1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345 |
- // Hannibal: partial C++ grammar to parse C++ type information
- // Copyright (c) 2005-2006 Danny Havenith
- //
- // Boost.Wave: A Standard compliant C++ preprocessor
- // Copyright (c) 2001-2009 Hartmut Kaiser
- //
- // http://www.boost.org/
- //
- // 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)
- #if !defined(HANNIBAL_TRANSLATION_UNIT_GRAMMAR_H_INCLUDED)
- #define HANNIBAL_TRANSLATION_UNIT_GRAMMAR_H_INCLUDED
- #include <map>
- #include <boost/assert.hpp>
- #include <boost/spirit/include/classic_core.hpp>
- #include <boost/spirit/include/classic_confix.hpp>
- #include <boost/wave/wave_config.hpp>
- #include <boost/wave/token_ids.hpp>
- #include <boost/wave/util/pattern_parser.hpp>
- //
- // If so required, trace every declaration and member-declaration.
- // This can be a much faster alternative to BOOST_SPIRIT_DEBUG-type of
- // debugging.
- //
- #ifdef HANNIBAL_TRACE_DECLARATIONS
- struct trace_actor
- {
- trace_actor(
- const char rule_type[],
- std::ostream &strm
- )
- : strm_( strm), rule_type_( rule_type)
- {
- // nop
- }
- template<typename PositionIterator>
- void operator()(PositionIterator begin, PositionIterator end) const
- {
- typedef const boost::wave::cpplexer::lex_token<>::position_type
- position_type;
- //typedef pos_iterator_type::token_type::position_type position_type;
- position_type &begin_pos(begin->get_position());
- strm_ << "Parsed " << rule_type_ << std::endl;
- strm_ << " from: " << begin_pos.get_file()
- << "(" << begin_pos.get_line() << ")"
- << std::endl;
- };
- private:
- std::ostream &strm_;
- char const* const rule_type_;
- };
- #define HANNIBAL_TRACE_ACTION( type) [trace_actor( (type), std::cout)]
- #else
- #define HANNIBAL_TRACE_ACTION( type)
- #endif
- ///////////////////////////////////////////////////////////////////////////////
- #define HANNIBAL_TRACE_TRANSLATION_UNIT_GRAMMAR \
- bool(BOOST_SPIRIT_DEBUG_FLAGS_CPP & BOOST_SPIRIT_DEBUG_FLAGS_CPP_EXPR_GRAMMAR) \
- /**/
- ///////////////////////////////////////////////////////////////////////////////
- // Helper macro to register rules for debugging
- #if HANNIBAL_DUMP_PARSE_TREE != 0
- #define HANNIBAL_REGISTER_RULE(r) \
- BOOST_SPIRIT_DEBUG_NODE(r); \
- self.declare_rule(r, #r) \
- /**/
- #else
- #define HANNIBAL_REGISTER_RULE(r) \
- BOOST_SPIRIT_DEBUG_NODE(r) \
- /**/
- #endif
- ///////////////////////////////////////////////////////////////////////////////
- struct dump_actor {
- template<typename ForwardIterator>
- void operator()(ForwardIterator begin, ForwardIterator end)
- {
- std::cerr << "*** COULD NOT PARSE THE FOLLOWING ***" << std::endl;
- while (begin != end)
- {
- std::cerr << begin->get_value();
- ++begin;
- }
- }
- } dump_a;
- ///////////////////////////////////////////////////////////////////////////////
- struct translation_unit_grammar
- : public boost::spirit::classic::grammar<translation_unit_grammar>
- {
- #if HANNIBAL_DUMP_PARSE_TREE != 0
- //
- // allow an external map with rule-id -> rule-name mappings.
- // this map is external so it can be altered by the definition constructor,
- // which receives a const grammar object.
- //
- // Please Note: the lifetime of the rule map should at least extend beyond the
- // call of the definition constructor...
- //
- typedef std::map<boost::spirit::classic::parser_id, std::string>
- rule_map_type;
- translation_unit_grammar(rule_map_type *rule_map_ptr_ = 0)
- : rule_map_ptr(rule_map_ptr_)
- #else
- translation_unit_grammar()
- #endif
- {
- BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME(*this,
- "translation_unit_grammar", HANNIBAL_TRACE_TRANSLATION_UNIT_GRAMMAR);
- }
- template <typename ScannerT>
- struct definition
- {
- // declare non-terminals
- typedef boost::spirit::classic::rule<ScannerT> rule_type;
- rule_type constant_expression;
- rule_type logical_or_exp, logical_and_exp;
- rule_type inclusive_or_exp, exclusive_or_exp, and_exp;
- rule_type cmp_equality, cmp_relational;
- rule_type shift_exp;
- rule_type add_exp, multiply_exp;
- rule_type unary_exp, primary_exp, constant;
- boost::spirit::classic::subrule<0> const_exp_subrule;
- boost::spirit::classic::subrule<1> shift_exp_clos;
- rule_type simple_type_name, class_keywords;
- rule_type storage_class_specifier, cv_qualifier, function_specifier;
- rule_type access_specifier;
- rule_type extension_type_decorator;
- rule_type operator_sym;
- rule_type class_key;
- rule_type enumerator;
- rule_type enumerator_list;
- rule_type enumerator_definition;
- rule_type member_declarator;
- rule_type member_declarator_list;
- rule_type member_declaration;
- rule_type constant_initializer;
- rule_type pure_specifier;
- rule_type namespace_body;
- rule_type type_id;
- rule_type unnamed_namespace_definition;
- rule_type extension_namespace_definition;
- rule_type original_namespace_definition;
- rule_type named_namespace_definition;
- rule_type namespace_definition;
- rule_type linkage_specification;
- rule_type explicit_specialization;
- rule_type using_directive;
- rule_type using_declaration;
- rule_type type_parameter;
- rule_type template_parameter;
- rule_type template_parameter_list;
- rule_type template_declaration;
- rule_type explicit_instantiation;
- rule_type qualified_namespace_specifier;
- rule_type namespace_alias_definition;
- rule_type expression_list;
- rule_type initializer_list;
- rule_type initializer_clause;
- rule_type initializer;
- rule_type init_declarator;
- rule_type init_declarator_list;
- rule_type asm_definition;
- rule_type simple_declaration;
- rule_type block_declaration;
- rule_type declaration;
- rule_type declaration_seq;
- rule_type translation_unit;
- rule_type function_definition, function_definition_helper, declarator;
- rule_type direct_declarator, parameters_or_array_spec;
- rule_type abstract_declarator, direct_abstract_declarator;
- rule_type direct_abstract_declarator_helper;
- rule_type parameter_declaration_clause, parameter_declaration_list;
- rule_type parameter_declaration, assignment_expression, decimal_literal;
- rule_type octal_literal, hexadecimal_literal;
- rule_type declarator_id, id_expression, qualified_id, unqualified_id;
- rule_type operator_function_id, conversion_function_id, conversion_type_id;
- rule_type conversion_declarator, function_body;
- rule_type compound_statement, ctor_initializer, ptr_operator;
- rule_type decl_specifier, type_specifier;
- rule_type type_specifier_seq, cv_qualifier_seq, enum_specifier;
- rule_type enum_keyword, simple_type_specifier;
- rule_type class_specifier, member_specification, class_head;
- rule_type type_name, elaborated_type_specifier, template_argument_list;
- rule_type template_argument, nested_name_specifier;
- rule_type class_or_namespace_name, class_name, enum_name, typedef_name;
- rule_type namespace_name, template_id;
- rule_type decl_specifier_seq, no_type_decl_specifier;
- rule_type function_try_block, handler_seq, handler;
- rule_type exception_specification, template_name;
- rule_type original_namespace_name, base_specifier;
- rule_type base_specifier_list, base_clause;
- rule_type odd_language_extension, mem_initializer_id;
- rule_type mem_initializer, mem_initializer_list;
- rule_type ta_expression_operator;
- rule_type ta_logical_or_expression;
- rule_type ta_expression;
- rule_type ta_conditional_expression;
- rule_type ta_throw_expression;
- rule_type ta_assignment_expression;
- rule_type postfix_expression_helper;
- rule_type simple_postfix_expression;
- rule_type pseudo_destructor_name;
- rule_type direct_new_declarator;
- rule_type new_declarator;
- rule_type new_initializer;
- rule_type new_type_id;
- rule_type new_placement;
- rule_type delete_expression;
- rule_type new_expression;
- rule_type unary_operator;
- rule_type postfix_expression;
- rule_type unary_expression;
- rule_type expression_operator;
- rule_type cast_expression;
- rule_type throw_expression;
- rule_type assignment_operator;
- rule_type logical_or_expression;
- rule_type conditional_expression;
- rule_type boolean_literal;
- rule_type string_literal;
- rule_type floating_literal;
- rule_type character_literal;
- rule_type integer_literal;
- rule_type expression;
- rule_type literal;
- rule_type primary_expression;
- //
- // grammar definition.
- definition(translation_unit_grammar const& self)
- {
- using namespace boost::spirit::classic;
- using namespace boost::wave;
- using boost::wave::util::pattern_p;
-
- //
- // First, a long list of expression rules.
- //
- HANNIBAL_REGISTER_RULE( primary_expression);
- primary_expression
- = literal
- | ch_p(T_THIS)
- | ch_p(T_COLON_COLON) >> ch_p(T_IDENTIFIER)
- | ch_p(T_COLON_COLON) >> operator_function_id
- | ch_p(T_COLON_COLON) >> qualified_id
- | ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN)
- | id_expression
- ;
-
- HANNIBAL_REGISTER_RULE( literal);
- literal
- = integer_literal
- | character_literal
- | floating_literal
- | string_literal
- | boolean_literal
- ;
-
- HANNIBAL_REGISTER_RULE( integer_literal);
- integer_literal
- = pattern_p( IntegerLiteralTokenType, TokenTypeMask)
- ;
-
- HANNIBAL_REGISTER_RULE( character_literal);
- character_literal
- = pattern_p( CharacterLiteralTokenType, TokenTypeMask)
- ;
-
- HANNIBAL_REGISTER_RULE( floating_literal);
- floating_literal
- = pattern_p( FloatingLiteralTokenType, TokenTypeMask)
- ;
-
- HANNIBAL_REGISTER_RULE( string_literal);
- string_literal
- = pattern_p( StringLiteralTokenType, TokenTypeMask)
- ;
-
- HANNIBAL_REGISTER_RULE( boolean_literal);
- boolean_literal
- = pattern_p( BoolLiteralTokenType, TokenTypeMask)
- ;
- //
- // TODO: separate assignment expression into a grammar of it's own
- //
- HANNIBAL_REGISTER_RULE( assignment_expression);
- assignment_expression
- = conditional_expression
- | logical_or_expression >> assignment_operator >> assignment_expression
- | throw_expression
- ;
- //
- // Have a separate assignment expression for template arguments.
- // This is needed, because without it, an expression of the form
- // template < a, b, c > x;
- // would not parse, since the 'c > x' part would be taken by the
- // assignment expression.
- //
- // Note that this ta_xxxxx duplication cascades all the way down to
- // logical_or_expression.
- // Both the previous example and a declaration of the form
- // template < a, b, (c > d) > x;
- // should parse fine now.
- //
- //
- HANNIBAL_REGISTER_RULE( ta_assignment_expression);
- ta_assignment_expression
- = ta_conditional_expression
- | ta_logical_or_expression >> assignment_operator >> ta_assignment_expression
- | ta_throw_expression
- ;
-
- HANNIBAL_REGISTER_RULE( throw_expression);
- throw_expression
- = ch_p(T_THROW) >> !assignment_expression
- ;
- HANNIBAL_REGISTER_RULE( ta_throw_expression);
- ta_throw_expression
- = ch_p(T_THROW) >> !ta_assignment_expression
- ;
- HANNIBAL_REGISTER_RULE( conditional_expression);
- conditional_expression
- = logical_or_expression
- >> !(
- ch_p(T_QUESTION_MARK)
- >> expression
- >> ch_p(T_COLON)
- >> assignment_expression
- )
- ;
- HANNIBAL_REGISTER_RULE( ta_conditional_expression);
- ta_conditional_expression
- = ta_logical_or_expression
- >> !(
- ch_p(T_QUESTION_MARK)
- >> ta_expression
- >> ch_p(T_COLON)
- >> ta_assignment_expression
- )
- ;
-
- HANNIBAL_REGISTER_RULE( expression);
- expression
- = assignment_expression % ch_p(T_COMMA);
-
- HANNIBAL_REGISTER_RULE( ta_expression);
- ta_expression
- = ta_assignment_expression % ch_p(T_COMMA);
- HANNIBAL_REGISTER_RULE( assignment_operator);
- assignment_operator
- = pp(T_ASSIGN)
- | pp(T_ANDASSIGN)
- | pp(T_ORASSIGN)
- | pp(T_XORASSIGN)
- | pp(T_DIVIDEASSIGN)
- | pp(T_MINUSASSIGN)
- | pp(T_PERCENTASSIGN)
- | pp(T_PLUSASSIGN)
- | pp(T_SHIFTLEFTASSIGN)
- | pp(T_SHIFTRIGHTASSIGN)
- | pp(T_STARASSIGN)
- ;
- // we skip quite a few rules here, since we're not interested in operator precedence
- // just now.
- HANNIBAL_REGISTER_RULE( logical_or_expression);
- logical_or_expression
- = cast_expression % expression_operator
- ;
- HANNIBAL_REGISTER_RULE( ta_logical_or_expression);
- ta_logical_or_expression
- = cast_expression % ta_expression_operator
- ;
-
- HANNIBAL_REGISTER_RULE( expression_operator );
- expression_operator
- = ta_expression_operator | pp(T_GREATER)
- ;
-
- HANNIBAL_REGISTER_RULE( ta_expression_operator );
- ta_expression_operator
- = pp(T_OROR)
- | pp(T_ANDAND)
- | pp(T_OR)
- | pp(T_XOR)
- | pp(T_AND)
- | pp(T_NOTEQUAL)
- | pp(T_EQUAL)
- | pp(T_GREATEREQUAL)
- | pp(T_LESSEQUAL)
- | pp(T_LESS)
- | pp(T_SHIFTLEFT)
- | pp(T_SHIFTRIGHT)
- | pp(T_PLUS)
- | pp(T_MINUS)
- | pp(T_PERCENT)
- | pp(T_DIVIDE)
- | pp(T_STAR)
- | pp(T_ARROWSTAR)
- | pp(T_DOTSTAR)
- ;
- HANNIBAL_REGISTER_RULE( cast_expression);
- cast_expression
- = ch_p(T_LEFTPAREN) >> type_id >> ch_p(T_RIGHTPAREN)
- >> cast_expression
- | unary_expression
- ;
-
- HANNIBAL_REGISTER_RULE( unary_expression);
- unary_expression
- = postfix_expression
- | ch_p(T_PLUSPLUS) >> cast_expression
- | ch_p(T_MINUSMINUS) >> cast_expression
- | unary_operator >> cast_expression
- | ch_p(T_SIZEOF) >> unary_expression
- | ch_p(T_SIZEOF)
- >> ch_p(T_LEFTPAREN) >> type_id >> ch_p(T_RIGHTPAREN)
- | new_expression
- | delete_expression
- ;
-
- HANNIBAL_REGISTER_RULE( unary_operator);
- unary_operator
- = ch_p(T_STAR)
- | pp(T_AND)
- | pp(T_PLUS)
- | ch_p(T_MINUS)
- | ch_p(T_NOT)
- | pp(T_COMPL)
- ;
- HANNIBAL_REGISTER_RULE( new_expression);
- new_expression
- = !ch_p(T_COLON_COLON) >> ch_p(T_NEW) >> !new_placement
- >> (
- new_type_id >> !new_initializer
- | ch_p(T_LEFTPAREN) >> type_id >> ch_p(T_RIGHTPAREN) >> !new_initializer
- )
- ;
-
- HANNIBAL_REGISTER_RULE( new_placement);
- new_placement
- = ch_p(T_LEFTPAREN) >> expression_list >> ch_p(T_RIGHTPAREN)
- ;
-
- HANNIBAL_REGISTER_RULE( new_type_id);
- new_type_id
- = type_specifier_seq >> !new_declarator
- ;
-
- HANNIBAL_REGISTER_RULE( new_declarator);
- new_declarator
- = ptr_operator >> !new_declarator
- | direct_new_declarator
- ;
-
- HANNIBAL_REGISTER_RULE( direct_new_declarator);
- direct_new_declarator
- = *( pp(T_LEFTBRACKET) >> expression >> pp(T_RIGHTBRACKET) )
- >> pp(T_LEFTBRACKET) >> constant_expression >> pp(T_RIGHTBRACKET)
- ;
-
- HANNIBAL_REGISTER_RULE( new_initializer);
- new_initializer
- = ch_p(T_LEFTPAREN) >> !expression_list >> ch_p(T_RIGHTPAREN)
- ;
-
- HANNIBAL_REGISTER_RULE( delete_expression);
- delete_expression
- = !ch_p(T_COLON_COLON) >> ch_p(T_DELETE) >> cast_expression
- | !ch_p(T_COLON_COLON) >> ch_p(T_DELETE)
- >> pp(T_LEFTBRACKET) >> pp(T_RIGHTBRACKET)
- >> cast_expression
- ;
-
- HANNIBAL_REGISTER_RULE( postfix_expression);
- postfix_expression
- = simple_postfix_expression >> *postfix_expression_helper
- ;
-
- HANNIBAL_REGISTER_RULE( simple_postfix_expression);
- simple_postfix_expression
- = primary_expression
- | simple_type_specifier
- >> ch_p(T_LEFTPAREN) >> !expression_list >> ch_p(T_RIGHTPAREN)
- | ch_p(T_DYNAMICCAST)
- >> ch_p(T_LESS) >> type_id >> ch_p(T_GREATER)
- >> ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN)
- | ch_p(T_STATICCAST)
- >> ch_p(T_LESS) >> type_id >> ch_p(T_GREATER)
- >> ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN)
- | ch_p(T_REINTERPRETCAST)
- >> ch_p(T_LESS) >> type_id >> ch_p(T_GREATER)
- >> ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN)
- | ch_p(T_CONSTCAST)
- >> ch_p(T_LESS) >> type_id >> ch_p(T_GREATER)
- >> ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN)
- | ch_p(T_TYPEID)
- >> ch_p(T_LEFTPAREN) >> expression >> ch_p(T_RIGHTPAREN)
- | ch_p(T_TYPEID)
- >> ch_p(T_LEFTPAREN) >> type_id >> ch_p(T_RIGHTPAREN)
- ;
-
- HANNIBAL_REGISTER_RULE( postfix_expression_helper );
- postfix_expression_helper
- = pp(T_LEFTBRACKET) >> expression >> pp(T_RIGHTBRACKET)
- | ch_p(T_LEFTPAREN) >> !expression_list >> ch_p(T_RIGHTPAREN)
- | ch_p(T_DOT) >> !ch_p(T_TEMPLATE) >> !ch_p(T_COLON_COLON) >> id_expression
- | ch_p(T_ARROW) >> !ch_p(T_TEMPLATE) >> !ch_p(T_COLON_COLON) >> id_expression
- | ch_p(T_DOT) >> pseudo_destructor_name
- | ch_p(T_ARROW) >> pseudo_destructor_name
- | ch_p(T_PLUSPLUS)
- | ch_p(T_MINUSMINUS)
- ;
-
- HANNIBAL_REGISTER_RULE( pseudo_destructor_name);
- pseudo_destructor_name
- = !ch_p(T_COLON_COLON) >> !nested_name_specifier
- >> (
- type_name >> ch_p(T_COLON_COLON) >> ch_p(T_COMPL) >> type_name
- | ch_p(T_COMPL) >> type_name
- )
- ;
- HANNIBAL_REGISTER_RULE(constant_expression);
- constant_expression
- = conditional_expression
- ;
- HANNIBAL_REGISTER_RULE(ctor_initializer);
- ctor_initializer
- = ch_p(T_COLON) >> mem_initializer_list
- ;
- HANNIBAL_REGISTER_RULE(mem_initializer_list);
- mem_initializer_list
- = mem_initializer % ch_p(T_COMMA)
- ;
- HANNIBAL_REGISTER_RULE(mem_initializer);
- mem_initializer
- = mem_initializer_id
- >> comment_nest_p(ch_p(T_LEFTPAREN), ch_p(T_RIGHTPAREN))
- // TODO: restore after assignment expression has been implemented
- //ch_p(T_LEFTPAREN) >> !expression_list >> ch_p(T_RIGHTPAREN)
- ;
- HANNIBAL_REGISTER_RULE(mem_initializer_id);
- mem_initializer_id
- = !ch_p(T_COLON_COLON) >> !nested_name_specifier >> class_name
- | ch_p(T_IDENTIFIER)
- ;
- //
- // the eps_p is added to allow skipping of trailing whitespace
- // (post-skip)
- //
- HANNIBAL_REGISTER_RULE(translation_unit);
- translation_unit
- = !declaration_seq >> end_p;
- ;
- HANNIBAL_REGISTER_RULE(odd_language_extension);
- odd_language_extension // read: microsoft extensions
- = extension_type_decorator
- >> !comment_nest_p(ch_p(T_LEFTPAREN), ch_p(T_RIGHTPAREN))
- ;
- HANNIBAL_REGISTER_RULE(declaration_seq);
- declaration_seq
- = +declaration HANNIBAL_TRACE_ACTION( "declaration")
- ;
- HANNIBAL_REGISTER_RULE(declaration);
- declaration
- = template_declaration
- | explicit_instantiation
- | explicit_specialization
- | linkage_specification
- | namespace_definition
- | block_declaration
- | function_definition
- ;
- HANNIBAL_REGISTER_RULE(block_declaration);
- block_declaration
- = simple_declaration
- | asm_definition
- | namespace_alias_definition
- | using_declaration
- | using_directive
- ;
- HANNIBAL_REGISTER_RULE(simple_declaration);
- simple_declaration
- = !decl_specifier_seq >> !init_declarator_list
- >> ch_p(T_SEMICOLON)
- ;
- HANNIBAL_REGISTER_RULE(asm_definition);
- asm_definition
- = ch_p(T_ASM)
- >> ch_p(T_LEFTPAREN) >> ch_p(T_STRINGLIT) >> ch_p(T_RIGHTPAREN)
- >> ch_p(T_SEMICOLON)
- ;
- HANNIBAL_REGISTER_RULE(init_declarator_list);
- init_declarator_list
- = init_declarator % ch_p(T_COMMA)
- ;
- HANNIBAL_REGISTER_RULE(init_declarator);
- init_declarator
- = declarator >> !initializer
- ;
- HANNIBAL_REGISTER_RULE(initializer);
- initializer
- = ch_p(T_ASSIGN) >> initializer_clause
- | ch_p(T_LEFTPAREN) >> expression_list >> ch_p(T_RIGHTPAREN)
- ;
- HANNIBAL_REGISTER_RULE(initializer_clause);
- initializer_clause
- = assignment_expression
- | ch_p(T_LEFTBRACE) >> initializer_list
- >> !ch_p(T_COMMA) >> ch_p(T_RIGHTBRACE)
- | ch_p(T_LEFTBRACE) >> ch_p(T_RIGHTBRACE)
- ;
- HANNIBAL_REGISTER_RULE(initializer_list);
- initializer_list
- = initializer_clause % ch_p(T_COMMA)
- ;
- HANNIBAL_REGISTER_RULE(expression_list);
- expression_list
- = assignment_expression % ch_p(T_COMMA)
- ;
- HANNIBAL_REGISTER_RULE(namespace_alias_definition);
- namespace_alias_definition
- = ch_p(T_NAMESPACE) >> ch_p(T_IDENTIFIER) >> ch_p(T_ASSIGN)
- >> qualified_namespace_specifier
- >> ch_p(T_SEMICOLON)
- ;
- HANNIBAL_REGISTER_RULE(qualified_namespace_specifier);
- qualified_namespace_specifier
- = !ch_p(T_COLON_COLON) >> !nested_name_specifier
- >> namespace_name
- ;
- HANNIBAL_REGISTER_RULE(explicit_instantiation);
- explicit_instantiation
- = template_declaration
- ;
- HANNIBAL_REGISTER_RULE(template_declaration);
- template_declaration
- = !ch_p(T_EXPORT) >> ch_p(T_TEMPLATE)
- >> ch_p(T_LESS) >> template_parameter_list >> ch_p(T_GREATER)
- >> declaration
- ;
- HANNIBAL_REGISTER_RULE(template_parameter_list);
- template_parameter_list
- = template_parameter % ch_p(T_COMMA)
- ;
- HANNIBAL_REGISTER_RULE(template_parameter);
- template_parameter
- = type_parameter
- | parameter_declaration
- ;
- HANNIBAL_REGISTER_RULE(type_parameter);
- type_parameter
- = ch_p(T_CLASS) >> !ch_p(T_IDENTIFIER)
- >> !(ch_p(T_ASSIGN) >> type_id)
- | ch_p(T_TYPENAME) >> !ch_p(T_IDENTIFIER)
- >> !(ch_p(T_ASSIGN) >> type_id)
- | ch_p(T_TEMPLATE)
- >> ch_p(T_LESS) >> template_parameter_list >> ch_p(T_GREATER)
- >> ch_p(T_CLASS) >> !ch_p(T_IDENTIFIER)
- >> !(ch_p(T_ASSIGN) >> template_name)
- ;
- HANNIBAL_REGISTER_RULE(template_name);
- template_name
- = ch_p(T_IDENTIFIER)
- ;
- HANNIBAL_REGISTER_RULE(using_declaration);
- using_declaration // optimize?
- = ch_p(T_USING) >> !ch_p(T_TYPENAME) >> !ch_p(T_COLON_COLON)
- >> nested_name_specifier >> unqualified_id
- >> ch_p(T_SEMICOLON)
- | ch_p(T_USING) >> ch_p(T_COLON_COLON) >> unqualified_id
- >> ch_p(T_SEMICOLON)
- ;
- HANNIBAL_REGISTER_RULE(using_directive);
- using_directive
- = ch_p(T_USING) >> ch_p(T_NAMESPACE) >> !ch_p(T_COLON_COLON)
- >> !nested_name_specifier >> namespace_name
- >> ch_p(T_SEMICOLON)
- ;
- HANNIBAL_REGISTER_RULE(explicit_specialization);
- explicit_specialization
- = ch_p(T_TEMPLATE) >> ch_p(T_LESS) >> ch_p(T_GREATER)
- >> declaration
- ;
- HANNIBAL_REGISTER_RULE(linkage_specification);
- linkage_specification
- = ch_p(T_EXTERN) >> ch_p(T_STRINGLIT)
- >> ( ch_p(T_LEFTBRACE) >> !declaration_seq >> ch_p(T_RIGHTBRACE)
- | declaration
- )
- ;
- HANNIBAL_REGISTER_RULE(namespace_definition);
- namespace_definition
- = named_namespace_definition
- | unnamed_namespace_definition // TODO: optimize?
- ;
- HANNIBAL_REGISTER_RULE(named_namespace_definition);
- named_namespace_definition
- = original_namespace_definition
- // | extension_namespace_definition // optimization: extension namespace is syntactically identical
- ;
- HANNIBAL_REGISTER_RULE(original_namespace_definition);
- original_namespace_definition
- = ch_p(T_NAMESPACE) >> ch_p(T_IDENTIFIER)
- >> ch_p(T_LEFTBRACE) >> namespace_body >> ch_p(T_RIGHTBRACE)
- ;
- HANNIBAL_REGISTER_RULE(extension_namespace_definition);
- extension_namespace_definition
- = ch_p(T_NAMESPACE) >> original_namespace_name
- >> ch_p(T_LEFTBRACE) >> namespace_body >> ch_p(T_RIGHTBRACE)
- ;
- HANNIBAL_REGISTER_RULE(original_namespace_name);
- original_namespace_name
- = ch_p(T_IDENTIFIER)
- ;
- HANNIBAL_REGISTER_RULE(unnamed_namespace_definition);
- unnamed_namespace_definition
- = ch_p(T_NAMESPACE)
- >> ch_p(T_LEFTBRACE) >> namespace_body >> ch_p(T_RIGHTBRACE)
- ;
- HANNIBAL_REGISTER_RULE(namespace_body);
- namespace_body
- = !declaration_seq
- ;
- HANNIBAL_REGISTER_RULE(function_definition);
- function_definition
- = function_definition_helper
- >> !ctor_initializer >> !function_body // removed semicolons
- | decl_specifier_seq >> declarator >> function_try_block
- | declarator >> function_try_block
- ;
- HANNIBAL_REGISTER_RULE(function_definition_helper);
- function_definition_helper
- = decl_specifier_seq >> declarator
- | +no_type_decl_specifier >> declarator
- | declarator
- ;
- HANNIBAL_REGISTER_RULE(function_try_block);
- function_try_block
- = ch_p(T_TRY)
- >> !ctor_initializer >> function_body >> handler_seq
- ;
- HANNIBAL_REGISTER_RULE(handler_seq);
- handler_seq
- = +handler
- ;
- HANNIBAL_REGISTER_RULE(handler);
- handler // TODO
- = ch_p(T_CATCH)
- >> comment_nest_p(ch_p(T_LEFTPAREN), ch_p(T_RIGHTPAREN))
- >> compound_statement
- ;
- HANNIBAL_REGISTER_RULE(declarator);
- declarator
- = *( ptr_operator
- | odd_language_extension
- )
- >> direct_declarator
- ;
- HANNIBAL_REGISTER_RULE(direct_declarator);
- direct_declarator
- = ( declarator_id
- | ch_p(T_LEFTPAREN) >> declarator >> ch_p(T_RIGHTPAREN)
- )
- >> *parameters_or_array_spec
- ;
- HANNIBAL_REGISTER_RULE(parameters_or_array_spec);
- parameters_or_array_spec
- = ch_p(T_LEFTPAREN) >> parameter_declaration_clause >> ch_p(T_RIGHTPAREN)
- >> !cv_qualifier_seq >> !exception_specification
- | pp(T_LEFTBRACKET) >> !constant_expression >> pp(T_RIGHTBRACKET)
- ;
- HANNIBAL_REGISTER_RULE(exception_specification);
- exception_specification // TODO
- = ch_p(T_THROW)
- >> comment_nest_p(ch_p(T_LEFTPAREN), ch_p(T_RIGHTPAREN))
- ;
- HANNIBAL_REGISTER_RULE(abstract_declarator);
- abstract_declarator
- = +( ptr_operator
- | odd_language_extension
- )
- >> !direct_abstract_declarator
- | direct_abstract_declarator
- ;
- HANNIBAL_REGISTER_RULE(direct_abstract_declarator);
- direct_abstract_declarator
- = ch_p(T_LEFTPAREN) >> abstract_declarator >> ch_p(T_RIGHTPAREN)
- >> *direct_abstract_declarator_helper
- ;
- HANNIBAL_REGISTER_RULE(direct_abstract_declarator_helper);
- direct_abstract_declarator_helper
- = ch_p(T_LEFTPAREN) >> parameter_declaration_clause >> ch_p(T_RIGHTPAREN)
- >> !cv_qualifier_seq >> !exception_specification
- | pp(T_LEFTBRACKET) >> !constant_expression >> pp(T_RIGHTBRACKET)
- ;
- HANNIBAL_REGISTER_RULE(parameter_declaration_clause);
- parameter_declaration_clause
- = parameter_declaration_list >> ch_p(T_COMMA)
- >> ch_p(T_ELLIPSIS)
- | !parameter_declaration_list >> !ch_p(T_ELLIPSIS)
- ;
- HANNIBAL_REGISTER_RULE(parameter_declaration_list);
- parameter_declaration_list
- = parameter_declaration % ch_p(T_COMMA)
- ;
- HANNIBAL_REGISTER_RULE(parameter_declaration);
- parameter_declaration
- = decl_specifier_seq
- >> !(declarator | abstract_declarator)
- >> !(ch_p(T_ASSIGN) >> assignment_expression)
- ;
- HANNIBAL_REGISTER_RULE(declarator_id);
- declarator_id
- = !ch_p(T_COLON_COLON)
- >> ( id_expression
- | !nested_name_specifier >> type_name
- )
- ;
- HANNIBAL_REGISTER_RULE(id_expression);
- id_expression
- = qualified_id
- | unqualified_id
- ;
- HANNIBAL_REGISTER_RULE(qualified_id);
- qualified_id
- = nested_name_specifier >> !ch_p(T_TEMPLATE) >> unqualified_id
- ;
- HANNIBAL_REGISTER_RULE(unqualified_id);
- unqualified_id
- = operator_function_id
- | conversion_function_id
- | ch_p(T_COMPL) >> class_name
- | template_id
- | ch_p(T_IDENTIFIER)
- ;
- HANNIBAL_REGISTER_RULE(operator_function_id);
- operator_function_id
- = ch_p(T_OPERATOR) >> operator_sym // this is called 'operator' in the std grammar
- ;
-
- HANNIBAL_REGISTER_RULE(operator_sym);
- operator_sym
- = ch_p(T_DELETE) >> !(pp(T_LEFTBRACKET) >> pp(T_RIGHTBRACKET))
- | ch_p(T_NEW) >> !(pp(T_LEFTBRACKET) >> pp(T_RIGHTBRACKET))
- | pp(T_LEFTBRACKET) >> pp(T_RIGHTBRACKET)
- | ch_p(T_LEFTPAREN) >> ch_p(T_RIGHTPAREN)
- | pattern_p(OperatorTokenType, TokenTypeMask)
- ;
- HANNIBAL_REGISTER_RULE(conversion_function_id);
- conversion_function_id
- = ch_p(T_OPERATOR) >> conversion_type_id
- ;
- HANNIBAL_REGISTER_RULE( conversion_type_id);
- conversion_type_id
- = type_specifier_seq >> !conversion_declarator
- ;
- HANNIBAL_REGISTER_RULE(type_id);
- type_id
- = type_specifier_seq >> !abstract_declarator
- ;
- HANNIBAL_REGISTER_RULE(conversion_declarator);
- conversion_declarator
- = ptr_operator >> !conversion_declarator
- ;
- HANNIBAL_REGISTER_RULE(function_body);
- function_body
- = compound_statement
- ;
- HANNIBAL_REGISTER_RULE(compound_statement);
- compound_statement
- = comment_nest_p(ch_p(T_LEFTBRACE), ch_p(T_RIGHTBRACE))
- ; // TODO later
- HANNIBAL_REGISTER_RULE(ptr_operator);
- ptr_operator
- = ch_p(T_STAR) >> !cv_qualifier_seq
- | ch_p(T_AND)
- | !ch_p(T_COLON_COLON) >> nested_name_specifier
- >> ch_p(T_STAR) >> !cv_qualifier_seq
- ;
- HANNIBAL_REGISTER_RULE(decl_specifier);
- decl_specifier
- = no_type_decl_specifier
- | type_specifier
- ;
- HANNIBAL_REGISTER_RULE(no_type_decl_specifier);
- no_type_decl_specifier
- = storage_class_specifier
- | function_specifier
- | ch_p(T_FRIEND)
- | ch_p(T_TYPEDEF)
- | cv_qualifier
- | odd_language_extension
- ;
- HANNIBAL_REGISTER_RULE(type_specifier_seq);
- type_specifier_seq
- = +type_specifier
- ;
- HANNIBAL_REGISTER_RULE(type_specifier);
- type_specifier
- = enum_specifier
- | class_specifier
- | elaborated_type_specifier
- | simple_type_specifier
- | cv_qualifier
- ;
- HANNIBAL_REGISTER_RULE(cv_qualifier_seq);
- cv_qualifier_seq
- = cv_qualifier >> !cv_qualifier_seq
- ;
- HANNIBAL_REGISTER_RULE(cv_qualifier);
- cv_qualifier
- = ch_p(T_CONST)
- | ch_p(T_VOLATILE)
- ;
- HANNIBAL_REGISTER_RULE(enum_specifier);
- enum_specifier
- = enum_keyword >> !ch_p(T_IDENTIFIER)
- >> ch_p(T_LEFTBRACE) >> !enumerator_list >> ch_p(T_RIGHTBRACE)
- ;
- HANNIBAL_REGISTER_RULE(enum_keyword);
- enum_keyword
- = ch_p(T_ENUM)
- ;
- HANNIBAL_REGISTER_RULE(enumerator_list);
- enumerator_list
- = enumerator_definition % ch_p(T_COMMA)
- >> !ch_p(T_COMMA)
- // TODO find out if this last COMMA_T is an MS-"extension"?
- // it seems not to be in the grammar but MSVC 7.0 accepts it.
- ;
- HANNIBAL_REGISTER_RULE(enumerator_definition);
- enumerator_definition
- = enumerator >> !(ch_p(T_ASSIGN) >> constant_expression)
- ;
- HANNIBAL_REGISTER_RULE(enumerator);
- enumerator
- = ch_p(T_IDENTIFIER)
- ;
- HANNIBAL_REGISTER_RULE(simple_type_specifier);
- simple_type_specifier
- = !ch_p(T_COLON_COLON) >> !nested_name_specifier
- >> ch_p(T_TEMPLATE) >> template_id
- | +simple_type_name
- | !ch_p(T_COLON_COLON) >> !nested_name_specifier >> type_name
- ;
- HANNIBAL_REGISTER_RULE(class_head);
- class_head // DH changed the order because otherwise it would always parse the (!IDENTIFIER) part.
- = !access_specifier >> *odd_language_extension
- >> class_key >> *odd_language_extension
- >> (
- !nested_name_specifier >> template_id
- | nested_name_specifier >> ch_p(T_IDENTIFIER)
- | !ch_p(T_IDENTIFIER)
- )
- >> !base_clause
- ;
- HANNIBAL_REGISTER_RULE(type_name);
- type_name
- = class_name
- | enum_name
- | typedef_name
- ;
- HANNIBAL_REGISTER_RULE(elaborated_type_specifier);
- elaborated_type_specifier
- = class_key >> *odd_language_extension
- >> !ch_p(T_COLON_COLON)
- >> !nested_name_specifier
- >> (
- !ch_p(T_TEMPLATE) >> template_id
- | ch_p(T_IDENTIFIER)
- )
- | ch_p(T_ENUM) >> !ch_p(T_COLON_COLON)
- >> !nested_name_specifier
- >> ch_p(T_IDENTIFIER)
- | ch_p(T_TYPENAME)
- >> !ch_p(T_COLON_COLON)
- >> nested_name_specifier
- >> (
- !ch_p(T_TEMPLATE) >> template_id
- | ch_p(T_IDENTIFIER)
- )
- ;
- HANNIBAL_REGISTER_RULE(template_argument_list);
- template_argument_list
- = template_argument % ch_p(T_COMMA)
- ;
- HANNIBAL_REGISTER_RULE(template_argument);
- template_argument
- = longest_d
- [
- type_id
- | ta_assignment_expression
- | template_name
- ]
- ;
- HANNIBAL_REGISTER_RULE(class_key);
- class_key
- = class_keywords
- ;
- HANNIBAL_REGISTER_RULE(class_keywords);
- class_keywords
- = ch_p(T_CLASS)
- | ch_p(T_STRUCT)
- | ch_p(T_UNION)
- ;
- HANNIBAL_REGISTER_RULE(nested_name_specifier);
- nested_name_specifier
- = class_or_namespace_name >> ch_p(T_COLON_COLON)
- >> ch_p(T_TEMPLATE) >> nested_name_specifier
- | class_or_namespace_name >> ch_p(T_COLON_COLON)
- >> !nested_name_specifier
- ;
- HANNIBAL_REGISTER_RULE(class_or_namespace_name);
- class_or_namespace_name
- = class_name
- | namespace_name
- ;
- HANNIBAL_REGISTER_RULE(class_name);
- class_name
- = template_id
- | ch_p(T_IDENTIFIER)
- ;
- HANNIBAL_REGISTER_RULE(enum_name);
- enum_name
- = ch_p(T_IDENTIFIER)
- ;
- HANNIBAL_REGISTER_RULE(typedef_name);
- typedef_name
- = ch_p(T_IDENTIFIER)
- ;
- HANNIBAL_REGISTER_RULE(namespace_name);
- namespace_name // TODO
- = ch_p(T_IDENTIFIER)
- ;
- HANNIBAL_REGISTER_RULE(template_id);
- template_id
- = template_name
- >> ch_p(T_LESS) >> template_argument_list >> ch_p(T_GREATER)
- ;
- //
- // This is kind of a HACK. We want to prevent the decl_specifier_seq
- // from eating the whole declaration, including the ch_p(T_IDENTIFIER).
- // Therefore in the sequence, we only allow one 'unknown' word
- // (the type_specifier), the rest of the decl_specifier sequence
- // must consist of known keywords or constructs (the
- // no_type_decl_specifier).
- // This means that a declaration like:
- // MYDLL_EXPORT int f();
- // will not be accepted unless the MYDLL_EXPORT is properly
- // expanded by the preprocessor first.
- //
- // This should not cause any problems normally, it just means that
- // this rule is not very robust in the case where not all symbols
- // are known.
- //
- HANNIBAL_REGISTER_RULE(decl_specifier_seq);
- decl_specifier_seq
- = *no_type_decl_specifier >> type_specifier >> *no_type_decl_specifier
- ;
- // The following rule is more according to the standard grammar
- // decl_specifier_seq // adapted
- // = decl_specifier >> decl_specifier_seq
- // | (decl_specifier - (declarator_id >> parameters_or_array_spec ))
- // ;
- HANNIBAL_REGISTER_RULE( storage_class_specifier);
- storage_class_specifier
- = ch_p(T_AUTO)
- | ch_p(T_REGISTER)
- | ch_p(T_STATIC)
- | ch_p(T_EXTERN)
- | ch_p(T_MUTABLE)
- ;
- HANNIBAL_REGISTER_RULE( function_specifier);
- function_specifier
- = ch_p(T_INLINE)
- | ch_p(T_VIRTUAL)
- | ch_p(T_EXPLICIT)
- ;
- HANNIBAL_REGISTER_RULE(class_specifier);
- class_specifier
- = class_head
- >> ch_p(T_LEFTBRACE) >> !member_specification >> ch_p(T_RIGHTBRACE)
- ;
- HANNIBAL_REGISTER_RULE(member_specification);
- member_specification
- = +( access_specifier >> ch_p(T_COLON)
- | member_declaration HANNIBAL_TRACE_ACTION("member declaration")
- )
- ;
- // member_specification
- // = access_specifier >> COLON_T >> !member_specification
- // | member_declaration >> !member_specification
- // ;
- HANNIBAL_REGISTER_RULE(member_declaration);
- member_declaration
- = using_declaration
- | template_declaration
- | !decl_specifier_seq >> !member_declarator_list
- >> ch_p(T_SEMICOLON)
- | function_definition >>
- !ch_p(T_SEMICOLON)
- | qualified_id
- >> ch_p(T_SEMICOLON)
- ;
- HANNIBAL_REGISTER_RULE(member_declarator_list);
- member_declarator_list
- = member_declarator % ch_p(T_COMMA)
- ;
- HANNIBAL_REGISTER_RULE(member_declarator);
- member_declarator
- = !ch_p(T_IDENTIFIER) >> ch_p(T_COLON) >> constant_expression
- | declarator >> !(pure_specifier | constant_initializer)
- ;
- HANNIBAL_REGISTER_RULE(pure_specifier);
- pure_specifier
- = ch_p(T_ASSIGN) >> ch_p(T_INTLIT)
- ;
- HANNIBAL_REGISTER_RULE(constant_initializer);
- constant_initializer
- = ch_p(T_ASSIGN) >> constant_expression
- ;
- HANNIBAL_REGISTER_RULE(access_specifier);
- access_specifier
- = ch_p(T_PUBLIC)
- | ch_p(T_PROTECTED)
- | ch_p(T_PRIVATE)
- ;
- HANNIBAL_REGISTER_RULE(base_clause);
- base_clause
- = ch_p(T_COLON) >> base_specifier_list
- ;
- HANNIBAL_REGISTER_RULE(base_specifier_list);
- base_specifier_list
- = base_specifier % ch_p(T_COMMA)
- ;
- HANNIBAL_REGISTER_RULE(base_specifier);
- base_specifier
- = ch_p(T_VIRTUAL) >> !access_specifier >> !ch_p(T_COLON_COLON)
- >> !nested_name_specifier >> class_name
- | access_specifier >> !ch_p(T_VIRTUAL) >> !ch_p(T_COLON_COLON)
- >> !nested_name_specifier >> class_name
- | !ch_p(T_COLON_COLON) >> !nested_name_specifier >> class_name
- ;
- HANNIBAL_REGISTER_RULE(extension_type_decorator);
- extension_type_decorator
- = ch_p(T_MSEXT_CDECL)
- | ch_p(T_MSEXT_DECLSPEC)
- | ch_p(T_MSEXT_BASED)
- | ch_p(T_MSEXT_FASTCALL)
- | ch_p(T_MSEXT_INLINE)
- ;
- HANNIBAL_REGISTER_RULE(simple_type_name);
- simple_type_name
- = ch_p(T_CHAR)
- | ch_p(T_WCHART)
- | ch_p(T_BOOL)
- | ch_p(T_SHORT)
- | ch_p(T_INT)
- | ch_p(T_LONG)
- | ch_p(T_UNSIGNED)
- | ch_p(T_SIGNED)
- | ch_p(T_FLOAT)
- | ch_p(T_DOUBLE)
- | ch_p(T_VOID)
- | ch_p(T_MSEXT_INT64)
- | ch_p(T_MSEXT_INT8)
- | ch_p(T_MSEXT_INT16)
- | ch_p(T_MSEXT_INT32)
- ;
- }
- rule_type const& start() const { return translation_unit; }
- // Helper function wrapping pattern_p
- static inline boost::wave::util::pattern_and< boost::wave::token_id>
- pp (boost::wave::token_id id)
- {
- using namespace boost::wave;
- return util::pattern_p(id, MainTokenMask);
- }
- };
-
- #if HANNIBAL_DUMP_PARSE_TREE != 0
- private:
- template<typename Rule>
- void declare_rule(Rule const& rule, std::string const& rule_name) const
- {
- if (rule_map_ptr)
- (*rule_map_ptr)[rule.id()] = rule_name;
- }
- rule_map_type *rule_map_ptr;
- #endif
- };
- #undef HANNIBAL_REGISTER_RULE
- #undef HANNIBAL_TRACE_TRANSLATION_UNIT_GRAMMAR
- #endif // HANNIBAL_TRANSLATION_UNIT_GRAMMAR_H_INCLUDED
|