detail/cpp03/function_eval.hpp

0001 #if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES)
0002
0003 #include <boost/phoenix/core/detail/cpp03/preprocessed/function_eval.hpp>
0004
0005 #else
0006
0007 #if !BOOST_PHOENIX_IS_ITERATING
0008
0009 #if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
0010 #pragma wave option(preserve: 2, line: 0, output: "preprocessed/function_eval_" BOOST_PHOENIX_LIMIT_STR ".hpp")
0011 #endif
0012 /*=============================================================================
0013     Copyright (c) 2001-2007 Joel de Guzman
0014
0015     Distributed under the Boost Software License, Version 1.0. (See accompanying
0016     file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0017 ==============================================================================*/
0018
0019 #if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
0020 #pragma wave option(preserve: 1)
0021 #endif
0022
0023         #define PHOENIX_GET_ARG(z, n, data)                                     \
0024             typedef                                                             \
0025                 typename boost::add_reference<                                  \
0026                     typename boost::add_const<                                  \
0027                         typename boost::result_of<                              \
0028                             boost::phoenix::evaluator(                          \
0029                                 BOOST_PP_CAT(A, n)                              \
0030                               , Context                                         \
0031                             )                                                   \
0032                         >::type                                                 \
0033                     >::type                                                     \
0034                 >::type                                                         \
0035                 BOOST_PP_CAT(a, n);
0036
0037         #define PHOENIX_EVAL_ARG(z, n, data)                                    \
0038             help_rvalue_deduction(boost::phoenix::eval(BOOST_PP_CAT(a, n), ctx))
0039
0040         #define M0(z, n, data)                                     \
0041             typename proto::detail::uncvref<BOOST_PP_CAT(a, n)>::type
0042
0043         #define BOOST_PHOENIX_ITERATION_PARAMS                                  \
0044             (3, (1, BOOST_PP_DEC(BOOST_PHOENIX_ACTOR_LIMIT),                    \
0045             <boost/phoenix/core/detail/cpp03/function_eval.hpp>))
0046 #include BOOST_PHOENIX_ITERATE()
0047
0048         #undef PHOENIX_GET_ARG
0049         #undef PHOENIX_EVAL_ARG
0050         #undef M0
0051
0052 #if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES)
0053 #pragma wave option(output: null)
0054 #endif
0055
0056 #else
0057             template <
0058                 typename This
0059               , typename F
0060               , BOOST_PHOENIX_typename_A
0061               , typename Context
0062             >
0063             struct result<This(F, BOOST_PHOENIX_A, Context)>
0064             {
0065                 typedef typename
0066                     remove_reference<
0067                         typename boost::result_of<evaluator(F, Context)>::type
0068                     >::type
0069                     fn;
0070
0071                 BOOST_PP_REPEAT(BOOST_PHOENIX_ITERATION, PHOENIX_GET_ARG, _)
0072
0073                 typedef typename
0074                     boost::result_of<fn(BOOST_PHOENIX_a)>::type
0075                     type;
0076             };
0077
0078             template <typename F, BOOST_PHOENIX_typename_A, typename Context>
0079             typename result<
0080                 function_eval(
0081                     F const &
0082                   , BOOST_PHOENIX_A_ref
0083                   , Context const &
0084                 )
0085             >::type
0086             operator()(F const & f, BOOST_PHOENIX_A_ref_a, Context const & ctx) const
0087             {
0088                 return boost::phoenix::eval(f, ctx)(BOOST_PP_ENUM(BOOST_PHOENIX_ITERATION, PHOENIX_EVAL_ARG, _));
0089             }
0090
0091             template <typename F, BOOST_PHOENIX_typename_A, typename Context>
0092             typename result<
0093                 function_eval(
0094                     F &
0095                   , BOOST_PHOENIX_A_ref
0096                   , Context const &
0097                 )
0098             >::type
0099             operator()(F & f, BOOST_PHOENIX_A_ref_a, Context const & ctx) const
0100             {
0101                 return boost::phoenix::eval(f, ctx)(BOOST_PP_ENUM(BOOST_PHOENIX_ITERATION, PHOENIX_EVAL_ARG, _));
0102             }
0103 #endif
0104
0105 #endif