| /*============================================================================= |
| Copyright (c) 2001-2003 Joel de Guzman |
| Copyright (c) 2002-2003 Hartmut Kaiser |
| http://spirit.sourceforge.net/ |
| |
| Distributed under the Boost Software License, Version 1.0. (See accompanying |
| file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| =============================================================================*/ |
| #ifndef BOOST_SPIRIT_CLOSURE_HPP |
| #define BOOST_SPIRIT_CLOSURE_HPP |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| #include <boost/spirit/home/classic/namespace.hpp> |
| #include <boost/spirit/home/classic/core/parser.hpp> |
| #include <boost/spirit/home/classic/core/composite/composite.hpp> |
| #include <boost/spirit/home/classic/core/non_terminal/parser_context.hpp> |
| #include <boost/spirit/home/classic/attribute/parametric.hpp> |
| #include <boost/spirit/home/classic/attribute/closure_context.hpp> |
| #include <boost/spirit/home/classic/attribute/closure_fwd.hpp> |
| |
| #include <boost/spirit/home/classic/phoenix/closures.hpp> |
| #include <boost/spirit/home/classic/phoenix/primitives.hpp> |
| #include <boost/spirit/home/classic/phoenix/casts.hpp> |
| #include <boost/spirit/home/classic/phoenix/operators.hpp> |
| #include <boost/spirit/home/classic/phoenix/tuple_helpers.hpp> |
| |
| #include <boost/static_assert.hpp> |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // Spirit predefined maximum closure limit. This limit defines the maximum |
| // number of elements a closure can hold. This number defaults to 3. The |
| // actual maximum is rounded up in multiples of 3. Thus, if this value |
| // is 4, the actual limit is 6. The ultimate maximum limit in this |
| // implementation is 15. |
| // |
| // It should NOT be greater than PHOENIX_LIMIT! |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| |
| #if !defined(BOOST_SPIRIT_CLOSURE_LIMIT) |
| #define BOOST_SPIRIT_CLOSURE_LIMIT PHOENIX_LIMIT |
| #endif |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| // |
| // ensure BOOST_SPIRIT_CLOSURE_LIMIT <= PHOENIX_LIMIT and SPIRIT_CLOSURE_LIMIT <= 15 |
| // |
| /////////////////////////////////////////////////////////////////////////////// |
| BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLOSURE_LIMIT <= PHOENIX_LIMIT); |
| BOOST_STATIC_ASSERT(BOOST_SPIRIT_CLOSURE_LIMIT <= 15); |
| |
| /////////////////////////////////////////////////////////////////////////////// |
| namespace boost { namespace spirit { |
| |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // closure_context class |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| template <typename ClosureT> |
| class closure_context : public parser_context_base |
| { |
| public: |
| |
| typedef typename ::phoenix::tuple_element<0, |
| typename ClosureT::tuple_t>::type attr_t; |
| typedef ClosureT base_t; |
| typedef closure_context_linker<closure_context<ClosureT> > |
| context_linker_t; |
| |
| closure_context(ClosureT const& clos) |
| : frame(clos) {} |
| |
| ~closure_context() {} |
| |
| template <typename ParserT, typename ScannerT> |
| void pre_parse(ParserT const&, ScannerT const&) {} |
| |
| template <typename ResultT, typename ParserT, typename ScannerT> |
| ResultT& post_parse(ResultT& hit, ParserT const&, ScannerT const&) |
| { hit.value(frame[::phoenix::tuple_index<0>()]); return hit; } |
| |
| private: |
| |
| ::phoenix::closure_frame<typename ClosureT::phoenix_closure_t> frame; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // init_closure_context class |
| // |
| // The init_closure_context class is a special parser context type |
| // which additionally initializes a closure contained in the derived |
| // parser with values from a given tuple. Please note, that this |
| // given tuple does not contain the required values directly, it |
| // contains phoenix::actor objects. These actors have to be |
| // dereferenced to gain the values to be used for initialization |
| // (this is done by the help of the phoenix::convert_actors<> |
| // template). |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| |
| template <typename ClosureT> |
| class init_closure_context : public parser_context_base |
| { |
| typedef typename ClosureT::tuple_t tuple_t; |
| typedef typename ClosureT::closure_t closure_t; |
| |
| public: |
| |
| init_closure_context(ClosureT const& clos) |
| : frame(clos.subject(), ::phoenix::convert_actors<tuple_t>(clos.init)) {} |
| |
| ~init_closure_context() {} |
| |
| template <typename ParserT, typename ScannerT> |
| void pre_parse(ParserT const& /*p*/, ScannerT const&) {} |
| |
| template <typename ResultT, typename ParserT, typename ScannerT> |
| ResultT& post_parse(ResultT& hit, ParserT const&, ScannerT const&) |
| { hit.value(frame[::phoenix::tuple_index<0>()]); return hit; } |
| |
| private: |
| |
| ::phoenix::closure_frame<closure_t> frame; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // init_closure_parser class |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| template <typename ParserT, typename ActorTupleT> |
| struct init_closure_parser |
| : public unary<ParserT, parser<init_closure_parser<ParserT, ActorTupleT> > > |
| { |
| typedef init_closure_parser<ParserT, ActorTupleT> self_t; |
| typedef unary<ParserT, parser<self_t> > base_t; |
| typedef typename ParserT::phoenix_closure_t closure_t; |
| typedef typename ParserT::tuple_t tuple_t; |
| typedef typename ::phoenix::tuple_element<0, tuple_t>::type attr_t; |
| |
| template <typename ScannerT> |
| struct result |
| { |
| typedef typename match_result<ScannerT, attr_t>::type type; |
| }; |
| |
| init_closure_parser(ParserT const& p, ActorTupleT const& init_) |
| : base_t(p), init(init_) {} |
| |
| template <typename ScannerT> |
| typename parser_result<self_t, ScannerT>::type |
| parse_main(ScannerT const& scan) const |
| { |
| return this->subject().parse_main(scan); |
| } |
| |
| template <typename ScannerT> |
| typename parser_result<self_t, ScannerT>::type |
| parse(ScannerT const& scan) const |
| { |
| typedef init_closure_context<self_t> init_context_t; |
| typedef parser_scanner_linker<ScannerT> scanner_t; |
| typedef closure_context_linker<init_context_t> context_t; |
| typedef typename parser_result<self_t, ScannerT>::type result_t; |
| BOOST_SPIRIT_CONTEXT_PARSE( |
| scan, *this, scanner_t, context_t, result_t); |
| } |
| |
| ActorTupleT init; |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // closure class |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| template < |
| typename DerivedT |
| , typename T0 |
| , typename T1 |
| , typename T2 |
| |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 3 |
| , typename T3 |
| , typename T4 |
| , typename T5 |
| |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 6 |
| , typename T6 |
| , typename T7 |
| , typename T8 |
| |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 9 |
| , typename T9 |
| , typename T10 |
| , typename T11 |
| |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 12 |
| , typename T12 |
| , typename T13 |
| , typename T14 |
| #endif |
| #endif |
| #endif |
| #endif |
| > |
| struct closure : |
| public ::phoenix::closure< |
| T0, T1, T2 |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 3 |
| , T3, T4, T5 |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 6 |
| , T6, T7, T8 |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 9 |
| , T9, T10, T11 |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 12 |
| , T12, T13, T14 |
| #endif |
| #endif |
| #endif |
| #endif |
| > |
| { |
| typedef ::phoenix::closure< |
| T0, T1, T2 |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 3 |
| , T3, T4, T5 |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 6 |
| , T6, T7, T8 |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 9 |
| , T9, T10, T11 |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 12 |
| , T12, T13, T14 |
| #endif |
| #endif |
| #endif |
| #endif |
| > phoenix_closure_t; |
| |
| typedef closure_context<DerivedT> context_t; |
| |
| template <typename DerivedT2> |
| struct aux |
| { |
| DerivedT2& aux_derived() |
| { return *static_cast<DerivedT2*>(this); } |
| |
| DerivedT2 const& aux_derived() const |
| { return *static_cast<DerivedT2 const*>(this); } |
| |
| // initialization functions |
| template <typename A> |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type |
| > |
| > |
| operator()(A const &a) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef ::phoenix::tuple<a_t> actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a) |
| ) |
| ); |
| } |
| |
| template <typename A, typename B> |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type, |
| typename ::phoenix::as_actor<B>::type |
| > |
| > |
| operator()(A const &a, B const &b) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef typename ::phoenix::as_actor<B>::type b_t; |
| typedef ::phoenix::tuple<a_t, b_t> actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a), |
| ::phoenix::as_actor<B>::convert(b) |
| ) |
| ); |
| } |
| |
| template <typename A, typename B, typename C> |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type, |
| typename ::phoenix::as_actor<B>::type, |
| typename ::phoenix::as_actor<C>::type |
| > |
| > |
| operator()(A const &a, B const &b, C const &c) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef typename ::phoenix::as_actor<B>::type b_t; |
| typedef typename ::phoenix::as_actor<C>::type c_t; |
| typedef ::phoenix::tuple<a_t, b_t, c_t> actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a), |
| ::phoenix::as_actor<B>::convert(b), |
| ::phoenix::as_actor<C>::convert(c) |
| ) |
| ); |
| } |
| |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 3 |
| |
| template < |
| typename A, typename B, typename C, typename D |
| > |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type, |
| typename ::phoenix::as_actor<B>::type, |
| typename ::phoenix::as_actor<C>::type, |
| typename ::phoenix::as_actor<D>::type |
| > |
| > |
| operator()( |
| A const &a, B const &b, C const &c, D const &d |
| ) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef typename ::phoenix::as_actor<B>::type b_t; |
| typedef typename ::phoenix::as_actor<C>::type c_t; |
| typedef typename ::phoenix::as_actor<D>::type d_t; |
| typedef ::phoenix::tuple< |
| a_t, b_t, c_t, d_t |
| > actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a), |
| ::phoenix::as_actor<B>::convert(b), |
| ::phoenix::as_actor<C>::convert(c), |
| ::phoenix::as_actor<D>::convert(d) |
| ) |
| ); |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E |
| > |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type, |
| typename ::phoenix::as_actor<B>::type, |
| typename ::phoenix::as_actor<C>::type, |
| typename ::phoenix::as_actor<D>::type, |
| typename ::phoenix::as_actor<E>::type |
| > |
| > |
| operator()( |
| A const &a, B const &b, C const &c, D const &d, E const &e |
| ) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef typename ::phoenix::as_actor<B>::type b_t; |
| typedef typename ::phoenix::as_actor<C>::type c_t; |
| typedef typename ::phoenix::as_actor<D>::type d_t; |
| typedef typename ::phoenix::as_actor<E>::type e_t; |
| typedef ::phoenix::tuple< |
| a_t, b_t, c_t, d_t, e_t |
| > actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a), |
| ::phoenix::as_actor<B>::convert(b), |
| ::phoenix::as_actor<C>::convert(c), |
| ::phoenix::as_actor<D>::convert(d), |
| ::phoenix::as_actor<E>::convert(e) |
| ) |
| ); |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F |
| > |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type, |
| typename ::phoenix::as_actor<B>::type, |
| typename ::phoenix::as_actor<C>::type, |
| typename ::phoenix::as_actor<D>::type, |
| typename ::phoenix::as_actor<E>::type, |
| typename ::phoenix::as_actor<F>::type |
| > |
| > |
| operator()( |
| A const &a, B const &b, C const &c, D const &d, E const &e, |
| F const &f |
| ) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef typename ::phoenix::as_actor<B>::type b_t; |
| typedef typename ::phoenix::as_actor<C>::type c_t; |
| typedef typename ::phoenix::as_actor<D>::type d_t; |
| typedef typename ::phoenix::as_actor<E>::type e_t; |
| typedef typename ::phoenix::as_actor<F>::type f_t; |
| typedef ::phoenix::tuple< |
| a_t, b_t, c_t, d_t, e_t, f_t |
| > actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a), |
| ::phoenix::as_actor<B>::convert(b), |
| ::phoenix::as_actor<C>::convert(c), |
| ::phoenix::as_actor<D>::convert(d), |
| ::phoenix::as_actor<E>::convert(e), |
| ::phoenix::as_actor<F>::convert(f) |
| ) |
| ); |
| } |
| |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 6 |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G |
| > |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type, |
| typename ::phoenix::as_actor<B>::type, |
| typename ::phoenix::as_actor<C>::type, |
| typename ::phoenix::as_actor<D>::type, |
| typename ::phoenix::as_actor<E>::type, |
| typename ::phoenix::as_actor<F>::type, |
| typename ::phoenix::as_actor<G>::type |
| > |
| > |
| operator()( |
| A const &a, B const &b, C const &c, D const &d, E const &e, |
| F const &f, G const &g |
| ) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef typename ::phoenix::as_actor<B>::type b_t; |
| typedef typename ::phoenix::as_actor<C>::type c_t; |
| typedef typename ::phoenix::as_actor<D>::type d_t; |
| typedef typename ::phoenix::as_actor<E>::type e_t; |
| typedef typename ::phoenix::as_actor<F>::type f_t; |
| typedef typename ::phoenix::as_actor<G>::type g_t; |
| typedef ::phoenix::tuple< |
| a_t, b_t, c_t, d_t, e_t, f_t, g_t |
| > actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a), |
| ::phoenix::as_actor<B>::convert(b), |
| ::phoenix::as_actor<C>::convert(c), |
| ::phoenix::as_actor<D>::convert(d), |
| ::phoenix::as_actor<E>::convert(e), |
| ::phoenix::as_actor<F>::convert(f), |
| ::phoenix::as_actor<G>::convert(g) |
| ) |
| ); |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H |
| > |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type, |
| typename ::phoenix::as_actor<B>::type, |
| typename ::phoenix::as_actor<C>::type, |
| typename ::phoenix::as_actor<D>::type, |
| typename ::phoenix::as_actor<E>::type, |
| typename ::phoenix::as_actor<F>::type, |
| typename ::phoenix::as_actor<G>::type, |
| typename ::phoenix::as_actor<H>::type |
| > |
| > |
| operator()( |
| A const &a, B const &b, C const &c, D const &d, E const &e, |
| F const &f, G const &g, H const &h |
| ) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef typename ::phoenix::as_actor<B>::type b_t; |
| typedef typename ::phoenix::as_actor<C>::type c_t; |
| typedef typename ::phoenix::as_actor<D>::type d_t; |
| typedef typename ::phoenix::as_actor<E>::type e_t; |
| typedef typename ::phoenix::as_actor<F>::type f_t; |
| typedef typename ::phoenix::as_actor<G>::type g_t; |
| typedef typename ::phoenix::as_actor<H>::type h_t; |
| typedef ::phoenix::tuple< |
| a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t |
| > actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a), |
| ::phoenix::as_actor<B>::convert(b), |
| ::phoenix::as_actor<C>::convert(c), |
| ::phoenix::as_actor<D>::convert(d), |
| ::phoenix::as_actor<E>::convert(e), |
| ::phoenix::as_actor<F>::convert(f), |
| ::phoenix::as_actor<G>::convert(g), |
| ::phoenix::as_actor<H>::convert(h) |
| ) |
| ); |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I |
| > |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type, |
| typename ::phoenix::as_actor<B>::type, |
| typename ::phoenix::as_actor<C>::type, |
| typename ::phoenix::as_actor<D>::type, |
| typename ::phoenix::as_actor<E>::type, |
| typename ::phoenix::as_actor<F>::type, |
| typename ::phoenix::as_actor<G>::type, |
| typename ::phoenix::as_actor<H>::type, |
| typename ::phoenix::as_actor<I>::type |
| > |
| > |
| operator()( |
| A const &a, B const &b, C const &c, D const &d, E const &e, |
| F const &f, G const &g, H const &h, I const &i |
| ) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef typename ::phoenix::as_actor<B>::type b_t; |
| typedef typename ::phoenix::as_actor<C>::type c_t; |
| typedef typename ::phoenix::as_actor<D>::type d_t; |
| typedef typename ::phoenix::as_actor<E>::type e_t; |
| typedef typename ::phoenix::as_actor<F>::type f_t; |
| typedef typename ::phoenix::as_actor<G>::type g_t; |
| typedef typename ::phoenix::as_actor<H>::type h_t; |
| typedef typename ::phoenix::as_actor<I>::type i_t; |
| typedef ::phoenix::tuple< |
| a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t |
| > actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a), |
| ::phoenix::as_actor<B>::convert(b), |
| ::phoenix::as_actor<C>::convert(c), |
| ::phoenix::as_actor<D>::convert(d), |
| ::phoenix::as_actor<E>::convert(e), |
| ::phoenix::as_actor<F>::convert(f), |
| ::phoenix::as_actor<G>::convert(g), |
| ::phoenix::as_actor<H>::convert(h), |
| ::phoenix::as_actor<I>::convert(i) |
| ) |
| ); |
| } |
| |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 9 |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J |
| > |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type, |
| typename ::phoenix::as_actor<B>::type, |
| typename ::phoenix::as_actor<C>::type, |
| typename ::phoenix::as_actor<D>::type, |
| typename ::phoenix::as_actor<E>::type, |
| typename ::phoenix::as_actor<F>::type, |
| typename ::phoenix::as_actor<G>::type, |
| typename ::phoenix::as_actor<H>::type, |
| typename ::phoenix::as_actor<I>::type, |
| typename ::phoenix::as_actor<J>::type |
| > |
| > |
| operator()( |
| A const &a, B const &b, C const &c, D const &d, E const &e, |
| F const &f, G const &g, H const &h, I const &i, J const &j |
| ) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef typename ::phoenix::as_actor<B>::type b_t; |
| typedef typename ::phoenix::as_actor<C>::type c_t; |
| typedef typename ::phoenix::as_actor<D>::type d_t; |
| typedef typename ::phoenix::as_actor<E>::type e_t; |
| typedef typename ::phoenix::as_actor<F>::type f_t; |
| typedef typename ::phoenix::as_actor<G>::type g_t; |
| typedef typename ::phoenix::as_actor<H>::type h_t; |
| typedef typename ::phoenix::as_actor<I>::type i_t; |
| typedef typename ::phoenix::as_actor<J>::type j_t; |
| typedef ::phoenix::tuple< |
| a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t |
| > actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a), |
| ::phoenix::as_actor<B>::convert(b), |
| ::phoenix::as_actor<C>::convert(c), |
| ::phoenix::as_actor<D>::convert(d), |
| ::phoenix::as_actor<E>::convert(e), |
| ::phoenix::as_actor<F>::convert(f), |
| ::phoenix::as_actor<G>::convert(g), |
| ::phoenix::as_actor<H>::convert(h), |
| ::phoenix::as_actor<I>::convert(i), |
| ::phoenix::as_actor<J>::convert(j) |
| ) |
| ); |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K |
| > |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type, |
| typename ::phoenix::as_actor<B>::type, |
| typename ::phoenix::as_actor<C>::type, |
| typename ::phoenix::as_actor<D>::type, |
| typename ::phoenix::as_actor<E>::type, |
| typename ::phoenix::as_actor<F>::type, |
| typename ::phoenix::as_actor<G>::type, |
| typename ::phoenix::as_actor<H>::type, |
| typename ::phoenix::as_actor<I>::type, |
| typename ::phoenix::as_actor<J>::type, |
| typename ::phoenix::as_actor<K>::type |
| > |
| > |
| operator()( |
| A const &a, B const &b, C const &c, D const &d, E const &e, |
| F const &f, G const &g, H const &h, I const &i, J const &j, |
| K const &k |
| ) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef typename ::phoenix::as_actor<B>::type b_t; |
| typedef typename ::phoenix::as_actor<C>::type c_t; |
| typedef typename ::phoenix::as_actor<D>::type d_t; |
| typedef typename ::phoenix::as_actor<E>::type e_t; |
| typedef typename ::phoenix::as_actor<F>::type f_t; |
| typedef typename ::phoenix::as_actor<G>::type g_t; |
| typedef typename ::phoenix::as_actor<H>::type h_t; |
| typedef typename ::phoenix::as_actor<I>::type i_t; |
| typedef typename ::phoenix::as_actor<J>::type j_t; |
| typedef typename ::phoenix::as_actor<K>::type k_t; |
| typedef ::phoenix::tuple< |
| a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, |
| k_t |
| > actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a), |
| ::phoenix::as_actor<B>::convert(b), |
| ::phoenix::as_actor<C>::convert(c), |
| ::phoenix::as_actor<D>::convert(d), |
| ::phoenix::as_actor<E>::convert(e), |
| ::phoenix::as_actor<F>::convert(f), |
| ::phoenix::as_actor<G>::convert(g), |
| ::phoenix::as_actor<H>::convert(h), |
| ::phoenix::as_actor<I>::convert(i), |
| ::phoenix::as_actor<J>::convert(j), |
| ::phoenix::as_actor<K>::convert(k) |
| ) |
| ); |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L |
| > |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type, |
| typename ::phoenix::as_actor<B>::type, |
| typename ::phoenix::as_actor<C>::type, |
| typename ::phoenix::as_actor<D>::type, |
| typename ::phoenix::as_actor<E>::type, |
| typename ::phoenix::as_actor<F>::type, |
| typename ::phoenix::as_actor<G>::type, |
| typename ::phoenix::as_actor<H>::type, |
| typename ::phoenix::as_actor<I>::type, |
| typename ::phoenix::as_actor<J>::type, |
| typename ::phoenix::as_actor<K>::type, |
| typename ::phoenix::as_actor<L>::type |
| > |
| > |
| operator()( |
| A const &a, B const &b, C const &c, D const &d, E const &e, |
| F const &f, G const &g, H const &h, I const &i, J const &j, |
| K const &k, L const &l |
| ) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef typename ::phoenix::as_actor<B>::type b_t; |
| typedef typename ::phoenix::as_actor<C>::type c_t; |
| typedef typename ::phoenix::as_actor<D>::type d_t; |
| typedef typename ::phoenix::as_actor<E>::type e_t; |
| typedef typename ::phoenix::as_actor<F>::type f_t; |
| typedef typename ::phoenix::as_actor<G>::type g_t; |
| typedef typename ::phoenix::as_actor<H>::type h_t; |
| typedef typename ::phoenix::as_actor<I>::type i_t; |
| typedef typename ::phoenix::as_actor<J>::type j_t; |
| typedef typename ::phoenix::as_actor<K>::type k_t; |
| typedef typename ::phoenix::as_actor<L>::type l_t; |
| typedef ::phoenix::tuple< |
| a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, |
| k_t, l_t |
| > actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a), |
| ::phoenix::as_actor<B>::convert(b), |
| ::phoenix::as_actor<C>::convert(c), |
| ::phoenix::as_actor<D>::convert(d), |
| ::phoenix::as_actor<E>::convert(e), |
| ::phoenix::as_actor<F>::convert(f), |
| ::phoenix::as_actor<G>::convert(g), |
| ::phoenix::as_actor<H>::convert(h), |
| ::phoenix::as_actor<I>::convert(i), |
| ::phoenix::as_actor<J>::convert(j), |
| ::phoenix::as_actor<K>::convert(k), |
| ::phoenix::as_actor<L>::convert(l) |
| ) |
| ); |
| } |
| |
| #if BOOST_SPIRIT_CLOSURE_LIMIT > 12 |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L, typename M |
| > |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type, |
| typename ::phoenix::as_actor<B>::type, |
| typename ::phoenix::as_actor<C>::type, |
| typename ::phoenix::as_actor<D>::type, |
| typename ::phoenix::as_actor<E>::type, |
| typename ::phoenix::as_actor<F>::type, |
| typename ::phoenix::as_actor<G>::type, |
| typename ::phoenix::as_actor<H>::type, |
| typename ::phoenix::as_actor<I>::type, |
| typename ::phoenix::as_actor<J>::type, |
| typename ::phoenix::as_actor<K>::type, |
| typename ::phoenix::as_actor<L>::type, |
| typename ::phoenix::as_actor<M>::type |
| > |
| > |
| operator()( |
| A const &a, B const &b, C const &c, D const &d, E const &e, |
| F const &f, G const &g, H const &h, I const &i, J const &j, |
| K const &k, L const &l, M const &m |
| ) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef typename ::phoenix::as_actor<B>::type b_t; |
| typedef typename ::phoenix::as_actor<C>::type c_t; |
| typedef typename ::phoenix::as_actor<D>::type d_t; |
| typedef typename ::phoenix::as_actor<E>::type e_t; |
| typedef typename ::phoenix::as_actor<F>::type f_t; |
| typedef typename ::phoenix::as_actor<G>::type g_t; |
| typedef typename ::phoenix::as_actor<H>::type h_t; |
| typedef typename ::phoenix::as_actor<I>::type i_t; |
| typedef typename ::phoenix::as_actor<J>::type j_t; |
| typedef typename ::phoenix::as_actor<K>::type k_t; |
| typedef typename ::phoenix::as_actor<L>::type l_t; |
| typedef typename ::phoenix::as_actor<M>::type m_t; |
| typedef ::phoenix::tuple< |
| a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, |
| k_t, l_t, m_t |
| > actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a), |
| ::phoenix::as_actor<B>::convert(b), |
| ::phoenix::as_actor<C>::convert(c), |
| ::phoenix::as_actor<D>::convert(d), |
| ::phoenix::as_actor<E>::convert(e), |
| ::phoenix::as_actor<F>::convert(f), |
| ::phoenix::as_actor<G>::convert(g), |
| ::phoenix::as_actor<H>::convert(h), |
| ::phoenix::as_actor<I>::convert(i), |
| ::phoenix::as_actor<J>::convert(j), |
| ::phoenix::as_actor<K>::convert(k), |
| ::phoenix::as_actor<L>::convert(l), |
| ::phoenix::as_actor<M>::convert(m) |
| ) |
| ); |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L, typename M, typename N |
| > |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type, |
| typename ::phoenix::as_actor<B>::type, |
| typename ::phoenix::as_actor<C>::type, |
| typename ::phoenix::as_actor<D>::type, |
| typename ::phoenix::as_actor<E>::type, |
| typename ::phoenix::as_actor<F>::type, |
| typename ::phoenix::as_actor<G>::type, |
| typename ::phoenix::as_actor<H>::type, |
| typename ::phoenix::as_actor<I>::type, |
| typename ::phoenix::as_actor<J>::type, |
| typename ::phoenix::as_actor<K>::type, |
| typename ::phoenix::as_actor<L>::type, |
| typename ::phoenix::as_actor<M>::type, |
| typename ::phoenix::as_actor<N>::type |
| > |
| > |
| operator()( |
| A const &a, B const &b, C const &c, D const &d, E const &e, |
| F const &f, G const &g, H const &h, I const &i, J const &j, |
| K const &k, L const &l, M const &m, N const &n |
| ) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef typename ::phoenix::as_actor<B>::type b_t; |
| typedef typename ::phoenix::as_actor<C>::type c_t; |
| typedef typename ::phoenix::as_actor<D>::type d_t; |
| typedef typename ::phoenix::as_actor<E>::type e_t; |
| typedef typename ::phoenix::as_actor<F>::type f_t; |
| typedef typename ::phoenix::as_actor<G>::type g_t; |
| typedef typename ::phoenix::as_actor<H>::type h_t; |
| typedef typename ::phoenix::as_actor<I>::type i_t; |
| typedef typename ::phoenix::as_actor<J>::type j_t; |
| typedef typename ::phoenix::as_actor<K>::type k_t; |
| typedef typename ::phoenix::as_actor<L>::type l_t; |
| typedef typename ::phoenix::as_actor<M>::type m_t; |
| typedef typename ::phoenix::as_actor<N>::type n_t; |
| typedef ::phoenix::tuple< |
| a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, |
| k_t, l_t, m_t, n_t |
| > actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a), |
| ::phoenix::as_actor<B>::convert(b), |
| ::phoenix::as_actor<C>::convert(c), |
| ::phoenix::as_actor<D>::convert(d), |
| ::phoenix::as_actor<E>::convert(e), |
| ::phoenix::as_actor<F>::convert(f), |
| ::phoenix::as_actor<G>::convert(g), |
| ::phoenix::as_actor<H>::convert(h), |
| ::phoenix::as_actor<I>::convert(i), |
| ::phoenix::as_actor<J>::convert(j), |
| ::phoenix::as_actor<K>::convert(k), |
| ::phoenix::as_actor<L>::convert(l), |
| ::phoenix::as_actor<M>::convert(m), |
| ::phoenix::as_actor<N>::convert(n) |
| ) |
| ); |
| } |
| |
| template < |
| typename A, typename B, typename C, typename D, typename E, |
| typename F, typename G, typename H, typename I, typename J, |
| typename K, typename L, typename M, typename N, typename O |
| > |
| init_closure_parser< |
| DerivedT2, |
| ::phoenix::tuple< |
| typename ::phoenix::as_actor<A>::type, |
| typename ::phoenix::as_actor<B>::type, |
| typename ::phoenix::as_actor<C>::type, |
| typename ::phoenix::as_actor<D>::type, |
| typename ::phoenix::as_actor<E>::type, |
| typename ::phoenix::as_actor<F>::type, |
| typename ::phoenix::as_actor<G>::type, |
| typename ::phoenix::as_actor<H>::type, |
| typename ::phoenix::as_actor<I>::type, |
| typename ::phoenix::as_actor<J>::type, |
| typename ::phoenix::as_actor<K>::type, |
| typename ::phoenix::as_actor<L>::type, |
| typename ::phoenix::as_actor<M>::type, |
| typename ::phoenix::as_actor<N>::type, |
| typename ::phoenix::as_actor<O>::type |
| > |
| > |
| operator()( |
| A const &a, B const &b, C const &c, D const &d, E const &e, |
| F const &f, G const &g, H const &h, I const &i, J const &j, |
| K const &k, L const &l, M const &m, N const &n, O const &o |
| ) const |
| { |
| typedef typename ::phoenix::as_actor<A>::type a_t; |
| typedef typename ::phoenix::as_actor<B>::type b_t; |
| typedef typename ::phoenix::as_actor<C>::type c_t; |
| typedef typename ::phoenix::as_actor<D>::type d_t; |
| typedef typename ::phoenix::as_actor<E>::type e_t; |
| typedef typename ::phoenix::as_actor<F>::type f_t; |
| typedef typename ::phoenix::as_actor<G>::type g_t; |
| typedef typename ::phoenix::as_actor<H>::type h_t; |
| typedef typename ::phoenix::as_actor<I>::type i_t; |
| typedef typename ::phoenix::as_actor<J>::type j_t; |
| typedef typename ::phoenix::as_actor<K>::type k_t; |
| typedef typename ::phoenix::as_actor<L>::type l_t; |
| typedef typename ::phoenix::as_actor<M>::type m_t; |
| typedef typename ::phoenix::as_actor<N>::type n_t; |
| typedef typename ::phoenix::as_actor<O>::type o_t; |
| typedef ::phoenix::tuple< |
| a_t, b_t, c_t, d_t, e_t, f_t, g_t, h_t, i_t, j_t, |
| k_t, l_t, m_t, n_t, o_t |
| > actor_tuple_t; |
| |
| return init_closure_parser<DerivedT2, actor_tuple_t>( |
| aux_derived(), |
| actor_tuple_t( |
| ::phoenix::as_actor<A>::convert(a), |
| ::phoenix::as_actor<B>::convert(b), |
| ::phoenix::as_actor<C>::convert(c), |
| ::phoenix::as_actor<D>::convert(d), |
| ::phoenix::as_actor<E>::convert(e), |
| ::phoenix::as_actor<F>::convert(f), |
| ::phoenix::as_actor<G>::convert(g), |
| ::phoenix::as_actor<H>::convert(h), |
| ::phoenix::as_actor<I>::convert(i), |
| ::phoenix::as_actor<J>::convert(j), |
| ::phoenix::as_actor<K>::convert(k), |
| ::phoenix::as_actor<L>::convert(l), |
| ::phoenix::as_actor<M>::convert(m), |
| ::phoenix::as_actor<N>::convert(n), |
| ::phoenix::as_actor<O>::convert(o) |
| ) |
| ); |
| } |
| |
| #endif |
| #endif |
| #endif |
| #endif |
| }; |
| |
| ~closure() {} |
| }; |
| |
| /////////////////////////////////////////////////////////////////////////// |
| // |
| // overloads for chseq_p and str_p taking in phoenix actors |
| // |
| /////////////////////////////////////////////////////////////////////////// |
| template <typename ActorT> |
| struct container_begin |
| { |
| typedef container_begin<ActorT> self_t; |
| |
| template <typename TupleT> |
| struct result |
| { |
| typedef typename ::phoenix::actor_result<ActorT, TupleT> |
| ::plain_type::iterator type; |
| }; |
| |
| container_begin(ActorT actor_) |
| : actor(actor_) {} |
| |
| template <typename TupleT> |
| typename ::phoenix::actor_result<self_t, TupleT>::type |
| eval(TupleT const& /*args*/) const |
| { return actor().begin(); } |
| |
| ActorT actor; |
| }; |
| |
| template <typename ActorT> |
| struct container_end |
| { |
| typedef container_begin<ActorT> self_t; |
| |
| template <typename TupleT> |
| struct result |
| { |
| typedef typename ::phoenix::actor_result<ActorT, TupleT> |
| ::plain_type::iterator type; |
| }; |
| |
| container_end(ActorT actor_) |
| : actor(actor_) {} |
| |
| template <typename TupleT> |
| typename ::phoenix::actor_result<self_t, TupleT>::type |
| eval(TupleT const& /*args*/) const |
| { return actor().end(); } |
| |
| ActorT actor; |
| }; |
| |
| template <typename BaseT> |
| inline f_chseq< |
| ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >, |
| ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > > |
| > |
| f_chseq_p(::phoenix::actor<BaseT> const& a) |
| { |
| typedef ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > > |
| container_begin_t; |
| typedef ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > > |
| container_end_t; |
| typedef f_chseq<container_begin_t, container_end_t> result_t; |
| |
| return result_t(container_begin_t(a), container_end_t(a)); |
| } |
| |
| template <typename BaseT> |
| inline f_strlit< |
| ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > >, |
| ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > > |
| > |
| f_str_p(::phoenix::actor<BaseT> const& a) |
| { |
| typedef ::phoenix::actor<container_begin< ::phoenix::actor<BaseT> > > |
| container_begin_t; |
| typedef ::phoenix::actor<container_end< ::phoenix::actor<BaseT> > > |
| container_end_t; |
| typedef f_strlit<container_begin_t, container_end_t> result_t; |
| |
| return result_t(container_begin_t(a), container_end_t(a)); |
| } |
| |
| BOOST_SPIRIT_CLASSIC_NAMESPACE_END |
| |
| }} // namespace BOOST_SPIRIT_CLASSIC_NS |
| |
| #endif |