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


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