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


8f5979026cfd958559208a792e54551d3f4ef38c
[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 b4_yysymprint_generate([b4_c_function_def])
624 #endif /* YYDEBUG. */
625 b4_yydestruct_generate([b4_c_function_def])
626 \f
627
628 /* Prevent warnings from -Wmissing-prototypes. */
629
630 #ifdef YYPARSE_PARAM
631 # if defined (__STDC__) || defined (__cplusplus)
632 int yyparse (void *YYPARSE_PARAM);
633 # else
634 int yyparse ();
635 # endif
636 #else /* ! YYPARSE_PARAM */
637 b4_c_function_decl([yyparse], [int], b4_parse_param)
638 #endif
639
640
641 m4_divert_push([KILL])# ======================== M4 code.
642 # b4_declare_parser_variables
643 # ---------------------------
644 # Declare the variables that are global, or local to YYPARSE if
645 # pure-parser.
646 m4_define([b4_declare_parser_variables],
647 [/* The lookahead symbol. */
648 int yychar;
649
650 /* The semantic value of the lookahead symbol. */
651 YYSTYPE yylval;
652
653 /* Number of parse errors so far. */
654 int yynerrs;b4_location_if([
655 /* Location data for the lookahead symbol. */
656 YYLTYPE yylloc;])
657 ])
658 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
659
660 b4_pure_if([],
661 [b4_declare_parser_variables])
662
663
664 /*----------.
665 | yyparse. |
666 `----------*/
667
668 #ifdef YYPARSE_PARAM
669 # if defined (__STDC__) || defined (__cplusplus)
670 int yyparse (void *YYPARSE_PARAM)
671 # else
672 int yyparse (YYPARSE_PARAM)
673 void *YYPARSE_PARAM;
674 # endif
675 #else /* ! YYPARSE_PARAM */
676 b4_c_function_def([yyparse], [int], b4_parse_param)
677 #endif
678 {[
679 ]b4_pure_if([b4_declare_parser_variables])[
680 register int yystate;
681 register int yyn;
682 int yyresult;
683 /* Number of tokens to shift before error messages enabled. */
684 int yyerrstatus;
685 /* Lookahead token as an internal (translated) token number. */
686 int yytoken = 0;
687
688 /* Three stacks and their tools:
689 `yyss': related to states,
690 `yyvs': related to semantic values,
691 `yyls': related to locations.
692
693 Refer to the stacks thru separate pointers, to allow yyoverflow
694 to reallocate them elsewhere. */
695
696 /* The state stack. */
697 short yyssa[YYINITDEPTH];
698 short *yyss = yyssa;
699 register short *yyssp;
700
701 /* The semantic value stack. */
702 YYSTYPE yyvsa[YYINITDEPTH];
703 YYSTYPE *yyvs = yyvsa;
704 register YYSTYPE *yyvsp;
705
706 ]b4_location_if(
707 [[ /* The location stack. */
708 YYLTYPE yylsa[YYINITDEPTH];
709 YYLTYPE *yyls = yylsa;
710 YYLTYPE *yylsp;]])[
711
712 #define YYPOPSTACK (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
713
714 YYSIZE_T yystacksize = YYINITDEPTH;
715
716 /* The variables used to return semantic value and location from the
717 action routines. */
718 YYSTYPE yyval;
719 ]b4_location_if([ YYLTYPE yyloc;])[
720
721 /* When reducing, the number of symbols on the RHS of the reduced
722 rule. */
723 int yylen;
724
725 YYDPRINTF ((stderr, "Starting parse\n"));
726
727 yystate = 0;
728 yyerrstatus = 0;
729 yynerrs = 0;
730 yychar = yytoken = YYEMPTY; /* Cause a token to be read. */
731
732 /* Initialize stack pointers.
733 Waste one element of value and location stack
734 so that they stay on the same level as the state stack.
735 The wasted elements are never initialized. */
736
737 yyssp = yyss;
738 yyvsp = yyvs;
739 ]b4_location_if([ yylsp = yyls;])[
740 goto yysetstate;
741
742 /*------------------------------------------------------------.
743 | yynewstate -- Push a new state, which is found in yystate. |
744 `------------------------------------------------------------*/
745 yynewstate:
746 /* In all cases, when you get here, the value and location stacks
747 have just been pushed. so pushing a state here evens the stacks.
748 */
749 yyssp++;
750
751 yysetstate:
752 *yyssp = yystate;
753
754 if (yyss + yystacksize - 1 <= yyssp)
755 {
756 /* Get the current used size of the three stacks, in elements. */
757 YYSIZE_T yysize = yyssp - yyss + 1;
758
759 #ifdef yyoverflow
760 {
761 /* Give user a chance to reallocate the stack. Use copies of
762 these so that the &'s don't force the real ones into
763 memory. */
764 YYSTYPE *yyvs1 = yyvs;
765 short *yyss1 = yyss;
766 ]b4_location_if([ YYLTYPE *yyls1 = yyls;])[
767
768 /* Each stack pointer address is followed by the size of the
769 data in use in that stack, in bytes. This used to be a
770 conditional around just the two extra args, but that might
771 be undefined if yyoverflow is a macro. */
772 yyoverflow ("parser stack overflow",
773 &yyss1, yysize * sizeof (*yyssp),
774 &yyvs1, yysize * sizeof (*yyvsp),
775 ]b4_location_if([ &yyls1, yysize * sizeof (*yylsp),])[
776 &yystacksize);
777 ]b4_location_if([ yyls = yyls1;])[
778 yyss = yyss1;
779 yyvs = yyvs1;
780 }
781 #else /* no yyoverflow */
782 # ifndef YYSTACK_RELOCATE
783 goto yyoverflowlab;
784 # else
785 /* Extend the stack our own way. */
786 if (YYMAXDEPTH <= yystacksize)
787 goto yyoverflowlab;
788 yystacksize *= 2;
789 if (YYMAXDEPTH < yystacksize)
790 yystacksize = YYMAXDEPTH;
791
792 {
793 short *yyss1 = yyss;
794 union yyalloc *yyptr =
795 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
796 if (! yyptr)
797 goto yyoverflowlab;
798 YYSTACK_RELOCATE (yyss);
799 YYSTACK_RELOCATE (yyvs);
800 ]b4_location_if([ YYSTACK_RELOCATE (yyls);])[
801 # undef YYSTACK_RELOCATE
802 if (yyss1 != yyssa)
803 YYSTACK_FREE (yyss1);
804 }
805 # endif
806 #endif /* no yyoverflow */
807
808 yyssp = yyss + yysize - 1;
809 yyvsp = yyvs + yysize - 1;
810 ]b4_location_if([ yylsp = yyls + yysize - 1;])[
811
812 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
813 (unsigned long int) yystacksize));
814
815 if (yyss + yystacksize - 1 <= yyssp)
816 YYABORT;
817 }
818
819 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
820
821 goto yybackup;
822
823 /*-----------.
824 | yybackup. |
825 `-----------*/
826 yybackup:
827
828 /* Do appropriate processing given the current state. */
829 /* Read a lookahead token if we need one and don't already have one. */
830 /* yyresume: */
831
832 /* First try to decide what to do without reference to lookahead token. */
833
834 yyn = yypact[yystate];
835 if (yyn == YYPACT_NINF)
836 goto yydefault;
837
838 /* Not known => get a lookahead token if don't already have one. */
839
840 /* YYTOKEN is either YYEMPTY or YYEOF or a valid token. */
841 if (yytoken == YYEMPTY)
842 {
843 YYDPRINTF ((stderr, "Reading a token: "));
844 yychar = YYLEX;
845 yytoken = YYTRANSLATE (yychar);
846 }
847
848 if (yytoken == YYEOF)
849 {
850 YYDPRINTF ((stderr, "Now at end of input.\n"));
851 }
852 else
853 {
854 /* We have to keep this `#if YYDEBUG', since we use variables
855 which are defined only if `YYDEBUG' is set. */
856 YYDPRINTF ((stderr, "Next token is "));
857 YYDSYMPRINT ((stderr, yytoken, &yylval]b4_location_if([, &yyloc])[));
858 YYDPRINTF ((stderr, "\n"));
859 }
860
861 /* If the proper action on seeing token YYTOKEN is to reduce or to
862 detect an error, take that action. */
863 yyn += yytoken;
864 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
865 goto yydefault;
866 yyn = yytable[yyn];
867 if (yyn <= 0)
868 {
869 if (yyn == 0 || yyn == YYTABLE_NINF)
870 goto yyerrlab;
871 yyn = -yyn;
872 goto yyreduce;
873 }
874
875 if (yyn == YYFINAL)
876 YYACCEPT;
877
878 /* Shift the lookahead token. */
879 YYDPRINTF ((stderr, "Shifting token %d (%s), ",
880 yytoken, yytname[yytoken]));
881
882 /* Discard the token being shifted unless it is eof. */
883 if (yytoken != YYEOF)
884 yytoken = YYEMPTY;
885
886 *++yyvsp = yylval;
887 ]b4_location_if([ *++yylsp = yylloc;])[
888
889 /* Count tokens shifted since error; after three, turn off error
890 status. */
891 if (yyerrstatus)
892 yyerrstatus--;
893
894 yystate = yyn;
895 goto yynewstate;
896
897
898 /*-----------------------------------------------------------.
899 | yydefault -- do the default action for the current state. |
900 `-----------------------------------------------------------*/
901 yydefault:
902 yyn = yydefact[yystate];
903 if (yyn == 0)
904 goto yyerrlab;
905 goto yyreduce;
906
907
908 /*-----------------------------.
909 | yyreduce -- Do a reduction. |
910 `-----------------------------*/
911 yyreduce:
912 /* yyn is the number of a rule to reduce with. */
913 yylen = yyr2[yyn];
914
915 /* If YYLEN is nonzero, implement the default value of the action:
916 `$$ = $1'.
917
918 Otherwise, the following line sets YYVAL to garbage.
919 This behavior is undocumented and Bison
920 users should not rely upon it. Assigning to YYVAL
921 unconditionally makes the parser a bit smaller, and it avoids a
922 GCC warning that YYVAL may be used uninitialized. */
923 yyval = yyvsp[1-yylen];
924
925 ]b4_location_if(
926 [ /* Default location. */
927 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);])[
928
929 #if YYDEBUG
930 /* We have to keep this `#if YYDEBUG', since we use variables which
931 are defined only if `YYDEBUG' is set. */
932 if (yydebug)
933 {
934 int yyi;
935
936 YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
937 yyn - 1, yyrline[yyn]);
938
939 /* Print the symbols being reduced, and their result. */
940 for (yyi = yyprhs[yyn]; 0 <= yyrhs[yyi]; yyi++)
941 YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
942 YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
943 }
944 #endif
945 switch (yyn)
946 ]{
947 b4_actions
948 }
949
950 /* Line __line__ of __file__. */
951 b4_syncline([@oline@], [@ofile@])
952 \f
953 [ yyvsp -= yylen;
954 yyssp -= yylen;
955 ]b4_location_if([ yylsp -= yylen;])[
956
957 #if YYDEBUG
958 if (yydebug)
959 {
960 short *yyssp1 = yyss - 1;
961 YYFPRINTF (stderr, "state stack now");
962 while (yyssp1 != yyssp)
963 YYFPRINTF (stderr, " %d", *++yyssp1);
964 YYFPRINTF (stderr, "\n");
965 }
966 #endif
967
968 *++yyvsp = yyval;
969 ]b4_location_if([ *++yylsp = yyloc;])[
970
971 /* Now `shift' the result of the reduction. Determine what state
972 that goes to, based on the state we popped back to and the rule
973 number reduced by. */
974
975 yyn = yyr1[yyn];
976
977 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
978 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
979 yystate = yytable[yystate];
980 else
981 yystate = yydefgoto[yyn - YYNTOKENS];
982
983 goto yynewstate;
984
985
986 /*------------------------------------.
987 | yyerrlab -- here on detecting error |
988 `------------------------------------*/
989 yyerrlab:
990 /* If not already recovering from an error, report this error. */
991 if (!yyerrstatus)
992 {
993 ++yynerrs;
994 #if YYERROR_VERBOSE
995 yyn = yypact[yystate];
996
997 if (YYPACT_NINF < yyn && yyn < YYLAST)
998 {
999 YYSIZE_T yysize = 0;
1000 int yytype = YYTRANSLATE (yychar);
1001 char *yymsg;
1002 int yyx, yycount;
1003
1004 yycount = 0;
1005 /* Start YYX at -YYN if negative to avoid negative indexes in
1006 YYCHECK. */
1007 for (yyx = yyn < 0 ? -yyn : 0;
1008 yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1009 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1010 yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1011 yysize += yystrlen ("parse error, unexpected ") + 1;
1012 yysize += yystrlen (yytname[yytype]);
1013 yymsg = (char *) YYSTACK_ALLOC (yysize);
1014 if (yymsg != 0)
1015 {
1016 char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
1017 yyp = yystpcpy (yyp, yytname[yytype]);
1018
1019 if (yycount < 5)
1020 {
1021 yycount = 0;
1022 for (yyx = yyn < 0 ? -yyn : 0;
1023 yyx < (int) (sizeof (yytname) / sizeof (char *));
1024 yyx++)
1025 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1026 {
1027 const char *yyq = ! yycount ? ", expecting " : " or ";
1028 yyp = yystpcpy (yyp, yyq);
1029 yyp = yystpcpy (yyp, yytname[yyx]);
1030 yycount++;
1031 }
1032 }
1033 yyerror (]b4_yyerror_args[yymsg);
1034 YYSTACK_FREE (yymsg);
1035 }
1036 else
1037 yyerror (]b4_yyerror_args["parse error; also virtual memory exhausted");
1038 }
1039 else
1040 #endif /* YYERROR_VERBOSE */
1041 yyerror (]b4_yyerror_args["parse error");
1042 }
1043 goto yyerrlab1;
1044
1045
1046 /*----------------------------------------------------.
1047 | yyerrlab1 -- error raised explicitly by an action. |
1048 `----------------------------------------------------*/
1049 yyerrlab1:
1050 if (yyerrstatus == 3)
1051 {
1052 /* If just tried and failed to reuse lookahead token after an
1053 error, discard it. */
1054
1055 /* Return failure if at end of input. */
1056 if (yytoken == YYEOF)
1057 {
1058 /* Pop the error token. */
1059 YYPOPSTACK;
1060 /* Pop the rest of the stack. */
1061 while (yyss < yyssp)
1062 {
1063 YYDPRINTF ((stderr, "Error: popping "));
1064 YYDSYMPRINT ((stderr,
1065 yystos[*yyssp],
1066 yyvsp]b4_location_if([, yylsp])[));
1067 YYDPRINTF ((stderr, "\n"));
1068 yydestruct (yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[);
1069 YYPOPSTACK;
1070 }
1071 YYABORT;
1072 }
1073
1074 YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
1075 yytoken, yytname[yytoken]));
1076 yydestruct (yytoken, &yylval]b4_location_if([, &yylloc])[);
1077 yytoken = YYEMPTY;
1078 }
1079
1080 /* Else will try to reuse lookahead token after shifting the error
1081 token. */
1082
1083 yyerrstatus = 3; /* Each real token shifted decrements this. */
1084
1085 for (;;)
1086 {
1087 yyn = yypact[yystate];
1088 if (yyn != YYPACT_NINF)
1089 {
1090 yyn += YYTERROR;
1091 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1092 {
1093 yyn = yytable[yyn];
1094 if (0 < yyn)
1095 break;
1096 }
1097 }
1098
1099 /* Pop the current state because it cannot handle the error token. */
1100 if (yyssp == yyss)
1101 YYABORT;
1102
1103 YYDPRINTF ((stderr, "Error: popping "));
1104 YYDSYMPRINT ((stderr,
1105 yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[));
1106 YYDPRINTF ((stderr, "\n"));
1107
1108 yydestruct (yystos[yystate], yyvsp]b4_location_if([, yylsp])[);
1109 yyvsp--;
1110 yystate = *--yyssp;
1111 ]b4_location_if([ yylsp--;])[
1112
1113 #if YYDEBUG
1114 if (yydebug)
1115 {
1116 short *yyssp1 = yyss - 1;
1117 YYFPRINTF (stderr, "Error: state stack now");
1118 while (yyssp1 != yyssp)
1119 YYFPRINTF (stderr, " %d", *++yyssp1);
1120 YYFPRINTF (stderr, "\n");
1121 }
1122 #endif
1123 }
1124
1125 if (yyn == YYFINAL)
1126 YYACCEPT;
1127
1128 YYDPRINTF ((stderr, "Shifting error token, "));
1129
1130 *++yyvsp = yylval;
1131 ]b4_location_if([ *++yylsp = yylloc;])[
1132
1133 yystate = yyn;
1134 goto yynewstate;
1135
1136
1137 /*-------------------------------------.
1138 | yyacceptlab -- YYACCEPT comes here. |
1139 `-------------------------------------*/
1140 yyacceptlab:
1141 yyresult = 0;
1142 goto yyreturn;
1143
1144 /*-----------------------------------.
1145 | yyabortlab -- YYABORT comes here. |
1146 `-----------------------------------*/
1147 yyabortlab:
1148 yyresult = 1;
1149 goto yyreturn;
1150
1151 #ifndef yyoverflow
1152 /*----------------------------------------------.
1153 | yyoverflowlab -- parser overflow comes here. |
1154 `----------------------------------------------*/
1155 yyoverflowlab:
1156 yyerror (]b4_yyerror_args["parser stack overflow");
1157 yyresult = 2;
1158 /* Fall through. */
1159 #endif
1160
1161 yyreturn:
1162 #ifndef yyoverflow
1163 if (yyss != yyssa)
1164 YYSTACK_FREE (yyss);
1165 #endif
1166 return yyresult;
1167 ]}
1168
1169
1170 b4_epilogue
1171 m4_if(b4_defines_flag, 0, [],
1172 [@output @output_header_name@
1173 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
1174 [1984, 1989, 1990, 2000, 2001, 2002])
1175
1176 /* As a special exception, when this file is copied by Bison into a
1177 Bison output file, you may use that output file without restriction.
1178 This special exception was added by the Free Software Foundation
1179 in version 1.24 of Bison. */
1180
1181 b4_token_defines(b4_tokens)
1182
1183 #ifndef YYSTYPE
1184 m4_ifdef([b4_stype],
1185 [b4_syncline([b4_stype_line], [b4_filename])
1186 typedef union b4_stype yystype;
1187 /* Line __line__ of __file__. */
1188 b4_syncline([@oline@], [@ofile@])],
1189 [typedef int yystype;])
1190 # define YYSTYPE yystype
1191 # define YYSTYPE_IS_TRIVIAL 1
1192 #endif
1193
1194 b4_pure_if([],
1195 [extern YYSTYPE b4_prefix[]lval;])
1196
1197 b4_location_if(
1198 [#ifndef YYLTYPE
1199 typedef struct yyltype
1200 {
1201 int first_line;
1202 int first_column;
1203 int last_line;
1204 int last_column;
1205 } yyltype;
1206 # define YYLTYPE yyltype
1207 #endif
1208
1209 m4_if(b4_pure, [0],
1210 [extern YYLTYPE b4_prefix[]lloc;])
1211 ])
1212 ])
bison