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


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