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