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