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


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