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


3d5350092e7d98ebc56660b256ab14be00118128
[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) \
718 { \
719 yychar = (Token); \
720 yylval = (Value); \
721 YYPOPSTACK (yylen); \
722 yystate = *yyssp; \]b4_lac_if([[
723 YY_LAC_DISCARD ("YYBACKUP"); \]])[
724 goto yybackup; \
725 } \
726 else \
727 { \
728 yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
729 YYERROR; \
730 } \
731 while (YYID (0))
732
733
734 #define YYTERROR 1
735 #define YYERRCODE 256
736
737
738 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
739 If N is 0, then set CURRENT to the empty location which ends
740 the previous symbol: RHS[0] (always defined). */
741
742 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
743 #ifndef YYLLOC_DEFAULT
744 # define YYLLOC_DEFAULT(Current, Rhs, N) \
745 do \
746 if (YYID (N)) \
747 { \
748 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
749 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
750 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
751 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
752 } \
753 else \
754 { \
755 (Current).first_line = (Current).last_line = \
756 YYRHSLOC (Rhs, 0).last_line; \
757 (Current).first_column = (Current).last_column = \
758 YYRHSLOC (Rhs, 0).last_column; \
759 } \
760 while (YYID (0))
761 #endif]b4_locations_if([[
762
763
764 /* YY_LOCATION_PRINT -- Print the location on the stream.
765 This macro was not mandated originally: define only if we know
766 we won't break user code: when these are the locations we know. */
767
768 #ifndef YY_LOCATION_PRINT
769 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
770 # define YY_LOCATION_PRINT(File, Loc) \
771 fprintf (File, "%d.%d-%d.%d", \
772 (Loc).first_line, (Loc).first_column, \
773 (Loc).last_line, (Loc).last_column)
774 # else
775 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
776 # endif
777 #endif]], [[
778
779
780 /* This macro is provided for backward compatibility. */
781
782 #ifndef YY_LOCATION_PRINT
783 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
784 #endif]])[
785
786
787 /* YYLEX -- calling `yylex' with the right arguments. */
788
789 #ifdef YYLEX_PARAM
790 # define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)
791 #else
792 # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
793 #endif
794
795 /* Enable debugging if requested. */
796 #if YYDEBUG
797
798 # ifndef YYFPRINTF
799 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
800 # define YYFPRINTF fprintf
801 # endif
802
803 # define YYDPRINTF(Args) \
804 do { \
805 if (yydebug) \
806 YYFPRINTF Args; \
807 } while (YYID (0))
808
809 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
810 do { \
811 if (yydebug) \
812 { \
813 YYFPRINTF (stderr, "%s ", Title); \
814 yy_symbol_print (stderr, \
815 Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
816 YYFPRINTF (stderr, "\n"); \
817 } \
818 } while (YYID (0))
819
820 ]b4_yy_symbol_print_generate([b4_c_function_def])[
821
822 /*------------------------------------------------------------------.
823 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
824 | TOP (included). |
825 `------------------------------------------------------------------*/
826
827 ]b4_c_function_def([yy_stack_print], [static void],
828 [[yytype_int16 *yybottom], [yybottom]],
829 [[yytype_int16 *yytop], [yytop]])[
830 {
831 YYFPRINTF (stderr, "Stack now");
832 for (; yybottom <= yytop; yybottom++)
833 {
834 int yybot = *yybottom;
835 YYFPRINTF (stderr, " %d", yybot);
836 }
837 YYFPRINTF (stderr, "\n");
838 }
839
840 # define YY_STACK_PRINT(Bottom, Top) \
841 do { \
842 if (yydebug) \
843 yy_stack_print ((Bottom), (Top)); \
844 } while (YYID (0))
845
846
847 /*------------------------------------------------.
848 | Report that the YYRULE is going to be reduced. |
849 `------------------------------------------------*/
850
851 ]b4_c_function_def([yy_reduce_print], [static void],
852 [[YYSTYPE *yyvsp], [yyvsp]],
853 b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
854 ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
855 b4_parse_param]))[
856 {
857 int yynrhs = yyr2[yyrule];
858 int yyi;
859 unsigned long int yylno = yyrline[yyrule];
860 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
861 yyrule - 1, yylno);
862 /* The symbols being reduced. */
863 for (yyi = 0; yyi < yynrhs; yyi++)
864 {
865 YYFPRINTF (stderr, " $%d = ", yyi + 1);
866 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
867 &]b4_rhs_value(yynrhs, yyi + 1)[
868 ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
869 b4_user_args[);
870 YYFPRINTF (stderr, "\n");
871 }
872 }
873
874 # define YY_REDUCE_PRINT(Rule) \
875 do { \
876 if (yydebug) \
877 yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
878 } while (YYID (0))
879
880 /* Nonzero means print parse trace. It is left uninitialized so that
881 multiple parsers can coexist. */
882 int yydebug;
883 #else /* !YYDEBUG */
884 # define YYDPRINTF(Args)
885 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
886 # define YY_STACK_PRINT(Bottom, Top)
887 # define YY_REDUCE_PRINT(Rule)
888 #endif /* !YYDEBUG */
889
890
891 /* YYINITDEPTH -- initial size of the parser's stacks. */
892 #ifndef YYINITDEPTH
893 # define YYINITDEPTH ]b4_stack_depth_init[
894 #endif
895
896 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
897 if the built-in stack extension method is used).
898
899 Do not make this value too large; the results are undefined if
900 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
901 evaluated with infinite-precision integer arithmetic. */
902
903 #ifndef YYMAXDEPTH
904 # define YYMAXDEPTH ]b4_stack_depth_max[
905 #endif]b4_lac_if([[
906
907 /* Given a state stack such that *YYBOTTOM is its bottom, such that
908 *YYTOP is either its top or is YYTOP_EMPTY to indicate an empty
909 stack, and such that *YYCAPACITY is the maximum number of elements it
910 can hold without a reallocation, make sure there is enough room to
911 store YYADD more elements. If not, allocate a new stack using
912 YYSTACK_ALLOC, copy the existing elements, and adjust *YYBOTTOM,
913 *YYTOP, and *YYCAPACITY to reflect the new capacity and memory
914 location. If *YYBOTTOM != YYBOTTOM_NO_FREE, then free the old stack
915 using YYSTACK_FREE. Return 0 if successful or if no reallocation is
916 required. Return 1 if memory is exhausted. */
917 static int
918 yy_lac_stack_realloc (YYSIZE_T *yycapacity, YYSIZE_T yyadd,
919 #if YYDEBUG
920 char const *yydebug_prefix,
921 char const *yydebug_suffix,
922 #endif
923 yytype_int16 **yybottom,
924 yytype_int16 *yybottom_no_free,
925 yytype_int16 **yytop, yytype_int16 *yytop_empty)
926 {
927 YYSIZE_T yysize_old =
928 *yytop == yytop_empty ? 0 : *yytop - *yybottom + 1;
929 YYSIZE_T yysize_new = yysize_old + yyadd;
930 if (*yycapacity < yysize_new)
931 {
932 YYSIZE_T yyalloc = 2 * yysize_new;
933 yytype_int16 *yybottom_new;
934 /* Use YYMAXDEPTH for maximum stack size given that the stack
935 should never need to grow larger than the main state stack
936 needs to grow without LAC. */
937 if (YYMAXDEPTH < yysize_new)
938 {
939 YYDPRINTF ((stderr, "%smax size exceeded%s", yydebug_prefix,
940 yydebug_suffix));
941 return 1;
942 }
943 if (YYMAXDEPTH < yyalloc)
944 yyalloc = YYMAXDEPTH;
945 yybottom_new =
946 (yytype_int16*) YYSTACK_ALLOC (yyalloc * sizeof *yybottom_new);
947 if (!yybottom_new)
948 {
949 YYDPRINTF ((stderr, "%srealloc failed%s", yydebug_prefix,
950 yydebug_suffix));
951 return 1;
952 }
953 if (*yytop != yytop_empty)
954 {
955 YYCOPY (yybottom_new, *yybottom, yysize_old);
956 *yytop = yybottom_new + (yysize_old - 1);
957 }
958 if (*yybottom != yybottom_no_free)
959 YYSTACK_FREE (*yybottom);
960 *yybottom = yybottom_new;
961 *yycapacity = yyalloc;]m4_if(b4_percent_define_get([[parse.lac.memory-trace]]),
962 [full], [[
963 YYDPRINTF ((stderr, "%srealloc to %lu%s", yydebug_prefix,
964 (unsigned long int) yyalloc, yydebug_suffix));]])[
965 }
966 return 0;
967 }
968
969 /* Establish the initial context for the current lookahead if no initial
970 context is currently established.
971
972 We define a context as a snapshot of the parser stacks. We define
973 the initial context for a lookahead as the context in which the
974 parser initially examines that lookahead in order to select a
975 syntactic action. Thus, if the lookahead eventually proves
976 syntactically unacceptable (possibly in a later context reached via a
977 series of reductions), the initial context can be used to determine
978 the exact set of tokens that would be syntactically acceptable in the
979 lookahead's place. Moreover, it is the context after which any
980 further semantic actions would be erroneous because they would be
981 determined by a syntactically unacceptable token.
982
983 YY_LAC_ESTABLISH should be invoked when a reduction is about to be
984 performed in an inconsistent state (which, for the purposes of LAC,
985 includes consistent states that don't know they're consistent because
986 their default reductions have been disabled). Iff there is a
987 lookahead token, it should also be invoked before reporting a syntax
988 error. This latter case is for the sake of the debugging output.
989
990 For parse.lac=full, the implementation of YY_LAC_ESTABLISH is as
991 follows. If no initial context is currently established for the
992 current lookahead, then check if that lookahead can eventually be
993 shifted if syntactic actions continue from the current context.
994 Report a syntax error if it cannot. */
995 #define YY_LAC_ESTABLISH \
996 do { \
997 if (!yy_lac_established) \
998 { \
999 YYDPRINTF ((stderr, \
1000 "LAC: initial context established for %s\n", \
1001 yytname[yytoken])); \
1002 yy_lac_established = 1; \
1003 { \
1004 int yy_lac_status = \
1005 yy_lac (yyesa, &yyes, &yyes_capacity, yyssp, yytoken); \
1006 if (yy_lac_status == 2) \
1007 goto yyexhaustedlab; \
1008 if (yy_lac_status == 1) \
1009 goto yyerrlab; \
1010 } \
1011 } \
1012 } while (YYID (0))
1013
1014 /* Discard any previous initial lookahead context because of Event,
1015 which may be a lookahead change or an invalidation of the currently
1016 established initial context for the current lookahead.
1017
1018 The most common example of a lookahead change is a shift. An example
1019 of both cases is syntax error recovery. That is, a syntax error
1020 occurs when the lookahead is syntactically erroneous for the
1021 currently established initial context, so error recovery manipulates
1022 the parser stacks to try to find a new initial context in which the
1023 current lookahead is syntactically acceptable. If it fails to find
1024 such a context, it discards the lookahead. */
1025 #if YYDEBUG
1026 # define YY_LAC_DISCARD(Event) \
1027 do { \
1028 if (yy_lac_established) \
1029 { \
1030 if (yydebug) \
1031 YYFPRINTF (stderr, "LAC: initial context discarded due to " \
1032 Event "\n"); \
1033 yy_lac_established = 0; \
1034 } \
1035 } while (YYID (0))
1036 #else
1037 # define YY_LAC_DISCARD(Event) yy_lac_established = 0
1038 #endif
1039
1040 /* Given the stack whose top is *YYSSP, return 0 iff YYTOKEN can
1041 eventually (after perhaps some reductions) be shifted, return 1 if
1042 not, or return 2 if memory is exhausted. As preconditions and
1043 postconditions: *YYES_CAPACITY is the allocated size of the array to
1044 which *YYES points, and either *YYES = YYESA or *YYES points to an
1045 array allocated with YYSTACK_ALLOC. yy_lac may overwrite the
1046 contents of either array, alter *YYES and *YYES_CAPACITY, and free
1047 any old *YYES other than YYESA. */
1048 static int
1049 yy_lac (yytype_int16 *yyesa, yytype_int16 **yyes,
1050 YYSIZE_T *yyes_capacity, yytype_int16 *yyssp, int yytoken)
1051 {
1052 yytype_int16 *yyes_prev = yyssp;
1053 yytype_int16 *yyesp = yyes_prev;
1054 YYDPRINTF ((stderr, "LAC: checking lookahead %s:", yytname[yytoken]));
1055 if (yytoken == YYUNDEFTOK)
1056 {
1057 YYDPRINTF ((stderr, " Always Err\n"));
1058 return 1;
1059 }
1060 while (1)
1061 {
1062 int yyrule = yypact[*yyesp];
1063 if (yypact_value_is_default (yyrule)
1064 || (yyrule += yytoken) < 0 || YYLAST < yyrule
1065 || yycheck[yyrule] != yytoken)
1066 {
1067 yyrule = yydefact[*yyesp];
1068 if (yyrule == 0)
1069 {
1070 YYDPRINTF ((stderr, " Err\n"));
1071 return 1;
1072 }
1073 }
1074 else
1075 {
1076 yyrule = yytable[yyrule];
1077 if (yytable_value_is_error (yyrule))
1078 {
1079 YYDPRINTF ((stderr, " Err\n"));
1080 return 1;
1081 }
1082 if (0 < yyrule)
1083 {
1084 YYDPRINTF ((stderr, " S%d\n", yyrule));
1085 return 0;
1086 }
1087 yyrule = -yyrule;
1088 }
1089 {
1090 YYSIZE_T yylen = yyr2[yyrule];
1091 YYDPRINTF ((stderr, " R%d", yyrule - 1));
1092 if (yyesp != yyes_prev)
1093 {
1094 YYSIZE_T yysize = yyesp - *yyes + 1;
1095 if (yylen < yysize)
1096 {
1097 yyesp -= yylen;
1098 yylen = 0;
1099 }
1100 else
1101 {
1102 yylen -= yysize;
1103 yyesp = yyes_prev;
1104 }
1105 }
1106 if (yylen)
1107 yyesp = yyes_prev -= yylen;
1108 }
1109 {
1110 int yystate;
1111 {
1112 int yylhs = yyr1[yyrule] - YYNTOKENS;
1113 yystate = yypgoto[yylhs] + *yyesp;
1114 if (yystate < 0 || YYLAST < yystate
1115 || yycheck[yystate] != *yyesp)
1116 yystate = yydefgoto[yylhs];
1117 else
1118 yystate = yytable[yystate];
1119 }
1120 if (yyesp == yyes_prev)
1121 {
1122 yyesp = *yyes;
1123 *yyesp = yystate;
1124 }
1125 else
1126 {
1127 if (yy_lac_stack_realloc (yyes_capacity, 1,
1128 #if YYDEBUG
1129 " (", ")",
1130 #endif
1131 yyes, yyesa, &yyesp, yyes_prev))
1132 {
1133 YYDPRINTF ((stderr, "\n"));
1134 return 2;
1135 }
1136 *++yyesp = yystate;
1137 }
1138 YYDPRINTF ((stderr, " G%d", yystate));
1139 }
1140 }
1141 }]])[
1142
1143
1144 #if YYERROR_VERBOSE
1145
1146 # ifndef yystrlen
1147 # if defined __GLIBC__ && defined _STRING_H
1148 # define yystrlen strlen
1149 # else
1150 /* Return the length of YYSTR. */
1151 ]b4_c_function_def([yystrlen], [static YYSIZE_T],
1152 [[const char *yystr], [yystr]])[
1153 {
1154 YYSIZE_T yylen;
1155 for (yylen = 0; yystr[yylen]; yylen++)
1156 continue;
1157 return yylen;
1158 }
1159 # endif
1160 # endif
1161
1162 # ifndef yystpcpy
1163 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1164 # define yystpcpy stpcpy
1165 # else
1166 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1167 YYDEST. */
1168 ]b4_c_function_def([yystpcpy], [static char *],
1169 [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[
1170 {
1171 char *yyd = yydest;
1172 const char *yys = yysrc;
1173
1174 while ((*yyd++ = *yys++) != '\0')
1175 continue;
1176
1177 return yyd - 1;
1178 }
1179 # endif
1180 # endif
1181
1182 # ifndef yytnamerr
1183 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1184 quotes and backslashes, so that it's suitable for yyerror. The
1185 heuristic is that double-quoting is unnecessary unless the string
1186 contains an apostrophe, a comma, or backslash (other than
1187 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1188 null, do not copy; instead, return the length of what the result
1189 would have been. */
1190 static YYSIZE_T
1191 yytnamerr (char *yyres, const char *yystr)
1192 {
1193 if (*yystr == '"')
1194 {
1195 YYSIZE_T yyn = 0;
1196 char const *yyp = yystr;
1197
1198 for (;;)
1199 switch (*++yyp)
1200 {
1201 case '\'':
1202 case ',':
1203 goto do_not_strip_quotes;
1204
1205 case '\\':
1206 if (*++yyp != '\\')
1207 goto do_not_strip_quotes;
1208 /* Fall through. */
1209 default:
1210 if (yyres)
1211 yyres[yyn] = *yyp;
1212 yyn++;
1213 break;
1214
1215 case '"':
1216 if (yyres)
1217 yyres[yyn] = '\0';
1218 return yyn;
1219 }
1220 do_not_strip_quotes: ;
1221 }
1222
1223 if (! yyres)
1224 return yystrlen (yystr);
1225
1226 return yystpcpy (yyres, yystr) - yyres;
1227 }
1228 # endif
1229
1230 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1231 about the unexpected token YYTOKEN for the state stack whose top is
1232 YYSSP.]b4_lac_if([[ In order to see if a particular token T is a
1233 valid looakhead, invoke yy_lac (YYESA, YYES, YYES_CAPACITY, YYSSP, T).]])[
1234
1235 Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1236 not large enough to hold the message. In that case, also set
1237 *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1238 required number of bytes is too large to store]b4_lac_if([[ or if
1239 yy_lac returned 2]])[. */
1240 static int
1241 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1242 ]b4_lac_if([[yytype_int16 *yyesa, yytype_int16 **yyes,
1243 YYSIZE_T *yyes_capacity, ]])[yytype_int16 *yyssp, int yytoken)
1244 {
1245 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
1246 YYSIZE_T yysize = yysize0;
1247 YYSIZE_T yysize1;
1248 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1249 /* Internationalized format string. */
1250 const char *yyformat = 0;
1251 /* Arguments of yyformat. */
1252 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1253 /* Number of reported tokens (one for the "unexpected", one per
1254 "expected"). */
1255 int yycount = 0;
1256
1257 /* There are many possibilities here to consider:
1258 - Assume YYFAIL is not used. It's too flawed to consider. See
1259 <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
1260 for details. YYERROR is fine as it does not invoke this
1261 function.
1262 - If this state is a consistent state with a default action, then
1263 the only way this function was invoked is if the default action
1264 is an error action. In that case, don't check for expected
1265 tokens because there are none.
1266 - The only way there can be no lookahead present (in yychar) is if
1267 this state is a consistent state with a default action. Thus,
1268 detecting the absence of a lookahead is sufficient to determine
1269 that there is no unexpected or expected token to report. In that
1270 case, just report a simple "syntax error".
1271 - Don't assume there isn't a lookahead just because this state is a
1272 consistent state with a default action. There might have been a
1273 previous inconsistent state, consistent state with a non-default
1274 action, or user semantic action that manipulated yychar.]b4_lac_if([[
1275 In the first two cases, it might appear that the current syntax
1276 error should have been detected in the previous state when yy_lac
1277 was invoked. However, at that time, there might have been a
1278 different syntax error that discarded a different initial context
1279 during error recovery, leaving behind the current lookahead.]], [[
1280 - Of course, the expected token list depends on states to have
1281 correct lookahead information, and it depends on the parser not
1282 to perform extra reductions after fetching a lookahead from the
1283 scanner and before detecting a syntax error. Thus, state merging
1284 (from LALR or IELR) and default reductions corrupt the expected
1285 token list. However, the list is correct for canonical LR with
1286 one exception: it will still contain any token that will not be
1287 accepted due to an error action in a later state.]])[
1288 */
1289 if (yytoken != YYEMPTY)
1290 {
1291 int yyn = yypact[*yyssp];]b4_lac_if([[
1292 YYDPRINTF ((stderr, "Constructing syntax error message\n"));]])[
1293 yyarg[yycount++] = yytname[yytoken];
1294 if (!yypact_value_is_default (yyn))
1295 {]b4_lac_if([], [[
1296 /* Start YYX at -YYN if negative to avoid negative indexes in
1297 YYCHECK. In other words, skip the first -YYN actions for
1298 this state because they are default actions. */
1299 int yyxbegin = yyn < 0 ? -yyn : 0;
1300 /* Stay within bounds of both yycheck and yytname. */
1301 int yychecklim = YYLAST - yyn + 1;
1302 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;]])[
1303 int yyx;]b4_lac_if([[
1304
1305 for (yyx = 0; yyx < YYNTOKENS; ++yyx)
1306 if (yyx != YYTERROR && yyx != YYUNDEFTOK)
1307 {
1308 {
1309 int yy_lac_status = yy_lac (yyesa, yyes, yyes_capacity,
1310 yyssp, yyx);
1311 if (yy_lac_status == 2)
1312 return 2;
1313 if (yy_lac_status == 1)
1314 continue;
1315 }]], [[
1316
1317 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1318 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1319 && !yytable_value_is_error (yytable[yyx + yyn]))
1320 {]])[
1321 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1322 {
1323 yycount = 1;
1324 yysize = yysize0;
1325 break;
1326 }
1327 yyarg[yycount++] = yytname[yyx];
1328 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
1329 if (! (yysize <= yysize1
1330 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1331 return 2;
1332 yysize = yysize1;
1333 }
1334 }]b4_lac_if([[
1335 # if YYDEBUG
1336 else if (yydebug)
1337 YYFPRINTF (stderr, "No expected tokens.\n");
1338 # endif]])[
1339 }
1340
1341 switch (yycount)
1342 {
1343 # define YYCASE_(N, S) \
1344 case N: \
1345 yyformat = S; \
1346 break
1347 YYCASE_(0, YY_("syntax error"));
1348 YYCASE_(1, YY_("syntax error, unexpected %s"));
1349 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1350 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1351 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1352 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1353 # undef YYCASE_
1354 }
1355
1356 yysize1 = yysize + yystrlen (yyformat);
1357 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1358 return 2;
1359 yysize = yysize1;
1360
1361 if (*yymsg_alloc < yysize)
1362 {
1363 *yymsg_alloc = 2 * yysize;
1364 if (! (yysize <= *yymsg_alloc
1365 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1366 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1367 return 1;
1368 }
1369
1370 /* Avoid sprintf, as that infringes on the user's name space.
1371 Don't have undefined behavior even if the translation
1372 produced a string with the wrong number of "%s"s. */
1373 {
1374 char *yyp = *yymsg;
1375 int yyi = 0;
1376 while ((*yyp = *yyformat) != '\0')
1377 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1378 {
1379 yyp += yytnamerr (yyp, yyarg[yyi++]);
1380 yyformat += 2;
1381 }
1382 else
1383 {
1384 yyp++;
1385 yyformat++;
1386 }
1387 }
1388 return 0;
1389 }
1390 #endif /* YYERROR_VERBOSE */
1391
1392 ]b4_yydestruct_generate([b4_c_function_def])b4_push_if([], [[
1393
1394
1395 /* Prevent warnings from -Wmissing-prototypes. */
1396 #ifdef YYPARSE_PARAM
1397 ]b4_c_function_decl([yyparse], [int],
1398 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
1399 #else /* ! YYPARSE_PARAM */
1400 ]b4_c_function_decl([yyparse], [int], b4_parse_param)[
1401 #endif /* ! YYPARSE_PARAM */]])b4_pure_if([], [
1402
1403 b4_declare_scanner_communication_variables])[]b4_push_if([[
1404
1405
1406 struct yypstate
1407 {]b4_declare_parser_state_variables[
1408 /* Used to determine if this is the first time this instance has
1409 been used. */
1410 int yynew;
1411 };]b4_pure_if([], [[
1412
1413 static char yypstate_allocated = 0;]])b4_pull_if([
1414
1415 b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
1416 {
1417 return yypull_parse (0]m4_ifset([b4_parse_param],
1418 [[, ]b4_c_args(b4_parse_param)])[);
1419 }
1420
1421 ]b4_c_function_def([[yypull_parse]], [[int]],
1422 [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1423 b4_parse_param]))[
1424 {
1425 int yystatus;
1426 yypstate *yyps_local;]b4_pure_if([[
1427 int yychar;
1428 YYSTYPE yylval;]b4_locations_if([[
1429 YYLTYPE yylloc;]])])[
1430 if (yyps == 0)
1431 {
1432 yyps_local = yypstate_new ();
1433 if (!yyps_local)
1434 {]b4_pure_if([[
1435 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
1436 if (!yypstate_allocated)
1437 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
1438 return 2;
1439 }
1440 }
1441 else
1442 yyps_local = yyps;
1443 do {
1444 yychar = YYLEX;
1445 yystatus =
1446 yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
1447 } while (yystatus == YYPUSH_MORE);
1448 if (yyps == 0)
1449 yypstate_delete (yyps_local);
1450 return yystatus;
1451 }]])[
1452
1453 /* Initialize the parser data structure. */
1454 ]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
1455 {
1456 yypstate *yyps;]b4_pure_if([], [[
1457 if (yypstate_allocated)
1458 return 0;]])[
1459 yyps = (yypstate *) malloc (sizeof *yyps);
1460 if (!yyps)
1461 return 0;
1462 yyps->yynew = 1;]b4_pure_if([], [[
1463 yypstate_allocated = 1;]])[
1464 return yyps;
1465 }
1466
1467 ]b4_c_function_def([[yypstate_delete]], [[void]],
1468 [[[yypstate *yyps]], [[yyps]]])[
1469 {
1470 #ifndef yyoverflow
1471 /* If the stack was reallocated but the parse did not complete, then the
1472 stack still needs to be freed. */
1473 if (!yyps->yynew && yyps->yyss != yyps->yyssa)
1474 YYSTACK_FREE (yyps->yyss);
1475 #endif]b4_lac_if([[
1476 if (!yyps->yynew && yyps->yyes != yyps->yyesa)
1477 YYSTACK_FREE (yyps->yyes);]])[
1478 free (yyps);]b4_pure_if([], [[
1479 yypstate_allocated = 0;]])[
1480 }
1481 ]b4_pure_if([[
1482 #define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs]])[
1483 #define yystate yyps->yystate
1484 #define yyerrstatus yyps->yyerrstatus
1485 #define yyssa yyps->yyssa
1486 #define yyss yyps->yyss
1487 #define yyssp yyps->yyssp
1488 #define yyvsa yyps->yyvsa
1489 #define yyvs yyps->yyvs
1490 #define yyvsp yyps->yyvsp]b4_locations_if([[
1491 #define yylsa yyps->yylsa
1492 #define yyls yyps->yyls
1493 #define yylsp yyps->yylsp
1494 #define yyerror_range yyps->yyerror_range]])[
1495 #define yystacksize yyps->yystacksize]b4_lac_if([[
1496 #define yyesa yyps->yyesa
1497 #define yyes yyps->yyes
1498 #define yyes_capacity yyps->yyes_capacity]])[
1499
1500
1501 /*---------------.
1502 | yypush_parse. |
1503 `---------------*/
1504
1505 ]b4_c_function_def([[yypush_parse]], [[int]],
1506 [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
1507 [[[int yypushed_char]], [[yypushed_char]]],
1508 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1509 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1510 b4_parse_param]))], [[
1511
1512
1513 /*----------.
1514 | yyparse. |
1515 `----------*/
1516
1517 #ifdef YYPARSE_PARAM
1518 ]b4_c_function_def([yyparse], [int],
1519 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
1520 #else /* ! YYPARSE_PARAM */
1521 ]b4_c_function_def([yyparse], [int], b4_parse_param)[
1522 #endif]])[
1523 {]b4_pure_if([b4_declare_scanner_communication_variables
1524 ])b4_push_if([b4_pure_if([], [[
1525 int yypushed_char = yychar;
1526 YYSTYPE yypushed_val = yylval;]b4_locations_if([[
1527 YYLTYPE yypushed_loc = yylloc;]])
1528 ])],
1529 [b4_declare_parser_state_variables
1530 ])b4_lac_if([[
1531 int yy_lac_established = 0;]])[
1532 int yyn;
1533 int yyresult;
1534 /* Lookahead token as an internal (translated) token number. */
1535 int yytoken;
1536 /* The variables used to return semantic value and location from the
1537 action routines. */
1538 YYSTYPE yyval;]b4_locations_if([[
1539 YYLTYPE yyloc;]])[
1540
1541 #if YYERROR_VERBOSE
1542 /* Buffer for error messages, and its allocated size. */
1543 char yymsgbuf[128];
1544 char *yymsg = yymsgbuf;
1545 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1546 #endif
1547
1548 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
1549
1550 /* The number of symbols on the RHS of the reduced rule.
1551 Keep to zero when no symbol should be popped. */
1552 int yylen = 0;]b4_push_if([[
1553
1554 if (!yyps->yynew)
1555 {
1556 yyn = yypact[yystate];
1557 goto yyread_pushed_token;
1558 }]])[
1559
1560 yytoken = 0;
1561 yyss = yyssa;
1562 yyvs = yyvsa;]b4_locations_if([[
1563 yyls = yylsa;]])[
1564 yystacksize = YYINITDEPTH;]b4_lac_if([[
1565
1566 yyes = yyesa;
1567 yyes_capacity = sizeof yyesa / sizeof *yyes;
1568 if (YYMAXDEPTH < yyes_capacity)
1569 yyes_capacity = YYMAXDEPTH;]])[
1570
1571 YYDPRINTF ((stderr, "Starting parse\n"));
1572
1573 yystate = 0;
1574 yyerrstatus = 0;
1575 yynerrs = 0;
1576 yychar = YYEMPTY; /* Cause a token to be read. */
1577
1578 /* Initialize stack pointers.
1579 Waste one element of value and location stack
1580 so that they stay on the same level as the state stack.
1581 The wasted elements are never initialized. */
1582 yyssp = yyss;
1583 yyvsp = yyvs;]b4_locations_if([[
1584 yylsp = yyls;
1585
1586 #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1587 /* Initialize the default location before parsing starts. */
1588 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
1589 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
1590 #endif]])
1591 m4_ifdef([b4_initial_action],[
1592 m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl
1593 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
1594 /* User initialization code. */
1595 b4_user_initial_action
1596 m4_popdef([b4_dollar_dollar])dnl
1597 m4_popdef([b4_at_dollar])])dnl
1598 m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval;
1599 ]])dnl
1600 m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc;
1601 ]])[
1602 goto yysetstate;
1603
1604 /*------------------------------------------------------------.
1605 | yynewstate -- Push a new state, which is found in yystate. |
1606 `------------------------------------------------------------*/
1607 yynewstate:
1608 /* In all cases, when you get here, the value and location stacks
1609 have just been pushed. So pushing a state here evens the stacks. */
1610 yyssp++;
1611
1612 yysetstate:
1613 *yyssp = yystate;
1614
1615 if (yyss + yystacksize - 1 <= yyssp)
1616 {
1617 /* Get the current used size of the three stacks, in elements. */
1618 YYSIZE_T yysize = yyssp - yyss + 1;
1619
1620 #ifdef yyoverflow
1621 {
1622 /* Give user a chance to reallocate the stack. Use copies of
1623 these so that the &'s don't force the real ones into
1624 memory. */
1625 YYSTYPE *yyvs1 = yyvs;
1626 yytype_int16 *yyss1 = yyss;]b4_locations_if([
1627 YYLTYPE *yyls1 = yyls;])[
1628
1629 /* Each stack pointer address is followed by the size of the
1630 data in use in that stack, in bytes. This used to be a
1631 conditional around just the two extra args, but that might
1632 be undefined if yyoverflow is a macro. */
1633 yyoverflow (YY_("memory exhausted"),
1634 &yyss1, yysize * sizeof (*yyssp),
1635 &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
1636 &yyls1, yysize * sizeof (*yylsp),])[
1637 &yystacksize);
1638 ]b4_locations_if([
1639 yyls = yyls1;])[
1640 yyss = yyss1;
1641 yyvs = yyvs1;
1642 }
1643 #else /* no yyoverflow */
1644 # ifndef YYSTACK_RELOCATE
1645 goto yyexhaustedlab;
1646 # else
1647 /* Extend the stack our own way. */
1648 if (YYMAXDEPTH <= yystacksize)
1649 goto yyexhaustedlab;
1650 yystacksize *= 2;
1651 if (YYMAXDEPTH < yystacksize)
1652 yystacksize = YYMAXDEPTH;
1653
1654 {
1655 yytype_int16 *yyss1 = yyss;
1656 union yyalloc *yyptr =
1657 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1658 if (! yyptr)
1659 goto yyexhaustedlab;
1660 YYSTACK_RELOCATE (yyss_alloc, yyss);
1661 YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
1662 YYSTACK_RELOCATE (yyls_alloc, yyls);])[
1663 # undef YYSTACK_RELOCATE
1664 if (yyss1 != yyssa)
1665 YYSTACK_FREE (yyss1);
1666 }
1667 # endif
1668 #endif /* no yyoverflow */
1669
1670 yyssp = yyss + yysize - 1;
1671 yyvsp = yyvs + yysize - 1;]b4_locations_if([
1672 yylsp = yyls + yysize - 1;])[
1673
1674 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1675 (unsigned long int) yystacksize));
1676
1677 if (yyss + yystacksize - 1 <= yyssp)
1678 YYABORT;
1679 }
1680
1681 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1682
1683 if (yystate == YYFINAL)
1684 YYACCEPT;
1685
1686 goto yybackup;
1687
1688 /*-----------.
1689 | yybackup. |
1690 `-----------*/
1691 yybackup:
1692
1693 /* Do appropriate processing given the current state. Read a
1694 lookahead token if we need one and don't already have one. */
1695
1696 /* First try to decide what to do without reference to lookahead token. */
1697 yyn = yypact[yystate];
1698 if (yypact_value_is_default (yyn))
1699 goto yydefault;
1700
1701 /* Not known => get a lookahead token if don't already have one. */
1702
1703 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1704 if (yychar == YYEMPTY)
1705 {]b4_push_if([[
1706 if (!yyps->yynew)
1707 {]b4_use_push_for_pull_if([], [[
1708 YYDPRINTF ((stderr, "Return for a new token:\n"));]])[
1709 yyresult = YYPUSH_MORE;
1710 goto yypushreturn;
1711 }
1712 yyps->yynew = 0;]b4_pure_if([], [[
1713 /* Restoring the pushed token is only necessary for the first
1714 yypush_parse invocation since subsequent invocations don't overwrite
1715 it before jumping to yyread_pushed_token. */
1716 yychar = yypushed_char;
1717 yylval = yypushed_val;]b4_locations_if([[
1718 yylloc = yypushed_loc;]])])[
1719 yyread_pushed_token:]])[
1720 YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[
1721 yychar = yypushed_char;
1722 if (yypushed_val)
1723 yylval = *yypushed_val;]b4_locations_if([[
1724 if (yypushed_loc)
1725 yylloc = *yypushed_loc;]])])], [[
1726 yychar = YYLEX;]])[
1727 }
1728
1729 if (yychar <= YYEOF)
1730 {
1731 yychar = yytoken = YYEOF;
1732 YYDPRINTF ((stderr, "Now at end of input.\n"));
1733 }
1734 else
1735 {
1736 yytoken = YYTRANSLATE (yychar);
1737 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1738 }
1739
1740 /* If the proper action on seeing token YYTOKEN is to reduce or to
1741 detect an error, take that action. */
1742 yyn += yytoken;
1743 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)]b4_lac_if([[
1744 {
1745 YY_LAC_ESTABLISH;
1746 goto yydefault;
1747 }]], [[
1748 goto yydefault;]])[
1749 yyn = yytable[yyn];
1750 if (yyn <= 0)
1751 {
1752 if (yytable_value_is_error (yyn))
1753 goto yyerrlab;]b4_lac_if([[
1754 YY_LAC_ESTABLISH;]])[
1755 yyn = -yyn;
1756 goto yyreduce;
1757 }
1758
1759 /* Count tokens shifted since error; after three, turn off error
1760 status. */
1761 if (yyerrstatus)
1762 yyerrstatus--;
1763
1764 /* Shift the lookahead token. */
1765 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1766
1767 /* Discard the shifted token. */
1768 yychar = YYEMPTY;]b4_lac_if([[
1769 YY_LAC_DISCARD ("shift");]])[
1770
1771 yystate = yyn;
1772 *++yyvsp = yylval;
1773 ]b4_locations_if([ *++yylsp = yylloc;])[
1774 goto yynewstate;
1775
1776
1777 /*-----------------------------------------------------------.
1778 | yydefault -- do the default action for the current state. |
1779 `-----------------------------------------------------------*/
1780 yydefault:
1781 yyn = yydefact[yystate];
1782 if (yyn == 0)
1783 goto yyerrlab;
1784 goto yyreduce;
1785
1786
1787 /*-----------------------------.
1788 | yyreduce -- Do a reduction. |
1789 `-----------------------------*/
1790 yyreduce:
1791 /* yyn is the number of a rule to reduce with. */
1792 yylen = yyr2[yyn];
1793
1794 /* If YYLEN is nonzero, implement the default value of the action:
1795 `$$ = $1'.
1796
1797 Otherwise, the following line sets YYVAL to garbage.
1798 This behavior is undocumented and Bison
1799 users should not rely upon it. Assigning to YYVAL
1800 unconditionally makes the parser a bit smaller, and it avoids a
1801 GCC warning that YYVAL may be used uninitialized. */
1802 yyval = yyvsp[1-yylen];
1803
1804 ]b4_locations_if(
1805 [[ /* Default location. */
1806 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
1807 YY_REDUCE_PRINT (yyn);]b4_lac_if([[
1808 {
1809 int yychar_backup = yychar;
1810 switch (yyn)
1811 {
1812 ]b4_user_actions[
1813 default: break;
1814 }
1815 if (yychar_backup != yychar)
1816 YY_LAC_DISCARD ("yychar change");
1817 }]], [[
1818 switch (yyn)
1819 {
1820 ]b4_user_actions[
1821 default: break;
1822 }]])[
1823 /* User semantic actions sometimes alter yychar, and that requires
1824 that yytoken be updated with the new translation. We take the
1825 approach of translating immediately before every use of yytoken.
1826 One alternative is translating here after every semantic action,
1827 but that translation would be missed if the semantic action invokes
1828 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1829 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1830 incorrect destructor might then be invoked immediately. In the
1831 case of YYERROR or YYBACKUP, subsequent parser actions might lead
1832 to an incorrect destructor call or verbose syntax error message
1833 before the lookahead is translated. */
1834 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1835
1836 YYPOPSTACK (yylen);
1837 yylen = 0;
1838 YY_STACK_PRINT (yyss, yyssp);
1839
1840 *++yyvsp = yyval;]b4_locations_if([
1841 *++yylsp = yyloc;])[
1842
1843 /* Now `shift' the result of the reduction. Determine what state
1844 that goes to, based on the state we popped back to and the rule
1845 number reduced by. */
1846
1847 yyn = yyr1[yyn];
1848
1849 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1850 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1851 yystate = yytable[yystate];
1852 else
1853 yystate = yydefgoto[yyn - YYNTOKENS];
1854
1855 goto yynewstate;
1856
1857
1858 /*------------------------------------.
1859 | yyerrlab -- here on detecting error |
1860 `------------------------------------*/
1861 yyerrlab:
1862 /* Make sure we have latest lookahead translation. See comments at
1863 user semantic actions for why this is necessary. */
1864 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1865
1866 /* If not already recovering from an error, report this error. */
1867 if (!yyerrstatus)
1868 {
1869 ++yynerrs;
1870 #if ! YYERROR_VERBOSE
1871 yyerror (]b4_yyerror_args[YY_("syntax error"));
1872 #else
1873 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \]b4_lac_if([[
1874 yyesa, &yyes, &yyes_capacity, \]])[
1875 yyssp, yytoken)
1876 {
1877 char const *yymsgp = YY_("syntax error");
1878 int yysyntax_error_status;]b4_lac_if([[
1879 if (yychar != YYEMPTY)
1880 YY_LAC_ESTABLISH;]])[
1881 yysyntax_error_status = YYSYNTAX_ERROR;
1882 if (yysyntax_error_status == 0)
1883 yymsgp = yymsg;
1884 else if (yysyntax_error_status == 1)
1885 {
1886 if (yymsg != yymsgbuf)
1887 YYSTACK_FREE (yymsg);
1888 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1889 if (!yymsg)
1890 {
1891 yymsg = yymsgbuf;
1892 yymsg_alloc = sizeof yymsgbuf;
1893 yysyntax_error_status = 2;
1894 }
1895 else
1896 {
1897 yysyntax_error_status = YYSYNTAX_ERROR;
1898 yymsgp = yymsg;
1899 }
1900 }
1901 yyerror (]b4_yyerror_args[yymsgp);
1902 if (yysyntax_error_status == 2)
1903 goto yyexhaustedlab;
1904 }
1905 # undef YYSYNTAX_ERROR
1906 #endif
1907 }
1908
1909 ]b4_locations_if([[ yyerror_range[1] = yylloc;]])[
1910
1911 if (yyerrstatus == 3)
1912 {
1913 /* If just tried and failed to reuse lookahead token after an
1914 error, discard it. */
1915
1916 if (yychar <= YYEOF)
1917 {
1918 /* Return failure if at end of input. */
1919 if (yychar == YYEOF)
1920 YYABORT;
1921 }
1922 else
1923 {
1924 yydestruct ("Error: discarding",
1925 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1926 yychar = YYEMPTY;
1927 }
1928 }
1929
1930 /* Else will try to reuse lookahead token after shifting the error
1931 token. */
1932 goto yyerrlab1;
1933
1934
1935 /*---------------------------------------------------.
1936 | yyerrorlab -- error raised explicitly by YYERROR. |
1937 `---------------------------------------------------*/
1938 yyerrorlab:
1939
1940 /* Pacify compilers like GCC when the user code never invokes
1941 YYERROR and the label yyerrorlab therefore never appears in user
1942 code. */
1943 if (/*CONSTCOND*/ 0)
1944 goto yyerrorlab;
1945
1946 ]b4_locations_if([[ yyerror_range[1] = yylsp[1-yylen];
1947 ]])[ /* Do not reclaim the symbols of the rule which action triggered
1948 this YYERROR. */
1949 YYPOPSTACK (yylen);
1950 yylen = 0;
1951 YY_STACK_PRINT (yyss, yyssp);
1952 yystate = *yyssp;
1953 goto yyerrlab1;
1954
1955
1956 /*-------------------------------------------------------------.
1957 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1958 `-------------------------------------------------------------*/
1959 yyerrlab1:
1960 yyerrstatus = 3; /* Each real token shifted decrements this. */
1961
1962 for (;;)
1963 {
1964 yyn = yypact[yystate];
1965 if (!yypact_value_is_default (yyn))
1966 {
1967 yyn += YYTERROR;
1968 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1969 {
1970 yyn = yytable[yyn];
1971 if (0 < yyn)
1972 break;
1973 }
1974 }
1975
1976 /* Pop the current state because it cannot handle the error token. */
1977 if (yyssp == yyss)
1978 YYABORT;
1979
1980 ]b4_locations_if([[ yyerror_range[1] = *yylsp;]])[
1981 yydestruct ("Error: popping",
1982 yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1983 YYPOPSTACK (1);
1984 yystate = *yyssp;
1985 YY_STACK_PRINT (yyss, yyssp);
1986 }]b4_lac_if([[
1987
1988 /* If the stack popping above didn't lose the initial context for the
1989 current lookahead token, the shift below will for sure. */
1990 YY_LAC_DISCARD ("error recovery");]])[
1991
1992 *++yyvsp = yylval;
1993 ]b4_locations_if([[
1994 yyerror_range[2] = yylloc;
1995 /* Using YYLLOC is tempting, but would change the location of
1996 the lookahead. YYLOC is available though. */
1997 YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
1998 *++yylsp = yyloc;]])[
1999
2000 /* Shift the error token. */
2001 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2002
2003 yystate = yyn;
2004 goto yynewstate;
2005
2006
2007 /*-------------------------------------.
2008 | yyacceptlab -- YYACCEPT comes here. |
2009 `-------------------------------------*/
2010 yyacceptlab:
2011 yyresult = 0;
2012 goto yyreturn;
2013
2014 /*-----------------------------------.
2015 | yyabortlab -- YYABORT comes here. |
2016 `-----------------------------------*/
2017 yyabortlab:
2018 yyresult = 1;
2019 goto yyreturn;
2020
2021 #if ]b4_lac_if([[1]], [[!defined yyoverflow || YYERROR_VERBOSE]])[
2022 /*-------------------------------------------------.
2023 | yyexhaustedlab -- memory exhaustion comes here. |
2024 `-------------------------------------------------*/
2025 yyexhaustedlab:
2026 yyerror (]b4_yyerror_args[YY_("memory exhausted"));
2027 yyresult = 2;
2028 /* Fall through. */
2029 #endif
2030
2031 yyreturn:
2032 if (yychar != YYEMPTY)
2033 {
2034 /* Make sure we have latest lookahead translation. See comments at
2035 user semantic actions for why this is necessary. */
2036 yytoken = YYTRANSLATE (yychar);
2037 yydestruct ("Cleanup: discarding lookahead",
2038 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
2039 }
2040 /* Do not reclaim the symbols of the rule which action triggered
2041 this YYABORT or YYACCEPT. */
2042 YYPOPSTACK (yylen);
2043 YY_STACK_PRINT (yyss, yyssp);
2044 while (yyssp != yyss)
2045 {
2046 yydestruct ("Cleanup: popping",
2047 yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
2048 YYPOPSTACK (1);
2049 }
2050 #ifndef yyoverflow
2051 if (yyss != yyssa)
2052 YYSTACK_FREE (yyss);
2053 #endif]b4_lac_if([[
2054 if (yyes != yyesa)
2055 YYSTACK_FREE (yyes);]])b4_push_if([[
2056 yyps->yynew = 1;
2057
2058 yypushreturn:]])[
2059 #if YYERROR_VERBOSE
2060 if (yymsg != yymsgbuf)
2061 YYSTACK_FREE (yymsg);
2062 #endif
2063 /* Make sure YYID is used. */
2064 return YYID (yyresult);
2065 }
2066
2067
2068 ]b4_epilogue
2069 b4_defines_if(
2070 [@output(b4_spec_defines_file@)@
2071 b4_copyright([Bison interface for Yacc-like parsers in C],
2072 [1984, 1989-1990, 2000-2011])
2073
2074 b4_percent_code_get([[requires]])[]dnl
2075
2076 b4_token_enums_defines(b4_tokens)
2077
2078 [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
2079 ]m4_ifdef([b4_stype],
2080 [[typedef union ]b4_union_name[
2081 {
2082 ]b4_user_stype[
2083 } YYSTYPE;
2084 # define YYSTYPE_IS_TRIVIAL 1]],
2085 [m4_if(b4_tag_seen_flag, 0,
2086 [[typedef int YYSTYPE;
2087 # define YYSTYPE_IS_TRIVIAL 1]])])[
2088 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
2089 # define YYSTYPE_IS_DECLARED 1
2090 #endif
2091
2092 ]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;]])
2093
2094 b4_locations_if(
2095 [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
2096 typedef struct YYLTYPE
2097 {
2098 int first_line;
2099 int first_column;
2100 int last_line;
2101 int last_column;
2102 } YYLTYPE;
2103 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
2104 # define YYLTYPE_IS_DECLARED 1
2105 # define YYLTYPE_IS_TRIVIAL 1
2106 #endif
2107
2108 ]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]])
2109 )dnl b4_locations_if
2110 b4_push_if([[
2111 #ifndef YYPUSH_DECLS
2112 # define YYPUSH_DECLS
2113 struct ]b4_prefix[pstate;
2114 typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
2115 enum { YYPUSH_MORE = 4 };
2116 ]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
2117 ])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
2118 [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([,
2119 [[[int yypushed_char]], [[yypushed_char]]],
2120 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
2121 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
2122 b4_parse_param]))
2123 b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
2124 [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
2125 b4_parse_param]))])
2126 b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
2127 [[[void]], []])
2128 b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
2129 [[b4_prefix[pstate *yyps]], [[yyps]]])[
2130 #endif
2131 ]])
2132 b4_percent_code_get([[provides]])[]dnl
2133 ])dnl b4_defines_if
2134 m4_divert_pop(0)
bison