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