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


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