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