This commit was manufactured by cvs2svn to create tag

'Version_1_32_0'.

[SVN r26264]

build/Jamfile

@@ -0,0 +1,49 @@
+
+subproject libs/program_options/build ;
+
+SOURCES = cmdline config_file options_description parsers variables_map 
+          value_semantic positional_options utf8_codecvt_facet convert
+          winmain
+;
+
+lib boost_program_options
+     : ../src/$(SOURCES).cpp
+     : # build requirements
+       [ common-names ] # magic for install and auto-link features
+       <include>$(BOOST_ROOT) <sysinclude>$(BOOST_ROOT)
+       std::locale-support
+     : debug release  # build variants
+     ;
+
+dll boost_program_options
+     : ../src/$(SOURCES).cpp
+     : # build requirements
+       [ common-names ]  # magic for install and auto-link features
+       <define>BOOST_ALL_DYN_LINK=1  # tell source we're building dll's
+       <runtime-link>dynamic  # build only for dynamic runtimes
+       <include>$(BOOST_ROOT) <sysinclude>$(BOOST_ROOT)
+       # The following really turns on static runtime linking
+       # which leads to runtime crashes when using DLL, so
+       # seem DLL is not usable on Metrowerks 8
+       # std::facet-support std::locale-support
+     : debug release  # build variants
+     ;
+
+install program_options lib
+     : <lib>boost_program_options <dll>boost_program_options
+     ;
+
+stage stage/lib : <lib>boost_program_options <dll>boost_program_options
+    :
+        # copy to a path rooted at BOOST_ROOT:
+        <locate>$(BOOST_ROOT)
+        # make sure the names of the libraries are correctly named:
+        [ common-names ]
+        # add this target to the "stage" and "all" psuedo-targets:
+        <target>stage
+        <target>all
+    :
+        debug release
+    ;
+
+# end

build/Jamfile.v2

@@ -3,17 +3,18 @@ project boost/program_options
     : source-location ../src 
     ;
 
-SOURCES =
-    cmdline config_file options_description parsers variables_map 
-    value_semantic positional_options utf8_codecvt_facet
-    convert winmain split
-    ;
+SOURCES = cmdline config_file options_description parsers variables_map 
+          value_semantic positional_options utf8_codecvt_facet
+          convert winmain
+      ;
 
-lib boost_program_options
-    : $(SOURCES).cpp
-    : <link>shared:<define>BOOST_PROGRAM_OPTIONS_DYN_LINK=1 # tell source we're building dll's
-    :
-    : <link>shared:<define>BOOST_PROGRAM_OPTIONS_DYN_LINK=1
-    ;
+import os ;
+if [ os.name ] = NT
+{
+    linkage = <link>static ;
+}
 
-boost-install boost_program_options ;
+lib program_options
+  : $(SOURCES).cpp
+  : $(linkage)
+    ;

doc/Jamfile.v2

@@ -2,12 +2,7 @@
 import toolset ;
 toolset.using doxygen ;
 
-boostbook program_option 
-    : program_options.xml 
-    : <implicit-dependency>autodoc 
-      <xsl:param>boost.root=../../../..
-      <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
-    ;
+boostbook program_option : program_options.xml ;
 
 doxygen autodoc 
     : [ glob ../../../boost/program_options/*.hpp ] ;

doc/design.xml

@@ -52,7 +52,8 @@
               <listitem>
                 <para>ascii input passed to a Unicode value, and Unicode input
                   passed to an ascii value will be converted using a codecvt
-                  facet (which may be specified by the user).
+                  facet (which may be specified by the user(which can be
+                  specified by the user)
                 </para>
               </listitem>                 
             </itemizedlist>
@@ -82,7 +83,7 @@
     </para>
 
     <para>The Unicode support outlined above is not complete. For example, we
-      don't support Unicode option names. Unicode support is hard and
+      don't plan allow Unicode in option names. Unicode support is hard and
       requires a Boost-wide solution. Even comparing two arbitrary Unicode
       strings is non-trivial. Finally, using Unicode in option names is
       related to internationalization, which has it's own

doc/howto.xml

@@ -107,7 +107,7 @@ if (vm.count("response-file")) {
      // Load the file and tokenize it
      ifstream ifs(vm["response-file"].as<string>().c_str());
      if (!ifs) {
-         cout << "Could not open the response file\n";
+         cout << "Could no open the response file\n";
          return 1;
      }
      // Read the whole file into a string
@@ -115,8 +115,7 @@ if (vm.count("response-file")) {
      ss << ifs.rdbuf();
      // Split the file content
      char_separator<char> sep(" \n\r");
-     std::string ResponsefileContents( ss.str() );
-     tokenizer<char_separator<char> > tok(ResponsefileContents, sep);
+     tokenizer<char_separator<char> > tok(ss.str(), sep);
      vector<string> args;
      copy(tok.begin(), tok.end(), back_inserter(args));
      // Parse the file and store the options
@@ -139,7 +138,7 @@ if (vm.count("response-file")) {
     compilers, it is possible to obtain
     the split command line, but it's not clear if all compilers support the
     same mechanism on all versions of the operating system. The
-    <code>split_winmain</code> function is a portable mechanism provided
+    <code>split_command_line</code> function is a portable mechanism provided
     by the library.</para>
 
     <para>Here's an example of use:
@@ -147,7 +146,7 @@ if (vm.count("response-file")) {
 vector&lt;string&gt; args = split_winmain(lpCmdLine);
 store(command_line_parser(args).options(desc).run(), vm);
 </programlisting>      
-      The <code>split_winmain</code> function is overloaded for <code>wchar_t</code> strings, so can
+      The function is an overload for <code>wchar_t</code> strings, so can
       also be used in Unicode applications.
     </para>
 
@@ -185,7 +184,7 @@ store(command_line_parser(args).options(desc).run(), vm);
 options_description general("General options");
 general.add_options()
     ("help", "produce a help message")
-    ("help-module", value<string>(),
+    ("help-module", value<string>()->implicit(),
         "produce a help for a given module")
     ("version", "output the version number")
     ;
@@ -285,7 +284,7 @@ void validate(boost::any& v,
     using namespace boost::program_options;
 
     // Make sure no previous assignment to 'a' was made.
-    validators::check_first_occurrence(v);
+    validators::check_first_occurence(v);
     // Extract the first string from 'values'. If there is more than
     // one string, it's an error, and exception will be thrown.
     const string& s = validators::get_single_string(values);
@@ -296,7 +295,7 @@ void validate(boost::any& v,
     if (regex_match(s, match, r)) {
         v = any(magic_number(lexical_cast<int>(match[1])));
     } else {
-        throw validation_error(validation_error::invalid_option_value);
+        throw validation_error("invalid value");
     }        
 }
 ]]>        
@@ -399,49 +398,13 @@ $ export LC_CTYPE=ru_RU.KOI8-R
 
     </section>
 
-    <section>
-      <title>Allowing Unknown Options</title>
-
-      <para>Usually, the library throws an exception on unknown option names. This 
-      behaviour can be changed. For example, only some part of your application uses 
-      <libraryname>Program_options</libraryname>, and you wish to pass unrecognized options to another part of
-      the program, or even to another application.</para>
-
-      <para>To allow unregistered options on the command line, you need to use 
-      the &basic_command_line_parser; class for parsing (not &parse_command_line;)
-      and call the <methodname alt="boost::program_options::basic_command_line_parser::allow_unregistered">allow_unregistered</methodname> 
-      method of that class:
-      <programlisting>
-parsed_options parsed = 
-    command_line_parser(argc, argv).options(desc).allow_unregistered().run();      
-      </programlisting>
-      
-      For each token that looks like an option, but does not have a known name, 
-      an instance of &basic_option; will be added to the result. 
-      The <code>string_key</code> and <code>value</code> fields of the instance will contain results 
-      of syntactic parsing of the token, the <code>unregistered</code> field will be set to <code>true</code>,
-      and the <code>original_tokens</code> field will contain the token as it appeared on the command line.
-      </para>
-
-      <para>If you want to pass the unrecognized options further, the 
-      <functionname alt="boost::program_options::collect_unrecognized">collect_unrecognized</functionname> function can be used.
-      The function will collect original tokens for all unrecognized values, and optionally, all found positional options.
-      Say, if your code handles a few options, but does not handles positional options at all, you can use the function like this:
-      <programlisting>
-vector&lt;string&gt; to_pass_further = collect_unrecognized(parsed.options, include_positional);
-      </programlisting>
-      
-      </para>     
-            
-    </section>
-
 </section>
 
 <!--
      Local Variables:
-     mode: nxml
-     sgml-indent-data: t
-     sgml-parent-document: ("userman.xml" "chapter")
+     mode: xml
+     sgml-indent-data: t     
+     sgml-parent-document: ("program_options.xml" "section")
      sgml-set-face: t
      End:
 -->

doc/index.html

@@ -1,14 +1,9 @@
 <html>
 <head>
-<meta http-equiv="refresh" content="0; URL=../../../doc/html/program_options.html">
+<meta http-equiv="refresh" content="0; URL=../../../doc/html/program_option.html">
 </head>
 <body>
 Automatic redirection failed, please go to
-<a href="../../../doc/html/program_options.html">../../../doc/html/program_options.html</a> 
-&nbsp;<hr>
-<p>© Copyright Beman Dawes, 2001</p>
-<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
-file <a href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
-at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
+<a href="../../../doc/html/program_options.html">../../../doc/html/program_options.html</a>
 </body>
 </html>

doc/overview.xml

@@ -148,150 +148,44 @@ desc.add_options()
     </para>
 
     <section>
-      <title>Syntactic Information</title>
+      <title>Syntactic information</title>
       <para>The syntactic information is provided by the
         <classname>boost::program_options::options_description</classname> class
         and some methods of the
-        <classname>boost::program_options::value_semantic</classname> class
-        and includes:        
-        <itemizedlist>
-          <listitem>
-            <para>
-              name of the option, used to identify the option inside the
-              program,
-            </para>
-          </listitem>
-          <listitem>
-            <para>
-              description of the option, which can be presented to the user,
-            </para>
-          </listitem>
-          <listitem>
-            <para>
-              the allowed number of source tokens that comprise options's
-              value, which is used during parsing.
-            </para>
-          </listitem>
-        </itemizedlist>
-      </para>
-
-      <para>Consider the following example:
-      <programlisting>
-options_description desc;
-desc.add_options()
-    ("help", "produce help message")
-    ("compression", value&lt;string&gt;(), "compression level")
-    ("verbose", value&lt;string&gt;()->zero_tokens(), "verbosity level")
-    ("email", value&lt;string&gt;()->multitoken(), "email to send to")
-    ;
-      </programlisting>
-      For the first parameter, we specify only the name and the
-      description. No value can be specified in the parsed source.
-      For the first option, the user must specify a value, using a single
-      token. For the third option, the user may either provide a single token
-      for the value, or no token at all. For the last option, the value can
-      span several tokens. For example, the following command line is OK:
-      <screen>
-          test --help --compression 10 --verbose --email beadle@mars beadle2@mars
-      </screen>      
-      </para>
-
-      <section>
-        <title>Description formatting</title>
-
-        <para>
-          Sometimes the description can get rather long, for example, when
-          several option's values need separate documentation. Below we
-          describe some simple formatting mechanisms you can use.
-        </para>
-
-        <para>The description string has one or more paragraphs, separated by
-        the newline character ('\n'). When an option is output, the library
-        will compute the indentation for options's description. Each of the
-        paragraph is output as a separate line with that intentation. If 
-        a paragraph does not fit on one line it is spanned over multiple
-        lines (which will have the same indentation).
-        </para>
-
-        <para>You may specify additional indent for the first specified by
-        inserting spaces at the beginning of a paragraph. For example: 
+        <classname>boost::program_options::value_semantic</classname> class.
+        The simplest usage is illustrated below:
         <programlisting>
-options.add_options()
-    ("help", "   A long help msg a long help msg a long help msg a long help
-msg a long help msg a long help msg a long help msg a long help msg ")
-    ;  
+          options_description desc;
+          desc.add_options()
+          ("help", "produce help message")
+          ;
         </programlisting>
-        will specify a four-space indent for the first line. The output will
-        look like:
-        <screen>
-  --help                    A long help msg a long
-                        help msg a long help msg
-                        a long help msg a long
-                        help msg a long help msg
-                        a long help msg a long
-                        help msg
-          
-        </screen>
-        </para>
-
-        <para>For the case where line is wrapped, you can want an additional
-        indent for wrapped text. This can be done by
-        inserting a tabulator character ('\t') at the desired position. For
-        example: 
+        This declares one option named "help" and associates a description with
+        it. The user is not allowed to specify any value.
+      </para>
+      
+      <para>To make an option accept a value, you'd need the
+        <code>value</code> function mentioned above:
         <programlisting>
-options.add_options()
-      ("well_formated", "As you can see this is a very well formatted
-option description.\n"
-                        "You can do this for example:\n\n"
-                        "Values:\n"
-                        "  Value1: \tdoes this and that, bla bla bla bla
-bla bla bla bla bla bla bla bla bla bla bla\n"
-                        "  Value2: \tdoes something else, bla bla bla bla
-bla bla bla bla bla bla bla bla bla bla bla\n\n"
-                        "    This paragraph has a first line indent only,
-bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla");          
+          options_description desc;
+          desc.add_options()
+          ("compression", "compression level", value&lt;string&gt;())
+          ("verbose", "verbosity level", value&lt;string&gt;()->implicit())
+          ("email", "email to send to", value&lt;string&gt;()->multitoken());
         </programlisting>
-        will produce:
+        With these declarations, the user must specify a value for
+        the first option, using a single token. For the second option, the user
+        may either provide a single token for the value, or no token at
+        all. For the last option, the value can span several tokens. For
+        example, the following command line is OK:
         <screen>
-  --well_formated       As you can see this is a
-                        very well formatted
-                        option description.
-                        You can do this for
-                        example:
-
-                        Values:
-                          Value1: does this and
-                                  that, bla bla
-                                  bla bla bla bla
-                                  bla bla bla bla
-                                  bla bla bla bla
-                                  bla
-                          Value2: does something
-                                  else, bla bla
-                                  bla bla bla bla
-                                  bla bla bla bla
-                                  bla bla bla bla
-                                  bla
-
-                            This paragraph has a
-                        first line indent only,
-                        bla bla bla bla bla bla
-                        bla bla bla bla bla bla
-                        bla bla bla
-        </screen>
-        The tab character is removed before output. Only one tabulator per
-        paragraph is allowed, otherwisee an exception of type
-        program_options::error is thrown. Finally, the tabulator is ignored if
-        it's is not on the first line of the paragraph or is on the last
-        possible position of the first line.
-        </para>
-
-      </section>
-
+          test --compression 10 --verbose --email beadle@mars beadle2@mars
+        </screen>      
+      </para>
     </section>
       
     <section>
-      <title>Semantic Information</title>
+      <title>Semantic information</title>
       
       <para>The semantic information is completely provided by the 
         <classname>boost::program_options::value_semantic</classname> class. For
@@ -299,10 +193,9 @@ bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla");
 <programlisting>
 options_description desc;
 desc.add_options()
-    ("compression", value&lt;int&gt;()->default_value(10), "compression level")
-    ("email", value&lt; vector&lt;string&gt; &gt;()
-        ->composing()->notifier(&amp;your_function), "email")
-    ;
+    ("compression", "compression level", value&lt;int&gt;()->default(10));
+    ("email", "email", value&lt; vector&lt;string&gt; &gt;()
+        ->composing()->notify(&amp;your_function);
 </programlisting>      
         These declarations specify that default value of the first option is 10,
         that the second option can appear several times and all instances should
@@ -313,7 +206,7 @@ desc.add_options()
     </section>
     
     <section>
-      <title>Positional Options</title>
+      <title>Positional options</title>
       
       <para>Our definition of option as (name, value) pairs is simple and
         useful, but in one special case of the command line, there's a
@@ -338,28 +231,21 @@ desc.add_options()
       <para>The &positional_options_desc; class allows the command line
         parser to assign the names. The class specifies how many positional options
         are allowed, and for each allowed option, specifies the name. For example:
-<programlisting>
-positional_options_description pd; pd.add("input-file", 1);
-</programlisting> specifies that for exactly one, first, positional
+        <programlisting>
+          positional_options_description pd; pd.add("input-file", 1, 1);
+        </programlisting> specifies that for exactly one, first, positional
         option the name will be "input-file".
       </para>
       
       <para>It's possible to specify that a number, or even all positional options, be
         given the same name.
-<programlisting>
-positional_options_description pd;
-pd.add("output-file", 2).add("input-file", -1);
-</programlisting>
+        <programlisting>
+          positional_options_description pd;
+          pd.add("output-file", 2, 2).add_optional("input-file", 0, -1);
+        </programlisting>
         In the above example, the first two positional options will be associated
         with name "output-file", and any others with the name "input-file".
       </para>
-
-    <warning>
-      <para>The &positional_options_desc; class only specifies translation from
-      position to name, and the option name should still be registered with
-      an instance of the &options_description; class.</para>
-    </warning>
-
       
     </section>
               
@@ -448,12 +334,12 @@ pd.add("output-file", 2).add("input-file", -1);
     </para>
 
     <para>Let's consider an example:
-<programlisting>
-variables_map vm;
-store(parse_command_line(argc, argv, desc), vm);
-store(parse_config_file("example.cfg", desc), vm);
-notify(vm);
-</programlisting>
+      <programlisting>
+        variables_map vm;
+        store(parse_command_line(argc, argv, desc), vm);
+        store(parse_config_file("example.cfg", desc), vm);
+        notify(vm);
+      </programlisting>
       The <code>variables_map</code> class is used to store the option
       values. The two calls to the <code>store</code> function add values
       found on the command line and in the config file. Finally the call to
@@ -474,97 +360,6 @@ notify(vm);
 
   </section>
 
-  <section>
-    <title>Specific parsers</title>
-
-    <section>
-      <title>Configuration file parser</title>
-
-      <para>The &parse_config_file; function implements parsing
-      of simple INI-like configuration files. Configuration file
-      syntax is line based:
-      </para>
-      <itemizedlist>
-        <listitem><para>A line in the form:</para>
-        <screen>
-<replaceable>name</replaceable>=<replaceable>value</replaceable>
-        </screen>
-        <para>gives a value to an option.</para>
-        </listitem>
-        <listitem><para>A line in the form:</para>
-        <screen>
-[<replaceable>section name</replaceable>]
-        </screen>
-        <para>introduces a new section in the configuration file.</para>
-        </listitem>
-        <listitem><para>The <literal>#</literal> character introduces a
-        comment that spans until the end of the line.</para>
-        </listitem>
-      </itemizedlist>
-
-      <para>The option names are relative to the section names, so
-      the following configuration file part:</para>
-      <screen>
-[gui.accessibility]
-visual_bell=yes
-      </screen>
-      <para>is equivalent to</para>
-      <screen>
-gui.accessibility.visual_bell=yes
-      </screen>
-                  
-    </section>
-
-    <section>
-      <title>Environment variables parser</title>
-
-      <para><firstterm>Environment variables</firstterm> are string variables
-      which are available to all programs via the <code>getenv</code> function
-      of C runtime library. The operating system allows to set initial values
-      for a given user, and the values can be further changed on the command
-      line.  For example, on Windows one can use the
-      <filename>autoexec.bat</filename> file or (on recent versions) the
-      <filename>Control Panel/System/Advanced/Environment Variables</filename>
-      dialog, and on Unix &#x2014;, the <filename>/etc/profile</filename>,
-      <filename>~/.profile</filename> and <filename>~/.bash_profile</filename>
-      files. Because environment variables can be set for the entire system,
-      they are particularly suitable for options which apply to all programs.
-      </para>
-
-      <para>The environment variables can be parsed with the
-      &parse_environment; function. The function have several overloaded
-      versions. The first parameter is always an &options_description;
-      instance, and the second specifies what variables must be processed, and
-      what option names must correspond to it. To describe the second
-      parameter we need to consider naming conventions for environment
-      variables.</para>
-      
-      <para>If you have an option that should be specified via environment
-      variable, you need make up the variable's name. To avoid name clashes,
-      we suggest that you use a sufficiently unique prefix for environment
-      variables. Also, while option names are most likely in lower case,
-      environment variables conventionally use upper case. So, for an option
-      name <literal>proxy</literal> the environment variable might be called
-      <envar>BOOST_PROXY</envar>. During parsing, we need to perform reverse
-      conversion of the names. This is accomplished by passing the choosen
-      prefix as the second parameter of the &parse_environment; function.
-      Say, if you pass <literal>BOOST_</literal> as the prefix, and there are
-      two variables, <envar>CVSROOT</envar> and <envar>BOOST_PROXY</envar>, the
-      first variable will be ignored, and the second one will be converted to
-      option <literal>proxy</literal>. 
-      </para>
-      
-      <para>The above logic is sufficient in many cases, but it is also
-      possible to pass, as the second parameter of the &parse_environment;
-      function, any function taking a <code>std::string</code> and returning
-      <code>std::string</code>. That function will be called for each
-      environment variable and should return either the name of the option, or
-      empty string if the variable should be ignored.
-      </para>
-            
-    </section>
-  </section>
-
   <section>
     <title>Annotated List of Symbols</title>
     
@@ -605,15 +400,8 @@ gui.accessibility.visual_bell=yes
           
           <row>
             <entry>&parse_command_line;</entry>
-            <entry>parses command line (simpified interface)</entry>
+            <entry>parses command line</entry>
           </row>
-
-          <row>
-            <entry>&basic_command_line_parser;</entry>
-            <entry>parses command line (extended interface)</entry>
-          </row>
-
-
           <row>
             <entry>&parse_config_file;</entry>
             <entry>parses config file</entry>
@@ -644,7 +432,7 @@ gui.accessibility.visual_bell=yes
 
 <!--
      Local Variables:
-     mode: nxml
+     mode: xml
      sgml-indent-data: t     
      sgml-parent-document: ("program_options.xml" "section")
      sgml-set-face: t

doc/post_review_plan.txt

@@ -151,7 +151,7 @@
    - test additional parser
    - Show default values in help output
    - Adaptive field width
-   - Mandatory options (2 votes (second Jonathan Graehl))
+   - Mandatory options
    - (new) return vector from parsers by auto_ptr, not by value?
    - (new) rename value_semantic into value_description
    - (new) output for positional_options_description

doc/program_options.ent

@@ -37,10 +37,3 @@
 <!ENTITY command_line_parser
      "<classname alt='boost::program_options::command_line_parser'>command_line_parser</classname>">
 
-<!ENTITY basic_command_line_parser
-     "<classname alt='boost::program_options::basic_command_line_parser'>basic_command_line_parser</classname>">
-
-
-<!ENTITY basic_option
-     "<classname alt='boost::program_options::basic_option'>basic_option</classname>">
-

doc/program_options.xml

@@ -83,5 +83,5 @@
   <xi:include href="design.xml"/>
   <xi:include href="acknowledgements.xml"/>    
    
-  <xi:include href="autodoc.xml"/> 
+  <xi:include href="autodoc.boostbook"/> 
 </library>

doc/todo.txt

@@ -1,20 +1,4 @@
 
-Say that variables_map is actually derived from std::map.
-
-Make parse_config_file("foo.cfg", desc) work.
-
-Document handling of positional options which depends on precedding options. 
-I.e scanning the parsed options and creating new variables_map when we see
-a positional option. (Email from Tony).
-
-> My instinctive reaction is to provide both via an options argument to
-> split_command_line (a name that would now be more appropriate). But I
-> haven't devoted much time to thinking this through, so I may be wrong. :-)
-> 
-> In any event, the tokenization isn't much fun. I'd expect the library to
-> provide a convenient mechanism for parsing a response file.
-
-
 > Similarly, is there some easy to use hook for customizing the "arg" to
 > indicate the type of the data (similar to how the textual representation
 > of the default argument can be changed, e.g.
@@ -217,22 +201,3 @@ More visibility for bool_switch.
 > as what can be achieved with the po::command_line_style::style_t enum. I
 > think most users will need this information sooner or later. A few
 > examples would be fine... But then again time is such a precious thing
-
-> Does the library supports sections in config files
-
-> What about the combination of (if some user-settable switch is thrown,
-> but not by default):
-> 
-> * allowing unknown options -- these are considered positional parameters
-> * rearranging the argument list such that all positional parameters
-> are moved to the end
-> 
-> This way:
-> 
-> program --unknown 42 --known-flag --known-arg value
-> 
-> is handled as if it were (in standard UNIX command-line-ese):
-> 
-> program --known-flag --known-arg value -- --unknown 42
-
-

doc/tutorial.xml

@@ -77,13 +77,14 @@ if (vm.count("compression")) {
   <para>It's now a good time to try compiling the code yourself, but if
     you're not yet ready, here's an example session:
 <screen>
-$ <userinput>bin/gcc/debug/first</userinput>
+$bin/gcc/debug/first
 Compression level was not set.
-$ <userinput>bin/gcc/debug/first --help</userinput>
+$bin/gcc/debug/first --help
 Allowed options:
   --help                 : produce help message
   --compression arg      : set compression level
-$ <userinput>bin/gcc/debug/first --compression 10</userinput>
+
+$bin/gcc/debug/first --compression 10
 Compression level was set to 10.
     </screen>
   </para>
@@ -96,7 +97,7 @@ Compression level was set to 10.
   <para>An option value, surely, can have other types than <code>int</code>, and
   can have other interesting properties, which we'll discuss right now. The
   complete version of the code snipped below can be found in
-  <filename>example/options_description.cpp</filename>.</para>
+  "example/options_description.cpp".</para>
 
   <para>Imagine we're writing a compiler. It should take the optimization
     level, a number of include paths, and a number of input files, and perform some
@@ -115,38 +116,30 @@ desc.add_options()
 </programlisting>
   </para>
 
-  <para>The <literal>"help"</literal> option should be familiar from 
-  the previous example. It's a good idea to have this option in all cases.
-  </para>
+  <para>The "--help" option should be familiar from the previous example. 
+    It's a good idea to have this option in all cases.</para>
 
-  <para>The <literal>"optimization"</literal> option shows two new features. First, we specify
+  <para>The "optimization" option shows two new features. First, we specify
     the address of the variable(<code>&amp;opt</code>). After storing values, that
     variable will have the value of the option. Second, we specify a default
     value of 10, which will be used if no value is specified by the user.
   </para>
 
-  <para>The <literal>"include-path"</literal> option is an example of the 
-  only case where the interface of the <code>options_description</code> 
-  class serves only one
+  <para>The "include-path" option is an example of the only case where
+    the interface of the <code>options_description</code> class serves only one
     source -- the command line. Users typically like to use short option names
     for common options, and the "include-path,I" name specifies that short
     option name is "I". So, both "--include-path" and "-I" can be used.
   </para>
-
-  <para>Note also that the type of the <literal>"include-path"</literal>
-  option is <type>std::vector</type>. The library provides special 
-  support for vectors -- it will be possible to specify the option several 
-  times, and all specified values will be collected in one vector.  
-  </para>
     
   <para>The "input-file" option specifies the list of files to
     process. That's okay for a start, but, of course, writing something like:
     <screen>
-<userinput>compiler --input-file=a.cpp</userinput>
+compiler --input-file=a.cpp
     </screen>
     is a little non-standard, compared with
     <screen>
-<userinput>compiler a.cpp</userinput>
+compiler a.cpp
     </screen>
     We'll address this in a moment.
   </para>
@@ -199,16 +192,16 @@ cout &lt;&lt; &quot;Optimization level is &quot; &lt;&lt; opt &lt;&lt; &quot;\n&
 
   <para>Here's an example session:
     <screen>
-$ <userinput>bin/gcc/debug/options_description --help</userinput>
+$bin/gcc/debug/options_description --help
 Usage: options_description [options]
 Allowed options:
   --help                 : produce help message
   --optimization arg     : optimization level
   -I [ --include-path ] arg : include path
   --input-file arg       : input file
-$ <userinput>bin/gcc/debug/options_description</userinput>
+$bin/gcc/debug/options_description
 Optimization level is 10
-$ <userinput>bin/gcc/debug/options_description --optimization 4 -I foo a.cpp</userinput>
+$bin/gcc/debug/options_description --optimization 4 -I foo a.cpp
 Include paths are: foo
 Input files are: a.cpp
 Optimization level is 4
@@ -308,10 +301,10 @@ visible.add(generic).add(config);
 
     <para>Here's an example session:
 <screen>
-$ <userinput>bin/gcc/debug/multiple_sources</userinput>
+$bin/gcc/debug/multiple_sources
 Include paths are: /opt
 Optimization level is 1
-$ <userinput>bin/gcc/debug/multiple_sources --help</userinput>
+$bin/gcc/debug/multiple_sources --help
 Allows options:
 
 Generic options:
@@ -322,7 +315,7 @@ Configuration:
   --optimization n       : optimization level
   -I [ --include-path ] path : include path
 
-$ <userinput>bin/gcc/debug/multiple_sources --optimization=4 -I foo a.cpp b.cpp</userinput>
+$bin/gcc/debug/multiple_sources --optimization=4 -I foo a.cpp b.cpp
 Include paths are: foo /opt
 Input files are: a.cpp b.cpp
 Optimization level is 4
@@ -345,7 +338,7 @@ Optimization level is 4
 
 <!--
      Local Variables:
-     mode: nxml
+     mode: xml
      sgml-indent-data: t     
      sgml-parent-document: ("program_options.xml" "section")
      sgml-set-face: t

example/Jamfile

@@ -0,0 +1,23 @@
+
+subproject libs/program_options/example ;
+
+rule program-options-example ( name extra-sources * )
+{
+    exe $(name) : $(name).cpp <lib>../build/boost_program_options $(extra-sources)
+    : <include>$(BOOST_ROOT) ;
+}
+
+program-options-example first ;
+program-options-example options_description ;
+program-options-example multiple_sources ;
+program-options-example custom_syntax ;
+program-options-example response_file ;
+program-options-example option_groups ;
+program-options-example real ;
+program-options-example regex <lib>../../regex/build/boost_regex ;
+
+
+#program-options-example prefix ;
+
+
+

example/Jamfile.v2

@@ -1,8 +1,7 @@
 
 project 
-    : requirements <library>../build//boost_program_options
+    : requirements <library>../build//program_options
       <hardcode-dll-paths>true
-      <link>static
     ;
 
 exe first : first.cpp ;
@@ -10,5 +9,7 @@ exe options_description : options_description.cpp ;
 exe multiple_sources : multiple_sources.cpp ;
 exe custom_syntax : custom_syntax.cpp ;
 
-exe real : real.cpp ;
-exe regex : regex.cpp /boost/regex//boost_regex ;
+exe a : a.cpp ;
+
+#exe real : real.cpp ;
+#exe regex : regex.cpp /boost/regex//boost_regex ;

example/multiple_sources.cpp

@@ -27,16 +27,13 @@ int main(int ac, char* av[])
 {
     try {
         int opt;
-        string config_file;
     
         // Declare a group of options that will be 
         // allowed only on command line
         po::options_description generic("Generic options");
         generic.add_options()
             ("version,v", "print version string")
-            ("help", "produce help message")
-            ("config,c", po::value<string>(&config_file)->default_value("multiple_sources.cfg"),
-                  "name of a file of a configuration.")
+            ("help", "produce help message")    
             ;
     
         // Declare a group of options that will be 
@@ -74,19 +71,10 @@ int main(int ac, char* av[])
         po::variables_map vm;
         store(po::command_line_parser(ac, av).
               options(cmdline_options).positional(p).run(), vm);
+
+        ifstream ifs("multiple_sources.cfg");
+        store(parse_config_file(ifs, config_file_options), vm);
         notify(vm);
-        
-        ifstream ifs(config_file.c_str());
-        if (!ifs)
-        {
-            cout << "can not open config file: " << config_file << "\n";
-            return 0;
-        }
-        else
-        {
-            store(parse_config_file(ifs, config_file_options), vm);
-            notify(vm);
-        }
     
         if (vm.count("help")) {
             cout << visible << "\n";

example/options_description.cpp

@@ -26,17 +26,11 @@ int main(int ac, char* av[])
 {
     try {
         int opt;
-        int portnum;
         po::options_description desc("Allowed options");
         desc.add_options()
             ("help", "produce help message")
             ("optimization", po::value<int>(&opt)->default_value(10), 
                   "optimization level")
-            ("verbose,v", po::value<int>()->implicit_value(1),
-                  "enable verbosity (optionally specify level)")
-            ("listen,l", po::value<int>(&portnum)->implicit_value(1001)
-                  ->default_value(0,"no"),
-                  "listen on a port.")
             ("include-path,I", po::value< vector<string> >(), 
                   "include path")
             ("input-file", po::value< vector<string> >(), "input file")
@@ -68,16 +62,9 @@ int main(int ac, char* av[])
                  << vm["input-file"].as< vector<string> >() << "\n";
         }
 
-        if (vm.count("verbose")) {
-            cout << "Verbosity enabled.  Level is " << vm["verbose"].as<int>()
-                 << "\n";
-        }
-
         cout << "Optimization level is " << opt << "\n";                
-
-        cout << "Listen port is " << portnum << "\n";                
     }
-    catch(std::exception& e)
+    catch(exception& e)
     {
         cout << e.what() << "\n";
         return 1;

example/regex.cpp

@@ -43,7 +43,7 @@ public:
 */
 void validate(boost::any& v, 
               const std::vector<std::string>& values,
-              magic_number*, int)
+              magic_number* target_type, int)
 {
     static regex r("\\d\\d\\d-(\\d\\d\\d)");
 
@@ -61,7 +61,7 @@ void validate(boost::any& v,
     if (regex_match(s, match, r)) {
         v = any(magic_number(lexical_cast<int>(match[1])));
     } else {
-        throw validation_error(validation_error::invalid_option_value);
+        throw validation_error("invalid value");
     }        
 }
 
@@ -94,7 +94,7 @@ int main(int ac, char* av[])
                  << vm["magic"].as<magic_number>().n << "\"\n";
         }
     }
-    catch(std::exception& e)
+    catch(exception& e)
     {
         cout << e.what() << "\n";
     }    

example/response_file.cpp

@@ -46,7 +46,6 @@ int main(int ac, char* av[])
             ("help", "produce a help message")
             ("include-path,I", value< vector<string> >()->composing(), 
                  "include path")
-            ("magic", value<int>(), "magic value")
             ("response-file", value<string>(), 
                  "can be specified with '@name', too")
         ;
@@ -70,8 +69,7 @@ int main(int ac, char* av[])
             ss << ifs.rdbuf();
             // Split the file content
             char_separator<char> sep(" \n\r");
-            string sstr = ss.str();
-            tokenizer<char_separator<char> > tok(sstr, sep);
+            tokenizer<char_separator<char> > tok(ss.str(), sep);
             vector<string> args;
             copy(tok.begin(), tok.end(), back_inserter(args));
             // Parse the file and store the options
@@ -84,11 +82,8 @@ int main(int ac, char* av[])
             copy(s.begin(), s.end(), ostream_iterator<string>(cout, " "));
             cout << "\n";
         }        
-        if (vm.count("magic")) {
-            cout << "Magic value: " << vm["magic"].as<int>() << "\n";
-        }
     }
-    catch (std::exception& e) {
+    catch(exception& e) {
         cout << e.what() << "\n";
     }
 }

example/response_file.rsp

@@ -1,3 +1,2 @@
 -I bar
--I biz
---magic 10
+-I biz

include/boost/program_options.hpp

@@ -3,8 +3,6 @@
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 
-//  See www.boost.org/libs/program_options for documentation.
-
 #ifndef PROGRAM_OPTIONS_VP_2003_05_19
 #define PROGRAM_OPTIONS_VP_2003_05_19
 

include/boost/program_options/cmdline.hpp

@@ -12,13 +12,13 @@ namespace boost { namespace program_options { namespace command_line_style {
     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.
+    for short option is also configurable.
 
-    Option's value can be specified in the same token as name
+    Option's value can be specified in the same token as value
     ("--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.
+    It's possible to introduce long option by the same character as
+    long option, see allow_long_disguise.
 
     Finally, guessing (specifying only prefix of option) and case
     insensitive processing are supported.
@@ -26,7 +26,7 @@ namespace boost { namespace program_options { namespace command_line_style {
     enum style_t {
         /// Allow "--long_name" style
         allow_long = 1,
-        /// Allow "-<single character" style
+        /// Alow "-<single character" style
         allow_short = allow_long << 1,
         /// Allow "-" in short options
         allow_dash_for_short = allow_short << 1,
@@ -39,7 +39,7 @@ namespace boost { namespace program_options { namespace command_line_style {
             @endverbatim
         */
         long_allow_adjacent = allow_slash_for_short << 1,
-        /** Allow option parameter in the next token for
+        /** Allow option parameter in the same token for
             long options. */
         long_allow_next = long_allow_adjacent << 1,
         /** Allow option parameter in the same token for
@@ -59,22 +59,17 @@ namespace boost { namespace program_options { namespace command_line_style {
         /** 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.
+            long option name is guessing is in effect.
         */
         allow_guessing = allow_sticky << 1,
-        /** Ignore the difference in case for long options.
+        /** Ignore the difference in case for options. 
+            @todo Should this apply to long options only?
         */            
-        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),        
+        case_insensitive = allow_guessing << 1,
         /** Allow long options with single option starting character,
             e.g <tt>-foo=10</tt>
         */
-        allow_long_disguise = short_case_insensitive << 1,
+        allow_long_disguise = 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

include/boost/program_options/detail/cmdline.hpp

@@ -10,10 +10,6 @@
 #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>
 
@@ -22,11 +18,6 @@
 #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:
@@ -64,9 +55,6 @@ namespace boost { namespace program_options { namespace detail {
         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
@@ -75,30 +63,12 @@ namespace boost { namespace program_options { namespace detail {
             unregistered options. They will be assigned index 1 and are
             assumed to have optional parameter.
         */
-        cmdline(const std::vector<std::string>& args);
+        cmdline(const std::vector<std::string>& args, int style,
+                bool allow_unregistered = false);
 
         /** @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);
-
+        cmdline(int argc, const char*const * argv, int style, 
+                bool allow_unregistered = false);
 
         /** Set additional parser. This will be called for each token
             of command line. If first string in pair is not empty,
@@ -110,38 +80,208 @@ namespace boost { namespace program_options { namespace detail {
         */
         void set_additional_parser(additional_parser p);
 
-        void extra_style_parser(style_parser s);
+        /** Registers a new option.
+            @param long_name Long name to use. When ending '*', symbols up to
+            it give an allowed prefix -- all options starting with it will be
+            allowed. The first character may not be '-'. Empty string means no
+            long name.
+            @param short_name Short name to use. Value of '\0' means no short
+            name.
+            @param properties Tell about possible parameters
+               '|' -- no parameter
+               '?' -- optional parameter
+               ':' -- required parameter
+               '*' -- 0 or more parameters
+               '+' -- 1 or more parameters
+            @param index A distinguishing value for the option.
+            The index will be returned by 'option_index' member function. 
+            Indices need not be unique -- e.g. client can set all indices to 0, 
+            and use the string value to recognize options.
+        */
+        void add_option(const std::string& long_name, char short_name,
+                        char properties = '|', int index = 0);
 
+        /** @overload */
+        void add_option(const char* long_name, char short_name,
+                        char properties = '|', int index = 0);
+
+
+        /** Returns false when nothing more can be extracted */
+        operator bool() const;
+
+        /** Advances to the next element on command line. 
+            When called for the first time, positions on the first element. */
+        cmdline& operator++();
+
+        /// Tells if the current element is option.
+        bool at_option() const;
+
+        /// Tells if the current element is argument.
+        bool at_argument() const;
+
+        /** Returns the option name. If there's long option name associated with
+            this option, it is returned, even if short name was used in command 
+            line.Otherwise, the short name given to 'add_option' is returned 
+            with a '-' prefix. 
+            For purposes of simplicity, '-' is used even when dos-style short 
+            option was found.
+        */
+        const std::string& option_name() const;
+        /** Returns the index for the current option. */
+        int option_index() const;
+        /** Returns the option name as found on the command line. Any symbols
+            that introduce the option, or delimit its parameter will be
+            stripped. This function allows to work with allowed prefixes, in
+            which case 'option_name' will return the prefix specification, and
+            full option name should be queried explicitly.
+            */
+        const std::string& raw_option_name() const;
+        /** Returns the first of option values. If there's more than one option
+            throws multiple_values. If there are no options, returns empty 
+            string. */
+        const std::string& option_value() const;
+        /** Returns all option values. */
+        const std::vector<std::string>& option_values() const;
+        /** Returns the argument. */
+        const std::string& argument() const;
+
+        /** Returns all arguments read by this command line parser. */
+        const std::vector<std::string>& arguments() const;
+
+        /** Returns the token that was current when 'operator++' was
+            last invoked. */
+        const std::string& last() const;
+
+    private:
+
+        // Properties of an option.
+        enum properties_t {
+            no_parameter = 1,
+            /// 0 or 1 parameter
+            allow_parameter,
+            /// exactly 1 parameter
+            require_parameter,
+            /// 0 or more parameters
+            allow_parameters,
+            /// 1 or more parameters 
+            require_parameters
+        };
+
+        enum element_kind_t {
+            ek_option = 0,
+            ek_argument
+        };
+
+        // General error status.
+        enum error_type_t {
+            no_error = 0,
+            unknown_option,
+            ambiguous_option,
+            invalid_syntax
+        };
+
+        // Detailed error status.
+        enum error_description_t {
+            ed_success = 0,
+            ed_long_not_allowed,
+            ed_long_adjacent_not_allowed,
+            ed_short_adjacent_not_allowed,
+            ed_empty_adjacent_parameter,
+            ed_missing_parameter,
+            ed_extra_parameter,
+            ed_unknown_option,
+            ed_ambiguous_option
+        };
+
+        // The standard say that nested classes has no access to
+        // private member of enclosing class. However, most compilers
+        // allow that and it's likely be to allowed in future:
+        // http://std.dkuug.dk/jtc1/sc22/wg21/docs/cwg_defects.html#45  
+        // For Sun compiler, try using friend declaration.
+#if BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x560))
+        struct option;
+        friend struct option;
+#endif
+
+        struct option {
+            option(const std::string& long_name, char short_name,
+                   properties_t properties, int index)
+            : long_name(long_name), short_name(short_name), index(index),
+            properties(properties)
+            {}
+
+            std::string long_name;
+            char short_name;
+            int index;
+            properties_t properties;
+        };
+
+
+        std::vector<option> options;
+
+        void init(const std::vector<std::string>& args, int style,
+                  bool allow_unregistered);
         void check_style(int style) const;
-        
-        bool is_style_active(style_t style) const;
+       
+        void next();
 
-        void init(const std::vector<std::string>& args);
+        const option* find_long_option(const char* name);
+        const option* find_short_option(char name);
 
-        void
-        finish_option(option& opt,
-                      std::vector<std::string>& other_tokens,
-                      const std::vector<style_parser>& style_parsers);
+        enum option_kind { error_option, no_option, long_option, short_option,
+                           dos_option };
+        option_kind is_option(const char* s);
+        // All handle_* member functions take string without any "--" or "-" or "/"
+        // They return true and success and set m_num_tokens to the number of
+        // tokens that were consumed.
+        bool handle_long_option(const char* s);
+        bool handle_short_option(const char* s, bool ignore_sticky = false);
+        bool handle_dos_option(const char* s);
+        // Attempts to apply additional parser to 's'.
+        bool handle_additional_parser(const std::pair<std::string, std::string>& p);
+
+        bool process_parameter(const option* opt, bool adjacent_parameter,
+                              bool next_parameter);
+        void advance(int count);
+
+        /// Converts parameter property character into enum value.
+        properties_t translate_property(char p);
+
+        /** Clears the error state. If there were an error, throws appripriate
+            exception. */
+        void clear_error();
 
         // Copies of input.
         std::vector<std::string> args;
-        style_t m_style;
-        bool m_allow_unregistered;
+        style_t style;
+        bool allow_unregistered;
 
-        const options_description* m_desc;
-        const positional_options_description* m_positional;
+        // Current state of parsing.
+        unsigned index;
+        const char* m_current;
+        const char* m_next;
+        const char* pending_short_option;
+        bool m_no_more_options;
+        error_description_t m_error_description;
+        element_kind_t m_element_kind;
+        int m_option_index;
+
+        // Results of parsing the last option
+        std::string m_last;
+        const option* m_opt;
+        std::string  m_option_name, m_raw_option_name, m_argument;
+        std::vector<std::string> m_option_values; 
+        int m_num_tokens;
+        bool m_disguised_long;
+
+        std::vector<std::string> m_arguments;
 
         additional_parser m_additional_parser;
-        style_parser m_style_parser;
     };
     
     void test_cmdline_detail();
     
 }}}
 
-#if defined(BOOST_MSVC)
-#   pragma warning (pop)
-#endif
-
 #endif
 

include/boost/program_options/detail/config_file.hpp

@@ -21,10 +21,6 @@
 #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>
@@ -70,8 +66,7 @@ namespace boost { namespace program_options { namespace detail {
     public:
         common_config_file_iterator() { found_eof(); }
         common_config_file_iterator(
-            const std::set<std::string>& allowed_options,
-            bool allow_unregistered = false);
+            const std::set<std::string>& allowed_options);
 
         virtual ~common_config_file_iterator() {}
 
@@ -104,7 +99,6 @@ namespace boost { namespace program_options { namespace detail {
         // 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>
@@ -118,8 +112,7 @@ namespace boost { namespace program_options { namespace detail {
         /** 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); 
+                                   const std::set<std::string>& allowed_options); 
 
     private: // base overrides
 
@@ -142,9 +135,8 @@ namespace boost { namespace program_options { namespace detail {
     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)
+                               const std::set<std::string>& allowed_options)
+    : common_config_file_iterator(allowed_options)
     {
         this->is.reset(&is, null_deleter());                 
         get();
@@ -168,8 +160,7 @@ namespace boost { namespace program_options { namespace detail {
     }
 
     // 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)))
+#if BOOST_WORKAROUND(__COMO_VERSION__, BOOST_TESTED_AT(4303))
     template<>
     bool
     basic_config_file_iterator<wchar_t>::getline(std::string& s);

include/boost/program_options/detail/convert.hpp

@@ -19,7 +19,7 @@
 #include <cwchar>
 #include <stdexcept>
 
-#if defined(BOOST_NO_STDC_NAMESPACE)
+#if BOOST_WORKAROUND(__ICL, <= 700) || BOOST_WORKAROUND(_MSC_VER, <= 1200)
 #include <wchar.h>
 namespace std
 {

include/boost/program_options/detail/parsers.hpp

@@ -8,8 +8,6 @@
 
 #include <boost/program_options/detail/convert.hpp>
 
-#include <iterator>
-
 namespace boost { namespace program_options {
 
     namespace detail {
@@ -29,18 +27,18 @@ namespace boost { namespace program_options {
     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))
+                              std::basic_string<charT> >& args)
+    : common_command_line_parser(to_internal(args))
     {}
 
 
     template<class charT>
     basic_command_line_parser<charT>::
-    basic_command_line_parser(int argc, const charT* const argv[])
-    : detail::cmdline(
+    basic_command_line_parser(int argc, charT* argv[])
+    : common_command_line_parser(
         // 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)))
+        to_internal(detail::make_vector<charT, charT**>(argv+1, argv+argc)))
     {}
 
     
@@ -48,7 +46,6 @@ namespace boost { namespace program_options {
     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;
     }
@@ -58,15 +55,15 @@ namespace boost { namespace program_options {
     basic_command_line_parser<charT>::positional(
         const positional_options_description& desc)
     {
-        detail::cmdline::set_positional_options(desc);
+        m_positional = &desc;
         return *this;
     }
 
     template<class charT>
     basic_command_line_parser<charT>& 
-    basic_command_line_parser<charT>::style(int xstyle)
+    basic_command_line_parser<charT>::style(int style)
     {
-        detail::cmdline::style(xstyle);
+        m_style = style;
         return *this;
     }
 
@@ -74,44 +71,24 @@ namespace boost { namespace program_options {
     basic_command_line_parser<charT>& 
     basic_command_line_parser<charT>::extra_parser(ext_parser ext)
     {
-        detail::cmdline::set_additional_parser(ext);
+        m_ext = 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()
+    basic_command_line_parser<charT>::run() const
     {
-        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);
+        return basic_parsed_options<charT>(
+            common_command_line_parser::run());
     }
 
 
     template<class charT>
     basic_parsed_options<charT>
-    parse_command_line(int argc, const charT* const argv[],
+    parse_command_line(int argc, charT* argv[],
                        const options_description& desc,
                        int style,
                        function1<std::pair<std::string, std::string>, 
@@ -121,26 +98,6 @@ namespace boost { namespace program_options {
             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

include/boost/program_options/detail/utf8_codecvt_facet.hpp

@@ -1,25 +1,221 @@
-// Copyright (c) 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
+#ifndef BOOST_UTF8_CODECVT_FACET_HPP
+#define BOOST_UTF8_CODECVT_FACET_HPP
+
+// MS compatible compilers support #pragma once
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
+#endif
+
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// utf8_codecvt_facet.hpp
+
+// Copyright © 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
+// Note:(Robert Ramey).  I have made the following alterations in the original
+// code.
+// a) Rendered utf8_codecvt<wchar_t, char>  with using templates
+// b) Move longer functions outside class definition to prevent inlining
+// and make code smaller
+// c) added on a derived class to permit translation to/from current
+// locale to utf8
+
+//  See http://www.boost.org for updates, documentation, and revision history.
+
+// archives stored as text - note these ar templated on the basic
+// stream templates to accommodate wide (and other?) kind of characters
+//
+// note the fact that on libraries without wide characters, ostream is
+// is not a specialization of basic_ostream which in fact is not defined
+// in such cases.   So we can't use basic_ostream<OStream::char_type> but rather
+// use two template parameters
+//
+// utf8_codecvt_facet
+//   This is an implementation of a std::codecvt facet for translating 
+//   from UTF-8 externally to UCS-4.  Note that this is not tied to
+//   any specific types in order to allow customization on platforms
+//   where wchar_t is not big enough.
+//
+// NOTES:  The current implementation jumps through some unpleasant hoops in
+// order to deal with signed character types.  As a std::codecvt_base::result,
+// it is necessary  for the ExternType to be convertible to unsigned  char.
+// I chose not to tie the extern_type explicitly to char. But if any combination
+// of types other than <wchar_t,char_t> is used, then std::codecvt must be
+// specialized on those types for this to work.
+
+#include <locale>
+// for mbstate_t
+#include <wchar.h>
 
 #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
-
+#include <boost/detail/workaround.hpp>
+#if BOOST_WORKAROUND(__BORLANDC__,BOOST_TESTED_AT(0x551))
+    #ifndef _RWSTD_NO_NAMESPACE
+    using std::codecvt;
+    using std::min;
+    #ifdef _RWSTD_NO_MBSTATE_T
+    using std::mbstate_t;
+    #endif
+    #endif
+#elif defined(__COMO__) || defined(_MSC_VER) && _MSC_VER <= 1300 
+    typedef ::mbstate_t mbstate_t;
+#elif defined(BOOST_NO_STDC_NAMESPACE)
+    typedef std::mbstate_t mbstate_t;
+    namespace std{ 
+        using ::codecvt; 
+    } // namespace std
 #endif
+
+// maximum lenght of a multibyte string
+#define MB_LENGTH_MAX 8
+
+namespace boost { namespace program_options { namespace detail {
+
+struct BOOST_PROGRAM_OPTIONS_DECL utf8_codecvt_facet_wchar_t :
+    public std::codecvt<wchar_t, char, mbstate_t>  
+{
+public:
+    explicit utf8_codecvt_facet_wchar_t(std::size_t no_locale_manage=0)
+        : std::codecvt<wchar_t, char, mbstate_t>(no_locale_manage) 
+    {}
+protected:
+    virtual std::codecvt_base::result do_in(
+        mbstate_t& state, 
+        const char * from,
+        const char * from_end, 
+        const char * & from_next,
+        wchar_t * to, 
+        wchar_t * to_end, 
+        wchar_t*& to_next
+    ) const;
+
+    virtual std::codecvt_base::result do_out(
+        mbstate_t & state, const wchar_t * from,
+        const wchar_t * from_end, const wchar_t*  & from_next,
+        char * to, char * to_end, char * & to_next
+    ) const;
+
+    bool invalid_continuing_octet(unsigned char octet_1) const {
+        return (octet_1 < 0x80|| 0xbf< octet_1);
+    }
+
+    bool invalid_leading_octet(unsigned char octet_1)   const {
+        return (0x7f < octet_1 && octet_1 < 0xc0) ||
+            (octet_1 > 0xfd);
+    }
+
+    // continuing octets = octets except for the leading octet
+    static unsigned int get_cont_octet_count(unsigned   char lead_octet) {
+        return get_octet_count(lead_octet) - 1;
+    }
+
+    static unsigned int get_octet_count(unsigned char   lead_octet);
+
+    // How many "continuing octets" will be needed for this word
+    // ==   total octets - 1.
+    int get_cont_octet_out_count(wchar_t word) const ;
+
+    virtual bool do_always_noconv() const throw() { return false; }
+
+    // UTF-8 isn't really stateful since we rewind on partial conversions
+    virtual std::codecvt_base::result do_unshift(
+        mbstate_t&,
+        char * from,
+        char * to,
+        char * & next
+    ) const 
+    {
+        next = from;
+        return ok;
+    }
+
+    virtual int do_encoding() const throw() {
+        const int variable_byte_external_encoding=0;
+        return variable_byte_external_encoding;
+    }
+
+    // How many char objects can I process to get <= max_limit
+    // wchar_t objects?
+    virtual int do_length(
+        mbstate_t &,
+        const char * from,
+        const char * from_end, 
+        std::size_t max_limit
+#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
+        ) const throw();
+#else
+        ) const;
+#endif
+
+    // Largest possible value do_length(state,from,from_end,1) could return.
+    virtual int do_max_length() const throw () {
+        return 6; // largest UTF-8 encoding of a UCS-4 character
+    }
+};
+
+#if 0 // not used - incorrect in any case
+// Robert Ramey - use the above to make a code converter from multi-byte
+// char strings to utf8 encoding
+struct utf8_codecvt_facet_char : public utf8_codecvt_facet_wchar_t
+{
+    typedef utf8_codecvt_facet_wchar_t base_class;
+public:
+    explicit utf8_codecvt_facet_char(size_t no_locale_manage=0)
+        : base_class(no_locale_manage)
+    {}
+protected:
+    virtual std::codecvt_base::result do_in(
+        mbstate_t & state, 
+        const char * from, 
+        const char * from_end, 
+        const char * & from_next,
+        char * to, 
+        char * to_end, 
+        char * & to_next
+    ) const;
+
+    virtual std::codecvt_base::result do_out(
+        mbstate_t & state, 
+        const char * from,
+        const char * from_end, 
+        const char*  & from_next,
+        char * to, 
+        char * to_end, 
+        char * & to_next
+    ) const;
+
+    // How many char objects can I process to get <= max_limit
+    // char objects?
+    virtual int do_length(
+        const mbstate_t&, 
+        const char * from,
+        const char * from_end, 
+        size_t max_limit
+    ) const;
+};
+#endif
+
+template<class Internal, class External>
+struct utf8_codecvt_facet
+{};
+
+template<>
+struct BOOST_PROGRAM_OPTIONS_DECL utf8_codecvt_facet<wchar_t, char>
+    : public utf8_codecvt_facet_wchar_t
+{};
+
+#if 0
+template<>
+struct utf8_codecvt_facet<char, char>
+    : public utf8_codecvt_facet_char
+{};
+#endif
+
+}}}
+
+#endif // BOOST_UTF8_CODECVT_FACET_HPP

include/boost/program_options/detail/value_semantic.hpp

@@ -6,8 +6,6 @@
 // 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;
@@ -16,13 +14,7 @@ namespace boost { namespace program_options {
     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()) {
+        if (!m_default_value.empty() && !m_default_value_as_text.empty()) {
             return arg + " (=" + m_default_value_as_text + ")";
         } else {
             return arg;
@@ -33,7 +25,7 @@ namespace boost { namespace program_options {
     void 
     typed_value<T, charT>::notify(const boost::any& value_store) const
     {
-        const T* value = boost::any_cast<T>(&value_store);
+        const T* value = boost::any_cast<const T>(&value_store);
         if (m_store_to) {
             *m_store_to = *value;
         }
@@ -55,12 +47,13 @@ namespace boost { namespace program_options {
         {
             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)
+                throw validation_error("multiple values not allowed");
+            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;
+            else if (allow_empty)
+                return empty;
+            else
+                throw validation_error("at least one value required");
         }
 
         /* Throws multiple_occurrences if 'value' is not empty. */
@@ -88,7 +81,7 @@ namespace boost { namespace program_options {
             v = any(lexical_cast<T>(s));
         }
         catch(const bad_lexical_cast&) {
-            boost::throw_exception(invalid_option_value(s));
+            throw invalid_option_value(s);
         }
     }
 
@@ -135,21 +128,14 @@ namespace boost { namespace program_options {
             v = boost::any(std::vector<T>());
         }
         std::vector<T>* tv = boost::any_cast< std::vector<T> >(&v);
-        assert(NULL != tv);
+        assert(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));
+                tv->push_back(boost::lexical_cast<T>(s[i]));
             }
             catch(const bad_lexical_cast& /*e*/) {
-                boost::throw_exception(invalid_option_value(s[i]));
+                throw invalid_option_value(s[i]);
             }
         }
     }
@@ -160,13 +146,7 @@ namespace boost { namespace program_options {
     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);
+        validate(value_store, new_tokens, (T*)0, 0);
     }
 
     template<class T>

include/boost/program_options/errors.hpp

@@ -13,110 +13,59 @@
 #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) {}
+        error(const std::string& what) : std::logic_error(what) {}
     };
 
     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);
+        invalid_syntax(const std::string& tokens, const std::string& msg)
+        : error(std::string(msg).append(" in '").append(tokens).append("'")),
+          tokens(tokens), msg(msg)                       
+        {}
 
         // 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;
+        std::string tokens, msg;
     };
 
     /** 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)
+        : error(std::string("unknown option ").append(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)
+                         const std::vector<std::string>& alternatives)
+        : error(std::string("ambiguous option ").append(name)),
+          alternatives(alternatives)
         {}
 
         ~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;
+        std::vector<std::string> alternatives;
     };
 
     /** 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.        
+        multiple_values(const std::string& what) : error(what) {}
     };
 
     /** Class thrown when there are several occurrences of an
@@ -124,58 +73,22 @@ namespace boost { namespace program_options {
         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.
+        multiple_occurrences(const std::string& what) : error(what) {}
     };
 
     /** 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(const std::string& what) : error(what) {}
         ~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;
+        mutable std::string m_message; // For on-demand formatting in 'what'
         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'
-
+        const char* what() const throw();  
     };
 
-    /** Class thrown if there is an invalid option value givenn */
     class BOOST_PROGRAM_OPTIONS_DECL invalid_option_value 
         : public validation_error
     {
@@ -186,23 +99,39 @@ namespace boost { namespace program_options {
 #endif
     };
 
-    /** Class thrown when there are too many positional options. 
-        This is a programming error.
-    */
+    /** Class thrown when there are too many positional options. */
     class BOOST_PROGRAM_OPTIONS_DECL too_many_positional_options_error : public error {
     public:
-        too_many_positional_options_error() 
-         : error("too many positional options") 
-        {}
+        too_many_positional_options_error(const std::string& what) 
+        : error(what) {}
+    };
+
+    /** Class thrown when there are too few positional options. */
+    class BOOST_PROGRAM_OPTIONS_DECL too_few_positional_options_error : public error {
+    public:
+        too_few_positional_options_error(const std::string& what) 
+        : error(what) {}
     };
 
-    /** Class thrown when there are syntax errors in given command line */
     class BOOST_PROGRAM_OPTIONS_DECL invalid_command_line_syntax : public invalid_syntax {
     public:
+        enum kind_t {
+            long_not_allowed = 30,
+            long_adjacent_not_allowed,
+            short_adjacent_not_allowed,
+            empty_adjacent_parameter,
+            missing_parameter,
+            extra_parameter
+        };
+
         invalid_command_line_syntax(const std::string& tokens, kind_t kind);
+        kind_t kind() const;
+    protected:
+        static std::string error_message(kind_t kind);
+    private:
+        kind_t m_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)
@@ -210,34 +139,7 @@ namespace boost { namespace program_options {
         {}
     };
 
-    /** 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

include/boost/program_options/option.hpp

@@ -23,17 +23,10 @@ namespace boost { namespace program_options {
     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)
+        basic_option() : position_key(-1) {}
+        basic_option(const std::string& string_key, 
+               const std::vector< std::string> &value) 
+        : string_key(string_key), value(value)
         {}
 
         /** String key of this option. Intentionally independent of the template
@@ -48,19 +41,6 @@ namespace boost { namespace program_options {
         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;

include/boost/program_options/options_description.hpp

@@ -1,5 +1,4 @@
 // 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)
@@ -25,12 +24,6 @@
 
 #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. */
@@ -71,7 +64,7 @@ namespace program_options {
             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.
+            after -- long name.
         */
         option_description(const char* name,
                            const value_semantic* s);
@@ -84,26 +77,11 @@ namespace program_options {
 
         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;
+        /// Name to be used with short-style option ("-w").
+        const std::string& short_name() const;
 
+        /// Name to be used with long-style option ("--whatever").
         const std::string& long_name() const;
-
         /// Explanation of this option
         const std::string& description() const;
 
@@ -113,15 +91,16 @@ namespace program_options {
         /// Returns the option name, formatted suitably for usage message. 
         std::string format_name() const;
 
-        /** Returns the parameter name and properties, formatted suitably for
+        /** Return the parameter name and properties, formatted suitably for
             usage message. */
         std::string format_parameter() const;
 
     private:
-    
-        option_description& set_name(const char* name);
+
+        option_description& name(const char* name);
 
         std::string m_short_name, m_long_name, m_description;
+        std::string m_default_value, m_default_parameter;
         // shared_ptr is needed to simplify memory management in
         // copy ctor and destructor.
         shared_ptr<const value_semantic> m_value_semantic;
@@ -162,21 +141,13 @@ namespace program_options {
     */
     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);
+        options_description();
         /** 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);
+        options_description(const std::string& caption);
         /** Adds new variable description. Throws duplicate_variable_error if
             either short or long name matches that of already present one. 
         */
@@ -198,18 +169,32 @@ namespace program_options {
         */
         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;
+        /** Count the number of option descriptions with given name. 
+            Returns 0 or 1.
+            The 'name' parameter can be either name of long option, and short
+            option prefixed by '-'.
+        */
+        unsigned count(const std::string& name) const;
+        /** Count the number of descriptions having the given string as
+            prefix. This makes sense only for long options.
+        */
+        unsigned count_approx(const std::string& prefix) const;
+        /** Returns description given a name. 
+            @pre count(name) == 1
+        */
+        const option_description& find(const std::string& name) const;
+        /** Returns description given a prefix. Throws
+            @pre count_approx(name) == 1 
+        */
+        const option_description& find_approx(const std::string& prefix) const;
+        /// Returns all such strings x for which count(x) == 1
+        std::set<std::string> keys() const;
+        /** For each option description stored, contains long name if not empty,
+            if it is empty, short name is returned.
+        */
+        std::set<std::string> primary_keys() const;
+        /// Returns all such long options for which 'prefix' is prefix
+        std::set<std::string> approximations(const std::string& prefix) const;
 
         /** Produces a human readable output of 'desc', listing options,
             their descriptions and allowed parameters. Other options_description
@@ -217,7 +202,7 @@ namespace program_options {
         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
+        /** Output 'desc' to the specified stream, calling 'f' to output each
             option_description element. */
         void print(std::ostream& os) const;
 
@@ -226,17 +211,15 @@ namespace program_options {
         typedef std::pair<name2index_iterator, name2index_iterator> 
             approximation_range;
 
-        //approximation_range find_approximation(const std::string& prefix) const;
+
+        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;
-
+        std::vector< shared_ptr<option_description> > options;
+        std::map<std::string, int> name2index;
         // 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
@@ -253,12 +236,8 @@ namespace program_options {
     /** 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) {}
+        duplicate_option_error(const std::string& what) : error(what) {}
     };
 }}
 
-#if defined(BOOST_MSVC)
-#   pragma warning (pop)
-#endif
-
 #endif

include/boost/program_options/parsers.hpp

@@ -9,7 +9,6 @@
 
 #include <boost/program_options/config.hpp>
 #include <boost/program_options/option.hpp>
-#include <boost/program_options/detail/cmdline.hpp>
 
 #include <boost/function/function1.hpp>
 
@@ -17,11 +16,6 @@
 #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;
@@ -36,8 +30,8 @@ namespace boost { namespace program_options {
     template<class charT>
     class basic_parsed_options {
     public:
-        explicit basic_parsed_options(const options_description* xdescription) 
-        : description(xdescription) {}
+        explicit basic_parsed_options(const options_description* description) 
+        : description(description) {}
         /** Options found in the source. */
         std::vector< basic_option<charT> > options;
         /** Options description that was used for parsing. 
@@ -75,22 +69,37 @@ namespace boost { namespace program_options {
 
     typedef function1<std::pair<std::string, std::string>, const std::string&> ext_parser;
 
+    /** Character-type independent command line parser. */
+    class BOOST_PROGRAM_OPTIONS_DECL common_command_line_parser {
+    public:
+        /// Creates the parsers. The arguments must be in internal encoding.
+        common_command_line_parser(const std::vector<std::string>& args);
+        /// Parses the command line and returns parsed options in internal
+        /// encoding.
+        parsed_options run() const;
+    protected:
+        int m_style;
+        const options_description* m_desc;
+        const positional_options_description* m_positional;
+        function1<std::pair<std::string, std::string>, const std::string&> m_ext;
+
+        // Intentionally independent from charT
+        std::vector<std::string> m_args;
+    };
+
     /** 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
+        and to parser the 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 {
+    class basic_command_line_parser : private common_command_line_parser {
     public:
         /** Creates a command line parser for the specified arguments
             list. The 'args' parameter should not include program name.
@@ -98,9 +107,9 @@ namespace boost { namespace program_options {
         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'.
+            list. The parameter should be the same as passes to 'main'.
         */
-        basic_command_line_parser(int argc, const charT* const argv[]);
+        basic_command_line_parser(int argc, charT* argv[]);
 
         /** Sets options descriptions to use. */
         basic_command_line_parser& options(const options_description& desc);
@@ -112,28 +121,9 @@ namespace boost { namespace program_options {
         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);
-
+        basic_parsed_options<charT> run() const;
     private:
-        const options_description* m_desc;
     };
 
     typedef basic_command_line_parser<char> command_line_parser;
@@ -144,7 +134,7 @@ namespace boost { namespace program_options {
      */
     template<class charT>
     basic_parsed_options<charT>
-    parse_command_line(int argc, const charT* const argv[],
+    parse_command_line(int argc, charT* argv[],
                        const options_description&,
                        int style = 0,
                        function1<std::pair<std::string, std::string>, 
@@ -152,45 +142,13 @@ namespace boost { namespace program_options {
                        = 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_config_file(std::basic_istream<charT>&, const options_description&);
 
     /** Parse environment. 
 
@@ -222,24 +180,6 @@ namespace boost { namespace program_options {
     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
@@ -256,12 +196,11 @@ namespace boost { namespace program_options {
     split_winmain(const std::wstring& cmdline);
     #endif
 #endif
-    
 
 }}
 
 #undef DECL
 
-#include "boost/program_options/detail/parsers.hpp"
+#include "detail/parsers.hpp"
 
 #endif

include/boost/program_options/positional_options.hpp

@@ -11,11 +11,6 @@
 #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. 
@@ -42,11 +37,10 @@ namespace boost { namespace program_options {
             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);
+        void 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
+            be present. Can return numeric_limits<unsigned>::max() to
             indicate unlimited number. */
         unsigned max_total_count() const;
 
@@ -66,9 +60,5 @@ namespace boost { namespace program_options {
 
 }}
 
-#if defined(BOOST_MSVC)
-#   pragma warning (pop)
-#endif
-
 #endif
 

include/boost/program_options/value_semantic.hpp

@@ -14,9 +14,9 @@
 #include <boost/lexical_cast.hpp>
 
 
+
 #include <string>
 #include <vector>
-#include <typeinfo>
 
 namespace boost { namespace program_options {
 
@@ -30,13 +30,11 @@ namespace boost { namespace program_options {
          */
         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 value cannot be specified in source at all.
+            Other methods can still set the value somehow, but
+            user can't affect it.
+        */
+        virtual bool is_zero_tokens() const = 0;
 
         /** Returns true if values from different sources should be composed.
             Otherwise, value from the first source is used and values from
@@ -44,10 +42,12 @@ namespace boost { namespace program_options {
         */
         virtual bool is_composing() const = 0;
 
-        /** Returns true if value must be given. Non-optional value
-
+        /** Returns true if explicit value of an option can be omitted. 
         */
-        virtual bool is_required() const = 0;
+        virtual bool is_implicit() const = 0;
+
+        /** Returns true if value can span several token in input source. */
+        virtual bool is_multitoken() const = 0;
         
         /** Parses a group of tokens that specify a value of option.
             Stores the result in 'value_store', using whatever representation
@@ -79,13 +79,6 @@ namespace boost { namespace program_options {
         // 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 {
@@ -99,13 +92,6 @@ namespace boost { namespace program_options {
             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 {
@@ -120,7 +106,6 @@ namespace boost { namespace program_options {
             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 
@@ -132,12 +117,10 @@ namespace boost { namespace program_options {
 
         std::string name() const;
 
-        unsigned min_tokens() const;
-        unsigned max_tokens() const;
-
+        bool is_zero_tokens() const { return m_zero_tokens; }
         bool is_composing() const { return false; }
-
-        bool is_required() const { return false; }
+        bool is_implicit() const { return false; }
+        bool is_multitoken() const { return false; }
         
         /** If 'value_store' is already initialized, or new_tokens
             has more than one elements, throws. Otherwise, assigns
@@ -156,36 +139,15 @@ namespace boost { namespace program_options {
         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
-    {
+    class typed_value : public value_semantic_codecvt_helper<charT>  {
     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)
+          m_implicit(false), m_multitoken(false), m_zero_tokens(false)
         {} 
 
         /** Specifies default value, which will be used
@@ -212,38 +174,6 @@ namespace boost { namespace program_options {
             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)
@@ -261,6 +191,13 @@ namespace boost { namespace program_options {
             return this;
         }
 
+        /** Specifies that the value is implicit. */
+        typed_value* implicit()
+        {
+            m_implicit =  true;
+            return this;
+        }
+
         /** Specifies that the value can span multiple tokens. */
         typed_value* multitoken()
         {
@@ -274,42 +211,19 @@ namespace boost { namespace program_options {
             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_zero_tokens() const { return m_zero_tokens; }
         bool is_composing() const { return m_composing; }
+        bool is_implicit() const { return m_implicit; }        
+        bool is_multitoken() const { return m_multitoken; }
 
-        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. */
+            its operator() to perform athe ctual conversion. */
         void xparse(boost::any& value_store, 
                     const std::vector< std::basic_string<charT> >& new_tokens) 
             const;
@@ -332,13 +246,6 @@ namespace boost { namespace program_options {
             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:
@@ -348,9 +255,7 @@ namespace boost { namespace program_options {
         // 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;
+        bool m_composing, m_implicit, m_multitoken, m_zero_tokens;
         boost::function1<void, const T&> m_notifier;
     };
 
@@ -399,7 +304,7 @@ namespace boost { namespace program_options {
 
 }}
 
-#include "boost/program_options/detail/value_semantic.hpp"
+#include "detail/value_semantic.hpp"
 
 #endif
 

include/boost/program_options/variables_map.hpp

@@ -14,12 +14,6 @@
 
 #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 {
 
@@ -29,50 +23,22 @@ namespace boost { namespace program_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) 
+        variable_value(const boost::any& v, bool defaulted) 
+        : v(v), m_defaulted(defaulted) 
         {}
 
         /** 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);
-       }
+        template<class T> const T& as() const;
+
+        /** @overload */
+        template<class T> T& as();
 
         /// Returns true if no value is stored.
         bool empty() const;
@@ -94,11 +60,10 @@ namespace boost { namespace program_options {
         // 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, 
+        friend void BOOST_PROGRAM_OPTIONS_DECL 
+        store(const basic_parsed_options<char>& options, 
               variables_map& m, bool);
-
-        friend BOOST_PROGRAM_OPTIONS_DECL class variables_map;
+        friend void BOOST_PROGRAM_OPTIONS_DECL notify(variables_map& m);
     };
 
     /** Implements string->string mapping with convenient value casting
@@ -138,11 +103,7 @@ namespace boost { namespace program_options {
         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.
-    */
+    /** Concrete variables map which store variables in real map. */
     class BOOST_PROGRAM_OPTIONS_DECL variables_map : public abstract_variables_map,
                                public std::map<std::string, variable_value>
     {
@@ -153,28 +114,32 @@ namespace boost { namespace program_options {
         // 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;
     };
 
+    /** 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);
+
 
     /*
      * Templates/inlines
@@ -206,6 +171,24 @@ namespace boost { namespace program_options {
         return v;
     }
 
+
+    template<class T>
+    const T&
+    variable_value::as() const {
+        const T* r = boost::any_cast<T>(&v);
+        if (!r)
+            throw boost::bad_any_cast();
+        return *r;
+    }
+
+    template<class T>
+    T&
+    variable_value::as() {
+        T* r = boost::any_cast<T>(&v);
+        if (!r)
+            throw boost::bad_any_cast();
+        return *r;
+    }
 }}
 
 #endif

index.html

@@ -4,11 +4,6 @@
 </head>
 <body>
 Automatic redirection failed, please go to
-<a href="../../doc/html/program_options.html">../../doc/html/program_options.html</a> 
-&nbsp;<hr>
-<p>© Copyright Beman Dawes, 2001</p>
-<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
-file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
-at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
+<a href="../../doc/html/program_options.html">../../doc/html/program_options.html</a>
 </body>
-</html>
+</html>

src/config_file.cpp

@@ -10,7 +10,6 @@
 #include <boost/program_options/detail/config_file.hpp>
 #include <boost/program_options/errors.hpp>
 #include <boost/program_options/detail/convert.hpp>
-#include <boost/throw_exception.hpp>
 
 #include <iostream>
 #include <fstream>
@@ -21,10 +20,8 @@ namespace boost { namespace program_options { namespace detail {
     using namespace std;
 
     common_config_file_iterator::common_config_file_iterator(
-        const std::set<std::string>& allowed_options,
-        bool allow_unregistered)
-    : allowed_options(allowed_options),
-      m_allow_unregistered(allow_unregistered)
+        const std::set<std::string>& allowed_options)
+    : allowed_options(allowed_options)
     {
         for(std::set<std::string>::const_iterator i = allowed_options.begin();
             i != allowed_options.end(); 
@@ -57,7 +54,7 @@ namespace boost { namespace program_options { namespace detail {
                     bad_prefixes = true;
             }
             if (bad_prefixes)
-                boost::throw_exception(error("bad prefixes"));
+                throw error("bad prefixes");
             allowed_prefixes.insert(s);
         }
     }
@@ -102,22 +99,20 @@ namespace boost { namespace program_options { namespace detail {
                     string name = m_prefix + trim_ws(s.substr(0, n));
                     string value = trim_ws(s.substr(n+1));
 
-                    bool registered = allowed_option(name);
-                    if (!registered && !m_allow_unregistered)
-                        boost::throw_exception(unknown_option(name));
-
+                    if (!allowed_option(name))
+                        throw unknown_option(name);
+                                        
+                    if (value.empty())
+                        throw invalid_syntax(s, "no value given");
+                    
                     found = true;
                     this->value().string_key = name;
                     this->value().value.clear();
                     this->value().value.push_back(value);
-                    this->value().unregistered = !registered;
-                    this->value().original_tokens.clear();
-                    this->value().original_tokens.push_back(name);
-                    this->value().original_tokens.push_back(value);
                     break;
 
                 } else {
-                    boost::throw_exception(invalid_syntax(s, invalid_syntax::unrecognized_line));
+                    throw invalid_syntax(s, "unrecognized line");
                 }
             }
         }
@@ -141,8 +136,9 @@ namespace boost { namespace program_options { namespace detail {
         return false;
     }
 
-#if BOOST_WORKAROUND(__COMO_VERSION__, BOOST_TESTED_AT(4303)) || \
-        (defined(__sgi) && BOOST_WORKAROUND(_COMPILER_VERSION, BOOST_TESTED_AT(741)))
+// On Metrowerks, the function is defined inline.
+
+#if BOOST_WORKAROUND(__COMO_VERSION__, BOOST_TESTED_AT(4303))
     template<>
     bool
     basic_config_file_iterator<wchar_t>::getline(std::string& s)

src/convert.cpp

@@ -17,7 +17,6 @@
 #include <boost/program_options/config.hpp>
 #include <boost/program_options/detail/convert.hpp>
 #include <boost/program_options/detail/utf8_codecvt_facet.hpp>
-#include <boost/throw_exception.hpp>
 
 #include <boost/bind.hpp>
 
@@ -43,7 +42,7 @@ namespace boost { namespace detail {
     {
         std::basic_string<ToChar> result;
         
-        std::mbstate_t state = std::mbstate_t();
+        std::mbstate_t state = {0};
 
         const FromChar* from = s.data();
         const FromChar* from_end = s.data() + s.size();
@@ -63,16 +62,14 @@ namespace boost { namespace detail {
                 fun(state, from, from_end, from, buffer, to_end, to_next);
             
             if (r == std::codecvt_base::error)
-                boost::throw_exception(
-                    std::logic_error("character conversion failed"));
+                throw std::logic_error("character conversion failed");
             // 'partial' is not an error, it just means not all source
             // characters were converted. However, we need to check that at
             // least one new target character was produced. If not, it means
             // the source data is incomplete, and since we don't have extra
             // data to add to source, it's error.
             if (to_next == buffer)
-                boost::throw_exception(
-                    std::logic_error("character conversion failed"));
+                throw std::logic_error("character conversion failed");
             
             // Add converted characters
             result.append(buffer, to_next);
@@ -109,7 +106,7 @@ namespace boost {
 
 
     namespace {
-        boost::program_options::detail::utf8_codecvt_facet
+        boost::program_options::detail::utf8_codecvt_facet<wchar_t, char> 
             utf8_facet;
     }
     

src/options_description.cpp

@@ -1,5 +1,4 @@
 // 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)
@@ -8,42 +7,23 @@
 #define BOOST_PROGRAM_OPTIONS_SOURCE
 #include <boost/program_options/config.hpp>
 #include <boost/program_options/options_description.hpp>
-// FIXME: this is only to get multiple_occurences class
+// FIXME: this is only to get multiple_occureces class
 // should move that to a separate headers.
 #include <boost/program_options/parsers.hpp>
 
-
 #include <boost/lexical_cast.hpp>
-#include <boost/tokenizer.hpp>
+
 #include <boost/detail/workaround.hpp>
-#include <boost/throw_exception.hpp>
 
 #include <cassert>
 #include <climits>
 #include <cstring>
 #include <cstdarg>
 #include <sstream>
-#include <iterator>
 using namespace std;
 
 namespace boost { namespace program_options {
 
-   namespace {
-
-       template< class charT >
-       std::basic_string< charT >  tolower_(const std::basic_string< charT >& str)
-       {
-           std::basic_string< charT > result;
-           for (typename std::basic_string< charT >::size_type i = 0; i < str.size(); ++i)
-           {
-               result.append(1, static_cast< charT >(std::tolower(str[i])));
-           }   
-           return result;
-       }
-
-    }  // unnamed namespace
-
-
     option_description::option_description()
     {
     }
@@ -53,7 +33,7 @@ namespace boost { namespace program_options {
                        const value_semantic* s)
     : m_value_semantic(s)
     {
-        this->set_name(name);
+        this->name(name);
     }
                                            
 
@@ -63,101 +43,40 @@ namespace boost { namespace program_options {
                        const char* description)
     : m_description(description), m_value_semantic(s)
     {
-        this->set_name(name);
+        this->name(name);
     }
 
     option_description::~option_description()
     {
     }
 
-    option_description::match_result
-    option_description::match(const std::string& option, 
-                              bool approx, 
-                              bool long_ignore_case,
-                              bool short_ignore_case) const
-    {
-        match_result result = no_match;        
-        
-        std::string local_long_name((long_ignore_case ? tolower_(m_long_name) : m_long_name));
-        
-        if (!local_long_name.empty()) {
-        
-            std::string local_option = (long_ignore_case ? tolower_(option) : option);
-
-            if (*local_long_name.rbegin() == '*')
-            {
-                // The name ends with '*'. Any specified name with the given
-                // prefix is OK.
-                if (local_option.find(local_long_name.substr(0, local_long_name.length()-1))
-                    == 0)
-                    result = approximate_match;
-            }
-
-            if (local_long_name == local_option)
-            {
-                result = full_match;
-            }
-            else if (approx)
-            {
-                if (local_long_name.find(local_option) == 0)
-                {
-                    result = approximate_match;
-                }
-            }
-        }
-         
-        if (result != full_match)
-        {
-            std::string local_option(short_ignore_case ? tolower_(option) : option);
-            std::string local_short_name(short_ignore_case ? tolower_(m_short_name) : m_short_name);
-
-            if (local_short_name == local_option)
-            {
-                result = full_match;
-            }
-        }
-
-        return result;        
-    }
-
-    const std::string& 
-    option_description::key(const std::string& option) const
-    {        
-        if (!m_long_name.empty()) 
-            if (m_long_name.find('*') != string::npos)
-                // The '*' character means we're long_name
-                // matches only part of the input. So, returning
-                // long name will remove some of the information,
-                // and we have to return the option as specified
-                // in the source.
-                return option;
-            else
-                return m_long_name;
-        else
-            return m_short_name;
-    }
-
-    const std::string&
-    option_description::long_name() const
-    {
-        return m_long_name;
-    }
-
     option_description&
-    option_description::set_name(const char* _name)
+    option_description::name(const char* _name)
     {
         std::string name(_name);
         string::size_type n = name.find(',');
         if (n != string::npos) {
             assert(n == name.size()-2);
             m_long_name = name.substr(0, n);
-            m_short_name = '-' + name.substr(n+1,1);
+            m_short_name = name.substr(n+1,1);
         } else {
             m_long_name = name;
         }
         return *this;
     }
 
+    const std::string&
+    option_description::short_name() const
+    {
+        return m_short_name;
+    }
+
+    const std::string&
+    option_description::long_name() const
+    {
+        return m_long_name;
+    }
+
     const std::string&
     option_description::description() const
     {
@@ -173,17 +92,17 @@ namespace boost { namespace program_options {
     std::string 
     option_description::format_name() const
     {
-        if (!m_short_name.empty())
-            return string(m_short_name).append(" [ --").
-            append(m_long_name).append(" ]");
+        if (!short_name().empty())
+            return string("-").append(short_name()).append(" [ --").
+            append(long_name()).append(" ]");
         else
-            return string("--").append(m_long_name);
+            return string("--").append(long_name());
     }
 
     std::string 
     option_description::format_parameter() const
     {
-        if (m_value_semantic->max_tokens() != 0)
+        if (!m_value_semantic->is_zero_tokens())
             return m_value_semantic->name();
         else
             return "";
@@ -231,32 +150,30 @@ namespace boost { namespace program_options {
         return *this;
     }
 
-    const unsigned options_description::m_default_line_length = 80;
+    options_description::options_description()
+    {}
 
-    options_description::options_description(unsigned line_length,
-                                             unsigned min_description_length)
-    : m_line_length(line_length)
-    , m_min_description_length(min_description_length)
-    {
-        // we require a space between the option and description parts, so add 1.
-        assert(m_min_description_length < m_line_length - 1);    
-    }
-
-    options_description::options_description(const std::string& caption,
-                                             unsigned line_length,
-                                             unsigned min_description_length)
+    options_description::options_description(const string& caption)
     : m_caption(caption)
-    , m_line_length(line_length)
-    , m_min_description_length(min_description_length)
-    {
-        // we require a space between the option and description parts, so add 1.
-        assert(m_min_description_length < m_line_length - 1);
-    }
-    
+    {}
+
     void
     options_description::add(shared_ptr<option_description> desc)
     {
-        m_options.push_back(desc);
+        const string& s = desc->short_name();
+        const string& l = desc->long_name();
+        assert(!s.empty() || !l.empty());
+        if (!s.empty())
+            if (name2index.count("-" + s) != 0)
+                throw duplicate_option_error("Short name '" + s + "' is already present");
+            else
+                name2index["-" + s] = options.size();
+        if (!l.empty())
+            if (name2index.count(s) != 0)
+                throw duplicate_option_error("Long name '" + s + "' is already present");
+            else
+                name2index[l] = options.size();
+        options.push_back(desc);
         belong_to_group.push_back(false);
     }
 
@@ -266,8 +183,8 @@ namespace boost { namespace program_options {
         shared_ptr<options_description> d(new options_description(desc));
         groups.push_back(d);
 
-        for (size_t i = 0; i < desc.m_options.size(); ++i) {
-            add(desc.m_options[i]);
+        for (size_t i = 0; i < desc.options.size(); ++i) {
+            add(desc.options[i]);
             belong_to_group.back() = true;
         }
 
@@ -280,78 +197,76 @@ namespace boost { namespace program_options {
         return options_description_easy_init(this);
     }
 
+    unsigned
+    options_description::count(const std::string& name) const
+    {
+        return name2index.count(name);
+    }
+
+    unsigned
+    options_description::count_approx(const std::string& prefix) const
+    {
+        approximation_range er = find_approximation(prefix);
+        return distance(er.first, er.second);
+    }
+
     const option_description&
-    options_description::find(const std::string& name, 
-                              bool approx,
-                              bool long_ignore_case,
-                              bool short_ignore_case) const
+    options_description::find(const std::string& name) const
     {
-        const option_description* d = find_nothrow(name, approx, 
-                                       long_ignore_case, short_ignore_case);
-        if (!d)
-            boost::throw_exception(unknown_option(name));
-        return *d;
+        assert(this->count(name) != 0);
+        return *options[name2index.find(name)->second];
     }
 
-    const std::vector< shared_ptr<option_description> >& 
-    options_description::options() const
+    const option_description&
+    options_description::find_approx(const std::string& prefix) const
     {
-        return m_options;
+        approximation_range er = find_approximation(prefix);
+        assert(distance(er.first, er.second) == 1);
+        return *options[er.first->second];
     }
 
-    const option_description*
-    options_description::find_nothrow(const std::string& name, 
-                                      bool approx,
-                                      bool long_ignore_case,
-                                      bool short_ignore_case) const
+    std::set<std::string>
+    options_description::keys() const
     {
-        shared_ptr<option_description> found;
-        bool had_full_match = false;
-        vector<string> approximate_matches;
-        vector<string> full_matches;
-        
-        // We use linear search because matching specified option
-        // name with the declared option name need to take care about
-        // case sensitivity and trailing '*' and so we can't use simple map.
-        for(unsigned i = 0; i < m_options.size(); ++i)
-        {
-            option_description::match_result r = 
-                m_options[i]->match(name, approx, long_ignore_case, short_ignore_case);
-
-            if (r == option_description::no_match)
-                continue;
-
-            if (r == option_description::full_match)
-            {                
-                full_matches.push_back(m_options[i]->key(name));
-                found = m_options[i];
-                had_full_match = true;
-            } 
-            else 
-            {                        
-                // FIXME: the use of 'key' here might not
-                // be the best approach.
-                approximate_matches.push_back(m_options[i]->key(name));
-                if (!had_full_match)
-                    found = m_options[i];
-            }
-        }
-        if (full_matches.size() > 1) 
-            boost::throw_exception(
-                ambiguous_option(name, full_matches));
-        
-        // If we have a full match, and an approximate match,
-        // ignore approximate match instead of reporting error.
-        // Say, if we have options "all" and "all-chroots", then
-        // "--all" on the command line should select the first one,
-        // without ambiguity.
-        if (full_matches.empty() && approximate_matches.size() > 1)
-            boost::throw_exception(
-                ambiguous_option(name, approximate_matches));
-
-        return found.get();
+        set<string> result;
+        for (map<string, int>::const_iterator i = name2index.begin();
+             i != name2index.end();
+             ++i)
+            result.insert(i->first);
+        return result;
     }
 
+    std::set<std::string>
+    options_description::primary_keys() const
+    {
+        set<string> result;
+        for (size_t i = 0; i < options.size(); ++i)
+            if (options[i]->long_name().empty())
+                result.insert("-" + options[i]->short_name());
+            else
+                result.insert(options[i]->long_name());
+        return result;
+    }
+
+    std::set<std::string>
+    options_description::approximations(const std::string& prefix) const
+    {
+        approximation_range er = find_approximation(prefix);
+        set<string> result;
+        for (name2index_iterator i = er.first; i != er.second; ++i)
+            result.insert(i->first);
+        return result;
+    }
+
+    options_description::approximation_range
+    options_description::find_approximation(const std::string& prefix) const
+    {
+        name2index_iterator b = name2index.lower_bound(prefix);
+        name2index_iterator e = name2index.upper_bound(prefix + char(CHAR_MAX));
+        return make_pair(b, e);
+    }
+
+
     BOOST_PROGRAM_OPTIONS_DECL
     std::ostream& operator<<(std::ostream& os, const options_description& desc)
     {
@@ -360,220 +275,21 @@ namespace boost { namespace program_options {
     }
 
     namespace {
-
-        /* Given a string 'par', that contains no newline characters
-           outputs it to 'os' with wordwrapping, that is, as several
-           line.
-
-           Each output line starts with 'indent' space characters, 
-           following by characters from 'par'. The total length of
-           line is no longer than 'line_length'.
-                                      
-        */
-        void format_paragraph(std::ostream& os,
-                              std::string par,
-                              unsigned indent,
-                              unsigned line_length)
-        {                    
-            // Through reminder of this function, 'line_length' will
-            // be the length available for characters, not including
-            // indent.
-            assert(indent < line_length);
-            line_length -= indent;
-
-            // index of tab (if present) is used as additional indent relative
-            // to first_column_width if paragrapth is spanned over multiple
-            // lines if tab is not on first line it is ignored
-            string::size_type par_indent = par.find('\t');
-
-            if (par_indent == string::npos)
-            {
-                par_indent = 0;
-            }
-            else
-            {
-                // only one tab per paragraph allowed
-                if (count(par.begin(), par.end(), '\t') > 1)
-                {
-                    boost::throw_exception(program_options::error(
-                        "Only one tab per paragraph is allowed"));
-                }
-          
-                // erase tab from string
-                par.erase(par_indent, 1);
-
-                // this assert may fail due to user error or 
-                // environment conditions!
-                assert(par_indent < line_length);
-
-                // ignore tab if not on first line
-                if (par_indent >= line_length)
-                {
-                    par_indent = 0;
-                }            
-            }
-          
-            if (par.size() < line_length)
-            {
-                os << par;
-            }
-            else
-            {
-                string::const_iterator       line_begin = par.begin();
-                const string::const_iterator par_end = par.end();
-
-                bool first_line = true; // of current paragraph!        
-            
-                while (line_begin < par_end)  // paragraph lines
-                {
-                    if (!first_line)
-                    {
-                        // If line starts with space, but second character
-                        // is not space, remove the leading space.
-                        // We don't remove double spaces because those
-                        // might be intentianal.
-                        if ((*line_begin == ' ') &&
-                            ((line_begin + 1 < par_end) &&
-                             (*(line_begin + 1) != ' ')))
-                        {
-                            line_begin += 1;  // line_begin != line_end
-                        }
-                    }
-
-                    // Take care to never increment the iterator past
-                    // the end, since MSVC 8.0 (brokenly), assumes that
-                    // doing that, even if no access happens, is a bug.
-                    unsigned remaining = distance(line_begin, par_end);
-                    string::const_iterator line_end = line_begin + 
-                        ((remaining < line_length) ? remaining : line_length);
-            
-                    // prevent chopped words
-                    // Is line_end between two non-space characters?
-                    if ((*(line_end - 1) != ' ') &&
-                        ((line_end < par_end) && (*line_end != ' ')))
-                    {
-                        // find last ' ' in the second half of the current paragraph line
-                        string::const_iterator last_space =
-                            find(reverse_iterator<string::const_iterator>(line_end),
-                                 reverse_iterator<string::const_iterator>(line_begin),
-                                 ' ')
-                            .base();
-                
-                        if (last_space != line_begin)
-                        {                 
-                            // is last_space within the second half ot the 
-                            // current line
-                            if (static_cast<unsigned>(distance(last_space, line_end)) < 
-                                (line_length / 2))
-                            {
-                                line_end = last_space;
-                            }
-                        }                                                
-                    } // prevent chopped words
-             
-                    // write line to stream
-                    copy(line_begin, line_end, ostream_iterator<char>(os));
-              
-                    if (first_line)
-                    {
-                        indent += par_indent;
-                        line_length -= par_indent; // there's less to work with now
-                        first_line = false;
-                    }
-
-                    // more lines to follow?
-                    if (line_end != par_end)
-                    {
-                        os << '\n';
-                
-                        for(unsigned pad = indent; pad > 0; --pad)
-                        {
-                            os.put(' ');
-                        }                                                        
-                    }
-              
-                    // next line starts after of this line
-                    line_begin = line_end;              
-                } // paragraph lines
-            }          
-        }                              
-        
-        void format_description(std::ostream& os,
-                                const std::string& desc, 
-                                unsigned first_column_width,
-                                unsigned line_length)
-        {
-            // we need to use one char less per line to work correctly if actual
-            // console has longer lines
-            assert(line_length > 1);
-            if (line_length > 1)
-            {
-                --line_length;
-            }
-
-            // line_length must be larger than first_column_width
-            // this assert may fail due to user error or environment conditions!
-            assert(line_length > first_column_width);
-
-            // Note: can't use 'tokenizer' as name of typedef -- borland
-            // will consider uses of 'tokenizer' below as uses of
-            // boost::tokenizer, not typedef.
-            typedef boost::tokenizer<boost::char_separator<char> > tok;
-          
-            tok paragraphs(
-                desc,
-                char_separator<char>("\n", "", boost::keep_empty_tokens));
-          
-            tok::const_iterator       par_iter = paragraphs.begin();                
-            const tok::const_iterator par_end = paragraphs.end();
-
-            while (par_iter != par_end)  // paragraphs
-            {
-                format_paragraph(os, *par_iter, first_column_width, 
-                                 line_length);
-            
-                ++par_iter;
-            
-                // prepair next line if any
-                if (par_iter != par_end)
-                {
-                    os << '\n';
-              
-                    for(unsigned pad = first_column_width; pad > 0; --pad)
-                    {
-                        os.put(' ');
-                    }                    
-                }            
-            }  // paragraphs
-        }
-    
         void format_one(std::ostream& os, const option_description& opt, 
-                        unsigned first_column_width, unsigned line_length)
+                        unsigned first_column_width)
         {
             stringstream ss;
             ss << "  " << opt.format_name() << ' ' << opt.format_parameter();
             
             // Don't use ss.rdbuf() since g++ 2.96 is buggy on it.
             os << ss.str();
-
-            if (!opt.description().empty())
-            {
-                if (ss.str().size() >= first_column_width)
-                {
-                   os.put('\n'); // first column is too long, lets put description in new line
-                   for (unsigned pad = first_column_width; pad > 0; --pad)
-                   {
-                      os.put(' ');
-                   }
-                } else {
-                   for(unsigned pad = first_column_width - ss.str().size(); pad > 0; --pad)
-                   {
-                      os.put(' ');
-                   }
-                }
             
-                format_description(os, opt.description(),
-                                   first_column_width, line_length);
+            if (!opt.description().empty()) {
+                
+                for(int pad = first_column_width - ss.str().size(); pad > 0; --pad) {
+                    os.put(' ');
+                }
+                os << " : " << opt.description();
             }
         }
     }
@@ -585,33 +301,25 @@ namespace boost { namespace program_options {
             os << m_caption << ":\n";
 
         /* Find the maximum width of the option column */
-        unsigned width(23);
+        unsigned width(24);
         unsigned i; // vc6 has broken for loop scoping
-        for (i = 0; i < m_options.size(); ++i)
+        for (i = 0; i < options.size(); ++i)
         {
-            const option_description& opt = *m_options[i];
+            const option_description& opt = *options[i];
             stringstream ss;
             ss << "  " << opt.format_name() << ' ' << opt.format_parameter();
-            width = (max)(width, static_cast<unsigned>(ss.str().size()));            
+            width = max(width, static_cast<unsigned>(ss.str().size()));            
         }
-        /* this is the column were description should start, if first
-           column is longer, we go to a new line */
-        const unsigned start_of_description_column = m_line_length - m_min_description_length;
 
-        width = (min)(width, start_of_description_column-1);
-        
-        /* add an additional space to improve readability */
-        ++width;
-            
         /* The options formatting style is stolen from Subversion. */
-        for (i = 0; i < m_options.size(); ++i)
+        for (i = 0; i < options.size(); ++i)
         {
             if (belong_to_group[i])
                 continue;
 
-            const option_description& opt = *m_options[i];
+            const option_description& opt = *options[i];
 
-            format_one(os, opt, width, m_line_length);
+            format_one(os, opt, width);
 
             os << "\n";
         }

src/parsers.cpp

@@ -17,10 +17,7 @@
 #include <boost/program_options/detail/convert.hpp>
 
 #include <boost/bind.hpp>
-#include <boost/throw_exception.hpp>
 
-#include <cctype>
-#include <fstream>
 
 #if !defined(__GNUC__) || __GNUC__ < 3
 #include <iostream>
@@ -68,16 +65,10 @@ namespace boost { namespace program_options {
             woption result;
             result.string_key = opt.string_key;
             result.position_key = opt.position_key;
-            result.unregistered = opt.unregistered;
             
             std::transform(opt.value.begin(), opt.value.end(),
                            back_inserter(result.value),
-                           boost::bind(from_utf8, _1));
-
-            std::transform(opt.original_tokens.begin(), 
-                           opt.original_tokens.end(),
-                           back_inserter(result.original_tokens),
-                           boost::bind(from_utf8, _1));
+                           bind(from_utf8, _1));
             return result;
         }
     }
@@ -92,30 +83,118 @@ namespace boost { namespace program_options {
     }
 #endif
 
+    namespace detail
+    {
+        void
+        parse_command_line(cmdline& cmd, parsed_options& result);
+    }
+
+    common_command_line_parser::
+    common_command_line_parser(const std::vector<std::string>& args)
+    : m_style(0), m_desc(0), m_positional(0), m_args(args)
+    {}
+
+    parsed_options
+    common_command_line_parser::run() const
+    {
+        parsed_options result(m_desc);
+        detail::cmdline cmd(m_args, m_style);
+        cmd.set_additional_parser(m_ext);
+
+        if (m_desc) {
+            set<string> keys = m_desc->primary_keys();
+            for (set<string>::iterator i = keys.begin(); i != keys.end(); ++i) {
+                const option_description& d = m_desc->find(*i);
+                char s = d.short_name().empty() ? '\0' : d.short_name()[0];
+
+                shared_ptr<const value_semantic> vs = d.semantic();
+                char flags;
+                if (vs->is_zero_tokens())
+                    flags = '|';
+                else
+                    if (vs->is_implicit()) 
+                        if (vs->is_multitoken())
+                            flags = '*';
+                        else
+                            flags = '?';
+                    else if (vs->is_multitoken())
+                        flags = '+';
+                    else flags = ':';
+
+                cmd.add_option(d.long_name(), s, flags, 1);
+            }
+        }
+
+        detail::parse_command_line(cmd, result);
+
+        if (m_positional)
+        {
+            unsigned position = 0;
+            for (unsigned i = 0; i < result.options.size(); ++i) {
+                option& opt = result.options[i];
+                if (opt.position_key != -1) {
+                    if (position >= m_positional->max_total_count())
+                    {
+                        throw too_many_positional_options_error(
+                            "too many positional options");
+                    }
+                    opt.string_key = m_positional->name_for_position(position);
+                    ++position;
+                }
+            }
+        }
+
+        return result;        
+    }
+
+
+    namespace detail {
+        void
+        parse_command_line(cmdline& cmd, parsed_options& result)
+        {
+            int position(0);
+            
+            while(++cmd) {
+                
+                option n;
+                
+                if (cmd.at_option()) {
+                    if (*cmd.option_name().rbegin() != '*') {
+                        n.string_key = cmd.option_name();
+                    }
+                    else {
+                        n.string_key = cmd.raw_option_name();
+                    }
+                    n.value = cmd.option_values();
+                } else {
+                    n.position_key = position++;
+                    n.value.clear();
+                    n.value.push_back(cmd.argument());
+                }
+                result.options.push_back(n);
+            }
+        }
+    }
+
     template<class charT>
     basic_parsed_options<charT>
     parse_config_file(std::basic_istream<charT>& is, 
-                      const options_description& desc,
-                      bool allow_unregistered)
+                      const options_description& desc)
     {    
         set<string> allowed_options;
-
-        const vector<shared_ptr<option_description> >& options = desc.options();
-        for (unsigned i = 0; i < options.size(); ++i)
-        {
-            const option_description& d = *options[i];
+        set<string> pm = desc.primary_keys();
+        for (set<string>::iterator i = pm.begin(); i != pm.end(); ++i) {
+            const option_description& d = desc.find(*i);
 
             if (d.long_name().empty())
-                boost::throw_exception(
-                    error("long name required for config file"));
+                throw error("long name required for config file");
 
             allowed_options.insert(d.long_name());
         }
 
         // Parser return char strings
         parsed_options result(&desc);        
-        copy(detail::basic_config_file_iterator<charT>(
-                 is, allowed_options, allow_unregistered), 
+        copy(detail::basic_config_file_iterator<charT>(is, allowed_options), 
              detail::basic_config_file_iterator<charT>(), 
              back_inserter(result.options));
         // Convert char strings into desired type.
@@ -125,46 +204,14 @@ namespace boost { namespace program_options {
     template
     BOOST_PROGRAM_OPTIONS_DECL basic_parsed_options<char>
     parse_config_file(std::basic_istream<char>& is, 
-                      const options_description& desc,
-                      bool allow_unregistered);
+                      const options_description& desc);
 
 #ifndef BOOST_NO_STD_WSTRING
     template
     BOOST_PROGRAM_OPTIONS_DECL basic_parsed_options<wchar_t>
     parse_config_file(std::basic_istream<wchar_t>& is, 
-                      const options_description& desc,
-                      bool allow_unregistered);
+                      const options_description& desc);
 #endif
-
-    template<class charT>
-    basic_parsed_options<charT>
-    parse_config_file(const char* filename, 
-                      const options_description& desc,
-                      bool allow_unregistered)
-    { 
-        // Parser return char strings
-        std::basic_ifstream< charT > strm(filename);
-        if (!strm) 
-        {
-            boost::throw_exception(reading_file(filename));
-        }
-        return parse_config_file(strm, desc, allow_unregistered);
-    }
-
-    template
-    BOOST_PROGRAM_OPTIONS_DECL basic_parsed_options<char>
-    parse_config_file(const char* filename, 
-                      const options_description& desc,
-                      bool allow_unregistered);
-
-#ifndef BOOST_NO_STD_WSTRING
-    template
-    BOOST_PROGRAM_OPTIONS_DECL basic_parsed_options<wchar_t>
-    parse_config_file(const char* filename, 
-                      const options_description& desc,
-                      bool allow_unregistered);
-#endif
-
     
 // This versio, which accepts any options without validation, is disabled,
 // in the hope that nobody will need it and we cant drop it altogether.
@@ -201,7 +248,7 @@ namespace boost { namespace program_options {
         return result;
     }
 
-    namespace detail {
+    namespace {
         class prefix_name_mapper {
         public:
             prefix_name_mapper(const std::string& prefix)
@@ -230,7 +277,7 @@ namespace boost { namespace program_options {
     parse_environment(const options_description& desc, 
                       const std::string& prefix)
     {
-        return parse_environment(desc, detail::prefix_name_mapper(prefix));
+        return parse_environment(desc, prefix_name_mapper(prefix));
     }
 
     BOOST_PROGRAM_OPTIONS_DECL parsed_options

src/positional_options.cpp

@@ -17,7 +17,7 @@ namespace boost { namespace program_options {
     positional_options_description::positional_options_description()
     {}
 
-    positional_options_description&
+    void
     positional_options_description::add(const char* name, int max_count)
     {
         assert(max_count != -1 || m_trailing.empty());
@@ -27,14 +27,14 @@ namespace boost { namespace program_options {
         else {
             m_names.resize(m_names.size() + max_count, name);
         }
-        return *this;
+        
     }
 
     unsigned
     positional_options_description::max_total_count() const
     {
         return m_trailing.empty() ? 
-          m_names.size() : (std::numeric_limits<unsigned>::max)();
+        m_names.size() : std::numeric_limits<unsigned>::max();
     }
     
     const std::string& 

src/split.cpp

@@ -1,62 +0,0 @@
-// Copyright Sascha Ochsenknecht 2009.
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt
-// or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#define BOOST_PROGRAM_OPTIONS_SOURCE
-
-#include <boost/program_options/parsers.hpp>
-#include <boost/tokenizer.hpp>
-
-#include <string>
-#include <vector>
-
-namespace boost { namespace program_options { namespace detail {
-
-   template< class charT >
-   std::vector<std::basic_string<charT> > 
-   split_unix(
-         const std::basic_string<charT>& cmdline, 
-         const std::basic_string<charT>& seperator, 
-         const std::basic_string<charT>& quote, 
-         const std::basic_string<charT>& escape)
-   {   
-      typedef boost::tokenizer< boost::escaped_list_separator<charT>, 
-            typename std::basic_string<charT>::const_iterator, 
-            std::basic_string<charT> >  tokenizerT;
-         
-      tokenizerT tok(cmdline.begin(), cmdline.end(), 
-                boost::escaped_list_separator< charT >(escape, seperator, quote));
-         
-      std::vector< std::basic_string<charT> > result;
-      for (typename tokenizerT::iterator cur_token(tok.begin()), end_token(tok.end()); cur_token != end_token; ++cur_token) {
-         if (!cur_token->empty())
-            result.push_back(*cur_token);
-      }
-      return result;
-   }
-   
-}}}   // namespace
-
-namespace boost { namespace program_options {
-
-   // Take a command line string and splits in into tokens, according
-   // to the given collection of seperators chars.
-   BOOST_PROGRAM_OPTIONS_DECL std::vector<std::string> 
-   split_unix(const std::string& cmdline, const std::string& seperator, 
-         const std::string& quote, const std::string& escape)
-   {
-      return detail::split_unix< char >(cmdline, seperator, quote, escape);
-   }
-
-#ifndef BOOST_NO_STD_WSTRING
-   BOOST_PROGRAM_OPTIONS_DECL std::vector<std::wstring>
-   split_unix(const std::wstring& cmdline, const std::wstring& seperator, 
-         const std::wstring& quote, const std::wstring& escape)
-   {
-      return detail::split_unix< wchar_t >(cmdline, seperator, quote, escape);
-   }
-#endif
-
-}}  // namespace
-

src/utf8_codecvt_facet.cpp

@@ -1,21 +1,364 @@
-// 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)
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// utf8_codecvt_facet.cpp
 
+// Copyright © 2001 Ronald Garcia, Indiana University (garcia@osl.iu.edu)
+// Andrew Lumsdaine, Indiana University (lums@osl.iu.edu). 
+// 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)
+
+#include <cstdlib> // for multi-byte converson routines
+
+#include <cassert>
 #define BOOST_PROGRAM_OPTIONS_SOURCE
-#include <boost/program_options/config.hpp>
+#include <boost/program_options/detail/utf8_codecvt_facet.hpp>
 
-#define BOOST_UTF8_BEGIN_NAMESPACE \
-     namespace boost { namespace program_options { namespace detail {
+#include <boost/limits.hpp>
+#include <boost/config.hpp>
 
-#define BOOST_UTF8_END_NAMESPACE }}}
-#define BOOST_UTF8_DECL BOOST_PROGRAM_OPTIONS_DECL
+// If we don't have wstring, then Unicode support 
+// is not available anyway, so we don't need to even
+// compiler this file. This also fixes the problem
+// with mingw, which can compile this file, but will
+// generate link error when building DLL.
+#ifndef BOOST_NO_STD_WSTRING
 
-#include "../../detail/utf8_codecvt_facet.cpp"
+namespace boost { namespace program_options { namespace detail {
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation for wchar_t
 
+// Translate incoming UTF-8 into UCS-4
+std::codecvt_base::result utf8_codecvt_facet_wchar_t::do_in(
+    mbstate_t& state, 
+    const char * from,
+    const char * from_end, 
+    const char * & from_next,
+    wchar_t * to, 
+    wchar_t * to_end, 
+    wchar_t * & to_next
+) const {
+    // Basic algorithm:  The first octet determines how many
+    // octets total make up the UCS-4 character.  The remaining
+    // "continuing octets" all begin with "10". To convert, subtract
+    // the amount that specifies the number of octets from the first
+    // octet.  Subtract 0x80 (1000 0000) from each continuing octet,
+    // then mash the whole lot together.  Note that each continuing
+    // octet only uses 6 bits as unique values, so only shift by
+    // multiples of 6 to combine.
+    while (from != from_end && to != to_end) {
 
-#undef BOOST_UTF8_BEGIN_NAMESPACE
-#undef BOOST_UTF8_END_NAMESPACE
-#undef BOOST_UTF8_DECL
+        // Error checking   on the first octet
+        if (invalid_leading_octet(*from)){
+            from_next = from;
+            to_next = to;
+            return std::codecvt_base::error;
+        }
 
+        // The first octet is   adjusted by a value dependent upon 
+        // the number   of "continuing octets" encoding the character
+        const   int cont_octet_count = get_cont_octet_count(*from);
+        const   wchar_t octet1_modifier_table[] =   {
+            0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc
+        };
+
+        // The unsigned char conversion is necessary in case char is
+        // signed   (I learned this the hard way)
+        wchar_t ucs_result = 
+            (unsigned char)(*from++) - octet1_modifier_table[cont_octet_count];
+
+        // Invariants   : 
+        //   1) At the start of the loop,   'i' continuing characters have been
+        //    processed 
+        //   2) *from   points to the next continuing character to be processed.
+        int i   = 0;
+        while(i != cont_octet_count && from != from_end) {
+
+            // Error checking on continuing characters
+            if (invalid_continuing_octet(*from)) {
+                from_next   = from;
+                to_next =   to;
+                return std::codecvt_base::error;
+            }
+
+            ucs_result *= (1 << 6); 
+
+            // each continuing character has an extra (10xxxxxx)b attached to 
+            // it that must be removed.
+            ucs_result += (unsigned char)(*from++) - 0x80;
+            ++i;
+        }
+
+        // If   the buffer ends with an incomplete unicode character...
+        if (from == from_end && i   != cont_octet_count) {
+            // rewind "from" to before the current character translation
+            from_next = from - (i+1); 
+            to_next = to;
+            return std::codecvt_base::partial;
+        }
+        *to++   = ucs_result;
+    }
+    from_next = from;
+    to_next = to;
+
+    // Were we done converting or did we run out of destination space?
+    if(from == from_end) return std::codecvt_base::ok;
+    else return std::codecvt_base::partial;
+}
+
+std::codecvt_base::result utf8_codecvt_facet_wchar_t::do_out(
+    mbstate_t& state, 
+    const wchar_t *   from,
+    const wchar_t * from_end, 
+    const wchar_t * & from_next,
+    char * to, 
+    char * to_end, 
+    char * & to_next
+) const
+{
+    // RG - consider merging this table with the other one
+    const wchar_t octet1_modifier_table[] = {
+        0x00, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc
+    };
+
+    wchar_t max_wchar = std::numeric_limits<wchar_t>::max();
+    while (from != from_end && to != to_end) {
+
+        // Check for invalid UCS-4 character
+        if (*from  > max_wchar) {
+            from_next = from;
+            to_next = to;
+            return std::codecvt_base::error;
+        }
+
+        int cont_octet_count = get_cont_octet_out_count(*from);
+
+        // RG  - comment this formula better
+        int shift_exponent = (cont_octet_count) *   6;
+
+        // Process the first character
+        *to++ = octet1_modifier_table[cont_octet_count] +
+            (unsigned char)(*from / (1 << shift_exponent));
+
+        // Process the continuation characters 
+        // Invariants: At   the start of the loop:
+        //   1) 'i' continuing octets   have been generated
+        //   2) '*to'   points to the next location to place an octet
+        //   3) shift_exponent is   6 more than needed for the next octet
+        int i   = 0;
+        while   (i != cont_octet_count && to != to_end) {
+            shift_exponent -= 6;
+            *to++ = 0x80 + ((*from / (1 << shift_exponent)) % (1 << 6));
+            ++i;
+        }
+        // If   we filled up the out buffer before encoding the character
+        if(to   == to_end && i != cont_octet_count) {
+            from_next = from;
+            to_next = to - (i+1);
+            return std::codecvt_base::partial;
+        }
+        *from++;
+    }
+    from_next = from;
+    to_next = to;
+    // Were we done or did we run out of destination space
+    if(from == from_end) return std::codecvt_base::ok;
+    else return std::codecvt_base::partial;
+}
+
+// How many char objects can I process to get <= max_limit
+// wchar_t objects?
+int utf8_codecvt_facet_wchar_t::do_length(
+    mbstate_t &,
+    const char * from,
+    const char * from_end, 
+    std::size_t max_limit
+#if BOOST_WORKAROUND(__IBMCPP__, BOOST_TESTED_AT(600))
+) const throw()
+#else
+) const
+#endif
+{ 
+    // RG - this code is confusing!  I need a better way to express it.
+    // and test cases.
+
+    // Invariants:
+    // 1) last_octet_count has the size of the last measured character
+    // 2) char_count holds the number of characters shown to fit
+    // within the bounds so far (no greater than max_limit)
+    // 3) from_next points to the octet 'last_octet_count' before the
+    // last measured character.  
+    int last_octet_count=0;
+    std::size_t char_count = 0;
+    const char* from_next = from;
+    // Use "<" because the buffer may represent incomplete characters
+    while (from_next+last_octet_count <= from_end && char_count <= max_limit) {
+        from_next += last_octet_count;
+        last_octet_count = (get_octet_count(*from_next));
+        ++char_count;
+    }
+    return from_next-from_end;
+}
+
+unsigned int utf8_codecvt_facet_wchar_t::get_octet_count(
+    unsigned char   lead_octet
+){
+    // if the 0-bit (MSB) is 0, then 1 character
+    if (lead_octet <= 0x7f) return 1;
+
+    // Otherwise the count number of consecutive 1 bits starting at MSB
+//    assert(0xc0 <= lead_octet && lead_octet <= 0xfd);
+
+    if (0xc0 <= lead_octet && lead_octet <= 0xdf) return 2;
+    else if (0xe0 <= lead_octet && lead_octet <= 0xef) return 3;
+    else if (0xf0 <= lead_octet && lead_octet <= 0xf7) return 4;
+    else if (0xf8 <= lead_octet && lead_octet <= 0xfb) return 5;
+    else return 6;
+}
+}}}
+
+namespace {
+template<std::size_t s>
+int get_cont_octet_out_count_impl(wchar_t word){
+    if (word < 0x80) {
+        return 0;
+    }
+    if (word < 0x800) {
+        return 1;
+    }
+    return 2;
+}
+
+template<>
+int get_cont_octet_out_count_impl<4>(wchar_t word){
+    if (word < 0x80) {
+        return 0;
+    }
+    if (word < 0x800) {
+        return 1;
+    }
+    if (word < 0x10000) {
+        return 2;
+    }
+    if (word < 0x200000) {
+        return 3;
+    }
+    if (word < 0x4000000) {
+        return 4;
+    }
+    return 5;
+}
+
+} // namespace anonymous
+
+namespace boost { namespace program_options { namespace detail {
+// How many "continuing octets" will be needed for this word
+// ==   total octets - 1.
+int utf8_codecvt_facet_wchar_t::get_cont_octet_out_count(
+    wchar_t word
+) const {
+    return get_cont_octet_out_count_impl<sizeof(wchar_t)>(word);
+}
+}}}
+
+#if 0 // not used?
+/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
+// implementation for char
+
+std::codecvt_base::result utf8_codecvt_facet_char::do_in(
+    mbstate_t & state, 
+    const char * from, 
+    const char * from_end, 
+    const char * & from_next,
+    char * to, 
+    char * to_end, 
+    char * & to_next
+) const
+{
+    while(from_next < from_end){
+        wchar_t w;
+        wchar_t *wnext = & w;
+        utf8_codecvt_facet_wchar_t::result ucs4_result;
+        ucs4_result = base_class::do_in(
+            state,
+            from, from_end, from_next,
+            wnext, wnext + 1, wnext
+        );
+        if(codecvt_base::ok != ucs4_result)
+            return ucs4_result;
+        // if the conversion succeeds. 
+        int length = std::wctomb(to_next, w);
+//        assert(-1 != length);
+        to_next += length;
+    }
+    return codecvt_base::ok;
+}
+
+std::codecvt_base::result utf8_codecvt_facet_char::do_out(
+    std::mbstate_t & state, 
+    const char * from,
+    const char * from_end, 
+    const char * & from_next,
+    char * to, 
+    char * to_end, 
+    char * & to_next
+) const
+{
+    while(from_next < from_end){
+        wchar_t w;
+        int result = std::mbtowc(&w, from_next,  MB_LENGTH_MAX);
+ //       assert(-1 != result);
+        from_next += result;
+        utf8_codecvt_facet_wchar_t::result ucs4_result;
+
+        const wchar_t *wptr = & w;
+        ucs4_result = base_class::do_out(
+            state,
+            wptr, wptr+1, wptr,
+            to_next, to_end, to_next
+        );
+        if(codecvt_base::ok != ucs4_result)
+            return ucs4_result;     
+    }
+    return codecvt_base::ok;
+}
+
+// How many bytes objects can I process to get <= max_limit
+// char objects?
+int utf8_codecvt_facet_char::do_length(
+    const mbstate_t & initial_state,
+    const char * from_next,
+    const char * from_end, 
+    std::size_t max_limit
+) const
+{
+    int total_length = 0;
+    const char *from = from_next;
+    mbstate_t state = initial_state;
+    while(from_next < from_end){
+        wchar_t w;
+        wchar_t *wnext = & w;
+        utf8_codecvt_facet_wchar_t::result ucs4_result;
+        ucs4_result = base_class::do_in(
+            state,
+            from_next, from_end, from_next,
+            wnext, wnext + 1, wnext
+        );
+
+        if(codecvt_base::ok != ucs4_result)
+            break;
+
+        char carray[MB_LENGTH_MAX];
+        std::size_t count = wctomb(carray, w);
+        if(count > max_limit)
+            break;
+
+        max_limit -= count;
+        total_length = from_next - from;
+    }
+    return total_length;
+}
+}
+
+#endif
+
+#endif

src/value_semantic.cpp

@@ -8,8 +8,6 @@
 #include <boost/program_options/value_semantic.hpp>
 #include <boost/program_options/detail/convert.hpp>
 
-#include <cctype>
-
 namespace boost { namespace program_options {
 
     using namespace std;
@@ -30,8 +28,7 @@ namespace boost { namespace program_options {
             }
             xparse(value_store, local_tokens);
 #else
-            boost::throw_exception(
-                std::runtime_error("UTF-8 conversion not supported."));
+            throw std::runtime_error("UTF-8 conversion not supported.");
 #endif
         } else {
             // Already in local encoding, pass unmodified
@@ -71,35 +68,15 @@ namespace boost { namespace program_options {
     {
         return arg;
     }
-    
-    unsigned 
-    untyped_value::min_tokens() const
-    {
-        if (m_zero_tokens)
-            return 0;
-        else
-            return 1;
-    }
-
-    unsigned 
-    untyped_value::max_tokens() const
-    {
-        if (m_zero_tokens)
-            return 0;
-        else
-            return 1;
-    }
-
 
     void 
     untyped_value::xparse(boost::any& value_store,
                           const std::vector<std::string>& new_tokens) const
     {
         if (!value_store.empty()) 
-            boost::throw_exception(
-                multiple_occurrences());
+            throw multiple_occurrences("multiple_occurrences");
         if (new_tokens.size() > 1)
-            boost::throw_exception(multiple_values());
+            throw multiple_values("multiple_values");
         value_store = new_tokens.empty() ? std::string("") : new_tokens.front();
     }
 
@@ -122,8 +99,8 @@ namespace boost { namespace program_options {
     /* Validates bool value.
         Any of "1", "true", "yes", "on" will be converted to "1".<br>
         Any of "0", "false", "no", "off" will be converted to "0".<br>
-        Case is ignored. The 'xs' vector can either be empty, in which
-        case the value is 'true', or can contain explicit value.
+        Case is ignored. Regardless of name passed, parameter will always
+        be optional.
     */
     BOOST_PROGRAM_OPTIONS_DECL void validate(any& v, const vector<string>& xs,
                        bool*, int)
@@ -139,7 +116,7 @@ namespace boost { namespace program_options {
         else if (s == "off" || s == "no" || s == "0" || s == "false")
             v = any(false);
         else
-            boost::throw_exception(validation_error(validation_error::invalid_bool_value, s));
+            throw validation_error("'" + s + "' doesn't look like a bool value.");
     }
 
     // This is blatant copy-paste. However, templating this will cause a problem,
@@ -161,14 +138,19 @@ namespace boost { namespace program_options {
         else if (s == L"off" || s == L"no" || s == L"0" || s == L"false")
             v = any(false);
         else
-            boost::throw_exception(validation_error(validation_error::invalid_bool_value));
+            throw validation_error("invalid bool value");
     }
 #endif
     BOOST_PROGRAM_OPTIONS_DECL 
     void validate(any& v, const vector<string>& xs, std::string*, int)
     {
         check_first_occurrence(v);
-        v = any(get_single_string(xs));
+        string s(get_single_string(xs));
+        if (*s.begin() == '\'' && *s.rbegin() == '\'' ||
+            *s.begin() == '"' && *s.rbegin() == '"')
+            v = any(s.substr(1, s.size()-2));
+        else
+            v = any(s);
     }
 
 #if !defined(BOOST_NO_STD_WSTRING)
@@ -176,7 +158,12 @@ namespace boost { namespace program_options {
     void validate(any& v, const vector<wstring>& xs, std::string*, int)
     {
         check_first_occurrence(v);
-        v = any(get_single_string(xs));
+        wstring s(get_single_string(xs));
+        if (*s.begin() == L'\'' && *s.rbegin() == L'\'' ||
+            *s.begin() == L'"' && *s.rbegin() == L'"')
+            v = any(s.substr(1, s.size()-2));
+        else
+            v = any(s);
     }
 #endif
 
@@ -186,18 +173,19 @@ namespace boost { namespace program_options {
         void check_first_occurrence(const boost::any& value)
         {
             if (!value.empty())
-                boost::throw_exception(
-                    multiple_occurrences());
+                throw multiple_occurrences("multiple_occurrences");
         }
     }
 
 
     invalid_option_value::
     invalid_option_value(const std::string& bad_value)
-    : validation_error(validation_error::invalid_option_value, bad_value)
+    : validation_error(string("invalid option value '")
+                       .append(bad_value).append("'"))
     {}
 
 #ifndef BOOST_NO_STD_WSTRING
+
     namespace
     {
         std::string convert_value(const std::wstring& s)
@@ -213,123 +201,35 @@ namespace boost { namespace program_options {
 
     invalid_option_value::
     invalid_option_value(const std::wstring& bad_value)
-    : validation_error(validation_error::invalid_option_value, convert_value(bad_value))
+    : validation_error(string("invalid option value '")
+                       .append(convert_value(bad_value))
+                       .append("'"))
     {}
-#endif
-    const std::string& 
-    unknown_option::get_option_name() const throw()
-    { 
-        return m_option_name; 
-    }
+#endif                       
 
-    const std::string& 
-    ambiguous_option::get_option_name() const throw()
-    { 
-        return m_option_name; 
-    }
- 
-    const std::vector<std::string>& 
-    ambiguous_option::alternatives() const throw()
-    {
-        return m_alternatives;
-    }
 
-    void 
-    multiple_values::set_option_name(const std::string& option_name)
+
+    void validation_error::set_option_name(const std::string& option_name)
     {
         m_option_name = option_name;
     }
 
-    const std::string& 
-    multiple_values::get_option_name() const throw()
-    {
-        return m_option_name;
-    }
-    
-    void 
-    multiple_occurrences::set_option_name(const std::string& option_name)
-    {
-        m_option_name = option_name;
-    }
-
-    const std::string& 
-    multiple_occurrences::get_option_name() const throw()
-    {
-        return m_option_name;
-    }
-        
-    validation_error::    
-    validation_error(kind_t kind, 
-                     const std::string& option_value, 
-                     const std::string& option_name)
-     : error("")
-     , m_kind(kind) 
-     , m_option_name(option_name)
-     , m_option_value(option_value)
-     , m_message(error_message(kind))
-    {
-       if (!option_value.empty())
-       {
-          m_message.append(std::string("'") + option_value + std::string("'"));
-       }
-    }
-
-    void 
-    validation_error::set_option_name(const std::string& option_name)
-    {
-        m_option_name = option_name;
-    }
-
-    const std::string& 
-    validation_error::get_option_name() const throw()
-    {
-        return m_option_name;
-    }
-
-    std::string 
-    validation_error::error_message(kind_t kind)
-    {
-        // Initially, store the message in 'const char*' variable,
-        // to avoid conversion to std::string in all cases.
-        const char* msg;
-        switch(kind)
-        {
-        case multiple_values_not_allowed:
-            msg = "multiple values not allowed";
-            break;
-        case at_least_one_value_required:
-            msg = "at least one value required";
-            break;
-        case invalid_bool_value:
-            msg = "invalid bool value";
-            break;
-        case invalid_option_value:
-            msg = "invalid option value";
-            break;
-        case invalid_option:
-            msg = "invalid option";
-            break;
-        default:
-            msg = "unknown error";
-        }
-        return msg;
-    }
-
-    const char* 
-    validation_error::what() const throw()
+    const char* validation_error::what() const throw()
     {
         if (!m_option_name.empty())
         {
             m_message = "in option '" + m_option_name + "': " 
-                + error_message(m_kind);
+                + logic_error::what();
+            return m_message.c_str();
+
+        }
+        else
+        {
+            return logic_error::what();
         }
-        return m_message.c_str();
-    }
-    
-    const std::string& 
-    required_option::get_option_name() const throw()
-    {
-        return m_option_name;
     }
 
+
+
+
 }}

src/variables_map.cpp

@@ -23,9 +23,6 @@ namespace boost { namespace program_options {
     void store(const parsed_options& options, variables_map& xm,
                bool utf8)
     {       
-        // TODO: what if we have different definition
-        // for the same option name during different calls
-        // 'store'.
         assert(options.description);
         const options_description& desc = *options.description;
 
@@ -33,103 +30,70 @@ namespace boost { namespace program_options {
         // variables_map. Ehmm.. messy.
         std::map<std::string, variable_value>& m = xm;
 
-        std::set<std::string> new_final;
+        // The set of existing values that should not be changed.
+        std::set<std::string> final;
+        for (map<string, variable_value>::iterator k = m.begin(); 
+             k != m.end(); 
+             ++k) 
+        {
+            if (!k->second.defaulted()) {
+                // TODO: what if we have different definition
+                // for the same option name during different calls
+                // 'store'.
+                bool composing = desc.count(k->first)
+                    && desc.find(k->first).semantic()->is_composing();
 
-        // Declared once, to please Intel in VC++ mode;
-        unsigned i;
+                if (!composing)
+                    final.insert(k->first);
+            }
+        }
 
         // First, convert/store all given options
-        for (i = 0; i < options.options.size(); ++i) {
+        for (size_t i = 0; i < options.options.size(); ++i) {
 
             const string& name = options.options[i].string_key;
             // Skip positional options without name
             if (name.empty())
                 continue;
 
-            // Ignore unregistered option. The 'unregistered'
-            // field can be true only if user has explicitly asked
-            // to allow unregistered options. We can't store them
-            // to variables map (lacking any information about paring), 
-            // so just ignore them.
-            if (options.options[i].unregistered)
-                continue;
-
             // If option has final value, skip this assignment
-            if (xm.m_final.count(name))
+            if (final.count(name))
                 continue;
 
-            const option_description& d = desc.find(name, false, 
-                                                      false, false);
+            // Ignore options which are not described
+            if (desc.count(name) == 0)
+                continue;
+
+            const option_description& d = desc.find(name);
 
             variable_value& v = m[name];            
             if (v.defaulted()) {
                 // Explicit assignment here erases defaulted value
                 v = variable_value();
             }
-            
             try {
                 d.semantic()->parse(v.value(), options.options[i].value, utf8);
             }
-#ifndef BOOST_NO_EXCEPTIONS
             catch(validation_error& e)
             {
                 e.set_option_name(name);
                 throw;
             }
-            catch(multiple_occurrences& e)
-            {
-                e.set_option_name(name);
-                throw;
-            }
-            catch(multiple_values& e) 
-            {
-                e.set_option_name(name);
-                throw;
-            }
-#endif
             v.m_value_semantic = d.semantic();
-            
-            // The option is not composing, and the value is explicitly
-            // provided. Ignore values of this option for subsequent
-            // calls to 'store'. We store this to a temporary set,
-            // so that several assignment inside *this* 'store' call
-            // are allowed.
-            if (!d.semantic()->is_composing())
-                new_final.insert(name);
         }
-        xm.m_final.insert(new_final.begin(), new_final.end());
+        
+        // Second, apply default values.
+        set<string> keys = desc.primary_keys();
+        for (set<string>::const_iterator j = keys.begin(); j != keys.end(); ++j)
+            if (m.count(*j) == 0) {
+                const option_description& d = desc.find(*j);
 
-        
-        
-        // Second, apply default values and store required options.
-        const vector<shared_ptr<option_description> >& all = desc.options();
-        for(i = 0; i < all.size(); ++i)
-        {
-            const option_description& d = *all[i];
-            string key = d.key("");
-            // FIXME: this logic relies on knowledge of option_description
-            // internals.
-            // The 'key' is empty if options description contains '*'. 
-            // In that 
-            // case, default value makes no sense at all.
-            if (key.empty())
-            {
-                continue;
-            }
-            if (m.count(key) == 0) {
-            
                 boost::any def;
                 if (d.semantic()->apply_default(def)) {
-                    m[key] = variable_value(def, true);
-                    m[key].m_value_semantic = d.semantic();
+                    m[*j] = variable_value(def, true);
+                    m[*j].m_value_semantic = d.semantic();
                 }
-            }  
-
-            // add empty value if this is an required option
-            if (d.semantic()->is_required()) {
-               xm.m_required.insert(key);
-            }
-        }
+            }        
     }
 
     BOOST_PROGRAM_OPTIONS_DECL 
@@ -141,7 +105,13 @@ namespace boost { namespace program_options {
     BOOST_PROGRAM_OPTIONS_DECL 
     void notify(variables_map& vm)
     {        
-        vm.notify();               
+        // Lastly, run notify actions.
+        for (map<string, variable_value>::iterator k = vm.begin(); 
+             k != vm.end(); 
+             ++k) 
+        {
+            k->second.m_value_semantic->notify(k->second.value());
+        }               
     }
 
     abstract_variables_map::abstract_variables_map()
@@ -192,40 +162,4 @@ namespace boost { namespace program_options {
         else
             return i->second;
     }
-    
-    void
-    variables_map::notify()
-    {
-        // This checks if all required options occur
-        for (set<string>::const_iterator r = m_required.begin();
-             r != m_required.end();
-             ++r)
-        {
-            const string& opt = *r;
-            map<string, variable_value>::const_iterator iter = find(opt);
-            if (iter == end() || iter->second.empty()) 
-            {
-                boost::throw_exception(required_option(opt));
-            
-            }
-        }
-
-        // Lastly, run notify actions.
-        for (map<string, variable_value>::iterator k = begin(); 
-             k != end(); 
-             ++k) 
-        {
-            /* Users might wish to use variables_map to store their own values
-               that are not parsed, and therefore will not have value_semantics
-               defined. Do no crash on such values. In multi-module programs,
-               one module might add custom values, and the 'notify' function
-               will be called after that, so we check that value_sematics is 
-               not NULL. See:
-                   https://svn.boost.org/trac/boost/ticket/2782
-            */
-            if (k->second.m_value_semantic)
-                k->second.m_value_semantic->notify(k->second.value());
-        }               
-    }
-    
 }}

src/winmain.cpp

@@ -10,27 +10,26 @@
 #ifdef _WIN32
 namespace boost { namespace program_options {
 
-    // Take a command line string and splits in into tokens, according
-    // to the rules windows command line processor uses.
-    // 
-    // The rules are pretty funny, see
+    using namespace std;
+
+    // The rules for windows command line are pretty funny, see
     //    http://article.gmane.org/gmane.comp.lib.boost.user/3005
     //    http://msdn.microsoft.com/library/en-us/vccelng/htm/progs_12.asp
+    
     BOOST_PROGRAM_OPTIONS_DECL
     std::vector<std::string> split_winmain(const std::string& input)
     {
         std::vector<std::string> result;
 
-        std::string::const_iterator i = input.begin(), e = input.end();
+        string::const_iterator i = input.begin(), e = input.end();
         for(;i != e; ++i)
-            if (!isspace((unsigned char)*i))
+            if (!isspace(*i))
                 break;
        
         if (i != e) {
    
             std::string current;
             bool inside_quoted = false;
-            bool empty_quote = false;
             int backslash_count = 0;
             
             for(; i != e; ++i) {
@@ -39,7 +38,6 @@ namespace boost { namespace program_options {
                     // n/2 backslashes and is a quoted block delimiter
                     if (backslash_count % 2 == 0) {
                         current.append(backslash_count / 2, '\\');
-                        empty_quote = inside_quoted && current.empty();
                         inside_quoted = !inside_quoted;
                         // '"' preceded by odd number (n) of backslashes generates
                         // (n-1)/2 backslashes and is literal quote.
@@ -57,12 +55,11 @@ namespace boost { namespace program_options {
                         current.append(backslash_count, '\\');
                         backslash_count = 0;
                     }
-                    if (isspace((unsigned char)*i) && !inside_quoted) {
+                    if (isspace(*i) && !inside_quoted) {
                         // Space outside quoted section terminate the current argument
                         result.push_back(current);
                         current.resize(0);
-                        empty_quote = false; 
-                        for(;i != e && isspace((unsigned char)*i); ++i)
+                        for(;i != e && isspace(*i); ++i)
                             ;
                         --i;
                     } else {                  
@@ -77,7 +74,7 @@ namespace boost { namespace program_options {
         
             // If we have non-empty 'current' or we're still in quoted
             // section (even if 'current' is empty), add the last token.
-            if (!current.empty() || inside_quoted || empty_quote)
+            if (!current.empty() || inside_quoted)
                 result.push_back(current);        
         }
         return result;
@@ -87,9 +84,9 @@ namespace boost { namespace program_options {
     BOOST_PROGRAM_OPTIONS_DECL std::vector<std::wstring>
     split_winmain(const std::wstring& cmdline)
     {
-        std::vector<std::wstring> result;
-        std::vector<std::string> aux = split_winmain(to_internal(cmdline));
-        for (unsigned i = 0, e = aux.size(); i < e; ++i)
+        vector<wstring> result;
+        vector<string> aux = split_winmain(to_internal(cmdline));
+        for (unsigned i = 0, e = result.size(); i < e; ++i)
             result.push_back(from_utf8(aux[i]));
         return result;        
     }
@@ -97,4 +94,3 @@ namespace boost { namespace program_options {
 
 }}
 #endif
-

test/Jamfile

@@ -0,0 +1,47 @@
+
+subproject libs/program_options/test ;
+
+import testing ;
+
+rule program-options-test ( name )
+{
+    return [ 
+      run $(name).cpp <lib>../build/boost_program_options
+        <lib>../../test/build/boost_test_exec_monitor : :
+        : <include>$(BOOST_ROOT) 
+          std::locale-support ]
+    ;
+}
+
+rule program-options-dll-test ( name )
+{
+    return [ 
+      run $(name).cpp <dll>../build/boost_program_options
+        <lib>../../test/build/boost_test_exec_monitor : :
+        : <include>$(BOOST_ROOT) 
+          <define>BOOST_ALL_DYN_LINK=1
+          <runtime-link>dynamic
+        : $(name)_dll ]
+    ;
+}
+
+
+test-suite program_options : 
+    [ program-options-test options_description_test ]
+    [ program-options-test parsers_test ]
+    [ program-options-test variable_map_test ]
+    [ program-options-test cmdline_test ]
+    [ program-options-test positional_options_test ]
+    [ program-options-test unicode_test ]
+    [ program-options-test winmain ] 
+    [ program-options-dll-test options_description_test ]
+    [ program-options-dll-test parsers_test ]
+    [ program-options-dll-test variable_map_test ]
+    [ program-options-dll-test cmdline_test ]
+    [ program-options-dll-test positional_options_test ]
+    [ program-options-dll-test unicode_test ]
+    [ program-options-dll-test winmain ] 
+    
+    
+    ;
+

test/Jamfile.v2

@@ -1,38 +1,24 @@
 
 project
     : requirements 
-    <library>../build//boost_program_options
-    <link>static
-    <variant>debug
+    <library>../build//program_options
+    <library>/boost/test//boost_test_exec_monitor
+    <hardcode-dll-paths>true
     
 #    <define>_GLIBCXX_CONCEPT_CHECKS
 #    <define>_GLIBCXX_DEBUG
     ;
-    
-rule po-test ( source : input-file ? )
-{
-    return
-        [ run $(source) : : $(input-file) ]
-        [ run $(source) : : $(input-file) 
-          : <link>shared <define>BOOST_PROGRAM_OPTIONS_DYN_LINK=1
-          : $(source:B)_dll ] 
-    ;   
-}    
 
 test-suite program_options :
 
-    [ po-test options_description_test.cpp ] 
-    [ po-test parsers_test.cpp : config_test.cfg ]
-    [ po-test variable_map_test.cpp ]
-    [ po-test cmdline_test.cpp ]
-    [ po-test positional_options_test.cpp ]
-    [ po-test unicode_test.cpp ] 
-    [ po-test winmain.cpp ] 
-    [ po-test exception_test.cpp ]
-    [ po-test split_test.cpp ]
-    [ po-test unrecognized_test.cpp ]
-    [ po-test required_test.cpp : required_test.cfg ]
+    [ run options_description_test.cpp ] 
+    [ run parsers_test.cpp ]
+    [ run variable_map_test.cpp ]
+    [ run cmdline_test.cpp ]
+    [ run positional_options_test.cpp ]
+    [ run unicode_test.cpp ] 
+    [ run winmain.cpp ] 
     ;
         
-exe test_convert : test_convert.cpp ;   
+exe test_convert : test_convert.cpp ../build//program_options ;   
 

test/cmdline_test.cpp

@@ -3,20 +3,21 @@
 // (See accompanying file LICENSE_1_0.txt
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+
 #include <boost/program_options/cmdline.hpp>
-#include <boost/program_options/options_description.hpp>
 #include <boost/program_options/detail/cmdline.hpp>
 using namespace boost::program_options;
 using boost::program_options::detail::cmdline;
 
+
+#include <boost/test/test_tools.hpp>
+
 #include <iostream>
 #include <sstream>
 #include <vector>
 #include <cassert>
 using namespace std;
 
-#include "minitest.hpp"
-
 /* To facilitate testing, declare a number of error codes. Otherwise,
    we'd have to specify the type of exception that should be thrown.
 */
@@ -30,7 +31,6 @@ const int s_short_adjacent_not_allowed = 5;
 const int s_empty_adjacent_parameter = 6;
 const int s_missing_parameter = 7;
 const int s_extra_parameter = 8;
-const int s_unrecognized_line = 9;
 
 int translate_syntax_error_kind(invalid_command_line_syntax::kind_t k)
 {
@@ -41,7 +41,6 @@ int translate_syntax_error_kind(invalid_command_line_syntax::kind_t k)
         invalid_command_line_syntax::empty_adjacent_parameter,
         invalid_command_line_syntax::missing_parameter,
         invalid_command_line_syntax::extra_parameter,
-        invalid_command_line_syntax::unrecognized_line 
     };
     invalid_command_line_syntax::kind_t *b, *e, *i;
     b = table;
@@ -51,19 +50,19 @@ int translate_syntax_error_kind(invalid_command_line_syntax::kind_t k)
     return std::distance(b, i) + 3;
 }
 
+
 struct test_case {
     const char* input;
     int expected_status;
     const char* expected_result;
 };
 
-
 /* Parses the syntax description in 'syntax' and initialized
    'cmd' accordingly' 
    The "boost::program_options" in parameter type is needed because CW9 
    has std::detail and it causes an ambiguity.
 */
-void apply_syntax(options_description& desc, 
+void apply_syntax(cmdline& cmd, 
                   const char* syntax)
 {
    
@@ -71,29 +70,32 @@ void apply_syntax(options_description& desc,
     stringstream ss;
     ss << syntax;
     while(ss >> s) {
-        value_semantic* v = 0;
+        string long_name;
+        char short_name = '\0';
+        char properties = '|';
         
         if (*(s.end()-1) == '=') {
-            v = value<string>();
+            properties = ':';
             s.resize(s.size()-1);
         } else if (*(s.end()-1) == '?') {
-            //v = value<string>()->implicit();
-            v = value<string>();
+            properties = '?';
             s.resize(s.size()-1);
         } else if (*(s.end()-1) == '*') {
-            v = value<vector<string> >()->multitoken();
+            properties = '*';
             s.resize(s.size()-1);
         } else if (*(s.end()-1) == '+') {
-            v = value<vector<string> >()->multitoken();
+            properties = '+';
             s.resize(s.size()-1);
         }
-        if (v) {
-            desc.add_options()
-                (s.c_str(), v, "");
+        string::size_type n = s.find(',');
+        if (n == string::npos) {
+            long_name = s;
         } else {
-            desc.add_options()
-                (s.c_str(), "");
+            assert(n == s.size()-2);
+            long_name = s.substr(0, s.size()-2);
+            short_name = *s.rbegin();
         }
+        cmd.add_option(long_name, short_name, properties, 1);
     }
 }
 
@@ -112,36 +114,30 @@ void test_cmdline(const char* syntax,
                 xinput.push_back(s);
             }
         }
-        options_description desc;
-        apply_syntax(desc, syntax);
-
-        cmdline cmd(xinput);
-        cmd.style(style);
-        cmd.set_options_description(desc);
+        cmdline cmd(xinput, style);
 
+        apply_syntax(cmd, syntax);
 
         string result;
         int status = 0;
 
         try {
-            vector<option> options = cmd.run();
-
-            for(unsigned i = 0; i < options.size(); ++i)
-            {
-                option opt = options[i];
-
-                if (opt.position_key != -1) {
+            while(++cmd) {
+                if (cmd.at_argument()) {
                     if (!result.empty())
                         result += " ";
-                    result += opt.value[0];
+                    result += cmd.argument();
                 } else {
                     if (!result.empty())
                         result += " ";
-                    result += opt.string_key + ":";
-                    for (size_t j = 0; j < opt.value.size(); ++j) {
-                        if (j != 0)
+                    if (*cmd.option_name().rbegin() != '*')
+                        result += cmd.option_name() + ":";
+                    else
+                        result += cmd.raw_option_name() + ":";
+                    for (size_t i = 0; i < cmd.option_values().size(); ++i) {
+                        if (i != 0)
                             result += "-";
-                        result += opt.value[j];
+                        result += cmd.option_values()[i];
                     }                    
                 }
             }
@@ -181,28 +177,34 @@ void test_long_options()
         {"--foo=13", s_extra_parameter, ""},
 
         // Test option with required parameter
+
         {"--bar=", s_empty_adjacent_parameter, ""},
         {"--bar", s_missing_parameter, ""},
-
         {"--bar=123", s_success, "bar:123"},
-        {0, 0, 0}
-    };
-    test_cmdline("foo bar=", style, test_cases1);
 
+        // Test option with optional parameter
+        {"--baz", s_success, "baz:"},
+        {"--baz=7", s_success, "baz:7"},
+        {0}
+    };
+    test_cmdline("foo bar= baz?", style, test_cases1);
 
     style = cmdline::style_t(
         allow_long | long_allow_next);
 
     test_case test_cases2[] = {
+        {"--foo", s_success, "foo:"},
+        {"--bar=10", s_long_adjacent_not_allowed, ""},
         {"--bar 10", s_success, "bar:10"},
         {"--bar", s_missing_parameter,  ""},
-        // Since --bar accepts a parameter, --foo is
-        // considered a value, even though it looks like
-        // an option.
-        {"--bar --foo", s_success, "bar:--foo"},
-        {0, 0, 0}
+        {"--bar --foo", s_missing_parameter, ""},
+        {"--baz", s_success, "baz:"},
+        {"--baz 10", s_success, "baz:10"},
+        {"--baz --foo", s_success, "baz: foo:"},
+        {0}
     };
-    test_cmdline("foo bar=", style, test_cases2);
+    test_cmdline("foo bar= baz?", style, test_cases2);
+
     style = cmdline::style_t(
         allow_long | long_allow_adjacent
         | long_allow_next);
@@ -210,9 +212,12 @@ void test_long_options()
     test_case test_cases3[] = {
         {"--bar=10", s_success, "bar:10"},
         {"--bar 11", s_success, "bar:11"},
-        {0, 0, 0}
+        {"--baz=12", s_success, "baz:12"},
+        {"--baz 13", s_success, "baz:13"},
+        {"--baz --foo", s_success, "baz: foo:"},
+        {0}
     };
-    test_cmdline("foo bar=", style, test_cases3);
+    test_cmdline("foo bar= baz?", style, test_cases3);
 
     style = cmdline::style_t(
         allow_long | long_allow_adjacent
@@ -226,7 +231,7 @@ void test_long_options()
         {"--bar=Ab", s_success, "bar:Ab"},
         {"--Bar=ab", s_success, "bar:ab"},
         {"--giz", s_success, "Giz:"},
-        {0, 0, 0}
+        {0}
     };
     test_cmdline("foo bar= baz? Giz", style, test_cases4);
 }
@@ -243,14 +248,14 @@ void test_short_options()
     test_case test_cases1[] = {
         {"-d d /bar", s_success, "-d: d /bar"},
         // This is treated as error when long options are disabled
-        {"--foo", s_success, "--foo"},
+        {"--foo", s_long_not_allowed, ""},
         {"-d13", s_extra_parameter, ""},
         {"-f14", s_success, "-f:14"},
         {"-g -f1", s_success, "-g: -f:1"},
         {"-f", s_missing_parameter, ""},
-        {0, 0, 0}
+        {0}
     };
-    test_cmdline(",d ,f= ,g", style, test_cases1);
+    test_cmdline(",d ,f= ,g?", style, test_cases1);
 
     style = cmdline::style_t(
         allow_short | allow_dash_for_short
@@ -260,11 +265,18 @@ void test_short_options()
         {"-f 13", s_success, "-f:13"},
         {"-f -13", s_success, "-f:-13"},
         {"-f", s_missing_parameter, ""},
+        {"-f --foo", s_missing_parameter, ""},
         {"-f /foo", s_success, "-f:/foo"},
-        {"-f -d", s_missing_parameter, ""},
-        {0, 0, 0}
+        {"-f -d", s_success, "-f:-d"},
+        {"-g 13", s_success, "-g:13"},
+        {"-g", s_success, "-g:"},
+        {"-g --foo", s_long_not_allowed, "-g:"},
+        {"-g /foo", s_success, "-g:/foo"},
+        {"-g -d", s_success, "-g: -d:"},
+        {"-f12", s_short_adjacent_not_allowed, ""},
+        {0}
     };
-    test_cmdline(",d ,f=", style, test_cases2);
+    test_cmdline(",d ,f= ,g?", style, test_cases2);
 
     style = cmdline::style_t(
         allow_short | short_allow_next
@@ -273,10 +285,13 @@ void test_short_options()
     test_case test_cases3[] = {
         {"-f10", s_success, "-f:10"},
         {"-f 10", s_success, "-f:10"},
-        {"-f -d", s_missing_parameter, ""},
-        {0, 0, 0}
+        {"-f -d", s_success, "-f:-d"},
+        {"-g10", s_success, "-g:10"},
+        {"-g 10", s_success, "-g:10"},
+        {"-g -d", s_success, "-g: -d:"},
+        {0}
     };
-    test_cmdline(",d ,f=", style, test_cases3);
+    test_cmdline(",d ,f= ,g?", style, test_cases3);
 
     style = cmdline::style_t(
         allow_short | short_allow_next
@@ -285,14 +300,14 @@ void test_short_options()
 
     test_case test_cases4[] = {
         {"-de", s_success, "-d: -e:"},
-        {"-df10", s_success, "-d: -f:10"},
-        // FIXME: review
-        //{"-d12", s_extra_parameter, ""},
-        {"-f12", s_success, "-f:12"},
+        {"-dg", s_success, "-d: -g:"},
+        {"-dg10", s_success, "-d: -g:10"},
+        {"-d12", s_extra_parameter, ""},
+        {"-gd", s_success, "-g:d"},
         {"-fe", s_success, "-f:e"},
-        {0, 0, 0}
+        {0}
     };
-    test_cmdline(",d ,f= ,e", style, test_cases4);
+    test_cmdline(",d ,f= ,g? ,e", style, test_cases4);
 
 }
 
@@ -308,13 +323,15 @@ void test_dos_options()
 
     test_case test_cases1[] = {
         {"/d d -bar", s_success, "-d: d -bar"},
-        {"--foo", s_success, "--foo"},
+        // This is treated as disallowed long option
+        {"--foo", s_long_not_allowed, ""},
         {"/d13", s_extra_parameter, ""},
         {"/f14", s_success, "-f:14"},
+        {"/g /f1", s_success, "-g: -f:1"},
         {"/f", s_missing_parameter, ""},
-        {0, 0, 0}
+        {0}
     };
-    test_cmdline(",d ,f=", style, test_cases1);
+    test_cmdline(",d ,f= ,g?", style, test_cases1);
 
     style = cmdline::style_t(
         allow_short 
@@ -323,14 +340,14 @@ void test_dos_options()
 
     test_case test_cases2[] = {
         {"/de", s_extra_parameter, ""},
+        {"/gd", s_success, "-g:d"},
         {"/fe", s_success, "-f:e"},
-        {0, 0, 0}
+        {0}
     };
-    test_cmdline(",d ,f= ,e", style, test_cases2);
+    test_cmdline(",d ,f= ,g? ,e", style, test_cases2);
 
 }
 
-
 void test_disguised_long()
 {
     using namespace command_line_style;
@@ -346,7 +363,7 @@ void test_disguised_long()
         {"-foo -f", s_success, "foo: foo:"},
         {"-goo=x -gy", s_success, "goo:x goo:y"},
         {"-bee=x -by", s_success, "bee:x bee:y"},
-        {0, 0, 0}
+        {0}
     };
     test_cmdline("foo,f goo,g= bee,b?", style, test_cases1);
 
@@ -354,7 +371,7 @@ void test_disguised_long()
     test_case test_cases2[] = {
         {"/foo -f", s_success, "foo: foo:"},
         {"/goo=x", s_success, "goo:x"},
-        {0, 0, 0}
+        {0}
     };
     test_cmdline("foo,f goo,g= bee,b?", style, test_cases2);
 }
@@ -375,7 +392,7 @@ void test_guessing()
         {"--opt", s_ambiguous_option, ""},
         {"--f=1", s_success, "foo:1"},
         {"-far", s_success, "foo:ar"},
-        {0, 0, 0}
+        {0}
     };
     test_cmdline("opt123 opt56 foo,f=", style, test_cases1);
 }
@@ -393,7 +410,7 @@ void test_arguments()
     test_case test_cases1[] = {
         {"-f file -gx file2", s_success, "-f: file -g:x file2"},
         {"-f - -gx - -- -e", s_success, "-f: - -g:x - -e"},
-        {0, 0, 0}
+        {0}
     };
     test_cmdline(",f ,g= ,e", style, test_cases1);
 
@@ -406,7 +423,7 @@ void test_arguments()
 
     test_case test_cases2[] = {
         {"-f - -gx - -- -e", s_success, "-f: - -g:x - -e"},
-        {0, 0, 0}
+        {0}
     };
     test_cmdline(",f ,g= ,e", style, test_cases2);
 }
@@ -424,182 +441,49 @@ void test_prefix()
 
     test_case test_cases1[] = {
         {"--foo.bar=12", s_success, "foo.bar:12"},
-        {0, 0, 0}
+        {0}
     };
 
     test_cmdline("foo*=", style, test_cases1);
 }
 
-
-pair<string, string> at_option_parser(string const&s)
+void test_multiple()
 {
-    if ('@' == s[0])
-        return std::make_pair(string("response-file"), s.substr(1));
-    else
-        return pair<string, string>();
+    using namespace command_line_style;
+    cmdline::style_t style;
+
+    style = cmdline::style_t(
+        unix_style | long_allow_next);
+
+    test_case test_cases1[] = {
+        {"--value 1 2 3 4 --help", s_success, "value:1-2-3-4 help:"},
+        {"--value 1 2 3 4 --", s_success, "value:1-2-3-4"},
+        {0}
+    };
+
+    test_cmdline("value+ help", style, test_cases1);
 }
 
-pair<string, string> at_option_parser_broken(string const&s)
+void test_style_errors()
 {
-    if ('@' == s[0])
-        return std::make_pair(string("some garbage"), s.substr(1));
-    else
-        return pair<string, string>();
+    using namespace command_line_style;
+    char* argv[] = {"program"};
+
+    BOOST_CHECK_THROW(cmdline cmd(1, (const char*const *)argv, allow_long),
+                      invalid_command_line_style);
+
+    BOOST_CHECK_THROW(cmdline cmd(1, (const char*const *)argv, allow_short),
+                      invalid_command_line_style);
+
+    BOOST_CHECK_THROW(cmdline cmd(1, (const char*const *)argv, allow_short | 
+                                  short_allow_next),
+                      invalid_command_line_style);
 }
 
-
-
-void test_additional_parser()
+int test_main(int ac, char* av[])
 {
-    options_description desc;
-    desc.add_options()
-        ("response-file", value<string>(), "response file")
-        ("foo", value<int>(), "foo")
-        ;
+// ###     detail::test_cmdline_detail();
 
-    vector<string> input;
-    input.push_back("@config");
-    input.push_back("--foo=1");
-
-    cmdline cmd(input);
-    cmd.set_options_description(desc);
-    cmd.set_additional_parser(at_option_parser);
-
-    vector<option> result = cmd.run();
-
-    BOOST_REQUIRE(result.size() == 2);
-    BOOST_CHECK_EQUAL(result[0].string_key, "response-file");
-    BOOST_CHECK_EQUAL(result[0].value[0], "config");
-    BOOST_CHECK_EQUAL(result[1].string_key, "foo");
-    BOOST_CHECK_EQUAL(result[1].value[0], "1");    
-
-    // Test that invalid options returned by additional style
-    // parser are detected.
-    cmdline cmd2(input);
-    cmd2.set_options_description(desc);
-    cmd2.set_additional_parser(at_option_parser_broken);
-
-    BOOST_CHECK_THROW(cmd2.run(), unknown_option);
-
-}
-
-vector<option> at_option_parser2(vector<string>& args)
-{
-    vector<option> result;
-    if ('@' == args[0][0]) {
-        // Simulate reading the response file.
-        result.push_back(option("foo", vector<string>(1, "1")));
-        result.push_back(option("bar", vector<string>(1, "1")));
-        args.erase(args.begin());
-    }
-    return result;
-}
-
-
-void test_style_parser()
-{
-    options_description desc;
-    desc.add_options()
-        ("foo", value<int>(), "foo")
-        ("bar", value<int>(), "bar")
-        ;
-
-    vector<string> input;
-    input.push_back("@config");
-
-    cmdline cmd(input);
-    cmd.set_options_description(desc);
-    cmd.extra_style_parser(at_option_parser2);
-
-    vector<option> result = cmd.run();
-
-    BOOST_REQUIRE(result.size() == 2);
-    BOOST_CHECK_EQUAL(result[0].string_key, "foo");
-    BOOST_CHECK_EQUAL(result[0].value[0], "1");    
-    BOOST_CHECK_EQUAL(result[1].string_key, "bar");
-    BOOST_CHECK_EQUAL(result[1].value[0], "1");    
-}
-
-void test_unregistered()
-{
-    // Check unregisted option when no options are registed at all.
-    options_description desc;
-
-    vector<string> input;
-    input.push_back("--foo=1");
-    input.push_back("--bar");
-    input.push_back("1");
-    input.push_back("-b");
-    input.push_back("-biz");
-
-    cmdline cmd(input);
-    cmd.set_options_description(desc);
-    cmd.allow_unregistered();
-    
-    vector<option> result = cmd.run();
-    BOOST_REQUIRE(result.size() == 5);
-    // --foo=1
-    BOOST_CHECK_EQUAL(result[0].string_key, "foo");
-    BOOST_CHECK_EQUAL(result[0].unregistered, true);
-    BOOST_CHECK_EQUAL(result[0].value[0], "1");
-    // --bar
-    BOOST_CHECK_EQUAL(result[1].string_key, "bar");
-    BOOST_CHECK_EQUAL(result[1].unregistered, true);
-    BOOST_CHECK(result[1].value.empty());
-    // '1' is considered a positional option, not a value to
-    // --bar
-    BOOST_CHECK(result[2].string_key.empty());
-    BOOST_CHECK(result[2].position_key == 0);
-    BOOST_CHECK_EQUAL(result[2].unregistered, false);
-    BOOST_CHECK_EQUAL(result[2].value[0], "1");
-    // -b
-    BOOST_CHECK_EQUAL(result[3].string_key, "-b");
-    BOOST_CHECK_EQUAL(result[3].unregistered, true);
-    BOOST_CHECK(result[3].value.empty());
-    // -biz
-    BOOST_CHECK_EQUAL(result[4].string_key, "-b");
-    BOOST_CHECK_EQUAL(result[4].unregistered, true);
-    BOOST_CHECK_EQUAL(result[4].value[0], "iz");
-
-    // Check sticky short options together with unregisted options.
-    
-    desc.add_options()
-        ("help,h", "")
-        ("magic,m", value<string>(), "")
-        ;
-
-    input.clear();
-    input.push_back("-hc");
-    input.push_back("-mc");
-
-
-    cmdline cmd2(input);
-    cmd2.set_options_description(desc);
-    cmd2.allow_unregistered();
-    
-    result = cmd2.run();
-
-    BOOST_REQUIRE(result.size() == 3);
-    BOOST_CHECK_EQUAL(result[0].string_key, "help");
-    BOOST_CHECK_EQUAL(result[0].unregistered, false);
-    BOOST_CHECK(result[0].value.empty());
-    BOOST_CHECK_EQUAL(result[1].string_key, "-c");
-    BOOST_CHECK_EQUAL(result[1].unregistered, true);
-    BOOST_CHECK(result[1].value.empty());
-    BOOST_CHECK_EQUAL(result[2].string_key, "magic");
-    BOOST_CHECK_EQUAL(result[2].unregistered, false);
-    BOOST_CHECK_EQUAL(result[2].value[0], "c");
-
-    // CONSIDER:
-    // There's a corner case:
-    //   -foo
-    // when 'allow_long_disguise' is set. Should this be considered
-    // disguised long option 'foo' or short option '-f' with value 'oo'?
-    // It's not clear yet, so I'm leaving the decision till later.
-}
-
-int main(int /*ac*/, char** /*av*/)
-{
     test_long_options();
     test_short_options();
     test_dos_options();
@@ -607,9 +491,31 @@ int main(int /*ac*/, char** /*av*/)
     test_guessing();
     test_arguments();
     test_prefix();
-    test_additional_parser();
-    test_style_parser();
-    test_unregistered();
+    test_multiple();
+    test_style_errors();
+
+    cmdline cmd((int)ac, (const char*const *)av, 
+                int(command_line_style::unix_style));
+    cmd.add_option("version", 'v');
+    cmd.add_option("help", 'h');
+    cmd.add_option("verbose", 'V');
+    cmd.add_option("magic", 'm');
+    cmd.add_option("output", 'o', ':');
+
+    try {
+        while(++cmd) {
+
+            if (cmd.at_argument()) {
+                cout << "Argument : " << cmd.argument() << "\n";
+            } else {
+                cout << "Option : " << cmd.option_name()
+                     << "(" << cmd.option_value() << ")\n";
+            } 
+        }
+    }
+    catch(exception& e) {
+        cout << e.what() << "\n";
+    }
 
     return 0;
 }

test/config_test.cfg

@@ -1,9 +0,0 @@
-gv1 = 0#asd
-empty_value = 
-plug3 = 7
-b = true
-
-[m1]
-v1 = 1
-
-v2 = 2

test/exception_test.cpp

@@ -1,164 +0,0 @@
-// Copyright Sascha Ochsenknecht 2009.
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt
-// or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-
-#include <boost/program_options/parsers.hpp>
-#include <boost/program_options/options_description.hpp>
-#include <boost/program_options/variables_map.hpp>
-#include <boost/program_options/cmdline.hpp>
-using namespace boost::program_options;
-
-#include <iostream>
-#include <sstream>
-#include <vector>
-#include <cassert>
-using namespace std;
-
-#include "minitest.hpp"
-
-
-void test_ambiguous() 
-{
-    options_description desc; 
-    desc.add_options()
-        ("cfgfile,c", value<string>()->multitoken(), "the config file") 
-        ("output,c", value<string>(), "the output file") 
-        ("output,o", value<string>(), "the output file")
-    ;
-
-    const char* cmdline[] = {"program", "-c", "file", "-o", "anotherfile"};
-
-    variables_map vm;
-    try {
-       store(parse_command_line(sizeof(cmdline)/sizeof(const char*), 
-                                    const_cast<char**>(cmdline), desc), vm);
-    }
-    catch (ambiguous_option& e)
-    {
-        BOOST_CHECK_EQUAL(e.alternatives().size(), 2);
-        BOOST_CHECK_EQUAL(e.get_option_name(), "-c");      
-        BOOST_CHECK_EQUAL(e.alternatives()[0], "cfgfile");
-        BOOST_CHECK_EQUAL(e.alternatives()[1], "output");
-    }
-}
-
-
-
-void test_unknown_option() 
-{
-   options_description desc;
-   desc.add_options()
-        ("cfgfile,c", value<string>(), "the configfile")
-      ;
-
-   const char* cmdline[] = {"program", "-c", "file", "-f", "anotherfile"};
-   
-   variables_map vm;
-   try {
-      store(parse_command_line(sizeof(cmdline)/sizeof(const char*), 
-                                    const_cast<char**>(cmdline), desc), vm);
-   }
-   catch (unknown_option& e)
-   {
-      BOOST_CHECK_EQUAL(e.get_option_name(), "-f");      
-      BOOST_CHECK_EQUAL(string(e.what()), "unknown option -f");
-   }
-}
-
-
-
-void test_multiple_values() 
-{
-   options_description desc;
-   desc.add_options()
-        ("cfgfile,c", value<string>()->multitoken(), "the config file")
-        ("output,o", value<string>(), "the output file")
-      ;
-
-   const char* cmdline[] = { "program", "-o", "fritz", "hugo", "--cfgfile", "file", "c", "-o", "text.out" };
-   
-   variables_map vm;
-   try {
-      store(parse_command_line(sizeof(cmdline)/sizeof(const char*), 
-                                    const_cast<char**>(cmdline), desc), vm);
-      notify(vm);
-   }
-   catch (validation_error& e)
-   {
-      // TODO: this is currently validation_error, shouldn't it be multiple_values ???
-      // 
-      //   multiple_values is thrown only at one place untyped_value::xparse(),
-      //    but I think this can never be reached
-      //   because: untyped_value always has one value and this is filtered before reach specific
-      //   validation and parsing
-      //
-      BOOST_CHECK_EQUAL(e.get_option_name(), "cfgfile");      
-      BOOST_CHECK_EQUAL(string(e.what()), "in option 'cfgfile': multiple values not allowed");
-   }
-}
-
-
-
-void test_multiple_occurrences()
-{
-   options_description desc;
-   desc.add_options()
-        ("cfgfile,c", value<string>(), "the configfile")
-      ;
-
-   const char* cmdline[] = {"program", "--cfgfile", "file", "-c", "anotherfile"};
-   
-   variables_map vm;
-   try {
-      store(parse_command_line(sizeof(cmdline)/sizeof(const char*), 
-                                    const_cast<char**>(cmdline), desc), vm);
-      notify(vm);
-   }
-   catch (multiple_occurrences& e)
-   {
-      BOOST_CHECK_EQUAL(e.get_option_name(), "cfgfile");      
-      BOOST_CHECK_EQUAL(string(e.what()), "multiple occurrences");
-   }
-}
-
-
-
-void test_missing_value()
-{
-    options_description desc;
-    desc.add_options()
-        ("cfgfile,c", value<string>()->multitoken(), "the config file") 
-        ("output,o", value<string>(), "the output file")
-    ;
-    // missing value for option '-c'
-    const char* cmdline[] = { "program", "-c", "-c", "output.txt"};
-    
-    variables_map vm;
-    
-    try {
-      store(parse_command_line(sizeof(cmdline)/sizeof(const char*), 
-                                       const_cast<char**>(cmdline), desc), vm);
-      notify(vm);
-   } 
-   catch (invalid_command_line_syntax& e)
-   {
-      BOOST_CHECK_EQUAL(e.kind(), invalid_syntax::missing_parameter);
-      BOOST_CHECK_EQUAL(e.tokens(), "cfgfile");
-   }
-}
-
-
-
-int main(int /*ac*/, char** /*av*/)
-{
-   test_ambiguous();
-   test_unknown_option();
-   test_multiple_values();
-   test_multiple_occurrences();
-   test_missing_value();
-
-   return 0;
-}
-

test/minitest.hpp

@@ -1,25 +0,0 @@
-#ifndef BOOST_PROGRAM_OPTIONS_MINITEST
-#define BOOST_PROGRAM_OPTIONS_MINITEST
-
-#include <assert.h>
-#include <iostream>
-#include <stdlib.h>
-
-#define BOOST_REQUIRE(b) assert(b)
-#define BOOST_CHECK(b) assert(b)
-#define BOOST_CHECK_EQUAL(a, b) assert(a == b)
-#define BOOST_ERROR(description) std::cerr << description; std::cerr << "\n"; abort();
-#define BOOST_CHECK_THROW(expression, exception) \
-    try \
-    { \
-        expression; \
-        BOOST_ERROR("expected exception not thrown");\
-        throw 10; \
-    } \
-    catch(exception &) \
-    { \
-    }
-
-
-
-#endif

test/options_description_test.cpp

@@ -10,234 +10,89 @@ using namespace boost::program_options;
 #include <boost/function.hpp>
 using namespace boost;
 
+#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
+#include <boost/test/test_tools.hpp>
+
 #include <utility>
-#include <string>
-#include <sstream>
 using namespace std;
 
-#include "minitest.hpp"
+/*  This is very wierd test case -- it tests trivial things. After writing it,
+    I think that XP folks must be somehow wrong.
+*/
+void test_option_description_construction()
+{
+    option_description d1("a", new untyped_value(), "desc1");
+    BOOST_TEST(d1.long_name() == "a");
+    BOOST_TEST(d1.description() == "desc1");
+    BOOST_TEST(d1.semantic()->name() == "arg");
 
-void test_type()
+    // It is not possible to compare boost::function
+    #if 0
+    function<string, string> f1;
+    BOOST_TEST(&option_description("x", "y", "z").
+               validator(f1).validator() ==
+               &f1);
+    function<void, string> f2;
+    BOOST_TEST(&option_description("x", "y", "z").
+               notify(f2).notify() ==
+               &f2);
+    #endif
+
+    option_description d4("foo,f", new untyped_value(), "desc1");
+    BOOST_CHECK(d4.long_name() == "foo");
+    BOOST_CHECK(d4.short_name() == "f");
+}
+
+void test_options_description()
 {
     options_description desc;
-    desc.add_options()
-        ("foo", value<int>(), "")
-        ("bar", value<string>(), "")
-        ;
-    
-    const typed_value_base* b = dynamic_cast<const typed_value_base*>
-        (desc.find("foo", false).semantic().get());
-    BOOST_CHECK(b);
-    BOOST_CHECK(b->value_type() == typeid(int));
 
-    const typed_value_base* b2 = dynamic_cast<const typed_value_base*>
-        (desc.find("bar", false).semantic().get());
-    BOOST_CHECK(b2);
-    BOOST_CHECK(b2->value_type() == typeid(string));
+    shared_ptr<option_description> d1(
+        new option_description("first,f", new untyped_value(), ""));
+    desc.add(d1);
+    BOOST_TEST(desc.count("first") == 1);
+    BOOST_TEST(desc.count("-f") == 1);
+    BOOST_TEST(desc.keys().size() == 2);
+    BOOST_TEST(desc.keys().count("first") == 1);
+    BOOST_TEST(desc.keys().count("-f") == 1);
+
+    desc.add_options()
+        ("second,s", new untyped_value())
+        ("third,t", new untyped_value())
+        ;
+    BOOST_TEST(desc.count("second") == 1);
+    BOOST_TEST(desc.count("-s") == 1);
+
+    desc.add_options()
+        (",x", new untyped_value)
+        ;
+    BOOST_TEST(desc.primary_keys().size() == 4);
+    BOOST_TEST(desc.primary_keys().count("first") == 1);
+    BOOST_TEST(desc.primary_keys().count("second") == 1);
+    BOOST_TEST(desc.primary_keys().count("third") == 1);
+    BOOST_TEST(desc.primary_keys().count("-x") == 1);
 }
 
 void test_approximation()
 {
     options_description desc;
     desc.add_options()
-        ("foo", new untyped_value())
-        ("fee", new untyped_value())
-        ("baz", new untyped_value())
-        ("all-chroots", new untyped_value())
-        ("all-sessions", new untyped_value())
-        ("all", new untyped_value())
-        ;
+    ("foo", new untyped_value())
+    ("fee", new untyped_value())
+    ("baz", new untyped_value());
 
-    BOOST_CHECK_EQUAL(desc.find("fo", true).long_name(), "foo");
-
-    BOOST_CHECK_EQUAL(desc.find("all", true).long_name(), "all");
-    BOOST_CHECK_EQUAL(desc.find("all-ch", true).long_name(), "all-chroots");
-
-    options_description desc2;
-    desc2.add_options()
-        ("help", "display this message")
-        ("config", value<string>(), "config file name")
-        ("config-value", value<string>(), "single config value")
-        ;
-
-    BOOST_CHECK_EQUAL(desc2.find("config", true).long_name(), "config");
-    BOOST_CHECK_EQUAL(desc2.find("config-value", true).long_name(), 
-                      "config-value");
-
-
-//    BOOST_CHECK(desc.count_approx("foo") == 1);
-//    set<string> a = desc.approximations("f");
-//    BOOST_CHECK(a.size() == 2);
-//    BOOST_CHECK(*a.begin() == "fee");
-//    BOOST_CHECK(*(++a.begin()) == "foo");
+    BOOST_TEST(desc.count_approx("f") == 2);
+    BOOST_TEST(desc.count_approx("foo") == 1);
+    set<string> a = desc.approximations("f");
+    BOOST_TEST(a.size() == 2);
+    BOOST_TEST(*a.begin() == "fee");
+    BOOST_TEST(*(++a.begin()) == "foo");
 }
 
-void test_formatting()
+int test_main(int, char* [])
 {
-    // Long option descriptions used to crash on MSVC-8.0.
-    options_description desc;
-    desc.add_options()(
-        "test", new untyped_value(),
-        "foo foo foo foo foo foo foo foo foo foo foo foo foo foo"
-        "foo foo foo foo foo foo foo foo foo foo foo foo foo foo"
-        "foo foo foo foo foo foo foo foo foo foo foo foo foo foo"
-        "foo foo foo foo foo foo foo foo foo foo foo foo foo foo")
-      ("list", new untyped_value(),
-         "a list:\n      \t"
-             "item1, item2, item3, item4, item5, item6, item7, item8, item9, "
-             "item10, item11, item12, item13, item14, item15, item16, item17, item18")
-      ("well_formated", new untyped_value(), 
-                        "As you can see this is a very well formatted option description.\n"
-                        "You can do this for example:\n\n"
-                        "Values:\n"
-                        "  Value1: \tdoes this and that, bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla\n"
-                        "  Value2: \tdoes something else, bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla\n\n"
-                        "    This paragraph has a first line indent only, bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla")
-      ;
-
-    stringstream ss;
-    ss << desc;
-    BOOST_CHECK_EQUAL(ss.str(),
-"  --test arg            foo foo foo foo foo foo foo foo foo foo foo foo foo \n"
-"                        foofoo foo foo foo foo foo foo foo foo foo foo foo foo \n"
-"                        foofoo foo foo foo foo foo foo foo foo foo foo foo foo \n"
-"                        foofoo foo foo foo foo foo foo foo foo foo foo foo foo \n"
-"                        foo\n"
-"  --list arg            a list:\n"
-"                              item1, item2, item3, item4, item5, item6, item7, \n"
-"                              item8, item9, item10, item11, item12, item13, \n"
-"                              item14, item15, item16, item17, item18\n"
-"  --well_formated arg   As you can see this is a very well formatted option \n"
-"                        description.\n"
-"                        You can do this for example:\n"
-"                        \n"
-"                        Values:\n"
-"                          Value1: does this and that, bla bla bla bla bla bla \n"
-"                                  bla bla bla bla bla bla bla bla bla\n"
-"                          Value2: does something else, bla bla bla bla bla bla \n"
-"                                  bla bla bla bla bla bla bla bla bla\n"
-"                        \n"
-"                            This paragraph has a first line indent only, bla \n"
-"                        bla bla bla bla bla bla bla bla bla bla bla bla bla bla\n"
-   );
-}
-
-void test_formatting_description_length()
-{
-    {
-        options_description desc("",
-                                 options_description::m_default_line_length,
-                                 options_description::m_default_line_length / 2U);
-        desc.add_options()
-            ("an-option-that-sets-the-max", new untyped_value(), // > 40 available for desc
-            "this description sits on the same line, but wrapping should still work correctly")
-            ("a-long-option-that-would-leave-very-little-space-for-description", new untyped_value(),
-            "the description of the long opt, but placed on the next line\n"
-            "    \talso ensure that the tabulation works correctly when a"
-            " description size has been set");
-
-        stringstream ss;
-        ss << desc;
-        BOOST_CHECK_EQUAL(ss.str(),
-        "  --an-option-that-sets-the-max arg     this description sits on the same line,\n"
-        "                                        but wrapping should still work \n"
-        "                                        correctly\n"
-        "  --a-long-option-that-would-leave-very-little-space-for-description arg\n"
-        "                                        the description of the long opt, but \n"
-        "                                        placed on the next line\n"
-        "                                            also ensure that the tabulation \n"
-        "                                            works correctly when a description \n"
-        "                                            size has been set\n");
-    }
-    {
-        // the default behaviour reserves 23 (+1 space) characters for the
-        // option column; this shows that the min_description_length does not
-        // breach that.
-        options_description desc("",
-                                 options_description::m_default_line_length,
-                                 options_description::m_default_line_length - 10U); // leaves < 23 (default option space)
-        desc.add_options()
-            ("an-option-that-encroaches-description", new untyped_value(),
-            "this description should always be placed on the next line, and wrapping should continue as normal");
-
-        stringstream ss;
-        ss << desc;
-        BOOST_CHECK_EQUAL(ss.str(),
-        "  --an-option-that-encroaches-description arg\n"
-       //123456789_123456789_
-        "          this description should always be placed on the next line, and \n"
-        "          wrapping should continue as normal\n");
-    }
-}
-
-void test_long_default_value()
-{
-    options_description desc;
-    desc.add_options()
-        ("cfgfile,c",
-         value<string>()->default_value("/usr/local/etc/myprogramXXXXXXXXX/configuration.conf"),
-         "the configfile")
-       ;
-
-    stringstream ss;
-    ss << desc;
-    BOOST_CHECK_EQUAL(ss.str(),
-"  -c [ --cfgfile ] arg (=/usr/local/etc/myprogramXXXXXXXXX/configuration.conf)\n"
-"                                        the configfile\n"
-   );
-}
-
-void test_word_wrapping()
-{
-   options_description desc("Supported options");
-   desc.add_options()
-      ("help",    "this is a sufficiently long text to require word-wrapping")
-      ("prefix", value<string>()->default_value("/h/proj/tmp/dispatch"), "root path of the dispatch installation")
-      ("opt1",    "this_is_a_sufficiently_long_text_to_require_word-wrapping_but_cannot_be_wrapped")
-      ("opt2",    "this_is_a_sufficiently long_text_to_require_word-wrapping")
-      ("opt3",    "this_is_a sufficiently_long_text_to_require_word-wrapping_but_will_not_be_wrapped")
-      ;
-    stringstream ss;
-    ss << desc;    
-    BOOST_CHECK_EQUAL(ss.str(),
-"Supported options:\n"
-"  --help                               this is a sufficiently long text to \n"
-"                                       require word-wrapping\n"
-"  --prefix arg (=/h/proj/tmp/dispatch) root path of the dispatch installation\n"
-"  --opt1                               this_is_a_sufficiently_long_text_to_requ\n"
-"                                       ire_word-wrapping_but_cannot_be_wrapped\n"
-"  --opt2                               this_is_a_sufficiently \n"
-"                                       long_text_to_require_word-wrapping\n"
-"  --opt3                               this_is_a sufficiently_long_text_to_requ\n"
-"                                       ire_word-wrapping_but_will_not_be_wrappe\n"
-"                                       d\n"
-   );
-}
-
-void test_default_values()
-{
-   options_description desc("Supported options");
-   desc.add_options()
-      ("maxlength", value<double>()->default_value(.1, "0.1"), "Maximum edge length to keep.")
-      ;
-   stringstream ss;
-   ss << desc;    
-   BOOST_CHECK_EQUAL(ss.str(),
-"Supported options:\n"
-"  --maxlength arg (=0.1) Maximum edge length to keep.\n"
-   );   
-}
-
-
-int main(int, char* [])
-{
-    test_type();
+    test_option_description_construction();
+    test_options_description();
     test_approximation();
-    test_formatting();
-    test_formatting_description_length();
-    test_long_default_value();
-    test_word_wrapping();
-    test_default_values();
     return 0;
 }
-

test/parsers_test.cpp

@@ -6,7 +6,6 @@
 
 #include <boost/program_options/parsers.hpp>
 #include <boost/program_options/options_description.hpp>
-#include <boost/program_options/variables_map.hpp>
 using namespace boost::program_options;
 // We'll use po::value everywhere to workaround vc6 bug.
 namespace po = boost::program_options;
@@ -14,17 +13,13 @@ namespace po = boost::program_options;
 #include <boost/function.hpp>
 using namespace boost;
 
+#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
+#include <boost/test/test_tools.hpp>
+
 #include <sstream>
-#include <iostream>
 using namespace std;
 
-#if defined(__sun)
-#include <stdlib.h> // for putenv on solaris
-#else
 #include <cstdlib> // for putenv
-#endif
-
-#include "minitest.hpp"
 
 #define TEST_CHECK_THROW(expression, exception, description) \
     try \
@@ -57,7 +52,7 @@ void check_value(const option& option, const char* name, const char* value)
     BOOST_CHECK(option.value.front() == value);
 }
 
-vector<string> sv(const char* array[], unsigned size)
+vector<string> sv(char* array[], unsigned size)
 {
     vector<string> r;
     for (unsigned i = 0; i < size; ++i)
@@ -65,11 +60,6 @@ vector<string> sv(const char* array[], unsigned size)
     return r;
 }
 
-pair<string, string> additional_parser(const std::string&)
-{
-    return pair<string, string>();
-}
-
 void test_command_line()
 {
     // The following commented out blocks used to test parsing
@@ -84,14 +74,14 @@ void test_command_line()
         parse_command_line(cmdline1,
                            cmdline1 + sizeof(cmdline1)/sizeof(cmdline1[0]));
 
-    BOOST_REQUIRE(a1.options().size() == 4);
-    BOOST_CHECK(a1.options()[0] == msp("a", ""));
-    BOOST_CHECK(a1.options()[1] == msp("b", "12"));
-    BOOST_CHECK(a1.options()[2] == msp("-f", ""));
-    BOOST_CHECK(a1.options()[3] == msp("-g", "4"));
-    BOOST_REQUIRE(a1.arguments().size() == 2);
-    BOOST_CHECK(a1.arguments()[0] == "-");
-    BOOST_CHECK(a1.arguments()[1] == "file");
+    BOOST_CRITICAL_TEST(a1.options().size() == 4);
+    BOOST_TEST(a1.options()[0] == msp("a", ""));
+    BOOST_TEST(a1.options()[1] == msp("b", "12"));
+    BOOST_TEST(a1.options()[2] == msp("-f", ""));
+    BOOST_TEST(a1.options()[3] == msp("-g", "4"));
+    BOOST_CRITICAL_TEST(a1.arguments().size() == 2);
+    BOOST_TEST(a1.arguments()[0] == "-");
+    BOOST_TEST(a1.arguments()[1] == "file");
 
     char* cmdline2[] = { "--a", "--", "file" };
 
@@ -99,110 +89,50 @@ void test_command_line()
         parse_command_line(cmdline2,
                            cmdline2 + sizeof(cmdline2)/sizeof(cmdline2[0]));
 
-    BOOST_REQUIRE(a2.options().size() == 1);
-    BOOST_CHECK(a2.options()[0] == msp("a", ""));
-    BOOST_CHECK(a2.arguments().size() == 1);
-    BOOST_CHECK(a2.arguments()[0] == "file");
+    BOOST_CRITICAL_TEST(a2.options().size() == 1);
+    BOOST_TEST(a2.options()[0] == msp("a", ""));
+    BOOST_TEST(a2.arguments().size() == 1);
+    BOOST_TEST(a2.arguments()[0] == "file");
     #endif
     
     options_description desc;
     desc.add_options()
         ("foo,f", new untyped_value(), "")
         // Explicit qualification is a workaround for vc6
-        ("bar,b", po::value<std::string>(), "")
+        ("bar,b", po::value<std::string>()->implicit(), "")
         ("baz", new untyped_value())
         ("plug*", new untyped_value())
         ;
-    const char* cmdline3_[] = { "--foo=12", "-f4", "--bar=11", "-b4",
-                          "--plug3=10"};
+    char* cmdline3_[] = { "--foo=12", "-f4", "--bar=11", "--bar", "-b4", "-b",
+                         "--plug3=10"};
     vector<string> cmdline3 = sv(cmdline3_,
-                                 sizeof(cmdline3_)/sizeof(const char*));
+                                 sizeof(cmdline3_)/sizeof(cmdline3_[0]));
     vector<option> a3 = 
         command_line_parser(cmdline3).options(desc).run().options;
                        
-    BOOST_CHECK_EQUAL(a3.size(), 5u);
+    BOOST_CRITICAL_TEST(a3.size() == 7);
 
     check_value(a3[0], "foo", "12");
     check_value(a3[1], "foo", "4");
     check_value(a3[2], "bar", "11");
-    check_value(a3[3], "bar", "4");
-    check_value(a3[4], "plug3", "10");
 
-    // Regression test: check that '0' as style is interpreted as 
-    // 'default_style'
-    vector<option> a4 = 
-        parse_command_line(sizeof(cmdline3_)/sizeof(const char*), cmdline3_, 
-                                                               desc, 0, additional_parser).options;
+    BOOST_TEST(a3[3].string_key == "bar");
+    BOOST_CRITICAL_TEST(a3[3].value.size() == 0);
 
-    BOOST_CHECK_EQUAL(a4.size(), 4u);
-    check_value(a4[0], "foo", "4");
-    check_value(a4[1], "bar", "11");
+    check_value(a3[4], "bar", "4");
 
-    // Check that we don't crash on empty values of type 'string'
-    const char* cmdline4[] = {"", "--open", ""};
-    options_description desc2;
-    desc2.add_options()
-        ("open", po::value<string>())
-        ;
-    variables_map vm;
-    po::store(po::parse_command_line(sizeof(cmdline4)/sizeof(const char*), const_cast<char**>(cmdline4), desc2), vm);
+    BOOST_TEST(a3[5].string_key == "bar");
+    BOOST_CRITICAL_TEST(a3[5].value.size() == 0);
 
-    const char* cmdline5[] = {"", "-p7", "-o", "1", "2", "3", "-x8"};
-    options_description desc3;
-    desc3.add_options()
-        (",p", po::value<string>())
-        (",o", po::value<string>()->multitoken())
-        (",x", po::value<string>())
-        ;
-    vector<option> a5 = 
-        parse_command_line(sizeof(cmdline5)/sizeof(const char*), const_cast<char**>(cmdline5), 
-                                                                     desc3, 0, additional_parser).options;
-    BOOST_CHECK_EQUAL(a5.size(), 3u);
-    check_value(a5[0], "-p", "7");
-    BOOST_REQUIRE(a5[1].value.size() == 3);
-    BOOST_CHECK_EQUAL(a5[1].string_key, "-o");
-    BOOST_CHECK_EQUAL(a5[1].value[0], "1");
-    BOOST_CHECK_EQUAL(a5[1].value[1], "2");
-    BOOST_CHECK_EQUAL(a5[1].value[2], "3");
-    check_value(a5[2], "-x", "8");   
-
-
-    po::options_description desc4( "" );
-    desc4.add_options()
-        ( "multitoken,m",
-          po::value< std::vector< std::string > >()->multitoken(),
-          "values"
-            )
-        ( "file",
-          po::value< std::string >(),
-          "the file to process"
-            )
-        ;
-
-    po::positional_options_description p;
-    p.add( "file", 1 );
-
-    const char* cmdline6[] = {"", "-m", "token1", "token2", "--", "some_file"};
-    vector<option> a6 = 
-        command_line_parser(sizeof(cmdline6)/sizeof(const char*), const_cast<char**>(cmdline6)).options(desc4).positional(p)
-        .run().options;
-    BOOST_CHECK_EQUAL(a6.size(), 2u);
-    BOOST_REQUIRE(a6[0].value.size() == 2);
-    BOOST_CHECK_EQUAL(a6[0].string_key, "multitoken");
-    BOOST_CHECK_EQUAL(a6[0].value[0], "token1");
-    BOOST_CHECK_EQUAL(a6[0].value[1], "token2");
-    BOOST_CHECK_EQUAL(a6[1].string_key, "file");
-    BOOST_REQUIRE(a6[1].value.size() == 1);
-    BOOST_CHECK_EQUAL(a6[1].value[0], "some_file");
+    check_value(a3[6], "plug3", "10");
 }
 
-void test_config_file(const char* config_file)
+void test_config_file()
 {
     options_description desc;
     desc.add_options()
         ("gv1", new untyped_value)
         ("gv2", new untyped_value)
-        ("empty_value", new untyped_value)
         ("plug*", new untyped_value)
         ("m1.v1", new untyped_value)
         ("m1.v2", new untyped_value)
@@ -211,7 +141,6 @@ void test_config_file(const char* config_file)
 
     const char content1[] =
     " gv1 = 0#asd\n"
-    "empty_value = \n"
     "plug3 = 7\n"
     "b = true\n"
     "[m1]\n"
@@ -222,23 +151,13 @@ void test_config_file(const char* config_file)
 
     stringstream ss(content1);
     vector<option> a1 = parse_config_file(ss, desc).options;
-    BOOST_REQUIRE(a1.size() == 6);
+    BOOST_CRITICAL_TEST(a1.size() == 5);
     check_value(a1[0], "gv1", "0");
-    check_value(a1[1], "empty_value", "");
-    check_value(a1[2], "plug3", "7");
-    check_value(a1[3], "b", "true");
-    check_value(a1[4], "m1.v1", "1");
-    check_value(a1[5], "m1.v2", "2");
-    
-    // same test, but now options come from file 
-    vector<option> a2 = parse_config_file<char>(config_file, desc).options;
-    BOOST_REQUIRE(a2.size() == 6);
-    check_value(a2[0], "gv1", "0");
-    check_value(a2[1], "empty_value", "");
-    check_value(a2[2], "plug3", "7");
-    check_value(a2[3], "b", "true");
-    check_value(a2[4], "m1.v1", "1");
-    check_value(a2[5], "m1.v2", "2");
+    check_value(a1[1], "plug3", "7");
+    check_value(a1[2], "b", "true");
+    check_value(a1[3], "m1.v1", "1");
+    check_value(a1[4], "m1.v2", "2");
+
 }
 
 void test_environment()
@@ -252,7 +171,7 @@ void test_environment()
 #if defined(_WIN32) && ! defined(__BORLANDC__)
     _putenv("PO_TEST_FOO=1");
 #else
-    putenv(const_cast<char*>("PO_TEST_FOO=1"));
+    putenv("PO_TEST_FOO=1");
 #endif
     parsed_options p = parse_environment(desc, "PO_TEST_");
 
@@ -265,63 +184,11 @@ void test_environment()
     // which already has a value.
 }
 
-void test_unregistered()
-{
-    options_description desc;
-
-    const char* cmdline1_[] = { "--foo=12", "--bar", "1"};
-    vector<string> cmdline1 = sv(cmdline1_,
-                                 sizeof(cmdline1_)/sizeof(const char*));
-    vector<option> a1 = 
-        command_line_parser(cmdline1).options(desc).allow_unregistered().run()
-        .options;
-
-    BOOST_REQUIRE(a1.size() == 3);
-    BOOST_CHECK(a1[0].string_key == "foo");
-    BOOST_CHECK(a1[0].unregistered == true);
-    BOOST_REQUIRE(a1[0].value.size() == 1);
-    BOOST_CHECK(a1[0].value[0] == "12");
-    BOOST_CHECK(a1[1].string_key == "bar");
-    BOOST_CHECK(a1[1].unregistered == true);
-    BOOST_CHECK(a1[2].string_key == "");
-    BOOST_CHECK(a1[2].unregistered == false);
-    
-
-    vector<string> a2 = collect_unrecognized(a1, include_positional);
-    BOOST_CHECK(a2[0] == "--foo=12");
-    BOOST_CHECK(a2[1] == "--bar");
-    BOOST_CHECK(a2[2] == "1");
-
-    // Test that storing unregisted options has no effect
-    variables_map vm;
-    
-    store(command_line_parser(cmdline1).options(desc).
-          allow_unregistered().run(),
-          vm);
-
-    BOOST_CHECK_EQUAL(vm.size(), 0u);   
-
-
-    const char content1[] =
-    "gv1 = 0\n"
-    "[m1]\n"
-    "v1 = 1\n"
-    ;
-
-    stringstream ss(content1);
-    vector<option> a3 = parse_config_file(ss, desc, true).options;
-    BOOST_REQUIRE(a3.size() == 2);
-    cout << "XXX" << a3[0].value.front() << "\n";
-    check_value(a3[0], "gv1", "0");
-    check_value(a3[1], "m1.v1", "1");
-}
-
-int main(int, char* av[])
+int test_main(int, char* [])
 {
     test_command_line();
-    test_config_file(av[1]);
+    test_config_file();
     test_environment();
-    test_unregistered();
     return 0;
 }
 

test/positional_options_test.cpp

@@ -12,8 +12,7 @@ namespace po = boost::program_options;
 
 
 #include <boost/limits.hpp>
-
-#include "minitest.hpp"
+#include <boost/test/test_tools.hpp>
 
 #include <vector>
 using namespace std;
@@ -35,7 +34,7 @@ void test_positional_options()
 
     p.add("third", -1);
 
-    BOOST_CHECK_EQUAL(p.max_total_count(), (std::numeric_limits<unsigned>::max)());
+    BOOST_CHECK_EQUAL(p.max_total_count(), std::numeric_limits<unsigned>::max());
     BOOST_CHECK_EQUAL(p.name_for_position(0), "first");
     BOOST_CHECK_EQUAL(p.name_for_position(1), "second");
     BOOST_CHECK_EQUAL(p.name_for_position(2), "second");
@@ -50,31 +49,28 @@ void test_parsing()
         ("first", po::value<int>())
         ("second", po::value<int>())
         ("input-file", po::value< vector<string> >())
-        ("some-other", po::value<string>())
     ;
 
     positional_options_description p;
-    p.add("input-file", 2).add("some-other", 1);
+    p.add("input-file", 2);
 
     vector<string> args;
     args.push_back("--first=10");
     args.push_back("file1");
     args.push_back("--second=10");
     args.push_back("file2");
-    args.push_back("file3");
 
     // Check that positional options are handled.
     parsed_options parsed = 
         command_line_parser(args).options(desc).positional(p).run();
 
-    BOOST_REQUIRE(parsed.options.size() == 5);
+    BOOST_REQUIRE(parsed.options.size() == 4);
     BOOST_CHECK_EQUAL(parsed.options[1].string_key, "input-file");
     BOOST_CHECK_EQUAL(parsed.options[1].value[0], "file1");
     BOOST_CHECK_EQUAL(parsed.options[3].string_key, "input-file");
     BOOST_CHECK_EQUAL(parsed.options[3].value[0], "file2");
-    BOOST_CHECK_EQUAL(parsed.options[4].value[0], "file3");
 
-    args.push_back("file4");
+    args.push_back("file3");
 
     // Check that excessive number of positional options is detected.
     BOOST_CHECK_THROW(command_line_parser(args).options(desc).positional(p)
@@ -82,7 +78,7 @@ void test_parsing()
                       too_many_positional_options_error);
 }
 
-int main(int, char* [])
+int test_main(int, char* [])
 {
     test_positional_options();
     test_parsing();

test/required_test.cfg

@@ -1 +0,0 @@
-cfgfile = file.cfg

test/required_test.cpp

@@ -1,97 +0,0 @@
-// Copyright Sascha Ochsenknecht 2009.
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt
-// or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/program_options.hpp>
-using namespace boost::program_options;
-
-#include <string>
-#include <iostream>
-#include <fstream>
-using namespace std;
-
-#include "minitest.hpp"
-
-
-void required_throw_test()
-{
-   options_description          opts;
-   opts.add_options()
-     ("cfgfile,c", value<string>()->required(), "the configfile")
-     ("fritz,f",   value<string>()->required(), "the output file")
-   ;
-
-   variables_map vm;
-   bool throwed = false;
-   {
-      // This test must throw exception
-      string cmdline = "prg -f file.txt";
-      vector< string > tokens =  split_unix(cmdline);
-      throwed = false;
-      try {
-         store(command_line_parser(tokens).options(opts).run(), vm);
-         notify(vm);    
-      } 
-      catch (required_option& e) {
-         throwed = true;
-      }      
-      BOOST_CHECK(throwed);
-   }
-   
-   {
-      // This test mustn't throw exception
-      string cmdline = "prg -c config.txt";
-      vector< string > tokens =  split_unix(cmdline);
-      throwed = false;
-      try {
-         store(command_line_parser(tokens).options(opts).run(), vm);
-         notify(vm);    
-      } 
-      catch (required_option& e) {
-         throwed = true;
-      }
-      BOOST_CHECK(!throwed);
-   }
-}
-
-
-
-void simple_required_test(const char* config_file)
-{
-   options_description          opts;
-   opts.add_options()
-     ("cfgfile,c", value<string>()->required(), "the configfile")
-     ("fritz,f",   value<string>()->required(), "the output file")
-   ;
-
-   variables_map vm;
-   bool throwed = false;
-   {
-      // This test must throw exception
-      string cmdline = "prg -f file.txt";
-      vector< string > tokens =  split_unix(cmdline);
-      throwed = false;
-      try {
-         // options coming from different sources
-         store(command_line_parser(tokens).options(opts).run(), vm);
-         store(parse_config_file<char>(config_file, opts), vm);
-         notify(vm);    
-      } 
-      catch (required_option& e) {
-         throwed = true;
-      }      
-      BOOST_CHECK(!throwed);
-   }
-}
-
-
-
-int main(int /*argc*/, char* av[])
-{  
-   required_throw_test();
-   simple_required_test(av[1]);
-   
-   return 0;
-}
-

test/split_test.cpp

@@ -1,189 +0,0 @@
-// Copyright Sascha Ochsenknecht 2009.
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt
-// or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-
-#include <boost/program_options/parsers.hpp>
-#include <boost/program_options/options_description.hpp>
-#include <boost/program_options/variables_map.hpp>
-#include <boost/program_options/cmdline.hpp>
-using namespace boost::program_options;
-
-#include <iostream>
-#include <sstream>
-#include <vector>
-#include <cassert>
-using namespace std;
-
-#include "minitest.hpp"
-
-void check_value(const string& option, const string& value)
-{
-    BOOST_CHECK(option == value);
-}
-
-void split_whitespace(const options_description& description)
-{
-
-   const char* cmdline = "prg --input input.txt \r --optimization 4  \t  --opt \n  option";
-   
-   vector< string > tokens =  split_unix(cmdline, " \t\n\r");
-   
-   BOOST_REQUIRE(tokens.size() == 7);
-   
-   check_value(tokens[0], "prg");
-   check_value(tokens[1], "--input");
-   check_value(tokens[2], "input.txt");
-   check_value(tokens[3], "--optimization");
-   check_value(tokens[4], "4");
-   check_value(tokens[5], "--opt");
-   check_value(tokens[6], "option");
-
-   variables_map vm;  
-   store(command_line_parser(tokens).options(description).run(), vm);
-   notify(vm);
-}
-
-void split_equalsign(const options_description& description)
-{
-
-   const char* cmdline = "prg --input=input.txt  --optimization=4 --opt=option";
-   
-   vector< string > tokens =  split_unix(cmdline, "= ");
- 
-   BOOST_REQUIRE(tokens.size() == 7);
-   check_value(tokens[0], "prg");
-   check_value(tokens[1], "--input");
-   check_value(tokens[2], "input.txt");
-   check_value(tokens[3], "--optimization");
-   check_value(tokens[4], "4");
-   check_value(tokens[5], "--opt");
-   check_value(tokens[6], "option");
-
-   variables_map vm;  
-   store(command_line_parser(tokens).options(description).run(), vm);
-   notify(vm);
-}
-
-void split_semi(const options_description& description)
-{
-
-   const char* cmdline = "prg;--input input.txt;--optimization 4;--opt option";
-   
-   vector< string > tokens =  split_unix(cmdline, "; ");
-   
-   BOOST_REQUIRE(tokens.size() == 7);
-   check_value(tokens[0], "prg");
-   check_value(tokens[1], "--input");
-   check_value(tokens[2], "input.txt");
-   check_value(tokens[3], "--optimization");
-   check_value(tokens[4], "4");
-   check_value(tokens[5], "--opt");
-   check_value(tokens[6], "option");
-
-   variables_map vm;  
-   store(command_line_parser(tokens).options(description).run(), vm);
-   notify(vm);
-}
-
-void split_quotes(const options_description& description)
-{
-   const char* cmdline = "prg --input \"input.txt input.txt\" --optimization 4 --opt \"option1 option2\"";
-   
-   vector< string > tokens =  split_unix(cmdline, " ");
- 
-   BOOST_REQUIRE(tokens.size() == 7);
-   check_value(tokens[0], "prg");
-   check_value(tokens[1], "--input");
-   check_value(tokens[2], "input.txt input.txt");
-   check_value(tokens[3], "--optimization");
-   check_value(tokens[4], "4");
-   check_value(tokens[5], "--opt");
-   check_value(tokens[6], "option1 option2");
-
-   variables_map vm;  
-   store(command_line_parser(tokens).options(description).run(), vm);
-   notify(vm);
-}
-
-void split_escape(const options_description& description)
-{
-   const char* cmdline = "prg --input \\\"input.txt\\\" --optimization 4 --opt \\\"option1\\ option2\\\"";
-   
-   vector< string > tokens =  split_unix(cmdline, " ");
-  
-   BOOST_REQUIRE(tokens.size() == 7);
-   check_value(tokens[0], "prg");
-   check_value(tokens[1], "--input");
-   check_value(tokens[2], "\"input.txt\"");
-   check_value(tokens[3], "--optimization");
-   check_value(tokens[4], "4");
-   check_value(tokens[5], "--opt");
-   check_value(tokens[6], "\"option1 option2\"");
-
-   variables_map vm;  
-   store(command_line_parser(tokens).options(description).run(), vm);
-   notify(vm);
-}
-
-
-void split_single_quote(const options_description& description)
-{
-   const char* cmdline = "prg --input 'input.txt input.txt' --optimization 4 --opt 'option1 option2'";
-   
-   vector< string > tokens =  split_unix(cmdline, " ", "'");
- 
-   BOOST_REQUIRE(tokens.size() == 7);
-   check_value(tokens[0], "prg");
-   check_value(tokens[1], "--input");
-   check_value(tokens[2], "input.txt input.txt");
-   check_value(tokens[3], "--optimization");
-   check_value(tokens[4], "4");
-   check_value(tokens[5], "--opt");
-   check_value(tokens[6], "option1 option2");
-
-   variables_map vm;  
-   store(command_line_parser(tokens).options(description).run(), vm);
-   notify(vm);
-}
-
-void split_defaults(const options_description& description)
-{
-   const char* cmdline = "prg --input \t \'input file.txt\' \t   --optimization 4 --opt \\\"option1\\ option2\\\"";
-   
-   vector< string > tokens =  split_unix(cmdline);
-  
-   BOOST_REQUIRE(tokens.size() == 7);
-   check_value(tokens[0], "prg");
-   check_value(tokens[1], "--input");
-   check_value(tokens[2], "input file.txt");
-   check_value(tokens[3], "--optimization");
-   check_value(tokens[4], "4");
-   check_value(tokens[5], "--opt");
-   check_value(tokens[6], "\"option1 option2\"");
-
-   variables_map vm;  
-   store(command_line_parser(tokens).options(description).run(), vm);
-   notify(vm);
-}
-
-int main(int /*ac*/, char** /*av*/)
-{
-   options_description desc;
-   desc.add_options()
-        ("input,i", value<string>(), "the input file")
-        ("optimization,O", value<unsigned>(), "optimization level")
-        ("opt,o", value<string>(), "misc option")
-      ;
-
-   split_whitespace(desc);
-   split_equalsign(desc);
-   split_semi(desc);
-   split_quotes(desc);
-   split_escape(desc);
-   split_single_quote(desc);
-   split_defaults(desc);
-   
-   return 0;
-}

test/test_convert.cpp

@@ -3,12 +3,11 @@
 // (See accompanying file LICENSE_1_0.txt
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include <cstring>
-#include <cassert>
 #include <string>
 #include <fstream>
 #include <sstream>
 #include <iostream>
+#include <cassert>
 #include <boost/progress.hpp>
 #include <boost/bind.hpp>
 #include <boost/ref.hpp>
@@ -16,8 +15,6 @@
 #include <boost/program_options/detail/convert.hpp>
 #include <boost/program_options/detail/utf8_codecvt_facet.hpp>
 
-#include "minitest.hpp"
-
 using namespace std;
 
 string file_content(const string& filename)
@@ -39,8 +36,8 @@ std::wstring from_8_bit_2(const std::string& s,
     std::wstring result;
 
 
-    std::mbstate_t state = std::mbstate_t();
-    
+    std::mbstate_t state = {0};
+
     const char* from = s.data();
     const char* from_end = s.data() + s.size();
     // The interace of cvt is not really iterator-like, and it's
@@ -78,7 +75,7 @@ std::wstring from_8_bit_2(const std::string& s,
 void test_convert(const std::string& input, 
                   const std::string& expected_output)
 {
-    boost::program_options::detail::utf8_codecvt_facet facet;
+    boost::program_options::detail::utf8_codecvt_facet<wchar_t, char> facet;
     
     std::wstring output;
     { 
@@ -97,7 +94,7 @@ void test_convert(const std::string& input,
                 facet);
     }
 
-    BOOST_CHECK(output.size()*2 == expected_output.size());
+    assert(output.size()*2 == expected_output.size());
 
     for(unsigned i = 0; i < output.size(); ++i) {
 
@@ -106,23 +103,23 @@ void test_convert(const std::string& input,
             low &= 0xFF;
             unsigned low2 = expected_output[2*i];
             low2 &= 0xFF;
-            BOOST_CHECK(low == low2);
+            assert(low == low2);
         }
         {        
             unsigned high = output[i];
             high >>= 8;
             high &= 0xFF;
             unsigned high2 = expected_output[2*i+1];            
-            BOOST_CHECK(high == high2);
+            assert(high == high2);
         }
     }
 
     string ref = boost::to_8_bit(output, facet);
 
-    BOOST_CHECK(ref == input);
+    assert(ref == input);
 }
 
-int main(int ac, char* av[])
+int test_main(int ac, char* av[])
 {       
     std::string input = file_content("utf8.txt");
     std::string expected = file_content("ucs2.txt");

test/unicode_test.cpp

@@ -15,11 +15,12 @@ namespace po = boost::program_options;
 #include <boost/function.hpp>
 using namespace boost;
 
+#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
+#include <boost/test/test_tools.hpp>
+
 #include <sstream>
 using namespace std;
 
-#include "minitest.hpp"
-
 // Test that unicode input is forwarded to unicode option without
 // problems.
 void test_unicode_to_unicode()
@@ -34,13 +35,9 @@ void test_unicode_to_unicode()
     args.push_back(L"--foo=\x044F");
 
     variables_map vm;
-    basic_parsed_options<wchar_t> parsed = 
-        wcommand_line_parser(args).options(desc).run();
-    store(parsed, vm);
+    store(wcommand_line_parser(args).options(desc).run(), vm);
 
-    BOOST_CHECK(vm["foo"].as<wstring>() == L"\x044F");
-    BOOST_CHECK(parsed.options[0].original_tokens.size() == 1);
-    BOOST_CHECK(parsed.options[0].original_tokens[0] == L"--foo=\x044F");
+    BOOST_CHECK(vm["foo"].as<wstring>() == L"\x044F");           
 }
 
 // Test that unicode input is property converted into
@@ -49,7 +46,7 @@ void test_unicode_to_unicode()
 void test_unicode_to_native()
 {
     std::codecvt<wchar_t, char, mbstate_t>* facet = 
-        new boost::program_options::detail::utf8_codecvt_facet;
+        new boost::program_options::detail::utf8_codecvt_facet<wchar_t, char>;
     locale::global(locale(locale(), facet));
 
     options_description desc;
@@ -64,13 +61,13 @@ void test_unicode_to_native()
     variables_map vm;
     store(wcommand_line_parser(args).options(desc).run(), vm);
 
-    BOOST_CHECK(vm["foo"].as<string>() == "\xD1\x8F");    
+    BOOST_TEST(vm["foo"].as<string>() == "\xD1\x8F");    
 }
 
 void test_native_to_unicode()
 {
     std::codecvt<wchar_t, char, mbstate_t>* facet = 
-        new boost::program_options::detail::utf8_codecvt_facet;
+        new boost::program_options::detail::utf8_codecvt_facet<wchar_t, char>;
     locale::global(locale(locale(), facet));
 
     options_description desc;
@@ -85,10 +82,11 @@ void test_native_to_unicode()
     variables_map vm;
     store(command_line_parser(args).options(desc).run(), vm);
 
-    BOOST_CHECK(vm["foo"].as<wstring>() == L"\x044F");    
+    BOOST_TEST(vm["foo"].as<wstring>() == L"\x044F");    
 }
 
-vector<wstring> sv(const wchar_t* array[], unsigned size)
+
+vector<wstring> sv(wchar_t* array[], unsigned size)
 {
     vector<wstring> r;
     for (unsigned i = 0; i < size; ++i)
@@ -109,19 +107,19 @@ void test_command_line()
     desc.add_options()
         ("foo,f", new untyped_value(), "")
         // Explicit qualification is a workaround for vc6
-        ("bar,b", po::value<std::string>(), "")
+        ("bar,b", po::value<std::string>()->implicit(), "")
         ("baz", new untyped_value())
         ("plug*", new untyped_value())
         ;
 
-    const wchar_t* cmdline4_[] = { L"--foo=1\u0FF52", L"-f4", L"--bar=11",
-                             L"-b4", L"--plug3=10"};
+    wchar_t* cmdline4_[] = { L"--foo=1\u0FF52", L"-f4", L"--bar=11", L"--bar", 
+                             L"-b4", L"-b", L"--plug3=10"};
     vector<wstring> cmdline4 = sv(cmdline4_,
                                   sizeof(cmdline4_)/sizeof(cmdline4_[0]));
     vector<woption> a4 = 
         wcommand_line_parser(cmdline4).options(desc).run().options;
 
-    BOOST_REQUIRE(a4.size() == 5);
+    BOOST_CRITICAL_TEST(a4.size() == 7);
 
     check_value(a4[0], "foo", L"1\u0FF52");
     check_value(a4[1], "foo", L"4");
@@ -134,7 +132,7 @@ void test_command_line()
 void test_config_file()
 {
     std::codecvt<wchar_t, char, mbstate_t>* facet = 
-        new boost::program_options::detail::utf8_codecvt_facet;
+        new boost::program_options::detail::utf8_codecvt_facet<wchar_t, char>;
     locale::global(locale(locale(), facet));
 
     options_description desc;
@@ -148,10 +146,10 @@ void test_config_file()
     variables_map vm;
     store(parse_config_file(stream, desc), vm);
 
-    BOOST_CHECK(vm["foo"].as<string>() == "\xD1\x8F");    
+    BOOST_TEST(vm["foo"].as<string>() == "\xD1\x8F");    
 }
 
-int main(int, char* [])
+int test_main(int, char* [])
 {
     test_unicode_to_unicode();
     test_unicode_to_native();

test/unrecognized_test.cpp

@@ -1,88 +0,0 @@
-// Copyright Sascha Ochsenknecht 2009.
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt
-// or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-
-#include <boost/program_options/cmdline.hpp>
-#include <boost/program_options/options_description.hpp>
-#include <boost/program_options/parsers.hpp>
-#include <boost/program_options/detail/cmdline.hpp>
-using namespace boost::program_options;
-using boost::program_options::detail::cmdline;
-
-#include <iostream>
-#include <sstream>
-#include <vector>
-#include <cassert>
-using namespace std;
-
-#include "minitest.hpp"
-
-
-// Test free function collect_unrecognized()
-//
-//  it collects the tokens of all not registered options. It can be used
-//  to pass them to an own parser implementation
-
-
-
-void test_unrecognize_cmdline() 
-{
-   options_description desc;
-   
-   string content = "prg --input input.txt --optimization 4 --opt option";   
-   vector< string > tokens =  split_unix(content);
-
-   cmdline cmd(tokens);
-   cmd.set_options_description(desc);
-   cmd.allow_unregistered();
-
-   vector< option > opts = cmd.run();
-   vector< string > result = collect_unrecognized(opts, include_positional);
-   
-   BOOST_CHECK_EQUAL(result.size(), 7);
-   BOOST_CHECK_EQUAL(result[0], "prg");
-   BOOST_CHECK_EQUAL(result[1], "--input");
-   BOOST_CHECK_EQUAL(result[2], "input.txt");
-   BOOST_CHECK_EQUAL(result[3], "--optimization");
-   BOOST_CHECK_EQUAL(result[4], "4");
-   BOOST_CHECK_EQUAL(result[5], "--opt");
-   BOOST_CHECK_EQUAL(result[6], "option");
-}
-
-
-
-void test_unrecognize_config() 
-{
-
-   options_description desc;
-   
-   string content  =
-    " input = input.txt\n"
-    " optimization = 4\n"
-    " opt = option\n"
-    ;
-
-   stringstream ss(content);
-   vector< option > opts = parse_config_file(ss, desc, true).options;
-   vector< string > result = collect_unrecognized(opts, include_positional);
-   
-   BOOST_CHECK_EQUAL(result.size(), 6);
-   BOOST_CHECK_EQUAL(result[0], "input");
-   BOOST_CHECK_EQUAL(result[1], "input.txt");
-   BOOST_CHECK_EQUAL(result[2], "optimization");
-   BOOST_CHECK_EQUAL(result[3], "4");
-   BOOST_CHECK_EQUAL(result[4], "opt");
-   BOOST_CHECK_EQUAL(result[5], "option");
-}
-
-
-
-int main(int /*ac*/, char** /*av*/)
-{
-   test_unrecognize_cmdline();
-   test_unrecognize_config();
-
-   return 0;
-}

test/variable_map_test.cpp

@@ -15,12 +15,24 @@ namespace po = boost::program_options;
 #include <boost/function.hpp>
 using namespace boost;
 
+#define BOOST_INCLUDE_MAIN  // for testing, include rather than link
+#include <boost/test/test_tools.hpp>
+
 #include <sstream>
 using namespace std;
 
-#include "minitest.hpp"
+#define TEST_CHECK_THROW(expression, exception, description) \
+    try \
+    { \
+        expression; \
+        BOOST_ERROR(description);\
+        throw 10; \
+    } \
+    catch(exception &) \
+    { \
+    }
 
-vector<string> sv(const char* array[], unsigned size)
+vector<string> sv(char* array[], unsigned size)
 {
     vector<string> r;
     for (unsigned i = 0; i < size; ++i)
@@ -33,24 +45,24 @@ void test_variable_map()
     options_description desc;
     desc.add_options()
         ("foo,f", new untyped_value)
-        ("bar,b", po::value<string>())
-        ("biz,z", po::value<string>())
+        ("bar,b", po::value<string>()->implicit())
+        ("biz,z", po::value<string>()->implicit())
         ("baz", new untyped_value())
         ("output,o", new untyped_value(), "")
         ;
-    const char* cmdline3_[] = { "--foo='12'", "--bar=11", "-z3", "-ofoo" };
+    char* cmdline3_[] = { "--foo='12'", "--bar=11", "-z3", "-ofoo" };
     vector<string> cmdline3 = sv(cmdline3_,
-                                 sizeof(cmdline3_)/sizeof(const char*));
+                                 sizeof(cmdline3_)/sizeof(cmdline3_[0]));
     parsed_options a3 = command_line_parser(cmdline3).options(desc).run();
     variables_map vm;
     store(a3, vm);
     notify(vm);
-    BOOST_REQUIRE(vm.size() == 4);
-    BOOST_CHECK(vm["foo"].as<string>() == "'12'");
-    BOOST_CHECK(vm["bar"].as<string>() == "11");
-    BOOST_CHECK(vm.count("biz") == 1);
-    BOOST_CHECK(vm["biz"].as<string>() == "3");
-    BOOST_CHECK(vm["output"].as<string>() == "foo");
+    BOOST_CRITICAL_TEST(vm.size() == 4);
+    BOOST_TEST(vm["foo"].as<string>() == "'12'");
+    BOOST_TEST(vm["bar"].as<string>() == "11");
+    BOOST_TEST(vm.count("biz") == 1);
+    BOOST_TEST(vm["biz"].as<string>() == "3");
+    BOOST_TEST(vm["output"].as<string>() == "foo");
 
     int i;
     desc.add_options()
@@ -58,19 +70,19 @@ void test_variable_map()
     ("zak", po::value<int>(&i), "")
     ("opt", bool_switch(), "");
 
-    const char* cmdline4_[] = { "--zee", "--zak=13" };
+    char* cmdline4_[] = { "--zee", "--zak=13" };
     vector<string> cmdline4 = sv(cmdline4_,
-                                 sizeof(cmdline4_)/sizeof(const char*));
+                                 sizeof(cmdline4_)/sizeof(cmdline4_[0]));
     parsed_options a4 = command_line_parser(cmdline4).options(desc).run();
 
     variables_map vm2;
     store(a4, vm2);
     notify(vm2);
-    BOOST_REQUIRE(vm2.size() == 3);
-    BOOST_CHECK(vm2["zee"].as<bool>() == true);
-    BOOST_CHECK(vm2["zak"].as<int>() == 13);
-    BOOST_CHECK(vm2["opt"].as<bool>() == false);
-    BOOST_CHECK(i == 13);
+    BOOST_CRITICAL_TEST(vm2.size() == 3);
+    BOOST_TEST(vm2["zee"].as<bool>() == true);
+    BOOST_TEST(vm2["zak"].as<int>() == 13);
+    BOOST_TEST(vm2["opt"].as<bool>() == false);
+    BOOST_TEST(i == 13);
 
     options_description desc2;
     desc2.add_options()
@@ -78,40 +90,18 @@ void test_variable_map()
     ("voo", po::value<string>())
     ("iii", po::value<int>()->default_value(123))
     ;
-    const char* cmdline5_[] = { "--voo=1" };
+    char* cmdline5_[] = {  "--voo=1" };
     vector<string> cmdline5 = sv(cmdline5_,
-                                 sizeof(cmdline5_)/sizeof(const char*));
+                                 sizeof(cmdline5_)/sizeof(cmdline5_[0]));
     parsed_options a5 = command_line_parser(cmdline5).options(desc2).run();
 
     variables_map vm3;
     store(a5, vm3);
     notify(vm3);
-    BOOST_REQUIRE(vm3.size() == 3);
-    BOOST_CHECK(vm3["vee"].as<string>() == "42");
-    BOOST_CHECK(vm3["voo"].as<string>() == "1");
-    BOOST_CHECK(vm3["iii"].as<int>() == 123);
-
-    options_description desc3;
-    desc3.add_options()
-    ("imp", po::value<int>()->implicit_value(100))
-    ("iim", po::value<int>()->implicit_value(200)->default_value(201))
-    ("mmp,m", po::value<int>()->implicit_value(123)->default_value(124))
-    ("foo", po::value<int>())
-    ;
-    /* The -m option is implicit. It does not have value in inside the token,
-       and we should not grab the next token.  */
-    const char* cmdline6_[] = {  "--imp=1", "-m", "--foo=1" };
-    vector<string> cmdline6 = sv(cmdline6_,
-                                 sizeof(cmdline6_)/sizeof(const char*));
-    parsed_options a6 = command_line_parser(cmdline6).options(desc3).run();
-
-    variables_map vm4;
-    store(a6, vm4);
-    notify(vm4);
-    BOOST_REQUIRE(vm4.size() == 4);
-    BOOST_CHECK(vm4["imp"].as<int>() == 1);
-    BOOST_CHECK(vm4["iim"].as<int>() == 201);
-    BOOST_CHECK(vm4["mmp"].as<int>() == 123);
+    BOOST_CRITICAL_TEST(vm3.size() == 3);
+    BOOST_TEST(vm3["vee"].as<string>() == "42");
+    BOOST_TEST(vm3["voo"].as<string>() == "1");
+    BOOST_TEST(vm3["iii"].as<int>() == 123);
 }
 
 int stored_value;
@@ -194,15 +184,15 @@ void test_priority()
     ("include", po::value< vector<int> >()->composing())
     ;
 
-    const char* cmdline1_[] = { "--first=1", "--aux=10", "--first=3", "--include=1" };
+    char* cmdline1_[] = { "--first=1", "--aux=10", "--first=3", "--include=1" };
     vector<string> cmdline1 = sv(cmdline1_, 
-                                 sizeof(cmdline1_)/sizeof(const char*));
+                                 sizeof(cmdline1_)/sizeof(cmdline1_[0]));
 
     parsed_options p1 = command_line_parser(cmdline1).options(desc).run();
 
-    const char* cmdline2_[] = { "--first=12", "--second=7", "--include=7" };
+    char* cmdline2_[] = { "--first=12", "--second=7", "--include=7" };
     vector<string> cmdline2 = sv(cmdline2_, 
-                                 sizeof(cmdline2_)/sizeof(const char*));
+                                 sizeof(cmdline2_)/sizeof(cmdline2_[0]));
 
     parsed_options p2 = command_line_parser(cmdline2).options(desc).run();
 
@@ -237,54 +227,13 @@ void test_priority()
     BOOST_CHECK_EQUAL(vm["include"].as< vector<int> >()[1], 7);
 }
 
-void test_multiple_assignments_with_different_option_description()
-{
-    // Test that if we store option twice into the same variable_map,
-    // and some of the options stored the first time are not present
-    // in the options descrription provided the second time, we don't crash.
-
-    options_description desc1("");    
-    desc1.add_options()
-        ("help,h", "")
-        ("includes", po::value< vector<string> >()->composing(), "");
-        ;
-
-    options_description desc2("");
-    desc2.add_options()
-        ("output,o", "");
-
-    vector<string> input1;
-    input1.push_back("--help");
-    input1.push_back("--includes=a");
-    parsed_options p1 = command_line_parser(input1).options(desc1).run();
-
-    vector<string> input2;
-    input1.push_back("--output");
-    parsed_options p2 = command_line_parser(input2).options(desc2).run();
-
-    vector<string> input3;
-    input3.push_back("--includes=b");
-    parsed_options p3 = command_line_parser(input3).options(desc1).run();
 
 
-    variables_map vm;
-    store(p1, vm);
-    store(p2, vm);
-    store(p3, vm);
-
-    BOOST_REQUIRE(vm.count("help") == 1);
-    BOOST_REQUIRE(vm.count("includes") == 1);
-    BOOST_CHECK_EQUAL(vm["includes"].as< vector<string> >()[0], "a");
-    BOOST_CHECK_EQUAL(vm["includes"].as< vector<string> >()[1], "b");
-
-} 
-
-int main(int, char* [])
+int test_main(int, char* [])
 {
     test_variable_map();
     test_semantic_values();
     test_priority();
-    test_multiple_assignments_with_different_option_description();
     return 0;
 }
 

test/winmain.cpp

@@ -3,46 +3,30 @@
 // (See accompanying file LICENSE_1_0.txt
 // or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#if defined(_WIN32)
+#ifdef _WIN32
 #include <string>
 #include <vector>
 #include <cctype>
-#include <iostream>
-#include <stdlib.h>
-
-using namespace std;
 
 #include <boost/program_options/parsers.hpp>
 using namespace boost::program_options;
 
-void check_equal(const std::vector<string>& actual, char **expected, int n)
-{
-    if (actual.size() != n)
-    {
-        std::cerr << "Size mismatch between expected and actual data\n";
-        abort();
-    }
-    for (int i = 0; i < n; ++i)
-    {
-        if (actual[i] != expected[i])
-        {
-            std::cerr << "Unexpected content\n";
-            abort();
-        }
-    }
-}
-
+#include <boost/test/test_tools.hpp>
 #include <boost/preprocessor/cat.hpp>
 
 void test_winmain()
 {
+    using namespace std;
 
 #define C ,
 #define TEST(input, expected) \
     char* BOOST_PP_CAT(e, __LINE__)[] = expected;\
     vector<string> BOOST_PP_CAT(v, __LINE__) = split_winmain(input);\
-    check_equal(BOOST_PP_CAT(v, __LINE__), BOOST_PP_CAT(e, __LINE__),\
-                sizeof(BOOST_PP_CAT(e, __LINE__))/sizeof(char*));    
+    BOOST_REQUIRE(BOOST_PP_CAT(v, __LINE__).size() == \
+            sizeof(BOOST_PP_CAT(e, __LINE__))/sizeof(char*));\
+    BOOST_CHECK_EQUAL_COLLECTIONS(BOOST_PP_CAT(v, __LINE__).begin(),\
+                                  BOOST_PP_CAT(v, __LINE__).end(),\
+                                  BOOST_PP_CAT(e, __LINE__));    
 
 // The following expectations were obtained in Win2000 shell:
     TEST("1 ", {"1"});
@@ -61,13 +45,13 @@ void test_winmain()
     TEST("1\\\\1 ", {"1\\\\1"});    
 }
 
-int main(int, char*[])
+int test_main(int, char*[])
 {
     test_winmain();
     return 0;
 }
 #else
-int main(int, char*[])
+int test_main(int, char*[])
 {
     return 0;
 }