source: trunk/contrib/bison-2.4.2/share/bison/glr.c @ 1935

Last change on this file since 1935 was 1933, checked in by sam, 10 years ago

contrib: add Bison and Flex executables for Windows.

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