Subject: [Boost-commit] svn:boost r57159 - in trunk: boost/proto boost/proto/context boost/proto/detail boost/proto/transform libs/proto/test
From: eric_at_[hidden]
Date: 2009-10-26 11:15:10
Author: eric_niebler
Date: 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
New Revision: 57159
URL: http://svn.boost.org/trac/boost/changeset/57159
Log:
accomodate recent change to fusion::fold, remove old support for Doxygen and pre-1.35 Fusion, fixes #3553
Removed:
trunk/boost/proto/detail/prefix.hpp
trunk/boost/proto/detail/suffix.hpp
Text files modified:
trunk/boost/proto/args.hpp | 61 ++---
trunk/boost/proto/context.hpp | 2
trunk/boost/proto/context/callable.hpp | 6
trunk/boost/proto/context/default.hpp | 6
trunk/boost/proto/context/null.hpp | 4
trunk/boost/proto/core.hpp | 2
trunk/boost/proto/debug.hpp | 2
trunk/boost/proto/deep_copy.hpp | 2
trunk/boost/proto/detail/as_lvalue.hpp | 2
trunk/boost/proto/detail/decltype.hpp | 21 -
trunk/boost/proto/detail/deprecated.hpp | 2
trunk/boost/proto/domain.hpp | 153 +++++++-------
trunk/boost/proto/eval.hpp | 2
trunk/boost/proto/expr.hpp | 13
trunk/boost/proto/extends.hpp | 344 ++++++++++++++++-----------------
trunk/boost/proto/fusion.hpp | 66 -----
trunk/boost/proto/generate.hpp | 405 +++++++++++++++++++--------------------
trunk/boost/proto/literal.hpp | 4
trunk/boost/proto/make_expr.hpp | 62 ++---
trunk/boost/proto/matches.hpp | 12
trunk/boost/proto/operators.hpp | 112 +++++-----
trunk/boost/proto/proto.hpp | 2
trunk/boost/proto/proto_fwd.hpp | 83 +-------
trunk/boost/proto/proto_typeof.hpp | 2
trunk/boost/proto/repeat.hpp | 2
trunk/boost/proto/tags.hpp | 2
trunk/boost/proto/traits.hpp | 26 +-
trunk/boost/proto/transform.hpp | 2
trunk/boost/proto/transform/arg.hpp | 2
trunk/boost/proto/transform/call.hpp | 2
trunk/boost/proto/transform/default.hpp | 4
trunk/boost/proto/transform/fold.hpp | 60 -----
trunk/boost/proto/transform/fold_tree.hpp | 2
trunk/boost/proto/transform/impl.hpp | 2
trunk/boost/proto/transform/lazy.hpp | 2
trunk/boost/proto/transform/make.hpp | 2
trunk/boost/proto/transform/pass_through.hpp | 2
trunk/boost/proto/transform/when.hpp | 4
trunk/libs/proto/test/examples.cpp | 11
trunk/libs/proto/test/lambda.cpp | 13 -
trunk/libs/proto/test/make_expr.cpp | 5
trunk/libs/proto/test/proto_fusion.cpp | 5
trunk/libs/proto/test/proto_fusion_s.cpp | 5
trunk/libs/proto/test/toy_spirit2.cpp | 26 --
44 files changed, 626 insertions(+), 923 deletions(-)
Modified: trunk/boost/proto/args.hpp
==============================================================================
--- trunk/boost/proto/args.hpp (original)
+++ trunk/boost/proto/args.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -11,7 +11,6 @@
#ifndef BOOST_PROTO_ARGS_HPP_EAN_04_01_2005
#define BOOST_PROTO_ARGS_HPP_EAN_04_01_2005
- #include <boost/proto/detail/prefix.hpp>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/preprocessor/cat.hpp>
@@ -24,7 +23,6 @@
#include <boost/mpl/if.hpp>
#include <boost/mpl/void.hpp>
#include <boost/proto/proto_fwd.hpp>
- #include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
@@ -123,46 +121,45 @@
}
////////////////////////////////////////////////////////////////////////////////////////////
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(argsns_)
-
- #define BOOST_PROTO_DEFINE_CHILD_N(Z, N, DATA) \
- typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(child, N); \
- /**< INTERNAL ONLY */
-
- #define BOOST_PROTO_DEFINE_VOID_N(z, n, data) \
- typedef mpl::void_ BOOST_PP_CAT(child, n); \
- /**< INTERNAL ONLY */
-
- /// \brief A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
- ///
- /// A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
- /// The types in the sequence correspond to the children of a node in an expression tree.
- template< typename Arg0 >
- struct term
+ namespace argsns_
{
- BOOST_STATIC_CONSTANT(long, arity = 0);
- typedef Arg0 child0;
- #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
- BOOST_PP_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_DEFINE_VOID_N, ~)
- #endif
+ #define BOOST_PROTO_DEFINE_CHILD_N(Z, N, DATA) \
+ typedef BOOST_PP_CAT(Arg, N) BOOST_PP_CAT(child, N); \
+ /**< INTERNAL ONLY */
+
+ #define BOOST_PROTO_DEFINE_VOID_N(z, n, data) \
+ typedef mpl::void_ BOOST_PP_CAT(child, n); \
+ /**< INTERNAL ONLY */
- /// INTERNAL ONLY
+ /// \brief A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
///
- typedef Arg0 back_;
- };
+ /// A type sequence, for use as the 2nd parameter to the \c expr\<\> class template.
+ /// The types in the sequence correspond to the children of a node in an expression tree.
+ template< typename Arg0 >
+ struct term
+ {
+ BOOST_STATIC_CONSTANT(long, arity = 0);
+ typedef Arg0 child0;
+
+ #if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+ BOOST_PP_REPEAT_FROM_TO(1, BOOST_PROTO_MAX_ARITY, BOOST_PROTO_DEFINE_VOID_N, ~)
+ #endif
+
+ /// INTERNAL ONLY
+ ///
+ typedef Arg0 back_;
+ };
- #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/args.hpp>))
- #include BOOST_PP_ITERATE()
+ #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/args.hpp>))
+ #include BOOST_PP_ITERATE()
- #undef BOOST_PROTO_DEFINE_CHILD_N
+ #undef BOOST_PROTO_DEFINE_CHILD_N
- BOOST_PROTO_END_ADL_NAMESPACE(argsns_)
+ }
////////////////////////////////////////////////////////////////////////////////////////////
- #ifndef BOOST_PROTO_BUILDING_DOCS
using namespace argsns_;
- #endif
}}
#endif
Modified: trunk/boost/proto/context.hpp
==============================================================================
--- trunk/boost/proto/context.hpp (original)
+++ trunk/boost/proto/context.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,10 +9,8 @@
#ifndef BOOST_PROTO_CONTEXT_HPP_EAN_06_23_2007
#define BOOST_PROTO_CONTEXT_HPP_EAN_06_23_2007
-#include <boost/proto/detail/prefix.hpp> // must be first include
#include <boost/proto/context/null.hpp>
#include <boost/proto/context/default.hpp>
#include <boost/proto/context/callable.hpp>
-#include <boost/proto/detail/suffix.hpp> // must be last include
#endif
Modified: trunk/boost/proto/context/callable.hpp
==============================================================================
--- trunk/boost/proto/context/callable.hpp (original)
+++ trunk/boost/proto/context/callable.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -14,7 +14,6 @@
#ifndef BOOST_PROTO_CONTEXT_CALLABLE_HPP_EAN_06_23_2007
#define BOOST_PROTO_CONTEXT_CALLABLE_HPP_EAN_06_23_2007
- #include <boost/proto/detail/prefix.hpp> // must be first include
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/preprocessor/cat.hpp>
@@ -32,7 +31,6 @@
#include <boost/type_traits/remove_cv.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/traits.hpp> // for child_c
- #include <boost/proto/detail/suffix.hpp> // must be last include
namespace boost { namespace proto
{
@@ -86,7 +84,7 @@
template<
typename Expr
, typename Context
- , long Arity BOOST_PROTO_WHEN_BUILDING_DOCS(= Expr::proto_arity_c)
+ , long Arity // = Expr::proto_arity_c
>
struct callable_eval
{};
@@ -191,7 +189,7 @@
/// \endcode
template<
typename Context
- , typename DefaultCtx BOOST_PROTO_WHEN_BUILDING_DOCS(= default_context)
+ , typename DefaultCtx // = default_context
>
struct callable_context
{
Modified: trunk/boost/proto/context/default.hpp
==============================================================================
--- trunk/boost/proto/context/default.hpp (original)
+++ trunk/boost/proto/context/default.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -12,7 +12,6 @@
#ifndef BOOST_PROTO_CONTEXT_DEFAULT_HPP_EAN_01_08_2007
#define BOOST_PROTO_CONTEXT_DEFAULT_HPP_EAN_01_08_2007
- #include <boost/proto/detail/prefix.hpp> // must be first include
#include <boost/config.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition/enum_shifted.hpp>
@@ -28,7 +27,6 @@
#include <boost/proto/eval.hpp>
#include <boost/proto/traits.hpp> // for proto::child_c()
#include <boost/proto/detail/decltype.hpp>
- #include <boost/proto/detail/suffix.hpp> // must be last include
namespace boost { namespace proto
{
@@ -41,8 +39,8 @@
template<
typename Expr
, typename Context
- , typename Tag BOOST_PROTO_WHEN_BUILDING_DOCS(= typename Expr::proto_tag)
- , long Arity BOOST_PROTO_WHEN_BUILDING_DOCS(= Expr::proto_arity_c)
+ , typename Tag // = typename Expr::proto_tag
+ , long Arity // = Expr::proto_arity_c
>
struct default_eval
{};
Modified: trunk/boost/proto/context/null.hpp
==============================================================================
--- trunk/boost/proto/context/null.hpp (original)
+++ trunk/boost/proto/context/null.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -12,13 +12,11 @@
#ifndef BOOST_PROTO_CONTEXT_NULL_HPP_EAN_06_24_2007
#define BOOST_PROTO_CONTEXT_NULL_HPP_EAN_06_24_2007
- #include <boost/proto/detail/prefix.hpp> // must be first include
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/eval.hpp>
#include <boost/proto/traits.hpp>
- #include <boost/proto/detail/suffix.hpp> // must be last include
namespace boost { namespace proto { namespace context
{
@@ -26,7 +24,7 @@
template<
typename Expr
, typename Context
- , long Arity BOOST_PROTO_WHEN_BUILDING_DOCS(= Expr::proto_arity_c)
+ , long Arity // = Expr::proto_arity_c
>
struct null_eval
{};
Modified: trunk/boost/proto/core.hpp
==============================================================================
--- trunk/boost/proto/core.hpp (original)
+++ trunk/boost/proto/core.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -10,7 +10,6 @@
#ifndef BOOST_PROTO_CORE_HPP_EAN_04_01_2005
#define BOOST_PROTO_CORE_HPP_EAN_04_01_2005
-#include <boost/proto/detail/prefix.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/args.hpp>
#include <boost/proto/tags.hpp>
@@ -27,6 +26,5 @@
#include <boost/proto/operators.hpp>
#include <boost/proto/deep_copy.hpp>
#include <boost/proto/make_expr.hpp>
-#include <boost/proto/detail/suffix.hpp>
#endif
Modified: trunk/boost/proto/debug.hpp
==============================================================================
--- trunk/boost/proto/debug.hpp (original)
+++ trunk/boost/proto/debug.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,7 +9,6 @@
#ifndef BOOST_PROTO_DEBUG_HPP_EAN_12_31_2006
#define BOOST_PROTO_DEBUG_HPP_EAN_12_31_2006
-#include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/iteration/local.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <iomanip>
@@ -19,7 +18,6 @@
#include <boost/proto/expr.hpp>
#include <boost/proto/traits.hpp>
#include <boost/proto/detail/dont_care.hpp>
-#include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
Modified: trunk/boost/proto/deep_copy.hpp
==============================================================================
--- trunk/boost/proto/deep_copy.hpp (original)
+++ trunk/boost/proto/deep_copy.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -10,7 +10,6 @@
#ifndef BOOST_PROTO_DEEP_COPY_HPP_EAN_11_21_2006
#define BOOST_PROTO_DEEP_COPY_HPP_EAN_11_21_2006
- #include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
@@ -19,7 +18,6 @@
#include <boost/type_traits/remove_reference.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/expr.hpp>
- #include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
Modified: trunk/boost/proto/detail/as_lvalue.hpp
==============================================================================
--- trunk/boost/proto/detail/as_lvalue.hpp (original)
+++ trunk/boost/proto/detail/as_lvalue.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,9 +9,7 @@
#ifndef BOOST_PROTO_TRANSFORM_AS_LVALUE_HPP_EAN_12_27_2007
#define BOOST_PROTO_TRANSFORM_AS_LVALUE_HPP_EAN_12_27_2007
-#include <boost/proto/detail/prefix.hpp>
#include <boost/proto/proto_fwd.hpp>
-#include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
Modified: trunk/boost/proto/detail/decltype.hpp
==============================================================================
--- trunk/boost/proto/detail/decltype.hpp (original)
+++ trunk/boost/proto/detail/decltype.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,7 +9,6 @@
#ifndef BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008
#define BOOST_PROTO_DETAIL_DECLTYPE_HPP_EAN_04_04_2008
-#include <boost/proto/detail/prefix.hpp> // must be first include
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/get_pointer.hpp>
@@ -35,15 +34,11 @@
#include <boost/utility/result_of.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/proto/repeat.hpp>
-#include <boost/proto/detail/suffix.hpp> // must be last include
-// If we're generating doxygen documentation, hide all the nasty
-// Boost.Typeof gunk.
-#ifndef BOOST_PROTO_BUILDING_DOCS
-# ifdef BOOST_HAS_DECLTYPE
-# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) typedef decltype(EXPR) TYPE;
-# else
-# define BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(NESTED, EXPR) \
+#ifdef BOOST_HAS_DECLTYPE
+# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) typedef decltype(EXPR) TYPE;
+#else
+# define BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(NESTED, EXPR) \
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(BOOST_PP_CAT(nested_and_hidden_, NESTED), EXPR) \
static int const sz = sizeof(boost::proto::detail::check_reference(EXPR)); \
struct NESTED \
@@ -53,15 +48,9 @@
, typename BOOST_PP_CAT(nested_and_hidden_, NESTED)::type \
> \
{};
-# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) \
+# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) \
BOOST_PROTO_DECLTYPE_NESTED_TYPEDEF_TPL_(BOOST_PP_CAT(nested_, TYPE), (EXPR)) \
typedef typename BOOST_PP_CAT(nested_, TYPE)::type TYPE;
-# endif
-#else
-/// INTERNAL ONLY
-///
-# define BOOST_PROTO_DECLTYPE_(EXPR, TYPE) \
- typedef detail::unspecified TYPE;
#endif
namespace boost { namespace proto
Modified: trunk/boost/proto/detail/deprecated.hpp
==============================================================================
--- trunk/boost/proto/detail/deprecated.hpp (original)
+++ trunk/boost/proto/detail/deprecated.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -10,7 +10,6 @@
#ifndef BOOST_PROTO_DETAIL_DEPRECATED_HPP_EAN_11_25_2008
#define BOOST_PROTO_DETAIL_DEPRECATED_HPP_EAN_11_25_2008
-#include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/facilities/intercept.hpp>
#include <boost/preprocessor/arithmetic/inc.hpp>
@@ -37,7 +36,6 @@
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
#include <boost/proto/proto_fwd.hpp>
-#include <boost/proto/detail/suffix.hpp>
/// INTERNAL ONLY
///
Deleted: trunk/boost/proto/detail/prefix.hpp
==============================================================================
--- trunk/boost/proto/detail/prefix.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
+++ (empty file)
@@ -1,10 +0,0 @@
-#if defined(__WAVE__) && defined(BOOST_PROTO_BUILDING_DOCS)
-#pragma wave option(output:push)
-#pragma wave option(output:null)
-#endif
-
-///////////////////////////////////////////////////////////////////////////////
-// Copyright 2008 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)
-///////////////////////////////////////////////////////////////////////////////
Deleted: trunk/boost/proto/detail/suffix.hpp
==============================================================================
--- trunk/boost/proto/detail/suffix.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
+++ (empty file)
@@ -1,16 +0,0 @@
-///////////////////////////////////////////////////////////////////////////////
-// Copyright 2008 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)
-///////////////////////////////////////////////////////////////////////////////
-
-#if defined(__WAVE__) && defined(BOOST_PROTO_BUILDING_DOCS)
-#pragma wave option(output:pop)
-#endif
-
-#ifndef BOOST_PROTO_SUFFIX_DUMMY_STRUCT_DEFINED
-#define BOOST_PROTO_SUFFIX_DUMMY_STRUCT_DEFINED
-/// INTERNAL ONLY
-///
-struct a_dummy_struct;
-#endif
Modified: trunk/boost/proto/domain.hpp
==============================================================================
--- trunk/boost/proto/domain.hpp (original)
+++ trunk/boost/proto/domain.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -11,12 +11,10 @@
#ifndef BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007
#define BOOST_PROTO_DOMAIN_HPP_EAN_02_13_2007
-#include <boost/proto/detail/prefix.hpp>
#include <boost/ref.hpp>
#include <boost/mpl/bool.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/generate.hpp>
-#include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
@@ -30,84 +28,83 @@
{};
}
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(domainns_)
-
- /// \brief For use in defining domain tags to be used
- /// with \c proto::extends\<\>. A \e Domain associates
- /// an expression type with a \e Generator, and optionally
- /// a \e Grammar.
- ///
- /// The Generator determines how new expressions in the
- /// domain are constructed. Typically, a generator wraps
- /// all new expressions in a wrapper that imparts
- /// domain-specific behaviors to expressions within its
- /// domain. (See \c proto::extends\<\>.)
- ///
- /// The Grammar determines whether a given expression is
- /// valid within the domain, and automatically disables
- /// any operator overloads which would cause an invalid
- /// expression to be created. By default, the Grammar
- /// parameter defaults to the wildcard, \c proto::_, which
- /// makes all expressions valid within the domain.
- ///
- /// Example:
- /// \code
- /// template<typename Expr>
- /// struct MyExpr;
- ///
- /// struct MyGrammar
- /// : or_< terminal<_>, plus<MyGrammar, MyGrammar> >
- /// {};
- ///
- /// // Define MyDomain, in which all expressions are
- /// // wrapped in MyExpr<> and only expressions that
- /// // conform to MyGrammar are allowed.
- /// struct MyDomain
- /// : domain<generator<MyExpr>, MyGrammar>
- /// {};
- ///
- /// // Use MyDomain to define MyExpr
- /// template<typename Expr>
- /// struct MyExpr
- /// : extends<Expr, MyExpr<Expr>, MyDomain>
- /// {
- /// // ...
- /// };
- /// \endcode
- ///
- template<
- typename Generator BOOST_PROTO_WHEN_BUILDING_DOCS(= default_generator)
- , typename Grammar BOOST_PROTO_WHEN_BUILDING_DOCS(= proto::_)
- >
- struct domain
- : Generator
+ namespace domainns_
{
- typedef Grammar proto_grammar;
+ /// \brief For use in defining domain tags to be used
+ /// with \c proto::extends\<\>. A \e Domain associates
+ /// an expression type with a \e Generator, and optionally
+ /// a \e Grammar.
+ ///
+ /// The Generator determines how new expressions in the
+ /// domain are constructed. Typically, a generator wraps
+ /// all new expressions in a wrapper that imparts
+ /// domain-specific behaviors to expressions within its
+ /// domain. (See \c proto::extends\<\>.)
+ ///
+ /// The Grammar determines whether a given expression is
+ /// valid within the domain, and automatically disables
+ /// any operator overloads which would cause an invalid
+ /// expression to be created. By default, the Grammar
+ /// parameter defaults to the wildcard, \c proto::_, which
+ /// makes all expressions valid within the domain.
+ ///
+ /// Example:
+ /// \code
+ /// template<typename Expr>
+ /// struct MyExpr;
+ ///
+ /// struct MyGrammar
+ /// : or_< terminal<_>, plus<MyGrammar, MyGrammar> >
+ /// {};
+ ///
+ /// // Define MyDomain, in which all expressions are
+ /// // wrapped in MyExpr<> and only expressions that
+ /// // conform to MyGrammar are allowed.
+ /// struct MyDomain
+ /// : domain<generator<MyExpr>, MyGrammar>
+ /// {};
+ ///
+ /// // Use MyDomain to define MyExpr
+ /// template<typename Expr>
+ /// struct MyExpr
+ /// : extends<Expr, MyExpr<Expr>, MyDomain>
+ /// {
+ /// // ...
+ /// };
+ /// \endcode
+ ///
+ template<
+ typename Generator // = default_generator
+ , typename Grammar // = proto::_
+ >
+ struct domain
+ : Generator
+ {
+ typedef Grammar proto_grammar;
- /// INTERNAL ONLY
- typedef void proto_is_domain_;
- };
+ /// INTERNAL ONLY
+ typedef void proto_is_domain_;
+ };
- /// \brief The domain expressions have by default, if
- /// \c proto::extends\<\> has not been used to associate
- /// a domain with an expression.
- ///
- struct default_domain
- : domain<>
- {};
-
- /// \brief A pseudo-domain for use in functions and
- /// metafunctions that require a domain parameter. It
- /// indicates that the domain of the parent node should
- /// be inferred from the domains of the child nodes.
- ///
- /// \attention \c deduce_domain is not itself a valid domain.
- ///
- struct deduce_domain
- : domain<detail::not_a_generator, detail::not_a_grammar>
- {};
+ /// \brief The domain expressions have by default, if
+ /// \c proto::extends\<\> has not been used to associate
+ /// a domain with an expression.
+ ///
+ struct default_domain
+ : domain<>
+ {};
- BOOST_PROTO_END_ADL_NAMESPACE(domainns_)
+ /// \brief A pseudo-domain for use in functions and
+ /// metafunctions that require a domain parameter. It
+ /// indicates that the domain of the parent node should
+ /// be inferred from the domains of the child nodes.
+ ///
+ /// \attention \c deduce_domain is not itself a valid domain.
+ ///
+ struct deduce_domain
+ : domain<detail::not_a_generator, detail::not_a_grammar>
+ {};
+ }
namespace result_of
{
@@ -116,7 +113,7 @@
/// \c mpl::false_ otherwise. If \c T inherits from
/// \c proto::domain\<\>, \c is_domain\<T\> is
/// \c mpl::true_.
- template<typename T, typename Void BOOST_PROTO_WHEN_BUILDING_DOCS(= void)>
+ template<typename T, typename Void /* = void*/>
struct is_domain
: mpl::false_
{};
@@ -133,7 +130,7 @@
/// type, it returns that expression's associated
/// domain. If not, it returns
/// \c proto::default_domain.
- template<typename T, typename Void BOOST_PROTO_WHEN_BUILDING_DOCS(= void)>
+ template<typename T, typename Void /* = void*/>
struct domain_of
{
typedef default_domain type;
Modified: trunk/boost/proto/eval.hpp
==============================================================================
--- trunk/boost/proto/eval.hpp (original)
+++ trunk/boost/proto/eval.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,10 +9,8 @@
#ifndef BOOST_PROTO_EVAL_HPP_EAN_03_29_2007
#define BOOST_PROTO_EVAL_HPP_EAN_03_29_2007
-#include <boost/proto/detail/prefix.hpp> // must be first include
#include <boost/proto/proto_fwd.hpp> // BOOST_PROTO_CALLABLE
#include <boost/type_traits/remove_reference.hpp>
-#include <boost/proto/detail/suffix.hpp> // must be last include
namespace boost { namespace proto
{
Modified: trunk/boost/proto/expr.hpp
==============================================================================
--- trunk/boost/proto/expr.hpp (original)
+++ trunk/boost/proto/expr.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -10,7 +10,6 @@
#ifndef BOOST_PROTO_EXPR_HPP_EAN_04_01_2005
#define BOOST_PROTO_EXPR_HPP_EAN_04_01_2005
- #include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/selection/max.hpp>
@@ -26,7 +25,6 @@
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/args.hpp>
#include <boost/proto/traits.hpp>
- #include <boost/proto/detail/suffix.hpp>
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma warning(push)
@@ -136,10 +134,11 @@
// a basic_expr because they should be layout compatible. Or not, because
// that would incur an extra template instantiation. :-(
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(exprns_)
- #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/expr.hpp>))
- #include BOOST_PP_ITERATE()
- BOOST_PROTO_END_ADL_NAMESPACE(exprns_)
+ namespace exprns_
+ {
+ #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/expr.hpp>))
+ #include BOOST_PP_ITERATE()
+ }
#undef BOOST_PROTO_CHILD
#undef BOOST_PROTO_VOID
@@ -221,7 +220,7 @@
typedef BOOST_PP_CAT(list, BOOST_PP_ITERATION())<BOOST_PP_ENUM_PARAMS(ARG_COUNT, Arg)> proto_args;
#endif
typedef default_domain proto_domain;
- BOOST_PROTO_FUSION_DEFINE_TAG(proto::tag::proto_expr)
+ typedef proto::tag::proto_expr fusion_tag;
typedef expr proto_derived_expr;
typedef void proto_is_expr_; /**< INTERNAL ONLY */
Modified: trunk/boost/proto/extends.hpp
==============================================================================
--- trunk/boost/proto/extends.hpp (original)
+++ trunk/boost/proto/extends.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,7 +9,6 @@
#ifndef BOOST_PROTO_EXTENDS_HPP_EAN_11_1_2006
#define BOOST_PROTO_EXTENDS_HPP_EAN_11_1_2006
-#include <boost/proto/detail/prefix.hpp>
#include <cstddef> // for offsetof
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/preprocessor/control/if.hpp>
@@ -30,7 +29,6 @@
#include <boost/proto/args.hpp>
#include <boost/proto/traits.hpp>
#include <boost/proto/generate.hpp>
-#include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
@@ -158,7 +156,7 @@
typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_; \
typedef void proto_is_expr_; /**< INTERNAL ONLY */ \
BOOST_STATIC_CONSTANT(long, proto_arity_c = proto_base_expr::proto_arity_c); \
- BOOST_PROTO_FUSION_DEFINE_TAG(boost::proto::tag::proto_expr) \
+ typedef boost::proto::tag::proto_expr fusion_tag; \
BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_CHILD, ~) \
\
static proto_derived_expr const make(Expr const &e) \
@@ -413,192 +411,192 @@
BOOST_PROTO_EXTENDS_FUNCTION() \
/**/
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(exprns_)
-
- /// \brief Empty type to be used as a dummy template parameter of
- /// POD expression wrappers. It allows argument-dependent lookup
- /// to find Proto's operator overloads.
- ///
- /// \c proto::is_proto_expr allows argument-dependent lookup
- /// to find Proto's operator overloads. For example:
- ///
- /// \code
- /// template<typename T, typename Dummy = proto::is_proto_expr>
- /// struct my_terminal
- /// {
- /// BOOST_PROTO_BASIC_EXTENDS(
- /// typename proto::terminal<T>::type
- /// , my_terminal<T>
- /// , default_domain
- /// )
- /// };
- ///
- /// // ...
- /// my_terminal<int> _1, _2;
- /// _1 + _2; // OK, uses proto::operator+
- /// \endcode
- ///
- /// Without the second \c Dummy template parameter, Proto's operator
- /// overloads would not be considered by name lookup.
- struct is_proto_expr
- {};
-
- /// \brief extends\<\> class template for adding behaviors to a Proto expression template
- ///
- template<
- typename Expr
- , typename Derived
- , typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= proto::default_domain)
- , long Arity BOOST_PROTO_WHEN_BUILDING_DOCS(= Expr::proto_arity_c)
- >
- struct extends
+ namespace exprns_
{
- extends()
- : proto_expr_()
- {}
-
- extends(extends const &that)
- : proto_expr_(that.proto_expr_)
- {}
-
- extends(Expr const &expr_)
- : proto_expr_(expr_)
- {}
-
- BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain)
- BOOST_PROTO_EXTENDS_ASSIGN_CONST()
- BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST()
-
- // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
- // nested preprocessor loops, use file iteration here to generate
- // the operator() overloads, which is more efficient.
- BOOST_PROTO_EXTENDS_FUNCTION_()
-
- #ifdef BOOST_HAS_VARIADIC_TMPL
- BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(1)
- #else
- /// INTERNAL ONLY
+ /// \brief Empty type to be used as a dummy template parameter of
+ /// POD expression wrappers. It allows argument-dependent lookup
+ /// to find Proto's operator overloads.
///
- #define BOOST_PP_LOCAL_MACRO(N) \
- BOOST_PROTO_DEFINE_FUN_OP_CONST(1, N, ~) \
- /**/
-
- /// INTERNAL ONLY
+ /// \c proto::is_proto_expr allows argument-dependent lookup
+ /// to find Proto's operator overloads. For example:
///
- #define BOOST_PP_LOCAL_LIMITS (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY))
- #include BOOST_PP_LOCAL_ITERATE()
-
- #endif
- };
-
- /// \brief extends\<\> class template for adding behaviors to a Proto expression template
- ///
- template<typename Expr, typename Derived, typename Domain>
- struct extends<Expr, Derived, Domain, 0>
- {
- extends()
- : proto_expr_()
- {}
-
- extends(extends const &that)
- : proto_expr_(that.proto_expr_)
- {}
-
- extends(Expr const &expr_)
- : proto_expr_(expr_)
- {}
-
- BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain)
- BOOST_PROTO_EXTENDS_ASSIGN()
- BOOST_PROTO_EXTENDS_SUBSCRIPT()
-
- // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
- // nested preprocessor loops, use file iteration here to generate
- // the operator() overloads, which is more efficient.
- BOOST_PROTO_EXTENDS_FUNCTION_()
-
- #ifdef BOOST_HAS_VARIADIC_TMPL
- BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(0)
- BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(1)
- #else
-
- /// INTERNAL ONLY
+ /// \code
+ /// template<typename T, typename Dummy = proto::is_proto_expr>
+ /// struct my_terminal
+ /// {
+ /// BOOST_PROTO_BASIC_EXTENDS(
+ /// typename proto::terminal<T>::type
+ /// , my_terminal<T>
+ /// , default_domain
+ /// )
+ /// };
///
- #define BOOST_PP_LOCAL_MACRO(N) \
- BOOST_PROTO_DEFINE_FUN_OP(1, N, ~) \
- /**/
+ /// // ...
+ /// my_terminal<int> _1, _2;
+ /// _1 + _2; // OK, uses proto::operator+
+ /// \endcode
+ ///
+ /// Without the second \c Dummy template parameter, Proto's operator
+ /// overloads would not be considered by name lookup.
+ struct is_proto_expr
+ {};
- /// INTERNAL ONLY
+ /// \brief extends\<\> class template for adding behaviors to a Proto expression template
///
- #define BOOST_PP_LOCAL_LIMITS (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY))
- #include BOOST_PP_LOCAL_ITERATE()
+ template<
+ typename Expr
+ , typename Derived
+ , typename Domain // = proto::default_domain
+ , long Arity // = Expr::proto_arity_c
+ >
+ struct extends
+ {
+ extends()
+ : proto_expr_()
+ {}
+
+ extends(extends const &that)
+ : proto_expr_(that.proto_expr_)
+ {}
+
+ extends(Expr const &expr_)
+ : proto_expr_(expr_)
+ {}
+
+ BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain)
+ BOOST_PROTO_EXTENDS_ASSIGN_CONST()
+ BOOST_PROTO_EXTENDS_SUBSCRIPT_CONST()
+
+ // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
+ // nested preprocessor loops, use file iteration here to generate
+ // the operator() overloads, which is more efficient.
+ BOOST_PROTO_EXTENDS_FUNCTION_()
+
+ #ifdef BOOST_HAS_VARIADIC_TMPL
+ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(1)
+ #else
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PP_LOCAL_MACRO(N) \
+ BOOST_PROTO_DEFINE_FUN_OP_CONST(1, N, ~) \
+ /**/
- #endif
- };
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PP_LOCAL_LIMITS (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY))
+ #include BOOST_PP_LOCAL_ITERATE()
- /// INTERNAL ONLY
- ///
- template<typename This, typename Fun, typename Domain>
- struct virtual_member
- {
- typedef
- expr<tag::member, list2<This &, expr<tag::terminal, term<Fun> > const &>, 2>
- proto_base_expr;
- typedef Domain proto_domain;
- typedef virtual_member<This, Fun, Domain> proto_derived_expr;
- typedef typename proto_base_expr::proto_tag proto_tag;
- typedef typename proto_base_expr::proto_args proto_args;
- typedef typename proto_base_expr::proto_arity proto_arity;
- typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_;
- typedef void proto_is_expr_; /**< INTERNAL ONLY */
- BOOST_STATIC_CONSTANT(long, proto_arity_c = proto_base_expr::proto_arity_c);
- BOOST_PROTO_FUSION_DEFINE_TAG(boost::proto::tag::proto_expr)
- BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_CHILD, ~)
- typedef void proto_is_aggregate_; /**< INTERNAL ONLY */
-
- BOOST_PROTO_EXTENDS_ASSIGN()
- BOOST_PROTO_EXTENDS_SUBSCRIPT()
- BOOST_PROTO_EXTENDS_FUNCTION()
+ #endif
+ };
- proto_base_expr const proto_base() const
+ /// \brief extends\<\> class template for adding behaviors to a Proto expression template
+ ///
+ template<typename Expr, typename Derived, typename Domain>
+ struct extends<Expr, Derived, Domain, 0>
{
- proto_base_expr that = {this->child0(), this->child1()};
- return that;
- }
+ extends()
+ : proto_expr_()
+ {}
+
+ extends(extends const &that)
+ : proto_expr_(that.proto_expr_)
+ {}
+
+ extends(Expr const &expr_)
+ : proto_expr_(expr_)
+ {}
+
+ BOOST_PROTO_BASIC_EXTENDS_(Expr, Derived, Domain)
+ BOOST_PROTO_EXTENDS_ASSIGN()
+ BOOST_PROTO_EXTENDS_SUBSCRIPT()
+
+ // Instead of using BOOST_PROTO_EXTENDS_FUNCTION, which uses
+ // nested preprocessor loops, use file iteration here to generate
+ // the operator() overloads, which is more efficient.
+ BOOST_PROTO_EXTENDS_FUNCTION_()
+
+ #ifdef BOOST_HAS_VARIADIC_TMPL
+ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(0)
+ BOOST_PROTO_DEFINE_FUN_OP_VARIADIC_IMPL_(1)
+ #else
+
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PP_LOCAL_MACRO(N) \
+ BOOST_PROTO_DEFINE_FUN_OP(1, N, ~) \
+ /**/
- proto_child0 child0() const
- {
- return *(This *)((char *)this - BOOST_PROTO_OFFSETOF(This, proto_member_union_start_));
- }
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PP_LOCAL_LIMITS (0, BOOST_PP_DEC(BOOST_PROTO_MAX_FUNCTION_CALL_ARITY))
+ #include BOOST_PP_LOCAL_ITERATE()
+
+ #endif
+ };
- proto_child1 child1() const
+ /// INTERNAL ONLY
+ ///
+ template<typename This, typename Fun, typename Domain>
+ struct virtual_member
{
- static expr<tag::terminal, term<Fun>, 0> const that = {Fun()};
- return that;
- }
- };
+ typedef
+ expr<tag::member, list2<This &, expr<tag::terminal, term<Fun> > const &>, 2>
+ proto_base_expr;
+ typedef Domain proto_domain;
+ typedef virtual_member<This, Fun, Domain> proto_derived_expr;
+ typedef typename proto_base_expr::proto_tag proto_tag;
+ typedef typename proto_base_expr::proto_args proto_args;
+ typedef typename proto_base_expr::proto_arity proto_arity;
+ typedef typename proto_base_expr::address_of_hack_type_ proto_address_of_hack_type_;
+ typedef void proto_is_expr_; /**< INTERNAL ONLY */
+ BOOST_STATIC_CONSTANT(long, proto_arity_c = proto_base_expr::proto_arity_c);
+ typedef boost::proto::tag::proto_expr fusion_tag;
+ BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, BOOST_PROTO_EXTENDS_CHILD, ~)
+ typedef void proto_is_aggregate_; /**< INTERNAL ONLY */
+
+ BOOST_PROTO_EXTENDS_ASSIGN()
+ BOOST_PROTO_EXTENDS_SUBSCRIPT()
+ BOOST_PROTO_EXTENDS_FUNCTION()
+
+ proto_base_expr const proto_base() const
+ {
+ proto_base_expr that = {this->child0(), this->child1()};
+ return that;
+ }
+
+ proto_child0 child0() const
+ {
+ return *(This *)((char *)this - BOOST_PROTO_OFFSETOF(This, proto_member_union_start_));
+ }
+
+ proto_child1 child1() const
+ {
+ static expr<tag::terminal, term<Fun>, 0> const that = {Fun()};
+ return that;
+ }
+ };
- /// INTERNAL ONLY
- ///
- #define BOOST_PROTO_EXTENDS_MEMBER_(R, DATA, ELEM) \
- boost::proto::exprns_::virtual_member< \
- proto_derived_expr \
- , BOOST_PP_TUPLE_ELEM(2, 0, ELEM) \
- , proto_domain \
- > BOOST_PP_TUPLE_ELEM(2, 1, ELEM); \
- /**/
+ /// INTERNAL ONLY
+ ///
+ #define BOOST_PROTO_EXTENDS_MEMBER_(R, DATA, ELEM) \
+ boost::proto::exprns_::virtual_member< \
+ proto_derived_expr \
+ , BOOST_PP_TUPLE_ELEM(2, 0, ELEM) \
+ , proto_domain \
+ > BOOST_PP_TUPLE_ELEM(2, 1, ELEM); \
+ /**/
- /// \brief For declaring virtual data members in an extension class.
- ///
- #define BOOST_PROTO_EXTENDS_MEMBERS(SEQ) \
- union \
- { \
- char proto_member_union_start_; \
- BOOST_PP_SEQ_FOR_EACH(BOOST_PROTO_EXTENDS_MEMBER_, ~, SEQ) \
- }; \
- /**/
+ /// \brief For declaring virtual data members in an extension class.
+ ///
+ #define BOOST_PROTO_EXTENDS_MEMBERS(SEQ) \
+ union \
+ { \
+ char proto_member_union_start_; \
+ BOOST_PP_SEQ_FOR_EACH(BOOST_PROTO_EXTENDS_MEMBER_, ~, SEQ) \
+ }; \
+ /**/
- BOOST_PROTO_END_ADL_NAMESPACE(exprns_)
+ }
}}
Modified: trunk/boost/proto/fusion.hpp
==============================================================================
--- trunk/boost/proto/fusion.hpp (original)
+++ trunk/boost/proto/fusion.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,14 +9,11 @@
#ifndef BOOST_PROTO_FUSION_HPP_EAN_11_04_2006
#define BOOST_PROTO_FUSION_HPP_EAN_11_04_2006
-#include <boost/proto/detail/prefix.hpp>
#include <boost/config.hpp>
-#include <boost/version.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/long.hpp>
#include <boost/mpl/sequence_tag_fwd.hpp>
-#if BOOST_VERSION >= 103500
#include <boost/fusion/include/is_view.hpp>
#include <boost/fusion/include/tag_of_fwd.hpp>
#include <boost/fusion/include/category_of.hpp>
@@ -30,21 +27,9 @@
#include <boost/fusion/sequence/intrinsic/ext_/segments.hpp>
#include <boost/fusion/sequence/intrinsic/ext_/size_s.hpp>
#include <boost/fusion/view/ext_/segmented_iterator.hpp>
-#else
-#include <boost/spirit/fusion/sequence/is_sequence.hpp>
-#include <boost/spirit/fusion/sequence/begin.hpp>
-#include <boost/spirit/fusion/sequence/end.hpp>
-#include <boost/spirit/fusion/sequence/at.hpp>
-#include <boost/spirit/fusion/sequence/value_at.hpp>
-#include <boost/spirit/fusion/sequence/single_view.hpp>
-#include <boost/spirit/fusion/sequence/transform_view.hpp>
-#include <boost/proto/detail/reverse.hpp>
-#include <boost/proto/detail/pop_front.hpp>
-#endif
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/traits.hpp>
#include <boost/proto/eval.hpp>
-#include <boost/proto/detail/suffix.hpp>
#if BOOST_MSVC
#pragma warning(push)
@@ -70,8 +55,8 @@
typedef Expr expr_type;
typedef typename Expr::proto_tag proto_tag;
BOOST_STATIC_CONSTANT(long, index = Pos);
- BOOST_PROTO_FUSION_DEFINE_CATEGORY(fusion::random_access_traversal_tag)
- BOOST_PROTO_FUSION_DEFINE_TAG(tag::proto_expr_iterator)
+ typedef fusion::random_access_traversal_tag category;
+ typedef tag::proto_expr_iterator fusion_tag;
expr_iterator(Expr const &e)
: expr(e)
@@ -85,8 +70,8 @@
{
typedef Expr expr_type;
typedef typename Expr::proto_tag proto_tag;
- BOOST_PROTO_FUSION_DEFINE_CATEGORY(fusion::forward_traversal_tag)
- BOOST_PROTO_FUSION_DEFINE_TAG(tag::proto_flat_view)
+ typedef fusion::forward_traversal_tag category;
+ typedef tag::proto_flat_view fusion_tag;
explicit flat_view(Expr &e)
: expr_(e)
@@ -190,12 +175,12 @@
struct result<This(Expr)>
{
typedef
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::pop_front<UNREF(Expr) const>::type
+ typename fusion::result_of::pop_front<UNREF(Expr) const>::type
type;
};
template<typename Expr>
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::pop_front<Expr const>::type
+ typename fusion::result_of::pop_front<Expr const>::type
operator ()(Expr const &e) const
{
return fusion::pop_front(e);
@@ -221,12 +206,12 @@
struct result<This(Expr)>
{
typedef
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::reverse<UNREF(Expr) const>::type
+ typename fusion::result_of::reverse<UNREF(Expr) const>::type
type;
};
template<typename Expr>
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::reverse<Expr const>::type
+ typename fusion::result_of::reverse<Expr const>::type
operator ()(Expr const &e) const
{
return fusion::reverse(e);
@@ -305,26 +290,9 @@
};
}}
-// Don't bother emitting all this into the Doxygen-generated
-// reference section. It's enough to say that Proto expressions
-// are valid Fusion sequence without showing all this gunk.
-#ifndef BOOST_PROTO_BUILDING_DOCS
-
namespace boost { namespace fusion
{
- #if BOOST_VERSION < 103500
- template<typename Tag, typename Args, long Arity>
- struct is_sequence<proto::expr<Tag, Args, Arity> >
- : mpl::true_
- {};
-
- template<typename Tag, typename Args, long Arity>
- struct is_sequence<proto::expr<Tag, Args, Arity> const>
- : mpl::true_
- {};
- #endif
-
- namespace BOOST_PROTO_FUSION_EXTENSION
+ namespace extension
{
template<typename Tag>
@@ -379,16 +347,6 @@
};
};
- #if BOOST_VERSION < 103500
- template<typename Tag>
- struct value_impl;
-
- template<>
- struct value_impl<proto::tag::proto_expr_iterator>
- : value_of_impl<proto::tag::proto_expr_iterator>
- {};
- #endif
-
template<typename Tag>
struct deref_impl;
@@ -489,7 +447,6 @@
{};
};
- #if BOOST_VERSION >= 103500
template<typename Tag>
struct category_of_impl;
@@ -502,7 +459,6 @@
typedef random_access_traversal_tag type;
};
};
- #endif
template<typename Tag>
struct size_impl;
@@ -631,7 +587,6 @@
};
};
- #if BOOST_VERSION >= 103500
template<typename Tag>
struct is_segmented_impl;
@@ -703,7 +658,6 @@
: fusion::segmented_size<Sequence>
{};
};
- #endif
}
@@ -718,8 +672,6 @@
};
}}
-#endif // BOOST_PROTO_BUILDING_DOCS
-
#undef UNREF
#if BOOST_MSVC
Modified: trunk/boost/proto/generate.hpp
==============================================================================
--- trunk/boost/proto/generate.hpp (original)
+++ trunk/boost/proto/generate.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -11,7 +11,6 @@
#ifndef BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007
#define BOOST_PROTO_GENERATE_HPP_EAN_02_13_2007
- #include <boost/proto/detail/prefix.hpp>
#include <boost/config.hpp>
#include <boost/utility/result_of.hpp>
#include <boost/preprocessor/cat.hpp>
@@ -20,7 +19,6 @@
#include <boost/utility/enable_if.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/args.hpp>
- #include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
@@ -75,242 +73,241 @@
}
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(generatorns_)
-
- /// \brief A simple generator that passes an expression
- /// through unchanged.
- ///
- /// Generators are intended for use as the first template parameter
- /// to the \c domain\<\> class template and control if and how
- /// expressions within that domain are to be customized.
- /// The \c default_generator makes no modifications to the expressions
- /// passed to it.
- struct default_generator
+ namespace generatorns_
{
- BOOST_PROTO_CALLABLE()
-
- template<typename Sig>
- struct result;
-
- template<typename This, typename Expr>
- struct result<This(Expr)>
+ /// \brief A simple generator that passes an expression
+ /// through unchanged.
+ ///
+ /// Generators are intended for use as the first template parameter
+ /// to the \c domain\<\> class template and control if and how
+ /// expressions within that domain are to be customized.
+ /// The \c default_generator makes no modifications to the expressions
+ /// passed to it.
+ struct default_generator
{
- typedef Expr type;
- };
-
- /// \param expr A Proto expression
- /// \return expr
- template<typename Expr>
- #ifdef BOOST_HAS_DECLTYPE
- Expr
- #else
- Expr const &
- #endif
- operator ()(Expr const &e) const
- {
- return e;
- }
- };
-
- /// \brief A generator that wraps expressions passed
- /// to it in the specified extension wrapper.
- ///
- /// Generators are intended for use as the first template parameter
- /// to the \c domain\<\> class template and control if and how
- /// expressions within that domain are to be customized.
- /// \c generator\<\> wraps each expression passed to it in
- /// the \c Extends\<\> wrapper.
- template<template<typename> class Extends>
- struct generator
- {
- BOOST_PROTO_CALLABLE()
+ BOOST_PROTO_CALLABLE()
- template<typename Sig>
- struct result;
+ template<typename Sig>
+ struct result;
- template<typename This, typename Expr>
- struct result<This(Expr)>
- {
- typedef Extends<Expr> type;
- };
+ template<typename This, typename Expr>
+ struct result<This(Expr)>
+ {
+ typedef Expr type;
+ };
- template<typename This, typename Expr>
- struct result<This(Expr &)>
- {
- typedef Extends<Expr> type;
+ /// \param expr A Proto expression
+ /// \return expr
+ template<typename Expr>
+ #ifdef BOOST_HAS_DECLTYPE
+ Expr
+ #else
+ Expr const &
+ #endif
+ operator ()(Expr const &e) const
+ {
+ return e;
+ }
};
- template<typename This, typename Expr>
- struct result<This(Expr const &)>
+ /// \brief A generator that wraps expressions passed
+ /// to it in the specified extension wrapper.
+ ///
+ /// Generators are intended for use as the first template parameter
+ /// to the \c domain\<\> class template and control if and how
+ /// expressions within that domain are to be customized.
+ /// \c generator\<\> wraps each expression passed to it in
+ /// the \c Extends\<\> wrapper.
+ template<template<typename> class Extends>
+ struct generator
{
- typedef Extends<Expr> type;
- };
+ BOOST_PROTO_CALLABLE()
- /// \param expr A Proto expression
- /// \return Extends<Expr>(expr)
- template<typename Expr>
- Extends<Expr> operator ()(Expr const &e) const
- {
- return Extends<Expr>(e);
- }
- };
+ template<typename Sig>
+ struct result;
- /// \brief A generator that wraps expressions passed
- /// to it in the specified extension wrapper and uses
- /// aggregate initialization for the wrapper.
- ///
- /// Generators are intended for use as the first template parameter
- /// to the \c domain\<\> class template and control if and how
- /// expressions within that domain are to be customized.
- /// \c pod_generator\<\> wraps each expression passed to it in
- /// the \c Extends\<\> wrapper, and uses aggregate initialzation
- /// for the wrapped object.
- template<template<typename> class Extends>
- struct pod_generator
- {
- BOOST_PROTO_CALLABLE()
+ template<typename This, typename Expr>
+ struct result<This(Expr)>
+ {
+ typedef Extends<Expr> type;
+ };
- template<typename Sig>
- struct result;
+ template<typename This, typename Expr>
+ struct result<This(Expr &)>
+ {
+ typedef Extends<Expr> type;
+ };
- template<typename This, typename Expr>
- struct result<This(Expr)>
- {
- typedef Extends<Expr> type;
- };
+ template<typename This, typename Expr>
+ struct result<This(Expr const &)>
+ {
+ typedef Extends<Expr> type;
+ };
- template<typename This, typename Expr>
- struct result<This(Expr &)>
- {
- typedef Extends<Expr> type;
+ /// \param expr A Proto expression
+ /// \return Extends<Expr>(expr)
+ template<typename Expr>
+ Extends<Expr> operator ()(Expr const &e) const
+ {
+ return Extends<Expr>(e);
+ }
};
- template<typename This, typename Expr>
- struct result<This(Expr const &)>
+ /// \brief A generator that wraps expressions passed
+ /// to it in the specified extension wrapper and uses
+ /// aggregate initialization for the wrapper.
+ ///
+ /// Generators are intended for use as the first template parameter
+ /// to the \c domain\<\> class template and control if and how
+ /// expressions within that domain are to be customized.
+ /// \c pod_generator\<\> wraps each expression passed to it in
+ /// the \c Extends\<\> wrapper, and uses aggregate initialzation
+ /// for the wrapped object.
+ template<template<typename> class Extends>
+ struct pod_generator
{
- typedef Extends<Expr> type;
- };
+ BOOST_PROTO_CALLABLE()
- /// \param expr The expression to wrap
- /// \return <tt>Extends\<Expr\> that = {expr}; return that;</tt>
- template<typename Expr>
- Extends<Expr> operator ()(Expr const &e) const
- {
- Extends<Expr> that = {e};
- return that;
- }
- };
+ template<typename Sig>
+ struct result;
- /// \brief A generator that replaces child nodes held by
- /// reference with ones held by value. Use with
- /// \c compose_generators to forward that result to another
- /// generator.
- ///
- /// Generators are intended for use as the first template parameter
- /// to the \c domain\<\> class template and control if and how
- /// expressions within that domain are to be customized.
- /// \c by_value_generator ensures all child nodes are
- /// held by value. This generator is typically composed with a
- /// second generator for further processing, as
- /// <tt>compose_generators\<by_value_generator, MyGenerator\></tt>.
- struct by_value_generator
- {
- BOOST_PROTO_CALLABLE()
+ template<typename This, typename Expr>
+ struct result<This(Expr)>
+ {
+ typedef Extends<Expr> type;
+ };
- template<typename Sig>
- struct result;
+ template<typename This, typename Expr>
+ struct result<This(Expr &)>
+ {
+ typedef Extends<Expr> type;
+ };
- template<typename This, typename Expr>
- struct result<This(Expr)>
- {
- typedef
- typename detail::by_value_generator_<Expr>::type
- type;
- };
+ template<typename This, typename Expr>
+ struct result<This(Expr const &)>
+ {
+ typedef Extends<Expr> type;
+ };
- template<typename This, typename Expr>
- struct result<This(Expr &)>
- {
- typedef
- typename detail::by_value_generator_<Expr>::type
- type;
+ /// \param expr The expression to wrap
+ /// \return <tt>Extends\<Expr\> that = {expr}; return that;</tt>
+ template<typename Expr>
+ Extends<Expr> operator ()(Expr const &e) const
+ {
+ Extends<Expr> that = {e};
+ return that;
+ }
};
- template<typename This, typename Expr>
- struct result<This(Expr const &)>
+ /// \brief A generator that replaces child nodes held by
+ /// reference with ones held by value. Use with
+ /// \c compose_generators to forward that result to another
+ /// generator.
+ ///
+ /// Generators are intended for use as the first template parameter
+ /// to the \c domain\<\> class template and control if and how
+ /// expressions within that domain are to be customized.
+ /// \c by_value_generator ensures all child nodes are
+ /// held by value. This generator is typically composed with a
+ /// second generator for further processing, as
+ /// <tt>compose_generators\<by_value_generator, MyGenerator\></tt>.
+ struct by_value_generator
{
- typedef
- typename detail::by_value_generator_<Expr>::type
- type;
- };
+ BOOST_PROTO_CALLABLE()
- /// \param expr The expression to modify.
- /// \return <tt>deep_copy(expr)</tt>
- template<typename Expr>
- typename result<by_value_generator(Expr)>::type operator ()(Expr const &e) const
- {
- return detail::by_value_generator_<Expr>::make(e);
- }
- };
+ template<typename Sig>
+ struct result;
- /// \brief A composite generator that first applies one
- /// transform to an expression and then forwards the result
- /// on to another generator for further transformation.
- ///
- /// Generators are intended for use as the first template parameter
- /// to the \c domain\<\> class template and control if and how
- /// expressions within that domain are to be customized.
- /// \c compose_generators\<\> is a composite generator that first
- /// applies one transform to an expression and then forwards the
- /// result on to another generator for further transformation.
- template<typename First, typename Second>
- struct compose_generators
- {
- BOOST_PROTO_CALLABLE()
+ template<typename This, typename Expr>
+ struct result<This(Expr)>
+ {
+ typedef
+ typename detail::by_value_generator_<Expr>::type
+ type;
+ };
- template<typename Sig>
- struct result;
+ template<typename This, typename Expr>
+ struct result<This(Expr &)>
+ {
+ typedef
+ typename detail::by_value_generator_<Expr>::type
+ type;
+ };
- template<typename This, typename Expr>
- struct result<This(Expr)>
- {
- typedef
- typename Second::template result<
- Second(typename First::template result<First(Expr)>::type)
- >::type
- type;
+ template<typename This, typename Expr>
+ struct result<This(Expr const &)>
+ {
+ typedef
+ typename detail::by_value_generator_<Expr>::type
+ type;
+ };
+
+ /// \param expr The expression to modify.
+ /// \return <tt>deep_copy(expr)</tt>
+ template<typename Expr>
+ typename result<by_value_generator(Expr)>::type operator ()(Expr const &e) const
+ {
+ return detail::by_value_generator_<Expr>::make(e);
+ }
};
- template<typename This, typename Expr>
- struct result<This(Expr &)>
+ /// \brief A composite generator that first applies one
+ /// transform to an expression and then forwards the result
+ /// on to another generator for further transformation.
+ ///
+ /// Generators are intended for use as the first template parameter
+ /// to the \c domain\<\> class template and control if and how
+ /// expressions within that domain are to be customized.
+ /// \c compose_generators\<\> is a composite generator that first
+ /// applies one transform to an expression and then forwards the
+ /// result on to another generator for further transformation.
+ template<typename First, typename Second>
+ struct compose_generators
{
- typedef
- typename Second::template result<
- Second(typename First::template result<First(Expr)>::type)
- >::type
- type;
- };
+ BOOST_PROTO_CALLABLE()
- template<typename This, typename Expr>
- struct result<This(Expr const &)>
- {
- typedef
- typename Second::template result<
- Second(typename First::template result<First(Expr)>::type)
- >::type
- type;
- };
+ template<typename Sig>
+ struct result;
- /// \param expr The expression to modify.
- /// \return Second()(First()(expr))
- template<typename Expr>
- typename result<compose_generators(Expr)>::type operator ()(Expr const &e) const
- {
- return Second()(First()(e));
- }
- };
+ template<typename This, typename Expr>
+ struct result<This(Expr)>
+ {
+ typedef
+ typename Second::template result<
+ Second(typename First::template result<First(Expr)>::type)
+ >::type
+ type;
+ };
+
+ template<typename This, typename Expr>
+ struct result<This(Expr &)>
+ {
+ typedef
+ typename Second::template result<
+ Second(typename First::template result<First(Expr)>::type)
+ >::type
+ type;
+ };
- BOOST_PROTO_END_ADL_NAMESPACE(generatorns_)
+ template<typename This, typename Expr>
+ struct result<This(Expr const &)>
+ {
+ typedef
+ typename Second::template result<
+ Second(typename First::template result<First(Expr)>::type)
+ >::type
+ type;
+ };
+
+ /// \param expr The expression to modify.
+ /// \return Second()(First()(expr))
+ template<typename Expr>
+ typename result<compose_generators(Expr)>::type operator ()(Expr const &e) const
+ {
+ return Second()(First()(e));
+ }
+ };
+ }
/// INTERNAL ONLY
template<>
Modified: trunk/boost/proto/literal.hpp
==============================================================================
--- trunk/boost/proto/literal.hpp (original)
+++ trunk/boost/proto/literal.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -10,13 +10,11 @@
#ifndef BOOST_PROTO_LITERAL_HPP_EAN_01_03_2007
#define BOOST_PROTO_LITERAL_HPP_EAN_01_03_2007
-#include <boost/proto/detail/prefix.hpp>
#include <boost/config.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/expr.hpp>
#include <boost/proto/traits.hpp>
#include <boost/proto/extends.hpp>
-#include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
@@ -33,7 +31,7 @@
/// \c proto::default_domain.
template<
typename T
- , typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= default_domain)
+ , typename Domain // = default_domain
>
struct literal
: extends<expr<tag::terminal, term<T>, 0>, literal<T, Domain>, Domain>
Modified: trunk/boost/proto/make_expr.hpp
==============================================================================
--- trunk/boost/proto/make_expr.hpp (original)
+++ trunk/boost/proto/make_expr.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -12,8 +12,6 @@
#ifndef BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005
#define BOOST_PROTO_MAKE_EXPR_HPP_EAN_04_01_2005
- #include <boost/proto/detail/prefix.hpp>
- #include <boost/version.hpp>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/preprocessor/cat.hpp>
@@ -28,7 +26,6 @@
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
- #include <boost/preprocessor/repetition/enum_shifted_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_binary_params.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/ref.hpp>
@@ -46,20 +43,12 @@
#include <boost/proto/traits.hpp>
#include <boost/proto/domain.hpp>
#include <boost/proto/generate.hpp>
- #if BOOST_VERSION >= 103500
- # include <boost/fusion/include/begin.hpp>
- # include <boost/fusion/include/next.hpp>
- # include <boost/fusion/include/value_of.hpp>
- # include <boost/fusion/include/size.hpp>
- #else
- # include <boost/spirit/fusion/sequence/begin.hpp>
- # include <boost/spirit/fusion/iterator/next.hpp>
- # include <boost/spirit/fusion/iterator/value_of.hpp>
- # include <boost/spirit/fusion/sequence/size.hpp>
- #endif
+ #include <boost/fusion/include/begin.hpp>
+ #include <boost/fusion/include/next.hpp>
+ #include <boost/fusion/include/value_of.hpp>
+ #include <boost/fusion/include/size.hpp>
#include <boost/proto/detail/poly_function.hpp>
#include <boost/proto/detail/deprecated.hpp>
- #include <boost/proto/detail/suffix.hpp>
#ifdef _MSC_VER
# pragma warning(push)
@@ -102,7 +91,7 @@
/// INTERNAL ONLY
///
#define BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE(Z, N, DATA) \
- typedef typename fusion::BOOST_PROTO_FUSION_RESULT_OF::next< \
+ typedef typename fusion::result_of::next< \
BOOST_PP_CAT(fusion_iterator, N)>::type \
BOOST_PP_CAT(fusion_iterator, BOOST_PP_INC(N)); \
/**/
@@ -111,7 +100,7 @@
///
#define BOOST_PROTO_FUSION_ITERATORS_TYPE(N) \
typedef \
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::begin<Sequence const>::type \
+ typename fusion::result_of::begin<Sequence const>::type \
fusion_iterator0; \
BOOST_PP_REPEAT(BOOST_PP_DEC(N), BOOST_PROTO_FUSION_NEXT_ITERATOR_TYPE, fusion_iterator) \
/**/
@@ -120,7 +109,7 @@
///
#define BOOST_PROTO_FUSION_AT_TYPE(Z, N, DATA) \
typename add_const< \
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::value_of< \
+ typename fusion::result_of::value_of< \
BOOST_PP_CAT(fusion_iterator, N) \
>::type \
>::type \
@@ -254,8 +243,8 @@
{
typedef
typename add_const<
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::value_of<
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::begin<Sequence>::type
+ typename fusion::result_of::value_of<
+ typename fusion::result_of::begin<Sequence>::type
>::type
>::type
terminal_type;
@@ -269,7 +258,7 @@
static type const call(Sequence const &sequence)
{
- return proto::detail::protoify_<terminal_type, Domain>::call(fusion::BOOST_PROTO_FUSION_AT_C(0, sequence));
+ return proto::detail::protoify_<terminal_type, Domain>::call(fusion::at_c<0>(sequence));
}
};
@@ -398,14 +387,9 @@
/// specialization is selected.)
template<
typename Tag
- , typename A0
- , BOOST_PP_ENUM_SHIFTED_BINARY_PARAMS(
- BOOST_PROTO_MAX_ARITY
- , typename A
- , BOOST_PROTO_WHEN_BUILDING_DOCS(= void) BOOST_PP_INTERCEPT
- )
- , typename Void1 BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
- , typename Void2 BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
+ , BOOST_PP_ENUM_PARAMS(BOOST_PROTO_MAX_ARITY, typename A)
+ , typename Void1 // = void
+ , typename Void2 // = void
>
struct make_expr
{
@@ -489,8 +473,8 @@
template<
typename Tag
, typename Sequence
- , typename Void1 BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
- , typename Void2 BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
+ , typename Void1 // = void
+ , typename Void2 // = void
>
struct unpack_expr
{
@@ -505,7 +489,7 @@
Tag
, deduce_domain
, Sequence
- , fusion::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence>::type::value
+ , fusion::result_of::size<Sequence>::type::value
>::type
type;
};
@@ -529,7 +513,7 @@
Tag
, Domain
, Sequence
- , fusion::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence>::type::value
+ , fusion::result_of::size<Sequence>::type::value
>::type
type;
};
@@ -545,7 +529,7 @@
///
/// <tt>functional::make_expr\<Tag\>()(a0, ... aN)</tt>
/// is equivalent to <tt>proto::make_expr\<Tag\>(a0, ... aN)</tt>.
- template<typename Tag, typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= deduce_domain)>
+ template<typename Tag, typename Domain /* = deduce_domain*/>
struct make_expr
{
BOOST_PROTO_CALLABLE()
@@ -619,7 +603,7 @@
///
/// <tt>functional::unpack_expr\<Tag\>()(seq)</tt>
/// is equivalent to <tt>proto::unpack_expr\<Tag\>(seq)</tt>.
- template<typename Tag, typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= deduce_domain)>
+ template<typename Tag, typename Domain /* = deduce_domain*/>
struct unpack_expr
{
BOOST_PROTO_CALLABLE()
@@ -653,7 +637,7 @@
Tag
, Domain
, Sequence const
- , fusion::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence>::type::value
+ , fusion::result_of::size<Sequence>::type::value
>::call(sequence);
}
};
@@ -688,7 +672,7 @@
Tag
, Domain
, Sequence const
- , fusion::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence>::type::value
+ , fusion::result_of::size<Sequence>::type::value
>::call(sequence);
}
};
@@ -805,7 +789,7 @@
Tag
, deduce_domain
, Sequence const
- , fusion::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence>::type::value
+ , fusion::result_of::size<Sequence>::type::value
>::call(sequence);
}
@@ -819,7 +803,7 @@
Tag
, Domain
, Sequence2 const
- , fusion::BOOST_PROTO_FUSION_RESULT_OF::size<Sequence2>::type::value
+ , fusion::result_of::size<Sequence2>::type::value
>::call(sequence2);
}
Modified: trunk/boost/proto/matches.hpp
==============================================================================
--- trunk/boost/proto/matches.hpp (original)
+++ trunk/boost/proto/matches.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -11,7 +11,6 @@
#ifndef BOOST_PROTO_MATCHES_HPP_EAN_11_03_2006
#define BOOST_PROTO_MATCHES_HPP_EAN_11_03_2006
- #include <boost/proto/detail/prefix.hpp> // must be first include
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/preprocessor/cat.hpp>
@@ -43,7 +42,6 @@
#include <boost/proto/traits.hpp>
#include <boost/proto/transform/when.hpp>
#include <boost/proto/transform/impl.hpp>
- #include <boost/proto/detail/suffix.hpp> // must be last include
// Some compilers (like GCC) need extra help figuring out a template's arity.
// I use MPL's BOOST_MPL_AUX_LAMBDA_ARITY_PARAM() macro to disambiguate, which
@@ -517,7 +515,8 @@
{};
}
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(wildcardns_)
+ namespace wildcardns_
+ {
/// \brief A wildcard grammar element that matches any expression,
/// and a transform that returns the current expression unchanged.
@@ -586,8 +585,7 @@
}
};
};
-
- BOOST_PROTO_END_ADL_NAMESPACE(wildcardns_)
+ }
namespace control
{
@@ -679,8 +677,8 @@
/// \endcode
template<
typename If
- , typename Then BOOST_PROTO_WHEN_BUILDING_DOCS(= _)
- , typename Else BOOST_PROTO_WHEN_BUILDING_DOCS(= not_<_>)
+ , typename Then // = _
+ , typename Else // = not_<_>
>
struct if_ : transform<if_<If, Then, Else> >
{
Modified: trunk/boost/proto/operators.hpp
==============================================================================
--- trunk/boost/proto/operators.hpp (original)
+++ trunk/boost/proto/operators.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -10,7 +10,6 @@
#ifndef BOOST_PROTO_OPERATORS_HPP_EAN_04_01_2005
#define BOOST_PROTO_OPERATORS_HPP_EAN_04_01_2005
-#include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/punctuation/comma.hpp>
#include <boost/preprocessor/seq/seq.hpp>
#include <boost/mpl/or.hpp>
@@ -22,7 +21,6 @@
#include <boost/proto/matches.hpp>
#include <boost/proto/generate.hpp>
#include <boost/proto/make_expr.hpp>
-#include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
@@ -274,63 +272,63 @@
} \
/**/
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(exprns_)
-
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(+, tag::unary_plus, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(-, tag::negate, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(*, tag::dereference, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(~, tag::complement, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(&, tag::address_of, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(!, tag::logical_not, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, tag::pre_inc, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, tag::pre_dec, 0)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, tag::post_inc, 1)
- BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, tag::post_dec, 1)
-
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<, tag::shift_left)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>, tag::shift_right)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(*, tag::multiplies)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(/, tag::divides)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(%, tag::modulus)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(+, tag::plus)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(-, tag::minus)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(<, tag::less)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(>, tag::greater)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(<=, tag::less_equal)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(>=, tag::greater_equal)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(==, tag::equal_to)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(!=, tag::not_equal_to)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(||, tag::logical_or)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(&&, tag::logical_and)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(&, tag::bitwise_and)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(|, tag::bitwise_or)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(^, tag::bitwise_xor)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(BOOST_PP_COMMA(), tag::comma)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(->*, tag::mem_ptr)
-
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<=, tag::shift_left_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>=, tag::shift_right_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(*=, tag::multiplies_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(/=, tag::divides_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(%=, tag::modulus_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(+=, tag::plus_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(-=, tag::minus_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(&=, tag::bitwise_and_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(|=, tag::bitwise_or_assign)
- BOOST_PROTO_DEFINE_BINARY_OPERATOR(^=, tag::bitwise_xor_assign)
-
- /// if_else
- ///
- template<typename A0, typename A1, typename A2>
- typename functional::make_expr<tag::if_else_>::impl<A0 const &, A1 const &, A2 const &>::result_type const
- if_else(A0 const &a0, A1 const &a1, A2 const &a2)
+ namespace exprns_
{
- return functional::make_expr<tag::if_else_>::impl<A0 const &, A1 const &, A2 const &>()(a0, a1, a2);
- }
- BOOST_PROTO_END_ADL_NAMESPACE(exprns_)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(+, tag::unary_plus, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(-, tag::negate, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(*, tag::dereference, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(~, tag::complement, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(&, tag::address_of, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(!, tag::logical_not, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, tag::pre_inc, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, tag::pre_dec, 0)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(++, tag::post_inc, 1)
+ BOOST_PROTO_DEFINE_UNARY_OPERATOR(--, tag::post_dec, 1)
+
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<, tag::shift_left)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>, tag::shift_right)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(*, tag::multiplies)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(/, tag::divides)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(%, tag::modulus)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(+, tag::plus)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(-, tag::minus)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<, tag::less)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>, tag::greater)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<=, tag::less_equal)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>=, tag::greater_equal)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(==, tag::equal_to)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(!=, tag::not_equal_to)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(||, tag::logical_or)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&&, tag::logical_and)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&, tag::bitwise_and)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(|, tag::bitwise_or)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(^, tag::bitwise_xor)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(BOOST_PP_COMMA(), tag::comma)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(->*, tag::mem_ptr)
+
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(<<=, tag::shift_left_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(>>=, tag::shift_right_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(*=, tag::multiplies_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(/=, tag::divides_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(%=, tag::modulus_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(+=, tag::plus_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(-=, tag::minus_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(&=, tag::bitwise_and_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(|=, tag::bitwise_or_assign)
+ BOOST_PROTO_DEFINE_BINARY_OPERATOR(^=, tag::bitwise_xor_assign)
+
+ /// if_else
+ ///
+ template<typename A0, typename A1, typename A2>
+ typename functional::make_expr<tag::if_else_>::impl<A0 const &, A1 const &, A2 const &>::result_type const
+ if_else(A0 const &a0, A1 const &a1, A2 const &a2)
+ {
+ return functional::make_expr<tag::if_else_>::impl<A0 const &, A1 const &, A2 const &>()(a0, a1, a2);
+ }
+ }
- BOOST_PROTO_WHEN_NOT_BUILDING_DOCS(using exprns_::if_else;)
+ using exprns_::if_else;
#undef BOOST_PROTO_DEFINE_UNARY_OPERATOR
#undef BOOST_PROTO_DEFINE_BINARY_OPERATOR
@@ -437,13 +435,11 @@
: mpl::false_
{};
- #ifndef BOOST_PROTO_BUILDING_DOCS
namespace exops
{
BOOST_PROTO_DEFINE_OPERATORS(is_extension, default_domain)
using proto::if_else;
}
- #endif
}}
Modified: trunk/boost/proto/proto.hpp
==============================================================================
--- trunk/boost/proto/proto.hpp (original)
+++ trunk/boost/proto/proto.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,11 +9,9 @@
#ifndef BOOST_PROTO_HPP_EAN_04_01_2005
#define BOOST_PROTO_HPP_EAN_04_01_2005
-#include <boost/proto/detail/prefix.hpp>
#include <boost/proto/core.hpp>
#include <boost/proto/debug.hpp>
#include <boost/proto/context.hpp>
#include <boost/proto/transform.hpp>
-#include <boost/proto/detail/suffix.hpp>
#endif
Modified: trunk/boost/proto/proto_fwd.hpp
==============================================================================
--- trunk/boost/proto/proto_fwd.hpp (original)
+++ trunk/boost/proto/proto_fwd.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,11 +9,9 @@
#ifndef BOOST_PROTO_FWD_HPP_EAN_04_01_2005
#define BOOST_PROTO_FWD_HPP_EAN_04_01_2005
-#include <boost/proto/detail/prefix.hpp> // must be first include
#include <cstddef>
#include <climits>
#include <boost/config.hpp>
-#include <boost/version.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/punctuation/comma.hpp>
@@ -82,59 +80,6 @@
# endif
#endif
-#if BOOST_VERSION < 103500
-#define BOOST_PROTO_FUSION_DEFINE_TAG(X) typedef X tag;
-#define BOOST_PROTO_FUSION_DEFINE_CATEGORY(X)
-#define BOOST_PROTO_FUSION_RESULT_OF meta
-#define BOOST_PROTO_FUSION_EXTENSION meta
-#define BOOST_PROTO_FUSION_AT_C(N, X) at<N>(X)
-#else
-#define BOOST_PROTO_FUSION_DEFINE_TAG(X) typedef X fusion_tag;
-#define BOOST_PROTO_FUSION_DEFINE_CATEGORY(X) typedef X category;
-#define BOOST_PROTO_FUSION_RESULT_OF result_of
-#define BOOST_PROTO_FUSION_EXTENSION extension
-#define BOOST_PROTO_FUSION_AT_C(N, X) at_c<N>(X)
-#endif
-
-#include <boost/proto/detail/suffix.hpp> // must be last include
-
-#ifdef BOOST_PROTO_BUILDING_DOCS
-// HACKHACK so Doxygen shows inheritance from mpl::true_ and mpl::false_
-namespace boost
-{
- /// INTERNAL ONLY
- ///
- namespace mpl
- {
- /// INTERNAL ONLY
- ///
- struct true_ {};
- /// INTERNAL ONLY
- ///
- struct false_ {};
- }
-
- /// INTERNAL ONLY
- ///
- namespace fusion
- {
- /// INTERNAL ONLY
- ///
- template<typename Function>
- class unfused_generic {};
- }
-}
-#define BOOST_PROTO_WHEN_BUILDING_DOCS(x) x
-#define BOOST_PROTO_WHEN_NOT_BUILDING_DOCS(x)
-#define BOOST_PROTO_BEGIN_ADL_NAMESPACE(x)
-#define BOOST_PROTO_END_ADL_NAMESPACE(x)
-#else
-#define BOOST_PROTO_WHEN_BUILDING_DOCS(x)
-#define BOOST_PROTO_WHEN_NOT_BUILDING_DOCS(x) x
-#define BOOST_PROTO_BEGIN_ADL_NAMESPACE(x) namespace x {
-#define BOOST_PROTO_END_ADL_NAMESPACE(x) }
-#endif
-
namespace boost { namespace proto
{
namespace detail
@@ -254,17 +199,17 @@
}
////////////////////////////////////////////////////////////////////////////////////////////////
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(wildcardns_)
+ namespace wildcardns_
+ {
struct _;
- BOOST_PROTO_END_ADL_NAMESPACE(wildcardns_)
+ }
////////////////////////////////////////////////////////////////////////////////////////////////
- #ifndef BOOST_PROTO_BUILDING_DOCS
using wildcardns_::_;
- #endif
////////////////////////////////////////////////////////////////////////////////////////////////
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(generatorns_)
+ namespace generatorns_
+ {
struct default_generator;
template<template<typename> class Extends>
@@ -277,36 +222,34 @@
template<typename First, typename Second>
struct compose_generators;
- BOOST_PROTO_END_ADL_NAMESPACE(generatorns_)
+ }
////////////////////////////////////////////////////////////////////////////////////////////////
- #ifndef BOOST_PROTO_BUILDING_DOCS
using generatorns_::default_generator;
using generatorns_::generator;
using generatorns_::pod_generator;
using generatorns_::by_value_generator;
using generatorns_::compose_generators;
- #endif
////////////////////////////////////////////////////////////////////////////////////////////////
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(domainns_)
+ namespace domainns_
+ {
template<typename Generator = default_generator, typename Grammar = proto::_>
struct domain;
struct default_domain;
struct deduce_domain;
- BOOST_PROTO_END_ADL_NAMESPACE(domainns_)
+ }
////////////////////////////////////////////////////////////////////////////////////////////////
- #ifndef BOOST_PROTO_BUILDING_DOCS
using domainns_::domain;
using domainns_::default_domain;
using domainns_::deduce_domain;
- #endif
////////////////////////////////////////////////////////////////////////////////////////////////
- BOOST_PROTO_BEGIN_ADL_NAMESPACE(exprns_)
+ namespace exprns_
+ {
template<typename Tag, typename Args, long Arity = Args::arity>
struct expr;
@@ -322,14 +265,12 @@
struct virtual_member;
struct is_proto_expr;
- BOOST_PROTO_END_ADL_NAMESPACE(exprns_)
+ }
////////////////////////////////////////////////////////////////////////////////////////////////
- #ifndef BOOST_PROTO_BUILDING_DOCS
using exprns_::expr;
using exprns_::extends;
using exprns_::is_proto_expr;
- #endif
namespace control
{
Modified: trunk/boost/proto/proto_typeof.hpp
==============================================================================
--- trunk/boost/proto/proto_typeof.hpp (original)
+++ trunk/boost/proto/proto_typeof.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -10,13 +10,11 @@
#ifndef BOOST_XPRESSIVE_PROTO_PROTO_TYPEOF_H
#define BOOST_XPRESSIVE_PROTO_PROTO_TYPEOF_H
-#include <boost/proto/detail/prefix.hpp>
#include <boost/config.hpp>
#include <boost/typeof/typeof.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/deep_copy.hpp>
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
-#include <boost/proto/detail/suffix.hpp>
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::terminal)
BOOST_TYPEOF_REGISTER_TYPE(boost::proto::tag::unary_plus)
Modified: trunk/boost/proto/repeat.hpp
==============================================================================
--- trunk/boost/proto/repeat.hpp (original)
+++ trunk/boost/proto/repeat.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,7 +9,6 @@
#ifndef BOOST_PROTO_REPEAT_HPP_EAN_11_24_2008
#define BOOST_PROTO_REPEAT_HPP_EAN_11_24_2008
-#include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/facilities/intercept.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
@@ -18,7 +17,6 @@
#include <boost/preprocessor/iteration/local.hpp>
#include <boost/preprocessor/tuple/elem.hpp>
#include <boost/proto/proto_fwd.hpp> // for BOOST_PROTO_MAX_ARITY
-#include <boost/proto/detail/suffix.hpp>
////////////////////////////////////////////
/// INTERNAL ONLY
Modified: trunk/boost/proto/tags.hpp
==============================================================================
--- trunk/boost/proto/tags.hpp (original)
+++ trunk/boost/proto/tags.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,9 +9,7 @@
#ifndef BOOST_PROTO_TAGS_HPP_EAN_04_01_2005
#define BOOST_PROTO_TAGS_HPP_EAN_04_01_2005
-#include <boost/proto/detail/prefix.hpp>
#include <boost/proto/proto_fwd.hpp>
-#include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto { namespace tag
{
Modified: trunk/boost/proto/traits.hpp
==============================================================================
--- trunk/boost/proto/traits.hpp (original)
+++ trunk/boost/proto/traits.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -12,7 +12,6 @@
#ifndef BOOST_PROTO_ARG_TRAITS_HPP_EAN_04_01_2005
#define BOOST_PROTO_ARG_TRAITS_HPP_EAN_04_01_2005
- #include <boost/proto/detail/prefix.hpp>
#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
@@ -44,7 +43,6 @@
#include <boost/proto/args.hpp>
#include <boost/proto/tags.hpp>
#include <boost/proto/transform/pass_through.hpp>
- #include <boost/proto/detail/suffix.hpp>
#if BOOST_WORKAROUND( BOOST_MSVC, >= 1400 )
#pragma warning(push)
@@ -155,7 +153,7 @@
{};
/// TODO document me!
- template<typename T, typename Void BOOST_PROTO_WHEN_BUILDING_DOCS(= void)>
+ template<typename T, typename Void /* = void*/>
struct is_transform
: mpl::false_
{};
@@ -176,7 +174,7 @@
/// from <tt>proto::extends\<\></tt> or that uses the
/// <tt>BOOST_PROTO_BASIC_EXTENDS()</tt> macro.) Otherwise,
/// <tt>is_expr\<T\>::::value</tt> is \c false.
- template<typename T, typename Void BOOST_PROTO_WHEN_BUILDING_DOCS(= void)>
+ template<typename T, typename Void /* = void*/>
struct is_expr
: mpl::false_
{};
@@ -242,10 +240,10 @@
/// <tt>boost::result_of\<Domain(expr\< tag::terminal, term\<A\> \>)\>::::type</tt>.
template<
typename T
- , typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= default_domain)
- , typename Void BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
+ , typename Domain // = default_domain
+ , typename Void // = void
#ifdef BOOST_PROTO_BROKEN_PTS
- , typename Void2 BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
+ , typename Void2 // = void
#endif
>
struct as_expr
@@ -337,10 +335,10 @@
/// <tt>boost::result_of\<Domain(expr\< tag::terminal, term\<T &\> \>)\>::::type</tt>.
template<
typename T
- , typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= default_domain)
- , typename Void BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
+ , typename Domain // = default_domain
+ , typename Void // = void
#ifdef BOOST_PROTO_BROKEN_PTS
- , typename Void2 BOOST_PROTO_WHEN_BUILDING_DOCS(= void)
+ , typename Void2 // = void
#endif
>
struct as_child
@@ -432,7 +430,7 @@
///
/// <tt>result_of::child\<Expr, N\></tt> is equivalent to
/// <tt>result_of::child_c\<Expr, N::value\></tt>.
- template<typename Expr, typename N BOOST_PROTO_WHEN_BUILDING_DOCS(= mpl::long_<0>) >
+ template<typename Expr, typename N /* = mpl::long_<0>*/>
struct child
: child_c<Expr, N::value>
{};
@@ -791,7 +789,7 @@
{
/// \brief A callable PolymorphicFunctionObject that is
/// equivalent to the \c as_expr() function.
- template<typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= default_domain)>
+ template<typename Domain /* = default_domain*/>
struct as_expr
{
BOOST_PROTO_CALLABLE()
@@ -845,7 +843,7 @@
/// \brief A callable PolymorphicFunctionObject that is
/// equivalent to the \c as_child() function.
- template<typename Domain BOOST_PROTO_WHEN_BUILDING_DOCS(= default_domain)>
+ template<typename Domain /* = default_domain*/>
struct as_child
{
BOOST_PROTO_CALLABLE()
@@ -926,7 +924,7 @@
/// A callable PolymorphicFunctionObject that is
/// equivalent to the \c child() function. \c N is required
/// to be an MPL Integral Constant.
- template<typename N BOOST_PROTO_WHEN_BUILDING_DOCS(= mpl::long_<0>) >
+ template<typename N /* = mpl::long_<0>*/>
struct child
{
BOOST_PROTO_CALLABLE()
Modified: trunk/boost/proto/transform.hpp
==============================================================================
--- trunk/boost/proto/transform.hpp (original)
+++ trunk/boost/proto/transform.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,7 +9,6 @@
#ifndef BOOST_PROTO_TRANSFORM_HPP_EAN_06_23_2007
#define BOOST_PROTO_TRANSFORM_HPP_EAN_06_23_2007
-#include <boost/proto/detail/prefix.hpp> // must be first include
#include <boost/proto/transform/arg.hpp>
#include <boost/proto/transform/call.hpp>
#include <boost/proto/transform/default.hpp>
@@ -19,6 +18,5 @@
#include <boost/proto/transform/make.hpp>
#include <boost/proto/transform/pass_through.hpp>
#include <boost/proto/transform/when.hpp>
-#include <boost/proto/detail/suffix.hpp> // must be last include
#endif
Modified: trunk/boost/proto/transform/arg.hpp
==============================================================================
--- trunk/boost/proto/transform/arg.hpp (original)
+++ trunk/boost/proto/transform/arg.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,12 +9,10 @@
#ifndef BOOST_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007
#define BOOST_PROTO_TRANSFORM_ARG_HPP_EAN_11_01_2007
-#include <boost/proto/detail/prefix.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/traits.hpp>
#include <boost/proto/transform/impl.hpp>
#include <boost/type_traits/is_array.hpp>
-#include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
Modified: trunk/boost/proto/transform/call.hpp
==============================================================================
--- trunk/boost/proto/transform/call.hpp (original)
+++ trunk/boost/proto/transform/call.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -10,7 +10,6 @@
#ifndef BOOST_PROTO_TRANSFORM_CALL_HPP_EAN_11_02_2007
#define BOOST_PROTO_TRANSFORM_CALL_HPP_EAN_11_02_2007
- #include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/facilities/intercept.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
@@ -27,7 +26,6 @@
#include <boost/proto/detail/dont_care.hpp>
#include <boost/proto/detail/as_lvalue.hpp>
#include <boost/proto/detail/poly_function.hpp>
- #include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
Modified: trunk/boost/proto/transform/default.hpp
==============================================================================
--- trunk/boost/proto/transform/default.hpp (original)
+++ trunk/boost/proto/transform/default.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -11,7 +11,6 @@
#ifndef BOOST_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008
#define BOOST_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008
- #include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/repetition/enum_shifted.hpp>
@@ -27,11 +26,10 @@
#include <boost/proto/transform/impl.hpp>
#include <boost/proto/transform/arg.hpp>
#include <boost/proto/detail/decltype.hpp>
- #include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
- template<typename Grammar BOOST_PROTO_WHEN_BUILDING_DOCS(= detail::_default)>
+ template<typename Grammar /*= detail::_default*/>
struct _default
: transform<_default<Grammar> >
{
Modified: trunk/boost/proto/transform/fold.hpp
==============================================================================
--- trunk/boost/proto/transform/fold.hpp (original)
+++ trunk/boost/proto/transform/fold.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -10,24 +10,17 @@
#ifndef BOOST_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007
#define BOOST_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007
- #include <boost/proto/detail/prefix.hpp>
- #include <boost/version.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/arithmetic/sub.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
- #if BOOST_VERSION >= 103500
#include <boost/fusion/include/fold.hpp>
- #else
- #include <boost/spirit/fusion/algorithm/fold.hpp>
- #endif
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/fusion.hpp>
#include <boost/proto/traits.hpp>
#include <boost/proto/transform/call.hpp>
#include <boost/proto/transform/impl.hpp>
- #include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
@@ -43,24 +36,17 @@
template<typename Sig>
struct result;
- template<typename This, typename Expr, typename State>
- struct result<This(Expr, State)>
+ template<typename This, typename State, typename Expr>
+ struct result<This(State, Expr)>
{
typedef
typename when<_, Transform>::template impl<Expr, State, Data>::result_type
type;
};
- #if BOOST_VERSION < 103500
- template<typename Expr, typename State>
- struct apply
- : result<as_callable(Expr, State)>
- {};
- #endif
-
- template<typename Expr, typename State>
+ template<typename State, typename Expr>
typename when<_, Transform>::template impl<Expr &, State const &, Data>::result_type
- operator ()(Expr &e, State const &s) const
+ operator ()(State const &s, Expr &e) const
{
return typename when<_, Transform>::template impl<Expr &, State const &, Data>()(e, s, this->v_);
}
@@ -69,38 +55,6 @@
Data v_;
};
- #if BOOST_VERSION < 103500
- template<typename Sequence, typename Void = void>
- struct as_fusion_sequence_type
- {
- typedef Sequence const type;
- };
-
- template<typename Sequence>
- Sequence const &as_fusion_sequence(Sequence const &sequence, ...)
- {
- return sequence;
- }
-
- template<typename Sequence>
- struct as_fusion_sequence_type<Sequence, typename Sequence::proto_is_expr_>
- {
- typedef typename Sequence::proto_base_expr const type;
- };
-
- template<typename Sequence>
- typename Sequence::proto_base_expr const &as_fusion_sequence(Sequence const &sequence, int)
- {
- return sequence.proto_base();
- }
-
- #define BOOST_PROTO_AS_FUSION_SEQUENCE_TYPE(X) typename detail::as_fusion_sequence_type<X>::type
- #define BOOST_PROTO_AS_FUSION_SEQUENCE(X) detail::as_fusion_sequence(X, 0)
- #else
- #define BOOST_PROTO_AS_FUSION_SEQUENCE_TYPE(X) X
- #define BOOST_PROTO_AS_FUSION_SEQUENCE(X) X
- #endif
-
template<
typename State0
, typename Fun
@@ -220,8 +174,8 @@
fun;
typedef
- typename fusion::BOOST_PROTO_FUSION_RESULT_OF::fold<
- BOOST_PROTO_AS_FUSION_SEQUENCE_TYPE(sequence)
+ typename fusion::result_of::fold<
+ sequence
, state0
, fun
>::type
@@ -245,7 +199,7 @@
typename when<_, Sequence>::template impl<Expr, State, Data> seq;
detail::as_callable<Fun, Data> f(d);
return fusion::fold(
- BOOST_PROTO_AS_FUSION_SEQUENCE(seq(e, s, d))
+ seq(e, s, d)
, typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d)
, f
);
Modified: trunk/boost/proto/transform/fold_tree.hpp
==============================================================================
--- trunk/boost/proto/transform/fold_tree.hpp (original)
+++ trunk/boost/proto/transform/fold_tree.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,14 +9,12 @@
#ifndef BOOST_PROTO_TRANSFORM_FOLD_TREE_HPP_EAN_11_05_2007
#define BOOST_PROTO_TRANSFORM_FOLD_TREE_HPP_EAN_11_05_2007
-#include <boost/proto/detail/prefix.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/traits.hpp>
#include <boost/proto/matches.hpp>
#include <boost/proto/transform/fold.hpp>
#include <boost/proto/transform/impl.hpp>
-#include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
Modified: trunk/boost/proto/transform/impl.hpp
==============================================================================
--- trunk/boost/proto/transform/impl.hpp (original)
+++ trunk/boost/proto/transform/impl.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -9,9 +9,7 @@
#ifndef BOOST_PROTO_TRANSFORM_IMPL_HPP_EAN_04_03_2008
#define BOOST_PROTO_TRANSFORM_IMPL_HPP_EAN_04_03_2008
-#include <boost/proto/detail/prefix.hpp>
#include <boost/proto/proto_fwd.hpp>
-#include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
Modified: trunk/boost/proto/transform/lazy.hpp
==============================================================================
--- trunk/boost/proto/transform/lazy.hpp (original)
+++ trunk/boost/proto/transform/lazy.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -10,7 +10,6 @@
#ifndef BOOST_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007
#define BOOST_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007
- #include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
@@ -18,7 +17,6 @@
#include <boost/proto/transform/make.hpp>
#include <boost/proto/transform/call.hpp>
#include <boost/proto/transform/impl.hpp>
- #include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
Modified: trunk/boost/proto/transform/make.hpp
==============================================================================
--- trunk/boost/proto/transform/make.hpp (original)
+++ trunk/boost/proto/transform/make.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -10,7 +10,6 @@
#ifndef BOOST_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007
#define BOOST_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007
- #include <boost/proto/detail/prefix.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
@@ -35,7 +34,6 @@
#include <boost/proto/transform/impl.hpp>
#include <boost/proto/detail/as_lvalue.hpp>
#include <boost/proto/detail/ignore_unused.hpp>
- #include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
Modified: trunk/boost/proto/transform/pass_through.hpp
==============================================================================
--- trunk/boost/proto/transform/pass_through.hpp (original)
+++ trunk/boost/proto/transform/pass_through.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -13,7 +13,6 @@
#ifndef BOOST_PROTO_TRANSFORM_PASS_THROUGH_HPP_EAN_12_26_2006
#define BOOST_PROTO_TRANSFORM_PASS_THROUGH_HPP_EAN_12_26_2006
- #include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/iteration/iterate.hpp>
@@ -22,7 +21,6 @@
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/args.hpp>
#include <boost/proto/transform/impl.hpp>
- #include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
Modified: trunk/boost/proto/transform/when.hpp
==============================================================================
--- trunk/boost/proto/transform/when.hpp (original)
+++ trunk/boost/proto/transform/when.hpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -10,7 +10,6 @@
#ifndef BOOST_PROTO_TRANSFORM_WHEN_HPP_EAN_10_29_2007
#define BOOST_PROTO_TRANSFORM_WHEN_HPP_EAN_10_29_2007
- #include <boost/proto/detail/prefix.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
@@ -21,7 +20,6 @@
#include <boost/proto/transform/call.hpp>
#include <boost/proto/transform/make.hpp>
#include <boost/proto/transform/impl.hpp>
- #include <boost/proto/detail/suffix.hpp>
namespace boost { namespace proto
{
@@ -53,7 +51,7 @@
///
/// <tt>when\<G,T\>()(e,s,v)</tt> is the same as
/// <tt>T()(e,s,v)</tt>.
- template<typename Grammar, typename PrimitiveTransform BOOST_PROTO_WHEN_BUILDING_DOCS(= Grammar)>
+ template<typename Grammar, typename PrimitiveTransform /*= Grammar*/>
struct when
: PrimitiveTransform
{
Modified: trunk/libs/proto/test/examples.cpp
==============================================================================
--- trunk/libs/proto/test/examples.cpp (original)
+++ trunk/libs/proto/test/examples.cpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -11,14 +11,9 @@
#include <boost/proto/core.hpp>
#include <boost/proto/transform.hpp>
#include <boost/utility/result_of.hpp>
-#if BOOST_VERSION < 103500
-# include <boost/spirit/fusion/sequence/cons.hpp>
-# include <boost/spirit/fusion/sequence/tuple.hpp>
-#else
-# include <boost/fusion/include/cons.hpp>
-# include <boost/fusion/include/tuple.hpp>
-# include <boost/fusion/include/pop_front.hpp>
-#endif
+#include <boost/fusion/include/cons.hpp>
+#include <boost/fusion/include/tuple.hpp>
+#include <boost/fusion/include/pop_front.hpp>
#include <boost/test/unit_test.hpp>
namespace mpl = boost::mpl;
Modified: trunk/libs/proto/test/lambda.cpp
==============================================================================
--- trunk/libs/proto/test/lambda.cpp (original)
+++ trunk/libs/proto/test/lambda.cpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -6,19 +6,12 @@
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <sstream>
-#include <boost/version.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/min_max.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/next_prior.hpp>
-#if BOOST_VERSION < 103500
-# include <boost/spirit/fusion/sequence/at.hpp>
-# include <boost/spirit/fusion/sequence/tuple.hpp>
-namespace boost { namespace fusion { namespace result_of { using namespace meta; }}}
-#else
-# include <boost/fusion/tuple.hpp>
-#endif
+#include <boost/fusion/tuple.hpp>
#include <boost/typeof/typeof.hpp>
#include <boost/typeof/std/sstream.hpp>
#include <boost/typeof/std/ostream.hpp>
@@ -95,11 +88,7 @@
typename fusion::result_of::at<Tuple, I>::type
operator ()(proto::tag::terminal, placeholder<I> const &) const
{
- #if BOOST_VERSION < 103500
- return fusion::at<I::value>(this->args_);
- #else
return fusion::at<I>(this->args_);
- #endif
}
Tuple args_;
Modified: trunk/libs/proto/test/make_expr.cpp
==============================================================================
--- trunk/libs/proto/test/make_expr.cpp (original)
+++ trunk/libs/proto/test/make_expr.cpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -6,15 +6,10 @@
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#include <sstream>
-#include <boost/version.hpp>
#include <boost/proto/core.hpp>
#include <boost/proto/transform.hpp>
#include <boost/utility/addressof.hpp>
-#if BOOST_VERSION >= 103500
#include <boost/fusion/tuple.hpp>
-#else
-#include <boost/spirit/fusion/sequence/make_tuple.hpp>
-#endif
#include <boost/test/unit_test.hpp>
using namespace boost;
Modified: trunk/libs/proto/test/proto_fusion.cpp
==============================================================================
--- trunk/libs/proto/test/proto_fusion.cpp (original)
+++ trunk/libs/proto/test/proto_fusion.cpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -5,11 +5,6 @@
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#include <boost/version.hpp>
-#if BOOST_VERSION < 103500
-# error This test only works on Boost v1.35
-#endif
-
#include <boost/proto/core.hpp>
#include <boost/proto/fusion.hpp>
#include <boost/fusion/include/for_each.hpp>
Modified: trunk/libs/proto/test/proto_fusion_s.cpp
==============================================================================
--- trunk/libs/proto/test/proto_fusion_s.cpp (original)
+++ trunk/libs/proto/test/proto_fusion_s.cpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -5,11 +5,6 @@
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#include <boost/version.hpp>
-#if BOOST_VERSION < 103500
-# error This test only works on Boost v1.35
-#endif
-
#include <boost/proto/core.hpp>
#include <boost/proto/fusion.hpp>
#include <boost/fusion/algorithm/iteration/ext_/for_each_s.hpp>
Modified: trunk/libs/proto/test/toy_spirit2.cpp
==============================================================================
--- trunk/libs/proto/test/toy_spirit2.cpp (original)
+++ trunk/libs/proto/test/toy_spirit2.cpp 2009-10-26 11:15:05 EDT (Mon, 26 Oct 2009)
@@ -10,24 +10,16 @@
#include <cstring>
#include <iomanip>
#include <iostream>
-#include <boost/version.hpp>
#include <boost/assert.hpp>
#include <boost/mpl/assert.hpp>
#include <boost/utility/result_of.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/proto/core.hpp>
#include <boost/proto/transform.hpp>
-#if BOOST_VERSION < 103500
-# include <boost/spirit/fusion/algorithm/for_each.hpp>
-# include <boost/spirit/fusion/algorithm/fold.hpp>
-# include <boost/spirit/fusion/algorithm/any.hpp>
-# include <boost/spirit/fusion/sequence/cons.hpp>
-#else
-# include <boost/fusion/include/for_each.hpp>
-# include <boost/fusion/include/fold.hpp>
-# include <boost/fusion/include/cons.hpp>
-# include <boost/fusion/include/any.hpp>
-#endif
+#include <boost/fusion/include/for_each.hpp>
+#include <boost/fusion/include/fold.hpp>
+#include <boost/fusion/include/cons.hpp>
+#include <boost/fusion/include/any.hpp>
#include <boost/test/unit_test.hpp>
namespace boost
@@ -291,18 +283,10 @@
: parse(p)
{}
- #if BOOST_VERSION < 103500
- template<typename, typename>
- struct apply
- {
- typedef bool type;
- };
- #else
typedef bool result_type;
- #endif
template<typename T>
- bool operator ()(T const &t, bool success) const
+ bool operator ()(bool success, T const &t) const
{
return success && this->parse(t);
}