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