X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/f2b30bdf3713e6fa9fafd0fc6caed68e38248ebc..89ff1b5e71a6d8aa34b3578282528adb43b198cd:/data/lalr1.java?ds=sidebyside diff --git a/data/lalr1.java b/data/lalr1.java index 5f0cfd76..204c03fc 100644 --- a/data/lalr1.java +++ b/data/lalr1.java @@ -1,6 +1,6 @@ # Java skeleton for Bison -*- autoconf -*- -# Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc. +# Copyright (C) 2007-2013 Free Software Foundation, Inc. # 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 @@ -30,10 +30,9 @@ m4_define([b4_symbol_no_destructor_assert], [b4_symbol_action_location([$1], [destructor])])])]) b4_symbol_foreach([b4_symbol_no_destructor_assert]) -m4_divert_push(0)dnl -@output(b4_parser_file_name@)@ +b4_output_begin([b4_parser_file_name]) b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java], - [2007, 2008, 2009]) + [2007-2013]) b4_percent_define_ifdef([package], [package b4_percent_define_get([package]); ])[/* First part of user declarations. */ @@ -120,7 +119,7 @@ b4_locations_if([[ 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); }]])[ @@ -133,7 +132,7 @@ b4_locations_if([[ /** Token returned by the scanner to signal the end of its input. */ public static final int EOF = 0; -]b4_token_enums(b4_tokens)[ +]b4_token_enums[ ]b4_locations_if([[/** * Method to retrieve the beginning position of the last scanned token. @@ -297,14 +296,14 @@ b4_lexer_if([[ } 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; } @@ -326,7 +325,7 @@ b4_lexer_if([[ { out.print ("Stack now"); - for (int i = 0; i < height; i++) + for (int i = 0; i <= height; i++) { out.print (' '); out.print (stateStack[i]); @@ -350,11 +349,9 @@ b4_lexer_if([[ * 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; @@ -378,7 +375,7 @@ b4_lexer_if([[ ]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. + '$$ = $1'. Otherwise, use the top of the stack. Otherwise, the following line sets YYVAL to garbage. This behavior is undocumented and Bison @@ -500,18 +497,14 @@ b4_lexer_if([[ /// Semantic value of the lookahead. b4_yystype[ yylval = null; - int yyresult; - 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 +b4_dollar_pushdef([yylval], [], [yylloc])dnl /* User initialization code. */ b4_user_initial_action -m4_popdef([b4_dollar_dollar])dnl -m4_popdef([b4_at_dollar])])dnl +b4_dollar_popdef])[]dnl [ /* Initialize the stack. */ yystack.push (yystate, yylval]b4_locations_if([, yylloc])[); @@ -573,7 +566,7 @@ m4_popdef([b4_at_dollar])])dnl else if ((yyn = yytable_[yyn]) <= 0) { if (yy_table_value_is_error_ (yyn)) - label = YYFAIL; + label = YYERRLAB; else { yyn = -yyn; @@ -607,7 +600,7 @@ m4_popdef([b4_at_dollar])])dnl case YYDEFAULT: yyn = yydefact_[yystate]; if (yyn == 0) - label = YYFAIL; + label = YYERRLAB; else label = YYREDUCE; break; @@ -624,11 +617,13 @@ m4_popdef([b4_at_dollar])])dnl /*------------------------------------. | yyerrlab -- here on detecting error | `------------------------------------*/ - case YYFAIL: + case YYERRLAB: /* If not already recovering from an error, report this error. */ if (yyerrstatus_ == 0) { ++yynerrs_; + if (yychar == yyempty_) + yytoken = yyempty_; yyerror (]b4_locations_if([yylloc, ])[yysyntax_error (yystate, yytoken)); } @@ -688,7 +683,7 @@ m4_popdef([b4_at_dollar])])dnl } /* 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);])[ @@ -729,39 +724,66 @@ m4_popdef([b4_at_dollar])])dnl {]b4_error_verbose_if([[ if (yyErrorVerbose) { - int yyn = yypact_[yystate]; - if (yypact_ninf_ < yyn && yyn <= yylast_) + /* There are many possibilities here to consider: + - 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. 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_ (yycheck_[x + yyn])) - ++count; - // FIXME: This method of building the message is not compatible // with internationalization. - res = new StringBuffer ("syntax error, unexpected "); + StringBuffer res = + new StringBuffer ("syntax error, unexpected "); res.append (yytnamerr_ (yytname_[tok])); - if (count < 5) + int yyn = yypact_[yystate]; + if (!yy_pact_value_is_default_ (yyn)) { - count = 0; + /* 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_ (yycheck_[x + yyn])) - { - res.append (count++ == 0 ? ", expecting " : " or "); - res.append (yytnamerr_ (yytname_[x])); - } + && !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 (); } @@ -785,7 +807,7 @@ m4_popdef([b4_at_dollar])])dnl */ private static boolean yy_table_value_is_error_ (int yyvalue) { - return yyvalue == 0 || yyvalue == yytable_ninf_; + return yyvalue == yytable_ninf_; } private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[; @@ -793,15 +815,15 @@ m4_popdef([b4_at_dollar])])dnl ]b4_parser_tables_define[ ]b4_integral_parser_table_define([token_number], [b4_toknum], - [TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding - to YYLEX-NUM.])[ + [[YYTOKEN_NUMBER[YYLEX-NUM] -- Internal symbol number corresponding + to YYLEX-NUM.]])[ /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. First, the terminals, then, starting at \a yyntokens_, nonterminals. */ ]b4_typed_parser_table_define([String], [tname], [b4_tname])[ ]b4_integral_parser_table_define([rline], [b4_rline], - [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[ + [[YYRLINE[YYN] -- Source line where rule number YYN was defined.]])[ // Report on the debug stream that the rule yyrule is going to be reduced. private void yy_reduce_print (int yyrule, YYStack yystack) @@ -818,7 +840,7 @@ m4_popdef([b4_at_dollar])])dnl /* The symbols being reduced. */ for (int yyi = 0; yyi < yynrhs; yyi++) yy_symbol_print (" $" + (yyi + 1) + " =", - yystos_[yystack.stateAt(yyi + 1 - yynrhs)], + yystos_[yystack.stateAt(yynrhs - (yyi + 1))], ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([, b4_rhs_location(yynrhs, yyi + 1)])[); } @@ -851,4 +873,4 @@ b4_percent_code_get[]dnl } b4_epilogue[]dnl -m4_divert_pop(0)dnl +b4_output_end()