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


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