Ticket #7431: spirit-warnings.diff

boost/spirit/home/phoenix/core/value.hpp

@@ -88 +88 @@
             type;
         };
 
-        actor_value(Actor const& actor)
-            : actor(actor) {}
+        actor_value(Actor const& actor_)
+            : actor(actor_) {}
 
         template <typename Env>
         typename result<Env>::type

boost/spirit/home/phoenix/function/function.hpp

@@ -16 +16 @@
     struct function
     {
         function() : f() {}
-        function(F const& f) : f(f) {}
+        function(F const& f_) : f(f_) {}
 
         actor<typename as_composite<detail::function_eval<0>, F>::type>
         operator()() const

boost/spirit/home/phoenix/object/construct.hpp

@@ -27 +27 @@
 
             template <typename RT, typename Env>
             static RT
-            eval(Env const& env)
+            eval(Env const& /*env*/)
             {
                 return RT();
             }

boost/spirit/home/qi/action/action.hpp

@@ -41 +41 @@
           : traits::attribute_of<Subject, Context, Iterator>
         {};
 
-        action(Subject const& subject, Action f)
-          : subject(subject), f(f) {}
+        action(Subject const& subject_, Action f_)
+          : subject(subject_), f(f_) {}
 
 #ifndef BOOST_SPIRIT_ACTIONS_ALLOW_ATTR_COMPAT
         template <typename Iterator, typename Context

boost/spirit/home/qi/auxiliary/attr.hpp

@@ -59 +59 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& /*first*/, Iterator const& /*last*/
           , Context& /*context*/, Skipper const& /*skipper*/
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
-            spirit::traits::assign_to(value_, attr);
+            spirit::traits::assign_to(value_, attr_);
             return true;        // never consume any input, succeed always
         }
 

boost/spirit/home/qi/auxiliary/attr_cast.hpp

@@ -53 +53 @@
           , traits::attribute_of<subject_type> >::type 
         transformed_attribute_type;
 
-        attr_cast_parser(Subject const& subject)
-          : subject(subject) 
+        attr_cast_parser(Subject const& subject_)
+          : subject(subject_) 
         {
             // If you got an error_invalid_expression error message here,
             // then the expression (Subject) is not a valid spirit qi
@@ -75 +75 @@
           , typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_param) const
         {
             // Find the real exposed attribute. If exposed is given, we use it
             // otherwise we assume the exposed attribute type to be the actual
@@ -90 +90 @@
                 exposed_attribute_type, transformed_attribute_type, domain> 
             transform;
 
-            typename transform::type attr_ = transform::pre(attr);
+            typename transform::type attr_ = transform::pre(attr_param);
 
             if (!compile<qi::domain>(subject).
                     parse(first, last, context, skipper, attr_))
             {
-                transform::fail(attr);
+                transform::fail(attr_param);
                 return false;
             }
 
             // do up-stream transformation, this mainly integrates the results
             // back into the original attribute value, if appropriate
-            traits::post_transform(attr, attr_);
+            traits::post_transform(attr_param, attr_);
             return true;
         }
 

boost/spirit/home/qi/auxiliary/eps.hpp

@@ -80 +80 @@
             typedef unused_type type;
         };
 
-        semantic_predicate(bool predicate)
-          : predicate(predicate) {}
+        semantic_predicate(bool predicate_)
+          : predicate(predicate_) {}
 
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>

boost/spirit/home/qi/auxiliary/lazy.hpp

@@ -60 +60 @@
         bool lazy_parse_impl(Parser const& p
           , Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr, mpl::true_)
+          , Attribute& /*attr*/, mpl::true_)
         {
             // If DeducedAuto is false (semantic actions is present), the
             // component's attribute is unused.
@@ -111 +111 @@
             type;
         };
 
-        lazy_parser(Function const& function, Modifiers const& modifiers)
-          : function(function), modifiers(modifiers) {}
+        lazy_parser(Function const& function_, Modifiers const& modifiers_)
+          : function(function_), modifiers(modifiers_) {}
 
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
@@ -183 +183 @@
         };
 
         lazy_directive(
-            Function const& function
-          , Subject const& subject
-          , Modifiers const& modifiers)
-          : function(function), subject(subject), modifiers(modifiers) {}
+            Function const& function_
+          , Subject const& subject_
+          , Modifiers const& modifiers_)
+          : function(function_), subject(subject_), modifiers(modifiers_) {}
 
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>

boost/spirit/home/qi/binary/binary.hpp

@@ -241 +241 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& /*context*/, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_param) const
         {
             qi::skip_over(first, last, skipper);
 
@@ -257 +257 @@
             }
 
             first = it;
-            spirit::traits::assign_to(attr_, attr);
+            spirit::traits::assign_to(attr_, attr_param);
             return true;
         }
 
@@ -280 +280 @@
             typedef unused_type type;
         };
 
-        binary_lit_parser(V n)
-          : n(n) {}
+        binary_lit_parser(V n_)
+          : n(n_) {}
 
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& /*context*/, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_param) const
         {
             qi::skip_over(first, last, skipper);
 
@@ -317 +317 @@
             }
 
             first = it;
-            spirit::traits::assign_to(attr_, attr);
+            spirit::traits::assign_to(attr_, attr_param);
             return true;
         }
 

boost/spirit/home/qi/char/char.hpp

@@ -123 +123 @@
         typedef CharEncoding char_encoding;
 
         template <typename Char>
-        literal_char(Char ch)
-          : ch(static_cast<char_type>(ch)) {}
+        literal_char(Char ch_)
+          : ch(static_cast<char_type>(ch_)) {}
 
         template <typename Context, typename Iterator>
         struct attribute
@@ -201 +201 @@
         typedef typename CharEncoding::char_type char_type;
         typedef CharEncoding char_encoding;
 
-        char_range(char_type from, char_type to)
-          : from(from), to(to) {}
+        char_range(char_type from_, char_type to_)
+          : from(from_), to(to_) {}
 
         template <typename CharParam, typename Context>
         bool test(CharParam ch_, Context&) const

boost/spirit/home/qi/char/char_parser.hpp

@@ -61 +61 @@
 
         template <typename Iterator, typename Context, typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
-          , Context& context, Skipper const& skipper, Attribute& attr) const
+          , Context& context, Skipper const& skipper, Attribute& attr_) const
         {
             qi::skip_over(first, last, skipper);
 
             if (first != last && this->derived().test(*first, context))
             {
-                spirit::traits::assign_to(*first, attr);
+                spirit::traits::assign_to(*first, attr_);
                 ++first;
                 return true;
             }
@@ -87 +87 @@
     struct negated_char_parser :
         char_parser<negated_char_parser<Positive>, typename Positive::char_type>
     {
-        negated_char_parser(Positive const& positive)
-          : positive(positive) {}
+        negated_char_parser(Positive const& positive_)
+          : positive(positive_) {}
 
         template <typename CharParam, typename Context>
         bool test(CharParam ch, Context& context) const

boost/spirit/home/qi/detail/alternative_function.hpp

@@ -56 +56 @@
     struct alternative_function
     {
         alternative_function(
-            Iterator& first, Iterator const& last, Context& context,
-            Skipper const& skipper, Attribute& attr)
-          : first(first), last(last), context(context), skipper(skipper),
-            attr(attr)
+            Iterator& first_, Iterator const& last_, Context& context_,
+            Skipper const& skipper_, Attribute& attr_)
+          : first(first_), last(last_), context(context_), skipper(skipper_),
+            attr(attr_)
         {
         }
 
@@ -185 +185 @@
     struct alternative_function<Iterator, Context, Skipper, unused_type const>
     {
         alternative_function(
-            Iterator& first, Iterator const& last, Context& context,
-            Skipper const& skipper, unused_type)
-          : first(first), last(last), context(context), skipper(skipper)
+            Iterator& first_, Iterator const& last_, Context& context_,
+            Skipper const& skipper_, unused_type)
+          : first(first_), last(last_), context(context_), skipper(skipper_)
         {
         }
 

boost/spirit/home/qi/detail/expect_function.hpp

@@ -26 +26 @@
         typedef Context context_type;
 
         expect_function(
-            Iterator& first, Iterator const& last
-          , Context& context, Skipper const& skipper)
-          : first(first)
-          , last(last)
-          , context(context)
-          , skipper(skipper)
+            Iterator& first_, Iterator const& last_
+          , Context& context_, Skipper const& skipper_)
+          : first(first_)
+          , last(last_)
+          , context(context_)
+          , skipper(skipper_)
           , is_first(true)
         {
         }

boost/spirit/home/qi/detail/fail_function.hpp

@@ -22 +22 @@
         typedef Context context_type;
 
         fail_function(
-            Iterator& first, Iterator const& last
-          , Context& context, Skipper const& skipper)
-          : first(first)
-          , last(last)
-          , context(context)
-          , skipper(skipper)
+            Iterator& first_, Iterator const& last_
+          , Context& context_, Skipper const& skipper_)
+          : first(first_)
+          , last(last_)
+          , context(context_)
+          , skipper(skipper_)
         {
         }
 

boost/spirit/home/qi/detail/pass_container.hpp

@@ -247 +247 @@
         typedef typename F::context_type context_type;
         typedef typename F::iterator_type iterator_type;
 
-        pass_container(F const& f, Attr& attr)
-          : f(f), attr(attr) {}
+        pass_container(F const& f_, Attr& attr_)
+          : f(f_), attr(attr_) {}
 
         // this is for the case when the current element exposes an attribute
         // which is pushed back onto the container

boost/spirit/home/qi/detail/pass_function.hpp

@@ -20 +20 @@
     struct pass_function
     {
         pass_function(
-            Iterator& first, Iterator const& last
-          , Context& context, Skipper const& skipper)
-          : first(first)
-          , last(last)
-          , context(context)
-          , skipper(skipper)
+            Iterator& first_, Iterator const& last_
+          , Context& context_, Skipper const& skipper_)
+          : first(first_)
+          , last(last_)
+          , context(context_)
+          , skipper(skipper_)
         {
         }
 

boost/spirit/home/qi/detail/permute_function.hpp

@@ -20 +20 @@
     struct permute_function
     {
         permute_function(
-            Iterator& first, Iterator const& last
-          , Context& context, Skipper const& skipper)
-          : first(first)
-          , last(last)
-          , context(context)
-          , skipper(skipper)
+            Iterator& first_, Iterator const& last_
+          , Context& context_, Skipper const& skipper_)
+          : first(first_)
+          , last(last_)
+          , context(context_)
+          , skipper(skipper_)
         {
         }
 

boost/spirit/home/qi/detail/unused_skipper.hpp

@@ -17 +17 @@
     template <typename Skipper>
     struct unused_skipper : unused_type
     {
-        unused_skipper(Skipper const& skipper)
-          : skipper(skipper) {}
+        unused_skipper(Skipper const& skipper_)
+          : skipper(skipper_) {}
         Skipper const& skipper;
 
     private:

boost/spirit/home/qi/directive/as.hpp

@@ -76 +76 @@
     struct as_directive : unary_parser<as_directive<Subject, T> >
     {
         typedef Subject subject_type;
-        as_directive(Subject const& subject)
-          : subject(subject) {}
+        as_directive(Subject const& subject_)
+          : subject(subject_) {}
 
         template <typename Context, typename Iterator>
         struct attribute
@@ -88 +88 @@
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
-          , Context& context, Skipper const& skipper, Attribute& attr) const
+          , Context& context, Skipper const& skipper, Attribute& attr_) const
         {
             Iterator i = first;
             T as_attr;
             if (subject.parse(i, last, context, skipper, as_attr))
             {
-                spirit::traits::assign_to(as_attr, attr);
+                spirit::traits::assign_to(as_attr, attr_);
                 first = i;
                 return true;
             }
@@ -103 +103 @@
 
         template <typename Iterator, typename Context, typename Skipper>
         bool parse(Iterator& first, Iterator const& last
-          , Context& context, Skipper const& skipper, T& attr) const
+          , Context& context, Skipper const& skipper, T& attr_) const
         {
             Iterator i = first;
-            if (subject.parse(i, last, context, skipper, attr))
+            if (subject.parse(i, last, context, skipper, attr_))
             {
                 first = i;
                 return true;

boost/spirit/home/qi/directive/hold.hpp

@@ -42 +42 @@
     struct hold_directive : unary_parser<hold_directive<Subject> >
     {
         typedef Subject subject_type;
-        hold_directive(Subject const& subject)
-          : subject(subject) {}
+        hold_directive(Subject const& subject_)
+          : subject(subject_) {}
 
         template <typename Context, typename Iterator>
         struct attribute
@@ -56 +56 @@
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
-          , Context& context, Skipper const& skipper, Attribute& attr) const
+          , Context& context, Skipper const& skipper, Attribute& attr_) const
         {
-            Attribute copy(attr);
+            Attribute copy(attr_);
             if (subject.parse(first, last, context, skipper, copy))
             {
-                traits::swap_impl(copy, attr);
+                traits::swap_impl(copy, attr_);
                 return true;
             }
             return false;

boost/spirit/home/qi/directive/lexeme.hpp

@@ -42 +42 @@
     struct lexeme_directive : unary_parser<lexeme_directive<Subject> >
     {
         typedef Subject subject_type;
-        lexeme_directive(Subject const& subject)
-          : subject(subject) {}
+        lexeme_directive(Subject const& subject_)
+          : subject(subject_) {}
 
         template <typename Context, typename Iterator>
         struct attribute
@@ -57 +57 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             qi::skip_over(first, last, skipper);
             return subject.parse(first, last, context
-              , detail::unused_skipper<Skipper>(skipper), attr);
+              , detail::unused_skipper<Skipper>(skipper), attr_);
         }
 
         template <typename Context>

boost/spirit/home/qi/directive/matches.hpp

@@ -44 +44 @@
     struct matches_directive : unary_parser<matches_directive<Subject> >
     {
         typedef Subject subject_type;
-        matches_directive(Subject const& subject)
-          : subject(subject) {}
+        matches_directive(Subject const& subject_)
+          : subject(subject_) {}
 
         template <typename Context, typename Iterator>
         struct attribute
@@ -56 +56 @@
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
-          , Context& context, Skipper const& skipper, Attribute& attr) const
+          , Context& context, Skipper const& skipper, Attribute& attr_) const
         {
             bool result = subject.parse(first, last, context, skipper, unused);
-            spirit::traits::assign_to(result, attr);
+            spirit::traits::assign_to(result, attr_);
             return true;
         }
 

boost/spirit/home/qi/directive/no_skip.hpp

@@ -45 +45 @@
     struct no_skip_directive : unary_parser<no_skip_directive<Subject> >
     {
         typedef Subject subject_type;
-        no_skip_directive(Subject const& subject)
-          : subject(subject) {}
+        no_skip_directive(Subject const& subject_)
+          : subject(subject_) {}
 
         template <typename Context, typename Iterator>
         struct attribute
@@ -60 +60 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             return subject.parse(first, last, context
-              , detail::unused_skipper<Skipper>(skipper), attr);
+              , detail::unused_skipper<Skipper>(skipper), attr_);
         }
 
         template <typename Context>

boost/spirit/home/qi/directive/omit.hpp

@@ -45 +45 @@
     struct omit_directive : unary_parser<omit_directive<Subject> >
     {
         typedef Subject subject_type;
-        omit_directive(Subject const& subject)
-          : subject(subject) {}
+        omit_directive(Subject const& subject_)
+          : subject(subject_) {}
 
         template <typename Context, typename Iterator>
         struct attribute
@@ -57 +57 @@
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
-          , Context& context, Skipper const& skipper, Attribute& attr) const
+          , Context& context, Skipper const& skipper, Attribute& attr_) const
         {
-            return subject.parse(first, last, context, skipper, attr);
+            return subject.parse(first, last, context, skipper, attr_);
         }
 
         template <typename Context>

boost/spirit/home/qi/directive/raw.hpp

@@ -44 +44 @@
     struct raw_directive : unary_parser<raw_directive<Subject> >
     {
         typedef Subject subject_type;
-        raw_directive(Subject const& subject)
-          : subject(subject) {}
+        raw_directive(Subject const& subject_)
+          : subject(subject_) {}
 
         template <typename Context, typename Iterator>
         struct attribute
@@ -56 +56 @@
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
-          , Context& context, Skipper const& skipper, Attribute& attr) const
+          , Context& context, Skipper const& skipper, Attribute& attr_) const
         {
             qi::skip_over(first, last, skipper);
             Iterator i = first;
             if (subject.parse(i, last, context, skipper, unused))
             {
-                spirit::traits::assign_to(first, i, attr);
+                spirit::traits::assign_to(first, i, attr_);
                 first = i;
                 return true;
             }

boost/spirit/home/qi/directive/repeat.hpp

@@ -81 +81 @@
     template <typename T>
     struct exact_iterator // handles repeat(exact)[p]
     {
-        exact_iterator(T const exact)
-          : exact(exact) {}
+        exact_iterator(T const exact_)
+          : exact(exact_) {}
 
         typedef T type;
         T start() const { return 0; }
@@ -99 +99 @@
     template <typename T>
     struct finite_iterator // handles repeat(min, max)[p]
     {
-        finite_iterator(T const min, T const max)
-          : min BOOST_PREVENT_MACRO_SUBSTITUTION (min)
-          , max BOOST_PREVENT_MACRO_SUBSTITUTION (max) {}
+        finite_iterator(T const min_, T const max_)
+          : min BOOST_PREVENT_MACRO_SUBSTITUTION (min_)
+          , max BOOST_PREVENT_MACRO_SUBSTITUTION (max_) {}
 
         typedef T type;
         T start() const { return 0; }
@@ -119 +119 @@
     template <typename T>
     struct infinite_iterator // handles repeat(min, inf)[p]
     {
-        infinite_iterator(T const min)
-          : min BOOST_PREVENT_MACRO_SUBSTITUTION (min) {}
+        infinite_iterator(T const min_)
+          : min BOOST_PREVENT_MACRO_SUBSTITUTION (min_) {}
 
         typedef T type;
         T start() const { return 0; }
@@ -153 +153 @@
             type;
         };
 
-        repeat_parser(Subject const& subject, LoopIter const& iter)
-          : subject(subject), iter(iter) {}
+        repeat_parser(Subject const& subject_, LoopIter const& iter_)
+          : subject(subject_), iter(iter_) {}
 
         template <typename F>
         bool parse_container(F f) const
@@ -183 +183 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             typedef detail::fail_function<Iterator, Context, Skipper>
                 fail_function;
 
             // ensure the attribute is actually a container type
-            traits::make_container(attr);
+            traits::make_container(attr_);
 
-            Iterator iter = first;
-            fail_function f(iter, last, context, skipper);
-            if (!parse_container(detail::make_pass_container(f, attr)))
+            Iterator iter_local = first;
+            fail_function f(iter_local, last, context, skipper);
+            if (!parse_container(detail::make_pass_container(f, attr_)))
                 return false;
 
             first = f.first;

boost/spirit/home/qi/directive/skip.hpp

@@ -70 +70 @@
             type;
         };
 
-        reskip_parser(Subject const& subject)
-          : subject(subject) {}
+        reskip_parser(Subject const& subject_)
+          : subject(subject_) {}
 
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& u // --> The skipper is reintroduced
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             return subject.parse(first, last, context
-              , detail::get_skipper(u), attr);
+              , detail::get_skipper(u), attr_);
         }
 
         template <typename Context>
@@ -106 +106 @@
             type;
         };
 
-        skip_parser(Subject const& subject, Skipper const& skipper)
-          : subject(subject), skipper(skipper) {}
+        skip_parser(Subject const& subject_, Skipper const& skipper_)
+          : subject(subject_), skipper(skipper_) {}
 
         template <typename Iterator, typename Context
           , typename Skipper_, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper_ const& //skipper --> bypass the supplied skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
-            return subject.parse(first, last, context, skipper, attr);
+            return subject.parse(first, last, context, skipper, attr_);
         }
 
         template <typename Context>

boost/spirit/home/qi/nonterminal/debug_handler.hpp

@@ -36 +36 @@
         function_type;
 
         debug_handler(
-            function_type subject
-          , F f
-          , std::string const& rule_name)
-          : subject(subject)
-          , f(f)
-          , rule_name(rule_name)
+            function_type subject_
+          , F f_
+          , std::string const& rule_name_)
+          : subject(subject_)
+          , f(f_)
+          , rule_name(rule_name_)
         {
         }
 

boost/spirit/home/qi/nonterminal/detail/parameterized.hpp

@@ -27 +27 @@
     struct parameterized_nonterminal
       : parser<parameterized_nonterminal<Subject, Params> >
     {
-        parameterized_nonterminal(Subject const& subject, Params const& params)
-          : ref(subject), params(params)
+        parameterized_nonterminal(Subject const& subject, Params const& params_)
+          : ref(subject), params(params_)
         {
         }
 
@@ -41 +41 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             // Forward to subject, passing the additional
             // params argument to parse.
-            return ref.get().parse(first, last, context, skipper, attr, params);
+            return ref.get().parse(first, last, context, skipper, attr_, params);
         }
 
         template <typename Context>

boost/spirit/home/qi/nonterminal/detail/parser_binder.hpp

@@ -21 +21 @@
     template <typename Parser, typename Auto>
     struct parser_binder
     {
-        parser_binder(Parser const& p)
-          : p(p) {}
+        parser_binder(Parser const& p_)
+          : p(p_) {}
 
         template <typename Iterator, typename Skipper, typename Context>
         bool call(Iterator& first, Iterator const& last
@@ -60 +60 @@
     template <typename Parser>
     struct parser_binder<Parser, mpl::true_>
     {
-        parser_binder(Parser const& p)
-          : p(p) {}
+        parser_binder(Parser const& p_)
+          : p(p_) {}
 
         template <typename Iterator, typename Skipper, typename Context>
         bool operator()(

boost/spirit/home/qi/nonterminal/error_handler.hpp

@@ -76 +76 @@
             )>
         function_type;
 
-        error_handler(function_type subject, F f)
-          : subject(subject)
-          , f(f)
+        error_handler(function_type subject_, F f_)
+          : subject(subject_)
+          , f(f_)
         {
         }
 

boost/spirit/home/qi/nonterminal/grammar.hpp

@@ -56 +56 @@
 
         grammar(
             start_type const& start
-          , std::string const& name_ = "unnamed-grammar")
+          , std::string const& name = "unnamed-grammar")
         : proto::extends<terminal, base_type>(terminal::make(reference_(start)))
-        , name_(name_)
+        , name_(name)
         {}
 
         // This constructor is used to catch if the start rule is not
@@ -90 +90 @@
         template <typename Context, typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             return this->proto_base().child0.parse(
-                first, last, context, skipper, attr);
+                first, last, context, skipper, attr_);
         }
 
         template <typename Context>

boost/spirit/home/qi/nonterminal/rule.hpp

@@ -154 +154 @@
             >::type
         encoding_modifier_type;
 
-        explicit rule(std::string const& name_ = "unnamed-rule")
+        explicit rule(std::string const& name = "unnamed-rule")
           : base_type(terminal::make(reference_(*this)))
-          , name_(name_)
+          , name_(name)
         {
         }
 
@@ -168 +168 @@
         }
 
         template <typename Auto, typename Expr>
-        static void define(rule& lhs, Expr const& expr, mpl::false_)
+        static void define(rule& /*lhs*/, Expr const& /*expr*/, mpl::false_)
         {
             // Report invalid expression error as early as possible.
             // If you got an error_invalid_expression error message here,
@@ -184 +184 @@
         }
 
         template <typename Expr>
-        rule(Expr const& expr, std::string const& name_ = "unnamed-rule")
+        rule(Expr const& expr, std::string const& name = "unnamed-rule")
           : base_type(terminal::make(reference_(*this)))
-          , name_(name_)
+          , name_(name)
         {
             define<mpl::false_>(*this, expr, traits::matches<qi::domain, Expr>());
         }
@@ -272 +272 @@
         template <typename Context, typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& /*context*/, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_param) const
         {
             if (f)
             {
@@ -288 +288 @@
                     typename make_attribute::type, attr_type, domain>
                 transform;
 
-                typename make_attribute::type made_attr = make_attribute::call(attr);
+                typename make_attribute::type made_attr = make_attribute::call(attr_param);
                 typename transform::type attr_ = transform::pre(made_attr);
 
                 // If you are seeing a compilation error here, you are probably
@@ -304 +304 @@
                 {
                     // do up-stream transformation, this integrates the results
                     // back into the original attribute value, if appropriate
-                    traits::post_transform(attr, attr_);
+                    traits::post_transform(attr_param, attr_);
                     return true;
                 }
 
                 // inform attribute transformation of failed rhs
-                traits::fail_transform(attr, attr_);
+                traits::fail_transform(attr_param, attr_);
             }
             return false;
         }
@@ -318 +318 @@
           , typename Attribute, typename Params>
         bool parse(Iterator& first, Iterator const& last
           , Context& caller_context, Skipper const& skipper
-          , Attribute& attr, Params const& params) const
+          , Attribute& attr_param, Params const& params) const
         {
             if (f)
             {
@@ -334 +334 @@
                     typename make_attribute::type, attr_type, domain>
                 transform;
 
-                typename make_attribute::type made_attr = make_attribute::call(attr);
+                typename make_attribute::type made_attr = make_attribute::call(attr_param);
                 typename transform::type attr_ = transform::pre(made_attr);
 
                 // If you are seeing a compilation error here, you are probably
@@ -350 +350 @@
                 {
                     // do up-stream transformation, this integrates the results
                     // back into the original attribute value, if appropriate
-                    traits::post_transform(attr, attr_);
+                    traits::post_transform(attr_param, attr_);
                     return true;
                 }
 
                 // inform attribute transformation of failed rhs
-                traits::fail_transform(attr, attr_);
+                traits::fail_transform(attr_param, attr_);
             }
             return false;
         }

boost/spirit/home/qi/nonterminal/success_handler.hpp

@@ -29 +29 @@
             )>
         function_type;
 
-        success_handler(function_type subject, F f)
-          : subject(subject)
-          , f(f)
+        success_handler(function_type subject_, F f_)
+          : subject(subject_)
+          , f(f_)
         {
         }
 

boost/spirit/home/qi/numeric/bool.hpp

@@ -153 +153 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& /*context*/, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             typedef detail::bool_impl<T, BoolPolicies> extract;
             qi::skip_over(first, last, skipper);
-            return extract::parse(first, last, attr, BoolPolicies());
+            return extract::parse(first, last, attr_, BoolPolicies());
         }
 
         template <typename Context>
@@ -184 +184 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& /*context*/, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             typedef detail::bool_impl<T, BoolPolicies> extract;
             qi::skip_over(first, last, skipper);
-            return extract::parse(first, last, attr, BoolPolicies(), n_, n_);
+            return extract::parse(first, last, attr_, BoolPolicies(), n_, n_);
         }
 
         template <typename Context>

boost/spirit/home/qi/numeric/bool_policies.hpp

@@ -24 +24 @@
     {
         template <typename Iterator, typename Attribute>
         static bool
-        parse_true(Iterator& first, Iterator const& last, Attribute& attr)
+        parse_true(Iterator& first, Iterator const& last, Attribute& attr_)
         {
             if (detail::string_parse("true", first, last, unused))
             {
-                spirit::traits::assign_to(T(true), attr);    // result is true
+                spirit::traits::assign_to(T(true), attr_);    // result is true
                 return true;
             }
             return false;
@@ -36 +36 @@
 
         template <typename Iterator, typename Attribute>
         static bool
-        parse_false(Iterator& first, Iterator const& last, Attribute& attr)
+        parse_false(Iterator& first, Iterator const& last, Attribute& attr_)
         {
             if (detail::string_parse("false", first, last, unused))
             {
-                spirit::traits::assign_to(T(false), attr);   // result is false
+                spirit::traits::assign_to(T(false), attr_);   // result is false
                 return true;
             }
             return false;
@@ -53 +53 @@
     {
         template <typename Iterator, typename Attribute>
         static bool
-        parse_true(Iterator& first, Iterator const& last, Attribute& attr)
+        parse_true(Iterator& first, Iterator const& last, Attribute& attr_)
         {
             if (detail::string_parse("true", "TRUE", first, last, unused))
             {
-                spirit::traits::assign_to(T(true), attr);    // result is true
+                spirit::traits::assign_to(T(true), attr_);    // result is true
                 return true;
             }
             return false;
@@ -65 +65 @@
 
         template <typename Iterator, typename Attribute>
         static bool
-        parse_false(Iterator& first, Iterator const& last, Attribute& attr)
+        parse_false(Iterator& first, Iterator const& last, Attribute& attr_)
         {
             if (detail::string_parse("false", "FALSE", first, last, unused))
             {
-                spirit::traits::assign_to(T(false), attr);   // result is false
+                spirit::traits::assign_to(T(false), attr_);   // result is false
                 return true;
             }
             return false;

boost/spirit/home/qi/numeric/int.hpp

@@ -198 +198 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& /*context*/, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             typedef extract_int<T, Radix, MinDigits, MaxDigits> extract;
             qi::skip_over(first, last, skipper);
-            return extract::call(first, last, attr);
+            return extract::call(first, last, attr_);
         }
 
         template <typename Context>
@@ -236 +236 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& /*context*/, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_param) const
         {
             typedef extract_int<T, Radix, MinDigits, MaxDigits> extract;
             qi::skip_over(first, last, skipper);
@@ -246 +246 @@
 
             if (extract::call(first, last, attr_) && (attr_ == n_))
             {
-                traits::assign_to(attr_, attr);
+                traits::assign_to(attr_, attr_param);
                 return true;
             }
 

boost/spirit/home/qi/numeric/numeric_utils.hpp

@@ -53 +53 @@
             not_supported_radix, ());
 
         template <typename Iterator>
-        inline static bool call(Iterator& first, Iterator const& last, T& attr)
+        inline static bool call(Iterator& first, Iterator const& last, T& attr_)
         {
             if (first == last)
                 return false;
@@ -69 +69 @@
 
             Iterator save = first;
             if (!extract_type::parse(first, last,
-                detail::cast_unsigned<T>::call(attr)))
+                detail::cast_unsigned<T>::call(attr_)))
             {
                 first = save;
                 return false;
@@ -81 +81 @@
         inline static bool call(Iterator& first, Iterator const& last, Attribute& attr_)
         {
             // this case is called when Attribute is not T
-            T attr;
-            if (call(first, last, attr))
+            T attr_local;
+            if (call(first, last, attr_local))
             {
-                traits::assign_to(attr, attr_);
+                traits::assign_to(attr_local, attr_);
                 return true;
             }
             return false;
@@ -103 +103 @@
             not_supported_radix, ());
 
         template <typename Iterator>
-        inline static bool call(Iterator& first, Iterator const& last, T& attr)
+        inline static bool call(Iterator& first, Iterator const& last, T& attr_)
         {
             if (first == last)
                 return false;
@@ -119 +119 @@
             Iterator save = first;
             bool hit = extract_sign(first, last);
             if (hit)
-                hit = extract_neg_type::parse(first, last, attr);
+                hit = extract_neg_type::parse(first, last, attr_);
             else
-                hit = extract_pos_type::parse(first, last, attr);
+                hit = extract_pos_type::parse(first, last, attr_);
 
             if (!hit)
             {
@@ -135 +135 @@
         inline static bool call(Iterator& first, Iterator const& last, Attribute& attr_)
         {
             // this case is called when Attribute is not T
-            T attr;
-            if (call(first, last, attr))
+            T attr_local;
+            if (call(first, last, attr_local))
             {
-                traits::assign_to(attr, attr_);
+                traits::assign_to(attr_local, attr_);
                 return true;
             }
             return false;

boost/spirit/home/qi/numeric/real.hpp

@@ -161 +161 @@
         template <typename Iterator, typename Context, typename Skipper>
         bool parse(Iterator& first, Iterator const& last
           , Context& /*context*/, Skipper const& skipper
-          , T& attr) const
+          , T& attr_) const
         {
             typedef detail::real_impl<T, RealPolicies> extract;
             qi::skip_over(first, last, skipper);
-            return extract::parse(first, last, attr, RealPolicies());
+            return extract::parse(first, last, attr_, RealPolicies());
         }
 
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_param) const
         {
             // this case is called when Attribute is not T
             T attr_;
             if (parse(first, last, context, skipper, attr_))
             {
-                traits::assign_to(attr_, attr);
+                traits::assign_to(attr_, attr_param);
                 return true;
             }
             return false;
@@ -207 +207 @@
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
-          , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Context& /*context*/, Skipper const& skipper
+          , Attribute& attr_param) const
         {
             typedef detail::real_impl<T, RealPolicies> extract;
             qi::skip_over(first, last, skipper);
@@ -219 +219 @@
             if (extract::parse(first, last, attr_, RealPolicies()) &&
                 (attr_ == n_))
             {
-                traits::assign_to(attr_, attr);
+                traits::assign_to(attr_, attr_param);
                 return true;
             }
 

boost/spirit/home/qi/numeric/real_policies.hpp

@@ -37 +37 @@
 
         template <typename Iterator, typename Attribute>
         static bool
-        parse_n(Iterator& first, Iterator const& last, Attribute& attr)
+        parse_n(Iterator& first, Iterator const& last, Attribute& attr_)
         {
-            return extract_uint<T, 10, 1, -1>::call(first, last, attr);
+            return extract_uint<T, 10, 1, -1>::call(first, last, attr_);
         }
 
         template <typename Iterator>
@@ -54 +54 @@
 
         template <typename Iterator, typename Attribute>
         static bool
-        parse_frac_n(Iterator& first, Iterator const& last, Attribute& attr)
+        parse_frac_n(Iterator& first, Iterator const& last, Attribute& attr_)
         {
-            return extract_uint<T, 10, 1, -1, true>::call(first, last, attr);
+            return extract_uint<T, 10, 1, -1, true>::call(first, last, attr_);
         }
 
         template <typename Iterator>
@@ -71 +71 @@
 
         template <typename Iterator>
         static bool
-        parse_exp_n(Iterator& first, Iterator const& last, int& attr)
+        parse_exp_n(Iterator& first, Iterator const& last, int& attr_)
         {
-            return extract_int<int, 10, 1, -1>::call(first, last, attr);
+            return extract_int<int, 10, 1, -1>::call(first, last, attr_);
         }
 
         ///////////////////////////////////////////////////////////////////////
@@ -105 +105 @@
         ///////////////////////////////////////////////////////////////////////
         template <typename Iterator, typename Attribute>
         static bool
-        parse_nan(Iterator& first, Iterator const& last, Attribute& attr)
+        parse_nan(Iterator& first, Iterator const& last, Attribute& attr_)
         {
             if (first == last)
                 return false;   // end of input reached
@@ -128 +128 @@
 
                     first = ++i;
                 }
-                attr = std::numeric_limits<T>::quiet_NaN();
+                attr_ = std::numeric_limits<T>::quiet_NaN();
                 return true;
             }
             return false;
@@ -136 +136 @@
 
         template <typename Iterator, typename Attribute>
         static bool
-        parse_inf(Iterator& first, Iterator const& last, Attribute& attr)
+        parse_inf(Iterator& first, Iterator const& last, Attribute& attr_)
         {
             if (first == last)
                 return false;   // end of input reached
@@ -149 +149 @@
             {
                 // skip allowed 'inity' part of infinity
                 detail::string_parse("inity", "INITY", first, last, unused);
-                attr = std::numeric_limits<T>::infinity();
+                attr_ = std::numeric_limits<T>::infinity();
                 return true;
             }
             return false;

boost/spirit/home/qi/numeric/uint.hpp

@@ -235 +235 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& /*context*/, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             typedef extract_uint<T, Radix, MinDigits, MaxDigits> extract;
             qi::skip_over(first, last, skipper);
-            return extract::call(first, last, attr);
+            return extract::call(first, last, attr_);
         }
 
         template <typename Context>
@@ -273 +273 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& /*context*/, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_param) const
         {
             typedef extract_uint<T, Radix, MinDigits, MaxDigits> extract;
             qi::skip_over(first, last, skipper);
@@ -283 +283 @@
 
             if (extract::call(first, last, attr_) && (attr_ == n_))
             {
-                traits::assign_to(attr_, attr);
+                traits::assign_to(attr_, attr_param);
                 return true;
             }
 

boost/spirit/home/qi/operator/alternative.hpp

@@ -63 +63 @@
             type;
         };
 
-        alternative(Elements const& elements)
-          : elements(elements) {}
+        alternative(Elements const& elements_)
+          : elements(elements_) {}
 
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             detail::alternative_function<Iterator, Context, Skipper, Attribute>
-                f(first, last, context, skipper, attr);
+                f(first, last, context, skipper, attr_);
 
             // return true if *any* of the parsers succeed
             return fusion::any(elements, f);

boost/spirit/home/qi/operator/and_predicate.hpp

@@ -43 +43 @@
             typedef unused_type type;
         };
 
-        and_predicate(Subject const& subject)
-          : subject(subject) {}
+        and_predicate(Subject const& subject_)
+          : subject(subject_) {}
 
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>

boost/spirit/home/qi/operator/difference.hpp

@@ -46 +46 @@
             type;
         };
 
-        difference(Left const& left, Right const& right)
-          : left(left), right(right) {}
+        difference(Left const& left_, Right const& right_)
+          : left(left_), right(right_) {}
 
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             // Unlike classic Spirit, with this version of difference, the rule
             // lit("policeman") - "police" will always fail to match.
@@ -71 +71 @@
                 return false;
             }
             // RHS fails, now try LHS
-            return left.parse(first, last, context, skipper, attr);
+            return left.parse(first, last, context, skipper, attr_);
         }
 
         template <typename Context>

boost/spirit/home/qi/operator/expect.hpp

@@ -39 +39 @@
     template <typename Iterator>
     struct expectation_failure : std::runtime_error
     {
-        expectation_failure(Iterator first, Iterator last, info const& what)
+        expectation_failure(Iterator first_, Iterator last_, info const& what)
           : std::runtime_error("boost::spirit::qi::expectation_failure")
-          , first(first), last(last), what_(what)
+          , first(first_), last(last_), what_(what)
         {}
         ~expectation_failure() throw() {}
 

boost/spirit/home/qi/operator/kleene.hpp

@@ -56 +56 @@
             type;
         };
 
-        kleene(Subject const& subject)
-          : subject(subject) {}
+        kleene(Subject const& subject_)
+          : subject(subject_) {}
 
         template <typename F>
         bool parse_container(F f) const
@@ -71 +71 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             // ensure the attribute is actually a container type
-            traits::make_container(attr);
+            traits::make_container(attr_);
 
             typedef detail::fail_function<Iterator, Context, Skipper>
                 fail_function;
 
             Iterator iter = first;
             fail_function f(iter, last, context, skipper);
-            parse_container(detail::make_pass_container(f, attr));
+            parse_container(detail::make_pass_container(f, attr_));
 
             first = f.first;
             return true;

boost/spirit/home/qi/operator/list.hpp

@@ -55 +55 @@
             type;
         };
 
-        list(Left const& left, Right const& right)
-          : left(left), right(right) {}
+        list(Left const& left_, Right const& right_)
+          : left(left_), right(right_) {}
 
         template <typename F>
         bool parse_container(F f) const
@@ -80 +80 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             typedef detail::fail_function<Iterator, Context, Skipper>
                 fail_function;
 
             // ensure the attribute is actually a container type
-            traits::make_container(attr);
+            traits::make_container(attr_);
 
             Iterator iter = first;
             fail_function f(iter, last, context, skipper);
-            if (!parse_container(detail::make_pass_container(f, attr)))
+            if (!parse_container(detail::make_pass_container(f, attr_)))
                 return false;
 
             first = f.first;

boost/spirit/home/qi/operator/not_predicate.hpp

@@ -42 +42 @@
             typedef unused_type type;
         };
 
-        not_predicate(Subject const& subject)
-          : subject(subject) {}
+        not_predicate(Subject const& subject_)
+          : subject(subject_) {}
 
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>

boost/spirit/home/qi/operator/optional.hpp

@@ -55 +55 @@
             type;
         };
 
-        optional(Subject const& subject)
-          : subject(subject) {}
+        optional(Subject const& subject_)
+          : subject(subject_) {}
 
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse_impl(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr, mpl::false_) const
+          , Attribute& attr_, mpl::false_) const
         {
             // create a local value if Attribute is not unused_type
             typename spirit::result_of::optional_value<Attribute>::type val = 
@@ -71 +71 @@
             if (subject.parse(first, last, context, skipper, val))
             {
                 // assign the parsed value into our attribute
-                spirit::traits::assign_to(val, attr);
+                spirit::traits::assign_to(val, attr_);
             }
             return true;
         }
@@ -80 +80 @@
           , typename Skipper, typename Attribute>
         bool parse_impl(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr, mpl::true_) const
+          , Attribute& attr_, mpl::true_) const
         {
-            subject.parse(first, last, context, skipper, attr);
+            subject.parse(first, last, context, skipper, attr_);
             return true;
         }
 
@@ -90 +90 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             typedef typename spirit::result_of::optional_value<Attribute>::type 
                 attribute_type;
 
-            return parse_impl(first, last, context, skipper, attr
+            return parse_impl(first, last, context, skipper, attr_
               , traits::is_container<attribute_type>());
         }
 

boost/spirit/home/qi/operator/permutation.hpp

@@ -62 +62 @@
             type;
         };
 
-        permutation(Elements const& elements)
-          : elements(elements) {}
+        permutation(Elements const& elements_)
+          : elements(elements_) {}
 
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
@@ -82 +82 @@
             }
 
             // wrap the attribute in a tuple if it is not a tuple
-            typename traits::wrap_if_not_tuple<Attribute>::type attr(attr_);
+            typename traits::wrap_if_not_tuple<Attribute>::type attr_local(attr_);
 
             // We have a bool array 'flags' with one flag for each parser.
             // permute_function sets the slot to true when the corresponding
@@ -91 +91 @@
 
             bool result = false;
             f.taken = flags.begin();
-            while (spirit::any_if_ns(elements, attr, f, predicate()))
+            while (spirit::any_if_ns(elements, attr_local, f, predicate()))
             {
                 f.taken = flags.begin();
                 result = true;

boost/spirit/home/qi/operator/plus.hpp

@@ -53 +53 @@
             type;
         };
 
-        plus(Subject const& subject)
-          : subject(subject) {}
+        plus(Subject const& subject_)
+          : subject(subject_) {}
 
         template <typename F>
         bool parse_container(F f) const
@@ -72 +72 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             typedef detail::fail_function<Iterator, Context, Skipper>
                 fail_function;
 
             // ensure the attribute is actually a container type
-            traits::make_container(attr);
+            traits::make_container(attr_);
 
             Iterator iter = first;
             fail_function f(iter, last, context, skipper);
-            if (!parse_container(detail::make_pass_container(f, attr)))
+            if (!parse_container(detail::make_pass_container(f, attr_)))
                 return false;
 
             first = f.first;

boost/spirit/home/qi/operator/sequence_base.hpp

@@ -60 +60 @@
             type;
         };
 
-        sequence_base(Elements const& elements)
-          : elements(elements) {}
+        sequence_base(Elements const& elements_)
+          : elements(elements_) {}
 
         // standard case. Attribute is a fusion tuple
         template <typename Iterator, typename Context
@@ -81 +81 @@
                     traits::one_element_sequence<attr_type_>
                   , mpl::not_<traits::one_element_sequence<Attribute> >
                 >::type 
-            >::type attr(attr_);
+            >::type attr_local(attr_);
 
             // return false if *any* of the parsers fail
-            if (spirit::any_if(elements, attr
+            if (spirit::any_if(elements, attr_local
               , Derived::fail_function(iter, last, context, skipper), predicate()))
                 return false;
             first = iter;
@@ -118 +118 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
-            return parse_impl(first, last, context, skipper, attr
+            return parse_impl(first, last, context, skipper, attr_
               , traits::is_container<Attribute>());
         }
 

boost/spirit/home/qi/operator/sequential_or.hpp

@@ -57 +57 @@
             type;
         };
 
-        sequential_or(Elements const& elements)
-          : elements(elements) {}
+        sequential_or(Elements const& elements_)
+          : elements(elements_) {}
 
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
@@ -71 +71 @@
                 f(first, last, context, skipper);
 
             // wrap the attribute in a tuple if it is not a tuple
-            typename traits::wrap_if_not_tuple<Attribute>::type attr(attr_);
+            typename traits::wrap_if_not_tuple<Attribute>::type attr_local(attr_);
 
             // return true if *any* of the parsers succeed
             // (we use the non-short-circuiting version: any_if_ns
             // to force all elements to be tested)
-            return spirit::any_if_ns(elements, attr, f, predicate());
+            return spirit::any_if_ns(elements, attr_local, f, predicate());
         }
 
         template <typename Context>

boost/spirit/home/qi/parse_attr.hpp

@@ -62 +62 @@
             BOOST_PP_ENUM(N, BOOST_SPIRIT_QI_ATTRIBUTE_REFERENCE, A)
         > vector_type;
 
-        vector_type attr (BOOST_PP_ENUM_PARAMS(N, attr));
-        return compile<qi::domain>(expr).parse(first, last, unused, unused, attr);
+        vector_type lattr (BOOST_PP_ENUM_PARAMS(N, attr));
+        return compile<qi::domain>(expr).parse(first, last, unused, unused, lattr);
     }
 
     template <typename Iterator, typename Expr
@@ -113 +113 @@
             BOOST_PP_ENUM(N, BOOST_SPIRIT_QI_ATTRIBUTE_REFERENCE, A)
         > vector_type;
 
-        vector_type attr (BOOST_PP_ENUM_PARAMS(N, attr));
+        vector_type lattr (BOOST_PP_ENUM_PARAMS(N, attr));
         if (!compile<qi::domain>(expr).parse(
-                first, last, unused, skipper_, attr))
+                first, last, unused, skipper_, lattr))
             return false;
 
         if (post_skip == skip_flag::postskip)

boost/spirit/home/qi/reference.hpp

@@ -38 +38 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& context, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
-            return ref.get().parse(first, last, context, skipper, attr);
+            return ref.get().parse(first, last, context, skipper, attr_);
         }
 
         template <typename Context>

boost/spirit/home/qi/stream/stream.hpp

@@ -58 +58 @@
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
           , Context& /*context*/, Skipper const& skipper
-          , Attribute& attr) const
+          , Attribute& attr_) const
         {
             typedef qi::detail::iterator_source<Iterator> source_device;
             typedef boost::iostreams::stream<source_device> instream;
@@ -66 +66 @@
             qi::skip_over(first, last, skipper);
 
             instream in(first, last);         // copies 'first'
-            in >> attr;                       // use existing operator>>()
+            in >> attr_;                       // use existing operator>>()
 
             // advance the iterator if everything is ok
             if (in.good()) {

boost/spirit/home/qi/string/detail/tst.hpp

@@ -24 +24 @@
     template <typename Char, typename T>
     struct tst_node
     {
-        tst_node(Char id)
-          : id(id), data(0), lt(0), eq(0), gt(0)
+        tst_node(Char id_)
+          : id(id_), data(0), lt(0), eq(0), gt(0)
         {
         }
 

boost/spirit/home/qi/string/lit.hpp

@@ -89 +89 @@
         char_type;
         typedef std::basic_string<char_type> string_type;
 
-        literal_string(typename add_reference<String>::type str)
-          : str(str)
+        literal_string(typename add_reference<String>::type str_)
+          : str(str_)
         {}
 
         template <typename Context, typename Iterator>
@@ -104 +104 @@
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
-          , Context& /*context*/, Skipper const& skipper, Attribute& attr) const
+          , Context& /*context*/, Skipper const& skipper, Attribute& attr_) const
         {
             qi::skip_over(first, last, skipper);
-            return detail::string_parse(str, first, last, attr);
+            return detail::string_parse(str, first, last, attr_);
         }
 
         template <typename Context>
@@ -163 +163 @@
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
-          , Context& /*context*/, Skipper const& skipper, Attribute& attr) const
+          , Context& /*context*/, Skipper const& skipper, Attribute& attr_) const
         {
             qi::skip_over(first, last, skipper);
-            return detail::string_parse(str_lo, str_hi, first, last, attr);
+            return detail::string_parse(str_lo, str_hi, first, last, attr_);
         }
 
         template <typename Context>

boost/spirit/home/qi/string/symbols.hpp

@@ -257 +257 @@
         template <typename Iterator, typename Context
           , typename Skipper, typename Attribute>
         bool parse(Iterator& first, Iterator const& last
-          , Context& /*context*/, Skipper const& skipper, Attribute& attr) const
+          , Context& /*context*/, Skipper const& skipper, Attribute& attr_) const
         {
             qi::skip_over(first, last, skipper);
 
             if (value_type* val_ptr
                 = lookup->find(first, last, Filter()))
             {
-                spirit::traits::assign_to(*val_ptr, attr);
+                spirit::traits::assign_to(*val_ptr, attr_);
                 return true;
             }
             return false;
@@ -290 +290 @@
             template <typename, typename = unused_type, typename = unused_type>
             struct result { typedef adder const& type; };
 
-            adder(symbols& sym)
-              : sym(sym)
+            adder(symbols& sym_)
+              : sym(sym_)
             {
             }
 
@@ -333 +333 @@
             template <typename, typename = unused_type, typename = unused_type>
             struct result { typedef remover const& type; };
 
-            remover(symbols& sym)
-              : sym(sym)
+            remover(symbols& sym_)
+              : sym(sym_)
             {
             }
 

boost/spirit/home/support/attributes.hpp

@@ -1158 +1158 @@
         template <typename Out>
         struct print_fusion_sequence
         {
-            print_fusion_sequence(Out& out)
-              : out(out), is_first(true) {}
+            print_fusion_sequence(Out& out_)
+              : out(out_), is_first(true) {}
 
             typedef void result_type;
 
@@ -1181 +1181 @@
         template <typename Out>
         struct print_visitor : static_visitor<>
         {
-            print_visitor(Out& out) : out(out) {}
+            print_visitor(Out& out_) : out(out_) {}
 
             template <typename T>
             void operator()(T const& val) const

boost/spirit/home/support/char_set/range.hpp

@@ -22 +22 @@
         typedef T value_type;
 
         range() : first(), last() {}
-        range(T first, T last) : first(first), last(last) {}
+        range(T first_, T last_) : first(first_), last(last_) {}
 
         T first;
         T last;

boost/spirit/home/support/context.hpp

@@ -116 +116 @@
             )
           , locals() {}
 
-        context(Attributes const& attributes)
-          : attributes(attributes), locals() {}
+        context(Attributes const& attributes_)
+          : attributes(attributes_), locals() {}
 
         Attributes attributes;  // The attributes
         Locals locals;          // Local variables

boost/spirit/home/support/detail/what_function.hpp

@@ -20 +20 @@
     template <typename Context>
     struct what_function
     {
-        what_function(info& what, Context& context)
-          : what(what), context(context)
+        what_function(info& what_, Context& context_)
+          : what(what_), context(context_)
         {
             what.value = std::list<info>();
         }

boost/spirit/home/support/info.hpp

@@ -40 +40 @@
             >
         value_type;
 
-        explicit info(utf8_string const& tag)
-          : tag(tag), value(nil()) {}
+        explicit info(utf8_string const& tag_)
+          : tag(tag_), value(nil()) {}
 
         template <typename T>
-        info(utf8_string const& tag, T const& value)
-          : tag(tag), value(value) {}
+        info(utf8_string const& tag_, T const& value_)
+          : tag(tag_), value(value_) {}
 
-        info(utf8_string const& tag, char value)
-          : tag(tag), value(utf8_string(1, value)) {}
+        info(utf8_string const& tag_, char value_)
+          : tag(tag_), value(utf8_string(1, value_)) {}
 
-        info(utf8_string const& tag, wchar_t value)
-          : tag(tag), value(to_utf8(value)) {}
+        info(utf8_string const& tag_, wchar_t value_)
+          : tag(tag_), value(to_utf8(value_)) {}
 
-        info(utf8_string const& tag, ucs4_char value)
-          : tag(tag), value(to_utf8(value)) {}
+        info(utf8_string const& tag_, ucs4_char value_)
+          : tag(tag_), value(to_utf8(value_)) {}
 
         template <typename Char>
-        info(utf8_string const& tag, Char const* str)
-          : tag(tag), value(to_utf8(str)) {}
+        info(utf8_string const& tag_, Char const* str)
+          : tag(tag_), value(to_utf8(str)) {}
 
         template <typename Char, typename Traits, typename Allocator>
-        info(utf8_string const& tag
+        info(utf8_string const& tag_
               , std::basic_string<Char, Traits, Allocator> const& str)
-          : tag(tag), value(to_utf8(str)) {}
+          : tag(tag_), value(to_utf8(str)) {}
 
         utf8_string tag;
         value_type value;
@@ -75 +75 @@
         typedef void result_type;
         typedef basic_info_walker<Callback> this_type;
 
-        basic_info_walker(Callback& callback, utf8_string const& tag, int depth)
-          : callback(callback), tag(tag), depth(depth) {}
+        basic_info_walker(Callback& callback_, utf8_string const& tag_, int depth_)
+          : callback(callback_), tag(tag_), depth(depth_) {}
 
         void operator()(info::nil) const
         {
@@ -128 +128 @@
     {
         typedef utf8_string string;
 
-        simple_printer(Out& out)
-          : out(out) {}
+        simple_printer(Out& out_)
+          : out(out_) {}
 
         void element(string const& tag, string const& value, int /*depth*/) const
         {

boost/spirit/home/support/nonterminal/expand_arg.hpp

@@ -50 +50 @@
         struct result<F(A0&)>
           : result_type<A0> {};
 
-        expand_arg(Context& context)
-          : context(context)
+        expand_arg(Context& context_)
+          : context(context_)
         {
         }
 

boost/spirit/home/support/terminal.hpp

@@ -33 +33 @@
         typedef Terminal terminal_type;
         typedef Args args_type;
 
-        terminal_ex(Args const& args)
-          : args(args) {}
-        terminal_ex(Args const& args, Terminal const& term)
-          : args(args), term(term) {}
+        terminal_ex(Args const& args_)
+          : args(args_) {}
+        terminal_ex(Args const& args_, Terminal const& term_)
+          : args(args_), term(term_) {}
 
         Args args;  // Args is guaranteed to be a fusion::vectorN so you
                     // can use that template for detection and specialization
@@ -50 +50 @@
         typedef Actor actor_type;
         static int const arity = Arity;
 
-        lazy_terminal(Actor const& actor)
-          : actor(actor) {}
-        lazy_terminal(Actor const& actor, Terminal const& term)
-          : actor(actor), term(term) {}
+        lazy_terminal(Actor const& actor_)
+          : actor(actor_) {}
+        lazy_terminal(Actor const& actor_, Terminal const& term_)
+          : actor(actor_), term(term_) {}
 
         Actor actor;
         Terminal term;
@@ -104 +104 @@
         typedef result_type type;
 
         result_type
-        operator()(F f, A0 const& _0) const
+        operator()(F f, A0 const& _0_) const
         {
             typedef typename result_type::proto_child0 child_type;
             return result_type::make(child_type(
-                phoenix::detail::expression::function_eval<F, A0>::make(f, _0)
+                phoenix::detail::expression::function_eval<F, A0>::make(f, _0_)
               , f.proto_base().child0
             ));
         }
@@ -129 +129 @@
         typedef result_type type;
 
         result_type
-        operator()(F f, A0 const& _0, A1 const& _1) const
+        operator()(F f, A0 const& _0_, A1 const& _1_) const
         {
             typedef typename result_type::proto_child0 child_type;
             return result_type::make(child_type(
-                phoenix::detail::expression::function_eval<F, A0, A1>::make(f, _0, _1)
+                phoenix::detail::expression::function_eval<F, A0, A1>::make(f, _0_, _1_)
               , f.proto_base().child0
             ));
         }
@@ -154 +154 @@
         typedef result_type type;
 
         result_type
-        operator()(F f, A0 const& _0, A1 const& _1, A2 const& _2) const
+        operator()(F f, A0 const& _0_, A1 const& _1_, A2 const& _2_) const
         {
             typedef typename result_type::proto_child0 child_type;
             return result_type::make(child_type(
-                phoenix::detail::expression::function_eval<F, A0, A1, A2>::make(f, _0, _1, _2)
+                phoenix::detail::expression::function_eval<F, A0, A1, A2>::make(f, _0_, _1_, _2_)
               , f.proto_base().child0
             ));
         }
@@ -368 +368 @@
 
         template <typename A0>
         typename result<A0>::type
-        operator()(A0 const& _0
+        operator()(A0 const& _0_
           , typename detail::contains_actor<A0>::is_false = 0) const
         {
             typedef typename result<A0>::type result_type;
             typedef typename result_type::proto_child0 child_type;
             return result_type::make(
                 child_type(
-                    detail::make_vector(_0)
+                    detail::make_vector(_0_)
                   , this->proto_base().child0)
             );
         }
 
         template <typename A0, typename A1>
         typename result<A0, A1>::type
-        operator()(A0 const& _0, A1 const& _1
+        operator()(A0 const& _0_, A1 const& _1_
           , typename detail::contains_actor<A0, A1>::is_false = 0) const
         {
             typedef typename result<A0, A1>::type result_type;
             typedef typename result_type::proto_child0 child_type;
             return result_type::make(
                 child_type(
-                    detail::make_vector(_0, _1)
+                    detail::make_vector(_0_, _1_)
                   , this->proto_base().child0)
             );
         }
 
         template <typename A0, typename A1, typename A2>
         typename result<A0, A1, A2>::type
-        operator()(A0 const& _0, A1 const& _1, A2 const& _2
+        operator()(A0 const& _0_, A1 const& _1_, A2 const& _2_
           , typename detail::contains_actor<A0, A1, A2>::is_false = 0) const
         {
             typedef typename result<A0, A1, A2>::type result_type;
             typedef typename result_type::proto_child0 child_type;
             return result_type::make(
                 child_type(
-                    detail::make_vector(_0, _1, _2)
+                    detail::make_vector(_0_, _1_, _2_)
                   , this->proto_base().child0)
             );
         }
@@ -412 +412 @@
         // least one arg is a Phoenix actor.
         template <typename A0>
         typename result<A0>::type
-        operator()(A0 const& _0
+        operator()(A0 const& _0_
           , typename detail::contains_actor<A0>::is_true = 0) const
         {
             return make_lazy<this_type
               , typename phoenix::as_actor<A0>::type>()(*this
-              , phoenix::as_actor<A0>::convert(_0));
+              , phoenix::as_actor<A0>::convert(_0_));
         }
 
         template <typename A0, typename A1>
         typename result<A0, A1>::type
-        operator()(A0 const& _0, A1 const& _1
+        operator()(A0 const& _0_, A1 const& _1_
           , typename detail::contains_actor<A0, A1>::is_true = 0) const
         {
             return make_lazy<this_type
               , typename phoenix::as_actor<A0>::type
               , typename phoenix::as_actor<A1>::type>()(*this
-              , phoenix::as_actor<A0>::convert(_0)
-              , phoenix::as_actor<A1>::convert(_1));
+              , phoenix::as_actor<A0>::convert(_0_)
+              , phoenix::as_actor<A1>::convert(_1_));
         }
 
         template <typename A0, typename A1, typename A2>
         typename result<A0, A1, A2>::type
-        operator()(A0 const& _0, A1 const& _1, A2 const& _2
+        operator()(A0 const& _0_, A1 const& _1_, A2 const& _2_
           , typename detail::contains_actor<A0, A1, A2>::is_true = 0) const
         {
             return make_lazy<this_type
               , typename phoenix::as_actor<A0>::type
               , typename phoenix::as_actor<A1>::type
               , typename phoenix::as_actor<A2>::type>()(*this
-              , phoenix::as_actor<A0>::convert(_0)
-              , phoenix::as_actor<A1>::convert(_1)
-              , phoenix::as_actor<A2>::convert(_2));
+              , phoenix::as_actor<A0>::convert(_0_)
+              , phoenix::as_actor<A1>::convert(_1_)
+              , phoenix::as_actor<A2>::convert(_2_));
         }
 
     private: