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


9cabf622190afa56612b56cfe59371222fd0943c
[bison.git] / data / glr.c
1 -*- C -*-
2
3 # GLR skeleton for Bison
4 # Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008 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_flag[
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_flag[
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,
1370 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
1371 {
1372 int yynrhs = yyrhsLength (yyrule);
1373 yybool yynormal __attribute__ ((__unused__)) =
1374 (yystackp->yysplitPoint == NULL);
1375 yyGLRStackItem* yyvsp = (yyGLRStackItem*) yystackp->yytops.yystates[yyk];
1376 int yylow = 1;
1377 int yyi;
1378 YYUSE (yyvalp);
1379 YYUSE (yylocp);
1380 ]b4_parse_param_use[]dnl
1381 [ YYFPRINTF (stderr, "Reducing stack %lu by rule %d (line %lu):\n",
1382 (unsigned long int) yyk, yyrule - 1,
1383 (unsigned long int) yyrline[yyrule]);
1384 /* The symbols being reduced. */
1385 for (yyi = 0; yyi < yynrhs; yyi++)
1386 {
1387 YYFPRINTF (stderr, " $%d = ", yyi + 1);
1388 yy_symbol_print (stderr,
1389 ]yystos@{b4_rhs_data(yynrhs, yyi + 1).yylrState@}[,
1390 &]b4_rhs_value(yynrhs, yyi + 1)[
1391 ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
1392 b4_user_args[);
1393 YYFPRINTF (stderr, "\n");
1394 }
1395 }
1396 #endif
1397
1398 /** Pop items off stack #K of STACK according to grammar rule RULE,
1399 * and push back on the resulting nonterminal symbol. Perform the
1400 * semantic action associated with RULE and store its value with the
1401 * newly pushed state, if FORCEEVAL or if STACK is currently
1402 * unambiguous. Otherwise, store the deferred semantic action with
1403 * the new state. If the new state would have an identical input
1404 * position, LR state, and predecessor to an existing state on the stack,
1405 * it is identified with that existing state, eliminating stack #K from
1406 * the STACK. In this case, the (necessarily deferred) semantic value is
1407 * added to the options for the existing state's semantic value.
1408 */
1409 static inline YYRESULTTAG
1410 yyglrReduce (yyGLRStack* yystackp, size_t yyk, yyRuleNum yyrule,
1411 yybool yyforceEval]b4_user_formals[)
1412 {
1413 size_t yyposn = yystackp->yytops.yystates[yyk]->yyposn;
1414
1415 if (yyforceEval || yystackp->yysplitPoint == NULL)
1416 {
1417 YYSTYPE yysval;
1418 YYLTYPE yyloc;
1419
1420 YY_REDUCE_PRINT ((yystackp, yyk, yyrule, &yysval, &yyloc]b4_user_args[));
1421 YYCHK (yydoAction (yystackp, yyk, yyrule, &yysval,
1422 &yyloc]b4_user_args[));
1423 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyrule], &yysval, &yyloc);
1424 yyglrShift (yystackp, yyk,
1425 yyLRgotoState (yystackp->yytops.yystates[yyk]->yylrState,
1426 yylhsNonterm (yyrule)),
1427 yyposn, &yysval, &yyloc);
1428 }
1429 else
1430 {
1431 size_t yyi;
1432 int yyn;
1433 yyGLRState* yys, *yys0 = yystackp->yytops.yystates[yyk];
1434 yyStateNum yynewLRState;
1435
1436 for (yys = yystackp->yytops.yystates[yyk], yyn = yyrhsLength (yyrule);
1437 0 < yyn; yyn -= 1)
1438 {
1439 yys = yys->yypred;
1440 YYASSERT (yys);
1441 }
1442 yyupdateSplit (yystackp, yys);
1443 yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
1444 YYDPRINTF ((stderr,
1445 "Reduced stack %lu by rule #%d; action deferred. Now in state %d.\n",
1446 (unsigned long int) yyk, yyrule - 1, yynewLRState));
1447 for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
1448 if (yyi != yyk && yystackp->yytops.yystates[yyi] != NULL)
1449 {
1450 yyGLRState* yyp, *yysplit = yystackp->yysplitPoint;
1451 yyp = yystackp->yytops.yystates[yyi];
1452 while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn)
1453 {
1454 if (yyp->yylrState == yynewLRState && yyp->yypred == yys)
1455 {
1456 yyaddDeferredAction (yystackp, yyk, yyp, yys0, yyrule);
1457 yymarkStackDeleted (yystackp, yyk);
1458 YYDPRINTF ((stderr, "Merging stack %lu into stack %lu.\n",
1459 (unsigned long int) yyk,
1460 (unsigned long int) yyi));
1461 return yyok;
1462 }
1463 yyp = yyp->yypred;
1464 }
1465 }
1466 yystackp->yytops.yystates[yyk] = yys;
1467 yyglrShiftDefer (yystackp, yyk, yynewLRState, yyposn, yys0, yyrule);
1468 }
1469 return yyok;
1470 }
1471
1472 static size_t
1473 yysplitStack (yyGLRStack* yystackp, size_t yyk)
1474 {
1475 if (yystackp->yysplitPoint == NULL)
1476 {
1477 YYASSERT (yyk == 0);
1478 yystackp->yysplitPoint = yystackp->yytops.yystates[yyk];
1479 }
1480 if (yystackp->yytops.yysize >= yystackp->yytops.yycapacity)
1481 {
1482 yyGLRState** yynewStates;
1483 yybool* yynewLookaheadNeeds;
1484
1485 yynewStates = NULL;
1486
1487 if (yystackp->yytops.yycapacity
1488 > (YYSIZEMAX / (2 * sizeof yynewStates[0])))
1489 yyMemoryExhausted (yystackp);
1490 yystackp->yytops.yycapacity *= 2;
1491
1492 yynewStates =
1493 (yyGLRState**) YYREALLOC (yystackp->yytops.yystates,
1494 (yystackp->yytops.yycapacity
1495 * sizeof yynewStates[0]));
1496 if (yynewStates == NULL)
1497 yyMemoryExhausted (yystackp);
1498 yystackp->yytops.yystates = yynewStates;
1499
1500 yynewLookaheadNeeds =
1501 (yybool*) YYREALLOC (yystackp->yytops.yylookaheadNeeds,
1502 (yystackp->yytops.yycapacity
1503 * sizeof yynewLookaheadNeeds[0]));
1504 if (yynewLookaheadNeeds == NULL)
1505 yyMemoryExhausted (yystackp);
1506 yystackp->yytops.yylookaheadNeeds = yynewLookaheadNeeds;
1507 }
1508 yystackp->yytops.yystates[yystackp->yytops.yysize]
1509 = yystackp->yytops.yystates[yyk];
1510 yystackp->yytops.yylookaheadNeeds[yystackp->yytops.yysize]
1511 = yystackp->yytops.yylookaheadNeeds[yyk];
1512 yystackp->yytops.yysize += 1;
1513 return yystackp->yytops.yysize-1;
1514 }
1515
1516 /** True iff Y0 and Y1 represent identical options at the top level.
1517 * That is, they represent the same rule applied to RHS symbols
1518 * that produce the same terminal symbols. */
1519 static yybool
1520 yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1)
1521 {
1522 if (yyy0->yyrule == yyy1->yyrule)
1523 {
1524 yyGLRState *yys0, *yys1;
1525 int yyn;
1526 for (yys0 = yyy0->yystate, yys1 = yyy1->yystate,
1527 yyn = yyrhsLength (yyy0->yyrule);
1528 yyn > 0;
1529 yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1)
1530 if (yys0->yyposn != yys1->yyposn)
1531 return yyfalse;
1532 return yytrue;
1533 }
1534 else
1535 return yyfalse;
1536 }
1537
1538 /** Assuming identicalOptions (Y0,Y1), destructively merge the
1539 * alternative semantic values for the RHS-symbols of Y1 and Y0. */
1540 static void
1541 yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1)
1542 {
1543 yyGLRState *yys0, *yys1;
1544 int yyn;
1545 for (yys0 = yyy0->yystate, yys1 = yyy1->yystate,
1546 yyn = yyrhsLength (yyy0->yyrule);
1547 yyn > 0;
1548 yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1)
1549 {
1550 if (yys0 == yys1)
1551 break;
1552 else if (yys0->yyresolved)
1553 {
1554 yys1->yyresolved = yytrue;
1555 yys1->yysemantics.yysval = yys0->yysemantics.yysval;
1556 }
1557 else if (yys1->yyresolved)
1558 {
1559 yys0->yyresolved = yytrue;
1560 yys0->yysemantics.yysval = yys1->yysemantics.yysval;
1561 }
1562 else
1563 {
1564 yySemanticOption** yyz0p;
1565 yySemanticOption* yyz1;
1566 yyz0p = &yys0->yysemantics.yyfirstVal;
1567 yyz1 = yys1->yysemantics.yyfirstVal;
1568 while (YYID (yytrue))
1569 {
1570 if (yyz1 == *yyz0p || yyz1 == NULL)
1571 break;
1572 else if (*yyz0p == NULL)
1573 {
1574 *yyz0p = yyz1;
1575 break;
1576 }
1577 else if (*yyz0p < yyz1)
1578 {
1579 yySemanticOption* yyz = *yyz0p;
1580 *yyz0p = yyz1;
1581 yyz1 = yyz1->yynext;
1582 (*yyz0p)->yynext = yyz;
1583 }
1584 yyz0p = &(*yyz0p)->yynext;
1585 }
1586 yys1->yysemantics.yyfirstVal = yys0->yysemantics.yyfirstVal;
1587 }
1588 }
1589 }
1590
1591 /** Y0 and Y1 represent two possible actions to take in a given
1592 * parsing state; return 0 if no combination is possible,
1593 * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */
1594 static int
1595 yypreference (yySemanticOption* y0, yySemanticOption* y1)
1596 {
1597 yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule;
1598 int p0 = yydprec[r0], p1 = yydprec[r1];
1599
1600 if (p0 == p1)
1601 {
1602 if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1])
1603 return 0;
1604 else
1605 return 1;
1606 }
1607 if (p0 == 0 || p1 == 0)
1608 return 0;
1609 if (p0 < p1)
1610 return 3;
1611 if (p1 < p0)
1612 return 2;
1613 return 0;
1614 }
1615
1616 static YYRESULTTAG yyresolveValue (yyGLRState* yys,
1617 yyGLRStack* yystackp]b4_user_formals[);
1618
1619
1620 /** Resolve the previous N states starting at and including state S. If result
1621 * != yyok, some states may have been left unresolved possibly with empty
1622 * semantic option chains. Regardless of whether result = yyok, each state
1623 * has been left with consistent data so that yydestroyGLRState can be invoked
1624 * if necessary. */
1625 static YYRESULTTAG
1626 yyresolveStates (yyGLRState* yys, int yyn,
1627 yyGLRStack* yystackp]b4_user_formals[)
1628 {
1629 if (0 < yyn)
1630 {
1631 YYASSERT (yys->yypred);
1632 YYCHK (yyresolveStates (yys->yypred, yyn-1, yystackp]b4_user_args[));
1633 if (! yys->yyresolved)
1634 YYCHK (yyresolveValue (yys, yystackp]b4_user_args[));
1635 }
1636 return yyok;
1637 }
1638
1639 /** Resolve the states for the RHS of OPT, perform its user action, and return
1640 * the semantic value and location. Regardless of whether result = yyok, all
1641 * RHS states have been destroyed (assuming the user action destroys all RHS
1642 * semantic values if invoked). */
1643 static YYRESULTTAG
1644 yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystackp,
1645 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
1646 {
1647 yyGLRStackItem yyrhsVals[YYMAXRHS + YYMAXLEFT + 1];
1648 int yynrhs;
1649 int yychar_current;
1650 YYSTYPE yylval_current;
1651 YYLTYPE yylloc_current;
1652 YYRESULTTAG yyflag;
1653
1654 yynrhs = yyrhsLength (yyopt->yyrule);
1655 yyflag = yyresolveStates (yyopt->yystate, yynrhs, yystackp]b4_user_args[);
1656 if (yyflag != yyok)
1657 {
1658 yyGLRState *yys;
1659 for (yys = yyopt->yystate; yynrhs > 0; yys = yys->yypred, yynrhs -= 1)
1660 yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
1661 return yyflag;
1662 }
1663
1664 yyrhsVals[YYMAXRHS + YYMAXLEFT].yystate.yypred = yyopt->yystate;]b4_locations_if([[
1665 if (yynrhs == 0)
1666 /* Set default location. */
1667 yyrhsVals[YYMAXRHS + YYMAXLEFT - 1].yystate.yyloc = yyopt->yystate->yyloc;]])[
1668 yychar_current = yychar;
1669 yylval_current = yylval;
1670 yylloc_current = yylloc;
1671 yychar = yyopt->yyrawchar;
1672 yylval = yyopt->yyval;
1673 yylloc = yyopt->yyloc;
1674 yyflag = yyuserAction (yyopt->yyrule, yynrhs,
1675 yyrhsVals + YYMAXRHS + YYMAXLEFT - 1,
1676 yyvalp, yylocp, yystackp]b4_user_args[);
1677 yychar = yychar_current;
1678 yylval = yylval_current;
1679 yylloc = yylloc_current;
1680 return yyflag;
1681 }
1682
1683 #if YYDEBUG
1684 static void
1685 yyreportTree (yySemanticOption* yyx, int yyindent)
1686 {
1687 int yynrhs = yyrhsLength (yyx->yyrule);
1688 int yyi;
1689 yyGLRState* yys;
1690 yyGLRState* yystates[1 + YYMAXRHS];
1691 yyGLRState yyleftmost_state;
1692
1693 for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred)
1694 yystates[yyi] = yys;
1695 if (yys == NULL)
1696 {
1697 yyleftmost_state.yyposn = 0;
1698 yystates[0] = &yyleftmost_state;
1699 }
1700 else
1701 yystates[0] = yys;
1702
1703 if (yyx->yystate->yyposn < yys->yyposn + 1)
1704 YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n",
1705 yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
1706 yyx->yyrule - 1);
1707 else
1708 YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n",
1709 yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
1710 yyx->yyrule - 1, (unsigned long int) (yys->yyposn + 1),
1711 (unsigned long int) yyx->yystate->yyposn);
1712 for (yyi = 1; yyi <= yynrhs; yyi += 1)
1713 {
1714 if (yystates[yyi]->yyresolved)
1715 {
1716 if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn)
1717 YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "",
1718 yytokenName (yystos[yystates[yyi-1]->yylrState]));
1719 else
1720 YYFPRINTF (stderr, "%*s%s <tokens %lu .. %lu>\n", yyindent+2, "",
1721 yytokenName (yystos[yystates[yyi-1]->yylrState]),
1722 (unsigned long int) (yystates[yyi-1]->yyposn + 1),
1723 (unsigned long int) yystates[yyi]->yyposn);
1724 }
1725 else
1726 yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2);
1727 }
1728 }
1729 #endif
1730
1731 /*ARGSUSED*/ static YYRESULTTAG
1732 yyreportAmbiguity (yySemanticOption* yyx0,
1733 yySemanticOption* yyx1]b4_pure_formals[)
1734 {
1735 YYUSE (yyx0);
1736 YYUSE (yyx1);
1737
1738 #if YYDEBUG
1739 YYFPRINTF (stderr, "Ambiguity detected.\n");
1740 YYFPRINTF (stderr, "Option 1,\n");
1741 yyreportTree (yyx0, 2);
1742 YYFPRINTF (stderr, "\nOption 2,\n");
1743 yyreportTree (yyx1, 2);
1744 YYFPRINTF (stderr, "\n");
1745 #endif
1746
1747 yyerror (]b4_yyerror_args[YY_("syntax is ambiguous"));
1748 return yyabort;
1749 }
1750
1751 /** Starting at and including state S1, resolve the location for each of the
1752 * previous N1 states that is unresolved. The first semantic option of a state
1753 * is always chosen. */
1754 static void
1755 yyresolveLocations (yyGLRState* yys1, int yyn1,
1756 yyGLRStack *yystackp]b4_user_formals[)
1757 {
1758 if (0 < yyn1)
1759 {
1760 yyresolveLocations (yys1->yypred, yyn1 - 1, yystackp]b4_user_args[);
1761 if (!yys1->yyresolved)
1762 {
1763 yySemanticOption *yyoption;
1764 yyGLRStackItem yyrhsloc[1 + YYMAXRHS];
1765 int yynrhs;
1766 int yychar_current;
1767 YYSTYPE yylval_current;
1768 YYLTYPE yylloc_current;
1769 yyoption = yys1->yysemantics.yyfirstVal;
1770 YYASSERT (yyoption != NULL);
1771 yynrhs = yyrhsLength (yyoption->yyrule);
1772 if (yynrhs > 0)
1773 {
1774 yyGLRState *yys;
1775 int yyn;
1776 yyresolveLocations (yyoption->yystate, yynrhs,
1777 yystackp]b4_user_args[);
1778 for (yys = yyoption->yystate, yyn = yynrhs;
1779 yyn > 0;
1780 yys = yys->yypred, yyn -= 1)
1781 yyrhsloc[yyn].yystate.yyloc = yys->yyloc;
1782 }
1783 else
1784 {
1785 /* Both yyresolveAction and yyresolveLocations traverse the GSS
1786 in reverse rightmost order. It is only necessary to invoke
1787 yyresolveLocations on a subforest for which yyresolveAction
1788 would have been invoked next had an ambiguity not been
1789 detected. Thus the location of the previous state (but not
1790 necessarily the previous state itself) is guaranteed to be
1791 resolved already. */
1792 yyGLRState *yyprevious = yyoption->yystate;
1793 yyrhsloc[0].yystate.yyloc = yyprevious->yyloc;
1794 }
1795 yychar_current = yychar;
1796 yylval_current = yylval;
1797 yylloc_current = yylloc;
1798 yychar = yyoption->yyrawchar;
1799 yylval = yyoption->yyval;
1800 yylloc = yyoption->yyloc;
1801 YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs);
1802 yychar = yychar_current;
1803 yylval = yylval_current;
1804 yylloc = yylloc_current;
1805 }
1806 }
1807 }
1808
1809 /** Resolve the ambiguity represented in state S, perform the indicated
1810 * actions, and set the semantic value of S. If result != yyok, the chain of
1811 * semantic options in S has been cleared instead or it has been left
1812 * unmodified except that redundant options may have been removed. Regardless
1813 * of whether result = yyok, S has been left with consistent data so that
1814 * yydestroyGLRState can be invoked if necessary. */
1815 static YYRESULTTAG
1816 yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
1817 {
1818 yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal;
1819 yySemanticOption* yybest;
1820 yySemanticOption** yypp;
1821 yybool yymerge;
1822 YYSTYPE yysval;
1823 YYRESULTTAG yyflag;
1824 YYLTYPE *yylocp = &yys->yyloc;
1825
1826 yybest = yyoptionList;
1827 yymerge = yyfalse;
1828 for (yypp = &yyoptionList->yynext; *yypp != NULL; )
1829 {
1830 yySemanticOption* yyp = *yypp;
1831
1832 if (yyidenticalOptions (yybest, yyp))
1833 {
1834 yymergeOptionSets (yybest, yyp);
1835 *yypp = yyp->yynext;
1836 }
1837 else
1838 {
1839 switch (yypreference (yybest, yyp))
1840 {
1841 case 0:
1842 yyresolveLocations (yys, 1, yystackp]b4_user_args[);
1843 return yyreportAmbiguity (yybest, yyp]b4_pure_args[);
1844 break;
1845 case 1:
1846 yymerge = yytrue;
1847 break;
1848 case 2:
1849 break;
1850 case 3:
1851 yybest = yyp;
1852 yymerge = yyfalse;
1853 break;
1854 default:
1855 /* This cannot happen so it is not worth a YYASSERT (yyfalse),
1856 but some compilers complain if the default case is
1857 omitted. */
1858 break;
1859 }
1860 yypp = &yyp->yynext;
1861 }
1862 }
1863
1864 if (yymerge)
1865 {
1866 yySemanticOption* yyp;
1867 int yyprec = yydprec[yybest->yyrule];
1868 yyflag = yyresolveAction (yybest, yystackp, &yysval,
1869 yylocp]b4_user_args[);
1870 if (yyflag == yyok)
1871 for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
1872 {
1873 if (yyprec == yydprec[yyp->yyrule])
1874 {
1875 YYSTYPE yysval_other;
1876 YYLTYPE yydummy;
1877 yyflag = yyresolveAction (yyp, yystackp, &yysval_other,
1878 &yydummy]b4_user_args[);
1879 if (yyflag != yyok)
1880 {
1881 yydestruct ("Cleanup: discarding incompletely merged value for",
1882 yystos[yys->yylrState],
1883 &yysval]b4_locations_if([, yylocp])[]b4_user_args[);
1884 break;
1885 }
1886 yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other);
1887 }
1888 }
1889 }
1890 else
1891 yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[);
1892
1893 if (yyflag == yyok)
1894 {
1895 yys->yyresolved = yytrue;
1896 yys->yysemantics.yysval = yysval;
1897 }
1898 else
1899 yys->yysemantics.yyfirstVal = NULL;
1900 return yyflag;
1901 }
1902
1903 static YYRESULTTAG
1904 yyresolveStack (yyGLRStack* yystackp]b4_user_formals[)
1905 {
1906 if (yystackp->yysplitPoint != NULL)
1907 {
1908 yyGLRState* yys;
1909 int yyn;
1910
1911 for (yyn = 0, yys = yystackp->yytops.yystates[0];
1912 yys != yystackp->yysplitPoint;
1913 yys = yys->yypred, yyn += 1)
1914 continue;
1915 YYCHK (yyresolveStates (yystackp->yytops.yystates[0], yyn, yystackp
1916 ]b4_user_args[));
1917 }
1918 return yyok;
1919 }
1920
1921 static void
1922 yycompressStack (yyGLRStack* yystackp)
1923 {
1924 yyGLRState* yyp, *yyq, *yyr;
1925
1926 if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == NULL)
1927 return;
1928
1929 for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = NULL;
1930 yyp != yystackp->yysplitPoint;
1931 yyr = yyp, yyp = yyq, yyq = yyp->yypred)
1932 yyp->yypred = yyr;
1933
1934 yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems;
1935 yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1;
1936 yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems;
1937 yystackp->yysplitPoint = NULL;
1938 yystackp->yylastDeleted = NULL;
1939
1940 while (yyr != NULL)
1941 {
1942 yystackp->yynextFree->yystate = *yyr;
1943 yyr = yyr->yypred;
1944 yystackp->yynextFree->yystate.yypred = &yystackp->yynextFree[-1].yystate;
1945 yystackp->yytops.yystates[0] = &yystackp->yynextFree->yystate;
1946 yystackp->yynextFree += 1;
1947 yystackp->yyspaceLeft -= 1;
1948 }
1949 }
1950
1951 static YYRESULTTAG
1952 yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
1953 size_t yyposn]b4_pure_formals[)
1954 {
1955 int yyaction;
1956 const short int* yyconflicts;
1957 yyRuleNum yyrule;
1958
1959 while (yystackp->yytops.yystates[yyk] != NULL)
1960 {
1961 yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState;
1962 YYDPRINTF ((stderr, "Stack %lu Entering state %d\n",
1963 (unsigned long int) yyk, yystate));
1964
1965 YYASSERT (yystate != YYFINAL);
1966
1967 if (yyisDefaultedState (yystate))
1968 {
1969 yyrule = yydefaultAction (yystate);
1970 if (yyrule == 0)
1971 {
1972 YYDPRINTF ((stderr, "Stack %lu dies.\n",
1973 (unsigned long int) yyk));
1974 yymarkStackDeleted (yystackp, yyk);
1975 return yyok;
1976 }
1977 YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse]b4_user_args[));
1978 }
1979 else
1980 {
1981 yySymbol yytoken;
1982 yystackp->yytops.yylookaheadNeeds[yyk] = yytrue;
1983 if (yychar == YYEMPTY)
1984 {
1985 YYDPRINTF ((stderr, "Reading a token: "));
1986 yychar = YYLEX;
1987 }
1988
1989 if (yychar <= YYEOF)
1990 {
1991 yychar = yytoken = YYEOF;
1992 YYDPRINTF ((stderr, "Now at end of input.\n"));
1993 }
1994 else
1995 {
1996 yytoken = YYTRANSLATE (yychar);
1997 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1998 }
1999
2000 yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
2001
2002 while (*yyconflicts != 0)
2003 {
2004 size_t yynewStack = yysplitStack (yystackp, yyk);
2005 YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n",
2006 (unsigned long int) yynewStack,
2007 (unsigned long int) yyk));
2008 YYCHK (yyglrReduce (yystackp, yynewStack,
2009 *yyconflicts, yyfalse]b4_user_args[));
2010 YYCHK (yyprocessOneStack (yystackp, yynewStack,
2011 yyposn]b4_pure_args[));
2012 yyconflicts += 1;
2013 }
2014
2015 if (yyisShiftAction (yyaction))
2016 break;
2017 else if (yyisErrorAction (yyaction))
2018 {
2019 YYDPRINTF ((stderr, "Stack %lu dies.\n",
2020 (unsigned long int) yyk));
2021 yymarkStackDeleted (yystackp, yyk);
2022 break;
2023 }
2024 else
2025 YYCHK (yyglrReduce (yystackp, yyk, -yyaction,
2026 yyfalse]b4_user_args[));
2027 }
2028 }
2029 return yyok;
2030 }
2031
2032 /*ARGSUSED*/ static void
2033 yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
2034 {
2035 if (yystackp->yyerrState == 0)
2036 {
2037 #if YYERROR_VERBOSE
2038 int yyn;
2039 yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
2040 if (YYPACT_NINF < yyn && yyn <= YYLAST)
2041 {
2042 yySymbol yytoken = YYTRANSLATE (yychar);
2043 size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
2044 size_t yysize = yysize0;
2045 size_t yysize1;
2046 yybool yysize_overflow = yyfalse;
2047 char* yymsg = NULL;
2048 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2049 /* Internationalized format string. */
2050 const char *yyformat = 0;
2051 /* Arguments of yyformat. */
2052 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2053
2054 /* Start YYX at -YYN if negative to avoid negative indexes in
2055 YYCHECK. */
2056 int yyxbegin = yyn < 0 ? -yyn : 0;
2057
2058 /* Stay within bounds of both yycheck and yytname. */
2059 int yychecklim = YYLAST - yyn + 1;
2060 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2061
2062 /* Number of reported tokens (one for the "unexpected", one per
2063 "expected"). */
2064 int yycount = 0;
2065 int yyx;
2066
2067 yyarg[yycount++] = yytokenName (yytoken);
2068
2069 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2070 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
2071 {
2072 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2073 {
2074 yycount = 1;
2075 yysize = yysize0;
2076 break;
2077 }
2078 yyarg[yycount++] = yytokenName (yyx);
2079 yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx));
2080 yysize_overflow |= yysize1 < yysize;
2081 yysize = yysize1;
2082 }
2083
2084 switch (yycount)
2085 {
2086 #define YYCASE_(N, S) \
2087 case N: \
2088 yyformat = S; \
2089 break
2090 YYCASE_(1, YY_("syntax error, unexpected %s"));
2091 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
2092 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
2093 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
2094 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
2095 #undef YYCASE_
2096 }
2097
2098 yysize1 = yysize + strlen (yyformat);
2099 yysize_overflow |= yysize1 < yysize;
2100 yysize = yysize1;
2101
2102 if (!yysize_overflow)
2103 yymsg = (char *) YYMALLOC (yysize);
2104
2105 if (yymsg)
2106 {
2107 char *yyp = yymsg;
2108 int yyi = 0;
2109 while ((*yyp = *yyformat))
2110 {
2111 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
2112 {
2113 yyp += yytnamerr (yyp, yyarg[yyi++]);
2114 yyformat += 2;
2115 }
2116 else
2117 {
2118 yyp++;
2119 yyformat++;
2120 }
2121 }
2122 yyerror (]b4_lyyerror_args[yymsg);
2123 YYFREE (yymsg);
2124 }
2125 else
2126 {
2127 yyerror (]b4_lyyerror_args[YY_("syntax error"));
2128 yyMemoryExhausted (yystackp);
2129 }
2130 }
2131 else
2132 #endif /* YYERROR_VERBOSE */
2133 yyerror (]b4_lyyerror_args[YY_("syntax error"));
2134 yynerrs += 1;
2135 }
2136 }
2137
2138 /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
2139 yylval, and yylloc are the syntactic category, semantic value, and location
2140 of the lookahead. */
2141 /*ARGSUSED*/ static void
2142 yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
2143 {
2144 size_t yyk;
2145 int yyj;
2146
2147 if (yystackp->yyerrState == 3)
2148 /* We just shifted the error token and (perhaps) took some
2149 reductions. Skip tokens until we can proceed. */
2150 while (YYID (yytrue))
2151 {
2152 yySymbol yytoken;
2153 if (yychar == YYEOF)
2154 yyFail (yystackp][]b4_lpure_args[, NULL);
2155 if (yychar != YYEMPTY)
2156 {]b4_locations_if([[
2157 /* We throw away the lookahead, but the error range
2158 of the shifted error token must take it into account. */
2159 yyGLRState *yys = yystackp->yytops.yystates[0];
2160 yyGLRStackItem yyerror_range[3];
2161 yyerror_range[1].yystate.yyloc = yys->yyloc;
2162 yyerror_range[2].yystate.yyloc = yylloc;
2163 YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[
2164 yytoken = YYTRANSLATE (yychar);
2165 yydestruct ("Error: discarding",
2166 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
2167 }
2168 YYDPRINTF ((stderr, "Reading a token: "));
2169 yychar = YYLEX;
2170 if (yychar <= YYEOF)
2171 {
2172 yychar = yytoken = YYEOF;
2173 YYDPRINTF ((stderr, "Now at end of input.\n"));
2174 }
2175 else
2176 {
2177 yytoken = YYTRANSLATE (yychar);
2178 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2179 }
2180 yyj = yypact[yystackp->yytops.yystates[0]->yylrState];
2181 if (yyis_pact_ninf (yyj))
2182 return;
2183 yyj += yytoken;
2184 if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken)
2185 {
2186 if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0)
2187 return;
2188 }
2189 else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj]))
2190 return;
2191 }
2192
2193 /* Reduce to one stack. */
2194 for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1)
2195 if (yystackp->yytops.yystates[yyk] != NULL)
2196 break;
2197 if (yyk >= yystackp->yytops.yysize)
2198 yyFail (yystackp][]b4_lpure_args[, NULL);
2199 for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1)
2200 yymarkStackDeleted (yystackp, yyk);
2201 yyremoveDeletes (yystackp);
2202 yycompressStack (yystackp);
2203
2204 /* Now pop stack until we find a state that shifts the error token. */
2205 yystackp->yyerrState = 3;
2206 while (yystackp->yytops.yystates[0] != NULL)
2207 {
2208 yyGLRState *yys = yystackp->yytops.yystates[0];
2209 yyj = yypact[yys->yylrState];
2210 if (! yyis_pact_ninf (yyj))
2211 {
2212 yyj += YYTERROR;
2213 if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
2214 && yyisShiftAction (yytable[yyj]))
2215 {
2216 /* Shift the error token having adjusted its location. */
2217 YYLTYPE yyerrloc;]b4_locations_if([[
2218 yystackp->yyerror_range[2].yystate.yyloc = yylloc;
2219 YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[
2220 YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
2221 &yylval, &yyerrloc);
2222 yyglrShift (yystackp, 0, yytable[yyj],
2223 yys->yyposn, &yylval, &yyerrloc);
2224 yys = yystackp->yytops.yystates[0];
2225 break;
2226 }
2227 }
2228 ]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
2229 if (yys->yypred != NULL)
2230 yydestroyGLRState ("Error: popping", yys]b4_user_args[);
2231 yystackp->yytops.yystates[0] = yys->yypred;
2232 yystackp->yynextFree -= 1;
2233 yystackp->yyspaceLeft += 1;
2234 }
2235 if (yystackp->yytops.yystates[0] == NULL)
2236 yyFail (yystackp][]b4_lpure_args[, NULL);
2237 }
2238
2239 #define YYCHK1(YYE) \
2240 do { \
2241 switch (YYE) { \
2242 case yyok: \
2243 break; \
2244 case yyabort: \
2245 goto yyabortlab; \
2246 case yyaccept: \
2247 goto yyacceptlab; \
2248 case yyerr: \
2249 goto yyuser_error; \
2250 default: \
2251 goto yybuglab; \
2252 } \
2253 } while (YYID (0))
2254
2255
2256 /*----------.
2257 | yyparse. |
2258 `----------*/
2259
2260 ]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[
2261 {
2262 int yyresult;
2263 yyGLRStack yystack;
2264 yyGLRStack* const yystackp = &yystack;
2265 size_t yyposn;
2266
2267 YYDPRINTF ((stderr, "Starting parse\n"));
2268
2269 yychar = YYEMPTY;
2270 yylval = yyval_default;
2271 ]b4_locations_if([
2272 #if YYLTYPE_IS_TRIVIAL
2273 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
2274 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
2275 #endif
2276 ])
2277 m4_ifdef([b4_initial_action], [
2278 m4_pushdef([b4_at_dollar], [yylloc])dnl
2279 m4_pushdef([b4_dollar_dollar], [yylval])dnl
2280 /* User initialization code. */
2281 b4_user_initial_action
2282 m4_popdef([b4_dollar_dollar])dnl
2283 m4_popdef([b4_at_dollar])])dnl
2284 [
2285 if (! yyinitGLRStack (yystackp, YYINITDEPTH))
2286 goto yyexhaustedlab;
2287 switch (YYSETJMP (yystack.yyexception_buffer))
2288 {
2289 case 0: break;
2290 case 1: goto yyabortlab;
2291 case 2: goto yyexhaustedlab;
2292 default: goto yybuglab;
2293 }
2294 yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc);
2295 yyposn = 0;
2296
2297 while (YYID (yytrue))
2298 {
2299 /* For efficiency, we have two loops, the first of which is
2300 specialized to deterministic operation (single stack, no
2301 potential ambiguity). */
2302 /* Standard mode */
2303 while (YYID (yytrue))
2304 {
2305 yyRuleNum yyrule;
2306 int yyaction;
2307 const short int* yyconflicts;
2308
2309 yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;
2310 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2311 if (yystate == YYFINAL)
2312 goto yyacceptlab;
2313 if (yyisDefaultedState (yystate))
2314 {
2315 yyrule = yydefaultAction (yystate);
2316 if (yyrule == 0)
2317 {
2318 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2319 yyreportSyntaxError (&yystack]b4_user_args[);
2320 goto yyuser_error;
2321 }
2322 YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[));
2323 }
2324 else
2325 {
2326 yySymbol yytoken;
2327 if (yychar == YYEMPTY)
2328 {
2329 YYDPRINTF ((stderr, "Reading a token: "));
2330 yychar = YYLEX;
2331 }
2332
2333 if (yychar <= YYEOF)
2334 {
2335 yychar = yytoken = YYEOF;
2336 YYDPRINTF ((stderr, "Now at end of input.\n"));
2337 }
2338 else
2339 {
2340 yytoken = YYTRANSLATE (yychar);
2341 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2342 }
2343
2344 yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
2345 if (*yyconflicts != 0)
2346 break;
2347 if (yyisShiftAction (yyaction))
2348 {
2349 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2350 yychar = YYEMPTY;
2351 yyposn += 1;
2352 yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc);
2353 if (0 < yystack.yyerrState)
2354 yystack.yyerrState -= 1;
2355 }
2356 else if (yyisErrorAction (yyaction))
2357 {
2358 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2359 yyreportSyntaxError (&yystack]b4_user_args[);
2360 goto yyuser_error;
2361 }
2362 else
2363 YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[));
2364 }
2365 }
2366
2367 while (YYID (yytrue))
2368 {
2369 yySymbol yytoken_to_shift;
2370 size_t yys;
2371
2372 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2373 yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY;
2374
2375 /* yyprocessOneStack returns one of three things:
2376
2377 - An error flag. If the caller is yyprocessOneStack, it
2378 immediately returns as well. When the caller is finally
2379 yyparse, it jumps to an error label via YYCHK1.
2380
2381 - yyok, but yyprocessOneStack has invoked yymarkStackDeleted
2382 (&yystack, yys), which sets the top state of yys to NULL. Thus,
2383 yyparse's following invocation of yyremoveDeletes will remove
2384 the stack.
2385
2386 - yyok, when ready to shift a token.
2387
2388 Except in the first case, yyparse will invoke yyremoveDeletes and
2389 then shift the next token onto all remaining stacks. This
2390 synchronization of the shift (that is, after all preceding
2391 reductions on all stacks) helps prevent double destructor calls
2392 on yylval in the event of memory exhaustion. */
2393
2394 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2395 YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[));
2396 yyremoveDeletes (&yystack);
2397 if (yystack.yytops.yysize == 0)
2398 {
2399 yyundeleteLastStack (&yystack);
2400 if (yystack.yytops.yysize == 0)
2401 yyFail (&yystack][]b4_lpure_args[, YY_("syntax error"));
2402 YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
2403 YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
2404 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2405 yyreportSyntaxError (&yystack]b4_user_args[);
2406 goto yyuser_error;
2407 }
2408
2409 /* If any yyglrShift call fails, it will fail after shifting. Thus,
2410 a copy of yylval will already be on stack 0 in the event of a
2411 failure in the following loop. Thus, yychar is set to YYEMPTY
2412 before the loop to make sure the user destructor for yylval isn't
2413 called twice. */
2414 yytoken_to_shift = YYTRANSLATE (yychar);
2415 yychar = YYEMPTY;
2416 yyposn += 1;
2417 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2418 {
2419 int yyaction;
2420 const short int* yyconflicts;
2421 yyStateNum yystate = yystack.yytops.yystates[yys]->yylrState;
2422 yygetLRActions (yystate, yytoken_to_shift, &yyaction,
2423 &yyconflicts);
2424 /* Note that yyconflicts were handled by yyprocessOneStack. */
2425 YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys));
2426 YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc);
2427 yyglrShift (&yystack, yys, yyaction, yyposn,
2428 &yylval, &yylloc);
2429 YYDPRINTF ((stderr, "Stack %lu now in state #%d\n",
2430 (unsigned long int) yys,
2431 yystack.yytops.yystates[yys]->yylrState));
2432 }
2433
2434 if (yystack.yytops.yysize == 1)
2435 {
2436 YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
2437 YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
2438 yycompressStack (&yystack);
2439 break;
2440 }
2441 }
2442 continue;
2443 yyuser_error:
2444 yyrecoverSyntaxError (&yystack]b4_user_args[);
2445 yyposn = yystack.yytops.yystates[0]->yyposn;
2446 }
2447
2448 yyacceptlab:
2449 yyresult = 0;
2450 goto yyreturn;
2451
2452 yybuglab:
2453 YYASSERT (yyfalse);
2454 goto yyabortlab;
2455
2456 yyabortlab:
2457 yyresult = 1;
2458 goto yyreturn;
2459
2460 yyexhaustedlab:
2461 yyerror (]b4_lyyerror_args[YY_("memory exhausted"));
2462 yyresult = 2;
2463 goto yyreturn;
2464
2465 yyreturn:
2466 if (yychar != YYEMPTY)
2467 yydestruct ("Cleanup: discarding lookahead",
2468 YYTRANSLATE (yychar),
2469 &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
2470
2471 /* If the stack is well-formed, pop the stack until it is empty,
2472 destroying its entries as we go. But free the stack regardless
2473 of whether it is well-formed. */
2474 if (yystack.yyitems)
2475 {
2476 yyGLRState** yystates = yystack.yytops.yystates;
2477 if (yystates)
2478 {
2479 size_t yysize = yystack.yytops.yysize;
2480 size_t yyk;
2481 for (yyk = 0; yyk < yysize; yyk += 1)
2482 if (yystates[yyk])
2483 {
2484 while (yystates[yyk])
2485 {
2486 yyGLRState *yys = yystates[yyk];
2487 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]]
2488 )[ if (yys->yypred != NULL)
2489 yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
2490 yystates[yyk] = yys->yypred;
2491 yystack.yynextFree -= 1;
2492 yystack.yyspaceLeft += 1;
2493 }
2494 break;
2495 }
2496 }
2497 yyfreeGLRStack (&yystack);
2498 }
2499
2500 /* Make sure YYID is used. */
2501 return YYID (yyresult);
2502 }
2503
2504 /* DEBUGGING ONLY */
2505 #if YYDEBUG
2506 static void yypstack (yyGLRStack* yystackp, size_t yyk)
2507 __attribute__ ((__unused__));
2508 static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__));
2509
2510 static void
2511 yy_yypstack (yyGLRState* yys)
2512 {
2513 if (yys->yypred)
2514 {
2515 yy_yypstack (yys->yypred);
2516 YYFPRINTF (stderr, " -> ");
2517 }
2518 YYFPRINTF (stderr, "%d@@%lu", yys->yylrState,
2519 (unsigned long int) yys->yyposn);
2520 }
2521
2522 static void
2523 yypstates (yyGLRState* yyst)
2524 {
2525 if (yyst == NULL)
2526 YYFPRINTF (stderr, "<null>");
2527 else
2528 yy_yypstack (yyst);
2529 YYFPRINTF (stderr, "\n");
2530 }
2531
2532 static void
2533 yypstack (yyGLRStack* yystackp, size_t yyk)
2534 {
2535 yypstates (yystackp->yytops.yystates[yyk]);
2536 }
2537
2538 #define YYINDEX(YYX) \
2539 ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems)
2540
2541
2542 static void
2543 yypdumpstack (yyGLRStack* yystackp)
2544 {
2545 yyGLRStackItem* yyp;
2546 size_t yyi;
2547 for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1)
2548 {
2549 YYFPRINTF (stderr, "%3lu. ",
2550 (unsigned long int) (yyp - yystackp->yyitems));
2551 if (*(yybool *) yyp)
2552 {
2553 YYFPRINTF (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
2554 yyp->yystate.yyresolved, yyp->yystate.yylrState,
2555 (unsigned long int) yyp->yystate.yyposn,
2556 (long int) YYINDEX (yyp->yystate.yypred));
2557 if (! yyp->yystate.yyresolved)
2558 YYFPRINTF (stderr, ", firstVal: %ld",
2559 (long int) YYINDEX (yyp->yystate
2560 .yysemantics.yyfirstVal));
2561 }
2562 else
2563 {
2564 YYFPRINTF (stderr, "Option. rule: %d, state: %ld, next: %ld",
2565 yyp->yyoption.yyrule - 1,
2566 (long int) YYINDEX (yyp->yyoption.yystate),
2567 (long int) YYINDEX (yyp->yyoption.yynext));
2568 }
2569 YYFPRINTF (stderr, "\n");
2570 }
2571 YYFPRINTF (stderr, "Tops:");
2572 for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
2573 YYFPRINTF (stderr, "%lu: %ld; ", (unsigned long int) yyi,
2574 (long int) YYINDEX (yystackp->yytops.yystates[yyi]));
2575 YYFPRINTF (stderr, "\n");
2576 }
2577 #endif
2578 ]b4_epilogue[]dnl
2579 dnl
2580 dnl glr.cc produces its own header.
2581 dnl
2582 m4_if(b4_skeleton, ["glr.c"],
2583 [b4_defines_if(
2584 [@output(b4_spec_defines_file@)@
2585 b4_copyright([Skeleton interface for Bison GLR parsers in C],
2586 [2002, 2003, 2004, 2005, 2006, 2007, 2008])
2587
2588 b4_shared_declarations
2589
2590 b4_pure_if([],
2591 [[extern YYSTYPE ]b4_prefix[lval;]])
2592
2593 b4_locations_if([b4_pure_if([],
2594 [extern YYLTYPE ]b4_prefix[lloc;])
2595 ])
2596 ])])[]dnl
2597 m4_divert_pop(0)
bison