Update of /cvsroot/boost/boost/boost/xpressive/proto
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv2719/proto
Modified Files:
make_expr.hpp operators.hpp proto_fwd.hpp traits.hpp
Log Message:
add BOOST_PROTO_DEFINE_OPERATORS, is_extension and the exops namespace, fix
BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE's handling of deduce_domain
Index: make_expr.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/make_expr.hpp,v
retrieving revision 1.23
retrieving revision 1.24
diff -u -d -r1.23 -r1.24
--- make_expr.hpp 23 Jun 2007 21:22:31 -0000 1.23
+++ make_expr.hpp 25 Jun 2007 05:39:40 -0000 1.24
@@ -20,6 +20,7 @@
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/iterate.hpp>
#include <boost/preprocessor/facilities/intercept.hpp>
+ #include <boost/preprocessor/comparison/greater.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/preprocessor/tuple/to_list.hpp>
#include <boost/preprocessor/logical/and.hpp>
@@ -167,41 +168,22 @@
/// INTERNAL ONLY
///
- #define BOOST_PROTO_VARARG_TYPE_YES_(R, DATA, I, ELEM)
\
- , typename boost::proto::result_of::as_expr<
\
- const BOOST_PP_SEQ_HEAD(ELEM)
\
- BOOST_PP_IF(
\
- BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM))
\
- , BOOST_PROTO_TEMPLATE_PARAMS_YES_
\
- , BOOST_PROTO_TEMPLATE_PARAMS_NO_
\
- )(R, DATA, I, ELEM)
\
- , DATA
\
- >::type
\
- /**/
-
- /// INTERNAL ONLY
- ///
- #define BOOST_PROTO_VARARG_TYPE_NO_(R, DATA, I, ELEM)
\
+ #define BOOST_PROTO_VARARG_TYPE_(R, DATA, I, ELEM)
\
+ BOOST_PP_COMMA_IF(I)
\
BOOST_PP_SEQ_HEAD(ELEM)
\
BOOST_PP_IF(
\
BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM))
\
, BOOST_PROTO_TEMPLATE_PARAMS_YES_
\
, BOOST_PROTO_TEMPLATE_PARAMS_NO_
\
- )(R, DATA, I, ELEM)
\
- /**/
-
- /// INTERNAL ONLY
- ///
- #define BOOST_PROTO_VARARG_TYPE_(R, DATA, I, ELEM)
\
- BOOST_PP_IF(I, BOOST_PROTO_VARARG_TYPE_YES_,
BOOST_PROTO_VARARG_TYPE_NO_)(R, DATA, I, ELEM) \
+ )(R, DATA, I, ELEM) BOOST_PP_EXPR_IF(BOOST_PP_GREATER(I, 1), const)
\
/**/
/// INTERNAL ONLY
///
#define BOOST_PROTO_VARARG_AS_EXPR_(R, DATA, I, ELEM)
\
BOOST_PP_EXPR_IF(
\
- I
\
- , (boost::proto::as_expr<DATA>(
\
+ BOOST_PP_GREATER(I, 1)
\
+ , ((
\
BOOST_PP_SEQ_HEAD(ELEM)
\
BOOST_PP_IF(
\
BOOST_PP_DEC(BOOST_PP_SEQ_SIZE(ELEM))
\
@@ -215,7 +197,7 @@
/// INTERNAL ONLY
///
#define BOOST_PROTO_VARARG_AS_ARG_(Z, N, DATA)
\
- (BOOST_PROTO_AS_ARG(Z, N, DATA))
\
+ (BOOST_PP_CAT(DATA, N))
\
/**/
/// INTERNAL ONLY
@@ -224,7 +206,6 @@
BOOST_PP_SEQ_POP_BACK(BOOST_PP_SEQ_PUSH_FRONT(BOOST_PP_SEQ_PUSH_BACK(SEQ,
_dummy_), ELEM)) \
/**/
-
/// INTERNAL ONLY
///
#define BOOST_PROTO_VARARG_AS_PARAM_(Z, N, DATA)
\
@@ -237,72 +218,60 @@
template<
\
BOOST_PP_SEQ_ENUM(
\
BOOST_PP_SEQ_FOR_EACH_I(
\
- BOOST_PROTO_VARARG_TEMPLATE_
\
- , ~
\
- , BOOST_PROTO_SEQ_PUSH_FRONT(
\
- BOOST_PP_TUPLE_ELEM(4, 2, DATA)
\
+ BOOST_PROTO_VARARG_TEMPLATE_, ~
\
+ , BOOST_PP_SEQ_PUSH_FRONT(
\
+ BOOST_PROTO_SEQ_PUSH_FRONT(
\
+ BOOST_PP_TUPLE_ELEM(4, 2, DATA)\
+ , (BOOST_PP_TUPLE_ELEM(4, 3, DATA))\
+ )
\
, BOOST_PP_TUPLE_ELEM(4, 1, DATA)
\
)
\
)
\
- BOOST_PP_REPEAT_ ## Z(
\
- N
\
- , BOOST_PROTO_VARARG_AS_PARAM_
\
- , typename A
\
- )
\
+ BOOST_PP_REPEAT_ ## Z(N, BOOST_PROTO_VARARG_AS_PARAM_,
typename A) \
)
\
>
\
- typename boost::mpl::apply_wrap1<
\
- BOOST_PP_TUPLE_ELEM(4, 3, DATA)
\
- , typename boost::proto::nary_expr<
\
- BOOST_PP_SEQ_FOR_EACH_I(
\
- BOOST_PROTO_VARARG_TYPE_
\
- , BOOST_PP_TUPLE_ELEM(4, 3, DATA)
\
- , BOOST_PROTO_SEQ_PUSH_FRONT(
\
+ typename boost::proto::result_of::make_expr<
\
+ BOOST_PP_SEQ_FOR_EACH_I(
\
+ BOOST_PROTO_VARARG_TYPE_, ~
\
+ , BOOST_PP_SEQ_PUSH_FRONT(
\
+ BOOST_PROTO_SEQ_PUSH_FRONT(
\
BOOST_PP_TUPLE_ELEM(4, 2, DATA)
\
- , BOOST_PP_TUPLE_ELEM(4, 1, DATA)
\
+ , (BOOST_PP_TUPLE_ELEM(4, 3, DATA))
\
)
\
+ , BOOST_PP_TUPLE_ELEM(4, 1, DATA)
\
)
\
- BOOST_PP_ENUM_TRAILING(
\
- N
\
- , BOOST_PROTO_AS_ARG_TYPE
\
- , (const A, BOOST_PP_TUPLE_ELEM(4, 3, DATA))
\
- )
\
- >::type
\
- >::type
\
+ )
\
+ BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
\
+ >::type const
\
BOOST_PP_TUPLE_ELEM(4, 0, DATA)(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N,
const A, &a)) \
{
\
- typename boost::proto::nary_expr<
\
+ return boost::proto::result_of::make_expr<
\
BOOST_PP_SEQ_FOR_EACH_I(
\
- BOOST_PROTO_VARARG_TYPE_
\
- , BOOST_PP_TUPLE_ELEM(4, 3, DATA)
\
- , BOOST_PROTO_SEQ_PUSH_FRONT(
\
- BOOST_PP_TUPLE_ELEM(4, 2, DATA)
\
+ BOOST_PROTO_VARARG_TYPE_, ~
\
+ , BOOST_PP_SEQ_PUSH_FRONT(
\
+ BOOST_PROTO_SEQ_PUSH_FRONT(
\
+ BOOST_PP_TUPLE_ELEM(4, 2, DATA)
\
+ , (BOOST_PP_TUPLE_ELEM(4, 3, DATA))
\
+ )
\
, BOOST_PP_TUPLE_ELEM(4, 1, DATA)
\
)
\
)
\
- BOOST_PP_ENUM_TRAILING(
\
- N
\
- , BOOST_PROTO_AS_ARG_TYPE
\
- , (const A, BOOST_PP_TUPLE_ELEM(4, 3, DATA))
\
- )
\
- >::type that = {
\
+ BOOST_PP_ENUM_TRAILING_PARAMS(N, const A)
\
+ >::call(
\
BOOST_PP_SEQ_ENUM(
\
BOOST_PP_SEQ_FOR_EACH_I(
\
- BOOST_PROTO_VARARG_AS_EXPR_
\
- , BOOST_PP_TUPLE_ELEM(4, 3, DATA)
\
- , BOOST_PROTO_SEQ_PUSH_FRONT(
\
- BOOST_PP_TUPLE_ELEM(4, 2, DATA)
\
+ BOOST_PROTO_VARARG_AS_EXPR_, ~
\
+ , BOOST_PP_SEQ_PUSH_FRONT(
\
+ BOOST_PROTO_SEQ_PUSH_FRONT(
\
+ BOOST_PP_TUPLE_ELEM(4, 2, DATA)
\
+ , (BOOST_PP_TUPLE_ELEM(4, 3, DATA))
\
+ )
\
, BOOST_PP_TUPLE_ELEM(4, 1, DATA)
\
)
\
)
\
- BOOST_PP_REPEAT_ ## Z(
\
- N
\
- , BOOST_PROTO_VARARG_AS_ARG_
\
- , (a, BOOST_PP_TUPLE_ELEM(4, 3, DATA))
\
- )
\
+ BOOST_PP_REPEAT_ ## Z(N, BOOST_PROTO_VARARG_AS_ARG_, a)
\
)
\
- };
\
- return BOOST_PP_TUPLE_ELEM(4, 3, DATA)::make(that);
\
+ );
\
}
\
/**/
Index: operators.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/operators.hpp,v
retrieving revision 1.33
retrieving revision 1.34
diff -u -d -r1.33 -r1.34
--- operators.hpp 23 Jun 2007 21:22:31 -0000 1.33
+++ operators.hpp 25 Jun 2007 05:39:40 -0000 1.34
@@ -102,133 +102,137 @@
return Left::proto_domain::make(that);
}
};
- } // detail
-#define BOOST_PROTO_UNARY_OP(op, tag)\
- template<typename Arg>\
- inline typename detail::generate_if<typename Arg::proto_domain, expr<tag,
args1<ref_<typename Arg::proto_derived_expr> > > >::type const\
- operator op(Arg &arg)\
- {\
- typedef expr<tag, args1<ref_<typename Arg::proto_derived_expr> > >
that_type;\
- that_type that = {{arg}};\
- return Arg::proto_domain::make(that);\
- }\
- template<typename Arg>\
- inline typename detail::generate_if<typename Arg::proto_domain, expr<tag,
args1<ref_<typename Arg::proto_derived_expr const> > > >::type const\
- operator op(Arg const &arg)\
- {\
- typedef expr<tag, args1<ref_<typename Arg::proto_derived_expr const> >
> that_type;\
- that_type that = {{arg}};\
- return Arg::proto_domain::make(that);\
- }\
- /**/
+ template<typename Arg, typename Trait, typename Enable = void>
+ struct arg_weight
+ {
+ BOOST_STATIC_CONSTANT(int, value = 1 + Trait::value);
+ };
-#define BOOST_PROTO_BINARY_OP(op, tag)\
- template<typename Left, typename Right>\
- inline typename detail::as_expr_if<tag, Left, Right>::type const\
- operator op(Left &left, Right &right)\
- {\
- return detail::as_expr_if<tag, Left, Right>::make(left, right);\
- }\
- template<typename Left, typename Right>\
- inline typename detail::as_expr_if<tag, Left, Right const>::type const\
- operator op(Left &left, Right const &right)\
- {\
- return detail::as_expr_if<tag, Left, Right const>::make(left, right);\
- }\
- template<typename Left, typename Right>\
- inline typename detail::as_expr_if<tag, Left const, Right>::type const\
- operator op(Left const &left, Right &right)\
- {\
- return detail::as_expr_if<tag, Left const, Right>::make(left, right);\
- }\
- template<typename Left, typename Right>\
- inline typename detail::as_expr_if<tag, Left const, Right const>::type
const\
- operator op(Left const &left, Right const &right)\
- {\
- return detail::as_expr_if<tag, Left const, Right const>::make(left,
right);\
- }\
- /**/
+ template<typename Arg, typename Trait>
+ struct arg_weight<Arg, Trait, typename Arg::proto_is_expr_>
+ {
+ BOOST_STATIC_CONSTANT(int, value = 0);
+ };
- BOOST_PROTO_UNARY_OP(+, tag::posit)
- BOOST_PROTO_UNARY_OP(-, tag::negate)
- BOOST_PROTO_UNARY_OP(*, tag::dereference)
- BOOST_PROTO_UNARY_OP(~, tag::complement)
- BOOST_PROTO_UNARY_OP(&, tag::address_of)
- BOOST_PROTO_UNARY_OP(!, tag::logical_not)
- BOOST_PROTO_UNARY_OP(++, tag::pre_inc)
- BOOST_PROTO_UNARY_OP(--, tag::pre_dec)
+ template<typename Domain, typename Trait, typename Arg, typename Expr>
+ struct enable_unary
+ : boost::enable_if<
+ boost::mpl::and_<Trait, boost::proto::matches<Expr, typename
Domain::grammar> >
+ , Expr
+ >
+ {};
- 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)
- BOOST_PROTO_BINARY_OP(+, tag::plus)
- BOOST_PROTO_BINARY_OP(-, tag::minus)
- BOOST_PROTO_BINARY_OP(<, tag::less)
- BOOST_PROTO_BINARY_OP(>, tag::greater)
- BOOST_PROTO_BINARY_OP(<=, tag::less_equal)
- BOOST_PROTO_BINARY_OP(>=, tag::greater_equal)
- BOOST_PROTO_BINARY_OP(==, tag::equal_to)
- BOOST_PROTO_BINARY_OP(!=, tag::not_equal_to)
- BOOST_PROTO_BINARY_OP(||, tag::logical_or)
- BOOST_PROTO_BINARY_OP(&&, tag::logical_and)
- BOOST_PROTO_BINARY_OP(&, tag::bitwise_and)
- BOOST_PROTO_BINARY_OP(|, tag::bitwise_or)
- BOOST_PROTO_BINARY_OP(^, tag::bitwise_xor)
- BOOST_PROTO_BINARY_OP(BOOST_PP_COMMA(), tag::comma)
- BOOST_PROTO_BINARY_OP(->*, tag::mem_ptr)
+ template<typename Domain, typename Trait1, typename Arg1, typename
Trait2, typename Arg2, typename Expr>
+ struct enable_binary
+ : boost::enable_if<
+ boost::mpl::and_<
+ mpl::bool_<(3 <= (arg_weight<Arg1, Trait1>::value +
arg_weight<Arg2, Trait2>::value))>
+ , boost::proto::matches<Expr, typename Domain::grammar>
+ >
+ , Expr
+ >
+ {};
- 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)
- BOOST_PROTO_BINARY_OP(+=, tag::plus_assign)
- BOOST_PROTO_BINARY_OP(-=, tag::minus_assign)
- BOOST_PROTO_BINARY_OP(&=, tag::bitwise_and_assign)
- BOOST_PROTO_BINARY_OP(|=, tag::bitwise_or_assign)
- BOOST_PROTO_BINARY_OP(^=, tag::bitwise_xor_assign)
+ } // detail
-#undef BOOST_PROTO_UNARY_OP
-#undef BOOST_PROTO_BINARY_OP
+#define BOOST_PROTO_UNARY_OP_IS_POSTFIX_0
+#define BOOST_PROTO_UNARY_OP_IS_POSTFIX_1 , int
- template<typename Arg>
- inline typename detail::generate_if<typename Arg::proto_domain,
expr<tag::post_inc, args1<ref_<typename Arg::proto_derived_expr> > > >::type
const
- operator ++(Arg &arg, int)
- {
- typedef expr<tag::post_inc, args1<ref_<typename
Arg::proto_derived_expr> > > that_type;
- that_type that = {{arg}};
- return Arg::proto_domain::make(that);
- }
+#define BOOST_PROTO_DEFINE_UNARY_OPERATOR(OP, TAG, POST)
\
+ template<typename Arg>
\
+ typename detail::generate_if<
\
+ typename Arg::proto_domain
\
+ , expr<TAG, args1<ref_<typename Arg::proto_derived_expr> > >
\
+ >::type const
\
+ operator OP(Arg &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST)
\
+ {
\
+ typedef expr<TAG, args1<ref_<typename Arg::proto_derived_expr> > >
that_type; \
+ that_type that = {{arg}};
\
+ return Arg::proto_domain::make(that);
\
+ }
\
+ template<typename Arg>
\
+ typename detail::generate_if<
\
+ typename Arg::proto_domain
\
+ , expr<TAG, args1<ref_<typename Arg::proto_derived_expr const> > >
\
+ >::type const
\
+ operator OP(Arg const &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST)
\
+ {
\
+ typedef expr<TAG, args1<ref_<typename Arg::proto_derived_expr const> >
> that_type; \
+ that_type that = {{arg}};
\
+ return Arg::proto_domain::make(that);
\
+ }
\
+ /**/
- template<typename Arg>
- inline typename detail::generate_if<typename Arg::proto_domain,
expr<tag::post_inc, args1<ref_<typename Arg::proto_derived_expr const> > >
>::type const
- operator ++(Arg const &arg, int)
- {
- typedef expr<tag::post_inc, args1<ref_<typename
Arg::proto_derived_expr const> > > that_type;
- that_type that = {{arg}};
- return Arg::proto_domain::make(that);
- }
+#define BOOST_PROTO_DEFINE_BINARY_OPERATOR(OP, TAG)
\
+ template<typename Left, typename Right>
\
+ inline typename detail::as_expr_if<TAG, Left, Right>::type const
\
+ operator OP(Left &left, Right &right)
\
+ {
\
+ return detail::as_expr_if<TAG, Left, Right>::make(left, right);
\
+ }
\
+ template<typename Left, typename Right>
\
+ inline typename detail::as_expr_if<TAG, Left, Right const>::type const
\
+ operator OP(Left &left, Right const &right)
\
+ {
\
+ return detail::as_expr_if<TAG, Left, Right const>::make(left, right);
\
+ }
\
+ template<typename Left, typename Right>
\
+ inline typename detail::as_expr_if<TAG, Left const, Right>::type const
\
+ operator OP(Left const &left, Right &right)
\
+ {
\
+ return detail::as_expr_if<TAG, Left const, Right>::make(left, right);
\
+ }
\
+ template<typename Left, typename Right>
\
+ inline typename detail::as_expr_if<TAG, Left const, Right const>::type
const \
+ operator OP(Left const &left, Right const &right)
\
+ {
\
+ return detail::as_expr_if<TAG, Left const, Right const>::make(left,
right); \
+ }
\
+ /**/
- template<typename Arg>
- inline typename detail::generate_if<typename Arg::proto_domain,
expr<tag::post_dec, args1<ref_<typename Arg::proto_derived_expr> > > >::type
const
- operator --(Arg &arg, int)
- {
- typedef expr<tag::post_dec, args1<ref_<typename
Arg::proto_derived_expr> > > that_type;
- that_type that = {{arg}};
- return Arg::proto_domain::make(that);
- }
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(+, tag::posit, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(-, tag::negate, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(*, tag::dereference, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(~, tag::complement, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(&, tag::address_of, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(!, tag::logical_not, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, tag::pre_inc, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, tag::pre_dec, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, tag::post_inc, 1)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, tag::post_dec, 1)
- template<typename Arg>
- inline typename detail::generate_if<typename Arg::proto_domain,
expr<tag::post_dec, args1<ref_<typename Arg::proto_derived_expr const> > >
>::type const
- operator --(Arg const &arg, int)
- {
- typedef expr<tag::post_dec, args1<ref_<typename
Arg::proto_derived_expr const> > > that_type;
- that_type that = {{arg}};
- return Arg::proto_domain::make(that);
- }
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<, tag::shift_left)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>, tag::shift_right)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(*, tag::multiplies)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(/, tag::divides)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(%, tag::modulus)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(+, tag::plus)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(-, tag::minus)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<, tag::less)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>, tag::greater)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<=, tag::less_equal)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>=, tag::greater_equal)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(==, tag::equal_to)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(!=, tag::not_equal_to)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(||, tag::logical_or)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&&, tag::logical_and)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&, tag::bitwise_and)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(|, tag::bitwise_or)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(^, tag::bitwise_xor)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(BOOST_PP_COMMA(), tag::comma)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(->*, tag::mem_ptr)
+
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<=, tag::shift_left_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>=, tag::shift_right_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(*=, tag::multilpies_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(/=, tag::divides_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(%=, tag::modulus_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(+=, tag::plus_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(-=, tag::minus_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&=, tag::bitwise_and_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(|=, tag::bitwise_or_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(^=, tag::bitwise_xor_assign)
/// if_else
///
@@ -240,6 +244,120 @@
, BOOST_PP_SEQ_NIL
)
+#undef BOOST_PROTO_DEFINE_UNARY_OPERATOR
+#undef BOOST_PROTO_DEFINE_BINARY_OPERATOR
+
+#define BOOST_PROTO_DEFINE_UNARY_OPERATOR(OP, TAG, TRAIT, DOMAIN, POST)
\
+ template<typename Arg>
\
+ typename boost::proto::detail::enable_unary<DOMAIN, TRAIT<Arg>, Arg
\
+ , typename boost::proto::result_of::make_expr<TAG, DOMAIN, Arg>::type
\
+ >::type const
\
+ operator OP(Arg &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST)
\
+ {
\
+ return boost::proto::result_of::make_expr<TAG, DOMAIN,
Arg>::call(arg); \
+ }
\
+ template<typename Arg>
\
+ typename boost::proto::detail::enable_unary<DOMAIN, TRAIT<Arg>, Arg
\
+ , typename boost::proto::result_of::make_expr<TAG, DOMAIN, Arg
const>::type \
+ >::type const
\
+ operator OP(Arg const &arg BOOST_PROTO_UNARY_OP_IS_POSTFIX_ ## POST)
\
+ {
\
+ return boost::proto::result_of::make_expr<TAG, DOMAIN, Arg
const>::call(arg); \
+ }
\
+ /**/
+
+#define BOOST_PROTO_DEFINE_BINARY_OPERATOR(OP, TAG, TRAIT, DOMAIN)
\
+ template<typename Left, typename Right>
\
+ typename boost::proto::detail::enable_binary<DOMAIN, TRAIT<Left>, Left,
TRAIT<Right>, Right \
+ , typename boost::proto::result_of::make_expr<TAG, DOMAIN, Left,
Right>::type \
+ >::type const
\
+ operator OP(Left &left, Right &right)
\
+ {
\
+ return boost::proto::result_of::make_expr<TAG, DOMAIN, Left, Right>
\
+ ::call(left, right);
\
+ }
\
+ template<typename Left, typename Right>
\
+ typename boost::proto::detail::enable_binary<DOMAIN, TRAIT<Left>, Left,
TRAIT<Right>, Right \
+ , typename boost::proto::result_of::make_expr<TAG, DOMAIN, Left, Right
const>::type \
+ >::type const
\
+ operator OP(Left &left, Right const &right)
\
+ {
\
+ return boost::proto::result_of::make_expr<TAG, DOMAIN, Left, Right
const> \
+ ::call(left, right);
\
+ }
\
+ template<typename Left, typename Right>
\
+ typename boost::proto::detail::enable_binary<DOMAIN, TRAIT<Left>, Left,
TRAIT<Right>, Right \
+ , typename boost::proto::result_of::make_expr<TAG, DOMAIN, Left const,
Right>::type \
+ >::type const
\
+ operator OP(Left const &left, Right &right)
\
+ {
\
+ return boost::proto::result_of::make_expr<TAG, DOMAIN, Left const,
Right> \
+ ::call(left, right);
\
+ }
\
+ template<typename Left, typename Right>
\
+ typename boost::proto::detail::enable_binary<DOMAIN, TRAIT<Left>, Left,
TRAIT<Right>, Right \
+ , typename boost::proto::result_of::make_expr<TAG, DOMAIN, Left const,
Right const>::type \
+ >::type const
\
+ operator OP(Left const &left, Right const &right)
\
+ {
\
+ return boost::proto::result_of::make_expr<TAG, DOMAIN, Left const,
Right const> \
+ ::call(left, right);
\
+ }
\
+ /**/
+
+#define BOOST_PROTO_DEFINE_OPERATORS(TRAIT, DOMAIN)
\
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(+, boost::proto::tag::posit, TRAIT,
DOMAIN, 0) \
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(-, boost::proto::tag::negate, TRAIT,
DOMAIN, 0) \
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(*, boost::proto::tag::dereference,
TRAIT, DOMAIN, 0) \
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(~, boost::proto::tag::complement, TRAIT,
DOMAIN, 0) \
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(&, boost::proto::tag::address_of, TRAIT,
DOMAIN, 0) \
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(!, boost::proto::tag::logical_not,
TRAIT, DOMAIN, 0) \
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, boost::proto::tag::pre_inc, TRAIT,
DOMAIN, 0) \
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, boost::proto::tag::pre_dec, TRAIT,
DOMAIN, 0) \
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, boost::proto::tag::post_inc, TRAIT,
DOMAIN, 1) \
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, boost::proto::tag::post_dec, TRAIT,
DOMAIN, 1) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<, boost::proto::tag::shift_left,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>, boost::proto::tag::shift_right,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(*, boost::proto::tag::multiplies,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(/, boost::proto::tag::divides, TRAIT,
DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(%, boost::proto::tag::modulus, TRAIT,
DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(+, boost::proto::tag::plus, TRAIT,
DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(-, boost::proto::tag::minus, TRAIT,
DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<, boost::proto::tag::less, TRAIT,
DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>, boost::proto::tag::greater, TRAIT,
DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<=, boost::proto::tag::less_equal,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>=, boost::proto::tag::greater_equal,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(==, boost::proto::tag::equal_to, TRAIT,
DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(!=, boost::proto::tag::not_equal_to,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(||, boost::proto::tag::logical_or,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&&, boost::proto::tag::logical_and,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&, boost::proto::tag::bitwise_and,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(|, boost::proto::tag::bitwise_or,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(^, boost::proto::tag::bitwise_xor,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(BOOST_PP_COMMA(),
boost::proto::tag::comma, TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(->*, boost::proto::tag::mem_ptr, TRAIT,
DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<=,
boost::proto::tag::shift_left_assign, TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>=,
boost::proto::tag::shift_right_assign, TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(*=,
boost::proto::tag::multilpies_assign, TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(/=, boost::proto::tag::divides_assign,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(%=, boost::proto::tag::modulus_assign,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(+=, boost::proto::tag::plus_assign,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(-=, boost::proto::tag::minus_assign,
TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&=,
boost::proto::tag::bitwise_and_assign, TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(|=,
boost::proto::tag::bitwise_or_assign, TRAIT, DOMAIN) \
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(^=,
boost::proto::tag::bitwise_xor_assign, TRAIT, DOMAIN) \
+ /**/
+
+ template<typename T>
+ struct is_extension
+ : mpl::false_
+ {};
+
+ namespace exops
+ {
+ BOOST_PROTO_DEFINE_OPERATORS(is_extension, deduce_domain)
+ using proto::if_else;
+ }
}}
#endif
Index: proto_fwd.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/proto_fwd.hpp,v
retrieving revision 1.78
retrieving revision 1.79
diff -u -d -r1.78 -r1.79
--- proto_fwd.hpp 23 Jun 2007 21:22:31 -0000 1.78
+++ proto_fwd.hpp 25 Jun 2007 05:39:40 -0000 1.79
@@ -464,6 +464,12 @@
int const N = INT_MAX;
+ template<typename T>
+ struct is_extension;
+
+ namespace exops
+ {}
+
}} // namespace boost::proto
#endif
Index: traits.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/traits.hpp,v
retrieving revision 1.60
retrieving revision 1.61
diff -u -d -r1.60 -r1.61
--- traits.hpp 23 Jun 2007 21:22:31 -0000 1.60
+++ traits.hpp 25 Jun 2007 05:39:40 -0000 1.61
@@ -312,6 +312,10 @@
typedef BOOST_PP_CAT(data, n) BOOST_PP_CAT(proto_arg, n);\
/**/
+ #define BOOST_PROTO_IMPLICIT_ARG(z, n, data)\
+ BOOST_PP_CAT(data, n) &BOOST_PP_CAT(a, n);\
+ /**/
+
#define BOOST_PROTO_ARG_N_TYPE(z, n, data)\
typename proto::result_of::unref<\
typename Expr::BOOST_PP_CAT(proto_arg, n)\
@@ -323,6 +327,7 @@
#undef BOOST_PROTO_ARG
#undef BOOST_PROTO_ARG_N_TYPE
+ #undef BOOST_PROTO_IMPLICIT_ARG
namespace functional
{
@@ -669,6 +674,33 @@
BOOST_PP_REPEAT(N, BOOST_PROTO_ARG, A)
BOOST_PP_REPEAT_FROM_TO(N, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_ARG,
detail::if_vararg<BOOST_PP_CAT(A, BOOST_PP_DEC(N))> BOOST_PP_INTERCEPT)
};
+
+
+ namespace detail
+ {
+ template<BOOST_PP_ENUM_PARAMS(N, typename A)>
+ struct BOOST_PP_CAT(implicit_expr_, N)
+ {
+ BOOST_PP_REPEAT(N, BOOST_PROTO_IMPLICIT_ARG, A)
+
+ template<typename Tag, typename Args, long Arity>
+ operator expr<Tag, Args, Arity> () const
+ {
+ expr<Tag, Args, Arity> that = {BOOST_PP_ENUM_PARAMS(N, a)};
+ return that;
+ }
+ };
+ }
+
+ template<BOOST_PP_ENUM_PARAMS(N, typename A)>
+ detail::BOOST_PP_CAT(implicit_expr_, N)<BOOST_PP_ENUM_PARAMS(N, A)>
+ implicit_expr(BOOST_PP_ENUM_BINARY_PARAMS(N, A, &a))
+ {
+ detail::BOOST_PP_CAT(implicit_expr_, N)<BOOST_PP_ENUM_PARAMS(N,
A)> that
+ = {BOOST_PP_ENUM_PARAMS(N, a)};
+ return that;
+ }
+
#endif
namespace result_of
@@ -694,6 +726,7 @@
{};
}
+
#undef N
#endif
-------------------------------------------------------------------------
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
