detail/preprocessed/make_gcc_workaround.hpp

0001     ///////////////////////////////////////////////////////////////////////////////
0002     /// \file make_gcc_workaround.hpp
0003     /// Special workaround code to make the make\<\> transform work on certain
0004     /// versions of gcc.
0005     //
0006     //  Copyright 2008 Eric Niebler. Distributed under the Boost
0007     //  Software License, Version 1.0. (See accompanying file
0008     //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
0009
0010     template<typename Tag, typename Args, long Arity >
0011     struct make<proto::expr<Tag, Args, Arity>()>
0012       : transform<make<proto::expr<Tag, Args, Arity>()> >
0013     {
0014         template<typename Expr, typename State, typename Data>
0015         struct impl : transform_impl<Expr, State, Data>
0016         {
0017             typedef proto::expr<Tag, Args, Arity> result_type;
0018             BOOST_FORCEINLINE
0019             result_type operator ()(
0020                 typename impl::expr_param e
0021               , typename impl::state_param s
0022               , typename impl::data_param d
0023             ) const
0024             {
0025                 return proto::expr<Tag, Args, Arity>::make(
0026
0027                 );
0028             }
0029         };
0030     };
0031     template<typename Tag, typename Args, long Arity >
0032     struct make<proto::basic_expr<Tag, Args, Arity>()>
0033       : transform<make<proto::basic_expr<Tag, Args, Arity>()> >
0034     {
0035         template<typename Expr, typename State, typename Data>
0036         struct impl : transform_impl<Expr, State, Data>
0037         {
0038             typedef proto::basic_expr<Tag, Args, Arity> result_type;
0039             BOOST_FORCEINLINE
0040             result_type operator ()(
0041                 typename impl::expr_param e
0042               , typename impl::state_param s
0043               , typename impl::data_param d
0044             ) const
0045             {
0046                 return proto::basic_expr<Tag, Args, Arity>::make(
0047
0048                 );
0049             }
0050         };
0051     };
0052
0053     template<typename Tag, typename Args, long Arity , typename A0>
0054     struct make<proto::expr<Tag, Args, Arity>(A0)>
0055       : transform<make<proto::expr<Tag, Args, Arity>(A0)> >
0056     {
0057         template<typename Expr, typename State, typename Data>
0058         struct impl : transform_impl<Expr, State, Data>
0059         {
0060             typedef proto::expr<Tag, Args, Arity> result_type;
0061             BOOST_FORCEINLINE
0062             result_type operator ()(
0063                 typename impl::expr_param e
0064               , typename impl::state_param s
0065               , typename impl::data_param d
0066             ) const
0067             {
0068                 return proto::expr<Tag, Args, Arity>::make(
0069                     detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) )
0070                 );
0071             }
0072         };
0073     };
0074     template<typename Tag, typename Args, long Arity , typename A0>
0075     struct make<proto::basic_expr<Tag, Args, Arity>(A0)>
0076       : transform<make<proto::basic_expr<Tag, Args, Arity>(A0)> >
0077     {
0078         template<typename Expr, typename State, typename Data>
0079         struct impl : transform_impl<Expr, State, Data>
0080         {
0081             typedef proto::basic_expr<Tag, Args, Arity> result_type;
0082             BOOST_FORCEINLINE
0083             result_type operator ()(
0084                 typename impl::expr_param e
0085               , typename impl::state_param s
0086               , typename impl::data_param d
0087             ) const
0088             {
0089                 return proto::basic_expr<Tag, Args, Arity>::make(
0090                     detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) )
0091                 );
0092             }
0093         };
0094     };
0095
0096     template<typename Tag, typename Args, long Arity , typename A0 , typename A1>
0097     struct make<proto::expr<Tag, Args, Arity>(A0 , A1)>
0098       : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1)> >
0099     {
0100         template<typename Expr, typename State, typename Data>
0101         struct impl : transform_impl<Expr, State, Data>
0102         {
0103             typedef proto::expr<Tag, Args, Arity> result_type;
0104             BOOST_FORCEINLINE
0105             result_type operator ()(
0106                 typename impl::expr_param e
0107               , typename impl::state_param s
0108               , typename impl::data_param d
0109             ) const
0110             {
0111                 return proto::expr<Tag, Args, Arity>::make(
0112                     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) )
0113                 );
0114             }
0115         };
0116     };
0117     template<typename Tag, typename Args, long Arity , typename A0 , typename A1>
0118     struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1)>
0119       : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1)> >
0120     {
0121         template<typename Expr, typename State, typename Data>
0122         struct impl : transform_impl<Expr, State, Data>
0123         {
0124             typedef proto::basic_expr<Tag, Args, Arity> result_type;
0125             BOOST_FORCEINLINE
0126             result_type operator ()(
0127                 typename impl::expr_param e
0128               , typename impl::state_param s
0129               , typename impl::data_param d
0130             ) const
0131             {
0132                 return proto::basic_expr<Tag, Args, Arity>::make(
0133                     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) )
0134                 );
0135             }
0136         };
0137     };
0138
0139     template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2>
0140     struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2)>
0141       : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2)> >
0142     {
0143         template<typename Expr, typename State, typename Data>
0144         struct impl : transform_impl<Expr, State, Data>
0145         {
0146             typedef proto::expr<Tag, Args, Arity> result_type;
0147             BOOST_FORCEINLINE
0148             result_type operator ()(
0149                 typename impl::expr_param e
0150               , typename impl::state_param s
0151               , typename impl::data_param d
0152             ) const
0153             {
0154                 return proto::expr<Tag, Args, Arity>::make(
0155                     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) )
0156                 );
0157             }
0158         };
0159     };
0160     template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2>
0161     struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2)>
0162       : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2)> >
0163     {
0164         template<typename Expr, typename State, typename Data>
0165         struct impl : transform_impl<Expr, State, Data>
0166         {
0167             typedef proto::basic_expr<Tag, Args, Arity> result_type;
0168             BOOST_FORCEINLINE
0169             result_type operator ()(
0170                 typename impl::expr_param e
0171               , typename impl::state_param s
0172               , typename impl::data_param d
0173             ) const
0174             {
0175                 return proto::basic_expr<Tag, Args, Arity>::make(
0176                     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) )
0177                 );
0178             }
0179         };
0180     };
0181
0182     template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3>
0183     struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)>
0184       : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> >
0185     {
0186         template<typename Expr, typename State, typename Data>
0187         struct impl : transform_impl<Expr, State, Data>
0188         {
0189             typedef proto::expr<Tag, Args, Arity> result_type;
0190             BOOST_FORCEINLINE
0191             result_type operator ()(
0192                 typename impl::expr_param e
0193               , typename impl::state_param s
0194               , typename impl::data_param d
0195             ) const
0196             {
0197                 return proto::expr<Tag, Args, Arity>::make(
0198                     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) )
0199                 );
0200             }
0201         };
0202     };
0203     template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3>
0204     struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)>
0205       : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> >
0206     {
0207         template<typename Expr, typename State, typename Data>
0208         struct impl : transform_impl<Expr, State, Data>
0209         {
0210             typedef proto::basic_expr<Tag, Args, Arity> result_type;
0211             BOOST_FORCEINLINE
0212             result_type operator ()(
0213                 typename impl::expr_param e
0214               , typename impl::state_param s
0215               , typename impl::data_param d
0216             ) const
0217             {
0218                 return proto::basic_expr<Tag, Args, Arity>::make(
0219                     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) )
0220                 );
0221             }
0222         };
0223     };
0224
0225     template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
0226     struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)>
0227       : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> >
0228     {
0229         template<typename Expr, typename State, typename Data>
0230         struct impl : transform_impl<Expr, State, Data>
0231         {
0232             typedef proto::expr<Tag, Args, Arity> result_type;
0233             BOOST_FORCEINLINE
0234             result_type operator ()(
0235                 typename impl::expr_param e
0236               , typename impl::state_param s
0237               , typename impl::data_param d
0238             ) const
0239             {
0240                 return proto::expr<Tag, Args, Arity>::make(
0241                     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) )
0242                 );
0243             }
0244         };
0245     };
0246     template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
0247     struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)>
0248       : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> >
0249     {
0250         template<typename Expr, typename State, typename Data>
0251         struct impl : transform_impl<Expr, State, Data>
0252         {
0253             typedef proto::basic_expr<Tag, Args, Arity> result_type;
0254             BOOST_FORCEINLINE
0255             result_type operator ()(
0256                 typename impl::expr_param e
0257               , typename impl::state_param s
0258               , typename impl::data_param d
0259             ) const
0260             {
0261                 return proto::basic_expr<Tag, Args, Arity>::make(
0262                     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) )
0263                 );
0264             }
0265         };
0266     };
0267
0268     template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
0269     struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)>
0270       : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> >
0271     {
0272         template<typename Expr, typename State, typename Data>
0273         struct impl : transform_impl<Expr, State, Data>
0274         {
0275             typedef proto::expr<Tag, Args, Arity> result_type;
0276             BOOST_FORCEINLINE
0277             result_type operator ()(
0278                 typename impl::expr_param e
0279               , typename impl::state_param s
0280               , typename impl::data_param d
0281             ) const
0282             {
0283                 return proto::expr<Tag, Args, Arity>::make(
0284                     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) )
0285                 );
0286             }
0287         };
0288     };
0289     template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
0290     struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)>
0291       : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> >
0292     {
0293         template<typename Expr, typename State, typename Data>
0294         struct impl : transform_impl<Expr, State, Data>
0295         {
0296             typedef proto::basic_expr<Tag, Args, Arity> result_type;
0297             BOOST_FORCEINLINE
0298             result_type operator ()(
0299                 typename impl::expr_param e
0300               , typename impl::state_param s
0301               , typename impl::data_param d
0302             ) const
0303             {
0304                 return proto::basic_expr<Tag, Args, Arity>::make(
0305                     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) )
0306                 );
0307             }
0308         };
0309     };
0310
0311     template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
0312     struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
0313       : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
0314     {
0315         template<typename Expr, typename State, typename Data>
0316         struct impl : transform_impl<Expr, State, Data>
0317         {
0318             typedef proto::expr<Tag, Args, Arity> result_type;
0319             BOOST_FORCEINLINE
0320             result_type operator ()(
0321                 typename impl::expr_param e
0322               , typename impl::state_param s
0323               , typename impl::data_param d
0324             ) const
0325             {
0326                 return proto::expr<Tag, Args, Arity>::make(
0327                     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) )
0328                 );
0329             }
0330         };
0331     };
0332     template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
0333     struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
0334       : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
0335     {
0336         template<typename Expr, typename State, typename Data>
0337         struct impl : transform_impl<Expr, State, Data>
0338         {
0339             typedef proto::basic_expr<Tag, Args, Arity> result_type;
0340             BOOST_FORCEINLINE
0341             result_type operator ()(
0342                 typename impl::expr_param e
0343               , typename impl::state_param s
0344               , typename impl::data_param d
0345             ) const
0346             {
0347                 return proto::basic_expr<Tag, Args, Arity>::make(
0348                     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) )
0349                 );
0350             }
0351         };
0352     };
0353
0354     template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
0355     struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
0356       : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
0357     {
0358         template<typename Expr, typename State, typename Data>
0359         struct impl : transform_impl<Expr, State, Data>
0360         {
0361             typedef proto::expr<Tag, Args, Arity> result_type;
0362             BOOST_FORCEINLINE
0363             result_type operator ()(
0364                 typename impl::expr_param e
0365               , typename impl::state_param s
0366               , typename impl::data_param d
0367             ) const
0368             {
0369                 return proto::expr<Tag, Args, Arity>::make(
0370                     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) )
0371                 );
0372             }
0373         };
0374     };
0375     template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
0376     struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
0377       : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
0378     {
0379         template<typename Expr, typename State, typename Data>
0380         struct impl : transform_impl<Expr, State, Data>
0381         {
0382             typedef proto::basic_expr<Tag, Args, Arity> result_type;
0383             BOOST_FORCEINLINE
0384             result_type operator ()(
0385                 typename impl::expr_param e
0386               , typename impl::state_param s
0387               , typename impl::data_param d
0388             ) const
0389             {
0390                 return proto::basic_expr<Tag, Args, Arity>::make(
0391                     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) )
0392                 );
0393             }
0394         };
0395     };
0396
0397     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>
0398     struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
0399       : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
0400     {
0401         template<typename Expr, typename State, typename Data>
0402         struct impl : transform_impl<Expr, State, Data>
0403         {
0404             typedef proto::expr<Tag, Args, Arity> result_type;
0405             BOOST_FORCEINLINE
0406             result_type operator ()(
0407                 typename impl::expr_param e
0408               , typename impl::state_param s
0409               , typename impl::data_param d
0410             ) const
0411             {
0412                 return proto::expr<Tag, Args, Arity>::make(
0413                     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) )
0414                 );
0415             }
0416         };
0417     };
0418     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>
0419     struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
0420       : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
0421     {
0422         template<typename Expr, typename State, typename Data>
0423         struct impl : transform_impl<Expr, State, Data>
0424         {
0425             typedef proto::basic_expr<Tag, Args, Arity> result_type;
0426             BOOST_FORCEINLINE
0427             result_type operator ()(
0428                 typename impl::expr_param e
0429               , typename impl::state_param s
0430               , typename impl::data_param d
0431             ) const
0432             {
0433                 return proto::basic_expr<Tag, Args, Arity>::make(
0434                     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) )
0435                 );
0436             }
0437         };
0438     };
0439
0440     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>
0441     struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
0442       : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
0443     {
0444         template<typename Expr, typename State, typename Data>
0445         struct impl : transform_impl<Expr, State, Data>
0446         {
0447             typedef proto::expr<Tag, Args, Arity> result_type;
0448             BOOST_FORCEINLINE
0449             result_type operator ()(
0450                 typename impl::expr_param e
0451               , typename impl::state_param s
0452               , typename impl::data_param d
0453             ) const
0454             {
0455                 return proto::expr<Tag, Args, Arity>::make(
0456                     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) )
0457                 );
0458             }
0459         };
0460     };
0461     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>
0462     struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
0463       : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
0464     {
0465         template<typename Expr, typename State, typename Data>
0466         struct impl : transform_impl<Expr, State, Data>
0467         {
0468             typedef proto::basic_expr<Tag, Args, Arity> result_type;
0469             BOOST_FORCEINLINE
0470             result_type operator ()(
0471                 typename impl::expr_param e
0472               , typename impl::state_param s
0473               , typename impl::data_param d
0474             ) const
0475             {
0476                 return proto::basic_expr<Tag, Args, Arity>::make(
0477                     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) )
0478                 );
0479             }
0480         };
0481     };