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