Swiftdiff options
Diffstat (limited to '3rdParty/Boost/src/boost/phoenix/scope')
9 files changed, 151 insertions, 196 deletions
diff --git a/3rdParty/Boost/src/boost/phoenix/scope/lambda.hpp b/3rdParty/Boost/src/boost/phoenix/scope/lambda.hpp index 432edd9..8221966 100644 --- a/3rdParty/Boost/src/boost/phoenix/scope/lambda.hpp +++ b/3rdParty/Boost/src/boost/phoenix/scope/lambda.hpp @@ -64,123 +64,123 @@ namespace boost { namespace phoenix , 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; + 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< + 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() > ) @@ -216,161 +216,161 @@ namespace boost { namespace phoenix , _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 + 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 + /*typedef typename proto::detail::uncvref< typename result_of::actions<Context>::type >::type - actions_type; + actions_type;*/ typedef typename proto::detail::uncvref< typename proto::result_of::value<Vars>::type >::type vars_type; - typedef + /*typedef typename proto::detail::uncvref< typename proto::result_of::value<Map>::type >::type - map_type; - - typedef typename + 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(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 diff --git a/3rdParty/Boost/src/boost/phoenix/scope/let.hpp b/3rdParty/Boost/src/boost/phoenix/scope/let.hpp index 8c84571..f1b428c 100644 --- a/3rdParty/Boost/src/boost/phoenix/scope/let.hpp +++ b/3rdParty/Boost/src/boost/phoenix/scope/let.hpp @@ -98,72 +98,72 @@ namespace boost { namespace phoenix 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); scoped_environment< env_type , env_type , locals_type , map_type > env(phoenix::env(ctx), phoenix::env(ctx), locals); return eval(expr, phoenix::context(env, phoenix::actions(ctx))); } }; template <typename Dummy> struct default_actions::when<rule::let_, Dummy> : call<let_eval, Dummy> {}; template <typename Locals, typename Map> struct let_actor_gen { - let_actor_gen(Locals const & locals) - : locals(locals) + let_actor_gen(Locals const & locals_) + : locals(locals_) {} let_actor_gen(let_actor_gen const & o) : locals(o.locals) {} template <typename Expr> typename expression::let_< Locals , Map , Expr >::type const operator[](Expr const & expr) const { return expression::let_<Locals, Map, Expr>::make(locals, Map(), expr); } Locals locals; }; #define BOOST_PHOENIX_SCOPE_ACTOR_GEN_NAME let_actor_gen #define BOOST_PHOENIX_SCOPE_ACTOR_GEN_FUNCTION let #define BOOST_PHOENIX_SCOPE_ACTOR_GEN_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 template <typename Dummy> struct is_nullary::when<rule::let_, Dummy> : proto::make< mpl::and_< proto::fold< proto::call<proto::_value(proto::_child_c<0>)> , proto::make<mpl::true_()> diff --git a/3rdParty/Boost/src/boost/phoenix/scope/local_variable.hpp b/3rdParty/Boost/src/boost/phoenix/scope/local_variable.hpp index ebc01c3..d62a5bb 100644 --- a/3rdParty/Boost/src/boost/phoenix/scope/local_variable.hpp +++ b/3rdParty/Boost/src/boost/phoenix/scope/local_variable.hpp @@ -25,103 +25,103 @@ namespace boost { namespace phoenix namespace expression { template <typename Key> struct local_variable : expression::terminal<detail::local<Key> > { typedef typename expression::terminal<detail::local<Key> >::type type; static type make() { type const e = {}; return e; } }; } namespace rule { struct local_variable : expression::local_variable<proto::_> {}; struct local_var_def : proto::assign<local_variable, meta_grammar> {}; } namespace result_of { template <typename Key> struct is_nullary<custom_terminal<detail::local<Key> > > : mpl::false_ {}; } - + namespace detail { struct scope_is_nullary_actions { template <typename Rule, typename Dummy = void> struct when : boost::phoenix::is_nullary::when<Rule, Dummy> {}; }; template <typename Dummy> struct scope_is_nullary_actions::when<boost::phoenix::rule::custom_terminal, Dummy> : proto::or_< proto::when<boost::phoenix::rule::local_variable, mpl::true_()> , proto::otherwise< is_nullary::when<boost::phoenix::rule::custom_terminal, Dummy> > > {}; struct local_var_not_found { }; } template<typename Key> struct is_custom_terminal<detail::local<Key> > : mpl::true_ {}; - template <typename Key> - struct custom_terminal<detail::local<Key> > + template <typename Key> + struct custom_terminal<detail::local<Key> > { template <typename Sig> struct result; template <typename This, typename Local, typename Context> struct result<This(Local, Context)> : result<This(Local const &, Context)> {}; template <typename This, typename Local, typename Context> struct result<This(Local &, Context)> { typedef typename remove_reference< typename result_of::env<Context>::type >::type env_type; typedef typename detail::apply_local<detail::local<Key>, env_type>::type type; }; template <typename Local, typename Context> typename result<custom_terminal(Local const &, Context const&)>::type operator()(Local, Context const & ctx) { typedef typename remove_reference< typename result_of::env<Context>::type >::type env_type; typedef typename detail::apply_local<detail::local<Key>, env_type>::type return_type; static const int index_value = detail::get_index<typename env_type::map_type, detail::local<Key> >::value; diff --git a/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_10.hpp b/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_10.hpp index 333240e..754f2b9 100644 --- a/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_10.hpp +++ b/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_10.hpp @@ -20,120 +20,120 @@ namespace boost { namespace phoenix , 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; + 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< + 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> @@ -163,154 +163,145 @@ namespace boost { namespace phoenix 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 + 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 + 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(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<>(); } template <typename A0> lambda_actor_gen< vector1<typename proto::detail::uncvref< typename proto::result_of::child_c< A0 , 1 >::type >::type> , detail::map_local_index_to_tuple<typename proto::detail::uncvref< typename proto::result_of::value< typename proto::result_of::child_c< A0 , 0 >::type >::type >::type> diff --git a/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_20.hpp b/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_20.hpp index 7eefa43..d9a4bdd 100644 --- a/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_20.hpp +++ b/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_20.hpp @@ -20,120 +20,120 @@ namespace boost { namespace phoenix , 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; + 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< + 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> @@ -163,154 +163,145 @@ namespace boost { namespace phoenix 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 + 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 + 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(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<>(); } template <typename A0> lambda_actor_gen< vector1<typename proto::detail::uncvref< typename proto::result_of::child_c< A0 , 1 >::type >::type> , detail::map_local_index_to_tuple<typename proto::detail::uncvref< typename proto::result_of::value< typename proto::result_of::child_c< A0 , 0 >::type >::type >::type> diff --git a/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_30.hpp b/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_30.hpp index e18d622..e7f8b2a 100644 --- a/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_30.hpp +++ b/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_30.hpp @@ -20,120 +20,120 @@ namespace boost { namespace phoenix , 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; + 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< + 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> @@ -163,154 +163,145 @@ namespace boost { namespace phoenix 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 + 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 + 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(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<>(); } template <typename A0> lambda_actor_gen< vector1<typename proto::detail::uncvref< typename proto::result_of::child_c< A0 , 1 >::type >::type> , detail::map_local_index_to_tuple<typename proto::detail::uncvref< typename proto::result_of::value< typename proto::result_of::child_c< A0 , 0 >::type >::type >::type> diff --git a/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_40.hpp b/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_40.hpp index c291c62..11fb23e 100644 --- a/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_40.hpp +++ b/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_40.hpp @@ -20,120 +20,120 @@ namespace boost { namespace phoenix , 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; + 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< + 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> @@ -163,154 +163,145 @@ namespace boost { namespace phoenix 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 + 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 + 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(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<>(); } template <typename A0> lambda_actor_gen< vector1<typename proto::detail::uncvref< typename proto::result_of::child_c< A0 , 1 >::type >::type> , detail::map_local_index_to_tuple<typename proto::detail::uncvref< typename proto::result_of::value< typename proto::result_of::child_c< A0 , 0 >::type >::type >::type> diff --git a/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_50.hpp b/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_50.hpp index 30f5fef..2128eb4 100644 --- a/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_50.hpp +++ b/3rdParty/Boost/src/boost/phoenix/scope/preprocessed/lambda_50.hpp @@ -20,120 +20,120 @@ namespace boost { namespace phoenix , 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; + 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< + 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> @@ -163,154 +163,145 @@ namespace boost { namespace phoenix 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 + 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 + 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(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<>(); } template <typename A0> lambda_actor_gen< vector1<typename proto::detail::uncvref< typename proto::result_of::child_c< A0 , 1 >::type >::type> , detail::map_local_index_to_tuple<typename proto::detail::uncvref< typename proto::result_of::value< typename proto::result_of::child_c< A0 , 0 >::type >::type >::type> diff --git a/3rdParty/Boost/src/boost/phoenix/scope/scoped_environment.hpp b/3rdParty/Boost/src/boost/phoenix/scope/scoped_environment.hpp index a53b4e5..5fcb245 100644 --- a/3rdParty/Boost/src/boost/phoenix/scope/scoped_environment.hpp +++ b/3rdParty/Boost/src/boost/phoenix/scope/scoped_environment.hpp @@ -3,84 +3,84 @@ 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_SCOPE_SCOPED_ENVIRONMENT_HPP #define BOOST_PHOENIX_SCOPE_SCOPED_ENVIRONMENT_HPP #include <boost/phoenix/core/limits.hpp> #include <boost/mpl/int.hpp> #include <boost/fusion/sequence/sequence_facade.hpp> #include <boost/fusion/sequence/intrinsic/begin.hpp> #include <boost/fusion/sequence/intrinsic/end.hpp> #include <boost/fusion/sequence/intrinsic/size.hpp> #include <boost/fusion/sequence/intrinsic/value_at.hpp> #include <boost/fusion/sequence/intrinsic/at.hpp> #include <boost/fusion/support/category_of.hpp> #include <boost/fusion/include/pop_front.hpp> #include <boost/utility/result_of.hpp> namespace boost { namespace phoenix { template<typename Env, typename OuterEnv, typename Locals, typename Map> struct scoped_environment : fusion::sequence_facade< scoped_environment<Env, OuterEnv, Locals, Map> , fusion::random_access_traversal_tag > { typedef Env env_type; typedef OuterEnv outer_env_type; typedef Locals locals_type; typedef Map map_type; scoped_environment( - Env const & env - , OuterEnv const &outer_env - , Locals const &locals + Env const & env_ + , OuterEnv const &outer_env_ + , Locals const &locals_ ) - : env(env) - , outer_env(outer_env) - , locals(locals) + : env(env_) + , outer_env(outer_env_) + , locals(locals_) {} - scoped_environment(scoped_environment const & o) - : env(o.env) + scoped_environment(scoped_environment const & o) + : env(o.env) , outer_env(o.outer_env) - , locals(o.locals) - {}; + , locals(o.locals) + {}; Env const & env; OuterEnv const & outer_env; Locals const & locals; typedef typename fusion::result_of::pop_front< typename add_const< typename proto::detail::uncvref<Env>::type >::type >::type args_type; args_type args() const { return fusion::pop_front(env); } #define BOOST_PHOENIX_ADAPT_SCOPED_ENVIRONMENT(INTRINSIC) \ template <typename Seq> \ struct INTRINSIC \ { \ typedef \ typename fusion::result_of::INTRINSIC< \ typename mpl::eval_if_c< \ is_const< \ typename remove_reference< \ typename Seq::env_type \ >::type \ >::value \ , add_const< \ typename proto::detail::uncvref< \ typename Seq::env_type \ >::type \ > \ |