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


f3dcfab47d37165adaeb89846fc14ae1752d502a
[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 b4_token_defines(b4_tokens)
170
171 /* Copy the first part of user declarations. */
172 b4_pre_prologue
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 If YYTABLE_NINF, parse error. */
419 #define YYTABLE_NINF b4_table_ninf
420 static const b4_int_type_for([b4_table]) yytable[[]] =
421 {
422 b4_table
423 };
424
425 static const b4_int_type_for([b4_check]) yycheck[[]] =
426 {
427 b4_check
428 };
429
430 /* YYSTOS[[STATE-NUM]] -- The (internal number of the) accessing
431 symbol of state STATE-NUM. */
432 static const b4_int_type_for([b4_stos]) yystos[[]] =
433 {
434 b4_stos
435 };
436
437 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
438 # define YYSIZE_T __SIZE_TYPE__
439 #endif
440 #if ! defined (YYSIZE_T) && defined (size_t)
441 # define YYSIZE_T size_t
442 #endif
443 #if ! defined (YYSIZE_T)
444 # if defined (__STDC__) || defined (__cplusplus)
445 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
446 # define YYSIZE_T size_t
447 # endif
448 #endif
449 #if ! defined (YYSIZE_T)
450 # define YYSIZE_T unsigned int
451 #endif
452
453 #define yyerrok (yyerrstatus = 0)
454 #define yyclearin (yychar = YYEMPTY)
455 #define YYEMPTY -2
456 #define YYEOF 0
457
458 #define YYACCEPT goto yyacceptlab
459 #define YYABORT goto yyabortlab
460 #define YYERROR goto yyerrlab1
461
462 /* Like YYERROR except do call yyerror. This remains here temporarily
463 to ease the transition to the new meaning of YYERROR, for GCC.
464 Once GCC version 2 has supplanted version 1, this can go. */
465
466 #define YYFAIL goto yyerrlab
467
468 #define YYRECOVERING() (!!yyerrstatus)
469
470 #define YYBACKUP(Token, Value) \
471 do \
472 if (yychar == YYEMPTY && yylen == 1) \
473 { \
474 yychar = (Token); \
475 yylval = (Value); \
476 yychar1 = YYTRANSLATE (yychar); \
477 YYPOPSTACK; \
478 goto yybackup; \
479 } \
480 else \
481 { \
482 yyerror ("syntax error: cannot back up"); \
483 YYERROR; \
484 } \
485 while (0)
486
487 #define YYTERROR 1
488 #define YYERRCODE 256
489
490 /* YYLLOC_DEFAULT -- Compute the default location (before the actions
491 are run). */
492
493 #ifndef YYLLOC_DEFAULT
494 # define YYLLOC_DEFAULT(Current, Rhs, N) \
495 Current.first_line = Rhs[[1]].first_line; \
496 Current.first_column = Rhs[[1]].first_column; \
497 Current.last_line = Rhs[[N]].last_line; \
498 Current.last_column = Rhs[[N]].last_column;
499 #endif
500
501 /* YYLEX -- calling `yylex' with the right arguments. */
502
503 b4_pure_if(
504 [#ifdef YYLEX_PARAM
505 # define YYLEX yylex (&yylval[]b4_location_if([, &yylloc]), YYLEX_PARAM)
506 #else
507 # define YYLEX yylex (&yylval[]b4_location_if([, &yylloc]))
508 #endif],
509 [#define YYLEX yylex ()])
510
511 /* Enable debugging if requested. */
512 #if YYDEBUG
513
514 # ifndef YYFPRINTF
515 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
516 # define YYFPRINTF fprintf
517 # endif
518
519 # define YYDPRINTF(Args) \
520 do { \
521 if (yydebug) \
522 YYFPRINTF Args; \
523 } while (0)
524 # define YYDSYMPRINT(Args) \
525 do { \
526 if (yydebug) \
527 yysymprint Args; \
528 } while (0)
529 /* Nonzero means print parse trace. It is left uninitialized so that
530 multiple parsers can coexist. */
531 int yydebug;
532 #else /* !YYDEBUG */
533 # define YYDPRINTF(Args)
534 # define YYDSYMPRINT(Args)
535 #endif /* !YYDEBUG */
536
537 /* YYINITDEPTH -- initial size of the parser's stacks. */
538 #ifndef YYINITDEPTH
539 # define YYINITDEPTH b4_initdepth
540 #endif
541
542 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
543 if the built-in stack extension method is used).
544
545 Do not make this value too large; the results are undefined if
546 SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
547 evaluated with infinite-precision integer arithmetic. */
548
549 #if YYMAXDEPTH == 0
550 # undef YYMAXDEPTH
551 #endif
552
553 #ifndef YYMAXDEPTH
554 # define YYMAXDEPTH b4_maxdepth
555 #endif
556
557 \f
558
559 #if YYERROR_VERBOSE
560
561 # ifndef yystrlen
562 # if defined (__GLIBC__) && defined (_STRING_H)
563 # define yystrlen strlen
564 # else
565 /* Return the length of YYSTR. */
566 static YYSIZE_T
567 # if defined (__STDC__) || defined (__cplusplus)
568 yystrlen (const char *yystr)
569 # else
570 yystrlen (yystr)
571 const char *yystr;
572 # endif
573 {
574 register const char *yys = yystr;
575
576 while (*yys++ != '\0')
577 continue;
578
579 return yys - yystr - 1;
580 }
581 # endif
582 # endif
583
584 # ifndef yystpcpy
585 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
586 # define yystpcpy stpcpy
587 # else
588 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
589 YYDEST. */
590 static char *
591 # if defined (__STDC__) || defined (__cplusplus)
592 yystpcpy (char *yydest, const char *yysrc)
593 # else
594 yystpcpy (yydest, yysrc)
595 char *yydest;
596 const char *yysrc;
597 # endif
598 {
599 register char *yyd = yydest;
600 register const char *yys = yysrc;
601
602 while ((*yyd++ = *yys++) != '\0')
603 continue;
604
605 return yyd - 1;
606 }
607 # endif
608 # endif
609
610 #endif /* !YYERROR_VERBOSE */
611
612 \f
613
614 #if YYDEBUG
615 /*-----------------------------.
616 | Print this symbol on YYOUT. |
617 `-----------------------------*/
618
619 b4_c_function([yysymprint],
620 [static void],
621 [[FILE*], [yyout]],
622 [[int], [yytype]],
623 [[YYSTYPE], [yyvalue]]b4_location_if([,
624 [[YYLTYPE], [yylocation]]]))
625 {
626 /* Pacify ``unused variable'' warnings. */
627 (void) yyvalue;
628 b4_location_if([ (void) yylocation;
629 ])dnl
630
631 if (yytype < YYNTOKENS)
632 {
633 YYFPRINTF (yyout, "token %s (", yytname[[yytype]]);
634 # ifdef YYPRINT
635 YYPRINT (yyout, yytoknum[[yytype]], yyvalue);
636 # endif
637 }
638 else
639 YYFPRINTF (yyout, "nterm %s (", yytname[[yytype]]);
640
641 switch (yytype)
642 {
643 m4_map([b4_symbol_actions], m4_defn([b4_symbol_printers]))dnl
644 default:
645 break;
646 }
647 YYFPRINTF (yyout, ")");
648 }
649 #endif /* YYDEBUG. */
650
651
652 /*-----------------------------------------------.
653 | Release the memory associated to this symbol. |
654 `-----------------------------------------------*/
655
656 b4_c_function([yydestruct],
657 [static void],
658 [[int], [yytype]],
659 [[YYSTYPE], [yyvalue]]b4_location_if([,
660 [[YYLTYPE], [yylocation]]]))
661 {
662 /* Pacify ``unused variable'' warnings. */
663 (void) yyvalue;
664 b4_location_if([ (void) yylocation;
665 ])dnl
666
667 switch (yytype)
668 {
669 m4_map([b4_symbol_actions], m4_defn([b4_symbol_destructors]))dnl
670 default:
671 break;
672 }
673 }
674
675 \f
676
677 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
678 into yyparse. The argument should have type void *.
679 It should actually point to an object.
680 Grammar actions can access the variable by casting it
681 to the proper pointer type. */
682
683 #ifdef YYPARSE_PARAM
684 # if defined (__STDC__) || defined (__cplusplus)
685 # define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
686 # define YYPARSE_PARAM_DECL
687 # else
688 # define YYPARSE_PARAM_ARG YYPARSE_PARAM
689 # define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
690 # endif
691 #else /* !YYPARSE_PARAM */
692 # define YYPARSE_PARAM_ARG
693 # define YYPARSE_PARAM_DECL
694 #endif /* !YYPARSE_PARAM */
695
696 /* Prevent warning if -Wstrict-prototypes. */
697 #ifdef __GNUC__
698 # ifdef YYPARSE_PARAM
699 int yyparse (void *);
700 # else
701 int yyparse (void);
702 # endif
703 #endif
704
705 m4_divert_push([KILL])# ======================== M4 code.
706 # b4_declare_parser_variables
707 # ---------------------------
708 # Declare the variables that are global, or local to YYPARSE if
709 # pure-parser
710 m4_define([b4_declare_parser_variables],
711 [/* The lookahead symbol. */
712 int yychar;
713
714 /* The semantic value of the lookahead symbol. */
715 YYSTYPE yylval;
716
717 /* Number of parse errors so far. */
718 int yynerrs;b4_location_if([
719 /* Location data for the lookahead symbol. */
720 YYLTYPE yylloc;])
721 ])
722 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
723
724 b4_pure_if([],
725 [b4_declare_parser_variables])
726
727 int
728 yyparse (YYPARSE_PARAM_ARG)
729 YYPARSE_PARAM_DECL
730 {[
731 ]b4_pure_if([b4_declare_parser_variables])[
732 register int yystate;
733 register int yyn;
734 int yyresult;
735 /* Number of tokens to shift before error messages enabled. */
736 int yyerrstatus;
737 /* Lookahead token as an internal (translated) token number. */
738 int yychar1 = 0;
739
740 /* Three stacks and their tools:
741 `yyss': related to states,
742 `yyvs': related to semantic values,
743 `yyls': related to locations.
744
745 Refer to the stacks thru separate pointers, to allow yyoverflow
746 to reallocate them elsewhere. */
747
748 /* The state stack. */
749 short yyssa[YYINITDEPTH];
750 short *yyss = yyssa;
751 register short *yyssp;
752
753 /* The semantic value stack. */
754 YYSTYPE yyvsa[YYINITDEPTH];
755 YYSTYPE *yyvs = yyvsa;
756 register YYSTYPE *yyvsp;
757
758 ]b4_location_if(
759 [[ /* The location stack. */
760 YYLTYPE yylsa[YYINITDEPTH];
761 YYLTYPE *yyls = yylsa;
762 YYLTYPE *yylsp;]])[
763
764 #define YYPOPSTACK (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
765
766 YYSIZE_T yystacksize = YYINITDEPTH;
767
768 /* The variables used to return semantic value and location from the
769 action routines. */
770 YYSTYPE yyval;
771 ]b4_location_if([ YYLTYPE yyloc;])[
772
773 /* When reducing, the number of symbols on the RHS of the reduced
774 rule. */
775 int yylen;
776
777 YYDPRINTF ((stderr, "Starting parse\n"));
778
779 yystate = 0;
780 yyerrstatus = 0;
781 yynerrs = 0;
782 yychar = YYEMPTY; /* Cause a token to be read. */
783
784 /* Initialize stack pointers.
785 Waste one element of value and location stack
786 so that they stay on the same level as the state stack.
787 The wasted elements are never initialized. */
788
789 yyssp = yyss;
790 yyvsp = yyvs;
791 ]b4_location_if([ yylsp = yyls;])[
792 goto yysetstate;
793
794 /*------------------------------------------------------------.
795 | yynewstate -- Push a new state, which is found in yystate. |
796 `------------------------------------------------------------*/
797 yynewstate:
798 /* In all cases, when you get here, the value and location stacks
799 have just been pushed. so pushing a state here evens the stacks.
800 */
801 yyssp++;
802
803 yysetstate:
804 *yyssp = yystate;
805
806 if (yyssp >= yyss + yystacksize - 1)
807 {
808 /* Get the current used size of the three stacks, in elements. */
809 YYSIZE_T yysize = yyssp - yyss + 1;
810
811 #ifdef yyoverflow
812 {
813 /* Give user a chance to reallocate the stack. Use copies of
814 these so that the &'s don't force the real ones into
815 memory. */
816 YYSTYPE *yyvs1 = yyvs;
817 short *yyss1 = yyss;
818 ]b4_location_if([ YYLTYPE *yyls1 = yyls;])[
819
820 /* Each stack pointer address is followed by the size of the
821 data in use in that stack, in bytes. This used to be a
822 conditional around just the two extra args, but that might
823 be undefined if yyoverflow is a macro. */
824 yyoverflow ("parser stack overflow",
825 &yyss1, yysize * sizeof (*yyssp),
826 &yyvs1, yysize * sizeof (*yyvsp),
827 ]b4_location_if([ &yyls1, yysize * sizeof (*yylsp),])[
828 &yystacksize);
829 ]b4_location_if([ yyls = yyls1;])[
830 yyss = yyss1;
831 yyvs = yyvs1;
832 }
833 #else /* no yyoverflow */
834 # ifndef YYSTACK_RELOCATE
835 goto yyoverflowlab;
836 # else
837 /* Extend the stack our own way. */
838 if (yystacksize >= YYMAXDEPTH)
839 goto yyoverflowlab;
840 yystacksize *= 2;
841 if (yystacksize > YYMAXDEPTH)
842 yystacksize = YYMAXDEPTH;
843
844 {
845 short *yyss1 = yyss;
846 union yyalloc *yyptr =
847 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
848 if (! yyptr)
849 goto yyoverflowlab;
850 YYSTACK_RELOCATE (yyss);
851 YYSTACK_RELOCATE (yyvs);
852 ]b4_location_if([ YYSTACK_RELOCATE (yyls);])[
853 # undef YYSTACK_RELOCATE
854 if (yyss1 != yyssa)
855 YYSTACK_FREE (yyss1);
856 }
857 # endif
858 #endif /* no yyoverflow */
859
860 yyssp = yyss + yysize - 1;
861 yyvsp = yyvs + yysize - 1;
862 ]b4_location_if([ yylsp = yyls + yysize - 1;])[
863
864 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
865 (unsigned long int) yystacksize));
866
867 if (yyssp >= yyss + yystacksize - 1)
868 YYABORT;
869 }
870
871 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
872
873 goto yybackup;
874
875 /*-----------.
876 | yybackup. |
877 `-----------*/
878 yybackup:
879
880 /* Do appropriate processing given the current state. */
881 /* Read a lookahead token if we need one and don't already have one. */
882 /* yyresume: */
883
884 /* First try to decide what to do without reference to lookahead token. */
885
886 yyn = yypact[yystate];
887 if (yyn == YYPACT_NINF)
888 goto yydefault;
889
890 /* Not known => get a lookahead token if don't already have one. */
891
892 /* yychar is either YYEMPTY or YYEOF
893 or a valid token in external form. */
894
895 if (yychar == YYEMPTY)
896 {
897 YYDPRINTF ((stderr, "Reading a token: "));
898 yychar = YYLEX;
899 }
900
901 /* Convert token to internal form (in yychar1) for indexing tables with. */
902
903 if (yychar <= 0) /* This means end of input. */
904 {
905 yychar1 = 0;
906 yychar = YYEOF; /* Don't call YYLEX any more. */
907
908 YYDPRINTF ((stderr, "Now at end of input.\n"));
909 }
910 else
911 {
912 yychar1 = YYTRANSLATE (yychar);
913
914 /* We have to keep this `#if YYDEBUG', since we use variables
915 which are defined only if `YYDEBUG' is set. */
916 YYDPRINTF ((stderr, "Next token is "));
917 YYDSYMPRINT ((stderr, yychar1, yylval]b4_location_if([, yyloc])[));
918 YYDPRINTF ((stderr, "\n"));
919 }
920
921 /* Set YYN to the action to take in STATE on seeing token YYCHAR1.
922 Result YYN means
923 - YYN < 0: Reduce on rule -YYN.
924 - YYN = 0: Error.
925 - YYN > 0: Shift to state YYN. */
926 yyn += yychar1;
927 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yychar1)
928 /* Defaulted action (reduction). */
929 yyn = -yydefact[yystate];
930 else if (yytable[yyn] != YYTABLE_NINF)
931 yyn = yytable[yyn];
932 else
933 yyn = 0;
934
935 if (yyn < 0)
936 {
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