]> 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
Use b4_parser_tables_define in Java.
[bison.git] / data / yacc.c
1 -*- C -*-
2 # Yacc compatible skeleton for Bison
3
4 # Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006,
5 # 2007, 2008 Free Software Foundation, Inc.
6
7 m4_pushdef([b4_copyright_years],
8 [1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008])
9
10 # This program is free software: you can redistribute it and/or modify
11 # it under the terms of the GNU General Public License as published by
12 # the Free Software Foundation, either version 3 of the License, or
13 # (at your option) any later version.
14 #
15 # This program is distributed in the hope that it will be useful,
16 # but WITHOUT ANY WARRANTY; without even the implied warranty of
17 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 # GNU General Public License for more details.
19 #
20 # You should have received a copy of the GNU General Public License
21 # along with this program. If not, see <http://www.gnu.org/licenses/>.
22
23 # Check the value of %define api.push_pull.
24 b4_percent_define_default([[api.push_pull]], [[pull]])
25 b4_percent_define_check_values([[[[api.push_pull]],
26 [[pull]], [[push]], [[both]]]])
27 b4_define_flag_if([pull]) m4_define([b4_pull_flag], [[1]])
28 b4_define_flag_if([push]) m4_define([b4_push_flag], [[1]])
29 m4_case(b4_percent_define_get([[api.push_pull]]),
30 [pull], [m4_define([b4_push_flag], [[0]])],
31 [push], [m4_define([b4_pull_flag], [[0]])])
32
33 # Handle BISON_USE_PUSH_FOR_PULL for the test suite. So that push parsing
34 # tests function as written, don't let BISON_USE_PUSH_FOR_PULL modify Bison's
35 # behavior at all when push parsing is already requested.
36 b4_define_flag_if([use_push_for_pull])
37 b4_use_push_for_pull_if([
38 b4_push_if([m4_define([b4_use_push_for_pull_flag], [[0]])],
39 [m4_define([b4_push_flag], [[1]])])])
40
41 m4_include(b4_pkgdatadir/[c.m4])
42
43 ## ---------------- ##
44 ## Default values. ##
45 ## ---------------- ##
46
47 # Stack parameters.
48 m4_define_default([b4_stack_depth_max], [10000])
49 m4_define_default([b4_stack_depth_init], [200])
50
51
52 ## ------------------------ ##
53 ## Pure/impure interfaces. ##
54 ## ------------------------ ##
55
56 b4_percent_define_default([[api.pure]], [[false]])
57 b4_define_flag_if([pure])
58 m4_define([b4_pure_flag],
59 [b4_percent_define_flag_if([[api.pure]], [[1]], [[0]])])
60
61 # b4_yacc_pure_if(IF-TRUE, IF-FALSE)
62 # ----------------------------------
63 # Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise.
64 m4_define([b4_yacc_pure_if],
65 [b4_pure_if([m4_ifset([b4_parse_param],
66 [$1], [$2])],
67 [$2])])
68
69
70 # b4_yyerror_args
71 # ---------------
72 # Arguments passed to yyerror: user args plus yylloc.
73 m4_define([b4_yyerror_args],
74 [b4_yacc_pure_if([b4_locations_if([&yylloc, ])])dnl
75 m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])])
76
77
78 # b4_lex_param
79 # ------------
80 # Accumulate in b4_lex_param all the yylex arguments.
81 # b4_lex_param arrives quoted twice, but we want to keep only one level.
82 m4_define([b4_lex_param],
83 m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl
84 b4_locations_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl
85 m4_ifdef([b4_lex_param], b4_lex_param)))
86
87
88 ## ------------ ##
89 ## Data Types. ##
90 ## ------------ ##
91
92 # b4_int_type(MIN, MAX)
93 # ---------------------
94 # Return the smallest int type able to handle numbers ranging from
95 # MIN to MAX (included). Overwrite the version from c.m4, which
96 # uses only C89 types, so that the user can override the shorter
97 # types, and so that pre-C89 compilers are handled correctly.
98 m4_define([b4_int_type],
99 [m4_if(b4_ints_in($@, [0], [255]), [1], [yytype_uint8],
100 b4_ints_in($@, [-128], [127]), [1], [yytype_int8],
101
102 b4_ints_in($@, [0], [65535]), [1], [yytype_uint16],
103 b4_ints_in($@, [-32768], [32767]), [1], [yytype_int16],
104
105 m4_eval([0 <= $1]), [1], [unsigned int],
106
107 [int])])
108
109
110 ## ----------------- ##
111 ## Semantic Values. ##
112 ## ----------------- ##
113
114
115 # b4_lhs_value([TYPE])
116 # --------------------
117 # Expansion of $<TYPE>$.
118 m4_define([b4_lhs_value],
119 [b4_symbol_value(yyval, [$1])])
120
121
122 # b4_rhs_value(RULE-LENGTH, NUM, [TYPE])
123 # --------------------------------------
124 # Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH
125 # symbols on RHS.
126 m4_define([b4_rhs_value],
127 [b4_symbol_value([yyvsp@{b4_subtract([$2], [$1])@}], [$3])])
128
129
130
131 ## ----------- ##
132 ## Locations. ##
133 ## ----------- ##
134
135 # b4_lhs_location()
136 # -----------------
137 # Expansion of @$.
138 m4_define([b4_lhs_location],
139 [(yyloc)])
140
141
142 # b4_rhs_location(RULE-LENGTH, NUM)
143 # ---------------------------------
144 # Expansion of @NUM, where the current rule has RULE-LENGTH symbols
145 # on RHS.
146 m4_define([b4_rhs_location],
147 [(yylsp@{b4_subtract([$2], [$1])@})])
148
149
150
151 ## --------------------------------------------------------- ##
152 ## Defining symbol actions, e.g., printers and destructors. ##
153 ## --------------------------------------------------------- ##
154
155 # We do want M4 expansion after # for CPP macros.
156 m4_changecom()
157 m4_divert_push(0)dnl
158 @output(b4_parser_file_name@)@
159 b4_copyright([Implementation for Bison's Yacc-like parsers in C])dnl'
160 [
161
162 /* C LALR(1) parser skeleton written by Richard Stallman, by
163 simplifying the original so-called "semantic" parser. */
164
165 /* All symbols defined below should begin with yy or YY, to avoid
166 infringing on user name space. This should be done even for local
167 variables, as they might otherwise be expanded by user macros.
168 There are some unavoidable exceptions within include files to
169 define necessary library symbols; they are noted "INFRINGES ON
170 USER NAME SPACE" below. */
171
172 ]b4_identification
173 b4_percent_code_get([[top]])[]dnl
174 m4_if(b4_prefix, [yy], [],
175 [[/* Substitute the variable and function names. */
176 ]b4_pull_if([[#define yyparse ]b4_prefix[parse
177 ]])b4_push_if([[#define yypush_parse ]b4_prefix[push_parse
178 ]b4_pull_if([[#define yypull_parse ]b4_prefix[pull_parse
179 ]])[#define yypstate_new ]b4_prefix[pstate_new
180 #define yypstate_delete ]b4_prefix[pstate_delete
181 #define yypstate ]b4_prefix[pstate
182 ]])[#define yylex ]b4_prefix[lex
183 #define yyerror ]b4_prefix[error
184 #define yylval ]b4_prefix[lval
185 #define yychar ]b4_prefix[char
186 #define yydebug ]b4_prefix[debug
187 #define yynerrs ]b4_prefix[nerrs
188 ]b4_locations_if([[#define yylloc ]b4_prefix[lloc]])])[
189
190 /* Copy the first part of user declarations. */
191 ]b4_user_pre_prologue[
192
193 /* Enabling traces. */
194 #ifndef YYDEBUG
195 # define YYDEBUG ]b4_debug_flag[
196 #endif
197
198 /* Enabling verbose error messages. */
199 #ifdef YYERROR_VERBOSE
200 # undef YYERROR_VERBOSE
201 # define YYERROR_VERBOSE 1
202 #else
203 # define YYERROR_VERBOSE ]b4_error_verbose_flag[
204 #endif
205
206 /* Enabling the token table. */
207 #ifndef YYTOKEN_TABLE
208 # define YYTOKEN_TABLE ]b4_token_table[
209 #endif
210
211 ]b4_percent_code_get([[requires]])[]dnl
212
213 b4_token_enums_defines(b4_tokens)[
214
215 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
216 ]m4_ifdef([b4_stype],
217 [[typedef union ]b4_union_name[
218 {
219 ]b4_user_stype[
220 } YYSTYPE;
221 # define YYSTYPE_IS_TRIVIAL 1]],
222 [m4_if(b4_tag_seen_flag, 0,
223 [[typedef int YYSTYPE;
224 # define YYSTYPE_IS_TRIVIAL 1]])])[
225 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
226 # define YYSTYPE_IS_DECLARED 1
227 #endif]b4_locations_if([[
228
229 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
230 typedef struct YYLTYPE
231 {
232 int first_line;
233 int first_column;
234 int last_line;
235 int last_column;
236 } YYLTYPE;
237 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
238 # define YYLTYPE_IS_DECLARED 1
239 # define YYLTYPE_IS_TRIVIAL 1
240 #endif]])b4_push_if([[
241
242 #ifndef YYPUSH_DECLS
243 # define YYPUSH_DECLS
244 struct yypstate;
245 typedef struct yypstate yypstate;
246 enum { YYPUSH_MORE = 4 };
247
248 ]b4_pull_if([b4_c_function_decl([[yyparse]], [[int]], b4_parse_param)
249 ])b4_c_function_decl([[yypush_parse]], [[int]],
250 [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
251 [[[int yypushed_char]], [[yypushed_char]]],
252 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
253 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
254 b4_parse_param]))
255 b4_pull_if([b4_c_function_decl([[yypull_parse]], [[int]],
256 [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
257 b4_parse_param]))])
258 b4_c_function_decl([[yypstate_new]], [[yypstate *]], [[[void]], []])
259 b4_c_function_decl([[yypstate_delete]], [[void]],
260 [[[yypstate *yyps]], [[yyps]]])[
261 #endif]])
262
263 b4_percent_code_get([[provides]])[]dnl
264
265 [/* Copy the second part of user declarations. */
266 ]b4_user_post_prologue
267 b4_percent_code_get[]dnl
268
269 [#ifdef short
270 # undef short
271 #endif
272
273 #ifdef YYTYPE_UINT8
274 typedef YYTYPE_UINT8 yytype_uint8;
275 #else
276 typedef unsigned char yytype_uint8;
277 #endif
278
279 #ifdef YYTYPE_INT8
280 typedef YYTYPE_INT8 yytype_int8;
281 #elif ]b4_c_modern[
282 typedef signed char yytype_int8;
283 #else
284 typedef short int yytype_int8;
285 #endif
286
287 #ifdef YYTYPE_UINT16
288 typedef YYTYPE_UINT16 yytype_uint16;
289 #else
290 typedef unsigned short int yytype_uint16;
291 #endif
292
293 #ifdef YYTYPE_INT16
294 typedef YYTYPE_INT16 yytype_int16;
295 #else
296 typedef short int yytype_int16;
297 #endif
298
299 #ifndef YYSIZE_T
300 # ifdef __SIZE_TYPE__
301 # define YYSIZE_T __SIZE_TYPE__
302 # elif defined size_t
303 # define YYSIZE_T size_t
304 # elif ! defined YYSIZE_T && ]b4_c_modern[
305 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
306 # define YYSIZE_T size_t
307 # else
308 # define YYSIZE_T unsigned int
309 # endif
310 #endif
311
312 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
313
314 #ifndef YY_
315 # if YYENABLE_NLS
316 # if ENABLE_NLS
317 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
318 # define YY_(msgid) dgettext ("bison-runtime", msgid)
319 # endif
320 # endif
321 # ifndef YY_
322 # define YY_(msgid) msgid
323 # endif
324 #endif
325
326 /* Suppress unused-variable warnings by "using" E. */
327 #if ! defined lint || defined __GNUC__
328 # define YYUSE(e) ((void) (e))
329 #else
330 # define YYUSE(e) /* empty */
331 #endif
332
333 /* Identity function, used to suppress warnings about constant conditions. */
334 #ifndef lint
335 # define YYID(n) (n)
336 #else
337 ]b4_c_function_def([YYID], [static int], [[int yyi], [yyi]])[
338 {
339 return yyi;
340 }
341 #endif
342
343 #if ! defined yyoverflow || YYERROR_VERBOSE
344
345 ]b4_push_if([],
346 [[/* The parser invokes alloca or malloc; define the necessary symbols. */
347
348 # ifdef YYSTACK_USE_ALLOCA
349 # if YYSTACK_USE_ALLOCA
350 # ifdef __GNUC__
351 # define YYSTACK_ALLOC __builtin_alloca
352 # elif defined __BUILTIN_VA_ARG_INCR
353 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
354 # elif defined _AIX
355 # define YYSTACK_ALLOC __alloca
356 # elif defined _MSC_VER
357 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
358 # define alloca _alloca
359 # else
360 # define YYSTACK_ALLOC alloca
361 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && ]b4_c_modern[
362 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
363 # ifndef _STDLIB_H
364 # define _STDLIB_H 1
365 # endif
366 # endif
367 # endif
368 # endif
369 # endif
370
371 ]])dnl
372 [# ifdef YYSTACK_ALLOC
373 /* Pacify GCC's `empty if-body' warning. */
374 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
375 # ifndef YYSTACK_ALLOC_MAXIMUM
376 /* The OS might guarantee only one guard page at the bottom of the stack,
377 and a page size can be as small as 4096 bytes. So we cannot safely
378 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
379 to allow for a few compiler-allocated temporary stack slots. */
380 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
381 # endif
382 # else
383 # define YYSTACK_ALLOC YYMALLOC
384 # define YYSTACK_FREE YYFREE
385 # ifndef YYSTACK_ALLOC_MAXIMUM
386 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
387 # endif
388 # if (defined __cplusplus && ! defined _STDLIB_H \
389 && ! ((defined YYMALLOC || defined malloc) \
390 && (defined YYFREE || defined free)))
391 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
392 # ifndef _STDLIB_H
393 # define _STDLIB_H 1
394 # endif
395 # endif
396 # ifndef YYMALLOC
397 # define YYMALLOC malloc
398 # if ! defined malloc && ! defined _STDLIB_H && ]b4_c_modern[
399 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
400 # endif
401 # endif
402 # ifndef YYFREE
403 # define YYFREE free
404 # if ! defined free && ! defined _STDLIB_H && ]b4_c_modern[
405 void free (void *); /* INFRINGES ON USER NAME SPACE */
406 # endif
407 # endif
408 # endif
409 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
410
411
412 #if (! defined yyoverflow \
413 && (! defined __cplusplus \
414 || (]b4_locations_if([[defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
415 && ]])[defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
416
417 /* A type that is properly aligned for any stack member. */
418 union yyalloc
419 {
420 yytype_int16 yyss_alloc;
421 YYSTYPE yyvs_alloc;]b4_locations_if([
422 YYLTYPE yyls_alloc;])[
423 };
424
425 /* The size of the maximum gap between one aligned stack and the next. */
426 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
427
428 /* The size of an array large to enough to hold all stacks, each with
429 N elements. */
430 ]b4_locations_if(
431 [# define YYSTACK_BYTES(N) \
432 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
433 + 2 * YYSTACK_GAP_MAXIMUM)],
434 [# define YYSTACK_BYTES(N) \
435 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
436 + YYSTACK_GAP_MAXIMUM)])[
437
438 /* Copy COUNT objects from FROM to TO. The source and destination do
439 not overlap. */
440 # ifndef YYCOPY
441 # if defined __GNUC__ && 1 < __GNUC__
442 # define YYCOPY(To, From, Count) \
443 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
444 # else
445 # define YYCOPY(To, From, Count) \
446 do \
447 { \
448 YYSIZE_T yyi; \
449 for (yyi = 0; yyi < (Count); yyi++) \
450 (To)[yyi] = (From)[yyi]; \
451 } \
452 while (YYID (0))
453 # endif
454 # endif
455
456 /* Relocate STACK from its old location to the new one. The
457 local variables YYSIZE and YYSTACKSIZE give the old and new number of
458 elements in the stack, and YYPTR gives the new location of the
459 stack. Advance YYPTR to a properly aligned location for the next
460 stack. */
461 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
462 do \
463 { \
464 YYSIZE_T yynewbytes; \
465 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
466 Stack = &yyptr->Stack_alloc; \
467 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
468 yyptr += yynewbytes / sizeof (*yyptr); \
469 } \
470 while (YYID (0))
471
472 #endif
473
474 /* YYFINAL -- State number of the termination state. */
475 #define YYFINAL ]b4_final_state_number[
476 /* YYLAST -- Last index in YYTABLE. */
477 #define YYLAST ]b4_last[
478
479 /* YYNTOKENS -- Number of terminals. */
480 #define YYNTOKENS ]b4_tokens_number[
481 /* YYNNTS -- Number of nonterminals. */
482 #define YYNNTS ]b4_nterms_number[
483 /* YYNRULES -- Number of rules. */
484 #define YYNRULES ]b4_rules_number[
485 /* YYNSTATES -- Number of states. */
486 #define YYNSTATES ]b4_states_number[
487
488 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
489 by yylex, with out-of-bounds checking. */
490 #define YYUNDEFTOK ]b4_undef_token_number[
491 #define YYMAXUTOK ]b4_user_token_number_max[
492
493 #define YYTRANSLATE(YYX) \
494 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
495
496 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
497 as returned by yylex, without out-of-bounds checking. */
498 static const ]b4_int_type_for([b4_translate])[ yytranslate[] =
499 {
500 ]b4_translate[
501 };
502
503 #if YYDEBUG
504 ]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 YYCHAR 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 yychar)
833 {
834 int yyn = yypact[yystate];
835
836 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
837 return 0;
838 else
839 {
840 int yytype = YYTRANSLATE (yychar);
841 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
842 YYSIZE_T yysize = yysize0;
843 YYSIZE_T yysize1;
844 int yysize_overflow = 0;
845 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
846 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
847 int yyx;
848
849 # if 0
850 /* This is so xgettext sees the translatable formats that are
851 constructed on the fly. */
852 YY_("syntax error, unexpected %s");
853 YY_("syntax error, unexpected %s, expecting %s");
854 YY_("syntax error, unexpected %s, expecting %s or %s");
855 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
856 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
857 # endif
858 char *yyfmt;
859 char const *yyf;
860 static char const yyunexpected[] = "syntax error, unexpected %s";
861 static char const yyexpecting[] = ", expecting %s";
862 static char const yyor[] = " or %s";
863 char yyformat[sizeof yyunexpected
864 + sizeof yyexpecting - 1
865 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
866 * (sizeof yyor - 1))];
867 char const *yyprefix = yyexpecting;
868
869 /* Start YYX at -YYN if negative to avoid negative indexes in
870 YYCHECK. */
871 int yyxbegin = yyn < 0 ? -yyn : 0;
872
873 /* Stay within bounds of both yycheck and yytname. */
874 int yychecklim = YYLAST - yyn + 1;
875 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
876 int yycount = 1;
877
878 yyarg[0] = yytname[yytype];
879 yyfmt = yystpcpy (yyformat, yyunexpected);
880
881 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
882 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
883 {
884 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
885 {
886 yycount = 1;
887 yysize = yysize0;
888 yyformat[sizeof yyunexpected - 1] = '\0';
889 break;
890 }
891 yyarg[yycount++] = yytname[yyx];
892 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
893 yysize_overflow |= (yysize1 < yysize);
894 yysize = yysize1;
895 yyfmt = yystpcpy (yyfmt, yyprefix);
896 yyprefix = yyor;
897 }
898
899 yyf = YY_(yyformat);
900 yysize1 = yysize + yystrlen (yyf);
901 yysize_overflow |= (yysize1 < yysize);
902 yysize = yysize1;
903
904 if (yysize_overflow)
905 return YYSIZE_MAXIMUM;
906
907 if (yyresult)
908 {
909 /* Avoid sprintf, as that infringes on the user's name space.
910 Don't have undefined behavior even if the translation
911 produced a string with the wrong number of "%s"s. */
912 char *yyp = yyresult;
913 int yyi = 0;
914 while ((*yyp = *yyf) != '\0')
915 {
916 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
917 {
918 yyp += yytnamerr (yyp, yyarg[yyi++]);
919 yyf += 2;
920 }
921 else
922 {
923 yyp++;
924 yyf++;
925 }
926 }
927 }
928 return yysize;
929 }
930 }
931 #endif /* YYERROR_VERBOSE */
932 \f
933
934 ]b4_yydestruct_generate([b4_c_function_def])[
935
936 ]b4_push_if([],
937 [[/* Prevent warnings from -Wmissing-prototypes. */
938 #ifdef YYPARSE_PARAM
939 ]b4_c_function_decl([yyparse], [int],
940 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
941 #else /* ! YYPARSE_PARAM */
942 ]b4_c_function_decl([yyparse], [int], b4_parse_param)[
943 #endif /* ! YYPARSE_PARAM */]])
944
945 m4_divert_push([KILL])# ======================== M4 code.
946 # b4_declare_scanner_communication_variables
947 # ------------------------------------------
948 # Declare the variables that are global, or local to YYPARSE if
949 # pure-parser.
950 m4_define([b4_declare_scanner_communication_variables],
951 [[/* The lookahead symbol. */
952 int yychar;
953
954 /* The semantic value of the lookahead symbol. */
955 YYSTYPE yylval;
956 ]b4_locations_if([[
957 /* Location data for the lookahead symbol. */
958 YYLTYPE yylloc;
959 ]])b4_pure_if([], [[
960 /* Number of syntax errors so far. */
961 int yynerrs;
962 ]])])
963
964 # b4_declare_parser_state_variables
965 # ---------------------------------
966 # Declare all the variables that are needed to maintain the parser state
967 # between calls to yypush_parse.
968 m4_define([b4_declare_parser_state_variables],
969 [b4_pure_if([[ /* Number of syntax errors so far. */
970 int yynerrs;
971 ]])[
972 int yystate;
973 /* Number of tokens to shift before error messages enabled. */
974 int yyerrstatus;
975
976 /* The stacks and their tools:
977 `yyss': related to states.
978 `yyvs': related to semantic values.]b4_locations_if([[
979 `yyls': related to locations.]])[
980
981 Refer to the stacks thru separate pointers, to allow yyoverflow
982 to reallocate them elsewhere. */
983
984 /* The state stack. */
985 yytype_int16 yyssa[YYINITDEPTH];
986 yytype_int16 *yyss;
987 yytype_int16 *yyssp;
988
989 /* The semantic value stack. */
990 YYSTYPE yyvsa[YYINITDEPTH];
991 YYSTYPE *yyvs;
992 YYSTYPE *yyvsp;
993 ]b4_locations_if([[
994 /* The location stack. */
995 YYLTYPE yylsa[YYINITDEPTH];
996 YYLTYPE *yyls;
997 YYLTYPE *yylsp;
998
999 /* The locations where the error started and ended. */
1000 YYLTYPE yyerror_range[2];
1001 ]])[
1002 YYSIZE_T yystacksize;
1003 ]])
1004
1005 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
1006
1007 b4_pure_if([], [b4_declare_scanner_communication_variables])
1008
1009 b4_push_if(
1010 [[struct yypstate
1011 {
1012 ]b4_declare_parser_state_variables[
1013 /* Used to determine if this is the first time this instance has
1014 been used. */
1015 int yynew;
1016 };]b4_pure_if([], [[
1017
1018 static char yypstate_allocated = 0;]])b4_pull_if([
1019
1020 b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
1021 {
1022 return yypull_parse (0]m4_ifset([b4_parse_param],
1023 [[, ]b4_c_args(b4_parse_param)])[);
1024 }
1025
1026 ]b4_c_function_def([[yypull_parse]], [[int]],
1027 [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1028 b4_parse_param]))[
1029 {
1030 int yystatus;
1031 yypstate *yyps_local;]b4_pure_if([[
1032 int yychar;
1033 YYSTYPE yylval;]b4_locations_if([[
1034 YYLTYPE yylloc;]])])[
1035 if (yyps == 0)
1036 {
1037 yyps_local = yypstate_new ();
1038 if (!yyps_local)
1039 {]b4_pure_if([[
1040 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
1041 if (!yypstate_allocated)
1042 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
1043 return 2;
1044 }
1045 }
1046 else
1047 yyps_local = yyps;
1048 do {
1049 yychar = YYLEX;
1050 yystatus =
1051 yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
1052 } while (yystatus == YYPUSH_MORE);
1053 if (yyps == 0)
1054 yypstate_delete (yyps_local);
1055 return yystatus;
1056 }]])[
1057
1058 /* Initialize the parser data structure. */
1059 ]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
1060 {
1061 yypstate *yyps;]b4_pure_if([], [[
1062 if (yypstate_allocated)
1063 return 0;]])[
1064 yyps = (yypstate *) malloc (sizeof *yyps);
1065 if (!yyps)
1066 return 0;
1067 yyps->yynew = 1;]b4_pure_if([], [[
1068 yypstate_allocated = 1;]])[
1069 return yyps;
1070 }
1071
1072 ]b4_c_function_def([[yypstate_delete]], [[void]],
1073 [[[yypstate *yyps]], [[yyps]]])[
1074 {
1075 #ifndef yyoverflow
1076 /* If the stack was reallocated but the parse did not complete, then the
1077 stack still needs to be freed. */
1078 if (!yyps->yynew && yyps->yyss != yyps->yyssa)
1079 YYSTACK_FREE (yyps->yyss);
1080 #endif
1081 free (yyps);]b4_pure_if([], [[
1082 yypstate_allocated = 0;]])[
1083 }
1084
1085 ]b4_pure_if([[#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs
1086 ]])[#define yystate yyps->yystate
1087 #define yyerrstatus yyps->yyerrstatus
1088 #define yyssa yyps->yyssa
1089 #define yyss yyps->yyss
1090 #define yyssp yyps->yyssp
1091 #define yyvsa yyps->yyvsa
1092 #define yyvs yyps->yyvs
1093 #define yyvsp yyps->yyvsp
1094 ]b4_locations_if([[#define yylsa yyps->yylsa
1095 #define yyls yyps->yyls
1096 #define yylsp yyps->yylsp
1097 #define yyerror_range yyps->yyerror_range
1098 ]])[#define yystacksize yyps->yystacksize
1099 ]])[
1100 /*-------------------------.
1101 | yyparse or yypush_parse. |
1102 `-------------------------*/
1103 ]b4_push_if([
1104 b4_c_function_def([[yypush_parse]], [[int]],
1105 [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
1106 [[[int yypushed_char]], [[yypushed_char]]],
1107 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1108 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1109 b4_parse_param]))], [
1110 #ifdef YYPARSE_PARAM
1111 b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])
1112 #else /* ! YYPARSE_PARAM */
1113 b4_c_function_def([yyparse], [int], b4_parse_param)
1114 #endif])[
1115 {
1116 ]b4_pure_if([b4_declare_scanner_communication_variables])
1117 b4_push_if([b4_pure_if([], [[ int yypushed_char = yychar;
1118 YYSTYPE yypushed_val = yylval;
1119 ]b4_locations_if([[YYLTYPE yypushed_loc = yylloc;
1120 ]])])],
1121 [b4_declare_parser_state_variables])[
1122 int yyn;
1123 int yyresult;
1124 /* Lookahead token as an internal (translated) token number. */
1125 int yytoken;
1126 /* The variables used to return semantic value and location from the
1127 action routines. */
1128 YYSTYPE yyval;]b4_locations_if([[
1129 YYLTYPE yyloc;]])[
1130
1131 #if YYERROR_VERBOSE
1132 /* Buffer for error messages, and its allocated size. */
1133 char yymsgbuf[128];
1134 char *yymsg = yymsgbuf;
1135 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1136 #endif
1137
1138 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
1139
1140 /* The number of symbols on the RHS of the reduced rule.
1141 Keep to zero when no symbol should be popped. */
1142 int yylen = 0;]b4_push_if([[
1143
1144 if (!yyps->yynew)
1145 {
1146 yyn = yypact[yystate];
1147 goto yyread_pushed_token;
1148 }]])[
1149
1150 yytoken = 0;
1151 yyss = yyssa;
1152 yyvs = yyvsa;]b4_locations_if([[
1153 yyls = yylsa;]])[
1154 yystacksize = YYINITDEPTH;
1155
1156 YYDPRINTF ((stderr, "Starting parse\n"));
1157
1158 yystate = 0;
1159 yyerrstatus = 0;
1160 yynerrs = 0;
1161 yychar = YYEMPTY; /* Cause a token to be read. */
1162
1163 /* Initialize stack pointers.
1164 Waste one element of value and location stack
1165 so that they stay on the same level as the state stack.
1166 The wasted elements are never initialized. */
1167 yyssp = yyss;
1168 yyvsp = yyvs;]b4_locations_if([[
1169 yylsp = yyls;
1170
1171 #if YYLTYPE_IS_TRIVIAL
1172 /* Initialize the default location before parsing starts. */
1173 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
1174 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
1175 #endif]])
1176 m4_ifdef([b4_initial_action],[
1177 m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl
1178 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
1179 /* User initialization code. */
1180 b4_user_initial_action
1181 m4_popdef([b4_dollar_dollar])dnl
1182 m4_popdef([b4_at_dollar])])dnl
1183 m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval;
1184 ]])dnl
1185 m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc;
1186 ]])[
1187 goto yysetstate;
1188
1189 /*------------------------------------------------------------.
1190 | yynewstate -- Push a new state, which is found in yystate. |
1191 `------------------------------------------------------------*/
1192 yynewstate:
1193 /* In all cases, when you get here, the value and location stacks
1194 have just been pushed. So pushing a state here evens the stacks. */
1195 yyssp++;
1196
1197 yysetstate:
1198 *yyssp = yystate;
1199
1200 if (yyss + yystacksize - 1 <= yyssp)
1201 {
1202 /* Get the current used size of the three stacks, in elements. */
1203 YYSIZE_T yysize = yyssp - yyss + 1;
1204
1205 #ifdef yyoverflow
1206 {
1207 /* Give user a chance to reallocate the stack. Use copies of
1208 these so that the &'s don't force the real ones into
1209 memory. */
1210 YYSTYPE *yyvs1 = yyvs;
1211 yytype_int16 *yyss1 = yyss;]b4_locations_if([
1212 YYLTYPE *yyls1 = yyls;])[
1213
1214 /* Each stack pointer address is followed by the size of the
1215 data in use in that stack, in bytes. This used to be a
1216 conditional around just the two extra args, but that might
1217 be undefined if yyoverflow is a macro. */
1218 yyoverflow (YY_("memory exhausted"),
1219 &yyss1, yysize * sizeof (*yyssp),
1220 &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
1221 &yyls1, yysize * sizeof (*yylsp),])[
1222 &yystacksize);
1223 ]b4_locations_if([
1224 yyls = yyls1;])[
1225 yyss = yyss1;
1226 yyvs = yyvs1;
1227 }
1228 #else /* no yyoverflow */
1229 # ifndef YYSTACK_RELOCATE
1230 goto yyexhaustedlab;
1231 # else
1232 /* Extend the stack our own way. */
1233 if (YYMAXDEPTH <= yystacksize)
1234 goto yyexhaustedlab;
1235 yystacksize *= 2;
1236 if (YYMAXDEPTH < yystacksize)
1237 yystacksize = YYMAXDEPTH;
1238
1239 {
1240 yytype_int16 *yyss1 = yyss;
1241 union yyalloc *yyptr =
1242 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1243 if (! yyptr)
1244 goto yyexhaustedlab;
1245 YYSTACK_RELOCATE (yyss_alloc, yyss);
1246 YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
1247 YYSTACK_RELOCATE (yyls_alloc, yyls);])[
1248 # undef YYSTACK_RELOCATE
1249 if (yyss1 != yyssa)
1250 YYSTACK_FREE (yyss1);
1251 }
1252 # endif
1253 #endif /* no yyoverflow */
1254
1255 yyssp = yyss + yysize - 1;
1256 yyvsp = yyvs + yysize - 1;]b4_locations_if([
1257 yylsp = yyls + yysize - 1;])[
1258
1259 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1260 (unsigned long int) yystacksize));
1261
1262 if (yyss + yystacksize - 1 <= yyssp)
1263 YYABORT;
1264 }
1265
1266 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1267
1268 if (yystate == YYFINAL)
1269 YYACCEPT;
1270
1271 goto yybackup;
1272
1273 /*-----------.
1274 | yybackup. |
1275 `-----------*/
1276 yybackup:
1277
1278 /* Do appropriate processing given the current state. Read a
1279 lookahead token if we need one and don't already have one. */
1280
1281 /* First try to decide what to do without reference to lookahead token. */
1282 yyn = yypact[yystate];
1283 if (yyn == YYPACT_NINF)
1284 goto yydefault;
1285
1286 /* Not known => get a lookahead token if don't already have one. */
1287
1288 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1289 if (yychar == YYEMPTY)
1290 {]b4_push_if([[
1291 if (!yyps->yynew)
1292 {]b4_use_push_for_pull_if([], [[
1293 YYDPRINTF ((stderr, "Return for a new token:\n"));]])[
1294 yyresult = YYPUSH_MORE;
1295 goto yypushreturn;
1296 }
1297 yyps->yynew = 0;]b4_pure_if([], [[
1298 /* Restoring the pushed token is only necessary for the first
1299 yypush_parse invocation since subsequent invocations don't overwrite
1300 it before jumping to yyread_pushed_token. */
1301 yychar = yypushed_char;
1302 yylval = yypushed_val;]b4_locations_if([[
1303 yylloc = yypushed_loc;]])])[
1304 yyread_pushed_token:]])[
1305 YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[
1306 yychar = yypushed_char;
1307 if (yypushed_val)
1308 yylval = *yypushed_val;]b4_locations_if([[
1309 if (yypushed_loc)
1310 yylloc = *yypushed_loc;]])])], [[
1311 yychar = YYLEX;]])[
1312 }
1313
1314 if (yychar <= YYEOF)
1315 {
1316 yychar = yytoken = YYEOF;
1317 YYDPRINTF ((stderr, "Now at end of input.\n"));
1318 }
1319 else
1320 {
1321 yytoken = YYTRANSLATE (yychar);
1322 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1323 }
1324
1325 /* If the proper action on seeing token YYTOKEN is to reduce or to
1326 detect an error, take that action. */
1327 yyn += yytoken;
1328 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1329 goto yydefault;
1330 yyn = yytable[yyn];
1331 if (yyn <= 0)
1332 {
1333 if (yyn == 0 || yyn == YYTABLE_NINF)
1334 goto yyerrlab;
1335 yyn = -yyn;
1336 goto yyreduce;
1337 }
1338
1339 /* Count tokens shifted since error; after three, turn off error
1340 status. */
1341 if (yyerrstatus)
1342 yyerrstatus--;
1343
1344 /* Shift the lookahead token. */
1345 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1346
1347 /* Discard the shifted token. */
1348 yychar = YYEMPTY;
1349
1350 yystate = yyn;
1351 *++yyvsp = yylval;
1352 ]b4_locations_if([ *++yylsp = yylloc;])[
1353 goto yynewstate;
1354
1355
1356 /*-----------------------------------------------------------.
1357 | yydefault -- do the default action for the current state. |
1358 `-----------------------------------------------------------*/
1359 yydefault:
1360 yyn = yydefact[yystate];
1361 if (yyn == 0)
1362 goto yyerrlab;
1363 goto yyreduce;
1364
1365
1366 /*-----------------------------.
1367 | yyreduce -- Do a reduction. |
1368 `-----------------------------*/
1369 yyreduce:
1370 /* yyn is the number of a rule to reduce with. */
1371 yylen = yyr2[yyn];
1372
1373 /* If YYLEN is nonzero, implement the default value of the action:
1374 `$$ = $1'.
1375
1376 Otherwise, the following line sets YYVAL to garbage.
1377 This behavior is undocumented and Bison
1378 users should not rely upon it. Assigning to YYVAL
1379 unconditionally makes the parser a bit smaller, and it avoids a
1380 GCC warning that YYVAL may be used uninitialized. */
1381 yyval = yyvsp[1-yylen];
1382
1383 ]b4_locations_if(
1384 [[ /* Default location. */
1385 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
1386 YY_REDUCE_PRINT (yyn);
1387 switch (yyn)
1388 {
1389 ]b4_user_actions[
1390 default: break;
1391 }
1392 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1393
1394 YYPOPSTACK (yylen);
1395 yylen = 0;
1396 YY_STACK_PRINT (yyss, yyssp);
1397
1398 *++yyvsp = yyval;]b4_locations_if([
1399 *++yylsp = yyloc;])[
1400
1401 /* Now `shift' the result of the reduction. Determine what state
1402 that goes to, based on the state we popped back to and the rule
1403 number reduced by. */
1404
1405 yyn = yyr1[yyn];
1406
1407 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1408 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1409 yystate = yytable[yystate];
1410 else
1411 yystate = yydefgoto[yyn - YYNTOKENS];
1412
1413 goto yynewstate;
1414
1415
1416 /*------------------------------------.
1417 | yyerrlab -- here on detecting error |
1418 `------------------------------------*/
1419 yyerrlab:
1420 /* If not already recovering from an error, report this error. */
1421 if (!yyerrstatus)
1422 {
1423 ++yynerrs;
1424 #if ! YYERROR_VERBOSE
1425 yyerror (]b4_yyerror_args[YY_("syntax error"));
1426 #else
1427 {
1428 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1429 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1430 {
1431 YYSIZE_T yyalloc = 2 * yysize;
1432 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1433 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1434 if (yymsg != yymsgbuf)
1435 YYSTACK_FREE (yymsg);
1436 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1437 if (yymsg)
1438 yymsg_alloc = yyalloc;
1439 else
1440 {
1441 yymsg = yymsgbuf;
1442 yymsg_alloc = sizeof yymsgbuf;
1443 }
1444 }
1445
1446 if (0 < yysize && yysize <= yymsg_alloc)
1447 {
1448 (void) yysyntax_error (yymsg, yystate, yychar);
1449 yyerror (]b4_yyerror_args[yymsg);
1450 }
1451 else
1452 {
1453 yyerror (]b4_yyerror_args[YY_("syntax error"));
1454 if (yysize != 0)
1455 goto yyexhaustedlab;
1456 }
1457 }
1458 #endif
1459 }
1460
1461 ]b4_locations_if([[ yyerror_range[0] = yylloc;]])[
1462
1463 if (yyerrstatus == 3)
1464 {
1465 /* If just tried and failed to reuse lookahead token after an
1466 error, discard it. */
1467
1468 if (yychar <= YYEOF)
1469 {
1470 /* Return failure if at end of input. */
1471 if (yychar == YYEOF)
1472 YYABORT;
1473 }
1474 else
1475 {
1476 yydestruct ("Error: discarding",
1477 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1478 yychar = YYEMPTY;
1479 }
1480 }
1481
1482 /* Else will try to reuse lookahead token after shifting the error
1483 token. */
1484 goto yyerrlab1;
1485
1486
1487 /*---------------------------------------------------.
1488 | yyerrorlab -- error raised explicitly by YYERROR. |
1489 `---------------------------------------------------*/
1490 yyerrorlab:
1491
1492 /* Pacify compilers like GCC when the user code never invokes
1493 YYERROR and the label yyerrorlab therefore never appears in user
1494 code. */
1495 if (/*CONSTCOND*/ 0)
1496 goto yyerrorlab;
1497
1498 ]b4_locations_if([[ yyerror_range[0] = yylsp[1-yylen];
1499 ]])[ /* Do not reclaim the symbols of the rule which action triggered
1500 this YYERROR. */
1501 YYPOPSTACK (yylen);
1502 yylen = 0;
1503 YY_STACK_PRINT (yyss, yyssp);
1504 yystate = *yyssp;
1505 goto yyerrlab1;
1506
1507
1508 /*-------------------------------------------------------------.
1509 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1510 `-------------------------------------------------------------*/
1511 yyerrlab1:
1512 yyerrstatus = 3; /* Each real token shifted decrements this. */
1513
1514 for (;;)
1515 {
1516 yyn = yypact[yystate];
1517 if (yyn != YYPACT_NINF)
1518 {
1519 yyn += YYTERROR;
1520 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1521 {
1522 yyn = yytable[yyn];
1523 if (0 < yyn)
1524 break;
1525 }
1526 }
1527
1528 /* Pop the current state because it cannot handle the error token. */
1529 if (yyssp == yyss)
1530 YYABORT;
1531
1532 ]b4_locations_if([[ yyerror_range[0] = *yylsp;]])[
1533 yydestruct ("Error: popping",
1534 yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1535 YYPOPSTACK (1);
1536 yystate = *yyssp;
1537 YY_STACK_PRINT (yyss, yyssp);
1538 }
1539
1540 *++yyvsp = yylval;
1541 ]b4_locations_if([[
1542 yyerror_range[1] = yylloc;
1543 /* Using YYLLOC is tempting, but would change the location of
1544 the lookahead. YYLOC is available though. */
1545 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
1546 *++yylsp = yyloc;]])[
1547
1548 /* Shift the error token. */
1549 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1550
1551 yystate = yyn;
1552 goto yynewstate;
1553
1554
1555 /*-------------------------------------.
1556 | yyacceptlab -- YYACCEPT comes here. |
1557 `-------------------------------------*/
1558 yyacceptlab:
1559 yyresult = 0;
1560 goto yyreturn;
1561
1562 /*-----------------------------------.
1563 | yyabortlab -- YYABORT comes here. |
1564 `-----------------------------------*/
1565 yyabortlab:
1566 yyresult = 1;
1567 goto yyreturn;
1568
1569 #if !defined(yyoverflow) || YYERROR_VERBOSE
1570 /*-------------------------------------------------.
1571 | yyexhaustedlab -- memory exhaustion comes here. |
1572 `-------------------------------------------------*/
1573 yyexhaustedlab:
1574 yyerror (]b4_yyerror_args[YY_("memory exhausted"));
1575 yyresult = 2;
1576 /* Fall through. */
1577 #endif
1578
1579 yyreturn:
1580 if (yychar != YYEMPTY)
1581 yydestruct ("Cleanup: discarding lookahead",
1582 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1583 /* Do not reclaim the symbols of the rule which action triggered
1584 this YYABORT or YYACCEPT. */
1585 YYPOPSTACK (yylen);
1586 YY_STACK_PRINT (yyss, yyssp);
1587 while (yyssp != yyss)
1588 {
1589 yydestruct ("Cleanup: popping",
1590 yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1591 YYPOPSTACK (1);
1592 }
1593 #ifndef yyoverflow
1594 if (yyss != yyssa)
1595 YYSTACK_FREE (yyss);
1596 #endif
1597 ]b4_push_if([[ yyps->yynew = 1;
1598
1599 yypushreturn:
1600 ]])[#if YYERROR_VERBOSE
1601 if (yymsg != yymsgbuf)
1602 YYSTACK_FREE (yymsg);
1603 #endif
1604 /* Make sure YYID is used. */
1605 return YYID (yyresult);
1606 }
1607
1608
1609 ]b4_epilogue
1610 b4_defines_if(
1611 [@output(b4_spec_defines_file@)@
1612 b4_copyright([Interface for Bison's Yacc-like parsers in C])dnl'
1613
1614 b4_percent_code_get([[requires]])[]dnl
1615
1616 b4_token_enums_defines(b4_tokens)
1617
1618 [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1619 ]m4_ifdef([b4_stype],
1620 [[typedef union ]b4_union_name[
1621 {
1622 ]b4_user_stype[
1623 } YYSTYPE;
1624 # define YYSTYPE_IS_TRIVIAL 1]],
1625 [m4_if(b4_tag_seen_flag, 0,
1626 [[typedef int YYSTYPE;
1627 # define YYSTYPE_IS_TRIVIAL 1]])])[
1628 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1629 # define YYSTYPE_IS_DECLARED 1
1630 #endif
1631
1632 ]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;]])
1633
1634 b4_locations_if(
1635 [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
1636 typedef struct YYLTYPE
1637 {
1638 int first_line;
1639 int first_column;
1640 int last_line;
1641 int last_column;
1642 } YYLTYPE;
1643 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1644 # define YYLTYPE_IS_DECLARED 1
1645 # define YYLTYPE_IS_TRIVIAL 1
1646 #endif
1647
1648 ]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]])
1649 )dnl b4_locations_if
1650 b4_push_if([[
1651 #ifndef YYPUSH_DECLS
1652 # define YYPUSH_DECLS
1653 struct ]b4_prefix[pstate;
1654 typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
1655 enum { YYPUSH_MORE = 4 };
1656 ]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
1657 ])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
1658 [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([,
1659 [[[int yypushed_char]], [[yypushed_char]]],
1660 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1661 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1662 b4_parse_param]))
1663 b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
1664 [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1665 b4_parse_param]))])
1666 b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
1667 [[[void]], []])
1668 b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
1669 [[b4_prefix[pstate *yyps]], [[yyps]]])[
1670 #endif
1671 ]])
1672 b4_percent_code_get([[provides]])[]dnl
1673 ])dnl b4_defines_if
1674 m4_divert_pop(0)
1675 m4_popdef([b4_copyright_years])
bison