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


a8b4e6c9fb6794ebd81ab51c2068a2c61de7c496
[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 # ifdef YYFPRINTF
608 # define YYFPUTC(Char, Stream) YYFPRINTF (Stream, "%c", Char)
609 # define YYFPUTS(Char, Stream) YYFPRINTF (Stream, "%s", String)
610 # else
611 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
612 # define YYFPRINTF fprintf
613 # define YYFPUTC fputc
614 # define YYFPUTS fputs
615 # endif
616
617 # define YYDPRINTF(Args) \
618 do { \
619 if (yydebug) \
620 YYFPRINTF Args; \
621 } while (0)
622
623 # define YYDPUTS(String, Stream) \
624 do { \
625 if (yydebug) \
626 YYFPUTS (String, Stream); \
627 } while (0)
628
629 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
630 do { \
631 if (yydebug) \
632 { \
633 YYFPRINTF (stderr, "%s ", Title); \
634 yysymprint (stderr, \
635 Type, Value]b4_location_if([, Location])[); \
636 YYFPUTC ('\n', stderr); \
637 } \
638 } while (0)
639
640 /*------------------------------------------------------------------.
641 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
642 | TOP (included). |
643 `------------------------------------------------------------------*/
644
645 ]b4_c_function_def([yy_stack_print], [static void],
646 [[short int *bottom], [bottom]],
647 [[short int *top], [top]])[
648 {
649 YYFPUTS ("Stack now", stderr);
650 for (/* Nothing. */; bottom <= top; ++bottom)
651 YYFPRINTF (stderr, " %d", *bottom);
652 YYFPUTC ('\n', stderr);
653 }
654
655 # define YY_STACK_PRINT(Bottom, Top) \
656 do { \
657 if (yydebug) \
658 yy_stack_print ((Bottom), (Top)); \
659 } while (0)
660
661
662 /*------------------------------------------------.
663 | Report that the YYRULE is going to be reduced. |
664 `------------------------------------------------*/
665
666 ]b4_c_function_def([yy_reduce_print], [static void],
667 [[int yyrule], [yyrule]])[
668 {
669 int yyi;
670 unsigned long int yylno = yyrline[yyrule];
671 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu), ",
672 yyrule - 1, yylno);
673 /* Print the symbols being reduced, and their result. */
674 for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
675 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
676 YYFPRINTF (stderr, "-> %s\n", yytname[yyr1[yyrule]]);
677 }
678
679 # define YY_REDUCE_PRINT(Rule) \
680 do { \
681 if (yydebug) \
682 yy_reduce_print (Rule); \
683 } while (0)
684
685 /* Nonzero means print parse trace. It is left uninitialized so that
686 multiple parsers can coexist. */
687 int yydebug;
688
689 #else /* !YYDEBUG */
690
691 # define YYDPUTS(String, File)
692 # define YYDPRINTF(Args)
693 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
694 # define YY_STACK_PRINT(Bottom, Top)
695 # define YY_REDUCE_PRINT(Rule)
696
697 #endif /* !YYDEBUG */
698
699
700 /* YYINITDEPTH -- initial size of the parser's stacks. */
701 #ifndef YYINITDEPTH
702 # define YYINITDEPTH ]b4_stack_depth_init[
703 #endif
704
705 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
706 if the built-in stack extension method is used).
707
708 Do not make this value too large; the results are undefined if
709 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
710 evaluated with infinite-precision integer arithmetic. */
711
712 #ifndef YYMAXDEPTH
713 # define YYMAXDEPTH ]b4_stack_depth_max[
714 #endif
715
716 \f
717
718 #if YYERROR_VERBOSE
719
720 # ifndef yystrlen
721 # if defined (__GLIBC__) && defined (_STRING_H)
722 # define yystrlen strlen
723 # else
724 /* Return the length of YYSTR. */
725 static YYSIZE_T
726 # if defined (__STDC__) || defined (__cplusplus)
727 yystrlen (const char *yystr)
728 # else
729 yystrlen (yystr)
730 const char *yystr;
731 # endif
732 {
733 const char *yys = yystr;
734
735 while (*yys++ != '\0')
736 continue;
737
738 return yys - yystr - 1;
739 }
740 # endif
741 # endif
742
743 # ifndef yystpcpy
744 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
745 # define yystpcpy stpcpy
746 # else
747 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
748 YYDEST. */
749 static char *
750 # if defined (__STDC__) || defined (__cplusplus)
751 yystpcpy (char *yydest, const char *yysrc)
752 # else
753 yystpcpy (yydest, yysrc)
754 char *yydest;
755 const char *yysrc;
756 # endif
757 {
758 char *yyd = yydest;
759 const char *yys = yysrc;
760
761 while ((*yyd++ = *yys++) != '\0')
762 continue;
763
764 return yyd - 1;
765 }
766 # endif
767 # endif
768
769 # ifndef yytnamerr
770 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
771 quotes and backslashes, so that it's suitable for yyerror. The
772 heuristic is that double-quoting is unnecessary unless the string
773 contains an apostrophe, a comma, or backslash (other than
774 backslash-backslash). YYSTR is taken from yytname. If YYRES is
775 null, do not copy; instead, return the length of what the result
776 would have been. */
777 static YYSIZE_T
778 yytnamerr (char *yyres, const char *yystr)
779 {
780 if (*yystr == '"')
781 {
782 size_t yyn = 0;
783 char const *yyp = yystr;
784
785 for (;;)
786 switch (*++yyp)
787 {
788 case '\'':
789 case ',':
790 goto do_not_strip_quotes;
791
792 case '\\':
793 if (*++yyp != '\\')
794 goto do_not_strip_quotes;
795 /* Fall through. */
796 default:
797 if (yyres)
798 yyres[yyn] = *yyp;
799 yyn++;
800 break;
801
802 case '"':
803 if (yyres)
804 yyres[yyn] = '\0';
805 return yyn;
806 }
807 do_not_strip_quotes: ;
808 }
809
810 if (! yyres)
811 return yystrlen (yystr);
812
813 return yystpcpy (yyres, yystr) - yyres;
814 }
815 # endif
816
817 /* Copy into YYRESULT an error message about the unexpected token
818 YYCHAR while in state YYSTATE. Return the number of bytes copied,
819 including the terminating null byte. If YYRESULT is null, do not
820 copy anything; just return the number of bytes that would be
821 copied. As a special case, return 0 if an ordinary "syntax error"
822 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
823 size calculation. */
824 static YYSIZE_T
825 yysyntax_error (char *yyresult, int yystate, int yychar)
826 {
827 int yyn = yypact[yystate];
828
829 if (! (YYPACT_NINF < yyn && yyn < YYLAST))
830 return 0;
831 else
832 {
833 int yytype = YYTRANSLATE (yychar);
834 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
835 YYSIZE_T yysize = yysize0;
836 YYSIZE_T yysize1;
837 int yysize_overflow = 0;
838 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
839 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
840 int yyx;
841
842 # if 0
843 /* This is so xgettext sees the translatable formats that are
844 constructed on the fly. */
845 YY_("syntax error, unexpected %s");
846 YY_("syntax error, unexpected %s, expecting %s");
847 YY_("syntax error, unexpected %s, expecting %s or %s");
848 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
849 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
850 # endif
851 char *yyfmt;
852 char const *yyf;
853 static char const yyunexpected[] = "syntax error, unexpected %s";
854 static char const yyexpecting[] = ", expecting %s";
855 static char const yyor[] = " or %s";
856 char yyformat[sizeof yyunexpected
857 + sizeof yyexpecting - 1
858 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
859 * (sizeof yyor - 1))];
860 char const *yyprefix = yyexpecting;
861
862 /* Start YYX at -YYN if negative to avoid negative indexes in
863 YYCHECK. */
864 int yyxbegin = yyn < 0 ? -yyn : 0;
865
866 /* Stay within bounds of both yycheck and yytname. */
867 int yychecklim = YYLAST - yyn;
868 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
869 int yycount = 1;
870
871 yyarg[0] = yytname[yytype];
872 yyfmt = yystpcpy (yyformat, yyunexpected);
873
874 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
875 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
876 {
877 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
878 {
879 yycount = 1;
880 yysize = yysize0;
881 yyformat[sizeof yyunexpected - 1] = '\0';
882 break;
883 }
884 yyarg[yycount++] = yytname[yyx];
885 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
886 yysize_overflow |= yysize1 < yysize;
887 yysize = yysize1;
888 yyfmt = yystpcpy (yyfmt, yyprefix);
889 yyprefix = yyor;
890 }
891
892 yyf = YY_(yyformat);
893 yysize1 = yysize + yystrlen (yyf);
894 yysize_overflow |= yysize1 < yysize;
895 yysize = yysize1;
896
897 if (yysize_overflow)
898 return YYSIZE_MAXIMUM;
899
900 if (yyresult)
901 {
902 /* Avoid sprintf, as that infringes on the user's name space.
903 Don't have undefined behavior even if the translation
904 produced a string with the wrong number of "%s"s. */
905 char *yyp = yyresult;
906 int yyi = 0;
907 while ((*yyp = *yyf))
908 {
909 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
910 {
911 yyp += yytnamerr (yyp, yyarg[yyi++]);
912 yyf += 2;
913 }
914 else
915 {
916 yyp++;
917 yyf++;
918 }
919 }
920 }
921 return yysize;
922 }
923 }
924 #endif /* YYERROR_VERBOSE */
925 \f
926
927 #if YYDEBUG
928 ]b4_yysymprint_generate([b4_c_function_def])[
929 #endif /* ! YYDEBUG */
930 ]b4_yydestruct_generate([b4_c_function_def])
931 \f
932
933 /* Prevent warnings from -Wmissing-prototypes. */
934
935 #ifdef YYPARSE_PARAM
936 # if defined (__STDC__) || defined (__cplusplus)
937 int yyparse (void *YYPARSE_PARAM);
938 # else
939 int yyparse ();
940 # endif
941 #else /* ! YYPARSE_PARAM */
942 b4_c_function_decl([yyparse], [int], b4_parse_param)
943 #endif /* ! YYPARSE_PARAM */
944
945
946 m4_divert_push([KILL])# ======================== M4 code.
947 # b4_declare_parser_variables
948 # ---------------------------
949 # Declare the variables that are global, or local to YYPARSE if
950 # pure-parser.
951 m4_define([b4_declare_parser_variables],
952 [/* The look-ahead symbol. */
953 int yychar;
954
955 /* The semantic value of the look-ahead symbol. */
956 YYSTYPE yylval;
957
958 /* Number of syntax errors so far. */
959 int yynerrs;b4_location_if([
960 /* Location data for the look-ahead symbol. */
961 YYLTYPE yylloc;])
962 ])
963 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
964
965 b4_pure_if([],
966 [b4_declare_parser_variables])
967
968
969 /*----------.
970 | yyparse. |
971 `----------*/
972
973 #ifdef YYPARSE_PARAM
974 # if defined (__STDC__) || defined (__cplusplus)
975 int yyparse (void *YYPARSE_PARAM)
976 # else
977 int yyparse (YYPARSE_PARAM)
978 void *YYPARSE_PARAM;
979 # endif
980 #else /* ! YYPARSE_PARAM */
981 b4_c_function_def([yyparse], [int], b4_parse_param)
982 #endif
983 {[
984 ]b4_pure_if([b4_declare_parser_variables])[
985 int yystate;
986 int yyn;
987 int yyresult;
988 /* Number of tokens to shift before error messages enabled. */
989 int yyerrstatus;
990 /* Look-ahead token as an internal (translated) token number. */
991 int yytoken = 0;
992 #if YYERROR_VERBOSE
993 /* Buffer for error messages, and its allocated size. */
994 char yymsgbuf[128];
995 char *yymsg = yymsgbuf;
996 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
997 #endif
998
999 /* Three stacks and their tools:
1000 `yyss': related to states,
1001 `yyvs': related to semantic values,
1002 `yyls': related to locations.
1003
1004 Refer to the stacks thru separate pointers, to allow yyoverflow
1005 to reallocate them elsewhere. */
1006
1007 /* The state stack. */
1008 short int yyssa[YYINITDEPTH];
1009 short int *yyss = yyssa;
1010 short int *yyssp;
1011
1012 /* The semantic value stack. */
1013 YYSTYPE yyvsa[YYINITDEPTH];
1014 YYSTYPE *yyvs = yyvsa;
1015 YYSTYPE *yyvsp;
1016
1017 ]b4_location_if(
1018 [[ /* The location stack. */
1019 YYLTYPE yylsa[YYINITDEPTH];
1020 YYLTYPE *yyls = yylsa;
1021 YYLTYPE *yylsp;
1022 /* The locations where the error started and ended. */
1023 YYLTYPE yyerror_range[2];]])[
1024
1025 #define YYPOPSTACK (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
1026
1027 YYSIZE_T yystacksize = YYINITDEPTH;
1028
1029 /* The variables used to return semantic value and location from the
1030 action routines. */
1031 YYSTYPE yyval;
1032 ]b4_location_if([ YYLTYPE yyloc;])[
1033
1034 /* When reducing, the number of symbols on the RHS of the reduced
1035 rule. */
1036 int yylen;
1037
1038 YYDPUTS ("Starting parse\n", stderr);
1039
1040 yystate = 0;
1041 yyerrstatus = 0;
1042 yynerrs = 0;
1043 yychar = YYEMPTY; /* Cause a token to be read. */
1044
1045 /* Initialize stack pointers.
1046 Waste one element of value and location stack
1047 so that they stay on the same level as the state stack.
1048 The wasted elements are never initialized. */
1049
1050 yyssp = yyss;
1051 yyvsp = yyvs;
1052 ]b4_location_if([[ yylsp = yyls;
1053 #if YYLTYPE_IS_TRIVIAL
1054 /* Initialize the default location before parsing starts. */
1055 yylloc.first_line = yylloc.last_line = 1;
1056 yylloc.first_column = yylloc.last_column = 0;
1057 #endif
1058 ]])
1059 m4_ifdef([b4_initial_action], [
1060 m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl
1061 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
1062 /* User initialization code. */
1063 b4_initial_action
1064 m4_popdef([b4_dollar_dollar])dnl
1065 m4_popdef([b4_at_dollar])dnl
1066 /* Line __line__ of yacc.c. */
1067 b4_syncline([@oline@], [@ofile@])
1068 ])dnl
1069 m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval;
1070 ]])dnl
1071 m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc;
1072 ]])dnl
1073 [ goto yysetstate;
1074
1075 /*------------------------------------------------------------.
1076 | yynewstate -- Push a new state, which is found in yystate. |
1077 `------------------------------------------------------------*/
1078 yynewstate:
1079 /* In all cases, when you get here, the value and location stacks
1080 have just been pushed. so pushing a state here evens the stacks.
1081 */
1082 yyssp++;
1083
1084 yysetstate:
1085 *yyssp = yystate;
1086
1087 if (yyss + yystacksize - 1 <= yyssp)
1088 {
1089 /* Get the current used size of the three stacks, in elements. */
1090 YYSIZE_T yysize = yyssp - yyss + 1;
1091
1092 #ifdef yyoverflow
1093 {
1094 /* Give user a chance to reallocate the stack. Use copies of
1095 these so that the &'s don't force the real ones into
1096 memory. */
1097 YYSTYPE *yyvs1 = yyvs;
1098 short int *yyss1 = yyss;
1099 ]b4_location_if([ YYLTYPE *yyls1 = yyls;])[
1100
1101 /* Each stack pointer address is followed by the size of the
1102 data in use in that stack, in bytes. This used to be a
1103 conditional around just the two extra args, but that might
1104 be undefined if yyoverflow is a macro. */
1105 yyoverflow (YY_("memory exhausted"),
1106 &yyss1, yysize * sizeof (*yyssp),
1107 &yyvs1, yysize * sizeof (*yyvsp),
1108 ]b4_location_if([ &yyls1, yysize * sizeof (*yylsp),])[
1109 &yystacksize);
1110 ]b4_location_if([ yyls = yyls1;])[
1111 yyss = yyss1;
1112 yyvs = yyvs1;
1113 }
1114 #else /* no yyoverflow */
1115 # ifndef YYSTACK_RELOCATE
1116 goto yyexhaustedlab;
1117 # else
1118 /* Extend the stack our own way. */
1119 if (YYMAXDEPTH <= yystacksize)
1120 goto yyexhaustedlab;
1121 yystacksize *= 2;
1122 if (YYMAXDEPTH < yystacksize)
1123 yystacksize = YYMAXDEPTH;
1124
1125 {
1126 short int *yyss1 = yyss;
1127 union yyalloc *yyptr =
1128 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1129 if (! yyptr)
1130 goto yyexhaustedlab;
1131 YYSTACK_RELOCATE (yyss);
1132 YYSTACK_RELOCATE (yyvs);
1133 ]b4_location_if([ YYSTACK_RELOCATE (yyls);])[
1134 # undef YYSTACK_RELOCATE
1135 if (yyss1 != yyssa)
1136 YYSTACK_FREE (yyss1);
1137 }
1138 # endif
1139 #endif /* no yyoverflow */
1140
1141 yyssp = yyss + yysize - 1;
1142 yyvsp = yyvs + yysize - 1;
1143 ]b4_location_if([ yylsp = yyls + yysize - 1;])[
1144
1145 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1146 (unsigned long int) yystacksize));
1147
1148 if (yyss + yystacksize - 1 <= yyssp)
1149 YYABORT;
1150 }
1151
1152 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1153
1154 goto yybackup;
1155
1156 /*-----------.
1157 | yybackup. |
1158 `-----------*/
1159 yybackup:
1160
1161 /* Do appropriate processing given the current state. */
1162 /* Read a look-ahead token if we need one and don't already have one. */
1163 /* yyresume: */
1164
1165 /* First try to decide what to do without reference to look-ahead token. */
1166
1167 yyn = yypact[yystate];
1168 if (yyn == YYPACT_NINF)
1169 goto yydefault;
1170
1171 /* Not known => get a look-ahead token if don't already have one. */
1172
1173 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
1174 if (yychar == YYEMPTY)
1175 {
1176 YYDPUTS ("Reading a token: ", stderr);
1177 yychar = YYLEX;
1178 }
1179
1180 if (yychar <= YYEOF)
1181 {
1182 yychar = yytoken = YYEOF;
1183 YYDPUTS ("Now at end of input.\n", stderr);
1184 }
1185 else
1186 {
1187 yytoken = YYTRANSLATE (yychar);
1188 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1189 }
1190
1191 /* If the proper action on seeing token YYTOKEN is to reduce or to
1192 detect an error, take that action. */
1193 yyn += yytoken;
1194 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1195 goto yydefault;
1196 yyn = yytable[yyn];
1197 if (yyn <= 0)
1198 {
1199 if (yyn == 0 || yyn == YYTABLE_NINF)
1200 goto yyerrlab;
1201 yyn = -yyn;
1202 goto yyreduce;
1203 }
1204
1205 if (yyn == YYFINAL)
1206 YYACCEPT;
1207
1208 /* Shift the look-ahead token. */
1209 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1210
1211 /* Discard the token being shifted unless it is eof. */
1212 if (yychar != YYEOF)
1213 yychar = YYEMPTY;
1214
1215 *++yyvsp = yylval;
1216 ]b4_location_if([ *++yylsp = yylloc;])[
1217
1218 /* Count tokens shifted since error; after three, turn off error
1219 status. */
1220 if (yyerrstatus)
1221 yyerrstatus--;
1222
1223 yystate = yyn;
1224 goto yynewstate;
1225
1226
1227 /*-----------------------------------------------------------.
1228 | yydefault -- do the default action for the current state. |
1229 `-----------------------------------------------------------*/
1230 yydefault:
1231 yyn = yydefact[yystate];
1232 if (yyn == 0)
1233 goto yyerrlab;
1234 goto yyreduce;
1235
1236
1237 /*-----------------------------.
1238 | yyreduce -- Do a reduction. |
1239 `-----------------------------*/
1240 yyreduce:
1241 /* yyn is the number of a rule to reduce with. */
1242 yylen = yyr2[yyn];
1243
1244 /* If YYLEN is nonzero, implement the default value of the action:
1245 `$$ = $1'.
1246
1247 Otherwise, the following line sets YYVAL to garbage.
1248 This behavior is undocumented and Bison
1249 users should not rely upon it. Assigning to YYVAL
1250 unconditionally makes the parser a bit smaller, and it avoids a
1251 GCC warning that YYVAL may be used uninitialized. */
1252 yyval = yyvsp[1-yylen];
1253
1254 ]b4_location_if(
1255 [[ /* Default location. */
1256 YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);]])[
1257 YY_REDUCE_PRINT (yyn);
1258 switch (yyn)
1259 ]{
1260 b4_actions
1261 default: break;
1262 }
1263
1264 /* Line __line__ of yacc.c. */
1265 b4_syncline([@oline@], [@ofile@])
1266 \f
1267 [ yyvsp -= yylen;
1268 yyssp -= yylen;
1269 ]b4_location_if([ yylsp -= yylen;])[
1270
1271 YY_STACK_PRINT (yyss, yyssp);
1272
1273 *++yyvsp = yyval;
1274 ]b4_location_if([ *++yylsp = yyloc;])[
1275
1276 /* Now `shift' the result of the reduction. Determine what state
1277 that goes to, based on the state we popped back to and the rule
1278 number reduced by. */
1279
1280 yyn = yyr1[yyn];
1281
1282 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1283 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1284 yystate = yytable[yystate];
1285 else
1286 yystate = yydefgoto[yyn - YYNTOKENS];
1287
1288 goto yynewstate;
1289
1290
1291 /*------------------------------------.
1292 | yyerrlab -- here on detecting error |
1293 `------------------------------------*/
1294 yyerrlab:
1295 /* If not already recovering from an error, report this error. */
1296 if (!yyerrstatus)
1297 {
1298 ++yynerrs;
1299 #if ! YYERROR_VERBOSE
1300 yyerror (]b4_yyerror_args[YY_("syntax error"));
1301 #else
1302 {
1303 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1304 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1305 {
1306 YYSIZE_T yyalloc = 2 * yysize;
1307 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1308 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1309 if (yymsg != yymsgbuf)
1310 YYSTACK_FREE (yymsg);
1311 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1312 if (yymsg)
1313 yymsg_alloc = yyalloc;
1314 else
1315 {
1316 yymsg = yymsgbuf;
1317 yymsg_alloc = sizeof yymsgbuf;
1318 }
1319 }
1320
1321 if (0 < yysize && yysize <= yymsg_alloc)
1322 {
1323 (void) yysyntax_error (yymsg, yystate, yychar);
1324 yyerror (]b4_yyerror_args[yymsg);
1325 }
1326 else
1327 {
1328 yyerror (]b4_yyerror_args[YY_("syntax error"));
1329 if (yysize != 0)
1330 goto yyexhaustedlab;
1331 }
1332 }
1333 #endif
1334 }
1335
1336 ]b4_location_if([[ yyerror_range[0] = yylloc;]])[
1337
1338 if (yyerrstatus == 3)
1339 {
1340 /* If just tried and failed to reuse look-ahead token after an
1341 error, discard it. */
1342
1343 if (yychar <= YYEOF)
1344 {
1345 /* Return failure if at end of input. */
1346 if (yychar == YYEOF)
1347 YYABORT;
1348 }
1349 else
1350 {
1351 yydestruct ("Error: discarding", yytoken, &yylval]b4_location_if([, &yylloc])[);
1352 yychar = YYEMPTY;
1353 }
1354 }
1355
1356 /* Else will try to reuse look-ahead token after shifting the error
1357 token. */
1358 goto yyerrlab1;
1359
1360
1361 /*---------------------------------------------------.
1362 | yyerrorlab -- error raised explicitly by YYERROR. |
1363 `---------------------------------------------------*/
1364 yyerrorlab:
1365
1366 /* Pacify compilers like GCC when the user code never invokes
1367 YYERROR and the label yyerrorlab therefore never appears in user
1368 code. */
1369 if (0)
1370 goto yyerrorlab;
1371
1372 ]b4_location_if([[ yyerror_range[0] = yylsp[1-yylen];
1373 yylsp -= yylen;
1374 ]])[yyvsp -= yylen;
1375 yyssp -= yylen;
1376 yystate = *yyssp;
1377 goto yyerrlab1;
1378
1379
1380 /*-------------------------------------------------------------.
1381 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1382 `-------------------------------------------------------------*/
1383 yyerrlab1:
1384 yyerrstatus = 3; /* Each real token shifted decrements this. */
1385
1386 for (;;)
1387 {
1388 yyn = yypact[yystate];
1389 if (yyn != YYPACT_NINF)
1390 {
1391 yyn += YYTERROR;
1392 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1393 {
1394 yyn = yytable[yyn];
1395 if (0 < yyn)
1396 break;
1397 }
1398 }
1399
1400 /* Pop the current state because it cannot handle the error token. */
1401 if (yyssp == yyss)
1402 YYABORT;
1403
1404 ]b4_location_if([[ yyerror_range[0] = *yylsp;]])[
1405 yydestruct ("Error: popping", yystos[yystate], yyvsp]b4_location_if([, yylsp])[);
1406 YYPOPSTACK;
1407 yystate = *yyssp;
1408 YY_STACK_PRINT (yyss, yyssp);
1409 }
1410
1411 if (yyn == YYFINAL)
1412 YYACCEPT;
1413
1414 *++yyvsp = yylval;
1415 ]b4_location_if([[
1416 yyerror_range[1] = yylloc;
1417 /* Using YYLLOC is tempting, but would change the location of
1418 the look-ahead. YYLOC is available though. */
1419 YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
1420 *++yylsp = yyloc;]])[
1421
1422 /* Shift the error token. */
1423 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1424
1425 yystate = yyn;
1426 goto yynewstate;
1427
1428
1429 /*-------------------------------------.
1430 | yyacceptlab -- YYACCEPT comes here. |
1431 `-------------------------------------*/
1432 yyacceptlab:
1433 yyresult = 0;
1434 goto yyreturn;
1435
1436 /*-----------------------------------.
1437 | yyabortlab -- YYABORT comes here. |
1438 `-----------------------------------*/
1439 yyabortlab:
1440 yyresult = 1;
1441 goto yyreturn;
1442
1443 #ifndef yyoverflow
1444 /*-------------------------------------------------.
1445 | yyexhaustedlab -- memory exhaustion comes here. |
1446 `-------------------------------------------------*/
1447 yyexhaustedlab:
1448 yyerror (]b4_yyerror_args[YY_("memory exhausted"));
1449 yyresult = 2;
1450 /* Fall through. */
1451 #endif
1452
1453 yyreturn:
1454 if (yychar != YYEOF && yychar != YYEMPTY)
1455 yydestruct ("Cleanup: discarding lookahead",
1456 yytoken, &yylval]b4_location_if([, &yylloc])[);
1457 while (yyssp != yyss)
1458 {
1459 yydestruct ("Cleanup: popping",
1460 yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[);
1461 YYPOPSTACK;
1462 }
1463 #ifndef yyoverflow
1464 if (yyss != yyssa)
1465 YYSTACK_FREE (yyss);
1466 #endif
1467 #if YYERROR_VERBOSE
1468 if (yymsg != yymsgbuf)
1469 YYSTACK_FREE (yymsg);
1470 #endif
1471 return yyresult;
1472 ]}
1473
1474
1475 b4_epilogue
1476 m4_if(b4_defines_flag, 0, [],
1477 [@output @output_header_name@
1478 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
1479 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005])
1480
1481 /* As a special exception, when this file is copied by Bison into a
1482 Bison output file, you may use that output file without restriction.
1483 This special exception was added by the Free Software Foundation
1484 in version 1.24 of Bison. */
1485
1486 b4_token_enums_defines(b4_tokens)
1487
1488 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
1489 m4_ifdef([b4_stype],
1490 [b4_syncline([b4_stype_line], [b4_file_name])
1491 typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
1492 /* Line __line__ of yacc.c. */
1493 b4_syncline([@oline@], [@ofile@])],
1494 [typedef int YYSTYPE;])
1495 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1496 # define YYSTYPE_IS_DECLARED 1
1497 # define YYSTYPE_IS_TRIVIAL 1
1498 #endif
1499
1500 b4_pure_if([],
1501 [extern YYSTYPE b4_prefix[]lval;])
1502
1503 b4_location_if(
1504 [#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
1505 typedef struct YYLTYPE
1506 {
1507 int first_line;
1508 int first_column;
1509 int last_line;
1510 int last_column;
1511 } YYLTYPE;
1512 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1513 # define YYLTYPE_IS_DECLARED 1
1514 # define YYLTYPE_IS_TRIVIAL 1
1515 #endif
1516
1517 m4_if(b4_pure, [0],
1518 [extern YYLTYPE b4_prefix[]lloc;])
1519 ])
1520 ])
bison