source: NonGTP/Boost/boost/spirit/attribute/closure.hpp @ 857

Revision 857, 46.1 KB checked in by igarcia, 19 years ago (diff)
Line 
1/*=============================================================================
2    Copyright (c) 2001-2003 Joel de Guzman
3    Copyright (c) 2002-2003 Hartmut Kaiser
4    http://spirit.sourceforge.net/
5
6    Use, modification and distribution is subject to the Boost Software
7    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
8    http://www.boost.org/LICENSE_1_0.txt)
9=============================================================================*/
10#ifndef BOOST_SPIRIT_CLOSURE_HPP
11#define BOOST_SPIRIT_CLOSURE_HPP
12
13///////////////////////////////////////////////////////////////////////////////
14#include <boost/spirit/core/parser.hpp>
15#include <boost/spirit/core/composite/composite.hpp>
16#include <boost/spirit/attribute/parametric.hpp>
17#include <boost/spirit/attribute/closure_context.hpp>
18
19#include <boost/spirit/phoenix/closures.hpp>
20#include <boost/spirit/phoenix/primitives.hpp>
21#include <boost/spirit/phoenix/casts.hpp>
22#include <boost/spirit/phoenix/operators.hpp>
23#include <boost/spirit/phoenix/tuple_helpers.hpp>
24
25#include <boost/static_assert.hpp>
26
27///////////////////////////////////////////////////////////////////////////////
28//
29//  Spirit predefined maximum closure limit. This limit defines the maximum
30//  number of elements a closure can hold. This number defaults to 3. The
31//  actual maximum is rounded up in multiples of 3. Thus, if this value
32//  is 4, the actual limit is 6. The ultimate maximum limit in this
33//  implementation is 15.
34//
35//  It should NOT be greater than PHOENIX_LIMIT!
36//
37///////////////////////////////////////////////////////////////////////////////
38
39#if !defined(BOOST_SPIRIT_CLOSURE_LIMIT)
40#define BOOST_SPIRIT_CLOSURE_LIMIT PHOENIX_LIMIT
41#endif
42
43///////////////////////////////////////////////////////////////////////////////
44//
45// ensure BOOST_SPIRIT_CLOSURE_LIMIT <= PHOENIX_LIMIT and SPIRIT_CLOSURE_LIMIT <= 15
46//
47///////////////////////////////////////////////////////////////////////////////
48BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLOSURE_LIMIT <= PHOENIX_LIMIT);
49BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLOSURE_LIMIT <= 15);
50
51///////////////////////////////////////////////////////////////////////////////
52namespace boost { namespace spirit {
53
54    ///////////////////////////////////////////////////////////////////////////
55    //
56    //  closure_context class
57    //
58    ///////////////////////////////////////////////////////////////////////////
59    template <typename ClosureT>
60    class closure_context : public parser_context_base
61    {
62    public:
63
64        typedef typename phoenix::tuple_element<0,
65            typename ClosureT::tuple_t>::type attr_t;
66        typedef ClosureT base_t;
67        typedef closure_context_linker<closure_context<ClosureT> >
68        context_linker_t;
69
70        closure_context(ClosureT const& clos)
71        : frame(clos) {}
72
73        ~closure_context() {}
74
75        template <typename ParserT, typename ScannerT>
76        void pre_parse(ParserT const&, ScannerT const&) {}
77
78        template <typename ResultT, typename ParserT, typename ScannerT>
79        ResultT& post_parse(ResultT& hit, ParserT const&, ScannerT const&)
80        { hit.value(frame[phoenix::tuple_index<0>()]); return hit; }
81
82    private:
83
84        phoenix::closure_frame<typename ClosureT::phoenix_closure_t> frame;
85    };
86
87    ///////////////////////////////////////////////////////////////////////////
88    //
89    //  init_closure_context class
90    //
91    //      The init_closure_context class is a special parser context type
92    //      which additionally initializes a closure contained in the derived
93    //      parser with values from a given tuple. Please note, that this
94    //      given tuple does not contain the required values directly, it
95    //      contains phoenix::actor objects. These actors have to be
96    //      dereferenced to gain the values to be used for initialization
97    //      (this is done by the help of the phoenix::convert_actors<>
98    //      template).
99    //
100    ///////////////////////////////////////////////////////////////////////////
101
102    template <typename ClosureT>
103    class init_closure_context : public parser_context_base
104    {
105        typedef typename ClosureT::tuple_t      tuple_t;
106        typedef typename ClosureT::closure_t    closure_t;
107
108    public:
109
110        init_closure_context(ClosureT const& clos)
111        : frame(clos.subject(), phoenix::convert_actors<tuple_t>(clos.init)) {}
112
113        ~init_closure_context() {}
114
115        template <typename ParserT, typename ScannerT>
116        void pre_parse(ParserT const& /*p*/, ScannerT const&) {}
117
118        template <typename ResultT, typename ParserT, typename ScannerT>
119        ResultT& post_parse(ResultT& hit, ParserT const&, ScannerT const&)
120        { hit.value(frame[phoenix::tuple_index<0>()]); return hit; }
121
122    private:
123
124        phoenix::closure_frame<closure_t> frame;
125    };
126
127    ///////////////////////////////////////////////////////////////////////////
128    //
129    //  init_closure_parser class
130    //
131    ///////////////////////////////////////////////////////////////////////////
132    template <typename ParserT, typename ActorTupleT>
133    struct init_closure_parser
134    : public unary<ParserT, parser<init_closure_parser<ParserT, ActorTupleT> > >
135    {
136        typedef init_closure_parser<ParserT, ActorTupleT>           self_t;
137        typedef unary<ParserT, parser<self_t> >                     base_t;
138        typedef typename ParserT::phoenix_closure_t                 closure_t;
139        typedef typename ParserT::tuple_t                           tuple_t;
140        typedef typename phoenix::tuple_element<0, tuple_t>::type   attr_t;
141
142        template <typename ScannerT>
143        struct result
144        {
145            typedef typename match_result<ScannerT, attr_t>::type type;
146        };
147
148        init_closure_parser(ParserT const& p, ActorTupleT const& init_)
149        : base_t(p), init(init_) {}
150
151        template <typename ScannerT>
152        typename parser_result<self_t, ScannerT>::type
153        parse_main(ScannerT const& scan) const
154        {
155            return this->subject().parse_main(scan);
156        }
157
158        template <typename ScannerT>
159        typename parser_result<self_t, ScannerT>::type
160        parse(ScannerT const& scan) const
161        {
162            typedef init_closure_context<self_t> init_context_t;
163            typedef parser_scanner_linker<ScannerT> scanner_t;
164            typedef closure_context_linker<init_context_t> context_t;
165            typedef typename parser_result<self_t, ScannerT>::type result_t;
166            BOOST_SPIRIT_CONTEXT_PARSE(
167                scan, *this, scanner_t, context_t, result_t);
168        }
169
170        ActorTupleT init;
171    };
172
173    ///////////////////////////////////////////////////////////////////////////
174    //
175    //  closure class
176    //
177    ///////////////////////////////////////////////////////////////////////////
178    template <
179            typename DerivedT
180        ,   typename T0 = phoenix::nil_t
181        ,   typename T1 = phoenix::nil_t
182        ,   typename T2 = phoenix::nil_t
183
184    #if BOOST_SPIRIT_CLOSURE_LIMIT > 3
185        ,   typename T3 = phoenix::nil_t
186        ,   typename T4 = phoenix::nil_t
187        ,   typename T5 = phoenix::nil_t
188
189    #if BOOST_SPIRIT_CLOSURE_LIMIT > 6
190        ,   typename T6 = phoenix::nil_t
191        ,   typename T7 = phoenix::nil_t
192        ,   typename T8 = phoenix::nil_t
193
194    #if BOOST_SPIRIT_CLOSURE_LIMIT > 9
195        ,   typename T9 = phoenix::nil_t
196        ,   typename T10 = phoenix::nil_t
197        ,   typename T11 = phoenix::nil_t
198
199    #if BOOST_SPIRIT_CLOSURE_LIMIT > 12
200        ,   typename T12 = phoenix::nil_t
201        ,   typename T13 = phoenix::nil_t
202        ,   typename T14 = phoenix::nil_t
203
204    #endif
205    #endif
206    #endif
207    #endif
208    >
209    struct closure :
210        public phoenix::closure<
211            T0, T1, T2
212    #if BOOST_SPIRIT_CLOSURE_LIMIT > 3
213        ,   T3, T4, T5
214    #if BOOST_SPIRIT_CLOSURE_LIMIT > 6
215        ,   T6, T7, T8
216    #if BOOST_SPIRIT_CLOSURE_LIMIT > 9
217        ,   T9, T10, T11
218    #if BOOST_SPIRIT_CLOSURE_LIMIT > 12
219        ,   T12, T13, T14
220    #endif
221    #endif
222    #endif
223    #endif
224        >
225    {
226        typedef phoenix::closure<
227                T0, T1, T2
228    #if BOOST_SPIRIT_CLOSURE_LIMIT > 3
229            ,   T3, T4, T5
230    #if BOOST_SPIRIT_CLOSURE_LIMIT > 6
231            ,   T6, T7, T8
232    #if BOOST_SPIRIT_CLOSURE_LIMIT > 9
233            ,   T9, T10, T11
234    #if BOOST_SPIRIT_CLOSURE_LIMIT > 12
235            ,   T12, T13, T14
236    #endif
237    #endif
238    #endif
239    #endif
240            > phoenix_closure_t;
241
242        typedef closure_context<DerivedT> context_t;
243
244        template <typename DerivedT2>
245        struct aux
246        {
247            DerivedT2& aux_derived()
248            { return *static_cast<DerivedT2*>(this); }
249
250            DerivedT2 const& aux_derived() const
251            { return *static_cast<DerivedT2 const*>(this); }
252
253        // initialization functions
254            template <typename A>
255            init_closure_parser<
256                DerivedT2,
257                phoenix::tuple<
258                    typename phoenix::as_actor<A>::type
259                >
260            >
261            operator()(A const &a) const
262            {
263                typedef typename phoenix::as_actor<A>::type a_t;
264                typedef phoenix::tuple<a_t> actor_tuple_t;
265
266                return init_closure_parser<DerivedT2, actor_tuple_t>(
267                        aux_derived(),
268                        actor_tuple_t(
269                            phoenix::as_actor<A>::convert(a)
270                        )
271                    );
272            }
273
274            template <typename A, typename B>
275            init_closure_parser<
276                DerivedT2,
277                phoenix::tuple<
278                    typename phoenix::as_actor<A>::type,
279                    typename phoenix::as_actor<B>::type
280                >
281            >
282            operator()(A const &a, B const &b) const
283            {
284                typedef typename phoenix::as_actor<A>::type a_t;
285                typedef typename phoenix::as_actor<B>::type b_t;
286                typedef phoenix::tuple<a_t, b_t> actor_tuple_t;
287
288                return init_closure_parser<DerivedT2, actor_tuple_t>(
289                        aux_derived(),
290                        actor_tuple_t(
291                            phoenix::as_actor<A>::convert(a),
292                            phoenix::as_actor<B>::convert(b)
293                        )
294                    );
295            }
296
297            template <typename A, typename B, typename C>
298            init_closure_parser<
299                DerivedT2,
300                phoenix::tuple<
301                    typename phoenix::as_actor<A>::type,
302                    typename phoenix::as_actor<B>::type,
303                    typename phoenix::as_actor<C>::type
304                >
305            >
306            operator()(A const &a, B const &b, C const &c) const
307            {
308                typedef typename phoenix::as_actor<A>::type a_t;
309                typedef typename phoenix::as_actor<B>::type b_t;
310                typedef typename phoenix::as_actor<C>::type c_t;
311                typedef phoenix::tuple<a_t, b_t, c_t> actor_tuple_t;
312
313                return init_closure_parser<DerivedT2, actor_tuple_t>(
314                        aux_derived(),
315                        actor_tuple_t(
316                            phoenix::as_actor<A>::convert(a),
317                            phoenix::as_actor<B>::convert(b),
318                            phoenix::as_actor<C>::convert(c)
319                        )
320                    );
321            }
322
323    #if BOOST_SPIRIT_CLOSURE_LIMIT > 3
324
325            template <
326                typename A, typename B, typename C, typename D
327            >
328            init_closure_parser<
329                DerivedT2,
330                phoenix::tuple<
331                    typename phoenix::as_actor<A>::type,
332                    typename phoenix::as_actor<B>::type,
333                    typename phoenix::as_actor<C>::type,
334                    typename phoenix::as_actor<D>::type
335                >
336            >
337            operator()(
338                A const &a, B const &b, C const &c, D const &d
339            ) const
340            {
341                typedef typename phoenix::as_actor<A>::type a_t;
342                typedef typename phoenix::as_actor<B>::type b_t;
343                typedef typename phoenix::as_actor<C>::type c_t;
344                typedef typename phoenix::as_actor<D>::type d_t;
345                typedef phoenix::tuple<
346                            a_t, b_t, c_t, d_t
347                        > actor_tuple_t;
348
349                return init_closure_parser<DerivedT2, actor_tuple_t>(
350                        aux_derived(),
351                        actor_tuple_t(
352                            phoenix::as_actor<A>::convert(a),
353                            phoenix::as_actor<B>::convert(b),
354                            phoenix::as_actor<C>::convert(c),
355                            phoenix::as_actor<D>::convert(d)
356                        )
357                    );
358            }
359
360            template <
361                typename A, typename B, typename C, typename D, typename E
362            >
363            init_closure_parser<
364                DerivedT2,
365                phoenix::tuple<
366                    typename phoenix::as_actor<A>::type,
367                    typename phoenix::as_actor<B>::type,
368                    typename phoenix::as_actor<C>::type,
369                    typename phoenix::as_actor<D>::type,
370                    typename phoenix::as_actor<E>::type
371                >
372            >
373            operator()(
374                A const &a, B const &b, C const &c, D const &d, E const &e
375            ) const
376            {
377                typedef typename phoenix::as_actor<A>::type a_t;
378                typedef typename phoenix::as_actor<B>::type b_t;
379                typedef typename phoenix::as_actor<C>::type c_t;
380                typedef typename phoenix::as_actor<D>::type d_t;
381                typedef typename phoenix::as_actor<E>::type e_t;
382                typedef phoenix::tuple<
383                            a_t, b_t, c_t, d_t, e_t
384                        > actor_tuple_t;
385
386                return init_closure_parser<DerivedT2, actor_tuple_t>(
387                        aux_derived(),
388                        actor_tuple_t(
389                            phoenix::as_actor<A>::convert(a),
390                            phoenix::as_actor<B>::convert(b),
391                            phoenix::as_actor<C>::convert(c),
392                            phoenix::as_actor<D>::convert(d),
393                            phoenix::as_actor<E>::convert(e)
394                        )
395                    );
396            }
397
398            template <
399                typename A, typename B, typename C, typename D, typename E,
400                typename F
401            >
402            init_closure_parser<
403                DerivedT2,
404                phoenix::tuple<
405                    typename phoenix::as_actor<A>::type,
406                    typename phoenix::as_actor<B>::type,
407                    typename phoenix::as_actor<C>::type,
408                    typename phoenix::as_actor<D>::type,
409                    typename phoenix::as_actor<E>::type,
410                    typename phoenix::as_actor<F>::type
411                >
412            >
413            operator()(
414                A const &a, B const &b, C const &c, D const &d, E const &e,
415                F const &f
416            ) const
417            {
418                typedef typename phoenix::as_actor<A>::type a_t;
419                typedef typename phoenix::as_actor<B>::type b_t;
420                typedef typename phoenix::as_actor<C>::type c_t;
421                typedef typename phoenix::as_actor<D>::type d_t;
422                typedef typename phoenix::as_actor<E>::type e_t;
423                typedef typename phoenix::as_actor<F>::type f_t;
424                typedef phoenix::tuple<
425                            a_t, b_t, c_t, d_t, e_t, f_t
426                        > actor_tuple_t;
427
428                return init_closure_parser<DerivedT2, actor_tuple_t>(
429                        aux_derived(),
430                        actor_tuple_t(
431                            phoenix::as_actor<A>::convert(a),
432                            phoenix::as_actor<B>::convert(b),
433                            phoenix::as_actor<C>::convert(c),
434                            phoenix::as_actor<D>::convert(d),
435                            phoenix::as_actor<E>::convert(e),
436                            phoenix::as_actor<F>::convert(f)
437                        )
438                    );
439            }
440
441    #if BOOST_SPIRIT_CLOSURE_LIMIT > 6
442
443            template <
444                typename A, typename B, typename C, typename D, typename E,
445                typename F, typename G
446            >
447            init_closure_parser<
448                DerivedT2,
449                phoenix::tuple<
450                    typename phoenix::as_actor<A>::type,
451                    typename phoenix::as_actor<B>::type,
452                    typename phoenix::as_actor<C>::type,
453                    typename phoenix::as_actor<D>::type,
454                    typename phoenix::as_actor<E>::type,
455                    typename phoenix::as_actor<F>::type,
456                    typename phoenix::as_actor<G>::type
457                >
458            >
459            operator()(
460                A const &a, B const &b, C const &c, D const &d, E const &e,
461                F const &f, G const &g
462            ) const
463            {
464                typedef typename phoenix::as_actor<A>::type a_t;
465                typedef typename phoenix::as_actor<B>::type b_t;
466                typedef typename phoenix::as_actor<C>::type c_t;
467                typedef typename phoenix::as_actor<D>::type d_t;
468                typedef typename phoenix::as_actor<E>::type e_t;
469                typedef typename phoenix::as_actor<F>::type f_t;
470                typedef typename phoenix::as_actor<G>::type g_t;
471                typedef phoenix::tuple<
472                            a_t, b_t, c_t, d_t, e_t, f_t, g_t
473                        > actor_tuple_t;
474
475                return init_closure_parser<DerivedT2, actor_tuple_t>(
476                        aux_derived(),
477                        actor_tuple_t(
478                            phoenix::as_actor<A>::convert(a),
479                            phoenix::as_actor<B>::convert(b),
480                            phoenix::as_actor<C>::convert(c),
481                            phoenix::as_actor<D>::convert(d),
482                            phoenix::as_actor<E>::convert(e),
483                            phoenix::as_actor<F>::convert(f),
484                            phoenix::as_actor<G>::convert(g)
485                        )
486                    );
487            }
488
489            template <
490                typename A, typename B, typename C, typename D, typename E,
491                typename F, typename G, typename H
492            >
493            init_closure_parser<
494                DerivedT2,
495                phoenix::tuple<
496                    typename phoenix::as_actor<A>::type,
497                    typename phoenix::as_actor<B>::type,
498                    typename phoenix::as_actor<C>::type,
499                    typename phoenix::as_actor<D>::type,
500                    typename phoenix::as_actor<E>::type,
501                    typename phoenix::as_actor<F>::type,
502                    typename phoenix::as_actor<G>::type,
503                    typename phoenix::as_actor<H>::type
504                >
505            >
506            operator()(
507                A const &a, B const &b, C const &c, D const &d, E const &e,
508                F const &f, G const &g, H const &h
509            ) const
510            {
511                typedef typename phoenix::as_actor<A>::type a_t;
512                typedef typename phoenix::as_actor<B>::type b_t;
513                typedef typename phoenix::as_actor<C>::type c_t;
514                typedef typename phoenix::as_actor<D>::type d_t;
515                typedef typename phoenix::as_actor<E>::type e_t;
516                typedef typename phoenix::as_actor<F>::type f_t;
517                typedef typename phoenix::as_actor<G>::type g_t;
518                typedef typename phoenix::as_actor<H>::type h_t;
519                typedef phoenix::tuple<
520                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t
521                        > actor_tuple_t;
522
523                return init_closure_parser<DerivedT2, actor_tuple_t>(
524                        aux_derived(),
525                        actor_tuple_t(
526                            phoenix::as_actor<A>::convert(a),
527                            phoenix::as_actor<B>::convert(b),
528                            phoenix::as_actor<C>::convert(c),
529                            phoenix::as_actor<D>::convert(d),
530                            phoenix::as_actor<E>::convert(e),
531                            phoenix::as_actor<F>::convert(f),
532                            phoenix::as_actor<G>::convert(g),
533                            phoenix::as_actor<H>::convert(h)
534                        )
535                    );
536            }
537
538            template <
539                typename A, typename B, typename C, typename D, typename E,
540                typename F, typename G, typename H, typename I
541            >
542            init_closure_parser<
543                DerivedT2,
544                phoenix::tuple<
545                    typename phoenix::as_actor<A>::type,
546                    typename phoenix::as_actor<B>::type,
547                    typename phoenix::as_actor<C>::type,
548                    typename phoenix::as_actor<D>::type,
549                    typename phoenix::as_actor<E>::type,
550                    typename phoenix::as_actor<F>::type,
551                    typename phoenix::as_actor<G>::type,
552                    typename phoenix::as_actor<H>::type,
553                    typename phoenix::as_actor<I>::type
554                >
555            >
556            operator()(
557                A const &a, B const &b, C const &c, D const &d, E const &e,
558                F const &f, G const &g, H const &h, I const &i
559            ) const
560            {
561                typedef typename phoenix::as_actor<A>::type a_t;
562                typedef typename phoenix::as_actor<B>::type b_t;
563                typedef typename phoenix::as_actor<C>::type c_t;
564                typedef typename phoenix::as_actor<D>::type d_t;
565                typedef typename phoenix::as_actor<E>::type e_t;
566                typedef typename phoenix::as_actor<F>::type f_t;
567                typedef typename phoenix::as_actor<G>::type g_t;
568                typedef typename phoenix::as_actor<H>::type h_t;
569                typedef typename phoenix::as_actor<I>::type i_t;
570                typedef phoenix::tuple<
571                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t
572                        > actor_tuple_t;
573
574                return init_closure_parser<DerivedT2, actor_tuple_t>(
575                        aux_derived(),
576                        actor_tuple_t(
577                            phoenix::as_actor<A>::convert(a),
578                            phoenix::as_actor<B>::convert(b),
579                            phoenix::as_actor<C>::convert(c),
580                            phoenix::as_actor<D>::convert(d),
581                            phoenix::as_actor<E>::convert(e),
582                            phoenix::as_actor<F>::convert(f),
583                            phoenix::as_actor<G>::convert(g),
584                            phoenix::as_actor<H>::convert(h),
585                            phoenix::as_actor<I>::convert(i)
586                        )
587                    );
588            }
589
590    #if BOOST_SPIRIT_CLOSURE_LIMIT > 9
591
592            template <
593                typename A, typename B, typename C, typename D, typename E,
594                typename F, typename G, typename H, typename I, typename J
595            >
596            init_closure_parser<
597                DerivedT2,
598                phoenix::tuple<
599                    typename phoenix::as_actor<A>::type,
600                    typename phoenix::as_actor<B>::type,
601                    typename phoenix::as_actor<C>::type,
602                    typename phoenix::as_actor<D>::type,
603                    typename phoenix::as_actor<E>::type,
604                    typename phoenix::as_actor<F>::type,
605                    typename phoenix::as_actor<G>::type,
606                    typename phoenix::as_actor<H>::type,
607                    typename phoenix::as_actor<I>::type,
608                    typename phoenix::as_actor<J>::type
609                >
610            >
611            operator()(
612                A const &a, B const &b, C const &c, D const &d, E const &e,
613                F const &f, G const &g, H const &h, I const &i, J const &j
614            ) const
615            {
616                typedef typename phoenix::as_actor<A>::type a_t;
617                typedef typename phoenix::as_actor<B>::type b_t;
618                typedef typename phoenix::as_actor<C>::type c_t;
619                typedef typename phoenix::as_actor<D>::type d_t;
620                typedef typename phoenix::as_actor<E>::type e_t;
621                typedef typename phoenix::as_actor<F>::type f_t;
622                typedef typename phoenix::as_actor<G>::type g_t;
623                typedef typename phoenix::as_actor<H>::type h_t;
624                typedef typename phoenix::as_actor<I>::type i_t;
625                typedef typename phoenix::as_actor<J>::type j_t;
626                typedef phoenix::tuple<
627                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t
628                        > actor_tuple_t;
629
630                return init_closure_parser<DerivedT2, actor_tuple_t>(
631                        aux_derived(),
632                        actor_tuple_t(
633                            phoenix::as_actor<A>::convert(a),
634                            phoenix::as_actor<B>::convert(b),
635                            phoenix::as_actor<C>::convert(c),
636                            phoenix::as_actor<D>::convert(d),
637                            phoenix::as_actor<E>::convert(e),
638                            phoenix::as_actor<F>::convert(f),
639                            phoenix::as_actor<G>::convert(g),
640                            phoenix::as_actor<H>::convert(h),
641                            phoenix::as_actor<I>::convert(i),
642                            phoenix::as_actor<J>::convert(j)
643                        )
644                    );
645            }
646
647            template <
648                typename A, typename B, typename C, typename D, typename E,
649                typename F, typename G, typename H, typename I, typename J,
650                typename K
651            >
652            init_closure_parser<
653                DerivedT2,
654                phoenix::tuple<
655                    typename phoenix::as_actor<A>::type,
656                    typename phoenix::as_actor<B>::type,
657                    typename phoenix::as_actor<C>::type,
658                    typename phoenix::as_actor<D>::type,
659                    typename phoenix::as_actor<E>::type,
660                    typename phoenix::as_actor<F>::type,
661                    typename phoenix::as_actor<G>::type,
662                    typename phoenix::as_actor<H>::type,
663                    typename phoenix::as_actor<I>::type,
664                    typename phoenix::as_actor<J>::type,
665                    typename phoenix::as_actor<K>::type
666                >
667            >
668            operator()(
669                A const &a, B const &b, C const &c, D const &d, E const &e,
670                F const &f, G const &g, H const &h, I const &i, J const &j,
671                K const &k
672            ) const
673            {
674                typedef typename phoenix::as_actor<A>::type a_t;
675                typedef typename phoenix::as_actor<B>::type b_t;
676                typedef typename phoenix::as_actor<C>::type c_t;
677                typedef typename phoenix::as_actor<D>::type d_t;
678                typedef typename phoenix::as_actor<E>::type e_t;
679                typedef typename phoenix::as_actor<F>::type f_t;
680                typedef typename phoenix::as_actor<G>::type g_t;
681                typedef typename phoenix::as_actor<H>::type h_t;
682                typedef typename phoenix::as_actor<I>::type i_t;
683                typedef typename phoenix::as_actor<J>::type j_t;
684                typedef typename phoenix::as_actor<K>::type k_t;
685                typedef phoenix::tuple<
686                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
687                            k_t
688                        > actor_tuple_t;
689
690                return init_closure_parser<DerivedT2, actor_tuple_t>(
691                        aux_derived(),
692                        actor_tuple_t(
693                            phoenix::as_actor<A>::convert(a),
694                            phoenix::as_actor<B>::convert(b),
695                            phoenix::as_actor<C>::convert(c),
696                            phoenix::as_actor<D>::convert(d),
697                            phoenix::as_actor<E>::convert(e),
698                            phoenix::as_actor<F>::convert(f),
699                            phoenix::as_actor<G>::convert(g),
700                            phoenix::as_actor<H>::convert(h),
701                            phoenix::as_actor<I>::convert(i),
702                            phoenix::as_actor<J>::convert(j),
703                            phoenix::as_actor<K>::convert(k)
704                        )
705                    );
706            }
707
708            template <
709                typename A, typename B, typename C, typename D, typename E,
710                typename F, typename G, typename H, typename I, typename J,
711                typename K, typename L
712            >
713            init_closure_parser<
714                DerivedT2,
715                phoenix::tuple<
716                    typename phoenix::as_actor<A>::type,
717                    typename phoenix::as_actor<B>::type,
718                    typename phoenix::as_actor<C>::type,
719                    typename phoenix::as_actor<D>::type,
720                    typename phoenix::as_actor<E>::type,
721                    typename phoenix::as_actor<F>::type,
722                    typename phoenix::as_actor<G>::type,
723                    typename phoenix::as_actor<H>::type,
724                    typename phoenix::as_actor<I>::type,
725                    typename phoenix::as_actor<J>::type,
726                    typename phoenix::as_actor<K>::type,
727                    typename phoenix::as_actor<L>::type
728                >
729            >
730            operator()(
731                A const &a, B const &b, C const &c, D const &d, E const &e,
732                F const &f, G const &g, H const &h, I const &i, J const &j,
733                K const &k, L const &l
734            ) const
735            {
736                typedef typename phoenix::as_actor<A>::type a_t;
737                typedef typename phoenix::as_actor<B>::type b_t;
738                typedef typename phoenix::as_actor<C>::type c_t;
739                typedef typename phoenix::as_actor<D>::type d_t;
740                typedef typename phoenix::as_actor<E>::type e_t;
741                typedef typename phoenix::as_actor<F>::type f_t;
742                typedef typename phoenix::as_actor<G>::type g_t;
743                typedef typename phoenix::as_actor<H>::type h_t;
744                typedef typename phoenix::as_actor<I>::type i_t;
745                typedef typename phoenix::as_actor<J>::type j_t;
746                typedef typename phoenix::as_actor<K>::type k_t;
747                typedef typename phoenix::as_actor<L>::type l_t;
748                typedef phoenix::tuple<
749                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
750                            k_t, l_t
751                        > actor_tuple_t;
752
753                return init_closure_parser<DerivedT2, actor_tuple_t>(
754                        aux_derived(),
755                        actor_tuple_t(
756                            phoenix::as_actor<A>::convert(a),
757                            phoenix::as_actor<B>::convert(b),
758                            phoenix::as_actor<C>::convert(c),
759                            phoenix::as_actor<D>::convert(d),
760                            phoenix::as_actor<E>::convert(e),
761                            phoenix::as_actor<F>::convert(f),
762                            phoenix::as_actor<G>::convert(g),
763                            phoenix::as_actor<H>::convert(h),
764                            phoenix::as_actor<I>::convert(i),
765                            phoenix::as_actor<J>::convert(j),
766                            phoenix::as_actor<K>::convert(k),
767                            phoenix::as_actor<L>::convert(l)
768                        )
769                    );
770            }
771
772    #if BOOST_SPIRIT_CLOSURE_LIMIT > 12
773
774            template <
775                typename A, typename B, typename C, typename D, typename E,
776                typename F, typename G, typename H, typename I, typename J,
777                typename K, typename L, typename M
778            >
779            init_closure_parser<
780                DerivedT2,
781                phoenix::tuple<
782                    typename phoenix::as_actor<A>::type,
783                    typename phoenix::as_actor<B>::type,
784                    typename phoenix::as_actor<C>::type,
785                    typename phoenix::as_actor<D>::type,
786                    typename phoenix::as_actor<E>::type,
787                    typename phoenix::as_actor<F>::type,
788                    typename phoenix::as_actor<G>::type,
789                    typename phoenix::as_actor<H>::type,
790                    typename phoenix::as_actor<I>::type,
791                    typename phoenix::as_actor<J>::type,
792                    typename phoenix::as_actor<K>::type,
793                    typename phoenix::as_actor<L>::type,
794                    typename phoenix::as_actor<M>::type
795                >
796            >
797            operator()(
798                A const &a, B const &b, C const &c, D const &d, E const &e,
799                F const &f, G const &g, H const &h, I const &i, J const &j,
800                K const &k, L const &l, M const &m
801            ) const
802            {
803                typedef typename phoenix::as_actor<A>::type a_t;
804                typedef typename phoenix::as_actor<B>::type b_t;
805                typedef typename phoenix::as_actor<C>::type c_t;
806                typedef typename phoenix::as_actor<D>::type d_t;
807                typedef typename phoenix::as_actor<E>::type e_t;
808                typedef typename phoenix::as_actor<F>::type f_t;
809                typedef typename phoenix::as_actor<G>::type g_t;
810                typedef typename phoenix::as_actor<H>::type h_t;
811                typedef typename phoenix::as_actor<I>::type i_t;
812                typedef typename phoenix::as_actor<J>::type j_t;
813                typedef typename phoenix::as_actor<K>::type k_t;
814                typedef typename phoenix::as_actor<L>::type l_t;
815                typedef typename phoenix::as_actor<M>::type m_t;
816                typedef phoenix::tuple<
817                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
818                            k_t, l_t, m_t
819                        > actor_tuple_t;
820
821                return init_closure_parser<DerivedT2, actor_tuple_t>(
822                        aux_derived(),
823                        actor_tuple_t(
824                            phoenix::as_actor<A>::convert(a),
825                            phoenix::as_actor<B>::convert(b),
826                            phoenix::as_actor<C>::convert(c),
827                            phoenix::as_actor<D>::convert(d),
828                            phoenix::as_actor<E>::convert(e),
829                            phoenix::as_actor<F>::convert(f),
830                            phoenix::as_actor<G>::convert(g),
831                            phoenix::as_actor<H>::convert(h),
832                            phoenix::as_actor<I>::convert(i),
833                            phoenix::as_actor<J>::convert(j),
834                            phoenix::as_actor<K>::convert(k),
835                            phoenix::as_actor<L>::convert(l),
836                            phoenix::as_actor<M>::convert(m)
837                        )
838                    );
839            }
840
841            template <
842                typename A, typename B, typename C, typename D, typename E,
843                typename F, typename G, typename H, typename I, typename J,
844                typename K, typename L, typename M, typename N
845            >
846            init_closure_parser<
847                DerivedT2,
848                phoenix::tuple<
849                    typename phoenix::as_actor<A>::type,
850                    typename phoenix::as_actor<B>::type,
851                    typename phoenix::as_actor<C>::type,
852                    typename phoenix::as_actor<D>::type,
853                    typename phoenix::as_actor<E>::type,
854                    typename phoenix::as_actor<F>::type,
855                    typename phoenix::as_actor<G>::type,
856                    typename phoenix::as_actor<H>::type,
857                    typename phoenix::as_actor<I>::type,
858                    typename phoenix::as_actor<J>::type,
859                    typename phoenix::as_actor<K>::type,
860                    typename phoenix::as_actor<L>::type,
861                    typename phoenix::as_actor<M>::type,
862                    typename phoenix::as_actor<N>::type
863                >
864            >
865            operator()(
866                A const &a, B const &b, C const &c, D const &d, E const &e,
867                F const &f, G const &g, H const &h, I const &i, J const &j,
868                K const &k, L const &l, M const &m, N const &n
869            ) const
870            {
871                typedef typename phoenix::as_actor<A>::type a_t;
872                typedef typename phoenix::as_actor<B>::type b_t;
873                typedef typename phoenix::as_actor<C>::type c_t;
874                typedef typename phoenix::as_actor<D>::type d_t;
875                typedef typename phoenix::as_actor<E>::type e_t;
876                typedef typename phoenix::as_actor<F>::type f_t;
877                typedef typename phoenix::as_actor<G>::type g_t;
878                typedef typename phoenix::as_actor<H>::type h_t;
879                typedef typename phoenix::as_actor<I>::type i_t;
880                typedef typename phoenix::as_actor<J>::type j_t;
881                typedef typename phoenix::as_actor<K>::type k_t;
882                typedef typename phoenix::as_actor<L>::type l_t;
883                typedef typename phoenix::as_actor<M>::type m_t;
884                typedef typename phoenix::as_actor<N>::type n_t;
885                typedef phoenix::tuple<
886                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
887                            k_t, l_t, m_t, n_t
888                        > actor_tuple_t;
889
890                return init_closure_parser<DerivedT2, actor_tuple_t>(
891                        aux_derived(),
892                        actor_tuple_t(
893                            phoenix::as_actor<A>::convert(a),
894                            phoenix::as_actor<B>::convert(b),
895                            phoenix::as_actor<C>::convert(c),
896                            phoenix::as_actor<D>::convert(d),
897                            phoenix::as_actor<E>::convert(e),
898                            phoenix::as_actor<F>::convert(f),
899                            phoenix::as_actor<G>::convert(g),
900                            phoenix::as_actor<H>::convert(h),
901                            phoenix::as_actor<I>::convert(i),
902                            phoenix::as_actor<J>::convert(j),
903                            phoenix::as_actor<K>::convert(k),
904                            phoenix::as_actor<L>::convert(l),
905                            phoenix::as_actor<M>::convert(m),
906                            phoenix::as_actor<N>::convert(n)
907                        )
908                    );
909            }
910
911            template <
912                typename A, typename B, typename C, typename D, typename E,
913                typename F, typename G, typename H, typename I, typename J,
914                typename K, typename L, typename M, typename N, typename O
915            >
916            init_closure_parser<
917                DerivedT2,
918                phoenix::tuple<
919                    typename phoenix::as_actor<A>::type,
920                    typename phoenix::as_actor<B>::type,
921                    typename phoenix::as_actor<C>::type,
922                    typename phoenix::as_actor<D>::type,
923                    typename phoenix::as_actor<E>::type,
924                    typename phoenix::as_actor<F>::type,
925                    typename phoenix::as_actor<G>::type,
926                    typename phoenix::as_actor<H>::type,
927                    typename phoenix::as_actor<I>::type,
928                    typename phoenix::as_actor<J>::type,
929                    typename phoenix::as_actor<K>::type,
930                    typename phoenix::as_actor<L>::type,
931                    typename phoenix::as_actor<M>::type,
932                    typename phoenix::as_actor<N>::type,
933                    typename phoenix::as_actor<O>::type
934                >
935            >
936            operator()(
937                A const &a, B const &b, C const &c, D const &d, E const &e,
938                F const &f, G const &g, H const &h, I const &i, J const &j,
939                K const &k, L const &l, M const &m, N const &n, O const &o
940            ) const
941            {
942                typedef typename phoenix::as_actor<A>::type a_t;
943                typedef typename phoenix::as_actor<B>::type b_t;
944                typedef typename phoenix::as_actor<C>::type c_t;
945                typedef typename phoenix::as_actor<D>::type d_t;
946                typedef typename phoenix::as_actor<E>::type e_t;
947                typedef typename phoenix::as_actor<F>::type f_t;
948                typedef typename phoenix::as_actor<G>::type g_t;
949                typedef typename phoenix::as_actor<H>::type h_t;
950                typedef typename phoenix::as_actor<I>::type i_t;
951                typedef typename phoenix::as_actor<J>::type j_t;
952                typedef typename phoenix::as_actor<K>::type k_t;
953                typedef typename phoenix::as_actor<L>::type l_t;
954                typedef typename phoenix::as_actor<M>::type m_t;
955                typedef typename phoenix::as_actor<N>::type n_t;
956                typedef typename phoenix::as_actor<O>::type o_t;
957                typedef phoenix::tuple<
958                            a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t,
959                            k_t, l_t, m_t, n_t, o_t
960                        > actor_tuple_t;
961
962                return init_closure_parser<DerivedT2, actor_tuple_t>(
963                        aux_derived(),
964                        actor_tuple_t(
965                            phoenix::as_actor<A>::convert(a),
966                            phoenix::as_actor<B>::convert(b),
967                            phoenix::as_actor<C>::convert(c),
968                            phoenix::as_actor<D>::convert(d),
969                            phoenix::as_actor<E>::convert(e),
970                            phoenix::as_actor<F>::convert(f),
971                            phoenix::as_actor<G>::convert(g),
972                            phoenix::as_actor<H>::convert(h),
973                            phoenix::as_actor<I>::convert(i),
974                            phoenix::as_actor<J>::convert(j),
975                            phoenix::as_actor<K>::convert(k),
976                            phoenix::as_actor<L>::convert(l),
977                            phoenix::as_actor<M>::convert(m),
978                            phoenix::as_actor<N>::convert(n),
979                            phoenix::as_actor<O>::convert(o)
980                        )
981                    );
982            }
983
984    #endif
985    #endif
986    #endif
987    #endif
988        };
989
990        ~closure() {}
991    };
992
993    ///////////////////////////////////////////////////////////////////////////
994    //
995    //  overloads for chseq_p and str_p taking in phoenix actors
996    //
997    ///////////////////////////////////////////////////////////////////////////
998    template <typename ActorT>
999    struct container_begin
1000    {
1001        typedef container_begin<ActorT> self_t;
1002
1003        template <typename TupleT>
1004        struct result
1005        {
1006            typedef typename phoenix::actor_result<ActorT, TupleT>
1007                ::plain_type::iterator type;
1008        };
1009
1010        container_begin(ActorT actor_)
1011        : actor(actor_) {}
1012
1013        template <typename TupleT>
1014        typename phoenix::actor_result<self_t, TupleT>::type
1015        eval(TupleT const& /*args*/) const
1016        { return actor().begin(); }
1017
1018        ActorT actor;
1019    };
1020
1021    template <typename ActorT>
1022    struct container_end
1023    {
1024        typedef container_begin<ActorT> self_t;
1025
1026        template <typename TupleT>
1027        struct result
1028        {
1029            typedef typename phoenix::actor_result<ActorT, TupleT>
1030                ::plain_type::iterator type;
1031        };
1032
1033        container_end(ActorT actor_)
1034        : actor(actor_) {}
1035
1036        template <typename TupleT>
1037        typename phoenix::actor_result<self_t, TupleT>::type
1038        eval(TupleT const& /*args*/) const
1039        { return actor().end(); }
1040
1041        ActorT actor;
1042    };
1043
1044    template <typename BaseT>
1045    inline f_chseq<
1046        phoenix::actor<container_begin<phoenix::actor<BaseT> > >,
1047        phoenix::actor<container_end<phoenix::actor<BaseT> > >
1048    >
1049    f_chseq_p(phoenix::actor<BaseT> const& a)
1050    {
1051        typedef phoenix::actor<container_begin<phoenix::actor<BaseT> > >
1052            container_begin_t;
1053        typedef phoenix::actor<container_end<phoenix::actor<BaseT> > >
1054            container_end_t;
1055        typedef f_chseq<container_begin_t, container_end_t> result_t;
1056
1057        return result_t(container_begin_t(a), container_end_t(a));
1058    }
1059
1060    template <typename BaseT>
1061    inline f_strlit<
1062        phoenix::actor<container_begin<phoenix::actor<BaseT> > >,
1063        phoenix::actor<container_end<phoenix::actor<BaseT> > >
1064    >
1065    f_str_p(phoenix::actor<BaseT> const& a)
1066    {
1067        typedef phoenix::actor<container_begin<phoenix::actor<BaseT> > >
1068            container_begin_t;
1069        typedef phoenix::actor<container_end<phoenix::actor<BaseT> > >
1070            container_end_t;
1071        typedef f_strlit<container_begin_t, container_end_t> result_t;
1072
1073        return result_t(container_begin_t(a), container_end_t(a));
1074    }
1075
1076}} // namespace boost::spirit
1077
1078#endif
Note: See TracBrowser for help on using the repository browser.