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