]> git.saurik.com Git - bison.git/blob - data/yacc.c
projects / bison.git / blob
? search:


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