]> git.saurik.com Git - bison.git/blob - data/glr.c
projects / bison.git / blob
? search:


e66e1c616a976640bae999ae681f5c2d95b60dc7
[bison.git] / data / glr.c
1 m4_divert(-1) -*- C -*-
2
3 # GLR skeleton for Bison
4 # Copyright (C) 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
5
6 # This program is free software; you can redistribute it and/or modify
7 # it under the terms of the GNU General Public License as published by
8 # the Free Software Foundation; either version 2 of the License, or
9 # (at your option) any later version.
10
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 # GNU General Public License for more details.
15
16 # You should have received a copy of the GNU General Public License
17 # along with this program; if not, write to the Free Software
18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 # 02110-1301 USA
20
21
22 m4_include(b4_pkgdatadir/[c.m4])
23
24 ## ---------------- ##
25 ## Default values. ##
26 ## ---------------- ##
27
28 # Stack parameters.
29 m4_define_default([b4_stack_depth_max], [10000])
30 m4_define_default([b4_stack_depth_init], [200])
31
32
33
34 ## ------------------------ ##
35 ## Pure/impure interfaces. ##
36 ## ------------------------ ##
37
38
39 # b4_user_formals
40 # ---------------
41 # The possible parse-params formal arguments preceded by a comma.
42 #
43 # This is not shared with yacc.c in c.m4 because GLR relies on ISO C
44 # formal argument declarations.
45 m4_define([b4_user_formals],
46 [m4_ifset([b4_parse_param], [, b4_c_ansi_formals(b4_parse_param)])])
47
48
49 # b4_lex_param
50 # ------------
51 # Accumule in b4_lex_param all the yylex arguments.
52 # Yes, this is quite ugly...
53 m4_define([b4_lex_param],
54 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
55 b4_locations_if([, [[YYLTYPE *], [&yylloc]]])])dnl
56 m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
57
58
59 # b4_yyerror_args
60 # ---------------
61 # Optional effective arguments passed to yyerror: user args plus yylloc, and
62 # a trailing comma.
63 m4_define([b4_yyerror_args],
64 [b4_pure_if([b4_locations_if([yylocp, ])])dnl
65 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
66
67
68 # b4_lyyerror_args
69 # ----------------
70 # Same as above, but on the lookahead, hence &yylloc instead of yylocp.
71 m4_define([b4_lyyerror_args],
72 [b4_pure_if([b4_locations_if([&yylloc, ])])dnl
73 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
74
75
76 # b4_pure_args
77 # ------------
78 # Same as b4_yyerror_args, but with a leading comma.
79 m4_define([b4_pure_args],
80 [b4_pure_if([b4_locations_if([, yylocp])])[]b4_user_args])
81
82
83 # b4_lpure_args
84 # -------------
85 # Same as above, but on the lookahead, hence &yylloc instead of yylocp.
86 m4_define([b4_lpure_args],
87 [b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args])
88
89
90 # b4_pure_formals
91 # ---------------
92 # Arguments passed to yyerror: user formals plus yylocp.
93 m4_define([b4_pure_formals],
94 [b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals])
95
96
97 ## ----------------- ##
98 ## Semantic Values. ##
99 ## ----------------- ##
100
101
102 # b4_lhs_value([TYPE])
103 # --------------------
104 # Expansion of $<TYPE>$.
105 m4_define([b4_lhs_value],
106 [((*yyvalp)[]m4_ifval([$1], [.$1]))])
107
108
109 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
110 # --------------------------------------
111 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
112 # symbols on RHS.
113 m4_define([b4_rhs_value],
114 [(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3]))])
115
116
117
118 ## ----------- ##
119 ## Locations. ##
120 ## ----------- ##
121
122 # b4_lhs_location()
123 # -----------------
124 # Expansion of @$.
125 m4_define([b4_lhs_location],
126 [(*yylocp)])
127
128
129 # b4_rhs_location(RULE-LENGTH, NUM)
130 # ---------------------------------
131 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
132 # on RHS.
133 m4_define([b4_rhs_location],
134 [(((yyGLRStackItem const *)yyvsp)@{YYFILL (($2) - ($1))@}.yystate.yyloc)])
135
136
137
138 ## -------------- ##
139 ## Output files. ##
140 ## -------------- ##
141
142 # We do want M4 expansion after # for CPP macros.
143 m4_changecom()
144 m4_divert(0)dnl
145 @output @output_parser_name@
146 b4_copyright([Skeleton implementation for Bison GLR parsers in C],
147 [2002, 2003, 2004, 2005, 2006])
148 [
149 /* C GLR parser skeleton written by Paul Hilfinger. */
150
151 ]b4_identification
152
153 m4_if(b4_prefix, [yy], [],
154 [/* Substitute the variable and function names. */
155 #define yyparse b4_prefix[]parse
156 #define yylex b4_prefix[]lex
157 #define yyerror b4_prefix[]error
158 #define yylval b4_prefix[]lval
159 #define yychar b4_prefix[]char
160 #define yydebug b4_prefix[]debug
161 #define yynerrs b4_prefix[]nerrs
162 #define yylloc b4_prefix[]lloc])[
163
164 /* Copy the first part of user declarations. */
165 ]b4_pre_prologue
166
167 dnl # b4_shared_declarations
168 dnl # ----------------------
169 dnl # Declaration that might either go into the header (if --defines)
170 dnl # or open coded in the parser body.
171 m4_define([b4_shared_declarations],
172 [m4_ifdef([b4_start_header],
173 [[/* Copy the %start-header blocks. */
174 ]b4_start_header])[]dnl
175
176 b4_token_enums(b4_tokens)
177
178 [#ifndef YYSTYPE
179 ]m4_ifdef([b4_stype],
180 [[typedef union ]b4_union_name[
181 ]b4_user_stype[
182 YYSTYPE;
183 # define YYSTYPE_IS_TRIVIAL 1]],
184 [m4_if(b4_tag_seen_flag, 0,
185 [[typedef int YYSTYPE;
186 # define YYSTYPE_IS_TRIVIAL 1]])])[
187 #endif
188
189 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
190 typedef struct YYLTYPE
191 {
192 ]b4_locations_if([
193 int first_line;
194 int first_column;
195 int last_line;
196 int last_column;
197 ],[
198 char yydummy;
199 ])[
200 } YYLTYPE;
201 # define YYLTYPE_IS_DECLARED 1
202 # define YYLTYPE_IS_TRIVIAL 1
203 #endif
204
205 ]m4_ifdef([b4_end_header],
206 [[/* Copy the %end-header blocks. */
207 ]b4_end_header])[]dnl
208 ])
209
210 b4_defines_if([#include @output_header_name@],
211 [b4_shared_declarations])[
212
213 /* Enabling traces. */
214 #ifndef YYDEBUG
215 # define YYDEBUG ]b4_debug_flag[
216 #endif
217
218 /* Enabling verbose error messages. */
219 #ifdef YYERROR_VERBOSE
220 # undef YYERROR_VERBOSE
221 # define YYERROR_VERBOSE 1
222 #else
223 # define YYERROR_VERBOSE ]b4_error_verbose_flag[
224 #endif
225
226 /* Enabling the token table. */
227 #ifndef YYTOKEN_TABLE
228 # define YYTOKEN_TABLE ]b4_token_table[
229 #endif
230
231 /* Default (constant) value used for initialization for null
232 right-hand sides. Unlike the standard yacc.c template,
233 here we set the default value of $$ to a zeroed-out value.
234 Since the default value is undefined, this behavior is
235 technically correct. */
236 static YYSTYPE yyval_default;
237
238 /* Copy the second part of user declarations. */
239 ]b4_user_post_prologue[
240
241 #include <stdio.h>
242 #include <stdlib.h>
243 #include <string.h>
244 #include <stdarg.h>
245
246 #ifndef YY_
247 # if YYENABLE_NLS
248 # if ENABLE_NLS
249 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
250 # define YY_(msgid) dgettext ("bison-runtime", msgid)
251 # endif
252 # endif
253 # ifndef YY_
254 # define YY_(msgid) msgid
255 # endif
256 #endif
257
258 /* Suppress unused-variable warnings by "using" E. */
259 #if ! defined lint || defined __GNUC__
260 # define YYUSE(e) ((void) (e))
261 #else
262 # define YYUSE(e) /* empty */
263 #endif
264
265 /* Identity function, used to suppress warnings about constant conditions. */
266 #ifndef lint
267 # define YYID(n) (n)
268 #else
269 ]b4_c_function_def([YYID], [static int], [[int i], [i]])[
270 {
271 return i;
272 }
273 #endif
274
275 #ifndef YYFREE
276 # define YYFREE free
277 #endif
278 #ifndef YYMALLOC
279 # define YYMALLOC malloc
280 #endif
281 #ifndef YYREALLOC
282 # define YYREALLOC realloc
283 #endif
284
285 #define YYSIZEMAX ((size_t) -1)
286
287 #ifdef __cplusplus
288 typedef bool yybool;
289 #else
290 typedef unsigned char yybool;
291 #endif
292 #define yytrue 1
293 #define yyfalse 0
294
295 #ifndef YYSETJMP
296 # include <setjmp.h>
297 # define YYJMP_BUF jmp_buf
298 # define YYSETJMP(env) setjmp (env)
299 # define YYLONGJMP(env, val) longjmp (env, val)
300 #endif
301
302 /*-----------------.
303 | GCC extensions. |
304 `-----------------*/
305
306 #ifndef __attribute__
307 /* This feature is available in gcc versions 2.5 and later. */
308 # if (! defined __GNUC__ || __GNUC__ < 2 \
309 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__)
310 # define __attribute__(Spec) /* empty */
311 # endif
312 #endif
313
314 ]b4_locations_if([#define YYOPTIONAL_LOC(Name) Name],[
315 #ifdef __cplusplus
316 # define YYOPTIONAL_LOC(Name) /* empty */
317 #else
318 # define YYOPTIONAL_LOC(Name) Name __attribute__ ((__unused__))
319 #endif])[
320
321 #ifndef YYASSERT
322 # define YYASSERT(condition) ((void) ((condition) || (abort (), 0)))
323 #endif
324
325 /* YYFINAL -- State number of the termination state. */
326 #define YYFINAL ]b4_final_state_number[
327 /* YYLAST -- Last index in YYTABLE. */
328 #define YYLAST ]b4_last[
329
330 /* YYNTOKENS -- Number of terminals. */
331 #define YYNTOKENS ]b4_tokens_number[
332 /* YYNNTS -- Number of nonterminals. */
333 #define YYNNTS ]b4_nterms_number[
334 /* YYNRULES -- Number of rules. */
335 #define YYNRULES ]b4_rules_number[
336 /* YYNRULES -- Number of states. */
337 #define YYNSTATES ]b4_states_number[
338 /* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */
339 #define YYMAXRHS ]b4_r2_max[
340 /* YYMAXLEFT -- Maximum number of symbols to the left of a handle
341 accessed by $0, $-1, etc., in any rule. */
342 #define YYMAXLEFT ]b4_max_left_semantic_context[
343
344 /* YYTRANSLATE(X) -- Bison symbol number corresponding to X. */
345 #define YYUNDEFTOK ]b4_undef_token_number[
346 #define YYMAXUTOK ]b4_user_token_number_max[
347
348 #define YYTRANSLATE(YYX) \
349 ((YYX <= 0) ? YYEOF : \
350 (unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
351
352 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
353 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
354 {
355 ]b4_translate[
356 };
357
358 #if YYDEBUG
359 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
360 YYRHS. */
361 static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
362 {
363 ]b4_prhs[
364 };
365
366 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
367 static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
368 {
369 ]b4_rhs[
370 };
371
372 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
373 static const ]b4_int_type_for([b4_rline])[ yyrline[] =
374 {
375 ]b4_rline[
376 };
377 #endif
378
379 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
380 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
381 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
382 static const char *const yytname[] =
383 {
384 ]b4_tname[
385 };
386 #endif
387
388 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
389 static const ]b4_int_type_for([b4_r1])[ yyr1[] =
390 {
391 ]b4_r1[
392 };
393
394 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
395 static const ]b4_int_type_for([b4_r2])[ yyr2[] =
396 {
397 ]b4_r2[
398 };
399
400 /* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */
401 static const ]b4_int_type_for([b4_dprec])[ yydprec[] =
402 {
403 ]b4_dprec[
404 };
405
406 /* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */
407 static const ]b4_int_type_for([b4_merger])[ yymerger[] =
408 {
409 ]b4_merger[
410 };
411
412 /* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
413 doesn't specify something else to do. Zero means the default is an
414 error. */
415 static const ]b4_int_type_for([b4_defact])[ yydefact[] =
416 {
417 ]b4_defact[
418 };
419
420 /* YYPDEFGOTO[NTERM-NUM]. */
421 static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
422 {
423 ]b4_defgoto[
424 };
425
426 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
427 STATE-NUM. */
428 #define YYPACT_NINF ]b4_pact_ninf[
429 static const ]b4_int_type_for([b4_pact])[ yypact[] =
430 {
431 ]b4_pact[
432 };
433
434 /* YYPGOTO[NTERM-NUM]. */
435 static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
436 {
437 ]b4_pgoto[
438 };
439
440 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
441 positive, shift that token. If negative, reduce the rule which
442 number is the opposite. If zero, do what YYDEFACT says.
443 If YYTABLE_NINF, syntax error. */
444 #define YYTABLE_NINF ]b4_table_ninf[
445 static const ]b4_int_type_for([b4_table])[ yytable[] =
446 {
447 ]b4_table[
448 };
449
450 /* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of
451 list of conflicting reductions corresponding to action entry for
452 state STATE-NUM in yytable. 0 means no conflicts. The list in
453 yyconfl is terminated by a rule number of 0. */
454 static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] =
455 {
456 ]b4_conflict_list_heads[
457 };
458
459 /* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by
460 0, pointed into by YYCONFLP. */
461 ]dnl Do not use b4_int_type_for here, since there are places where
462 dnl pointers onto yyconfl are taken, which type is "short int *".
463 dnl We probably ought to introduce a type for confl.
464 [static const short int yyconfl[] =
465 {
466 ]b4_conflicting_rules[
467 };
468
469 static const ]b4_int_type_for([b4_check])[ yycheck[] =
470 {
471 ]b4_check[
472 };
473
474 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
475 symbol of state STATE-NUM. */
476 static const ]b4_int_type_for([b4_stos])[ yystos[] =
477 {
478 ]b4_stos[
479 };
480
481 \f
482 /* Prevent warning if -Wmissing-prototypes. */
483 ]b4_c_ansi_function_decl([yyparse], [int], b4_parse_param)[
484
485 /* Error token number */
486 #define YYTERROR 1
487
488 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
489 If N is 0, then set CURRENT to the empty location which ends
490 the previous symbol: RHS[0] (always defined). */
491
492 ]b4_locations_if([[
493 #define YYRHSLOC(Rhs, K) ((Rhs)[K].yystate.yyloc)
494 #ifndef YYLLOC_DEFAULT
495 # define YYLLOC_DEFAULT(Current, Rhs, N) \
496 do \
497 if (YYID (N)) \
498 { \
499 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
500 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
501 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
502 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
503 } \
504 else \
505 { \
506 (Current).first_line = (Current).last_line = \
507 YYRHSLOC (Rhs, 0).last_line; \
508 (Current).first_column = (Current).last_column = \
509 YYRHSLOC (Rhs, 0).last_column; \
510 } \
511 while (YYID (0))
512
513 /* YY_LOCATION_PRINT -- Print the location on the stream.
514 This macro was not mandated originally: define only if we know
515 we won't break user code: when these are the locations we know. */
516
517 # define YY_LOCATION_PRINT(File, Loc) \
518 fprintf (File, "%d.%d-%d.%d", \
519 (Loc).first_line, (Loc).first_column, \
520 (Loc).last_line, (Loc).last_column)
521 #endif
522 ]],[
523 #ifndef YYLLOC_DEFAULT
524 # define YYLLOC_DEFAULT(Current, Rhs, N) ((void) 0)
525 #endif
526 ])[
527
528 #ifndef YY_LOCATION_PRINT
529 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
530 #endif
531
532
533 /* YYLEX -- calling `yylex' with the right arguments. */
534 #define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
535
536 ]b4_pure_if(
537 [
538 #undef yynerrs
539 #define yynerrs (yystackp->yyerrcnt)
540 #undef yychar
541 #define yychar (yystackp->yyrawchar)
542 #undef yylval
543 #define yylval (yystackp->yyval)
544 #undef yylloc
545 #define yylloc (yystackp->yyloc)
546 m4_if(b4_prefix[], [yy], [],
547 [#define b4_prefix[]nerrs yynerrs
548 #define b4_prefix[]char yychar
549 #define b4_prefix[]lval yylval
550 #define b4_prefix[]lloc yylloc])],
551 [YYSTYPE yylval;
552
553 YYLTYPE yylloc;
554
555 int yynerrs;
556 int yychar;])[
557
558 static const int YYEOF = 0;
559 static const int YYEMPTY = -2;
560
561 typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
562
563 #define YYCHK(YYE) \
564 do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; } \
565 while (YYID (0))
566
567 #if YYDEBUG
568
569 # ifndef YYFPRINTF
570 # define YYFPRINTF fprintf
571 # endif
572
573 # define YYDPRINTF(Args) \
574 do { \
575 if (yydebug) \
576 YYFPRINTF Args; \
577 } while (YYID (0))
578
579 ]b4_yy_symbol_print_generate([b4_c_ansi_function_def])[
580
581 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
582 do { \
583 if (yydebug) \
584 { \
585 YYFPRINTF (stderr, "%s ", Title); \
586 yy_symbol_print (stderr, Type, \
587 Value]b4_locations_if([, Location])[]b4_user_args[); \
588 YYFPRINTF (stderr, "\n"); \
589 } \
590 } while (YYID (0))
591
592 /* Nonzero means print parse trace. It is left uninitialized so that
593 multiple parsers can coexist. */
594 int yydebug;
595
596 #else /* !YYDEBUG */
597
598 # define YYDPRINTF(Args)
599 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
600
601 #endif /* !YYDEBUG */
602
603 /* YYINITDEPTH -- initial size of the parser's stacks. */
604 #ifndef YYINITDEPTH
605 # define YYINITDEPTH ]b4_stack_depth_init[
606 #endif
607
608 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
609 if the built-in stack extension method is used).
610
611 Do not make this value too large; the results are undefined if
612 SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem)
613 evaluated with infinite-precision integer arithmetic. */
614
615 #ifndef YYMAXDEPTH
616 # define YYMAXDEPTH ]b4_stack_depth_max[
617 #endif
618
619 /* Minimum number of free items on the stack allowed after an
620 allocation. This is to allow allocation and initialization
621 to be completed by functions that call yyexpandGLRStack before the
622 stack is expanded, thus insuring that all necessary pointers get
623 properly redirected to new data. */
624 #define YYHEADROOM 2
625
626 #ifndef YYSTACKEXPANDABLE
627 # if (! defined __cplusplus \
628 || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
629 && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))
630 # define YYSTACKEXPANDABLE 1
631 # else
632 # define YYSTACKEXPANDABLE 0
633 # endif
634 #endif
635
636 #if YYSTACKEXPANDABLE
637 # define YY_RESERVE_GLRSTACK(Yystack) \
638 do { \
639 if (Yystack->yyspaceLeft < YYHEADROOM) \
640 yyexpandGLRStack (Yystack); \
641 } while (YYID (0))
642 #else
643 # define YY_RESERVE_GLRSTACK(Yystack) \
644 do { \
645 if (Yystack->yyspaceLeft < YYHEADROOM) \
646 yyMemoryExhausted (Yystack); \
647 } while (YYID (0))
648 #endif
649
650
651 #if YYERROR_VERBOSE
652
653 # ifndef yystpcpy
654 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
655 # define yystpcpy stpcpy
656 # else
657 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
658 YYDEST. */
659 static char *
660 yystpcpy (char *yydest, const char *yysrc)
661 {
662 char *yyd = yydest;
663 const char *yys = yysrc;
664
665 while ((*yyd++ = *yys++) != '\0')
666 continue;
667
668 return yyd - 1;
669 }
670 # endif
671 # endif
672
673 # ifndef yytnamerr
674 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
675 quotes and backslashes, so that it's suitable for yyerror. The
676 heuristic is that double-quoting is unnecessary unless the string
677 contains an apostrophe, a comma, or backslash (other than
678 backslash-backslash). YYSTR is taken from yytname. If YYRES is
679 null, do not copy; instead, return the length of what the result
680 would have been. */
681 static size_t
682 yytnamerr (char *yyres, const char *yystr)
683 {
684 if (*yystr == '"')
685 {
686 size_t yyn = 0;
687 char const *yyp = yystr;
688
689 for (;;)
690 switch (*++yyp)
691 {
692 case '\'':
693 case ',':
694 goto do_not_strip_quotes;
695
696 case '\\':
697 if (*++yyp != '\\')
698 goto do_not_strip_quotes;
699 /* Fall through. */
700 default:
701 if (yyres)
702 yyres[yyn] = *yyp;
703 yyn++;
704 break;
705
706 case '"':
707 if (yyres)
708 yyres[yyn] = '\0';
709 return yyn;
710 }
711 do_not_strip_quotes: ;
712 }
713
714 if (! yyres)
715 return strlen (yystr);
716
717 return yystpcpy (yyres, yystr) - yyres;
718 }
719 # endif
720
721 #endif /* !YYERROR_VERBOSE */
722
723 /** State numbers, as in LALR(1) machine */
724 typedef int yyStateNum;
725
726 /** Rule numbers, as in LALR(1) machine */
727 typedef int yyRuleNum;
728
729 /** Grammar symbol */
730 typedef short int yySymbol;
731
732 /** Item references, as in LALR(1) machine */
733 typedef short int yyItemNum;
734
735 typedef struct yyGLRState yyGLRState;
736 typedef struct yyGLRStateSet yyGLRStateSet;
737 typedef struct yySemanticOption yySemanticOption;
738 typedef union yyGLRStackItem yyGLRStackItem;
739 typedef struct yyGLRStack yyGLRStack;
740
741 struct yyGLRState {
742 /** Type tag: always true. */
743 yybool yyisState;
744 /** Type tag for yysemantics. If true, yysval applies, otherwise
745 * yyfirstVal applies. */
746 yybool yyresolved;
747 /** Number of corresponding LALR(1) machine state. */
748 yyStateNum yylrState;
749 /** Preceding state in this stack */
750 yyGLRState* yypred;
751 /** Source position of the first token produced by my symbol */
752 size_t yyposn;
753 union {
754 /** First in a chain of alternative reductions producing the
755 * non-terminal corresponding to this state, threaded through
756 * yynext. */
757 yySemanticOption* yyfirstVal;
758 /** Semantic value for this state. */
759 YYSTYPE yysval;
760 } yysemantics;
761 /** Source location for this state. */
762 YYLTYPE yyloc;
763 };
764
765 struct yyGLRStateSet {
766 yyGLRState** yystates;
767 /** During nondeterministic operation, yylookaheadNeeds tracks which
768 * stacks have actually needed the current lookahead. During deterministic
769 * operation, yylookaheadNeeds[0] is not maintained since it would merely
770 * duplicate yychar != YYEMPTY. */
771 yybool* yylookaheadNeeds;
772 size_t yysize, yycapacity;
773 };
774
775 struct yySemanticOption {
776 /** Type tag: always false. */
777 yybool yyisState;
778 /** Rule number for this reduction */
779 yyRuleNum yyrule;
780 /** The last RHS state in the list of states to be reduced. */
781 yyGLRState* yystate;
782 /** The lookahead for this reduction. */
783 int yyrawchar;
784 YYSTYPE yyval;
785 YYLTYPE yyloc;
786 /** Next sibling in chain of options. To facilitate merging,
787 * options are chained in decreasing order by address. */
788 yySemanticOption* yynext;
789 };
790
791 /** Type of the items in the GLR stack. The yyisState field
792 * indicates which item of the union is valid. */
793 union yyGLRStackItem {
794 yyGLRState yystate;
795 yySemanticOption yyoption;
796 };
797
798 struct yyGLRStack {
799 int yyerrState;
800 ]b4_locations_if([[ /* To compute the location of the error token. */
801 yyGLRStackItem yyerror_range[3];]])[
802 ]b4_pure_if(
803 [
804 int yyerrcnt;
805 int yyrawchar;
806 YYSTYPE yyval;
807 YYLTYPE yyloc;
808 ])[
809 YYJMP_BUF yyexception_buffer;
810 yyGLRStackItem* yyitems;
811 yyGLRStackItem* yynextFree;
812 size_t yyspaceLeft;
813 yyGLRState* yysplitPoint;
814 yyGLRState* yylastDeleted;
815 yyGLRStateSet yytops;
816 };
817
818 #if YYSTACKEXPANDABLE
819 static void yyexpandGLRStack (yyGLRStack* yystackp);
820 #endif
821
822 static void yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg)
823 __attribute__ ((__noreturn__));
824 static void
825 yyFail (yyGLRStack* yystackp]b4_pure_formals[, const char* yymsg)
826 {
827 if (yymsg != NULL)
828 yyerror (]b4_yyerror_args[yymsg);
829 YYLONGJMP (yystackp->yyexception_buffer, 1);
830 }
831
832 static void yyMemoryExhausted (yyGLRStack* yystackp)
833 __attribute__ ((__noreturn__));
834 static void
835 yyMemoryExhausted (yyGLRStack* yystackp)
836 {
837 YYLONGJMP (yystackp->yyexception_buffer, 2);
838 }
839
840 #if YYDEBUG || YYERROR_VERBOSE
841 /** A printable representation of TOKEN. */
842 static inline const char*
843 yytokenName (yySymbol yytoken)
844 {
845 if (yytoken == YYEMPTY)
846 return "";
847
848 return yytname[yytoken];
849 }
850 #endif
851
852 /** Fill in YYVSP[YYLOW1 .. YYLOW0-1] from the chain of states starting
853 * at YYVSP[YYLOW0].yystate.yypred. Leaves YYVSP[YYLOW1].yystate.yypred
854 * containing the pointer to the next state in the chain. */
855 static void yyfillin (yyGLRStackItem *, int, int) __attribute__ ((__unused__));
856 static void
857 yyfillin (yyGLRStackItem *yyvsp, int yylow0, int yylow1)
858 {
859 yyGLRState* s;
860 int i;
861 s = yyvsp[yylow0].yystate.yypred;
862 for (i = yylow0-1; i >= yylow1; i -= 1)
863 {
864 YYASSERT (s->yyresolved);
865 yyvsp[i].yystate.yyresolved = yytrue;
866 yyvsp[i].yystate.yysemantics.yysval = s->yysemantics.yysval;
867 yyvsp[i].yystate.yyloc = s->yyloc;
868 s = yyvsp[i].yystate.yypred = s->yypred;
869 }
870 }
871
872 /* Do nothing if YYNORMAL or if *YYLOW <= YYLOW1. Otherwise, fill in
873 * YYVSP[YYLOW1 .. *YYLOW-1] as in yyfillin and set *YYLOW = YYLOW1.
874 * For convenience, always return YYLOW1. */
875 static inline int yyfill (yyGLRStackItem *, int *, int, yybool)
876 __attribute__ ((__unused__));
877 static inline int
878 yyfill (yyGLRStackItem *yyvsp, int *yylow, int yylow1, yybool yynormal)
879 {
880 if (!yynormal && yylow1 < *yylow)
881 {
882 yyfillin (yyvsp, *yylow, yylow1);
883 *yylow = yylow1;
884 }
885 return yylow1;
886 }
887
888 /** Perform user action for rule number YYN, with RHS length YYRHSLEN,
889 * and top stack item YYVSP. YYLVALP points to place to put semantic
890 * value ($$), and yylocp points to place for location information
891 * (@@$). Returns yyok for normal return, yyaccept for YYACCEPT,
892 * yyerr for YYERROR, yyabort for YYABORT. */
893 /*ARGSUSED*/ static YYRESULTTAG
894 yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
895 YYSTYPE* yyvalp,
896 YYLTYPE* YYOPTIONAL_LOC (yylocp),
897 yyGLRStack* yystackp
898 ]b4_user_formals[)
899 {
900 yybool yynormal __attribute__ ((__unused__)) =
901 (yystackp->yysplitPoint == NULL);
902 int yylow;
903 ]b4_parse_param_use[]dnl
904 [# undef yyerrok
905 # define yyerrok (yystackp->yyerrState = 0)
906 # undef YYACCEPT
907 # define YYACCEPT return yyaccept
908 # undef YYABORT
909 # define YYABORT return yyabort
910 # undef YYERROR
911 # define YYERROR return yyerrok, yyerr
912 # undef YYRECOVERING
913 # define YYRECOVERING() (yystackp->yyerrState != 0)
914 # undef yyclearin
915 # define yyclearin (yychar = YYEMPTY)
916 # undef YYFILL
917 # define YYFILL(N) yyfill (yyvsp, &yylow, N, yynormal)
918 # undef YYBACKUP
919 # define YYBACKUP(Token, Value) \
920 return yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")), \
921 yyerrok, yyerr
922
923 yylow = 1;
924 if (yyrhslen == 0)
925 *yyvalp = yyval_default;
926 else
927 *yyvalp = yyvsp[YYFILL (1-yyrhslen)].yystate.yysemantics.yysval;
928 YYLLOC_DEFAULT ((*yylocp), (yyvsp - yyrhslen), yyrhslen);
929 ]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = *yylocp;
930 ]])[
931 switch (yyn)
932 {
933 ]b4_user_actions[
934 default: break;
935 }
936
937 return yyok;
938 # undef yyerrok
939 # undef YYABORT
940 # undef YYACCEPT
941 # undef YYERROR
942 # undef YYBACKUP
943 # undef yyclearin
944 # undef YYRECOVERING
945 }
946 \f
947
948 /*ARGSUSED*/ static void
949 yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
950 {
951 YYUSE (yy0);
952 YYUSE (yy1);
953
954 switch (yyn)
955 {
956 ]b4_mergers[
957 default: break;
958 }
959 }
960
961 /* Bison grammar-table manipulation. */
962
963 ]b4_yydestruct_generate([b4_c_ansi_function_def])[
964
965 /** Number of symbols composing the right hand side of rule #RULE. */
966 static inline int
967 yyrhsLength (yyRuleNum yyrule)
968 {
969 return yyr2[yyrule];
970 }
971
972 static void
973 yydestroyGLRState (char const *yymsg, yyGLRState *yys]b4_user_formals[)
974 {
975 if (yys->yyresolved)
976 yydestruct (yymsg, yystos[yys->yylrState],
977 &yys->yysemantics.yysval]b4_locations_if([, &yys->yyloc])[]b4_user_args[);
978 else
979 {
980 #if YYDEBUG
981 if (yydebug)
982 {
983 if (yys->yysemantics.yyfirstVal)
984 YYFPRINTF (stderr, "%s unresolved ", yymsg);
985 else
986 YYFPRINTF (stderr, "%s incomplete ", yymsg);
987 yy_symbol_print (stderr, yystos[yys->yylrState],
988 NULL]b4_locations_if([, &yys->yyloc])[]b4_user_args[);
989 YYFPRINTF (stderr, "\n");
990 }
991 #endif
992
993 if (yys->yysemantics.yyfirstVal)
994 {
995 yySemanticOption *yyoption = yys->yysemantics.yyfirstVal;
996 yyGLRState *yyrh;
997 int yyn;
998 for (yyrh = yyoption->yystate, yyn = yyrhsLength (yyoption->yyrule);
999 yyn > 0;
1000 yyrh = yyrh->yypred, yyn -= 1)
1001 yydestroyGLRState (yymsg, yyrh]b4_user_args[);
1002 }
1003 }
1004 }
1005
1006 /** Left-hand-side symbol for rule #RULE. */
1007 static inline yySymbol
1008 yylhsNonterm (yyRuleNum yyrule)
1009 {
1010 return yyr1[yyrule];
1011 }
1012
1013 #define yyis_pact_ninf(yystate) \
1014 ]m4_if(m4_eval(b4_pact_ninf < b4_pact_min), [1],
1015 [0],
1016 [((yystate) == YYPACT_NINF)])[
1017
1018 /** True iff LR state STATE has only a default reduction (regardless
1019 * of token). */
1020 static inline yybool
1021 yyisDefaultedState (yyStateNum yystate)
1022 {
1023 return yyis_pact_ninf (yypact[yystate]);
1024 }
1025
1026 /** The default reduction for STATE, assuming it has one. */
1027 static inline yyRuleNum
1028 yydefaultAction (yyStateNum yystate)
1029 {
1030 return yydefact[yystate];
1031 }
1032
1033 #define yyis_table_ninf(yytable_value) \
1034 ]m4_if(m4_eval(b4_table_ninf < b4_table_min), [1],
1035 [YYID (0)],
1036 [((yytable_value) == YYTABLE_NINF)])[
1037
1038 /** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN.
1039 * Result R means
1040 * R < 0: Reduce on rule -R.
1041 * R = 0: Error.
1042 * R > 0: Shift to state R.
1043 * Set *CONFLICTS to a pointer into yyconfl to 0-terminated list of
1044 * conflicting reductions.
1045 */
1046 static inline void
1047 yygetLRActions (yyStateNum yystate, int yytoken,
1048 int* yyaction, const short int** yyconflicts)
1049 {
1050 int yyindex = yypact[yystate] + yytoken;
1051 if (yyindex < 0 || YYLAST < yyindex
1052 || (]b4_safest_int_type[)yycheck[yyindex] != yytoken)
1053 {
1054 *yyaction = -yydefact[yystate];
1055 *yyconflicts = yyconfl;
1056 }
1057 else if (! yyis_table_ninf (yytable[yyindex]))
1058 {
1059 *yyaction = yytable[yyindex];
1060 *yyconflicts = yyconfl + yyconflp[yyindex];
1061 }
1062 else
1063 {
1064 *yyaction = 0;
1065 *yyconflicts = yyconfl + yyconflp[yyindex];
1066 }
1067 }
1068
1069 static inline yyStateNum
1070 yyLRgotoState (yyStateNum yystate, yySymbol yylhs)
1071 {
1072 int yyr;
1073 yyr = yypgoto[yylhs - YYNTOKENS] + yystate;
1074 if (0 <= yyr && yyr <= YYLAST
1075 && (]b4_safest_int_type[)yycheck[yyr] == yystate)
1076 return yytable[yyr];
1077 else
1078 return yydefgoto[yylhs - YYNTOKENS];
1079 }
1080
1081 static inline yybool
1082 yyisShiftAction (int yyaction)
1083 {
1084 return 0 < yyaction;
1085 }
1086
1087 static inline yybool
1088 yyisErrorAction (int yyaction)
1089 {
1090 return yyaction == 0;
1091 }
1092
1093 /* GLRStates */
1094
1095 /** Return a fresh GLRStackItem. Callers should call
1096 * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient
1097 * headroom. */
1098
1099 static inline yyGLRStackItem*
1100 yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState)
1101 {
1102 yyGLRStackItem* yynewItem = yystackp->yynextFree;
1103 yystackp->yyspaceLeft -= 1;
1104 yystackp->yynextFree += 1;
1105 yynewItem->yystate.yyisState = yyisState;
1106 return yynewItem;
1107 }
1108
1109 /** Add a new semantic action that will execute the action for rule
1110 * RULENUM on the semantic values in RHS to the list of
1111 * alternative actions for STATE. Assumes that RHS comes from
1112 * stack #K of *STACKP. */
1113 static void
1114 yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,
1115 yyGLRState* rhs, yyRuleNum yyrule)
1116 {
1117 yySemanticOption* yynewOption =
1118 &yynewGLRStackItem (yystackp, yyfalse)->yyoption;
1119 yynewOption->yystate = rhs;
1120 yynewOption->yyrule = yyrule;
1121 if (yystackp->yytops.yylookaheadNeeds[yyk])
1122 {
1123 yynewOption->yyrawchar = yychar;
1124 yynewOption->yyval = yylval;
1125 yynewOption->yyloc = yylloc;
1126 }
1127 else
1128 yynewOption->yyrawchar = YYEMPTY;
1129 yynewOption->yynext = yystate->yysemantics.yyfirstVal;
1130 yystate->yysemantics.yyfirstVal = yynewOption;
1131
1132 YY_RESERVE_GLRSTACK (yystackp);
1133 }
1134
1135 /* GLRStacks */
1136
1137 /** Initialize SET to a singleton set containing an empty stack. */
1138 static yybool
1139 yyinitStateSet (yyGLRStateSet* yyset)
1140 {
1141 yyset->yysize = 1;
1142 yyset->yycapacity = 16;
1143 yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]);
1144 if (! yyset->yystates)
1145 return yyfalse;
1146 yyset->yystates[0] = NULL;
1147 yyset->yylookaheadNeeds =
1148 (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]);
1149 if (! yyset->yylookaheadNeeds)
1150 {
1151 YYFREE (yyset->yystates);
1152 return yyfalse;
1153 }
1154 return yytrue;
1155 }
1156
1157 static void yyfreeStateSet (yyGLRStateSet* yyset)
1158 {
1159 YYFREE (yyset->yystates);
1160 YYFREE (yyset->yylookaheadNeeds);
1161 }
1162
1163 /** Initialize STACK to a single empty stack, with total maximum
1164 * capacity for all stacks of SIZE. */
1165 static yybool
1166 yyinitGLRStack (yyGLRStack* yystackp, size_t yysize)
1167 {
1168 yystackp->yyerrState = 0;
1169 yynerrs = 0;
1170 yystackp->yyspaceLeft = yysize;
1171 yystackp->yyitems =
1172 (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystackp->yynextFree[0]);
1173 if (!yystackp->yyitems)
1174 return yyfalse;
1175 yystackp->yynextFree = yystackp->yyitems;
1176 yystackp->yysplitPoint = NULL;
1177 yystackp->yylastDeleted = NULL;
1178 return yyinitStateSet (&yystackp->yytops);
1179 }
1180
1181
1182 #if YYSTACKEXPANDABLE
1183 # define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \
1184 &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE
1185
1186 /** If STACK is expandable, extend it. WARNING: Pointers into the
1187 stack from outside should be considered invalid after this call.
1188 We always expand when there are 1 or fewer items left AFTER an
1189 allocation, so that we can avoid having external pointers exist
1190 across an allocation. */
1191 static void
1192 yyexpandGLRStack (yyGLRStack* yystackp)
1193 {
1194 yyGLRStackItem* yynewItems;
1195 yyGLRStackItem* yyp0, *yyp1;
1196 size_t yysize, yynewSize;
1197 size_t yyn;
1198 yysize = yystackp->yynextFree - yystackp->yyitems;
1199 if (YYMAXDEPTH - YYHEADROOM < yysize)
1200 yyMemoryExhausted (yystackp);
1201 yynewSize = 2*yysize;
1202 if (YYMAXDEPTH < yynewSize)
1203 yynewSize = YYMAXDEPTH;
1204 yynewItems = (yyGLRStackItem*) YYMALLOC (yynewSize * sizeof yynewItems[0]);
1205 if (! yynewItems)
1206 yyMemoryExhausted (yystackp);
1207 for (yyp0 = yystackp->yyitems, yyp1 = yynewItems, yyn = yysize;
1208 0 < yyn;
1209 yyn -= 1, yyp0 += 1, yyp1 += 1)
1210 {
1211 *yyp1 = *yyp0;
1212 if (*(yybool *) yyp0)
1213 {
1214 yyGLRState* yys0 = &yyp0->yystate;
1215 yyGLRState* yys1 = &yyp1->yystate;
1216 if (yys0->yypred != NULL)
1217 yys1->yypred =
1218 YYRELOC (yyp0, yyp1, yys0->yypred, yystate);
1219 if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != NULL)
1220 yys1->yysemantics.yyfirstVal =
1221 YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption);
1222 }
1223 else
1224 {
1225 yySemanticOption* yyv0 = &yyp0->yyoption;
1226 yySemanticOption* yyv1 = &yyp1->yyoption;
1227 if (yyv0->yystate != NULL)
1228 yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate);
1229 if (yyv0->yynext != NULL)
1230 yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption);
1231 }
1232 }
1233 if (yystackp->yysplitPoint != NULL)
1234 yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems,
1235 yystackp->yysplitPoint, yystate);
1236
1237 for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1)
1238 if (yystackp->yytops.yystates[yyn] != NULL)
1239 yystackp->yytops.yystates[yyn] =
1240 YYRELOC (yystackp->yyitems, yynewItems,
1241 yystackp->yytops.yystates[yyn], yystate);
1242 YYFREE (yystackp->yyitems);
1243 yystackp->yyitems = yynewItems;
1244 yystackp->yynextFree = yynewItems + yysize;
1245 yystackp->yyspaceLeft = yynewSize - yysize;
1246 }
1247 #endif
1248
1249 static void
1250 yyfreeGLRStack (yyGLRStack* yystackp)
1251 {
1252 YYFREE (yystackp->yyitems);
1253 yyfreeStateSet (&yystackp->yytops);
1254 }
1255
1256 /** Assuming that S is a GLRState somewhere on STACK, update the
1257 * splitpoint of STACK, if needed, so that it is at least as deep as
1258 * S. */
1259 static inline void
1260 yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys)
1261 {
1262 if (yystackp->yysplitPoint != NULL && yystackp->yysplitPoint > yys)
1263 yystackp->yysplitPoint = yys;
1264 }
1265
1266 /** Invalidate stack #K in STACK. */
1267 static inline void
1268 yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk)
1269 {
1270 if (yystackp->yytops.yystates[yyk] != NULL)
1271 yystackp->yylastDeleted = yystackp->yytops.yystates[yyk];
1272 yystackp->yytops.yystates[yyk] = NULL;
1273 }
1274
1275 /** Undelete the last stack that was marked as deleted. Can only be
1276 done once after a deletion, and only when all other stacks have
1277 been deleted. */
1278 static void
1279 yyundeleteLastStack (yyGLRStack* yystackp)
1280 {
1281 if (yystackp->yylastDeleted == NULL || yystackp->yytops.yysize != 0)
1282 return;
1283 yystackp->yytops.yystates[0] = yystackp->yylastDeleted;
1284 yystackp->yytops.yysize = 1;
1285 YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n"));
1286 yystackp->yylastDeleted = NULL;
1287 }
1288
1289 static inline void
1290 yyremoveDeletes (yyGLRStack* yystackp)
1291 {
1292 size_t yyi, yyj;
1293 yyi = yyj = 0;
1294 while (yyj < yystackp->yytops.yysize)
1295 {
1296 if (yystackp->yytops.yystates[yyi] == NULL)
1297 {
1298 if (yyi == yyj)
1299 {
1300 YYDPRINTF ((stderr, "Removing dead stacks.\n"));
1301 }
1302 yystackp->yytops.yysize -= 1;
1303 }
1304 else
1305 {
1306 yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi];
1307 /* In the current implementation, it's unnecessary to copy
1308 yystackp->yytops.yylookaheadNeeds[yyi] since, after
1309 yyremoveDeletes returns, the parser immediately either enters
1310 deterministic operation or shifts a token. However, it doesn't
1311 hurt, and the code might evolve to need it. */
1312 yystackp->yytops.yylookaheadNeeds[yyj] =
1313 yystackp->yytops.yylookaheadNeeds[yyi];
1314 if (yyj != yyi)
1315 {
1316 YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n",
1317 (unsigned long int) yyi, (unsigned long int) yyj));
1318 }
1319 yyj += 1;
1320 }
1321 yyi += 1;
1322 }
1323 }
1324
1325 /** Shift to a new state on stack #K of STACK, corresponding to LR state
1326 * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */
1327 static inline void
1328 yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
1329 size_t yyposn,
1330 YYSTYPE* yyvalp, YYLTYPE* yylocp)
1331 {
1332 yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
1333
1334 yynewState->yylrState = yylrState;
1335 yynewState->yyposn = yyposn;
1336 yynewState->yyresolved = yytrue;
1337 yynewState->yypred = yystackp->yytops.yystates[yyk];
1338 yynewState->yysemantics.yysval = *yyvalp;
1339 yynewState->yyloc = *yylocp;
1340 yystackp->yytops.yystates[yyk] = yynewState;
1341
1342 YY_RESERVE_GLRSTACK (yystackp);
1343 }
1344
1345 /** Shift stack #K of YYSTACK, to a new state corresponding to LR
1346 * state YYLRSTATE, at input position YYPOSN, with the (unresolved)
1347 * semantic value of YYRHS under the action for YYRULE. */
1348 static inline void
1349 yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
1350 size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule)
1351 {
1352 yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
1353
1354 yynewState->yylrState = yylrState;
1355 yynewState->yyposn = yyposn;
1356 yynewState->yyresolved = yyfalse;
1357 yynewState->yypred = yystackp->yytops.yystates[yyk];
1358 yynewState->yysemantics.yyfirstVal = NULL;
1359 yystackp->yytops.yystates[yyk] = yynewState;
1360
1361 /* Invokes YY_RESERVE_GLRSTACK. */
1362 yyaddDeferredAction (yystackp, yyk, yynewState, rhs, yyrule);
1363 }
1364
1365 /** Pop the symbols consumed by reduction #RULE from the top of stack
1366 * #K of STACK, and perform the appropriate semantic action on their
1367 * semantic values. Assumes that all ambiguities in semantic values
1368 * have been previously resolved. Set *VALP to the resulting value,
1369 * and *LOCP to the computed location (if any). Return value is as
1370 * for userAction. */
1371 static inline YYRESULTTAG
1372 yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
1373 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
1374 {
1375 int yynrhs = yyrhsLength (yyrule);
1376
1377 if (yystackp->yysplitPoint == NULL)
1378 {
1379 /* Standard special case: single stack. */
1380 yyGLRStackItem* rhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
1381 YYASSERT (yyk == 0);
1382 yystackp->yynextFree -= yynrhs;
1383 yystackp->yyspaceLeft += yynrhs;
1384 yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate;
1385 return yyuserAction (yyrule, yynrhs, rhs,
1386 yyvalp, yylocp, yystackp]b4_user_args[);
1387 }
1388 else
1389 {
1390 /* At present, doAction is never called in nondeterministic
1391 * mode, so this branch is never taken. It is here in
1392 * anticipation of a future feature that will allow immediate
1393 * evaluation of selected actions in nondeterministic mode. */
1394 int yyi;
1395 yyGLRState* yys;
1396 yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
1397 yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred
1398 = yystackp->yytops.yystates[yyk];]b4_locations_if([[
1399 if (yynrhs == 0)
1400 /* Set default location. */
1401 yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[
1402 for (yyi = 0; yyi < yynrhs; yyi += 1)
1403 {
1404 yys = yys->yypred;
1405 YYASSERT (yys);
1406 }
1407 yyupdateSplit (yystackp, yys);
1408 yystackp->yytops.yystates[yyk] = yys;
1409 return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
1410 yyvalp, yylocp, yystackp]b4_user_args[);
1411 }
1412 }
1413
1414 #if !YYDEBUG
1415 # define YY_REDUCE_PRINT(Args)
1416 #else
1417 # define YY_REDUCE_PRINT(Args) \
1418 do { \
1419 if (yydebug) \
1420 yy_reduce_print Args; \
1421 } while (YYID (0))
1422
1423 /*----------------------------------------------------------.
1424 | Report that the RULE is going to be reduced on stack #K. |
1425 `----------------------------------------------------------*/
1426
1427 /*ARGSUSED*/ static inline void
1428 yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
1429 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
1430 {
1431 int yynrhs = yyrhsLength (yyrule);
1432 yybool yynormal __attribute__ ((__unused__)) =
1433 (yystackp->yysplitPoint == NULL);
1434 yyGLRStackItem* yyvsp = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
1435 int yylow = 1;
1436 int yyi;
1437 YYUSE (yyvalp);
1438 YYUSE (yylocp);
1439 ]b4_parse_param_use[]dnl
1440 [ YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n",
1441 (unsigned long int) yyk, yyrule - 1,
1442 (unsigned long int) yyrline[yyrule]);
1443 /* The symbols being reduced. */
1444 for (yyi = 0; yyi < yynrhs; yyi++)
1445 {
1446 fprintf (stderr, " $%d = ", yyi + 1);
1447 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1448 &]b4_rhs_value(yynrhs, yyi + 1)[
1449 ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
1450 b4_user_args[);
1451 fprintf (stderr, "\n");
1452 }
1453 }
1454 #endif
1455
1456 /** Pop items off stack #K of STACK according to grammar rule RULE,
1457 * and push back on the resulting nonterminal symbol. Perform the
1458 * semantic action associated with RULE and store its value with the
1459 * newly pushed state, if FORCEEVAL or if STACK is currently
1460 * unambiguous. Otherwise, store the deferred semantic action with
1461 * the new state. If the new state would have an identical input
1462 * position, LR state, and predecessor to an existing state on the stack,
1463 * it is identified with that existing state, eliminating stack #K from
1464 * the STACK. In this case, the (necessarily deferred) semantic value is
1465 * added to the options for the existing state's semantic value.
1466 */
1467 static inline YYRESULTTAG
1468 yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
1469 yybool yyforceEval]b4_user_formals[)
1470 {
1471 size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn;
1472
1473 if (yyforceEval || yystackp->yysplitPoint == NULL)
1474 {
1475 YYSTYPE yysval;
1476 YYLTYPE yyloc;
1477
1478 YY_REDUCE_PRINT ((yystackp, yyk, yyrule, &yysval, &yyloc]b4_user_args[));
1479 YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval,
1480 &yyloc]b4_user_args[));
1481 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc);
1482 yyglrShift (yystackp, yyk,
1483 yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState,
1484 yylhsNonterm (yyrule)),
1485 yyposn, &yysval, &yyloc);
1486 }
1487 else
1488 {
1489 size_t yyi;
1490 int yyn;
1491 yyGLRState* yys, *yys0 = yystackp->yytops.yystates[yyk];
1492 yyStateNum yynewLRState;
1493
1494 for (yys = yystackp->yytops.yystates[yyk], yyn = yyrhsLength (yyrule);
1495 0 < yyn; yyn -= 1)
1496 {
1497 yys = yys->yypred;
1498 YYASSERT (yys);
1499 }
1500 yyupdateSplit (yystackp, yys);
1501 yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
1502 YYDPRINTF ((stderr,
1503 "Reduced stack %lu by rule #%d; action deferred. Now in state %d.\n",
1504 (unsigned long int) yyk, yyrule - 1, yynewLRState));
1505 for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
1506 if (yyi != yyk && yystackp->yytops.yystates[yyi] != NULL)
1507 {
1508 yyGLRState* yyp, *yysplit = yystackp->yysplitPoint;
1509 yyp = yystackp->yytops.yystates[yyi];
1510 while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn)
1511 {
1512 if (yyp->yylrState == yynewLRState && yyp->yypred == yys)
1513 {
1514 yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule);
1515 yymarkStackDeleted (yystackp, yyk);
1516 YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n",
1517 (unsigned long int) yyk,
1518 (unsigned long int) yyi));
1519 return yyok;
1520 }
1521 yyp = yyp->yypred;
1522 }
1523 }
1524 yystackp->yytops.yystates[yyk] = yys;
1525 yyglrShiftDefer (yystackp, yyk, yynewLRState, yyposn, yys0, yyrule);
1526 }
1527 return yyok;
1528 }
1529
1530 static size_t
1531 yysplitStack (yyGLRStack* yystackp, size_t yyk)
1532 {
1533 if (yystackp->yysplitPoint == NULL)
1534 {
1535 YYASSERT (yyk == 0);
1536 yystackp->yysplitPoint = yystackp->yytops.yystates[yyk];
1537 }
1538 if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity)
1539 {
1540 yyGLRState** yynewStates;
1541 yybool* yynewLookaheadNeeds;
1542
1543 yynewStates = NULL;
1544
1545 if (yystackp->yytops.yycapacity
1546 > (YYSIZEMAX / (2 * sizeof yynewStates[0])))
1547 yyMemoryExhausted (yystackp);
1548 yystackp->yytops.yycapacity *= 2;
1549
1550 yynewStates =
1551 (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
1552 (yystackp->yytops.yycapacity
1553 * sizeof yynewStates[0]));
1554 if (yynewStates == NULL)
1555 yyMemoryExhausted (yystackp);
1556 yystackp->yytops.yystates = yynewStates;
1557
1558 yynewLookaheadNeeds =
1559 (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds,
1560 (yystackp->yytops.yycapacity
1561 * sizeof yynewLookaheadNeeds[0]));
1562 if (yynewLookaheadNeeds == NULL)
1563 yyMemoryExhausted (yystackp);
1564 yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds;
1565 }
1566 yystackp->yytops.yystates[yystackp->yytops.yysize]
1567 = yystackp->yytops.yystates[yyk];
1568 yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize]
1569 = yystackp->yytops.yylookaheadNeeds[yyk];
1570 yystackp->yytops.yysize += 1;
1571 return yystackp->yytops.yysize-1;
1572 }
1573
1574 /** True iff Y0 and Y1 represent identical options at the top level.
1575 * That is, they represent the same rule applied to RHS symbols
1576 * that produce the same terminal symbols. */
1577 static yybool
1578 yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1)
1579 {
1580 if (yyy0->yyrule == yyy1->yyrule)
1581 {
1582 yyGLRState *yys0, *yys1;
1583 int yyn;
1584 for (yys0 = yyy0->yystate, yys1 = yyy1->yystate,
1585 yyn = yyrhsLength (yyy0->yyrule);
1586 yyn > 0;
1587 yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1)
1588 if (yys0->yyposn != yys1->yyposn)
1589 return yyfalse;
1590 return yytrue;
1591 }
1592 else
1593 return yyfalse;
1594 }
1595
1596 /** Assuming identicalOptions (Y0,Y1), destructively merge the
1597 * alternative semantic values for the RHS-symbols of Y1 and Y0. */
1598 static void
1599 yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1)
1600 {
1601 yyGLRState *yys0, *yys1;
1602 int yyn;
1603 for (yys0 = yyy0->yystate, yys1 = yyy1->yystate,
1604 yyn = yyrhsLength (yyy0->yyrule);
1605 yyn > 0;
1606 yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1)
1607 {
1608 if (yys0 == yys1)
1609 break;
1610 else if (yys0->yyresolved)
1611 {
1612 yys1->yyresolved = yytrue;
1613 yys1->yysemantics.yysval = yys0->yysemantics.yysval;
1614 }
1615 else if (yys1->yyresolved)
1616 {
1617 yys0->yyresolved = yytrue;
1618 yys0->yysemantics.yysval = yys1->yysemantics.yysval;
1619 }
1620 else
1621 {
1622 yySemanticOption** yyz0p;
1623 yySemanticOption* yyz1;
1624 yyz0p = &yys0->yysemantics.yyfirstVal;
1625 yyz1 = yys1->yysemantics.yyfirstVal;
1626 while (YYID (yytrue))
1627 {
1628 if (yyz1 == *yyz0p || yyz1 == NULL)
1629 break;
1630 else if (*yyz0p == NULL)
1631 {
1632 *yyz0p = yyz1;
1633 break;
1634 }
1635 else if (*yyz0p < yyz1)
1636 {
1637 yySemanticOption* yyz = *yyz0p;
1638 *yyz0p = yyz1;
1639 yyz1 = yyz1->yynext;
1640 (*yyz0p)->yynext = yyz;
1641 }
1642 yyz0p = &(*yyz0p)->yynext;
1643 }
1644 yys1->yysemantics.yyfirstVal = yys0->yysemantics.yyfirstVal;
1645 }
1646 }
1647 }
1648
1649 /** Y0 and Y1 represent two possible actions to take in a given
1650 * parsing state; return 0 if no combination is possible,
1651 * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */
1652 static int
1653 yypreference (yySemanticOption* y0, yySemanticOption* y1)
1654 {
1655 yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule;
1656 int p0 = yydprec[r0], p1 = yydprec[r1];
1657
1658 if (p0 == p1)
1659 {
1660 if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1])
1661 return 0;
1662 else
1663 return 1;
1664 }
1665 if (p0 == 0 || p1 == 0)
1666 return 0;
1667 if (p0 < p1)
1668 return 3;
1669 if (p1 < p0)
1670 return 2;
1671 return 0;
1672 }
1673
1674 static YYRESULTTAG yyresolveValue (yyGLRState* yys,
1675 yyGLRStack* yystackp]b4_user_formals[);
1676
1677
1678 /** Resolve the previous N states starting at and including state S. If result
1679 * != yyok, some states may have been left unresolved possibly with empty
1680 * semantic option chains. Regardless of whether result = yyok, each state
1681 * has been left with consistent data so that yydestroyGLRState can be invoked
1682 * if necessary. */
1683 static YYRESULTTAG
1684 yyresolveStates (yyGLRState* yys, int yyn,
1685 yyGLRStack* yystackp]b4_user_formals[)
1686 {
1687 if (0 < yyn)
1688 {
1689 YYASSERT (yys->yypred);
1690 YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[));
1691 if (! yys->yyresolved)
1692 YYCHK (yyresolveValue (yys, yystackp]b4_user_args[));
1693 }
1694 return yyok;
1695 }
1696
1697 /** Resolve the states for the RHS of OPT, perform its user action, and return
1698 * the semantic value and location. Regardless of whether result = yyok, all
1699 * RHS states have been destroyed (assuming the user action destroys all RHS
1700 * semantic values if invoked). */
1701 static YYRESULTTAG
1702 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
1703 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
1704 {
1705 yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
1706 int yynrhs;
1707 int yychar_current;
1708 YYSTYPE yylval_current;
1709 YYLTYPE yylloc_current;
1710 YYRESULTTAG yyflag;
1711
1712 yynrhs = yyrhsLength (yyopt->yyrule);
1713 yyflag = yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[);
1714 if (yyflag != yyok)
1715 {
1716 yyGLRState *yys;
1717 for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1)
1718 yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
1719 return yyflag;
1720 }
1721
1722 yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_locations_if([[
1723 if (yynrhs == 0)
1724 /* Set default location. */
1725 yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[
1726 yychar_current = yychar;
1727 yylval_current = yylval;
1728 yylloc_current = yylloc;
1729 yychar = yyopt->yyrawchar;
1730 yylval = yyopt->yyval;
1731 yylloc = yyopt->yyloc;
1732 yyflag = yyuserAction (yyopt->yyrule, yynrhs,
1733 yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
1734 yyvalp, yylocp, yystackp]b4_user_args[);
1735 yychar = yychar_current;
1736 yylval = yylval_current;
1737 yylloc = yylloc_current;
1738 return yyflag;
1739 }
1740
1741 #if YYDEBUG
1742 static void
1743 yyreportTree (yySemanticOption* yyx, int yyindent)
1744 {
1745 int yynrhs = yyrhsLength (yyx->yyrule);
1746 int yyi;
1747 yyGLRState* yys;
1748 yyGLRState* yystates[1 + YYMAXRHS];
1749 yyGLRState yyleftmost_state;
1750
1751 for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred)
1752 yystates[yyi] = yys;
1753 if (yys == NULL)
1754 {
1755 yyleftmost_state.yyposn = 0;
1756 yystates[0] = &yyleftmost_state;
1757 }
1758 else
1759 yystates[0] = yys;
1760
1761 if (yyx->yystate->yyposn < yys->yyposn + 1)
1762 YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n",
1763 yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
1764 yyx->yyrule - 1);
1765 else
1766 YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n",
1767 yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
1768 yyx->yyrule - 1, (unsigned long int) (yys->yyposn + 1),
1769 (unsigned long int) yyx->yystate->yyposn);
1770 for (yyi = 1; yyi <= yynrhs; yyi += 1)
1771 {
1772 if (yystates[yyi]->yyresolved)
1773 {
1774 if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn)
1775 YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "",
1776 yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]));
1777 else
1778 YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "",
1779 yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]),
1780 (unsigned long int) (yystates[yyi - 1]->yyposn + 1),
1781 (unsigned long int) yystates[yyi]->yyposn);
1782 }
1783 else
1784 yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2);
1785 }
1786 }
1787 #endif
1788
1789 /*ARGSUSED*/ static YYRESULTTAG
1790 yyreportAmbiguity (yySemanticOption* yyx0,
1791 yySemanticOption* yyx1]b4_pure_formals[)
1792 {
1793 YYUSE (yyx0);
1794 YYUSE (yyx1);
1795
1796 #if YYDEBUG
1797 YYFPRINTF (stderr, "Ambiguity detected.\n");
1798 YYFPRINTF (stderr, "Option 1,\n");
1799 yyreportTree (yyx0, 2);
1800 YYFPRINTF (stderr, "\nOption 2,\n");
1801 yyreportTree (yyx1, 2);
1802 YYFPRINTF (stderr, "\n");
1803 #endif
1804
1805 yyerror (]b4_yyerror_args[YY_("syntax is ambiguous"));
1806 return yyabort;
1807 }
1808
1809 /** Starting at and including state S1, resolve the location for each of the
1810 * previous N1 states that is unresolved. The first semantic option of a state
1811 * is always chosen. */
1812 static void
1813 yyresolveLocations (yyGLRState* yys1, int yyn1,
1814 yyGLRStack *yystackp]b4_user_formals[)
1815 {
1816 if (0 < yyn1)
1817 {
1818 yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[);
1819 if (!yys1->yyresolved)
1820 {
1821 yySemanticOption *yyoption;
1822 yyGLRStackItem yyrhsloc[1 + YYMAXRHS];
1823 int yynrhs;
1824 int yychar_current;
1825 YYSTYPE yylval_current;
1826 YYLTYPE yylloc_current;
1827 yyoption = yys1->yysemantics.yyfirstVal;
1828 YYASSERT (yyoption != NULL);
1829 yynrhs = yyrhsLength (yyoption->yyrule);
1830 if (yynrhs > 0)
1831 {
1832 yyGLRState *yys;
1833 int yyn;
1834 yyresolveLocations (yyoption->yystate, yynrhs,
1835 yystackp]b4_user_args[);
1836 for (yys = yyoption->yystate, yyn = yynrhs;
1837 yyn > 0;
1838 yys = yys->yypred, yyn -= 1)
1839 yyrhsloc[yyn].yystate.yyloc = yys->yyloc;
1840 }
1841 else
1842 {
1843 /* Both yyresolveAction and yyresolveLocations traverse the GSS
1844 in reverse rightmost order. It is only necessary to invoke
1845 yyresolveLocations on a subforest for which yyresolveAction
1846 would have been invoked next had an ambiguity not been
1847 detected. Thus the location of the previous state (but not
1848 necessarily the previous state itself) is guaranteed to be
1849 resolved already. */
1850 yyGLRState *yyprevious = yyoption->yystate;
1851 yyrhsloc[0].yystate.yyloc = yyprevious->yyloc;
1852 }
1853 yychar_current = yychar;
1854 yylval_current = yylval;
1855 yylloc_current = yylloc;
1856 yychar = yyoption->yyrawchar;
1857 yylval = yyoption->yyval;
1858 yylloc = yyoption->yyloc;
1859 YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs);
1860 yychar = yychar_current;
1861 yylval = yylval_current;
1862 yylloc = yylloc_current;
1863 }
1864 }
1865 }
1866
1867 /** Resolve the ambiguity represented in state S, perform the indicated
1868 * actions, and set the semantic value of S. If result != yyok, the chain of
1869 * semantic options in S has been cleared instead or it has been left
1870 * unmodified except that redundant options may have been removed. Regardless
1871 * of whether result = yyok, S has been left with consistent data so that
1872 * yydestroyGLRState can be invoked if necessary. */
1873 static YYRESULTTAG
1874 yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
1875 {
1876 yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal;
1877 yySemanticOption* yybest;
1878 yySemanticOption** yypp;
1879 yybool yymerge;
1880 YYSTYPE yysval;
1881 YYRESULTTAG yyflag;
1882 YYLTYPE *yylocp = &yys->yyloc;
1883
1884 yybest = yyoptionList;
1885 yymerge = yyfalse;
1886 for (yypp = &yyoptionList->yynext; *yypp != NULL; )
1887 {
1888 yySemanticOption* yyp = *yypp;
1889
1890 if (yyidenticalOptions (yybest, yyp))
1891 {
1892 yymergeOptionSets (yybest, yyp);
1893 *yypp = yyp->yynext;
1894 }
1895 else
1896 {
1897 switch (yypreference (yybest, yyp))
1898 {
1899 case 0:
1900 yyresolveLocations (yys, 1, yystackp]b4_user_args[);
1901 return yyreportAmbiguity (yybest, yyp]b4_pure_args[);
1902 break;
1903 case 1:
1904 yymerge = yytrue;
1905 break;
1906 case 2:
1907 break;
1908 case 3:
1909 yybest = yyp;
1910 yymerge = yyfalse;
1911 break;
1912 default:
1913 /* This cannot happen so it is not worth a YYASSERT (yyfalse),
1914 but some compilers complain if the default case is
1915 omitted. */
1916 break;
1917 }
1918 yypp = &yyp->yynext;
1919 }
1920 }
1921
1922 if (yymerge)
1923 {
1924 yySemanticOption* yyp;
1925 int yyprec = yydprec[yybest->yyrule];
1926 yyflag = yyresolveAction (yybest, yystackp, &yysval,
1927 yylocp]b4_user_args[);
1928 if (yyflag == yyok)
1929 for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
1930 {
1931 if (yyprec == yydprec[yyp->yyrule])
1932 {
1933 YYSTYPE yysval_other;
1934 YYLTYPE yydummy;
1935 yyflag = yyresolveAction (yyp, yystackp, &yysval_other,
1936 &yydummy]b4_user_args[);
1937 if (yyflag != yyok)
1938 {
1939 yydestruct ("Cleanup: discarding incompletely merged value for",
1940 yystos[yys->yylrState],
1941 &yysval]b4_locations_if([, yylocp])[]b4_user_args[);
1942 break;
1943 }
1944 yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other);
1945 }
1946 }
1947 }
1948 else
1949 yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[);
1950
1951 if (yyflag == yyok)
1952 {
1953 yys->yyresolved = yytrue;
1954 yys->yysemantics.yysval = yysval;
1955 }
1956 else
1957 yys->yysemantics.yyfirstVal = NULL;
1958 return yyflag;
1959 }
1960
1961 static YYRESULTTAG
1962 yyresolveStack (yyGLRStack* yystackp]b4_user_formals[)
1963 {
1964 if (yystackp->yysplitPoint != NULL)
1965 {
1966 yyGLRState* yys;
1967 int yyn;
1968
1969 for (yyn = 0, yys = yystackp->yytops.yystates[0];
1970 yys != yystackp->yysplitPoint;
1971 yys = yys->yypred, yyn += 1)
1972 continue;
1973 YYCHK (yyresolveStates (yystackp->yytops.yystates[0], yyn, yystackp
1974 ]b4_user_args[));
1975 }
1976 return yyok;
1977 }
1978
1979 static void
1980 yycompressStack (yyGLRStack* yystackp)
1981 {
1982 yyGLRState* yyp, *yyq, *yyr;
1983
1984 if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == NULL)
1985 return;
1986
1987 for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = NULL;
1988 yyp != yystackp->yysplitPoint;
1989 yyr = yyp, yyp = yyq, yyq = yyp->yypred)
1990 yyp->yypred = yyr;
1991
1992 yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems;
1993 yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1;
1994 yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems;
1995 yystackp->yysplitPoint = NULL;
1996 yystackp->yylastDeleted = NULL;
1997
1998 while (yyr != NULL)
1999 {
2000 yystackp->yynextFree->yystate = *yyr;
2001 yyr = yyr->yypred;
2002 yystackp->yynextFree->yystate.yypred = &yystackp->yynextFree[-1].yystate;
2003 yystackp->yytops.yystates[0] = &yystackp->yynextFree->yystate;
2004 yystackp->yynextFree += 1;
2005 yystackp->yyspaceLeft -= 1;
2006 }
2007 }
2008
2009 static YYRESULTTAG
2010 yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
2011 size_t yyposn]b4_pure_formals[)
2012 {
2013 int yyaction;
2014 const short int* yyconflicts;
2015 yyRuleNum yyrule;
2016
2017 while (yystackp->yytops.yystates[yyk] != NULL)
2018 {
2019 yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState;
2020 YYDPRINTF ((stderr, "Stack %lu Entering state %d\n",
2021 (unsigned long int) yyk, yystate));
2022
2023 YYASSERT (yystate != YYFINAL);
2024
2025 if (yyisDefaultedState (yystate))
2026 {
2027 yyrule = yydefaultAction (yystate);
2028 if (yyrule == 0)
2029 {
2030 YYDPRINTF ((stderr, "Stack %lu dies.\n",
2031 (unsigned long int) yyk));
2032 yymarkStackDeleted (yystackp, yyk);
2033 return yyok;
2034 }
2035 YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse]b4_user_args[));
2036 }
2037 else
2038 {
2039 yySymbol yytoken;
2040 yystackp->yytops.yylookaheadNeeds[yyk] = yytrue;
2041 if (yychar == YYEMPTY)
2042 {
2043 YYDPRINTF ((stderr, "Reading a token: "));
2044 yychar = YYLEX;
2045 yytoken = YYTRANSLATE (yychar);
2046 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2047 }
2048 else
2049 yytoken = YYTRANSLATE (yychar);
2050 yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
2051
2052 while (*yyconflicts != 0)
2053 {
2054 size_t yynewStack = yysplitStack (yystackp, yyk);
2055 YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n",
2056 (unsigned long int) yynewStack,
2057 (unsigned long int) yyk));
2058 YYCHK (yyglrReduce (yystackp, yynewStack,
2059 *yyconflicts, yyfalse]b4_user_args[));
2060 YYCHK (yyprocessOneStack (yystackp, yynewStack,
2061 yyposn]b4_pure_args[));
2062 yyconflicts += 1;
2063 }
2064
2065 if (yyisShiftAction (yyaction))
2066 break;
2067 else if (yyisErrorAction (yyaction))
2068 {
2069 YYDPRINTF ((stderr, "Stack %lu dies.\n",
2070 (unsigned long int) yyk));
2071 yymarkStackDeleted (yystackp, yyk);
2072 break;
2073 }
2074 else
2075 YYCHK (yyglrReduce (yystackp, yyk, -yyaction,
2076 yyfalse]b4_user_args[));
2077 }
2078 }
2079 return yyok;
2080 }
2081
2082 /*ARGSUSED*/ static void
2083 yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
2084 {
2085 if (yystackp->yyerrState == 0)
2086 {
2087 #if YYERROR_VERBOSE
2088 int yyn;
2089 yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
2090 if (YYPACT_NINF < yyn && yyn <= YYLAST)
2091 {
2092 yySymbol yytoken = YYTRANSLATE (yychar);
2093 size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
2094 size_t yysize = yysize0;
2095 size_t yysize1;
2096 yybool yysize_overflow = yyfalse;
2097 char* yymsg = NULL;
2098 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2099 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2100 int yyx;
2101 char *yyfmt;
2102 char const *yyf;
2103 static char const yyunexpected[] = "syntax error, unexpected %s";
2104 static char const yyexpecting[] = ", expecting %s";
2105 static char const yyor[] = " or %s";
2106 char yyformat[sizeof yyunexpected
2107 + sizeof yyexpecting - 1
2108 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
2109 * (sizeof yyor - 1))];
2110 char const *yyprefix = yyexpecting;
2111
2112 /* Start YYX at -YYN if negative to avoid negative indexes in
2113 YYCHECK. */
2114 int yyxbegin = yyn < 0 ? -yyn : 0;
2115
2116 /* Stay within bounds of both yycheck and yytname. */
2117 int yychecklim = YYLAST - yyn + 1;
2118 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2119 int yycount = 1;
2120
2121 yyarg[0] = yytokenName (yytoken);
2122 yyfmt = yystpcpy (yyformat, yyunexpected);
2123
2124 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2125 if ((]b4_safest_int_type[)yycheck[yyx + yyn] == yyx
2126 && yyx != YYTERROR)
2127 {
2128 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2129 {
2130 yycount = 1;
2131 yysize = yysize0;
2132 yyformat[sizeof yyunexpected - 1] = '\0';
2133 break;
2134 }
2135 yyarg[yycount++] = yytokenName (yyx);
2136 yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx));
2137 yysize_overflow |= yysize1 < yysize;
2138 yysize = yysize1;
2139 yyfmt = yystpcpy (yyfmt, yyprefix);
2140 yyprefix = yyor;
2141 }
2142
2143 yyf = YY_(yyformat);
2144 yysize1 = yysize + strlen (yyf);
2145 yysize_overflow |= yysize1 < yysize;
2146 yysize = yysize1;
2147
2148 if (!yysize_overflow)
2149 yymsg = (char *) YYMALLOC (yysize);
2150
2151 if (yymsg)
2152 {
2153 char *yyp = yymsg;
2154 int yyi = 0;
2155 while ((*yyp = *yyf))
2156 {
2157 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
2158 {
2159 yyp += yytnamerr (yyp, yyarg[yyi++]);
2160 yyf += 2;
2161 }
2162 else
2163 {
2164 yyp++;
2165 yyf++;
2166 }
2167 }
2168 yyerror (]b4_lyyerror_args[yymsg);
2169 YYFREE (yymsg);
2170 }
2171 else
2172 {
2173 yyerror (]b4_lyyerror_args[YY_("syntax error"));
2174 yyMemoryExhausted (yystackp);
2175 }
2176 }
2177 else
2178 #endif /* YYERROR_VERBOSE */
2179 yyerror (]b4_lyyerror_args[YY_("syntax error"));
2180 yynerrs += 1;
2181 }
2182 }
2183
2184 /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
2185 yylval, and yylloc are the syntactic category, semantic value, and location
2186 of the lookahead. */
2187 /*ARGSUSED*/ static void
2188 yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
2189 {
2190 size_t yyk;
2191 int yyj;
2192
2193 if (yystackp->yyerrState == 3)
2194 /* We just shifted the error token and (perhaps) took some
2195 reductions. Skip tokens until we can proceed. */
2196 while (YYID (yytrue))
2197 {
2198 yySymbol yytoken;
2199 if (yychar == YYEOF)
2200 yyFail (yystackp][]b4_lpure_args[, NULL);
2201 if (yychar != YYEMPTY)
2202 {]b4_locations_if([[
2203 /* We throw away the lookahead, but the error range
2204 of the shifted error token must take it into account. */
2205 yyGLRState *yys = yystackp->yytops.yystates[0];
2206 yyGLRStackItem yyerror_range[3];
2207 yyerror_range[1].yystate.yyloc = yys->yyloc;
2208 yyerror_range[2].yystate.yyloc = yylloc;
2209 YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[
2210 yytoken = YYTRANSLATE (yychar);
2211 yydestruct ("Error: discarding",
2212 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
2213 }
2214 YYDPRINTF ((stderr, "Reading a token: "));
2215 yychar = YYLEX;
2216 yytoken = YYTRANSLATE (yychar);
2217 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2218 yyj = yypact[yystackp->yytops.yystates[0]->yylrState];
2219 if (yyis_pact_ninf (yyj))
2220 return;
2221 yyj += yytoken;
2222 if (yyj < 0 || YYLAST < yyj
2223 || (]b4_safest_int_type[)yycheck[yyj] != yytoken)
2224 {
2225 if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0)
2226 return;
2227 }
2228 else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj]))
2229 return;
2230 }
2231
2232 /* Reduce to one stack. */
2233 for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1)
2234 if (yystackp->yytops.yystates[yyk] != NULL)
2235 break;
2236 if (yyk >= yystackp->yytops.yysize)
2237 yyFail (yystackp][]b4_lpure_args[, NULL);
2238 for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1)
2239 yymarkStackDeleted (yystackp, yyk);
2240 yyremoveDeletes (yystackp);
2241 yycompressStack (yystackp);
2242
2243 /* Now pop stack until we find a state that shifts the error token. */
2244 yystackp->yyerrState = 3;
2245 while (yystackp->yytops.yystates[0] != NULL)
2246 {
2247 yyGLRState *yys = yystackp->yytops.yystates[0];
2248 yyj = yypact[yys->yylrState];
2249 if (! yyis_pact_ninf (yyj))
2250 {
2251 yyj += YYTERROR;
2252 if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
2253 && yyisShiftAction (yytable[yyj]))
2254 {
2255 /* Shift the error token having adjusted its location. */
2256 YYLTYPE yyerrloc;]b4_locations_if([[
2257 yystackp->yyerror_range[2].yystate.yyloc = yylloc;
2258 YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[
2259 YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
2260 &yylval, &yyerrloc);
2261 yyglrShift (yystackp, 0, yytable[yyj],
2262 yys->yyposn, &yylval, &yyerrloc);
2263 yys = yystackp->yytops.yystates[0];
2264 break;
2265 }
2266 }
2267 ]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
2268 if (yys->yypred != NULL)
2269 yydestroyGLRState ("Error: popping", yys]b4_user_args[);
2270 yystackp->yytops.yystates[0] = yys->yypred;
2271 yystackp->yynextFree -= 1;
2272 yystackp->yyspaceLeft += 1;
2273 }
2274 if (yystackp->yytops.yystates[0] == NULL)
2275 yyFail (yystackp][]b4_lpure_args[, NULL);
2276 }
2277
2278 #define YYCHK1(YYE) \
2279 do { \
2280 switch (YYE) { \
2281 case yyok: \
2282 break; \
2283 case yyabort: \
2284 goto yyabortlab; \
2285 case yyaccept: \
2286 goto yyacceptlab; \
2287 case yyerr: \
2288 goto yyuser_error; \
2289 default: \
2290 goto yybuglab; \
2291 } \
2292 } while (YYID (0))
2293
2294
2295 /*----------.
2296 | yyparse. |
2297 `----------*/
2298
2299 ]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[
2300 {
2301 int yyresult;
2302 yyGLRStack yystack;
2303 yyGLRStack* const yystackp = &yystack;
2304 size_t yyposn;
2305
2306 YYDPRINTF ((stderr, "Starting parse\n"));
2307
2308 yychar = YYEMPTY;
2309 yylval = yyval_default;
2310 ]b4_locations_if([
2311 #if YYLTYPE_IS_TRIVIAL
2312 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
2313 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
2314 #endif
2315 ])
2316 m4_ifdef([b4_initial_action], [
2317 m4_pushdef([b4_at_dollar], [yylloc])dnl
2318 m4_pushdef([b4_dollar_dollar], [yylval])dnl
2319 /* User initialization code. */
2320 b4_user_initial_action
2321 m4_popdef([b4_dollar_dollar])dnl
2322 m4_popdef([b4_at_dollar])])dnl
2323 [
2324 if (! yyinitGLRStack (yystackp, YYINITDEPTH))
2325 goto yyexhaustedlab;
2326 switch (YYSETJMP (yystack.yyexception_buffer))
2327 {
2328 case 0: break;
2329 case 1: goto yyabortlab;
2330 case 2: goto yyexhaustedlab;
2331 default: goto yybuglab;
2332 }
2333 yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc);
2334 yyposn = 0;
2335
2336 while (YYID (yytrue))
2337 {
2338 /* For efficiency, we have two loops, the first of which is
2339 specialized to deterministic operation (single stack, no
2340 potential ambiguity). */
2341 /* Standard mode */
2342 while (YYID (yytrue))
2343 {
2344 yyRuleNum yyrule;
2345 int yyaction;
2346 const short int* yyconflicts;
2347
2348 yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;
2349 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2350 if (yystate == YYFINAL)
2351 goto yyacceptlab;
2352 if (yyisDefaultedState (yystate))
2353 {
2354 yyrule = yydefaultAction (yystate);
2355 if (yyrule == 0)
2356 {
2357 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2358 yyreportSyntaxError (&yystack]b4_user_args[);
2359 goto yyuser_error;
2360 }
2361 YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[));
2362 }
2363 else
2364 {
2365 yySymbol yytoken;
2366 if (yychar == YYEMPTY)
2367 {
2368 YYDPRINTF ((stderr, "Reading a token: "));
2369 yychar = YYLEX;
2370 yytoken = YYTRANSLATE (yychar);
2371 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2372 }
2373 else
2374 yytoken = YYTRANSLATE (yychar);
2375 yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
2376 if (*yyconflicts != 0)
2377 break;
2378 if (yyisShiftAction (yyaction))
2379 {
2380 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2381 yychar = YYEMPTY;
2382 yyposn += 1;
2383 yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc);
2384 if (0 < yystack.yyerrState)
2385 yystack.yyerrState -= 1;
2386 }
2387 else if (yyisErrorAction (yyaction))
2388 {
2389 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2390 yyreportSyntaxError (&yystack]b4_user_args[);
2391 goto yyuser_error;
2392 }
2393 else
2394 YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[));
2395 }
2396 }
2397
2398 while (YYID (yytrue))
2399 {
2400 yySymbol yytoken_to_shift;
2401 size_t yys;
2402
2403 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2404 yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY;
2405
2406 /* yyprocessOneStack returns one of three things:
2407
2408 - An error flag. If the caller is yyprocessOneStack, it
2409 immediately returns as well. When the caller is finally
2410 yyparse, it jumps to an error label via YYCHK1.
2411
2412 - yyok, but yyprocessOneStack has invoked yymarkStackDeleted
2413 (&yystack, yys), which sets the top state of yys to NULL. Thus,
2414 yyparse's following invocation of yyremoveDeletes will remove
2415 the stack.
2416
2417 - yyok, when ready to shift a token.
2418
2419 Except in the first case, yyparse will invoke yyremoveDeletes and
2420 then shift the next token onto all remaining stacks. This
2421 synchronization of the shift (that is, after all preceding
2422 reductions on all stacks) helps prevent double destructor calls
2423 on yylval in the event of memory exhaustion. */
2424
2425 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2426 YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[));
2427 yyremoveDeletes (&yystack);
2428 if (yystack.yytops.yysize == 0)
2429 {
2430 yyundeleteLastStack (&yystack);
2431 if (yystack.yytops.yysize == 0)
2432 yyFail (&yystack][]b4_lpure_args[, YY_("syntax error"));
2433 YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
2434 YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
2435 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2436 yyreportSyntaxError (&yystack]b4_user_args[);
2437 goto yyuser_error;
2438 }
2439
2440 /* If any yyglrShift call fails, it will fail after shifting. Thus,
2441 a copy of yylval will already be on stack 0 in the event of a
2442 failure in the following loop. Thus, yychar is set to YYEMPTY
2443 before the loop to make sure the user destructor for yylval isn't
2444 called twice. */
2445 yytoken_to_shift = YYTRANSLATE (yychar);
2446 yychar = YYEMPTY;
2447 yyposn += 1;
2448 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2449 {
2450 int yyaction;
2451 const short int* yyconflicts;
2452 yyStateNum yystate = yystack.yytops.yystates[yys]->yylrState;
2453 yygetLRActions (yystate, yytoken_to_shift, &yyaction,
2454 &yyconflicts);
2455 /* Note that yyconflicts were handled by yyprocessOneStack. */
2456 YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys));
2457 YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc);
2458 yyglrShift (&yystack, yys, yyaction, yyposn,
2459 &yylval, &yylloc);
2460 YYDPRINTF ((stderr, "Stack %lu now in state #%d\n",
2461 (unsigned long int) yys,
2462 yystack.yytops.yystates[yys]->yylrState));
2463 }
2464
2465 if (yystack.yytops.yysize == 1)
2466 {
2467 YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
2468 YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
2469 yycompressStack (&yystack);
2470 break;
2471 }
2472 }
2473 continue;
2474 yyuser_error:
2475 yyrecoverSyntaxError (&yystack]b4_user_args[);
2476 yyposn = yystack.yytops.yystates[0]->yyposn;
2477 }
2478
2479 yyacceptlab:
2480 yyresult = 0;
2481 goto yyreturn;
2482
2483 yybuglab:
2484 YYASSERT (yyfalse);
2485 goto yyabortlab;
2486
2487 yyabortlab:
2488 yyresult = 1;
2489 goto yyreturn;
2490
2491 yyexhaustedlab:
2492 yyerror (]b4_lyyerror_args[YY_("memory exhausted"));
2493 yyresult = 2;
2494 goto yyreturn;
2495
2496 yyreturn:
2497 if (yychar != YYEMPTY)
2498 yydestruct ("Cleanup: discarding lookahead",
2499 YYTRANSLATE (yychar),
2500 &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
2501
2502 /* If the stack is well-formed, pop the stack until it is empty,
2503 destroying its entries as we go. But free the stack regardless
2504 of whether it is well-formed. */
2505 if (yystack.yyitems)
2506 {
2507 yyGLRState** yystates = yystack.yytops.yystates;
2508 if (yystates)
2509 {
2510 size_t yysize = yystack.yytops.yysize;
2511 size_t yyk;
2512 for (yyk = 0; yyk < yysize; yyk += 1)
2513 if (yystates[yyk])
2514 {
2515 while (yystates[yyk])
2516 {
2517 yyGLRState *yys = yystates[yyk];
2518 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]]
2519 )[ if (yys->yypred != NULL)
2520 yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
2521 yystates[yyk] = yys->yypred;
2522 yystack.yynextFree -= 1;
2523 yystack.yyspaceLeft += 1;
2524 }
2525 break;
2526 }
2527 }
2528 yyfreeGLRStack (&yystack);
2529 }
2530
2531 /* Make sure YYID is used. */
2532 return YYID (yyresult);
2533 }
2534
2535 /* DEBUGGING ONLY */
2536 #ifdef YYDEBUG
2537 static void yypstack (yyGLRStack* yystackp, size_t yyk)
2538 __attribute__ ((__unused__));
2539 static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__));
2540
2541 static void
2542 yy_yypstack (yyGLRState* yys)
2543 {
2544 if (yys->yypred)
2545 {
2546 yy_yypstack (yys->yypred);
2547 fprintf (stderr, " -> ");
2548 }
2549 fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long int) yys->yyposn);
2550 }
2551
2552 static void
2553 yypstates (yyGLRState* yyst)
2554 {
2555 if (yyst == NULL)
2556 fprintf (stderr, "<null>");
2557 else
2558 yy_yypstack (yyst);
2559 fprintf (stderr, "\n");
2560 }
2561
2562 static void
2563 yypstack (yyGLRStack* yystackp, size_t yyk)
2564 {
2565 yypstates (yystackp->yytops.yystates[yyk]);
2566 }
2567
2568 #define YYINDEX(YYX) \
2569 ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems)
2570
2571
2572 static void
2573 yypdumpstack (yyGLRStack* yystackp)
2574 {
2575 yyGLRStackItem* yyp;
2576 size_t yyi;
2577 for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1)
2578 {
2579 fprintf (stderr, "%3lu. ", (unsigned long int) (yyp - yystackp->yyitems));
2580 if (*(yybool *) yyp)
2581 {
2582 fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
2583 yyp->yystate.yyresolved, yyp->yystate.yylrState,
2584 (unsigned long int) yyp->yystate.yyposn,
2585 (long int) YYINDEX (yyp->yystate.yypred));
2586 if (! yyp->yystate.yyresolved)
2587 fprintf (stderr, ", firstVal: %ld",
2588 (long int) YYINDEX (yyp->yystate.yysemantics.yyfirstVal));
2589 }
2590 else
2591 {
2592 fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld",
2593 yyp->yyoption.yyrule - 1,
2594 (long int) YYINDEX (yyp->yyoption.yystate),
2595 (long int) YYINDEX (yyp->yyoption.yynext));
2596 }
2597 fprintf (stderr, "\n");
2598 }
2599 fprintf (stderr, "Tops:");
2600 for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
2601 fprintf (stderr, "%lu: %ld; ", (unsigned long int) yyi,
2602 (long int) YYINDEX (yystackp->yytops.yystates[yyi]));
2603 fprintf (stderr, "\n");
2604 }
2605 #endif
2606 ]
2607
2608 b4_epilogue
2609 b4_defines_if(
2610 [@output @output_header_name@
2611 b4_copyright([Skeleton interface for Bison GLR parsers in C],
2612 [2002, 2003, 2004, 2005, 2006])
2613
2614 b4_shared_declarations
2615
2616 extern YYSTYPE b4_prefix[]lval;
2617
2618 b4_locations_if([b4_pure_if([],
2619 [extern YYLTYPE b4_prefix[]lloc;])
2620 ])
2621 ])
bison