]> git.saurik.com Git - bison.git/blame - data/glr.c
Augment the similarity between GLR and LALR traces.
[bison.git] / data / glr.c
CommitLineData
720623af
PH
1m4_divert(-1) -*- C -*-
2m4_include([c.m4])
01241d47 3
fb8135fa
AD
4# GLR skeleton for Bison
5# Copyright (C) 2002 Free Software Foundation, Inc.
6
7# This program is free software; you can redistribute it and/or modify
8# it under the terms of the GNU General Public License as published by
9# the Free Software Foundation; either version 2 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, write to the Free Software
19# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
20# 02111-1307 USA
21
66d30cd4
AD
22
23## ---------------- ##
24## Default values. ##
25## ---------------- ##
26
27# Stack parameters.
28m4_define_default([b4_stack_depth_max], [10000])
29m4_define_default([b4_stack_depth_init], [200])
30
31# Location type.
32m4_define_default([b4_location_type], [yyltype])
33
2a8d363a
AD
34
35
36## ------------------------ ##
37## Pure/impure interfaces. ##
38## ------------------------ ##
39
40
41# b4_lex_param
42# ------------
21964f43
AD
43# Accumule in b4_lex_param all the yylex arguments.
44# Yes, this is quite ugly...
45m4_define([b4_lex_param],
46m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[yylvalp]]][]dnl
47b4_location_if([, [[YYLTYPE *], [yyllocp]]])])dnl
48m4_ifdef([b4_lex_param], [, ]b4_lex_param)))
49
2a8d363a
AD
50
51# b4_user_formals
52# ---------------
53m4_define([b4_user_formals],
54[m4_ifset([b4_parse_param], [, b4_c_ansi_formals(b4_parse_param)])])
55
56
93724f13
AD
57# b4_yyerror_args
58# ---------------
59# Arguments passed to yyerror: user args plus yylloc.
60m4_define([b4_yyerror_args],
61[b4_pure_if([b4_location_if([yylocp, ])])dnl
62m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
63
64
65# b4_lyyerror_args
66# ----------------
67# Same as above, but on the lookahead, hence yyllocp instead of yylocp.
68m4_define([b4_lyyerror_args],
69[b4_pure_if([b4_location_if([yyllocp, ])])dnl
70m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
71
72
2a8d363a
AD
73# b4_pure_args
74# ------------
93724f13 75# Arguments needed by yyerror: user args plus yylloc.
2a8d363a
AD
76m4_define([b4_pure_args],
77[b4_pure_if([b4_location_if([, yylocp])])[]b4_user_args])
78
79
80# b4_pure_formals
81# ---------------
82# Arguments passed to yyerror: user formals plus yyllocp.
83m4_define([b4_pure_formals],
84[b4_pure_if([b4_location_if([, YYLTYPE *yylocp])])[]b4_user_formals])
85
86
87# b4_lpure_args
88# -------------
89# Same as above, but on the lookahead, hence yyllocp instead of yylocp.
90m4_define([b4_lpure_args],
91[b4_pure_if([b4_location_if([, yyllocp])])[]b4_user_args])
0245f82d 92
66d30cd4 93
2a8d363a
AD
94# b4_lpure_formals
95# ----------------
96# Same as above, but on the lookahead, hence yyllocp instead of yylocp.
97m4_define([b4_lpure_formals],
98[b4_pure_if([b4_location_if([YYLTYPE *yyllocp])])[]b4_user_formals])
99
66d30cd4
AD
100
101## ----------------- ##
102## Semantic Values. ##
103## ----------------- ##
104
105
01241d47
PH
106# b4_lhs_value([TYPE])
107# --------------------
108# Expansion of $<TYPE>$.
109m4_define([b4_lhs_value],
110[(*yyvalp)[]m4_ifval([$1], [.$1])])
111
112
113# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
114# --------------------------------------
115# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
116# symbols on RHS.
117m4_define([b4_rhs_value],
947427ae 118[yyvsp@{m4_eval([$2 - $1])@}.yystate.yysemantics.yysval[]m4_ifval([$3], [.$3])])
01241d47
PH
119
120
121
122## ----------- ##
123## Locations. ##
124## ----------- ##
125
01241d47
PH
126# b4_lhs_location()
127# -----------------
128# Expansion of @$.
129m4_define([b4_lhs_location],
130[(*yylocp)])
131
132
133# b4_rhs_location(RULE-LENGTH, NUM)
134# ---------------------------------
135# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
136# on RHS.
137m4_define([b4_rhs_location],
947427ae 138[yyvsp@{m4_eval([$2 - $1])@}.yystate.yyloc])
01241d47
PH
139
140
b526ee61
AD
141# We do want M4 expansion after # for CPP macros.
142m4_changecom()
01241d47 143m4_divert(0)dnl
947427ae 144@output @output_parser_name@
fb8135fa
AD
145b4_copyright([Skeleton parser for GLR parsing with Bison], [2002])
146[
01241d47
PH
147/* This is the parser code for GLR (Generalized LR) parser. */
148
cf126971 149#include <assert.h>
cf126971
PE
150#include <stdio.h>
151#include <stdlib.h>
152#include <string.h>
2a8d363a
AD
153#include <stdarg.h>
154#include <setjmp.h>
01241d47 155
2a8d363a
AD
156]b4_identification
157m4_if(b4_prefix[], [yy], [],
01241d47
PH
158[/* If NAME_PREFIX is specified substitute the variables and functions
159 names. */
160#define yyparse b4_prefix[]parse
161#define yylex b4_prefix[]lex
162#define yyerror b4_prefix[]error
163#define yylval b4_prefix[]lval
164#define yychar b4_prefix[]char
165#define yydebug b4_prefix[]debug
166#define yynerrs b4_prefix[]nerrs
167b4_location_if([#define yylloc b4_prefix[]lloc])])
168
17acead5 169b4_token_defines(b4_tokens)
01241d47 170
17acead5
PE
171/* Copy the first part of user declarations. */
172b4_pre_prologue[
01241d47
PH
173
174/* Enabling traces. */
175#ifndef YYDEBUG
176# define YYDEBUG ]b4_debug[
177#endif
178
179/* Enabling verbose error messages. */
180#ifdef YYERROR_VERBOSE
181# undef YYERROR_VERBOSE
182# define YYERROR_VERBOSE 1
183#else
184# define YYERROR_VERBOSE ]b4_error_verbose[
185#endif
186
187#ifndef YYSTYPE
188]m4_ifdef([b4_stype],
437c2d80 189[b4_syncline([b4_stype_line], [b4_filename])
01241d47
PH
190typedef union b4_stype yystype;
191/* Line __line__ of __file__. */
947427ae 192b4_syncline([@oline@], [@ofile@])],
01241d47
PH
193[typedef int yystype;])[
194# define YYSTYPE yystype
195# define YYSTYPE_IS_TRIVIAL 1
196#endif
197
198#ifndef YYLTYPE
199typedef struct yyltype
200{
f50adbbd
AD
201 int first_line;
202 int first_column;
203 int last_line;
ffa4c58a 204 int last_column;
01241d47 205} yyltype;
66d30cd4 206# define YYLTYPE ]b4_location_type[
01241d47
PH
207# define YYLTYPE_IS_TRIVIAL 1
208#endif
209
210/* Default (constant) values used for initialization for null
fb8135fa 211 right-hand sides. Unlike the standard bison.simple template,
947427ae 212 here we set the default values of $$ and $@@ to zeroed-out
01241d47
PH
213 values. Since the default value of these quantities is undefined,
214 this behavior is technically correct. */
215static YYSTYPE yyval_default;
216static YYLTYPE yyloc_default;
217
218/* Copy the second part of user declarations. */
219]b4_post_prologue[
220
221]/* Line __line__ of __file__. */
947427ae 222b4_syncline([@oline@], [@ofile@])
01241d47
PH
223[
224#if ! defined (__cplusplus)
225 typedef char bool;
226# define yytrue 1
227# define yyfalse 0
228#endif
229
1154cced
AD
230/*-----------------.
231| GCC extensions. |
232`-----------------*/
233
234#ifndef __attribute__
235/* This feature is available in gcc versions 2.5 and later. */
236# if !defined (__GNUC__) || __GNUC__ < 2 || \
237(__GNUC__ == 2 && __GNUC_MINOR__ < 5) || __STRICT_ANSI__
238# define __attribute__(Spec) /* empty */
239# endif
240#endif
241
242#ifndef ATTRIBUTE_UNUSED
243# define ATTRIBUTE_UNUSED __attribute__ ((__unused__))
244#endif
245
01241d47 246/* YYFINAL -- State number of the termination state. */
7db2ed2d 247#define YYFINAL ]b4_final_state_number[
39912f52 248/* YYLAST -- Last index in YYTABLE. */
01241d47
PH
249#define YYLAST ]b4_last[
250
251/* YYNTOKENS -- Number of terminals. */
7db2ed2d 252#define YYNTOKENS ]b4_tokens_number[
01241d47 253/* YYNNTS -- Number of nonterminals. */
7db2ed2d 254#define YYNNTS ]b4_nterms_number[
01241d47 255/* YYNRULES -- Number of rules. */
7db2ed2d 256#define YYNRULES ]b4_rules_number[
01241d47 257/* YYNRULES -- Number of states. */
7db2ed2d 258#define YYNSTATES ]b4_states_number[
01241d47
PH
259/* YYMAXRHS -- Maximum number of symbols on right-hand side of rule. */
260#define YYMAXRHS ]b4_r2_max[
261
262/* YYTRANSLATE(X) -- Bison symbol number corresponding to X. */
263#define YYUNDEFTOK ]b4_undef_token_number[
264#define YYMAXUTOK ]b4_user_token_number_max[
265
b0400cc6
AD
266#define YYTRANSLATE(YYX) \
267 ((YYX <= 0) ? YYEOF : \
268 (unsigned)(YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
01241d47
PH
269
270/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
a762e609 271static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
01241d47
PH
272{
273 ]b4_translate[
274};
275
276#if YYDEBUG
277/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
278 YYRHS. */
a762e609 279static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
01241d47
PH
280{
281 ]b4_prhs[
282};
283
284/* YYRHS -- A `-1'-separated list of the rules' RHS. */
a762e609 285static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
01241d47
PH
286{
287 ]b4_rhs[
288};
289
290/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
a762e609 291static const ]b4_int_type_for([b4_rline])[ yyrline[] =
01241d47
PH
292{
293 ]b4_rline[
294};
295#endif
296
297#if (YYDEBUG) || YYERROR_VERBOSE
298/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
299 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
300static const char *const yytname[] =
301{
302 ]b4_tname[
303};
304
1154cced 305#define yytname_size ((int) (sizeof (yytname) / sizeof (yytname[0])))
01241d47
PH
306#endif
307
308/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
a762e609 309static const ]b4_int_type_for([b4_r1])[ yyr1[] =
01241d47
PH
310{
311 ]b4_r1[
312};
313
314/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
a762e609 315static const ]b4_int_type_for([b4_r2])[ yyr2[] =
01241d47
PH
316{
317 ]b4_r2[
318};
319
320/* YYDPREC[RULE-NUM] -- Dynamic precedence of rule #RULE-NUM (0 if none). */
a762e609 321static const ]b4_int_type_for([b4_dprec])[ yydprec[] =
01241d47
PH
322{
323 ]b4_dprec[
324};
325
326/* YYMERGER[RULE-NUM] -- Index of merging function for rule #RULE-NUM. */
a762e609 327static const ]b4_int_type_for([b4_merger])[ yymerger[] =
01241d47
PH
328{
329 ]b4_merger[
330};
331
332/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
333 doesn't specify something else to do. Zero means the default is an
334 error. */
a762e609 335static const ]b4_int_type_for([b4_defact])[ yydefact[] =
01241d47
PH
336{
337 ]b4_defact[
338};
339
12b0043a 340/* YYPDEFGOTO[NTERM-NUM]. */
a762e609 341static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
01241d47
PH
342{
343 ]b4_defgoto[
344};
345
346/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
347 STATE-NUM. */
12b0043a 348#define YYPACT_NINF ]b4_pact_ninf[
a762e609 349static const ]b4_int_type_for([b4_pact])[ yypact[] =
01241d47
PH
350{
351 ]b4_pact[
352};
353
354/* YYPGOTO[NTERM-NUM]. */
a762e609 355static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
01241d47
PH
356{
357 ]b4_pgoto[
358};
359
360/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
361 positive, shift that token. If negative, reduce the rule which
f50adbbd 362 number is the opposite. If zero, do what YYDEFACT says.
6e649e65 363 If YYTABLE_NINF, syntax error. */
12b0043a 364#define YYTABLE_NINF ]b4_table_ninf[
a762e609 365static const ]b4_int_type_for([b4_table])[ yytable[] =
01241d47
PH
366{
367 ]b4_table[
368};
369
ea99527d
AD
370/* YYCONFLP[YYPACT[STATE-NUM]] -- Pointer into YYCONFL of start of
371 list of conflicting reductions corresponding to action entry for
372 state STATE-NUM in yytable. 0 means no conflicts. The list in
373 yyconfl is terminated by a rule number of 0. */
a762e609 374static const ]b4_int_type_for([b4_conflict_list_heads])[ yyconflp[] =
01241d47
PH
375{
376 ]b4_conflict_list_heads[
377};
378
ea99527d
AD
379/* YYCONFL[I] -- lists of conflicting rule numbers, each terminated by
380 0, pointed into by YYCONFLP. */
a762e609
AD
381]dnl Do not use b4_int_type_for here, since there are places where
382dnl pointers onto yyconfl are taken, which type is "short *".
383dnl We probably ought to introduce a type for confl.
384[static const short yyconfl[] =
01241d47
PH
385{
386 ]b4_conflicting_rules[
387};
388
a762e609 389static const ]b4_int_type_for([b4_check])[ yycheck[] =
01241d47
PH
390{
391 ]b4_check[
392};
393
7bd6c77e
AD
394/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
395 symbol of state STATE-NUM. */
396static const ]b4_int_type_for([b4_stos])[ yystos[] =
397{
398 ]b4_stos[
399};
400
01241d47 401\f
0245f82d 402/* Prevent warning if -Wmissing-prototypes. */
2a8d363a 403]b4_c_ansi_function_decl([yyparse], [int], b4_parse_param)[
e7cb57c0 404
2a8d363a 405/* Error token number */
01241d47
PH
406#define YYTERROR 1
407
408/* YYLLOC_DEFAULT -- Compute the default location (before the actions
409 are run). */
410
411#define YYRHSLOC(yyRhs,YYK) (yyRhs[YYK].yystate.yyloc)
412
413#ifndef YYLLOC_DEFAULT
12b0043a 414# define YYLLOC_DEFAULT(yyCurrent, yyRhs, YYN) \
f50adbbd
AD
415 yyCurrent.first_line = YYRHSLOC(yyRhs,1).first_line; \
416 yyCurrent.first_column = YYRHSLOC(yyRhs,1).first_column; \
417 yyCurrent.last_line = YYRHSLOC(yyRhs,YYN).last_line; \
418 yyCurrent.last_column = YYRHSLOC(yyRhs,YYN).last_column;
01241d47
PH
419#endif
420
421/* YYLEX -- calling `yylex' with the right arguments. */
21964f43 422#define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
01241d47
PH
423
424]b4_pure_if(
425[
01241d47
PH
426#undef yynerrs
427#define yynerrs (yystack->yyerrcnt)
428#undef yychar
429#define yychar (yystack->yyrawchar)],
430[YYSTYPE yylval;
431
432YYLTYPE yylloc;
433
434int yynerrs;
435int yychar;])[
436
437static const int YYEOF = 0;
438static const int YYEMPTY = -2;
439
440typedef enum { yyok, yyaccept, yyabort, yyerr } YYRESULTTAG;
441
442#define YYCHK(YYE) \
443 do { YYRESULTTAG yyflag = YYE; if (yyflag != yyok) return yyflag; } \
444 while (0)
445
446#if YYDEBUG
447
448#if ! defined (YYFPRINTF)
449# define YYFPRINTF fprintf
450#endif
451
452# define YYDPRINTF(Args) \
453do { \
454 if (yydebug) \
455 YYFPRINTF Args; \
456} while (0)
7bd6c77e
AD
457
458]b4_yysymprint_generate([b4_c_ansi_function_def])[
459
460# define YYDSYMPRINT(Args) \
461do { \
462 if (yydebug) \
463 yysymprint Args; \
464} while (0)
465
9c1e26bd
AD
466# define YYDSYMPRINTF(Title, Token, Value, Location) \
467do { \
468 if (yydebug) \
469 { \
470 YYFPRINTF (stderr, "%s ", Title); \
471 yysymprint (stderr, \
472 Token, Value]b4_location_if([, Location])[); \
473 YYFPRINTF (stderr, "\n"); \
474 } \
475} while (0)
476
01241d47
PH
477/* Nonzero means print parse trace. It is left uninitialized so that
478 multiple parsers can coexist. */
479int yydebug;
7bd6c77e 480
01241d47 481#else /* !YYDEBUG */
7bd6c77e 482
1154cced 483 /* Avoid empty `if' bodies. */
7bd6c77e
AD
484# define YYDPRINTF(Args) {}
485# define YYDSYMPRINT(Args) {}
9c1e26bd 486# define YYDSYMPRINTF(Title, Token, Value, Location) {}
7bd6c77e 487
01241d47
PH
488#endif /* !YYDEBUG */
489
490/* YYINITDEPTH -- initial size of the parser's stacks. */
491#ifndef YYINITDEPTH
66d30cd4 492# define YYINITDEPTH ]b4_stack_depth_init[
01241d47
PH
493#endif
494
495/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
496 if the built-in stack extension method is used).
497
498 Do not make this value too large; the results are undefined if
fb8135fa 499 SIZE_MAX < YYMAXDEPTH * sizeof (GLRStackItem)
01241d47
PH
500 evaluated with infinite-precision integer arithmetic. */
501
502#if YYMAXDEPTH == 0
503# undef YYMAXDEPTH
504#endif
505
506#ifndef YYMAXDEPTH
66d30cd4 507# define YYMAXDEPTH ]b4_stack_depth_max[
01241d47
PH
508#endif
509
510/* Minimum number of free items on the stack allowed after an
fb8135fa
AD
511 allocation. This is to allow allocation and initialization
512 to be completed by functions that call expandGLRStack before the
513 stack is expanded, thus insuring that all necessary pointers get
01241d47
PH
514 properly redirected to new data. */
515#define YYHEADROOM 2
516
517#if ! defined (YYSTACKEXPANDABLE) \
518 && (! defined (__cplusplus) || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL))
519#define YYSTACKEXPANDABLE 1
520#else
521#define YYSTACKEXPANDABLE 0
522#endif
523
524/** State numbers, as in LALR(1) machine */
525typedef int yyStateNum;
526
527/** Rule numbers, as in LALR(1) machine */
528typedef int yyRuleNum;
529
530/** Grammar symbol */
531typedef short yySymbol;
532
533/** Item references, as in LALR(1) machine */
534typedef short yyItemNum;
535
536typedef struct yyGLRState yyGLRState;
537typedef struct yySemanticOption yySemanticOption;
538typedef union yyGLRStackItem yyGLRStackItem;
539typedef struct yyGLRStack yyGLRStack;
540typedef struct yyGLRStateSet yyGLRStateSet;
541
542struct yyGLRState {
fb8135fa 543 bool yyisState;
01241d47
PH
544 bool yyresolved;
545 yyStateNum yylrState;
546 yyGLRState* yypred;
547 size_t yyposn;
548 union {
549 yySemanticOption* yyfirstVal;
550 YYSTYPE yysval;
551 } yysemantics;
552 YYLTYPE yyloc;
553};
554
555struct yyGLRStateSet {
556 yyGLRState** yystates;
557 size_t yysize, yycapacity;
558};
559
560struct yySemanticOption {
561 bool yyisState;
562 yyRuleNum yyrule;
563 yyGLRState* yystate;
564 yySemanticOption* yynext;
565};
566
567union yyGLRStackItem {
568 yyGLRState yystate;
569 yySemanticOption yyoption;
570};
571
572struct yyGLRStack {
573 int yyerrflag;
574 int yyerrState;
575]b4_pure_if(
576[
577 int yyerrcnt;
578 int yyrawchar;
579])[
580 yySymbol* yytokenp;
581 jmp_buf yyexception_buffer;
582 yyGLRStackItem* yyitems;
583 yyGLRStackItem* yynextFree;
584 int yyspaceLeft;
585 yyGLRState* yysplitPoint;
586 yyGLRState* yylastDeleted;
587 yyGLRStateSet yytops;
588};
589
590static void yyinitGLRStack (yyGLRStack* yystack, size_t yysize);
2a8d363a 591static void yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[);
01241d47
PH
592static void yyfreeGLRStack (yyGLRStack* yystack);
593
594static void
2a8d363a 595yyFail (yyGLRStack* yystack]b4_pure_formals[, const char* yyformat, ...)
01241d47 596{
970785f1 597 yystack->yyerrflag = 1;
01241d47
PH
598 if (yyformat != NULL)
599 {
600 char yymsg[256];
601 va_list yyap;
602 va_start (yyap, yyformat);
01241d47 603 vsprintf (yymsg, yyformat, yyap);
93724f13 604 yyerror (]b4_yyerror_args[yymsg);
01241d47
PH
605 }
606 longjmp (yystack->yyexception_buffer, 1);
607}
608
609#if YYDEBUG || YYERROR_VERBOSE
610/** A printable representation of TOKEN. Valid until next call to
611 * tokenName. */
fb8135fa
AD
612static inline const char*
613yytokenName (yySymbol yytoken)
01241d47
PH
614{
615 return yytname[yytoken];
616}
617#endif
618
619/** Perform user action for rule number YYN, with RHS length YYRHSLEN,
620 * and top stack item YYVSP. YYLVALP points to place to put semantic
621 * value ($$), and yylocp points to place for location information
947427ae 622 * (@@$). Returns yyok for normal return, yyaccept for YYACCEPT,
01241d47
PH
623 * yyerr for YYERROR, yyabort for YYABORT. */
624static YYRESULTTAG
fb8135fa 625yyuserAction (yyRuleNum yyn, int yyrhslen, yyGLRStackItem* yyvsp,
e7cb57c0 626 YYSTYPE* yyvalp, YYLTYPE* yylocp, yyGLRStack* yystack
2a8d363a 627 ]b4_user_formals[)
01241d47 628{
1154cced
AD
629 /* Avoid `unused' warnings in there are no $n. */
630 (void) yystack;
631
fb8135fa 632 if (yyrhslen == 0)
01241d47
PH
633 {
634 *yyvalp = yyval_default;
635 *yylocp = yyloc_default;
636 }
fb8135fa 637 else
01241d47
PH
638 {
639 *yyvalp = yyvsp[1-yyrhslen].yystate.yysemantics.yysval;
640 *yylocp = yyvsp[1-yyrhslen].yystate.yyloc;
641 }
01241d47
PH
642# undef yyerrok
643# define yyerrok (yystack->yyerrState = 0)
644# undef YYACCEPT
645# define YYACCEPT return yyaccept
646# undef YYABORT
647# define YYABORT return yyabort
648# undef YYERROR
649# define YYERROR return yyerr
650# undef YYRECOVERING
651# define YYRECOVERING (yystack->yyerrState != 0)
652# undef yyclearin
653# define yyclearin (yychar = *(yystack->yytokenp) = YYEMPTY)
654# undef YYBACKUP
655# define YYBACKUP(Token, Value) \
656 do { \
93724f13 657 yyerror (]b4_yyerror_args["syntax error: cannot back up"); \
01241d47
PH
658 YYERROR; \
659 } while (0)
660
661]
fb8135fa 662 switch (yyn)
01241d47
PH
663 {
664 b4_actions
665 }
666
667 return yyok;
01241d47
PH
668# undef yyerrok
669# undef YYABORT
670# undef YYACCEPT
671# undef YYERROR
672# undef YYBACKUP
673# undef yyclearin
674# undef YYRECOVERING
675/* Line __line__ of __file__. */
947427ae 676b4_syncline([@oline@], [@ofile@])
01241d47
PH
677}
678\f
679
680static YYSTYPE
681yyuserMerge (int yyn, YYSTYPE* yy0, YYSTYPE* yy1)
682{
683 YYSTYPE yyval = *yy0;
2a8d363a 684 /* `Use' the arguments. */
1154cced
AD
685 (void) yy0;
686 (void) yy1;
687
fb8135fa 688 switch (yyn)
01241d47
PH
689 {
690 b4_mergers
691 }
692 return yyval;
693}
694[
2a8d363a 695 /* Bison grammar-table manipulation. */
01241d47 696
7bd6c77e
AD
697]b4_yydestruct_generate([b4_c_ansi_function_def])[
698
01241d47
PH
699/** Number of symbols composing the right hand side of rule #RULE. */
700static inline int
fb8135fa 701yyrhsLength (yyRuleNum yyrule)
01241d47
PH
702{
703 return yyr2[yyrule];
704}
705
706/** Left-hand-side symbol for rule #RULE. */
707static inline yySymbol
fb8135fa 708yylhsNonterm (yyRuleNum yyrule)
01241d47
PH
709{
710 return yyr1[yyrule];
711}
712
944ed9f4
PE
713#define yyis_pact_ninf(yystate) \
714 ]m4_if(m4_eval(b4_pact_ninf < b4_pact_min), 1,
715 0,
716 ((yystate) == YYPACT_NINF))[
717
01241d47
PH
718/** True iff LR state STATE has only a default reduction (regardless
719 * of token). */
720static inline bool
721yyisDefaultedState (yyStateNum yystate)
722{
944ed9f4 723 return yyis_pact_ninf (yypact[yystate]);
01241d47 724}
fb8135fa 725
01241d47
PH
726/** The default reduction for STATE, assuming it has one. */
727static inline yyRuleNum
728yydefaultAction (yyStateNum yystate)
729{
730 return yydefact[yystate];
731}
732
944ed9f4
PE
733#define yyis_table_ninf(yyindex) \
734 ]m4_if(m4_eval(b4_table_ninf < b4_table_min), 1,
735 0,
736 ((yyindex) == YYTABLE_NINF))[
737
2a1fe6ed 738/** Set *YYACTION to the action to take in YYSTATE on seeing YYTOKEN.
01241d47
PH
739 * Result R means
740 * R < 0: Reduce on rule -R.
741 * R = 0: Error.
fb8135fa
AD
742 * R > 0: Shift to state R.
743 * Set *CONFLICTS to a pointer into yyconfl to 0-terminated list of
01241d47
PH
744 * conflicting reductions.
745 */
746static inline void
fb8135fa 747yygetLRActions (yyStateNum yystate, int yytoken,
01241d47
PH
748 int* yyaction, const short** yyconflicts)
749{
750 int yyindex = yypact[yystate] + yytoken;
f50adbbd 751 if (yyindex < 0 || YYLAST < yyindex || yycheck[yyindex] != yytoken)
01241d47
PH
752 {
753 *yyaction = -yydefact[yystate];
754 *yyconflicts = yyconfl;
755 }
944ed9f4 756 else if (! yyis_table_ninf (yyindex))
01241d47
PH
757 {
758 *yyaction = yytable[yyindex];
759 *yyconflicts = yyconfl + yyconflp[yyindex];
760 }
f50adbbd
AD
761 else
762 {
763 *yyaction = 0;
764 *yyconflicts = yyconfl + yyconflp[yyindex];
765 }
01241d47
PH
766}
767
768static inline yyStateNum
769yyLRgotoState (yyStateNum yystate, yySymbol yylhs)
770{
771 int yyr;
772 yyr = yypgoto[yylhs - YYNTOKENS] + yystate;
f50adbbd 773 if (0 <= yyr && yyr <= YYLAST && yycheck[yyr] == yystate)
01241d47
PH
774 return yytable[yyr];
775 else
776 return yydefgoto[yylhs - YYNTOKENS];
777}
778
779static inline bool
fb8135fa 780yyisShiftAction (int yyaction)
01241d47 781{
39912f52 782 return 0 < yyaction;
01241d47
PH
783}
784
785static inline bool
fb8135fa 786yyisErrorAction (int yyaction)
01241d47 787{
f50adbbd 788 return yyaction == 0;
01241d47
PH
789}
790
791 /* GLRStates */
792
793/** True iff the semantic value of the edge leading to STATE is
794 * resolved. */
795static inline bool
fb8135fa 796yyhasResolvedValue (yyGLRState* yystate)
01241d47
PH
797{
798 return yystate->yyresolved;
799}
800
1154cced
AD
801static void
802yyaddDeferredAction (yyGLRStack* yystack, yyGLRState* yystate,
2a8d363a 803 yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[)
01241d47
PH
804{
805 yySemanticOption* yynewItem;
806 yynewItem = &yystack->yynextFree->yyoption;
807 yystack->yyspaceLeft -= 1;
808 yystack->yynextFree += 1;
809 yynewItem->yyisState = yyfalse;
6fed0802 810 yynewItem->yystate = rhs;
fb8135fa 811 yynewItem->yyrule = yyrule;
01241d47
PH
812 yynewItem->yynext = yystate->yysemantics.yyfirstVal;
813 yystate->yysemantics.yyfirstVal = yynewItem;
814 if (yystack->yyspaceLeft < YYHEADROOM)
2a8d363a 815 yyexpandGLRStack (yystack]b4_pure_args[);
01241d47
PH
816}
817
818 /* GLRStacks */
819
820/** Initialize SET to a singleton set containing an empty stack. */
821static void
822yyinitStateSet (yyGLRStateSet* yyset)
823{
824 yyset->yysize = 1;
825 yyset->yycapacity = 16;
826 yyset->yystates = (yyGLRState**) malloc (16 * sizeof (yyset->yystates[0]));
827 yyset->yystates[0] = NULL;
828}
829
fb8135fa 830static void yyfreeStateSet (yyGLRStateSet* yyset)
01241d47
PH
831{
832 free (yyset->yystates);
833}
834
835/** Initialize STACK to a single empty stack, with total maximum
836 * capacity for all stacks of SIZE. */
837static void
838yyinitGLRStack (yyGLRStack* yystack, size_t yysize)
839{
840 yystack->yyerrflag = 0;
841 yystack->yyerrState = 0;
842 yynerrs = 0;
843 yystack->yyspaceLeft = yysize;
fb8135fa 844 yystack->yynextFree = yystack->yyitems =
01241d47
PH
845 (yyGLRStackItem*) malloc (yysize * sizeof (yystack->yynextFree[0]));
846 yystack->yysplitPoint = NULL;
847 yystack->yylastDeleted = NULL;
848 yyinitStateSet (&yystack->yytops);
849}
850
851#define YYRELOC(YYFROMITEMS,YYTOITEMS,YYX,YYTYPE) \
852 &((YYTOITEMS) - ((YYFROMITEMS) - (yyGLRStackItem*) (YYX)))->YYTYPE
853
854/** If STACK is expandable, extend it. WARNING: Pointers into the
855 stack from outside should be considered invalid after this call.
856 We always expand when there are 1 or fewer items left AFTER an
857 allocation, so that we can avoid having external pointers exist
858 across an allocation. */
859static void
2a8d363a 860yyexpandGLRStack (yyGLRStack* yystack]b4_pure_formals[)
01241d47
PH
861{
862#if YYSTACKEXPANDABLE
863 yyGLRStack yynewStack;
864 yyGLRStackItem* yyp0, *yyp1;
865 size_t yysize, yynewSize;
866 size_t yyn;
867 yysize = yystack->yynextFree - yystack->yyitems;
39912f52 868 if (YYMAXDEPTH <= yysize)
6e649e65 869 yyFail (yystack][]b4_pure_args[, "parser stack overflow");
01241d47 870 yynewSize = 2*yysize;
39912f52 871 if (YYMAXDEPTH < yynewSize)
01241d47
PH
872 yynewSize = YYMAXDEPTH;
873 yyinitGLRStack (&yynewStack, yynewSize);
fb8135fa 874 for (yyp0 = yystack->yyitems, yyp1 = yynewStack.yyitems, yyn = yysize;
39912f52 875 0 < yyn;
fb8135fa 876 yyn -= 1, yyp0 += 1, yyp1 += 1)
01241d47
PH
877 {
878 *yyp1 = *yyp0;
fb8135fa
AD
879 if (*(bool*) yyp0)
880 {
01241d47
PH
881 yyGLRState* yys0 = &yyp0->yystate;
882 yyGLRState* yys1 = &yyp1->yystate;
fb8135fa
AD
883 if (yys0->yypred != NULL)
884 yys1->yypred =
01241d47
PH
885 YYRELOC (yyp0, yyp1, yys0->yypred, yystate);
886 if (! yys0->yyresolved && yys0->yysemantics.yyfirstVal != NULL)
fb8135fa 887 yys1->yysemantics.yyfirstVal =
01241d47
PH
888 YYRELOC(yyp0, yyp1, yys0->yysemantics.yyfirstVal, yyoption);
889 }
fb8135fa 890 else
01241d47
PH
891 {
892 yySemanticOption* yyv0 = &yyp0->yyoption;
893 yySemanticOption* yyv1 = &yyp1->yyoption;
894 if (yyv0->yystate != NULL)
895 yyv1->yystate = YYRELOC (yyp0, yyp1, yyv0->yystate, yystate);
896 if (yyv0->yynext != NULL)
897 yyv1->yynext = YYRELOC (yyp0, yyp1, yyv0->yynext, yyoption);
898 }
899 }
900 if (yystack->yysplitPoint != NULL)
fb8135fa 901 yystack->yysplitPoint = YYRELOC (yystack->yyitems, yynewStack.yyitems,
01241d47 902 yystack->yysplitPoint, yystate);
fb8135fa
AD
903
904 for (yyn = 0; yyn < yystack->yytops.yysize; yyn += 1)
01241d47 905 if (yystack->yytops.yystates[yyn] != NULL)
fb8135fa
AD
906 yystack->yytops.yystates[yyn] =
907 YYRELOC (yystack->yyitems, yynewStack.yyitems,
01241d47
PH
908 yystack->yytops.yystates[yyn], yystate);
909 free (yystack->yyitems);
910 yystack->yyitems = yynewStack.yyitems;
911 yystack->yynextFree = yynewStack.yynextFree + yysize;
912 yystack->yyspaceLeft = yynewStack.yyspaceLeft - yysize;
913
914#else
fb8135fa 915
6e649e65 916 yyFail (yystack][]b4_lpure_args[, "parser stack overflow");
fb8135fa 917#endif
01241d47
PH
918}
919
920static void
fb8135fa 921yyfreeGLRStack (yyGLRStack* yystack)
01241d47
PH
922{
923 free (yystack->yyitems);
924 yyfreeStateSet (&yystack->yytops);
925}
926
927/** Assuming that S is a GLRState somewhere on STACK, update the
fb8135fa 928 * splitpoint of STACK, if needed, so that it is at least as deep as
01241d47
PH
929 * S. */
930static inline void
fb8135fa 931yyupdateSplit (yyGLRStack* yystack, yyGLRState* yys)
01241d47 932{
fb8135fa 933 if (yystack->yysplitPoint != NULL && yystack->yysplitPoint > yys)
01241d47
PH
934 yystack->yysplitPoint = yys;
935}
936
937/** Invalidate stack #K in STACK. */
938static inline void
fb8135fa 939yymarkStackDeleted (yyGLRStack* yystack, int yyk)
01241d47
PH
940{
941 if (yystack->yytops.yystates[yyk] != NULL)
942 yystack->yylastDeleted = yystack->yytops.yystates[yyk];
943 yystack->yytops.yystates[yyk] = NULL;
944}
945
fb8135fa 946/** Undelete the last stack that was marked as deleted. Can only be
01241d47
PH
947 done once after a deletion, and only when all other stacks have
948 been deleted. */
949static void
950yyundeleteLastStack (yyGLRStack* yystack)
951{
952 if (yystack->yylastDeleted == NULL || yystack->yytops.yysize != 0)
953 return;
fb8135fa 954 yystack->yytops.yystates[0] = yystack->yylastDeleted;
01241d47
PH
955 yystack->yytops.yysize = 1;
956 YYDPRINTF ((stderr, "Restoring last deleted stack as stack #0.\n"));
957 yystack->yylastDeleted = NULL;
958}
959
960static inline void
961yyremoveDeletes (yyGLRStack* yystack)
962{
1154cced 963 size_t yyi, yyj;
01241d47 964 yyi = yyj = 0;
fb8135fa 965 while (yyj < yystack->yytops.yysize)
01241d47
PH
966 {
967 if (yystack->yytops.yystates[yyi] == NULL)
968 {
1154cced 969 if (yyi == yyj)
01241d47
PH
970 YYDPRINTF ((stderr, "Removing dead stacks.\n"));
971 yystack->yytops.yysize -= 1;
972 }
fb8135fa 973 else
01241d47
PH
974 {
975 yystack->yytops.yystates[yyj] = yystack->yytops.yystates[yyi];
976 if (yyj != yyi)
977 YYDPRINTF ((stderr, "Rename stack %d -> %d.\n", yyi, yyj));
978 yyj += 1;
979 }
980 yyi += 1;
981 }
982}
983
fb8135fa 984/** Shift to a new state on stack #K of STACK, corresponding to LR state
01241d47
PH
985 * LRSTATE, at input position POSN, with (resolved) semantic value SVAL. */
986static inline void
fb8135fa 987yyglrShift (yyGLRStack* yystack, int yyk, yyStateNum yylrState, size_t yyposn,
2a8d363a 988 YYSTYPE yysval, YYLTYPE* yylocp]b4_user_formals[)
01241d47
PH
989{
990 yyGLRStackItem* yynewItem;
991
992 yynewItem = yystack->yynextFree;
993 yystack->yynextFree += 1;
994 yystack->yyspaceLeft -= 1;
995 yynewItem->yystate.yyisState = yytrue;
996 yynewItem->yystate.yylrState = yylrState;
997 yynewItem->yystate.yyposn = yyposn;
998 yynewItem->yystate.yyresolved = yytrue;
999 yynewItem->yystate.yypred = yystack->yytops.yystates[yyk];
1000 yystack->yytops.yystates[yyk] = &yynewItem->yystate;
1001 yynewItem->yystate.yysemantics.yysval = yysval;
1002 yynewItem->yystate.yyloc = *yylocp;
1003 if (yystack->yyspaceLeft < YYHEADROOM)
2a8d363a 1004 yyexpandGLRStack (yystack]b4_pure_args[);
01241d47
PH
1005}
1006
1007/** Shift to a new state on stack #K of STACK, to a new state
1008 * corresponding to LR state LRSTATE, at input position POSN, with
1009 * the (unresolved) semantic value of RHS under the action for RULE. */
1010static inline void
fb8135fa 1011yyglrShiftDefer (yyGLRStack* yystack, int yyk, yyStateNum yylrState,
2a8d363a 1012 size_t yyposn, yyGLRState* rhs, yyRuleNum yyrule]b4_pure_formals[)
01241d47
PH
1013{
1014 yyGLRStackItem* yynewItem;
1015
1016 yynewItem = yystack->yynextFree;
1017 yynewItem->yystate.yyisState = yytrue;
1018 yynewItem->yystate.yylrState = yylrState;
1019 yynewItem->yystate.yyposn = yyposn;
1020 yynewItem->yystate.yyresolved = yyfalse;
1021 yynewItem->yystate.yypred = yystack->yytops.yystates[yyk];
1022 yynewItem->yystate.yysemantics.yyfirstVal = NULL;
1023 yystack->yytops.yystates[yyk] = &yynewItem->yystate;
1024 yystack->yynextFree += 1;
1025 yystack->yyspaceLeft -= 1;
2a8d363a 1026 yyaddDeferredAction (yystack, &yynewItem->yystate, rhs, yyrule]b4_pure_args[);
01241d47
PH
1027}
1028
1029/** Pop the symbols consumed by reduction #RULE from the top of stack
fb8135fa
AD
1030 * #K of STACK, and perform the appropriate semantic action on their
1031 * semantic values. Assumes that all ambiguities in semantic values
01241d47
PH
1032 * have been previously resolved. Set *VALP to the resulting value,
1033 * and *LOCP to the computed location (if any). Return value is as
1034 * for userAction. */
ff032592 1035static inline YYRESULTTAG
01241d47 1036yydoAction (yyGLRStack* yystack, int yyk, yyRuleNum yyrule,
2a8d363a 1037 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
01241d47
PH
1038{
1039 int yynrhs = yyrhsLength (yyrule);
1040
fb8135fa 1041 if (yystack->yysplitPoint == NULL)
01241d47
PH
1042 {
1043 /* Standard special case: single stack. */
6fed0802 1044 yyGLRStackItem* rhs = (yyGLRStackItem*) yystack->yytops.yystates[yyk];
01241d47
PH
1045 assert (yyk == 0);
1046 yystack->yynextFree -= yynrhs;
1047 yystack->yyspaceLeft += yynrhs;
1048 yystack->yytops.yystates[0] = & yystack->yynextFree[-1].yystate;
fb8135fa 1049 if (yynrhs == 0)
01241d47
PH
1050 {
1051 *yyvalp = yyval_default;
1052 *yylocp = yyloc_default;
1053 }
fb8135fa 1054 else
01241d47 1055 {
6fed0802
AD
1056 *yyvalp = rhs[1-yynrhs].yystate.yysemantics.yysval;
1057 *yylocp = rhs[1-yynrhs].yystate.yyloc;
01241d47 1058 }
e7cb57c0 1059 return yyuserAction (yyrule, yynrhs, rhs,
2a8d363a 1060 yyvalp, yylocp, yystack]b4_user_args[);
01241d47 1061 }
fb8135fa 1062 else
01241d47
PH
1063 {
1064 int yyi;
1065 yyGLRState* yys;
1066 yyGLRStackItem yyrhsVals[YYMAXRHS];
39912f52 1067 for (yyi = yynrhs-1, yys = yystack->yytops.yystates[yyk]; 0 <= yyi;
fb8135fa 1068 yyi -= 1, yys = yys->yypred)
01241d47
PH
1069 {
1070 assert (yys->yypred != NULL);
1071 yyrhsVals[yyi].yystate.yyresolved = yytrue;
1072 yyrhsVals[yyi].yystate.yysemantics.yysval = yys->yysemantics.yysval;
1073 yyrhsVals[yyi].yystate.yyloc = yys->yyloc;
1074 }
1075 yyupdateSplit (yystack, yys);
1076 yystack->yytops.yystates[yyk] = yys;
fb8135fa 1077 if (yynrhs == 0)
01241d47
PH
1078 {
1079 *yyvalp = yyval_default;
1080 *yylocp = yyloc_default;
1081 }
fb8135fa 1082 else
01241d47
PH
1083 {
1084 *yyvalp = yyrhsVals[0].yystate.yysemantics.yysval;
1085 *yylocp = yyrhsVals[0].yystate.yyloc;
1086 }
fb8135fa 1087 return yyuserAction (yyrule, yynrhs, yyrhsVals + (yynrhs-1),
2a8d363a 1088 yyvalp, yylocp, yystack]b4_user_args[);
01241d47
PH
1089 }
1090}
1091
e7cb57c0
AD
1092#if !YYDEBUG
1093# define YY_REDUCE_PRINT(K, Rule)
1094#else
1095# define YY_REDUCE_PRINT(K, Rule) \
1096do { \
1097 if (yydebug) \
1098 yy_reduce_print (K, Rule); \
1099} while (0)
1100
1101/*----------------------------------------------------------.
1102| Report that the RULE is going to be reduced on stack #K. |
1103`----------------------------------------------------------*/
1104
1105static inline void
1106yy_reduce_print (size_t yyk, yyRuleNum yyrule)
1107{
1108 int yyi;
b0937b22
AD
1109 YYFPRINTF (stderr, "Reducing stack %d by rule %d (line %d), ",
1110 yyk, yyrule - 1, yyrline[yyrule]);
e7cb57c0
AD
1111 /* Print the symbols being reduced, and their result. */
1112 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
1113 YYFPRINTF (stderr, "%s ", yytokenName (yyrhs[yyi]));
9c1e26bd 1114 YYFPRINTF (stderr, "-> %s\n", yytokenName (yyr1[yyrule]));
e7cb57c0
AD
1115}
1116#endif
1117
01241d47
PH
1118/** Pop items off stack #K of STACK according to grammar rule RULE,
1119 * and push back on the resulting nonterminal symbol. Perform the
fb8135fa 1120 * semantic action associated with RULE and store its value with the
01241d47
PH
1121 * newly pushed state, if FORCEEVAL or if STACK is currently
1122 * unambiguous. Otherwise, store the deferred semantic action with
1123 * the new state. If the new state would have an identical input
1124 * position, LR state, and predecessor to an existing state on the stack,
fb8135fa
AD
1125 * it is identified with that existing state, eliminating stack #K from
1126 * the STACK. In this case, the (necessarily deferred) semantic value is
1127 * added to the options for the existing state's semantic value.
01241d47
PH
1128 */
1129static inline YYRESULTTAG
1154cced 1130yyglrReduce (yyGLRStack* yystack, size_t yyk, yyRuleNum yyrule,
2a8d363a 1131 bool yyforceEval]b4_pure_formals[)
01241d47 1132{
1154cced 1133 size_t yyposn = yystack->yytops.yystates[yyk]->yyposn;
01241d47 1134
fb8135fa 1135 if (yyforceEval || yystack->yysplitPoint == NULL)
01241d47
PH
1136 {
1137 YYSTYPE yysval;
1138 YYLTYPE yyloc;
fb8135fa 1139
e7cb57c0 1140 YY_REDUCE_PRINT (yyk, yyrule);
2a8d363a 1141 YYCHK (yydoAction (yystack, yyk, yyrule, &yysval, &yyloc]b4_user_args[));
fb8135fa
AD
1142 yyglrShift (yystack, yyk,
1143 yyLRgotoState (yystack->yytops.yystates[yyk]->yylrState,
01241d47 1144 yylhsNonterm (yyrule)),
2a8d363a 1145 yyposn, yysval, &yyloc]b4_user_args[);
01241d47 1146 }
fb8135fa 1147 else
01241d47 1148 {
1154cced
AD
1149 size_t yyi;
1150 int yyn;
01241d47
PH
1151 yyGLRState* yys, *yys0 = yystack->yytops.yystates[yyk];
1152 yyStateNum yynewLRState;
1153
fb8135fa 1154 for (yys = yystack->yytops.yystates[yyk], yyn = yyrhsLength (yyrule);
39912f52 1155 0 < yyn; yyn -= 1)
01241d47
PH
1156 {
1157 yys = yys->yypred;
1158 assert (yys != NULL);
1159 }
1160 yyupdateSplit (yystack, yys);
1161 yynewLRState = yyLRgotoState (yys->yylrState, yylhsNonterm (yyrule));
fb8135fa 1162 YYDPRINTF ((stderr,
01241d47
PH
1163 "Reduced stack %d by rule #%d; action deferred. "
1164 "Now in state %d.\n",
1165 yyk, yyrule-1, yynewLRState));
1166 for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1)
fb8135fa 1167 if (yyi != yyk && yystack->yytops.yystates[yyi] != NULL)
01241d47
PH
1168 {
1169 yyGLRState* yyp, *yysplit = yystack->yysplitPoint;
1170 yyp = yystack->yytops.yystates[yyi];
fb8135fa 1171 while (yyp != yys && yyp != yysplit && yyp->yyposn >= yyposn)
01241d47 1172 {
fb8135fa 1173 if (yyp->yylrState == yynewLRState && yyp->yypred == yys)
01241d47 1174 {
2a8d363a 1175 yyaddDeferredAction (yystack, yyp, yys0, yyrule]b4_pure_args[);
01241d47
PH
1176 yymarkStackDeleted (yystack, yyk);
1177 YYDPRINTF ((stderr, "Merging stack %d into stack %d.\n",
1178 yyk, yyi));
ff032592 1179 return yyok;
01241d47
PH
1180 }
1181 yyp = yyp->yypred;
1182 }
1183 }
1184 yystack->yytops.yystates[yyk] = yys;
2a8d363a 1185 yyglrShiftDefer (yystack, yyk, yynewLRState, yyposn, yys0, yyrule]b4_pure_args[);
fb8135fa 1186 }
ff032592 1187 return yyok;
01241d47
PH
1188}
1189
1190static int
1191yysplitStack (yyGLRStack* yystack, int yyk)
1192{
fb8135fa 1193 if (yystack->yysplitPoint == NULL)
01241d47
PH
1194 {
1195 assert (yyk == 0);
1196 yystack->yysplitPoint = yystack->yytops.yystates[yyk];
1197 }
fb8135fa 1198 if (yystack->yytops.yysize >= yystack->yytops.yycapacity)
01241d47
PH
1199 {
1200 yystack->yytops.yycapacity *= 2;
fb8135fa
AD
1201 yystack->yytops.yystates =
1202 (yyGLRState**) realloc (yystack->yytops.yystates,
1203 yystack->yytops.yycapacity
01241d47
PH
1204 * sizeof (yyGLRState*));
1205 }
fb8135fa 1206 yystack->yytops.yystates[yystack->yytops.yysize]
01241d47
PH
1207 = yystack->yytops.yystates[yyk];
1208 yystack->yytops.yysize += 1;
1209 return yystack->yytops.yysize-1;
1210}
1211
1212/** True iff Y0 and Y1 represent identical options at the top level.
1213 * That is, they represent the same rule applied to RHS symbols
1214 * that produce the same terminal symbols. */
1215static bool
1216yyidenticalOptions (yySemanticOption* yyy0, yySemanticOption* yyy1)
1217{
fb8135fa 1218 if (yyy0->yyrule == yyy1->yyrule)
01241d47
PH
1219 {
1220 yyGLRState *yys0, *yys1;
1221 int yyn;
fb8135fa 1222 for (yys0 = yyy0->yystate, yys1 = yyy1->yystate,
01241d47
PH
1223 yyn = yyrhsLength (yyy0->yyrule);
1224 yyn > 0;
1225 yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1)
1226 if (yys0->yyposn != yys1->yyposn)
1227 return yyfalse;
1228 return yytrue;
1229 }
1230 else
1231 return yyfalse;
1232}
1233
1234/** Assuming identicalOptions (Y0,Y1), (destructively) merge the
fb8135fa 1235 * alternative semantic values for the RHS-symbols of Y1 into the
01241d47
PH
1236 * corresponding semantic value sets of the symbols of Y0. */
1237static void
1238yymergeOptionSets (yySemanticOption* yyy0, yySemanticOption* yyy1)
1239{
1240 yyGLRState *yys0, *yys1;
1241 int yyn;
fb8135fa 1242 for (yys0 = yyy0->yystate, yys1 = yyy1->yystate,
01241d47
PH
1243 yyn = yyrhsLength (yyy0->yyrule);
1244 yyn > 0;
1245 yys0 = yys0->yypred, yys1 = yys1->yypred, yyn -= 1)
1246 if (yys0 == yys1)
1247 break;
fb8135fa 1248 else if (! yys0->yyresolved && ! yys1->yyresolved)
01241d47
PH
1249 {
1250 yySemanticOption* yyz;
fb8135fa 1251 for (yyz = yys0->yysemantics.yyfirstVal; yyz->yynext != NULL;
01241d47
PH
1252 yyz = yyz->yynext)
1253 ;
1254 yyz->yynext = yys1->yysemantics.yyfirstVal;
1255 }
1256}
1257
1258/** Y0 and Y1 represent two possible actions to take in a given
1259 * parsing state; return 0 if no combination is possible,
1260 * 1 if user-mergeable, 2 if Y0 is preferred, 3 if Y1 is preferred. */
1261static int
1154cced 1262yypreference (yySemanticOption* y0, yySemanticOption* y1)
01241d47 1263{
1154cced
AD
1264 yyRuleNum r0 = y0->yyrule, r1 = y1->yyrule;
1265 int p0 = yydprec[r0], p1 = yydprec[r1];
01241d47 1266
1154cced 1267 if (p0 == p1)
01241d47 1268 {
1154cced 1269 if (yymerger[r0] == 0 || yymerger[r0] != yymerger[r1])
01241d47
PH
1270 return 0;
1271 else
1272 return 1;
1273 }
1154cced 1274 if (p0 == 0 || p1 == 0)
01241d47 1275 return 0;
1154cced 1276 if (p0 < p1)
01241d47 1277 return 3;
39912f52 1278 if (p1 < p0)
01241d47
PH
1279 return 2;
1280 return 0;
1281}
1282
fb8135fa
AD
1283static YYRESULTTAG yyresolveValue (yySemanticOption* yyoptionList,
1284 yyGLRStack* yystack, YYSTYPE* yyvalp,
2a8d363a 1285 YYLTYPE* yylocp]b4_user_formals[);
01241d47
PH
1286
1287static YYRESULTTAG
2a8d363a 1288yyresolveStates (yyGLRState* yys, int yyn, yyGLRStack* yystack]b4_user_formals[)
01241d47
PH
1289{
1290 YYRESULTTAG yyflag;
39912f52 1291 if (0 < yyn)
01241d47
PH
1292 {
1293 assert (yys->yypred != NULL);
2a8d363a 1294 yyflag = yyresolveStates (yys->yypred, yyn-1, yystack]b4_user_args[);
01241d47
PH
1295 if (yyflag != yyok)
1296 return yyflag;
fb8135fa 1297 if (! yys->yyresolved)
01241d47
PH
1298 {
1299 yyflag = yyresolveValue (yys->yysemantics.yyfirstVal, yystack,
e7cb57c0 1300 &yys->yysemantics.yysval, &yys->yyloc
2a8d363a 1301 ]b4_user_args[);
01241d47
PH
1302 if (yyflag != yyok)
1303 return yyflag;
1304 yys->yyresolved = yytrue;
1305 }
1306 }
1307 return yyok;
1308}
1309
1310static YYRESULTTAG
fb8135fa 1311yyresolveAction (yySemanticOption* yyopt, yyGLRStack* yystack,
2a8d363a 1312 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
01241d47
PH
1313{
1314 yyGLRStackItem yyrhsVals[YYMAXRHS];
1315 int yynrhs, yyi;
1316 yyGLRState* yys;
1317
1318 yynrhs = yyrhsLength (yyopt->yyrule);
2a8d363a 1319 YYCHK (yyresolveStates (yyopt->yystate, yynrhs, yystack]b4_user_args[));
39912f52 1320 for (yyi = yynrhs-1, yys = yyopt->yystate; 0 <= yyi;
01241d47
PH
1321 yyi -= 1, yys = yys->yypred)
1322 {
1323 assert (yys->yypred != NULL);
1324 yyrhsVals[yyi].yystate.yyresolved = yytrue;
1325 yyrhsVals[yyi].yystate.yysemantics.yysval = yys->yysemantics.yysval;
1326 yyrhsVals[yyi].yystate.yyloc = yys->yyloc;
fb8135fa
AD
1327 }
1328 return yyuserAction (yyopt->yyrule, yynrhs, yyrhsVals + (yynrhs-1),
2a8d363a 1329 yyvalp, yylocp, yystack]b4_user_args[);
01241d47
PH
1330}
1331
1332#if YYDEBUG
e7cb57c0
AD
1333static void
1334yyreportTree (yySemanticOption* yyx, int yyindent)
01241d47
PH
1335{
1336 int yynrhs = yyrhsLength (yyx->yyrule);
1337 int yyi;
1338 yyGLRState* yys;
1339 yyGLRState* yystates[YYMAXRHS];
782a05f9 1340 yyGLRState yyleftmost_state;
01241d47 1341
39912f52 1342 for (yyi = yynrhs, yys = yyx->yystate; 0 < yyi; yyi -= 1, yys = yys->yypred)
01241d47
PH
1343 yystates[yyi] = yys;
1344 if (yys == NULL)
782a05f9
PE
1345 {
1346 yyleftmost_state.yyposn = 0;
1347 yystates[0] = &yyleftmost_state;
1348 }
01241d47
PH
1349 else
1350 yystates[0] = yys;
1351
39912f52 1352 if (yyx->yystate->yyposn < yys->yyposn + 1)
01241d47 1353 YYFPRINTF (stderr, "%*s%s -> <Rule %d, empty>\n",
fb8135fa 1354 yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
01241d47
PH
1355 yyx->yyrule);
1356 else
fb8135fa 1357 YYFPRINTF (stderr, "%*s%s -> <Rule %d, tokens %d .. %d>\n",
01241d47
PH
1358 yyindent, "", yytokenName (yylhsNonterm (yyx->yyrule)),
1359 yyx->yyrule, yys->yyposn+1, yyx->yystate->yyposn);
fb8135fa 1360 for (yyi = 1; yyi <= yynrhs; yyi += 1)
01241d47 1361 {
fb8135fa 1362 if (yystates[yyi]->yyresolved)
01241d47
PH
1363 {
1364 if (yystates[yyi-1]->yyposn+1 > yystates[yyi]->yyposn)
1365 YYFPRINTF (stderr, "%*s%s <empty>\n", yyindent+2, "",
1366 yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]));
1367 else
1368 YYFPRINTF (stderr, "%*s%s <tokens %d .. %d>\n", yyindent+2, "",
1369 yytokenName (yyrhs[yyprhs[yyx->yyrule]+yyi-1]),
1370 yystates[yyi-1]->yyposn+1, yystates[yyi]->yyposn);
1371 }
fb8135fa 1372 else
01241d47
PH
1373 yyreportTree (yystates[yyi]->yysemantics.yyfirstVal, yyindent+2);
1374 }
1375}
fb8135fa 1376#endif
01241d47
PH
1377
1378static void
1379yyreportAmbiguity (yySemanticOption* yyx0, yySemanticOption* yyx1,
2a8d363a 1380 yyGLRStack* yystack]b4_pure_formals[)
01241d47 1381{
1154cced
AD
1382 /* `Unused' warnings. */
1383 (void) yyx0;
1384 (void) yyx1;
1385
01241d47
PH
1386#if YYDEBUG
1387 YYFPRINTF (stderr, "Ambiguity detected.\n");
1388 YYFPRINTF (stderr, "Option 1,\n");
1389 yyreportTree (yyx0, 2);
1390 YYFPRINTF (stderr, "\nOption 2,\n");
1391 yyreportTree (yyx1, 2);
1392 YYFPRINTF (stderr, "\n");
1393#endif
2a8d363a 1394 yyFail (yystack][]b4_pure_args[, "ambiguity detected");
01241d47
PH
1395}
1396
1397
1398/** Resolve the ambiguity represented by OPTIONLIST, perform the indicated
1399 * actions, and return the result. */
1400static YYRESULTTAG
fb8135fa 1401yyresolveValue (yySemanticOption* yyoptionList, yyGLRStack* yystack,
2a8d363a 1402 YYSTYPE* yyvalp, YYLTYPE* yylocp]b4_user_formals[)
01241d47
PH
1403{
1404 yySemanticOption* yybest;
1405 yySemanticOption* yyp;
1406 int yymerge;
1407
fb8135fa 1408 yybest = yyoptionList;
01241d47 1409 yymerge = 0;
fb8135fa 1410 for (yyp = yyoptionList->yynext; yyp != NULL; yyp = yyp->yynext)
01241d47
PH
1411 {
1412 if (yyidenticalOptions (yybest, yyp))
1413 yymergeOptionSets (yybest, yyp);
1414 else
fb8135fa 1415 switch (yypreference (yybest, yyp))
01241d47
PH
1416 {
1417 case 0:
2a8d363a 1418 yyreportAmbiguity (yybest, yyp, yystack]b4_pure_args[);
01241d47
PH
1419 break;
1420 case 1:
1421 yymerge = 1;
1422 break;
1423 case 2:
1424 break;
1425 case 3:
1426 yybest = yyp;
1427 yymerge = 0;
1428 break;
1429 }
1430 }
1431
fb8135fa 1432 if (yymerge)
01241d47
PH
1433 {
1434 int yyprec = yydprec[yybest->yyrule];
2a8d363a 1435 YYCHK (yyresolveAction (yybest, yystack, yyvalp, yylocp]b4_user_args[));
fb8135fa 1436 for (yyp = yybest->yynext; yyp != NULL; yyp = yyp->yynext)
01241d47 1437 {
fb8135fa 1438 if (yyprec == yydprec[yyp->yyrule])
01241d47
PH
1439 {
1440 YYSTYPE yyval1;
1441 YYLTYPE yydummy;
2a8d363a 1442 YYCHK (yyresolveAction (yyp, yystack, &yyval1, &yydummy]b4_user_args[));
01241d47
PH
1443 *yyvalp = yyuserMerge (yymerger[yyp->yyrule], yyvalp, &yyval1);
1444 }
1445 }
1446 return yyok;
1447 }
1448 else
2a8d363a 1449 return yyresolveAction (yybest, yystack, yyvalp, yylocp]b4_user_args[);
01241d47
PH
1450}
1451
1452static YYRESULTTAG
2a8d363a 1453yyresolveStack (yyGLRStack* yystack]b4_user_formals[)
01241d47 1454{
fb8135fa 1455 if (yystack->yysplitPoint != NULL)
01241d47
PH
1456 {
1457 yyGLRState* yys;
1458 int yyn;
1459
fb8135fa
AD
1460 for (yyn = 0, yys = yystack->yytops.yystates[0];
1461 yys != yystack->yysplitPoint;
01241d47
PH
1462 yys = yys->yypred, yyn += 1)
1463 ;
e7cb57c0 1464 YYCHK (yyresolveStates (yystack->yytops.yystates[0], yyn, yystack
2a8d363a 1465 ]b4_user_args[));
01241d47
PH
1466 }
1467 return yyok;
1468}
1469
1470static void
fb8135fa 1471yycompressStack (yyGLRStack* yystack)
01241d47
PH
1472{
1473 yyGLRState* yyp, *yyq, *yyr;
1474
1475 if (yystack->yytops.yysize != 1 || yystack->yysplitPoint == NULL)
1476 return;
1477
fb8135fa
AD
1478 for (yyp = yystack->yytops.yystates[0], yyq = yyp->yypred, yyr = NULL;
1479 yyp != yystack->yysplitPoint;
01241d47
PH
1480 yyr = yyp, yyp = yyq, yyq = yyp->yypred)
1481 yyp->yypred = yyr;
fb8135fa 1482
01241d47
PH
1483 yystack->yyspaceLeft += yystack->yynextFree - yystack->yyitems;
1484 yystack->yynextFree = ((yyGLRStackItem*) yystack->yysplitPoint) + 1;
1485 yystack->yyspaceLeft -= yystack->yynextFree - yystack->yyitems;
1486 yystack->yysplitPoint = NULL;
1487 yystack->yylastDeleted = NULL;
fb8135fa
AD
1488
1489 while (yyr != NULL)
1490 {
01241d47
PH
1491 yystack->yynextFree->yystate = *yyr;
1492 yyr = yyr->yypred;
1493 yystack->yynextFree->yystate.yypred = & yystack->yynextFree[-1].yystate;
1494 yystack->yytops.yystates[0] = &yystack->yynextFree->yystate;
1495 yystack->yynextFree += 1;
1496 yystack->yyspaceLeft -= 1;
1497 }
1498}
1499
1500static YYRESULTTAG
fb8135fa 1501yyprocessOneStack (yyGLRStack* yystack, int yyk,
e7cb57c0 1502 size_t yyposn, YYSTYPE* yylvalp, YYLTYPE* yyllocp
2a8d363a 1503 ]b4_user_formals[)
01241d47
PH
1504{
1505 int yyaction;
1506 const short* yyconflicts;
1507 yyRuleNum yyrule;
1508 yySymbol* const yytokenp = yystack->yytokenp;
1509
fb8135fa 1510 while (yystack->yytops.yystates[yyk] != NULL)
01241d47
PH
1511 {
1512 yyStateNum yystate = yystack->yytops.yystates[yyk]->yylrState;
b0937b22 1513 YYDPRINTF ((stderr, "Stack %d Entering state %d\n", yyk, yystate));
01241d47
PH
1514
1515 assert (yystate != YYFINAL);
fb8135fa 1516 if (yyisDefaultedState (yystate))
01241d47
PH
1517 {
1518 yyrule = yydefaultAction (yystate);
fb8135fa 1519 if (yyrule == 0)
01241d47
PH
1520 {
1521 YYDPRINTF ((stderr, "Stack %d dies.\n", yyk));
1522 yymarkStackDeleted (yystack, yyk);
1523 return yyok;
1524 }
2a8d363a 1525 YYCHK (yyglrReduce (yystack, yyk, yyrule, yyfalse]b4_lpure_args[));
01241d47 1526 }
fb8135fa 1527 else
01241d47 1528 {
fb8135fa 1529 if (*yytokenp == YYEMPTY)
01241d47 1530 {
2a1fe6ed 1531 YYDPRINTF ((stderr, "Reading a token: "));
01241d47 1532 yychar = YYLEX;
b0400cc6 1533 *yytokenp = YYTRANSLATE (yychar);
9c1e26bd 1534 YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp);
01241d47
PH
1535 }
1536 yygetLRActions (yystate, *yytokenp, &yyaction, &yyconflicts);
1537
fb8135fa 1538 while (*yyconflicts != 0)
01241d47
PH
1539 {
1540 int yynewStack = yysplitStack (yystack, yyk);
1541 YYDPRINTF ((stderr, "Splitting off stack %d from %d.\n",
1542 yynewStack, yyk));
e7cb57c0 1543 YYCHK (yyglrReduce (yystack, yynewStack,
2a8d363a 1544 *yyconflicts, yyfalse]b4_lpure_args[));
fb8135fa 1545 YYCHK (yyprocessOneStack (yystack, yynewStack, yyposn,
2a8d363a 1546 yylvalp, yyllocp]b4_user_args[));
01241d47
PH
1547 yyconflicts += 1;
1548 }
fb8135fa
AD
1549
1550 if (yyisShiftAction (yyaction))
01241d47 1551 {
2a1fe6ed 1552 YYDPRINTF ((stderr, "Shifting token %s on stack %d, ",
01241d47 1553 yytokenName (*yytokenp), yyk));
2a8d363a
AD
1554 yyglrShift (yystack, yyk, yyaction, yyposn+1,
1555 *yylvalp, yyllocp]b4_user_args[);
fb8135fa 1556 YYDPRINTF ((stderr, "which is now in state #%d\n",
01241d47
PH
1557 yystack->yytops.yystates[yyk]->yylrState));
1558 break;
1559 }
fb8135fa 1560 else if (yyisErrorAction (yyaction))
01241d47
PH
1561 {
1562 YYDPRINTF ((stderr, "Stack %d dies.\n", yyk));
1563 yymarkStackDeleted (yystack, yyk);
1564 break;
1565 }
1566 else
2a8d363a 1567 YYCHK (yyglrReduce (yystack, yyk, -yyaction, yyfalse]b4_lpure_args[));
01241d47
PH
1568 }
1569 }
1570 return yyok;
1571}
1572
1573static void
2a8d363a
AD
1574yyreportParseError (yyGLRStack* yystack,
1575 YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[)
01241d47 1576{
1154cced
AD
1577 /* `Unused' warnings. */
1578 (void) yylvalp;
1579 (void) yyllocp;
01241d47
PH
1580
1581 if (yystack->yyerrState == 0)
1582 {
fb8135fa 1583#if YYERROR_VERBOSE
1154cced 1584 yySymbol* const yytokenp = yystack->yytokenp;
cf126971
PE
1585 int yyn, yyx, yycount;
1586 size_t yysize;
1154cced 1587 const char* yyprefix;
01241d47
PH
1588 char* yyp;
1589 char* yymsg;
1590 yyn = yypact[yystack->yytops.yystates[0]->yylrState];
12b0043a 1591 if (YYPACT_NINF < yyn && yyn < YYLAST)
01241d47
PH
1592 {
1593 yycount = 0;
1594 /* Start YYX at -YYN if negative to avoid negative indexes in
1595 YYCHECK. */
6e649e65 1596 yysize = sizeof ("syntax error, unexpected ")
01241d47
PH
1597 + strlen (yytokenName (*yytokenp));
1598 yyprefix = ", expecting ";
fb8135fa 1599 for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size && yycount <= 5;
01241d47 1600 yyx += 1)
217598da 1601 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01241d47
PH
1602 yysize += strlen (yytokenName (yyx)) + strlen (yyprefix),
1603 yycount += 1, yyprefix = " or ";
1604 yymsg = yyp = (char*) malloc (yysize);
6e649e65
PE
1605 sprintf (yyp, "syntax error, unexpected %s",
1606 yytokenName (*yytokenp));
3eb49163 1607 yyp += strlen (yyp);
01241d47
PH
1608 if (yycount < 5)
1609 {
1610 yyprefix = ", expecting ";
1611 for (yyx = yyn < 0 ? -yyn : 0; yyx < yytname_size; yyx += 1)
f50adbbd 1612 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01241d47 1613 {
3eb49163
PE
1614 sprintf (yyp, "%s%s", yyprefix, yytokenName (yyx));
1615 yyp += strlen (yyp);
01241d47
PH
1616 yyprefix = " or ";
1617 }
1618 }
93724f13 1619 yyerror (]b4_lyyerror_args[yymsg);
01241d47
PH
1620 free (yymsg);
1621 }
1622 else
1623#endif
6e649e65 1624 yyerror (]b4_lyyerror_args["syntax error");
01241d47
PH
1625 yynerrs += 1;
1626 }
1627}
1628
f50adbbd 1629/* Recover from a syntax error on YYSTACK, assuming that YYTOKENP,
01241d47 1630 YYLVALP, and YYLLOCP point to the syntactic category, semantic
f50adbbd 1631 value, and location of the lookahead. */
fb8135fa 1632static void
2a8d363a
AD
1633yyrecoverParseError (yyGLRStack* yystack,
1634 YYSTYPE* yylvalp, YYLTYPE* yyllocp]b4_user_formals[)
01241d47
PH
1635{
1636 yySymbol* const yytokenp = yystack->yytokenp;
1154cced
AD
1637 size_t yyk;
1638 int yyj;
01241d47 1639
fb8135fa 1640 if (yystack->yyerrState == 0)
01241d47 1641 yystack->yyerrState = 3;
fb8135fa 1642 else if (yystack->yyerrState == 3)
2a1fe6ed
AD
1643 /* We just shifted the error token and (perhaps) took some
1644 reductions. Skip tokens until we can proceed. */
1645 while (yytrue)
1646 {
01241d47 1647 if (*yytokenp == YYEOF)
7bd6c77e
AD
1648 {
1649 /* Now pop stack until we find a state that shifts the
1650 error token. */
1651 while (yystack->yytops.yystates[0] != NULL)
1652 {
1653 yyGLRState *yys = yystack->yytops.yystates[0];
9c1e26bd 1654 YYDSYMPRINTF ("Error: popping",
7bd6c77e 1655 yystos[yys->yylrState],
9c1e26bd 1656 &yys->yysemantics.yysval, &yys->yyloc);
7bd6c77e
AD
1657 yydestruct (yystos[yys->yylrState],
1658 &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
1659 yystack->yytops.yystates[0] = yys->yypred;
1660 yystack->yynextFree -= 1;
1661 yystack->yyspaceLeft += 1;
1662 }
1663 yyFail (yystack][]b4_lpure_args[, NULL);
1664 }
01241d47 1665 if (*yytokenp != YYEMPTY)
7bd6c77e 1666 {
9c1e26bd 1667 YYDSYMPRINTF ("Error: discarding", *yytokenp, yylvalp, yyllocp);
7bd6c77e
AD
1668 yydestruct (*yytokenp, yylvalp]b4_location_if([, yyllocp])[);
1669 }
2a1fe6ed 1670 YYDPRINTF ((stderr, "Reading a token: "));
01241d47
PH
1671 yychar = YYLEX;
1672 *yytokenp = YYTRANSLATE (yychar);
9c1e26bd 1673 YYDSYMPRINTF ("Next token is", *yytokenp, yylvalp, yyllocp);
01241d47 1674 yyj = yypact[yystack->yytops.yystates[0]->yylrState];
944ed9f4 1675 if (yyis_pact_ninf (yyj))
2a1fe6ed 1676 /* Something's not right; we shouldn't be here. */
2a8d363a 1677 yyFail (yystack][]b4_lpure_args[, NULL);
01241d47 1678 yyj += *yytokenp;
ea99527d 1679 if (yyj < 0 || YYLAST < yyj || yycheck[yyj] != *yytokenp)
01241d47
PH
1680 {
1681 if (yydefact[yystack->yytops.yystates[0]->yylrState] != 0)
1682 return;
1683 }
944ed9f4 1684 else if (yytable[yyj] != 0 && ! yyis_table_ninf (yytable[yyj]))
01241d47 1685 return;
2a1fe6ed 1686 }
fb8135fa 1687
2a1fe6ed 1688 /* Reduce to one stack. */
01241d47
PH
1689 for (yyk = 0; yyk < yystack->yytops.yysize; yyk += 1)
1690 if (yystack->yytops.yystates[yyk] != NULL)
1691 break;
1692 if (yyk >= yystack->yytops.yysize)
2a8d363a 1693 yyFail (yystack][]b4_lpure_args[, NULL);
01241d47
PH
1694 for (yyk += 1; yyk < yystack->yytops.yysize; yyk += 1)
1695 yymarkStackDeleted (yystack, yyk);
1696 yyremoveDeletes (yystack);
1697 yycompressStack (yystack);
1698
1699 /* Now pop stack until we find a state that shifts the error token. */
fb8135fa 1700 while (yystack->yytops.yystates[0] != NULL)
01241d47 1701 {
7bd6c77e
AD
1702 yyGLRState *yys = yystack->yytops.yystates[0];
1703 yyj = yypact[yys->yylrState];
944ed9f4 1704 if (! yyis_pact_ninf (yyj))
01241d47 1705 {
944ed9f4
PE
1706 yyj += YYTERROR;
1707 if (0 <= yyj && yyj <= YYLAST && yycheck[yyj] == YYTERROR
1708 && yyisShiftAction (yytable[yyj]))
1709 {
7bd6c77e 1710 YYDPRINTF ((stderr, "Shifting error token, "));
944ed9f4 1711 yyglrShift (yystack, 0, yytable[yyj],
7bd6c77e 1712 yys->yyposn, *yylvalp, yyllocp]b4_user_args[);
944ed9f4
PE
1713 break;
1714 }
01241d47 1715 }
9c1e26bd 1716 YYDSYMPRINTF ("Error: popping",
7bd6c77e 1717 yystos[yys->yylrState],
9c1e26bd 1718 &yys->yysemantics.yysval, &yys->yyloc);
7bd6c77e
AD
1719 yydestruct (yystos[yys->yylrState],
1720 &yys->yysemantics.yysval]b4_location_if([, &yys->yyloc])[);
1721 yystack->yytops.yystates[0] = yys->yypred;
01241d47
PH
1722 yystack->yynextFree -= 1;
1723 yystack->yyspaceLeft += 1;
1724 }
1725 if (yystack->yytops.yystates[0] == NULL)
2a8d363a 1726 yyFail (yystack][]b4_lpure_args[, NULL);
fb8135fa
AD
1727}
1728
01241d47
PH
1729#define YYCHK1(YYE) \
1730 do { \
1731 switch (YYE) { \
1732 default: \
1733 break; \
1734 case yyabort: \
1735 yystack.yyerrflag = 1; \
1736 goto yyDone; \
1737 case yyaccept: \
1738 yystack.yyerrflag = 0; \
1739 goto yyDone; \
1740 case yyerr: \
1741 goto yyuser_error; \
1742 } \
fb8135fa 1743 } while (0)
01241d47 1744
0245f82d
AD
1745
1746/*----------.
1747| yyparse. |
1748`----------*/
1749
1750]b4_c_ansi_function_def([yyparse], [int], b4_parse_param)[
01241d47
PH
1751{
1752 yySymbol yytoken;
1753 yyGLRStack yystack;
1754 size_t yyposn;
1755]b4_pure_if(
1756[
1757 YYSTYPE yylval;
1758 YYLTYPE yylloc;
1759 #undef yychar
1760 #define yychar (yystack.yyrawchar)
1761])[
1762
1763 YYSTYPE* const yylvalp = &yylval;
1764 YYLTYPE* const yyllocp = &yylloc;
fb8135fa 1765
01241d47
PH
1766 yyinitGLRStack (&yystack, YYINITDEPTH);
1767 yystack.yytokenp = &yytoken;
1768
2a1fe6ed
AD
1769 YYDPRINTF ((stderr, "Starting parse\n"));
1770
01241d47
PH
1771 if (setjmp (yystack.yyexception_buffer) != 0)
1772 goto yyDone;
1773
2a8d363a 1774 yyglrShift (&yystack, 0, 0, 0, yyval_default, &yyloc_default]b4_user_args[);
01241d47
PH
1775 yytoken = YYEMPTY;
1776 yyposn = 0;
1777
fb8135fa 1778 while (yytrue)
01241d47 1779 {
21964f43
AD
1780 /* For efficiency, we have two loops, the first of which is
1781 specialized to deterministic operation (single stack, no
1782 potential ambiguity). */
01241d47 1783 /* Standard mode */
fb8135fa 1784 while (yytrue)
01241d47
PH
1785 {
1786 yyRuleNum yyrule;
1787 int yyaction;
1788 const short* yyconflicts;
1789
1790 yyStateNum yystate = yystack.yytops.yystates[0]->yylrState;
b0937b22 1791 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01241d47
PH
1792 if (yystate == YYFINAL)
1793 goto yyDone;
fb8135fa 1794 if (yyisDefaultedState (yystate))
01241d47
PH
1795 {
1796 yyrule = yydefaultAction (yystate);
fb8135fa 1797 if (yyrule == 0)
01241d47 1798 {
2a8d363a 1799 yyreportParseError (&yystack, yylvalp, yyllocp]b4_user_args[);
01241d47
PH
1800 goto yyuser_error;
1801 }
2a8d363a 1802 YYCHK1 (yyglrReduce (&yystack, 0, yyrule, yytrue]b4_lpure_args[));
01241d47 1803 }
fb8135fa 1804 else
01241d47 1805 {
fb8135fa 1806 if (yytoken == YYEMPTY)
01241d47 1807 {
2a1fe6ed 1808 YYDPRINTF ((stderr, "Reading a token: "));
01241d47
PH
1809 yychar = YYLEX;
1810 yytoken = YYTRANSLATE (yychar);
9c1e26bd 1811 YYDSYMPRINTF ("Next token is", yytoken, yylvalp, yyllocp);
01241d47
PH
1812 }
1813 yygetLRActions (yystate, yytoken, &yyaction, &yyconflicts);
1814 if (*yyconflicts != 0)
1815 break;
fb8135fa 1816 if (yyisShiftAction (yyaction))
01241d47 1817 {
2a1fe6ed 1818 YYDPRINTF ((stderr, "Shifting token %s, ",
01241d47
PH
1819 yytokenName (yytoken)));
1820 if (yytoken != YYEOF)
1821 yytoken = YYEMPTY;
1822 yyposn += 1;
2a8d363a
AD
1823 yyglrShift (&yystack, 0, yyaction, yyposn,
1824 yylval, yyllocp]b4_user_args[);
39912f52 1825 if (0 < yystack.yyerrState)
01241d47 1826 yystack.yyerrState -= 1;
01241d47
PH
1827 }
1828 else if (yyisErrorAction (yyaction))
1829 {
2a8d363a 1830 yyreportParseError (&yystack, yylvalp, yyllocp]b4_user_args[);
01241d47
PH
1831 goto yyuser_error;
1832 }
1833 else
2a8d363a 1834 YYCHK1 (yyglrReduce (&yystack, 0, -yyaction, yytrue]b4_lpure_args[));
01241d47
PH
1835 }
1836 }
1837
fb8135fa 1838 while (yytrue)
01241d47
PH
1839 {
1840 int yys;
1841 int yyn = yystack.yytops.yysize;
1842 for (yys = 0; yys < yyn; yys += 1)
1843 YYCHK1 (yyprocessOneStack (&yystack, yys, yyposn,
2a8d363a 1844 yylvalp, yyllocp]b4_user_args[));
01241d47
PH
1845 yytoken = YYEMPTY;
1846 yyposn += 1;
1847 yyremoveDeletes (&yystack);
1848 if (yystack.yytops.yysize == 0)
1849 {
1850 yyundeleteLastStack (&yystack);
1851 if (yystack.yytops.yysize == 0)
6e649e65 1852 yyFail (&yystack][]b4_lpure_args[, "syntax error");
2a8d363a 1853 YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
01241d47 1854 YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
2a8d363a 1855 yyreportParseError (&yystack, yylvalp, yyllocp]b4_user_args[);
01241d47
PH
1856 goto yyuser_error;
1857 }
fb8135fa 1858 else if (yystack.yytops.yysize == 1)
01241d47 1859 {
2a8d363a 1860 YYCHK1 (yyresolveStack (&yystack]b4_user_args[));
01241d47
PH
1861 YYDPRINTF ((stderr, "Returning to deterministic operation.\n"));
1862 yycompressStack (&yystack);
1863 break;
1864 }
1865 }
1866 continue;
1867 yyuser_error:
2a8d363a 1868 yyrecoverParseError (&yystack, yylvalp, yyllocp]b4_user_args[);
01241d47
PH
1869 yyposn = yystack.yytops.yystates[0]->yyposn;
1870 }
1871 yyDone:
1872 ;
1873
1874 yyfreeGLRStack (&yystack);
1875 return yystack.yyerrflag;
1876}
1877
1878/* DEBUGGING ONLY */
1154cced
AD
1879static void yypstack (yyGLRStack* yystack, int yyk) ATTRIBUTE_UNUSED;
1880static void yypdumpstack (yyGLRStack* yystack) ATTRIBUTE_UNUSED;
01241d47 1881
1154cced 1882static void
cf126971 1883yy_yypstack (yyGLRState* yys)
01241d47 1884{
cf126971 1885 if (yys->yypred)
01241d47 1886 {
cf126971
PE
1887 yy_yypstack (yys->yypred);
1888 fprintf (stderr, " -> ");
01241d47 1889 }
947427ae 1890 fprintf (stderr, "%d@@%lu", yys->yylrState, (unsigned long) yys->yyposn);
cf126971 1891}
01241d47 1892
cf126971
PE
1893static void
1894yypstates (yyGLRState* yyst)
1895{
fb8135fa 1896 if (yyst == NULL)
01241d47 1897 fprintf (stderr, "<null>");
fb8135fa 1898 else
01241d47
PH
1899 yy_yypstack (yyst);
1900 fprintf (stderr, "\n");
1901}
1902
1154cced 1903static void
fb8135fa 1904yypstack (yyGLRStack* yystack, int yyk)
01241d47
PH
1905{
1906 yypstates (yystack->yytops.yystates[yyk]);
1907}
1908
1909#define YYINDEX(YYX) \
1910 ((YYX) == NULL ? -1 : (yyGLRStackItem*) (YYX) - yystack->yyitems)
1911
1912
1154cced 1913static void
fb8135fa 1914yypdumpstack (yyGLRStack* yystack)
01241d47
PH
1915{
1916 yyGLRStackItem* yyp;
1154cced 1917 size_t yyi;
fb8135fa 1918 for (yyp = yystack->yyitems; yyp < yystack->yynextFree; yyp += 1)
01241d47 1919 {
cf126971 1920 fprintf (stderr, "%3lu. ", (unsigned long) (yyp - yystack->yyitems));
fb8135fa 1921 if (*(bool*) yyp)
01241d47 1922 {
cf126971 1923 fprintf (stderr, "Res: %d, LR State: %d, posn: %lu, pred: %ld",
fb8135fa 1924 yyp->yystate.yyresolved, yyp->yystate.yylrState,
cf126971
PE
1925 (unsigned long) yyp->yystate.yyposn,
1926 (long) YYINDEX (yyp->yystate.yypred));
fb8135fa 1927 if (! yyp->yystate.yyresolved)
cf126971
PE
1928 fprintf (stderr, ", firstVal: %ld",
1929 (long) YYINDEX (yyp->yystate.yysemantics.yyfirstVal));
01241d47 1930 }
fb8135fa 1931 else
01241d47 1932 {
cf126971
PE
1933 fprintf (stderr, "Option. rule: %d, state: %ld, next: %ld",
1934 yyp->yyoption.yyrule,
1935 (long) YYINDEX (yyp->yyoption.yystate),
1936 (long) YYINDEX (yyp->yyoption.yynext));
01241d47
PH
1937 }
1938 fprintf (stderr, "\n");
1939 }
1940 fprintf (stderr, "Tops:");
1941 for (yyi = 0; yyi < yystack->yytops.yysize; yyi += 1)
cf126971
PE
1942 fprintf (stderr, "%lu: %ld; ", (unsigned long) yyi,
1943 (long) YYINDEX (yystack->yytops.yystates[yyi]));
01241d47
PH
1944 fprintf (stderr, "\n");
1945}
01241d47
PH
1946]
1947
1948b4_epilogue
1949m4_if(b4_defines_flag, 0, [],
947427ae 1950[@output @output_header_name@
fb8135fa 1951b4_copyright([Skeleton parser for GLR parsing with Bison], [2002])
01241d47
PH
1952
1953b4_token_defines(b4_tokens)
1954
1955#ifndef YYSTYPE
1956m4_ifdef([b4_stype],
437c2d80 1957[b4_syncline([b4_stype_line], [b4_filename])
01241d47
PH
1958typedef union b4_stype yystype;
1959/* Line __line__ of __file__. */
947427ae 1960b4_syncline([@oline@], [@ofile@])],
01241d47
PH
1961[typedef int yystype;])
1962# define YYSTYPE yystype
947427ae 1963# define YYSTYPE_IS_TRIVIAL 1
01241d47
PH
1964#endif
1965
1966b4_pure_if([],
1967[extern YYSTYPE b4_prefix[]lval;])
1968
1969b4_location_if(
1970[#ifndef YYLTYPE
1971typedef struct yyltype
1972{
f50adbbd
AD
1973 int first_line;
1974 int first_column;
1975 int last_line;
1976 int last_column;
01241d47
PH
1977} yyltype;
1978# define YYLTYPE yyltype
1979#endif
1980
1981m4_if(b4_pure, [0],
1982[extern YYLTYPE b4_prefix[]lloc;])
1983])
01241d47 1984])