rule_parser.hpp File Reference

#include <boost/config.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/call_traits.hpp>
#include <boost/typeof/typeof.hpp>
#include <boost/spirit/home/classic/namespace.hpp>
#include <boost/spirit/home/classic/core/parser.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/seq/seq.hpp>
#include <boost/preprocessor/seq/for_each_i.hpp>
#include <boost/preprocessor/tuple/eat.hpp>
#include <boost/preprocessor/tuple/to_seq.hpp>
#include <boost/preprocessor/array/size.hpp>
#include <boost/preprocessor/control/if.hpp>
#include <boost/preprocessor/control/iif.hpp>
#include <boost/preprocessor/control/expr_iif.hpp>
#include <boost/preprocessor/logical/or.hpp>
#include <boost/preprocessor/logical/nor.hpp>
#include <boost/preprocessor/logical/not.hpp>
#include <boost/preprocessor/logical/compl.hpp>
#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/arithmetic/dec.hpp>
#include <boost/preprocessor/arithmetic/add.hpp>
#include <boost/preprocessor/detail/is_unary.hpp>
#include <boost/preprocessor/detail/is_binary.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/repetition/enum_params.hpp>
#include <boost/preprocessor/repetition/enum_binary_params.hpp>
#include <boost/preprocessor/repetition/enum_shifted_params.hpp>
#include <boost/preprocessor/repetition/enum_trailing_params.hpp>
#include <boost/preprocessor/punctuation/comma.hpp>
#include <boost/preprocessor/punctuation/comma_if.hpp>
#include <boost/preprocessor/facilities/empty.hpp>
#include <boost/preprocessor/facilities/identity.hpp>
#include <boost/preprocessor/facilities/intercept.hpp>
#include <BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()>

Include dependency graph for rule_parser.hpp:

This graph shows which files directly or indirectly include this file:

Classes
class	boost::spirit::parser_reference< P >
class	boost::spirit::parser_reference< P >
struct	boost::spirit::parser_reference< P >::result< ScannerT >
struct	boost::spirit::type_of::nop_functor
class	boost::spirit::type_of::composite_action< Action1, Action2 >
struct	boost::spirit::type_of::action_concatenator< Action1, Action2 >
struct	boost::spirit::type_of::action_concatenator< nop_functor, Action >
struct	boost::spirit::type_of::action_concatenator< Action, nop_functor >
struct	boost::spirit::type_of::action_concatenator< nop_functor, nop_functor >
class	boost::spirit::type_of::action_chain< Placeholder, Mode, Action >
class	boost::spirit::type_of::action_chains< ChainOrChains, LastChain >
struct	boost::spirit::type_of::placeholdee< Placeholder, StartAction, NewChainOrChains >
struct	boost::spirit::type_of::placeholdee< Placeholder, StartAction, action_chains< Head, Tail > >
struct	boost::spirit::type_of::placeholdee< Placeholder, StartAction, action_chain< Placeholder, replace, A > >
struct	boost::spirit::type_of::placeholdee< Placeholder, StartAction, action_chain< Placeholder, append, A > >
struct	boost::spirit::type_of::remove_special_fptr< T >
struct	boost::spirit::type_of::remove_special_fptr< special_result &(*)(T) >

Namespaces
	boost
	Duration formatting facet for input.
	boost::spirit
	boost::spirit::type_of

Macros
#define	BOOST_SPIRIT_RULE_PARSER(name, params, actions, members, rule)   BOOST_SPIRIT_RP_IMPL_I(name,params,actions,members,rule)
#define	BOOST_SPIRIT_OPAQUE_RULE_PARSER(name, params, members, rule)   BOOST_SPIRIT_RP_OPAQUE_IMPL_I(name,params,members,rule)
#define	BOOST_SPIRIT_ACTION_PLACEHOLDER(name)   BOOST_SPIRIT_RP_AP_IMPL(name,::BOOST_SPIRIT_CLASSIC_NS::type_of)
#define	BOOST_SPIRIT_RP_REGISTER_TEMPLATE(name, params)
#define	BOOST_SPIRIT_RP_REGISTER_TYPE(name)
#define	BOOST_SPIRIT_RP_AP_IMPL(name, ns)
#define	BOOST_SPIRIT_RP_IMPL_I(name, pars, acts, mbrs, expr)
#define	BOOST_SPIRIT_RP_IMPL_II(name, name_t, pars, np, acts, na, mbrs, nm, x)
#define	BOOST_SPIRIT_RP_IMPL_III(name, name_t, pars, np, acts, na, mbrs, nm, x)
#define	BOOST_SPIRIT_RP_OPAQUE_IMPL_I(name, pars, mbrs, expr)
#define	BOOST_SPIRIT_RP_OPAQUE_IMPL_II(name, name_t, pars, np, _1, _2, mbrs, nm, x)
#define	BOOST_SPIRIT_RP_AP_HANDLER(name_t, np, acts, na, ns)
#define	BOOST_SPIRIT_RP_AP_EXTRA_MBRS(np, na)
#define	BOOST_SPIRIT_RP_PM_MBRS(z, i, d)   __T ## i __p ## i ;
#define	BOOST_SPIRIT_RP_AP_MBRS(z, i, d)   __A ## i __a ## i ;
#define	BOOST_SPIRIT_RP_CTOR(what, pars, np, acts)
#define	BOOST_SPIRIT_RP_CTOR_COMMA(what, pars, np, acts)   BOOST_SPIRIT_RP_CTOR(what,pars,np,acts) ,
#define	BOOST_SPIRIT_RP_TPL_PARAMS(pars, acts, prefix, defaults)
#define	BOOST_SPIRIT_RP_GEN_FUNC(name, name_t, np, na)
#define	BOOST_SPIRIT_RP_GEN_OPAQUE(name, name_t, np, pars)
#define	BOOST_SPIRIT_RP_GLOB_VAR(name, name_t, np, na)
#define	BOOST_SPIRIT_RP_GLOB_OPAQUE(name, name_t, np, pars)   static name_t const name = name_t () ;
#define	BOOST_SPIRIT_RP__NS_OPEN(r, data, i, elem)   namespace BOOST_SPIRIT_RP_OPTIONAL(elem) {
#define	BOOST_SPIRIT_RP__NS_QUALIFY(r, data, i, elem)   BOOST_SPIRIT_RP_OPTIONAL(elem ::)
#define	BOOST_SPIRIT_RP__NS_CLOSE(r, data, i, elem)   }
#define	BOOST_SPIRIT_RP__PM_STATIC(r, data, i, elem)   static typename ::boost::call_traits< data ## i >::reference elem ;
#define	BOOST_SPIRIT_RP__PM_CTOR_PARAMS(r, data, i, elem)
#define	BOOST_SPIRIT_RP__PM_CTOR_ARGS(r, data, i, elem)   BOOST_PP_COMMA_IF(i) elem
#define	BOOST_SPIRIT_RP__PM_CTOR_INIT_LIST(r, data, i, elem)   BOOST_PP_COMMA_IF(i) __p ## i ( elem )
#define	BOOST_SPIRIT_RP__PM_CTOR_COPY_INIT_LIST(r, data, i, elem)   BOOST_PP_COMMA_IF(i) __p ## i ( that. __p ## i )
#define	BOOST_SPIRIT_RP__PM_TEMPLATE_PARAMS(r, data, i, elem)   , data ## i
#define	BOOST_SPIRIT_RP__PM_OPAQUE_STATIC(r, data, i, elem)
#define	BOOST_SPIRIT_RP__PM_OPAQUE_CTOR_PARAMS(r, data, i, elem)
#define	BOOST_SPIRIT_RP__PM_OPAQUE_GEN_PARAMS(r, data, i, elem)
#define	BOOST_SPIRIT_RP__MV_NONSTATIC(r, data, i, elem)
#define	BOOST_SPIRIT_RP__MV_STATIC(r, data, i, elem)
#define	BOOST_SPIRIT_RP__MV_CTOR_INIT_LIST(r, data, i, elem)
#define	BOOST_SPIRIT_RP__MV_CTOR_COPY_INIT_LIST(r, data, i, elem)
#define	BOOST_SPIRIT_RP__AP_STATIC(r, data, i, elem)   static __A ## i & elem ;
#define	BOOST_SPIRIT_RP__AP_CTOR_PARAMS(r, data, i, elem)
#define	BOOST_SPIRIT_RP__AP_CTOR_ARGS(r, data, i, elem)   BOOST_SPIRIT_RP_COMMA_IF_OR(data,i) elem
#define	BOOST_SPIRIT_RP__AP_CTOR_INIT_LIST(r, data, i, elem)   BOOST_SPIRIT_RP_COMMA_IF_OR(data,i) __a ## i ( elem )
#define	BOOST_SPIRIT_RP__AP_CTOR_COPY_INIT_LIST(r, data, i, elem)   BOOST_SPIRIT_RP_COMMA_IF_OR(data,i) __a ## i ( that. __a ## i )
#define	BOOST_SPIRIT_RP__AP_TEMPLATE_PARAMS(r, data, i, elem)
#define	BOOST_SPIRIT_RP__AP_REBOUND_ARGS(r, data, i, elem)
#define	BOOST_SPIRIT_RP__AP_REBOUND_TPL_ARGS(r, data, i, elem)
#define	BOOST_SPIRIT_RP_EMIT(op, array, data)   BOOST_SPIRIT_RP_ARRAY_FOR_EACH_I(BOOST_SPIRIT_RP__ ## op,data,array)
#define	BOOST_SPIRIT_RP_ARRAY_FOR_EACH_I(macro, data, optional_array)
#define	BOOST_SPIRIT_RP_ARRAY_FOR_EACH_I_IMPL(macro, data, array)
#define	BOOST_SPIRIT_RP_ARRAY_SIZE(optional_array)
#define	BOOST_SPIRIT_RP_OPTIONAL(elem)   BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_PP_IS_UNARY(elem)),elem)
#define	BOOST_SPIRIT_RP_COMMA_IF_OR(a, b)   BOOST_PP_IIF(BOOST_PP_OR(a,b),BOOST_PP_COMMA,BOOST_PP_EMPTY)()
#define	BOOST_SPIRIT_RP_IF(cond, name, arity)   BOOST_PP_IF(cond,BOOST_ ## name,BOOST_PP_TUPLE_EAT(arity))
#define	BOOST_SPIRIT_RP_TYPE(x)

Enumerations
enum	boost::spirit::type_of::action_chain_mode {   boost::spirit::type_of::replace,   boost::spirit::type_of::append }

Functions
template<class P >
parser_reference< P >	boost::spirit::embed_by_reference (parser< P > const &)
template<class P >
parser_reference< P >	boost::spirit::embed_by_reference (::BOOST_SPIRIT_CLASSIC_NS::parser< P > &p)
template<typename Action1 , typename Action2 >
action_concatenator< Action1, Action2 >::type	boost::spirit::type_of::concatenate_actions (Action1 const &a1, Action2 const &a2)
template<class PH , action_chain_mode M, typename A1 , typename A2 >
action_chain< PH, M, typename action_concatenator< A1, A2 > ::type >	boost::spirit::type_of::operator, (action_chain< PH, M, A1 > const &chain, A2 const &a)
template<class Head , class Tail >
action_chains< Head, Tail >	boost::spirit::type_of::make_chain (Head const &h, Tail const &t)
template<class PH1 , action_chain_mode M1, typename A1 , class PH2 , action_chain_mode M2, typename A2 >
action_chains< action_chain < PH1, M1, A1 >, action_chain < PH2, M2, A2 > >	boost::spirit::type_of::operator, (action_chain< PH1, M1, A1 > const &h, action_chain< PH2, M2, A2 > const &t)
template<class Head , class Tail , class PH , action_chain_mode M, typename A >
action_chains< action_chains < Head, Tail >, action_chain < PH, M, A > >	boost::spirit::type_of::operator, (action_chains< Head, Tail > const &h, action_chain< PH, M, A > const &t)
template<class Placeholder , typename StartAction , class NewChainOrChains >
placeholdee< Placeholder, StartAction, NewChainOrChains > ::type	boost::spirit::type_of::get_placeholdee (StartAction const &a, NewChainOrChains const &c)
template<typename T , typename X >
X const &	boost::spirit::type_of::depend_on_type (X const &x)

Macro Definition Documentation

#define BOOST_SPIRIT_ACTION_PLACEHOLDER

(

name

)

BOOST_SPIRIT_RP_AP_IMPL(name,::BOOST_SPIRIT_CLASSIC_NS::type_of)

#define BOOST_SPIRIT_OPAQUE_RULE_PARSER	(		name,
			params,
			members,
			rule
	)		BOOST_SPIRIT_RP_OPAQUE_IMPL_I(name,params,members,rule)

#define BOOST_SPIRIT_RP__AP_CTOR_ARGS	(		r,
			data,
			i,
			elem
	)		BOOST_SPIRIT_RP_COMMA_IF_OR(data,i) elem

#define BOOST_SPIRIT_RP__AP_CTOR_COPY_INIT_LIST	(		r,
			data,
			i,
			elem
	)		BOOST_SPIRIT_RP_COMMA_IF_OR(data,i) __a ## i ( that. __a ## i )

#define BOOST_SPIRIT_RP__AP_CTOR_INIT_LIST	(		r,
			data,
			i,
			elem
	)		BOOST_SPIRIT_RP_COMMA_IF_OR(data,i) __a ## i ( elem )

#define BOOST_SPIRIT_RP__AP_CTOR_PARAMS	(		r,
			data,
			i,
			elem
	)

Value:

BOOST_SPIRIT_RP_COMMA_IF_OR(data,i)                                      \
      typename ::boost::call_traits< __A ## i >::param_type elem

#define BOOST_SPIRIT_RP__AP_REBOUND_ARGS	(		r,
			data,
			i,
			elem
	)

Value:

BOOST_PP_COMMA_IF(i)                                                     \
      ::BOOST_SPIRIT_CLASSIC_NS::type_of::get_placeholdee< __action_placeholder:: elem > \
                                                           ( __a ## i , data )

#define BOOST_SPIRIT_RP__AP_REBOUND_TPL_ARGS	(		r,
			data,
			i,
			elem
	)

Value:

, typename ::BOOST_SPIRIT_CLASSIC_NS::type_of::placeholdee<                        \
                  __action_placeholder:: elem , __A ## i, data >::type

#define BOOST_SPIRIT_RP__AP_STATIC	(		r,
			data,
			i,
			elem
	)		static __A ## i & elem ;

#define BOOST_SPIRIT_RP__AP_TEMPLATE_PARAMS	(		r,
			data,
			i,
			elem
	)

Value:

, BOOST_PP_CAT(BOOST_PP_TUPLE_ELEM(2,0,data),i)                          \
      BOOST_PP_EXPR_IIF(BOOST_PP_TUPLE_ELEM(2,1,data),                         \
          = ::BOOST_SPIRIT_CLASSIC_NS::type_of::nop_functor)

#define BOOST_SPIRIT_RP__MV_CTOR_COPY_INIT_LIST	(		r,
			data,
			i,
			elem
	)

Value:

BOOST_PP_COMMA_IF(i)                                                     \
      BOOST_PP_TUPLE_ELEM(3,1,elem) (data . BOOST_PP_TUPLE_ELEM(3,1,elem))

#define BOOST_SPIRIT_RP__MV_CTOR_INIT_LIST	(		r,
			data,
			i,
			elem
	)

Value:

BOOST_PP_COMMA_IF(i)                                                     \
      BOOST_PP_TUPLE_ELEM(3,1,elem) BOOST_PP_TUPLE_ELEM(3,2,elem)

#define BOOST_SPIRIT_RP__MV_NONSTATIC	(		r,
			data,
			i,
			elem
	)

Value:

data() BOOST_SPIRIT_RP_TYPE(BOOST_PP_TUPLE_ELEM(3,0,elem))               \
        BOOST_PP_TUPLE_ELEM(3,1,elem) ;

#define BOOST_SPIRIT_RP__MV_STATIC	(		r,
			data,
			i,
			elem
	)

Value:

static data() ::boost::call_traits<                                      \
            data() BOOST_SPIRIT_RP_TYPE(BOOST_PP_TUPLE_ELEM(3,0,elem))         \
        >::reference BOOST_PP_TUPLE_ELEM(3,1,elem) ;

#define BOOST_SPIRIT_RP__NS_CLOSE	(		r,
			data,
			i,
			elem
	)		}

#define BOOST_SPIRIT_RP__NS_OPEN	(		r,
			data,
			i,
			elem
	)		namespace BOOST_SPIRIT_RP_OPTIONAL(elem) {

#define BOOST_SPIRIT_RP__NS_QUALIFY	(		r,
			data,
			i,
			elem
	)		BOOST_SPIRIT_RP_OPTIONAL(elem ::)

#define BOOST_SPIRIT_RP__PM_CTOR_ARGS	(		r,
			data,
			i,
			elem
	)		BOOST_PP_COMMA_IF(i) elem

#define BOOST_SPIRIT_RP__PM_CTOR_COPY_INIT_LIST	(		r,
			data,
			i,
			elem
	)		BOOST_PP_COMMA_IF(i) __p ## i ( that. __p ## i )

#define BOOST_SPIRIT_RP__PM_CTOR_INIT_LIST	(		r,
			data,
			i,
			elem
	)		BOOST_PP_COMMA_IF(i) __p ## i ( elem )

#define BOOST_SPIRIT_RP__PM_CTOR_PARAMS	(		r,
			data,
			i,
			elem
	)

Value:

BOOST_PP_COMMA_IF(i)                                                     \
      typename ::boost::call_traits< data ## i >::param_type elem

#define BOOST_SPIRIT_RP__PM_OPAQUE_CTOR_PARAMS	(		r,
			data,
			i,
			elem
	)

Value:

BOOST_PP_COMMA_IF(i) ::boost::call_traits<                               \
          BOOST_SPIRIT_RP_TYPE(BOOST_PP_TUPLE_ELEM(2,0,elem))                  \
        >::param_type BOOST_PP_TUPLE_ELEM(2,1,elem)

#define BOOST_SPIRIT_RP__PM_OPAQUE_GEN_PARAMS	(		r,
			data,
			i,
			elem
	)

Value:

BOOST_PP_COMMA_IF(i) ::boost::call_traits<                               \
          BOOST_SPIRIT_RP_TYPE(BOOST_PP_TUPLE_ELEM(2,0,elem))                  \
        >::param_type data ## i

#define BOOST_SPIRIT_RP__PM_OPAQUE_STATIC	(		r,
			data,
			i,
			elem
	)

Value:

static ::boost::call_traits<                                             \
          BOOST_SPIRIT_RP_TYPE(BOOST_PP_TUPLE_ELEM(2,0,elem))                  \
        >::reference BOOST_PP_TUPLE_ELEM(2,1,elem) ;

#define BOOST_SPIRIT_RP__PM_STATIC	(		r,
			data,
			i,
			elem
	)		static typename ::boost::call_traits< data ## i >::reference elem ;

#define BOOST_SPIRIT_RP__PM_TEMPLATE_PARAMS	(		r,
			data,
			i,
			elem
	)		, data ## i

#define BOOST_SPIRIT_RP_AP_EXTRA_MBRS	(		np,
			na
	)

Value:

private:                                                                 \
        BOOST_PP_REPEAT(np,BOOST_SPIRIT_RP_PM_MBRS,-)                          \
        BOOST_PP_REPEAT(na,BOOST_SPIRIT_RP_AP_MBRS,-)

#define BOOST_SPIRIT_RP_AP_HANDLER	(		name_t,
			np,
			acts,
			na,
			ns
	)

#define BOOST_SPIRIT_RP_AP_IMPL	(		name,
			ns
	)

Value:

namespace __action_placeholder                                           \
      {                                                                        \
        struct name                                                            \
        {                                                                      \
          template<typename Action>                                            \
          ns :: action_chain< name, ns :: replace, Action>                     \
          operator=(Action const & __a) const                                  \
          { return ns :: action_chain< name, ns :: replace, Action>(__a); }    \
                                                                               \
          template<typename Action>                                            \
          ns :: action_chain< name, ns :: append, Action>                      \
          operator+=(Action const & __a) const                                 \
          { return ns :: action_chain< name, ns :: append, Action> (__a); }    \
        };                                                                     \
      }                                                                        \
      __action_placeholder:: name const name = __action_placeholder:: name ();

#define BOOST_SPIRIT_RP_AP_MBRS	(		z,
			i,
			d
	)		__A ## i __a ## i ;

#define BOOST_SPIRIT_RP_ARRAY_FOR_EACH_I	(		macro,
			data,
			optional_array
	)

Value:

BOOST_PP_IIF(BOOST_PP_IS_BINARY(optional_array),                         \
                   BOOST_SPIRIT_RP_ARRAY_FOR_EACH_I_IMPL,                      \
                   BOOST_PP_TUPLE_EAT(3))(macro,data,optional_array)

#define BOOST_SPIRIT_RP_ARRAY_FOR_EACH_I_IMPL	(		macro,
			data,
			array
	)

Value:

BOOST_SPIRIT_RP_IF(BOOST_PP_ARRAY_SIZE(array),PP_SEQ_FOR_EACH_I,3)       \
        (macro,data, BOOST_SPIRIT_RP_IF(BOOST_PP_ARRAY_SIZE(array),            \
                                        PP_TUPLE_TO_SEQ,2) array)

#define BOOST_SPIRIT_RP_ARRAY_SIZE

(

optional_array

)

Value:

BOOST_PP_IIF(BOOST_PP_IS_BINARY(optional_array),                         \
                   BOOST_PP_ARRAY_SIZE, 0 BOOST_PP_TUPLE_EAT(1))(optional_array)

#define BOOST_SPIRIT_RP_COMMA_IF_OR	(		a,
			b
	)		BOOST_PP_IIF(BOOST_PP_OR(a,b),BOOST_PP_COMMA,BOOST_PP_EMPTY)()

#define BOOST_SPIRIT_RP_CTOR	(		what,
			pars,
			np,
			acts
	)

Value:

BOOST_SPIRIT_RP_EMIT(PM_CTOR_ ## what,pars,__T)                          \
      BOOST_SPIRIT_RP_EMIT(AP_CTOR_ ## what,acts,np)

#define BOOST_SPIRIT_RP_CTOR_COMMA	(		what,
			pars,
			np,
			acts
	)		BOOST_SPIRIT_RP_CTOR(what,pars,np,acts) ,

#define BOOST_SPIRIT_RP_EMIT	(		op,
			array,
			data
	)		BOOST_SPIRIT_RP_ARRAY_FOR_EACH_I(BOOST_SPIRIT_RP__ ## op,data,array)

#define BOOST_SPIRIT_RP_GEN_FUNC	(		name,
			name_t,
			np,
			na
	)

Value:

template< BOOST_PP_ENUM_PARAMS(np,typename T) >                          \
      inline name_t < void BOOST_PP_ENUM_TRAILING_PARAMS(np,T) >               \
      name( BOOST_PP_ENUM_BINARY_PARAMS(np,T, const & p) )                     \
      { return name_t < void BOOST_PP_ENUM_TRAILING_PARAMS(np,T) >             \
                 (BOOST_PP_ENUM_PARAMS(np,p) BOOST_PP_ENUM_TRAILING_PARAMS(na, \
                ::BOOST_SPIRIT_CLASSIC_NS::type_of::nop_functor() BOOST_PP_INTERCEPT) ); \
      }

#define BOOST_SPIRIT_RP_GEN_OPAQUE	(		name,
			name_t,
			np,
			pars
	)

Value:

inline name_t name( BOOST_SPIRIT_RP_EMIT(PM_OPAQUE_GEN_PARAMS,pars,p))   \
      { return name_t (BOOST_PP_ENUM_PARAMS(np,p)); }

#define BOOST_SPIRIT_RP_GLOB_OPAQUE	(		name,
			name_t,
			np,
			pars
	)		static name_t const name = name_t () ;

#define BOOST_SPIRIT_RP_GLOB_VAR	(		name,
			name_t,
			np,
			na
	)

Value:

static name_t <void> const name = name_t <void>(BOOST_PP_ENUM_PARAMS(na, \
                ::BOOST_SPIRIT_CLASSIC_NS::type_of::nop_functor() BOOST_PP_INTERCEPT) );

#define BOOST_SPIRIT_RP_IF	(		cond,
			name,
			arity
	)		BOOST_PP_IF(cond,BOOST_ ## name,BOOST_PP_TUPLE_EAT(arity))

#define BOOST_SPIRIT_RP_IMPL_I	(		name,
			pars,
			acts,
			mbrs,
			expr
	)

Value:

BOOST_SPIRIT_RP_IMPL_II(name, name ## _t ,                               \
                              pars, BOOST_SPIRIT_RP_ARRAY_SIZE(pars),          \
                              acts, BOOST_SPIRIT_RP_ARRAY_SIZE(acts),          \
                              mbrs, BOOST_SPIRIT_RP_ARRAY_SIZE(mbrs), expr)

#define BOOST_SPIRIT_RP_IMPL_II	(		name,
			name_t,
			pars,
			np,
			acts,
			na,
			mbrs,
			nm,
			x
	)

Value:

BOOST_PP_IIF(BOOST_PP_OR(np,na),BOOST_SPIRIT_RP_IMPL_III,                \
                                      BOOST_SPIRIT_RP_OPAQUE_IMPL_II)          \
                                         (name,name_t,pars,np,acts,na,mbrs,nm,x)

#define BOOST_SPIRIT_RP_IMPL_III	(		name,
			name_t,
			pars,
			np,
			acts,
			na,
			mbrs,
			nm,
			x
	)

#define BOOST_SPIRIT_RP_OPAQUE_IMPL_I	(		name,
			pars,
			mbrs,
			expr
	)

Value:

BOOST_SPIRIT_RP_OPAQUE_IMPL_II(name, name ## _t,                         \
                                     pars,BOOST_SPIRIT_RP_ARRAY_SIZE(pars),-,-,\
                                     mbrs,BOOST_SPIRIT_RP_ARRAY_SIZE(mbrs),expr)

#define BOOST_SPIRIT_RP_OPAQUE_IMPL_II	(		name,
			name_t,
			pars,
			np,
			_1,
			_2,
			mbrs,
			nm,
			x
	)

#define BOOST_SPIRIT_RP_OPTIONAL

(

elem

)

BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_PP_IS_UNARY(elem)),elem)

#define BOOST_SPIRIT_RP_PM_MBRS	(		z,
			i,
			d
	)		__T ## i __p ## i ;

#define BOOST_SPIRIT_RP_REGISTER_TEMPLATE	(		name,
			params
	)

Value:

BOOST_SPIRIT_RP_EMIT(NS_CLOSE,BOOST_SPIRIT__NAMESPACE,-)                 \
    BOOST_TYPEOF_REGISTER_TEMPLATE(                                            \
        BOOST_SPIRIT_RP_EMIT(NS_QUALIFY,BOOST_SPIRIT__NAMESPACE,-) name,       \
        params)                                                                \
      BOOST_SPIRIT_RP_EMIT(NS_OPEN,BOOST_SPIRIT__NAMESPACE,-)

#define BOOST_SPIRIT_RP_REGISTER_TYPE

(

name

)

Value:

BOOST_SPIRIT_RP_EMIT(NS_CLOSE,BOOST_SPIRIT__NAMESPACE,-)                 \
    BOOST_TYPEOF_REGISTER_TYPE(                                                \
        BOOST_SPIRIT_RP_EMIT(NS_QUALIFY,BOOST_SPIRIT__NAMESPACE,-) name )      \
      BOOST_SPIRIT_RP_EMIT(NS_OPEN,BOOST_SPIRIT__NAMESPACE,-)

#define BOOST_SPIRIT_RP_TPL_PARAMS	(		pars,
			acts,
			prefix,
			defaults
	)

Value:

prefix ## Dummy                                                          \
      BOOST_SPIRIT_RP_EMIT(PM_TEMPLATE_PARAMS,pars,prefix ## T)                \
      BOOST_SPIRIT_RP_EMIT(AP_TEMPLATE_PARAMS,acts,(prefix ## A,defaults))

#define BOOST_SPIRIT_RP_TYPE

(

x

)

Value:

::BOOST_SPIRIT_CLASSIC_NS::type_of::remove_special_fptr \
      < ::BOOST_SPIRIT_CLASSIC_NS::type_of::special_result & (*) x >::type

#define BOOST_SPIRIT_RULE_PARSER	(		name,
			params,
			actions,
			members,
			rule
	)		BOOST_SPIRIT_RP_IMPL_I(name,params,actions,members,rule)