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


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