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


17690db3485404013a9403994301a42b850c4bb1
[bison.git] / data / yacc.c
1 m4_divert(-1) -*- C -*-
2
3 # Yacc compatible skeleton for Bison
4
5 # Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6 # Free Software Foundation, Inc.
7
8 # This program is free software; you can redistribute it and/or modify
9 # it under the terms of the GNU General Public License as published by
10 # the Free Software Foundation; either version 2 of the License, or
11 # (at your option) any later version.
12
13 # This program is distributed in the hope that it will be useful,
14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 # GNU General Public License for more details.
17
18 # You should have received a copy of the GNU General Public License
19 # along with this program; if not, write to the Free Software
20 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21 # 02110-1301 USA
22
23 m4_include(b4_pkgdatadir/[c.m4])
24
25 ## ---------------- ##
26 ## Default values. ##
27 ## ---------------- ##
28
29 # Stack parameters.
30 m4_define_default([b4_stack_depth_max], [10000])
31 m4_define_default([b4_stack_depth_init], [200])
32
33
34 ## ------------------------ ##
35 ## Pure/impure interfaces. ##
36 ## ------------------------ ##
37
38
39 # b4_yacc_pure_if(IF-TRUE, IF-FALSE)
40 # ----------------------------------
41 # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
42 m4_define([b4_yacc_pure_if],
43 [b4_pure_if([m4_ifset([b4_parse_param],
44 [$1], [$2])],
45 [$2])])
46
47
48 # b4_yyerror_args
49 # ---------------
50 # Arguments passed to yyerror: user args plus yylloc.
51 m4_define([b4_yyerror_args],
52 [b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl
53 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
54
55
56 # b4_lex_param
57 # ------------
58 # Accumulate in b4_lex_param all the yylex arguments.
59 # b4_lex_param arrives quoted twice, but we want to keep only one level.
60 m4_define([b4_lex_param],
61 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
62 b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
63 m4_ifdef([b4_lex_param], b4_lex_param)))
64
65
66
67 ## ------------ ##
68 ## Data Types. ##
69 ## ------------ ##
70
71 # b4_int_type(MIN, MAX)
72 # ---------------------
73 # Return the smallest int type able to handle numbers ranging from
74 # MIN to MAX (included). Overwrite the version from c.m4, which
75 # uses only C89 types, so that the user can override the shorter
76 # types, and so that pre-C89 compilers are handled correctly.
77 m4_define([b4_int_type],
78 [m4_if(b4_ints_in($@, [0], [255]), [1], [yytype_uint8],
79 b4_ints_in($@, [-128], [127]), [1], [yytype_int8],
80
81 b4_ints_in($@, [0], [65535]), [1], [yytype_uint16],
82 b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16],
83
84 m4_eval([0 <= $1]), [1], [unsigned int],
85
86 [int])])
87
88
89 # b4_safest_int_type
90 # ------------------
91 # The safest int type to cast to when it's necessary to compare a signed int
92 # type against an int type set by b4_int_type. Overwrite the version from
93 # c.m4 as a reminder to keep it consistent with overwritten b4_int_type.
94 m4_define([b4_safest_int_type],[int])
95
96
97
98 ## ----------------- ##
99 ## Semantic Values. ##
100 ## ----------------- ##
101
102
103 # b4_lhs_value([TYPE])
104 # --------------------
105 # Expansion of $<TYPE>$.
106 m4_define([b4_lhs_value],
107 [(yyval[]m4_ifval([$1], [.$1]))])
108
109
110 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
111 # --------------------------------------
112 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
113 # symbols on RHS.
114 m4_define([b4_rhs_value],
115 [(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$3]))])
116
117
118
119 ## ----------- ##
120 ## Locations. ##
121 ## ----------- ##
122
123 # b4_lhs_location()
124 # -----------------
125 # Expansion of @$.
126 m4_define([b4_lhs_location],
127 [(yyloc)])
128
129
130 # b4_rhs_location(RULE-LENGTH, NUM)
131 # ---------------------------------
132 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
133 # on RHS.
134 m4_define([b4_rhs_location],
135 [(yylsp@{($2) - ($1)@})])
136
137
138
139 ## --------------------------------------------------------- ##
140 ## Defining symbol actions, e.g., printers and destructors. ##
141 ## --------------------------------------------------------- ##
142
143 # We do want M4 expansion after # for CPP macros.
144 m4_changecom()
145 m4_divert(0)dnl
146 @output @output_parser_name@
147 b4_copyright([Skeleton implementation for Bison's Yacc-like parsers in C],dnl '
148 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006])[
149
150 /* C LALR(1) parser skeleton written by Richard Stallman, by
151 simplifying the original so-called "semantic" parser. */
152
153 /* All symbols defined below should begin with yy or YY, to avoid
154 infringing on user name space. This should be done even for local
155 variables, as they might otherwise be expanded by user macros.
156 There are some unavoidable exceptions within include files to
157 define necessary library symbols; they are noted "INFRINGES ON
158 USER NAME SPACE" below. */
159
160 ]b4_identification
161 m4_if(b4_prefix, [yy], [],
162 [/* Substitute the variable and function names. */
163 #define yyparse b4_prefix[]parse
164 #define yylex b4_prefix[]lex
165 #define yyerror b4_prefix[]error
166 #define yylval b4_prefix[]lval
167 #define yychar b4_prefix[]char
168 #define yydebug b4_prefix[]debug
169 #define yynerrs b4_prefix[]nerrs
170 b4_locations_if([#define yylloc b4_prefix[]lloc])])[
171
172 /* Copy the first part of user declarations. */
173 ]b4_pre_prologue[
174
175 /* Enabling traces. */
176 #ifndef YYDEBUG
177 # define YYDEBUG ]b4_debug_flag[
178 #endif
179
180 /* Enabling verbose error messages. */
181 #ifdef YYERROR_VERBOSE
182 # undef YYERROR_VERBOSE
183 # define YYERROR_VERBOSE 1
184 #else
185 # define YYERROR_VERBOSE ]b4_error_verbose_flag[
186 #endif
187
188 /* Enabling the token table. */
189 #ifndef YYTOKEN_TABLE
190 # define YYTOKEN_TABLE ]b4_token_table[
191 #endif
192
193 ]m4_ifdef([b4_start_header],
194 [[/* Copy the %start-header blocks. */
195 ]b4_start_header])[]dnl
196
197 b4_token_enums_defines(b4_tokens)[
198
199 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
200 ]m4_ifdef([b4_stype],
201 [[typedef union ]b4_union_name[
202 ]b4_user_stype[
203 YYSTYPE;
204 # define YYSTYPE_IS_TRIVIAL 1]],
205 [m4_if(b4_tag_seen_flag, 0,
206 [[typedef int YYSTYPE;
207 # define YYSTYPE_IS_TRIVIAL 1]])])[
208 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
209 # define YYSTYPE_IS_DECLARED 1
210 #endif
211
212 ]b4_locations_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 m4_ifdef([b4_end_header],
226 [[/* Copy the %end-header blocks. */
227 ]b4_end_header])[]dnl
228
229 [/* Copy the second part of user declarations. */
230 ]b4_user_post_prologue[
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 yyi], [yyi]])[
301 {
302 return yyi;
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_locations_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_locations_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_locations_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_locations_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_locations_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 *yybottom], [yybottom]],
688 [[yytype_int16 *yytop], [yytop]])[
689 {
690 YYFPRINTF (stderr, "Stack now");
691 for (; yybottom <= yytop; yybottom++)
692 {
693 int yybot = *yybottom;
694 YYFPRINTF (stderr, " %d", yybot);
695 }
696 YYFPRINTF (stderr, "\n");
697 }
698
699 # define YY_STACK_PRINT(Bottom, Top) \
700 do { \
701 if (yydebug) \
702 yy_stack_print ((Bottom), (Top)); \
703 } while (YYID (0))
704
705
706 /*------------------------------------------------.
707 | Report that the YYRULE is going to be reduced. |
708 `------------------------------------------------*/
709
710 ]b4_c_function_def([yy_reduce_print], [static void],
711 [[YYSTYPE *yyvsp], [yyvsp]],
712 b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
713 ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
714 ])b4_parse_param)[
715 {
716 int yynrhs = yyr2[yyrule];
717 int yyi;
718 unsigned long int yylno = yyrline[yyrule];
719 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
720 yyrule - 1, yylno);
721 /* The symbols being reduced. */
722 for (yyi = 0; yyi < yynrhs; yyi++)
723 {
724 fprintf (stderr, " $%d = ", yyi + 1);
725 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
726 &]b4_rhs_value(yynrhs, yyi + 1)[
727 ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
728 b4_user_args[);
729 fprintf (stderr, "\n");
730 }
731 }
732
733 # define YY_REDUCE_PRINT(Rule) \
734 do { \
735 if (yydebug) \
736 yy_reduce_print (yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
737 } while (YYID (0))
738
739 /* Nonzero means print parse trace. It is left uninitialized so that
740 multiple parsers can coexist. */
741 int yydebug;
742 #else /* !YYDEBUG */
743 # define YYDPRINTF(Args)
744 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
745 # define YY_STACK_PRINT(Bottom, Top)
746 # define YY_REDUCE_PRINT(Rule)
747 #endif /* !YYDEBUG */
748
749
750 /* YYINITDEPTH -- initial size of the parser's stacks. */
751 #ifndef YYINITDEPTH
752 # define YYINITDEPTH ]b4_stack_depth_init[
753 #endif
754
755 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
756 if the built-in stack extension method is used).
757
758 Do not make this value too large; the results are undefined if
759 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
760 evaluated with infinite-precision integer arithmetic. */
761
762 #ifndef YYMAXDEPTH
763 # define YYMAXDEPTH ]b4_stack_depth_max[
764 #endif
765
766 \f
767
768 #if YYERROR_VERBOSE
769
770 # ifndef yystrlen
771 # if defined __GLIBC__ && defined _STRING_H
772 # define yystrlen strlen
773 # else
774 /* Return the length of YYSTR. */
775 ]b4_c_function_def([yystrlen], [static YYSIZE_T],
776 [[const char *yystr], [yystr]])[
777 {
778 YYSIZE_T yylen;
779 for (yylen = 0; yystr[yylen]; yylen++)
780 continue;
781 return yylen;
782 }
783 # endif
784 # endif
785
786 # ifndef yystpcpy
787 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
788 # define yystpcpy stpcpy
789 # else
790 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
791 YYDEST. */
792 ]b4_c_function_def([yystpcpy], [static char *],
793 [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[
794 {
795 char *yyd = yydest;
796 const char *yys = yysrc;
797
798 while ((*yyd++ = *yys++) != '\0')
799 continue;
800
801 return yyd - 1;
802 }
803 # endif
804 # endif
805
806 # ifndef yytnamerr
807 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
808 quotes and backslashes, so that it's suitable for yyerror. The
809 heuristic is that double-quoting is unnecessary unless the string
810 contains an apostrophe, a comma, or backslash (other than
811 backslash-backslash). YYSTR is taken from yytname. If YYRES is
812 null, do not copy; instead, return the length of what the result
813 would have been. */
814 static YYSIZE_T
815 yytnamerr (char *yyres, const char *yystr)
816 {
817 if (*yystr == '"')
818 {
819 YYSIZE_T yyn = 0;
820 char const *yyp = yystr;
821
822 for (;;)
823 switch (*++yyp)
824 {
825 case '\'':
826 case ',':
827 goto do_not_strip_quotes;
828
829 case '\\':
830 if (*++yyp != '\\')
831 goto do_not_strip_quotes;
832 /* Fall through. */
833 default:
834 if (yyres)
835 yyres[yyn] = *yyp;
836 yyn++;
837 break;
838
839 case '"':
840 if (yyres)
841 yyres[yyn] = '\0';
842 return yyn;
843 }
844 do_not_strip_quotes: ;
845 }
846
847 if (! yyres)
848 return yystrlen (yystr);
849
850 return yystpcpy (yyres, yystr) - yyres;
851 }
852 # endif
853
854 /* Copy into YYRESULT an error message about the unexpected token
855 YYCHAR while in state YYSTATE. Return the number of bytes copied,
856 including the terminating null byte. If YYRESULT is null, do not
857 copy anything; just return the number of bytes that would be
858 copied. As a special case, return 0 if an ordinary "syntax error"
859 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
860 size calculation. */
861 static YYSIZE_T
862 yysyntax_error (char *yyresult, int yystate, int yychar)
863 {
864 int yyn = yypact[yystate];
865
866 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
867 return 0;
868 else
869 {
870 int yytype = YYTRANSLATE (yychar);
871 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
872 YYSIZE_T yysize = yysize0;
873 YYSIZE_T yysize1;
874 int yysize_overflow = 0;
875 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
876 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
877 int yyx;
878
879 # if 0
880 /* This is so xgettext sees the translatable formats that are
881 constructed on the fly. */
882 YY_("syntax error, unexpected %s");
883 YY_("syntax error, unexpected %s, expecting %s");
884 YY_("syntax error, unexpected %s, expecting %s or %s");
885 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
886 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
887 # endif
888 char *yyfmt;
889 char const *yyf;
890 static char const yyunexpected[] = "syntax error, unexpected %s";
891 static char const yyexpecting[] = ", expecting %s";
892 static char const yyor[] = " or %s";
893 char yyformat[sizeof yyunexpected
894 + sizeof yyexpecting - 1
895 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
896 * (sizeof yyor - 1))];
897 char const *yyprefix = yyexpecting;
898
899 /* Start YYX at -YYN if negative to avoid negative indexes in
900 YYCHECK. */
901 int yyxbegin = yyn < 0 ? -yyn : 0;
902
903 /* Stay within bounds of both yycheck and yytname. */
904 int yychecklim = YYLAST - yyn + 1;
905 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
906 int yycount = 1;
907
908 yyarg[0] = yytname[yytype];
909 yyfmt = yystpcpy (yyformat, yyunexpected);
910
911 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
912 if ((]b4_safest_int_type[)yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
913 {
914 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
915 {
916 yycount = 1;
917 yysize = yysize0;
918 yyformat[sizeof yyunexpected - 1] = '\0';
919 break;
920 }
921 yyarg[yycount++] = yytname[yyx];
922 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
923 yysize_overflow |= (yysize1 < yysize);
924 yysize = yysize1;
925 yyfmt = yystpcpy (yyfmt, yyprefix);
926 yyprefix = yyor;
927 }
928
929 yyf = YY_(yyformat);
930 yysize1 = yysize + yystrlen (yyf);
931 yysize_overflow |= (yysize1 < yysize);
932 yysize = yysize1;
933
934 if (yysize_overflow)
935 return YYSIZE_MAXIMUM;
936
937 if (yyresult)
938 {
939 /* Avoid sprintf, as that infringes on the user's name space.
940 Don't have undefined behavior even if the translation
941 produced a string with the wrong number of "%s"s. */
942 char *yyp = yyresult;
943 int yyi = 0;
944 while ((*yyp = *yyf) != '\0')
945 {
946 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
947 {
948 yyp += yytnamerr (yyp, yyarg[yyi++]);
949 yyf += 2;
950 }
951 else
952 {
953 yyp++;
954 yyf++;
955 }
956 }
957 }
958 return yysize;
959 }
960 }
961 #endif /* YYERROR_VERBOSE */
962 \f
963
964 ]b4_yydestruct_generate([b4_c_function_def])[
965 \f
966
967 /* Prevent warnings from -Wmissing-prototypes. */
968
969 #ifdef YYPARSE_PARAM
970 ]b4_c_function_decl([yyparse], [int],
971 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
972 #else /* ! YYPARSE_PARAM */
973 ]b4_c_function_decl([yyparse], [int], b4_parse_param)[
974 #endif /* ! YYPARSE_PARAM */
975
976
977 ]m4_divert_push([KILL])# ======================== M4 code.
978 # b4_declare_parser_variables
979 # ---------------------------
980 # Declare the variables that are global, or local to YYPARSE if
981 # pure-parser.
982 m4_define([b4_declare_parser_variables],
983 [/* The lookahead symbol. */
984 int yychar;
985
986 /* The semantic value of the lookahead symbol. */
987 YYSTYPE yylval;
988
989 /* Number of syntax errors so far. */
990 int yynerrs;b4_locations_if([
991 /* Location data for the lookahead symbol. */
992 YYLTYPE yylloc;])
993 ])
994 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
995
996 b4_pure_if([],
997 [b4_declare_parser_variables])
998
999
1000 /*----------.
1001 | yyparse. |
1002 `----------*/
1003
1004 #ifdef YYPARSE_PARAM
1005 b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])
1006 #else /* ! YYPARSE_PARAM */
1007 b4_c_function_def([yyparse], [int], b4_parse_param)
1008 #endif
1009 {[
1010 ]b4_pure_if([b4_declare_parser_variables])[
1011 int yystate;
1012 int yyn;
1013 int yyresult;
1014 /* Number of tokens to shift before error messages enabled. */
1015 int yyerrstatus;
1016 /* Lookahead token as an internal (translated) token number. */
1017 int yytoken = 0;
1018 #if YYERROR_VERBOSE
1019 /* Buffer for error messages, and its allocated size. */
1020 char yymsgbuf[128];
1021 char *yymsg = yymsgbuf;
1022 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1023 #endif
1024
1025 /* Three stacks and their tools:
1026 `yyss': related to states,
1027 `yyvs': related to semantic values,
1028 `yyls': related to locations.
1029
1030 Refer to the stacks thru separate pointers, to allow yyoverflow
1031 to reallocate them elsewhere. */
1032
1033 /* The state stack. */
1034 yytype_int16 yyssa[YYINITDEPTH];
1035 yytype_int16 *yyss = yyssa;
1036 yytype_int16 *yyssp;
1037
1038 /* The semantic value stack. */
1039 YYSTYPE yyvsa[YYINITDEPTH];
1040 YYSTYPE *yyvs = yyvsa;
1041 YYSTYPE *yyvsp;
1042
1043 ]b4_locations_if(
1044 [[ /* The location stack. */
1045 YYLTYPE yylsa[YYINITDEPTH];
1046 YYLTYPE *yyls = yylsa;
1047 YYLTYPE *yylsp;
1048 /* The locations where the error started and ended. */
1049 YYLTYPE yyerror_range[2];]])[
1050
1051 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
1052
1053 YYSIZE_T yystacksize = YYINITDEPTH;
1054
1055 /* The variables used to return semantic value and location from the
1056 action routines. */
1057 YYSTYPE yyval;
1058 ]b4_locations_if([ YYLTYPE yyloc;])[
1059
1060 /* The number of symbols on the RHS of the reduced rule.
1061 Keep to zero when no symbol should be popped. */
1062 int yylen = 0;
1063
1064 YYDPRINTF ((stderr, "Starting parse\n"));
1065
1066 yystate = 0;
1067 yyerrstatus = 0;
1068 yynerrs = 0;
1069 yychar = YYEMPTY; /* Cause a token to be read. */
1070
1071 /* Initialize stack pointers.
1072 Waste one element of value and location stack
1073 so that they stay on the same level as the state stack.
1074 The wasted elements are never initialized. */
1075
1076 yyssp = yyss;
1077 yyvsp = yyvs;
1078 ]b4_locations_if([[ yylsp = yyls;
1079 #if YYLTYPE_IS_TRIVIAL
1080 /* Initialize the default location before parsing starts. */
1081 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
1082 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
1083 #endif
1084 ]])
1085 m4_ifdef([b4_initial_action], [
1086 m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl
1087 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
1088 /* User initialization code. */
1089 b4_user_initial_action
1090 m4_popdef([b4_dollar_dollar])dnl
1091 m4_popdef([b4_at_dollar])])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_locations_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_locations_if([ &yyls1, yysize * sizeof (*yylsp),])[
1131 &yystacksize);
1132 ]b4_locations_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_locations_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_locations_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 if (yystate == YYFINAL)
1177 YYACCEPT;
1178
1179 goto yybackup;
1180
1181 /*-----------.
1182 | yybackup. |
1183 `-----------*/
1184 yybackup:
1185
1186 /* Do appropriate processing given the current state. Read a
1187 lookahead token if we need one and don't already have one. */
1188
1189 /* First try to decide what to do without reference to lookahead token. */
1190 yyn = yypact[yystate];
1191 if (yyn == YYPACT_NINF)
1192 goto yydefault;
1193
1194 /* Not known => get a lookahead token if don't already have one. */
1195
1196 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1197 if (yychar == YYEMPTY)
1198 {
1199 YYDPRINTF ((stderr, "Reading a token: "));
1200 yychar = YYLEX;
1201 }
1202
1203 if (yychar <= YYEOF)
1204 {
1205 yychar = yytoken = YYEOF;
1206 YYDPRINTF ((stderr, "Now at end of input.\n"));
1207 }
1208 else
1209 {
1210 yytoken = YYTRANSLATE (yychar);
1211 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1212 }
1213
1214 /* If the proper action on seeing token YYTOKEN is to reduce or to
1215 detect an error, take that action. */
1216 yyn += yytoken;
1217 if (yyn < 0 || YYLAST < yyn || (]b4_safest_int_type[)yycheck[yyn] != yytoken)
1218 goto yydefault;
1219 yyn = yytable[yyn];
1220 if (yyn <= 0)
1221 {
1222 if (yyn == 0 || yyn == YYTABLE_NINF)
1223 goto yyerrlab;
1224 yyn = -yyn;
1225 goto yyreduce;
1226 }
1227
1228 /* Count tokens shifted since error; after three, turn off error
1229 status. */
1230 if (yyerrstatus)
1231 yyerrstatus--;
1232
1233 /* Shift the lookahead token. */
1234 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1235
1236 /* Discard the shifted token. */
1237 yychar = YYEMPTY;
1238
1239 yystate = yyn;
1240 *++yyvsp = yylval;
1241 ]b4_locations_if([ *++yylsp = yylloc;])[
1242 goto yynewstate;
1243
1244
1245 /*-----------------------------------------------------------.
1246 | yydefault -- do the default action for the current state. |
1247 `-----------------------------------------------------------*/
1248 yydefault:
1249 yyn = yydefact[yystate];
1250 if (yyn == 0)
1251 goto yyerrlab;
1252 goto yyreduce;
1253
1254
1255 /*-----------------------------.
1256 | yyreduce -- Do a reduction. |
1257 `-----------------------------*/
1258 yyreduce:
1259 /* yyn is the number of a rule to reduce with. */
1260 yylen = yyr2[yyn];
1261
1262 /* If YYLEN is nonzero, implement the default value of the action:
1263 `$$ = $1'.
1264
1265 Otherwise, the following line sets YYVAL to garbage.
1266 This behavior is undocumented and Bison
1267 users should not rely upon it. Assigning to YYVAL
1268 unconditionally makes the parser a bit smaller, and it avoids a
1269 GCC warning that YYVAL may be used uninitialized. */
1270 yyval = yyvsp[1-yylen];
1271
1272 ]b4_locations_if(
1273 [[ /* Default location. */
1274 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
1275 YY_REDUCE_PRINT (yyn);
1276 switch (yyn)
1277 {
1278 ]b4_user_actions[
1279 default: break;
1280 }
1281 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1282
1283 YYPOPSTACK (yylen);
1284 yylen = 0;
1285 YY_STACK_PRINT (yyss, yyssp);
1286
1287 *++yyvsp = yyval;
1288 ]b4_locations_if([ *++yylsp = yyloc;])[
1289
1290 /* Now `shift' the result of the reduction. Determine what state
1291 that goes to, based on the state we popped back to and the rule
1292 number reduced by. */
1293
1294 yyn = yyr1[yyn];
1295
1296 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1297 if (0 <= yystate && yystate <= YYLAST
1298 && (]b4_safest_int_type[)yycheck[yystate] == *yyssp)
1299 yystate = yytable[yystate];
1300 else
1301 yystate = yydefgoto[yyn - YYNTOKENS];
1302
1303 goto yynewstate;
1304
1305
1306 /*------------------------------------.
1307 | yyerrlab -- here on detecting error |
1308 `------------------------------------*/
1309 yyerrlab:
1310 /* If not already recovering from an error, report this error. */
1311 if (!yyerrstatus)
1312 {
1313 ++yynerrs;
1314 #if ! YYERROR_VERBOSE
1315 yyerror (]b4_yyerror_args[YY_("syntax error"));
1316 #else
1317 {
1318 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1319 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1320 {
1321 YYSIZE_T yyalloc = 2 * yysize;
1322 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1323 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1324 if (yymsg != yymsgbuf)
1325 YYSTACK_FREE (yymsg);
1326 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1327 if (yymsg)
1328 yymsg_alloc = yyalloc;
1329 else
1330 {
1331 yymsg = yymsgbuf;
1332 yymsg_alloc = sizeof yymsgbuf;
1333 }
1334 }
1335
1336 if (0 < yysize && yysize <= yymsg_alloc)
1337 {
1338 (void) yysyntax_error (yymsg, yystate, yychar);
1339 yyerror (]b4_yyerror_args[yymsg);
1340 }
1341 else
1342 {
1343 yyerror (]b4_yyerror_args[YY_("syntax error"));
1344 if (yysize != 0)
1345 goto yyexhaustedlab;
1346 }
1347 }
1348 #endif
1349 }
1350
1351 ]b4_locations_if([[ yyerror_range[0] = yylloc;]])[
1352
1353 if (yyerrstatus == 3)
1354 {
1355 /* If just tried and failed to reuse lookahead token after an
1356 error, discard it. */
1357
1358 if (yychar <= YYEOF)
1359 {
1360 /* Return failure if at end of input. */
1361 if (yychar == YYEOF)
1362 YYABORT;
1363 }
1364 else
1365 {
1366 yydestruct ("Error: discarding",
1367 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1368 yychar = YYEMPTY;
1369 }
1370 }
1371
1372 /* Else will try to reuse lookahead token after shifting the error
1373 token. */
1374 goto yyerrlab1;
1375
1376
1377 /*---------------------------------------------------.
1378 | yyerrorlab -- error raised explicitly by YYERROR. |
1379 `---------------------------------------------------*/
1380 yyerrorlab:
1381
1382 /* Pacify compilers like GCC when the user code never invokes
1383 YYERROR and the label yyerrorlab therefore never appears in user
1384 code. */
1385 if (/*CONSTCOND*/ 0)
1386 goto yyerrorlab;
1387
1388 ]b4_locations_if([[ yyerror_range[0] = yylsp[1-yylen];
1389 ]])[ /* Do not reclaim the symbols of the rule which action triggered
1390 this YYERROR. */
1391 YYPOPSTACK (yylen);
1392 yylen = 0;
1393 YY_STACK_PRINT (yyss, yyssp);
1394 yystate = *yyssp;
1395 goto yyerrlab1;
1396
1397
1398 /*-------------------------------------------------------------.
1399 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1400 `-------------------------------------------------------------*/
1401 yyerrlab1:
1402 yyerrstatus = 3; /* Each real token shifted decrements this. */
1403
1404 for (;;)
1405 {
1406 yyn = yypact[yystate];
1407 if (yyn != YYPACT_NINF)
1408 {
1409 yyn += YYTERROR;
1410 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1411 {
1412 yyn = yytable[yyn];
1413 if (0 < yyn)
1414 break;
1415 }
1416 }
1417
1418 /* Pop the current state because it cannot handle the error token. */
1419 if (yyssp == yyss)
1420 YYABORT;
1421
1422 ]b4_locations_if([[ yyerror_range[0] = *yylsp;]])[
1423 yydestruct ("Error: popping",
1424 yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1425 YYPOPSTACK (1);
1426 yystate = *yyssp;
1427 YY_STACK_PRINT (yyss, yyssp);
1428 }
1429
1430 *++yyvsp = yylval;
1431 ]b4_locations_if([[
1432 yyerror_range[1] = yylloc;
1433 /* Using YYLLOC is tempting, but would change the location of
1434 the lookahead. YYLOC is available though. */
1435 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
1436 *++yylsp = yyloc;]])[
1437
1438 /* Shift the error token. */
1439 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1440
1441 yystate = yyn;
1442 goto yynewstate;
1443
1444
1445 /*-------------------------------------.
1446 | yyacceptlab -- YYACCEPT comes here. |
1447 `-------------------------------------*/
1448 yyacceptlab:
1449 yyresult = 0;
1450 goto yyreturn;
1451
1452 /*-----------------------------------.
1453 | yyabortlab -- YYABORT comes here. |
1454 `-----------------------------------*/
1455 yyabortlab:
1456 yyresult = 1;
1457 goto yyreturn;
1458
1459 #ifndef yyoverflow
1460 /*-------------------------------------------------.
1461 | yyexhaustedlab -- memory exhaustion comes here. |
1462 `-------------------------------------------------*/
1463 yyexhaustedlab:
1464 yyerror (]b4_yyerror_args[YY_("memory exhausted"));
1465 yyresult = 2;
1466 /* Fall through. */
1467 #endif
1468
1469 yyreturn:
1470 if (yychar != YYEMPTY)
1471 yydestruct ("Cleanup: discarding lookahead",
1472 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1473 /* Do not reclaim the symbols of the rule which action triggered
1474 this YYABORT or YYACCEPT. */
1475 YYPOPSTACK (yylen);
1476 YY_STACK_PRINT (yyss, yyssp);
1477 while (yyssp != yyss)
1478 {
1479 yydestruct ("Cleanup: popping",
1480 yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1481 YYPOPSTACK (1);
1482 }
1483 #ifndef yyoverflow
1484 if (yyss != yyssa)
1485 YYSTACK_FREE (yyss);
1486 #endif
1487 #if YYERROR_VERBOSE
1488 if (yymsg != yymsgbuf)
1489 YYSTACK_FREE (yymsg);
1490 #endif
1491 /* Make sure YYID is used. */
1492 return YYID (yyresult);
1493 ]}
1494
1495
1496 b4_epilogue
1497 b4_defines_if(
1498 [@output @output_header_name@
1499 b4_copyright([Skeleton interface for Bison's Yacc-like parsers in C],dnl '
1500 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006])
1501
1502 m4_ifdef([b4_start_header],
1503 [[/* Copy the %start-header blocks. */
1504 ]b4_start_header])[]dnl
1505
1506 b4_token_enums_defines(b4_tokens)
1507
1508 [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1509 ]m4_ifdef([b4_stype],
1510 [[typedef union ]b4_union_name[
1511 ]b4_user_stype[
1512 YYSTYPE;
1513 # define YYSTYPE_IS_TRIVIAL 1]],
1514 [m4_if(b4_tag_seen_flag, 0,
1515 [[typedef int YYSTYPE;
1516 # define YYSTYPE_IS_TRIVIAL 1]])])[
1517 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1518 # define YYSTYPE_IS_DECLARED 1
1519 #endif
1520
1521 ]b4_pure_if([],
1522 [extern YYSTYPE b4_prefix[]lval;])
1523
1524 b4_locations_if(
1525 [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
1526 typedef struct YYLTYPE
1527 {
1528 int first_line;
1529 int first_column;
1530 int last_line;
1531 int last_column;
1532 } YYLTYPE;
1533 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1534 # define YYLTYPE_IS_DECLARED 1
1535 # define YYLTYPE_IS_TRIVIAL 1
1536 #endif
1537
1538 ]b4_pure_if([],
1539 [extern YYLTYPE b4_prefix[]lloc;])
1540 )dnl b4_locations_if
1541
1542 m4_ifdef([b4_end_header],
1543 [[/* Copy the %end-header blocks. */
1544 ]b4_end_header])[]dnl
1545 ])dnl b4_defines_if
bison