Update of /cvsroot/boost/boost/boost/xpressive/proto
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv4813/boost/xpressive/proto
Modified Files:
context.hpp debug.hpp operators.hpp proto_fwd.hpp
proto_typeof.hpp tags.hpp traits.hpp
Log Message:
major renames for proto to conform with <functional>
Index: context.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/context.hpp,v
retrieving revision 1.25
retrieving revision 1.26
diff -u -d -r1.25 -r1.26
--- context.hpp 26 Apr 2007 07:07:24 -0000 1.25
+++ context.hpp 29 Apr 2007 03:38:49 -0000 1.26
@@ -185,9 +185,9 @@
};\
/**/
- BOOST_PROTO_UNARY_OP_RESULT(+, proto::tag::unary_plus)
- BOOST_PROTO_UNARY_OP_RESULT(-, proto::tag::unary_minus)
- BOOST_PROTO_UNARY_OP_RESULT(*, proto::tag::unary_star)
+ BOOST_PROTO_UNARY_OP_RESULT(+, proto::tag::posit)
+ BOOST_PROTO_UNARY_OP_RESULT(-, proto::tag::negate)
+ BOOST_PROTO_UNARY_OP_RESULT(*, proto::tag::dereference)
BOOST_PROTO_UNARY_OP_RESULT(~, proto::tag::complement)
BOOST_PROTO_UNARY_OP_RESULT(&, proto::tag::address_of)
BOOST_PROTO_UNARY_OP_RESULT(!, proto::tag::logical_not)
@@ -196,17 +196,17 @@
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::multiply)
- BOOST_PROTO_BINARY_OP_RESULT(/, proto::tag::divide)
+ BOOST_PROTO_BINARY_OP_RESULT(*, proto::tag::multiplies)
+ BOOST_PROTO_BINARY_OP_RESULT(/, proto::tag::divides)
BOOST_PROTO_BINARY_OP_RESULT(%, proto::tag::modulus)
- BOOST_PROTO_BINARY_OP_RESULT(+, proto::tag::add)
- BOOST_PROTO_BINARY_OP_RESULT(-, proto::tag::subtract)
+ BOOST_PROTO_BINARY_OP_RESULT(+, proto::tag::plus)
+ BOOST_PROTO_BINARY_OP_RESULT(-, proto::tag::minus)
BOOST_PROTO_BINARY_OP_RESULT(<, proto::tag::less)
BOOST_PROTO_BINARY_OP_RESULT(>, proto::tag::greater)
BOOST_PROTO_BINARY_OP_RESULT(<=, proto::tag::less_equal)
BOOST_PROTO_BINARY_OP_RESULT(>=, proto::tag::greater_equal)
- BOOST_PROTO_BINARY_OP_RESULT(==, proto::tag::equal)
- BOOST_PROTO_BINARY_OP_RESULT(!=, proto::tag::not_equal)
+ BOOST_PROTO_BINARY_OP_RESULT(==, proto::tag::equal_to)
+ BOOST_PROTO_BINARY_OP_RESULT(!=, proto::tag::not_equal_to)
BOOST_PROTO_BINARY_OP_RESULT(||, proto::tag::logical_or)
BOOST_PROTO_BINARY_OP_RESULT(&&, proto::tag::logical_and)
BOOST_PROTO_BINARY_OP_RESULT(&, proto::tag::bitwise_and)
@@ -217,11 +217,11 @@
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::multiply_assign)
- BOOST_PROTO_BINARY_OP_RESULT(/=, proto::tag::divide_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)
- BOOST_PROTO_BINARY_OP_RESULT(+=, proto::tag::add_assign)
- BOOST_PROTO_BINARY_OP_RESULT(-=, proto::tag::subtract_assign)
+ BOOST_PROTO_BINARY_OP_RESULT(+=, proto::tag::plus_assign)
+ BOOST_PROTO_BINARY_OP_RESULT(-=, proto::tag::minus_assign)
BOOST_PROTO_BINARY_OP_RESULT(&=, proto::tag::bitwise_and_assign)
BOOST_PROTO_BINARY_OP_RESULT(|=, proto::tag::bitwise_or_assign)
BOOST_PROTO_BINARY_OP_RESULT(^=, proto::tag::bitwise_xor_assign)
Index: debug.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/debug.hpp,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -d -r1.5 -r1.6
--- debug.hpp 16 Apr 2007 04:50:45 -0000 1.5
+++ debug.hpp 29 Apr 2007 03:38:49 -0000 1.6
@@ -41,9 +41,9 @@
}\
/**/
- BOOST_PROTO_DEFINE_TAG_NAME(unary_plus)
- BOOST_PROTO_DEFINE_TAG_NAME(unary_minus)
- BOOST_PROTO_DEFINE_TAG_NAME(unary_star)
+ BOOST_PROTO_DEFINE_TAG_NAME(posit)
+ BOOST_PROTO_DEFINE_TAG_NAME(negate)
+ BOOST_PROTO_DEFINE_TAG_NAME(dereference)
BOOST_PROTO_DEFINE_TAG_NAME(complement)
BOOST_PROTO_DEFINE_TAG_NAME(address_of)
BOOST_PROTO_DEFINE_TAG_NAME(logical_not)
@@ -53,17 +53,17 @@
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(multiply)
- BOOST_PROTO_DEFINE_TAG_NAME(divide)
+ BOOST_PROTO_DEFINE_TAG_NAME(multiplies)
+ BOOST_PROTO_DEFINE_TAG_NAME(divides)
BOOST_PROTO_DEFINE_TAG_NAME(modulus)
- BOOST_PROTO_DEFINE_TAG_NAME(add)
- BOOST_PROTO_DEFINE_TAG_NAME(subtract)
+ BOOST_PROTO_DEFINE_TAG_NAME(plus)
+ BOOST_PROTO_DEFINE_TAG_NAME(minus)
BOOST_PROTO_DEFINE_TAG_NAME(less)
BOOST_PROTO_DEFINE_TAG_NAME(greater)
BOOST_PROTO_DEFINE_TAG_NAME(less_equal)
BOOST_PROTO_DEFINE_TAG_NAME(greater_equal)
- BOOST_PROTO_DEFINE_TAG_NAME(equal)
- BOOST_PROTO_DEFINE_TAG_NAME(not_equal)
+ BOOST_PROTO_DEFINE_TAG_NAME(equal_to)
+ BOOST_PROTO_DEFINE_TAG_NAME(not_equal_to)
BOOST_PROTO_DEFINE_TAG_NAME(logical_or)
BOOST_PROTO_DEFINE_TAG_NAME(logical_and)
BOOST_PROTO_DEFINE_TAG_NAME(bitwise_and)
@@ -74,11 +74,11 @@
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(multiply_assign)
- BOOST_PROTO_DEFINE_TAG_NAME(divide_assign)
+ BOOST_PROTO_DEFINE_TAG_NAME(multilpies_assign)
+ BOOST_PROTO_DEFINE_TAG_NAME(divides_assign)
BOOST_PROTO_DEFINE_TAG_NAME(modulus_assign)
- BOOST_PROTO_DEFINE_TAG_NAME(add_assign)
- BOOST_PROTO_DEFINE_TAG_NAME(subtract_assign)
+ BOOST_PROTO_DEFINE_TAG_NAME(plus_assign)
+ BOOST_PROTO_DEFINE_TAG_NAME(minus_assign)
BOOST_PROTO_DEFINE_TAG_NAME(bitwise_and_assign)
BOOST_PROTO_DEFINE_TAG_NAME(bitwise_or_assign)
BOOST_PROTO_DEFINE_TAG_NAME(bitwise_xor_assign)
Index: operators.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/operators.hpp,v
retrieving revision 1.26
retrieving revision 1.27
diff -u -d -r1.26 -r1.27
--- operators.hpp 14 Feb 2007 08:03:06 -0000 1.26
+++ operators.hpp 29 Apr 2007 03:38:49 -0000 1.27
@@ -149,9 +149,9 @@
}\
/**/
- 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::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)
@@ -160,17 +160,17 @@
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::multiplies)
+ BOOST_PROTO_BINARY_OP(/, tag::divides)
BOOST_PROTO_BINARY_OP(%, tag::modulus)
- BOOST_PROTO_BINARY_OP(+, tag::add)
- BOOST_PROTO_BINARY_OP(-, tag::subtract)
+ 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)
- BOOST_PROTO_BINARY_OP(!=, tag::not_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)
@@ -181,11 +181,11 @@
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::multilpies_assign)
+ BOOST_PROTO_BINARY_OP(/=, tag::divides_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::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)
Index: proto_fwd.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/proto_fwd.hpp,v
retrieving revision 1.59
retrieving revision 1.60
diff -u -d -r1.59 -r1.60
--- proto_fwd.hpp 12 Apr 2007 23:44:41 -0000 1.59
+++ proto_fwd.hpp 29 Apr 2007 03:38:49 -0000 1.60
@@ -50,14 +50,10 @@
// Operator tags
namespace tag
{
- struct unary;
- struct binary;
- struct nary;
-
struct terminal;
- struct unary_plus;
- struct unary_minus;
- struct unary_star;
+ struct posit;
+ struct negate;
+ struct dereference;
struct complement;
struct address_of;
struct logical_not;
@@ -68,17 +64,17 @@
struct left_shift;
struct right_shift;
- struct multiply;
- struct divide;
+ struct multiplies;
+ struct divides;
struct modulus;
- struct add;
- struct subtract;
+ struct plus;
+ struct minus;
struct less;
struct greater;
struct less_equal;
struct greater_equal;
- struct equal;
- struct not_equal;
+ struct equal_to;
+ struct not_equal_to;
struct logical_or;
struct logical_and;
struct bitwise_and;
@@ -90,11 +86,11 @@
struct assign;
struct left_shift_assign;
struct right_shift_assign;
- struct multiply_assign;
- struct divide_assign;
+ struct multilpies_assign;
+ struct divides_assign;
struct modulus_assign;
- struct add_assign;
- struct subtract_assign;
+ struct plus_assign;
+ struct minus_assign;
struct bitwise_and_assign;
struct bitwise_or_assign;
struct bitwise_xor_assign;
@@ -103,61 +99,6 @@
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;
- typedef bitwise_or_assign_tag bitor_assign_tag;
- typedef bitwise_and_assign_tag bitand_assign_tag;
- typedef bitwise_xor_assign_tag bitxor_assign_tag;
-
template<typename Tag, typename Args, long Arity = Args::size>
struct expr;
@@ -332,9 +273,9 @@
// Specific expression generators, for convenience
template<typename T> struct terminal;
- template<typename T> struct unary_plus;
- template<typename T> struct unary_minus;
- template<typename T> struct unary_star;
+ template<typename T> struct posit;
+ template<typename T> struct negate;
+ template<typename T> struct dereference;
template<typename T> struct complement;
template<typename T> struct address_of;
template<typename T> struct logical_not;
@@ -345,17 +286,17 @@
template<typename T, typename U> struct left_shift;
template<typename T, typename U> struct right_shift;
- template<typename T, typename U> struct multiply;
- template<typename T, typename U> struct divide;
+ template<typename T, typename U> struct multiplies;
+ template<typename T, typename U> struct divides;
template<typename T, typename U> struct modulus;
- template<typename T, typename U> struct add;
- template<typename T, typename U> struct subtract;
+ template<typename T, typename U> struct plus;
+ template<typename T, typename U> struct minus;
template<typename T, typename U> struct less;
template<typename T, typename U> struct greater;
template<typename T, typename U> struct less_equal;
template<typename T, typename U> struct greater_equal;
- template<typename T, typename U> struct equal;
- template<typename T, typename U> struct not_equal;
+ template<typename T, typename U> struct equal_to;
+ template<typename T, typename U> struct not_equal_to;
template<typename T, typename U> struct logical_or;
template<typename T, typename U> struct logical_and;
template<typename T, typename U> struct bitwise_and;
@@ -367,11 +308,11 @@
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 multiply_assign;
- template<typename T, typename U> struct divide_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;
- template<typename T, typename U> struct add_assign;
- template<typename T, typename U> struct subtract_assign;
+ template<typename T, typename U> struct plus_assign;
+ template<typename T, typename U> struct minus_assign;
template<typename T, typename U> struct bitwise_and_assign;
template<typename T, typename U> struct bitwise_or_assign;
template<typename T, typename U> struct bitwise_xor_assign;
Index: proto_typeof.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/proto_typeof.hpp,v
retrieving revision 1.11
retrieving revision 1.12
diff -u -d -r1.11 -r1.12
--- proto_typeof.hpp 3 Feb 2007 00:14:33 -0000 1.11
+++ proto_typeof.hpp 29 Apr 2007 03:38:49 -0000 1.12
@@ -18,13 +18,10 @@
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
#include <boost/xpressive/proto/detail/suffix.hpp>
-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::posit)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::negate)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::dereference)
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)
@@ -34,17 +31,17 @@
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::multiplies)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::divides)
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::plus)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::minus)
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::equal_to)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::not_equal_to)
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::bitwise_and)
@@ -55,11 +52,11 @@
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::multilpies_assign)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::divides_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::plus_assign)
+BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::minus_assign)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_and_assign)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_or_assign)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::bitwise_xor_assign)
@@ -68,7 +65,7 @@
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::ref, (typename))
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::expr, (typename)(typename)(long))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::terminal, (typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::literal, (typename)(typename))
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::args1, 1)
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::args2, 2)
@@ -98,6 +95,36 @@
#if BOOST_PROTO_MAX_ARITY >= 10
BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::args10, 10)
#endif
+#if BOOST_PROTO_MAX_ARITY >= 11
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::args11, 11)
+#endif
+#if BOOST_PROTO_MAX_ARITY >= 12
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::args12, 12)
+#endif
+#if BOOST_PROTO_MAX_ARITY >= 13
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::args13, 13)
+#endif
+#if BOOST_PROTO_MAX_ARITY >= 14
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::args14, 14)
+#endif
+#if BOOST_PROTO_MAX_ARITY >= 15
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::args15, 15)
+#endif
+#if BOOST_PROTO_MAX_ARITY >= 16
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::args16, 16)
+#endif
+#if BOOST_PROTO_MAX_ARITY >= 17
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::args17, 17)
+#endif
+#if BOOST_PROTO_MAX_ARITY >= 18
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::args18, 18)
+#endif
+#if BOOST_PROTO_MAX_ARITY >= 19
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::args19, 19)
+#endif
+#if BOOST_PROTO_MAX_ARITY >= 20
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::proto::args20, 20)
+#endif
#define BOOST_PROTO_AUTO(Var, Expr) BOOST_AUTO(Var,
boost::proto::deep_copy(Expr))
#define BOOST_PROTO_AUTO_TPL(Var, Expr) BOOST_AUTO_TPL(Var,
boost::proto::deep_copy(Expr))
Index: tags.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/tags.hpp,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -d -r1.7 -r1.8
--- tags.hpp 13 Jan 2007 18:09:21 -0000 1.7
+++ tags.hpp 29 Apr 2007 03:38:49 -0000 1.8
@@ -1,15 +1,13 @@
///////////////////////////////////////////////////////////////////////////////
/// \file tags.hpp
-/// Contains the tags for all the overloadable operators in C++, as well as
-/// the base tags unary, binary and nary, as well as the is_unary\<\>,
-/// is_binary\<\> and is_nary\<\> predicates.
+/// Contains the tags for all the overloadable operators in C++
//
// Copyright 2004 Eric Niebler. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#ifndef BOOST_PROTO_OP_TAGS_HPP_EAN_04_01_2005
-#define BOOST_PROTO_OP_TAGS_HPP_EAN_04_01_2005
+#ifndef BOOST_PROTO_TAGS_HPP_EAN_04_01_2005
+#define BOOST_PROTO_TAGS_HPP_EAN_04_01_2005
#include <boost/xpressive/proto/detail/prefix.hpp>
#include <boost/type_traits/is_base_and_derived.hpp>
@@ -19,59 +17,137 @@
namespace boost { namespace proto { namespace tag
{
-
///////////////////////////////////////////////////////////////////////////////
- // Operator tags
- struct unary {};
- struct binary {};
- struct nary {}; // for operator()
+ /// Tag type for terminals; aka, leaves in the expression tree.
+ struct terminal {};
- 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 {};
+ /// Tag type for the unary + operator.
+ struct posit {};
- 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 {};
+ /// Tag type for the unary - operator.
+ struct negate {};
- 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 {};
+ /// Tag type for the unary * operator.
+ struct dereference {};
- struct function : nary {};
+ /// Tag type for the unary ~ operator.
+ struct complement {};
+
+ /// Tag type for the unary & operator.
+ struct address_of {};
+
+ /// Tag type for the unary ! operator.
+ struct logical_not {};
+
+ /// Tag type for the unary prefix ++ operator.
+ struct pre_inc {};
+
+ /// Tag type for the unary prefix -- operator.
+ struct pre_dec {};
+
+ /// Tag type for the unary postfix ++ operator.
+ struct post_inc {};
+
+ /// Tag type for the unary postfix -- operator.
+ struct post_dec {};
+
+ /// Tag type for the binary \<\< operator.
+ struct left_shift {};
+
+ /// Tag type for the binary \>\> operator.
+ struct right_shift {};
+
+ /// Tag type for the binary * operator.
+ struct multiplies {};
+
+ /// Tag type for the binary / operator.
+ struct divides {};
+
+ /// Tag type for the binary % operator.
+ struct modulus {};
+
+ /// Tag type for the binary + operator.
+ struct plus {};
+
+ /// Tag type for the binary - operator.
+ struct minus {};
+
+ /// Tag type for the binary \< operator.
+ struct less {};
+
+ /// Tag type for the binary \> operator.
+ struct greater {};
+
+ /// Tag type for the binary \<= operator.
+ struct less_equal {};
+
+ /// Tag type for the binary \>= operator.
+ struct greater_equal {};
+
+ /// Tag type for the binary == operator.
+ struct equal_to {};
+
+ /// Tag type for the binary != operator.
+ struct not_equal_to {};
+
+ /// Tag type for the binary || operator.
+ struct logical_or {};
+
+ /// Tag type for the binary && operator.
+ struct logical_and {};
+
+ /// Tag type for the binary & operator.
+ struct bitwise_and {};
+
+ /// Tag type for the binary | operator.
+ struct bitwise_or {};
+
+ /// Tag type for the binary ^ operator.
+ struct bitwise_xor {};
+
+ /// Tag type for the binary , operator.
+ struct comma {};
+
+ /// Tag type for the binary ->* operator.
+ struct mem_ptr {};
+
+ /// Tag type for the binary = operator.
+ struct assign {};
+
+ /// Tag type for the binary \<\<= operator.
+ struct left_shift_assign {};
+
+ /// Tag type for the binary \>\>= operator.
+ struct right_shift_assign {};
+
+ /// Tag type for the binary *= operator.
+ struct multilpies_assign {};
+
+ /// Tag type for the binary /= operator.
+ struct divides_assign {};
+
+ /// Tag type for the binary %= operator.
+ struct modulus_assign {};
+
+ /// Tag type for the binary += operator.
+ struct plus_assign {};
+
+ /// Tag type for the binary -= operator.
+ struct minus_assign {};
+
+ /// Tag type for the binary &= operator.
+ struct bitwise_and_assign {};
+
+ /// Tag type for the binary |= operator.
+ struct bitwise_or_assign {};
+
+ /// Tag type for the binary ^= operator.
+ struct bitwise_xor_assign {};
+
+ /// Tag type for the binary subscript operator.
+ struct subscript {};
+
+ /// Tag type for the nary function call operator.
+ struct function {};
}}}
Index: traits.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/traits.hpp,v
retrieving revision 1.48
retrieving revision 1.49
diff -u -d -r1.48 -r1.49
--- traits.hpp 12 Apr 2007 23:44:41 -0000 1.48
+++ traits.hpp 29 Apr 2007 03:38:49 -0000 1.49
@@ -225,9 +225,9 @@
};\
/**/
- BOOST_PROTO_UNARY_GENERATOR(unary_plus)
- BOOST_PROTO_UNARY_GENERATOR(unary_minus)
- BOOST_PROTO_UNARY_GENERATOR(unary_star)
+ BOOST_PROTO_UNARY_GENERATOR(posit)
+ BOOST_PROTO_UNARY_GENERATOR(negate)
+ BOOST_PROTO_UNARY_GENERATOR(dereference)
BOOST_PROTO_UNARY_GENERATOR(complement)
BOOST_PROTO_UNARY_GENERATOR(address_of)
BOOST_PROTO_UNARY_GENERATOR(logical_not)
@@ -238,17 +238,17 @@
BOOST_PROTO_BINARY_GENERATOR(left_shift)
BOOST_PROTO_BINARY_GENERATOR(right_shift)
- BOOST_PROTO_BINARY_GENERATOR(multiply)
- BOOST_PROTO_BINARY_GENERATOR(divide)
+ BOOST_PROTO_BINARY_GENERATOR(multiplies)
+ BOOST_PROTO_BINARY_GENERATOR(divides)
BOOST_PROTO_BINARY_GENERATOR(modulus)
- BOOST_PROTO_BINARY_GENERATOR(add)
- BOOST_PROTO_BINARY_GENERATOR(subtract)
+ BOOST_PROTO_BINARY_GENERATOR(plus)
+ BOOST_PROTO_BINARY_GENERATOR(minus)
BOOST_PROTO_BINARY_GENERATOR(less)
BOOST_PROTO_BINARY_GENERATOR(greater)
BOOST_PROTO_BINARY_GENERATOR(less_equal)
BOOST_PROTO_BINARY_GENERATOR(greater_equal)
- BOOST_PROTO_BINARY_GENERATOR(equal)
- BOOST_PROTO_BINARY_GENERATOR(not_equal)
+ BOOST_PROTO_BINARY_GENERATOR(equal_to)
+ BOOST_PROTO_BINARY_GENERATOR(not_equal_to)
BOOST_PROTO_BINARY_GENERATOR(logical_or)
BOOST_PROTO_BINARY_GENERATOR(logical_and)
BOOST_PROTO_BINARY_GENERATOR(bitwise_and)
@@ -260,11 +260,11 @@
BOOST_PROTO_BINARY_GENERATOR(assign)
BOOST_PROTO_BINARY_GENERATOR(left_shift_assign)
BOOST_PROTO_BINARY_GENERATOR(right_shift_assign)
- BOOST_PROTO_BINARY_GENERATOR(multiply_assign)
- BOOST_PROTO_BINARY_GENERATOR(divide_assign)
+ BOOST_PROTO_BINARY_GENERATOR(multilpies_assign)
+ BOOST_PROTO_BINARY_GENERATOR(divides_assign)
BOOST_PROTO_BINARY_GENERATOR(modulus_assign)
- BOOST_PROTO_BINARY_GENERATOR(add_assign)
- BOOST_PROTO_BINARY_GENERATOR(subtract_assign)
+ BOOST_PROTO_BINARY_GENERATOR(plus_assign)
+ BOOST_PROTO_BINARY_GENERATOR(minus_assign)
BOOST_PROTO_BINARY_GENERATOR(bitwise_and_assign)
BOOST_PROTO_BINARY_GENERATOR(bitwise_or_assign)
BOOST_PROTO_BINARY_GENERATOR(bitwise_xor_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
