X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/8405b70c057cf1e117e81a77114b055d7c9b59f1..642f240e229cb561b401ca8b897621c4c4b37fdc:/data/lalr1.java?ds=inline diff --git a/data/lalr1.java b/data/lalr1.java index 7c1add69..5fbce2b5 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, 2008, 2009 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, 2008, 2009]) 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); 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 yylex;]) - b4_parse_param_vars[ + ]])[/** The object doing lexical analysis for us. */ + private Lexer yylexer; + ] + b4_parse_param_vars +b4_lexer_if([[ /** - * Instantiates the Bison-generated parser. ]b4_pure_if([ - * @@param yylex The scanner that will supply tokens to the parser.])[ + * Instantiates the Bison-generated 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[ + 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[ } +]]) - private java.io.PrintStream debugStream = System.err; + /** + * Instantiates the Bison-generated parser. + * @@param yylexer The scanner that will supply tokens to the parser. + */ + 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; /** * 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]; + + public int size = 16; + public int height = -1; - 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 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; @@ -273,15 +275,15 @@ 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++) { out.print (' '); @@ -323,19 +325,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 +345,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 +412,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 +429,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 +440,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,7 +454,7 @@ b4_token_enums(b4_tokens) ]b4_location_type[ yyloc;]) /// Semantic value of the lookahead. - b4_union_name[ yylval = null; + b4_yystype[ yylval = null; int yyresult; @@ -479,12 +481,12 @@ 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_) @@ -492,20 +494,18 @@ m4_popdef([b4_at_dollar])])dnl 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,15 +516,15 @@ 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) { @@ -536,27 +536,27 @@ m4_popdef([b4_at_dollar])])dnl 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. | `-----------------------------------------------------------*/ @@ -567,7 +567,7 @@ m4_popdef([b4_at_dollar])])dnl else label = YYREDUCE; break; - + /*-----------------------------. | yyreduce -- Do a reduction. | `-----------------------------*/ @@ -576,7 +576,7 @@ m4_popdef([b4_at_dollar])])dnl label = yyaction (yyn, yystack, yylen); yystate = yystack.stateAt (0); break; - + /*------------------------------------. | yyerrlab -- here on detecting error | `------------------------------------*/ @@ -587,13 +587,13 @@ m4_popdef([b4_at_dollar])])dnl ++yynerrs_; 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 +603,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,13 +622,13 @@ 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]; @@ -642,18 +642,18 @@ m4_popdef([b4_at_dollar])])dnl break; } } - + /* Pop the current state because it cannot handle the error token. */ if (yystack.height == 1) 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 +664,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; @@ -732,9 +732,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[ @@ -827,7 +827,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 +842,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)])[); }