]> git.saurik.com Git - bison.git/blob - data/yacc.c
projects / bison.git / blob
? search:


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