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


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