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


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