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


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