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


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