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


52c8fae602f6ac28add5bff76b6f6162aa6308ae
[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, 2007, 2008, 2009])
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_parse_trace_if([1], [0])[
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_if([1], [0])[
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 ]b4_integral_parser_table_define([rline], [b4_rline],
505 [YYRLINE[YYN] -- Source line where rule number YYN was defined.])[
506 #endif
507
508 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
509 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
510 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
511 static const char *const yytname[] =
512 {
513 ]b4_tname[
514 };
515 #endif
516
517 # ifdef YYPRINT
518 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
519 (internal) symbol number NUM (which must be that of a token). */
520 static const ]b4_int_type_for([b4_toknum])[ yytoknum[] =
521 {
522 ]b4_toknum[
523 };
524 # endif
525
526 #define YYPACT_NINF ]b4_pact_ninf[
527
528 #define YYTABLE_NINF ]b4_table_ninf[
529
530 ]b4_parser_tables_define[
531
532 #define yyerrok (yyerrstatus = 0)
533 #define yyclearin (yychar = YYEMPTY)
534 #define YYEMPTY (-2)
535 #define YYEOF 0
536
537 #define YYACCEPT goto yyacceptlab
538 #define YYABORT goto yyabortlab
539 #define YYERROR goto yyerrorlab
540
541
542 /* Like YYERROR except do call yyerror. This remains here temporarily
543 to ease the transition to the new meaning of YYERROR, for GCC.
544 Once GCC version 2 has supplanted version 1, this can go. */
545
546 #define YYFAIL goto yyerrlab
547
548 #define YYRECOVERING() (!!yyerrstatus)
549
550 #define YYBACKUP(Token, Value) \
551 do \
552 if (yychar == YYEMPTY && yylen == 1) \
553 { \
554 yychar = (Token); \
555 yylval = (Value); \
556 yytoken = YYTRANSLATE (yychar); \
557 YYPOPSTACK (1); \
558 goto yybackup; \
559 } \
560 else \
561 { \
562 yyerror (]b4_yyerror_args[YY_("syntax error: cannot back up")); \
563 YYERROR; \
564 } \
565 while (YYID (0))
566
567
568 #define YYTERROR 1
569 #define YYERRCODE 256
570
571
572 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
573 If N is 0, then set CURRENT to the empty location which ends
574 the previous symbol: RHS[0] (always defined). */
575
576 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
577 #ifndef YYLLOC_DEFAULT
578 # define YYLLOC_DEFAULT(Current, Rhs, N) \
579 do \
580 if (YYID (N)) \
581 { \
582 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
583 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
584 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
585 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
586 } \
587 else \
588 { \
589 (Current).first_line = (Current).last_line = \
590 YYRHSLOC (Rhs, 0).last_line; \
591 (Current).first_column = (Current).last_column = \
592 YYRHSLOC (Rhs, 0).last_column; \
593 } \
594 while (YYID (0))
595 #endif
596
597
598 /* YY_LOCATION_PRINT -- Print the location on the stream.
599 This macro was not mandated originally: define only if we know
600 we won't break user code: when these are the locations we know. */
601
602 #ifndef YY_LOCATION_PRINT
603 # if YYLTYPE_IS_TRIVIAL
604 # define YY_LOCATION_PRINT(File, Loc) \
605 fprintf (File, "%d.%d-%d.%d", \
606 (Loc).first_line, (Loc).first_column, \
607 (Loc).last_line, (Loc).last_column)
608 # else
609 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
610 # endif
611 #endif
612
613
614 /* YYLEX -- calling `yylex' with the right arguments. */
615
616 #ifdef YYLEX_PARAM
617 # define YYLEX yylex (]b4_pure_if([&yylval[]b4_locations_if([, &yylloc]), ])[YYLEX_PARAM)
618 #else
619 # define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[
620 #endif
621
622 /* Enable debugging if requested. */
623 #if YYDEBUG
624
625 # ifndef YYFPRINTF
626 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
627 # define YYFPRINTF fprintf
628 # endif
629
630 # define YYDPRINTF(Args) \
631 do { \
632 if (yydebug) \
633 YYFPRINTF Args; \
634 } while (YYID (0))
635
636 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
637 do { \
638 if (yydebug) \
639 { \
640 YYFPRINTF (stderr, "%s ", Title); \
641 yy_symbol_print (stderr, \
642 Type, Value]b4_locations_if([, Location])[]b4_user_args[); \
643 YYFPRINTF (stderr, "\n"); \
644 } \
645 } while (YYID (0))
646
647 ]b4_yy_symbol_print_generate([b4_c_function_def])[
648
649 /*------------------------------------------------------------------.
650 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
651 | TOP (included). |
652 `------------------------------------------------------------------*/
653
654 ]b4_c_function_def([yy_stack_print], [static void],
655 [[yytype_int16 *yybottom], [yybottom]],
656 [[yytype_int16 *yytop], [yytop]])[
657 {
658 YYFPRINTF (stderr, "Stack now");
659 for (; yybottom <= yytop; yybottom++)
660 {
661 int yybot = *yybottom;
662 YYFPRINTF (stderr, " %d", yybot);
663 }
664 YYFPRINTF (stderr, "\n");
665 }
666
667 # define YY_STACK_PRINT(Bottom, Top) \
668 do { \
669 if (yydebug) \
670 yy_stack_print ((Bottom), (Top)); \
671 } while (YYID (0))
672
673
674 /*------------------------------------------------.
675 | Report that the YYRULE is going to be reduced. |
676 `------------------------------------------------*/
677
678 ]b4_c_function_def([yy_reduce_print], [static void],
679 [[yytype_int16 *yyssp], [yyssp]],
680 [[YYSTYPE *yyvsp], [yyvsp]],
681 b4_locations_if([[[YYLTYPE *yylsp], [yylsp]],
682 ])[[int yyrule], [yyrule]]m4_ifset([b4_parse_param], [,
683 b4_parse_param]))[
684 {
685 unsigned long int yylno = yyrline[yyrule];
686 int yynrhs = yyr2[yyrule];
687 int yyi;
688 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
689 yyrule - 1, yylno);
690 /* The symbols being reduced. */
691 for (yyi = 0; yyi < yynrhs; yyi++)
692 {
693 YYFPRINTF (stderr, " $%d = ", yyi + 1);
694 yy_symbol_print (stderr,
695 yystos[yyssp[yyi + 1 - yynrhs]],
696 &]b4_rhs_value(yynrhs, yyi + 1)[
697 ]b4_locations_if([, &]b4_rhs_location(yynrhs, yyi + 1))[]dnl
698 b4_user_args[);
699 YYFPRINTF (stderr, "\n");
700 }
701 }
702
703 # define YY_REDUCE_PRINT(Rule) \
704 do { \
705 if (yydebug) \
706 yy_reduce_print (yyssp, yyvsp, ]b4_locations_if([yylsp, ])[Rule]b4_user_args[); \
707 } while (YYID (0))
708
709 /* Nonzero means print parse trace. It is left uninitialized so that
710 multiple parsers can coexist. */
711 int yydebug;
712 #else /* !YYDEBUG */
713 # define YYDPRINTF(Args)
714 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
715 # define YY_STACK_PRINT(Bottom, Top)
716 # define YY_REDUCE_PRINT(Rule)
717 #endif /* !YYDEBUG */
718
719
720 /* YYINITDEPTH -- initial size of the parser's stacks. */
721 #ifndef YYINITDEPTH
722 # define YYINITDEPTH ]b4_stack_depth_init[
723 #endif
724
725 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
726 if the built-in stack extension method is used).
727
728 Do not make this value too large; the results are undefined if
729 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
730 evaluated with infinite-precision integer arithmetic. */
731
732 #ifndef YYMAXDEPTH
733 # define YYMAXDEPTH ]b4_stack_depth_max[
734 #endif
735
736 \f
737
738 #if YYERROR_VERBOSE
739
740 # ifndef yystrlen
741 # if defined __GLIBC__ && defined _STRING_H
742 # define yystrlen strlen
743 # else
744 /* Return the length of YYSTR. */
745 ]b4_c_function_def([yystrlen], [static YYSIZE_T],
746 [[const char *yystr], [yystr]])[
747 {
748 YYSIZE_T yylen;
749 for (yylen = 0; yystr[yylen]; yylen++)
750 continue;
751 return yylen;
752 }
753 # endif
754 # endif
755
756 # ifndef yystpcpy
757 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
758 # define yystpcpy stpcpy
759 # else
760 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
761 YYDEST. */
762 ]b4_c_function_def([yystpcpy], [static char *],
763 [[char *yydest], [yydest]], [[const char *yysrc], [yysrc]])[
764 {
765 char *yyd = yydest;
766 const char *yys = yysrc;
767
768 while ((*yyd++ = *yys++) != '\0')
769 continue;
770
771 return yyd - 1;
772 }
773 # endif
774 # endif
775
776 # ifndef yytnamerr
777 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
778 quotes and backslashes, so that it's suitable for yyerror. The
779 heuristic is that double-quoting is unnecessary unless the string
780 contains an apostrophe, a comma, or backslash (other than
781 backslash-backslash). YYSTR is taken from yytname. If YYRES is
782 null, do not copy; instead, return the length of what the result
783 would have been. */
784 static YYSIZE_T
785 yytnamerr (char *yyres, const char *yystr)
786 {
787 if (*yystr == '"')
788 {
789 YYSIZE_T yyn = 0;
790 char const *yyp = yystr;
791
792 for (;;)
793 switch (*++yyp)
794 {
795 case '\'':
796 case ',':
797 goto do_not_strip_quotes;
798
799 case '\\':
800 if (*++yyp != '\\')
801 goto do_not_strip_quotes;
802 /* Fall through. */
803 default:
804 if (yyres)
805 yyres[yyn] = *yyp;
806 yyn++;
807 break;
808
809 case '"':
810 if (yyres)
811 yyres[yyn] = '\0';
812 return yyn;
813 }
814 do_not_strip_quotes: ;
815 }
816
817 if (! yyres)
818 return yystrlen (yystr);
819
820 return yystpcpy (yyres, yystr) - yyres;
821 }
822 # endif
823
824 /* Copy into YYRESULT an error message about the unexpected token
825 YYTOKEN while in state YYSTATE. Return the number of bytes copied,
826 including the terminating null byte. If YYRESULT is null, do not
827 copy anything; just return the number of bytes that would be
828 copied. As a special case, return 0 if an ordinary "syntax error"
829 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
830 size calculation. */
831 static YYSIZE_T
832 yysyntax_error (char *yyresult, int yystate, int yytoken)
833 {
834 int yyn = yypact[yystate];
835
836 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
837 return 0;
838 else
839 {
840 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
841 YYSIZE_T yysize = yysize0;
842 YYSIZE_T yysize1;
843 int yysize_overflow = 0;
844 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
845 /* Internationalized format string. */
846 const char *yyformat = 0;
847 /* Arguments of yyformat. */
848 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
849
850 /* Start YYX at -YYN if negative to avoid negative indexes in
851 YYCHECK. */
852 int yyxbegin = yyn < 0 ? -yyn : 0;
853
854 /* Stay within bounds of both yycheck and yytname. */
855 int yychecklim = YYLAST - yyn + 1;
856 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
857 /* Number of reported tokens (one for the "unexpected", one per
858 "expected"). */
859 int yycount = 0;
860 int yyx;
861
862 yyarg[yycount++] = yytname[yytoken];
863
864 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
865 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
866 {
867 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
868 {
869 yycount = 1;
870 yysize = yysize0;
871 break;
872 }
873 yyarg[yycount++] = yytname[yyx];
874 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
875 yysize_overflow |= (yysize1 < yysize);
876 yysize = yysize1;
877 }
878
879 switch (yycount)
880 {
881 #define YYCASE_(N, S) \
882 case N: \
883 yyformat = S; \
884 break
885 YYCASE_(1, YY_("syntax error, unexpected %s"));
886 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
887 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
888 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
889 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
890 #undef YYCASE_
891 }
892
893 yysize1 = yysize + yystrlen (yyformat);
894 yysize_overflow |= (yysize1 < yysize);
895 yysize = yysize1;
896
897 if (yysize_overflow)
898 return YYSIZE_MAXIMUM;
899
900 if (yyresult)
901 {
902 /* Avoid sprintf, as that infringes on the user's name space.
903 Don't have undefined behavior even if the translation
904 produced a string with the wrong number of "%s"s. */
905 char *yyp = yyresult;
906 int yyi = 0;
907 while ((*yyp = *yyformat) != '\0')
908 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
909 {
910 yyp += yytnamerr (yyp, yyarg[yyi++]);
911 yyformat += 2;
912 }
913 else
914 {
915 yyp++;
916 yyformat++;
917 }
918 }
919 return yysize;
920 }
921 }
922 #endif /* YYERROR_VERBOSE */
923 \f
924
925 ]b4_yydestruct_generate([b4_c_function_def])[
926
927 ]b4_push_if([],
928 [[/* Prevent warnings from -Wmissing-prototypes. */
929 #ifdef YYPARSE_PARAM
930 ]b4_c_function_decl([yyparse], [int],
931 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
932 #else /* ! YYPARSE_PARAM */
933 ]b4_c_function_decl([yyparse], [int], b4_parse_param)[
934 #endif /* ! YYPARSE_PARAM */]])
935
936 m4_divert_push([KILL])# ======================== M4 code.
937 # b4_declare_scanner_communication_variables
938 # ------------------------------------------
939 # Declare the variables that are global, or local to YYPARSE if
940 # pure-parser.
941 m4_define([b4_declare_scanner_communication_variables],
942 [[/* The lookahead symbol. */
943 int yychar;
944
945 /* The semantic value of the lookahead symbol. */
946 YYSTYPE yylval;
947 ]b4_locations_if([[
948 /* Location data for the lookahead symbol. */
949 YYLTYPE yylloc;
950 ]])b4_pure_if([], [[
951 /* Number of syntax errors so far. */
952 int yynerrs;
953 ]])])
954
955 # b4_declare_parser_state_variables
956 # ---------------------------------
957 # Declare all the variables that are needed to maintain the parser state
958 # between calls to yypush_parse.
959 m4_define([b4_declare_parser_state_variables],
960 [b4_pure_if([[ /* Number of syntax errors so far. */
961 int yynerrs;
962 ]])[
963 int yystate;
964 /* Number of tokens to shift before error messages enabled. */
965 int yyerrstatus;
966
967 /* The stacks and their tools:
968 `yyss': related to states.
969 `yyvs': related to semantic values.]b4_locations_if([[
970 `yyls': related to locations.]])[
971
972 Refer to the stacks thru separate pointers, to allow yyoverflow
973 to reallocate them elsewhere. */
974
975 /* The state stack. */
976 yytype_int16 yyssa[YYINITDEPTH];
977 yytype_int16 *yyss;
978 yytype_int16 *yyssp;
979
980 /* The semantic value stack. */
981 YYSTYPE yyvsa[YYINITDEPTH];
982 YYSTYPE *yyvs;
983 YYSTYPE *yyvsp;
984 ]b4_locations_if([[
985 /* The location stack. */
986 YYLTYPE yylsa[YYINITDEPTH];
987 YYLTYPE *yyls;
988 YYLTYPE *yylsp;
989
990 /* The locations where the error started and ended. */
991 YYLTYPE yyerror_range[2];
992 ]])[
993 YYSIZE_T yystacksize;
994 ]])
995
996 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
997
998 b4_pure_if([], [b4_declare_scanner_communication_variables])
999
1000 b4_push_if(
1001 [[struct yypstate
1002 {
1003 ]b4_declare_parser_state_variables[
1004 /* Used to determine if this is the first time this instance has
1005 been used. */
1006 int yynew;
1007 };]b4_pure_if([], [[
1008
1009 static char yypstate_allocated = 0;]])b4_pull_if([
1010
1011 b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
1012 {
1013 return yypull_parse (0]m4_ifset([b4_parse_param],
1014 [[, ]b4_c_args(b4_parse_param)])[);
1015 }
1016
1017 ]b4_c_function_def([[yypull_parse]], [[int]],
1018 [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1019 b4_parse_param]))[
1020 {
1021 int yystatus;
1022 yypstate *yyps_local;]b4_pure_if([[
1023 int yychar;
1024 YYSTYPE yylval;]b4_locations_if([[
1025 YYLTYPE yylloc;]])])[
1026 if (yyps == 0)
1027 {
1028 yyps_local = yypstate_new ();
1029 if (!yyps_local)
1030 {]b4_pure_if([[
1031 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
1032 if (!yypstate_allocated)
1033 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
1034 return 2;
1035 }
1036 }
1037 else
1038 yyps_local = yyps;
1039 do {
1040 yychar = YYLEX;
1041 yystatus =
1042 yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
1043 } while (yystatus == YYPUSH_MORE);
1044 if (yyps == 0)
1045 yypstate_delete (yyps_local);
1046 return yystatus;
1047 }]])[
1048
1049 /* Initialize the parser data structure. */
1050 ]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
1051 {
1052 yypstate *yyps;]b4_pure_if([], [[
1053 if (yypstate_allocated)
1054 return 0;]])[
1055 yyps = (yypstate *) malloc (sizeof *yyps);
1056 if (!yyps)
1057 return 0;
1058 yyps->yynew = 1;]b4_pure_if([], [[
1059 yypstate_allocated = 1;]])[
1060 return yyps;
1061 }
1062
1063 ]b4_c_function_def([[yypstate_delete]], [[void]],
1064 [[[yypstate *yyps]], [[yyps]]])[
1065 {
1066 #ifndef yyoverflow
1067 /* If the stack was reallocated but the parse did not complete, then the
1068 stack still needs to be freed. */
1069 if (!yyps->yynew && yyps->yyss != yyps->yyssa)
1070 YYSTACK_FREE (yyps->yyss);
1071 #endif
1072 free (yyps);]b4_pure_if([], [[
1073 yypstate_allocated = 0;]])[
1074 }
1075
1076 ]b4_pure_if([[#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs
1077 ]])[#define yystate yyps->yystate
1078 #define yyerrstatus yyps->yyerrstatus
1079 #define yyssa yyps->yyssa
1080 #define yyss yyps->yyss
1081 #define yyssp yyps->yyssp
1082 #define yyvsa yyps->yyvsa
1083 #define yyvs yyps->yyvs
1084 #define yyvsp yyps->yyvsp
1085 ]b4_locations_if([[#define yylsa yyps->yylsa
1086 #define yyls yyps->yyls
1087 #define yylsp yyps->yylsp
1088 #define yyerror_range yyps->yyerror_range
1089 ]])[#define yystacksize yyps->yystacksize
1090 ]])[
1091 /*-------------------------.
1092 | yyparse or yypush_parse. |
1093 `-------------------------*/
1094 ]b4_push_if([
1095 b4_c_function_def([[yypush_parse]], [[int]],
1096 [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
1097 [[[int yypushed_char]], [[yypushed_char]]],
1098 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1099 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1100 b4_parse_param]))], [
1101 #ifdef YYPARSE_PARAM
1102 b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])
1103 #else /* ! YYPARSE_PARAM */
1104 b4_c_function_def([yyparse], [int], b4_parse_param)
1105 #endif])[
1106 {
1107 ]b4_pure_if([b4_declare_scanner_communication_variables])
1108 b4_push_if([b4_pure_if([], [[ int yypushed_char = yychar;
1109 YYSTYPE yypushed_val = yylval;
1110 ]b4_locations_if([[YYLTYPE yypushed_loc = yylloc;
1111 ]])])],
1112 [b4_declare_parser_state_variables])[
1113 int yyn;
1114 int yyresult;
1115 /* Lookahead token as an internal (translated) token number. */
1116 int yytoken;
1117 /* The variables used to return semantic value and location from the
1118 action routines. */
1119 YYSTYPE yyval;]b4_locations_if([[
1120 YYLTYPE yyloc;]])[
1121
1122 #if YYERROR_VERBOSE
1123 /* Buffer for error messages, and its allocated size. */
1124 char yymsgbuf[128];
1125 char *yymsg = yymsgbuf;
1126 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1127 #endif
1128
1129 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
1130
1131 /* The number of symbols on the RHS of the reduced rule.
1132 Keep to zero when no symbol should be popped. */
1133 int yylen = 0;]b4_push_if([[
1134
1135 if (!yyps->yynew)
1136 {
1137 yyn = yypact[yystate];
1138 goto yyread_pushed_token;
1139 }]])[
1140
1141 yytoken = 0;
1142 yyss = yyssa;
1143 yyvs = yyvsa;]b4_locations_if([[
1144 yyls = yylsa;]])[
1145 yystacksize = YYINITDEPTH;
1146
1147 YYDPRINTF ((stderr, "Starting parse\n"));
1148
1149 yystate = 0;
1150 yyerrstatus = 0;
1151 yynerrs = 0;
1152 yychar = YYEMPTY; /* Cause a token to be read. */
1153
1154 /* Initialize stack pointers.
1155 Waste one element of value and location stack
1156 so that they stay on the same level as the state stack.
1157 The wasted elements are never initialized. */
1158 yyssp = yyss;
1159 yyvsp = yyvs;]b4_locations_if([[
1160 yylsp = yyls;
1161
1162 #if YYLTYPE_IS_TRIVIAL
1163 /* Initialize the default location before parsing starts. */
1164 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
1165 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
1166 #endif]])
1167 m4_ifdef([b4_initial_action],[
1168 m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl
1169 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
1170 /* User initialization code. */
1171 b4_user_initial_action
1172 m4_popdef([b4_dollar_dollar])dnl
1173 m4_popdef([b4_at_dollar])])dnl
1174 m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval;
1175 ]])dnl
1176 m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc;
1177 ]])[
1178 goto yysetstate;
1179
1180 /*------------------------------------------------------------.
1181 | yynewstate -- Push a new state, which is found in yystate. |
1182 `------------------------------------------------------------*/
1183 yynewstate:
1184 /* In all cases, when you get here, the value and location stacks
1185 have just been pushed. So pushing a state here evens the stacks. */
1186 yyssp++;
1187
1188 yysetstate:
1189 *yyssp = yystate;
1190
1191 if (yyss + yystacksize - 1 <= yyssp)
1192 {
1193 /* Get the current used size of the three stacks, in elements. */
1194 YYSIZE_T yysize = yyssp - yyss + 1;
1195
1196 #ifdef yyoverflow
1197 {
1198 /* Give user a chance to reallocate the stack. Use copies of
1199 these so that the &'s don't force the real ones into
1200 memory. */
1201 YYSTYPE *yyvs1 = yyvs;
1202 yytype_int16 *yyss1 = yyss;]b4_locations_if([
1203 YYLTYPE *yyls1 = yyls;])[
1204
1205 /* Each stack pointer address is followed by the size of the
1206 data in use in that stack, in bytes. This used to be a
1207 conditional around just the two extra args, but that might
1208 be undefined if yyoverflow is a macro. */
1209 yyoverflow (YY_("memory exhausted"),
1210 &yyss1, yysize * sizeof (*yyssp),
1211 &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
1212 &yyls1, yysize * sizeof (*yylsp),])[
1213 &yystacksize);
1214 ]b4_locations_if([
1215 yyls = yyls1;])[
1216 yyss = yyss1;
1217 yyvs = yyvs1;
1218 }
1219 #else /* no yyoverflow */
1220 # ifndef YYSTACK_RELOCATE
1221 goto yyexhaustedlab;
1222 # else
1223 /* Extend the stack our own way. */
1224 if (YYMAXDEPTH <= yystacksize)
1225 goto yyexhaustedlab;
1226 yystacksize *= 2;
1227 if (YYMAXDEPTH < yystacksize)
1228 yystacksize = YYMAXDEPTH;
1229
1230 {
1231 yytype_int16 *yyss1 = yyss;
1232 union yyalloc *yyptr =
1233 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1234 if (! yyptr)
1235 goto yyexhaustedlab;
1236 YYSTACK_RELOCATE (yyss_alloc, yyss);
1237 YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
1238 YYSTACK_RELOCATE (yyls_alloc, yyls);])[
1239 # undef YYSTACK_RELOCATE
1240 if (yyss1 != yyssa)
1241 YYSTACK_FREE (yyss1);
1242 }
1243 # endif
1244 #endif /* no yyoverflow */
1245
1246 yyssp = yyss + yysize - 1;
1247 yyvsp = yyvs + yysize - 1;]b4_locations_if([
1248 yylsp = yyls + yysize - 1;])[
1249
1250 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1251 (unsigned long int) yystacksize));
1252
1253 if (yyss + yystacksize - 1 <= yyssp)
1254 YYABORT;
1255 }
1256
1257 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1258
1259 if (yystate == YYFINAL)
1260 YYACCEPT;
1261
1262 goto yybackup;
1263
1264 /*-----------.
1265 | yybackup. |
1266 `-----------*/
1267 yybackup:
1268
1269 /* Do appropriate processing given the current state. Read a
1270 lookahead token if we need one and don't already have one. */
1271
1272 /* First try to decide what to do without reference to lookahead token. */
1273 yyn = yypact[yystate];
1274 if (yyn == YYPACT_NINF)
1275 goto yydefault;
1276
1277 /* Not known => get a lookahead token if don't already have one. */
1278
1279 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1280 if (yychar == YYEMPTY)
1281 {]b4_push_if([[
1282 if (!yyps->yynew)
1283 {]b4_use_push_for_pull_if([], [[
1284 YYDPRINTF ((stderr, "Return for a new token:\n"));]])[
1285 yyresult = YYPUSH_MORE;
1286 goto yypushreturn;
1287 }
1288 yyps->yynew = 0;]b4_pure_if([], [[
1289 /* Restoring the pushed token is only necessary for the first
1290 yypush_parse invocation since subsequent invocations don't overwrite
1291 it before jumping to yyread_pushed_token. */
1292 yychar = yypushed_char;
1293 yylval = yypushed_val;]b4_locations_if([[
1294 yylloc = yypushed_loc;]])])[
1295 yyread_pushed_token:]])[
1296 YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[
1297 yychar = yypushed_char;
1298 if (yypushed_val)
1299 yylval = *yypushed_val;]b4_locations_if([[
1300 if (yypushed_loc)
1301 yylloc = *yypushed_loc;]])])], [[
1302 yychar = YYLEX;]])[
1303 }
1304
1305 if (yychar <= YYEOF)
1306 {
1307 yychar = yytoken = YYEOF;
1308 YYDPRINTF ((stderr, "Now at end of input.\n"));
1309 }
1310 else
1311 {
1312 yytoken = YYTRANSLATE (yychar);
1313 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1314 }
1315
1316 /* If the proper action on seeing token YYTOKEN is to reduce or to
1317 detect an error, take that action. */
1318 yyn += yytoken;
1319 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1320 goto yydefault;
1321 yyn = yytable[yyn];
1322 if (yyn <= 0)
1323 {
1324 if (yyn == 0 || yyn == YYTABLE_NINF)
1325 goto yyerrlab;
1326 yyn = -yyn;
1327 goto yyreduce;
1328 }
1329
1330 /* Count tokens shifted since error; after three, turn off error
1331 status. */
1332 if (yyerrstatus)
1333 yyerrstatus--;
1334
1335 /* Shift the lookahead token. */
1336 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1337
1338 /* Discard the shifted token. */
1339 yychar = YYEMPTY;
1340
1341 yystate = yyn;
1342 *++yyvsp = yylval;
1343 ]b4_locations_if([ *++yylsp = yylloc;])[
1344 goto yynewstate;
1345
1346
1347 /*-----------------------------------------------------------.
1348 | yydefault -- do the default action for the current state. |
1349 `-----------------------------------------------------------*/
1350 yydefault:
1351 yyn = yydefact[yystate];
1352 if (yyn == 0)
1353 goto yyerrlab;
1354 goto yyreduce;
1355
1356
1357 /*-----------------------------.
1358 | yyreduce -- Do a reduction. |
1359 `-----------------------------*/
1360 yyreduce:
1361 /* yyn is the number of a rule to reduce with. */
1362 yylen = yyr2[yyn];
1363
1364 /* If YYLEN is nonzero, implement the default value of the action:
1365 `$$ = $1'.
1366
1367 Otherwise, the following line sets YYVAL to garbage.
1368 This behavior is undocumented and Bison
1369 users should not rely upon it. Assigning to YYVAL
1370 unconditionally makes the parser a bit smaller, and it avoids a
1371 GCC warning that YYVAL may be used uninitialized. */
1372 yyval = yyvsp[1-yylen];
1373
1374 ]b4_locations_if(
1375 [[ /* Default location. */
1376 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
1377 YY_REDUCE_PRINT (yyn);
1378 switch (yyn)
1379 {
1380 ]b4_user_actions[
1381 default: break;
1382 }
1383 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1384
1385 YYPOPSTACK (yylen);
1386 yylen = 0;
1387 YY_STACK_PRINT (yyss, yyssp);
1388
1389 *++yyvsp = yyval;]b4_locations_if([
1390 *++yylsp = yyloc;])[
1391
1392 /* Now `shift' the result of the reduction. Determine what state
1393 that goes to, based on the state we popped back to and the rule
1394 number reduced by. */
1395
1396 yyn = yyr1[yyn];
1397
1398 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1399 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1400 yystate = yytable[yystate];
1401 else
1402 yystate = yydefgoto[yyn - YYNTOKENS];
1403
1404 goto yynewstate;
1405
1406
1407 /*------------------------------------.
1408 | yyerrlab -- here on detecting error |
1409 `------------------------------------*/
1410 yyerrlab:
1411 /* If not already recovering from an error, report this error. */
1412 if (!yyerrstatus)
1413 {
1414 ++yynerrs;
1415 #if ! YYERROR_VERBOSE
1416 yyerror (]b4_yyerror_args[YY_("syntax error"));
1417 #else
1418 {
1419 YYSIZE_T yysize = yysyntax_error (0, yystate, yytoken);
1420 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1421 {
1422 YYSIZE_T yyalloc = 2 * yysize;
1423 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1424 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1425 if (yymsg != yymsgbuf)
1426 YYSTACK_FREE (yymsg);
1427 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1428 if (yymsg)
1429 yymsg_alloc = yyalloc;
1430 else
1431 {
1432 yymsg = yymsgbuf;
1433 yymsg_alloc = sizeof yymsgbuf;
1434 }
1435 }
1436
1437 if (0 < yysize && yysize <= yymsg_alloc)
1438 {
1439 (void) yysyntax_error (yymsg, yystate, yytoken);
1440 yyerror (]b4_yyerror_args[yymsg);
1441 }
1442 else
1443 {
1444 yyerror (]b4_yyerror_args[YY_("syntax error"));
1445 if (yysize != 0)
1446 goto yyexhaustedlab;
1447 }
1448 }
1449 #endif
1450 }
1451
1452 ]b4_locations_if([[ yyerror_range[0] = yylloc;]])[
1453
1454 if (yyerrstatus == 3)
1455 {
1456 /* If just tried and failed to reuse lookahead token after an
1457 error, discard it. */
1458
1459 if (yychar <= YYEOF)
1460 {
1461 /* Return failure if at end of input. */
1462 if (yychar == YYEOF)
1463 YYABORT;
1464 }
1465 else
1466 {
1467 yydestruct ("Error: discarding",
1468 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1469 yychar = YYEMPTY;
1470 }
1471 }
1472
1473 /* Else will try to reuse lookahead token after shifting the error
1474 token. */
1475 goto yyerrlab1;
1476
1477
1478 /*---------------------------------------------------.
1479 | yyerrorlab -- error raised explicitly by YYERROR. |
1480 `---------------------------------------------------*/
1481 yyerrorlab:
1482
1483 /* Pacify compilers like GCC when the user code never invokes
1484 YYERROR and the label yyerrorlab therefore never appears in user
1485 code. */
1486 if (/*CONSTCOND*/ 0)
1487 goto yyerrorlab;
1488
1489 ]b4_locations_if([[ yyerror_range[0] = yylsp[1-yylen];
1490 ]])[ /* Do not reclaim the symbols of the rule which action triggered
1491 this YYERROR. */
1492 YYPOPSTACK (yylen);
1493 yylen = 0;
1494 YY_STACK_PRINT (yyss, yyssp);
1495 yystate = *yyssp;
1496 goto yyerrlab1;
1497
1498
1499 /*-------------------------------------------------------------.
1500 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1501 `-------------------------------------------------------------*/
1502 yyerrlab1:
1503 yyerrstatus = 3; /* Each real token shifted decrements this. */
1504
1505 for (;;)
1506 {
1507 yyn = yypact[yystate];
1508 if (yyn != YYPACT_NINF)
1509 {
1510 yyn += YYTERROR;
1511 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1512 {
1513 yyn = yytable[yyn];
1514 if (0 < yyn)
1515 break;
1516 }
1517 }
1518
1519 /* Pop the current state because it cannot handle the error token. */
1520 if (yyssp == yyss)
1521 YYABORT;
1522
1523 ]b4_locations_if([[ yyerror_range[0] = *yylsp;]])[
1524 yydestruct ("Error: popping",
1525 yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1526 YYPOPSTACK (1);
1527 yystate = *yyssp;
1528 YY_STACK_PRINT (yyss, yyssp);
1529 }
1530
1531 *++yyvsp = yylval;
1532 ]b4_locations_if([[
1533 yyerror_range[1] = yylloc;
1534 /* Using YYLLOC is tempting, but would change the location of
1535 the lookahead. YYLOC is available though. */
1536 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
1537 *++yylsp = yyloc;]])[
1538
1539 /* Shift the error token. */
1540 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1541
1542 yystate = yyn;
1543 goto yynewstate;
1544
1545
1546 /*-------------------------------------.
1547 | yyacceptlab -- YYACCEPT comes here. |
1548 `-------------------------------------*/
1549 yyacceptlab:
1550 yyresult = 0;
1551 goto yyreturn;
1552
1553 /*-----------------------------------.
1554 | yyabortlab -- YYABORT comes here. |
1555 `-----------------------------------*/
1556 yyabortlab:
1557 yyresult = 1;
1558 goto yyreturn;
1559
1560 #if !defined(yyoverflow) || YYERROR_VERBOSE
1561 /*-------------------------------------------------.
1562 | yyexhaustedlab -- memory exhaustion comes here. |
1563 `-------------------------------------------------*/
1564 yyexhaustedlab:
1565 yyerror (]b4_yyerror_args[YY_("memory exhausted"));
1566 yyresult = 2;
1567 /* Fall through. */
1568 #endif
1569
1570 yyreturn:
1571 if (yychar != YYEMPTY)
1572 yydestruct ("Cleanup: discarding lookahead",
1573 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1574 /* Do not reclaim the symbols of the rule which action triggered
1575 this YYABORT or YYACCEPT. */
1576 YYPOPSTACK (yylen);
1577 YY_STACK_PRINT (yyss, yyssp);
1578 while (yyssp != yyss)
1579 {
1580 yydestruct ("Cleanup: popping",
1581 yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1582 YYPOPSTACK (1);
1583 }
1584 #ifndef yyoverflow
1585 if (yyss != yyssa)
1586 YYSTACK_FREE (yyss);
1587 #endif
1588 ]b4_push_if([[ yyps->yynew = 1;
1589
1590 yypushreturn:
1591 ]])[#if YYERROR_VERBOSE
1592 if (yymsg != yymsgbuf)
1593 YYSTACK_FREE (yymsg);
1594 #endif
1595 /* Make sure YYID is used. */
1596 return YYID (yyresult);
1597 }
1598
1599 ]b4_epilogue[]dnl
1600 b4_defines_if(
1601 [@output(b4_spec_defines_file@)@
1602 b4_copyright([Interface for Bison's Yacc-like parsers in C])dnl'
1603
1604 b4_percent_code_get([[requires]])[]dnl
1605
1606 b4_token_enums_defines(b4_tokens)
1607
1608 [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1609 ]m4_ifdef([b4_stype],
1610 [[typedef union ]b4_union_name[
1611 {
1612 ]b4_user_stype[
1613 } YYSTYPE;
1614 # define YYSTYPE_IS_TRIVIAL 1]],
1615 [m4_if(b4_tag_seen_flag, 0,
1616 [[typedef int YYSTYPE;
1617 # define YYSTYPE_IS_TRIVIAL 1]])])[
1618 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1619 # define YYSTYPE_IS_DECLARED 1
1620 #endif
1621
1622 ]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;]])
1623
1624 b4_locations_if(
1625 [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
1626 typedef struct YYLTYPE
1627 {
1628 int first_line;
1629 int first_column;
1630 int last_line;
1631 int last_column;
1632 } YYLTYPE;
1633 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1634 # define YYLTYPE_IS_DECLARED 1
1635 # define YYLTYPE_IS_TRIVIAL 1
1636 #endif
1637
1638 ]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]])
1639 )dnl b4_locations_if
1640 b4_push_if([[
1641 #ifndef YYPUSH_DECLS
1642 # define YYPUSH_DECLS
1643 struct ]b4_prefix[pstate;
1644 typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
1645 enum { YYPUSH_MORE = 4 };
1646 ]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
1647 ])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
1648 [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([,
1649 [[[int yypushed_char]], [[yypushed_char]]],
1650 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1651 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1652 b4_parse_param]))
1653 b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
1654 [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1655 b4_parse_param]))])
1656 b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
1657 [[[void]], []])
1658 b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
1659 [[b4_prefix[pstate *yyps]], [[yyps]]])[
1660 #endif
1661 ]])
1662 b4_percent_code_get([[provides]])[]dnl
1663 ])dnl b4_defines_if
1664 m4_divert_pop(0)
1665 m4_popdef([b4_copyright_years])
bison