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