Add boost program options into playuver code in order to increase cross platform compatibility
This commit is contained in:
1 parent
a52012a762
commit
9c45d6fe29
33 files changed
+5877
-11
No files matched your search
+4
-5
@@ -84,7 +84,7 @@ SET( CMAKE_CXX_FLAGS "" )
|
||||
|
||||
FIND_PACKAGE(Boost COMPONENTS program_options )
|
||||
SET_PACKAGE_PROPERTIES(Boost PROPERTIES URL "http://www.boost.org" DESCRIPTION "Boost library support" TYPE OPTIONAL)
|
||||
SET(USE_BOOST ${Boost_FOUND})
|
||||
|
||||
|
||||
OPTION( USE_OPENCV "Add OpenCV support" ON )
|
||||
IF( USE_OPENCV )
|
||||
@@ -103,6 +103,7 @@ SET_PACKAGE_PROPERTIES(FFmpeg PROPERTIES URL "http://ffmpeg.org/" DESCRIPTION "L
|
||||
ADD_FEATURE_INFO(SSE USE_SSE "SSE instructions support" )
|
||||
ADD_FEATURE_INFO(WErrors USE_WERROR "Warnings as errors" )
|
||||
|
||||
|
||||
IF( WIN32 )
|
||||
INCLUDE( cmake/Win32.cmake )
|
||||
ENDIF()
|
||||
@@ -131,10 +132,8 @@ ADD_FEATURE_INFO(PlaYUVerTools PLAYUVER_BUILD_APP "Build Command line too
|
||||
ADD_SUBDIRECTORY( lib )
|
||||
ADD_SUBDIRECTORY( modules )
|
||||
|
||||
IF( ${USE_BOOST} )
|
||||
IF( ${PLAYUVER_BUILD_TOOLS} )
|
||||
ADD_SUBDIRECTORY( tools )
|
||||
ENDIF()
|
||||
IF( ${PLAYUVER_BUILD_TOOLS} )
|
||||
ADD_SUBDIRECTORY( tools )
|
||||
ENDIF()
|
||||
|
||||
IF( ${PLAYUVER_BUILD_APP} )
|
||||
|
||||
+9
-6
@@ -4,7 +4,13 @@
|
||||
|
||||
INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR}/../ )
|
||||
|
||||
INCLUDE_DIRECTORIES( ${Boost_INCLUDE_DIRS} )
|
||||
#
|
||||
# Add boost support
|
||||
#
|
||||
IF( NOT ${Boost_FOUND} )
|
||||
MESSAGE("Using internal boost program options lib")
|
||||
ADD_SUBDIRECTORY( ${CMAKE_CURRENT_SOURCE_DIR}/external/boost_program_options )
|
||||
ENDIF()
|
||||
|
||||
set(plaYUver_Lib_SRCS
|
||||
# Frame
|
||||
@@ -13,13 +19,10 @@ set(plaYUver_Lib_SRCS
|
||||
PlaYUVerFrameStats.cpp
|
||||
# Stream
|
||||
PlaYUVerStream.cpp
|
||||
# Command Line Parser
|
||||
PlaYUVerCmdParser.cpp
|
||||
)
|
||||
|
||||
IF( USE_BOOST )
|
||||
# Command Line Parser
|
||||
LIST( APPEND plaYUver_Lib_SRCS PlaYUVerCmdParser.cpp )
|
||||
ENDIF()
|
||||
|
||||
IF( USE_FFMPEG )
|
||||
LIST( APPEND plaYUver_Lib_SRCS LibAvContextHandle.cpp )
|
||||
ENDIF()
|
||||
|
||||
@@ -0,0 +1,29 @@
|
||||
###
|
||||
### CMakeLists for playuver external component
|
||||
###
|
||||
|
||||
|
||||
#
|
||||
# Boost Library
|
||||
#
|
||||
|
||||
INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR}/include )
|
||||
|
||||
set(BoostProgramOptions_SRCS
|
||||
src/cmdline.cpp
|
||||
src/config_file.cpp
|
||||
src/options_description.cpp
|
||||
src/parsers.cpp
|
||||
src/variables_map.cpp
|
||||
src/value_semantic.cpp
|
||||
src/positional_options.cpp
|
||||
src/utf8_codecvt_facet.cpp
|
||||
src/convert.cpp
|
||||
src/winmain.cpp
|
||||
src/split.cpp
|
||||
)
|
||||
|
||||
ADD_LIBRARY( BoostProgramOptions STATIC ${BoostProgramOptions_SRCS} )
|
||||
|
||||
SET( Boost_FOUND TRUE PARENT_SCOPE)
|
||||
SET( Boost_LIBRARIES BoostProgramOptions PARENT_SCOPE)
|
||||
@@ -0,0 +1,25 @@
|
||||
// Copyright Vladimir Prus 2002.
|
||||
// Distributed under the Boost Software License, Version 1.0. (See
|
||||
// accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// See www.boost.org/libs/program_options for documentation.
|
||||
|
||||
#ifndef PROGRAM_OPTIONS_VP_2003_05_19
|
||||
#define PROGRAM_OPTIONS_VP_2003_05_19
|
||||
|
||||
#if defined(_MSC_VER)
|
||||
#pragma once
|
||||
#endif
|
||||
|
||||
#include <boost/program_options/options_description.hpp>
|
||||
#include <boost/program_options/positional_options.hpp>
|
||||
#include <boost/program_options/parsers.hpp>
|
||||
#include <boost/program_options/variables_map.hpp>
|
||||
#include <boost/program_options/cmdline.hpp>
|
||||
#include <boost/program_options/errors.hpp>
|
||||
#include <boost/program_options/option.hpp>
|
||||
#include <boost/program_options/value_semantic.hpp>
|
||||
#include <boost/program_options/version.hpp>
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,90 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_CMDLINE_HPP_VP_2004_03_13
|
||||
#define BOOST_CMDLINE_HPP_VP_2004_03_13
|
||||
|
||||
namespace boost { namespace program_options { namespace command_line_style {
|
||||
/** Various possible styles of options.
|
||||
|
||||
There are "long" options, which start with "--" and "short",
|
||||
which start with either "-" or "/". Both kinds can be allowed or
|
||||
disallowed, see allow_long and allow_short. The allowed character
|
||||
for short options is also configurable.
|
||||
|
||||
Option's value can be specified in the same token as name
|
||||
("--foo=bar"), or in the next token.
|
||||
|
||||
It's possible to introduce long options by the same character as
|
||||
short options, see allow_long_disguise.
|
||||
|
||||
Finally, guessing (specifying only prefix of option) and case
|
||||
insensitive processing are supported.
|
||||
*/
|
||||
enum style_t {
|
||||
/// Allow "--long_name" style
|
||||
allow_long = 1,
|
||||
/// Allow "-<single character" style
|
||||
allow_short = allow_long << 1,
|
||||
/// Allow "-" in short options
|
||||
allow_dash_for_short = allow_short << 1,
|
||||
/// Allow "/" in short options
|
||||
allow_slash_for_short = allow_dash_for_short << 1,
|
||||
/** Allow option parameter in the same token
|
||||
for long option, like in
|
||||
@verbatim
|
||||
--foo=10
|
||||
@endverbatim
|
||||
*/
|
||||
long_allow_adjacent = allow_slash_for_short << 1,
|
||||
/** Allow option parameter in the next token for
|
||||
long options. */
|
||||
long_allow_next = long_allow_adjacent << 1,
|
||||
/** Allow option parameter in the same token for
|
||||
short options. */
|
||||
short_allow_adjacent = long_allow_next << 1,
|
||||
/** Allow option parameter in the next token for
|
||||
short options. */
|
||||
short_allow_next = short_allow_adjacent << 1,
|
||||
/** Allow to merge several short options together,
|
||||
so that "-s -k" become "-sk". All of the options
|
||||
but last should accept no parameter. For example, if
|
||||
"-s" accept a parameter, then "k" will be taken as
|
||||
parameter, not another short option.
|
||||
Dos-style short options cannot be sticky.
|
||||
*/
|
||||
allow_sticky = short_allow_next << 1,
|
||||
/** Allow abbreviated spellings for long options,
|
||||
if they unambiguously identify long option.
|
||||
No long option name should be prefix of other
|
||||
long option name if guessing is in effect.
|
||||
*/
|
||||
allow_guessing = allow_sticky << 1,
|
||||
/** Ignore the difference in case for long options.
|
||||
*/
|
||||
long_case_insensitive = allow_guessing << 1,
|
||||
/** Ignore the difference in case for short options.
|
||||
*/
|
||||
short_case_insensitive = long_case_insensitive << 1,
|
||||
/** Ignore the difference in case for all options.
|
||||
*/
|
||||
case_insensitive = (long_case_insensitive | short_case_insensitive),
|
||||
/** Allow long options with single option starting character,
|
||||
e.g <tt>-foo=10</tt>
|
||||
*/
|
||||
allow_long_disguise = short_case_insensitive << 1,
|
||||
/** The more-or-less traditional unix style. */
|
||||
unix_style = (allow_short | short_allow_adjacent | short_allow_next
|
||||
| allow_long | long_allow_adjacent | long_allow_next
|
||||
| allow_sticky | allow_guessing
|
||||
| allow_dash_for_short),
|
||||
/** The default style. */
|
||||
default_style = unix_style
|
||||
};
|
||||
}}}
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,52 @@
|
||||
// Copyright (c) 2004 Hartmut Kaiser
|
||||
//
|
||||
// Use, modification and distribution is subject to the Boost Software
|
||||
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_PROGRAM_OPTIONS_CONFIG_HK_2004_01_11
|
||||
#define BOOST_PROGRAM_OPTIONS_CONFIG_HK_2004_01_11
|
||||
|
||||
#include <boost/config.hpp>
|
||||
#include <boost/version.hpp>
|
||||
|
||||
// Support for autolinking.
|
||||
#if BOOST_VERSION >= 103100 // works beginning from Boost V1.31.0
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
// enable automatic library variant selection
|
||||
#if !defined(BOOST_PROGRAM_OPTIONS_SOURCE) && !defined(BOOST_ALL_NO_LIB) && \
|
||||
!defined(BOOST_PROGRAM_OPTIONS_NO_LIB)
|
||||
|
||||
// Set the name of our library, this will get undef'ed by auto_link.hpp
|
||||
// once it's done with it:
|
||||
#define BOOST_LIB_NAME boost_program_options
|
||||
// tell the auto-link code to select a dll when required:
|
||||
#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_PROGRAM_OPTIONS_DYN_LINK)
|
||||
# define BOOST_DYN_LINK
|
||||
#endif
|
||||
|
||||
// And include the header that does the work:
|
||||
#include <boost/config/auto_link.hpp>
|
||||
|
||||
#endif // auto-linking disabled
|
||||
|
||||
#endif // BOOST_VERSION
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_PROGRAM_OPTIONS_DYN_LINK)
|
||||
// export if this is our own source, otherwise import:
|
||||
#ifdef BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
# define BOOST_PROGRAM_OPTIONS_DECL BOOST_SYMBOL_EXPORT
|
||||
#else
|
||||
# define BOOST_PROGRAM_OPTIONS_DECL BOOST_SYMBOL_IMPORT
|
||||
#endif // BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
#endif // DYN_LINK
|
||||
|
||||
#ifndef BOOST_PROGRAM_OPTIONS_DECL
|
||||
#define BOOST_PROGRAM_OPTIONS_DECL
|
||||
#endif
|
||||
|
||||
|
||||
#endif // PROGRAM_OPTIONS_CONFIG_HK_2004_01_11
|
||||
|
||||
+159
@@ -0,0 +1,159 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#ifndef BOOST_CMDLINE_VP_2003_05_19
|
||||
#define BOOST_CMDLINE_VP_2003_05_19
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/errors.hpp>
|
||||
#include <boost/program_options/cmdline.hpp>
|
||||
#include <boost/program_options/option.hpp>
|
||||
#include <boost/program_options/options_description.hpp>
|
||||
#include <boost/program_options/positional_options.hpp>
|
||||
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <boost/function.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning (push)
|
||||
# pragma warning (disable:4251) // class 'std::vector<_Ty>' needs to have dll-interface to be used by clients of class 'boost::program_options::positional_options_description'
|
||||
#endif
|
||||
|
||||
namespace boost { namespace program_options { namespace detail {
|
||||
|
||||
/** Command line parser class. Main requirements were:
|
||||
- Powerful enough to support all common uses.
|
||||
- Simple and easy to learn/use.
|
||||
- Minimal code size and external dependencies.
|
||||
- Extensible for custom syntaxes.
|
||||
|
||||
First all options are registered. After that, elements of command line
|
||||
are extracted using operator++.
|
||||
|
||||
For each element, user can find
|
||||
- if it's an option or an argument
|
||||
- name of the option
|
||||
- index of the option
|
||||
- option value(s), if any
|
||||
|
||||
Sometimes the registered option name is not equal to the encountered
|
||||
one, for example, because name abbreviation is supported. Therefore
|
||||
two option names can be obtained:
|
||||
- the registered one
|
||||
- the one found at the command line
|
||||
|
||||
There are lot of style options, which can be used to tune the command
|
||||
line parsing. In addition, it's possible to install additional parser
|
||||
which will process custom option styles.
|
||||
|
||||
@todo mininal match length for guessing?
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL cmdline {
|
||||
public:
|
||||
|
||||
typedef ::boost::program_options::command_line_style::style_t style_t;
|
||||
|
||||
typedef function1<std::pair<std::string, std::string>,
|
||||
const std::string&>
|
||||
additional_parser;
|
||||
|
||||
typedef function1<std::vector<option>, std::vector<std::string>&>
|
||||
style_parser;
|
||||
|
||||
/** Constructs a command line parser for (argc, argv) pair. Uses
|
||||
style options passed in 'style', which should be binary or'ed values
|
||||
of style_t enum. It can also be zero, in which case a "default"
|
||||
style will be used. If 'allow_unregistered' is true, then allows
|
||||
unregistered options. They will be assigned index 1 and are
|
||||
assumed to have optional parameter.
|
||||
*/
|
||||
cmdline(const std::vector<std::string>& args);
|
||||
|
||||
/** @overload */
|
||||
cmdline(int argc, const char*const * argv);
|
||||
|
||||
void style(int style);
|
||||
|
||||
/** returns the canonical option prefix associated with the command_line_style
|
||||
* In order of precedence:
|
||||
* allow_long : allow_long
|
||||
* allow_long_disguise : allow_long_disguise
|
||||
* allow_dash_for_short : allow_short | allow_dash_for_short
|
||||
* allow_slash_for_short: allow_short | allow_slash_for_short
|
||||
*
|
||||
* This is mainly used for the diagnostic messages in exceptions
|
||||
*/
|
||||
int get_canonical_option_prefix();
|
||||
|
||||
void allow_unregistered();
|
||||
|
||||
void set_options_description(const options_description& desc);
|
||||
void set_positional_options(
|
||||
const positional_options_description& m_positional);
|
||||
|
||||
std::vector<option> run();
|
||||
|
||||
std::vector<option> parse_long_option(std::vector<std::string>& args);
|
||||
std::vector<option> parse_short_option(std::vector<std::string>& args);
|
||||
std::vector<option> parse_dos_option(std::vector<std::string>& args);
|
||||
std::vector<option> parse_disguised_long_option(
|
||||
std::vector<std::string>& args);
|
||||
std::vector<option> parse_terminator(
|
||||
std::vector<std::string>& args);
|
||||
std::vector<option> handle_additional_parser(
|
||||
std::vector<std::string>& args);
|
||||
|
||||
|
||||
/** Set additional parser. This will be called for each token
|
||||
of command line. If first string in pair is not empty,
|
||||
then the token is considered matched by this parser,
|
||||
and the first string will be considered an option name
|
||||
(which can be long or short), while the second will be
|
||||
option's parameter (if not empty).
|
||||
Note that additional parser can match only one token.
|
||||
*/
|
||||
void set_additional_parser(additional_parser p);
|
||||
|
||||
void extra_style_parser(style_parser s);
|
||||
|
||||
void check_style(int style) const;
|
||||
|
||||
bool is_style_active(style_t style) const;
|
||||
|
||||
void init(const std::vector<std::string>& args);
|
||||
|
||||
void
|
||||
finish_option(option& opt,
|
||||
std::vector<std::string>& other_tokens,
|
||||
const std::vector<style_parser>& style_parsers);
|
||||
|
||||
// Copies of input.
|
||||
std::vector<std::string> args;
|
||||
style_t m_style;
|
||||
bool m_allow_unregistered;
|
||||
|
||||
const options_description* m_desc;
|
||||
const positional_options_description* m_positional;
|
||||
|
||||
additional_parser m_additional_parser;
|
||||
style_parser m_style_parser;
|
||||
};
|
||||
|
||||
void test_cmdline_detail();
|
||||
|
||||
}}}
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning (pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
+180
@@ -0,0 +1,180 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#ifndef BOOST_CONFIG_FILE_VP_2003_01_02
|
||||
#define BOOST_CONFIG_FILE_VP_2003_01_02
|
||||
|
||||
#include <iosfwd>
|
||||
#include <string>
|
||||
#include <set>
|
||||
|
||||
#include <boost/noncopyable.hpp>
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/option.hpp>
|
||||
#include <boost/program_options/eof_iterator.hpp>
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/program_options/detail/convert.hpp>
|
||||
|
||||
#if BOOST_WORKAROUND(__DECCXX_VER, BOOST_TESTED_AT(60590042))
|
||||
#include <istream> // std::getline
|
||||
#endif
|
||||
|
||||
#include <boost/static_assert.hpp>
|
||||
#include <boost/type_traits/is_same.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
|
||||
|
||||
|
||||
namespace boost { namespace program_options { namespace detail {
|
||||
|
||||
/** Standalone parser for config files in ini-line format.
|
||||
The parser is a model of single-pass lvalue iterator, and
|
||||
default constructor creates past-the-end-iterator. The typical usage is:
|
||||
config_file_iterator i(is, ... set of options ...), e;
|
||||
for(; i !=e; ++i) {
|
||||
*i;
|
||||
}
|
||||
|
||||
Syntax conventions:
|
||||
|
||||
- config file can not contain positional options
|
||||
- '#' is comment character: it is ignored together with
|
||||
the rest of the line.
|
||||
- variable assignments are in the form
|
||||
name '=' value.
|
||||
spaces around '=' are trimmed.
|
||||
- Section names are given in brackets.
|
||||
|
||||
The actual option name is constructed by combining current section
|
||||
name and specified option name, with dot between. If section_name
|
||||
already contains dot at the end, new dot is not inserted. For example:
|
||||
@verbatim
|
||||
[gui.accessibility]
|
||||
visual_bell=yes
|
||||
@endverbatim
|
||||
will result in option "gui.accessibility.visual_bell" with value
|
||||
"yes" been returned.
|
||||
|
||||
TODO: maybe, we should just accept a pointer to options_description
|
||||
class.
|
||||
*/
|
||||
class common_config_file_iterator
|
||||
: public eof_iterator<common_config_file_iterator, option>
|
||||
{
|
||||
public:
|
||||
common_config_file_iterator() { found_eof(); }
|
||||
common_config_file_iterator(
|
||||
const std::set<std::string>& allowed_options,
|
||||
bool allow_unregistered = false);
|
||||
|
||||
virtual ~common_config_file_iterator() {}
|
||||
|
||||
public: // Method required by eof_iterator
|
||||
|
||||
void get();
|
||||
|
||||
protected: // Stubs for derived classes
|
||||
|
||||
// Obtains next line from the config file
|
||||
// Note: really, this design is a bit ugly
|
||||
// The most clean thing would be to pass 'line_iterator' to
|
||||
// constructor of this class, but to avoid templating this class
|
||||
// we'd need polymorphic iterator, which does not exist yet.
|
||||
virtual bool getline(std::string&) { return false; }
|
||||
|
||||
private:
|
||||
/** Adds another allowed option. If the 'name' ends with
|
||||
'*', then all options with the same prefix are
|
||||
allowed. For example, if 'name' is 'foo*', then 'foo1' and
|
||||
'foo_bar' are allowed. */
|
||||
void add_option(const char* name);
|
||||
|
||||
// Returns true if 's' is a registered option name.
|
||||
bool allowed_option(const std::string& s) const;
|
||||
|
||||
// That's probably too much data for iterator, since
|
||||
// it will be copied, but let's not bother for now.
|
||||
std::set<std::string> allowed_options;
|
||||
// Invariant: no element is prefix of other element.
|
||||
std::set<std::string> allowed_prefixes;
|
||||
std::string m_prefix;
|
||||
bool m_allow_unregistered;
|
||||
};
|
||||
|
||||
template<class charT>
|
||||
class basic_config_file_iterator : public common_config_file_iterator {
|
||||
public:
|
||||
basic_config_file_iterator()
|
||||
{
|
||||
found_eof();
|
||||
}
|
||||
|
||||
/** Creates a config file parser for the specified stream.
|
||||
*/
|
||||
basic_config_file_iterator(std::basic_istream<charT>& is,
|
||||
const std::set<std::string>& allowed_options,
|
||||
bool allow_unregistered = false);
|
||||
|
||||
private: // base overrides
|
||||
|
||||
bool getline(std::string&);
|
||||
|
||||
private: // internal data
|
||||
shared_ptr<std::basic_istream<charT> > is;
|
||||
};
|
||||
|
||||
typedef basic_config_file_iterator<char> config_file_iterator;
|
||||
typedef basic_config_file_iterator<wchar_t> wconfig_file_iterator;
|
||||
|
||||
|
||||
struct null_deleter
|
||||
{
|
||||
void operator()(void const *) const {}
|
||||
};
|
||||
|
||||
|
||||
template<class charT>
|
||||
basic_config_file_iterator<charT>::
|
||||
basic_config_file_iterator(std::basic_istream<charT>& is,
|
||||
const std::set<std::string>& allowed_options,
|
||||
bool allow_unregistered)
|
||||
: common_config_file_iterator(allowed_options, allow_unregistered)
|
||||
{
|
||||
this->is.reset(&is, null_deleter());
|
||||
get();
|
||||
}
|
||||
|
||||
// Specializing this function for wchar_t causes problems on
|
||||
// borland and vc7, as well as on metrowerks. On the first two
|
||||
// I don't know a workaround, so make use of 'to_internal' to
|
||||
// avoid specialization.
|
||||
template<class charT>
|
||||
bool
|
||||
basic_config_file_iterator<charT>::getline(std::string& s)
|
||||
{
|
||||
std::basic_string<charT> in;
|
||||
if (std::getline(*is, in)) {
|
||||
s = to_internal(in);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Specialization is needed to workaround getline bug on Comeau.
|
||||
#if BOOST_WORKAROUND(__COMO_VERSION__, BOOST_TESTED_AT(4303)) || \
|
||||
(defined(__sgi) && BOOST_WORKAROUND(_COMPILER_VERSION, BOOST_TESTED_AT(741)))
|
||||
template<>
|
||||
bool
|
||||
basic_config_file_iterator<wchar_t>::getline(std::string& s);
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
}}}
|
||||
|
||||
#endif
|
||||
+107
@@ -0,0 +1,107 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_CONVERT_HPP_VP_2004_04_28
|
||||
#define BOOST_CONVERT_HPP_VP_2004_04_28
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#if !defined(BOOST_NO_STD_WSTRING)
|
||||
|
||||
#include <boost/detail/workaround.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <locale>
|
||||
// for mbstate_t
|
||||
#include <cwchar>
|
||||
#include <stdexcept>
|
||||
|
||||
#if defined(BOOST_NO_STDC_NAMESPACE)
|
||||
#include <wchar.h>
|
||||
namespace std
|
||||
{
|
||||
using ::mbstate_t;
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
|
||||
/** Converts from local 8 bit encoding into wchar_t string using
|
||||
the specified locale facet. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::wstring
|
||||
from_8_bit(const std::string& s,
|
||||
const std::codecvt<wchar_t, char, std::mbstate_t>& cvt);
|
||||
|
||||
/** Converts from wchar_t string into local 8 bit encoding into using
|
||||
the specified locale facet. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string
|
||||
to_8_bit(const std::wstring& s,
|
||||
const std::codecvt<wchar_t, char, std::mbstate_t>& cvt);
|
||||
|
||||
|
||||
/** Converts 's', which is assumed to be in UTF8 encoding, into wide
|
||||
string. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::wstring
|
||||
from_utf8(const std::string& s);
|
||||
|
||||
/** Converts wide string 's' into string in UTF8 encoding. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string
|
||||
to_utf8(const std::wstring& s);
|
||||
|
||||
/** Converts wide string 's' into local 8 bit encoding determined by
|
||||
the current locale. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string
|
||||
to_local_8_bit(const std::wstring& s);
|
||||
|
||||
/** Converts 's', which is assumed to be in local 8 bit encoding, into wide
|
||||
string. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::wstring
|
||||
from_local_8_bit(const std::string& s);
|
||||
|
||||
namespace program_options
|
||||
{
|
||||
/** Convert the input string into internal encoding used by
|
||||
program_options. Presence of this function allows to avoid
|
||||
specializing all methods which access input on wchar_t.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string to_internal(const std::string&);
|
||||
/** @overload */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string to_internal(const std::wstring&);
|
||||
|
||||
template<class T>
|
||||
std::vector<std::string> to_internal(const std::vector<T>& s)
|
||||
{
|
||||
std::vector<std::string> result;
|
||||
for (unsigned i = 0; i < s.size(); ++i)
|
||||
result.push_back(to_internal(s[i]));
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
#else
|
||||
#include <vector>
|
||||
#include <string>
|
||||
namespace boost{
|
||||
namespace program_options{
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string to_internal(const std::string&);
|
||||
|
||||
template<class T>
|
||||
std::vector<std::string> to_internal(const std::vector<T>& s)
|
||||
{
|
||||
std::vector<std::string> result;
|
||||
for (unsigned i = 0; i < s.size(); ++i)
|
||||
result.push_back(to_internal(s[i]));
|
||||
return result;
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
+150
@@ -0,0 +1,150 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_PARSERS_HPP_VP_2004_05_06
|
||||
#define BOOST_PARSERS_HPP_VP_2004_05_06
|
||||
|
||||
#include <boost/program_options/detail/convert.hpp>
|
||||
|
||||
#include <iterator>
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
namespace detail {
|
||||
template<class charT, class Iterator>
|
||||
std::vector<std::basic_string<charT> >
|
||||
make_vector(Iterator i, Iterator e)
|
||||
{
|
||||
std::vector<std::basic_string<charT> > result;
|
||||
// Some compilers don't have templated constructor for
|
||||
// vector, so we can't create vector from (argv+1, argv+argc) range
|
||||
for(; i != e; ++i)
|
||||
result.push_back(*i);
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
template<class charT>
|
||||
basic_command_line_parser<charT>::
|
||||
basic_command_line_parser(const std::vector<
|
||||
std::basic_string<charT> >& xargs)
|
||||
: detail::cmdline(to_internal(xargs))
|
||||
{}
|
||||
|
||||
|
||||
template<class charT>
|
||||
basic_command_line_parser<charT>::
|
||||
basic_command_line_parser(int argc, const charT* const argv[])
|
||||
: detail::cmdline(
|
||||
// Explicit template arguments are required by gcc 3.3.1
|
||||
// (at least mingw version), and do no harm on other compilers.
|
||||
to_internal(detail::make_vector<charT, const charT* const*>(argv+1, argv+argc+!argc)))
|
||||
{}
|
||||
|
||||
|
||||
template<class charT>
|
||||
basic_command_line_parser<charT>&
|
||||
basic_command_line_parser<charT>::options(const options_description& desc)
|
||||
{
|
||||
detail::cmdline::set_options_description(desc);
|
||||
m_desc = &desc;
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class charT>
|
||||
basic_command_line_parser<charT>&
|
||||
basic_command_line_parser<charT>::positional(
|
||||
const positional_options_description& desc)
|
||||
{
|
||||
detail::cmdline::set_positional_options(desc);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class charT>
|
||||
basic_command_line_parser<charT>&
|
||||
basic_command_line_parser<charT>::style(int xstyle)
|
||||
{
|
||||
detail::cmdline::style(xstyle);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class charT>
|
||||
basic_command_line_parser<charT>&
|
||||
basic_command_line_parser<charT>::extra_parser(ext_parser ext)
|
||||
{
|
||||
detail::cmdline::set_additional_parser(ext);
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class charT>
|
||||
basic_command_line_parser<charT>&
|
||||
basic_command_line_parser<charT>::allow_unregistered()
|
||||
{
|
||||
detail::cmdline::allow_unregistered();
|
||||
return *this;
|
||||
}
|
||||
|
||||
template<class charT>
|
||||
basic_command_line_parser<charT>&
|
||||
basic_command_line_parser<charT>::extra_style_parser(style_parser s)
|
||||
{
|
||||
detail::cmdline::extra_style_parser(s);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
||||
|
||||
template<class charT>
|
||||
basic_parsed_options<charT>
|
||||
basic_command_line_parser<charT>::run()
|
||||
{
|
||||
// save the canonical prefixes which were used by this cmdline parser
|
||||
// eventually inside the parsed results
|
||||
// This will be handy to format recognisable options
|
||||
// for diagnostic messages if everything blows up much later on
|
||||
parsed_options result(m_desc, detail::cmdline::get_canonical_option_prefix());
|
||||
result.options = detail::cmdline::run();
|
||||
|
||||
// Presense of parsed_options -> wparsed_options conversion
|
||||
// does the trick.
|
||||
return basic_parsed_options<charT>(result);
|
||||
}
|
||||
|
||||
|
||||
template<class charT>
|
||||
basic_parsed_options<charT>
|
||||
parse_command_line(int argc, const charT* const argv[],
|
||||
const options_description& desc,
|
||||
int style,
|
||||
function1<std::pair<std::string, std::string>,
|
||||
const std::string&> ext)
|
||||
{
|
||||
return basic_command_line_parser<charT>(argc, argv).options(desc).
|
||||
style(style).extra_parser(ext).run();
|
||||
}
|
||||
|
||||
template<class charT>
|
||||
std::vector< std::basic_string<charT> >
|
||||
collect_unrecognized(const std::vector< basic_option<charT> >& options,
|
||||
enum collect_unrecognized_mode mode)
|
||||
{
|
||||
std::vector< std::basic_string<charT> > result;
|
||||
for(unsigned i = 0; i < options.size(); ++i)
|
||||
{
|
||||
if (options[i].unregistered ||
|
||||
(mode == include_positional && options[i].position_key != -1))
|
||||
{
|
||||
copy(options[i].original_tokens.begin(),
|
||||
options[i].original_tokens.end(),
|
||||
back_inserter(result));
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
Vendored
+25
@@ -0,0 +1,25 @@
|
||||
// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
|
||||
// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu). Permission to copy,
|
||||
// use, modify, sell and distribute this software is granted provided this
|
||||
// copyright notice appears in all copies. This software is provided "as is"
|
||||
// without express or implied warranty, and with no claim as to its suitability
|
||||
// for any purpose.
|
||||
|
||||
#ifndef BOOST_PROGRAM_OPTIONS_UTF8_CODECVT_FACET_HPP
|
||||
#define BOOST_PROGRAM_OPTIONS_UTF8_CODECVT_FACET_HPP
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#define BOOST_UTF8_BEGIN_NAMESPACE \
|
||||
namespace boost { namespace program_options { namespace detail {
|
||||
|
||||
#define BOOST_UTF8_END_NAMESPACE }}}
|
||||
#define BOOST_UTF8_DECL BOOST_PROGRAM_OPTIONS_DECL
|
||||
|
||||
#include <boost/detail/utf8_codecvt_facet.hpp>
|
||||
|
||||
#undef BOOST_UTF8_BEGIN_NAMESPACE
|
||||
#undef BOOST_UTF8_END_NAMESPACE
|
||||
#undef BOOST_UTF8_DECL
|
||||
|
||||
#endif
|
||||
+205
@@ -0,0 +1,205 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
// This file defines template functions that are declared in
|
||||
// ../value_semantic.hpp.
|
||||
|
||||
#include <boost/throw_exception.hpp>
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
extern BOOST_PROGRAM_OPTIONS_DECL std::string arg;
|
||||
|
||||
template<class T, class charT>
|
||||
std::string
|
||||
typed_value<T, charT>::name() const
|
||||
{
|
||||
std::string const& var = (m_value_name.empty() ? arg : m_value_name);
|
||||
if (!m_implicit_value.empty() && !m_implicit_value_as_text.empty()) {
|
||||
std::string msg = "[=" + var + "(=" + m_implicit_value_as_text + ")]";
|
||||
if (!m_default_value.empty() && !m_default_value_as_text.empty())
|
||||
msg += " (=" + m_default_value_as_text + ")";
|
||||
return msg;
|
||||
}
|
||||
else if (!m_default_value.empty() && !m_default_value_as_text.empty()) {
|
||||
return var + " (=" + m_default_value_as_text + ")";
|
||||
} else {
|
||||
return var;
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class charT>
|
||||
void
|
||||
typed_value<T, charT>::notify(const boost::any& value_store) const
|
||||
{
|
||||
const T* value = boost::any_cast<T>(&value_store);
|
||||
if (m_store_to) {
|
||||
*m_store_to = *value;
|
||||
}
|
||||
if (m_notifier) {
|
||||
m_notifier(*value);
|
||||
}
|
||||
}
|
||||
|
||||
namespace validators {
|
||||
/* If v.size() > 1, throw validation_error.
|
||||
If v.size() == 1, return v.front()
|
||||
Otherwise, returns a reference to a statically allocated
|
||||
empty string if 'allow_empty' and throws validation_error
|
||||
otherwise. */
|
||||
template<class charT>
|
||||
const std::basic_string<charT>& get_single_string(
|
||||
const std::vector<std::basic_string<charT> >& v,
|
||||
bool allow_empty = false)
|
||||
{
|
||||
static std::basic_string<charT> empty;
|
||||
if (v.size() > 1)
|
||||
boost::throw_exception(validation_error(validation_error::multiple_values_not_allowed));
|
||||
else if (v.size() == 1)
|
||||
return v.front();
|
||||
else if (!allow_empty)
|
||||
boost::throw_exception(validation_error(validation_error::at_least_one_value_required));
|
||||
return empty;
|
||||
}
|
||||
|
||||
/* Throws multiple_occurrences if 'value' is not empty. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL void
|
||||
check_first_occurrence(const boost::any& value);
|
||||
}
|
||||
|
||||
using namespace validators;
|
||||
|
||||
/** Validates 's' and updates 'v'.
|
||||
@pre 'v' is either empty or in the state assigned by the previous
|
||||
invocation of 'validate'.
|
||||
The target type is specified via a parameter which has the type of
|
||||
pointer to the desired type. This is workaround for compilers without
|
||||
partial template ordering, just like the last 'long/int' parameter.
|
||||
*/
|
||||
template<class T, class charT>
|
||||
void validate(boost::any& v,
|
||||
const std::vector< std::basic_string<charT> >& xs,
|
||||
T*, long)
|
||||
{
|
||||
validators::check_first_occurrence(v);
|
||||
std::basic_string<charT> s(validators::get_single_string(xs));
|
||||
try {
|
||||
v = any(lexical_cast<T>(s));
|
||||
}
|
||||
catch(const bad_lexical_cast&) {
|
||||
boost::throw_exception(invalid_option_value(s));
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL void validate(boost::any& v,
|
||||
const std::vector<std::string>& xs,
|
||||
bool*,
|
||||
int);
|
||||
|
||||
#if !defined(BOOST_NO_STD_WSTRING)
|
||||
BOOST_PROGRAM_OPTIONS_DECL void validate(boost::any& v,
|
||||
const std::vector<std::wstring>& xs,
|
||||
bool*,
|
||||
int);
|
||||
#endif
|
||||
// For some reason, this declaration, which is require by the standard,
|
||||
// cause msvc 7.1 to not generate code to specialization defined in
|
||||
// value_semantic.cpp
|
||||
#if ! ( BOOST_WORKAROUND(BOOST_MSVC, == 1310) )
|
||||
BOOST_PROGRAM_OPTIONS_DECL void validate(boost::any& v,
|
||||
const std::vector<std::string>& xs,
|
||||
std::string*,
|
||||
int);
|
||||
|
||||
#if !defined(BOOST_NO_STD_WSTRING)
|
||||
BOOST_PROGRAM_OPTIONS_DECL void validate(boost::any& v,
|
||||
const std::vector<std::wstring>& xs,
|
||||
std::string*,
|
||||
int);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/** Validates sequences. Allows multiple values per option occurrence
|
||||
and multiple occurrences. */
|
||||
template<class T, class charT>
|
||||
void validate(boost::any& v,
|
||||
const std::vector<std::basic_string<charT> >& s,
|
||||
std::vector<T>*,
|
||||
int)
|
||||
{
|
||||
if (v.empty()) {
|
||||
v = boost::any(std::vector<T>());
|
||||
}
|
||||
std::vector<T>* tv = boost::any_cast< std::vector<T> >(&v);
|
||||
assert(NULL != tv);
|
||||
for (unsigned i = 0; i < s.size(); ++i)
|
||||
{
|
||||
try {
|
||||
/* We call validate so that if user provided
|
||||
a validator for class T, we use it even
|
||||
when parsing vector<T>. */
|
||||
boost::any a;
|
||||
std::vector<std::basic_string<charT> > cv;
|
||||
cv.push_back(s[i]);
|
||||
validate(a, cv, (T*)0, 0);
|
||||
tv->push_back(boost::any_cast<T>(a));
|
||||
}
|
||||
catch(const bad_lexical_cast& /*e*/) {
|
||||
boost::throw_exception(invalid_option_value(s[i]));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template<class T, class charT>
|
||||
void
|
||||
typed_value<T, charT>::
|
||||
xparse(boost::any& value_store,
|
||||
const std::vector<std::basic_string<charT> >& new_tokens) const
|
||||
{
|
||||
// If no tokens were given, and the option accepts an implicit
|
||||
// value, then assign the implicit value as the stored value;
|
||||
// otherwise, validate the user-provided token(s).
|
||||
if (new_tokens.empty() && !m_implicit_value.empty())
|
||||
value_store = m_implicit_value;
|
||||
else
|
||||
validate(value_store, new_tokens, (T*)0, 0);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
typed_value<T>*
|
||||
value()
|
||||
{
|
||||
// Explicit qualification is vc6 workaround.
|
||||
return boost::program_options::value<T>(0);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
typed_value<T>*
|
||||
value(T* v)
|
||||
{
|
||||
typed_value<T>* r = new typed_value<T>(v);
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
typed_value<T, wchar_t>*
|
||||
wvalue()
|
||||
{
|
||||
return wvalue<T>(0);
|
||||
}
|
||||
|
||||
template<class T>
|
||||
typed_value<T, wchar_t>*
|
||||
wvalue(T* v)
|
||||
{
|
||||
typed_value<T, wchar_t>* r = new typed_value<T, wchar_t>(v);
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
|
||||
}}
|
||||
+51
@@ -0,0 +1,51 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_ENVIRONMENT_ITERATOR_VP_2004_05_14
|
||||
#define BOOST_ENVIRONMENT_ITERATOR_VP_2004_05_14
|
||||
|
||||
#include "eof_iterator.hpp"
|
||||
|
||||
#include <utility>
|
||||
#include <string>
|
||||
#include <cassert>
|
||||
|
||||
namespace boost {
|
||||
|
||||
class environment_iterator
|
||||
: public eof_iterator<environment_iterator,
|
||||
std::pair<std::string, std::string> >
|
||||
{
|
||||
public:
|
||||
environment_iterator(char** environment)
|
||||
: m_environment(environment)
|
||||
{
|
||||
get();
|
||||
}
|
||||
|
||||
environment_iterator()
|
||||
{
|
||||
found_eof();
|
||||
}
|
||||
|
||||
void get()
|
||||
{
|
||||
if (*m_environment == 0)
|
||||
found_eof();
|
||||
else {
|
||||
std::string s(*m_environment);
|
||||
std::string::size_type n = s.find('=');
|
||||
assert(n != s.npos);
|
||||
value().first = s.substr(0, n);
|
||||
value().second = s.substr(n+1);
|
||||
}
|
||||
++m_environment;
|
||||
}
|
||||
|
||||
private:
|
||||
char** m_environment;
|
||||
};
|
||||
}
|
||||
#endif
|
||||
+97
@@ -0,0 +1,97 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_EOF_ITERATOR_VP_2004_03_12
|
||||
#define BOOST_EOF_ITERATOR_VP_2004_03_12
|
||||
|
||||
#include <boost/iterator/iterator_facade.hpp>
|
||||
|
||||
namespace boost {
|
||||
|
||||
/** The 'eof_iterator' class is useful for constructing forward iterators
|
||||
in cases where iterator extract data from some source and it's easy
|
||||
to detect 'eof' -- i.e. the situation where there's no data. One
|
||||
apparent example is reading lines from a file.
|
||||
|
||||
Implementing such iterators using 'iterator_facade' directly would
|
||||
require to create class with three core operation, a couple of
|
||||
constructors. When using 'eof_iterator', the derived class should define
|
||||
only one method to get new value, plus a couple of constructors.
|
||||
|
||||
The basic idea is that iterator has 'eof' bit. Two iterators are equal
|
||||
only if both have their 'eof' bits set. The 'get' method either obtains
|
||||
the new value or sets the 'eof' bit.
|
||||
|
||||
Specifically, derived class should define:
|
||||
|
||||
1. A default constructor, which creates iterator with 'eof' bit set. The
|
||||
constructor body should call 'found_eof' method defined here.
|
||||
2. Some other constructor. It should initialize some 'data pointer' used
|
||||
in iterator operation and then call 'get'.
|
||||
3. The 'get' method. It should operate this way:
|
||||
- look at some 'data pointer' to see if new element is available;
|
||||
if not, it should call 'found_eof'.
|
||||
- extract new element and store it at location returned by the 'value'
|
||||
method.
|
||||
- advance the data pointer.
|
||||
|
||||
Essentially, the 'get' method has the functionality of both 'increment'
|
||||
and 'dereference'. It's very good for the cases where data extraction
|
||||
implicitly moves data pointer, like for stream operation.
|
||||
*/
|
||||
template<class Derived, class ValueType>
|
||||
class eof_iterator : public iterator_facade<Derived, const ValueType,
|
||||
forward_traversal_tag>
|
||||
{
|
||||
public:
|
||||
eof_iterator()
|
||||
: m_at_eof(false)
|
||||
{}
|
||||
|
||||
protected: // interface for derived
|
||||
|
||||
/** Returns the reference which should be used by derived
|
||||
class to store the next value. */
|
||||
ValueType& value()
|
||||
{
|
||||
return m_value;
|
||||
}
|
||||
|
||||
/** Should be called by derived class to indicate that it can't
|
||||
produce next element. */
|
||||
void found_eof()
|
||||
{
|
||||
m_at_eof = true;
|
||||
}
|
||||
|
||||
|
||||
private: // iterator core operations
|
||||
friend class iterator_core_access;
|
||||
|
||||
void increment()
|
||||
{
|
||||
static_cast<Derived&>(*this).get();
|
||||
}
|
||||
|
||||
bool equal(const eof_iterator& other) const
|
||||
{
|
||||
if (m_at_eof && other.m_at_eof)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
const ValueType& dereference() const
|
||||
{
|
||||
return m_value;
|
||||
}
|
||||
|
||||
bool m_at_eof;
|
||||
ValueType m_value;
|
||||
};
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,416 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#ifndef BOOST_ERRORS_VP_2003_01_02
|
||||
#define BOOST_ERRORS_VP_2003_01_02
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <stdexcept>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning (push)
|
||||
# pragma warning (disable:4275) // non dll-interface class 'std::logic_error' used as base for dll-interface class 'boost::program_options::error'
|
||||
# pragma warning (disable:4251) // class 'std::vector<_Ty>' needs to have dll-interface to be used by clients of class 'boost::program_options::ambiguous_option'
|
||||
#endif
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
inline std::string strip_prefixes(const std::string& text)
|
||||
{
|
||||
// "--foo-bar" -> "foo-bar"
|
||||
return text.substr(text.find_first_not_of("-/"));
|
||||
}
|
||||
|
||||
/** Base class for all errors in the library. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL error : public std::logic_error {
|
||||
public:
|
||||
error(const std::string& xwhat) : std::logic_error(xwhat) {}
|
||||
};
|
||||
|
||||
|
||||
/** Class thrown when there are too many positional options.
|
||||
This is a programming error.
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL too_many_positional_options_error : public error {
|
||||
public:
|
||||
too_many_positional_options_error()
|
||||
: error("too many positional options have been specified on the command line")
|
||||
{}
|
||||
};
|
||||
|
||||
/** Class thrown when there are programming error related to style */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL invalid_command_line_style : public error {
|
||||
public:
|
||||
invalid_command_line_style(const std::string& msg)
|
||||
: error(msg)
|
||||
{}
|
||||
};
|
||||
|
||||
/** Class thrown if config file can not be read */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL reading_file : public error {
|
||||
public:
|
||||
reading_file(const char* filename)
|
||||
: error(std::string("can not read options configuration file '").append(filename).append("'"))
|
||||
{}
|
||||
};
|
||||
|
||||
|
||||
/** Base class for most exceptions in the library.
|
||||
*
|
||||
* Substitutes the values for the parameter name
|
||||
* placeholders in the template to create the human
|
||||
* readable error message
|
||||
*
|
||||
* Placeholders are surrounded by % signs: %example%
|
||||
* Poor man's version of boost::format
|
||||
*
|
||||
* If a parameter name is absent, perform default substitutions
|
||||
* instead so ugly placeholders are never left in-place.
|
||||
*
|
||||
* Options are displayed in "canonical" form
|
||||
* This is the most unambiguous form of the
|
||||
* *parsed* option name and would correspond to
|
||||
* option_description::format_name()
|
||||
* i.e. what is shown by print_usage()
|
||||
*
|
||||
* The "canonical" form depends on whether the option is
|
||||
* specified in short or long form, using dashes or slashes
|
||||
* or without a prefix (from a configuration file)
|
||||
*
|
||||
* */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL error_with_option_name : public error {
|
||||
|
||||
protected:
|
||||
/** can be
|
||||
* 0 = no prefix (config file options)
|
||||
* allow_long
|
||||
* allow_dash_for_short
|
||||
* allow_slash_for_short
|
||||
* allow_long_disguise */
|
||||
int m_option_style;
|
||||
|
||||
|
||||
/** substitutions
|
||||
* from placeholders to values */
|
||||
std::map<std::string, std::string> m_substitutions;
|
||||
typedef std::pair<std::string, std::string> string_pair;
|
||||
std::map<std::string, string_pair > m_substitution_defaults;
|
||||
|
||||
public:
|
||||
/** template with placeholders */
|
||||
std::string m_error_template;
|
||||
|
||||
error_with_option_name(const std::string& template_,
|
||||
const std::string& option_name = "",
|
||||
const std::string& original_token = "",
|
||||
int option_style = 0);
|
||||
|
||||
/** gcc says that throw specification on dtor is loosened
|
||||
* without this line
|
||||
* */
|
||||
~error_with_option_name() throw() {}
|
||||
|
||||
|
||||
//void dump() const
|
||||
//{
|
||||
// std::cerr << "m_substitution_defaults:\n";
|
||||
// for (std::map<std::string, string_pair>::const_iterator iter = m_substitution_defaults.begin();
|
||||
// iter != m_substitution_defaults.end(); ++iter)
|
||||
// std::cerr << "\t" << iter->first << ":" << iter->second.first << "=" << iter->second.second << "\n";
|
||||
// std::cerr << "m_substitutions:\n";
|
||||
// for (std::map<std::string, std::string>::const_iterator iter = m_substitutions.begin();
|
||||
// iter != m_substitutions.end(); ++iter)
|
||||
// std::cerr << "\t" << iter->first << "=" << iter->second << "\n";
|
||||
// std::cerr << "m_error_template:\n";
|
||||
// std::cerr << "\t" << m_error_template << "\n";
|
||||
// std::cerr << "canonical_option_prefix:[" << get_canonical_option_prefix() << "]\n";
|
||||
// std::cerr << "canonical_option_name:[" << get_canonical_option_name() <<"]\n";
|
||||
// std::cerr << "what:[" << what() << "]\n";
|
||||
//}
|
||||
|
||||
/** Substitute
|
||||
* parameter_name->value to create the error message from
|
||||
* the error template */
|
||||
void set_substitute(const std::string& parameter_name, const std::string& value)
|
||||
{ m_substitutions[parameter_name] = value; }
|
||||
|
||||
/** If the parameter is missing, then make the
|
||||
* from->to substitution instead */
|
||||
void set_substitute_default(const std::string& parameter_name,
|
||||
const std::string& from,
|
||||
const std::string& to)
|
||||
{
|
||||
m_substitution_defaults[parameter_name] = std::make_pair(from, to);
|
||||
}
|
||||
|
||||
|
||||
/** Add context to an exception */
|
||||
void add_context(const std::string& option_name,
|
||||
const std::string& original_token,
|
||||
int option_style)
|
||||
{
|
||||
set_option_name(option_name);
|
||||
set_original_token(original_token);
|
||||
set_prefix(option_style);
|
||||
}
|
||||
|
||||
void set_prefix(int option_style)
|
||||
{ m_option_style = option_style;}
|
||||
|
||||
/** Overridden in error_with_no_option_name */
|
||||
virtual void set_option_name(const std::string& option_name)
|
||||
{ set_substitute("option", option_name);}
|
||||
|
||||
std::string get_option_name() const throw()
|
||||
{ return get_canonical_option_name(); }
|
||||
|
||||
void set_original_token(const std::string& original_token)
|
||||
{ set_substitute("original_token", original_token);}
|
||||
|
||||
|
||||
/** Creates the error_message on the fly
|
||||
* Currently a thin wrapper for substitute_placeholders() */
|
||||
virtual const char* what() const throw();
|
||||
|
||||
protected:
|
||||
/** Used to hold the error text returned by what() */
|
||||
mutable std::string m_message; // For on-demand formatting in 'what'
|
||||
|
||||
/** Makes all substitutions using the template */
|
||||
virtual void substitute_placeholders(const std::string& error_template) const;
|
||||
|
||||
// helper function for substitute_placeholders
|
||||
void replace_token(const std::string& from, const std::string& to) const;
|
||||
|
||||
/** Construct option name in accordance with the appropriate
|
||||
* prefix style: i.e. long dash or short slash etc */
|
||||
std::string get_canonical_option_name() const;
|
||||
std::string get_canonical_option_prefix() const;
|
||||
};
|
||||
|
||||
|
||||
/** Class thrown when there are several option values, but
|
||||
user called a method which cannot return them all. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL multiple_values : public error_with_option_name {
|
||||
public:
|
||||
multiple_values()
|
||||
: error_with_option_name("option '%canonical_option%' only takes a single argument"){}
|
||||
|
||||
~multiple_values() throw() {}
|
||||
};
|
||||
|
||||
/** Class thrown when there are several occurrences of an
|
||||
option, but user called a method which cannot return
|
||||
them all. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL multiple_occurrences : public error_with_option_name {
|
||||
public:
|
||||
multiple_occurrences()
|
||||
: error_with_option_name("option '%canonical_option%' cannot be specified more than once"){}
|
||||
|
||||
~multiple_occurrences() throw() {}
|
||||
|
||||
};
|
||||
|
||||
/** Class thrown when a required/mandatory option is missing */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL required_option : public error_with_option_name {
|
||||
public:
|
||||
// option name is constructed by the option_descriptor and never on the fly
|
||||
required_option(const std::string& option_name)
|
||||
: error_with_option_name("the option '%canonical_option%' is required but missing", "", option_name)
|
||||
{
|
||||
}
|
||||
|
||||
~required_option() throw() {}
|
||||
};
|
||||
|
||||
/** Base class of unparsable options,
|
||||
* when the desired option cannot be identified.
|
||||
*
|
||||
*
|
||||
* It makes no sense to have an option name, when we can't match an option to the
|
||||
* parameter
|
||||
*
|
||||
* Having this a part of the error_with_option_name hierachy makes error handling
|
||||
* a lot easier, even if the name indicates some sort of conceptual dissonance!
|
||||
*
|
||||
* */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL error_with_no_option_name : public error_with_option_name {
|
||||
public:
|
||||
error_with_no_option_name(const std::string& template_,
|
||||
const std::string& original_token = "")
|
||||
: error_with_option_name(template_, "", original_token)
|
||||
{
|
||||
}
|
||||
|
||||
/** Does NOT set option name, because no option name makes sense */
|
||||
virtual void set_option_name(const std::string&) {}
|
||||
|
||||
~error_with_no_option_name() throw() {}
|
||||
};
|
||||
|
||||
|
||||
/** Class thrown when option name is not recognized. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL unknown_option : public error_with_no_option_name {
|
||||
public:
|
||||
unknown_option(const std::string& original_token = "")
|
||||
: error_with_no_option_name("unrecognised option '%canonical_option%'", original_token)
|
||||
{
|
||||
}
|
||||
|
||||
~unknown_option() throw() {}
|
||||
};
|
||||
|
||||
|
||||
|
||||
/** Class thrown when there's ambiguity amoung several possible options. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL ambiguous_option : public error_with_no_option_name {
|
||||
public:
|
||||
ambiguous_option(const std::vector<std::string>& xalternatives)
|
||||
: error_with_no_option_name("option '%canonical_option%' is ambiguous"),
|
||||
m_alternatives(xalternatives)
|
||||
{}
|
||||
|
||||
~ambiguous_option() throw() {}
|
||||
|
||||
const std::vector<std::string>& alternatives() const throw() {return m_alternatives;}
|
||||
|
||||
protected:
|
||||
/** Makes all substitutions using the template */
|
||||
virtual void substitute_placeholders(const std::string& error_template) const;
|
||||
private:
|
||||
// TODO: copy ctor might throw
|
||||
std::vector<std::string> m_alternatives;
|
||||
};
|
||||
|
||||
|
||||
/** Class thrown when there's syntax error either for command
|
||||
* line or config file options. See derived children for
|
||||
* concrete classes. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL invalid_syntax : public error_with_option_name {
|
||||
public:
|
||||
enum kind_t {
|
||||
long_not_allowed = 30,
|
||||
long_adjacent_not_allowed,
|
||||
short_adjacent_not_allowed,
|
||||
empty_adjacent_parameter,
|
||||
missing_parameter,
|
||||
extra_parameter,
|
||||
unrecognized_line
|
||||
};
|
||||
|
||||
invalid_syntax(kind_t kind,
|
||||
const std::string& option_name = "",
|
||||
const std::string& original_token = "",
|
||||
int option_style = 0):
|
||||
error_with_option_name(get_template(kind), option_name, original_token, option_style),
|
||||
m_kind(kind)
|
||||
{
|
||||
}
|
||||
|
||||
~invalid_syntax() throw() {}
|
||||
|
||||
kind_t kind() const {return m_kind;}
|
||||
|
||||
/** Convenience functions for backwards compatibility */
|
||||
virtual std::string tokens() const {return get_option_name(); }
|
||||
protected:
|
||||
/** Used to convert kind_t to a related error text */
|
||||
std::string get_template(kind_t kind);
|
||||
kind_t m_kind;
|
||||
};
|
||||
|
||||
class BOOST_PROGRAM_OPTIONS_DECL invalid_config_file_syntax : public invalid_syntax {
|
||||
public:
|
||||
invalid_config_file_syntax(const std::string& invalid_line, kind_t kind):
|
||||
invalid_syntax(kind)
|
||||
{
|
||||
m_substitutions["invalid_line"] = invalid_line;
|
||||
}
|
||||
|
||||
~invalid_config_file_syntax() throw() {}
|
||||
|
||||
/** Convenience functions for backwards compatibility */
|
||||
virtual std::string tokens() const {return m_substitutions.find("invalid_line")->second; }
|
||||
};
|
||||
|
||||
|
||||
/** Class thrown when there are syntax errors in given command line */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL invalid_command_line_syntax : public invalid_syntax {
|
||||
public:
|
||||
invalid_command_line_syntax(kind_t kind,
|
||||
const std::string& option_name = "",
|
||||
const std::string& original_token = "",
|
||||
int option_style = 0):
|
||||
invalid_syntax(kind, option_name, original_token, option_style) {}
|
||||
~invalid_command_line_syntax() throw() {}
|
||||
};
|
||||
|
||||
|
||||
/** Class thrown when value of option is incorrect. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL validation_error : public error_with_option_name {
|
||||
public:
|
||||
enum kind_t {
|
||||
multiple_values_not_allowed = 30,
|
||||
at_least_one_value_required,
|
||||
invalid_bool_value,
|
||||
invalid_option_value,
|
||||
invalid_option
|
||||
};
|
||||
|
||||
public:
|
||||
validation_error(kind_t kind,
|
||||
const std::string& option_name = "",
|
||||
const std::string& original_token = "",
|
||||
int option_style = 0):
|
||||
error_with_option_name(get_template(kind), option_name, original_token, option_style)
|
||||
{
|
||||
}
|
||||
|
||||
~validation_error() throw() {}
|
||||
|
||||
protected:
|
||||
/** Used to convert kind_t to a related error text */
|
||||
std::string get_template(kind_t kind);
|
||||
kind_t m_kind;
|
||||
};
|
||||
|
||||
/** Class thrown if there is an invalid option value given */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL invalid_option_value
|
||||
: public validation_error
|
||||
{
|
||||
public:
|
||||
invalid_option_value(const std::string& value);
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
invalid_option_value(const std::wstring& value);
|
||||
#endif
|
||||
};
|
||||
|
||||
/** Class thrown if there is an invalid bool value given */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL invalid_bool_value
|
||||
: public validation_error
|
||||
{
|
||||
public:
|
||||
invalid_bool_value(const std::string& value);
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
}}
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning (pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,70 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_OPTION_HPP_VP_2004_02_25
|
||||
#define BOOST_OPTION_HPP_VP_2004_02_25
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
/** Option found in input source.
|
||||
Contains a key and a value. The key, in turn, can be a string (name of
|
||||
an option), or an integer (position in input source) -- in case no name
|
||||
is specified. The latter is only possible for command line.
|
||||
The template parameter specifies the type of char used for storing the
|
||||
option's value.
|
||||
*/
|
||||
template<class charT>
|
||||
class basic_option {
|
||||
public:
|
||||
basic_option()
|
||||
: position_key(-1)
|
||||
, unregistered(false)
|
||||
, case_insensitive(false)
|
||||
{}
|
||||
basic_option(const std::string& xstring_key,
|
||||
const std::vector< std::string> &xvalue)
|
||||
: string_key(xstring_key)
|
||||
, value(xvalue)
|
||||
, unregistered(false)
|
||||
, case_insensitive(false)
|
||||
{}
|
||||
|
||||
/** String key of this option. Intentionally independent of the template
|
||||
parameter. */
|
||||
std::string string_key;
|
||||
/** Position key of this option. All options without an explicit name are
|
||||
sequentially numbered starting from 0. If an option has explicit name,
|
||||
'position_key' is equal to -1. It is possible that both
|
||||
position_key and string_key is specified, in case name is implicitly
|
||||
added.
|
||||
*/
|
||||
int position_key;
|
||||
/** Option's value */
|
||||
std::vector< std::basic_string<charT> > value;
|
||||
/** The original unchanged tokens this option was
|
||||
created from. */
|
||||
std::vector< std::basic_string<charT> > original_tokens;
|
||||
/** True if option was not recognized. In that case,
|
||||
'string_key' and 'value' are results of purely
|
||||
syntactic parsing of source. The original tokens can be
|
||||
recovered from the "original_tokens" member.
|
||||
*/
|
||||
bool unregistered;
|
||||
/** True if string_key has to be handled
|
||||
case insensitive.
|
||||
*/
|
||||
bool case_insensitive;
|
||||
};
|
||||
typedef basic_option<char> option;
|
||||
typedef basic_option<wchar_t> woption;
|
||||
|
||||
}}
|
||||
|
||||
#endif
|
||||
+278
@@ -0,0 +1,278 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Copyright Bertolt Mildner 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#ifndef BOOST_OPTION_DESCRIPTION_VP_2003_05_19
|
||||
#define BOOST_OPTION_DESCRIPTION_VP_2003_05_19
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/errors.hpp>
|
||||
#include <boost/program_options/value_semantic.hpp>
|
||||
|
||||
#include <boost/function.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/any.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <set>
|
||||
#include <map>
|
||||
#include <stdexcept>
|
||||
|
||||
#include <iosfwd>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning (push)
|
||||
# pragma warning (disable:4251) // class 'boost::shared_ptr<T>' needs to have dll-interface to be used by clients of class 'boost::program_options::option_description'
|
||||
#endif
|
||||
|
||||
|
||||
/** Boost namespace */
|
||||
namespace boost {
|
||||
/** Namespace for the library. */
|
||||
namespace program_options {
|
||||
|
||||
/** Describes one possible command line/config file option. There are two
|
||||
kinds of properties of an option. First describe it syntactically and
|
||||
are used only to validate input. Second affect interpretation of the
|
||||
option, for example default value for it or function that should be
|
||||
called when the value is finally known. Routines which perform parsing
|
||||
never use second kind of properties -- they are side effect free.
|
||||
@sa options_description
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL option_description {
|
||||
public:
|
||||
|
||||
option_description();
|
||||
|
||||
/** Initializes the object with the passed data.
|
||||
|
||||
Note: it would be nice to make the second parameter auto_ptr,
|
||||
to explicitly pass ownership. Unfortunately, it's often needed to
|
||||
create objects of types derived from 'value_semantic':
|
||||
options_description d;
|
||||
d.add_options()("a", parameter<int>("n")->default_value(1));
|
||||
Here, the static type returned by 'parameter' should be derived
|
||||
from value_semantic.
|
||||
|
||||
Alas, derived->base conversion for auto_ptr does not really work,
|
||||
see
|
||||
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2000/n1232.pdf
|
||||
http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#84
|
||||
|
||||
So, we have to use plain old pointers. Besides, users are not
|
||||
expected to use the constructor directly.
|
||||
|
||||
|
||||
The 'name' parameter is interpreted by the following rules:
|
||||
- if there's no "," character in 'name', it specifies long name
|
||||
- otherwise, the part before "," specifies long name and the part
|
||||
after -- short name.
|
||||
*/
|
||||
option_description(const char* name,
|
||||
const value_semantic* s);
|
||||
|
||||
/** Initializes the class with the passed data.
|
||||
*/
|
||||
option_description(const char* name,
|
||||
const value_semantic* s,
|
||||
const char* description);
|
||||
|
||||
virtual ~option_description();
|
||||
|
||||
enum match_result { no_match, full_match, approximate_match };
|
||||
|
||||
/** Given 'option', specified in the input source,
|
||||
returns 'true' if 'option' specifies *this.
|
||||
*/
|
||||
match_result match(const std::string& option, bool approx,
|
||||
bool long_ignore_case, bool short_ignore_case) const;
|
||||
|
||||
/** Returns the key that should identify the option, in
|
||||
particular in the variables_map class.
|
||||
The 'option' parameter is the option spelling from the
|
||||
input source.
|
||||
If option name contains '*', returns 'option'.
|
||||
If long name was specified, it's the long name, otherwise
|
||||
it's a short name with prepended '-'.
|
||||
*/
|
||||
const std::string& key(const std::string& option) const;
|
||||
|
||||
|
||||
/** Returns the canonical name for the option description to enable the user to
|
||||
recognised a matching option.
|
||||
1) For short options ('-', '/'), returns the short name prefixed.
|
||||
2) For long options ('--' / '-') returns the long name prefixed
|
||||
3) All other cases, returns the long name (if present) or the short name,
|
||||
unprefixed.
|
||||
*/
|
||||
std::string canonical_display_name(int canonical_option_style = 0) const;
|
||||
|
||||
const std::string& long_name() const;
|
||||
|
||||
/// Explanation of this option
|
||||
const std::string& description() const;
|
||||
|
||||
/// Semantic of option's value
|
||||
shared_ptr<const value_semantic> semantic() const;
|
||||
|
||||
/// Returns the option name, formatted suitably for usage message.
|
||||
std::string format_name() const;
|
||||
|
||||
/** Returns the parameter name and properties, formatted suitably for
|
||||
usage message. */
|
||||
std::string format_parameter() const;
|
||||
|
||||
private:
|
||||
|
||||
option_description& set_name(const char* name);
|
||||
|
||||
std::string m_short_name, m_long_name, m_description;
|
||||
// shared_ptr is needed to simplify memory management in
|
||||
// copy ctor and destructor.
|
||||
shared_ptr<const value_semantic> m_value_semantic;
|
||||
};
|
||||
|
||||
class options_description;
|
||||
|
||||
/** Class which provides convenient creation syntax to option_description.
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL options_description_easy_init {
|
||||
public:
|
||||
options_description_easy_init(options_description* owner);
|
||||
|
||||
options_description_easy_init&
|
||||
operator()(const char* name,
|
||||
const char* description);
|
||||
|
||||
options_description_easy_init&
|
||||
operator()(const char* name,
|
||||
const value_semantic* s);
|
||||
|
||||
options_description_easy_init&
|
||||
operator()(const char* name,
|
||||
const value_semantic* s,
|
||||
const char* description);
|
||||
|
||||
private:
|
||||
options_description* owner;
|
||||
};
|
||||
|
||||
|
||||
/** A set of option descriptions. This provides convenient interface for
|
||||
adding new option (the add_options) method, and facilities to search
|
||||
for options by name.
|
||||
|
||||
See @ref a_adding_options "here" for option adding interface discussion.
|
||||
@sa option_description
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL options_description {
|
||||
public:
|
||||
static const unsigned m_default_line_length;
|
||||
|
||||
/** Creates the instance. */
|
||||
options_description(unsigned line_length = m_default_line_length,
|
||||
unsigned min_description_length = m_default_line_length / 2);
|
||||
/** Creates the instance. The 'caption' parameter gives the name of
|
||||
this 'options_description' instance. Primarily useful for output.
|
||||
The 'description_length' specifies the number of columns that
|
||||
should be reserved for the description text; if the option text
|
||||
encroaches into this, then the description will start on the next
|
||||
line.
|
||||
*/
|
||||
options_description(const std::string& caption,
|
||||
unsigned line_length = m_default_line_length,
|
||||
unsigned min_description_length = m_default_line_length / 2);
|
||||
/** Adds new variable description. Throws duplicate_variable_error if
|
||||
either short or long name matches that of already present one.
|
||||
*/
|
||||
void add(shared_ptr<option_description> desc);
|
||||
/** Adds a group of option description. This has the same
|
||||
effect as adding all option_descriptions in 'desc'
|
||||
individually, except that output operator will show
|
||||
a separate group.
|
||||
Returns *this.
|
||||
*/
|
||||
options_description& add(const options_description& desc);
|
||||
|
||||
/** Find the maximum width of the option column, including options
|
||||
in groups. */
|
||||
unsigned get_option_column_width() const;
|
||||
|
||||
public:
|
||||
/** Returns an object of implementation-defined type suitable for adding
|
||||
options to options_description. The returned object will
|
||||
have overloaded operator() with parameter type matching
|
||||
'option_description' constructors. Calling the operator will create
|
||||
new option_description instance and add it.
|
||||
*/
|
||||
options_description_easy_init add_options();
|
||||
|
||||
const option_description& find(const std::string& name,
|
||||
bool approx,
|
||||
bool long_ignore_case = false,
|
||||
bool short_ignore_case = false) const;
|
||||
|
||||
const option_description* find_nothrow(const std::string& name,
|
||||
bool approx,
|
||||
bool long_ignore_case = false,
|
||||
bool short_ignore_case = false) const;
|
||||
|
||||
|
||||
const std::vector< shared_ptr<option_description> >& options() const;
|
||||
|
||||
/** Produces a human readable output of 'desc', listing options,
|
||||
their descriptions and allowed parameters. Other options_description
|
||||
instances previously passed to add will be output separately. */
|
||||
friend BOOST_PROGRAM_OPTIONS_DECL std::ostream& operator<<(std::ostream& os,
|
||||
const options_description& desc);
|
||||
|
||||
/** Outputs 'desc' to the specified stream, calling 'f' to output each
|
||||
option_description element. */
|
||||
void print(std::ostream& os, unsigned width = 0) const;
|
||||
|
||||
private:
|
||||
typedef std::map<std::string, int>::const_iterator name2index_iterator;
|
||||
typedef std::pair<name2index_iterator, name2index_iterator>
|
||||
approximation_range;
|
||||
|
||||
//approximation_range find_approximation(const std::string& prefix) const;
|
||||
|
||||
std::string m_caption;
|
||||
const unsigned m_line_length;
|
||||
const unsigned m_min_description_length;
|
||||
|
||||
// Data organization is chosen because:
|
||||
// - there could be two names for one option
|
||||
// - option_add_proxy needs to know the last added option
|
||||
std::vector< shared_ptr<option_description> > m_options;
|
||||
|
||||
// Whether the option comes from one of declared groups.
|
||||
#if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, BOOST_TESTED_AT(313))
|
||||
// vector<bool> is buggy there, see
|
||||
// http://support.microsoft.com/default.aspx?scid=kb;en-us;837698
|
||||
std::vector<char> belong_to_group;
|
||||
#else
|
||||
std::vector<bool> belong_to_group;
|
||||
#endif
|
||||
|
||||
std::vector< shared_ptr<options_description> > groups;
|
||||
|
||||
};
|
||||
|
||||
/** Class thrown when duplicate option description is found. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL duplicate_option_error : public error {
|
||||
public:
|
||||
duplicate_option_error(const std::string& xwhat) : error(xwhat) {}
|
||||
};
|
||||
}}
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning (pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
+293
@@ -0,0 +1,293 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#ifndef BOOST_PARSERS_VP_2003_05_19
|
||||
#define BOOST_PARSERS_VP_2003_05_19
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/option.hpp>
|
||||
#include <boost/program_options/detail/cmdline.hpp>
|
||||
|
||||
#include <boost/function/function1.hpp>
|
||||
|
||||
#include <iosfwd>
|
||||
#include <vector>
|
||||
#include <utility>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning (push)
|
||||
# pragma warning (disable:4251) // class 'std::vector<_Ty>' needs to have dll-interface to be used by clients of class 'boost::program_options::basic_parsed_options<wchar_t>'
|
||||
#endif
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
class options_description;
|
||||
class positional_options_description;
|
||||
|
||||
|
||||
/** Results of parsing an input source.
|
||||
The primary use of this class is passing information from parsers
|
||||
component to value storage component. This class does not makes
|
||||
much sense itself.
|
||||
*/
|
||||
template<class charT>
|
||||
class basic_parsed_options {
|
||||
public:
|
||||
explicit basic_parsed_options(const options_description* xdescription, int options_prefix = 0)
|
||||
: description(xdescription), m_options_prefix(options_prefix) {}
|
||||
/** Options found in the source. */
|
||||
std::vector< basic_option<charT> > options;
|
||||
/** Options description that was used for parsing.
|
||||
Parsers should return pointer to the instance of
|
||||
option_description passed to them, and issues of lifetime are
|
||||
up to the caller. Can be NULL.
|
||||
*/
|
||||
const options_description* description;
|
||||
|
||||
/** Mainly used for the diagnostic messages in exceptions.
|
||||
* The canonical option prefix for the parser which generated these results,
|
||||
* depending on the settings for basic_command_line_parser::style() or
|
||||
* cmdline::style(). In order of precedence of command_line_style enums:
|
||||
* allow_long
|
||||
* allow_long_disguise
|
||||
* allow_dash_for_short
|
||||
* allow_slash_for_short
|
||||
*/
|
||||
int m_options_prefix;
|
||||
};
|
||||
|
||||
/** Specialization of basic_parsed_options which:
|
||||
- provides convenient conversion from basic_parsed_options<char>
|
||||
- stores the passed char-based options for later use.
|
||||
*/
|
||||
template<>
|
||||
class BOOST_PROGRAM_OPTIONS_DECL basic_parsed_options<wchar_t> {
|
||||
public:
|
||||
/** Constructs wrapped options from options in UTF8 encoding. */
|
||||
explicit basic_parsed_options(const basic_parsed_options<char>& po);
|
||||
|
||||
std::vector< basic_option<wchar_t> > options;
|
||||
const options_description* description;
|
||||
|
||||
/** Stores UTF8 encoded options that were passed to constructor,
|
||||
to avoid reverse conversion in some cases. */
|
||||
basic_parsed_options<char> utf8_encoded_options;
|
||||
|
||||
/** Mainly used for the diagnostic messages in exceptions.
|
||||
* The canonical option prefix for the parser which generated these results,
|
||||
* depending on the settings for basic_command_line_parser::style() or
|
||||
* cmdline::style(). In order of precedence of command_line_style enums:
|
||||
* allow_long
|
||||
* allow_long_disguise
|
||||
* allow_dash_for_short
|
||||
* allow_slash_for_short
|
||||
*/
|
||||
int m_options_prefix;
|
||||
};
|
||||
|
||||
typedef basic_parsed_options<char> parsed_options;
|
||||
typedef basic_parsed_options<wchar_t> wparsed_options;
|
||||
|
||||
/** Augments basic_parsed_options<wchar_t> with conversion from
|
||||
'parsed_options' */
|
||||
|
||||
|
||||
typedef function1<std::pair<std::string, std::string>, const std::string&> ext_parser;
|
||||
|
||||
/** Command line parser.
|
||||
|
||||
The class allows one to specify all the information needed for parsing
|
||||
and to parse the command line. It is primarily needed to
|
||||
emulate named function parameters -- a regular function with 5
|
||||
parameters will be hard to use and creating overloads with a smaller
|
||||
nuber of parameters will be confusing.
|
||||
|
||||
For the most common case, the function parse_command_line is a better
|
||||
alternative.
|
||||
|
||||
There are two typedefs -- command_line_parser and wcommand_line_parser,
|
||||
for charT == char and charT == wchar_t cases.
|
||||
*/
|
||||
template<class charT>
|
||||
class basic_command_line_parser : private detail::cmdline {
|
||||
public:
|
||||
/** Creates a command line parser for the specified arguments
|
||||
list. The 'args' parameter should not include program name.
|
||||
*/
|
||||
basic_command_line_parser(const std::vector<
|
||||
std::basic_string<charT> >& args);
|
||||
/** Creates a command line parser for the specified arguments
|
||||
list. The parameters should be the same as passed to 'main'.
|
||||
*/
|
||||
basic_command_line_parser(int argc, const charT* const argv[]);
|
||||
|
||||
/** Sets options descriptions to use. */
|
||||
basic_command_line_parser& options(const options_description& desc);
|
||||
/** Sets positional options description to use. */
|
||||
basic_command_line_parser& positional(
|
||||
const positional_options_description& desc);
|
||||
|
||||
/** Sets the command line style. */
|
||||
basic_command_line_parser& style(int);
|
||||
/** Sets the extra parsers. */
|
||||
basic_command_line_parser& extra_parser(ext_parser);
|
||||
|
||||
/** Parses the options and returns the result of parsing.
|
||||
Throws on error.
|
||||
*/
|
||||
basic_parsed_options<charT> run();
|
||||
|
||||
/** Specifies that unregistered options are allowed and should
|
||||
be passed though. For each command like token that looks
|
||||
like an option but does not contain a recognized name, an
|
||||
instance of basic_option<charT> will be added to result,
|
||||
with 'unrecognized' field set to 'true'. It's possible to
|
||||
collect all unrecognized options with the 'collect_unrecognized'
|
||||
funciton.
|
||||
*/
|
||||
basic_command_line_parser& allow_unregistered();
|
||||
|
||||
using detail::cmdline::style_parser;
|
||||
|
||||
basic_command_line_parser& extra_style_parser(style_parser s);
|
||||
|
||||
private:
|
||||
const options_description* m_desc;
|
||||
};
|
||||
|
||||
typedef basic_command_line_parser<char> command_line_parser;
|
||||
typedef basic_command_line_parser<wchar_t> wcommand_line_parser;
|
||||
|
||||
/** Creates instance of 'command_line_parser', passes parameters to it,
|
||||
and returns the result of calling the 'run' method.
|
||||
*/
|
||||
template<class charT>
|
||||
basic_parsed_options<charT>
|
||||
parse_command_line(int argc, const charT* const argv[],
|
||||
const options_description&,
|
||||
int style = 0,
|
||||
function1<std::pair<std::string, std::string>,
|
||||
const std::string&> ext
|
||||
= ext_parser());
|
||||
|
||||
/** Parse a config file.
|
||||
|
||||
Read from given stream.
|
||||
*/
|
||||
template<class charT>
|
||||
#if ! BOOST_WORKAROUND(__ICL, BOOST_TESTED_AT(700))
|
||||
BOOST_PROGRAM_OPTIONS_DECL
|
||||
#endif
|
||||
basic_parsed_options<charT>
|
||||
parse_config_file(std::basic_istream<charT>&, const options_description&,
|
||||
bool allow_unregistered = false);
|
||||
|
||||
/** Parse a config file.
|
||||
|
||||
Read from file with the given name. The character type is
|
||||
passed to the file stream.
|
||||
*/
|
||||
template<class charT>
|
||||
#if ! BOOST_WORKAROUND(__ICL, BOOST_TESTED_AT(700))
|
||||
BOOST_PROGRAM_OPTIONS_DECL
|
||||
#endif
|
||||
basic_parsed_options<charT>
|
||||
parse_config_file(const char* filename, const options_description&,
|
||||
bool allow_unregistered = false);
|
||||
|
||||
/** Controls if the 'collect_unregistered' function should
|
||||
include positional options, or not. */
|
||||
enum collect_unrecognized_mode
|
||||
{ include_positional, exclude_positional };
|
||||
|
||||
/** Collects the original tokens for all named options with
|
||||
'unregistered' flag set. If 'mode' is 'include_positional'
|
||||
also collects all positional options.
|
||||
Returns the vector of origianl tokens for all collected
|
||||
options.
|
||||
*/
|
||||
template<class charT>
|
||||
std::vector< std::basic_string<charT> >
|
||||
collect_unrecognized(const std::vector< basic_option<charT> >& options,
|
||||
enum collect_unrecognized_mode mode);
|
||||
|
||||
/** Parse environment.
|
||||
|
||||
For each environment variable, the 'name_mapper' function is called to
|
||||
obtain the option name. If it returns empty string, the variable is
|
||||
ignored.
|
||||
|
||||
This is done since naming of environment variables is typically
|
||||
different from the naming of command line options.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL parsed_options
|
||||
parse_environment(const options_description&,
|
||||
const function1<std::string, std::string>& name_mapper);
|
||||
|
||||
/** Parse environment.
|
||||
|
||||
Takes all environment variables which start with 'prefix'. The option
|
||||
name is obtained from variable name by removing the prefix and
|
||||
converting the remaining string into lower case.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL parsed_options
|
||||
parse_environment(const options_description&, const std::string& prefix);
|
||||
|
||||
/** @overload
|
||||
This function exists to resolve ambiguity between the two above
|
||||
functions when second argument is of 'char*' type. There's implicit
|
||||
conversion to both function1 and string.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL parsed_options
|
||||
parse_environment(const options_description&, const char* prefix);
|
||||
|
||||
/** Splits a given string to a collection of single strings which
|
||||
can be passed to command_line_parser. The second parameter is
|
||||
used to specify a collection of possible seperator chars used
|
||||
for splitting. The seperator is defaulted to space " ".
|
||||
Splitting is done in a unix style way, with respect to quotes '"'
|
||||
and escape characters '\'
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::vector<std::string>
|
||||
split_unix(const std::string& cmdline, const std::string& seperator = " \t",
|
||||
const std::string& quote = "'\"", const std::string& escape = "\\");
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
/** @overload */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::vector<std::wstring>
|
||||
split_unix(const std::wstring& cmdline, const std::wstring& seperator = L" \t",
|
||||
const std::wstring& quote = L"'\"", const std::wstring& escape = L"\\");
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
/** Parses the char* string which is passed to WinMain function on
|
||||
windows. This function is provided for convenience, and because it's
|
||||
not clear how to portably access split command line string from
|
||||
runtime library and if it always exists.
|
||||
This function is available only on Windows.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::vector<std::string>
|
||||
split_winmain(const std::string& cmdline);
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
/** @overload */
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::vector<std::wstring>
|
||||
split_winmain(const std::wstring& cmdline);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
}}
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning (pop)
|
||||
#endif
|
||||
|
||||
#undef DECL
|
||||
|
||||
#include "boost/program_options/detail/parsers.hpp"
|
||||
|
||||
#endif
|
||||
+74
@@ -0,0 +1,74 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_PROGRAM_OPTIONS_POSITIONAL_OPTIONS_VP_2004_03_02
|
||||
#define BOOST_PROGRAM_OPTIONS_POSITIONAL_OPTIONS_VP_2004_03_02
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#include <vector>
|
||||
#include <string>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning (push)
|
||||
# pragma warning (disable:4251) // class 'std::vector<_Ty>' needs to have dll-interface to be used by clients of class 'boost::program_options::positional_options_description'
|
||||
#endif
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
/** Describes positional options.
|
||||
|
||||
The class allows to guess option names for positional options, which
|
||||
are specified on the command line and are identified by the position.
|
||||
The class uses the information provided by the user to associate a name
|
||||
with every positional option, or tell that no name is known.
|
||||
|
||||
The primary assumption is that only the relative order of the
|
||||
positional options themselves matters, and that any interleaving
|
||||
ordinary options don't affect interpretation of positional options.
|
||||
|
||||
The user initializes the class by specifying that first N positional
|
||||
options should be given the name X1, following M options should be given
|
||||
the name X2 and so on.
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL positional_options_description {
|
||||
public:
|
||||
positional_options_description();
|
||||
|
||||
/** Species that up to 'max_count' next positional options
|
||||
should be given the 'name'. The value of '-1' means 'unlimited'.
|
||||
No calls to 'add' can be made after call with 'max_value' equal to
|
||||
'-1'.
|
||||
*/
|
||||
positional_options_description&
|
||||
add(const char* name, int max_count);
|
||||
|
||||
/** Returns the maximum number of positional options that can
|
||||
be present. Can return (numeric_limits<unsigned>::max)() to
|
||||
indicate unlimited number. */
|
||||
unsigned max_total_count() const;
|
||||
|
||||
/** Returns the name that should be associated with positional
|
||||
options at 'position'.
|
||||
Precondition: position < max_total_count()
|
||||
*/
|
||||
const std::string& name_for_position(unsigned position) const;
|
||||
|
||||
private:
|
||||
// List of names corresponding to the positions. If the number of
|
||||
// positions is unlimited, then the last name is stored in
|
||||
// m_trailing;
|
||||
std::vector<std::string> m_names;
|
||||
std::string m_trailing;
|
||||
};
|
||||
|
||||
}}
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning (pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
+421
@@ -0,0 +1,421 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_VALUE_SEMANTIC_HPP_VP_2004_02_24
|
||||
#define BOOST_VALUE_SEMANTIC_HPP_VP_2004_02_24
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/errors.hpp>
|
||||
|
||||
#include <boost/any.hpp>
|
||||
#include <boost/function/function1.hpp>
|
||||
#include <boost/lexical_cast.hpp>
|
||||
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <typeinfo>
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
/** Class which specifies how the option's value is to be parsed
|
||||
and converted into C++ types.
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL value_semantic {
|
||||
public:
|
||||
/** Returns the name of the option. The name is only meaningful
|
||||
for automatic help message.
|
||||
*/
|
||||
virtual std::string name() const = 0;
|
||||
|
||||
/** The minimum number of tokens for this option that
|
||||
should be present on the command line. */
|
||||
virtual unsigned min_tokens() const = 0;
|
||||
|
||||
/** The maximum number of tokens for this option that
|
||||
should be present on the command line. */
|
||||
virtual unsigned max_tokens() const = 0;
|
||||
|
||||
/** Returns true if values from different sources should be composed.
|
||||
Otherwise, value from the first source is used and values from
|
||||
other sources are discarded.
|
||||
*/
|
||||
virtual bool is_composing() const = 0;
|
||||
|
||||
/** Returns true if value must be given. Non-optional value
|
||||
|
||||
*/
|
||||
virtual bool is_required() const = 0;
|
||||
|
||||
/** Parses a group of tokens that specify a value of option.
|
||||
Stores the result in 'value_store', using whatever representation
|
||||
is desired. May be be called several times if value of the same
|
||||
option is specified more than once.
|
||||
*/
|
||||
virtual void parse(boost::any& value_store,
|
||||
const std::vector<std::string>& new_tokens,
|
||||
bool utf8) const
|
||||
= 0;
|
||||
|
||||
/** Called to assign default value to 'value_store'. Returns
|
||||
true if default value is assigned, and false if no default
|
||||
value exists. */
|
||||
virtual bool apply_default(boost::any& value_store) const = 0;
|
||||
|
||||
/** Called when final value of an option is determined.
|
||||
*/
|
||||
virtual void notify(const boost::any& value_store) const = 0;
|
||||
|
||||
virtual ~value_semantic() {}
|
||||
};
|
||||
|
||||
/** Helper class which perform necessary character conversions in the
|
||||
'parse' method and forwards the data further.
|
||||
*/
|
||||
template<class charT>
|
||||
class value_semantic_codecvt_helper {
|
||||
// Nothing here. Specializations to follow.
|
||||
};
|
||||
|
||||
/** Helper conversion class for values that accept ascii
|
||||
strings as input.
|
||||
Overrides the 'parse' method and defines new 'xparse'
|
||||
method taking std::string. Depending on whether input
|
||||
to parse is ascii or UTF8, will pass it to xparse unmodified,
|
||||
or with UTF8->ascii conversion.
|
||||
*/
|
||||
template<>
|
||||
class BOOST_PROGRAM_OPTIONS_DECL
|
||||
value_semantic_codecvt_helper<char> : public value_semantic {
|
||||
private: // base overrides
|
||||
void parse(boost::any& value_store,
|
||||
const std::vector<std::string>& new_tokens,
|
||||
bool utf8) const;
|
||||
protected: // interface for derived classes.
|
||||
virtual void xparse(boost::any& value_store,
|
||||
const std::vector<std::string>& new_tokens)
|
||||
const = 0;
|
||||
};
|
||||
|
||||
/** Helper conversion class for values that accept ascii
|
||||
strings as input.
|
||||
Overrides the 'parse' method and defines new 'xparse'
|
||||
method taking std::wstring. Depending on whether input
|
||||
to parse is ascii or UTF8, will recode input to Unicode, or
|
||||
pass it unmodified.
|
||||
*/
|
||||
template<>
|
||||
class BOOST_PROGRAM_OPTIONS_DECL
|
||||
value_semantic_codecvt_helper<wchar_t> : public value_semantic {
|
||||
private: // base overrides
|
||||
void parse(boost::any& value_store,
|
||||
const std::vector<std::string>& new_tokens,
|
||||
bool utf8) const;
|
||||
protected: // interface for derived classes.
|
||||
#if !defined(BOOST_NO_STD_WSTRING)
|
||||
virtual void xparse(boost::any& value_store,
|
||||
const std::vector<std::wstring>& new_tokens)
|
||||
const = 0;
|
||||
#endif
|
||||
};
|
||||
|
||||
/** Class which specifies a simple handling of a value: the value will
|
||||
have string type and only one token is allowed. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL
|
||||
untyped_value : public value_semantic_codecvt_helper<char> {
|
||||
public:
|
||||
untyped_value(bool zero_tokens = false)
|
||||
: m_zero_tokens(zero_tokens)
|
||||
{}
|
||||
|
||||
std::string name() const;
|
||||
|
||||
unsigned min_tokens() const;
|
||||
unsigned max_tokens() const;
|
||||
|
||||
bool is_composing() const { return false; }
|
||||
|
||||
bool is_required() const { return false; }
|
||||
|
||||
/** If 'value_store' is already initialized, or new_tokens
|
||||
has more than one elements, throws. Otherwise, assigns
|
||||
the first string from 'new_tokens' to 'value_store', without
|
||||
any modifications.
|
||||
*/
|
||||
void xparse(boost::any& value_store,
|
||||
const std::vector<std::string>& new_tokens) const;
|
||||
|
||||
/** Does nothing. */
|
||||
bool apply_default(boost::any&) const { return false; }
|
||||
|
||||
/** Does nothing. */
|
||||
void notify(const boost::any&) const {}
|
||||
private:
|
||||
bool m_zero_tokens;
|
||||
};
|
||||
|
||||
/** Base class for all option that have a fixed type, and are
|
||||
willing to announce this type to the outside world.
|
||||
Any 'value_semantics' for which you want to find out the
|
||||
type can be dynamic_cast-ed to typed_value_base. If conversion
|
||||
succeeds, the 'type' method can be called.
|
||||
*/
|
||||
class typed_value_base
|
||||
{
|
||||
public:
|
||||
// Returns the type of the value described by this
|
||||
// object.
|
||||
virtual const std::type_info& value_type() const = 0;
|
||||
// Not really needed, since deletion from this
|
||||
// class is silly, but just in case.
|
||||
virtual ~typed_value_base() {}
|
||||
};
|
||||
|
||||
|
||||
/** Class which handles value of a specific type. */
|
||||
template<class T, class charT = char>
|
||||
class typed_value : public value_semantic_codecvt_helper<charT>,
|
||||
public typed_value_base
|
||||
{
|
||||
public:
|
||||
/** Ctor. The 'store_to' parameter tells where to store
|
||||
the value when it's known. The parameter can be NULL. */
|
||||
typed_value(T* store_to)
|
||||
: m_store_to(store_to), m_composing(false),
|
||||
m_multitoken(false), m_zero_tokens(false),
|
||||
m_required(false)
|
||||
{}
|
||||
|
||||
/** Specifies default value, which will be used
|
||||
if none is explicitly specified. The type 'T' should
|
||||
provide operator<< for ostream.
|
||||
*/
|
||||
typed_value* default_value(const T& v)
|
||||
{
|
||||
m_default_value = boost::any(v);
|
||||
m_default_value_as_text = boost::lexical_cast<std::string>(v);
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Specifies default value, which will be used
|
||||
if none is explicitly specified. Unlike the above overload,
|
||||
the type 'T' need not provide operator<< for ostream,
|
||||
but textual representation of default value must be provided
|
||||
by the user.
|
||||
*/
|
||||
typed_value* default_value(const T& v, const std::string& textual)
|
||||
{
|
||||
m_default_value = boost::any(v);
|
||||
m_default_value_as_text = textual;
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Specifies an implicit value, which will be used
|
||||
if the option is given, but without an adjacent value.
|
||||
Using this implies that an explicit value is optional, but if
|
||||
given, must be strictly adjacent to the option, i.e.: '-ovalue'
|
||||
or '--option=value'. Giving '-o' or '--option' will cause the
|
||||
implicit value to be applied.
|
||||
*/
|
||||
typed_value* implicit_value(const T &v)
|
||||
{
|
||||
m_implicit_value = boost::any(v);
|
||||
m_implicit_value_as_text =
|
||||
boost::lexical_cast<std::string>(v);
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Specifies the name used to to the value in help message. */
|
||||
typed_value* value_name(const std::string& name)
|
||||
{
|
||||
m_value_name = name;
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Specifies an implicit value, which will be used
|
||||
if the option is given, but without an adjacent value.
|
||||
Using this implies that an explicit value is optional, but if
|
||||
given, must be strictly adjacent to the option, i.e.: '-ovalue'
|
||||
or '--option=value'. Giving '-o' or '--option' will cause the
|
||||
implicit value to be applied.
|
||||
Unlike the above overload, the type 'T' need not provide
|
||||
operator<< for ostream, but textual representation of default
|
||||
value must be provided by the user.
|
||||
*/
|
||||
typed_value* implicit_value(const T &v, const std::string& textual)
|
||||
{
|
||||
m_implicit_value = boost::any(v);
|
||||
m_implicit_value_as_text = textual;
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Specifies a function to be called when the final value
|
||||
is determined. */
|
||||
typed_value* notifier(function1<void, const T&> f)
|
||||
{
|
||||
m_notifier = f;
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Specifies that the value is composing. See the 'is_composing'
|
||||
method for explanation.
|
||||
*/
|
||||
typed_value* composing()
|
||||
{
|
||||
m_composing = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Specifies that the value can span multiple tokens.
|
||||
*/
|
||||
typed_value* multitoken()
|
||||
{
|
||||
m_multitoken = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Specifies that no tokens may be provided as the value of
|
||||
this option, which means that only presense of the option
|
||||
is significant. For such option to be useful, either the
|
||||
'validate' function should be specialized, or the
|
||||
'implicit_value' method should be also used. In most
|
||||
cases, you can use the 'bool_switch' function instead of
|
||||
using this method. */
|
||||
typed_value* zero_tokens()
|
||||
{
|
||||
m_zero_tokens = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
/** Specifies that the value must occur. */
|
||||
typed_value* required()
|
||||
{
|
||||
m_required = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
public: // value semantic overrides
|
||||
|
||||
std::string name() const;
|
||||
|
||||
bool is_composing() const { return m_composing; }
|
||||
|
||||
unsigned min_tokens() const
|
||||
{
|
||||
if (m_zero_tokens || !m_implicit_value.empty()) {
|
||||
return 0;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
unsigned max_tokens() const {
|
||||
if (m_multitoken) {
|
||||
return 32000;
|
||||
} else if (m_zero_tokens) {
|
||||
return 0;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
|
||||
bool is_required() const { return m_required; }
|
||||
|
||||
/** Creates an instance of the 'validator' class and calls
|
||||
its operator() to perform the actual conversion. */
|
||||
void xparse(boost::any& value_store,
|
||||
const std::vector< std::basic_string<charT> >& new_tokens)
|
||||
const;
|
||||
|
||||
/** If default value was specified via previous call to
|
||||
'default_value', stores that value into 'value_store'.
|
||||
Returns true if default value was stored.
|
||||
*/
|
||||
virtual bool apply_default(boost::any& value_store) const
|
||||
{
|
||||
if (m_default_value.empty()) {
|
||||
return false;
|
||||
} else {
|
||||
value_store = m_default_value;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
/** If an address of variable to store value was specified
|
||||
when creating *this, stores the value there. Otherwise,
|
||||
does nothing. */
|
||||
void notify(const boost::any& value_store) const;
|
||||
|
||||
public: // typed_value_base overrides
|
||||
|
||||
const std::type_info& value_type() const
|
||||
{
|
||||
return typeid(T);
|
||||
}
|
||||
|
||||
|
||||
private:
|
||||
T* m_store_to;
|
||||
|
||||
// Default value is stored as boost::any and not
|
||||
// as boost::optional to avoid unnecessary instantiations.
|
||||
std::string m_value_name;
|
||||
boost::any m_default_value;
|
||||
std::string m_default_value_as_text;
|
||||
boost::any m_implicit_value;
|
||||
std::string m_implicit_value_as_text;
|
||||
bool m_composing, m_implicit, m_multitoken, m_zero_tokens, m_required;
|
||||
boost::function1<void, const T&> m_notifier;
|
||||
};
|
||||
|
||||
|
||||
/** Creates a typed_value<T> instance. This function is the primary
|
||||
method to create value_semantic instance for a specific type, which
|
||||
can later be passed to 'option_description' constructor.
|
||||
The second overload is used when it's additionally desired to store the
|
||||
value of option into program variable.
|
||||
*/
|
||||
template<class T>
|
||||
typed_value<T>*
|
||||
value();
|
||||
|
||||
/** @overload
|
||||
*/
|
||||
template<class T>
|
||||
typed_value<T>*
|
||||
value(T* v);
|
||||
|
||||
/** Creates a typed_value<T> instance. This function is the primary
|
||||
method to create value_semantic instance for a specific type, which
|
||||
can later be passed to 'option_description' constructor.
|
||||
*/
|
||||
template<class T>
|
||||
typed_value<T, wchar_t>*
|
||||
wvalue();
|
||||
|
||||
/** @overload
|
||||
*/
|
||||
template<class T>
|
||||
typed_value<T, wchar_t>*
|
||||
wvalue(T* v);
|
||||
|
||||
/** Works the same way as the 'value<bool>' function, but the created
|
||||
value_semantic won't accept any explicit value. So, if the option
|
||||
is present on the command line, the value will be 'true'.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL typed_value<bool>*
|
||||
bool_switch();
|
||||
|
||||
/** @overload
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL typed_value<bool>*
|
||||
bool_switch(bool* v);
|
||||
|
||||
}}
|
||||
|
||||
#include "boost/program_options/detail/value_semantic.hpp"
|
||||
|
||||
#endif
|
||||
|
||||
+220
@@ -0,0 +1,220 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#ifndef BOOST_VARIABLES_MAP_VP_2003_05_19
|
||||
#define BOOST_VARIABLES_MAP_VP_2003_05_19
|
||||
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#include <boost/any.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <map>
|
||||
#include <set>
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning (push)
|
||||
# pragma warning (disable:4251) // 'boost::program_options::variable_value::v' : class 'boost::any' needs to have dll-interface to be used by clients of class 'boost::program_options::variable_value
|
||||
#endif
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
template<class charT>
|
||||
class basic_parsed_options;
|
||||
|
||||
class value_semantic;
|
||||
class variables_map;
|
||||
|
||||
// forward declaration
|
||||
|
||||
/** Stores in 'm' all options that are defined in 'options'.
|
||||
If 'm' already has a non-defaulted value of an option, that value
|
||||
is not changed, even if 'options' specify some value.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL
|
||||
void store(const basic_parsed_options<char>& options, variables_map& m,
|
||||
bool utf8 = false);
|
||||
|
||||
/** Stores in 'm' all options that are defined in 'options'.
|
||||
If 'm' already has a non-defaulted value of an option, that value
|
||||
is not changed, even if 'options' specify some value.
|
||||
This is wide character variant.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL
|
||||
void store(const basic_parsed_options<wchar_t>& options,
|
||||
variables_map& m);
|
||||
|
||||
|
||||
/** Runs all 'notify' function for options in 'm'. */
|
||||
BOOST_PROGRAM_OPTIONS_DECL void notify(variables_map& m);
|
||||
|
||||
/** Class holding value of option. Contains details about how the
|
||||
value is set and allows to conveniently obtain the value.
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL variable_value {
|
||||
public:
|
||||
variable_value() : m_defaulted(false) {}
|
||||
variable_value(const boost::any& xv, bool xdefaulted)
|
||||
: v(xv), m_defaulted(xdefaulted)
|
||||
{}
|
||||
|
||||
/** If stored value if of type T, returns that value. Otherwise,
|
||||
throws boost::bad_any_cast exception. */
|
||||
template<class T>
|
||||
const T& as() const {
|
||||
return boost::any_cast<const T&>(v);
|
||||
}
|
||||
/** @overload */
|
||||
template<class T>
|
||||
T& as() {
|
||||
return boost::any_cast<T&>(v);
|
||||
}
|
||||
|
||||
/// Returns true if no value is stored.
|
||||
bool empty() const;
|
||||
/** Returns true if the value was not explicitly
|
||||
given, but has default value. */
|
||||
bool defaulted() const;
|
||||
/** Returns the contained value. */
|
||||
const boost::any& value() const;
|
||||
|
||||
/** Returns the contained value. */
|
||||
boost::any& value();
|
||||
private:
|
||||
boost::any v;
|
||||
bool m_defaulted;
|
||||
// Internal reference to value semantic. We need to run
|
||||
// notifications when *final* values of options are known, and
|
||||
// they are known only after all sources are stored. By that
|
||||
// time options_description for the first source might not
|
||||
// be easily accessible, so we need to store semantic here.
|
||||
shared_ptr<const value_semantic> m_value_semantic;
|
||||
|
||||
friend BOOST_PROGRAM_OPTIONS_DECL
|
||||
void store(const basic_parsed_options<char>& options,
|
||||
variables_map& m, bool);
|
||||
|
||||
friend class BOOST_PROGRAM_OPTIONS_DECL variables_map;
|
||||
};
|
||||
|
||||
/** Implements string->string mapping with convenient value casting
|
||||
facilities. */
|
||||
class BOOST_PROGRAM_OPTIONS_DECL abstract_variables_map {
|
||||
public:
|
||||
abstract_variables_map();
|
||||
abstract_variables_map(const abstract_variables_map* next);
|
||||
|
||||
virtual ~abstract_variables_map() {}
|
||||
|
||||
/** Obtains the value of variable 'name', from *this and
|
||||
possibly from the chain of variable maps.
|
||||
|
||||
- if there's no value in *this.
|
||||
- if there's next variable map, returns value from it
|
||||
- otherwise, returns empty value
|
||||
|
||||
- if there's defaulted value
|
||||
- if there's next varaible map, which has a non-defauled
|
||||
value, return that
|
||||
- otherwise, return value from *this
|
||||
|
||||
- if there's a non-defauled value, returns it.
|
||||
*/
|
||||
const variable_value& operator[](const std::string& name) const;
|
||||
|
||||
/** Sets next variable map, which will be used to find
|
||||
variables not found in *this. */
|
||||
void next(abstract_variables_map* next);
|
||||
|
||||
private:
|
||||
/** Returns value of variable 'name' stored in *this, or
|
||||
empty value otherwise. */
|
||||
virtual const variable_value& get(const std::string& name) const = 0;
|
||||
|
||||
const abstract_variables_map* m_next;
|
||||
};
|
||||
|
||||
/** Concrete variables map which store variables in real map.
|
||||
|
||||
This class is derived from std::map<std::string, variable_value>,
|
||||
so you can use all map operators to examine its content.
|
||||
*/
|
||||
class BOOST_PROGRAM_OPTIONS_DECL variables_map : public abstract_variables_map,
|
||||
public std::map<std::string, variable_value>
|
||||
{
|
||||
public:
|
||||
variables_map();
|
||||
variables_map(const abstract_variables_map* next);
|
||||
|
||||
// Resolve conflict between inherited operators.
|
||||
const variable_value& operator[](const std::string& name) const
|
||||
{ return abstract_variables_map::operator[](name); }
|
||||
|
||||
// Override to clear some extra fields.
|
||||
void clear();
|
||||
|
||||
void notify();
|
||||
|
||||
private:
|
||||
/** Implementation of abstract_variables_map::get
|
||||
which does 'find' in *this. */
|
||||
const variable_value& get(const std::string& name) const;
|
||||
|
||||
/** Names of option with 'final' values -- which should not
|
||||
be changed by subsequence assignments. */
|
||||
std::set<std::string> m_final;
|
||||
|
||||
friend BOOST_PROGRAM_OPTIONS_DECL
|
||||
void store(const basic_parsed_options<char>& options,
|
||||
variables_map& xm,
|
||||
bool utf8);
|
||||
|
||||
/** Names of required options, filled by parser which has
|
||||
access to options_description.
|
||||
The map values are the "canonical" names for each corresponding option.
|
||||
This is useful in creating diagnostic messages when the option is absent. */
|
||||
std::map<std::string, std::string> m_required;
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Templates/inlines
|
||||
*/
|
||||
|
||||
inline bool
|
||||
variable_value::empty() const
|
||||
{
|
||||
return v.empty();
|
||||
}
|
||||
|
||||
inline bool
|
||||
variable_value::defaulted() const
|
||||
{
|
||||
return m_defaulted;
|
||||
}
|
||||
|
||||
inline
|
||||
const boost::any&
|
||||
variable_value::value() const
|
||||
{
|
||||
return v;
|
||||
}
|
||||
|
||||
inline
|
||||
boost::any&
|
||||
variable_value::value()
|
||||
{
|
||||
return v;
|
||||
}
|
||||
|
||||
}}
|
||||
|
||||
#if defined(BOOST_MSVC)
|
||||
# pragma warning (pop)
|
||||
#endif
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,19 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#ifndef BOOST_PROGRAM_OPTIONS_VERSION_HPP_VP_2004_04_05
|
||||
#define BOOST_PROGRAM_OPTIONS_VERSION_HPP_VP_2004_04_05
|
||||
|
||||
/** The version of the source interface.
|
||||
The value will be incremented whenever a change is made which might
|
||||
cause compilation errors for existing code.
|
||||
*/
|
||||
#ifdef BOOST_PROGRAM_OPTIONS_VERSION
|
||||
#error BOOST_PROGRAM_OPTIONS_VERSION already defined
|
||||
#endif
|
||||
#define BOOST_PROGRAM_OPTIONS_VERSION 2
|
||||
|
||||
|
||||
#endif
|
||||
+716
@@ -0,0 +1,716 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#define BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#include <boost/program_options/detail/cmdline.hpp>
|
||||
#include <boost/program_options/errors.hpp>
|
||||
#include <boost/program_options/value_semantic.hpp>
|
||||
#include <boost/program_options/options_description.hpp>
|
||||
#include <boost/program_options/positional_options.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
#include <cassert>
|
||||
#include <cstring>
|
||||
#include <cctype>
|
||||
#include <climits>
|
||||
|
||||
#include <cstdio>
|
||||
|
||||
#include <iostream>
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
using namespace std;
|
||||
using namespace boost::program_options::command_line_style;
|
||||
|
||||
|
||||
string
|
||||
invalid_syntax::get_template(kind_t kind)
|
||||
{
|
||||
// Initially, store the message in 'const char*' variable,
|
||||
// to avoid conversion to string in all cases.
|
||||
const char* msg;
|
||||
switch(kind)
|
||||
{
|
||||
case empty_adjacent_parameter:
|
||||
msg = "the argument for option '%canonical_option%' should follow immediately after the equal sign";
|
||||
break;
|
||||
case missing_parameter:
|
||||
msg = "the required argument for option '%canonical_option%' is missing";
|
||||
break;
|
||||
case unrecognized_line:
|
||||
msg = "the options configuration file contains an invalid line '%invalid_line%'";
|
||||
break;
|
||||
// none of the following are currently used:
|
||||
case long_not_allowed:
|
||||
msg = "the unabbreviated option '%canonical_option%' is not valid";
|
||||
break;
|
||||
case long_adjacent_not_allowed:
|
||||
msg = "the unabbreviated option '%canonical_option%' does not take any arguments";
|
||||
break;
|
||||
case short_adjacent_not_allowed:
|
||||
msg = "the abbreviated option '%canonical_option%' does not take any arguments";
|
||||
break;
|
||||
case extra_parameter:
|
||||
msg = "option '%canonical_option%' does not take any arguments";
|
||||
break;
|
||||
default:
|
||||
msg = "unknown command line syntax error for '%s'";
|
||||
}
|
||||
return msg;
|
||||
}
|
||||
|
||||
|
||||
}}
|
||||
|
||||
|
||||
namespace boost { namespace program_options { namespace detail {
|
||||
|
||||
// vc6 needs this, but borland chokes when this is added.
|
||||
#if BOOST_WORKAROUND(_MSC_VER, < 1300)
|
||||
using namespace std;
|
||||
using namespace program_options;
|
||||
#endif
|
||||
|
||||
|
||||
cmdline::cmdline(const vector<string>& args)
|
||||
{
|
||||
init(args);
|
||||
}
|
||||
|
||||
cmdline::cmdline(int argc, const char*const * argv)
|
||||
{
|
||||
#if defined(BOOST_NO_TEMPLATED_ITERATOR_CONSTRUCTORS)
|
||||
vector<string> args;
|
||||
copy(argv+1, argv+argc+!argc, inserter(args, args.end()));
|
||||
init(args);
|
||||
#else
|
||||
init(vector<string>(argv+1, argv+argc+!argc));
|
||||
#endif
|
||||
}
|
||||
|
||||
void
|
||||
cmdline::init(const vector<string>& args)
|
||||
{
|
||||
this->args = args;
|
||||
m_style = command_line_style::default_style;
|
||||
m_desc = 0;
|
||||
m_positional = 0;
|
||||
m_allow_unregistered = false;
|
||||
}
|
||||
|
||||
void
|
||||
cmdline::style(int style)
|
||||
{
|
||||
if (style == 0)
|
||||
style = default_style;
|
||||
|
||||
check_style(style);
|
||||
this->m_style = style_t(style);
|
||||
}
|
||||
|
||||
void
|
||||
cmdline::allow_unregistered()
|
||||
{
|
||||
this->m_allow_unregistered = true;
|
||||
}
|
||||
|
||||
void
|
||||
cmdline::check_style(int style) const
|
||||
{
|
||||
bool allow_some_long =
|
||||
(style & allow_long) || (style & allow_long_disguise);
|
||||
|
||||
const char* error = 0;
|
||||
if (allow_some_long &&
|
||||
!(style & long_allow_adjacent) && !(style & long_allow_next))
|
||||
error = "boost::program_options misconfiguration: "
|
||||
"choose one or other of 'command_line_style::long_allow_next' "
|
||||
"(whitespace separated arguments) or "
|
||||
"'command_line_style::long_allow_adjacent' ('=' separated arguments) for "
|
||||
"long options.";
|
||||
|
||||
if (!error && (style & allow_short) &&
|
||||
!(style & short_allow_adjacent) && !(style & short_allow_next))
|
||||
error = "boost::program_options misconfiguration: "
|
||||
"choose one or other of 'command_line_style::short_allow_next' "
|
||||
"(whitespace separated arguments) or "
|
||||
"'command_line_style::short_allow_adjacent' ('=' separated arguments) for "
|
||||
"short options.";
|
||||
|
||||
if (!error && (style & allow_short) &&
|
||||
!(style & allow_dash_for_short) && !(style & allow_slash_for_short))
|
||||
error = "boost::program_options misconfiguration: "
|
||||
"choose one or other of 'command_line_style::allow_slash_for_short' "
|
||||
"(slashes) or 'command_line_style::allow_dash_for_short' (dashes) for "
|
||||
"short options.";
|
||||
|
||||
if (error)
|
||||
boost::throw_exception(invalid_command_line_style(error));
|
||||
|
||||
// Need to check that if guessing and long disguise are enabled
|
||||
// -f will mean the same as -foo
|
||||
}
|
||||
|
||||
bool
|
||||
cmdline::is_style_active(style_t style) const
|
||||
{
|
||||
return ((m_style & style) ? true : false);
|
||||
}
|
||||
|
||||
void
|
||||
cmdline::set_options_description(const options_description& desc)
|
||||
{
|
||||
m_desc = &desc;
|
||||
}
|
||||
|
||||
void
|
||||
cmdline::set_positional_options(
|
||||
const positional_options_description& positional)
|
||||
{
|
||||
m_positional = &positional;
|
||||
}
|
||||
|
||||
int
|
||||
cmdline::get_canonical_option_prefix()
|
||||
{
|
||||
if (m_style & allow_long)
|
||||
return allow_long;
|
||||
|
||||
if (m_style & allow_long_disguise)
|
||||
return allow_long_disguise;
|
||||
|
||||
if ((m_style & allow_short) && (m_style & allow_dash_for_short))
|
||||
return allow_dash_for_short;
|
||||
|
||||
if ((m_style & allow_short) && (m_style & allow_slash_for_short))
|
||||
return allow_slash_for_short;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
vector<option>
|
||||
cmdline::run()
|
||||
{
|
||||
// The parsing is done by having a set of 'style parsers'
|
||||
// and trying then in order. Each parser is passed a vector
|
||||
// of unparsed tokens and can consume some of them (by
|
||||
// removing elements on front) and return a vector of options.
|
||||
//
|
||||
// We try each style parser in turn, untill some input
|
||||
// is consumed. The returned vector of option may contain the
|
||||
// result of just syntactic parsing of token, say --foo will
|
||||
// be parsed as option with name 'foo', and the style parser
|
||||
// is not required to care if that option is defined, and how
|
||||
// many tokens the value may take.
|
||||
// So, after vector is returned, we validate them.
|
||||
assert(m_desc);
|
||||
|
||||
vector<style_parser> style_parsers;
|
||||
|
||||
if (m_style_parser)
|
||||
style_parsers.push_back(m_style_parser);
|
||||
|
||||
if (m_additional_parser)
|
||||
style_parsers.push_back(
|
||||
boost::bind(&cmdline::handle_additional_parser, this, _1));
|
||||
|
||||
if (m_style & allow_long)
|
||||
style_parsers.push_back(
|
||||
boost::bind(&cmdline::parse_long_option, this, _1));
|
||||
|
||||
if ((m_style & allow_long_disguise))
|
||||
style_parsers.push_back(
|
||||
boost::bind(&cmdline::parse_disguised_long_option, this, _1));
|
||||
|
||||
if ((m_style & allow_short) && (m_style & allow_dash_for_short))
|
||||
style_parsers.push_back(
|
||||
boost::bind(&cmdline::parse_short_option, this, _1));
|
||||
|
||||
if ((m_style & allow_short) && (m_style & allow_slash_for_short))
|
||||
style_parsers.push_back(boost::bind(&cmdline::parse_dos_option, this, _1));
|
||||
|
||||
style_parsers.push_back(boost::bind(&cmdline::parse_terminator, this, _1));
|
||||
|
||||
vector<option> result;
|
||||
while(!args.empty())
|
||||
{
|
||||
bool ok = false;
|
||||
for(unsigned i = 0; i < style_parsers.size(); ++i)
|
||||
{
|
||||
unsigned current_size = static_cast<unsigned>(args.size());
|
||||
vector<option> next = style_parsers[i](args);
|
||||
|
||||
// Check that option names
|
||||
// are valid, and that all values are in place.
|
||||
if (!next.empty())
|
||||
{
|
||||
vector<string> e;
|
||||
for(unsigned k = 0; k < next.size()-1; ++k) {
|
||||
finish_option(next[k], e, style_parsers);
|
||||
}
|
||||
// For the last option, pass the unparsed tokens
|
||||
// so that they can be added to next.back()'s values
|
||||
// if appropriate.
|
||||
finish_option(next.back(), args, style_parsers);
|
||||
for (unsigned j = 0; j < next.size(); ++j)
|
||||
result.push_back(next[j]);
|
||||
}
|
||||
|
||||
if (args.size() != current_size) {
|
||||
ok = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!ok) {
|
||||
option opt;
|
||||
opt.value.push_back(args[0]);
|
||||
opt.original_tokens.push_back(args[0]);
|
||||
result.push_back(opt);
|
||||
args.erase(args.begin());
|
||||
}
|
||||
}
|
||||
|
||||
/* If an key option is followed by a positional option,
|
||||
can can consume more tokens (e.g. it's multitoken option),
|
||||
give those tokens to it. */
|
||||
vector<option> result2;
|
||||
for (unsigned i = 0; i < result.size(); ++i)
|
||||
{
|
||||
result2.push_back(result[i]);
|
||||
option& opt = result2.back();
|
||||
|
||||
if (opt.string_key.empty())
|
||||
continue;
|
||||
|
||||
const option_description* xd;
|
||||
try
|
||||
{
|
||||
xd = m_desc->find_nothrow(opt.string_key,
|
||||
is_style_active(allow_guessing),
|
||||
is_style_active(long_case_insensitive),
|
||||
is_style_active(short_case_insensitive));
|
||||
}
|
||||
catch(error_with_option_name& e)
|
||||
{
|
||||
// add context and rethrow
|
||||
e.add_context(opt.string_key, opt.original_tokens[0], get_canonical_option_prefix());
|
||||
throw;
|
||||
}
|
||||
|
||||
if (!xd)
|
||||
continue;
|
||||
|
||||
unsigned min_tokens = xd->semantic()->min_tokens();
|
||||
unsigned max_tokens = xd->semantic()->max_tokens();
|
||||
if (min_tokens < max_tokens && opt.value.size() < max_tokens)
|
||||
{
|
||||
// This option may grab some more tokens.
|
||||
// We only allow to grab tokens that are not already
|
||||
// recognized as key options.
|
||||
|
||||
int can_take_more = max_tokens - static_cast<int>(opt.value.size());
|
||||
unsigned j = i+1;
|
||||
for (; can_take_more && j < result.size(); --can_take_more, ++j)
|
||||
{
|
||||
option& opt2 = result[j];
|
||||
if (!opt2.string_key.empty())
|
||||
break;
|
||||
|
||||
if (opt2.position_key == INT_MAX)
|
||||
{
|
||||
// We use INT_MAX to mark positional options that
|
||||
// were found after the '--' terminator and therefore
|
||||
// should stay positional forever.
|
||||
break;
|
||||
}
|
||||
|
||||
assert(opt2.value.size() == 1);
|
||||
|
||||
opt.value.push_back(opt2.value[0]);
|
||||
|
||||
assert(opt2.original_tokens.size() == 1);
|
||||
|
||||
opt.original_tokens.push_back(opt2.original_tokens[0]);
|
||||
}
|
||||
i = j-1;
|
||||
}
|
||||
}
|
||||
result.swap(result2);
|
||||
|
||||
|
||||
// Assign position keys to positional options.
|
||||
int position_key = 0;
|
||||
for(unsigned i = 0; i < result.size(); ++i) {
|
||||
if (result[i].string_key.empty())
|
||||
result[i].position_key = position_key++;
|
||||
}
|
||||
|
||||
if (m_positional)
|
||||
{
|
||||
unsigned position = 0;
|
||||
for (unsigned i = 0; i < result.size(); ++i) {
|
||||
option& opt = result[i];
|
||||
if (opt.position_key != -1) {
|
||||
if (position >= m_positional->max_total_count())
|
||||
{
|
||||
boost::throw_exception(too_many_positional_options_error());
|
||||
}
|
||||
opt.string_key = m_positional->name_for_position(position);
|
||||
++position;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// set case sensitive flag
|
||||
for (unsigned i = 0; i < result.size(); ++i) {
|
||||
if (result[i].string_key.size() > 2 ||
|
||||
(result[i].string_key.size() > 1 && result[i].string_key[0] != '-'))
|
||||
{
|
||||
// it is a long option
|
||||
result[i].case_insensitive = is_style_active(long_case_insensitive);
|
||||
}
|
||||
else
|
||||
{
|
||||
// it is a short option
|
||||
result[i].case_insensitive = is_style_active(short_case_insensitive);
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void
|
||||
cmdline::finish_option(option& opt,
|
||||
vector<string>& other_tokens,
|
||||
const vector<style_parser>& style_parsers)
|
||||
{
|
||||
if (opt.string_key.empty())
|
||||
return;
|
||||
|
||||
//
|
||||
// Be defensive:
|
||||
// will have no original token if option created by handle_additional_parser()
|
||||
std::string original_token_for_exceptions = opt.string_key;
|
||||
if (opt.original_tokens.size())
|
||||
original_token_for_exceptions = opt.original_tokens[0];
|
||||
|
||||
try
|
||||
{
|
||||
// First check that the option is valid, and get its description.
|
||||
const option_description* xd = m_desc->find_nothrow(opt.string_key,
|
||||
is_style_active(allow_guessing),
|
||||
is_style_active(long_case_insensitive),
|
||||
is_style_active(short_case_insensitive));
|
||||
|
||||
if (!xd)
|
||||
{
|
||||
if (m_allow_unregistered) {
|
||||
opt.unregistered = true;
|
||||
return;
|
||||
} else {
|
||||
boost::throw_exception(unknown_option());
|
||||
}
|
||||
}
|
||||
const option_description& d = *xd;
|
||||
|
||||
// Canonize the name
|
||||
opt.string_key = d.key(opt.string_key);
|
||||
|
||||
// We check that the min/max number of tokens for the option
|
||||
// agrees with the number of tokens we have. The 'adjacent_value'
|
||||
// (the value in --foo=1) counts as a separate token, and if present
|
||||
// must be consumed. The following tokens on the command line may be
|
||||
// left unconsumed.
|
||||
|
||||
// We don't check if those tokens look like option, or not!
|
||||
|
||||
unsigned min_tokens = d.semantic()->min_tokens();
|
||||
unsigned max_tokens = d.semantic()->max_tokens();
|
||||
|
||||
unsigned present_tokens = static_cast<unsigned>(opt.value.size() + other_tokens.size());
|
||||
|
||||
if (present_tokens >= min_tokens)
|
||||
{
|
||||
if (!opt.value.empty() && max_tokens == 0)
|
||||
{
|
||||
boost::throw_exception(
|
||||
invalid_command_line_syntax(invalid_command_line_syntax::extra_parameter));
|
||||
}
|
||||
|
||||
// If an option wants, at minimum, N tokens, we grab them there,
|
||||
// when adding these tokens as values to current option we check
|
||||
// if they look like options
|
||||
if (opt.value.size() <= min_tokens)
|
||||
{
|
||||
min_tokens -= static_cast<unsigned>(opt.value.size());
|
||||
}
|
||||
else
|
||||
{
|
||||
min_tokens = 0;
|
||||
}
|
||||
|
||||
// Everything's OK, move the values to the result.
|
||||
for(;!other_tokens.empty() && min_tokens--; )
|
||||
{
|
||||
// check if extra parameter looks like a known option
|
||||
// we use style parsers to check if it is syntactically an option,
|
||||
// additionally we check if an option_description exists
|
||||
vector<option> followed_option;
|
||||
vector<string> next_token(1, other_tokens[0]);
|
||||
for (unsigned i = 0; followed_option.empty() && i < style_parsers.size(); ++i)
|
||||
{
|
||||
followed_option = style_parsers[i](next_token);
|
||||
}
|
||||
if (!followed_option.empty())
|
||||
{
|
||||
original_token_for_exceptions = other_tokens[0];
|
||||
const option_description* od = m_desc->find_nothrow(other_tokens[0],
|
||||
is_style_active(allow_guessing),
|
||||
is_style_active(long_case_insensitive),
|
||||
is_style_active(short_case_insensitive));
|
||||
if (od)
|
||||
boost::throw_exception(
|
||||
invalid_command_line_syntax(invalid_command_line_syntax::missing_parameter));
|
||||
}
|
||||
opt.value.push_back(other_tokens[0]);
|
||||
opt.original_tokens.push_back(other_tokens[0]);
|
||||
other_tokens.erase(other_tokens.begin());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
boost::throw_exception(
|
||||
invalid_command_line_syntax(invalid_command_line_syntax::missing_parameter));
|
||||
|
||||
}
|
||||
}
|
||||
// use only original token for unknown_option / ambiguous_option since by definition
|
||||
// they are unrecognised / unparsable
|
||||
catch(error_with_option_name& e)
|
||||
{
|
||||
// add context and rethrow
|
||||
e.add_context(opt.string_key, original_token_for_exceptions, get_canonical_option_prefix());
|
||||
throw;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
vector<option>
|
||||
cmdline::parse_long_option(vector<string>& args)
|
||||
{
|
||||
vector<option> result;
|
||||
const string& tok = args[0];
|
||||
if (tok.size() >= 3 && tok[0] == '-' && tok[1] == '-')
|
||||
{
|
||||
string name, adjacent;
|
||||
|
||||
string::size_type p = tok.find('=');
|
||||
if (p != tok.npos)
|
||||
{
|
||||
name = tok.substr(2, p-2);
|
||||
adjacent = tok.substr(p+1);
|
||||
if (adjacent.empty())
|
||||
boost::throw_exception( invalid_command_line_syntax(
|
||||
invalid_command_line_syntax::empty_adjacent_parameter,
|
||||
name,
|
||||
name,
|
||||
get_canonical_option_prefix()) );
|
||||
}
|
||||
else
|
||||
{
|
||||
name = tok.substr(2);
|
||||
}
|
||||
option opt;
|
||||
opt.string_key = name;
|
||||
if (!adjacent.empty())
|
||||
opt.value.push_back(adjacent);
|
||||
opt.original_tokens.push_back(tok);
|
||||
result.push_back(opt);
|
||||
args.erase(args.begin());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
vector<option>
|
||||
cmdline::parse_short_option(vector<string>& args)
|
||||
{
|
||||
const string& tok = args[0];
|
||||
if (tok.size() >= 2 && tok[0] == '-' && tok[1] != '-')
|
||||
{
|
||||
vector<option> result;
|
||||
|
||||
string name = tok.substr(0,2);
|
||||
string adjacent = tok.substr(2);
|
||||
|
||||
// Short options can be 'grouped', so that
|
||||
// "-d -a" becomes "-da". Loop, processing one
|
||||
// option at a time. We exit the loop when either
|
||||
// we've processed all the token, or when the remainder
|
||||
// of token is considered to be value, not further grouped
|
||||
// option.
|
||||
for(;;) {
|
||||
const option_description* d;
|
||||
try
|
||||
{
|
||||
|
||||
d = m_desc->find_nothrow(name, false, false,
|
||||
is_style_active(short_case_insensitive));
|
||||
}
|
||||
catch(error_with_option_name& e)
|
||||
{
|
||||
// add context and rethrow
|
||||
e.add_context(name, name, get_canonical_option_prefix());
|
||||
throw;
|
||||
}
|
||||
|
||||
|
||||
// FIXME: check for 'allow_sticky'.
|
||||
if (d && (m_style & allow_sticky) &&
|
||||
d->semantic()->max_tokens() == 0 && !adjacent.empty()) {
|
||||
// 'adjacent' is in fact further option.
|
||||
option opt;
|
||||
opt.string_key = name;
|
||||
result.push_back(opt);
|
||||
|
||||
if (adjacent.empty())
|
||||
{
|
||||
args.erase(args.begin());
|
||||
break;
|
||||
}
|
||||
|
||||
name = string("-") + adjacent[0];
|
||||
adjacent.erase(adjacent.begin());
|
||||
} else {
|
||||
|
||||
option opt;
|
||||
opt.string_key = name;
|
||||
opt.original_tokens.push_back(tok);
|
||||
if (!adjacent.empty())
|
||||
opt.value.push_back(adjacent);
|
||||
result.push_back(opt);
|
||||
args.erase(args.begin());
|
||||
break;
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
return vector<option>();
|
||||
}
|
||||
|
||||
vector<option>
|
||||
cmdline::parse_dos_option(vector<string>& args)
|
||||
{
|
||||
vector<option> result;
|
||||
const string& tok = args[0];
|
||||
if (tok.size() >= 2 && tok[0] == '/')
|
||||
{
|
||||
string name = "-" + tok.substr(1,1);
|
||||
string adjacent = tok.substr(2);
|
||||
|
||||
option opt;
|
||||
opt.string_key = name;
|
||||
if (!adjacent.empty())
|
||||
opt.value.push_back(adjacent);
|
||||
opt.original_tokens.push_back(tok);
|
||||
result.push_back(opt);
|
||||
args.erase(args.begin());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
vector<option>
|
||||
cmdline::parse_disguised_long_option(vector<string>& args)
|
||||
{
|
||||
const string& tok = args[0];
|
||||
if (tok.size() >= 2 &&
|
||||
((tok[0] == '-' && tok[1] != '-') ||
|
||||
((m_style & allow_slash_for_short) && tok[0] == '/')))
|
||||
{
|
||||
try
|
||||
{
|
||||
if (m_desc->find_nothrow(tok.substr(1, tok.find('=')-1),
|
||||
is_style_active(allow_guessing),
|
||||
is_style_active(long_case_insensitive),
|
||||
is_style_active(short_case_insensitive)))
|
||||
{
|
||||
args[0].insert(0, "-");
|
||||
if (args[0][1] == '/')
|
||||
args[0][1] = '-';
|
||||
return parse_long_option(args);
|
||||
}
|
||||
}
|
||||
catch(error_with_option_name& e)
|
||||
{
|
||||
// add context and rethrow
|
||||
e.add_context(tok, tok, get_canonical_option_prefix());
|
||||
throw;
|
||||
}
|
||||
}
|
||||
return vector<option>();
|
||||
}
|
||||
|
||||
vector<option>
|
||||
cmdline::parse_terminator(vector<string>& args)
|
||||
{
|
||||
vector<option> result;
|
||||
const string& tok = args[0];
|
||||
if (tok == "--")
|
||||
{
|
||||
for(unsigned i = 1; i < args.size(); ++i)
|
||||
{
|
||||
option opt;
|
||||
opt.value.push_back(args[i]);
|
||||
opt.original_tokens.push_back(args[i]);
|
||||
opt.position_key = INT_MAX;
|
||||
result.push_back(opt);
|
||||
}
|
||||
args.clear();
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
vector<option>
|
||||
cmdline::handle_additional_parser(vector<string>& args)
|
||||
{
|
||||
vector<option> result;
|
||||
pair<string, string> r = m_additional_parser(args[0]);
|
||||
if (!r.first.empty()) {
|
||||
option next;
|
||||
next.string_key = r.first;
|
||||
if (!r.second.empty())
|
||||
next.value.push_back(r.second);
|
||||
result.push_back(next);
|
||||
args.erase(args.begin());
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
void
|
||||
cmdline::set_additional_parser(additional_parser p)
|
||||
{
|
||||
m_additional_parser = p;
|
||||
}
|
||||
|
||||
void
|
||||
cmdline::extra_style_parser(style_parser s)
|
||||
{
|
||||
m_style_parser = s;
|
||||
}
|
||||
|
||||
|
||||
|
||||
}}}
|
||||
@@ -0,0 +1,198 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#define BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#include <boost/program_options/detail/config_file.hpp>
|
||||
#include <boost/program_options/errors.hpp>
|
||||
#include <boost/program_options/detail/convert.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <cassert>
|
||||
|
||||
namespace boost { namespace program_options { namespace detail {
|
||||
|
||||
using namespace std;
|
||||
|
||||
common_config_file_iterator::common_config_file_iterator(
|
||||
const std::set<std::string>& allowed_options,
|
||||
bool allow_unregistered)
|
||||
: allowed_options(allowed_options),
|
||||
m_allow_unregistered(allow_unregistered)
|
||||
{
|
||||
for(std::set<std::string>::const_iterator i = allowed_options.begin();
|
||||
i != allowed_options.end();
|
||||
++i)
|
||||
{
|
||||
add_option(i->c_str());
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
common_config_file_iterator::add_option(const char* name)
|
||||
{
|
||||
string s(name);
|
||||
assert(!s.empty());
|
||||
if (*s.rbegin() == '*') {
|
||||
s.resize(s.size()-1);
|
||||
bool bad_prefixes(false);
|
||||
// If 's' is a prefix of one of allowed suffix, then
|
||||
// lower_bound will return that element.
|
||||
// If some element is prefix of 's', then lower_bound will
|
||||
// return the next element.
|
||||
set<string>::iterator i = allowed_prefixes.lower_bound(s);
|
||||
if (i != allowed_prefixes.end()) {
|
||||
if (i->find(s) == 0)
|
||||
bad_prefixes = true;
|
||||
}
|
||||
if (i != allowed_prefixes.begin()) {
|
||||
--i;
|
||||
if (s.find(*i) == 0)
|
||||
bad_prefixes = true;
|
||||
}
|
||||
if (bad_prefixes)
|
||||
boost::throw_exception(error("options '" + string(name) + "' and '" +
|
||||
*i + "*' will both match the same "
|
||||
"arguments from the configuration file"));
|
||||
allowed_prefixes.insert(s);
|
||||
}
|
||||
}
|
||||
|
||||
namespace {
|
||||
string trim_ws(const string& s)
|
||||
{
|
||||
string::size_type n, n2;
|
||||
n = s.find_first_not_of(" \t\r\n");
|
||||
if (n == string::npos)
|
||||
return string();
|
||||
else {
|
||||
n2 = s.find_last_not_of(" \t\r\n");
|
||||
return s.substr(n, n2-n+1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
void common_config_file_iterator::get()
|
||||
{
|
||||
string s;
|
||||
string::size_type n;
|
||||
bool found = false;
|
||||
|
||||
while(this->getline(s)) {
|
||||
|
||||
// strip '#' comments and whitespace
|
||||
if ((n = s.find('#')) != string::npos)
|
||||
s = s.substr(0, n);
|
||||
s = trim_ws(s);
|
||||
|
||||
if (!s.empty()) {
|
||||
// Handle section name
|
||||
if (*s.begin() == '[' && *s.rbegin() == ']') {
|
||||
m_prefix = s.substr(1, s.size()-2);
|
||||
if (*m_prefix.rbegin() != '.')
|
||||
m_prefix += '.';
|
||||
}
|
||||
else if ((n = s.find('=')) != string::npos) {
|
||||
|
||||
string name = m_prefix + trim_ws(s.substr(0, n));
|
||||
string value = trim_ws(s.substr(n+1));
|
||||
|
||||
bool registered = allowed_option(name);
|
||||
if (!registered && !m_allow_unregistered)
|
||||
boost::throw_exception(unknown_option(name));
|
||||
|
||||
found = true;
|
||||
this->value().string_key = name;
|
||||
this->value().value.clear();
|
||||
this->value().value.push_back(value);
|
||||
this->value().unregistered = !registered;
|
||||
this->value().original_tokens.clear();
|
||||
this->value().original_tokens.push_back(name);
|
||||
this->value().original_tokens.push_back(value);
|
||||
break;
|
||||
|
||||
} else {
|
||||
boost::throw_exception(invalid_config_file_syntax(s, invalid_syntax::unrecognized_line));
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!found)
|
||||
found_eof();
|
||||
}
|
||||
|
||||
|
||||
bool
|
||||
common_config_file_iterator::allowed_option(const std::string& s) const
|
||||
{
|
||||
set<string>::const_iterator i = allowed_options.find(s);
|
||||
if (i != allowed_options.end())
|
||||
return true;
|
||||
// If s is "pa" where "p" is allowed prefix then
|
||||
// lower_bound should find the element after "p".
|
||||
// This depends on 'allowed_prefixes' invariant.
|
||||
i = allowed_prefixes.lower_bound(s);
|
||||
if (i != allowed_prefixes.begin() && s.find(*--i) == 0)
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
#if BOOST_WORKAROUND(__COMO_VERSION__, BOOST_TESTED_AT(4303)) || \
|
||||
(defined(__sgi) && BOOST_WORKAROUND(_COMPILER_VERSION, BOOST_TESTED_AT(741)))
|
||||
template<>
|
||||
bool
|
||||
basic_config_file_iterator<wchar_t>::getline(std::string& s)
|
||||
{
|
||||
std::wstring ws;
|
||||
// On Comeau, using two-argument version causes
|
||||
// call to some internal function with std::wstring, and '\n'
|
||||
// (not L'\n') and compile can't resolve that call.
|
||||
|
||||
if (std::getline(*is, ws, L'\n')) {
|
||||
s = to_utf8(ws);
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
}}}
|
||||
|
||||
#if 0
|
||||
using boost::program_options::config_file;
|
||||
|
||||
#include <sstream>
|
||||
#include <cassert>
|
||||
|
||||
int main()
|
||||
{
|
||||
try {
|
||||
stringstream s(
|
||||
"a = 1\n"
|
||||
"b = 2\n");
|
||||
|
||||
config_file cf(s);
|
||||
cf.add_option("a");
|
||||
cf.add_option("b");
|
||||
|
||||
assert(++cf);
|
||||
assert(cf.name() == "a");
|
||||
assert(cf.value() == "1");
|
||||
assert(++cf);
|
||||
assert(cf.name() == "b");
|
||||
assert(cf.value() == "2");
|
||||
assert(!++cf);
|
||||
}
|
||||
catch(exception& e)
|
||||
{
|
||||
cout << e.what() << "\n";
|
||||
}
|
||||
}
|
||||
#endif
|
||||
+161
@@ -0,0 +1,161 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#include <fstream>
|
||||
#include <locale.h>
|
||||
#include <locale>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <locale>
|
||||
#include <stdexcept>
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#define BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/detail/convert.hpp>
|
||||
#include <boost/program_options/detail/utf8_codecvt_facet.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
namespace boost { namespace detail {
|
||||
|
||||
/* Internal function to actually perform conversion.
|
||||
The logic in from_8_bit and to_8_bit function is exactly
|
||||
the same, except that one calls 'in' method of codecvt and another
|
||||
calls the 'out' method, and that syntax difference makes straightforward
|
||||
template implementation impossible.
|
||||
|
||||
This functions takes a 'fun' argument, which should have the same
|
||||
parameters and return type and the in/out methods. The actual converting
|
||||
function will pass functional objects created with boost::bind.
|
||||
Experiments show that the performance loss is less than 10%.
|
||||
*/
|
||||
template<class ToChar, class FromChar, class Fun>
|
||||
std::basic_string<ToChar>
|
||||
convert(const std::basic_string<FromChar>& s, Fun fun)
|
||||
|
||||
{
|
||||
std::basic_string<ToChar> result;
|
||||
|
||||
std::mbstate_t state = std::mbstate_t();
|
||||
|
||||
const FromChar* from = s.data();
|
||||
const FromChar* from_end = s.data() + s.size();
|
||||
// The interface of cvt is not really iterator-like, and it's
|
||||
// not possible the tell the required output size without the conversion.
|
||||
// All we can is convert data by pieces.
|
||||
while(from != from_end) {
|
||||
|
||||
// std::basic_string does not provide non-const pointers to the data,
|
||||
// so converting directly into string is not possible.
|
||||
ToChar buffer[32];
|
||||
|
||||
ToChar* to_next = buffer;
|
||||
// Need variable because boost::bind doesn't work with rvalues.
|
||||
ToChar* to_end = buffer + 32;
|
||||
std::codecvt_base::result r =
|
||||
fun(state, from, from_end, from, buffer, to_end, to_next);
|
||||
|
||||
if (r == std::codecvt_base::error)
|
||||
boost::throw_exception(
|
||||
std::logic_error("character conversion failed"));
|
||||
// 'partial' is not an error, it just means not all source
|
||||
// characters were converted. However, we need to check that at
|
||||
// least one new target character was produced. If not, it means
|
||||
// the source data is incomplete, and since we don't have extra
|
||||
// data to add to source, it's error.
|
||||
if (to_next == buffer)
|
||||
boost::throw_exception(
|
||||
std::logic_error("character conversion failed"));
|
||||
|
||||
// Add converted characters
|
||||
result.append(buffer, to_next);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
}}
|
||||
|
||||
namespace boost {
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::wstring
|
||||
from_8_bit(const std::string& s,
|
||||
const std::codecvt<wchar_t, char, std::mbstate_t>& cvt)
|
||||
{
|
||||
return detail::convert<wchar_t>(
|
||||
s,
|
||||
boost::bind(&std::codecvt<wchar_t, char, mbstate_t>::in,
|
||||
&cvt,
|
||||
_1, _2, _3, _4, _5, _6, _7));
|
||||
}
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string
|
||||
to_8_bit(const std::wstring& s,
|
||||
const std::codecvt<wchar_t, char, std::mbstate_t>& cvt)
|
||||
{
|
||||
return detail::convert<char>(
|
||||
s,
|
||||
boost::bind(&codecvt<wchar_t, char, mbstate_t>::out,
|
||||
&cvt,
|
||||
_1, _2, _3, _4, _5, _6, _7));
|
||||
}
|
||||
|
||||
|
||||
namespace {
|
||||
boost::program_options::detail::utf8_codecvt_facet
|
||||
utf8_facet;
|
||||
}
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::wstring
|
||||
from_utf8(const std::string& s)
|
||||
{
|
||||
return from_8_bit(s, utf8_facet);
|
||||
}
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string
|
||||
to_utf8(const std::wstring& s)
|
||||
{
|
||||
return to_8_bit(s, utf8_facet);
|
||||
}
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::wstring
|
||||
from_local_8_bit(const std::string& s)
|
||||
{
|
||||
typedef codecvt<wchar_t, char, mbstate_t> facet_type;
|
||||
return from_8_bit(s,
|
||||
BOOST_USE_FACET(facet_type, locale()));
|
||||
}
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string
|
||||
to_local_8_bit(const std::wstring& s)
|
||||
{
|
||||
typedef codecvt<wchar_t, char, mbstate_t> facet_type;
|
||||
return to_8_bit(s,
|
||||
BOOST_USE_FACET(facet_type, locale()));
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace program_options
|
||||
{
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string to_internal(const std::string& s)
|
||||
{
|
||||
return s;
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string to_internal(const std::wstring& s)
|
||||
{
|
||||
return to_utf8(s);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@@ -0,0 +1,664 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Copyright Bertolt Mildner 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#define BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/options_description.hpp>
|
||||
// FIXME: this is only to get multiple_occurences class
|
||||
// should move that to a separate headers.
|
||||
#include <boost/program_options/parsers.hpp>
|
||||
|
||||
|
||||
#include <boost/lexical_cast.hpp>
|
||||
#include <boost/tokenizer.hpp>
|
||||
#include <boost/detail/workaround.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
|
||||
#include <cassert>
|
||||
#include <climits>
|
||||
#include <cstring>
|
||||
#include <cstdarg>
|
||||
#include <sstream>
|
||||
#include <iterator>
|
||||
using namespace std;
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
namespace {
|
||||
|
||||
template< class charT >
|
||||
std::basic_string< charT > tolower_(const std::basic_string< charT >& str)
|
||||
{
|
||||
std::basic_string< charT > result;
|
||||
for (typename std::basic_string< charT >::size_type i = 0; i < str.size(); ++i)
|
||||
{
|
||||
result.append(1, static_cast< charT >(std::tolower(str[i])));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
} // unnamed namespace
|
||||
|
||||
|
||||
option_description::option_description()
|
||||
{
|
||||
}
|
||||
|
||||
option_description::
|
||||
option_description(const char* name,
|
||||
const value_semantic* s)
|
||||
: m_value_semantic(s)
|
||||
{
|
||||
this->set_name(name);
|
||||
}
|
||||
|
||||
|
||||
option_description::
|
||||
option_description(const char* name,
|
||||
const value_semantic* s,
|
||||
const char* description)
|
||||
: m_description(description), m_value_semantic(s)
|
||||
{
|
||||
this->set_name(name);
|
||||
}
|
||||
|
||||
option_description::~option_description()
|
||||
{
|
||||
}
|
||||
|
||||
option_description::match_result
|
||||
option_description::match(const std::string& option,
|
||||
bool approx,
|
||||
bool long_ignore_case,
|
||||
bool short_ignore_case) const
|
||||
{
|
||||
match_result result = no_match;
|
||||
|
||||
std::string local_long_name((long_ignore_case ? tolower_(m_long_name) : m_long_name));
|
||||
|
||||
if (!local_long_name.empty()) {
|
||||
|
||||
std::string local_option = (long_ignore_case ? tolower_(option) : option);
|
||||
|
||||
if (*local_long_name.rbegin() == '*')
|
||||
{
|
||||
// The name ends with '*'. Any specified name with the given
|
||||
// prefix is OK.
|
||||
if (local_option.find(local_long_name.substr(0, local_long_name.length()-1))
|
||||
== 0)
|
||||
result = approximate_match;
|
||||
}
|
||||
|
||||
if (local_long_name == local_option)
|
||||
{
|
||||
result = full_match;
|
||||
}
|
||||
else if (approx)
|
||||
{
|
||||
if (local_long_name.find(local_option) == 0)
|
||||
{
|
||||
result = approximate_match;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (result != full_match)
|
||||
{
|
||||
std::string local_option(short_ignore_case ? tolower_(option) : option);
|
||||
std::string local_short_name(short_ignore_case ? tolower_(m_short_name) : m_short_name);
|
||||
|
||||
if (local_short_name == local_option)
|
||||
{
|
||||
result = full_match;
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
const std::string&
|
||||
option_description::key(const std::string& option) const
|
||||
{
|
||||
if (!m_long_name.empty())
|
||||
if (m_long_name.find('*') != string::npos)
|
||||
// The '*' character means we're long_name
|
||||
// matches only part of the input. So, returning
|
||||
// long name will remove some of the information,
|
||||
// and we have to return the option as specified
|
||||
// in the source.
|
||||
return option;
|
||||
else
|
||||
return m_long_name;
|
||||
else
|
||||
return m_short_name;
|
||||
}
|
||||
|
||||
std::string
|
||||
option_description::canonical_display_name(int prefix_style) const
|
||||
{
|
||||
if (!m_long_name.empty())
|
||||
{
|
||||
if (prefix_style == command_line_style::allow_long)
|
||||
return "--" + m_long_name;
|
||||
if (prefix_style == command_line_style::allow_long_disguise)
|
||||
return "-" + m_long_name;
|
||||
}
|
||||
// sanity check: m_short_name[0] should be '-' or '/'
|
||||
if (m_short_name.length() == 2)
|
||||
{
|
||||
if (prefix_style == command_line_style::allow_slash_for_short)
|
||||
return string("/") + m_short_name[1];
|
||||
if (prefix_style == command_line_style::allow_dash_for_short)
|
||||
return string("-") + m_short_name[1];
|
||||
}
|
||||
if (!m_long_name.empty())
|
||||
return m_long_name;
|
||||
else
|
||||
return m_short_name;
|
||||
}
|
||||
|
||||
|
||||
const std::string&
|
||||
option_description::long_name() const
|
||||
{
|
||||
return m_long_name;
|
||||
}
|
||||
|
||||
option_description&
|
||||
option_description::set_name(const char* _name)
|
||||
{
|
||||
std::string name(_name);
|
||||
string::size_type n = name.find(',');
|
||||
if (n != string::npos) {
|
||||
assert(n == name.size()-2);
|
||||
m_long_name = name.substr(0, n);
|
||||
m_short_name = '-' + name.substr(n+1,1);
|
||||
} else {
|
||||
m_long_name = name;
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
const std::string&
|
||||
option_description::description() const
|
||||
{
|
||||
return m_description;
|
||||
}
|
||||
|
||||
shared_ptr<const value_semantic>
|
||||
option_description::semantic() const
|
||||
{
|
||||
return m_value_semantic;
|
||||
}
|
||||
|
||||
std::string
|
||||
option_description::format_name() const
|
||||
{
|
||||
if (!m_short_name.empty())
|
||||
{
|
||||
return m_long_name.empty()
|
||||
? m_short_name
|
||||
: string(m_short_name).append(" [ --").
|
||||
append(m_long_name).append(" ]");
|
||||
}
|
||||
return string("--").append(m_long_name);
|
||||
}
|
||||
|
||||
std::string
|
||||
option_description::format_parameter() const
|
||||
{
|
||||
if (m_value_semantic->max_tokens() != 0)
|
||||
return m_value_semantic->name();
|
||||
else
|
||||
return "";
|
||||
}
|
||||
|
||||
options_description_easy_init::
|
||||
options_description_easy_init(options_description* owner)
|
||||
: owner(owner)
|
||||
{}
|
||||
|
||||
options_description_easy_init&
|
||||
options_description_easy_init::
|
||||
operator()(const char* name,
|
||||
const char* description)
|
||||
{
|
||||
// Create untypes semantic which accepts zero tokens: i.e.
|
||||
// no value can be specified on command line.
|
||||
// FIXME: does not look exception-safe
|
||||
shared_ptr<option_description> d(
|
||||
new option_description(name, new untyped_value(true), description));
|
||||
|
||||
owner->add(d);
|
||||
return *this;
|
||||
}
|
||||
|
||||
options_description_easy_init&
|
||||
options_description_easy_init::
|
||||
operator()(const char* name,
|
||||
const value_semantic* s)
|
||||
{
|
||||
shared_ptr<option_description> d(new option_description(name, s));
|
||||
owner->add(d);
|
||||
return *this;
|
||||
}
|
||||
|
||||
options_description_easy_init&
|
||||
options_description_easy_init::
|
||||
operator()(const char* name,
|
||||
const value_semantic* s,
|
||||
const char* description)
|
||||
{
|
||||
shared_ptr<option_description> d(new option_description(name, s, description));
|
||||
|
||||
owner->add(d);
|
||||
return *this;
|
||||
}
|
||||
|
||||
const unsigned options_description::m_default_line_length = 80;
|
||||
|
||||
options_description::options_description(unsigned line_length,
|
||||
unsigned min_description_length)
|
||||
: m_line_length(line_length)
|
||||
, m_min_description_length(min_description_length)
|
||||
{
|
||||
// we require a space between the option and description parts, so add 1.
|
||||
assert(m_min_description_length < m_line_length - 1);
|
||||
}
|
||||
|
||||
options_description::options_description(const std::string& caption,
|
||||
unsigned line_length,
|
||||
unsigned min_description_length)
|
||||
: m_caption(caption)
|
||||
, m_line_length(line_length)
|
||||
, m_min_description_length(min_description_length)
|
||||
{
|
||||
// we require a space between the option and description parts, so add 1.
|
||||
assert(m_min_description_length < m_line_length - 1);
|
||||
}
|
||||
|
||||
void
|
||||
options_description::add(shared_ptr<option_description> desc)
|
||||
{
|
||||
m_options.push_back(desc);
|
||||
belong_to_group.push_back(false);
|
||||
}
|
||||
|
||||
options_description&
|
||||
options_description::add(const options_description& desc)
|
||||
{
|
||||
shared_ptr<options_description> d(new options_description(desc));
|
||||
groups.push_back(d);
|
||||
|
||||
for (size_t i = 0; i < desc.m_options.size(); ++i) {
|
||||
add(desc.m_options[i]);
|
||||
belong_to_group.back() = true;
|
||||
}
|
||||
|
||||
return *this;
|
||||
}
|
||||
|
||||
options_description_easy_init
|
||||
options_description::add_options()
|
||||
{
|
||||
return options_description_easy_init(this);
|
||||
}
|
||||
|
||||
const option_description&
|
||||
options_description::find(const std::string& name,
|
||||
bool approx,
|
||||
bool long_ignore_case,
|
||||
bool short_ignore_case) const
|
||||
{
|
||||
const option_description* d = find_nothrow(name, approx,
|
||||
long_ignore_case, short_ignore_case);
|
||||
if (!d)
|
||||
boost::throw_exception(unknown_option());
|
||||
return *d;
|
||||
}
|
||||
|
||||
const std::vector< shared_ptr<option_description> >&
|
||||
options_description::options() const
|
||||
{
|
||||
return m_options;
|
||||
}
|
||||
|
||||
const option_description*
|
||||
options_description::find_nothrow(const std::string& name,
|
||||
bool approx,
|
||||
bool long_ignore_case,
|
||||
bool short_ignore_case) const
|
||||
{
|
||||
shared_ptr<option_description> found;
|
||||
bool had_full_match = false;
|
||||
vector<string> approximate_matches;
|
||||
vector<string> full_matches;
|
||||
|
||||
// We use linear search because matching specified option
|
||||
// name with the declared option name need to take care about
|
||||
// case sensitivity and trailing '*' and so we can't use simple map.
|
||||
for(unsigned i = 0; i < m_options.size(); ++i)
|
||||
{
|
||||
option_description::match_result r =
|
||||
m_options[i]->match(name, approx, long_ignore_case, short_ignore_case);
|
||||
|
||||
if (r == option_description::no_match)
|
||||
continue;
|
||||
|
||||
if (r == option_description::full_match)
|
||||
{
|
||||
full_matches.push_back(m_options[i]->key(name));
|
||||
found = m_options[i];
|
||||
had_full_match = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// FIXME: the use of 'key' here might not
|
||||
// be the best approach.
|
||||
approximate_matches.push_back(m_options[i]->key(name));
|
||||
if (!had_full_match)
|
||||
found = m_options[i];
|
||||
}
|
||||
}
|
||||
if (full_matches.size() > 1)
|
||||
boost::throw_exception(ambiguous_option(full_matches));
|
||||
|
||||
// If we have a full match, and an approximate match,
|
||||
// ignore approximate match instead of reporting error.
|
||||
// Say, if we have options "all" and "all-chroots", then
|
||||
// "--all" on the command line should select the first one,
|
||||
// without ambiguity.
|
||||
if (full_matches.empty() && approximate_matches.size() > 1)
|
||||
boost::throw_exception(ambiguous_option(approximate_matches));
|
||||
|
||||
return found.get();
|
||||
}
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL
|
||||
std::ostream& operator<<(std::ostream& os, const options_description& desc)
|
||||
{
|
||||
desc.print(os);
|
||||
return os;
|
||||
}
|
||||
|
||||
namespace {
|
||||
|
||||
/* Given a string 'par', that contains no newline characters
|
||||
outputs it to 'os' with wordwrapping, that is, as several
|
||||
line.
|
||||
|
||||
Each output line starts with 'indent' space characters,
|
||||
following by characters from 'par'. The total length of
|
||||
line is no longer than 'line_length'.
|
||||
|
||||
*/
|
||||
void format_paragraph(std::ostream& os,
|
||||
std::string par,
|
||||
unsigned indent,
|
||||
unsigned line_length)
|
||||
{
|
||||
// Through reminder of this function, 'line_length' will
|
||||
// be the length available for characters, not including
|
||||
// indent.
|
||||
assert(indent < line_length);
|
||||
line_length -= indent;
|
||||
|
||||
// index of tab (if present) is used as additional indent relative
|
||||
// to first_column_width if paragrapth is spanned over multiple
|
||||
// lines if tab is not on first line it is ignored
|
||||
string::size_type par_indent = par.find('\t');
|
||||
|
||||
if (par_indent == string::npos)
|
||||
{
|
||||
par_indent = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
// only one tab per paragraph allowed
|
||||
if (count(par.begin(), par.end(), '\t') > 1)
|
||||
{
|
||||
boost::throw_exception(program_options::error(
|
||||
"Only one tab per paragraph is allowed in the options description"));
|
||||
}
|
||||
|
||||
// erase tab from string
|
||||
par.erase(par_indent, 1);
|
||||
|
||||
// this assert may fail due to user error or
|
||||
// environment conditions!
|
||||
assert(par_indent < line_length);
|
||||
|
||||
// ignore tab if not on first line
|
||||
if (par_indent >= line_length)
|
||||
{
|
||||
par_indent = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (par.size() < line_length)
|
||||
{
|
||||
os << par;
|
||||
}
|
||||
else
|
||||
{
|
||||
string::const_iterator line_begin = par.begin();
|
||||
const string::const_iterator par_end = par.end();
|
||||
|
||||
bool first_line = true; // of current paragraph!
|
||||
|
||||
while (line_begin < par_end) // paragraph lines
|
||||
{
|
||||
if (!first_line)
|
||||
{
|
||||
// If line starts with space, but second character
|
||||
// is not space, remove the leading space.
|
||||
// We don't remove double spaces because those
|
||||
// might be intentianal.
|
||||
if ((*line_begin == ' ') &&
|
||||
((line_begin + 1 < par_end) &&
|
||||
(*(line_begin + 1) != ' ')))
|
||||
{
|
||||
line_begin += 1; // line_begin != line_end
|
||||
}
|
||||
}
|
||||
|
||||
// Take care to never increment the iterator past
|
||||
// the end, since MSVC 8.0 (brokenly), assumes that
|
||||
// doing that, even if no access happens, is a bug.
|
||||
unsigned remaining = static_cast<unsigned>(std::distance(line_begin, par_end));
|
||||
string::const_iterator line_end = line_begin +
|
||||
((remaining < line_length) ? remaining : line_length);
|
||||
|
||||
// prevent chopped words
|
||||
// Is line_end between two non-space characters?
|
||||
if ((*(line_end - 1) != ' ') &&
|
||||
((line_end < par_end) && (*line_end != ' ')))
|
||||
{
|
||||
// find last ' ' in the second half of the current paragraph line
|
||||
string::const_iterator last_space =
|
||||
find(reverse_iterator<string::const_iterator>(line_end),
|
||||
reverse_iterator<string::const_iterator>(line_begin),
|
||||
' ')
|
||||
.base();
|
||||
|
||||
if (last_space != line_begin)
|
||||
{
|
||||
// is last_space within the second half ot the
|
||||
// current line
|
||||
if (static_cast<unsigned>(std::distance(last_space, line_end)) <
|
||||
(line_length / 2))
|
||||
{
|
||||
line_end = last_space;
|
||||
}
|
||||
}
|
||||
} // prevent chopped words
|
||||
|
||||
// write line to stream
|
||||
copy(line_begin, line_end, ostream_iterator<char>(os));
|
||||
|
||||
if (first_line)
|
||||
{
|
||||
indent += static_cast<unsigned>(par_indent);
|
||||
line_length -= static_cast<unsigned>(par_indent); // there's less to work with now
|
||||
first_line = false;
|
||||
}
|
||||
|
||||
// more lines to follow?
|
||||
if (line_end != par_end)
|
||||
{
|
||||
os << '\n';
|
||||
|
||||
for(unsigned pad = indent; pad > 0; --pad)
|
||||
{
|
||||
os.put(' ');
|
||||
}
|
||||
}
|
||||
|
||||
// next line starts after of this line
|
||||
line_begin = line_end;
|
||||
} // paragraph lines
|
||||
}
|
||||
}
|
||||
|
||||
void format_description(std::ostream& os,
|
||||
const std::string& desc,
|
||||
unsigned first_column_width,
|
||||
unsigned line_length)
|
||||
{
|
||||
// we need to use one char less per line to work correctly if actual
|
||||
// console has longer lines
|
||||
assert(line_length > 1);
|
||||
if (line_length > 1)
|
||||
{
|
||||
--line_length;
|
||||
}
|
||||
|
||||
// line_length must be larger than first_column_width
|
||||
// this assert may fail due to user error or environment conditions!
|
||||
assert(line_length > first_column_width);
|
||||
|
||||
// Note: can't use 'tokenizer' as name of typedef -- borland
|
||||
// will consider uses of 'tokenizer' below as uses of
|
||||
// boost::tokenizer, not typedef.
|
||||
typedef boost::tokenizer<boost::char_separator<char> > tok;
|
||||
|
||||
tok paragraphs(
|
||||
desc,
|
||||
char_separator<char>("\n", "", boost::keep_empty_tokens));
|
||||
|
||||
tok::const_iterator par_iter = paragraphs.begin();
|
||||
const tok::const_iterator par_end = paragraphs.end();
|
||||
|
||||
while (par_iter != par_end) // paragraphs
|
||||
{
|
||||
format_paragraph(os, *par_iter, first_column_width,
|
||||
line_length);
|
||||
|
||||
++par_iter;
|
||||
|
||||
// prepair next line if any
|
||||
if (par_iter != par_end)
|
||||
{
|
||||
os << '\n';
|
||||
|
||||
for(unsigned pad = first_column_width; pad > 0; --pad)
|
||||
{
|
||||
os.put(' ');
|
||||
}
|
||||
}
|
||||
} // paragraphs
|
||||
}
|
||||
|
||||
void format_one(std::ostream& os, const option_description& opt,
|
||||
unsigned first_column_width, unsigned line_length)
|
||||
{
|
||||
stringstream ss;
|
||||
ss << " " << opt.format_name() << ' ' << opt.format_parameter();
|
||||
|
||||
// Don't use ss.rdbuf() since g++ 2.96 is buggy on it.
|
||||
os << ss.str();
|
||||
|
||||
if (!opt.description().empty())
|
||||
{
|
||||
if (ss.str().size() >= first_column_width)
|
||||
{
|
||||
os.put('\n'); // first column is too long, lets put description in new line
|
||||
for (unsigned pad = first_column_width; pad > 0; --pad)
|
||||
{
|
||||
os.put(' ');
|
||||
}
|
||||
} else {
|
||||
for(unsigned pad = first_column_width - static_cast<unsigned>(ss.str().size()); pad > 0; --pad)
|
||||
{
|
||||
os.put(' ');
|
||||
}
|
||||
}
|
||||
|
||||
format_description(os, opt.description(),
|
||||
first_column_width, line_length);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
unsigned
|
||||
options_description::get_option_column_width() const
|
||||
{
|
||||
/* Find the maximum width of the option column */
|
||||
unsigned width(23);
|
||||
unsigned i; // vc6 has broken for loop scoping
|
||||
for (i = 0; i < m_options.size(); ++i)
|
||||
{
|
||||
const option_description& opt = *m_options[i];
|
||||
stringstream ss;
|
||||
ss << " " << opt.format_name() << ' ' << opt.format_parameter();
|
||||
width = (max)(width, static_cast<unsigned>(ss.str().size()));
|
||||
}
|
||||
|
||||
/* Get width of groups as well*/
|
||||
for (unsigned j = 0; j < groups.size(); ++j)
|
||||
width = max(width, groups[j]->get_option_column_width());
|
||||
|
||||
/* this is the column were description should start, if first
|
||||
column is longer, we go to a new line */
|
||||
const unsigned start_of_description_column = m_line_length - m_min_description_length;
|
||||
|
||||
width = (min)(width, start_of_description_column-1);
|
||||
|
||||
/* add an additional space to improve readability */
|
||||
++width;
|
||||
return width;
|
||||
}
|
||||
|
||||
void
|
||||
options_description::print(std::ostream& os, unsigned width) const
|
||||
{
|
||||
if (!m_caption.empty())
|
||||
os << m_caption << ":\n";
|
||||
|
||||
if (!width)
|
||||
width = get_option_column_width();
|
||||
|
||||
/* The options formatting style is stolen from Subversion. */
|
||||
for (unsigned i = 0; i < m_options.size(); ++i)
|
||||
{
|
||||
if (belong_to_group[i])
|
||||
continue;
|
||||
|
||||
const option_description& opt = *m_options[i];
|
||||
|
||||
format_one(os, opt, width, m_line_length);
|
||||
|
||||
os << "\n";
|
||||
}
|
||||
|
||||
for (unsigned j = 0; j < groups.size(); ++j) {
|
||||
os << "\n";
|
||||
groups[j]->print(os, width);
|
||||
}
|
||||
}
|
||||
|
||||
}}
|
||||
+249
@@ -0,0 +1,249 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#include <boost/config.hpp>
|
||||
|
||||
#define BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/parsers.hpp>
|
||||
#include <boost/program_options/options_description.hpp>
|
||||
#include <boost/program_options/positional_options.hpp>
|
||||
#include <boost/program_options/detail/cmdline.hpp>
|
||||
#include <boost/program_options/detail/config_file.hpp>
|
||||
#include <boost/program_options/environment_iterator.hpp>
|
||||
#include <boost/program_options/detail/convert.hpp>
|
||||
|
||||
#include <boost/bind.hpp>
|
||||
#include <boost/throw_exception.hpp>
|
||||
|
||||
#include <cctype>
|
||||
#include <fstream>
|
||||
|
||||
#if !defined(__GNUC__) || __GNUC__ < 3
|
||||
#include <iostream>
|
||||
#else
|
||||
#include <istream>
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
#include <stdlib.h>
|
||||
#else
|
||||
#include <unistd.h>
|
||||
#endif
|
||||
|
||||
// The 'environ' should be declared in some cases. E.g. Linux man page says:
|
||||
// (This variable must be declared in the user program, but is declared in
|
||||
// the header file unistd.h in case the header files came from libc4 or libc5,
|
||||
// and in case they came from glibc and _GNU_SOURCE was defined.)
|
||||
// To be safe, declare it here.
|
||||
|
||||
// It appears that on Mac OS X the 'environ' variable is not
|
||||
// available to dynamically linked libraries.
|
||||
// See: http://article.gmane.org/gmane.comp.lib.boost.devel/103843
|
||||
// See: http://lists.gnu.org/archive/html/bug-guile/2004-01/msg00013.html
|
||||
#if defined(__APPLE__) && defined(__DYNAMIC__)
|
||||
// The proper include for this is crt_externs.h, however it's not
|
||||
// available on iOS. The right replacement is not known. See
|
||||
// https://svn.boost.org/trac/boost/ticket/5053
|
||||
extern "C" { extern char ***_NSGetEnviron(void); }
|
||||
#define environ (*_NSGetEnviron())
|
||||
#else
|
||||
#if defined(__MWERKS__)
|
||||
#include <crtl.h>
|
||||
#else
|
||||
#if !defined(_WIN32) || defined(__COMO_VERSION__)
|
||||
extern char** environ;
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
using namespace std;
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
namespace {
|
||||
woption woption_from_option(const option& opt)
|
||||
{
|
||||
woption result;
|
||||
result.string_key = opt.string_key;
|
||||
result.position_key = opt.position_key;
|
||||
result.unregistered = opt.unregistered;
|
||||
|
||||
std::transform(opt.value.begin(), opt.value.end(),
|
||||
back_inserter(result.value),
|
||||
boost::bind(from_utf8, _1));
|
||||
|
||||
std::transform(opt.original_tokens.begin(),
|
||||
opt.original_tokens.end(),
|
||||
back_inserter(result.original_tokens),
|
||||
boost::bind(from_utf8, _1));
|
||||
return result;
|
||||
}
|
||||
}
|
||||
|
||||
basic_parsed_options<wchar_t>
|
||||
::basic_parsed_options(const parsed_options& po)
|
||||
: description(po.description),
|
||||
utf8_encoded_options(po),
|
||||
m_options_prefix(po.m_options_prefix)
|
||||
{
|
||||
for (unsigned i = 0; i < po.options.size(); ++i)
|
||||
options.push_back(woption_from_option(po.options[i]));
|
||||
}
|
||||
#endif
|
||||
|
||||
template<class charT>
|
||||
basic_parsed_options<charT>
|
||||
parse_config_file(std::basic_istream<charT>& is,
|
||||
const options_description& desc,
|
||||
bool allow_unregistered)
|
||||
{
|
||||
set<string> allowed_options;
|
||||
|
||||
const vector<shared_ptr<option_description> >& options = desc.options();
|
||||
for (unsigned i = 0; i < options.size(); ++i)
|
||||
{
|
||||
const option_description& d = *options[i];
|
||||
|
||||
if (d.long_name().empty())
|
||||
boost::throw_exception(
|
||||
error("abbreviated option names are not permitted in options configuration files"));
|
||||
|
||||
allowed_options.insert(d.long_name());
|
||||
}
|
||||
|
||||
// Parser return char strings
|
||||
parsed_options result(&desc);
|
||||
copy(detail::basic_config_file_iterator<charT>(
|
||||
is, allowed_options, allow_unregistered),
|
||||
detail::basic_config_file_iterator<charT>(),
|
||||
back_inserter(result.options));
|
||||
// Convert char strings into desired type.
|
||||
return basic_parsed_options<charT>(result);
|
||||
}
|
||||
|
||||
template
|
||||
BOOST_PROGRAM_OPTIONS_DECL basic_parsed_options<char>
|
||||
parse_config_file(std::basic_istream<char>& is,
|
||||
const options_description& desc,
|
||||
bool allow_unregistered);
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
template
|
||||
BOOST_PROGRAM_OPTIONS_DECL basic_parsed_options<wchar_t>
|
||||
parse_config_file(std::basic_istream<wchar_t>& is,
|
||||
const options_description& desc,
|
||||
bool allow_unregistered);
|
||||
#endif
|
||||
|
||||
template<class charT>
|
||||
basic_parsed_options<charT>
|
||||
parse_config_file(const char* filename,
|
||||
const options_description& desc,
|
||||
bool allow_unregistered)
|
||||
{
|
||||
// Parser return char strings
|
||||
std::basic_ifstream< charT > strm(filename);
|
||||
if (!strm)
|
||||
{
|
||||
boost::throw_exception(reading_file(filename));
|
||||
}
|
||||
return parse_config_file(strm, desc, allow_unregistered);
|
||||
}
|
||||
|
||||
template
|
||||
BOOST_PROGRAM_OPTIONS_DECL basic_parsed_options<char>
|
||||
parse_config_file(const char* filename,
|
||||
const options_description& desc,
|
||||
bool allow_unregistered);
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
template
|
||||
BOOST_PROGRAM_OPTIONS_DECL basic_parsed_options<wchar_t>
|
||||
parse_config_file(const char* filename,
|
||||
const options_description& desc,
|
||||
bool allow_unregistered);
|
||||
#endif
|
||||
|
||||
|
||||
// This versio, which accepts any options without validation, is disabled,
|
||||
// in the hope that nobody will need it and we cant drop it altogether.
|
||||
// Besides, probably the right way to handle all options is the '*' name.
|
||||
#if 0
|
||||
BOOST_PROGRAM_OPTIONS_DECL parsed_options
|
||||
parse_config_file(std::istream& is)
|
||||
{
|
||||
detail::config_file_iterator cf(is, false);
|
||||
parsed_options result(0);
|
||||
copy(cf, detail::config_file_iterator(),
|
||||
back_inserter(result.options));
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL parsed_options
|
||||
parse_environment(const options_description& desc,
|
||||
const function1<std::string, std::string>& name_mapper)
|
||||
{
|
||||
parsed_options result(&desc);
|
||||
|
||||
for(environment_iterator i(environ), e; i != e; ++i) {
|
||||
string option_name = name_mapper(i->first);
|
||||
|
||||
if (!option_name.empty()) {
|
||||
option n;
|
||||
n.string_key = option_name;
|
||||
n.value.push_back(i->second);
|
||||
result.options.push_back(n);
|
||||
}
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
namespace detail {
|
||||
class prefix_name_mapper {
|
||||
public:
|
||||
prefix_name_mapper(const std::string& prefix)
|
||||
: prefix(prefix)
|
||||
{}
|
||||
|
||||
std::string operator()(const std::string& s)
|
||||
{
|
||||
string result;
|
||||
if (s.find(prefix) == 0) {
|
||||
for(string::size_type n = prefix.size(); n < s.size(); ++n)
|
||||
{
|
||||
// Intel-Win-7.1 does not understand
|
||||
// push_back on string.
|
||||
result += tolower(s[n]);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
private:
|
||||
std::string prefix;
|
||||
};
|
||||
}
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL parsed_options
|
||||
parse_environment(const options_description& desc,
|
||||
const std::string& prefix)
|
||||
{
|
||||
return parse_environment(desc, detail::prefix_name_mapper(prefix));
|
||||
}
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL parsed_options
|
||||
parse_environment(const options_description& desc, const char* prefix)
|
||||
{
|
||||
return parse_environment(desc, string(prefix));
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
}}
|
||||
@@ -0,0 +1,53 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#define BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#include <boost/program_options/positional_options.hpp>
|
||||
|
||||
#include <boost/limits.hpp>
|
||||
|
||||
#include <cassert>
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
positional_options_description::positional_options_description()
|
||||
{}
|
||||
|
||||
positional_options_description&
|
||||
positional_options_description::add(const char* name, int max_count)
|
||||
{
|
||||
assert(max_count != -1 || m_trailing.empty());
|
||||
|
||||
if (max_count == -1)
|
||||
m_trailing = name;
|
||||
else {
|
||||
m_names.resize(m_names.size() + max_count, name);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
||||
unsigned
|
||||
positional_options_description::max_total_count() const
|
||||
{
|
||||
return m_trailing.empty() ?
|
||||
static_cast<unsigned>(m_names.size()) : (std::numeric_limits<unsigned>::max)();
|
||||
}
|
||||
|
||||
const std::string&
|
||||
positional_options_description::name_for_position(unsigned position) const
|
||||
{
|
||||
assert(position < max_total_count());
|
||||
|
||||
if (position < m_names.size())
|
||||
return m_names[position];
|
||||
else
|
||||
return m_trailing;
|
||||
}
|
||||
|
||||
|
||||
}}
|
||||
|
||||
@@ -0,0 +1,62 @@
|
||||
// Copyright Sascha Ochsenknecht 2009.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#define BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
|
||||
#include <boost/program_options/parsers.hpp>
|
||||
#include <boost/tokenizer.hpp>
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace boost { namespace program_options { namespace detail {
|
||||
|
||||
template< class charT >
|
||||
std::vector<std::basic_string<charT> >
|
||||
split_unix(
|
||||
const std::basic_string<charT>& cmdline,
|
||||
const std::basic_string<charT>& seperator,
|
||||
const std::basic_string<charT>& quote,
|
||||
const std::basic_string<charT>& escape)
|
||||
{
|
||||
typedef boost::tokenizer< boost::escaped_list_separator<charT>,
|
||||
typename std::basic_string<charT>::const_iterator,
|
||||
std::basic_string<charT> > tokenizerT;
|
||||
|
||||
tokenizerT tok(cmdline.begin(), cmdline.end(),
|
||||
boost::escaped_list_separator< charT >(escape, seperator, quote));
|
||||
|
||||
std::vector< std::basic_string<charT> > result;
|
||||
for (typename tokenizerT::iterator cur_token(tok.begin()), end_token(tok.end()); cur_token != end_token; ++cur_token) {
|
||||
if (!cur_token->empty())
|
||||
result.push_back(*cur_token);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
}}} // namespace
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
// Take a command line string and splits in into tokens, according
|
||||
// to the given collection of seperators chars.
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::vector<std::string>
|
||||
split_unix(const std::string& cmdline, const std::string& seperator,
|
||||
const std::string& quote, const std::string& escape)
|
||||
{
|
||||
return detail::split_unix< char >(cmdline, seperator, quote, escape);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::vector<std::wstring>
|
||||
split_unix(const std::wstring& cmdline, const std::wstring& seperator,
|
||||
const std::wstring& quote, const std::wstring& escape)
|
||||
{
|
||||
return detail::split_unix< wchar_t >(cmdline, seperator, quote, escape);
|
||||
}
|
||||
#endif
|
||||
|
||||
}} // namespace
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#define BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
#include <boost/program_options/config.hpp>
|
||||
|
||||
#define BOOST_UTF8_BEGIN_NAMESPACE \
|
||||
namespace boost { namespace program_options { namespace detail {
|
||||
|
||||
#define BOOST_UTF8_END_NAMESPACE }}}
|
||||
#define BOOST_UTF8_DECL BOOST_PROGRAM_OPTIONS_DECL
|
||||
|
||||
#include <boost/detail/utf8_codecvt_facet.ipp>
|
||||
|
||||
|
||||
#undef BOOST_UTF8_BEGIN_NAMESPACE
|
||||
#undef BOOST_UTF8_END_NAMESPACE
|
||||
#undef BOOST_UTF8_DECL
|
||||
|
||||
@@ -0,0 +1,428 @@
|
||||
// Copyright Vladimir Prus 2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#define BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/value_semantic.hpp>
|
||||
#include <boost/program_options/detail/convert.hpp>
|
||||
#include <boost/program_options/detail/cmdline.hpp>
|
||||
#include <set>
|
||||
|
||||
#include <cctype>
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
using namespace std;
|
||||
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
namespace
|
||||
{
|
||||
std::string convert_value(const std::wstring& s)
|
||||
{
|
||||
try {
|
||||
return to_local_8_bit(s);
|
||||
}
|
||||
catch(const std::exception&) {
|
||||
return "<unrepresentable unicode string>";
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
void
|
||||
value_semantic_codecvt_helper<char>::
|
||||
parse(boost::any& value_store,
|
||||
const std::vector<std::string>& new_tokens,
|
||||
bool utf8) const
|
||||
{
|
||||
if (utf8) {
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
// Need to convert to local encoding.
|
||||
std::vector<string> local_tokens;
|
||||
for (unsigned i = 0; i < new_tokens.size(); ++i) {
|
||||
std::wstring w = from_utf8(new_tokens[i]);
|
||||
local_tokens.push_back(to_local_8_bit(w));
|
||||
}
|
||||
xparse(value_store, local_tokens);
|
||||
#else
|
||||
boost::throw_exception(
|
||||
std::runtime_error("UTF-8 conversion not supported."));
|
||||
#endif
|
||||
} else {
|
||||
// Already in local encoding, pass unmodified
|
||||
xparse(value_store, new_tokens);
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
void
|
||||
value_semantic_codecvt_helper<wchar_t>::
|
||||
parse(boost::any& value_store,
|
||||
const std::vector<std::string>& new_tokens,
|
||||
bool utf8) const
|
||||
{
|
||||
std::vector<wstring> tokens;
|
||||
if (utf8) {
|
||||
// Convert from utf8
|
||||
for (unsigned i = 0; i < new_tokens.size(); ++i) {
|
||||
tokens.push_back(from_utf8(new_tokens[i]));
|
||||
}
|
||||
|
||||
} else {
|
||||
// Convert from local encoding
|
||||
for (unsigned i = 0; i < new_tokens.size(); ++i) {
|
||||
tokens.push_back(from_local_8_bit(new_tokens[i]));
|
||||
}
|
||||
}
|
||||
|
||||
xparse(value_store, tokens);
|
||||
}
|
||||
#endif
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::string arg("arg");
|
||||
|
||||
std::string
|
||||
untyped_value::name() const
|
||||
{
|
||||
return arg;
|
||||
}
|
||||
|
||||
unsigned
|
||||
untyped_value::min_tokens() const
|
||||
{
|
||||
if (m_zero_tokens)
|
||||
return 0;
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
|
||||
unsigned
|
||||
untyped_value::max_tokens() const
|
||||
{
|
||||
if (m_zero_tokens)
|
||||
return 0;
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
void
|
||||
untyped_value::xparse(boost::any& value_store,
|
||||
const std::vector<std::string>& new_tokens) const
|
||||
{
|
||||
if (!value_store.empty())
|
||||
boost::throw_exception(
|
||||
multiple_occurrences());
|
||||
if (new_tokens.size() > 1)
|
||||
boost::throw_exception(multiple_values());
|
||||
value_store = new_tokens.empty() ? std::string("") : new_tokens.front();
|
||||
}
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL typed_value<bool>*
|
||||
bool_switch()
|
||||
{
|
||||
return bool_switch(0);
|
||||
}
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL typed_value<bool>*
|
||||
bool_switch(bool* v)
|
||||
{
|
||||
typed_value<bool>* r = new typed_value<bool>(v);
|
||||
r->default_value(0);
|
||||
r->zero_tokens();
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
/* Validates bool value.
|
||||
Any of "1", "true", "yes", "on" will be converted to "1".<br>
|
||||
Any of "0", "false", "no", "off" will be converted to "0".<br>
|
||||
Case is ignored. The 'xs' vector can either be empty, in which
|
||||
case the value is 'true', or can contain explicit value.
|
||||
*/
|
||||
BOOST_PROGRAM_OPTIONS_DECL void validate(any& v, const vector<string>& xs,
|
||||
bool*, int)
|
||||
{
|
||||
check_first_occurrence(v);
|
||||
string s(get_single_string(xs, true));
|
||||
|
||||
for (size_t i = 0; i < s.size(); ++i)
|
||||
s[i] = char(tolower(s[i]));
|
||||
|
||||
if (s.empty() || s == "on" || s == "yes" || s == "1" || s == "true")
|
||||
v = any(true);
|
||||
else if (s == "off" || s == "no" || s == "0" || s == "false")
|
||||
v = any(false);
|
||||
else
|
||||
boost::throw_exception(invalid_bool_value(s));
|
||||
}
|
||||
|
||||
// This is blatant copy-paste. However, templating this will cause a problem,
|
||||
// since wstring can't be constructed/compared with char*. We'd need to
|
||||
// create auxiliary 'widen' routine to convert from char* into
|
||||
// needed string type, and that's more work.
|
||||
#if !defined(BOOST_NO_STD_WSTRING)
|
||||
BOOST_PROGRAM_OPTIONS_DECL
|
||||
void validate(any& v, const vector<wstring>& xs, bool*, int)
|
||||
{
|
||||
check_first_occurrence(v);
|
||||
wstring s(get_single_string(xs, true));
|
||||
|
||||
for (size_t i = 0; i < s.size(); ++i)
|
||||
s[i] = wchar_t(tolower(s[i]));
|
||||
|
||||
if (s.empty() || s == L"on" || s == L"yes" || s == L"1" || s == L"true")
|
||||
v = any(true);
|
||||
else if (s == L"off" || s == L"no" || s == L"0" || s == L"false")
|
||||
v = any(false);
|
||||
else
|
||||
boost::throw_exception(invalid_bool_value(convert_value(s)));
|
||||
}
|
||||
#endif
|
||||
BOOST_PROGRAM_OPTIONS_DECL
|
||||
void validate(any& v, const vector<string>& xs, std::string*, int)
|
||||
{
|
||||
check_first_occurrence(v);
|
||||
v = any(get_single_string(xs));
|
||||
}
|
||||
|
||||
#if !defined(BOOST_NO_STD_WSTRING)
|
||||
BOOST_PROGRAM_OPTIONS_DECL
|
||||
void validate(any& v, const vector<wstring>& xs, std::string*, int)
|
||||
{
|
||||
check_first_occurrence(v);
|
||||
v = any(get_single_string(xs));
|
||||
}
|
||||
#endif
|
||||
|
||||
namespace validators {
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL
|
||||
void check_first_occurrence(const boost::any& value)
|
||||
{
|
||||
if (!value.empty())
|
||||
boost::throw_exception(
|
||||
multiple_occurrences());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
invalid_option_value::
|
||||
invalid_option_value(const std::string& bad_value)
|
||||
: validation_error(validation_error::invalid_option_value)
|
||||
{
|
||||
set_substitute("value", bad_value);
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
invalid_option_value::
|
||||
invalid_option_value(const std::wstring& bad_value)
|
||||
: validation_error(validation_error::invalid_option_value)
|
||||
{
|
||||
set_substitute("value", convert_value(bad_value));
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
invalid_bool_value::
|
||||
invalid_bool_value(const std::string& bad_value)
|
||||
: validation_error(validation_error::invalid_bool_value)
|
||||
{
|
||||
set_substitute("value", bad_value);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
error_with_option_name::error_with_option_name( const std::string& template_,
|
||||
const std::string& option_name,
|
||||
const std::string& original_token,
|
||||
int option_style) :
|
||||
error(template_),
|
||||
m_option_style(option_style),
|
||||
m_error_template(template_)
|
||||
{
|
||||
// parameter | placeholder | value
|
||||
// --------- | ----------- | -----
|
||||
set_substitute_default("canonical_option", "option '%canonical_option%'", "option");
|
||||
set_substitute_default("value", "argument ('%value%')", "argument");
|
||||
set_substitute_default("prefix", "%prefix%", "");
|
||||
m_substitutions["option"] = option_name;
|
||||
m_substitutions["original_token"] = original_token;
|
||||
}
|
||||
|
||||
|
||||
const char* error_with_option_name::what() const throw()
|
||||
{
|
||||
// will substitute tokens each time what is run()
|
||||
substitute_placeholders(m_error_template);
|
||||
|
||||
return m_message.c_str();
|
||||
}
|
||||
|
||||
void error_with_option_name::replace_token(const string& from, const string& to) const
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
std::size_t pos = m_message.find(from.c_str(), 0, from.length());
|
||||
// not found: all replaced
|
||||
if (pos == std::string::npos)
|
||||
return;
|
||||
m_message.replace(pos, from.length(), to);
|
||||
}
|
||||
}
|
||||
|
||||
string error_with_option_name::get_canonical_option_prefix() const
|
||||
{
|
||||
switch (m_option_style)
|
||||
{
|
||||
case command_line_style::allow_dash_for_short:
|
||||
return "-";
|
||||
case command_line_style::allow_slash_for_short:
|
||||
return "/";
|
||||
case command_line_style::allow_long_disguise:
|
||||
return "-";
|
||||
case command_line_style::allow_long:
|
||||
return "--";
|
||||
case 0:
|
||||
return "";
|
||||
}
|
||||
throw std::logic_error("error_with_option_name::m_option_style can only be "
|
||||
"one of [0, allow_dash_for_short, allow_slash_for_short, "
|
||||
"allow_long_disguise or allow_long]");
|
||||
}
|
||||
|
||||
|
||||
string error_with_option_name::get_canonical_option_name() const
|
||||
{
|
||||
if (!m_substitutions.find("option")->second.length())
|
||||
return m_substitutions.find("original_token")->second;
|
||||
|
||||
string original_token = strip_prefixes(m_substitutions.find("original_token")->second);
|
||||
string option_name = strip_prefixes(m_substitutions.find("option")->second);
|
||||
|
||||
// For long options, use option name
|
||||
if (m_option_style == command_line_style::allow_long ||
|
||||
m_option_style == command_line_style::allow_long_disguise)
|
||||
return get_canonical_option_prefix() + option_name;
|
||||
|
||||
// For short options use first letter of original_token
|
||||
if (m_option_style && original_token.length())
|
||||
return get_canonical_option_prefix() + original_token[0];
|
||||
|
||||
// no prefix
|
||||
return option_name;
|
||||
}
|
||||
|
||||
|
||||
void error_with_option_name::substitute_placeholders(const string& error_template) const
|
||||
{
|
||||
m_message = error_template;
|
||||
std::map<std::string, std::string> substitutions(m_substitutions);
|
||||
substitutions["canonical_option"] = get_canonical_option_name();
|
||||
substitutions["prefix"] = get_canonical_option_prefix();
|
||||
|
||||
|
||||
//
|
||||
// replace placeholder with defaults if values are missing
|
||||
//
|
||||
for (map<string, string_pair>::const_iterator iter = m_substitution_defaults.begin();
|
||||
iter != m_substitution_defaults.end(); ++iter)
|
||||
{
|
||||
// missing parameter: use default
|
||||
if (substitutions.count(iter->first) == 0 ||
|
||||
substitutions[iter->first].length() == 0)
|
||||
replace_token(iter->second.first, iter->second.second);
|
||||
}
|
||||
|
||||
|
||||
//
|
||||
// replace placeholder with values
|
||||
// placeholder are denoted by surrounding '%'
|
||||
//
|
||||
for (map<string, string>::iterator iter = substitutions.begin();
|
||||
iter != substitutions.end(); ++iter)
|
||||
replace_token('%' + iter->first + '%', iter->second);
|
||||
}
|
||||
|
||||
|
||||
void ambiguous_option::substitute_placeholders(const string& original_error_template) const
|
||||
{
|
||||
// For short forms, all alternatives must be identical, by
|
||||
// definition, to the specified option, so we don't need to
|
||||
// display alternatives
|
||||
if (m_option_style == command_line_style::allow_dash_for_short ||
|
||||
m_option_style == command_line_style::allow_slash_for_short)
|
||||
{
|
||||
error_with_option_name::substitute_placeholders(original_error_template);
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
string error_template = original_error_template;
|
||||
// remove duplicates using std::set
|
||||
std::set<std::string> alternatives_set (m_alternatives.begin(), m_alternatives.end());
|
||||
std::vector<std::string> alternatives_vec (alternatives_set.begin(), alternatives_set.end());
|
||||
|
||||
error_template += " and matches ";
|
||||
// Being very cautious: should be > 1 alternative!
|
||||
if (alternatives_vec.size() > 1)
|
||||
{
|
||||
for (unsigned i = 0; i < alternatives_vec.size() - 1; ++i)
|
||||
error_template += "'%prefix%" + alternatives_vec[i] + "', ";
|
||||
error_template += "and ";
|
||||
}
|
||||
|
||||
// there is a programming error if multiple options have the same name...
|
||||
if (m_alternatives.size() > 1 && alternatives_vec.size() == 1)
|
||||
error_template += "different versions of ";
|
||||
|
||||
error_template += "'%prefix%" + alternatives_vec.back() + "'";
|
||||
|
||||
|
||||
// use inherited logic
|
||||
error_with_option_name::substitute_placeholders(error_template);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
string
|
||||
validation_error::get_template(kind_t kind)
|
||||
{
|
||||
// Initially, store the message in 'const char*' variable,
|
||||
// to avoid conversion to std::string in all cases.
|
||||
const char* msg;
|
||||
switch(kind)
|
||||
{
|
||||
case invalid_bool_value:
|
||||
msg = "the argument ('%value%') for option '%canonical_option%' is invalid. Valid choices are 'on|off', 'yes|no', '1|0' and 'true|false'";
|
||||
break;
|
||||
case invalid_option_value:
|
||||
msg = "the argument ('%value%') for option '%canonical_option%' is invalid";
|
||||
break;
|
||||
case multiple_values_not_allowed:
|
||||
msg = "option '%canonical_option%' only takes a single argument";
|
||||
break;
|
||||
case at_least_one_value_required:
|
||||
msg = "option '%canonical_option%' requires at least one argument";
|
||||
break;
|
||||
// currently unused
|
||||
case invalid_option:
|
||||
msg = "option '%canonical_option%' is not valid";
|
||||
break;
|
||||
default:
|
||||
msg = "unknown error";
|
||||
}
|
||||
return msg;
|
||||
}
|
||||
|
||||
}}
|
||||
@@ -0,0 +1,249 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
|
||||
#define BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
#include <boost/program_options/config.hpp>
|
||||
#include <boost/program_options/parsers.hpp>
|
||||
#include <boost/program_options/options_description.hpp>
|
||||
#include <boost/program_options/value_semantic.hpp>
|
||||
#include <boost/program_options/variables_map.hpp>
|
||||
|
||||
#include <cassert>
|
||||
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
using namespace std;
|
||||
|
||||
// First, performs semantic actions for 'oa'.
|
||||
// Then, stores in 'm' all options that are defined in 'desc'.
|
||||
BOOST_PROGRAM_OPTIONS_DECL
|
||||
void store(const parsed_options& options, variables_map& xm,
|
||||
bool utf8)
|
||||
{
|
||||
// TODO: what if we have different definition
|
||||
// for the same option name during different calls
|
||||
// 'store'.
|
||||
assert(options.description);
|
||||
const options_description& desc = *options.description;
|
||||
|
||||
// We need to access map's operator[], not the overriden version
|
||||
// variables_map. Ehmm.. messy.
|
||||
std::map<std::string, variable_value>& m = xm;
|
||||
|
||||
std::set<std::string> new_final;
|
||||
|
||||
// Declared once, to please Intel in VC++ mode;
|
||||
unsigned i;
|
||||
|
||||
// Declared here so can be used to provide context for exceptions
|
||||
string option_name;
|
||||
string original_token;
|
||||
|
||||
try
|
||||
{
|
||||
|
||||
// First, convert/store all given options
|
||||
for (i = 0; i < options.options.size(); ++i) {
|
||||
|
||||
option_name = options.options[i].string_key;
|
||||
original_token = options.options[i].original_tokens.size() ?
|
||||
options.options[i].original_tokens[0] :
|
||||
option_name;
|
||||
// Skip positional options without name
|
||||
if (option_name.empty())
|
||||
continue;
|
||||
|
||||
// Ignore unregistered option. The 'unregistered'
|
||||
// field can be true only if user has explicitly asked
|
||||
// to allow unregistered options. We can't store them
|
||||
// to variables map (lacking any information about paring),
|
||||
// so just ignore them.
|
||||
if (options.options[i].unregistered)
|
||||
continue;
|
||||
|
||||
// If option has final value, skip this assignment
|
||||
if (xm.m_final.count(option_name))
|
||||
continue;
|
||||
|
||||
string original_token = options.options[i].original_tokens.size() ?
|
||||
options.options[i].original_tokens[0] : "";
|
||||
const option_description& d = desc.find(option_name, false,
|
||||
false, false);
|
||||
|
||||
variable_value& v = m[option_name];
|
||||
if (v.defaulted()) {
|
||||
// Explicit assignment here erases defaulted value
|
||||
v = variable_value();
|
||||
}
|
||||
|
||||
d.semantic()->parse(v.value(), options.options[i].value, utf8);
|
||||
|
||||
v.m_value_semantic = d.semantic();
|
||||
|
||||
// The option is not composing, and the value is explicitly
|
||||
// provided. Ignore values of this option for subsequent
|
||||
// calls to 'store'. We store this to a temporary set,
|
||||
// so that several assignment inside *this* 'store' call
|
||||
// are allowed.
|
||||
if (!d.semantic()->is_composing())
|
||||
new_final.insert(option_name);
|
||||
}
|
||||
}
|
||||
#ifndef BOOST_NO_EXCEPTIONS
|
||||
catch(error_with_option_name& e)
|
||||
{
|
||||
// add context and rethrow
|
||||
e.add_context(option_name, original_token, options.m_options_prefix);
|
||||
throw;
|
||||
}
|
||||
#endif
|
||||
xm.m_final.insert(new_final.begin(), new_final.end());
|
||||
|
||||
|
||||
|
||||
// Second, apply default values and store required options.
|
||||
const vector<shared_ptr<option_description> >& all = desc.options();
|
||||
for(i = 0; i < all.size(); ++i)
|
||||
{
|
||||
const option_description& d = *all[i];
|
||||
string key = d.key("");
|
||||
// FIXME: this logic relies on knowledge of option_description
|
||||
// internals.
|
||||
// The 'key' is empty if options description contains '*'.
|
||||
// In that
|
||||
// case, default value makes no sense at all.
|
||||
if (key.empty())
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if (m.count(key) == 0) {
|
||||
|
||||
boost::any def;
|
||||
if (d.semantic()->apply_default(def)) {
|
||||
m[key] = variable_value(def, true);
|
||||
m[key].m_value_semantic = d.semantic();
|
||||
}
|
||||
}
|
||||
|
||||
// add empty value if this is an required option
|
||||
if (d.semantic()->is_required()) {
|
||||
|
||||
// For option names specified in multiple ways, e.g. on the command line,
|
||||
// config file etc, the following precedence rules apply:
|
||||
// "--" > ("-" or "/") > ""
|
||||
// Precedence is set conveniently by a single call to length()
|
||||
string canonical_name = d.canonical_display_name(options.m_options_prefix);
|
||||
if (canonical_name.length() > xm.m_required[key].length())
|
||||
xm.m_required[key] = canonical_name;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL
|
||||
void store(const wparsed_options& options, variables_map& m)
|
||||
{
|
||||
store(options.utf8_encoded_options, m, true);
|
||||
}
|
||||
|
||||
BOOST_PROGRAM_OPTIONS_DECL
|
||||
void notify(variables_map& vm)
|
||||
{
|
||||
vm.notify();
|
||||
}
|
||||
|
||||
abstract_variables_map::abstract_variables_map()
|
||||
: m_next(0)
|
||||
{}
|
||||
|
||||
abstract_variables_map::
|
||||
abstract_variables_map(const abstract_variables_map* next)
|
||||
: m_next(next)
|
||||
{}
|
||||
|
||||
const variable_value&
|
||||
abstract_variables_map::operator[](const std::string& name) const
|
||||
{
|
||||
const variable_value& v = get(name);
|
||||
if (v.empty() && m_next)
|
||||
return (*m_next)[name];
|
||||
else if (v.defaulted() && m_next) {
|
||||
const variable_value& v2 = (*m_next)[name];
|
||||
if (!v2.empty() && !v2.defaulted())
|
||||
return v2;
|
||||
else return v;
|
||||
} else {
|
||||
return v;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
abstract_variables_map::next(abstract_variables_map* next)
|
||||
{
|
||||
m_next = next;
|
||||
}
|
||||
|
||||
variables_map::variables_map()
|
||||
{}
|
||||
|
||||
variables_map::variables_map(const abstract_variables_map* next)
|
||||
: abstract_variables_map(next)
|
||||
{}
|
||||
|
||||
void variables_map::clear()
|
||||
{
|
||||
std::map<std::string, variable_value>::clear();
|
||||
m_final.clear();
|
||||
m_required.clear();
|
||||
}
|
||||
|
||||
const variable_value&
|
||||
variables_map::get(const std::string& name) const
|
||||
{
|
||||
static variable_value empty;
|
||||
const_iterator i = this->find(name);
|
||||
if (i == this->end())
|
||||
return empty;
|
||||
else
|
||||
return i->second;
|
||||
}
|
||||
|
||||
void
|
||||
variables_map::notify()
|
||||
{
|
||||
// This checks if all required options occur
|
||||
for (map<string, string>::const_iterator r = m_required.begin();
|
||||
r != m_required.end();
|
||||
++r)
|
||||
{
|
||||
const string& opt = r->first;
|
||||
const string& display_opt = r->second;
|
||||
map<string, variable_value>::const_iterator iter = find(opt);
|
||||
if (iter == end() || iter->second.empty())
|
||||
{
|
||||
boost::throw_exception(required_option(display_opt));
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// Lastly, run notify actions.
|
||||
for (map<string, variable_value>::iterator k = begin();
|
||||
k != end();
|
||||
++k)
|
||||
{
|
||||
/* Users might wish to use variables_map to store their own values
|
||||
that are not parsed, and therefore will not have value_semantics
|
||||
defined. Do no crash on such values. In multi-module programs,
|
||||
one module might add custom values, and the 'notify' function
|
||||
will be called after that, so we check that value_sematics is
|
||||
not NULL. See:
|
||||
https://svn.boost.org/trac/boost/ticket/2782
|
||||
*/
|
||||
if (k->second.m_value_semantic)
|
||||
k->second.m_value_semantic->notify(k->second.value());
|
||||
}
|
||||
}
|
||||
|
||||
}}
|
||||
+102
@@ -0,0 +1,102 @@
|
||||
// Copyright Vladimir Prus 2002-2004.
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt
|
||||
// or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
|
||||
#define BOOST_PROGRAM_OPTIONS_SOURCE
|
||||
#include <boost/program_options/parsers.hpp>
|
||||
#include <cctype>
|
||||
|
||||
using std::size_t;
|
||||
|
||||
#ifdef _WIN32
|
||||
namespace boost { namespace program_options {
|
||||
|
||||
// Take a command line string and splits in into tokens, according
|
||||
// to the rules windows command line processor uses.
|
||||
//
|
||||
// The rules are pretty funny, see
|
||||
// http://article.gmane.org/gmane.comp.lib.boost.user/3005
|
||||
// http://msdn.microsoft.com/library/en-us/vccelng/htm/progs_12.asp
|
||||
BOOST_PROGRAM_OPTIONS_DECL
|
||||
std::vector<std::string> split_winmain(const std::string& input)
|
||||
{
|
||||
std::vector<std::string> result;
|
||||
|
||||
std::string::const_iterator i = input.begin(), e = input.end();
|
||||
for(;i != e; ++i)
|
||||
if (!isspace((unsigned char)*i))
|
||||
break;
|
||||
|
||||
if (i != e) {
|
||||
|
||||
std::string current;
|
||||
bool inside_quoted = false;
|
||||
bool empty_quote = false;
|
||||
int backslash_count = 0;
|
||||
|
||||
for(; i != e; ++i) {
|
||||
if (*i == '"') {
|
||||
// '"' preceded by even number (n) of backslashes generates
|
||||
// n/2 backslashes and is a quoted block delimiter
|
||||
if (backslash_count % 2 == 0) {
|
||||
current.append(backslash_count / 2, '\\');
|
||||
empty_quote = inside_quoted && current.empty();
|
||||
inside_quoted = !inside_quoted;
|
||||
// '"' preceded by odd number (n) of backslashes generates
|
||||
// (n-1)/2 backslashes and is literal quote.
|
||||
} else {
|
||||
current.append(backslash_count / 2, '\\');
|
||||
current += '"';
|
||||
}
|
||||
backslash_count = 0;
|
||||
} else if (*i == '\\') {
|
||||
++backslash_count;
|
||||
} else {
|
||||
// Not quote or backslash. All accumulated backslashes should be
|
||||
// added
|
||||
if (backslash_count) {
|
||||
current.append(backslash_count, '\\');
|
||||
backslash_count = 0;
|
||||
}
|
||||
if (isspace((unsigned char)*i) && !inside_quoted) {
|
||||
// Space outside quoted section terminate the current argument
|
||||
result.push_back(current);
|
||||
current.resize(0);
|
||||
empty_quote = false;
|
||||
for(;i != e && isspace((unsigned char)*i); ++i)
|
||||
;
|
||||
--i;
|
||||
} else {
|
||||
current += *i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If we have trailing backslashes, add them
|
||||
if (backslash_count)
|
||||
current.append(backslash_count, '\\');
|
||||
|
||||
// If we have non-empty 'current' or we're still in quoted
|
||||
// section (even if 'current' is empty), add the last token.
|
||||
if (!current.empty() || inside_quoted || empty_quote)
|
||||
result.push_back(current);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
#ifndef BOOST_NO_STD_WSTRING
|
||||
BOOST_PROGRAM_OPTIONS_DECL std::vector<std::wstring>
|
||||
split_winmain(const std::wstring& cmdline)
|
||||
{
|
||||
std::vector<std::wstring> result;
|
||||
std::vector<std::string> aux = split_winmain(to_internal(cmdline));
|
||||
for (size_t i = 0, e = aux.size(); i < e; ++i)
|
||||
result.push_back(from_utf8(aux[i]));
|
||||
return result;
|
||||
}
|
||||
#endif
|
||||
|
||||
}}
|
||||
#endif
|
||||
|
||||
Reference in new issue
Block a user