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


836df5032c72d646cea95dd866ca80b558d37aa5
[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 || yycheck[yyindex] != yytoken)
1052 {
1053 *yyaction = -yydefact[yystate];
1054 *yyconflicts = yyconfl;
1055 }
1056 else if (! yyis_table_ninf (yytable[yyindex]))
1057 {
1058 *yyaction = yytable[yyindex];
1059 *yyconflicts = yyconfl + yyconflp[yyindex];
1060 }
1061 else
1062 {
1063 *yyaction = 0;
1064 *yyconflicts = yyconfl + yyconflp[yyindex];
1065 }
1066 }
1067
1068 static inline yyStateNum
1069 yyLRgotoState (yyStateNum yystate, yySymbol yylhs)
1070 {
1071 int yyr;
1072 yyr = yypgoto[yylhs - YYNTOKENS] + yystate;
1073 if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate)
1074 return yytable[yyr];
1075 else
1076 return yydefgoto[yylhs - YYNTOKENS];
1077 }
1078
1079 static inline yybool
1080 yyisShiftAction (int yyaction)
1081 {
1082 return 0 < yyaction;
1083 }
1084
1085 static inline yybool
1086 yyisErrorAction (int yyaction)
1087 {
1088 return yyaction == 0;
1089 }
1090
1091 /* GLRStates */
1092
1093 /** Return a fresh GLRStackItem. Callers should call
1094 * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient
1095 * headroom. */
1096
1097 static inline yyGLRStackItem*
1098 yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState)
1099 {
1100 yyGLRStackItem* yynewItem = yystackp->yynextFree;
1101 yystackp->yyspaceLeft -= 1;
1102 yystackp->yynextFree += 1;
1103 yynewItem->yystate.yyisState = yyisState;
1104 return yynewItem;
1105 }
1106
1107 /** Add a new semantic action that will execute the action for rule
1108 * RULENUM on the semantic values in RHS to the list of
1109 * alternative actions for STATE. Assumes that RHS comes from
1110 * stack #K of *STACKP. */
1111 static void
1112 yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,
1113 yyGLRState* rhs, yyRuleNum yyrule)
1114 {
1115 yySemanticOption* yynewOption =
1116 &yynewGLRStackItem (yystackp, yyfalse)->yyoption;
1117 yynewOption->yystate = rhs;
1118 yynewOption->yyrule = yyrule;
1119 if (yystackp->yytops.yylookaheadNeeds[yyk])
1120 {
1121 yynewOption->yyrawchar = yychar;
1122 yynewOption->yyval = yylval;
1123 yynewOption->yyloc = yylloc;
1124 }
1125 else
1126 yynewOption->yyrawchar = YYEMPTY;
1127 yynewOption->yynext = yystate->yysemantics.yyfirstVal;
1128 yystate->yysemantics.yyfirstVal = yynewOption;
1129
1130 YY_RESERVE_GLRSTACK (yystackp);
1131 }
1132
1133 /* GLRStacks */
1134
1135 /** Initialize SET to a singleton set containing an empty stack. */
1136 static yybool
1137 yyinitStateSet (yyGLRStateSet* yyset)
1138 {
1139 yyset->yysize = 1;
1140 yyset->yycapacity = 16;
1141 yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]);
1142 if (! yyset->yystates)
1143 return yyfalse;
1144 yyset->yystates[0] = NULL;
1145 yyset->yylookaheadNeeds =
1146 (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]);
1147 if (! yyset->yylookaheadNeeds)
1148 {
1149 YYFREE (yyset->yystates);
1150 return yyfalse;
1151 }
1152 return yytrue;
1153 }
1154
1155 static void yyfreeStateSet (yyGLRStateSet* yyset)
1156 {
1157 YYFREE (yyset->yystates);
1158 YYFREE (yyset->yylookaheadNeeds);
1159 }
1160
1161 /** Initialize STACK to a single empty stack, with total maximum
1162 * capacity for all stacks of SIZE. */
1163 static yybool
1164 yyinitGLRStack (yyGLRStack* yystackp, size_t yysize)
1165 {
1166 yystackp->yyerrState = 0;
1167 yynerrs = 0;
1168 yystackp->yyspaceLeft = yysize;
1169 yystackp->yyitems =
1170 (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystackp->yynextFree[0]);
1171 if (!yystackp->yyitems)
1172 return yyfalse;
1173 yystackp->yynextFree = yystackp->yyitems;
1174 yystackp->yysplitPoint = NULL;
1175 yystackp->yylastDeleted = NULL;
1176 return yyinitStateSet (&yystackp->yytops);
1177 }
1178
1179
1180 #if YYSTACKEXPANDABLE
1181 # define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \
1182 &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE
1183
1184 /** If STACK is expandable, extend it. WARNING: Pointers into the
1185 stack from outside should be considered invalid after this call.
1186 We always expand when there are 1 or fewer items left AFTER an
1187 allocation, so that we can avoid having external pointers exist
1188 across an allocation. */
1189 static void
1190 yyexpandGLRStack (yyGLRStack* yystackp)
1191 {
1192 yyGLRStackItem* yynewItems;
1193 yyGLRStackItem* yyp0, *yyp1;
1194 size_t yysize, yynewSize;
1195 size_t yyn;
1196 yysize = yystackp->yynextFree - yystackp->yyitems;
1197 if (YYMAXDEPTH - YYHEADROOM < yysize)
1198 yyMemoryExhausted (yystackp);
1199 yynewSize = 2*yysize;
1200 if (YYMAXDEPTH < yynewSize)
1201 yynewSize = YYMAXDEPTH;
1202 yynewItems = (yyGLRStackItem*) YYMALLOC (yynewSize * sizeof yynewItems[0]);
1203 if (! yynewItems)
1204 yyMemoryExhausted (yystackp);
1205 for (yyp0 = yystackp->yyitems, yyp1 = yynewItems, yyn = yysize;
1206 0 < yyn;
1207 yyn -= 1, yyp0 += 1, yyp1 += 1)
1208 {
1209 *yyp1 = *yyp0;
1210 if (*(yybool *) yyp0)
1211 {
1212 yyGLRState* yys0 = &yyp0->yystate;
1213 yyGLRState* yys1 = &yyp1->yystate;
1214 if (yys0->yypred != NULL)
1215 yys1->yypred =
1216 YYRELOC (yyp0, yyp1, yys0->yypred, yystate);
1217 if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != NULL)
1218 yys1->yysemantics.yyfirstVal =
1219 YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption);
1220 }
1221 else
1222 {
1223 yySemanticOption* yyv0 = &yyp0->yyoption;
1224 yySemanticOption* yyv1 = &yyp1->yyoption;
1225 if (yyv0->yystate != NULL)
1226 yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate);
1227 if (yyv0->yynext != NULL)
1228 yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption);
1229 }
1230 }
1231 if (yystackp->yysplitPoint != NULL)
1232 yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems,
1233 yystackp->yysplitPoint, yystate);
1234
1235 for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1)
1236 if (yystackp->yytops.yystates[yyn] != NULL)
1237 yystackp->yytops.yystates[yyn] =
1238 YYRELOC (yystackp->yyitems, yynewItems,
1239 yystackp->yytops.yystates[yyn], yystate);
1240 YYFREE (yystackp->yyitems);
1241 yystackp->yyitems = yynewItems;
1242 yystackp->yynextFree = yynewItems + yysize;
1243 yystackp->yyspaceLeft = yynewSize - yysize;
1244 }
1245 #endif
1246
1247 static void
1248 yyfreeGLRStack (yyGLRStack* yystackp)
1249 {
1250 YYFREE (yystackp->yyitems);
1251 yyfreeStateSet (&yystackp->yytops);
1252 }
1253
1254 /** Assuming that S is a GLRState somewhere on STACK, update the
1255 * splitpoint of STACK, if needed, so that it is at least as deep as
1256 * S. */
1257 static inline void
1258 yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys)
1259 {
1260 if (yystackp->yysplitPoint != NULL && yystackp->yysplitPoint > yys)
1261 yystackp->yysplitPoint = yys;
1262 }
1263
1264 /** Invalidate stack #K in STACK. */
1265 static inline void
1266 yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk)
1267 {
1268 if (yystackp->yytops.yystates[yyk] != NULL)
1269 yystackp->yylastDeleted = yystackp->yytops.yystates[yyk];
1270 yystackp->yytops.yystates[yyk] = NULL;
1271 }
1272
1273 /** Undelete the last stack that was marked as deleted. Can only be
1274 done once after a deletion, and only when all other stacks have
1275 been deleted. */
1276 static void
1277 yyundeleteLastStack (yyGLRStack* yystackp)
1278 {
1279 if (yystackp->yylastDeleted == NULL || yystackp->yytops.yysize != 0)
1280 return;
1281 yystackp->yytops.yystates[0] = yystackp->yylastDeleted;
1282 yystackp->yytops.yysize = 1;
1283 YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n"));
1284 yystackp->yylastDeleted = NULL;
1285 }
1286
1287 static inline void
1288 yyremoveDeletes (yyGLRStack* yystackp)
1289 {
1290 size_t yyi, yyj;
1291 yyi = yyj = 0;
1292 while (yyj < yystackp->yytops.yysize)
1293 {
1294 if (yystackp->yytops.yystates[yyi] == NULL)
1295 {
1296 if (yyi == yyj)
1297 {
1298 YYDPRINTF ((stderr, "Removing dead stacks.\n"));
1299 }
1300 yystackp->yytops.yysize -= 1;
1301 }
1302 else
1303 {
1304 yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi];
1305 /* In the current implementation, it's unnecessary to copy
1306 yystackp->yytops.yylookaheadNeeds[yyi] since, after
1307 yyremoveDeletes returns, the parser immediately either enters
1308 deterministic operation or shifts a token. However, it doesn't
1309 hurt, and the code might evolve to need it. */
1310 yystackp->yytops.yylookaheadNeeds[yyj] =
1311 yystackp->yytops.yylookaheadNeeds[yyi];
1312 if (yyj != yyi)
1313 {
1314 YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n",
1315 (unsigned long int) yyi, (unsigned long int) yyj));
1316 }
1317 yyj += 1;
1318 }
1319 yyi += 1;
1320 }
1321 }
1322
1323 /** Shift to a new state on stack #K of STACK, corresponding to LR state
1324 * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */
1325 static inline void
1326 yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
1327 size_t yyposn,
1328 YYSTYPE* yyvalp, YYLTYPE* yylocp)
1329 {
1330 yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
1331
1332 yynewState->yylrState = yylrState;
1333 yynewState->yyposn = yyposn;
1334 yynewState->yyresolved = yytrue;
1335 yynewState->yypred = yystackp->yytops.yystates[yyk];
1336 yynewState->yysemantics.yysval = *yyvalp;
1337 yynewState->yyloc = *yylocp;
1338 yystackp->yytops.yystates[yyk] = yynewState;
1339
1340 YY_RESERVE_GLRSTACK (yystackp);
1341 }
1342
1343 /** Shift stack #K of YYSTACK, to a new state corresponding to LR
1344 * state YYLRSTATE, at input position YYPOSN, with the (unresolved)
1345 * semantic value of YYRHS under the action for YYRULE. */
1346 static inline void
1347 yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
1348 size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule)
1349 {
1350 yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
1351
1352 yynewState->yylrState = yylrState;
1353 yynewState->yyposn = yyposn;
1354 yynewState->yyresolved = yyfalse;
1355 yynewState->yypred = yystackp->yytops.yystates[yyk];
1356 yynewState->yysemantics.yyfirstVal = NULL;
1357 yystackp->yytops.yystates[yyk] = yynewState;
1358
1359 /* Invokes YY_RESERVE_GLRSTACK. */
1360 yyaddDeferredAction (yystackp, yyk, yynewState, rhs, yyrule);
1361 }
1362
1363 /** Pop the symbols consumed by reduction #RULE from the top of stack
1364 * #K of STACK, and perform the appropriate semantic action on their
1365 * semantic values. Assumes that all ambiguities in semantic values
1366 * have been previously resolved. Set *VALP to the resulting value,
1367 * and *LOCP to the computed location (if any). Return value is as
1368 * for userAction. */
1369 static inline YYRESULTTAG
1370 yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
1371 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
1372 {
1373 int yynrhs = yyrhsLength (yyrule);
1374
1375 if (yystackp->yysplitPoint == NULL)
1376 {
1377 /* Standard special case: single stack. */
1378 yyGLRStackItem* rhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
1379 YYASSERT (yyk == 0);
1380 yystackp->yynextFree -= yynrhs;
1381 yystackp->yyspaceLeft += yynrhs;
1382 yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate;
1383 return yyuserAction (yyrule, yynrhs, rhs,
1384 yyvalp, yylocp, yystackp]b4_user_args[);
1385 }
1386 else
1387 {
1388 /* At present, doAction is never called in nondeterministic
1389 * mode, so this branch is never taken. It is here in
1390 * anticipation of a future feature that will allow immediate
1391 * evaluation of selected actions in nondeterministic mode. */
1392 int yyi;
1393 yyGLRState* yys;
1394 yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
1395 yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred
1396 = yystackp->yytops.yystates[yyk];]b4_locations_if([[
1397 if (yynrhs == 0)
1398 /* Set default location. */
1399 yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[
1400 for (yyi = 0; yyi < yynrhs; yyi += 1)
1401 {
1402 yys = yys->yypred;
1403 YYASSERT (yys);
1404 }
1405 yyupdateSplit (yystackp, yys);
1406 yystackp->yytops.yystates[yyk] = yys;
1407 return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
1408 yyvalp, yylocp, yystackp]b4_user_args[);
1409 }
1410 }
1411
1412 #if !YYDEBUG
1413 # define YY_REDUCE_PRINT(Args)
1414 #else
1415 # define YY_REDUCE_PRINT(Args) \
1416 do { \
1417 if (yydebug) \
1418 yy_reduce_print Args; \
1419 } while (YYID (0))
1420
1421 /*----------------------------------------------------------.
1422 | Report that the RULE is going to be reduced on stack #K. |
1423 `----------------------------------------------------------*/
1424
1425 /*ARGSUSED*/ static inline void
1426 yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
1427 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
1428 {
1429 int yynrhs = yyrhsLength (yyrule);
1430 yybool yynormal __attribute__ ((__unused__)) =
1431 (yystackp->yysplitPoint == NULL);
1432 yyGLRStackItem* yyvsp = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
1433 int yylow = 1;
1434 int yyi;
1435 YYUSE (yyvalp);
1436 YYUSE (yylocp);
1437 ]b4_parse_param_use[]dnl
1438 [ YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n",
1439 (unsigned long int) yyk, yyrule - 1,
1440 (unsigned long int) yyrline[yyrule]);
1441 /* The symbols being reduced. */
1442 for (yyi = 0; yyi < yynrhs; yyi++)
1443 {
1444 fprintf (stderr, " $%d = ", yyi + 1);
1445 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1446 &]b4_rhs_value(yynrhs, yyi + 1)[
1447 ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
1448 b4_user_args[);
1449 fprintf (stderr, "\n");
1450 }
1451 }
1452 #endif
1453
1454 /** Pop items off stack #K of STACK according to grammar rule RULE,
1455 * and push back on the resulting nonterminal symbol. Perform the
1456 * semantic action associated with RULE and store its value with the
1457 * newly pushed state, if FORCEEVAL or if STACK is currently
1458 * unambiguous. Otherwise, store the deferred semantic action with
1459 * the new state. If the new state would have an identical input
1460 * position, LR state, and predecessor to an existing state on the stack,
1461 * it is identified with that existing state, eliminating stack #K from
1462 * the STACK. In this case, the (necessarily deferred) semantic value is
1463 * added to the options for the existing state's semantic value.
1464 */
1465 static inline YYRESULTTAG
1466 yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
1467 yybool yyforceEval]b4_user_formals[)
1468 {
1469 size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn;
1470
1471 if (yyforceEval || yystackp->yysplitPoint == NULL)
1472 {
1473 YYSTYPE yysval;
1474 YYLTYPE yyloc;
1475
1476 YY_REDUCE_PRINT ((yystackp, yyk, yyrule, &yysval, &yyloc]b4_user_args[));
1477 YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval,
1478 &yyloc]b4_user_args[));
1479 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc);
1480 yyglrShift (yystackp, yyk,
1481 yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState,
1482 yylhsNonterm (yyrule)),
1483 yyposn, &yysval, &yyloc);
1484 }
1485 else
1486 {
1487 size_t yyi;
1488 int yyn;
1489 yyGLRState* yys, *yys0 = yystackp->yytops.yystates[yyk];
1490 yyStateNum yynewLRState;
1491
1492 for (yys = yystackp->yytops.yystates[yyk], yyn = yyrhsLength (yyrule);
1493 0 < yyn; yyn -= 1)
1494 {
1495 yys = yys->yypred;
1496 YYASSERT (yys);
1497 }
1498 yyupdateSplit (yystackp, yys);
1499 yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
1500 YYDPRINTF ((stderr,
1501 "Reduced stack %lu by rule #%d; action deferred. Now in state %d.\n",
1502 (unsigned long int) yyk, yyrule - 1, yynewLRState));
1503 for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
1504 if (yyi != yyk && yystackp->yytops.yystates[yyi] != NULL)
1505 {
1506 yyGLRState* yyp, *yysplit = yystackp->yysplitPoint;
1507 yyp = yystackp->yytops.yystates[yyi];
1508 while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn)
1509 {
1510 if (yyp->yylrState == yynewLRState && yyp->yypred == yys)
1511 {
1512 yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule);
1513 yymarkStackDeleted (yystackp, yyk);
1514 YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n",
1515 (unsigned long int) yyk,
1516 (unsigned long int) yyi));
1517 return yyok;
1518 }
1519 yyp = yyp->yypred;
1520 }
1521 }
1522 yystackp->yytops.yystates[yyk] = yys;
1523 yyglrShiftDefer (yystackp, yyk, yynewLRState, yyposn, yys0, yyrule);
1524 }
1525 return yyok;
1526 }
1527
1528 static size_t
1529 yysplitStack (yyGLRStack* yystackp, size_t yyk)
1530 {
1531 if (yystackp->yysplitPoint == NULL)
1532 {
1533 YYASSERT (yyk == 0);
1534 yystackp->yysplitPoint = yystackp->yytops.yystates[yyk];
1535 }
1536 if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity)
1537 {
1538 yyGLRState** yynewStates;
1539 yybool* yynewLookaheadNeeds;
1540
1541 yynewStates = NULL;
1542
1543 if (yystackp->yytops.yycapacity
1544 > (YYSIZEMAX / (2 * sizeof yynewStates[0])))
1545 yyMemoryExhausted (yystackp);
1546 yystackp->yytops.yycapacity *= 2;
1547
1548 yynewStates =
1549 (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
1550 (yystackp->yytops.yycapacity
1551 * sizeof yynewStates[0]));
1552 if (yynewStates == NULL)
1553 yyMemoryExhausted (yystackp);
1554 yystackp->yytops.yystates = yynewStates;
1555
1556 yynewLookaheadNeeds =
1557 (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds,
1558 (yystackp->yytops.yycapacity
1559 * sizeof yynewLookaheadNeeds[0]));
1560 if (yynewLookaheadNeeds == NULL)
1561 yyMemoryExhausted (yystackp);
1562 yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds;
1563 }
1564 yystackp->yytops.yystates[yystackp->yytops.yysize]
1565 = yystackp->yytops.yystates[yyk];
1566 yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize]
1567 = yystackp->yytops.yylookaheadNeeds[yyk];
1568 yystackp->yytops.yysize += 1;
1569 return yystackp->yytops.yysize-1;
1570 }
1571
1572 /** True iff Y0 and Y1 represent identical options at the top level.
1573 * That is, they represent the same rule applied to RHS symbols
1574 * that produce the same terminal symbols. */
1575 static yybool
1576 yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1)
1577 {
1578 if (yyy0->yyrule == yyy1->yyrule)
1579 {
1580 yyGLRState *yys0, *yys1;
1581 int yyn;
1582 for (yys0 = yyy0->yystate, yys1 = yyy1->yystate,
1583 yyn = yyrhsLength (yyy0->yyrule);
1584 yyn > 0;
1585 yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1)
1586 if (yys0->yyposn != yys1->yyposn)
1587 return yyfalse;
1588 return yytrue;
1589 }
1590 else
1591 return yyfalse;
1592 }
1593
1594 /** Assuming identicalOptions (Y0,Y1), destructively merge the
1595 * alternative semantic values for the RHS-symbols of Y1 and Y0. */
1596 static void
1597 yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1)
1598 {
1599 yyGLRState *yys0, *yys1;
1600 int yyn;
1601 for (yys0 = yyy0->yystate, yys1 = yyy1->yystate,
1602 yyn = yyrhsLength (yyy0->yyrule);
1603 yyn > 0;
1604 yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1)
1605 {
1606 if (yys0 == yys1)
1607 break;
1608 else if (yys0->yyresolved)
1609 {
1610 yys1->yyresolved = yytrue;
1611 yys1->yysemantics.yysval = yys0->yysemantics.yysval;
1612 }
1613 else if (yys1->yyresolved)
1614 {
1615 yys0->yyresolved = yytrue;
1616 yys0->yysemantics.yysval = yys1->yysemantics.yysval;
1617 }
1618 else
1619 {
1620 yySemanticOption** yyz0p;
1621 yySemanticOption* yyz1;
1622 yyz0p = &yys0->yysemantics.yyfirstVal;
1623 yyz1 = yys1->yysemantics.yyfirstVal;
1624 while (YYID (yytrue))
1625 {
1626 if (yyz1 == *yyz0p || yyz1 == NULL)
1627 break;
1628 else if (*yyz0p == NULL)
1629 {
1630 *yyz0p = yyz1;
1631 break;
1632 }
1633 else if (*yyz0p < yyz1)
1634 {
1635 yySemanticOption* yyz = *yyz0p;
1636 *yyz0p = yyz1;
1637 yyz1 = yyz1->yynext;
1638 (*yyz0p)->yynext = yyz;
1639 }
1640 yyz0p = &(*yyz0p)->yynext;
1641 }
1642 yys1->yysemantics.yyfirstVal = yys0->yysemantics.yyfirstVal;
1643 }
1644 }
1645 }
1646
1647 /** Y0 and Y1 represent two possible actions to take in a given
1648 * parsing state; return 0 if no combination is possible,
1649 * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */
1650 static int
1651 yypreference (yySemanticOption* y0, yySemanticOption* y1)
1652 {
1653 yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule;
1654 int p0 = yydprec[r0], p1 = yydprec[r1];
1655
1656 if (p0 == p1)
1657 {
1658 if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1])
1659 return 0;
1660 else
1661 return 1;
1662 }
1663 if (p0 == 0 || p1 == 0)
1664 return 0;
1665 if (p0 < p1)
1666 return 3;
1667 if (p1 < p0)
1668 return 2;
1669 return 0;
1670 }
1671
1672 static YYRESULTTAG yyresolveValue (yyGLRState* yys,
1673 yyGLRStack* yystackp]b4_user_formals[);
1674
1675
1676 /** Resolve the previous N states starting at and including state S. If result
1677 * != yyok, some states may have been left unresolved possibly with empty
1678 * semantic option chains. Regardless of whether result = yyok, each state
1679 * has been left with consistent data so that yydestroyGLRState can be invoked
1680 * if necessary. */
1681 static YYRESULTTAG
1682 yyresolveStates (yyGLRState* yys, int yyn,
1683 yyGLRStack* yystackp]b4_user_formals[)
1684 {
1685 if (0 < yyn)
1686 {
1687 YYASSERT (yys->yypred);
1688 YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[));
1689 if (! yys->yyresolved)
1690 YYCHK (yyresolveValue (yys, yystackp]b4_user_args[));
1691 }
1692 return yyok;
1693 }
1694
1695 /** Resolve the states for the RHS of OPT, perform its user action, and return
1696 * the semantic value and location. Regardless of whether result = yyok, all
1697 * RHS states have been destroyed (assuming the user action destroys all RHS
1698 * semantic values if invoked). */
1699 static YYRESULTTAG
1700 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
1701 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
1702 {
1703 yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
1704 int yynrhs;
1705 int yychar_current;
1706 YYSTYPE yylval_current;
1707 YYLTYPE yylloc_current;
1708 YYRESULTTAG yyflag;
1709
1710 yynrhs = yyrhsLength (yyopt->yyrule);
1711 yyflag = yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[);
1712 if (yyflag != yyok)
1713 {
1714 yyGLRState *yys;
1715 for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1)
1716 yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
1717 return yyflag;
1718 }
1719
1720 yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_locations_if([[
1721 if (yynrhs == 0)
1722 /* Set default location. */
1723 yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[
1724 yychar_current = yychar;
1725 yylval_current = yylval;
1726 yylloc_current = yylloc;
1727 yychar = yyopt->yyrawchar;
1728 yylval = yyopt->yyval;
1729 yylloc = yyopt->yyloc;
1730 yyflag = yyuserAction (yyopt->yyrule, yynrhs,
1731 yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
1732 yyvalp, yylocp, yystackp]b4_user_args[);
1733 yychar = yychar_current;
1734 yylval = yylval_current;
1735 yylloc = yylloc_current;
1736 return yyflag;
1737 }
1738
1739 #if YYDEBUG
1740 static void
1741 yyreportTree (yySemanticOption* yyx, int yyindent)
1742 {
1743 int yynrhs = yyrhsLength (yyx->yyrule);
1744 int yyi;
1745 yyGLRState* yys;
1746 yyGLRState* yystates[1 + YYMAXRHS];
1747 yyGLRState yyleftmost_state;
1748
1749 for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred)
1750 yystates[yyi] = yys;
1751 if (yys == NULL)
1752 {
1753 yyleftmost_state.yyposn = 0;
1754 yystates[0] = &yyleftmost_state;
1755 }
1756 else
1757 yystates[0] = yys;
1758
1759 if (yyx->yystate->yyposn < yys->yyposn + 1)
1760 YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n",
1761 yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
1762 yyx->yyrule - 1);
1763 else
1764 YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n",
1765 yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
1766 yyx->yyrule - 1, (unsigned long int) (yys->yyposn + 1),
1767 (unsigned long int) yyx->yystate->yyposn);
1768 for (yyi = 1; yyi <= yynrhs; yyi += 1)
1769 {
1770 if (yystates[yyi]->yyresolved)
1771 {
1772 if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn)
1773 YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "",
1774 yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]));
1775 else
1776 YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "",
1777 yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]),
1778 (unsigned long int) (yystates[yyi - 1]->yyposn + 1),
1779 (unsigned long int) yystates[yyi]->yyposn);
1780 }
1781 else
1782 yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2);
1783 }
1784 }
1785 #endif
1786
1787 /*ARGSUSED*/ static YYRESULTTAG
1788 yyreportAmbiguity (yySemanticOption* yyx0,
1789 yySemanticOption* yyx1]b4_pure_formals[)
1790 {
1791 YYUSE (yyx0);
1792 YYUSE (yyx1);
1793
1794 #if YYDEBUG
1795 YYFPRINTF (stderr, "Ambiguity detected.\n");
1796 YYFPRINTF (stderr, "Option 1,\n");
1797 yyreportTree (yyx0, 2);
1798 YYFPRINTF (stderr, "\nOption 2,\n");
1799 yyreportTree (yyx1, 2);
1800 YYFPRINTF (stderr, "\n");
1801 #endif
1802
1803 yyerror (]b4_yyerror_args[YY_("syntax is ambiguous"));
1804 return yyabort;
1805 }
1806
1807 /** Starting at and including state S1, resolve the location for each of the
1808 * previous N1 states that is unresolved. The first semantic option of a state
1809 * is always chosen. */
1810 static void
1811 yyresolveLocations (yyGLRState* yys1, int yyn1,
1812 yyGLRStack *yystackp]b4_user_formals[)
1813 {
1814 if (0 < yyn1)
1815 {
1816 yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[);
1817 if (!yys1->yyresolved)
1818 {
1819 yySemanticOption *yyoption;
1820 yyGLRStackItem yyrhsloc[1 + YYMAXRHS];
1821 int yynrhs;
1822 int yychar_current;
1823 YYSTYPE yylval_current;
1824 YYLTYPE yylloc_current;
1825 yyoption = yys1->yysemantics.yyfirstVal;
1826 YYASSERT (yyoption != NULL);
1827 yynrhs = yyrhsLength (yyoption->yyrule);
1828 if (yynrhs > 0)
1829 {
1830 yyGLRState *yys;
1831 int yyn;
1832 yyresolveLocations (yyoption->yystate, yynrhs,
1833 yystackp]b4_user_args[);
1834 for (yys = yyoption->yystate, yyn = yynrhs;
1835 yyn > 0;
1836 yys = yys->yypred, yyn -= 1)
1837 yyrhsloc[yyn].yystate.yyloc = yys->yyloc;
1838 }
1839 else
1840 {
1841 /* Both yyresolveAction and yyresolveLocations traverse the GSS
1842 in reverse rightmost order. It is only necessary to invoke
1843 yyresolveLocations on a subforest for which yyresolveAction
1844 would have been invoked next had an ambiguity not been
1845 detected. Thus the location of the previous state (but not
1846 necessarily the previous state itself) is guaranteed to be
1847 resolved already. */
1848 yyGLRState *yyprevious = yyoption->yystate;
1849 yyrhsloc[0].yystate.yyloc = yyprevious->yyloc;
1850 }
1851 yychar_current = yychar;
1852 yylval_current = yylval;
1853 yylloc_current = yylloc;
1854 yychar = yyoption->yyrawchar;
1855 yylval = yyoption->yyval;
1856 yylloc = yyoption->yyloc;
1857 YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs);
1858 yychar = yychar_current;
1859 yylval = yylval_current;
1860 yylloc = yylloc_current;
1861 }
1862 }
1863 }
1864
1865 /** Resolve the ambiguity represented in state S, perform the indicated
1866 * actions, and set the semantic value of S. If result != yyok, the chain of
1867 * semantic options in S has been cleared instead or it has been left
1868 * unmodified except that redundant options may have been removed. Regardless
1869 * of whether result = yyok, S has been left with consistent data so that
1870 * yydestroyGLRState can be invoked if necessary. */
1871 static YYRESULTTAG
1872 yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
1873 {
1874 yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal;
1875 yySemanticOption* yybest;
1876 yySemanticOption** yypp;
1877 yybool yymerge;
1878 YYSTYPE yysval;
1879 YYRESULTTAG yyflag;
1880 YYLTYPE *yylocp = &yys->yyloc;
1881
1882 yybest = yyoptionList;
1883 yymerge = yyfalse;
1884 for (yypp = &yyoptionList->yynext; *yypp != NULL; )
1885 {
1886 yySemanticOption* yyp = *yypp;
1887
1888 if (yyidenticalOptions (yybest, yyp))
1889 {
1890 yymergeOptionSets (yybest, yyp);
1891 *yypp = yyp->yynext;
1892 }
1893 else
1894 {
1895 switch (yypreference (yybest, yyp))
1896 {
1897 case 0:
1898 yyresolveLocations (yys, 1, yystackp]b4_user_args[);
1899 return yyreportAmbiguity (yybest, yyp]b4_pure_args[);
1900 break;
1901 case 1:
1902 yymerge = yytrue;
1903 break;
1904 case 2:
1905 break;
1906 case 3:
1907 yybest = yyp;
1908 yymerge = yyfalse;
1909 break;
1910 default:
1911 /* This cannot happen so it is not worth a YYASSERT (yyfalse),
1912 but some compilers complain if the default case is
1913 omitted. */
1914 break;
1915 }
1916 yypp = &yyp->yynext;
1917 }
1918 }
1919
1920 if (yymerge)
1921 {
1922 yySemanticOption* yyp;
1923 int yyprec = yydprec[yybest->yyrule];
1924 yyflag = yyresolveAction (yybest, yystackp, &yysval,
1925 yylocp]b4_user_args[);
1926 if (yyflag == yyok)
1927 for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
1928 {
1929 if (yyprec == yydprec[yyp->yyrule])
1930 {
1931 YYSTYPE yysval_other;
1932 YYLTYPE yydummy;
1933 yyflag = yyresolveAction (yyp, yystackp, &yysval_other,
1934 &yydummy]b4_user_args[);
1935 if (yyflag != yyok)
1936 {
1937 yydestruct ("Cleanup: discarding incompletely merged value for",
1938 yystos[yys->yylrState],
1939 &yysval]b4_locations_if([, yylocp])[]b4_user_args[);
1940 break;
1941 }
1942 yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other);
1943 }
1944 }
1945 }
1946 else
1947 yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[);
1948
1949 if (yyflag == yyok)
1950 {
1951 yys->yyresolved = yytrue;
1952 yys->yysemantics.yysval = yysval;
1953 }
1954 else
1955 yys->yysemantics.yyfirstVal = NULL;
1956 return yyflag;
1957 }
1958
1959 static YYRESULTTAG
1960 yyresolveStack (yyGLRStack* yystackp]b4_user_formals[)
1961 {
1962 if (yystackp->yysplitPoint != NULL)
1963 {
1964 yyGLRState* yys;
1965 int yyn;
1966
1967 for (yyn = 0, yys = yystackp->yytops.yystates[0];
1968 yys != yystackp->yysplitPoint;
1969 yys = yys->yypred, yyn += 1)
1970 continue;
1971 YYCHK (yyresolveStates (yystackp->yytops.yystates[0], yyn, yystackp
1972 ]b4_user_args[));
1973 }
1974 return yyok;
1975 }
1976
1977 static void
1978 yycompressStack (yyGLRStack* yystackp)
1979 {
1980 yyGLRState* yyp, *yyq, *yyr;
1981
1982 if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == NULL)
1983 return;
1984
1985 for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = NULL;
1986 yyp != yystackp->yysplitPoint;
1987 yyr = yyp, yyp = yyq, yyq = yyp->yypred)
1988 yyp->yypred = yyr;
1989
1990 yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems;
1991 yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1;
1992 yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems;
1993 yystackp->yysplitPoint = NULL;
1994 yystackp->yylastDeleted = NULL;
1995
1996 while (yyr != NULL)
1997 {
1998 yystackp->yynextFree->yystate = *yyr;
1999 yyr = yyr->yypred;
2000 yystackp->yynextFree->yystate.yypred = &yystackp->yynextFree[-1].yystate;
2001 yystackp->yytops.yystates[0] = &yystackp->yynextFree->yystate;
2002 yystackp->yynextFree += 1;
2003 yystackp->yyspaceLeft -= 1;
2004 }
2005 }
2006
2007 static YYRESULTTAG
2008 yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
2009 size_t yyposn]b4_pure_formals[)
2010 {
2011 int yyaction;
2012 const short int* yyconflicts;
2013 yyRuleNum yyrule;
2014
2015 while (yystackp->yytops.yystates[yyk] != NULL)
2016 {
2017 yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState;
2018 YYDPRINTF ((stderr, "Stack %lu Entering state %d\n",
2019 (unsigned long int) yyk, yystate));
2020
2021 YYASSERT (yystate != YYFINAL);
2022
2023 if (yyisDefaultedState (yystate))
2024 {
2025 yyrule = yydefaultAction (yystate);
2026 if (yyrule == 0)
2027 {
2028 YYDPRINTF ((stderr, "Stack %lu dies.\n",
2029 (unsigned long int) yyk));
2030 yymarkStackDeleted (yystackp, yyk);
2031 return yyok;
2032 }
2033 YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse]b4_user_args[));
2034 }
2035 else
2036 {
2037 yySymbol yytoken;
2038 yystackp->yytops.yylookaheadNeeds[yyk] = yytrue;
2039 if (yychar == YYEMPTY)
2040 {
2041 YYDPRINTF ((stderr, "Reading a token: "));
2042 yychar = YYLEX;
2043 yytoken = YYTRANSLATE (yychar);
2044 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2045 }
2046 else
2047 yytoken = YYTRANSLATE (yychar);
2048 yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
2049
2050 while (*yyconflicts != 0)
2051 {
2052 size_t yynewStack = yysplitStack (yystackp, yyk);
2053 YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n",
2054 (unsigned long int) yynewStack,
2055 (unsigned long int) yyk));
2056 YYCHK (yyglrReduce (yystackp, yynewStack,
2057 *yyconflicts, yyfalse]b4_user_args[));
2058 YYCHK (yyprocessOneStack (yystackp, yynewStack,
2059 yyposn]b4_pure_args[));
2060 yyconflicts += 1;
2061 }
2062
2063 if (yyisShiftAction (yyaction))
2064 break;
2065 else if (yyisErrorAction (yyaction))
2066 {
2067 YYDPRINTF ((stderr, "Stack %lu dies.\n",
2068 (unsigned long int) yyk));
2069 yymarkStackDeleted (yystackp, yyk);
2070 break;
2071 }
2072 else
2073 YYCHK (yyglrReduce (yystackp, yyk, -yyaction,
2074 yyfalse]b4_user_args[));
2075 }
2076 }
2077 return yyok;
2078 }
2079
2080 /*ARGSUSED*/ static void
2081 yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
2082 {
2083 if (yystackp->yyerrState == 0)
2084 {
2085 #if YYERROR_VERBOSE
2086 int yyn;
2087 yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
2088 if (YYPACT_NINF < yyn && yyn <= YYLAST)
2089 {
2090 yySymbol yytoken = YYTRANSLATE (yychar);
2091 size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
2092 size_t yysize = yysize0;
2093 size_t yysize1;
2094 yybool yysize_overflow = yyfalse;
2095 char* yymsg = NULL;
2096 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2097 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2098 int yyx;
2099 char *yyfmt;
2100 char const *yyf;
2101 static char const yyunexpected[] = "syntax error, unexpected %s";
2102 static char const yyexpecting[] = ", expecting %s";
2103 static char const yyor[] = " or %s";
2104 char yyformat[sizeof yyunexpected
2105 + sizeof yyexpecting - 1
2106 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
2107 * (sizeof yyor - 1))];
2108 char const *yyprefix = yyexpecting;
2109
2110 /* Start YYX at -YYN if negative to avoid negative indexes in
2111 YYCHECK. */
2112 int yyxbegin = yyn < 0 ? -yyn : 0;
2113
2114 /* Stay within bounds of both yycheck and yytname. */
2115 int yychecklim = YYLAST - yyn + 1;
2116 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2117 int yycount = 1;
2118
2119 yyarg[0] = yytokenName (yytoken);
2120 yyfmt = yystpcpy (yyformat, yyunexpected);
2121
2122 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2123 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
2124 {
2125 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2126 {
2127 yycount = 1;
2128 yysize = yysize0;
2129 yyformat[sizeof yyunexpected - 1] = '\0';
2130 break;
2131 }
2132 yyarg[yycount++] = yytokenName (yyx);
2133 yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx));
2134 yysize_overflow |= yysize1 < yysize;
2135 yysize = yysize1;
2136 yyfmt = yystpcpy (yyfmt, yyprefix);
2137 yyprefix = yyor;
2138 }
2139
2140 yyf = YY_(yyformat);
2141 yysize1 = yysize + strlen (yyf);
2142 yysize_overflow |= yysize1 < yysize;
2143 yysize = yysize1;
2144
2145 if (!yysize_overflow)
2146 yymsg = (char *) YYMALLOC (yysize);
2147
2148 if (yymsg)
2149 {
2150 char *yyp = yymsg;
2151 int yyi = 0;
2152 while ((*yyp = *yyf))
2153 {
2154 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
2155 {
2156 yyp += yytnamerr (yyp, yyarg[yyi++]);
2157 yyf += 2;
2158 }
2159 else
2160 {
2161 yyp++;
2162 yyf++;
2163 }
2164 }
2165 yyerror (]b4_lyyerror_args[yymsg);
2166 YYFREE (yymsg);
2167 }
2168 else
2169 {
2170 yyerror (]b4_lyyerror_args[YY_("syntax error"));
2171 yyMemoryExhausted (yystackp);
2172 }
2173 }
2174 else
2175 #endif /* YYERROR_VERBOSE */
2176 yyerror (]b4_lyyerror_args[YY_("syntax error"));
2177 yynerrs += 1;
2178 }
2179 }
2180
2181 /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
2182 yylval, and yylloc are the syntactic category, semantic value, and location
2183 of the lookahead. */
2184 /*ARGSUSED*/ static void
2185 yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
2186 {
2187 size_t yyk;
2188 int yyj;
2189
2190 if (yystackp->yyerrState == 3)
2191 /* We just shifted the error token and (perhaps) took some
2192 reductions. Skip tokens until we can proceed. */
2193 while (YYID (yytrue))
2194 {
2195 yySymbol yytoken;
2196 if (yychar == YYEOF)
2197 yyFail (yystackp][]b4_lpure_args[, NULL);
2198 if (yychar != YYEMPTY)
2199 {]b4_locations_if([[
2200 /* We throw away the lookahead, but the error range
2201 of the shifted error token must take it into account. */
2202 yyGLRState *yys = yystackp->yytops.yystates[0];
2203 yyGLRStackItem yyerror_range[3];
2204 yyerror_range[1].yystate.yyloc = yys->yyloc;
2205 yyerror_range[2].yystate.yyloc = yylloc;
2206 YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[
2207 yytoken = YYTRANSLATE (yychar);
2208 yydestruct ("Error: discarding",
2209 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
2210 }
2211 YYDPRINTF ((stderr, "Reading a token: "));
2212 yychar = YYLEX;
2213 yytoken = YYTRANSLATE (yychar);
2214 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2215 yyj = yypact[yystackp->yytops.yystates[0]->yylrState];
2216 if (yyis_pact_ninf (yyj))
2217 return;
2218 yyj += yytoken;
2219 if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken)
2220 {
2221 if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0)
2222 return;
2223 }
2224 else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj]))
2225 return;
2226 }
2227
2228 /* Reduce to one stack. */
2229 for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1)
2230 if (yystackp->yytops.yystates[yyk] != NULL)
2231 break;
2232 if (yyk >= yystackp->yytops.yysize)
2233 yyFail (yystackp][]b4_lpure_args[, NULL);
2234 for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1)
2235 yymarkStackDeleted (yystackp, yyk);
2236 yyremoveDeletes (yystackp);
2237 yycompressStack (yystackp);
2238
2239 /* Now pop stack until we find a state that shifts the error token. */
2240 yystackp->yyerrState = 3;
2241 while (yystackp->yytops.yystates[0] != NULL)
2242 {
2243 yyGLRState *yys = yystackp->yytops.yystates[0];
2244 yyj = yypact[yys->yylrState];
2245 if (! yyis_pact_ninf (yyj))
2246 {
2247 yyj += YYTERROR;
2248 if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
2249 && yyisShiftAction (yytable[yyj]))
2250 {
2251 /* Shift the error token having adjusted its location. */
2252 YYLTYPE yyerrloc;]b4_locations_if([[
2253 yystackp->yyerror_range[2].yystate.yyloc = yylloc;
2254 YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[
2255 YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
2256 &yylval, &yyerrloc);
2257 yyglrShift (yystackp, 0, yytable[yyj],
2258 yys->yyposn, &yylval, &yyerrloc);
2259 yys = yystackp->yytops.yystates[0];
2260 break;
2261 }
2262 }
2263 ]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
2264 yydestroyGLRState ("Error: popping", yys]b4_user_args[);
2265 yystackp->yytops.yystates[0] = yys->yypred;
2266 yystackp->yynextFree -= 1;
2267 yystackp->yyspaceLeft += 1;
2268 }
2269 if (yystackp->yytops.yystates[0] == NULL)
2270 yyFail (yystackp][]b4_lpure_args[, NULL);
2271 }
2272
2273 #define YYCHK1(YYE) \
2274 do { \
2275 switch (YYE) { \
2276 case yyok: \
2277 break; \
2278 case yyabort: \
2279 goto yyabortlab; \
2280 case yyaccept: \
2281 goto yyacceptlab; \
2282 case yyerr: \
2283 goto yyuser_error; \
2284 default: \
2285 goto yybuglab; \
2286 } \
2287 } while (YYID (0))
2288
2289
2290 /*----------.
2291 | yyparse. |
2292 `----------*/
2293
2294 ]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[
2295 {
2296 int yyresult;
2297 yyGLRStack yystack;
2298 yyGLRStack* const yystackp = &yystack;
2299 size_t yyposn;
2300
2301 YYDPRINTF ((stderr, "Starting parse\n"));
2302
2303 yychar = YYEMPTY;
2304 yylval = yyval_default;
2305 ]b4_locations_if([
2306 #if YYLTYPE_IS_TRIVIAL
2307 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
2308 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
2309 #endif
2310 ])
2311 m4_ifdef([b4_initial_action], [
2312 m4_pushdef([b4_at_dollar], [yylloc])dnl
2313 m4_pushdef([b4_dollar_dollar], [yylval])dnl
2314 /* User initialization code. */
2315 b4_user_initial_action
2316 m4_popdef([b4_dollar_dollar])dnl
2317 m4_popdef([b4_at_dollar])])dnl
2318 [
2319 if (! yyinitGLRStack (yystackp, YYINITDEPTH))
2320 goto yyexhaustedlab;
2321 switch (YYSETJMP (yystack.yyexception_buffer))
2322 {
2323 case 0: break;
2324 case 1: goto yyabortlab;
2325 case 2: goto yyexhaustedlab;
2326 default: goto yybuglab;
2327 }
2328 yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc);
2329 yyposn = 0;
2330
2331 while (YYID (yytrue))
2332 {
2333 /* For efficiency, we have two loops, the first of which is
2334 specialized to deterministic operation (single stack, no
2335 potential ambiguity). */
2336 /* Standard mode */
2337 while (YYID (yytrue))
2338 {
2339 yyRuleNum yyrule;
2340 int yyaction;
2341 const short int* yyconflicts;
2342
2343 yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;
2344 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2345 if (yystate == YYFINAL)
2346 goto yyacceptlab;
2347 if (yyisDefaultedState (yystate))
2348 {
2349 yyrule = yydefaultAction (yystate);
2350 if (yyrule == 0)
2351 {
2352 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2353 yyreportSyntaxError (&yystack]b4_user_args[);
2354 goto yyuser_error;
2355 }
2356 YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[));
2357 }
2358 else
2359 {
2360 yySymbol yytoken;
2361 if (yychar == YYEMPTY)
2362 {
2363 YYDPRINTF ((stderr, "Reading a token: "));
2364 yychar = YYLEX;
2365 yytoken = YYTRANSLATE (yychar);
2366 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2367 }
2368 else
2369 yytoken = YYTRANSLATE (yychar);
2370 yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
2371 if (*yyconflicts != 0)
2372 break;
2373 if (yyisShiftAction (yyaction))
2374 {
2375 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2376 if (yychar != YYEOF)
2377 yychar = YYEMPTY;
2378 yyposn += 1;
2379 yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc);
2380 if (0 < yystack.yyerrState)
2381 yystack.yyerrState -= 1;
2382 }
2383 else if (yyisErrorAction (yyaction))
2384 {
2385 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2386 yyreportSyntaxError (&yystack]b4_user_args[);
2387 goto yyuser_error;
2388 }
2389 else
2390 YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[));
2391 }
2392 }
2393
2394 while (YYID (yytrue))
2395 {
2396 yySymbol yytoken_to_shift;
2397 size_t yys;
2398
2399 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2400 yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY;
2401
2402 /* yyprocessOneStack returns one of three things:
2403
2404 - An error flag. If the caller is yyprocessOneStack, it
2405 immediately returns as well. When the caller is finally
2406 yyparse, it jumps to an error label via YYCHK1.
2407
2408 - yyok, but yyprocessOneStack has invoked yymarkStackDeleted
2409 (&yystack, yys), which sets the top state of yys to NULL. Thus,
2410 yyparse's following invocation of yyremoveDeletes will remove
2411 the stack.
2412
2413 - yyok, when ready to shift a token.
2414
2415 Except in the first case, yyparse will invoke yyremoveDeletes and
2416 then shift the next token onto all remaining stacks. This
2417 synchronization of the shift (that is, after all preceding
2418 reductions on all stacks) helps prevent double destructor calls
2419 on yylval in the event of memory exhaustion. */
2420
2421 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2422 YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[));
2423 yyremoveDeletes (&yystack);
2424 if (yystack.yytops.yysize == 0)
2425 {
2426 yyundeleteLastStack (&yystack);
2427 if (yystack.yytops.yysize == 0)
2428 yyFail (&yystack][]b4_lpure_args[, YY_("syntax error"));
2429 YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
2430 YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
2431 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2432 yyreportSyntaxError (&yystack]b4_user_args[);
2433 goto yyuser_error;
2434 }
2435
2436 /* If any yyglrShift call fails, it will fail after shifting. Thus,
2437 a copy of yylval will already be on stack 0 in the event of a
2438 failure in the following loop. Thus, yychar is set to YYEMPTY
2439 before the loop to make sure the user destructor for yylval isn't
2440 called twice. */
2441 yytoken_to_shift = YYTRANSLATE (yychar);
2442 yychar = YYEMPTY;
2443 yyposn += 1;
2444 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2445 {
2446 int yyaction;
2447 const short int* yyconflicts;
2448 yyStateNum yystate = yystack.yytops.yystates[yys]->yylrState;
2449 yygetLRActions (yystate, yytoken_to_shift, &yyaction,
2450 &yyconflicts);
2451 /* Note that yyconflicts were handled by yyprocessOneStack. */
2452 YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys));
2453 YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc);
2454 yyglrShift (&yystack, yys, yyaction, yyposn,
2455 &yylval, &yylloc);
2456 YYDPRINTF ((stderr, "Stack %lu now in state #%d\n",
2457 (unsigned long int) yys,
2458 yystack.yytops.yystates[yys]->yylrState));
2459 }
2460
2461 if (yystack.yytops.yysize == 1)
2462 {
2463 YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
2464 YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
2465 yycompressStack (&yystack);
2466 break;
2467 }
2468 }
2469 continue;
2470 yyuser_error:
2471 yyrecoverSyntaxError (&yystack]b4_user_args[);
2472 yyposn = yystack.yytops.yystates[0]->yyposn;
2473 }
2474
2475 yyacceptlab:
2476 yyresult = 0;
2477 goto yyreturn;
2478
2479 yybuglab:
2480 YYASSERT (yyfalse);
2481 goto yyabortlab;
2482
2483 yyabortlab:
2484 yyresult = 1;
2485 goto yyreturn;
2486
2487 yyexhaustedlab:
2488 yyerror (]b4_lyyerror_args[YY_("memory exhausted"));
2489 yyresult = 2;
2490 goto yyreturn;
2491
2492 yyreturn:
2493 if (yychar != YYEOF && yychar != YYEMPTY)
2494 yydestruct ("Cleanup: discarding lookahead",
2495 YYTRANSLATE (yychar),
2496 &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
2497
2498 /* If the stack is well-formed, pop the stack until it is empty,
2499 destroying its entries as we go. But free the stack regardless
2500 of whether it is well-formed. */
2501 if (yystack.yyitems)
2502 {
2503 yyGLRState** yystates = yystack.yytops.yystates;
2504 if (yystates)
2505 {
2506 size_t yysize = yystack.yytops.yysize;
2507 size_t yyk;
2508 for (yyk = 0; yyk < yysize; yyk += 1)
2509 if (yystates[yyk])
2510 {
2511 while (yystates[yyk])
2512 {
2513 yyGLRState *yys = yystates[yyk];
2514 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]]
2515 )[ yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
2516 yystates[yyk] = yys->yypred;
2517 yystack.yynextFree -= 1;
2518 yystack.yyspaceLeft += 1;
2519 }
2520 break;
2521 }
2522 }
2523 yyfreeGLRStack (&yystack);
2524 }
2525
2526 /* Make sure YYID is used. */
2527 return YYID (yyresult);
2528 }
2529
2530 /* DEBUGGING ONLY */
2531 #ifdef YYDEBUG
2532 static void yypstack (yyGLRStack* yystackp, size_t yyk)
2533 __attribute__ ((__unused__));
2534 static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__));
2535
2536 static void
2537 yy_yypstack (yyGLRState* yys)
2538 {
2539 if (yys->yypred)
2540 {
2541 yy_yypstack (yys->yypred);
2542 fprintf (stderr, " -> ");
2543 }
2544 fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long int) yys->yyposn);
2545 }
2546
2547 static void
2548 yypstates (yyGLRState* yyst)
2549 {
2550 if (yyst == NULL)
2551 fprintf (stderr, "<null>");
2552 else
2553 yy_yypstack (yyst);
2554 fprintf (stderr, "\n");
2555 }
2556
2557 static void
2558 yypstack (yyGLRStack* yystackp, size_t yyk)
2559 {
2560 yypstates (yystackp->yytops.yystates[yyk]);
2561 }
2562
2563 #define YYINDEX(YYX) \
2564 ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems)
2565
2566
2567 static void
2568 yypdumpstack (yyGLRStack* yystackp)
2569 {
2570 yyGLRStackItem* yyp;
2571 size_t yyi;
2572 for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1)
2573 {
2574 fprintf (stderr, "%3lu. ", (unsigned long int) (yyp - yystackp->yyitems));
2575 if (*(yybool *) yyp)
2576 {
2577 fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
2578 yyp->yystate.yyresolved, yyp->yystate.yylrState,
2579 (unsigned long int) yyp->yystate.yyposn,
2580 (long int) YYINDEX (yyp->yystate.yypred));
2581 if (! yyp->yystate.yyresolved)
2582 fprintf (stderr, ", firstVal: %ld",
2583 (long int) YYINDEX (yyp->yystate.yysemantics.yyfirstVal));
2584 }
2585 else
2586 {
2587 fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld",
2588 yyp->yyoption.yyrule - 1,
2589 (long int) YYINDEX (yyp->yyoption.yystate),
2590 (long int) YYINDEX (yyp->yyoption.yynext));
2591 }
2592 fprintf (stderr, "\n");
2593 }
2594 fprintf (stderr, "Tops:");
2595 for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
2596 fprintf (stderr, "%lu: %ld; ", (unsigned long int) yyi,
2597 (long int) YYINDEX (yystackp->yytops.yystates[yyi]));
2598 fprintf (stderr, "\n");
2599 }
2600 #endif
2601 ]
2602
2603 b4_epilogue
2604 b4_defines_if(
2605 [@output @output_header_name@
2606 b4_copyright([Skeleton interface for Bison GLR parsers in C],
2607 [2002, 2003, 2004, 2005, 2006])
2608
2609 b4_shared_declarations
2610
2611 extern YYSTYPE b4_prefix[]lval;
2612
2613 b4_locations_if([b4_pure_if([],
2614 [extern YYLTYPE b4_prefix[]lloc;])
2615 ])
2616 ])
bison