[270] | 1 | # Java skeleton for Bison -*- autoconf -*-
|
---|
| 2 |
|
---|
| 3 | # Copyright (C) 2007, 2008 Free Software Foundation, Inc.
|
---|
| 4 |
|
---|
| 5 | # This program is free software: you can redistribute it and/or modify
|
---|
| 6 | # it under the terms of the GNU General Public License as published by
|
---|
| 7 | # the Free Software Foundation, either version 3 of the License, or
|
---|
| 8 | # (at your option) any later version.
|
---|
| 9 | #
|
---|
| 10 | # This program is distributed in the hope that it will be useful,
|
---|
| 11 | # but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 12 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
---|
| 13 | # GNU General Public License for more details.
|
---|
| 14 | #
|
---|
| 15 | # You should have received a copy of the GNU General Public License
|
---|
| 16 | # along with this program. If not, see <http://www.gnu.org/licenses/>.
|
---|
| 17 |
|
---|
| 18 | m4_include(b4_pkgdatadir/[java.m4])
|
---|
| 19 |
|
---|
| 20 | b4_defines_if([b4_fatal([%s: %%defines does not make sense in Java], [b4_skeleton])])
|
---|
| 21 | m4_ifval(m4_defn([b4_symbol_destructors]),
|
---|
| 22 | [b4_fatal([%s: %%destructor does not make sense in Java], [b4_skeleton])],
|
---|
| 23 | [])
|
---|
| 24 |
|
---|
| 25 | m4_divert_push(0)dnl
|
---|
| 26 | @output(b4_parser_file_name@)
|
---|
| 27 | b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java],
|
---|
| 28 | [2007, 2008])
|
---|
| 29 |
|
---|
| 30 | b4_percent_define_ifdef([package], [package b4_percent_define_get([package]);
|
---|
| 31 | ])[/* First part of user declarations. */
|
---|
| 32 | ]b4_pre_prologue
|
---|
| 33 | b4_percent_code_get([[imports]])
|
---|
| 34 | [/**
|
---|
| 35 | * A Bison parser, automatically generated from <tt>]m4_bpatsubst(b4_file_name, [^"\(.*\)"$], [\1])[</tt>.
|
---|
| 36 | *
|
---|
| 37 | * @@author LALR (1) parser skeleton written by Paolo Bonzini.
|
---|
| 38 | */
|
---|
| 39 | ]b4_public_if([public ])dnl
|
---|
| 40 | b4_abstract_if([abstract ])dnl
|
---|
| 41 | b4_final_if([final ])dnl
|
---|
| 42 | b4_strictfp_if([strictfp ])dnl
|
---|
| 43 | [class ]b4_parser_class_name[]dnl
|
---|
| 44 | b4_percent_define_get3([extends], [ extends ])dnl
|
---|
| 45 | b4_percent_define_get3([implements], [ implements ])[
|
---|
| 46 | {
|
---|
| 47 | ]b4_identification[
|
---|
| 48 |
|
---|
| 49 | /** True if verbose error messages are enabled. */
|
---|
| 50 | public boolean errorVerbose = ]b4_flag_value([error_verbose]);
|
---|
| 51 |
|
---|
| 52 | b4_locations_if([[
|
---|
| 53 | /**
|
---|
| 54 | * A class defining a pair of positions. Positions, defined by the
|
---|
| 55 | * <code>]b4_position_type[</code> class, denote a point in the input.
|
---|
| 56 | * Locations represent a part of the input through the beginning
|
---|
| 57 | * and ending positions. */
|
---|
| 58 | public class ]b4_location_type[ {
|
---|
| 59 | /** The first, inclusive, position in the range. */
|
---|
| 60 | public ]b4_position_type[ begin;
|
---|
| 61 |
|
---|
| 62 | /** The first position beyond the range. */
|
---|
| 63 | public ]b4_position_type[ end;
|
---|
| 64 |
|
---|
| 65 | /**
|
---|
| 66 | * Create a <code>]b4_location_type[</code> denoting an empty range located at
|
---|
| 67 | * a given point.
|
---|
| 68 | * @@param loc The position at which the range is anchored. */
|
---|
| 69 | public ]b4_location_type[ (]b4_position_type[ loc) {
|
---|
| 70 | this.begin = this.end = loc;
|
---|
| 71 | }
|
---|
| 72 |
|
---|
| 73 | /**
|
---|
| 74 | * Create a <code>]b4_location_type[</code> from the endpoints of the range.
|
---|
| 75 | * @@param begin The first position included in the range.
|
---|
| 76 | * @@param end The first position beyond the range. */
|
---|
| 77 | public ]b4_location_type[ (]b4_position_type[ begin, ]b4_position_type[ end) {
|
---|
| 78 | this.begin = begin;
|
---|
| 79 | this.end = end;
|
---|
| 80 | }
|
---|
| 81 |
|
---|
| 82 | /**
|
---|
| 83 | * Print a representation of the location. For this to be correct,
|
---|
| 84 | * <code>]b4_position_type[</code> should override the <code>equals</code>
|
---|
| 85 | * method. */
|
---|
| 86 | public String toString () {
|
---|
| 87 | if (begin.equals (end))
|
---|
| 88 | return begin.toString ();
|
---|
| 89 | else
|
---|
| 90 | return begin.toString () + "-" + end.toString ();
|
---|
| 91 | }
|
---|
| 92 | }
|
---|
| 93 |
|
---|
| 94 | ]])
|
---|
| 95 |
|
---|
| 96 | [ /** Token returned by the scanner to signal the end of its input. */
|
---|
| 97 | public static final int EOF = 0;]
|
---|
| 98 |
|
---|
| 99 | b4_token_enums(b4_tokens)
|
---|
| 100 |
|
---|
| 101 | b4_locations_if([[
|
---|
| 102 | private ]b4_location_type[ yylloc (YYStack rhs, int n)
|
---|
| 103 | {
|
---|
| 104 | if (n > 0)
|
---|
| 105 | return new ]b4_location_type[ (rhs.locationAt (1).begin, rhs.locationAt (n).end);
|
---|
| 106 | else
|
---|
| 107 | return new ]b4_location_type[ (rhs.locationAt (0).end);
|
---|
| 108 | }]])[
|
---|
| 109 |
|
---|
| 110 | /**
|
---|
| 111 | * Communication interface between the scanner and the Bison-generated
|
---|
| 112 | * parser <tt>]b4_parser_class_name[</tt>.
|
---|
| 113 | */
|
---|
| 114 | public interface Lexer {
|
---|
| 115 | ]b4_locations_if([[/**
|
---|
| 116 | * Method to retrieve the beginning position of the last scanned token.
|
---|
| 117 | * @@return the position at which the last scanned token starts. */
|
---|
| 118 | ]b4_position_type[ getStartPos ();
|
---|
| 119 |
|
---|
| 120 | /**
|
---|
| 121 | * Method to retrieve the ending position of the last scanned token.
|
---|
| 122 | * @@return the first position beyond the last scanned token. */
|
---|
| 123 | ]b4_position_type[ getEndPos ();]])[
|
---|
| 124 |
|
---|
| 125 | /**
|
---|
| 126 | * Method to retrieve the semantic value of the last scanned token.
|
---|
| 127 | * @@return the semantic value of the last scanned token. */
|
---|
| 128 | ]b4_yystype[ getLVal ();
|
---|
| 129 |
|
---|
| 130 | /**
|
---|
| 131 | * Entry point for the scanner. Returns the token identifier corresponding
|
---|
| 132 | * to the next token and prepares to return the semantic value
|
---|
| 133 | * ]b4_locations_if([and beginning/ending positions ])[of the token.
|
---|
| 134 | * @@return the token identifier corresponding to the next token. */
|
---|
| 135 | int yylex () ]b4_maybe_throws([b4_lex_throws])[;
|
---|
| 136 |
|
---|
| 137 | /**
|
---|
| 138 | * Entry point for error reporting. Emits an error
|
---|
| 139 | * ]b4_locations_if([referring to the given location ])[in a user-defined way.
|
---|
| 140 | *
|
---|
| 141 | * ]b4_locations_if([[@@param loc The location of the element to which the
|
---|
| 142 | * error message is related]])[
|
---|
| 143 | * @@param s The string for the error message. */
|
---|
| 144 | void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String s);]
|
---|
| 145 | }
|
---|
| 146 |
|
---|
| 147 | b4_lexer_if([[private class YYLexer implements Lexer {
|
---|
| 148 | ]b4_percent_code_get([[lexer]])[
|
---|
| 149 | }
|
---|
| 150 |
|
---|
| 151 | ]])[/** The object doing lexical analysis for us. */
|
---|
| 152 | private Lexer yylexer;
|
---|
| 153 | ]
|
---|
| 154 | b4_parse_param_vars
|
---|
| 155 |
|
---|
| 156 | b4_lexer_if([[
|
---|
| 157 | /**
|
---|
| 158 | * Instantiates the Bison-generated parser.
|
---|
| 159 | */
|
---|
| 160 | public ]b4_parser_class_name (b4_parse_param_decl([b4_lex_param_decl])[) {
|
---|
| 161 | this.yylexer = new YYLexer(]b4_lex_param_call[);
|
---|
| 162 | ]b4_parse_param_cons[
|
---|
| 163 | }
|
---|
| 164 | ]])
|
---|
| 165 |
|
---|
| 166 | /**
|
---|
| 167 | * Instantiates the Bison-generated parser.
|
---|
| 168 | * @@param yylexer The scanner that will supply tokens to the parser.
|
---|
| 169 | */
|
---|
| 170 | b4_lexer_if([[protected]], [[public]]) b4_parser_class_name[ (]b4_parse_param_decl([[Lexer yylexer]])[) {
|
---|
| 171 | this.yylexer = yylexer;
|
---|
| 172 | ]b4_parse_param_cons[
|
---|
| 173 | }
|
---|
| 174 |
|
---|
| 175 | private java.io.PrintStream yyDebugStream = System.err;
|
---|
| 176 |
|
---|
| 177 | /**
|
---|
| 178 | * Return the <tt>PrintStream</tt> on which the debugging output is
|
---|
| 179 | * printed.
|
---|
| 180 | */
|
---|
| 181 | public final java.io.PrintStream getDebugStream () { return yyDebugStream; }
|
---|
| 182 |
|
---|
| 183 | /**
|
---|
| 184 | * Set the <tt>PrintStream</tt> on which the debug output is printed.
|
---|
| 185 | * @@param s The stream that is used for debugging output.
|
---|
| 186 | */
|
---|
| 187 | public final void setDebugStream(java.io.PrintStream s) { yyDebugStream = s; }
|
---|
| 188 |
|
---|
| 189 | private int yydebug = 0;
|
---|
| 190 |
|
---|
| 191 | /**
|
---|
| 192 | * Answer the verbosity of the debugging output; 0 means that all kinds of
|
---|
| 193 | * output from the parser are suppressed.
|
---|
| 194 | */
|
---|
| 195 | public final int getDebugLevel() { return yydebug; }
|
---|
| 196 |
|
---|
| 197 | /**
|
---|
| 198 | * Set the verbosity of the debugging output; 0 means that all kinds of
|
---|
| 199 | * output from the parser are suppressed.
|
---|
| 200 | * @@param level The verbosity level for debugging output.
|
---|
| 201 | */
|
---|
| 202 | public final void setDebugLevel(int level) { yydebug = level; }
|
---|
| 203 |
|
---|
| 204 | private final int yylex () ]b4_maybe_throws([b4_lex_throws]) [{
|
---|
| 205 | return yylexer.yylex ();
|
---|
| 206 | }
|
---|
| 207 | protected final void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String s) {
|
---|
| 208 | yylexer.yyerror (]b4_locations_if([loc, ])[s);
|
---|
| 209 | }
|
---|
| 210 |
|
---|
| 211 | ]b4_locations_if([
|
---|
| 212 | protected final void yyerror (String s) {
|
---|
| 213 | yylexer.yyerror ((]b4_location_type[)null, s);
|
---|
| 214 | }
|
---|
| 215 | protected final void yyerror (]b4_position_type[ loc, String s) {
|
---|
| 216 | yylexer.yyerror (new ]b4_location_type[ (loc), s);
|
---|
| 217 | }])
|
---|
| 218 |
|
---|
| 219 | [protected final void yycdebug (String s) {
|
---|
| 220 | if (yydebug > 0)
|
---|
| 221 | yyDebugStream.println (s);
|
---|
| 222 | }
|
---|
| 223 |
|
---|
| 224 | private final class YYStack {
|
---|
| 225 | private int[] stateStack = new int[16];
|
---|
| 226 | ]b4_locations_if([[private ]b4_location_type[[] locStack = new ]b4_location_type[[16];]])[
|
---|
| 227 | private ]b4_yystype[[] valueStack = new ]b4_yystype[[16];
|
---|
| 228 |
|
---|
| 229 | public int size = 16;
|
---|
| 230 | public int height = -1;
|
---|
| 231 |
|
---|
| 232 | public final void push (int state, ]b4_yystype[ value]dnl
|
---|
| 233 | b4_locations_if([, ]b4_location_type[ loc])[) {
|
---|
| 234 | height++;
|
---|
| 235 | if (size == height)
|
---|
| 236 | {
|
---|
| 237 | int[] newStateStack = new int[size * 2];
|
---|
| 238 | System.arraycopy (stateStack, 0, newStateStack, 0, height);
|
---|
| 239 | stateStack = newStateStack;
|
---|
| 240 | ]b4_locations_if([[
|
---|
| 241 | ]b4_location_type[[] newLocStack = new ]b4_location_type[[size * 2];
|
---|
| 242 | System.arraycopy (locStack, 0, newLocStack, 0, height);
|
---|
| 243 | locStack = newLocStack;]])
|
---|
| 244 |
|
---|
| 245 | b4_yystype[[] newValueStack = new ]b4_yystype[[size * 2];
|
---|
| 246 | System.arraycopy (valueStack, 0, newValueStack, 0, height);
|
---|
| 247 | valueStack = newValueStack;
|
---|
| 248 |
|
---|
| 249 | size *= 2;
|
---|
| 250 | }
|
---|
| 251 |
|
---|
| 252 | stateStack[height] = state;
|
---|
| 253 | ]b4_locations_if([[locStack[height] = loc;]])[
|
---|
| 254 | valueStack[height] = value;
|
---|
| 255 | }
|
---|
| 256 |
|
---|
| 257 | public final void pop () {
|
---|
| 258 | height--;
|
---|
| 259 | }
|
---|
| 260 |
|
---|
| 261 | public final void pop (int num) {
|
---|
| 262 | // Avoid memory leaks... garbage collection is a white lie!
|
---|
| 263 | if (num > 0) {
|
---|
| 264 | java.util.Arrays.fill (valueStack, height - num + 1, height, null);
|
---|
| 265 | ]b4_locations_if([[java.util.Arrays.fill (locStack, height - num + 1, height, null);]])[
|
---|
| 266 | }
|
---|
| 267 | height -= num;
|
---|
| 268 | }
|
---|
| 269 |
|
---|
| 270 | public final int stateAt (int i) {
|
---|
| 271 | return stateStack[height - i];
|
---|
| 272 | }
|
---|
| 273 |
|
---|
| 274 | ]b4_locations_if([[public final ]b4_location_type[ locationAt (int i) {
|
---|
| 275 | return locStack[height - i];
|
---|
| 276 | }
|
---|
| 277 |
|
---|
| 278 | ]])[public final ]b4_yystype[ valueAt (int i) {
|
---|
| 279 | return valueStack[height - i];
|
---|
| 280 | }
|
---|
| 281 |
|
---|
| 282 | // Print the state stack on the debug stream.
|
---|
| 283 | public void print (java.io.PrintStream out)
|
---|
| 284 | {
|
---|
| 285 | out.print ("Stack now");
|
---|
| 286 |
|
---|
| 287 | for (int i = 0; i < height; i++)
|
---|
| 288 | {
|
---|
| 289 | out.print (' ');
|
---|
| 290 | out.print (stateStack[i]);
|
---|
| 291 | }
|
---|
| 292 | out.println ();
|
---|
| 293 | }
|
---|
| 294 | }
|
---|
| 295 |
|
---|
| 296 | /**
|
---|
| 297 | * Returned by a Bison action in order to stop the parsing process and
|
---|
| 298 | * return success (<tt>true</tt>). */
|
---|
| 299 | public static final int YYACCEPT = 0;
|
---|
| 300 |
|
---|
| 301 | /**
|
---|
| 302 | * Returned by a Bison action in order to stop the parsing process and
|
---|
| 303 | * return failure (<tt>false</tt>). */
|
---|
| 304 | public static final int YYABORT = 1;
|
---|
| 305 |
|
---|
| 306 | /**
|
---|
| 307 | * Returned by a Bison action in order to start error recovery without
|
---|
| 308 | * printing an error message. */
|
---|
| 309 | public static final int YYERROR = 2;
|
---|
| 310 |
|
---|
| 311 | /**
|
---|
| 312 | * Returned by a Bison action in order to print an error message and start
|
---|
| 313 | * error recovery. */
|
---|
| 314 | public static final int YYFAIL = 3;
|
---|
| 315 |
|
---|
| 316 | private static final int YYNEWSTATE = 4;
|
---|
| 317 | private static final int YYDEFAULT = 5;
|
---|
| 318 | private static final int YYREDUCE = 6;
|
---|
| 319 | private static final int YYERRLAB1 = 7;
|
---|
| 320 | private static final int YYRETURN = 8;
|
---|
| 321 |
|
---|
| 322 | private int yyerrstatus_ = 0;
|
---|
| 323 |
|
---|
| 324 | /**
|
---|
| 325 | * Return whether error recovery is being done. In this state, the parser
|
---|
| 326 | * reads token until it reaches a known state, and then restarts normal
|
---|
| 327 | * operation. */
|
---|
| 328 | public final boolean recovering ()
|
---|
| 329 | {
|
---|
| 330 | return yyerrstatus_ == 0;
|
---|
| 331 | }
|
---|
| 332 |
|
---|
| 333 | private int yyaction (int yyn, YYStack yystack, int yylen) ]b4_maybe_throws([b4_throws])[
|
---|
| 334 | {
|
---|
| 335 | ]b4_yystype[ yyval;
|
---|
| 336 | ]b4_locations_if([b4_location_type[ yyloc = yylloc (yystack, yylen);]])[
|
---|
| 337 |
|
---|
| 338 | /* If YYLEN is nonzero, implement the default value of the action:
|
---|
| 339 | `$$ = $1'. Otherwise, use the top of the stack.
|
---|
| 340 |
|
---|
| 341 | Otherwise, the following line sets YYVAL to garbage.
|
---|
| 342 | This behavior is undocumented and Bison
|
---|
| 343 | users should not rely upon it. */
|
---|
| 344 | if (yylen > 0)
|
---|
| 345 | yyval = yystack.valueAt (yylen - 1);
|
---|
| 346 | else
|
---|
| 347 | yyval = yystack.valueAt (0);
|
---|
| 348 |
|
---|
| 349 | yy_reduce_print (yyn, yystack);
|
---|
| 350 |
|
---|
| 351 | switch (yyn)
|
---|
| 352 | {
|
---|
| 353 | ]b4_user_actions[
|
---|
| 354 | default: break;
|
---|
| 355 | }
|
---|
| 356 |
|
---|
| 357 | yy_symbol_print ("-> $$ =", yyr1_[yyn], yyval]b4_locations_if([, yyloc])[);
|
---|
| 358 |
|
---|
| 359 | yystack.pop (yylen);
|
---|
| 360 | yylen = 0;
|
---|
| 361 |
|
---|
| 362 | /* Shift the result of the reduction. */
|
---|
| 363 | yyn = yyr1_[yyn];
|
---|
| 364 | int yystate = yypgoto_[yyn - yyntokens_] + yystack.stateAt (0);
|
---|
| 365 | if (0 <= yystate && yystate <= yylast_
|
---|
| 366 | && yycheck_[yystate] == yystack.stateAt (0))
|
---|
| 367 | yystate = yytable_[yystate];
|
---|
| 368 | else
|
---|
| 369 | yystate = yydefgoto_[yyn - yyntokens_];
|
---|
| 370 |
|
---|
| 371 | yystack.push (yystate, yyval]b4_locations_if([, yyloc])[);
|
---|
| 372 | return YYNEWSTATE;
|
---|
| 373 | }
|
---|
| 374 |
|
---|
| 375 | /* Return YYSTR after stripping away unnecessary quotes and
|
---|
| 376 | backslashes, so that it's suitable for yyerror. The heuristic is
|
---|
| 377 | that double-quoting is unnecessary unless the string contains an
|
---|
| 378 | apostrophe, a comma, or backslash (other than backslash-backslash).
|
---|
| 379 | YYSTR is taken from yytname. */
|
---|
| 380 | private final String yytnamerr_ (String yystr)
|
---|
| 381 | {
|
---|
| 382 | if (yystr.charAt (0) == '"')
|
---|
| 383 | {
|
---|
| 384 | StringBuffer yyr = new StringBuffer ();
|
---|
| 385 | strip_quotes: for (int i = 1; i < yystr.length (); i++)
|
---|
| 386 | switch (yystr.charAt (i))
|
---|
| 387 | {
|
---|
| 388 | case '\'':
|
---|
| 389 | case ',':
|
---|
| 390 | break strip_quotes;
|
---|
| 391 |
|
---|
| 392 | case '\\':
|
---|
| 393 | if (yystr.charAt(++i) != '\\')
|
---|
| 394 | break strip_quotes;
|
---|
| 395 | /* Fall through. */
|
---|
| 396 | default:
|
---|
| 397 | yyr.append (yystr.charAt (i));
|
---|
| 398 | break;
|
---|
| 399 |
|
---|
| 400 | case '"':
|
---|
| 401 | return yyr.toString ();
|
---|
| 402 | }
|
---|
| 403 | }
|
---|
| 404 | else if (yystr.equals ("$end"))
|
---|
| 405 | return "end of input";
|
---|
| 406 |
|
---|
| 407 | return yystr;
|
---|
| 408 | }
|
---|
| 409 |
|
---|
| 410 | /*--------------------------------.
|
---|
| 411 | | Print this symbol on YYOUTPUT. |
|
---|
| 412 | `--------------------------------*/
|
---|
| 413 |
|
---|
| 414 | private void yy_symbol_print (String s, int yytype,
|
---|
| 415 | ]b4_yystype[ yyvaluep]dnl
|
---|
| 416 | b4_locations_if([, Object yylocationp])[)
|
---|
| 417 | {
|
---|
| 418 | if (yydebug > 0)
|
---|
| 419 | yycdebug (s + (yytype < yyntokens_ ? " token " : " nterm ")
|
---|
| 420 | + yytname_[yytype] + " ("]b4_locations_if([
|
---|
| 421 | + yylocationp + ": "])[
|
---|
| 422 | + (yyvaluep == null ? "(null)" : yyvaluep.toString ()) + ")");
|
---|
| 423 | }
|
---|
| 424 |
|
---|
| 425 | /**
|
---|
| 426 | * Parse input from the scanner that was specified at object construction
|
---|
| 427 | * time. Return whether the end of the input was reached successfully.
|
---|
| 428 | *
|
---|
| 429 | * @@return <tt>true</tt> if the parsing succeeds. Note that this does not
|
---|
| 430 | * imply that there were no syntax errors.
|
---|
| 431 | */
|
---|
| 432 | public boolean parse () ]b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])[
|
---|
| 433 | {
|
---|
| 434 | /// Lookahead and lookahead in internal form.
|
---|
| 435 | int yychar = yyempty_;
|
---|
| 436 | int yytoken = 0;
|
---|
| 437 |
|
---|
| 438 | /* State. */
|
---|
| 439 | int yyn = 0;
|
---|
| 440 | int yylen = 0;
|
---|
| 441 | int yystate = 0;
|
---|
| 442 |
|
---|
| 443 | YYStack yystack = new YYStack ();
|
---|
| 444 |
|
---|
| 445 | /* Error handling. */
|
---|
| 446 | int yynerrs_ = 0;
|
---|
| 447 | ]b4_locations_if([/// The location where the error started.
|
---|
| 448 | ]b4_location_type[ yyerrloc = null;
|
---|
| 449 |
|
---|
| 450 | /// ]b4_location_type[ of the lookahead.
|
---|
| 451 | ]b4_location_type[ yylloc = new ]b4_location_type[ (null, null);
|
---|
| 452 |
|
---|
| 453 | /// @@$.
|
---|
| 454 | ]b4_location_type[ yyloc;])
|
---|
| 455 |
|
---|
| 456 | /// Semantic value of the lookahead.
|
---|
| 457 | b4_yystype[ yylval = null;
|
---|
| 458 |
|
---|
| 459 | int yyresult;
|
---|
| 460 |
|
---|
| 461 | yycdebug ("Starting parse\n");
|
---|
| 462 | yyerrstatus_ = 0;
|
---|
| 463 |
|
---|
| 464 | ]m4_ifdef([b4_initial_action], [
|
---|
| 465 | m4_pushdef([b4_at_dollar], [yylloc])dnl
|
---|
| 466 | m4_pushdef([b4_dollar_dollar], [yylval])dnl
|
---|
| 467 | /* User initialization code. */
|
---|
| 468 | b4_user_initial_action
|
---|
| 469 | m4_popdef([b4_dollar_dollar])dnl
|
---|
| 470 | m4_popdef([b4_at_dollar])])dnl
|
---|
| 471 |
|
---|
| 472 | [ /* Initialize the stack. */
|
---|
| 473 | yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);
|
---|
| 474 |
|
---|
| 475 | int label = YYNEWSTATE;
|
---|
| 476 | for (;;)
|
---|
| 477 | switch (label)
|
---|
| 478 | {
|
---|
| 479 | /* New state. Unlike in the C/C++ skeletons, the state is already
|
---|
| 480 | pushed when we come here. */
|
---|
| 481 | case YYNEWSTATE:
|
---|
| 482 | yycdebug ("Entering state " + yystate + "\n");
|
---|
| 483 | if (yydebug > 0)
|
---|
| 484 | yystack.print (yyDebugStream);
|
---|
| 485 |
|
---|
| 486 | /* Accept? */
|
---|
| 487 | if (yystate == yyfinal_)
|
---|
| 488 | return true;
|
---|
| 489 |
|
---|
| 490 | /* Take a decision. First try without lookahead. */
|
---|
| 491 | yyn = yypact_[yystate];
|
---|
| 492 | if (yyn == yypact_ninf_)
|
---|
| 493 | {
|
---|
| 494 | label = YYDEFAULT;
|
---|
| 495 | break;
|
---|
| 496 | }
|
---|
| 497 |
|
---|
| 498 | /* Read a lookahead token. */
|
---|
| 499 | if (yychar == yyempty_)
|
---|
| 500 | {
|
---|
| 501 | yycdebug ("Reading a token: ");
|
---|
| 502 | yychar = yylex ();]
|
---|
| 503 | b4_locations_if([[
|
---|
| 504 | yylloc = new ]b4_location_type[(yylexer.getStartPos (),
|
---|
| 505 | yylexer.getEndPos ());]])
|
---|
| 506 | yylval = yylexer.getLVal ();[
|
---|
| 507 | }
|
---|
| 508 |
|
---|
| 509 | /* Convert token to internal form. */
|
---|
| 510 | if (yychar <= EOF)
|
---|
| 511 | {
|
---|
| 512 | yychar = yytoken = EOF;
|
---|
| 513 | yycdebug ("Now at end of input.\n");
|
---|
| 514 | }
|
---|
| 515 | else
|
---|
| 516 | {
|
---|
| 517 | yytoken = yytranslate_ (yychar);
|
---|
| 518 | yy_symbol_print ("Next token is", yytoken,
|
---|
| 519 | yylval]b4_locations_if([, yylloc])[);
|
---|
| 520 | }
|
---|
| 521 |
|
---|
| 522 | /* If the proper action on seeing token YYTOKEN is to reduce or to
|
---|
| 523 | detect an error, take that action. */
|
---|
| 524 | yyn += yytoken;
|
---|
| 525 | if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
|
---|
| 526 | label = YYDEFAULT;
|
---|
| 527 |
|
---|
| 528 | /* <= 0 means reduce or error. */
|
---|
| 529 | else if ((yyn = yytable_[yyn]) <= 0)
|
---|
| 530 | {
|
---|
| 531 | if (yyn == 0 || yyn == yytable_ninf_)
|
---|
| 532 | label = YYFAIL;
|
---|
| 533 | else
|
---|
| 534 | {
|
---|
| 535 | yyn = -yyn;
|
---|
| 536 | label = YYREDUCE;
|
---|
| 537 | }
|
---|
| 538 | }
|
---|
| 539 |
|
---|
| 540 | else
|
---|
| 541 | {
|
---|
| 542 | /* Shift the lookahead token. */
|
---|
| 543 | yy_symbol_print ("Shifting", yytoken,
|
---|
| 544 | yylval]b4_locations_if([, yylloc])[);
|
---|
| 545 |
|
---|
| 546 | /* Discard the token being shifted. */
|
---|
| 547 | yychar = yyempty_;
|
---|
| 548 |
|
---|
| 549 | /* Count tokens shifted since error; after three, turn off error
|
---|
| 550 | status. */
|
---|
| 551 | if (yyerrstatus_ > 0)
|
---|
| 552 | --yyerrstatus_;
|
---|
| 553 |
|
---|
| 554 | yystate = yyn;
|
---|
| 555 | yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);
|
---|
| 556 | label = YYNEWSTATE;
|
---|
| 557 | }
|
---|
| 558 | break;
|
---|
| 559 |
|
---|
| 560 | /*-----------------------------------------------------------.
|
---|
| 561 | | yydefault -- do the default action for the current state. |
|
---|
| 562 | `-----------------------------------------------------------*/
|
---|
| 563 | case YYDEFAULT:
|
---|
| 564 | yyn = yydefact_[yystate];
|
---|
| 565 | if (yyn == 0)
|
---|
| 566 | label = YYFAIL;
|
---|
| 567 | else
|
---|
| 568 | label = YYREDUCE;
|
---|
| 569 | break;
|
---|
| 570 |
|
---|
| 571 | /*-----------------------------.
|
---|
| 572 | | yyreduce -- Do a reduction. |
|
---|
| 573 | `-----------------------------*/
|
---|
| 574 | case YYREDUCE:
|
---|
| 575 | yylen = yyr2_[yyn];
|
---|
| 576 | label = yyaction (yyn, yystack, yylen);
|
---|
| 577 | yystate = yystack.stateAt (0);
|
---|
| 578 | break;
|
---|
| 579 |
|
---|
| 580 | /*------------------------------------.
|
---|
| 581 | | yyerrlab -- here on detecting error |
|
---|
| 582 | `------------------------------------*/
|
---|
| 583 | case YYFAIL:
|
---|
| 584 | /* If not already recovering from an error, report this error. */
|
---|
| 585 | if (yyerrstatus_ == 0)
|
---|
| 586 | {
|
---|
| 587 | ++yynerrs_;
|
---|
| 588 | yyerror (]b4_locations_if([yylloc, ])[yysyntax_error (yystate, yytoken));
|
---|
| 589 | }
|
---|
| 590 |
|
---|
| 591 | ]b4_locations_if([yyerrloc = yylloc;])[
|
---|
| 592 | if (yyerrstatus_ == 3)
|
---|
| 593 | {
|
---|
| 594 | /* If just tried and failed to reuse lookahead token after an
|
---|
| 595 | error, discard it. */
|
---|
| 596 |
|
---|
| 597 | if (yychar <= EOF)
|
---|
| 598 | {
|
---|
| 599 | /* Return failure if at end of input. */
|
---|
| 600 | if (yychar == EOF)
|
---|
| 601 | return false;
|
---|
| 602 | }
|
---|
| 603 | else
|
---|
| 604 | yychar = yyempty_;
|
---|
| 605 | }
|
---|
| 606 |
|
---|
| 607 | /* Else will try to reuse lookahead token after shifting the error
|
---|
| 608 | token. */
|
---|
| 609 | label = YYERRLAB1;
|
---|
| 610 | break;
|
---|
| 611 |
|
---|
| 612 | /*---------------------------------------------------.
|
---|
| 613 | | errorlab -- error raised explicitly by YYERROR. |
|
---|
| 614 | `---------------------------------------------------*/
|
---|
| 615 | case YYERROR:
|
---|
| 616 |
|
---|
| 617 | ]b4_locations_if([yyerrloc = yystack.locationAt (yylen - 1);])[
|
---|
| 618 | /* Do not reclaim the symbols of the rule which action triggered
|
---|
| 619 | this YYERROR. */
|
---|
| 620 | yystack.pop (yylen);
|
---|
| 621 | yylen = 0;
|
---|
| 622 | yystate = yystack.stateAt (0);
|
---|
| 623 | label = YYERRLAB1;
|
---|
| 624 | break;
|
---|
| 625 |
|
---|
| 626 | /*-------------------------------------------------------------.
|
---|
| 627 | | yyerrlab1 -- common code for both syntax error and YYERROR. |
|
---|
| 628 | `-------------------------------------------------------------*/
|
---|
| 629 | case YYERRLAB1:
|
---|
| 630 | yyerrstatus_ = 3; /* Each real token shifted decrements this. */
|
---|
| 631 |
|
---|
| 632 | for (;;)
|
---|
| 633 | {
|
---|
| 634 | yyn = yypact_[yystate];
|
---|
| 635 | if (yyn != yypact_ninf_)
|
---|
| 636 | {
|
---|
| 637 | yyn += yyterror_;
|
---|
| 638 | if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
|
---|
| 639 | {
|
---|
| 640 | yyn = yytable_[yyn];
|
---|
| 641 | if (0 < yyn)
|
---|
| 642 | break;
|
---|
| 643 | }
|
---|
| 644 | }
|
---|
| 645 |
|
---|
| 646 | /* Pop the current state because it cannot handle the error token. */
|
---|
| 647 | if (yystack.height == 1)
|
---|
| 648 | return false;
|
---|
| 649 |
|
---|
| 650 | ]b4_locations_if([yyerrloc = yystack.locationAt (0);])[
|
---|
| 651 | yystack.pop ();
|
---|
| 652 | yystate = yystack.stateAt (0);
|
---|
| 653 | if (yydebug > 0)
|
---|
| 654 | yystack.print (yyDebugStream);
|
---|
| 655 | }
|
---|
| 656 |
|
---|
| 657 | ]b4_locations_if([
|
---|
| 658 | /* Muck with the stack to setup for yylloc. */
|
---|
| 659 | yystack.push (0, null, yylloc);
|
---|
| 660 | yystack.push (0, null, yyerrloc);
|
---|
| 661 | yyloc = yylloc (yystack, 2);
|
---|
| 662 | yystack.pop (2);])[
|
---|
| 663 |
|
---|
| 664 | /* Shift the error token. */
|
---|
| 665 | yy_symbol_print ("Shifting", yystos_[yyn],
|
---|
| 666 | yylval]b4_locations_if([, yyloc])[);
|
---|
| 667 |
|
---|
| 668 | yystate = yyn;
|
---|
| 669 | yystack.push (yyn, yylval]b4_locations_if([, yyloc])[);
|
---|
| 670 | label = YYNEWSTATE;
|
---|
| 671 | break;
|
---|
| 672 |
|
---|
| 673 | /* Accept. */
|
---|
| 674 | case YYACCEPT:
|
---|
| 675 | return true;
|
---|
| 676 |
|
---|
| 677 | /* Abort. */
|
---|
| 678 | case YYABORT:
|
---|
| 679 | return false;
|
---|
| 680 | }
|
---|
| 681 | }
|
---|
| 682 |
|
---|
| 683 | // Generate an error message.
|
---|
| 684 | private String yysyntax_error (int yystate, int tok)
|
---|
| 685 | {
|
---|
| 686 | if (errorVerbose)
|
---|
| 687 | {
|
---|
| 688 | int yyn = yypact_[yystate];
|
---|
| 689 | if (yypact_ninf_ < yyn && yyn <= yylast_)
|
---|
| 690 | {
|
---|
| 691 | StringBuffer res;
|
---|
| 692 |
|
---|
| 693 | /* Start YYX at -YYN if negative to avoid negative indexes in
|
---|
| 694 | YYCHECK. */
|
---|
| 695 | int yyxbegin = yyn < 0 ? -yyn : 0;
|
---|
| 696 |
|
---|
| 697 | /* Stay within bounds of both yycheck and yytname. */
|
---|
| 698 | int yychecklim = yylast_ - yyn + 1;
|
---|
| 699 | int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
|
---|
| 700 | int count = 0;
|
---|
| 701 | for (int x = yyxbegin; x < yyxend; ++x)
|
---|
| 702 | if (yycheck_[x + yyn] == x && x != yyterror_)
|
---|
| 703 | ++count;
|
---|
| 704 |
|
---|
| 705 | // FIXME: This method of building the message is not compatible
|
---|
| 706 | // with internationalization.
|
---|
| 707 | res = new StringBuffer ("syntax error, unexpected ");
|
---|
| 708 | res.append (yytnamerr_ (yytname_[tok]));
|
---|
| 709 | if (count < 5)
|
---|
| 710 | {
|
---|
| 711 | count = 0;
|
---|
| 712 | for (int x = yyxbegin; x < yyxend; ++x)
|
---|
| 713 | if (yycheck_[x + yyn] == x && x != yyterror_)
|
---|
| 714 | {
|
---|
| 715 | res.append (count++ == 0 ? ", expecting " : " or ");
|
---|
| 716 | res.append (yytnamerr_ (yytname_[x]));
|
---|
| 717 | }
|
---|
| 718 | }
|
---|
| 719 | return res.toString ();
|
---|
| 720 | }
|
---|
| 721 | }
|
---|
| 722 |
|
---|
| 723 | return "syntax error";
|
---|
| 724 | }
|
---|
| 725 |
|
---|
| 726 |
|
---|
| 727 | /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
|
---|
| 728 | STATE-NUM. */
|
---|
| 729 | private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[;
|
---|
| 730 | private static final ]b4_int_type_for([b4_pact])[ yypact_[] =
|
---|
| 731 | {
|
---|
| 732 | ]b4_pact[
|
---|
| 733 | };
|
---|
| 734 |
|
---|
| 735 | /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
|
---|
| 736 | doesn't specify something else to do. Zero means the default is an
|
---|
| 737 | error. */
|
---|
| 738 | private static final ]b4_int_type_for([b4_defact])[ yydefact_[] =
|
---|
| 739 | {
|
---|
| 740 | ]b4_defact[
|
---|
| 741 | };
|
---|
| 742 |
|
---|
| 743 | /* YYPGOTO[NTERM-NUM]. */
|
---|
| 744 | private static final ]b4_int_type_for([b4_pgoto])[ yypgoto_[] =
|
---|
| 745 | {
|
---|
| 746 | ]b4_pgoto[
|
---|
| 747 | };
|
---|
| 748 |
|
---|
| 749 | /* YYDEFGOTO[NTERM-NUM]. */
|
---|
| 750 | private static final ]b4_int_type_for([b4_defgoto])[
|
---|
| 751 | yydefgoto_[] =
|
---|
| 752 | {
|
---|
| 753 | ]b4_defgoto[
|
---|
| 754 | };
|
---|
| 755 |
|
---|
| 756 | /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
|
---|
| 757 | positive, shift that token. If negative, reduce the rule which
|
---|
| 758 | number is the opposite. If zero, do what YYDEFACT says. */
|
---|
| 759 | private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[;
|
---|
| 760 | private static final ]b4_int_type_for([b4_table])[
|
---|
| 761 | yytable_[] =
|
---|
| 762 | {
|
---|
| 763 | ]b4_table[
|
---|
| 764 | };
|
---|
| 765 |
|
---|
| 766 | /* YYCHECK. */
|
---|
| 767 | private static final ]b4_int_type_for([b4_check])[
|
---|
| 768 | yycheck_[] =
|
---|
| 769 | {
|
---|
| 770 | ]b4_check[
|
---|
| 771 | };
|
---|
| 772 |
|
---|
| 773 | /* STOS_[STATE-NUM] -- The (internal number of the) accessing
|
---|
| 774 | symbol of state STATE-NUM. */
|
---|
| 775 | private static final ]b4_int_type_for([b4_stos])[
|
---|
| 776 | yystos_[] =
|
---|
| 777 | {
|
---|
| 778 | ]b4_stos[
|
---|
| 779 | };
|
---|
| 780 |
|
---|
| 781 | /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
|
---|
| 782 | to YYLEX-NUM. */
|
---|
| 783 | private static final ]b4_int_type_for([b4_toknum])[
|
---|
| 784 | yytoken_number_[] =
|
---|
| 785 | {
|
---|
| 786 | ]b4_toknum[
|
---|
| 787 | };
|
---|
| 788 |
|
---|
| 789 | /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
|
---|
| 790 | private static final ]b4_int_type_for([b4_r1])[
|
---|
| 791 | yyr1_[] =
|
---|
| 792 | {
|
---|
| 793 | ]b4_r1[
|
---|
| 794 | };
|
---|
| 795 |
|
---|
| 796 | /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
|
---|
| 797 | private static final ]b4_int_type_for([b4_r2])[
|
---|
| 798 | yyr2_[] =
|
---|
| 799 | {
|
---|
| 800 | ]b4_r2[
|
---|
| 801 | };
|
---|
| 802 |
|
---|
| 803 | /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
|
---|
| 804 | First, the terminals, then, starting at \a yyntokens_, nonterminals. */
|
---|
| 805 | private static final String yytname_[] =
|
---|
| 806 | {
|
---|
| 807 | ]b4_tname[
|
---|
| 808 | };
|
---|
| 809 |
|
---|
| 810 | /* YYRHS -- A `-1'-separated list of the rules' RHS. */
|
---|
| 811 | private static final ]b4_int_type_for([b4_rhs])[ yyrhs_[] =
|
---|
| 812 | {
|
---|
| 813 | ]b4_rhs[
|
---|
| 814 | };
|
---|
| 815 |
|
---|
| 816 | /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
|
---|
| 817 | YYRHS. */
|
---|
| 818 | private static final ]b4_int_type_for([b4_prhs])[ yyprhs_[] =
|
---|
| 819 | {
|
---|
| 820 | ]b4_prhs[
|
---|
| 821 | };
|
---|
| 822 |
|
---|
| 823 | /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
|
---|
| 824 | private static final ]b4_int_type_for([b4_rline])[ yyrline_[] =
|
---|
| 825 | {
|
---|
| 826 | ]b4_rline[
|
---|
| 827 | };
|
---|
| 828 |
|
---|
| 829 | // Report on the debug stream that the rule yyrule is going to be reduced.
|
---|
| 830 | private void yy_reduce_print (int yyrule, YYStack yystack)
|
---|
| 831 | {
|
---|
| 832 | if (yydebug == 0)
|
---|
| 833 | return;
|
---|
| 834 |
|
---|
| 835 | int yylno = yyrline_[yyrule];
|
---|
| 836 | int yynrhs = yyr2_[yyrule];
|
---|
| 837 | /* Print the symbols being reduced, and their result. */
|
---|
| 838 | yycdebug ("Reducing stack by rule " + (yyrule - 1)
|
---|
| 839 | + " (line " + yylno + "), ");
|
---|
| 840 |
|
---|
| 841 | /* The symbols being reduced. */
|
---|
| 842 | for (int yyi = 0; yyi < yynrhs; yyi++)
|
---|
| 843 | yy_symbol_print (" $" + (yyi + 1) + " =",
|
---|
| 844 | yyrhs_[yyprhs_[yyrule] + yyi],
|
---|
| 845 | ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([,
|
---|
| 846 | b4_rhs_location(yynrhs, yyi + 1)])[);
|
---|
| 847 | }
|
---|
| 848 |
|
---|
| 849 | /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
|
---|
| 850 | private static final ]b4_int_type_for([b4_translate])[ yytranslate_table_[] =
|
---|
| 851 | {
|
---|
| 852 | ]b4_translate[
|
---|
| 853 | };
|
---|
| 854 |
|
---|
| 855 | private static final ]b4_int_type_for([b4_translate])[ yytranslate_ (int t)
|
---|
| 856 | {
|
---|
| 857 | if (t >= 0 && t <= yyuser_token_number_max_)
|
---|
| 858 | return yytranslate_table_[t];
|
---|
| 859 | else
|
---|
| 860 | return yyundef_token_;
|
---|
| 861 | }
|
---|
| 862 |
|
---|
| 863 | private static final int yylast_ = ]b4_last[;
|
---|
| 864 | private static final int yynnts_ = ]b4_nterms_number[;
|
---|
| 865 | private static final int yyempty_ = -2;
|
---|
| 866 | private static final int yyfinal_ = ]b4_final_state_number[;
|
---|
| 867 | private static final int yyterror_ = 1;
|
---|
| 868 | private static final int yyerrcode_ = 256;
|
---|
| 869 | private static final int yyntokens_ = ]b4_tokens_number[;
|
---|
| 870 |
|
---|
| 871 | private static final int yyuser_token_number_max_ = ]b4_user_token_number_max[;
|
---|
| 872 | private static final int yyundef_token_ = ]b4_undef_token_number[;
|
---|
| 873 |
|
---|
| 874 | ]/* User implementation code. */
|
---|
| 875 | b4_percent_code_get[]dnl
|
---|
| 876 |
|
---|
| 877 | }
|
---|
| 878 |
|
---|
| 879 | b4_epilogue
|
---|
| 880 | m4_divert_pop(0)dnl
|
---|