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


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