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