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