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


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