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


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