Added boost header

test/external/boost/program_options/cmdline.hpp

@@ -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
+

test/external/boost/program_options/config.hpp

@@ -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
+

test/external/boost/program_options/detail/cmdline.hpp

@@ -0,0 +1,147 @@
+// 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);
+        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
+

test/external/boost/program_options/detail/config_file.hpp

@@ -0,0 +1,182 @@
+// 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>
+#if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3202))
+#include <boost/program_options/detail/convert.hpp>
+#endif
+
+#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

test/external/boost/program_options/detail/convert.hpp

@@ -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

test/external/boost/program_options/detail/parsers.hpp

@@ -0,0 +1,146 @@
+// 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()
+    {
+        parsed_options result(m_desc);
+        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

test/external/boost/program_options/detail/utf8_codecvt_facet.hpp

@@ -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

test/external/boost/program_options/detail/value_semantic.hpp

@@ -0,0 +1,207 @@
+// 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
+    {
+        if (!m_implicit_value.empty() && !m_implicit_value_as_text.empty()) {
+            std::string msg = "[=arg(=" + 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 arg + " (=" + m_default_value_as_text + ")";
+        } else {
+            return arg;
+        }
+    }
+
+    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 gcc 3.2 to not generate code to specialization defined in
+    // value_semantic.cpp
+#if ! ( ( BOOST_WORKAROUND(__GNUC__, <= 3) &&\
+          BOOST_WORKAROUND(__GNUC_MINOR__, < 3) ) || \
+        ( 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;        
+    }
+
+
+
+}}

test/external/boost/program_options/environment_iterator.hpp

@@ -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

test/external/boost/program_options/eof_iterator.hpp

@@ -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
+

test/external/boost/program_options/errors.hpp

@@ -0,0 +1,243 @@
+// 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>
+
+#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 {
+
+    /** 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 BOOST_PROGRAM_OPTIONS_DECL invalid_syntax : public error {
+    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(const std::string& tokens, kind_t kind);
+
+        // gcc says that throw specification on dtor is loosened
+        // without this line
+        ~invalid_syntax() throw() {}
+        
+        kind_t kind() const;
+        
+        const std::string& tokens() const;
+        
+    protected:
+        /** Used to convert kind_t to a related error text */
+        static std::string error_message(kind_t kind);
+
+    private:
+        // TODO: copy ctor might throw
+        std::string m_tokens;
+
+        kind_t m_kind;
+    };
+
+    /** Class thrown when option name is not recognized. */
+    class BOOST_PROGRAM_OPTIONS_DECL unknown_option : public error {
+    public:
+        unknown_option(const std::string& name)
+        : error(std::string("unknown option ").append(name)), 
+          m_option_name(name)
+        {}
+
+        // gcc says that throw specification on dtor is loosened
+        // without this line
+        ~unknown_option() throw() {}
+        
+        const std::string& get_option_name() const throw();
+        
+    private:
+        std::string m_option_name;
+    };
+
+    /** Class thrown when there's ambiguity amoung several possible options. */
+    class BOOST_PROGRAM_OPTIONS_DECL ambiguous_option : public error {
+    public:
+        ambiguous_option(const std::string& name, 
+                         const std::vector<std::string>& xalternatives)
+        : error(std::string("ambiguous option ").append(name))
+        , m_alternatives(xalternatives)
+        , m_option_name(name)
+        {}
+
+        ~ambiguous_option() throw() {}
+        
+        const std::string& get_option_name() const throw();
+        
+        const std::vector<std::string>& alternatives() const throw();
+
+    private:
+        // TODO: copy ctor might throw
+        std::vector<std::string> m_alternatives;
+        std::string m_option_name;
+    };
+
+    /** 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 {
+    public:
+        multiple_values() 
+         : error("multiple values")
+         , m_option_name() {}
+         
+        ~multiple_values() throw() {}
+        
+        void set_option_name(const std::string& option);
+        
+        const std::string& get_option_name() const throw();
+        
+    private:
+        std::string m_option_name; // The name of the option which
+                                   // caused the exception.        
+    };
+
+    /** 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 {
+    public:
+        multiple_occurrences() 
+         : error("multiple occurrences")
+         , m_option_name() {}
+         
+        ~multiple_occurrences() throw() {}
+        
+        void set_option_name(const std::string& option);
+        
+        const std::string& get_option_name() const throw();
+
+    private:        
+        std::string m_option_name; // The name of the option which
+                                   // caused the exception.
+    };
+
+    /** Class thrown when value of option is incorrect. */
+    class BOOST_PROGRAM_OPTIONS_DECL validation_error : public error {
+    public:
+        enum kind_t {
+            multiple_values_not_allowed = 30,
+            at_least_one_value_required, 
+            invalid_bool_value,
+            invalid_option_value,
+            invalid_option
+        };
+        
+        validation_error(kind_t kind, 
+                         const std::string& option_value = "",
+                         const std::string& option_name = "");
+                         
+        ~validation_error() throw() {}
+
+        void set_option_name(const std::string& option);
+        
+        const std::string& get_option_name() const throw();
+        
+        const char* what() const throw();
+        
+    protected:
+        /** Used to convert kind_t to a related error text */
+        static std::string error_message(kind_t kind);
+
+    private:
+        kind_t m_kind;
+        std::string m_option_name; // The name of the option which
+                                   // caused the exception.
+        std::string m_option_value; // Optional: value of the option m_options_name
+        mutable std::string m_message; // For on-demand formatting in 'what'
+
+    };
+
+    /** Class thrown if there is an invalid option value givenn */
+    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 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") 
+        {}
+    };
+
+    /** 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(const std::string& tokens, kind_t kind);
+    };
+
+    /** 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 file ").append(filename))
+        {}
+    };
+    
+     /** Class thrown when a required/mandatory option is missing */
+     class BOOST_PROGRAM_OPTIONS_DECL required_option : public error {
+     public:
+        required_option(const std::string& name)
+        : error(std::string("missing required option ").append(name))
+        , m_option_name(name)
+        {}
+ 
+        ~required_option() throw() {}
+
+        const std::string& get_option_name() const throw();
+        
+     private:
+        std::string m_option_name; // The name of the option which
+                                   // caused the exception.
+     };
+}}
+
+#if defined(BOOST_MSVC)
+#   pragma warning (pop)
+#endif
+
+#endif

test/external/boost/program_options/option.hpp

@@ -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

test/external/boost/program_options/options_description.hpp

@@ -0,0 +1,264 @@
+// 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://anubis.dkuug.dk/jtc1/sc22/wg21/docs/papers/2000/n1232.pdf
+            http://std.dkuug.dk/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;
+
+        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);
+
+    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) 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

test/external/boost/program_options/parsers.hpp

@@ -0,0 +1,267 @@
+// 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) 
+        : description(xdescription) {}
+        /** 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;
+    };
+
+    /** 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;        
+    };
+
+    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
+    
+
+}}
+
+#undef DECL
+
+#include "boost/program_options/detail/parsers.hpp"
+
+#endif

test/external/boost/program_options/positional_options.hpp

@@ -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
+

test/external/boost/program_options/value_semantic.hpp

@@ -0,0 +1,405 @@
+// 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 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;
+        }
+
+        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.
+        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
+

test/external/boost/program_options/variables_map.hpp

@@ -0,0 +1,211 @@
+// 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 BOOST_PROGRAM_OPTIONS_DECL class 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); }
+        
+        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. */
+        std::set<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;
+    }
+
+}}
+
+#endif

test/external/boost/program_options/version.hpp

@@ -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