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


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