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