/[bison]/bison/data/yacc.c
ViewVC logotype

Contents of /bison/data/yacc.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.62 - (show annotations) (download)
Mon Aug 25 15:16:24 2003 UTC (20 years, 8 months ago) by akim
Branch: MAIN
Changes since 1.61: +11 -1 lines
File MIME type: text/plain
When reducing initial empty rules, Bison parser read an initial
location that is not defined.  This results in garbage, and that
affects Bison's own parser.  Therefore we need (i) to extend Bison
to support a means to initialize this location, and (ii) to use
this CVS Bison to fix CVS Bison's parser.
* src/reader.h, reader.c (epilogue_augment): Remove, replace
with...
* src/muscle_tab.h, src/muscle_tab.c (muscle_code_grow): this.
* src/parse-gram.y: Adjust.
(%initial-action): New.
(%error-verbose): Since we require CVS Bison, there is no reason
not to use it.
* src/scan-gram.l: Adjust.
* src/Makefile.am (YACC): New, to make sure we use our own parser.
* data/yacc.c (yyparse): Use b4_initial_action.

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 # ifndef YYFREE
220 # define YYFREE free
221 # endif
222 # ifndef YYMALLOC
223 # define YYMALLOC malloc
224 # endif
225
226 /* The parser invokes alloca or malloc; define the necessary symbols. */
227
228 # ifdef YYSTACK_USE_ALLOCA
229 # if YYSTACK_USE_ALLOCA
230 # define YYSTACK_ALLOC alloca
231 # endif
232 # else
233 # if defined (alloca) || defined (_ALLOCA_H)
234 # define YYSTACK_ALLOC alloca
235 # else
236 # ifdef __GNUC__
237 # define YYSTACK_ALLOC __builtin_alloca
238 # endif
239 # endif
240 # endif
241
242 # ifdef YYSTACK_ALLOC
243 /* Pacify GCC's `empty if-body' warning. */
244 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
245 # else
246 # if defined (__STDC__) || defined (__cplusplus)
247 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
248 # define YYSIZE_T size_t
249 # endif
250 # define YYSTACK_ALLOC YYMALLOC
251 # define YYSTACK_FREE YYFREE
252 # endif
253 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
254
255
256 #if (! defined (yyoverflow) \
257 && (! defined (__cplusplus) \
258 || (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
259 && ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
260
261 /* A type that is properly aligned for any stack member. */
262 union yyalloc
263 {
264 short yyss;
265 YYSTYPE yyvs;
266 ]b4_location_if([ YYLTYPE yyls;
267 ])dnl
268 [};
269
270 /* The size of the maximum gap between one aligned stack and the next. */
271 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
272
273 /* The size of an array large to enough to hold all stacks, each with
274 N elements. */
275 ]b4_location_if(
276 [# define YYSTACK_BYTES(N) \
277 ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
278 + 2 * YYSTACK_GAP_MAXIMUM)],
279 [# define YYSTACK_BYTES(N) \
280 ((N) * (sizeof (short) + sizeof (YYSTYPE)) \
281 + YYSTACK_GAP_MAXIMUM)])[
282
283 /* Copy COUNT objects from FROM to TO. The source and destination do
284 not overlap. */
285 # ifndef YYCOPY
286 # if defined (__GNUC__) && 1 < __GNUC__
287 # define YYCOPY(To, From, Count) \
288 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
289 # else
290 # define YYCOPY(To, From, Count) \
291 do \
292 { \
293 register YYSIZE_T yyi; \
294 for (yyi = 0; yyi < (Count); yyi++) \
295 (To)[yyi] = (From)[yyi]; \
296 } \
297 while (0)
298 # endif
299 # endif
300
301 /* Relocate STACK from its old location to the new one. The
302 local variables YYSIZE and YYSTACKSIZE give the old and new number of
303 elements in the stack, and YYPTR gives the new location of the
304 stack. Advance YYPTR to a properly aligned location for the next
305 stack. */
306 # define YYSTACK_RELOCATE(Stack) \
307 do \
308 { \
309 YYSIZE_T yynewbytes; \
310 YYCOPY (&yyptr->Stack, Stack, yysize); \
311 Stack = &yyptr->Stack; \
312 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
313 yyptr += yynewbytes / sizeof (*yyptr); \
314 } \
315 while (0)
316
317 #endif
318
319 #if defined (__STDC__) || defined (__cplusplus)
320 typedef signed char yysigned_char;
321 #else
322 typedef short yysigned_char;
323 #endif
324
325 /* YYFINAL -- State number of the termination state. */
326 #define YYFINAL ]b4_final_state_number[
327 /* YYLAST -- Last index in YYTABLE. */
328 #define YYLAST ]b4_last[
329
330 /* YYNTOKENS -- Number of terminals. */
331 #define YYNTOKENS ]b4_tokens_number[
332 /* YYNNTS -- Number of nonterminals. */
333 #define YYNNTS ]b4_nterms_number[
334 /* YYNRULES -- Number of rules. */
335 #define YYNRULES ]b4_rules_number[
336 /* YYNRULES -- Number of states. */
337 #define YYNSTATES ]b4_states_number[
338
339 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
340 #define YYUNDEFTOK ]b4_undef_token_number[
341 #define YYMAXUTOK ]b4_user_token_number_max[
342
343 #define YYTRANSLATE(YYX) \
344 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
345
346 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
347 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
348 {
349 ]b4_translate[
350 };
351
352 #if YYDEBUG
353 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
354 YYRHS. */
355 static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
356 {
357 ]b4_prhs[
358 };
359
360 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
361 static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
362 {
363 ]b4_rhs[
364 };
365
366 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
367 static const ]b4_int_type_for([b4_rline])[ yyrline[] =
368 {
369 ]b4_rline[
370 };
371 #endif
372
373 #if YYDEBUG || YYERROR_VERBOSE
374 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
375 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
376 static const char *const yytname[] =
377 {
378 ]b4_tname[
379 };
380 #endif
381
382 # ifdef YYPRINT
383 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
384 token YYLEX-NUM. */
385 static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
386 {
387 ]b4_toknum[
388 };
389 # endif
390
391 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
392 static const ]b4_int_type_for([b4_r1])[ yyr1[] =
393 {
394 ]b4_r1[
395 };
396
397 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
398 static const ]b4_int_type_for([b4_r2])[ yyr2[] =
399 {
400 ]b4_r2[
401 };
402
403 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
404 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
405 means the default is an error. */
406 static const ]b4_int_type_for([b4_defact])[ yydefact[] =
407 {
408 ]b4_defact[
409 };
410
411 /* YYDEFGOTO[NTERM-NUM]. */
412 static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
413 {
414 ]b4_defgoto[
415 };
416
417 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
418 STATE-NUM. */
419 #define YYPACT_NINF ]b4_pact_ninf[
420 static const ]b4_int_type_for([b4_pact])[ yypact[] =
421 {
422 ]b4_pact[
423 };
424
425 /* YYPGOTO[NTERM-NUM]. */
426 static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
427 {
428 ]b4_pgoto[
429 };
430
431 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
432 positive, shift that token. If negative, reduce the rule which
433 number is the opposite. If zero, do what YYDEFACT says.
434 If YYTABLE_NINF, syntax error. */
435 #define YYTABLE_NINF ]b4_table_ninf[
436 static const ]b4_int_type_for([b4_table])[ yytable[] =
437 {
438 ]b4_table[
439 };
440
441 static const ]b4_int_type_for([b4_check])[ yycheck[] =
442 {
443 ]b4_check[
444 };
445
446 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
447 symbol of state STATE-NUM. */
448 static const ]b4_int_type_for([b4_stos])[ yystos[] =
449 {
450 ]b4_stos[
451 };
452
453 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
454 # define YYSIZE_T __SIZE_TYPE__
455 #endif
456 #if ! defined (YYSIZE_T) && defined (size_t)
457 # define YYSIZE_T size_t
458 #endif
459 #if ! defined (YYSIZE_T)
460 # if defined (__STDC__) || defined (__cplusplus)
461 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
462 # define YYSIZE_T size_t
463 # endif
464 #endif
465 #if ! defined (YYSIZE_T)
466 # define YYSIZE_T unsigned int
467 #endif
468
469 #define yyerrok (yyerrstatus = 0)
470 #define yyclearin (yychar = YYEMPTY)
471 #define YYEMPTY (-2)
472 #define YYEOF 0
473
474 #define YYACCEPT goto yyacceptlab
475 #define YYABORT goto yyabortlab
476 #define YYERROR goto yyerrorlab
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 (included). |
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
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
690
691 #if YYDEBUG
692 ]b4_yysymprint_generate([b4_c_function_def])[
693 #endif /* ! YYDEBUG */
694 ]b4_yydestruct_generate([b4_c_function_def])
695
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 ]m4_ifdef([b4_initial_action], [
811 m4_pushdef([b4_at_dollar], [(*yylsp)])dnl
812 m4_pushdef([b4_dollar_dollar], [(*yyvsp)])dnl
813 /* User initialization code. */
814 b4_initial_action
815 m4_popdef([b4_dollar_dollar])dnl
816 m4_popdef([b4_at_dollar])dnl
817 /* Line __line__ of yacc.c. */
818 b4_syncline([@oline@], [@ofile@])])dnl
819
820 [ goto yysetstate;
821
822 /*------------------------------------------------------------.
823 | yynewstate -- Push a new state, which is found in yystate. |
824 `------------------------------------------------------------*/
825 yynewstate:
826 /* In all cases, when you get here, the value and location stacks
827 have just been pushed. so pushing a state here evens the stacks.
828 */
829 yyssp++;
830
831 yysetstate:
832 *yyssp = yystate;
833
834 if (yyss + yystacksize - 1 <= yyssp)
835 {
836 /* Get the current used size of the three stacks, in elements. */
837 YYSIZE_T yysize = yyssp - yyss + 1;
838
839 #ifdef yyoverflow
840 {
841 /* Give user a chance to reallocate the stack. Use copies of
842 these so that the &'s don't force the real ones into
843 memory. */
844 YYSTYPE *yyvs1 = yyvs;
845 short *yyss1 = yyss;
846 ]b4_location_if([ YYLTYPE *yyls1 = yyls;])[
847
848 /* Each stack pointer address is followed by the size of the
849 data in use in that stack, in bytes. This used to be a
850 conditional around just the two extra args, but that might
851 be undefined if yyoverflow is a macro. */
852 yyoverflow ("parser stack overflow",
853 &yyss1, yysize * sizeof (*yyssp),
854 &yyvs1, yysize * sizeof (*yyvsp),
855 ]b4_location_if([ &yyls1, yysize * sizeof (*yylsp),])[
856 &yystacksize);
857 ]b4_location_if([ yyls = yyls1;])[
858 yyss = yyss1;
859 yyvs = yyvs1;
860 }
861 #else /* no yyoverflow */
862 # ifndef YYSTACK_RELOCATE
863 goto yyoverflowlab;
864 # else
865 /* Extend the stack our own way. */
866 if (YYMAXDEPTH <= yystacksize)
867 goto yyoverflowlab;
868 yystacksize *= 2;
869 if (YYMAXDEPTH < yystacksize)
870 yystacksize = YYMAXDEPTH;
871
872 {
873 short *yyss1 = yyss;
874 union yyalloc *yyptr =
875 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
876 if (! yyptr)
877 goto yyoverflowlab;
878 YYSTACK_RELOCATE (yyss);
879 YYSTACK_RELOCATE (yyvs);
880 ]b4_location_if([ YYSTACK_RELOCATE (yyls);])[
881 # undef YYSTACK_RELOCATE
882 if (yyss1 != yyssa)
883 YYSTACK_FREE (yyss1);
884 }
885 # endif
886 #endif /* no yyoverflow */
887
888 yyssp = yyss + yysize - 1;
889 yyvsp = yyvs + yysize - 1;
890 ]b4_location_if([ yylsp = yyls + yysize - 1;])[
891
892 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
893 (unsigned long int) yystacksize));
894
895 if (yyss + yystacksize - 1 <= yyssp)
896 YYABORT;
897 }
898
899 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
900
901 goto yybackup;
902
903 /*-----------.
904 | yybackup. |
905 `-----------*/
906 yybackup:
907
908 /* Do appropriate processing given the current state. */
909 /* Read a lookahead token if we need one and don't already have one. */
910 /* yyresume: */
911
912 /* First try to decide what to do without reference to lookahead token. */
913
914 yyn = yypact[yystate];
915 if (yyn == YYPACT_NINF)
916 goto yydefault;
917
918 /* Not known => get a lookahead token if don't already have one. */
919
920 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
921 if (yychar == YYEMPTY)
922 {
923 YYDPRINTF ((stderr, "Reading a token: "));
924 yychar = YYLEX;
925 }
926
927 if (yychar <= YYEOF)
928 {
929 yychar = yytoken = YYEOF;
930 YYDPRINTF ((stderr, "Now at end of input.\n"));
931 }
932 else
933 {
934 yytoken = YYTRANSLATE (yychar);
935 YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
936 }
937
938 /* If the proper action on seeing token YYTOKEN is to reduce or to
939 detect an error, take that action. */
940 yyn += yytoken;
941 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
942 goto yydefault;
943 yyn = yytable[yyn];
944 if (yyn <= 0)
945 {
946 if (yyn == 0 || yyn == YYTABLE_NINF)
947 goto yyerrlab;
948 yyn = -yyn;
949 goto yyreduce;
950 }
951
952 if (yyn == YYFINAL)
953 YYACCEPT;
954
955 /* Shift the lookahead token. */
956 YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
957
958 /* Discard the token being shifted unless it is eof. */
959 if (yychar != YYEOF)
960 yychar = YYEMPTY;
961
962 *++yyvsp = yylval;
963 ]b4_location_if([ *++yylsp = yylloc;])[
964
965 /* Count tokens shifted since error; after three, turn off error
966 status. */
967 if (yyerrstatus)
968 yyerrstatus--;
969
970 yystate = yyn;
971 goto yynewstate;
972
973
974 /*-----------------------------------------------------------.
975 | yydefault -- do the default action for the current state. |
976 `-----------------------------------------------------------*/
977 yydefault:
978 yyn = yydefact[yystate];
979 if (yyn == 0)
980 goto yyerrlab;
981 goto yyreduce;
982
983
984 /*-----------------------------.
985 | yyreduce -- Do a reduction. |
986 `-----------------------------*/
987 yyreduce:
988 /* yyn is the number of a rule to reduce with. */
989 yylen = yyr2[yyn];
990
991 /* If YYLEN is nonzero, implement the default value of the action:
992 `$$ = $1'.
993
994 Otherwise, the following line sets YYVAL to garbage.
995 This behavior is undocumented and Bison
996 users should not rely upon it. Assigning to YYVAL
997 unconditionally makes the parser a bit smaller, and it avoids a
998 GCC warning that YYVAL may be used uninitialized. */
999 yyval = yyvsp[1-yylen];
1000
1001 ]b4_location_if(
1002 [ /* Default location. */
1003 YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);])[
1004 YY_REDUCE_PRINT (yyn);
1005 switch (yyn)
1006 ]{
1007 b4_actions
1008 }
1009
1010 /* Line __line__ of yacc.c. */
1011 b4_syncline([@oline@], [@ofile@])
1012
1013 [ yyvsp -= yylen;
1014 yyssp -= yylen;
1015 ]b4_location_if([ yylsp -= yylen;])[
1016
1017 YY_STACK_PRINT (yyss, yyssp);
1018
1019 *++yyvsp = yyval;
1020 ]b4_location_if([ *++yylsp = yyloc;])[
1021
1022 /* Now `shift' the result of the reduction. Determine what state
1023 that goes to, based on the state we popped back to and the rule
1024 number reduced by. */
1025
1026 yyn = yyr1[yyn];
1027
1028 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1029 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1030 yystate = yytable[yystate];
1031 else
1032 yystate = yydefgoto[yyn - YYNTOKENS];
1033
1034 goto yynewstate;
1035
1036
1037 /*------------------------------------.
1038 | yyerrlab -- here on detecting error |
1039 `------------------------------------*/
1040 yyerrlab:
1041 /* If not already recovering from an error, report this error. */
1042 if (!yyerrstatus)
1043 {
1044 ++yynerrs;
1045 #if YYERROR_VERBOSE
1046 yyn = yypact[yystate];
1047
1048 if (YYPACT_NINF < yyn && yyn < YYLAST)
1049 {
1050 YYSIZE_T yysize = 0;
1051 int yytype = YYTRANSLATE (yychar);
1052 const char* yyprefix;
1053 char *yymsg;
1054 int yyx;
1055
1056 /* Start YYX at -YYN if negative to avoid negative indexes in
1057 YYCHECK. */
1058 int yyxbegin = yyn < 0 ? -yyn : 0;
1059
1060 /* Stay within bounds of both yycheck and yytname. */
1061 int yychecklim = YYLAST - yyn;
1062 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1063 int yycount = 0;
1064
1065 yyprefix = ", expecting ";
1066 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1067 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1068 {
1069 yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
1070 yycount += 1;
1071 if (yycount == 5)
1072 {
1073 yysize = 0;
1074 break;
1075 }
1076 }
1077 yysize += (sizeof ("syntax error, unexpected ")
1078 + yystrlen (yytname[yytype]));
1079 yymsg = (char *) YYSTACK_ALLOC (yysize);
1080 if (yymsg != 0)
1081 {
1082 char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
1083 yyp = yystpcpy (yyp, yytname[yytype]);
1084
1085 if (yycount < 5)
1086 {
1087 yyprefix = ", expecting ";
1088 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1089 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1090 {
1091 yyp = yystpcpy (yyp, yyprefix);
1092 yyp = yystpcpy (yyp, yytname[yyx]);
1093 yyprefix = " or ";
1094 }
1095 }
1096 yyerror (]b4_yyerror_args[yymsg);
1097 YYSTACK_FREE (yymsg);
1098 }
1099 else
1100 yyerror (]b4_yyerror_args["syntax error; also virtual memory exhausted");
1101 }
1102 else
1103 #endif /* YYERROR_VERBOSE */
1104 yyerror (]b4_yyerror_args["syntax error");
1105 }
1106
1107 ]b4_location_if([ yylerrsp = yylsp;])[
1108
1109 if (yyerrstatus == 3)
1110 {
1111 /* If just tried and failed to reuse lookahead token after an
1112 error, discard it. */
1113
1114 if (yychar <= YYEOF)
1115 {
1116 /* If at end of input, pop the error token,
1117 then the rest of the stack, then return failure. */
1118 if (yychar == YYEOF)
1119 for (;;)
1120 {
1121 YYPOPSTACK;
1122 if (yyssp == yyss)
1123 YYABORT;
1124 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1125 yydestruct (yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[);
1126 }
1127 }
1128 else
1129 {
1130 YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
1131 yydestruct (yytoken, &yylval]b4_location_if([, &yylloc])[);
1132 yychar = YYEMPTY;
1133 ]b4_location_if([ *++yylerrsp = yylloc;])[
1134 }
1135 }
1136
1137 /* Else will try to reuse lookahead token after shifting the error
1138 token. */
1139 goto yyerrlab1;
1140
1141
1142 /*---------------------------------------------------.
1143 | yyerrorlab -- error raised explicitly by YYERROR. |
1144 `---------------------------------------------------*/
1145 yyerrorlab:
1146
1147 #ifdef __GNUC__
1148 /* Pacify GCC when the user code never invokes YYERROR and the label
1149 yyerrorlab therefore never appears in user code. */
1150 if (0)
1151 goto yyerrorlab;
1152 #endif
1153
1154 yyvsp -= yylen;
1155 yyssp -= yylen;
1156 yystate = *yyssp;
1157 ]b4_location_if([yylerrsp = yylsp;
1158 *++yylerrsp = yyloc;
1159 yylsp -= yylen;
1160 ])[goto yyerrlab1;
1161
1162
1163 /*-------------------------------------------------------------.
1164 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1165 `-------------------------------------------------------------*/
1166 yyerrlab1:
1167 yyerrstatus = 3; /* Each real token shifted decrements this. */
1168
1169 for (;;)
1170 {
1171 yyn = yypact[yystate];
1172 if (yyn != YYPACT_NINF)
1173 {
1174 yyn += YYTERROR;
1175 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1176 {
1177 yyn = yytable[yyn];
1178 if (0 < yyn)
1179 break;
1180 }
1181 }
1182
1183 /* Pop the current state because it cannot handle the error token. */
1184 if (yyssp == yyss)
1185 YYABORT;
1186
1187 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1188 yydestruct (yystos[yystate], yyvsp]b4_location_if([, yylsp])[);
1189 YYPOPSTACK;
1190 yystate = *yyssp;
1191 YY_STACK_PRINT (yyss, yyssp);
1192 }
1193
1194 if (yyn == YYFINAL)
1195 YYACCEPT;
1196
1197 YYDPRINTF ((stderr, "Shifting error token, "));
1198
1199 *++yyvsp = yylval;
1200 ]b4_location_if([ YYLLOC_DEFAULT (yyloc, yylsp, yylerrsp - yylsp);
1201 *++yylsp = yyloc;])[
1202
1203 yystate = yyn;
1204 goto yynewstate;
1205
1206
1207 /*-------------------------------------.
1208 | yyacceptlab -- YYACCEPT comes here. |
1209 `-------------------------------------*/
1210 yyacceptlab:
1211 yyresult = 0;
1212 goto yyreturn;
1213
1214 /*-----------------------------------.
1215 | yyabortlab -- YYABORT comes here. |
1216 `-----------------------------------*/
1217 yyabortlab:
1218 yyresult = 1;
1219 goto yyreturn;
1220
1221 #ifndef yyoverflow
1222 /*----------------------------------------------.
1223 | yyoverflowlab -- parser overflow comes here. |
1224 `----------------------------------------------*/
1225 yyoverflowlab:
1226 yyerror (]b4_yyerror_args["parser stack overflow");
1227 yyresult = 2;
1228 /* Fall through. */
1229 #endif
1230
1231 yyreturn:
1232 #ifndef yyoverflow
1233 if (yyss != yyssa)
1234 YYSTACK_FREE (yyss);
1235 #endif
1236 return yyresult;
1237 ]}
1238
1239
1240 b4_epilogue
1241 m4_if(b4_defines_flag, 0, [],
1242 [@output @output_header_name@
1243 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
1244 [1984, 1989, 1990, 2000, 2001, 2002, 2003])
1245
1246 /* As a special exception, when this file is copied by Bison into a
1247 Bison output file, you may use that output file without restriction.
1248 This special exception was added by the Free Software Foundation
1249 in version 1.24 of Bison. */
1250
1251 b4_token_defines(b4_tokens)
1252
1253 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
1254 m4_ifdef([b4_stype],
1255 [b4_syncline([b4_stype_line], [b4_filename])
1256 typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
1257 /* Line __line__ of yacc.c. */
1258 b4_syncline([@oline@], [@ofile@])],
1259 [typedef int YYSTYPE;])
1260 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1261 # define YYSTYPE_IS_DECLARED 1
1262 # define YYSTYPE_IS_TRIVIAL 1
1263 #endif
1264
1265 b4_pure_if([],
1266 [extern YYSTYPE b4_prefix[]lval;])
1267
1268 b4_location_if(
1269 [#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
1270 typedef struct YYLTYPE
1271 {
1272 int first_line;
1273 int first_column;
1274 int last_line;
1275 int last_column;
1276 } YYLTYPE;
1277 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1278 # define YYLTYPE_IS_DECLARED 1
1279 # define YYLTYPE_IS_TRIVIAL 1
1280 #endif
1281
1282 m4_if(b4_pure, [0],
1283 [extern YYLTYPE b4_prefix[]lloc;])
1284 ])
1285 ])

savannah-hackers-public@gnu.org
ViewVC Help
Powered by ViewVC 1.1.26