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