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