From fa666b5328704f147dcc60be45f1bcdf3826bfcb Mon Sep 17 00:00:00 2001 From: Franz Detro Date: Tue, 4 Sep 2012 15:16:56 +0200 Subject: [PATCH] fix warnings in boost spirit --- boost/spirit/home/phoenix/core/value.hpp | 4 +- boost/spirit/home/phoenix/function/function.hpp | 2 +- boost/spirit/home/phoenix/object/construct.hpp | 2 +- boost/spirit/home/qi/action/action.hpp | 4 +- boost/spirit/home/qi/auxiliary/attr.hpp | 4 +- boost/spirit/home/qi/auxiliary/attr_cast.hpp | 12 ++--- boost/spirit/home/qi/auxiliary/eps.hpp | 4 +- boost/spirit/home/qi/auxiliary/lazy.hpp | 14 +++--- boost/spirit/home/qi/binary/binary.hpp | 12 ++--- boost/spirit/home/qi/char/char.hpp | 8 +-- boost/spirit/home/qi/char/char_parser.hpp | 8 +-- .../spirit/home/qi/detail/alternative_function.hpp | 14 +++--- boost/spirit/home/qi/detail/expect_function.hpp | 12 ++--- boost/spirit/home/qi/detail/fail_function.hpp | 12 ++--- boost/spirit/home/qi/detail/pass_container.hpp | 4 +- boost/spirit/home/qi/detail/pass_function.hpp | 12 ++--- boost/spirit/home/qi/detail/permute_function.hpp | 12 ++--- boost/spirit/home/qi/detail/unused_skipper.hpp | 4 +- boost/spirit/home/qi/directive/as.hpp | 12 ++--- boost/spirit/home/qi/directive/hold.hpp | 10 ++-- boost/spirit/home/qi/directive/lexeme.hpp | 8 +-- boost/spirit/home/qi/directive/matches.hpp | 8 +-- boost/spirit/home/qi/directive/no_skip.hpp | 8 +-- boost/spirit/home/qi/directive/omit.hpp | 8 +-- boost/spirit/home/qi/directive/raw.hpp | 8 +-- boost/spirit/home/qi/directive/repeat.hpp | 28 +++++------ boost/spirit/home/qi/directive/skip.hpp | 16 +++--- boost/spirit/home/qi/nonterminal/debug_handler.hpp | 12 ++--- .../home/qi/nonterminal/detail/parameterized.hpp | 8 +-- .../home/qi/nonterminal/detail/parser_binder.hpp | 8 +-- boost/spirit/home/qi/nonterminal/error_handler.hpp | 6 +-- boost/spirit/home/qi/nonterminal/grammar.hpp | 8 +-- boost/spirit/home/qi/nonterminal/rule.hpp | 26 +++++----- .../spirit/home/qi/nonterminal/success_handler.hpp | 6 +-- boost/spirit/home/qi/numeric/bool.hpp | 8 +-- boost/spirit/home/qi/numeric/bool_policies.hpp | 16 +++--- boost/spirit/home/qi/numeric/int.hpp | 8 +-- boost/spirit/home/qi/numeric/numeric_utils.hpp | 22 ++++---- boost/spirit/home/qi/numeric/real.hpp | 14 +++--- boost/spirit/home/qi/numeric/real_policies.hpp | 20 ++++---- boost/spirit/home/qi/numeric/uint.hpp | 8 +-- boost/spirit/home/qi/operator/alternative.hpp | 8 +-- boost/spirit/home/qi/operator/and_predicate.hpp | 4 +- boost/spirit/home/qi/operator/difference.hpp | 8 +-- boost/spirit/home/qi/operator/expect.hpp | 4 +- boost/spirit/home/qi/operator/kleene.hpp | 10 ++-- boost/spirit/home/qi/operator/list.hpp | 10 ++-- boost/spirit/home/qi/operator/not_predicate.hpp | 4 +- boost/spirit/home/qi/operator/optional.hpp | 16 +++--- boost/spirit/home/qi/operator/permutation.hpp | 8 +-- boost/spirit/home/qi/operator/plus.hpp | 10 ++-- boost/spirit/home/qi/operator/sequence_base.hpp | 12 ++--- boost/spirit/home/qi/operator/sequential_or.hpp | 8 +-- boost/spirit/home/qi/parse_attr.hpp | 8 +-- boost/spirit/home/qi/reference.hpp | 4 +- boost/spirit/home/qi/stream/stream.hpp | 4 +- boost/spirit/home/qi/string/detail/tst.hpp | 4 +- boost/spirit/home/qi/string/lit.hpp | 12 ++--- boost/spirit/home/qi/string/symbols.hpp | 12 ++--- boost/spirit/home/support/attributes.hpp | 6 +-- boost/spirit/home/support/char_set/range.hpp | 2 +- boost/spirit/home/support/context.hpp | 4 +- boost/spirit/home/support/detail/what_function.hpp | 4 +- boost/spirit/home/support/info.hpp | 36 +++++++------- .../spirit/home/support/nonterminal/expand_arg.hpp | 4 +- boost/spirit/home/support/terminal.hpp | 58 +++++++++++----------- 66 files changed, 340 insertions(+), 340 deletions(-) diff --git a/boost/spirit/home/phoenix/core/value.hpp b/boost/spirit/home/phoenix/core/value.hpp index a275a7d..5cfd94a 100644 --- a/boost/spirit/home/phoenix/core/value.hpp +++ b/boost/spirit/home/phoenix/core/value.hpp @@ -88,8 +88,8 @@ namespace boost { namespace phoenix type; }; - actor_value(Actor const& actor) - : actor(actor) {} + actor_value(Actor const& actor_) + : actor(actor_) {} template typename result::type diff --git a/boost/spirit/home/phoenix/function/function.hpp b/boost/spirit/home/phoenix/function/function.hpp index 1cf4701..e33d02d 100644 --- a/boost/spirit/home/phoenix/function/function.hpp +++ b/boost/spirit/home/phoenix/function/function.hpp @@ -16,7 +16,7 @@ namespace boost { namespace phoenix struct function { function() : f() {} - function(F const& f) : f(f) {} + function(F const& f_) : f(f_) {} actor, F>::type> operator()() const diff --git a/boost/spirit/home/phoenix/object/construct.hpp b/boost/spirit/home/phoenix/object/construct.hpp index d26d6a4..ec743b5 100644 --- a/boost/spirit/home/phoenix/object/construct.hpp +++ b/boost/spirit/home/phoenix/object/construct.hpp @@ -27,7 +27,7 @@ namespace boost { namespace phoenix template static RT - eval(Env const& env) + eval(Env const& /*env*/) { return RT(); } diff --git a/boost/spirit/home/qi/action/action.hpp b/boost/spirit/home/qi/action/action.hpp index 746dd84..2bdf7d8 100644 --- a/boost/spirit/home/qi/action/action.hpp +++ b/boost/spirit/home/qi/action/action.hpp @@ -41,8 +41,8 @@ namespace boost { namespace spirit { namespace qi : traits::attribute_of {}; - 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 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 } diff --git a/boost/spirit/home/qi/auxiliary/attr_cast.hpp b/boost/spirit/home/qi/auxiliary/attr_cast.hpp index a8fc688..b53c64f 100644 --- a/boost/spirit/home/qi/auxiliary/attr_cast.hpp +++ b/boost/spirit/home/qi/auxiliary/attr_cast.hpp @@ -53,8 +53,8 @@ namespace boost { namespace spirit { namespace qi , traits::attribute_of >::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,7 +75,7 @@ namespace boost { namespace spirit { namespace qi , 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,18 +90,18 @@ namespace boost { namespace spirit { namespace qi 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(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; } diff --git a/boost/spirit/home/qi/auxiliary/eps.hpp b/boost/spirit/home/qi/auxiliary/eps.hpp index fe23935..4ba6aa4 100644 --- a/boost/spirit/home/qi/auxiliary/eps.hpp +++ b/boost/spirit/home/qi/auxiliary/eps.hpp @@ -80,8 +80,8 @@ namespace boost { namespace spirit { namespace qi typedef unused_type type; }; - semantic_predicate(bool predicate) - : predicate(predicate) {} + semantic_predicate(bool predicate_) + : predicate(predicate_) {} template diff --git a/boost/spirit/home/qi/auxiliary/lazy.hpp b/boost/spirit/home/qi/auxiliary/lazy.hpp index b935261..60b61d4 100644 --- a/boost/spirit/home/qi/auxiliary/lazy.hpp +++ b/boost/spirit/home/qi/auxiliary/lazy.hpp @@ -60,7 +60,7 @@ namespace boost { namespace spirit { namespace qi 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,8 +111,8 @@ namespace boost { namespace spirit { namespace qi 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 @@ -183,10 +183,10 @@ namespace boost { namespace spirit { namespace qi }; 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 diff --git a/boost/spirit/home/qi/binary/binary.hpp b/boost/spirit/home/qi/binary/binary.hpp index 7d47a6e..a4e83f0 100644 --- a/boost/spirit/home/qi/binary/binary.hpp +++ b/boost/spirit/home/qi/binary/binary.hpp @@ -241,7 +241,7 @@ namespace boost { namespace spirit { namespace qi , 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,7 +257,7 @@ namespace boost { namespace spirit { namespace qi } first = it; - spirit::traits::assign_to(attr_, attr); + spirit::traits::assign_to(attr_, attr_param); return true; } @@ -280,14 +280,14 @@ namespace boost { namespace spirit { namespace qi typedef unused_type type; }; - binary_lit_parser(V n) - : n(n) {} + binary_lit_parser(V n_) + : n(n_) {} template 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,7 +317,7 @@ namespace boost { namespace spirit { namespace qi } first = it; - spirit::traits::assign_to(attr_, attr); + spirit::traits::assign_to(attr_, attr_param); return true; } diff --git a/boost/spirit/home/qi/char/char.hpp b/boost/spirit/home/qi/char/char.hpp index 7269da4..8c22aaa 100644 --- a/boost/spirit/home/qi/char/char.hpp +++ b/boost/spirit/home/qi/char/char.hpp @@ -123,8 +123,8 @@ namespace boost { namespace spirit { namespace qi typedef CharEncoding char_encoding; template - literal_char(Char ch) - : ch(static_cast(ch)) {} + literal_char(Char ch_) + : ch(static_cast(ch_)) {} template struct attribute @@ -201,8 +201,8 @@ namespace boost { namespace spirit { namespace qi 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 bool test(CharParam ch_, Context&) const diff --git a/boost/spirit/home/qi/char/char_parser.hpp b/boost/spirit/home/qi/char/char_parser.hpp index b896f73..1d06d7c 100644 --- a/boost/spirit/home/qi/char/char_parser.hpp +++ b/boost/spirit/home/qi/char/char_parser.hpp @@ -61,13 +61,13 @@ namespace boost { namespace spirit { namespace qi template 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,8 +87,8 @@ namespace boost { namespace spirit { namespace qi struct negated_char_parser : char_parser, typename Positive::char_type> { - negated_char_parser(Positive const& positive) - : positive(positive) {} + negated_char_parser(Positive const& positive_) + : positive(positive_) {} template bool test(CharParam ch, Context& context) const diff --git a/boost/spirit/home/qi/detail/alternative_function.hpp b/boost/spirit/home/qi/detail/alternative_function.hpp index aad0c54..e2223b8 100644 --- a/boost/spirit/home/qi/detail/alternative_function.hpp +++ b/boost/spirit/home/qi/detail/alternative_function.hpp @@ -56,10 +56,10 @@ namespace boost { namespace spirit { namespace qi { namespace detail 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,9 +185,9 @@ namespace boost { namespace spirit { namespace qi { namespace detail struct alternative_function { 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_) { } diff --git a/boost/spirit/home/qi/detail/expect_function.hpp b/boost/spirit/home/qi/detail/expect_function.hpp index 34dd910..920e309 100644 --- a/boost/spirit/home/qi/detail/expect_function.hpp +++ b/boost/spirit/home/qi/detail/expect_function.hpp @@ -26,12 +26,12 @@ namespace boost { namespace spirit { namespace qi { namespace detail 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) { } diff --git a/boost/spirit/home/qi/detail/fail_function.hpp b/boost/spirit/home/qi/detail/fail_function.hpp index fca03b3..7ab8d82 100644 --- a/boost/spirit/home/qi/detail/fail_function.hpp +++ b/boost/spirit/home/qi/detail/fail_function.hpp @@ -22,12 +22,12 @@ namespace boost { namespace spirit { namespace qi { namespace detail 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_) { } diff --git a/boost/spirit/home/qi/detail/pass_container.hpp b/boost/spirit/home/qi/detail/pass_container.hpp index 82e153a..93dcde2 100644 --- a/boost/spirit/home/qi/detail/pass_container.hpp +++ b/boost/spirit/home/qi/detail/pass_container.hpp @@ -247,8 +247,8 @@ namespace boost { namespace spirit { namespace qi { namespace detail 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 diff --git a/boost/spirit/home/qi/detail/pass_function.hpp b/boost/spirit/home/qi/detail/pass_function.hpp index 2d9e6ba..555adb8 100644 --- a/boost/spirit/home/qi/detail/pass_function.hpp +++ b/boost/spirit/home/qi/detail/pass_function.hpp @@ -20,12 +20,12 @@ namespace boost { namespace spirit { namespace qi { namespace detail 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_) { } diff --git a/boost/spirit/home/qi/detail/permute_function.hpp b/boost/spirit/home/qi/detail/permute_function.hpp index 13c1b8c..8b1ed8a 100644 --- a/boost/spirit/home/qi/detail/permute_function.hpp +++ b/boost/spirit/home/qi/detail/permute_function.hpp @@ -20,12 +20,12 @@ namespace boost { namespace spirit { namespace qi { namespace detail 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_) { } diff --git a/boost/spirit/home/qi/detail/unused_skipper.hpp b/boost/spirit/home/qi/detail/unused_skipper.hpp index c1405d6..6fc7f8d 100644 --- a/boost/spirit/home/qi/detail/unused_skipper.hpp +++ b/boost/spirit/home/qi/detail/unused_skipper.hpp @@ -17,8 +17,8 @@ namespace boost { namespace spirit { namespace qi { namespace detail template struct unused_skipper : unused_type { - unused_skipper(Skipper const& skipper) - : skipper(skipper) {} + unused_skipper(Skipper const& skipper_) + : skipper(skipper_) {} Skipper const& skipper; private: diff --git a/boost/spirit/home/qi/directive/as.hpp b/boost/spirit/home/qi/directive/as.hpp index 9ace587..e0376eb 100644 --- a/boost/spirit/home/qi/directive/as.hpp +++ b/boost/spirit/home/qi/directive/as.hpp @@ -76,8 +76,8 @@ namespace boost { namespace spirit { namespace qi struct as_directive : unary_parser > { typedef Subject subject_type; - as_directive(Subject const& subject) - : subject(subject) {} + as_directive(Subject const& subject_) + : subject(subject_) {} template struct attribute @@ -88,13 +88,13 @@ namespace boost { namespace spirit { namespace qi template 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,10 +103,10 @@ namespace boost { namespace spirit { namespace qi template 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; diff --git a/boost/spirit/home/qi/directive/hold.hpp b/boost/spirit/home/qi/directive/hold.hpp index d5b2ed5..9cd905c 100644 --- a/boost/spirit/home/qi/directive/hold.hpp +++ b/boost/spirit/home/qi/directive/hold.hpp @@ -42,8 +42,8 @@ namespace boost { namespace spirit { namespace qi struct hold_directive : unary_parser > { typedef Subject subject_type; - hold_directive(Subject const& subject) - : subject(subject) {} + hold_directive(Subject const& subject_) + : subject(subject_) {} template struct attribute @@ -56,12 +56,12 @@ namespace boost { namespace spirit { namespace qi template 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; diff --git a/boost/spirit/home/qi/directive/lexeme.hpp b/boost/spirit/home/qi/directive/lexeme.hpp index f0b8399..e39fc74 100644 --- a/boost/spirit/home/qi/directive/lexeme.hpp +++ b/boost/spirit/home/qi/directive/lexeme.hpp @@ -42,8 +42,8 @@ namespace boost { namespace spirit { namespace qi struct lexeme_directive : unary_parser > { typedef Subject subject_type; - lexeme_directive(Subject const& subject) - : subject(subject) {} + lexeme_directive(Subject const& subject_) + : subject(subject_) {} template struct attribute @@ -57,11 +57,11 @@ namespace boost { namespace spirit { namespace qi , 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), attr); + , detail::unused_skipper(skipper), attr_); } template diff --git a/boost/spirit/home/qi/directive/matches.hpp b/boost/spirit/home/qi/directive/matches.hpp index b534927..b6fecb9 100644 --- a/boost/spirit/home/qi/directive/matches.hpp +++ b/boost/spirit/home/qi/directive/matches.hpp @@ -44,8 +44,8 @@ namespace boost { namespace spirit { namespace qi struct matches_directive : unary_parser > { typedef Subject subject_type; - matches_directive(Subject const& subject) - : subject(subject) {} + matches_directive(Subject const& subject_) + : subject(subject_) {} template struct attribute @@ -56,10 +56,10 @@ namespace boost { namespace spirit { namespace qi template 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; } diff --git a/boost/spirit/home/qi/directive/no_skip.hpp b/boost/spirit/home/qi/directive/no_skip.hpp index 9764d4a..eeeb33b 100644 --- a/boost/spirit/home/qi/directive/no_skip.hpp +++ b/boost/spirit/home/qi/directive/no_skip.hpp @@ -45,8 +45,8 @@ namespace boost { namespace spirit { namespace qi struct no_skip_directive : unary_parser > { typedef Subject subject_type; - no_skip_directive(Subject const& subject) - : subject(subject) {} + no_skip_directive(Subject const& subject_) + : subject(subject_) {} template struct attribute @@ -60,10 +60,10 @@ namespace boost { namespace spirit { namespace qi , 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), attr); + , detail::unused_skipper(skipper), attr_); } template diff --git a/boost/spirit/home/qi/directive/omit.hpp b/boost/spirit/home/qi/directive/omit.hpp index b0ed86b..05a6a76 100644 --- a/boost/spirit/home/qi/directive/omit.hpp +++ b/boost/spirit/home/qi/directive/omit.hpp @@ -45,8 +45,8 @@ namespace boost { namespace spirit { namespace qi struct omit_directive : unary_parser > { typedef Subject subject_type; - omit_directive(Subject const& subject) - : subject(subject) {} + omit_directive(Subject const& subject_) + : subject(subject_) {} template struct attribute @@ -57,9 +57,9 @@ namespace boost { namespace spirit { namespace qi template 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 diff --git a/boost/spirit/home/qi/directive/raw.hpp b/boost/spirit/home/qi/directive/raw.hpp index b88458e..e1d208e 100644 --- a/boost/spirit/home/qi/directive/raw.hpp +++ b/boost/spirit/home/qi/directive/raw.hpp @@ -44,8 +44,8 @@ namespace boost { namespace spirit { namespace qi struct raw_directive : unary_parser > { typedef Subject subject_type; - raw_directive(Subject const& subject) - : subject(subject) {} + raw_directive(Subject const& subject_) + : subject(subject_) {} template struct attribute @@ -56,13 +56,13 @@ namespace boost { namespace spirit { namespace qi template 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; } diff --git a/boost/spirit/home/qi/directive/repeat.hpp b/boost/spirit/home/qi/directive/repeat.hpp index 252e18f..72c3a99 100644 --- a/boost/spirit/home/qi/directive/repeat.hpp +++ b/boost/spirit/home/qi/directive/repeat.hpp @@ -81,8 +81,8 @@ namespace boost { namespace spirit { namespace qi template 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,9 +99,9 @@ namespace boost { namespace spirit { namespace qi template 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,8 +119,8 @@ namespace boost { namespace spirit { namespace qi template 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,8 +153,8 @@ namespace boost { namespace spirit { namespace qi 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 bool parse_container(F f) const @@ -183,17 +183,17 @@ namespace boost { namespace spirit { namespace qi , 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 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; diff --git a/boost/spirit/home/qi/directive/skip.hpp b/boost/spirit/home/qi/directive/skip.hpp index 28539da..ecf1df2 100644 --- a/boost/spirit/home/qi/directive/skip.hpp +++ b/boost/spirit/home/qi/directive/skip.hpp @@ -70,17 +70,17 @@ namespace boost { namespace spirit { namespace qi type; }; - reskip_parser(Subject const& subject) - : subject(subject) {} + reskip_parser(Subject const& subject_) + : subject(subject_) {} template 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 @@ -106,16 +106,16 @@ namespace boost { namespace spirit { namespace qi 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 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 diff --git a/boost/spirit/home/qi/nonterminal/debug_handler.hpp b/boost/spirit/home/qi/nonterminal/debug_handler.hpp index 3328732..6a9f536 100644 --- a/boost/spirit/home/qi/nonterminal/debug_handler.hpp +++ b/boost/spirit/home/qi/nonterminal/debug_handler.hpp @@ -36,12 +36,12 @@ namespace boost { namespace spirit { namespace qi 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_) { } diff --git a/boost/spirit/home/qi/nonterminal/detail/parameterized.hpp b/boost/spirit/home/qi/nonterminal/detail/parameterized.hpp index 0300a06..825fa40 100644 --- a/boost/spirit/home/qi/nonterminal/detail/parameterized.hpp +++ b/boost/spirit/home/qi/nonterminal/detail/parameterized.hpp @@ -27,8 +27,8 @@ namespace boost { namespace spirit { namespace qi struct parameterized_nonterminal : parser > { - 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,11 +41,11 @@ namespace boost { namespace spirit { namespace qi , 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 diff --git a/boost/spirit/home/qi/nonterminal/detail/parser_binder.hpp b/boost/spirit/home/qi/nonterminal/detail/parser_binder.hpp index 91bceba..87d8e84 100644 --- a/boost/spirit/home/qi/nonterminal/detail/parser_binder.hpp +++ b/boost/spirit/home/qi/nonterminal/detail/parser_binder.hpp @@ -21,8 +21,8 @@ namespace boost { namespace spirit { namespace qi { namespace detail template struct parser_binder { - parser_binder(Parser const& p) - : p(p) {} + parser_binder(Parser const& p_) + : p(p_) {} template bool call(Iterator& first, Iterator const& last @@ -60,8 +60,8 @@ namespace boost { namespace spirit { namespace qi { namespace detail template struct parser_binder { - parser_binder(Parser const& p) - : p(p) {} + parser_binder(Parser const& p_) + : p(p_) {} template bool operator()( diff --git a/boost/spirit/home/qi/nonterminal/error_handler.hpp b/boost/spirit/home/qi/nonterminal/error_handler.hpp index 6dd4f08..e8c4f87 100644 --- a/boost/spirit/home/qi/nonterminal/error_handler.hpp +++ b/boost/spirit/home/qi/nonterminal/error_handler.hpp @@ -76,9 +76,9 @@ namespace boost { namespace spirit { namespace qi )> function_type; - error_handler(function_type subject, F f) - : subject(subject) - , f(f) + error_handler(function_type subject_, F f_) + : subject(subject_) + , f(f_) { } diff --git a/boost/spirit/home/qi/nonterminal/grammar.hpp b/boost/spirit/home/qi/nonterminal/grammar.hpp index 982e49b..d41590c 100644 --- a/boost/spirit/home/qi/nonterminal/grammar.hpp +++ b/boost/spirit/home/qi/nonterminal/grammar.hpp @@ -56,9 +56,9 @@ namespace boost { namespace spirit { namespace qi grammar( start_type const& start - , std::string const& name_ = "unnamed-grammar") + , std::string const& name = "unnamed-grammar") : proto::extends(terminal::make(reference_(start))) - , name_(name_) + , name_(name) {} // This constructor is used to catch if the start rule is not @@ -90,10 +90,10 @@ namespace boost { namespace spirit { namespace qi template 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 diff --git a/boost/spirit/home/qi/nonterminal/rule.hpp b/boost/spirit/home/qi/nonterminal/rule.hpp index 23d2559..8941c23 100644 --- a/boost/spirit/home/qi/nonterminal/rule.hpp +++ b/boost/spirit/home/qi/nonterminal/rule.hpp @@ -154,9 +154,9 @@ namespace boost { namespace spirit { namespace qi >::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,7 +168,7 @@ namespace boost { namespace spirit { namespace qi } template - 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,9 +184,9 @@ namespace boost { namespace spirit { namespace qi } template - 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(*this, expr, traits::matches()); } @@ -272,7 +272,7 @@ namespace boost { namespace spirit { namespace qi template bool parse(Iterator& first, Iterator const& last , Context& /*context*/, Skipper const& skipper - , Attribute& attr) const + , Attribute& attr_param) const { if (f) { @@ -288,7 +288,7 @@ namespace boost { namespace spirit { namespace qi 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,12 +304,12 @@ namespace boost { namespace spirit { namespace qi { // 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,7 +318,7 @@ namespace boost { namespace spirit { namespace qi , 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,7 +334,7 @@ namespace boost { namespace spirit { namespace qi 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,12 +350,12 @@ namespace boost { namespace spirit { namespace qi { // 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; } diff --git a/boost/spirit/home/qi/nonterminal/success_handler.hpp b/boost/spirit/home/qi/nonterminal/success_handler.hpp index 3b3133c..5db83a2 100644 --- a/boost/spirit/home/qi/nonterminal/success_handler.hpp +++ b/boost/spirit/home/qi/nonterminal/success_handler.hpp @@ -29,9 +29,9 @@ namespace boost { namespace spirit { namespace qi )> function_type; - success_handler(function_type subject, F f) - : subject(subject) - , f(f) + success_handler(function_type subject_, F f_) + : subject(subject_) + , f(f_) { } diff --git a/boost/spirit/home/qi/numeric/bool.hpp b/boost/spirit/home/qi/numeric/bool.hpp index 4041fc3..74e1343 100644 --- a/boost/spirit/home/qi/numeric/bool.hpp +++ b/boost/spirit/home/qi/numeric/bool.hpp @@ -153,11 +153,11 @@ namespace boost { namespace spirit { namespace qi , 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 extract; qi::skip_over(first, last, skipper); - return extract::parse(first, last, attr, BoolPolicies()); + return extract::parse(first, last, attr_, BoolPolicies()); } template @@ -184,11 +184,11 @@ namespace boost { namespace spirit { namespace qi , 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 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 diff --git a/boost/spirit/home/qi/numeric/bool_policies.hpp b/boost/spirit/home/qi/numeric/bool_policies.hpp index 1e7c6e5..62641a6 100644 --- a/boost/spirit/home/qi/numeric/bool_policies.hpp +++ b/boost/spirit/home/qi/numeric/bool_policies.hpp @@ -24,11 +24,11 @@ namespace boost { namespace spirit { namespace qi { template 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,11 +36,11 @@ namespace boost { namespace spirit { namespace qi template 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,11 +53,11 @@ namespace boost { namespace spirit { namespace qi { template 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,11 +65,11 @@ namespace boost { namespace spirit { namespace qi template 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; diff --git a/boost/spirit/home/qi/numeric/int.hpp b/boost/spirit/home/qi/numeric/int.hpp index a30bb3f..2da9817 100644 --- a/boost/spirit/home/qi/numeric/int.hpp +++ b/boost/spirit/home/qi/numeric/int.hpp @@ -198,11 +198,11 @@ namespace boost { namespace spirit { namespace qi , 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 extract; qi::skip_over(first, last, skipper); - return extract::call(first, last, attr); + return extract::call(first, last, attr_); } template @@ -236,7 +236,7 @@ namespace boost { namespace spirit { namespace qi , 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 extract; qi::skip_over(first, last, skipper); @@ -246,7 +246,7 @@ namespace boost { namespace spirit { namespace qi if (extract::call(first, last, attr_) && (attr_ == n_)) { - traits::assign_to(attr_, attr); + traits::assign_to(attr_, attr_param); return true; } diff --git a/boost/spirit/home/qi/numeric/numeric_utils.hpp b/boost/spirit/home/qi/numeric/numeric_utils.hpp index 72a54d8..eebf40a 100644 --- a/boost/spirit/home/qi/numeric/numeric_utils.hpp +++ b/boost/spirit/home/qi/numeric/numeric_utils.hpp @@ -53,7 +53,7 @@ namespace boost { namespace spirit { namespace qi not_supported_radix, ()); template - 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,7 +69,7 @@ namespace boost { namespace spirit { namespace qi Iterator save = first; if (!extract_type::parse(first, last, - detail::cast_unsigned::call(attr))) + detail::cast_unsigned::call(attr_))) { first = save; return false; @@ -81,10 +81,10 @@ namespace boost { namespace spirit { namespace qi 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,7 +103,7 @@ namespace boost { namespace spirit { namespace qi not_supported_radix, ()); template - 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,9 +119,9 @@ namespace boost { namespace spirit { namespace qi 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,10 +135,10 @@ namespace boost { namespace spirit { namespace qi 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; diff --git a/boost/spirit/home/qi/numeric/real.hpp b/boost/spirit/home/qi/numeric/real.hpp index 325acd5..5c78421 100644 --- a/boost/spirit/home/qi/numeric/real.hpp +++ b/boost/spirit/home/qi/numeric/real.hpp @@ -161,24 +161,24 @@ namespace boost { namespace spirit { namespace qi template bool parse(Iterator& first, Iterator const& last , Context& /*context*/, Skipper const& skipper - , T& attr) const + , T& attr_) const { typedef detail::real_impl extract; qi::skip_over(first, last, skipper); - return extract::parse(first, last, attr, RealPolicies()); + return extract::parse(first, last, attr_, RealPolicies()); } template 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,8 +207,8 @@ namespace boost { namespace spirit { namespace qi template 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 extract; qi::skip_over(first, last, skipper); @@ -219,7 +219,7 @@ namespace boost { namespace spirit { namespace qi if (extract::parse(first, last, attr_, RealPolicies()) && (attr_ == n_)) { - traits::assign_to(attr_, attr); + traits::assign_to(attr_, attr_param); return true; } diff --git a/boost/spirit/home/qi/numeric/real_policies.hpp b/boost/spirit/home/qi/numeric/real_policies.hpp index 6512d6f..1315888 100644 --- a/boost/spirit/home/qi/numeric/real_policies.hpp +++ b/boost/spirit/home/qi/numeric/real_policies.hpp @@ -37,9 +37,9 @@ namespace boost { namespace spirit { namespace qi template static bool - parse_n(Iterator& first, Iterator const& last, Attribute& attr) + parse_n(Iterator& first, Iterator const& last, Attribute& attr_) { - return extract_uint::call(first, last, attr); + return extract_uint::call(first, last, attr_); } template @@ -54,9 +54,9 @@ namespace boost { namespace spirit { namespace qi template 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::call(first, last, attr); + return extract_uint::call(first, last, attr_); } template @@ -71,9 +71,9 @@ namespace boost { namespace spirit { namespace qi template 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::call(first, last, attr); + return extract_int::call(first, last, attr_); } /////////////////////////////////////////////////////////////////////// @@ -105,7 +105,7 @@ namespace boost { namespace spirit { namespace qi /////////////////////////////////////////////////////////////////////// template 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,7 +128,7 @@ namespace boost { namespace spirit { namespace qi first = ++i; } - attr = std::numeric_limits::quiet_NaN(); + attr_ = std::numeric_limits::quiet_NaN(); return true; } return false; @@ -136,7 +136,7 @@ namespace boost { namespace spirit { namespace qi template 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,7 +149,7 @@ namespace boost { namespace spirit { namespace qi { // skip allowed 'inity' part of infinity detail::string_parse("inity", "INITY", first, last, unused); - attr = std::numeric_limits::infinity(); + attr_ = std::numeric_limits::infinity(); return true; } return false; diff --git a/boost/spirit/home/qi/numeric/uint.hpp b/boost/spirit/home/qi/numeric/uint.hpp index ea763d3..f6d1efd 100644 --- a/boost/spirit/home/qi/numeric/uint.hpp +++ b/boost/spirit/home/qi/numeric/uint.hpp @@ -235,11 +235,11 @@ namespace boost { namespace spirit { namespace qi , 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 extract; qi::skip_over(first, last, skipper); - return extract::call(first, last, attr); + return extract::call(first, last, attr_); } template @@ -273,7 +273,7 @@ namespace boost { namespace spirit { namespace qi , 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 extract; qi::skip_over(first, last, skipper); @@ -283,7 +283,7 @@ namespace boost { namespace spirit { namespace qi if (extract::call(first, last, attr_) && (attr_ == n_)) { - traits::assign_to(attr_, attr); + traits::assign_to(attr_, attr_param); return true; } diff --git a/boost/spirit/home/qi/operator/alternative.hpp b/boost/spirit/home/qi/operator/alternative.hpp index 9785d45..22cfdef 100644 --- a/boost/spirit/home/qi/operator/alternative.hpp +++ b/boost/spirit/home/qi/operator/alternative.hpp @@ -63,17 +63,17 @@ namespace boost { namespace spirit { namespace qi type; }; - alternative(Elements const& elements) - : elements(elements) {} + alternative(Elements const& elements_) + : elements(elements_) {} template bool parse(Iterator& first, Iterator const& last , Context& context, Skipper const& skipper - , Attribute& attr) const + , Attribute& attr_) const { detail::alternative_function - 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); diff --git a/boost/spirit/home/qi/operator/and_predicate.hpp b/boost/spirit/home/qi/operator/and_predicate.hpp index 031ce1d..0554c10 100644 --- a/boost/spirit/home/qi/operator/and_predicate.hpp +++ b/boost/spirit/home/qi/operator/and_predicate.hpp @@ -43,8 +43,8 @@ namespace boost { namespace spirit { namespace qi typedef unused_type type; }; - and_predicate(Subject const& subject) - : subject(subject) {} + and_predicate(Subject const& subject_) + : subject(subject_) {} template diff --git a/boost/spirit/home/qi/operator/difference.hpp b/boost/spirit/home/qi/operator/difference.hpp index 5f8c4c9..f703d7f 100644 --- a/boost/spirit/home/qi/operator/difference.hpp +++ b/boost/spirit/home/qi/operator/difference.hpp @@ -46,14 +46,14 @@ namespace boost { namespace spirit { namespace qi type; }; - difference(Left const& left, Right const& right) - : left(left), right(right) {} + difference(Left const& left_, Right const& right_) + : left(left_), right(right_) {} template 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,7 +71,7 @@ namespace boost { namespace spirit { namespace qi return false; } // RHS fails, now try LHS - return left.parse(first, last, context, skipper, attr); + return left.parse(first, last, context, skipper, attr_); } template diff --git a/boost/spirit/home/qi/operator/expect.hpp b/boost/spirit/home/qi/operator/expect.hpp index c42b2de..ff279fd 100644 --- a/boost/spirit/home/qi/operator/expect.hpp +++ b/boost/spirit/home/qi/operator/expect.hpp @@ -39,9 +39,9 @@ namespace boost { namespace spirit { namespace qi template 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() {} diff --git a/boost/spirit/home/qi/operator/kleene.hpp b/boost/spirit/home/qi/operator/kleene.hpp index ae778f0..798e63d 100644 --- a/boost/spirit/home/qi/operator/kleene.hpp +++ b/boost/spirit/home/qi/operator/kleene.hpp @@ -56,8 +56,8 @@ namespace boost { namespace spirit { namespace qi type; }; - kleene(Subject const& subject) - : subject(subject) {} + kleene(Subject const& subject_) + : subject(subject_) {} template bool parse_container(F f) const @@ -71,17 +71,17 @@ namespace boost { namespace spirit { namespace qi , 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 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; diff --git a/boost/spirit/home/qi/operator/list.hpp b/boost/spirit/home/qi/operator/list.hpp index cc067cd..c5b3ef6 100644 --- a/boost/spirit/home/qi/operator/list.hpp +++ b/boost/spirit/home/qi/operator/list.hpp @@ -55,8 +55,8 @@ namespace boost { namespace spirit { namespace qi type; }; - list(Left const& left, Right const& right) - : left(left), right(right) {} + list(Left const& left_, Right const& right_) + : left(left_), right(right_) {} template bool parse_container(F f) const @@ -80,17 +80,17 @@ namespace boost { namespace spirit { namespace qi , 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 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; diff --git a/boost/spirit/home/qi/operator/not_predicate.hpp b/boost/spirit/home/qi/operator/not_predicate.hpp index 57cbb0d..1fb81cd 100644 --- a/boost/spirit/home/qi/operator/not_predicate.hpp +++ b/boost/spirit/home/qi/operator/not_predicate.hpp @@ -42,8 +42,8 @@ namespace boost { namespace spirit { namespace qi typedef unused_type type; }; - not_predicate(Subject const& subject) - : subject(subject) {} + not_predicate(Subject const& subject_) + : subject(subject_) {} template diff --git a/boost/spirit/home/qi/operator/optional.hpp b/boost/spirit/home/qi/operator/optional.hpp index b183ad6..4910c7f 100644 --- a/boost/spirit/home/qi/operator/optional.hpp +++ b/boost/spirit/home/qi/operator/optional.hpp @@ -55,14 +55,14 @@ namespace boost { namespace spirit { namespace qi type; }; - optional(Subject const& subject) - : subject(subject) {} + optional(Subject const& subject_) + : subject(subject_) {} template 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::type val = @@ -71,7 +71,7 @@ namespace boost { namespace spirit { namespace qi 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,9 +80,9 @@ namespace boost { namespace spirit { namespace qi , 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,12 +90,12 @@ namespace boost { namespace spirit { namespace qi , 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::type attribute_type; - return parse_impl(first, last, context, skipper, attr + return parse_impl(first, last, context, skipper, attr_ , traits::is_container()); } diff --git a/boost/spirit/home/qi/operator/permutation.hpp b/boost/spirit/home/qi/operator/permutation.hpp index 1dcad89..cadfa24 100644 --- a/boost/spirit/home/qi/operator/permutation.hpp +++ b/boost/spirit/home/qi/operator/permutation.hpp @@ -62,8 +62,8 @@ namespace boost { namespace spirit { namespace qi type; }; - permutation(Elements const& elements) - : elements(elements) {} + permutation(Elements const& elements_) + : elements(elements_) {} template @@ -82,7 +82,7 @@ namespace boost { namespace spirit { namespace qi } // wrap the attribute in a tuple if it is not a tuple - typename traits::wrap_if_not_tuple::type attr(attr_); + typename traits::wrap_if_not_tuple::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,7 +91,7 @@ namespace boost { namespace spirit { namespace qi 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; diff --git a/boost/spirit/home/qi/operator/plus.hpp b/boost/spirit/home/qi/operator/plus.hpp index 780403a..3c08d1f 100644 --- a/boost/spirit/home/qi/operator/plus.hpp +++ b/boost/spirit/home/qi/operator/plus.hpp @@ -53,8 +53,8 @@ namespace boost { namespace spirit { namespace qi type; }; - plus(Subject const& subject) - : subject(subject) {} + plus(Subject const& subject_) + : subject(subject_) {} template bool parse_container(F f) const @@ -72,17 +72,17 @@ namespace boost { namespace spirit { namespace qi , 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 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; diff --git a/boost/spirit/home/qi/operator/sequence_base.hpp b/boost/spirit/home/qi/operator/sequence_base.hpp index 35f45df..921cf53 100644 --- a/boost/spirit/home/qi/operator/sequence_base.hpp +++ b/boost/spirit/home/qi/operator/sequence_base.hpp @@ -60,8 +60,8 @@ namespace boost { namespace spirit { namespace qi type; }; - sequence_base(Elements const& elements) - : elements(elements) {} + sequence_base(Elements const& elements_) + : elements(elements_) {} // standard case. Attribute is a fusion tuple template , mpl::not_ > >::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,9 +118,9 @@ namespace boost { namespace spirit { namespace qi , 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()); } diff --git a/boost/spirit/home/qi/operator/sequential_or.hpp b/boost/spirit/home/qi/operator/sequential_or.hpp index 80b86f3..be0135e 100644 --- a/boost/spirit/home/qi/operator/sequential_or.hpp +++ b/boost/spirit/home/qi/operator/sequential_or.hpp @@ -57,8 +57,8 @@ namespace boost { namespace spirit { namespace qi type; }; - sequential_or(Elements const& elements) - : elements(elements) {} + sequential_or(Elements const& elements_) + : elements(elements_) {} template @@ -71,12 +71,12 @@ namespace boost { namespace spirit { namespace qi f(first, last, context, skipper); // wrap the attribute in a tuple if it is not a tuple - typename traits::wrap_if_not_tuple::type attr(attr_); + typename traits::wrap_if_not_tuple::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 diff --git a/boost/spirit/home/qi/parse_attr.hpp b/boost/spirit/home/qi/parse_attr.hpp index 1933ffb..6db3300 100644 --- a/boost/spirit/home/qi/parse_attr.hpp +++ b/boost/spirit/home/qi/parse_attr.hpp @@ -62,8 +62,8 @@ namespace boost { namespace spirit { namespace qi BOOST_PP_ENUM(N, BOOST_SPIRIT_QI_ATTRIBUTE_REFERENCE, A) > vector_type; - vector_type attr (BOOST_PP_ENUM_PARAMS(N, attr)); - return compile(expr).parse(first, last, unused, unused, attr); + vector_type lattr (BOOST_PP_ENUM_PARAMS(N, attr)); + return compile(expr).parse(first, last, unused, unused, lattr); } template vector_type; - vector_type attr (BOOST_PP_ENUM_PARAMS(N, attr)); + vector_type lattr (BOOST_PP_ENUM_PARAMS(N, attr)); if (!compile(expr).parse( - first, last, unused, skipper_, attr)) + first, last, unused, skipper_, lattr)) return false; if (post_skip == skip_flag::postskip) diff --git a/boost/spirit/home/qi/reference.hpp b/boost/spirit/home/qi/reference.hpp index f6fcabc..f1f5c67 100644 --- a/boost/spirit/home/qi/reference.hpp +++ b/boost/spirit/home/qi/reference.hpp @@ -38,9 +38,9 @@ namespace boost { namespace spirit { namespace qi , 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 diff --git a/boost/spirit/home/qi/stream/stream.hpp b/boost/spirit/home/qi/stream/stream.hpp index 952f2f9..555f28d 100644 --- a/boost/spirit/home/qi/stream/stream.hpp +++ b/boost/spirit/home/qi/stream/stream.hpp @@ -58,7 +58,7 @@ namespace boost { namespace spirit { namespace qi , 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 source_device; typedef boost::iostreams::stream instream; @@ -66,7 +66,7 @@ namespace boost { namespace spirit { namespace qi 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()) { diff --git a/boost/spirit/home/qi/string/detail/tst.hpp b/boost/spirit/home/qi/string/detail/tst.hpp index 989477d..168e4cf 100644 --- a/boost/spirit/home/qi/string/detail/tst.hpp +++ b/boost/spirit/home/qi/string/detail/tst.hpp @@ -24,8 +24,8 @@ namespace boost { namespace spirit { namespace qi { namespace detail template 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) { } diff --git a/boost/spirit/home/qi/string/lit.hpp b/boost/spirit/home/qi/string/lit.hpp index 1b966c3..1e16361 100644 --- a/boost/spirit/home/qi/string/lit.hpp +++ b/boost/spirit/home/qi/string/lit.hpp @@ -89,8 +89,8 @@ namespace boost { namespace spirit { namespace qi char_type; typedef std::basic_string string_type; - literal_string(typename add_reference::type str) - : str(str) + literal_string(typename add_reference::type str_) + : str(str_) {} template @@ -104,10 +104,10 @@ namespace boost { namespace spirit { namespace qi template 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 @@ -163,10 +163,10 @@ namespace boost { namespace spirit { namespace qi template 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 diff --git a/boost/spirit/home/qi/string/symbols.hpp b/boost/spirit/home/qi/string/symbols.hpp index a9656f1..ae38892 100644 --- a/boost/spirit/home/qi/string/symbols.hpp +++ b/boost/spirit/home/qi/string/symbols.hpp @@ -257,14 +257,14 @@ public: template 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,8 +290,8 @@ public: template struct result { typedef adder const& type; }; - adder(symbols& sym) - : sym(sym) + adder(symbols& sym_) + : sym(sym_) { } @@ -333,8 +333,8 @@ public: template struct result { typedef remover const& type; }; - remover(symbols& sym) - : sym(sym) + remover(symbols& sym_) + : sym(sym_) { } diff --git a/boost/spirit/home/support/attributes.hpp b/boost/spirit/home/support/attributes.hpp index 48bff06..0efb2d5 100644 --- a/boost/spirit/home/support/attributes.hpp +++ b/boost/spirit/home/support/attributes.hpp @@ -1158,8 +1158,8 @@ namespace boost { namespace spirit { namespace traits template 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,7 +1181,7 @@ namespace boost { namespace spirit { namespace traits template struct print_visitor : static_visitor<> { - print_visitor(Out& out) : out(out) {} + print_visitor(Out& out_) : out(out_) {} template void operator()(T const& val) const diff --git a/boost/spirit/home/support/char_set/range.hpp b/boost/spirit/home/support/char_set/range.hpp index 6d1f661..1973889 100644 --- a/boost/spirit/home/support/char_set/range.hpp +++ b/boost/spirit/home/support/char_set/range.hpp @@ -22,7 +22,7 @@ namespace boost { namespace spirit { namespace support { namespace detail 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; diff --git a/boost/spirit/home/support/context.hpp b/boost/spirit/home/support/context.hpp index b728b4f..9c9715f 100644 --- a/boost/spirit/home/support/context.hpp +++ b/boost/spirit/home/support/context.hpp @@ -116,8 +116,8 @@ namespace boost { namespace spirit ) , locals() {} - context(Attributes const& attributes) - : attributes(attributes), locals() {} + context(Attributes const& attributes_) + : attributes(attributes_), locals() {} Attributes attributes; // The attributes Locals locals; // Local variables diff --git a/boost/spirit/home/support/detail/what_function.hpp b/boost/spirit/home/support/detail/what_function.hpp index d9678dd..179807b 100644 --- a/boost/spirit/home/support/detail/what_function.hpp +++ b/boost/spirit/home/support/detail/what_function.hpp @@ -20,8 +20,8 @@ namespace boost { namespace spirit { namespace detail template 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(); } diff --git a/boost/spirit/home/support/info.hpp b/boost/spirit/home/support/info.hpp index 0701888..a44fab4 100644 --- a/boost/spirit/home/support/info.hpp +++ b/boost/spirit/home/support/info.hpp @@ -40,30 +40,30 @@ namespace boost { namespace spirit > value_type; - explicit info(utf8_string const& tag) - : tag(tag), value(nil()) {} + explicit info(utf8_string const& tag_) + : tag(tag_), value(nil()) {} template - 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 - 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 - info(utf8_string const& tag + info(utf8_string const& tag_ , std::basic_string const& str) - : tag(tag), value(to_utf8(str)) {} + : tag(tag_), value(to_utf8(str)) {} utf8_string tag; value_type value; @@ -75,8 +75,8 @@ namespace boost { namespace spirit typedef void result_type; typedef basic_info_walker 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,8 +128,8 @@ namespace boost { namespace spirit { 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 { diff --git a/boost/spirit/home/support/nonterminal/expand_arg.hpp b/boost/spirit/home/support/nonterminal/expand_arg.hpp index f037acc..f214096 100644 --- a/boost/spirit/home/support/nonterminal/expand_arg.hpp +++ b/boost/spirit/home/support/nonterminal/expand_arg.hpp @@ -50,8 +50,8 @@ namespace boost { namespace spirit { namespace detail struct result : result_type {}; - expand_arg(Context& context) - : context(context) + expand_arg(Context& context_) + : context(context_) { } diff --git a/boost/spirit/home/support/terminal.hpp b/boost/spirit/home/support/terminal.hpp index d52fad2..f9b23de 100644 --- a/boost/spirit/home/support/terminal.hpp +++ b/boost/spirit/home/support/terminal.hpp @@ -33,10 +33,10 @@ namespace boost { namespace spirit 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,10 +50,10 @@ namespace boost { namespace spirit 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,11 +104,11 @@ namespace boost { namespace spirit 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::make(f, _0) + phoenix::detail::expression::function_eval::make(f, _0_) , f.proto_base().child0 )); } @@ -129,11 +129,11 @@ namespace boost { namespace spirit 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::make(f, _0, _1) + phoenix::detail::expression::function_eval::make(f, _0_, _1_) , f.proto_base().child0 )); } @@ -154,11 +154,11 @@ namespace boost { namespace spirit 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::make(f, _0, _1, _2) + phoenix::detail::expression::function_eval::make(f, _0_, _1_, _2_) , f.proto_base().child0 )); } @@ -368,42 +368,42 @@ namespace boost { namespace spirit template typename result::type - operator()(A0 const& _0 + operator()(A0 const& _0_ , typename detail::contains_actor::is_false = 0) const { typedef typename result::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 result::type - operator()(A0 const& _0, A1 const& _1 + operator()(A0 const& _0_, A1 const& _1_ , typename detail::contains_actor::is_false = 0) const { typedef typename result::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 result::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::is_false = 0) const { typedef typename result::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,38 +412,38 @@ namespace boost { namespace spirit // least one arg is a Phoenix actor. template typename result::type - operator()(A0 const& _0 + operator()(A0 const& _0_ , typename detail::contains_actor::is_true = 0) const { return make_lazy::type>()(*this - , phoenix::as_actor::convert(_0)); + , phoenix::as_actor::convert(_0_)); } template typename result::type - operator()(A0 const& _0, A1 const& _1 + operator()(A0 const& _0_, A1 const& _1_ , typename detail::contains_actor::is_true = 0) const { return make_lazy::type , typename phoenix::as_actor::type>()(*this - , phoenix::as_actor::convert(_0) - , phoenix::as_actor::convert(_1)); + , phoenix::as_actor::convert(_0_) + , phoenix::as_actor::convert(_1_)); } template typename result::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::is_true = 0) const { return make_lazy::type , typename phoenix::as_actor::type , typename phoenix::as_actor::type>()(*this - , phoenix::as_actor::convert(_0) - , phoenix::as_actor::convert(_1) - , phoenix::as_actor::convert(_2)); + , phoenix::as_actor::convert(_0_) + , phoenix::as_actor::convert(_1_) + , phoenix::as_actor::convert(_2_)); } private: -- 1.7.11.1