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


748684138edc247952299a48dcec4a4be192f7bd
[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 #if ! defined (yyoverflow) || YYERROR_VERBOSE
232
233 /* The parser invokes alloca or malloc; define the necessary symbols. */
234
235 # ifdef YYSTACK_USE_ALLOCA
236 # if YYSTACK_USE_ALLOCA
237 # ifdef __GNUC__
238 # define YYSTACK_ALLOC __builtin_alloca
239 # else
240 # define YYSTACK_ALLOC alloca
241 # if defined (__STDC__) || defined (__cplusplus)
242 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
243 # define YYINCLUDED_STDLIB_H
244 # endif
245 # endif
246 # endif
247 # endif
248
249 # ifdef YYSTACK_ALLOC
250 /* Pacify GCC's `empty if-body' warning. */
251 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
252 # ifndef YYSTACK_ALLOC_MAXIMUM
253 /* The OS might guarantee only one guard page at the bottom of the stack,
254 and a page size can be as small as 4096 bytes. So we cannot safely
255 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
256 to allow for a few compiler-allocated temporary stack slots. */
257 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
258 # endif
259 # else
260 # define YYSTACK_ALLOC YYMALLOC
261 # define YYSTACK_FREE YYFREE
262 # ifndef YYSTACK_ALLOC_MAXIMUM
263 # define YYSTACK_ALLOC_MAXIMUM ((YYSIZE_T) -1)
264 # endif
265 # ifdef __cplusplus
266 extern "C" {
267 # endif
268 # ifndef YYMALLOC
269 # define YYMALLOC malloc
270 # if (! defined (malloc) && ! defined (YYINCLUDED_STDLIB_H) \
271 && (defined (__STDC__) || defined (__cplusplus)))
272 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
273 # endif
274 # endif
275 # ifndef YYFREE
276 # define YYFREE free
277 # if (! defined (free) && ! defined (YYINCLUDED_STDLIB_H) \
278 && (defined (__STDC__) || defined (__cplusplus)))
279 void free (void *); /* INFRINGES ON USER NAME SPACE */
280 # endif
281 # endif
282 # ifdef __cplusplus
283 }
284 # endif
285 # endif
286 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
287
288
289 #if (! defined (yyoverflow) \
290 && (! defined (__cplusplus) \
291 || (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
292 && ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
293
294 /* A type that is properly aligned for any stack member. */
295 union yyalloc
296 {
297 short int yyss;
298 YYSTYPE yyvs;
299 ]b4_location_if([ YYLTYPE yyls;
300 ])dnl
301 [};
302
303 /* The size of the maximum gap between one aligned stack and the next. */
304 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
305
306 /* The size of an array large to enough to hold all stacks, each with
307 N elements. */
308 ]b4_location_if(
309 [# define YYSTACK_BYTES(N) \
310 ((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
311 + 2 * YYSTACK_GAP_MAXIMUM)],
312 [# define YYSTACK_BYTES(N) \
313 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
314 + YYSTACK_GAP_MAXIMUM)])[
315
316 /* Copy COUNT objects from FROM to TO. The source and destination do
317 not overlap. */
318 # ifndef YYCOPY
319 # if defined (__GNUC__) && 1 < __GNUC__
320 # define YYCOPY(To, From, Count) \
321 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
322 # else
323 # define YYCOPY(To, From, Count) \
324 do \
325 { \
326 YYSIZE_T yyi; \
327 for (yyi = 0; yyi < (Count); yyi++) \
328 (To)[yyi] = (From)[yyi]; \
329 } \
330 while (0)
331 # endif
332 # endif
333
334 /* Relocate STACK from its old location to the new one. The
335 local variables YYSIZE and YYSTACKSIZE give the old and new number of
336 elements in the stack, and YYPTR gives the new location of the
337 stack. Advance YYPTR to a properly aligned location for the next
338 stack. */
339 # define YYSTACK_RELOCATE(Stack) \
340 do \
341 { \
342 YYSIZE_T yynewbytes; \
343 YYCOPY (&yyptr->Stack, Stack, yysize); \
344 Stack = &yyptr->Stack; \
345 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
346 yyptr += yynewbytes / sizeof (*yyptr); \
347 } \
348 while (0)
349
350 #endif
351
352 #if defined (__STDC__) || defined (__cplusplus)
353 typedef signed char yysigned_char;
354 #else
355 typedef short int yysigned_char;
356 #endif
357
358 /* YYFINAL -- State number of the termination state. */
359 #define YYFINAL ]b4_final_state_number[
360 /* YYLAST -- Last index in YYTABLE. */
361 #define YYLAST ]b4_last[
362
363 /* YYNTOKENS -- Number of terminals. */
364 #define YYNTOKENS ]b4_tokens_number[
365 /* YYNNTS -- Number of nonterminals. */
366 #define YYNNTS ]b4_nterms_number[
367 /* YYNRULES -- Number of rules. */
368 #define YYNRULES ]b4_rules_number[
369 /* YYNRULES -- Number of states. */
370 #define YYNSTATES ]b4_states_number[
371
372 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
373 #define YYUNDEFTOK ]b4_undef_token_number[
374 #define YYMAXUTOK ]b4_user_token_number_max[
375
376 #define YYTRANSLATE(YYX) \
377 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
378
379 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
380 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
381 {
382 ]b4_translate[
383 };
384
385 #if YYDEBUG
386 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
387 YYRHS. */
388 static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
389 {
390 ]b4_prhs[
391 };
392
393 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
394 static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
395 {
396 ]b4_rhs[
397 };
398
399 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
400 static const ]b4_int_type_for([b4_rline])[ yyrline[] =
401 {
402 ]b4_rline[
403 };
404 #endif
405
406 #if YYDEBUG || YYERROR_VERBOSE
407 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
408 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
409 static const char *const yytname[] =
410 {
411 ]b4_tname[
412 };
413 #endif
414
415 #ifndef YYI18N
416 # if YYENABLE_NLS
417 # if ENABLE_NLS
418 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
419 # define YYI18N(msgid) dgettext ("bison-runtime", msgid)
420 # endif
421 # endif
422 # ifndef YYI18N
423 # define YYI18N(msgid) msgid
424 # endif
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[YYI18N ("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, YYI18N ("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 int yylno = yyrline[yyrule];
644 YYFPRINTF (stderr, YYI18N ("Reducing stack by rule %d (line %u), "),
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 (YYI18N ("parser stack overflow"),
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 yyoverflowlab;
926 # else
927 /* Extend the stack our own way. */
928 if (YYMAXDEPTH <= yystacksize)
929 goto yyoverflowlab;
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 yyoverflowlab;
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, YYI18N ("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, YYI18N ("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, YYI18N ("Reading a token: ")));
986 yychar = YYLEX;
987 }
988
989 if (yychar <= YYEOF)
990 {
991 yychar = yytoken = YYEOF;
992 YYDPRINTF ((stderr, YYI18N ("Now at end of input.\n")));
993 }
994 else
995 {
996 yytoken = YYTRANSLATE (yychar);
997 YY_SYMBOL_PRINT (YYI18N ("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 (YYI18N ("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 YYI18N ("syntax error, unexpected %s");
1127 YYI18N ("syntax error, unexpected %s, expecting %s");
1128 YYI18N ("syntax error, unexpected %s, expecting %s or %s");
1129 YYI18N ("syntax error, unexpected %s, expecting %s or %s or %s");
1130 YYI18N ("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 = YYI18N (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 yyerror (]b4_yyerror_args[YYI18N ("syntax error; also memory exhausted"));
1205 }
1206 else
1207 #endif /* YYERROR_VERBOSE */
1208 yyerror (]b4_yyerror_args[YYI18N ("syntax error"));
1209 }
1210
1211 ]b4_location_if([[ yyerror_range[0] = yylloc;]])[
1212
1213 if (yyerrstatus == 3)
1214 {
1215 /* If just tried and failed to reuse look-ahead token after an
1216 error, discard it. */
1217
1218 if (yychar <= YYEOF)
1219 {
1220 /* If at end of input, pop the error token,
1221 then the rest of the stack, then return failure. */
1222 if (yychar == YYEOF)
1223 YYABORT;
1224 }
1225 else
1226 {
1227 yydestruct (YYI18N ("Error: discarding"), yytoken, &yylval]b4_location_if([, &yylloc])[);
1228 yychar = YYEMPTY;
1229 }
1230 }
1231
1232 /* Else will try to reuse look-ahead token after shifting the error
1233 token. */
1234 goto yyerrlab1;
1235
1236
1237 /*---------------------------------------------------.
1238 | yyerrorlab -- error raised explicitly by YYERROR. |
1239 `---------------------------------------------------*/
1240 yyerrorlab:
1241
1242 /* Pacify compilers like GCC when the user code never invokes
1243 YYERROR and the label yyerrorlab therefore never appears in user
1244 code. */
1245 if (0)
1246 goto yyerrorlab;
1247
1248 ]b4_location_if([[ yyerror_range[0] = yylsp[1-yylen];
1249 yylsp -= yylen;
1250 ]])[yyvsp -= yylen;
1251 yyssp -= yylen;
1252 yystate = *yyssp;
1253 goto yyerrlab1;
1254
1255
1256 /*-------------------------------------------------------------.
1257 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1258 `-------------------------------------------------------------*/
1259 yyerrlab1:
1260 yyerrstatus = 3; /* Each real token shifted decrements this. */
1261
1262 for (;;)
1263 {
1264 yyn = yypact[yystate];
1265 if (yyn != YYPACT_NINF)
1266 {
1267 yyn += YYTERROR;
1268 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1269 {
1270 yyn = yytable[yyn];
1271 if (0 < yyn)
1272 break;
1273 }
1274 }
1275
1276 /* Pop the current state because it cannot handle the error token. */
1277 if (yyssp == yyss)
1278 YYABORT;
1279
1280 ]b4_location_if([[ yyerror_range[0] = *yylsp;]])[
1281 yydestruct (YYI18N ("Error: popping"), yystos[yystate], yyvsp]b4_location_if([, yylsp])[);
1282 YYPOPSTACK;
1283 yystate = *yyssp;
1284 YY_STACK_PRINT (yyss, yyssp);
1285 }
1286
1287 if (yyn == YYFINAL)
1288 YYACCEPT;
1289
1290 *++yyvsp = yylval;
1291 ]b4_location_if([[
1292 yyerror_range[1] = yylloc;
1293 /* Using YYLLOC is tempting, but would change the location of
1294 the look-ahead. YYLOC is available though. */
1295 YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
1296 *++yylsp = yyloc;]])[
1297
1298 /* Shift the error token. */
1299 YY_SYMBOL_PRINT (YYI18N ("Shifting"), yystos[yyn], yyvsp, yylsp);
1300
1301 yystate = yyn;
1302 goto yynewstate;
1303
1304
1305 /*-------------------------------------.
1306 | yyacceptlab -- YYACCEPT comes here. |
1307 `-------------------------------------*/
1308 yyacceptlab:
1309 yyresult = 0;
1310 goto yyreturn;
1311
1312 /*-----------------------------------.
1313 | yyabortlab -- YYABORT comes here. |
1314 `-----------------------------------*/
1315 yyabortlab:
1316 yyresult = 1;
1317 goto yyreturn;
1318
1319 #ifndef yyoverflow
1320 /*----------------------------------------------.
1321 | yyoverflowlab -- parser overflow comes here. |
1322 `----------------------------------------------*/
1323 yyoverflowlab:
1324 yyerror (]b4_yyerror_args[YYI18N ("parser stack overflow"));
1325 yyresult = 2;
1326 /* Fall through. */
1327 #endif
1328
1329 yyreturn:
1330 if (yychar != YYEOF && yychar != YYEMPTY)
1331 yydestruct (YYI18N ("Error: discarding lookahead"),
1332 yytoken, &yylval]b4_location_if([, &yylloc])[);
1333 if (yyssp != yyss)
1334 for (;;)
1335 {
1336 ]b4_location_if([[ yyerror_range[0] = *yylsp;]])[
1337 YYPOPSTACK;
1338 if (yyssp == yyss)
1339 break;
1340 yydestruct (YYI18N ("Error: popping"),
1341 yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[);
1342 }
1343 #ifndef yyoverflow
1344 if (yyss != yyssa)
1345 YYSTACK_FREE (yyss);
1346 #endif
1347 return yyresult;
1348 ]}
1349
1350
1351 b4_epilogue
1352 m4_if(b4_defines_flag, 0, [],
1353 [@output @output_header_name@
1354 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
1355 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005])
1356
1357 /* As a special exception, when this file is copied by Bison into a
1358 Bison output file, you may use that output file without restriction.
1359 This special exception was added by the Free Software Foundation
1360 in version 1.24 of Bison. */
1361
1362 b4_token_defines(b4_tokens)
1363
1364 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
1365 m4_ifdef([b4_stype],
1366 [b4_syncline([b4_stype_line], [b4_filename])
1367 typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
1368 /* Line __line__ of yacc.c. */
1369 b4_syncline([@oline@], [@ofile@])],
1370 [typedef int YYSTYPE;])
1371 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1372 # define YYSTYPE_IS_DECLARED 1
1373 # define YYSTYPE_IS_TRIVIAL 1
1374 #endif
1375
1376 b4_pure_if([],
1377 [extern YYSTYPE b4_prefix[]lval;])
1378
1379 b4_location_if(
1380 [#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
1381 typedef struct YYLTYPE
1382 {
1383 int first_line;
1384 int first_column;
1385 int last_line;
1386 int last_column;
1387 } YYLTYPE;
1388 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1389 # define YYLTYPE_IS_DECLARED 1
1390 # define YYLTYPE_IS_TRIVIAL 1
1391 #endif
1392
1393 m4_if(b4_pure, [0],
1394 [extern YYLTYPE b4_prefix[]lloc;])
1395 ])
1396 ])
bison