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


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