]> git.saurik.com Git - bison.git/blob - data/yacc.c
projects / bison.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* data/yacc.c: Guard the declaration of yytoknum also with
[bison.git] / data / yacc.c
1 m4_divert(-1) -*- C -*-
2 m4_include([c.m4])
3
4 # Yacc compatible skeleton for Bison
5 # Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002
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., 59 Temple Place, Suite 330, Boston, MA
21 # 02111-1307 USA
22
23 # b4_lhs_value([TYPE])
24 # --------------------
25 # Expansion of $<TYPE>$.
26 m4_define([b4_lhs_value],
27 [yyval[]m4_ifval([$1], [.$1])])
28
29
30 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
31 # --------------------------------------
32 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
33 # symbols on RHS.
34 m4_define([b4_rhs_value],
35 [yyvsp@<:@m4_eval([$2 - $1])@:>@m4_ifval([$3], [.$3])])
36
37
38
39 ## ----------- ##
40 ## Locations. ##
41 ## ----------- ##
42
43 # b4_location_if(IF-TRUE, IF-FALSE)
44 # ---------------------------------
45 # Expand IF-TRUE, if locations are used, IF-FALSE otherwise.
46 m4_define([b4_location_if],
47 [m4_if(b4_locations_flag, [1],
48 [$1],
49 [$2])])
50
51
52 # b4_lhs_location()
53 # -----------------
54 # Expansion of @$.
55 m4_define([b4_lhs_location],
56 [yyloc])
57
58
59 # b4_rhs_location(RULE-LENGTH, NUM)
60 # ---------------------------------
61 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
62 # on RHS.
63 m4_define([b4_rhs_location],
64 [yylsp@<:@m4_eval([$2 - $1])@:>@])
65
66
67
68 ## -------------- ##
69 ## %pure-parser. ##
70 ## -------------- ##
71
72 # b4_pure_if(IF-TRUE, IF-FALSE)
73 # -----------------------------
74 # Expand IF-TRUE, if %pure-parser, IF-FALSE otherwise.
75 m4_define([b4_pure_if],
76 [m4_if(b4_pure, [1],
77 [$1],
78 [$2])])
79
80
81 ## ------------------- ##
82 ## Output file names. ##
83 ## ------------------- ##
84
85 m4_define_default([b4_input_suffix], [.y])
86
87 m4_define_default([b4_output_parser_suffix],
88 [m4_translit(b4_input_suffix, [yY], [cC])])
89
90 m4_define_default([b4_output_parser_name],
91 [b4_output_prefix[]b4_output_infix[]b4_output_parser_suffix[]])
92
93
94 m4_define_default([b4_output_header_suffix],
95 [m4_translit(b4_input_suffix, [yY], [hH])])
96
97 m4_define_default([b4_output_header_name],
98 [b4_output_prefix[]b4_output_infix[]b4_output_header_suffix[]])
99
100 m4_define_default([b4_header_guard],
101 [m4_bpatsubst(m4_toupper([BISON_]b4_output_header_name),
102 [[^ABCDEFGHIJKLMNOPQRSTUVWXYZ]], [_])])
103
104
105
106 ## --------------------------------------------------------- ##
107 ## Defining symbol actions, e.g., printers and destructors. ##
108 ## --------------------------------------------------------- ##
109
110 # b4_symbol_actions(FILENAME, LINENO,
111 # SYMBOL-TAG, SYMBOL-NUM,
112 # SYMBOL-ACTION, SYMBOL-TYPENAME)
113 # -------------------------------------------------
114 m4_define([b4_symbol_actions],
115 [m4_pushdef([b4_dollar_dollar], [yyvalue.$6])dnl
116 m4_pushdef([b4_at_dollar], [yylocation])dnl
117 case $4: /* $3 */
118 #line $2 "$1"
119 $5;
120 #line __oline__ "__ofile__"
121 break;
122 m4_popdef([b4_at_dollar])dnl
123 m4_popdef([b4_dollar_dollar])dnl
124 ])
125
126
127
128 m4_divert(0)dnl
129 #output "b4_output_parser_name"
130 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
131 [1984, 1989, 1990, 2000, 2001, 2002])
132
133 /* Written by Richard Stallman by simplifying the original so called
134 ``semantic'' parser. */
135
136 /* All symbols defined below should begin with yy or YY, to avoid
137 infringing on user name space. This should be done even for local
138 variables, as they might otherwise be expanded by user macros.
139 There are some unavoidable exceptions within include files to
140 define necessary library symbols; they are noted "INFRINGES ON
141 USER NAME SPACE" below. */
142
143 /* Identify Bison output. */
144 #define YYBISON 1
145
146 /* Pure parsers. */
147 #define YYPURE b4_pure
148
149 /* Using locations. */
150 #define YYLSP_NEEDED b4_locations_flag
151
152 m4_if(b4_prefix[], [yy], [],
153 [/* If NAME_PREFIX is specified substitute the variables and functions
154 names. */
155 #define yyparse b4_prefix[]parse
156 #define yylex b4_prefix[]lex
157 #define yyerror b4_prefix[]error
158 #define yylval b4_prefix[]lval
159 #define yychar b4_prefix[]char
160 #define yydebug b4_prefix[]debug
161 #define yynerrs b4_prefix[]nerrs
162 b4_location_if([#define yylloc b4_prefix[]lloc])])
163
164 /* Copy the first part of user declarations. */
165 b4_pre_prologue
166
167 b4_token_defines(b4_tokens)
168
169 /* Enabling traces. */
170 #ifndef YYDEBUG
171 # define YYDEBUG b4_debug
172 #endif
173
174 /* Enabling verbose error messages. */
175 #ifdef YYERROR_VERBOSE
176 # undef YYERROR_VERBOSE
177 # define YYERROR_VERBOSE 1
178 #else
179 # define YYERROR_VERBOSE b4_error_verbose
180 #endif
181
182 #ifndef YYSTYPE
183 m4_ifdef([b4_stype],
184 [#line b4_stype_line "b4_filename"
185 typedef union b4_stype yystype;
186 /* Line __line__ of __file__. */
187 #line __oline__ "__ofile__"],
188 [typedef int yystype;])
189 # define YYSTYPE yystype
190 # define YYSTYPE_IS_TRIVIAL 1
191 #endif
192
193 #ifndef YYLTYPE
194 typedef struct yyltype
195 {
196 int first_line;
197 int first_column;
198 int last_line;
199 int last_column;
200 } yyltype;
201 # define YYLTYPE b4_ltype
202 # define YYLTYPE_IS_TRIVIAL 1
203 #endif
204
205 /* Copy the second part of user declarations. */
206 b4_post_prologue
207
208 /* Line __line__ of __file__. */
209 #line __oline__ "__ofile__"
210
211 #if ! defined (yyoverflow) || YYERROR_VERBOSE
212
213 /* The parser invokes alloca or malloc; define the necessary symbols. */
214
215 # if YYSTACK_USE_ALLOCA
216 # define YYSTACK_ALLOC alloca
217 # else
218 # ifndef YYSTACK_USE_ALLOCA
219 # if defined (alloca) || defined (_ALLOCA_H)
220 # define YYSTACK_ALLOC alloca
221 # else
222 # ifdef __GNUC__
223 # define YYSTACK_ALLOC __builtin_alloca
224 # endif
225 # endif
226 # endif
227 # endif
228
229 # ifdef YYSTACK_ALLOC
230 /* Pacify GCC's `empty if-body' warning. */
231 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
232 # else
233 # if defined (__STDC__) || defined (__cplusplus)
234 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
235 # define YYSIZE_T size_t
236 # endif
237 # define YYSTACK_ALLOC malloc
238 # define YYSTACK_FREE free
239 # endif
240 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
241
242
243 #if (! defined (yyoverflow) \
244 && (! defined (__cplusplus) \
245 || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
246
247 /* A type that is properly aligned for any stack member. */
248 union yyalloc
249 {
250 short yyss;
251 YYSTYPE yyvs;
252 b4_location_if([ YYLTYPE yyls;
253 ])dnl
254 };
255
256 /* The size of the maximum gap between one aligned stack and the next. */
257 # define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
258
259 /* The size of an array large to enough to hold all stacks, each with
260 N elements. */
261 b4_location_if(
262 [# define YYSTACK_BYTES(N) \
263 ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
264 + 2 * YYSTACK_GAP_MAX)],
265 [# define YYSTACK_BYTES(N) \
266 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
267 + YYSTACK_GAP_MAX)])
268
269 /* Copy COUNT objects from FROM to TO. The source and destination do
270 not overlap. */
271 # ifndef YYCOPY
272 # if 1 < __GNUC__
273 # define YYCOPY(To, From, Count) \
274 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
275 # else
276 # define YYCOPY(To, From, Count) \
277 do \
278 { \
279 register YYSIZE_T yyi; \
280 for (yyi = 0; yyi < (Count); yyi++) \
281 (To)[[yyi]] = (From)[[yyi]]; \
282 } \
283 while (0)
284 # endif
285 # endif
286
287 /* Relocate STACK from its old location to the new one. The
288 local variables YYSIZE and YYSTACKSIZE give the old and new number of
289 elements in the stack, and YYPTR gives the new location of the
290 stack. Advance YYPTR to a properly aligned location for the next
291 stack. */
292 # define YYSTACK_RELOCATE(Stack) \
293 do \
294 { \
295 YYSIZE_T yynewbytes; \
296 YYCOPY (&yyptr->Stack, Stack, yysize); \
297 Stack = &yyptr->Stack; \
298 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX; \
299 yyptr += yynewbytes / sizeof (*yyptr); \
300 } \
301 while (0)
302
303 #endif
304
305 /* YYFINAL -- State number of the termination state. */
306 #define YYFINAL b4_final_state_number
307 #define YYLAST b4_last
308
309 /* YYNTOKENS -- Number of terminals. */
310 #define YYNTOKENS b4_tokens_number
311 /* YYNNTS -- Number of nonterminals. */
312 #define YYNNTS b4_nterms_number
313 /* YYNRULES -- Number of rules. */
314 #define YYNRULES b4_rules_number
315 /* YYNRULES -- Number of states. */
316 #define YYNSTATES b4_states_number
317
318 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
319 #define YYUNDEFTOK b4_undef_token_number
320 #define YYMAXUTOK b4_user_token_number_max
321
322 #define YYTRANSLATE(X) \
323 ((unsigned)(X) <= YYMAXUTOK ? yytranslate[[X]] : YYUNDEFTOK)
324
325 /* YYTRANSLATE[[YYLEX]] -- Bison symbol number corresponding to YYLEX. */
326 static const b4_int_type_for([b4_translate]) yytranslate[[]] =
327 {
328 b4_translate
329 };
330
331 #if YYDEBUG
332 /* YYPRHS[[YYN]] -- Index of the first RHS symbol of rule number YYN in
333 YYRHS. */
334 static const b4_int_type_for([b4_prhs]) yyprhs[[]] =
335 {
336 b4_prhs
337 };
338
339 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
340 static const b4_int_type_for([b4_rhs]) yyrhs[[]] =
341 {
342 b4_rhs
343 };
344
345 /* YYRLINE[[YYN]] -- source line where rule number YYN was defined. */
346 static const b4_int_type_for([b4_rline]) yyrline[[]] =
347 {
348 b4_rline
349 };
350 #endif
351
352 #if YYDEBUG || YYERROR_VERBOSE
353 /* YYTNME[[SYMBOL-NUM]] -- String name of the symbol SYMBOL-NUM.
354 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
355 static const char *const yytname[[]] =
356 {
357 b4_tname
358 };
359 #endif
360
361 # ifdef YYPRINT
362 /* YYTOKNUM[[YYLEX-NUM]] -- Internal token number corresponding to
363 token YYLEX-NUM. */
364 static const b4_int_type_for([b4_toknum]) yytoknum[[]] =
365 {
366 b4_toknum
367 };
368 # endif
369
370 /* YYR1[[YYN]] -- Symbol number of symbol that rule YYN derives. */
371 static const b4_int_type_for([b4_r1]) yyr1[[]] =
372 {
373 b4_r1
374 };
375
376 /* YYR2[[YYN]] -- Number of symbols composing right hand side of rule YYN. */
377 static const b4_int_type_for([b4_r2]) yyr2[[]] =
378 {
379 b4_r2
380 };
381
382 /* YYDEFACT[[STATE-NAME]] -- Default rule to reduce with in state
383 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
384 means the default is an error. */
385 static const b4_int_type_for([b4_defact]) yydefact[[]] =
386 {
387 b4_defact
388 };
389
390 /* YYDEFGOTO[[NTERM-NUM]]. */
391 static const b4_int_type_for([b4_defgoto]) yydefgoto[[]] =
392 {
393 b4_defgoto
394 };
395
396 /* YYPACT[[STATE-NUM]] -- Index in YYTABLE of the portion describing
397 STATE-NUM. */
398 #define YYPACT_NINF b4_pact_ninf
399 static const b4_int_type_for([b4_pact]) yypact[[]] =
400 {
401 b4_pact
402 };
403
404 /* YYPGOTO[[NTERM-NUM]]. */
405 static const b4_int_type_for([b4_pgoto]) yypgoto[[]] =
406 {
407 b4_pgoto
408 };
409
410 /* YYTABLE[[YYPACT[STATE-NUM]]]. What to do in state STATE-NUM. If
411 positive, shift that token. If negative, reduce the rule which
412 number is the opposite. If zero, do what YYDEFACT says. */
413 #define YYTABLE_NINF b4_table_ninf
414 static const b4_int_type_for([b4_table]) yytable[[]] =
415 {
416 b4_table
417 };
418
419 static const b4_int_type_for([b4_check]) yycheck[[]] =
420 {
421 b4_check
422 };
423
424 /* YYSTOS[[STATE-NUM]] -- The (internal number of the) accessing
425 symbol of state STATE-NUM. */
426 static const b4_int_type_for([b4_stos]) yystos[[]] =
427 {
428 b4_stos
429 };
430
431 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
432 # define YYSIZE_T __SIZE_TYPE__
433 #endif
434 #if ! defined (YYSIZE_T) && defined (size_t)
435 # define YYSIZE_T size_t
436 #endif
437 #if ! defined (YYSIZE_T)
438 # if defined (__STDC__) || defined (__cplusplus)
439 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
440 # define YYSIZE_T size_t
441 # endif
442 #endif
443 #if ! defined (YYSIZE_T)
444 # define YYSIZE_T unsigned int
445 #endif
446
447 #define yyerrok (yyerrstatus = 0)
448 #define yyclearin (yychar = YYEMPTY)
449 #define YYEMPTY -2
450 #define YYEOF 0
451
452 #define YYACCEPT goto yyacceptlab
453 #define YYABORT goto yyabortlab
454 #define YYERROR goto yyerrlab1
455
456 /* Like YYERROR except do call yyerror. This remains here temporarily
457 to ease the transition to the new meaning of YYERROR, for GCC.
458 Once GCC version 2 has supplanted version 1, this can go. */
459
460 #define YYFAIL goto yyerrlab
461
462 #define YYRECOVERING() (!!yyerrstatus)
463
464 #define YYBACKUP(Token, Value) \
465 do \
466 if (yychar == YYEMPTY && yylen == 1) \
467 { \
468 yychar = (Token); \
469 yylval = (Value); \
470 yychar1 = YYTRANSLATE (yychar); \
471 YYPOPSTACK; \
472 goto yybackup; \
473 } \
474 else \
475 { \
476 yyerror ("syntax error: cannot back up"); \
477 YYERROR; \
478 } \
479 while (0)
480
481 #define YYTERROR 1
482 #define YYERRCODE 256
483
484 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
485 are run). */
486
487 #ifndef YYLLOC_DEFAULT
488 # define YYLLOC_DEFAULT(Current, Rhs, N) \
489 Current.first_line = Rhs[[1]].first_line; \
490 Current.first_column = Rhs[[1]].first_column; \
491 Current.last_line = Rhs[[N]].last_line; \
492 Current.last_column = Rhs[[N]].last_column;
493 #endif
494
495 /* YYLEX -- calling `yylex' with the right arguments. */
496
497 b4_pure_if(
498 [#ifdef YYLEX_PARAM
499 # define YYLEX yylex (&yylval[]b4_location_if([, &yylloc]), YYLEX_PARAM)
500 #else
501 # define YYLEX yylex (&yylval[]b4_location_if([, &yylloc]))
502 #endif],
503 [#define YYLEX yylex ()])
504
505 /* Enable debugging if requested. */
506 #if YYDEBUG
507
508 # ifndef YYFPRINTF
509 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
510 # define YYFPRINTF fprintf
511 # endif
512
513 # define YYDPRINTF(Args) \
514 do { \
515 if (yydebug) \
516 YYFPRINTF Args; \
517 } while (0)
518 # define YYDSYMPRINT(Args) \
519 do { \
520 if (yydebug) \
521 yysymprint Args; \
522 } while (0)
523 /* Nonzero means print parse trace. It is left uninitialized so that
524 multiple parsers can coexist. */
525 int yydebug;
526 #else /* !YYDEBUG */
527 # define YYDPRINTF(Args)
528 # define YYDSYMPRINT(Args)
529 #endif /* !YYDEBUG */
530
531 /* YYINITDEPTH -- initial size of the parser's stacks. */
532 #ifndef YYINITDEPTH
533 # define YYINITDEPTH b4_initdepth
534 #endif
535
536 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
537 if the built-in stack extension method is used).
538
539 Do not make this value too large; the results are undefined if
540 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
541 evaluated with infinite-precision integer arithmetic. */
542
543 #if YYMAXDEPTH == 0
544 # undef YYMAXDEPTH
545 #endif
546
547 #ifndef YYMAXDEPTH
548 # define YYMAXDEPTH b4_maxdepth
549 #endif
550
551 \f
552
553 #if YYERROR_VERBOSE
554
555 # ifndef yystrlen
556 # if defined (__GLIBC__) && defined (_STRING_H)
557 # define yystrlen strlen
558 # else
559 /* Return the length of YYSTR. */
560 static YYSIZE_T
561 # if defined (__STDC__) || defined (__cplusplus)
562 yystrlen (const char *yystr)
563 # else
564 yystrlen (yystr)
565 const char *yystr;
566 # endif
567 {
568 register const char *yys = yystr;
569
570 while (*yys++ != '\0')
571 continue;
572
573 return yys - yystr - 1;
574 }
575 # endif
576 # endif
577
578 # ifndef yystpcpy
579 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
580 # define yystpcpy stpcpy
581 # else
582 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
583 YYDEST. */
584 static char *
585 # if defined (__STDC__) || defined (__cplusplus)
586 yystpcpy (char *yydest, const char *yysrc)
587 # else
588 yystpcpy (yydest, yysrc)
589 char *yydest;
590 const char *yysrc;
591 # endif
592 {
593 register char *yyd = yydest;
594 register const char *yys = yysrc;
595
596 while ((*yyd++ = *yys++) != '\0')
597 continue;
598
599 return yyd - 1;
600 }
601 # endif
602 # endif
603
604 #endif /* !YYERROR_VERBOSE */
605
606 \f
607
608 #if YYDEBUG
609 /*-----------------------------.
610 | Print this symbol on YYOUT. |
611 `-----------------------------*/
612
613 b4_c_function([yysymprint],
614 [static void],
615 [[FILE*], [yyout]],
616 [[int], [yytype]],
617 [[YYSTYPE], [yyvalue]]b4_location_if([,
618 [[YYLTYPE], [yylocation]]]))
619 {
620 /* Pacify ``unused variable'' warnings. */
621 (void) yyvalue;
622 b4_location_if([ (void) yylocation;
623 ])dnl
624
625 if (yytype < YYNTOKENS)
626 {
627 YYFPRINTF (yyout, "token %s (", yytname[[yytype]]);
628 # ifdef YYPRINT
629 YYPRINT (yyout, yytoknum[[yytype]], yyvalue);
630 # endif
631 }
632 else
633 YYFPRINTF (yyout, "nterm %s (", yytname[[yytype]]);
634
635 switch (yytype)
636 {
637 m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
638 default:
639 break;
640 }
641 YYFPRINTF (yyout, ")");
642 }
643 #endif /* YYDEBUG. */
644
645
646 /*----------------------------------------------------------.
647 | yyreport_parse_error -- report a parse error in YYSTATE. |
648 `----------------------------------------------------------*/
649
650 b4_c_function([yyreport_parse_error],
651 [static void],
652 [[int], [yystate]],
653 [[int], [yychar]],
654 [[YYSTYPE], [yyvalue]]b4_location_if([,
655 [[YYLTYPE], [yylloc]]]))
656 [{
657 #if YYERROR_VERBOSE
658 int yyn = yypact[yystate];
659
660 if (YYPACT_NINF < yyn && yyn < YYLAST)
661 {
662 YYSIZE_T yysize = 0;
663 int yytype = YYTRANSLATE (yychar);
664 char *yymsg;
665 int yyx, yycount;
666
667 yycount = 0;
668 /* Start YYX at -YYN if negative to avoid negative indexes in
669 YYCHECK. */
670 for (yyx = yyn < 0 ? -yyn : 0;
671 yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
672 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
673 yysize += yystrlen (yytname[yyx]) + 15, yycount++;
674 yysize += yystrlen ("parse error, unexpected ") + 1;
675 yysize += yystrlen (yytname[yytype]);
676 yymsg = (char *) YYSTACK_ALLOC (yysize);
677 if (yymsg != 0)
678 {
679 char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
680 yyp = yystpcpy (yyp, yytname[yytype]);
681
682 if (yycount < 5)
683 {
684 yycount = 0;
685 for (yyx = yyn < 0 ? -yyn : 0;
686 yyx < (int) (sizeof (yytname) / sizeof (char *));
687 yyx++)
688 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
689 {
690 const char *yyq = ! yycount ? ", expecting " : " or ";
691 yyp = yystpcpy (yyp, yyq);
692 yyp = yystpcpy (yyp, yytname[yyx]);
693 yycount++;
694 }
695 }
696 yyerror (yymsg);
697 YYSTACK_FREE (yymsg);
698 }
699 else
700 yyerror ("parse error; also virtual memory exhausted");
701 }
702 else
703 #endif /* YYERROR_VERBOSE */
704 yyerror ("parse error");
705
706 /* Pacify ``unused variable'' warnings. */
707 (void) yystate;
708 (void) yychar;
709 (void) yyvalue;
710 ]b4_location_if([(void) yylloc;])[
711 }]
712
713
714 /*-----------------------------------------------.
715 | Release the memory associated to this symbol. |
716 `-----------------------------------------------*/
717
718 b4_c_function([yydestruct],
719 [static void],
720 [[int], [yytype]],
721 [[YYSTYPE], [yyvalue]]b4_location_if([,
722 [[YYLTYPE], [yylocation]]]))
723 {
724 /* Pacify ``unused variable'' warnings. */
725 (void) yyvalue;
726 b4_location_if([ (void) yylocation;
727 ])dnl
728
729 switch (yytype)
730 {
731 m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))dnl
732 default:
733 break;
734 }
735 }
736
737 \f
738
739 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
740 into yyparse. The argument should have type void *.
741 It should actually point to an object.
742 Grammar actions can access the variable by casting it
743 to the proper pointer type. */
744
745 #ifdef YYPARSE_PARAM
746 # if defined (__STDC__) || defined (__cplusplus)
747 # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
748 # define YYPARSE_PARAM_DECL
749 # else
750 # define YYPARSE_PARAM_ARG YYPARSE_PARAM
751 # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
752 # endif
753 #else /* !YYPARSE_PARAM */
754 # define YYPARSE_PARAM_ARG
755 # define YYPARSE_PARAM_DECL
756 #endif /* !YYPARSE_PARAM */
757
758 /* Prevent warning if -Wstrict-prototypes. */
759 #ifdef __GNUC__
760 # ifdef YYPARSE_PARAM
761 int yyparse (void *);
762 # else
763 int yyparse (void);
764 # endif
765 #endif
766
767 m4_divert_push([KILL])# ======================== M4 code.
768 # b4_declare_parser_variables
769 # ---------------------------
770 # Declare the variables that are global, or local to YYPARSE if
771 # pure-parser
772 m4_define([b4_declare_parser_variables],
773 [/* The lookahead symbol. */
774 int yychar;
775
776 /* The semantic value of the lookahead symbol. */
777 YYSTYPE yylval;
778
779 /* Number of parse errors so far. */
780 int yynerrs;b4_location_if([
781 /* Location data for the lookahead symbol. */
782 YYLTYPE yylloc;])
783 ])
784 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
785
786 b4_pure_if([],
787 [b4_declare_parser_variables])
788
789 int
790 yyparse (YYPARSE_PARAM_ARG)
791 YYPARSE_PARAM_DECL
792 {[
793 ]b4_pure_if([b4_declare_parser_variables])[
794 register int yystate;
795 register int yyn;
796 int yyresult;
797 /* Number of tokens to shift before error messages enabled. */
798 int yyerrstatus;
799 /* Lookahead token as an internal (translated) token number. */
800 int yychar1 = 0;
801
802 /* Three stacks and their tools:
803 `yyss': related to states,
804 `yyvs': related to semantic values,
805 `yyls': related to locations.
806
807 Refer to the stacks thru separate pointers, to allow yyoverflow
808 to reallocate them elsewhere. */
809
810 /* The state stack. */
811 short yyssa[YYINITDEPTH];
812 short *yyss = yyssa;
813 register short *yyssp;
814
815 /* The semantic value stack. */
816 YYSTYPE yyvsa[YYINITDEPTH];
817 YYSTYPE *yyvs = yyvsa;
818 register YYSTYPE *yyvsp;
819
820 ]b4_location_if(
821 [[ /* The location stack. */
822 YYLTYPE yylsa[YYINITDEPTH];
823 YYLTYPE *yyls = yylsa;
824 YYLTYPE *yylsp;]])[
825
826 #define YYPOPSTACK (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
827
828 YYSIZE_T yystacksize = YYINITDEPTH;
829
830 /* The variables used to return semantic value and location from the
831 action routines. */
832 YYSTYPE yyval;
833 ]b4_location_if([ YYLTYPE yyloc;])[
834
835 /* When reducing, the number of symbols on the RHS of the reduced
836 rule. */
837 int yylen;
838
839 YYDPRINTF ((stderr, "Starting parse\n"));
840
841 yystate = 0;
842 yyerrstatus = 0;
843 yynerrs = 0;
844 yychar = YYEMPTY; /* Cause a token to be read. */
845
846 /* Initialize stack pointers.
847 Waste one element of value and location stack
848 so that they stay on the same level as the state stack.
849 The wasted elements are never initialized. */
850
851 yyssp = yyss;
852 yyvsp = yyvs;
853 ]b4_location_if([ yylsp = yyls;])[
854 goto yysetstate;
855
856 /*------------------------------------------------------------.
857 | yynewstate -- Push a new state, which is found in yystate. |
858 `------------------------------------------------------------*/
859 yynewstate:
860 /* In all cases, when you get here, the value and location stacks
861 have just been pushed. so pushing a state here evens the stacks.
862 */
863 yyssp++;
864
865 yysetstate:
866 *yyssp = yystate;
867
868 if (yyssp >= yyss + yystacksize - 1)
869 {
870 /* Get the current used size of the three stacks, in elements. */
871 YYSIZE_T yysize = yyssp - yyss + 1;
872
873 #ifdef yyoverflow
874 {
875 /* Give user a chance to reallocate the stack. Use copies of
876 these so that the &'s don't force the real ones into
877 memory. */
878 YYSTYPE *yyvs1 = yyvs;
879 short *yyss1 = yyss;
880 ]b4_location_if([ YYLTYPE *yyls1 = yyls;])[
881
882 /* Each stack pointer address is followed by the size of the
883 data in use in that stack, in bytes. This used to be a
884 conditional around just the two extra args, but that might
885 be undefined if yyoverflow is a macro. */
886 yyoverflow ("parser stack overflow",
887 &yyss1, yysize * sizeof (*yyssp),
888 &yyvs1, yysize * sizeof (*yyvsp),
889 ]b4_location_if([ &yyls1, yysize * sizeof (*yylsp),])[
890 &yystacksize);
891 ]b4_location_if([ yyls = yyls1;])[
892 yyss = yyss1;
893 yyvs = yyvs1;
894 }
895 #else /* no yyoverflow */
896 # ifndef YYSTACK_RELOCATE
897 goto yyoverflowlab;
898 # else
899 /* Extend the stack our own way. */
900 if (yystacksize >= YYMAXDEPTH)
901 goto yyoverflowlab;
902 yystacksize *= 2;
903 if (yystacksize > YYMAXDEPTH)
904 yystacksize = YYMAXDEPTH;
905
906 {
907 short *yyss1 = yyss;
908 union yyalloc *yyptr =
909 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
910 if (! yyptr)
911 goto yyoverflowlab;
912 YYSTACK_RELOCATE (yyss);
913 YYSTACK_RELOCATE (yyvs);
914 ]b4_location_if([ YYSTACK_RELOCATE (yyls);])[
915 # undef YYSTACK_RELOCATE
916 if (yyss1 != yyssa)
917 YYSTACK_FREE (yyss1);
918 }
919 # endif
920 #endif /* no yyoverflow */
921
922 yyssp = yyss + yysize - 1;
923 yyvsp = yyvs + yysize - 1;
924 ]b4_location_if([ yylsp = yyls + yysize - 1;])[
925
926 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
927 (unsigned long int) yystacksize));
928
929 if (yyssp >= yyss + yystacksize - 1)
930 YYABORT;
931 }
932
933 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
934
935 goto yybackup;
936
937 /*-----------.
938 | yybackup. |
939 `-----------*/
940 yybackup:
941
942 /* Do appropriate processing given the current state. */
943 /* Read a lookahead token if we need one and don't already have one. */
944 /* yyresume: */
945
946 /* First try to decide what to do without reference to lookahead token. */
947
948 yyn = yypact[yystate];
949 if (yyn == YYPACT_NINF)
950 goto yydefault;
951
952 /* Not known => get a lookahead token if don't already have one. */
953
954 /* yychar is either YYEMPTY or YYEOF
955 or a valid token in external form. */
956
957 if (yychar == YYEMPTY)
958 {
959 YYDPRINTF ((stderr, "Reading a token: "));
960 yychar = YYLEX;
961 }
962
963 /* Convert token to internal form (in yychar1) for indexing tables with. */
964
965 if (yychar <= 0) /* This means end of input. */
966 {
967 yychar1 = 0;
968 yychar = YYEOF; /* Don't call YYLEX any more. */
969
970 YYDPRINTF ((stderr, "Now at end of input.\n"));
971 }
972 else
973 {
974 yychar1 = YYTRANSLATE (yychar);
975
976 /* We have to keep this `#if YYDEBUG', since we use variables
977 which are defined only if `YYDEBUG' is set. */
978 YYDPRINTF ((stderr, "Next token is "));
979 YYDSYMPRINT ((stderr, yychar1, yylval]b4_location_if([, yyloc])[));
980 YYDPRINTF ((stderr, "\n"));
981 }
982
983 yyn += yychar1;
984 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
985 goto yydefault;
986
987 yyn = yytable[yyn];
988
989 /* yyn is what to do for this token type in this state.
990 Negative => reduce, -yyn is rule number.
991 Positive => shift, yyn is new state.
992 New state is final state => don't bother to shift,
993 just return success.
994 0, or most negative number => error. */
995
996 if (yyn < 0)
997 {
998 if (yyn == YYTABLE_NINF)
999 goto yyerrlab;
1000 yyn = -yyn;
1001 goto yyreduce;
1002 }
1003 else if (yyn == 0)
1004 goto yyerrlab;
1005
1006 if (yyn == YYFINAL)
1007 YYACCEPT;
1008
1009 /* Shift the lookahead token. */
1010 YYDPRINTF ((stderr, "Shifting token %d (%s), ",
1011 yychar, yytname[yychar1]));
1012
1013 /* Discard the token being shifted unless it is eof. */
1014 if (yychar != YYEOF)
1015 yychar = YYEMPTY;
1016
1017 *++yyvsp = yylval;
1018 ]b4_location_if([ *++yylsp = yylloc;])[
1019
1020 /* Count tokens shifted since error; after three, turn off error
1021 status. */
1022 if (yyerrstatus)
1023 yyerrstatus--;
1024
1025 yystate = yyn;
1026 goto yynewstate;
1027
1028
1029 /*-----------------------------------------------------------.
1030 | yydefault -- do the default action for the current state. |
1031 `-----------------------------------------------------------*/
1032 yydefault:
1033 yyn = yydefact[yystate];
1034 if (yyn == 0)
1035 goto yyerrlab;
1036 goto yyreduce;
1037
1038
1039 /*-----------------------------.
1040 | yyreduce -- Do a reduction. |
1041 `-----------------------------*/
1042 yyreduce:
1043 /* yyn is the number of a rule to reduce with. */
1044 yylen = yyr2[yyn];
1045
1046 /* If YYLEN is nonzero, implement the default value of the action:
1047 `$$ = $1'.
1048
1049 Otherwise, the following line sets YYVAL to garbage.
1050 This behavior is undocumented and Bison
1051 users should not rely upon it. Assigning to YYVAL
1052 unconditionally makes the parser a bit smaller, and it avoids a
1053 GCC warning that YYVAL may be used uninitialized. */
1054 yyval = yyvsp[1-yylen];
1055
1056 ]b4_location_if(
1057 [ /* Default location. */
1058 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);])[
1059
1060 #if YYDEBUG
1061 /* We have to keep this `#if YYDEBUG', since we use variables which
1062 are defined only if `YYDEBUG' is set. */
1063 if (yydebug)
1064 {
1065 int yyi;
1066
1067 YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
1068 yyn - 1, yyrline[yyn]);
1069
1070 /* Print the symbols being reduced, and their result. */
1071 for (yyi = yyprhs[yyn]; yyrhs[yyi] >= 0; yyi++)
1072 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
1073 YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1074 }
1075 #endif
1076 switch (yyn)
1077 ]{
1078 b4_actions
1079 }
1080
1081 /* Line __line__ of __file__. */
1082 #line __oline__ "__ofile__"
1083 \f
1084 [ yyvsp -= yylen;
1085 yyssp -= yylen;
1086 ]b4_location_if([ yylsp -= yylen;])[
1087
1088 #if YYDEBUG
1089 if (yydebug)
1090 {
1091 short *yyssp1 = yyss - 1;
1092 YYFPRINTF (stderr, "state stack now");
1093 while (yyssp1 != yyssp)
1094 YYFPRINTF (stderr, " %d", *++yyssp1);
1095 YYFPRINTF (stderr, "\n");
1096 }
1097 #endif
1098
1099 *++yyvsp = yyval;
1100 ]b4_location_if([ *++yylsp = yyloc;])[
1101
1102 /* Now `shift' the result of the reduction. Determine what state
1103 that goes to, based on the state we popped back to and the rule
1104 number reduced by. */
1105
1106 yyn = yyr1[yyn];
1107
1108 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1109 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1110 yystate = yytable[yystate];
1111 else
1112 yystate = yydefgoto[yyn - YYNTOKENS];
1113
1114 goto yynewstate;
1115
1116
1117 /*------------------------------------.
1118 | yyerrlab -- here on detecting error |
1119 `------------------------------------*/
1120 yyerrlab:
1121 /* If not already recovering from an error, report this error. */
1122 if (!yyerrstatus)
1123 {
1124 ++yynerrs;
1125 yyreport_parse_error (yystate, yychar, yylval]b4_location_if([, yylloc])[);
1126 }
1127 goto yyerrlab1;
1128
1129
1130 /*----------------------------------------------------.
1131 | yyerrlab1 -- error raised explicitly by an action. |
1132 `----------------------------------------------------*/
1133 yyerrlab1:
1134 if (yyerrstatus == 3)
1135 {
1136 /* If just tried and failed to reuse lookahead token after an
1137 error, discard it. */
1138
1139 /* Return failure if at end of input. */
1140 if (yychar == YYEOF)
1141 {
1142 /* Pop the error token. */
1143 YYPOPSTACK;
1144 /* Pop the rest of the stack. */
1145 while (yyssp > yyss)
1146 {
1147 YYDPRINTF ((stderr, "Error: popping "));
1148 YYDSYMPRINT ((stderr,
1149 yystos[*yyssp],
1150 *yyvsp]b4_location_if([, *yylsp])[));
1151 YYDPRINTF ((stderr, "\n"));
1152 yydestruct (yystos[*yyssp], *yyvsp]b4_location_if([, *yylsp])[);
1153 YYPOPSTACK;
1154 }
1155 YYABORT;
1156 }
1157
1158 YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
1159 yychar, yytname[yychar1]));
1160 yydestruct (yychar1, yylval]b4_location_if([, yylloc])[);
1161 yychar = YYEMPTY;
1162 }
1163
1164 /* Else will try to reuse lookahead token after shifting the error
1165 token. */
1166
1167 yyerrstatus = 3; /* Each real token shifted decrements this. */
1168
1169 for (;;)
1170 {
1171 yyn = yypact[yystate];
1172 if (yyn != YYPACT_NINF)
1173 {
1174 yyn += YYTERROR;
1175 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1176 {
1177 yyn = yytable[yyn];
1178 if (0 < yyn)
1179 break;
1180 }
1181 }
1182
1183 /* Pop the current state because it cannot handle the error token. */
1184 if (yyssp == yyss)
1185 YYABORT;
1186
1187 YYDPRINTF ((stderr, "Error: popping "));
1188 YYDSYMPRINT ((stderr,
1189 yystos[*yyssp], *yyvsp]b4_location_if([, *yylsp])[));
1190 YYDPRINTF ((stderr, "\n"));
1191
1192 yydestruct (yystos[yystate], *yyvsp]b4_location_if([, *yylsp])[);
1193 yyvsp--;
1194 yystate = *--yyssp;
1195 ]b4_location_if([ yylsp--;])[
1196
1197 #if YYDEBUG
1198 if (yydebug)
1199 {
1200 short *yyssp1 = yyss - 1;
1201 YYFPRINTF (stderr, "Error: state stack now");
1202 while (yyssp1 != yyssp)
1203 YYFPRINTF (stderr, " %d", *++yyssp1);
1204 YYFPRINTF (stderr, "\n");
1205 }
1206 #endif
1207 }
1208
1209 if (yyn == YYFINAL)
1210 YYACCEPT;
1211
1212 YYDPRINTF ((stderr, "Shifting error token, "));
1213
1214 *++yyvsp = yylval;
1215 ]b4_location_if([ *++yylsp = yylloc;])[
1216
1217 yystate = yyn;
1218 goto yynewstate;
1219
1220
1221 /*-------------------------------------.
1222 | yyacceptlab -- YYACCEPT comes here. |
1223 `-------------------------------------*/
1224 yyacceptlab:
1225 yyresult = 0;
1226 goto yyreturn;
1227
1228 /*-----------------------------------.
1229 | yyabortlab -- YYABORT comes here. |
1230 `-----------------------------------*/
1231 yyabortlab:
1232 yyresult = 1;
1233 goto yyreturn;
1234
1235 #ifndef yyoverflow
1236 /*----------------------------------------------.
1237 | yyoverflowlab -- parser overflow comes here. |
1238 `----------------------------------------------*/
1239 yyoverflowlab:
1240 yyerror ("parser stack overflow");
1241 yyresult = 2;
1242 /* Fall through. */
1243 #endif
1244
1245 yyreturn:
1246 #ifndef yyoverflow
1247 if (yyss != yyssa)
1248 YYSTACK_FREE (yyss);
1249 #endif
1250 return yyresult;
1251 ]}
1252
1253
1254 b4_epilogue
1255 m4_if(b4_defines_flag, 0, [],
1256 [#output "b4_output_header_name"
1257 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
1258 [1984, 1989, 1990, 2000, 2001, 2002])
1259
1260 #ifndef b4_header_guard
1261 # define b4_header_guard
1262
1263 b4_token_defines(b4_tokens)
1264
1265 #ifndef YYSTYPE
1266 m4_ifdef([b4_stype],
1267 [#line b4_stype_line "b4_filename"
1268 typedef union b4_stype yystype;
1269 /* Line __line__ of __file__. */
1270 #line __oline__ "__ofile__"],
1271 [typedef int yystype;])
1272 # define YYSTYPE yystype
1273 #endif
1274
1275 b4_pure_if([],
1276 [extern YYSTYPE b4_prefix[]lval;])
1277
1278 b4_location_if(
1279 [#ifndef YYLTYPE
1280 typedef struct yyltype
1281 {
1282 int first_line;
1283 int first_column;
1284 int last_line;
1285 int last_column;
1286 } yyltype;
1287 # define YYLTYPE yyltype
1288 #endif
1289
1290 m4_if(b4_pure, [0],
1291 [extern YYLTYPE b4_prefix[]lloc;])
1292 ])
1293 #endif /* not b4_header_guard */
1294 ])
bison