]> git.saurik.com Git - bison.git/blame - data/yacc.c
tests: strengthen the test on generated headers inclusion
[bison.git] / data / yacc.c
CommitLineData
08af01c2 1 -*- C -*-
a8289c62 2
60491a94 3# Yacc compatible skeleton for Bison
c7a65b99 4
c932d613 5# Copyright (C) 1984, 1989-1990, 2000-2012 Free Software Foundation,
ea0a7676 6# Inc.
60491a94 7
f16b0819 8# This program is free software: you can redistribute it and/or modify
60491a94 9# it under the terms of the GNU General Public License as published by
f16b0819 10# the Free Software Foundation, either version 3 of the License, or
60491a94 11# (at your option) any later version.
f16b0819 12#
60491a94
AD
13# This program is distributed in the hope that it will be useful,
14# but WITHOUT ANY WARRANTY; without even the implied warranty of
15# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16# GNU General Public License for more details.
f16b0819 17#
60491a94 18# You should have received a copy of the GNU General Public License
f16b0819 19# along with this program. If not, see <http://www.gnu.org/licenses/>.
60491a94 20
812775a0
JD
21# Check the value of %define api.push-pull.
22b4_percent_define_default([[api.push-pull]], [[pull]])
23b4_percent_define_check_values([[[[api.push-pull]],
93d0103d 24 [[pull]], [[push]], [[both]]]])
9ca7f077
JD
25b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]])
26b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]])
812775a0 27m4_case(b4_percent_define_get([[api.push-pull]]),
9ca7f077
JD
28 [pull], [m4_define([b4_push_flag], [[0]])],
29 [push], [m4_define([b4_pull_flag], [[0]])])
30
31# Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing
7e5ef706
PE
32# tests function as written, do not let BISON_USE_PUSH_FOR_PULL modify the
33# behavior of Bison at all when push parsing is already requested.
9ca7f077
JD
34b4_define_flag_if([use_push_for_pull])
35b4_use_push_for_pull_if([
36 b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])],
37 [m4_define([b4_push_flag], [[1]])])])
945e396c 38
723fe7d1
JD
39# Check the value of %define parse.lac and friends, where LAC stands for
40# lookahead correction.
ea13bea8 41b4_percent_define_default([[parse.lac]], [[none]])
723fe7d1
JD
42b4_percent_define_default([[parse.lac.es-capacity-initial]], [[20]])
43b4_percent_define_default([[parse.lac.memory-trace]], [[failures]])
44b4_percent_define_check_values([[[[parse.lac]], [[full]], [[none]]]],
45 [[[[parse.lac.memory-trace]],
46 [[failures]], [[full]]]])
ea13bea8
JD
47b4_define_flag_if([lac])
48m4_define([b4_lac_flag],
49 [m4_if(b4_percent_define_get([[parse.lac]]),
50 [none], [[0]], [[1]])])
51
0a96ba81 52m4_include(b4_pkgdatadir/[c.m4])
7eb8a0bc 53
66d30cd4
AD
54## ---------------- ##
55## Default values. ##
56## ---------------- ##
57
58# Stack parameters.
59m4_define_default([b4_stack_depth_max], [10000])
60m4_define_default([b4_stack_depth_init], [200])
61
2a8d363a
AD
62
63## ------------------------ ##
64## Pure/impure interfaces. ##
65## ------------------------ ##
66
d9df47b6
JD
67b4_percent_define_default([[api.pure]], [[false]])
68b4_define_flag_if([pure])
69m4_define([b4_pure_flag],
70 [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])
2a8d363a 71
4b367315
AD
72# b4_yacc_pure_if(IF-TRUE, IF-FALSE)
73# ----------------------------------
2a8d363a 74# Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
4b367315 75m4_define([b4_yacc_pure_if],
2a8d363a 76[b4_pure_if([m4_ifset([b4_parse_param],
02650b7f
PE
77 [$1], [$2])],
78 [$2])])
2a8d363a
AD
79
80
93724f13
AD
81# b4_yyerror_args
82# ---------------
2a8d363a 83# Arguments passed to yyerror: user args plus yylloc.
93724f13 84m4_define([b4_yyerror_args],
327afc7c 85[b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl
93724f13 86m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
2a8d363a
AD
87
88
89# b4_lex_param
90# ------------
d42f69cd 91# Accumulate in b4_lex_param all the yylex arguments.
2a8d363a 92# b4_lex_param arrives quoted twice, but we want to keep only one level.
21964f43
AD
93m4_define([b4_lex_param],
94m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
327afc7c 95b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
68cdf747 96m4_ifdef([b4_lex_param], b4_lex_param)))
66d30cd4
AD
97
98
f1886bb2
AD
99## ------------ ##
100## Data Types. ##
101## ------------ ##
102
103# b4_int_type(MIN, MAX)
104# ---------------------
105# Return the smallest int type able to handle numbers ranging from
d42cf844
PE
106# MIN to MAX (included). Overwrite the version from c.m4, which
107# uses only C89 types, so that the user can override the shorter
108# types, and so that pre-C89 compilers are handled correctly.
f1886bb2 109m4_define([b4_int_type],
d42cf844
PE
110[m4_if(b4_ints_in($@, [0], [255]), [1], [yytype_uint8],
111 b4_ints_in($@, [-128], [127]), [1], [yytype_int8],
f1886bb2 112
d42cf844
PE
113 b4_ints_in($@, [0], [65535]), [1], [yytype_uint16],
114 b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16],
f1886bb2
AD
115
116 m4_eval([0 <= $1]), [1], [unsigned int],
117
02650b7f 118 [int])])
f1886bb2
AD
119
120
66d30cd4
AD
121## ----------------- ##
122## Semantic Values. ##
123## ----------------- ##
124
125
82b6cb3f
AD
126# b4_lhs_value([TYPE])
127# --------------------
128# Expansion of $<TYPE>$.
129m4_define([b4_lhs_value],
bc82c5a5 130[(yyval[]m4_ifval([$1], [.$1]))])
82b6cb3f
AD
131
132
133# b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
134# --------------------------------------
135# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
136# symbols on RHS.
137m4_define([b4_rhs_value],
d1ff7a7c 138[(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$3]))])
82b6cb3f
AD
139
140
58612f1d
AD
141
142## ----------- ##
143## Locations. ##
144## ----------- ##
145
82b6cb3f
AD
146# b4_lhs_location()
147# -----------------
148# Expansion of @$.
149m4_define([b4_lhs_location],
bc82c5a5 150[(yyloc)])
82b6cb3f
AD
151
152
153# b4_rhs_location(RULE-LENGTH, NUM)
154# ---------------------------------
155# Expansion of @NUM, where the current rule has RULE-LENGTH symbols
156# on RHS.
157m4_define([b4_rhs_location],
d1ff7a7c 158[(yylsp@{($2) - ($1)@})])
be2a1a68 159
0d8bed56 160
c0828abf
AD
161## -------------- ##
162## Declarations. ##
163## -------------- ##
93d0103d
JD
164
165# b4_declare_scanner_communication_variables
166# ------------------------------------------
167# Declare the variables that are global, or local to YYPARSE if
168# pure-parser.
169m4_define([b4_declare_scanner_communication_variables], [[
170/* The lookahead symbol. */
171int yychar;
172
173/* The semantic value of the lookahead symbol. */
174YYSTYPE yylval;]b4_locations_if([[
175
176/* Location data for the lookahead symbol. */
177YYLTYPE yylloc;]])b4_pure_if([], [[
178
179/* Number of syntax errors so far. */
180int yynerrs;]])])
181
182
183# b4_declare_parser_state_variables
184# ---------------------------------
185# Declare all the variables that are needed to maintain the parser state
186# between calls to yypush_parse.
187m4_define([b4_declare_parser_state_variables], [b4_pure_if([[
188 /* Number of syntax errors so far. */
189 int yynerrs;
190]])[
191 int yystate;
192 /* Number of tokens to shift before error messages enabled. */
193 int yyerrstatus;
194
195 /* The stacks and their tools:
196 `yyss': related to states.
197 `yyvs': related to semantic values.]b4_locations_if([[
198 `yyls': related to locations.]])[
199
cbdb6d91 200 Refer to the stacks through separate pointers, to allow yyoverflow
93d0103d
JD
201 to reallocate them elsewhere. */
202
203 /* The state stack. */
204 yytype_int16 yyssa[YYINITDEPTH];
205 yytype_int16 *yyss;
206 yytype_int16 *yyssp;
207
208 /* The semantic value stack. */
209 YYSTYPE yyvsa[YYINITDEPTH];
210 YYSTYPE *yyvs;
211 YYSTYPE *yyvsp;]b4_locations_if([[
212
213 /* The location stack. */
214 YYLTYPE yylsa[YYINITDEPTH];
215 YYLTYPE *yyls;
216 YYLTYPE *yylsp;
217
218 /* The locations where the error started and ended. */
a005dbcb 219 YYLTYPE yyerror_range[3];]])[
93d0103d 220
723fe7d1
JD
221 YYSIZE_T yystacksize;]b4_lac_if([[
222
223 yytype_int16 yyesa@{]b4_percent_define_get([[parse.lac.es-capacity-initial]])[@};
224 yytype_int16 *yyes;
225 YYSIZE_T yyes_capacity;]])])
93d0103d 226
ae6bdabb
AD
227
228# b4_shared_declarations
229# ----------------------
230# Declaration that might either go into the header (if --defines)
231# or open coded in the parser body.
232m4_define([b4_shared_declarations],
233[b4_percent_code_get([[requires]])[
234]b4_token_enums_defines(b4_tokens)[
235]b4_declare_yylstype[
236]b4_push_if([[
237#ifndef YYPUSH_DECLS
238# define YYPUSH_DECLS
239typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
240enum { YYPUSH_MORE = 4 };
241]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
242])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
243 [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([,
244 [[[int yypushed_char]], [[yypushed_char]]],
245 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
246 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
247 b4_parse_param]))
248b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
249 [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
250 b4_parse_param]))])
251b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
252 [[[void]], []])
253b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
254 [[b4_prefix[pstate *yyps]], [[yyps]]])[
255#endif
256]])
257b4_percent_code_get([[provides]])[]dnl
258])
259
c0828abf
AD
260## -------------- ##
261## Output files. ##
262## -------------- ##
1ae72863 263
b526ee61
AD
264# We do want M4 expansion after # for CPP macros.
265m4_changecom()
08af01c2 266m4_divert_push(0)dnl
0d2b2ab0 267@output(b4_parser_file_name@)@
448dc38b 268b4_copyright([Bison implementation for Yacc-like parsers in C],
681dda24 269 [1984, 1989-1990, 2000-2012])[
af3412cd
PE
270
271/* C LALR(1) parser skeleton written by Richard Stallman, by
272 simplifying the original so-called "semantic" parser. */
444fbf65 273
cf44a9ae
PE
274/* All symbols defined below should begin with yy or YY, to avoid
275 infringing on user name space. This should be done even for local
276 variables, as they might otherwise be expanded by user macros.
277 There are some unavoidable exceptions within include files to
278 define necessary library symbols; they are noted "INFRINGES ON
279 USER NAME SPACE" below. */
280
9c1e26bd 281]b4_identification
a4e25e1d 282b4_percent_code_get([[top]])[]dnl
aa08666d 283m4_if(b4_prefix, [yy], [],
93d0103d
JD
284[[/* Substitute the variable and function names. */]b4_pull_if([[
285#define yyparse ]b4_prefix[parse]])b4_push_if([[
286#define yypush_parse ]b4_prefix[push_parse]b4_pull_if([[
287#define yypull_parse ]b4_prefix[pull_parse]])[
288#define yypstate_new ]b4_prefix[pstate_new
9ca7f077 289#define yypstate_delete ]b4_prefix[pstate_delete
93d0103d
JD
290#define yypstate ]b4_prefix[pstate]])[
291#define yylex ]b4_prefix[lex
9ca7f077
JD
292#define yyerror ]b4_prefix[error
293#define yylval ]b4_prefix[lval
294#define yychar ]b4_prefix[char
295#define yydebug ]b4_prefix[debug
296#define yynerrs ]b4_prefix[nerrs
297]b4_locations_if([[#define yylloc ]b4_prefix[lloc]])])[
17da6427 298
0dd1580a 299/* Copy the first part of user declarations. */
136a0f76 300]b4_user_pre_prologue[
cce71710 301
ef51bfa7
AD
302]b4_null_define[
303
d99361e6
AD
304/* Enabling traces. */
305#ifndef YYDEBUG
327afc7c 306# define YYDEBUG ]b4_debug_flag[
d99361e6
AD
307#endif
308
309/* Enabling verbose error messages. */
310#ifdef YYERROR_VERBOSE
311# undef YYERROR_VERBOSE
312# define YYERROR_VERBOSE 1
313#else
327afc7c 314# define YYERROR_VERBOSE ]b4_error_verbose_flag[
d99361e6
AD
315#endif
316
141f5793
PE
317/* Enabling the token table. */
318#ifndef YYTOKEN_TABLE
319# define YYTOKEN_TABLE ]b4_token_table[
320#endif
321
0f11eec2
AD
322]b4_defines_if([[#include "@basename(]b4_spec_defines_file[@)"]],
323 [b4_shared_declarations])[
9bc0dd67 324
ae6bdabb 325/* Copy the second part of user declarations. */
8e0a5e9e 326]b4_user_post_prologue
a4e25e1d 327b4_percent_code_get[]dnl
7093d0f5 328
8e0a5e9e 329[#ifdef short
d42cf844
PE
330# undef short
331#endif
332
333#ifdef YYTYPE_UINT8
334typedef YYTYPE_UINT8 yytype_uint8;
335#else
336typedef unsigned char yytype_uint8;
337#endif
338
339#ifdef YYTYPE_INT8
340typedef YYTYPE_INT8 yytype_int8;
341#elif ]b4_c_modern[
342typedef signed char yytype_int8;
343#else
344typedef short int yytype_int8;
345#endif
346
347#ifdef YYTYPE_UINT16
348typedef YYTYPE_UINT16 yytype_uint16;
349#else
350typedef unsigned short int yytype_uint16;
351#endif
352
353#ifdef YYTYPE_INT16
354typedef YYTYPE_INT16 yytype_int16;
355#else
356typedef short int yytype_int16;
357#endif
358
55289366 359#ifndef YYSIZE_T
02650b7f 360# ifdef __SIZE_TYPE__
55289366 361# define YYSIZE_T __SIZE_TYPE__
02650b7f 362# elif defined size_t
55289366 363# define YYSIZE_T size_t
02650b7f 364# elif ! defined YYSIZE_T && ]b4_c_modern[
55289366
PE
365# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
366# define YYSIZE_T size_t
367# else
368# define YYSIZE_T unsigned int
369# endif
bedf57f5 370#endif
7093d0f5 371
b4c1f9d2
PE
372#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
373
30757c8c 374#ifndef YY_
06caf0e1 375# if defined YYENABLE_NLS && YYENABLE_NLS
30757c8c
PE
376# if ENABLE_NLS
377# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
378# define YY_(msgid) dgettext ("bison-runtime", msgid)
379# endif
380# endif
381# ifndef YY_
382# define YY_(msgid) msgid
383# endif
384#endif
385
2a4647a3 386/* Suppress unused-variable warnings by "using" E. */
02650b7f 387#if ! defined lint || defined __GNUC__
12ce2df6
PE
388# define YYUSE(e) ((void) (e))
389#else
390# define YYUSE(e) /* empty */
391#endif
392
393/* Identity function, used to suppress warnings about constant conditions. */
394#ifndef lint
395# define YYID(n) (n)
396#else
cd9e1ba2 397]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[
12ce2df6 398{
cd9e1ba2 399 return yyi;
12ce2df6
PE
400}
401#endif
2a4647a3 402
723fe7d1 403#if ]b4_lac_if([[1]], [[! defined yyoverflow || YYERROR_VERBOSE]])[
2779e383 404
723fe7d1
JD
405/* The parser invokes alloca or malloc; define the necessary symbols. */]dnl
406b4_push_if([], [b4_lac_if([], [[
7093d0f5 407
b929851a
PE
408# ifdef YYSTACK_USE_ALLOCA
409# if YYSTACK_USE_ALLOCA
b929851a
PE
410# ifdef __GNUC__
411# define YYSTACK_ALLOC __builtin_alloca
02650b7f 412# elif defined __BUILTIN_VA_ARG_INCR
55289366 413# include <alloca.h> /* INFRINGES ON USER NAME SPACE */
02650b7f 414# elif defined _AIX
55289366 415# define YYSTACK_ALLOC __alloca
02650b7f 416# elif defined _MSC_VER
55289366
PE
417# include <malloc.h> /* INFRINGES ON USER NAME SPACE */
418# define alloca _alloca
d7e14fc0
PE
419# else
420# define YYSTACK_ALLOC alloca
ea6046b9 421# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && ]b4_c_modern[
bedf57f5 422# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
43e9e2a1 423 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
ea6046b9
PE
424# ifndef EXIT_SUCCESS
425# define EXIT_SUCCESS 0
55289366 426# endif
bedf57f5 427# endif
7093d0f5
AD
428# endif
429# endif
723fe7d1 430# endif]])])[
7093d0f5 431
723fe7d1 432# ifdef YYSTACK_ALLOC
9d9b8b70 433 /* Pacify GCC's `empty if-body' warning. */
12ce2df6 434# define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
506ffb1f 435# ifndef YYSTACK_ALLOC_MAXIMUM
b9c9f761
PE
436 /* The OS might guarantee only one guard page at the bottom of the stack,
437 and a page size can be as small as 4096 bytes. So we cannot safely
438 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
439 to allow for a few compiler-allocated temporary stack slots. */
e2a21b6f 440# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
506ffb1f 441# endif
7093d0f5 442# else
2779e383
PE
443# define YYSTACK_ALLOC YYMALLOC
444# define YYSTACK_FREE YYFREE
506ffb1f 445# ifndef YYSTACK_ALLOC_MAXIMUM
b4c1f9d2 446# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
506ffb1f 447# endif
ea6046b9 448# if (defined __cplusplus && ! defined EXIT_SUCCESS \
fc3f467f
PE
449 && ! ((defined YYMALLOC || defined malloc) \
450 && (defined YYFREE || defined free)))
451# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
ea6046b9
PE
452# ifndef EXIT_SUCCESS
453# define EXIT_SUCCESS 0
fc3f467f 454# endif
0925ebb4 455# endif
bedf57f5
PE
456# ifndef YYMALLOC
457# define YYMALLOC malloc
ea6046b9 458# if ! defined malloc && ! defined EXIT_SUCCESS && ]b4_c_modern[
bedf57f5
PE
459void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
460# endif
461# endif
462# ifndef YYFREE
463# define YYFREE free
ea6046b9 464# if ! defined free && ! defined EXIT_SUCCESS && ]b4_c_modern[
bedf57f5
PE
465void free (void *); /* INFRINGES ON USER NAME SPACE */
466# endif
467# endif
723fe7d1
JD
468# endif]b4_lac_if([[
469# define YYCOPY_NEEDED 1]])[
470#endif]b4_lac_if([], [[ /* ! defined yyoverflow || YYERROR_VERBOSE */]])[
cf44a9ae
PE
471
472
02650b7f
PE
473#if (! defined yyoverflow \
474 && (! defined __cplusplus \
327afc7c 475 || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
02650b7f 476 && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
7093d0f5 477
600f9b0c
PE
478/* A type that is properly aligned for any stack member. */
479union yyalloc
480{
9ca7f077
JD
481 yytype_int16 yyss_alloc;
482 YYSTYPE yyvs_alloc;]b4_locations_if([
483 YYLTYPE yyls_alloc;])[
484};
600f9b0c
PE
485
486/* The size of the maximum gap between one aligned stack and the next. */
17836590 487# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
600f9b0c
PE
488
489/* The size of an array large to enough to hold all stacks, each with
490 N elements. */
327afc7c 491]b4_locations_if(
58612f1d 492[# define YYSTACK_BYTES(N) \
d42cf844 493 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
17836590 494 + 2 * YYSTACK_GAP_MAXIMUM)],
58612f1d 495[# define YYSTACK_BYTES(N) \
d42cf844 496 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
17836590 497 + YYSTACK_GAP_MAXIMUM)])[
600f9b0c 498
723fe7d1 499# define YYCOPY_NEEDED 1
5b041382
PE
500
501/* Relocate STACK from its old location to the new one. The
7093d0f5 502 local variables YYSIZE and YYSTACKSIZE give the old and new number of
600f9b0c
PE
503 elements in the stack, and YYPTR gives the new location of the
504 stack. Advance YYPTR to a properly aligned location for the next
505 stack. */
9ca7f077 506# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
7093d0f5
AD
507 do \
508 { \
509 YYSIZE_T yynewbytes; \
9ca7f077
JD
510 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
511 Stack = &yyptr->Stack_alloc; \
17836590 512 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
2729e106 513 yyptr += yynewbytes / sizeof (*yyptr); \
7093d0f5 514 } \
12ce2df6 515 while (YYID (0))
7093d0f5 516
cf44a9ae 517#endif
8850be4b 518
723fe7d1 519#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
14f4455e 520/* Copy COUNT objects from SRC to DST. The source and destination do
723fe7d1
JD
521 not overlap. */
522# ifndef YYCOPY
523# if defined __GNUC__ && 1 < __GNUC__
14f4455e
AD
524# define YYCOPY(Dst, Src, Count) \
525 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
723fe7d1 526# else
14f4455e
AD
527# define YYCOPY(Dst, Src, Count) \
528 do \
529 { \
530 YYSIZE_T yyi; \
531 for (yyi = 0; yyi < (Count); yyi++) \
532 (Dst)[yyi] = (Src)[yyi]; \
533 } \
723fe7d1
JD
534 while (YYID (0))
535# endif
536# endif
537#endif /* !YYCOPY_NEEDED */
538
9d9b8b70 539/* YYFINAL -- State number of the termination state. */
9c1e26bd 540#define YYFINAL ]b4_final_state_number[
39912f52 541/* YYLAST -- Last index in YYTABLE. */
9c1e26bd 542#define YYLAST ]b4_last[
7742ddeb 543
9d9b8b70 544/* YYNTOKENS -- Number of terminals. */
9c1e26bd 545#define YYNTOKENS ]b4_tokens_number[
9d9b8b70 546/* YYNNTS -- Number of nonterminals. */
9c1e26bd 547#define YYNNTS ]b4_nterms_number[
9d9b8b70 548/* YYNRULES -- Number of rules. */
9c1e26bd 549#define YYNRULES ]b4_rules_number[
9d9b8b70 550/* YYNRULES -- Number of states. */
9c1e26bd 551#define YYNSTATES ]b4_states_number[
7742ddeb
AD
552
553/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
9c1e26bd
AD
554#define YYUNDEFTOK ]b4_undef_token_number[
555#define YYMAXUTOK ]b4_user_token_number_max[
007a50a4 556
04098407 557#define YYTRANSLATE(YYX) \
a20713a4 558 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
a8289c62 559
b0400cc6
AD
560/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
561static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
a8289c62 562{
c5e3e510 563 ]b4_translate[
a8289c62
RA
564};
565
566#if YYDEBUG
c5e3e510 567/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
7742ddeb 568 YYRHS. */
c5e3e510 569static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
a8289c62 570{
c5e3e510 571 ]b4_prhs[
a8289c62
RA
572};
573
9d9b8b70 574/* YYRHS -- A `-1'-separated list of the rules' RHS. */
c5e3e510 575static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
a8289c62 576{
c5e3e510 577 ]b4_rhs[
a8289c62
RA
578};
579
c5e3e510
AD
580/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
581static const ]b4_int_type_for([b4_rline])[ yyrline[] =
a8289c62 582{
c5e3e510 583 ]b4_rline[
a8289c62
RA
584};
585#endif
586
141f5793 587#if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
9e0876fb 588/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
9d9b8b70 589 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
c5e3e510 590static const char *const yytname[] =
a8289c62 591{
c5e3e510 592 ]b4_tname[
a8289c62
RA
593};
594#endif
595
c0ad8bf3 596# ifdef YYPRINT
c5e3e510 597/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
769b430f 598 token YYLEX-NUM. */
c5e3e510 599static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
a8289c62 600{
c5e3e510 601 ]b4_toknum[
a8289c62 602};
c0ad8bf3 603# endif
a8289c62 604
c5e3e510
AD
605/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
606static const ]b4_int_type_for([b4_r1])[ yyr1[] =
a8289c62 607{
c5e3e510 608 ]b4_r1[
a8289c62
RA
609};
610
c5e3e510
AD
611/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
612static const ]b4_int_type_for([b4_r2])[ yyr2[] =
a8289c62 613{
c5e3e510 614 ]b4_r2[
a8289c62
RA
615};
616
620b5727
JD
617/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
618 Performed when YYTABLE doesn't specify something else to do. Zero
5504898e 619 means the default is an error. */
c5e3e510 620static const ]b4_int_type_for([b4_defact])[ yydefact[] =
a8289c62 621{
c5e3e510 622 ]b4_defact[
a8289c62
RA
623};
624
9d9b8b70 625/* YYDEFGOTO[NTERM-NUM]. */
c5e3e510 626static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
a8289c62 627{
c5e3e510 628 ]b4_defgoto[
a8289c62
RA
629};
630
c5e3e510 631/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
7742ddeb 632 STATE-NUM. */
c5e3e510
AD
633#define YYPACT_NINF ]b4_pact_ninf[
634static const ]b4_int_type_for([b4_pact])[ yypact[] =
a8289c62 635{
c5e3e510 636 ]b4_pact[
a8289c62
RA
637};
638
c5e3e510
AD
639/* YYPGOTO[NTERM-NUM]. */
640static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
a8289c62 641{
c5e3e510 642 ]b4_pgoto[
a8289c62
RA
643};
644
c5e3e510 645/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
7742ddeb 646 positive, shift that token. If negative, reduce the rule which
e4bcae3c 647 number is the opposite. If YYTABLE_NINF, syntax error. */
c5e3e510
AD
648#define YYTABLE_NINF ]b4_table_ninf[
649static const ]b4_int_type_for([b4_table])[ yytable[] =
a8289c62 650{
c5e3e510 651 ]b4_table[
a8289c62
RA
652};
653
d5eb0826 654#define yypact_value_is_default(yystate) \
77373efa
JD
655 ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[
656
d5eb0826 657#define yytable_value_is_error(yytable_value) \
e4bcae3c 658 ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[
77373efa 659
c5e3e510 660static const ]b4_int_type_for([b4_check])[ yycheck[] =
a8289c62 661{
c5e3e510 662 ]b4_check[
a8289c62
RA
663};
664
c5e3e510 665/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
5504898e 666 symbol of state STATE-NUM. */
c5e3e510 667static const ]b4_int_type_for([b4_stos])[ yystos[] =
5504898e 668{
c5e3e510 669 ]b4_stos[
5504898e 670};
7093d0f5 671
10fa2066 672#define yyerrok (yyerrstatus = 0)
a20713a4
PE
673#define yyclearin (yychar = YYEMPTY)
674#define YYEMPTY (-2)
10fa2066 675#define YYEOF 0
a8289c62 676
70ddf897 677#define YYACCEPT goto yyacceptlab
a8289c62 678#define YYABORT goto yyabortlab
a6b89bb2 679#define YYERROR goto yyerrorlab
8a3eb3c8 680
a8289c62 681
71da9eea
AD
682/* Like YYERROR except do call yyerror. This remains here temporarily
683 to ease the transition to the new meaning of YYERROR, for GCC.
41d35e54
JD
684 Once GCC version 2 has supplanted version 1, this can go. However,
685 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
686 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
687 discussed. */
a8289c62 688
10fa2066 689#define YYFAIL goto yyerrlab
41d35e54
JD
690#if defined YYFAIL
691 /* This is here to suppress warnings from the GCC cpp's
692 -Wunused-macros. Normally we don't worry about that warning, but
693 some users do, and we want to make it easy for users to remove
694 YYFAIL uses, which will produce warnings from Bison 2.5. */
695#endif
a8289c62 696
10fa2066 697#define YYRECOVERING() (!!yyerrstatus)
a8289c62 698
94556574
AD
699#define YYBACKUP(Token, Value) \
700do \
701 if (yychar == YYEMPTY) \
702 { \
703 yychar = (Token); \
704 yylval = (Value); \
705 YYPOPSTACK (yylen); \
706 yystate = *yyssp; \]b4_lac_if([[
707 YY_LAC_DISCARD ("YYBACKUP"); \]])[
708 goto yybackup; \
709 } \
710 else \
711 { \
30757c8c 712 yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
71da9eea
AD
713 YYERROR; \
714 } \
12ce2df6 715while (YYID (0))
10fa2066 716
3fc16193 717
10fa2066
RS
718#define YYTERROR 1
719#define YYERRCODE 256
720
3fc16193 721
b4a20338
AD
722/* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
723 If N is 0, then set CURRENT to the empty location which ends
724 the previous symbol: RHS[0] (always defined). */
3abcd459 725
24e0cbd0 726#define YYRHSLOC(Rhs, K) ((Rhs)[K])
3abcd459 727#ifndef YYLLOC_DEFAULT
24e0cbd0
PE
728# define YYLLOC_DEFAULT(Current, Rhs, N) \
729 do \
d6cff4dc 730 if (YYID (N)) \
24e0cbd0 731 { \
9bec482e
PE
732 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
733 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
734 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
735 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
24e0cbd0
PE
736 } \
737 else \
738 { \
739 (Current).first_line = (Current).last_line = \
9bec482e 740 YYRHSLOC (Rhs, 0).last_line; \
24e0cbd0 741 (Current).first_column = (Current).last_column = \
9bec482e 742 YYRHSLOC (Rhs, 0).last_column; \
24e0cbd0 743 } \
12ce2df6 744 while (YYID (0))
3bba2dad
JD
745#endif]b4_locations_if([[
746
b8458aa5 747
3fc16193
AD
748/* YY_LOCATION_PRINT -- Print the location on the stream.
749 This macro was not mandated originally: define only if we know
750 we won't break user code: when these are the locations we know. */
751
3fc16193 752#ifndef YY_LOCATION_PRINT
06caf0e1 753# if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
b8458aa5
AD
754# define YY_LOCATION_PRINT(File, Loc) \
755 fprintf (File, "%d.%d-%d.%d", \
02650b7f
PE
756 (Loc).first_line, (Loc).first_column, \
757 (Loc).last_line, (Loc).last_column)
0dcca5c2
AD
758# else
759# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
b8458aa5 760# endif
3bba2dad
JD
761#endif]], [[
762
763
874ac415 764/* This macro is provided for backward compatibility. */
3abcd459 765
874ac415
JN
766#ifndef YY_LOCATION_PRINT
767# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
3bba2dad
JD
768#endif]])[
769
3fc16193 770
3abcd459 771/* YYLEX -- calling `yylex' with the right arguments. */
553e2b22 772
ae7453f2 773#ifdef YYLEX_PARAM
327afc7c 774# define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)
74310291 775#else
9c1e26bd 776# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
ae7453f2 777#endif
553e2b22 778
5a35a6cb 779/* Enable debugging if requested. */
0d533154 780#if YYDEBUG
b7575ffe 781
2f4f028d 782# ifndef YYFPRINTF
45119af1
PE
783# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
784# define YYFPRINTF fprintf
b7575ffe
PE
785# endif
786
5a35a6cb
AD
787# define YYDPRINTF(Args) \
788do { \
17da6427 789 if (yydebug) \
b7575ffe 790 YYFPRINTF Args; \
12ce2df6 791} while (YYID (0))
c5e3e510 792
4b367315
AD
793# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
794do { \
795 if (yydebug) \
796 { \
797 YYFPRINTF (stderr, "%s ", Title); \
a0af42fc 798 yy_symbol_print (stderr, \
327afc7c 799 Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
4b367315
AD
800 YYFPRINTF (stderr, "\n"); \
801 } \
12ce2df6 802} while (YYID (0))
9c1e26bd 803
a0af42fc 804]b4_yy_symbol_print_generate([b4_c_function_def])[
d1ff7a7c 805
b0937b22
AD
806/*------------------------------------------------------------------.
807| yy_stack_print -- Print the state stack from its BOTTOM up to its |
5348bfbe 808| TOP (included). |
b0937b22
AD
809`------------------------------------------------------------------*/
810
811]b4_c_function_def([yy_stack_print], [static void],
cd9e1ba2
PE
812 [[yytype_int16 *yybottom], [yybottom]],
813 [[yytype_int16 *yytop], [yytop]])[
b0937b22 814{
2f4f028d 815 YYFPRINTF (stderr, "Stack now");
cd9e1ba2
PE
816 for (; yybottom <= yytop; yybottom++)
817 {
818 int yybot = *yybottom;
819 YYFPRINTF (stderr, " %d", yybot);
820 }
2f4f028d 821 YYFPRINTF (stderr, "\n");
b0937b22
AD
822}
823
824# define YY_STACK_PRINT(Bottom, Top) \
825do { \
826 if (yydebug) \
827 yy_stack_print ((Bottom), (Top)); \
12ce2df6 828} while (YYID (0))
b0937b22
AD
829
830
831/*------------------------------------------------.
832| Report that the YYRULE is going to be reduced. |
833`------------------------------------------------*/
834
835]b4_c_function_def([yy_reduce_print], [static void],
02650b7f 836 [[YYSTYPE *yyvsp], [yyvsp]],
aefef0d6
PE
837 b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
838 ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
9ca7f077 839 b4_parse_param]))[
b0937b22 840{
d1ff7a7c 841 int yynrhs = yyr2[yyrule];
b0937b22 842 int yyi;
30757c8c 843 unsigned long int yylno = yyrline[yyrule];
d1ff7a7c 844 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
02650b7f 845 yyrule - 1, yylno);
d1ff7a7c
AD
846 /* The symbols being reduced. */
847 for (yyi = 0; yyi < yynrhs; yyi++)
848 {
f57a7536 849 YYFPRINTF (stderr, " $%d = ", yyi + 1);
a0af42fc 850 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
02650b7f 851 &]b4_rhs_value(yynrhs, yyi + 1)[
327afc7c 852 ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
02650b7f 853 b4_user_args[);
f57a7536 854 YYFPRINTF (stderr, "\n");
d1ff7a7c 855 }
b0937b22
AD
856}
857
d9963c85
PE
858# define YY_REDUCE_PRINT(Rule) \
859do { \
860 if (yydebug) \
327afc7c 861 yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
12ce2df6 862} while (YYID (0))
b0937b22 863
cf44a9ae
PE
864/* Nonzero means print parse trace. It is left uninitialized so that
865 multiple parsers can coexist. */
17da6427 866int yydebug;
5a35a6cb
AD
867#else /* !YYDEBUG */
868# define YYDPRINTF(Args)
284acc8b 869# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
b0937b22 870# define YY_STACK_PRINT(Bottom, Top)
d9963c85 871# define YY_REDUCE_PRINT(Rule)
5a35a6cb
AD
872#endif /* !YYDEBUG */
873
b0937b22 874
5a35a6cb 875/* YYINITDEPTH -- initial size of the parser's stacks. */
10fa2066 876#ifndef YYINITDEPTH
9c1e26bd 877# define YYINITDEPTH ]b4_stack_depth_init[
10fa2066
RS
878#endif
879
5a35a6cb 880/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
600f9b0c
PE
881 if the built-in stack extension method is used).
882
883 Do not make this value too large; the results are undefined if
506ffb1f 884 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
600f9b0c
PE
885 evaluated with infinite-precision integer arithmetic. */
886
10fa2066 887#ifndef YYMAXDEPTH
9c1e26bd 888# define YYMAXDEPTH ]b4_stack_depth_max[
ea13bea8
JD
889#endif]b4_lac_if([[
890
723fe7d1
JD
891/* Given a state stack such that *YYBOTTOM is its bottom, such that
892 *YYTOP is either its top or is YYTOP_EMPTY to indicate an empty
893 stack, and such that *YYCAPACITY is the maximum number of elements it
894 can hold without a reallocation, make sure there is enough room to
895 store YYADD more elements. If not, allocate a new stack using
896 YYSTACK_ALLOC, copy the existing elements, and adjust *YYBOTTOM,
897 *YYTOP, and *YYCAPACITY to reflect the new capacity and memory
898 location. If *YYBOTTOM != YYBOTTOM_NO_FREE, then free the old stack
899 using YYSTACK_FREE. Return 0 if successful or if no reallocation is
900 required. Return 1 if memory is exhausted. */
901static int
902yy_lac_stack_realloc (YYSIZE_T *yycapacity, YYSIZE_T yyadd,
903#if YYDEBUG
904 char const *yydebug_prefix,
905 char const *yydebug_suffix,
906#endif
907 yytype_int16 **yybottom,
908 yytype_int16 *yybottom_no_free,
909 yytype_int16 **yytop, yytype_int16 *yytop_empty)
910{
911 YYSIZE_T yysize_old =
912 *yytop == yytop_empty ? 0 : *yytop - *yybottom + 1;
913 YYSIZE_T yysize_new = yysize_old + yyadd;
914 if (*yycapacity < yysize_new)
915 {
916 YYSIZE_T yyalloc = 2 * yysize_new;
917 yytype_int16 *yybottom_new;
918 /* Use YYMAXDEPTH for maximum stack size given that the stack
919 should never need to grow larger than the main state stack
920 needs to grow without LAC. */
921 if (YYMAXDEPTH < yysize_new)
922 {
923 YYDPRINTF ((stderr, "%smax size exceeded%s", yydebug_prefix,
924 yydebug_suffix));
925 return 1;
926 }
927 if (YYMAXDEPTH < yyalloc)
928 yyalloc = YYMAXDEPTH;
929 yybottom_new =
930 (yytype_int16*) YYSTACK_ALLOC (yyalloc * sizeof *yybottom_new);
931 if (!yybottom_new)
932 {
933 YYDPRINTF ((stderr, "%srealloc failed%s", yydebug_prefix,
934 yydebug_suffix));
935 return 1;
936 }
937 if (*yytop != yytop_empty)
938 {
939 YYCOPY (yybottom_new, *yybottom, yysize_old);
940 *yytop = yybottom_new + (yysize_old - 1);
941 }
942 if (*yybottom != yybottom_no_free)
943 YYSTACK_FREE (*yybottom);
944 *yybottom = yybottom_new;
945 *yycapacity = yyalloc;]m4_if(b4_percent_define_get([[parse.lac.memory-trace]]),
946 [full], [[
947 YYDPRINTF ((stderr, "%srealloc to %lu%s", yydebug_prefix,
948 (unsigned long int) yyalloc, yydebug_suffix));]])[
949 }
950 return 0;
951}
952
ea13bea8
JD
953/* Establish the initial context for the current lookahead if no initial
954 context is currently established.
955
956 We define a context as a snapshot of the parser stacks. We define
957 the initial context for a lookahead as the context in which the
958 parser initially examines that lookahead in order to select a
959 syntactic action. Thus, if the lookahead eventually proves
960 syntactically unacceptable (possibly in a later context reached via a
961 series of reductions), the initial context can be used to determine
962 the exact set of tokens that would be syntactically acceptable in the
963 lookahead's place. Moreover, it is the context after which any
964 further semantic actions would be erroneous because they would be
965 determined by a syntactically unacceptable token.
966
967 YY_LAC_ESTABLISH should be invoked when a reduction is about to be
968 performed in an inconsistent state (which, for the purposes of LAC,
969 includes consistent states that don't know they're consistent because
970 their default reductions have been disabled). Iff there is a
971 lookahead token, it should also be invoked before reporting a syntax
972 error. This latter case is for the sake of the debugging output.
973
974 For parse.lac=full, the implementation of YY_LAC_ESTABLISH is as
975 follows. If no initial context is currently established for the
976 current lookahead, then check if that lookahead can eventually be
977 shifted if syntactic actions continue from the current context.
978 Report a syntax error if it cannot. */
723fe7d1
JD
979#define YY_LAC_ESTABLISH \
980do { \
981 if (!yy_lac_established) \
982 { \
983 YYDPRINTF ((stderr, \
984 "LAC: initial context established for %s\n", \
985 yytname[yytoken])); \
986 yy_lac_established = 1; \
987 { \
988 int yy_lac_status = \
989 yy_lac (yyesa, &yyes, &yyes_capacity, yyssp, yytoken); \
990 if (yy_lac_status == 2) \
991 goto yyexhaustedlab; \
992 if (yy_lac_status == 1) \
993 goto yyerrlab; \
994 } \
995 } \
ea13bea8
JD
996} while (YYID (0))
997
998/* Discard any previous initial lookahead context because of Event,
999 which may be a lookahead change or an invalidation of the currently
1000 established initial context for the current lookahead.
1001
1002 The most common example of a lookahead change is a shift. An example
1003 of both cases is syntax error recovery. That is, a syntax error
1004 occurs when the lookahead is syntactically erroneous for the
1005 currently established initial context, so error recovery manipulates
1006 the parser stacks to try to find a new initial context in which the
1007 current lookahead is syntactically acceptable. If it fails to find
1008 such a context, it discards the lookahead. */
1009#if YYDEBUG
1010# define YY_LAC_DISCARD(Event) \
1011do { \
1012 if (yy_lac_established) \
1013 { \
1014 if (yydebug) \
1015 YYFPRINTF (stderr, "LAC: initial context discarded due to " \
1016 Event "\n"); \
1017 yy_lac_established = 0; \
1018 } \
1019} while (YYID (0))
1020#else
1021# define YY_LAC_DISCARD(Event) yy_lac_established = 0
10fa2066 1022#endif
a8289c62 1023
ea13bea8 1024/* Given the stack whose top is *YYSSP, return 0 iff YYTOKEN can
723fe7d1
JD
1025 eventually (after perhaps some reductions) be shifted, return 1 if
1026 not, or return 2 if memory is exhausted. As preconditions and
1027 postconditions: *YYES_CAPACITY is the allocated size of the array to
1028 which *YYES points, and either *YYES = YYESA or *YYES points to an
1029 array allocated with YYSTACK_ALLOC. yy_lac may overwrite the
1030 contents of either array, alter *YYES and *YYES_CAPACITY, and free
1031 any old *YYES other than YYESA. */
ea13bea8 1032static int
723fe7d1
JD
1033yy_lac (yytype_int16 *yyesa, yytype_int16 **yyes,
1034 YYSIZE_T *yyes_capacity, yytype_int16 *yyssp, int yytoken)
ea13bea8
JD
1035{
1036 yytype_int16 *yyes_prev = yyssp;
ea13bea8
JD
1037 yytype_int16 *yyesp = yyes_prev;
1038 YYDPRINTF ((stderr, "LAC: checking lookahead %s:", yytname[yytoken]));
1039 if (yytoken == YYUNDEFTOK)
1040 {
1041 YYDPRINTF ((stderr, " Always Err\n"));
1042 return 1;
1043 }
1044 while (1)
1045 {
1046 int yyrule = yypact[*yyesp];
1047 if (yypact_value_is_default (yyrule)
1048 || (yyrule += yytoken) < 0 || YYLAST < yyrule
1049 || yycheck[yyrule] != yytoken)
1050 {
1051 yyrule = yydefact[*yyesp];
1052 if (yyrule == 0)
1053 {
1054 YYDPRINTF ((stderr, " Err\n"));
1055 return 1;
1056 }
1057 }
1058 else
1059 {
1060 yyrule = yytable[yyrule];
1061 if (yytable_value_is_error (yyrule))
1062 {
1063 YYDPRINTF ((stderr, " Err\n"));
1064 return 1;
1065 }
1066 if (0 < yyrule)
1067 {
1068 YYDPRINTF ((stderr, " S%d\n", yyrule));
1069 return 0;
1070 }
1071 yyrule = -yyrule;
1072 }
1073 {
1074 YYSIZE_T yylen = yyr2[yyrule];
1075 YYDPRINTF ((stderr, " R%d", yyrule - 1));
1076 if (yyesp != yyes_prev)
1077 {
723fe7d1 1078 YYSIZE_T yysize = yyesp - *yyes + 1;
ea13bea8
JD
1079 if (yylen < yysize)
1080 {
1081 yyesp -= yylen;
1082 yylen = 0;
1083 }
1084 else
1085 {
1086 yylen -= yysize;
1087 yyesp = yyes_prev;
1088 }
1089 }
1090 if (yylen)
1091 yyesp = yyes_prev -= yylen;
1092 }
1093 {
1094 int yystate;
1095 {
1096 int yylhs = yyr1[yyrule] - YYNTOKENS;
1097 yystate = yypgoto[yylhs] + *yyesp;
1098 if (yystate < 0 || YYLAST < yystate
1099 || yycheck[yystate] != *yyesp)
1100 yystate = yydefgoto[yylhs];
1101 else
1102 yystate = yytable[yystate];
1103 }
1104 if (yyesp == yyes_prev)
1105 {
723fe7d1 1106 yyesp = *yyes;
ea13bea8
JD
1107 *yyesp = yystate;
1108 }
1109 else
1110 {
723fe7d1
JD
1111 if (yy_lac_stack_realloc (yyes_capacity, 1,
1112#if YYDEBUG
1113 " (", ")",
1114#endif
1115 yyes, yyesa, &yyesp, yyes_prev))
ea13bea8 1116 {
723fe7d1 1117 YYDPRINTF ((stderr, "\n"));
ea13bea8
JD
1118 return 2;
1119 }
1120 *++yyesp = yystate;
1121 }
7e5ef706 1122 YYDPRINTF ((stderr, " G%d", yystate));
ea13bea8
JD
1123 }
1124 }
1125}]])[
1126
a8289c62 1127
7093d0f5
AD
1128#if YYERROR_VERBOSE
1129
1130# ifndef yystrlen
02650b7f 1131# if defined __GLIBC__ && defined _STRING_H
7093d0f5
AD
1132# define yystrlen strlen
1133# else
1134/* Return the length of YYSTR. */
1b9c21fb
PE
1135]b4_c_function_def([yystrlen], [static YYSIZE_T],
1136 [[const char *yystr], [yystr]])[
7093d0f5 1137{
12ce2df6
PE
1138 YYSIZE_T yylen;
1139 for (yylen = 0; yystr[yylen]; yylen++)
7093d0f5 1140 continue;
12ce2df6 1141 return yylen;
7093d0f5
AD
1142}
1143# endif
1144# endif
1145
1146# ifndef yystpcpy
02650b7f 1147# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
7093d0f5
AD
1148# define yystpcpy stpcpy
1149# else
1150/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1151 YYDEST. */
1b9c21fb
PE
1152]b4_c_function_def([yystpcpy], [static char *],
1153 [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[
7093d0f5 1154{
cb530ce9
PE
1155 char *yyd = yydest;
1156 const char *yys = yysrc;
7093d0f5
AD
1157
1158 while ((*yyd++ = *yys++) != '\0')
1159 continue;
1160
1161 return yyd - 1;
1162}
1163# endif
1164# endif
1165
9e0876fb
PE
1166# ifndef yytnamerr
1167/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1168 quotes and backslashes, so that it's suitable for yyerror. The
1169 heuristic is that double-quoting is unnecessary unless the string
1170 contains an apostrophe, a comma, or backslash (other than
1171 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1172 null, do not copy; instead, return the length of what the result
1173 would have been. */
1174static YYSIZE_T
1175yytnamerr (char *yyres, const char *yystr)
1176{
1177 if (*yystr == '"')
1178 {
276f48df 1179 YYSIZE_T yyn = 0;
9e0876fb
PE
1180 char const *yyp = yystr;
1181
1182 for (;;)
1183 switch (*++yyp)
1184 {
1185 case '\'':
1186 case ',':
1187 goto do_not_strip_quotes;
1188
1189 case '\\':
1190 if (*++yyp != '\\')
1191 goto do_not_strip_quotes;
1192 /* Fall through. */
1193 default:
1194 if (yyres)
1195 yyres[yyn] = *yyp;
1196 yyn++;
1197 break;
1198
1199 case '"':
1200 if (yyres)
1201 yyres[yyn] = '\0';
1202 return yyn;
1203 }
1204 do_not_strip_quotes: ;
1205 }
1206
1207 if (! yyres)
1208 return yystrlen (yystr);
1209
1210 return yystpcpy (yyres, yystr) - yyres;
1211}
1212# endif
1213
69a2ab11 1214/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
ea13bea8
JD
1215 about the unexpected token YYTOKEN for the state stack whose top is
1216 YYSSP.]b4_lac_if([[ In order to see if a particular token T is a
723fe7d1 1217 valid looakhead, invoke yy_lac (YYESA, YYES, YYES_CAPACITY, YYSSP, T).]])[
69a2ab11 1218
095a1d11
JD
1219 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1220 not large enough to hold the message. In that case, also set
1221 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
ea13bea8
JD
1222 required number of bytes is too large to store]b4_lac_if([[ or if
1223 yy_lac returned 2]])[. */
69a2ab11
JD
1224static int
1225yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
723fe7d1
JD
1226 ]b4_lac_if([[yytype_int16 *yyesa, yytype_int16 **yyes,
1227 YYSIZE_T *yyes_capacity, ]])[yytype_int16 *yyssp, int yytoken)
f953cb20 1228{
6557bcce 1229 YYSIZE_T yysize0 = yytnamerr (YY_NULL, yytname[yytoken]);
f953cb20
JD
1230 YYSIZE_T yysize = yysize0;
1231 YYSIZE_T yysize1;
1232 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1233 /* Internationalized format string. */
6557bcce 1234 const char *yyformat = YY_NULL;
f953cb20
JD
1235 /* Arguments of yyformat. */
1236 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
095a1d11
JD
1237 /* Number of reported tokens (one for the "unexpected", one per
1238 "expected"). */
1239 int yycount = 0;
f953cb20 1240
095a1d11
JD
1241 /* There are many possibilities here to consider:
1242 - Assume YYFAIL is not used. It's too flawed to consider. See
1243 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1244 for details. YYERROR is fine as it does not invoke this
1245 function.
1246 - If this state is a consistent state with a default action, then
1247 the only way this function was invoked is if the default action
1248 is an error action. In that case, don't check for expected
1249 tokens because there are none.
1250 - The only way there can be no lookahead present (in yychar) is if
1251 this state is a consistent state with a default action. Thus,
1252 detecting the absence of a lookahead is sufficient to determine
1253 that there is no unexpected or expected token to report. In that
1254 case, just report a simple "syntax error".
1255 - Don't assume there isn't a lookahead just because this state is a
1256 consistent state with a default action. There might have been a
1257 previous inconsistent state, consistent state with a non-default
ea13bea8
JD
1258 action, or user semantic action that manipulated yychar.]b4_lac_if([[
1259 In the first two cases, it might appear that the current syntax
1260 error should have been detected in the previous state when yy_lac
1261 was invoked. However, at that time, there might have been a
1262 different syntax error that discarded a different initial context
1263 during error recovery, leaving behind the current lookahead.]], [[
095a1d11
JD
1264 - Of course, the expected token list depends on states to have
1265 correct lookahead information, and it depends on the parser not
1266 to perform extra reductions after fetching a lookahead from the
1267 scanner and before detecting a syntax error. Thus, state merging
1268 (from LALR or IELR) and default reductions corrupt the expected
1269 token list. However, the list is correct for canonical LR with
1270 one exception: it will still contain any token that will not be
ea13bea8 1271 accepted due to an error action in a later state.]])[
095a1d11
JD
1272 */
1273 if (yytoken != YYEMPTY)
1274 {
ea13bea8
JD
1275 int yyn = yypact[*yyssp];]b4_lac_if([[
1276 YYDPRINTF ((stderr, "Constructing syntax error message\n"));]])[
095a1d11
JD
1277 yyarg[yycount++] = yytname[yytoken];
1278 if (!yypact_value_is_default (yyn))
ea13bea8 1279 {]b4_lac_if([], [[
f953cb20
JD
1280 /* Start YYX at -YYN if negative to avoid negative indexes in
1281 YYCHECK. In other words, skip the first -YYN actions for
1282 this state because they are default actions. */
1283 int yyxbegin = yyn < 0 ? -yyn : 0;
f953cb20
JD
1284 /* Stay within bounds of both yycheck and yytname. */
1285 int yychecklim = YYLAST - yyn + 1;
ea13bea8
JD
1286 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;]])[
1287 int yyx;]b4_lac_if([[
1288
1289 for (yyx = 0; yyx < YYNTOKENS; ++yyx)
1290 if (yyx != YYTERROR && yyx != YYUNDEFTOK)
1291 {
1292 {
723fe7d1
JD
1293 int yy_lac_status = yy_lac (yyesa, yyes, yyes_capacity,
1294 yyssp, yyx);
ea13bea8
JD
1295 if (yy_lac_status == 2)
1296 return 2;
1297 if (yy_lac_status == 1)
1298 continue;
1299 }]], [[
1300
f953cb20
JD
1301 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1302 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1303 && !yytable_value_is_error (yytable[yyx + yyn]))
ea13bea8 1304 {]])[
f953cb20
JD
1305 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1306 {
1307 yycount = 1;
1308 yysize = yysize0;
1309 break;
1310 }
1311 yyarg[yycount++] = yytname[yyx];
6557bcce 1312 yysize1 = yysize + yytnamerr (YY_NULL, yytname[yyx]);
095a1d11
JD
1313 if (! (yysize <= yysize1
1314 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1315 return 2;
f953cb20
JD
1316 yysize = yysize1;
1317 }
ea13bea8
JD
1318 }]b4_lac_if([[
1319# if YYDEBUG
1320 else if (yydebug)
1321 YYFPRINTF (stderr, "No expected tokens.\n");
1322# endif]])[
095a1d11 1323 }
f953cb20
JD
1324
1325 switch (yycount)
b4c1f9d2 1326 {
ea13bea8 1327# define YYCASE_(N, S) \
f953cb20
JD
1328 case N: \
1329 yyformat = S; \
1330 break
095a1d11 1331 YYCASE_(0, YY_("syntax error"));
f953cb20
JD
1332 YYCASE_(1, YY_("syntax error, unexpected %s"));
1333 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1334 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1335 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1336 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
ea13bea8 1337# undef YYCASE_
f953cb20 1338 }
d3d3628b 1339
f953cb20
JD
1340 yysize1 = yysize + yystrlen (yyformat);
1341 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
095a1d11 1342 return 2;
f953cb20
JD
1343 yysize = yysize1;
1344
1345 if (*yymsg_alloc < yysize)
1346 {
1347 *yymsg_alloc = 2 * yysize;
1348 if (! (yysize <= *yymsg_alloc
1349 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1350 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
095a1d11 1351 return 1;
f953cb20
JD
1352 }
1353
1354 /* Avoid sprintf, as that infringes on the user's name space.
1355 Don't have undefined behavior even if the translation
1356 produced a string with the wrong number of "%s"s. */
1357 {
1358 char *yyp = *yymsg;
1359 int yyi = 0;
1360 while ((*yyp = *yyformat) != '\0')
1361 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
69a2ab11 1362 {
f953cb20
JD
1363 yyp += yytnamerr (yyp, yyarg[yyi++]);
1364 yyformat += 2;
69a2ab11 1365 }
f953cb20 1366 else
69a2ab11 1367 {
f953cb20
JD
1368 yyp++;
1369 yyformat++;
69a2ab11 1370 }
f953cb20
JD
1371 }
1372 return 0;
1373}
b4c1f9d2 1374#endif /* YYERROR_VERBOSE */
a8289c62 1375
93d0103d 1376]b4_yydestruct_generate([b4_c_function_def])b4_push_if([], [[
4a2a22f4 1377
93d0103d
JD
1378
1379/* Prevent warnings from -Wmissing-prototypes. */
4a2a22f4 1380#ifdef YYPARSE_PARAM
1b9c21fb 1381]b4_c_function_decl([yyparse], [int],
93d0103d 1382 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
0245f82d 1383#else /* ! YYPARSE_PARAM */
d1ff7a7c 1384]b4_c_function_decl([yyparse], [int], b4_parse_param)[
93d0103d 1385#endif /* ! YYPARSE_PARAM */]])b4_pure_if([], [
9ca7f077 1386
93d0103d 1387b4_declare_scanner_communication_variables])[]b4_push_if([[
9ca7f077 1388
9ca7f077 1389
93d0103d
JD
1390struct yypstate
1391 {]b4_declare_parser_state_variables[
9ca7f077
JD
1392 /* Used to determine if this is the first time this instance has
1393 been used. */
1394 int yynew;
333e670c 1395 };]b4_pure_if([], [[
a35f64ea 1396
333e670c
JD
1397static char yypstate_allocated = 0;]])b4_pull_if([
1398
1399b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
9ca7f077 1400{
6557bcce 1401 return yypull_parse (YY_NULL]m4_ifset([b4_parse_param],
9ca7f077 1402 [[, ]b4_c_args(b4_parse_param)])[);
333e670c 1403}
0245f82d 1404
9ca7f077
JD
1405]b4_c_function_def([[yypull_parse]], [[int]],
1406 [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1407 b4_parse_param]))[
1408{
1409 int yystatus;
333e670c
JD
1410 yypstate *yyps_local;]b4_pure_if([[
1411 int yychar;
1412 YYSTYPE yylval;]b4_locations_if([[
1413 YYLTYPE yylloc;]])])[
6557bcce
AD
1414 if (yyps)
1415 yyps_local = yyps;
1416 else
9ca7f077
JD
1417 {
1418 yyps_local = yypstate_new ();
1419 if (!yyps_local)
1420 {]b4_pure_if([[
1421 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
1422 if (!yypstate_allocated)
1423 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
1424 return 2;
1425 }
1426 }
9ca7f077
JD
1427 do {
1428 yychar = YYLEX;
1429 yystatus =
1430 yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
1431 } while (yystatus == YYPUSH_MORE);
6557bcce 1432 if (!yyps)
9ca7f077
JD
1433 yypstate_delete (yyps_local);
1434 return yystatus;
333e670c
JD
1435}]])[
1436
9ca7f077
JD
1437/* Initialize the parser data structure. */
1438]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
1439{
1440 yypstate *yyps;]b4_pure_if([], [[
1441 if (yypstate_allocated)
6557bcce 1442 return YY_NULL;]])[
9ca7f077
JD
1443 yyps = (yypstate *) malloc (sizeof *yyps);
1444 if (!yyps)
6557bcce 1445 return YY_NULL;
9ca7f077
JD
1446 yyps->yynew = 1;]b4_pure_if([], [[
1447 yypstate_allocated = 1;]])[
1448 return yyps;
1449}
1450
1451]b4_c_function_def([[yypstate_delete]], [[void]],
1452 [[[yypstate *yyps]], [[yyps]]])[
1453{
1454#ifndef yyoverflow
1455 /* If the stack was reallocated but the parse did not complete, then the
1456 stack still needs to be freed. */
1457 if (!yyps->yynew && yyps->yyss != yyps->yyssa)
1458 YYSTACK_FREE (yyps->yyss);
723fe7d1
JD
1459#endif]b4_lac_if([[
1460 if (!yyps->yynew && yyps->yyes != yyps->yyesa)
1461 YYSTACK_FREE (yyps->yyes);]])[
9ca7f077
JD
1462 free (yyps);]b4_pure_if([], [[
1463 yypstate_allocated = 0;]])[
1464}
93d0103d
JD
1465]b4_pure_if([[
1466#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs]])[
1467#define yystate yyps->yystate
9ca7f077
JD
1468#define yyerrstatus yyps->yyerrstatus
1469#define yyssa yyps->yyssa
1470#define yyss yyps->yyss
1471#define yyssp yyps->yyssp
1472#define yyvsa yyps->yyvsa
1473#define yyvs yyps->yyvs
93d0103d
JD
1474#define yyvsp yyps->yyvsp]b4_locations_if([[
1475#define yylsa yyps->yylsa
9ca7f077
JD
1476#define yyls yyps->yyls
1477#define yylsp yyps->yylsp
93d0103d 1478#define yyerror_range yyps->yyerror_range]])[
723fe7d1
JD
1479#define yystacksize yyps->yystacksize]b4_lac_if([[
1480#define yyesa yyps->yyesa
1481#define yyes yyps->yyes
1482#define yyes_capacity yyps->yyes_capacity]])[
93d0103d
JD
1483
1484
1485/*---------------.
1486| yypush_parse. |
1487`---------------*/
1488
1489]b4_c_function_def([[yypush_parse]], [[int]],
9ca7f077
JD
1490 [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
1491 [[[int yypushed_char]], [[yypushed_char]]],
1492 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1493 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
93d0103d
JD
1494 b4_parse_param]))], [[
1495
1496
1497/*----------.
1498| yyparse. |
1499`----------*/
1500
0245f82d 1501#ifdef YYPARSE_PARAM
93d0103d
JD
1502]b4_c_function_def([yyparse], [int],
1503 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
0245f82d 1504#else /* ! YYPARSE_PARAM */
93d0103d
JD
1505]b4_c_function_def([yyparse], [int], b4_parse_param)[
1506#endif]])[
1507{]b4_pure_if([b4_declare_scanner_communication_variables
1508])b4_push_if([b4_pure_if([], [[
1509 int yypushed_char = yychar;
1510 YYSTYPE yypushed_val = yylval;]b4_locations_if([[
1511 YYLTYPE yypushed_loc = yylloc;]])
1512])],
1513 [b4_declare_parser_state_variables
ea13bea8
JD
1514])b4_lac_if([[
1515 int yy_lac_established = 0;]])[
cb530ce9 1516 int yyn;
600f9b0c 1517 int yyresult;
742e4900 1518 /* Lookahead token as an internal (translated) token number. */
9ca7f077
JD
1519 int yytoken;
1520 /* The variables used to return semantic value and location from the
1521 action routines. */
fa6aa7b3
JD
1522 YYSTYPE yyval;]b4_locations_if([[
1523 YYLTYPE yyloc;]])[
1524
b4c1f9d2
PE
1525#if YYERROR_VERBOSE
1526 /* Buffer for error messages, and its allocated size. */
1527 char yymsgbuf[128];
1528 char *yymsg = yymsgbuf;
1529 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1530#endif
10fa2066 1531
327afc7c 1532#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
10fa2066 1533
a85284cf 1534 /* The number of symbols on the RHS of the reduced rule.
9d9b8b70 1535 Keep to zero when no symbol should be popped. */
fa6aa7b3
JD
1536 int yylen = 0;]b4_push_if([[
1537
9ca7f077
JD
1538 if (!yyps->yynew)
1539 {
1540 yyn = yypact[yystate];
1541 goto yyread_pushed_token;
fa6aa7b3
JD
1542 }]])[
1543
9ca7f077
JD
1544 yytoken = 0;
1545 yyss = yyssa;
fa6aa7b3
JD
1546 yyvs = yyvsa;]b4_locations_if([[
1547 yyls = yylsa;]])[
723fe7d1
JD
1548 yystacksize = YYINITDEPTH;]b4_lac_if([[
1549
1550 yyes = yyesa;
1551 yyes_capacity = sizeof yyesa / sizeof *yyes;
1552 if (YYMAXDEPTH < yyes_capacity)
1553 yyes_capacity = YYMAXDEPTH;]])[
10fa2066 1554
2f4f028d 1555 YYDPRINTF ((stderr, "Starting parse\n"));
10fa2066
RS
1556
1557 yystate = 0;
1558 yyerrstatus = 0;
17da6427 1559 yynerrs = 0;
9ca7f077 1560 yychar = YYEMPTY; /* Cause a token to be read. */
10fa2066
RS
1561
1562 /* Initialize stack pointers.
1563 Waste one element of value and location stack
1564 so that they stay on the same level as the state stack.
1565 The wasted elements are never initialized. */
cbd89906 1566 yyssp = yyss;
9ca7f077
JD
1567 yyvsp = yyvs;]b4_locations_if([[
1568 yylsp = yyls;
1569
06caf0e1 1570#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
b8458aa5 1571 /* Initialize the default location before parsing starts. */
cd48d21d
AD
1572 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
1573 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
9ca7f077
JD
1574#endif]])
1575m4_ifdef([b4_initial_action],[
407d4a75
PE
1576m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl
1577m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
9ca7f077
JD
1578/* User initialization code. */
1579b4_user_initial_action
cd3684cf 1580m4_popdef([b4_dollar_dollar])dnl
8ec0a172 1581m4_popdef([b4_at_dollar])])dnl
407d4a75
PE
1582m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval;
1583]])dnl
1584m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc;
9ca7f077
JD
1585]])[
1586 goto yysetstate;
10fa2066 1587
71da9eea
AD
1588/*------------------------------------------------------------.
1589| yynewstate -- Push a new state, which is found in yystate. |
1590`------------------------------------------------------------*/
342b8b6e 1591 yynewstate:
71da9eea 1592 /* In all cases, when you get here, the value and location stacks
9d9b8b70 1593 have just been pushed. So pushing a state here evens the stacks. */
cbd89906
PE
1594 yyssp++;
1595
342b8b6e 1596 yysetstate:
cbd89906 1597 *yyssp = yystate;
10fa2066 1598
39912f52 1599 if (yyss + yystacksize - 1 <= yyssp)
10fa2066 1600 {
10fa2066 1601 /* Get the current used size of the three stacks, in elements. */
7093d0f5 1602 YYSIZE_T yysize = yyssp - yyss + 1;
10fa2066
RS
1603
1604#ifdef yyoverflow
3d76b07d 1605 {
9d9b8b70 1606 /* Give user a chance to reallocate the stack. Use copies of
3d76b07d
AD
1607 these so that the &'s don't force the real ones into
1608 memory. */
1609 YYSTYPE *yyvs1 = yyvs;
9ca7f077
JD
1610 yytype_int16 *yyss1 = yyss;]b4_locations_if([
1611 YYLTYPE *yyls1 = yyls;])[
3d76b07d
AD
1612
1613 /* Each stack pointer address is followed by the size of the
58612f1d
AD
1614 data in use in that stack, in bytes. This used to be a
1615 conditional around just the two extra args, but that might
1616 be undefined if yyoverflow is a macro. */
1a059451 1617 yyoverflow (YY_("memory exhausted"),
7093d0f5 1618 &yyss1, yysize * sizeof (*yyssp),
9ca7f077
JD
1619 &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
1620 &yyls1, yysize * sizeof (*yylsp),])[
3d76b07d 1621 &yystacksize);
9ca7f077
JD
1622]b4_locations_if([
1623 yyls = yyls1;])[
3d76b07d
AD
1624 yyss = yyss1;
1625 yyvs = yyvs1;
1626 }
10fa2066 1627#else /* no yyoverflow */
cf44a9ae 1628# ifndef YYSTACK_RELOCATE
1a059451 1629 goto yyexhaustedlab;
cf44a9ae 1630# else
10fa2066 1631 /* Extend the stack our own way. */
39912f52 1632 if (YYMAXDEPTH <= yystacksize)
1a059451 1633 goto yyexhaustedlab;
10fa2066 1634 yystacksize *= 2;
39912f52 1635 if (YYMAXDEPTH < yystacksize)
10fa2066 1636 yystacksize = YYMAXDEPTH;
e9e4c321 1637
600f9b0c 1638 {
d42cf844 1639 yytype_int16 *yyss1 = yyss;
2729e106
PE
1640 union yyalloc *yyptr =
1641 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
600f9b0c 1642 if (! yyptr)
1a059451 1643 goto yyexhaustedlab;
9ca7f077
JD
1644 YYSTACK_RELOCATE (yyss_alloc, yyss);
1645 YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
1646 YYSTACK_RELOCATE (yyls_alloc, yyls);])[
cf44a9ae 1647# undef YYSTACK_RELOCATE
600f9b0c
PE
1648 if (yyss1 != yyssa)
1649 YYSTACK_FREE (yyss1);
1650 }
cf44a9ae 1651# endif
10fa2066
RS
1652#endif /* no yyoverflow */
1653
7093d0f5 1654 yyssp = yyss + yysize - 1;
9ca7f077
JD
1655 yyvsp = yyvs + yysize - 1;]b4_locations_if([
1656 yylsp = yyls + yysize - 1;])[
10fa2066 1657
30757c8c 1658 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
600f9b0c 1659 (unsigned long int) yystacksize));
10fa2066 1660
39912f52 1661 if (yyss + yystacksize - 1 <= yyssp)
10fa2066
RS
1662 YYABORT;
1663 }
1664
30757c8c 1665 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
10fa2066 1666
868d2d96
JD
1667 if (yystate == YYFINAL)
1668 YYACCEPT;
1669
10fa2066 1670 goto yybackup;
71da9eea 1671
71da9eea
AD
1672/*-----------.
1673| yybackup. |
1674`-----------*/
1675yybackup:
10fa2066 1676
a85284cf 1677 /* Do appropriate processing given the current state. Read a
742e4900 1678 lookahead token if we need one and don't already have one. */
10fa2066 1679
742e4900 1680 /* First try to decide what to do without reference to lookahead token. */
10fa2066 1681 yyn = yypact[yystate];
d5eb0826 1682 if (yypact_value_is_default (yyn))
10fa2066
RS
1683 goto yydefault;
1684
742e4900 1685 /* Not known => get a lookahead token if don't already have one. */
10fa2066 1686
742e4900 1687 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
a20713a4 1688 if (yychar == YYEMPTY)
fa6aa7b3
JD
1689 {]b4_push_if([[
1690 if (!yyps->yynew)
1691 {]b4_use_push_for_pull_if([], [[
1692 YYDPRINTF ((stderr, "Return for a new token:\n"));]])[
1693 yyresult = YYPUSH_MORE;
9ca7f077
JD
1694 goto yypushreturn;
1695 }
fa6aa7b3 1696 yyps->yynew = 0;]b4_pure_if([], [[
9ca7f077
JD
1697 /* Restoring the pushed token is only necessary for the first
1698 yypush_parse invocation since subsequent invocations don't overwrite
1699 it before jumping to yyread_pushed_token. */
1700 yychar = yypushed_char;
fa6aa7b3
JD
1701 yylval = yypushed_val;]b4_locations_if([[
1702 yylloc = yypushed_loc;]])])[
1703yyread_pushed_token:]])[
1704 YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[
1705 yychar = yypushed_char;
9ca7f077 1706 if (yypushed_val)
fa6aa7b3
JD
1707 yylval = *yypushed_val;]b4_locations_if([[
1708 if (yypushed_loc)
1709 yylloc = *yypushed_loc;]])])], [[
1710 yychar = YYLEX;]])[
1711 }
10fa2066 1712
a20713a4 1713 if (yychar <= YYEOF)
10fa2066 1714 {
a20713a4 1715 yychar = yytoken = YYEOF;
2f4f028d 1716 YYDPRINTF ((stderr, "Now at end of input.\n"));
10fa2066
RS
1717 }
1718 else
1719 {
a20713a4 1720 yytoken = YYTRANSLATE (yychar);
30757c8c 1721 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
10fa2066
RS
1722 }
1723
b0400cc6 1724 /* If the proper action on seeing token YYTOKEN is to reduce or to
e5cfd9d8 1725 detect an error, take that action. */
b0400cc6 1726 yyn += yytoken;
ea13bea8
JD
1727 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)]b4_lac_if([[
1728 {
1729 YY_LAC_ESTABLISH;
1730 goto yydefault;
1731 }]], [[
1732 goto yydefault;]])[
e5cfd9d8
PE
1733 yyn = yytable[yyn];
1734 if (yyn <= 0)
10fa2066 1735 {
d5eb0826 1736 if (yytable_value_is_error (yyn))
ea13bea8
JD
1737 goto yyerrlab;]b4_lac_if([[
1738 YY_LAC_ESTABLISH;]])[
10fa2066
RS
1739 yyn = -yyn;
1740 goto yyreduce;
1741 }
10fa2066 1742
a85284cf
AD
1743 /* Count tokens shifted since error; after three, turn off error
1744 status. */
1745 if (yyerrstatus)
1746 yyerrstatus--;
1747
742e4900 1748 /* Shift the lookahead token. */
30757c8c 1749 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
10fa2066 1750
868d2d96 1751 /* Discard the shifted token. */
ea13bea8
JD
1752 yychar = YYEMPTY;]b4_lac_if([[
1753 YY_LAC_DISCARD ("shift");]])[
10fa2066 1754
a85284cf 1755 yystate = yyn;
17da6427 1756 *++yyvsp = yylval;
327afc7c 1757]b4_locations_if([ *++yylsp = yylloc;])[
10fa2066
RS
1758 goto yynewstate;
1759
10fa2066 1760
71da9eea
AD
1761/*-----------------------------------------------------------.
1762| yydefault -- do the default action for the current state. |
1763`-----------------------------------------------------------*/
1764yydefault:
10fa2066
RS
1765 yyn = yydefact[yystate];
1766 if (yyn == 0)
1767 goto yyerrlab;
71da9eea 1768 goto yyreduce;
10fa2066 1769
71da9eea
AD
1770
1771/*-----------------------------.
1772| yyreduce -- Do a reduction. |
1773`-----------------------------*/
10fa2066 1774yyreduce:
71da9eea 1775 /* yyn is the number of a rule to reduce with. */
10fa2066 1776 yylen = yyr2[yyn];
da9abf43
AD
1777
1778 /* If YYLEN is nonzero, implement the default value of the action:
573c1d9f 1779 `$$ = $1'.
da9abf43 1780
accea6db
PE
1781 Otherwise, the following line sets YYVAL to garbage.
1782 This behavior is undocumented and Bison
da9abf43
AD
1783 users should not rely upon it. Assigning to YYVAL
1784 unconditionally makes the parser a bit smaller, and it avoids a
1785 GCC warning that YYVAL may be used uninitialized. */
1786 yyval = yyvsp[1-yylen];
3abcd459 1787
327afc7c 1788]b4_locations_if(
9d9b8b70 1789[[ /* Default location. */
401aace6 1790 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
ea13bea8
JD
1791 YY_REDUCE_PRINT (yyn);]b4_lac_if([[
1792 {
1793 int yychar_backup = yychar;
1794 switch (yyn)
1795 {
1796 ]b4_user_actions[
1797 default: break;
1798 }
1799 if (yychar_backup != yychar)
1800 YY_LAC_DISCARD ("yychar change");
1801 }]], [[
a8289c62 1802 switch (yyn)
d1ff7a7c 1803 {
8ec0a172 1804 ]b4_user_actions[
95f22ad2 1805 default: break;
ea13bea8 1806 }]])[
abcc7c03
JD
1807 /* User semantic actions sometimes alter yychar, and that requires
1808 that yytoken be updated with the new translation. We take the
1809 approach of translating immediately before every use of yytoken.
1810 One alternative is translating here after every semantic action,
1811 but that translation would be missed if the semantic action invokes
1812 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1813 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1814 incorrect destructor might then be invoked immediately. In the
1815 case of YYERROR or YYBACKUP, subsequent parser actions might lead
1816 to an incorrect destructor call or verbose syntax error message
1817 before the lookahead is translated. */
d1ff7a7c 1818 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
897668ee 1819
a85284cf
AD
1820 YYPOPSTACK (yylen);
1821 yylen = 0;
b0937b22 1822 YY_STACK_PRINT (yyss, yyssp);
10fa2066 1823
9ca7f077
JD
1824 *++yyvsp = yyval;]b4_locations_if([
1825 *++yylsp = yyloc;])[
10fa2066 1826
41aca2e0
AD
1827 /* Now `shift' the result of the reduction. Determine what state
1828 that goes to, based on the state we popped back to and the rule
1829 number reduced by. */
10fa2066
RS
1830
1831 yyn = yyr1[yyn];
1832
7742ddeb 1833 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
34ec3579 1834 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
10fa2066
RS
1835 yystate = yytable[yystate];
1836 else
7742ddeb 1837 yystate = yydefgoto[yyn - YYNTOKENS];
10fa2066
RS
1838
1839 goto yynewstate;
1840
10fa2066 1841
71da9eea
AD
1842/*------------------------------------.
1843| yyerrlab -- here on detecting error |
1844`------------------------------------*/
1845yyerrlab:
abcc7c03
JD
1846 /* Make sure we have latest lookahead translation. See comments at
1847 user semantic actions for why this is necessary. */
095a1d11 1848 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
abcc7c03 1849
71da9eea
AD
1850 /* If not already recovering from an error, report this error. */
1851 if (!yyerrstatus)
10fa2066 1852 {
17da6427 1853 ++yynerrs;
b4c1f9d2
PE
1854#if ! YYERROR_VERBOSE
1855 yyerror (]b4_yyerror_args[YY_("syntax error"));
1856#else
723fe7d1
JD
1857# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \]b4_lac_if([[
1858 yyesa, &yyes, &yyes_capacity, \]])[
1859 yyssp, yytoken)
0e0f066b
JD
1860 {
1861 char const *yymsgp = YY_("syntax error");
ea13bea8
JD
1862 int yysyntax_error_status;]b4_lac_if([[
1863 if (yychar != YYEMPTY)
1864 YY_LAC_ESTABLISH;]])[
1865 yysyntax_error_status = YYSYNTAX_ERROR;
0e0f066b
JD
1866 if (yysyntax_error_status == 0)
1867 yymsgp = yymsg;
095a1d11 1868 else if (yysyntax_error_status == 1)
0e0f066b
JD
1869 {
1870 if (yymsg != yymsgbuf)
1871 YYSTACK_FREE (yymsg);
1872 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1873 if (!yymsg)
1874 {
1875 yymsg = yymsgbuf;
1876 yymsg_alloc = sizeof yymsgbuf;
095a1d11 1877 yysyntax_error_status = 2;
0e0f066b
JD
1878 }
1879 else
1880 {
1881 yysyntax_error_status = YYSYNTAX_ERROR;
1882 yymsgp = yymsg;
1883 }
1884 }
1885 yyerror (]b4_yyerror_args[yymsgp);
1886 if (yysyntax_error_status == 2)
1887 goto yyexhaustedlab;
1888 }
1889# undef YYSYNTAX_ERROR
b4c1f9d2 1890#endif
10fa2066 1891 }
71da9eea 1892
a005dbcb 1893]b4_locations_if([[ yyerror_range[1] = yylloc;]])[
d42f69cd 1894
10fa2066
RS
1895 if (yyerrstatus == 3)
1896 {
742e4900 1897 /* If just tried and failed to reuse lookahead token after an
71da9eea 1898 error, discard it. */
10fa2066 1899
a6b89bb2 1900 if (yychar <= YYEOF)
02650b7f 1901 {
258b75ca 1902 /* Return failure if at end of input. */
a6b89bb2 1903 if (yychar == YYEOF)
80ce3401 1904 YYABORT;
02650b7f 1905 }
a6b89bb2
PE
1906 else
1907 {
4b367315 1908 yydestruct ("Error: discarding",
327afc7c 1909 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
a6b89bb2 1910 yychar = YYEMPTY;
a6b89bb2 1911 }
10fa2066
RS
1912 }
1913
742e4900 1914 /* Else will try to reuse lookahead token after shifting the error
71da9eea 1915 token. */
8a3eb3c8 1916 goto yyerrlab1;
300a7966 1917
10fa2066 1918
a6b89bb2
PE
1919/*---------------------------------------------------.
1920| yyerrorlab -- error raised explicitly by YYERROR. |
1921`---------------------------------------------------*/
1922yyerrorlab:
1923
c7a65b99
PE
1924 /* Pacify compilers like GCC when the user code never invokes
1925 YYERROR and the label yyerrorlab therefore never appears in user
1926 code. */
2a4647a3 1927 if (/*CONSTCOND*/ 0)
a6b89bb2 1928 goto yyerrorlab;
a6b89bb2 1929
a005dbcb 1930]b4_locations_if([[ yyerror_range[1] = yylsp[1-yylen];
a85284cf 1931]])[ /* Do not reclaim the symbols of the rule which action triggered
9d9b8b70 1932 this YYERROR. */
a85284cf
AD
1933 YYPOPSTACK (yylen);
1934 yylen = 0;
1935 YY_STACK_PRINT (yyss, yyssp);
a6b89bb2 1936 yystate = *yyssp;
3fc16193 1937 goto yyerrlab1;
a6b89bb2
PE
1938
1939
1940/*-------------------------------------------------------------.
1941| yyerrlab1 -- common code for both syntax error and YYERROR. |
1942`-------------------------------------------------------------*/
300a7966 1943yyerrlab1:
cf44a9ae 1944 yyerrstatus = 3; /* Each real token shifted decrements this. */
10fa2066 1945
660bc8dd
PE
1946 for (;;)
1947 {
1948 yyn = yypact[yystate];
d5eb0826 1949 if (!yypact_value_is_default (yyn))
660bc8dd
PE
1950 {
1951 yyn += YYTERROR;
1952 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1953 {
1954 yyn = yytable[yyn];
1955 if (0 < yyn)
1956 break;
1957 }
1958 }
10fa2066 1959
660bc8dd
PE
1960 /* Pop the current state because it cannot handle the error token. */
1961 if (yyssp == yyss)
1962 YYABORT;
5504898e 1963
a005dbcb 1964]b4_locations_if([[ yyerror_range[1] = *yylsp;]])[
4b367315 1965 yydestruct ("Error: popping",
327afc7c 1966 yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
a85284cf 1967 YYPOPSTACK (1);
a6b89bb2 1968 yystate = *yyssp;
b0937b22 1969 YY_STACK_PRINT (yyss, yyssp);
ea13bea8
JD
1970 }]b4_lac_if([[
1971
1972 /* If the stack popping above didn't lose the initial context for the
1973 current lookahead token, the shift below will for sure. */
1974 YY_LAC_DISCARD ("error recovery");]])[
10fa2066 1975
17da6427 1976 *++yyvsp = yylval;
327afc7c 1977]b4_locations_if([[
a005dbcb 1978 yyerror_range[2] = yylloc;
3fc16193 1979 /* Using YYLLOC is tempting, but would change the location of
742e4900 1980 the lookahead. YYLOC is available though. */
a005dbcb 1981 YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
3fc16193 1982 *++yylsp = yyloc;]])[
10fa2066 1983
9d9b8b70 1984 /* Shift the error token. */
30757c8c 1985 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1576d44d 1986
10fa2066
RS
1987 yystate = yyn;
1988 goto yynewstate;
70ddf897 1989
71da9eea
AD
1990
1991/*-------------------------------------.
1992| yyacceptlab -- YYACCEPT comes here. |
1993`-------------------------------------*/
1994yyacceptlab:
600f9b0c
PE
1995 yyresult = 0;
1996 goto yyreturn;
71da9eea
AD
1997
1998/*-----------------------------------.
1999| yyabortlab -- YYABORT comes here. |
2000`-----------------------------------*/
2001yyabortlab:
600f9b0c
PE
2002 yyresult = 1;
2003 goto yyreturn;
2004
24bb5f8f 2005#if ]b4_lac_if([[1]], [[!defined yyoverflow || YYERROR_VERBOSE]])[
1a059451
PE
2006/*-------------------------------------------------.
2007| yyexhaustedlab -- memory exhaustion comes here. |
2008`-------------------------------------------------*/
2009yyexhaustedlab:
2010 yyerror (]b4_yyerror_args[YY_("memory exhausted"));
600f9b0c
PE
2011 yyresult = 2;
2012 /* Fall through. */
0bfb02ff 2013#endif
600f9b0c
PE
2014
2015yyreturn:
868d2d96 2016 if (yychar != YYEMPTY)
abcc7c03
JD
2017 {
2018 /* Make sure we have latest lookahead translation. See comments at
2019 user semantic actions for why this is necessary. */
2020 yytoken = YYTRANSLATE (yychar);
2021 yydestruct ("Cleanup: discarding lookahead",
2022 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
2023 }
a85284cf 2024 /* Do not reclaim the symbols of the rule which action triggered
9d9b8b70 2025 this YYABORT or YYACCEPT. */
a85284cf
AD
2026 YYPOPSTACK (yylen);
2027 YY_STACK_PRINT (yyss, yyssp);
258b75ca
PE
2028 while (yyssp != yyss)
2029 {
dd5f2af2 2030 yydestruct ("Cleanup: popping",
327afc7c 2031 yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
a85284cf 2032 YYPOPSTACK (1);
258b75ca 2033 }
600f9b0c
PE
2034#ifndef yyoverflow
2035 if (yyss != yyssa)
2036 YYSTACK_FREE (yyss);
723fe7d1
JD
2037#endif]b4_lac_if([[
2038 if (yyes != yyesa)
2039 YYSTACK_FREE (yyes);]])b4_push_if([[
93d0103d 2040 yyps->yynew = 1;
9ca7f077 2041
93d0103d
JD
2042yypushreturn:]])[
2043#if YYERROR_VERBOSE
b4c1f9d2
PE
2044 if (yymsg != yymsgbuf)
2045 YYSTACK_FREE (yymsg);
70ddf897 2046#endif
7b5cdcbd
JD
2047 /* Make sure YYID is used. */
2048 return YYID (yyresult);
9ca7f077 2049}
be2a1a68 2050
24c0aad7 2051
9ca7f077 2052]b4_epilogue
327afc7c 2053b4_defines_if(
0d2b2ab0 2054[@output(b4_spec_defines_file@)@
7e5ef706 2055b4_copyright([Bison interface for Yacc-like parsers in C],
ae6bdabb
AD
2056 [1984, 1989-1990, 2000-2012])[
2057]b4_shared_declarations[
c0828abf
AD
2058]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;
2059]b4_locations_if([[extern YYLTYPE ]b4_prefix[lloc;]])])dnl
327afc7c 2060])dnl b4_defines_if
08af01c2 2061m4_divert_pop(0)