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