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