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


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