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