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


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