# Java skeleton for Bison -*- autoconf -*-
# Copyright (C) 2007-2015 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],
# We do not depend on %debug in Java, but pacify warnings about
b4_parse_trace_if([0], [0])
m4_define([b4_symbol_no_destructor_assert],
[b4_symbol_if([$1], [has_destructor],
[b4_fatal([%s: %s: %%destructor does not make sense in Java],
[b4_symbol_action_location([$1], [destructor])])])])
b4_symbol_foreach([b4_symbol_no_destructor_assert])
# Setup some macros for api.push-pull.
b4_percent_define_default([[api.push-pull]], [[pull]])
b4_percent_define_check_values([[[[api.push-pull]],
[[pull]], [[push]], [[both]]]])
# Define m4 conditional macros that encode the value
# of the api.push-pull flag.
b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]])
b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]])
m4_case(b4_percent_define_get([[api.push-pull]]),
[pull], [m4_define([b4_push_flag], [[0]])],
[push], [m4_define([b4_pull_flag], [[0]])])
# Define a macro to be true when api.push-pull has the value "both".
m4_define([b4_both_if],[b4_push_if([b4_pull_if([$1],[$2])],[$2])])
# Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing
# tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the
# behavior of Bison at all when push parsing is already requested.
b4_define_flag_if([use_push_for_pull])
b4_use_push_for_pull_if([
b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])],
[m4_define([b4_push_flag], [[1]])])])
# Define a macro to encapsulate the parse state variables.
# This allows them to be defined either in parse() when doing
# pull parsing, or as class instance variable when doing push parsing.
m4_define([b4_define_state],[[
/* Lookahead and lookahead in internal form. */
YYStack yystack = new YYStack ();
]b4_locations_if([/* The location where the error started. */
b4_location_type yyerrloc = null;
b4_location_type yylloc = new b4_location_type (null, null);])[
/* Semantic value of the lookahead. */
]b4_yystype[ yylval = null;
b4_output_begin([b4_parser_file_name])
b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java],
b4_percent_define_ifdef([package], [package b4_percent_define_get([package]);
])[/* First part of user declarations. */
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_percent_define_get3([annotations], [], [ ])dnl
b4_public_if([public ])dnl
b4_abstract_if([abstract ])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 ])[
* True if verbose error messages are enabled.
private boolean yyErrorVerbose = true;
* Return whether verbose error messages are enabled.
public final boolean getErrorVerbose() { return yyErrorVerbose; }
* Set the verbosity of error messages.
* @@param verbose True to request verbose error messages.
public final void setErrorVerbose(boolean verbose)
{ yyErrorVerbose = verbose; }
* 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
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
* @@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) {
* Print a representation of the location. For this to be correct,
* <code>]b4_position_type[</code> should override the <code>equals</code>
public String toString () {
return begin.toString ();
return begin.toString () + "-" + end.toString ();
private ]b4_location_type[ yylloc (YYStack rhs, int n)
return new ]b4_location_type[ (rhs.locationAt (n-1).begin, rhs.locationAt (0).end);
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>.
/** Token returned by the scanner to signal the end of its input. */
public static final int EOF = 0;
* 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.
* 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 msg The string for the error message.
void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String msg);]
b4_lexer_if([[private class YYLexer implements Lexer {
]b4_percent_code_get([[lexer]])[
* The object doing lexical analysis for us.
* Instantiates the Bison-generated parser.
public ]b4_parser_class_name (b4_parse_param_decl([b4_lex_param_decl])[) ]b4_maybe_throws([b4_init_throws])[
]b4_percent_code_get([[init]])[
this.yylexer = new YYLexer(]b4_lex_param_call[);
* 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]])[) ]b4_maybe_throws([b4_init_throws])[
]b4_percent_code_get([[init]])[
private java.io.PrintStream yyDebugStream = System.err;
* Return the <tt>PrintStream</tt> on which the debugging output is
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; }
* 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; }
* Print an error message via the lexer.
*]b4_locations_if([[ Use a <code>null</code> location.]])[
* @@param msg The error message.
public final void yyerror (String msg)
yylexer.yyerror (]b4_locations_if([[(]b4_location_type[)null, ]])[msg);
* Print an error message via the lexer.
* @@param loc The location associated with the message.
* @@param msg The error message.
public final void yyerror (]b4_location_type[ loc, String msg)
yylexer.yyerror (loc, msg);
* Print an error message via the lexer.
* @@param pos The position associated with the message.
* @@param msg The error message.
public final void yyerror (]b4_position_type[ pos, String msg)
yylexer.yyerror (new ]b4_location_type[ (pos), msg);
[protected final void yycdebug (String s) {
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 final void push (int state, ]b4_yystype[ value]dnl
b4_locations_if([, ]b4_location_type[ loc])[) {
int[] newStateStack = new int[size * 2];
System.arraycopy (stateStack, 0, newStateStack, 0, height);
stateStack = newStateStack;
]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;
stateStack[height] = state;
]b4_locations_if([[locStack[height] = loc;]])[
valueStack[height] = value;
public final void pop () {
public final void pop (int num) {
// Avoid memory leaks... garbage collection is a white lie!
java.util.Arrays.fill (valueStack, height - num + 1, height + 1, null);
]b4_locations_if([[java.util.Arrays.fill (locStack, height - num + 1, height + 1, null);]])[
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)
for (int i = 0; i <= height; i++)
out.print (stateStack[i]);
* 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 request a new token.
public static final int YYPUSH_MORE = 4;])[
* Returned by a Bison action in order to start error recovery without
* printing an error message.
public static final int YYERROR = 2;
* Internal return codes that are not supported for user semantic
private static final int YYERRLAB = 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;
]b4_push_if([[ private static final int YYGETTOKEN = 9; /* Signify that a new token is expected when doing push-parsing. */]])[
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
public final boolean recovering ()
return yyerrstatus_ == 0;
/** Compute post-reduction state.
* @@param yystate the current state
* @@param yysym the nonterminal to push on the stack
private int yy_lr_goto_state_ (int yystate, int yysym)
int yyr = yypgoto_[yysym - yyntokens_] + yystate;
if (0 <= yyr && yyr <= yylast_ && yycheck_[yyr] == yystate)
return yydefgoto_[yysym - yyntokens_];
private int yyaction (int yyn, YYStack yystack, int yylen) ]b4_maybe_throws([b4_throws])[
]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. */
yyval = yystack.valueAt (yylen - 1);
yyval = yystack.valueAt (0);
yy_reduce_print (yyn, yystack);
yy_symbol_print ("-> $$ =", yyr1_[yyn], yyval]b4_locations_if([, yyloc])[);
/* Shift the result of the reduction. */
int yystate = yy_lr_goto_state_ (yystack.stateAt (0), yyr1_[yyn]);
yystack.push (yystate, yyval]b4_locations_if([, yyloc])[);
It is recommended that you Edit text format, this type of Fix handles quite a lot in one request
