You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
1083 lines
46 KiB
1083 lines
46 KiB
/*============================================================================= |
|
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
|
|
|