content: # Java skeleton for Bison -*- autoconf -*-
  
  # Copyright (C) 2007, 2008 Free Software Foundation, Inc.
  
  # This program is free software: you can redistribute it and/or modify
  # it under the terms of the GNU General Public License as published by
  # the Free Software Foundation, either version 3 of the License, or
  # (at your option) any later version.
  #
  # This program is distributed in the hope that it will be useful,
  # but WITHOUT ANY WARRANTY; without even the implied warranty of
  # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  # GNU General Public License for more details.
  #
  # You should have received a copy of the GNU General Public License
  # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  
  m4_include(b4_pkgdatadir/[java.m4])
  
  b4_defines_if([b4_fatal([%s: %%defines does not make sense in Java], [b4_skeleton])])
  m4_ifval(m4_defn([b4_symbol_destructors]),
          [b4_fatal([%s: %%destructor does not make sense in Java], [b4_skeleton])],
          [])
  
  m4_divert_push(0)dnl
  @output(b4_parser_file_name@)
  b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java],
    [2007, 2008])
  
  b4_percent_define_ifdef([package], [package b4_percent_define_get([package]);
  ])[/* First part of user declarations.  */
  ]b4_pre_prologue
  b4_percent_code_get([[imports]])
  [/**
   * A Bison parser, automatically generated from <tt>]m4_bpatsubst(b4_file_name, [^"\(.*\)"$], [\1])[</tt>.
   *
   * @@author LALR (1) parser skeleton written by Paolo Bonzini.
   */
  ]b4_public_if([public ])dnl
  b4_abstract_if([abstract ])dnl
  b4_final_if([final ])dnl
  b4_strictfp_if([strictfp ])dnl
  [class ]b4_parser_class_name[]dnl
  b4_percent_define_get3([extends], [ extends ])dnl
  b4_percent_define_get3([implements], [ implements ])[
  {
    ]b4_identification[
  
    /** True if verbose error messages are enabled.  */
    public boolean errorVerbose = ]b4_flag_value([error_verbose]);
  
  b4_locations_if([[
    /**
     * A class defining a pair of positions.  Positions, defined by the
     * <code>]b4_position_type[</code> class, denote a point in the input.
     * Locations represent a part of the input through the beginning
     * and ending positions.  */
    public class ]b4_location_type[ {
      /** The first, inclusive, position in the range.  */
      public ]b4_position_type[ begin;
  
      /** The first position beyond the range.  */
      public ]b4_position_type[ end;
  
      /**
       * Create a <code>]b4_location_type[</code> denoting an empty range located at
       * a given point.
       * @@param loc The position at which the range is anchored.  */
      public ]b4_location_type[ (]b4_position_type[ loc) {
        this.begin = this.end = loc;
      }
  
      /**
       * Create a <code>]b4_location_type[</code> from the endpoints of the range.
       * @@param begin The first position included in the range.
       * @@param end   The first position beyond the range.  */
      public ]b4_location_type[ (]b4_position_type[ begin, ]b4_position_type[ end) {
        this.begin = begin;
        this.end = end;
      }
  
      /**
       * Print a representation of the location.  For this to be correct,
       * <code>]b4_position_type[</code> should override the <code>equals</code>
       * method.  */
      public String toString () {
        if (begin.equals (end))
          return begin.toString ();
        else
          return begin.toString () + "-" + end.toString ();
      }
    }
  
  ]])
  
  [  /** Token returned by the scanner to signal the end of its input.  */
    public static final int EOF = 0;]
  
  b4_token_enums(b4_tokens)
  
    b4_locations_if([[
    private ]b4_location_type[ yylloc (YYStack rhs, int n)
    {
      if (n > 0)
        return new ]b4_location_type[ (rhs.locationAt (1).begin, rhs.locationAt (n).end);
      else
        return new ]b4_location_type[ (rhs.locationAt (0).end);
    }]])[
  
    /**
     * Communication interface between the scanner and the Bison-generated
     * parser <tt>]b4_parser_class_name[</tt>.
     */
    public interface Lexer {
      ]b4_locations_if([[/**
       * Method to retrieve the beginning position of the last scanned token.
       * @@return the position at which the last scanned token starts.  */
      ]b4_position_type[ getStartPos ();
  
      /**
       * Method to retrieve the ending position of the last scanned token.
       * @@return the first position beyond the last scanned token.  */
      ]b4_position_type[ getEndPos ();]])[
  
      /**
       * Method to retrieve the semantic value of the last scanned token.
       * @@return the semantic value of the last scanned token.  */
      ]b4_yystype[ getLVal ();
  
      /**
       * Entry point for the scanner.  Returns the token identifier corresponding
       * to the next token and prepares to return the semantic value
       * ]b4_locations_if([and beginning/ending positions ])[of the token. 
       * @@return the token identifier corresponding to the next token. */
      int yylex () ]b4_maybe_throws([b4_lex_throws])[;
  
      /**
       * Entry point for error reporting.  Emits an error
       * ]b4_locations_if([referring to the given location ])[in a user-defined way.
       *
       * ]b4_locations_if([[@@param loc The location of the element to which the
       *                error message is related]])[
       * @@param s The string for the error message.  */
       void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String s);]
    }
  
    b4_lexer_if([[private class YYLexer implements Lexer {
  ]b4_percent_code_get([[lexer]])[
    }
  
    ]])[/** The object doing lexical analysis for us.  */
    private Lexer yylexer;
    ]
    b4_parse_param_vars
  
  b4_lexer_if([[
    /**
     * Instantiates the Bison-generated parser.
     */
    public ]b4_parser_class_name (b4_parse_param_decl([b4_lex_param_decl])[) {
      this.yylexer = new YYLexer(]b4_lex_param_call[);
      ]b4_parse_param_cons[
    }
  ]])
  
    /**
     * Instantiates the Bison-generated parser.
     * @@param yylexer The scanner that will supply tokens to the parser.
     */
    b4_lexer_if([[protected]], [[public]]) b4_parser_class_name[ (]b4_parse_param_decl([[Lexer yylexer]])[) {
      this.yylexer = yylexer;
      ]b4_parse_param_cons[
    }
  
    private java.io.PrintStream yyDebugStream = System.err;
  
    /**
     * Return the <tt>PrintStream</tt> on which the debugging output is
     * printed.
     */
    public final java.io.PrintStream getDebugStream () { return yyDebugStream; }
  
    /**
     * Set the <tt>PrintStream</tt> on which the debug output is printed.
     * @@param s The stream that is used for debugging output.
     */
    public final void setDebugStream(java.io.PrintStream s) { yyDebugStream = s; }
  
    private int yydebug = 0;
  
    /**
     * Answer the verbosity of the debugging output; 0 means that all kinds of
     * output from the parser are suppressed.
     */
    public final int getDebugLevel() { return yydebug; }
  
    /**
     * Set the verbosity of the debugging output; 0 means that all kinds of
     * output from the parser are suppressed.
     * @@param level The verbosity level for debugging output.
     */
    public final void setDebugLevel(int level) { yydebug = level; }
  
    private final int yylex () ]b4_maybe_throws([b4_lex_throws]) [{
      return yylexer.yylex ();
    }
    protected final void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String s) {
      yylexer.yyerror (]b4_locations_if([loc, ])[s);
    }
  
    ]b4_locations_if([
    protected final void yyerror (String s) {
      yylexer.yyerror ((]b4_location_type[)null, s);
    }
    protected final void yyerror (]b4_position_type[ loc, String s) {
      yylexer.yyerror (new ]b4_location_type[ (loc), s);
    }])
  
    [protected final void yycdebug (String s) {
      if (yydebug > 0)
        yyDebugStream.println (s);
    }
  
    private final class YYStack {
      private int[] stateStack = new int[16];
      ]b4_locations_if([[private ]b4_location_type[[] locStack = new ]b4_location_type[[16];]])[
      private ]b4_yystype[[] valueStack = new ]b4_yystype[[16];
  
      public int size = 16;
      public int height = -1;
      
      public final void push (int state, ]b4_yystype[ value]dnl
      	   	      	    b4_locations_if([, ]b4_location_type[ loc])[) {
        height++;
        if (size == height) 
          {
  	  int[] newStateStack = new int[size * 2];
  	  System.arraycopy (stateStack, 0, newStateStack, 0, height);
  	  stateStack = newStateStack;
  	  ]b4_locations_if([[
  	  ]b4_location_type[[] newLocStack = new ]b4_location_type[[size * 2];
  	  System.arraycopy (locStack, 0, newLocStack, 0, height);
  	  locStack = newLocStack;]])
  	  
  	  b4_yystype[[] newValueStack = new ]b4_yystype[[size * 2];
  	  System.arraycopy (valueStack, 0, newValueStack, 0, height);
  	  valueStack = newValueStack;
  
  	  size *= 2;
  	}
  
        stateStack[height] = state;
        ]b4_locations_if([[locStack[height] = loc;]])[
        valueStack[height] = value;
      }
  
      public final void pop () {
        height--;
      }
  
      public final void pop (int num) {
        // Avoid memory leaks... garbage collection is a white lie!
        if (num > 0) {
  	java.util.Arrays.fill (valueStack, height - num + 1, height, null);
          ]b4_locations_if([[java.util.Arrays.fill (locStack, height - num + 1, height, null);]])[
        }
        height -= num;
      }
  
      public final int stateAt (int i) {
        return stateStack[height - i];
      }
  
      ]b4_locations_if([[public final ]b4_location_type[ locationAt (int i) {
        return locStack[height - i];
      }
  
      ]])[public final ]b4_yystype[ valueAt (int i) {
        return valueStack[height - i];
      }
  
      // Print the state stack on the debug stream.
      public void print (java.io.PrintStream out)
      {
        out.print ("Stack now");
        
        for (int i = 0; i < height; i++)
          {
  	  out.print (' ');
  	  out.print (stateStack[i]);
          }
        out.println ();
      }
    }
  
    /**
     * Returned by a Bison action in order to stop the parsing process and
     * return success (<tt>true</tt>).  */
    public static final int YYACCEPT = 0;
  
    /**
     * Returned by a Bison action in order to stop the parsing process and
     * return failure (<tt>false</tt>).  */
    public static final int YYABORT = 1;
  
    /**
     * Returned by a Bison action in order to start error recovery without
     * printing an error message.  */
    public static final int YYERROR = 2;
  
    /**
     * Returned by a Bison action in order to print an error message and start
     * error recovery.  */
    public static final int YYFAIL = 3;
  
    private static final int YYNEWSTATE = 4;
    private static final int YYDEFAULT = 5;
    private static final int YYREDUCE = 6;
    private static final int YYERRLAB1 = 7;
    private static final int YYRETURN = 8;
  
    private int yyerrstatus_ = 0;
  
    /**
     * Return whether error recovery is being done.  In this state, the parser
     * reads token until it reaches a known state, and then restarts normal
     * operation.  */
    public final boolean recovering ()
    {
      return yyerrstatus_ == 0;
    }
  
    private int yyaction (int yyn, YYStack yystack, int yylen) ]b4_maybe_throws([b4_throws])[
    {
      ]b4_yystype[ yyval;
      ]b4_locations_if([b4_location_type[ yyloc = yylloc (yystack, yylen);]])[
  
      /* If YYLEN is nonzero, implement the default value of the action:
         `$$ = $1'.  Otherwise, use the top of the stack.
      
         Otherwise, the following line sets YYVAL to garbage.
         This behavior is undocumented and Bison
         users should not rely upon it.  */
      if (yylen > 0)
        yyval = yystack.valueAt (yylen - 1);
      else
        yyval = yystack.valueAt (0);
      
      yy_reduce_print (yyn, yystack);
  
      switch (yyn)
        {
  	]b4_user_actions[
  	default: break;
        }
  
      yy_symbol_print ("-> $$ =", yyr1_[yyn], yyval]b4_locations_if([, yyloc])[);
  
      yystack.pop (yylen);
      yylen = 0;
  
      /* Shift the result of the reduction.  */
      yyn = yyr1_[yyn];
      int yystate = yypgoto_[yyn - yyntokens_] + yystack.stateAt (0);
      if (0 <= yystate && yystate <= yylast_
  	&& yycheck_[yystate] == yystack.stateAt (0))
        yystate = yytable_[yystate];
      else
        yystate = yydefgoto_[yyn - yyntokens_];
  
      yystack.push (yystate, yyval]b4_locations_if([, yyloc])[);
      return YYNEWSTATE;
    }
  
    /* Return YYSTR after stripping away unnecessary quotes and
       backslashes, so that it's suitable for yyerror.  The heuristic is
       that double-quoting is unnecessary unless the string contains an
       apostrophe, a comma, or backslash (other than backslash-backslash).
       YYSTR is taken from yytname.  */
    private final String yytnamerr_ (String yystr)
    {
      if (yystr.charAt (0) == '"')
        {
          StringBuffer yyr = new StringBuffer ();
          strip_quotes: for (int i = 1; i < yystr.length (); i++)
            switch (yystr.charAt (i))
              {
              case '\'':
              case ',':
                break strip_quotes;
  
              case '\\':
  	      if (yystr.charAt(++i) != '\\')
                  break strip_quotes;
                /* Fall through.  */
              default:
                yyr.append (yystr.charAt (i));
                break;
  
              case '"':
                return yyr.toString ();
              }
        }
      else if (yystr.equals ("$end"))
        return "end of input";
  
      return yystr;
    }
  
    /*--------------------------------.
    | Print this symbol on YYOUTPUT.  |
    `--------------------------------*/
  
    private void yy_symbol_print (String s, int yytype,
  			         ]b4_yystype[ yyvaluep]dnl
  				 b4_locations_if([, Object yylocationp])[)
    {
      if (yydebug > 0)
      yycdebug (s + (yytype < yyntokens_ ? " token " : " nterm ")
  	      + yytname_[yytype] + " ("]b4_locations_if([
  	      + yylocationp + ": "])[
  	      + (yyvaluep == null ? "(null)" : yyvaluep.toString ()) + ")");
    }
  
    /**
     * Parse input from the scanner that was specified at object construction
     * time.  Return whether the end of the input was reached successfully.
     *
     * @@return <tt>true</tt> if the parsing succeeds.  Note that this does not
     *          imply that there were no syntax errors.
     */
    public boolean parse () ]b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])[
    {
      /// Lookahead and lookahead in internal form.
      int yychar = yyempty_;
      int yytoken = 0;
  
      /* State.  */
      int yyn = 0;
      int yylen = 0;
      int yystate = 0;
  
      YYStack yystack = new YYStack ();
  
      /* Error handling.  */
      int yynerrs_ = 0;
      ]b4_locations_if([/// The location where the error started.
      ]b4_location_type[ yyerrloc = null;
  
      /// ]b4_location_type[ of the lookahead.
      ]b4_location_type[ yylloc = new ]b4_location_type[ (null, null);
  
      /// @@$.
      ]b4_location_type[ yyloc;])
  
      /// Semantic value of the lookahead.
      b4_yystype[ yylval = null;
  
      int yyresult;
  
      yycdebug ("Starting parse\n");
      yyerrstatus_ = 0;
  
  ]m4_ifdef([b4_initial_action], [
  m4_pushdef([b4_at_dollar],     [yylloc])dnl
  m4_pushdef([b4_dollar_dollar], [yylval])dnl
      /* User initialization code.  */
      b4_user_initial_action
  m4_popdef([b4_dollar_dollar])dnl
  m4_popdef([b4_at_dollar])])dnl
  
    [  /* Initialize the stack.  */
      yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);
  
      int label = YYNEWSTATE;
      for (;;)
        switch (label)
        {
          /* New state.  Unlike in the C/C++ skeletons, the state is already
  	   pushed when we come here.  */
        case YYNEWSTATE:
          yycdebug ("Entering state " + yystate + "\n");
          if (yydebug > 0)
            yystack.print (yyDebugStream);
      
          /* Accept?  */
          if (yystate == yyfinal_)
            return true;
      
          /* Take a decision.  First try without lookahead.  */
          yyn = yypact_[yystate];
          if (yyn == yypact_ninf_)
            {
              label = YYDEFAULT;
  	    break;
            }
      
          /* Read a lookahead token.  */
          if (yychar == yyempty_)
            {
  	    yycdebug ("Reading a token: ");
  	    yychar = yylex ();]
              b4_locations_if([[
  	    yylloc = new ]b4_location_type[(yylexer.getStartPos (),
  	    		   	            yylexer.getEndPos ());]])
              yylval = yylexer.getLVal ();[
            }
      
          /* Convert token to internal form.  */
          if (yychar <= EOF)
            {
  	    yychar = yytoken = EOF;
  	    yycdebug ("Now at end of input.\n");
            }
          else
            {
  	    yytoken = yytranslate_ (yychar);
  	    yy_symbol_print ("Next token is", yytoken,
  	    		     yylval]b4_locations_if([, yylloc])[);
            }
      
          /* If the proper action on seeing token YYTOKEN is to reduce or to
             detect an error, take that action.  */
          yyn += yytoken;
          if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
            label = YYDEFAULT;
      
          /* <= 0 means reduce or error.  */
          else if ((yyn = yytable_[yyn]) <= 0)
            {
  	    if (yyn == 0 || yyn == yytable_ninf_)
  	      label = YYFAIL;
  	    else
  	      {
  	        yyn = -yyn;
  	        label = YYREDUCE;
  	      }
            }
      
          else
            {
              /* Shift the lookahead token.  */
  	    yy_symbol_print ("Shifting", yytoken,
  	    		     yylval]b4_locations_if([, yylloc])[);
      
              /* Discard the token being shifted.  */
              yychar = yyempty_;
      
              /* Count tokens shifted since error; after three, turn off error
                 status.  */
              if (yyerrstatus_ > 0)
                --yyerrstatus_;
      
              yystate = yyn;
              yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);
              label = YYNEWSTATE;
            }
          break;
      
        /*-----------------------------------------------------------.
        | yydefault -- do the default action for the current state.  |
        `-----------------------------------------------------------*/
        case YYDEFAULT:
          yyn = yydefact_[yystate];
          if (yyn == 0)
            label = YYFAIL;
          else
            label = YYREDUCE;
          break;
      
        /*-----------------------------.
        | yyreduce -- Do a reduction.  |
        `-----------------------------*/
        case YYREDUCE:
          yylen = yyr2_[yyn];
          label = yyaction (yyn, yystack, yylen);
  	yystate = yystack.stateAt (0);
          break;
      
        /*------------------------------------.
        | yyerrlab -- here on detecting error |
        `------------------------------------*/
        case YYFAIL:
          /* If not already recovering from an error, report this error.  */
          if (yyerrstatus_ == 0)
            {
  	    ++yynerrs_;
  	    yyerror (]b4_locations_if([yylloc, ])[yysyntax_error (yystate, yytoken));
            }
      
          ]b4_locations_if([yyerrloc = yylloc;])[
          if (yyerrstatus_ == 3)
            {
  	    /* If just tried and failed to reuse lookahead token after an
  	     error, discard it.  */
      
  	    if (yychar <= EOF)
  	      {
  	      /* Return failure if at end of input.  */
  	      if (yychar == EOF)
  	        return false;
  	      }
  	    else
  	      yychar = yyempty_;
            }
      
          /* Else will try to reuse lookahead token after shifting the error
             token.  */
          label = YYERRLAB1;
          break;
      
        /*---------------------------------------------------.
        | errorlab -- error raised explicitly by YYERROR.  |
        `---------------------------------------------------*/
        case YYERROR:
      
          ]b4_locations_if([yyerrloc = yystack.locationAt (yylen - 1);])[
          /* Do not reclaim the symbols of the rule which action triggered
             this YYERROR.  */
          yystack.pop (yylen);
          yylen = 0;
          yystate = yystack.stateAt (0);
          label = YYERRLAB1;
          break;
      
        /*-------------------------------------------------------------.
        | yyerrlab1 -- common code for both syntax error and YYERROR.  |
        `-------------------------------------------------------------*/
        case YYERRLAB1:
          yyerrstatus_ = 3;	/* Each real token shifted decrements this.  */
      
          for (;;)
            {
  	    yyn = yypact_[yystate];
  	    if (yyn != yypact_ninf_)
  	      {
  	        yyn += yyterror_;
  	        if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
  	          {
  	            yyn = yytable_[yyn];
  	            if (0 < yyn)
  		      break;
  	          }
  	      }
      
  	    /* Pop the current state because it cannot handle the error token.  */
  	    if (yystack.height == 1)
  	      return false;
      
  	    ]b4_locations_if([yyerrloc = yystack.locationAt (0);])[
  	    yystack.pop ();
  	    yystate = yystack.stateAt (0);
  	    if (yydebug > 0)
  	      yystack.print (yyDebugStream);
            }
      
  	]b4_locations_if([
  	/* Muck with the stack to setup for yylloc.  */
  	yystack.push (0, null, yylloc);
  	yystack.push (0, null, yyerrloc);
          yyloc = yylloc (yystack, 2);
  	yystack.pop (2);])[
  
          /* Shift the error token.  */
          yy_symbol_print ("Shifting", yystos_[yyn],
  			 yylval]b4_locations_if([, yyloc])[);
      
          yystate = yyn;
  	yystack.push (yyn, yylval]b4_locations_if([, yyloc])[);
          label = YYNEWSTATE;
          break;
      
          /* Accept.  */
        case YYACCEPT:
          return true;
      
          /* Abort.  */
        case YYABORT:
          return false;
        }
    }
  
    // Generate an error message.
    private String yysyntax_error (int yystate, int tok)
    {
      if (errorVerbose)
        {
          int yyn = yypact_[yystate];
          if (yypact_ninf_ < yyn && yyn <= yylast_)
            {
  	    StringBuffer res;
  
  	    /* Start YYX at -YYN if negative to avoid negative indexes in
  	       YYCHECK.  */
  	    int yyxbegin = yyn < 0 ? -yyn : 0;
  
  	    /* Stay within bounds of both yycheck and yytname.  */
  	    int yychecklim = yylast_ - yyn + 1;
  	    int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
  	    int count = 0;
  	    for (int x = yyxbegin; x < yyxend; ++x)
  	      if (yycheck_[x + yyn] == x && x != yyterror_)
  	        ++count;
  
  	    // FIXME: This method of building the message is not compatible
  	    // with internationalization.
  	    res = new StringBuffer ("syntax error, unexpected ");
  	    res.append (yytnamerr_ (yytname_[tok]));
  	    if (count < 5)
  	      {
  	        count = 0;
  	        for (int x = yyxbegin; x < yyxend; ++x)
  	          if (yycheck_[x + yyn] == x && x != yyterror_)
  		    {
  		      res.append (count++ == 0 ? ", expecting " : " or ");
  		      res.append (yytnamerr_ (yytname_[x]));
  		    }
  	      }
  	    return res.toString ();
            }
        }
  
      return "syntax error";
    }
  
  
    /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
       STATE-NUM.  */
    private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[;
    private static final ]b4_int_type_for([b4_pact])[ yypact_[] =
    {
      ]b4_pact[
    };
  
    /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
       doesn't specify something else to do.  Zero means the default is an
       error.  */
    private static final ]b4_int_type_for([b4_defact])[ yydefact_[] =
    {
      ]b4_defact[
    };
  
    /* YYPGOTO[NTERM-NUM].  */
    private static final ]b4_int_type_for([b4_pgoto])[ yypgoto_[] =
    {
      ]b4_pgoto[
    };
  
    /* YYDEFGOTO[NTERM-NUM].  */
    private static final ]b4_int_type_for([b4_defgoto])[
    yydefgoto_[] =
    {
      ]b4_defgoto[
    };
  
    /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
       positive, shift that token.  If negative, reduce the rule which
       number is the opposite.  If zero, do what YYDEFACT says.  */
    private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[;
    private static final ]b4_int_type_for([b4_table])[
    yytable_[] =
    {
      ]b4_table[
    };
  
    /* YYCHECK.  */
    private static final ]b4_int_type_for([b4_check])[
    yycheck_[] =
    {
      ]b4_check[
    };
  
    /* STOS_[STATE-NUM] -- The (internal number of the) accessing
       symbol of state STATE-NUM.  */
    private static final ]b4_int_type_for([b4_stos])[
    yystos_[] =
    {
      ]b4_stos[
    };
  
    /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
       to YYLEX-NUM.  */
    private static final ]b4_int_type_for([b4_toknum])[
    yytoken_number_[] =
    {
      ]b4_toknum[
    };
  
    /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
    private static final ]b4_int_type_for([b4_r1])[
    yyr1_[] =
    {
      ]b4_r1[
    };
  
    /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
    private static final ]b4_int_type_for([b4_r2])[
    yyr2_[] =
    {
      ]b4_r2[
    };
  
    /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
       First, the terminals, then, starting at \a yyntokens_, nonterminals.  */
    private static final String yytname_[] =
    {
      ]b4_tname[
    };
  
    /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
    private static final ]b4_int_type_for([b4_rhs])[ yyrhs_[] =
    {
      ]b4_rhs[
    };
  
    /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
       YYRHS.  */
    private static final ]b4_int_type_for([b4_prhs])[ yyprhs_[] =
    {
      ]b4_prhs[
    };
  
    /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
    private static final ]b4_int_type_for([b4_rline])[ yyrline_[] =
    {
      ]b4_rline[
    };
  
    // Report on the debug stream that the rule yyrule is going to be reduced.
    private void yy_reduce_print (int yyrule, YYStack yystack)
    {
      if (yydebug == 0)
        return;
  
      int yylno = yyrline_[yyrule];
      int yynrhs = yyr2_[yyrule];
      /* Print the symbols being reduced, and their result.  */
      yycdebug ("Reducing stack by rule " + (yyrule - 1)
  	      + " (line " + yylno + "), ");
  
      /* The symbols being reduced.  */
      for (int yyi = 0; yyi < yynrhs; yyi++)
        yy_symbol_print ("   $" + (yyi + 1) + " =",
  		       yyrhs_[yyprhs_[yyrule] + yyi],
  		       ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([, 
  		       b4_rhs_location(yynrhs, yyi + 1)])[);
    }
  
    /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
    private static final ]b4_int_type_for([b4_translate])[ yytranslate_table_[] =
    {
      ]b4_translate[
    };
  
    private static final ]b4_int_type_for([b4_translate])[ yytranslate_ (int t)
    {
      if (t >= 0 && t <= yyuser_token_number_max_)
        return yytranslate_table_[t];
      else
        return yyundef_token_;
    }
  
    private static final int yylast_ = ]b4_last[;
    private static final int yynnts_ = ]b4_nterms_number[;
    private static final int yyempty_ = -2;
    private static final int yyfinal_ = ]b4_final_state_number[;
    private static final int yyterror_ = 1;
    private static final int yyerrcode_ = 256;
    private static final int yyntokens_ = ]b4_tokens_number[;
  
    private static final int yyuser_token_number_max_ = ]b4_user_token_number_max[;
    private static final int yyundef_token_ = ]b4_undef_token_number[;
  
  ]/* User implementation code.  */
  b4_percent_code_get[]dnl
  
  }
  
  b4_epilogue
  m4_divert_pop(0)dnl
  