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


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