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


67d6abdab479a38bdbaa80c93e28388085e46d19
[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 # ifndef EXIT_SUCCESS
441 # define EXIT_SUCCESS 0
442 # endif
443 # endif
444 # endif
445 # endif
446 # endif]])])[
447
448 # ifdef YYSTACK_ALLOC
449 /* Pacify GCC's `empty if-body' warning. */
450 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
451 # ifndef YYSTACK_ALLOC_MAXIMUM
452 /* The OS might guarantee only one guard page at the bottom of the stack,
453 and a page size can be as small as 4096 bytes. So we cannot safely
454 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
455 to allow for a few compiler-allocated temporary stack slots. */
456 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
457 # endif
458 # else
459 # define YYSTACK_ALLOC YYMALLOC
460 # define YYSTACK_FREE YYFREE
461 # ifndef YYSTACK_ALLOC_MAXIMUM
462 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
463 # endif
464 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
465 && ! ((defined YYMALLOC || defined malloc) \
466 && (defined YYFREE || defined free)))
467 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
468 # ifndef EXIT_SUCCESS
469 # define EXIT_SUCCESS 0
470 # endif
471 # endif
472 # ifndef YYMALLOC
473 # define YYMALLOC malloc
474 # if ! defined malloc && ! defined EXIT_SUCCESS && ]b4_c_modern[
475 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
476 # endif
477 # endif
478 # ifndef YYFREE
479 # define YYFREE free
480 # if ! defined free && ! defined EXIT_SUCCESS && ]b4_c_modern[
481 void free (void *); /* INFRINGES ON USER NAME SPACE */
482 # endif
483 # endif
484 # endif]b4_lac_if([[
485 # define YYCOPY_NEEDED 1]])[
486 #endif]b4_lac_if([], [[ /* ! defined yyoverflow || YYERROR_VERBOSE */]])[
487
488
489 #if (! defined yyoverflow \
490 && (! defined __cplusplus \
491 || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
492 && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
493
494 /* A type that is properly aligned for any stack member. */
495 union yyalloc
496 {
497 yytype_int16 yyss_alloc;
498 YYSTYPE yyvs_alloc;]b4_locations_if([
499 YYLTYPE yyls_alloc;])[
500 };
501
502 /* The size of the maximum gap between one aligned stack and the next. */
503 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
504
505 /* The size of an array large to enough to hold all stacks, each with
506 N elements. */
507 ]b4_locations_if(
508 [# define YYSTACK_BYTES(N) \
509 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
510 + 2 * YYSTACK_GAP_MAXIMUM)],
511 [# define YYSTACK_BYTES(N) \
512 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
513 + YYSTACK_GAP_MAXIMUM)])[
514
515 # define YYCOPY_NEEDED 1
516
517 /* Relocate STACK from its old location to the new one. The
518 local variables YYSIZE and YYSTACKSIZE give the old and new number of
519 elements in the stack, and YYPTR gives the new location of the
520 stack. Advance YYPTR to a properly aligned location for the next
521 stack. */
522 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
523 do \
524 { \
525 YYSIZE_T yynewbytes; \
526 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
527 Stack = &yyptr->Stack_alloc; \
528 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
529 yyptr += yynewbytes / sizeof (*yyptr); \
530 } \
531 while (YYID (0))
532
533 #endif
534
535 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
536 /* Copy COUNT objects from FROM to TO. The source and destination do
537 not overlap. */
538 # ifndef YYCOPY
539 # if defined __GNUC__ && 1 < __GNUC__
540 # define YYCOPY(To, From, Count) \
541 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
542 # else
543 # define YYCOPY(To, From, Count) \
544 do \
545 { \
546 YYSIZE_T yyi; \
547 for (yyi = 0; yyi < (Count); yyi++) \
548 (To)[yyi] = (From)[yyi]; \
549 } \
550 while (YYID (0))
551 # endif
552 # endif
553 #endif /* !YYCOPY_NEEDED */
554
555 /* YYFINAL -- State number of the termination state. */
556 #define YYFINAL ]b4_final_state_number[
557 /* YYLAST -- Last index in YYTABLE. */
558 #define YYLAST ]b4_last[
559
560 /* YYNTOKENS -- Number of terminals. */
561 #define YYNTOKENS ]b4_tokens_number[
562 /* YYNNTS -- Number of nonterminals. */
563 #define YYNNTS ]b4_nterms_number[
564 /* YYNRULES -- Number of rules. */
565 #define YYNRULES ]b4_rules_number[
566 /* YYNRULES -- Number of states. */
567 #define YYNSTATES ]b4_states_number[
568
569 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
570 #define YYUNDEFTOK ]b4_undef_token_number[
571 #define YYMAXUTOK ]b4_user_token_number_max[
572
573 #define YYTRANSLATE(YYX) \
574 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
575
576 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
577 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
578 {
579 ]b4_translate[
580 };
581
582 #if YYDEBUG
583 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
584 YYRHS. */
585 static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
586 {
587 ]b4_prhs[
588 };
589
590 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
591 static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
592 {
593 ]b4_rhs[
594 };
595
596 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
597 static const ]b4_int_type_for([b4_rline])[ yyrline[] =
598 {
599 ]b4_rline[
600 };
601 #endif
602
603 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
604 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
605 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
606 static const char *const yytname[] =
607 {
608 ]b4_tname[
609 };
610 #endif
611
612 # ifdef YYPRINT
613 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
614 token YYLEX-NUM. */
615 static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
616 {
617 ]b4_toknum[
618 };
619 # endif
620
621 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
622 static const ]b4_int_type_for([b4_r1])[ yyr1[] =
623 {
624 ]b4_r1[
625 };
626
627 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
628 static const ]b4_int_type_for([b4_r2])[ yyr2[] =
629 {
630 ]b4_r2[
631 };
632
633 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
634 Performed when YYTABLE doesn't specify something else to do. Zero
635 means the default is an error. */
636 static const ]b4_int_type_for([b4_defact])[ yydefact[] =
637 {
638 ]b4_defact[
639 };
640
641 /* YYDEFGOTO[NTERM-NUM]. */
642 static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
643 {
644 ]b4_defgoto[
645 };
646
647 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
648 STATE-NUM. */
649 #define YYPACT_NINF ]b4_pact_ninf[
650 static const ]b4_int_type_for([b4_pact])[ yypact[] =
651 {
652 ]b4_pact[
653 };
654
655 /* YYPGOTO[NTERM-NUM]. */
656 static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
657 {
658 ]b4_pgoto[
659 };
660
661 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
662 positive, shift that token. If negative, reduce the rule which
663 number is the opposite. If YYTABLE_NINF, syntax error. */
664 #define YYTABLE_NINF ]b4_table_ninf[
665 static const ]b4_int_type_for([b4_table])[ yytable[] =
666 {
667 ]b4_table[
668 };
669
670 #define yypact_value_is_default(yystate) \
671 ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[
672
673 #define yytable_value_is_error(yytable_value) \
674 ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[
675
676 static const ]b4_int_type_for([b4_check])[ yycheck[] =
677 {
678 ]b4_check[
679 };
680
681 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
682 symbol of state STATE-NUM. */
683 static const ]b4_int_type_for([b4_stos])[ yystos[] =
684 {
685 ]b4_stos[
686 };
687
688 #define yyerrok (yyerrstatus = 0)
689 #define yyclearin (yychar = YYEMPTY)
690 #define YYEMPTY (-2)
691 #define YYEOF 0
692
693 #define YYACCEPT goto yyacceptlab
694 #define YYABORT goto yyabortlab
695 #define YYERROR goto yyerrorlab
696
697
698 /* Like YYERROR except do call yyerror. This remains here temporarily
699 to ease the transition to the new meaning of YYERROR, for GCC.
700 Once GCC version 2 has supplanted version 1, this can go. However,
701 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
702 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
703 discussed. */
704
705 #define YYFAIL goto yyerrlab
706 #if defined YYFAIL
707 /* This is here to suppress warnings from the GCC cpp's
708 -Wunused-macros. Normally we don't worry about that warning, but
709 some users do, and we want to make it easy for users to remove
710 YYFAIL uses, which will produce warnings from Bison 2.5. */
711 #endif
712
713 #define YYRECOVERING() (!!yyerrstatus)
714
715 #define YYBACKUP(Token, Value) \
716 do \
717 if (yychar == YYEMPTY && yylen == 1) \
718 { \
719 yychar = (Token); \
720 yylval = (Value); \
721 YYPOPSTACK (1); \]b4_lac_if([[
722 YY_LAC_DISCARD ("YYBACKUP"); \]])[
723 goto yybackup; \
724 } \
725 else \
726 { \
727 yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
728 YYERROR; \
729 } \
730 while (YYID (0))
731
732
733 #define YYTERROR 1
734 #define YYERRCODE 256
735
736
737 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
738 If N is 0, then set CURRENT to the empty location which ends
739 the previous symbol: RHS[0] (always defined). */
740
741 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
742 #ifndef YYLLOC_DEFAULT
743 # define YYLLOC_DEFAULT(Current, Rhs, N) \
744 do \
745 if (YYID (N)) \
746 { \
747 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
748 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
749 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
750 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
751 } \
752 else \
753 { \
754 (Current).first_line = (Current).last_line = \
755 YYRHSLOC (Rhs, 0).last_line; \
756 (Current).first_column = (Current).last_column = \
757 YYRHSLOC (Rhs, 0).last_column; \
758 } \
759 while (YYID (0))
760 #endif]b4_locations_if([[
761
762
763 /* YY_LOCATION_PRINT -- Print the location on the stream.
764 This macro was not mandated originally: define only if we know
765 we won't break user code: when these are the locations we know. */
766
767 #ifndef YY_LOCATION_PRINT
768 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
769 # define YY_LOCATION_PRINT(File, Loc) \
770 fprintf (File, "%d.%d-%d.%d", \
771 (Loc).first_line, (Loc).first_column, \
772 (Loc).last_line, (Loc).last_column)
773 # else
774 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
775 # endif
776 #endif]], [[
777
778
779 /* This macro is provided for backward compatibility. */
780
781 #ifndef YY_LOCATION_PRINT
782 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
783 #endif]])[
784
785
786 /* YYLEX -- calling `yylex' with the right arguments. */
787
788 #ifdef YYLEX_PARAM
789 # define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)
790 #else
791 # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
792 #endif
793
794 /* Enable debugging if requested. */
795 #if YYDEBUG
796
797 # ifndef YYFPRINTF
798 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
799 # define YYFPRINTF fprintf
800 # endif
801
802 # define YYDPRINTF(Args) \
803 do { \
804 if (yydebug) \
805 YYFPRINTF Args; \
806 } while (YYID (0))
807
808 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
809 do { \
810 if (yydebug) \
811 { \
812 YYFPRINTF (stderr, "%s ", Title); \
813 yy_symbol_print (stderr, \
814 Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
815 YYFPRINTF (stderr, "\n"); \
816 } \
817 } while (YYID (0))
818
819 ]b4_yy_symbol_print_generate([b4_c_function_def])[
820
821 /*------------------------------------------------------------------.
822 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
823 | TOP (included). |
824 `------------------------------------------------------------------*/
825
826 ]b4_c_function_def([yy_stack_print], [static void],
827 [[yytype_int16 *yybottom], [yybottom]],
828 [[yytype_int16 *yytop], [yytop]])[
829 {
830 YYFPRINTF (stderr, "Stack now");
831 for (; yybottom <= yytop; yybottom++)
832 {
833 int yybot = *yybottom;
834 YYFPRINTF (stderr, " %d", yybot);
835 }
836 YYFPRINTF (stderr, "\n");
837 }
838
839 # define YY_STACK_PRINT(Bottom, Top) \
840 do { \
841 if (yydebug) \
842 yy_stack_print ((Bottom), (Top)); \
843 } while (YYID (0))
844
845
846 /*------------------------------------------------.
847 | Report that the YYRULE is going to be reduced. |
848 `------------------------------------------------*/
849
850 ]b4_c_function_def([yy_reduce_print], [static void],
851 [[YYSTYPE *yyvsp], [yyvsp]],
852 b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
853 ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
854 b4_parse_param]))[
855 {
856 int yynrhs = yyr2[yyrule];
857 int yyi;
858 unsigned long int yylno = yyrline[yyrule];
859 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
860 yyrule - 1, yylno);
861 /* The symbols being reduced. */
862 for (yyi = 0; yyi < yynrhs; yyi++)
863 {
864 YYFPRINTF (stderr, " $%d = ", yyi + 1);
865 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
866 &]b4_rhs_value(yynrhs, yyi + 1)[
867 ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
868 b4_user_args[);
869 YYFPRINTF (stderr, "\n");
870 }
871 }
872
873 # define YY_REDUCE_PRINT(Rule) \
874 do { \
875 if (yydebug) \
876 yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
877 } while (YYID (0))
878
879 /* Nonzero means print parse trace. It is left uninitialized so that
880 multiple parsers can coexist. */
881 int yydebug;
882 #else /* !YYDEBUG */
883 # define YYDPRINTF(Args)
884 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
885 # define YY_STACK_PRINT(Bottom, Top)
886 # define YY_REDUCE_PRINT(Rule)
887 #endif /* !YYDEBUG */
888
889
890 /* YYINITDEPTH -- initial size of the parser's stacks. */
891 #ifndef YYINITDEPTH
892 # define YYINITDEPTH ]b4_stack_depth_init[
893 #endif
894
895 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
896 if the built-in stack extension method is used).
897
898 Do not make this value too large; the results are undefined if
899 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
900 evaluated with infinite-precision integer arithmetic. */
901
902 #ifndef YYMAXDEPTH
903 # define YYMAXDEPTH ]b4_stack_depth_max[
904 #endif]b4_lac_if([[
905
906 /* Given a state stack such that *YYBOTTOM is its bottom, such that
907 *YYTOP is either its top or is YYTOP_EMPTY to indicate an empty
908 stack, and such that *YYCAPACITY is the maximum number of elements it
909 can hold without a reallocation, make sure there is enough room to
910 store YYADD more elements. If not, allocate a new stack using
911 YYSTACK_ALLOC, copy the existing elements, and adjust *YYBOTTOM,
912 *YYTOP, and *YYCAPACITY to reflect the new capacity and memory
913 location. If *YYBOTTOM != YYBOTTOM_NO_FREE, then free the old stack
914 using YYSTACK_FREE. Return 0 if successful or if no reallocation is
915 required. Return 1 if memory is exhausted. */
916 static int
917 yy_lac_stack_realloc (YYSIZE_T *yycapacity, YYSIZE_T yyadd,
918 #if YYDEBUG
919 char const *yydebug_prefix,
920 char const *yydebug_suffix,
921 #endif
922 yytype_int16 **yybottom,
923 yytype_int16 *yybottom_no_free,
924 yytype_int16 **yytop, yytype_int16 *yytop_empty)
925 {
926 YYSIZE_T yysize_old =
927 *yytop == yytop_empty ? 0 : *yytop - *yybottom + 1;
928 YYSIZE_T yysize_new = yysize_old + yyadd;
929 if (*yycapacity < yysize_new)
930 {
931 YYSIZE_T yyalloc = 2 * yysize_new;
932 yytype_int16 *yybottom_new;
933 /* Use YYMAXDEPTH for maximum stack size given that the stack
934 should never need to grow larger than the main state stack
935 needs to grow without LAC. */
936 if (YYMAXDEPTH < yysize_new)
937 {
938 YYDPRINTF ((stderr, "%smax size exceeded%s", yydebug_prefix,
939 yydebug_suffix));
940 return 1;
941 }
942 if (YYMAXDEPTH < yyalloc)
943 yyalloc = YYMAXDEPTH;
944 yybottom_new =
945 (yytype_int16*) YYSTACK_ALLOC (yyalloc * sizeof *yybottom_new);
946 if (!yybottom_new)
947 {
948 YYDPRINTF ((stderr, "%srealloc failed%s", yydebug_prefix,
949 yydebug_suffix));
950 return 1;
951 }
952 if (*yytop != yytop_empty)
953 {
954 YYCOPY (yybottom_new, *yybottom, yysize_old);
955 *yytop = yybottom_new + (yysize_old - 1);
956 }
957 if (*yybottom != yybottom_no_free)
958 YYSTACK_FREE (*yybottom);
959 *yybottom = yybottom_new;
960 *yycapacity = yyalloc;]m4_if(b4_percent_define_get([[parse.lac.memory-trace]]),
961 [full], [[
962 YYDPRINTF ((stderr, "%srealloc to %lu%s", yydebug_prefix,
963 (unsigned long int) yyalloc, yydebug_suffix));]])[
964 }
965 return 0;
966 }
967
968 /* Establish the initial context for the current lookahead if no initial
969 context is currently established.
970
971 We define a context as a snapshot of the parser stacks. We define
972 the initial context for a lookahead as the context in which the
973 parser initially examines that lookahead in order to select a
974 syntactic action. Thus, if the lookahead eventually proves
975 syntactically unacceptable (possibly in a later context reached via a
976 series of reductions), the initial context can be used to determine
977 the exact set of tokens that would be syntactically acceptable in the
978 lookahead's place. Moreover, it is the context after which any
979 further semantic actions would be erroneous because they would be
980 determined by a syntactically unacceptable token.
981
982 YY_LAC_ESTABLISH should be invoked when a reduction is about to be
983 performed in an inconsistent state (which, for the purposes of LAC,
984 includes consistent states that don't know they're consistent because
985 their default reductions have been disabled). Iff there is a
986 lookahead token, it should also be invoked before reporting a syntax
987 error. This latter case is for the sake of the debugging output.
988
989 For parse.lac=full, the implementation of YY_LAC_ESTABLISH is as
990 follows. If no initial context is currently established for the
991 current lookahead, then check if that lookahead can eventually be
992 shifted if syntactic actions continue from the current context.
993 Report a syntax error if it cannot. */
994 #define YY_LAC_ESTABLISH \
995 do { \
996 if (!yy_lac_established) \
997 { \
998 YYDPRINTF ((stderr, \
999 "LAC: initial context established for %s\n", \
1000 yytname[yytoken])); \
1001 yy_lac_established = 1; \
1002 { \
1003 int yy_lac_status = \
1004 yy_lac (yyesa, &yyes, &yyes_capacity, yyssp, yytoken); \
1005 if (yy_lac_status == 2) \
1006 goto yyexhaustedlab; \
1007 if (yy_lac_status == 1) \
1008 goto yyerrlab; \
1009 } \
1010 } \
1011 } while (YYID (0))
1012
1013 /* Discard any previous initial lookahead context because of Event,
1014 which may be a lookahead change or an invalidation of the currently
1015 established initial context for the current lookahead.
1016
1017 The most common example of a lookahead change is a shift. An example
1018 of both cases is syntax error recovery. That is, a syntax error
1019 occurs when the lookahead is syntactically erroneous for the
1020 currently established initial context, so error recovery manipulates
1021 the parser stacks to try to find a new initial context in which the
1022 current lookahead is syntactically acceptable. If it fails to find
1023 such a context, it discards the lookahead. */
1024 #if YYDEBUG
1025 # define YY_LAC_DISCARD(Event) \
1026 do { \
1027 if (yy_lac_established) \
1028 { \
1029 if (yydebug) \
1030 YYFPRINTF (stderr, "LAC: initial context discarded due to " \
1031 Event "\n"); \
1032 yy_lac_established = 0; \
1033 } \
1034 } while (YYID (0))
1035 #else
1036 # define YY_LAC_DISCARD(Event) yy_lac_established = 0
1037 #endif
1038
1039 /* Given the stack whose top is *YYSSP, return 0 iff YYTOKEN can
1040 eventually (after perhaps some reductions) be shifted, return 1 if
1041 not, or return 2 if memory is exhausted. As preconditions and
1042 postconditions: *YYES_CAPACITY is the allocated size of the array to
1043 which *YYES points, and either *YYES = YYESA or *YYES points to an
1044 array allocated with YYSTACK_ALLOC. yy_lac may overwrite the
1045 contents of either array, alter *YYES and *YYES_CAPACITY, and free
1046 any old *YYES other than YYESA. */
1047 static int
1048 yy_lac (yytype_int16 *yyesa, yytype_int16 **yyes,
1049 YYSIZE_T *yyes_capacity, yytype_int16 *yyssp, int yytoken)
1050 {
1051 yytype_int16 *yyes_prev = yyssp;
1052 yytype_int16 *yyesp = yyes_prev;
1053 YYDPRINTF ((stderr, "LAC: checking lookahead %s:", yytname[yytoken]));
1054 if (yytoken == YYUNDEFTOK)
1055 {
1056 YYDPRINTF ((stderr, " Always Err\n"));
1057 return 1;
1058 }
1059 while (1)
1060 {
1061 int yyrule = yypact[*yyesp];
1062 if (yypact_value_is_default (yyrule)
1063 || (yyrule += yytoken) < 0 || YYLAST < yyrule
1064 || yycheck[yyrule] != yytoken)
1065 {
1066 yyrule = yydefact[*yyesp];
1067 if (yyrule == 0)
1068 {
1069 YYDPRINTF ((stderr, " Err\n"));
1070 return 1;
1071 }
1072 }
1073 else
1074 {
1075 yyrule = yytable[yyrule];
1076 if (yytable_value_is_error (yyrule))
1077 {
1078 YYDPRINTF ((stderr, " Err\n"));
1079 return 1;
1080 }
1081 if (0 < yyrule)
1082 {
1083 YYDPRINTF ((stderr, " S%d\n", yyrule));
1084 return 0;
1085 }
1086 yyrule = -yyrule;
1087 }
1088 {
1089 YYSIZE_T yylen = yyr2[yyrule];
1090 YYDPRINTF ((stderr, " R%d", yyrule - 1));
1091 if (yyesp != yyes_prev)
1092 {
1093 YYSIZE_T yysize = yyesp - *yyes + 1;
1094 if (yylen < yysize)
1095 {
1096 yyesp -= yylen;
1097 yylen = 0;
1098 }
1099 else
1100 {
1101 yylen -= yysize;
1102 yyesp = yyes_prev;
1103 }
1104 }
1105 if (yylen)
1106 yyesp = yyes_prev -= yylen;
1107 }
1108 {
1109 int yystate;
1110 {
1111 int yylhs = yyr1[yyrule] - YYNTOKENS;
1112 yystate = yypgoto[yylhs] + *yyesp;
1113 if (yystate < 0 || YYLAST < yystate
1114 || yycheck[yystate] != *yyesp)
1115 yystate = yydefgoto[yylhs];
1116 else
1117 yystate = yytable[yystate];
1118 }
1119 if (yyesp == yyes_prev)
1120 {
1121 yyesp = *yyes;
1122 *yyesp = yystate;
1123 }
1124 else
1125 {
1126 if (yy_lac_stack_realloc (yyes_capacity, 1,
1127 #if YYDEBUG
1128 " (", ")",
1129 #endif
1130 yyes, yyesa, &yyesp, yyes_prev))
1131 {
1132 YYDPRINTF ((stderr, "\n"));
1133 return 2;
1134 }
1135 *++yyesp = yystate;
1136 }
1137 YYDPRINTF ((stderr, " G%d", yystate));
1138 }
1139 }
1140 }]])[
1141
1142
1143 #if YYERROR_VERBOSE
1144
1145 # ifndef yystrlen
1146 # if defined __GLIBC__ && defined _STRING_H
1147 # define yystrlen strlen
1148 # else
1149 /* Return the length of YYSTR. */
1150 ]b4_c_function_def([yystrlen], [static YYSIZE_T],
1151 [[const char *yystr], [yystr]])[
1152 {
1153 YYSIZE_T yylen;
1154 for (yylen = 0; yystr[yylen]; yylen++)
1155 continue;
1156 return yylen;
1157 }
1158 # endif
1159 # endif
1160
1161 # ifndef yystpcpy
1162 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1163 # define yystpcpy stpcpy
1164 # else
1165 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1166 YYDEST. */
1167 ]b4_c_function_def([yystpcpy], [static char *],
1168 [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[
1169 {
1170 char *yyd = yydest;
1171 const char *yys = yysrc;
1172
1173 while ((*yyd++ = *yys++) != '\0')
1174 continue;
1175
1176 return yyd - 1;
1177 }
1178 # endif
1179 # endif
1180
1181 # ifndef yytnamerr
1182 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1183 quotes and backslashes, so that it's suitable for yyerror. The
1184 heuristic is that double-quoting is unnecessary unless the string
1185 contains an apostrophe, a comma, or backslash (other than
1186 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1187 null, do not copy; instead, return the length of what the result
1188 would have been. */
1189 static YYSIZE_T
1190 yytnamerr (char *yyres, const char *yystr)
1191 {
1192 if (*yystr == '"')
1193 {
1194 YYSIZE_T yyn = 0;
1195 char const *yyp = yystr;
1196
1197 for (;;)
1198 switch (*++yyp)
1199 {
1200 case '\'':
1201 case ',':
1202 goto do_not_strip_quotes;
1203
1204 case '\\':
1205 if (*++yyp != '\\')
1206 goto do_not_strip_quotes;
1207 /* Fall through. */
1208 default:
1209 if (yyres)
1210 yyres[yyn] = *yyp;
1211 yyn++;
1212 break;
1213
1214 case '"':
1215 if (yyres)
1216 yyres[yyn] = '\0';
1217 return yyn;
1218 }
1219 do_not_strip_quotes: ;
1220 }
1221
1222 if (! yyres)
1223 return yystrlen (yystr);
1224
1225 return yystpcpy (yyres, yystr) - yyres;
1226 }
1227 # endif
1228
1229 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1230 about the unexpected token YYTOKEN for the state stack whose top is
1231 YYSSP.]b4_lac_if([[ In order to see if a particular token T is a
1232 valid looakhead, invoke yy_lac (YYESA, YYES, YYES_CAPACITY, YYSSP, T).]])[
1233
1234 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1235 not large enough to hold the message. In that case, also set
1236 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1237 required number of bytes is too large to store]b4_lac_if([[ or if
1238 yy_lac returned 2]])[. */
1239 static int
1240 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1241 ]b4_lac_if([[yytype_int16 *yyesa, yytype_int16 **yyes,
1242 YYSIZE_T *yyes_capacity, ]])[yytype_int16 *yyssp, int yytoken)
1243 {
1244 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
1245 YYSIZE_T yysize = yysize0;
1246 YYSIZE_T yysize1;
1247 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1248 /* Internationalized format string. */
1249 const char *yyformat = 0;
1250 /* Arguments of yyformat. */
1251 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1252 /* Number of reported tokens (one for the "unexpected", one per
1253 "expected"). */
1254 int yycount = 0;
1255
1256 /* There are many possibilities here to consider:
1257 - Assume YYFAIL is not used. It's too flawed to consider. See
1258 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1259 for details. YYERROR is fine as it does not invoke this
1260 function.
1261 - If this state is a consistent state with a default action, then
1262 the only way this function was invoked is if the default action
1263 is an error action. In that case, don't check for expected
1264 tokens because there are none.
1265 - The only way there can be no lookahead present (in yychar) is if
1266 this state is a consistent state with a default action. Thus,
1267 detecting the absence of a lookahead is sufficient to determine
1268 that there is no unexpected or expected token to report. In that
1269 case, just report a simple "syntax error".
1270 - Don't assume there isn't a lookahead just because this state is a
1271 consistent state with a default action. There might have been a
1272 previous inconsistent state, consistent state with a non-default
1273 action, or user semantic action that manipulated yychar.]b4_lac_if([[
1274 In the first two cases, it might appear that the current syntax
1275 error should have been detected in the previous state when yy_lac
1276 was invoked. However, at that time, there might have been a
1277 different syntax error that discarded a different initial context
1278 during error recovery, leaving behind the current lookahead.]], [[
1279 - Of course, the expected token list depends on states to have
1280 correct lookahead information, and it depends on the parser not
1281 to perform extra reductions after fetching a lookahead from the
1282 scanner and before detecting a syntax error. Thus, state merging
1283 (from LALR or IELR) and default reductions corrupt the expected
1284 token list. However, the list is correct for canonical LR with
1285 one exception: it will still contain any token that will not be
1286 accepted due to an error action in a later state.]])[
1287 */
1288 if (yytoken != YYEMPTY)
1289 {
1290 int yyn = yypact[*yyssp];]b4_lac_if([[
1291 YYDPRINTF ((stderr, "Constructing syntax error message\n"));]])[
1292 yyarg[yycount++] = yytname[yytoken];
1293 if (!yypact_value_is_default (yyn))
1294 {]b4_lac_if([], [[
1295 /* Start YYX at -YYN if negative to avoid negative indexes in
1296 YYCHECK. In other words, skip the first -YYN actions for
1297 this state because they are default actions. */
1298 int yyxbegin = yyn < 0 ? -yyn : 0;
1299 /* Stay within bounds of both yycheck and yytname. */
1300 int yychecklim = YYLAST - yyn + 1;
1301 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;]])[
1302 int yyx;]b4_lac_if([[
1303
1304 for (yyx = 0; yyx < YYNTOKENS; ++yyx)
1305 if (yyx != YYTERROR && yyx != YYUNDEFTOK)
1306 {
1307 {
1308 int yy_lac_status = yy_lac (yyesa, yyes, yyes_capacity,
1309 yyssp, yyx);
1310 if (yy_lac_status == 2)
1311 return 2;
1312 if (yy_lac_status == 1)
1313 continue;
1314 }]], [[
1315
1316 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1317 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1318 && !yytable_value_is_error (yytable[yyx + yyn]))
1319 {]])[
1320 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1321 {
1322 yycount = 1;
1323 yysize = yysize0;
1324 break;
1325 }
1326 yyarg[yycount++] = yytname[yyx];
1327 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1328 if (! (yysize <= yysize1
1329 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1330 return 2;
1331 yysize = yysize1;
1332 }
1333 }]b4_lac_if([[
1334 # if YYDEBUG
1335 else if (yydebug)
1336 YYFPRINTF (stderr, "No expected tokens.\n");
1337 # endif]])[
1338 }
1339
1340 switch (yycount)
1341 {
1342 # define YYCASE_(N, S) \
1343 case N: \
1344 yyformat = S; \
1345 break
1346 YYCASE_(0, YY_("syntax error"));
1347 YYCASE_(1, YY_("syntax error, unexpected %s"));
1348 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1349 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1350 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1351 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1352 # undef YYCASE_
1353 }
1354
1355 yysize1 = yysize + yystrlen (yyformat);
1356 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1357 return 2;
1358 yysize = yysize1;
1359
1360 if (*yymsg_alloc < yysize)
1361 {
1362 *yymsg_alloc = 2 * yysize;
1363 if (! (yysize <= *yymsg_alloc
1364 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1365 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1366 return 1;
1367 }
1368
1369 /* Avoid sprintf, as that infringes on the user's name space.
1370 Don't have undefined behavior even if the translation
1371 produced a string with the wrong number of "%s"s. */
1372 {
1373 char *yyp = *yymsg;
1374 int yyi = 0;
1375 while ((*yyp = *yyformat) != '\0')
1376 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1377 {
1378 yyp += yytnamerr (yyp, yyarg[yyi++]);
1379 yyformat += 2;
1380 }
1381 else
1382 {
1383 yyp++;
1384 yyformat++;
1385 }
1386 }
1387 return 0;
1388 }
1389 #endif /* YYERROR_VERBOSE */
1390
1391 ]b4_yydestruct_generate([b4_c_function_def])b4_push_if([], [[
1392
1393
1394 /* Prevent warnings from -Wmissing-prototypes. */
1395 #ifdef YYPARSE_PARAM
1396 ]b4_c_function_decl([yyparse], [int],
1397 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
1398 #else /* ! YYPARSE_PARAM */
1399 ]b4_c_function_decl([yyparse], [int], b4_parse_param)[
1400 #endif /* ! YYPARSE_PARAM */]])b4_pure_if([], [
1401
1402 b4_declare_scanner_communication_variables])[]b4_push_if([[
1403
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 (0]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 == 0)
1430 {
1431 yyps_local = yypstate_new ();
1432 if (!yyps_local)
1433 {]b4_pure_if([[
1434 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
1435 if (!yypstate_allocated)
1436 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
1437 return 2;
1438 }
1439 }
1440 else
1441 yyps_local = yyps;
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 == 0)
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 0;]])[
1458 yyps = (yypstate *) malloc (sizeof *yyps);
1459 if (!yyps)
1460 return 0;
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-2011])
2072
2073 b4_percent_code_get([[requires]])[]dnl
2074
2075 b4_token_enums_defines(b4_tokens)
2076
2077 [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
2078 ]m4_ifdef([b4_stype],
2079 [[typedef union ]b4_union_name[
2080 {
2081 ]b4_user_stype[
2082 } YYSTYPE;
2083 # define YYSTYPE_IS_TRIVIAL 1]],
2084 [m4_if(b4_tag_seen_flag, 0,
2085 [[typedef int YYSTYPE;
2086 # define YYSTYPE_IS_TRIVIAL 1]])])[
2087 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
2088 # define YYSTYPE_IS_DECLARED 1
2089 #endif
2090
2091 ]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;]])
2092
2093 b4_locations_if(
2094 [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
2095 typedef struct YYLTYPE
2096 {
2097 int first_line;
2098 int first_column;
2099 int last_line;
2100 int last_column;
2101 } YYLTYPE;
2102 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
2103 # define YYLTYPE_IS_DECLARED 1
2104 # define YYLTYPE_IS_TRIVIAL 1
2105 #endif
2106
2107 ]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]])
2108 )dnl b4_locations_if
2109 b4_push_if([[
2110 #ifndef YYPUSH_DECLS
2111 # define YYPUSH_DECLS
2112 struct ]b4_prefix[pstate;
2113 typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
2114 enum { YYPUSH_MORE = 4 };
2115 ]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
2116 ])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
2117 [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([,
2118 [[[int yypushed_char]], [[yypushed_char]]],
2119 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
2120 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
2121 b4_parse_param]))
2122 b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
2123 [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
2124 b4_parse_param]))])
2125 b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
2126 [[[void]], []])
2127 b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
2128 [[b4_prefix[pstate *yyps]], [[yyps]]])[
2129 #endif
2130 ]])
2131 b4_percent_code_get([[provides]])[]dnl
2132 ])dnl b4_defines_if
2133 m4_divert_pop(0)
bison