OLD | NEW |
(Empty) | |
| 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_skeleto
n])]) |
| 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 wa
y. |
| 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, ]])[Str
ing 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, he
ight, 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([b
4_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, yytok
en)); |
| 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_n
inf[; |
| 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 |
OLD | NEW |