|
|
Boost-Commit : |
Subject: [Boost-commit] svn:boost r67061 - in sandbox/SOC/2010/phoenix3: boost/phoenix boost/phoenix/core boost/phoenix/scope libs/phoenix/test/scope
From: thom.heller_at_[hidden]
Date: 2010-12-06 04:55:33
Author: theller
Date: 2010-12-06 04:55:29 EST (Mon, 06 Dec 2010)
New Revision: 67061
URL: http://svn.boost.org/trac/boost/changeset/67061
Log:
scope, temporary, another attempt
Text files modified:
sandbox/SOC/2010/phoenix3/boost/phoenix/core/actor.hpp | 28 ++-
sandbox/SOC/2010/phoenix3/boost/phoenix/core/meta_grammar.hpp | 4
sandbox/SOC/2010/phoenix3/boost/phoenix/scope.hpp | 2
sandbox/SOC/2010/phoenix3/boost/phoenix/scope/lambda.hpp | 269 ++++++++++++++++++++++++++++++++++++++-
sandbox/SOC/2010/phoenix3/boost/phoenix/scope/let.hpp | 62 ++++++++
sandbox/SOC/2010/phoenix3/boost/phoenix/scope/local_variable.hpp | 188 +++++++++++++++++++++------
sandbox/SOC/2010/phoenix3/boost/phoenix/scope/scoped_environment.hpp | 12 -
sandbox/SOC/2010/phoenix3/libs/phoenix/test/scope/lambda_tests.cpp | 56 +++++--
sandbox/SOC/2010/phoenix3/libs/phoenix/test/scope/let_tests.cpp | 9
9 files changed, 534 insertions(+), 96 deletions(-)
Modified: sandbox/SOC/2010/phoenix3/boost/phoenix/core/actor.hpp
==============================================================================
--- sandbox/SOC/2010/phoenix3/boost/phoenix/core/actor.hpp (original)
+++ sandbox/SOC/2010/phoenix3/boost/phoenix/core/actor.hpp 2010-12-06 04:55:29 EST (Mon, 06 Dec 2010)
@@ -44,19 +44,29 @@
struct actor;
template <typename Expr>
+ struct result_matches
+ : mpl::eval_if<
+ typename is_nullary<Expr>::type // avoid calling result_of::actor when this is false
+ , boost::result_of<
+ evaluator(
+ Expr const &
+ , fusion::vector2<fusion::vector0<>&, default_actions>&
+ )
+ >
+ , mpl::identity<detail::error_expecting_arguments>
+ >
+ {
+ };
+
+ template <typename Expr>
struct actor<Expr>
{
//static const int arity = result_of::arity<Expr>::type::value;
- typedef typename
- mpl::eval_if<
- typename is_nullary<Expr>::type // avoid calling result_of::actor when this is false
- , boost::result_of<
- evaluator(
- Expr const &
- , fusion::vector2<fusion::vector0<>&, default_actions>&
- )
- >
+ typedef
+ typename mpl::eval_if<
+ typename proto::matches<Expr, meta_grammar>::type
+ , result_matches<Expr>
, mpl::identity<detail::error_expecting_arguments>
>::type
type;
Modified: sandbox/SOC/2010/phoenix3/boost/phoenix/core/meta_grammar.hpp
==============================================================================
--- sandbox/SOC/2010/phoenix3/boost/phoenix/core/meta_grammar.hpp (original)
+++ sandbox/SOC/2010/phoenix3/boost/phoenix/core/meta_grammar.hpp 2010-12-06 04:55:29 EST (Mon, 06 Dec 2010)
@@ -48,9 +48,9 @@
// Set of default actions. Extend this whenever you add a new phoenix construct
struct default_actions
{
- template <typename Rule, typename Dummy = void>
+ template <typename Rule, typename Grammar = meta_grammar>
struct when
- : proto::_default<meta_grammar>
+ : proto::_default<Grammar>
{};
};
Modified: sandbox/SOC/2010/phoenix3/boost/phoenix/scope.hpp
==============================================================================
--- sandbox/SOC/2010/phoenix3/boost/phoenix/scope.hpp (original)
+++ sandbox/SOC/2010/phoenix3/boost/phoenix/scope.hpp 2010-12-06 04:55:29 EST (Mon, 06 Dec 2010)
@@ -10,7 +10,7 @@
#include <boost/phoenix/version.hpp>
#include <boost/phoenix/scope/scoped_environment.hpp>
-#include <boost/phoenix/scope/lambda.hpp>
+//#include <boost/phoenix/scope/lambda.hpp>
#include <boost/phoenix/scope/let.hpp>
#include <boost/phoenix/scope/local_variable.hpp>
Modified: sandbox/SOC/2010/phoenix3/boost/phoenix/scope/lambda.hpp
==============================================================================
--- sandbox/SOC/2010/phoenix3/boost/phoenix/scope/lambda.hpp (original)
+++ sandbox/SOC/2010/phoenix3/boost/phoenix/scope/lambda.hpp 2010-12-06 04:55:29 EST (Mon, 06 Dec 2010)
@@ -26,12 +26,266 @@
namespace boost { namespace phoenix
{
+ //template <typename> struct lambda_actor;
+
PHOENIX_DEFINE_EXPRESSION(
lambda
- , (rule::local_var_def_list)
- (meta_grammar)
+ , (proto::terminal<proto::_>) // OuterEnv
+ (rule::local_var_def_list) // Locals
+ (meta_grammar) // Lambda
)
+ struct lambda_eval
+ : proto::callable
+ {
+ template <typename Sig>
+ struct result;
+
+ template <typename This, typename Env, typename OuterEnv, typename Locals, typename Lambda>
+ struct result<This(Env, OuterEnv, Locals &, Lambda &)>
+ {
+ typedef
+ typename proto::detail::uncvref<
+ typename boost::result_of<
+ functional::actions(Env)
+ >::type
+ >::type
+ actions_type;
+
+ typedef typename proto::detail::uncvref<Locals>::type locals_type;
+ typedef typename proto::detail::uncvref<OuterEnv>::type outer_env_type;
+ typedef typename proto::detail::uncvref<Env>::type env_type;
+ typedef scoped_environment<env_type const, outer_env_type const, locals_type const> scoped_env;
+ typedef fusion::vector2<scoped_env, actions_type&> new_env_type;
+ typedef
+ typename mpl::eval_if<
+ /*proto::matches<
+ typename proto::detail::uncvref<Locals>::type
+ , proto::terminal<mpl::void_>
+ >*/mpl::false_
+ , boost::result_of<evaluator(Lambda &, Env)>
+ , boost::result_of<evaluator(Lambda &, new_env_type)>
+ >::type type;
+ //typedef int type;
+ };
+
+ template <typename Env, typename OuterEnv, typename Locals, typename Lambda>
+ typename result<lambda_eval(Env &, OuterEnv const&, Locals &, Lambda &)>::type
+ operator()(Env& env, OuterEnv const & outer_env, Locals const& locals, Lambda const& lambda) const
+ {
+ typedef
+ typename proto::detail::uncvref<
+ typename boost::result_of<
+ functional::actions(Env &)
+ >::type
+ >::type
+ actions_type;
+
+ typedef typename proto::detail::uncvref<Locals>::type locals_type;
+ typedef typename proto::detail::uncvref<OuterEnv>::type outer_env_type;
+ typedef typename proto::detail::uncvref<Env>::type env_type;
+ typedef scoped_environment<env_type const, outer_env_type const, locals_type const> scoped_env_type;
+
+ outer_env_type o = outer_env;
+ env_type e = env;
+ locals_type l = locals;
+
+ scoped_env_type
+ scoped_env(
+ e
+ , o
+ , l
+ );
+
+ std::cout << typeid(env).name() << "\n";
+ std::cout << typeid(fusion::at_c<0>(env)).name() << "\n";
+ std::cout << typeid(fusion::at_c<0>(outer_env)).name() << "\n";
+ std::cout << fusion::at_c<0>(fusion::at_c<0>(env)) << "\n";
+ std::cout << "fuuu\n";
+ //std::cout << fusion::at_c<0>(fusion::at_c<0>(outer_env)) << "\n";
+ //std::cout << fusion::at_c<0>(outer_env) << "\n";
+
+ fusion::vector2<scoped_env_type, actions_type>
+ new_env(scoped_env, functional::actions()(env));
+
+ //std::cout << eval(lambda, new_env) << "\n";
+ /*
+ //std::cout << "success!\n";
+ return eval(lambda, new_env);
+ */
+ //std::cout << typeid(Locals).name() << "\n";
+ return eval(lambda, new_env);
+ }
+ };
+
+ template <typename Dummy>
+ struct default_actions::when<rule::lambda, Dummy>
+ : proto::call<lambda_eval(_env, proto::_value(proto::_child_c<0>), proto::_child_c<1>, proto::_child_c<2>)>
+ {};
+
+ namespace detail
+ {
+ template <typename Dummy>
+ struct is_nullary_::when<rule::lambda, Dummy>
+ : proto::when<
+ expression::lambda<
+ proto::terminal<proto::_>
+ , rule::local_var_def_list
+ , meta_grammar
+ >
+ , evaluator(proto::_child_c<2>, _env)
+ >
+ {};
+ }
+
+ namespace tag
+ {
+ struct lambda_actor {};
+ }
+
+ namespace expression
+ {
+ template <typename A0 = void, typename A1 = void, typename Dummy = void>
+ struct lambda_actor;
+
+ template <typename A0>
+ struct lambda_actor<A0>
+ : expr/*_ext<lambda_actor,*/< tag::lambda_actor, A0>
+ {};
+
+ template <typename A0, typename A1>
+ struct lambda_actor<A0, A1>
+ : expr/*_ext<lambda_actor,*/< tag::lambda_actor, A0, A1>
+ {};
+ }
+
+ namespace rule
+ {
+ struct lambda_actor
+ : proto::or_<
+ expression::lambda_actor<meta_grammar>
+ , expression::lambda_actor<rule::local_var_def_list, meta_grammar>
+ >
+ {};
+ }
+
+ namespace detail
+ {
+ template <typename Dummy>
+ struct is_nullary_::when<rule::lambda_actor, Dummy>
+ : proto::or_<
+ proto::when<
+ expression::lambda_actor<meta_grammar>
+ , mpl::true_()
+ >
+ , proto::when<
+ expression::lambda_actor<
+ rule::local_var_def_list
+ , meta_grammar
+ >
+ , evaluator(proto::_child_c<1>, _env)
+ >
+ >
+ {};
+ }
+
+
+ template <typename Dummy>
+ struct meta_grammar::case_<tag::lambda_actor, Dummy>
+ : proto::when<rule::lambda_actor, proto::external_transform>
+ {};
+
+ struct lambda_actor_eval
+ : proto::callable
+ {
+ template <typename Sig>
+ struct result;
+
+ template <typename This, typename Env, typename Lambda>
+ struct result<This(Env, Lambda &)>
+ {
+ typedef typename proto::detail::uncvref<Env>::type env_type;
+ typedef typename expression::lambda<env_type, mpl::void_, typename proto::detail::uncvref<Lambda>::type>::type const type;
+ };
+
+ template <typename This, typename Env, typename Locals, typename Lambda>
+ struct result<This(Env, Locals, Lambda)>
+ {
+ typedef
+ typename proto::detail::uncvref<
+ typename boost::result_of<
+ rule::local_var_def_list(
+ typename proto::detail::uncvref<Locals>::type &
+ , Env
+ )
+ >::type
+ >::type
+ locals_type;
+ typedef typename proto::detail::uncvref<Env>::type env_type;
+
+ typedef
+ typename expression::lambda<env_type, locals_type, typename proto::detail::uncvref<Lambda>::type>::type const type;
+ };
+
+ template <typename Env, typename Lambda>
+ typename result<lambda_actor_eval(Env&, Lambda const&)>::type
+ operator()(Env & env, Lambda const& lambda) const
+ {
+ typedef typename proto::detail::uncvref<Env>::type env_type;
+ //proto::terminal<mpl::void_>::type t = {mpl::void_()};
+ //return expression::lambda<env_type, proto::terminal<mpl::void_>::type, Lambda>::make(env, t, lambda);
+ mpl::void_ t;
+ return expression::lambda<env_type, mpl::void_, Lambda>::make(env, t, lambda);
+ }
+
+ template <typename Env, typename Locals, typename Lambda>
+ typename result<lambda_actor_eval(Env&, Locals const&, Lambda const&)>::type
+ operator()(Env & env, Locals const& locals, Lambda const& lambda) const
+ {
+ typedef
+ typename proto::detail::uncvref<
+ typename boost::result_of<
+ rule::local_var_def_list(
+ Locals &
+ , Env &
+ )
+ >::type
+ >::type
+ locals_type;
+
+ locals_type l =
+ rule::local_var_def_list()(
+ locals
+ , env
+ );
+
+ typedef typename proto::detail::uncvref<Env>::type env_type;
+ static env_type e(env);
+
+ std::cout << typeid(env).name() << "\n";
+
+ return expression::lambda<env_type, locals_type, Lambda>::make(e, l, lambda);
+ }
+ };
+
+ template <typename Dummy>
+ struct default_actions::when<rule::lambda_actor, Dummy>
+ : proto::call<lambda_actor_eval(_env, unpack)>
+ {};
+
+ /*
+ template <typename Expr>
+ struct lambda_actor
+ : actor<Expr>
+ {
+ typedef actor< Expr > base_type;
+
+ lambda_actor(base_type const & base)
+ : base_type( base )
+ {}
+ };
+ */
+
template <typename Locals = void, typename Dummy = void>
struct lambda_actor_gen;
@@ -39,10 +293,10 @@
struct lambda_actor_gen<void, void>
{
template <typename Expr>
- Expr const &
+ typename expression::lambda_actor<Expr>::type const
operator[](Expr const & expr) const
{
- return expr;
+ return expression::lambda_actor<Expr>::make(expr);
}
};
@@ -54,19 +308,20 @@
{}
template <typename Expr>
- typename expression::lambda<
+ typename expression::lambda_actor<
Locals
, Expr
>::type const
operator[](Expr const & expr) const
{
- return expression::lambda<Locals, Expr>::make(locals, expr);
+ return expression::lambda_actor<Locals, Expr>::make(locals, expr);
}
Locals locals;
};
struct lambda_local_gen
+ : lambda_actor_gen<>
{
lambda_actor_gen<> const
operator()() const
@@ -95,7 +350,7 @@
};
- lambda_local_gen const lambda = {};
+ lambda_local_gen const lambda = lambda_local_gen();
#if 0
namespace result_of
Modified: sandbox/SOC/2010/phoenix3/boost/phoenix/scope/let.hpp
==============================================================================
--- sandbox/SOC/2010/phoenix3/boost/phoenix/scope/let.hpp (original)
+++ sandbox/SOC/2010/phoenix3/boost/phoenix/scope/let.hpp 2010-12-06 04:55:29 EST (Mon, 06 Dec 2010)
@@ -17,10 +17,36 @@
namespace boost { namespace phoenix
{
+ struct let_grammar
+ : proto::or_<
+ proto::when<rule::local_variable, proto::external_transform>
+ , meta_grammar
+ >
+ {};
+
+ struct let_evaluator
+ : proto::call<
+ let_grammar(
+ proto::_
+ , functional::args(proto::_state)
+ , functional::actions(proto::_state)
+ )
+ >
+ {};
+
+ struct let_actions
+ {
+ template <typename Rule>
+ struct when
+ : default_actions::when<Rule, let_grammar>
+ {};
+ };
+
PHOENIX_DEFINE_EXPRESSION(
let
, (rule::local_var_def_list)
- (meta_grammar)
+ (let_grammar)
+ //(meta_grammar)
)
struct let_eval
@@ -52,9 +78,9 @@
typedef
typename boost::result_of<
- evaluator(
+ let_evaluator(
Let const &
- , fusion::vector2<scoped_environment<Env, Env, locals_type&> &, actions_type> &
+ , fusion::vector2<scoped_environment<Env, Env, locals_type&> &, let_actions>&//actions_type> &
)
>::type
type;
@@ -64,6 +90,7 @@
typename result<let_eval(Env&, Locals const &, Let const &)>::type
operator()(Env & env, Locals const & locals, Let const & let) const
{
+ /*
typedef
typename proto::detail::uncvref<
typename boost::result_of<
@@ -71,6 +98,7 @@
>::type
>::type
actions_type;
+ */
typedef
typename proto::detail::uncvref<
@@ -96,9 +124,14 @@
, l
);
- fusion::vector2<scoped_environment<Env, Env, locals_type &> &, actions_type>
- new_env(scoped_env, functional::actions()(env));
- return eval(let, new_env);
+ fusion::vector2<scoped_environment<Env, Env, locals_type &> &, let_actions>
+ new_env(scoped_env, let_actions());//functional::actions()(env));
+
+ std::cout << ":(\n";
+ std::cout << typeid(Let).name() << "\n";
+
+ return let_evaluator()(let, new_env);
+ //return eval(let, new_env);
}
};
@@ -171,6 +204,23 @@
};
let_local_gen const let = {};
+
+ namespace detail
+ {
+ struct let_is_nullary
+ : proto::or_<
+ proto::when<rule::let, mpl::and_<let_is_nullary(proto::_child_c<0>, _env), let_is_nullary(proto::_child_c<1>, _env)>() >
+ , proto::when<rule::local_var_def_list, detail::local_var_def_is_nullary(proto::_, _env)>
+ , proto::when<rule::local_variable, mpl::true_()>
+ , proto::otherwise<evaluator(proto::_, _env)>
+ >
+ {};
+
+ template <typename Dummy>
+ struct is_nullary_::when<rule::let, Dummy>
+ : proto::make<let_is_nullary>
+ {};
+ }
}}
#endif
Modified: sandbox/SOC/2010/phoenix3/boost/phoenix/scope/local_variable.hpp
==============================================================================
--- sandbox/SOC/2010/phoenix3/boost/phoenix/scope/local_variable.hpp (original)
+++ sandbox/SOC/2010/phoenix3/boost/phoenix/scope/local_variable.hpp 2010-12-06 04:55:29 EST (Mon, 06 Dec 2010)
@@ -14,16 +14,60 @@
namespace boost { namespace phoenix
{
- template <typename Key>
- struct local_variable
+
+ namespace detail
{
- typedef Key type;
- };
+ template <typename Key>
+ struct local
+ {
+ typedef Key type;
+ };
+ }
+
+ namespace tag
+ {
+ struct local_variable {};
+ }
namespace expression
{
- template <typename Key>
+ template <typename Key, typename _ = proto::is_proto_expr>
struct local_variable
+ {
+ typedef expr<tag::local_variable, Key> expr_type;
+ typedef typename expr_type::type type;
+ typedef typename expr_type::proto_grammar proto_grammar;
+ //BOOST_PROTO_BASIC_EXTENDS(typename expr_type::type, local_variable, phoenix_domain)
+ };
+ /* : proto::transform<local_variable<Key>, int>
+ {
+ typedef detail::local_expr<tag::local_variable, detail::local<Key> > type;
+ typedef detail::local_expr<tag::local_variable, detail::local<Key> > proto_grammar;
+
+ template <typename Expr, typename State, typename Data>
+ struct impl : proto::transform_impl<Expr, State, Data>
+ {
+ typedef Expr result_type;
+
+ result_type
+ operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param
+ , typename impl::data_param
+ ) const
+ {
+ return e;
+ }
+ };
+
+ /// INTERNAL ONLY
+ typedef tag::local_variable proto_tag;
+ /// INTERNAL ONLY
+ typedef detail::local<Key> proto_child0;
+
+ };
+ */
+ /*
: proto::terminal< ::boost::phoenix::local_variable<Key> >
{
typedef
@@ -46,12 +90,14 @@
return e;
}
};
+ */
}
namespace rule
{
struct local_variable
- : proto::terminal< ::boost::phoenix::local_variable<proto::_> >
+ : expression::local_variable<proto::_>
+ //: proto::terminal< ::boost::phoenix::local_variable<proto::_> >
{};
struct local_var_def
@@ -86,7 +132,7 @@
operator()(Expr& expr, Env & env) const
{
typedef typename result<local_eval(Expr const&, Env&)>::result_type result_type;
-
+
return this->make(expr, env, typename is_reference<result_type>::type());
}
@@ -180,7 +226,8 @@
struct find_local
: proto::or_<
- proto::when<
+ proto::when<proto::terminal<mpl::void_>, detail::local_var_not_found()>
+ , proto::when<
proto::comma<find_local, rule::local_var_def>
, proto::if_<
proto::matches<proto::_left(proto::_right), proto::_data>()
@@ -201,7 +248,33 @@
template<typename This, typename Args, typename Env, typename Key>
struct get_local_result_impl
- : mpl::if_<
+ : mpl::eval_if<
+ is_same<
+ typename Args::locals_type
+ , mpl::void_
+ >
+ , boost::result_of<
+ This(typename Args::outer_env_type&)
+ >
+ , mpl::eval_if<
+ is_same<
+ typename proto::detail::uncvref<
+ typename boost::result_of<
+ detail::find_local(typename Args::locals_type &, Env, Key)
+ >::type
+ >::type
+ , detail::local_var_not_found
+ >
+ , boost::result_of<
+ This(typename Args::outer_env_type&)
+ >
+ , boost::result_of<
+ detail::find_local(typename Args::locals_type &, Env, Key)
+ >
+ >
+ >
+ /*
+ : mpl::if_<
typename is_same<
typename proto::detail::uncvref<
typename boost::result_of<
@@ -217,6 +290,23 @@
detail::find_local(typename Args::locals_type &, Env, Key)
>::type
>
+ */
+ {};
+
+ struct local_var_def_is_nullary
+ : proto::or_<
+ proto::when<
+ proto::comma<local_var_def_is_nullary, rule::local_var_def>
+ , mpl::and_<
+ local_var_def_is_nullary(proto::_left, _env)
+ , evaluator(proto::_right(proto::_right), _env)
+ >()
+ >
+ , proto::when<
+ rule::local_var_def
+ , evaluator(proto::_right, _env)
+ >
+ >
{};
}
@@ -317,6 +407,7 @@
};
+ /*
template<typename T>
struct is_custom_terminal<local_variable<T> >
: mpl::true_
@@ -325,6 +416,9 @@
template<typename T>
struct custom_terminal<local_variable<T> >
: proto::callable
+ */
+ struct local_var_eval
+ : proto::callable
{
template <typename Sig>
struct result;
@@ -333,7 +427,7 @@
struct result<This(Local &, Env)>
{
typedef
- proto::terminal< local_variable<typename Local::type> >
+ typename expression::local_variable<Local>::type
lookup_grammar;
typedef
@@ -342,17 +436,24 @@
};
template <typename Local, typename Env>
- typename result<custom_terminal(Local const &, Env&)>::type
+ //typename result<custom_terminal(Local const &, Env&)>::type
+ typename result<local_var_eval(Local const &, Env&)>::type
operator()(Local & local, Env & env)
{
typedef
- proto::terminal< local_variable<typename Local::type> >
+ typename expression::local_variable<Local>::type
lookup_grammar;
-
+ std::cout << "muuh ...\n";
return get_local<lookup_grammar>()(env);
}
};
+ template <typename Dummy>
+ struct default_actions::when<rule::local_variable, Dummy>
+ : proto::call<local_var_eval(proto::_value(proto::_child_c<0>), _env)>
+ {};
+
+#if 0
struct foo
: proto::callable
{
@@ -367,43 +468,44 @@
template <typename T>
struct is_nullary<custom_terminal<local_variable<T> > >
- //: proto::make<mpl::false_()>
- : proto::if_<
+ : proto::make<mpl::false_()>
+ /*: proto::if_<
//is_scoped_environment<functional::args(proto::_state)>()
foo(functional::args(proto::_state))
, mpl::false_()
, mpl::true_()
- >
+ >*/
{};
-
+#endif
+
namespace local_names
{
- expression::local_variable<struct _a_key>::type const _a = {};
- expression::local_variable<struct _b_key>::type const _b = {};
- expression::local_variable<struct _c_key>::type const _c = {};
- expression::local_variable<struct _d_key>::type const _d = {};
- expression::local_variable<struct _e_key>::type const _e = {};
- expression::local_variable<struct _f_key>::type const _f = {};
- expression::local_variable<struct _g_key>::type const _g = {};
- expression::local_variable<struct _h_key>::type const _h = {};
- expression::local_variable<struct _i_key>::type const _i = {};
- expression::local_variable<struct _j_key>::type const _j = {};
- expression::local_variable<struct _k_key>::type const _k = {};
- expression::local_variable<struct _l_key>::type const _l = {};
- expression::local_variable<struct _m_key>::type const _m = {};
- expression::local_variable<struct _n_key>::type const _n = {};
- expression::local_variable<struct _o_key>::type const _o = {};
- expression::local_variable<struct _p_key>::type const _p = {};
- expression::local_variable<struct _q_key>::type const _q = {};
- expression::local_variable<struct _r_key>::type const _r = {};
- expression::local_variable<struct _s_key>::type const _s = {};
- expression::local_variable<struct _t_key>::type const _t = {};
- expression::local_variable<struct _u_key>::type const _u = {};
- expression::local_variable<struct _v_key>::type const _v = {};
- expression::local_variable<struct _w_key>::type const _w = {};
- expression::local_variable<struct _x_key>::type const _x = {};
- expression::local_variable<struct _y_key>::type const _y = {};
- expression::local_variable<struct _z_key>::type const _z = {};
+ expression::local_variable<detail::local<struct _a_key> >::type const _a = {};
+ expression::local_variable<detail::local<struct _b_key> >::type const _b = {};
+ expression::local_variable<detail::local<struct _c_key> >::type const _c = {};
+ expression::local_variable<detail::local<struct _d_key> >::type const _d = {};
+ expression::local_variable<detail::local<struct _e_key> >::type const _e = {};
+ expression::local_variable<detail::local<struct _f_key> >::type const _f = {};
+ expression::local_variable<detail::local<struct _g_key> >::type const _g = {};
+ expression::local_variable<detail::local<struct _h_key> >::type const _h = {};
+ expression::local_variable<detail::local<struct _i_key> >::type const _i = {};
+ expression::local_variable<detail::local<struct _j_key> >::type const _j = {};
+ expression::local_variable<detail::local<struct _k_key> >::type const _k = {};
+ expression::local_variable<detail::local<struct _l_key> >::type const _l = {};
+ expression::local_variable<detail::local<struct _m_key> >::type const _m = {};
+ expression::local_variable<detail::local<struct _n_key> >::type const _n = {};
+ expression::local_variable<detail::local<struct _o_key> >::type const _o = {};
+ expression::local_variable<detail::local<struct _p_key> >::type const _p = {};
+ expression::local_variable<detail::local<struct _q_key> >::type const _q = {};
+ expression::local_variable<detail::local<struct _r_key> >::type const _r = {};
+ expression::local_variable<detail::local<struct _s_key> >::type const _s = {};
+ expression::local_variable<detail::local<struct _t_key> >::type const _t = {};
+ expression::local_variable<detail::local<struct _u_key> >::type const _u = {};
+ expression::local_variable<detail::local<struct _v_key> >::type const _v = {};
+ expression::local_variable<detail::local<struct _w_key> >::type const _w = {};
+ expression::local_variable<detail::local<struct _x_key> >::type const _x = {};
+ expression::local_variable<detail::local<struct _y_key> >::type const _y = {};
+ expression::local_variable<detail::local<struct _z_key> >::type const _z = {};
}
namespace detail
Modified: sandbox/SOC/2010/phoenix3/boost/phoenix/scope/scoped_environment.hpp
==============================================================================
--- sandbox/SOC/2010/phoenix3/boost/phoenix/scope/scoped_environment.hpp (original)
+++ sandbox/SOC/2010/phoenix3/boost/phoenix/scope/scoped_environment.hpp 2010-12-06 04:55:29 EST (Mon, 06 Dec 2010)
@@ -30,7 +30,7 @@
typedef OuterEnv outer_env_type;
typedef Locals locals_type;
- scoped_environment(Env& env, OuterEnv& outer_env, Locals const& locals)
+ scoped_environment(Env& env, OuterEnv& outer_env, Locals & locals)
: env(env)
, outer_env(outer_env)
, locals(locals)
@@ -40,13 +40,11 @@
: env(o.env)
, outer_env(o.outer_env)
, locals(o.locals)
- {
- std::cout << "cctor called\n";
- }
+ {}
- Env env;
- OuterEnv outer_env;
- Locals locals;
+ Env &env;
+ OuterEnv &outer_env;
+ Locals &locals;
#define PHOENIX_ADAPT_SCOPED_ENVIRONMENT(INTRINSIC) \
template <typename Seq> \
Modified: sandbox/SOC/2010/phoenix3/libs/phoenix/test/scope/lambda_tests.cpp
==============================================================================
--- sandbox/SOC/2010/phoenix3/libs/phoenix/test/scope/lambda_tests.cpp (original)
+++ sandbox/SOC/2010/phoenix3/libs/phoenix/test/scope/lambda_tests.cpp 2010-12-06 04:55:29 EST (Mon, 06 Dec 2010)
@@ -70,19 +70,20 @@
using boost::phoenix::lambda;
using boost::phoenix::let;
using boost::phoenix::ref;
+ using boost::phoenix::val;
using boost::phoenix::arg_names::_1;
using boost::phoenix::arg_names::_2;
using boost::phoenix::local_names::_a;
using boost::phoenix::local_names::_b;
using boost::phoenix::placeholders::arg1;
+ /*
{
int x = 1;
int y = lambda[_1]()(x);
BOOST_TEST(x == y);
}
-/*
{
int x = 1, y = 10;
BOOST_TEST(
@@ -103,17 +104,15 @@
(x, z)(y) == x + y + z
);
}
+
{
int x = 4;
int y = 5;
- //lambda(_a = _1)[_a = 555](x)();
-
- std::cout << typeid(lambda(_a = _1)[_a = 555](x)()).name() << "\n";
- std::cout << typeid(lambda(_a = _1)[_a = 555](x)(0)).name() << "\n";
-
+ lambda(_a = _1)[_a = 555](x)();
BOOST_TEST(x == 555);
(void)y;
}
+
{
int x = 1;
long x2 = 2;
@@ -123,9 +122,9 @@
BOOST_TEST(lambda[_1](x)(y) == y);
BOOST_TEST(lambda(_a = _1)[_a](x)(y) == x);
- BOOST_TEST(lambda(_a = _1)[lambda[_a]](x)(y)(z) == x);
- BOOST_TEST(lambda(_a = _1)[lambda[_a + _1]](x)(y)(x) == 2);
- BOOST_TEST(lambda(_a = _1)[lambda(_b = _1)[_a + _b + _1]](x)(x2)(x3) == 6);
+ //BOOST_TEST(lambda(_a = _1)[lambda[_a]](x)(y)(z) == x);
+ //BOOST_TEST(lambda(_a = _1)[lambda[_a + _1]](x)(y)(x) == 2);
+ //BOOST_TEST(lambda(_a = _1)[lambda(_b = _1)[_a + _b + _1]](x)(x2)(x3) == 6);
}
{
@@ -134,20 +133,33 @@
(_1 + lambda(_a = _1)[_a + _1 + 2])(x)(y) == 1+1+10+2
);
}
+ */
{
int x = 1, y = 10;
BOOST_TEST(
- (_1 +
+ (
+ _1 +
lambda(_a = _1)
[
+ //_a + lambda[_a + 2]
_a + lambda[_a + 2]
]
)
(x)(y)(y) == 1+1+1+2
);
+ std::cout << (
+ _1 +
+ lambda(_a = _1)
+ [
+ //_a + lambda[_a + 2]
+ _1 + lambda(_b = _1)[_a + 2]
+ ]
+ )
+ (x)(y)(y) << "\n";
}
+ /*
{
using boost::phoenix::for_each;
@@ -184,21 +196,33 @@
(x, z)(y) == x + y + z
);
}
+ */
+ /*
{
// $$$ Fixme. This should not be failing $$$
- //int x = (let(_a = lambda[val(1)])[_a])(0)(0);
+ int x = (let(_a = lambda[val(1)])[_a])()();
//BOOST_TEST(x == 1);
}
+ */
+ /*
{
- int i = 0;
- lambda[let(_a = _1)[_a = _2](_1, _2)]()(i, 2);
// $$$ Fixme. This should not be failing $$$
- //lambda[let(_a = _1)[_a = _2]]()(i, 2);
- BOOST_TEST(i == 2);
+ int x = (let(_a = lambda[val(1)])[_a])(0);
+ //BOOST_TEST(x == 1);
}
-*/
+ */
+
+ /*
+ {
+ int i = 0;
+ int j = 2;
+ BOOST_TEST(lambda[let(_a = _1)[_a = _2]]()(i, j) == j);
+ BOOST_TEST(i == j);
+ }
+ */
+
return boost::report_errors();
}
Modified: sandbox/SOC/2010/phoenix3/libs/phoenix/test/scope/let_tests.cpp
==============================================================================
--- sandbox/SOC/2010/phoenix3/libs/phoenix/test/scope/let_tests.cpp (original)
+++ sandbox/SOC/2010/phoenix3/libs/phoenix/test/scope/let_tests.cpp 2010-12-06 04:55:29 EST (Mon, 06 Dec 2010)
@@ -46,7 +46,6 @@
using boost::phoenix::local_names::_z;
using boost::phoenix::placeholders::arg1;
-#if 0
{
int x = 1;
BOOST_TEST(
@@ -83,6 +82,7 @@
);
}
+ /*
{
int x = 1, y = 10;
BOOST_TEST(
@@ -133,19 +133,18 @@
BOOST_TEST(x == 999);
}
-#endif
{
+ // FIXME
BOOST_TEST(
let(_a = 1, _b = 2, _c = 3, _d = 4, _e = 5)
[
_a + _b + _c + _d + _e
]
- () == 1 + 2 + 3 + 4 + 5
+ (0) == 1 + 2 + 3 + 4 + 5
);
}
-#if 0
#ifdef PHOENIX_SHOULD_NOT_COMPILE_TEST
{
// disallow this:
@@ -190,7 +189,7 @@
let(_a = _1)[_a = _2](i, 2);
BOOST_TEST(i == 2);
}
-#endif
+ */
return boost::report_errors();
}
Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk