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