data/lalr1.java

   1 # Java skeleton for Bison -*- autoconf -*-
   2
   3 # Copyright (C) 2007-2012 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-2012])
  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 (n-1).begin, rhs.locationAt (0).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       pop (1);
 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 + 1, null);
 307         ]b4_locations_if([[java.util.Arrays.fill (locStack, height - num + 1, height + 1, 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     yycdebug ("Starting parse\n");
 502     yyerrstatus_ = 0;
 503
 504 ]m4_ifdef([b4_initial_action], [
 505 m4_pushdef([b4_at_dollar],     [yylloc])dnl
 506 m4_pushdef([b4_dollar_dollar], [yylval])dnl
 507     /* User initialization code.  */
 508     b4_user_initial_action
 509 m4_popdef([b4_dollar_dollar])dnl
 510 m4_popdef([b4_at_dollar])])dnl
 511
 512   [  /* Initialize the stack.  */
 513     yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);
 514
 515     int label = YYNEWSTATE;
 516     for (;;)
 517       switch (label)
 518       {
 519         /* New state.  Unlike in the C/C++ skeletons, the state is already
 520            pushed when we come here.  */
 521       case YYNEWSTATE:
 522         yycdebug ("Entering state " + yystate + "\n");
 523         if (yydebug > 0)
 524           yystack.print (yyDebugStream);
 525
 526         /* Accept?  */
 527         if (yystate == yyfinal_)
 528           return true;
 529
 530         /* Take a decision.  First try without lookahead.  */
 531         yyn = yypact_[yystate];
 532         if (yy_pact_value_is_default_ (yyn))
 533           {
 534             label = YYDEFAULT;
 535             break;
 536           }
 537
 538         /* Read a lookahead token.  */
 539         if (yychar == yyempty_)
 540           {
 541             yycdebug ("Reading a token: ");
 542             yychar = yylexer.yylex ();]
 543             b4_locations_if([[
 544             yylloc = new ]b4_location_type[(yylexer.getStartPos (),
 545                             yylexer.getEndPos ());]])
 546             yylval = yylexer.getLVal ();[
 547           }
 548
 549         /* Convert token to internal form.  */
 550         if (yychar <= Lexer.EOF)
 551           {
 552             yychar = yytoken = Lexer.EOF;
 553             yycdebug ("Now at end of input.\n");
 554           }
 555         else
 556           {
 557             yytoken = yytranslate_ (yychar);
 558             yy_symbol_print ("Next token is", yytoken,
 559                              yylval]b4_locations_if([, yylloc])[);
 560           }
 561
 562         /* If the proper action on seeing token YYTOKEN is to reduce or to
 563            detect an error, take that action.  */
 564         yyn += yytoken;
 565         if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
 566           label = YYDEFAULT;
 567
 568         /* <= 0 means reduce or error.  */
 569         else if ((yyn = yytable_[yyn]) <= 0)
 570           {
 571             if (yy_table_value_is_error_ (yyn))
 572               label = YYERRLAB;
 573             else
 574               {
 575                 yyn = -yyn;
 576                 label = YYREDUCE;
 577               }
 578           }
 579
 580         else
 581           {
 582             /* Shift the lookahead token.  */
 583             yy_symbol_print ("Shifting", yytoken,
 584                              yylval]b4_locations_if([, yylloc])[);
 585
 586             /* Discard the token being shifted.  */
 587             yychar = yyempty_;
 588
 589             /* Count tokens shifted since error; after three, turn off error
 590                status.  */
 591             if (yyerrstatus_ > 0)
 592               --yyerrstatus_;
 593
 594             yystate = yyn;
 595             yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);
 596             label = YYNEWSTATE;
 597           }
 598         break;
 599
 600       /*-----------------------------------------------------------.
 601       | yydefault -- do the default action for the current state.  |
 602       `-----------------------------------------------------------*/
 603       case YYDEFAULT:
 604         yyn = yydefact_[yystate];
 605         if (yyn == 0)
 606           label = YYERRLAB;
 607         else
 608           label = YYREDUCE;
 609         break;
 610
 611       /*-----------------------------.
 612       | yyreduce -- Do a reduction.  |
 613       `-----------------------------*/
 614       case YYREDUCE:
 615         yylen = yyr2_[yyn];
 616         label = yyaction (yyn, yystack, yylen);
 617         yystate = yystack.stateAt (0);
 618         break;
 619
 620       /*------------------------------------.
 621       | yyerrlab -- here on detecting error |
 622       `------------------------------------*/
 623       case YYERRLAB:
 624         /* If not already recovering from an error, report this error.  */
 625         if (yyerrstatus_ == 0)
 626           {
 627             ++yynerrs_;
 628             if (yychar == yyempty_)
 629               yytoken = yyempty_;
 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         /* There are many possibilities here to consider:
 731            - Assume YYFAIL is not used.  It's too flawed to consider.
 732              See
 733              <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
 734              for details.  YYERROR is fine as it does not invoke this
 735              function.
 736            - If this state is a consistent state with a default action,
 737              then the only way this function was invoked is if the
 738              default action is an error action.  In that case, don't
 739              check for expected tokens because there are none.
 740            - The only way there can be no lookahead present (in tok) is
 741              if this state is a consistent state with a default action.
 742              Thus, detecting the absence of a lookahead is sufficient to
 743              determine that there is no unexpected or expected token to
 744              report.  In that case, just report a simple "syntax error".
 745            - Don't assume there isn't a lookahead just because this
 746              state is a consistent state with a default action.  There
 747              might have been a previous inconsistent state, consistent
 748              state with a non-default action, or user semantic action
 749              that manipulated yychar.  (However, yychar is currently out
 750              of scope during semantic actions.)
 751            - Of course, the expected token list depends on states to
 752              have correct lookahead information, and it depends on the
 753              parser not to perform extra reductions after fetching a
 754              lookahead from the scanner and before detecting a syntax
 755              error.  Thus, state merging (from LALR or IELR) and default
 756              reductions corrupt the expected token list.  However, the
 757              list is correct for canonical LR with one exception: it
 758              will still contain any token that will not be accepted due
 759              to an error action in a later state.
 760         */
 761         if (tok != yyempty_)
 762           {
 763             // FIXME: This method of building the message is not compatible
 764             // with internationalization.
 765             StringBuffer res =
 766               new StringBuffer ("syntax error, unexpected ");
 767             res.append (yytnamerr_ (yytname_[tok]));
 768             int yyn = yypact_[yystate];
 769             if (!yy_pact_value_is_default_ (yyn))
 770               {
 771                 /* Start YYX at -YYN if negative to avoid negative
 772                    indexes in YYCHECK.  In other words, skip the first
 773                    -YYN actions for this state because they are default
 774                    actions.  */
 775                 int yyxbegin = yyn < 0 ? -yyn : 0;
 776                 /* Stay within bounds of both yycheck and yytname.  */
 777                 int yychecklim = yylast_ - yyn + 1;
 778                 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
 779                 int count = 0;
 780                 for (int x = yyxbegin; x < yyxend; ++x)
 781                   if (yycheck_[x + yyn] == x && x != yyterror_
 782                       && !yy_table_value_is_error_ (yytable_[x + yyn]))
 783                     ++count;
 784                 if (count < 5)
 785                   {
 786                     count = 0;
 787                     for (int x = yyxbegin; x < yyxend; ++x)
 788                       if (yycheck_[x + yyn] == x && x != yyterror_
 789                           && !yy_table_value_is_error_ (yytable_[x + yyn]))
 790                         {
 791                           res.append (count++ == 0 ? ", expecting " : " or ");
 792                           res.append (yytnamerr_ (yytname_[x]));
 793                         }
 794                   }
 795               }
 796             return res.toString ();
 797           }
 798       }
 799 ]])[
 800     return "syntax error";
 801   }
 802
 803   /**
 804    * Whether the given <code>yypact_</code> value indicates a defaulted state.
 805    * @@param yyvalue   the value to check
 806    */
 807   private static boolean yy_pact_value_is_default_ (int yyvalue)
 808   {
 809     return yyvalue == yypact_ninf_;
 810   }
 811
 812   /**
 813    * Whether the given <code>yytable_</code> value indicates a syntax error.
 814    * @@param yyvalue   the value to check
 815    */
 816   private static boolean yy_table_value_is_error_ (int yyvalue)
 817   {
 818     return yyvalue == yytable_ninf_;
 819   }
 820
 821   private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[;
 822   private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[;
 823
 824   ]b4_parser_tables_define[
 825   ]b4_integral_parser_table_define([token_number], [b4_toknum],
 826      [TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
 827      to YYLEX-NUM.])[
 828
 829   /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
 830      First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
 831   ]b4_typed_parser_table_define([String], [tname], [b4_tname])[
 832
 833   ]b4_integral_parser_table_define([rline], [b4_rline],
 834   [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[
 835
 836   // Report on the debug stream that the rule yyrule is going to be reduced.
 837   private void yy_reduce_print (int yyrule, YYStack yystack)
 838   {
 839     if (yydebug == 0)
 840       return;
 841
 842     int yylno = yyrline_[yyrule];
 843     int yynrhs = yyr2_[yyrule];
 844     /* Print the symbols being reduced, and their result.  */
 845     yycdebug ("Reducing stack by rule " + (yyrule - 1)
 846               + " (line " + yylno + "), ");
 847
 848     /* The symbols being reduced.  */
 849     for (int yyi = 0; yyi < yynrhs; yyi++)
 850       yy_symbol_print ("   $" + (yyi + 1) + " =",
 851                        yystos_[yystack.stateAt(yynrhs - (yyi + 1))],
 852                        ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([,
 853                        b4_rhs_location(yynrhs, yyi + 1)])[);
 854   }
 855
 856   /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 857   ]b4_integral_parser_table_define([translate_table], [b4_translate])[
 858
 859   private static final ]b4_int_type_for([b4_translate])[ yytranslate_ (int t)
 860   {
 861     if (t >= 0 && t <= yyuser_token_number_max_)
 862       return yytranslate_table_[t];
 863     else
 864       return yyundef_token_;
 865   }
 866
 867   private static final int yylast_ = ]b4_last[;
 868   private static final int yynnts_ = ]b4_nterms_number[;
 869   private static final int yyempty_ = -2;
 870   private static final int yyfinal_ = ]b4_final_state_number[;
 871   private static final int yyterror_ = 1;
 872   private static final int yyerrcode_ = 256;
 873   private static final int yyntokens_ = ]b4_tokens_number[;
 874
 875   private static final int yyuser_token_number_max_ = ]b4_user_token_number_max[;
 876   private static final int yyundef_token_ = ]b4_undef_token_number[;
 877
 878 ]/* User implementation code.  */
 879 b4_percent_code_get[]dnl
 880
 881 }
 882
 883 b4_epilogue[]dnl
 884 m4_divert_pop(0)dnl