Boost-Commit :

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r71811 - in trunk: boost/proto boost/proto/detail/preprocessed boost/proto/transform boost/proto/transform/detail boost/proto/transform/detail/preprocessed libs/proto/preprocess
From: eric_at_[hidden]
Date: 2011-05-08 07:42:43

Author: eric_niebler
Date: 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
New Revision: 71811
URL: http://svn.boost.org/trac/boost/changeset/71811

Log:
more pre-preprocessing, bump all the max arities to 10, more p-pp work to come...
Added:
   trunk/boost/proto/transform/detail/construct_funop.hpp (contents, props changed)
   trunk/boost/proto/transform/detail/construct_pod_funop.hpp (contents, props changed)
   trunk/boost/proto/transform/detail/default_function_impl.hpp (contents, props changed)
   trunk/boost/proto/transform/detail/fold_impl.hpp (contents, props changed)
   trunk/boost/proto/transform/detail/lazy.hpp (contents, props changed)
   trunk/boost/proto/transform/detail/make.hpp (contents, props changed)
   trunk/boost/proto/transform/detail/make_gcc_workaround.hpp (contents, props changed)
   trunk/boost/proto/transform/detail/preprocessed/construct_funop.hpp (contents, props changed)
   trunk/boost/proto/transform/detail/preprocessed/construct_pod_funop.hpp (contents, props changed)
   trunk/boost/proto/transform/detail/preprocessed/default_function_impl.hpp (contents, props changed)
   trunk/boost/proto/transform/detail/preprocessed/fold_impl.hpp (contents, props changed)
   trunk/boost/proto/transform/detail/preprocessed/lazy.hpp (contents, props changed)
   trunk/boost/proto/transform/detail/preprocessed/make.hpp (contents, props changed)
   trunk/boost/proto/transform/detail/preprocessed/make_gcc_workaround.hpp (contents, props changed)
Text files modified:
   trunk/boost/proto/detail/preprocessed/and_n.hpp | 68 +
   trunk/boost/proto/detail/preprocessed/args.hpp | 82 +
   trunk/boost/proto/detail/preprocessed/basic_expr.hpp | 352 ++++++
   trunk/boost/proto/detail/preprocessed/deep_copy.hpp | 115 ++
   trunk/boost/proto/detail/preprocessed/expr.hpp | 2002 +++++++++++++++++++++++++++++++++++++++
   trunk/boost/proto/detail/preprocessed/expr_variadic.hpp | 917 ++++++++++++++++++
   trunk/boost/proto/detail/preprocessed/extends_funop.hpp | 5
   trunk/boost/proto/detail/preprocessed/extends_funop_const.hpp | 5
   trunk/boost/proto/detail/preprocessed/funop.hpp | 175 +++
   trunk/boost/proto/detail/preprocessed/generate_by_value.hpp | 230 ++++
   trunk/boost/proto/detail/preprocessed/lambda_matches.hpp | 75 +
   trunk/boost/proto/detail/preprocessed/make_expr.hpp | 170 +++
   trunk/boost/proto/detail/preprocessed/make_expr_.hpp | 171 +++
   trunk/boost/proto/detail/preprocessed/make_expr_funop.hpp | 135 ++
   trunk/boost/proto/detail/preprocessed/matches_.hpp | 102 ++
   trunk/boost/proto/detail/preprocessed/or_n.hpp | 26
   trunk/boost/proto/detail/preprocessed/traits.hpp | 756 ++++++++++++++
   trunk/boost/proto/detail/preprocessed/unpack_expr_.hpp | 205 ++++
   trunk/boost/proto/detail/preprocessed/vararg_matches_impl.hpp | 95 +
   trunk/boost/proto/proto_fwd.hpp | 10
   trunk/boost/proto/transform/default.hpp | 1031 +++++++++----------
   trunk/boost/proto/transform/detail/preprocessed/call.hpp | 150 ++
   trunk/boost/proto/transform/fold.hpp | 516 ++++-----
   trunk/boost/proto/transform/lazy.hpp | 121 -
   trunk/boost/proto/transform/make.hpp | 672 ++++--------
   trunk/libs/proto/preprocess/preprocess_proto.cpp | 4
   26 files changed, 6766 insertions(+), 1424 deletions(-)

Modified: trunk/boost/proto/detail/preprocessed/and_n.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/and_n.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/and_n.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -240,3 +240,71 @@
                 return Gimpl7()(e,s,d);
             }
         };
+
+
+
+ template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7>
+ struct and_9
+ : and_8<
+ P0::value ,
+ P1 , P2 , P3 , P4 , P5 , P6 , P7
+ >
+ {};
+ template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7>
+ struct and_9<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7>
+ : mpl::false_
+ {};
+ template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8, typename Expr, typename State, typename Data>
+ struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8>, Expr, State, Data>
+ : proto::transform_impl<Expr, State, Data>
+ {
+ typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8;
+ typedef typename Gimpl8::result_type result_type;
+ result_type operator()(
+ typename _and_impl::expr_param e
+ , typename _and_impl::state_param s
+ , typename _and_impl::data_param d
+ ) const
+ {
+
+
+
+
+ Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d);
+ return Gimpl8()(e,s,d);
+ }
+ };
+
+
+
+ template<bool B, typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8>
+ struct and_10
+ : and_9<
+ P0::value ,
+ P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8
+ >
+ {};
+ template<typename P0 , typename P1 , typename P2 , typename P3 , typename P4 , typename P5 , typename P6 , typename P7 , typename P8>
+ struct and_10<false, P0 , P1 , P2 , P3 , P4 , P5 , P6 , P7 , P8>
+ : mpl::false_
+ {};
+ template<typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9, typename Expr, typename State, typename Data>
+ struct _and_impl<proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9>, Expr, State, Data>
+ : proto::transform_impl<Expr, State, Data>
+ {
+ typedef typename proto::when<proto::_, G0> ::template impl<Expr, State, Data> Gimpl0; typedef typename proto::when<proto::_, G1> ::template impl<Expr, State, Data> Gimpl1; typedef typename proto::when<proto::_, G2> ::template impl<Expr, State, Data> Gimpl2; typedef typename proto::when<proto::_, G3> ::template impl<Expr, State, Data> Gimpl3; typedef typename proto::when<proto::_, G4> ::template impl<Expr, State, Data> Gimpl4; typedef typename proto::when<proto::_, G5> ::template impl<Expr, State, Data> Gimpl5; typedef typename proto::when<proto::_, G6> ::template impl<Expr, State, Data> Gimpl6; typedef typename proto::when<proto::_, G7> ::template impl<Expr, State, Data> Gimpl7; typedef typename proto::when<proto::_, G8> ::template impl<Expr, State, Data> Gimpl8; typedef typename proto::when<proto::_, G9> ::template impl<Expr, State, Data> Gimpl9;
+ typedef typename Gimpl9::result_type result_type;
+ result_type operator()(
+ typename _and_impl::expr_param e
+ , typename _and_impl::state_param s
+ , typename _and_impl::data_param d
+ ) const
+ {
+
+
+
+
+ Gimpl0()(e,s,d); Gimpl1()(e,s,d); Gimpl2()(e,s,d); Gimpl3()(e,s,d); Gimpl4()(e,s,d); Gimpl5()(e,s,d); Gimpl6()(e,s,d); Gimpl7()(e,s,d); Gimpl8()(e,s,d);
+ return Gimpl9()(e,s,d);
+ }
+ };

Modified: trunk/boost/proto/detail/preprocessed/args.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/args.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/args.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -15,7 +15,7 @@
     {
         static const long arity = 0;
         typedef Arg0 child0;
- typedef mpl::void_ child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4;
+ typedef mpl::void_ child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;


         typedef Arg0 back_;
@@ -29,7 +29,7 @@
     {
         static const long arity = 1;
         typedef Arg0 child0;
- typedef mpl::void_ child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4;
+ typedef mpl::void_ child1; typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;


         typedef Arg0 back_;
@@ -43,7 +43,7 @@
     {
         static const long arity = 2;
         typedef Arg0 child0; typedef Arg1 child1;
- typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4;
+ typedef mpl::void_ child2; typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;


         typedef Arg1 back_;
@@ -57,7 +57,7 @@
     {
         static const long arity = 3;
         typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2;
- typedef mpl::void_ child3; typedef mpl::void_ child4;
+ typedef mpl::void_ child3; typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;


         typedef Arg2 back_;
@@ -71,7 +71,7 @@
     {
         static const long arity = 4;
         typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3;
- typedef mpl::void_ child4;
+ typedef mpl::void_ child4; typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;


         typedef Arg3 back_;
@@ -85,8 +85,78 @@
     {
         static const long arity = 5;
         typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4;
-
+ typedef mpl::void_ child5; typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;


         typedef Arg4 back_;
     };
+
+
+
+
+ template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
+ struct list6
+ {
+ static const long arity = 6;
+ typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5;
+ typedef mpl::void_ child6; typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+
+
+ typedef Arg5 back_;
+ };
+
+
+
+
+ template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 >
+ struct list7
+ {
+ static const long arity = 7;
+ typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6;
+ typedef mpl::void_ child7; typedef mpl::void_ child8; typedef mpl::void_ child9;
+
+
+ typedef Arg6 back_;
+ };
+
+
+
+
+ template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 >
+ struct list8
+ {
+ static const long arity = 8;
+ typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7;
+ typedef mpl::void_ child8; typedef mpl::void_ child9;
+
+
+ typedef Arg7 back_;
+ };
+
+
+
+
+ template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 >
+ struct list9
+ {
+ static const long arity = 9;
+ typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7; typedef Arg8 child8;
+ typedef mpl::void_ child9;
+
+
+ typedef Arg8 back_;
+ };
+
+
+
+
+ template< typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 >
+ struct list10
+ {
+ static const long arity = 10;
+ typedef Arg0 child0; typedef Arg1 child1; typedef Arg2 child2; typedef Arg3 child3; typedef Arg4 child4; typedef Arg5 child5; typedef Arg6 child6; typedef Arg7 child7; typedef Arg8 child8; typedef Arg9 child9;
+
+
+
+ typedef Arg9 back_;
+ };

Modified: trunk/boost/proto/detail/preprocessed/basic_expr.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/basic_expr.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/basic_expr.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -48,7 +48,7 @@
         typedef basic_expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0;
- typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4;
+ typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         basic_expr const &proto_base() const
@@ -122,7 +122,7 @@
         typedef basic_expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0;
- typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4;
+ typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         basic_expr const &proto_base() const
@@ -202,7 +202,7 @@
         typedef basic_expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1;
- typedef void proto_child2; typedef void proto_child3; typedef void proto_child4;
+ typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         basic_expr const &proto_base() const
@@ -270,7 +270,7 @@
         typedef basic_expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2;
- typedef void proto_child3; typedef void proto_child4;
+ typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         basic_expr const &proto_base() const
@@ -338,7 +338,7 @@
         typedef basic_expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3;
- typedef void proto_child4;
+ typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         basic_expr const &proto_base() const
@@ -406,7 +406,7 @@
         typedef basic_expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4;
-
+ typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         basic_expr const &proto_base() const
@@ -432,3 +432,343 @@

         typedef detail::not_a_valid_type address_of_hack_type_;
     };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5>
+ struct basic_expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 6;
+ typedef mpl::long_<6 > proto_arity;
+ typedef basic_expr proto_base_expr;
+ typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args;
+ typedef basic_expr proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef basic_expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5;
+ typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+
+
+ basic_expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ basic_expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
+ {
+ basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6>
+ struct basic_expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 7;
+ typedef mpl::long_<7 > proto_arity;
+ typedef basic_expr proto_base_expr;
+ typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args;
+ typedef basic_expr proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef basic_expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6;
+ typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+
+
+ basic_expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ basic_expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
+ {
+ basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7>
+ struct basic_expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 8;
+ typedef mpl::long_<8 > proto_arity;
+ typedef basic_expr proto_base_expr;
+ typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args;
+ typedef basic_expr proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef basic_expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7;
+ typedef void proto_child8; typedef void proto_child9;
+
+
+ basic_expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ basic_expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
+ {
+ basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8>
+ struct basic_expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 9;
+ typedef mpl::long_<9 > proto_arity;
+ typedef basic_expr proto_base_expr;
+ typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args;
+ typedef basic_expr proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef basic_expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8;
+ typedef void proto_child9;
+
+
+ basic_expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ basic_expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
+ {
+ basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9>
+ struct basic_expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 10;
+ typedef mpl::long_<10 > proto_arity;
+ typedef basic_expr proto_base_expr;
+ typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args;
+ typedef basic_expr proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef basic_expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9;
+
+
+
+ basic_expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ basic_expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ static basic_expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9)
+ {
+ basic_expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+ };

Modified: trunk/boost/proto/detail/preprocessed/deep_copy.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/deep_copy.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/deep_copy.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -120,3 +120,118 @@
             return proto_generator()(that);
         }
     };
+ template<typename Expr>
+ struct deep_copy_impl<Expr, 6>
+ {
+ typedef
+ typename base_expr<
+ typename Expr::proto_domain
+ , typename Expr::proto_tag
+ , list6<
+ typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type
+ >
+ >::type
+ expr_type;
+ typedef typename Expr::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+ template<typename Expr2, typename S, typename D>
+ result_type operator()(Expr2 const &e, S const &, D const &) const
+ {
+ expr_type const that = {
+ proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5)
+ };
+ return proto_generator()(that);
+ }
+ };
+ template<typename Expr>
+ struct deep_copy_impl<Expr, 7>
+ {
+ typedef
+ typename base_expr<
+ typename Expr::proto_domain
+ , typename Expr::proto_tag
+ , list7<
+ typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type
+ >
+ >::type
+ expr_type;
+ typedef typename Expr::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+ template<typename Expr2, typename S, typename D>
+ result_type operator()(Expr2 const &e, S const &, D const &) const
+ {
+ expr_type const that = {
+ proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6)
+ };
+ return proto_generator()(that);
+ }
+ };
+ template<typename Expr>
+ struct deep_copy_impl<Expr, 8>
+ {
+ typedef
+ typename base_expr<
+ typename Expr::proto_domain
+ , typename Expr::proto_tag
+ , list8<
+ typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type
+ >
+ >::type
+ expr_type;
+ typedef typename Expr::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+ template<typename Expr2, typename S, typename D>
+ result_type operator()(Expr2 const &e, S const &, D const &) const
+ {
+ expr_type const that = {
+ proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7)
+ };
+ return proto_generator()(that);
+ }
+ };
+ template<typename Expr>
+ struct deep_copy_impl<Expr, 9>
+ {
+ typedef
+ typename base_expr<
+ typename Expr::proto_domain
+ , typename Expr::proto_tag
+ , list9<
+ typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type , ty
pename deep_copy_impl< typename remove_reference< typename Expr::proto_child8 >::type::proto_derived_expr >::result_type
+ >
+ >::type
+ expr_type;
+ typedef typename Expr::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+ template<typename Expr2, typename S, typename D>
+ result_type operator()(Expr2 const &e, S const &, D const &) const
+ {
+ expr_type const that = {
+ proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7) , proto::deep_copy(e.proto_base().child8)
+ };
+ return proto_generator()(that);
+ }
+ };
+ template<typename Expr>
+ struct deep_copy_impl<Expr, 10>
+ {
+ typedef
+ typename base_expr<
+ typename Expr::proto_domain
+ , typename Expr::proto_tag
+ , list10<
+ typename deep_copy_impl< typename remove_reference< typename Expr::proto_child0 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child1 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child2 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child3 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child4 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child5 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child6 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child7 >::type::proto_derived_expr >::result_type , ty
pename deep_copy_impl< typename remove_reference< typename Expr::proto_child8 >::type::proto_derived_expr >::result_type , typename deep_copy_impl< typename remove_reference< typename Expr::proto_child9 >::type::proto_derived_expr >::result_type
+ >
+ >::type
+ expr_type;
+ typedef typename Expr::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+ template<typename Expr2, typename S, typename D>
+ result_type operator()(Expr2 const &e, S const &, D const &) const
+ {
+ expr_type const that = {
+ proto::deep_copy(e.proto_base().child0) , proto::deep_copy(e.proto_base().child1) , proto::deep_copy(e.proto_base().child2) , proto::deep_copy(e.proto_base().child3) , proto::deep_copy(e.proto_base().child4) , proto::deep_copy(e.proto_base().child5) , proto::deep_copy(e.proto_base().child6) , proto::deep_copy(e.proto_base().child7) , proto::deep_copy(e.proto_base().child8) , proto::deep_copy(e.proto_base().child9)
+ };
+ return proto_generator()(that);
+ }
+ };

Modified: trunk/boost/proto/detail/preprocessed/expr.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/expr.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/expr.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -48,7 +48,7 @@
         typedef expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0;
- typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4;
+ typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         expr const &proto_base() const
@@ -373,6 +373,146 @@
               , default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
         }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ typename result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+ {
+ return result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::call(*this , a0 , a1 , a2 , a3 , a4);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ typename result_of::funop5<
+ expr
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4)
+ {
+ return result_of::funop5<
+ expr
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::call(*this , a0 , a1 , a2 , a3 , a4);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ typename result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+ {
+ return result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ typename result_of::funop6<
+ expr
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
+ {
+ return result_of::funop6<
+ expr
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ typename result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+ {
+ return result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ typename result_of::funop7<
+ expr
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
+ {
+ return result_of::funop7<
+ expr
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ typename result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+ {
+ return result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ typename result_of::funop8<
+ expr
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
+ {
+ return result_of::funop8<
+ expr
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ typename result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+ {
+ return result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ typename result_of::funop9<
+ expr
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
+ {
+ return result_of::funop9<
+ expr
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
     };


@@ -416,7 +556,7 @@
         typedef expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0;
- typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4;
+ typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         expr const &proto_base() const
@@ -615,6 +755,76 @@
               , default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
         }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ typename result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+ {
+ return result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::call(*this , a0 , a1 , a2 , a3 , a4);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ typename result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+ {
+ return result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ typename result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+ {
+ return result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ typename result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+ {
+ return result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ typename result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+ {
+ return result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
     };


@@ -658,7 +868,7 @@
         typedef expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1;
- typedef void proto_child2; typedef void proto_child3; typedef void proto_child4;
+ typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         expr const &proto_base() const
@@ -845,6 +1055,76 @@
               , default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
         }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ typename result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+ {
+ return result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::call(*this , a0 , a1 , a2 , a3 , a4);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ typename result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+ {
+ return result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ typename result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+ {
+ return result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ typename result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+ {
+ return result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ typename result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+ {
+ return result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
     };


@@ -888,7 +1168,7 @@
         typedef expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2;
- typedef void proto_child3; typedef void proto_child4;
+ typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         expr const &proto_base() const
@@ -1075,6 +1355,76 @@
               , default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
         }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ typename result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+ {
+ return result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::call(*this , a0 , a1 , a2 , a3 , a4);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ typename result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+ {
+ return result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ typename result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+ {
+ return result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ typename result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+ {
+ return result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ typename result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+ {
+ return result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
     };


@@ -1118,7 +1468,7 @@
         typedef expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3;
- typedef void proto_child4;
+ typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         expr const &proto_base() const
@@ -1305,6 +1655,76 @@
               , default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
         }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ typename result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+ {
+ return result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::call(*this , a0 , a1 , a2 , a3 , a4);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ typename result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+ {
+ return result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ typename result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+ {
+ return result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ typename result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+ {
+ return result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ typename result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+ {
+ return result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
     };


@@ -1348,7 +1768,7 @@
         typedef expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4;
-
+ typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         expr const &proto_base() const
@@ -1535,4 +1955,1574 @@
               , default_domain , const A0 , const A1 , const A2 , const A3
>::call(*this , a0 , a1 , a2 , a3);
         }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ typename result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+ {
+ return result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::call(*this , a0 , a1 , a2 , a3 , a4);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ typename result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+ {
+ return result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ typename result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+ {
+ return result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ typename result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+ {
+ return result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ typename result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+ {
+ return result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5>
+ struct expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 6;
+ typedef mpl::long_<6 > proto_arity;
+ typedef expr proto_base_expr;
+ typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args;
+ typedef basic_expr<Tag, proto_args, 6 > proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5;
+ typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+
+
+ expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
+ {
+ expr that = {a0 , a1 , a2 , a3 , a4 , a5};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+
+
+
+
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > const
+ operator =(expr const &a)
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > that = {*this, a};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator =(A &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator =(A const &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator [](A &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator [](A const &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename Sig>
+ struct result
+ {
+ typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+ };
+
+
+
+ proto::expr<proto::tag::function, list1<expr const &>, 1> const
+ operator ()() const
+ {
+ proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+ return that;
+ }
+
+
+ template<typename A0>
+ typename result_of::funop1<
+ expr const
+ , default_domain , const A0
+ >::type const
+ operator ()(A0 const &a0) const
+ {
+ return result_of::funop1<
+ expr const
+ , default_domain , const A0
+ >::call(*this , a0);
+ }
+
+
+ template<typename A0 , typename A1>
+ typename result_of::funop2<
+ expr const
+ , default_domain , const A0 , const A1
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1) const
+ {
+ return result_of::funop2<
+ expr const
+ , default_domain , const A0 , const A1
+ >::call(*this , a0 , a1);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2>
+ typename result_of::funop3<
+ expr const
+ , default_domain , const A0 , const A1 , const A2
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+ {
+ return result_of::funop3<
+ expr const
+ , default_domain , const A0 , const A1 , const A2
+ >::call(*this , a0 , a1 , a2);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3>
+ typename result_of::funop4<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+ {
+ return result_of::funop4<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3
+ >::call(*this , a0 , a1 , a2 , a3);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ typename result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+ {
+ return result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::call(*this , a0 , a1 , a2 , a3 , a4);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ typename result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+ {
+ return result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ typename result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+ {
+ return result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ typename result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+ {
+ return result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ typename result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+ {
+ return result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6>
+ struct expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 7;
+ typedef mpl::long_<7 > proto_arity;
+ typedef expr proto_base_expr;
+ typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args;
+ typedef basic_expr<Tag, proto_args, 7 > proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6;
+ typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+
+
+ expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
+ {
+ expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+
+
+
+
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > const
+ operator =(expr const &a)
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > that = {*this, a};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator =(A &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator =(A const &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator [](A &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator [](A const &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename Sig>
+ struct result
+ {
+ typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+ };
+
+
+
+ proto::expr<proto::tag::function, list1<expr const &>, 1> const
+ operator ()() const
+ {
+ proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+ return that;
+ }
+
+
+ template<typename A0>
+ typename result_of::funop1<
+ expr const
+ , default_domain , const A0
+ >::type const
+ operator ()(A0 const &a0) const
+ {
+ return result_of::funop1<
+ expr const
+ , default_domain , const A0
+ >::call(*this , a0);
+ }
+
+
+ template<typename A0 , typename A1>
+ typename result_of::funop2<
+ expr const
+ , default_domain , const A0 , const A1
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1) const
+ {
+ return result_of::funop2<
+ expr const
+ , default_domain , const A0 , const A1
+ >::call(*this , a0 , a1);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2>
+ typename result_of::funop3<
+ expr const
+ , default_domain , const A0 , const A1 , const A2
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+ {
+ return result_of::funop3<
+ expr const
+ , default_domain , const A0 , const A1 , const A2
+ >::call(*this , a0 , a1 , a2);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3>
+ typename result_of::funop4<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+ {
+ return result_of::funop4<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3
+ >::call(*this , a0 , a1 , a2 , a3);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ typename result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+ {
+ return result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::call(*this , a0 , a1 , a2 , a3 , a4);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ typename result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+ {
+ return result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ typename result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+ {
+ return result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ typename result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+ {
+ return result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ typename result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+ {
+ return result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7>
+ struct expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 8;
+ typedef mpl::long_<8 > proto_arity;
+ typedef expr proto_base_expr;
+ typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args;
+ typedef basic_expr<Tag, proto_args, 8 > proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7;
+ typedef void proto_child8; typedef void proto_child9;
+
+
+ expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
+ {
+ expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+
+
+
+
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > const
+ operator =(expr const &a)
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > that = {*this, a};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator =(A &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator =(A const &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator [](A &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator [](A const &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename Sig>
+ struct result
+ {
+ typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+ };
+
+
+
+ proto::expr<proto::tag::function, list1<expr const &>, 1> const
+ operator ()() const
+ {
+ proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+ return that;
+ }
+
+
+ template<typename A0>
+ typename result_of::funop1<
+ expr const
+ , default_domain , const A0
+ >::type const
+ operator ()(A0 const &a0) const
+ {
+ return result_of::funop1<
+ expr const
+ , default_domain , const A0
+ >::call(*this , a0);
+ }
+
+
+ template<typename A0 , typename A1>
+ typename result_of::funop2<
+ expr const
+ , default_domain , const A0 , const A1
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1) const
+ {
+ return result_of::funop2<
+ expr const
+ , default_domain , const A0 , const A1
+ >::call(*this , a0 , a1);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2>
+ typename result_of::funop3<
+ expr const
+ , default_domain , const A0 , const A1 , const A2
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+ {
+ return result_of::funop3<
+ expr const
+ , default_domain , const A0 , const A1 , const A2
+ >::call(*this , a0 , a1 , a2);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3>
+ typename result_of::funop4<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+ {
+ return result_of::funop4<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3
+ >::call(*this , a0 , a1 , a2 , a3);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ typename result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+ {
+ return result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::call(*this , a0 , a1 , a2 , a3 , a4);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ typename result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+ {
+ return result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ typename result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+ {
+ return result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ typename result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+ {
+ return result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ typename result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+ {
+ return result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8>
+ struct expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 9;
+ typedef mpl::long_<9 > proto_arity;
+ typedef expr proto_base_expr;
+ typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args;
+ typedef basic_expr<Tag, proto_args, 9 > proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8;
+ typedef void proto_child9;
+
+
+ expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
+ {
+ expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+
+
+
+
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > const
+ operator =(expr const &a)
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > that = {*this, a};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator =(A &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator =(A const &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator [](A &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator [](A const &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename Sig>
+ struct result
+ {
+ typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+ };
+
+
+
+ proto::expr<proto::tag::function, list1<expr const &>, 1> const
+ operator ()() const
+ {
+ proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+ return that;
+ }
+
+
+ template<typename A0>
+ typename result_of::funop1<
+ expr const
+ , default_domain , const A0
+ >::type const
+ operator ()(A0 const &a0) const
+ {
+ return result_of::funop1<
+ expr const
+ , default_domain , const A0
+ >::call(*this , a0);
+ }
+
+
+ template<typename A0 , typename A1>
+ typename result_of::funop2<
+ expr const
+ , default_domain , const A0 , const A1
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1) const
+ {
+ return result_of::funop2<
+ expr const
+ , default_domain , const A0 , const A1
+ >::call(*this , a0 , a1);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2>
+ typename result_of::funop3<
+ expr const
+ , default_domain , const A0 , const A1 , const A2
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+ {
+ return result_of::funop3<
+ expr const
+ , default_domain , const A0 , const A1 , const A2
+ >::call(*this , a0 , a1 , a2);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3>
+ typename result_of::funop4<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+ {
+ return result_of::funop4<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3
+ >::call(*this , a0 , a1 , a2 , a3);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ typename result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+ {
+ return result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::call(*this , a0 , a1 , a2 , a3 , a4);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ typename result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+ {
+ return result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ typename result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+ {
+ return result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ typename result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+ {
+ return result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ typename result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+ {
+ return result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9>
+ struct expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 10;
+ typedef mpl::long_<10 > proto_arity;
+ typedef expr proto_base_expr;
+ typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args;
+ typedef basic_expr<Tag, proto_args, 10 > proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9;
+
+
+
+ expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9)
+ {
+ expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+
+
+
+
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > const
+ operator =(expr const &a)
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > that = {*this, a};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator =(A &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator =(A const &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator [](A &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator [](A const &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename Sig>
+ struct result
+ {
+ typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+ };
+
+
+
+ proto::expr<proto::tag::function, list1<expr const &>, 1> const
+ operator ()() const
+ {
+ proto::expr<proto::tag::function, list1<expr const &>, 1> that = {*this};
+ return that;
+ }
+
+
+ template<typename A0>
+ typename result_of::funop1<
+ expr const
+ , default_domain , const A0
+ >::type const
+ operator ()(A0 const &a0) const
+ {
+ return result_of::funop1<
+ expr const
+ , default_domain , const A0
+ >::call(*this , a0);
+ }
+
+
+ template<typename A0 , typename A1>
+ typename result_of::funop2<
+ expr const
+ , default_domain , const A0 , const A1
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1) const
+ {
+ return result_of::funop2<
+ expr const
+ , default_domain , const A0 , const A1
+ >::call(*this , a0 , a1);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2>
+ typename result_of::funop3<
+ expr const
+ , default_domain , const A0 , const A1 , const A2
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const
+ {
+ return result_of::funop3<
+ expr const
+ , default_domain , const A0 , const A1 , const A2
+ >::call(*this , a0 , a1 , a2);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3>
+ typename result_of::funop4<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const
+ {
+ return result_of::funop4<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3
+ >::call(*this , a0 , a1 , a2 , a3);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ typename result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const
+ {
+ return result_of::funop5<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4
+ >::call(*this , a0 , a1 , a2 , a3 , a4);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ typename result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const
+ {
+ return result_of::funop6<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ typename result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const
+ {
+ return result_of::funop7<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ typename result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const
+ {
+ return result_of::funop8<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ typename result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::type const
+ operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const
+ {
+ return result_of::funop9<
+ expr const
+ , default_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::call(*this , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
     };

Modified: trunk/boost/proto/detail/preprocessed/expr_variadic.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/expr_variadic.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/expr_variadic.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -48,7 +48,7 @@
         typedef expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0;
- typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4;
+ typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         expr const &proto_base() const
@@ -319,7 +319,7 @@
         typedef expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0;
- typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4;
+ typedef void proto_child1; typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         expr const &proto_base() const
@@ -512,7 +512,7 @@
         typedef expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1;
- typedef void proto_child2; typedef void proto_child3; typedef void proto_child4;
+ typedef void proto_child2; typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         expr const &proto_base() const
@@ -693,7 +693,7 @@
         typedef expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2;
- typedef void proto_child3; typedef void proto_child4;
+ typedef void proto_child3; typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         expr const &proto_base() const
@@ -874,7 +874,7 @@
         typedef expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3;
- typedef void proto_child4;
+ typedef void proto_child4; typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         expr const &proto_base() const
@@ -1055,7 +1055,7 @@
         typedef expr proto_derived_expr;
         typedef void proto_is_expr_;
         typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4;
-
+ typedef void proto_child5; typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;


         expr const &proto_base() const
@@ -1195,3 +1195,908 @@
         }
     };

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5>
+ struct expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 6;
+ typedef mpl::long_<6 > proto_arity;
+ typedef expr proto_base_expr;
+ typedef list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5> proto_args;
+ typedef basic_expr<Tag, proto_args, 6 > proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5;
+ typedef void proto_child6; typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+
+
+ expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5)
+ {
+ expr that = {a0 , a1 , a2 , a3 , a4 , a5};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+
+
+
+
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > const
+ operator =(expr const &a)
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > that = {*this, a};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator =(A &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator =(A const &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator [](A &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator [](A const &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename Sig>
+ struct result
+ {
+ typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+ };
+
+
+ template<typename ...A>
+ typename result_of::funop<
+ expr const(A const &...)
+ , expr
+ , default_domain
+ >::type const
+ operator ()(A const &... a) const
+ {
+ return result_of::funop<
+ expr const(A const &...)
+ , expr
+ , default_domain
+ >::call(*this, a...);
+ }
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6>
+ struct expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 7;
+ typedef mpl::long_<7 > proto_arity;
+ typedef expr proto_base_expr;
+ typedef list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6> proto_args;
+ typedef basic_expr<Tag, proto_args, 7 > proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6;
+ typedef void proto_child7; typedef void proto_child8; typedef void proto_child9;
+
+
+ expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6)
+ {
+ expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+
+
+
+
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > const
+ operator =(expr const &a)
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > that = {*this, a};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator =(A &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator =(A const &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator [](A &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator [](A const &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename Sig>
+ struct result
+ {
+ typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+ };
+
+
+ template<typename ...A>
+ typename result_of::funop<
+ expr const(A const &...)
+ , expr
+ , default_domain
+ >::type const
+ operator ()(A const &... a) const
+ {
+ return result_of::funop<
+ expr const(A const &...)
+ , expr
+ , default_domain
+ >::call(*this, a...);
+ }
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7>
+ struct expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 8;
+ typedef mpl::long_<8 > proto_arity;
+ typedef expr proto_base_expr;
+ typedef list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7> proto_args;
+ typedef basic_expr<Tag, proto_args, 8 > proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7;
+ typedef void proto_child8; typedef void proto_child9;
+
+
+ expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7)
+ {
+ expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+
+
+
+
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > const
+ operator =(expr const &a)
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > that = {*this, a};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator =(A &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator =(A const &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator [](A &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator [](A const &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename Sig>
+ struct result
+ {
+ typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+ };
+
+
+ template<typename ...A>
+ typename result_of::funop<
+ expr const(A const &...)
+ , expr
+ , default_domain
+ >::type const
+ operator ()(A const &... a) const
+ {
+ return result_of::funop<
+ expr const(A const &...)
+ , expr
+ , default_domain
+ >::call(*this, a...);
+ }
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8>
+ struct expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 9;
+ typedef mpl::long_<9 > proto_arity;
+ typedef expr proto_base_expr;
+ typedef list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8> proto_args;
+ typedef basic_expr<Tag, proto_args, 9 > proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8;
+ typedef void proto_child9;
+
+
+ expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8)
+ {
+ expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+
+
+
+
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > const
+ operator =(expr const &a)
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > that = {*this, a};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator =(A &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator =(A const &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator [](A &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator [](A const &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename Sig>
+ struct result
+ {
+ typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+ };
+
+
+ template<typename ...A>
+ typename result_of::funop<
+ expr const(A const &...)
+ , expr
+ , default_domain
+ >::type const
+ operator ()(A const &... a) const
+ {
+ return result_of::funop<
+ expr const(A const &...)
+ , expr
+ , default_domain
+ >::call(*this, a...);
+ }
+ };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9>
+ struct expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10 >
+ {
+ typedef Tag proto_tag;
+ static const long proto_arity_c = 10;
+ typedef mpl::long_<10 > proto_arity;
+ typedef expr proto_base_expr;
+ typedef list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9> proto_args;
+ typedef basic_expr<Tag, proto_args, 10 > proto_grammar;
+ typedef default_domain proto_domain;
+ typedef default_generator proto_generator;
+ typedef proto::tag::proto_expr fusion_tag;
+ typedef expr proto_derived_expr;
+ typedef void proto_is_expr_;
+ typedef Arg0 proto_child0; proto_child0 child0; typedef Arg1 proto_child1; proto_child1 child1; typedef Arg2 proto_child2; proto_child2 child2; typedef Arg3 proto_child3; proto_child3 child3; typedef Arg4 proto_child4; proto_child4 child4; typedef Arg5 proto_child5; proto_child5 child5; typedef Arg6 proto_child6; proto_child6 child6; typedef Arg7 proto_child7; proto_child7 child7; typedef Arg8 proto_child8; proto_child8 child8; typedef Arg9 proto_child9; proto_child9 child9;
+
+
+
+ expr const &proto_base() const
+ {
+ return *this;
+ }
+
+
+ expr &proto_base()
+ {
+ return *this;
+ }
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ static expr const make(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8 , A9 const &a9)
+ {
+ expr that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9};
+ return that;
+ }
+
+
+ typedef detail::not_a_valid_type address_of_hack_type_;
+
+
+
+
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > const
+ operator =(expr const &a)
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr &, expr const &>
+ , 2
+ > that = {*this, a};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator =(A &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator =(A const &a) const
+ {
+ proto::expr<
+ proto::tag::assign
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > const
+ operator [](A &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename A>
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > const
+ operator [](A const &a) const
+ {
+ proto::expr<
+ proto::tag::subscript
+ , list2<expr const &, typename result_of::as_child<A const>::type>
+ , 2
+ > that = {*this, proto::as_child(a)};
+ return that;
+ }
+
+
+ template<typename Sig>
+ struct result
+ {
+ typedef typename result_of::funop<Sig, expr, default_domain>::type const type;
+ };
+
+
+ template<typename ...A>
+ typename result_of::funop<
+ expr const(A const &...)
+ , expr
+ , default_domain
+ >::type const
+ operator ()(A const &... a) const
+ {
+ return result_of::funop<
+ expr const(A const &...)
+ , expr
+ , default_domain
+ >::call(*this, a...);
+ }
+ };
+

Modified: trunk/boost/proto/detail/preprocessed/extends_funop.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/extends_funop.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/extends_funop.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -11,3 +11,8 @@
         template<typename A0 , typename A1> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) const { typedef boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 ) ); } template<typename A0 , typename A1> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) { typedef boost::proto::result_of::funop2< proto_derived_expr , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 ) ); }
         template<typename A0 , typename A1 , typename A2> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { typedef boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 ) ); } template<typename A0 , typename A1 , typename A2> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) { typedef boost::proto::result_of::funop3< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(th
is) , a0 , a1 , a2 ) ); }
         template<typename A0 , typename A1 , typename A2 , typename A3> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { typedef boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) { typedef boost::proto::result_of::funop4< proto_derived_expr , proto_domain , const A0 , const A1
, const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 ) ); }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { typedef boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) { t
ypedef boost::proto::result_of::funop5< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 ) ); }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { typedef boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator
()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) { typedef boost::proto::result_of::funop6< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { typedef boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr , proto_domain , const A0 , const A1 , cons
t A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) { typedef boost::proto::result_of::funop7< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { typedef boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::
funop8< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) { typedef boost::proto::result_of::funop8< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { typedef boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); } template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> typename boo
st::tr1_result_of< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) { typedef boost::proto::result_of::funop9< proto_derived_expr , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); }

Modified: trunk/boost/proto/detail/preprocessed/extends_funop_const.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/extends_funop_const.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/extends_funop_const.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -11,3 +11,8 @@
         template<typename A0 , typename A1> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1) const { typedef boost::proto::result_of::funop2< proto_derived_expr const , proto_domain , const A0 , const A1 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 ) ); }
         template<typename A0 , typename A1 , typename A2> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2) const { typedef boost::proto::result_of::funop3< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 ) ); }
         template<typename A0 , typename A1 , typename A2 , typename A3> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3) const { typedef boost::proto::result_of::funop4< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 ) ); }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4) const { typedef boost::proto::result_of::funop5< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 ) ); }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5) const { typedef boost::proto::result_of::funop6< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 ) ); }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6) const { typedef boost::proto::result_of::funop7< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 ) ); }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7) const { typedef boost::proto::result_of::funop8< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 ) ); }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8> typename boost::tr1_result_of< proto_generator( typename boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 >::type ) >::type const operator ()(A0 const &a0 , A1 const &a1 , A2 const &a2 , A3 const &a3 , A4 const &a4 , A5 const &a5 , A6 const &a6 , A7 const &a7 , A8 const &a8) const { typedef boost::proto::result_of::funop9< proto_derived_expr const , proto_domain , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 > funop; return proto_generator()( funop::call( *static_cast<proto_derived_expr const *>(this) , a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 ) ); }

Modified: trunk/boost/proto/detail/preprocessed/funop.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/funop.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/funop.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -180,3 +180,178 @@
, typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type
>
{};
+
+
+ template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ struct funop5
+ {
+ typedef typename proto::base_expr<
+ Domain
+ , tag::function
+ , list6<
+ Expr &
+ , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type
+ >
+ >::type type;
+ static type const call(
+ Expr &e
+ , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4
+ )
+ {
+ type that = {
+ e
+ , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4)
+ };
+ return that;
+ }
+ };
+
+
+ template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4, typename This, typename Domain>
+ struct funop<Expr(A0 , A1 , A2 , A3 , A4), This, Domain>
+ : funop5<
+ typename detail::same_cv<Expr, This>::type
+ , Domain
+ , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type
+ >
+ {};
+
+
+ template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ struct funop6
+ {
+ typedef typename proto::base_expr<
+ Domain
+ , tag::function
+ , list7<
+ Expr &
+ , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type
+ >
+ >::type type;
+ static type const call(
+ Expr &e
+ , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5
+ )
+ {
+ type that = {
+ e
+ , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5)
+ };
+ return that;
+ }
+ };
+
+
+ template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5, typename This, typename Domain>
+ struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5), This, Domain>
+ : funop6<
+ typename detail::same_cv<Expr, This>::type
+ , Domain
+ , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type
+ >
+ {};
+
+
+ template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ struct funop7
+ {
+ typedef typename proto::base_expr<
+ Domain
+ , tag::function
+ , list8<
+ Expr &
+ , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type
+ >
+ >::type type;
+ static type const call(
+ Expr &e
+ , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6
+ )
+ {
+ type that = {
+ e
+ , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6)
+ };
+ return that;
+ }
+ };
+
+
+ template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6, typename This, typename Domain>
+ struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6), This, Domain>
+ : funop7<
+ typename detail::same_cv<Expr, This>::type
+ , Domain
+ , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type
+ >
+ {};
+
+
+ template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ struct funop8
+ {
+ typedef typename proto::base_expr<
+ Domain
+ , tag::function
+ , list9<
+ Expr &
+ , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type , typename proto::result_of::as_child<A7, Domain>::type
+ >
+ >::type type;
+ static type const call(
+ Expr &e
+ , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7
+ )
+ {
+ type that = {
+ e
+ , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) , proto::as_child<Domain>(a7)
+ };
+ return that;
+ }
+ };
+
+
+ template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7, typename This, typename Domain>
+ struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7), This, Domain>
+ : funop8<
+ typename detail::same_cv<Expr, This>::type
+ , Domain
+ , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type
+ >
+ {};
+
+
+ template<typename Expr, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ struct funop9
+ {
+ typedef typename proto::base_expr<
+ Domain
+ , tag::function
+ , list10<
+ Expr &
+ , typename proto::result_of::as_child<A0, Domain>::type , typename proto::result_of::as_child<A1, Domain>::type , typename proto::result_of::as_child<A2, Domain>::type , typename proto::result_of::as_child<A3, Domain>::type , typename proto::result_of::as_child<A4, Domain>::type , typename proto::result_of::as_child<A5, Domain>::type , typename proto::result_of::as_child<A6, Domain>::type , typename proto::result_of::as_child<A7, Domain>::type , typename proto::result_of::as_child<A8, Domain>::type
+ >
+ >::type type;
+ static type const call(
+ Expr &e
+ , A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8
+ )
+ {
+ type that = {
+ e
+ , proto::as_child<Domain>(a0) , proto::as_child<Domain>(a1) , proto::as_child<Domain>(a2) , proto::as_child<Domain>(a3) , proto::as_child<Domain>(a4) , proto::as_child<Domain>(a5) , proto::as_child<Domain>(a6) , proto::as_child<Domain>(a7) , proto::as_child<Domain>(a8)
+ };
+ return that;
+ }
+ };
+
+
+ template<typename Expr , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8, typename This, typename Domain>
+ struct funop<Expr(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8), This, Domain>
+ : funop9<
+ typename detail::same_cv<Expr, This>::type
+ , Domain
+ , typename remove_reference<A0 >::type , typename remove_reference<A1 >::type , typename remove_reference<A2 >::type , typename remove_reference<A3 >::type , typename remove_reference<A4 >::type , typename remove_reference<A5 >::type , typename remove_reference<A6 >::type , typename remove_reference<A7 >::type , typename remove_reference<A8 >::type
+ >
+ {};

Modified: trunk/boost/proto/detail/preprocessed/generate_by_value.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/generate_by_value.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/generate_by_value.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -235,3 +235,233 @@
             return that;
         }
     };
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
+ struct by_value_generator_<
+ proto::expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6>
+ >
+ {
+ typedef
+ list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>
+ src_args;
+ typedef
+ list6<
+ typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type
+ >
+ dst_args;
+ typedef proto::expr<Tag, src_args, 6> src_type;
+ typedef proto::expr<Tag, dst_args, 6> type;
+ static type const call(src_type const &e)
+ {
+ type that = {
+ e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5
+ };
+ return that;
+ }
+ };
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 >
+ struct by_value_generator_<
+ proto::basic_expr<Tag, list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>, 6>
+ >
+ {
+ typedef
+ list6<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5>
+ src_args;
+ typedef
+ list6<
+ typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type
+ >
+ dst_args;
+ typedef proto::basic_expr<Tag, src_args, 6> src_type;
+ typedef proto::basic_expr<Tag, dst_args, 6> type;
+ static type const call(src_type const &e)
+ {
+ type that = {
+ e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5
+ };
+ return that;
+ }
+ };
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 >
+ struct by_value_generator_<
+ proto::expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7>
+ >
+ {
+ typedef
+ list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>
+ src_args;
+ typedef
+ list7<
+ typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type
+ >
+ dst_args;
+ typedef proto::expr<Tag, src_args, 7> src_type;
+ typedef proto::expr<Tag, dst_args, 7> type;
+ static type const call(src_type const &e)
+ {
+ type that = {
+ e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6
+ };
+ return that;
+ }
+ };
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 >
+ struct by_value_generator_<
+ proto::basic_expr<Tag, list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>, 7>
+ >
+ {
+ typedef
+ list7<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6>
+ src_args;
+ typedef
+ list7<
+ typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type
+ >
+ dst_args;
+ typedef proto::basic_expr<Tag, src_args, 7> src_type;
+ typedef proto::basic_expr<Tag, dst_args, 7> type;
+ static type const call(src_type const &e)
+ {
+ type that = {
+ e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6
+ };
+ return that;
+ }
+ };
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 >
+ struct by_value_generator_<
+ proto::expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8>
+ >
+ {
+ typedef
+ list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>
+ src_args;
+ typedef
+ list8<
+ typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type
+ >
+ dst_args;
+ typedef proto::expr<Tag, src_args, 8> src_type;
+ typedef proto::expr<Tag, dst_args, 8> type;
+ static type const call(src_type const &e)
+ {
+ type that = {
+ e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7
+ };
+ return that;
+ }
+ };
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 >
+ struct by_value_generator_<
+ proto::basic_expr<Tag, list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>, 8>
+ >
+ {
+ typedef
+ list8<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7>
+ src_args;
+ typedef
+ list8<
+ typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type
+ >
+ dst_args;
+ typedef proto::basic_expr<Tag, src_args, 8> src_type;
+ typedef proto::basic_expr<Tag, dst_args, 8> type;
+ static type const call(src_type const &e)
+ {
+ type that = {
+ e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7
+ };
+ return that;
+ }
+ };
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 >
+ struct by_value_generator_<
+ proto::expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9>
+ >
+ {
+ typedef
+ list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>
+ src_args;
+ typedef
+ list9<
+ typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type
+ >
+ dst_args;
+ typedef proto::expr<Tag, src_args, 9> src_type;
+ typedef proto::expr<Tag, dst_args, 9> type;
+ static type const call(src_type const &e)
+ {
+ type that = {
+ e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8
+ };
+ return that;
+ }
+ };
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 >
+ struct by_value_generator_<
+ proto::basic_expr<Tag, list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>, 9>
+ >
+ {
+ typedef
+ list9<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8>
+ src_args;
+ typedef
+ list9<
+ typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type
+ >
+ dst_args;
+ typedef proto::basic_expr<Tag, src_args, 9> src_type;
+ typedef proto::basic_expr<Tag, dst_args, 9> type;
+ static type const call(src_type const &e)
+ {
+ type that = {
+ e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8
+ };
+ return that;
+ }
+ };
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 >
+ struct by_value_generator_<
+ proto::expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10>
+ >
+ {
+ typedef
+ list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>
+ src_args;
+ typedef
+ list10<
+ typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type , typename uncvref<Arg9 >::type
+ >
+ dst_args;
+ typedef proto::expr<Tag, src_args, 10> src_type;
+ typedef proto::expr<Tag, dst_args, 10> type;
+ static type const call(src_type const &e)
+ {
+ type that = {
+ e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 , e.child9
+ };
+ return that;
+ }
+ };
+ template<typename Tag , typename Arg0 , typename Arg1 , typename Arg2 , typename Arg3 , typename Arg4 , typename Arg5 , typename Arg6 , typename Arg7 , typename Arg8 , typename Arg9 >
+ struct by_value_generator_<
+ proto::basic_expr<Tag, list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>, 10>
+ >
+ {
+ typedef
+ list10<Arg0 , Arg1 , Arg2 , Arg3 , Arg4 , Arg5 , Arg6 , Arg7 , Arg8 , Arg9>
+ src_args;
+ typedef
+ list10<
+ typename uncvref<Arg0 >::type , typename uncvref<Arg1 >::type , typename uncvref<Arg2 >::type , typename uncvref<Arg3 >::type , typename uncvref<Arg4 >::type , typename uncvref<Arg5 >::type , typename uncvref<Arg6 >::type , typename uncvref<Arg7 >::type , typename uncvref<Arg8 >::type , typename uncvref<Arg9 >::type
+ >
+ dst_args;
+ typedef proto::basic_expr<Tag, src_args, 10> src_type;
+ typedef proto::basic_expr<Tag, dst_args, 10> type;
+ static type const call(src_type const &e)
+ {
+ type that = {
+ e.child0 , e.child1 , e.child2 , e.child3 , e.child4 , e.child5 , e.child6 , e.child7 , e.child8 , e.child9
+ };
+ return that;
+ }
+ };

Modified: trunk/boost/proto/detail/preprocessed/lambda_matches.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/lambda_matches.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/lambda_matches.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -65,3 +65,78 @@
lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 >
>
{};
+ template<
+ template<typename , typename , typename , typename , typename , typename> class T
+ , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5
+ , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5
+ >
+ struct lambda_matches<
+ T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5>
+ , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5>
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(6)
+ >
+ : and_6<
+ lambda_matches< Expr0 , Grammar0 >::value,
+ lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 >
+ >
+ {};
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename> class T
+ , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6
+ , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6
+ >
+ struct lambda_matches<
+ T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6>
+ , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6>
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(7)
+ >
+ : and_7<
+ lambda_matches< Expr0 , Grammar0 >::value,
+ lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 >
+ >
+ {};
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename , typename> class T
+ , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7
+ , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7
+ >
+ struct lambda_matches<
+ T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7>
+ , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7>
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(8)
+ >
+ : and_8<
+ lambda_matches< Expr0 , Grammar0 >::value,
+ lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 >
+ >
+ {};
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class T
+ , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7 , typename Expr8
+ , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7 , typename Grammar8
+ >
+ struct lambda_matches<
+ T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7 , Expr8>
+ , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7 , Grammar8>
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(9)
+ >
+ : and_9<
+ lambda_matches< Expr0 , Grammar0 >::value,
+ lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 > , lambda_matches< Expr8 , Grammar8 >
+ >
+ {};
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class T
+ , typename Expr0 , typename Expr1 , typename Expr2 , typename Expr3 , typename Expr4 , typename Expr5 , typename Expr6 , typename Expr7 , typename Expr8 , typename Expr9
+ , typename Grammar0 , typename Grammar1 , typename Grammar2 , typename Grammar3 , typename Grammar4 , typename Grammar5 , typename Grammar6 , typename Grammar7 , typename Grammar8 , typename Grammar9
+ >
+ struct lambda_matches<
+ T<Expr0 , Expr1 , Expr2 , Expr3 , Expr4 , Expr5 , Expr6 , Expr7 , Expr8 , Expr9>
+ , T<Grammar0 , Grammar1 , Grammar2 , Grammar3 , Grammar4 , Grammar5 , Grammar6 , Grammar7 , Grammar8 , Grammar9>
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(10)
+ >
+ : and_10<
+ lambda_matches< Expr0 , Grammar0 >::value,
+ lambda_matches< Expr1 , Grammar1 > , lambda_matches< Expr2 , Grammar2 > , lambda_matches< Expr3 , Grammar3 > , lambda_matches< Expr4 , Grammar4 > , lambda_matches< Expr5 , Grammar5 > , lambda_matches< Expr6 , Grammar6 > , lambda_matches< Expr7 , Grammar7 > , lambda_matches< Expr8 , Grammar8 > , lambda_matches< Expr9 , Grammar9 >
+ >
+ {};

Modified: trunk/boost/proto/detail/preprocessed/make_expr.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/make_expr.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/make_expr.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -141,3 +141,173 @@
, const C0 , const C1 , const C2 , const C3 , const C4
>()(c0 , c1 , c2 , c3 , c4);
}
+
+
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ typename lazy_disable_if<
+ is_domain<A0>
+ , result_of::make_expr<
+ Tag
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >
+ >::type const
+ make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5)
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , deduce_domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >()(a0 , a1 , a2 , a3 , a4 , a5);
+ }
+
+
+ template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5>
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , const C0 , const C1 , const C2 , const C3 , const C4 , const C5
+ >::type const
+ make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5)
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , Domain
+ , const C0 , const C1 , const C2 , const C3 , const C4 , const C5
+ >()(c0 , c1 , c2 , c3 , c4 , c5);
+ }
+
+
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ typename lazy_disable_if<
+ is_domain<A0>
+ , result_of::make_expr<
+ Tag
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >
+ >::type const
+ make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6)
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , deduce_domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >()(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+
+
+ template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6>
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6
+ >::type const
+ make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6)
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , Domain
+ , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6
+ >()(c0 , c1 , c2 , c3 , c4 , c5 , c6);
+ }
+
+
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ typename lazy_disable_if<
+ is_domain<A0>
+ , result_of::make_expr<
+ Tag
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >
+ >::type const
+ make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7)
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , deduce_domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+
+
+ template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7>
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7
+ >::type const
+ make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7)
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , Domain
+ , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7
+ >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7);
+ }
+
+
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ typename lazy_disable_if<
+ is_domain<A0>
+ , result_of::make_expr<
+ Tag
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >
+ >::type const
+ make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8)
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , deduce_domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
+
+
+ template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8>
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8
+ >::type const
+ make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7 , const C8 &c8)
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , Domain
+ , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8
+ >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8);
+ }
+
+
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ typename lazy_disable_if<
+ is_domain<A0>
+ , result_of::make_expr<
+ Tag
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
+ >
+ >::type const
+ make_expr(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8 , const A9 &a9)
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , deduce_domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
+ >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+ }
+
+
+ template<typename Tag, typename Domain , typename C0 , typename C1 , typename C2 , typename C3 , typename C4 , typename C5 , typename C6 , typename C7 , typename C8 , typename C9>
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 , const C9
+ >::type const
+ make_expr(const C0 &c0 , const C1 &c1 , const C2 &c2 , const C3 &c3 , const C4 &c4 , const C5 &c5 , const C6 &c6 , const C7 &c7 , const C8 &c8 , const C9 &c9)
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , Domain
+ , const C0 , const C1 , const C2 , const C3 , const C4 , const C5 , const C6 , const C7 , const C8 , const C9
+ >()(c0 , c1 , c2 , c3 , c4 , c5 , c6 , c7 , c8 , c9);
+ }

Modified: trunk/boost/proto/detail/preprocessed/make_expr_.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/make_expr_.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/make_expr_.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -8,14 +8,14 @@
     template<
         typename Tag
       , typename Domain
- , typename A0 = void , typename A1 = void , typename A2 = void , typename A3 = void , typename A4 = void
+ , typename A0 = void , typename A1 = void , typename A2 = void , typename A3 = void , typename A4 = void , typename A5 = void , typename A6 = void , typename A7 = void , typename A8 = void , typename A9 = void
       , typename _ = void
>
     struct make_expr_
     {};
     template<typename Domain, typename A>
     struct make_expr_<tag::terminal, Domain, A
- , void , void , void , void , void>
+ , void , void , void , void , void , void , void , void , void , void>
     {
         typedef typename proto::detail::protoify<A, Domain>::result_type result_type;
         result_type operator()(typename add_reference<A>::type a) const
@@ -25,12 +25,12 @@
     };
     template<typename A>
     struct make_expr_<tag::terminal, deduce_domain, A
- , void , void , void , void , void>
+ , void , void , void , void , void , void , void , void , void , void>
       : make_expr_<tag::terminal, default_domain, A>
     {};
     template<typename Tag, typename Domain , typename A0>
     struct make_expr_<Tag, Domain , A0
- , void , void , void , void, void>
+ , void , void , void , void , void , void , void , void , void, void>
     {
         typedef
             list1<
@@ -50,7 +50,7 @@
     };
     template<typename Tag , typename A0>
     struct make_expr_<Tag, deduce_domain , A0
- , void , void , void , void, void>
+ , void , void , void , void , void , void , void , void , void, void>
       : make_expr_<
             Tag
           , typename deduce_domain1<A0>::type
@@ -59,7 +59,7 @@
     {};
     template<typename Tag, typename Domain , typename A0 , typename A1>
     struct make_expr_<Tag, Domain , A0 , A1
- , void , void , void, void>
+ , void , void , void , void , void , void , void , void, void>
     {
         typedef
             list2<
@@ -79,7 +79,7 @@
     };
     template<typename Tag , typename A0 , typename A1>
     struct make_expr_<Tag, deduce_domain , A0 , A1
- , void , void , void, void>
+ , void , void , void , void , void , void , void , void, void>
       : make_expr_<
             Tag
           , typename deduce_domain2<A0 , A1>::type
@@ -88,7 +88,7 @@
     {};
     template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2>
     struct make_expr_<Tag, Domain , A0 , A1 , A2
- , void , void, void>
+ , void , void , void , void , void , void , void, void>
     {
         typedef
             list3<
@@ -108,7 +108,7 @@
     };
     template<typename Tag , typename A0 , typename A1 , typename A2>
     struct make_expr_<Tag, deduce_domain , A0 , A1 , A2
- , void , void, void>
+ , void , void , void , void , void , void , void, void>
       : make_expr_<
             Tag
           , typename deduce_domain3<A0 , A1 , A2>::type
@@ -117,7 +117,7 @@
     {};
     template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3>
     struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3
- , void, void>
+ , void , void , void , void , void , void, void>
     {
         typedef
             list4<
@@ -137,7 +137,7 @@
     };
     template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3>
     struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3
- , void, void>
+ , void , void , void , void , void , void, void>
       : make_expr_<
             Tag
           , typename deduce_domain4<A0 , A1 , A2 , A3>::type
@@ -146,7 +146,7 @@
     {};
     template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
     struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4
- , void>
+ , void , void , void , void , void, void>
     {
         typedef
             list5<
@@ -166,10 +166,155 @@
     };
     template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
     struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4
- , void>
+ , void , void , void , void , void, void>
       : make_expr_<
             Tag
           , typename deduce_domain5<A0 , A1 , A2 , A3 , A4>::type
             , A0 , A1 , A2 , A3 , A4
>
     {};
+ template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5
+ , void , void , void , void, void>
+ {
+ typedef
+ list6<
+ typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type
+ >
+ proto_args;
+ typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+ typedef typename Domain::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+ result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5) const
+ {
+ expr_type const that = {
+ boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5)
+ };
+ return proto_generator()(that);
+ }
+ };
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5
+ , void , void , void , void, void>
+ : make_expr_<
+ Tag
+ , typename deduce_domain6<A0 , A1 , A2 , A3 , A4 , A5>::type
+ , A0 , A1 , A2 , A3 , A4 , A5
+ >
+ {};
+ template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6
+ , void , void , void, void>
+ {
+ typedef
+ list7<
+ typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type
+ >
+ proto_args;
+ typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+ typedef typename Domain::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+ result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6) const
+ {
+ expr_type const that = {
+ boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6)
+ };
+ return proto_generator()(that);
+ }
+ };
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6
+ , void , void , void, void>
+ : make_expr_<
+ Tag
+ , typename deduce_domain7<A0 , A1 , A2 , A3 , A4 , A5 , A6>::type
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6
+ >
+ {};
+ template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+ , void , void, void>
+ {
+ typedef
+ list8<
+ typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type
+ >
+ proto_args;
+ typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+ typedef typename Domain::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+ result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7) const
+ {
+ expr_type const that = {
+ boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7)
+ };
+ return proto_generator()(that);
+ }
+ };
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+ , void , void, void>
+ : make_expr_<
+ Tag
+ , typename deduce_domain8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>::type
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+ >
+ {};
+ template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+ , void, void>
+ {
+ typedef
+ list9<
+ typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type , typename boost::proto::detail::protoify< A8 , Domain >::result_type
+ >
+ proto_args;
+ typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+ typedef typename Domain::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+ result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7 , typename add_reference<A8 >::type a8) const
+ {
+ expr_type const that = {
+ boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) , boost::proto::detail::protoify< A8 , Domain >()(a8)
+ };
+ return proto_generator()(that);
+ }
+ };
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+ , void, void>
+ : make_expr_<
+ Tag
+ , typename deduce_domain9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>::type
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+ >
+ {};
+ template<typename Tag, typename Domain , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ struct make_expr_<Tag, Domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+ , void>
+ {
+ typedef
+ list10<
+ typename boost::proto::detail::protoify< A0 , Domain >::result_type , typename boost::proto::detail::protoify< A1 , Domain >::result_type , typename boost::proto::detail::protoify< A2 , Domain >::result_type , typename boost::proto::detail::protoify< A3 , Domain >::result_type , typename boost::proto::detail::protoify< A4 , Domain >::result_type , typename boost::proto::detail::protoify< A5 , Domain >::result_type , typename boost::proto::detail::protoify< A6 , Domain >::result_type , typename boost::proto::detail::protoify< A7 , Domain >::result_type , typename boost::proto::detail::protoify< A8 , Domain >::result_type , typename boost::proto::detail::protoify< A9 , Domain >::result_type
+ >
+ proto_args;
+ typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+ typedef typename Domain::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type result_type;
+ result_type operator()(typename add_reference<A0 >::type a0 , typename add_reference<A1 >::type a1 , typename add_reference<A2 >::type a2 , typename add_reference<A3 >::type a3 , typename add_reference<A4 >::type a4 , typename add_reference<A5 >::type a5 , typename add_reference<A6 >::type a6 , typename add_reference<A7 >::type a7 , typename add_reference<A8 >::type a8 , typename add_reference<A9 >::type a9) const
+ {
+ expr_type const that = {
+ boost::proto::detail::protoify< A0 , Domain >()(a0) , boost::proto::detail::protoify< A1 , Domain >()(a1) , boost::proto::detail::protoify< A2 , Domain >()(a2) , boost::proto::detail::protoify< A3 , Domain >()(a3) , boost::proto::detail::protoify< A4 , Domain >()(a4) , boost::proto::detail::protoify< A5 , Domain >()(a5) , boost::proto::detail::protoify< A6 , Domain >()(a6) , boost::proto::detail::protoify< A7 , Domain >()(a7) , boost::proto::detail::protoify< A8 , Domain >()(a8) , boost::proto::detail::protoify< A9 , Domain >()(a9)
+ };
+ return proto_generator()(that);
+ }
+ };
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ struct make_expr_<Tag, deduce_domain , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+ , void>
+ : make_expr_<
+ Tag
+ , typename deduce_domain10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>::type
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+ >
+ {};

Modified: trunk/boost/proto/detail/preprocessed/make_expr_funop.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/make_expr_funop.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/make_expr_funop.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -113,3 +113,138 @@
, const A0 , const A1 , const A2 , const A3 , const A4
>()(a0 , a1 , a2 , a3 , a4);
}
+ template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ struct result<This(A0 , A1 , A2 , A3 , A4 , A5)>
+ {
+ typedef
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , A0 , A1 , A2 , A3 , A4 , A5
+ >::type
+ type;
+ };
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >::type const
+ operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5) const
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , Domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5
+ >()(a0 , a1 , a2 , a3 , a4 , a5);
+ }
+ template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+ {
+ typedef
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6
+ >::type
+ type;
+ };
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >::type const
+ operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6) const
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , Domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6
+ >()(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+ template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+ {
+ typedef
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+ >::type
+ type;
+ };
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >::type const
+ operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7) const
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , Domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7
+ >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+ template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+ {
+ typedef
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+ >::type
+ type;
+ };
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >::type const
+ operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8) const
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , Domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8
+ >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
+ template<typename This , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ struct result<This(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+ {
+ typedef
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+ >::type
+ type;
+ };
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ typename result_of::make_expr<
+ Tag
+ , Domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
+ >::type const
+ operator ()(const A0 &a0 , const A1 &a1 , const A2 &a2 , const A3 &a3 , const A4 &a4 , const A5 &a5 , const A6 &a6 , const A7 &a7 , const A8 &a8 , const A9 &a9) const
+ {
+ return proto::detail::make_expr_<
+ Tag
+ , Domain
+ , const A0 , const A1 , const A2 , const A3 , const A4 , const A5 , const A6 , const A7 , const A8 , const A9
+ >()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+ }

Modified: trunk/boost/proto/detail/preprocessed/matches_.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/matches_.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/matches_.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -141,6 +141,20 @@
                 matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar >
>
         {};
+ template<typename Expr, typename Tag, typename Args1, typename Args2>
+ struct matches_< Expr, proto::basic_expr<Tag, Args1, 6>, proto::basic_expr<Tag, Args2, 6> >
+ : and_6<
+ matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+ matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_tra
its<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar >
+ >
+ {};
+ template<typename Expr, typename Tag, typename Args1, typename Args2>
+ struct matches_< Expr, proto::basic_expr<Tag, Args1, 6>, proto::basic_expr<proto::_, Args2, 6> >
+ : and_6<
+ matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+ matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_tra
its<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar >
+ >
+ {};

         template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6>
         struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6> >
@@ -157,6 +171,20 @@
                 matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar >
>
         {};
+ template<typename Expr, typename Tag, typename Args1, typename Args2>
+ struct matches_< Expr, proto::basic_expr<Tag, Args1, 7>, proto::basic_expr<Tag, Args2, 7> >
+ : and_7<
+ matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+ matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_tra
its<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar >
+ >
+ {};
+ template<typename Expr, typename Tag, typename Args1, typename Args2>
+ struct matches_< Expr, proto::basic_expr<Tag, Args1, 7>, proto::basic_expr<proto::_, Args2, 7> >
+ : and_7<
+ matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+ matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_tra
its<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar >
+ >
+ {};

         template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7>
         struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7> >
@@ -173,3 +201,77 @@
                 matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar >
>
         {};
+ template<typename Expr, typename Tag, typename Args1, typename Args2>
+ struct matches_< Expr, proto::basic_expr<Tag, Args1, 8>, proto::basic_expr<Tag, Args2, 8> >
+ : and_8<
+ matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+ matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_tra
its<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar >
+ >
+ {};
+ template<typename Expr, typename Tag, typename Args1, typename Args2>
+ struct matches_< Expr, proto::basic_expr<Tag, Args1, 8>, proto::basic_expr<proto::_, Args2, 8> >
+ : and_8<
+ matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+ matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_tra
its<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar >
+ >
+ {};
+
+ template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
+ struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8> >
+ : or_9<
+ matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+ Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8
+ >
+ {};
+
+ template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
+ struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8> >
+ : detail::and_9<
+ matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+ matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar > , matches_< Expr , BasicExpr , typename G8::proto_grammar >
+ >
+ {};
+ template<typename Expr, typename Tag, typename Args1, typename Args2>
+ struct matches_< Expr, proto::basic_expr<Tag, Args1, 9>, proto::basic_expr<Tag, Args2, 9> >
+ : and_9<
+ matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+ matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_tra
its<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar >
+ >
+ {};
+ template<typename Expr, typename Tag, typename Args1, typename Args2>
+ struct matches_< Expr, proto::basic_expr<Tag, Args1, 9>, proto::basic_expr<proto::_, Args2, 9> >
+ : and_9<
+ matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+ matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_tra
its<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar >
+ >
+ {};
+
+ template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+ struct matches_<Expr, BasicExpr, proto::or_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> >
+ : or_10<
+ matches_<Expr, BasicExpr, typename G0::proto_grammar>::value,
+ Expr, BasicExpr , G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9
+ >
+ {};
+
+ template<typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+ struct matches_<Expr, BasicExpr, proto::and_<G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9> >
+ : detail::and_10<
+ matches_< Expr , BasicExpr , typename G0::proto_grammar >::value,
+ matches_< Expr , BasicExpr , typename G1::proto_grammar > , matches_< Expr , BasicExpr , typename G2::proto_grammar > , matches_< Expr , BasicExpr , typename G3::proto_grammar > , matches_< Expr , BasicExpr , typename G4::proto_grammar > , matches_< Expr , BasicExpr , typename G5::proto_grammar > , matches_< Expr , BasicExpr , typename G6::proto_grammar > , matches_< Expr , BasicExpr , typename G7::proto_grammar > , matches_< Expr , BasicExpr , typename G8::proto_grammar > , matches_< Expr , BasicExpr , typename G9::proto_grammar >
+ >
+ {};
+ template<typename Expr, typename Tag, typename Args1, typename Args2>
+ struct matches_< Expr, proto::basic_expr<Tag, Args1, 10>, proto::basic_expr<Tag, Args2, 10> >
+ : and_10<
+ matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+ matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_tra
its<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child9>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child9>::value_type::proto_grammar , typename Args2::child9::proto_grammar >
+ >
+ {};
+ template<typename Expr, typename Tag, typename Args1, typename Args2>
+ struct matches_< Expr, proto::basic_expr<Tag, Args1, 10>, proto::basic_expr<proto::_, Args2, 10> >
+ : and_10<
+ matches_< typename detail::expr_traits<typename Args1::child0>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child0>::value_type::proto_grammar , typename Args2::child0::proto_grammar >::value,
+ matches_< typename detail::expr_traits<typename Args1::child1>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child1>::value_type::proto_grammar , typename Args2::child1::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child2>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child2>::value_type::proto_grammar , typename Args2::child2::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child3>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child3>::value_type::proto_grammar , typename Args2::child3::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child4>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child4>::value_type::proto_grammar , typename Args2::child4::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child5>::value_type::proto_derived_expr , typename detail::expr_tra
its<typename Args1::child5>::value_type::proto_grammar , typename Args2::child5::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child6>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child6>::value_type::proto_grammar , typename Args2::child6::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child7>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child7>::value_type::proto_grammar , typename Args2::child7::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child8>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child8>::value_type::proto_grammar , typename Args2::child8::proto_grammar > , matches_< typename detail::expr_traits<typename Args1::child9>::value_type::proto_derived_expr , typename detail::expr_traits<typename Args1::child9>::value_type::proto_grammar , typename Args2::child9::proto_grammar >
+ >
+ {};

Modified: trunk/boost/proto/detail/preprocessed/or_n.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/or_n.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/or_n.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -95,3 +95,29 @@
     {
         typedef G0 which;
     };
+ template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
+ struct or_9
+ : or_8<
+ matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+ , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8
+ >
+ {};
+ template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8>
+ struct or_9<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8>
+ : mpl::true_
+ {
+ typedef G0 which;
+ };
+ template<bool B, typename Expr, typename BasicExpr, typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+ struct or_10
+ : or_9<
+ matches_<Expr, BasicExpr, typename G1::proto_grammar>::value
+ , Expr, BasicExpr, G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9
+ >
+ {};
+ template<typename Expr, typename BasicExpr , typename G0 , typename G1 , typename G2 , typename G3 , typename G4 , typename G5 , typename G6 , typename G7 , typename G8 , typename G9>
+ struct or_10<true, Expr, BasicExpr, G0 , G1 , G2 , G3 , G4 , G5 , G6 , G7 , G8 , G9>
+ : mpl::true_
+ {
+ typedef G0 which;
+ };

Modified: trunk/boost/proto/detail/preprocessed/traits.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/traits.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/traits.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -79,12 +79,12 @@
         struct function
         <
             A0
- , void , void , void , void
+ , void , void , void , void , void , void , void , void , void
>
           : proto::transform<
                 function<
                     A0
- , void , void , void , void
+ , void , void , void , void , void , void , void , void , void
>
               , int
>
@@ -98,7 +98,7 @@

             typedef proto::tag::function proto_tag;
             typedef A0 proto_child0;
- typedef detail::if_vararg<A0> proto_child1; typedef detail::if_vararg<A0> proto_child2; typedef detail::if_vararg<A0> proto_child3; typedef detail::if_vararg<A0> proto_child4;
+ typedef detail::if_vararg<A0> proto_child1; typedef detail::if_vararg<A0> proto_child2; typedef detail::if_vararg<A0> proto_child3; typedef detail::if_vararg<A0> proto_child4; typedef detail::if_vararg<A0> proto_child5; typedef detail::if_vararg<A0> proto_child6; typedef detail::if_vararg<A0> proto_child7; typedef detail::if_vararg<A0> proto_child8; typedef detail::if_vararg<A0> proto_child9;
         };


@@ -113,13 +113,13 @@
         <
             Tag
             , A0
- , void , void , void , void
+ , void , void , void , void , void , void , void , void , void
>
           : proto::transform<
                 nary_expr<
                     Tag
                     , A0
- , void , void , void , void
+ , void , void , void , void , void , void , void , void , void
>
               , int
>
@@ -133,7 +133,7 @@

             typedef Tag proto_tag;
             typedef A0 proto_child0;
- typedef detail::if_vararg<A0> proto_child1; typedef detail::if_vararg<A0> proto_child2; typedef detail::if_vararg<A0> proto_child3; typedef detail::if_vararg<A0> proto_child4;
+ typedef detail::if_vararg<A0> proto_child1; typedef detail::if_vararg<A0> proto_child2; typedef detail::if_vararg<A0> proto_child3; typedef detail::if_vararg<A0> proto_child4; typedef detail::if_vararg<A0> proto_child5; typedef detail::if_vararg<A0> proto_child6; typedef detail::if_vararg<A0> proto_child7; typedef detail::if_vararg<A0> proto_child8; typedef detail::if_vararg<A0> proto_child9;
         };
         namespace detail
         {
@@ -219,12 +219,12 @@
         struct function
         <
             A0 , A1
- , void , void , void
+ , void , void , void , void , void , void , void , void
>
           : proto::transform<
                 function<
                     A0 , A1
- , void , void , void
+ , void , void , void , void , void , void , void , void
>
               , int
>
@@ -238,7 +238,7 @@

             typedef proto::tag::function proto_tag;
             typedef A0 proto_child0; typedef A1 proto_child1;
- typedef detail::if_vararg<A1> proto_child2; typedef detail::if_vararg<A1> proto_child3; typedef detail::if_vararg<A1> proto_child4;
+ typedef detail::if_vararg<A1> proto_child2; typedef detail::if_vararg<A1> proto_child3; typedef detail::if_vararg<A1> proto_child4; typedef detail::if_vararg<A1> proto_child5; typedef detail::if_vararg<A1> proto_child6; typedef detail::if_vararg<A1> proto_child7; typedef detail::if_vararg<A1> proto_child8; typedef detail::if_vararg<A1> proto_child9;
         };


@@ -253,13 +253,13 @@
         <
             Tag
             , A0 , A1
- , void , void , void
+ , void , void , void , void , void , void , void , void
>
           : proto::transform<
                 nary_expr<
                     Tag
                     , A0 , A1
- , void , void , void
+ , void , void , void , void , void , void , void , void
>
               , int
>
@@ -273,7 +273,7 @@

             typedef Tag proto_tag;
             typedef A0 proto_child0; typedef A1 proto_child1;
- typedef detail::if_vararg<A1> proto_child2; typedef detail::if_vararg<A1> proto_child3; typedef detail::if_vararg<A1> proto_child4;
+ typedef detail::if_vararg<A1> proto_child2; typedef detail::if_vararg<A1> proto_child3; typedef detail::if_vararg<A1> proto_child4; typedef detail::if_vararg<A1> proto_child5; typedef detail::if_vararg<A1> proto_child6; typedef detail::if_vararg<A1> proto_child7; typedef detail::if_vararg<A1> proto_child8; typedef detail::if_vararg<A1> proto_child9;
         };
         namespace detail
         {
@@ -359,12 +359,12 @@
         struct function
         <
             A0 , A1 , A2
- , void , void
+ , void , void , void , void , void , void , void
>
           : proto::transform<
                 function<
                     A0 , A1 , A2
- , void , void
+ , void , void , void , void , void , void , void
>
               , int
>
@@ -378,7 +378,7 @@

             typedef proto::tag::function proto_tag;
             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2;
- typedef detail::if_vararg<A2> proto_child3; typedef detail::if_vararg<A2> proto_child4;
+ typedef detail::if_vararg<A2> proto_child3; typedef detail::if_vararg<A2> proto_child4; typedef detail::if_vararg<A2> proto_child5; typedef detail::if_vararg<A2> proto_child6; typedef detail::if_vararg<A2> proto_child7; typedef detail::if_vararg<A2> proto_child8; typedef detail::if_vararg<A2> proto_child9;
         };


@@ -393,13 +393,13 @@
         <
             Tag
             , A0 , A1 , A2
- , void , void
+ , void , void , void , void , void , void , void
>
           : proto::transform<
                 nary_expr<
                     Tag
                     , A0 , A1 , A2
- , void , void
+ , void , void , void , void , void , void , void
>
               , int
>
@@ -413,7 +413,7 @@

             typedef Tag proto_tag;
             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2;
- typedef detail::if_vararg<A2> proto_child3; typedef detail::if_vararg<A2> proto_child4;
+ typedef detail::if_vararg<A2> proto_child3; typedef detail::if_vararg<A2> proto_child4; typedef detail::if_vararg<A2> proto_child5; typedef detail::if_vararg<A2> proto_child6; typedef detail::if_vararg<A2> proto_child7; typedef detail::if_vararg<A2> proto_child8; typedef detail::if_vararg<A2> proto_child9;
         };
         namespace detail
         {
@@ -499,12 +499,12 @@
         struct function
         <
             A0 , A1 , A2 , A3
- , void
+ , void , void , void , void , void , void
>
           : proto::transform<
                 function<
                     A0 , A1 , A2 , A3
- , void
+ , void , void , void , void , void , void
>
               , int
>
@@ -518,7 +518,7 @@

             typedef proto::tag::function proto_tag;
             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3;
- typedef detail::if_vararg<A3> proto_child4;
+ typedef detail::if_vararg<A3> proto_child4; typedef detail::if_vararg<A3> proto_child5; typedef detail::if_vararg<A3> proto_child6; typedef detail::if_vararg<A3> proto_child7; typedef detail::if_vararg<A3> proto_child8; typedef detail::if_vararg<A3> proto_child9;
         };


@@ -533,13 +533,13 @@
         <
             Tag
             , A0 , A1 , A2 , A3
- , void
+ , void , void , void , void , void , void
>
           : proto::transform<
                 nary_expr<
                     Tag
                     , A0 , A1 , A2 , A3
- , void
+ , void , void , void , void , void , void
>
               , int
>
@@ -553,7 +553,7 @@

             typedef Tag proto_tag;
             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3;
- typedef detail::if_vararg<A3> proto_child4;
+ typedef detail::if_vararg<A3> proto_child4; typedef detail::if_vararg<A3> proto_child5; typedef detail::if_vararg<A3> proto_child6; typedef detail::if_vararg<A3> proto_child7; typedef detail::if_vararg<A3> proto_child8; typedef detail::if_vararg<A3> proto_child9;
         };
         namespace detail
         {
@@ -637,10 +637,14 @@

         template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
         struct function
+ <
+ A0 , A1 , A2 , A3 , A4
+ , void , void , void , void , void
+ >
           : proto::transform<
                 function<
                     A0 , A1 , A2 , A3 , A4
-
+ , void , void , void , void , void
>
               , int
>
@@ -654,7 +658,7 @@

             typedef proto::tag::function proto_tag;
             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4;
-
+ typedef detail::if_vararg<A4> proto_child5; typedef detail::if_vararg<A4> proto_child6; typedef detail::if_vararg<A4> proto_child7; typedef detail::if_vararg<A4> proto_child8; typedef detail::if_vararg<A4> proto_child9;
         };


@@ -666,11 +670,16 @@

         template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
         struct nary_expr
+ <
+ Tag
+ , A0 , A1 , A2 , A3 , A4
+ , void , void , void , void , void
+ >
           : proto::transform<
                 nary_expr<
                     Tag
                     , A0 , A1 , A2 , A3 , A4
-
+ , void , void , void , void , void
>
               , int
>
@@ -684,7 +693,7 @@

             typedef Tag proto_tag;
             typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4;
-
+ typedef detail::if_vararg<A4> proto_child5; typedef detail::if_vararg<A4> proto_child6; typedef detail::if_vararg<A4> proto_child7; typedef detail::if_vararg<A4> proto_child8; typedef detail::if_vararg<A4> proto_child9;
         };
         namespace detail
         {
@@ -762,3 +771,694 @@
                 }
             };
         }
+
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ struct function
+ <
+ A0 , A1 , A2 , A3 , A4 , A5
+ , void , void , void , void
+ >
+ : proto::transform<
+ function<
+ A0 , A1 , A2 , A3 , A4 , A5
+ , void , void , void , void
+ >
+ , int
+ >
+ {
+ typedef proto::expr<proto::tag::function, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> type;
+ typedef proto::basic_expr<proto::tag::function, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> proto_grammar;
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : detail::pass_through_impl<function, Expr, State, Data>
+ {};
+
+ typedef proto::tag::function proto_tag;
+ typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5;
+ typedef detail::if_vararg<A5> proto_child6; typedef detail::if_vararg<A5> proto_child7; typedef detail::if_vararg<A5> proto_child8; typedef detail::if_vararg<A5> proto_child9;
+ };
+
+
+
+
+
+
+
+
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ struct nary_expr
+ <
+ Tag
+ , A0 , A1 , A2 , A3 , A4 , A5
+ , void , void , void , void
+ >
+ : proto::transform<
+ nary_expr<
+ Tag
+ , A0 , A1 , A2 , A3 , A4 , A5
+ , void , void , void , void
+ >
+ , int
+ >
+ {
+ typedef proto::expr<Tag, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> type;
+ typedef proto::basic_expr<Tag, list6<A0 , A1 , A2 , A3 , A4 , A5>, 6> proto_grammar;
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : detail::pass_through_impl<nary_expr, Expr, State, Data>
+ {};
+
+ typedef Tag proto_tag;
+ typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5;
+ typedef detail::if_vararg<A5> proto_child6; typedef detail::if_vararg<A5> proto_child7; typedef detail::if_vararg<A5> proto_child8; typedef detail::if_vararg<A5> proto_child9;
+ };
+ namespace detail
+ {
+ template<
+ template<typename , typename , typename , typename , typename , typename> class T
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
+ >
+ struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5> BOOST_PROTO_TEMPLATE_ARITY_PARAM(6)>
+ : is_same<A5, callable>
+ {};
+ }
+ namespace result_of
+ {
+
+
+
+
+
+
+ template<typename Expr>
+ struct child_c<Expr, 6>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child6 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child6>::value_type type;
+ };
+ template<typename Expr>
+ struct child_c<Expr &, 6>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child6 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child6>::reference type;
+
+
+ static type call(Expr &e)
+ {
+ return e.proto_base().child6;
+ }
+ };
+ template<typename Expr>
+ struct child_c<Expr const &, 6>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child6 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child6>::const_reference type;
+
+
+ static type call(Expr const &e)
+ {
+ return e.proto_base().child6;
+ }
+ };
+ }
+
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ struct function
+ <
+ A0 , A1 , A2 , A3 , A4 , A5 , A6
+ , void , void , void
+ >
+ : proto::transform<
+ function<
+ A0 , A1 , A2 , A3 , A4 , A5 , A6
+ , void , void , void
+ >
+ , int
+ >
+ {
+ typedef proto::expr<proto::tag::function, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> type;
+ typedef proto::basic_expr<proto::tag::function, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> proto_grammar;
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : detail::pass_through_impl<function, Expr, State, Data>
+ {};
+
+ typedef proto::tag::function proto_tag;
+ typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6;
+ typedef detail::if_vararg<A6> proto_child7; typedef detail::if_vararg<A6> proto_child8; typedef detail::if_vararg<A6> proto_child9;
+ };
+
+
+
+
+
+
+
+
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ struct nary_expr
+ <
+ Tag
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6
+ , void , void , void
+ >
+ : proto::transform<
+ nary_expr<
+ Tag
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6
+ , void , void , void
+ >
+ , int
+ >
+ {
+ typedef proto::expr<Tag, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> type;
+ typedef proto::basic_expr<Tag, list7<A0 , A1 , A2 , A3 , A4 , A5 , A6>, 7> proto_grammar;
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : detail::pass_through_impl<nary_expr, Expr, State, Data>
+ {};
+
+ typedef Tag proto_tag;
+ typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6;
+ typedef detail::if_vararg<A6> proto_child7; typedef detail::if_vararg<A6> proto_child8; typedef detail::if_vararg<A6> proto_child9;
+ };
+ namespace detail
+ {
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename> class T
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
+ >
+ struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6> BOOST_PROTO_TEMPLATE_ARITY_PARAM(7)>
+ : is_same<A6, callable>
+ {};
+ }
+ namespace result_of
+ {
+
+
+
+
+
+
+ template<typename Expr>
+ struct child_c<Expr, 7>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child7 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child7>::value_type type;
+ };
+ template<typename Expr>
+ struct child_c<Expr &, 7>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child7 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child7>::reference type;
+
+
+ static type call(Expr &e)
+ {
+ return e.proto_base().child7;
+ }
+ };
+ template<typename Expr>
+ struct child_c<Expr const &, 7>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child7 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child7>::const_reference type;
+
+
+ static type call(Expr const &e)
+ {
+ return e.proto_base().child7;
+ }
+ };
+ }
+
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ struct function
+ <
+ A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+ , void , void
+ >
+ : proto::transform<
+ function<
+ A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+ , void , void
+ >
+ , int
+ >
+ {
+ typedef proto::expr<proto::tag::function, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> type;
+ typedef proto::basic_expr<proto::tag::function, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> proto_grammar;
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : detail::pass_through_impl<function, Expr, State, Data>
+ {};
+
+ typedef proto::tag::function proto_tag;
+ typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7;
+ typedef detail::if_vararg<A7> proto_child8; typedef detail::if_vararg<A7> proto_child9;
+ };
+
+
+
+
+
+
+
+
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ struct nary_expr
+ <
+ Tag
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+ , void , void
+ >
+ : proto::transform<
+ nary_expr<
+ Tag
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7
+ , void , void
+ >
+ , int
+ >
+ {
+ typedef proto::expr<Tag, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> type;
+ typedef proto::basic_expr<Tag, list8<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>, 8> proto_grammar;
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : detail::pass_through_impl<nary_expr, Expr, State, Data>
+ {};
+
+ typedef Tag proto_tag;
+ typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7;
+ typedef detail::if_vararg<A7> proto_child8; typedef detail::if_vararg<A7> proto_child9;
+ };
+ namespace detail
+ {
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename , typename> class T
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7
+ >
+ struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> BOOST_PROTO_TEMPLATE_ARITY_PARAM(8)>
+ : is_same<A7, callable>
+ {};
+ }
+ namespace result_of
+ {
+
+
+
+
+
+
+ template<typename Expr>
+ struct child_c<Expr, 8>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child8 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child8>::value_type type;
+ };
+ template<typename Expr>
+ struct child_c<Expr &, 8>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child8 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child8>::reference type;
+
+
+ static type call(Expr &e)
+ {
+ return e.proto_base().child8;
+ }
+ };
+ template<typename Expr>
+ struct child_c<Expr const &, 8>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child8 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child8>::const_reference type;
+
+
+ static type call(Expr const &e)
+ {
+ return e.proto_base().child8;
+ }
+ };
+ }
+
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ struct function
+ <
+ A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+ , void
+ >
+ : proto::transform<
+ function<
+ A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+ , void
+ >
+ , int
+ >
+ {
+ typedef proto::expr<proto::tag::function, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> type;
+ typedef proto::basic_expr<proto::tag::function, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> proto_grammar;
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : detail::pass_through_impl<function, Expr, State, Data>
+ {};
+
+ typedef proto::tag::function proto_tag;
+ typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8;
+ typedef detail::if_vararg<A8> proto_child9;
+ };
+
+
+
+
+
+
+
+
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ struct nary_expr
+ <
+ Tag
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+ , void
+ >
+ : proto::transform<
+ nary_expr<
+ Tag
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8
+ , void
+ >
+ , int
+ >
+ {
+ typedef proto::expr<Tag, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> type;
+ typedef proto::basic_expr<Tag, list9<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>, 9> proto_grammar;
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : detail::pass_through_impl<nary_expr, Expr, State, Data>
+ {};
+
+ typedef Tag proto_tag;
+ typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8;
+ typedef detail::if_vararg<A8> proto_child9;
+ };
+ namespace detail
+ {
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class T
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8
+ >
+ struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> BOOST_PROTO_TEMPLATE_ARITY_PARAM(9)>
+ : is_same<A8, callable>
+ {};
+ }
+ namespace result_of
+ {
+
+
+
+
+
+
+ template<typename Expr>
+ struct child_c<Expr, 9>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child9 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child9>::value_type type;
+ };
+ template<typename Expr>
+ struct child_c<Expr &, 9>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child9 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child9>::reference type;
+
+
+ static type call(Expr &e)
+ {
+ return e.proto_base().child9;
+ }
+ };
+ template<typename Expr>
+ struct child_c<Expr const &, 9>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child9 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child9>::const_reference type;
+
+
+ static type call(Expr const &e)
+ {
+ return e.proto_base().child9;
+ }
+ };
+ }
+
+
+
+
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ struct function
+ : proto::transform<
+ function<
+ A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+
+ >
+ , int
+ >
+ {
+ typedef proto::expr<proto::tag::function, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> type;
+ typedef proto::basic_expr<proto::tag::function, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> proto_grammar;
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : detail::pass_through_impl<function, Expr, State, Data>
+ {};
+
+ typedef proto::tag::function proto_tag;
+ typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8; typedef A9 proto_child9;
+
+ };
+
+
+
+
+
+
+
+
+ template<typename Tag , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ struct nary_expr
+ : proto::transform<
+ nary_expr<
+ Tag
+ , A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9
+
+ >
+ , int
+ >
+ {
+ typedef proto::expr<Tag, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> type;
+ typedef proto::basic_expr<Tag, list10<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>, 10> proto_grammar;
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : detail::pass_through_impl<nary_expr, Expr, State, Data>
+ {};
+
+ typedef Tag proto_tag;
+ typedef A0 proto_child0; typedef A1 proto_child1; typedef A2 proto_child2; typedef A3 proto_child3; typedef A4 proto_child4; typedef A5 proto_child5; typedef A6 proto_child6; typedef A7 proto_child7; typedef A8 proto_child8; typedef A9 proto_child9;
+
+ };
+ namespace detail
+ {
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class T
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
+ >
+ struct is_callable_<T<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> BOOST_PROTO_TEMPLATE_ARITY_PARAM(10)>
+ : is_same<A9, callable>
+ {};
+ }
+ namespace result_of
+ {
+
+
+
+
+
+
+ template<typename Expr>
+ struct child_c<Expr, 10>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child10 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child10>::value_type type;
+ };
+ template<typename Expr>
+ struct child_c<Expr &, 10>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child10 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child10>::reference type;
+
+
+ static type call(Expr &e)
+ {
+ return e.proto_base().child10;
+ }
+ };
+ template<typename Expr>
+ struct child_c<Expr const &, 10>
+ {
+
+ BOOST_STATIC_ASSERT(0 != Expr::proto_arity_c);
+
+
+ typedef typename Expr::proto_child10 value_type;
+
+
+
+
+
+ typedef typename detail::expr_traits<typename Expr::proto_child10>::const_reference type;
+
+
+ static type call(Expr const &e)
+ {
+ return e.proto_base().child10;
+ }
+ };
+ }

Modified: trunk/boost/proto/detail/preprocessed/unpack_expr_.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/unpack_expr_.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/unpack_expr_.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -238,3 +238,208 @@
             return other::call(sequence);
         }
     };
+ template<typename Tag, typename Domain, typename Sequence>
+ struct unpack_expr_<Tag, Domain, Sequence, 6>
+ {
+ typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5;
+ typedef
+ list6<
+ typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type
+ >
+ proto_args;
+ typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+ typedef typename Domain::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+ static type const call(Sequence const &sequence)
+ {
+ fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4);
+ expr_type const that = {
+ detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5)
+ };
+ return proto_generator()(that);
+ }
+ };
+ template<typename Tag, typename Sequence>
+ struct unpack_expr_<Tag, deduce_domain, Sequence, 6>
+ {
+ typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5;
+ typedef
+ unpack_expr_<
+ Tag
+ , typename deduce_domain6<
+ typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type
+ >::type
+ , Sequence
+ , 6
+ >
+ other;
+ typedef typename other::type type;
+ static type const call(Sequence const &sequence)
+ {
+ return other::call(sequence);
+ }
+ };
+ template<typename Tag, typename Domain, typename Sequence>
+ struct unpack_expr_<Tag, Domain, Sequence, 7>
+ {
+ typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6;
+ typedef
+ list7<
+ typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type
+ >
+ proto_args;
+ typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+ typedef typename Domain::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+ static type const call(Sequence const &sequence)
+ {
+ fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5);
+ expr_type const that = {
+ detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6)
+ };
+ return proto_generator()(that);
+ }
+ };
+ template<typename Tag, typename Sequence>
+ struct unpack_expr_<Tag, deduce_domain, Sequence, 7>
+ {
+ typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6;
+ typedef
+ unpack_expr_<
+ Tag
+ , typename deduce_domain7<
+ typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type
+ >::type
+ , Sequence
+ , 7
+ >
+ other;
+ typedef typename other::type type;
+ static type const call(Sequence const &sequence)
+ {
+ return other::call(sequence);
+ }
+ };
+ template<typename Tag, typename Domain, typename Sequence>
+ struct unpack_expr_<Tag, Domain, Sequence, 8>
+ {
+ typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7;
+ typedef
+ list8<
+ typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type
, typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type
+ >
+ proto_args;
+ typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+ typedef typename Domain::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+ static type const call(Sequence const &sequence)
+ {
+ fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6);
+ expr_type const that = {
+ detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::
type >::type , Domain >()(*it7)
+ };
+ return proto_generator()(that);
+ }
+ };
+ template<typename Tag, typename Sequence>
+ struct unpack_expr_<Tag, deduce_domain, Sequence, 8>
+ {
+ typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7;
+ typedef
+ unpack_expr_<
+ Tag
+ , typename deduce_domain8<
+ typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type
+ >::type
+ , Sequence
+ , 8
+ >
+ other;
+ typedef typename other::type type;
+ static type const call(Sequence const &sequence)
+ {
+ return other::call(sequence);
+ }
+ };
+ template<typename Tag, typename Domain, typename Sequence>
+ struct unpack_expr_<Tag, Domain, Sequence, 9>
+ {
+ typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8;
+ typedef
+ list9<
+ typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type
, typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >::result_type
+ >
+ proto_args;
+ typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+ typedef typename Domain::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+ static type const call(Sequence const &sequence)
+ {
+ fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6); fusion_iterator8 it8 = fusion::next(it7);
+ expr_type const that = {
+ detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::
type >::type , Domain >()(*it7) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >()(*it8)
+ };
+ return proto_generator()(that);
+ }
+ };
+ template<typename Tag, typename Sequence>
+ struct unpack_expr_<Tag, deduce_domain, Sequence, 9>
+ {
+ typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8;
+ typedef
+ unpack_expr_<
+ Tag
+ , typename deduce_domain9<
+ typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type
+ >::type
+ , Sequence
+ , 9
+ >
+ other;
+ typedef typename other::type type;
+ static type const call(Sequence const &sequence)
+ {
+ return other::call(sequence);
+ }
+ };
+ template<typename Tag, typename Domain, typename Sequence>
+ struct unpack_expr_<Tag, Domain, Sequence, 10>
+ {
+ typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; typedef typename fusion::result_of::next< fusion_iterator8>::type fusion_iterator9;
+ typedef
+ list10<
+ typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >::result_type
, typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >::result_type , typename detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type , Domain >::result_type
+ >
+ proto_args;
+ typedef typename base_expr<Domain, Tag, proto_args>::type expr_type;
+ typedef typename Domain::proto_generator proto_generator;
+ typedef typename proto_generator::template result<proto_generator(expr_type)>::type type;
+ static type const call(Sequence const &sequence)
+ {
+ fusion_iterator0 it0 = fusion::begin(sequence); fusion_iterator1 it1 = fusion::next(it0); fusion_iterator2 it2 = fusion::next(it1); fusion_iterator3 it3 = fusion::next(it2); fusion_iterator4 it4 = fusion::next(it3); fusion_iterator5 it5 = fusion::next(it4); fusion_iterator6 it6 = fusion::next(it5); fusion_iterator7 it7 = fusion::next(it6); fusion_iterator8 it8 = fusion::next(it7); fusion_iterator9 it9 = fusion::next(it8);
+ expr_type const that = {
+ detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , Domain >()(*it0) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , Domain >()(*it1) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , Domain >()(*it2) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , Domain >()(*it3) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , Domain >()(*it4) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , Domain >()(*it5) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , Domain >()(*it6) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::
type >::type , Domain >()(*it7) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , Domain >()(*it8) , detail::protoify< typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type , Domain >()(*it9)
+ };
+ return proto_generator()(that);
+ }
+ };
+ template<typename Tag, typename Sequence>
+ struct unpack_expr_<Tag, deduce_domain, Sequence, 10>
+ {
+ typedef typename fusion::result_of::begin<Sequence const>::type fusion_iterator0; typedef typename fusion::result_of::next< fusion_iterator0>::type fusion_iterator1; typedef typename fusion::result_of::next< fusion_iterator1>::type fusion_iterator2; typedef typename fusion::result_of::next< fusion_iterator2>::type fusion_iterator3; typedef typename fusion::result_of::next< fusion_iterator3>::type fusion_iterator4; typedef typename fusion::result_of::next< fusion_iterator4>::type fusion_iterator5; typedef typename fusion::result_of::next< fusion_iterator5>::type fusion_iterator6; typedef typename fusion::result_of::next< fusion_iterator6>::type fusion_iterator7; typedef typename fusion::result_of::next< fusion_iterator7>::type fusion_iterator8; typedef typename fusion::result_of::next< fusion_iterator8>::type fusion_iterator9;
+ typedef
+ unpack_expr_<
+ Tag
+ , typename deduce_domain10<
+ typename add_const< typename fusion::result_of::value_of< fusion_iterator0 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator1 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator2 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator3 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator4 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator5 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator6 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator7 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator8 >::type >::type , typename add_const< typename fusion::result_of::value_of< fusion_iterator9 >::type >::type
+ >::type
+ , Sequence
+ , 10
+ >
+ other;
+ typedef typename other::type type;
+ static type const call(Sequence const &sequence)
+ {
+ return other::call(sequence);
+ }
+ };

Modified: trunk/boost/proto/detail/preprocessed/vararg_matches_impl.hpp
==============================================================================
--- trunk/boost/proto/detail/preprocessed/vararg_matches_impl.hpp (original)
+++ trunk/boost/proto/detail/preprocessed/vararg_matches_impl.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -81,3 +81,98 @@
, Back
>
{};
+ template<typename Args, typename Back, long To>
+ struct vararg_matches_impl<Args, Back, 6, To>
+ : and_2<
+ matches_<
+ typename detail::expr_traits<typename Args::child5>::value_type::proto_derived_expr
+ , typename detail::expr_traits<typename Args::child5>::value_type::proto_grammar
+ , Back
+ >::value
+ , vararg_matches_impl<Args, Back, 6 + 1, To>
+ >
+ {};
+ template<typename Args, typename Back>
+ struct vararg_matches_impl<Args, Back, 6, 6>
+ : matches_<
+ typename detail::expr_traits<typename Args::child5>::value_type::proto_derived_expr
+ , typename detail::expr_traits<typename Args::child5>::value_type::proto_grammar
+ , Back
+ >
+ {};
+ template<typename Args, typename Back, long To>
+ struct vararg_matches_impl<Args, Back, 7, To>
+ : and_2<
+ matches_<
+ typename detail::expr_traits<typename Args::child6>::value_type::proto_derived_expr
+ , typename detail::expr_traits<typename Args::child6>::value_type::proto_grammar
+ , Back
+ >::value
+ , vararg_matches_impl<Args, Back, 7 + 1, To>
+ >
+ {};
+ template<typename Args, typename Back>
+ struct vararg_matches_impl<Args, Back, 7, 7>
+ : matches_<
+ typename detail::expr_traits<typename Args::child6>::value_type::proto_derived_expr
+ , typename detail::expr_traits<typename Args::child6>::value_type::proto_grammar
+ , Back
+ >
+ {};
+ template<typename Args, typename Back, long To>
+ struct vararg_matches_impl<Args, Back, 8, To>
+ : and_2<
+ matches_<
+ typename detail::expr_traits<typename Args::child7>::value_type::proto_derived_expr
+ , typename detail::expr_traits<typename Args::child7>::value_type::proto_grammar
+ , Back
+ >::value
+ , vararg_matches_impl<Args, Back, 8 + 1, To>
+ >
+ {};
+ template<typename Args, typename Back>
+ struct vararg_matches_impl<Args, Back, 8, 8>
+ : matches_<
+ typename detail::expr_traits<typename Args::child7>::value_type::proto_derived_expr
+ , typename detail::expr_traits<typename Args::child7>::value_type::proto_grammar
+ , Back
+ >
+ {};
+ template<typename Args, typename Back, long To>
+ struct vararg_matches_impl<Args, Back, 9, To>
+ : and_2<
+ matches_<
+ typename detail::expr_traits<typename Args::child8>::value_type::proto_derived_expr
+ , typename detail::expr_traits<typename Args::child8>::value_type::proto_grammar
+ , Back
+ >::value
+ , vararg_matches_impl<Args, Back, 9 + 1, To>
+ >
+ {};
+ template<typename Args, typename Back>
+ struct vararg_matches_impl<Args, Back, 9, 9>
+ : matches_<
+ typename detail::expr_traits<typename Args::child8>::value_type::proto_derived_expr
+ , typename detail::expr_traits<typename Args::child8>::value_type::proto_grammar
+ , Back
+ >
+ {};
+ template<typename Args, typename Back, long To>
+ struct vararg_matches_impl<Args, Back, 10, To>
+ : and_2<
+ matches_<
+ typename detail::expr_traits<typename Args::child9>::value_type::proto_derived_expr
+ , typename detail::expr_traits<typename Args::child9>::value_type::proto_grammar
+ , Back
+ >::value
+ , vararg_matches_impl<Args, Back, 10 + 1, To>
+ >
+ {};
+ template<typename Args, typename Back>
+ struct vararg_matches_impl<Args, Back, 10, 10>
+ : matches_<
+ typename detail::expr_traits<typename Args::child9>::value_type::proto_derived_expr
+ , typename detail::expr_traits<typename Args::child9>::value_type::proto_grammar
+ , Back
+ >
+ {};

Modified: trunk/boost/proto/proto_fwd.hpp
==============================================================================
--- trunk/boost/proto/proto_fwd.hpp (original)
+++ trunk/boost/proto/proto_fwd.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -27,11 +27,11 @@
#include <boost/mpl/aux_/config/ttp.hpp>

#ifndef BOOST_PROTO_MAX_ARITY
-# define BOOST_PROTO_MAX_ARITY 5
+# define BOOST_PROTO_MAX_ARITY 10
#endif

#ifndef BOOST_PROTO_MAX_LOGICAL_ARITY
-# define BOOST_PROTO_MAX_LOGICAL_ARITY 8
+# define BOOST_PROTO_MAX_LOGICAL_ARITY 10
#endif

#ifndef BOOST_PROTO_MAX_FUNCTION_CALL_ARITY
@@ -47,9 +47,9 @@
#endif

#ifndef BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
- #if 5 != BOOST_PROTO_MAX_ARITY || \
- 8 != BOOST_PROTO_MAX_LOGICAL_ARITY || \
- 5 != BOOST_PROTO_MAX_FUNCTION_CALL_ARITY
+ #if 10 < BOOST_PROTO_MAX_ARITY || \
+ 10 < BOOST_PROTO_MAX_LOGICAL_ARITY || \
+ 10 < BOOST_PROTO_MAX_FUNCTION_CALL_ARITY
#define BOOST_PROTO_DONT_USE_PREPROCESSED_FILES
#endif
#endif

Modified: trunk/boost/proto/transform/default.hpp
==============================================================================
--- trunk/boost/proto/transform/default.hpp (original)
+++ trunk/boost/proto/transform/default.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -1,621 +1,510 @@
-#ifndef BOOST_PP_IS_ITERATING
- ///////////////////////////////////////////////////////////////////////////////
- /// \file default.hpp
- /// Contains definition of the _default transform, which gives operators their
- /// usual C++ meanings and uses Boost.Typeof to deduce return types.
- //
- // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008
- #define BOOST_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008
-
- #include <boost/preprocessor/iteration/iterate.hpp>
- #include <boost/preprocessor/repetition/repeat.hpp>
- #include <boost/preprocessor/arithmetic/add.hpp>
- #include <boost/preprocessor/arithmetic/sub.hpp>
- #include <boost/preprocessor/repetition/enum.hpp>
- #include <boost/preprocessor/repetition/enum_shifted.hpp>
- #include <boost/preprocessor/repetition/enum_shifted_params.hpp>
- #include <boost/ref.hpp>
- #include <boost/get_pointer.hpp>
- #include <boost/utility/enable_if.hpp>
- #include <boost/type_traits/is_member_pointer.hpp>
- #include <boost/type_traits/is_member_object_pointer.hpp>
- #include <boost/type_traits/is_member_function_pointer.hpp>
- #include <boost/proto/proto_fwd.hpp>
- #include <boost/proto/traits.hpp>
- #include <boost/proto/transform/impl.hpp>
- #include <boost/proto/transform/arg.hpp>
- #include <boost/proto/detail/decltype.hpp>
-
- namespace boost { namespace proto
+///////////////////////////////////////////////////////////////////////////////
+/// \file default.hpp
+/// Contains definition of the _default transform, which gives operators their
+/// usual C++ meanings and uses Boost.Typeof to deduce return types.
+//
+// Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008
+#define BOOST_PROTO_TRANSFORM_DEFAULT_HPP_EAN_04_04_2008
+
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/arithmetic/add.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_shifted.hpp>
+#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
+#include <boost/ref.hpp>
+#include <boost/get_pointer.hpp>
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_member_pointer.hpp>
+#include <boost/type_traits/is_member_object_pointer.hpp>
+#include <boost/type_traits/is_member_function_pointer.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/traits.hpp>
+#include <boost/proto/transform/impl.hpp>
+#include <boost/proto/transform/arg.hpp>
+#include <boost/proto/detail/decltype.hpp>
+
+namespace boost { namespace proto
+{
+ namespace detail
     {
- namespace detail
+ template<typename Grammar, typename Tag>
+ struct default_case
+ : not_<_>
+ {};
+
+ template<typename Grammar>
+ struct default_case<Grammar, tag::terminal>
+ : when<terminal<_>, _value>
+ {};
+
+ template<typename Grammar>
+ struct default_cases
         {
- template<typename Grammar, typename Tag>
- struct default_case
- : not_<_>
+ template<typename Tag>
+ struct case_
+ : default_case<Grammar, Tag>
             {};
+ };

- template<typename Grammar>
- struct default_case<Grammar, tag::terminal>
- : when<terminal<_>, _value>
- {};
+ #define BOOST_PROTO_UNARY_DEFAULT_EVAL(OP, TAG, MAKE) \
+ template<typename Grammar> \
+ struct BOOST_PP_CAT(default_, TAG) \
+ : transform<BOOST_PP_CAT(default_, TAG)<Grammar> > \
+ { \
+ template<typename Expr, typename State, typename Data> \
+ struct impl \
+ : transform_impl<Expr, State, Data> \
+ { \
+ private: \
+ typedef typename result_of::child_c<Expr, 0>::type e0; \
+ typedef typename Grammar::template impl<e0, State, Data>::result_type r0; \
+ public: \
+ BOOST_PROTO_DECLTYPE_(OP proto::detail::MAKE<r0>(), result_type) \
+ result_type operator ()( \
+ typename impl::expr_param e \
+ , typename impl::state_param s \
+ , typename impl::data_param d \
+ ) const \
+ { \
+ typename Grammar::template impl<e0, State, Data> t0; \
+ return OP t0(proto::child_c<0>(e), s, d); \
+ } \
+ }; \
+ }; \
+ \
+ template<typename Grammar> \
+ struct default_case<Grammar, tag::TAG> \
+ : when<unary_expr<tag::TAG, Grammar>, BOOST_PP_CAT(default_, TAG)<Grammar> > \
+ {}; \
+ /**/
+
+ #define BOOST_PROTO_BINARY_DEFAULT_EVAL(OP, TAG, LMAKE, RMAKE) \
+ template<typename Grammar> \
+ struct BOOST_PP_CAT(default_, TAG) \
+ : transform<BOOST_PP_CAT(default_, TAG)<Grammar> > \
+ { \
+ template<typename Expr, typename State, typename Data> \
+ struct impl \
+ : transform_impl<Expr, State, Data> \
+ { \
+ private: \
+ typedef typename result_of::child_c<Expr, 0>::type e0; \
+ typedef typename result_of::child_c<Expr, 1>::type e1; \
+ typedef typename Grammar::template impl<e0, State, Data>::result_type r0; \
+ typedef typename Grammar::template impl<e1, State, Data>::result_type r1; \
+ public: \
+ BOOST_PROTO_DECLTYPE_( \
+ proto::detail::LMAKE<r0>() OP proto::detail::RMAKE<r1>() \
+ , result_type \
+ ) \
+ result_type operator ()( \
+ typename impl::expr_param e \
+ , typename impl::state_param s \
+ , typename impl::data_param d \
+ ) const \
+ { \
+ typename Grammar::template impl<e0, State, Data> t0; \
+ typename Grammar::template impl<e1, State, Data> t1; \
+ return t0(proto::child_c<0>(e), s, d) \
+ OP t1(proto::child_c<1>(e), s, d); \
+ } \
+ }; \
+ }; \
+ \
+ template<typename Grammar> \
+ struct default_case<Grammar, tag::TAG> \
+ : when<binary_expr<tag::TAG, Grammar, Grammar>, BOOST_PP_CAT(default_, TAG)<Grammar> > \
+ {}; \
+ /**/
+
+ BOOST_PROTO_UNARY_DEFAULT_EVAL(+, unary_plus, make)
+ BOOST_PROTO_UNARY_DEFAULT_EVAL(-, negate, make)
+ BOOST_PROTO_UNARY_DEFAULT_EVAL(*, dereference, make)
+ BOOST_PROTO_UNARY_DEFAULT_EVAL(~, complement, make)
+ BOOST_PROTO_UNARY_DEFAULT_EVAL(&, address_of, make)
+ BOOST_PROTO_UNARY_DEFAULT_EVAL(!, logical_not, make)
+ BOOST_PROTO_UNARY_DEFAULT_EVAL(++, pre_inc, make_mutable)
+ BOOST_PROTO_UNARY_DEFAULT_EVAL(--, pre_dec, make_mutable)
+
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(<<, shift_left, make_mutable, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(>>, shift_right, make_mutable, make_mutable)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(*, multiplies, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(/, divides, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(%, modulus, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(+, plus, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(-, minus, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(<, less, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(>, greater, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(<=, less_equal, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(>=, greater_equal, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(==, equal_to, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(!=, not_equal_to, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(||, logical_or, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(&&, logical_and, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(&, bitwise_and, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(|, bitwise_or, make, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(^, bitwise_xor, make, make)
+
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(=, assign, make_mutable, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(<<=, shift_left_assign, make_mutable, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(>>=, shift_right_assign, make_mutable, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(*=, multiplies_assign, make_mutable, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(/=, divides_assign, make_mutable, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(%=, modulus_assign, make_mutable, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(+=, plus_assign, make_mutable, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(-=, minus_assign, make_mutable, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(&=, bitwise_and_assign, make_mutable, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(|=, bitwise_or_assign, make_mutable, make)
+ BOOST_PROTO_BINARY_DEFAULT_EVAL(^=, bitwise_xor_assign, make_mutable, make)

- template<typename Grammar>
- struct default_cases
- {
- template<typename Tag>
- struct case_
- : default_case<Grammar, Tag>
- {};
- };
+ #undef BOOST_PROTO_UNARY_DEFAULT_EVAL
+ #undef BOOST_PROTO_BINARY_DEFAULT_EVAL

- #define BOOST_PROTO_UNARY_DEFAULT_EVAL(OP, TAG, MAKE) \
- template<typename Grammar> \
- struct BOOST_PP_CAT(default_, TAG) \
- : transform<BOOST_PP_CAT(default_, TAG)<Grammar> > \
- { \
- template<typename Expr, typename State, typename Data> \
- struct impl \
- : transform_impl<Expr, State, Data> \
- { \
- private: \
- typedef typename result_of::child_c<Expr, 0>::type e0; \
- typedef typename Grammar::template impl<e0, State, Data>::result_type r0; \
- public: \
- BOOST_PROTO_DECLTYPE_(OP proto::detail::MAKE<r0>(), result_type) \
- result_type operator ()( \
- typename impl::expr_param e \
- , typename impl::state_param s \
- , typename impl::data_param d \
- ) const \
- { \
- typename Grammar::template impl<e0, State, Data> t0; \
- return OP t0(proto::child_c<0>(e), s, d); \
- } \
- }; \
- }; \
- \
- template<typename Grammar> \
- struct default_case<Grammar, tag::TAG> \
- : when<unary_expr<tag::TAG, Grammar>, BOOST_PP_CAT(default_, TAG)<Grammar> > \
- {}; \
- /**/
+ /// INTERNAL ONLY
+ template<typename Grammar, typename Expr, typename State, typename Data>
+ struct is_member_function_invocation
+ : is_member_function_pointer<
+ typename uncvref<
+ typename Grammar::template impl<
+ typename result_of::child_c<Expr, 1>::type
+ , State
+ , Data
+ >::result_type
+ >::type
+ >
+ {};

- #define BOOST_PROTO_BINARY_DEFAULT_EVAL(OP, TAG, LMAKE, RMAKE) \
- template<typename Grammar> \
- struct BOOST_PP_CAT(default_, TAG) \
- : transform<BOOST_PP_CAT(default_, TAG)<Grammar> > \
- { \
- template<typename Expr, typename State, typename Data> \
- struct impl \
- : transform_impl<Expr, State, Data> \
- { \
- private: \
- typedef typename result_of::child_c<Expr, 0>::type e0; \
- typedef typename result_of::child_c<Expr, 1>::type e1; \
- typedef typename Grammar::template impl<e0, State, Data>::result_type r0; \
- typedef typename Grammar::template impl<e1, State, Data>::result_type r1; \
- public: \
- BOOST_PROTO_DECLTYPE_( \
- proto::detail::LMAKE<r0>() OP proto::detail::RMAKE<r1>() \
- , result_type \
- ) \
- result_type operator ()( \
- typename impl::expr_param e \
- , typename impl::state_param s \
- , typename impl::data_param d \
- ) const \
- { \
- typename Grammar::template impl<e0, State, Data> t0; \
- typename Grammar::template impl<e1, State, Data> t1; \
- return t0(proto::child_c<0>(e), s, d) \
- OP t1(proto::child_c<1>(e), s, d); \
- } \
- }; \
- }; \
- \
- template<typename Grammar> \
- struct default_case<Grammar, tag::TAG> \
- : when<binary_expr<tag::TAG, Grammar, Grammar>, BOOST_PP_CAT(default_, TAG)<Grammar> > \
- {}; \
- /**/
+ /// INTERNAL ONLY
+ template<typename Grammar, typename Expr, typename State, typename Data, bool IsMemFunCall>
+ struct default_mem_ptr_impl
+ : transform_impl<Expr, State, Data>
+ {
+ private:
+ typedef typename result_of::child_c<Expr, 0>::type e0;
+ typedef typename result_of::child_c<Expr, 1>::type e1;
+ typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
+ typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
+ public:
+ typedef typename detail::mem_ptr_fun<r0, r1>::result_type result_type;
+ result_type operator ()(
+ typename default_mem_ptr_impl::expr_param e
+ , typename default_mem_ptr_impl::state_param s
+ , typename default_mem_ptr_impl::data_param d
+ ) const
+ {
+ typename Grammar::template impl<e0, State, Data> t0;
+ typename Grammar::template impl<e1, State, Data> t1;
+ return detail::mem_ptr_fun<r0, r1>()(
+ t0(proto::child_c<0>(e), s, d)
+ , t1(proto::child_c<1>(e), s, d)
+ );
+ }
+ };

- BOOST_PROTO_UNARY_DEFAULT_EVAL(+, unary_plus, make)
- BOOST_PROTO_UNARY_DEFAULT_EVAL(-, negate, make)
- BOOST_PROTO_UNARY_DEFAULT_EVAL(*, dereference, make)
- BOOST_PROTO_UNARY_DEFAULT_EVAL(~, complement, make)
- BOOST_PROTO_UNARY_DEFAULT_EVAL(&, address_of, make)
- BOOST_PROTO_UNARY_DEFAULT_EVAL(!, logical_not, make)
- BOOST_PROTO_UNARY_DEFAULT_EVAL(++, pre_inc, make_mutable)
- BOOST_PROTO_UNARY_DEFAULT_EVAL(--, pre_dec, make_mutable)
-
- BOOST_PROTO_BINARY_DEFAULT_EVAL(<<, shift_left, make_mutable, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(>>, shift_right, make_mutable, make_mutable)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(*, multiplies, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(/, divides, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(%, modulus, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(+, plus, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(-, minus, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(<, less, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(>, greater, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(<=, less_equal, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(>=, greater_equal, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(==, equal_to, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(!=, not_equal_to, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(||, logical_or, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(&&, logical_and, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(&, bitwise_and, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(|, bitwise_or, make, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(^, bitwise_xor, make, make)
-
- BOOST_PROTO_BINARY_DEFAULT_EVAL(=, assign, make_mutable, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(<<=, shift_left_assign, make_mutable, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(>>=, shift_right_assign, make_mutable, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(*=, multiplies_assign, make_mutable, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(/=, divides_assign, make_mutable, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(%=, modulus_assign, make_mutable, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(+=, plus_assign, make_mutable, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(-=, minus_assign, make_mutable, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(&=, bitwise_and_assign, make_mutable, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(|=, bitwise_or_assign, make_mutable, make)
- BOOST_PROTO_BINARY_DEFAULT_EVAL(^=, bitwise_xor_assign, make_mutable, make)
-
- #undef BOOST_PROTO_UNARY_DEFAULT_EVAL
- #undef BOOST_PROTO_BINARY_DEFAULT_EVAL
-
- /// INTERNAL ONLY
- template<typename Grammar, typename Expr, typename State, typename Data>
- struct is_member_function_invocation
- : is_member_function_pointer<
- typename uncvref<
- typename Grammar::template impl<
- typename result_of::child_c<Expr, 1>::type
- , State
- , Data
- >::result_type
- >::type
+ /// INTERNAL ONLY
+ template<typename Grammar, typename Expr, typename State, typename Data>
+ struct default_mem_ptr_impl<Grammar, Expr, State, Data, true>
+ : transform_impl<Expr, State, Data>
+ {
+ private:
+ typedef typename result_of::child_c<Expr, 0>::type e0;
+ typedef typename result_of::child_c<Expr, 1>::type e1;
+ typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
+ typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
+ public:
+ typedef detail::memfun<r0, r1> result_type;
+ result_type const operator ()(
+ typename default_mem_ptr_impl::expr_param e
+ , typename default_mem_ptr_impl::state_param s
+ , typename default_mem_ptr_impl::data_param d
+ ) const
+ {
+ typename Grammar::template impl<e0, State, Data> t0;
+ typename Grammar::template impl<e1, State, Data> t1;
+ return detail::memfun<r0, r1>(
+ t0(proto::child_c<0>(e), s, d)
+ , t1(proto::child_c<1>(e), s, d)
+ );
+ }
+ };
+
+ template<typename Grammar>
+ struct default_mem_ptr
+ : transform<default_mem_ptr<Grammar> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : default_mem_ptr_impl<
+ Grammar
+ , Expr
+ , State
+ , Data
+ , is_member_function_invocation<Grammar, Expr, State, Data>::value
>
             {};
+ };
+
+ template<typename Grammar>
+ struct default_case<Grammar, tag::mem_ptr>
+ : when<mem_ptr<Grammar, Grammar>, default_mem_ptr<Grammar> >
+ {};

- /// INTERNAL ONLY
- template<typename Grammar, typename Expr, typename State, typename Data, bool IsMemFunCall>
- struct default_mem_ptr_impl
+ template<typename Grammar>
+ struct default_post_inc
+ : transform<default_post_inc<Grammar> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
               : transform_impl<Expr, State, Data>
             {
             private:
                 typedef typename result_of::child_c<Expr, 0>::type e0;
- typedef typename result_of::child_c<Expr, 1>::type e1;
                 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
- typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
             public:
- typedef typename detail::mem_ptr_fun<r0, r1>::result_type result_type;
+ BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() ++, result_type)
                 result_type operator ()(
- typename default_mem_ptr_impl::expr_param e
- , typename default_mem_ptr_impl::state_param s
- , typename default_mem_ptr_impl::data_param d
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
                 ) const
                 {
                     typename Grammar::template impl<e0, State, Data> t0;
- typename Grammar::template impl<e1, State, Data> t1;
- return detail::mem_ptr_fun<r0, r1>()(
- t0(proto::child_c<0>(e), s, d)
- , t1(proto::child_c<1>(e), s, d)
- );
+ return t0(proto::child_c<0>(e), s, d) ++;
                 }
             };
+ };
+
+ template<typename Grammar>
+ struct default_case<Grammar, tag::post_inc>
+ : when<post_inc<Grammar>, default_post_inc<Grammar> >
+ {};

- /// INTERNAL ONLY
- template<typename Grammar, typename Expr, typename State, typename Data>
- struct default_mem_ptr_impl<Grammar, Expr, State, Data, true>
+ template<typename Grammar>
+ struct default_post_dec
+ : transform<default_post_dec<Grammar> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
               : transform_impl<Expr, State, Data>
             {
             private:
                 typedef typename result_of::child_c<Expr, 0>::type e0;
- typedef typename result_of::child_c<Expr, 1>::type e1;
                 typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
- typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
             public:
- typedef detail::memfun<r0, r1> result_type;
- result_type const operator ()(
- typename default_mem_ptr_impl::expr_param e
- , typename default_mem_ptr_impl::state_param s
- , typename default_mem_ptr_impl::data_param d
+ BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() --, result_type)
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
                 ) const
                 {
                     typename Grammar::template impl<e0, State, Data> t0;
- typename Grammar::template impl<e1, State, Data> t1;
- return detail::memfun<r0, r1>(
- t0(proto::child_c<0>(e), s, d)
- , t1(proto::child_c<1>(e), s, d)
- );
+ return t0(proto::child_c<0>(e), s, d) --;
                 }
             };
+ };

- template<typename Grammar>
- struct default_mem_ptr
- : transform<default_mem_ptr<Grammar> >
- {
- template<typename Expr, typename State, typename Data>
- struct impl
- : default_mem_ptr_impl<
- Grammar
- , Expr
- , State
- , Data
- , is_member_function_invocation<Grammar, Expr, State, Data>::value
- >
- {};
- };
-
- template<typename Grammar>
- struct default_case<Grammar, tag::mem_ptr>
- : when<mem_ptr<Grammar, Grammar>, default_mem_ptr<Grammar> >
- {};
-
- template<typename Grammar>
- struct default_post_inc
- : transform<default_post_inc<Grammar> >
- {
- template<typename Expr, typename State, typename Data>
- struct impl
- : transform_impl<Expr, State, Data>
- {
- private:
- typedef typename result_of::child_c<Expr, 0>::type e0;
- typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
- public:
- BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() ++, result_type)
- result_type operator ()(
- typename impl::expr_param e
- , typename impl::state_param s
- , typename impl::data_param d
- ) const
- {
- typename Grammar::template impl<e0, State, Data> t0;
- return t0(proto::child_c<0>(e), s, d) ++;
- }
- };
- };
-
- template<typename Grammar>
- struct default_case<Grammar, tag::post_inc>
- : when<post_inc<Grammar>, default_post_inc<Grammar> >
- {};
-
- template<typename Grammar>
- struct default_post_dec
- : transform<default_post_dec<Grammar> >
- {
- template<typename Expr, typename State, typename Data>
- struct impl
- : transform_impl<Expr, State, Data>
- {
- private:
- typedef typename result_of::child_c<Expr, 0>::type e0;
- typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
- public:
- BOOST_PROTO_DECLTYPE_(proto::detail::make_mutable<r0>() --, result_type)
- result_type operator ()(
- typename impl::expr_param e
- , typename impl::state_param s
- , typename impl::data_param d
- ) const
- {
- typename Grammar::template impl<e0, State, Data> t0;
- return t0(proto::child_c<0>(e), s, d) --;
- }
- };
- };
-
- template<typename Grammar>
- struct default_case<Grammar, tag::post_dec>
- : when<post_dec<Grammar>, default_post_dec<Grammar> >
- {};
-
- template<typename Grammar>
- struct default_subscript
- : transform<default_subscript<Grammar> >
- {
- template<typename Expr, typename State, typename Data>
- struct impl
- : transform_impl<Expr, State, Data>
- {
- private:
- typedef typename result_of::child_c<Expr, 0>::type e0;
- typedef typename result_of::child_c<Expr, 1>::type e1;
- typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
- typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
- public:
- BOOST_PROTO_DECLTYPE_(
- proto::detail::make_subscriptable<r0>() [ proto::detail::make<r1>() ]
- , result_type
- )
- result_type operator ()(
- typename impl::expr_param e
- , typename impl::state_param s
- , typename impl::data_param d
- ) const
- {
- typename Grammar::template impl<e0, State, Data> t0;
- typename Grammar::template impl<e1, State, Data> t1;
- return t0(proto::child_c<0>(e), s, d) [
- t1(proto::child_c<1>(e), s, d) ];
- }
- };
- };
-
- template<typename Grammar>
- struct default_case<Grammar, tag::subscript>
- : when<subscript<Grammar, Grammar>, default_subscript<Grammar> >
- {};
-
- template<typename Grammar>
- struct default_if_else_
- {
- template<typename Expr, typename State, typename Data>
- struct impl
- : transform_impl<Expr, State, Data>
- {
- private:
- typedef typename result_of::child_c<Expr, 0>::type e0;
- typedef typename result_of::child_c<Expr, 1>::type e1;
- typedef typename result_of::child_c<Expr, 2>::type e2;
- typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
- typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
- typedef typename Grammar::template impl<e2, State, Data>::result_type r2;
- public:
- BOOST_PROTO_DECLTYPE_(
- proto::detail::make<r0>()
- ? proto::detail::make<r1>()
- : proto::detail::make<r2>()
- , result_type
- )
- result_type operator ()(
- typename impl::expr_param e
- , typename impl::state_param s
- , typename impl::data_param d
- ) const
- {
- typename Grammar::template impl<e0, State, Data> t0;
- typename Grammar::template impl<e1, State, Data> t1;
- typename Grammar::template impl<e2, State, Data> t2;
- return t0(proto::child_c<0>(e), s, d)
- ? t1(proto::child_c<1>(e), s, d)
- : t2(proto::child_c<2>(e), s, d);
- }
- };
- };
-
- template<typename Grammar>
- struct default_case<Grammar, tag::if_else_>
- : when<if_else_<Grammar, Grammar, Grammar>, default_if_else_<Grammar> >
- {};
-
- template<typename Grammar>
- struct default_comma
- : transform<default_comma<Grammar> >
- {
- template<typename Expr, typename State, typename Data>
- struct impl
- : transform_impl<Expr, State, Data>
- {
- private:
- typedef typename result_of::child_c<Expr, 0>::type e0;
- typedef typename result_of::child_c<Expr, 1>::type e1;
- typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
- typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
- public:
- typedef typename proto::detail::comma_result<r0, r1>::type result_type;
- result_type operator ()(
- typename impl::expr_param e
- , typename impl::state_param s
- , typename impl::data_param d
- ) const
- {
- typename Grammar::template impl<e0, State, Data> t0;
- typename Grammar::template impl<e1, State, Data> t1;
- return t0(proto::child_c<0>(e), s, d)
- , t1(proto::child_c<1>(e), s, d);
- }
- };
- };
-
- template<typename Grammar>
- struct default_case<Grammar, tag::comma>
- : when<comma<Grammar, Grammar>, default_comma<Grammar> >
- {};
-
- template<typename Grammar, typename Expr, typename State, typename Data, long Arity>
- struct default_function_impl;
-
- template<typename Grammar>
- struct default_function
- : transform<default_function<Grammar> >
- {
- template<typename Expr, typename State, typename Data>
- struct impl
- : default_function_impl<
- Grammar
- , Expr
- , State
- , Data
- , transform_impl<Expr, State, Data>::expr::proto_arity_c
- >
- {};
- };
-
- template<typename Grammar>
- struct default_case<Grammar, tag::function>
- : when<function<Grammar, vararg<Grammar> >, default_function<Grammar> >
- {};
-
- #define BOOST_PROTO_DEFAULT_EVAL_TYPE(Z, N, DATA) \
- typedef \
- typename result_of::child_c<DATA, N>::type \
- BOOST_PP_CAT(e, N); \
- \
- typedef \
- typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>::result_type \
- BOOST_PP_CAT(r, N); \
- /**/
-
- #define BOOST_PROTO_DEFAULT_EVAL(Z, N, DATA) \
- typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>()( \
- proto::child_c<N>(DATA), s, d \
- ) \
- /**/
+ template<typename Grammar>
+ struct default_case<Grammar, tag::post_dec>
+ : when<post_dec<Grammar>, default_post_dec<Grammar> >
+ {};

- template<typename Grammar, typename Expr, typename State, typename Data>
- struct default_function_impl<Grammar, Expr, State, Data, 1>
+ template<typename Grammar>
+ struct default_subscript
+ : transform<default_subscript<Grammar> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
               : transform_impl<Expr, State, Data>
             {
- BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
-
- typedef
- typename proto::detail::result_of_fixup<r0>::type
- function_type;
-
- typedef
- typename BOOST_PROTO_RESULT_OF<function_type()>::type
- result_type;
-
+ private:
+ typedef typename result_of::child_c<Expr, 0>::type e0;
+ typedef typename result_of::child_c<Expr, 1>::type e1;
+ typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
+ typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
+ public:
+ BOOST_PROTO_DECLTYPE_(
+ proto::detail::make_subscriptable<r0>() [ proto::detail::make<r1>() ]
+ , result_type
+ )
                 result_type operator ()(
- typename default_function_impl::expr_param e
- , typename default_function_impl::state_param s
- , typename default_function_impl::data_param d
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
                 ) const
                 {
- return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)();
+ typename Grammar::template impl<e0, State, Data> t0;
+ typename Grammar::template impl<e1, State, Data> t1;
+ return t0(proto::child_c<0>(e), s, d) [
+ t1(proto::child_c<1>(e), s, d) ];
                 }
             };
+ };

- template<typename Grammar, typename Expr, typename State, typename Data>
- struct default_function_impl<Grammar, Expr, State, Data, 2>
+ template<typename Grammar>
+ struct default_case<Grammar, tag::subscript>
+ : when<subscript<Grammar, Grammar>, default_subscript<Grammar> >
+ {};
+
+ template<typename Grammar>
+ struct default_if_else_
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
               : transform_impl<Expr, State, Data>
             {
- BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
- BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 1, Expr)
-
- typedef
- typename proto::detail::result_of_fixup<r0>::type
- function_type;
-
- typedef
- typename detail::result_of_<function_type(r1)>::type
- result_type;
-
- result_type operator ()(
- typename default_function_impl::expr_param e
- , typename default_function_impl::state_param s
- , typename default_function_impl::data_param d
- ) const
- {
- return this->invoke(
- e
- , s
- , d
- , is_member_function_pointer<function_type>()
- , is_member_object_pointer<function_type>()
- );
- }
-
             private:
- result_type invoke(
- typename default_function_impl::expr_param e
- , typename default_function_impl::state_param s
- , typename default_function_impl::data_param d
- , mpl::false_
- , mpl::false_
+ typedef typename result_of::child_c<Expr, 0>::type e0;
+ typedef typename result_of::child_c<Expr, 1>::type e1;
+ typedef typename result_of::child_c<Expr, 2>::type e2;
+ typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
+ typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
+ typedef typename Grammar::template impl<e2, State, Data>::result_type r2;
+ public:
+ BOOST_PROTO_DECLTYPE_(
+ proto::detail::make<r0>()
+ ? proto::detail::make<r1>()
+ : proto::detail::make<r2>()
+ , result_type
+ )
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
                 ) const
                 {
- return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)(BOOST_PROTO_DEFAULT_EVAL(~, 1, e));
+ typename Grammar::template impl<e0, State, Data> t0;
+ typename Grammar::template impl<e1, State, Data> t1;
+ typename Grammar::template impl<e2, State, Data> t2;
+ return t0(proto::child_c<0>(e), s, d)
+ ? t1(proto::child_c<1>(e), s, d)
+ : t2(proto::child_c<2>(e), s, d);
                 }
+ };
+ };

- result_type invoke(
- typename default_function_impl::expr_param e
- , typename default_function_impl::state_param s
- , typename default_function_impl::data_param d
- , mpl::true_
- , mpl::false_
- ) const
- {
- BOOST_PROTO_USE_GET_POINTER();
- typedef typename detail::classtypeof<function_type>::type class_type;
- return (
- BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, e)) ->*
- BOOST_PROTO_DEFAULT_EVAL(~, 0, e)
- )();
- }
+ template<typename Grammar>
+ struct default_case<Grammar, tag::if_else_>
+ : when<if_else_<Grammar, Grammar, Grammar>, default_if_else_<Grammar> >
+ {};

- result_type invoke(
- typename default_function_impl::expr_param e
- , typename default_function_impl::state_param s
- , typename default_function_impl::data_param d
- , mpl::false_
- , mpl::true_
+ template<typename Grammar>
+ struct default_comma
+ : transform<default_comma<Grammar> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : transform_impl<Expr, State, Data>
+ {
+ private:
+ typedef typename result_of::child_c<Expr, 0>::type e0;
+ typedef typename result_of::child_c<Expr, 1>::type e1;
+ typedef typename Grammar::template impl<e0, State, Data>::result_type r0;
+ typedef typename Grammar::template impl<e1, State, Data>::result_type r1;
+ public:
+ typedef typename proto::detail::comma_result<r0, r1>::type result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
                 ) const
                 {
- BOOST_PROTO_USE_GET_POINTER();
- typedef typename detail::classtypeof<function_type>::type class_type;
- return (
- BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, e)) ->*
- BOOST_PROTO_DEFAULT_EVAL(~, 0, e)
- );
+ typename Grammar::template impl<e0, State, Data> t0;
+ typename Grammar::template impl<e1, State, Data> t1;
+ return t0(proto::child_c<0>(e), s, d)
+ , t1(proto::child_c<1>(e), s, d);
                 }
             };
+ };

- #define BOOST_PP_ITERATION_PARAMS_1 (3, (3, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/default.hpp>))
- #include BOOST_PP_ITERATE()
+ template<typename Grammar>
+ struct default_case<Grammar, tag::comma>
+ : when<comma<Grammar, Grammar>, default_comma<Grammar> >
+ {};

- #undef BOOST_PROTO_DEFAULT_EVAL_TYPE
- #undef BOOST_PROTO_DEFAULT_EVAL
- }
+ template<typename Grammar, typename Expr, typename State, typename Data, long Arity>
+ struct default_function_impl;

- template<typename Grammar /*= detail::_default*/>
- struct _default
- : switch_<detail::default_cases<Grammar> >
- {};
+ template<typename Grammar>
+ struct default_function
+ : transform<default_function<Grammar> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : default_function_impl<
+ Grammar
+ , Expr
+ , State
+ , Data
+ , transform_impl<Expr, State, Data>::expr::proto_arity_c
+ >
+ {};
+ };

         template<typename Grammar>
- struct is_callable<_default<Grammar> >
- : mpl::true_
+ struct default_case<Grammar, tag::function>
+ : when<function<Grammar, vararg<Grammar> >, default_function<Grammar> >
         {};

- namespace detail
- {
- // Loopy indirection that allows proto::_default<> to be
- // used without specifying a Grammar argument.
- struct _default
- : proto::_default<>
- {};
- }
+ #define BOOST_PROTO_DEFAULT_EVAL_TYPE(Z, N, DATA) \
+ typedef \
+ typename result_of::child_c<DATA, N>::type \
+ BOOST_PP_CAT(e, N); \
+ \
+ typedef \
+ typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>::result_type \
+ BOOST_PP_CAT(r, N); \
+ /**/

- }}
+ #define BOOST_PROTO_DEFAULT_EVAL(Z, N, DATA) \
+ typename Grammar::template impl<BOOST_PP_CAT(e, N), State, Data>()( \
+ proto::child_c<N>(DATA), s, d \
+ ) \
+ /**/
+
+ template<typename Grammar, typename Expr, typename State, typename Data>
+ struct default_function_impl<Grammar, Expr, State, Data, 1>
+ : transform_impl<Expr, State, Data>
+ {
+ BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)

- #endif
+ typedef
+ typename proto::detail::result_of_fixup<r0>::type
+ function_type;

-#else
+ typedef
+ typename BOOST_PROTO_RESULT_OF<function_type()>::type
+ result_type;

- #define N BOOST_PP_ITERATION()
+ result_type operator ()(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ ) const
+ {
+ return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)();
+ }
+ };

         template<typename Grammar, typename Expr, typename State, typename Data>
- struct default_function_impl<Grammar, Expr, State, Data, N>
+ struct default_function_impl<Grammar, Expr, State, Data, 2>
           : transform_impl<Expr, State, Data>
         {
- BOOST_PP_REPEAT(N, BOOST_PROTO_DEFAULT_EVAL_TYPE, Expr)
+ BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 0, Expr)
+ BOOST_PROTO_DEFAULT_EVAL_TYPE(~, 1, Expr)

             typedef
                 typename proto::detail::result_of_fixup<r0>::type
             function_type;

             typedef
- typename BOOST_PROTO_RESULT_OF<
- function_type(BOOST_PP_ENUM_SHIFTED_PARAMS(N, r))
- >::type
+ typename detail::result_of_<function_type(r1)>::type
             result_type;

             result_type operator ()(
@@ -624,7 +513,13 @@
               , typename default_function_impl::data_param d
             ) const
             {
- return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+ return this->invoke(
+ e
+ , s
+ , d
+ , is_member_function_pointer<function_type>()
+ , is_member_object_pointer<function_type>()
+ );
             }

         private:
@@ -633,11 +528,10 @@
               , typename default_function_impl::state_param s
               , typename default_function_impl::data_param d
               , mpl::false_
+ , mpl::false_
             ) const
             {
- return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)(
- BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL, e)
- );
+ return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)(BOOST_PROTO_DEFAULT_EVAL(~, 1, e));
             }

             result_type invoke(
@@ -645,19 +539,60 @@
               , typename default_function_impl::state_param s
               , typename default_function_impl::data_param d
               , mpl::true_
+ , mpl::false_
             ) const
             {
- #define M0(Z, M, DATA) BOOST_PROTO_DEFAULT_EVAL(Z, BOOST_PP_ADD(M, 2), DATA)
                 BOOST_PROTO_USE_GET_POINTER();
                 typedef typename detail::classtypeof<function_type>::type class_type;
                 return (
                     BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, e)) ->*
                     BOOST_PROTO_DEFAULT_EVAL(~, 0, e)
- )(BOOST_PP_ENUM(BOOST_PP_SUB(N, 2), M0, e));
- #undef M0
+ )();
+ }
+
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::false_
+ , mpl::true_
+ ) const
+ {
+ BOOST_PROTO_USE_GET_POINTER();
+ typedef typename detail::classtypeof<function_type>::type class_type;
+ return (
+ BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, e)) ->*
+ BOOST_PROTO_DEFAULT_EVAL(~, 0, e)
+ );
             }
         };

- #undef N
+ #include <boost/proto/transform/detail/default_function_impl.hpp>
+
+ #undef BOOST_PROTO_DEFAULT_EVAL_TYPE
+ #undef BOOST_PROTO_DEFAULT_EVAL
+ }
+
+ template<typename Grammar /*= detail::_default*/>
+ struct _default
+ : switch_<detail::default_cases<Grammar> >
+ {};
+
+ template<typename Grammar>
+ struct is_callable<_default<Grammar> >
+ : mpl::true_
+ {};
+
+ namespace detail
+ {
+ // Loopy indirection that allows proto::_default<> to be
+ // used without specifying a Grammar argument.
+ struct _default
+ : proto::_default<>
+ {};
+ }
+
+}}

#endif
+

Added: trunk/boost/proto/transform/detail/construct_funop.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/construct_funop.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -0,0 +1,43 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+ #include <boost/proto/transform/detail/preprocessed/construct_funop.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(preserve: 2, line: 0, output: "preprocessed/construct_funop.hpp")
+ #endif
+
+ ///////////////////////////////////////////////////////////////////////////////
+ /// \file construct_funop.hpp
+ /// Overloads of construct_\<\>::operator().
+ //
+ // Copyright 2008 Eric Niebler. 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_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(preserve: 1)
+ #endif
+
+ #define BOOST_PP_ITERATION_PARAMS_1 \
+ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/construct_funop.hpp>))
+ #include BOOST_PP_ITERATE()
+
+ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(output: null)
+ #endif
+
+#else
+
+ #define N BOOST_PP_ITERATION()
+
+ template<BOOST_PP_ENUM_PARAMS(N, typename A)>
+ Type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, &a)) const
+ {
+ return Type(BOOST_PP_ENUM_PARAMS(N, a));
+ }
+
+ #undef N
+
+#endif

Added: trunk/boost/proto/transform/detail/construct_pod_funop.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/construct_pod_funop.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -0,0 +1,44 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+ #include <boost/proto/transform/detail/preprocessed/construct_pod_funop.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(preserve: 2, line: 0, output: "preprocessed/construct_pod_funop.hpp")
+ #endif
+
+ ///////////////////////////////////////////////////////////////////////////////
+ /// \file construct_pod_funop.hpp
+ /// Overloads of construct_\<\>::operator().
+ //
+ // Copyright 2008 Eric Niebler. 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_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(preserve: 1)
+ #endif
+
+ #define BOOST_PP_ITERATION_PARAMS_1 \
+ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/construct_pod_funop.hpp>))
+ #include BOOST_PP_ITERATE()
+
+ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(output: null)
+ #endif
+
+#else
+
+ #define N BOOST_PP_ITERATION()
+
+ template<BOOST_PP_ENUM_PARAMS(N, typename A)>
+ Type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(N, A, &a)) const
+ {
+ Type that = {BOOST_PP_ENUM_PARAMS(N, a)};
+ return that;
+ }
+
+ #undef N
+
+#endif

Added: trunk/boost/proto/transform/detail/default_function_impl.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/default_function_impl.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -0,0 +1,97 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+ #include <boost/proto/transform/detail/preprocessed/default_function_impl.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+ #define BOOST_PROTO_DEF_FUN_INVOKE_ARG(Z, M, DATA) \
+ BOOST_PROTO_DEFAULT_EVAL(Z, BOOST_PP_ADD(M, 2), DATA)
+
+ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(preserve: 2, line: 0, output: "preprocessed/default_function_impl.hpp")
+ #endif
+
+ ///////////////////////////////////////////////////////////////////////////////
+ /// \file default_function_impl.hpp
+ /// Contains definition of the default_function_impl, the implementation of the
+ /// _default transform for function-like nodes.
+ //
+ // Copyright 2008 Eric Niebler. 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_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(preserve: 1)
+ #endif
+
+ #define BOOST_PP_ITERATION_PARAMS_1 \
+ (3, (3, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/default_function_impl.hpp>))
+ #include BOOST_PP_ITERATE()
+
+ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(output: null)
+ #endif
+
+ #undef BOOST_PROTO_DEF_FUN_INVOKE_ARG
+
+#else
+
+ #define N BOOST_PP_ITERATION()
+
+ template<typename Grammar, typename Expr, typename State, typename Data>
+ struct default_function_impl<Grammar, Expr, State, Data, N>
+ : transform_impl<Expr, State, Data>
+ {
+ BOOST_PP_REPEAT(N, BOOST_PROTO_DEFAULT_EVAL_TYPE, Expr)
+
+ typedef
+ typename proto::detail::result_of_fixup<r0>::type
+ function_type;
+
+ typedef
+ typename BOOST_PROTO_RESULT_OF<
+ function_type(BOOST_PP_ENUM_SHIFTED_PARAMS(N, r))
+ >::type
+ result_type;
+
+ result_type operator ()(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ ) const
+ {
+ return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+ }
+
+ private:
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::false_
+ ) const
+ {
+ return BOOST_PROTO_DEFAULT_EVAL(~, 0, e)(
+ BOOST_PP_ENUM_SHIFTED(N, BOOST_PROTO_DEFAULT_EVAL, e)
+ );
+ }
+
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::true_
+ ) const
+ {
+ BOOST_PROTO_USE_GET_POINTER();
+ typedef typename detail::classtypeof<function_type>::type class_type;
+ return (
+ BOOST_PROTO_GET_POINTER(class_type, BOOST_PROTO_DEFAULT_EVAL(~, 1, e)) ->*
+ BOOST_PROTO_DEFAULT_EVAL(~, 0, e)
+ )(BOOST_PP_ENUM(BOOST_PP_SUB(N, 2), BOOST_PROTO_DEF_FUN_INVOKE_ARG, e));
+ }
+ };
+
+ #undef N
+
+#endif

Added: trunk/boost/proto/transform/detail/fold_impl.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/fold_impl.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -0,0 +1,143 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+ #include <boost/proto/transform/detail/preprocessed/fold_impl.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+ #define BOOST_PROTO_CHILD_N_TYPE(N) \
+ BOOST_PP_CAT(proto_child, N) \
+ /**/
+
+ #define BOOST_PROTO_FOLD_STATE_TYPE(Z, N, DATA) \
+ typedef \
+ typename when<_, Fun>::template impl< \
+ typename result_of::child_c<Expr, N>::type \
+ , BOOST_PP_CAT(state, N) \
+ , Data \
+ >::result_type \
+ BOOST_PP_CAT(state, BOOST_PP_INC(N)); \
+ /**/
+
+ #define BOOST_PROTO_FOLD_STATE(Z, N, DATA) \
+ BOOST_PP_CAT(state, BOOST_PP_INC(N)) \
+ BOOST_PP_CAT(s, BOOST_PP_INC(N)) \
+ = typename when<_, Fun>::template impl< \
+ typename result_of::child_c<Expr, N>::type \
+ , BOOST_PP_CAT(state, N) \
+ , Data \
+ >()( \
+ proto::child_c<N>(e) \
+ , BOOST_PP_CAT(s, N) \
+ , d \
+ ); \
+ /**/
+
+ #define BOOST_PROTO_REVERSE_FOLD_STATE_TYPE(Z, N, DATA) \
+ typedef \
+ typename when<_, Fun>::template impl< \
+ typename result_of::child_c< \
+ Expr \
+ , BOOST_PP_SUB(DATA, BOOST_PP_INC(N)) \
+ >::type \
+ , BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, N)) \
+ , Data \
+ >::result_type \
+ BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))); \
+ /**/
+
+ #define BOOST_PROTO_REVERSE_FOLD_STATE(Z, N, DATA) \
+ BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))) \
+ BOOST_PP_CAT(s, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))) \
+ = typename when<_, Fun>::template impl< \
+ typename result_of::child_c< \
+ Expr \
+ , BOOST_PP_SUB(DATA, BOOST_PP_INC(N)) \
+ >::type \
+ , BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, N)) \
+ , Data \
+ >()( \
+ proto::child_c<BOOST_PP_SUB(DATA, BOOST_PP_INC(N))>(e) \
+ , BOOST_PP_CAT(s, BOOST_PP_SUB(DATA, N)) \
+ , d \
+ ); \
+ /**/
+
+ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(preserve: 2, line: 0, output: "preprocessed/fold_impl.hpp")
+ #endif
+
+ ///////////////////////////////////////////////////////////////////////////////
+ /// \file fold_impl.hpp
+ /// Contains definition of fold_impl<> and reverse_fold_impl<> templates.
+ //
+ // Copyright 2008 Eric Niebler. 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_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(preserve: 1)
+ #endif
+
+ #define BOOST_PP_ITERATION_PARAMS_1 \
+ (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/fold_impl.hpp>))
+ #include BOOST_PP_ITERATE()
+
+ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(output: null)
+ #endif
+
+ #undef BOOST_PROTO_REVERSE_FOLD_STATE
+ #undef BOOST_PROTO_REVERSE_FOLD_STATE_TYPE
+ #undef BOOST_PROTO_FOLD_STATE
+ #undef BOOST_PROTO_FOLD_STATE_TYPE
+ #undef BOOST_PROTO_CHILD_N_TYPE
+
+#else
+
+ #define N BOOST_PP_ITERATION()
+
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct fold_impl<State0, Fun, Expr, State, Data, N>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+ BOOST_PP_REPEAT(N, BOOST_PROTO_FOLD_STATE_TYPE, N)
+ typedef BOOST_PP_CAT(state, N) result_type;
+
+ result_type operator ()(
+ typename fold_impl::expr_param e
+ , typename fold_impl::state_param s
+ , typename fold_impl::data_param d
+ ) const
+ {
+ state0 s0 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ BOOST_PP_REPEAT(N, BOOST_PROTO_FOLD_STATE, N)
+ return BOOST_PP_CAT(s, N);
+ }
+ };
+
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct reverse_fold_impl<State0, Fun, Expr, State, Data, N>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type BOOST_PP_CAT(state, N);
+ BOOST_PP_REPEAT(N, BOOST_PROTO_REVERSE_FOLD_STATE_TYPE, N)
+ typedef state0 result_type;
+
+ result_type operator ()(
+ typename reverse_fold_impl::expr_param e
+ , typename reverse_fold_impl::state_param s
+ , typename reverse_fold_impl::data_param d
+ ) const
+ {
+ BOOST_PP_CAT(state, N) BOOST_PP_CAT(s, N) =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ BOOST_PP_REPEAT(N, BOOST_PROTO_REVERSE_FOLD_STATE, N)
+ return s0;
+ }
+ };
+
+ #undef N
+
+#endif

Added: trunk/boost/proto/transform/detail/lazy.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/lazy.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -0,0 +1,58 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+ #include <boost/proto/transform/detail/preprocessed/lazy.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(preserve: 2, line: 0, output: "preprocessed/lazy.hpp")
+ #endif
+
+ ///////////////////////////////////////////////////////////////////////////////
+ /// \file lazy.hpp
+ /// Contains definition of the lazy<> transform.
+ //
+ // Copyright 2008 Eric Niebler. 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_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(preserve: 1)
+ #endif
+
+ #define BOOST_PP_ITERATION_PARAMS_1 \
+ (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/lazy.hpp>))
+ #include BOOST_PP_ITERATE()
+
+ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(output: null)
+ #endif
+
+#else
+
+ #define N BOOST_PP_ITERATION()
+
+ /// \brief A PrimitiveTransform that uses <tt>make\<\></tt> to build
+ /// a CallableTransform, and then uses <tt>call\<\></tt> to apply it.
+ ///
+ /// <tt>lazy\<\></tt> is useful as a higher-order transform, when the
+ /// transform to be applied depends on the current state of the
+ /// transformation. The invocation of the <tt>make\<\></tt> transform
+ /// evaluates any nested transforms, and the resulting type is treated
+ /// as a CallableTransform, which is evaluated with <tt>call\<\></tt>.
+ template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+ struct lazy<Object(BOOST_PP_ENUM_PARAMS(N, A))>
+ : transform<lazy<Object(BOOST_PP_ENUM_PARAMS(N, A))> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : call<
+ typename make<Object>::template impl<Expr, State, Data>::result_type
+ (BOOST_PP_ENUM_PARAMS(N, A))
+ >::template impl<Expr, State, Data>
+ {};
+ };
+
+ #undef N
+
+#endif

Added: trunk/boost/proto/transform/detail/make.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/make.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -0,0 +1,174 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+ #include <boost/proto/transform/detail/preprocessed/make.hpp>
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+ #define BOOST_PROTO_MAKE_IF(Z, M, DATA) \
+ make_if_<BOOST_PP_CAT(A, M), Expr, State, Data> \
+ /**/
+
+ #define BOOST_PROTO_MAKE_IF_TYPE(Z, M, DATA) \
+ typename BOOST_PROTO_MAKE_IF(Z, M, DATA) ::type \
+ /**/
+
+ #define BOOST_PROTO_MAKE_IF_APPLIED(Z, M, DATA) \
+ BOOST_PROTO_MAKE_IF(Z, M, DATA) ::applied || \
+ /**/
+
+ #define BOOST_PROTO_CONSTRUCT_ARG(Z, M, DATA) \
+ detail::as_lvalue( \
+ typename when<_, BOOST_PP_CAT(A, M)>::template impl<Expr, State, Data>()(e, s, d) \
+ ) \
+ /**/
+
+ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(preserve: 2, line: 0, output: "preprocessed/make.hpp")
+ #endif
+
+ ///////////////////////////////////////////////////////////////////////////////
+ /// \file make.hpp
+ /// Contains definition of the make<> transform.
+ //
+ // Copyright 2008 Eric Niebler. 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_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(preserve: 1)
+ #endif
+
+ #define BOOST_PP_ITERATION_PARAMS_1 \
+ (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/make.hpp>))
+ #include BOOST_PP_ITERATE()
+
+ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(output: null)
+ #endif
+
+ #undef BOOST_PROTO_CONSTRUCT_ARG
+ #undef BOOST_PROTO_MAKE_IF_APPLIED
+ #undef BOOST_PROTO_MAKE_IF_TYPE
+ #undef BOOST_PROTO_MAKE_IF
+
+#else
+
+ #define N BOOST_PP_ITERATION()
+
+ namespace detail
+ {
+ #if N > 0
+
+ template<
+ template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class R
+ BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ R<BOOST_PP_ENUM_PARAMS(N, A)>
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(N)
+ >
+ : nested_type_if<
+ R<BOOST_PP_ENUM(N, BOOST_PROTO_MAKE_IF_TYPE, ~)>
+ , (BOOST_PP_REPEAT(N, BOOST_PROTO_MAKE_IF_APPLIED, ~) false)
+ >
+ {};
+
+ template<
+ template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class R
+ BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ noinvoke<R<BOOST_PP_ENUM_PARAMS(N, A)> >
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
+ >
+ {
+ typedef R<BOOST_PP_ENUM(N, BOOST_PROTO_MAKE_IF_TYPE, ~)> type;
+ static bool const applied = true;
+ };
+
+ #endif
+
+ template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+ struct is_applyable<R(BOOST_PP_ENUM_PARAMS(N, A))>
+ : mpl::true_
+ {};
+
+ template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+ struct is_applyable<R(*)(BOOST_PP_ENUM_PARAMS(N, A))>
+ : mpl::true_
+ {};
+
+ template<typename T, typename A>
+ struct construct_<proto::expr<T, A, N>, true>
+ {
+ typedef proto::expr<T, A, N> result_type;
+
+ template<BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), typename A)>
+ result_type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_MAX(N, 1), A, &a)) const
+ {
+ return result_type::make(BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), a));
+ }
+ };
+
+ template<typename T, typename A>
+ struct construct_<proto::basic_expr<T, A, N>, true>
+ {
+ typedef proto::basic_expr<T, A, N> result_type;
+
+ template<BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), typename A)>
+ result_type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_MAX(N, 1), A, &a)) const
+ {
+ return result_type::make(BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), a));
+ }
+ };
+
+ template<typename Type BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+ Type construct(BOOST_PP_ENUM_BINARY_PARAMS(N, A, &a))
+ {
+ return construct_<Type>()(BOOST_PP_ENUM_PARAMS(N, a));
+ }
+
+ } // namespace detail
+
+ /// \brief A PrimitiveTransform which computes a type by evaluating any
+ /// nested transforms and then constructs an object of that type with the
+ /// current expression, state and data, transformed according
+ /// to \c A0 through \c AN.
+ template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+ struct make<Object(BOOST_PP_ENUM_PARAMS(N, A))>
+ : transform<make<Object(BOOST_PP_ENUM_PARAMS(N, A))> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ /// \brief <tt>boost::result_of\<make\<Object\>(Expr, State, Data)\>::type</tt>
+ typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+
+ /// Let \c ax be <tt>when\<_, Ax\>()(e, s, d)</tt>
+ /// for each \c x in <tt>[0,N]</tt>.
+ /// Return <tt>result_type(a0, a1,... aN)</tt>.
+ ///
+ /// \param e The current expression
+ /// \param s The current state
+ /// \param d An arbitrary data
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ proto::detail::ignore_unused(e);
+ proto::detail::ignore_unused(s);
+ proto::detail::ignore_unused(d);
+ return detail::construct<result_type>(BOOST_PP_ENUM(N, BOOST_PROTO_CONSTRUCT_ARG, DATA));
+ }
+ };
+ };
+
+ #undef N
+
+#endif

Added: trunk/boost/proto/transform/detail/make_gcc_workaround.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/make_gcc_workaround.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -0,0 +1,98 @@
+#if !defined(BOOST_PROTO_DONT_USE_PREPROCESSED_FILES)
+
+ #if BOOST_WORKAROUND(__GNUC__, == 3) || (__GNUC__ == 4 && __GNUC_MINOR__ == 0)
+ #include <boost/proto/transform/detail/preprocessed/make_gcc_workaround.hpp>
+ #endif
+
+#elif !defined(BOOST_PP_IS_ITERATING)
+
+ #define BOOST_PROTO_EXPR_MAKE_ARG(Z, M, DATA) \
+ detail::as_lvalue( \
+ typename when<_, BOOST_PP_CAT(A, M)>::template impl<Expr, State, Data>()(e, s, d) \
+ ) \
+ /**/
+
+ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(preserve: 2, line: 0, output: "preprocessed/make_gcc_workaround.hpp")
+ #endif
+
+ ///////////////////////////////////////////////////////////////////////////////
+ /// \file make_gcc_workaround.hpp
+ /// Special workaround code to make the make\<\> transform work on certain
+ /// versions of gcc.
+ //
+ // Copyright 2008 Eric Niebler. 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_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(preserve: 1)
+ #endif
+
+ #if BOOST_WORKAROUND(__GNUC__, == 3) || (__GNUC__ == 4 && __GNUC_MINOR__ == 0) || \
+ (defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES))
+
+ #define BOOST_PP_ITERATION_PARAMS_1 \
+ (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/detail/make_gcc_workaround.hpp>))
+ #include BOOST_PP_ITERATE()
+
+ #endif
+
+ #if defined(__WAVE__) && defined(BOOST_PROTO_CREATE_PREPROCESSED_FILES)
+ #pragma wave option(output: null)
+ #endif
+
+ #undef BOOST_PROTO_EXPR_MAKE_ARG
+
+#else
+
+ #define N BOOST_PP_ITERATION()
+
+ // work around GCC bug
+ template<typename Tag, typename Args, long Arity BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+ struct make<proto::expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))>
+ : transform<make<proto::expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::expr<Tag, Args, Arity> result_type;
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::expr<Tag, Args, Arity>::make(
+ BOOST_PP_ENUM(N, BOOST_PROTO_EXPR_MAKE_ARG, DATA)
+ );
+ }
+ };
+ };
+
+ template<typename Tag, typename Args, long Arity BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
+ struct make<proto::basic_expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))>
+ : transform<make<proto::basic_expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::basic_expr<Tag, Args, Arity> result_type;
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::basic_expr<Tag, Args, Arity>::make(
+ BOOST_PP_ENUM(N, BOOST_PROTO_EXPR_MAKE_ARG, DATA)
+ );
+ }
+ };
+ };
+
+ #undef N
+
+#endif

Modified: trunk/boost/proto/transform/detail/preprocessed/call.hpp
==============================================================================
--- trunk/boost/proto/transform/detail/preprocessed/call.hpp (original)
+++ trunk/boost/proto/transform/detail/preprocessed/call.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -65,3 +65,153 @@
             }
         };
     };
+
+
+
+ template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5;
+ typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5)> function_traits;
+ typedef typename function_traits::result_type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ typedef typename function_traits::function_type function_type;
+ return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)));
+ }
+ };
+ };
+
+
+
+ template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6;
+ typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6)> function_traits;
+ typedef typename function_traits::result_type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ typedef typename function_traits::function_type function_type;
+ return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)));
+ }
+ };
+ };
+
+
+
+ template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7;
+ typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7)> function_traits;
+ typedef typename function_traits::result_type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ typedef typename function_traits::function_type function_type;
+ return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)));
+ }
+ };
+ };
+
+
+
+ template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; typedef typename when<_, A8>::template impl<Expr, State, Data> a8; typedef typename a8::result_type b8;
+ typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7 , b8)> function_traits;
+ typedef typename function_traits::result_type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ typedef typename function_traits::function_type function_type;
+ return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)) , detail::as_lvalue(a8()(e, s, d)));
+ }
+ };
+ };
+
+
+
+ template<typename Fun , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ struct call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> : transform<call<Fun(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, A0>::template impl<Expr, State, Data> a0; typedef typename a0::result_type b0; typedef typename when<_, A1>::template impl<Expr, State, Data> a1; typedef typename a1::result_type b1; typedef typename when<_, A2>::template impl<Expr, State, Data> a2; typedef typename a2::result_type b2; typedef typename when<_, A3>::template impl<Expr, State, Data> a3; typedef typename a3::result_type b3; typedef typename when<_, A4>::template impl<Expr, State, Data> a4; typedef typename a4::result_type b4; typedef typename when<_, A5>::template impl<Expr, State, Data> a5; typedef typename a5::result_type b5; typedef typename when<_, A6>::template impl<Expr, State, Data> a6; typedef typename a6::result_type b6; typedef typename when<_, A7>::template impl<Expr, State, Data> a7; typedef typename a7::result_type b7; typedef typename when<_, A8>::template impl<Expr, State, Data> a8; typedef typename a8::result_type b8; typedef typename when<_, A9>::template impl<Expr, State, Data> a9; typedef
typename a9::result_type b9;
+ typedef detail::poly_function_traits<Fun, Fun(b0 , b1 , b2 , b3 , b4 , b5 , b6 , b7 , b8 , b9)> function_traits;
+ typedef typename function_traits::result_type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ typedef typename function_traits::function_type function_type;
+ return function_type()(detail::as_lvalue(a0()(e, s, d)) , detail::as_lvalue(a1()(e, s, d)) , detail::as_lvalue(a2()(e, s, d)) , detail::as_lvalue(a3()(e, s, d)) , detail::as_lvalue(a4()(e, s, d)) , detail::as_lvalue(a5()(e, s, d)) , detail::as_lvalue(a6()(e, s, d)) , detail::as_lvalue(a7()(e, s, d)) , detail::as_lvalue(a8()(e, s, d)) , detail::as_lvalue(a9()(e, s, d)));
+ }
+ };
+ };

Added: trunk/boost/proto/transform/detail/preprocessed/construct_funop.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/preprocessed/construct_funop.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -0,0 +1,57 @@
+ ///////////////////////////////////////////////////////////////////////////////
+ /// \file construct_funop.hpp
+ /// Overloads of construct_\<\>::operator().
+ //
+ // Copyright 2008 Eric Niebler. 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)
+ template<typename A0>
+ Type operator ()(A0 &a0) const
+ {
+ return Type(a0);
+ }
+ template<typename A0 , typename A1>
+ Type operator ()(A0 &a0 , A1 &a1) const
+ {
+ return Type(a0 , a1);
+ }
+ template<typename A0 , typename A1 , typename A2>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const
+ {
+ return Type(a0 , a1 , a2);
+ }
+ template<typename A0 , typename A1 , typename A2 , typename A3>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const
+ {
+ return Type(a0 , a1 , a2 , a3);
+ }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const
+ {
+ return Type(a0 , a1 , a2 , a3 , a4);
+ }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const
+ {
+ return Type(a0 , a1 , a2 , a3 , a4 , a5);
+ }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const
+ {
+ return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const
+ {
+ return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const
+ {
+ return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const
+ {
+ return Type(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+ }

Added: trunk/boost/proto/transform/detail/preprocessed/construct_pod_funop.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/preprocessed/construct_pod_funop.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -0,0 +1,67 @@
+ ///////////////////////////////////////////////////////////////////////////////
+ /// \file construct_pod_funop.hpp
+ /// Overloads of construct_\<\>::operator().
+ //
+ // Copyright 2008 Eric Niebler. 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)
+ template<typename A0>
+ Type operator ()(A0 &a0) const
+ {
+ Type that = {a0};
+ return that;
+ }
+ template<typename A0 , typename A1>
+ Type operator ()(A0 &a0 , A1 &a1) const
+ {
+ Type that = {a0 , a1};
+ return that;
+ }
+ template<typename A0 , typename A1 , typename A2>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const
+ {
+ Type that = {a0 , a1 , a2};
+ return that;
+ }
+ template<typename A0 , typename A1 , typename A2 , typename A3>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const
+ {
+ Type that = {a0 , a1 , a2 , a3};
+ return that;
+ }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const
+ {
+ Type that = {a0 , a1 , a2 , a3 , a4};
+ return that;
+ }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const
+ {
+ Type that = {a0 , a1 , a2 , a3 , a4 , a5};
+ return that;
+ }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const
+ {
+ Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6};
+ return that;
+ }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const
+ {
+ Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7};
+ return that;
+ }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const
+ {
+ Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8};
+ return that;
+ }
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ Type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const
+ {
+ Type that = {a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9};
+ return that;
+ }

Added: trunk/boost/proto/transform/detail/preprocessed/default_function_impl.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/preprocessed/default_function_impl.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -0,0 +1,392 @@
+ ///////////////////////////////////////////////////////////////////////////////
+ /// \file default_function_impl.hpp
+ /// Contains definition of the default_function_impl, the implementation of the
+ /// _default transform for function-like nodes.
+ //
+ // Copyright 2008 Eric Niebler. 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)
+ template<typename Grammar, typename Expr, typename State, typename Data>
+ struct default_function_impl<Grammar, Expr, State, Data, 3>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2;
+ typedef
+ typename proto::detail::result_of_fixup<r0>::type
+ function_type;
+ typedef
+ typename boost::tr1_result_of<
+ function_type(r1 , r2)
+ >::type
+ result_type;
+ result_type operator ()(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ ) const
+ {
+ return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+ }
+ private:
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::false_
+ ) const
+ {
+ return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+ typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d )
+ );
+ }
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::true_
+ ) const
+ {
+ using namespace boost::proto::detail::get_pointerns;
+ typedef typename detail::classtypeof<function_type>::type class_type;
+ return (
+ boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )) , (true ? 0 : get_pointer( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )))) ) ->*
+ typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+ )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ));
+ }
+ };
+ template<typename Grammar, typename Expr, typename State, typename Data>
+ struct default_function_impl<Grammar, Expr, State, Data, 4>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3;
+ typedef
+ typename proto::detail::result_of_fixup<r0>::type
+ function_type;
+ typedef
+ typename boost::tr1_result_of<
+ function_type(r1 , r2 , r3)
+ >::type
+ result_type;
+ result_type operator ()(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ ) const
+ {
+ return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+ }
+ private:
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::false_
+ ) const
+ {
+ return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+ typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d )
+ );
+ }
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::true_
+ ) const
+ {
+ using namespace boost::proto::detail::get_pointerns;
+ typedef typename detail::classtypeof<function_type>::type class_type;
+ return (
+ boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )) , (true ? 0 : get_pointer( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )))) ) ->*
+ typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+ )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ));
+ }
+ };
+ template<typename Grammar, typename Expr, typename State, typename Data>
+ struct default_function_impl<Grammar, Expr, State, Data, 5>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4;
+ typedef
+ typename proto::detail::result_of_fixup<r0>::type
+ function_type;
+ typedef
+ typename boost::tr1_result_of<
+ function_type(r1 , r2 , r3 , r4)
+ >::type
+ result_type;
+ result_type operator ()(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ ) const
+ {
+ return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+ }
+ private:
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::false_
+ ) const
+ {
+ return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+ typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d )
+ );
+ }
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::true_
+ ) const
+ {
+ using namespace boost::proto::detail::get_pointerns;
+ typedef typename detail::classtypeof<function_type>::type class_type;
+ return (
+ boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )) , (true ? 0 : get_pointer( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )))) ) ->*
+ typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+ )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ));
+ }
+ };
+ template<typename Grammar, typename Expr, typename State, typename Data>
+ struct default_function_impl<Grammar, Expr, State, Data, 6>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5;
+ typedef
+ typename proto::detail::result_of_fixup<r0>::type
+ function_type;
+ typedef
+ typename boost::tr1_result_of<
+ function_type(r1 , r2 , r3 , r4 , r5)
+ >::type
+ result_type;
+ result_type operator ()(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ ) const
+ {
+ return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+ }
+ private:
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::false_
+ ) const
+ {
+ return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+ typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d )
+ );
+ }
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::true_
+ ) const
+ {
+ using namespace boost::proto::detail::get_pointerns;
+ typedef typename detail::classtypeof<function_type>::type class_type;
+ return (
+ boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )) , (true ? 0 : get_pointer( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )))) ) ->*
+ typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+ )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ));
+ }
+ };
+ template<typename Grammar, typename Expr, typename State, typename Data>
+ struct default_function_impl<Grammar, Expr, State, Data, 7>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6;
+ typedef
+ typename proto::detail::result_of_fixup<r0>::type
+ function_type;
+ typedef
+ typename boost::tr1_result_of<
+ function_type(r1 , r2 , r3 , r4 , r5 , r6)
+ >::type
+ result_type;
+ result_type operator ()(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ ) const
+ {
+ return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+ }
+ private:
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::false_
+ ) const
+ {
+ return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+ typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d )
+ );
+ }
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::true_
+ ) const
+ {
+ using namespace boost::proto::detail::get_pointerns;
+ typedef typename detail::classtypeof<function_type>::type class_type;
+ return (
+ boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )) , (true ? 0 : get_pointer( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )))) ) ->*
+ typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+ )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ));
+ }
+ };
+ template<typename Grammar, typename Expr, typename State, typename Data>
+ struct default_function_impl<Grammar, Expr, State, Data, 8>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, Stat
e, Data>::result_type r7;
+ typedef
+ typename proto::detail::result_of_fixup<r0>::type
+ function_type;
+ typedef
+ typename boost::tr1_result_of<
+ function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7)
+ >::type
+ result_type;
+ result_type operator ()(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ ) const
+ {
+ return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+ }
+ private:
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::false_
+ ) const
+ {
+ return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+ typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d )
+ );
+ }
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::true_
+ ) const
+ {
+ using namespace boost::proto::detail::get_pointerns;
+ typedef typename detail::classtypeof<function_type>::type class_type;
+ return (
+ boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )) , (true ? 0 : get_pointer( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )))) ) ->*
+ typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+ )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ));
+ }
+ };
+ template<typename Grammar, typename Expr, typename State, typename Data>
+ struct default_function_impl<Grammar, Expr, State, Data, 9>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, Stat
e, Data>::result_type r7; typedef typename result_of::child_c< Expr, 8>::type e8; typedef typename Grammar::template impl<e8, State, Data>::result_type r8;
+ typedef
+ typename proto::detail::result_of_fixup<r0>::type
+ function_type;
+ typedef
+ typename boost::tr1_result_of<
+ function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7 , r8)
+ >::type
+ result_type;
+ result_type operator ()(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ ) const
+ {
+ return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+ }
+ private:
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::false_
+ ) const
+ {
+ return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+ typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d )
+ );
+ }
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::true_
+ ) const
+ {
+ using namespace boost::proto::detail::get_pointerns;
+ typedef typename detail::classtypeof<function_type>::type class_type;
+ return (
+ boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )) , (true ? 0 : get_pointer( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )))) ) ->*
+ typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+ )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ));
+ }
+ };
+ template<typename Grammar, typename Expr, typename State, typename Data>
+ struct default_function_impl<Grammar, Expr, State, Data, 10>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename result_of::child_c< Expr, 0>::type e0; typedef typename Grammar::template impl<e0, State, Data>::result_type r0; typedef typename result_of::child_c< Expr, 1>::type e1; typedef typename Grammar::template impl<e1, State, Data>::result_type r1; typedef typename result_of::child_c< Expr, 2>::type e2; typedef typename Grammar::template impl<e2, State, Data>::result_type r2; typedef typename result_of::child_c< Expr, 3>::type e3; typedef typename Grammar::template impl<e3, State, Data>::result_type r3; typedef typename result_of::child_c< Expr, 4>::type e4; typedef typename Grammar::template impl<e4, State, Data>::result_type r4; typedef typename result_of::child_c< Expr, 5>::type e5; typedef typename Grammar::template impl<e5, State, Data>::result_type r5; typedef typename result_of::child_c< Expr, 6>::type e6; typedef typename Grammar::template impl<e6, State, Data>::result_type r6; typedef typename result_of::child_c< Expr, 7>::type e7; typedef typename Grammar::template impl<e7, Stat
e, Data>::result_type r7; typedef typename result_of::child_c< Expr, 8>::type e8; typedef typename Grammar::template impl<e8, State, Data>::result_type r8; typedef typename result_of::child_c< Expr, 9>::type e9; typedef typename Grammar::template impl<e9, State, Data>::result_type r9;
+ typedef
+ typename proto::detail::result_of_fixup<r0>::type
+ function_type;
+ typedef
+ typename boost::tr1_result_of<
+ function_type(r1 , r2 , r3 , r4 , r5 , r6 , r7 , r8 , r9)
+ >::type
+ result_type;
+ result_type operator ()(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ ) const
+ {
+ return this->invoke(e, s, d, is_member_function_pointer<function_type>());
+ }
+ private:
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::false_
+ ) const
+ {
+ return typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )(
+ typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ) , typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) , typename Grammar::template impl<e9, State, Data>()( proto::child_c< 9>( e), s, d )
+ );
+ }
+ result_type invoke(
+ typename default_function_impl::expr_param e
+ , typename default_function_impl::state_param s
+ , typename default_function_impl::data_param d
+ , mpl::true_
+ ) const
+ {
+ using namespace boost::proto::detail::get_pointerns;
+ typedef typename detail::classtypeof<function_type>::type class_type;
+ return (
+ boost::proto::detail::proto_get_pointer<class_type>( boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )) , (true ? 0 : get_pointer( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d ))) , (true ? 0 : boost::addressof(boost::proto::detail::lvalue( typename Grammar::template impl<e1, State, Data>()( proto::child_c< 1>( e), s, d )))) ) ->*
+ typename Grammar::template impl<e0, State, Data>()( proto::child_c< 0>( e), s, d )
+ )(typename Grammar::template impl<e2, State, Data>()( proto::child_c< 2>( e), s, d ) , typename Grammar::template impl<e3, State, Data>()( proto::child_c< 3>( e), s, d ) , typename Grammar::template impl<e4, State, Data>()( proto::child_c< 4>( e), s, d ) , typename Grammar::template impl<e5, State, Data>()( proto::child_c< 5>( e), s, d ) , typename Grammar::template impl<e6, State, Data>()( proto::child_c< 6>( e), s, d ) , typename Grammar::template impl<e7, State, Data>()( proto::child_c< 7>( e), s, d ) , typename Grammar::template impl<e8, State, Data>()( proto::child_c< 8>( e), s, d ) , typename Grammar::template impl<e9, State, Data>()( proto::child_c< 9>( e), s, d ));
+ }
+ };

Added: trunk/boost/proto/transform/detail/preprocessed/fold_impl.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/preprocessed/fold_impl.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -0,0 +1,387 @@
+ ///////////////////////////////////////////////////////////////////////////////
+ /// \file fold_impl.hpp
+ /// Contains definition of fold_impl<> and reverse_fold_impl<> templates.
+ //
+ // Copyright 2008 Eric Niebler. 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)
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct fold_impl<State0, Fun, Expr, State, Data, 1>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1;
+ typedef state1 result_type;
+ result_type operator ()(
+ typename fold_impl::expr_param e
+ , typename fold_impl::state_param s
+ , typename fold_impl::data_param d
+ ) const
+ {
+ state0 s0 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d );
+ return s1;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct reverse_fold_impl<State0, Fun, Expr, State, Data, 1>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state1;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+ typedef state0 result_type;
+ result_type operator ()(
+ typename reverse_fold_impl::expr_param e
+ , typename reverse_fold_impl::state_param s
+ , typename reverse_fold_impl::data_param d
+ ) const
+ {
+ state1 s1 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+ return s0;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct fold_impl<State0, Fun, Expr, State, Data, 2>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2;
+ typedef state2 result_type;
+ result_type operator ()(
+ typename fold_impl::expr_param e
+ , typename fold_impl::state_param s
+ , typename fold_impl::data_param d
+ ) const
+ {
+ state0 s0 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d );
+ return s2;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct reverse_fold_impl<State0, Fun, Expr, State, Data, 2>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state2;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+ typedef state0 result_type;
+ result_type operator ()(
+ typename reverse_fold_impl::expr_param e
+ , typename reverse_fold_impl::state_param s
+ , typename reverse_fold_impl::data_param d
+ ) const
+ {
+ state2 s2 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+ return s0;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct fold_impl<State0, Fun, Expr, State, Data, 3>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3;
+ typedef state3 result_type;
+ result_type operator ()(
+ typename fold_impl::expr_param e
+ , typename fold_impl::state_param s
+ , typename fold_impl::data_param d
+ ) const
+ {
+ state0 s0 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d );
+ return s3;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct reverse_fold_impl<State0, Fun, Expr, State, Data, 3>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state3;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+ typedef state0 result_type;
+ result_type operator ()(
+ typename reverse_fold_impl::expr_param e
+ , typename reverse_fold_impl::state_param s
+ , typename reverse_fold_impl::data_param d
+ ) const
+ {
+ state3 s3 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+ return s0;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct fold_impl<State0, Fun, Expr, State, Data, 4>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4;
+ typedef state4 result_type;
+ result_type operator ()(
+ typename fold_impl::expr_param e
+ , typename fold_impl::state_param s
+ , typename fold_impl::data_param d
+ ) const
+ {
+ state0 s0 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d );
+ return s4;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct reverse_fold_impl<State0, Fun, Expr, State, Data, 4>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state4;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+ typedef state0 result_type;
+ result_type operator ()(
+ typename reverse_fold_impl::expr_param e
+ , typename reverse_fold_impl::state_param s
+ , typename reverse_fold_impl::data_param d
+ ) const
+ {
+ state4 s4 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+ return s0;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct fold_impl<State0, Fun, Expr, State, Data, 5>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5;
+ typedef state5 result_type;
+ result_type operator ()(
+ typename fold_impl::expr_param e
+ , typename fold_impl::state_param s
+ , typename fold_impl::data_param d
+ ) const
+ {
+ state0 s0 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d );
+ return s5;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct reverse_fold_impl<State0, Fun, Expr, State, Data, 5>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state5;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+ typedef state0 result_type;
+ result_type operator ()(
+ typename reverse_fold_impl::expr_param e
+ , typename reverse_fold_impl::state_param s
+ , typename reverse_fold_impl::data_param d
+ ) const
+ {
+ state5 s5 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+ return s0;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct fold_impl<State0, Fun, Expr, State, Data, 6>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6;
+ typedef state6 result_type;
+ result_type operator ()(
+ typename fold_impl::expr_param e
+ , typename fold_impl::state_param s
+ , typename fold_impl::data_param d
+ ) const
+ {
+ state0 s0 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d );
+ return s6;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct reverse_fold_impl<State0, Fun, Expr, State, Data, 6>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state6;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+ typedef state0 result_type;
+ result_type operator ()(
+ typename reverse_fold_impl::expr_param e
+ , typename reverse_fold_impl::state_param s
+ , typename reverse_fold_impl::data_param d
+ ) const
+ {
+ state6 s6 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+ return s0;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct fold_impl<State0, Fun, Expr, State, Data, 7>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7;
+ typedef state7 result_type;
+ result_type operator ()(
+ typename fold_impl::expr_param e
+ , typename fold_impl::state_param s
+ , typename fold_impl::data_param d
+ ) const
+ {
+ state0 s0 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::c
hild_c< 6>(e) , s6 , d );
+ return s7;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct reverse_fold_impl<State0, Fun, Expr, State, Data, 7>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state7;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+ typedef state0 result_type;
+ result_type operator ()(
+ typename reverse_fold_impl::expr_param e
+ , typename reverse_fold_impl::state_param s
+ , typename reverse_fold_impl::data_param d
+ ) const
+ {
+ state7 s7 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Dat
a >()( proto::child_c<0>(e) , s1 , d );
+ return s0;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct fold_impl<State0, Fun, Expr, State, Data, 8>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_typ
e state8;
+ typedef state8 result_type;
+ result_type operator ()(
+ typename fold_impl::expr_param e
+ , typename fold_impl::state_param s
+ , typename fold_impl::data_param d
+ ) const
+ {
+ state0 s0 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::c
hild_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d );
+ return s8;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct reverse_fold_impl<State0, Fun, Expr, State, Data, 8>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state8;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , sta
te1 , Data >::result_type state0;
+ typedef state0 result_type;
+ result_type operator ()(
+ typename reverse_fold_impl::expr_param e
+ , typename reverse_fold_impl::state_param s
+ , typename reverse_fold_impl::data_param d
+ ) const
+ {
+ state8 s8 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Dat
a >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+ return s0;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct fold_impl<State0, Fun, Expr, State, Data, 9>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_typ
e state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >::result_type state9;
+ typedef state9 result_type;
+ result_type operator ()(
+ typename fold_impl::expr_param e
+ , typename fold_impl::state_param s
+ , typename fold_impl::data_param d
+ ) const
+ {
+ state0 s0 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::c
hild_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >()( proto::child_c< 8>(e) , s8 , d );
+ return s9;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct reverse_fold_impl<State0, Fun, Expr, State, Data, 9>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state9;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , sta
te2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+ typedef state0 result_type;
+ result_type operator ()(
+ typename reverse_fold_impl::expr_param e
+ , typename reverse_fold_impl::state_param s
+ , typename reverse_fold_impl::data_param d
+ ) const
+ {
+ state9 s9 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >()( proto::child_c<8>(e) , s9 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Dat
a >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+ return s0;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct fold_impl<State0, Fun, Expr, State, Data, 10>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >::result_typ
e state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >::result_type state9; typedef typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 9>::type , state9 , Data >::result_type state10;
+ typedef state10 result_type;
+ result_type operator ()(
+ typename fold_impl::expr_param e
+ , typename fold_impl::state_param s
+ , typename fold_impl::data_param d
+ ) const
+ {
+ state0 s0 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 0>::type , state0 , Data >()( proto::child_c< 0>(e) , s0 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 1>::type , state1 , Data >()( proto::child_c< 1>(e) , s1 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 2>::type , state2 , Data >()( proto::child_c< 2>(e) , s2 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 3>::type , state3 , Data >()( proto::child_c< 3>(e) , s3 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 4>::type , state4 , Data >()( proto::child_c< 4>(e) , s4 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 5>::type , state5 , Data >()( proto::child_c< 5>(e) , s5 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 6>::type , state6 , Data >()( proto::c
hild_c< 6>(e) , s6 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 7>::type , state7 , Data >()( proto::child_c< 7>(e) , s7 , d ); state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 8>::type , state8 , Data >()( proto::child_c< 8>(e) , s8 , d ); state10 s10 = typename when<_, Fun>::template impl< typename result_of::child_c<Expr, 9>::type , state9 , Data >()( proto::child_c< 9>(e) , s9 , d );
+ return s10;
+ }
+ };
+ template<typename State0, typename Fun, typename Expr, typename State, typename Data>
+ struct reverse_fold_impl<State0, Fun, Expr, State, Data, 10>
+ : transform_impl<Expr, State, Data>
+ {
+ typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state10;
+ typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 9 >::type , state10 , Data >::result_type state9; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >::result_type state8; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >::result_type state7; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >::result_type state6; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >::result_type state5; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >::result_type state4; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , Data >::result_type state3; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , st
ate3 , Data >::result_type state2; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >::result_type state1; typedef typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >::result_type state0;
+ typedef state0 result_type;
+ result_type operator ()(
+ typename reverse_fold_impl::expr_param e
+ , typename reverse_fold_impl::state_param s
+ , typename reverse_fold_impl::data_param d
+ ) const
+ {
+ state10 s10 =
+ typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
+ state9 s9 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 9 >::type , state10 , Data >()( proto::child_c<9>(e) , s10 , d ); state8 s8 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 8 >::type , state9 , Data >()( proto::child_c<8>(e) , s9 , d ); state7 s7 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 7 >::type , state8 , Data >()( proto::child_c<7>(e) , s8 , d ); state6 s6 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 6 >::type , state7 , Data >()( proto::child_c<6>(e) , s7 , d ); state5 s5 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 5 >::type , state6 , Data >()( proto::child_c<5>(e) , s6 , d ); state4 s4 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 4 >::type , state5 , Data >()( proto::child_c<4>(e) , s5 , d ); state3 s3 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 3 >::type , state4 , D
ata >()( proto::child_c<3>(e) , s4 , d ); state2 s2 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 2 >::type , state3 , Data >()( proto::child_c<2>(e) , s3 , d ); state1 s1 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 1 >::type , state2 , Data >()( proto::child_c<1>(e) , s2 , d ); state0 s0 = typename when<_, Fun>::template impl< typename result_of::child_c< Expr , 0 >::type , state1 , Data >()( proto::child_c<0>(e) , s1 , d );
+ return s0;
+ }
+ };

Added: trunk/boost/proto/transform/detail/preprocessed/lazy.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/preprocessed/lazy.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -0,0 +1,227 @@
+ ///////////////////////////////////////////////////////////////////////////////
+ /// \file lazy.hpp
+ /// Contains definition of the lazy<> transform.
+ //
+ // Copyright 2008 Eric Niebler. 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)
+
+
+
+
+
+
+
+
+ template<typename Object >
+ struct lazy<Object()>
+ : transform<lazy<Object()> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : call<
+ typename make<Object>::template impl<Expr, State, Data>::result_type
+ ()
+ >::template impl<Expr, State, Data>
+ {};
+ };
+
+
+
+
+
+
+
+
+ template<typename Object , typename A0>
+ struct lazy<Object(A0)>
+ : transform<lazy<Object(A0)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : call<
+ typename make<Object>::template impl<Expr, State, Data>::result_type
+ (A0)
+ >::template impl<Expr, State, Data>
+ {};
+ };
+
+
+
+
+
+
+
+
+ template<typename Object , typename A0 , typename A1>
+ struct lazy<Object(A0 , A1)>
+ : transform<lazy<Object(A0 , A1)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : call<
+ typename make<Object>::template impl<Expr, State, Data>::result_type
+ (A0 , A1)
+ >::template impl<Expr, State, Data>
+ {};
+ };
+
+
+
+
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2>
+ struct lazy<Object(A0 , A1 , A2)>
+ : transform<lazy<Object(A0 , A1 , A2)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : call<
+ typename make<Object>::template impl<Expr, State, Data>::result_type
+ (A0 , A1 , A2)
+ >::template impl<Expr, State, Data>
+ {};
+ };
+
+
+
+
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
+ struct lazy<Object(A0 , A1 , A2 , A3)>
+ : transform<lazy<Object(A0 , A1 , A2 , A3)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : call<
+ typename make<Object>::template impl<Expr, State, Data>::result_type
+ (A0 , A1 , A2 , A3)
+ >::template impl<Expr, State, Data>
+ {};
+ };
+
+
+
+
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ struct lazy<Object(A0 , A1 , A2 , A3 , A4)>
+ : transform<lazy<Object(A0 , A1 , A2 , A3 , A4)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : call<
+ typename make<Object>::template impl<Expr, State, Data>::result_type
+ (A0 , A1 , A2 , A3 , A4)
+ >::template impl<Expr, State, Data>
+ {};
+ };
+
+
+
+
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)>
+ : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : call<
+ typename make<Object>::template impl<Expr, State, Data>::result_type
+ (A0 , A1 , A2 , A3 , A4 , A5)
+ >::template impl<Expr, State, Data>
+ {};
+ };
+
+
+
+
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+ : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : call<
+ typename make<Object>::template impl<Expr, State, Data>::result_type
+ (A0 , A1 , A2 , A3 , A4 , A5 , A6)
+ >::template impl<Expr, State, Data>
+ {};
+ };
+
+
+
+
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+ : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : call<
+ typename make<Object>::template impl<Expr, State, Data>::result_type
+ (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)
+ >::template impl<Expr, State, Data>
+ {};
+ };
+
+
+
+
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+ : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : call<
+ typename make<Object>::template impl<Expr, State, Data>::result_type
+ (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)
+ >::template impl<Expr, State, Data>
+ {};
+ };
+
+
+
+
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ struct lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+ : transform<lazy<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : call<
+ typename make<Object>::template impl<Expr, State, Data>::result_type
+ (A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)
+ >::template impl<Expr, State, Data>
+ {};
+ };

Added: trunk/boost/proto/transform/detail/preprocessed/make.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/preprocessed/make.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -0,0 +1,1056 @@
+ ///////////////////////////////////////////////////////////////////////////////
+ /// \file make.hpp
+ /// Contains definition of the make<> transform.
+ //
+ // Copyright 2008 Eric Niebler. 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)
+ namespace detail
+ {
+ template<typename R >
+ struct is_applyable<R()>
+ : mpl::true_
+ {};
+ template<typename R >
+ struct is_applyable<R(*)()>
+ : mpl::true_
+ {};
+ template<typename T, typename A>
+ struct construct_<proto::expr<T, A, 0>, true>
+ {
+ typedef proto::expr<T, A, 0> result_type;
+ template<typename A0>
+ result_type operator ()(A0 &a0) const
+ {
+ return result_type::make(a0);
+ }
+ };
+ template<typename T, typename A>
+ struct construct_<proto::basic_expr<T, A, 0>, true>
+ {
+ typedef proto::basic_expr<T, A, 0> result_type;
+ template<typename A0>
+ result_type operator ()(A0 &a0) const
+ {
+ return result_type::make(a0);
+ }
+ };
+ template<typename Type >
+ Type construct()
+ {
+ return construct_<Type>()();
+ }
+ }
+
+
+
+
+ template<typename Object >
+ struct make<Object()>
+ : transform<make<Object()> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+
+ typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ proto::detail::ignore_unused(e);
+ proto::detail::ignore_unused(s);
+ proto::detail::ignore_unused(d);
+ return detail::construct<result_type>();
+ }
+ };
+ };
+ namespace detail
+ {
+ template<
+ template<typename> class R
+ , typename A0
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ R<A0>
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
+ >
+ : nested_type_if<
+ R<typename make_if_<A0, Expr, State, Data> ::type>
+ , (make_if_<A0, Expr, State, Data> ::applied || false)
+ >
+ {};
+ template<
+ template<typename> class R
+ , typename A0
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ noinvoke<R<A0> >
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
+ >
+ {
+ typedef R<typename make_if_<A0, Expr, State, Data> ::type> type;
+ static bool const applied = true;
+ };
+ template<typename R , typename A0>
+ struct is_applyable<R(A0)>
+ : mpl::true_
+ {};
+ template<typename R , typename A0>
+ struct is_applyable<R(*)(A0)>
+ : mpl::true_
+ {};
+ template<typename T, typename A>
+ struct construct_<proto::expr<T, A, 1>, true>
+ {
+ typedef proto::expr<T, A, 1> result_type;
+ template<typename A0>
+ result_type operator ()(A0 &a0) const
+ {
+ return result_type::make(a0);
+ }
+ };
+ template<typename T, typename A>
+ struct construct_<proto::basic_expr<T, A, 1>, true>
+ {
+ typedef proto::basic_expr<T, A, 1> result_type;
+ template<typename A0>
+ result_type operator ()(A0 &a0) const
+ {
+ return result_type::make(a0);
+ }
+ };
+ template<typename Type , typename A0>
+ Type construct(A0 &a0)
+ {
+ return construct_<Type>()(a0);
+ }
+ }
+
+
+
+
+ template<typename Object , typename A0>
+ struct make<Object(A0)>
+ : transform<make<Object(A0)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+
+ typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ proto::detail::ignore_unused(e);
+ proto::detail::ignore_unused(s);
+ proto::detail::ignore_unused(d);
+ return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ));
+ }
+ };
+ };
+ namespace detail
+ {
+ template<
+ template<typename , typename> class R
+ , typename A0 , typename A1
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ R<A0 , A1>
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(2)
+ >
+ : nested_type_if<
+ R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type>
+ , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || false)
+ >
+ {};
+ template<
+ template<typename , typename> class R
+ , typename A0 , typename A1
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ noinvoke<R<A0 , A1> >
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
+ >
+ {
+ typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type> type;
+ static bool const applied = true;
+ };
+ template<typename R , typename A0 , typename A1>
+ struct is_applyable<R(A0 , A1)>
+ : mpl::true_
+ {};
+ template<typename R , typename A0 , typename A1>
+ struct is_applyable<R(*)(A0 , A1)>
+ : mpl::true_
+ {};
+ template<typename T, typename A>
+ struct construct_<proto::expr<T, A, 2>, true>
+ {
+ typedef proto::expr<T, A, 2> result_type;
+ template<typename A0 , typename A1>
+ result_type operator ()(A0 &a0 , A1 &a1) const
+ {
+ return result_type::make(a0 , a1);
+ }
+ };
+ template<typename T, typename A>
+ struct construct_<proto::basic_expr<T, A, 2>, true>
+ {
+ typedef proto::basic_expr<T, A, 2> result_type;
+ template<typename A0 , typename A1>
+ result_type operator ()(A0 &a0 , A1 &a1) const
+ {
+ return result_type::make(a0 , a1);
+ }
+ };
+ template<typename Type , typename A0 , typename A1>
+ Type construct(A0 &a0 , A1 &a1)
+ {
+ return construct_<Type>()(a0 , a1);
+ }
+ }
+
+
+
+
+ template<typename Object , typename A0 , typename A1>
+ struct make<Object(A0 , A1)>
+ : transform<make<Object(A0 , A1)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+
+ typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ proto::detail::ignore_unused(e);
+ proto::detail::ignore_unused(s);
+ proto::detail::ignore_unused(d);
+ return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ));
+ }
+ };
+ };
+ namespace detail
+ {
+ template<
+ template<typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ R<A0 , A1 , A2>
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(3)
+ >
+ : nested_type_if<
+ R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type>
+ , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || false)
+ >
+ {};
+ template<
+ template<typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ noinvoke<R<A0 , A1 , A2> >
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
+ >
+ {
+ typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type> type;
+ static bool const applied = true;
+ };
+ template<typename R , typename A0 , typename A1 , typename A2>
+ struct is_applyable<R(A0 , A1 , A2)>
+ : mpl::true_
+ {};
+ template<typename R , typename A0 , typename A1 , typename A2>
+ struct is_applyable<R(*)(A0 , A1 , A2)>
+ : mpl::true_
+ {};
+ template<typename T, typename A>
+ struct construct_<proto::expr<T, A, 3>, true>
+ {
+ typedef proto::expr<T, A, 3> result_type;
+ template<typename A0 , typename A1 , typename A2>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const
+ {
+ return result_type::make(a0 , a1 , a2);
+ }
+ };
+ template<typename T, typename A>
+ struct construct_<proto::basic_expr<T, A, 3>, true>
+ {
+ typedef proto::basic_expr<T, A, 3> result_type;
+ template<typename A0 , typename A1 , typename A2>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2) const
+ {
+ return result_type::make(a0 , a1 , a2);
+ }
+ };
+ template<typename Type , typename A0 , typename A1 , typename A2>
+ Type construct(A0 &a0 , A1 &a1 , A2 &a2)
+ {
+ return construct_<Type>()(a0 , a1 , a2);
+ }
+ }
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2>
+ struct make<Object(A0 , A1 , A2)>
+ : transform<make<Object(A0 , A1 , A2)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+
+ typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ proto::detail::ignore_unused(e);
+ proto::detail::ignore_unused(s);
+ proto::detail::ignore_unused(d);
+ return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ));
+ }
+ };
+ };
+ namespace detail
+ {
+ template<
+ template<typename , typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2 , typename A3
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ R<A0 , A1 , A2 , A3>
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(4)
+ >
+ : nested_type_if<
+ R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type>
+ , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || false)
+ >
+ {};
+ template<
+ template<typename , typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2 , typename A3
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ noinvoke<R<A0 , A1 , A2 , A3> >
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
+ >
+ {
+ typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type> type;
+ static bool const applied = true;
+ };
+ template<typename R , typename A0 , typename A1 , typename A2 , typename A3>
+ struct is_applyable<R(A0 , A1 , A2 , A3)>
+ : mpl::true_
+ {};
+ template<typename R , typename A0 , typename A1 , typename A2 , typename A3>
+ struct is_applyable<R(*)(A0 , A1 , A2 , A3)>
+ : mpl::true_
+ {};
+ template<typename T, typename A>
+ struct construct_<proto::expr<T, A, 4>, true>
+ {
+ typedef proto::expr<T, A, 4> result_type;
+ template<typename A0 , typename A1 , typename A2 , typename A3>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const
+ {
+ return result_type::make(a0 , a1 , a2 , a3);
+ }
+ };
+ template<typename T, typename A>
+ struct construct_<proto::basic_expr<T, A, 4>, true>
+ {
+ typedef proto::basic_expr<T, A, 4> result_type;
+ template<typename A0 , typename A1 , typename A2 , typename A3>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3) const
+ {
+ return result_type::make(a0 , a1 , a2 , a3);
+ }
+ };
+ template<typename Type , typename A0 , typename A1 , typename A2 , typename A3>
+ Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3)
+ {
+ return construct_<Type>()(a0 , a1 , a2 , a3);
+ }
+ }
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2 , typename A3>
+ struct make<Object(A0 , A1 , A2 , A3)>
+ : transform<make<Object(A0 , A1 , A2 , A3)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+
+ typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ proto::detail::ignore_unused(e);
+ proto::detail::ignore_unused(s);
+ proto::detail::ignore_unused(d);
+ return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ));
+ }
+ };
+ };
+ namespace detail
+ {
+ template<
+ template<typename , typename , typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ R<A0 , A1 , A2 , A3 , A4>
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(5)
+ >
+ : nested_type_if<
+ R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type>
+ , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || false)
+ >
+ {};
+ template<
+ template<typename , typename , typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ noinvoke<R<A0 , A1 , A2 , A3 , A4> >
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
+ >
+ {
+ typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type> type;
+ static bool const applied = true;
+ };
+ template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ struct is_applyable<R(A0 , A1 , A2 , A3 , A4)>
+ : mpl::true_
+ {};
+ template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4)>
+ : mpl::true_
+ {};
+ template<typename T, typename A>
+ struct construct_<proto::expr<T, A, 5>, true>
+ {
+ typedef proto::expr<T, A, 5> result_type;
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const
+ {
+ return result_type::make(a0 , a1 , a2 , a3 , a4);
+ }
+ };
+ template<typename T, typename A>
+ struct construct_<proto::basic_expr<T, A, 5>, true>
+ {
+ typedef proto::basic_expr<T, A, 5> result_type;
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4) const
+ {
+ return result_type::make(a0 , a1 , a2 , a3 , a4);
+ }
+ };
+ template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4)
+ {
+ return construct_<Type>()(a0 , a1 , a2 , a3 , a4);
+ }
+ }
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ struct make<Object(A0 , A1 , A2 , A3 , A4)>
+ : transform<make<Object(A0 , A1 , A2 , A3 , A4)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+
+ typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ proto::detail::ignore_unused(e);
+ proto::detail::ignore_unused(s);
+ proto::detail::ignore_unused(d);
+ return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ));
+ }
+ };
+ };
+ namespace detail
+ {
+ template<
+ template<typename , typename , typename , typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ R<A0 , A1 , A2 , A3 , A4 , A5>
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(6)
+ >
+ : nested_type_if<
+ R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type>
+ , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || false)
+ >
+ {};
+ template<
+ template<typename , typename , typename , typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5> >
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
+ >
+ {
+ typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type> type;
+ static bool const applied = true;
+ };
+ template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5)>
+ : mpl::true_
+ {};
+ template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5)>
+ : mpl::true_
+ {};
+ template<typename T, typename A>
+ struct construct_<proto::expr<T, A, 6>, true>
+ {
+ typedef proto::expr<T, A, 6> result_type;
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const
+ {
+ return result_type::make(a0 , a1 , a2 , a3 , a4 , a5);
+ }
+ };
+ template<typename T, typename A>
+ struct construct_<proto::basic_expr<T, A, 6>, true>
+ {
+ typedef proto::basic_expr<T, A, 6> result_type;
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5) const
+ {
+ return result_type::make(a0 , a1 , a2 , a3 , a4 , a5);
+ }
+ };
+ template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5)
+ {
+ return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5);
+ }
+ }
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ struct make<Object(A0 , A1 , A2 , A3 , A4 , A5)>
+ : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+
+ typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ proto::detail::ignore_unused(e);
+ proto::detail::ignore_unused(s);
+ proto::detail::ignore_unused(d);
+ return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ));
+ }
+ };
+ };
+ namespace detail
+ {
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ R<A0 , A1 , A2 , A3 , A4 , A5 , A6>
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(7)
+ >
+ : nested_type_if<
+ R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type>
+ , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || false)
+ >
+ {};
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6> >
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
+ >
+ {
+ typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type> type;
+ static bool const applied = true;
+ };
+ template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+ : mpl::true_
+ {};
+ template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+ : mpl::true_
+ {};
+ template<typename T, typename A>
+ struct construct_<proto::expr<T, A, 7>, true>
+ {
+ typedef proto::expr<T, A, 7> result_type;
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const
+ {
+ return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+ };
+ template<typename T, typename A>
+ struct construct_<proto::basic_expr<T, A, 7>, true>
+ {
+ typedef proto::basic_expr<T, A, 7> result_type;
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6) const
+ {
+ return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+ };
+ template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6)
+ {
+ return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6);
+ }
+ }
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+ : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+
+ typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ proto::detail::ignore_unused(e);
+ proto::detail::ignore_unused(s);
+ proto::detail::ignore_unused(d);
+ return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ));
+ }
+ };
+ };
+ namespace detail
+ {
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7>
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(8)
+ >
+ : nested_type_if<
+ R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type>
+ , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || false)
+ >
+ {};
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7> >
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
+ >
+ {
+ typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type> type;
+ static bool const applied = true;
+ };
+ template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+ : mpl::true_
+ {};
+ template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+ : mpl::true_
+ {};
+ template<typename T, typename A>
+ struct construct_<proto::expr<T, A, 8>, true>
+ {
+ typedef proto::expr<T, A, 8> result_type;
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const
+ {
+ return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+ };
+ template<typename T, typename A>
+ struct construct_<proto::basic_expr<T, A, 8>, true>
+ {
+ typedef proto::basic_expr<T, A, 8> result_type;
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7) const
+ {
+ return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+ };
+ template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7)
+ {
+ return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7);
+ }
+ }
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+ : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+
+ typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ proto::detail::ignore_unused(e);
+ proto::detail::ignore_unused(s);
+ proto::detail::ignore_unused(d);
+ return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ));
+ }
+ };
+ };
+ namespace detail
+ {
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8>
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(9)
+ >
+ : nested_type_if<
+ R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type>
+ , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || make_if_<A8, Expr, State, Data> ::applied || false)
+ >
+ {};
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8> >
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
+ >
+ {
+ typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type> type;
+ static bool const applied = true;
+ };
+ template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+ : mpl::true_
+ {};
+ template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+ : mpl::true_
+ {};
+ template<typename T, typename A>
+ struct construct_<proto::expr<T, A, 9>, true>
+ {
+ typedef proto::expr<T, A, 9> result_type;
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const
+ {
+ return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
+ };
+ template<typename T, typename A>
+ struct construct_<proto::basic_expr<T, A, 9>, true>
+ {
+ typedef proto::basic_expr<T, A, 9> result_type;
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8) const
+ {
+ return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
+ };
+ template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8)
+ {
+ return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8);
+ }
+ }
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+ : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+
+ typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ proto::detail::ignore_unused(e);
+ proto::detail::ignore_unused(s);
+ proto::detail::ignore_unused(d);
+ return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ));
+ }
+ };
+ };
+ namespace detail
+ {
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9>
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(10)
+ >
+ : nested_type_if<
+ R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type , typename make_if_<A9, Expr, State, Data> ::type>
+ , (make_if_<A0, Expr, State, Data> ::applied || make_if_<A1, Expr, State, Data> ::applied || make_if_<A2, Expr, State, Data> ::applied || make_if_<A3, Expr, State, Data> ::applied || make_if_<A4, Expr, State, Data> ::applied || make_if_<A5, Expr, State, Data> ::applied || make_if_<A6, Expr, State, Data> ::applied || make_if_<A7, Expr, State, Data> ::applied || make_if_<A8, Expr, State, Data> ::applied || make_if_<A9, Expr, State, Data> ::applied || false)
+ >
+ {};
+ template<
+ template<typename , typename , typename , typename , typename , typename , typename , typename , typename , typename> class R
+ , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9
+ , typename Expr, typename State, typename Data
+ >
+ struct make_<
+ noinvoke<R<A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9> >
+ , Expr, State, Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
+ >
+ {
+ typedef R<typename make_if_<A0, Expr, State, Data> ::type , typename make_if_<A1, Expr, State, Data> ::type , typename make_if_<A2, Expr, State, Data> ::type , typename make_if_<A3, Expr, State, Data> ::type , typename make_if_<A4, Expr, State, Data> ::type , typename make_if_<A5, Expr, State, Data> ::type , typename make_if_<A6, Expr, State, Data> ::type , typename make_if_<A7, Expr, State, Data> ::type , typename make_if_<A8, Expr, State, Data> ::type , typename make_if_<A9, Expr, State, Data> ::type> type;
+ static bool const applied = true;
+ };
+ template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ struct is_applyable<R(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+ : mpl::true_
+ {};
+ template<typename R , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ struct is_applyable<R(*)(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+ : mpl::true_
+ {};
+ template<typename T, typename A>
+ struct construct_<proto::expr<T, A, 10>, true>
+ {
+ typedef proto::expr<T, A, 10> result_type;
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const
+ {
+ return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+ }
+ };
+ template<typename T, typename A>
+ struct construct_<proto::basic_expr<T, A, 10>, true>
+ {
+ typedef proto::basic_expr<T, A, 10> result_type;
+ template<typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ result_type operator ()(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9) const
+ {
+ return result_type::make(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+ }
+ };
+ template<typename Type , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ Type construct(A0 &a0 , A1 &a1 , A2 &a2 , A3 &a3 , A4 &a4 , A5 &a5 , A6 &a6 , A7 &a7 , A8 &a8 , A9 &a9)
+ {
+ return construct_<Type>()(a0 , a1 , a2 , a3 , a4 , a5 , a6 , a7 , a8 , a9);
+ }
+ }
+
+
+
+
+ template<typename Object , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ struct make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+ : transform<make<Object(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+
+ typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+
+
+
+
+
+
+
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ proto::detail::ignore_unused(e);
+ proto::detail::ignore_unused(s);
+ proto::detail::ignore_unused(d);
+ return detail::construct<result_type>(detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) ));
+ }
+ };
+ };

Added: trunk/boost/proto/transform/detail/preprocessed/make_gcc_workaround.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/proto/transform/detail/preprocessed/make_gcc_workaround.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -0,0 +1,459 @@
+ ///////////////////////////////////////////////////////////////////////////////
+ /// \file make_gcc_workaround.hpp
+ /// Special workaround code to make the make\<\> transform work on certain
+ /// versions of gcc.
+ //
+ // Copyright 2008 Eric Niebler. 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)
+
+ template<typename Tag, typename Args, long Arity >
+ struct make<proto::expr<Tag, Args, Arity>()>
+ : transform<make<proto::expr<Tag, Args, Arity>()> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::expr<Tag, Args, Arity>::make(
+
+ );
+ }
+ };
+ };
+ template<typename Tag, typename Args, long Arity >
+ struct make<proto::basic_expr<Tag, Args, Arity>()>
+ : transform<make<proto::basic_expr<Tag, Args, Arity>()> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::basic_expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::basic_expr<Tag, Args, Arity>::make(
+
+ );
+ }
+ };
+ };
+
+ template<typename Tag, typename Args, long Arity , typename A0>
+ struct make<proto::expr<Tag, Args, Arity>(A0)>
+ : transform<make<proto::expr<Tag, Args, Arity>(A0)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+ template<typename Tag, typename Args, long Arity , typename A0>
+ struct make<proto::basic_expr<Tag, Args, Arity>(A0)>
+ : transform<make<proto::basic_expr<Tag, Args, Arity>(A0)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::basic_expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::basic_expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1>
+ struct make<proto::expr<Tag, Args, Arity>(A0 , A1)>
+ : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1>
+ struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1)>
+ : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::basic_expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::basic_expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2>
+ struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2)>
+ : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2>
+ struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2)>
+ : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::basic_expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::basic_expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3>
+ struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)>
+ : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3>
+ struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)>
+ : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::basic_expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::basic_expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)>
+ : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
+ struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)>
+ : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::basic_expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::basic_expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)>
+ : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
+ struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)>
+ : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::basic_expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::basic_expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+ : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
+ struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
+ : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::basic_expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::basic_expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+ : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
+ struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
+ : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::basic_expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::basic_expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+ : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8>
+ struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
+ : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::basic_expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::basic_expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+ : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };
+ template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7 , typename A8 , typename A9>
+ struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
+ : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
+ {
+ typedef proto::basic_expr<Tag, Args, Arity> result_type;
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ return proto::basic_expr<Tag, Args, Arity>::make(
+ detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A1>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A2>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A3>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A4>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A5>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A6>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A7>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A8>::template impl<Expr, State, Data>()(e, s, d) ) , detail::as_lvalue( typename when<_, A9>::template impl<Expr, State, Data>()(e, s, d) )
+ );
+ }
+ };
+ };

Modified: trunk/boost/proto/transform/fold.hpp
==============================================================================
--- trunk/boost/proto/transform/fold.hpp (original)
+++ trunk/boost/proto/transform/fold.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -1,316 +1,250 @@
-#ifndef BOOST_PP_IS_ITERATING
- ///////////////////////////////////////////////////////////////////////////////
- /// \file fold.hpp
- /// Contains definition of the fold<> and reverse_fold<> transforms.
- //
- // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007
- #define BOOST_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007
-
- #include <boost/preprocessor/cat.hpp>
- #include <boost/preprocessor/iteration/iterate.hpp>
- #include <boost/preprocessor/arithmetic/inc.hpp>
- #include <boost/preprocessor/arithmetic/sub.hpp>
- #include <boost/preprocessor/repetition/repeat.hpp>
- #include <boost/fusion/include/fold.hpp>
- #include <boost/proto/proto_fwd.hpp>
- #include <boost/proto/fusion.hpp>
- #include <boost/proto/functional/fusion/reverse.hpp>
- #include <boost/proto/traits.hpp>
- #include <boost/proto/transform/call.hpp>
- #include <boost/proto/transform/impl.hpp>
-
- namespace boost { namespace proto
+///////////////////////////////////////////////////////////////////////////////
+/// \file fold.hpp
+/// Contains definition of the fold<> and reverse_fold<> transforms.
+//
+// Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007
+#define BOOST_PROTO_TRANSFORM_FOLD_HPP_EAN_11_04_2007
+
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/preprocessor/arithmetic/sub.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/fusion/include/fold.hpp>
+#include <boost/fusion/include/reverse_fold.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/traits.hpp>
+#include <boost/proto/transform/impl.hpp>
+#include <boost/proto/transform/when.hpp>
+
+namespace boost { namespace proto
+{
+ namespace detail
     {
- namespace detail
+ template<typename Transform, typename Data>
+ struct as_callable
         {
- template<typename Transform, typename Data>
- struct as_callable
- {
- as_callable(Data d)
- : d_(d)
- {}
-
- template<typename Sig>
- struct result;
-
- template<typename This, typename State, typename Expr>
- struct result<This(State, Expr)>
- {
- typedef
- typename when<_, Transform>::template impl<Expr, State, Data>::result_type
- type;
- };
-
- template<typename State, typename Expr>
- typename when<_, Transform>::template impl<Expr &, State const &, Data>::result_type
- operator ()(State const &s, Expr &e) const
- {
- return typename when<_, Transform>::template impl<Expr &, State const &, Data>()(e, s, this->d_);
- }
+ as_callable(Data d)
+ : d_(d)
+ {}

- private:
- Data d_;
- };
+ template<typename Sig>
+ struct result;

- template<
- typename State0
- , typename Fun
- , typename Expr
- , typename State
- , typename Data
- , long Arity = arity_of<Expr>::value
- >
- struct fold_impl
- {};
-
- template<
- typename State0
- , typename Fun
- , typename Expr
- , typename State
- , typename Data
- , long Arity = arity_of<Expr>::value
- >
- struct reverse_fold_impl
- {};
-
- #define BOOST_PROTO_CHILD_N_TYPE(N)\
- BOOST_PP_CAT(proto_child, N)\
- /**/
-
- #define BOOST_PROTO_FOLD_STATE_TYPE(Z, N, DATA) \
- typedef \
- typename when<_, Fun>::template impl< \
- typename result_of::child_c<Expr, N>::type \
- , BOOST_PP_CAT(state, N) \
- , Data \
- >::result_type \
- BOOST_PP_CAT(state, BOOST_PP_INC(N)); \
- /**/
-
- #define BOOST_PROTO_FOLD_STATE(Z, N, DATA) \
- BOOST_PP_CAT(state, BOOST_PP_INC(N)) \
- BOOST_PP_CAT(s, BOOST_PP_INC(N)) \
- = typename when<_, Fun>::template impl< \
- typename result_of::child_c<Expr, N>::type \
- , BOOST_PP_CAT(state, N) \
- , Data \
- >()( \
- proto::child_c<N>(e) \
- , BOOST_PP_CAT(s, N) \
- , d \
- ); \
- /**/
-
- #define BOOST_PROTO_REVERSE_FOLD_STATE_TYPE(Z, N, DATA) \
- typedef \
- typename when<_, Fun>::template impl< \
- typename result_of::child_c< \
- Expr \
- , BOOST_PP_SUB(DATA, BOOST_PP_INC(N)) \
- >::type \
- , BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, N)) \
- , Data \
- >::result_type \
- BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))); \
- /**/
-
- #define BOOST_PROTO_REVERSE_FOLD_STATE(Z, N, DATA) \
- BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))) \
- BOOST_PP_CAT(s, BOOST_PP_SUB(DATA, BOOST_PP_INC(N))) \
- = typename when<_, Fun>::template impl< \
- typename result_of::child_c< \
- Expr \
- , BOOST_PP_SUB(DATA, BOOST_PP_INC(N)) \
- >::type \
- , BOOST_PP_CAT(state, BOOST_PP_SUB(DATA, N)) \
- , Data \
- >()( \
- proto::child_c<BOOST_PP_SUB(DATA, BOOST_PP_INC(N))>(e) \
- , BOOST_PP_CAT(s, BOOST_PP_SUB(DATA, N)) \
- , d \
- ); \
- /**/
-
- #define BOOST_PP_ITERATION_PARAMS_1 (3, (1, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/fold.hpp>))
- #include BOOST_PP_ITERATE()
-
- #undef BOOST_PROTO_REVERSE_FOLD_STATE
- #undef BOOST_PROTO_REVERSE_FOLD_STATE_TYPE
- #undef BOOST_PROTO_FOLD_STATE
- #undef BOOST_PROTO_FOLD_STATE_TYPE
- #undef BOOST_PROTO_CHILD_N_TYPE
-
- } // namespace detail
-
- /// \brief A PrimitiveTransform that invokes the <tt>fusion::fold\<\></tt>
- /// algorithm to accumulate
- template<typename Sequence, typename State0, typename Fun>
- struct fold : transform<fold<Sequence, State0, Fun> >
- {
- template<typename Expr, typename State, typename Data>
- struct impl : transform_impl<Expr, State, Data>
+ template<typename This, typename State, typename Expr>
+ struct result<This(State, Expr)>
             {
- /// \brief A Fusion sequence.
                 typedef
- typename remove_reference<
- typename when<_, Sequence>::template impl<Expr, State, Data>::result_type
- >::type
- sequence;
-
- /// \brief An initial state for the fold.
- typedef
- typename remove_reference<
- typename when<_, State0>::template impl<Expr, State, Data>::result_type
- >::type
- state0;
+ typename when<_, Transform>::template impl<Expr, State, Data>::result_type
+ type;
+ };

- /// \brief <tt>fun(d)(e,s) == when\<_,Fun\>()(e,s,d)</tt>
- typedef
- detail::as_callable<Fun, Data>
- fun;
+ template<typename State, typename Expr>
+ typename when<_, Transform>::template impl<Expr &, State const &, Data>::result_type
+ operator ()(State const &s, Expr &e) const
+ {
+ return typename when<_, Transform>::template impl<Expr &, State const &, Data>()(e, s, this->d_);
+ }

- typedef
- typename fusion::result_of::fold<
- sequence
- , state0
- , fun
- >::type
- result_type;
-
- /// Let \c seq be <tt>when\<_, Sequence\>()(e, s, d)</tt>, let
- /// \c state0 be <tt>when\<_, State0\>()(e, s, d)</tt>, and
- /// let \c fun(d) be an object such that <tt>fun(d)(e, s)</tt>
- /// is equivalent to <tt>when\<_, Fun\>()(e, s, d)</tt>. Then, this
- /// function returns <tt>fusion::fold(seq, state0, fun(d))</tt>.
- ///
- /// \param e The current expression
- /// \param s The current state
- /// \param d An arbitrary data
- result_type operator ()(
- typename impl::expr_param e
- , typename impl::state_param s
- , typename impl::data_param d
- ) const
- {
- typename when<_, Sequence>::template impl<Expr, State, Data> seq;
- detail::as_callable<Fun, Data> f(d);
- return fusion::fold(
- seq(e, s, d)
- , typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d)
- , f
- );
- }
- };
+ private:
+ Data d_;
         };

- /// \brief A PrimitiveTransform that is the same as the
- /// <tt>fold\<\></tt> transform, except that it folds
- /// back-to-front instead of front-to-back. It uses
- /// the \c _reverse callable PolymorphicFunctionObject
- /// to create a <tt>fusion::reverse_view\<\></tt> of the
- /// sequence before invoking <tt>fusion::fold\<\></tt>.
- template<typename Sequence, typename State0, typename Fun>
- struct reverse_fold
- : fold<call<_reverse(Sequence)>, State0, Fun>
+ template<
+ typename State0
+ , typename Fun
+ , typename Expr
+ , typename State
+ , typename Data
+ , long Arity = arity_of<Expr>::value
+ >
+ struct fold_impl
+ {};
+
+ template<
+ typename State0
+ , typename Fun
+ , typename Expr
+ , typename State
+ , typename Data
+ , long Arity = arity_of<Expr>::value
+ >
+ struct reverse_fold_impl
         {};

- // This specialization is only for improved compile-time performance
- // in the commom case when the Sequence transform is \c proto::_.
- //
- /// INTERNAL ONLY
- ///
- template<typename State0, typename Fun>
- struct fold<_, State0, Fun> : transform<fold<_, State0, Fun> >
+ #include <boost/proto/transform/detail/fold_impl.hpp>
+
+ } // namespace detail
+
+ /// \brief A PrimitiveTransform that invokes the <tt>fusion::fold\<\></tt>
+ /// algorithm to accumulate
+ template<typename Sequence, typename State0, typename Fun>
+ struct fold : transform<fold<Sequence, State0, Fun> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
         {
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::fold_impl<State0, Fun, Expr, State, Data>
- {};
+ /// \brief A Fusion sequence.
+ typedef
+ typename remove_reference<
+ typename when<_, Sequence>::template impl<Expr, State, Data>::result_type
+ >::type
+ sequence;
+
+ /// \brief An initial state for the fold.
+ typedef
+ typename remove_reference<
+ typename when<_, State0>::template impl<Expr, State, Data>::result_type
+ >::type
+ state0;
+
+ /// \brief <tt>fun(d)(e,s) == when\<_,Fun\>()(e,s,d)</tt>
+ typedef
+ detail::as_callable<Fun, Data>
+ fun;
+
+ typedef
+ typename fusion::result_of::fold<
+ sequence
+ , state0
+ , fun
+ >::type
+ result_type;
+
+ /// Let \c seq be <tt>when\<_, Sequence\>()(e, s, d)</tt>, let
+ /// \c state0 be <tt>when\<_, State0\>()(e, s, d)</tt>, and
+ /// let \c fun(d) be an object such that <tt>fun(d)(e, s)</tt>
+ /// is equivalent to <tt>when\<_, Fun\>()(e, s, d)</tt>. Then, this
+ /// function returns <tt>fusion::fold(seq, state0, fun(d))</tt>.
+ ///
+ /// \param e The current expression
+ /// \param s The current state
+ /// \param d An arbitrary data
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ typename when<_, Sequence>::template impl<Expr, State, Data> seq;
+ detail::as_callable<Fun, Data> f(d);
+ return fusion::fold(
+ seq(e, s, d)
+ , typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d)
+ , f
+ );
+ }
         };
+ };

- // This specialization is only for improved compile-time performance
- // in the commom case when the Sequence transform is \c proto::_.
- //
- /// INTERNAL ONLY
- ///
- template<typename State0, typename Fun>
- struct reverse_fold<_, State0, Fun> : transform<reverse_fold<_, State0, Fun> >
+ /// \brief A PrimitiveTransform that is the same as the
+ /// <tt>fold\<\></tt> transform, except that it folds
+ /// back-to-front instead of front-to-back.
+ template<typename Sequence, typename State0, typename Fun>
+ struct reverse_fold : transform<reverse_fold<Sequence, State0, Fun> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
         {
- template<typename Expr, typename State, typename Data>
- struct impl
- : detail::reverse_fold_impl<State0, Fun, Expr, State, Data>
- {};
+ /// \brief A Fusion sequence.
+ typedef
+ typename remove_reference<
+ typename when<_, Sequence>::template impl<Expr, State, Data>::result_type
+ >::type
+ sequence;
+
+ /// \brief An initial state for the fold.
+ typedef
+ typename remove_reference<
+ typename when<_, State0>::template impl<Expr, State, Data>::result_type
+ >::type
+ state0;
+
+ /// \brief <tt>fun(d)(e,s) == when\<_,Fun\>()(e,s,d)</tt>
+ typedef
+ detail::as_callable<Fun, Data>
+ fun;
+
+ typedef
+ typename fusion::result_of::reverse_fold<
+ sequence
+ , state0
+ , fun
+ >::type
+ result_type;
+
+ /// Let \c seq be <tt>when\<_, Sequence\>()(e, s, d)</tt>, let
+ /// \c state0 be <tt>when\<_, State0\>()(e, s, d)</tt>, and
+ /// let \c fun(d) be an object such that <tt>fun(d)(e, s)</tt>
+ /// is equivalent to <tt>when\<_, Fun\>()(e, s, d)</tt>. Then, this
+ /// function returns <tt>fusion::fold(seq, state0, fun(d))</tt>.
+ ///
+ /// \param e The current expression
+ /// \param s The current state
+ /// \param d An arbitrary data
+ result_type operator ()(
+ typename impl::expr_param e
+ , typename impl::state_param s
+ , typename impl::data_param d
+ ) const
+ {
+ typename when<_, Sequence>::template impl<Expr, State, Data> seq;
+ detail::as_callable<Fun, Data> f(d);
+ return fusion::reverse_fold(
+ seq(e, s, d)
+ , typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d)
+ , f
+ );
+ }
         };
+ };

- /// INTERNAL ONLY
- ///
- template<typename Sequence, typename State, typename Fun>
- struct is_callable<fold<Sequence, State, Fun> >
- : mpl::true_
+ // This specialization is only for improved compile-time performance
+ // in the commom case when the Sequence transform is \c proto::_.
+ //
+ /// INTERNAL ONLY
+ ///
+ template<typename State0, typename Fun>
+ struct fold<_, State0, Fun> : transform<fold<_, State0, Fun> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : detail::fold_impl<State0, Fun, Expr, State, Data>
         {};
+ };

- /// INTERNAL ONLY
- ///
- template<typename Sequence, typename State, typename Fun>
- struct is_callable<reverse_fold<Sequence, State, Fun> >
- : mpl::true_
+ // This specialization is only for improved compile-time performance
+ // in the commom case when the Sequence transform is \c proto::_.
+ //
+ /// INTERNAL ONLY
+ ///
+ template<typename State0, typename Fun>
+ struct reverse_fold<_, State0, Fun> : transform<reverse_fold<_, State0, Fun> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : detail::reverse_fold_impl<State0, Fun, Expr, State, Data>
         {};
+ };

- }}
-
- #endif
-
-#else
-
- #define N BOOST_PP_ITERATION()
-
- template<typename State0, typename Fun, typename Expr, typename State, typename Data>
- struct fold_impl<State0, Fun, Expr, State, Data, N>
- : transform_impl<Expr, State, Data>
- {
- typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type state0;
- BOOST_PP_REPEAT(N, BOOST_PROTO_FOLD_STATE_TYPE, N)
- typedef BOOST_PP_CAT(state, N) result_type;
-
- result_type operator ()(
- typename fold_impl::expr_param e
- , typename fold_impl::state_param s
- , typename fold_impl::data_param d
- ) const
- {
- state0 s0 =
- typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
- BOOST_PP_REPEAT(N, BOOST_PROTO_FOLD_STATE, N)
- return BOOST_PP_CAT(s, N);
- }
- };
-
- template<typename State0, typename Fun, typename Expr, typename State, typename Data>
- struct reverse_fold_impl<State0, Fun, Expr, State, Data, N>
- : transform_impl<Expr, State, Data>
- {
- typedef typename when<_, State0>::template impl<Expr, State, Data>::result_type BOOST_PP_CAT(state, N);
- BOOST_PP_REPEAT(N, BOOST_PROTO_REVERSE_FOLD_STATE_TYPE, N)
- typedef state0 result_type;
-
- result_type operator ()(
- typename reverse_fold_impl::expr_param e
- , typename reverse_fold_impl::state_param s
- , typename reverse_fold_impl::data_param d
- ) const
- {
- BOOST_PP_CAT(state, N) BOOST_PP_CAT(s, N) =
- typename when<_, State0>::template impl<Expr, State, Data>()(e, s, d);
- BOOST_PP_REPEAT(N, BOOST_PROTO_REVERSE_FOLD_STATE, N)
- return s0;
- }
- };
+ /// INTERNAL ONLY
+ ///
+ template<typename Sequence, typename State, typename Fun>
+ struct is_callable<fold<Sequence, State, Fun> >
+ : mpl::true_
+ {};
+
+ /// INTERNAL ONLY
+ ///
+ template<typename Sequence, typename State, typename Fun>
+ struct is_callable<reverse_fold<Sequence, State, Fun> >
+ : mpl::true_
+ {};

- #undef N
+}}

#endif

Modified: trunk/boost/proto/transform/lazy.hpp
==============================================================================
--- trunk/boost/proto/transform/lazy.hpp (original)
+++ trunk/boost/proto/transform/lazy.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -1,83 +1,52 @@
-#ifndef BOOST_PP_IS_ITERATING
- ///////////////////////////////////////////////////////////////////////////////
- /// \file lazy.hpp
- /// Contains definition of the lazy<> transform.
- //
- // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007
- #define BOOST_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007
-
- #include <boost/preprocessor/iteration/iterate.hpp>
- #include <boost/preprocessor/repetition/enum_params.hpp>
- #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
- #include <boost/proto/proto_fwd.hpp>
- #include <boost/proto/transform/make.hpp>
- #include <boost/proto/transform/call.hpp>
- #include <boost/proto/transform/impl.hpp>
-
- namespace boost { namespace proto
+///////////////////////////////////////////////////////////////////////////////
+/// \file lazy.hpp
+/// Contains definition of the lazy<> transform.
+//
+// Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007
+#define BOOST_PROTO_TRANSFORM_LAZY_HPP_EAN_12_02_2007
+
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/transform/make.hpp>
+#include <boost/proto/transform/call.hpp>
+#include <boost/proto/transform/impl.hpp>
+
+namespace boost { namespace proto
+{
+ /// \brief A PrimitiveTransform that uses <tt>make\<\></tt> to build
+ /// a CallableTransform, and then uses <tt>call\<\></tt> to apply it.
+ ///
+ /// <tt>lazy\<\></tt> is useful as a higher-order transform, when the
+ /// transform to be applied depends on the current state of the
+ /// transformation. The invocation of the <tt>make\<\></tt> transform
+ /// evaluates any nested transforms, and the resulting type is treated
+ /// as a CallableTransform, which is evaluated with <tt>call\<\></tt>.
+ template<typename Object>
+ struct lazy : transform<lazy<Object> >
{
- /// \brief A PrimitiveTransform that uses <tt>make\<\></tt> to build
- /// a CallableTransform, and then uses <tt>call\<\></tt> to apply it.
- ///
- /// <tt>lazy\<\></tt> is useful as a higher-order transform, when the
- /// transform to be applied depends on the current state of the
- /// transformation. The invocation of the <tt>make\<\></tt> transform
- /// evaluates any nested transforms, and the resulting type is treated
- /// as a CallableTransform, which is evaluated with <tt>call\<\></tt>.
- template<typename Object>
- struct lazy : transform<lazy<Object> >
- {
- template<typename Expr, typename State, typename Data>
- struct impl
- : call<
- typename make<Object>::template impl<Expr, State, Data>::result_type
- >::template impl<Expr, State, Data>
- {};
- };
-
- #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/lazy.hpp>))
- #include BOOST_PP_ITERATE()
-
- /// INTERNAL ONLY
- ///
- template<typename Object>
- struct is_callable<lazy<Object> >
- : mpl::true_
+ template<typename Expr, typename State, typename Data>
+ struct impl
+ : call<
+ typename make<Object>::template impl<Expr, State, Data>::result_type
+ >::template impl<Expr, State, Data>
{};
+ };

- }}
-
- #endif
-
-#else
-
- #define N BOOST_PP_ITERATION()
+ #include <boost/proto/transform/detail/lazy.hpp>

- /// \brief A PrimitiveTransform that uses <tt>make\<\></tt> to build
- /// a CallableTransform, and then uses <tt>call\<\></tt> to apply it.
- ///
- /// <tt>lazy\<\></tt> is useful as a higher-order transform, when the
- /// transform to be applied depends on the current state of the
- /// transformation. The invocation of the <tt>make\<\></tt> transform
- /// evaluates any nested transforms, and the resulting type is treated
- /// as a CallableTransform, which is evaluated with <tt>call\<\></tt>.
- template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
- struct lazy<Object(BOOST_PP_ENUM_PARAMS(N, A))>
- : transform<lazy<Object(BOOST_PP_ENUM_PARAMS(N, A))> >
- {
- template<typename Expr, typename State, typename Data>
- struct impl
- : call<
- typename make<Object>::template impl<Expr, State, Data>::result_type
- (BOOST_PP_ENUM_PARAMS(N, A))
- >::template impl<Expr, State, Data>
- {};
- };
+ /// INTERNAL ONLY
+ ///
+ template<typename Object>
+ struct is_callable<lazy<Object> >
+ : mpl::true_
+ {};

- #undef N
+}}

#endif

Modified: trunk/boost/proto/transform/make.hpp
==============================================================================
--- trunk/boost/proto/transform/make.hpp (original)
+++ trunk/boost/proto/transform/make.hpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -1,471 +1,265 @@
-#ifndef BOOST_PP_IS_ITERATING
- ///////////////////////////////////////////////////////////////////////////////
- /// \file make.hpp
- /// Contains definition of the make<> transform.
- //
- // Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007
- #define BOOST_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007
-
- #include <boost/detail/workaround.hpp>
- #include <boost/preprocessor/repetition/enum.hpp>
- #include <boost/preprocessor/repetition/enum_params.hpp>
- #include <boost/preprocessor/repetition/enum_trailing_params.hpp>
- #include <boost/preprocessor/repetition/enum_binary_params.hpp>
- #include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
- #include <boost/preprocessor/repetition/repeat_from_to.hpp>
- #include <boost/preprocessor/facilities/intercept.hpp>
- #include <boost/preprocessor/cat.hpp>
- #include <boost/preprocessor/iteration/iterate.hpp>
- #include <boost/preprocessor/selection/max.hpp>
- #include <boost/preprocessor/arithmetic/inc.hpp>
- #include <boost/mpl/and.hpp>
- #include <boost/mpl/aux_/has_type.hpp>
- #include <boost/proto/detail/template_arity.hpp>
- #include <boost/utility/result_of.hpp>
- #include <boost/proto/proto_fwd.hpp>
- #include <boost/proto/traits.hpp>
- #include <boost/proto/args.hpp>
- #include <boost/proto/transform/impl.hpp>
- #include <boost/proto/detail/as_lvalue.hpp>
- #include <boost/proto/detail/ignore_unused.hpp>
-
- namespace boost { namespace proto
+///////////////////////////////////////////////////////////////////////////////
+/// \file make.hpp
+/// Contains definition of the make<> transform.
+//
+// Copyright 2008 Eric Niebler. 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_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007
+#define BOOST_PROTO_TRANSFORM_MAKE_HPP_EAN_12_02_2007
+
+#include <boost/detail/workaround.hpp>
+#include <boost/preprocessor/repetition/enum.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
+#include <boost/preprocessor/repetition/enum_binary_params.hpp>
+#include <boost/preprocessor/repetition/enum_params_with_a_default.hpp>
+#include <boost/preprocessor/repetition/repeat_from_to.hpp>
+#include <boost/preprocessor/facilities/intercept.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/iteration/iterate.hpp>
+#include <boost/preprocessor/selection/max.hpp>
+#include <boost/preprocessor/arithmetic/inc.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/aux_/has_type.hpp>
+#include <boost/proto/detail/template_arity.hpp>
+#include <boost/utility/result_of.hpp>
+#include <boost/proto/proto_fwd.hpp>
+#include <boost/proto/traits.hpp>
+#include <boost/proto/args.hpp>
+#include <boost/proto/transform/impl.hpp>
+#include <boost/proto/detail/as_lvalue.hpp>
+#include <boost/proto/detail/ignore_unused.hpp>
+
+namespace boost { namespace proto
+{
+ namespace detail
     {
- namespace detail
- {
- template<typename T>
- struct is_applyable
- : mpl::and_<is_callable<T>, is_transform<T> >
- {};
-
- template<typename T, bool HasType = mpl::aux::has_type<T>::value>
- struct nested_type
- {
- typedef typename T::type type;
- };
-
- template<typename T>
- struct nested_type<T, false>
- {
- typedef T type;
- };
-
- template<typename T, bool Applied>
- struct nested_type_if
- {
- typedef T type;
- static bool const applied = false;
- };
-
- template<typename T>
- struct nested_type_if<T, true>
- : nested_type<T>
- {
- static bool const applied = true;
- };
-
- template<
- typename R
- , typename Expr, typename State, typename Data
- BOOST_PROTO_TEMPLATE_ARITY_PARAM(long Arity = detail::template_arity<R>::value)
- >
- struct make_
- {
- typedef R type;
- static bool const applied = false;
- };
-
- template<
- typename R
- , typename Expr, typename State, typename Data
- , bool IsApplyable = is_applyable<R>::value
- >
- struct make_if_
- : make_<R, Expr, State, Data>
- {};
-
- template<typename R, typename Expr, typename State, typename Data>
- struct make_if_<R, Expr, State, Data, true>
- : uncvref<typename when<_, R>::template impl<Expr, State, Data>::result_type>
- {
- static bool const applied = true;
- };
-
- #if BOOST_WORKAROUND(__GNUC__, == 3) || (__GNUC__ == 4 && __GNUC_MINOR__ == 0)
- // work around GCC bug
- template<typename Tag, typename Args, long N, typename Expr, typename State, typename Data>
- struct make_if_<proto::expr<Tag, Args, N>, Expr, State, Data, false>
- {
- typedef proto::expr<Tag, Args, N> type;
- static bool const applied = false;
- };
-
- // work around GCC bug
- template<typename Tag, typename Args, long N, typename Expr, typename State, typename Data>
- struct make_if_<proto::basic_expr<Tag, Args, N>, Expr, State, Data, false>
- {
- typedef proto::basic_expr<Tag, Args, N> type;
- static bool const applied = false;
- };
- #endif
-
- template<typename Type, bool IsAggregate = is_aggregate<Type>::value>
- struct construct_
- {
- typedef Type result_type;
+ template<typename T>
+ struct is_applyable
+ : mpl::and_<is_callable<T>, is_transform<T> >
+ {};

- Type operator ()() const
- {
- return Type();
- }
-
- #define TMP(Z, N, DATA) \
- template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)> \
- Type operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, &a)) const \
- { \
- return Type(BOOST_PP_ENUM_PARAMS_Z(Z, N, a)); \
- }
- BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), TMP, ~)
- #undef TMP
- };
+ template<typename T, bool HasType = mpl::aux::has_type<T>::value>
+ struct nested_type
+ {
+ typedef typename T::type type;
+ };

- template<typename Type>
- struct construct_<Type, true>
- {
- typedef Type result_type;
+ template<typename T>
+ struct nested_type<T, false>
+ {
+ typedef T type;
+ };

- Type operator ()() const
- {
- return Type();
- }
-
- #define TMP(Z, N, DATA) \
- template<BOOST_PP_ENUM_PARAMS_Z(Z, N, typename A)> \
- Type operator ()(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, &a)) const \
- { \
- Type that = {BOOST_PP_ENUM_PARAMS_Z(Z, N, a)}; \
- return that; \
- }
- BOOST_PP_REPEAT_FROM_TO(1, BOOST_PP_INC(BOOST_PROTO_MAX_ARITY), TMP, ~)
- #undef TMP
- };
-
- #define TMP(Z, N, DATA) \
- template<typename Type BOOST_PP_ENUM_TRAILING_PARAMS_Z(Z, N, typename A)> \
- Type construct(BOOST_PP_ENUM_BINARY_PARAMS_Z(Z, N, A, &a)) \
- { \
- return construct_<Type>()(BOOST_PP_ENUM_PARAMS_Z(Z, N, a)); \
- }
- BOOST_PP_REPEAT(BOOST_PROTO_MAX_ARITY, TMP, ~)
- #undef TMP
- }
-
- /// \brief A PrimitiveTransform which prevents another PrimitiveTransform
- /// from being applied in an \c ObjectTransform.
- ///
- /// When building higher order transforms with <tt>make\<\></tt> or
- /// <tt>lazy\<\></tt>, you sometimes would like to build types that
- /// are parameterized with Proto transforms. In such lambda-style
- /// transforms, Proto will unhelpfully find all nested transforms
- /// and apply them, even if you don't want them to be applied. Consider
- /// the following transform, which will replace the \c _ in
- /// <tt>Bar<_>()</tt> with <tt>proto::terminal\<int\>::type</tt>:
- ///
- /// \code
- /// template<typename T>
- /// struct Bar
- /// {};
- ///
- /// struct Foo
- /// : proto::when<_, Bar<_>() >
- /// {};
- ///
- /// proto::terminal<int>::type i = {0};
- ///
- /// int main()
- /// {
- /// Foo()(i);
- /// std::cout << typeid(Foo()(i)).name() << std::endl;
- /// }
- /// \endcode
- ///
- /// If you actually wanted to default-construct an object of type
- /// <tt>Bar\<_\></tt>, you would have to protect the \c _ to prevent
- /// it from being applied. You can use <tt>proto::protect\<\></tt>
- /// as follows:
- ///
- /// \code
- /// // OK: replace anything with Bar<_>()
- /// struct Foo
- /// : proto::when<_, Bar<protect<_> >() >
- /// {};
- /// \endcode
- template<typename PrimitiveTransform>
- struct protect : transform<protect<PrimitiveTransform> >
+ template<typename T, bool Applied>
+ struct nested_type_if
         {
- template<typename, typename, typename>
- struct impl
- {
- typedef PrimitiveTransform result_type;
- };
+ typedef T type;
+ static bool const applied = false;
         };

- /// \brief A PrimitiveTransform which computes a type by evaluating any
- /// nested transforms and then constructs an object of that type.
- ///
- /// The <tt>make\<\></tt> transform checks to see if \c Object is a template.
- /// If it is, the template type is disassembled to find nested transforms.
- /// Proto considers the following types to represent transforms:
- ///
- /// \li Function types
- /// \li Function pointer types
- /// \li Types for which <tt>proto::is_callable\< type \>::value</tt> is \c true
- ///
- /// <tt>boost::result_of\<make\<T\<X0,X1,...\> \>(Expr, State, Data)\>::type</tt>
- /// is evaluated as follows. For each \c X in <tt>X0,X1,...</tt>, do:
- ///
- /// \li If \c X is a template like <tt>U\<Y0,Y1,...\></tt>, then let <tt>X'</tt>
- /// be <tt>boost::result_of\<make\<U\<Y0,Y1,...\> \>(Expr, State, Data)\>::type</tt>
- /// (which evaluates this procedure recursively). Note whether any
- /// substitutions took place during this operation.
- /// \li Otherwise, if \c X is a transform, then let <tt>X'</tt> be
- /// <tt>boost::result_of\<when\<_, X\>(Expr, State, Data)\>::type</tt>.
- /// Note that a substitution took place.
- /// \li Otherwise, let <tt>X'</tt> be \c X, and note that no substitution
- /// took place.
- /// \li If any substitutions took place in any of the above steps and
- /// <tt>T\<X0',X1',...\></tt> has a nested <tt>::type</tt> typedef,
- /// the result type is <tt>T\<X0',X1',...\>::type</tt>.
- /// \li Otherwise, the result type is <tt>T\<X0',X1',...\></tt>.
- ///
- /// Note that <tt>when\<\></tt> is implemented in terms of <tt>call\<\></tt>
- /// and <tt>make\<\></tt>, so the above procedure is evaluated recursively.
- template<typename Object>
- struct make : transform<make<Object> >
+ template<typename T>
+ struct nested_type_if<T, true>
+ : nested_type<T>
         {
- template<typename Expr, typename State, typename Data>
- struct impl : transform_impl<Expr, State, Data>
- {
- typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+ static bool const applied = true;
+ };

- /// \return <tt>result_type()</tt>
- result_type operator ()(
- typename impl::expr_param
- , typename impl::state_param
- , typename impl::data_param
- ) const
- {
- return result_type();
- }
- };
- };
-
- #define BOOST_PP_ITERATION_PARAMS_1 (3, (0, BOOST_PROTO_MAX_ARITY, <boost/proto/transform/make.hpp>))
- #include BOOST_PP_ITERATE()
-
- /// INTERNAL ONLY
- ///
- template<typename Object>
- struct is_callable<make<Object> >
- : mpl::true_
- {};
+ template<
+ typename R
+ , typename Expr, typename State, typename Data
+ BOOST_PROTO_TEMPLATE_ARITY_PARAM(long Arity = detail::template_arity<R>::value)
+ >
+ struct make_
+ {
+ typedef R type;
+ static bool const applied = false;
+ };

- /// INTERNAL ONLY
- ///
- template<typename PrimitiveTransform>
- struct is_callable<protect<PrimitiveTransform> >
- : mpl::true_
+ template<
+ typename R
+ , typename Expr, typename State, typename Data
+ , bool IsApplyable = is_applyable<R>::value
+ >
+ struct make_if_
+ : make_<R, Expr, State, Data>
         {};

- }}
-
- #endif
+ template<typename R, typename Expr, typename State, typename Data>
+ struct make_if_<R, Expr, State, Data, true>
+ : uncvref<typename when<_, R>::template impl<Expr, State, Data>::result_type>
+ {
+ static bool const applied = true;
+ };

-#else
+ #if BOOST_WORKAROUND(__GNUC__, == 3) || (__GNUC__ == 4 && __GNUC_MINOR__ == 0)
+ // work around GCC bug
+ template<typename Tag, typename Args, long N, typename Expr, typename State, typename Data>
+ struct make_if_<proto::expr<Tag, Args, N>, Expr, State, Data, false>
+ {
+ typedef proto::expr<Tag, Args, N> type;
+ static bool const applied = false;
+ };

- #define N BOOST_PP_ITERATION()
+ // work around GCC bug
+ template<typename Tag, typename Args, long N, typename Expr, typename State, typename Data>
+ struct make_if_<proto::basic_expr<Tag, Args, N>, Expr, State, Data, false>
+ {
+ typedef proto::basic_expr<Tag, Args, N> type;
+ static bool const applied = false;
+ };
+ #endif

- namespace detail
- {
- #if N > 0
- #define TMP0(Z, M, DATA) make_if_<BOOST_PP_CAT(A, M), Expr, State, Data>
- #define TMP1(Z, M, DATA) typename TMP0(Z, M, DATA) ::type
- #define TMP2(Z, M, DATA) TMP0(Z, M, DATA) ::applied ||
-
- template<
- template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class R
- BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)
- , typename Expr, typename State, typename Data
- >
- struct make_<
- R<BOOST_PP_ENUM_PARAMS(N, A)>
- , Expr, State, Data
- BOOST_PROTO_TEMPLATE_ARITY_PARAM(N)
- >
- : nested_type_if<R<BOOST_PP_ENUM(N, TMP1, ~)>, (BOOST_PP_REPEAT(N, TMP2, ~) false)>
- {};
-
- template<
- template<BOOST_PP_ENUM_PARAMS(N, typename BOOST_PP_INTERCEPT)> class R
- BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)
- , typename Expr, typename State, typename Data
- >
- struct make_<
- noinvoke<R<BOOST_PP_ENUM_PARAMS(N, A)> >
- , Expr, State, Data
- BOOST_PROTO_TEMPLATE_ARITY_PARAM(1)
- >
- {
- typedef R<BOOST_PP_ENUM(N, TMP1, ~)> type;
- static bool const applied = true;
- };
-
- #undef TMP0
- #undef TMP1
- #undef TMP2
- #endif
-
- template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
- struct is_applyable<R(BOOST_PP_ENUM_PARAMS(N, A))>
- : mpl::true_
- {};
-
- template<typename R BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
- struct is_applyable<R(*)(BOOST_PP_ENUM_PARAMS(N, A))>
- : mpl::true_
- {};
+ template<typename Type, bool IsAggregate = is_aggregate<Type>::value>
+ struct construct_
+ {
+ typedef Type result_type;

- template<typename T, typename A>
- struct construct_<proto::expr<T, A, N>, true>
+ Type operator ()() const
             {
- typedef proto::expr<T, A, N> result_type;
-
- template<BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), typename A)>
- result_type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_MAX(N, 1), A, &a)) const
- {
- return result_type::make(BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), a));
- }
- };
+ return Type();
+ }

- template<typename T, typename A>
- struct construct_<proto::basic_expr<T, A, N>, true>
- {
- typedef proto::basic_expr<T, A, N> result_type;
+ // Other overloads generated by the preprocessor
+ #include <boost/proto/transform/detail/construct_funop.hpp>
+ };

- template<BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), typename A)>
- result_type operator ()(BOOST_PP_ENUM_BINARY_PARAMS(BOOST_PP_MAX(N, 1), A, &a)) const
- {
- return result_type::make(BOOST_PP_ENUM_PARAMS(BOOST_PP_MAX(N, 1), a));
- }
- };
- }
-
- /// \brief A PrimitiveTransform which computes a type by evaluating any
- /// nested transforms and then constructs an object of that type with the
- /// current expression, state and data, transformed according
- /// to \c A0 through \c AN.
- template<typename Object BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
- struct make<Object(BOOST_PP_ENUM_PARAMS(N, A))>
- : transform<make<Object(BOOST_PP_ENUM_PARAMS(N, A))> >
+ template<typename Type>
+ struct construct_<Type, true>
         {
- template<typename Expr, typename State, typename Data>
- struct impl : transform_impl<Expr, State, Data>
+ typedef Type result_type;
+
+ Type operator ()() const
             {
- /// \brief <tt>boost::result_of\<make\<Object\>(Expr, State, Data)\>::type</tt>
- typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;
+ return Type();
+ }

- /// Let \c ax be <tt>when\<_, Ax\>()(e, s, d)</tt>
- /// for each \c x in <tt>[0,N]</tt>.
- /// Return <tt>result_type(a0, a1,... aN)</tt>.
- ///
- /// \param e The current expression
- /// \param s The current state
- /// \param d An arbitrary data
- result_type operator ()(
- typename impl::expr_param e
- , typename impl::state_param s
- , typename impl::data_param d
- ) const
- {
- proto::detail::ignore_unused(e);
- proto::detail::ignore_unused(s);
- proto::detail::ignore_unused(d);
- return detail::construct<result_type>(
- #define TMP(Z, M, DATA) \
- detail::as_lvalue( \
- typename when<_, BOOST_PP_CAT(A, M)> \
- ::template impl<Expr, State, Data>()(e, s, d) \
- )
- BOOST_PP_ENUM(N, TMP, DATA)
- #undef TMP
- );
- }
- };
+ // Other overloads generated by the preprocessor
+ #include <boost/proto/transform/detail/construct_pod_funop.hpp>
         };

- #if BOOST_WORKAROUND(__GNUC__, == 3) || (__GNUC__ == 4 && __GNUC_MINOR__ == 0)
- // work around GCC bug
- template<typename Tag, typename Args, long Arity BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
- struct make<proto::expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))>
- : transform<make<proto::expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> >
+ }
+
+ /// \brief A PrimitiveTransform which prevents another PrimitiveTransform
+ /// from being applied in an \c ObjectTransform.
+ ///
+ /// When building higher order transforms with <tt>make\<\></tt> or
+ /// <tt>lazy\<\></tt>, you sometimes would like to build types that
+ /// are parameterized with Proto transforms. In such lambda-style
+ /// transforms, Proto will unhelpfully find all nested transforms
+ /// and apply them, even if you don't want them to be applied. Consider
+ /// the following transform, which will replace the \c _ in
+ /// <tt>Bar<_>()</tt> with <tt>proto::terminal\<int\>::type</tt>:
+ ///
+ /// \code
+ /// template<typename T>
+ /// struct Bar
+ /// {};
+ ///
+ /// struct Foo
+ /// : proto::when<_, Bar<_>() >
+ /// {};
+ ///
+ /// proto::terminal<int>::type i = {0};
+ ///
+ /// int main()
+ /// {
+ /// Foo()(i);
+ /// std::cout << typeid(Foo()(i)).name() << std::endl;
+ /// }
+ /// \endcode
+ ///
+ /// If you actually wanted to default-construct an object of type
+ /// <tt>Bar\<_\></tt>, you would have to protect the \c _ to prevent
+ /// it from being applied. You can use <tt>proto::protect\<\></tt>
+ /// as follows:
+ ///
+ /// \code
+ /// // OK: replace anything with Bar<_>()
+ /// struct Foo
+ /// : proto::when<_, Bar<protect<_> >() >
+ /// {};
+ /// \endcode
+ template<typename PrimitiveTransform>
+ struct protect : transform<protect<PrimitiveTransform> >
+ {
+ template<typename, typename, typename>
+ struct impl
         {
- template<typename Expr, typename State, typename Data>
- struct impl : transform_impl<Expr, State, Data>
- {
- typedef proto::expr<Tag, Args, Arity> result_type;
+ typedef PrimitiveTransform result_type;
+ };
+ };

- result_type operator ()(
- typename impl::expr_param e
- , typename impl::state_param s
- , typename impl::data_param d
- ) const
- {
- return proto::expr<Tag, Args, Arity>::make(
- #define TMP(Z, M, DATA) \
- detail::as_lvalue( \
- typename when<_, BOOST_PP_CAT(A, M)> \
- ::template impl<Expr, State, Data>()(e, s, d) \
- )
- BOOST_PP_ENUM(N, TMP, DATA)
- #undef TMP
- );
- }
- };
- };
-
- template<typename Tag, typename Args, long Arity BOOST_PP_ENUM_TRAILING_PARAMS(N, typename A)>
- struct make<proto::basic_expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))>
- : transform<make<proto::basic_expr<Tag, Args, Arity>(BOOST_PP_ENUM_PARAMS(N, A))> >
+ /// \brief A PrimitiveTransform which computes a type by evaluating any
+ /// nested transforms and then constructs an object of that type.
+ ///
+ /// The <tt>make\<\></tt> transform checks to see if \c Object is a template.
+ /// If it is, the template type is disassembled to find nested transforms.
+ /// Proto considers the following types to represent transforms:
+ ///
+ /// \li Function types
+ /// \li Function pointer types
+ /// \li Types for which <tt>proto::is_callable\< type \>::value</tt> is \c true
+ ///
+ /// <tt>boost::result_of\<make\<T\<X0,X1,...\> \>(Expr, State, Data)\>::type</tt>
+ /// is evaluated as follows. For each \c X in <tt>X0,X1,...</tt>, do:
+ ///
+ /// \li If \c X is a template like <tt>U\<Y0,Y1,...\></tt>, then let <tt>X'</tt>
+ /// be <tt>boost::result_of\<make\<U\<Y0,Y1,...\> \>(Expr, State, Data)\>::type</tt>
+ /// (which evaluates this procedure recursively). Note whether any
+ /// substitutions took place during this operation.
+ /// \li Otherwise, if \c X is a transform, then let <tt>X'</tt> be
+ /// <tt>boost::result_of\<when\<_, X\>(Expr, State, Data)\>::type</tt>.
+ /// Note that a substitution took place.
+ /// \li Otherwise, let <tt>X'</tt> be \c X, and note that no substitution
+ /// took place.
+ /// \li If any substitutions took place in any of the above steps and
+ /// <tt>T\<X0',X1',...\></tt> has a nested <tt>::type</tt> typedef,
+ /// the result type is <tt>T\<X0',X1',...\>::type</tt>.
+ /// \li Otherwise, the result type is <tt>T\<X0',X1',...\></tt>.
+ ///
+ /// Note that <tt>when\<\></tt> is implemented in terms of <tt>call\<\></tt>
+ /// and <tt>make\<\></tt>, so the above procedure is evaluated recursively.
+ template<typename Object>
+ struct make : transform<make<Object> >
+ {
+ template<typename Expr, typename State, typename Data>
+ struct impl : transform_impl<Expr, State, Data>
         {
- template<typename Expr, typename State, typename Data>
- struct impl : transform_impl<Expr, State, Data>
- {
- typedef proto::basic_expr<Tag, Args, Arity> result_type;
+ typedef typename detail::make_if_<Object, Expr, State, Data>::type result_type;

- result_type operator ()(
- typename impl::expr_param e
- , typename impl::state_param s
- , typename impl::data_param d
- ) const
- {
- return proto::basic_expr<Tag, Args, Arity>::make(
- #define TMP(Z, M, DATA) \
- detail::as_lvalue( \
- typename when<_, BOOST_PP_CAT(A, M)> \
- ::template impl<Expr, State, Data>()(e, s, d) \
- )
- BOOST_PP_ENUM(N, TMP, DATA)
- #undef TMP
- );
- }
- };
+ /// \return <tt>result_type()</tt>
+ result_type operator ()(
+ typename impl::expr_param
+ , typename impl::state_param
+ , typename impl::data_param
+ ) const
+ {
+ return result_type();
+ }
         };
- #endif
+ };
+
+ // Other specializations generated by the preprocessor.
+ #include <boost/proto/transform/detail/make.hpp>
+ #include <boost/proto/transform/detail/make_gcc_workaround.hpp>
+
+ /// INTERNAL ONLY
+ ///
+ template<typename Object>
+ struct is_callable<make<Object> >
+ : mpl::true_
+ {};
+
+ /// INTERNAL ONLY
+ ///
+ template<typename PrimitiveTransform>
+ struct is_callable<protect<PrimitiveTransform> >
+ : mpl::true_
+ {};

- #undef N
+}}

#endif

Modified: trunk/libs/proto/preprocess/preprocess_proto.cpp
==============================================================================
--- trunk/libs/proto/preprocess/preprocess_proto.cpp (original)
+++ trunk/libs/proto/preprocess/preprocess_proto.cpp 2011-05-08 07:42:37 EDT (Sun, 08 May 2011)
@@ -17,3 +17,7 @@
#include <boost/proto/make_expr.hpp>
#include <boost/proto/matches.hpp>
#include <boost/proto/transform/call.hpp>
+#include <boost/proto/transform/default.hpp>
+#include <boost/proto/transform/fold.hpp>
+#include <boost/proto/transform/lazy.hpp>
+#include <boost/proto/transform/make.hpp>

Date view	Thread view	Subject view	Author view

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