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