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


68095c1f753e4f8c06f3264d2a88633ae8a43026
[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 3 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, see <http://www.gnu.org/licenses/>.
20
21 # Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing
22 # tests function as written, don't let BISON_USE_PUSH_FOR_PULL modify Bison's
23 # behavior at all when push parsing is already requested.
24 b4_use_push_for_pull_if([
25 b4_push_if([
26 m4_define([b4_use_push_for_pull_flag], [[0]])
27 b4_define_flag_if([use_push_for_pull])
28 ], [
29 m4_define([b4_push_flag], [[1]])
30 b4_define_flag_if([push])
31 ])])
32
33 m4_include(b4_pkgdatadir/[c.m4])
34
35 ## ---------------- ##
36 ## Default values. ##
37 ## ---------------- ##
38
39 # Stack parameters.
40 m4_define_default([b4_stack_depth_max], [10000])
41 m4_define_default([b4_stack_depth_init], [200])
42
43
44 ## ------------------------ ##
45 ## Pure/impure interfaces. ##
46 ## ------------------------ ##
47
48
49 # b4_yacc_pure_if(IF-TRUE, IF-FALSE)
50 # ----------------------------------
51 # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
52 m4_define([b4_yacc_pure_if],
53 [b4_pure_if([m4_ifset([b4_parse_param],
54 [$1], [$2])],
55 [$2])])
56
57
58 # b4_yyerror_args
59 # ---------------
60 # Arguments passed to yyerror: user args plus yylloc.
61 m4_define([b4_yyerror_args],
62 [b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl
63 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
64
65
66 # b4_lex_param
67 # ------------
68 # Accumulate in b4_lex_param all the yylex arguments.
69 # b4_lex_param arrives quoted twice, but we want to keep only one level.
70 m4_define([b4_lex_param],
71 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
72 b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
73 m4_ifdef([b4_lex_param], b4_lex_param)))
74
75
76 ## ------------ ##
77 ## Data Types. ##
78 ## ------------ ##
79
80 # b4_int_type(MIN, MAX)
81 # ---------------------
82 # Return the smallest int type able to handle numbers ranging from
83 # MIN to MAX (included). Overwrite the version from c.m4, which
84 # uses only C89 types, so that the user can override the shorter
85 # types, and so that pre-C89 compilers are handled correctly.
86 m4_define([b4_int_type],
87 [m4_if(b4_ints_in($@, [0], [255]), [1], [yytype_uint8],
88 b4_ints_in($@, [-128], [127]), [1], [yytype_int8],
89
90 b4_ints_in($@, [0], [65535]), [1], [yytype_uint16],
91 b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16],
92
93 m4_eval([0 <= $1]), [1], [unsigned int],
94
95 [int])])
96
97
98 ## ----------------- ##
99 ## Semantic Values. ##
100 ## ----------------- ##
101
102
103 # b4_lhs_value([TYPE])
104 # --------------------
105 # Expansion of $<TYPE>$.
106 m4_define([b4_lhs_value],
107 [(yyval[]m4_ifval([$1], [.$1]))])
108
109
110 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
111 # --------------------------------------
112 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
113 # symbols on RHS.
114 m4_define([b4_rhs_value],
115 [(yyvsp@{($2) - ($1)@}m4_ifval([$3], [.$3]))])
116
117
118
119 ## ----------- ##
120 ## Locations. ##
121 ## ----------- ##
122
123 # b4_lhs_location()
124 # -----------------
125 # Expansion of @$.
126 m4_define([b4_lhs_location],
127 [(yyloc)])
128
129
130 # b4_rhs_location(RULE-LENGTH, NUM)
131 # ---------------------------------
132 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
133 # on RHS.
134 m4_define([b4_rhs_location],
135 [(yylsp@{($2) - ($1)@})])
136
137
138
139 ## --------------------------------------------------------- ##
140 ## Defining symbol actions, e.g., printers and destructors. ##
141 ## --------------------------------------------------------- ##
142
143 # We do want M4 expansion after # for CPP macros.
144 m4_changecom()
145 m4_divert_push(0)dnl
146 @output(b4_parser_file_name@)
147 b4_copyright([Skeleton implementation for Bison's Yacc-like parsers in C],dnl '
148 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006])[
149
150 /* C LALR(1) parser skeleton written by Richard Stallman, by
151 simplifying the original so-called "semantic" parser. */
152
153 /* All symbols defined below should begin with yy or YY, to avoid
154 infringing on user name space. This should be done even for local
155 variables, as they might otherwise be expanded by user macros.
156 There are some unavoidable exceptions within include files to
157 define necessary library symbols; they are noted "INFRINGES ON
158 USER NAME SPACE" below. */
159
160 ]b4_identification
161 b4_percent_code_get([[top]])[]dnl
162 m4_if(b4_prefix, [yy], [],
163 [[/* Substitute the variable and function names. */
164 ]b4_pull_if([[#define yyparse ]b4_prefix[parse
165 ]])b4_push_if([[#define yypush_parse ]b4_prefix[push_parse
166 ]b4_pull_if([[#define yypull_parse ]b4_prefix[pull_parse
167 ]])[#define yypstate_new ]b4_prefix[pstate_new
168 #define yypstate_delete ]b4_prefix[pstate_delete
169 #define yypstate ]b4_prefix[pstate
170 ]])[#define yylex ]b4_prefix[lex
171 #define yyerror ]b4_prefix[error
172 #define yylval ]b4_prefix[lval
173 #define yychar ]b4_prefix[char
174 #define yydebug ]b4_prefix[debug
175 #define yynerrs ]b4_prefix[nerrs
176 ]b4_locations_if([[#define yylloc ]b4_prefix[lloc]])])[
177
178 /* Copy the first part of user declarations. */
179 ]b4_user_pre_prologue[
180
181 /* Enabling traces. */
182 #ifndef YYDEBUG
183 # define YYDEBUG ]b4_debug_flag[
184 #endif
185
186 /* Enabling verbose error messages. */
187 #ifdef YYERROR_VERBOSE
188 # undef YYERROR_VERBOSE
189 # define YYERROR_VERBOSE 1
190 #else
191 # define YYERROR_VERBOSE ]b4_error_verbose_flag[
192 #endif
193
194 /* Enabling the token table. */
195 #ifndef YYTOKEN_TABLE
196 # define YYTOKEN_TABLE ]b4_token_table[
197 #endif
198
199 ]b4_percent_code_get([[requires]])[]dnl
200
201 b4_token_enums_defines(b4_tokens)[
202
203 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
204 ]m4_ifdef([b4_stype],
205 [[typedef union ]b4_union_name[
206 {
207 ]b4_user_stype[
208 } YYSTYPE;
209 # define YYSTYPE_IS_TRIVIAL 1]],
210 [m4_if(b4_tag_seen_flag, 0,
211 [[typedef int YYSTYPE;
212 # define YYSTYPE_IS_TRIVIAL 1]])])[
213 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
214 # define YYSTYPE_IS_DECLARED 1
215 #endif
216
217 ]b4_locations_if([#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
218 typedef struct YYLTYPE
219 {
220 int first_line;
221 int first_column;
222 int last_line;
223 int last_column;
224 } YYLTYPE;
225 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
226 # define YYLTYPE_IS_DECLARED 1
227 # define YYLTYPE_IS_TRIVIAL 1
228 #endif])
229
230 b4_push_if([[#ifndef YYPUSH_DECLS
231 # define YYPUSH_DECLS
232 struct yypstate;
233 typedef struct yypstate yypstate;
234 enum { YYPUSH_MORE = 4 };
235
236 ]b4_pull_if([b4_c_function_decl([[yyparse]], [[int]], b4_parse_param)
237 ])b4_c_function_decl([[yypush_parse]], [[int]],
238 [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
239 [[[int yypushed_char]], [[yypushed_char]]],
240 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
241 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
242 b4_parse_param]))
243 b4_pull_if([b4_c_function_decl([[yypull_parse]], [[int]],
244 [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
245 b4_parse_param]))])
246 b4_c_function_decl([[yypstate_new]], [[yypstate *]], [[[void]], []])
247 b4_c_function_decl([[yypstate_delete]], [[void]],
248 [[[yypstate *yyps]], [[yyps]]])[
249 #endif
250 ]])
251 b4_percent_code_get([[provides]])[]dnl
252
253 [/* Copy the second part of user declarations. */
254 ]b4_user_post_prologue
255 b4_percent_code_get[]dnl
256
257 [#ifdef short
258 # undef short
259 #endif
260
261 #ifdef YYTYPE_UINT8
262 typedef YYTYPE_UINT8 yytype_uint8;
263 #else
264 typedef unsigned char yytype_uint8;
265 #endif
266
267 #ifdef YYTYPE_INT8
268 typedef YYTYPE_INT8 yytype_int8;
269 #elif ]b4_c_modern[
270 typedef signed char yytype_int8;
271 #else
272 typedef short int yytype_int8;
273 #endif
274
275 #ifdef YYTYPE_UINT16
276 typedef YYTYPE_UINT16 yytype_uint16;
277 #else
278 typedef unsigned short int yytype_uint16;
279 #endif
280
281 #ifdef YYTYPE_INT16
282 typedef YYTYPE_INT16 yytype_int16;
283 #else
284 typedef short int yytype_int16;
285 #endif
286
287 #ifndef YYSIZE_T
288 # ifdef __SIZE_TYPE__
289 # define YYSIZE_T __SIZE_TYPE__
290 # elif defined size_t
291 # define YYSIZE_T size_t
292 # elif ! defined YYSIZE_T && ]b4_c_modern[
293 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
294 # define YYSIZE_T size_t
295 # else
296 # define YYSIZE_T unsigned int
297 # endif
298 #endif
299
300 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
301
302 #ifndef YY_
303 # if YYENABLE_NLS
304 # if ENABLE_NLS
305 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
306 # define YY_(msgid) dgettext ("bison-runtime", msgid)
307 # endif
308 # endif
309 # ifndef YY_
310 # define YY_(msgid) msgid
311 # endif
312 #endif
313
314 /* Suppress unused-variable warnings by "using" E. */
315 #if ! defined lint || defined __GNUC__
316 # define YYUSE(e) ((void) (e))
317 #else
318 # define YYUSE(e) /* empty */
319 #endif
320
321 /* Identity function, used to suppress warnings about constant conditions. */
322 #ifndef lint
323 # define YYID(n) (n)
324 #else
325 ]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[
326 {
327 return yyi;
328 }
329 #endif
330
331 #if ! defined yyoverflow || YYERROR_VERBOSE
332
333 ]b4_push_if([],
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 ]])dnl
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 YYFPRINTF (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 YYFPRINTF (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 }]b4_pure_if([], [[
1080
1081 static char yypstate_allocated = 0;]])[
1082
1083 ]b4_c_function_def([[yypull_parse]], [[int]],
1084 [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1085 b4_parse_param]))[
1086 {
1087 int yystatus;
1088 yypstate *yyps_local;
1089 ]b4_pure_if([[ int yychar;
1090 YYSTYPE yylval;
1091 ]b4_locations_if([[ YYLTYPE yylloc;
1092 ]])])[
1093 if (yyps == 0)
1094 {
1095 yyps_local = yypstate_new ();
1096 if (!yyps_local)
1097 {]b4_pure_if([[
1098 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
1099 if (!yypstate_allocated)
1100 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
1101 return 2;
1102 }
1103 }
1104 else
1105 yyps_local = yyps;
1106 do {
1107 yychar = YYLEX;
1108 yystatus =
1109 yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
1110 } while (yystatus == YYPUSH_MORE);
1111 if (yyps == 0)
1112 yypstate_delete (yyps_local);
1113 return yystatus;
1114 }
1115 ]])[
1116 /* Initialize the parser data structure. */
1117 ]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
1118 {
1119 yypstate *yyps;]b4_pure_if([], [[
1120 if (yypstate_allocated)
1121 {
1122 yyerror (]b4_yyerror_args[YY_("cannot allocate multiple impure push-parser instances"));
1123 return 0;
1124 }]])[
1125 yyps = (yypstate *) malloc (sizeof *yyps);
1126 if (!yyps)
1127 return 0;
1128 yyps->yynew = 1;]b4_pure_if([], [[
1129 yypstate_allocated = 1;]])[
1130 return yyps;
1131 }
1132
1133 ]b4_c_function_def([[yypstate_delete]], [[void]],
1134 [[[yypstate *yyps]], [[yyps]]])[
1135 {
1136 #ifndef yyoverflow
1137 /* If the stack was reallocated but the parse did not complete, then the
1138 stack still needs to be freed. */
1139 if (!yyps->yynew && yyps->yyss != yyps->yyssa)
1140 YYSTACK_FREE (yyps->yyss);
1141 #endif
1142 free (yyps);]b4_pure_if([], [[
1143 yypstate_allocated = 0;]])[
1144 }
1145
1146 ]b4_pure_if([[#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs
1147 ]])[#define yystate yyps->yystate
1148 #define yyerrstatus yyps->yyerrstatus
1149 #define yyssa yyps->yyssa
1150 #define yyss yyps->yyss
1151 #define yyssp yyps->yyssp
1152 #define yyvsa yyps->yyvsa
1153 #define yyvs yyps->yyvs
1154 #define yyvsp yyps->yyvsp
1155 ]b4_locations_if([[#define yylsa yyps->yylsa
1156 #define yyls yyps->yyls
1157 #define yylsp yyps->yylsp
1158 #define yyerror_range yyps->yyerror_range
1159 ]])[#define yystacksize yyps->yystacksize
1160 ]])[
1161
1162 /*-------------------------.
1163 | yyparse or yypush_parse. |
1164 `-------------------------*/
1165
1166 ]b4_push_if([
1167 b4_c_function_def([[yypush_parse]], [[int]],
1168 [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
1169 [[[int yypushed_char]], [[yypushed_char]]],
1170 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1171 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1172 b4_parse_param]))], [
1173 #ifdef YYPARSE_PARAM
1174 b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])
1175 #else /* ! YYPARSE_PARAM */
1176 b4_c_function_def([yyparse], [int], b4_parse_param)
1177 #endif])[
1178 {
1179 ]b4_pure_if([b4_declare_scanner_communication_variables])
1180 b4_push_if([b4_pure_if([], [[ int yypushed_char = yychar;
1181 YYSTYPE yypushed_val = yylval;
1182 ]b4_locations_if([[YYLTYPE yypushed_loc = yylloc;
1183 ]])])],
1184 [b4_declare_parser_state_variables])[
1185 int yyn;
1186 int yyresult;
1187 /* Look-ahead token as an internal (translated) token number. */
1188 int yytoken;
1189 /* The variables used to return semantic value and location from the
1190 action routines. */
1191 YYSTYPE yyval;
1192 ]b4_locations_if([[ YYLTYPE yyloc;
1193 ]])[
1194 #if YYERROR_VERBOSE
1195 /* Buffer for error messages, and its allocated size. */
1196 char yymsgbuf[128];
1197 char *yymsg = yymsgbuf;
1198 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1199 #endif
1200
1201 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
1202
1203 /* The number of symbols on the RHS of the reduced rule.
1204 Keep to zero when no symbol should be popped. */
1205 int yylen = 0;
1206 ]b4_push_if([[
1207 if (!yyps->yynew)
1208 {
1209 yyn = yypact[yystate];
1210 goto yyread_pushed_token;
1211 }
1212 ]])[
1213 yytoken = 0;
1214 yyss = yyssa;
1215 yyvs = yyvsa;
1216 ]b4_locations_if([[ yyls = yylsa;
1217 ]])[
1218 yystacksize = YYINITDEPTH;
1219
1220 YYDPRINTF ((stderr, "Starting parse\n"));
1221
1222 yystate = 0;
1223 yyerrstatus = 0;
1224 yynerrs = 0;
1225 yychar = YYEMPTY; /* Cause a token to be read. */
1226
1227 /* Initialize stack pointers.
1228 Waste one element of value and location stack
1229 so that they stay on the same level as the state stack.
1230 The wasted elements are never initialized. */
1231 yyssp = yyss;
1232 yyvsp = yyvs;
1233 ]b4_locations_if([[ yylsp = yyls;
1234
1235 #if YYLTYPE_IS_TRIVIAL
1236 /* Initialize the default location before parsing starts. */
1237 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
1238 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
1239 #endif
1240 ]])
1241 m4_ifdef([b4_initial_action], [
1242 m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl
1243 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
1244 /* User initialization code. */
1245 b4_user_initial_action
1246 m4_popdef([b4_dollar_dollar])dnl
1247 m4_popdef([b4_at_dollar])])dnl
1248 m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval;
1249 ]])dnl
1250 m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc;
1251 ]])dnl
1252 [
1253 goto yysetstate;
1254
1255 /*------------------------------------------------------------.
1256 | yynewstate -- Push a new state, which is found in yystate. |
1257 `------------------------------------------------------------*/
1258 yynewstate:
1259 /* In all cases, when you get here, the value and location stacks
1260 have just been pushed. So pushing a state here evens the stacks. */
1261 yyssp++;
1262
1263 yysetstate:
1264 *yyssp = yystate;
1265
1266 if (yyss + yystacksize - 1 <= yyssp)
1267 {
1268 /* Get the current used size of the three stacks, in elements. */
1269 YYSIZE_T yysize = yyssp - yyss + 1;
1270
1271 #ifdef yyoverflow
1272 {
1273 /* Give user a chance to reallocate the stack. Use copies of
1274 these so that the &'s don't force the real ones into
1275 memory. */
1276 YYSTYPE *yyvs1 = yyvs;
1277 yytype_int16 *yyss1 = yyss;
1278 ]b4_locations_if([ YYLTYPE *yyls1 = yyls;])[
1279
1280 /* Each stack pointer address is followed by the size of the
1281 data in use in that stack, in bytes. This used to be a
1282 conditional around just the two extra args, but that might
1283 be undefined if yyoverflow is a macro. */
1284 yyoverflow (YY_("memory exhausted"),
1285 &yyss1, yysize * sizeof (*yyssp),
1286 &yyvs1, yysize * sizeof (*yyvsp),
1287 ]b4_locations_if([ &yyls1, yysize * sizeof (*yylsp),])[
1288 &yystacksize);
1289 ]b4_locations_if([ yyls = yyls1;])[
1290 yyss = yyss1;
1291 yyvs = yyvs1;
1292 }
1293 #else /* no yyoverflow */
1294 # ifndef YYSTACK_RELOCATE
1295 goto yyexhaustedlab;
1296 # else
1297 /* Extend the stack our own way. */
1298 if (YYMAXDEPTH <= yystacksize)
1299 goto yyexhaustedlab;
1300 yystacksize *= 2;
1301 if (YYMAXDEPTH < yystacksize)
1302 yystacksize = YYMAXDEPTH;
1303
1304 {
1305 yytype_int16 *yyss1 = yyss;
1306 union yyalloc *yyptr =
1307 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1308 if (! yyptr)
1309 goto yyexhaustedlab;
1310 YYSTACK_RELOCATE (yyss_alloc, yyss);
1311 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1312 ]b4_locations_if([ YYSTACK_RELOCATE (yyls_alloc, yyls);])[
1313 # undef YYSTACK_RELOCATE
1314 if (yyss1 != yyssa)
1315 YYSTACK_FREE (yyss1);
1316 }
1317 # endif
1318 #endif /* no yyoverflow */
1319
1320 yyssp = yyss + yysize - 1;
1321 yyvsp = yyvs + yysize - 1;
1322 ]b4_locations_if([ yylsp = yyls + yysize - 1;])[
1323
1324 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1325 (unsigned long int) yystacksize));
1326
1327 if (yyss + yystacksize - 1 <= yyssp)
1328 YYABORT;
1329 }
1330
1331 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1332
1333 if (yystate == YYFINAL)
1334 YYACCEPT;
1335
1336 goto yybackup;
1337
1338 /*-----------.
1339 | yybackup. |
1340 `-----------*/
1341 yybackup:
1342
1343 /* Do appropriate processing given the current state. Read a
1344 lookahead token if we need one and don't already have one. */
1345
1346 /* First try to decide what to do without reference to lookahead token. */
1347 yyn = yypact[yystate];
1348 if (yyn == YYPACT_NINF)
1349 goto yydefault;
1350
1351 /* Not known => get a lookahead token if don't already have one. */
1352
1353 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1354 if (yychar == YYEMPTY)
1355 {
1356 ]b4_push_if([[ if (!yyps->yynew)
1357 {
1358 ]b4_use_push_for_pull_if([],
1359 [[ YYDPRINTF ((stderr, "Return for a new token:\n"));
1360 ]])[ yyresult = YYPUSH_MORE;
1361 goto yypushreturn;
1362 }
1363 yyps->yynew = 0;
1364 ]b4_pure_if([], [[
1365 /* Restoring the pushed token is only necessary for the first
1366 yypush_parse invocation since subsequent invocations don't overwrite
1367 it before jumping to yyread_pushed_token. */
1368 yychar = yypushed_char;
1369 yylval = yypushed_val;
1370 ]b4_locations_if([[yylloc = yypushed_loc;
1371 ]])])[
1372 yyread_pushed_token:
1373 ]])[ YYDPRINTF ((stderr, "Reading a token: "));
1374 ]b4_push_if([b4_pure_if([[ yychar = yypushed_char;
1375 if (yypushed_val)
1376 yylval = *yypushed_val;
1377 ]b4_locations_if([[ if (yypushed_loc)
1378 yylloc = *yypushed_loc;
1379 ]])])],
1380 [[ yychar = YYLEX;
1381 ]])[ }
1382
1383 if (yychar <= YYEOF)
1384 {
1385 yychar = yytoken = YYEOF;
1386 YYDPRINTF ((stderr, "Now at end of input.\n"));
1387 }
1388 else
1389 {
1390 yytoken = YYTRANSLATE (yychar);
1391 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1392 }
1393
1394 /* If the proper action on seeing token YYTOKEN is to reduce or to
1395 detect an error, take that action. */
1396 yyn += yytoken;
1397 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1398 goto yydefault;
1399 yyn = yytable[yyn];
1400 if (yyn <= 0)
1401 {
1402 if (yyn == 0 || yyn == YYTABLE_NINF)
1403 goto yyerrlab;
1404 yyn = -yyn;
1405 goto yyreduce;
1406 }
1407
1408 /* Count tokens shifted since error; after three, turn off error
1409 status. */
1410 if (yyerrstatus)
1411 yyerrstatus--;
1412
1413 /* Shift the lookahead token. */
1414 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1415
1416 /* Discard the shifted token. */
1417 yychar = YYEMPTY;
1418
1419 yystate = yyn;
1420 *++yyvsp = yylval;
1421 ]b4_locations_if([ *++yylsp = yylloc;])[
1422 goto yynewstate;
1423
1424
1425 /*-----------------------------------------------------------.
1426 | yydefault -- do the default action for the current state. |
1427 `-----------------------------------------------------------*/
1428 yydefault:
1429 yyn = yydefact[yystate];
1430 if (yyn == 0)
1431 goto yyerrlab;
1432 goto yyreduce;
1433
1434
1435 /*-----------------------------.
1436 | yyreduce -- Do a reduction. |
1437 `-----------------------------*/
1438 yyreduce:
1439 /* yyn is the number of a rule to reduce with. */
1440 yylen = yyr2[yyn];
1441
1442 /* If YYLEN is nonzero, implement the default value of the action:
1443 `$$ = $1'.
1444
1445 Otherwise, the following line sets YYVAL to garbage.
1446 This behavior is undocumented and Bison
1447 users should not rely upon it. Assigning to YYVAL
1448 unconditionally makes the parser a bit smaller, and it avoids a
1449 GCC warning that YYVAL may be used uninitialized. */
1450 yyval = yyvsp[1-yylen];
1451
1452 ]b4_locations_if(
1453 [[ /* Default location. */
1454 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
1455 YY_REDUCE_PRINT (yyn);
1456 switch (yyn)
1457 {
1458 ]b4_user_actions[
1459 default: break;
1460 }
1461 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1462
1463 YYPOPSTACK (yylen);
1464 yylen = 0;
1465 YY_STACK_PRINT (yyss, yyssp);
1466
1467 *++yyvsp = yyval;
1468 ]b4_locations_if([ *++yylsp = yyloc;])[
1469
1470 /* Now `shift' the result of the reduction. Determine what state
1471 that goes to, based on the state we popped back to and the rule
1472 number reduced by. */
1473
1474 yyn = yyr1[yyn];
1475
1476 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1477 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1478 yystate = yytable[yystate];
1479 else
1480 yystate = yydefgoto[yyn - YYNTOKENS];
1481
1482 goto yynewstate;
1483
1484
1485 /*------------------------------------.
1486 | yyerrlab -- here on detecting error |
1487 `------------------------------------*/
1488 yyerrlab:
1489 /* If not already recovering from an error, report this error. */
1490 if (!yyerrstatus)
1491 {
1492 ++yynerrs;
1493 #if ! YYERROR_VERBOSE
1494 yyerror (]b4_yyerror_args[YY_("syntax error"));
1495 #else
1496 {
1497 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1498 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1499 {
1500 YYSIZE_T yyalloc = 2 * yysize;
1501 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1502 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1503 if (yymsg != yymsgbuf)
1504 YYSTACK_FREE (yymsg);
1505 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1506 if (yymsg)
1507 yymsg_alloc = yyalloc;
1508 else
1509 {
1510 yymsg = yymsgbuf;
1511 yymsg_alloc = sizeof yymsgbuf;
1512 }
1513 }
1514
1515 if (0 < yysize && yysize <= yymsg_alloc)
1516 {
1517 (void) yysyntax_error (yymsg, yystate, yychar);
1518 yyerror (]b4_yyerror_args[yymsg);
1519 }
1520 else
1521 {
1522 yyerror (]b4_yyerror_args[YY_("syntax error"));
1523 if (yysize != 0)
1524 goto yyexhaustedlab;
1525 }
1526 }
1527 #endif
1528 }
1529
1530 ]b4_locations_if([[ yyerror_range[0] = yylloc;]])[
1531
1532 if (yyerrstatus == 3)
1533 {
1534 /* If just tried and failed to reuse lookahead token after an
1535 error, discard it. */
1536
1537 if (yychar <= YYEOF)
1538 {
1539 /* Return failure if at end of input. */
1540 if (yychar == YYEOF)
1541 YYABORT;
1542 }
1543 else
1544 {
1545 yydestruct ("Error: discarding",
1546 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1547 yychar = YYEMPTY;
1548 }
1549 }
1550
1551 /* Else will try to reuse lookahead token after shifting the error
1552 token. */
1553 goto yyerrlab1;
1554
1555
1556 /*---------------------------------------------------.
1557 | yyerrorlab -- error raised explicitly by YYERROR. |
1558 `---------------------------------------------------*/
1559 yyerrorlab:
1560
1561 /* Pacify compilers like GCC when the user code never invokes
1562 YYERROR and the label yyerrorlab therefore never appears in user
1563 code. */
1564 if (/*CONSTCOND*/ 0)
1565 goto yyerrorlab;
1566
1567 ]b4_locations_if([[ yyerror_range[0] = yylsp[1-yylen];
1568 ]])[ /* Do not reclaim the symbols of the rule which action triggered
1569 this YYERROR. */
1570 YYPOPSTACK (yylen);
1571 yylen = 0;
1572 YY_STACK_PRINT (yyss, yyssp);
1573 yystate = *yyssp;
1574 goto yyerrlab1;
1575
1576
1577 /*-------------------------------------------------------------.
1578 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1579 `-------------------------------------------------------------*/
1580 yyerrlab1:
1581 yyerrstatus = 3; /* Each real token shifted decrements this. */
1582
1583 for (;;)
1584 {
1585 yyn = yypact[yystate];
1586 if (yyn != YYPACT_NINF)
1587 {
1588 yyn += YYTERROR;
1589 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1590 {
1591 yyn = yytable[yyn];
1592 if (0 < yyn)
1593 break;
1594 }
1595 }
1596
1597 /* Pop the current state because it cannot handle the error token. */
1598 if (yyssp == yyss)
1599 YYABORT;
1600
1601 ]b4_locations_if([[ yyerror_range[0] = *yylsp;]])[
1602 yydestruct ("Error: popping",
1603 yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1604 YYPOPSTACK (1);
1605 yystate = *yyssp;
1606 YY_STACK_PRINT (yyss, yyssp);
1607 }
1608
1609 *++yyvsp = yylval;
1610 ]b4_locations_if([[
1611 yyerror_range[1] = yylloc;
1612 /* Using YYLLOC is tempting, but would change the location of
1613 the lookahead. YYLOC is available though. */
1614 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
1615 *++yylsp = yyloc;]])[
1616
1617 /* Shift the error token. */
1618 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1619
1620 yystate = yyn;
1621 goto yynewstate;
1622
1623
1624 /*-------------------------------------.
1625 | yyacceptlab -- YYACCEPT comes here. |
1626 `-------------------------------------*/
1627 yyacceptlab:
1628 yyresult = 0;
1629 goto yyreturn;
1630
1631 /*-----------------------------------.
1632 | yyabortlab -- YYABORT comes here. |
1633 `-----------------------------------*/
1634 yyabortlab:
1635 yyresult = 1;
1636 goto yyreturn;
1637
1638 #ifndef yyoverflow
1639 /*-------------------------------------------------.
1640 | yyexhaustedlab -- memory exhaustion comes here. |
1641 `-------------------------------------------------*/
1642 yyexhaustedlab:
1643 yyerror (]b4_yyerror_args[YY_("memory exhausted"));
1644 yyresult = 2;
1645 /* Fall through. */
1646 #endif
1647
1648 yyreturn:
1649 if (yychar != YYEMPTY)
1650 yydestruct ("Cleanup: discarding lookahead",
1651 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1652 /* Do not reclaim the symbols of the rule which action triggered
1653 this YYABORT or YYACCEPT. */
1654 YYPOPSTACK (yylen);
1655 YY_STACK_PRINT (yyss, yyssp);
1656 while (yyssp != yyss)
1657 {
1658 yydestruct ("Cleanup: popping",
1659 yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1660 YYPOPSTACK (1);
1661 }
1662 #ifndef yyoverflow
1663 if (yyss != yyssa)
1664 YYSTACK_FREE (yyss);
1665 #endif
1666 ]b4_push_if([[ yyps->yynew = 1;
1667
1668 yypushreturn:
1669 ]])[#if YYERROR_VERBOSE
1670 if (yymsg != yymsgbuf)
1671 YYSTACK_FREE (yymsg);
1672 #endif
1673 /* Make sure YYID is used. */
1674 return YYID (yyresult);
1675 }
1676
1677
1678 ]b4_epilogue
1679 b4_defines_if(
1680 [@output(b4_spec_defines_file@)
1681 b4_copyright([Skeleton interface for Bison's Yacc-like parsers in C],dnl '
1682 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006])
1683
1684 b4_percent_code_get([[requires]])[]dnl
1685
1686 b4_token_enums_defines(b4_tokens)
1687
1688 [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1689 ]m4_ifdef([b4_stype],
1690 [[typedef union ]b4_union_name[
1691 {
1692 ]b4_user_stype[
1693 } YYSTYPE;
1694 # define YYSTYPE_IS_TRIVIAL 1]],
1695 [m4_if(b4_tag_seen_flag, 0,
1696 [[typedef int YYSTYPE;
1697 # define YYSTYPE_IS_TRIVIAL 1]])])[
1698 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1699 # define YYSTYPE_IS_DECLARED 1
1700 #endif
1701
1702 ]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;]])
1703
1704 b4_locations_if(
1705 [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
1706 typedef struct YYLTYPE
1707 {
1708 int first_line;
1709 int first_column;
1710 int last_line;
1711 int last_column;
1712 } YYLTYPE;
1713 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1714 # define YYLTYPE_IS_DECLARED 1
1715 # define YYLTYPE_IS_TRIVIAL 1
1716 #endif
1717
1718 ]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]])
1719 )dnl b4_locations_if
1720
1721 b4_push_if([[#ifndef YYPUSH_DECLS
1722 # define YYPUSH_DECLS
1723 struct ]b4_prefix[pstate;
1724 typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
1725 enum { YYPUSH_MORE = 4 };
1726 ]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
1727 ])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
1728 [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([,
1729 [[[int yypushed_char]], [[yypushed_char]]],
1730 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1731 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1732 b4_parse_param]))
1733 b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
1734 [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1735 b4_parse_param]))])
1736 b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
1737 [[[void]], []])
1738 b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
1739 [[b4_prefix[pstate *yyps]], [[yyps]]])[
1740 #endif
1741 ]])
1742 b4_percent_code_get([[provides]])[]dnl
1743 ])dnl b4_defines_if
1744 m4_divert_pop(0)
bison