]> 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
Formatting changes.
[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 /* Internationalized format string. */
847 const char *yyformat = 0;
848 /* Arguments of yyformat. */
849 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
850
851 /* Start YYX at -YYN if negative to avoid negative indexes in
852 YYCHECK. */
853 int yyxbegin = yyn < 0 ? -yyn : 0;
854
855 /* Stay within bounds of both yycheck and yytname. */
856 int yychecklim = YYLAST - yyn + 1;
857 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
858 /* Number of reported tokens (one for the "unexpected", one per
859 "expected"). */
860 int yycount = 0;
861 int yyx;
862
863 yyarg[yycount++] = yytname[yytype];
864
865 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
866 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
867 {
868 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
869 {
870 yycount = 1;
871 yysize = yysize0;
872 break;
873 }
874 yyarg[yycount++] = yytname[yyx];
875 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
876 yysize_overflow |= (yysize1 < yysize);
877 yysize = yysize1;
878 }
879
880 switch (yycount)
881 {
882 #define YYCASE_(N, S) \
883 case N: \
884 yyformat = S; \
885 break
886 YYCASE_(1, YY_("syntax error, unexpected %s"));
887 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
888 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
889 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
890 YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
891 #undef YYCASE_
892 }
893
894 yysize1 = yysize + yystrlen (yyformat);
895 yysize_overflow |= (yysize1 < yysize);
896 yysize = yysize1;
897
898 if (yysize_overflow)
899 return YYSIZE_MAXIMUM;
900
901 if (yyresult)
902 {
903 /* Avoid sprintf, as that infringes on the user's name space.
904 Don't have undefined behavior even if the translation
905 produced a string with the wrong number of "%s"s. */
906 char *yyp = yyresult;
907 int yyi = 0;
908 while ((*yyp = *yyformat) != '\0')
909 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
910 {
911 yyp += yytnamerr (yyp, yyarg[yyi++]);
912 yyformat += 2;
913 }
914 else
915 {
916 yyp++;
917 yyformat++;
918 }
919 }
920 return yysize;
921 }
922 }
923 #endif /* YYERROR_VERBOSE */
924 \f
925
926 ]b4_yydestruct_generate([b4_c_function_def])[
927
928 ]b4_push_if([],
929 [[/* Prevent warnings from -Wmissing-prototypes. */
930 #ifdef YYPARSE_PARAM
931 ]b4_c_function_decl([yyparse], [int],
932 [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])[
933 #else /* ! YYPARSE_PARAM */
934 ]b4_c_function_decl([yyparse], [int], b4_parse_param)[
935 #endif /* ! YYPARSE_PARAM */]])
936
937 m4_divert_push([KILL])# ======================== M4 code.
938 # b4_declare_scanner_communication_variables
939 # ------------------------------------------
940 # Declare the variables that are global, or local to YYPARSE if
941 # pure-parser.
942 m4_define([b4_declare_scanner_communication_variables],
943 [[/* The lookahead symbol. */
944 int yychar;
945
946 /* The semantic value of the lookahead symbol. */
947 YYSTYPE yylval;
948 ]b4_locations_if([[
949 /* Location data for the lookahead symbol. */
950 YYLTYPE yylloc;
951 ]])b4_pure_if([], [[
952 /* Number of syntax errors so far. */
953 int yynerrs;
954 ]])])
955
956 # b4_declare_parser_state_variables
957 # ---------------------------------
958 # Declare all the variables that are needed to maintain the parser state
959 # between calls to yypush_parse.
960 m4_define([b4_declare_parser_state_variables],
961 [b4_pure_if([[ /* Number of syntax errors so far. */
962 int yynerrs;
963 ]])[
964 int yystate;
965 /* Number of tokens to shift before error messages enabled. */
966 int yyerrstatus;
967
968 /* The stacks and their tools:
969 `yyss': related to states.
970 `yyvs': related to semantic values.]b4_locations_if([[
971 `yyls': related to locations.]])[
972
973 Refer to the stacks thru separate pointers, to allow yyoverflow
974 to reallocate them elsewhere. */
975
976 /* The state stack. */
977 yytype_int16 yyssa[YYINITDEPTH];
978 yytype_int16 *yyss;
979 yytype_int16 *yyssp;
980
981 /* The semantic value stack. */
982 YYSTYPE yyvsa[YYINITDEPTH];
983 YYSTYPE *yyvs;
984 YYSTYPE *yyvsp;
985 ]b4_locations_if([[
986 /* The location stack. */
987 YYLTYPE yylsa[YYINITDEPTH];
988 YYLTYPE *yyls;
989 YYLTYPE *yylsp;
990
991 /* The locations where the error started and ended. */
992 YYLTYPE yyerror_range[2];
993 ]])[
994 YYSIZE_T yystacksize;
995 ]])
996
997 m4_divert_pop([KILL])dnl# ====================== End of M4 code.
998
999 b4_pure_if([], [b4_declare_scanner_communication_variables])
1000
1001 b4_push_if(
1002 [[struct yypstate
1003 {
1004 ]b4_declare_parser_state_variables[
1005 /* Used to determine if this is the first time this instance has
1006 been used. */
1007 int yynew;
1008 };]b4_pure_if([], [[
1009
1010 static char yypstate_allocated = 0;]])b4_pull_if([
1011
1012 b4_c_function_def([[yyparse]], [[int]], b4_parse_param)[
1013 {
1014 return yypull_parse (0]m4_ifset([b4_parse_param],
1015 [[, ]b4_c_args(b4_parse_param)])[);
1016 }
1017
1018 ]b4_c_function_def([[yypull_parse]], [[int]],
1019 [[[yypstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1020 b4_parse_param]))[
1021 {
1022 int yystatus;
1023 yypstate *yyps_local;]b4_pure_if([[
1024 int yychar;
1025 YYSTYPE yylval;]b4_locations_if([[
1026 YYLTYPE yylloc;]])])[
1027 if (yyps == 0)
1028 {
1029 yyps_local = yypstate_new ();
1030 if (!yyps_local)
1031 {]b4_pure_if([[
1032 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]], [[
1033 if (!yypstate_allocated)
1034 yyerror (]b4_yyerror_args[YY_("memory exhausted"));]])[
1035 return 2;
1036 }
1037 }
1038 else
1039 yyps_local = yyps;
1040 do {
1041 yychar = YYLEX;
1042 yystatus =
1043 yypush_parse (yyps_local]b4_pure_if([[, yychar, &yylval]b4_locations_if([[, &yylloc]])])m4_ifset([b4_parse_param], [, b4_c_args(b4_parse_param)])[);
1044 } while (yystatus == YYPUSH_MORE);
1045 if (yyps == 0)
1046 yypstate_delete (yyps_local);
1047 return yystatus;
1048 }]])[
1049
1050 /* Initialize the parser data structure. */
1051 ]b4_c_function_def([[yypstate_new]], [[yypstate *]])[
1052 {
1053 yypstate *yyps;]b4_pure_if([], [[
1054 if (yypstate_allocated)
1055 return 0;]])[
1056 yyps = (yypstate *) malloc (sizeof *yyps);
1057 if (!yyps)
1058 return 0;
1059 yyps->yynew = 1;]b4_pure_if([], [[
1060 yypstate_allocated = 1;]])[
1061 return yyps;
1062 }
1063
1064 ]b4_c_function_def([[yypstate_delete]], [[void]],
1065 [[[yypstate *yyps]], [[yyps]]])[
1066 {
1067 #ifndef yyoverflow
1068 /* If the stack was reallocated but the parse did not complete, then the
1069 stack still needs to be freed. */
1070 if (!yyps->yynew && yyps->yyss != yyps->yyssa)
1071 YYSTACK_FREE (yyps->yyss);
1072 #endif
1073 free (yyps);]b4_pure_if([], [[
1074 yypstate_allocated = 0;]])[
1075 }
1076
1077 ]b4_pure_if([[#define ]b4_prefix[nerrs yyps->]b4_prefix[nerrs
1078 ]])[#define yystate yyps->yystate
1079 #define yyerrstatus yyps->yyerrstatus
1080 #define yyssa yyps->yyssa
1081 #define yyss yyps->yyss
1082 #define yyssp yyps->yyssp
1083 #define yyvsa yyps->yyvsa
1084 #define yyvs yyps->yyvs
1085 #define yyvsp yyps->yyvsp
1086 ]b4_locations_if([[#define yylsa yyps->yylsa
1087 #define yyls yyps->yyls
1088 #define yylsp yyps->yylsp
1089 #define yyerror_range yyps->yyerror_range
1090 ]])[#define yystacksize yyps->yystacksize
1091 ]])[
1092 /*-------------------------.
1093 | yyparse or yypush_parse. |
1094 `-------------------------*/
1095 ]b4_push_if([
1096 b4_c_function_def([[yypush_parse]], [[int]],
1097 [[[yypstate *yyps]], [[yyps]]]b4_pure_if([,
1098 [[[int yypushed_char]], [[yypushed_char]]],
1099 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1100 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1101 b4_parse_param]))], [
1102 #ifdef YYPARSE_PARAM
1103 b4_c_function_def([yyparse], [int], [[void *YYPARSE_PARAM], [YYPARSE_PARAM]])
1104 #else /* ! YYPARSE_PARAM */
1105 b4_c_function_def([yyparse], [int], b4_parse_param)
1106 #endif])[
1107 {
1108 ]b4_pure_if([b4_declare_scanner_communication_variables])
1109 b4_push_if([b4_pure_if([], [[ int yypushed_char = yychar;
1110 YYSTYPE yypushed_val = yylval;
1111 ]b4_locations_if([[YYLTYPE yypushed_loc = yylloc;
1112 ]])])],
1113 [b4_declare_parser_state_variables])[
1114 int yyn;
1115 int yyresult;
1116 /* Lookahead token as an internal (translated) token number. */
1117 int yytoken;
1118 /* The variables used to return semantic value and location from the
1119 action routines. */
1120 YYSTYPE yyval;]b4_locations_if([[
1121 YYLTYPE yyloc;]])[
1122
1123 #if YYERROR_VERBOSE
1124 /* Buffer for error messages, and its allocated size. */
1125 char yymsgbuf[128];
1126 char *yymsg = yymsgbuf;
1127 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1128 #endif
1129
1130 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)]b4_locations_if([, yylsp -= (N)])[)
1131
1132 /* The number of symbols on the RHS of the reduced rule.
1133 Keep to zero when no symbol should be popped. */
1134 int yylen = 0;]b4_push_if([[
1135
1136 if (!yyps->yynew)
1137 {
1138 yyn = yypact[yystate];
1139 goto yyread_pushed_token;
1140 }]])[
1141
1142 yytoken = 0;
1143 yyss = yyssa;
1144 yyvs = yyvsa;]b4_locations_if([[
1145 yyls = yylsa;]])[
1146 yystacksize = YYINITDEPTH;
1147
1148 YYDPRINTF ((stderr, "Starting parse\n"));
1149
1150 yystate = 0;
1151 yyerrstatus = 0;
1152 yynerrs = 0;
1153 yychar = YYEMPTY; /* Cause a token to be read. */
1154
1155 /* Initialize stack pointers.
1156 Waste one element of value and location stack
1157 so that they stay on the same level as the state stack.
1158 The wasted elements are never initialized. */
1159 yyssp = yyss;
1160 yyvsp = yyvs;]b4_locations_if([[
1161 yylsp = yyls;
1162
1163 #if YYLTYPE_IS_TRIVIAL
1164 /* Initialize the default location before parsing starts. */
1165 yylloc.first_line = yylloc.last_line = ]b4_location_initial_line[;
1166 yylloc.first_column = yylloc.last_column = ]b4_location_initial_column[;
1167 #endif]])
1168 m4_ifdef([b4_initial_action],[
1169 m4_pushdef([b4_at_dollar], [m4_define([b4_at_dollar_used])yylloc])dnl
1170 m4_pushdef([b4_dollar_dollar], [m4_define([b4_dollar_dollar_used])yylval])dnl
1171 /* User initialization code. */
1172 b4_user_initial_action
1173 m4_popdef([b4_dollar_dollar])dnl
1174 m4_popdef([b4_at_dollar])])dnl
1175 m4_ifdef([b4_dollar_dollar_used],[[ yyvsp[0] = yylval;
1176 ]])dnl
1177 m4_ifdef([b4_at_dollar_used], [[ yylsp[0] = yylloc;
1178 ]])[
1179 goto yysetstate;
1180
1181 /*------------------------------------------------------------.
1182 | yynewstate -- Push a new state, which is found in yystate. |
1183 `------------------------------------------------------------*/
1184 yynewstate:
1185 /* In all cases, when you get here, the value and location stacks
1186 have just been pushed. So pushing a state here evens the stacks. */
1187 yyssp++;
1188
1189 yysetstate:
1190 *yyssp = yystate;
1191
1192 if (yyss + yystacksize - 1 <= yyssp)
1193 {
1194 /* Get the current used size of the three stacks, in elements. */
1195 YYSIZE_T yysize = yyssp - yyss + 1;
1196
1197 #ifdef yyoverflow
1198 {
1199 /* Give user a chance to reallocate the stack. Use copies of
1200 these so that the &'s don't force the real ones into
1201 memory. */
1202 YYSTYPE *yyvs1 = yyvs;
1203 yytype_int16 *yyss1 = yyss;]b4_locations_if([
1204 YYLTYPE *yyls1 = yyls;])[
1205
1206 /* Each stack pointer address is followed by the size of the
1207 data in use in that stack, in bytes. This used to be a
1208 conditional around just the two extra args, but that might
1209 be undefined if yyoverflow is a macro. */
1210 yyoverflow (YY_("memory exhausted"),
1211 &yyss1, yysize * sizeof (*yyssp),
1212 &yyvs1, yysize * sizeof (*yyvsp),]b4_locations_if([
1213 &yyls1, yysize * sizeof (*yylsp),])[
1214 &yystacksize);
1215 ]b4_locations_if([
1216 yyls = yyls1;])[
1217 yyss = yyss1;
1218 yyvs = yyvs1;
1219 }
1220 #else /* no yyoverflow */
1221 # ifndef YYSTACK_RELOCATE
1222 goto yyexhaustedlab;
1223 # else
1224 /* Extend the stack our own way. */
1225 if (YYMAXDEPTH <= yystacksize)
1226 goto yyexhaustedlab;
1227 yystacksize *= 2;
1228 if (YYMAXDEPTH < yystacksize)
1229 yystacksize = YYMAXDEPTH;
1230
1231 {
1232 yytype_int16 *yyss1 = yyss;
1233 union yyalloc *yyptr =
1234 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1235 if (! yyptr)
1236 goto yyexhaustedlab;
1237 YYSTACK_RELOCATE (yyss_alloc, yyss);
1238 YYSTACK_RELOCATE (yyvs_alloc, yyvs);]b4_locations_if([
1239 YYSTACK_RELOCATE (yyls_alloc, yyls);])[
1240 # undef YYSTACK_RELOCATE
1241 if (yyss1 != yyssa)
1242 YYSTACK_FREE (yyss1);
1243 }
1244 # endif
1245 #endif /* no yyoverflow */
1246
1247 yyssp = yyss + yysize - 1;
1248 yyvsp = yyvs + yysize - 1;]b4_locations_if([
1249 yylsp = yyls + yysize - 1;])[
1250
1251 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1252 (unsigned long int) yystacksize));
1253
1254 if (yyss + yystacksize - 1 <= yyssp)
1255 YYABORT;
1256 }
1257
1258 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1259
1260 if (yystate == YYFINAL)
1261 YYACCEPT;
1262
1263 goto yybackup;
1264
1265 /*-----------.
1266 | yybackup. |
1267 `-----------*/
1268 yybackup:
1269
1270 /* Do appropriate processing given the current state. Read a
1271 lookahead token if we need one and don't already have one. */
1272
1273 /* First try to decide what to do without reference to lookahead token. */
1274 yyn = yypact[yystate];
1275 if (yyn == YYPACT_NINF)
1276 goto yydefault;
1277
1278 /* Not known => get a lookahead token if don't already have one. */
1279
1280 /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1281 if (yychar == YYEMPTY)
1282 {]b4_push_if([[
1283 if (!yyps->yynew)
1284 {]b4_use_push_for_pull_if([], [[
1285 YYDPRINTF ((stderr, "Return for a new token:\n"));]])[
1286 yyresult = YYPUSH_MORE;
1287 goto yypushreturn;
1288 }
1289 yyps->yynew = 0;]b4_pure_if([], [[
1290 /* Restoring the pushed token is only necessary for the first
1291 yypush_parse invocation since subsequent invocations don't overwrite
1292 it before jumping to yyread_pushed_token. */
1293 yychar = yypushed_char;
1294 yylval = yypushed_val;]b4_locations_if([[
1295 yylloc = yypushed_loc;]])])[
1296 yyread_pushed_token:]])[
1297 YYDPRINTF ((stderr, "Reading a token: "));]b4_push_if([b4_pure_if([[
1298 yychar = yypushed_char;
1299 if (yypushed_val)
1300 yylval = *yypushed_val;]b4_locations_if([[
1301 if (yypushed_loc)
1302 yylloc = *yypushed_loc;]])])], [[
1303 yychar = YYLEX;]])[
1304 }
1305
1306 if (yychar <= YYEOF)
1307 {
1308 yychar = yytoken = YYEOF;
1309 YYDPRINTF ((stderr, "Now at end of input.\n"));
1310 }
1311 else
1312 {
1313 yytoken = YYTRANSLATE (yychar);
1314 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1315 }
1316
1317 /* If the proper action on seeing token YYTOKEN is to reduce or to
1318 detect an error, take that action. */
1319 yyn += yytoken;
1320 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1321 goto yydefault;
1322 yyn = yytable[yyn];
1323 if (yyn <= 0)
1324 {
1325 if (yyn == 0 || yyn == YYTABLE_NINF)
1326 goto yyerrlab;
1327 yyn = -yyn;
1328 goto yyreduce;
1329 }
1330
1331 /* Count tokens shifted since error; after three, turn off error
1332 status. */
1333 if (yyerrstatus)
1334 yyerrstatus--;
1335
1336 /* Shift the lookahead token. */
1337 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1338
1339 /* Discard the shifted token. */
1340 yychar = YYEMPTY;
1341
1342 yystate = yyn;
1343 *++yyvsp = yylval;
1344 ]b4_locations_if([ *++yylsp = yylloc;])[
1345 goto yynewstate;
1346
1347
1348 /*-----------------------------------------------------------.
1349 | yydefault -- do the default action for the current state. |
1350 `-----------------------------------------------------------*/
1351 yydefault:
1352 yyn = yydefact[yystate];
1353 if (yyn == 0)
1354 goto yyerrlab;
1355 goto yyreduce;
1356
1357
1358 /*-----------------------------.
1359 | yyreduce -- Do a reduction. |
1360 `-----------------------------*/
1361 yyreduce:
1362 /* yyn is the number of a rule to reduce with. */
1363 yylen = yyr2[yyn];
1364
1365 /* If YYLEN is nonzero, implement the default value of the action:
1366 `$$ = $1'.
1367
1368 Otherwise, the following line sets YYVAL to garbage.
1369 This behavior is undocumented and Bison
1370 users should not rely upon it. Assigning to YYVAL
1371 unconditionally makes the parser a bit smaller, and it avoids a
1372 GCC warning that YYVAL may be used uninitialized. */
1373 yyval = yyvsp[1-yylen];
1374
1375 ]b4_locations_if(
1376 [[ /* Default location. */
1377 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);]])[
1378 YY_REDUCE_PRINT (yyn);
1379 switch (yyn)
1380 {
1381 ]b4_user_actions[
1382 default: break;
1383 }
1384 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
1385
1386 YYPOPSTACK (yylen);
1387 yylen = 0;
1388 YY_STACK_PRINT (yyss, yyssp);
1389
1390 *++yyvsp = yyval;]b4_locations_if([
1391 *++yylsp = yyloc;])[
1392
1393 /* Now `shift' the result of the reduction. Determine what state
1394 that goes to, based on the state we popped back to and the rule
1395 number reduced by. */
1396
1397 yyn = yyr1[yyn];
1398
1399 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1400 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1401 yystate = yytable[yystate];
1402 else
1403 yystate = yydefgoto[yyn - YYNTOKENS];
1404
1405 goto yynewstate;
1406
1407
1408 /*------------------------------------.
1409 | yyerrlab -- here on detecting error |
1410 `------------------------------------*/
1411 yyerrlab:
1412 /* If not already recovering from an error, report this error. */
1413 if (!yyerrstatus)
1414 {
1415 ++yynerrs;
1416 #if ! YYERROR_VERBOSE
1417 yyerror (]b4_yyerror_args[YY_("syntax error"));
1418 #else
1419 {
1420 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
1421 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
1422 {
1423 YYSIZE_T yyalloc = 2 * yysize;
1424 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
1425 yyalloc = YYSTACK_ALLOC_MAXIMUM;
1426 if (yymsg != yymsgbuf)
1427 YYSTACK_FREE (yymsg);
1428 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
1429 if (yymsg)
1430 yymsg_alloc = yyalloc;
1431 else
1432 {
1433 yymsg = yymsgbuf;
1434 yymsg_alloc = sizeof yymsgbuf;
1435 }
1436 }
1437
1438 if (0 < yysize && yysize <= yymsg_alloc)
1439 {
1440 (void) yysyntax_error (yymsg, yystate, yychar);
1441 yyerror (]b4_yyerror_args[yymsg);
1442 }
1443 else
1444 {
1445 yyerror (]b4_yyerror_args[YY_("syntax error"));
1446 if (yysize != 0)
1447 goto yyexhaustedlab;
1448 }
1449 }
1450 #endif
1451 }
1452
1453 ]b4_locations_if([[ yyerror_range[0] = yylloc;]])[
1454
1455 if (yyerrstatus == 3)
1456 {
1457 /* If just tried and failed to reuse lookahead token after an
1458 error, discard it. */
1459
1460 if (yychar <= YYEOF)
1461 {
1462 /* Return failure if at end of input. */
1463 if (yychar == YYEOF)
1464 YYABORT;
1465 }
1466 else
1467 {
1468 yydestruct ("Error: discarding",
1469 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1470 yychar = YYEMPTY;
1471 }
1472 }
1473
1474 /* Else will try to reuse lookahead token after shifting the error
1475 token. */
1476 goto yyerrlab1;
1477
1478
1479 /*---------------------------------------------------.
1480 | yyerrorlab -- error raised explicitly by YYERROR. |
1481 `---------------------------------------------------*/
1482 yyerrorlab:
1483
1484 /* Pacify compilers like GCC when the user code never invokes
1485 YYERROR and the label yyerrorlab therefore never appears in user
1486 code. */
1487 if (/*CONSTCOND*/ 0)
1488 goto yyerrorlab;
1489
1490 ]b4_locations_if([[ yyerror_range[0] = yylsp[1-yylen];
1491 ]])[ /* Do not reclaim the symbols of the rule which action triggered
1492 this YYERROR. */
1493 YYPOPSTACK (yylen);
1494 yylen = 0;
1495 YY_STACK_PRINT (yyss, yyssp);
1496 yystate = *yyssp;
1497 goto yyerrlab1;
1498
1499
1500 /*-------------------------------------------------------------.
1501 | yyerrlab1 -- common code for both syntax error and YYERROR. |
1502 `-------------------------------------------------------------*/
1503 yyerrlab1:
1504 yyerrstatus = 3; /* Each real token shifted decrements this. */
1505
1506 for (;;)
1507 {
1508 yyn = yypact[yystate];
1509 if (yyn != YYPACT_NINF)
1510 {
1511 yyn += YYTERROR;
1512 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1513 {
1514 yyn = yytable[yyn];
1515 if (0 < yyn)
1516 break;
1517 }
1518 }
1519
1520 /* Pop the current state because it cannot handle the error token. */
1521 if (yyssp == yyss)
1522 YYABORT;
1523
1524 ]b4_locations_if([[ yyerror_range[0] = *yylsp;]])[
1525 yydestruct ("Error: popping",
1526 yystos[yystate], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1527 YYPOPSTACK (1);
1528 yystate = *yyssp;
1529 YY_STACK_PRINT (yyss, yyssp);
1530 }
1531
1532 *++yyvsp = yylval;
1533 ]b4_locations_if([[
1534 yyerror_range[1] = yylloc;
1535 /* Using YYLLOC is tempting, but would change the location of
1536 the lookahead. YYLOC is available though. */
1537 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
1538 *++yylsp = yyloc;]])[
1539
1540 /* Shift the error token. */
1541 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
1542
1543 yystate = yyn;
1544 goto yynewstate;
1545
1546
1547 /*-------------------------------------.
1548 | yyacceptlab -- YYACCEPT comes here. |
1549 `-------------------------------------*/
1550 yyacceptlab:
1551 yyresult = 0;
1552 goto yyreturn;
1553
1554 /*-----------------------------------.
1555 | yyabortlab -- YYABORT comes here. |
1556 `-----------------------------------*/
1557 yyabortlab:
1558 yyresult = 1;
1559 goto yyreturn;
1560
1561 #if !defined(yyoverflow) || YYERROR_VERBOSE
1562 /*-------------------------------------------------.
1563 | yyexhaustedlab -- memory exhaustion comes here. |
1564 `-------------------------------------------------*/
1565 yyexhaustedlab:
1566 yyerror (]b4_yyerror_args[YY_("memory exhausted"));
1567 yyresult = 2;
1568 /* Fall through. */
1569 #endif
1570
1571 yyreturn:
1572 if (yychar != YYEMPTY)
1573 yydestruct ("Cleanup: discarding lookahead",
1574 yytoken, &yylval]b4_locations_if([, &yylloc])[]b4_user_args[);
1575 /* Do not reclaim the symbols of the rule which action triggered
1576 this YYABORT or YYACCEPT. */
1577 YYPOPSTACK (yylen);
1578 YY_STACK_PRINT (yyss, yyssp);
1579 while (yyssp != yyss)
1580 {
1581 yydestruct ("Cleanup: popping",
1582 yystos[*yyssp], yyvsp]b4_locations_if([, yylsp])[]b4_user_args[);
1583 YYPOPSTACK (1);
1584 }
1585 #ifndef yyoverflow
1586 if (yyss != yyssa)
1587 YYSTACK_FREE (yyss);
1588 #endif
1589 ]b4_push_if([[ yyps->yynew = 1;
1590
1591 yypushreturn:
1592 ]])[#if YYERROR_VERBOSE
1593 if (yymsg != yymsgbuf)
1594 YYSTACK_FREE (yymsg);
1595 #endif
1596 /* Make sure YYID is used. */
1597 return YYID (yyresult);
1598 }
1599
1600
1601 ]b4_epilogue
1602 b4_defines_if(
1603 [@output(b4_spec_defines_file@)@
1604 b4_copyright([Interface for Bison's Yacc-like parsers in C])dnl'
1605
1606 b4_percent_code_get([[requires]])[]dnl
1607
1608 b4_token_enums_defines(b4_tokens)
1609
1610 [#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
1611 ]m4_ifdef([b4_stype],
1612 [[typedef union ]b4_union_name[
1613 {
1614 ]b4_user_stype[
1615 } YYSTYPE;
1616 # define YYSTYPE_IS_TRIVIAL 1]],
1617 [m4_if(b4_tag_seen_flag, 0,
1618 [[typedef int YYSTYPE;
1619 # define YYSTYPE_IS_TRIVIAL 1]])])[
1620 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
1621 # define YYSTYPE_IS_DECLARED 1
1622 #endif
1623
1624 ]b4_pure_if([], [[extern YYSTYPE ]b4_prefix[lval;]])
1625
1626 b4_locations_if(
1627 [#if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
1628 typedef struct YYLTYPE
1629 {
1630 int first_line;
1631 int first_column;
1632 int last_line;
1633 int last_column;
1634 } YYLTYPE;
1635 # define yyltype YYLTYPE /* obsolescent; will be withdrawn */
1636 # define YYLTYPE_IS_DECLARED 1
1637 # define YYLTYPE_IS_TRIVIAL 1
1638 #endif
1639
1640 ]b4_pure_if([], [[extern YYLTYPE ]b4_prefix[lloc;]])
1641 )dnl b4_locations_if
1642 b4_push_if([[
1643 #ifndef YYPUSH_DECLS
1644 # define YYPUSH_DECLS
1645 struct ]b4_prefix[pstate;
1646 typedef struct ]b4_prefix[pstate ]b4_prefix[pstate;
1647 enum { YYPUSH_MORE = 4 };
1648 ]b4_pull_if([b4_c_function_decl([b4_prefix[parse]], [[int]], b4_parse_param)
1649 ])b4_c_function_decl([b4_prefix[push_parse]], [[int]],
1650 [[b4_prefix[pstate *yyps]], [[yyps]]]b4_pure_if([,
1651 [[[int yypushed_char]], [[yypushed_char]]],
1652 [[[YYSTYPE const *yypushed_val]], [[yypushed_val]]]b4_locations_if([,
1653 [[[YYLTYPE const *yypushed_loc]], [[yypushed_loc]]]])])m4_ifset([b4_parse_param], [,
1654 b4_parse_param]))
1655 b4_pull_if([b4_c_function_decl([b4_prefix[pull_parse]], [[int]],
1656 [[b4_prefix[pstate *yyps]], [[yyps]]]m4_ifset([b4_parse_param], [,
1657 b4_parse_param]))])
1658 b4_c_function_decl([b4_prefix[pstate_new]], [b4_prefix[pstate *]],
1659 [[[void]], []])
1660 b4_c_function_decl([b4_prefix[pstate_delete]], [[void]],
1661 [[b4_prefix[pstate *yyps]], [[yyps]]])[
1662 #endif
1663 ]])
1664 b4_percent_code_get([[provides]])[]dnl
1665 ])dnl b4_defines_if
1666 m4_divert_pop(0)
1667 m4_popdef([b4_copyright_years])
bison