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


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