| /*============================================================================= |
| Copyright (c) 2005-2010 Joel de Guzman |
| Copyright (c) 2010 Eric Niebler |
| Copyright (c) 2010 Thomas Heller |
| |
| Distributed under the Boost Software License, Version 1.0. (See accompanying |
| file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| ==============================================================================*/ |
| #ifndef BOOST_PHOENIX_CORE_ACTOR_HPP |
| #define BOOST_PHOENIX_CORE_ACTOR_HPP |
| |
| #include <boost/phoenix/core/limits.hpp> |
| |
| #include <boost/is_placeholder.hpp> |
| #include <boost/mpl/identity.hpp> |
| #include <boost/mpl/eval_if.hpp> |
| #include <boost/phoenix/core/domain.hpp> |
| #include <boost/phoenix/core/environment.hpp> |
| #include <boost/phoenix/core/is_nullary.hpp> |
| #include <boost/phoenix/core/meta_grammar.hpp> |
| #include <boost/phoenix/support/iterate.hpp> |
| #include <boost/phoenix/support/vector.hpp> |
| #include <boost/proto/extends.hpp> |
| #include <boost/proto/make_expr.hpp> |
| #include <boost/utility/result_of.hpp> |
| #include <boost/mpl/void.hpp> |
| #include <cstring> |
| |
| #ifdef BOOST_MSVC |
| #pragma warning(push) |
| #pragma warning(disable: 4522) // 'this' used in base member initializer list |
| #endif |
| |
| namespace boost { namespace phoenix |
| { |
| template <typename Expr> |
| struct actor; |
| |
| namespace detail |
| { |
| struct error_expecting_arguments |
| { |
| template <typename T> |
| error_expecting_arguments(T const&) {} |
| }; |
| |
| struct error_invalid_lambda_expr |
| { |
| template <typename T> |
| error_invalid_lambda_expr(T const&) {} |
| }; |
| |
| template <typename T> |
| struct result_type_deduction_helper |
| { |
| typedef T const & type; |
| }; |
| |
| template <typename T> |
| struct result_type_deduction_helper<T &> |
| { |
| typedef T & type; |
| }; |
| |
| template <typename T> |
| struct result_type_deduction_helper<T const &> |
| { |
| typedef T const & type; |
| }; |
| |
| struct do_assign |
| { |
| BOOST_PROTO_CALLABLE() |
| |
| typedef void result_type; |
| |
| template <typename T1, typename T2> |
| void operator()(T1 & t1, T2 const & t2) const |
| { |
| proto::value(t1) = proto::value(t2); |
| } |
| }; |
| |
| #define BOOST_PHOENIX_ACTOR_ASSIGN_CHILD(Z, N, D) \ |
| assign( \ |
| proto::_child_c<N> \ |
| , proto::call< \ |
| proto::_child_c<N>(proto::_state) \ |
| > \ |
| ) \ |
| /**/ |
| #define BOOST_PHOENIX_ACTOR_ASSIGN_CALL(Z, N, D) \ |
| proto::when< \ |
| proto::nary_expr<proto::_ , \ |
| BOOST_PP_ENUM_PARAMS(N, proto::_ BOOST_PP_INTERCEPT) \ |
| > \ |
| , proto::and_< \ |
| BOOST_PP_ENUM( \ |
| N \ |
| , BOOST_PHOENIX_ACTOR_ASSIGN_CHILD \ |
| , _ \ |
| ) \ |
| > \ |
| > \ |
| /**/ |
| |
| #if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES) |
| #include <boost/phoenix/core/preprocessed/actor.hpp> |
| #else |
| #if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES) |
| #pragma wave option(preserve: 2, line: 0, output: "preprocessed/actor_" BOOST_PHOENIX_LIMIT_STR ".hpp") |
| #endif |
| /*============================================================================== |
| Copyright (c) 2005-2010 Joel de Guzman |
| Copyright (c) 2010-2011 Thomas Heller |
| |
| 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_PHOENIX_CREATE_PREPROCESSED_FILES) |
| #pragma wave option(preserve: 1) |
| #endif |
| |
| struct assign |
| : proto::or_< |
| BOOST_PP_ENUM_SHIFTED( |
| BOOST_PHOENIX_LIMIT |
| , BOOST_PHOENIX_ACTOR_ASSIGN_CALL |
| , _ |
| ) |
| , proto::when< |
| proto::terminal<proto::_> |
| , do_assign(proto::_, proto::_state) |
| > |
| > |
| {}; |
| |
| #if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES) |
| #pragma wave option(output: null) |
| #endif |
| |
| #endif |
| #undef BOOST_PHOENIX_ACTOR_ASSIGN_CALL |
| #undef BOOST_PHOENIX_ACTOR_ASSIGN_CHILD |
| } |
| |
| // Bring in the result_of::actor<> |
| #include <boost/phoenix/core/detail/actor_result_of.hpp> |
| |
| //////////////////////////////////////////////////////////////////////////// |
| // |
| // actor |
| // |
| // The actor class. The main thing! In phoenix, everything is an actor |
| // This class is responsible for full function evaluation. Partial |
| // function evaluation involves creating a hierarchy of actor objects. |
| // |
| //////////////////////////////////////////////////////////////////////////// |
| template <typename Expr> |
| struct actor |
| { |
| typedef typename |
| mpl::eval_if_c< |
| mpl::or_< |
| is_custom_terminal<Expr> |
| , mpl::bool_<is_placeholder<Expr>::value> |
| >::value |
| , proto::terminal<Expr> |
| , mpl::identity<Expr> |
| >::type |
| expr_type; |
| |
| BOOST_PROTO_BASIC_EXTENDS(expr_type, actor<expr_type>, phoenix_domain) |
| |
| // providing operator= to be assignable |
| actor& operator=(actor const& other) |
| { |
| detail::assign()(*this, other); |
| return *this; |
| } |
| actor& operator=(actor & other) |
| { |
| detail::assign()(*this, other); |
| return *this; |
| } |
| |
| template <typename A0> |
| typename proto::result_of::make_expr< |
| proto::tag::assign |
| , phoenix_domain |
| , proto_base_expr |
| , A0 |
| >::type const |
| operator=(A0 const & a0) const |
| { |
| return proto::make_expr<proto::tag::assign, phoenix_domain>(this->proto_expr_, a0); |
| } |
| |
| template <typename A0> |
| typename proto::result_of::make_expr< |
| proto::tag::assign |
| , phoenix_domain |
| , proto_base_expr |
| , A0 |
| >::type const |
| operator=(A0 & a0) const |
| { |
| return proto::make_expr<proto::tag::assign, phoenix_domain>(this->proto_expr_, a0); |
| } |
| |
| template <typename A0> |
| typename proto::result_of::make_expr< |
| proto::tag::subscript |
| , phoenix_domain |
| , proto_base_expr |
| , A0 |
| >::type const |
| operator[](A0 const & a0) const |
| { |
| return proto::make_expr<proto::tag::subscript, phoenix_domain>(this->proto_expr_, a0); |
| } |
| |
| template <typename A0> |
| typename proto::result_of::make_expr< |
| proto::tag::subscript |
| , phoenix_domain |
| , proto_base_expr |
| , A0 |
| >::type const |
| operator[](A0 & a0) const |
| { |
| return proto::make_expr<proto::tag::subscript, phoenix_domain>(this->proto_expr_, a0); |
| } |
| |
| template <typename Sig> |
| struct result; |
| |
| typename result_of::actor<proto_base_expr>::type |
| operator()() |
| { |
| typedef vector1<const actor<Expr> *> env_type; |
| env_type env = {this}; |
| |
| return phoenix::eval(*this, phoenix::context(env, default_actions())); |
| } |
| |
| typename result_of::actor<proto_base_expr>::type |
| operator()() const |
| { |
| typedef vector1<const actor<Expr> *> env_type; |
| env_type env = {this}; |
| |
| return phoenix::eval(*this, phoenix::context(env, default_actions())); |
| } |
| |
| template <typename Env> |
| typename evaluator::impl< |
| proto_base_expr const & |
| , typename result_of::context< |
| Env const & |
| , default_actions const & |
| >::type |
| , int |
| >::result_type |
| eval(Env const & env) const |
| { |
| return phoenix::eval(*this, phoenix::context(env, default_actions())); |
| } |
| |
| // Bring in the rest |
| #include <boost/phoenix/core/detail/actor_operator.hpp> |
| }; |
| |
| }} |
| |
| namespace boost |
| { |
| // specialize boost::result_of to return the proper result type |
| template <typename Expr> |
| struct result_of<phoenix::actor<Expr>()> |
| : phoenix::result_of::actor<typename phoenix::actor<Expr>::proto_base_expr> |
| {}; |
| |
| template <typename Expr> |
| struct result_of<phoenix::actor<Expr> const()> |
| : phoenix::result_of::actor<typename phoenix::actor<Expr>::proto_base_expr> |
| {}; |
| } |
| |
| |
| #ifdef BOOST_MSVC |
| #pragma warning(pop) |
| #endif |
| |
| #endif |
| |
