Ticket #4015: boost_program_options_gcc_warning_cleanup.diff

boost/program_options/detail/parsers.hpp

@@ -29 +29 @@
     template<class charT>
     basic_command_line_parser<charT>::
     basic_command_line_parser(const std::vector<
-                              std::basic_string<charT> >& args)
-       : detail::cmdline(to_internal(args))
+                              std::basic_string<charT> >& p_args)
+       : detail::cmdline(to_internal(p_args))
     {}
 
 
@@ -64 +64 @@
 
     template<class charT>
     basic_command_line_parser<charT>& 
-    basic_command_line_parser<charT>::style(int style)
+    basic_command_line_parser<charT>::style(int p_style)
     {
-        detail::cmdline::style(style);
+        detail::cmdline::style(p_style);
         return *this;
     }
 

boost/program_options/detail/value_semantic.hpp

@@ -143 +143 @@
                    a validator for class T, we use it even
                    when parsing vector<T>.  */
                 boost::any a;
-                std::vector<std::basic_string<charT> > v;
-                v.push_back(s[i]);
-                validate(a, v, (T*)0, 0);                
+                std::vector<std::basic_string<charT> > cv;
+                cv.push_back(s[i]);
+                validate(a, cv, (T*)0, 0);                
                 tv->push_back(boost::any_cast<T>(a));
             }
             catch(const bad_lexical_cast& /*e*/) {

boost/program_options/errors.hpp

@@ -20 +20 @@
     /** Base class for all errors in the library. */
     class BOOST_PROGRAM_OPTIONS_DECL error : public std::logic_error {
     public:
-        error(const std::string& what) : std::logic_error(what) {}
+        error(const std::string& p_what) : std::logic_error(p_what) {}
     };
 
     class BOOST_PROGRAM_OPTIONS_DECL invalid_syntax : public error {
@@ -78 +78 @@
     class BOOST_PROGRAM_OPTIONS_DECL ambiguous_option : public error {
     public:
         ambiguous_option(const std::string& name, 
-                         const std::vector<std::string>& alternatives)
+                         const std::vector<std::string>& p_alternatives)
         : error(std::string("ambiguous option ").append(name))
-        , m_alternatives(alternatives)
+        , m_alternatives(p_alternatives)
         , m_option_name(name)
         {}
 

boost/program_options/options_description.hpp

@@ -247 +247 @@
     /** Class thrown when duplicate option description is found. */
     class BOOST_PROGRAM_OPTIONS_DECL duplicate_option_error : public error {
     public:
-        duplicate_option_error(const std::string& what) : error(what) {}
+        duplicate_option_error(const std::string& p_what) : error(p_what) {}
     };
 }}
 

boost/program_options/parsers.hpp

@@ -31 +31 @@
     template<class charT>
     class basic_parsed_options {
     public:
-        explicit basic_parsed_options(const options_description* description) 
-        : description(description) {}
+        explicit basic_parsed_options(const options_description* p_description) 
+        : description(p_description) {}
         /** Options found in the source. */
         std::vector< basic_option<charT> > options;
         /** Options description that was used for parsing. 

boost/program_options/variables_map.hpp

@@ -53 +53 @@
     class BOOST_PROGRAM_OPTIONS_DECL variable_value {
     public:
         variable_value() : m_defaulted(false) {}
-        variable_value(const boost::any& v, bool defaulted) 
-        : v(v), m_defaulted(defaulted) 
+        variable_value(const boost::any& p_v, bool p_defaulted) 
+        : v(p_v), m_defaulted(p_defaulted) 
         {}
 
         /** If stored value if of type T, returns that value. Otherwise,

boost/program_options/option.hpp

@@ -28 +28 @@
         , unregistered(false) 
         , case_insensitive(false)
         {}
-        basic_option(const std::string& string_key, 
-               const std::vector< std::string> &value)
-        : string_key(string_key)
-        , value(value)
+        basic_option(const std::string& p_string_key, 
+               const std::vector< std::string> &p_value)
+        : string_key(p_string_key)
+        , value(p_value)
         , unregistered(false)
         , case_insensitive(false)
         {}