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


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