Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/boost_1_33_1/boost/spirit/attribute/closure.hpp @ 20

Last change on this file since 20 was 12, checked in by landauf, 18 years ago
added boost
File size: 45.0 KB

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: