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