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