Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r55838 - in trunk/boost: fusion/view/ext_ proto proto/detail xpressive xpressive/detail xpressive/detail/core xpressive/detail/core/matcher xpressive/detail/dynamic xpressive/detail/static xpressive/detail/utility xpressive/detail/utility/chset
From: eric_at_[hidden]
Date: 2009-08-28 12:45:26


Author: eric_niebler
Date: 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
New Revision: 55838
URL: http://svn.boost.org/trac/boost/changeset/55838

Log:
reduce fusion, proto and xpressive warnings under msvc /Za switch
Text files modified:
   trunk/boost/fusion/view/ext_/segmented_iterator.hpp | 4
   trunk/boost/proto/deep_copy.hpp | 16 +++---
   trunk/boost/proto/detail/funop.hpp | 21 +--------
   trunk/boost/proto/eval.hpp | 16 +++---
   trunk/boost/proto/expr.hpp | 15 +++++
   trunk/boost/proto/extends.hpp | 4
   trunk/boost/proto/fusion.hpp | 28 ++++++------
   trunk/boost/proto/generate.hpp | 28 ++++++------
   trunk/boost/proto/make_expr.hpp | 8 +-
   trunk/boost/proto/traits.hpp | 88 ++++++++++++++++++++--------------------
   trunk/boost/xpressive/detail/core/access.hpp | 4
   trunk/boost/xpressive/detail/core/finder.hpp | 28 ++++++------
   trunk/boost/xpressive/detail/core/linker.hpp | 4
   trunk/boost/xpressive/detail/core/matcher/alternate_matcher.hpp | 4
   trunk/boost/xpressive/detail/core/matcher/assert_bol_matcher.hpp | 4
   trunk/boost/xpressive/detail/core/matcher/assert_eol_matcher.hpp | 4
   trunk/boost/xpressive/detail/core/matcher/assert_line_base.hpp | 8 +-
   trunk/boost/xpressive/detail/core/matcher/assert_word_matcher.hpp | 10 ++--
   trunk/boost/xpressive/detail/core/matcher/attr_matcher.hpp | 12 ++--
   trunk/boost/xpressive/detail/core/matcher/literal_matcher.hpp | 4
   trunk/boost/xpressive/detail/core/matcher/logical_newline_matcher.hpp | 8 +-
   trunk/boost/xpressive/detail/core/matcher/lookbehind_matcher.hpp | 4
   trunk/boost/xpressive/detail/core/matcher/range_matcher.hpp | 8 +-
   trunk/boost/xpressive/detail/core/matcher/repeat_end_matcher.hpp | 4
   trunk/boost/xpressive/detail/core/matcher/set_matcher.hpp | 8 +-
   trunk/boost/xpressive/detail/core/matcher/string_matcher.hpp | 4
   trunk/boost/xpressive/detail/core/optimize.hpp | 18 ++++----
   trunk/boost/xpressive/detail/core/peeker.hpp | 14 +++---
   trunk/boost/xpressive/detail/core/regex_impl.hpp | 4
   trunk/boost/xpressive/detail/core/results_cache.hpp | 4
   trunk/boost/xpressive/detail/detail_fwd.hpp | 12 ++--
   trunk/boost/xpressive/detail/dynamic/parse_charset.hpp | 30 ++++++------
   trunk/boost/xpressive/detail/dynamic/parser.hpp | 54 ++++++++++++------------
   trunk/boost/xpressive/detail/static/compile.hpp | 10 ++--
   trunk/boost/xpressive/detail/static/visitor.hpp | 6 +-
   trunk/boost/xpressive/detail/utility/algorithm.hpp | 6 +-
   trunk/boost/xpressive/detail/utility/boyer_moore.hpp | 36 ++++++++--------
   trunk/boost/xpressive/detail/utility/chset/basic_chset.hpp | 30 ++++++------
   trunk/boost/xpressive/detail/utility/chset/basic_chset.ipp | 36 ++++++++--------
   trunk/boost/xpressive/detail/utility/chset/chset.hpp | 28 ++++++------
   trunk/boost/xpressive/detail/utility/chset/range_run.hpp | 2
   trunk/boost/xpressive/detail/utility/chset/range_run.ipp | 4
   trunk/boost/xpressive/detail/utility/hash_peek_bitset.hpp | 30 ++++++------
   trunk/boost/xpressive/detail/utility/symbols.hpp | 2
   trunk/boost/xpressive/detail/utility/traits_utils.hpp | 24 +++++-----
   trunk/boost/xpressive/detail/utility/width.hpp | 4
   trunk/boost/xpressive/match_results.hpp | 8 +-
   trunk/boost/xpressive/regex_token_iterator.hpp | 8 +-
   48 files changed, 356 insertions(+), 360 deletions(-)

Modified: trunk/boost/fusion/view/ext_/segmented_iterator.hpp
==============================================================================
--- trunk/boost/fusion/view/ext_/segmented_iterator.hpp (original)
+++ trunk/boost/fusion/view/ext_/segmented_iterator.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -327,8 +327,8 @@
         typedef typename Cons::car_type car_type;
         typedef typename Cons::cdr_type cdr_type;
 
- explicit segmented_iterator(Cons const &cons)
- : cons_(cons)
+ explicit segmented_iterator(Cons const &c)
+ : cons_(c)
         {}
 
         cons_type const &cons() const { return this->cons_; };

Modified: trunk/boost/proto/deep_copy.hpp
==============================================================================
--- trunk/boost/proto/deep_copy.hpp (original)
+++ trunk/boost/proto/deep_copy.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -45,9 +45,9 @@
                 typedef typename proto_domain::template result<proto_domain(expr_type)>::type type;
 
                 template<typename Expr2>
- static type call(Expr2 const &expr)
+ static type call(Expr2 const &e)
                 {
- return typename Expr::proto_domain()(expr_type::make(expr.proto_base().child0));
+ return typename Expr::proto_domain()(expr_type::make(e.proto_base().child0));
                 }
             };
         }
@@ -107,9 +107,9 @@
                 /// value.
                 template<typename Expr>
                 typename result_of::deep_copy<Expr>::type
- operator()(Expr const &expr) const
+ operator()(Expr const &e) const
                 {
- return proto::detail::deep_copy_impl<Expr>::call(expr);
+ return proto::detail::deep_copy_impl<Expr>::call(e);
                 }
             };
         }
@@ -128,9 +128,9 @@
         /// \sa proto::functional::deep_copy.
         template<typename Expr>
         typename proto::result_of::deep_copy<Expr>::type
- deep_copy(Expr const &expr)
+ deep_copy(Expr const &e)
         {
- return proto::detail::deep_copy_impl<Expr>::call(expr);
+ return proto::detail::deep_copy_impl<Expr>::call(e);
         }
 
         namespace detail
@@ -144,7 +144,7 @@
             /**/
 
         #define BOOST_PROTO_DEFINE_DEEP_COPY_FUN(Z, N, DATA) \
- proto::deep_copy(expr.proto_base().BOOST_PP_CAT(child, N)) \
+ proto::deep_copy(e.proto_base().BOOST_PP_CAT(child, N)) \
             /**/
 
         #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/deep_copy.hpp>))
@@ -179,7 +179,7 @@
                 typedef typename proto_domain::template result<proto_domain(expr_type)>::type type;
 
                 template<typename Expr2>
- static type call(Expr2 const &expr)
+ static type call(Expr2 const &e)
                 {
                     expr_type that = {
                         BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_DEEP_COPY_FUN, ~)

Modified: trunk/boost/proto/detail/funop.hpp
==============================================================================
--- trunk/boost/proto/detail/funop.hpp (original)
+++ trunk/boost/proto/detail/funop.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -33,12 +33,12 @@
> type;
 
         static type const call(
- Expr &expr
+ Expr &e
             BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(BOOST_PP_ITERATION(), A, &a)
         )
         {
             type that = {
- expr
+ e
                 BOOST_PP_ENUM_TRAILING(BOOST_PP_ITERATION(), M1, ~)
             };
             return that;
@@ -50,22 +50,7 @@
     template<typename Expr BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename A), typename This, typename Domain>
     struct funop<Expr(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), This, Domain>
       : BOOST_PP_CAT(funop, BOOST_PP_ITERATION())<
- This
- , Domain
- BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(
- BOOST_PP_ITERATION()
- , typename remove_reference<A
- , >::type BOOST_PP_INTERCEPT
- )
- >
- {};
-
- /// \brief A helper metafunction for computing the
- /// return type of \c proto::expr\<\>::operator().
- template<typename Expr BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_ITERATION(), typename A), typename This, typename Domain>
- struct funop<Expr const(BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), A)), This, Domain>
- : BOOST_PP_CAT(funop, BOOST_PP_ITERATION())<
- This const
+ typename detail::same_cv<Expr, This>::type
           , Domain
             BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(
                 BOOST_PP_ITERATION()

Modified: trunk/boost/proto/eval.hpp
==============================================================================
--- trunk/boost/proto/eval.hpp (original)
+++ trunk/boost/proto/eval.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -64,18 +64,18 @@
             /// \return <tt>typename Context::template eval<Expr>()(expr, context)</tt>
             template<typename Expr, typename Context>
             typename proto::result_of::eval<Expr, Context>::type
- operator ()(Expr &expr, Context &context) const
+ operator ()(Expr &e, Context &ctx) const
             {
- return typename Context::template eval<Expr>()(expr, context);
+ return typename Context::template eval<Expr>()(e, ctx);
             }
 
             /// \overload
             ///
             template<typename Expr, typename Context>
             typename proto::result_of::eval<Expr, Context>::type
- operator ()(Expr &expr, Context const &context) const
+ operator ()(Expr &e, Context const &ctx) const
             {
- return typename Context::template eval<Expr>()(expr, context);
+ return typename Context::template eval<Expr>()(e, ctx);
             }
         };
     }
@@ -88,18 +88,18 @@
     /// \return <tt>typename Context::template eval<Expr>()(expr, context)</tt>
     template<typename Expr, typename Context>
     typename proto::result_of::eval<Expr, Context>::type
- eval(Expr &expr, Context &context)
+ eval(Expr &e, Context &ctx)
     {
- return typename Context::template eval<Expr>()(expr, context);
+ return typename Context::template eval<Expr>()(e, ctx);
     }
 
     /// \overload
     ///
     template<typename Expr, typename Context>
     typename proto::result_of::eval<Expr, Context>::type
- eval(Expr &expr, Context const &context)
+ eval(Expr &e, Context const &ctx)
     {
- return typename Context::template eval<Expr>()(expr, context);
+ return typename Context::template eval<Expr>()(e, ctx);
     }
 }}
 

Modified: trunk/boost/proto/expr.hpp
==============================================================================
--- trunk/boost/proto/expr.hpp (original)
+++ trunk/boost/proto/expr.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -101,6 +101,17 @@
                 return that;
             }
 
+ template<typename T, typename U>
+ struct same_cv
+ {
+ typedef U type;
+ };
+
+ template<typename T, typename U>
+ struct same_cv<T const, U>
+ {
+ typedef U const type;
+ };
         }
 
         namespace result_of
@@ -142,8 +153,8 @@
         {
             BOOST_PROTO_UNEXPR()
 
- explicit unexpr(Expr const &expr)
- : Expr(expr)
+ explicit unexpr(Expr const &e)
+ : Expr(e)
             {}
             
             using Expr::operator =;

Modified: trunk/boost/proto/extends.hpp
==============================================================================
--- trunk/boost/proto/extends.hpp (original)
+++ trunk/boost/proto/extends.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -161,9 +161,9 @@
         BOOST_PROTO_FUSION_DEFINE_TAG(boost::proto::tag::proto_expr) \
         BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_CHILD, ~) \
                                                                                                     \
- static proto_derived_expr const make(Expr const &expr) \
+ static proto_derived_expr const make(Expr const &e) \
         { \
- proto_derived_expr that = {expr}; \
+ proto_derived_expr that = {e}; \
             return that; \
         } \
                                                                                                     \

Modified: trunk/boost/proto/fusion.hpp
==============================================================================
--- trunk/boost/proto/fusion.hpp (original)
+++ trunk/boost/proto/fusion.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -88,8 +88,8 @@
             BOOST_PROTO_FUSION_DEFINE_CATEGORY(fusion::forward_traversal_tag)
             BOOST_PROTO_FUSION_DEFINE_TAG(tag::proto_flat_view)
 
- explicit flat_view(Expr &expr)
- : expr_(expr)
+ explicit flat_view(Expr &e)
+ : expr_(e)
             {}
 
             Expr &expr_;
@@ -112,9 +112,9 @@
 
             template<typename Expr>
             typename result<as_element(Expr const &)>::type
- operator ()(Expr const &expr) const
+ operator ()(Expr const &e) const
             {
- return typename result<as_element(Expr const &)>::type(expr);
+ return typename result<as_element(Expr const &)>::type(e);
             }
         };
     }
@@ -163,9 +163,9 @@
 
             template<typename Expr>
             proto::detail::flat_view<Expr const>
- operator ()(Expr const &expr) const
+ operator ()(Expr const &e) const
             {
- return proto::detail::flat_view<Expr const>(expr);
+ return proto::detail::flat_view<Expr const>(e);
             }
         };
 
@@ -196,9 +196,9 @@
 
             template<typename Expr>
             typename fusion::BOOST_PROTO_FUSION_RESULT_OF::pop_front<Expr const>::type
- operator ()(Expr const &expr) const
+ operator ()(Expr const &e) const
             {
- return fusion::pop_front(expr);
+ return fusion::pop_front(e);
             }
         };
 
@@ -227,9 +227,9 @@
 
             template<typename Expr>
             typename fusion::BOOST_PROTO_FUSION_RESULT_OF::reverse<Expr const>::type
- operator ()(Expr const &expr) const
+ operator ()(Expr const &e) const
             {
- return fusion::reverse(expr);
+ return fusion::reverse(e);
             }
         };
     }
@@ -247,9 +247,9 @@
     /// <tt>((a | b) | c)</tt>.
     template<typename Expr>
     proto::detail::flat_view<Expr const>
- flatten(Expr const &expr)
+ flatten(Expr const &e)
     {
- return proto::detail::flat_view<Expr const>(expr);
+ return proto::detail::flat_view<Expr const>(e);
     }
 
     /// INTERNAL ONLY
@@ -295,9 +295,9 @@
 
         template<typename Expr>
         typename proto::result_of::eval<Expr, Context>::type
- operator ()(Expr &expr) const
+ operator ()(Expr &e) const
         {
- return proto::eval(expr, this->ctx_);
+ return proto::eval(e, this->ctx_);
         }
 
     private:

Modified: trunk/boost/proto/generate.hpp
==============================================================================
--- trunk/boost/proto/generate.hpp (original)
+++ trunk/boost/proto/generate.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -60,9 +60,9 @@
>
                 type;
 
- static type const make(Expr const &expr)
+ static type const make(Expr const &e)
                 {
- type that = {expr.child0};
+ type that = {e.child0};
                     return that;
                 }
             };
@@ -106,9 +106,9 @@
             #else
             Expr const &
             #endif
- operator ()(Expr const &expr) const
+ operator ()(Expr const &e) const
             {
- return expr;
+ return e;
             }
         };
 
@@ -149,9 +149,9 @@
             /// \param expr A Proto expression
             /// \return Extends<Expr>(expr)
             template<typename Expr>
- Extends<Expr> operator ()(Expr const &expr) const
+ Extends<Expr> operator ()(Expr const &e) const
             {
- return Extends<Expr>(expr);
+ return Extends<Expr>(e);
             }
         };
 
@@ -194,9 +194,9 @@
             /// \param expr The expression to wrap
             /// \return <tt>Extends\<Expr\> that = {expr}; return that;</tt>
             template<typename Expr>
- Extends<Expr> operator ()(Expr const &expr) const
+ Extends<Expr> operator ()(Expr const &e) const
             {
- Extends<Expr> that = {expr};
+ Extends<Expr> that = {e};
                 return that;
             }
         };
@@ -247,9 +247,9 @@
             /// \param expr The expression to modify.
             /// \return <tt>deep_copy(expr)</tt>
             template<typename Expr>
- typename result<by_value_generator(Expr)>::type operator ()(Expr const &expr) const
+ typename result<by_value_generator(Expr)>::type operator ()(Expr const &e) const
             {
- return detail::by_value_generator_<Expr>::make(expr);
+ return detail::by_value_generator_<Expr>::make(e);
             }
         };
 
@@ -304,9 +304,9 @@
             /// \param expr The expression to modify.
             /// \return Second()(First()(expr))
             template<typename Expr>
- typename result<compose_generators(Expr)>::type operator ()(Expr const &expr) const
+ typename result<compose_generators(Expr)>::type operator ()(Expr const &e) const
             {
- return Second()(First()(expr));
+ return Second()(First()(e));
             }
         };
 
@@ -374,11 +374,11 @@
>
                 type;
 
- static type const make(Expr const &expr)
+ static type const make(Expr const &e)
                 {
                     type that = {
                         // expr.child0, ...
- BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_BY_VALUE, expr)
+ BOOST_PP_ENUM(N, BOOST_PROTO_DEFINE_BY_VALUE, e)
                     };
                     return that;
                 }

Modified: trunk/boost/proto/make_expr.hpp
==============================================================================
--- trunk/boost/proto/make_expr.hpp (original)
+++ trunk/boost/proto/make_expr.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -310,15 +310,15 @@
             {};
 
             template<typename Base, typename Expr>
- Expr implicit_expr_wrap(Base const &expr, mpl::false_, Expr *)
+ Expr implicit_expr_wrap(Base const &e, mpl::false_, Expr *)
             {
- return Expr(expr);
+ return Expr(e);
             }
 
             template<typename Base, typename Expr>
- Expr implicit_expr_wrap(Base const &expr, mpl::true_, Expr *)
+ Expr implicit_expr_wrap(Base const &e, mpl::true_, Expr *)
             {
- Expr that = {expr};
+ Expr that = {e};
                 return that;
             }
 

Modified: trunk/boost/proto/traits.hpp
==============================================================================
--- trunk/boost/proto/traits.hpp (original)
+++ trunk/boost/proto/traits.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -904,18 +904,18 @@
                 /// \throw nothrow
                 template<typename Expr>
                 typename result_of::child_c<Expr &, N>::type
- operator ()(Expr &expr) const
+ operator ()(Expr &e) const
                 {
- return result_of::child_c<Expr &, N>::call(expr);
+ return result_of::child_c<Expr &, N>::call(e);
                 }
 
                 /// \overload
                 ///
                 template<typename Expr>
                 typename result_of::child_c<Expr const &, N>::type
- operator ()(Expr const &expr) const
+ operator ()(Expr const &e) const
                 {
- return result_of::child_c<Expr const &, N>::call(expr);
+ return result_of::child_c<Expr const &, N>::call(e);
                 }
             };
 
@@ -947,18 +947,18 @@
                 /// \throw nothrow
                 template<typename Expr>
                 typename result_of::child<Expr &, N>::type
- operator ()(Expr &expr) const
+ operator ()(Expr &e) const
                 {
- return result_of::child<Expr &, N>::call(expr);
+ return result_of::child<Expr &, N>::call(e);
                 }
 
                 /// \overload
                 ///
                 template<typename Expr>
                 typename result_of::child<Expr const &, N>::type
- operator ()(Expr const &expr) const
+ operator ()(Expr const &e) const
                 {
- return result_of::child<Expr const &, N>::call(expr);
+ return result_of::child<Expr const &, N>::call(e);
                 }
             };
 
@@ -985,18 +985,18 @@
                 /// \throw nothrow
                 template<typename Expr>
                 typename result_of::value<Expr &>::type
- operator ()(Expr &expr) const
+ operator ()(Expr &e) const
                 {
- return expr.proto_base().child0;
+ return e.proto_base().child0;
                 }
 
                 /// \overload
                 ///
                 template<typename Expr>
                 typename result_of::value<Expr const &>::type
- operator ()(Expr const &expr) const
+ operator ()(Expr const &e) const
                 {
- return expr.proto_base().child0;
+ return e.proto_base().child0;
                 }
             };
 
@@ -1023,18 +1023,18 @@
                 /// \throw nothrow
                 template<typename Expr>
                 typename result_of::left<Expr &>::type
- operator ()(Expr &expr) const
+ operator ()(Expr &e) const
                 {
- return expr.proto_base().child0;
+ return e.proto_base().child0;
                 }
 
                 /// \overload
                 ///
                 template<typename Expr>
                 typename result_of::left<Expr const &>::type
- operator ()(Expr const &expr) const
+ operator ()(Expr const &e) const
                 {
- return expr.proto_base().child0;
+ return e.proto_base().child0;
                 }
             };
 
@@ -1061,16 +1061,16 @@
                 /// \throw nothrow
                 template<typename Expr>
                 typename result_of::right<Expr &>::type
- operator ()(Expr &expr) const
+ operator ()(Expr &e) const
                 {
- return expr.proto_base().child1;
+ return e.proto_base().child1;
                 }
 
                 template<typename Expr>
                 typename result_of::right<Expr const &>::type
- operator ()(Expr const &expr) const
+ operator ()(Expr const &e) const
                 {
- return expr.proto_base().child1;
+ return e.proto_base().child1;
                 }
             };
 
@@ -1199,18 +1199,18 @@
         /// \return A reference to the Nth child
         template<typename N, typename Expr>
         typename result_of::child<Expr &, N>::type
- child(Expr &expr BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
+ child(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
         {
- return result_of::child<Expr &, N>::call(expr);
+ return result_of::child<Expr &, N>::call(e);
         }
 
         /// \overload
         ///
         template<typename N, typename Expr>
         typename result_of::child<Expr const &, N>::type
- child(Expr const &expr)
+ child(Expr const &e)
         {
- return result_of::child<Expr const &, N>::call(expr);
+ return result_of::child<Expr const &, N>::call(e);
         }
 
         /// \overload
@@ -1243,18 +1243,18 @@
         /// \return A reference to the Nth child
         template<long N, typename Expr>
         typename result_of::child_c<Expr &, N>::type
- child_c(Expr &expr BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
+ child_c(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
         {
- return result_of::child_c<Expr &, N>::call(expr);
+ return result_of::child_c<Expr &, N>::call(e);
         }
 
         /// \overload
         ///
         template<long N, typename Expr>
         typename result_of::child_c<Expr const &, N>::type
- child_c(Expr const &expr)
+ child_c(Expr const &e)
         {
- return result_of::child_c<Expr const &, N>::call(expr);
+ return result_of::child_c<Expr const &, N>::call(e);
         }
 
         /// \brief Return the value stored within the specified Proto
@@ -1270,18 +1270,18 @@
         /// \return A reference to the terminal's value
         template<typename Expr>
         typename result_of::value<Expr &>::type
- value(Expr &expr BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
+ value(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
         {
- return expr.proto_base().child0;
+ return e.proto_base().child0;
         }
 
         /// \overload
         ///
         template<typename Expr>
         typename result_of::value<Expr const &>::type
- value(Expr const &expr)
+ value(Expr const &e)
         {
- return expr.proto_base().child0;
+ return e.proto_base().child0;
         }
 
         /// \brief Return the left child of the specified binary Proto
@@ -1297,18 +1297,18 @@
         /// \return A reference to the left child
         template<typename Expr>
         typename result_of::left<Expr &>::type
- left(Expr &expr BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
+ left(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
         {
- return expr.proto_base().child0;
+ return e.proto_base().child0;
         }
 
         /// \overload
         ///
         template<typename Expr>
         typename result_of::left<Expr const &>::type
- left(Expr const &expr)
+ left(Expr const &e)
         {
- return expr.proto_base().child0;
+ return e.proto_base().child0;
         }
 
         /// \brief Return the right child of the specified binary Proto
@@ -1324,18 +1324,18 @@
         /// \return A reference to the right child
         template<typename Expr>
         typename result_of::right<Expr &>::type
- right(Expr &expr BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
+ right(Expr &e BOOST_PROTO_DISABLE_IF_IS_CONST(Expr))
         {
- return expr.proto_base().child1;
+ return e.proto_base().child1;
         }
 
         /// \overload
         ///
         template<typename Expr>
         typename result_of::right<Expr const &>::type
- right(Expr const &expr)
+ right(Expr const &e)
         {
- return expr.proto_base().child1;
+ return e.proto_base().child1;
         }
 
         /// INTERNAL ONLY
@@ -1518,9 +1518,9 @@
 
                 /// INTERNAL ONLY
                 ///
- static type call(Expr &expr)
+ static type call(Expr &e)
                 {
- return expr.proto_base().BOOST_PP_CAT(child, N);
+ return e.proto_base().BOOST_PP_CAT(child, N);
                 }
             };
 
@@ -1540,9 +1540,9 @@
 
                 /// INTERNAL ONLY
                 ///
- static type call(Expr const &expr)
+ static type call(Expr const &e)
                 {
- return expr.proto_base().BOOST_PP_CAT(child, N);
+ return e.proto_base().BOOST_PP_CAT(child, N);
                 }
             };
         }

Modified: trunk/boost/xpressive/detail/core/access.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/access.hpp (original)
+++ trunk/boost/xpressive/detail/core/access.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -71,13 +71,13 @@
     (
         match_results<BidiIter> &what
       , regex_id_type regex_id
- , intrusive_ptr<traits<char_type> const> const &traits
+ , intrusive_ptr<traits<char_type> const> const &tr
       , sub_match_impl<BidiIter> *sub_matches
       , std::size_t size
       , std::vector<named_mark<char_type> > const &named_marks
     )
     {
- what.init_(regex_id, traits, sub_matches, size, named_marks);
+ what.init_(regex_id, tr, sub_matches, size, named_marks);
     }
 
     static sub_match_vector<BidiIter> &get_sub_match_vector(match_results<BidiIter> &what)

Modified: trunk/boost/xpressive/detail/core/finder.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/finder.hpp (original)
+++ trunk/boost/xpressive/detail/core/finder.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -43,8 +43,8 @@
 
     bool operator ()(match_state<BidiIter> &state) const
     {
- Traits const &traits = traits_cast<Traits>(state);
- state.cur_ = this->bm_.find(state.cur_, state.end_, traits);
+ Traits const &tr = traits_cast<Traits>(state);
+ state.cur_ = this->bm_.find(state.cur_, state.end_, tr);
         return state.cur_ != state.end_;
     }
 
@@ -71,10 +71,10 @@
 
     bool operator ()(match_state<BidiIter> &state) const
     {
- Traits const &traits = traits_cast<Traits>(state);
+ Traits const &tr = traits_cast<Traits>(state);
         state.cur_ = (this->bset_.icase()
- ? this->find_(state.cur_, state.end_, traits, mpl::true_())
- : this->find_(state.cur_, state.end_, traits, mpl::false_()));
+ ? this->find_(state.cur_, state.end_, tr, mpl::true_())
+ : this->find_(state.cur_, state.end_, tr, mpl::false_()));
         return state.cur_ != state.end_;
     }
 
@@ -83,9 +83,9 @@
     hash_peek_finder &operator =(hash_peek_finder const &);
 
     template<typename ICase>
- BidiIter find_(BidiIter begin, BidiIter end, Traits const &traits, ICase) const
+ BidiIter find_(BidiIter begin, BidiIter end, Traits const &tr, ICase) const
     {
- for(; begin != end && !this->bset_.test(*begin, traits, ICase()); ++begin)
+ for(; begin != end && !this->bset_.test(*begin, tr, ICase()); ++begin)
             ;
         return begin;
     }
@@ -104,8 +104,8 @@
     typedef typename iterator_difference<BidiIter>::type diff_type;
     typedef typename Traits::char_class_type char_class_type;
 
- line_start_finder(Traits const &traits)
- : newline_(lookup_classname(traits, "newline"))
+ line_start_finder(Traits const &tr)
+ : newline_(lookup_classname(tr, "newline"))
     {
     }
 
@@ -116,14 +116,14 @@
             return true;
         }
 
- Traits const &traits = traits_cast<Traits>(state);
+ Traits const &tr = traits_cast<Traits>(state);
         BidiIter cur = state.cur_;
         BidiIter const end = state.end_;
         std::advance(cur, static_cast<diff_type>(-!state.bos()));
 
         for(; cur != end; ++cur)
         {
- if(traits.isctype(*cur, this->newline_))
+ if(tr.isctype(*cur, this->newline_))
             {
                 state.cur_ = ++cur;
                 return true;
@@ -151,12 +151,12 @@
     typedef typename iterator_difference<BidiIter>::type diff_type;
     typedef typename Traits::char_class_type char_class_type;
 
- line_start_finder(Traits const &traits)
+ line_start_finder(Traits const &tr)
     {
- char_class_type newline = lookup_classname(traits, "newline");
+ char_class_type newline = lookup_classname(tr, "newline");
         for(int j = 0; j < 256; ++j)
         {
- this->bits_[j] = traits.isctype(static_cast<char_type>(static_cast<unsigned char>(j)), newline);
+ this->bits_[j] = tr.isctype(static_cast<char_type>(static_cast<unsigned char>(j)), newline);
         }
     }
 

Modified: trunk/boost/xpressive/detail/core/linker.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/linker.hpp (original)
+++ trunk/boost/xpressive/detail/core/linker.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -141,9 +141,9 @@
 struct xpression_linker
 {
     template<typename Traits>
- explicit xpression_linker(Traits const &traits)
+ explicit xpression_linker(Traits const &tr)
       : back_stack_()
- , traits_(&traits)
+ , traits_(&tr)
       , traits_type_(&typeid(Traits))
       , has_backrefs_(false)
     {

Modified: trunk/boost/xpressive/detail/core/matcher/alternate_matcher.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/matcher/alternate_matcher.hpp (original)
+++ trunk/boost/xpressive/detail/core/matcher/alternate_matcher.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -121,9 +121,9 @@
     private:
         alternate_matcher &operator =(alternate_matcher const &);
 
- bool can_match_(char_type ch, Traits const &traits) const
+ bool can_match_(char_type ch, Traits const &tr) const
         {
- return this->bset_.test(ch, traits);
+ return this->bset_.test(ch, tr);
         }
     };
 

Modified: trunk/boost/xpressive/detail/core/matcher/assert_bol_matcher.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/matcher/assert_bol_matcher.hpp (original)
+++ trunk/boost/xpressive/detail/core/matcher/assert_bol_matcher.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -31,8 +31,8 @@
     {
         typedef typename Traits::char_type char_type;
 
- assert_bol_matcher(Traits const &traits)
- : assert_line_base<Traits>(traits)
+ assert_bol_matcher(Traits const &tr)
+ : assert_line_base<Traits>(tr)
         {
         }
 

Modified: trunk/boost/xpressive/detail/core/matcher/assert_eol_matcher.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/matcher/assert_eol_matcher.hpp (original)
+++ trunk/boost/xpressive/detail/core/matcher/assert_eol_matcher.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -31,8 +31,8 @@
     {
         typedef typename Traits::char_type char_type;
         
- assert_eol_matcher(Traits const &traits)
- : assert_line_base<Traits>(traits)
+ assert_eol_matcher(Traits const &tr)
+ : assert_line_base<Traits>(tr)
         {
         }
 

Modified: trunk/boost/xpressive/detail/core/matcher/assert_line_base.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/matcher/assert_line_base.hpp (original)
+++ trunk/boost/xpressive/detail/core/matcher/assert_line_base.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -31,10 +31,10 @@
         typedef typename Traits::char_class_type char_class_type;
 
     protected:
- assert_line_base(Traits const &traits)
- : newline_(lookup_classname(traits, "newline"))
- , nl_(traits.widen('\n'))
- , cr_(traits.widen('\r'))
+ assert_line_base(Traits const &tr)
+ : newline_(lookup_classname(tr, "newline"))
+ , nl_(tr.widen('\n'))
+ , cr_(tr.widen('\r'))
         {
         }
 

Modified: trunk/boost/xpressive/detail/core/matcher/assert_word_matcher.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/matcher/assert_word_matcher.hpp (original)
+++ trunk/boost/xpressive/detail/core/matcher/assert_word_matcher.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -84,8 +84,8 @@
         typedef typename Traits::char_type char_type;
         typedef typename Traits::char_class_type char_class_type;
 
- assert_word_matcher(Traits const &traits)
- : word_(lookup_classname(traits, "w"))
+ assert_word_matcher(Traits const &tr)
+ : word_(lookup_classname(tr, "w"))
         {
             BOOST_ASSERT(0 != this->word_);
         }
@@ -94,10 +94,10 @@
           : word_(word)
         {}
 
- bool is_word(Traits const &traits, char_type ch) const
+ bool is_word(Traits const &tr, char_type ch) const
         {
- detail::ignore_unused(traits);
- return traits.isctype(traits.translate(ch), this->word_);
+ detail::ignore_unused(tr);
+ return tr.isctype(tr.translate(ch), this->word_);
         }
 
         template<typename BidiIter, typename Next>

Modified: trunk/boost/xpressive/detail/core/matcher/attr_matcher.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/matcher/attr_matcher.hpp (original)
+++ trunk/boost/xpressive/detail/core/matcher/attr_matcher.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -33,8 +33,8 @@
         typedef typename Traits::char_type char_type;
         Traits const &traits_;
 
- explicit char_translate(Traits const &traits)
- : traits_(traits)
+ explicit char_translate(Traits const &tr)
+ : traits_(tr)
         {}
 
         char_type operator ()(char_type ch1) const
@@ -54,8 +54,8 @@
         typedef typename Traits::char_type char_type;
         Traits const &traits_;
 
- explicit char_translate(Traits const &traits)
- : traits_(traits)
+ explicit char_translate(Traits const &tr)
+ : traits_(tr)
         {}
 
         char_type operator ()(char_type ch1) const
@@ -75,10 +75,10 @@
     {
         typedef typename Matcher::value_type::second_type const* result_type;
 
- attr_matcher(int slot, Matcher const &matcher, Traits const& traits)
+ attr_matcher(int slot, Matcher const &matcher, Traits const& tr)
           : slot_(slot-1)
         {
- char_translate<Traits, ICase::value> trans(traits);
+ char_translate<Traits, ICase::value> trans(tr);
             this->sym_.load(matcher, trans);
         }
 

Modified: trunk/boost/xpressive/detail/core/matcher/literal_matcher.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/matcher/literal_matcher.hpp (original)
+++ trunk/boost/xpressive/detail/core/matcher/literal_matcher.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -37,8 +37,8 @@
           : ch_(ch)
         {}
 
- literal_matcher(char_type ch, Traits const &traits)
- : ch_(detail::translate(ch, traits, icase_type()))
+ literal_matcher(char_type ch, Traits const &tr)
+ : ch_(detail::translate(ch, tr, icase_type()))
         {}
 
         template<typename BidiIter, typename Next>

Modified: trunk/boost/xpressive/detail/core/matcher/logical_newline_matcher.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/matcher/logical_newline_matcher.hpp (original)
+++ trunk/boost/xpressive/detail/core/matcher/logical_newline_matcher.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -30,10 +30,10 @@
         typedef typename Traits::char_type char_type;
         typedef typename Traits::char_class_type char_class_type;
 
- logical_newline_matcher(Traits const &traits)
- : newline_(lookup_classname(traits, "newline"))
- , nl_(traits.widen('\n'))
- , cr_(traits.widen('\r'))
+ logical_newline_matcher(Traits const &tr)
+ : newline_(lookup_classname(tr, "newline"))
+ , nl_(tr.widen('\n'))
+ , cr_(tr.widen('\r'))
         {
         }
 

Modified: trunk/boost/xpressive/detail/core/matcher/lookbehind_matcher.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/matcher/lookbehind_matcher.hpp (original)
+++ trunk/boost/xpressive/detail/core/matcher/lookbehind_matcher.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -33,11 +33,11 @@
     struct lookbehind_matcher
       : quant_style<quant_none, 0, Xpr::pure>
     {
- lookbehind_matcher(Xpr const &xpr, std::size_t width, bool no, bool pure = Xpr::pure)
+ lookbehind_matcher(Xpr const &xpr, std::size_t wid, bool no, bool pure = Xpr::pure)
           : xpr_(xpr)
           , not_(no)
           , pure_(pure)
- , width_(width)
+ , width_(wid)
         {
             BOOST_XPR_ENSURE_(!is_unknown(this->width_), regex_constants::error_badlookbehind,
                 "Variable-width look-behind assertions are not supported");

Modified: trunk/boost/xpressive/detail/core/matcher/range_matcher.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/matcher/range_matcher.hpp (original)
+++ trunk/boost/xpressive/detail/core/matcher/range_matcher.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -48,14 +48,14 @@
             this->not_ = !this->not_;
         }
 
- bool in_range(Traits const &traits, char_type ch, mpl::false_) const // case-sensitive
+ bool in_range(Traits const &tr, char_type ch, mpl::false_) const // case-sensitive
         {
- return traits.in_range(this->ch_min_, this->ch_max_, ch);
+ return tr.in_range(this->ch_min_, this->ch_max_, ch);
         }
 
- bool in_range(Traits const &traits, char_type ch, mpl::true_) const // case-insensitive
+ bool in_range(Traits const &tr, char_type ch, mpl::true_) const // case-insensitive
         {
- return traits.in_range_nocase(this->ch_min_, this->ch_max_, ch);
+ return tr.in_range_nocase(this->ch_min_, this->ch_max_, ch);
         }
 
         template<typename BidiIter, typename Next>

Modified: trunk/boost/xpressive/detail/core/matcher/repeat_end_matcher.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/matcher/repeat_end_matcher.hpp (original)
+++ trunk/boost/xpressive/detail/core/matcher/repeat_end_matcher.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -33,8 +33,8 @@
         unsigned int min_, max_;
         mutable void const *back_;
 
- repeat_end_matcher(int mark_number, unsigned int min, unsigned int max)
- : mark_number_(mark_number)
+ repeat_end_matcher(int mark_nbr, unsigned int min, unsigned int max)
+ : mark_number_(mark_nbr)
           , min_(min)
           , max_(max)
           , back_(0)

Modified: trunk/boost/xpressive/detail/core/matcher/set_matcher.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/matcher/set_matcher.hpp (original)
+++ trunk/boost/xpressive/detail/core/matcher/set_matcher.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -51,20 +51,20 @@
         this->not_ = !this->not_;
     }
 
- void nocase(Traits const &traits)
+ void nocase(Traits const &tr)
     {
         this->icase_ = true;
 
         for(int i = 0; i < Size::value; ++i)
         {
- this->set_[i] = traits.translate_nocase(this->set_[i]);
+ this->set_[i] = tr.translate_nocase(this->set_[i]);
         }
     }
 
- bool in_set(Traits const &traits, char_type ch) const
+ bool in_set(Traits const &tr, char_type ch) const
     {
         char_type const *begin = &this->set_[0], *end = begin + Size::value;
- ch = this->icase_ ? traits.translate_nocase(ch) : traits.translate(ch);
+ ch = this->icase_ ? tr.translate_nocase(ch) : tr.translate(ch);
         return end != std::find(begin, end, ch);
     }
 

Modified: trunk/boost/xpressive/detail/core/matcher/string_matcher.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/matcher/string_matcher.hpp (original)
+++ trunk/boost/xpressive/detail/core/matcher/string_matcher.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -36,7 +36,7 @@
         string_type str_;
         char_type const *end_;
 
- string_matcher(string_type const &str, Traits const &traits)
+ string_matcher(string_type const &str, Traits const &tr)
           : str_(str)
           , end_()
         {
@@ -44,7 +44,7 @@
             typename range_iterator<string_type>::type end = boost::end(this->str_);
             for(; cur != end; ++cur)
             {
- *cur = detail::translate(*cur, traits, icase_type());
+ *cur = detail::translate(*cur, tr, icase_type());
             }
             this->end_ = detail::data_end(str_);
         }

Modified: trunk/boost/xpressive/detail/core/optimize.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/optimize.hpp (original)
+++ trunk/boost/xpressive/detail/core/optimize.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -28,7 +28,7 @@
 intrusive_ptr<finder<BidiIter> > optimize_regex
 (
     xpression_peeker<typename iterator_value<BidiIter>::type> const &peeker
- , Traits const &traits
+ , Traits const &tr
   , mpl::false_
 )
 {
@@ -36,7 +36,7 @@
     {
         return intrusive_ptr<finder<BidiIter> >
         (
- new line_start_finder<BidiIter, Traits>(traits)
+ new line_start_finder<BidiIter, Traits>(tr)
         );
     }
     else if(peeker.leading_simple_repeat())
@@ -64,7 +64,7 @@
 intrusive_ptr<finder<BidiIter> > optimize_regex
 (
     xpression_peeker<typename iterator_value<BidiIter>::type> const &peeker
- , Traits const &traits
+ , Traits const &tr
   , mpl::true_
 )
 {
@@ -77,11 +77,11 @@
         BOOST_ASSERT(1 == peeker.bitset().count());
         return intrusive_ptr<finder<BidiIter> >
         (
- new boyer_moore_finder<BidiIter, Traits>(str.begin_, str.end_, traits, str.icase_)
+ new boyer_moore_finder<BidiIter, Traits>(str.begin_, str.end_, tr, str.icase_)
         );
     }
 
- return optimize_regex<BidiIter>(peeker, traits, mpl::false_());
+ return optimize_regex<BidiIter>(peeker, tr, mpl::false_());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -92,22 +92,22 @@
 (
     intrusive_ptr<matchable_ex<BidiIter> const> const &regex
   , regex_impl<BidiIter> &impl
- , Traits const &traits
+ , Traits const &tr
 )
 {
     typedef typename iterator_value<BidiIter>::type char_type;
 
     // "link" the regex
- xpression_linker<char_type> linker(traits);
+ xpression_linker<char_type> linker(tr);
     regex->link(linker);
 
     // "peek" into the compiled regex to see if there are optimization opportunities
     hash_peek_bitset<char_type> bset;
- xpression_peeker<char_type> peeker(bset, traits, linker.has_backrefs());
+ xpression_peeker<char_type> peeker(bset, tr, linker.has_backrefs());
     regex->peek(peeker);
 
     // optimization: get the peek chars OR the boyer-moore search string
- impl.finder_ = optimize_regex<BidiIter>(peeker, traits, is_random<BidiIter>());
+ impl.finder_ = optimize_regex<BidiIter>(peeker, tr, is_random<BidiIter>());
     impl.xpr_ = regex;
 }
 

Modified: trunk/boost/xpressive/detail/core/peeker.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/peeker.hpp (original)
+++ trunk/boost/xpressive/detail/core/peeker.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -49,9 +49,9 @@
 {
     typedef typename Traits::char_type char_type;
 
- char_sink(hash_peek_bitset<char_type> &bset, Traits const &traits)
+ char_sink(hash_peek_bitset<char_type> &bset, Traits const &tr)
       : bset_(bset)
- , traits_(traits)
+ , traits_(tr)
     {}
 
     void operator()(char_type ch) const
@@ -72,7 +72,7 @@
 struct xpression_peeker
 {
     template<typename Traits>
- xpression_peeker(hash_peek_bitset<Char> &bset, Traits const &traits, bool has_backrefs = false)
+ xpression_peeker(hash_peek_bitset<Char> &bset, Traits const &tr, bool has_backrefs = false)
       : bset_(bset)
       , str_()
       , line_start_(false)
@@ -81,7 +81,7 @@
       , leading_simple_repeat_(0)
       , has_backrefs_(has_backrefs)
     {
- this->set_traits(traits);
+ this->set_traits(tr);
     }
 
     ///////////////////////////////////////////////////////////////////////////////
@@ -245,14 +245,14 @@
     }
 
     template<typename Traits>
- void set_traits(Traits const &traits)
+ void set_traits(Traits const &tr)
     {
         if(0 == this->traits_)
         {
- this->traits_ = &traits;
+ this->traits_ = &tr;
             this->traits_type_ = &typeid(Traits);
         }
- else if(*this->traits_type_ != typeid(Traits) || this->get_traits_<Traits>() != traits)
+ else if(*this->traits_type_ != typeid(Traits) || this->get_traits_<Traits>() != tr)
         {
             this->fail(); // traits mis-match! set all and bail
         }

Modified: trunk/boost/xpressive/detail/core/regex_impl.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/regex_impl.hpp (original)
+++ trunk/boost/xpressive/detail/core/regex_impl.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -72,8 +72,8 @@
 {
     typedef typename Traits::char_type char_type;
 
- explicit traits_holder(Traits const &traits)
- : traits_(traits)
+ explicit traits_holder(Traits const &tr)
+ : traits_(tr)
     {
     }
 

Modified: trunk/boost/xpressive/detail/core/results_cache.hpp
==============================================================================
--- trunk/boost/xpressive/detail/core/results_cache.hpp (original)
+++ trunk/boost/xpressive/detail/core/results_cache.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -42,8 +42,8 @@
   : private std::list<match_results<BidiIter> >
 {
     friend struct results_cache<BidiIter>;
- friend struct match_results<BidiIter>;
- typedef std::list<match_results<BidiIter> > base_type;
+ friend struct xpressive::match_results<BidiIter>;
+ typedef std::list<xpressive::match_results<BidiIter> > base_type;
 
     using base_type::iterator;
     using base_type::const_iterator;

Modified: trunk/boost/xpressive/detail/detail_fwd.hpp
==============================================================================
--- trunk/boost/xpressive/detail/detail_fwd.hpp (original)
+++ trunk/boost/xpressive/detail/detail_fwd.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -323,22 +323,22 @@
     struct memento;
 
     template<typename Char, typename Traits>
- void set_char(compound_charset<Traits> &chset, Char ch, Traits const &traits, bool icase);
+ void set_char(compound_charset<Traits> &chset, Char ch, Traits const &tr, bool icase);
 
     template<typename Char, typename Traits>
- void set_range(compound_charset<Traits> &chset, Char from, Char to, Traits const &traits, bool icase);
+ void set_range(compound_charset<Traits> &chset, Char from, Char to, Traits const &tr, bool icase);
 
     template<typename Traits>
- void set_class(compound_charset<Traits> &chset, typename Traits::char_class_type char_class, bool no, Traits const &traits);
+ void set_class(compound_charset<Traits> &chset, typename Traits::char_class_type char_class, bool no, Traits const &tr);
 
     template<typename Char, typename Traits>
- void set_char(basic_chset<Char> &chset, Char ch, Traits const &traits, bool icase);
+ void set_char(basic_chset<Char> &chset, Char ch, Traits const &tr, bool icase);
 
     template<typename Char, typename Traits>
- void set_range(basic_chset<Char> &chset, Char from, Char to, Traits const &traits, bool icase);
+ void set_range(basic_chset<Char> &chset, Char from, Char to, Traits const &tr, bool icase);
 
     template<typename Char, typename Traits>
- void set_class(basic_chset<Char> &chset, typename Traits::char_class_type char_class, bool no, Traits const &traits);
+ void set_class(basic_chset<Char> &chset, typename Traits::char_class_type char_class, bool no, Traits const &tr);
 
     template<typename Matcher>
     static_xpression<Matcher> const

Modified: trunk/boost/xpressive/detail/dynamic/parse_charset.hpp
==============================================================================
--- trunk/boost/xpressive/detail/dynamic/parse_charset.hpp (original)
+++ trunk/boost/xpressive/detail/dynamic/parse_charset.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -69,7 +69,7 @@
 //
 template<typename FwdIter, typename CompilerTraits>
 escape_value<typename iterator_value<FwdIter>::type, typename CompilerTraits::regex_traits::char_class_type>
-parse_escape(FwdIter &begin, FwdIter end, CompilerTraits &traits)
+parse_escape(FwdIter &begin, FwdIter end, CompilerTraits &tr)
 {
     using namespace regex_constants;
     typedef typename iterator_value<FwdIter>::type char_type;
@@ -84,8 +84,8 @@
     BOOST_XPR_ENSURE_(begin != end, error_escape, "unexpected end of pattern found");
     numeric::converter<int, uchar_t, converstion_traits, char_overflow_handler> converter;
     escape_value<char_type,char_class_type> esc = { 0, 0, 0, escape_char };
- bool const icase = (0 != (regex_constants::icase_ & traits.flags()));
- regex_traits const &rxtraits = traits.traits();
+ bool const icase = (0 != (regex_constants::icase_ & tr.flags()));
+ regex_traits const &rxtraits = tr.traits();
     FwdIter tmp;
 
     esc.class_ = rxtraits.lookup_classname(begin, begin + 1, icase);
@@ -192,28 +192,28 @@
     FwdIter &begin
   , FwdIter end
   , compound_charset<RegexTraits> &chset
- , CompilerTraits &traits
+ , CompilerTraits &tr
 )
 {
     using namespace regex_constants;
     typedef typename RegexTraits::char_type char_type;
     typedef typename RegexTraits::char_class_type char_class_type;
     BOOST_ASSERT(begin != end);
- RegexTraits const &rxtraits = traits.traits();
- bool const icase = (0 != (regex_constants::icase_ & traits.flags()));
+ RegexTraits const &rxtraits = tr.traits();
+ bool const icase = (0 != (regex_constants::icase_ & tr.flags()));
     FwdIter iprev = FwdIter();
     escape_value<char_type, char_class_type> esc = {0, 0, 0, escape_char};
     bool invert = false;
 
     // check to see if we have an inverse charset
- if(begin != end && token_charset_invert == traits.get_charset_token(iprev = begin, end))
+ if(begin != end && token_charset_invert == tr.get_charset_token(iprev = begin, end))
     {
         begin = iprev;
         invert = true;
     }
 
     // skip the end token if-and-only-if it is the first token in the charset
- if(begin != end && token_charset_end == traits.get_charset_token(iprev = begin, end))
+ if(begin != end && token_charset_end == tr.get_charset_token(iprev = begin, end))
     {
         for(; begin != iprev; ++begin)
         {
@@ -229,7 +229,7 @@
 
     // remember the current position and grab the next token
     iprev = begin;
- tok = traits.get_charset_token(begin, end);
+ tok = tr.get_charset_token(begin, end);
     do
     {
         BOOST_XPR_ENSURE_(begin != end, error_brack, "unexpected end of pattern found");
@@ -241,7 +241,7 @@
             have_prev = false;
 
             // ch_prev is lower bound of a range
- switch(traits.get_charset_token(begin, end))
+ switch(tr.get_charset_token(begin, end))
             {
             case token_charset_hyphen:
             case token_charset_invert:
@@ -257,7 +257,7 @@
                 chset.set_range(ch_prev, ch_next, rxtraits, icase);
                 continue;
             case token_escape:
- esc = parse_escape(begin, end, traits);
+ esc = parse_escape(begin, end, tr);
                 if(escape_char == esc.type_)
                 {
                     BOOST_XPR_ENSURE_(ch_prev <= esc.ch_, error_range, "invalid charset range");
@@ -298,12 +298,12 @@
         case token_posix_charset_begin:
             {
                 FwdIter tmp = begin, start = begin;
- bool invert = (token_charset_invert == traits.get_charset_token(tmp, end));
+ bool invert = (token_charset_invert == tr.get_charset_token(tmp, end));
                 if(invert)
                 {
                     begin = start = tmp;
                 }
- while(token_literal == (tok = traits.get_charset_token(begin, end)))
+ while(token_literal == (tok = tr.get_charset_token(begin, end)))
                 {
                     tmp = ++begin;
                     BOOST_XPR_ENSURE_(begin != end, error_brack, "unexpected end of pattern found");
@@ -322,7 +322,7 @@
             continue;
 
         case token_escape:
- esc = parse_escape(begin, end, traits);
+ esc = parse_escape(begin, end, tr);
             if(escape_char == esc.type_)
             {
                 ch_prev = esc.ch_;
@@ -347,7 +347,7 @@
         }
     }
     while(BOOST_XPR_ENSURE_((iprev = begin) != end, error_brack, "unexpected end of pattern found"),
- token_charset_end != (tok = traits.get_charset_token(begin, end)));
+ token_charset_end != (tok = tr.get_charset_token(begin, end)));
 
     if(have_prev)
     {

Modified: trunk/boost/xpressive/detail/dynamic/parser.hpp
==============================================================================
--- trunk/boost/xpressive/detail/dynamic/parser.hpp (original)
+++ trunk/boost/xpressive/detail/dynamic/parser.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -53,17 +53,17 @@
 (
     Char ch
   , regex_constants::syntax_option_type flags
- , Traits const &traits
+ , Traits const &tr
 )
 {
     if(0 != (regex_constants::icase_ & flags))
     {
- literal_matcher<Traits, mpl::true_, mpl::false_> matcher(ch, traits);
+ literal_matcher<Traits, mpl::true_, mpl::false_> matcher(ch, tr);
         return make_dynamic<BidiIter>(matcher);
     }
     else
     {
- literal_matcher<Traits, mpl::false_, mpl::false_> matcher(ch, traits);
+ literal_matcher<Traits, mpl::false_, mpl::false_> matcher(ch, tr);
         return make_dynamic<BidiIter>(matcher);
     }
 }
@@ -75,7 +75,7 @@
 inline sequence<BidiIter> make_any_xpression
 (
     regex_constants::syntax_option_type flags
- , Traits const &traits
+ , Traits const &tr
 )
 {
     using namespace regex_constants;
@@ -83,7 +83,7 @@
     typedef detail::set_matcher<Traits, mpl::int_<2> > set_matcher;
     typedef literal_matcher<Traits, mpl::false_, mpl::true_> literal_matcher;
 
- char_type const newline = traits.widen('\n');
+ char_type const newline = tr.widen('\n');
     set_matcher s;
     s.set_[0] = newline;
     s.set_[1] = 0;
@@ -92,10 +92,10 @@
     switch(((int)not_dot_newline | not_dot_null) & flags)
     {
     case not_dot_null:
- return make_dynamic<BidiIter>(literal_matcher(char_type(0), traits));
+ return make_dynamic<BidiIter>(literal_matcher(char_type(0), tr));
 
     case not_dot_newline:
- return make_dynamic<BidiIter>(literal_matcher(newline, traits));
+ return make_dynamic<BidiIter>(literal_matcher(newline, tr));
 
     case (int)not_dot_newline | not_dot_null:
         return make_dynamic<BidiIter>(s);
@@ -113,23 +113,23 @@
 (
     typename Traits::string_type const &literal
   , regex_constants::syntax_option_type flags
- , Traits const &traits
+ , Traits const &tr
 )
 {
     BOOST_ASSERT(0 != literal.size());
     if(1 == literal.size())
     {
- return make_char_xpression<BidiIter>(literal[0], flags, traits);
+ return make_char_xpression<BidiIter>(literal[0], flags, tr);
     }
 
     if(0 != (regex_constants::icase_ & flags))
     {
- string_matcher<Traits, mpl::true_> matcher(literal, traits);
+ string_matcher<Traits, mpl::true_> matcher(literal, tr);
         return make_dynamic<BidiIter>(matcher);
     }
     else
     {
- string_matcher<Traits, mpl::false_> matcher(literal, traits);
+ string_matcher<Traits, mpl::false_> matcher(literal, tr);
         return make_dynamic<BidiIter>(matcher);
     }
 }
@@ -142,21 +142,21 @@
 (
     int mark_nbr
   , regex_constants::syntax_option_type flags
- , Traits const &traits
+ , Traits const &tr
 )
 {
     if(0 != (regex_constants::icase_ & flags))
     {
         return make_dynamic<BidiIter>
         (
- mark_matcher<Traits, mpl::true_>(mark_nbr, traits)
+ mark_matcher<Traits, mpl::true_>(mark_nbr, tr)
         );
     }
     else
     {
         return make_dynamic<BidiIter>
         (
- mark_matcher<Traits, mpl::false_>(mark_nbr, traits)
+ mark_matcher<Traits, mpl::false_>(mark_nbr, tr)
         );
     }
 }
@@ -169,16 +169,16 @@
 (
     basic_chset<Char> &basic
   , compound_charset<Traits> const &compound
- , Traits const &traits
+ , Traits const &tr
 )
 {
- detail::ignore_unused(traits);
+ detail::ignore_unused(tr);
     if(0 != compound.posix_yes())
     {
         typename Traits::char_class_type mask = compound.posix_yes();
         for(int i = 0; i <= static_cast<int>(UCHAR_MAX); ++i)
         {
- if(traits.isctype((Char)i, mask))
+ if(tr.isctype((Char)i, mask))
             {
                 basic.set((Char)i);
             }
@@ -192,7 +192,7 @@
             typename Traits::char_class_type mask = compound.posix_no()[j];
             for(int i = 0; i <= static_cast<int>(UCHAR_MAX); ++i)
             {
- if(!traits.isctype((Char)i, mask))
+ if(!tr.isctype((Char)i, mask))
                 {
                     basic.set((Char)i);
                 }
@@ -213,7 +213,7 @@
 inline sequence<BidiIter> make_charset_xpression
 (
     compound_charset<Traits> &chset
- , Traits const &traits
+ , Traits const &tr
   , regex_constants::syntax_option_type flags
 )
 {
@@ -229,13 +229,13 @@
         if(icase)
         {
             charset_matcher<Traits, mpl::true_, charset_type> matcher(charset);
- merge_charset(matcher.charset_, chset, traits);
+ merge_charset(matcher.charset_, chset, tr);
             return make_dynamic<BidiIter>(matcher);
         }
         else
         {
             charset_matcher<Traits, mpl::false_, charset_type> matcher(charset);
- merge_charset(matcher.charset_, chset, traits);
+ merge_charset(matcher.charset_, chset, tr);
             return make_dynamic<BidiIter>(matcher);
         }
     }
@@ -287,7 +287,7 @@
 inline sequence<BidiIter> make_assert_begin_line
 (
     regex_constants::syntax_option_type flags
- , Traits const &traits
+ , Traits const &tr
 )
 {
     if(0 != (regex_constants::single_line & flags))
@@ -296,7 +296,7 @@
     }
     else
     {
- detail::assert_bol_matcher<Traits> matcher(traits);
+ detail::assert_bol_matcher<Traits> matcher(tr);
         return detail::make_dynamic<BidiIter>(matcher);
     }
 }
@@ -308,7 +308,7 @@
 inline sequence<BidiIter> make_assert_end_line
 (
     regex_constants::syntax_option_type flags
- , Traits const &traits
+ , Traits const &tr
 )
 {
     if(0 != (regex_constants::single_line & flags))
@@ -317,7 +317,7 @@
     }
     else
     {
- detail::assert_eol_matcher<Traits> matcher(traits);
+ detail::assert_eol_matcher<Traits> matcher(tr);
         return detail::make_dynamic<BidiIter>(matcher);
     }
 }
@@ -326,12 +326,12 @@
 // make_assert_word
 //
 template<typename BidiIter, typename Cond, typename Traits>
-inline sequence<BidiIter> make_assert_word(Cond, Traits const &traits)
+inline sequence<BidiIter> make_assert_word(Cond, Traits const &tr)
 {
     typedef typename iterator_value<BidiIter>::type char_type;
     return detail::make_dynamic<BidiIter>
     (
- detail::assert_word_matcher<Cond, Traits>(traits)
+ detail::assert_word_matcher<Cond, Traits>(tr)
     );
 }
 

Modified: trunk/boost/xpressive/detail/static/compile.hpp
==============================================================================
--- trunk/boost/xpressive/detail/static/compile.hpp (original)
+++ trunk/boost/xpressive/detail/static/compile.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -32,15 +32,15 @@
     ///////////////////////////////////////////////////////////////////////////////
     // static_compile_impl2
     template<typename Xpr, typename BidiIter, typename Traits>
- void static_compile_impl2(Xpr const &xpr, shared_ptr<regex_impl<BidiIter> > const &impl, Traits const &traits)
+ void static_compile_impl2(Xpr const &xpr, shared_ptr<regex_impl<BidiIter> > const &impl, Traits const &tr)
     {
         typedef typename iterator_value<BidiIter>::type char_type;
         impl->tracking_clear();
- impl->traits_ = new traits_holder<Traits>(traits);
+ impl->traits_ = new traits_holder<Traits>(tr);
 
         // "compile" the regex and wrap it in an xpression_adaptor.
         typedef xpression_visitor<BidiIter, mpl::false_, Traits> visitor_type;
- visitor_type visitor(traits, impl);
+ visitor_type visitor(tr, impl);
         intrusive_ptr<matchable_ex<BidiIter> const> adxpr = make_adaptor<matchable_ex<BidiIter> >(
             typename Grammar<char_type>::template impl<Xpr const &, end_xpression, visitor_type &>()(
                 xpr
@@ -75,8 +75,8 @@
         // use default traits
         typedef typename iterator_value<BidiIter>::type char_type;
         typedef typename default_regex_traits<char_type>::type traits_type;
- traits_type traits;
- static_compile_impl2(xpr, impl, traits);
+ traits_type tr;
+ static_compile_impl2(xpr, impl, tr);
     }
 
     ///////////////////////////////////////////////////////////////////////////////

Modified: trunk/boost/xpressive/detail/static/visitor.hpp
==============================================================================
--- trunk/boost/xpressive/detail/static/visitor.hpp (original)
+++ trunk/boost/xpressive/detail/static/visitor.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -42,12 +42,12 @@
             return -(int)(++this->self_->hidden_mark_count_);
         }
 
- void mark_number(int mark_number)
+ void mark_number(int mark_nbr)
         {
- if(0 < mark_number)
+ if(0 < mark_nbr)
             {
                 this->self_->mark_count_ =
- (std::max)(this->self_->mark_count_, (std::size_t)mark_number);
+ (std::max)(this->self_->mark_count_, (std::size_t)mark_nbr);
             }
         }
 

Modified: trunk/boost/xpressive/detail/utility/algorithm.hpp
==============================================================================
--- trunk/boost/xpressive/detail/utility/algorithm.hpp (original)
+++ trunk/boost/xpressive/detail/utility/algorithm.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -58,11 +58,11 @@
 // toi
 //
 template<typename InIter, typename Traits>
-int toi(InIter &begin, InIter end, Traits const &traits, int radix = 10, int max = INT_MAX)
+int toi(InIter &begin, InIter end, Traits const &tr, int radix = 10, int max = INT_MAX)
 {
- detail::ignore_unused(traits);
+ detail::ignore_unused(tr);
     int i = 0, c = 0;
- for(; begin != end && -1 != (c = traits.value(*begin, radix)); ++begin)
+ for(; begin != end && -1 != (c = tr.value(*begin, radix)); ++begin)
     {
         if(max < ((i *= radix) += c))
             return i / radix;

Modified: trunk/boost/xpressive/detail/utility/boyer_moore.hpp
==============================================================================
--- trunk/boost/xpressive/detail/utility/boyer_moore.hpp (original)
+++ trunk/boost/xpressive/detail/utility/boyer_moore.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -45,7 +45,7 @@
 
     // initialize the Boyer-Moore search data structure, using the
     // search sub-sequence to prime the pump.
- boyer_moore(char_type const *begin, char_type const *end, Traits const &traits, bool icase)
+ boyer_moore(char_type const *begin, char_type const *end, Traits const &tr, bool icase)
       : begin_(begin)
       , last_(begin)
       , fold_()
@@ -61,41 +61,41 @@
         std::fill_n(static_cast<unsigned char *>(this->offsets_), uchar_max + 1, this->length_);
         --this->length_;
 
- icase ? this->init_(traits, case_fold()) : this->init_(traits, mpl::false_());
+ icase ? this->init_(tr, case_fold()) : this->init_(tr, mpl::false_());
     }
 
- BidiIter find(BidiIter begin, BidiIter end, Traits const &traits) const
+ BidiIter find(BidiIter begin, BidiIter end, Traits const &tr) const
     {
- return (this->*this->find_fun_)(begin, end, traits);
+ return (this->*this->find_fun_)(begin, end, tr);
     }
 
 private:
 
- void init_(Traits const &traits, mpl::false_)
+ void init_(Traits const &tr, mpl::false_)
     {
         for(unsigned char offset = this->length_; offset; --offset, ++this->last_)
         {
- this->offsets_[traits.hash(*this->last_)] = offset;
+ this->offsets_[tr.hash(*this->last_)] = offset;
         }
     }
 
- void init_(Traits const &traits, mpl::true_)
+ void init_(Traits const &tr, mpl::true_)
     {
         this->fold_.reserve(this->length_ + 1);
         for(unsigned char offset = this->length_; offset; --offset, ++this->last_)
         {
- this->fold_.push_back(traits.fold_case(*this->last_));
+ this->fold_.push_back(tr.fold_case(*this->last_));
             for(typename string_type::const_iterator beg = this->fold_.back().begin(), end = this->fold_.back().end();
                 beg != end; ++beg)
             {
- this->offsets_[traits.hash(*beg)] = offset;
+ this->offsets_[tr.hash(*beg)] = offset;
             }
         }
- this->fold_.push_back(traits.fold_case(*this->last_));
+ this->fold_.push_back(tr.fold_case(*this->last_));
     }
 
     // case-sensitive Boyer-Moore search
- BidiIter find_(BidiIter begin, BidiIter end, Traits const &traits) const
+ BidiIter find_(BidiIter begin, BidiIter end, Traits const &tr) const
     {
         typedef typename boost::iterator_difference<BidiIter>::type diff_type;
         diff_type const endpos = std::distance(begin, end);
@@ -108,7 +108,7 @@
             char_type const *pat_tmp = this->last_;
             BidiIter str_tmp = begin;
 
- for(; traits.translate(*str_tmp) == *pat_tmp; --pat_tmp, --str_tmp)
+ for(; tr.translate(*str_tmp) == *pat_tmp; --pat_tmp, --str_tmp)
             {
                 if(pat_tmp == this->begin_)
                 {
@@ -116,14 +116,14 @@
                 }
             }
 
- offset = this->offsets_[traits.hash(traits.translate(*begin))];
+ offset = this->offsets_[tr.hash(tr.translate(*begin))];
         }
 
         return end;
     }
 
     // case-insensitive Boyer-Moore search
- BidiIter find_nocase_(BidiIter begin, BidiIter end, Traits const &traits) const
+ BidiIter find_nocase_(BidiIter begin, BidiIter end, Traits const &tr) const
     {
         typedef typename boost::iterator_difference<BidiIter>::type diff_type;
         diff_type const endpos = std::distance(begin, end);
@@ -136,7 +136,7 @@
             char_type const *pat_tmp = this->last_;
             BidiIter str_tmp = begin;
 
- for(; traits.translate_nocase(*str_tmp) == *pat_tmp; --pat_tmp, --str_tmp)
+ for(; tr.translate_nocase(*str_tmp) == *pat_tmp; --pat_tmp, --str_tmp)
             {
                 if(pat_tmp == this->begin_)
                 {
@@ -144,14 +144,14 @@
                 }
             }
 
- offset = this->offsets_[traits.hash(traits.translate_nocase(*begin))];
+ offset = this->offsets_[tr.hash(tr.translate_nocase(*begin))];
         }
 
         return end;
     }
 
     // case-insensitive Boyer-Moore search with case-folding
- BidiIter find_nocase_fold_(BidiIter begin, BidiIter end, Traits const &traits) const
+ BidiIter find_nocase_fold_(BidiIter begin, BidiIter end, Traits const &tr) const
     {
         typedef typename boost::iterator_difference<BidiIter>::type diff_type;
         diff_type const endpos = std::distance(begin, end);
@@ -173,7 +173,7 @@
                 }
             }
 
- offset = this->offsets_[traits.hash(*begin)];
+ offset = this->offsets_[tr.hash(*begin)];
         }
 
         return end;

Modified: trunk/boost/xpressive/detail/utility/chset/basic_chset.hpp
==============================================================================
--- trunk/boost/xpressive/detail/utility/chset/basic_chset.hpp (original)
+++ trunk/boost/xpressive/detail/utility/chset/basic_chset.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -32,23 +32,23 @@
     bool empty() const;
     void set(Char from, Char to);
     template<typename Traits>
- void set(Char from, Char to, Traits const &traits);
+ void set(Char from, Char to, Traits const &tr);
     void set(Char c);
     template<typename Traits>
- void set(Char c, Traits const &traits);
+ void set(Char c, Traits const &tr);
 
     void clear(Char from, Char to);
     template<typename Traits>
- void clear(Char from, Char to, Traits const &traits);
+ void clear(Char from, Char to, Traits const &tr);
     void clear(Char c);
     template<typename Traits>
- void clear(Char c, Traits const &traits);
+ void clear(Char c, Traits const &tr);
     void clear();
 
     template<typename Traits>
- bool test(Char v, Traits const &traits, mpl::false_) const; // case-sensitive
+ bool test(Char v, Traits const &tr, mpl::false_) const; // case-sensitive
     template<typename Traits>
- bool test(Char v, Traits const &traits, mpl::true_) const; // case-insensitive
+ bool test(Char v, Traits const &tr, mpl::true_) const; // case-insensitive
 
     void inverse();
     void swap(basic_chset& x);
@@ -79,23 +79,23 @@
 
     void set(Char from, Char to);
     template<typename Traits>
- void set(Char from, Char to, Traits const &traits);
+ void set(Char from, Char to, Traits const &tr);
     void set(Char c);
     template<typename Traits>
- void set(Char c, Traits const &traits);
+ void set(Char c, Traits const &tr);
 
     void clear(Char from, Char to);
     template<typename Traits>
- void clear(Char from, Char to, Traits const &traits);
+ void clear(Char from, Char to, Traits const &tr);
     void clear(Char c);
     template<typename Traits>
- void clear(Char c, Traits const &traits);
+ void clear(Char c, Traits const &tr);
     void clear();
 
     template<typename Traits>
- bool test(Char v, Traits const &traits, mpl::false_) const; // case-sensitive
+ bool test(Char v, Traits const &tr, mpl::false_) const; // case-sensitive
     template<typename Traits>
- bool test(Char v, Traits const &traits, mpl::true_) const; // case-insensitive
+ bool test(Char v, Traits const &tr, mpl::true_) const; // case-insensitive
 
     void inverse();
     void swap(basic_chset_8bit& x);
@@ -159,13 +159,13 @@
 ///////////////////////////////////////////////////////////////////////////////
 // helpers
 template<typename Char, typename Traits>
-void set_char(basic_chset<Char> &chset, Char ch, Traits const &traits, bool icase);
+void set_char(basic_chset<Char> &chset, Char ch, Traits const &tr, bool icase);
 
 template<typename Char, typename Traits>
-void set_range(basic_chset<Char> &chset, Char from, Char to, Traits const &traits, bool icase);
+void set_range(basic_chset<Char> &chset, Char from, Char to, Traits const &tr, bool icase);
 
 template<typename Char, typename Traits>
-void set_class(basic_chset<Char> &chset, typename Traits::char_class_type char_class, bool no, Traits const &traits);
+void set_class(basic_chset<Char> &chset, typename Traits::char_class_type char_class, bool no, Traits const &tr);
 
 }}} // namespace boost::xpressive::detail
 

Modified: trunk/boost/xpressive/detail/utility/chset/basic_chset.ipp
==============================================================================
--- trunk/boost/xpressive/detail/utility/chset/basic_chset.ipp (original)
+++ trunk/boost/xpressive/detail/utility/chset/basic_chset.ipp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -53,9 +53,9 @@
 //////////////////////////////////
 template<typename Char>
 template<typename Traits>
-inline bool basic_chset<Char>::test(Char v, Traits const &traits, mpl::true_) const // case-insensitive
+inline bool basic_chset<Char>::test(Char v, Traits const &tr, mpl::true_) const // case-insensitive
 {
- return this->rr_.test(v, traits);
+ return this->rr_.test(v, tr);
 }
 
 //////////////////////////////////
@@ -230,9 +230,9 @@
 /////////////////////////////////
 template<typename Char>
 template<typename Traits>
-inline bool basic_chset_8bit<Char>::test(Char v, Traits const &traits, mpl::true_) const // case-insensitive
+inline bool basic_chset_8bit<Char>::test(Char v, Traits const &tr, mpl::true_) const // case-insensitive
 {
- return this->bset_.test((unsigned char)traits.translate_nocase(v));
+ return this->bset_.test((unsigned char)tr.translate_nocase(v));
 }
 
 /////////////////////////////////
@@ -248,11 +248,11 @@
 /////////////////////////////////
 template<typename Char>
 template<typename Traits>
-inline void basic_chset_8bit<Char>::set(Char from, Char to, Traits const &traits)
+inline void basic_chset_8bit<Char>::set(Char from, Char to, Traits const &tr)
 {
     for(int i = from; i <= to; ++i)
     {
- this->bset_.set((unsigned char)traits.translate_nocase((Char)i));
+ this->bset_.set((unsigned char)tr.translate_nocase((Char)i));
     }
 }
 
@@ -266,9 +266,9 @@
 /////////////////////////////////
 template<typename Char>
 template<typename Traits>
-inline void basic_chset_8bit<Char>::set(Char c, Traits const &traits)
+inline void basic_chset_8bit<Char>::set(Char c, Traits const &tr)
 {
- this->bset_.set((unsigned char)traits.translate_nocase(c));
+ this->bset_.set((unsigned char)tr.translate_nocase(c));
 }
 
 /////////////////////////////////
@@ -284,11 +284,11 @@
 /////////////////////////////////
 template<typename Char>
 template<typename Traits>
-inline void basic_chset_8bit<Char>::clear(Char from, Char to, Traits const &traits)
+inline void basic_chset_8bit<Char>::clear(Char from, Char to, Traits const &tr)
 {
     for(int i = from; i <= to; ++i)
     {
- this->bset_.reset((unsigned char)traits.translate_nocase((Char)i));
+ this->bset_.reset((unsigned char)tr.translate_nocase((Char)i));
     }
 }
 
@@ -302,9 +302,9 @@
 /////////////////////////////////
 template<typename Char>
 template<typename Traits>
-inline void basic_chset_8bit<Char>::clear(Char c, Traits const &traits)
+inline void basic_chset_8bit<Char>::clear(Char c, Traits const &tr)
 {
- this->bset_.reset((unsigned char)traits.tranlsate_nocase(c));
+ this->bset_.reset((unsigned char)tr.tranlsate_nocase(c));
 }
 
 /////////////////////////////////
@@ -377,26 +377,26 @@
 ///////////////////////////////////////////////////////////////////////////////
 // helpers
 template<typename Char, typename Traits>
-inline void set_char(basic_chset<Char> &chset, Char ch, Traits const &traits, bool icase)
+inline void set_char(basic_chset<Char> &chset, Char ch, Traits const &tr, bool icase)
 {
- icase ? chset.set(ch, traits) : chset.set(ch);
+ icase ? chset.set(ch, tr) : chset.set(ch);
 }
 
 template<typename Char, typename Traits>
-inline void set_range(basic_chset<Char> &chset, Char from, Char to, Traits const &traits, bool icase)
+inline void set_range(basic_chset<Char> &chset, Char from, Char to, Traits const &tr, bool icase)
 {
- icase ? chset.set(from, to, traits) : chset.set(from, to);
+ icase ? chset.set(from, to, tr) : chset.set(from, to);
 }
 
 template<typename Char, typename Traits>
-inline void set_class(basic_chset<Char> &chset, typename Traits::char_class_type char_class, bool no, Traits const &traits)
+inline void set_class(basic_chset<Char> &chset, typename Traits::char_class_type char_class, bool no, Traits const &tr)
 {
     BOOST_MPL_ASSERT_RELATION(1, ==, sizeof(Char));
     for(std::size_t i = 0; i <= UCHAR_MAX; ++i)
     {
         typedef typename std::char_traits<Char>::int_type int_type;
         Char ch = std::char_traits<Char>::to_char_type(static_cast<int_type>(i));
- if(no != traits.isctype(ch, char_class))
+ if(no != tr.isctype(ch, char_class))
         {
             chset.set(ch);
         }

Modified: trunk/boost/xpressive/detail/utility/chset/chset.hpp
==============================================================================
--- trunk/boost/xpressive/detail/utility/chset/chset.hpp (original)
+++ trunk/boost/xpressive/detail/utility/chset/chset.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -74,14 +74,14 @@
 
     ///////////////////////////////////////////////////////////////////////////////
     // set
- void set_char(char_type ch, Traits const &traits, bool icase)
+ void set_char(char_type ch, Traits const &tr, bool icase)
     {
- icase ? this->base_type::set(ch, traits) : this->base_type::set(ch);
+ icase ? this->base_type::set(ch, tr) : this->base_type::set(ch);
     }
 
- void set_range(char_type from, char_type to, Traits const &traits, bool icase)
+ void set_range(char_type from, char_type to, Traits const &tr, bool icase)
     {
- icase ? this->base_type::set(from, to, traits) : this->base_type::set(from, to);
+ icase ? this->base_type::set(from, to, tr) : this->base_type::set(from, to);
     }
 
     void set_class(char_class_type const &m, bool no)
@@ -101,11 +101,11 @@
     ///////////////////////////////////////////////////////////////////////////////
     // test
     template<typename ICase>
- bool test(char_type ch, Traits const &traits, ICase) const
+ bool test(char_type ch, Traits const &tr, ICase) const
     {
         return this->complement_ !=
- (this->base_type::test(ch, traits, ICase()) ||
- (this->has_posix_ && this->test_posix(ch, traits)));
+ (this->base_type::test(ch, tr, ICase()) ||
+ (this->has_posix_ && this->test_posix(ch, tr)));
     }
 
 private:
@@ -125,10 +125,10 @@
 
     ///////////////////////////////////////////////////////////////////////////////
     // test_posix
- bool test_posix(char_type ch, Traits const &traits) const
+ bool test_posix(char_type ch, Traits const &tr) const
     {
- not_posix_pred const pred = {ch, &traits};
- return traits.isctype(ch, this->posix_yes_)
+ not_posix_pred const pred = {ch, &tr};
+ return tr.isctype(ch, this->posix_yes_)
             || any(this->posix_no_.begin(), this->posix_no_.end(), pred);
     }
 
@@ -142,15 +142,15 @@
 ///////////////////////////////////////////////////////////////////////////////
 // helpers
 template<typename Char, typename Traits>
-inline void set_char(compound_charset<Traits> &chset, Char ch, Traits const &traits, bool icase)
+inline void set_char(compound_charset<Traits> &chset, Char ch, Traits const &tr, bool icase)
 {
- chset.set_char(ch, traits, icase);
+ chset.set_char(ch, tr, icase);
 }
 
 template<typename Char, typename Traits>
-inline void set_range(compound_charset<Traits> &chset, Char from, Char to, Traits const &traits, bool icase)
+inline void set_range(compound_charset<Traits> &chset, Char from, Char to, Traits const &tr, bool icase)
 {
- chset.set_range(from, to, traits, icase);
+ chset.set_range(from, to, tr, icase);
 }
 
 template<typename Traits>

Modified: trunk/boost/xpressive/detail/utility/chset/range_run.hpp
==============================================================================
--- trunk/boost/xpressive/detail/utility/chset/range_run.hpp (original)
+++ trunk/boost/xpressive/detail/utility/chset/range_run.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -82,7 +82,7 @@
     bool empty() const;
     bool test(Char v) const;
     template<typename Traits>
- bool test(Char v, Traits const &traits) const;
+ bool test(Char v, Traits const &tr) const;
     void set(range_type const &r);
     void clear(range_type const &r);
     void clear();

Modified: trunk/boost/xpressive/detail/utility/chset/range_run.ipp
==============================================================================
--- trunk/boost/xpressive/detail/utility/chset/range_run.ipp (original)
+++ trunk/boost/xpressive/detail/utility/chset/range_run.ipp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -102,14 +102,14 @@
 
 template<typename Char>
 template<typename Traits>
-inline bool range_run<Char>::test(Char v, Traits const &traits) const
+inline bool range_run<Char>::test(Char v, Traits const &tr) const
 {
     const_iterator begin = this->run_.begin();
     const_iterator end = this->run_.end();
 
     for(; begin != end; ++begin)
     {
- if(traits.in_range_nocase(begin->first_, begin->last_, v))
+ if(tr.in_range_nocase(begin->first_, begin->last_, v))
         {
             return true;
         }

Modified: trunk/boost/xpressive/detail/utility/hash_peek_bitset.hpp
==============================================================================
--- trunk/boost/xpressive/detail/utility/hash_peek_bitset.hpp (original)
+++ trunk/boost/xpressive/detail/utility/hash_peek_bitset.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -50,17 +50,17 @@
     }
 
     template<typename Traits>
- void set_char(char_type ch, bool icase, Traits const &traits)
+ void set_char(char_type ch, bool icase, Traits const &tr)
     {
         if(this->test_icase_(icase))
         {
- ch = icase ? traits.translate_nocase(ch) : traits.translate(ch);
- this->bset_.set(traits.hash(ch));
+ ch = icase ? tr.translate_nocase(ch) : tr.translate(ch);
+ this->bset_.set(tr.hash(ch));
         }
     }
 
     template<typename Traits>
- void set_range(char_type from, char_type to, bool no, bool icase, Traits const &traits)
+ void set_range(char_type from, char_type to, bool no, bool icase, Traits const &tr)
     {
         int_type ifrom = std::char_traits<char_type>::to_int_type(from);
         int_type ito = std::char_traits<char_type>::to_int_type(to);
@@ -75,14 +75,14 @@
             for(int_type i = ifrom; i <= ito; ++i)
             {
                 char_type ch = std::char_traits<char_type>::to_char_type(i);
- ch = icase ? traits.translate_nocase(ch) : traits.translate(ch);
- this->bset_.set(traits.hash(ch));
+ ch = icase ? tr.translate_nocase(ch) : tr.translate(ch);
+ this->bset_.set(tr.hash(ch));
             }
         }
     }
 
     template<typename Traits>
- void set_class(typename Traits::char_class_type char_class, bool no, Traits const &traits)
+ void set_class(typename Traits::char_class_type char_class, bool no, Traits const &tr)
     {
         if(1 != sizeof(char_type))
         {
@@ -94,7 +94,7 @@
             for(std::size_t i = 0; i <= UCHAR_MAX; ++i)
             {
                 char_type ch = std::char_traits<char_type>::to_char_type(static_cast<int_type>(i));
- if(no != traits.isctype(ch, char_class))
+ if(no != tr.isctype(ch, char_class))
                 {
                     this->bset_.set(i);
                 }
@@ -124,24 +124,24 @@
     }
 
     template<typename Traits>
- bool test(char_type ch, Traits const &traits) const
+ bool test(char_type ch, Traits const &tr) const
     {
- ch = this->icase_ ? traits.translate_nocase(ch) : traits.translate(ch);
- return this->bset_.test(traits.hash(ch));
+ ch = this->icase_ ? tr.translate_nocase(ch) : tr.translate(ch);
+ return this->bset_.test(tr.hash(ch));
     }
 
     template<typename Traits>
- bool test(char_type ch, Traits const &traits, mpl::false_) const
+ bool test(char_type ch, Traits const &tr, mpl::false_) const
     {
         BOOST_ASSERT(!this->icase_);
- return this->bset_.test(traits.hash(traits.translate(ch)));
+ return this->bset_.test(tr.hash(tr.translate(ch)));
     }
 
     template<typename Traits>
- bool test(char_type ch, Traits const &traits, mpl::true_) const
+ bool test(char_type ch, Traits const &tr, mpl::true_) const
     {
         BOOST_ASSERT(this->icase_);
- return this->bset_.test(traits.hash(traits.translate_nocase(ch)));
+ return this->bset_.test(tr.hash(tr.translate_nocase(ch)));
     }
 
 private:

Modified: trunk/boost/xpressive/detail/utility/symbols.hpp
==============================================================================
--- trunk/boost/xpressive/detail/utility/symbols.hpp (original)
+++ trunk/boost/xpressive/detail/utility/symbols.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -169,7 +169,7 @@
         // conditional rotation : the goal is to minimize the overall
         // weighted path length of each binary search tree
         //
- bool const cond_rotation(bool left, node* const i, node* const j) const
+ bool cond_rotation(bool left, node* const i, node* const j) const
         {
             // don't rotate top node in binary search tree
             if (i == j)

Modified: trunk/boost/xpressive/detail/utility/traits_utils.hpp
==============================================================================
--- trunk/boost/xpressive/detail/utility/traits_utils.hpp (original)
+++ trunk/boost/xpressive/detail/utility/traits_utils.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -38,10 +38,10 @@
 
     template<typename ToChar, typename FromChar, typename Traits>
     inline ToChar
- char_cast(FromChar from, Traits const &traits, typename disable_if<is_same<ToChar, FromChar> >::type * = 0)
+ char_cast(FromChar from, Traits const &tr, typename disable_if<is_same<ToChar, FromChar> >::type * = 0)
     {
         BOOST_MPL_ASSERT((is_same<FromChar, char>));
- return traits.widen(from);
+ return tr.widen(from);
     }
 
     ///////////////////////////////////////////////////////////////////////////////
@@ -51,8 +51,8 @@
     struct widen_fun
     {
         typedef typename Traits::char_type result_type;
- explicit widen_fun(Traits const &traits)
- : traits_(traits)
+ explicit widen_fun(Traits const &tr)
+ : traits_(tr)
         {}
 
         result_type operator()(char ch) const
@@ -77,9 +77,9 @@
         BOOST_MPL_ASSERT((is_same<FromChar, char>));
         typedef To const result_type;
         template<typename Traits>
- result_type operator()(From const &from, Traits const &traits) const
+ result_type operator()(From const &from, Traits const &tr) const
         {
- widen_fun<Traits> widen(traits);
+ widen_fun<Traits> widen(tr);
             To to(
                 boost::make_transform_iterator(detail::data_begin(from), widen)
               , boost::make_transform_iterator(detail::data_end(from), widen)
@@ -116,24 +116,24 @@
     //
     template<typename To, typename From, typename Traits>
     typename string_cast_<To, From>::result_type
- string_cast(From const &from, Traits const &traits)
+ string_cast(From const &from, Traits const &tr)
     {
- return string_cast_<To, From>()(from, traits);
+ return string_cast_<To, From>()(from, tr);
     }
 
     ///////////////////////////////////////////////////////////////////////////////
     // translate
     //
     template<typename Char, typename Traits>
- inline Char translate(Char ch, Traits const &traits, mpl::false_) // case-sensitive
+ inline Char translate(Char ch, Traits const &tr, mpl::false_) // case-sensitive
     {
- return traits.translate(ch);
+ return tr.translate(ch);
     }
 
     template<typename Char, typename Traits>
- inline Char translate(Char ch, Traits const &traits, mpl::true_) // case-insensitive
+ inline Char translate(Char ch, Traits const &tr, mpl::true_) // case-insensitive
     {
- return traits.translate_nocase(ch);
+ return tr.translate_nocase(ch);
     }
 
 }}} // namespace boost::xpressive::detail

Modified: trunk/boost/xpressive/detail/utility/width.hpp
==============================================================================
--- trunk/boost/xpressive/detail/utility/width.hpp (original)
+++ trunk/boost/xpressive/detail/utility/width.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -27,8 +27,8 @@
 // width
 struct width
 {
- width(std::size_t value = 0)
- : value_(value)
+ width(std::size_t val = 0)
+ : value_(val)
     {
     }
 

Modified: trunk/boost/xpressive/match_results.hpp
==============================================================================
--- trunk/boost/xpressive/match_results.hpp (original)
+++ trunk/boost/xpressive/match_results.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -125,9 +125,9 @@
 struct case_converting_iterator
   : std::iterator<std::output_iterator_tag, Char, void, void, case_converting_iterator<OutputIterator, Char> >
 {
- case_converting_iterator(OutputIterator const &out, traits<Char> const *traits)
+ case_converting_iterator(OutputIterator const &out, traits<Char> const *tr)
       : out_(out)
- , traits_(traits)
+ , traits_(tr)
       , next_(None)
       , rest_(None)
     {}
@@ -709,13 +709,13 @@
     void init_
     (
         regex_id_type regex_id
- , intrusive_ptr<detail::traits<char_type> const> const &traits
+ , intrusive_ptr<detail::traits<char_type> const> const &tr
       , detail::sub_match_impl<BidiIter> *sub_matches
       , size_type size
       , std::vector<detail::named_mark<char_type> > const &named_marks
     )
     {
- this->traits_ = traits;
+ this->traits_ = tr;
         this->regex_id_ = regex_id;
         this->named_marks_ = named_marks;
         detail::core_access<BidiIter>::init_sub_match_vector(this->sub_matches_, sub_matches, size);

Modified: trunk/boost/xpressive/regex_token_iterator.hpp
==============================================================================
--- trunk/boost/xpressive/regex_token_iterator.hpp (original)
+++ trunk/boost/xpressive/regex_token_iterator.hpp 2009-08-28 12:45:21 EDT (Fri, 28 Aug 2009)
@@ -93,14 +93,14 @@
     return i;
 }
 
-inline std::vector<int> to_vector(int sub_match)
+inline std::vector<int> to_vector(int subs)
 {
- return std::vector<int>(1, sub_match);
+ return std::vector<int>(1, subs);
 }
 
-inline std::vector<int> const &to_vector(std::vector<int> const &sub_matches)
+inline std::vector<int> const &to_vector(std::vector<int> const &subs)
 {
- return sub_matches;
+ return subs;
 }
 
 template<typename Int, std::size_t Size>


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk