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