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