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


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