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


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