/*============================================================================== | |
Copyright (c) 2006 Tobias Schwinger | |
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) | |
==============================================================================*/ | |
// The comment below contains a unnamed 'namespace {', which is flagged by the | |
// Boost inspect tool as a violation of common C++ programming rules. Since it's | |
// in a comment, well, we switch it off :-P | |
// boostinspect:nounnamed | |
// | |
// About: | |
// ===== | |
// | |
// Using a typeof operator or Boost.Typeof to automatically set the type of | |
// variables (as done in the Spirit example demonstrating typeof) is by far not | |
// all we can do to tighten up our grammars as there are some significant | |
// drawbacks of this approach: | |
// - the types complexity scales with the complexity of the grammar (sooner or | |
// later hitting the limits of the compiler), | |
// - recursive grammars are not possible, and | |
// - all parser objects are embedded by value. | |
// | |
// The Spirit documentation therefore recommends creating custom parser classes | |
// (derived from the a sub_grammar template): | |
// | |
// http://www.boost.org/libs/spirit/doc/techniques.html#no_rules | |
// http://www.boost.org/libs/spirit/doc/techniques.html#typeof | |
// | |
// In practice manually applying this technique leads to rather lengthy code and | |
// overthis requires the user to have a solid understanding of Spirit details. | |
// | |
// Here is a generalized, macro-based approach to easily create typeof-based | |
// grammars that can be recursive and arbitrarily complex. | |
// | |
// | |
// Quick manual: | |
// ============ | |
// | |
// 1. Setup | |
// | |
// Before the rule parser macro (the protagonist of the facility) can be used | |
// the the user must define the macro BOOST_SPIRIT__NAMESPACE (note the double | |
// underscore characeter) and setup a registration group for Boost.Typeof. | |
// | |
// Examples: | |
// | |
// // should come after regular #includeS | |
// #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() | |
// | |
// // [...] | |
// | |
// #define BOOST_SPIRIT__NAMESPACE (2,(my_project, my_module)) | |
// // | | +- outer +- inner | |
// // ! space ! -+ | namespace namespace | |
// // | | |
// // +--- number of nested namespaces | |
// | |
// namespace my_project { namespace my_module { | |
// | |
// // [...] | |
// | |
// --- | |
// | |
// // should come after regular #includeS | |
// #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() | |
// | |
// // [...] | |
// | |
// #define BOOST_SPIRIT__NAMESPACE (2,(my_project, (anonymous) )) | |
// | |
// namespace my_project { namespace { | |
// | |
// // [...] | |
// | |
// --- | |
// | |
// // should come after regular #includeS | |
// #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() | |
// | |
// // [...] | |
// | |
// | |
// #define BOOST_SPIRIT__NAMESPACE - | |
// // we're working at root namespace | |
// | |
// | |
// Why do I have to do this? | |
// | |
// Boost.Typeof needs to assign a unique ID for each registration. This ID is | |
// created composed of the line number and the registration group. The | |
// facility performs Typeof registration and thus requires the source file to | |
// have its own registration group. Further Boost.Typeof requires registration | |
// to happen at root namespace so we have to close and reopen the namespace | |
// we're in. | |
// | |
// | |
// 2. The rule parser macro | |
// | |
// A simple rule parser definition looks like that: | |
// | |
// // we're at namespace scope here | |
// | |
// // Skip parser for C/C++ comments and whitespace | |
// BOOST_SPIRIT_RULE_PARSER(skipper, | |
// -,-,-, | |
// | |
// +( confix_p("//",*anychar_p,eol_p) | |
// | confix_p("/*",*anychar_p,"*/") | |
// | space_p | |
// ) | |
// ) | |
// | |
// Now we can use 'skipper' in other Spirit expressions. | |
// | |
// The code above creates a parser (template) class 'skpper_t' and (in this | |
// case, because there are no parameters) a static const instance 'skipper' of | |
// that class. The class is automatically registered with Boost.Typeof. The type | |
// name our parser is skipper_t here. | |
// | |
// | |
// 2.1. Parametrized rule parsers | |
// | |
// Rule parser definitions can have parameters. | |
// | |
// Parameters are passed to the BOOST_SPIRIT_RULE_PARSER macro as its second | |
// argument (just pass '-' if there are no parameters) with the following | |
// format: | |
// | |
// (N,( param1,param2, / ... / paramN )) | |
// +-- number of parameters | |
// | |
// Example of a whole rule parser: | |
// | |
// BOOST_SPIRIT_RULE_PARSER(new_name, | |
// (1,( symbol_table )),-,-, | |
// | |
// lexeme_d[ (alpha_p >> *alnum_p)[ symbol_table.add ] ] | |
// ) | |
// | |
// The expression 'new_name(my_symbols)' parses a string literal and adds it to | |
// the symbol table 'my_symbols'. | |
// | |
// The rule parser macro creates a function template as called 'new_name' that | |
// takes one parameter of deduced reference type and returns a specialization of | |
// 'new_name_t' in this case. | |
// | |
// Since parsers that require to be fast and lightweight often also require to | |
// be reentrant, it's quite common to pass in some semantic controller (the | |
// symbol table in the example above). | |
// However, parameters are templated so they can be anything (including parsers | |
// of course) so refactoring tasks can be abstracted with rule parsers as well. | |
// | |
// BOOST_SPIRIT_RULE_PARSER(enumeration_parser, | |
// (2,( element_parser, delimiter_parser )),-,-, | |
// | |
// element_parser >> *(delimiter_parser >> element_parser) | |
// ) | |
// | |
// The expression 'enumeration_parser(int_p[ some_action ], ',')' creates a | |
// parser for a comma-separated list of integers. | |
// | |
// | |
// 2.2. Rule parsrs and semantic actions | |
// | |
// While semantic actions can be globally attached to a rule parser or passed | |
// to a parametrized rule parser as (part of) an argument, even more control is | |
// possible by using action placeholders. E.g: | |
// | |
// BOOST_SPIRIT_ACTION_PLACEHOLDER(int_action) | |
// | |
// BOOST_SPIRIT_RULE_PARSER(int_list, | |
// -,(1,( int_action )),-, | |
// | |
// int_p[ int_action ] >> *(',' >> int_p[ int_action ]) | |
// ) | |
// | |
// The expression 'int_list[ my_action ]' parses a comma separated list of | |
// integers and calls 'my_action' for every integer parsed therein. | |
// | |
// Of course multiple actions can be attached to one placeholder as usual (in | |
// this case 'int_list[ my_action1 ][ my_action2 ] would call two actions). | |
// | |
// Further there can be multiple action placeholders for a single rule parser: | |
// | |
// BOOST_SPIRIT_ACTION_PLACEHOLDER(feed_int) | |
// BOOST_SPIRIT_ACTION_PLACEHOLDER(next_int) | |
// | |
// BOOST_SPIRIT_RULE_PARSER(int_list, | |
// -,(2,( feed_int, next_int )),-, | |
// | |
// int_p[ feed_int ] >> *(',' >> int_p[ next_int ][ feed_int ]) | |
// ) | |
// | |
// The expression 'int_list[ (feed_int = my_action1), (next_int = my_action2) ]' | |
// creates a parser for a comma separated list of integers with the actions | |
// attached appropriately. | |
// | |
// int_list[ feed_int = my_action1,my_action2, next_int = my_action3 ] | |
// | |
// works too (in this case the action placeholder 'feed_int' has two actions | |
// attached to it). | |
// | |
// You can both override and append actions associated with an action | |
// placeholder: | |
// | |
// var = int_list[ feed_int = my_action1, next_int = my_action2 ] | |
// | |
// // [...] | |
// | |
// ... var[ feed_int = another_action ] | |
// // 'another_action' overrides the actions previously attached to 'feed_int' | |
// | |
// ... var[ next_int += another_action ] | |
// // 'another_action' is appended to the list of actions attached to | |
// // 'next_int' | |
// | |
// Action placeholders are not entirely for free -- they add to the size and the | |
// initialization time of the rule parser. However, the impact on an already | |
// initialized rule parser instance should be quite small. | |
// | |
// | |
// 2.3. Member variables | |
// | |
// You can add member variables to the rule parser class using the third | |
// parameter of the rule parser macro: | |
// | |
// BOOST_SPIRIT_RULE_PARSER( calc, | |
// -, | |
// -, | |
// (3,( ((subrule<0>),expression,()), | |
// ((subrule<1>),term,()), | |
// ((subrule<2>),factor,() )) ), | |
// | |
// // [...] | |
// | |
// adds three subrules to the rule parser. | |
// Each parameter must have the following type to allow commas to be handled | |
// safely from within the preprocessing code: | |
// | |
// ((type)),name,(constructor argument(s))) | |
// | |
// | |
// 2.4. The opaque rule parser | |
// | |
// Rule parsers usually are templates. Building large grammars pushes the | |
// compiler really hard (and eventually to its limits) because of the | |
// metafunction complexity involved. | |
// If a rule parser without parameters and action placeholders is defined, a | |
// non-template class is created. Non-templated rule parsers can also be created | |
// explicitly by using BOOST_SPIRIT_OPAQUE_RULE_PARSER. | |
// Opaque rule parsers can have parameters and member variables (note: no action | |
// placeholders are possible). The parameters of an opaque rule parsers are | |
// strictly typed, e.g: | |
// | |
// BOOST_SPIRIT_OPAQUE_RULE_PARSER(new_identifier, | |
// (1,( ((my_symbol_table_t &),symbol_table) )) | |
// ,-, | |
// (alpha_p >> *alnum_p) [ symbol_table.add ] | |
// ) | |
// | |
// Note it's also possible to have opaque rule parsers accept parameters of | |
// non-const reference types which is not possible with regular rule parsers. | |
// | |
// | |
// 3. Utilities for by-reference embedding | |
// | |
// When using parsers mutiple times or recursively it can be helpful to embed | |
// them by-reference into the final parser expression. | |
// For this purpose the library provides a wrapper template 'parser_reference'. | |
// There is also a function template to create a wrapped parser which can deduce | |
// the parser's type from its argument. | |
// | |
// --- --- - - --- - - --- - - - - --- - - - - - - - - - - - - - - - - - - - - - | |
#if !defined(BOOST_SPIRIT_UTILITY_RULE_PARSER_HPP_INCLUDED) | |
# define BOOST_SPIRIT_UTILITY_RULE_PARSER_HPP_INCLUDED | |
//============================================================================== | |
// Dependencies | |
//============================================================================== | |
# 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> | |
//============================================================================== | |
// Interface | |
//============================================================================== | |
// Creates a rule parser. Use at namespace scope. | |
# define BOOST_SPIRIT_RULE_PARSER(name,params,actions,members,rule) \ | |
BOOST_SPIRIT_RP_IMPL_I(name,params,actions,members,rule) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// Creates a non-templated rule parser. Use at namespace scope. | |
# define BOOST_SPIRIT_OPAQUE_RULE_PARSER(name,params,members,rule) \ | |
BOOST_SPIRIT_RP_OPAQUE_IMPL_I(name,params,members,rule) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// Defines an action placeholder. Use at namespace scope. | |
# define BOOST_SPIRIT_ACTION_PLACEHOLDER(name) \ | |
BOOST_SPIRIT_RP_AP_IMPL(name,::BOOST_SPIRIT_CLASSIC_NS::type_of) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// Utilities to embed parsers by reference. | |
namespace boost | |
{ | |
namespace spirit | |
{ | |
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN | |
template<class P> class parser_reference; | |
template<class P> parser_reference<P> embed_by_reference(parser<P> const &); | |
BOOST_SPIRIT_CLASSIC_NAMESPACE_END | |
} | |
} | |
//============================================================================== | |
// Implementation | |
//============================================================================== | |
#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP() | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_REGISTER_TEMPLATE | |
// | |
// Boost.Typeof registration from within BOOST_SPIRIT__NAMESPACE | |
# define BOOST_SPIRIT_RP_REGISTER_TEMPLATE(name,params) \ | |
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,-) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_REGISTER_TYPE | |
// | |
// Boost.Typeof registration from within BOOST_SPIRIT__NAMESPACE | |
# define BOOST_SPIRIT_RP_REGISTER_TYPE(name) \ | |
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,-) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_AP_IMPL | |
// | |
// The action placeholder definition | |
# define BOOST_SPIRIT_RP_AP_IMPL(name,ns) \ | |
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 (); | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_IMPL_I | |
// | |
// Does some precalculation so RP_IMPL_II can look cleaner | |
# define BOOST_SPIRIT_RP_IMPL_I(name,pars,acts,mbrs,expr) \ | |
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) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_IMPL_II | |
# define BOOST_SPIRIT_RP_IMPL_II(name,name_t,pars,np,acts,na,mbrs,nm,x) \ | |
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) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_IMPL_III | |
// | |
// The rule parser definition | |
# define BOOST_SPIRIT_RP_IMPL_III(name,name_t,pars,np,acts,na,mbrs,nm,x) \ | |
\ | |
template< BOOST_SPIRIT_RP_TPL_PARAMS(pars,acts,typename __,1) > \ | |
class name_t \ | |
: public ::BOOST_SPIRIT_CLASSIC_NS::parser< name_t \ | |
< BOOST_SPIRIT_RP_TPL_PARAMS(pars,acts,__,0) > > \ | |
{ \ | |
class __rule \ | |
{ \ | |
BOOST_SPIRIT_RP_EMIT(PM_STATIC,pars,__T) \ | |
BOOST_SPIRIT_RP_EMIT(AP_STATIC,acts,-) \ | |
BOOST_SPIRIT_RP_EMIT(MV_STATIC,mbrs,BOOST_PP_IDENTITY(typename)) \ | |
public: \ | |
BOOST_TYPEOF_NESTED_TYPEDEF_TPL(__expr, \ | |
::BOOST_SPIRIT_CLASSIC_NS::type_of::depend_on_type<__Dummy>(x) ) \ | |
}; \ | |
\ | |
public: \ | |
\ | |
typedef name_t self_t; \ | |
typedef typename __rule::__expr::type::parser_category_t \ | |
parser_category_t; \ | |
\ | |
BOOST_PP_EXPR_IIF(BOOST_PP_NOR(np,na),typedef self_t const & embed_t;) \ | |
\ | |
protected: \ | |
\ | |
BOOST_SPIRIT_RP_EMIT(MV_NONSTATIC,mbrs,BOOST_PP_IDENTITY(typename)) \ | |
BOOST_SPIRIT_RP_IF(na,SPIRIT_RP_AP_EXTRA_MBRS,2)(np,na) \ | |
\ | |
typename __rule::__expr::type::embed_t __parser; \ | |
\ | |
public: \ | |
\ | |
explicit name_t ( BOOST_SPIRIT_RP_CTOR(PARAMS,pars,np,acts) ) \ | |
: BOOST_SPIRIT_RP_EMIT(MV_CTOR_INIT_LIST,mbrs,-) \ | |
BOOST_PP_COMMA_IF(nm) \ | |
BOOST_SPIRIT_RP_IF(na,SPIRIT_RP_CTOR_COMMA,4)(INIT_LIST,pars,np,acts)\ | |
__parser(x) \ | |
{ } \ | |
\ | |
name_t( name_t const & that) \ | |
: BOOST_SPIRIT_RP_EMIT(MV_CTOR_COPY_INIT_LIST,mbrs,that) \ | |
BOOST_PP_COMMA_IF(nm) \ | |
BOOST_SPIRIT_RP_IF(na,SPIRIT_RP_CTOR_COMMA,4) \ | |
(COPY_INIT_LIST,pars,np,acts) \ | |
__parser(that.__parser) \ | |
{ } \ | |
\ | |
template<typename Scanner> struct result \ | |
{ \ | |
typedef typename ::BOOST_SPIRIT_CLASSIC_NS::parser_result< \ | |
typename __rule::__expr::type, Scanner>::type type; \ | |
}; \ | |
\ | |
template<typename Scanner> \ | |
typename ::BOOST_SPIRIT_CLASSIC_NS::parser_result<self_t, Scanner>::type \ | |
parse(Scanner const & s) const { return __parser.parse(s); } \ | |
\ | |
BOOST_SPIRIT_RP_IF(na,SPIRIT_RP_AP_HANDLER,5) \ | |
(name_t,np,acts,na,::BOOST_SPIRIT_CLASSIC_NS::type_of) \ | |
}; \ | |
\ | |
BOOST_PP_IF(np,BOOST_SPIRIT_RP_GEN_FUNC,BOOST_SPIRIT_RP_GLOB_VAR) \ | |
(name,name_t,np,na) \ | |
BOOST_SPIRIT_RP_REGISTER_TEMPLATE \ | |
(name_t,BOOST_PP_INC(BOOST_PP_ADD(np,na))) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_OPAQUE_IMPL_I | |
// | |
# define BOOST_SPIRIT_RP_OPAQUE_IMPL_I(name,pars,mbrs,expr) \ | |
BOOST_SPIRIT_RP_OPAQUE_IMPL_II(name, name ## _t, \ | |
pars,BOOST_SPIRIT_RP_ARRAY_SIZE(pars),-,-,\ | |
mbrs,BOOST_SPIRIT_RP_ARRAY_SIZE(mbrs),expr) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_OPAQUE_IMPL_II | |
// | |
# define BOOST_SPIRIT_RP_OPAQUE_IMPL_II(name,name_t,pars,np,_1,_2,mbrs,nm,x) \ | |
class name_t; \ | |
\ | |
BOOST_SPIRIT_RP_REGISTER_TYPE(name_t) \ | |
\ | |
class name_t \ | |
: public ::BOOST_SPIRIT_CLASSIC_NS::parser< name_t > \ | |
{ \ | |
class __rule \ | |
{ \ | |
BOOST_SPIRIT_RP_EMIT(PM_OPAQUE_STATIC,pars,-) \ | |
BOOST_SPIRIT_RP_EMIT(MV_STATIC,mbrs,BOOST_PP_EMPTY) \ | |
public: \ | |
BOOST_TYPEOF_NESTED_TYPEDEF(__expr,x) \ | |
}; \ | |
\ | |
public: \ | |
\ | |
typedef name_t self_t; \ | |
typedef __rule::__expr::type::parser_category_t parser_category_t; \ | |
BOOST_PP_EXPR_IIF(BOOST_PP_NOT(np),typedef self_t const & embed_t;) \ | |
\ | |
protected: \ | |
\ | |
BOOST_SPIRIT_RP_EMIT(MV_NONSTATIC,mbrs,BOOST_PP_EMPTY) \ | |
\ | |
__rule::__expr::type::embed_t __parser; \ | |
\ | |
public: \ | |
\ | |
explicit name_t (BOOST_SPIRIT_RP_EMIT(PM_OPAQUE_CTOR_PARAMS,pars,-)) \ | |
: BOOST_SPIRIT_RP_EMIT(MV_CTOR_INIT_LIST,mbrs,-) \ | |
BOOST_PP_COMMA_IF(nm) __parser(x) \ | |
{ } \ | |
\ | |
name_t(name_t const & that) \ | |
: BOOST_SPIRIT_RP_EMIT(MV_CTOR_COPY_INIT_LIST,mbrs,that) \ | |
BOOST_PP_COMMA_IF(nm) __parser(that.__parser) \ | |
{ } \ | |
\ | |
template<typename Scanner> struct result \ | |
{ \ | |
typedef typename ::BOOST_SPIRIT_CLASSIC_NS::parser_result< \ | |
__rule::__expr::type, Scanner>::type type; \ | |
}; \ | |
\ | |
template<typename Scanner> \ | |
typename ::BOOST_SPIRIT_CLASSIC_NS::parser_result<self_t, Scanner>::type \ | |
parse(Scanner const & s) const { return __parser.parse(s); } \ | |
}; \ | |
\ | |
BOOST_PP_IF(np,BOOST_SPIRIT_RP_GEN_OPAQUE,BOOST_SPIRIT_RP_GLOB_OPAQUE) \ | |
(name,name_t,np,pars) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_AP_HANDLER | |
// | |
// Part of the rule parser definition for handling action placeholders | |
# define BOOST_SPIRIT_RP_AP_HANDLER(name_t,np,acts,na,ns) \ | |
private: \ | |
template<typename A> struct __rebound_1st \ | |
{ \ | |
typedef name_t < void BOOST_PP_ENUM_TRAILING_PARAMS(np,__T) , \ | |
typename ns ::action_concatenator<__A0,A>::type \ | |
BOOST_PP_COMMA_IF(BOOST_PP_DEC(na)) \ | |
BOOST_PP_ENUM_SHIFTED_PARAMS(na,__A) \ | |
> type; \ | |
}; \ | |
\ | |
template<typename X> struct __rebound \ | |
{ \ | |
typedef name_t < \ | |
void BOOST_PP_ENUM_TRAILING_PARAMS(np,__T) \ | |
BOOST_SPIRIT_RP_EMIT(AP_REBOUND_TPL_ARGS,acts,X) \ | |
> type; \ | |
}; \ | |
public: \ | |
template<typename A> \ | |
typename __rebound_1st<A>::type const operator[](A const & a) const \ | |
{ \ | |
return typename __rebound_1st<A>::type ( \ | |
BOOST_PP_ENUM_PARAMS(np,__p) BOOST_PP_COMMA_IF(np) \ | |
ns ::concatenate_actions(__a0,a) \ | |
BOOST_PP_COMMA_IF(BOOST_PP_DEC(na)) \ | |
BOOST_PP_ENUM_SHIFTED_PARAMS(na,__a) ); \ | |
} \ | |
template<class PH, ns ::action_chain_mode M, typename A> \ | |
typename __rebound< ns ::action_chain<PH,M,A> >::type const \ | |
operator[]( ns ::action_chain<PH,M,A> const & x) const \ | |
{ \ | |
return typename __rebound< ns ::action_chain<PH,M,A> >::type ( \ | |
BOOST_PP_ENUM_PARAMS(np,__p) BOOST_PP_COMMA_IF(np) \ | |
BOOST_SPIRIT_RP_EMIT(AP_REBOUND_ARGS,acts,x) ); \ | |
} \ | |
template<class Head, class Tail> \ | |
typename __rebound< ns ::action_chains<Head,Tail> >::type const \ | |
operator[]( ns ::action_chains<Head,Tail> const & x) const \ | |
{ \ | |
return typename __rebound< ns ::action_chains<Head,Tail> >::type ( \ | |
BOOST_PP_ENUM_PARAMS(np,__p) BOOST_PP_COMMA_IF(np) \ | |
BOOST_SPIRIT_RP_EMIT(AP_REBOUND_ARGS,acts,x) ); \ | |
} | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_AP_EXTRA_MBRS | |
// | |
// Extra members we need for rebinding if there are action placeholders | |
# define BOOST_SPIRIT_RP_AP_EXTRA_MBRS(np,na) \ | |
private: \ | |
BOOST_PP_REPEAT(np,BOOST_SPIRIT_RP_PM_MBRS,-) \ | |
BOOST_PP_REPEAT(na,BOOST_SPIRIT_RP_AP_MBRS,-) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_PM_MBRS | |
// | |
// Member variables to remember parameters if there are action placeholder | |
# define BOOST_SPIRIT_RP_PM_MBRS(z,i,d) __T ## i __p ## i ; | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_AP_MBRS | |
// | |
// Member variables to remember action placeholder substitutes | |
# define BOOST_SPIRIT_RP_AP_MBRS(z,i,d) __A ## i __a ## i ; | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_CTOR | |
// | |
// Expands to a fragment of a constructor (parameters or init-list) | |
# define BOOST_SPIRIT_RP_CTOR(what,pars,np,acts) \ | |
BOOST_SPIRIT_RP_EMIT(PM_CTOR_ ## what,pars,__T) \ | |
BOOST_SPIRIT_RP_EMIT(AP_CTOR_ ## what,acts,np) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_CTOR_COMMA | |
// | |
// RP_CTOR with a trailing comma | |
# define BOOST_SPIRIT_RP_CTOR_COMMA(what,pars,np,acts) \ | |
BOOST_SPIRIT_RP_CTOR(what,pars,np,acts) , | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_TPL_PARAMS | |
// | |
// Expands to the template parameters or arguments of the rule parser template | |
# define BOOST_SPIRIT_RP_TPL_PARAMS(pars,acts,prefix,defaults) \ | |
prefix ## Dummy \ | |
BOOST_SPIRIT_RP_EMIT(PM_TEMPLATE_PARAMS,pars,prefix ## T) \ | |
BOOST_SPIRIT_RP_EMIT(AP_TEMPLATE_PARAMS,acts,(prefix ## A,defaults)) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_GEN_FUNC | |
// | |
// Generator function | |
# define BOOST_SPIRIT_RP_GEN_FUNC(name,name_t,np,na) \ | |
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) ); \ | |
} | |
// RP_GEN_OPAQUE | |
// | |
// non-templated version for opaque rule parsers. | |
# define BOOST_SPIRIT_RP_GEN_OPAQUE(name,name_t,np,pars) \ | |
inline name_t name( BOOST_SPIRIT_RP_EMIT(PM_OPAQUE_GEN_PARAMS,pars,p)) \ | |
{ return name_t (BOOST_PP_ENUM_PARAMS(np,p)); } | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_GLOB_VAR | |
// | |
// Global variable -- used instead of the generator function if there are no | |
// parameters | |
# define BOOST_SPIRIT_RP_GLOB_VAR(name,name_t,np,na) \ | |
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) ); | |
// RP_GLOB_OPAQUE | |
// | |
// non-templated version for opaque rule parsers. | |
# define BOOST_SPIRIT_RP_GLOB_OPAQUE(name,name_t,np,pars) \ | |
static name_t const name = name_t () ; | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// PP_EMIT operations (fragment emittion based on array input) | |
// - - Namespace handling | |
// NS_OPEN | |
# define BOOST_SPIRIT_RP__NS_OPEN(r,data,i,elem) \ | |
namespace BOOST_SPIRIT_RP_OPTIONAL(elem) { | |
// NS_QUALIFY | |
# define BOOST_SPIRIT_RP__NS_QUALIFY(r,data,i,elem) \ | |
BOOST_SPIRIT_RP_OPTIONAL(elem ::) | |
// NS_CLOSE | |
# define BOOST_SPIRIT_RP__NS_CLOSE(r,data,i,elem) } | |
// - - Parameter handling | |
// PM_STATIC | |
# define BOOST_SPIRIT_RP__PM_STATIC(r,data,i,elem) \ | |
static typename ::boost::call_traits< data ## i >::reference elem ; | |
// PM_CTOR_PARAMS | |
# define BOOST_SPIRIT_RP__PM_CTOR_PARAMS(r,data,i,elem) \ | |
BOOST_PP_COMMA_IF(i) \ | |
typename ::boost::call_traits< data ## i >::param_type elem | |
// PM_CTOR_ARGS | |
# define BOOST_SPIRIT_RP__PM_CTOR_ARGS(r,data,i,elem) \ | |
BOOST_PP_COMMA_IF(i) elem | |
// PM_CTOR_INIT_LIST | |
# define BOOST_SPIRIT_RP__PM_CTOR_INIT_LIST(r,data,i,elem) \ | |
BOOST_PP_COMMA_IF(i) __p ## i ( elem ) | |
// PM_CTOR_COPY_INIT_LIST | |
# define BOOST_SPIRIT_RP__PM_CTOR_COPY_INIT_LIST(r,data,i,elem) \ | |
BOOST_PP_COMMA_IF(i) __p ## i ( that. __p ## i ) | |
// PM_TEMPLATE_PARAMS | |
# define BOOST_SPIRIT_RP__PM_TEMPLATE_PARAMS(r,data,i,elem) , data ## i | |
// - strictly typed parameters of the opaque rule_parser | |
// PM_OPAQUE_STATIC | |
# define BOOST_SPIRIT_RP__PM_OPAQUE_STATIC(r,data,i,elem) \ | |
static ::boost::call_traits< \ | |
BOOST_SPIRIT_RP_TYPE(BOOST_PP_TUPLE_ELEM(2,0,elem)) \ | |
>::reference BOOST_PP_TUPLE_ELEM(2,1,elem) ; | |
// PM_OPAQUE_CTOR_PARAMS | |
# define BOOST_SPIRIT_RP__PM_OPAQUE_CTOR_PARAMS(r,data,i,elem) \ | |
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) | |
// PM_OPAQUE_GEN_PARAMS | |
# define BOOST_SPIRIT_RP__PM_OPAQUE_GEN_PARAMS(r,data,i,elem) \ | |
BOOST_PP_COMMA_IF(i) ::boost::call_traits< \ | |
BOOST_SPIRIT_RP_TYPE(BOOST_PP_TUPLE_ELEM(2,0,elem)) \ | |
>::param_type data ## i | |
// - - Member variable handling | |
// MV_NONSTATIC | |
# define BOOST_SPIRIT_RP__MV_NONSTATIC(r,data,i,elem) \ | |
data() BOOST_SPIRIT_RP_TYPE(BOOST_PP_TUPLE_ELEM(3,0,elem)) \ | |
BOOST_PP_TUPLE_ELEM(3,1,elem) ; | |
// MV_STATIC | |
# define BOOST_SPIRIT_RP__MV_STATIC(r,data,i,elem) \ | |
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) ; | |
// MV_CTOR_INIT_LIST | |
# define BOOST_SPIRIT_RP__MV_CTOR_INIT_LIST(r,data,i,elem) \ | |
BOOST_PP_COMMA_IF(i) \ | |
BOOST_PP_TUPLE_ELEM(3,1,elem) BOOST_PP_TUPLE_ELEM(3,2,elem) | |
// MV_CTOR_COPY_INIT_LIST | |
# define BOOST_SPIRIT_RP__MV_CTOR_COPY_INIT_LIST(r,data,i,elem) \ | |
BOOST_PP_COMMA_IF(i) \ | |
BOOST_PP_TUPLE_ELEM(3,1,elem) (data . BOOST_PP_TUPLE_ELEM(3,1,elem)) | |
// - - Action placeholder handling | |
// AP_STATIC | |
# define BOOST_SPIRIT_RP__AP_STATIC(r,data,i,elem) static __A ## i & elem ; | |
// AP_CTOR_PARAMS | |
# define BOOST_SPIRIT_RP__AP_CTOR_PARAMS(r,data,i,elem) \ | |
BOOST_SPIRIT_RP_COMMA_IF_OR(data,i) \ | |
typename ::boost::call_traits< __A ## i >::param_type elem | |
// AP_CTOR_ARGS | |
# define BOOST_SPIRIT_RP__AP_CTOR_ARGS(r,data,i,elem) \ | |
BOOST_SPIRIT_RP_COMMA_IF_OR(data,i) elem | |
// AP_CTOR_INIT_LIST | |
# define BOOST_SPIRIT_RP__AP_CTOR_INIT_LIST(r,data,i,elem) \ | |
BOOST_SPIRIT_RP_COMMA_IF_OR(data,i) __a ## i ( elem ) | |
// AP_CTOR_COPY_INIT_LIST | |
# 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 ) | |
// AP_TEMPLATE_PARAMS | |
# define BOOST_SPIRIT_RP__AP_TEMPLATE_PARAMS(r,data,i,elem) \ | |
, 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) | |
// AP_REBOUND_ARGS | |
# define BOOST_SPIRIT_RP__AP_REBOUND_ARGS(r,data,i,elem) \ | |
BOOST_PP_COMMA_IF(i) \ | |
::BOOST_SPIRIT_CLASSIC_NS::type_of::get_placeholdee< __action_placeholder:: elem > \ | |
( __a ## i , data ) | |
// AP_REBOUND_TPL_ARGS | |
# define BOOST_SPIRIT_RP__AP_REBOUND_TPL_ARGS(r,data,i,elem) \ | |
, typename ::BOOST_SPIRIT_CLASSIC_NS::type_of::placeholdee< \ | |
__action_placeholder:: elem , __A ## i, data >::type | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// PP_EMIT | |
// | |
// Performs one of the operations in the above section on an optional array. | |
// | |
# define BOOST_SPIRIT_RP_EMIT(op, array, data) \ | |
BOOST_SPIRIT_RP_ARRAY_FOR_EACH_I(BOOST_SPIRIT_RP__ ## op,data,array) | |
// --- --- - - --- - - --- - - - - --- - - - - - - - - - - - - - - - - - - - - - | |
// RP_ARRAY_FOR_EACH_I | |
// | |
// Iterates an optional array. That is you can pass e.g.'-' or 'none' to denote | |
// emptiness. | |
# define BOOST_SPIRIT_RP_ARRAY_FOR_EACH_I(macro,data,optional_array) \ | |
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) | |
// RP_ARRAY_FOR_EACH_I_IMPL | |
# define BOOST_SPIRIT_RP_ARRAY_FOR_EACH_I_IMPL(macro,data,array) \ | |
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) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_ARRAY_SIZE | |
// | |
// Expands to the size of an "optional array". | |
// | |
// Examples: | |
// | |
// BOOST_SPIRIT_RP_ARRAY_SIZE( (2,(a,b)) ) // 2 | |
// BOOST_SPIRIT_RP_ARRAY_SIZE( (0,()) ) // 0 | |
// BOOST_SPIRIT_RP_ARRAY_SIZE( none ) // 0 | |
// BOOST_SPIRIT_RP_ARRAY_SIZE( - ) // 0 | |
// | |
# define BOOST_SPIRIT_RP_ARRAY_SIZE(optional_array) \ | |
BOOST_PP_IIF(BOOST_PP_IS_BINARY(optional_array), \ | |
BOOST_PP_ARRAY_SIZE, 0 BOOST_PP_TUPLE_EAT(1))(optional_array) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_OPTIONAL | |
// | |
// Expands to nothing if the argument is parenthesized. | |
// | |
// Examples: | |
// | |
// BOOST_SPIRIT_RP_OPTIONAL( foobar ) // foobar | |
// BOOST_SPIRIT_RP_OPTIONAL( (none) ) // evaluates to nothing | |
// | |
# define BOOST_SPIRIT_RP_OPTIONAL(elem) \ | |
BOOST_PP_EXPR_IIF(BOOST_PP_COMPL(BOOST_PP_IS_UNARY(elem)),elem) | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_COMMA_IF_OR | |
// | |
// Expands to nothing if both arguments are zero, otherwise expands to a comma. | |
// | |
# define BOOST_SPIRIT_RP_COMMA_IF_OR(a,b) \ | |
BOOST_PP_IIF(BOOST_PP_OR(a,b),BOOST_PP_COMMA,BOOST_PP_EMPTY)() | |
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - | |
// RP_IF | |
// | |
// BOOST_SPIRIT_RP_IF(cond,name,arity) | |
// | |
// is equivalent to: | |
// | |
// BOOST_PP_IF(cond,BOOST_name,BOOST_PP_TUPLE_EAT(arity)) | |
// | |
# define BOOST_SPIRIT_RP_IF(cond,name,arity) \ | |
BOOST_PP_IF(cond,BOOST_ ## name,BOOST_PP_TUPLE_EAT(arity)) | |
//------------------------------------------------------------------------------ | |
// Wrapper and gernator function to embed a parser by reference | |
//------------------------------------------------------------------------------ | |
namespace boost { namespace spirit { | |
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN | |
// Wrapper to embed a parser by reference | |
template<class P> class parser_reference | |
: public parser< parser_reference<P> > | |
{ | |
P const & ref_that; | |
public: | |
parser_reference(P & that) | |
// we allow implicit conversion but forbid temporaries. | |
: ref_that(that) | |
{ } | |
typedef parser_reference<P> self_t; | |
typedef self_t const & embed_t; | |
typedef typename P::parser_category_t parser_category_t; | |
template<typename ScannerT> struct result | |
{ typedef typename P::BOOST_NESTED_TEMPLATE result<ScannerT>::type type; }; | |
template<typename ScannerT> | |
typename result<ScannerT>::type | |
parse(ScannerT const & scan) const | |
{ return this->ref_that.parse(scan); } | |
}; | |
template<class P> parser_reference<P> | |
embed_by_reference(::BOOST_SPIRIT_CLASSIC_NS::parser<P> & p) | |
{ return p; } | |
BOOST_SPIRIT_CLASSIC_NAMESPACE_END | |
} } // namespace ::BOOST_SPIRIT_CLASSIC_NS | |
BOOST_TYPEOF_REGISTER_TEMPLATE(BOOST_SPIRIT_CLASSIC_NS::parser_reference, 1) | |
//------------------------------------------------------------------------------ | |
// Expression templates for action placeholders. | |
//------------------------------------------------------------------------------ | |
namespace boost { namespace spirit { | |
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN | |
namespace type_of { | |
// No-operation functor | |
struct nop_functor | |
{ | |
template<typename T> | |
bool operator()(T const &) const | |
{ return false; } | |
template<typename T, typename U> | |
bool operator()(T const &, U const &) const | |
{ return false; } | |
typedef bool result_type; | |
}; | |
// Composite action | |
template<typename Action1, typename Action2> | |
class composite_action | |
{ | |
Action1 fnc_a1; | |
Action2 fnc_a2; | |
public: | |
composite_action(Action1 const & a1, Action2 const & a2) | |
: fnc_a1(a1), fnc_a2(a2) | |
{ } | |
template<typename T> | |
void operator()(T const & inp) const | |
{ fnc_a1(inp); fnc_a2(inp); } | |
template<typename T, typename U> | |
void operator()(T const & inp1, U const inp2) const | |
{ fnc_a1(inp1, inp2); fnc_a2(inp1, inp2); } | |
}; | |
// Action concatenation (and optimize away nop_functorS) | |
template<typename Action1, typename Action2> | |
struct action_concatenator | |
{ | |
typedef composite_action<Action1,Action2> type; | |
static type concatenate(Action1 const & a1, Action2 const & a2) | |
{ return composite_action<Action1,Action2>(a1,a2); } | |
}; | |
template<typename Action> struct action_concatenator<nop_functor, Action> | |
{ | |
typedef Action type; | |
static type concatenate(nop_functor const &, Action const & a) | |
{ return a; } | |
}; | |
template<typename Action> struct action_concatenator<Action, nop_functor> | |
{ | |
typedef Action type; | |
static type concatenate(Action const & a, nop_functor const &) | |
{ return a; } | |
}; | |
template<> struct action_concatenator<nop_functor, nop_functor> | |
{ | |
typedef nop_functor type; | |
static type concatenate(nop_functor const &, nop_functor const &) | |
{ return nop_functor(); } | |
}; | |
template<typename Action1, typename Action2> | |
typename action_concatenator<Action1,Action2>::type | |
concatenate_actions(Action1 const & a1, Action2 const & a2) | |
{ | |
return action_concatenator<Action1,Action2>::concatenate(a1,a2); | |
} | |
// Action chains | |
enum action_chain_mode { replace, append }; | |
template<class Placeholder, action_chain_mode Mode, typename Action> | |
class action_chain | |
{ | |
Action fnc_action; | |
public: | |
action_chain(Action const & a) | |
: fnc_action(a) | |
{ } | |
typedef Action action_type; | |
Action const & action() const { return fnc_action; } | |
}; | |
// This operator adds actions to an action chain definition | |
template<class PH, action_chain_mode M, typename A1, typename A2> | |
action_chain<PH, M, typename action_concatenator<A1,A2>::type> | |
operator, (action_chain<PH,M,A1> const & chain, A2 const & a) | |
{ | |
return action_chain<PH,M,typename action_concatenator<A1,A2>::type> | |
( concatenate_actions(chain.action(), a) ); | |
} | |
// Expression template for mutiple action chain assignments | |
template<class ChainOrChains, class LastChain> | |
class action_chains | |
{ | |
ChainOrChains obj_head; | |
LastChain obj_tail; | |
public: | |
action_chains(ChainOrChains const & head, LastChain const & tail) | |
: obj_head(head), obj_tail(tail) | |
{ } | |
typedef ChainOrChains head_type; | |
typedef LastChain tail_type; | |
head_type const & head() const { return obj_head; } | |
tail_type const & tail() const { return obj_tail; } | |
}; | |
// Action chain concatenation | |
template<class Head, class Tail> | |
action_chains<Head,Tail> make_chain(Head const & h, Tail const & t) | |
{ return action_chains<Head,Tail>(h,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> > | |
operator, (action_chain<PH1,M1,A1> const & h, | |
action_chain<PH2,M2,A2> const & t) | |
{ return make_chain(h,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> > | |
operator, (action_chains<Head,Tail> const & h, action_chain<PH,M,A> const & t) | |
{ return make_chain(h,t); } | |
// Extract the (maybe composite) action associated with an action | |
// placeholders from the chains with a fold algorithm. | |
template<class Placeholder, typename StartAction, class NewChainOrChains> | |
struct placeholdee | |
{ | |
typedef StartAction type; | |
static type get(StartAction const & a, NewChainOrChains const &) | |
{ return a; } | |
}; | |
template<class Placeholder, // <-- non-deduced | |
typename StartAction, class NewChainOrChains> | |
typename placeholdee<Placeholder,StartAction,NewChainOrChains>::type | |
get_placeholdee(StartAction const & a, NewChainOrChains const & c) | |
{ return placeholdee<Placeholder,StartAction,NewChainOrChains>::get(a,c); } | |
template<class Placeholder, typename StartAction, class Head, class Tail> | |
struct placeholdee | |
< Placeholder, StartAction, action_chains<Head,Tail> > | |
{ | |
typedef typename placeholdee<Placeholder, | |
typename placeholdee<Placeholder,StartAction,Head>::type, Tail >::type | |
type; | |
static type get(StartAction const & a, action_chains<Head,Tail> const & c) | |
{ | |
return get_placeholdee<Placeholder>( | |
get_placeholdee<Placeholder>(a,c.head()), c.tail() ); | |
} | |
}; | |
template<class Placeholder, typename StartAction, typename A> | |
struct placeholdee | |
< Placeholder, StartAction, action_chain<Placeholder,replace,A> > | |
{ | |
typedef A type; | |
static type get(StartAction const &, | |
action_chain<Placeholder,replace,A> const & c) | |
{ return c.action(); } | |
}; | |
template<class Placeholder, typename StartAction, typename A> | |
struct placeholdee | |
< Placeholder, StartAction, action_chain<Placeholder,append,A> > | |
{ | |
typedef typename action_concatenator<StartAction,A>::type type; | |
static type get(StartAction const & a, | |
action_chain<Placeholder,append,A> const & c) | |
{ return concatenate_actions(a,c.action()); } | |
}; | |
} | |
BOOST_SPIRIT_CLASSIC_NAMESPACE_END | |
} } // namespace ::BOOST_SPIRIT_CLASSIC_NS::type_of | |
BOOST_TYPEOF_REGISTER_TYPE(BOOST_SPIRIT_CLASSIC_NS::type_of::nop_functor) | |
BOOST_TYPEOF_REGISTER_TEMPLATE(BOOST_SPIRIT_CLASSIC_NS::type_of::composite_action,2) | |
//------------------------------------------------------------------------------ | |
// Misc.utilities | |
//------------------------------------------------------------------------------ | |
namespace boost { namespace spirit { | |
BOOST_SPIRIT_CLASSIC_NAMESPACE_BEGIN | |
namespace type_of { | |
// Utility function to create a dependency to a template argument. | |
template<typename T, typename X> | |
X const & depend_on_type(X const & x) | |
{ return x; } | |
// Utility to allow use parenthesized type expressions with commas inside | |
// as a type within macros. Thanks to Dave Abrahams for telling me this nice | |
// trick. | |
#define BOOST_SPIRIT_RP_TYPE(x) \ | |
::BOOST_SPIRIT_CLASSIC_NS::type_of::remove_special_fptr \ | |
< ::BOOST_SPIRIT_CLASSIC_NS::type_of::special_result & (*) x >::type | |
struct special_result; | |
template<typename T> struct remove_special_fptr { }; | |
template<typename T> struct remove_special_fptr< special_result & (*)(T) > | |
{ typedef T type; }; | |
} | |
BOOST_SPIRIT_CLASSIC_NAMESPACE_END | |
} } // namespace ::BOOST_SPIRIT_CLASSIC_NS::type_of | |
//------------------------------------------------------------------------------ | |
#endif | |
//------------------------------------------------------------------------------ | |