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


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