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


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