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