Subject: [Boost-commit] svn:boost r66763 - in sandbox/SOC/2010/phoenix3: boost/phoenix boost/phoenix/statement libs/phoenix/test/statement
From: thom.heller_at_[hidden]
Date: 2010-11-26 02:33:53
Author: theller
Date: 2010-11-26 02:33:48 EST (Fri, 26 Nov 2010)
New Revision: 66763
URL: http://svn.boost.org/trac/boost/changeset/66763
Log:
switch refactoring temporary commit
Text files modified:
sandbox/SOC/2010/phoenix3/boost/phoenix/statement.hpp | 2
sandbox/SOC/2010/phoenix3/boost/phoenix/statement/switch.hpp | 302 +++++++++++++++++++++------------------
sandbox/SOC/2010/phoenix3/libs/phoenix/test/statement/switch_tests.cpp | 11 +
3 files changed, 170 insertions(+), 145 deletions(-)
Modified: sandbox/SOC/2010/phoenix3/boost/phoenix/statement.hpp
==============================================================================
--- sandbox/SOC/2010/phoenix3/boost/phoenix/statement.hpp (original)
+++ sandbox/SOC/2010/phoenix3/boost/phoenix/statement.hpp 2010-11-26 02:33:48 EST (Fri, 26 Nov 2010)
@@ -12,7 +12,7 @@
#include <boost/phoenix/statement/for.hpp>
#include <boost/phoenix/statement/if.hpp>
#include <boost/phoenix/statement/sequence.hpp>
-//#include <boost/phoenix/statement/switch.hpp>
+#include <boost/phoenix/statement/switch.hpp>
//#include <boost/phoenix/statement/throw.hpp>
//#include <boost/phoenix/statement/try_catch.hpp>
#include <boost/phoenix/statement/while.hpp>
Modified: sandbox/SOC/2010/phoenix3/boost/phoenix/statement/switch.hpp
==============================================================================
--- sandbox/SOC/2010/phoenix3/boost/phoenix/statement/switch.hpp (original)
+++ sandbox/SOC/2010/phoenix3/boost/phoenix/statement/switch.hpp 2010-11-26 02:33:48 EST (Fri, 26 Nov 2010)
@@ -10,186 +10,204 @@
#include <boost/phoenix/core/limits.hpp>
#include <boost/phoenix/core/meta_grammar.hpp>
-#include <boost/phoenix/core/compose.hpp>
+#include <boost/phoenix/core/expression.hpp>
+#include <boost/phoenix/core/is_nullary.hpp>
#include <boost/phoenix/support/iterate.hpp>
#include <boost/proto/proto_fwd.hpp>
#include <boost/proto/make_expr.hpp>
namespace boost { namespace phoenix
{
- struct switch_case_tag {};
- struct switch_default_tag {};
+ namespace tag
+ {
+ struct switch_case {};
+ struct switch_default_case {};
+ }
- namespace detail
+ namespace expression
{
- struct case_label
- : proto::terminal<proto::_>
+ template <typename N, typename A>
+ struct switch_case
+ : proto::binary_expr<tag::switch_case, N, A>
{};
-
- struct case_statement
- : proto::binary_expr<switch_case_tag, case_label, eval_grammar>
+
+ template <typename A>
+ struct switch_default_case
+ : proto::unary_expr<tag::switch_default_case, A>
{};
+ }
- struct default_statement
- : proto::unary_expr<switch_default_tag, eval_grammar>
+ namespace rule
+ {
+ struct switch_case
+ : expression::switch_case<
+ proto::terminal<proto::_>
+ , meta_grammar
+ >
{};
-
- struct switch_size
+
+ struct switch_default_case
+ : expression::switch_default_case<
+ meta_grammar
+ >
+ {};
+ }
+ namespace detail
+ {
+ struct switch_case_grammar;
+ struct switch_case_with_default_grammar;
+ struct switch_grammar
: proto::or_<
- proto::when<
- proto::comma<switch_size, proto::_>
- , mpl::next<switch_size(proto::_left)>()
- >
- , proto::when<proto::_, mpl::int_<1>()>
+ detail::switch_case_grammar
+ , detail::switch_case_with_default_grammar
>
{};
+ }
- struct switch_has_default
+ PHOENIX_DEFINE_EXPRESSION(
+ switch_
+ , (meta_grammar) // Cond
+ (detail::switch_grammar) // Cases
+ )
+
+ namespace detail
+ {
+ struct switch_case_is_nullary
: proto::or_<
proto::when<
- proto::comma<switch_size, case_statement>
- , mpl::false_()
+ proto::comma<
+ switch_case_is_nullary
+ , rule::switch_default_case
+ >
+ , mpl::and_<
+ switch_case_is_nullary(proto::_child_c<0>, proto::_state)
+ , evaluator(proto::_child_c<0>(proto::_child_c<1>), proto::_state)
+ >()
>
, proto::when<
- proto::comma<switch_size, default_statement>
- , mpl::true_()
+ proto::comma<
+ switch_case_is_nullary
+ , rule::switch_case
+ >
+ , mpl::and_<
+ switch_case_is_nullary(proto::_child_c<0>, proto::_state)
+ , evaluator(proto::_child_c<1>(proto::_child_c<1>), proto::_state)
+ >()
>
, proto::when<
- case_statement
- , mpl::false_()
+ rule::switch_default_case
+ , evaluator(proto::_child_c<0>, proto::_state)
>
, proto::when<
- default_statement
- , mpl::true_()
+ rule::switch_case
+ , evaluator(proto::_child_c<1>, proto::_state)
>
>
{};
- struct switch_case_statement
- : proto::or_<
- proto::when<
- proto::comma<switch_case_statement, proto::_>
- , proto::if_<
- is_same<mpl::prior<proto::_data>(), proto::_state>()
- , proto::_right
- , switch_case_statement(proto::_left, proto::_state, mpl::prior<proto::_data>())
- >
- >
- , proto::otherwise<proto::_>
+ template <typename Dummy>
+ struct is_nullary_::when<rule::switch_, Dummy>
+ : proto::make<
+ mpl::and_<
+ evaluator(proto::_child_c<0>, _env)
+ , switch_case_is_nullary(proto::_child_c<1>, _env)
+ >()
>
{};
- }
-
- namespace result_of
- {
- template <typename Cases>
- struct cases_size : boost::result_of<detail::switch_size(Cases)> {};
-
- template <typename Cases, typename N>
- struct case_compound
- : mpl::eval_if<
- mpl::less<N, typename cases_size<Cases>::type >
- , boost::result_of<detail::switch_case_statement(Cases, N, typename cases_size<Cases>::type)>
- , mpl::void_
+ struct switch_case_grammar
+ : proto::or_<
+ proto::comma<switch_case_grammar, rule::switch_case>
+ , rule::switch_case
>
{};
- template <typename Case>
- struct case_statement
- : proto::result_of::right<Case>
- {};
-
- template <typename Case>
- struct case_label
- : proto::result_of::value<
- typename proto::result_of::left<
- Case
- >::type
+ struct switch_case_with_default_grammar
+ : proto::or_<
+ proto::comma<switch_case_grammar, rule::switch_default_case>
+ , rule::switch_default_case
>
{};
-
- template <typename Cases>
- struct switch_has_default : boost::result_of<detail::switch_has_default(Cases)> {};
-
- template <typename Case>
- struct is_default_case
- : proto::matches<Case, detail::default_statement>
- {};
- }
-
- template <int N, typename Cases>
- typename result_of::case_compound<Cases, mpl::int_<N> >::type const &
- case_compound_c(Cases const& cases)
- {
- typename result_of::cases_size<Cases>::type size;
- return detail::switch_case_statement()(cases, mpl::int_<N>(), size);
- }
-
- template <typename N, typename Cases>
- typename result_of::case_compound<Cases, N>::type const &
- case_compound(Cases const& cases)
- {
- typename result_of::cases_size<Cases>::type size;
- return detail::switch_case_statement()(cases, N(), size);
}
- template <typename Case>
- typename result_of::case_statement<Case>::type const &
- case_statement(Case const& case_)
+ struct switch_eval
{
- return proto::right(case_);
- }
-
- template <
- typename Cond,
- typename Cases,
- int N = result_of::cases_size<Cases>::type::value,
- typename Dummy = void>
- struct make_switch;
-
- // Bring in the rest ....
- #include <boost/phoenix/statement/detail/switch.hpp>
+ typedef void result_type;
+
+ template <typename Env>
+ result_type
+ operator()(Env & env) const
+ {
+ }
- template <int N, typename A0>
- typename proto::result_of::make_expr<
- switch_case_tag
- , default_domain_with_basic_expr
- , mpl::int_<N>
- , A0
- >::type const
- case_(A0 const& a0)
- {
- typedef typename
- proto::result_of::make_expr<
- switch_case_tag
- , default_domain_with_basic_expr
- , mpl::int_<N>
- , A0
- >::type
- expr_type;
+ template <typename Env, typename Cond, typename Cases>
+ result_type
+ operator()(Env & env, Cond const & cond, Cases const & cases) const
+ {
+ /*
+ typedef typename fusion::result_of::as_vector<Cases>::type as_vector;
+ std::cout << typeid(Cases).name() << "\n";
+ std::cout << fusion::result_of::size<Cases>::value << "\n";
+ std::cout << typeid(typename fusion::result_of::at_c<as_vector, 0>::type).name() << "\n";
+ std::cout << typeid(typename proto::matches<typename Cases::expr_type, detail::switch_case_with_default_grammar>::type).name() << "\n";
+ */
+ //std::cout << typeid(typename fusion::result_of::at_c<flattened_expr, 2>::type).name() << "\n";
+ this->evaluate(env, cond, fusion::as_vector(cases), mpl::int_<fusion::result_of::size<Cases>::value>(), typename proto::matches<typename Cases::expr_type, detail::switch_case_with_default_grammar>::type());
+ }
- expr_type const e = {mpl::int_<N>(), a0};
- return e;
- }
+ //proto::result_of::child_c<typename fusion::result_of::at_c<Cases, N>::type, 0>::type::value :
+ private:
+ #define PHOENIX_SWITCH_EVAL_R(Z, N, DATA) \
+ case \
+ proto::value< \
+ typename proto::result_of::child_c<\
+ typename fusion::result_of::at_c<Cases, N>::type \
+ , 0 \
+ >::type \
+ >::type::value : \
+ eval(proto::child_c<1>(fusion::at_c<N>(cases)), env);
+ /**/
+ #define PHOENIX_SWITCH_EVAL(Z, N, DATA) \
+ template <typename Env, typename Cond, typename Cases> \
+ result_type evaluate(Env & env, Cond const & cond, Cases const & cases, mpl::int_<N>, mpl::false_) const\
+ { \
+ } \
+ \
+ template <typename Env, typename Cond, typename Cases> \
+ result_type evaluate(Env & env, Cond const & cond, Cases const & cases, mpl::int_<N>, mpl::true_) const\
+ { \
+ switch(eval(cond, env)) \
+ { \
+ BOOST_PP_REPEAT(BOOST_PP_DEC(N), PHOENIX_SWITCH_EVAL_R, _) \
+ default: eval(fusion::at_c<N-1>(cases), env); \
+ } \
+ } \
+ /**/
+ BOOST_PP_REPEAT(PHOENIX_LIMIT, PHOENIX_SWITCH_EVAL, _)
+ };
- template <typename A0>
- typename proto::result_of::make_expr<
- switch_default_tag
- , default_domain_with_basic_expr
- , A0
- >::type const
- default_(A0 const& a0)
- {
- typedef typename
- proto::result_of::make_expr<
- switch_default_tag
- , default_domain_with_basic_expr
- , A0
- >::type
- expr_type;
-
- expr_type const e = {a0};
- return e;
+ template <typename Dummy>
+ struct default_actions::when<rule::switch_, Dummy>
+ : proto::call<
+ switch_eval(
+ _env
+ , proto::_child_c<0> // Cond
+ , proto::functional::flatten(proto::_child_c<1>) // Cases
+ )
+ >
+ {};
+
+ template <int N, typename A>
+ typename proto::result_of::make_expr<tag::switch_case, default_domain_with_basic_expr, mpl::int_<N>, A>::type const
+ case_(A const & a)
+ {
+ return proto::make_expr<tag::switch_case, default_domain_with_basic_expr>(mpl::int_<N>(), a);
+ }
+
+ template <typename A>
+ typename proto::result_of::make_expr<tag::switch_default_case, default_domain_with_basic_expr, A>::type const
+ default_(A const& a)
+ {
+ return proto::make_expr<tag::switch_default_case, default_domain_with_basic_expr>(a);
}
template <typename Cond>
@@ -198,15 +216,15 @@
switch_gen(Cond const& cond) : cond(cond) {}
template <typename Cases>
- typename make_switch<
+ typename expression::switch_<
Cond
, Cases
>::type
operator[](Cases const& cases) const
{
- BOOST_MPL_ASSERT((proto::matches<Cases, detail::switch_case_statement>));
+ BOOST_MPL_ASSERT((proto::matches<Cases, detail::switch_grammar>));
- return make_switch<Cond, Cases>()(cond, cases);
+ return expression::switch_<Cond, Cases>::make(cond, cases);
}
Cond const& cond;
Modified: sandbox/SOC/2010/phoenix3/libs/phoenix/test/statement/switch_tests.cpp
==============================================================================
--- sandbox/SOC/2010/phoenix3/libs/phoenix/test/statement/switch_tests.cpp (original)
+++ sandbox/SOC/2010/phoenix3/libs/phoenix/test/statement/switch_tests.cpp 2010-11-26 02:33:48 EST (Fri, 26 Nov 2010)
@@ -4,20 +4,23 @@
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)
==============================================================================*/
+
+#define PHOENIX_LIMIT 10
+
#include <iostream>
#include <vector>
#include <algorithm>
#include <boost/detail/lightweight_test.hpp>
+#include <boost/phoenix/core.hpp>
#include <boost/phoenix/statement.hpp>
#include <boost/phoenix/operator.hpp>
-#include <boost/phoenix/core.hpp>
int
main()
{
using boost::phoenix::arg_names::_1;
using boost::phoenix::case_;
- using boost::phoenix::default_;
+ //using boost::phoenix::default_;
using boost::phoenix::switch_;
using boost::phoenix::ref;
using boost::phoenix::val;
@@ -30,6 +33,7 @@
int init[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
vector<int> v(init, init+10);
+ /*
for_each(v.begin(), v.end(),
switch_(_1)
[
@@ -37,6 +41,7 @@
case_<4>(cout << val("<4>") << endl)
]
);
+ */
cout << endl;
for_each(v.begin(), v.end(),
@@ -49,6 +54,7 @@
cout << endl;
+ /*
for_each(v.begin(), v.end(),
switch_(_1)
[
@@ -58,6 +64,7 @@
case_<4>(cout << val("<4>") << endl)
]
);
+ */
cout << endl;