Ticket #9892: 0001-property_tree-fix-GCC-Wshadow-warnings.patch

include/boost/property_tree/detail/json_parser_error.hpp

@@ -20 +20 @@
     class json_parser_error: public file_parser_error
     {
     public:
-        json_parser_error(const std::string &message, 
-                          const std::string &filename, 
-                          unsigned long line): 
-            file_parser_error(message, filename, line)
+        json_parser_error(const std::string &message_,
+                          const std::string &filename_,
+                          unsigned long line_):
+            file_parser_error(message_, filename_, line_)
         { 
         }
     };

include/boost/property_tree/detail/json_parser_read.hpp

@@ -45 +45 @@
         struct a_object_s
         {
             context &c;
-            a_object_s(context &c): c(c) { }
+            a_object_s(context &c_): c(c_) { }
             void operator()(Ch) const
             {
                 if (c.stack.empty())
@@ -63 +63 @@
         struct a_object_e
         {
             context &c;
-            a_object_e(context &c): c(c) { }
+            a_object_e(context &c_): c(c_) { }
             void operator()(Ch) const
             {
                 BOOST_ASSERT(c.stack.size() >= 1);
@@ -74 +74 @@
         struct a_name
         {
             context &c;
-            a_name(context &c): c(c) { }
+            a_name(context &c_): c(c_) { }
             void operator()(It, It) const
             {
                 c.name.swap(c.string);
@@ -85 +85 @@
         struct a_string_val
         {
             context &c;
-            a_string_val(context &c): c(c) { }
+            a_string_val(context &c_): c(c_) { }
             void operator()(It, It) const
             {
                 BOOST_ASSERT(c.stack.size() >= 1);
@@ -98 +98 @@
         struct a_literal_val
         {
             context &c;
-            a_literal_val(context &c): c(c) { }
+            a_literal_val(context &c_): c(c_) { }
             void operator()(It b, It e) const
             {
                 BOOST_ASSERT(c.stack.size() >= 1);
@@ -112 +112 @@
         struct a_char
         {
             context &c;
-            a_char(context &c): c(c) { }
+            a_char(context &c_): c(c_) { }
             void operator()(It b, It) const
             {
                 c.string += *b;
@@ -122 +122 @@
         struct a_escape
         {
             context &c;
-            a_escape(context &c): c(c) { }
+            a_escape(context &c_): c(c_) { }
             void operator()(Ch ch) const
             {
                 switch (ch)
@@ -143 +143 @@
         struct a_unicode
         {
             context &c;
-            a_unicode(context &c): c(c) { }
+            a_unicode(context &c_): c(c_) { }
             void operator()(unsigned long u) const
             {
                 u = (std::min)(u, static_cast<unsigned long>((std::numeric_limits<Ch>::max)()));

include/boost/property_tree/detail/ptree_implementation.hpp

@@ -549 +549 @@
 
     template<class K, class D, class C>
     basic_ptree<K, D, C> &
-        basic_ptree<K, D, C>::get_child(const path_type &path)
+        basic_ptree<K, D, C>::get_child(const path_type &path_)
     {
-        path_type p(path);
+        path_type p(path_);
         self_type *n = walk_path(p);
         if (!n) {
-            BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path));
+            BOOST_PROPERTY_TREE_THROW(ptree_bad_path("No such node", path_));
         }
         return *n;
     }
 
     template<class K, class D, class C> inline
     const basic_ptree<K, D, C> &
-        basic_ptree<K, D, C>::get_child(const path_type &path) const
+        basic_ptree<K, D, C>::get_child(const path_type &path_) const
     {
-        return const_cast<self_type*>(this)->get_child(path);
+        return const_cast<self_type*>(this)->get_child(path_);
     }
 
     template<class K, class D, class C> inline
     basic_ptree<K, D, C> &
-        basic_ptree<K, D, C>::get_child(const path_type &path,
+        basic_ptree<K, D, C>::get_child(const path_type &path_,
                                         self_type &default_value)
     {
-        path_type p(path);
+        path_type p(path_);
         self_type *n = walk_path(p);
         return n ? *n : default_value;
     }
 
     template<class K, class D, class C> inline
     const basic_ptree<K, D, C> &
-        basic_ptree<K, D, C>::get_child(const path_type &path,
+        basic_ptree<K, D, C>::get_child(const path_type &path_,
                                         const self_type &default_value) const
     {
-        return const_cast<self_type*>(this)->get_child(path,
+        return const_cast<self_type*>(this)->get_child(path_,
             const_cast<self_type&>(default_value));
     }
 
 
     template<class K, class D, class C>
     optional<basic_ptree<K, D, C> &>
-        basic_ptree<K, D, C>::get_child_optional(const path_type &path)
+        basic_ptree<K, D, C>::get_child_optional(const path_type &path_)
     {
-        path_type p(path);
+        path_type p(path_);
         self_type *n = walk_path(p);
         if (!n) {
             return optional<self_type&>();
@@ -600 +600 @@
 
     template<class K, class D, class C>
     optional<const basic_ptree<K, D, C> &>
-        basic_ptree<K, D, C>::get_child_optional(const path_type &path) const
+        basic_ptree<K, D, C>::get_child_optional(const path_type &path_) const
     {
-        path_type p(path);
+        path_type p(path_);
         self_type *n = walk_path(p);
         if (!n) {
             return optional<const self_type&>();
@@ -612 +612 @@
 
     template<class K, class D, class C>
     basic_ptree<K, D, C> &
-        basic_ptree<K, D, C>::put_child(const path_type &path,
+        basic_ptree<K, D, C>::put_child(const path_type &path_,
                                         const self_type &value)
     {
-        path_type p(path);
+        path_type p(path_);
         self_type &parent = force_path(p);
         // Got the parent. Now get the correct child.
         key_type fragment = p.reduce();
@@ -630 +630 @@
 
     template<class K, class D, class C>
     basic_ptree<K, D, C> &
-        basic_ptree<K, D, C>::add_child(const path_type &path,
+        basic_ptree<K, D, C>::add_child(const path_type &path_,
                                         const self_type &value)
     {
-        path_type p(path);
+        path_type p(path_);
         self_type &parent = force_path(p);
         // Got the parent.
         key_type fragment = p.reduce();
@@ -719 +719 @@
     template<class K, class D, class C>
     template<class Type, class Translator> inline
     typename boost::enable_if<detail::is_translator<Translator>, Type>::type
-    basic_ptree<K, D, C>::get(const path_type &path,
+    basic_ptree<K, D, C>::get(const path_type &path_,
                               Translator tr) const
     {
-        return get_child(path).BOOST_NESTED_TEMPLATE get_value<Type>(tr);
+        return get_child(path_).BOOST_NESTED_TEMPLATE get_value<Type>(tr);
     }
 
     template<class K, class D, class C>
     template<class Type> inline
-    Type basic_ptree<K, D, C>::get(const path_type &path) const
+    Type basic_ptree<K, D, C>::get(const path_type &path_) const
     {
-        return get_child(path).BOOST_NESTED_TEMPLATE get_value<Type>();
+        return get_child(path_).BOOST_NESTED_TEMPLATE get_value<Type>();
     }
 
     template<class K, class D, class C>
     template<class Type, class Translator> inline
-    Type basic_ptree<K, D, C>::get(const path_type &path,
+    Type basic_ptree<K, D, C>::get(const path_type &path_,
                                    const Type &default_value,
                                    Translator tr) const
     {
-        return get_optional<Type>(path, tr).get_value_or(default_value);
+        return get_optional<Type>(path_, tr).get_value_or(default_value);
     }
 
     template<class K, class D, class C>
@@ -748 +748 @@
         std::basic_string<Ch>
     >::type
     basic_ptree<K, D, C>::get(
-        const path_type &path, const Ch *default_value, Translator tr) const
+        const path_type &path_, const Ch *default_value, Translator tr) const
     {
-        return get<std::basic_string<Ch>, Translator>(path, default_value, tr);
+        return get<std::basic_string<Ch>, Translator>(path_, default_value, tr);
     }
 
     template<class K, class D, class C>
     template<class Type> inline
     typename boost::disable_if<detail::is_translator<Type>, Type>::type
-    basic_ptree<K, D, C>::get(const path_type &path,
+    basic_ptree<K, D, C>::get(const path_type &path_,
                               const Type &default_value) const
     {
-        return get_optional<Type>(path).get_value_or(default_value);
+        return get_optional<Type>(path_).get_value_or(default_value);
     }
 
     template<class K, class D, class C>
@@ -769 +769 @@
         std::basic_string<Ch>
     >::type
     basic_ptree<K, D, C>::get(
-        const path_type &path, const Ch *default_value) const
+        const path_type &path_, const Ch *default_value) const
     {
-        return get< std::basic_string<Ch> >(path, default_value);
+        return get< std::basic_string<Ch> >(path_, default_value);
     }
 
     template<class K, class D, class C>
     template<class Type, class Translator>
-    optional<Type> basic_ptree<K, D, C>::get_optional(const path_type &path,
+    optional<Type> basic_ptree<K, D, C>::get_optional(const path_type &path_,
                                                          Translator tr) const
     {
-        if (optional<const self_type&> child = get_child_optional(path))
+        if (optional<const self_type&> child = get_child_optional(path_))
             return child.get().
                 BOOST_NESTED_TEMPLATE get_value_optional<Type>(tr);
         else
@@ -789 +789 @@
     template<class K, class D, class C>
     template<class Type>
     optional<Type> basic_ptree<K, D, C>::get_optional(
-                                                const path_type &path) const
+                                                const path_type &path_) const
     {
-        if (optional<const self_type&> child = get_child_optional(path))
+        if (optional<const self_type&> child = get_child_optional(path_))
             return child.get().BOOST_NESTED_TEMPLATE get_value_optional<Type>();
         else
             return optional<Type>();
@@ -820 +820 @@
     template<class K, class D, class C>
     template<class Type, typename Translator>
     basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
-        const path_type &path, const Type &value, Translator tr)
+        const path_type &path_, const Type &value, Translator tr)
     {
-        if(optional<self_type &> child = get_child_optional(path)) {
+        if(optional<self_type &> child = get_child_optional(path_)) {
             child.get().put_value(value, tr);
             return *child;
         } else {
-            self_type &child2 = put_child(path, self_type());
+            self_type &child2 = put_child(path_, self_type());
             child2.put_value(value, tr);
             return child2;
         }
@@ -835 +835 @@
     template<class K, class D, class C>
     template<class Type> inline
     basic_ptree<K, D, C> & basic_ptree<K, D, C>::put(
-        const path_type &path, const Type &value)
+        const path_type &path_, const Type &value)
     {
-        return put(path, value,
+        return put(path_, value,
                    typename translator_between<data_type, Type>::type());
     }
 
     template<class K, class D, class C>
     template<class Type, typename Translator> inline
     basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
-        const path_type &path, const Type &value, Translator tr)
+        const path_type &path_, const Type &value, Translator tr)
     {
-        self_type &child = add_child(path, self_type());
+        self_type &child = add_child(path_, self_type());
         child.put_value(value, tr);
         return child;
     }
@@ -854 +854 @@
     template<class K, class D, class C>
     template<class Type> inline
     basic_ptree<K, D, C> & basic_ptree<K, D, C>::add(
-        const path_type &path, const Type &value)
+        const path_type &path_, const Type &value)
     {
-        return add(path, value,
+        return add(path_, value,
                    typename translator_between<data_type, Type>::type());
     }
 

include/boost/property_tree/string_path.hpp

@@ -88 +88 @@
         typedef typename String::value_type char_type;
 
         /// Create an empty path.
-        explicit string_path(char_type separator = char_type('.'));
+        explicit string_path(char_type separator_ = char_type('.'));
         /// Create a path by parsing the given string.
         /// @param value A sequence, possibly with separators, that describes
         ///              the path, e.g. "one.two.three".
         /// @param separator The separator used in parsing. Defaults to '.'.
         /// @param tr The translator used by this path to convert the individual
         ///           parts to keys.
-        string_path(const String &value, char_type separator = char_type('.'),
+        string_path(const String &value, char_type separator_ = char_type('.'),
                     Translator tr = Translator());
         /// Create a path by parsing the given string.
         /// @param value A zero-terminated array of values. Only use if zero-
@@ -106 +106 @@
         /// @param tr The translator used by this path to convert the individual
         ///           parts to keys.
         string_path(const char_type *value,
-                    char_type separator = char_type('.'),
+                    char_type separator_ = char_type('.'),
                     Translator tr = Translator());
 
         // Default copying doesn't do the right thing with the iterator
@@ -162 +162 @@
     };
 
     template <typename String, typename Translator> inline
-    string_path<String, Translator>::string_path(char_type separator)
-        : m_separator(separator), m_start(m_value.begin())
+    string_path<String, Translator>::string_path(char_type separator_)
+        : m_separator(separator_), m_start(m_value.begin())
     {}
 
     template <typename String, typename Translator> inline
     string_path<String, Translator>::string_path(const String &value,
-                                                 char_type separator,
+                                                 char_type separator_,
                                                  Translator tr)
-        : m_value(value), m_separator(separator),
+        : m_value(value), m_separator(separator_),
           m_tr(tr), m_start(m_value.begin())
     {}
 
     template <typename String, typename Translator> inline
     string_path<String, Translator>::string_path(const char_type *value,
-                                                 char_type separator,
+                                                 char_type separator_,
                                                  Translator tr)
-        : m_value(value), m_separator(separator),
+        : m_value(value), m_separator(separator_),
           m_tr(tr), m_start(m_value.begin())
     {}