detail/preprocessed/pass_through_impl.hpp

0001     ///////////////////////////////////////////////////////////////////////////////
0002     /// \file pass_through_impl.hpp
0003     ///
0004     /// Specializations of pass_through_impl, used in the implementation of the
0005     /// pass_through transform.
0006     //
0007     //  Copyright 2008 Eric Niebler. Distributed under the Boost
0008     //  Software License, Version 1.0. (See accompanying file
0009     //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0010     template<typename Grammar, typename Domain, typename Expr, typename State, typename Data>
0011     struct pass_through_impl<Grammar, Domain, Expr, State, Data, 1>
0012       : transform_impl<Expr, State, Data>
0013     {
0014         typedef typename pass_through_impl::expr unref_expr;
0015         typedef
0016             typename mpl::if_c<
0017                 is_same<Domain, deduce_domain>::value
0018               , typename unref_expr::proto_domain
0019               , Domain
0020             >::type
0021         result_domain;
0022         typedef
0023             typename base_expr<
0024                 result_domain
0025               , typename unref_expr::proto_tag
0026               , list1<
0027                     typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type
0028                 >
0029             >::type
0030         expr_type;
0031         typedef typename result_domain::proto_generator proto_generator;
0032         typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type;
0033         BOOST_FORCEINLINE
0034         BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const)
0035         operator ()(
0036             typename pass_through_impl::expr_param e
0037           , typename pass_through_impl::state_param s
0038           , typename pass_through_impl::data_param d
0039         ) const
0040         {
0041             expr_type const that = {
0042                 typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d )
0043             };
0044
0045
0046
0047             detail::ignore_unused(&that);
0048             return proto_generator()(that);
0049         }
0050     };
0051     template<typename Grammar, typename Domain, typename Expr, typename State, typename Data>
0052     struct pass_through_impl<Grammar, Domain, Expr, State, Data, 2>
0053       : transform_impl<Expr, State, Data>
0054     {
0055         typedef typename pass_through_impl::expr unref_expr;
0056         typedef
0057             typename mpl::if_c<
0058                 is_same<Domain, deduce_domain>::value
0059               , typename unref_expr::proto_domain
0060               , Domain
0061             >::type
0062         result_domain;
0063         typedef
0064             typename base_expr<
0065                 result_domain
0066               , typename unref_expr::proto_tag
0067               , list2<
0068                     typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type
0069                 >
0070             >::type
0071         expr_type;
0072         typedef typename result_domain::proto_generator proto_generator;
0073         typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type;
0074         BOOST_FORCEINLINE
0075         BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const)
0076         operator ()(
0077             typename pass_through_impl::expr_param e
0078           , typename pass_through_impl::state_param s
0079           , typename pass_through_impl::data_param d
0080         ) const
0081         {
0082             expr_type const that = {
0083                 typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d )
0084             };
0085
0086
0087
0088             detail::ignore_unused(&that);
0089             return proto_generator()(that);
0090         }
0091     };
0092     template<typename Grammar, typename Domain, typename Expr, typename State, typename Data>
0093     struct pass_through_impl<Grammar, Domain, Expr, State, Data, 3>
0094       : transform_impl<Expr, State, Data>
0095     {
0096         typedef typename pass_through_impl::expr unref_expr;
0097         typedef
0098             typename mpl::if_c<
0099                 is_same<Domain, deduce_domain>::value
0100               , typename unref_expr::proto_domain
0101               , Domain
0102             >::type
0103         result_domain;
0104         typedef
0105             typename base_expr<
0106                 result_domain
0107               , typename unref_expr::proto_tag
0108               , list3<
0109                     typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type
0110                 >
0111             >::type
0112         expr_type;
0113         typedef typename result_domain::proto_generator proto_generator;
0114         typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type;
0115         BOOST_FORCEINLINE
0116         BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const)
0117         operator ()(
0118             typename pass_through_impl::expr_param e
0119           , typename pass_through_impl::state_param s
0120           , typename pass_through_impl::data_param d
0121         ) const
0122         {
0123             expr_type const that = {
0124                 typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d )
0125             };
0126
0127
0128
0129             detail::ignore_unused(&that);
0130             return proto_generator()(that);
0131         }
0132     };
0133     template<typename Grammar, typename Domain, typename Expr, typename State, typename Data>
0134     struct pass_through_impl<Grammar, Domain, Expr, State, Data, 4>
0135       : transform_impl<Expr, State, Data>
0136     {
0137         typedef typename pass_through_impl::expr unref_expr;
0138         typedef
0139             typename mpl::if_c<
0140                 is_same<Domain, deduce_domain>::value
0141               , typename unref_expr::proto_domain
0142               , Domain
0143             >::type
0144         result_domain;
0145         typedef
0146             typename base_expr<
0147                 result_domain
0148               , typename unref_expr::proto_tag
0149               , list4<
0150                     typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type
0151                 >
0152             >::type
0153         expr_type;
0154         typedef typename result_domain::proto_generator proto_generator;
0155         typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type;
0156         BOOST_FORCEINLINE
0157         BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const)
0158         operator ()(
0159             typename pass_through_impl::expr_param e
0160           , typename pass_through_impl::state_param s
0161           , typename pass_through_impl::data_param d
0162         ) const
0163         {
0164             expr_type const that = {
0165                 typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d )
0166             };
0167
0168
0169
0170             detail::ignore_unused(&that);
0171             return proto_generator()(that);
0172         }
0173     };
0174     template<typename Grammar, typename Domain, typename Expr, typename State, typename Data>
0175     struct pass_through_impl<Grammar, Domain, Expr, State, Data, 5>
0176       : transform_impl<Expr, State, Data>
0177     {
0178         typedef typename pass_through_impl::expr unref_expr;
0179         typedef
0180             typename mpl::if_c<
0181                 is_same<Domain, deduce_domain>::value
0182               , typename unref_expr::proto_domain
0183               , Domain
0184             >::type
0185         result_domain;
0186         typedef
0187             typename base_expr<
0188                 result_domain
0189               , typename unref_expr::proto_tag
0190               , list5<
0191                     typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type
0192                 >
0193             >::type
0194         expr_type;
0195         typedef typename result_domain::proto_generator proto_generator;
0196         typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type;
0197         BOOST_FORCEINLINE
0198         BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const)
0199         operator ()(
0200             typename pass_through_impl::expr_param e
0201           , typename pass_through_impl::state_param s
0202           , typename pass_through_impl::data_param d
0203         ) const
0204         {
0205             expr_type const that = {
0206                 typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d )
0207             };
0208
0209
0210
0211             detail::ignore_unused(&that);
0212             return proto_generator()(that);
0213         }
0214     };
0215     template<typename Grammar, typename Domain, typename Expr, typename State, typename Data>
0216     struct pass_through_impl<Grammar, Domain, Expr, State, Data, 6>
0217       : transform_impl<Expr, State, Data>
0218     {
0219         typedef typename pass_through_impl::expr unref_expr;
0220         typedef
0221             typename mpl::if_c<
0222                 is_same<Domain, deduce_domain>::value
0223               , typename unref_expr::proto_domain
0224               , Domain
0225             >::type
0226         result_domain;
0227         typedef
0228             typename base_expr<
0229                 result_domain
0230               , typename unref_expr::proto_tag
0231               , list6<
0232                     typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type
0233                 >
0234             >::type
0235         expr_type;
0236         typedef typename result_domain::proto_generator proto_generator;
0237         typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type;
0238         BOOST_FORCEINLINE
0239         BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const)
0240         operator ()(
0241             typename pass_through_impl::expr_param e
0242           , typename pass_through_impl::state_param s
0243           , typename pass_through_impl::data_param d
0244         ) const
0245         {
0246             expr_type const that = {
0247                 typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d )
0248             };
0249
0250
0251
0252             detail::ignore_unused(&that);
0253             return proto_generator()(that);
0254         }
0255     };
0256     template<typename Grammar, typename Domain, typename Expr, typename State, typename Data>
0257     struct pass_through_impl<Grammar, Domain, Expr, State, Data, 7>
0258       : transform_impl<Expr, State, Data>
0259     {
0260         typedef typename pass_through_impl::expr unref_expr;
0261         typedef
0262             typename mpl::if_c<
0263                 is_same<Domain, deduce_domain>::value
0264               , typename unref_expr::proto_domain
0265               , Domain
0266             >::type
0267         result_domain;
0268         typedef
0269             typename base_expr<
0270                 result_domain
0271               , typename unref_expr::proto_tag
0272               , list7<
0273                     typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type
0274                 >
0275             >::type
0276         expr_type;
0277         typedef typename result_domain::proto_generator proto_generator;
0278         typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type;
0279         BOOST_FORCEINLINE
0280         BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const)
0281         operator ()(
0282             typename pass_through_impl::expr_param e
0283           , typename pass_through_impl::state_param s
0284           , typename pass_through_impl::data_param d
0285         ) const
0286         {
0287             expr_type const that = {
0288                 typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d )
0289             };
0290
0291
0292
0293             detail::ignore_unused(&that);
0294             return proto_generator()(that);
0295         }
0296     };
0297     template<typename Grammar, typename Domain, typename Expr, typename State, typename Data>
0298     struct pass_through_impl<Grammar, Domain, Expr, State, Data, 8>
0299       : transform_impl<Expr, State, Data>
0300     {
0301         typedef typename pass_through_impl::expr unref_expr;
0302         typedef
0303             typename mpl::if_c<
0304                 is_same<Domain, deduce_domain>::value
0305               , typename unref_expr::proto_domain
0306               , Domain
0307             >::type
0308         result_domain;
0309         typedef
0310             typename base_expr<
0311                 result_domain
0312               , typename unref_expr::proto_tag
0313               , list8<
0314                     typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type
0315                 >
0316             >::type
0317         expr_type;
0318         typedef typename result_domain::proto_generator proto_generator;
0319         typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type;
0320         BOOST_FORCEINLINE
0321         BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const)
0322         operator ()(
0323             typename pass_through_impl::expr_param e
0324           , typename pass_through_impl::state_param s
0325           , typename pass_through_impl::data_param d
0326         ) const
0327         {
0328             expr_type const that = {
0329                 typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d )
0330             };
0331
0332
0333
0334             detail::ignore_unused(&that);
0335             return proto_generator()(that);
0336         }
0337     };
0338     template<typename Grammar, typename Domain, typename Expr, typename State, typename Data>
0339     struct pass_through_impl<Grammar, Domain, Expr, State, Data, 9>
0340       : transform_impl<Expr, State, Data>
0341     {
0342         typedef typename pass_through_impl::expr unref_expr;
0343         typedef
0344             typename mpl::if_c<
0345                 is_same<Domain, deduce_domain>::value
0346               , typename unref_expr::proto_domain
0347               , Domain
0348             >::type
0349         result_domain;
0350         typedef
0351             typename base_expr<
0352                 result_domain
0353               , typename unref_expr::proto_tag
0354               , list9<
0355                     typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >::result_type
0356                 >
0357             >::type
0358         expr_type;
0359         typedef typename result_domain::proto_generator proto_generator;
0360         typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type;
0361         BOOST_FORCEINLINE
0362         BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const)
0363         operator ()(
0364             typename pass_through_impl::expr_param e
0365           , typename pass_through_impl::state_param s
0366           , typename pass_through_impl::data_param d
0367         ) const
0368         {
0369             expr_type const that = {
0370                 typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d ) , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >()( e.proto_base().child8, s, d )
0371             };
0372
0373
0374
0375             detail::ignore_unused(&that);
0376             return proto_generator()(that);
0377         }
0378     };
0379     template<typename Grammar, typename Domain, typename Expr, typename State, typename Data>
0380     struct pass_through_impl<Grammar, Domain, Expr, State, Data, 10>
0381       : transform_impl<Expr, State, Data>
0382     {
0383         typedef typename pass_through_impl::expr unref_expr;
0384         typedef
0385             typename mpl::if_c<
0386                 is_same<Domain, deduce_domain>::value
0387               , typename unref_expr::proto_domain
0388               , Domain
0389             >::type
0390         result_domain;
0391         typedef
0392             typename base_expr<
0393                 result_domain
0394               , typename unref_expr::proto_tag
0395               , list10<
0396                     typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >::result_type , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >::result_type , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >::result_type , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >::result_type , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >::result_type , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >::result_type , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >::result_type , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >::result_type , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >::result_type , typename Grammar::proto_child9::template impl< typename result_of::child_c<Expr, 9>::type , State , Data >::result_type
0397                 >
0398             >::type
0399         expr_type;
0400         typedef typename result_domain::proto_generator proto_generator;
0401         typedef typename BOOST_PROTO_RESULT_OF<proto_generator(expr_type)>::type result_type;
0402         BOOST_FORCEINLINE
0403         BOOST_PROTO_RETURN_TYPE_STRICT_LOOSE(result_type, result_type const)
0404         operator ()(
0405             typename pass_through_impl::expr_param e
0406           , typename pass_through_impl::state_param s
0407           , typename pass_through_impl::data_param d
0408         ) const
0409         {
0410             expr_type const that = {
0411                 typename Grammar::proto_child0::template impl< typename result_of::child_c<Expr, 0>::type , State , Data >()( e.proto_base().child0, s, d ) , typename Grammar::proto_child1::template impl< typename result_of::child_c<Expr, 1>::type , State , Data >()( e.proto_base().child1, s, d ) , typename Grammar::proto_child2::template impl< typename result_of::child_c<Expr, 2>::type , State , Data >()( e.proto_base().child2, s, d ) , typename Grammar::proto_child3::template impl< typename result_of::child_c<Expr, 3>::type , State , Data >()( e.proto_base().child3, s, d ) , typename Grammar::proto_child4::template impl< typename result_of::child_c<Expr, 4>::type , State , Data >()( e.proto_base().child4, s, d ) , typename Grammar::proto_child5::template impl< typename result_of::child_c<Expr, 5>::type , State , Data >()( e.proto_base().child5, s, d ) , typename Grammar::proto_child6::template impl< typename result_of::child_c<Expr, 6>::type , State , Data >()( e.proto_base().child6, s, d ) , typename Grammar::proto_child7::template impl< typename result_of::child_c<Expr, 7>::type , State , Data >()( e.proto_base().child7, s, d ) , typename Grammar::proto_child8::template impl< typename result_of::child_c<Expr, 8>::type , State , Data >()( e.proto_base().child8, s, d ) , typename Grammar::proto_child9::template impl< typename result_of::child_c<Expr, 9>::type , State , Data >()( e.proto_base().child9, s, d )
0412             };
0413
0414
0415
0416             detail::ignore_unused(&that);
0417             return proto_generator()(that);
0418         }
0419     };