Merge from trunk

vprus · vprus · commit c3cb7cf05d59 · 2009-07-11T12:00:18.000Z
[SVN r54884]
diff --git a/example/options_description.cpp b/example/options_description.cpp
@@ -77,7 +77,7 @@ int main(int ac, char* av[])
 
         cout << "Listen port is " << portnum << "\n";                
     }
-    catch(exception& e)
+    catch(std::exception& e)
     {
         cout << e.what() << "\n";
         return 1;
diff --git a/example/regex.cpp b/example/regex.cpp
@@ -94,7 +94,7 @@ int main(int ac, char* av[])
                  << vm["magic"].as<magic_number>().n << "\"\n";
         }
     }
-    catch(exception& e)
+    catch(std::exception& e)
     {
         cout << e.what() << "\n";
     }    
diff --git a/include/boost/program_options/detail/parsers.hpp b/include/boost/program_options/detail/parsers.hpp
@@ -8,6 +8,8 @@
 
 #include <boost/program_options/detail/convert.hpp>
 
+#include <iterator>
+
 namespace boost { namespace program_options {
 
     namespace detail {
diff --git a/include/boost/program_options/detail/value_semantic.hpp b/include/boost/program_options/detail/value_semantic.hpp
@@ -55,13 +55,12 @@ namespace boost { namespace program_options {
         {
             static std::basic_string<charT> empty;
             if (v.size() > 1)
-                throw validation_error("multiple values not allowed");
-            if (v.size() == 1)
+                boost::throw_exception(validation_error("multiple values not allowed"));
+            else if (v.size() == 1)
                 return v.front();
-            else if (allow_empty)
-                return empty;
-            else
-                throw validation_error("at least one value required");
+            else if (!allow_empty)
+              boost::throw_exception(validation_error("at least one value required"));
+            return empty;
         }
 
         /* Throws multiple_occurrences if 'value' is not empty. */
diff --git a/src/cmdline.cpp b/src/cmdline.cpp
@@ -152,7 +152,7 @@ namespace boost { namespace program_options { namespace detail {
             error = "style disallows all characters for short options";
 
         if (error)
-            throw invalid_command_line_style(error);
+            boost::throw_exception(invalid_command_line_style(error));
 
         // Need to check that if guessing and long disguise are enabled
         // -f will mean the same as -foo
@@ -196,24 +196,24 @@ namespace boost { namespace program_options { namespace detail {
 
         if (m_additional_parser)
             style_parsers.push_back(
-                bind(&cmdline::handle_additional_parser, this, _1));
+                boost::bind(&cmdline::handle_additional_parser, this, _1));
 
         if (m_style & allow_long)
             style_parsers.push_back(
-                bind(&cmdline::parse_long_option, this, _1));
+                boost::bind(&cmdline::parse_long_option, this, _1));
 
         if ((m_style & allow_long_disguise))
             style_parsers.push_back(
-                bind(&cmdline::parse_disguised_long_option, this, _1));
+                boost::bind(&cmdline::parse_disguised_long_option, this, _1));
 
         if ((m_style & allow_short) && (m_style & allow_dash_for_short))
             style_parsers.push_back(
-                bind(&cmdline::parse_short_option, this, _1));
+                boost::bind(&cmdline::parse_short_option, this, _1));
 
         if ((m_style & allow_short) && (m_style & allow_slash_for_short))
-            style_parsers.push_back(bind(&cmdline::parse_dos_option, this, _1));
+            style_parsers.push_back(boost::bind(&cmdline::parse_dos_option, this, _1));
 
-        style_parsers.push_back(bind(&cmdline::parse_terminator, this, _1));
+        style_parsers.push_back(boost::bind(&cmdline::parse_terminator, this, _1));
 
         vector<option> result;
         while(!args.empty())
@@ -326,8 +326,8 @@ namespace boost { namespace program_options { namespace detail {
                 if (opt.position_key != -1) {
                     if (position >= m_positional->max_total_count())
                     {
-                        throw too_many_positional_options_error(
-                            "too many positional options");
+                        boost::throw_exception(too_many_positional_options_error(
+                                               "too many positional options"));
                     }
                     opt.string_key = m_positional->name_for_position(position);
                     ++position;
@@ -380,8 +380,8 @@ namespace boost { namespace program_options { namespace detail {
         if (present_tokens >= min_tokens)
         {
             if (!opt.value.empty() && max_tokens == 0) {
-                throw invalid_command_line_syntax(opt.string_key,
-                    invalid_command_line_syntax::extra_parameter);                                                                
+                boost::throw_exception(invalid_command_line_syntax(opt.string_key,
+                                             invalid_command_line_syntax::extra_parameter));
             }
             
             // If an option wants, at minimum, N tokens, we grab them
@@ -406,8 +406,8 @@ namespace boost { namespace program_options { namespace detail {
         }
         else
         {
-            throw invalid_command_line_syntax(opt.string_key,
-                invalid_command_line_syntax::missing_parameter); 
+            boost::throw_exception(invalid_command_line_syntax(opt.string_key,
+                                            invalid_command_line_syntax::missing_parameter)); 
 
         }
     }
@@ -427,8 +427,8 @@ namespace boost { namespace program_options { namespace detail {
                 name = tok.substr(2, p-2);
                 adjacent = tok.substr(p+1);
                 if (adjacent.empty())
-                    throw invalid_command_line_syntax(name,
-                      invalid_command_line_syntax::empty_adjacent_parameter);
+                    boost::throw_exception( invalid_command_line_syntax(name,
+                                                      invalid_command_line_syntax::empty_adjacent_parameter));
             }
             else
             {
diff --git a/src/parsers.cpp b/src/parsers.cpp
@@ -67,10 +67,16 @@ namespace boost { namespace program_options {
             woption result;
             result.string_key = opt.string_key;
             result.position_key = opt.position_key;
+            result.unregistered = opt.unregistered;
             
             std::transform(opt.value.begin(), opt.value.end(),
                            back_inserter(result.value),
-                           bind(from_utf8, _1));
+                           boost::bind(from_utf8, _1));
+
+            std::transform(opt.original_tokens.begin(), 
+                           opt.original_tokens.end(),
+                           back_inserter(result.original_tokens),
+                           boost::bind(from_utf8, _1));
             return result;
         }
     }
diff --git a/src/variables_map.cpp b/src/variables_map.cpp
@@ -74,11 +74,13 @@ namespace boost { namespace program_options {
             try {
                 d.semantic()->parse(v.value(), options.options[i].value, utf8);
             }
+#ifndef BOOST_NO_EXCEPTIONS
             catch(validation_error& e)
             {
                 e.set_option_name(name);
                 throw;
             }
+#endif
             v.m_value_semantic = d.semantic();
             
             // The option is not composing, and the value is explicitly
@@ -133,7 +135,16 @@ namespace boost { namespace program_options {
              k != vm.end(); 
              ++k) 
         {
-            k->second.m_value_semantic->notify(k->second.value());
+            /* Users might wish to use variables_map to store their own values
+               that are not parsed, and therefore will not have value_semantics
+               defined. Do no crash on such values. In multi-module programs,
+               one module might add custom values, and the 'notify' function
+               will be called after that, so we check that value_sematics is 
+               not NULL. See:
+                   https://svn.boost.org/trac/boost/ticket/2782
+            */
+            if (k->second.m_value_semantic)
+                k->second.m_value_semantic->notify(k->second.value());
         }               
     }
 
diff --git a/test/unicode_test.cpp b/test/unicode_test.cpp
@@ -34,9 +34,13 @@ void test_unicode_to_unicode()
     args.push_back(L"--foo=\x044F");
 
     variables_map vm;
-    store(wcommand_line_parser(args).options(desc).run(), vm);
+    basic_parsed_options<wchar_t> parsed = 
+        wcommand_line_parser(args).options(desc).run();
+    store(parsed, vm);
 
-    BOOST_CHECK(vm["foo"].as<wstring>() == L"\x044F");           
+    BOOST_CHECK(vm["foo"].as<wstring>() == L"\x044F");
+    BOOST_CHECK(parsed.options[0].original_tokens.size() == 1);
+    BOOST_CHECK(parsed.options[0].original_tokens[0] == L"--foo=\x044F");
 }
 
 // Test that unicode input is property converted into

Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ int main(int ac, char* av[])`
`77`	`77`
`78`	`78`	`cout << "Listen port is " << portnum << "\n";`
`79`	`79`	`}`
`80`		`- catch(exception& e)`
	`80`	`+ catch(std::exception& e)`
`81`	`81`	`{`
`82`	`82`	`cout << e.what() << "\n";`
`83`	`83`	`return 1;`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ int main(int ac, char* av[])`
`94`	`94`	`<< vm["magic"].as<magic_number>().n << "\"\n";`
`95`	`95`	`}`
`96`	`96`	`}`
`97`		`- catch(exception& e)`
	`97`	`+ catch(std::exception& e)`
`98`	`98`	`{`
`99`	`99`	`cout << e.what() << "\n";`
`100`	`100`	`}`
Original file line number	Diff line number	Diff line change
`@@ -74,11 +74,13 @@ namespace boost { namespace program_options {`
`74`	`74`	`try {`
`75`	`75`	`d.semantic()->parse(v.value(), options.options[i].value, utf8);`
`76`	`76`	`}`
	`77`	`+#ifndef BOOST_NO_EXCEPTIONS`
`77`	`78`	`catch(validation_error& e)`
`78`	`79`	`{`
`79`	`80`	`e.set_option_name(name);`
`80`	`81`	`throw;`
`81`	`82`	`}`
	`83`	`+#endif`
`82`	`84`	`v.m_value_semantic = d.semantic();`
`83`	`85`
`84`	`86`	`// The option is not composing, and the value is explicitly`
`@@ -133,7 +135,16 @@ namespace boost { namespace program_options {`
`133`	`135`	`k != vm.end();`
`134`	`136`	`++k)`
`135`	`137`	`{`
`136`		`- k->second.m_value_semantic->notify(k->second.value());`
	`138`	`+ /* Users might wish to use variables_map to store their own values`
	`139`	`+ that are not parsed, and therefore will not have value_semantics`
	`140`	`+ defined. Do no crash on such values. In multi-module programs,`
	`141`	`+ one module might add custom values, and the 'notify' function`
	`142`	`+ will be called after that, so we check that value_sematics is`
	`143`	`+ not NULL. See:`
	`144`	`+ https://svn.boost.org/trac/boost/ticket/2782`
	`145`	`+ */`
	`146`	`+ if (k->second.m_value_semantic)`
	`147`	`+ k->second.m_value_semantic->notify(k->second.value());`
`137`	`148`	`}`
`138`	`149`	`}`
`139`	`150`