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


2e9c9fd0b0d04859b5fa1f8fad95e97b3b19fb82
[bison.git] / data / yacc.c
1 m4_divert(-1) -*- C -*-
2
3 # Yacc compatible skeleton for Bison
4 # Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004
5 # Free Software Foundation, Inc.
6
7 # This program is free software; you can redistribute it and/or modify
8 # it under the terms of the GNU General Public License as published by
9 # the Free Software Foundation; either version 2 of the License, or
10 # (at your option) any later version.
11
12 # This program is distributed in the hope that it will be useful,
13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 # GNU General Public License for more details.
16
17 # You should have received a copy of the GNU General Public License
18 # along with this program; if not, write to the Free Software
19 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
20 # 02111-1307 USA
21
22
23
24 ## ---------------- ##
25 ## Default values. ##
26 ## ---------------- ##
27
28 # Stack parameters.
29 m4_define_default([b4_stack_depth_max], [10000])
30 m4_define_default([b4_stack_depth_init], [200])
31
32
33 ## ------------------------ ##
34 ## Pure/impure interfaces. ##
35 ## ------------------------ ##
36
37
38 # b4_pure_if(IF-TRUE, IF-FALSE)
39 # -----------------------------
40 # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
41 m4_define([b4_Pure_if],
42 [b4_pure_if([m4_ifset([b4_parse_param],
43 [$1], [$2])],
44 [$2])])
45
46
47 # b4_yyerror_args
48 # ---------------
49 # Arguments passed to yyerror: user args plus yylloc.
50 m4_define([b4_yyerror_args],
51 [b4_Pure_if([b4_location_if([&yylloc, ])])dnl
52 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
53
54
55 # b4_lex_param
56 # ------------
57 # Accumulate in b4_lex_param all the yylex arguments.
58 # b4_lex_param arrives quoted twice, but we want to keep only one level.
59 m4_define([b4_lex_param],
60 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
61 b4_location_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
62 m4_ifdef([b4_lex_param], b4_lex_param)))
63
64
65
66 ## ------------ ##
67 ## Data Types. ##
68 ## ------------ ##
69
70 # b4_int_type(MIN, MAX)
71 # ---------------------
72 # Return the smallest int type able to handle numbers ranging from
73 # MIN to MAX (included). We overwrite the version from c.m4 which relies
74 # on "signed char" which is not portable to old K&R compilers.
75 m4_define([b4_int_type],
76 [m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char],
77 b4_ints_in($@, [-128], [127]), [1], [yysigned_char],
78
79 b4_ints_in($@, [0], [65535]), [1], [unsigned short int],
80 b4_ints_in($@, [-32768], [32767]), [1], [short int],
81
82 m4_eval([0 <= $1]), [1], [unsigned int],
83
84 [int])])
85
86
87 ## ----------------- ##
88 ## Semantic Values. ##
89 ## ----------------- ##
90
91
92 # b4_lhs_value([TYPE])
93 # --------------------
94 # Expansion of $<TYPE>$.
95 m4_define([b4_lhs_value],
96 [yyval[]m4_ifval([$1], [.$1])])
97
98
99 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
100 # --------------------------------------
101 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
102 # symbols on RHS.
103 m4_define([b4_rhs_value],
104 [yyvsp@{m4_eval([$2 - $1])@}m4_ifval([$3], [.$3])])
105
106
107
108 ## ----------- ##
109 ## Locations. ##
110 ## ----------- ##
111
112 # b4_lhs_location()
113 # -----------------
114 # Expansion of @$.
115 m4_define([b4_lhs_location],
116 [yyloc])
117
118
119 # b4_rhs_location(RULE-LENGTH, NUM)
120 # ---------------------------------
121 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
122 # on RHS.
123 m4_define([b4_rhs_location],
124 [yylsp@{m4_eval([$2 - $1])@}])
125
126
127
128 ## --------------------------------------------------------- ##
129 ## Defining symbol actions, e.g., printers and destructors. ##
130 ## --------------------------------------------------------- ##
131
132 # We do want M4 expansion after # for CPP macros.
133 m4_changecom()
134 m4_divert(0)dnl
135 @output @output_parser_name@
136 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
137 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004])[
138
139 /* As a special exception, when this file is copied by Bison into a
140 Bison output file, you may use that output file without restriction.
141 This special exception was added by the Free Software Foundation
142 in version 1.24 of Bison. */
143
144 /* Written by Richard Stallman by simplifying the original so called
145 ``semantic'' parser. */
146
147 /* All symbols defined below should begin with yy or YY, to avoid
148 infringing on user name space. This should be done even for local
149 variables, as they might otherwise be expanded by user macros.
150 There are some unavoidable exceptions within include files to
151 define necessary library symbols; they are noted "INFRINGES ON
152 USER NAME SPACE" below. */
153
154 ]b4_identification
155 m4_if(b4_prefix[], [yy], [],
156 [/* If NAME_PREFIX is specified substitute the variables and functions
157 names. */
158 #define yyparse b4_prefix[]parse
159 #define yylex b4_prefix[]lex
160 #define yyerror b4_prefix[]error
161 #define yylval b4_prefix[]lval
162 #define yychar b4_prefix[]char
163 #define yydebug b4_prefix[]debug
164 #define yynerrs b4_prefix[]nerrs
165 b4_location_if([#define yylloc b4_prefix[]lloc])])[
166
167 ]b4_token_defines(b4_tokens)[
168
169 /* Copy the first part of user declarations. */
170 ]b4_pre_prologue[
171
172 /* Enabling traces. */
173 #ifndef YYDEBUG
174 # define YYDEBUG ]b4_debug[
175 #endif
176
177 /* Enabling verbose error messages. */
178 #ifdef YYERROR_VERBOSE
179 # undef YYERROR_VERBOSE
180 # define YYERROR_VERBOSE 1
181 #else
182 # define YYERROR_VERBOSE ]b4_error_verbose[
183 #endif
184
185 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
186 ]m4_ifdef([b4_stype],
187 [b4_syncline([b4_stype_line], [b4_filename])
188 typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
189 /* Line __line__ of yacc.c. */
190 b4_syncline([@oline@], [@ofile@])],
191 [typedef int YYSTYPE;])[
192 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
193 # define YYSTYPE_IS_DECLARED 1
194 # define YYSTYPE_IS_TRIVIAL 1
195 #endif
196
197 ]b4_location_if([#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
198 typedef struct YYLTYPE
199 {
200 int first_line;
201 int first_column;
202 int last_line;
203 int last_column;
204 } YYLTYPE;
205 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
206 # define YYLTYPE_IS_DECLARED 1
207 # define YYLTYPE_IS_TRIVIAL 1
208 #endif
209 ])[
210
211 /* Copy the second part of user declarations. */
212 ]b4_post_prologue
213
214 /* Line __line__ of yacc.c. */
215 b4_syncline([@oline@], [@ofile@])[
216
217 #if ! defined (yyoverflow) || YYERROR_VERBOSE
218
219 # ifndef YYFREE
220 # define YYFREE free
221 # endif
222 # ifndef YYMALLOC
223 # define YYMALLOC malloc
224 # endif
225
226 /* The parser invokes alloca or malloc; define the necessary symbols. */
227
228 # ifdef YYSTACK_USE_ALLOCA
229 # if YYSTACK_USE_ALLOCA
230 # define YYSTACK_ALLOC alloca
231 # endif
232 # else
233 # if defined (alloca) || defined (_ALLOCA_H)
234 # define YYSTACK_ALLOC alloca
235 # else
236 # ifdef __GNUC__
237 # define YYSTACK_ALLOC __builtin_alloca
238 # endif
239 # endif
240 # endif
241
242 # ifdef YYSTACK_ALLOC
243 /* Pacify GCC's `empty if-body' warning. */
244 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
245 # else
246 # if defined (__STDC__) || defined (__cplusplus)
247 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
248 # define YYSIZE_T size_t
249 # endif
250 # define YYSTACK_ALLOC YYMALLOC
251 # define YYSTACK_FREE YYFREE
252 # endif
253 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
254
255
256 #if (! defined (yyoverflow) \
257 && (! defined (__cplusplus) \
258 || (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
259 && ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
260
261 /* A type that is properly aligned for any stack member. */
262 union yyalloc
263 {
264 short int yyss;
265 YYSTYPE yyvs;
266 ]b4_location_if([ YYLTYPE yyls;
267 ])dnl
268 [};
269
270 /* The size of the maximum gap between one aligned stack and the next. */
271 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
272
273 /* The size of an array large to enough to hold all stacks, each with
274 N elements. */
275 ]b4_location_if(
276 [# define YYSTACK_BYTES(N) \
277 ((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
278 + 2 * YYSTACK_GAP_MAXIMUM)],
279 [# define YYSTACK_BYTES(N) \
280 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
281 + YYSTACK_GAP_MAXIMUM)])[
282
283 /* Copy COUNT objects from FROM to TO. The source and destination do
284 not overlap. */
285 # ifndef YYCOPY
286 # if defined (__GNUC__) && 1 < __GNUC__
287 # define YYCOPY(To, From, Count) \
288 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
289 # else
290 # define YYCOPY(To, From, Count) \
291 do \
292 { \
293 register YYSIZE_T yyi; \
294 for (yyi = 0; yyi < (Count); yyi++) \
295 (To)[yyi] = (From)[yyi]; \
296 } \
297 while (0)
298 # endif
299 # endif
300
301 /* Relocate STACK from its old location to the new one. The
302 local variables YYSIZE and YYSTACKSIZE give the old and new number of
303 elements in the stack, and YYPTR gives the new location of the
304 stack. Advance YYPTR to a properly aligned location for the next
305 stack. */
306 # define YYSTACK_RELOCATE(Stack) \
307 do \
308 { \
309 YYSIZE_T yynewbytes; \
310 YYCOPY (&yyptr->Stack, Stack, yysize); \
311 Stack = &yyptr->Stack; \
312 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
313 yyptr += yynewbytes / sizeof (*yyptr); \
314 } \
315 while (0)
316
317 #endif
318
319 #if defined (__STDC__) || defined (__cplusplus)
320 typedef signed char yysigned_char;
321 #else
322 typedef short int yysigned_char;
323 #endif
324
325 /* YYFINAL -- State number of the termination state. */
326 #define YYFINAL ]b4_final_state_number[
327 /* YYLAST -- Last index in YYTABLE. */
328 #define YYLAST ]b4_last[
329
330 /* YYNTOKENS -- Number of terminals. */
331 #define YYNTOKENS ]b4_tokens_number[
332 /* YYNNTS -- Number of nonterminals. */
333 #define YYNNTS ]b4_nterms_number[
334 /* YYNRULES -- Number of rules. */
335 #define YYNRULES ]b4_rules_number[
336 /* YYNRULES -- Number of states. */
337 #define YYNSTATES ]b4_states_number[
338
339 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
340 #define YYUNDEFTOK ]b4_undef_token_number[
341 #define YYMAXUTOK ]b4_user_token_number_max[
342
343 #define YYTRANSLATE(YYX) \
344 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
345
346 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
347 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
348 {
349 ]b4_translate[
350 };
351
352 #if YYDEBUG
353 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
354 YYRHS. */
355 static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
356 {
357 ]b4_prhs[
358 };
359
360 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
361 static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
362 {
363 ]b4_rhs[
364 };
365
366 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
367 static const ]b4_int_type_for([b4_rline])[ yyrline[] =
368 {
369 ]b4_rline[
370 };
371 #endif
372
373 #if YYDEBUG || YYERROR_VERBOSE
374 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
375 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
376 static const char *const yytname[] =
377 {
378 ]b4_tname[
379 };
380 #endif
381
382 # ifdef YYPRINT
383 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
384 token YYLEX-NUM. */
385 static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
386 {
387 ]b4_toknum[
388 };
389 # endif
390
391 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
392 static const ]b4_int_type_for([b4_r1])[ yyr1[] =
393 {
394 ]b4_r1[
395 };
396
397 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
398 static const ]b4_int_type_for([b4_r2])[ yyr2[] =
399 {
400 ]b4_r2[
401 };
402
403 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
404 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
405 means the default is an error. */
406 static const ]b4_int_type_for([b4_defact])[ yydefact[] =
407 {
408 ]b4_defact[
409 };
410
411 /* YYDEFGOTO[NTERM-NUM]. */
412 static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
413 {
414 ]b4_defgoto[
415 };
416
417 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
418 STATE-NUM. */
419 #define YYPACT_NINF ]b4_pact_ninf[
420 static const ]b4_int_type_for([b4_pact])[ yypact[] =
421 {
422 ]b4_pact[
423 };
424
425 /* YYPGOTO[NTERM-NUM]. */
426 static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
427 {
428 ]b4_pgoto[
429 };
430
431 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
432 positive, shift that token. If negative, reduce the rule which
433 number is the opposite. If zero, do what YYDEFACT says.
434 If YYTABLE_NINF, syntax error. */
435 #define YYTABLE_NINF ]b4_table_ninf[
436 static const ]b4_int_type_for([b4_table])[ yytable[] =
437 {
438 ]b4_table[
439 };
440
441 static const ]b4_int_type_for([b4_check])[ yycheck[] =
442 {
443 ]b4_check[
444 };
445
446 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
447 symbol of state STATE-NUM. */
448 static const ]b4_int_type_for([b4_stos])[ yystos[] =
449 {
450 ]b4_stos[
451 };
452
453 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
454 # define YYSIZE_T __SIZE_TYPE__
455 #endif
456 #if ! defined (YYSIZE_T) && defined (size_t)
457 # define YYSIZE_T size_t
458 #endif
459 #if ! defined (YYSIZE_T)
460 # if defined (__STDC__) || defined (__cplusplus)
461 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
462 # define YYSIZE_T size_t
463 # endif
464 #endif
465 #if ! defined (YYSIZE_T)
466 # define YYSIZE_T unsigned int
467 #endif
468
469 #define yyerrok (yyerrstatus = 0)
470 #define yyclearin (yychar = YYEMPTY)
471 #define YYEMPTY (-2)
472 #define YYEOF 0
473
474 #define YYACCEPT goto yyacceptlab
475 #define YYABORT goto yyabortlab
476 #define YYERROR goto yyerrorlab
477
478
479 /* Like YYERROR except do call yyerror. This remains here temporarily
480 to ease the transition to the new meaning of YYERROR, for GCC.
481 Once GCC version 2 has supplanted version 1, this can go. */
482
483 #define YYFAIL goto yyerrlab
484
485 #define YYRECOVERING() (!!yyerrstatus)
486
487 #define YYBACKUP(Token, Value) \
488 do \
489 if (yychar == YYEMPTY && yylen == 1) \
490 { \
491 yychar = (Token); \
492 yylval = (Value); \
493 yytoken = YYTRANSLATE (yychar); \
494 YYPOPSTACK; \
495 goto yybackup; \
496 } \
497 else \
498 { \
499 yyerror (]b4_yyerror_args["syntax error: cannot back up");\
500 YYERROR; \
501 } \
502 while (0)
503
504
505 #define YYTERROR 1
506 #define YYERRCODE 256
507
508
509 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
510 If N is 0, then set CURRENT to the empty location which ends
511 the previous symbol: RHS[0] (always defined). */
512
513 #ifndef YYLLOC_DEFAULT
514 # define YYLLOC_DEFAULT(Current, Rhs, N) \
515 do { \
516 if (N) \
517 { \
518 (Current).first_line = (Rhs)[1].first_line; \
519 (Current).first_column = (Rhs)[1].first_column; \
520 (Current).last_line = (Rhs)[N].last_line; \
521 (Current).last_column = (Rhs)[N].last_column; \
522 } \
523 else \
524 { \
525 (Current).first_line = (Current).last_line = (Rhs)[0].last_line; \
526 (Current).first_column = (Current).last_column = (Rhs)[0].last_column; \
527 } \
528 } while(0)
529 #endif
530
531
532 /* YY_LOCATION_PRINT -- Print the location on the stream.
533 This macro was not mandated originally: define only if we know
534 we won't break user code: when these are the locations we know. */
535
536 #ifndef YY_LOCATION_PRINT
537 # if YYLTYPE_IS_TRIVIAL
538 # define YY_LOCATION_PRINT(File, Loc) \
539 fprintf (File, "%d.%d-%d.%d", \
540 (Loc).first_line, (Loc).first_column, \
541 (Loc).last_line, (Loc).last_column)
542 # else
543 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
544 # endif
545 #endif
546
547
548 /* YYLEX -- calling `yylex' with the right arguments. */
549
550 #ifdef YYLEX_PARAM
551 # define YYLEX yylex (]b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])[YYLEX_PARAM)
552 #else
553 # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
554 #endif
555
556 /* Enable debugging if requested. */
557 #if YYDEBUG
558
559 # ifndef YYFPRINTF
560 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
561 # define YYFPRINTF fprintf
562 # endif
563
564 # define YYDPRINTF(Args) \
565 do { \
566 if (yydebug) \
567 YYFPRINTF Args; \
568 } while (0)
569
570 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
571 do { \
572 if (yydebug) \
573 { \
574 YYFPRINTF (stderr, "%s ", Title); \
575 yysymprint (stderr, \
576 Type, Value]b4_location_if([, Location])[); \
577 YYFPRINTF (stderr, "\n"); \
578 } \
579 } while (0)
580
581 /*------------------------------------------------------------------.
582 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
583 | TOP (included). |
584 `------------------------------------------------------------------*/
585
586 ]b4_c_function_def([yy_stack_print], [static void],
587 [[short int *bottom], [bottom]],
588 [[short int *top], [top]])[
589 {
590 YYFPRINTF (stderr, "Stack now");
591 for (/* Nothing. */; bottom <= top; ++bottom)
592 YYFPRINTF (stderr, " %d", *bottom);
593 YYFPRINTF (stderr, "\n");
594 }
595
596 # define YY_STACK_PRINT(Bottom, Top) \
597 do { \
598 if (yydebug) \
599 yy_stack_print ((Bottom), (Top)); \
600 } while (0)
601
602
603 /*------------------------------------------------.
604 | Report that the YYRULE is going to be reduced. |
605 `------------------------------------------------*/
606
607 ]b4_c_function_def([yy_reduce_print], [static void],
608 [[int yyrule], [yyrule]])[
609 {
610 int yyi;
611 unsigned int yylno = yyrline[yyrule];
612 YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
613 yyrule - 1, yylno);
614 /* Print the symbols being reduced, and their result. */
615 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
616 YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
617 YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
618 }
619
620 # define YY_REDUCE_PRINT(Rule) \
621 do { \
622 if (yydebug) \
623 yy_reduce_print (Rule); \
624 } while (0)
625
626 /* Nonzero means print parse trace. It is left uninitialized so that
627 multiple parsers can coexist. */
628 int yydebug;
629 #else /* !YYDEBUG */
630 # define YYDPRINTF(Args)
631 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
632 # define YY_STACK_PRINT(Bottom, Top)
633 # define YY_REDUCE_PRINT(Rule)
634 #endif /* !YYDEBUG */
635
636
637 /* YYINITDEPTH -- initial size of the parser's stacks. */
638 #ifndef YYINITDEPTH
639 # define YYINITDEPTH ]b4_stack_depth_init[
640 #endif
641
642 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
643 if the built-in stack extension method is used).
644
645 Do not make this value too large; the results are undefined if
646 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
647 evaluated with infinite-precision integer arithmetic. */
648
649 #if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
650 # undef YYMAXDEPTH
651 #endif
652
653 #ifndef YYMAXDEPTH
654 # define YYMAXDEPTH ]b4_stack_depth_max[
655 #endif
656
657 \f
658
659 #if YYERROR_VERBOSE
660
661 # ifndef yystrlen
662 # if defined (__GLIBC__) && defined (_STRING_H)
663 # define yystrlen strlen
664 # else
665 /* Return the length of YYSTR. */
666 static YYSIZE_T
667 # if defined (__STDC__) || defined (__cplusplus)
668 yystrlen (const char *yystr)
669 # else
670 yystrlen (yystr)
671 const char *yystr;
672 # endif
673 {
674 register const char *yys = yystr;
675
676 while (*yys++ != '\0')
677 continue;
678
679 return yys - yystr - 1;
680 }
681 # endif
682 # endif
683
684 # ifndef yystpcpy
685 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
686 # define yystpcpy stpcpy
687 # else
688 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
689 YYDEST. */
690 static char *
691 # if defined (__STDC__) || defined (__cplusplus)
692 yystpcpy (char *yydest, const char *yysrc)
693 # else
694 yystpcpy (yydest, yysrc)
695 char *yydest;
696 const char *yysrc;
697 # endif
698 {
699 register char *yyd = yydest;
700 register const char *yys = yysrc;
701
702 while ((*yyd++ = *yys++) != '\0')
703 continue;
704
705 return yyd - 1;
706 }
707 # endif
708 # endif
709
710 #endif /* !YYERROR_VERBOSE */
711
712 \f
713
714 #if YYDEBUG
715 ]b4_yysymprint_generate([b4_c_function_def])[
716 #endif /* ! YYDEBUG */
717 ]b4_yydestruct_generate([b4_c_function_def])
718 \f
719
720 /* Prevent warnings from -Wmissing-prototypes. */
721
722 #ifdef YYPARSE_PARAM
723 # if defined (__STDC__) || defined (__cplusplus)
724 int yyparse (void *YYPARSE_PARAM);
725 # else
726 int yyparse ();
727 # endif
728 #else /* ! YYPARSE_PARAM */
729 b4_c_function_decl([yyparse], [int], b4_parse_param)
730 #endif /* ! YYPARSE_PARAM */
731
732
733 m4_divert_push([KILL])# ======================== M4 code.
734 # b4_declare_parser_variables
735 # ---------------------------
736 # Declare the variables that are global, or local to YYPARSE if
737 # pure-parser.
738 m4_define([b4_declare_parser_variables],
739 [/* The look-ahead symbol. */
740 int yychar;
741
742 /* The semantic value of the look-ahead symbol. */
743 YYSTYPE yylval;
744
745 /* Number of syntax errors so far. */
746 int yynerrs;b4_location_if([
747 /* Location data for the look-ahead symbol. */
748 YYLTYPE yylloc;])
749 ])
750 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
751
752 b4_pure_if([],
753 [b4_declare_parser_variables])
754
755
756 /*----------.
757 | yyparse. |
758 `----------*/
759
760 #ifdef YYPARSE_PARAM
761 # if defined (__STDC__) || defined (__cplusplus)
762 int yyparse (void *YYPARSE_PARAM)
763 # else
764 int yyparse (YYPARSE_PARAM)
765 void *YYPARSE_PARAM;
766 # endif
767 #else /* ! YYPARSE_PARAM */
768 b4_c_function_def([yyparse], [int], b4_parse_param)
769 #endif
770 {[
771 ]b4_pure_if([b4_declare_parser_variables])[
772 register int yystate;
773 register int yyn;
774 int yyresult;
775 /* Number of tokens to shift before error messages enabled. */
776 int yyerrstatus;
777 /* Look-ahead token as an internal (translated) token number. */
778 int yytoken = 0;
779
780 /* Three stacks and their tools:
781 `yyss': related to states,
782 `yyvs': related to semantic values,
783 `yyls': related to locations.
784
785 Refer to the stacks thru separate pointers, to allow yyoverflow
786 to reallocate them elsewhere. */
787
788 /* The state stack. */
789 short int yyssa[YYINITDEPTH];
790 short int *yyss = yyssa;
791 register short int *yyssp;
792
793 /* The semantic value stack. */
794 YYSTYPE yyvsa[YYINITDEPTH];
795 YYSTYPE *yyvs = yyvsa;
796 register YYSTYPE *yyvsp;
797
798 ]b4_location_if(
799 [[ /* The location stack. */
800 YYLTYPE yylsa[YYINITDEPTH];
801 YYLTYPE *yyls = yylsa;
802 YYLTYPE *yylsp;
803 /* The locations where the error started and ended. */
804 YYLTYPE yyerror_range[2];]])[
805
806 #define YYPOPSTACK (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
807
808 YYSIZE_T yystacksize = YYINITDEPTH;
809
810 /* The variables used to return semantic value and location from the
811 action routines. */
812 YYSTYPE yyval;
813 ]b4_location_if([ YYLTYPE yyloc;])[
814
815 /* When reducing, the number of symbols on the RHS of the reduced
816 rule. */
817 int yylen;
818
819 YYDPRINTF ((stderr, "Starting parse\n"));
820
821 yystate = 0;
822 yyerrstatus = 0;
823 yynerrs = 0;
824 yychar = YYEMPTY; /* Cause a token to be read. */
825
826 /* Initialize stack pointers.
827 Waste one element of value and location stack
828 so that they stay on the same level as the state stack.
829 The wasted elements are never initialized. */
830
831 yyssp = yyss;
832 yyvsp = yyvs;
833 ]b4_location_if([[ yylsp = yyls;
834 #if YYLTYPE_IS_TRIVIAL
835 /* Initialize the default location before parsing starts. */
836 yylloc.first_line = yylloc.last_line = 1;
837 yylloc.first_column = yylloc.last_column = 0;
838 #endif
839 ]])
840 m4_ifdef([b4_initial_action], [
841 m4_pushdef([b4_at_dollar], [yylloc])dnl
842 m4_pushdef([b4_dollar_dollar], [yylval])dnl
843 /* User initialization code. */
844 b4_initial_action
845 m4_popdef([b4_dollar_dollar])dnl
846 m4_popdef([b4_at_dollar])dnl
847 /* Line __line__ of yacc.c. */
848 b4_syncline([@oline@], [@ofile@])])dnl
849 [
850 yyvsp[0] = yylval;
851 ]b4_location_if([[ yylsp[0] = yylloc;
852 ]])
853 [ goto yysetstate;
854
855 /*------------------------------------------------------------.
856 | yynewstate -- Push a new state, which is found in yystate. |
857 `------------------------------------------------------------*/
858 yynewstate:
859 /* In all cases, when you get here, the value and location stacks
860 have just been pushed. so pushing a state here evens the stacks.
861 */
862 yyssp++;
863
864 yysetstate:
865 *yyssp = yystate;
866
867 if (yyss + yystacksize - 1 <= yyssp)
868 {
869 /* Get the current used size of the three stacks, in elements. */
870 YYSIZE_T yysize = yyssp - yyss + 1;
871
872 #ifdef yyoverflow
873 {
874 /* Give user a chance to reallocate the stack. Use copies of
875 these so that the &'s don't force the real ones into
876 memory. */
877 YYSTYPE *yyvs1 = yyvs;
878 short int *yyss1 = yyss;
879 ]b4_location_if([ YYLTYPE *yyls1 = yyls;])[
880
881 /* Each stack pointer address is followed by the size of the
882 data in use in that stack, in bytes. This used to be a
883 conditional around just the two extra args, but that might
884 be undefined if yyoverflow is a macro. */
885 yyoverflow ("parser stack overflow",
886 &yyss1, yysize * sizeof (*yyssp),
887 &yyvs1, yysize * sizeof (*yyvsp),
888 ]b4_location_if([ &yyls1, yysize * sizeof (*yylsp),])[
889 &yystacksize);
890 ]b4_location_if([ yyls = yyls1;])[
891 yyss = yyss1;
892 yyvs = yyvs1;
893 }
894 #else /* no yyoverflow */
895 # ifndef YYSTACK_RELOCATE
896 goto yyoverflowlab;
897 # else
898 /* Extend the stack our own way. */
899 if (YYMAXDEPTH <= yystacksize)
900 goto yyoverflowlab;
901 yystacksize *= 2;
902 if (YYMAXDEPTH < yystacksize)
903 yystacksize = YYMAXDEPTH;
904
905 {
906 short int *yyss1 = yyss;
907 union yyalloc *yyptr =
908 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
909 if (! yyptr)
910 goto yyoverflowlab;
911 YYSTACK_RELOCATE (yyss);
912 YYSTACK_RELOCATE (yyvs);
913 ]b4_location_if([ YYSTACK_RELOCATE (yyls);])[
914 # undef YYSTACK_RELOCATE
915 if (yyss1 != yyssa)
916 YYSTACK_FREE (yyss1);
917 }
918 # endif
919 #endif /* no yyoverflow */
920
921 yyssp = yyss + yysize - 1;
922 yyvsp = yyvs + yysize - 1;
923 ]b4_location_if([ yylsp = yyls + yysize - 1;])[
924
925 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
926 (unsigned long int) yystacksize));
927
928 if (yyss + yystacksize - 1 <= yyssp)
929 YYABORT;
930 }
931
932 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
933
934 goto yybackup;
935
936 /*-----------.
937 | yybackup. |
938 `-----------*/
939 yybackup:
940
941 /* Do appropriate processing given the current state. */
942 /* Read a look-ahead token if we need one and don't already have one. */
943 /* yyresume: */
944
945 /* First try to decide what to do without reference to look-ahead token. */
946
947 yyn = yypact[yystate];
948 if (yyn == YYPACT_NINF)
949 goto yydefault;
950
951 /* Not known => get a look-ahead token if don't already have one. */
952
953 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
954 if (yychar == YYEMPTY)
955 {
956 YYDPRINTF ((stderr, "Reading a token: "));
957 yychar = YYLEX;
958 }
959
960 if (yychar <= YYEOF)
961 {
962 yychar = yytoken = YYEOF;
963 YYDPRINTF ((stderr, "Now at end of input.\n"));
964 }
965 else
966 {
967 yytoken = YYTRANSLATE (yychar);
968 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
969 }
970
971 /* If the proper action on seeing token YYTOKEN is to reduce or to
972 detect an error, take that action. */
973 yyn += yytoken;
974 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
975 goto yydefault;
976 yyn = yytable[yyn];
977 if (yyn <= 0)
978 {
979 if (yyn == 0 || yyn == YYTABLE_NINF)
980 goto yyerrlab;
981 yyn = -yyn;
982 goto yyreduce;
983 }
984
985 if (yyn == YYFINAL)
986 YYACCEPT;
987
988 /* Shift the look-ahead token. */
989 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
990
991 /* Discard the token being shifted unless it is eof. */
992 if (yychar != YYEOF)
993 yychar = YYEMPTY;
994
995 *++yyvsp = yylval;
996 ]b4_location_if([ *++yylsp = yylloc;])[
997
998 /* Count tokens shifted since error; after three, turn off error
999 status. */
1000 if (yyerrstatus)
1001 yyerrstatus--;
1002
1003 yystate = yyn;
1004 goto yynewstate;
1005
1006
1007 /*-----------------------------------------------------------.
1008 | yydefault -- do the default action for the current state. |
1009 `-----------------------------------------------------------*/
1010 yydefault:
1011 yyn = yydefact[yystate];
1012 if (yyn == 0)
1013 goto yyerrlab;
1014 goto yyreduce;
1015
1016
1017 /*-----------------------------.
1018 | yyreduce -- Do a reduction. |
1019 `-----------------------------*/
1020 yyreduce:
1021 /* yyn is the number of a rule to reduce with. */
1022 yylen = yyr2[yyn];
1023
1024 /* If YYLEN is nonzero, implement the default value of the action:
1025 `$$ = $1'.
1026
1027 Otherwise, the following line sets YYVAL to garbage.
1028 This behavior is undocumented and Bison
1029 users should not rely upon it. Assigning to YYVAL
1030 unconditionally makes the parser a bit smaller, and it avoids a
1031 GCC warning that YYVAL may be used uninitialized. */
1032 yyval = yyvsp[1-yylen];
1033
1034 ]b4_location_if(
1035 [[ /* Default location. */
1036 YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);]])[
1037 YY_REDUCE_PRINT (yyn);
1038 switch (yyn)
1039 ]{
1040 b4_actions
1041 }
1042
1043 /* Line __line__ of yacc.c. */
1044 b4_syncline([@oline@], [@ofile@])
1045 \f
1046 [ yyvsp -= yylen;
1047 yyssp -= yylen;
1048 ]b4_location_if([ yylsp -= yylen;])[
1049
1050 YY_STACK_PRINT (yyss, yyssp);
1051
1052 *++yyvsp = yyval;
1053 ]b4_location_if([ *++yylsp = yyloc;])[
1054
1055 /* Now `shift' the result of the reduction. Determine what state
1056 that goes to, based on the state we popped back to and the rule
1057 number reduced by. */
1058
1059 yyn = yyr1[yyn];
1060
1061 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1062 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1063 yystate = yytable[yystate];
1064 else
1065 yystate = yydefgoto[yyn - YYNTOKENS];
1066
1067 goto yynewstate;
1068
1069
1070 /*------------------------------------.
1071 | yyerrlab -- here on detecting error |
1072 `------------------------------------*/
1073 yyerrlab:
1074 /* If not already recovering from an error, report this error. */
1075 if (!yyerrstatus)
1076 {
1077 ++yynerrs;
1078 #if YYERROR_VERBOSE
1079 yyn = yypact[yystate];
1080
1081 if (YYPACT_NINF < yyn && yyn < YYLAST)
1082 {
1083 YYSIZE_T yysize = 0;
1084 int yytype = YYTRANSLATE (yychar);
1085 const char* yyprefix;
1086 char *yymsg;
1087 int yyx;
1088
1089 /* Start YYX at -YYN if negative to avoid negative indexes in
1090 YYCHECK. */
1091 int yyxbegin = yyn < 0 ? -yyn : 0;
1092
1093 /* Stay within bounds of both yycheck and yytname. */
1094 int yychecklim = YYLAST - yyn;
1095 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1096 int yycount = 0;
1097
1098 yyprefix = ", expecting ";
1099 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1100 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1101 {
1102 yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
1103 yycount += 1;
1104 if (yycount == 5)
1105 {
1106 yysize = 0;
1107 break;
1108 }
1109 }
1110 yysize += (sizeof ("syntax error, unexpected ")
1111 + yystrlen (yytname[yytype]));
1112 yymsg = (char *) YYSTACK_ALLOC (yysize);
1113 if (yymsg != 0)
1114 {
1115 char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
1116 yyp = yystpcpy (yyp, yytname[yytype]);
1117
1118 if (yycount < 5)
1119 {
1120 yyprefix = ", expecting ";
1121 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1122 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1123 {
1124 yyp = yystpcpy (yyp, yyprefix);
1125 yyp = yystpcpy (yyp, yytname[yyx]);
1126 yyprefix = " or ";
1127 }
1128 }
1129 yyerror (]b4_yyerror_args[yymsg);
1130 YYSTACK_FREE (yymsg);
1131 }
1132 else
1133 yyerror (]b4_yyerror_args["syntax error; also virtual memory exhausted");
1134 }
1135 else
1136 #endif /* YYERROR_VERBOSE */
1137 yyerror (]b4_yyerror_args["syntax error");
1138 }
1139
1140 ]b4_location_if([[ yyerror_range[0] = yylloc;]])[
1141
1142 if (yyerrstatus == 3)
1143 {
1144 /* If just tried and failed to reuse look-ahead token after an
1145 error, discard it. */
1146
1147 if (yychar <= YYEOF)
1148 {
1149 /* If at end of input, pop the error token,
1150 then the rest of the stack, then return failure. */
1151 if (yychar == YYEOF)
1152 for (;;)
1153 {
1154 ]b4_location_if([[ yyerror_range[0] = *yylsp;]])[
1155 YYPOPSTACK;
1156 if (yyssp == yyss)
1157 YYABORT;
1158 yydestruct ("Error: popping",
1159 yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[);
1160 }
1161 }
1162 else
1163 {
1164 yydestruct ("Error: discarding", yytoken, &yylval]b4_location_if([, &yylloc])[);
1165 yychar = YYEMPTY;
1166 }
1167 }
1168
1169 /* Else will try to reuse look-ahead token after shifting the error
1170 token. */
1171 goto yyerrlab1;
1172
1173
1174 /*---------------------------------------------------.
1175 | yyerrorlab -- error raised explicitly by YYERROR. |
1176 `---------------------------------------------------*/
1177 yyerrorlab:
1178
1179 #ifdef __GNUC__
1180 /* Pacify GCC when the user code never invokes YYERROR and the label
1181 yyerrorlab therefore never appears in user code. */
1182 if (0)
1183 goto yyerrorlab;
1184 #endif
1185
1186 ]b4_location_if([[ yyerror_range[0] = yylsp[1-yylen];
1187 yylsp -= yylen;
1188 ]])[yyvsp -= yylen;
1189 yyssp -= yylen;
1190 yystate = *yyssp;
1191 goto yyerrlab1;
1192
1193
1194 /*-------------------------------------------------------------.
1195 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1196 `-------------------------------------------------------------*/
1197 yyerrlab1:
1198 yyerrstatus = 3; /* Each real token shifted decrements this. */
1199
1200 for (;;)
1201 {
1202 yyn = yypact[yystate];
1203 if (yyn != YYPACT_NINF)
1204 {
1205 yyn += YYTERROR;
1206 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1207 {
1208 yyn = yytable[yyn];
1209 if (0 < yyn)
1210 break;
1211 }
1212 }
1213
1214 /* Pop the current state because it cannot handle the error token. */
1215 if (yyssp == yyss)
1216 YYABORT;
1217
1218 ]b4_location_if([[ yyerror_range[0] = *yylsp;]])[
1219 yydestruct ("Error: popping", yystos[yystate], yyvsp]b4_location_if([, yylsp])[);
1220 YYPOPSTACK;
1221 yystate = *yyssp;
1222 YY_STACK_PRINT (yyss, yyssp);
1223 }
1224
1225 if (yyn == YYFINAL)
1226 YYACCEPT;
1227
1228 *++yyvsp = yylval;
1229 ]b4_location_if([[
1230 yyerror_range[1] = yylloc;
1231 /* Using YYLLOC is tempting, but would change the location of
1232 the look-ahead. YYLOC is available though. */
1233 YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
1234 *++yylsp = yyloc;]])[
1235
1236 /* Shift the error token. */
1237 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1238
1239 yystate = yyn;
1240 goto yynewstate;
1241
1242
1243 /*-------------------------------------.
1244 | yyacceptlab -- YYACCEPT comes here. |
1245 `-------------------------------------*/
1246 yyacceptlab:
1247 yyresult = 0;
1248 goto yyreturn;
1249
1250 /*-----------------------------------.
1251 | yyabortlab -- YYABORT comes here. |
1252 `-----------------------------------*/
1253 yyabortlab:
1254 yydestruct ("Error: discarding lookahead",
1255 yytoken, &yylval]b4_location_if([, &yylloc])[);
1256 yychar = YYEMPTY;
1257 yyresult = 1;
1258 goto yyreturn;
1259
1260 #ifndef yyoverflow
1261 /*----------------------------------------------.
1262 | yyoverflowlab -- parser overflow comes here. |
1263 `----------------------------------------------*/
1264 yyoverflowlab:
1265 yyerror (]b4_yyerror_args["parser stack overflow");
1266 yyresult = 2;
1267 /* Fall through. */
1268 #endif
1269
1270 yyreturn:
1271 #ifndef yyoverflow
1272 if (yyss != yyssa)
1273 YYSTACK_FREE (yyss);
1274 #endif
1275 return yyresult;
1276 ]}
1277
1278
1279 b4_epilogue
1280 m4_if(b4_defines_flag, 0, [],
1281 [@output @output_header_name@
1282 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
1283 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004])
1284
1285 /* As a special exception, when this file is copied by Bison into a
1286 Bison output file, you may use that output file without restriction.
1287 This special exception was added by the Free Software Foundation
1288 in version 1.24 of Bison. */
1289
1290 b4_token_defines(b4_tokens)
1291
1292 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
1293 m4_ifdef([b4_stype],
1294 [b4_syncline([b4_stype_line], [b4_filename])
1295 typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
1296 /* Line __line__ of yacc.c. */
1297 b4_syncline([@oline@], [@ofile@])],
1298 [typedef int YYSTYPE;])
1299 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1300 # define YYSTYPE_IS_DECLARED 1
1301 # define YYSTYPE_IS_TRIVIAL 1
1302 #endif
1303
1304 b4_pure_if([],
1305 [extern YYSTYPE b4_prefix[]lval;])
1306
1307 b4_location_if(
1308 [#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
1309 typedef struct YYLTYPE
1310 {
1311 int first_line;
1312 int first_column;
1313 int last_line;
1314 int last_column;
1315 } YYLTYPE;
1316 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1317 # define YYLTYPE_IS_DECLARED 1
1318 # define YYLTYPE_IS_TRIVIAL 1
1319 #endif
1320
1321 m4_if(b4_pure, [0],
1322 [extern YYLTYPE b4_prefix[]lloc;])
1323 ])
1324 ])
bison