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