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


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