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


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