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