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


85a5affd0cb0f2a7318264333afd599b7703fd4f
[bison.git] / data / glr.c
1 -*- C -*-
2
3 # GLR skeleton for Bison
4 # Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free
5 # Software Foundation, Inc.
6
7 # This program is free software: you can redistribute it and/or modify
8 # it under the terms of the GNU General Public License as published by
9 # the Free Software Foundation, either version 3 of the License, or
10 # (at your option) any later version.
11 #
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU General Public License for more details.
16 #
17 # You should have received a copy of the GNU General Public License
18 # along with this program. If not, see <http://www.gnu.org/licenses/>.
19
20
21 m4_include(b4_pkgdatadir/[c.m4])
22
23 ## ---------------- ##
24 ## Default values. ##
25 ## ---------------- ##
26
27 # Stack parameters.
28 m4_define_default([b4_stack_depth_max], [10000])
29 m4_define_default([b4_stack_depth_init], [200])
30
31
32
33 ## ------------------------ ##
34 ## Pure/impure interfaces. ##
35 ## ------------------------ ##
36
37 b4_define_flag_if([pure])
38 # If glr.cc is including this file and thus has already set b4_pure_flag, don't
39 # change the value of b4_pure_flag, and don't record a use of api.pure.
40 m4_ifndef([b4_pure_flag],
41 [b4_percent_define_default([[api.pure]], [[false]])
42 m4_define([b4_pure_flag],
43 [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])])
44
45 # b4_user_formals
46 # ---------------
47 # The possible parse-params formal arguments preceded by a comma.
48 #
49 # This is not shared with yacc.c in c.m4 because GLR relies on ISO C
50 # formal argument declarations.
51 m4_define([b4_user_formals],
52 [m4_ifset([b4_parse_param], [, b4_c_ansi_formals(b4_parse_param)])])
53
54
55 # b4_lex_param
56 # ------------
57 # Accumule in b4_lex_param all the yylex arguments.
58 # Yes, this is quite ugly...
59 m4_define([b4_lex_param],
60 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
61 b4_locations_if([, [[YYLTYPE *], [&yylloc]]])])dnl
62 m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
63
64
65 # b4_yyerror_args
66 # ---------------
67 # Optional effective arguments passed to yyerror: user args plus yylloc, and
68 # a trailing comma.
69 m4_define([b4_yyerror_args],
70 [b4_pure_if([b4_locations_if([yylocp, ])])dnl
71 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
72
73
74 # b4_lyyerror_args
75 # ----------------
76 # Same as above, but on the lookahead, hence &yylloc instead of yylocp.
77 m4_define([b4_lyyerror_args],
78 [b4_pure_if([b4_locations_if([&yylloc, ])])dnl
79 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
80
81
82 # b4_pure_args
83 # ------------
84 # Same as b4_yyerror_args, but with a leading comma.
85 m4_define([b4_pure_args],
86 [b4_pure_if([b4_locations_if([, yylocp])])[]b4_user_args])
87
88
89 # b4_lpure_args
90 # -------------
91 # Same as above, but on the lookahead, hence &yylloc instead of yylocp.
92 m4_define([b4_lpure_args],
93 [b4_pure_if([b4_locations_if([, &yylloc])])[]b4_user_args])
94
95
96 # b4_pure_formals
97 # ---------------
98 # Arguments passed to yyerror: user formals plus yylocp.
99 m4_define([b4_pure_formals],
100 [b4_pure_if([b4_locations_if([, YYLTYPE *yylocp])])[]b4_user_formals])
101
102
103 ## ----------------- ##
104 ## Semantic Values. ##
105 ## ----------------- ##
106
107
108 # b4_lhs_value([TYPE])
109 # --------------------
110 # Expansion of $<TYPE>$.
111 m4_define([b4_lhs_value],
112 [b4_symbol_value([(*yyvalp)], [$1])])
113
114
115 # b4_rhs_data(RULE-LENGTH, NUM)
116 # -----------------------------
117 # Expand to the semantic stack place that contains value and location
118 # of symbol number NUM in a rule of length RULE-LENGTH.
119 m4_define([b4_rhs_data],
120 [((yyGLRStackItem const *)yyvsp)@{YYFILL (b4_subtract([$2], [$1]))@}.yystate])
121
122
123 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
124 # --------------------------------------
125 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
126 # symbols on RHS.
127 m4_define([b4_rhs_value],
128 [b4_symbol_value([b4_rhs_data([$1], [$2]).yysemantics.yysval], [$3])])
129
130
131
132 ## ----------- ##
133 ## Locations. ##
134 ## ----------- ##
135
136 # b4_lhs_location()
137 # -----------------
138 # Expansion of @$.
139 m4_define([b4_lhs_location],
140 [(*yylocp)])
141
142
143 # b4_rhs_location(RULE-LENGTH, NUM)
144 # ---------------------------------
145 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
146 # on RHS.
147 m4_define([b4_rhs_location],
148 [(b4_rhs_data([$1], [$2]).yyloc)])
149
150
151
152 ## -------------- ##
153 ## Output files. ##
154 ## -------------- ##
155
156 # We do want M4 expansion after # for CPP macros.
157 m4_changecom()
158 m4_divert_push(0)dnl
159 @output(b4_parser_file_name@)@
160 b4_copyright([Skeleton implementation for Bison GLR parsers in C],
161 [2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009])
162 [
163 /* C GLR parser skeleton written by Paul Hilfinger. */
164
165 ]b4_identification
166
167 b4_percent_code_get([[top]])[]dnl
168 m4_if(b4_prefix, [yy], [],
169 [/* Substitute the variable and function names. */
170 #define yyparse b4_prefix[]parse
171 #define yylex b4_prefix[]lex
172 #define yyerror b4_prefix[]error
173 #define yylval b4_prefix[]lval
174 #define yychar b4_prefix[]char
175 #define yydebug b4_prefix[]debug
176 #define yynerrs b4_prefix[]nerrs
177 #define yylloc b4_prefix[]lloc])[
178
179 /* Copy the first part of user declarations. */
180 ]b4_user_pre_prologue
181
182 dnl # b4_shared_declarations
183 dnl # ----------------------
184 dnl # Declaration that might either go into the header (if --defines)
185 dnl # or open coded in the parser body.
186 m4_define([b4_shared_declarations],
187 [b4_percent_code_get([[requires]])[]dnl
188
189 b4_token_enums(b4_tokens)
190
191 [#ifndef YYSTYPE
192 ]m4_ifdef([b4_stype],
193 [[typedef union ]b4_union_name[
194 {
195 ]b4_user_stype[
196 } YYSTYPE;
197 # define YYSTYPE_IS_TRIVIAL 1]],
198 [m4_if(b4_tag_seen_flag, 0,
199 [[typedef int YYSTYPE;
200 # define YYSTYPE_IS_TRIVIAL 1]])])[
201 #endif
202
203 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
204 typedef struct YYLTYPE
205 {
206 ]b4_locations_if([
207 int first_line;
208 int first_column;
209 int last_line;
210 int last_column;
211 ],[
212 char yydummy;
213 ])[
214 } YYLTYPE;
215 # define YYLTYPE_IS_DECLARED 1
216 # define YYLTYPE_IS_TRIVIAL 1
217 #endif
218
219 ]b4_percent_code_get([[provides]])[]dnl
220 ])
221
222 b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
223 [b4_shared_declarations])[
224
225 /* Enabling traces. */
226 #ifndef YYDEBUG
227 # define YYDEBUG ]b4_parse_trace_if([1], [0])[
228 #endif
229
230 /* Enabling verbose error messages. */
231 #ifdef YYERROR_VERBOSE
232 # undef YYERROR_VERBOSE
233 # define YYERROR_VERBOSE 1
234 #else
235 # define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[
236 #endif
237
238 /* Enabling the token table. */
239 #ifndef YYTOKEN_TABLE
240 # define YYTOKEN_TABLE ]b4_token_table[
241 #endif
242
243 /* Default (constant) value used for initialization for null
244 right-hand sides. Unlike the standard yacc.c template,
245 here we set the default value of $$ to a zeroed-out value.
246 Since the default value is undefined, this behavior is
247 technically correct. */
248 static YYSTYPE yyval_default;
249
250 /* Copy the second part of user declarations. */
251 ]b4_user_post_prologue
252 b4_percent_code_get[]dnl
253
254 [#include <stdio.h>
255 #include <stdlib.h>
256 #include <string.h>
257
258 #ifndef YY_
259 # if YYENABLE_NLS
260 # if ENABLE_NLS
261 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
262 # define YY_(msgid) dgettext ("bison-runtime", msgid)
263 # endif
264 # endif
265 # ifndef YY_
266 # define YY_(msgid) msgid
267 # endif
268 #endif
269
270 /* Suppress unused-variable warnings by "using" E. */
271 #if ! defined lint || defined __GNUC__
272 # define YYUSE(e) ((void) (e))
273 #else
274 # define YYUSE(e) /* empty */
275 #endif
276
277 /* Identity function, used to suppress warnings about constant conditions. */
278 #ifndef lint
279 # define YYID(n) (n)
280 #else
281 ]b4_c_function_def([YYID], [static int], [[int i], [i]])[
282 {
283 return i;
284 }
285 #endif
286
287 #ifndef YYFREE
288 # define YYFREE free
289 #endif
290 #ifndef YYMALLOC
291 # define YYMALLOC malloc
292 #endif
293 #ifndef YYREALLOC
294 # define YYREALLOC realloc
295 #endif
296
297 #define YYSIZEMAX ((size_t) -1)
298
299 #ifdef __cplusplus
300 typedef bool yybool;
301 #else
302 typedef unsigned char yybool;
303 #endif
304 #define yytrue 1
305 #define yyfalse 0
306
307 #ifndef YYSETJMP
308 # include <setjmp.h>
309 # define YYJMP_BUF jmp_buf
310 # define YYSETJMP(env) setjmp (env)
311 # define YYLONGJMP(env, val) longjmp (env, val)
312 #endif
313
314 /*-----------------.
315 | GCC extensions. |
316 `-----------------*/
317
318 #ifndef __attribute__
319 /* This feature is available in gcc versions 2.5 and later. */
320 # if (! defined __GNUC__ || __GNUC__ < 2 \
321 || (__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __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 yyis_pact_ninf(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 yyis_pact_ninf (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 yyis_table_ninf(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 (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken)
991 {
992 *yyaction = -yydefact[yystate];
993 *yyconflicts = yyconfl;
994 }
995 else if (! yyis_table_ninf (yytable[yyindex]))
996 {
997 *yyaction = yytable[yyindex];
998 *yyconflicts = yyconfl + yyconflp[yyindex];
999 }
1000 else
1001 {
1002 *yyaction = 0;
1003 *yyconflicts = yyconfl + yyconflp[yyindex];
1004 }
1005 }
1006
1007 static inline yyStateNum
1008 yyLRgotoState (yyStateNum yystate, yySymbol yylhs)
1009 {
1010 int yyr = yypgoto[yylhs - YYNTOKENS] + yystate;
1011 if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate)
1012 return yytable[yyr];
1013 else
1014 return yydefgoto[yylhs - YYNTOKENS];
1015 }
1016
1017 static inline yybool
1018 yyisShiftAction (int yyaction)
1019 {
1020 return 0 < yyaction;
1021 }
1022
1023 static inline yybool
1024 yyisErrorAction (int yyaction)
1025 {
1026 return yyaction == 0;
1027 }
1028
1029 /* GLRStates */
1030
1031 /** Return a fresh GLRStackItem. Callers should call
1032 * YY_RESERVE_GLRSTACK afterwards to make sure there is sufficient
1033 * headroom. */
1034
1035 static inline yyGLRStackItem*
1036 yynewGLRStackItem (yyGLRStack* yystackp, yybool yyisState)
1037 {
1038 yyGLRStackItem* yynewItem = yystackp->yynextFree;
1039 yystackp->yyspaceLeft -= 1;
1040 yystackp->yynextFree += 1;
1041 yynewItem->yystate.yyisState = yyisState;
1042 return yynewItem;
1043 }
1044
1045 /** Add a new semantic action that will execute the action for rule
1046 * RULENUM on the semantic values in RHS to the list of
1047 * alternative actions for STATE. Assumes that RHS comes from
1048 * stack #K of *STACKP. */
1049 static void
1050 yyaddDeferredAction (yyGLRStack* yystackp, size_t yyk, yyGLRState* yystate,
1051 yyGLRState* yyrhs, yyRuleNum yyrule)
1052 {
1053 yySemanticOption* yynewOption =
1054 &yynewGLRStackItem (yystackp, yyfalse)->yyoption;
1055 yynewOption->yystate = yyrhs;
1056 yynewOption->yyrule = yyrule;
1057 if (yystackp->yytops.yylookaheadNeeds[yyk])
1058 {
1059 yynewOption->yyrawchar = yychar;
1060 yynewOption->yyval = yylval;
1061 yynewOption->yyloc = yylloc;
1062 }
1063 else
1064 yynewOption->yyrawchar = YYEMPTY;
1065 yynewOption->yynext = yystate->yysemantics.yyfirstVal;
1066 yystate->yysemantics.yyfirstVal = yynewOption;
1067
1068 YY_RESERVE_GLRSTACK (yystackp);
1069 }
1070
1071 /* GLRStacks */
1072
1073 /** Initialize SET to a singleton set containing an empty stack. */
1074 static yybool
1075 yyinitStateSet (yyGLRStateSet* yyset)
1076 {
1077 yyset->yysize = 1;
1078 yyset->yycapacity = 16;
1079 yyset->yystates = (yyGLRState**) YYMALLOC (16 * sizeof yyset->yystates[0]);
1080 if (! yyset->yystates)
1081 return yyfalse;
1082 yyset->yystates[0] = NULL;
1083 yyset->yylookaheadNeeds =
1084 (yybool*) YYMALLOC (16 * sizeof yyset->yylookaheadNeeds[0]);
1085 if (! yyset->yylookaheadNeeds)
1086 {
1087 YYFREE (yyset->yystates);
1088 return yyfalse;
1089 }
1090 return yytrue;
1091 }
1092
1093 static void yyfreeStateSet (yyGLRStateSet* yyset)
1094 {
1095 YYFREE (yyset->yystates);
1096 YYFREE (yyset->yylookaheadNeeds);
1097 }
1098
1099 /** Initialize STACK to a single empty stack, with total maximum
1100 * capacity for all stacks of SIZE. */
1101 static yybool
1102 yyinitGLRStack (yyGLRStack* yystackp, size_t yysize)
1103 {
1104 yystackp->yyerrState = 0;
1105 yynerrs = 0;
1106 yystackp->yyspaceLeft = yysize;
1107 yystackp->yyitems =
1108 (yyGLRStackItem*) YYMALLOC (yysize * sizeof yystackp->yynextFree[0]);
1109 if (!yystackp->yyitems)
1110 return yyfalse;
1111 yystackp->yynextFree = yystackp->yyitems;
1112 yystackp->yysplitPoint = NULL;
1113 yystackp->yylastDeleted = NULL;
1114 return yyinitStateSet (&yystackp->yytops);
1115 }
1116
1117
1118 #if YYSTACKEXPANDABLE
1119 # define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \
1120 &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE
1121
1122 /** If STACK is expandable, extend it. WARNING: Pointers into the
1123 stack from outside should be considered invalid after this call.
1124 We always expand when there are 1 or fewer items left AFTER an
1125 allocation, so that we can avoid having external pointers exist
1126 across an allocation. */
1127 static void
1128 yyexpandGLRStack (yyGLRStack* yystackp)
1129 {
1130 yyGLRStackItem* yynewItems;
1131 yyGLRStackItem* yyp0, *yyp1;
1132 size_t yysize, yynewSize;
1133 size_t yyn;
1134 yysize = yystackp->yynextFree - yystackp->yyitems;
1135 if (YYMAXDEPTH - YYHEADROOM < yysize)
1136 yyMemoryExhausted (yystackp);
1137 yynewSize = 2*yysize;
1138 if (YYMAXDEPTH < yynewSize)
1139 yynewSize = YYMAXDEPTH;
1140 yynewItems = (yyGLRStackItem*) YYMALLOC (yynewSize * sizeof yynewItems[0]);
1141 if (! yynewItems)
1142 yyMemoryExhausted (yystackp);
1143 for (yyp0 = yystackp->yyitems, yyp1 = yynewItems, yyn = yysize;
1144 0 < yyn;
1145 yyn -= 1, yyp0 += 1, yyp1 += 1)
1146 {
1147 *yyp1 = *yyp0;
1148 if (*(yybool *) yyp0)
1149 {
1150 yyGLRState* yys0 = &yyp0->yystate;
1151 yyGLRState* yys1 = &yyp1->yystate;
1152 if (yys0->yypred != NULL)
1153 yys1->yypred =
1154 YYRELOC (yyp0, yyp1, yys0->yypred, yystate);
1155 if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != NULL)
1156 yys1->yysemantics.yyfirstVal =
1157 YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption);
1158 }
1159 else
1160 {
1161 yySemanticOption* yyv0 = &yyp0->yyoption;
1162 yySemanticOption* yyv1 = &yyp1->yyoption;
1163 if (yyv0->yystate != NULL)
1164 yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate);
1165 if (yyv0->yynext != NULL)
1166 yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption);
1167 }
1168 }
1169 if (yystackp->yysplitPoint != NULL)
1170 yystackp->yysplitPoint = YYRELOC (yystackp->yyitems, yynewItems,
1171 yystackp->yysplitPoint, yystate);
1172
1173 for (yyn = 0; yyn < yystackp->yytops.yysize; yyn += 1)
1174 if (yystackp->yytops.yystates[yyn] != NULL)
1175 yystackp->yytops.yystates[yyn] =
1176 YYRELOC (yystackp->yyitems, yynewItems,
1177 yystackp->yytops.yystates[yyn], yystate);
1178 YYFREE (yystackp->yyitems);
1179 yystackp->yyitems = yynewItems;
1180 yystackp->yynextFree = yynewItems + yysize;
1181 yystackp->yyspaceLeft = yynewSize - yysize;
1182 }
1183 #endif
1184
1185 static void
1186 yyfreeGLRStack (yyGLRStack* yystackp)
1187 {
1188 YYFREE (yystackp->yyitems);
1189 yyfreeStateSet (&yystackp->yytops);
1190 }
1191
1192 /** Assuming that S is a GLRState somewhere on STACK, update the
1193 * splitpoint of STACK, if needed, so that it is at least as deep as
1194 * S. */
1195 static inline void
1196 yyupdateSplit (yyGLRStack* yystackp, yyGLRState* yys)
1197 {
1198 if (yystackp->yysplitPoint != NULL && yystackp->yysplitPoint > yys)
1199 yystackp->yysplitPoint = yys;
1200 }
1201
1202 /** Invalidate stack #K in STACK. */
1203 static inline void
1204 yymarkStackDeleted (yyGLRStack* yystackp, size_t yyk)
1205 {
1206 if (yystackp->yytops.yystates[yyk] != NULL)
1207 yystackp->yylastDeleted = yystackp->yytops.yystates[yyk];
1208 yystackp->yytops.yystates[yyk] = NULL;
1209 }
1210
1211 /** Undelete the last stack that was marked as deleted. Can only be
1212 done once after a deletion, and only when all other stacks have
1213 been deleted. */
1214 static void
1215 yyundeleteLastStack (yyGLRStack* yystackp)
1216 {
1217 if (yystackp->yylastDeleted == NULL || yystackp->yytops.yysize != 0)
1218 return;
1219 yystackp->yytops.yystates[0] = yystackp->yylastDeleted;
1220 yystackp->yytops.yysize = 1;
1221 YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n"));
1222 yystackp->yylastDeleted = NULL;
1223 }
1224
1225 static inline void
1226 yyremoveDeletes (yyGLRStack* yystackp)
1227 {
1228 size_t yyi, yyj;
1229 yyi = yyj = 0;
1230 while (yyj < yystackp->yytops.yysize)
1231 {
1232 if (yystackp->yytops.yystates[yyi] == NULL)
1233 {
1234 if (yyi == yyj)
1235 {
1236 YYDPRINTF ((stderr, "Removing dead stacks.\n"));
1237 }
1238 yystackp->yytops.yysize -= 1;
1239 }
1240 else
1241 {
1242 yystackp->yytops.yystates[yyj] = yystackp->yytops.yystates[yyi];
1243 /* In the current implementation, it's unnecessary to copy
1244 yystackp->yytops.yylookaheadNeeds[yyi] since, after
1245 yyremoveDeletes returns, the parser immediately either enters
1246 deterministic operation or shifts a token. However, it doesn't
1247 hurt, and the code might evolve to need it. */
1248 yystackp->yytops.yylookaheadNeeds[yyj] =
1249 yystackp->yytops.yylookaheadNeeds[yyi];
1250 if (yyj != yyi)
1251 {
1252 YYDPRINTF ((stderr, "Rename stack %lu -> %lu.\n",
1253 (unsigned long int) yyi, (unsigned long int) yyj));
1254 }
1255 yyj += 1;
1256 }
1257 yyi += 1;
1258 }
1259 }
1260
1261 /** Shift to a new state on stack #K of STACK, corresponding to LR state
1262 * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */
1263 static inline void
1264 yyglrShift (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
1265 size_t yyposn,
1266 YYSTYPE* yyvalp, YYLTYPE* yylocp)
1267 {
1268 yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
1269
1270 yynewState->yylrState = yylrState;
1271 yynewState->yyposn = yyposn;
1272 yynewState->yyresolved = yytrue;
1273 yynewState->yypred = yystackp->yytops.yystates[yyk];
1274 yynewState->yysemantics.yysval = *yyvalp;
1275 yynewState->yyloc = *yylocp;
1276 yystackp->yytops.yystates[yyk] = yynewState;
1277
1278 YY_RESERVE_GLRSTACK (yystackp);
1279 }
1280
1281 /** Shift stack #K of YYSTACK, to a new state corresponding to LR
1282 * state YYLRSTATE, at input position YYPOSN, with the (unresolved)
1283 * semantic value of YYRHS under the action for YYRULE. */
1284 static inline void
1285 yyglrShiftDefer (yyGLRStack* yystackp, size_t yyk, yyStateNum yylrState,
1286 size_t yyposn, yyGLRState* yyrhs, yyRuleNum yyrule)
1287 {
1288 yyGLRState* yynewState = &yynewGLRStackItem (yystackp, yytrue)->yystate;
1289
1290 yynewState->yylrState = yylrState;
1291 yynewState->yyposn = yyposn;
1292 yynewState->yyresolved = yyfalse;
1293 yynewState->yypred = yystackp->yytops.yystates[yyk];
1294 yynewState->yysemantics.yyfirstVal = NULL;
1295 yystackp->yytops.yystates[yyk] = yynewState;
1296
1297 /* Invokes YY_RESERVE_GLRSTACK. */
1298 yyaddDeferredAction (yystackp, yyk, yynewState, yyrhs, yyrule);
1299 }
1300
1301 /** Pop the symbols consumed by reduction #RULE from the top of stack
1302 * #K of STACK, and perform the appropriate semantic action on their
1303 * semantic values. Assumes that all ambiguities in semantic values
1304 * have been previously resolved. Set *VALP to the resulting value,
1305 * and *LOCP to the computed location (if any). Return value is as
1306 * for userAction. */
1307 static inline YYRESULTTAG
1308 yydoAction (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
1309 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
1310 {
1311 int yynrhs = yyrhsLength (yyrule);
1312
1313 if (yystackp->yysplitPoint == NULL)
1314 {
1315 /* Standard special case: single stack. */
1316 yyGLRStackItem* yyrhs = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
1317 YYASSERT (yyk == 0);
1318 yystackp->yynextFree -= yynrhs;
1319 yystackp->yyspaceLeft += yynrhs;
1320 yystackp->yytops.yystates[0] = & yystackp->yynextFree[-1].yystate;
1321 return yyuserAction (yyrule, yynrhs, yyrhs,
1322 yyvalp, yylocp, yystackp]b4_user_args[);
1323 }
1324 else
1325 {
1326 /* At present, doAction is never called in nondeterministic
1327 * mode, so this branch is never taken. It is here in
1328 * anticipation of a future feature that will allow immediate
1329 * evaluation of selected actions in nondeterministic mode. */
1330 int yyi;
1331 yyGLRState* yys;
1332 yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
1333 yys = yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred
1334 = yystackp->yytops.yystates[yyk];]b4_locations_if([[
1335 if (yynrhs == 0)
1336 /* Set default location. */
1337 yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yys->yyloc;]])[
1338 for (yyi = 0; yyi < yynrhs; yyi += 1)
1339 {
1340 yys = yys->yypred;
1341 YYASSERT (yys);
1342 }
1343 yyupdateSplit (yystackp, yys);
1344 yystackp->yytops.yystates[yyk] = yys;
1345 return yyuserAction (yyrule, yynrhs, yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
1346 yyvalp, yylocp, yystackp]b4_user_args[);
1347 }
1348 }
1349
1350 #if !YYDEBUG
1351 # define YY_REDUCE_PRINT(Args)
1352 #else
1353 # define YY_REDUCE_PRINT(Args) \
1354 do { \
1355 if (yydebug) \
1356 yy_reduce_print Args; \
1357 } while (YYID (0))
1358
1359 /*----------------------------------------------------------.
1360 | Report that the RULE is going to be reduced on stack #K. |
1361 `----------------------------------------------------------*/
1362
1363 /*ARGSUSED*/ static inline void
1364 yy_reduce_print (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule]b4_user_formals[)
1365 {
1366 int yynrhs = yyrhsLength (yyrule);
1367 yybool yynormal __attribute__ ((__unused__)) =
1368 (yystackp->yysplitPoint == NULL);
1369 yyGLRStackItem* yyvsp = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
1370 int yylow = 1;
1371 int yyi;
1372 ]b4_parse_param_use[]dnl
1373 [ YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n",
1374 (unsigned long int) yyk, yyrule - 1,
1375 (unsigned long int) yyrline[yyrule]);
1376 /* The symbols being reduced. */
1377 for (yyi = 0; yyi < yynrhs; yyi++)
1378 {
1379 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1380 yy_symbol_print (stderr,
1381 ]yystos@{b4_rhs_data(yynrhs, yyi + 1).yylrState@}[,
1382 &]b4_rhs_value(yynrhs, yyi + 1)[
1383 ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
1384 b4_user_args[);
1385 YYFPRINTF (stderr, "\n");
1386 }
1387 }
1388 #endif
1389
1390 /** Pop items off stack #K of STACK according to grammar rule RULE,
1391 * and push back on the resulting nonterminal symbol. Perform the
1392 * semantic action associated with RULE and store its value with the
1393 * newly pushed state, if FORCEEVAL or if STACK is currently
1394 * unambiguous. Otherwise, store the deferred semantic action with
1395 * the new state. If the new state would have an identical input
1396 * position, LR state, and predecessor to an existing state on the stack,
1397 * it is identified with that existing state, eliminating stack #K from
1398 * the STACK. In this case, the (necessarily deferred) semantic value is
1399 * added to the options for the existing state's semantic value.
1400 */
1401 static inline YYRESULTTAG
1402 yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
1403 yybool yyforceEval]b4_user_formals[)
1404 {
1405 size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn;
1406
1407 if (yyforceEval || yystackp->yysplitPoint == NULL)
1408 {
1409 YYSTYPE yysval;
1410 YYLTYPE yyloc;
1411
1412 YY_REDUCE_PRINT ((yystackp, yyk, yyrule]b4_user_args[));
1413 YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval,
1414 &yyloc]b4_user_args[));
1415 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc);
1416 yyglrShift (yystackp, yyk,
1417 yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState,
1418 yylhsNonterm (yyrule)),
1419 yyposn, &yysval, &yyloc);
1420 }
1421 else
1422 {
1423 size_t yyi;
1424 int yyn;
1425 yyGLRState* yys, *yys0 = yystackp->yytops.yystates[yyk];
1426 yyStateNum yynewLRState;
1427
1428 for (yys = yystackp->yytops.yystates[yyk], yyn = yyrhsLength (yyrule);
1429 0 < yyn; yyn -= 1)
1430 {
1431 yys = yys->yypred;
1432 YYASSERT (yys);
1433 }
1434 yyupdateSplit (yystackp, yys);
1435 yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
1436 YYDPRINTF ((stderr,
1437 "Reduced stack %lu by rule #%d; action deferred. Now in state %d.\n",
1438 (unsigned long int) yyk, yyrule - 1, yynewLRState));
1439 for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
1440 if (yyi != yyk && yystackp->yytops.yystates[yyi] != NULL)
1441 {
1442 yyGLRState* yyp, *yysplit = yystackp->yysplitPoint;
1443 yyp = yystackp->yytops.yystates[yyi];
1444 while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn)
1445 {
1446 if (yyp->yylrState == yynewLRState && yyp->yypred == yys)
1447 {
1448 yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule);
1449 yymarkStackDeleted (yystackp, yyk);
1450 YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n",
1451 (unsigned long int) yyk,
1452 (unsigned long int) yyi));
1453 return yyok;
1454 }
1455 yyp = yyp->yypred;
1456 }
1457 }
1458 yystackp->yytops.yystates[yyk] = yys;
1459 yyglrShiftDefer (yystackp, yyk, yynewLRState, yyposn, yys0, yyrule);
1460 }
1461 return yyok;
1462 }
1463
1464 static size_t
1465 yysplitStack (yyGLRStack* yystackp, size_t yyk)
1466 {
1467 if (yystackp->yysplitPoint == NULL)
1468 {
1469 YYASSERT (yyk == 0);
1470 yystackp->yysplitPoint = yystackp->yytops.yystates[yyk];
1471 }
1472 if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity)
1473 {
1474 yyGLRState** yynewStates;
1475 yybool* yynewLookaheadNeeds;
1476
1477 yynewStates = NULL;
1478
1479 if (yystackp->yytops.yycapacity
1480 > (YYSIZEMAX / (2 * sizeof yynewStates[0])))
1481 yyMemoryExhausted (yystackp);
1482 yystackp->yytops.yycapacity *= 2;
1483
1484 yynewStates =
1485 (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
1486 (yystackp->yytops.yycapacity
1487 * sizeof yynewStates[0]));
1488 if (yynewStates == NULL)
1489 yyMemoryExhausted (yystackp);
1490 yystackp->yytops.yystates = yynewStates;
1491
1492 yynewLookaheadNeeds =
1493 (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds,
1494 (yystackp->yytops.yycapacity
1495 * sizeof yynewLookaheadNeeds[0]));
1496 if (yynewLookaheadNeeds == NULL)
1497 yyMemoryExhausted (yystackp);
1498 yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds;
1499 }
1500 yystackp->yytops.yystates[yystackp->yytops.yysize]
1501 = yystackp->yytops.yystates[yyk];
1502 yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize]
1503 = yystackp->yytops.yylookaheadNeeds[yyk];
1504 yystackp->yytops.yysize += 1;
1505 return yystackp->yytops.yysize-1;
1506 }
1507
1508 /** True iff Y0 and Y1 represent identical options at the top level.
1509 * That is, they represent the same rule applied to RHS symbols
1510 * that produce the same terminal symbols. */
1511 static yybool
1512 yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1)
1513 {
1514 if (yyy0->yyrule == yyy1->yyrule)
1515 {
1516 yyGLRState *yys0, *yys1;
1517 int yyn;
1518 for (yys0 = yyy0->yystate, yys1 = yyy1->yystate,
1519 yyn = yyrhsLength (yyy0->yyrule);
1520 yyn > 0;
1521 yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1)
1522 if (yys0->yyposn != yys1->yyposn)
1523 return yyfalse;
1524 return yytrue;
1525 }
1526 else
1527 return yyfalse;
1528 }
1529
1530 /** Assuming identicalOptions (Y0,Y1), destructively merge the
1531 * alternative semantic values for the RHS-symbols of Y1 and Y0. */
1532 static void
1533 yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1)
1534 {
1535 yyGLRState *yys0, *yys1;
1536 int yyn;
1537 for (yys0 = yyy0->yystate, yys1 = yyy1->yystate,
1538 yyn = yyrhsLength (yyy0->yyrule);
1539 yyn > 0;
1540 yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1)
1541 {
1542 if (yys0 == yys1)
1543 break;
1544 else if (yys0->yyresolved)
1545 {
1546 yys1->yyresolved = yytrue;
1547 yys1->yysemantics.yysval = yys0->yysemantics.yysval;
1548 }
1549 else if (yys1->yyresolved)
1550 {
1551 yys0->yyresolved = yytrue;
1552 yys0->yysemantics.yysval = yys1->yysemantics.yysval;
1553 }
1554 else
1555 {
1556 yySemanticOption** yyz0p;
1557 yySemanticOption* yyz1;
1558 yyz0p = &yys0->yysemantics.yyfirstVal;
1559 yyz1 = yys1->yysemantics.yyfirstVal;
1560 while (YYID (yytrue))
1561 {
1562 if (yyz1 == *yyz0p || yyz1 == NULL)
1563 break;
1564 else if (*yyz0p == NULL)
1565 {
1566 *yyz0p = yyz1;
1567 break;
1568 }
1569 else if (*yyz0p < yyz1)
1570 {
1571 yySemanticOption* yyz = *yyz0p;
1572 *yyz0p = yyz1;
1573 yyz1 = yyz1->yynext;
1574 (*yyz0p)->yynext = yyz;
1575 }
1576 yyz0p = &(*yyz0p)->yynext;
1577 }
1578 yys1->yysemantics.yyfirstVal = yys0->yysemantics.yyfirstVal;
1579 }
1580 }
1581 }
1582
1583 /** Y0 and Y1 represent two possible actions to take in a given
1584 * parsing state; return 0 if no combination is possible,
1585 * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */
1586 static int
1587 yypreference (yySemanticOption* y0, yySemanticOption* y1)
1588 {
1589 yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule;
1590 int p0 = yydprec[r0], p1 = yydprec[r1];
1591
1592 if (p0 == p1)
1593 {
1594 if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1])
1595 return 0;
1596 else
1597 return 1;
1598 }
1599 if (p0 == 0 || p1 == 0)
1600 return 0;
1601 if (p0 < p1)
1602 return 3;
1603 if (p1 < p0)
1604 return 2;
1605 return 0;
1606 }
1607
1608 static YYRESULTTAG yyresolveValue (yyGLRState* yys,
1609 yyGLRStack* yystackp]b4_user_formals[);
1610
1611
1612 /** Resolve the previous N states starting at and including state S. If result
1613 * != yyok, some states may have been left unresolved possibly with empty
1614 * semantic option chains. Regardless of whether result = yyok, each state
1615 * has been left with consistent data so that yydestroyGLRState can be invoked
1616 * if necessary. */
1617 static YYRESULTTAG
1618 yyresolveStates (yyGLRState* yys, int yyn,
1619 yyGLRStack* yystackp]b4_user_formals[)
1620 {
1621 if (0 < yyn)
1622 {
1623 YYASSERT (yys->yypred);
1624 YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[));
1625 if (! yys->yyresolved)
1626 YYCHK (yyresolveValue (yys, yystackp]b4_user_args[));
1627 }
1628 return yyok;
1629 }
1630
1631 /** Resolve the states for the RHS of OPT, perform its user action, and return
1632 * the semantic value and location. Regardless of whether result = yyok, all
1633 * RHS states have been destroyed (assuming the user action destroys all RHS
1634 * semantic values if invoked). */
1635 static YYRESULTTAG
1636 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
1637 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
1638 {
1639 yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
1640 int yynrhs;
1641 int yychar_current;
1642 YYSTYPE yylval_current;
1643 YYLTYPE yylloc_current;
1644 YYRESULTTAG yyflag;
1645
1646 yynrhs = yyrhsLength (yyopt->yyrule);
1647 yyflag = yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[);
1648 if (yyflag != yyok)
1649 {
1650 yyGLRState *yys;
1651 for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1)
1652 yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
1653 return yyflag;
1654 }
1655
1656 yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_locations_if([[
1657 if (yynrhs == 0)
1658 /* Set default location. */
1659 yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[
1660 yychar_current = yychar;
1661 yylval_current = yylval;
1662 yylloc_current = yylloc;
1663 yychar = yyopt->yyrawchar;
1664 yylval = yyopt->yyval;
1665 yylloc = yyopt->yyloc;
1666 yyflag = yyuserAction (yyopt->yyrule, yynrhs,
1667 yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
1668 yyvalp, yylocp, yystackp]b4_user_args[);
1669 yychar = yychar_current;
1670 yylval = yylval_current;
1671 yylloc = yylloc_current;
1672 return yyflag;
1673 }
1674
1675 #if YYDEBUG
1676 static void
1677 yyreportTree (yySemanticOption* yyx, int yyindent)
1678 {
1679 int yynrhs = yyrhsLength (yyx->yyrule);
1680 int yyi;
1681 yyGLRState* yys;
1682 yyGLRState* yystates[1 + YYMAXRHS];
1683 yyGLRState yyleftmost_state;
1684
1685 for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred)
1686 yystates[yyi] = yys;
1687 if (yys == NULL)
1688 {
1689 yyleftmost_state.yyposn = 0;
1690 yystates[0] = &yyleftmost_state;
1691 }
1692 else
1693 yystates[0] = yys;
1694
1695 if (yyx->yystate->yyposn < yys->yyposn + 1)
1696 YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n",
1697 yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
1698 yyx->yyrule - 1);
1699 else
1700 YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n",
1701 yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
1702 yyx->yyrule - 1, (unsigned long int) (yys->yyposn + 1),
1703 (unsigned long int) yyx->yystate->yyposn);
1704 for (yyi = 1; yyi <= yynrhs; yyi += 1)
1705 {
1706 if (yystates[yyi]->yyresolved)
1707 {
1708 if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn)
1709 YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "",
1710 yytokenName (yystos[yystates[yyi-1]->yylrState]));
1711 else
1712 YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "",
1713 yytokenName (yystos[yystates[yyi-1]->yylrState]),
1714 (unsigned long int) (yystates[yyi-1]->yyposn + 1),
1715 (unsigned long int) yystates[yyi]->yyposn);
1716 }
1717 else
1718 yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2);
1719 }
1720 }
1721 #endif
1722
1723 /*ARGSUSED*/ static YYRESULTTAG
1724 yyreportAmbiguity (yySemanticOption* yyx0,
1725 yySemanticOption* yyx1]b4_pure_formals[)
1726 {
1727 YYUSE (yyx0);
1728 YYUSE (yyx1);
1729
1730 #if YYDEBUG
1731 YYFPRINTF (stderr, "Ambiguity detected.\n");
1732 YYFPRINTF (stderr, "Option 1,\n");
1733 yyreportTree (yyx0, 2);
1734 YYFPRINTF (stderr, "\nOption 2,\n");
1735 yyreportTree (yyx1, 2);
1736 YYFPRINTF (stderr, "\n");
1737 #endif
1738
1739 yyerror (]b4_yyerror_args[YY_("syntax is ambiguous"));
1740 return yyabort;
1741 }
1742
1743 /** Starting at and including state S1, resolve the location for each of the
1744 * previous N1 states that is unresolved. The first semantic option of a state
1745 * is always chosen. */
1746 static void
1747 yyresolveLocations (yyGLRState* yys1, int yyn1,
1748 yyGLRStack *yystackp]b4_user_formals[)
1749 {
1750 if (0 < yyn1)
1751 {
1752 yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[);
1753 if (!yys1->yyresolved)
1754 {
1755 yySemanticOption *yyoption;
1756 yyGLRStackItem yyrhsloc[1 + YYMAXRHS];
1757 int yynrhs;
1758 int yychar_current;
1759 YYSTYPE yylval_current;
1760 YYLTYPE yylloc_current;
1761 yyoption = yys1->yysemantics.yyfirstVal;
1762 YYASSERT (yyoption != NULL);
1763 yynrhs = yyrhsLength (yyoption->yyrule);
1764 if (yynrhs > 0)
1765 {
1766 yyGLRState *yys;
1767 int yyn;
1768 yyresolveLocations (yyoption->yystate, yynrhs,
1769 yystackp]b4_user_args[);
1770 for (yys = yyoption->yystate, yyn = yynrhs;
1771 yyn > 0;
1772 yys = yys->yypred, yyn -= 1)
1773 yyrhsloc[yyn].yystate.yyloc = yys->yyloc;
1774 }
1775 else
1776 {
1777 /* Both yyresolveAction and yyresolveLocations traverse the GSS
1778 in reverse rightmost order. It is only necessary to invoke
1779 yyresolveLocations on a subforest for which yyresolveAction
1780 would have been invoked next had an ambiguity not been
1781 detected. Thus the location of the previous state (but not
1782 necessarily the previous state itself) is guaranteed to be
1783 resolved already. */
1784 yyGLRState *yyprevious = yyoption->yystate;
1785 yyrhsloc[0].yystate.yyloc = yyprevious->yyloc;
1786 }
1787 yychar_current = yychar;
1788 yylval_current = yylval;
1789 yylloc_current = yylloc;
1790 yychar = yyoption->yyrawchar;
1791 yylval = yyoption->yyval;
1792 yylloc = yyoption->yyloc;
1793 YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs);
1794 yychar = yychar_current;
1795 yylval = yylval_current;
1796 yylloc = yylloc_current;
1797 }
1798 }
1799 }
1800
1801 /** Resolve the ambiguity represented in state S, perform the indicated
1802 * actions, and set the semantic value of S. If result != yyok, the chain of
1803 * semantic options in S has been cleared instead or it has been left
1804 * unmodified except that redundant options may have been removed. Regardless
1805 * of whether result = yyok, S has been left with consistent data so that
1806 * yydestroyGLRState can be invoked if necessary. */
1807 static YYRESULTTAG
1808 yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
1809 {
1810 yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal;
1811 yySemanticOption* yybest;
1812 yySemanticOption** yypp;
1813 yybool yymerge;
1814 YYSTYPE yysval;
1815 YYRESULTTAG yyflag;
1816 YYLTYPE *yylocp = &yys->yyloc;
1817
1818 yybest = yyoptionList;
1819 yymerge = yyfalse;
1820 for (yypp = &yyoptionList->yynext; *yypp != NULL; )
1821 {
1822 yySemanticOption* yyp = *yypp;
1823
1824 if (yyidenticalOptions (yybest, yyp))
1825 {
1826 yymergeOptionSets (yybest, yyp);
1827 *yypp = yyp->yynext;
1828 }
1829 else
1830 {
1831 switch (yypreference (yybest, yyp))
1832 {
1833 case 0:
1834 yyresolveLocations (yys, 1, yystackp]b4_user_args[);
1835 return yyreportAmbiguity (yybest, yyp]b4_pure_args[);
1836 break;
1837 case 1:
1838 yymerge = yytrue;
1839 break;
1840 case 2:
1841 break;
1842 case 3:
1843 yybest = yyp;
1844 yymerge = yyfalse;
1845 break;
1846 default:
1847 /* This cannot happen so it is not worth a YYASSERT (yyfalse),
1848 but some compilers complain if the default case is
1849 omitted. */
1850 break;
1851 }
1852 yypp = &yyp->yynext;
1853 }
1854 }
1855
1856 if (yymerge)
1857 {
1858 yySemanticOption* yyp;
1859 int yyprec = yydprec[yybest->yyrule];
1860 yyflag = yyresolveAction (yybest, yystackp, &yysval,
1861 yylocp]b4_user_args[);
1862 if (yyflag == yyok)
1863 for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
1864 {
1865 if (yyprec == yydprec[yyp->yyrule])
1866 {
1867 YYSTYPE yysval_other;
1868 YYLTYPE yydummy;
1869 yyflag = yyresolveAction (yyp, yystackp, &yysval_other,
1870 &yydummy]b4_user_args[);
1871 if (yyflag != yyok)
1872 {
1873 yydestruct ("Cleanup: discarding incompletely merged value for",
1874 yystos[yys->yylrState],
1875 &yysval]b4_locations_if([, yylocp])[]b4_user_args[);
1876 break;
1877 }
1878 yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other);
1879 }
1880 }
1881 }
1882 else
1883 yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[);
1884
1885 if (yyflag == yyok)
1886 {
1887 yys->yyresolved = yytrue;
1888 yys->yysemantics.yysval = yysval;
1889 }
1890 else
1891 yys->yysemantics.yyfirstVal = NULL;
1892 return yyflag;
1893 }
1894
1895 static YYRESULTTAG
1896 yyresolveStack (yyGLRStack* yystackp]b4_user_formals[)
1897 {
1898 if (yystackp->yysplitPoint != NULL)
1899 {
1900 yyGLRState* yys;
1901 int yyn;
1902
1903 for (yyn = 0, yys = yystackp->yytops.yystates[0];
1904 yys != yystackp->yysplitPoint;
1905 yys = yys->yypred, yyn += 1)
1906 continue;
1907 YYCHK (yyresolveStates (yystackp->yytops.yystates[0], yyn, yystackp
1908 ]b4_user_args[));
1909 }
1910 return yyok;
1911 }
1912
1913 static void
1914 yycompressStack (yyGLRStack* yystackp)
1915 {
1916 yyGLRState* yyp, *yyq, *yyr;
1917
1918 if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == NULL)
1919 return;
1920
1921 for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = NULL;
1922 yyp != yystackp->yysplitPoint;
1923 yyr = yyp, yyp = yyq, yyq = yyp->yypred)
1924 yyp->yypred = yyr;
1925
1926 yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems;
1927 yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1;
1928 yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems;
1929 yystackp->yysplitPoint = NULL;
1930 yystackp->yylastDeleted = NULL;
1931
1932 while (yyr != NULL)
1933 {
1934 yystackp->yynextFree->yystate = *yyr;
1935 yyr = yyr->yypred;
1936 yystackp->yynextFree->yystate.yypred = &yystackp->yynextFree[-1].yystate;
1937 yystackp->yytops.yystates[0] = &yystackp->yynextFree->yystate;
1938 yystackp->yynextFree += 1;
1939 yystackp->yyspaceLeft -= 1;
1940 }
1941 }
1942
1943 static YYRESULTTAG
1944 yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
1945 size_t yyposn]b4_pure_formals[)
1946 {
1947 int yyaction;
1948 const short int* yyconflicts;
1949 yyRuleNum yyrule;
1950
1951 while (yystackp->yytops.yystates[yyk] != NULL)
1952 {
1953 yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState;
1954 YYDPRINTF ((stderr, "Stack %lu Entering state %d\n",
1955 (unsigned long int) yyk, yystate));
1956
1957 YYASSERT (yystate != YYFINAL);
1958
1959 if (yyisDefaultedState (yystate))
1960 {
1961 yyrule = yydefaultAction (yystate);
1962 if (yyrule == 0)
1963 {
1964 YYDPRINTF ((stderr, "Stack %lu dies.\n",
1965 (unsigned long int) yyk));
1966 yymarkStackDeleted (yystackp, yyk);
1967 return yyok;
1968 }
1969 YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse]b4_user_args[));
1970 }
1971 else
1972 {
1973 yySymbol yytoken;
1974 yystackp->yytops.yylookaheadNeeds[yyk] = yytrue;
1975 if (yychar == YYEMPTY)
1976 {
1977 YYDPRINTF ((stderr, "Reading a token: "));
1978 yychar = YYLEX;
1979 }
1980
1981 if (yychar <= YYEOF)
1982 {
1983 yychar = yytoken = YYEOF;
1984 YYDPRINTF ((stderr, "Now at end of input.\n"));
1985 }
1986 else
1987 {
1988 yytoken = YYTRANSLATE (yychar);
1989 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1990 }
1991
1992 yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
1993
1994 while (*yyconflicts != 0)
1995 {
1996 size_t yynewStack = yysplitStack (yystackp, yyk);
1997 YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n",
1998 (unsigned long int) yynewStack,
1999 (unsigned long int) yyk));
2000 YYCHK (yyglrReduce (yystackp, yynewStack,
2001 *yyconflicts, yyfalse]b4_user_args[));
2002 YYCHK (yyprocessOneStack (yystackp, yynewStack,
2003 yyposn]b4_pure_args[));
2004 yyconflicts += 1;
2005 }
2006
2007 if (yyisShiftAction (yyaction))
2008 break;
2009 else if (yyisErrorAction (yyaction))
2010 {
2011 YYDPRINTF ((stderr, "Stack %lu dies.\n",
2012 (unsigned long int) yyk));
2013 yymarkStackDeleted (yystackp, yyk);
2014 break;
2015 }
2016 else
2017 YYCHK (yyglrReduce (yystackp, yyk, -yyaction,
2018 yyfalse]b4_user_args[));
2019 }
2020 }
2021 return yyok;
2022 }
2023
2024 /*ARGSUSED*/ static void
2025 yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
2026 {
2027 if (yystackp->yyerrState == 0)
2028 {
2029 #if YYERROR_VERBOSE
2030 int yyn;
2031 yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
2032 if (YYPACT_NINF < yyn && yyn <= YYLAST)
2033 {
2034 yySymbol yytoken = YYTRANSLATE (yychar);
2035 size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
2036 size_t yysize = yysize0;
2037 size_t yysize1;
2038 yybool yysize_overflow = yyfalse;
2039 char* yymsg = NULL;
2040 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2041 /* Internationalized format string. */
2042 const char *yyformat = 0;
2043 /* Arguments of yyformat. */
2044 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2045
2046 /* Start YYX at -YYN if negative to avoid negative indexes in
2047 YYCHECK. In other words, skip the first -YYN actions for this
2048 state because they are default actions. */
2049 int yyxbegin = yyn < 0 ? -yyn : 0;
2050
2051 /* Stay within bounds of both yycheck and yytname. */
2052 int yychecklim = YYLAST - yyn + 1;
2053 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2054
2055 /* Number of reported tokens (one for the "unexpected", one per
2056 "expected"). */
2057 int yycount = 0;
2058 int yyx;
2059
2060 yyarg[yycount++] = yytokenName (yytoken);
2061
2062 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2063 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
2064 && !yyis_table_ninf (yytable[yyx + yyn]))
2065 {
2066 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2067 {
2068 yycount = 1;
2069 yysize = yysize0;
2070 break;
2071 }
2072 yyarg[yycount++] = yytokenName (yyx);
2073 yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx));
2074 yysize_overflow |= yysize1 < yysize;
2075 yysize = yysize1;
2076 }
2077
2078 switch (yycount)
2079 {
2080 #define YYCASE_(N, S) \
2081 case N: \
2082 yyformat = S; \
2083 break
2084 YYCASE_(1, YY_("syntax error, unexpected %s"));
2085 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
2086 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
2087 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
2088 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
2089 #undef YYCASE_
2090 }
2091
2092 yysize1 = yysize + strlen (yyformat);
2093 yysize_overflow |= yysize1 < yysize;
2094 yysize = yysize1;
2095
2096 if (!yysize_overflow)
2097 yymsg = (char *) YYMALLOC (yysize);
2098
2099 if (yymsg)
2100 {
2101 char *yyp = yymsg;
2102 int yyi = 0;
2103 while ((*yyp = *yyformat))
2104 {
2105 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
2106 {
2107 yyp += yytnamerr (yyp, yyarg[yyi++]);
2108 yyformat += 2;
2109 }
2110 else
2111 {
2112 yyp++;
2113 yyformat++;
2114 }
2115 }
2116 yyerror (]b4_lyyerror_args[yymsg);
2117 YYFREE (yymsg);
2118 }
2119 else
2120 {
2121 yyerror (]b4_lyyerror_args[YY_("syntax error"));
2122 yyMemoryExhausted (yystackp);
2123 }
2124 }
2125 else
2126 #endif /* YYERROR_VERBOSE */
2127 yyerror (]b4_lyyerror_args[YY_("syntax error"));
2128 yynerrs += 1;
2129 }
2130 }
2131
2132 /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
2133 yylval, and yylloc are the syntactic category, semantic value, and location
2134 of the lookahead. */
2135 /*ARGSUSED*/ static void
2136 yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
2137 {
2138 size_t yyk;
2139 int yyj;
2140
2141 if (yystackp->yyerrState == 3)
2142 /* We just shifted the error token and (perhaps) took some
2143 reductions. Skip tokens until we can proceed. */
2144 while (YYID (yytrue))
2145 {
2146 yySymbol yytoken;
2147 if (yychar == YYEOF)
2148 yyFail (yystackp][]b4_lpure_args[, NULL);
2149 if (yychar != YYEMPTY)
2150 {]b4_locations_if([[
2151 /* We throw away the lookahead, but the error range
2152 of the shifted error token must take it into account. */
2153 yyGLRState *yys = yystackp->yytops.yystates[0];
2154 yyGLRStackItem yyerror_range[3];
2155 yyerror_range[1].yystate.yyloc = yys->yyloc;
2156 yyerror_range[2].yystate.yyloc = yylloc;
2157 YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[
2158 yytoken = YYTRANSLATE (yychar);
2159 yydestruct ("Error: discarding",
2160 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
2161 }
2162 YYDPRINTF ((stderr, "Reading a token: "));
2163 yychar = YYLEX;
2164 if (yychar <= YYEOF)
2165 {
2166 yychar = yytoken = YYEOF;
2167 YYDPRINTF ((stderr, "Now at end of input.\n"));
2168 }
2169 else
2170 {
2171 yytoken = YYTRANSLATE (yychar);
2172 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2173 }
2174 yyj = yypact[yystackp->yytops.yystates[0]->yylrState];
2175 if (yyis_pact_ninf (yyj))
2176 return;
2177 yyj += yytoken;
2178 if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken)
2179 {
2180 if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0)
2181 return;
2182 }
2183 else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj]))
2184 return;
2185 }
2186
2187 /* Reduce to one stack. */
2188 for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1)
2189 if (yystackp->yytops.yystates[yyk] != NULL)
2190 break;
2191 if (yyk >= yystackp->yytops.yysize)
2192 yyFail (yystackp][]b4_lpure_args[, NULL);
2193 for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1)
2194 yymarkStackDeleted (yystackp, yyk);
2195 yyremoveDeletes (yystackp);
2196 yycompressStack (yystackp);
2197
2198 /* Now pop stack until we find a state that shifts the error token. */
2199 yystackp->yyerrState = 3;
2200 while (yystackp->yytops.yystates[0] != NULL)
2201 {
2202 yyGLRState *yys = yystackp->yytops.yystates[0];
2203 yyj = yypact[yys->yylrState];
2204 if (! yyis_pact_ninf (yyj))
2205 {
2206 yyj += YYTERROR;
2207 if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
2208 && yyisShiftAction (yytable[yyj]))
2209 {
2210 /* Shift the error token having adjusted its location. */
2211 YYLTYPE yyerrloc;]b4_locations_if([[
2212 yystackp->yyerror_range[2].yystate.yyloc = yylloc;
2213 YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[
2214 YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
2215 &yylval, &yyerrloc);
2216 yyglrShift (yystackp, 0, yytable[yyj],
2217 yys->yyposn, &yylval, &yyerrloc);
2218 yys = yystackp->yytops.yystates[0];
2219 break;
2220 }
2221 }
2222 ]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
2223 if (yys->yypred != NULL)
2224 yydestroyGLRState ("Error: popping", yys]b4_user_args[);
2225 yystackp->yytops.yystates[0] = yys->yypred;
2226 yystackp->yynextFree -= 1;
2227 yystackp->yyspaceLeft += 1;
2228 }
2229 if (yystackp->yytops.yystates[0] == NULL)
2230 yyFail (yystackp][]b4_lpure_args[, NULL);
2231 }
2232
2233 #define YYCHK1(YYE) \
2234 do { \
2235 switch (YYE) { \
2236 case yyok: \
2237 break; \
2238 case yyabort: \
2239 goto yyabortlab; \
2240 case yyaccept: \
2241 goto yyacceptlab; \
2242 case yyerr: \
2243 goto yyuser_error; \
2244 default: \
2245 goto yybuglab; \
2246 } \
2247 } while (YYID (0))
2248
2249
2250 /*----------.
2251 | yyparse. |
2252 `----------*/
2253
2254 ]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[
2255 {
2256 int yyresult;
2257 yyGLRStack yystack;
2258 yyGLRStack* const yystackp = &yystack;
2259 size_t yyposn;
2260
2261 YYDPRINTF ((stderr, "Starting parse\n"));
2262
2263 yychar = YYEMPTY;
2264 yylval = yyval_default;
2265 ]b4_locations_if([
2266 #if YYLTYPE_IS_TRIVIAL
2267 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
2268 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
2269 #endif
2270 ])
2271 m4_ifdef([b4_initial_action], [
2272 m4_pushdef([b4_at_dollar], [yylloc])dnl
2273 m4_pushdef([b4_dollar_dollar], [yylval])dnl
2274 /* User initialization code. */
2275 b4_user_initial_action
2276 m4_popdef([b4_dollar_dollar])dnl
2277 m4_popdef([b4_at_dollar])])dnl
2278 [
2279 if (! yyinitGLRStack (yystackp, YYINITDEPTH))
2280 goto yyexhaustedlab;
2281 switch (YYSETJMP (yystack.yyexception_buffer))
2282 {
2283 case 0: break;
2284 case 1: goto yyabortlab;
2285 case 2: goto yyexhaustedlab;
2286 default: goto yybuglab;
2287 }
2288 yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc);
2289 yyposn = 0;
2290
2291 while (YYID (yytrue))
2292 {
2293 /* For efficiency, we have two loops, the first of which is
2294 specialized to deterministic operation (single stack, no
2295 potential ambiguity). */
2296 /* Standard mode */
2297 while (YYID (yytrue))
2298 {
2299 yyRuleNum yyrule;
2300 int yyaction;
2301 const short int* yyconflicts;
2302
2303 yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;
2304 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2305 if (yystate == YYFINAL)
2306 goto yyacceptlab;
2307 if (yyisDefaultedState (yystate))
2308 {
2309 yyrule = yydefaultAction (yystate);
2310 if (yyrule == 0)
2311 {
2312 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2313 yyreportSyntaxError (&yystack]b4_user_args[);
2314 goto yyuser_error;
2315 }
2316 YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[));
2317 }
2318 else
2319 {
2320 yySymbol yytoken;
2321 if (yychar == YYEMPTY)
2322 {
2323 YYDPRINTF ((stderr, "Reading a token: "));
2324 yychar = YYLEX;
2325 }
2326
2327 if (yychar <= YYEOF)
2328 {
2329 yychar = yytoken = YYEOF;
2330 YYDPRINTF ((stderr, "Now at end of input.\n"));
2331 }
2332 else
2333 {
2334 yytoken = YYTRANSLATE (yychar);
2335 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2336 }
2337
2338 yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
2339 if (*yyconflicts != 0)
2340 break;
2341 if (yyisShiftAction (yyaction))
2342 {
2343 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2344 yychar = YYEMPTY;
2345 yyposn += 1;
2346 yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc);
2347 if (0 < yystack.yyerrState)
2348 yystack.yyerrState -= 1;
2349 }
2350 else if (yyisErrorAction (yyaction))
2351 {
2352 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2353 yyreportSyntaxError (&yystack]b4_user_args[);
2354 goto yyuser_error;
2355 }
2356 else
2357 YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[));
2358 }
2359 }
2360
2361 while (YYID (yytrue))
2362 {
2363 yySymbol yytoken_to_shift;
2364 size_t yys;
2365
2366 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2367 yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY;
2368
2369 /* yyprocessOneStack returns one of three things:
2370
2371 - An error flag. If the caller is yyprocessOneStack, it
2372 immediately returns as well. When the caller is finally
2373 yyparse, it jumps to an error label via YYCHK1.
2374
2375 - yyok, but yyprocessOneStack has invoked yymarkStackDeleted
2376 (&yystack, yys), which sets the top state of yys to NULL. Thus,
2377 yyparse's following invocation of yyremoveDeletes will remove
2378 the stack.
2379
2380 - yyok, when ready to shift a token.
2381
2382 Except in the first case, yyparse will invoke yyremoveDeletes and
2383 then shift the next token onto all remaining stacks. This
2384 synchronization of the shift (that is, after all preceding
2385 reductions on all stacks) helps prevent double destructor calls
2386 on yylval in the event of memory exhaustion. */
2387
2388 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2389 YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[));
2390 yyremoveDeletes (&yystack);
2391 if (yystack.yytops.yysize == 0)
2392 {
2393 yyundeleteLastStack (&yystack);
2394 if (yystack.yytops.yysize == 0)
2395 yyFail (&yystack][]b4_lpure_args[, YY_("syntax error"));
2396 YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
2397 YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
2398 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2399 yyreportSyntaxError (&yystack]b4_user_args[);
2400 goto yyuser_error;
2401 }
2402
2403 /* If any yyglrShift call fails, it will fail after shifting. Thus,
2404 a copy of yylval will already be on stack 0 in the event of a
2405 failure in the following loop. Thus, yychar is set to YYEMPTY
2406 before the loop to make sure the user destructor for yylval isn't
2407 called twice. */
2408 yytoken_to_shift = YYTRANSLATE (yychar);
2409 yychar = YYEMPTY;
2410 yyposn += 1;
2411 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2412 {
2413 int yyaction;
2414 const short int* yyconflicts;
2415 yyStateNum yystate = yystack.yytops.yystates[yys]->yylrState;
2416 yygetLRActions (yystate, yytoken_to_shift, &yyaction,
2417 &yyconflicts);
2418 /* Note that yyconflicts were handled by yyprocessOneStack. */
2419 YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys));
2420 YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc);
2421 yyglrShift (&yystack, yys, yyaction, yyposn,
2422 &yylval, &yylloc);
2423 YYDPRINTF ((stderr, "Stack %lu now in state #%d\n",
2424 (unsigned long int) yys,
2425 yystack.yytops.yystates[yys]->yylrState));
2426 }
2427
2428 if (yystack.yytops.yysize == 1)
2429 {
2430 YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
2431 YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
2432 yycompressStack (&yystack);
2433 break;
2434 }
2435 }
2436 continue;
2437 yyuser_error:
2438 yyrecoverSyntaxError (&yystack]b4_user_args[);
2439 yyposn = yystack.yytops.yystates[0]->yyposn;
2440 }
2441
2442 yyacceptlab:
2443 yyresult = 0;
2444 goto yyreturn;
2445
2446 yybuglab:
2447 YYASSERT (yyfalse);
2448 goto yyabortlab;
2449
2450 yyabortlab:
2451 yyresult = 1;
2452 goto yyreturn;
2453
2454 yyexhaustedlab:
2455 yyerror (]b4_lyyerror_args[YY_("memory exhausted"));
2456 yyresult = 2;
2457 goto yyreturn;
2458
2459 yyreturn:
2460 if (yychar != YYEMPTY)
2461 yydestruct ("Cleanup: discarding lookahead",
2462 YYTRANSLATE (yychar),
2463 &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
2464
2465 /* If the stack is well-formed, pop the stack until it is empty,
2466 destroying its entries as we go. But free the stack regardless
2467 of whether it is well-formed. */
2468 if (yystack.yyitems)
2469 {
2470 yyGLRState** yystates = yystack.yytops.yystates;
2471 if (yystates)
2472 {
2473 size_t yysize = yystack.yytops.yysize;
2474 size_t yyk;
2475 for (yyk = 0; yyk < yysize; yyk += 1)
2476 if (yystates[yyk])
2477 {
2478 while (yystates[yyk])
2479 {
2480 yyGLRState *yys = yystates[yyk];
2481 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]]
2482 )[ if (yys->yypred != NULL)
2483 yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
2484 yystates[yyk] = yys->yypred;
2485 yystack.yynextFree -= 1;
2486 yystack.yyspaceLeft += 1;
2487 }
2488 break;
2489 }
2490 }
2491 yyfreeGLRStack (&yystack);
2492 }
2493
2494 /* Make sure YYID is used. */
2495 return YYID (yyresult);
2496 }
2497
2498 /* DEBUGGING ONLY */
2499 #if YYDEBUG
2500 static void yypstack (yyGLRStack* yystackp, size_t yyk)
2501 __attribute__ ((__unused__));
2502 static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__));
2503
2504 static void
2505 yy_yypstack (yyGLRState* yys)
2506 {
2507 if (yys->yypred)
2508 {
2509 yy_yypstack (yys->yypred);
2510 YYFPRINTF (stderr, " -> ");
2511 }
2512 YYFPRINTF (stderr, "%d@@%lu", yys->yylrState,
2513 (unsigned long int) yys->yyposn);
2514 }
2515
2516 static void
2517 yypstates (yyGLRState* yyst)
2518 {
2519 if (yyst == NULL)
2520 YYFPRINTF (stderr, "<null>");
2521 else
2522 yy_yypstack (yyst);
2523 YYFPRINTF (stderr, "\n");
2524 }
2525
2526 static void
2527 yypstack (yyGLRStack* yystackp, size_t yyk)
2528 {
2529 yypstates (yystackp->yytops.yystates[yyk]);
2530 }
2531
2532 #define YYINDEX(YYX) \
2533 ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems)
2534
2535
2536 static void
2537 yypdumpstack (yyGLRStack* yystackp)
2538 {
2539 yyGLRStackItem* yyp;
2540 size_t yyi;
2541 for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1)
2542 {
2543 YYFPRINTF (stderr, "%3lu. ",
2544 (unsigned long int) (yyp - yystackp->yyitems));
2545 if (*(yybool *) yyp)
2546 {
2547 YYFPRINTF (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
2548 yyp->yystate.yyresolved, yyp->yystate.yylrState,
2549 (unsigned long int) yyp->yystate.yyposn,
2550 (long int) YYINDEX (yyp->yystate.yypred));
2551 if (! yyp->yystate.yyresolved)
2552 YYFPRINTF (stderr, ", firstVal: %ld",
2553 (long int) YYINDEX (yyp->yystate
2554 .yysemantics.yyfirstVal));
2555 }
2556 else
2557 {
2558 YYFPRINTF (stderr, "Option. rule: %d, state: %ld, next: %ld",
2559 yyp->yyoption.yyrule - 1,
2560 (long int) YYINDEX (yyp->yyoption.yystate),
2561 (long int) YYINDEX (yyp->yyoption.yynext));
2562 }
2563 YYFPRINTF (stderr, "\n");
2564 }
2565 YYFPRINTF (stderr, "Tops:");
2566 for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
2567 YYFPRINTF (stderr, "%lu: %ld; ", (unsigned long int) yyi,
2568 (long int) YYINDEX (yystackp->yytops.yystates[yyi]));
2569 YYFPRINTF (stderr, "\n");
2570 }
2571 #endif
2572 ]b4_epilogue[]dnl
2573 dnl
2574 dnl glr.cc produces its own header.
2575 dnl
2576 m4_if(b4_skeleton, ["glr.c"],
2577 [b4_defines_if(
2578 [@output(b4_spec_defines_file@)@
2579 b4_copyright([Skeleton interface for Bison GLR parsers in C],
2580 [2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009])
2581
2582 b4_shared_declarations
2583
2584 b4_pure_if([],
2585 [[extern YYSTYPE ]b4_prefix[lval;]])
2586
2587 b4_locations_if([b4_pure_if([],
2588 [extern YYLTYPE ]b4_prefix[lloc;])
2589 ])
2590 ])])[]dnl
2591 m4_divert_pop(0)
bison