X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/7d424de14c0385012d328642bec6874c8e6cef17..89ff1b5e71a6d8aa34b3578282528adb43b198cd:/data/lalr1.java diff --git a/data/lalr1.java b/data/lalr1.java index c6bd4038..204c03fc 100644 --- a/data/lalr1.java +++ b/data/lalr1.java @@ -1,6 +1,6 @@ # Java skeleton for Bison -*- autoconf -*- -# Copyright (C) 2007, 2008, 2009, 2010 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, 2010]) + [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]); @@ -376,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 @@ -498,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])[); @@ -627,6 +622,8 @@ m4_popdef([b4_at_dollar])])dnl if (yyerrstatus_ == 0) { ++yynerrs_; + if (yychar == yyempty_) + yytoken = yyempty_; yyerror (]b4_locations_if([yylloc, ])[yysyntax_error (yystate, yytoken)); } @@ -686,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);])[ @@ -727,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_ (yytable_[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_ (yytable_[x + yyn])) - { - res.append (count++ == 0 ? ", expecting " : " or "); - res.append (yytnamerr_ (yytname_[x])); - } + ++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 (); } @@ -791,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) @@ -816,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)])[); } @@ -849,4 +873,4 @@ b4_percent_code_get[]dnl } b4_epilogue[]dnl -m4_divert_pop(0)dnl +b4_output_end()