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


2e46a1e21008dc6215f2a71ec235ac2bbb4b83bd
[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_declare_yyparse_push_
229 # ------------------------
230 # Declaration of yyparse (and dependencies) when using the push parser
231 # (including in pull mode).
232 m4_define([b4_declare_yyparse_push_],
233 [[typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
234 enum { YYPUSH_MORE = 4 };
235 ]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
236 ])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
237 [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([,
238 [[[int yypushed_char]], [[yypushed_char]]],
239 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
240 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
241 b4_parse_param]))
242 b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
243 [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
244 b4_parse_param]))])
245 b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
246 [[[void]], []])
247 b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
248 [[b4_prefix[pstate *yyps]], [[yyps]]])dnl
249 ])
250
251 # b4_declare_yyparse_
252 # -------------------
253 # When not the push parser.
254 m4_define([b4_declare_yyparse_],
255 [[#ifdef YYPARSE_PARAM
256 ]b4_c_function_decl(b4_prefix[parse], [int],
257 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
258 #else /* ! YYPARSE_PARAM */
259 ]b4_c_function_decl(b4_prefix[parse], [int], b4_parse_param)[
260 #endif /* ! YYPARSE_PARAM */]dnl
261 ])
262
263
264 # b4_declare_yyparse
265 # ------------------
266 m4_define([b4_declare_yyparse],
267 [b4_push_if([b4_declare_yyparse_push_],
268 [b4_declare_yyparse_])[]dnl
269 ])
270
271
272 # b4_shared_declarations
273 # ----------------------
274 # Declaration that might either go into the header (if --defines)
275 # or open coded in the parser body.
276 m4_define([b4_shared_declarations],
277 [b4_cpp_guard_open([b4_spec_defines_file])[
278 ]b4_declare_yydebug[
279 ]b4_percent_code_get([[requires]])[
280 ]b4_token_enums_defines(b4_tokens)[
281 ]b4_declare_yylstype[
282 ]b4_declare_yyparse[
283 ]b4_percent_code_get([[provides]])[
284 ]b4_cpp_guard_close([b4_spec_defines_file])[]dnl
285 ])
286
287 ## -------------- ##
288 ## Output files. ##
289 ## -------------- ##
290
291 # We do want M4 expansion after # for CPP macros.
292 m4_changecom()
293 m4_divert_push(0)dnl
294 @output(b4_parser_file_name@)@
295 b4_copyright([Bison implementation for Yacc-like parsers in C],
296 [1984, 1989-1990, 2000-2012])[
297
298 /* C LALR(1) parser skeleton written by Richard Stallman, by
299 simplifying the original so-called "semantic" parser. */
300
301 /* All symbols defined below should begin with yy or YY, to avoid
302 infringing on user name space. This should be done even for local
303 variables, as they might otherwise be expanded by user macros.
304 There are some unavoidable exceptions within include files to
305 define necessary library symbols; they are noted "INFRINGES ON
306 USER NAME SPACE" below. */
307
308 ]b4_identification
309 b4_percent_code_get([[top]])[]dnl
310 m4_if(b4_api_prefix, [yy], [],
311 [[/* Substitute the type names. */
312 #define YYSTYPE ]b4_api_PREFIX[STYPE]b4_locations_if([[
313 #define YYLTYPE ]b4_api_PREFIX[LTYPE]])])[
314 ]m4_if(b4_prefix, [yy], [],
315 [[/* Substitute the variable and function names. */]b4_pull_if([[
316 #define yyparse ]b4_prefix[parse]])b4_push_if([[
317 #define yypush_parse ]b4_prefix[push_parse]b4_pull_if([[
318 #define yypull_parse ]b4_prefix[pull_parse]])[
319 #define yypstate_new ]b4_prefix[pstate_new
320 #define yypstate_delete ]b4_prefix[pstate_delete
321 #define yypstate ]b4_prefix[pstate]])[
322 #define yylex ]b4_prefix[lex
323 #define yyerror ]b4_prefix[error
324 #define yylval ]b4_prefix[lval
325 #define yychar ]b4_prefix[char
326 #define yydebug ]b4_prefix[debug
327 #define yynerrs ]b4_prefix[nerrs]b4_locations_if([[
328 #define yylloc ]b4_prefix[lloc]])])[
329
330 /* Copy the first part of user declarations. */
331 ]b4_user_pre_prologue[
332
333 ]b4_null_define[
334
335 /* Enabling verbose error messages. */
336 #ifdef YYERROR_VERBOSE
337 # undef YYERROR_VERBOSE
338 # define YYERROR_VERBOSE 1
339 #else
340 # define YYERROR_VERBOSE ]b4_error_verbose_flag[
341 #endif
342
343 /* In a future release of Bison, this section will be replaced
344 by #include "@basename(]b4_spec_defines_file[@)". */
345 ]b4_shared_declarations[
346
347 /* Copy the second part of user declarations. */
348 ]b4_user_post_prologue
349 b4_percent_code_get[]dnl
350
351 [#ifdef short
352 # undef short
353 #endif
354
355 #ifdef YYTYPE_UINT8
356 typedef YYTYPE_UINT8 yytype_uint8;
357 #else
358 typedef unsigned char yytype_uint8;
359 #endif
360
361 #ifdef YYTYPE_INT8
362 typedef YYTYPE_INT8 yytype_int8;
363 #elif ]b4_c_modern[
364 typedef signed char yytype_int8;
365 #else
366 typedef short int yytype_int8;
367 #endif
368
369 #ifdef YYTYPE_UINT16
370 typedef YYTYPE_UINT16 yytype_uint16;
371 #else
372 typedef unsigned short int yytype_uint16;
373 #endif
374
375 #ifdef YYTYPE_INT16
376 typedef YYTYPE_INT16 yytype_int16;
377 #else
378 typedef short int yytype_int16;
379 #endif
380
381 #ifndef YYSIZE_T
382 # ifdef __SIZE_TYPE__
383 # define YYSIZE_T __SIZE_TYPE__
384 # elif defined size_t
385 # define YYSIZE_T size_t
386 # elif ! defined YYSIZE_T && ]b4_c_modern[
387 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
388 # define YYSIZE_T size_t
389 # else
390 # define YYSIZE_T unsigned int
391 # endif
392 #endif
393
394 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
395
396 #ifndef YY_
397 # if defined YYENABLE_NLS && YYENABLE_NLS
398 # if ENABLE_NLS
399 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
400 # define YY_(msgid) dgettext ("bison-runtime", msgid)
401 # endif
402 # endif
403 # ifndef YY_
404 # define YY_(msgid) msgid
405 # endif
406 #endif
407
408 /* Suppress unused-variable warnings by "using" E. */
409 #if ! defined lint || defined __GNUC__
410 # define YYUSE(e) ((void) (e))
411 #else
412 # define YYUSE(e) /* empty */
413 #endif
414
415 /* Identity function, used to suppress warnings about constant conditions. */
416 #ifndef lint
417 # define YYID(n) (n)
418 #else
419 ]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[
420 {
421 return yyi;
422 }
423 #endif
424
425 #if ]b4_lac_if([[1]], [[! defined yyoverflow || YYERROR_VERBOSE]])[
426
427 /* The parser invokes alloca or malloc; define the necessary symbols. */]dnl
428 b4_push_if([], [b4_lac_if([], [[
429
430 # ifdef YYSTACK_USE_ALLOCA
431 # if YYSTACK_USE_ALLOCA
432 # ifdef __GNUC__
433 # define YYSTACK_ALLOC __builtin_alloca
434 # elif defined __BUILTIN_VA_ARG_INCR
435 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
436 # elif defined _AIX
437 # define YYSTACK_ALLOC __alloca
438 # elif defined _MSC_VER
439 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
440 # define alloca _alloca
441 # else
442 # define YYSTACK_ALLOC alloca
443 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && ]b4_c_modern[
444 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
445 /* Use EXIT_SUCCESS as a witness for stdlib.h. */
446 # ifndef EXIT_SUCCESS
447 # define EXIT_SUCCESS 0
448 # endif
449 # endif
450 # endif
451 # endif
452 # endif]])])[
453
454 # ifdef YYSTACK_ALLOC
455 /* Pacify GCC's `empty if-body' warning. */
456 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
457 # ifndef YYSTACK_ALLOC_MAXIMUM
458 /* The OS might guarantee only one guard page at the bottom of the stack,
459 and a page size can be as small as 4096 bytes. So we cannot safely
460 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
461 to allow for a few compiler-allocated temporary stack slots. */
462 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
463 # endif
464 # else
465 # define YYSTACK_ALLOC YYMALLOC
466 # define YYSTACK_FREE YYFREE
467 # ifndef YYSTACK_ALLOC_MAXIMUM
468 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
469 # endif
470 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
471 && ! ((defined YYMALLOC || defined malloc) \
472 && (defined YYFREE || defined free)))
473 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
474 # ifndef EXIT_SUCCESS
475 # define EXIT_SUCCESS 0
476 # endif
477 # endif
478 # ifndef YYMALLOC
479 # define YYMALLOC malloc
480 # if ! defined malloc && ! defined EXIT_SUCCESS && ]b4_c_modern[
481 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
482 # endif
483 # endif
484 # ifndef YYFREE
485 # define YYFREE free
486 # if ! defined free && ! defined EXIT_SUCCESS && ]b4_c_modern[
487 void free (void *); /* INFRINGES ON USER NAME SPACE */
488 # endif
489 # endif
490 # endif]b4_lac_if([[
491 # define YYCOPY_NEEDED 1]])[
492 #endif]b4_lac_if([], [[ /* ! defined yyoverflow || YYERROR_VERBOSE */]])[
493
494
495 #if (! defined yyoverflow \
496 && (! defined __cplusplus \
497 || (]b4_locations_if([[defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL \
498 && ]])[defined ]b4_api_PREFIX[STYPE_IS_TRIVIAL && ]b4_api_PREFIX[STYPE_IS_TRIVIAL)))
499
500 /* A type that is properly aligned for any stack member. */
501 union yyalloc
502 {
503 yytype_int16 yyss_alloc;
504 YYSTYPE yyvs_alloc;]b4_locations_if([
505 YYLTYPE yyls_alloc;])[
506 };
507
508 /* The size of the maximum gap between one aligned stack and the next. */
509 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
510
511 /* The size of an array large to enough to hold all stacks, each with
512 N elements. */
513 ]b4_locations_if(
514 [# define YYSTACK_BYTES(N) \
515 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
516 + 2 * YYSTACK_GAP_MAXIMUM)],
517 [# define YYSTACK_BYTES(N) \
518 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
519 + YYSTACK_GAP_MAXIMUM)])[
520
521 # define YYCOPY_NEEDED 1
522
523 /* Relocate STACK from its old location to the new one. The
524 local variables YYSIZE and YYSTACKSIZE give the old and new number of
525 elements in the stack, and YYPTR gives the new location of the
526 stack. Advance YYPTR to a properly aligned location for the next
527 stack. */
528 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
529 do \
530 { \
531 YYSIZE_T yynewbytes; \
532 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
533 Stack = &yyptr->Stack_alloc; \
534 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
535 yyptr += yynewbytes / sizeof (*yyptr); \
536 } \
537 while (YYID (0))
538
539 #endif
540
541 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
542 /* Copy COUNT objects from SRC to DST. The source and destination do
543 not overlap. */
544 # ifndef YYCOPY
545 # if defined __GNUC__ && 1 < __GNUC__
546 # define YYCOPY(Dst, Src, Count) \
547 __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
548 # else
549 # define YYCOPY(Dst, Src, Count) \
550 do \
551 { \
552 YYSIZE_T yyi; \
553 for (yyi = 0; yyi < (Count); yyi++) \
554 (Dst)[yyi] = (Src)[yyi]; \
555 } \
556 while (YYID (0))
557 # endif
558 # endif
559 #endif /* !YYCOPY_NEEDED */
560
561 /* YYFINAL -- State number of the termination state. */
562 #define YYFINAL ]b4_final_state_number[
563 /* YYLAST -- Last index in YYTABLE. */
564 #define YYLAST ]b4_last[
565
566 /* YYNTOKENS -- Number of terminals. */
567 #define YYNTOKENS ]b4_tokens_number[
568 /* YYNNTS -- Number of nonterminals. */
569 #define YYNNTS ]b4_nterms_number[
570 /* YYNRULES -- Number of rules. */
571 #define YYNRULES ]b4_rules_number[
572 /* YYNRULES -- Number of states. */
573 #define YYNSTATES ]b4_states_number[
574
575 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
576 #define YYUNDEFTOK ]b4_undef_token_number[
577 #define YYMAXUTOK ]b4_user_token_number_max[
578
579 #define YYTRANSLATE(YYX) \
580 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
581
582 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
583 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
584 {
585 ]b4_translate[
586 };
587
588 #if ]b4_api_PREFIX[DEBUG
589 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
590 YYRHS. */
591 static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
592 {
593 ]b4_prhs[
594 };
595
596 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
597 static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
598 {
599 ]b4_rhs[
600 };
601
602 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
603 static const ]b4_int_type_for([b4_rline])[ yyrline[] =
604 {
605 ]b4_rline[
606 };
607 #endif
608
609 #if ]b4_api_PREFIX[DEBUG || YYERROR_VERBOSE || ]b4_token_table_flag[
610 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
611 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
612 static const char *const yytname[] =
613 {
614 ]b4_tname[
615 };
616 #endif
617
618 # ifdef YYPRINT
619 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
620 token YYLEX-NUM. */
621 static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
622 {
623 ]b4_toknum[
624 };
625 # endif
626
627 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
628 static const ]b4_int_type_for([b4_r1])[ yyr1[] =
629 {
630 ]b4_r1[
631 };
632
633 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
634 static const ]b4_int_type_for([b4_r2])[ yyr2[] =
635 {
636 ]b4_r2[
637 };
638
639 /* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
640 Performed when YYTABLE doesn't specify something else to do. Zero
641 means the default is an error. */
642 static const ]b4_int_type_for([b4_defact])[ yydefact[] =
643 {
644 ]b4_defact[
645 };
646
647 /* YYDEFGOTO[NTERM-NUM]. */
648 static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
649 {
650 ]b4_defgoto[
651 };
652
653 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
654 STATE-NUM. */
655 #define YYPACT_NINF ]b4_pact_ninf[
656 static const ]b4_int_type_for([b4_pact])[ yypact[] =
657 {
658 ]b4_pact[
659 };
660
661 /* YYPGOTO[NTERM-NUM]. */
662 static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
663 {
664 ]b4_pgoto[
665 };
666
667 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
668 positive, shift that token. If negative, reduce the rule which
669 number is the opposite. If YYTABLE_NINF, syntax error. */
670 #define YYTABLE_NINF ]b4_table_ninf[
671 static const ]b4_int_type_for([b4_table])[ yytable[] =
672 {
673 ]b4_table[
674 };
675
676 #define yypact_value_is_default(yystate) \
677 ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[
678
679 #define yytable_value_is_error(yytable_value) \
680 ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[
681
682 static const ]b4_int_type_for([b4_check])[ yycheck[] =
683 {
684 ]b4_check[
685 };
686
687 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
688 symbol of state STATE-NUM. */
689 static const ]b4_int_type_for([b4_stos])[ yystos[] =
690 {
691 ]b4_stos[
692 };
693
694 #define yyerrok (yyerrstatus = 0)
695 #define yyclearin (yychar = YYEMPTY)
696 #define YYEMPTY (-2)
697 #define YYEOF 0
698
699 #define YYACCEPT goto yyacceptlab
700 #define YYABORT goto yyabortlab
701 #define YYERROR goto yyerrorlab
702
703
704 /* Like YYERROR except do call yyerror. This remains here temporarily
705 to ease the transition to the new meaning of YYERROR, for GCC.
706 Once GCC version 2 has supplanted version 1, this can go. However,
707 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
708 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
709 discussed. */
710
711 #define YYFAIL goto yyerrlab
712 #if defined YYFAIL
713 /* This is here to suppress warnings from the GCC cpp's
714 -Wunused-macros. Normally we don't worry about that warning, but
715 some users do, and we want to make it easy for users to remove
716 YYFAIL uses, which will produce warnings from Bison 2.5. */
717 #endif
718
719 #define YYRECOVERING() (!!yyerrstatus)
720
721 #define YYBACKUP(Token, Value) \
722 do \
723 if (yychar == YYEMPTY) \
724 { \
725 yychar = (Token); \
726 yylval = (Value); \
727 YYPOPSTACK (yylen); \
728 yystate = *yyssp; \]b4_lac_if([[
729 YY_LAC_DISCARD ("YYBACKUP"); \]])[
730 goto yybackup; \
731 } \
732 else \
733 { \
734 yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
735 YYERROR; \
736 } \
737 while (YYID (0))
738
739
740 #define YYTERROR 1
741 #define YYERRCODE 256
742
743 ]b4_yylloc_default_define[
744 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
745 ]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 ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_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 ]b4_api_PREFIX[DEBUG
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 /* !]b4_api_PREFIX[DEBUG */
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 /* !]b4_api_PREFIX[DEBUG */
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 ]b4_api_PREFIX[DEBUG
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 ]b4_api_PREFIX[DEBUG
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 ]b4_api_PREFIX[DEBUG
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 ]b4_api_PREFIX[DEBUG
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])[
1377
1378 ]b4_pure_if([], [
1379
1380 b4_declare_scanner_communication_variables])[]b4_push_if([[
1381
1382 struct yypstate
1383 {]b4_declare_parser_state_variables[
1384 /* Used to determine if this is the first time this instance has
1385 been used. */
1386 int yynew;
1387 };]b4_pure_if([], [[
1388
1389 static char yypstate_allocated = 0;]])b4_pull_if([
1390
1391 b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
1392 {
1393 return yypull_parse (YY_NULL]m4_ifset([b4_parse_param],
1394 [[, ]b4_c_args(b4_parse_param)])[);
1395 }
1396
1397 ]b4_c_function_def([[yypull_parse]], [[int]],
1398 [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1399 b4_parse_param]))[
1400 {
1401 int yystatus;
1402 yypstate *yyps_local;]b4_pure_if([[
1403 int yychar;
1404 YYSTYPE yylval;]b4_locations_if([[
1405 YYLTYPE yylloc;]])])[
1406 if (yyps)
1407 yyps_local = yyps;
1408 else
1409 {
1410 yyps_local = yypstate_new ();
1411 if (!yyps_local)
1412 {]b4_pure_if([[
1413 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
1414 if (!yypstate_allocated)
1415 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
1416 return 2;
1417 }
1418 }
1419 do {
1420 yychar = YYLEX;
1421 yystatus =
1422 yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
1423 } while (yystatus == YYPUSH_MORE);
1424 if (!yyps)
1425 yypstate_delete (yyps_local);
1426 return yystatus;
1427 }]])[
1428
1429 /* Initialize the parser data structure. */
1430 ]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
1431 {
1432 yypstate *yyps;]b4_pure_if([], [[
1433 if (yypstate_allocated)
1434 return YY_NULL;]])[
1435 yyps = (yypstate *) malloc (sizeof *yyps);
1436 if (!yyps)
1437 return YY_NULL;
1438 yyps->yynew = 1;]b4_pure_if([], [[
1439 yypstate_allocated = 1;]])[
1440 return yyps;
1441 }
1442
1443 ]b4_c_function_def([[yypstate_delete]], [[void]],
1444 [[[yypstate *yyps]], [[yyps]]])[
1445 {
1446 #ifndef yyoverflow
1447 /* If the stack was reallocated but the parse did not complete, then the
1448 stack still needs to be freed. */
1449 if (!yyps->yynew && yyps->yyss != yyps->yyssa)
1450 YYSTACK_FREE (yyps->yyss);
1451 #endif]b4_lac_if([[
1452 if (!yyps->yynew && yyps->yyes != yyps->yyesa)
1453 YYSTACK_FREE (yyps->yyes);]])[
1454 free (yyps);]b4_pure_if([], [[
1455 yypstate_allocated = 0;]])[
1456 }
1457 ]b4_pure_if([[
1458 #define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs]])[
1459 #define yystate yyps->yystate
1460 #define yyerrstatus yyps->yyerrstatus
1461 #define yyssa yyps->yyssa
1462 #define yyss yyps->yyss
1463 #define yyssp yyps->yyssp
1464 #define yyvsa yyps->yyvsa
1465 #define yyvs yyps->yyvs
1466 #define yyvsp yyps->yyvsp]b4_locations_if([[
1467 #define yylsa yyps->yylsa
1468 #define yyls yyps->yyls
1469 #define yylsp yyps->yylsp
1470 #define yyerror_range yyps->yyerror_range]])[
1471 #define yystacksize yyps->yystacksize]b4_lac_if([[
1472 #define yyesa yyps->yyesa
1473 #define yyes yyps->yyes
1474 #define yyes_capacity yyps->yyes_capacity]])[
1475
1476
1477 /*---------------.
1478 | yypush_parse. |
1479 `---------------*/
1480
1481 ]b4_c_function_def([[yypush_parse]], [[int]],
1482 [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
1483 [[[int yypushed_char]], [[yypushed_char]]],
1484 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1485 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1486 b4_parse_param]))], [[
1487
1488
1489 /*----------.
1490 | yyparse. |
1491 `----------*/
1492
1493 #ifdef YYPARSE_PARAM
1494 ]b4_c_function_def([yyparse], [int],
1495 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
1496 #else /* ! YYPARSE_PARAM */
1497 ]b4_c_function_def([yyparse], [int], b4_parse_param)[
1498 #endif]])[
1499 {]b4_pure_if([b4_declare_scanner_communication_variables
1500 ])b4_push_if([b4_pure_if([], [[
1501 int yypushed_char = yychar;
1502 YYSTYPE yypushed_val = yylval;]b4_locations_if([[
1503 YYLTYPE yypushed_loc = yylloc;]])
1504 ])],
1505 [b4_declare_parser_state_variables
1506 ])b4_lac_if([[
1507 int yy_lac_established = 0;]])[
1508 int yyn;
1509 int yyresult;
1510 /* Lookahead token as an internal (translated) token number. */
1511 int yytoken;
1512 /* The variables used to return semantic value and location from the
1513 action routines. */
1514 YYSTYPE yyval;]b4_locations_if([[
1515 YYLTYPE yyloc;]])[
1516
1517 #if YYERROR_VERBOSE
1518 /* Buffer for error messages, and its allocated size. */
1519 char yymsgbuf[128];
1520 char *yymsg = yymsgbuf;
1521 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1522 #endif
1523
1524 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
1525
1526 /* The number of symbols on the RHS of the reduced rule.
1527 Keep to zero when no symbol should be popped. */
1528 int yylen = 0;]b4_push_if([[
1529
1530 if (!yyps->yynew)
1531 {
1532 yyn = yypact[yystate];
1533 goto yyread_pushed_token;
1534 }]])[
1535
1536 yytoken = 0;
1537 yyss = yyssa;
1538 yyvs = yyvsa;]b4_locations_if([[
1539 yyls = yylsa;]])[
1540 yystacksize = YYINITDEPTH;]b4_lac_if([[
1541
1542 yyes = yyesa;
1543 yyes_capacity = sizeof yyesa / sizeof *yyes;
1544 if (YYMAXDEPTH < yyes_capacity)
1545 yyes_capacity = YYMAXDEPTH;]])[
1546
1547 YYDPRINTF ((stderr, "Starting parse\n"));
1548
1549 yystate = 0;
1550 yyerrstatus = 0;
1551 yynerrs = 0;
1552 yychar = YYEMPTY; /* Cause a token to be read. */
1553
1554 /* Initialize stack pointers.
1555 Waste one element of value and location stack
1556 so that they stay on the same level as the state stack.
1557 The wasted elements are never initialized. */
1558 yyssp = yyss;
1559 yyvsp = yyvs;]b4_locations_if([[
1560 yylsp = yyls;
1561
1562 #if defined ]b4_api_PREFIX[LTYPE_IS_TRIVIAL && ]b4_api_PREFIX[LTYPE_IS_TRIVIAL
1563 /* Initialize the default location before parsing starts. */
1564 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
1565 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
1566 #endif]])
1567 m4_ifdef([b4_initial_action],[
1568 m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl
1569 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
1570 /* User initialization code. */
1571 b4_user_initial_action
1572 m4_popdef([b4_dollar_dollar])dnl
1573 m4_popdef([b4_at_dollar])])dnl
1574 m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval;
1575 ]])dnl
1576 m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc;
1577 ]])[
1578 goto yysetstate;
1579
1580 /*------------------------------------------------------------.
1581 | yynewstate -- Push a new state, which is found in yystate. |
1582 `------------------------------------------------------------*/
1583 yynewstate:
1584 /* In all cases, when you get here, the value and location stacks
1585 have just been pushed. So pushing a state here evens the stacks. */
1586 yyssp++;
1587
1588 yysetstate:
1589 *yyssp = yystate;
1590
1591 if (yyss + yystacksize - 1 <= yyssp)
1592 {
1593 /* Get the current used size of the three stacks, in elements. */
1594 YYSIZE_T yysize = yyssp - yyss + 1;
1595
1596 #ifdef yyoverflow
1597 {
1598 /* Give user a chance to reallocate the stack. Use copies of
1599 these so that the &'s don't force the real ones into
1600 memory. */
1601 YYSTYPE *yyvs1 = yyvs;
1602 yytype_int16 *yyss1 = yyss;]b4_locations_if([
1603 YYLTYPE *yyls1 = yyls;])[
1604
1605 /* Each stack pointer address is followed by the size of the
1606 data in use in that stack, in bytes. This used to be a
1607 conditional around just the two extra args, but that might
1608 be undefined if yyoverflow is a macro. */
1609 yyoverflow (YY_("memory exhausted"),
1610 &yyss1, yysize * sizeof (*yyssp),
1611 &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
1612 &yyls1, yysize * sizeof (*yylsp),])[
1613 &yystacksize);
1614 ]b4_locations_if([
1615 yyls = yyls1;])[
1616 yyss = yyss1;
1617 yyvs = yyvs1;
1618 }
1619 #else /* no yyoverflow */
1620 # ifndef YYSTACK_RELOCATE
1621 goto yyexhaustedlab;
1622 # else
1623 /* Extend the stack our own way. */
1624 if (YYMAXDEPTH <= yystacksize)
1625 goto yyexhaustedlab;
1626 yystacksize *= 2;
1627 if (YYMAXDEPTH < yystacksize)
1628 yystacksize = YYMAXDEPTH;
1629
1630 {
1631 yytype_int16 *yyss1 = yyss;
1632 union yyalloc *yyptr =
1633 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1634 if (! yyptr)
1635 goto yyexhaustedlab;
1636 YYSTACK_RELOCATE (yyss_alloc, yyss);
1637 YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
1638 YYSTACK_RELOCATE (yyls_alloc, yyls);])[
1639 # undef YYSTACK_RELOCATE
1640 if (yyss1 != yyssa)
1641 YYSTACK_FREE (yyss1);
1642 }
1643 # endif
1644 #endif /* no yyoverflow */
1645
1646 yyssp = yyss + yysize - 1;
1647 yyvsp = yyvs + yysize - 1;]b4_locations_if([
1648 yylsp = yyls + yysize - 1;])[
1649
1650 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1651 (unsigned long int) yystacksize));
1652
1653 if (yyss + yystacksize - 1 <= yyssp)
1654 YYABORT;
1655 }
1656
1657 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1658
1659 if (yystate == YYFINAL)
1660 YYACCEPT;
1661
1662 goto yybackup;
1663
1664 /*-----------.
1665 | yybackup. |
1666 `-----------*/
1667 yybackup:
1668
1669 /* Do appropriate processing given the current state. Read a
1670 lookahead token if we need one and don't already have one. */
1671
1672 /* First try to decide what to do without reference to lookahead token. */
1673 yyn = yypact[yystate];
1674 if (yypact_value_is_default (yyn))
1675 goto yydefault;
1676
1677 /* Not known => get a lookahead token if don't already have one. */
1678
1679 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1680 if (yychar == YYEMPTY)
1681 {]b4_push_if([[
1682 if (!yyps->yynew)
1683 {]b4_use_push_for_pull_if([], [[
1684 YYDPRINTF ((stderr, "Return for a new token:\n"));]])[
1685 yyresult = YYPUSH_MORE;
1686 goto yypushreturn;
1687 }
1688 yyps->yynew = 0;]b4_pure_if([], [[
1689 /* Restoring the pushed token is only necessary for the first
1690 yypush_parse invocation since subsequent invocations don't overwrite
1691 it before jumping to yyread_pushed_token. */
1692 yychar = yypushed_char;
1693 yylval = yypushed_val;]b4_locations_if([[
1694 yylloc = yypushed_loc;]])])[
1695 yyread_pushed_token:]])[
1696 YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[
1697 yychar = yypushed_char;
1698 if (yypushed_val)
1699 yylval = *yypushed_val;]b4_locations_if([[
1700 if (yypushed_loc)
1701 yylloc = *yypushed_loc;]])])], [[
1702 yychar = YYLEX;]])[
1703 }
1704
1705 if (yychar <= YYEOF)
1706 {
1707 yychar = yytoken = YYEOF;
1708 YYDPRINTF ((stderr, "Now at end of input.\n"));
1709 }
1710 else
1711 {
1712 yytoken = YYTRANSLATE (yychar);
1713 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1714 }
1715
1716 /* If the proper action on seeing token YYTOKEN is to reduce or to
1717 detect an error, take that action. */
1718 yyn += yytoken;
1719 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)]b4_lac_if([[
1720 {
1721 YY_LAC_ESTABLISH;
1722 goto yydefault;
1723 }]], [[
1724 goto yydefault;]])[
1725 yyn = yytable[yyn];
1726 if (yyn <= 0)
1727 {
1728 if (yytable_value_is_error (yyn))
1729 goto yyerrlab;]b4_lac_if([[
1730 YY_LAC_ESTABLISH;]])[
1731 yyn = -yyn;
1732 goto yyreduce;
1733 }
1734
1735 /* Count tokens shifted since error; after three, turn off error
1736 status. */
1737 if (yyerrstatus)
1738 yyerrstatus--;
1739
1740 /* Shift the lookahead token. */
1741 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1742
1743 /* Discard the shifted token. */
1744 yychar = YYEMPTY;]b4_lac_if([[
1745 YY_LAC_DISCARD ("shift");]])[
1746
1747 yystate = yyn;
1748 *++yyvsp = yylval;
1749 ]b4_locations_if([ *++yylsp = yylloc;])[
1750 goto yynewstate;
1751
1752
1753 /*-----------------------------------------------------------.
1754 | yydefault -- do the default action for the current state. |
1755 `-----------------------------------------------------------*/
1756 yydefault:
1757 yyn = yydefact[yystate];
1758 if (yyn == 0)
1759 goto yyerrlab;
1760 goto yyreduce;
1761
1762
1763 /*-----------------------------.
1764 | yyreduce -- Do a reduction. |
1765 `-----------------------------*/
1766 yyreduce:
1767 /* yyn is the number of a rule to reduce with. */
1768 yylen = yyr2[yyn];
1769
1770 /* If YYLEN is nonzero, implement the default value of the action:
1771 `$$ = $1'.
1772
1773 Otherwise, the following line sets YYVAL to garbage.
1774 This behavior is undocumented and Bison
1775 users should not rely upon it. Assigning to YYVAL
1776 unconditionally makes the parser a bit smaller, and it avoids a
1777 GCC warning that YYVAL may be used uninitialized. */
1778 yyval = yyvsp[1-yylen];
1779
1780 ]b4_locations_if(
1781 [[ /* Default location. */
1782 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
1783 YY_REDUCE_PRINT (yyn);]b4_lac_if([[
1784 {
1785 int yychar_backup = yychar;
1786 switch (yyn)
1787 {
1788 ]b4_user_actions[
1789 default: break;
1790 }
1791 if (yychar_backup != yychar)
1792 YY_LAC_DISCARD ("yychar change");
1793 }]], [[
1794 switch (yyn)
1795 {
1796 ]b4_user_actions[
1797 default: break;
1798 }]])[
1799 /* User semantic actions sometimes alter yychar, and that requires
1800 that yytoken be updated with the new translation. We take the
1801 approach of translating immediately before every use of yytoken.
1802 One alternative is translating here after every semantic action,
1803 but that translation would be missed if the semantic action invokes
1804 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
1805 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
1806 incorrect destructor might then be invoked immediately. In the
1807 case of YYERROR or YYBACKUP, subsequent parser actions might lead
1808 to an incorrect destructor call or verbose syntax error message
1809 before the lookahead is translated. */
1810 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1811
1812 YYPOPSTACK (yylen);
1813 yylen = 0;
1814 YY_STACK_PRINT (yyss, yyssp);
1815
1816 *++yyvsp = yyval;]b4_locations_if([
1817 *++yylsp = yyloc;])[
1818
1819 /* Now `shift' the result of the reduction. Determine what state
1820 that goes to, based on the state we popped back to and the rule
1821 number reduced by. */
1822
1823 yyn = yyr1[yyn];
1824
1825 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1826 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1827 yystate = yytable[yystate];
1828 else
1829 yystate = yydefgoto[yyn - YYNTOKENS];
1830
1831 goto yynewstate;
1832
1833
1834 /*------------------------------------.
1835 | yyerrlab -- here on detecting error |
1836 `------------------------------------*/
1837 yyerrlab:
1838 /* Make sure we have latest lookahead translation. See comments at
1839 user semantic actions for why this is necessary. */
1840 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1841
1842 /* If not already recovering from an error, report this error. */
1843 if (!yyerrstatus)
1844 {
1845 ++yynerrs;
1846 #if ! YYERROR_VERBOSE
1847 yyerror (]b4_yyerror_args[YY_("syntax error"));
1848 #else
1849 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \]b4_lac_if([[
1850 yyesa, &yyes, &yyes_capacity, \]])[
1851 yyssp, yytoken)
1852 {
1853 char const *yymsgp = YY_("syntax error");
1854 int yysyntax_error_status;]b4_lac_if([[
1855 if (yychar != YYEMPTY)
1856 YY_LAC_ESTABLISH;]])[
1857 yysyntax_error_status = YYSYNTAX_ERROR;
1858 if (yysyntax_error_status == 0)
1859 yymsgp = yymsg;
1860 else if (yysyntax_error_status == 1)
1861 {
1862 if (yymsg != yymsgbuf)
1863 YYSTACK_FREE (yymsg);
1864 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1865 if (!yymsg)
1866 {
1867 yymsg = yymsgbuf;
1868 yymsg_alloc = sizeof yymsgbuf;
1869 yysyntax_error_status = 2;
1870 }
1871 else
1872 {
1873 yysyntax_error_status = YYSYNTAX_ERROR;
1874 yymsgp = yymsg;
1875 }
1876 }
1877 yyerror (]b4_yyerror_args[yymsgp);
1878 if (yysyntax_error_status == 2)
1879 goto yyexhaustedlab;
1880 }
1881 # undef YYSYNTAX_ERROR
1882 #endif
1883 }
1884
1885 ]b4_locations_if([[ yyerror_range[1] = yylloc;]])[
1886
1887 if (yyerrstatus == 3)
1888 {
1889 /* If just tried and failed to reuse lookahead token after an
1890 error, discard it. */
1891
1892 if (yychar <= YYEOF)
1893 {
1894 /* Return failure if at end of input. */
1895 if (yychar == YYEOF)
1896 YYABORT;
1897 }
1898 else
1899 {
1900 yydestruct ("Error: discarding",
1901 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1902 yychar = YYEMPTY;
1903 }
1904 }
1905
1906 /* Else will try to reuse lookahead token after shifting the error
1907 token. */
1908 goto yyerrlab1;
1909
1910
1911 /*---------------------------------------------------.
1912 | yyerrorlab -- error raised explicitly by YYERROR. |
1913 `---------------------------------------------------*/
1914 yyerrorlab:
1915
1916 /* Pacify compilers like GCC when the user code never invokes
1917 YYERROR and the label yyerrorlab therefore never appears in user
1918 code. */
1919 if (/*CONSTCOND*/ 0)
1920 goto yyerrorlab;
1921
1922 ]b4_locations_if([[ yyerror_range[1] = yylsp[1-yylen];
1923 ]])[ /* Do not reclaim the symbols of the rule which action triggered
1924 this YYERROR. */
1925 YYPOPSTACK (yylen);
1926 yylen = 0;
1927 YY_STACK_PRINT (yyss, yyssp);
1928 yystate = *yyssp;
1929 goto yyerrlab1;
1930
1931
1932 /*-------------------------------------------------------------.
1933 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1934 `-------------------------------------------------------------*/
1935 yyerrlab1:
1936 yyerrstatus = 3; /* Each real token shifted decrements this. */
1937
1938 for (;;)
1939 {
1940 yyn = yypact[yystate];
1941 if (!yypact_value_is_default (yyn))
1942 {
1943 yyn += YYTERROR;
1944 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1945 {
1946 yyn = yytable[yyn];
1947 if (0 < yyn)
1948 break;
1949 }
1950 }
1951
1952 /* Pop the current state because it cannot handle the error token. */
1953 if (yyssp == yyss)
1954 YYABORT;
1955
1956 ]b4_locations_if([[ yyerror_range[1] = *yylsp;]])[
1957 yydestruct ("Error: popping",
1958 yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1959 YYPOPSTACK (1);
1960 yystate = *yyssp;
1961 YY_STACK_PRINT (yyss, yyssp);
1962 }]b4_lac_if([[
1963
1964 /* If the stack popping above didn't lose the initial context for the
1965 current lookahead token, the shift below will for sure. */
1966 YY_LAC_DISCARD ("error recovery");]])[
1967
1968 *++yyvsp = yylval;
1969 ]b4_locations_if([[
1970 yyerror_range[2] = yylloc;
1971 /* Using YYLLOC is tempting, but would change the location of
1972 the lookahead. YYLOC is available though. */
1973 YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
1974 *++yylsp = yyloc;]])[
1975
1976 /* Shift the error token. */
1977 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1978
1979 yystate = yyn;
1980 goto yynewstate;
1981
1982
1983 /*-------------------------------------.
1984 | yyacceptlab -- YYACCEPT comes here. |
1985 `-------------------------------------*/
1986 yyacceptlab:
1987 yyresult = 0;
1988 goto yyreturn;
1989
1990 /*-----------------------------------.
1991 | yyabortlab -- YYABORT comes here. |
1992 `-----------------------------------*/
1993 yyabortlab:
1994 yyresult = 1;
1995 goto yyreturn;
1996
1997 #if ]b4_lac_if([[1]], [[!defined yyoverflow || YYERROR_VERBOSE]])[
1998 /*-------------------------------------------------.
1999 | yyexhaustedlab -- memory exhaustion comes here. |
2000 `-------------------------------------------------*/
2001 yyexhaustedlab:
2002 yyerror (]b4_yyerror_args[YY_("memory exhausted"));
2003 yyresult = 2;
2004 /* Fall through. */
2005 #endif
2006
2007 yyreturn:
2008 if (yychar != YYEMPTY)
2009 {
2010 /* Make sure we have latest lookahead translation. See comments at
2011 user semantic actions for why this is necessary. */
2012 yytoken = YYTRANSLATE (yychar);
2013 yydestruct ("Cleanup: discarding lookahead",
2014 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
2015 }
2016 /* Do not reclaim the symbols of the rule which action triggered
2017 this YYABORT or YYACCEPT. */
2018 YYPOPSTACK (yylen);
2019 YY_STACK_PRINT (yyss, yyssp);
2020 while (yyssp != yyss)
2021 {
2022 yydestruct ("Cleanup: popping",
2023 yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
2024 YYPOPSTACK (1);
2025 }
2026 #ifndef yyoverflow
2027 if (yyss != yyssa)
2028 YYSTACK_FREE (yyss);
2029 #endif]b4_lac_if([[
2030 if (yyes != yyesa)
2031 YYSTACK_FREE (yyes);]])b4_push_if([[
2032 yyps->yynew = 1;
2033
2034 yypushreturn:]])[
2035 #if YYERROR_VERBOSE
2036 if (yymsg != yymsgbuf)
2037 YYSTACK_FREE (yymsg);
2038 #endif
2039 /* Make sure YYID is used. */
2040 return YYID (yyresult);
2041 }
2042
2043
2044 ]b4_epilogue
2045 b4_defines_if(
2046 [@output(b4_spec_defines_file@)@
2047 b4_copyright([Bison interface for Yacc-like parsers in C],
2048 [1984, 1989-1990, 2000-2012])[
2049
2050 ]b4_shared_declarations[
2051 ]])dnl b4_defines_if
2052 m4_divert_pop(0)
bison