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


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