Update of /cvsroot/boost/boost/boost/xpressive/proto
In directory
sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv19904/boost/xpressive/proto
Modified Files:
context.hpp debug.hpp expr.hpp extends.hpp operators.hpp
proto_fwd.hpp proto_typeof.hpp tags.hpp traits.hpp
Log Message:
rename left_shift to shift_left, non-terminals do not get non-const overloads
for op=, op[] and op() for better compile times
Index: context.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/context.hpp,v
retrieving revision 1.28
retrieving revision 1.29
diff -u -d -r1.28 -r1.29
--- context.hpp 5 May 2007 15:02:17 -0000 1.28
+++ context.hpp 21 May 2007 03:21:33 -0000 1.29
@@ -37,7 +37,7 @@
// If we're generating doxygen documentation, hide all the nasty
// Boost.Typeof gunk.
#ifndef BOOST_PROTO_DOXYGEN_INVOKED
- #define BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL(Nested, Expr)\
+ #define BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(Nested, Expr)\
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(BOOST_PP_CAT(nested_and_hidden_,
Nested), Expr)\
struct Nested\
: mpl::if_c<\
@@ -47,13 +47,16 @@
>\
{};
- #define BOOST_PROTO_TYPEOF(Expr, Type)\
- BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL(BOOST_PP_CAT(nested_,
Type), (Expr))\
+ #define BOOST_PROTO_DECLTYPE_(Expr, Type)\
+ BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(BOOST_PP_CAT(nested_,
Type), (Expr))\
typedef typename BOOST_PP_CAT(nested_, Type)::type Type;
#else
/// INTERNAL ONLY
///
- #define BOOST_PROTO_TYPEOF(Expr, Type)\
+ #define BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(Nested, Expr)
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_DECLTYPE_(Expr, Type)\
typedef detail::unspecified Type;
#endif
@@ -81,7 +84,7 @@
template<typename A0, typename A1>
struct comma_result
{
- BOOST_PROTO_TYPEOF((detail::make<A0>(), detail::make<A1>()),
type)
+ BOOST_PROTO_DECLTYPE_((detail::make<A0>(),
detail::make<A1>()), type)
};
template<typename A0>
@@ -157,7 +160,7 @@
static Expr &sexpr;\
static Context &sctx;\
public:\
- BOOST_PROTO_TYPEOF(Op
proto::eval(BOOST_PROTO_REF(proto::arg_c<0>(sexpr)), sctx), result_type)\
+ BOOST_PROTO_DECLTYPE_(Op
proto::eval(BOOST_PROTO_REF(proto::arg_c<0>(sexpr)), sctx), result_type)\
result_type operator()(Expr &expr, Context &ctx) const\
{\
return Op proto::eval(proto::arg_c<0>(expr), ctx);\
@@ -175,7 +178,7 @@
static Expr &sexpr;\
static Context &sctx;\
public:\
-
BOOST_PROTO_TYPEOF(proto::eval(BOOST_PROTO_REF(proto::arg_c<0>(sexpr)), sctx)
Op proto::eval(BOOST_PROTO_REF(proto::arg_c<1>(sexpr)), sctx), result_type)\
+
BOOST_PROTO_DECLTYPE_(proto::eval(BOOST_PROTO_REF(proto::arg_c<0>(sexpr)),
sctx) Op proto::eval(BOOST_PROTO_REF(proto::arg_c<1>(sexpr)), sctx),
result_type)\
result_type operator()(Expr &expr, Context &ctx) const\
{\
return proto::eval(proto::arg_c<0>(expr), ctx) Op
proto::eval(proto::arg_c<1>(expr), ctx);\
@@ -192,8 +195,8 @@
BOOST_PROTO_UNARY_OP_RESULT(++, proto::tag::pre_inc)
BOOST_PROTO_UNARY_OP_RESULT(--, proto::tag::pre_dec)
- BOOST_PROTO_BINARY_OP_RESULT(<<, proto::tag::left_shift)
- BOOST_PROTO_BINARY_OP_RESULT(>>, proto::tag::right_shift)
+ BOOST_PROTO_BINARY_OP_RESULT(<<, proto::tag::shift_left)
+ BOOST_PROTO_BINARY_OP_RESULT(>>, proto::tag::shift_right)
BOOST_PROTO_BINARY_OP_RESULT(*, proto::tag::multiplies)
BOOST_PROTO_BINARY_OP_RESULT(/, proto::tag::divides)
BOOST_PROTO_BINARY_OP_RESULT(%, proto::tag::modulus)
@@ -213,8 +216,8 @@
BOOST_PROTO_BINARY_OP_RESULT(->*, proto::tag::mem_ptr)
BOOST_PROTO_BINARY_OP_RESULT(=, proto::tag::assign)
- BOOST_PROTO_BINARY_OP_RESULT(<<=, proto::tag::left_shift_assign)
- BOOST_PROTO_BINARY_OP_RESULT(>>=, proto::tag::right_shift_assign)
+ BOOST_PROTO_BINARY_OP_RESULT(<<=, proto::tag::shift_left_assign)
+ BOOST_PROTO_BINARY_OP_RESULT(>>=, proto::tag::shift_right_assign)
BOOST_PROTO_BINARY_OP_RESULT(*=, proto::tag::multilpies_assign)
BOOST_PROTO_BINARY_OP_RESULT(/=, proto::tag::divides_assign)
BOOST_PROTO_BINARY_OP_RESULT(%=, proto::tag::modulus_assign)
@@ -249,7 +252,7 @@
static Expr &sexpr;
static Context &sctx;
public:
-
BOOST_PROTO_TYPEOF(proto::eval(BOOST_PROTO_REF(proto::arg_c<0>(sexpr)), sctx)
++, result_type)
+
BOOST_PROTO_DECLTYPE_(proto::eval(BOOST_PROTO_REF(proto::arg_c<0>(sexpr)),
sctx) ++, result_type)
result_type operator()(Expr &expr, Context &ctx) const
{
return proto::eval(proto::arg_c<0>(expr), ctx) ++;
@@ -264,7 +267,7 @@
static Expr &sexpr;
static Context &sctx;
public:
-
BOOST_PROTO_TYPEOF(proto::eval(BOOST_PROTO_REF(proto::arg_c<0>(sexpr)), sctx)
--, result_type)
+
BOOST_PROTO_DECLTYPE_(proto::eval(BOOST_PROTO_REF(proto::arg_c<0>(sexpr)),
sctx) --, result_type)
result_type operator()(Expr &expr, Context &ctx) const
{
return proto::eval(proto::arg_c<0>(expr), ctx) --;
@@ -279,7 +282,7 @@
static Expr &sexpr;
static Context &sctx;
public:
-
BOOST_PROTO_TYPEOF(proto::eval(BOOST_PROTO_REF(proto::arg_c<0>(sexpr)),
sctx)[proto::eval(BOOST_PROTO_REF(proto::arg_c<1>(sexpr)), sctx)], result_type)
+
BOOST_PROTO_DECLTYPE_(proto::eval(BOOST_PROTO_REF(proto::arg_c<0>(sexpr)),
sctx)[proto::eval(BOOST_PROTO_REF(proto::arg_c<1>(sexpr)), sctx)], result_type)
result_type operator()(Expr &expr, Context &ctx) const
{
return proto::eval(proto::arg_c<0>(expr),
ctx)[proto::eval(proto::arg_c<1>(expr), ctx)];
@@ -349,6 +352,9 @@
}}
+ #undef BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_
+ #undef BOOST_PROTO_DECLTYPE_
+
#endif
#else
Index: debug.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/debug.hpp,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- debug.hpp 29 Apr 2007 03:38:49 -0000 1.6
+++ debug.hpp 21 May 2007 03:21:33 -0000 1.7
@@ -51,8 +51,8 @@
BOOST_PROTO_DEFINE_TAG_NAME(pre_dec)
BOOST_PROTO_DEFINE_TAG_NAME(post_inc)
BOOST_PROTO_DEFINE_TAG_NAME(post_dec)
- BOOST_PROTO_DEFINE_TAG_NAME(left_shift)
- BOOST_PROTO_DEFINE_TAG_NAME(right_shift)
+ BOOST_PROTO_DEFINE_TAG_NAME(shift_left)
+ BOOST_PROTO_DEFINE_TAG_NAME(shift_right)
BOOST_PROTO_DEFINE_TAG_NAME(multiplies)
BOOST_PROTO_DEFINE_TAG_NAME(divides)
BOOST_PROTO_DEFINE_TAG_NAME(modulus)
@@ -72,8 +72,8 @@
BOOST_PROTO_DEFINE_TAG_NAME(comma)
BOOST_PROTO_DEFINE_TAG_NAME(mem_ptr)
BOOST_PROTO_DEFINE_TAG_NAME(assign)
- BOOST_PROTO_DEFINE_TAG_NAME(left_shift_assign)
- BOOST_PROTO_DEFINE_TAG_NAME(right_shift_assign)
+ BOOST_PROTO_DEFINE_TAG_NAME(shift_left_assign)
+ BOOST_PROTO_DEFINE_TAG_NAME(shift_right_assign)
BOOST_PROTO_DEFINE_TAG_NAME(multilpies_assign)
BOOST_PROTO_DEFINE_TAG_NAME(divides_assign)
BOOST_PROTO_DEFINE_TAG_NAME(modulus_assign)
Index: expr.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/expr.hpp,v
retrieving revision 1.31
retrieving revision 1.32
diff -u -d -r1.31 -r1.32
--- expr.hpp 5 May 2007 01:07:16 -0000 1.31
+++ expr.hpp 21 May 2007 03:21:33 -0000 1.32
@@ -71,11 +71,14 @@
namespace result_of
{
- #define BOOST_PP_ITERATION_PARAMS_1 (3, (1,
BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY), <boost/xpressive/proto/detail/funop.hpp>))
+ template<typename Sig, typename This>
+ struct funop;
+
+ #define BOOST_PP_ITERATION_PARAMS_1 (3, (0,
BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY), <boost/xpressive/proto/detail/funop.hpp>))
#include BOOST_PP_ITERATE()
}
- #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY,
<boost/xpressive/proto/expr.hpp>))
+ #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PROTO_MAX_ARITY,
<boost/xpressive/proto/expr.hpp>))
#include BOOST_PP_ITERATE()
#undef BOOST_PROTO_ARG
@@ -110,32 +113,44 @@
/// type is \c boost::proto::tag::terminal, in which case
/// \c Args must be \c proto::args1\<T\>, where \c T can
be any
/// type.
+ #if 0 == BOOST_PP_ITERATION()
+ #define IS_TERMINAL 1
+ #define ARG_COUNT 1
+ template<typename Args>
+ struct expr<proto::tag::terminal, Args, 1>
+ {
+ typedef proto::tag::terminal tag_type;
+ typedef mpl::long_<1> arity;
+ #else
+ #define IS_TERMINAL 0
+ #define ARG_COUNT BOOST_PP_ITERATION()
template<typename Tag, typename Args>
struct expr<Tag, Args, BOOST_PP_ITERATION() >
{
typedef Tag tag_type;
+ typedef mpl::long_<BOOST_PP_ITERATION() > arity;
+ #endif
typedef expr type;
typedef Args args_type;
typedef default_domain domain;
- typedef mpl::long_<BOOST_PP_ITERATION()> arity;
typedef proto_expr_tag fusion_tag;
typedef void is_boost_proto_expr_;
typedef expr boost_proto_expr_type_;
BOOST_PROTO_IDENTITY_TRANSFORM();
- BOOST_PP_REPEAT(BOOST_PP_ITERATION(), BOOST_PROTO_ARG, ~)
- BOOST_PP_REPEAT_FROM_TO(BOOST_PP_ITERATION(),
BOOST_PROTO_MAX_ARITY, BOOST_PROTO_VOID, ~)
+ BOOST_PP_REPEAT(ARG_COUNT, BOOST_PROTO_ARG, ~)
+ BOOST_PP_REPEAT_FROM_TO(ARG_COUNT, BOOST_PROTO_MAX_ARITY,
BOOST_PROTO_VOID, ~)
/// \return *this
///
- expr &cast()
+ expr const &cast() const
{
return *this;
}
- /// \return *this
+ /// \overload
///
- expr const &cast() const
+ expr &cast()
{
return *this;
}
@@ -143,14 +158,14 @@
/// \return A new \c expr\<\> object initialized with the specified
/// arguments.
///
- template<BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), typename A)>
- static expr make(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_ITERATION(),
A, const &a))
+ template<BOOST_PP_ENUM_PARAMS(ARG_COUNT, typename A)>
+ static expr make(BOOST_PP_ENUM_BINARY_PARAMS(ARG_COUNT, A, const
&a))
{
- expr that = {BOOST_PP_ENUM_PARAMS(BOOST_PP_ITERATION(), a)};
+ expr that = {BOOST_PP_ENUM_PARAMS(ARG_COUNT, a)};
return that;
}
- #if 1 == BOOST_PP_ITERATION()
+ #if IS_TERMINAL
/// \overload
///
template<typename A0>
@@ -159,7 +174,9 @@
expr that = {a0};
return that;
}
+ #endif
+ #if 1 == BOOST_PP_ITERATION()
/// If \c Tag is \c boost::proto::tag::address_of and \c arg0_type
is
/// \c proto::ref_\<T\>, then \c address_of_hack_type_ is
<tt>T*</tt>.
/// Otherwise, it is some undefined type.
@@ -183,95 +200,95 @@
/// \param a The rhs.
/// \return A new \c expr\<\> node representing an assignment of
\c a to \c *this.
template<typename A>
- expr<tag::assign, args2<ref_<expr>, typename
result_of::as_arg<A>::type> > const
- operator =(A &a)
+ expr<tag::assign, args2<ref_<expr const>, typename
result_of::as_arg<A>::type> > const
+ operator =(A &a) const
{
- expr<tag::assign, args2<ref_<expr>, typename
result_of::as_arg<A>::type> > that = {{*this}, proto::as_arg(a)};
+ expr<tag::assign, args2<ref_<expr const>, typename
result_of::as_arg<A>::type> > that = {{*this}, proto::as_arg(a)};
return that;
}
/// \overload
///
template<typename A>
- expr<tag::assign, args2<ref_<expr>, typename result_of::as_arg<A
const>::type> > const
- operator =(A const &a)
+ expr<tag::assign, args2<ref_<expr const>, typename
result_of::as_arg<A const>::type> > const
+ operator =(A const &a) const
{
- expr<tag::assign, args2<ref_<expr>, typename
result_of::as_arg<A const>::type> > that = {{*this}, proto::as_arg(a)};
+ expr<tag::assign, args2<ref_<expr const>, typename
result_of::as_arg<A const>::type> > that = {{*this}, proto::as_arg(a)};
return that;
}
+ #if IS_TERMINAL
/// \overload
///
template<typename A>
- expr<tag::assign, args2<ref_<expr const>, typename
result_of::as_arg<A>::type> > const
- operator =(A &a) const
+ expr<tag::assign, args2<ref_<expr>, typename
result_of::as_arg<A>::type> > const
+ operator =(A &a)
{
- expr<tag::assign, args2<ref_<expr const>, typename
result_of::as_arg<A>::type> > that = {{*this}, proto::as_arg(a)};
+ expr<tag::assign, args2<ref_<expr>, typename
result_of::as_arg<A>::type> > that = {{*this}, proto::as_arg(a)};
return that;
}
/// \overload
///
template<typename A>
- expr<tag::assign, args2<ref_<expr const>, typename
result_of::as_arg<A const>::type> > const
- operator =(A const &a) const
+ expr<tag::assign, args2<ref_<expr>, typename result_of::as_arg<A
const>::type> > const
+ operator =(A const &a)
{
- expr<tag::assign, args2<ref_<expr const>, typename
result_of::as_arg<A const>::type> > that = {{*this}, proto::as_arg(a)};
+ expr<tag::assign, args2<ref_<expr>, typename
result_of::as_arg<A const>::type> > that = {{*this}, proto::as_arg(a)};
return that;
}
+ #endif
/// Subscript
///
/// \param a The rhs.
/// \return A new \c expr\<\> node representing \c *this
subscripted with \c a.
template<typename A>
- expr<tag::subscript, args2<ref_<expr>, typename
result_of::as_arg<A>::type> > const
- operator [](A &a)
+ expr<tag::subscript, args2<ref_<expr const>, typename
result_of::as_arg<A>::type> > const
+ operator [](A &a) const
{
- expr<tag::subscript, args2<ref_<expr>, typename
result_of::as_arg<A>::type> > that = {{*this}, proto::as_arg(a)};
+ expr<tag::subscript, args2<ref_<expr const>, typename
result_of::as_arg<A>::type> > that = {{*this}, proto::as_arg(a)};
return that;
}
/// \overload
///
template<typename A>
- expr<tag::subscript, args2<ref_<expr>, typename
result_of::as_arg<A const>::type> > const
- operator [](A const &a)
+ expr<tag::subscript, args2<ref_<expr const>, typename
result_of::as_arg<A const>::type> > const
+ operator [](A const &a) const
{
- expr<tag::subscript, args2<ref_<expr>, typename
result_of::as_arg<A const>::type> > that = {{*this}, proto::as_arg(a)};
+ expr<tag::subscript, args2<ref_<expr const>, typename
result_of::as_arg<A const>::type> > that = {{*this}, proto::as_arg(a)};
return that;
}
+ #if IS_TERMINAL
/// \overload
///
template<typename A>
- expr<tag::subscript, args2<ref_<expr const>, typename
result_of::as_arg<A>::type> > const
- operator [](A &a) const
+ expr<tag::subscript, args2<ref_<expr>, typename
result_of::as_arg<A>::type> > const
+ operator [](A &a)
{
- expr<tag::subscript, args2<ref_<expr const>, typename
result_of::as_arg<A>::type> > that = {{*this}, proto::as_arg(a)};
+ expr<tag::subscript, args2<ref_<expr>, typename
result_of::as_arg<A>::type> > that = {{*this}, proto::as_arg(a)};
return that;
}
/// \overload
///
template<typename A>
- expr<tag::subscript, args2<ref_<expr const>, typename
result_of::as_arg<A const>::type> > const
- operator [](A const &a) const
+ expr<tag::subscript, args2<ref_<expr>, typename
result_of::as_arg<A const>::type> > const
+ operator [](A const &a)
{
- expr<tag::subscript, args2<ref_<expr const>, typename
result_of::as_arg<A const>::type> > that = {{*this}, proto::as_arg(a)};
+ expr<tag::subscript, args2<ref_<expr>, typename
result_of::as_arg<A const>::type> > that = {{*this}, proto::as_arg(a)};
return that;
}
-
- template<typename Sig>
- struct result {};
+ #endif
/// Encodes the return type of \c expr\<\>::operator(), for use
with \c boost::result_of\<\>
///
- template<typename This>
- struct result<This()>
- {
- typedef expr<tag::function, args1<ref_<expr const> > > type;
- };
+ template<typename Sig>
+ struct result
+ : result_of::funop<Sig, expr>
+ {};
/// Function call
///
@@ -283,19 +300,28 @@
return that;
}
+ #if IS_TERMINAL
+ /// \overload
+ ///
+ expr<tag::function, args1<ref_<expr> > > const
+ operator ()()
+ {
+ expr<tag::function, args1<ref_<expr> > > that = {{*this}};
+ return that;
+ }
+ #endif
+
#define BOOST_PP_ITERATION_PARAMS_2 (3, (1,
BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY), <boost/xpressive/proto/expr.hpp>))
#include BOOST_PP_ITERATE()
};
+ #undef ARG_COUNT
+ #undef IS_TERMINAL
+
#elif BOOST_PP_ITERATION_DEPTH() == 2
#define N BOOST_PP_ITERATION()
- template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
- struct result<This(BOOST_PP_ENUM_PARAMS(N, A))>
- : result_of::BOOST_PP_CAT(funop, N)<expr const
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, typename remove_reference<A, >::type
BOOST_PP_INTERCEPT)>
- {};
-
/// \overload
///
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
@@ -306,6 +332,18 @@
::call(*this BOOST_PP_ENUM_TRAILING_PARAMS(N, a));
}
+ #if IS_TERMINAL
+ /// \overload
+ ///
+ template<BOOST_PP_ENUM_PARAMS(N, typename A)>
+ typename result_of::BOOST_PP_CAT(funop, N)<expr
BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)>::type const
+ operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a))
+ {
+ return result_of::BOOST_PP_CAT(funop, N)<expr
BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)>
+ ::call(*this BOOST_PP_ENUM_TRAILING_PARAMS(N, a));
+ }
+ #endif
+
#undef N
#endif
Index: extends.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/extends.hpp,v
retrieving revision 1.31
retrieving revision 1.32
diff -u -d -r1.31 -r1.32
--- extends.hpp 7 May 2007 04:41:25 -0000 1.31
+++ extends.hpp 21 May 2007 03:21:33 -0000 1.32
@@ -11,6 +11,7 @@
#include <boost/xpressive/proto/detail/prefix.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
+#include <boost/preprocessor/control/if.hpp>
#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/iteration/local.hpp>
@@ -30,48 +31,62 @@
{
/// INTERNAL ONLY
///
- #define BOOST_PROTO_DEFINE_FUN_OP(Z, N, Data)\
- template<typename This BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, typename
A)>\
- struct result<This(BOOST_PP_ENUM_PARAMS_Z(Z, N, A))>\
- {\
- typedef\
- typename boost::proto::generate<\
- BOOST_PP_TUPLE_ELEM(3, 2, Data)\
- , typename boost::proto::result_of::BOOST_PP_CAT(funop, N)<\
- BOOST_PP_TUPLE_ELEM(3, 1, Data) const\
- BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(\
- Z\
- , N\
- , typename boost::remove_reference<A\
- , >::type BOOST_PP_INTERCEPT\
- )\
- >::type\
- >::type\
- type;\
- };\
- \
- template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)>\
+ #define BOOST_PROTO_CONST0
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_CONST1 const
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_TEMPLATE_YES_(Z, N) template<BOOST_PP_ENUM_PARAMS_Z(Z,
N, typename A)>
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_TEMPLATE_NO_(Z, N)
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, Data, Const)\
+ BOOST_PP_IF(N, BOOST_PROTO_TEMPLATE_YES_, BOOST_PROTO_TEMPLATE_NO_)(Z,
N)\
typename boost::proto::generate<\
BOOST_PP_TUPLE_ELEM(3, 2, Data)\
, typename boost::proto::result_of::BOOST_PP_CAT(funop, N)<\
- BOOST_PP_TUPLE_ELEM(3, 1, Data) const\
+ BOOST_PP_TUPLE_ELEM(3, 1, Data) BOOST_PROTO_CONST ## Const\
BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A)\
>::type\
>::type const\
- operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a)) const\
+ operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, const &a))
BOOST_PROTO_CONST ## Const\
{\
typedef boost::proto::result_of::BOOST_PP_CAT(funop, N)<\
- BOOST_PP_TUPLE_ELEM(3, 1, Data) const\
+ BOOST_PP_TUPLE_ELEM(3, 1, Data) BOOST_PROTO_CONST ## Const\
BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, const A)\
> funop;\
return boost::proto::generate<BOOST_PP_TUPLE_ELEM(3, 2, Data),
typename funop::type>::make(\
- funop::call(*static_cast<BOOST_PP_TUPLE_ELEM(3, 1, Data) const
*>(this) BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, a))\
+ funop::call(*static_cast<BOOST_PP_TUPLE_ELEM(3, 1, Data)
BOOST_PROTO_CONST ## Const *>(this) BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, a))\
);\
}\
/**/
/// INTERNAL ONLY
///
+ #define BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, Data)\
+ BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, Data, 1)
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, Data)\
+ BOOST_PROTO_DEFINE_FUN_OP_IMPL_(Z, N, Data, 0)
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_DEFINE_FUN_OP(Z, N, Data)\
+ BOOST_PROTO_DEFINE_FUN_OP_CONST(Z, N, Data)\
+ BOOST_PROTO_DEFINE_FUN_OP_NON_CONST(Z, N, Data)\
+ /**/
+
+ /// INTERNAL ONLY
+ ///
#define BOOST_PROTO_EXTENDS_ARG(z, n, Expr)\
typedef\
typename Expr::BOOST_PP_CAT(BOOST_PP_CAT(arg, n), _type)\
@@ -110,106 +125,97 @@
}\
/**/
- #define BOOST_PROTO_EXTENDS_ASSIGN(Expr, Derived, Domain)\
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(Expr, Derived, Domain, Const)\
template<typename A>\
- typename boost::proto::generate<Domain,
boost::proto::expr<boost::proto::tag::assign,
boost::proto::args2<boost::proto::ref_<Derived >, typename
boost::proto::result_of::as_arg<A>::type> > >::type const\
- operator =(A &a)\
+ typename boost::proto::generate<Domain,
boost::proto::expr<boost::proto::tag::assign,
boost::proto::args2<boost::proto::ref_<Derived BOOST_PROTO_CONST ## Const>,
typename boost::proto::result_of::as_arg<A>::type> > >::type const\
+ operator =(A &a) BOOST_PROTO_CONST ## Const\
{\
- typedef boost::proto::expr<boost::proto::tag::assign,
boost::proto::args2<boost::proto::ref_<Derived >, typename
boost::proto::result_of::as_arg<A>::type> > that_type;\
- that_type that = {{*static_cast<Derived *>(this)},
boost::proto::as_arg(a)};\
+ typedef boost::proto::expr<boost::proto::tag::assign,
boost::proto::args2<boost::proto::ref_<Derived BOOST_PROTO_CONST ## Const>,
typename boost::proto::result_of::as_arg<A>::type> > that_type;\
+ that_type that = {{*static_cast<Derived BOOST_PROTO_CONST ## Const
*>(this)}, boost::proto::as_arg(a)};\
return boost::proto::generate<Domain, that_type>::make(that);\
}\
\
template<typename A>\
- typename boost::proto::generate<Domain,
boost::proto::expr<boost::proto::tag::assign,
boost::proto::args2<boost::proto::ref_<Derived >, typename
boost::proto::result_of::as_arg<A const>::type> > >::type const\
- operator =(A const &a)\
+ typename boost::proto::generate<Domain,
boost::proto::expr<boost::proto::tag::assign,
boost::proto::args2<boost::proto::ref_<Derived BOOST_PROTO_CONST ## Const>,
typename boost::proto::result_of::as_arg<A const>::type> > >::type const\
+ operator =(A const &a) BOOST_PROTO_CONST ## Const\
{\
- typedef boost::proto::expr<boost::proto::tag::assign,
boost::proto::args2<boost::proto::ref_<Derived >, typename
boost::proto::result_of::as_arg<A const>::type> > that_type;\
- that_type that = {{*static_cast<Derived *>(this)},
boost::proto::as_arg(a)};\
+ typedef boost::proto::expr<boost::proto::tag::assign,
boost::proto::args2<boost::proto::ref_<Derived BOOST_PROTO_CONST ## Const>,
typename boost::proto::result_of::as_arg<A const>::type> > that_type;\
+ that_type that = {{*static_cast<Derived BOOST_PROTO_CONST ## Const
*>(this)}, boost::proto::as_arg(a)};\
return boost::proto::generate<Domain, that_type>::make(that);\
}\
- \
+ /**/
+
+ #define BOOST_PROTO_EXTENDS_ASSIGN_CONST(Expr, Derived, Domain)\
+ BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(Expr, Derived, Domain, 1)
+
+ #define BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST(Expr, Derived, Domain)\
+ BOOST_PROTO_EXTENDS_ASSIGN_IMPL_(Expr, Derived, Domain, 0)
+
+ #define BOOST_PROTO_EXTENDS_ASSIGN(Expr, Derived, Domain)\
+ BOOST_PROTO_EXTENDS_ASSIGN_CONST(Expr, Derived, Domain)\
+ BOOST_PROTO_EXTENDS_ASSIGN_NON_CONST(Expr, Derived, Domain)\
+ /**/
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(Expr, Derived, Domain, Const)\
template<typename A>\
- typename boost::proto::generate<Domain,
boost::proto::expr<boost::proto::tag::assign,
boost::proto::args2<boost::proto::ref_<Derived const>, typename
boost::proto::result_of::as_arg<A>::type> > >::type const\
- operator =(A &a) const\
+ typename boost::proto::generate<Domain,
boost::proto::expr<boost::proto::tag::subscript,
boost::proto::args2<boost::proto::ref_<Derived BOOST_PROTO_CONST ## Const>,
typename boost::proto::result_of::as_arg<A>::type> > >::type const\
+ operator [](A &a) BOOST_PROTO_CONST ## Const\
{\
- typedef boost::proto::expr<boost::proto::tag::assign,
boost::proto::args2<boost::proto::ref_<Derived const>, typename
boost::proto::result_of::as_arg<A>::type> > that_type;\
- that_type that = {{*static_cast<Derived const *>(this)},
boost::proto::as_arg(a)};\
+ typedef boost::proto::expr<boost::proto::tag::subscript,
boost::proto::args2<boost::proto::ref_<Derived BOOST_PROTO_CONST ## Const>,
typename boost::proto::result_of::as_arg<A>::type> > that_type;\
+ that_type that = {{*static_cast<Derived BOOST_PROTO_CONST ## Const
*>(this)}, boost::proto::as_arg(a)};\
return boost::proto::generate<Domain, that_type>::make(that);\
}\
\
template<typename A>\
- typename boost::proto::generate<Domain,
boost::proto::expr<boost::proto::tag::assign,
boost::proto::args2<boost::proto::ref_<Derived const>, typename
boost::proto::result_of::as_arg<A const>::type> > >::type const\
- operator =(A const &a) const\
+ typename boost::proto::generate<Domain,
boost::proto::expr<boost::proto::tag::subscript,
boost::proto::args2<boost::proto::ref_<Derived BOOST_PROTO_CONST ## Const>,
typename boost::proto::result_of::as_arg<A const>::type> > >::type const\
+ operator [](A const &a) BOOST_PROTO_CONST ## Const\
{\
- typedef boost::proto::expr<boost::proto::tag::assign,
boost::proto::args2<boost::proto::ref_<Derived const>, typename
boost::proto::result_of::as_arg<A const>::type> > that_type;\
- that_type that = {{*static_cast<Derived const *>(this)},
boost::proto::as_arg(a)};\
+ typedef boost::proto::expr<boost::proto::tag::subscript,
boost::proto::args2<boost::proto::ref_<Derived BOOST_PROTO_CONST ## Const>,
typename boost::proto::result_of::as_arg<A const>::type> > that_type;\
+ that_type that = {{*static_cast<Derived BOOST_PROTO_CONST ## Const
*>(this)}, boost::proto::as_arg(a)};\
return boost::proto::generate<Domain, that_type>::make(that);\
}\
/**/
+ #define BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST(Expr, Derived, Domain)\
+ BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(Expr, Derived, Domain, 1)
+
+ #define BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST(Expr, Derived, Domain)\
+ BOOST_PROTO_EXTENDS_SUBSCRIPT_IMPL_(Expr, Derived, Domain, 0)
+
#define BOOST_PROTO_EXTENDS_SUBSCRIPT(Expr, Derived, Domain)\
- template<typename A>\
- typename boost::proto::generate<Domain,
boost::proto::expr<boost::proto::tag::subscript,
boost::proto::args2<boost::proto::ref_<Derived >, typename
boost::proto::result_of::as_arg<A>::type> > >::type const\
- operator [](A &a)\
- {\
- typedef boost::proto::expr<boost::proto::tag::subscript,
boost::proto::args2<boost::proto::ref_<Derived >, typename
boost::proto::result_of::as_arg<A>::type> > that_type;\
- that_type that = {{*static_cast<Derived *>(this)},
boost::proto::as_arg(a)};\
- return boost::proto::generate<Domain, that_type>::make(that);\
- }\
- \
- template<typename A>\
- typename boost::proto::generate<Domain,
boost::proto::expr<boost::proto::tag::subscript,
boost::proto::args2<boost::proto::ref_<Derived >, typename
boost::proto::result_of::as_arg<A const>::type> > >::type const\
- operator [](A const &a)\
- {\
- typedef boost::proto::expr<boost::proto::tag::subscript,
boost::proto::args2<boost::proto::ref_<Derived >, typename
boost::proto::result_of::as_arg<A const>::type> > that_type;\
- that_type that = {{*static_cast<Derived *>(this)},
boost::proto::as_arg(a)};\
- return boost::proto::generate<Domain, that_type>::make(that);\
- }\
- \
- template<typename A>\
- typename boost::proto::generate<Domain,
boost::proto::expr<boost::proto::tag::subscript,
boost::proto::args2<boost::proto::ref_<Derived const>, typename
boost::proto::result_of::as_arg<A>::type> > >::type const\
- operator [](A &a) const\
- {\
- typedef boost::proto::expr<boost::proto::tag::subscript,
boost::proto::args2<boost::proto::ref_<Derived const>, typename
boost::proto::result_of::as_arg<A>::type> > that_type;\
- that_type that = {{*static_cast<Derived const *>(this)},
boost::proto::as_arg(a)};\
- return boost::proto::generate<Domain, that_type>::make(that);\
- }\
- \
- template<typename A>\
- typename boost::proto::generate<Domain,
boost::proto::expr<boost::proto::tag::subscript,
boost::proto::args2<boost::proto::ref_<Derived const>, typename
boost::proto::result_of::as_arg<A const>::type> > >::type const\
- operator [](A const &a) const\
- {\
- typedef boost::proto::expr<boost::proto::tag::subscript,
boost::proto::args2<boost::proto::ref_<Derived const>, typename
boost::proto::result_of::as_arg<A const>::type> > that_type;\
- that_type that = {{*static_cast<Derived const *>(this)},
boost::proto::as_arg(a)};\
- return boost::proto::generate<Domain, that_type>::make(that);\
- }\
+ BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST(Expr, Derived, Domain)\
+ BOOST_PROTO_EXTENDS_SUBSCRIPT_NON_CONST(Expr, Derived, Domain)\
/**/
/// INTERNAL ONLY
///
#define BOOST_PROTO_EXTENDS_FUNCTION_(Expr, Derived, Domain)\
template<typename Sig>\
- struct result {};\
- \
- template<typename This>\
- struct result<This()>\
+ struct result\
{\
- typedef typename boost::proto::generate<Domain,
boost::proto::expr<boost::proto::tag::function,
boost::proto::args1<boost::proto::ref_<Derived const> > > >::type type;\
+ typedef\
+ typename boost::proto::generate<Domain, typename
boost::proto::result_of::funop<Sig, Derived>::type>::type\
+ type;\
};\
- \
- typename boost::proto::generate<Domain,
boost::proto::expr<boost::proto::tag::function,
boost::proto::args1<boost::proto::ref_<Derived const> > > >::type const\
- operator ()() const\
- {\
- typedef boost::proto::expr<boost::proto::tag::function,
boost::proto::args1<boost::proto::ref_<Derived const> > > that_type;\
- that_type that = {{*static_cast<Derived const *>(this)}};\
- return boost::proto::generate<Domain, that_type>::make(that);\
- }\
+ /**/
+
+ #define BOOST_PROTO_EXTENDS_FUNCTION_CONST(Expr, Derived, Domain)\
+ BOOST_PROTO_EXTENDS_FUNCTION_(Expr, Derived, Domain)\
+ BOOST_PP_REPEAT_FROM_TO(0, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY),
BOOST_PROTO_DEFINE_FUN_OP_CONST, (Expr, Derived, Domain))\
+ /**/
+
+ #define BOOST_PROTO_EXTENDS_FUNCTION_NON_CONST(Expr, Derived, Domain)\
+ BOOST_PROTO_EXTENDS_FUNCTION_(Expr, Derived, Domain)\
+ BOOST_PP_REPEAT_FROM_TO(0, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY),
BOOST_PROTO_DEFINE_FUN_OP_NON_CONST, (Expr, Derived, Domain))\
/**/
#define BOOST_PROTO_EXTENDS_FUNCTION(Expr, Derived, Domain)\
BOOST_PROTO_EXTENDS_FUNCTION_(Expr, Derived, Domain)\
- BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY),
BOOST_PROTO_DEFINE_FUN_OP, (Expr, Derived, Domain))\
+ BOOST_PP_REPEAT_FROM_TO(0, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY),
BOOST_PROTO_DEFINE_FUN_OP, (Expr, Derived, Domain))\
/**/
/// \brief Empty type to be used as a dummy template parameter of
@@ -242,7 +248,7 @@
/// \brief extends\<\> class template for adding behaviors to a proto
expression template
///
- template<typename Expr, typename Derived, typename Domain>
+ template<typename Expr, typename Derived, typename Domain, typename Tag>
struct extends
{
extends()
@@ -258,6 +264,44 @@
{}
BOOST_PROTO_EXTENDS(Expr, Derived, Domain)
+ BOOST_PROTO_EXTENDS_ASSIGN_CONST(Expr, Derived, Domain)
+ BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST(Expr, Derived, Domain)
+
+ // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
+ // nested preprocessor loops, use file iteration here to generate
+ // the operator() overloads, which is more efficient.
+ BOOST_PROTO_EXTENDS_FUNCTION_(Expr, Derived, Domain)
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PP_LOCAL_MACRO(N) \
+ BOOST_PROTO_DEFINE_FUN_OP_CONST(1, N, (Expr, Derived, Domain))\
+ /**/
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PP_LOCAL_LIMITS (0, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY))
+ #include BOOST_PP_LOCAL_ITERATE()
+ };
+
+ /// \brief extends\<\> class template for adding behaviors to a proto
expression template
+ ///
+ template<typename Expr, typename Derived, typename Domain>
+ struct extends<Expr, Derived, Domain, tag::terminal>
+ {
+ extends()
+ : expr()
+ {}
+
+ extends(extends const &that)
+ : expr(that.expr)
+ {}
+
+ extends(Expr const &expr_)
+ : expr(expr_)
+ {}
+
+ BOOST_PROTO_EXTENDS(Expr, Derived, Domain)
BOOST_PROTO_EXTENDS_ASSIGN(Expr, Derived, Domain)
BOOST_PROTO_EXTENDS_SUBSCRIPT(Expr, Derived, Domain)
@@ -274,7 +318,7 @@
/// INTERNAL ONLY
///
- #define BOOST_PP_LOCAL_LIMITS (1, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY))
+ #define BOOST_PP_LOCAL_LIMITS (0, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY))
#include BOOST_PP_LOCAL_ITERATE()
};
Index: operators.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/operators.hpp,v
retrieving revision 1.28
retrieving revision 1.29
diff -u -d -r1.28 -r1.29
--- operators.hpp 30 Apr 2007 23:07:18 -0000 1.28
+++ operators.hpp 21 May 2007 03:21:33 -0000 1.29
@@ -158,8 +158,8 @@
BOOST_PROTO_UNARY_OP(++, tag::pre_inc)
BOOST_PROTO_UNARY_OP(--, tag::pre_dec)
- BOOST_PROTO_BINARY_OP(<<, tag::left_shift)
- BOOST_PROTO_BINARY_OP(>>, tag::right_shift)
+ BOOST_PROTO_BINARY_OP(<<, tag::shift_left)
+ BOOST_PROTO_BINARY_OP(>>, tag::shift_right)
BOOST_PROTO_BINARY_OP(*, tag::multiplies)
BOOST_PROTO_BINARY_OP(/, tag::divides)
BOOST_PROTO_BINARY_OP(%, tag::modulus)
@@ -179,8 +179,8 @@
BOOST_PROTO_BINARY_OP(BOOST_PP_COMMA(), tag::comma)
BOOST_PROTO_BINARY_OP(->*, tag::mem_ptr)
- BOOST_PROTO_BINARY_OP(<<=, tag::left_shift_assign)
- BOOST_PROTO_BINARY_OP(>>=, tag::right_shift_assign)
+ BOOST_PROTO_BINARY_OP(<<=, tag::shift_left_assign)
+ BOOST_PROTO_BINARY_OP(>>=, tag::shift_right_assign)
BOOST_PROTO_BINARY_OP(*=, tag::multilpies_assign)
BOOST_PROTO_BINARY_OP(/=, tag::divides_assign)
BOOST_PROTO_BINARY_OP(%=, tag::modulus_assign)
Index: proto_fwd.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/proto_fwd.hpp,v
retrieving revision 1.61
retrieving revision 1.62
diff -u -d -r1.61 -r1.62
--- proto_fwd.hpp 30 Apr 2007 23:07:18 -0000 1.61
+++ proto_fwd.hpp 21 May 2007 03:21:33 -0000 1.62
@@ -62,8 +62,8 @@
struct post_inc;
struct post_dec;
- struct left_shift;
- struct right_shift;
+ struct shift_left;
+ struct shift_right;
struct multiplies;
struct divides;
struct modulus;
@@ -84,8 +84,8 @@
struct mem_ptr;
struct assign;
- struct left_shift_assign;
- struct right_shift_assign;
+ struct shift_left_assign;
+ struct shift_right_assign;
struct multilpies_assign;
struct divides_assign;
struct modulus_assign;
@@ -197,7 +197,7 @@
typedef domain<> default_domain;
- template<typename Expr, typename Derived, typename Domain = default_domain>
+ template<typename Expr, typename Derived, typename Domain =
default_domain, typename Tag = typename Expr::tag_type>
struct extends;
struct default_context;
@@ -284,8 +284,8 @@
template<typename T> struct post_inc;
template<typename T> struct post_dec;
- template<typename T, typename U> struct left_shift;
- template<typename T, typename U> struct right_shift;
+ template<typename T, typename U> struct shift_left;
+ template<typename T, typename U> struct shift_right;
template<typename T, typename U> struct multiplies;
template<typename T, typename U> struct divides;
template<typename T, typename U> struct modulus;
@@ -306,8 +306,8 @@
template<typename T, typename U> struct mem_ptr;
template<typename T, typename U> struct assign;
- template<typename T, typename U> struct left_shift_assign;
- template<typename T, typename U> struct right_shift_assign;
+ template<typename T, typename U> struct shift_left_assign;
+ template<typename T, typename U> struct shift_right_assign;
template<typename T, typename U> struct multilpies_assign;
template<typename T, typename U> struct divides_assign;
template<typename T, typename U> struct modulus_assign;
Index: proto_typeof.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/proto_typeof.hpp,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -d -r1.13 -r1.14
--- proto_typeof.hpp 30 Apr 2007 23:07:18 -0000 1.13
+++ proto_typeof.hpp 21 May 2007 03:21:33 -0000 1.14
@@ -29,8 +29,8 @@
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::pre_dec)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::post_inc)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::post_dec)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::left_shift)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::right_shift)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::shift_left)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::shift_right)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::multiplies)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::divides)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::modulus)
@@ -50,8 +50,8 @@
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::comma)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::mem_ptr)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::assign)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::left_shift_assign)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::right_shift_assign)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::shift_left_assign)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::shift_right_assign)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::multilpies_assign)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::divides_assign)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::modulus_assign)
Index: tags.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/tags.hpp,v
retrieving revision 1.9
retrieving revision 1.10
diff -u -d -r1.9 -r1.10
--- tags.hpp 29 Apr 2007 22:03:43 -0000 1.9
+++ tags.hpp 21 May 2007 03:21:33 -0000 1.10
@@ -50,10 +50,10 @@
struct post_dec {};
/// Tag type for the binary \<\< operator.
- struct left_shift {};
+ struct shift_left {};
/// Tag type for the binary \>\> operator.
- struct right_shift {};
+ struct shift_right {};
/// Tag type for the binary * operator.
struct multiplies {};
@@ -113,10 +113,10 @@
struct assign {};
/// Tag type for the binary \<\<= operator.
- struct left_shift_assign {};
+ struct shift_left_assign {};
/// Tag type for the binary \>\>= operator.
- struct right_shift_assign {};
+ struct shift_right_assign {};
/// Tag type for the binary *= operator.
struct multilpies_assign {};
Index: traits.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/traits.hpp,v
retrieving revision 1.50
retrieving revision 1.51
diff -u -d -r1.50 -r1.51
--- traits.hpp 30 Apr 2007 23:07:18 -0000 1.50
+++ traits.hpp 21 May 2007 03:21:33 -0000 1.51
@@ -236,8 +236,8 @@
BOOST_PROTO_UNARY_GENERATOR(post_inc)
BOOST_PROTO_UNARY_GENERATOR(post_dec)
- BOOST_PROTO_BINARY_GENERATOR(left_shift)
- BOOST_PROTO_BINARY_GENERATOR(right_shift)
+ BOOST_PROTO_BINARY_GENERATOR(shift_left)
+ BOOST_PROTO_BINARY_GENERATOR(shift_right)
BOOST_PROTO_BINARY_GENERATOR(multiplies)
BOOST_PROTO_BINARY_GENERATOR(divides)
BOOST_PROTO_BINARY_GENERATOR(modulus)
@@ -258,8 +258,8 @@
BOOST_PROTO_BINARY_GENERATOR(mem_ptr)
BOOST_PROTO_BINARY_GENERATOR(assign)
- BOOST_PROTO_BINARY_GENERATOR(left_shift_assign)
- BOOST_PROTO_BINARY_GENERATOR(right_shift_assign)
+ BOOST_PROTO_BINARY_GENERATOR(shift_left_assign)
+ BOOST_PROTO_BINARY_GENERATOR(shift_right_assign)
BOOST_PROTO_BINARY_GENERATOR(multilpies_assign)
BOOST_PROTO_BINARY_GENERATOR(divides_assign)
BOOST_PROTO_BINARY_GENERATOR(modulus_assign)
-------------------------------------------------------------------------
This SF.net email is sponsored by DB2 Express
Download DB2 Express C - the FREE version of DB2 express and take
control of your XML. No limits. Just data. Click to get it now.
http://sourceforge.net/powerbar/db2/
_______________________________________________
Boost-cvs mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/boost-cvs
