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


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