Future/bison
1
0
Fork 0
mirror of https://git.savannah.gnu.org/git/bison.git synced 2026-03-27 21:23:03 +00:00
Code Issues Packages Projects Releases Wiki Activity

* data/lalr1.cc: Move the body of the ctor and dtor into the

Browse Source 
parser file (instead of the header).
Wrap the implementations in a "namespace yy".
This commit is contained in:
Akim Demaille
2005-11-12 11:32:46 +00:00
parent 1989d9476c
commit 98ae96438e
2 changed files with 540 additions and 519 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
ChangeLog
View File

@@ -1,3 +1,16 @@
2005-11-12 Akim <akim@epita.fr>
* data/lalr1.cc: Move the body of the ctor and dtor into the
parser file (instead of the header).
Wrap the implementations in a "namespace yy".
2005-11-12 Akim Demaille <akim@epita.fr>
Have glr.c include its header file when created.
* data/glr.c (b4_shared_declarations): New.
Output them verbatim in the parser if !%defines, otherwise
output then in the header file, and include it instead.
2005-11-11 Akim Demaille <akim@epita.fr> 2005-11-11 Akim Demaille <akim@epita.fr>
* data/glr.c: Comment changes. * data/glr.c: Comment changes.

368
data/lalr1.cc
View File

@@ -117,15 +117,8 @@ b4_syncline([@oline@], [@ofile@])],
}; };
/// Build a parser object. /// Build a parser object.
]b4_parser_class_name[ (]b4_parse_param_decl[) : ]b4_parser_class_name[ (]b4_parse_param_decl[);
yydebug_ (false), virtual ~]b4_parser_class_name[ ();
yycdebug_ (&std::cerr)]b4_parse_param_cons[
{
}
virtual ~]b4_parser_class_name[ ()
{
}
/// Parse. /// Parse.
/// \returns 0 iff parsing succeeded. /// \returns 0 iff parsing succeeded.
@@ -404,15 +397,28 @@ yy::]b4_parser_class_name[::yytnamerr_ (const char *yystr)
#endif #endif
#if YYDEBUG namespace yy
/*--------------------------------.
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
void
yy::]b4_parser_class_name[::yysymprint_ (int yytype,
const semantic_type* yyvaluep, const location_type* yylocationp)
{ {
/// Build a parser object.
]b4_parser_class_name::b4_parser_class_name[ (]b4_parse_param_decl[)
: yydebug_ (false),
yycdebug_ (&std::cerr)]b4_parse_param_cons[
{
}
]b4_parser_class_name::~b4_parser_class_name[ ()
{
}
#if YYDEBUG
/*--------------------------------.
| Print this symbol on YYOUTPUT. |
`--------------------------------*/
void
]b4_parser_class_name[::yysymprint_ (int yytype,
const semantic_type* yyvaluep, const location_type* yylocationp)
{
/* Backward compatibility, but should be removed eventually. */ /* Backward compatibility, but should be removed eventually. */
std::ostream& cdebug_ = *yycdebug_; std::ostream& cdebug_ = *yycdebug_;
@@ -425,18 +431,18 @@ yy::]b4_parser_class_name[::yysymprint_ (int yytype,
<< *yylocationp << ": "; << *yylocationp << ": ";
switch (yytype) switch (yytype)
{ {
]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
[ default: [ default:
break; break;
} }
*yycdebug_ << ')'; *yycdebug_ << ')';
} }
#endif /* ! YYDEBUG */ #endif /* ! YYDEBUG */
void void
yy::]b4_parser_class_name[::yydestruct_ (const char* yymsg, ]b4_parser_class_name[::yydestruct_ (const char* yymsg,
int yytype, semantic_type* yyvaluep, location_type* yylocationp) int yytype, semantic_type* yyvaluep, location_type* yylocationp)
{ {
YYUSE (yylocationp); YYUSE (yylocationp);
YYUSE (yymsg); YYUSE (yymsg);
YYUSE (yyvaluep); YYUSE (yyvaluep);
@@ -445,49 +451,49 @@ yy::]b4_parser_class_name[::yydestruct_ (const char* yymsg,
switch (yytype) switch (yytype)
{ {
]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[ ]m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))[
default: default:
break; break;
} }
} }
void void
yy::]b4_parser_class_name[::yypop_ (unsigned int n) ]b4_parser_class_name[::yypop_ (unsigned int n)
{ {
yystate_stack_.pop (n); yystate_stack_.pop (n);
yysemantic_stack_.pop (n); yysemantic_stack_.pop (n);
yylocation_stack_.pop (n); yylocation_stack_.pop (n);
} }
std::ostream& std::ostream&
yy::]b4_parser_class_name[::debug_stream () const ]b4_parser_class_name[::debug_stream () const
{ {
return *yycdebug_; return *yycdebug_;
} }
void void
yy::]b4_parser_class_name[::set_debug_stream (std::ostream& o) ]b4_parser_class_name[::set_debug_stream (std::ostream& o)
{ {
yycdebug_ = &o; yycdebug_ = &o;
} }
yy::]b4_parser_class_name[::debug_level_type ]b4_parser_class_name[::debug_level_type
yy::]b4_parser_class_name[::debug_level () const ]b4_parser_class_name[::debug_level () const
{ {
return yydebug_; return yydebug_;
} }
void void
yy::]b4_parser_class_name[::set_debug_level (debug_level_type l) ]b4_parser_class_name[::set_debug_level (debug_level_type l)
{ {
yydebug_ = l; yydebug_ = l;
} }
int int
yy::]b4_parser_class_name[::parse () ]b4_parser_class_name[::parse ()
{ {
/// Look-ahead and look-ahead in internal form. /// Look-ahead and look-ahead in internal form.
int yychar = yyempty_; int yychar = yyempty_;
int yytoken = 0; int yytoken = 0;
@@ -524,10 +530,10 @@ m4_pushdef([b4_dollar_dollar], [yylval])dnl
b4_initial_action b4_initial_action
m4_popdef([b4_dollar_dollar])dnl m4_popdef([b4_dollar_dollar])dnl
m4_popdef([b4_at_dollar])dnl m4_popdef([b4_at_dollar])dnl
/* Line __line__ of yacc.c. */ /* Line __line__ of yacc.c. */
b4_syncline([@oline@], [@ofile@])])dnl b4_syncline([@oline@], [@ofile@])])dnl
[ /* Initialize the stacks. The initial state will be pushed in [ /* Initialize the stacks. The initial state will be pushed in
yynewstate, since the latter expects the semantical and the yynewstate, since the latter expects the semantical and the
location values to have been already stored, initialize these location values to have been already stored, initialize these
stacks with a primary value. */ stacks with a primary value. */
@@ -538,13 +544,13 @@ b4_syncline([@oline@], [@ofile@])])dnl
yylocation_stack_.push (yylloc); yylocation_stack_.push (yylloc);
/* New state. */ /* New state. */
yynewstate: yynewstate:
yystate_stack_.push (yystate); yystate_stack_.push (yystate);
YYCDEBUG << "Entering state " << yystate << std::endl; YYCDEBUG << "Entering state " << yystate << std::endl;
goto yybackup; goto yybackup;
/* Backup. */ /* Backup. */
yybackup: yybackup:
/* Try to take a decision without look-ahead. */ /* Try to take a decision without look-ahead. */
yyn = yypact_[yystate]; yyn = yypact_[yystate];
@@ -556,7 +562,7 @@ yybackup:
{ {
YYCDEBUG << "Reading a token: "; YYCDEBUG << "Reading a token: ";
yychar = ]b4_c_function_call([yylex], [int], yychar = ]b4_c_function_call([yylex], [int],
[[YYSTYPE*], [&yylval]][]dnl [[YYSTYPE*], [&yylval]][]dnl
b4_location_if([, [[location*], [&yylloc]]])dnl b4_location_if([, [[location*], [&yylloc]]])dnl
m4_ifdef([b4_lex_param], [, ]b4_lex_param))[; m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
} }
@@ -612,19 +618,19 @@ m4_ifdef([b4_lex_param], [, ]b4_lex_param))[;
yystate = yyn; yystate = yyn;
goto yynewstate; goto yynewstate;
/*-----------------------------------------------------------. /*-----------------------------------------------------------.
| yydefault -- do the default action for the current state. | | yydefault -- do the default action for the current state. |
`-----------------------------------------------------------*/ `-----------------------------------------------------------*/
yydefault: yydefault:
yyn = yydefact_[yystate]; yyn = yydefact_[yystate];
if (yyn == 0) if (yyn == 0)
goto yyerrlab; goto yyerrlab;
goto yyreduce; goto yyreduce;
/*-----------------------------. /*-----------------------------.
| yyreduce -- Do a reduction. | | yyreduce -- Do a reduction. |
`-----------------------------*/ `-----------------------------*/
yyreduce: yyreduce:
yylen = yyr2_[yyn]; yylen = yyr2_[yyn];
/* If LEN_ is nonzero, implement the default value of the action: /* If LEN_ is nonzero, implement the default value of the action:
`$$ = $1'. Otherwise, use the top of the stack. `$$ = $1'. Otherwise, use the top of the stack.
@@ -648,8 +654,8 @@ yyreduce:
default: break; default: break;
} }
]/* Line __line__ of lalr1.cc. */ ]/* Line __line__ of lalr1.cc. */
b4_syncline([@oline@], [@ofile@])[ b4_syncline([@oline@], [@ofile@])[
yypop_ (yylen); yypop_ (yylen);
@@ -668,10 +674,10 @@ b4_syncline([@oline@], [@ofile@])[
yystate = yydefgoto_[yyn - yyntokens_]; yystate = yydefgoto_[yyn - yyntokens_];
goto yynewstate; goto yynewstate;
/*------------------------------------. /*------------------------------------.
| yyerrlab -- here on detecting error | | yyerrlab -- here on detecting error |
`------------------------------------*/ `------------------------------------*/
yyerrlab: yyerrlab:
/* If not already recovering from an error, report this error. */ /* If not already recovering from an error, report this error. */
if (!yyerrstatus_) if (!yyerrstatus_)
{ {
@@ -704,10 +710,10 @@ b4_error_verbose_if([, yytoken])[));
goto yyerrlab1; goto yyerrlab1;
/*---------------------------------------------------. /*---------------------------------------------------.
| yyerrorlab -- error raised explicitly by YYERROR. | | yyerrorlab -- error raised explicitly by YYERROR. |
`---------------------------------------------------*/ `---------------------------------------------------*/
yyerrorlab: yyerrorlab:
/* Pacify compilers like GCC when the user code never invokes /* Pacify compilers like GCC when the user code never invokes
YYERROR and the label yyerrorlab therefore never appears in user YYERROR and the label yyerrorlab therefore never appears in user
@@ -720,10 +726,10 @@ yyerrorlab:
yystate = yystate_stack_[0]; yystate = yystate_stack_[0];
goto yyerrlab1; goto yyerrlab1;
/*-------------------------------------------------------------. /*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR. | | yyerrlab1 -- common code for both syntax error and YYERROR. |
`-------------------------------------------------------------*/ `-------------------------------------------------------------*/
yyerrlab1: yyerrlab1:
yyerrstatus_ = 3; /* Each real token shifted decrements this. */ yyerrstatus_ = 3; /* Each real token shifted decrements this. */
for (;;) for (;;)
@@ -771,16 +777,16 @@ yyerrlab1:
goto yynewstate; goto yynewstate;
/* Accept. */ /* Accept. */
yyacceptlab: yyacceptlab:
yyresult = 0; yyresult = 0;
goto yyreturn; goto yyreturn;
/* Abort. */ /* Abort. */
yyabortlab: yyabortlab:
yyresult = 1; yyresult = 1;
goto yyreturn; goto yyreturn;
yyreturn: yyreturn:
if (yychar != yyeof_ && yychar != yyempty_) if (yychar != yyeof_ && yychar != yyempty_)
yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc); yydestruct_ ("Cleanup: discarding lookahead", yytoken, &yylval, &yylloc);
@@ -794,13 +800,13 @@ yyreturn:
} }
return yyresult; return yyresult;
} }
// Generate an error message. // Generate an error message.
std::string std::string
yy::]b4_parser_class_name[::yysyntax_error_ (int yystate]dnl ]b4_parser_class_name[::yysyntax_error_ (int yystate]dnl
b4_error_verbose_if([, int tok])[) b4_error_verbose_if([, int tok])[)
{ {
std::string res; std::string res;
#if YYERROR_VERBOSE #if YYERROR_VERBOSE
int yyn = yypact_[yystate]; int yyn = yypact_[yystate];
@@ -843,138 +849,138 @@ b4_error_verbose_if([, int tok])[)
#endif #endif
res = YY_("syntax error"); res = YY_("syntax error");
return res; return res;
} }
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */ STATE-NUM. */
const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) yy::b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[; const ]b4_int_type(b4_pact_ninf, b4_pact_ninf) b4_parser_class_name::yypact_ninf_ = b4_pact_ninf[;
const ]b4_int_type_for([b4_pact])[ const ]b4_int_type_for([b4_pact])[
yy::]b4_parser_class_name[::yypact_[] = ]b4_parser_class_name[::yypact_[] =
{ {
]b4_pact[ ]b4_pact[
}; };
/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
doesn't specify something else to do. Zero means the default is an doesn't specify something else to do. Zero means the default is an
error. */ error. */
const ]b4_int_type_for([b4_defact])[ const ]b4_int_type_for([b4_defact])[
yy::]b4_parser_class_name[::yydefact_[] = ]b4_parser_class_name[::yydefact_[] =
{ {
]b4_defact[ ]b4_defact[
}; };
/* YYPGOTO[NTERM-NUM]. */ /* YYPGOTO[NTERM-NUM]. */
const ]b4_int_type_for([b4_pgoto])[ const ]b4_int_type_for([b4_pgoto])[
yy::]b4_parser_class_name[::yypgoto_[] = ]b4_parser_class_name[::yypgoto_[] =
{ {
]b4_pgoto[ ]b4_pgoto[
}; };
/* YYDEFGOTO[NTERM-NUM]. */ /* YYDEFGOTO[NTERM-NUM]. */
const ]b4_int_type_for([b4_defgoto])[ const ]b4_int_type_for([b4_defgoto])[
yy::]b4_parser_class_name[::yydefgoto_[] = ]b4_parser_class_name[::yydefgoto_[] =
{ {
]b4_defgoto[ ]b4_defgoto[
}; };
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
positive, shift that token. If negative, reduce the rule which positive, shift that token. If negative, reduce the rule which
number is the opposite. If zero, do what YYDEFACT says. */ number is the opposite. If zero, do what YYDEFACT says. */
const ]b4_int_type(b4_table_ninf, b4_table_ninf) yy::b4_parser_class_name::yytable_ninf_ = b4_table_ninf[; const ]b4_int_type(b4_table_ninf, b4_table_ninf) b4_parser_class_name::yytable_ninf_ = b4_table_ninf[;
const ]b4_int_type_for([b4_table])[ const ]b4_int_type_for([b4_table])[
yy::]b4_parser_class_name[::yytable_[] = ]b4_parser_class_name[::yytable_[] =
{ {
]b4_table[ ]b4_table[
}; };
/* YYCHECK. */ /* YYCHECK. */
const ]b4_int_type_for([b4_check])[ const ]b4_int_type_for([b4_check])[
yy::]b4_parser_class_name[::yycheck_[] = ]b4_parser_class_name[::yycheck_[] =
{ {
]b4_check[ ]b4_check[
}; };
/* STOS_[STATE-NUM] -- The (internal number of the) accessing /* STOS_[STATE-NUM] -- The (internal number of the) accessing
symbol of state STATE-NUM. */ symbol of state STATE-NUM. */
const ]b4_int_type_for([b4_stos])[ const ]b4_int_type_for([b4_stos])[
yy::]b4_parser_class_name[::yystos_[] = ]b4_parser_class_name[::yystos_[] =
{ {
]b4_stos[ ]b4_stos[
}; };
#if YYDEBUG #if YYDEBUG
/* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
to YYLEX-NUM. */ to YYLEX-NUM. */
const ]b4_int_type_for([b4_toknum])[ const ]b4_int_type_for([b4_toknum])[
yy::]b4_parser_class_name[::yytoken_number_[] = ]b4_parser_class_name[::yytoken_number_[] =
{ {
]b4_toknum[ ]b4_toknum[
}; };
#endif #endif
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
const ]b4_int_type_for([b4_r1])[ const ]b4_int_type_for([b4_r1])[
yy::]b4_parser_class_name[::yyr1_[] = ]b4_parser_class_name[::yyr1_[] =
{ {
]b4_r1[ ]b4_r1[
}; };
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
const ]b4_int_type_for([b4_r2])[ const ]b4_int_type_for([b4_r2])[
yy::]b4_parser_class_name[::yyr2_[] = ]b4_parser_class_name[::yyr2_[] =
{ {
]b4_r2[ ]b4_r2[
}; };
#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
First, the terminals, then, starting at \a yyntokens_, nonterminals. */ First, the terminals, then, starting at \a yyntokens_, nonterminals. */
const char* const char*
const yy::]b4_parser_class_name[::yytname_[] = const ]b4_parser_class_name[::yytname_[] =
{ {
]b4_tname[ ]b4_tname[
}; };
#endif #endif
#if YYDEBUG #if YYDEBUG
/* YYRHS -- A `-1'-separated list of the rules' RHS. */ /* YYRHS -- A `-1'-separated list of the rules' RHS. */
const yy::]b4_parser_class_name[::rhs_number_type const ]b4_parser_class_name[::rhs_number_type
yy::]b4_parser_class_name[::yyrhs_[] = ]b4_parser_class_name[::yyrhs_[] =
{ {
]b4_rhs[ ]b4_rhs[
}; };
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
YYRHS. */ YYRHS. */
const ]b4_int_type_for([b4_prhs])[ const ]b4_int_type_for([b4_prhs])[
yy::]b4_parser_class_name[::yyprhs_[] = ]b4_parser_class_name[::yyprhs_[] =
{ {
]b4_prhs[ ]b4_prhs[
}; };
/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
const ]b4_int_type_for([b4_rline])[ const ]b4_int_type_for([b4_rline])[
yy::]b4_parser_class_name[::yyrline_[] = ]b4_parser_class_name[::yyrline_[] =
{ {
]b4_rline[ ]b4_rline[
}; };
// Print the state stack on the debug stream. // Print the state stack on the debug stream.
void void
yy::]b4_parser_class_name[::yystack_print_ () ]b4_parser_class_name[::yystack_print_ ()
{ {
*yycdebug_ << "Stack now"; *yycdebug_ << "Stack now";
for (state_stack_type::const_iterator i = yystate_stack_.begin (); for (state_stack_type::const_iterator i = yystate_stack_.begin ();
i != yystate_stack_.end (); ++i) i != yystate_stack_.end (); ++i)
*yycdebug_ << ' ' << *i; *yycdebug_ << ' ' << *i;
*yycdebug_ << std::endl; *yycdebug_ << std::endl;
} }
// Report on the debug stream that the rule \a yyrule is going to be reduced. // Report on the debug stream that the rule \a yyrule is going to be reduced.
void void
yy::]b4_parser_class_name[::yyreduce_print_ (int yyrule) ]b4_parser_class_name[::yyreduce_print_ (int yyrule)
{ {
unsigned int yylno = yyrline_[yyrule]; unsigned int yylno = yyrline_[yyrule];
/* Print the symbols being reduced, and their result. */ /* Print the symbols being reduced, and their result. */
*yycdebug_ << "Reducing stack by rule " << yyrule - 1 *yycdebug_ << "Reducing stack by rule " << yyrule - 1
@@ -983,13 +989,13 @@ yy::]b4_parser_class_name[::yyreduce_print_ (int yyrule)
0 <= yyrhs_[i]; ++i) 0 <= yyrhs_[i]; ++i)
*yycdebug_ << yytname_[yyrhs_[i]] << ' '; *yycdebug_ << yytname_[yyrhs_[i]] << ' ';
*yycdebug_ << "-> " << yytname_[yyr1_[yyrule]] << std::endl; *yycdebug_ << "-> " << yytname_[yyr1_[yyrule]] << std::endl;
} }
#endif // YYDEBUG #endif // YYDEBUG
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
yy::]b4_parser_class_name[::token_number_type ]b4_parser_class_name[::token_number_type
yy::]b4_parser_class_name[::yytranslate_ (int token) ]b4_parser_class_name[::yytranslate_ (int token)
{ {
static static
const token_number_type const token_number_type
translate_table[] = translate_table[] =
@@ -1000,19 +1006,21 @@ yy::]b4_parser_class_name[::yytranslate_ (int token)
return translate_table[token]; return translate_table[token];
else else
return yyundef_token_; return yyundef_token_;
} }
const int yy::]b4_parser_class_name[::yyeof_ = 0; const int ]b4_parser_class_name[::yyeof_ = 0;
const int yy::]b4_parser_class_name[::yylast_ = ]b4_last[; const int ]b4_parser_class_name[::yylast_ = ]b4_last[;
const int yy::]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[; const int ]b4_parser_class_name[::yynnts_ = ]b4_nterms_number[;
const int yy::]b4_parser_class_name[::yyempty_ = -2; const int ]b4_parser_class_name[::yyempty_ = -2;
const int yy::]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[; const int ]b4_parser_class_name[::yyfinal_ = ]b4_final_state_number[;
const int yy::]b4_parser_class_name[::yyterror_ = 1; const int ]b4_parser_class_name[::yyterror_ = 1;
const int yy::]b4_parser_class_name[::yyerrcode_ = 256; const int ]b4_parser_class_name[::yyerrcode_ = 256;
const int yy::]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[; const int ]b4_parser_class_name[::yyntokens_ = ]b4_tokens_number[;
const unsigned int yy::]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[; const unsigned int ]b4_parser_class_name[::yyuser_token_number_max_ = ]b4_user_token_number_max[;
const yy::]b4_parser_class_name[::token_number_type yy::]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[; const ]b4_parser_class_name[::token_number_type ]b4_parser_class_name[::yyundef_token_ = ]b4_undef_token_number[;
} // namespace yy
]b4_epilogue ]b4_epilogue
dnl dnl