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