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