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