| /*============================================================================= | |
| 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 |