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