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


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