X-Git-Url: https://git.saurik.com/bison.git/blobdiff_plain/c4ddc0fb0b96ca5a4abaeaae5155bf72818453f7..dd31e17d7e415d3be8fc603f752f7e975297bcc2:/data/lalr1.java?ds=sidebyside diff --git a/data/lalr1.java b/data/lalr1.java index 78953947..57ff9932 100644 --- a/data/lalr1.java +++ b/data/lalr1.java @@ -1,6 +1,6 @@ # Java skeleton for Bison -*- autoconf -*- -# Copyright (C) 2007, 2008 Free Software Foundation, Inc. +# Copyright (C) 2007-2012 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 @@ -17,15 +17,23 @@ m4_include(b4_pkgdatadir/[java.m4]) -b4_defines_if([b4_fatal([%s: %%defines does not make sense in Java], [b4_skeleton])]) -m4_ifval(m4_defn([b4_symbol_destructors]), - [b4_fatal([%s: %%destructor does not make sense in Java], [b4_skeleton])], - []) +b4_defines_if([b4_fatal([%s: %%defines does not make sense in Java], + [b4_skeleton])]) + +# We don't depend on %debug in Java, but pacify warnings about non-used flags. +b4_parse_trace_if([0], [0]) + +m4_define([b4_symbol_no_destructor_assert], +[b4_symbol_if([$1], [has_destructor], + [b4_fatal([%s: %s: %%destructor does not make sense in Java], + [b4_skeleton], + [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_copyright([Skeleton implementation for Bison LALR(1) parsers in Java], - [2007, 2008]) + [2007-2012]) b4_percent_define_ifdef([package], [package b4_percent_define_get([package]); ])[/* First part of user declarations. */ @@ -112,7 +120,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); }]])[ @@ -289,14 +297,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; } @@ -318,7 +326,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]); @@ -342,11 +350,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; @@ -492,8 +498,6 @@ b4_lexer_if([[ /// Semantic value of the lookahead. b4_yystype[ yylval = null; - int yyresult; - yycdebug ("Starting parse\n"); yyerrstatus_ = 0; @@ -525,7 +529,7 @@ m4_popdef([b4_at_dollar])])dnl /* Take a decision. First try without lookahead. */ yyn = yypact_[yystate]; - if (yyn == yypact_ninf_) + if (yy_pact_value_is_default_ (yyn)) { label = YYDEFAULT; break; @@ -564,8 +568,8 @@ m4_popdef([b4_at_dollar])])dnl /* <= 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; @@ -599,7 +603,7 @@ m4_popdef([b4_at_dollar])])dnl case YYDEFAULT: yyn = yydefact_[yystate]; if (yyn == 0) - label = YYFAIL; + label = YYERRLAB; else label = YYREDUCE; break; @@ -616,11 +620,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)); } @@ -668,7 +674,7 @@ m4_popdef([b4_at_dollar])])dnl 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_) @@ -721,96 +727,111 @@ 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: + - 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 "); + 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_) - { - res.append (count++ == 0 ? ", expecting " : " or "); - res.append (yytnamerr_ (yytname_[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 res.toString (); } } ]])[ return "syntax error"; } - /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing - STATE-NUM. */ - private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[; - ]b4_integral_parser_table([yypact_], [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. */ - ]b4_integral_parser_table([yydefact_], [b4_defact])[ - - /* YYPGOTO[NTERM-NUM]. */ - ]b4_integral_parser_table([yypgoto_], [b4_pgoto])[ + /** + * 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_; + } - /* YYDEFGOTO[NTERM-NUM]. */ - ]b4_integral_parser_table([yydefgoto_], [b4_defgoto])[ + /** + * 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_; + } - /* 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. */ + private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[; private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[; - ]b4_integral_parser_table([yytable_], [b4_table])[ - - /* YYCHECK. */ - ]b4_integral_parser_table([yycheck_], [b4_check])[ - - /* STOS_[STATE-NUM] -- The (internal number of the) accessing - symbol of state STATE-NUM. */ - ]b4_integral_parser_table([yystos_], [b4_stos])[ - - /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding - to YYLEX-NUM. */ - ]b4_integral_parser_table([yytoken_number_], [b4_toknum])[ - /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ - ]b4_integral_parser_table([yyr1_], [b4_r1])[ - - /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ - ]b4_integral_parser_table([yyr2_], [b4_r2])[ + ]b4_parser_tables_define[ + ]b4_integral_parser_table_define([token_number], [b4_toknum], + [TOKEN_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([String], [yytname_], [b4_tname])[ - - /* YYRHS -- A `-1'-separated list of the rules' RHS. */ - ]b4_integral_parser_table([yyrhs_], [b4_rhs])[ - - /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in - YYRHS. */ - ]b4_integral_parser_table([yyprhs_], [b4_prhs])[ + ]b4_typed_parser_table_define([String], [tname], [b4_tname])[ - /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */ - ]b4_integral_parser_table([yyrline_], [b4_rline])[ + ]b4_integral_parser_table_define([rline], [b4_rline], + [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) @@ -827,13 +848,13 @@ m4_popdef([b4_at_dollar])])dnl /* The symbols being reduced. */ for (int yyi = 0; yyi < yynrhs; yyi++) yy_symbol_print (" $" + (yyi + 1) + " =", - yyrhs_[yyprhs_[yyrule] + yyi], + yystos_[yystack.stateAt(yynrhs - (yyi + 1))], ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([, b4_rhs_location(yynrhs, yyi + 1)])[); } /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ - ]b4_integral_parser_table([yytranslate_table_], [b4_translate])[ + ]b4_integral_parser_table_define([translate_table], [b4_translate])[ private static final ]b4_int_type_for([b4_translate])[ yytranslate_ (int t) { @@ -859,5 +880,5 @@ b4_percent_code_get[]dnl } -b4_epilogue +b4_epilogue[]dnl m4_divert_pop(0)dnl