]> git.saurik.com Git - bison.git/blob - data/yacc.c
projects / bison.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Remove dead code.
[bison.git] / data / yacc.c
1 -*- C -*-
2 # Yacc compatible skeleton for Bison
3
4 # Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
5 # 2007, 2008, 2009 Free Software Foundation, Inc.
6
7 m4_pushdef([b4_copyright_years],
8 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
9 2007, 2008, 2009])
10
11 # This program is free software: you can redistribute it and/or modify
12 # it under the terms of the GNU General Public License as published by
13 # the Free Software Foundation, either version 3 of the License, or
14 # (at your option) any later version.
15 #
16 # This program is distributed in the hope that it will be useful,
17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 # GNU General Public License for more details.
20 #
21 # You should have received a copy of the GNU General Public License
22 # along with this program. If not, see <http://www.gnu.org/licenses/>.
23
24 # Check the value of %define api.push-pull.
25 b4_percent_define_default([[api.push-pull]], [[pull]])
26 b4_percent_define_check_values([[[[api.push-pull]],
27 [[pull]], [[push]], [[both]]]])
28 b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]])
29 b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]])
30 m4_case(b4_percent_define_get([[api.push-pull]]),
31 [pull], [m4_define([b4_push_flag], [[0]])],
32 [push], [m4_define([b4_pull_flag], [[0]])])
33
34 # Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing
35 # tests function as written, don't let BISON_USE_PUSH_FOR_PULL modify Bison's
36 # behavior at all when push parsing is already requested.
37 b4_define_flag_if([use_push_for_pull])
38 b4_use_push_for_pull_if([
39 b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])],
40 [m4_define([b4_push_flag], [[1]])])])
41
42 m4_include(b4_pkgdatadir/[c.m4])
43
44 ## ---------------- ##
45 ## Default values. ##
46 ## ---------------- ##
47
48 # Stack parameters.
49 m4_define_default([b4_stack_depth_max], [10000])
50 m4_define_default([b4_stack_depth_init], [200])
51
52
53 ## ------------------------ ##
54 ## Pure/impure interfaces. ##
55 ## ------------------------ ##
56
57 b4_percent_define_default([[api.pure]], [[false]])
58 b4_define_flag_if([pure])
59 m4_define([b4_pure_flag],
60 [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])
61
62 # b4_yacc_pure_if(IF-TRUE, IF-FALSE)
63 # ----------------------------------
64 # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
65 m4_define([b4_yacc_pure_if],
66 [b4_pure_if([m4_ifset([b4_parse_param],
67 [$1], [$2])],
68 [$2])])
69
70
71 # b4_yyerror_args
72 # ---------------
73 # Arguments passed to yyerror: user args plus yylloc.
74 m4_define([b4_yyerror_args],
75 [b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl
76 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
77
78
79 # b4_lex_param
80 # ------------
81 # Accumulate in b4_lex_param all the yylex arguments.
82 # b4_lex_param arrives quoted twice, but we want to keep only one level.
83 m4_define([b4_lex_param],
84 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
85 b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
86 m4_ifdef([b4_lex_param], b4_lex_param)))
87
88
89 ## ------------ ##
90 ## Data Types. ##
91 ## ------------ ##
92
93 # b4_int_type(MIN, MAX)
94 # ---------------------
95 # Return the smallest int type able to handle numbers ranging from
96 # MIN to MAX (included). Overwrite the version from c.m4, which
97 # uses only C89 types, so that the user can override the shorter
98 # types, and so that pre-C89 compilers are handled correctly.
99 m4_define([b4_int_type],
100 [m4_if(b4_ints_in($@, [0], [255]), [1], [yytype_uint8],
101 b4_ints_in($@, [-128], [127]), [1], [yytype_int8],
102
103 b4_ints_in($@, [0], [65535]), [1], [yytype_uint16],
104 b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16],
105
106 m4_eval([0 <= $1]), [1], [unsigned int],
107
108 [int])])
109
110
111 ## ----------------- ##
112 ## Semantic Values. ##
113 ## ----------------- ##
114
115
116 # b4_lhs_value([TYPE])
117 # --------------------
118 # Expansion of $<TYPE>$.
119 m4_define([b4_lhs_value],
120 [b4_symbol_value(yyval, [$1])])
121
122
123 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
124 # --------------------------------------
125 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
126 # symbols on RHS.
127 m4_define([b4_rhs_value],
128 [b4_symbol_value([yyvsp@{b4_subtract([$2], [$1])@}], [$3])])
129
130
131
132 ## ----------- ##
133 ## Locations. ##
134 ## ----------- ##
135
136 # b4_lhs_location()
137 # -----------------
138 # Expansion of @$.
139 m4_define([b4_lhs_location],
140 [(yyloc)])
141
142
143 # b4_rhs_location(RULE-LENGTH, NUM)
144 # ---------------------------------
145 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
146 # on RHS.
147 m4_define([b4_rhs_location],
148 [(yylsp@{b4_subtract([$2], [$1])@})])
149
150
151 ## ------------------ ##
152 ## Parser variables. ##
153 ## ------------------ ##
154
155 # b4_declare_scanner_communication_variables
156 # ------------------------------------------
157 # Declare the variables that are global, or local to YYPARSE if
158 # pure-parser.
159 m4_define([b4_declare_scanner_communication_variables], [[
160 /* The lookahead symbol. */
161 int yychar;
162
163 /* The semantic value of the lookahead symbol. */
164 YYSTYPE yylval;]b4_locations_if([[
165
166 /* Location data for the lookahead symbol. */
167 YYLTYPE yylloc;]])b4_pure_if([], [[
168
169 /* Number of syntax errors so far. */
170 int yynerrs;]])])
171
172
173 # b4_declare_parser_state_variables
174 # ---------------------------------
175 # Declare all the variables that are needed to maintain the parser state
176 # between calls to yypush_parse.
177 m4_define([b4_declare_parser_state_variables], [b4_pure_if([[
178 /* Number of syntax errors so far. */
179 int yynerrs;
180 ]])[
181 int yystate;
182 /* Number of tokens to shift before error messages enabled. */
183 int yyerrstatus;
184
185 /* The stacks and their tools:
186 `yyss': related to states.
187 `yyvs': related to semantic values.]b4_locations_if([[
188 `yyls': related to locations.]])[
189
190 Refer to the stacks thru separate pointers, to allow yyoverflow
191 to reallocate them elsewhere. */
192
193 /* The state stack. */
194 yytype_int16 yyssa[YYINITDEPTH];
195 yytype_int16 *yyss;
196 yytype_int16 *yyssp;
197
198 /* The semantic value stack. */
199 YYSTYPE yyvsa[YYINITDEPTH];
200 YYSTYPE *yyvs;
201 YYSTYPE *yyvsp;]b4_locations_if([[
202
203 /* The location stack. */
204 YYLTYPE yylsa[YYINITDEPTH];
205 YYLTYPE *yyls;
206 YYLTYPE *yylsp;
207
208 /* The locations where the error started and ended. */
209 YYLTYPE yyerror_range[2];]])[
210
211 YYSIZE_T yystacksize;]])
212
213
214 ## --------------------------------------------------------- ##
215 ## Defining symbol actions, e.g., printers and destructors. ##
216 ## --------------------------------------------------------- ##
217
218 # We do want M4 expansion after # for CPP macros.
219 m4_changecom()
220 m4_divert_push(0)dnl
221 @output(b4_parser_file_name@)@
222 b4_copyright([Implementation for Bison's Yacc-like parsers in C])[
223
224 /* C LALR(1) parser skeleton written by Richard Stallman, by
225 simplifying the original so-called "semantic" parser. */
226
227 /* All symbols defined below should begin with yy or YY, to avoid
228 infringing on user name space. This should be done even for local
229 variables, as they might otherwise be expanded by user macros.
230 There are some unavoidable exceptions within include files to
231 define necessary library symbols; they are noted "INFRINGES ON
232 USER NAME SPACE" below. */
233
234 ]b4_identification
235 b4_percent_code_get([[top]])[]dnl
236 m4_if(b4_prefix, [yy], [],
237 [[/* Substitute the variable and function names. */]b4_pull_if([[
238 #define yyparse ]b4_prefix[parse]])b4_push_if([[
239 #define yypush_parse ]b4_prefix[push_parse]b4_pull_if([[
240 #define yypull_parse ]b4_prefix[pull_parse]])[
241 #define yypstate_new ]b4_prefix[pstate_new
242 #define yypstate_delete ]b4_prefix[pstate_delete
243 #define yypstate ]b4_prefix[pstate]])[
244 #define yylex ]b4_prefix[lex
245 #define yyerror ]b4_prefix[error
246 #define yylval ]b4_prefix[lval
247 #define yychar ]b4_prefix[char
248 #define yydebug ]b4_prefix[debug
249 #define yynerrs ]b4_prefix[nerrs
250 ]b4_locations_if([[#define yylloc ]b4_prefix[lloc]])])[
251
252 /* Copy the first part of user declarations. */
253 ]b4_user_pre_prologue[
254
255 /* Enabling traces. */
256 #ifndef YYDEBUG
257 # define YYDEBUG ]b4_parse_trace_if([1], [0])[
258 #endif
259
260 /* Enabling verbose error messages. */
261 #ifdef YYERROR_VERBOSE
262 # undef YYERROR_VERBOSE
263 # define YYERROR_VERBOSE 1
264 #else
265 # define YYERROR_VERBOSE ]b4_error_verbose_if([1], [0])[
266 #endif
267
268 /* Enabling the token table. */
269 #ifndef YYTOKEN_TABLE
270 # define YYTOKEN_TABLE ]b4_token_table[
271 #endif
272
273 ]b4_percent_code_get([[requires]])[]dnl
274
275 b4_token_enums_defines(b4_tokens)[
276
277 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
278 ]m4_ifdef([b4_stype],
279 [[typedef union ]b4_union_name[
280 {
281 ]b4_user_stype[
282 } YYSTYPE;
283 # define YYSTYPE_IS_TRIVIAL 1]],
284 [m4_if(b4_tag_seen_flag, 0,
285 [[typedef int YYSTYPE;
286 # define YYSTYPE_IS_TRIVIAL 1]])])[
287 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
288 # define YYSTYPE_IS_DECLARED 1
289 #endif]b4_locations_if([[
290
291 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
292 typedef struct YYLTYPE
293 {
294 int first_line;
295 int first_column;
296 int last_line;
297 int last_column;
298 } YYLTYPE;
299 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
300 # define YYLTYPE_IS_DECLARED 1
301 # define YYLTYPE_IS_TRIVIAL 1
302 #endif]])b4_push_if([[
303
304 #ifndef YYPUSH_DECLS
305 # define YYPUSH_DECLS
306 struct yypstate;
307 typedef struct yypstate yypstate;
308 enum { YYPUSH_MORE = 4 };
309
310 ]b4_pull_if([b4_c_function_decl([[yyparse]], [[int]], b4_parse_param)
311 ])b4_c_function_decl([[yypush_parse]], [[int]],
312 [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
313 [[[int yypushed_char]], [[yypushed_char]]],
314 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
315 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
316 b4_parse_param]))
317 b4_pull_if([b4_c_function_decl([[yypull_parse]], [[int]],
318 [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
319 b4_parse_param]))])
320 b4_c_function_decl([[yypstate_new]], [[yypstate *]], [[[void]], []])
321 b4_c_function_decl([[yypstate_delete]], [[void]],
322 [[[yypstate *yyps]], [[yyps]]])[
323 #endif]])
324
325 b4_percent_code_get([[provides]])[]dnl
326
327 [/* Copy the second part of user declarations. */
328 ]b4_user_post_prologue
329 b4_percent_code_get[]dnl
330
331 [#ifdef short
332 # undef short
333 #endif
334
335 #ifdef YYTYPE_UINT8
336 typedef YYTYPE_UINT8 yytype_uint8;
337 #else
338 typedef unsigned char yytype_uint8;
339 #endif
340
341 #ifdef YYTYPE_INT8
342 typedef YYTYPE_INT8 yytype_int8;
343 #elif ]b4_c_modern[
344 typedef signed char yytype_int8;
345 #else
346 typedef short int yytype_int8;
347 #endif
348
349 #ifdef YYTYPE_UINT16
350 typedef YYTYPE_UINT16 yytype_uint16;
351 #else
352 typedef unsigned short int yytype_uint16;
353 #endif
354
355 #ifdef YYTYPE_INT16
356 typedef YYTYPE_INT16 yytype_int16;
357 #else
358 typedef short int yytype_int16;
359 #endif
360
361 #ifndef YYSIZE_T
362 # ifdef __SIZE_TYPE__
363 # define YYSIZE_T __SIZE_TYPE__
364 # elif defined size_t
365 # define YYSIZE_T size_t
366 # elif ! defined YYSIZE_T && ]b4_c_modern[
367 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
368 # define YYSIZE_T size_t
369 # else
370 # define YYSIZE_T unsigned int
371 # endif
372 #endif
373
374 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
375
376 #ifndef YY_
377 # if YYENABLE_NLS
378 # if ENABLE_NLS
379 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
380 # define YY_(msgid) dgettext ("bison-runtime", msgid)
381 # endif
382 # endif
383 # ifndef YY_
384 # define YY_(msgid) msgid
385 # endif
386 #endif
387
388 /* Suppress unused-variable warnings by "using" E. */
389 #if ! defined lint || defined __GNUC__
390 # define YYUSE(e) ((void) (e))
391 #else
392 # define YYUSE(e) /* empty */
393 #endif
394
395 /* Identity function, used to suppress warnings about constant conditions. */
396 #ifndef lint
397 # define YYID(n) (n)
398 #else
399 ]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[
400 {
401 return yyi;
402 }
403 #endif
404
405 #if ! defined yyoverflow || YYERROR_VERBOSE
406
407 ]b4_push_if([],
408 [[/* The parser invokes alloca or malloc; define the necessary symbols. */
409
410 # ifdef YYSTACK_USE_ALLOCA
411 # if YYSTACK_USE_ALLOCA
412 # ifdef __GNUC__
413 # define YYSTACK_ALLOC __builtin_alloca
414 # elif defined __BUILTIN_VA_ARG_INCR
415 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
416 # elif defined _AIX
417 # define YYSTACK_ALLOC __alloca
418 # elif defined _MSC_VER
419 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
420 # define alloca _alloca
421 # else
422 # define YYSTACK_ALLOC alloca
423 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && ]b4_c_modern[
424 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
425 # ifndef _STDLIB_H
426 # define _STDLIB_H 1
427 # endif
428 # endif
429 # endif
430 # endif
431 # endif
432
433 ]])dnl
434 [# ifdef YYSTACK_ALLOC
435 /* Pacify GCC's `empty if-body' warning. */
436 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
437 # ifndef YYSTACK_ALLOC_MAXIMUM
438 /* The OS might guarantee only one guard page at the bottom of the stack,
439 and a page size can be as small as 4096 bytes. So we cannot safely
440 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
441 to allow for a few compiler-allocated temporary stack slots. */
442 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
443 # endif
444 # else
445 # define YYSTACK_ALLOC YYMALLOC
446 # define YYSTACK_FREE YYFREE
447 # ifndef YYSTACK_ALLOC_MAXIMUM
448 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
449 # endif
450 # if (defined __cplusplus && ! defined _STDLIB_H \
451 && ! ((defined YYMALLOC || defined malloc) \
452 && (defined YYFREE || defined free)))
453 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
454 # ifndef _STDLIB_H
455 # define _STDLIB_H 1
456 # endif
457 # endif
458 # ifndef YYMALLOC
459 # define YYMALLOC malloc
460 # if ! defined malloc && ! defined _STDLIB_H && ]b4_c_modern[
461 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
462 # endif
463 # endif
464 # ifndef YYFREE
465 # define YYFREE free
466 # if ! defined free && ! defined _STDLIB_H && ]b4_c_modern[
467 void free (void *); /* INFRINGES ON USER NAME SPACE */
468 # endif
469 # endif
470 # endif
471 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
472
473
474 #if (! defined yyoverflow \
475 && (! defined __cplusplus \
476 || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
477 && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
478
479 /* A type that is properly aligned for any stack member. */
480 union yyalloc
481 {
482 yytype_int16 yyss_alloc;
483 YYSTYPE yyvs_alloc;]b4_locations_if([
484 YYLTYPE yyls_alloc;])[
485 };
486
487 /* The size of the maximum gap between one aligned stack and the next. */
488 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
489
490 /* The size of an array large to enough to hold all stacks, each with
491 N elements. */
492 ]b4_locations_if(
493 [# define YYSTACK_BYTES(N) \
494 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
495 + 2 * YYSTACK_GAP_MAXIMUM)],
496 [# define YYSTACK_BYTES(N) \
497 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
498 + YYSTACK_GAP_MAXIMUM)])[
499
500 /* Copy COUNT objects from FROM to TO. The source and destination do
501 not overlap. */
502 # ifndef YYCOPY
503 # if defined __GNUC__ && 1 < __GNUC__
504 # define YYCOPY(To, From, Count) \
505 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
506 # else
507 # define YYCOPY(To, From, Count) \
508 do \
509 { \
510 YYSIZE_T yyi; \
511 for (yyi = 0; yyi < (Count); yyi++) \
512 (To)[yyi] = (From)[yyi]; \
513 } \
514 while (YYID (0))
515 # endif
516 # endif
517
518 /* Relocate STACK from its old location to the new one. The
519 local variables YYSIZE and YYSTACKSIZE give the old and new number of
520 elements in the stack, and YYPTR gives the new location of the
521 stack. Advance YYPTR to a properly aligned location for the next
522 stack. */
523 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
524 do \
525 { \
526 YYSIZE_T yynewbytes; \
527 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
528 Stack = &yyptr->Stack_alloc; \
529 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
530 yyptr += yynewbytes / sizeof (*yyptr); \
531 } \
532 while (YYID (0))
533
534 #endif
535
536 /* YYFINAL -- State number of the termination state. */
537 #define YYFINAL ]b4_final_state_number[
538 /* YYLAST -- Last index in YYTABLE. */
539 #define YYLAST ]b4_last[
540
541 /* YYNTOKENS -- Number of terminals. */
542 #define YYNTOKENS ]b4_tokens_number[
543 /* YYNNTS -- Number of nonterminals. */
544 #define YYNNTS ]b4_nterms_number[
545 /* YYNRULES -- Number of rules. */
546 #define YYNRULES ]b4_rules_number[
547 /* YYNSTATES -- Number of states. */
548 #define YYNSTATES ]b4_states_number[
549
550 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
551 by yylex, with out-of-bounds checking. */
552 #define YYUNDEFTOK ]b4_undef_token_number[
553 #define YYMAXUTOK ]b4_user_token_number_max[
554
555 #define YYTRANSLATE(YYX) \
556 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
557
558 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
559 as returned by yylex, without out-of-bounds checking. */
560 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
561 {
562 ]b4_translate[
563 };
564
565 #if YYDEBUG
566 ]b4_integral_parser_table_define([rline], [b4_rline],
567 [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[
568 #endif
569
570 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
571 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
572 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
573 static const char *const yytname[] =
574 {
575 ]b4_tname[
576 };
577 #endif
578
579 # ifdef YYPRINT
580 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
581 (internal) symbol number NUM (which must be that of a token). */
582 static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
583 {
584 ]b4_toknum[
585 };
586 # endif
587
588 #define YYPACT_NINF ]b4_pact_ninf[
589
590 #define yypact_value_is_default(yystate) \
591 ]b4_table_value_equals([[pact]], [[yystate]], [b4_pact_ninf])[
592
593 #define YYTABLE_NINF ]b4_table_ninf[
594
595 #define yytable_value_is_error(yytable_value) \
596 ]b4_table_value_equals([[table]], [[yytable_value]], [b4_table_ninf])[
597
598 ]b4_parser_tables_define[
599
600 #define yyerrok (yyerrstatus = 0)
601 #define yyclearin (yychar = YYEMPTY)
602 #define YYEMPTY (-2)
603 #define YYEOF 0
604
605 #define YYACCEPT goto yyacceptlab
606 #define YYABORT goto yyabortlab
607 #define YYERROR goto yyerrorlab
608
609
610 /* Like YYERROR except do call yyerror. This remains here temporarily
611 to ease the transition to the new meaning of YYERROR, for GCC.
612 Once GCC version 2 has supplanted version 1, this can go. */
613
614 #define YYFAIL goto yyerrlab
615
616 #define YYRECOVERING() (!!yyerrstatus)
617
618 #define YYBACKUP(Token, Value) \
619 do \
620 if (yychar == YYEMPTY && yylen == 1) \
621 { \
622 yychar = (Token); \
623 yylval = (Value); \
624 yytoken = YYTRANSLATE (yychar); \
625 YYPOPSTACK (1); \
626 goto yybackup; \
627 } \
628 else \
629 { \
630 yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
631 YYERROR; \
632 } \
633 while (YYID (0))
634
635
636 #define YYTERROR 1
637 #define YYERRCODE 256
638
639
640 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
641 If N is 0, then set CURRENT to the empty location which ends
642 the previous symbol: RHS[0] (always defined). */
643
644 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
645 #ifndef YYLLOC_DEFAULT
646 # define YYLLOC_DEFAULT(Current, Rhs, N) \
647 do \
648 if (YYID (N)) \
649 { \
650 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
651 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
652 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
653 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
654 } \
655 else \
656 { \
657 (Current).first_line = (Current).last_line = \
658 YYRHSLOC (Rhs, 0).last_line; \
659 (Current).first_column = (Current).last_column = \
660 YYRHSLOC (Rhs, 0).last_column; \
661 } \
662 while (YYID (0))
663 #endif
664
665
666 /* YY_LOCATION_PRINT -- Print the location on the stream.
667 This macro was not mandated originally: define only if we know
668 we won't break user code: when these are the locations we know. */
669
670 #ifndef YY_LOCATION_PRINT
671 # if YYLTYPE_IS_TRIVIAL
672 # define YY_LOCATION_PRINT(File, Loc) \
673 fprintf (File, "%d.%d-%d.%d", \
674 (Loc).first_line, (Loc).first_column, \
675 (Loc).last_line, (Loc).last_column)
676 # else
677 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
678 # endif
679 #endif
680
681
682 /* YYLEX -- calling `yylex' with the right arguments. */
683
684 #ifdef YYLEX_PARAM
685 # define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)
686 #else
687 # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
688 #endif
689
690 /* Enable debugging if requested. */
691 #if YYDEBUG
692
693 # ifndef YYFPRINTF
694 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
695 # define YYFPRINTF fprintf
696 # endif
697
698 # define YYDPRINTF(Args) \
699 do { \
700 if (yydebug) \
701 YYFPRINTF Args; \
702 } while (YYID (0))
703
704 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
705 do { \
706 if (yydebug) \
707 { \
708 YYFPRINTF (stderr, "%s ", Title); \
709 yy_symbol_print (stderr, \
710 Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
711 YYFPRINTF (stderr, "\n"); \
712 } \
713 } while (YYID (0))
714
715 ]b4_yy_symbol_print_generate([b4_c_function_def])[
716
717 /*------------------------------------------------------------------.
718 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
719 | TOP (included). |
720 `------------------------------------------------------------------*/
721
722 ]b4_c_function_def([yy_stack_print], [static void],
723 [[yytype_int16 *yybottom], [yybottom]],
724 [[yytype_int16 *yytop], [yytop]])[
725 {
726 YYFPRINTF (stderr, "Stack now");
727 for (; yybottom <= yytop; yybottom++)
728 {
729 int yybot = *yybottom;
730 YYFPRINTF (stderr, " %d", yybot);
731 }
732 YYFPRINTF (stderr, "\n");
733 }
734
735 # define YY_STACK_PRINT(Bottom, Top) \
736 do { \
737 if (yydebug) \
738 yy_stack_print ((Bottom), (Top)); \
739 } while (YYID (0))
740
741
742 /*------------------------------------------------.
743 | Report that the YYRULE is going to be reduced. |
744 `------------------------------------------------*/
745
746 ]b4_c_function_def([yy_reduce_print], [static void],
747 [[yytype_int16 *yyssp], [yyssp]],
748 [[YYSTYPE *yyvsp], [yyvsp]],
749 b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
750 ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
751 b4_parse_param]))[
752 {
753 unsigned long int yylno = yyrline[yyrule];
754 int yynrhs = yyr2[yyrule];
755 int yyi;
756 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
757 yyrule - 1, yylno);
758 /* The symbols being reduced. */
759 for (yyi = 0; yyi < yynrhs; yyi++)
760 {
761 YYFPRINTF (stderr, " $%d = ", yyi + 1);
762 yy_symbol_print (stderr,
763 yystos[yyssp[yyi + 1 - yynrhs]],
764 &]b4_rhs_value(yynrhs, yyi + 1)[
765 ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
766 b4_user_args[);
767 YYFPRINTF (stderr, "\n");
768 }
769 }
770
771 # define YY_REDUCE_PRINT(Rule) \
772 do { \
773 if (yydebug) \
774 yy_reduce_print (yyssp, yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
775 } while (YYID (0))
776
777 /* Nonzero means print parse trace. It is left uninitialized so that
778 multiple parsers can coexist. */
779 int yydebug;
780 #else /* !YYDEBUG */
781 # define YYDPRINTF(Args)
782 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
783 # define YY_STACK_PRINT(Bottom, Top)
784 # define YY_REDUCE_PRINT(Rule)
785 #endif /* !YYDEBUG */
786
787
788 /* YYINITDEPTH -- initial size of the parser's stacks. */
789 #ifndef YYINITDEPTH
790 # define YYINITDEPTH ]b4_stack_depth_init[
791 #endif
792
793 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
794 if the built-in stack extension method is used).
795
796 Do not make this value too large; the results are undefined if
797 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
798 evaluated with infinite-precision integer arithmetic. */
799
800 #ifndef YYMAXDEPTH
801 # define YYMAXDEPTH ]b4_stack_depth_max[
802 #endif
803
804 \f
805
806 #if YYERROR_VERBOSE
807
808 # ifndef yystrlen
809 # if defined __GLIBC__ && defined _STRING_H
810 # define yystrlen strlen
811 # else
812 /* Return the length of YYSTR. */
813 ]b4_c_function_def([yystrlen], [static YYSIZE_T],
814 [[const char *yystr], [yystr]])[
815 {
816 YYSIZE_T yylen;
817 for (yylen = 0; yystr[yylen]; yylen++)
818 continue;
819 return yylen;
820 }
821 # endif
822 # endif
823
824 # ifndef yystpcpy
825 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
826 # define yystpcpy stpcpy
827 # else
828 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
829 YYDEST. */
830 ]b4_c_function_def([yystpcpy], [static char *],
831 [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[
832 {
833 char *yyd = yydest;
834 const char *yys = yysrc;
835
836 while ((*yyd++ = *yys++) != '\0')
837 continue;
838
839 return yyd - 1;
840 }
841 # endif
842 # endif
843
844 # ifndef yytnamerr
845 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
846 quotes and backslashes, so that it's suitable for yyerror. The
847 heuristic is that double-quoting is unnecessary unless the string
848 contains an apostrophe, a comma, or backslash (other than
849 backslash-backslash). YYSTR is taken from yytname. If YYRES is
850 null, do not copy; instead, return the length of what the result
851 would have been. */
852 static YYSIZE_T
853 yytnamerr (char *yyres, const char *yystr)
854 {
855 if (*yystr == '"')
856 {
857 YYSIZE_T yyn = 0;
858 char const *yyp = yystr;
859
860 for (;;)
861 switch (*++yyp)
862 {
863 case '\'':
864 case ',':
865 goto do_not_strip_quotes;
866
867 case '\\':
868 if (*++yyp != '\\')
869 goto do_not_strip_quotes;
870 /* Fall through. */
871 default:
872 if (yyres)
873 yyres[yyn] = *yyp;
874 yyn++;
875 break;
876
877 case '"':
878 if (yyres)
879 yyres[yyn] = '\0';
880 return yyn;
881 }
882 do_not_strip_quotes: ;
883 }
884
885 if (! yyres)
886 return yystrlen (yystr);
887
888 return yystpcpy (yyres, yystr) - yyres;
889 }
890 # endif
891
892 /* Copy into YYRESULT an error message about the unexpected token
893 YYTOKEN while in state YYSTATE. Return the number of bytes copied,
894 including the terminating null byte. If YYRESULT is null, do not
895 copy anything; just return the number of bytes that would be
896 copied. As a special case, return 0 if an ordinary "syntax error"
897 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
898 size calculation. */
899 static YYSIZE_T
900 yysyntax_error (char *yyresult, int yystate, int yytoken)
901 {
902 int yyn = yypact[yystate];
903
904 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
905 return 0;
906 else
907 {
908 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
909 YYSIZE_T yysize = yysize0;
910 YYSIZE_T yysize1;
911 int yysize_overflow = 0;
912 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
913 /* Internationalized format string. */
914 const char *yyformat = 0;
915 /* Arguments of yyformat. */
916 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
917
918 /* Start YYX at -YYN if negative to avoid negative indexes in
919 YYCHECK. In other words, skip the first -YYN actions for this
920 state because they are default actions. */
921 int yyxbegin = yyn < 0 ? -yyn : 0;
922
923 /* Stay within bounds of both yycheck and yytname. */
924 int yychecklim = YYLAST - yyn + 1;
925 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
926 /* Number of reported tokens (one for the "unexpected", one per
927 "expected"). */
928 int yycount = 0;
929 int yyx;
930
931 yyarg[yycount++] = yytname[yytoken];
932
933 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
934 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
935 && !yytable_value_is_error (yytable[yyx + yyn]))
936 {
937 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
938 {
939 yycount = 1;
940 yysize = yysize0;
941 break;
942 }
943 yyarg[yycount++] = yytname[yyx];
944 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
945 yysize_overflow |= (yysize1 < yysize);
946 yysize = yysize1;
947 }
948
949 switch (yycount)
950 {
951 #define YYCASE_(N, S) \
952 case N: \
953 yyformat = S; \
954 break
955 YYCASE_(1, YY_("syntax error, unexpected %s"));
956 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
957 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
958 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
959 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
960 #undef YYCASE_
961 }
962
963 yysize1 = yysize + yystrlen (yyformat);
964 yysize_overflow |= (yysize1 < yysize);
965 yysize = yysize1;
966
967 if (yysize_overflow)
968 return YYSIZE_MAXIMUM;
969
970 if (yyresult)
971 {
972 /* Avoid sprintf, as that infringes on the user's name space.
973 Don't have undefined behavior even if the translation
974 produced a string with the wrong number of "%s"s. */
975 char *yyp = yyresult;
976 int yyi = 0;
977 while ((*yyp = *yyformat) != '\0')
978 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
979 {
980 yyp += yytnamerr (yyp, yyarg[yyi++]);
981 yyformat += 2;
982 }
983 else
984 {
985 yyp++;
986 yyformat++;
987 }
988 }
989 return yysize;
990 }
991 }
992 #endif /* YYERROR_VERBOSE */
993 \f
994
995 ]b4_yydestruct_generate([b4_c_function_def])b4_push_if([], [[
996
997
998 /* Prevent warnings from -Wmissing-prototypes. */
999 #ifdef YYPARSE_PARAM
1000 ]b4_c_function_decl([yyparse], [int],
1001 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
1002 #else /* ! YYPARSE_PARAM */
1003 ]b4_c_function_decl([yyparse], [int], b4_parse_param)[
1004 #endif /* ! YYPARSE_PARAM */]])b4_pure_if([], [
1005
1006 b4_declare_scanner_communication_variables])[]b4_push_if([[
1007
1008
1009 struct yypstate
1010 {]b4_declare_parser_state_variables[
1011 /* Used to determine if this is the first time this instance has
1012 been used. */
1013 int yynew;
1014 };]b4_pure_if([], [[
1015
1016 static char yypstate_allocated = 0;]])b4_pull_if([
1017
1018 b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
1019 {
1020 return yypull_parse (0]m4_ifset([b4_parse_param],
1021 [[, ]b4_c_args(b4_parse_param)])[);
1022 }
1023
1024 ]b4_c_function_def([[yypull_parse]], [[int]],
1025 [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1026 b4_parse_param]))[
1027 {
1028 int yystatus;
1029 yypstate *yyps_local;]b4_pure_if([[
1030 int yychar;
1031 YYSTYPE yylval;]b4_locations_if([[
1032 YYLTYPE yylloc;]])])[
1033 if (yyps == 0)
1034 {
1035 yyps_local = yypstate_new ();
1036 if (!yyps_local)
1037 {]b4_pure_if([[
1038 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
1039 if (!yypstate_allocated)
1040 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
1041 return 2;
1042 }
1043 }
1044 else
1045 yyps_local = yyps;
1046 do {
1047 yychar = YYLEX;
1048 yystatus =
1049 yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
1050 } while (yystatus == YYPUSH_MORE);
1051 if (yyps == 0)
1052 yypstate_delete (yyps_local);
1053 return yystatus;
1054 }]])[
1055
1056 /* Initialize the parser data structure. */
1057 ]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
1058 {
1059 yypstate *yyps;]b4_pure_if([], [[
1060 if (yypstate_allocated)
1061 return 0;]])[
1062 yyps = (yypstate *) malloc (sizeof *yyps);
1063 if (!yyps)
1064 return 0;
1065 yyps->yynew = 1;]b4_pure_if([], [[
1066 yypstate_allocated = 1;]])[
1067 return yyps;
1068 }
1069
1070 ]b4_c_function_def([[yypstate_delete]], [[void]],
1071 [[[yypstate *yyps]], [[yyps]]])[
1072 {
1073 #ifndef yyoverflow
1074 /* If the stack was reallocated but the parse did not complete, then the
1075 stack still needs to be freed. */
1076 if (!yyps->yynew && yyps->yyss != yyps->yyssa)
1077 YYSTACK_FREE (yyps->yyss);
1078 #endif
1079 free (yyps);]b4_pure_if([], [[
1080 yypstate_allocated = 0;]])[
1081 }
1082 ]b4_pure_if([[
1083 #define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs]])[
1084 #define yystate yyps->yystate
1085 #define yyerrstatus yyps->yyerrstatus
1086 #define yyssa yyps->yyssa
1087 #define yyss yyps->yyss
1088 #define yyssp yyps->yyssp
1089 #define yyvsa yyps->yyvsa
1090 #define yyvs yyps->yyvs
1091 #define yyvsp yyps->yyvsp]b4_locations_if([[
1092 #define yylsa yyps->yylsa
1093 #define yyls yyps->yyls
1094 #define yylsp yyps->yylsp
1095 #define yyerror_range yyps->yyerror_range]])[
1096 #define yystacksize yyps->yystacksize
1097
1098
1099 /*---------------.
1100 | yypush_parse. |
1101 `---------------*/
1102
1103 ]b4_c_function_def([[yypush_parse]], [[int]],
1104 [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
1105 [[[int yypushed_char]], [[yypushed_char]]],
1106 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1107 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1108 b4_parse_param]))], [[
1109
1110
1111 /*----------.
1112 | yyparse. |
1113 `----------*/
1114
1115 #ifdef YYPARSE_PARAM
1116 ]b4_c_function_def([yyparse], [int],
1117 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
1118 #else /* ! YYPARSE_PARAM */
1119 ]b4_c_function_def([yyparse], [int], b4_parse_param)[
1120 #endif]])[
1121 {]b4_pure_if([b4_declare_scanner_communication_variables
1122 ])b4_push_if([b4_pure_if([], [[
1123 int yypushed_char = yychar;
1124 YYSTYPE yypushed_val = yylval;]b4_locations_if([[
1125 YYLTYPE yypushed_loc = yylloc;]])
1126 ])],
1127 [b4_declare_parser_state_variables
1128 ])[
1129 int yyn;
1130 int yyresult;
1131 /* Lookahead token as an internal (translated) token number. */
1132 int yytoken;
1133 /* The variables used to return semantic value and location from the
1134 action routines. */
1135 YYSTYPE yyval;]b4_locations_if([[
1136 YYLTYPE yyloc;]])[
1137
1138 #if YYERROR_VERBOSE
1139 /* Buffer for error messages, and its allocated size. */
1140 char yymsgbuf[128];
1141 char *yymsg = yymsgbuf;
1142 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1143 #endif
1144
1145 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
1146
1147 /* The number of symbols on the RHS of the reduced rule.
1148 Keep to zero when no symbol should be popped. */
1149 int yylen = 0;]b4_push_if([[
1150
1151 if (!yyps->yynew)
1152 {
1153 yyn = yypact[yystate];
1154 goto yyread_pushed_token;
1155 }]])[
1156
1157 yytoken = 0;
1158 yyss = yyssa;
1159 yyvs = yyvsa;]b4_locations_if([[
1160 yyls = yylsa;]])[
1161 yystacksize = YYINITDEPTH;
1162
1163 YYDPRINTF ((stderr, "Starting parse\n"));
1164
1165 yystate = 0;
1166 yyerrstatus = 0;
1167 yynerrs = 0;
1168 yychar = YYEMPTY; /* Cause a token to be read. */
1169
1170 /* Initialize stack pointers.
1171 Waste one element of value and location stack
1172 so that they stay on the same level as the state stack.
1173 The wasted elements are never initialized. */
1174 yyssp = yyss;
1175 yyvsp = yyvs;]b4_locations_if([[
1176 yylsp = yyls;
1177
1178 #if YYLTYPE_IS_TRIVIAL
1179 /* Initialize the default location before parsing starts. */
1180 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
1181 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
1182 #endif]])
1183 m4_ifdef([b4_initial_action],[
1184 m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl
1185 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
1186 /* User initialization code. */
1187 b4_user_initial_action
1188 m4_popdef([b4_dollar_dollar])dnl
1189 m4_popdef([b4_at_dollar])])dnl
1190 m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval;
1191 ]])dnl
1192 m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc;
1193 ]])[
1194 goto yysetstate;
1195
1196 /*------------------------------------------------------------.
1197 | yynewstate -- Push a new state, which is found in yystate. |
1198 `------------------------------------------------------------*/
1199 yynewstate:
1200 /* In all cases, when you get here, the value and location stacks
1201 have just been pushed. So pushing a state here evens the stacks. */
1202 yyssp++;
1203
1204 yysetstate:
1205 *yyssp = yystate;
1206
1207 if (yyss + yystacksize - 1 <= yyssp)
1208 {
1209 /* Get the current used size of the three stacks, in elements. */
1210 YYSIZE_T yysize = yyssp - yyss + 1;
1211
1212 #ifdef yyoverflow
1213 {
1214 /* Give user a chance to reallocate the stack. Use copies of
1215 these so that the &'s don't force the real ones into
1216 memory. */
1217 YYSTYPE *yyvs1 = yyvs;
1218 yytype_int16 *yyss1 = yyss;]b4_locations_if([
1219 YYLTYPE *yyls1 = yyls;])[
1220
1221 /* Each stack pointer address is followed by the size of the
1222 data in use in that stack, in bytes. This used to be a
1223 conditional around just the two extra args, but that might
1224 be undefined if yyoverflow is a macro. */
1225 yyoverflow (YY_("memory exhausted"),
1226 &yyss1, yysize * sizeof (*yyssp),
1227 &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
1228 &yyls1, yysize * sizeof (*yylsp),])[
1229 &yystacksize);
1230 ]b4_locations_if([
1231 yyls = yyls1;])[
1232 yyss = yyss1;
1233 yyvs = yyvs1;
1234 }
1235 #else /* no yyoverflow */
1236 # ifndef YYSTACK_RELOCATE
1237 goto yyexhaustedlab;
1238 # else
1239 /* Extend the stack our own way. */
1240 if (YYMAXDEPTH <= yystacksize)
1241 goto yyexhaustedlab;
1242 yystacksize *= 2;
1243 if (YYMAXDEPTH < yystacksize)
1244 yystacksize = YYMAXDEPTH;
1245
1246 {
1247 yytype_int16 *yyss1 = yyss;
1248 union yyalloc *yyptr =
1249 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1250 if (! yyptr)
1251 goto yyexhaustedlab;
1252 YYSTACK_RELOCATE (yyss_alloc, yyss);
1253 YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
1254 YYSTACK_RELOCATE (yyls_alloc, yyls);])[
1255 # undef YYSTACK_RELOCATE
1256 if (yyss1 != yyssa)
1257 YYSTACK_FREE (yyss1);
1258 }
1259 # endif
1260 #endif /* no yyoverflow */
1261
1262 yyssp = yyss + yysize - 1;
1263 yyvsp = yyvs + yysize - 1;]b4_locations_if([
1264 yylsp = yyls + yysize - 1;])[
1265
1266 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1267 (unsigned long int) yystacksize));
1268
1269 if (yyss + yystacksize - 1 <= yyssp)
1270 YYABORT;
1271 }
1272
1273 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1274
1275 if (yystate == YYFINAL)
1276 YYACCEPT;
1277
1278 goto yybackup;
1279
1280 /*-----------.
1281 | yybackup. |
1282 `-----------*/
1283 yybackup:
1284
1285 /* Do appropriate processing given the current state. Read a
1286 lookahead token if we need one and don't already have one. */
1287
1288 /* First try to decide what to do without reference to lookahead token. */
1289 yyn = yypact[yystate];
1290 if (yypact_value_is_default (yyn))
1291 goto yydefault;
1292
1293 /* Not known => get a lookahead token if don't already have one. */
1294
1295 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1296 if (yychar == YYEMPTY)
1297 {]b4_push_if([[
1298 if (!yyps->yynew)
1299 {]b4_use_push_for_pull_if([], [[
1300 YYDPRINTF ((stderr, "Return for a new token:\n"));]])[
1301 yyresult = YYPUSH_MORE;
1302 goto yypushreturn;
1303 }
1304 yyps->yynew = 0;]b4_pure_if([], [[
1305 /* Restoring the pushed token is only necessary for the first
1306 yypush_parse invocation since subsequent invocations don't overwrite
1307 it before jumping to yyread_pushed_token. */
1308 yychar = yypushed_char;
1309 yylval = yypushed_val;]b4_locations_if([[
1310 yylloc = yypushed_loc;]])])[
1311 yyread_pushed_token:]])[
1312 YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[
1313 yychar = yypushed_char;
1314 if (yypushed_val)
1315 yylval = *yypushed_val;]b4_locations_if([[
1316 if (yypushed_loc)
1317 yylloc = *yypushed_loc;]])])], [[
1318 yychar = YYLEX;]])[
1319 }
1320
1321 if (yychar <= YYEOF)
1322 {
1323 yychar = yytoken = YYEOF;
1324 YYDPRINTF ((stderr, "Now at end of input.\n"));
1325 }
1326 else
1327 {
1328 yytoken = YYTRANSLATE (yychar);
1329 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1330 }
1331
1332 /* If the proper action on seeing token YYTOKEN is to reduce or to
1333 detect an error, take that action. */
1334 yyn += yytoken;
1335 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1336 goto yydefault;
1337 yyn = yytable[yyn];
1338 if (yyn <= 0)
1339 {
1340 if (yytable_value_is_error (yyn))
1341 goto yyerrlab;
1342 yyn = -yyn;
1343 goto yyreduce;
1344 }
1345
1346 /* Count tokens shifted since error; after three, turn off error
1347 status. */
1348 if (yyerrstatus)
1349 yyerrstatus--;
1350
1351 /* Shift the lookahead token. */
1352 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1353
1354 /* Discard the shifted token. */
1355 yychar = YYEMPTY;
1356
1357 yystate = yyn;
1358 *++yyvsp = yylval;
1359 ]b4_locations_if([ *++yylsp = yylloc;])[
1360 goto yynewstate;
1361
1362
1363 /*-----------------------------------------------------------.
1364 | yydefault -- do the default action for the current state. |
1365 `-----------------------------------------------------------*/
1366 yydefault:
1367 yyn = yydefact[yystate];
1368 if (yyn == 0)
1369 goto yyerrlab;
1370 goto yyreduce;
1371
1372
1373 /*-----------------------------.
1374 | yyreduce -- Do a reduction. |
1375 `-----------------------------*/
1376 yyreduce:
1377 /* yyn is the number of a rule to reduce with. */
1378 yylen = yyr2[yyn];
1379
1380 /* If YYLEN is nonzero, implement the default value of the action:
1381 `$$ = $1'.
1382
1383 Otherwise, the following line sets YYVAL to garbage.
1384 This behavior is undocumented and Bison
1385 users should not rely upon it. Assigning to YYVAL
1386 unconditionally makes the parser a bit smaller, and it avoids a
1387 GCC warning that YYVAL may be used uninitialized. */
1388 yyval = yyvsp[1-yylen];
1389
1390 ]b4_locations_if(
1391 [[ /* Default location. */
1392 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
1393 YY_REDUCE_PRINT (yyn);
1394 switch (yyn)
1395 {
1396 ]b4_user_actions[
1397 default: break;
1398 }
1399 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1400
1401 YYPOPSTACK (yylen);
1402 yylen = 0;
1403 YY_STACK_PRINT (yyss, yyssp);
1404
1405 *++yyvsp = yyval;]b4_locations_if([
1406 *++yylsp = yyloc;])[
1407
1408 /* Now `shift' the result of the reduction. Determine what state
1409 that goes to, based on the state we popped back to and the rule
1410 number reduced by. */
1411
1412 yyn = yyr1[yyn];
1413
1414 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1415 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1416 yystate = yytable[yystate];
1417 else
1418 yystate = yydefgoto[yyn - YYNTOKENS];
1419
1420 goto yynewstate;
1421
1422
1423 /*------------------------------------.
1424 | yyerrlab -- here on detecting error |
1425 `------------------------------------*/
1426 yyerrlab:
1427 /* If not already recovering from an error, report this error. */
1428 if (!yyerrstatus)
1429 {
1430 ++yynerrs;
1431 #if ! YYERROR_VERBOSE
1432 yyerror (]b4_yyerror_args[YY_("syntax error"));
1433 #else
1434 {
1435 YYSIZE_T yysize = yysyntax_error (0, yystate, yytoken);
1436 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1437 {
1438 YYSIZE_T yyalloc = 2 * yysize;
1439 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1440 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1441 if (yymsg != yymsgbuf)
1442 YYSTACK_FREE (yymsg);
1443 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1444 if (yymsg)
1445 yymsg_alloc = yyalloc;
1446 else
1447 {
1448 yymsg = yymsgbuf;
1449 yymsg_alloc = sizeof yymsgbuf;
1450 }
1451 }
1452
1453 if (0 < yysize && yysize <= yymsg_alloc)
1454 {
1455 (void) yysyntax_error (yymsg, yystate, yytoken);
1456 yyerror (]b4_yyerror_args[yymsg);
1457 }
1458 else
1459 {
1460 yyerror (]b4_yyerror_args[YY_("syntax error"));
1461 if (yysize != 0)
1462 goto yyexhaustedlab;
1463 }
1464 }
1465 #endif
1466 }
1467
1468 ]b4_locations_if([[ yyerror_range[0] = yylloc;]])[
1469
1470 if (yyerrstatus == 3)
1471 {
1472 /* If just tried and failed to reuse lookahead token after an
1473 error, discard it. */
1474
1475 if (yychar <= YYEOF)
1476 {
1477 /* Return failure if at end of input. */
1478 if (yychar == YYEOF)
1479 YYABORT;
1480 }
1481 else
1482 {
1483 yydestruct ("Error: discarding",
1484 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1485 yychar = YYEMPTY;
1486 }
1487 }
1488
1489 /* Else will try to reuse lookahead token after shifting the error
1490 token. */
1491 goto yyerrlab1;
1492
1493
1494 /*---------------------------------------------------.
1495 | yyerrorlab -- error raised explicitly by YYERROR. |
1496 `---------------------------------------------------*/
1497 yyerrorlab:
1498
1499 /* Pacify compilers like GCC when the user code never invokes
1500 YYERROR and the label yyerrorlab therefore never appears in user
1501 code. */
1502 if (/*CONSTCOND*/ 0)
1503 goto yyerrorlab;
1504
1505 ]b4_locations_if([[ yyerror_range[0] = yylsp[1-yylen];
1506 ]])[ /* Do not reclaim the symbols of the rule which action triggered
1507 this YYERROR. */
1508 YYPOPSTACK (yylen);
1509 yylen = 0;
1510 YY_STACK_PRINT (yyss, yyssp);
1511 yystate = *yyssp;
1512 goto yyerrlab1;
1513
1514
1515 /*-------------------------------------------------------------.
1516 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1517 `-------------------------------------------------------------*/
1518 yyerrlab1:
1519 yyerrstatus = 3; /* Each real token shifted decrements this. */
1520
1521 for (;;)
1522 {
1523 yyn = yypact[yystate];
1524 if (!yypact_value_is_default (yyn))
1525 {
1526 yyn += YYTERROR;
1527 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1528 {
1529 yyn = yytable[yyn];
1530 if (0 < yyn)
1531 break;
1532 }
1533 }
1534
1535 /* Pop the current state because it cannot handle the error token. */
1536 if (yyssp == yyss)
1537 YYABORT;
1538
1539 ]b4_locations_if([[ yyerror_range[0] = *yylsp;]])[
1540 yydestruct ("Error: popping",
1541 yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1542 YYPOPSTACK (1);
1543 yystate = *yyssp;
1544 YY_STACK_PRINT (yyss, yyssp);
1545 }
1546
1547 *++yyvsp = yylval;
1548 ]b4_locations_if([[
1549 yyerror_range[1] = yylloc;
1550 /* Using YYLLOC is tempting, but would change the location of
1551 the lookahead. YYLOC is available though. */
1552 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
1553 *++yylsp = yyloc;]])[
1554
1555 /* Shift the error token. */
1556 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1557
1558 yystate = yyn;
1559 goto yynewstate;
1560
1561
1562 /*-------------------------------------.
1563 | yyacceptlab -- YYACCEPT comes here. |
1564 `-------------------------------------*/
1565 yyacceptlab:
1566 yyresult = 0;
1567 goto yyreturn;
1568
1569 /*-----------------------------------.
1570 | yyabortlab -- YYABORT comes here. |
1571 `-----------------------------------*/
1572 yyabortlab:
1573 yyresult = 1;
1574 goto yyreturn;
1575
1576 #if !defined(yyoverflow) || YYERROR_VERBOSE
1577 /*-------------------------------------------------.
1578 | yyexhaustedlab -- memory exhaustion comes here. |
1579 `-------------------------------------------------*/
1580 yyexhaustedlab:
1581 yyerror (]b4_yyerror_args[YY_("memory exhausted"));
1582 yyresult = 2;
1583 /* Fall through. */
1584 #endif
1585
1586 yyreturn:
1587 if (yychar != YYEMPTY)
1588 yydestruct ("Cleanup: discarding lookahead",
1589 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1590 /* Do not reclaim the symbols of the rule which action triggered
1591 this YYABORT or YYACCEPT. */
1592 YYPOPSTACK (yylen);
1593 YY_STACK_PRINT (yyss, yyssp);
1594 while (yyssp != yyss)
1595 {
1596 yydestruct ("Cleanup: popping",
1597 yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1598 YYPOPSTACK (1);
1599 }
1600 #ifndef yyoverflow
1601 if (yyss != yyssa)
1602 YYSTACK_FREE (yyss);
1603 #endif]b4_push_if([[
1604 yyps->yynew = 1;
1605
1606 yypushreturn:]])[
1607 #if YYERROR_VERBOSE
1608 if (yymsg != yymsgbuf)
1609 YYSTACK_FREE (yymsg);
1610 #endif
1611 /* Make sure YYID is used. */
1612 return YYID (yyresult);
1613 }
1614
1615 ]b4_epilogue[]dnl
1616 b4_defines_if(
1617 [@output(b4_spec_defines_file@)@
1618 b4_copyright([Interface for Bison's Yacc-like parsers in C])dnl
1619
1620 b4_percent_code_get([[requires]])[]dnl
1621
1622 b4_token_enums_defines(b4_tokens)
1623
1624 [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1625 ]m4_ifdef([b4_stype],
1626 [[typedef union ]b4_union_name[
1627 {
1628 ]b4_user_stype[
1629 } YYSTYPE;
1630 # define YYSTYPE_IS_TRIVIAL 1]],
1631 [m4_if(b4_tag_seen_flag, 0,
1632 [[typedef int YYSTYPE;
1633 # define YYSTYPE_IS_TRIVIAL 1]])])[
1634 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1635 # define YYSTYPE_IS_DECLARED 1
1636 #endif
1637
1638 ]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;]])
1639
1640 b4_locations_if(
1641 [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
1642 typedef struct YYLTYPE
1643 {
1644 int first_line;
1645 int first_column;
1646 int last_line;
1647 int last_column;
1648 } YYLTYPE;
1649 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1650 # define YYLTYPE_IS_DECLARED 1
1651 # define YYLTYPE_IS_TRIVIAL 1
1652 #endif
1653
1654 ]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]])
1655 )dnl b4_locations_if
1656 b4_push_if([[
1657 #ifndef YYPUSH_DECLS
1658 # define YYPUSH_DECLS
1659 struct ]b4_prefix[pstate;
1660 typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
1661 enum { YYPUSH_MORE = 4 };
1662 ]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
1663 ])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
1664 [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([,
1665 [[[int yypushed_char]], [[yypushed_char]]],
1666 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1667 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1668 b4_parse_param]))
1669 b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
1670 [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1671 b4_parse_param]))])
1672 b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
1673 [[[void]], []])
1674 b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
1675 [[b4_prefix[pstate *yyps]], [[yyps]]])[
1676 #endif
1677 ]])
1678 b4_percent_code_get([[provides]])[]dnl
1679 ])dnl b4_defines_if
1680 m4_divert_pop(0)
1681 m4_popdef([b4_copyright_years])
bison