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


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