X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/8405b70c057cf1e117e81a77114b055d7c9b59f1..bcbbf654863dd285b176a0f54a75a28c4bdac1d3:/data/lalr1.java diff --git a/data/lalr1.java b/data/lalr1.java index 7c1add69..103c03dd 100644 --- a/data/lalr1.java +++ b/data/lalr1.java @@ -1,21 +1,19 @@ # 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 . m4_include(b4_pkgdatadir/[java.m4]) @@ -25,20 +23,26 @@ m4_ifval(m4_defn([b4_symbol_destructors]), []) 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 @ofile@. + * A Bison parser, automatically generated from ]m4_bpatsubst(b4_file_name, [^"\(.*\)"$], [\1])[. * * @@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[ @@ -59,7 +63,7 @@ b4_locations_if([[ public ]b4_position_type[ end; /** - * Create a ]b4_location_type[ denoting an empty range located at + * Create a ]b4_location_type[ 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) { @@ -69,7 +73,7 @@ b4_locations_if([[ /** * Create a ]b4_location_type[ 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; @@ -95,15 +99,15 @@ b4_locations_if([[ b4_token_enums(b4_tokens) b4_locations_if([[ - private ]b4_location_type[ yylloc (Stack rhs, int n) + 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 ]b4_parser_class_name[. */ @@ -121,68 +125,66 @@ b4_token_enums(b4_tokens) /** * 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 debugStream = System.err; + private java.io.PrintStream yyDebugStream = System.err; /** * Return the PrintStream on which the debugging output is * printed. */ - public final java.io.PrintStream getDebugStream () { return debugStream; } + public final java.io.PrintStream getDebugStream () { return yyDebugStream; } /** * Set the PrintStream on which the debug output is printed. * @@param s The stream that is used for debugging output. */ - public final void setDebugStream(java.io.PrintStream s) { debugStream = s; } + public final void setDebugStream(java.io.PrintStream s) { yyDebugStream = s; } private int yydebug = 0; @@ -199,38 +201,38 @@ b4_token_enums(b4_tokens) */ 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) { if (yydebug > 0) - debugStream.println (s); + yyDebugStream.println (s); } - private final class Stack { + 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]; - private int size = 16; - private int height = -1; - - public final void push (int state, ]b4_union_name[ value]dnl - b4_locations_if([, ]b4_location_type[ loc])[) { + public int size = 16; + public int height = -1; + + 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); @@ -239,8 +241,8 @@ b4_token_enums(b4_tokens) ]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; @@ -253,14 +255,14 @@ b4_token_enums(b4_tokens) } 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; } @@ -273,16 +275,16 @@ b4_token_enums(b4_tokens) return locStack[height - i]; } - ]])[public final ]b4_union_name[ valueAt (int i) { + ]])[public final ]b4_yystype[ valueAt (int i) { return valueStack[height - i]; } // Print the state stack on the debug stream. - private void print (java.io.PrintStream out) + 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]); @@ -306,11 +308,9 @@ b4_token_enums(b4_tokens) * 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; @@ -323,19 +323,19 @@ b4_token_enums(b4_tokens) * Return whether error recovery is being done. In this state, the parser * reads token until it reaches a known state, and then restarts normal * operation. */ - public final boolean yyrecovering () + public final boolean recovering () { return yyerrstatus_ == 0; } - private int yyaction (int yyn, Stack 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. */ @@ -343,7 +343,7 @@ b4_token_enums(b4_tokens) yyval = yystack.valueAt (yylen - 1); else yyval = yystack.valueAt (0); - + yy_reduce_print (yyn, yystack); switch (yyn) @@ -410,14 +410,14 @@ b4_token_enums(b4_tokens) `--------------------------------*/ 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 ()) + ")"); } /** @@ -427,7 +427,7 @@ b4_token_enums(b4_tokens) * @@return true 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_; @@ -438,7 +438,7 @@ b4_token_enums(b4_tokens) int yylen = 0; int yystate = 0; - Stack yystack = new Stack (); + YYStack yystack = new YYStack (); /* Error handling. */ int yynerrs_ = 0; @@ -452,9 +452,7 @@ b4_token_enums(b4_tokens) ]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; @@ -479,33 +477,31 @@ m4_popdef([b4_at_dollar])])dnl case YYNEWSTATE: yycdebug ("Entering state " + yystate + "\n"); if (yydebug > 0) - yystack.print (debugStream); - + 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) { @@ -516,58 +512,58 @@ m4_popdef([b4_at_dollar])])dnl { 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. | `-----------------------------*/ @@ -576,24 +572,26 @@ m4_popdef([b4_at_dollar])])dnl 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. */ @@ -603,17 +601,17 @@ m4_popdef([b4_at_dollar])])dnl 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. */ @@ -622,17 +620,17 @@ m4_popdef([b4_at_dollar])])dnl 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_) @@ -642,18 +640,18 @@ m4_popdef([b4_at_dollar])])dnl 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 (debugStream); + yystack.print (yyDebugStream); } - + ]b4_locations_if([ /* Muck with the stack to setup for yylloc. */ yystack.push (0, null, yylloc); @@ -664,16 +662,16 @@ m4_popdef([b4_at_dollar])])dnl /* 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; @@ -685,44 +683,96 @@ m4_popdef([b4_at_dollar])])dnl { 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 + + 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 yypact_ 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 yytable_ 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. */ @@ -732,9 +782,9 @@ m4_popdef([b4_at_dollar])])dnl ]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[ @@ -755,7 +805,7 @@ m4_popdef([b4_at_dollar])])dnl /* 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_[] = @@ -827,7 +877,7 @@ m4_popdef([b4_at_dollar])])dnl }; // Report on the debug stream that the rule yyrule is going to be reduced. - private void yy_reduce_print (int yyrule, Stack yystack) + private void yy_reduce_print (int yyrule, YYStack yystack) { if (yydebug == 0) return; @@ -842,7 +892,7 @@ m4_popdef([b4_at_dollar])])dnl 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)])[); }