]> 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/yacc.c (yy_reduce_print, YY_REDUCE_PRINT):
[bison.git] / data / yacc.c
1 m4_divert(-1) -*- C -*-
2
3 # Yacc compatible skeleton for Bison
4
5 # Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005
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., 51 Franklin Street, Fifth Floor, Boston, MA
21 # 02110-1301 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
34 ## ------------------------ ##
35 ## Pure/impure interfaces. ##
36 ## ------------------------ ##
37
38
39 # b4_yacc_pure_if(IF-TRUE, IF-FALSE)
40 # ----------------------------------
41 # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
42 m4_define([b4_yacc_pure_if],
43 [b4_pure_if([m4_ifset([b4_parse_param],
44 [$1], [$2])],
45 [$2])])
46
47
48 # b4_yyerror_args
49 # ---------------
50 # Arguments passed to yyerror: user args plus yylloc.
51 m4_define([b4_yyerror_args],
52 [b4_yacc_pure_if([b4_location_if([&yylloc, ])])dnl
53 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
54
55
56 # b4_lex_param
57 # ------------
58 # Accumulate in b4_lex_param all the yylex arguments.
59 # b4_lex_param arrives quoted twice, but we want to keep only one level.
60 m4_define([b4_lex_param],
61 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
62 b4_location_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
63 m4_ifdef([b4_lex_param], b4_lex_param)))
64
65
66
67 ## ------------ ##
68 ## Data Types. ##
69 ## ------------ ##
70
71 # b4_int_type(MIN, MAX)
72 # ---------------------
73 # Return the smallest int type able to handle numbers ranging from
74 # MIN to MAX (included). We overwrite the version from c.m4 which relies
75 # on "signed char" which is not portable to old K&R compilers.
76 m4_define([b4_int_type],
77 [m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char],
78 b4_ints_in($@, [-128], [127]), [1], [yysigned_char],
79
80 b4_ints_in($@, [0], [65535]), [1], [unsigned short int],
81 b4_ints_in($@, [-32768], [32767]), [1], [short int],
82
83 m4_eval([0 <= $1]), [1], [unsigned int],
84
85 [int])])
86
87
88 ## ----------------- ##
89 ## Semantic Values. ##
90 ## ----------------- ##
91
92
93 # b4_lhs_value([TYPE])
94 # --------------------
95 # Expansion of $<TYPE>$.
96 m4_define([b4_lhs_value],
97 [(yyval[]m4_ifval([$1], [.$1]))])
98
99
100 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
101 # --------------------------------------
102 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
103 # symbols on RHS.
104 m4_define([b4_rhs_value],
105 [(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$3]))])
106
107
108
109 ## ----------- ##
110 ## Locations. ##
111 ## ----------- ##
112
113 # b4_lhs_location()
114 # -----------------
115 # Expansion of @$.
116 m4_define([b4_lhs_location],
117 [(yyloc)])
118
119
120 # b4_rhs_location(RULE-LENGTH, NUM)
121 # ---------------------------------
122 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
123 # on RHS.
124 m4_define([b4_rhs_location],
125 [(yylsp@{($2) - ($1)@})])
126
127
128
129 ## --------------------------------------------------------- ##
130 ## Defining symbol actions, e.g., printers and destructors. ##
131 ## --------------------------------------------------------- ##
132
133 # We do want M4 expansion after # for CPP macros.
134 m4_changecom()
135 m4_divert(0)dnl
136 @output @output_parser_name@
137 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
138 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005])[
139
140 /* As a special exception, when this file is copied by Bison into a
141 Bison output file, you may use that output file without restriction.
142 This special exception was added by the Free Software Foundation
143 in version 1.24 of Bison. */
144
145 /* Written by Richard Stallman by simplifying the original so called
146 ``semantic'' parser. */
147
148 /* All symbols defined below should begin with yy or YY, to avoid
149 infringing on user name space. This should be done even for local
150 variables, as they might otherwise be expanded by user macros.
151 There are some unavoidable exceptions within include files to
152 define necessary library symbols; they are noted "INFRINGES ON
153 USER NAME SPACE" below. */
154
155 ]b4_identification
156 m4_if(b4_prefix[], [yy], [],
157 [/* Substitute the variable and function names. */
158 #define yyparse b4_prefix[]parse
159 #define yylex b4_prefix[]lex
160 #define yyerror b4_prefix[]error
161 #define yylval b4_prefix[]lval
162 #define yychar b4_prefix[]char
163 #define yydebug b4_prefix[]debug
164 #define yynerrs b4_prefix[]nerrs
165 b4_location_if([#define yylloc b4_prefix[]lloc])])[
166
167 ]b4_token_enums_defines(b4_tokens)[
168
169 /* Copy the first part of user declarations. */
170 ]b4_pre_prologue[
171
172 /* Enabling traces. */
173 #ifndef YYDEBUG
174 # define YYDEBUG ]b4_debug[
175 #endif
176
177 /* Enabling verbose error messages. */
178 #ifdef YYERROR_VERBOSE
179 # undef YYERROR_VERBOSE
180 # define YYERROR_VERBOSE 1
181 #else
182 # define YYERROR_VERBOSE ]b4_error_verbose[
183 #endif
184
185 /* Enabling the token table. */
186 #ifndef YYTOKEN_TABLE
187 # define YYTOKEN_TABLE ]b4_token_table[
188 #endif
189
190 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
191 ]m4_ifdef([b4_stype],
192 [b4_syncline([b4_stype_line], [b4_file_name])
193 typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
194 /* Line __line__ of yacc.c. */
195 b4_syncline([@oline@], [@ofile@])],
196 [typedef int YYSTYPE;])[
197 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
198 # define YYSTYPE_IS_DECLARED 1
199 # define YYSTYPE_IS_TRIVIAL 1
200 #endif
201
202 ]b4_location_if([#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
203 typedef struct YYLTYPE
204 {
205 int first_line;
206 int first_column;
207 int last_line;
208 int last_column;
209 } YYLTYPE;
210 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
211 # define YYLTYPE_IS_DECLARED 1
212 # define YYLTYPE_IS_TRIVIAL 1
213 #endif
214 ])[
215
216 /* Copy the second part of user declarations. */
217 ]b4_post_prologue
218
219 /* Line __line__ of yacc.c. */
220 b4_syncline([@oline@], [@ofile@])[
221
222 /* Define YYMODERN_C if this compiler supports C89 or better. If
223 __STDC__ is defined, the compiler is modern. IBM xlc 7.0 when run
224 as 'cc' doesn't define __STDC__ (or __STDC_VERSION__) for pedantic
225 reasons, but it defines __C99__FUNC__ so check that as well.
226 Consider a C++ compiler to be modern if it defines __cplusplus. */
227 #ifndef YYMODERN_C
228 # if defined (__STDC__) || defined (__C99__FUNC__) || defined (__cplusplus)
229 # define YYMODERN_C 1
230 # else
231 # define YYMODERN_C 0
232 # endif
233 #endif
234
235 #ifndef YYSIZE_T
236 # if defined (__SIZE_TYPE__)
237 # define YYSIZE_T __SIZE_TYPE__
238 # elif defined (size_t)
239 # define YYSIZE_T size_t
240 # elif ! defined (YYSIZE_T) && YYMODERN_C
241 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
242 # define YYSIZE_T size_t
243 # else
244 # define YYSIZE_T unsigned int
245 # endif
246 #endif
247
248 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
249
250 #ifndef YY_
251 # if YYENABLE_NLS
252 # if ENABLE_NLS
253 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
254 # define YY_(msgid) dgettext ("bison-runtime", msgid)
255 # endif
256 # endif
257 # ifndef YY_
258 # define YY_(msgid) msgid
259 # endif
260 #endif
261
262 /* Suppress unused-variable warnings by "using" E. */
263 #define YYUSE(e) do {;} while (/*CONSTCOND*/ 0 && (e))
264
265 #if ! defined (yyoverflow) || YYERROR_VERBOSE
266
267 /* The parser invokes alloca or malloc; define the necessary symbols. */
268
269 # ifdef YYSTACK_USE_ALLOCA
270 # if YYSTACK_USE_ALLOCA
271 # ifdef __GNUC__
272 # define YYSTACK_ALLOC __builtin_alloca
273 # elif defined (__BUILTIN_VA_ARG_INCR)
274 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
275 # elif defined (_AIX)
276 # define YYSTACK_ALLOC __alloca
277 # elif defined (_MSC_VER)
278 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
279 # define alloca _alloca
280 # else
281 # define YYSTACK_ALLOC alloca
282 # if ! defined (_ALLOCA_H) && ! defined (_STDLIB_H) && YYMODERN_C
283 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
284 # ifndef _STDLIB_H
285 # define _STDLIB_H 1
286 # endif
287 # endif
288 # endif
289 # endif
290 # endif
291
292 # ifdef YYSTACK_ALLOC
293 /* Pacify GCC's `empty if-body' warning. */
294 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
295 # ifndef YYSTACK_ALLOC_MAXIMUM
296 /* The OS might guarantee only one guard page at the bottom of the stack,
297 and a page size can be as small as 4096 bytes. So we cannot safely
298 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
299 to allow for a few compiler-allocated temporary stack slots. */
300 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2005 */
301 # endif
302 # else
303 # define YYSTACK_ALLOC YYMALLOC
304 # define YYSTACK_FREE YYFREE
305 # ifndef YYSTACK_ALLOC_MAXIMUM
306 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
307 # endif
308 # ifdef __cplusplus
309 extern "C" {
310 # endif
311 # ifndef YYMALLOC
312 # define YYMALLOC malloc
313 # if ! defined (malloc) && ! defined (_STDLIB_H) && YYMODERN_C
314 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
315 # endif
316 # endif
317 # ifndef YYFREE
318 # define YYFREE free
319 # if ! defined (free) && ! defined (_STDLIB_H) && YYMODERN_C
320 void free (void *); /* INFRINGES ON USER NAME SPACE */
321 # endif
322 # endif
323 # ifdef __cplusplus
324 }
325 # endif
326 # endif
327 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
328
329
330 #if (! defined (yyoverflow) \
331 && (! defined (__cplusplus) \
332 || (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \
333 && ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
334
335 /* A type that is properly aligned for any stack member. */
336 union yyalloc
337 {
338 short int yyss;
339 YYSTYPE yyvs;
340 ]b4_location_if([ YYLTYPE yyls;
341 ])dnl
342 [};
343
344 /* The size of the maximum gap between one aligned stack and the next. */
345 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
346
347 /* The size of an array large to enough to hold all stacks, each with
348 N elements. */
349 ]b4_location_if(
350 [# define YYSTACK_BYTES(N) \
351 ((N) * (sizeof (short int) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
352 + 2 * YYSTACK_GAP_MAXIMUM)],
353 [# define YYSTACK_BYTES(N) \
354 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
355 + YYSTACK_GAP_MAXIMUM)])[
356
357 /* Copy COUNT objects from FROM to TO. The source and destination do
358 not overlap. */
359 # ifndef YYCOPY
360 # if defined (__GNUC__) && 1 < __GNUC__
361 # define YYCOPY(To, From, Count) \
362 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
363 # else
364 # define YYCOPY(To, From, Count) \
365 do \
366 { \
367 YYSIZE_T yyi; \
368 for (yyi = 0; yyi < (Count); yyi++) \
369 (To)[yyi] = (From)[yyi]; \
370 } \
371 while (/*CONSTCOND*/ 0)
372 # endif
373 # endif
374
375 /* Relocate STACK from its old location to the new one. The
376 local variables YYSIZE and YYSTACKSIZE give the old and new number of
377 elements in the stack, and YYPTR gives the new location of the
378 stack. Advance YYPTR to a properly aligned location for the next
379 stack. */
380 # define YYSTACK_RELOCATE(Stack) \
381 do \
382 { \
383 YYSIZE_T yynewbytes; \
384 YYCOPY (&yyptr->Stack, Stack, yysize); \
385 Stack = &yyptr->Stack; \
386 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
387 yyptr += yynewbytes / sizeof (*yyptr); \
388 } \
389 while (/*CONSTCOND*/ 0)
390
391 #endif
392
393 #if YYMODERN_C
394 typedef signed char yysigned_char;
395 #else
396 typedef short int yysigned_char;
397 #endif
398
399 /* YYFINAL -- State number of the termination state. */
400 #define YYFINAL ]b4_final_state_number[
401 /* YYLAST -- Last index in YYTABLE. */
402 #define YYLAST ]b4_last[
403
404 /* YYNTOKENS -- Number of terminals. */
405 #define YYNTOKENS ]b4_tokens_number[
406 /* YYNNTS -- Number of nonterminals. */
407 #define YYNNTS ]b4_nterms_number[
408 /* YYNRULES -- Number of rules. */
409 #define YYNRULES ]b4_rules_number[
410 /* YYNRULES -- Number of states. */
411 #define YYNSTATES ]b4_states_number[
412
413 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
414 #define YYUNDEFTOK ]b4_undef_token_number[
415 #define YYMAXUTOK ]b4_user_token_number_max[
416
417 #define YYTRANSLATE(YYX) \
418 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
419
420 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
421 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
422 {
423 ]b4_translate[
424 };
425
426 #if YYDEBUG
427 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
428 YYRHS. */
429 static const ]b4_int_type_for([b4_prhs])[ yyprhs[] =
430 {
431 ]b4_prhs[
432 };
433
434 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
435 static const ]b4_int_type_for([b4_rhs])[ yyrhs[] =
436 {
437 ]b4_rhs[
438 };
439
440 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
441 static const ]b4_int_type_for([b4_rline])[ yyrline[] =
442 {
443 ]b4_rline[
444 };
445 #endif
446
447 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
448 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
449 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
450 static const char *const yytname[] =
451 {
452 ]b4_tname[
453 };
454 #endif
455
456 # ifdef YYPRINT
457 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
458 token YYLEX-NUM. */
459 static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
460 {
461 ]b4_toknum[
462 };
463 # endif
464
465 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
466 static const ]b4_int_type_for([b4_r1])[ yyr1[] =
467 {
468 ]b4_r1[
469 };
470
471 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
472 static const ]b4_int_type_for([b4_r2])[ yyr2[] =
473 {
474 ]b4_r2[
475 };
476
477 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
478 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
479 means the default is an error. */
480 static const ]b4_int_type_for([b4_defact])[ yydefact[] =
481 {
482 ]b4_defact[
483 };
484
485 /* YYDEFGOTO[NTERM-NUM]. */
486 static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] =
487 {
488 ]b4_defgoto[
489 };
490
491 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
492 STATE-NUM. */
493 #define YYPACT_NINF ]b4_pact_ninf[
494 static const ]b4_int_type_for([b4_pact])[ yypact[] =
495 {
496 ]b4_pact[
497 };
498
499 /* YYPGOTO[NTERM-NUM]. */
500 static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] =
501 {
502 ]b4_pgoto[
503 };
504
505 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
506 positive, shift that token. If negative, reduce the rule which
507 number is the opposite. If zero, do what YYDEFACT says.
508 If YYTABLE_NINF, syntax error. */
509 #define YYTABLE_NINF ]b4_table_ninf[
510 static const ]b4_int_type_for([b4_table])[ yytable[] =
511 {
512 ]b4_table[
513 };
514
515 static const ]b4_int_type_for([b4_check])[ yycheck[] =
516 {
517 ]b4_check[
518 };
519
520 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
521 symbol of state STATE-NUM. */
522 static const ]b4_int_type_for([b4_stos])[ yystos[] =
523 {
524 ]b4_stos[
525 };
526
527 #define yyerrok (yyerrstatus = 0)
528 #define yyclearin (yychar = YYEMPTY)
529 #define YYEMPTY (-2)
530 #define YYEOF 0
531
532 #define YYACCEPT goto yyacceptlab
533 #define YYABORT goto yyabortlab
534 #define YYERROR goto yyerrorlab
535
536
537 /* Like YYERROR except do call yyerror. This remains here temporarily
538 to ease the transition to the new meaning of YYERROR, for GCC.
539 Once GCC version 2 has supplanted version 1, this can go. */
540
541 #define YYFAIL goto yyerrlab
542
543 #define YYRECOVERING() (!!yyerrstatus)
544
545 #define YYBACKUP(Token, Value) \
546 do \
547 if (yychar == YYEMPTY && yylen == 1) \
548 { \
549 yychar = (Token); \
550 yylval = (Value); \
551 yytoken = YYTRANSLATE (yychar); \
552 YYPOPSTACK; \
553 goto yybackup; \
554 } \
555 else \
556 { \
557 yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
558 YYERROR; \
559 } \
560 while (/*CONSTCOND*/ 0)
561
562
563 #define YYTERROR 1
564 #define YYERRCODE 256
565
566
567 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
568 If N is 0, then set CURRENT to the empty location which ends
569 the previous symbol: RHS[0] (always defined). */
570
571 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
572 #ifndef YYLLOC_DEFAULT
573 # define YYLLOC_DEFAULT(Current, Rhs, N) \
574 do \
575 if (N) \
576 { \
577 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
578 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
579 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
580 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
581 } \
582 else \
583 { \
584 (Current).first_line = (Current).last_line = \
585 YYRHSLOC (Rhs, 0).last_line; \
586 (Current).first_column = (Current).last_column = \
587 YYRHSLOC (Rhs, 0).last_column; \
588 } \
589 while (/*CONSTCOND*/ 0)
590 #endif
591
592
593 /* YY_LOCATION_PRINT -- Print the location on the stream.
594 This macro was not mandated originally: define only if we know
595 we won't break user code: when these are the locations we know. */
596
597 #ifndef YY_LOCATION_PRINT
598 # if YYLTYPE_IS_TRIVIAL
599 # define YY_LOCATION_PRINT(File, Loc) \
600 fprintf (File, "%d.%d-%d.%d", \
601 (Loc).first_line, (Loc).first_column, \
602 (Loc).last_line, (Loc).last_column)
603 # else
604 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
605 # endif
606 #endif
607
608
609 /* YYLEX -- calling `yylex' with the right arguments. */
610
611 #ifdef YYLEX_PARAM
612 # define YYLEX yylex (]b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])[YYLEX_PARAM)
613 #else
614 # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
615 #endif
616
617 /* Enable debugging if requested. */
618 #if YYDEBUG
619
620 # ifndef YYFPRINTF
621 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
622 # define YYFPRINTF fprintf
623 # endif
624
625 # define YYDPRINTF(Args) \
626 do { \
627 if (yydebug) \
628 YYFPRINTF Args; \
629 } while (/*CONSTCOND*/ 0)
630
631 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
632 do { \
633 if (yydebug) \
634 { \
635 YYFPRINTF (stderr, "%s ", Title); \
636 yysymprint (stderr, \
637 Type, Value]b4_location_if([, Location])[]b4_user_args[); \
638 YYFPRINTF (stderr, "\n"); \
639 } \
640 } while (/*CONSTCOND*/ 0)
641
642 ]b4_yysymprint_generate([b4_c_function_def])[
643
644 /*------------------------------------------------------------------.
645 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
646 | TOP (included). |
647 `------------------------------------------------------------------*/
648
649 ]b4_c_function_def([yy_stack_print], [static void],
650 [[short int *bottom], [bottom]],
651 [[short int *top], [top]])[
652 {
653 YYFPRINTF (stderr, "Stack now");
654 for (/* Nothing. */; bottom <= top; ++bottom)
655 YYFPRINTF (stderr, " %d", *bottom);
656 YYFPRINTF (stderr, "\n");
657 }
658
659 # define YY_STACK_PRINT(Bottom, Top) \
660 do { \
661 if (yydebug) \
662 yy_stack_print ((Bottom), (Top)); \
663 } while (/*CONSTCOND*/ 0)
664
665
666 /*------------------------------------------------.
667 | Report that the YYRULE is going to be reduced. |
668 `------------------------------------------------*/
669
670 ]b4_c_function_def([yy_reduce_print], [static void],
671 [[YYSTYPE *yyvsp], [yyvsp]],
672 b4_location_if([[[YYLTYPE *yylsp], [yylsp]],])
673 [[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,])
674 b4_parse_param)[
675 {
676 int yynrhs = yyr2[yyrule];
677 int yyi;
678 unsigned long int yylno = yyrline[yyrule];
679 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
680 yyrule - 1, yylno);
681 /* The symbols being reduced. */
682 for (yyi = 0; yyi < yynrhs; yyi++)
683 {
684 fprintf (stderr, " $%d = ", yyi + 1);
685 yysymprint (stderr, yyrhs[yyprhs[yyrule] + yyi],
686 &]b4_rhs_value(yynrhs, yyi + 1)[
687 ]b4_location_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
688 b4_user_args[);
689 fprintf (stderr, "\n");
690 }
691 }
692
693 # define YY_REDUCE_PRINT(Rule) \
694 do { \
695 if (yydebug) \
696 yy_reduce_print (yyvsp, ]b4_location_if([yylsp, ])[Rule]b4_user_args[); \
697 } while (/*CONSTCOND*/ 0)
698
699 /* Nonzero means print parse trace. It is left uninitialized so that
700 multiple parsers can coexist. */
701 int yydebug;
702 #else /* !YYDEBUG */
703 # define YYDPRINTF(Args)
704 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
705 # define YY_STACK_PRINT(Bottom, Top)
706 # define YY_REDUCE_PRINT(Rule)
707 #endif /* !YYDEBUG */
708
709
710 /* YYINITDEPTH -- initial size of the parser's stacks. */
711 #ifndef YYINITDEPTH
712 # define YYINITDEPTH ]b4_stack_depth_init[
713 #endif
714
715 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
716 if the built-in stack extension method is used).
717
718 Do not make this value too large; the results are undefined if
719 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
720 evaluated with infinite-precision integer arithmetic. */
721
722 #ifndef YYMAXDEPTH
723 # define YYMAXDEPTH ]b4_stack_depth_max[
724 #endif
725
726 \f
727
728 #if YYERROR_VERBOSE
729
730 # ifndef yystrlen
731 # if defined (__GLIBC__) && defined (_STRING_H)
732 # define yystrlen strlen
733 # else
734 /* Return the length of YYSTR. */
735 static YYSIZE_T
736 # if YYMODERN_C
737 yystrlen (const char *yystr)
738 # else
739 yystrlen (yystr)
740 const char *yystr;
741 # endif
742 {
743 const char *yys = yystr;
744
745 while (*yys++ != '\0')
746 continue;
747
748 return yys - yystr - 1;
749 }
750 # endif
751 # endif
752
753 # ifndef yystpcpy
754 # if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
755 # define yystpcpy stpcpy
756 # else
757 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
758 YYDEST. */
759 static char *
760 # if YYMODERN_C
761 yystpcpy (char *yydest, const char *yysrc)
762 # else
763 yystpcpy (yydest, yysrc)
764 char *yydest;
765 const char *yysrc;
766 # endif
767 {
768 char *yyd = yydest;
769 const char *yys = yysrc;
770
771 while ((*yyd++ = *yys++) != '\0')
772 continue;
773
774 return yyd - 1;
775 }
776 # endif
777 # endif
778
779 # ifndef yytnamerr
780 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
781 quotes and backslashes, so that it's suitable for yyerror. The
782 heuristic is that double-quoting is unnecessary unless the string
783 contains an apostrophe, a comma, or backslash (other than
784 backslash-backslash). YYSTR is taken from yytname. If YYRES is
785 null, do not copy; instead, return the length of what the result
786 would have been. */
787 static YYSIZE_T
788 yytnamerr (char *yyres, const char *yystr)
789 {
790 if (*yystr == '"')
791 {
792 size_t yyn = 0;
793 char const *yyp = yystr;
794
795 for (;;)
796 switch (*++yyp)
797 {
798 case '\'':
799 case ',':
800 goto do_not_strip_quotes;
801
802 case '\\':
803 if (*++yyp != '\\')
804 goto do_not_strip_quotes;
805 /* Fall through. */
806 default:
807 if (yyres)
808 yyres[yyn] = *yyp;
809 yyn++;
810 break;
811
812 case '"':
813 if (yyres)
814 yyres[yyn] = '\0';
815 return yyn;
816 }
817 do_not_strip_quotes: ;
818 }
819
820 if (! yyres)
821 return yystrlen (yystr);
822
823 return yystpcpy (yyres, yystr) - yyres;
824 }
825 # endif
826
827 /* Copy into YYRESULT an error message about the unexpected token
828 YYCHAR while in state YYSTATE. Return the number of bytes copied,
829 including the terminating null byte. If YYRESULT is null, do not
830 copy anything; just return the number of bytes that would be
831 copied. As a special case, return 0 if an ordinary "syntax error"
832 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
833 size calculation. */
834 static YYSIZE_T
835 yysyntax_error (char *yyresult, int yystate, int yychar)
836 {
837 int yyn = yypact[yystate];
838
839 if (! (YYPACT_NINF < yyn && yyn < YYLAST))
840 return 0;
841 else
842 {
843 int yytype = YYTRANSLATE (yychar);
844 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
845 YYSIZE_T yysize = yysize0;
846 YYSIZE_T yysize1;
847 int yysize_overflow = 0;
848 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
849 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
850 int yyx;
851
852 # if 0
853 /* This is so xgettext sees the translatable formats that are
854 constructed on the fly. */
855 YY_("syntax error, unexpected %s");
856 YY_("syntax error, unexpected %s, expecting %s");
857 YY_("syntax error, unexpected %s, expecting %s or %s");
858 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
859 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
860 # endif
861 char *yyfmt;
862 char const *yyf;
863 static char const yyunexpected[] = "syntax error, unexpected %s";
864 static char const yyexpecting[] = ", expecting %s";
865 static char const yyor[] = " or %s";
866 char yyformat[sizeof yyunexpected
867 + sizeof yyexpecting - 1
868 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
869 * (sizeof yyor - 1))];
870 char const *yyprefix = yyexpecting;
871
872 /* Start YYX at -YYN if negative to avoid negative indexes in
873 YYCHECK. */
874 int yyxbegin = yyn < 0 ? -yyn : 0;
875
876 /* Stay within bounds of both yycheck and yytname. */
877 int yychecklim = YYLAST - yyn;
878 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
879 int yycount = 1;
880
881 yyarg[0] = yytname[yytype];
882 yyfmt = yystpcpy (yyformat, yyunexpected);
883
884 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
885 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
886 {
887 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
888 {
889 yycount = 1;
890 yysize = yysize0;
891 yyformat[sizeof yyunexpected - 1] = '\0';
892 break;
893 }
894 yyarg[yycount++] = yytname[yyx];
895 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
896 yysize_overflow |= yysize1 < yysize;
897 yysize = yysize1;
898 yyfmt = yystpcpy (yyfmt, yyprefix);
899 yyprefix = yyor;
900 }
901
902 yyf = YY_(yyformat);
903 yysize1 = yysize + yystrlen (yyf);
904 yysize_overflow |= yysize1 < yysize;
905 yysize = yysize1;
906
907 if (yysize_overflow)
908 return YYSIZE_MAXIMUM;
909
910 if (yyresult)
911 {
912 /* Avoid sprintf, as that infringes on the user's name space.
913 Don't have undefined behavior even if the translation
914 produced a string with the wrong number of "%s"s. */
915 char *yyp = yyresult;
916 int yyi = 0;
917 while ((*yyp = *yyf))
918 {
919 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
920 {
921 yyp += yytnamerr (yyp, yyarg[yyi++]);
922 yyf += 2;
923 }
924 else
925 {
926 yyp++;
927 yyf++;
928 }
929 }
930 }
931 return yysize;
932 }
933 }
934 #endif /* YYERROR_VERBOSE */
935 \f
936
937 ]b4_yydestruct_generate([b4_c_function_def])[
938 \f
939
940 /* Prevent warnings from -Wmissing-prototypes. */
941
942 #ifdef YYPARSE_PARAM
943 # if YYMODERN_C
944 int yyparse (void *YYPARSE_PARAM);
945 # else
946 int yyparse ();
947 # endif
948 #else /* ! YYPARSE_PARAM */
949 ]b4_c_function_decl([yyparse], [int], b4_parse_param)[
950 #endif /* ! YYPARSE_PARAM */
951
952
953 ]m4_divert_push([KILL])# ======================== M4 code.
954 # b4_declare_parser_variables
955 # ---------------------------
956 # Declare the variables that are global, or local to YYPARSE if
957 # pure-parser.
958 m4_define([b4_declare_parser_variables],
959 [/* The look-ahead symbol. */
960 int yychar;
961
962 /* The semantic value of the look-ahead symbol. */
963 YYSTYPE yylval;
964
965 /* Number of syntax errors so far. */
966 int yynerrs;b4_location_if([
967 /* Location data for the look-ahead symbol. */
968 YYLTYPE yylloc;])
969 ])
970 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
971
972 b4_pure_if([],
973 [b4_declare_parser_variables])
974
975
976 /*----------.
977 | yyparse. |
978 `----------*/
979
980 #ifdef YYPARSE_PARAM
981 # if YYMODERN_C
982 int yyparse (void *YYPARSE_PARAM)
983 # else
984 int yyparse (YYPARSE_PARAM)
985 void *YYPARSE_PARAM;
986 # endif
987 #else /* ! YYPARSE_PARAM */
988 b4_c_function_def([yyparse], [int], b4_parse_param)
989 #endif
990 {[
991 ]b4_pure_if([b4_declare_parser_variables])[
992 int yystate;
993 int yyn;
994 int yyresult;
995 /* Number of tokens to shift before error messages enabled. */
996 int yyerrstatus;
997 /* Look-ahead token as an internal (translated) token number. */
998 int yytoken = 0;
999 #if YYERROR_VERBOSE
1000 /* Buffer for error messages, and its allocated size. */
1001 char yymsgbuf[128];
1002 char *yymsg = yymsgbuf;
1003 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1004 #endif
1005
1006 /* Three stacks and their tools:
1007 `yyss': related to states,
1008 `yyvs': related to semantic values,
1009 `yyls': related to locations.
1010
1011 Refer to the stacks thru separate pointers, to allow yyoverflow
1012 to reallocate them elsewhere. */
1013
1014 /* The state stack. */
1015 short int yyssa[YYINITDEPTH];
1016 short int *yyss = yyssa;
1017 short int *yyssp;
1018
1019 /* The semantic value stack. */
1020 YYSTYPE yyvsa[YYINITDEPTH];
1021 YYSTYPE *yyvs = yyvsa;
1022 YYSTYPE *yyvsp;
1023
1024 ]b4_location_if(
1025 [[ /* The location stack. */
1026 YYLTYPE yylsa[YYINITDEPTH];
1027 YYLTYPE *yyls = yylsa;
1028 YYLTYPE *yylsp;
1029 /* The locations where the error started and ended. */
1030 YYLTYPE yyerror_range[2];]])[
1031
1032 #define YYPOPSTACK (yyvsp--, yyssp--]b4_location_if([, yylsp--])[)
1033
1034 YYSIZE_T yystacksize = YYINITDEPTH;
1035
1036 /* The variables used to return semantic value and location from the
1037 action routines. */
1038 YYSTYPE yyval;
1039 ]b4_location_if([ YYLTYPE yyloc;])[
1040
1041 /* When reducing, the number of symbols on the RHS of the reduced
1042 rule. */
1043 int yylen;
1044
1045 YYDPRINTF ((stderr, "Starting parse\n"));
1046
1047 yystate = 0;
1048 yyerrstatus = 0;
1049 yynerrs = 0;
1050 yychar = YYEMPTY; /* Cause a token to be read. */
1051
1052 /* Initialize stack pointers.
1053 Waste one element of value and location stack
1054 so that they stay on the same level as the state stack.
1055 The wasted elements are never initialized. */
1056
1057 yyssp = yyss;
1058 yyvsp = yyvs;
1059 ]b4_location_if([[ yylsp = yyls;
1060 #if YYLTYPE_IS_TRIVIAL
1061 /* Initialize the default location before parsing starts. */
1062 yylloc.first_line = yylloc.last_line = 1;
1063 yylloc.first_column = yylloc.last_column = 0;
1064 #endif
1065 ]])
1066 m4_ifdef([b4_initial_action], [
1067 m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl
1068 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
1069 /* User initialization code. */
1070 b4_initial_action
1071 m4_popdef([b4_dollar_dollar])dnl
1072 m4_popdef([b4_at_dollar])dnl
1073 /* Line __line__ of yacc.c. */
1074 b4_syncline([@oline@], [@ofile@])
1075 ])dnl
1076 m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval;
1077 ]])dnl
1078 m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc;
1079 ]])dnl
1080 [ goto yysetstate;
1081
1082 /*------------------------------------------------------------.
1083 | yynewstate -- Push a new state, which is found in yystate. |
1084 `------------------------------------------------------------*/
1085 yynewstate:
1086 /* In all cases, when you get here, the value and location stacks
1087 have just been pushed. so pushing a state here evens the stacks.
1088 */
1089 yyssp++;
1090
1091 yysetstate:
1092 *yyssp = yystate;
1093
1094 if (yyss + yystacksize - 1 <= yyssp)
1095 {
1096 /* Get the current used size of the three stacks, in elements. */
1097 YYSIZE_T yysize = yyssp - yyss + 1;
1098
1099 #ifdef yyoverflow
1100 {
1101 /* Give user a chance to reallocate the stack. Use copies of
1102 these so that the &'s don't force the real ones into
1103 memory. */
1104 YYSTYPE *yyvs1 = yyvs;
1105 short int *yyss1 = yyss;
1106 ]b4_location_if([ YYLTYPE *yyls1 = yyls;])[
1107
1108 /* Each stack pointer address is followed by the size of the
1109 data in use in that stack, in bytes. This used to be a
1110 conditional around just the two extra args, but that might
1111 be undefined if yyoverflow is a macro. */
1112 yyoverflow (YY_("memory exhausted"),
1113 &yyss1, yysize * sizeof (*yyssp),
1114 &yyvs1, yysize * sizeof (*yyvsp),
1115 ]b4_location_if([ &yyls1, yysize * sizeof (*yylsp),])[
1116 &yystacksize);
1117 ]b4_location_if([ yyls = yyls1;])[
1118 yyss = yyss1;
1119 yyvs = yyvs1;
1120 }
1121 #else /* no yyoverflow */
1122 # ifndef YYSTACK_RELOCATE
1123 goto yyexhaustedlab;
1124 # else
1125 /* Extend the stack our own way. */
1126 if (YYMAXDEPTH <= yystacksize)
1127 goto yyexhaustedlab;
1128 yystacksize *= 2;
1129 if (YYMAXDEPTH < yystacksize)
1130 yystacksize = YYMAXDEPTH;
1131
1132 {
1133 short int *yyss1 = yyss;
1134 union yyalloc *yyptr =
1135 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1136 if (! yyptr)
1137 goto yyexhaustedlab;
1138 YYSTACK_RELOCATE (yyss);
1139 YYSTACK_RELOCATE (yyvs);
1140 ]b4_location_if([ YYSTACK_RELOCATE (yyls);])[
1141 # undef YYSTACK_RELOCATE
1142 if (yyss1 != yyssa)
1143 YYSTACK_FREE (yyss1);
1144 }
1145 # endif
1146 #endif /* no yyoverflow */
1147
1148 yyssp = yyss + yysize - 1;
1149 yyvsp = yyvs + yysize - 1;
1150 ]b4_location_if([ yylsp = yyls + yysize - 1;])[
1151
1152 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1153 (unsigned long int) yystacksize));
1154
1155 if (yyss + yystacksize - 1 <= yyssp)
1156 YYABORT;
1157 }
1158
1159 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1160
1161 goto yybackup;
1162
1163 /*-----------.
1164 | yybackup. |
1165 `-----------*/
1166 yybackup:
1167
1168 /* Do appropriate processing given the current state. */
1169 /* Read a look-ahead token if we need one and don't already have one. */
1170 /* yyresume: */
1171
1172 /* First try to decide what to do without reference to look-ahead token. */
1173
1174 yyn = yypact[yystate];
1175 if (yyn == YYPACT_NINF)
1176 goto yydefault;
1177
1178 /* Not known => get a look-ahead token if don't already have one. */
1179
1180 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
1181 if (yychar == YYEMPTY)
1182 {
1183 YYDPRINTF ((stderr, "Reading a token: "));
1184 yychar = YYLEX;
1185 }
1186
1187 if (yychar <= YYEOF)
1188 {
1189 yychar = yytoken = YYEOF;
1190 YYDPRINTF ((stderr, "Now at end of input.\n"));
1191 }
1192 else
1193 {
1194 yytoken = YYTRANSLATE (yychar);
1195 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1196 }
1197
1198 /* If the proper action on seeing token YYTOKEN is to reduce or to
1199 detect an error, take that action. */
1200 yyn += yytoken;
1201 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1202 goto yydefault;
1203 yyn = yytable[yyn];
1204 if (yyn <= 0)
1205 {
1206 if (yyn == 0 || yyn == YYTABLE_NINF)
1207 goto yyerrlab;
1208 yyn = -yyn;
1209 goto yyreduce;
1210 }
1211
1212 if (yyn == YYFINAL)
1213 YYACCEPT;
1214
1215 /* Shift the look-ahead token. */
1216 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1217
1218 /* Discard the token being shifted unless it is eof. */
1219 if (yychar != YYEOF)
1220 yychar = YYEMPTY;
1221
1222 *++yyvsp = yylval;
1223 ]b4_location_if([ *++yylsp = yylloc;])[
1224
1225 /* Count tokens shifted since error; after three, turn off error
1226 status. */
1227 if (yyerrstatus)
1228 yyerrstatus--;
1229
1230 yystate = yyn;
1231 goto yynewstate;
1232
1233
1234 /*-----------------------------------------------------------.
1235 | yydefault -- do the default action for the current state. |
1236 `-----------------------------------------------------------*/
1237 yydefault:
1238 yyn = yydefact[yystate];
1239 if (yyn == 0)
1240 goto yyerrlab;
1241 goto yyreduce;
1242
1243
1244 /*-----------------------------.
1245 | yyreduce -- Do a reduction. |
1246 `-----------------------------*/
1247 yyreduce:
1248 /* yyn is the number of a rule to reduce with. */
1249 yylen = yyr2[yyn];
1250
1251 /* If YYLEN is nonzero, implement the default value of the action:
1252 `$$ = $1'.
1253
1254 Otherwise, the following line sets YYVAL to garbage.
1255 This behavior is undocumented and Bison
1256 users should not rely upon it. Assigning to YYVAL
1257 unconditionally makes the parser a bit smaller, and it avoids a
1258 GCC warning that YYVAL may be used uninitialized. */
1259 yyval = yyvsp[1-yylen];
1260
1261 ]b4_location_if(
1262 [[ /* Default location. */
1263 YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);]])[
1264 YY_REDUCE_PRINT (yyn);
1265 switch (yyn)
1266 {
1267 ]b4_actions[
1268 default: break;
1269 }
1270 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1271
1272 /* Line __line__ of yacc.c. */
1273 ]b4_syncline([@oline@], [@ofile@])[
1274 \f
1275 yyvsp -= yylen;
1276 yyssp -= yylen;
1277 ]b4_location_if([ yylsp -= yylen;])[
1278
1279 YY_STACK_PRINT (yyss, yyssp);
1280
1281 *++yyvsp = yyval;
1282 ]b4_location_if([ *++yylsp = yyloc;])[
1283
1284 /* Now `shift' the result of the reduction. Determine what state
1285 that goes to, based on the state we popped back to and the rule
1286 number reduced by. */
1287
1288 yyn = yyr1[yyn];
1289
1290 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1291 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1292 yystate = yytable[yystate];
1293 else
1294 yystate = yydefgoto[yyn - YYNTOKENS];
1295
1296 goto yynewstate;
1297
1298
1299 /*------------------------------------.
1300 | yyerrlab -- here on detecting error |
1301 `------------------------------------*/
1302 yyerrlab:
1303 /* If not already recovering from an error, report this error. */
1304 if (!yyerrstatus)
1305 {
1306 ++yynerrs;
1307 #if ! YYERROR_VERBOSE
1308 yyerror (]b4_yyerror_args[YY_("syntax error"));
1309 #else
1310 {
1311 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1312 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1313 {
1314 YYSIZE_T yyalloc = 2 * yysize;
1315 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1316 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1317 if (yymsg != yymsgbuf)
1318 YYSTACK_FREE (yymsg);
1319 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1320 if (yymsg)
1321 yymsg_alloc = yyalloc;
1322 else
1323 {
1324 yymsg = yymsgbuf;
1325 yymsg_alloc = sizeof yymsgbuf;
1326 }
1327 }
1328
1329 if (0 < yysize && yysize <= yymsg_alloc)
1330 {
1331 (void) yysyntax_error (yymsg, yystate, yychar);
1332 yyerror (]b4_yyerror_args[yymsg);
1333 }
1334 else
1335 {
1336 yyerror (]b4_yyerror_args[YY_("syntax error"));
1337 if (yysize != 0)
1338 goto yyexhaustedlab;
1339 }
1340 }
1341 #endif
1342 }
1343
1344 ]b4_location_if([[ yyerror_range[0] = yylloc;]])[
1345
1346 if (yyerrstatus == 3)
1347 {
1348 /* If just tried and failed to reuse look-ahead token after an
1349 error, discard it. */
1350
1351 if (yychar <= YYEOF)
1352 {
1353 /* Return failure if at end of input. */
1354 if (yychar == YYEOF)
1355 YYABORT;
1356 }
1357 else
1358 {
1359 yydestruct ("Error: discarding",
1360 yytoken, &yylval]b4_location_if([, &yylloc])[]b4_user_args[);
1361 yychar = YYEMPTY;
1362 }
1363 }
1364
1365 /* Else will try to reuse look-ahead token after shifting the error
1366 token. */
1367 goto yyerrlab1;
1368
1369
1370 /*---------------------------------------------------.
1371 | yyerrorlab -- error raised explicitly by YYERROR. |
1372 `---------------------------------------------------*/
1373 yyerrorlab:
1374
1375 /* Pacify compilers like GCC when the user code never invokes
1376 YYERROR and the label yyerrorlab therefore never appears in user
1377 code. */
1378 if (/*CONSTCOND*/ 0)
1379 goto yyerrorlab;
1380
1381 ]b4_location_if([[ yyerror_range[0] = yylsp[1-yylen];
1382 yylsp -= yylen;
1383 ]])[yyvsp -= yylen;
1384 yyssp -= yylen;
1385 yystate = *yyssp;
1386 goto yyerrlab1;
1387
1388
1389 /*-------------------------------------------------------------.
1390 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1391 `-------------------------------------------------------------*/
1392 yyerrlab1:
1393 yyerrstatus = 3; /* Each real token shifted decrements this. */
1394
1395 for (;;)
1396 {
1397 yyn = yypact[yystate];
1398 if (yyn != YYPACT_NINF)
1399 {
1400 yyn += YYTERROR;
1401 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1402 {
1403 yyn = yytable[yyn];
1404 if (0 < yyn)
1405 break;
1406 }
1407 }
1408
1409 /* Pop the current state because it cannot handle the error token. */
1410 if (yyssp == yyss)
1411 YYABORT;
1412
1413 ]b4_location_if([[ yyerror_range[0] = *yylsp;]])[
1414 yydestruct ("Error: popping",
1415 yystos[yystate], yyvsp]b4_location_if([, yylsp])[]b4_user_args[);
1416 YYPOPSTACK;
1417 yystate = *yyssp;
1418 YY_STACK_PRINT (yyss, yyssp);
1419 }
1420
1421 if (yyn == YYFINAL)
1422 YYACCEPT;
1423
1424 *++yyvsp = yylval;
1425 ]b4_location_if([[
1426 yyerror_range[1] = yylloc;
1427 /* Using YYLLOC is tempting, but would change the location of
1428 the look-ahead. YYLOC is available though. */
1429 YYLLOC_DEFAULT (yyloc, yyerror_range - 1, 2);
1430 *++yylsp = yyloc;]])[
1431
1432 /* Shift the error token. */
1433 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1434
1435 yystate = yyn;
1436 goto yynewstate;
1437
1438
1439 /*-------------------------------------.
1440 | yyacceptlab -- YYACCEPT comes here. |
1441 `-------------------------------------*/
1442 yyacceptlab:
1443 yyresult = 0;
1444 goto yyreturn;
1445
1446 /*-----------------------------------.
1447 | yyabortlab -- YYABORT comes here. |
1448 `-----------------------------------*/
1449 yyabortlab:
1450 yyresult = 1;
1451 goto yyreturn;
1452
1453 #ifndef yyoverflow
1454 /*-------------------------------------------------.
1455 | yyexhaustedlab -- memory exhaustion comes here. |
1456 `-------------------------------------------------*/
1457 yyexhaustedlab:
1458 yyerror (]b4_yyerror_args[YY_("memory exhausted"));
1459 yyresult = 2;
1460 /* Fall through. */
1461 #endif
1462
1463 yyreturn:
1464 if (yychar != YYEOF && yychar != YYEMPTY)
1465 yydestruct ("Cleanup: discarding lookahead",
1466 yytoken, &yylval]b4_location_if([, &yylloc])[]b4_user_args[);
1467 while (yyssp != yyss)
1468 {
1469 yydestruct ("Cleanup: popping",
1470 yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[]b4_user_args[);
1471 YYPOPSTACK;
1472 }
1473 #ifndef yyoverflow
1474 if (yyss != yyssa)
1475 YYSTACK_FREE (yyss);
1476 #endif
1477 #if YYERROR_VERBOSE
1478 if (yymsg != yymsgbuf)
1479 YYSTACK_FREE (yymsg);
1480 #endif
1481 return yyresult;
1482 ]}
1483
1484
1485 b4_epilogue
1486 m4_if(b4_defines_flag, 0, [],
1487 [@output @output_header_name@
1488 b4_copyright([Skeleton parser for Yacc-like parsing with Bison],
1489 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005])
1490
1491 /* As a special exception, when this file is copied by Bison into a
1492 Bison output file, you may use that output file without restriction.
1493 This special exception was added by the Free Software Foundation
1494 in version 1.24 of Bison. */
1495
1496 b4_token_enums_defines(b4_tokens)
1497
1498 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
1499 m4_ifdef([b4_stype],
1500 [b4_syncline([b4_stype_line], [b4_file_name])
1501 typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE;
1502 /* Line __line__ of yacc.c. */
1503 b4_syncline([@oline@], [@ofile@])],
1504 [typedef int YYSTYPE;])
1505 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1506 # define YYSTYPE_IS_DECLARED 1
1507 # define YYSTYPE_IS_TRIVIAL 1
1508 #endif
1509
1510 b4_pure_if([],
1511 [extern YYSTYPE b4_prefix[]lval;])
1512
1513 b4_location_if(
1514 [#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED)
1515 typedef struct YYLTYPE
1516 {
1517 int first_line;
1518 int first_column;
1519 int last_line;
1520 int last_column;
1521 } YYLTYPE;
1522 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1523 # define YYLTYPE_IS_DECLARED 1
1524 # define YYLTYPE_IS_TRIVIAL 1
1525 #endif
1526
1527 m4_if(b4_pure, [0],
1528 [extern YYLTYPE b4_prefix[]lloc;])
1529 ])
1530 ])
bison