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


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