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