1 # Java skeleton
for Bison
-*- autoconf
-*-
3 #
Copyright (C
) 2007-2012 Free Software Foundation
, Inc
.
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
.
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
.
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/>.
18 m4_include(b4_pkgdatadir
/[java
.m4
])
20 b4_defines_if([b4_fatal([%s
: %%defines does not make sense in Java
],
23 # We don
't depend on %debug in Java, but pacify warnings about non-used flags.
24 b4_parse_trace_if([0], [0])
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],
30 [b4_symbol_action_location([$1], [destructor])])])])
31 b4_symbol_foreach([b4_symbol_no_destructor_assert])
33 b4_output_begin([b4_parser_file_name])
34 b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java],
37 b4_percent_define_ifdef([package], [package b4_percent_define_get([package]);
38 ])[/* First part of user declarations. */
41 b4_percent_code_get([[imports]])
43 * A Bison parser, automatically generated from <tt>]m4_bpatsubst(b4_file_name, [^"\(.*\)"$], [\1])[</tt>.
45 * @@author LALR (1) parser skeleton written by Paolo Bonzini.
47 ]b4_percent_define_get3([annotations], [], [ ])dnl
48 b4_public_if([public ])dnl
49 b4_abstract_if([abstract ])dnl
50 b4_final_if([final ])dnl
51 b4_strictfp_if([strictfp ])dnl
52 [class ]b4_parser_class_name[]dnl
53 b4_percent_define_get3([extends], [ extends ])dnl
54 b4_percent_define_get3([implements], [ implements ])[
57 ]b4_error_verbose_if([[
58 /** True if verbose error messages are enabled. */
59 private boolean yyErrorVerbose = true;
62 * Return whether verbose error messages are enabled.
64 public final boolean getErrorVerbose() { return yyErrorVerbose; }
67 * Set the verbosity of error messages.
68 * @@param verbose True to request verbose error messages.
70 public final void setErrorVerbose(boolean verbose)
71 { yyErrorVerbose = verbose; }
76 * A class defining a pair of positions. Positions, defined by the
77 * <code>]b4_position_type[</code> class, denote a point in the input.
78 * Locations represent a part of the input through the beginning
79 * and ending positions. */
80 public class ]b4_location_type[ {
81 /** The first, inclusive, position in the range. */
82 public ]b4_position_type[ begin;
84 /** The first position beyond the range. */
85 public ]b4_position_type[ end;
88 * Create a <code>]b4_location_type[</code> denoting an empty range located at
90 * @@param loc The position at which the range is anchored. */
91 public ]b4_location_type[ (]b4_position_type[ loc) {
92 this.begin = this.end = loc;
96 * Create a <code>]b4_location_type[</code> from the endpoints of the range.
97 * @@param begin The first position included in the range.
98 * @@param end The first position beyond the range. */
99 public ]b4_location_type[ (]b4_position_type[ begin, ]b4_position_type[ end) {
105 * Print a representation of the location. For this to be correct,
106 * <code>]b4_position_type[</code> should override the <code>equals</code>
108 public String toString () {
109 if (begin.equals (end))
110 return begin.toString ();
112 return begin.toString () + "-" + end.toString ();
119 private ]b4_location_type[ yylloc (YYStack rhs, int n)
122 return new ]b4_location_type[ (rhs.locationAt (n-1).begin, rhs.locationAt (0).end);
124 return new ]b4_location_type[ (rhs.locationAt (0).end);
128 * Communication interface between the scanner and the Bison-generated
129 * parser <tt>]b4_parser_class_name[</tt>.
131 public interface Lexer {
132 /** Token returned by the scanner to signal the end of its input. */
133 public static final int EOF = 0;
137 ]b4_locations_if([[/**
138 * Method to retrieve the beginning position of the last scanned token.
139 * @@return the position at which the last scanned token starts. */
140 ]b4_position_type[ getStartPos ();
143 * Method to retrieve the ending position of the last scanned token.
144 * @@return the first position beyond the last scanned token. */
145 ]b4_position_type[ getEndPos ();]])[
148 * Method to retrieve the semantic value of the last scanned token.
149 * @@return the semantic value of the last scanned token. */
150 ]b4_yystype[ getLVal ();
153 * Entry point for the scanner. Returns the token identifier corresponding
154 * to the next token and prepares to return the semantic value
155 * ]b4_locations_if([and beginning/ending positions ])[of the token.
156 * @@return the token identifier corresponding to the next token. */
157 int yylex () ]b4_maybe_throws([b4_lex_throws])[;
160 * Entry point for error reporting. Emits an error
161 * ]b4_locations_if([referring to the given location ])[in a user-defined way.
163 * ]b4_locations_if([[@@param loc The location of the element to which the
164 * error message is related]])[
165 * @@param msg The string for the error message. */
166 void yyerror (]b4_locations_if([b4_location_type[ loc, ]])[String msg);]
169 b4_lexer_if([[private class YYLexer implements Lexer {
170 ]b4_percent_code_get([[lexer]])[
173 ]])[/** The object doing lexical analysis for us. */
174 private Lexer yylexer;
180 * Instantiates the Bison-generated parser.
182 public ]b4_parser_class_name (b4_parse_param_decl([b4_lex_param_decl])[) ]b4_maybe_throws([b4_init_throws])[
184 ]b4_percent_code_get([[init]])[
185 this.yylexer = new YYLexer(]b4_lex_param_call[);
186 ]b4_parse_param_cons[
191 * Instantiates the Bison-generated parser.
192 * @@param yylexer The scanner that will supply tokens to the parser.
194 b4_lexer_if([[protected]], [[public]]) b4_parser_class_name[ (]b4_parse_param_decl([[Lexer yylexer]])[) ]b4_maybe_throws([b4_init_throws])[
196 ]b4_percent_code_get([[init]])[
197 this.yylexer = yylexer;
198 ]b4_parse_param_cons[
201 private java.io.PrintStream yyDebugStream = System.err;
204 * Return the <tt>PrintStream</tt> on which the debugging output is
207 public final java.io.PrintStream getDebugStream () { return yyDebugStream; }
210 * Set the <tt>PrintStream</tt> on which the debug output is printed.
211 * @@param s The stream that is used for debugging output.
213 public final void setDebugStream(java.io.PrintStream s) { yyDebugStream = s; }
215 private int yydebug = 0;
218 * Answer the verbosity of the debugging output; 0 means that all kinds of
219 * output from the parser are suppressed.
221 public final int getDebugLevel() { return yydebug; }
224 * Set the verbosity of the debugging output; 0 means that all kinds of
225 * output from the parser are suppressed.
226 * @@param level The verbosity level for debugging output.
228 public final void setDebugLevel(int level) { yydebug = level; }
231 * Print an error message via the lexer.
232 *]b4_locations_if([[ Use a <code>null</code> location.]])[
233 * @@param msg The error message.
235 public final void yyerror (String msg)
237 yylexer.yyerror (]b4_locations_if([[(]b4_location_type[)null, ]])[msg);
241 * Print an error message via the lexer.
242 * @@param loc The location associated with the message.
243 * @@param msg The error message.
245 public final void yyerror (]b4_location_type[ loc, String msg)
247 yylexer.yyerror (loc, msg);
251 * Print an error message via the lexer.
252 * @@param pos The position associated with the message.
253 * @@param msg The error message.
255 public final void yyerror (]b4_position_type[ pos, String msg)
257 yylexer.yyerror (new ]b4_location_type[ (pos), msg);
260 [protected final void yycdebug (String s) {
262 yyDebugStream.println (s);
265 private final class YYStack {
266 private int[] stateStack = new int[16];
267 ]b4_locations_if([[private ]b4_location_type[[] locStack = new ]b4_location_type[[16];]])[
268 private ]b4_yystype[[] valueStack = new ]b4_yystype[[16];
270 public int size = 16;
271 public int height = -1;
273 public final void push (int state, ]b4_yystype[ value]dnl
274 b4_locations_if([, ]b4_location_type[ loc])[) {
278 int[] newStateStack = new int[size * 2];
279 System.arraycopy (stateStack, 0, newStateStack, 0, height);
280 stateStack = newStateStack;
282 ]b4_location_type[[] newLocStack = new ]b4_location_type[[size * 2];
283 System.arraycopy (locStack, 0, newLocStack, 0, height);
284 locStack = newLocStack;]])
286 b4_yystype[[] newValueStack = new ]b4_yystype[[size * 2];
287 System.arraycopy (valueStack, 0, newValueStack, 0, height);
288 valueStack = newValueStack;
293 stateStack[height] = state;
294 ]b4_locations_if([[locStack[height] = loc;]])[
295 valueStack[height] = value;
298 public final void pop () {
302 public final void pop (int num) {
303 // Avoid memory leaks... garbage collection is a white lie!
305 java.util.Arrays.fill (valueStack, height - num + 1, height + 1, null);
306 ]b4_locations_if([[java.util.Arrays.fill (locStack, height - num + 1, height + 1, null);]])[
311 public final int stateAt (int i) {
312 return stateStack[height - i];
315 ]b4_locations_if([[public final ]b4_location_type[ locationAt (int i) {
316 return locStack[height - i];
319 ]])[public final ]b4_yystype[ valueAt (int i) {
320 return valueStack[height - i];
323 // Print the state stack on the debug stream.
324 public void print (java.io.PrintStream out)
326 out.print ("Stack now");
328 for (int i = 0; i <= height; i++)
331 out.print (stateStack[i]);
338 * Returned by a Bison action in order to stop the parsing process and
339 * return success (<tt>true</tt>). */
340 public static final int YYACCEPT = 0;
343 * Returned by a Bison action in order to stop the parsing process and
344 * return failure (<tt>false</tt>). */
345 public static final int YYABORT = 1;
348 * Returned by a Bison action in order to start error recovery without
349 * printing an error message. */
350 public static final int YYERROR = 2;
352 // Internal return codes that are not supported for user semantic
354 private static final int YYERRLAB = 3;
355 private static final int YYNEWSTATE = 4;
356 private static final int YYDEFAULT = 5;
357 private static final int YYREDUCE = 6;
358 private static final int YYERRLAB1 = 7;
359 private static final int YYRETURN = 8;
361 private int yyerrstatus_ = 0;
364 * Return whether error recovery is being done. In this state, the parser
365 * reads token until it reaches a known state, and then restarts normal
367 public final boolean recovering ()
369 return yyerrstatus_ == 0;
372 private int yyaction (int yyn, YYStack yystack, int yylen) ]b4_maybe_throws([b4_throws])[
375 ]b4_locations_if([b4_location_type[ yyloc = yylloc (yystack, yylen);]])[
377 /* If YYLEN is nonzero, implement the default value of the action:
378 `$$ = $1'. Otherwise
, use the top of the stack
.
380 Otherwise
, the following line sets YYVAL to garbage
.
381 This behavior is undocumented and Bison
382 users should not rely upon it
. */
384 yyval
= yystack
.valueAt (yylen
- 1);
386 yyval
= yystack
.valueAt (0);
388 yy_reduce_print (yyn
, yystack
);
396 yy_symbol_print ("-> $$ =", yyr1_
[yyn
], yyval
]b4_locations_if([, yyloc
])[);
401 /* Shift the result of the reduction. */
403 int yystate
= yypgoto_
[yyn
- yyntokens_
] + yystack
.stateAt (0);
404 if (0 <= yystate
&& yystate
<= yylast_
405 && yycheck_
[yystate
] == yystack
.stateAt (0))
406 yystate
= yytable_
[yystate
];
408 yystate
= yydefgoto_
[yyn
- yyntokens_
];
410 yystack
.push (yystate
, yyval
]b4_locations_if([, yyloc
])[);
414 ]b4_error_verbose_if([[
415 /* Return YYSTR after stripping away unnecessary quotes and
416 backslashes, so that it's suitable for yyerror. The heuristic is
417 that double-quoting is unnecessary unless the string contains an
418 apostrophe, a comma, or backslash (other than backslash-backslash).
419 YYSTR is taken from yytname. */
420 private final String
yytnamerr_ (String yystr
)
422 if (yystr
.charAt (0) == '"')
424 StringBuffer yyr
= new StringBuffer ();
425 strip_quotes
: for (int i
= 1; i
< yystr
.length (); i
++)
426 switch (yystr
.charAt (i
))
433 if (yystr
.charAt(++i
) != '\\')
437 yyr
.append (yystr
.charAt (i
));
441 return yyr
.toString ();
444 else if (yystr
.equals ("$end"))
445 return "end of input";
451 /*--------------------------------.
452 | Print this symbol on YYOUTPUT. |
453 `--------------------------------*/
455 private void yy_symbol_print (String s
, int yytype
,
456 ]b4_yystype
[ yyvaluep
]dnl
457 b4_locations_if([, Object yylocationp
])[)
460 yycdebug (s
+ (yytype
< yyntokens_ ?
" token " : " nterm ")
461 + yytname_
[yytype
] + " ("]b4_locations_if([
462 + yylocationp
+ ": "])[
463 + (yyvaluep
== null ?
"(null)" : yyvaluep
.toString ()) + ")");
467 * Parse input from the scanner that was specified at object construction
468 * time. Return whether the end of the input was reached successfully.
470 * @@return <tt>true</tt> if the parsing succeeds. Note that this does not
471 * imply that there were no syntax errors.
473 public boolean parse () ]b4_maybe_throws([b4_list2([b4_lex_throws
], [b4_throws
])])[
475 /// Lookahead and lookahead in internal form.
476 int yychar
= yyempty_
;
484 YYStack yystack
= new YYStack ();
486 /* Error handling. */
488 ]b4_locations_if([/// The location where the error started.
489 ]b4_location_type
[ yyerrloc
= null;
491 /// ]b4_location_type[ of the lookahead.
492 ]b4_location_type
[ yylloc
= new ]b4_location_type
[ (null, null);
495 ]b4_location_type
[ yyloc
;])
497 /// Semantic value of the lookahead.
498 b4_yystype
[ yylval
= null;
500 yycdebug ("Starting parse\n");
503 ]m4_ifdef([b4_initial_action
], [
504 b4_dollar_pushdef([yylval
], [], [yylloc
])dnl
505 /* User initialization code. */
506 b4_user_initial_action
507 b4_dollar_popdef
])[]dnl
509 [ /* Initialize the stack. */
510 yystack
.push (yystate
, yylval
]b4_locations_if([, yylloc
])[);
512 int label
= YYNEWSTATE
;
516 /* New state. Unlike in the C/C++ skeletons, the state is already
517 pushed when we come here. */
519 yycdebug ("Entering state " + yystate
+ "\n");
521 yystack
.print (yyDebugStream
);
524 if (yystate
== yyfinal_
)
527 /* Take a decision. First try without lookahead. */
528 yyn
= yypact_
[yystate
];
529 if (yy_pact_value_is_default_ (yyn
))
535 /* Read a lookahead token. */
536 if (yychar
== yyempty_
)
538 yycdebug ("Reading a token: ");
539 yychar
= yylexer
.yylex ();]
541 yylloc
= new ]b4_location_type
[(yylexer
.getStartPos (),
542 yylexer
.getEndPos ());]])
543 yylval
= yylexer
.getLVal ();[
546 /* Convert token to internal form. */
547 if (yychar
<= Lexer
.EOF
)
549 yychar
= yytoken
= Lexer
.EOF
;
550 yycdebug ("Now at end of input.\n");
554 yytoken
= yytranslate_ (yychar
);
555 yy_symbol_print ("Next token is", yytoken
,
556 yylval
]b4_locations_if([, yylloc
])[);
559 /* If the proper action on seeing token YYTOKEN is to reduce or to
560 detect an error, take that action. */
562 if (yyn
< 0 || yylast_
< yyn
|| yycheck_
[yyn
] != yytoken
)
565 /* <= 0 means reduce or error. */
566 else if ((yyn
= yytable_
[yyn
]) <= 0)
568 if (yy_table_value_is_error_ (yyn
))
579 /* Shift the lookahead token. */
580 yy_symbol_print ("Shifting", yytoken
,
581 yylval
]b4_locations_if([, yylloc
])[);
583 /* Discard the token being shifted. */
586 /* Count tokens shifted since error; after three, turn off error
588 if (yyerrstatus_
> 0)
592 yystack
.push (yystate
, yylval
]b4_locations_if([, yylloc
])[);
597 /*-----------------------------------------------------------.
598 | yydefault -- do the default action for the current state. |
599 `-----------------------------------------------------------*/
601 yyn
= yydefact_
[yystate
];
608 /*-----------------------------.
609 | yyreduce -- Do a reduction. |
610 `-----------------------------*/
613 label
= yyaction (yyn
, yystack
, yylen
);
614 yystate
= yystack
.stateAt (0);
617 /*------------------------------------.
618 | yyerrlab -- here on detecting error |
619 `------------------------------------*/
621 /* If not already recovering from an error, report this error. */
622 if (yyerrstatus_
== 0)
625 if (yychar
== yyempty_
)
627 yyerror (]b4_locations_if([yylloc
, ])[yysyntax_error (yystate
, yytoken
));
630 ]b4_locations_if([yyerrloc
= yylloc
;])[
631 if (yyerrstatus_
== 3)
633 /* If just tried and failed to reuse lookahead token after an
634 error, discard it. */
636 if (yychar
<= Lexer
.EOF
)
638 /* Return failure if at end of input. */
639 if (yychar
== Lexer
.EOF
)
646 /* Else will try to reuse lookahead token after shifting the error
651 /*---------------------------------------------------.
652 | errorlab -- error raised explicitly by YYERROR. |
653 `---------------------------------------------------*/
656 ]b4_locations_if([yyerrloc
= yystack
.locationAt (yylen
- 1);])[
657 /* Do not reclaim the symbols of the rule which action triggered
661 yystate
= yystack
.stateAt (0);
665 /*-------------------------------------------------------------.
666 | yyerrlab1 -- common code for both syntax error and YYERROR. |
667 `-------------------------------------------------------------*/
669 yyerrstatus_
= 3; /* Each real token shifted decrements this. */
673 yyn
= yypact_
[yystate
];
674 if (!yy_pact_value_is_default_ (yyn
))
677 if (0 <= yyn
&& yyn
<= yylast_
&& yycheck_
[yyn
] == yyterror_
)
685 /* Pop the current state because it cannot handle the error token. */
686 if (yystack
.height
== 0)
689 ]b4_locations_if([yyerrloc
= yystack
.locationAt (0);])[
691 yystate
= yystack
.stateAt (0);
693 yystack
.print (yyDebugStream
);
697 /* Muck with the stack to setup for yylloc. */
698 yystack
.push (0, null, yylloc
);
699 yystack
.push (0, null, yyerrloc
);
700 yyloc
= yylloc (yystack
, 2);
703 /* Shift the error token. */
704 yy_symbol_print ("Shifting", yystos_
[yyn
],
705 yylval
]b4_locations_if([, yyloc
])[);
708 yystack
.push (yyn
, yylval
]b4_locations_if([, yyloc
])[);
722 // Generate an error message.
723 private String
yysyntax_error (int yystate
, int tok
)
724 {]b4_error_verbose_if([[
727 /* There are many possibilities here to consider:
728 - If this state is a consistent state with a default action,
729 then the only way this function was invoked is if the
730 default action is an error action. In that case, don't
731 check for expected tokens because there are none.
732 - The only way there can be no lookahead present (in tok) is
733 if this state is a consistent state with a default action.
734 Thus, detecting the absence of a lookahead is sufficient to
735 determine that there is no unexpected or expected token to
736 report. In that case, just report a simple "syntax error".
737 - Don't assume there isn't a lookahead just because this
738 state is a consistent state with a default action. There
739 might have been a previous inconsistent state, consistent
740 state with a non-default action, or user semantic action
741 that manipulated yychar. (However, yychar is currently out
742 of scope during semantic actions.)
743 - Of course, the expected token list depends on states to
744 have correct lookahead information, and it depends on the
745 parser not to perform extra reductions after fetching a
746 lookahead from the scanner and before detecting a syntax
747 error. Thus, state merging (from LALR or IELR) and default
748 reductions corrupt the expected token list. However, the
749 list is correct for canonical LR with one exception: it
750 will still contain any token that will not be accepted due
751 to an error action in a later state.
755 // FIXME: This method of building the message is not compatible
756 // with internationalization.
758 new StringBuffer ("syntax error, unexpected ");
759 res
.append (yytnamerr_ (yytname_
[tok
]));
760 int yyn
= yypact_
[yystate
];
761 if (!yy_pact_value_is_default_ (yyn
))
763 /* Start YYX at -YYN if negative to avoid negative
764 indexes in YYCHECK. In other words, skip the first
765 -YYN actions for this state because they are default
767 int yyxbegin
= yyn
< 0 ?
-yyn
: 0;
768 /* Stay within bounds of both yycheck and yytname. */
769 int yychecklim
= yylast_
- yyn
+ 1;
770 int yyxend
= yychecklim
< yyntokens_ ? yychecklim
: yyntokens_
;
772 for (int x
= yyxbegin
; x
< yyxend
; ++x
)
773 if (yycheck_
[x
+ yyn
] == x
&& x
!= yyterror_
774 && !yy_table_value_is_error_ (yytable_
[x
+ yyn
]))
779 for (int x
= yyxbegin
; x
< yyxend
; ++x
)
780 if (yycheck_
[x
+ yyn
] == x
&& x
!= yyterror_
781 && !yy_table_value_is_error_ (yytable_
[x
+ yyn
]))
783 res
.append (count
++ == 0 ?
", expecting " : " or ");
784 res
.append (yytnamerr_ (yytname_
[x
]));
788 return res
.toString ();
792 return "syntax error";
796 * Whether the given <code>yypact_</code> value indicates a defaulted state.
797 * @@param yyvalue the value to check
799 private static boolean yy_pact_value_is_default_ (int yyvalue
)
801 return yyvalue
== yypact_ninf_
;
805 * Whether the given <code>yytable_</code> value indicates a syntax error.
806 * @@param yyvalue the value to check
808 private static boolean yy_table_value_is_error_ (int yyvalue
)
810 return yyvalue
== yytable_ninf_
;
813 private static final ]b4_int_type_for([b4_pact
])[ yypact_ninf_
= ]b4_pact_ninf
[;
814 private static final ]b4_int_type_for([b4_table
])[ yytable_ninf_
= ]b4_table_ninf
[;
816 ]b4_parser_tables_define
[
817 ]b4_integral_parser_table_define([token_number
], [b4_toknum
],
818 [TOKEN_NUMBER_
[YYLEX
-NUM
] -- Internal symbol number corresponding
821 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
822 First, the terminals, then, starting at \a yyntokens_, nonterminals. */
823 ]b4_typed_parser_table_define([String
], [tname
], [b4_tname
])[
825 ]b4_integral_parser_table_define([rline
], [b4_rline
],
826 [YYRLINE
[YYN
] -- Source line where rule number YYN was defined
.])[
828 // Report on the debug stream that the rule yyrule is going to be reduced.
829 private void yy_reduce_print (int yyrule
, YYStack yystack
)
834 int yylno
= yyrline_
[yyrule
];
835 int yynrhs
= yyr2_
[yyrule
];
836 /* Print the symbols being reduced, and their result. */
837 yycdebug ("Reducing stack by rule " + (yyrule
- 1)
838 + " (line " + yylno
+ "), ");
840 /* The symbols being reduced. */
841 for (int yyi
= 0; yyi
< yynrhs
; yyi
++)
842 yy_symbol_print (" $" + (yyi
+ 1) + " =",
843 yystos_
[yystack
.stateAt(yynrhs
- (yyi
+ 1))],
844 ]b4_rhs_value(yynrhs
, yyi
+ 1)b4_locations_if([,
845 b4_rhs_location(yynrhs
, yyi
+ 1)])[);
848 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
849 ]b4_integral_parser_table_define([translate_table
], [b4_translate
])[
851 private static final ]b4_int_type_for([b4_translate
])[ yytranslate_ (int t
)
853 if (t
>= 0 && t
<= yyuser_token_number_max_
)
854 return yytranslate_table_
[t
];
856 return yyundef_token_
;
859 private static final int yylast_
= ]b4_last
[;
860 private static final int yynnts_
= ]b4_nterms_number
[;
861 private static final int yyempty_
= -2;
862 private static final int yyfinal_
= ]b4_final_state_number
[;
863 private static final int yyterror_
= 1;
864 private static final int yyerrcode_
= 256;
865 private static final int yyntokens_
= ]b4_tokens_number
[;
867 private static final int yyuser_token_number_max_
= ]b4_user_token_number_max
[;
868 private static final int yyundef_token_
= ]b4_undef_token_number
[;
870 ]/* User implementation code. */
871 b4_percent_code_get
[]dnl