]> git.saurik.com Git - bison.git/blob - data/glr.c
projects / bison.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* data/glr.c (yyreportSyntaxError): Fix off-by-one error in
[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[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);
1761 else
1762 YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %lu .. %lu>\n",
1763 yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
1764 yyx->yyrule, (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 yyGLRState *yyprevious = yyoption->yystate;
1840 YYASSERT (yyprevious->yyresolved);
1841 yyrhsloc[0].yystate.yyloc = yyprevious->yyloc;
1842 }
1843 yychar_current = yychar;
1844 yylval_current = yylval;
1845 yylloc_current = yylloc;
1846 yychar = yyoption->yyrawchar;
1847 yylval = yyoption->yyval;
1848 yylloc = yyoption->yyloc;
1849 YYLLOC_DEFAULT ((yys1->yyloc), yyrhsloc, yynrhs);
1850 yychar = yychar_current;
1851 yylval = yylval_current;
1852 yylloc = yylloc_current;
1853 }
1854 }
1855 }
1856
1857 /** Resolve the ambiguity represented in state S, perform the indicated
1858 * actions, and set the semantic value of S. If result != yyok, the chain of
1859 * semantic options in S has been cleared instead or it has been left
1860 * unmodified except that redundant options may have been removed. Regardless
1861 * of whether result = yyok, S has been left with consistent data so that
1862 * yydestroyGLRState can be invoked if necessary. */
1863 static YYRESULTTAG
1864 yyresolveValue (yyGLRState* yys, yyGLRStack* yystackp]b4_user_formals[)
1865 {
1866 yySemanticOption* yyoptionList = yys->yysemantics.yyfirstVal;
1867 yySemanticOption* yybest;
1868 yySemanticOption** yypp;
1869 yybool yymerge;
1870 YYSTYPE yysval;
1871 YYRESULTTAG yyflag;
1872 YYLTYPE *yylocp = &yys->yyloc;
1873
1874 yybest = yyoptionList;
1875 yymerge = yyfalse;
1876 for (yypp = &yyoptionList->yynext; *yypp != NULL; )
1877 {
1878 yySemanticOption* yyp = *yypp;
1879
1880 if (yyidenticalOptions (yybest, yyp))
1881 {
1882 yymergeOptionSets (yybest, yyp);
1883 *yypp = yyp->yynext;
1884 }
1885 else
1886 {
1887 switch (yypreference (yybest, yyp))
1888 {
1889 case 0:
1890 yyresolveLocations (yys, 1, yystackp]b4_user_args[);
1891 return yyreportAmbiguity (yybest, yyp]b4_pure_args[);
1892 break;
1893 case 1:
1894 yymerge = yytrue;
1895 break;
1896 case 2:
1897 break;
1898 case 3:
1899 yybest = yyp;
1900 yymerge = yyfalse;
1901 break;
1902 default:
1903 /* This cannot happen so it is not worth a YYASSERT (yyfalse),
1904 but some compilers complain if the default case is
1905 omitted. */
1906 break;
1907 }
1908 yypp = &yyp->yynext;
1909 }
1910 }
1911
1912 if (yymerge)
1913 {
1914 yySemanticOption* yyp;
1915 int yyprec = yydprec[yybest->yyrule];
1916 yyflag = yyresolveAction (yybest, yystackp, &yysval,
1917 yylocp]b4_user_args[);
1918 if (yyflag == yyok)
1919 for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
1920 {
1921 if (yyprec == yydprec[yyp->yyrule])
1922 {
1923 YYSTYPE yysval_other;
1924 YYLTYPE yydummy;
1925 yyflag = yyresolveAction (yyp, yystackp, &yysval_other,
1926 &yydummy]b4_user_args[);
1927 if (yyflag != yyok)
1928 {
1929 yydestruct ("Cleanup: discarding incompletely merged value for",
1930 yystos[yys->yylrState],
1931 &yysval]b4_locations_if([, yylocp])[]b4_user_args[);
1932 break;
1933 }
1934 yyuserMerge (yymerger[yyp->yyrule], &yysval, &yysval_other);
1935 }
1936 }
1937 }
1938 else
1939 yyflag = yyresolveAction (yybest, yystackp, &yysval, yylocp]b4_user_args[);
1940
1941 if (yyflag == yyok)
1942 {
1943 yys->yyresolved = yytrue;
1944 yys->yysemantics.yysval = yysval;
1945 }
1946 else
1947 yys->yysemantics.yyfirstVal = NULL;
1948 return yyflag;
1949 }
1950
1951 static YYRESULTTAG
1952 yyresolveStack (yyGLRStack* yystackp]b4_user_formals[)
1953 {
1954 if (yystackp->yysplitPoint != NULL)
1955 {
1956 yyGLRState* yys;
1957 int yyn;
1958
1959 for (yyn = 0, yys = yystackp->yytops.yystates[0];
1960 yys != yystackp->yysplitPoint;
1961 yys = yys->yypred, yyn += 1)
1962 continue;
1963 YYCHK (yyresolveStates (yystackp->yytops.yystates[0], yyn, yystackp
1964 ]b4_user_args[));
1965 }
1966 return yyok;
1967 }
1968
1969 static void
1970 yycompressStack (yyGLRStack* yystackp)
1971 {
1972 yyGLRState* yyp, *yyq, *yyr;
1973
1974 if (yystackp->yytops.yysize != 1 || yystackp->yysplitPoint == NULL)
1975 return;
1976
1977 for (yyp = yystackp->yytops.yystates[0], yyq = yyp->yypred, yyr = NULL;
1978 yyp != yystackp->yysplitPoint;
1979 yyr = yyp, yyp = yyq, yyq = yyp->yypred)
1980 yyp->yypred = yyr;
1981
1982 yystackp->yyspaceLeft += yystackp->yynextFree - yystackp->yyitems;
1983 yystackp->yynextFree = ((yyGLRStackItem*) yystackp->yysplitPoint) + 1;
1984 yystackp->yyspaceLeft -= yystackp->yynextFree - yystackp->yyitems;
1985 yystackp->yysplitPoint = NULL;
1986 yystackp->yylastDeleted = NULL;
1987
1988 while (yyr != NULL)
1989 {
1990 yystackp->yynextFree->yystate = *yyr;
1991 yyr = yyr->yypred;
1992 yystackp->yynextFree->yystate.yypred = &yystackp->yynextFree[-1].yystate;
1993 yystackp->yytops.yystates[0] = &yystackp->yynextFree->yystate;
1994 yystackp->yynextFree += 1;
1995 yystackp->yyspaceLeft -= 1;
1996 }
1997 }
1998
1999 static YYRESULTTAG
2000 yyprocessOneStack (yyGLRStack* yystackp, size_t yyk,
2001 size_t yyposn]b4_pure_formals[)
2002 {
2003 int yyaction;
2004 const short int* yyconflicts;
2005 yyRuleNum yyrule;
2006
2007 while (yystackp->yytops.yystates[yyk] != NULL)
2008 {
2009 yyStateNum yystate = yystackp->yytops.yystates[yyk]->yylrState;
2010 YYDPRINTF ((stderr, "Stack %lu Entering state %d\n",
2011 (unsigned long int) yyk, yystate));
2012
2013 YYASSERT (yystate != YYFINAL);
2014
2015 if (yyisDefaultedState (yystate))
2016 {
2017 yyrule = yydefaultAction (yystate);
2018 if (yyrule == 0)
2019 {
2020 YYDPRINTF ((stderr, "Stack %lu dies.\n",
2021 (unsigned long int) yyk));
2022 yymarkStackDeleted (yystackp, yyk);
2023 return yyok;
2024 }
2025 YYCHK (yyglrReduce (yystackp, yyk, yyrule, yyfalse]b4_user_args[));
2026 }
2027 else
2028 {
2029 yySymbol yytoken;
2030 yystackp->yytops.yylookaheadNeeds[yyk] = yytrue;
2031 if (yychar == YYEMPTY)
2032 {
2033 YYDPRINTF ((stderr, "Reading a token: "));
2034 yychar = YYLEX;
2035 yytoken = YYTRANSLATE (yychar);
2036 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2037 }
2038 else
2039 yytoken = YYTRANSLATE (yychar);
2040 yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
2041
2042 while (*yyconflicts != 0)
2043 {
2044 size_t yynewStack = yysplitStack (yystackp, yyk);
2045 YYDPRINTF ((stderr, "Splitting off stack %lu from %lu.\n",
2046 (unsigned long int) yynewStack,
2047 (unsigned long int) yyk));
2048 YYCHK (yyglrReduce (yystackp, yynewStack,
2049 *yyconflicts, yyfalse]b4_user_args[));
2050 YYCHK (yyprocessOneStack (yystackp, yynewStack,
2051 yyposn]b4_pure_args[));
2052 yyconflicts += 1;
2053 }
2054
2055 if (yyisShiftAction (yyaction))
2056 break;
2057 else if (yyisErrorAction (yyaction))
2058 {
2059 YYDPRINTF ((stderr, "Stack %lu dies.\n",
2060 (unsigned long int) yyk));
2061 yymarkStackDeleted (yystackp, yyk);
2062 break;
2063 }
2064 else
2065 YYCHK (yyglrReduce (yystackp, yyk, -yyaction,
2066 yyfalse]b4_user_args[));
2067 }
2068 }
2069 return yyok;
2070 }
2071
2072 /*ARGSUSED*/ static void
2073 yyreportSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
2074 {
2075 if (yystackp->yyerrState == 0)
2076 {
2077 #if YYERROR_VERBOSE
2078 int yyn;
2079 yyn = yypact[yystackp->yytops.yystates[0]->yylrState];
2080 if (YYPACT_NINF < yyn && yyn <= YYLAST)
2081 {
2082 yySymbol yytoken = YYTRANSLATE (yychar);
2083 size_t yysize0 = yytnamerr (NULL, yytokenName (yytoken));
2084 size_t yysize = yysize0;
2085 size_t yysize1;
2086 yybool yysize_overflow = yyfalse;
2087 char* yymsg = NULL;
2088 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2089 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2090 int yyx;
2091 char *yyfmt;
2092 char const *yyf;
2093 static char const yyunexpected[] = "syntax error, unexpected %s";
2094 static char const yyexpecting[] = ", expecting %s";
2095 static char const yyor[] = " or %s";
2096 char yyformat[sizeof yyunexpected
2097 + sizeof yyexpecting - 1
2098 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
2099 * (sizeof yyor - 1))];
2100 char const *yyprefix = yyexpecting;
2101
2102 /* Start YYX at -YYN if negative to avoid negative indexes in
2103 YYCHECK. */
2104 int yyxbegin = yyn < 0 ? -yyn : 0;
2105
2106 /* Stay within bounds of both yycheck and yytname. */
2107 int yychecklim = YYLAST - yyn + 1;
2108 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2109 int yycount = 1;
2110
2111 yyarg[0] = yytokenName (yytoken);
2112 yyfmt = yystpcpy (yyformat, yyunexpected);
2113
2114 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2115 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
2116 {
2117 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2118 {
2119 yycount = 1;
2120 yysize = yysize0;
2121 yyformat[sizeof yyunexpected - 1] = '\0';
2122 break;
2123 }
2124 yyarg[yycount++] = yytokenName (yyx);
2125 yysize1 = yysize + yytnamerr (NULL, yytokenName (yyx));
2126 yysize_overflow |= yysize1 < yysize;
2127 yysize = yysize1;
2128 yyfmt = yystpcpy (yyfmt, yyprefix);
2129 yyprefix = yyor;
2130 }
2131
2132 yyf = YY_(yyformat);
2133 yysize1 = yysize + strlen (yyf);
2134 yysize_overflow |= yysize1 < yysize;
2135 yysize = yysize1;
2136
2137 if (!yysize_overflow)
2138 yymsg = (char *) YYMALLOC (yysize);
2139
2140 if (yymsg)
2141 {
2142 char *yyp = yymsg;
2143 int yyi = 0;
2144 while ((*yyp = *yyf))
2145 {
2146 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
2147 {
2148 yyp += yytnamerr (yyp, yyarg[yyi++]);
2149 yyf += 2;
2150 }
2151 else
2152 {
2153 yyp++;
2154 yyf++;
2155 }
2156 }
2157 yyerror (]b4_lyyerror_args[yymsg);
2158 YYFREE (yymsg);
2159 }
2160 else
2161 {
2162 yyerror (]b4_lyyerror_args[YY_("syntax error"));
2163 yyMemoryExhausted (yystackp);
2164 }
2165 }
2166 else
2167 #endif /* YYERROR_VERBOSE */
2168 yyerror (]b4_lyyerror_args[YY_("syntax error"));
2169 yynerrs += 1;
2170 }
2171 }
2172
2173 /* Recover from a syntax error on *YYSTACKP, assuming that *YYSTACKP->YYTOKENP,
2174 yylval, and yylloc are the syntactic category, semantic value, and location
2175 of the look-ahead. */
2176 /*ARGSUSED*/ static void
2177 yyrecoverSyntaxError (yyGLRStack* yystackp]b4_user_formals[)
2178 {
2179 size_t yyk;
2180 int yyj;
2181
2182 if (yystackp->yyerrState == 3)
2183 /* We just shifted the error token and (perhaps) took some
2184 reductions. Skip tokens until we can proceed. */
2185 while (YYID (yytrue))
2186 {
2187 yySymbol yytoken;
2188 if (yychar == YYEOF)
2189 yyFail (yystackp][]b4_lpure_args[, NULL);
2190 if (yychar != YYEMPTY)
2191 {]b4_locations_if([[
2192 /* We throw away the lookahead, but the error range
2193 of the shifted error token must take it into account. */
2194 yyGLRState *yys = yystackp->yytops.yystates[0];
2195 yyGLRStackItem yyerror_range[3];
2196 yyerror_range[1].yystate.yyloc = yys->yyloc;
2197 yyerror_range[2].yystate.yyloc = yylloc;
2198 YYLLOC_DEFAULT ((yys->yyloc), yyerror_range, 2);]])[
2199 yytoken = YYTRANSLATE (yychar);
2200 yydestruct ("Error: discarding",
2201 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
2202 }
2203 YYDPRINTF ((stderr, "Reading a token: "));
2204 yychar = YYLEX;
2205 yytoken = YYTRANSLATE (yychar);
2206 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2207 yyj = yypact[yystackp->yytops.yystates[0]->yylrState];
2208 if (yyis_pact_ninf (yyj))
2209 return;
2210 yyj += yytoken;
2211 if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != yytoken)
2212 {
2213 if (yydefact[yystackp->yytops.yystates[0]->yylrState] != 0)
2214 return;
2215 }
2216 else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj]))
2217 return;
2218 }
2219
2220 /* Reduce to one stack. */
2221 for (yyk = 0; yyk < yystackp->yytops.yysize; yyk += 1)
2222 if (yystackp->yytops.yystates[yyk] != NULL)
2223 break;
2224 if (yyk >= yystackp->yytops.yysize)
2225 yyFail (yystackp][]b4_lpure_args[, NULL);
2226 for (yyk += 1; yyk < yystackp->yytops.yysize; yyk += 1)
2227 yymarkStackDeleted (yystackp, yyk);
2228 yyremoveDeletes (yystackp);
2229 yycompressStack (yystackp);
2230
2231 /* Now pop stack until we find a state that shifts the error token. */
2232 yystackp->yyerrState = 3;
2233 while (yystackp->yytops.yystates[0] != NULL)
2234 {
2235 yyGLRState *yys = yystackp->yytops.yystates[0];
2236 yyj = yypact[yys->yylrState];
2237 if (! yyis_pact_ninf (yyj))
2238 {
2239 yyj += YYTERROR;
2240 if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
2241 && yyisShiftAction (yytable[yyj]))
2242 {
2243 /* Shift the error token having adjusted its location. */
2244 YYLTYPE yyerrloc;]b4_locations_if([[
2245 yystackp->yyerror_range[2].yystate.yyloc = yylloc;
2246 YYLLOC_DEFAULT (yyerrloc, (yystackp->yyerror_range), 2);]])[
2247 YY_SYMBOL_PRINT ("Shifting", yystos[yytable[yyj]],
2248 &yylval, &yyerrloc);
2249 yyglrShift (yystackp, 0, yytable[yyj],
2250 yys->yyposn, &yylval, &yyerrloc);
2251 yys = yystackp->yytops.yystates[0];
2252 break;
2253 }
2254 }
2255 ]b4_locations_if([[ yystackp->yyerror_range[1].yystate.yyloc = yys->yyloc;]])[
2256 yydestroyGLRState ("Error: popping", yys]b4_user_args[);
2257 yystackp->yytops.yystates[0] = yys->yypred;
2258 yystackp->yynextFree -= 1;
2259 yystackp->yyspaceLeft += 1;
2260 }
2261 if (yystackp->yytops.yystates[0] == NULL)
2262 yyFail (yystackp][]b4_lpure_args[, NULL);
2263 }
2264
2265 #define YYCHK1(YYE) \
2266 do { \
2267 switch (YYE) { \
2268 case yyok: \
2269 break; \
2270 case yyabort: \
2271 goto yyabortlab; \
2272 case yyaccept: \
2273 goto yyacceptlab; \
2274 case yyerr: \
2275 goto yyuser_error; \
2276 default: \
2277 goto yybuglab; \
2278 } \
2279 } while (YYID (0))
2280
2281
2282 /*----------.
2283 | yyparse. |
2284 `----------*/
2285
2286 ]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[
2287 {
2288 int yyresult;
2289 yyGLRStack yystack;
2290 yyGLRStack* const yystackp = &yystack;
2291 size_t yyposn;
2292
2293 YYDPRINTF ((stderr, "Starting parse\n"));
2294
2295 yychar = YYEMPTY;
2296 yylval = yyval_default;
2297 ]b4_locations_if([
2298 #if YYLTYPE_IS_TRIVIAL
2299 yylloc.first_line = yylloc.last_line = 1;
2300 yylloc.first_column = yylloc.last_column = 0;
2301 #endif
2302 ])
2303 m4_ifdef([b4_initial_action], [
2304 m4_pushdef([b4_at_dollar], [yylloc])dnl
2305 m4_pushdef([b4_dollar_dollar], [yylval])dnl
2306 /* User initialization code. */
2307 b4_initial_action
2308 m4_popdef([b4_dollar_dollar])dnl
2309 m4_popdef([b4_at_dollar])dnl
2310 /* Line __line__ of glr.c. */
2311 b4_syncline([@oline@], [@ofile@])])dnl
2312 [
2313 if (! yyinitGLRStack (yystackp, YYINITDEPTH))
2314 goto yyexhaustedlab;
2315 switch (YYSETJMP (yystack.yyexception_buffer))
2316 {
2317 case 0: break;
2318 case 1: goto yyabortlab;
2319 case 2: goto yyexhaustedlab;
2320 default: goto yybuglab;
2321 }
2322 yyglrShift (&yystack, 0, 0, 0, &yylval, &yylloc);
2323 yyposn = 0;
2324
2325 while (YYID (yytrue))
2326 {
2327 /* For efficiency, we have two loops, the first of which is
2328 specialized to deterministic operation (single stack, no
2329 potential ambiguity). */
2330 /* Standard mode */
2331 while (YYID (yytrue))
2332 {
2333 yyRuleNum yyrule;
2334 int yyaction;
2335 const short int* yyconflicts;
2336
2337 yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;
2338 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2339 if (yystate == YYFINAL)
2340 goto yyacceptlab;
2341 if (yyisDefaultedState (yystate))
2342 {
2343 yyrule = yydefaultAction (yystate);
2344 if (yyrule == 0)
2345 {
2346 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2347 yyreportSyntaxError (&yystack]b4_user_args[);
2348 goto yyuser_error;
2349 }
2350 YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_user_args[));
2351 }
2352 else
2353 {
2354 yySymbol yytoken;
2355 if (yychar == YYEMPTY)
2356 {
2357 YYDPRINTF ((stderr, "Reading a token: "));
2358 yychar = YYLEX;
2359 yytoken = YYTRANSLATE (yychar);
2360 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2361 }
2362 else
2363 yytoken = YYTRANSLATE (yychar);
2364 yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
2365 if (*yyconflicts != 0)
2366 break;
2367 if (yyisShiftAction (yyaction))
2368 {
2369 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2370 if (yychar != YYEOF)
2371 yychar = YYEMPTY;
2372 yyposn += 1;
2373 yyglrShift (&yystack, 0, yyaction, yyposn, &yylval, &yylloc);
2374 if (0 < yystack.yyerrState)
2375 yystack.yyerrState -= 1;
2376 }
2377 else if (yyisErrorAction (yyaction))
2378 {
2379 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2380 yyreportSyntaxError (&yystack]b4_user_args[);
2381 goto yyuser_error;
2382 }
2383 else
2384 YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_user_args[));
2385 }
2386 }
2387
2388 while (YYID (yytrue))
2389 {
2390 yySymbol yytoken_to_shift;
2391 size_t yys;
2392
2393 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2394 yystackp->yytops.yylookaheadNeeds[yys] = yychar != YYEMPTY;
2395
2396 /* yyprocessOneStack returns one of three things:
2397
2398 - An error flag. If the caller is yyprocessOneStack, it
2399 immediately returns as well. When the caller is finally
2400 yyparse, it jumps to an error label via YYCHK1.
2401
2402 - yyok, but yyprocessOneStack has invoked yymarkStackDeleted
2403 (&yystack, yys), which sets the top state of yys to NULL. Thus,
2404 yyparse's following invocation of yyremoveDeletes will remove
2405 the stack.
2406
2407 - yyok, when ready to shift a token.
2408
2409 Except in the first case, yyparse will invoke yyremoveDeletes and
2410 then shift the next token onto all remaining stacks. This
2411 synchronization of the shift (that is, after all preceding
2412 reductions on all stacks) helps prevent double destructor calls
2413 on yylval in the event of memory exhaustion. */
2414
2415 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2416 YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn]b4_lpure_args[));
2417 yyremoveDeletes (&yystack);
2418 if (yystack.yytops.yysize == 0)
2419 {
2420 yyundeleteLastStack (&yystack);
2421 if (yystack.yytops.yysize == 0)
2422 yyFail (&yystack][]b4_lpure_args[, YY_("syntax error"));
2423 YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
2424 YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
2425 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yylloc;]])[
2426 yyreportSyntaxError (&yystack]b4_user_args[);
2427 goto yyuser_error;
2428 }
2429
2430 /* If any yyglrShift call fails, it will fail after shifting. Thus,
2431 a copy of yylval will already be on stack 0 in the event of a
2432 failure in the following loop. Thus, yychar is set to YYEMPTY
2433 before the loop to make sure the user destructor for yylval isn't
2434 called twice. */
2435 yytoken_to_shift = YYTRANSLATE (yychar);
2436 yychar = YYEMPTY;
2437 yyposn += 1;
2438 for (yys = 0; yys < yystack.yytops.yysize; yys += 1)
2439 {
2440 int yyaction;
2441 const short int* yyconflicts;
2442 yyStateNum yystate = yystack.yytops.yystates[yys]->yylrState;
2443 yygetLRActions (yystate, yytoken_to_shift, &yyaction,
2444 &yyconflicts);
2445 /* Note that yyconflicts were handled by yyprocessOneStack. */
2446 YYDPRINTF ((stderr, "On stack %lu, ", (unsigned long int) yys));
2447 YY_SYMBOL_PRINT ("shifting", yytoken_to_shift, &yylval, &yylloc);
2448 yyglrShift (&yystack, yys, yyaction, yyposn,
2449 &yylval, &yylloc);
2450 YYDPRINTF ((stderr, "Stack %lu now in state #%d\n",
2451 (unsigned long int) yys,
2452 yystack.yytops.yystates[yys]->yylrState));
2453 }
2454
2455 if (yystack.yytops.yysize == 1)
2456 {
2457 YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
2458 YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
2459 yycompressStack (&yystack);
2460 break;
2461 }
2462 }
2463 continue;
2464 yyuser_error:
2465 yyrecoverSyntaxError (&yystack]b4_user_args[);
2466 yyposn = yystack.yytops.yystates[0]->yyposn;
2467 }
2468
2469 yyacceptlab:
2470 yyresult = 0;
2471 goto yyreturn;
2472
2473 yybuglab:
2474 YYASSERT (yyfalse);
2475 goto yyabortlab;
2476
2477 yyabortlab:
2478 yyresult = 1;
2479 goto yyreturn;
2480
2481 yyexhaustedlab:
2482 yyerror (]b4_lyyerror_args[YY_("memory exhausted"));
2483 yyresult = 2;
2484 goto yyreturn;
2485
2486 yyreturn:
2487 if (yychar != YYEOF && yychar != YYEMPTY)
2488 yydestruct ("Cleanup: discarding lookahead",
2489 YYTRANSLATE (yychar),
2490 &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
2491
2492 /* If the stack is well-formed, pop the stack until it is empty,
2493 destroying its entries as we go. But free the stack regardless
2494 of whether it is well-formed. */
2495 if (yystack.yyitems)
2496 {
2497 yyGLRState** yystates = yystack.yytops.yystates;
2498 if (yystates)
2499 {
2500 size_t yysize = yystack.yytops.yysize;
2501 size_t yyk;
2502 for (yyk = 0; yyk < yysize; yyk += 1)
2503 if (yystates[yyk])
2504 {
2505 while (yystates[yyk])
2506 {
2507 yyGLRState *yys = yystates[yyk];
2508 ]b4_locations_if([[ yystack.yyerror_range[1].yystate.yyloc = yys->yyloc;]]
2509 )[ yydestroyGLRState ("Cleanup: popping", yys]b4_user_args[);
2510 yystates[yyk] = yys->yypred;
2511 yystack.yynextFree -= 1;
2512 yystack.yyspaceLeft += 1;
2513 }
2514 break;
2515 }
2516 }
2517 yyfreeGLRStack (&yystack);
2518 }
2519
2520 return yyresult;
2521 }
2522
2523 /* DEBUGGING ONLY */
2524 #ifdef YYDEBUG
2525 static void yypstack (yyGLRStack* yystackp, size_t yyk)
2526 __attribute__ ((__unused__));
2527 static void yypdumpstack (yyGLRStack* yystackp) __attribute__ ((__unused__));
2528
2529 static void
2530 yy_yypstack (yyGLRState* yys)
2531 {
2532 if (yys->yypred)
2533 {
2534 yy_yypstack (yys->yypred);
2535 fprintf (stderr, " -> ");
2536 }
2537 fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long int) yys->yyposn);
2538 }
2539
2540 static void
2541 yypstates (yyGLRState* yyst)
2542 {
2543 if (yyst == NULL)
2544 fprintf (stderr, "<null>");
2545 else
2546 yy_yypstack (yyst);
2547 fprintf (stderr, "\n");
2548 }
2549
2550 static void
2551 yypstack (yyGLRStack* yystackp, size_t yyk)
2552 {
2553 yypstates (yystackp->yytops.yystates[yyk]);
2554 }
2555
2556 #define YYINDEX(YYX) \
2557 ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystackp->yyitems)
2558
2559
2560 static void
2561 yypdumpstack (yyGLRStack* yystackp)
2562 {
2563 yyGLRStackItem* yyp;
2564 size_t yyi;
2565 for (yyp = yystackp->yyitems; yyp < yystackp->yynextFree; yyp += 1)
2566 {
2567 fprintf (stderr, "%3lu. ", (unsigned long int) (yyp - yystackp->yyitems));
2568 if (*(yybool *) yyp)
2569 {
2570 fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
2571 yyp->yystate.yyresolved, yyp->yystate.yylrState,
2572 (unsigned long int) yyp->yystate.yyposn,
2573 (long int) YYINDEX (yyp->yystate.yypred));
2574 if (! yyp->yystate.yyresolved)
2575 fprintf (stderr, ", firstVal: %ld",
2576 (long int) YYINDEX (yyp->yystate.yysemantics.yyfirstVal));
2577 }
2578 else
2579 {
2580 fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld",
2581 yyp->yyoption.yyrule,
2582 (long int) YYINDEX (yyp->yyoption.yystate),
2583 (long int) YYINDEX (yyp->yyoption.yynext));
2584 }
2585 fprintf (stderr, "\n");
2586 }
2587 fprintf (stderr, "Tops:");
2588 for (yyi = 0; yyi < yystackp->yytops.yysize; yyi += 1)
2589 fprintf (stderr, "%lu: %ld; ", (unsigned long int) yyi,
2590 (long int) YYINDEX (yystackp->yytops.yystates[yyi]));
2591 fprintf (stderr, "\n");
2592 }
2593 #endif
2594 ]
2595
2596 b4_epilogue
2597 b4_defines_if(
2598 [@output @output_header_name@
2599 b4_copyright([Skeleton interface for Bison GLR parsers in C],
2600 [2002, 2003, 2004, 2005, 2006])
2601
2602 b4_shared_declarations
2603
2604 extern YYSTYPE b4_prefix[]lval;
2605
2606 b4_locations_if([b4_pure_if([],
2607 [extern YYLTYPE b4_prefix[]lloc;])
2608 ])
2609 ])
bison