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


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