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