Update of /cvsroot/boost/boost/boost/xpressive/proto
In directory sc8-pr-cvs3.sourceforge.net:/tmp/cvs-serv7821
Modified Files:
domain.hpp expr.hpp extends.hpp fusion.hpp literal.hpp
matches.hpp operators.hpp proto_fwd.hpp ref.hpp traits.hpp
Log Message:
get more stuff out of the proto namespace
Index: domain.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/domain.hpp,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- domain.hpp 6 Jul 2007 02:55:54 -0000 1.8
+++ domain.hpp 6 Jul 2007 08:54:43 -0000 1.9
@@ -50,28 +50,30 @@
{};
}
- template<typename T, typename EnableIf>
- struct is_domain
- : mpl::false_
- {};
-
- template<typename T>
- struct is_domain<T, typename T::proto_is_domain_>
- : mpl::true_
- {};
-
- template<typename T, typename EnableIf>
- struct domain_of
+ namespace result_of
{
- typedef default_domain type;
- };
+ template<typename T, typename EnableIf>
+ struct is_domain
+ : mpl::false_
+ {};
- template<typename T>
- struct domain_of<T, typename T::proto_is_expr_>
- {
- typedef typename T::proto_domain type;
- };
+ template<typename T>
+ struct is_domain<T, typename T::proto_is_domain_>
+ : mpl::true_
+ {};
+
+ template<typename T, typename EnableIf>
+ struct domain_of
+ {
+ typedef default_domain type;
+ };
+ template<typename T>
+ struct domain_of<T, typename T::proto_is_expr_>
+ {
+ typedef typename T::proto_domain type;
+ };
+ }
}}
#endif
Index: expr.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/expr.hpp,v
retrieving revision 1.38
retrieving revision 1.39
diff -u -d -r1.38 -r1.39
--- expr.hpp 26 Jun 2007 17:03:00 -0000 1.38
+++ expr.hpp 6 Jul 2007 08:54:43 -0000 1.39
@@ -108,7 +108,7 @@
#include BOOST_PP_ITERATE()
}
- namespace ops
+ namespace exprns_
{
#define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PROTO_MAX_ARITY,
<boost/xpressive/proto/expr.hpp>))
#include BOOST_PP_ITERATE()
@@ -158,7 +158,7 @@
typedef expr proto_base_expr;
typedef Args proto_args;
typedef default_domain proto_domain;
- typedef proto_expr_tag fusion_tag;
+ typedef tag::proto_expr fusion_tag;
typedef void proto_is_expr_;
typedef expr proto_derived_expr;
Index: extends.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/extends.hpp,v
retrieving revision 1.36
retrieving revision 1.37
diff -u -d -r1.36 -r1.37
--- extends.hpp 26 Jun 2007 17:03:00 -0000 1.36
+++ extends.hpp 6 Jul 2007 08:54:43 -0000 1.37
@@ -104,7 +104,7 @@
typedef typename Expr::proto_args proto_args;\
typedef typename Expr::proto_arity proto_arity;\
typedef void proto_is_expr_;\
- typedef boost::proto::proto_expr_tag fusion_tag;\
+ typedef boost::proto::tag::proto_expr fusion_tag;\
\
BOOST_PROTO_IDENTITY_TRANSFORM();\
BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_ARG, Expr)\
@@ -219,7 +219,7 @@
BOOST_PP_REPEAT_FROM_TO(0, BOOST_PP_DEC(BOOST_PROTO_MAX_ARITY),
BOOST_PROTO_DEFINE_FUN_OP, (Expr, Derived, Domain))\
/**/
- namespace ops
+ namespace exprns_
{
/// \brief Empty type to be used as a dummy template parameter of
/// POD expression wrappers. It allows argument-dependent lookup
@@ -325,7 +325,7 @@
#include BOOST_PP_LOCAL_ITERATE()
};
- } // namespace ops
+ } // namespace exprns_
}}
Index: fusion.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/fusion.hpp,v
retrieving revision 1.31
retrieving revision 1.32
diff -u -d -r1.31 -r1.32
--- fusion.hpp 16 Jun 2007 05:46:16 -0000 1.31
+++ fusion.hpp 6 Jul 2007 08:54:43 -0000 1.32
@@ -49,7 +49,7 @@
typedef Expr expr_type;
typedef mpl::long_<Pos> index;
typedef fusion::forward_traversal_tag category;
- typedef proto_ref_iterator_tag fusion_tag;
+ typedef tag::proto_ref_iterator fusion_tag;
ref_iterator(Expr const &expr)
: expr_(expr)
@@ -112,7 +112,7 @@
struct is_view_impl;
template<>
- struct is_view_impl<proto::proto_ref_tag>
+ struct is_view_impl<proto::tag::proto_ref>
{
template<typename Iterator>
struct apply
@@ -121,7 +121,7 @@
};
template<>
- struct is_view_impl<proto::proto_expr_tag>
+ struct is_view_impl<proto::tag::proto_expr>
{
template<typename Iterator>
struct apply
@@ -133,7 +133,7 @@
struct value_of_impl;
template<>
- struct value_of_impl<proto::proto_ref_iterator_tag>
+ struct value_of_impl<proto::tag::proto_ref_iterator>
{
template<typename Iterator>
struct apply
@@ -145,7 +145,7 @@
struct deref_impl;
template<>
- struct deref_impl<proto::proto_ref_iterator_tag>
+ struct deref_impl<proto::tag::proto_ref_iterator>
{
template<typename Iterator>
struct apply
@@ -166,7 +166,7 @@
struct advance_impl;
template<>
- struct advance_impl<proto::proto_ref_iterator_tag>
+ struct advance_impl<proto::tag::proto_ref_iterator>
{
template<typename Iterator, typename N>
struct apply
@@ -187,7 +187,7 @@
struct distance_impl;
template<>
- struct distance_impl<proto::proto_ref_iterator_tag>
+ struct distance_impl<proto::tag::proto_ref_iterator>
{
template<typename IteratorFrom, typename IteratorTo>
struct apply
@@ -199,11 +199,11 @@
struct next_impl;
template<>
- struct next_impl<proto::proto_ref_iterator_tag>
+ struct next_impl<proto::tag::proto_ref_iterator>
{
template<typename Iterator>
struct apply
- : advance_impl<proto::proto_ref_iterator_tag>::template
apply<Iterator, mpl::long_<1> >
+ : advance_impl<proto::tag::proto_ref_iterator>::template
apply<Iterator, mpl::long_<1> >
{};
};
@@ -211,11 +211,11 @@
struct prior_impl;
template<>
- struct prior_impl<proto::proto_ref_iterator_tag>
+ struct prior_impl<proto::tag::proto_ref_iterator>
{
template<typename Iterator>
struct apply
- : advance_impl<proto::proto_ref_iterator_tag>::template
apply<Iterator, mpl::long_<-1> >
+ : advance_impl<proto::tag::proto_ref_iterator>::template
apply<Iterator, mpl::long_<-1> >
{};
};
@@ -223,7 +223,7 @@
struct category_of_impl;
template<>
- struct category_of_impl<proto::proto_ref_tag>
+ struct category_of_impl<proto::tag::proto_ref>
{
template<typename Sequence>
struct apply
@@ -236,7 +236,7 @@
struct size_impl;
template<>
- struct size_impl<proto::proto_ref_tag>
+ struct size_impl<proto::tag::proto_ref>
{
template<typename Sequence>
struct apply
@@ -248,7 +248,7 @@
struct begin_impl;
template<>
- struct begin_impl<proto::proto_ref_tag>
+ struct begin_impl<proto::tag::proto_ref>
{
template<typename Sequence>
struct apply
@@ -266,7 +266,7 @@
struct end_impl;
template<>
- struct end_impl<proto::proto_ref_tag>
+ struct end_impl<proto::tag::proto_ref>
{
template<typename Sequence>
struct apply
@@ -284,7 +284,7 @@
struct value_at_impl;
template<>
- struct value_at_impl<proto::proto_ref_tag>
+ struct value_at_impl<proto::tag::proto_ref>
{
template<typename Sequence, typename N>
struct apply
@@ -297,7 +297,7 @@
struct at_impl;
template<>
- struct at_impl<proto::proto_ref_tag>
+ struct at_impl<proto::tag::proto_ref>
{
template<typename Sequence, typename N>
struct apply
@@ -315,7 +315,7 @@
struct is_segmented_impl;
template<>
- struct is_segmented_impl<proto::proto_expr_tag>
+ struct is_segmented_impl<proto::tag::proto_expr>
{
template<typename Iterator>
struct apply
@@ -350,7 +350,7 @@
struct segments_impl;
template<>
- struct segments_impl<proto::proto_expr_tag>
+ struct segments_impl<proto::tag::proto_expr>
{
template<typename Sequence>
struct apply
@@ -371,7 +371,7 @@
};
template<>
- struct category_of_impl<proto::proto_expr_tag>
+ struct category_of_impl<proto::tag::proto_expr>
{
template<typename Sequence>
struct apply
@@ -381,7 +381,7 @@
};
template<>
- struct begin_impl<proto::proto_expr_tag>
+ struct begin_impl<proto::tag::proto_expr>
{
template<typename Sequence>
struct apply
@@ -390,7 +390,7 @@
};
template<>
- struct end_impl<proto::proto_expr_tag>
+ struct end_impl<proto::tag::proto_expr>
{
template<typename Sequence>
struct apply
@@ -399,7 +399,7 @@
};
template<>
- struct size_impl<proto::proto_expr_tag>
+ struct size_impl<proto::tag::proto_expr>
{
template<typename Sequence>
struct apply
@@ -412,7 +412,7 @@
//namespace boost { namespace mpl
//{
//template<>
- //struct begin_impl<proto::proto_expr_tag>
+ //struct begin_impl<proto::tag::proto_expr>
//{
// template<typename Sequence>
// struct apply
@@ -422,7 +422,7 @@
//};
//template<>
- //struct end_impl<proto::proto_expr_tag>
+ //struct end_impl<proto::tag::proto_expr>
//{
// template<typename Sequence>
// struct apply
@@ -432,7 +432,7 @@
//};
//template<>
- //struct size_impl<proto::proto_expr_tag>
+ //struct size_impl<proto::tag::proto_expr>
//{
// template<typename Sequence>
// struct apply
@@ -442,7 +442,7 @@
//};
//template<>
- //struct at_impl<proto::proto_expr_tag>
+ //struct at_impl<proto::tag::proto_expr>
//{
// template<typename Sequence, typename N>
// struct apply
@@ -453,7 +453,7 @@
//template<>
- //struct begin_impl<proto::proto_ref_tag>
+ //struct begin_impl<proto::tag::proto_ref>
//{
// template<typename Sequence>
// struct apply
@@ -463,7 +463,7 @@
//};
//template<>
- //struct end_impl<proto::proto_ref_tag>
+ //struct end_impl<proto::tag::proto_ref>
//{
// template<typename Sequence>
// struct apply
@@ -473,7 +473,7 @@
//};
//template<>
- //struct size_impl<proto::proto_ref_tag>
+ //struct size_impl<proto::tag::proto_ref>
//{
// template<typename Sequence>
// struct apply
@@ -483,7 +483,7 @@
//};
//template<>
- //struct at_impl<proto::proto_ref_tag>
+ //struct at_impl<proto::tag::proto_ref>
//{
// template<typename Sequence, typename N>
// struct apply
@@ -500,17 +500,17 @@
// template<typename Tag, typename Args, long Arity>
// struct sequence_tag<proto::expr<Tag, Args, Arity> >
// {
-// typedef proto::proto_expr_tag type;
+// typedef proto::tag::proto_expr type;
// };
//
// template<typename Expr>
// struct sequence_tag<proto::ref_<Expr> >
// {
-// typedef proto::proto_expr_tag type;
+// typedef proto::tag::proto_expr type;
// };
//
// template<>
-// struct begin_impl<proto::proto_expr_tag>
+// struct begin_impl<proto::tag::proto_expr>
// {
// template<typename Sequence>
// struct apply
@@ -520,7 +520,7 @@
// };
//
// template<>
-// struct end_impl<proto::proto_expr_tag>
+// struct end_impl<proto::tag::proto_expr>
// {
// template<typename Sequence>
// struct apply
@@ -530,7 +530,7 @@
// };
//
// template<>
-// struct size_impl<proto::proto_expr_tag>
+// struct size_impl<proto::tag::proto_expr>
// {
// template<typename Sequence>
// struct apply
@@ -540,7 +540,7 @@
// };
//
// template<>
-// struct at_impl<proto::proto_expr_tag>
+// struct at_impl<proto::tag::proto_expr>
// {
// template<typename Sequence, typename N>
// struct apply
Index: literal.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/literal.hpp,v
retrieving revision 1.8
retrieving revision 1.9
diff -u -d -r1.8 -r1.9
--- literal.hpp 12 Apr 2007 23:44:41 -0000 1.8
+++ literal.hpp 6 Jul 2007 08:54:43 -0000 1.9
@@ -19,30 +19,33 @@
namespace boost { namespace proto
{
- template<typename T, typename Domain>
- struct literal
- : extends<typename terminal<T>::type, literal<T, Domain>, Domain>
+ namespace utility
{
- typedef typename terminal<T>::type terminal_type;
- typedef extends<terminal_type, literal<T, Domain>, Domain> base_type;
+ template<typename T, typename Domain>
+ struct literal
+ : extends<typename terminal<T>::type, literal<T, Domain>, Domain>
+ {
+ typedef typename terminal<T>::type terminal_type;
+ typedef extends<terminal_type, literal<T, Domain>, Domain>
base_type;
- template<typename U>
- literal(U &u)
- : base_type(terminal_type::make(u))
- {}
+ template<typename U>
+ literal(U &u)
+ : base_type(terminal_type::make(u))
+ {}
- template<typename U>
- literal(U const &u)
- : base_type(terminal_type::make(u))
- {}
+ template<typename U>
+ literal(U const &u)
+ : base_type(terminal_type::make(u))
+ {}
- template<typename U>
- literal(literal<U, Domain> const &u)
- : base_type(terminal_type::make(proto::arg(u)))
- {}
+ template<typename U>
+ literal(literal<U, Domain> const &u)
+ : base_type(terminal_type::make(proto::arg(u)))
+ {}
- using base_type::operator =;
- };
+ using base_type::operator =;
+ };
+ }
/// lit
///
@@ -57,14 +60,16 @@
template<typename T>
inline literal<T const &> lit(T const &t)
{
-#ifdef _MSC_VER
-#pragma warning(push)
-#pragma warning(disable: 4180) // warning C4180: qualifier applied to function
type has no meaning; ignored
-#endif
+ #ifdef _MSC_VER
+ #pragma warning(push)
+ #pragma warning(disable: 4180) // warning C4180: qualifier applied to
function type has no meaning; ignored
+ #endif
+
return literal<T const &>(t);
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
+
+ #ifdef _MSC_VER
+ #pragma warning(pop)
+ #endif
}
}}
Index: matches.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/matches.hpp,v
retrieving revision 1.53
retrieving revision 1.54
diff -u -d -r1.53 -r1.54
--- matches.hpp 4 Jul 2007 21:40:16 -0000 1.53
+++ matches.hpp 6 Jul 2007 08:54:43 -0000 1.54
@@ -339,25 +339,13 @@
{};
}
- template<typename Expr, typename Grammar>
- struct matches
- : detail::matches_impl<typename Expr::proto_base_expr, typename
Grammar::proto_base_expr>
- {};
-
- template<typename Grammar>
- struct vararg
- : Grammar
+ namespace result_of
{
- typedef void proto_is_vararg_;
- };
-
- template<typename T>
- struct exact
- {};
-
- template<typename T>
- struct convertible_to
- {};
+ template<typename Expr, typename Grammar>
+ struct matches
+ : detail::matches_impl<typename Expr::proto_base_expr, typename
Grammar::proto_base_expr>
+ {};
+ }
namespace wildcardns_
{
@@ -465,6 +453,21 @@
return Cases::template case_<typename
Expr::proto_tag>::call(expr, state, visitor);
}
};
+
+ template<typename T>
+ struct exact
+ {};
+
+ template<typename T>
+ struct convertible_to
+ {};
+
+ template<typename Grammar>
+ struct vararg
+ : Grammar
+ {
+ typedef void proto_is_vararg_;
+ };
}
}}
Index: operators.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/operators.hpp,v
retrieving revision 1.37
retrieving revision 1.38
diff -u -d -r1.37 -r1.38
--- operators.hpp 29 Jun 2007 07:49:33 -0000 1.37
+++ operators.hpp 6 Jul 2007 08:54:43 -0000 1.38
@@ -226,7 +226,7 @@
}
\
/**/
- namespace ops
+ namespace exprns_
{
BOOST_PROTO_DEFINE_UNARY_OPERATOR(+, tag::posit, 0)
BOOST_PROTO_DEFINE_UNARY_OPERATOR(-, tag::negate, 0)
@@ -270,17 +270,19 @@
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
- ///
- BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(
- 3
- , if_else
- , deduce_domain
- , (tag::if_else_)
- , BOOST_PP_SEQ_NIL
- )
+ /// if_else
+ ///
+ BOOST_PROTO_DEFINE_FUNCTION_TEMPLATE(
+ 3
+ , if_else
+ , deduce_domain
+ , (tag::if_else_)
+ , BOOST_PP_SEQ_NIL
+ )
+ } // exprns_
+
+ using exprns_::if_else;
#undef BOOST_PROTO_DEFINE_UNARY_OPERATOR
#undef BOOST_PROTO_DEFINE_BINARY_OPERATOR
@@ -391,13 +393,13 @@
: mpl::false_
{};
-#ifndef BOOST_PROTO_DOXYGEN_INVOKED
+ #ifndef BOOST_PROTO_DOXYGEN_INVOKED
namespace exops
{
BOOST_PROTO_DEFINE_OPERATORS(is_extension, default_domain)
using proto::if_else;
}
-#endif
+ #endif
}}
Index: proto_fwd.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/proto_fwd.hpp,v
retrieving revision 1.85
retrieving revision 1.86
diff -u -d -r1.85 -r1.86
--- proto_fwd.hpp 6 Jul 2007 02:55:54 -0000 1.85
+++ proto_fwd.hpp 6 Jul 2007 08:54:43 -0000 1.86
@@ -114,6 +114,11 @@
struct subscript;
struct if_else_;
struct function;
+
+ // Fusion tags
+ struct proto_expr;
+ struct proto_ref;
+ struct proto_ref_iterator;
}
namespace wildcardns_
@@ -152,7 +157,7 @@
using domainns_::default_domain;
using domainns_::deduce_domain;
- namespace ops
+ namespace exprns_
{
template<typename Tag, typename Args, long Arity = Args::size>
struct expr;
@@ -168,11 +173,9 @@
struct is_proto_expr;
}
- using ops::expr;
-
- using ops::extends;
-
- using ops::is_proto_expr;
+ using exprns_::expr;
+ using exprns_::extends;
+ using exprns_::is_proto_expr;
namespace refns_
{
@@ -182,15 +185,6 @@
using refns_::ref_;
- template<typename Expr, typename Grammar>
- struct matches;
-
- template<typename T>
- struct exact;
-
- template<typename T>
- struct convertible_to;
-
namespace control
{
template<
@@ -215,6 +209,17 @@
template<typename Grammar>
struct not_;
+
+ template<typename T>
+ struct exact;
+
+ template<typename T>
+ struct convertible_to;
+
+ template<typename Grammar>
+ struct vararg;
+
+ int const N = INT_MAX;
}
using control::if_;
@@ -222,27 +227,44 @@
using control::and_;
using control::not_;
using control::switch_;
+ using control::exact;
+ using control::convertible_to;
+ using control::vararg;
+ using control::N;
- struct proto_expr_tag;
- struct proto_ref_tag;
- struct proto_ref_iterator_tag;
+ namespace context
+ {
+ struct null_context;
- struct default_context;
+ template<typename Expr, typename Context, long Arity =
Expr::proto_arity::value>
+ struct null_eval;
- template<typename Derived, typename DefaultCtx = default_context>
- struct callable_context;
+ struct default_context;
- template<typename T, typename Domain = default_domain>
- struct literal;
+ template<typename Expr, typename Context, typename Tag = typename
Expr::proto_tag, long Arity = Expr::proto_arity::value>
+ struct default_eval;
- template<typename T, typename EnableIf = void>
- struct is_ref;
+ template<typename Derived, typename DefaultCtx = default_context>
+ struct callable_context;
- template<typename T, typename EnableIf = void>
- struct is_expr;
+ template<typename Expr, typename Context, long Arity =
Expr::proto_arity::value>
+ struct callable_eval;
+ }
- template<typename T, typename EnableIf = void>
- struct is_domain;
+ using context::null_context;
+ using context::null_eval;
+ using context::default_context;
+ using context::default_eval;
+ using context::callable_context;
+ using context::callable_eval;
+
+ namespace utility
+ {
+ template<typename T, typename Domain = default_domain>
+ struct literal;
+ }
+
+ using utility::literal;
namespace result_of
{
@@ -287,77 +309,102 @@
template<typename Tag, typename DomainOrSequence, typename
SequenceOrVoid = void, typename _ = void>
struct unpack_expr;
- }
- template<typename Expr>
- struct tag_of;
+ template<typename T, typename EnableIf = void>
+ struct is_ref;
- template<typename T, typename EnableIf = void>
- struct domain_of;
+ template<typename T, typename EnableIf = void>
+ struct is_expr;
- template<typename Expr>
- struct id;
+ template<typename T, typename EnableIf = void>
+ struct is_domain;
- // Generic expression generators
- template<typename Tag, typename Arg>
- struct unary_expr;
+ template<typename Expr>
+ struct tag_of;
- template<typename Tag, typename Left, typename Right>
- struct binary_expr;
+ template<typename T, typename EnableIf = void>
+ struct domain_of;
- template<typename Tag,
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void),
typename Dummy = void>
- struct nary_expr;
+ template<typename Expr>
+ struct id;
- // Specific expression generators, for convenience
- template<typename T> struct terminal;
- 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;
- template<typename T> struct pre_inc;
- template<typename T> struct pre_dec;
- template<typename T> struct post_inc;
- template<typename T> struct post_dec;
+ template<typename Expr, typename Grammar>
+ struct matches;
+ }
- 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;
- 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_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;
- template<typename T, typename U> struct bitwise_or;
- template<typename T, typename U> struct bitwise_xor;
- template<typename T, typename U> struct comma;
- template<typename T, typename U> struct mem_ptr;
+ using proto::result_of::is_ref;
+ using proto::result_of::is_expr;
+ using proto::result_of::is_domain;
+ using proto::result_of::tag_of;
+ using proto::result_of::domain_of;
+ using proto::result_of::id;
+ using proto::result_of::matches;
- template<typename T, typename U> struct 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;
- 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;
- template<typename T, typename U> struct subscript;
- template<typename T, typename U, typename V> struct if_else_;
+ namespace op
+ {
+ // Generic expression generators
+ template<typename Tag, typename Arg>
+ struct unary_expr;
- template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY,
typename A, void), typename Dummy = void>
- struct function;
+ template<typename Tag, typename Left, typename Right>
+ struct binary_expr;
+
+ template<typename Tag,
BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY, typename A, void),
typename Dummy = void>
+ struct nary_expr;
+
+ // Specific expression generators, for convenience
+ template<typename T> struct terminal;
+ 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;
+ template<typename T> struct pre_inc;
+ template<typename T> struct pre_dec;
+ template<typename T> struct post_inc;
+ template<typename T> struct post_dec;
+
+ 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;
+ 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_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;
+ template<typename T, typename U> struct bitwise_or;
+ template<typename T, typename U> struct bitwise_xor;
+ template<typename T, typename U> struct comma;
+ template<typename T, typename U> struct mem_ptr;
+
+ template<typename T, typename U> struct 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;
+ 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;
+ template<typename T, typename U> struct subscript;
+ template<typename T, typename U, typename V> struct if_else_;
+
+ template<BOOST_PP_ENUM_PARAMS_WITH_A_DEFAULT(BOOST_PROTO_MAX_ARITY,
typename A, void), typename Dummy = void>
+ struct function;
+ }
+
+ using namespace op;
namespace functional
{
@@ -392,6 +439,18 @@
struct unfused_expr;
}
+#define BOOST_PROTO_IDENTITY_TRANSFORM()\
+ template<typename Expr_, typename State_, typename Visitor_>\
+ static Expr_ const &call(Expr_ const &expr_, State_ const &, Visitor_ &)\
+ {\
+ return expr_;\
+ }\
+ template<typename Expr_, typename, typename>\
+ struct apply\
+ {\
+ typedef Expr_ type;\
+ }
+
namespace transform
{
namespace detail
@@ -477,35 +536,19 @@
struct construct;
}
-#define BOOST_PROTO_IDENTITY_TRANSFORM()\
- template<typename Expr_, typename State_, typename Visitor_>\
- static Expr_ const &call(Expr_ const &expr_, State_ const &, Visitor_ &)\
- {\
- return expr_;\
- }\
- template<typename Expr_, typename, typename>\
- struct apply\
- {\
- typedef Expr_ type;\
- }
-
- namespace identitytfxns_
+ namespace has_transformns_
{
+ template<typename Grammar>
+ struct has_pass_through_transform;
+
struct has_identity_transform
{
BOOST_PROTO_IDENTITY_TRANSFORM();
};
}
- using identitytfxns_::has_identity_transform;
-
- template<typename Grammar>
- struct has_pass_through_transform;
-
- template<typename Grammar>
- struct vararg;
-
- int const N = INT_MAX;
+ using has_transformns_::has_identity_transform;
+ using has_transformns_::has_pass_through_transform;
template<typename T>
struct is_extension;
Index: ref.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/ref.hpp,v
retrieving revision 1.30
retrieving revision 1.31
diff -u -d -r1.30 -r1.31
--- ref.hpp 4 Jul 2007 21:40:17 -0000 1.30
+++ ref.hpp 6 Jul 2007 08:54:43 -0000 1.31
@@ -36,7 +36,7 @@
typedef typename Expr::proto_args proto_args;
typedef typename Expr::proto_arity proto_arity;
typedef typename Expr::proto_domain proto_domain;
- typedef proto_ref_tag fusion_tag;
+ typedef tag::proto_ref fusion_tag;
typedef void proto_is_ref_;
typedef void proto_is_expr_;
typedef Expr proto_derived_expr;
Index: traits.hpp
===================================================================
RCS file: /cvsroot/boost/boost/boost/xpressive/proto/traits.hpp,v
retrieving revision 1.62
retrieving revision 1.63
diff -u -d -r1.62 -r1.63
--- traits.hpp 2 Jul 2007 06:21:28 -0000 1.62
+++ traits.hpp 6 Jul 2007 08:54:43 -0000 1.63
@@ -57,30 +57,43 @@
namespace boost { namespace proto
{
- // is_ref
- template<typename T, typename EnableIf>
- struct is_ref
- : mpl::false_
- {};
+ namespace result_of
+ {
+ // is_ref
+ template<typename T, typename EnableIf>
+ struct is_ref
+ : mpl::false_
+ {};
- template<typename T>
- struct is_ref<T, typename T::proto_is_ref_>
- : mpl::true_
- {};
+ template<typename T>
+ struct is_ref<T, typename T::proto_is_ref_>
+ : mpl::true_
+ {};
- // is_expr
- template<typename T, typename EnableIf>
- struct is_expr
- : mpl::false_
- {};
+ // is_expr
+ template<typename T, typename EnableIf>
+ struct is_expr
+ : mpl::false_
+ {};
- template<typename T>
- struct is_expr<T, typename T::proto_is_expr_>
- : mpl::true_
- {};
+ template<typename T>
+ struct is_expr<T, typename T::proto_is_expr_>
+ : mpl::true_
+ {};
+
+ // tag_of
+ template<typename Expr>
+ struct tag_of
+ {
+ typedef typename Expr::proto_tag type;
+ };
+
+ // id
+ template<typename Expr>
+ struct id
+ : result_of::deep_copy<Expr>
+ {};
- namespace result_of
- {
// as_expr
template<typename T, typename Domain, typename EnableIf>
struct as_expr
@@ -175,138 +188,129 @@
{};
}
- // terminal
- template<typename T>
- struct terminal : has_identity_transform
- {
- terminal();
- typedef expr<proto::tag::terminal, args0<T> > type;
- typedef type proto_base_expr;
- typedef proto::tag::terminal proto_tag;
- typedef T proto_arg0;
- };
-
- // if_else
- template<typename T, typename U, typename V>
- struct if_else_ : has_pass_through_transform<if_else_<T, U, V> >
+ namespace op
{
- if_else_();
- typedef expr<proto::tag::if_else_, args3<T, U, V> > type;
- typedef type proto_base_expr;
- typedef proto::tag::if_else_ proto_tag;
- typedef T proto_arg0;
- typedef U proto_arg1;
- typedef V proto_arg2;
- };
+ // terminal
+ template<typename T>
+ struct terminal : has_identity_transform
+ {
+ terminal();
+ typedef expr<proto::tag::terminal, args0<T> > type;
+ typedef type proto_base_expr;
+ typedef proto::tag::terminal proto_tag;
+ typedef T proto_arg0;
+ };
- // unary_expr
- template<typename Tag, typename T>
- struct unary_expr : has_pass_through_transform<unary_expr<Tag, T> >
- {
- unary_expr();
- typedef expr<Tag, args1<T> > type;
- typedef type proto_base_expr;
- typedef Tag proto_tag;
- typedef T proto_arg0;
- };
+ // if_else
+ template<typename T, typename U, typename V>
+ struct if_else_ : has_pass_through_transform<if_else_<T, U, V> >
+ {
+ if_else_();
+ typedef expr<proto::tag::if_else_, args3<T, U, V> > type;
+ typedef type proto_base_expr;
+ typedef proto::tag::if_else_ proto_tag;
+ typedef T proto_arg0;
+ typedef U proto_arg1;
+ typedef V proto_arg2;
+ };
- // binary_expr
- template<typename Tag, typename T, typename U>
- struct binary_expr : has_pass_through_transform<binary_expr<Tag, T, U>
>
- {
- binary_expr();
- typedef expr<Tag, args2<T, U> > type;
- typedef type proto_base_expr;
- typedef Tag proto_tag;
- typedef T proto_arg0;
- typedef U proto_arg1;
- };
+ // unary_expr
+ template<typename Tag, typename T>
+ struct unary_expr : has_pass_through_transform<unary_expr<Tag, T> >
+ {
+ unary_expr();
+ typedef expr<Tag, args1<T> > type;
+ typedef type proto_base_expr;
+ typedef Tag proto_tag;
+ typedef T proto_arg0;
+ };
- #define BOOST_PROTO_UNARY_GENERATOR(Name)\
- template<typename T>\
- struct Name : has_pass_through_transform<Name<T> >\
- {\
- Name();\
- typedef expr<proto::tag::Name, args1<T> > type;\
- typedef type proto_base_expr;\
- typedef proto::tag::Name proto_tag;\
- typedef T proto_arg0;\
- };\
- /**/
+ // binary_expr
+ template<typename Tag, typename T, typename U>
+ struct binary_expr : has_pass_through_transform<binary_expr<Tag,
T, U> >
+ {
+ binary_expr();
+ typedef expr<Tag, args2<T, U> > type;
+ typedef type proto_base_expr;
+ typedef Tag proto_tag;
+ typedef T proto_arg0;
+ typedef U proto_arg1;
+ };
- #define BOOST_PROTO_BINARY_GENERATOR(Name)\
- template<typename T, typename U>\
- struct Name : has_pass_through_transform<Name<T, U> >\
- {\
- Name();\
- typedef expr<proto::tag::Name, args2<T, U> > type;\
- typedef type proto_base_expr;\
- typedef proto::tag::Name proto_tag;\
- typedef T proto_arg0;\
- typedef U proto_arg1;\
- };\
- /**/
+ #define BOOST_PROTO_UNARY_GENERATOR(Name)\
+ template<typename T>\
+ struct Name : has_pass_through_transform<Name<T> >\
+ {\
+ Name();\
+ typedef expr<proto::tag::Name, args1<T> > type;\
+ typedef type proto_base_expr;\
+ typedef proto::tag::Name proto_tag;\
+ typedef T proto_arg0;\
+ };\
+ /**/
- 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)
- BOOST_PROTO_UNARY_GENERATOR(pre_inc)
- BOOST_PROTO_UNARY_GENERATOR(pre_dec)
- BOOST_PROTO_UNARY_GENERATOR(post_inc)
- BOOST_PROTO_UNARY_GENERATOR(post_dec)
+ #define BOOST_PROTO_BINARY_GENERATOR(Name)\
+ template<typename T, typename U>\
+ struct Name : has_pass_through_transform<Name<T, U> >\
+ {\
+ Name();\
+ typedef expr<proto::tag::Name, args2<T, U> > type;\
+ typedef type proto_base_expr;\
+ typedef proto::tag::Name proto_tag;\
+ typedef T proto_arg0;\
+ typedef U proto_arg1;\
+ };\
+ /**/
- 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)
- 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_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)
- BOOST_PROTO_BINARY_GENERATOR(bitwise_or)
- BOOST_PROTO_BINARY_GENERATOR(bitwise_xor)
- BOOST_PROTO_BINARY_GENERATOR(comma)
- BOOST_PROTO_BINARY_GENERATOR(mem_ptr)
+ 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)
+ BOOST_PROTO_UNARY_GENERATOR(pre_inc)
+ BOOST_PROTO_UNARY_GENERATOR(pre_dec)
+ BOOST_PROTO_UNARY_GENERATOR(post_inc)
+ BOOST_PROTO_UNARY_GENERATOR(post_dec)
- BOOST_PROTO_BINARY_GENERATOR(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)
- 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)
- BOOST_PROTO_BINARY_GENERATOR(subscript)
+ 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)
+ 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_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)
+ BOOST_PROTO_BINARY_GENERATOR(bitwise_or)
+ BOOST_PROTO_BINARY_GENERATOR(bitwise_xor)
+ BOOST_PROTO_BINARY_GENERATOR(comma)
+ BOOST_PROTO_BINARY_GENERATOR(mem_ptr)
- #undef BOOST_PROTO_UNARY_GENERATOR
- #undef BOOST_PROTO_BINARY_GENERATOR
+ BOOST_PROTO_BINARY_GENERATOR(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)
+ 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)
+ BOOST_PROTO_BINARY_GENERATOR(subscript)
- // tag_of
- template<typename Expr>
- struct tag_of
- {
- typedef typename Expr::proto_tag type;
- };
+ #undef BOOST_PROTO_UNARY_GENERATOR
+ #undef BOOST_PROTO_BINARY_GENERATOR
- // id
- template<typename Expr>
- struct id
- : result_of::deep_copy<Expr>
- {};
+ } // namespace op
#define BOOST_PROTO_ARG(z, n, data)\
typedef BOOST_PP_CAT(data, n) BOOST_PP_CAT(proto_arg, n);\
@@ -635,46 +639,48 @@
#define N BOOST_PP_ITERATION()
#if N > 0
- template<BOOST_PP_ENUM_PARAMS(N, typename A)>
- struct function<
- BOOST_PP_ENUM_PARAMS(N, A)
- BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY,
N), void BOOST_PP_INTERCEPT), void
- >
- : has_pass_through_transform<
- function<
- BOOST_PP_ENUM_PARAMS(N, A)
-
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void
BOOST_PP_INTERCEPT), void
- >
- >
+ namespace op
{
- typedef expr<proto::tag::function, BOOST_PP_CAT(args,
N)<BOOST_PP_ENUM_PARAMS(N, A)> > type;
- typedef type proto_base_expr;
- typedef proto::tag::function proto_tag;
- 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)
- };
-
- template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
- struct nary_expr<
- Tag
- BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
- BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY,
N), void BOOST_PP_INTERCEPT), void
- >
- : has_pass_through_transform<
- nary_expr<
- Tag
- BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
-
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void
BOOST_PP_INTERCEPT), void
- >
+ template<BOOST_PP_ENUM_PARAMS(N, typename A)>
+ struct function<
+ 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<Tag, BOOST_PP_CAT(args, N)<BOOST_PP_ENUM_PARAMS(N,
A)> > type;
- typedef type proto_base_expr;
- typedef Tag proto_tag;
- 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)
- };
+ : has_pass_through_transform<
+ function<
+ 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<proto::tag::function, BOOST_PP_CAT(args,
N)<BOOST_PP_ENUM_PARAMS(N, A)> > type;
+ typedef type proto_base_expr;
+ typedef proto::tag::function proto_tag;
+ 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)
+ };
+ template<typename Tag BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+ struct nary_expr<
+ Tag
+ BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
+
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void
BOOST_PP_INTERCEPT), void
+ >
+ : has_pass_through_transform<
+ nary_expr<
+ Tag
+ BOOST_PP_ENUM_TRAILING_PARAMS(N, A)
+
BOOST_PP_ENUM_TRAILING_PARAMS(BOOST_PP_SUB(BOOST_PROTO_MAX_ARITY, N), void
BOOST_PP_INTERCEPT), void
+ >
+ >
+ {
+ typedef expr<Tag, BOOST_PP_CAT(args,
N)<BOOST_PP_ENUM_PARAMS(N, A)> > type;
+ typedef type proto_base_expr;
+ typedef Tag proto_tag;
+ 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 op
namespace detail
{
@@ -726,7 +732,6 @@
{};
}
-
#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
