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