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