From fda6414443d25e3c8d90043669744a47ce29fe45 Mon Sep 17 00:00:00 2001
From: Vladimir Prus <vladimir@codesourcery.com>
Date: Thu, 19 Dec 2013 08:09:13 +0400
Subject: [PATCH 01/26] Don't use vector<>::data.

This is only required by C++ 11. Most compilers have it anyway,
but there are exceptions, like msvc 8 and msvc 9.
---
 test/exception_txt_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/exception_txt_test.cpp b/test/exception_txt_test.cpp
index d37973a..bbc6003 100644
--- a/test/exception_txt_test.cpp
+++ b/test/exception_txt_test.cpp
@@ -59,7 +59,7 @@ void test_each_exception_message(const string& test_description, const vector<co
         if (style == -1)
             store(parse_config_file(is, desc), vm);
         else
-            store(parse_command_line(argv.size(), argv.data(), desc, style), vm);
+            store(parse_command_line(argv.size(), &argv[0], desc, style), vm);
         notify(vm);    
     } 
     catch (EXCEPTION& e)

From 4ae33ce15e5b6345e6eefa19466fdf7cd28a7bbd Mon Sep 17 00:00:00 2001
From: Vladimir Prus <vladimir@codesourcery.com>
Date: Thu, 19 Dec 2013 08:16:19 +0400
Subject: [PATCH 02/26] Add dllexport to common_config_file_iterator.

As reported in #6797, there are linker errors otherwise. I
do not know why regression tests, which test dll linking
explicitly, do not catch this.
---
 include/boost/program_options/detail/config_file.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/program_options/detail/config_file.hpp b/include/boost/program_options/detail/config_file.hpp
index 4c2c15b..b819b5d 100644
--- a/include/boost/program_options/detail/config_file.hpp
+++ b/include/boost/program_options/detail/config_file.hpp
@@ -62,7 +62,7 @@ namespace boost { namespace program_options { namespace detail {
          TODO: maybe, we should just accept a pointer to options_description
          class.
      */    
-    class common_config_file_iterator 
+    class BOOST_PROGRAM_OPTIONS_DECL common_config_file_iterator
         : public eof_iterator<common_config_file_iterator, option>
     {
     public:

From 2acfab15a3a1516ac8295036c83b673879a0a4a4 Mon Sep 17 00:00:00 2001
From: Daniela Engert <dani@ngrt.de>
Date: Wed, 8 Jan 2014 17:07:45 +0100
Subject: [PATCH 03/26] Fix config_file compilation errors with MSVC

Previous fix 4ae33c for ticket #6797 introduced a new problem with
Visual Studio compilers about two missing methods in
'common_config_file_iterator'. Adding those seemingly not required
methods as empty methods fixes the issue. As an added bonus, the
bogus warnings about DLL-interfaces get a silencing treatment, too.

Tests were run with vc10, vc11, and vc12. Without this fix, the
affected test cases fail on all 3 compilers. With the fix in place,
all tests pass.

Signed-off-by: Daniela Engert <dani@ngrt.de>
---
 .../boost/program_options/detail/config_file.hpp   | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/include/boost/program_options/detail/config_file.hpp b/include/boost/program_options/detail/config_file.hpp
index b819b5d..9d35f9e 100644
--- a/include/boost/program_options/detail/config_file.hpp
+++ b/include/boost/program_options/detail/config_file.hpp
@@ -27,6 +27,11 @@
 #include <boost/type_traits/is_same.hpp>
 #include <boost/shared_ptr.hpp>
 
+#ifdef BOOST_MSVC
+# pragma warning(push)
+# pragma warning(disable: 4251) // class XYZ needs to have dll-interface to be used by clients of class XYZ
+#endif
+
 
 
 namespace boost { namespace program_options { namespace detail {
@@ -77,6 +82,11 @@ namespace boost { namespace program_options { namespace detail {
         
         void get();
         
+#if BOOST_WORKAROUND(_MSC_VER, <= 1800)
+        void decrement() {}
+        void advance(difference_type) {}
+#endif
+
     protected: // Stubs for derived classes
 
         // Obtains next line from the config file
@@ -177,4 +187,8 @@ namespace boost { namespace program_options { namespace detail {
 
 }}}
 
+#ifdef BOOST_MSVC
+# pragma warning(pop)
+#endif
+
 #endif

From 3ce1c74a0f0257d291c47e28bd2bae8385b69225 Mon Sep 17 00:00:00 2001
From: Daniela Engert <dani@ngrt.de>
Date: Wed, 8 Jan 2014 20:00:47 +0100
Subject: [PATCH 04/26] Suppress msvc level-4 warnings.

Even when compiled at warning level 4 (i.e. all), project
policies may require compilations without warnings issued.

Signed-off-by: Daniela Engert <dani@ngrt.de>
---
 include/boost/program_options/options_description.hpp | 5 +++++
 src/parsers.cpp                                       | 2 +-
 src/value_semantic.cpp                                | 5 +++++
 3 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/include/boost/program_options/options_description.hpp b/include/boost/program_options/options_description.hpp
index 32f6990..04e42a8 100644
--- a/include/boost/program_options/options_description.hpp
+++ b/include/boost/program_options/options_description.hpp
@@ -236,6 +236,11 @@ namespace program_options {
         void print(std::ostream& os, unsigned width = 0) const;
 
     private:
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1800))
+        // prevent warning C4512: assignment operator could not be generated
+        options_description& operator=(const options_description&);
+#endif
+
         typedef std::map<std::string, int>::const_iterator name2index_iterator;
         typedef std::pair<name2index_iterator, name2index_iterator> 
             approximation_range;
diff --git a/src/parsers.cpp b/src/parsers.cpp
index 2361a48..dd62c66 100644
--- a/src/parsers.cpp
+++ b/src/parsers.cpp
@@ -220,7 +220,7 @@ namespace boost { namespace program_options {
                     {   
                         // Intel-Win-7.1 does not understand
             // push_back on string.         
-                        result += tolower(s[n]);
+                        result += static_cast<char>(tolower(s[n]));
                     }
                 }
                 return result;
diff --git a/src/value_semantic.cpp b/src/value_semantic.cpp
index 5314029..5818b07 100644
--- a/src/value_semantic.cpp
+++ b/src/value_semantic.cpp
@@ -268,7 +268,12 @@ namespace boost { namespace program_options {
 
     void error_with_option_name::replace_token(const string& from, const string& to) const
     {
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1800))
+// prevent warning C4127: conditional expression is constant
+        for (;;)
+#else
         while (1)
+#endif
         {
             std::size_t pos = m_message.find(from.c_str(), 0, from.length());
             // not found: all replaced

From f50b02750a7b17ec6a149c0264bef5727a8df1f6 Mon Sep 17 00:00:00 2001
From: Vladimir Prus <vladimir@codesourcery.com>
Date: Mon, 20 Jan 2014 09:28:12 +0400
Subject: [PATCH 05/26] Don't increment environment pointer past the end.

This should not effect correct programs, since once the
iterator itself is past-the-end, it should not matter what
the underlying state of that iterator is. But, the new behaviour
is more obvious.
---
 include/boost/program_options/environment_iterator.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/include/boost/program_options/environment_iterator.hpp b/include/boost/program_options/environment_iterator.hpp
index c815693..933919d 100644
--- a/include/boost/program_options/environment_iterator.hpp
+++ b/include/boost/program_options/environment_iterator.hpp
@@ -40,8 +40,9 @@ namespace boost {
                 assert(n != s.npos);
                 value().first = s.substr(0, n);
                 value().second = s.substr(n+1);
-            }            
-            ++m_environment;
+                
+                ++m_environment;
+            }
         }
         
     private:

From 37804b54d4ecbeaea770e4f4fce46cc371083c81 Mon Sep 17 00:00:00 2001
From: Vladimir Prus <vladimir@codesourcery.com>
Date: Wed, 9 Apr 2014 14:04:48 +0400
Subject: [PATCH 06/26] Remove unnecessary workaround.

Closes #9854.
---
 src/value_semantic.cpp | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/value_semantic.cpp b/src/value_semantic.cpp
index 5818b07..a7366d4 100644
--- a/src/value_semantic.cpp
+++ b/src/value_semantic.cpp
@@ -268,12 +268,7 @@ namespace boost { namespace program_options {
 
     void error_with_option_name::replace_token(const string& from, const string& to) const
     {
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1800))
-// prevent warning C4127: conditional expression is constant
         for (;;)
-#else
-        while (1)
-#endif
         {
             std::size_t pos = m_message.find(from.c_str(), 0, from.length());
             // not found: all replaced

From f081a9364353b8c40f84fd058312c81d3c9539f8 Mon Sep 17 00:00:00 2001
From: Daniel James <daniel@calamity.org.uk>
Date: Mon, 18 Aug 2014 15:09:12 +0100
Subject: [PATCH 07/26] Add metadata file.

---
 meta/libraries.json | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 meta/libraries.json

diff --git a/meta/libraries.json b/meta/libraries.json
new file mode 100644
index 0000000..5fbf312
--- /dev/null
+++ b/meta/libraries.json
@@ -0,0 +1,15 @@
+{
+    "key": "program_options",
+    "name": "Program Options",
+    "authors": [
+        "Vladimir Prus"
+    ],
+    "description": "The program_options library allows program developers to obtain program options, that is (name, value) pairs from the user, via conventional methods such as command line and config file.",
+    "category": [
+        "IO",
+        "Miscellaneous"
+    ],
+    "maintainers": [
+        "Vladimir Prus <vladimir.prus -at- gmail.com>"
+    ]
+}

From 6e846597d5e3d5de8efda897880e0b92c2602778 Mon Sep 17 00:00:00 2001
From: Hans Hohenfeld <hans.hohenfeld@posteo.de>
Date: Fri, 31 Oct 2014 17:59:20 +0100
Subject: [PATCH 08/26] Use maximum unsigned as default multitoken limit.

Fixes #10718.
---
 include/boost/program_options/value_semantic.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/include/boost/program_options/value_semantic.hpp b/include/boost/program_options/value_semantic.hpp
index 081e997..57bb2ac 100644
--- a/include/boost/program_options/value_semantic.hpp
+++ b/include/boost/program_options/value_semantic.hpp
@@ -17,6 +17,7 @@
 #include <string>
 #include <vector>
 #include <typeinfo>
+#include <limits>
 
 namespace boost { namespace program_options {
 
@@ -313,7 +314,7 @@ namespace boost { namespace program_options {
 
         unsigned max_tokens() const {
             if (m_multitoken) {
-                return 32000;
+                return std::numeric_limits<unsigned>::max();
             } else if (m_zero_tokens) {
                 return 0;
             } else {

From 1a17f20532be3480f01d11a1c692008024136597 Mon Sep 17 00:00:00 2001
From: Marcel Raad <raad@teamviewer.com>
Date: Thu, 3 Jul 2014 21:32:27 +0200
Subject: [PATCH 09/26] Compile fix for MSVC 14

Also fixes some new variable shadowing warnings
in cmdline_test with Visual C++ 14.
---
 include/boost/program_options/detail/config_file.hpp |  2 +-
 test/cmdline_test.cpp                                | 12 ++++++------
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/boost/program_options/detail/config_file.hpp b/include/boost/program_options/detail/config_file.hpp
index 9d35f9e..be6bba1 100644
--- a/include/boost/program_options/detail/config_file.hpp
+++ b/include/boost/program_options/detail/config_file.hpp
@@ -82,7 +82,7 @@ namespace boost { namespace program_options { namespace detail {
         
         void get();
         
-#if BOOST_WORKAROUND(_MSC_VER, <= 1800)
+#if BOOST_WORKAROUND(_MSC_VER, <= 1900)
         void decrement() {}
         void advance(difference_type) {}
 #endif
diff --git a/test/cmdline_test.cpp b/test/cmdline_test.cpp
index ed86160..23c15e4 100644
--- a/test/cmdline_test.cpp
+++ b/test/cmdline_test.cpp
@@ -126,9 +126,9 @@ void test_cmdline(const char* syntax,
         try {
             vector<option> options = cmd.run();
 
-            for(unsigned i = 0; i < options.size(); ++i)
+            for(unsigned j = 0; j < options.size(); ++j)
             {
-                option opt = options[i];
+                option opt = options[j];
 
                 if (opt.position_key != -1) {
                     if (!result.empty())
@@ -138,18 +138,18 @@ void test_cmdline(const char* syntax,
                     if (!result.empty())
                         result += " ";
                     result += opt.string_key + ":";
-                    for (size_t j = 0; j < opt.value.size(); ++j) {
-                        if (j != 0)
+                    for (size_t k = 0; k < opt.value.size(); ++k) {
+                        if (k != 0)
                             result += "-";
                         result += opt.value[j];
                     }                    
                 }
             }
         }
-        catch(unknown_option& e) {
+        catch(unknown_option&) {
             status = s_unknown_option;
         }
-        catch(ambiguous_option& e) {
+        catch(ambiguous_option&) {
             status = s_ambiguous_option;
         }
         catch(invalid_command_line_syntax& e) {

From fcc4e6ef1a7183828dd83ab3e28cddb9ddcd009c Mon Sep 17 00:00:00 2001
From: Jurko <jurko.gospodnetic@pke.hr>
Date: Thu, 27 Nov 2014 02:27:25 +0100
Subject: [PATCH 10/26] trim trailing spaces

---
 doc/design.xml                                |  20 ++--
 doc/overview.xml                              | 106 +++++++++---------
 .../boost/program_options/eof_iterator.hpp    |  34 +++---
 include/boost/program_options/parsers.hpp     |  68 +++++------
 .../boost/program_options/variables_map.hpp   |  34 +++---
 5 files changed, 131 insertions(+), 131 deletions(-)

diff --git a/doc/design.xml b/doc/design.xml
index 3051e5e..86f440a 100644
--- a/doc/design.xml
+++ b/doc/design.xml
@@ -22,7 +22,7 @@
       not mean strict 7-bit ASCII encoding, but rather "char" strings in local
       8-bit encoding.
     </para>
-          
+
     <para>
       Generally, &quot;Unicode support&quot; can mean
       many things, but for the program_options library it means that:
@@ -54,7 +54,7 @@
                   passed to an ascii value will be converted using a codecvt
                   facet (which may be specified by the user).
                 </para>
-              </listitem>                 
+              </listitem>
             </itemizedlist>
           </para>
         </listitem>
@@ -94,7 +94,7 @@
     <para>The primary question in implementing the Unicode support is whether
       to use templates and <code>std::basic_string</code> or to use some
       internal encoding and convert between internal and external encodings on
-      the interface boundaries.            
+      the interface boundaries.
     </para>
 
     <para>The choice, mostly, is between code size and execution
@@ -171,14 +171,14 @@
             number of new instantiations.
           </para>
         </listitem>
-          
+
       </itemizedlist>
       There's no clear leader, but the last point seems important, so UTF-8
-      will be used.      
+      will be used.
     </para>
 
-    <para>Choosing the UTF-8 encoding allows the use of existing parsers, 
-      because 7-bit ascii characters retain their values in UTF-8, 
+    <para>Choosing the UTF-8 encoding allows the use of existing parsers,
+      because 7-bit ascii characters retain their values in UTF-8,
       so searching for 7-bit strings is simple. However, there are
       two subtle issues:
       <itemizedlist>
@@ -197,16 +197,16 @@
       almost universal encoding and since composing characters following '=' (and
       other characters with special meaning to the library) are not likely to appear.
     </para>
-                   
+
   </section>
 
-  
+
 </section>
 
 <!--
      Local Variables:
      mode: xml
-     sgml-indent-data: t     
+     sgml-indent-data: t
      sgml-parent-document: ("program_options.xml" "section")
      sgml-set-face: t
      End:
diff --git a/doc/overview.xml b/doc/overview.xml
index dcfbaf4..94ecf3d 100644
--- a/doc/overview.xml
+++ b/doc/overview.xml
@@ -22,7 +22,7 @@
       </listitem>
       <listitem>
         <para>The parsers component, which uses this information to find option names
-          and values in the input sources and return them. 
+          and values in the input sources and return them.
         </para>
       </listitem>
       <listitem>
@@ -72,10 +72,10 @@
         </para>
       </listitem>
       <listitem>
-        <para>The storage component is focused on storing options values. It 
+        <para>The storage component is focused on storing options values. It
         </para>
       </listitem>
-  
+
 
     </itemizedlist>
 
@@ -105,7 +105,7 @@ desc.add_options()
     ("help", "produce help")
     ("optimization", value&lt;int&gt;()->default_value(10), "optimization level")
     ;
-</programlisting>      
+</programlisting>
     </para>
 
     <para>The call to the <code>value</code> function creates an instance of
@@ -116,14 +116,14 @@ desc.add_options()
       essentially emulates named parameters of the constructor.) Calls to
       <code>operator()</code> on the object returned by <code>add_options</code>
       forward arguments to the constructor of the <code>option_description</code>
-      class and add the new instance. 
+      class and add the new instance.
     </para>
 
     <para>
       Note that in addition to the
       <code>value</code>, library provides the <code>bool_switch</code>
       function, and user can write his own function which will return
-      other subclasses of <code>value_semantic</code> with 
+      other subclasses of <code>value_semantic</code> with
       different behaviour. For the remainder of this section, we'll talk only
       about the <code>value</code> function.
     </para>
@@ -135,7 +135,7 @@ desc.add_options()
       where value is just a vector of strings
       (<code>std::vector&lt;std::string&gt;</code>). The semantic layer
       is responsible for converting the value of the option into more usable C++
-      types. 
+      types.
     </para>
 
     <para>This separation is an important part of library design. The parsers
@@ -153,7 +153,7 @@ desc.add_options()
         <classname>boost::program_options::options_description</classname> class
         and some methods of the
         <classname>boost::program_options::value_semantic</classname> class
-        and includes:        
+        and includes:
         <itemizedlist>
           <listitem>
             <para>
@@ -193,7 +193,7 @@ desc.add_options()
       span several tokens. For example, the following command line is OK:
       <screen>
           test --help --compression 10 --verbose --email beadle@mars beadle2@mars
-      </screen>      
+      </screen>
       </para>
 
       <section>
@@ -208,18 +208,18 @@ desc.add_options()
         <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 
+        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: 
+        inserting spaces at the beginning of a paragraph. For example:
         <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 ")
-    ;  
+    ;
         </programlisting>
         will specify a four-space indent for the first line. The output will
         look like:
@@ -230,14 +230,14 @@ msg a long help msg a long help msg a long help msg a long help msg ")
                         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: 
+        example:
         <programlisting>
 options.add_options()
       ("well_formated", "As you can see this is a very well formatted
@@ -249,7 +249,7 @@ 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");          
+bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla");
         </programlisting>
         will produce:
         <screen>
@@ -289,11 +289,11 @@ bla bla bla bla bla bla bla bla bla bla bla bla bla bla bla");
       </section>
 
     </section>
-      
+
     <section>
       <title>Semantic Information</title>
-      
-      <para>The semantic information is completely provided by the 
+
+      <para>The semantic information is completely provided by the
         <classname>boost::program_options::value_semantic</classname> class. For
         example:
 <programlisting>
@@ -303,18 +303,18 @@ desc.add_options()
     ("email", value&lt; vector&lt;string&gt; &gt;()
         ->composing()->notifier(&amp;your_function), "email")
     ;
-</programlisting>      
+</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
         be merged, and that after parsing is done, the library will  call
         function <code>&amp;your_function</code>, passing the value of the
-        "email" option as argument.      
+        "email" option as argument.
       </para>
     </section>
-    
+
     <section>
       <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
         problem. A command line can include a <firstterm>positional option</firstterm>,
@@ -324,7 +324,7 @@ desc.add_options()
         </screen>
         Here, the "/etc/passwd" element does not have any option name.
       </para>
-      
+
       <para>One solution is to ask the user to extract positional options
         himself and process them as he likes. However, there's a nicer approach
         -- provide a method to automatically assign the names for positional
@@ -334,7 +334,7 @@ desc.add_options()
           archiver --compression=9 --input-file=/etc/passwd
         </screen>
       </para>
-      
+
       <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:
@@ -343,7 +343,7 @@ positional_options_description pd; pd.add("input-file", 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>
@@ -360,11 +360,11 @@ pd.add("output-file", 2).add("input-file", -1);
       an instance of the &options_description; class.</para>
     </warning>
 
-      
+
     </section>
-              
+
     <!-- Note that the classes are not modified during parsing -->
-          
+
   </section>
 
   <section>
@@ -390,7 +390,7 @@ pd.add("output-file", 2).add("input-file", -1);
       The results of parsing are returned as an instance of the &parsed_options;
       class. Typically, that object is passed directly to the storage
       component. However, it also can be used directly, or undergo some additional
-      processing. 
+      processing.
     </para>
 
     <para>
@@ -422,8 +422,8 @@ pd.add("output-file", 2).add("input-file", -1);
           </para>
         </listitem>
       </itemizedlist>
-    </para>      
-    
+    </para>
+
   </section>
 
 
@@ -512,7 +512,7 @@ visual_bell=yes
       <screen>
 gui.accessibility.visual_bell=yes
       </screen>
-                  
+
     </section>
 
     <section>
@@ -538,7 +538,7 @@ gui.accessibility.visual_bell=yes
       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
@@ -551,9 +551,9 @@ gui.accessibility.visual_bell=yes
       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>. 
+      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
@@ -561,35 +561,35 @@ gui.accessibility.visual_bell=yes
       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>
-    
+
     <para>The following table describes all the important symbols in the
       library, for quick access.</para>
-    
+
     <informaltable pgwide="1">
-        
+
       <tgroup cols="2">
         <colspec colname='c1'/>
         <colspec colname='c2'/>
         <thead>
-          
-          <row>            
+
+          <row>
             <entry>Symbol</entry>
             <entry>Description</entry>
           </row>
         </thead>
-        
+
         <tbody>
-          
-          <row>            
+
+          <row>
             <entry namest='c1' nameend='c2'>Options description component</entry>
           </row>
-          
+
           <row>
             <entry>&options_description;</entry>
             <entry>describes a number of options</entry>
@@ -599,10 +599,10 @@ gui.accessibility.visual_bell=yes
             <entry>defines the option's value</entry>
           </row>
 
-          <row>            
+          <row>
             <entry namest='c1' nameend='c2'>Parsers component</entry>
           </row>
-          
+
           <row>
             <entry>&parse_command_line;</entry>
             <entry>parses command line (simpified interface)</entry>
@@ -624,7 +624,7 @@ gui.accessibility.visual_bell=yes
             <entry>parses environment</entry>
           </row>
 
-          <row>            
+          <row>
             <entry namest='c1' nameend='c2'>Storage component</entry>
           </row>
 
@@ -632,20 +632,20 @@ gui.accessibility.visual_bell=yes
             <entry>&variables_map;</entry>
             <entry>storage for option values</entry>
           </row>
-   
+
         </tbody>
       </tgroup>
-      
+
     </informaltable>
-    
+
   </section>
-  
+
 </section>
 
 <!--
      Local Variables:
      mode: nxml
-     sgml-indent-data: t     
+     sgml-indent-data: t
      sgml-parent-document: ("program_options.xml" "section")
      sgml-set-face: t
      End:
diff --git a/include/boost/program_options/eof_iterator.hpp b/include/boost/program_options/eof_iterator.hpp
index 0efa6f7..28a174e 100644
--- a/include/boost/program_options/eof_iterator.hpp
+++ b/include/boost/program_options/eof_iterator.hpp
@@ -10,17 +10,17 @@
 
 namespace boost {
 
-    /** The 'eof_iterator' class is useful for constructing forward iterators 
-        in cases where iterator extract data from some source and it's easy 
-        to detect 'eof' -- i.e. the situation where there's no data. One 
+    /** The 'eof_iterator' class is useful for constructing forward iterators
+        in cases where iterator extract data from some source and it's easy
+        to detect 'eof' -- i.e. the situation where there's no data. One
         apparent example is reading lines from a file.
-        
+
         Implementing such iterators using 'iterator_facade' directly would
-        require to create class with three core operation, a couple of 
-        constructors. When using 'eof_iterator', the derived class should define 
+        require to create class with three core operation, a couple of
+        constructors. When using 'eof_iterator', the derived class should define
         only one method to get new value, plus a couple of constructors.
 
-        The basic idea is that iterator has 'eof' bit. Two iterators are equal 
+        The basic idea is that iterator has 'eof' bit. Two iterators are equal
         only if both have their 'eof' bits set. The 'get' method either obtains
         the new value or sets the 'eof' bit.
 
@@ -33,13 +33,13 @@ namespace boost {
         3. The 'get' method. It should operate this way:
             - look at some 'data pointer' to see if new element is available;
               if not, it should call 'found_eof'.
-            - extract new element and store it at location returned by the 'value' 
+            - extract new element and store it at location returned by the 'value'
                method.
             - advance the data pointer.
 
-        Essentially, the 'get' method has the functionality of both 'increment' 
-        and 'dereference'. It's very good for the cases where data extraction 
-        implicitly moves data pointer, like for stream operation.         
+        Essentially, the 'get' method has the functionality of both 'increment'
+        and 'dereference'. It's very good for the cases where data extraction
+        implicitly moves data pointer, like for stream operation.
     */
     template<class Derived, class ValueType>
     class eof_iterator : public iterator_facade<Derived, const ValueType,
@@ -65,16 +65,16 @@ namespace boost {
         {
             m_at_eof = true;
         }
-        
+
 
     private: // iterator core operations
         friend class iterator_core_access;
-    
-        void increment() 
+
+        void increment()
         {
             static_cast<Derived&>(*this).get();
         }
-    
+
         bool equal(const eof_iterator& other) const
         {
             if (m_at_eof && other.m_at_eof)
@@ -82,14 +82,14 @@ namespace boost {
             else
                 return false;
         }
-        
+
         const ValueType& dereference() const
         {
             return m_value;
         }
 
         bool m_at_eof;
-        ValueType m_value;        
+        ValueType m_value;
     };
 }
 
diff --git a/include/boost/program_options/parsers.hpp b/include/boost/program_options/parsers.hpp
index 96f38f2..1b3a165 100644
--- a/include/boost/program_options/parsers.hpp
+++ b/include/boost/program_options/parsers.hpp
@@ -28,20 +28,20 @@ namespace boost { namespace program_options {
     class positional_options_description;
 
 
-    /** Results of parsing an input source. 
-        The primary use of this class is passing information from parsers 
+    /** Results of parsing an input source.
+        The primary use of this class is passing information from parsers
         component to value storage component. This class does not makes
-        much sense itself.        
+        much sense itself.
     */
     template<class charT>
     class basic_parsed_options {
     public:
-        explicit basic_parsed_options(const options_description* xdescription, int options_prefix = 0) 
+        explicit basic_parsed_options(const options_description* xdescription, int options_prefix = 0)
         : description(xdescription), m_options_prefix(options_prefix) {}
         /** Options found in the source. */
         std::vector< basic_option<charT> > options;
-        /** Options description that was used for parsing. 
-            Parsers should return pointer to the instance of 
+        /** Options description that was used for parsing.
+            Parsers should return pointer to the instance of
             option_description passed to them, and issues of lifetime are
             up to the caller. Can be NULL.
          */
@@ -55,7 +55,7 @@ namespace boost { namespace program_options {
          *      allow_long_disguise
          *      allow_dash_for_short
          *      allow_slash_for_short
-        */ 
+        */
         int m_options_prefix;
     };
 
@@ -74,7 +74,7 @@ namespace boost { namespace program_options {
 
         /** Stores UTF8 encoded options that were passed to constructor,
             to avoid reverse conversion in some cases. */
-        basic_parsed_options<char> utf8_encoded_options;        
+        basic_parsed_options<char> utf8_encoded_options;
 
         /** Mainly used for the diagnostic messages in exceptions.
          *  The canonical option prefix  for the parser which generated these results,
@@ -84,7 +84,7 @@ namespace boost { namespace program_options {
          *      allow_long_disguise
          *      allow_dash_for_short
          *      allow_slash_for_short
-        */ 
+        */
         int m_options_prefix;
     };
 
@@ -105,8 +105,8 @@ namespace boost { namespace program_options {
         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.        
+        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.
@@ -146,10 +146,10 @@ namespace boost { namespace program_options {
             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. 
+            funciton.
         */
         basic_command_line_parser& allow_unregistered();
-        
+
         using detail::cmdline::style_parser;
 
         basic_command_line_parser& extra_style_parser(style_parser s);
@@ -162,19 +162,19 @@ namespace boost { namespace program_options {
     typedef basic_command_line_parser<wchar_t> wcommand_line_parser;
 
     /** Creates instance of 'command_line_parser', passes parameters to it,
-        and returns the result of calling the 'run' method.        
+        and returns the result of calling the 'run' method.
      */
     template<class charT>
     basic_parsed_options<charT>
     parse_command_line(int argc, const charT* const argv[],
                        const options_description&,
                        int style = 0,
-                       function1<std::pair<std::string, std::string>, 
+                       function1<std::pair<std::string, std::string>,
                                  const std::string&> ext
                        = ext_parser());
 
-    /** Parse a config file. 
-    
+    /** Parse a config file.
+
         Read from given stream.
     */
     template<class charT>
@@ -185,10 +185,10 @@ namespace boost { namespace program_options {
     parse_config_file(std::basic_istream<charT>&, const options_description&,
                       bool allow_unregistered = false);
 
-    /** Parse a config file. 
-    
+    /** Parse a config file.
+
         Read from file with the given name. The character type is
-        passed to the file stream. 
+        passed to the file stream.
     */
     template<class charT>
 #if ! BOOST_WORKAROUND(__ICL, BOOST_TESTED_AT(700))
@@ -200,7 +200,7 @@ namespace boost { namespace program_options {
 
     /** Controls if the 'collect_unregistered' function should
         include positional options, or not. */
-    enum collect_unrecognized_mode 
+    enum collect_unrecognized_mode
     { include_positional, exclude_positional };
 
     /** Collects the original tokens for all named options with
@@ -210,34 +210,34 @@ namespace boost { namespace program_options {
         options.
     */
     template<class charT>
-    std::vector< std::basic_string<charT> > 
+    std::vector< std::basic_string<charT> >
     collect_unrecognized(const std::vector< basic_option<charT> >& options,
                          enum collect_unrecognized_mode mode);
 
-    /** Parse environment. 
+    /** Parse environment.
 
         For each environment variable, the 'name_mapper' function is called to
-        obtain the option name. If it returns empty string, the variable is 
-        ignored. 
+        obtain the option name. If it returns empty string, the variable is
+        ignored.
 
-        This is done since naming of environment variables is typically 
-        different from the naming of command line options.        
+        This is done since naming of environment variables is typically
+        different from the naming of command line options.
     */
     BOOST_PROGRAM_OPTIONS_DECL parsed_options
-    parse_environment(const options_description&, 
+    parse_environment(const options_description&,
                       const function1<std::string, std::string>& name_mapper);
 
     /** Parse environment.
 
         Takes all environment variables which start with 'prefix'. The option
-        name is obtained from variable name by removing the prefix and 
+        name is obtained from variable name by removing the prefix and
         converting the remaining string into lower case.
     */
     BOOST_PROGRAM_OPTIONS_DECL parsed_options
     parse_environment(const options_description&, const std::string& prefix);
 
     /** @overload
-        This function exists to resolve ambiguity between the two above 
+        This function exists to resolve ambiguity between the two above
         functions when second argument is of 'char*' type. There's implicit
         conversion to both function1 and string.
     */
@@ -252,13 +252,13 @@ namespace boost { namespace program_options {
         and escape characters '\'
     */
     BOOST_PROGRAM_OPTIONS_DECL std::vector<std::string>
-    split_unix(const std::string& cmdline, const std::string& seperator = " \t", 
+    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", 
+    split_unix(const std::wstring& cmdline, const std::wstring& seperator = L" \t",
          const std::wstring& quote = L"'\"", const std::wstring& escape = L"\\");
 #endif
 
@@ -278,7 +278,7 @@ namespace boost { namespace program_options {
     split_winmain(const std::wstring& cmdline);
     #endif
 #endif
-    
+
 
 }}
 
diff --git a/include/boost/program_options/variables_map.hpp b/include/boost/program_options/variables_map.hpp
index 09badbf..b8fa44f 100644
--- a/include/boost/program_options/variables_map.hpp
+++ b/include/boost/program_options/variables_map.hpp
@@ -31,35 +31,35 @@ namespace boost { namespace program_options {
 
     // forward declaration
 
-    /** Stores in 'm' all options that are defined in 'options'. 
+    /** 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.        
+        is not changed, even if 'options' specify some value.
     */
-    BOOST_PROGRAM_OPTIONS_DECL 
+    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'. 
+    /** 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.        
+        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, 
+    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 
+    /** 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& xv, bool xdefaulted)
+        : v(xv), m_defaulted(xdefaulted)
         {}
 
         /** If stored value if of type T, returns that value. Otherwise,
@@ -95,7 +95,7 @@ namespace boost { namespace program_options {
         shared_ptr<const value_semantic> m_value_semantic;
 
         friend BOOST_PROGRAM_OPTIONS_DECL
-        void store(const basic_parsed_options<char>& options, 
+        void store(const basic_parsed_options<char>& options,
               variables_map& m, bool);
 
         friend class BOOST_PROGRAM_OPTIONS_DECL variables_map;
@@ -138,8 +138,8 @@ namespace boost { namespace program_options {
         const abstract_variables_map* m_next;
     };
 
-    /** Concrete variables map which store variables in real map. 
-        
+    /** 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.
     */
@@ -155,8 +155,8 @@ namespace boost { namespace program_options {
         { return abstract_variables_map::operator[](name); }
 
         // Override to clear some extra fields.
-        void clear(); 
-        
+        void clear();
+
         void notify();
 
     private:
@@ -169,10 +169,10 @@ namespace boost { namespace program_options {
         std::set<std::string> m_final;
 
         friend BOOST_PROGRAM_OPTIONS_DECL
-        void store(const basic_parsed_options<char>& options, 
+        void store(const basic_parsed_options<char>& options,
                           variables_map& xm,
                           bool utf8);
-        
+
         /** Names of required options, filled by parser which has
             access to options_description.
             The map values are the "canonical" names for each corresponding option.

From 3cec23f2ba3974fa5684ce15768d0b18ec8bcdcd Mon Sep 17 00:00:00 2001
From: Jurko <jurko.gospodnetic@pke.hr>
Date: Thu, 27 Nov 2014 02:27:54 +0100
Subject: [PATCH 11/26] fix documentation typos & style

typo corrections:
 - otherwisee --> otherwise
 - it's is --> it is
 - nuber --> number
 - will likely to use --> is likely to use
 - varaible --> variable
 - defauled --> defaulted

stylistic changes:
 - which would make --> making
---
 doc/design.xml                                  | 4 ++--
 doc/overview.xml                                | 4 ++--
 include/boost/program_options/parsers.hpp       | 2 +-
 include/boost/program_options/variables_map.hpp | 4 ++--
 4 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/doc/design.xml b/doc/design.xml
index 86f440a..0881500 100644
--- a/doc/design.xml
+++ b/doc/design.xml
@@ -68,8 +68,8 @@
       Second, imagine a reusable library which has some options and exposes
       options description in its interface. If <emphasis>all</emphasis>
       options are either ascii or Unicode, and the library does not use any
-      Unicode strings, then the author will likely to use ascii options, which
-      would make the library unusable inside Unicode
+      Unicode strings, then the author is likely to use ascii options, making
+      the library unusable inside Unicode
       applications. Essentially, it would be necessary to provide two versions
       of the library -- ascii and Unicode.
     </para>
diff --git a/doc/overview.xml b/doc/overview.xml
index 94ecf3d..f7de296 100644
--- a/doc/overview.xml
+++ b/doc/overview.xml
@@ -280,9 +280,9 @@ bla bla bla 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
+        paragraph is allowed, otherwise 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
+        it is not on the first line of the paragraph or is on the last
         possible position of the first line.
         </para>
 
diff --git a/include/boost/program_options/parsers.hpp b/include/boost/program_options/parsers.hpp
index 1b3a165..7b35ce1 100644
--- a/include/boost/program_options/parsers.hpp
+++ b/include/boost/program_options/parsers.hpp
@@ -103,7 +103,7 @@ namespace boost { namespace program_options {
         and to parse the command line. It is primarily needed to
         emulate named function parameters -- a regular function with 5
         parameters will be hard to use and creating overloads with a smaller
-        nuber of parameters will be confusing.
+        number of parameters will be confusing.
 
         For the most common case, the function parse_command_line is a better
         alternative.
diff --git a/include/boost/program_options/variables_map.hpp b/include/boost/program_options/variables_map.hpp
index b8fa44f..70d1dee 100644
--- a/include/boost/program_options/variables_map.hpp
+++ b/include/boost/program_options/variables_map.hpp
@@ -118,11 +118,11 @@ namespace boost { namespace program_options {
                 - otherwise, returns empty value
 
             - if there's defaulted value
-                - if there's next varaible map, which has a non-defauled
+                - if there's next variable map, which has a non-defaulted
                   value, return that
                 - otherwise, return value from *this
 
-            - if there's a non-defauled value, returns it.
+            - if there's a non-defaulted value, returns it.
         */
         const variable_value& operator[](const std::string& name) const;
 

From a9ea9bb453030857067fce168bb4bfcdb47c6df8 Mon Sep 17 00:00:00 2001
From: Jurko <jurko.gospodnetic@pke.hr>
Date: Thu, 27 Nov 2014 09:19:24 +0100
Subject: [PATCH 12/26] escape first dash ('-') in double-dashes ('--') found
 in doxygen comments

This should prevent doxygen from generating bad documentation HTML pages
containing '<ndash></ndash>' where those double-dashes should be.
---
 include/boost/program_options/eof_iterator.hpp        | 2 +-
 include/boost/program_options/option.hpp              | 2 +-
 include/boost/program_options/options_description.hpp | 4 ++--
 include/boost/program_options/parsers.hpp             | 4 ++--
 include/boost/program_options/variables_map.hpp       | 2 +-
 5 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/boost/program_options/eof_iterator.hpp b/include/boost/program_options/eof_iterator.hpp
index 28a174e..4eeef0e 100644
--- a/include/boost/program_options/eof_iterator.hpp
+++ b/include/boost/program_options/eof_iterator.hpp
@@ -12,7 +12,7 @@ namespace boost {
 
     /** The 'eof_iterator' class is useful for constructing forward iterators
         in cases where iterator extract data from some source and it's easy
-        to detect 'eof' -- i.e. the situation where there's no data. One
+        to detect 'eof' \-- i.e. the situation where there's no data. One
         apparent example is reading lines from a file.
 
         Implementing such iterators using 'iterator_facade' directly would
diff --git a/include/boost/program_options/option.hpp b/include/boost/program_options/option.hpp
index fa6be52..1fa6a19 100644
--- a/include/boost/program_options/option.hpp
+++ b/include/boost/program_options/option.hpp
@@ -15,7 +15,7 @@ namespace boost { namespace program_options {
 
     /** Option found in input source.
         Contains a key and a value. The key, in turn, can be a string (name of
-        an option), or an integer (position in input source) -- in case no name
+        an option), or an integer (position in input source) \-- in case no name
         is specified. The latter is only possible for command line.
         The template parameter specifies the type of char used for storing the
         option's value.
diff --git a/include/boost/program_options/options_description.hpp b/include/boost/program_options/options_description.hpp
index 04e42a8..fac6acc 100644
--- a/include/boost/program_options/options_description.hpp
+++ b/include/boost/program_options/options_description.hpp
@@ -41,7 +41,7 @@ namespace program_options {
         are used only to validate input. Second affect interpretation of the
         option, for example default value for it or function that should be
         called  when the value is finally known. Routines which perform parsing
-        never use second kind of properties -- they are side effect free.
+        never use second kind of properties \-- they are side effect free.
         @sa options_description
     */
     class BOOST_PROGRAM_OPTIONS_DECL option_description {
@@ -71,7 +71,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 \-- short name.
         */
         option_description(const char* name,
                            const value_semantic* s);
diff --git a/include/boost/program_options/parsers.hpp b/include/boost/program_options/parsers.hpp
index 7b35ce1..bc79839 100644
--- a/include/boost/program_options/parsers.hpp
+++ b/include/boost/program_options/parsers.hpp
@@ -101,14 +101,14 @@ namespace boost { namespace program_options {
 
         The class allows one to specify all the information needed for parsing
         and to parse the command line. It is primarily needed to
-        emulate named function parameters -- a regular function with 5
+        emulate named function parameters \-- a regular function with 5
         parameters will be hard to use and creating overloads with a smaller
         number 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,
+        There are two typedefs \-- command_line_parser and wcommand_line_parser,
         for charT == char and charT == wchar_t cases.
     */
     template<class charT>
diff --git a/include/boost/program_options/variables_map.hpp b/include/boost/program_options/variables_map.hpp
index 70d1dee..362dedf 100644
--- a/include/boost/program_options/variables_map.hpp
+++ b/include/boost/program_options/variables_map.hpp
@@ -164,7 +164,7 @@ namespace boost { namespace program_options {
             which does 'find' in *this. */
         const variable_value& get(const std::string& name) const;
 
-        /** Names of option with 'final' values -- which should not
+        /** Names of option with 'final' values \-- which should not
             be changed by subsequence assignments. */
         std::set<std::string> m_final;
 

From 794de34bf983ea9157cc9558b6fb53dcf6d28926 Mon Sep 17 00:00:00 2001
From: Jurko <jurko.gospodnetic@pke.hr>
Date: Tue, 2 Dec 2014 01:40:17 +0100
Subject: [PATCH 13/26] trim trailing spaces

---
 doc/howto.xml                   | 64 +++++++++++++++----------------
 example/options_description.cpp | 20 +++++-----
 src/variables_map.cpp           | 68 ++++++++++++++++-----------------
 3 files changed, 76 insertions(+), 76 deletions(-)

diff --git a/doc/howto.xml b/doc/howto.xml
index 1173c4d..b573d46 100644
--- a/doc/howto.xml
+++ b/doc/howto.xml
@@ -21,7 +21,7 @@ options groups/hidden options
 -->
   <section>
     <title>Non-conventional Syntax</title>
-    
+
     <para>Sometimes, standard command line syntaxes are not enough. For
     example, the gcc compiler has "-frtti" and -fno-rtti" options, and this
     syntax is not directly supported.
@@ -57,14 +57,14 @@ store(command_line_parser(ac, av).options(desc).extra_parser(reg_foo)
         .run(), vm);
 </programlisting>
       The complete example can be found in the "example/custom_syntax.cpp"
-      file.                
+      file.
     </para>
   </section>
 
   <section>
     <title>Response Files</title>
 
-    <indexterm><primary>response files</primary></indexterm> 
+    <indexterm><primary>response files</primary></indexterm>
 
     <para>Some operating system have very low limits of the command line
       length. The common way to work around those limitations is using
@@ -79,7 +79,7 @@ store(command_line_parser(ac, av).options(desc).extra_parser(reg_foo)
     <para>
       First, you need to define an option for the response file:
 <programlisting>
-("response-file", value&lt;string&gt;(), 
+("response-file", value&lt;string&gt;(),
      "can be specified with '@name', too")
 </programlisting>
     </para>
@@ -120,14 +120,14 @@ if (vm.count("response-file")) {
      vector<string> args;
      copy(tok.begin(), tok.end(), back_inserter(args));
      // Parse the file and store the options
-     store(command_line_parser(args).options(desc).run(), vm);     
+     store(command_line_parser(args).options(desc).run(), vm);
 }
 ]]>
 </programlisting>
       The complete example can be found in the "example/response_file.cpp"
-      file.                
+      file.
     </para>
- 
+
   </section>
 
   <section>
@@ -146,7 +146,7 @@ if (vm.count("response-file")) {
 <programlisting>
 vector&lt;string&gt; args = split_winmain(lpCmdLine);
 store(command_line_parser(args).options(desc).run(), vm);
-</programlisting>      
+</programlisting>
       The <code>split_winmain</code> function is overloaded for <code>wchar_t</code> strings, so can
       also be used in Unicode applications.
     </para>
@@ -223,7 +223,7 @@ visible.add(general).add(gui);
 variables_map vm;
 store(parse_command_line(ac, av, all), vm);
 
-if (vm.count("help")) 
+if (vm.count("help"))
 {
     cout << visible;
     return 0;
@@ -235,7 +235,7 @@ if (vm.count("help-module")) {
     } else if (s == "backend") {
         cout << backend;
     } else {
-        cout << "Unknown module '" 
+        cout << "Unknown module '"
              << s << "' in the --help-module option\n";
         return 1;
     }
@@ -243,8 +243,8 @@ if (vm.count("help-module")) {
 }
 if (vm.count("num-threads")) {
     cout << "The 'num-threads' options was set to "
-         << vm["num-threads"].as<int>() << "\n";            
-}                           
+         << vm["num-threads"].as<int>() << "\n";
+}
 ]]></programlisting>
       When parsing the command line, all options are allowed. The "--help"
       message, however, does not include the "Backend options" group -- the
@@ -253,7 +253,7 @@ if (vm.count("num-threads")) {
       option. The complete example can be found in the
       "example/option_groups.cpp" file.
     </para>
-  
+
   </section>
 
   <section>
@@ -276,7 +276,7 @@ public:
 };
 ]]></programlisting> and then overload the <code>validate</code> function:
 <programlisting><![CDATA[
-void validate(boost::any& v, 
+void validate(boost::any& v,
               const std::vector<std::string>& values,
               magic_number* target_type, int)
 {
@@ -290,16 +290,16 @@ void validate(boost::any& v,
     // one string, it's an error, and exception will be thrown.
     const string& s = validators::get_single_string(values);
 
-    // Do regex match and convert the interesting part to 
+    // Do regex match and convert the interesting part to
     // int.
     smatch match;
     if (regex_match(s, match, r)) {
         v = any(magic_number(lexical_cast<int>(match[1])));
     } else {
         throw validation_error(validation_error::invalid_option_value);
-    }        
+    }
 }
-]]>        
+]]>
 </programlisting>The function takes four parameters. The first is the storage
       for the value, and in this case is either empty or contains an instance of
       the <code>magic_number</code> class. The second is the list of strings
@@ -372,7 +372,7 @@ void validate(boost::any& v,
 locale::global(locale(""));
       </programlisting>
       which would set up the conversion facet according to the user's selected
-      locale. 
+      locale.
     </para>
 
     <para>It's wise to check the status of the C++ locale support on your
@@ -402,37 +402,37 @@ $ export LC_CTYPE=ru_RU.KOI8-R
     <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 
+      <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 
+      <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> 
+      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();      
+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 
+
+      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 
+      <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>     
-            
+
+      </para>
+
     </section>
 
 </section>
diff --git a/example/options_description.cpp b/example/options_description.cpp
index d7ef4ce..e9ad2a6 100644
--- a/example/options_description.cpp
+++ b/example/options_description.cpp
@@ -18,7 +18,7 @@ using namespace std;
 template<class T>
 ostream& operator<<(ostream& os, const vector<T>& v)
 {
-    copy(v.begin(), v.end(), ostream_iterator<T>(os, " ")); 
+    copy(v.begin(), v.end(), ostream_iterator<T>(os, " "));
     return os;
 }
 
@@ -30,26 +30,26 @@ int main(int ac, char* av[])
         po::options_description desc("Allowed options");
         desc.add_options()
             ("help", "produce help message")
-            ("optimization", po::value<int>(&opt)->default_value(10), 
+            ("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,I", po::value< vector<string> >(),
                   "include path")
             ("input-file", po::value< vector<string> >(), "input file")
         ;
 
         po::positional_options_description p;
         p.add("input-file", -1);
-        
+
         po::variables_map vm;
         po::store(po::command_line_parser(ac, av).
                   options(desc).positional(p).run(), vm);
         po::notify(vm);
-    
+
         if (vm.count("help")) {
             cout << "Usage: options_description [options]\n";
             cout << desc;
@@ -58,13 +58,13 @@ int main(int ac, char* av[])
 
         if (vm.count("include-path"))
         {
-            cout << "Include paths are: " 
+            cout << "Include paths are: "
                  << vm["include-path"].as< vector<string> >() << "\n";
         }
 
         if (vm.count("input-file"))
         {
-            cout << "Input files are: " 
+            cout << "Input files are: "
                  << vm["input-file"].as< vector<string> >() << "\n";
         }
 
@@ -73,14 +73,14 @@ int main(int ac, char* av[])
                  << "\n";
         }
 
-        cout << "Optimization level is " << opt << "\n";                
+        cout << "Optimization level is " << opt << "\n";
 
-        cout << "Listen port is " << portnum << "\n";                
+        cout << "Listen port is " << portnum << "\n";
     }
     catch(std::exception& e)
     {
         cout << e.what() << "\n";
         return 1;
-    }    
+    }
     return 0;
 }
diff --git a/src/variables_map.cpp b/src/variables_map.cpp
index caf354e..9a6c506 100644
--- a/src/variables_map.cpp
+++ b/src/variables_map.cpp
@@ -17,12 +17,12 @@ namespace boost { namespace program_options {
 
     using namespace std;
 
-    // First, performs semantic actions for 'oa'. 
-    // Then, stores in 'm' all options that are defined in 'desc'. 
-    BOOST_PROGRAM_OPTIONS_DECL 
+    // First, performs semantic actions for 'oa'.
+    // Then, stores in 'm' all options that are defined in 'desc'.
+    BOOST_PROGRAM_OPTIONS_DECL
     void store(const parsed_options& options, variables_map& xm,
                bool utf8)
-    {       
+    {
         // TODO: what if we have different definition
         // for the same option name during different calls
         // 'store'.
@@ -49,7 +49,7 @@ namespace boost { namespace program_options {
             for (i = 0; i < options.options.size(); ++i) {
 
                 option_name = options.options[i].string_key;
-                original_token = options.options[i].original_tokens.size() ? 
+                original_token = options.options[i].original_tokens.size() ?
                                 options.options[i].original_tokens[0] :
                                 option_name;
                 // Skip positional options without name
@@ -59,7 +59,7 @@ namespace boost { namespace program_options {
                 // 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), 
+                // to variables map (lacking any information about paring),
                 // so just ignore them.
                 if (options.options[i].unregistered)
                     continue;
@@ -68,21 +68,21 @@ namespace boost { namespace program_options {
                 if (xm.m_final.count(option_name))
                     continue;
 
-                string original_token = options.options[i].original_tokens.size() ? 
+                string original_token = options.options[i].original_tokens.size() ?
                                         options.options[i].original_tokens[0]     : "";
-                const option_description& d = desc.find(option_name, false, 
+                const option_description& d = desc.find(option_name, false,
                                                         false, false);
 
-                variable_value& v = m[option_name];            
+                variable_value& v = m[option_name];
                 if (v.defaulted()) {
                     // Explicit assignment here erases defaulted value
                     v = variable_value();
                 }
-                
+
                 d.semantic()->parse(v.value(), options.options[i].value, utf8);
 
                 v.m_value_semantic = d.semantic();
-                
+
                 // The option is not composing, and the value is explicitly
                 // provided. Ignore values of this option for subsequent
                 // calls to 'store'. We store this to a temporary set,
@@ -91,7 +91,7 @@ namespace boost { namespace program_options {
                 if (!d.semantic()->is_composing())
                     new_final.insert(option_name);
             }
-        } 
+        }
 #ifndef BOOST_NO_EXCEPTIONS
         catch(error_with_option_name& e)
         {
@@ -102,8 +102,8 @@ namespace boost { namespace program_options {
 #endif
         xm.m_final.insert(new_final.begin(), new_final.end());
 
-        
-        
+
+
         // Second, apply default values and store required options.
         const vector<shared_ptr<option_description> >& all = desc.options();
         for(i = 0; i < all.size(); ++i)
@@ -112,21 +112,21 @@ namespace boost { namespace program_options {
             string key = d.key("");
             // FIXME: this logic relies on knowledge of option_description
             // internals.
-            // The 'key' is empty if options description contains '*'. 
-            // In that 
+            // The 'key' is empty if options description contains '*'.
+            // In that
             // case, default value makes no sense at all.
             if (key.empty())
             {
                 continue;
             }
             if (m.count(key) == 0) {
-            
+
                 boost::any def;
                 if (d.semantic()->apply_default(def)) {
                     m[key] = variable_value(def, true);
                     m[key].m_value_semantic = d.semantic();
                 }
-            }  
+            }
 
             // add empty value if this is an required option
             if (d.semantic()->is_required()) {
@@ -142,16 +142,16 @@ namespace boost { namespace program_options {
         }
     }
 
-    BOOST_PROGRAM_OPTIONS_DECL 
+    BOOST_PROGRAM_OPTIONS_DECL
     void store(const wparsed_options& options, variables_map& m)
     {
         store(options.utf8_encoded_options, m, true);
     }
 
-    BOOST_PROGRAM_OPTIONS_DECL 
+    BOOST_PROGRAM_OPTIONS_DECL
     void notify(variables_map& vm)
-    {        
-        vm.notify();               
+    {
+        vm.notify();
     }
 
     abstract_variables_map::abstract_variables_map()
@@ -163,7 +163,7 @@ namespace boost { namespace program_options {
     : m_next(next)
     {}
 
-    const variable_value& 
+    const variable_value&
     abstract_variables_map::operator[](const std::string& name) const
     {
         const variable_value& v = get(name);
@@ -179,7 +179,7 @@ namespace boost { namespace program_options {
         }
     }
 
-    void 
+    void
     abstract_variables_map::next(abstract_variables_map* next)
     {
         m_next = next;
@@ -209,7 +209,7 @@ namespace boost { namespace program_options {
         else
             return i->second;
     }
-    
+
     void
     variables_map::notify()
     {
@@ -221,29 +221,29 @@ namespace boost { namespace program_options {
             const string& opt = r->first;
             const string& display_opt = r->second;
             map<string, variable_value>::const_iterator iter = find(opt);
-            if (iter == end() || iter->second.empty()) 
+            if (iter == end() || iter->second.empty())
             {
                 boost::throw_exception(required_option(display_opt));
-            
+
             }
         }
 
         // Lastly, run notify actions.
-        for (map<string, variable_value>::iterator k = begin(); 
-             k != end(); 
-             ++k) 
+        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,
+               defined. Do not 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 
+               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());
-        }               
+        }
     }
-    
+
 }}

From 7542447620665e8eb98e7bbaf16271462405cb9b Mon Sep 17 00:00:00 2001
From: Jurko <jurko.gospodnetic@pke.hr>
Date: Tue, 2 Dec 2014 01:41:01 +0100
Subject: [PATCH 14/26] fix documentation typos

environmemt --> environment
does not handles --> does not handle
---
 doc/howto.xml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/doc/howto.xml b/doc/howto.xml
index b573d46..45ff25b 100644
--- a/doc/howto.xml
+++ b/doc/howto.xml
@@ -382,7 +382,7 @@ locale::global(locale(""));
           <para>Go the the "test" directory and build the "test_convert" binary.</para>
         </listitem>
         <listitem>
-          <para>Set some non-ascii locale in the environmemt. On Linux, one can
+          <para>Set some non-ascii locale in the environment. On Linux, one can
           run, for example: <screen>
 $ export LC_CTYPE=ru_RU.KOI8-R
 </screen>
@@ -426,7 +426,7 @@ parsed_options parsed =
       <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:
+      Say, if your code handles a few options, but does not handle 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>

From 145e5728d756a3a9e5f5c778d64b92cdb918ff30 Mon Sep 17 00:00:00 2001
From: Vladimir Prus <vladimir@codesourcery.com>
Date: Tue, 30 Dec 2014 08:49:02 +0300
Subject: [PATCH 15/26] Unbreak cmdline_test.

There was a k-vs-j loop error introduced by a prior comment.
---
 test/cmdline_test.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/cmdline_test.cpp b/test/cmdline_test.cpp
index 23c15e4..e1b70c1 100644
--- a/test/cmdline_test.cpp
+++ b/test/cmdline_test.cpp
@@ -141,7 +141,7 @@ void test_cmdline(const char* syntax,
                     for (size_t k = 0; k < opt.value.size(); ++k) {
                         if (k != 0)
                             result += "-";
-                        result += opt.value[j];
+                        result += opt.value[k];
                     }                    
                 }
             }

From 88dea3c6fdea8c9ea894911897b1770599c383e4 Mon Sep 17 00:00:00 2001
From: Michael John Decker <mdecker6@kent.edu>
Date: Mon, 29 Dec 2014 19:15:53 -0500
Subject: [PATCH 16/26] Stop options with implicit value from consuming
 separate tokens.

The current documentation states that if an option has implicit
value, it will only consume adjacent token.
---
 include/boost/program_options/value_semantic.hpp | 10 +++++++++-
 src/cmdline.cpp                                  |  3 +++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/include/boost/program_options/value_semantic.hpp b/include/boost/program_options/value_semantic.hpp
index 57bb2ac..bb377a2 100644
--- a/include/boost/program_options/value_semantic.hpp
+++ b/include/boost/program_options/value_semantic.hpp
@@ -39,6 +39,11 @@ namespace boost { namespace program_options {
             should be present on the command line. */
         virtual unsigned max_tokens() const = 0;
 
+        /** Returns true if the option should only take adjacent token,
+            not one from further command-line arguments.
+        */
+        virtual bool adjacent_tokens_only() const = 0;
+
         /** Returns true if values from different sources should be composed.
             Otherwise, value from the first source is used and values from
             other sources are discarded.
@@ -49,7 +54,7 @@ namespace boost { namespace program_options {
 
         */
         virtual bool is_required() const = 0;
-        
+
         /** Parses a group of tokens that specify a value of option.
             Stores the result in 'value_store', using whatever representation
             is desired. May be be called several times if value of the same
@@ -135,6 +140,7 @@ namespace boost { namespace program_options {
 
         unsigned min_tokens() const;
         unsigned max_tokens() const;
+        bool adjacent_tokens_only() const { return false; }
 
         bool is_composing() const { return false; }
 
@@ -322,6 +328,8 @@ namespace boost { namespace program_options {
             }
         }
 
+        bool adjacent_tokens_only() const { return !m_implicit_value.empty(); }
+
         bool is_required() const { return m_required; }
 
         /** Creates an instance of the 'validator' class and calls
diff --git a/src/cmdline.cpp b/src/cmdline.cpp
index d7910c2..49c7c93 100644
--- a/src/cmdline.cpp
+++ b/src/cmdline.cpp
@@ -313,6 +313,9 @@ namespace boost { namespace program_options { namespace detail {
             if (!xd)
                 continue;
 
+            if (xd->semantic()->adjacent_tokens_only())
+                continue;
+
             unsigned min_tokens = xd->semantic()->min_tokens();
             unsigned max_tokens = xd->semantic()->max_tokens();
             if (min_tokens < max_tokens && opt.value.size() < max_tokens)

From 0c01e9aadc4f6132d7a88742a6198c14843a4928 Mon Sep 17 00:00:00 2001
From: Michael John Decker <mdecker6@kent.edu>
Date: Tue, 30 Dec 2014 12:22:13 -0500
Subject: [PATCH 17/26] Add testing for implicit_values and non-consuming of
 separate tokens.

---
 test/cmdline_test.cpp | 53 +++++++++++++++++++++++++++++++++++--------
 1 file changed, 44 insertions(+), 9 deletions(-)

diff --git a/test/cmdline_test.cpp b/test/cmdline_test.cpp
index e1b70c1..e70d604 100644
--- a/test/cmdline_test.cpp
+++ b/test/cmdline_test.cpp
@@ -63,7 +63,8 @@ struct test_case {
    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(options_description& desc,
+                  positional_options_description & m_positional,
                   const char* syntax)
 {
    
@@ -77,8 +78,8 @@ void apply_syntax(options_description& desc,
             v = value<string>();
             s.resize(s.size()-1);
         } else if (*(s.end()-1) == '?') {
-            //v = value<string>()->implicit();
-            v = value<string>();
+            v = value<string>()->implicit_value("bar");
+            m_positional.add("positional", -1);
             s.resize(s.size()-1);
         } else if (*(s.end()-1) == '*') {
             v = value<vector<string> >()->multitoken();
@@ -113,12 +114,14 @@ void test_cmdline(const char* syntax,
             }
         }
         options_description desc;
-        apply_syntax(desc, syntax);
+        positional_options_description m_positional;
+        apply_syntax(desc, m_positional, syntax);
 
         cmdline cmd(xinput);
         cmd.style(style);
         cmd.set_options_description(desc);
-
+        if(m_positional.max_total_count())
+            cmd.set_positional_options(m_positional);
 
         string result;
         int status = 0;
@@ -130,7 +133,9 @@ void test_cmdline(const char* syntax,
             {
                 option opt = options[j];
 
-                if (opt.position_key != -1) {
+                if (opt.position_key != -1
+                    && (m_positional.max_total_count() == 0 || (size_t)opt.position_key >= m_positional.max_total_count()
+                     || m_positional.name_for_position(opt.position_key) != "positional")) {
                     if (!result.empty())
                         result += " ";
                     result += opt.value[0];
@@ -228,7 +233,7 @@ void test_long_options()
         {"--giz", s_success, "Giz:"},
         {0, 0, 0}
     };
-    test_cmdline("foo bar= baz? Giz", style, test_cases4);
+    test_cmdline("foo bar= Giz", style, test_cases4);
 }
 
 void test_short_options()
@@ -348,7 +353,7 @@ void test_disguised_long()
         {"-bee=x -by", s_success, "bee:x bee:y"},
         {0, 0, 0}
     };
-    test_cmdline("foo,f goo,g= bee,b?", style, test_cases1);
+    test_cmdline("foo,f goo,g= bee,b=", style, test_cases1);
 
     style = cmdline::style_t(style | allow_slash_for_short);
     test_case test_cases2[] = {
@@ -356,7 +361,7 @@ void test_disguised_long()
         {"/goo=x", s_success, "goo:x"},
         {0, 0, 0}
     };
-    test_cmdline("foo,f goo,g= bee,b?", style, test_cases2);
+    test_cmdline("foo,f goo,g=", style, test_cases2);
 }
 
 void test_guessing()
@@ -607,6 +612,35 @@ void test_unregistered()
     // It's not clear yet, so I'm leaving the decision till later.
 }
 
+void test_implicit_value()
+{
+    using namespace command_line_style;
+    cmdline::style_t style;
+
+    style = cmdline::style_t(
+        allow_long | long_allow_adjacent
+        );
+
+    test_case test_cases1[] = {
+        {"--foo bar", s_success, "foo: positional:bar"},
+        {"--foo=bar foobar", s_success, "foo:bar positional:foobar"},
+        {0, 0, 0}
+    };
+
+    test_cmdline("positional= foo?", style, test_cases1);
+
+    style = cmdline::style_t(
+        allow_short | allow_dash_for_short 
+        | short_allow_adjacent);
+
+    test_case test_cases2[] = {
+        {"-f bar", s_success, "-f: positional:bar"},
+        {"-fbar foobar", s_success, "-f:bar positional:foobar"},
+        {0, 0, 0}
+    };
+    test_cmdline("positional= ,f?", style, test_cases2);
+}
+
 int main(int /*ac*/, char** /*av*/)
 {
     test_long_options();
@@ -619,6 +653,7 @@ int main(int /*ac*/, char** /*av*/)
     test_additional_parser();
     test_style_parser();
     test_unregistered();
+    test_implicit_value();
 
     return 0;
 }

From 0f9793e369d0068fb65f812907c166c71fa5f2e4 Mon Sep 17 00:00:00 2001
From: Vladimir Prus <vladimir@codesourcery.com>
Date: Sun, 15 Feb 2015 21:41:48 +0300
Subject: [PATCH 18/26] Make option_groups.cpp compile.

---
 example/option_groups.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/example/option_groups.cpp b/example/option_groups.cpp
index 834802c..63e1fca 100644
--- a/example/option_groups.cpp
+++ b/example/option_groups.cpp
@@ -29,9 +29,9 @@ using namespace boost::program_options;
 
 #include <iostream>
 #include <fstream>
+#include <exception>
 using namespace std;
 
-
 int main(int ac, char* av[])
 {
     try {
@@ -39,7 +39,7 @@ int main(int ac, char* av[])
         options_description general("General options");
         general.add_options()
             ("help", "produce a help message")
-            ("help-module", value<string>()->implicit(),
+            ("help-module", value<string>(),
                 "produce a help for a given module")
             ("version", "output the version number")
             ;
@@ -91,7 +91,7 @@ int main(int ac, char* av[])
                  << vm["num-threads"].as<int>() << "\n";            
         }                           
     }
-    catch(exception& e) {
+    catch(std::exception& e) {
         cout << e.what() << "\n";
     }
 }

From c724b800a8d8d588d36c2fa347634f5db61b8c4d Mon Sep 17 00:00:00 2001
From: Lauri Nurmi <lanurmi@iki.fi>
Date: Sat, 28 Mar 2015 23:08:51 +0200
Subject: [PATCH 19/26] Fix spelling of "occurrence" where appropriate.

---
 doc/rationale               | 8 ++++----
 doc/rationale.dox           | 2 +-
 src/options_description.cpp | 2 +-
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/doc/rationale b/doc/rationale
index b597b78..03192a9 100644
--- a/doc/rationale
+++ b/doc/rationale
@@ -4,12 +4,12 @@ implement generic composition classes. The former was choosen,
 mostly because of simplicity.
 
 There were two implementation approaches for multiple option
-occurences in options_and_arguments. First is store them
+occurrences in options_and_arguments. First is store them
 separately. The advantage is that it's easy to obtain all
-occurences before certain position on command line. The
+occurrences before certain position on command line. The
 disadvantage is that we cannot return a reference to 
 vector<vector<string> > in get_all_values. It was considered
 that if support for position-dependent options is to be
-added, then we're be mostly interested in occurences of 
+added, then we're be mostly interested in occurrences of
 a single option that were before some point. That's possible
-with vector<vector<string> > storage.
\ No newline at end of file
+with vector<vector<string> > storage.
diff --git a/doc/rationale.dox b/doc/rationale.dox
index bc21507..388bba2 100644
--- a/doc/rationale.dox
+++ b/doc/rationale.dox
@@ -81,7 +81,7 @@
 
     @section help_handling Handling of --help
 
-    It was suggested by Gennadiy Rozental that occurence of <tt>--help</tt>
+    It was suggested by Gennadiy Rozental that occurrence of <tt>--help</tt>
     on command line results in throwing an exception. Actually, the 
     &quot;special&quot; option must have been configurable. This was not 
     implemented, because applications might reasonable want to process
diff --git a/src/options_description.cpp b/src/options_description.cpp
index 9d51ce9..6592a5d 100644
--- a/src/options_description.cpp
+++ b/src/options_description.cpp
@@ -8,7 +8,7 @@
 #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_occurrences class
 // should move that to a separate headers.
 #include <boost/program_options/parsers.hpp>
 

From bae408095f296da50a5fd1bac1e24b73125ba690 Mon Sep 17 00:00:00 2001
From: Zoey Greer <tempozrene@gmail.com>
Date: Wed, 25 Feb 2015 10:23:49 -0500
Subject: [PATCH 20/26] Explicitly initialize m_implicit

m_implicit was previously uninitialized in this constructor, leading to possibly inconsistent functionality. Instead, we now initialize it to false. This issue is related to Coverity CID10559 and was uncovered by Coverity.
---
 include/boost/program_options/value_semantic.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/boost/program_options/value_semantic.hpp b/include/boost/program_options/value_semantic.hpp
index bb377a2..9bc2c3d 100644
--- a/include/boost/program_options/value_semantic.hpp
+++ b/include/boost/program_options/value_semantic.hpp
@@ -191,8 +191,8 @@ namespace boost { namespace program_options {
             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), m_required(false)
         {} 
 
         /** Specifies default value, which will be used

From 2c4d25a04b0f2d5789e85bfb090a364e9fb81f70 Mon Sep 17 00:00:00 2001
From: Zoey Greer <tempozrene@gmail.com>
Date: Wed, 25 Feb 2015 12:36:38 -0500
Subject: [PATCH 21/26] Value-initialize m_desc

Value-initialize m_desc (to NULL) in this constructor to avoid uninitialized memory situations. This issue is related to Coverity CID12523 and was uncovered by Coverity.
---
 include/boost/program_options/detail/parsers.hpp | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/include/boost/program_options/detail/parsers.hpp b/include/boost/program_options/detail/parsers.hpp
index af240c6..8c5b02e 100644
--- a/include/boost/program_options/detail/parsers.hpp
+++ b/include/boost/program_options/detail/parsers.hpp
@@ -40,7 +40,8 @@ namespace boost { namespace program_options {
     : detail::cmdline(
         // Explicit template arguments are required by gcc 3.3.1 
         // (at least mingw version), and do no harm on other compilers.
-        to_internal(detail::make_vector<charT, const charT* const*>(argv+1, argv+argc+!argc)))
+        to_internal(detail::make_vector<charT, const charT* const*>(argv+1, argv+argc+!argc))),
+        m_desc()
     {}
 
     

From 0efb385e99cc3d611aa40e0ff4b321622c90f289 Mon Sep 17 00:00:00 2001
From: Marcel Raad <MarcelRaad@users.noreply.github.com>
Date: Mon, 26 Jan 2015 14:56:06 +0100
Subject: [PATCH 22/26] Protect against max macro

This fixes compilation for MSVC in the case when NOMINMAX is not defined and the program_options include appears after the windows.h include.
---
 include/boost/program_options/value_semantic.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/program_options/value_semantic.hpp b/include/boost/program_options/value_semantic.hpp
index 9bc2c3d..16e8d65 100644
--- a/include/boost/program_options/value_semantic.hpp
+++ b/include/boost/program_options/value_semantic.hpp
@@ -320,7 +320,7 @@ namespace boost { namespace program_options {
 
         unsigned max_tokens() const {
             if (m_multitoken) {
-                return std::numeric_limits<unsigned>::max();
+                return std::numeric_limits<unsigned>::max BOOST_PREVENT_MACRO_SUBSTITUTION();
             } else if (m_zero_tokens) {
                 return 0;
             } else {

From 6feeeb3b92c551434b571bbb7d6faebbee562278 Mon Sep 17 00:00:00 2001
From: Minmin Gong <gongminmin@msn.com>
Date: Mon, 27 Apr 2015 22:52:38 -0700
Subject: [PATCH 23/26] Using type_index to avoid RTTIs in program_options.
 (fixes #10347)

---
 .../boost/program_options/value_semantic.hpp   | 18 ++++++++++++------
 test/Jamfile.v2                                |  1 +
 test/options_description_test.cpp              |  6 ++++--
 3 files changed, 17 insertions(+), 8 deletions(-)

diff --git a/include/boost/program_options/value_semantic.hpp b/include/boost/program_options/value_semantic.hpp
index 16e8d65..00ea8cb 100644
--- a/include/boost/program_options/value_semantic.hpp
+++ b/include/boost/program_options/value_semantic.hpp
@@ -12,11 +12,11 @@
 #include <boost/any.hpp>
 #include <boost/function/function1.hpp>
 #include <boost/lexical_cast.hpp>
+#include <boost/type_index.hpp>
 
 
 #include <string>
 #include <vector>
-#include <typeinfo>
 #include <limits>
 
 namespace boost { namespace program_options {
@@ -163,6 +163,7 @@ namespace boost { namespace program_options {
         bool m_zero_tokens;
     };
 
+#ifndef BOOST_NO_RTTI
     /** 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
@@ -174,17 +175,20 @@ namespace boost { namespace program_options {
     public:
         // Returns the type of the value described by this
         // object.
-        virtual const std::type_info& value_type() const = 0;
+        virtual const boost::typeindex::type_info& value_type() const = 0;
         // Not really needed, since deletion from this
         // class is silly, but just in case.
         virtual ~typed_value_base() {}
     };
+#endif
 
 
     /** 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>
+#ifndef BOOST_NO_RTTI
+                      , public typed_value_base
+#endif
     {
     public:
         /** Ctor. The 'store_to' parameter tells where to store
@@ -359,10 +363,12 @@ namespace boost { namespace program_options {
 
     public: // typed_value_base overrides
         
-        const std::type_info& value_type() const
+#ifndef BOOST_NO_RTTI
+        const boost::typeindex::type_info& value_type() const
         {
-            return typeid(T);
+            return boost::typeindex::type_id<T>().type_info();
         }
+#endif
         
 
     private:
diff --git a/test/Jamfile.v2 b/test/Jamfile.v2
index e18e008..41b41cf 100644
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@@ -33,6 +33,7 @@ test-suite program_options :
     [ po-test unrecognized_test.cpp ]
     [ po-test required_test.cpp : required_test.cfg ]
     [ po-test exception_txt_test.cpp ]
+    [ run options_description_test.cpp : : : <rtti>off <define>BOOST_NO_RTTI <define>BOOST_NO_TYPEID : options_description_no_rtti_test ]
     ;
         
 exe test_convert : test_convert.cpp ;   
diff --git a/test/options_description_test.cpp b/test/options_description_test.cpp
index d443a7b..695f1d9 100644
--- a/test/options_description_test.cpp
+++ b/test/options_description_test.cpp
@@ -25,15 +25,17 @@ void test_type()
         ("bar", value<string>(), "")
         ;
     
+#ifndef BOOST_NO_RTTI
     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));
+    BOOST_CHECK(b->value_type() == boost::typeindex::type_id<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));
+    BOOST_CHECK(b2->value_type() == boost::typeindex::type_id<string>());
+#endif
 }
 
 void test_approximation()

From bd1d0bd861891ec901a30db45bb69d38c684a188 Mon Sep 17 00:00:00 2001
From: Vladimir Prus <vladimir@codesourcery.com>
Date: Thu, 30 Apr 2015 22:15:31 +0300
Subject: [PATCH 24/26] Put back std::type_info.

Since typed_value_base is only used with RTTI on, there's
no need to avoid std::type_info there.
---
 include/boost/program_options/value_semantic.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/boost/program_options/value_semantic.hpp b/include/boost/program_options/value_semantic.hpp
index 00ea8cb..6e078f8 100644
--- a/include/boost/program_options/value_semantic.hpp
+++ b/include/boost/program_options/value_semantic.hpp
@@ -175,7 +175,7 @@ namespace boost { namespace program_options {
     public:
         // Returns the type of the value described by this
         // object.
-        virtual const boost::typeindex::type_info& value_type() const = 0;
+        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() {}
@@ -366,7 +366,7 @@ namespace boost { namespace program_options {
 #ifndef BOOST_NO_RTTI
         const boost::typeindex::type_info& value_type() const
         {
-            return boost::typeindex::type_id<T>().type_info();
+            return typeid(T);
         }
 #endif
         

From 0756d35f8bf84eacd4521a07fdc560bd69d1fdb1 Mon Sep 17 00:00:00 2001
From: Vladimir Prus <vladimir@codesourcery.com>
Date: Fri, 1 May 2015 19:13:38 +0300
Subject: [PATCH 25/26] Remove more unnecessary use of boost::type_index.

---
 include/boost/program_options/value_semantic.hpp | 3 +--
 test/options_description_test.cpp                | 4 ++--
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/include/boost/program_options/value_semantic.hpp b/include/boost/program_options/value_semantic.hpp
index 6e078f8..e8235b7 100644
--- a/include/boost/program_options/value_semantic.hpp
+++ b/include/boost/program_options/value_semantic.hpp
@@ -12,11 +12,10 @@
 #include <boost/any.hpp>
 #include <boost/function/function1.hpp>
 #include <boost/lexical_cast.hpp>
-#include <boost/type_index.hpp>
-
 
 #include <string>
 #include <vector>
+#include <typeinfo>
 #include <limits>
 
 namespace boost { namespace program_options {
diff --git a/test/options_description_test.cpp b/test/options_description_test.cpp
index 695f1d9..42365e9 100644
--- a/test/options_description_test.cpp
+++ b/test/options_description_test.cpp
@@ -29,12 +29,12 @@ void test_type()
     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() == boost::typeindex::type_id<int>());
+    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() == boost::typeindex::type_id<string>());
+    BOOST_CHECK(b2->value_type() == typeid(string));
 #endif
 }
 

From c0cee7f6dab8f1b04ee11b618b6bc6e002ffe456 Mon Sep 17 00:00:00 2001
From: Vladimir Prus <vladimir@codesourcery.com>
Date: Sun, 3 May 2015 21:55:08 +0300
Subject: [PATCH 26/26] Go back to std::type_info in one more place.

---
 include/boost/program_options/value_semantic.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/include/boost/program_options/value_semantic.hpp b/include/boost/program_options/value_semantic.hpp
index e8235b7..be3f108 100644
--- a/include/boost/program_options/value_semantic.hpp
+++ b/include/boost/program_options/value_semantic.hpp
@@ -363,7 +363,7 @@ namespace boost { namespace program_options {
     public: // typed_value_base overrides
         
 #ifndef BOOST_NO_RTTI
-        const boost::typeindex::type_info& value_type() const
+        const std::type_info& value_type() const
         {
             return typeid(T);
         }