detail/cpp03/expression.hpp

0001
0002 #if !BOOST_PHOENIX_IS_ITERATING
0003
0004 #include <boost/phoenix/support/iterate.hpp>
0005 #include <boost/preprocessor/comparison/equal.hpp>
0006
0007 #if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
0008
0009 #include <boost/phoenix/core/detail/cpp03/preprocessed/expression.hpp>
0010
0011 #else
0012
0013 #if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
0014 #pragma wave option(preserve: 2, line: 0, output: "preprocessed/expression_" BOOST_PHOENIX_LIMIT_STR ".hpp")
0015 #endif
0016
0017 /*=============================================================================
0018     Copyright (c) 2005-2010 Joel de Guzman
0019     Copyright (c) 2010 Eric Niebler
0020     Copyright (c) 2010 Thomas Heller
0021
0022     Distributed under the Boost Software License, Version 1.0. (See accompanying
0023     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0024 ==============================================================================*/
0025
0026 #if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
0027 #pragma wave option(preserve: 1)
0028 #endif
0029
0030     template <
0031         template <typename> class Actor
0032       , typename Tag
0033       , BOOST_PHOENIX_typename_A_void(BOOST_PHOENIX_COMPOSITE_LIMIT)
0034       , typename Dummy = void>
0035     struct expr_ext;
0036
0037     template <
0038         typename Tag
0039       , BOOST_PHOENIX_typename_A_void(BOOST_PHOENIX_COMPOSITE_LIMIT)
0040       , typename Dummy = void
0041     >
0042     struct expr : expr_ext<actor, Tag, BOOST_PHOENIX_A(BOOST_PHOENIX_COMPOSITE_LIMIT)> {};
0043
0044 #define M0(Z, N, D)                                                             \
0045     BOOST_PP_COMMA_IF(N)                                                        \
0046     typename proto::detail::uncvref<BOOST_PP_CAT(A, N)>::type
0047
0048 #define M1(Z, N, D)                                                             \
0049     BOOST_PP_COMMA_IF(N) typename boost::add_reference<typename boost::add_const<BOOST_PP_CAT(A, N)>::type>::type BOOST_PP_CAT(a, N)
0050
0051 #define BOOST_PHOENIX_ITERATION_PARAMS                                          \
0052     (3, (1, BOOST_PHOENIX_COMPOSITE_LIMIT,                                      \
0053     <boost/phoenix/core/detail/cpp03/expression.hpp>))                          \
0054 /**/
0055     #include BOOST_PHOENIX_ITERATE()
0056
0057 #undef M0
0058 #undef M1
0059
0060 #if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
0061 #pragma wave option(output: null)
0062 #endif
0063
0064 #endif // PHOENIX_DONT_USE_PREPROCESSED_FILES
0065
0066 #else
0067     template <template <typename> class Actor, typename Tag, BOOST_PHOENIX_typename_A>
0068     struct expr_ext<Actor, Tag, BOOST_PHOENIX_A>
0069         : proto::transform<expr_ext<Actor, Tag, BOOST_PHOENIX_A>, int>
0070     {
0071         typedef
0072             typename proto::result_of::make_expr<
0073                 Tag
0074               , phoenix_default_domain //proto::basic_default_domain
0075               , BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, M0, _)
0076             >::type
0077             base_type;
0078
0079         typedef Actor<base_type> type;
0080
0081         typedef
0082             typename proto::nary_expr<Tag, BOOST_PHOENIX_A>::proto_grammar
0083             proto_grammar;
0084
0085         static type make(BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, M1, _))
0086       { //?? actor or Actor??
0087         //Actor<base_type> const e =
0088                 actor<base_type> const e =
0089                 {
0090                     proto::make_expr<
0091                         Tag
0092                       , phoenix_default_domain // proto::basic_default_domain
0093                     >(BOOST_PHOENIX_a)
0094                 };
0095             return e;
0096         }
0097
0098         template<typename Expr, typename State, typename Data>
0099         struct impl
0100           : proto::pass_through<expr_ext>::template impl<Expr, State, Data>
0101         {};
0102
0103         typedef Tag proto_tag;
0104     #define BOOST_PHOENIX_ENUM_CHILDREN(_, N, __)                               \
0105         typedef BOOST_PP_CAT(A, N) BOOST_PP_CAT(proto_child, N);                \
0106     /**/
0107         BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, BOOST_PHOENIX_ENUM_CHILDREN, _)
0108     #undef BOOST_PHOENIX_ENUM_CHILDREN
0109     };
0110
0111 #endif