Update of /cvsroot/boost/boost/boost/xpressive/proto
In directory
sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv14120/boost/xpressive/proto
Modified Files:
deep_copy.hpp expr.hpp extends.hpp matches.hpp operators.hpp
proto_fwd.hpp proto_typeof.hpp ref.hpp tags.hpp traits.hpp
Log Message:
rename all proto tag types, move into tag:: namespace
Index: deep_copy.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/deep_copy.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- deep_copy.hpp 1 Dec 2006 02:58:48 -0000 1.3
+++ deep_copy.hpp 1 Dec 2006 05:46:05 -0000 1.4
@@ -25,7 +25,7 @@
struct deep_copy_impl;
template<typename Expr>
- struct deep_copy_impl<Expr, terminal_tag, 1>
+ struct deep_copy_impl<Expr, tag::terminal, 1>
{
typedef typename Expr::expr_type type;
Index: expr.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/expr.hpp,v
retrieving revision 1.4
retrieving revision 1.5
diff -u -d -r1.4 -r1.5
--- expr.hpp 1 Dec 2006 02:58:48 -0000 1.4
+++ expr.hpp 1 Dec 2006 05:46:06 -0000 1.5
@@ -90,18 +90,18 @@
}
template<typename A>
- expr<assign_tag, args2<ref<expr>, typename
meta::as_expr_ref<A>::type> > const
+ expr<tag::assign, args2<ref<expr>, typename
meta::as_expr_ref<A>::type> > const
operator =(A const &a) const
{
- expr<assign_tag, args2<ref<expr>, typename
meta::as_expr_ref<A>::type> > that = {{*this}, proto::as_expr_ref(a)};
+ expr<tag::assign, args2<ref<expr>, typename
meta::as_expr_ref<A>::type> > that = {{*this}, proto::as_expr_ref(a)};
return that;
}
template<typename A>
- expr<subscript_tag, args2<ref<expr>, typename
meta::as_expr_ref<A>::type> > const
+ expr<tag::subscript, args2<ref<expr>, typename
meta::as_expr_ref<A>::type> > const
operator [](A const &a) const
{
- expr<subscript_tag, args2<ref<expr>, typename
meta::as_expr_ref<A>::type> > that = {{*this}, proto::as_expr_ref(a)};
+ expr<tag::subscript, args2<ref<expr>, typename
meta::as_expr_ref<A>::type> > that = {{*this}, proto::as_expr_ref(a)};
return that;
}
@@ -111,13 +111,13 @@
template<typename This>
struct result<This()>
{
- typedef expr<function_tag, args1<ref<expr> > > type;
+ typedef expr<tag::function, args1<ref<expr> > > type;
};
- expr<function_tag, args1<ref<expr> > > const
+ expr<tag::function, args1<ref<expr> > > const
operator ()() const
{
- expr<function_tag, args1<ref<expr> > > that = {{*this}};
+ expr<tag::function, args1<ref<expr> > > that = {{*this}};
return that;
}
@@ -133,14 +133,14 @@
template<typename This BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
struct result<This(BOOST_PP_ENUM_PARAMS(N, A))>
{
- typedef expr<function_tag, BOOST_PP_CAT(args,
BOOST_PP_INC(N))<ref<expr> BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, typename
meta::as_expr_ref<A, >::type BOOST_PP_INTERCEPT)> > type;
+ typedef expr<tag::function, BOOST_PP_CAT(args,
BOOST_PP_INC(N))<ref<expr> BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, typename
meta::as_expr_ref<A, >::type BOOST_PP_INTERCEPT)> > type;
};
template<BOOST_PP_ENUM_PARAMS(N, typename A)>
- expr<function_tag, BOOST_PP_CAT(args, BOOST_PP_INC(N))<ref<expr>
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, typename meta::as_expr_ref<A, >::type
BOOST_PP_INTERCEPT)> > const
+ expr<tag::function, BOOST_PP_CAT(args, BOOST_PP_INC(N))<ref<expr>
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, typename meta::as_expr_ref<A, >::type
BOOST_PP_INTERCEPT)> > const
operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, const &a)) const
{
- expr<function_tag, BOOST_PP_CAT(args, BOOST_PP_INC(N))<ref<expr>
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, typename meta::as_expr_ref<A, >::type
BOOST_PP_INTERCEPT)> > that = {{*this} BOOST_PP_ENUM_TRAILING(N,
BOOST_PROTO_AS_OP, _)};
+ expr<tag::function, BOOST_PP_CAT(args, BOOST_PP_INC(N))<ref<expr>
BOOST_PP_ENUM_TRAILING_BINARY_PARAMS(N, typename meta::as_expr_ref<A, >::type
BOOST_PP_INTERCEPT)> > that = {{*this} BOOST_PP_ENUM_TRAILING(N,
BOOST_PROTO_AS_OP, _)};
return that;
}
Index: extends.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/extends.hpp,v
retrieving revision 1.6
retrieving revision 1.7
diff -u -d -r1.6 -r1.7
--- extends.hpp 1 Dec 2006 02:58:48 -0000 1.6
+++ extends.hpp 1 Dec 2006 05:46:06 -0000 1.7
@@ -49,37 +49,37 @@
}\
/**/
- BOOST_PROTO_EXTENDS_BINARY_OP(<<, left_shift_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(>>, right_shift_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(*, multiply_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(/, divide_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(%, modulus_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(+, add_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(-, subtract_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(<, less_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(>, greater_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(<=, less_equal_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(>=, greater_equal_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(==, equal_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(!=, not_equal_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(||, logical_or_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(&&, logical_and_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(&, bitwise_and_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(|, bitwise_or_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(^, bitwise_xor_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(BOOST_PP_COMMA(), comma_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(->*, mem_ptr_tag)
+ BOOST_PROTO_EXTENDS_BINARY_OP(<<, tag::left_shift)
+ BOOST_PROTO_EXTENDS_BINARY_OP(>>, tag::right_shift)
+ BOOST_PROTO_EXTENDS_BINARY_OP(*, tag::multiply)
+ BOOST_PROTO_EXTENDS_BINARY_OP(/, tag::divide)
+ BOOST_PROTO_EXTENDS_BINARY_OP(%, tag::modulus)
+ BOOST_PROTO_EXTENDS_BINARY_OP(+, tag::add)
+ BOOST_PROTO_EXTENDS_BINARY_OP(-, tag::subtract)
+ BOOST_PROTO_EXTENDS_BINARY_OP(<, tag::less)
+ BOOST_PROTO_EXTENDS_BINARY_OP(>, tag::greater)
+ BOOST_PROTO_EXTENDS_BINARY_OP(<=, tag::less_equal)
+ BOOST_PROTO_EXTENDS_BINARY_OP(>=, tag::greater_equal)
+ BOOST_PROTO_EXTENDS_BINARY_OP(==, tag::equal)
+ BOOST_PROTO_EXTENDS_BINARY_OP(!=, tag::not_equal)
+ BOOST_PROTO_EXTENDS_BINARY_OP(||, tag::logical_or)
+ BOOST_PROTO_EXTENDS_BINARY_OP(&&, tag::logical_and)
+ BOOST_PROTO_EXTENDS_BINARY_OP(&, tag::bitwise_and)
+ BOOST_PROTO_EXTENDS_BINARY_OP(|, tag::bitwise_or)
+ BOOST_PROTO_EXTENDS_BINARY_OP(^, tag::bitwise_xor)
+ BOOST_PROTO_EXTENDS_BINARY_OP(BOOST_PP_COMMA(), tag::comma)
+ BOOST_PROTO_EXTENDS_BINARY_OP(->*, tag::mem_ptr)
- BOOST_PROTO_EXTENDS_BINARY_OP(<<=, left_shift_assign_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(>>=, right_shift_assign_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(*=, multiply_assign_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(/=, divide_assign_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(%=, modulus_assign_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(+=, add_assign_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(-=, subtract_assign_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(&=, bitwise_and_assign_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(|=, bitwise_or_assign_tag)
- BOOST_PROTO_EXTENDS_BINARY_OP(^=, bitwise_xor_assign_tag)
+ BOOST_PROTO_EXTENDS_BINARY_OP(<<=, tag::left_shift_assign)
+ BOOST_PROTO_EXTENDS_BINARY_OP(>>=, tag::right_shift_assign)
+ BOOST_PROTO_EXTENDS_BINARY_OP(*=, tag::multiply_assign)
+ BOOST_PROTO_EXTENDS_BINARY_OP(/=, tag::divide_assign)
+ BOOST_PROTO_EXTENDS_BINARY_OP(%=, tag::modulus_assign)
+ BOOST_PROTO_EXTENDS_BINARY_OP(+=, tag::add_assign)
+ BOOST_PROTO_EXTENDS_BINARY_OP(-=, tag::subtract_assign)
+ BOOST_PROTO_EXTENDS_BINARY_OP(&=, tag::bitwise_and_assign)
+ BOOST_PROTO_EXTENDS_BINARY_OP(|=, tag::bitwise_or_assign)
+ BOOST_PROTO_EXTENDS_BINARY_OP(^=, tag::bitwise_xor_assign)
#undef BOOST_PROTO_EXTENDS_BINARY_OP
Index: matches.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/matches.hpp,v
retrieving revision 1.15
retrieving revision 1.16
diff -u -d -r1.15 -r1.16
--- matches.hpp 20 Nov 2006 03:41:07 -0000 1.15
+++ matches.hpp 1 Dec 2006 05:46:06 -0000 1.16
@@ -157,7 +157,7 @@
{};
template<typename Args1, typename Args2>
- struct matches_impl< expr<terminal_tag, Args1, 1>,
expr<terminal_tag, Args2, 1> >
+ struct matches_impl< expr<tag::terminal, Args1, 1>,
expr<tag::terminal, Args2, 1> >
: terminal_matches<
typename Args1::arg0
, typename Args2::arg0
Index: operators.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/operators.hpp,v
retrieving revision 1.13
retrieving revision 1.14
diff -u -d -r1.13 -r1.14
--- operators.hpp 1 Dec 2006 02:58:48 -0000 1.13
+++ operators.hpp 1 Dec 2006 05:46:06 -0000 1.14
@@ -53,60 +53,60 @@
}\
/**/
- BOOST_PROTO_UNARY_OP(+, unary_plus_tag)
- BOOST_PROTO_UNARY_OP(-, unary_minus_tag)
- BOOST_PROTO_UNARY_OP(*, unary_star_tag)
- BOOST_PROTO_UNARY_OP(~, complement_tag)
- BOOST_PROTO_UNARY_OP(&, address_of_tag)
- BOOST_PROTO_UNARY_OP(!, logical_not_tag)
- BOOST_PROTO_UNARY_OP(++, pre_inc_tag)
- BOOST_PROTO_UNARY_OP(--, pre_dec_tag)
+ BOOST_PROTO_UNARY_OP(+, tag::unary_plus)
+ BOOST_PROTO_UNARY_OP(-, tag::unary_minus)
+ BOOST_PROTO_UNARY_OP(*, tag::unary_star)
+ 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)
- BOOST_PROTO_BINARY_OP(<<, left_shift_tag)
- BOOST_PROTO_BINARY_OP(>>, right_shift_tag)
- BOOST_PROTO_BINARY_OP(*, multiply_tag)
- BOOST_PROTO_BINARY_OP(/, divide_tag)
- BOOST_PROTO_BINARY_OP(%, modulus_tag)
- BOOST_PROTO_BINARY_OP(+, add_tag)
- BOOST_PROTO_BINARY_OP(-, subtract_tag)
- BOOST_PROTO_BINARY_OP(<, less_tag)
- BOOST_PROTO_BINARY_OP(>, greater_tag)
- BOOST_PROTO_BINARY_OP(<=, less_equal_tag)
- BOOST_PROTO_BINARY_OP(>=, greater_equal_tag)
- BOOST_PROTO_BINARY_OP(==, equal_tag)
- BOOST_PROTO_BINARY_OP(!=, not_equal_tag)
- BOOST_PROTO_BINARY_OP(||, logical_or_tag)
- BOOST_PROTO_BINARY_OP(&&, logical_and_tag)
- BOOST_PROTO_BINARY_OP(&, bitwise_and_tag)
- BOOST_PROTO_BINARY_OP(|, bitwise_or_tag)
- BOOST_PROTO_BINARY_OP(^, bitwise_xor_tag)
- BOOST_PROTO_BINARY_OP(BOOST_PP_COMMA(), comma_tag)
- BOOST_PROTO_BINARY_OP(->*, mem_ptr_tag)
+ BOOST_PROTO_BINARY_OP(<<, tag::left_shift)
+ BOOST_PROTO_BINARY_OP(>>, tag::right_shift)
+ BOOST_PROTO_BINARY_OP(*, tag::multiply)
+ BOOST_PROTO_BINARY_OP(/, tag::divide)
+ BOOST_PROTO_BINARY_OP(%, tag::modulus)
+ BOOST_PROTO_BINARY_OP(+, tag::add)
+ BOOST_PROTO_BINARY_OP(-, tag::subtract)
+ 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)
+ BOOST_PROTO_BINARY_OP(!=, tag::not_equal)
+ 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)
- BOOST_PROTO_BINARY_OP(<<=, left_shift_assign_tag)
- BOOST_PROTO_BINARY_OP(>>=, right_shift_assign_tag)
- BOOST_PROTO_BINARY_OP(*=, multiply_assign_tag)
- BOOST_PROTO_BINARY_OP(/=, divide_assign_tag)
- BOOST_PROTO_BINARY_OP(%=, modulus_assign_tag)
- BOOST_PROTO_BINARY_OP(+=, add_assign_tag)
- BOOST_PROTO_BINARY_OP(-=, subtract_assign_tag)
- BOOST_PROTO_BINARY_OP(&=, bitwise_and_assign_tag)
- BOOST_PROTO_BINARY_OP(|=, bitwise_or_assign_tag)
- BOOST_PROTO_BINARY_OP(^=, bitwise_xor_assign_tag)
+ BOOST_PROTO_BINARY_OP(<<=, tag::left_shift_assign)
+ BOOST_PROTO_BINARY_OP(>>=, tag::right_shift_assign)
+ BOOST_PROTO_BINARY_OP(*=, tag::multiply_assign)
+ BOOST_PROTO_BINARY_OP(/=, tag::divide_assign)
+ BOOST_PROTO_BINARY_OP(%=, tag::modulus_assign)
+ BOOST_PROTO_BINARY_OP(+=, tag::add_assign)
+ BOOST_PROTO_BINARY_OP(-=, tag::subtract_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)
template<typename Tag, typename Args, long Arity>
- inline expr<post_inc_tag, args1<ref<expr<Tag, Args, Arity> > > > const
+ inline expr<tag::post_inc, args1<ref<expr<Tag, Args, Arity> > > > const
operator ++(expr<Tag, Args, Arity> const &arg, int)
{
- expr<post_inc_tag, args1<ref<expr<Tag, Args, Arity> > > > that =
{{arg}};
+ expr<tag::post_inc, args1<ref<expr<Tag, Args, Arity> > > > that =
{{arg}};
return that;
}
template<typename Tag, typename Args, long Arity>
- inline expr<post_dec_tag, args1<ref<expr<Tag, Args, Arity> > > > const
+ inline expr<tag::post_dec, args1<ref<expr<Tag, Args, Arity> > > > const
operator --(expr<Tag, Args, Arity> const &arg, int)
{
- expr<post_dec_tag, args1<ref<expr<Tag, Args, Arity> > > > that =
{{arg}};
+ expr<tag::post_dec, args1<ref<expr<Tag, Args, Arity> > > > that =
{{arg}};
return that;
}
Index: proto_fwd.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/proto_fwd.hpp,v
retrieving revision 1.32
retrieving revision 1.33
diff -u -d -r1.32 -r1.33
--- proto_fwd.hpp 1 Dec 2006 02:58:48 -0000 1.32
+++ proto_fwd.hpp 1 Dec 2006 05:46:06 -0000 1.33
@@ -9,11 +9,8 @@
#ifndef BOOST_PROTO_FWD_HPP_EAN_04_01_2005
#define BOOST_PROTO_FWD_HPP_EAN_04_01_2005
-#include <boost/version.hpp>
-#include <boost/mpl/size.hpp>
#include <boost/type_traits/remove_cv.hpp>
#include <boost/type_traits/remove_reference.hpp>
-#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/mpl/long.hpp>
#include <boost/preprocessor/arithmetic/sub.hpp>
#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
@@ -26,59 +23,109 @@
{
///////////////////////////////////////////////////////////////////////////////
// Operator tags
- struct unary_tag;
- struct binary_tag;
- struct nary_tag;
+ namespace tag
+ {
+ struct unary;
+ struct binary;
+ struct nary;
- struct terminal_tag;
- struct unary_plus_tag;
- struct unary_minus_tag;
- struct unary_star_tag;
- struct complement_tag;
- struct address_of_tag;
- struct logical_not_tag;
- struct pre_inc_tag;
- struct pre_dec_tag;
- struct post_inc_tag;
- struct post_dec_tag;
+ struct terminal;
+ struct unary_plus;
+ struct unary_minus;
+ struct unary_star;
+ struct complement;
+ struct address_of;
+ struct logical_not;
+ struct pre_inc;
+ struct pre_dec;
+ struct post_inc;
+ struct post_dec;
- struct left_shift_tag;
- struct right_shift_tag;
- struct multiply_tag;
- struct divide_tag;
- struct modulus_tag;
- struct add_tag;
- struct subtract_tag;
- struct less_tag;
- struct greater_tag;
- struct less_equal_tag;
- struct greater_equal_tag;
- struct equal_tag;
- struct not_equal_tag;
- struct logical_or_tag;
- struct logical_and_tag;
- struct bitwise_and_tag;
- struct bitwise_or_tag;
- struct bitwise_xor_tag;
- struct comma_tag;
- struct mem_ptr_tag;
+ struct left_shift;
+ struct right_shift;
+ struct multiply;
+ struct divide;
+ struct modulus;
+ struct add;
+ struct subtract;
+ struct less;
+ struct greater;
+ struct less_equal;
+ struct greater_equal;
+ struct equal;
+ struct not_equal;
+ struct logical_or;
+ struct logical_and;
+ struct bitwise_and;
+ struct bitwise_or;
+ struct bitwise_xor;
+ struct comma;
+ struct mem_ptr;
- struct assign_tag;
- struct left_shift_assign_tag;
- struct right_shift_assign_tag;
- struct multiply_assign_tag;
- struct divide_assign_tag;
- struct modulus_assign_tag;
- struct add_assign_tag;
- struct subtract_assign_tag;
- struct bitwise_and_assign_tag;
- struct bitwise_or_assign_tag;
- struct bitwise_xor_assign_tag;
- struct subscript_tag;
+ struct assign;
+ struct left_shift_assign;
+ struct right_shift_assign;
+ struct multiply_assign;
+ struct divide_assign;
+ struct modulus_assign;
+ struct add_assign;
+ struct subtract_assign;
+ struct bitwise_and_assign;
+ struct bitwise_or_assign;
+ struct bitwise_xor_assign;
+ struct subscript;
- struct function_tag;
+ struct function;
+ }
// for backwards compatibility
+ typedef tag::unary unary_type;
+ typedef tag::binary binary_tag;
+ typedef tag::nary nary_tag;
+ typedef tag::terminal terminal_tag;
+ typedef tag::unary_plus unary_plus_tag;
+ typedef tag::unary_minus unary_minus_tag;
+ typedef tag::unary_star unary_star_tag;
+ typedef tag::complement complement_tag;
+ typedef tag::address_of address_of_tag;
+ typedef tag::logical_not logical_not_tag;
+ typedef tag::pre_inc pre_inc_tag;
+ typedef tag::pre_dec pre_dec_tag;
+ typedef tag::post_inc post_inc_tag;
+ typedef tag::post_dec post_dec_tag;
+ typedef tag::left_shift left_shift_tag;
+ typedef tag::right_shift right_shift_tag;
+ typedef tag::multiply multiply_tag;
+ typedef tag::divide divide_tag;
+ typedef tag::modulus modulus_tag;
+ typedef tag::add add_tag;
+ typedef tag::subtract subtract_tag;
+ typedef tag::less less_tag;
+ typedef tag::greater greater_tag;
+ typedef tag::less_equal less_equal_tag;
+ typedef tag::greater_equal greater_equal_tag;
+ typedef tag::equal equal_tag;
+ typedef tag::not_equal not_equal_tag;
+ typedef tag::logical_or logical_or_tag;
+ typedef tag::logical_and logical_and_tag;
+ typedef tag::bitwise_and bitwise_and_tag;
+ typedef tag::bitwise_or bitwise_or_tag;
+ typedef tag::bitwise_xor bitwise_xor_tag;
+ typedef tag::comma comma_tag;
+ typedef tag::mem_ptr mem_ptr_tag;
+ typedef tag::assign assign_tag;
+ typedef tag::left_shift_assign left_shift_assign_tag;
+ typedef tag::right_shift_assign right_shift_assign_tag;
+ typedef tag::multiply_assign multiply_assign_tag;
+ typedef tag::divide_assign divide_assign_tag;
+ typedef tag::modulus_assign modulus_assign_tag;
+ typedef tag::add_assign add_assign_tag;
+ typedef tag::subtract_assign subtract_assign_tag;
+ typedef tag::bitwise_and_assign bitwise_and_assign_tag;
+ typedef tag::bitwise_or_assign bitwise_or_assign_tag;
+ typedef tag::bitwise_xor_assign bitwise_xor_assign_tag;
+ typedef tag::subscript subscript_tag;
+ typedef tag::function function_tag;
typedef bitwise_or_tag bitor_tag;
typedef bitwise_and_tag bitand_tag;
typedef bitwise_xor_tag bitxor_tag;
Index: proto_typeof.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/proto_typeof.hpp,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- proto_typeof.hpp 21 Nov 2006 17:28:15 -0000 1.7
+++ proto_typeof.hpp 1 Dec 2006 05:46:06 -0000 1.8
@@ -22,53 +22,53 @@
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::unary_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::binary_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::nary_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::terminal_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::unary_plus_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::unary_minus_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::unary_star_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::complement_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::address_of_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::logical_not_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::pre_inc_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::pre_dec_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::post_inc_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::post_dec_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::left_shift_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::right_shift_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::multiply_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::divide_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::modulus_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::add_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::subtract_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::less_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::greater_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::less_equal_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::greater_equal_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::equal_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::not_equal_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::logical_or_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::logical_and_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::bitand_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::bitor_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::bitxor_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::comma_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::mem_ptr_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::assign_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::left_shift_assign_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::right_shift_assign_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::multiply_assign_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::divide_assign_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::modulus_assign_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::add_assign_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::subtract_assign_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::bitand_assign_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::bitor_assign_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::bitxor_assign_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::subscript_tag)
-BOOST_TYPEOF_REGISTER_TYPE(boost::proto::function_tag)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::unary)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::binary)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::nary)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::terminal)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::unary_plus)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::unary_minus)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::unary_star)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::complement)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::address_of)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::logical_not)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::pre_inc)
+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::multiply)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::divide)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::modulus)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::add)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::subtract)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::less)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::greater)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::less_equal)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::greater_equal)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::equal)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::not_equal)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::logical_or)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::logical_and)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitand)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_or)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitxor)
+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::multiply_assign)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::divide_assign)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::modulus_assign)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::add_assign)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::subtract_assign)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitand_assign)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitor_assign)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitxor_assign)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::subscript)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::function)
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::ref, (typename))
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::expr, (typename)(typename)(long))
Index: ref.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/ref.hpp,v
retrieving revision 1.10
retrieving revision 1.11
diff -u -d -r1.10 -r1.11
--- ref.hpp 1 Dec 2006 02:58:48 -0000 1.10
+++ ref.hpp 1 Dec 2006 05:46:06 -0000 1.11
@@ -9,6 +9,7 @@
#ifndef BOOST_PROTO_REF_HPP_EAN_04_01_2005
#define BOOST_PROTO_REF_HPP_EAN_04_01_2005
+#include <boost/mpl/bool.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/xpressive/proto/proto_fwd.hpp>
Index: tags.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/tags.hpp,v
retrieving revision 1.3
retrieving revision 1.4
diff -u -d -r1.3 -r1.4
--- tags.hpp 3 Nov 2006 02:47:44 -0000 1.3
+++ tags.hpp 1 Dec 2006 05:46:06 -0000 1.4
@@ -1,7 +1,7 @@
///////////////////////////////////////////////////////////////////////////////
/// \file tags.hpp
/// Contains the tags for all the overloadable operators in C++, as well as
-/// the base tags unary_tag, binary_tag and nary_tag, as well as the
is_unary\<\>,
+/// the base tags unary, binary and nary, as well as the is_unary\<\>,
/// is_binary\<\> and is_nary\<\> predicates.
//
// Copyright 2004 Eric Niebler. Distributed under the Boost
@@ -14,63 +14,63 @@
#include <boost/type_traits/is_base_and_derived.hpp>
#include <boost/xpressive/proto/proto_fwd.hpp>
-namespace boost { namespace proto
+namespace boost { namespace proto { namespace tag
{
///////////////////////////////////////////////////////////////////////////////
// Operator tags
- struct unary_tag {};
- struct binary_tag {};
- struct nary_tag {}; // for operator()
+ struct unary {};
+ struct binary {};
+ struct nary {}; // for operator()
- struct terminal_tag : unary_tag {};
- struct unary_plus_tag : unary_tag {};
- struct unary_minus_tag : unary_tag {};
- struct unary_star_tag : unary_tag {};
- struct complement_tag : unary_tag {};
- struct address_of_tag : unary_tag {};
- struct logical_not_tag : unary_tag {};
- struct pre_inc_tag : unary_tag {};
- struct pre_dec_tag : unary_tag {};
- struct post_inc_tag : unary_tag {};
- struct post_dec_tag : unary_tag {};
+ struct terminal : unary {};
+ struct unary_plus : unary {};
+ struct unary_minus : unary {};
+ struct unary_star : unary {};
+ struct complement : unary {};
+ struct address_of : unary {};
+ struct logical_not : unary {};
+ struct pre_inc : unary {};
+ struct pre_dec : unary {};
+ struct post_inc : unary {};
+ struct post_dec : unary {};
- struct left_shift_tag : binary_tag {};
- struct right_shift_tag : binary_tag {};
- struct multiply_tag : binary_tag {};
- struct divide_tag : binary_tag {};
- struct modulus_tag : binary_tag {};
- struct add_tag : binary_tag {};
- struct subtract_tag : binary_tag {};
- struct less_tag : binary_tag {};
- struct greater_tag : binary_tag {};
- struct less_equal_tag : binary_tag {};
- struct greater_equal_tag : binary_tag {};
- struct equal_tag : binary_tag {};
- struct not_equal_tag : binary_tag {};
- struct logical_or_tag : binary_tag {};
- struct logical_and_tag : binary_tag {};
- struct bitwise_and_tag : binary_tag {};
- struct bitwise_or_tag : binary_tag {};
- struct bitwise_xor_tag : binary_tag {};
- struct comma_tag : binary_tag {};
- struct mem_ptr_tag : binary_tag {};
+ struct left_shift : binary {};
+ struct right_shift : binary {};
+ struct multiply : binary {};
+ struct divide : binary {};
+ struct modulus : binary {};
+ struct add : binary {};
+ struct subtract : binary {};
+ struct less : binary {};
+ struct greater : binary {};
+ struct less_equal : binary {};
+ struct greater_equal : binary {};
+ struct equal : binary {};
+ struct not_equal : binary {};
+ struct logical_or : binary {};
+ struct logical_and : binary {};
+ struct bitwise_and : binary {};
+ struct bitwise_or : binary {};
+ struct bitwise_xor : binary {};
+ struct comma : binary {};
+ struct mem_ptr : binary {};
- struct assign_tag : binary_tag {};
- struct left_shift_assign_tag : binary_tag {};
- struct right_shift_assign_tag : binary_tag {};
- struct multiply_assign_tag : binary_tag {};
- struct divide_assign_tag : binary_tag {};
- struct modulus_assign_tag : binary_tag {};
- struct add_assign_tag : binary_tag {};
- struct subtract_assign_tag : binary_tag {};
- struct bitwise_and_assign_tag : binary_tag {};
- struct bitwise_or_assign_tag : binary_tag {};
- struct bitwise_xor_assign_tag : binary_tag {};
- struct subscript_tag : binary_tag {};
+ struct assign : binary {};
+ struct left_shift_assign : binary {};
+ struct right_shift_assign : binary {};
+ struct multiply_assign : binary {};
+ struct divide_assign : binary {};
+ struct modulus_assign : binary {};
+ struct add_assign : binary {};
+ struct subtract_assign : binary {};
+ struct bitwise_and_assign : binary {};
+ struct bitwise_or_assign : binary {};
+ struct bitwise_xor_assign : binary {};
+ struct subscript : binary {};
- struct function_tag : nary_tag {};
+ struct function : nary {};
-}}
+}}}
#endif
Index: traits.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/traits.hpp,v
retrieving revision 1.19
retrieving revision 1.20
diff -u -d -r1.19 -r1.20
--- traits.hpp 1 Dec 2006 02:58:48 -0000 1.19
+++ traits.hpp 1 Dec 2006 05:46:06 -0000 1.20
@@ -13,6 +13,7 @@
#define BOOST_PROTO_ARG_TRAITS_HPP_EAN_04_01_2005
#include <boost/ref.hpp>
+ #include <boost/mpl/if.hpp>
#include <boost/mpl/or.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/call_traits.hpp>
@@ -71,7 +72,7 @@
struct as_expr<T, false>
{
BOOST_STATIC_ASSERT(!is_reference<T>::value);
- typedef expr<terminal_tag, args1<typename
call_traits<T>::value_type> > type;
+ typedef expr<proto::tag::terminal, args1<typename
call_traits<T>::value_type> > type;
};
template<typename T>
@@ -84,7 +85,7 @@
struct as_expr_ref<T, false>
{
BOOST_STATIC_ASSERT(!is_reference<T>::value);
- typedef expr<terminal_tag, args1<typename
call_traits<T>::value_type> > type;
+ typedef expr<proto::tag::terminal, args1<typename
call_traits<T>::value_type> > type;
};
template<typename T>
@@ -119,7 +120,7 @@
{
BOOST_STATIC_ASSERT(!is_reference<T>::value);
typedef typename call_traits<T>::value_type value_type;
- typedef expr<terminal_tag, args1<value_type> > type;
+ typedef expr<proto::tag::terminal, args1<value_type> > type;
};
// unary_expr
@@ -143,7 +144,7 @@
template<typename T>\
struct Name\
{\
- typedef expr<BOOST_PP_CAT(Name, _tag), args1<T> > type;\
+ typedef expr<proto::tag::Name, args1<T> > type;\
};\
/**/
@@ -151,7 +152,7 @@
template<typename T, typename U>\
struct Name\
{\
- typedef expr<BOOST_PP_CAT(Name, _tag), args2<T, U> > type;\
+ typedef expr<proto::tag::Name, args2<T, U> > type;\
};\
/**/
@@ -433,7 +434,7 @@
BOOST_PP_ENUM_PARAMS(N, A)
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void
BOOST_PP_INTERCEPT), void >
{
- typedef expr<function_tag, BOOST_PP_CAT(args,
N)<BOOST_PP_ENUM_PARAMS(N, A)> > type;
+ typedef expr<proto::tag::function, BOOST_PP_CAT(args,
N)<BOOST_PP_ENUM_PARAMS(N, A)> > type;
};
#endif
-------------------------------------------------------------------------
Take Surveys. Earn Cash. Influence the Future of IT
Join SourceForge.net's Techsay panel and you'll get the chance to share your
opinions on IT & business topics through brief surveys - and earn cash
http://www.techsay.com/default.php?page=join.php&p=sourceforge&CID=DEVDEV
_______________________________________________
Boost-cvs mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/boost-cvs
