PageRenderTime 126ms CodeModel.GetById 16ms app.highlight 102ms RepoModel.GetById 2ms app.codeStats 0ms

/Src/Dependencies/Boost/boost/proto/transform/detail/preprocessed/make_gcc_workaround.hpp

http://hadesmem.googlecode.com/
C++ Header | 459 lines | 438 code | 13 blank | 8 comment | 0 complexity | 5cf91f84dd3e2b43d11d565df6724897 MD5 | raw file
  1    ///////////////////////////////////////////////////////////////////////////////
  2    /// \file make_gcc_workaround.hpp
  3    /// Special workaround code to make the make\<\> transform work on certain
  4    /// versions of gcc.
  5    //
  6    //  Copyright 2008 Eric Niebler. Distributed under the Boost
  7    //  Software License, Version 1.0. (See accompanying file
  8    //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
  9    
 10    template<typename Tag, typename Args, long Arity >
 11    struct make<proto::expr<Tag, Args, Arity>()>
 12      : transform<make<proto::expr<Tag, Args, Arity>()> >
 13    {
 14        template<typename Expr, typename State, typename Data>
 15        struct impl : transform_impl<Expr, State, Data>
 16        {
 17            typedef proto::expr<Tag, Args, Arity> result_type;
 18            result_type operator ()(
 19                typename impl::expr_param e
 20              , typename impl::state_param s
 21              , typename impl::data_param d
 22            ) const
 23            {
 24                return proto::expr<Tag, Args, Arity>::make(
 25                    
 26                );
 27            }
 28        };
 29    };
 30    template<typename Tag, typename Args, long Arity >
 31    struct make<proto::basic_expr<Tag, Args, Arity>()>
 32      : transform<make<proto::basic_expr<Tag, Args, Arity>()> >
 33    {
 34        template<typename Expr, typename State, typename Data>
 35        struct impl : transform_impl<Expr, State, Data>
 36        {
 37            typedef proto::basic_expr<Tag, Args, Arity> result_type;
 38            result_type operator ()(
 39                typename impl::expr_param e
 40              , typename impl::state_param s
 41              , typename impl::data_param d
 42            ) const
 43            {
 44                return proto::basic_expr<Tag, Args, Arity>::make(
 45                    
 46                );
 47            }
 48        };
 49    };
 50    
 51    template<typename Tag, typename Args, long Arity , typename A0>
 52    struct make<proto::expr<Tag, Args, Arity>(A0)>
 53      : transform<make<proto::expr<Tag, Args, Arity>(A0)> >
 54    {
 55        template<typename Expr, typename State, typename Data>
 56        struct impl : transform_impl<Expr, State, Data>
 57        {
 58            typedef proto::expr<Tag, Args, Arity> result_type;
 59            result_type operator ()(
 60                typename impl::expr_param e
 61              , typename impl::state_param s
 62              , typename impl::data_param d
 63            ) const
 64            {
 65                return proto::expr<Tag, Args, Arity>::make(
 66                    detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) )
 67                );
 68            }
 69        };
 70    };
 71    template<typename Tag, typename Args, long Arity , typename A0>
 72    struct make<proto::basic_expr<Tag, Args, Arity>(A0)>
 73      : transform<make<proto::basic_expr<Tag, Args, Arity>(A0)> >
 74    {
 75        template<typename Expr, typename State, typename Data>
 76        struct impl : transform_impl<Expr, State, Data>
 77        {
 78            typedef proto::basic_expr<Tag, Args, Arity> result_type;
 79            result_type operator ()(
 80                typename impl::expr_param e
 81              , typename impl::state_param s
 82              , typename impl::data_param d
 83            ) const
 84            {
 85                return proto::basic_expr<Tag, Args, Arity>::make(
 86                    detail::as_lvalue( typename when<_, A0>::template impl<Expr, State, Data>()(e, s, d) )
 87                );
 88            }
 89        };
 90    };
 91    
 92    template<typename Tag, typename Args, long Arity , typename A0 , typename A1>
 93    struct make<proto::expr<Tag, Args, Arity>(A0 , A1)>
 94      : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1)> >
 95    {
 96        template<typename Expr, typename State, typename Data>
 97        struct impl : transform_impl<Expr, State, Data>
 98        {
 99            typedef proto::expr<Tag, Args, Arity> result_type;
100            result_type operator ()(
101                typename impl::expr_param e
102              , typename impl::state_param s
103              , typename impl::data_param d
104            ) const
105            {
106                return proto::expr<Tag, Args, Arity>::make(
107                    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) )
108                );
109            }
110        };
111    };
112    template<typename Tag, typename Args, long Arity , typename A0 , typename A1>
113    struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1)>
114      : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1)> >
115    {
116        template<typename Expr, typename State, typename Data>
117        struct impl : transform_impl<Expr, State, Data>
118        {
119            typedef proto::basic_expr<Tag, Args, Arity> result_type;
120            result_type operator ()(
121                typename impl::expr_param e
122              , typename impl::state_param s
123              , typename impl::data_param d
124            ) const
125            {
126                return proto::basic_expr<Tag, Args, Arity>::make(
127                    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) )
128                );
129            }
130        };
131    };
132    
133    template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2>
134    struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2)>
135      : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2)> >
136    {
137        template<typename Expr, typename State, typename Data>
138        struct impl : transform_impl<Expr, State, Data>
139        {
140            typedef proto::expr<Tag, Args, Arity> result_type;
141            result_type operator ()(
142                typename impl::expr_param e
143              , typename impl::state_param s
144              , typename impl::data_param d
145            ) const
146            {
147                return proto::expr<Tag, Args, Arity>::make(
148                    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) )
149                );
150            }
151        };
152    };
153    template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2>
154    struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2)>
155      : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2)> >
156    {
157        template<typename Expr, typename State, typename Data>
158        struct impl : transform_impl<Expr, State, Data>
159        {
160            typedef proto::basic_expr<Tag, Args, Arity> result_type;
161            result_type operator ()(
162                typename impl::expr_param e
163              , typename impl::state_param s
164              , typename impl::data_param d
165            ) const
166            {
167                return proto::basic_expr<Tag, Args, Arity>::make(
168                    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) )
169                );
170            }
171        };
172    };
173    
174    template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3>
175    struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)>
176      : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> >
177    {
178        template<typename Expr, typename State, typename Data>
179        struct impl : transform_impl<Expr, State, Data>
180        {
181            typedef proto::expr<Tag, Args, Arity> result_type;
182            result_type operator ()(
183                typename impl::expr_param e
184              , typename impl::state_param s
185              , typename impl::data_param d
186            ) const
187            {
188                return proto::expr<Tag, Args, Arity>::make(
189                    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) )
190                );
191            }
192        };
193    };
194    template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3>
195    struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)>
196      : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3)> >
197    {
198        template<typename Expr, typename State, typename Data>
199        struct impl : transform_impl<Expr, State, Data>
200        {
201            typedef proto::basic_expr<Tag, Args, Arity> result_type;
202            result_type operator ()(
203                typename impl::expr_param e
204              , typename impl::state_param s
205              , typename impl::data_param d
206            ) const
207            {
208                return proto::basic_expr<Tag, Args, Arity>::make(
209                    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) )
210                );
211            }
212        };
213    };
214    
215    template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
216    struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)>
217      : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> >
218    {
219        template<typename Expr, typename State, typename Data>
220        struct impl : transform_impl<Expr, State, Data>
221        {
222            typedef proto::expr<Tag, Args, Arity> result_type;
223            result_type operator ()(
224                typename impl::expr_param e
225              , typename impl::state_param s
226              , typename impl::data_param d
227            ) const
228            {
229                return proto::expr<Tag, Args, Arity>::make(
230                    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) )
231                );
232            }
233        };
234    };
235    template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4>
236    struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)>
237      : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4)> >
238    {
239        template<typename Expr, typename State, typename Data>
240        struct impl : transform_impl<Expr, State, Data>
241        {
242            typedef proto::basic_expr<Tag, Args, Arity> result_type;
243            result_type operator ()(
244                typename impl::expr_param e
245              , typename impl::state_param s
246              , typename impl::data_param d
247            ) const
248            {
249                return proto::basic_expr<Tag, Args, Arity>::make(
250                    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) )
251                );
252            }
253        };
254    };
255    
256    template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
257    struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)>
258      : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> >
259    {
260        template<typename Expr, typename State, typename Data>
261        struct impl : transform_impl<Expr, State, Data>
262        {
263            typedef proto::expr<Tag, Args, Arity> result_type;
264            result_type operator ()(
265                typename impl::expr_param e
266              , typename impl::state_param s
267              , typename impl::data_param d
268            ) const
269            {
270                return proto::expr<Tag, Args, Arity>::make(
271                    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) )
272                );
273            }
274        };
275    };
276    template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5>
277    struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)>
278      : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5)> >
279    {
280        template<typename Expr, typename State, typename Data>
281        struct impl : transform_impl<Expr, State, Data>
282        {
283            typedef proto::basic_expr<Tag, Args, Arity> result_type;
284            result_type operator ()(
285                typename impl::expr_param e
286              , typename impl::state_param s
287              , typename impl::data_param d
288            ) const
289            {
290                return proto::basic_expr<Tag, Args, Arity>::make(
291                    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) )
292                );
293            }
294        };
295    };
296    
297    template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
298    struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
299      : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
300    {
301        template<typename Expr, typename State, typename Data>
302        struct impl : transform_impl<Expr, State, Data>
303        {
304            typedef proto::expr<Tag, Args, Arity> result_type;
305            result_type operator ()(
306                typename impl::expr_param e
307              , typename impl::state_param s
308              , typename impl::data_param d
309            ) const
310            {
311                return proto::expr<Tag, Args, Arity>::make(
312                    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) )
313                );
314            }
315        };
316    };
317    template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6>
318    struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)>
319      : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6)> >
320    {
321        template<typename Expr, typename State, typename Data>
322        struct impl : transform_impl<Expr, State, Data>
323        {
324            typedef proto::basic_expr<Tag, Args, Arity> result_type;
325            result_type operator ()(
326                typename impl::expr_param e
327              , typename impl::state_param s
328              , typename impl::data_param d
329            ) const
330            {
331                return proto::basic_expr<Tag, Args, Arity>::make(
332                    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) )
333                );
334            }
335        };
336    };
337    
338    template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
339    struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
340      : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
341    {
342        template<typename Expr, typename State, typename Data>
343        struct impl : transform_impl<Expr, State, Data>
344        {
345            typedef proto::expr<Tag, Args, Arity> result_type;
346            result_type operator ()(
347                typename impl::expr_param e
348              , typename impl::state_param s
349              , typename impl::data_param d
350            ) const
351            {
352                return proto::expr<Tag, Args, Arity>::make(
353                    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) )
354                );
355            }
356        };
357    };
358    template<typename Tag, typename Args, long Arity , typename A0 , typename A1 , typename A2 , typename A3 , typename A4 , typename A5 , typename A6 , typename A7>
359    struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)>
360      : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7)> >
361    {
362        template<typename Expr, typename State, typename Data>
363        struct impl : transform_impl<Expr, State, Data>
364        {
365            typedef proto::basic_expr<Tag, Args, Arity> result_type;
366            result_type operator ()(
367                typename impl::expr_param e
368              , typename impl::state_param s
369              , typename impl::data_param d
370            ) const
371            {
372                return proto::basic_expr<Tag, Args, Arity>::make(
373                    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) )
374                );
375            }
376        };
377    };
378    
379    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>
380    struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
381      : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
382    {
383        template<typename Expr, typename State, typename Data>
384        struct impl : transform_impl<Expr, State, Data>
385        {
386            typedef proto::expr<Tag, Args, Arity> result_type;
387            result_type operator ()(
388                typename impl::expr_param e
389              , typename impl::state_param s
390              , typename impl::data_param d
391            ) const
392            {
393                return proto::expr<Tag, Args, Arity>::make(
394                    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) )
395                );
396            }
397        };
398    };
399    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>
400    struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)>
401      : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8)> >
402    {
403        template<typename Expr, typename State, typename Data>
404        struct impl : transform_impl<Expr, State, Data>
405        {
406            typedef proto::basic_expr<Tag, Args, Arity> result_type;
407            result_type operator ()(
408                typename impl::expr_param e
409              , typename impl::state_param s
410              , typename impl::data_param d
411            ) const
412            {
413                return proto::basic_expr<Tag, Args, Arity>::make(
414                    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) )
415                );
416            }
417        };
418    };
419    
420    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>
421    struct make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
422      : transform<make<proto::expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
423    {
424        template<typename Expr, typename State, typename Data>
425        struct impl : transform_impl<Expr, State, Data>
426        {
427            typedef proto::expr<Tag, Args, Arity> result_type;
428            result_type operator ()(
429                typename impl::expr_param e
430              , typename impl::state_param s
431              , typename impl::data_param d
432            ) const
433            {
434                return proto::expr<Tag, Args, Arity>::make(
435                    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) )
436                );
437            }
438        };
439    };
440    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>
441    struct make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)>
442      : transform<make<proto::basic_expr<Tag, Args, Arity>(A0 , A1 , A2 , A3 , A4 , A5 , A6 , A7 , A8 , A9)> >
443    {
444        template<typename Expr, typename State, typename Data>
445        struct impl : transform_impl<Expr, State, Data>
446        {
447            typedef proto::basic_expr<Tag, Args, Arity> result_type;
448            result_type operator ()(
449                typename impl::expr_param e
450              , typename impl::state_param s
451              , typename impl::data_param d
452            ) const
453            {
454                return proto::basic_expr<Tag, Args, Arity>::make(
455                    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) )
456                );
457            }
458        };
459    };