Index: boost/spirit/home/classic/core/impl/match.ipp
===================================================================
--- boost/spirit/home/classic/core/impl/match.ipp	(revision 48662)
+++ boost/spirit/home/classic/core/impl/match.ipp	(working copy)
@@ -19,12 +19,12 @@
     : len(-1), val() {}
 
     template <typename T>
-    inline match<T>::match(std::size_t length)
-    : len(length), val() {}
+    inline match<T>::match(std::size_t length_)
+    : len(length_), val() {}
 
     template <typename T>
-    inline match<T>::match(std::size_t length, ctor_param_t val_)
-    : len(length), val(val_) {}
+    inline match<T>::match(std::size_t length_, ctor_param_t val_)
+    : len(length_), val(val_) {}
 
     template <typename T>
     inline bool
@@ -66,11 +66,11 @@
     inline match<nil_t>::match()
     : len(-1) {}
 
-    inline match<nil_t>::match(std::size_t length)
-    : len(length) {}
+    inline match<nil_t>::match(std::size_t length_)
+    : len(length_) {}
 
-    inline match<nil_t>::match(std::size_t length, nil_t)
-    : len(length) {}
+    inline match<nil_t>::match(std::size_t length_, nil_t)
+    : len(length_) {}
 
     inline bool
     match<nil_t>::operator!() const
Index: boost/spirit/home/classic/core/non_terminal/impl/rule.ipp
===================================================================
--- boost/spirit/home/classic/core/non_terminal/impl/rule.ipp	(revision 48662)
+++ boost/spirit/home/classic/core/non_terminal/impl/rule.ipp	(working copy)
@@ -226,7 +226,7 @@
         template <typename ParserT, typename ScannerT, typename AttrT>
         struct concrete_parser : abstract_parser<ScannerT, AttrT>
         {
-            concrete_parser(ParserT const& p) : p(p) {}
+            concrete_parser(ParserT const& p_) : p(p_) {}
             virtual ~concrete_parser() {}
 
             virtual typename match_result<ScannerT, AttrT>::type
Index: boost/spirit/home/classic/core/non_terminal/subrule.hpp
===================================================================
--- boost/spirit/home/classic/core/non_terminal/subrule.hpp	(revision 48662)
+++ boost/spirit/home/classic/core/non_terminal/subrule.hpp	(working copy)
@@ -148,7 +148,7 @@
             subrule_list<
                 subrule_parser<ID, DefT, ContextT>,
                 RestT> >
-        operator,(subrule_parser<ID, DefT, ContextT> const& rhs)
+        operator,(subrule_parser<ID, DefT, ContextT> const& rhs_)
         {
             return subrule_list<
                 FirstT,
@@ -158,7 +158,7 @@
                         first,
                         subrule_list<
                             subrule_parser<ID, DefT, ContextT>,
-                            RestT>(rhs, rest));
+                            RestT>(rhs_, rest));
         }
 
         FirstT first;
@@ -258,10 +258,10 @@
         parse_main(ScannerT const& scan) const
         {
             typedef typename parser_result<self_t, ScannerT>::type result_t;
-            result_t result;
+            result_t result_;
             impl::parse_subrule<result_t, ScannerT, ID>::
-                do_(result, scan);
-            return result;
+                do_(result_, scan);
+            return result_;
         }
 
         template <typename ScannerT>
Index: boost/spirit/home/classic/core/non_terminal/rule.hpp
===================================================================
--- boost/spirit/home/classic/core/non_terminal/rule.hpp	(revision 48662)
+++ boost/spirit/home/classic/core/non_terminal/rule.hpp	(working copy)
@@ -159,11 +159,11 @@
             return ptr.get();
         }
 
-        rule(abstract_parser_t* ptr)
-        : ptr(ptr) {}
+        rule(abstract_parser_t* ptr_)
+        : ptr(ptr_) {}
 
-        rule(abstract_parser_t const* ptr)
-        : ptr(ptr) {}
+        rule(abstract_parser_t const* ptr_)
+        : ptr(ptr_) {}
 
         scoped_ptr<abstract_parser_t> ptr;
     };
Index: boost/spirit/home/classic/core/non_terminal/parser_id.hpp
===================================================================
--- boost/spirit/home/classic/core/non_terminal/parser_id.hpp	(revision 48662)
+++ boost/spirit/home/classic/core/non_terminal/parser_id.hpp	(working copy)
@@ -106,7 +106,7 @@
                 : parser_id(reinterpret_cast<std::size_t>(this)); 
         }
 
-        void set_id(parser_id id) { tag = id; } 
+        void set_id(parser_id id_) { tag = id_; } 
         
     private:
     
Index: boost/spirit/home/classic/error_handling/exceptions.hpp
===================================================================
--- boost/spirit/home/classic/error_handling/exceptions.hpp	(revision 48662)
+++ boost/spirit/home/classic/error_handling/exceptions.hpp	(working copy)
@@ -126,8 +126,8 @@
         typedef unary<ParserT, parser<self_t> >         base_t;
         typedef unary_parser_category                   parser_category_t;
 
-        assertive_parser(ParserT const& parser, ErrorDescrT descriptor)
-        : base_t(parser), descriptor(descriptor) {}
+        assertive_parser(ParserT const& parser, ErrorDescrT descriptor_)
+        : base_t(parser), descriptor(descriptor_) {}
 
         template <typename ScannerT>
         struct result
Index: boost/spirit/home/classic/tree/common.hpp
===================================================================
--- boost/spirit/home/classic/tree/common.hpp	(revision 48662)
+++ boost/spirit/home/classic/tree/common.hpp	(working copy)
@@ -555,18 +555,18 @@
     {}
 
     explicit
-    tree_match(std::size_t length)
-    : match<T>(length), trees()
+    tree_match(std::size_t length_)
+    : match<T>(length_), trees()
     {}
 
-    tree_match(std::size_t length, parse_node_t const& n)
-    : match<T>(length), trees()
+    tree_match(std::size_t length_, parse_node_t const& n)
+    : match<T>(length_), trees()
     { 
         trees.push_back(node_t(n)); 
     }
 
-    tree_match(std::size_t length, param_type val, parse_node_t const& n)
-    : match<T>(length, val), trees()
+    tree_match(std::size_t length_, param_type val, parse_node_t const& n)
+    : match<T>(length_, val), trees()
     {
 #if !defined(BOOST_SPIRIT_USE_LIST_FOR_TREES)
         trees.reserve(10); // this is more or less an arbitrary number...
@@ -575,14 +575,14 @@
     }
 
     // attention, these constructors will change the second parameter!
-    tree_match(std::size_t length, container_t& c)
-    : match<T>(length), trees()
+    tree_match(std::size_t length_, container_t& c)
+    : match<T>(length_), trees()
     { 
         impl::cp_swap(trees, c);
     }
 
-    tree_match(std::size_t length, param_type val, container_t& c)
-    : match<T>(length, val), trees()
+    tree_match(std::size_t length_, param_type val, container_t& c)
+    : match<T>(length_, val), trees()
     {
         impl::cp_swap(trees, c);
     }
Index: boost/spirit/home/classic/phoenix/actor.hpp
===================================================================
--- boost/spirit/home/classic/phoenix/actor.hpp	(revision 48662)
+++ boost/spirit/home/classic/phoenix/actor.hpp	(working copy)
@@ -340,27 +340,27 @@
 template <typename BaseT>
 template <typename A>
 inline typename actor_result<BaseT, tuple<A&> >::type
-actor<BaseT>::operator()(A& a) const
+actor<BaseT>::operator()(A& a_) const
 {
-    return BaseT::eval(tuple<A&>(a));
+    return BaseT::eval(tuple<A&>(a_));
 }
 
 //////////////////////////////////
 template <typename BaseT>
 template <typename A, typename B>
 inline typename actor_result<BaseT, tuple<A&, B&> >::type
-actor<BaseT>::operator()(A& a, B& b) const
+actor<BaseT>::operator()(A& a_, B& b_) const
 {
-    return BaseT::eval(tuple<A&, B&>(a, b));
+    return BaseT::eval(tuple<A&, B&>(a_, b_));
 }
 
 //////////////////////////////////
 template <typename BaseT>
 template <typename A, typename B, typename C>
 inline typename actor_result<BaseT, tuple<A&, B&, C&> >::type
-actor<BaseT>::operator()(A& a, B& b, C& c) const
+actor<BaseT>::operator()(A& a_, B& b_, C& c_) const
 {
-    return BaseT::eval(tuple<A&, B&, C&>(a, b, c));
+    return BaseT::eval(tuple<A&, B&, C&>(a_, b_, c_));
 }
 
 #if PHOENIX_LIMIT > 3
@@ -368,18 +368,18 @@
 template <typename BaseT>
 template <typename A, typename B, typename C, typename D>
 inline typename actor_result<BaseT, tuple<A&, B&, C&, D&> >::type
-actor<BaseT>::operator()(A& a, B& b, C& c, D& d) const
+actor<BaseT>::operator()(A& a_, B& b_, C& c_, D& d_) const
 {
-    return BaseT::eval(tuple<A&, B&, C&, D&>(a, b, c, d));
+    return BaseT::eval(tuple<A&, B&, C&, D&>(a_, b_, c_, d_));
 }
 
 //////////////////////////////////
 template <typename BaseT>
 template <typename A, typename B, typename C, typename D, typename E>
 inline typename actor_result<BaseT, tuple<A&, B&, C&, D&, E&> >::type
-actor<BaseT>::operator()(A& a, B& b, C& c, D& d, E& e) const
+actor<BaseT>::operator()(A& a_, B& b_, C& c_, D& d_, E& e_) const
 {
-    return BaseT::eval(tuple<A&, B&, C&, D&, E&>(a, b, c, d, e));
+    return BaseT::eval(tuple<A&, B&, C&, D&, E&>(a_, b_, c_, d_, e_));
 }
 
 //////////////////////////////////
@@ -391,12 +391,12 @@
     tuple<A&, B&, C&, D&, E&, F&>
 >::type
 actor<BaseT>::operator()(
-    A& a, B& b, C& c, D& d, E& e, F& f
+    A& a_, B& b_, C& c_, D& d_, E& e_, F& f_
 ) const
 {
     return BaseT::eval(
         tuple<A&, B&, C&, D&, E&, F&>
-        (a, b, c, d, e, f)
+        (a_, b_, c_, d_, e_, f_)
     );
 }