You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
393 lines
12 KiB
393 lines
12 KiB
#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< |
|
int() |
|
> |
|
) |
|
> |
|
{}; |
|
|
|
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<int()> |
|
) |
|
> |
|
>() |
|
> |
|
> |
|
> |
|
> |
|
{}; |
|
|
|
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 &) |
|
>::type const |
|
operator()(Vars const& vars, Map const& map, Lambda const& lambda, Context & 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(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
|
|
|