# Java skeleton for Bison -*- autoconf -*-
-# Copyright (C) 2007 Free Software Foundation, Inc.
+# Copyright (C) 2007-2012 Free Software Foundation, Inc.
-# This program is free software; you can redistribute it and/or modify
+# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
+# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
-
+#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
-
+#
# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
-# 02110-1301 USA
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
m4_include(b4_pkgdatadir/[java.m4])
[])
m4_divert_push(0)dnl
-@output(b4_parser_file_name@)
+@output(b4_parser_file_name@)@
b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java],
- [2007])
+ [2007-2012])
b4_percent_define_ifdef([package], [package b4_percent_define_get([package]);
])[/* First part of user declarations. */
]b4_pre_prologue
b4_percent_code_get([[imports]])
[/**
- * A Bison parser, automatically generated from <tt>@ofile@</tt>.
+ * A Bison parser, automatically generated from <tt>]m4_bpatsubst(b4_file_name, [^"\(.*\)"$], [\1])[</tt>.
*
* @@author LALR (1) parser skeleton written by Paolo Bonzini.
*/
-]b4_public_if([public ])b4_abstract_if([abstract ])[class ]b4_parser_class_name[
+]b4_public_if([public ])dnl
+b4_abstract_if([abstract ])dnl
+b4_final_if([final ])dnl
+b4_strictfp_if([strictfp ])dnl
+[class ]b4_parser_class_name[]dnl
+b4_percent_define_get3([extends], [ extends ])dnl
+b4_percent_define_get3([implements], [ implements ])[
{
]b4_identification[
public ]b4_position_type[ end;
/**
- * Create a ]b4_location_type[ denoting an empty range located at
+ * Create a <code>]b4_location_type[</code> denoting an empty range located at
* a given point.
* @@param loc The position at which the range is anchored. */
public ]b4_location_type[ (]b4_position_type[ loc) {
/**
* Create a <code>]b4_location_type[</code> from the endpoints of the range.
* @@param begin The first position included in the range.
- * @@param begin The first position beyond the range. */
+ * @@param end The first position beyond the range. */
public ]b4_location_type[ (]b4_position_type[ begin, ]b4_position_type[ end) {
this.begin = begin;
this.end = end;
private ]b4_location_type[ yylloc (YYStack rhs, int n)
{
if (n > 0)
- return new ]b4_location_type[ (rhs.locationAt (1).begin, rhs.locationAt (n).end);
+ return new ]b4_location_type[ (rhs.locationAt (n-1).begin, rhs.locationAt (0).end);
else
return new ]b4_location_type[ (rhs.locationAt (0).end);
- }]])
+ }]])[
- b4_pure_if([[/**
+ /**
* Communication interface between the scanner and the Bison-generated
* parser <tt>]b4_parser_class_name[</tt>.
*/
/**
* Method to retrieve the semantic value of the last scanned token.
* @@return the semantic value of the last scanned token. */
- ]b4_union_name[ getLVal ();]], [[
-
- /**
- * A place where the scanner can store the beginning position of the
- * last scanned token. */
- ]b4_locations_if([b4_position_type[ yystartpos;]])[
-
- /**
- * A place where the scanner can store the ending position of the last
- * scanned token, i.e. the first position beyond the last scanned token. */
- ]b4_locations_if([b4_position_type[ yyendpos;]])[
+ ]b4_yystype[ getLVal ();
/**
- * A place where the scanner can store the semantic value of the
- * last scanned token. */
- protected ]b4_union_name[ yylval;]])
-
- b4_single_class_if([], [[/**
* Entry point for the scanner. Returns the token identifier corresponding
- * to the next token and ]b4_pure_if([prepares to return], [stores])[
- * the semantic value]b4_locations_if([ and beginning/ending positions])[
- * of the token.
+ * to the next token and prepares to return the semantic value
+ * ]b4_locations_if([and beginning/ending positions ])[of the token.
* @@return the token identifier corresponding to the next token. */
- abstract int yylex (]b4_lex_param_decl) b4_maybe_throws([b4_lex_throws])[;
+ int yylex () ]b4_maybe_throws([b4_lex_throws])[;
/**
* Entry point for error reporting. Emits an error
- * ]b4_locations_if([ referring to the given location])[in a user-defined
- * way.
+ * ]b4_locations_if([referring to the given location ])[in a user-defined way.
*
- * ]b4_locations_if([loc], [[The location of the element to which the
+ * ]b4_locations_if([[@@param loc The location of the element to which the
* error message is related]])[
* @@param s The string for the error message. */
- abstract void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String s);]])
- b4_pure_if([}
+ void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String s);]
+ }
+
+ b4_lexer_if([[private class YYLexer implements Lexer {
+]b4_percent_code_get([[lexer]])[
+ }
+
+ ]])[/** The object doing lexical analysis for us. */
+ private Lexer yylexer;
+ ]
+ b4_parse_param_vars
- /** The object doing lexical analysis for us. */
- private Lexer yylex;])
- b4_parse_param_vars[
+b4_lexer_if([[
+ /**
+ * Instantiates the Bison-generated parser.
+ */
+ public ]b4_parser_class_name (b4_parse_param_decl([b4_lex_param_decl])[) {
+ this.yylexer = new YYLexer(]b4_lex_param_call[);
+ ]b4_parse_param_cons[
+ }
+]])
/**
- * Instantiates the Bison-generated parser. ]b4_pure_if([
- * @@param yylex The scanner that will supply tokens to the parser.])[
+ * Instantiates the Bison-generated parser.
+ * @@param yylexer The scanner that will supply tokens to the parser.
*/
- public ]b4_parser_class_name[ (]b4_parse_param_decl([b4_pure_if([Lexer yylex])])[) {
- ]b4_pure_if(this.yylex = yylex;)
- b4_parse_param_cons[
+ b4_lexer_if([[protected]], [[public]]) b4_parser_class_name[ (]b4_parse_param_decl([[Lexer yylexer]])[) {
+ this.yylexer = yylexer;
+ ]b4_parse_param_cons[
}
private java.io.PrintStream yyDebugStream = System.err;
*/
public final void setDebugLevel(int level) { yydebug = level; }
- ]b4_pure_if([[
- private final int yylex (]b4_lex_param_decl) b4_maybe_throws([b4_lex_throws]) [{
- return yylex.yylex (]b4_lex_param_call[);
+ private final int yylex () ]b4_maybe_throws([b4_lex_throws]) [{
+ return yylexer.yylex ();
}
protected final void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String s) {
- yylex.yyerror (]b4_locations_if([loc, ])[s);
- }]])
- b4_locations_if([
+ yylexer.yyerror (]b4_locations_if([loc, ])[s);
+ }
+
+ ]b4_locations_if([
protected final void yyerror (String s) {
- yyerror ((Location)null, s);
+ yylexer.yyerror ((]b4_location_type[)null, s);
}
protected final void yyerror (]b4_position_type[ loc, String s) {
- yyerror (new ]b4_location_type[ (loc), s);
+ yylexer.yyerror (new ]b4_location_type[ (loc), s);
}])
[protected final void yycdebug (String s) {
private final class YYStack {
private int[] stateStack = new int[16];
]b4_locations_if([[private ]b4_location_type[[] locStack = new ]b4_location_type[[16];]])[
- private ]b4_union_name[[] valueStack = new ]b4_union_name[[16];
+ private ]b4_yystype[[] valueStack = new ]b4_yystype[[16];
public int size = 16;
public int height = -1;
-
- public final void push (int state, ]b4_union_name[ value]dnl
- b4_locations_if([, ]b4_location_type[ loc])[) {
+
+ public final void push (int state, ]b4_yystype[ value]dnl
+ b4_locations_if([, ]b4_location_type[ loc])[) {
height++;
- if (size == height)
+ if (size == height)
{
int[] newStateStack = new int[size * 2];
System.arraycopy (stateStack, 0, newStateStack, 0, height);
]b4_location_type[[] newLocStack = new ]b4_location_type[[size * 2];
System.arraycopy (locStack, 0, newLocStack, 0, height);
locStack = newLocStack;]])
-
- b4_union_name[[] newValueStack = new ]b4_union_name[[size * 2];
+
+ b4_yystype[[] newValueStack = new ]b4_yystype[[size * 2];
System.arraycopy (valueStack, 0, newValueStack, 0, height);
valueStack = newValueStack;
}
public final void pop () {
- height--;
+ pop (1);
}
public final void pop (int num) {
// Avoid memory leaks... garbage collection is a white lie!
if (num > 0) {
- java.util.Arrays.fill (valueStack, height - num + 1, height, null);
- ]b4_locations_if([[java.util.Arrays.fill (locStack, height - num + 1, height, null);]])[
+ java.util.Arrays.fill (valueStack, height - num + 1, height + 1, null);
+ ]b4_locations_if([[java.util.Arrays.fill (locStack, height - num + 1, height + 1, null);]])[
}
height -= num;
}
return locStack[height - i];
}
- ]])[public final ]b4_union_name[ valueAt (int i) {
+ ]])[public final ]b4_yystype[ valueAt (int i) {
return valueStack[height - i];
}
public void print (java.io.PrintStream out)
{
out.print ("Stack now");
-
- for (int i = 0; i < height; i++)
+
+ for (int i = 0; i <= height; i++)
{
out.print (' ');
out.print (stateStack[i]);
* printing an error message. */
public static final int YYERROR = 2;
- /**
- * Returned by a Bison action in order to print an error message and start
- * error recovery. */
- public static final int YYFAIL = 3;
-
+ // Internal return codes that are not supported for user semantic
+ // actions.
+ private static final int YYERRLAB = 3;
private static final int YYNEWSTATE = 4;
private static final int YYDEFAULT = 5;
private static final int YYREDUCE = 6;
return yyerrstatus_ == 0;
}
- private int yyaction (int yyn, YYStack yystack, int yylen)
+ private int yyaction (int yyn, YYStack yystack, int yylen) ]b4_maybe_throws([b4_throws])[
{
- ]b4_union_name[ yyval;
+ ]b4_yystype[ yyval;
]b4_locations_if([b4_location_type[ yyloc = yylloc (yystack, yylen);]])[
/* If YYLEN is nonzero, implement the default value of the action:
`$$ = $1'. Otherwise, use the top of the stack.
-
+
Otherwise, the following line sets YYVAL to garbage.
This behavior is undocumented and Bison
users should not rely upon it. */
yyval = yystack.valueAt (yylen - 1);
else
yyval = yystack.valueAt (0);
-
+
yy_reduce_print (yyn, yystack);
switch (yyn)
`--------------------------------*/
private void yy_symbol_print (String s, int yytype,
- ]b4_union_name[ yyvaluep]dnl
+ ]b4_yystype[ yyvaluep]dnl
b4_locations_if([, Object yylocationp])[)
{
if (yydebug > 0)
yycdebug (s + (yytype < yyntokens_ ? " token " : " nterm ")
+ yytname_[yytype] + " ("]b4_locations_if([
+ yylocationp + ": "])[
- + (yyvaluep == null ? "(null)" : yyvaluep) + ")");
+ + (yyvaluep == null ? "(null)" : yyvaluep.toString ()) + ")");
}
/**
* @@return <tt>true</tt> if the parsing succeeds. Note that this does not
* imply that there were no syntax errors.
*/
- public boolean parse () ]b4_maybe_throws([b4_throws])[
+ public boolean parse () ]b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])[
{
/// Lookahead and lookahead in internal form.
int yychar = yyempty_;
]b4_location_type[ yyloc;])
/// Semantic value of the lookahead.
- b4_union_name[ yylval = null;
-
- int yyresult;
+ b4_yystype[ yylval = null;
yycdebug ("Starting parse\n");
yyerrstatus_ = 0;
]m4_ifdef([b4_initial_action], [
-m4_pushdef([b4_at_dollar], [yylloc])dnl
-m4_pushdef([b4_dollar_dollar], [yylval])dnl
- /* User initialization code. */
- b4_user_initial_action
-m4_popdef([b4_dollar_dollar])dnl
-m4_popdef([b4_at_dollar])])dnl
+b4_dollar_pushdef([yylval], [], [yylloc])dnl
+/* User initialization code. */
+b4_user_initial_action
+b4_dollar_popdef])[]dnl
[ /* Initialize the stack. */
yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);
yycdebug ("Entering state " + yystate + "\n");
if (yydebug > 0)
yystack.print (yyDebugStream);
-
+
/* Accept? */
if (yystate == yyfinal_)
return true;
-
+
/* Take a decision. First try without lookahead. */
yyn = yypact_[yystate];
- if (yyn == yypact_ninf_)
+ if (yy_pact_value_is_default_ (yyn))
{
label = YYDEFAULT;
break;
}
-
+
/* Read a lookahead token. */
if (yychar == yyempty_)
{
yycdebug ("Reading a token: ");
- yychar = yylex (]b4_lex_param_call[);]
- b4_locations_if([
- b4_pure_if([yylloc = new ]b4_location_type[(yylex.getStartPos (),
- yylex.getEndPos ());],
- [yylloc = new ]b4_location_type[(this.yystartpos,
- this.yyendpos);]);])
- b4_pure_if([yylval = yylex.getLVal ()], [yylval = this.yylval]);[
+ yychar = yylex ();]
+ b4_locations_if([[
+ yylloc = new ]b4_location_type[(yylexer.getStartPos (),
+ yylexer.getEndPos ());]])
+ yylval = yylexer.getLVal ();[
}
-
+
/* Convert token to internal form. */
if (yychar <= EOF)
{
{
yytoken = yytranslate_ (yychar);
yy_symbol_print ("Next token is", yytoken,
- yylval]b4_locations_if([, yylloc])[);
+ yylval]b4_locations_if([, yylloc])[);
}
-
+
/* If the proper action on seeing token YYTOKEN is to reduce or to
detect an error, take that action. */
yyn += yytoken;
if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
label = YYDEFAULT;
-
+
/* <= 0 means reduce or error. */
else if ((yyn = yytable_[yyn]) <= 0)
{
- if (yyn == 0 || yyn == yytable_ninf_)
- label = YYFAIL;
+ if (yy_table_value_is_error_ (yyn))
+ label = YYERRLAB;
else
{
yyn = -yyn;
label = YYREDUCE;
}
}
-
+
else
{
/* Shift the lookahead token. */
yy_symbol_print ("Shifting", yytoken,
- yylval]b4_locations_if([, yylloc])[);
-
+ yylval]b4_locations_if([, yylloc])[);
+
/* Discard the token being shifted. */
yychar = yyempty_;
-
+
/* Count tokens shifted since error; after three, turn off error
status. */
if (yyerrstatus_ > 0)
--yyerrstatus_;
-
+
yystate = yyn;
yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);
label = YYNEWSTATE;
}
break;
-
+
/*-----------------------------------------------------------.
| yydefault -- do the default action for the current state. |
`-----------------------------------------------------------*/
case YYDEFAULT:
yyn = yydefact_[yystate];
if (yyn == 0)
- label = YYFAIL;
+ label = YYERRLAB;
else
label = YYREDUCE;
break;
-
+
/*-----------------------------.
| yyreduce -- Do a reduction. |
`-----------------------------*/
label = yyaction (yyn, yystack, yylen);
yystate = yystack.stateAt (0);
break;
-
+
/*------------------------------------.
| yyerrlab -- here on detecting error |
`------------------------------------*/
- case YYFAIL:
+ case YYERRLAB:
/* If not already recovering from an error, report this error. */
if (yyerrstatus_ == 0)
{
- ++yynerrs_;
- yyerror (]b4_locations_if([yylloc, ])[yysyntax_error (yystate, yytoken));
+ ++yynerrs_;
+ if (yychar == yyempty_)
+ yytoken = yyempty_;
+ yyerror (]b4_locations_if([yylloc, ])[yysyntax_error (yystate, yytoken));
}
-
+
]b4_locations_if([yyerrloc = yylloc;])[
if (yyerrstatus_ == 3)
{
/* If just tried and failed to reuse lookahead token after an
error, discard it. */
-
+
if (yychar <= EOF)
{
/* Return failure if at end of input. */
else
yychar = yyempty_;
}
-
+
/* Else will try to reuse lookahead token after shifting the error
token. */
label = YYERRLAB1;
break;
-
+
/*---------------------------------------------------.
| errorlab -- error raised explicitly by YYERROR. |
`---------------------------------------------------*/
case YYERROR:
-
+
]b4_locations_if([yyerrloc = yystack.locationAt (yylen - 1);])[
/* Do not reclaim the symbols of the rule which action triggered
this YYERROR. */
yystate = yystack.stateAt (0);
label = YYERRLAB1;
break;
-
+
/*-------------------------------------------------------------.
| yyerrlab1 -- common code for both syntax error and YYERROR. |
`-------------------------------------------------------------*/
case YYERRLAB1:
yyerrstatus_ = 3; /* Each real token shifted decrements this. */
-
+
for (;;)
{
yyn = yypact_[yystate];
- if (yyn != yypact_ninf_)
+ if (!yy_pact_value_is_default_ (yyn))
{
yyn += yyterror_;
if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
break;
}
}
-
+
/* Pop the current state because it cannot handle the error token. */
- if (yystack.height == 1)
+ if (yystack.height == 0)
return false;
-
+
]b4_locations_if([yyerrloc = yystack.locationAt (0);])[
yystack.pop ();
yystate = yystack.stateAt (0);
if (yydebug > 0)
yystack.print (yyDebugStream);
}
-
+
]b4_locations_if([
/* Muck with the stack to setup for yylloc. */
yystack.push (0, null, yylloc);
/* Shift the error token. */
yy_symbol_print ("Shifting", yystos_[yyn],
yylval]b4_locations_if([, yyloc])[);
-
+
yystate = yyn;
yystack.push (yyn, yylval]b4_locations_if([, yyloc])[);
label = YYNEWSTATE;
break;
-
+
/* Accept. */
case YYACCEPT:
return true;
-
+
/* Abort. */
case YYABORT:
return false;
{
if (errorVerbose)
{
- int yyn = yypact_[yystate];
- if (yypact_ninf_ < yyn && yyn <= yylast_)
+ /* There are many possibilities here to consider:
+ - Assume YYFAIL is not used. It's too flawed to consider.
+ See
+ <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
+ for details. YYERROR is fine as it does not invoke this
+ function.
+ - If this state is a consistent state with a default action,
+ then the only way this function was invoked is if the
+ default action is an error action. In that case, don't
+ check for expected tokens because there are none.
+ - The only way there can be no lookahead present (in tok) is
+ if this state is a consistent state with a default action.
+ Thus, detecting the absence of a lookahead is sufficient to
+ determine that there is no unexpected or expected token to
+ report. In that case, just report a simple "syntax error".
+ - Don't assume there isn't a lookahead just because this
+ state is a consistent state with a default action. There
+ might have been a previous inconsistent state, consistent
+ state with a non-default action, or user semantic action
+ that manipulated yychar. (However, yychar is currently out
+ of scope during semantic actions.)
+ - Of course, the expected token list depends on states to
+ have correct lookahead information, and it depends on the
+ parser not to perform extra reductions after fetching a
+ lookahead from the scanner and before detecting a syntax
+ error. Thus, state merging (from LALR or IELR) and default
+ reductions corrupt the expected token list. However, the
+ list is correct for canonical LR with one exception: it
+ will still contain any token that will not be accepted due
+ to an error action in a later state.
+ */
+ if (tok != yyempty_)
{
- StringBuffer res;
-
- /* Start YYX at -YYN if negative to avoid negative indexes in
- YYCHECK. */
- int yyxbegin = yyn < 0 ? -yyn : 0;
-
- /* Stay within bounds of both yycheck and yytname. */
- int yychecklim = yylast_ - yyn + 1;
- int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
- int count = 0;
- for (int x = yyxbegin; x < yyxend; ++x)
- if (yycheck_[x + yyn] == x && x != yyterror_)
- ++count;
-
- // FIXME: This method of building the message is not compatible
- // with internationalization.
- res = new StringBuffer ("syntax error, unexpected ");
- res.append (yytnamerr_ (yytname_[tok]));
- if (count < 5)
- {
- count = 0;
- for (int x = yyxbegin; x < yyxend; ++x)
- if (yycheck_[x + yyn] == x && x != yyterror_)
- {
- res.append (count++ == 0 ? ", expecting " : " or ");
- res.append (yytnamerr_ (yytname_[x]));
- }
- }
- return res.toString ();
+ // FIXME: This method of building the message is not compatible
+ // with internationalization.
+ StringBuffer res =
+ new StringBuffer ("syntax error, unexpected ");
+ res.append (yytnamerr_ (yytname_[tok]));
+ int yyn = yypact_[yystate];
+ if (!yy_pact_value_is_default_ (yyn))
+ {
+ /* Start YYX at -YYN if negative to avoid negative
+ indexes in YYCHECK. In other words, skip the first
+ -YYN actions for this state because they are default
+ actions. */
+ int yyxbegin = yyn < 0 ? -yyn : 0;
+ /* Stay within bounds of both yycheck and yytname. */
+ int yychecklim = yylast_ - yyn + 1;
+ int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
+ int count = 0;
+ for (int x = yyxbegin; x < yyxend; ++x)
+ if (yycheck_[x + yyn] == x && x != yyterror_
+ && !yy_table_value_is_error_ (yytable_[x + yyn]))
+ ++count;
+ if (count < 5)
+ {
+ count = 0;
+ for (int x = yyxbegin; x < yyxend; ++x)
+ if (yycheck_[x + yyn] == x && x != yyterror_
+ && !yy_table_value_is_error_ (yytable_[x + yyn]))
+ {
+ res.append (count++ == 0 ? ", expecting " : " or ");
+ res.append (yytnamerr_ (yytname_[x]));
+ }
+ }
+ }
+ return res.toString ();
}
}
return "syntax error";
}
+ /**
+ * Whether the given <code>yypact_</code> value indicates a defaulted state.
+ * @@param yyvalue the value to check
+ */
+ private static boolean yy_pact_value_is_default_ (int yyvalue)
+ {
+ return yyvalue == yypact_ninf_;
+ }
+
+ /**
+ * Whether the given <code>yytable_</code> value indicates a syntax error.
+ * @@param yyvalue the value to check
+ */
+ private static boolean yy_table_value_is_error_ (int yyvalue)
+ {
+ return yyvalue == yytable_ninf_;
+ }
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
STATE-NUM. */
]b4_pact[
};
- /* 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
- error. */
+ /* YYDEFACT[S] -- default reduction number in state S. Performed when
+ YYTABLE doesn't specify something else to do. Zero means the
+ default is an error. */
private static final ]b4_int_type_for([b4_defact])[ yydefact_[] =
{
]b4_defact[
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
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 YYTABLE_NINF_, syntax error. */
private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[;
private static final ]b4_int_type_for([b4_table])[
yytable_[] =
for (int yyi = 0; yyi < yynrhs; yyi++)
yy_symbol_print (" $" + (yyi + 1) + " =",
yyrhs_[yyprhs_[yyrule] + yyi],
- ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([,
+ ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([,
b4_rhs_location(yynrhs, yyi + 1)])[);
}
projects / bison.git / blobdiff