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