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


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