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


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