]> 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
YYFAIL: warn about uses and remove from lalr1.java.
[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 defined YYENABLE_NLS && 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. However,
613 YYFAIL appears to be in use. Nevertheless, it is formally deprecated
614 in Bison 2.4.2's NEWS entry, where a plan to phase it out is
615 discussed. */
616
617 #define YYFAIL goto yyerrlab
618 #if defined YYFAIL
619 /* This is here to suppress warnings from the GCC cpp's
620 -Wunused-macros. Normally we don't worry about that warning, but
621 some users do, and we want to make it easy for users to remove
622 YYFAIL uses, which will produce warnings from Bison 2.5. */
623 #endif
624
625 #define YYRECOVERING() (!!yyerrstatus)
626
627 #define YYBACKUP(Token, Value) \
628 do \
629 if (yychar == YYEMPTY && yylen == 1) \
630 { \
631 yychar = (Token); \
632 yylval = (Value); \
633 yytoken = YYTRANSLATE (yychar); \
634 YYPOPSTACK (1); \
635 goto yybackup; \
636 } \
637 else \
638 { \
639 yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
640 YYERROR; \
641 } \
642 while (YYID (0))
643
644
645 #define YYTERROR 1
646 #define YYERRCODE 256
647
648
649 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
650 If N is 0, then set CURRENT to the empty location which ends
651 the previous symbol: RHS[0] (always defined). */
652
653 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
654 #ifndef YYLLOC_DEFAULT
655 # define YYLLOC_DEFAULT(Current, Rhs, N) \
656 do \
657 if (YYID (N)) \
658 { \
659 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
660 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
661 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
662 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
663 } \
664 else \
665 { \
666 (Current).first_line = (Current).last_line = \
667 YYRHSLOC (Rhs, 0).last_line; \
668 (Current).first_column = (Current).last_column = \
669 YYRHSLOC (Rhs, 0).last_column; \
670 } \
671 while (YYID (0))
672 #endif]b4_locations_if([[
673
674
675 /* YY_LOCATION_PRINT -- Print the location on the stream.
676 This macro was not mandated originally: define only if we know
677 we won't break user code: when these are the locations we know. */
678
679 #ifndef YY_LOCATION_PRINT
680 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
681 # define YY_LOCATION_PRINT(File, Loc) \
682 fprintf (File, "%d.%d-%d.%d", \
683 (Loc).first_line, (Loc).first_column, \
684 (Loc).last_line, (Loc).last_column)
685 # else
686 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
687 # endif
688 #endif]], [[
689
690
691 /* This macro is provided for backward compatibility. */
692
693 #ifndef YY_LOCATION_PRINT
694 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
695 #endif]])[
696
697
698 /* YYLEX -- calling `yylex' with the right arguments. */
699
700 #ifdef YYLEX_PARAM
701 # define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)
702 #else
703 # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
704 #endif
705
706 /* Enable debugging if requested. */
707 #if YYDEBUG
708
709 # ifndef YYFPRINTF
710 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
711 # define YYFPRINTF fprintf
712 # endif
713
714 # define YYDPRINTF(Args) \
715 do { \
716 if (yydebug) \
717 YYFPRINTF Args; \
718 } while (YYID (0))
719
720 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
721 do { \
722 if (yydebug) \
723 { \
724 YYFPRINTF (stderr, "%s ", Title); \
725 yy_symbol_print (stderr, \
726 Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
727 YYFPRINTF (stderr, "\n"); \
728 } \
729 } while (YYID (0))
730
731 ]b4_yy_symbol_print_generate([b4_c_function_def])[
732
733 /*------------------------------------------------------------------.
734 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
735 | TOP (included). |
736 `------------------------------------------------------------------*/
737
738 ]b4_c_function_def([yy_stack_print], [static void],
739 [[yytype_int16 *yybottom], [yybottom]],
740 [[yytype_int16 *yytop], [yytop]])[
741 {
742 YYFPRINTF (stderr, "Stack now");
743 for (; yybottom <= yytop; yybottom++)
744 {
745 int yybot = *yybottom;
746 YYFPRINTF (stderr, " %d", yybot);
747 }
748 YYFPRINTF (stderr, "\n");
749 }
750
751 # define YY_STACK_PRINT(Bottom, Top) \
752 do { \
753 if (yydebug) \
754 yy_stack_print ((Bottom), (Top)); \
755 } while (YYID (0))
756
757
758 /*------------------------------------------------.
759 | Report that the YYRULE is going to be reduced. |
760 `------------------------------------------------*/
761
762 ]b4_c_function_def([yy_reduce_print], [static void],
763 [[yytype_int16 *yyssp], [yyssp]],
764 [[YYSTYPE *yyvsp], [yyvsp]],
765 b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
766 ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
767 b4_parse_param]))[
768 {
769 unsigned long int yylno = yyrline[yyrule];
770 int yynrhs = yyr2[yyrule];
771 int yyi;
772 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
773 yyrule - 1, yylno);
774 /* The symbols being reduced. */
775 for (yyi = 0; yyi < yynrhs; yyi++)
776 {
777 YYFPRINTF (stderr, " $%d = ", yyi + 1);
778 yy_symbol_print (stderr,
779 yystos[yyssp[yyi + 1 - yynrhs]],
780 &]b4_rhs_value(yynrhs, yyi + 1)[
781 ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
782 b4_user_args[);
783 YYFPRINTF (stderr, "\n");
784 }
785 }
786
787 # define YY_REDUCE_PRINT(Rule) \
788 do { \
789 if (yydebug) \
790 yy_reduce_print (yyssp, yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
791 } while (YYID (0))
792
793 /* Nonzero means print parse trace. It is left uninitialized so that
794 multiple parsers can coexist. */
795 int yydebug;
796 #else /* !YYDEBUG */
797 # define YYDPRINTF(Args)
798 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
799 # define YY_STACK_PRINT(Bottom, Top)
800 # define YY_REDUCE_PRINT(Rule)
801 #endif /* !YYDEBUG */
802
803
804 /* YYINITDEPTH -- initial size of the parser's stacks. */
805 #ifndef YYINITDEPTH
806 # define YYINITDEPTH ]b4_stack_depth_init[
807 #endif
808
809 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
810 if the built-in stack extension method is used).
811
812 Do not make this value too large; the results are undefined if
813 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
814 evaluated with infinite-precision integer arithmetic. */
815
816 #ifndef YYMAXDEPTH
817 # define YYMAXDEPTH ]b4_stack_depth_max[
818 #endif
819
820 \f
821
822 #if YYERROR_VERBOSE
823
824 # ifndef yystrlen
825 # if defined __GLIBC__ && defined _STRING_H
826 # define yystrlen strlen
827 # else
828 /* Return the length of YYSTR. */
829 ]b4_c_function_def([yystrlen], [static YYSIZE_T],
830 [[const char *yystr], [yystr]])[
831 {
832 YYSIZE_T yylen;
833 for (yylen = 0; yystr[yylen]; yylen++)
834 continue;
835 return yylen;
836 }
837 # endif
838 # endif
839
840 # ifndef yystpcpy
841 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
842 # define yystpcpy stpcpy
843 # else
844 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
845 YYDEST. */
846 ]b4_c_function_def([yystpcpy], [static char *],
847 [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[
848 {
849 char *yyd = yydest;
850 const char *yys = yysrc;
851
852 while ((*yyd++ = *yys++) != '\0')
853 continue;
854
855 return yyd - 1;
856 }
857 # endif
858 # endif
859
860 # ifndef yytnamerr
861 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
862 quotes and backslashes, so that it's suitable for yyerror. The
863 heuristic is that double-quoting is unnecessary unless the string
864 contains an apostrophe, a comma, or backslash (other than
865 backslash-backslash). YYSTR is taken from yytname. If YYRES is
866 null, do not copy; instead, return the length of what the result
867 would have been. */
868 static YYSIZE_T
869 yytnamerr (char *yyres, const char *yystr)
870 {
871 if (*yystr == '"')
872 {
873 YYSIZE_T yyn = 0;
874 char const *yyp = yystr;
875
876 for (;;)
877 switch (*++yyp)
878 {
879 case '\'':
880 case ',':
881 goto do_not_strip_quotes;
882
883 case '\\':
884 if (*++yyp != '\\')
885 goto do_not_strip_quotes;
886 /* Fall through. */
887 default:
888 if (yyres)
889 yyres[yyn] = *yyp;
890 yyn++;
891 break;
892
893 case '"':
894 if (yyres)
895 yyres[yyn] = '\0';
896 return yyn;
897 }
898 do_not_strip_quotes: ;
899 }
900
901 if (! yyres)
902 return yystrlen (yystr);
903
904 return yystpcpy (yyres, yystr) - yyres;
905 }
906 # endif
907
908 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
909 about the unexpected token YYTOKEN while in state YYSTATE.
910
911 Return 0 if *YYMSG was successfully written. Return 1 if an ordinary
912 "syntax error" message will suffice instead. Return 2 if *YYMSG is
913 not large enough to hold the message. In the last case, also set
914 *YYMSG_ALLOC to either (a) the required number of bytes or (b) zero
915 if the required number of bytes is too large to store. */
916 static int
917 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
918 int yystate, int yytoken)
919 {
920 int yyn = yypact[yystate];
921
922 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
923 return 1;
924 else
925 {
926 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
927 YYSIZE_T yysize = yysize0;
928 YYSIZE_T yysize1;
929 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
930 /* Internationalized format string. */
931 const char *yyformat = 0;
932 /* Arguments of yyformat. */
933 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
934
935 /* Start YYX at -YYN if negative to avoid negative indexes in
936 YYCHECK. In other words, skip the first -YYN actions for this
937 state because they are default actions. */
938 int yyxbegin = yyn < 0 ? -yyn : 0;
939
940 /* Stay within bounds of both yycheck and yytname. */
941 int yychecklim = YYLAST - yyn + 1;
942 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
943 /* Number of reported tokens (one for the "unexpected", one per
944 "expected"). */
945 int yycount = 0;
946 int yyx;
947
948 yyarg[yycount++] = yytname[yytoken];
949
950 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
951 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
952 && !yytable_value_is_error (yytable[yyx + yyn]))
953 {
954 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
955 {
956 yycount = 1;
957 yysize = yysize0;
958 break;
959 }
960 yyarg[yycount++] = yytname[yyx];
961 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
962 if (! (yysize <= yysize1
963 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
964 {
965 /* Overflow. */
966 *yymsg_alloc = 0;
967 return 2;
968 }
969 yysize = yysize1;
970 }
971
972 switch (yycount)
973 {
974 #define YYCASE_(N, S) \
975 case N: \
976 yyformat = S; \
977 break
978 YYCASE_(1, YY_("syntax error, unexpected %s"));
979 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
980 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
981 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
982 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
983 #undef YYCASE_
984 }
985
986 yysize1 = yysize + yystrlen (yyformat);
987 if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
988 {
989 /* Overflow. */
990 *yymsg_alloc = 0;
991 return 2;
992 }
993 yysize = yysize1;
994
995 if (*yymsg_alloc < yysize)
996 {
997 *yymsg_alloc = 2 * yysize;
998 if (! (yysize <= *yymsg_alloc
999 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1000 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1001 return 2;
1002 }
1003
1004 /* Avoid sprintf, as that infringes on the user's name space.
1005 Don't have undefined behavior even if the translation
1006 produced a string with the wrong number of "%s"s. */
1007 {
1008 char *yyp = *yymsg;
1009 int yyi = 0;
1010 while ((*yyp = *yyformat) != '\0')
1011 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1012 {
1013 yyp += yytnamerr (yyp, yyarg[yyi++]);
1014 yyformat += 2;
1015 }
1016 else
1017 {
1018 yyp++;
1019 yyformat++;
1020 }
1021 }
1022 return 0;
1023 }
1024 }
1025 #endif /* YYERROR_VERBOSE */
1026 \f
1027
1028 ]b4_yydestruct_generate([b4_c_function_def])b4_push_if([], [[
1029
1030
1031 /* Prevent warnings from -Wmissing-prototypes. */
1032 #ifdef YYPARSE_PARAM
1033 ]b4_c_function_decl([yyparse], [int],
1034 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
1035 #else /* ! YYPARSE_PARAM */
1036 ]b4_c_function_decl([yyparse], [int], b4_parse_param)[
1037 #endif /* ! YYPARSE_PARAM */]])b4_pure_if([], [
1038
1039 b4_declare_scanner_communication_variables])[]b4_push_if([[
1040
1041
1042 struct yypstate
1043 {]b4_declare_parser_state_variables[
1044 /* Used to determine if this is the first time this instance has
1045 been used. */
1046 int yynew;
1047 };]b4_pure_if([], [[
1048
1049 static char yypstate_allocated = 0;]])b4_pull_if([
1050
1051 b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
1052 {
1053 return yypull_parse (0]m4_ifset([b4_parse_param],
1054 [[, ]b4_c_args(b4_parse_param)])[);
1055 }
1056
1057 ]b4_c_function_def([[yypull_parse]], [[int]],
1058 [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1059 b4_parse_param]))[
1060 {
1061 int yystatus;
1062 yypstate *yyps_local;]b4_pure_if([[
1063 int yychar;
1064 YYSTYPE yylval;]b4_locations_if([[
1065 YYLTYPE yylloc;]])])[
1066 if (yyps == 0)
1067 {
1068 yyps_local = yypstate_new ();
1069 if (!yyps_local)
1070 {]b4_pure_if([[
1071 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
1072 if (!yypstate_allocated)
1073 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
1074 return 2;
1075 }
1076 }
1077 else
1078 yyps_local = yyps;
1079 do {
1080 yychar = YYLEX;
1081 yystatus =
1082 yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
1083 } while (yystatus == YYPUSH_MORE);
1084 if (yyps == 0)
1085 yypstate_delete (yyps_local);
1086 return yystatus;
1087 }]])[
1088
1089 /* Initialize the parser data structure. */
1090 ]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
1091 {
1092 yypstate *yyps;]b4_pure_if([], [[
1093 if (yypstate_allocated)
1094 return 0;]])[
1095 yyps = (yypstate *) malloc (sizeof *yyps);
1096 if (!yyps)
1097 return 0;
1098 yyps->yynew = 1;]b4_pure_if([], [[
1099 yypstate_allocated = 1;]])[
1100 return yyps;
1101 }
1102
1103 ]b4_c_function_def([[yypstate_delete]], [[void]],
1104 [[[yypstate *yyps]], [[yyps]]])[
1105 {
1106 #ifndef yyoverflow
1107 /* If the stack was reallocated but the parse did not complete, then the
1108 stack still needs to be freed. */
1109 if (!yyps->yynew && yyps->yyss != yyps->yyssa)
1110 YYSTACK_FREE (yyps->yyss);
1111 #endif
1112 free (yyps);]b4_pure_if([], [[
1113 yypstate_allocated = 0;]])[
1114 }
1115 ]b4_pure_if([[
1116 #define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs]])[
1117 #define yystate yyps->yystate
1118 #define yyerrstatus yyps->yyerrstatus
1119 #define yyssa yyps->yyssa
1120 #define yyss yyps->yyss
1121 #define yyssp yyps->yyssp
1122 #define yyvsa yyps->yyvsa
1123 #define yyvs yyps->yyvs
1124 #define yyvsp yyps->yyvsp]b4_locations_if([[
1125 #define yylsa yyps->yylsa
1126 #define yyls yyps->yyls
1127 #define yylsp yyps->yylsp
1128 #define yyerror_range yyps->yyerror_range]])[
1129 #define yystacksize yyps->yystacksize
1130
1131
1132 /*---------------.
1133 | yypush_parse. |
1134 `---------------*/
1135
1136 ]b4_c_function_def([[yypush_parse]], [[int]],
1137 [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
1138 [[[int yypushed_char]], [[yypushed_char]]],
1139 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1140 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1141 b4_parse_param]))], [[
1142
1143
1144 /*----------.
1145 | yyparse. |
1146 `----------*/
1147
1148 #ifdef YYPARSE_PARAM
1149 ]b4_c_function_def([yyparse], [int],
1150 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
1151 #else /* ! YYPARSE_PARAM */
1152 ]b4_c_function_def([yyparse], [int], b4_parse_param)[
1153 #endif]])[
1154 {]b4_pure_if([b4_declare_scanner_communication_variables
1155 ])b4_push_if([b4_pure_if([], [[
1156 int yypushed_char = yychar;
1157 YYSTYPE yypushed_val = yylval;]b4_locations_if([[
1158 YYLTYPE yypushed_loc = yylloc;]])
1159 ])],
1160 [b4_declare_parser_state_variables
1161 ])[
1162 int yyn;
1163 int yyresult;
1164 /* Lookahead token as an internal (translated) token number. */
1165 int yytoken;
1166 /* The variables used to return semantic value and location from the
1167 action routines. */
1168 YYSTYPE yyval;]b4_locations_if([[
1169 YYLTYPE yyloc;]])[
1170
1171 #if YYERROR_VERBOSE
1172 /* Buffer for error messages, and its allocated size. */
1173 char yymsgbuf[128];
1174 char *yymsg = yymsgbuf;
1175 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1176 #endif
1177
1178 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
1179
1180 /* The number of symbols on the RHS of the reduced rule.
1181 Keep to zero when no symbol should be popped. */
1182 int yylen = 0;]b4_push_if([[
1183
1184 if (!yyps->yynew)
1185 {
1186 yyn = yypact[yystate];
1187 goto yyread_pushed_token;
1188 }]])[
1189
1190 yytoken = 0;
1191 yyss = yyssa;
1192 yyvs = yyvsa;]b4_locations_if([[
1193 yyls = yylsa;]])[
1194 yystacksize = YYINITDEPTH;
1195
1196 YYDPRINTF ((stderr, "Starting parse\n"));
1197
1198 yystate = 0;
1199 yyerrstatus = 0;
1200 yynerrs = 0;
1201 yychar = YYEMPTY; /* Cause a token to be read. */
1202
1203 /* Initialize stack pointers.
1204 Waste one element of value and location stack
1205 so that they stay on the same level as the state stack.
1206 The wasted elements are never initialized. */
1207 yyssp = yyss;
1208 yyvsp = yyvs;]b4_locations_if([[
1209 yylsp = yyls;
1210
1211 #if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1212 /* Initialize the default location before parsing starts. */
1213 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
1214 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
1215 #endif]])
1216 m4_ifdef([b4_initial_action],[
1217 m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl
1218 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
1219 /* User initialization code. */
1220 b4_user_initial_action
1221 m4_popdef([b4_dollar_dollar])dnl
1222 m4_popdef([b4_at_dollar])])dnl
1223 m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval;
1224 ]])dnl
1225 m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc;
1226 ]])[
1227 goto yysetstate;
1228
1229 /*------------------------------------------------------------.
1230 | yynewstate -- Push a new state, which is found in yystate. |
1231 `------------------------------------------------------------*/
1232 yynewstate:
1233 /* In all cases, when you get here, the value and location stacks
1234 have just been pushed. So pushing a state here evens the stacks. */
1235 yyssp++;
1236
1237 yysetstate:
1238 *yyssp = yystate;
1239
1240 if (yyss + yystacksize - 1 <= yyssp)
1241 {
1242 /* Get the current used size of the three stacks, in elements. */
1243 YYSIZE_T yysize = yyssp - yyss + 1;
1244
1245 #ifdef yyoverflow
1246 {
1247 /* Give user a chance to reallocate the stack. Use copies of
1248 these so that the &'s don't force the real ones into
1249 memory. */
1250 YYSTYPE *yyvs1 = yyvs;
1251 yytype_int16 *yyss1 = yyss;]b4_locations_if([
1252 YYLTYPE *yyls1 = yyls;])[
1253
1254 /* Each stack pointer address is followed by the size of the
1255 data in use in that stack, in bytes. This used to be a
1256 conditional around just the two extra args, but that might
1257 be undefined if yyoverflow is a macro. */
1258 yyoverflow (YY_("memory exhausted"),
1259 &yyss1, yysize * sizeof (*yyssp),
1260 &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
1261 &yyls1, yysize * sizeof (*yylsp),])[
1262 &yystacksize);
1263 ]b4_locations_if([
1264 yyls = yyls1;])[
1265 yyss = yyss1;
1266 yyvs = yyvs1;
1267 }
1268 #else /* no yyoverflow */
1269 # ifndef YYSTACK_RELOCATE
1270 goto yyexhaustedlab;
1271 # else
1272 /* Extend the stack our own way. */
1273 if (YYMAXDEPTH <= yystacksize)
1274 goto yyexhaustedlab;
1275 yystacksize *= 2;
1276 if (YYMAXDEPTH < yystacksize)
1277 yystacksize = YYMAXDEPTH;
1278
1279 {
1280 yytype_int16 *yyss1 = yyss;
1281 union yyalloc *yyptr =
1282 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1283 if (! yyptr)
1284 goto yyexhaustedlab;
1285 YYSTACK_RELOCATE (yyss_alloc, yyss);
1286 YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
1287 YYSTACK_RELOCATE (yyls_alloc, yyls);])[
1288 # undef YYSTACK_RELOCATE
1289 if (yyss1 != yyssa)
1290 YYSTACK_FREE (yyss1);
1291 }
1292 # endif
1293 #endif /* no yyoverflow */
1294
1295 yyssp = yyss + yysize - 1;
1296 yyvsp = yyvs + yysize - 1;]b4_locations_if([
1297 yylsp = yyls + yysize - 1;])[
1298
1299 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1300 (unsigned long int) yystacksize));
1301
1302 if (yyss + yystacksize - 1 <= yyssp)
1303 YYABORT;
1304 }
1305
1306 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1307
1308 if (yystate == YYFINAL)
1309 YYACCEPT;
1310
1311 goto yybackup;
1312
1313 /*-----------.
1314 | yybackup. |
1315 `-----------*/
1316 yybackup:
1317
1318 /* Do appropriate processing given the current state. Read a
1319 lookahead token if we need one and don't already have one. */
1320
1321 /* First try to decide what to do without reference to lookahead token. */
1322 yyn = yypact[yystate];
1323 if (yypact_value_is_default (yyn))
1324 goto yydefault;
1325
1326 /* Not known => get a lookahead token if don't already have one. */
1327
1328 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1329 if (yychar == YYEMPTY)
1330 {]b4_push_if([[
1331 if (!yyps->yynew)
1332 {]b4_use_push_for_pull_if([], [[
1333 YYDPRINTF ((stderr, "Return for a new token:\n"));]])[
1334 yyresult = YYPUSH_MORE;
1335 goto yypushreturn;
1336 }
1337 yyps->yynew = 0;]b4_pure_if([], [[
1338 /* Restoring the pushed token is only necessary for the first
1339 yypush_parse invocation since subsequent invocations don't overwrite
1340 it before jumping to yyread_pushed_token. */
1341 yychar = yypushed_char;
1342 yylval = yypushed_val;]b4_locations_if([[
1343 yylloc = yypushed_loc;]])])[
1344 yyread_pushed_token:]])[
1345 YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[
1346 yychar = yypushed_char;
1347 if (yypushed_val)
1348 yylval = *yypushed_val;]b4_locations_if([[
1349 if (yypushed_loc)
1350 yylloc = *yypushed_loc;]])])], [[
1351 yychar = YYLEX;]])[
1352 }
1353
1354 if (yychar <= YYEOF)
1355 {
1356 yychar = yytoken = YYEOF;
1357 YYDPRINTF ((stderr, "Now at end of input.\n"));
1358 }
1359 else
1360 {
1361 yytoken = YYTRANSLATE (yychar);
1362 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1363 }
1364
1365 /* If the proper action on seeing token YYTOKEN is to reduce or to
1366 detect an error, take that action. */
1367 yyn += yytoken;
1368 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1369 goto yydefault;
1370 yyn = yytable[yyn];
1371 if (yyn <= 0)
1372 {
1373 if (yytable_value_is_error (yyn))
1374 goto yyerrlab;
1375 yyn = -yyn;
1376 goto yyreduce;
1377 }
1378
1379 /* Count tokens shifted since error; after three, turn off error
1380 status. */
1381 if (yyerrstatus)
1382 yyerrstatus--;
1383
1384 /* Shift the lookahead token. */
1385 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1386
1387 /* Discard the shifted token. */
1388 yychar = YYEMPTY;
1389
1390 yystate = yyn;
1391 *++yyvsp = yylval;
1392 ]b4_locations_if([ *++yylsp = yylloc;])[
1393 goto yynewstate;
1394
1395
1396 /*-----------------------------------------------------------.
1397 | yydefault -- do the default action for the current state. |
1398 `-----------------------------------------------------------*/
1399 yydefault:
1400 yyn = yydefact[yystate];
1401 if (yyn == 0)
1402 goto yyerrlab;
1403 goto yyreduce;
1404
1405
1406 /*-----------------------------.
1407 | yyreduce -- Do a reduction. |
1408 `-----------------------------*/
1409 yyreduce:
1410 /* yyn is the number of a rule to reduce with. */
1411 yylen = yyr2[yyn];
1412
1413 /* If YYLEN is nonzero, implement the default value of the action:
1414 `$$ = $1'.
1415
1416 Otherwise, the following line sets YYVAL to garbage.
1417 This behavior is undocumented and Bison
1418 users should not rely upon it. Assigning to YYVAL
1419 unconditionally makes the parser a bit smaller, and it avoids a
1420 GCC warning that YYVAL may be used uninitialized. */
1421 yyval = yyvsp[1-yylen];
1422
1423 ]b4_locations_if(
1424 [[ /* Default location. */
1425 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
1426 YY_REDUCE_PRINT (yyn);
1427 switch (yyn)
1428 {
1429 ]b4_user_actions[
1430 default: break;
1431 }
1432 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1433
1434 YYPOPSTACK (yylen);
1435 yylen = 0;
1436 YY_STACK_PRINT (yyss, yyssp);
1437
1438 *++yyvsp = yyval;]b4_locations_if([
1439 *++yylsp = yyloc;])[
1440
1441 /* Now `shift' the result of the reduction. Determine what state
1442 that goes to, based on the state we popped back to and the rule
1443 number reduced by. */
1444
1445 yyn = yyr1[yyn];
1446
1447 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1448 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1449 yystate = yytable[yystate];
1450 else
1451 yystate = yydefgoto[yyn - YYNTOKENS];
1452
1453 goto yynewstate;
1454
1455
1456 /*------------------------------------.
1457 | yyerrlab -- here on detecting error |
1458 `------------------------------------*/
1459 yyerrlab:
1460 /* If not already recovering from an error, report this error. */
1461 if (!yyerrstatus)
1462 {
1463 ++yynerrs;
1464 #if ! YYERROR_VERBOSE
1465 yyerror (]b4_yyerror_args[YY_("syntax error"));
1466 #else
1467 while (1)
1468 {
1469 int yysyntax_error_status =
1470 yysyntax_error (&yymsg_alloc, &yymsg, yystate, yytoken);
1471 if (yysyntax_error_status == 2 && 0 < yymsg_alloc)
1472 {
1473 if (yymsg != yymsgbuf)
1474 YYSTACK_FREE (yymsg);
1475 yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
1476 if (yymsg)
1477 continue;
1478 yymsg = yymsgbuf;
1479 yymsg_alloc = sizeof yymsgbuf;
1480 }
1481 if (yysyntax_error_status == 0)
1482 yyerror (]b4_yyerror_args[yymsg);
1483 else
1484 yyerror (]b4_yyerror_args[YY_("syntax error"));
1485 if (yysyntax_error_status == 2)
1486 goto yyexhaustedlab;
1487 break;
1488 }
1489 #endif
1490 }
1491
1492 ]b4_locations_if([[ yyerror_range[0] = yylloc;]])[
1493
1494 if (yyerrstatus == 3)
1495 {
1496 /* If just tried and failed to reuse lookahead token after an
1497 error, discard it. */
1498
1499 if (yychar <= YYEOF)
1500 {
1501 /* Return failure if at end of input. */
1502 if (yychar == YYEOF)
1503 YYABORT;
1504 }
1505 else
1506 {
1507 yydestruct ("Error: discarding",
1508 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1509 yychar = YYEMPTY;
1510 }
1511 }
1512
1513 /* Else will try to reuse lookahead token after shifting the error
1514 token. */
1515 goto yyerrlab1;
1516
1517
1518 /*---------------------------------------------------.
1519 | yyerrorlab -- error raised explicitly by YYERROR. |
1520 `---------------------------------------------------*/
1521 yyerrorlab:
1522
1523 /* Pacify compilers like GCC when the user code never invokes
1524 YYERROR and the label yyerrorlab therefore never appears in user
1525 code. */
1526 if (/*CONSTCOND*/ 0)
1527 goto yyerrorlab;
1528
1529 ]b4_locations_if([[ yyerror_range[0] = yylsp[1-yylen];
1530 ]])[ /* Do not reclaim the symbols of the rule which action triggered
1531 this YYERROR. */
1532 YYPOPSTACK (yylen);
1533 yylen = 0;
1534 YY_STACK_PRINT (yyss, yyssp);
1535 yystate = *yyssp;
1536 goto yyerrlab1;
1537
1538
1539 /*-------------------------------------------------------------.
1540 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1541 `-------------------------------------------------------------*/
1542 yyerrlab1:
1543 yyerrstatus = 3; /* Each real token shifted decrements this. */
1544
1545 for (;;)
1546 {
1547 yyn = yypact[yystate];
1548 if (!yypact_value_is_default (yyn))
1549 {
1550 yyn += YYTERROR;
1551 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1552 {
1553 yyn = yytable[yyn];
1554 if (0 < yyn)
1555 break;
1556 }
1557 }
1558
1559 /* Pop the current state because it cannot handle the error token. */
1560 if (yyssp == yyss)
1561 YYABORT;
1562
1563 ]b4_locations_if([[ yyerror_range[0] = *yylsp;]])[
1564 yydestruct ("Error: popping",
1565 yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1566 YYPOPSTACK (1);
1567 yystate = *yyssp;
1568 YY_STACK_PRINT (yyss, yyssp);
1569 }
1570
1571 *++yyvsp = yylval;
1572 ]b4_locations_if([[
1573 yyerror_range[1] = yylloc;
1574 /* Using YYLLOC is tempting, but would change the location of
1575 the lookahead. YYLOC is available though. */
1576 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
1577 *++yylsp = yyloc;]])[
1578
1579 /* Shift the error token. */
1580 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1581
1582 yystate = yyn;
1583 goto yynewstate;
1584
1585
1586 /*-------------------------------------.
1587 | yyacceptlab -- YYACCEPT comes here. |
1588 `-------------------------------------*/
1589 yyacceptlab:
1590 yyresult = 0;
1591 goto yyreturn;
1592
1593 /*-----------------------------------.
1594 | yyabortlab -- YYABORT comes here. |
1595 `-----------------------------------*/
1596 yyabortlab:
1597 yyresult = 1;
1598 goto yyreturn;
1599
1600 #if !defined(yyoverflow) || YYERROR_VERBOSE
1601 /*-------------------------------------------------.
1602 | yyexhaustedlab -- memory exhaustion comes here. |
1603 `-------------------------------------------------*/
1604 yyexhaustedlab:
1605 yyerror (]b4_yyerror_args[YY_("memory exhausted"));
1606 yyresult = 2;
1607 /* Fall through. */
1608 #endif
1609
1610 yyreturn:
1611 if (yychar != YYEMPTY)
1612 yydestruct ("Cleanup: discarding lookahead",
1613 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1614 /* Do not reclaim the symbols of the rule which action triggered
1615 this YYABORT or YYACCEPT. */
1616 YYPOPSTACK (yylen);
1617 YY_STACK_PRINT (yyss, yyssp);
1618 while (yyssp != yyss)
1619 {
1620 yydestruct ("Cleanup: popping",
1621 yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1622 YYPOPSTACK (1);
1623 }
1624 #ifndef yyoverflow
1625 if (yyss != yyssa)
1626 YYSTACK_FREE (yyss);
1627 #endif]b4_push_if([[
1628 yyps->yynew = 1;
1629
1630 yypushreturn:]])[
1631 #if YYERROR_VERBOSE
1632 if (yymsg != yymsgbuf)
1633 YYSTACK_FREE (yymsg);
1634 #endif
1635 /* Make sure YYID is used. */
1636 return YYID (yyresult);
1637 }
1638
1639 ]b4_epilogue[]dnl
1640 b4_defines_if(
1641 [@output(b4_spec_defines_file@)@
1642 b4_copyright([Interface for Bison's Yacc-like parsers in C])dnl
1643
1644 b4_percent_code_get([[requires]])[]dnl
1645
1646 b4_token_enums_defines(b4_tokens)
1647
1648 [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1649 ]m4_ifdef([b4_stype],
1650 [[typedef union ]b4_union_name[
1651 {
1652 ]b4_user_stype[
1653 } YYSTYPE;
1654 # define YYSTYPE_IS_TRIVIAL 1]],
1655 [m4_if(b4_tag_seen_flag, 0,
1656 [[typedef int YYSTYPE;
1657 # define YYSTYPE_IS_TRIVIAL 1]])])[
1658 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1659 # define YYSTYPE_IS_DECLARED 1
1660 #endif
1661
1662 ]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;]])
1663
1664 b4_locations_if(
1665 [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
1666 typedef struct YYLTYPE
1667 {
1668 int first_line;
1669 int first_column;
1670 int last_line;
1671 int last_column;
1672 } YYLTYPE;
1673 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1674 # define YYLTYPE_IS_DECLARED 1
1675 # define YYLTYPE_IS_TRIVIAL 1
1676 #endif
1677
1678 ]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]])
1679 )dnl b4_locations_if
1680 b4_push_if([[
1681 #ifndef YYPUSH_DECLS
1682 # define YYPUSH_DECLS
1683 struct ]b4_prefix[pstate;
1684 typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
1685 enum { YYPUSH_MORE = 4 };
1686 ]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
1687 ])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
1688 [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([,
1689 [[[int yypushed_char]], [[yypushed_char]]],
1690 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1691 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1692 b4_parse_param]))
1693 b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
1694 [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1695 b4_parse_param]))])
1696 b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
1697 [[[void]], []])
1698 b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
1699 [[b4_prefix[pstate *yyps]], [[yyps]]])[
1700 #endif
1701 ]])
1702 b4_percent_code_get([[provides]])[]dnl
1703 ])dnl b4_defines_if
1704 m4_divert_pop(0)
1705 m4_popdef([b4_copyright_years])
bison