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


2e6165b58580b77d4a25f3d054bc33a6b911bb73
[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], [struct yypvars *], [[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 /* The variables used to return semantic value and location from the
1042 action routines. */
1043 YYSTYPE yyval;
1044 /* Used to determine if this is the first time this instance has
1045 been used. */
1046 int yynew;]b4_locations_if([YYLTYPE yyloc;])[
1047 };
1048
1049 /* Initialize the parser data structure. */
1050 struct yypvars*
1051 yypvarsinit (void)
1052 {
1053 struct yypvars *pv = (struct yypvars *) malloc (sizeof *pv);
1054 pv->yystate = 0;
1055 pv->yyresult = -1;
1056 pv->yyerrstatus = 0;
1057 pv->yytoken = 0;
1058
1059 pv->yyss = pv->yyssa;
1060 pv->yyvs = pv->yyvsa;
1061
1062 ]b4_locations_if([
1063 pv->yyls = pv->yylsa;])[
1064 pv->yystacksize = YYINITDEPTH;
1065
1066 pv->yyssp = pv->yyss;
1067 pv->yyvsp = pv->yyvs;
1068
1069 pv->yynew = 1;
1070
1071 ]b4_locations_if([ pv->yylsp = pv->yyls;])[
1072
1073 return pv;
1074 }])
1075 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
1076
1077 b4_push_if([],[b4_pure_if([],
1078 [b4_declare_parser_variables])])
1079
1080 b4_push_if([b4_declare_yyparse_variables])
1081
1082 /*-------------------------.
1083 | yyparse or yypushparse. |
1084 `-------------------------*/
1085
1086 b4_push_if([
1087 b4_c_function_def([yypushparse], [int], [[struct yypvars *yypvars], [yypvars]],
1088 [[int yynchar], [yynchar]], [[YYSTYPE *yynlval], [yynlval]]
1089 b4_locations_if([,[[YYLTYPE *yynlloc], [yynlloc]]]))],[
1090 #ifdef YYPARSE_PARAM
1091 b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])
1092 #else /* ! YYPARSE_PARAM */
1093 b4_c_function_def([yyparse], [int], b4_parse_param)
1094 #endif])
1095 {[
1096 ]b4_pure_if([b4_declare_parser_variables])[
1097 ]b4_push_if([b4_declare_parser_variables])[
1098 ]b4_push_if([struct yypvars *pv;])[
1099 int yystate;
1100 int yyn;
1101 int yyresult;
1102 /* Number of tokens to shift before error messages enabled. */
1103 int yyerrstatus;
1104 /* Lookahead token as an internal (translated) token number. */
1105 int yytoken = 0;
1106 #if YYERROR_VERBOSE
1107 /* Buffer for error messages, and its allocated size. */
1108 char yymsgbuf[128];
1109 char *yymsg = yymsgbuf;
1110 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1111 #endif
1112
1113 /* Three stacks and their tools:
1114 `yyss': related to states,
1115 `yyvs': related to semantic values,
1116 `yyls': related to locations.
1117
1118 Refer to the stacks thru separate pointers, to allow yyoverflow
1119 to reallocate them elsewhere. */
1120
1121 /* The state stack. */
1122 yytype_int16 yyssa[YYINITDEPTH];
1123 yytype_int16 *yyss = yyssa;
1124 yytype_int16 *yyssp;
1125
1126 /* The semantic value stack. */
1127 YYSTYPE yyvsa[YYINITDEPTH];
1128 YYSTYPE *yyvs = yyvsa;
1129 YYSTYPE *yyvsp;
1130
1131 ]b4_locations_if(
1132 [[ /* The location stack. */
1133 YYLTYPE yylsa[YYINITDEPTH];
1134 YYLTYPE *yyls = yylsa;
1135 YYLTYPE *yylsp;
1136 /* The locations where the error started and ended. */
1137 ]b4_push_if([],[YYLTYPE yyerror_range[[2]]])[;
1138 ]])[
1139
1140 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
1141
1142 YYSIZE_T yystacksize = YYINITDEPTH;
1143
1144 /* The variables used to return semantic value and location from the
1145 action routines. */
1146 YYSTYPE yyval;
1147 ]b4_locations_if([ YYLTYPE yyloc;])[
1148
1149 /* The number of symbols on the RHS of the reduced rule.
1150 Keep to zero when no symbol should be popped. */
1151 int yylen = 0;
1152
1153 YYDPRINTF ((stderr, "Starting parse\n"));
1154
1155 yystate = 0;
1156 yyerrstatus = 0;
1157 ]b4_push_if([ yychar = yynchar;
1158 pv = yypvars;
1159 if (yynlval)
1160 yylval = *yynlval;
1161 ]b4_locations_if([ if (yynlloc)
1162 yylloc = *yynlloc;])[],[yynerrs = 0;
1163 yychar = YYEMPTY; /* Cause a token to be read. */])[
1164
1165 /* Initialize stack pointers.
1166 Waste one element of value and location stack
1167 so that they stay on the same level as the state stack.
1168 The wasted elements are never initialized. */
1169
1170 yyssp = yyss;
1171 yyvsp = yyvs;
1172 ]b4_locations_if([[ yylsp = yyls;
1173 ]b4_push_if([],[
1174 #if YYLTYPE_IS_TRIVIAL
1175 /* Initialize the default location before parsing starts. */
1176 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
1177 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
1178 #endif])[
1179 ]])
1180 m4_ifdef([b4_initial_action], [
1181 m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl
1182 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
1183 /* User initialization code. */
1184 b4_user_initial_action
1185 m4_popdef([b4_dollar_dollar])dnl
1186 m4_popdef([b4_at_dollar])])dnl
1187 m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval;
1188 ]])dnl
1189 m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc;
1190 ]])dnl
1191 [ ]b4_push_if([
1192 /* Initialize the locals to the current context. */
1193 yystate = pv->yystate;
1194 yyn = pv->yyn;
1195 yyresult = pv->yyresult;
1196 yyerrstatus = pv->yyerrstatus;
1197 yytoken = pv->yytoken;
1198
1199 yyss = pv->yyss;
1200 yyssp = pv->yyssp;
1201
1202 yyvs = pv->yyvs;
1203 yyvsp = pv->yyvsp;
1204
1205 ]b4_locations_if([[ /* The location stack. */
1206 yyls = pv->yyls;
1207 yylsp = pv->yylsp;]])[
1208
1209 yystacksize = pv->yystacksize;
1210 yyval = pv->yyval;
1211 ]b4_locations_if([yyloc = pv->yyloc;])[
1212 if (pv->yynew == 0)
1213 {
1214 goto gottoken;
1215 }
1216 pv->yynew= 0;])[
1217 goto yysetstate;
1218
1219 /*------------------------------------------------------------.
1220 | yynewstate -- Push a new state, which is found in yystate. |
1221 `------------------------------------------------------------*/
1222 yynewstate:
1223 /* In all cases, when you get here, the value and location stacks
1224 have just been pushed. So pushing a state here evens the stacks. */
1225 yyssp++;
1226
1227 yysetstate:
1228 *yyssp = yystate;
1229
1230 if (yyss + yystacksize - 1 <= yyssp)
1231 {
1232 /* Get the current used size of the three stacks, in elements. */
1233 YYSIZE_T yysize = yyssp - yyss + 1;
1234
1235 #ifdef yyoverflow
1236 {
1237 /* Give user a chance to reallocate the stack. Use copies of
1238 these so that the &'s don't force the real ones into
1239 memory. */
1240 YYSTYPE *yyvs1 = yyvs;
1241 yytype_int16 *yyss1 = yyss;
1242 ]b4_locations_if([ YYLTYPE *yyls1 = yyls;])[
1243
1244 /* Each stack pointer address is followed by the size of the
1245 data in use in that stack, in bytes. This used to be a
1246 conditional around just the two extra args, but that might
1247 be undefined if yyoverflow is a macro. */
1248 yyoverflow (YY_("memory exhausted"),
1249 &yyss1, yysize * sizeof (*yyssp),
1250 &yyvs1, yysize * sizeof (*yyvsp),
1251 ]b4_locations_if([ &yyls1, yysize * sizeof (*yylsp),])[
1252 &yystacksize);
1253 ]b4_locations_if([ yyls = yyls1;])[
1254 yyss = yyss1;
1255 yyvs = yyvs1;
1256 }
1257 #else /* no yyoverflow */
1258 # ifndef YYSTACK_RELOCATE
1259 goto yyexhaustedlab;
1260 # else
1261 /* Extend the stack our own way. */
1262 if (YYMAXDEPTH <= yystacksize)
1263 goto yyexhaustedlab;
1264 yystacksize *= 2;
1265 if (YYMAXDEPTH < yystacksize)
1266 yystacksize = YYMAXDEPTH;
1267
1268 {
1269 yytype_int16 *yyss1 = yyss;
1270 union yyalloc *yyptr =
1271 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1272 if (! yyptr)
1273 goto yyexhaustedlab;
1274 YYSTACK_RELOCATE (yyss);
1275 YYSTACK_RELOCATE (yyvs);
1276 ]b4_locations_if([ YYSTACK_RELOCATE (yyls);])[
1277 # undef YYSTACK_RELOCATE
1278 if (yyss1 != ]b4_yyssa[)
1279 YYSTACK_FREE (yyss1);
1280 }
1281 # endif
1282 #endif /* no yyoverflow */
1283
1284 yyssp = yyss + yysize - 1;
1285 yyvsp = yyvs + yysize - 1;
1286 ]b4_locations_if([ yylsp = yyls + yysize - 1;])[
1287
1288 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1289 (unsigned long int) yystacksize));
1290
1291 if (yyss + yystacksize - 1 <= yyssp)
1292 YYABORT;
1293 }
1294
1295 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1296
1297 if (yystate == YYFINAL)
1298 YYACCEPT;
1299
1300 goto yybackup;
1301
1302 /*-----------.
1303 | yybackup. |
1304 `-----------*/
1305 yybackup:
1306
1307 /* Do appropriate processing given the current state. Read a
1308 lookahead token if we need one and don't already have one. */
1309
1310 /* First try to decide what to do without reference to lookahead token. */
1311 yyn = yypact[yystate];
1312 if (yyn == YYPACT_NINF)
1313 goto yydefault;
1314
1315 /* Not known => get a lookahead token if don't already have one. */
1316
1317 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1318 if (yychar == YYEMPTY)
1319 {
1320 ]b4_push_if([
1321 YYDPRINTF ((stderr, "Return for a new token:\n"));
1322 yyresult = YYPUSH_MORE;
1323 /* Initialize the locals to the current context. */
1324 pv->yystate = yystate;
1325 pv->yyn = yyn;
1326 pv->yyerrstatus = yyerrstatus;
1327 pv->yytoken = yytoken;
1328
1329 pv->yyss = yyss;
1330 pv->yyssp = yyssp;
1331
1332 pv->yyvs = yyvs;
1333 pv->yyvsp = yyvsp;
1334
1335 ]b4_locations_if([[ /* The location stack. */
1336 pv->yyls = yyls;
1337 pv->yylsp = yylsp;]])[
1338
1339 pv->yystacksize = yystacksize;
1340 pv->yyval = yyval;
1341 ]b4_locations_if([pv->yyloc = yyloc;])[
1342 goto yypushreturn;
1343 gottoken:])[
1344 YYDPRINTF ((stderr, "Reading a token: "));
1345 ]b4_push_if([], [yychar = YYLEX;])[
1346 }
1347
1348 if (yychar <= YYEOF)
1349 {
1350 yychar = yytoken = YYEOF;
1351 YYDPRINTF ((stderr, "Now at end of input.\n"));
1352 }
1353 else
1354 {
1355 yytoken = YYTRANSLATE (yychar);
1356 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1357 }
1358
1359 /* If the proper action on seeing token YYTOKEN is to reduce or to
1360 detect an error, take that action. */
1361 yyn += yytoken;
1362 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1363 goto yydefault;
1364 yyn = yytable[yyn];
1365 if (yyn <= 0)
1366 {
1367 if (yyn == 0 || yyn == YYTABLE_NINF)
1368 goto yyerrlab;
1369 yyn = -yyn;
1370 goto yyreduce;
1371 }
1372
1373 /* Count tokens shifted since error; after three, turn off error
1374 status. */
1375 if (yyerrstatus)
1376 yyerrstatus--;
1377
1378 /* Shift the lookahead token. */
1379 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1380
1381 /* Discard the shifted token. */
1382 yychar = YYEMPTY;
1383
1384 yystate = yyn;
1385 *++yyvsp = yylval;
1386 ]b4_locations_if([ *++yylsp = yylloc;])[
1387 goto yynewstate;
1388
1389
1390 /*-----------------------------------------------------------.
1391 | yydefault -- do the default action for the current state. |
1392 `-----------------------------------------------------------*/
1393 yydefault:
1394 yyn = yydefact[yystate];
1395 if (yyn == 0)
1396 goto yyerrlab;
1397 goto yyreduce;
1398
1399
1400 /*-----------------------------.
1401 | yyreduce -- Do a reduction. |
1402 `-----------------------------*/
1403 yyreduce:
1404 /* yyn is the number of a rule to reduce with. */
1405 yylen = yyr2[yyn];
1406
1407 /* If YYLEN is nonzero, implement the default value of the action:
1408 `$$ = $1'.
1409
1410 Otherwise, the following line sets YYVAL to garbage.
1411 This behavior is undocumented and Bison
1412 users should not rely upon it. Assigning to YYVAL
1413 unconditionally makes the parser a bit smaller, and it avoids a
1414 GCC warning that YYVAL may be used uninitialized. */
1415 yyval = yyvsp[1-yylen];
1416
1417 ]b4_locations_if(
1418 [[ /* Default location. */
1419 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
1420 YY_REDUCE_PRINT (yyn);
1421 switch (yyn)
1422 {
1423 ]b4_user_actions[
1424 default: break;
1425 }
1426 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1427
1428 YYPOPSTACK (yylen);
1429 yylen = 0;
1430 YY_STACK_PRINT (yyss, yyssp);
1431
1432 *++yyvsp = yyval;
1433 ]b4_locations_if([ *++yylsp = yyloc;])[
1434
1435 /* Now `shift' the result of the reduction. Determine what state
1436 that goes to, based on the state we popped back to and the rule
1437 number reduced by. */
1438
1439 yyn = yyr1[yyn];
1440
1441 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1442 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1443 yystate = yytable[yystate];
1444 else
1445 yystate = yydefgoto[yyn - YYNTOKENS];
1446
1447 goto yynewstate;
1448
1449
1450 /*------------------------------------.
1451 | yyerrlab -- here on detecting error |
1452 `------------------------------------*/
1453 yyerrlab:
1454 /* If not already recovering from an error, report this error. */
1455 if (!yyerrstatus)
1456 {
1457 ]b4_push_if([],[ ++yynerrs;])[
1458 #if ! YYERROR_VERBOSE
1459 yyerror (]b4_yyerror_args[YY_("syntax error"));
1460 #else
1461 {
1462 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1463 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1464 {
1465 YYSIZE_T yyalloc = 2 * yysize;
1466 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1467 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1468 if (yymsg != yymsgbuf)
1469 YYSTACK_FREE (yymsg);
1470 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1471 if (yymsg)
1472 yymsg_alloc = yyalloc;
1473 else
1474 {
1475 yymsg = yymsgbuf;
1476 yymsg_alloc = sizeof yymsgbuf;
1477 }
1478 }
1479
1480 if (0 < yysize && yysize <= yymsg_alloc)
1481 {
1482 (void) yysyntax_error (yymsg, yystate, yychar);
1483 yyerror (]b4_yyerror_args[yymsg);
1484 }
1485 else
1486 {
1487 yyerror (]b4_yyerror_args[YY_("syntax error"));
1488 if (yysize != 0)
1489 goto yyexhaustedlab;
1490 }
1491 }
1492 #endif
1493 }
1494
1495 ]b4_locations_if([[ ]b4_yyerror_range[[0] = yylloc;]])[
1496
1497 if (yyerrstatus == 3)
1498 {
1499 /* If just tried and failed to reuse lookahead token after an
1500 error, discard it. */
1501
1502 if (yychar <= YYEOF)
1503 {
1504 /* Return failure if at end of input. */
1505 if (yychar == YYEOF)
1506 YYABORT;
1507 }
1508 else
1509 {
1510 yydestruct ("Error: discarding",
1511 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1512 yychar = YYEMPTY;
1513 }
1514 }
1515
1516 /* Else will try to reuse lookahead token after shifting the error
1517 token. */
1518 goto yyerrlab1;
1519
1520
1521 /*---------------------------------------------------.
1522 | yyerrorlab -- error raised explicitly by YYERROR. |
1523 `---------------------------------------------------*/
1524 yyerrorlab:
1525
1526 /* Pacify compilers like GCC when the user code never invokes
1527 YYERROR and the label yyerrorlab therefore never appears in user
1528 code. */
1529 if (/*CONSTCOND*/ 0)
1530 goto yyerrorlab;
1531
1532 ]b4_locations_if([[ ]b4_yyerror_range[[0] = yylsp[1-yylen];
1533 ]])[ /* Do not reclaim the symbols of the rule which action triggered
1534 this YYERROR. */
1535 YYPOPSTACK (yylen);
1536 yylen = 0;
1537 YY_STACK_PRINT (yyss, yyssp);
1538 yystate = *yyssp;
1539 goto yyerrlab1;
1540
1541
1542 /*-------------------------------------------------------------.
1543 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1544 `-------------------------------------------------------------*/
1545 yyerrlab1:
1546 yyerrstatus = 3; /* Each real token shifted decrements this. */
1547
1548 for (;;)
1549 {
1550 yyn = yypact[yystate];
1551 if (yyn != YYPACT_NINF)
1552 {
1553 yyn += YYTERROR;
1554 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1555 {
1556 yyn = yytable[yyn];
1557 if (0 < yyn)
1558 break;
1559 }
1560 }
1561
1562 /* Pop the current state because it cannot handle the error token. */
1563 if (yyssp == yyss)
1564 YYABORT;
1565
1566 ]b4_locations_if([[ ]b4_yyerror_range[[0] = *yylsp;]])[
1567 yydestruct ("Error: popping",
1568 yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1569 YYPOPSTACK (1);
1570 yystate = *yyssp;
1571 YY_STACK_PRINT (yyss, yyssp);
1572 }
1573
1574 *++yyvsp = yylval;
1575 ]b4_locations_if([[
1576 ]b4_yyerror_range[[1] = yylloc;
1577 /* Using YYLLOC is tempting, but would change the location of
1578 the lookahead. YYLOC is available though. */
1579 YYLLOC_DEFAULT (yyloc, (]b4_yyerror_range[- 1), 2);
1580 *++yylsp = yyloc;]])[
1581
1582 /* Shift the error token. */
1583 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1584
1585 yystate = yyn;
1586 goto yynewstate;
1587
1588
1589 /*-------------------------------------.
1590 | yyacceptlab -- YYACCEPT comes here. |
1591 `-------------------------------------*/
1592 yyacceptlab:
1593 yyresult = 0;
1594 goto yyreturn;
1595
1596 /*-----------------------------------.
1597 | yyabortlab -- YYABORT comes here. |
1598 `-----------------------------------*/
1599 yyabortlab:
1600 yyresult = 1;
1601 goto yyreturn;
1602
1603 #ifndef yyoverflow
1604 /*-------------------------------------------------.
1605 | yyexhaustedlab -- memory exhaustion comes here. |
1606 `-------------------------------------------------*/
1607 yyexhaustedlab:
1608 yyerror (]b4_yyerror_args[YY_("memory exhausted"));
1609 yyresult = 2;
1610 /* Fall through. */
1611 #endif
1612
1613 yyreturn:
1614 if (yychar != YYEMPTY)
1615 yydestruct ("Cleanup: discarding lookahead",
1616 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1617 /* Do not reclaim the symbols of the rule which action triggered
1618 this YYABORT or YYACCEPT. */
1619 YYPOPSTACK (yylen);
1620 YY_STACK_PRINT (yyss, yyssp);
1621 while (yyssp != yyss)
1622 {
1623 yydestruct ("Cleanup: popping",
1624 yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1625 YYPOPSTACK (1);
1626 }
1627 #ifndef yyoverflow
1628 if (yyss != ]b4_yyssa[)
1629 YYSTACK_FREE (yyss);
1630 #endif
1631 ]b4_push_if([yypushreturn:])[
1632 #if YYERROR_VERBOSE
1633 if (yymsg != yymsgbuf)
1634 YYSTACK_FREE (yymsg);
1635 #endif
1636 ]b4_push_if([pv->yyresult = YYID (yyresult);])[
1637 /* Make sure YYID is used. */
1638 return YYID (yyresult);
1639 ]}
1640
1641 b4_epilogue
1642 b4_defines_if(
1643 [@output @output_header_name@
1644 b4_copyright([Skeleton interface for Bison's Yacc-like parsers in C],dnl '
1645 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006])
1646
1647 m4_ifdef([b4_requires],
1648 [[/* Copy the %requires blocks. */
1649 ]b4_user_requires])[]dnl
1650
1651 b4_token_enums_defines(b4_tokens)
1652
1653 [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1654 ]m4_ifdef([b4_stype],
1655 [[typedef union ]b4_union_name[
1656 ]b4_user_stype[
1657 YYSTYPE;
1658 # define YYSTYPE_IS_TRIVIAL 1]],
1659 [m4_if(b4_tag_seen_flag, 0,
1660 [[typedef int YYSTYPE;
1661 # define YYSTYPE_IS_TRIVIAL 1]])])[
1662 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1663 # define YYSTYPE_IS_DECLARED 1
1664 #endif
1665
1666 ]b4_pure_if([],
1667 [extern YYSTYPE b4_prefix[]lval;])
1668
1669 b4_locations_if(
1670 [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
1671 typedef struct YYLTYPE
1672 {
1673 int first_line;
1674 int first_column;
1675 int last_line;
1676 int last_column;
1677 } YYLTYPE;
1678 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1679 # define YYLTYPE_IS_DECLARED 1
1680 # define YYLTYPE_IS_TRIVIAL 1
1681 #endif
1682
1683 ]b4_push_if([struct ]b4_prefix[pvars;
1684 enum { YYPUSH_MORE = 4 };])[
1685 ]b4_pure_if([],
1686 [extern YYLTYPE b4_prefix[]lloc;])
1687 )dnl b4_locations_if
1688
1689 m4_ifdef([b4_provides],
1690 [[/* Copy the %provides blocks. */
1691 ]b4_user_provides])[]
1692 ])dnl b4_defines_if
bison