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


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