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


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