source: EcnlProtoTool/trunk/tools/share/bison/lalr1.java@ 270

Last change on this file since 270 was 270, checked in by coas-nagasima, 7 years ago

mruby版ECNLプロトタイピング・ツールを追加
File size: 25.9 KB
Line 
1# Java skeleton for Bison -*- autoconf -*-
2
3# Copyright (C) 2007, 2008 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
18m4_include(b4_pkgdatadir/[java.m4])
19
20b4_defines_if([b4_fatal([%s: %%defines does not make sense in Java], [b4_skeleton])])
21m4_ifval(m4_defn([b4_symbol_destructors]),
22 [b4_fatal([%s: %%destructor does not make sense in Java], [b4_skeleton])],
23 [])
24
25m4_divert_push(0)dnl
26@output(b4_parser_file_name@)
27b4_copyright([Skeleton implementation for Bison LALR(1) parsers in Java],
28 [2007, 2008])
29
30b4_percent_define_ifdef([package], [package b4_percent_define_get([package]);
31])[/* First part of user declarations. */
32]b4_pre_prologue
33b4_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
40b4_abstract_if([abstract ])dnl
41b4_final_if([final ])dnl
42b4_strictfp_if([strictfp ])dnl
43[class ]b4_parser_class_name[]dnl
44b4_percent_define_get3([extends], [ extends ])dnl
45b4_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
52b4_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
99b4_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
156b4_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 /**
312 * Returned by a Bison action in order to print an error message and start
313 * error recovery. */
314 public static final int YYFAIL = 3;
315
316 private static final int YYNEWSTATE = 4;
317 private static final int YYDEFAULT = 5;
318 private static final int YYREDUCE = 6;
319 private static final int YYERRLAB1 = 7;
320 private static final int YYRETURN = 8;
321
322 private int yyerrstatus_ = 0;
323
324 /**
325 * Return whether error recovery is being done. In this state, the parser
326 * reads token until it reaches a known state, and then restarts normal
327 * operation. */
328 public final boolean recovering ()
329 {
330 return yyerrstatus_ == 0;
331 }
332
333 private int yyaction (int yyn, YYStack yystack, int yylen) ]b4_maybe_throws([b4_throws])[
334 {
335 ]b4_yystype[ yyval;
336 ]b4_locations_if([b4_location_type[ yyloc = yylloc (yystack, yylen);]])[
337
338 /* If YYLEN is nonzero, implement the default value of the action:
339 `$$ = $1'. Otherwise, use the top of the stack.
340
341 Otherwise, the following line sets YYVAL to garbage.
342 This behavior is undocumented and Bison
343 users should not rely upon it. */
344 if (yylen > 0)
345 yyval = yystack.valueAt (yylen - 1);
346 else
347 yyval = yystack.valueAt (0);
348
349 yy_reduce_print (yyn, yystack);
350
351 switch (yyn)
352 {
353 ]b4_user_actions[
354 default: break;
355 }
356
357 yy_symbol_print ("-> $$ =", yyr1_[yyn], yyval]b4_locations_if([, yyloc])[);
358
359 yystack.pop (yylen);
360 yylen = 0;
361
362 /* Shift the result of the reduction. */
363 yyn = yyr1_[yyn];
364 int yystate = yypgoto_[yyn - yyntokens_] + yystack.stateAt (0);
365 if (0 <= yystate && yystate <= yylast_
366 && yycheck_[yystate] == yystack.stateAt (0))
367 yystate = yytable_[yystate];
368 else
369 yystate = yydefgoto_[yyn - yyntokens_];
370
371 yystack.push (yystate, yyval]b4_locations_if([, yyloc])[);
372 return YYNEWSTATE;
373 }
374
375 /* Return YYSTR after stripping away unnecessary quotes and
376 backslashes, so that it's suitable for yyerror. The heuristic is
377 that double-quoting is unnecessary unless the string contains an
378 apostrophe, a comma, or backslash (other than backslash-backslash).
379 YYSTR is taken from yytname. */
380 private final String yytnamerr_ (String yystr)
381 {
382 if (yystr.charAt (0) == '"')
383 {
384 StringBuffer yyr = new StringBuffer ();
385 strip_quotes: for (int i = 1; i < yystr.length (); i++)
386 switch (yystr.charAt (i))
387 {
388 case '\'':
389 case ',':
390 break strip_quotes;
391
392 case '\\':
393 if (yystr.charAt(++i) != '\\')
394 break strip_quotes;
395 /* Fall through. */
396 default:
397 yyr.append (yystr.charAt (i));
398 break;
399
400 case '"':
401 return yyr.toString ();
402 }
403 }
404 else if (yystr.equals ("$end"))
405 return "end of input";
406
407 return yystr;
408 }
409
410 /*--------------------------------.
411 | Print this symbol on YYOUTPUT. |
412 `--------------------------------*/
413
414 private void yy_symbol_print (String s, int yytype,
415 ]b4_yystype[ yyvaluep]dnl
416 b4_locations_if([, Object yylocationp])[)
417 {
418 if (yydebug > 0)
419 yycdebug (s + (yytype < yyntokens_ ? " token " : " nterm ")
420 + yytname_[yytype] + " ("]b4_locations_if([
421 + yylocationp + ": "])[
422 + (yyvaluep == null ? "(null)" : yyvaluep.toString ()) + ")");
423 }
424
425 /**
426 * Parse input from the scanner that was specified at object construction
427 * time. Return whether the end of the input was reached successfully.
428 *
429 * @@return <tt>true</tt> if the parsing succeeds. Note that this does not
430 * imply that there were no syntax errors.
431 */
432 public boolean parse () ]b4_maybe_throws([b4_list2([b4_lex_throws], [b4_throws])])[
433 {
434 /// Lookahead and lookahead in internal form.
435 int yychar = yyempty_;
436 int yytoken = 0;
437
438 /* State. */
439 int yyn = 0;
440 int yylen = 0;
441 int yystate = 0;
442
443 YYStack yystack = new YYStack ();
444
445 /* Error handling. */
446 int yynerrs_ = 0;
447 ]b4_locations_if([/// The location where the error started.
448 ]b4_location_type[ yyerrloc = null;
449
450 /// ]b4_location_type[ of the lookahead.
451 ]b4_location_type[ yylloc = new ]b4_location_type[ (null, null);
452
453 /// @@$.
454 ]b4_location_type[ yyloc;])
455
456 /// Semantic value of the lookahead.
457 b4_yystype[ yylval = null;
458
459 int yyresult;
460
461 yycdebug ("Starting parse\n");
462 yyerrstatus_ = 0;
463
464]m4_ifdef([b4_initial_action], [
465m4_pushdef([b4_at_dollar], [yylloc])dnl
466m4_pushdef([b4_dollar_dollar], [yylval])dnl
467 /* User initialization code. */
468 b4_user_initial_action
469m4_popdef([b4_dollar_dollar])dnl
470m4_popdef([b4_at_dollar])])dnl
471
472 [ /* Initialize the stack. */
473 yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);
474
475 int label = YYNEWSTATE;
476 for (;;)
477 switch (label)
478 {
479 /* New state. Unlike in the C/C++ skeletons, the state is already
480 pushed when we come here. */
481 case YYNEWSTATE:
482 yycdebug ("Entering state " + yystate + "\n");
483 if (yydebug > 0)
484 yystack.print (yyDebugStream);
485
486 /* Accept? */
487 if (yystate == yyfinal_)
488 return true;
489
490 /* Take a decision. First try without lookahead. */
491 yyn = yypact_[yystate];
492 if (yyn == yypact_ninf_)
493 {
494 label = YYDEFAULT;
495 break;
496 }
497
498 /* Read a lookahead token. */
499 if (yychar == yyempty_)
500 {
501 yycdebug ("Reading a token: ");
502 yychar = yylex ();]
503 b4_locations_if([[
504 yylloc = new ]b4_location_type[(yylexer.getStartPos (),
505 yylexer.getEndPos ());]])
506 yylval = yylexer.getLVal ();[
507 }
508
509 /* Convert token to internal form. */
510 if (yychar <= EOF)
511 {
512 yychar = yytoken = EOF;
513 yycdebug ("Now at end of input.\n");
514 }
515 else
516 {
517 yytoken = yytranslate_ (yychar);
518 yy_symbol_print ("Next token is", yytoken,
519 yylval]b4_locations_if([, yylloc])[);
520 }
521
522 /* If the proper action on seeing token YYTOKEN is to reduce or to
523 detect an error, take that action. */
524 yyn += yytoken;
525 if (yyn < 0 || yylast_ < yyn || yycheck_[yyn] != yytoken)
526 label = YYDEFAULT;
527
528 /* <= 0 means reduce or error. */
529 else if ((yyn = yytable_[yyn]) <= 0)
530 {
531 if (yyn == 0 || yyn == yytable_ninf_)
532 label = YYFAIL;
533 else
534 {
535 yyn = -yyn;
536 label = YYREDUCE;
537 }
538 }
539
540 else
541 {
542 /* Shift the lookahead token. */
543 yy_symbol_print ("Shifting", yytoken,
544 yylval]b4_locations_if([, yylloc])[);
545
546 /* Discard the token being shifted. */
547 yychar = yyempty_;
548
549 /* Count tokens shifted since error; after three, turn off error
550 status. */
551 if (yyerrstatus_ > 0)
552 --yyerrstatus_;
553
554 yystate = yyn;
555 yystack.push (yystate, yylval]b4_locations_if([, yylloc])[);
556 label = YYNEWSTATE;
557 }
558 break;
559
560 /*-----------------------------------------------------------.
561 | yydefault -- do the default action for the current state. |
562 `-----------------------------------------------------------*/
563 case YYDEFAULT:
564 yyn = yydefact_[yystate];
565 if (yyn == 0)
566 label = YYFAIL;
567 else
568 label = YYREDUCE;
569 break;
570
571 /*-----------------------------.
572 | yyreduce -- Do a reduction. |
573 `-----------------------------*/
574 case YYREDUCE:
575 yylen = yyr2_[yyn];
576 label = yyaction (yyn, yystack, yylen);
577 yystate = yystack.stateAt (0);
578 break;
579
580 /*------------------------------------.
581 | yyerrlab -- here on detecting error |
582 `------------------------------------*/
583 case YYFAIL:
584 /* If not already recovering from an error, report this error. */
585 if (yyerrstatus_ == 0)
586 {
587 ++yynerrs_;
588 yyerror (]b4_locations_if([yylloc, ])[yysyntax_error (yystate, yytoken));
589 }
590
591 ]b4_locations_if([yyerrloc = yylloc;])[
592 if (yyerrstatus_ == 3)
593 {
594 /* If just tried and failed to reuse lookahead token after an
595 error, discard it. */
596
597 if (yychar <= EOF)
598 {
599 /* Return failure if at end of input. */
600 if (yychar == EOF)
601 return false;
602 }
603 else
604 yychar = yyempty_;
605 }
606
607 /* Else will try to reuse lookahead token after shifting the error
608 token. */
609 label = YYERRLAB1;
610 break;
611
612 /*---------------------------------------------------.
613 | errorlab -- error raised explicitly by YYERROR. |
614 `---------------------------------------------------*/
615 case YYERROR:
616
617 ]b4_locations_if([yyerrloc = yystack.locationAt (yylen - 1);])[
618 /* Do not reclaim the symbols of the rule which action triggered
619 this YYERROR. */
620 yystack.pop (yylen);
621 yylen = 0;
622 yystate = yystack.stateAt (0);
623 label = YYERRLAB1;
624 break;
625
626 /*-------------------------------------------------------------.
627 | yyerrlab1 -- common code for both syntax error and YYERROR. |
628 `-------------------------------------------------------------*/
629 case YYERRLAB1:
630 yyerrstatus_ = 3; /* Each real token shifted decrements this. */
631
632 for (;;)
633 {
634 yyn = yypact_[yystate];
635 if (yyn != yypact_ninf_)
636 {
637 yyn += yyterror_;
638 if (0 <= yyn && yyn <= yylast_ && yycheck_[yyn] == yyterror_)
639 {
640 yyn = yytable_[yyn];
641 if (0 < yyn)
642 break;
643 }
644 }
645
646 /* Pop the current state because it cannot handle the error token. */
647 if (yystack.height == 1)
648 return false;
649
650 ]b4_locations_if([yyerrloc = yystack.locationAt (0);])[
651 yystack.pop ();
652 yystate = yystack.stateAt (0);
653 if (yydebug > 0)
654 yystack.print (yyDebugStream);
655 }
656
657 ]b4_locations_if([
658 /* Muck with the stack to setup for yylloc. */
659 yystack.push (0, null, yylloc);
660 yystack.push (0, null, yyerrloc);
661 yyloc = yylloc (yystack, 2);
662 yystack.pop (2);])[
663
664 /* Shift the error token. */
665 yy_symbol_print ("Shifting", yystos_[yyn],
666 yylval]b4_locations_if([, yyloc])[);
667
668 yystate = yyn;
669 yystack.push (yyn, yylval]b4_locations_if([, yyloc])[);
670 label = YYNEWSTATE;
671 break;
672
673 /* Accept. */
674 case YYACCEPT:
675 return true;
676
677 /* Abort. */
678 case YYABORT:
679 return false;
680 }
681 }
682
683 // Generate an error message.
684 private String yysyntax_error (int yystate, int tok)
685 {
686 if (errorVerbose)
687 {
688 int yyn = yypact_[yystate];
689 if (yypact_ninf_ < yyn && yyn <= yylast_)
690 {
691 StringBuffer res;
692
693 /* Start YYX at -YYN if negative to avoid negative indexes in
694 YYCHECK. */
695 int yyxbegin = yyn < 0 ? -yyn : 0;
696
697 /* Stay within bounds of both yycheck and yytname. */
698 int yychecklim = yylast_ - yyn + 1;
699 int yyxend = yychecklim < yyntokens_ ? yychecklim : yyntokens_;
700 int count = 0;
701 for (int x = yyxbegin; x < yyxend; ++x)
702 if (yycheck_[x + yyn] == x && x != yyterror_)
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 {
715 res.append (count++ == 0 ? ", expecting " : " or ");
716 res.append (yytnamerr_ (yytname_[x]));
717 }
718 }
719 return res.toString ();
720 }
721 }
722
723 return "syntax error";
724 }
725
726
727 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
728 STATE-NUM. */
729 private static final ]b4_int_type_for([b4_pact])[ yypact_ninf_ = ]b4_pact_ninf[;
730 private static final ]b4_int_type_for([b4_pact])[ yypact_[] =
731 {
732 ]b4_pact[
733 };
734
735 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
736 doesn't specify something else to do. Zero means the default is an
737 error. */
738 private static final ]b4_int_type_for([b4_defact])[ yydefact_[] =
739 {
740 ]b4_defact[
741 };
742
743 /* YYPGOTO[NTERM-NUM]. */
744 private static final ]b4_int_type_for([b4_pgoto])[ yypgoto_[] =
745 {
746 ]b4_pgoto[
747 };
748
749 /* YYDEFGOTO[NTERM-NUM]. */
750 private static final ]b4_int_type_for([b4_defgoto])[
751 yydefgoto_[] =
752 {
753 ]b4_defgoto[
754 };
755
756 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
757 positive, shift that token. If negative, reduce the rule which
758 number is the opposite. If zero, do what YYDEFACT says. */
759 private static final ]b4_int_type_for([b4_table])[ yytable_ninf_ = ]b4_table_ninf[;
760 private static final ]b4_int_type_for([b4_table])[
761 yytable_[] =
762 {
763 ]b4_table[
764 };
765
766 /* YYCHECK. */
767 private static final ]b4_int_type_for([b4_check])[
768 yycheck_[] =
769 {
770 ]b4_check[
771 };
772
773 /* STOS_[STATE-NUM] -- The (internal number of the) accessing
774 symbol of state STATE-NUM. */
775 private static final ]b4_int_type_for([b4_stos])[
776 yystos_[] =
777 {
778 ]b4_stos[
779 };
780
781 /* TOKEN_NUMBER_[YYLEX-NUM] -- Internal symbol number corresponding
782 to YYLEX-NUM. */
783 private static final ]b4_int_type_for([b4_toknum])[
784 yytoken_number_[] =
785 {
786 ]b4_toknum[
787 };
788
789 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
790 private static final ]b4_int_type_for([b4_r1])[
791 yyr1_[] =
792 {
793 ]b4_r1[
794 };
795
796 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
797 private static final ]b4_int_type_for([b4_r2])[
798 yyr2_[] =
799 {
800 ]b4_r2[
801 };
802
803 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
804 First, the terminals, then, starting at \a yyntokens_, nonterminals. */
805 private static final String yytname_[] =
806 {
807 ]b4_tname[
808 };
809
810 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
811 private static final ]b4_int_type_for([b4_rhs])[ yyrhs_[] =
812 {
813 ]b4_rhs[
814 };
815
816 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
817 YYRHS. */
818 private static final ]b4_int_type_for([b4_prhs])[ yyprhs_[] =
819 {
820 ]b4_prhs[
821 };
822
823 /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
824 private static final ]b4_int_type_for([b4_rline])[ yyrline_[] =
825 {
826 ]b4_rline[
827 };
828
829 // Report on the debug stream that the rule yyrule is going to be reduced.
830 private void yy_reduce_print (int yyrule, YYStack yystack)
831 {
832 if (yydebug == 0)
833 return;
834
835 int yylno = yyrline_[yyrule];
836 int yynrhs = yyr2_[yyrule];
837 /* Print the symbols being reduced, and their result. */
838 yycdebug ("Reducing stack by rule " + (yyrule - 1)
839 + " (line " + yylno + "), ");
840
841 /* The symbols being reduced. */
842 for (int yyi = 0; yyi < yynrhs; yyi++)
843 yy_symbol_print (" $" + (yyi + 1) + " =",
844 yyrhs_[yyprhs_[yyrule] + yyi],
845 ]b4_rhs_value(yynrhs, yyi + 1)b4_locations_if([,
846 b4_rhs_location(yynrhs, yyi + 1)])[);
847 }
848
849 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
850 private static final ]b4_int_type_for([b4_translate])[ yytranslate_table_[] =
851 {
852 ]b4_translate[
853 };
854
855 private static final ]b4_int_type_for([b4_translate])[ yytranslate_ (int t)
856 {
857 if (t >= 0 && t <= yyuser_token_number_max_)
858 return yytranslate_table_[t];
859 else
860 return yyundef_token_;
861 }
862
863 private static final int yylast_ = ]b4_last[;
864 private static final int yynnts_ = ]b4_nterms_number[;
865 private static final int yyempty_ = -2;
866 private static final int yyfinal_ = ]b4_final_state_number[;
867 private static final int yyterror_ = 1;
868 private static final int yyerrcode_ = 256;
869 private static final int yyntokens_ = ]b4_tokens_number[;
870
871 private static final int yyuser_token_number_max_ = ]b4_user_token_number_max[;
872 private static final int yyundef_token_ = ]b4_undef_token_number[;
873
874]/* User implementation code. */
875b4_percent_code_get[]dnl
876
877}
878
879b4_epilogue
880m4_divert_pop(0)dnl
Note: See TracBrowser for help on using the repository browser.