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


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