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


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