Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/phoenix/scope/lambda.hpp')
| -rw-r--r-- | 3rdParty/Boost/src/boost/phoenix/scope/lambda.hpp | 393 |
1 files changed, 393 insertions, 0 deletions
diff --git a/3rdParty/Boost/src/boost/phoenix/scope/lambda.hpp b/3rdParty/Boost/src/boost/phoenix/scope/lambda.hpp new file mode 100644 index 0000000..432edd9 --- /dev/null +++ b/3rdParty/Boost/src/boost/phoenix/scope/lambda.hpp @@ -0,0 +1,393 @@ +#ifndef BOOST_PHOENIX_SCOPE_LAMBDA_HPP +#define BOOST_PHOENIX_SCOPE_LAMBDA_HPP + +#include <boost/phoenix/core/limits.hpp> +#include <boost/fusion/include/transform.hpp> +#include <boost/fusion/include/as_vector.hpp> +#include <boost/mpl/int.hpp> +#include <boost/phoenix/core/call.hpp> +#include <boost/phoenix/core/expression.hpp> +#include <boost/phoenix/core/meta_grammar.hpp> +#include <boost/phoenix/scope/local_variable.hpp> +#include <boost/phoenix/scope/scoped_environment.hpp> + +#if !defined(BOOST_PHOENIX_DONT_USE_PREPROCESSED_FILES) + +#include <boost/phoenix/scope/preprocessed/lambda.hpp> + +#else + +#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES) +#pragma wave option(preserve: 2, line: 0, output: "preprocessed/lambda_" BOOST_PHOENIX_LIMIT_STR ".hpp") +#endif +/*============================================================================== + Copyright (c) 2001-2010 Joel de Guzman + Copyright (c) 2004 Daniel Wallin + 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) +==============================================================================*/ +#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES) +#pragma wave option(preserve: 1) +#endif + +BOOST_PHOENIX_DEFINE_EXPRESSION( + (boost)(phoenix)(lambda_actor) + , (proto::terminal<proto::_>) // Locals + (proto::terminal<proto::_>) // Map + (meta_grammar) // Lambda +) + +BOOST_PHOENIX_DEFINE_EXPRESSION( + (boost)(phoenix)(lambda) + , (proto::terminal<proto::_>) // OuterEnv + (proto::terminal<proto::_>) // Locals + (proto::terminal<proto::_>) // Map + (meta_grammar) // Lambda +) + +namespace boost { namespace phoenix +{ + struct lambda_eval + { + BOOST_PROTO_CALLABLE() + + template <typename Sig> + struct result; + + template < + typename This + , typename OuterEnv + , typename Locals + , typename Map + , typename Lambda + , typename Context + > + struct result<This(OuterEnv, Locals, Map, Lambda, Context)> + { + typedef + typename proto::detail::uncvref< + typename proto::result_of::value< + OuterEnv + >::type + >::type + outer_env_type; + + typedef + typename proto::detail::uncvref< + typename proto::result_of::value< + Locals + >::type + >::type + locals_type; + + typedef + typename proto::detail::uncvref< + typename proto::result_of::value< + Map + >::type + >::type + map_type; + + typedef + typename proto::detail::uncvref< + typename result_of::env<Context>::type + >::type + env_type; + + typedef + typename result_of::eval< + Lambda + , typename result_of::context< + scoped_environment< + env_type + , outer_env_type + , locals_type + , map_type + > + , typename result_of::actions< + Context + >::type + >::type + >::type + type; + }; + + template <typename OuterEnv, typename Locals, typename Map, typename Lambda, typename Context> + typename result<lambda_eval(OuterEnv const &, Locals const &, Map const &, Lambda const &, Context const &)>::type + operator()(OuterEnv const & outer_env, Locals const & locals, Map const &, Lambda const & lambda, Context const & ctx) const + { + typedef + typename proto::detail::uncvref< + typename proto::result_of::value< + OuterEnv + >::type + >::type + outer_env_type; + + typedef + typename proto::detail::uncvref< + typename proto::result_of::value< + Locals + >::type + >::type + locals_type; + + typedef + typename proto::detail::uncvref< + typename proto::result_of::value< + Map + >::type + >::type + map_type; + + typedef + typename proto::detail::uncvref< + typename result_of::env<Context>::type + >::type + env_type; + + scoped_environment< + env_type + , outer_env_type + , locals_type + , map_type + > + env(phoenix::env(ctx), proto::value(outer_env), proto::value(locals)); + + return eval(lambda, phoenix::context(env, phoenix::actions(ctx))); + } + }; + + template <typename Dummy> + struct default_actions::when<rule::lambda, Dummy> + : call<lambda_eval, Dummy> + {}; + + template <typename Dummy> + struct is_nullary::when<rule::lambda, Dummy> + : proto::call< + evaluator( + proto::_child_c<3> + , proto::call< + functional::context( + proto::make< + mpl::true_() + > + , proto::make< + detail::scope_is_nullary_actions() + > + ) + > + , proto::make< + proto::empty_env() + > + ) + > + {}; + + template <typename Dummy> + struct is_nullary::when<rule::lambda_actor, Dummy> + : proto::or_< + proto::when< + expression::lambda_actor< + proto::terminal<vector0<> > + , proto::terminal<proto::_> + , meta_grammar + > + , mpl::true_() + > + , proto::when< + expression::lambda_actor< + proto::terminal<proto::_> + , proto::terminal<proto::_> + , meta_grammar + > + , proto::fold< + proto::call<proto::_value(proto::_child_c<0>)> + , proto::make<mpl::true_()> + , proto::make< + mpl::and_< + proto::_state + , proto::call< + evaluator( + proto::_ + , _context + , proto::make<proto::empty_env()> + ) + > + >() + > + > + > + > + {}; + + struct lambda_actor_eval + { + template <typename Sig> + struct result; + + template <typename This, typename Vars, typename Map, typename Lambda, typename Context> + struct result<This(Vars, Map, Lambda, Context)> + { + typedef + typename proto::detail::uncvref< + typename result_of::env<Context>::type + >::type + env_type; + typedef + typename proto::detail::uncvref< + typename result_of::actions<Context>::type + >::type + actions_type; + typedef + typename proto::detail::uncvref< + typename proto::result_of::value<Vars>::type + >::type + vars_type; + + typedef typename + detail::result_of::initialize_locals< + vars_type + , Context + >::type + locals_type; + + typedef + typename expression::lambda< + env_type + , locals_type + , Map + , Lambda + >::type const + type; + }; + + template < + typename Vars + , typename Map + , typename Lambda + , typename Context + > + typename result< + lambda_actor_eval(Vars const&, Map const &, Lambda const&, Context const &) + >::type const + operator()(Vars const& vars, Map const& map, Lambda const& lambda, Context const & ctx) const + { + typedef + typename proto::detail::uncvref< + typename result_of::env<Context>::type + >::type + env_type; + typedef + typename proto::detail::uncvref< + typename result_of::actions<Context>::type + >::type + actions_type; + typedef + typename proto::detail::uncvref< + typename proto::result_of::value<Vars>::type + >::type + vars_type; + typedef + typename proto::detail::uncvref< + typename proto::result_of::value<Map>::type + >::type + map_type; + + typedef typename + detail::result_of::initialize_locals< + vars_type + , Context + >::type + locals_type; + + locals_type locals = initialize_locals(proto::value(vars), ctx); + + return + expression:: + lambda<env_type, locals_type, Map, Lambda>:: + make(phoenix::env(ctx), locals, map, lambda); + } + }; + + template <typename Dummy> + struct default_actions::when<rule::lambda_actor, Dummy> + : call<lambda_actor_eval, Dummy> + {}; + + template <typename Locals = void, typename Map = void, typename Dummy = void> + struct lambda_actor_gen; + + template <> + struct lambda_actor_gen<void, void, void> + { + template <typename Expr> + typename expression::lambda_actor<vector0<>, detail::map_local_index_to_tuple<>, Expr>::type const + operator[](Expr const & expr) const + { + typedef vector0<> locals_type; + typedef detail::map_local_index_to_tuple<> map_type; + return expression::lambda_actor<locals_type, map_type, Expr>::make(locals_type(), map_type(), expr); + } + }; + + template <typename Locals, typename Map> + struct lambda_actor_gen<Locals, Map> + { + lambda_actor_gen(Locals const & locals) + : locals(locals) + {} + + lambda_actor_gen(lambda_actor_gen const & o) + : locals(o.locals) + {}; + + template <typename Expr> + typename expression::lambda_actor< + Locals + , Map + , Expr + >::type const + operator[](Expr const & expr) const + { + return expression::lambda_actor<Locals, Map, Expr>::make(locals, Map(), expr); + } + + Locals locals; + }; + + struct lambda_local_gen + : lambda_actor_gen<> + { + lambda_actor_gen<> const + operator()() const + { + return lambda_actor_gen<>(); + } + +#define BOOST_PHOENIX_SCOPE_ACTOR_GEN_NAME lambda_actor_gen +#define BOOST_PHOENIX_SCOPE_ACTOR_GEN_FUNCTION operator() +#define BOOST_PHOENIX_SCOPE_ACTOR_GEN_CONST const + #include <boost/phoenix/scope/detail/local_gen.hpp> +#undef BOOST_PHOENIX_SCOPE_ACTOR_GEN_NAME +#undef BOOST_PHOENIX_SCOPE_ACTOR_GEN_FUNCTION +#undef BOOST_PHOENIX_SCOPE_ACTOR_GEN_CONST + + + }; + + typedef lambda_local_gen lambda_type; + lambda_local_gen const lambda = lambda_local_gen(); + +}} + +#if defined(__WAVE__) && defined(BOOST_PHOENIX_CREATE_PREPROCESSED_FILES) +#pragma wave option(output: null) +#endif + +#endif + +#endif |