data/lalr1.java

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