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


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