1 |
m4_divert(-1) -*- C -*- |
2 |
|
3 |
# Yacc compatible skeleton for Bison |
4 |
# Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 |
5 |
# Free Software Foundation, Inc. |
6 |
|
7 |
# This program is free software; you can redistribute it and/or modify |
8 |
# it under the terms of the GNU General Public License as published by |
9 |
# the Free Software Foundation; either version 2 of the License, or |
10 |
# (at your option) any later version. |
11 |
|
12 |
# This program is distributed in the hope that it will be useful, |
13 |
# but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 |
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
15 |
# GNU General Public License for more details. |
16 |
|
17 |
# You should have received a copy of the GNU General Public License |
18 |
# along with this program; if not, write to the Free Software |
19 |
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA |
20 |
# 02111-1307 USA |
21 |
|
22 |
|
23 |
|
24 |
## ---------------- ## |
25 |
## Default values. ## |
26 |
## ---------------- ## |
27 |
|
28 |
# Stack parameters. |
29 |
m4_define_default([b4_stack_depth_max], [10000]) |
30 |
m4_define_default([b4_stack_depth_init], [200]) |
31 |
|
32 |
|
33 |
## ------------------------ ## |
34 |
## Pure/impure interfaces. ## |
35 |
## ------------------------ ## |
36 |
|
37 |
|
38 |
# b4_pure_if(IF-TRUE, IF-FALSE) |
39 |
# ----------------------------- |
40 |
# Expand IF-TRUE, if %pure-parser and %parse-param, IF-FALSE otherwise. |
41 |
m4_define([b4_Pure_if], |
42 |
[b4_pure_if([m4_ifset([b4_parse_param], |
43 |
[$1], [$2])], |
44 |
[$2])]) |
45 |
|
46 |
|
47 |
# b4_yyerror_args |
48 |
# --------------- |
49 |
# Arguments passed to yyerror: user args plus yylloc. |
50 |
m4_define([b4_yyerror_args], |
51 |
[b4_Pure_if([b4_location_if([&yylloc, ])])dnl |
52 |
m4_ifset([b4_parse_param], [b4_c_args(b4_parse_param), ])]) |
53 |
|
54 |
|
55 |
# b4_lex_param |
56 |
# ------------ |
57 |
# Accumulate in b4_lex_param all the yylex arguments. |
58 |
# b4_lex_param arrives quoted twice, but we want to keep only one level. |
59 |
m4_define([b4_lex_param], |
60 |
m4_dquote(b4_pure_if([[[[YYSTYPE *]], [[&yylval]]][]dnl |
61 |
b4_location_if([, [[YYLTYPE *], [&yylloc]]])m4_ifdef([b4_lex_param], [, ])])dnl |
62 |
m4_ifdef([b4_lex_param], b4_lex_param))) |
63 |
|
64 |
|
65 |
|
66 |
## ------------ ## |
67 |
## Data Types. ## |
68 |
## ------------ ## |
69 |
|
70 |
# b4_int_type(MIN, MAX) |
71 |
# --------------------- |
72 |
# Return the smallest int type able to handle numbers ranging from |
73 |
# MIN to MAX (included). We overwrite the version from c.m4 which relies |
74 |
# on "signed char" which is not portable to old K&R compilers. |
75 |
m4_define([b4_int_type], |
76 |
[m4_if(b4_ints_in($@, [0], [255]), [1], [unsigned char], |
77 |
b4_ints_in($@, [-128], [127]), [1], [yysigned_char], |
78 |
|
79 |
b4_ints_in($@, [0], [65535]), [1], [unsigned short], |
80 |
b4_ints_in($@, [-32768], [32767]), [1], [short], |
81 |
|
82 |
m4_eval([0 <= $1]), [1], [unsigned int], |
83 |
|
84 |
[int])]) |
85 |
|
86 |
|
87 |
## ----------------- ## |
88 |
## Semantic Values. ## |
89 |
## ----------------- ## |
90 |
|
91 |
|
92 |
# b4_lhs_value([TYPE]) |
93 |
# -------------------- |
94 |
# Expansion of $<TYPE>$. |
95 |
m4_define([b4_lhs_value], |
96 |
[yyval[]m4_ifval([$1], [.$1])]) |
97 |
|
98 |
|
99 |
# b4_rhs_value(RULE-LENGTH, NUM, [TYPE]) |
100 |
# -------------------------------------- |
101 |
# Expansion of $<TYPE>NUM, where the current rule has RULE-LENGTH |
102 |
# symbols on RHS. |
103 |
m4_define([b4_rhs_value], |
104 |
[yyvsp@{m4_eval([$2 - $1])@}m4_ifval([$3], [.$3])]) |
105 |
|
106 |
|
107 |
|
108 |
## ----------- ## |
109 |
## Locations. ## |
110 |
## ----------- ## |
111 |
|
112 |
# b4_lhs_location() |
113 |
# ----------------- |
114 |
# Expansion of @$. |
115 |
m4_define([b4_lhs_location], |
116 |
[yyloc]) |
117 |
|
118 |
|
119 |
# b4_rhs_location(RULE-LENGTH, NUM) |
120 |
# --------------------------------- |
121 |
# Expansion of @NUM, where the current rule has RULE-LENGTH symbols |
122 |
# on RHS. |
123 |
m4_define([b4_rhs_location], |
124 |
[yylsp@{m4_eval([$2 - $1])@}]) |
125 |
|
126 |
|
127 |
|
128 |
## --------------------------------------------------------- ## |
129 |
## Defining symbol actions, e.g., printers and destructors. ## |
130 |
## --------------------------------------------------------- ## |
131 |
|
132 |
# We do want M4 expansion after # for CPP macros. |
133 |
m4_changecom() |
134 |
m4_divert(0)dnl |
135 |
@output @output_parser_name@ |
136 |
b4_copyright([Skeleton parser for Yacc-like parsing with Bison], |
137 |
[1984, 1989, 1990, 2000, 2001, 2002, 2003])[ |
138 |
|
139 |
/* As a special exception, when this file is copied by Bison into a |
140 |
Bison output file, you may use that output file without restriction. |
141 |
This special exception was added by the Free Software Foundation |
142 |
in version 1.24 of Bison. */ |
143 |
|
144 |
/* Written by Richard Stallman by simplifying the original so called |
145 |
``semantic'' parser. */ |
146 |
|
147 |
/* All symbols defined below should begin with yy or YY, to avoid |
148 |
infringing on user name space. This should be done even for local |
149 |
variables, as they might otherwise be expanded by user macros. |
150 |
There are some unavoidable exceptions within include files to |
151 |
define necessary library symbols; they are noted "INFRINGES ON |
152 |
USER NAME SPACE" below. */ |
153 |
|
154 |
]b4_identification |
155 |
m4_if(b4_prefix[], [yy], [], |
156 |
[/* If NAME_PREFIX is specified substitute the variables and functions |
157 |
names. */ |
158 |
#define yyparse b4_prefix[]parse |
159 |
#define yylex b4_prefix[]lex |
160 |
#define yyerror b4_prefix[]error |
161 |
#define yylval b4_prefix[]lval |
162 |
#define yychar b4_prefix[]char |
163 |
#define yydebug b4_prefix[]debug |
164 |
#define yynerrs b4_prefix[]nerrs |
165 |
b4_location_if([#define yylloc b4_prefix[]lloc])])[ |
166 |
|
167 |
]b4_token_defines(b4_tokens)[ |
168 |
|
169 |
/* Copy the first part of user declarations. */ |
170 |
]b4_pre_prologue[ |
171 |
|
172 |
/* Enabling traces. */ |
173 |
#ifndef YYDEBUG |
174 |
# define YYDEBUG ]b4_debug[ |
175 |
#endif |
176 |
|
177 |
/* Enabling verbose error messages. */ |
178 |
#ifdef YYERROR_VERBOSE |
179 |
# undef YYERROR_VERBOSE |
180 |
# define YYERROR_VERBOSE 1 |
181 |
#else |
182 |
# define YYERROR_VERBOSE ]b4_error_verbose[ |
183 |
#endif |
184 |
|
185 |
#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) |
186 |
]m4_ifdef([b4_stype], |
187 |
[b4_syncline([b4_stype_line], [b4_filename]) |
188 |
typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE; |
189 |
/* Line __line__ of yacc.c. */ |
190 |
b4_syncline([@oline@], [@ofile@])], |
191 |
[typedef int YYSTYPE;])[ |
192 |
# define yystype YYSTYPE /* obsolescent; will be withdrawn */ |
193 |
# define YYSTYPE_IS_DECLARED 1 |
194 |
# define YYSTYPE_IS_TRIVIAL 1 |
195 |
#endif |
196 |
|
197 |
]b4_location_if([#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED) |
198 |
typedef struct YYLTYPE |
199 |
{ |
200 |
int first_line; |
201 |
int first_column; |
202 |
int last_line; |
203 |
int last_column; |
204 |
} YYLTYPE; |
205 |
# define yyltype YYLTYPE /* obsolescent; will be withdrawn */ |
206 |
# define YYLTYPE_IS_DECLARED 1 |
207 |
# define YYLTYPE_IS_TRIVIAL 1 |
208 |
#endif |
209 |
])[ |
210 |
|
211 |
/* Copy the second part of user declarations. */ |
212 |
]b4_post_prologue |
213 |
|
214 |
/* Line __line__ of yacc.c. */ |
215 |
b4_syncline([@oline@], [@ofile@])[ |
216 |
|
217 |
#if ! defined (yyoverflow) || YYERROR_VERBOSE |
218 |
|
219 |
# ifndef YYFREE |
220 |
# define YYFREE free |
221 |
# endif |
222 |
# ifndef YYMALLOC |
223 |
# define YYMALLOC malloc |
224 |
# endif |
225 |
|
226 |
/* The parser invokes alloca or malloc; define the necessary symbols. */ |
227 |
|
228 |
# ifdef YYSTACK_USE_ALLOCA |
229 |
# if YYSTACK_USE_ALLOCA |
230 |
# define YYSTACK_ALLOC alloca |
231 |
# endif |
232 |
# else |
233 |
# if defined (alloca) || defined (_ALLOCA_H) |
234 |
# define YYSTACK_ALLOC alloca |
235 |
# else |
236 |
# ifdef __GNUC__ |
237 |
# define YYSTACK_ALLOC __builtin_alloca |
238 |
# endif |
239 |
# endif |
240 |
# endif |
241 |
|
242 |
# ifdef YYSTACK_ALLOC |
243 |
/* Pacify GCC's `empty if-body' warning. */ |
244 |
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0) |
245 |
# else |
246 |
# if defined (__STDC__) || defined (__cplusplus) |
247 |
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */ |
248 |
# define YYSIZE_T size_t |
249 |
# endif |
250 |
# define YYSTACK_ALLOC YYMALLOC |
251 |
# define YYSTACK_FREE YYFREE |
252 |
# endif |
253 |
#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */ |
254 |
|
255 |
|
256 |
#if (! defined (yyoverflow) \ |
257 |
&& (! defined (__cplusplus) \ |
258 |
|| (]b4_location_if([[defined (YYLTYPE_IS_TRIVIAL) && YYLTYPE_IS_TRIVIAL \ |
259 |
&& ]])[defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL))) |
260 |
|
261 |
/* A type that is properly aligned for any stack member. */ |
262 |
union yyalloc |
263 |
{ |
264 |
short yyss; |
265 |
YYSTYPE yyvs; |
266 |
]b4_location_if([ YYLTYPE yyls; |
267 |
])dnl |
268 |
[}; |
269 |
|
270 |
/* The size of the maximum gap between one aligned stack and the next. */ |
271 |
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1) |
272 |
|
273 |
/* The size of an array large to enough to hold all stacks, each with |
274 |
N elements. */ |
275 |
]b4_location_if( |
276 |
[# define YYSTACK_BYTES(N) \ |
277 |
((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \ |
278 |
+ 2 * YYSTACK_GAP_MAXIMUM)], |
279 |
[# define YYSTACK_BYTES(N) \ |
280 |
((N) * (sizeof (short) + sizeof (YYSTYPE)) \ |
281 |
+ YYSTACK_GAP_MAXIMUM)])[ |
282 |
|
283 |
/* Copy COUNT objects from FROM to TO. The source and destination do |
284 |
not overlap. */ |
285 |
# ifndef YYCOPY |
286 |
# if defined (__GNUC__) && 1 < __GNUC__ |
287 |
# define YYCOPY(To, From, Count) \ |
288 |
__builtin_memcpy (To, From, (Count) * sizeof (*(From))) |
289 |
# else |
290 |
# define YYCOPY(To, From, Count) \ |
291 |
do \ |
292 |
{ \ |
293 |
register YYSIZE_T yyi; \ |
294 |
for (yyi = 0; yyi < (Count); yyi++) \ |
295 |
(To)[yyi] = (From)[yyi]; \ |
296 |
} \ |
297 |
while (0) |
298 |
# endif |
299 |
# endif |
300 |
|
301 |
/* Relocate STACK from its old location to the new one. The |
302 |
local variables YYSIZE and YYSTACKSIZE give the old and new number of |
303 |
elements in the stack, and YYPTR gives the new location of the |
304 |
stack. Advance YYPTR to a properly aligned location for the next |
305 |
stack. */ |
306 |
# define YYSTACK_RELOCATE(Stack) \ |
307 |
do \ |
308 |
{ \ |
309 |
YYSIZE_T yynewbytes; \ |
310 |
YYCOPY (&yyptr->Stack, Stack, yysize); \ |
311 |
Stack = &yyptr->Stack; \ |
312 |
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \ |
313 |
yyptr += yynewbytes / sizeof (*yyptr); \ |
314 |
} \ |
315 |
while (0) |
316 |
|
317 |
#endif |
318 |
|
319 |
#if defined (__STDC__) || defined (__cplusplus) |
320 |
typedef signed char yysigned_char; |
321 |
#else |
322 |
typedef short yysigned_char; |
323 |
#endif |
324 |
|
325 |
/* YYFINAL -- State number of the termination state. */ |
326 |
#define YYFINAL ]b4_final_state_number[ |
327 |
/* YYLAST -- Last index in YYTABLE. */ |
328 |
#define YYLAST ]b4_last[ |
329 |
|
330 |
/* YYNTOKENS -- Number of terminals. */ |
331 |
#define YYNTOKENS ]b4_tokens_number[ |
332 |
/* YYNNTS -- Number of nonterminals. */ |
333 |
#define YYNNTS ]b4_nterms_number[ |
334 |
/* YYNRULES -- Number of rules. */ |
335 |
#define YYNRULES ]b4_rules_number[ |
336 |
/* YYNRULES -- Number of states. */ |
337 |
#define YYNSTATES ]b4_states_number[ |
338 |
|
339 |
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */ |
340 |
#define YYUNDEFTOK ]b4_undef_token_number[ |
341 |
#define YYMAXUTOK ]b4_user_token_number_max[ |
342 |
|
343 |
#define YYTRANSLATE(YYX) \ |
344 |
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK) |
345 |
|
346 |
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */ |
347 |
static const ]b4_int_type_for([b4_translate])[ yytranslate[] = |
348 |
{ |
349 |
]b4_translate[ |
350 |
}; |
351 |
|
352 |
#if YYDEBUG |
353 |
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in |
354 |
YYRHS. */ |
355 |
static const ]b4_int_type_for([b4_prhs])[ yyprhs[] = |
356 |
{ |
357 |
]b4_prhs[ |
358 |
}; |
359 |
|
360 |
/* YYRHS -- A `-1'-separated list of the rules' RHS. */ |
361 |
static const ]b4_int_type_for([b4_rhs])[ yyrhs[] = |
362 |
{ |
363 |
]b4_rhs[ |
364 |
}; |
365 |
|
366 |
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */ |
367 |
static const ]b4_int_type_for([b4_rline])[ yyrline[] = |
368 |
{ |
369 |
]b4_rline[ |
370 |
}; |
371 |
#endif |
372 |
|
373 |
#if YYDEBUG || YYERROR_VERBOSE |
374 |
/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM. |
375 |
First, the terminals, then, starting at YYNTOKENS, nonterminals. */ |
376 |
static const char *const yytname[] = |
377 |
{ |
378 |
]b4_tname[ |
379 |
}; |
380 |
#endif |
381 |
|
382 |
# ifdef YYPRINT |
383 |
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to |
384 |
token YYLEX-NUM. */ |
385 |
static const ]b4_int_type_for([b4_toknum])[ yytoknum[] = |
386 |
{ |
387 |
]b4_toknum[ |
388 |
}; |
389 |
# endif |
390 |
|
391 |
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */ |
392 |
static const ]b4_int_type_for([b4_r1])[ yyr1[] = |
393 |
{ |
394 |
]b4_r1[ |
395 |
}; |
396 |
|
397 |
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */ |
398 |
static const ]b4_int_type_for([b4_r2])[ yyr2[] = |
399 |
{ |
400 |
]b4_r2[ |
401 |
}; |
402 |
|
403 |
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state |
404 |
STATE-NUM when YYTABLE doesn't specify something else to do. Zero |
405 |
means the default is an error. */ |
406 |
static const ]b4_int_type_for([b4_defact])[ yydefact[] = |
407 |
{ |
408 |
]b4_defact[ |
409 |
}; |
410 |
|
411 |
/* YYDEFGOTO[NTERM-NUM]. */ |
412 |
static const ]b4_int_type_for([b4_defgoto])[ yydefgoto[] = |
413 |
{ |
414 |
]b4_defgoto[ |
415 |
}; |
416 |
|
417 |
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing |
418 |
STATE-NUM. */ |
419 |
#define YYPACT_NINF ]b4_pact_ninf[ |
420 |
static const ]b4_int_type_for([b4_pact])[ yypact[] = |
421 |
{ |
422 |
]b4_pact[ |
423 |
}; |
424 |
|
425 |
/* YYPGOTO[NTERM-NUM]. */ |
426 |
static const ]b4_int_type_for([b4_pgoto])[ yypgoto[] = |
427 |
{ |
428 |
]b4_pgoto[ |
429 |
}; |
430 |
|
431 |
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If |
432 |
positive, shift that token. If negative, reduce the rule which |
433 |
number is the opposite. If zero, do what YYDEFACT says. |
434 |
If YYTABLE_NINF, syntax error. */ |
435 |
#define YYTABLE_NINF ]b4_table_ninf[ |
436 |
static const ]b4_int_type_for([b4_table])[ yytable[] = |
437 |
{ |
438 |
]b4_table[ |
439 |
}; |
440 |
|
441 |
static const ]b4_int_type_for([b4_check])[ yycheck[] = |
442 |
{ |
443 |
]b4_check[ |
444 |
}; |
445 |
|
446 |
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing |
447 |
symbol of state STATE-NUM. */ |
448 |
static const ]b4_int_type_for([b4_stos])[ yystos[] = |
449 |
{ |
450 |
]b4_stos[ |
451 |
}; |
452 |
|
453 |
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__) |
454 |
# define YYSIZE_T __SIZE_TYPE__ |
455 |
#endif |
456 |
#if ! defined (YYSIZE_T) && defined (size_t) |
457 |
# define YYSIZE_T size_t |
458 |
#endif |
459 |
#if ! defined (YYSIZE_T) |
460 |
# if defined (__STDC__) || defined (__cplusplus) |
461 |
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */ |
462 |
# define YYSIZE_T size_t |
463 |
# endif |
464 |
#endif |
465 |
#if ! defined (YYSIZE_T) |
466 |
# define YYSIZE_T unsigned int |
467 |
#endif |
468 |
|
469 |
#define yyerrok (yyerrstatus = 0) |
470 |
#define yyclearin (yychar = YYEMPTY) |
471 |
#define YYEMPTY (-2) |
472 |
#define YYEOF 0 |
473 |
|
474 |
#define YYACCEPT goto yyacceptlab |
475 |
#define YYABORT goto yyabortlab |
476 |
#define YYERROR goto yyerrorlab |
477 |
|
478 |
|
479 |
/* Like YYERROR except do call yyerror. This remains here temporarily |
480 |
to ease the transition to the new meaning of YYERROR, for GCC. |
481 |
Once GCC version 2 has supplanted version 1, this can go. */ |
482 |
|
483 |
#define YYFAIL goto yyerrlab |
484 |
|
485 |
#define YYRECOVERING() (!!yyerrstatus) |
486 |
|
487 |
#define YYBACKUP(Token, Value) \ |
488 |
do \ |
489 |
if (yychar == YYEMPTY && yylen == 1) \ |
490 |
{ \ |
491 |
yychar = (Token); \ |
492 |
yylval = (Value); \ |
493 |
yytoken = YYTRANSLATE (yychar); \ |
494 |
YYPOPSTACK; \ |
495 |
goto yybackup; \ |
496 |
} \ |
497 |
else \ |
498 |
{ \ |
499 |
yyerror (]b4_yyerror_args["syntax error: cannot back up");\ |
500 |
YYERROR; \ |
501 |
} \ |
502 |
while (0) |
503 |
|
504 |
#define YYTERROR 1 |
505 |
#define YYERRCODE 256 |
506 |
|
507 |
/* YYLLOC_DEFAULT -- Compute the default location (before the actions |
508 |
are run). */ |
509 |
|
510 |
#ifndef YYLLOC_DEFAULT |
511 |
# define YYLLOC_DEFAULT(Current, Rhs, N) \ |
512 |
((Current).first_line = (Rhs)[1].first_line, \ |
513 |
(Current).first_column = (Rhs)[1].first_column, \ |
514 |
(Current).last_line = (Rhs)[N].last_line, \ |
515 |
(Current).last_column = (Rhs)[N].last_column) |
516 |
#endif |
517 |
|
518 |
/* YYLEX -- calling `yylex' with the right arguments. */ |
519 |
|
520 |
#ifdef YYLEX_PARAM |
521 |
# define YYLEX yylex (]b4_pure_if([&yylval[]b4_location_if([, &yylloc]), ])[YYLEX_PARAM) |
522 |
#else |
523 |
# define YYLEX ]b4_c_function_call([yylex], [int], b4_lex_param)[ |
524 |
#endif |
525 |
|
526 |
/* Enable debugging if requested. */ |
527 |
#if YYDEBUG |
528 |
|
529 |
# ifndef YYFPRINTF |
530 |
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */ |
531 |
# define YYFPRINTF fprintf |
532 |
# endif |
533 |
|
534 |
# define YYDPRINTF(Args) \ |
535 |
do { \ |
536 |
if (yydebug) \ |
537 |
YYFPRINTF Args; \ |
538 |
} while (0) |
539 |
|
540 |
# define YYDSYMPRINT(Args) \ |
541 |
do { \ |
542 |
if (yydebug) \ |
543 |
yysymprint Args; \ |
544 |
} while (0) |
545 |
|
546 |
# define YYDSYMPRINTF(Title, Token, Value, Location) \ |
547 |
do { \ |
548 |
if (yydebug) \ |
549 |
{ \ |
550 |
YYFPRINTF (stderr, "%s ", Title); \ |
551 |
yysymprint (stderr, \ |
552 |
Token, Value]b4_location_if([, Location])[); \ |
553 |
YYFPRINTF (stderr, "\n"); \ |
554 |
} \ |
555 |
} while (0) |
556 |
|
557 |
/*------------------------------------------------------------------. |
558 |
| yy_stack_print -- Print the state stack from its BOTTOM up to its | |
559 |
| TOP (included). | |
560 |
`------------------------------------------------------------------*/ |
561 |
|
562 |
]b4_c_function_def([yy_stack_print], [static void], |
563 |
[[short *bottom], [bottom]], |
564 |
[[short *top], [top]])[ |
565 |
{ |
566 |
YYFPRINTF (stderr, "Stack now"); |
567 |
for (/* Nothing. */; bottom <= top; ++bottom) |
568 |
YYFPRINTF (stderr, " %d", *bottom); |
569 |
YYFPRINTF (stderr, "\n"); |
570 |
} |
571 |
|
572 |
# define YY_STACK_PRINT(Bottom, Top) \ |
573 |
do { \ |
574 |
if (yydebug) \ |
575 |
yy_stack_print ((Bottom), (Top)); \ |
576 |
} while (0) |
577 |
|
578 |
|
579 |
/*------------------------------------------------. |
580 |
| Report that the YYRULE is going to be reduced. | |
581 |
`------------------------------------------------*/ |
582 |
|
583 |
]b4_c_function_def([yy_reduce_print], [static void], |
584 |
[[int yyrule], [yyrule]])[ |
585 |
{ |
586 |
int yyi; |
587 |
unsigned int yylno = yyrline[yyrule]; |
588 |
YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ", |
589 |
yyrule - 1, yylno); |
590 |
/* Print the symbols being reduced, and their result. */ |
591 |
for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++) |
592 |
YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]); |
593 |
YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]); |
594 |
} |
595 |
|
596 |
# define YY_REDUCE_PRINT(Rule) \ |
597 |
do { \ |
598 |
if (yydebug) \ |
599 |
yy_reduce_print (Rule); \ |
600 |
} while (0) |
601 |
|
602 |
/* Nonzero means print parse trace. It is left uninitialized so that |
603 |
multiple parsers can coexist. */ |
604 |
int yydebug; |
605 |
#else /* !YYDEBUG */ |
606 |
# define YYDPRINTF(Args) |
607 |
# define YYDSYMPRINT(Args) |
608 |
# define YYDSYMPRINTF(Title, Token, Value, Location) |
609 |
# define YY_STACK_PRINT(Bottom, Top) |
610 |
# define YY_REDUCE_PRINT(Rule) |
611 |
#endif /* !YYDEBUG */ |
612 |
|
613 |
|
614 |
/* YYINITDEPTH -- initial size of the parser's stacks. */ |
615 |
#ifndef YYINITDEPTH |
616 |
# define YYINITDEPTH ]b4_stack_depth_init[ |
617 |
#endif |
618 |
|
619 |
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only |
620 |
if the built-in stack extension method is used). |
621 |
|
622 |
Do not make this value too large; the results are undefined if |
623 |
SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH) |
624 |
evaluated with infinite-precision integer arithmetic. */ |
625 |
|
626 |
#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0 |
627 |
# undef YYMAXDEPTH |
628 |
#endif |
629 |
|
630 |
#ifndef YYMAXDEPTH |
631 |
# define YYMAXDEPTH ]b4_stack_depth_max[ |
632 |
#endif |
633 |
|
634 |
|
635 |
|
636 |
#if YYERROR_VERBOSE |
637 |
|
638 |
# ifndef yystrlen |
639 |
# if defined (__GLIBC__) && defined (_STRING_H) |
640 |
# define yystrlen strlen |
641 |
# else |
642 |
/* Return the length of YYSTR. */ |
643 |
static YYSIZE_T |
644 |
# if defined (__STDC__) || defined (__cplusplus) |
645 |
yystrlen (const char *yystr) |
646 |
# else |
647 |
yystrlen (yystr) |
648 |
const char *yystr; |
649 |
# endif |
650 |
{ |
651 |
register const char *yys = yystr; |
652 |
|
653 |
while (*yys++ != '\0') |
654 |
continue; |
655 |
|
656 |
return yys - yystr - 1; |
657 |
} |
658 |
# endif |
659 |
# endif |
660 |
|
661 |
# ifndef yystpcpy |
662 |
# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE) |
663 |
# define yystpcpy stpcpy |
664 |
# else |
665 |
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in |
666 |
YYDEST. */ |
667 |
static char * |
668 |
# if defined (__STDC__) || defined (__cplusplus) |
669 |
yystpcpy (char *yydest, const char *yysrc) |
670 |
# else |
671 |
yystpcpy (yydest, yysrc) |
672 |
char *yydest; |
673 |
const char *yysrc; |
674 |
# endif |
675 |
{ |
676 |
register char *yyd = yydest; |
677 |
register const char *yys = yysrc; |
678 |
|
679 |
while ((*yyd++ = *yys++) != '\0') |
680 |
continue; |
681 |
|
682 |
return yyd - 1; |
683 |
} |
684 |
# endif |
685 |
# endif |
686 |
|
687 |
#endif /* !YYERROR_VERBOSE */ |
688 |
|
689 |
|
690 |
|
691 |
#if YYDEBUG |
692 |
]b4_yysymprint_generate([b4_c_function_def])[ |
693 |
#endif /* ! YYDEBUG */ |
694 |
]b4_yydestruct_generate([b4_c_function_def]) |
695 |
|
696 |
|
697 |
/* Prevent warnings from -Wmissing-prototypes. */ |
698 |
|
699 |
#ifdef YYPARSE_PARAM |
700 |
# if defined (__STDC__) || defined (__cplusplus) |
701 |
int yyparse (void *YYPARSE_PARAM); |
702 |
# else |
703 |
int yyparse (); |
704 |
# endif |
705 |
#else /* ! YYPARSE_PARAM */ |
706 |
b4_c_function_decl([yyparse], [int], b4_parse_param) |
707 |
#endif /* ! YYPARSE_PARAM */ |
708 |
|
709 |
|
710 |
m4_divert_push([KILL])# ======================== M4 code. |
711 |
# b4_declare_parser_variables |
712 |
# --------------------------- |
713 |
# Declare the variables that are global, or local to YYPARSE if |
714 |
# pure-parser. |
715 |
m4_define([b4_declare_parser_variables], |
716 |
[/* The lookahead symbol. */ |
717 |
int yychar; |
718 |
|
719 |
/* The semantic value of the lookahead symbol. */ |
720 |
YYSTYPE yylval; |
721 |
|
722 |
/* Number of syntax errors so far. */ |
723 |
int yynerrs;b4_location_if([ |
724 |
/* Location data for the lookahead symbol. */ |
725 |
YYLTYPE yylloc;]) |
726 |
]) |
727 |
m4_divert_pop([KILL])dnl# ====================== End of M4 code. |
728 |
|
729 |
b4_pure_if([], |
730 |
[b4_declare_parser_variables]) |
731 |
|
732 |
|
733 |
/*----------. |
734 |
| yyparse. | |
735 |
`----------*/ |
736 |
|
737 |
#ifdef YYPARSE_PARAM |
738 |
# if defined (__STDC__) || defined (__cplusplus) |
739 |
int yyparse (void *YYPARSE_PARAM) |
740 |
# else |
741 |
int yyparse (YYPARSE_PARAM) |
742 |
void *YYPARSE_PARAM; |
743 |
# endif |
744 |
#else /* ! YYPARSE_PARAM */ |
745 |
b4_c_function_def([yyparse], [int], b4_parse_param) |
746 |
#endif |
747 |
{[ |
748 |
]b4_pure_if([b4_declare_parser_variables])[ |
749 |
register int yystate; |
750 |
register int yyn; |
751 |
int yyresult; |
752 |
/* Number of tokens to shift before error messages enabled. */ |
753 |
int yyerrstatus; |
754 |
/* Lookahead token as an internal (translated) token number. */ |
755 |
int yytoken = 0; |
756 |
|
757 |
/* Three stacks and their tools: |
758 |
`yyss': related to states, |
759 |
`yyvs': related to semantic values, |
760 |
`yyls': related to locations. |
761 |
|
762 |
Refer to the stacks thru separate pointers, to allow yyoverflow |
763 |
to reallocate them elsewhere. */ |
764 |
|
765 |
/* The state stack. */ |
766 |
short yyssa[YYINITDEPTH]; |
767 |
short *yyss = yyssa; |
768 |
register short *yyssp; |
769 |
|
770 |
/* The semantic value stack. */ |
771 |
YYSTYPE yyvsa[YYINITDEPTH]; |
772 |
YYSTYPE *yyvs = yyvsa; |
773 |
register YYSTYPE *yyvsp; |
774 |
|
775 |
]b4_location_if( |
776 |
[[ /* The location stack. */ |
777 |
YYLTYPE yylsa[YYINITDEPTH]; |
778 |
YYLTYPE *yyls = yylsa; |
779 |
YYLTYPE *yylsp; |
780 |
YYLTYPE *yylerrsp;]])[ |
781 |
|
782 |
#define YYPOPSTACK (yyvsp--, yyssp--]b4_location_if([, yylsp--])[) |
783 |
|
784 |
YYSIZE_T yystacksize = YYINITDEPTH; |
785 |
|
786 |
/* The variables used to return semantic value and location from the |
787 |
action routines. */ |
788 |
YYSTYPE yyval; |
789 |
]b4_location_if([ YYLTYPE yyloc;])[ |
790 |
|
791 |
/* When reducing, the number of symbols on the RHS of the reduced |
792 |
rule. */ |
793 |
int yylen; |
794 |
|
795 |
YYDPRINTF ((stderr, "Starting parse\n")); |
796 |
|
797 |
yystate = 0; |
798 |
yyerrstatus = 0; |
799 |
yynerrs = 0; |
800 |
yychar = YYEMPTY; /* Cause a token to be read. */ |
801 |
|
802 |
/* Initialize stack pointers. |
803 |
Waste one element of value and location stack |
804 |
so that they stay on the same level as the state stack. |
805 |
The wasted elements are never initialized. */ |
806 |
|
807 |
yyssp = yyss; |
808 |
yyvsp = yyvs; |
809 |
]b4_location_if([ yylsp = yyls;])[ |
810 |
]m4_ifdef([b4_initial_action], [ |
811 |
m4_pushdef([b4_at_dollar], [(*yylsp)])dnl |
812 |
m4_pushdef([b4_dollar_dollar], [(*yyvsp)])dnl |
813 |
/* User initialization code. */ |
814 |
b4_initial_action |
815 |
m4_popdef([b4_dollar_dollar])dnl |
816 |
m4_popdef([b4_at_dollar])dnl |
817 |
/* Line __line__ of yacc.c. */ |
818 |
b4_syncline([@oline@], [@ofile@])])dnl |
819 |
|
820 |
[ goto yysetstate; |
821 |
|
822 |
/*------------------------------------------------------------. |
823 |
| yynewstate -- Push a new state, which is found in yystate. | |
824 |
`------------------------------------------------------------*/ |
825 |
yynewstate: |
826 |
/* In all cases, when you get here, the value and location stacks |
827 |
have just been pushed. so pushing a state here evens the stacks. |
828 |
*/ |
829 |
yyssp++; |
830 |
|
831 |
yysetstate: |
832 |
*yyssp = yystate; |
833 |
|
834 |
if (yyss + yystacksize - 1 <= yyssp) |
835 |
{ |
836 |
/* Get the current used size of the three stacks, in elements. */ |
837 |
YYSIZE_T yysize = yyssp - yyss + 1; |
838 |
|
839 |
#ifdef yyoverflow |
840 |
{ |
841 |
/* Give user a chance to reallocate the stack. Use copies of |
842 |
these so that the &'s don't force the real ones into |
843 |
memory. */ |
844 |
YYSTYPE *yyvs1 = yyvs; |
845 |
short *yyss1 = yyss; |
846 |
]b4_location_if([ YYLTYPE *yyls1 = yyls;])[ |
847 |
|
848 |
/* Each stack pointer address is followed by the size of the |
849 |
data in use in that stack, in bytes. This used to be a |
850 |
conditional around just the two extra args, but that might |
851 |
be undefined if yyoverflow is a macro. */ |
852 |
yyoverflow ("parser stack overflow", |
853 |
&yyss1, yysize * sizeof (*yyssp), |
854 |
&yyvs1, yysize * sizeof (*yyvsp), |
855 |
]b4_location_if([ &yyls1, yysize * sizeof (*yylsp),])[ |
856 |
&yystacksize); |
857 |
]b4_location_if([ yyls = yyls1;])[ |
858 |
yyss = yyss1; |
859 |
yyvs = yyvs1; |
860 |
} |
861 |
#else /* no yyoverflow */ |
862 |
# ifndef YYSTACK_RELOCATE |
863 |
goto yyoverflowlab; |
864 |
# else |
865 |
/* Extend the stack our own way. */ |
866 |
if (YYMAXDEPTH <= yystacksize) |
867 |
goto yyoverflowlab; |
868 |
yystacksize *= 2; |
869 |
if (YYMAXDEPTH < yystacksize) |
870 |
yystacksize = YYMAXDEPTH; |
871 |
|
872 |
{ |
873 |
short *yyss1 = yyss; |
874 |
union yyalloc *yyptr = |
875 |
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize)); |
876 |
if (! yyptr) |
877 |
goto yyoverflowlab; |
878 |
YYSTACK_RELOCATE (yyss); |
879 |
YYSTACK_RELOCATE (yyvs); |
880 |
]b4_location_if([ YYSTACK_RELOCATE (yyls);])[ |
881 |
# undef YYSTACK_RELOCATE |
882 |
if (yyss1 != yyssa) |
883 |
YYSTACK_FREE (yyss1); |
884 |
} |
885 |
# endif |
886 |
#endif /* no yyoverflow */ |
887 |
|
888 |
yyssp = yyss + yysize - 1; |
889 |
yyvsp = yyvs + yysize - 1; |
890 |
]b4_location_if([ yylsp = yyls + yysize - 1;])[ |
891 |
|
892 |
YYDPRINTF ((stderr, "Stack size increased to %lu\n", |
893 |
(unsigned long int) yystacksize)); |
894 |
|
895 |
if (yyss + yystacksize - 1 <= yyssp) |
896 |
YYABORT; |
897 |
} |
898 |
|
899 |
YYDPRINTF ((stderr, "Entering state %d\n", yystate)); |
900 |
|
901 |
goto yybackup; |
902 |
|
903 |
/*-----------. |
904 |
| yybackup. | |
905 |
`-----------*/ |
906 |
yybackup: |
907 |
|
908 |
/* Do appropriate processing given the current state. */ |
909 |
/* Read a lookahead token if we need one and don't already have one. */ |
910 |
/* yyresume: */ |
911 |
|
912 |
/* First try to decide what to do without reference to lookahead token. */ |
913 |
|
914 |
yyn = yypact[yystate]; |
915 |
if (yyn == YYPACT_NINF) |
916 |
goto yydefault; |
917 |
|
918 |
/* Not known => get a lookahead token if don't already have one. */ |
919 |
|
920 |
/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */ |
921 |
if (yychar == YYEMPTY) |
922 |
{ |
923 |
YYDPRINTF ((stderr, "Reading a token: ")); |
924 |
yychar = YYLEX; |
925 |
} |
926 |
|
927 |
if (yychar <= YYEOF) |
928 |
{ |
929 |
yychar = yytoken = YYEOF; |
930 |
YYDPRINTF ((stderr, "Now at end of input.\n")); |
931 |
} |
932 |
else |
933 |
{ |
934 |
yytoken = YYTRANSLATE (yychar); |
935 |
YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc); |
936 |
} |
937 |
|
938 |
/* If the proper action on seeing token YYTOKEN is to reduce or to |
939 |
detect an error, take that action. */ |
940 |
yyn += yytoken; |
941 |
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) |
942 |
goto yydefault; |
943 |
yyn = yytable[yyn]; |
944 |
if (yyn <= 0) |
945 |
{ |
946 |
if (yyn == 0 || yyn == YYTABLE_NINF) |
947 |
goto yyerrlab; |
948 |
yyn = -yyn; |
949 |
goto yyreduce; |
950 |
} |
951 |
|
952 |
if (yyn == YYFINAL) |
953 |
YYACCEPT; |
954 |
|
955 |
/* Shift the lookahead token. */ |
956 |
YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken])); |
957 |
|
958 |
/* Discard the token being shifted unless it is eof. */ |
959 |
if (yychar != YYEOF) |
960 |
yychar = YYEMPTY; |
961 |
|
962 |
*++yyvsp = yylval; |
963 |
]b4_location_if([ *++yylsp = yylloc;])[ |
964 |
|
965 |
/* Count tokens shifted since error; after three, turn off error |
966 |
status. */ |
967 |
if (yyerrstatus) |
968 |
yyerrstatus--; |
969 |
|
970 |
yystate = yyn; |
971 |
goto yynewstate; |
972 |
|
973 |
|
974 |
/*-----------------------------------------------------------. |
975 |
| yydefault -- do the default action for the current state. | |
976 |
`-----------------------------------------------------------*/ |
977 |
yydefault: |
978 |
yyn = yydefact[yystate]; |
979 |
if (yyn == 0) |
980 |
goto yyerrlab; |
981 |
goto yyreduce; |
982 |
|
983 |
|
984 |
/*-----------------------------. |
985 |
| yyreduce -- Do a reduction. | |
986 |
`-----------------------------*/ |
987 |
yyreduce: |
988 |
/* yyn is the number of a rule to reduce with. */ |
989 |
yylen = yyr2[yyn]; |
990 |
|
991 |
/* If YYLEN is nonzero, implement the default value of the action: |
992 |
`$$ = $1'. |
993 |
|
994 |
Otherwise, the following line sets YYVAL to garbage. |
995 |
This behavior is undocumented and Bison |
996 |
users should not rely upon it. Assigning to YYVAL |
997 |
unconditionally makes the parser a bit smaller, and it avoids a |
998 |
GCC warning that YYVAL may be used uninitialized. */ |
999 |
yyval = yyvsp[1-yylen]; |
1000 |
|
1001 |
]b4_location_if( |
1002 |
[ /* Default location. */ |
1003 |
YYLLOC_DEFAULT (yyloc, yylsp - yylen, yylen);])[ |
1004 |
YY_REDUCE_PRINT (yyn); |
1005 |
switch (yyn) |
1006 |
]{ |
1007 |
b4_actions |
1008 |
} |
1009 |
|
1010 |
/* Line __line__ of yacc.c. */ |
1011 |
b4_syncline([@oline@], [@ofile@]) |
1012 |
|
1013 |
[ yyvsp -= yylen; |
1014 |
yyssp -= yylen; |
1015 |
]b4_location_if([ yylsp -= yylen;])[ |
1016 |
|
1017 |
YY_STACK_PRINT (yyss, yyssp); |
1018 |
|
1019 |
*++yyvsp = yyval; |
1020 |
]b4_location_if([ *++yylsp = yyloc;])[ |
1021 |
|
1022 |
/* Now `shift' the result of the reduction. Determine what state |
1023 |
that goes to, based on the state we popped back to and the rule |
1024 |
number reduced by. */ |
1025 |
|
1026 |
yyn = yyr1[yyn]; |
1027 |
|
1028 |
yystate = yypgoto[yyn - YYNTOKENS] + *yyssp; |
1029 |
if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp) |
1030 |
yystate = yytable[yystate]; |
1031 |
else |
1032 |
yystate = yydefgoto[yyn - YYNTOKENS]; |
1033 |
|
1034 |
goto yynewstate; |
1035 |
|
1036 |
|
1037 |
/*------------------------------------. |
1038 |
| yyerrlab -- here on detecting error | |
1039 |
`------------------------------------*/ |
1040 |
yyerrlab: |
1041 |
/* If not already recovering from an error, report this error. */ |
1042 |
if (!yyerrstatus) |
1043 |
{ |
1044 |
++yynerrs; |
1045 |
#if YYERROR_VERBOSE |
1046 |
yyn = yypact[yystate]; |
1047 |
|
1048 |
if (YYPACT_NINF < yyn && yyn < YYLAST) |
1049 |
{ |
1050 |
YYSIZE_T yysize = 0; |
1051 |
int yytype = YYTRANSLATE (yychar); |
1052 |
const char* yyprefix; |
1053 |
char *yymsg; |
1054 |
int yyx; |
1055 |
|
1056 |
/* Start YYX at -YYN if negative to avoid negative indexes in |
1057 |
YYCHECK. */ |
1058 |
int yyxbegin = yyn < 0 ? -yyn : 0; |
1059 |
|
1060 |
/* Stay within bounds of both yycheck and yytname. */ |
1061 |
int yychecklim = YYLAST - yyn; |
1062 |
int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS; |
1063 |
int yycount = 0; |
1064 |
|
1065 |
yyprefix = ", expecting "; |
1066 |
for (yyx = yyxbegin; yyx < yyxend; ++yyx) |
1067 |
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
1068 |
{ |
1069 |
yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]); |
1070 |
yycount += 1; |
1071 |
if (yycount == 5) |
1072 |
{ |
1073 |
yysize = 0; |
1074 |
break; |
1075 |
} |
1076 |
} |
1077 |
yysize += (sizeof ("syntax error, unexpected ") |
1078 |
+ yystrlen (yytname[yytype])); |
1079 |
yymsg = (char *) YYSTACK_ALLOC (yysize); |
1080 |
if (yymsg != 0) |
1081 |
{ |
1082 |
char *yyp = yystpcpy (yymsg, "syntax error, unexpected "); |
1083 |
yyp = yystpcpy (yyp, yytname[yytype]); |
1084 |
|
1085 |
if (yycount < 5) |
1086 |
{ |
1087 |
yyprefix = ", expecting "; |
1088 |
for (yyx = yyxbegin; yyx < yyxend; ++yyx) |
1089 |
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR) |
1090 |
{ |
1091 |
yyp = yystpcpy (yyp, yyprefix); |
1092 |
yyp = yystpcpy (yyp, yytname[yyx]); |
1093 |
yyprefix = " or "; |
1094 |
} |
1095 |
} |
1096 |
yyerror (]b4_yyerror_args[yymsg); |
1097 |
YYSTACK_FREE (yymsg); |
1098 |
} |
1099 |
else |
1100 |
yyerror (]b4_yyerror_args["syntax error; also virtual memory exhausted"); |
1101 |
} |
1102 |
else |
1103 |
#endif /* YYERROR_VERBOSE */ |
1104 |
yyerror (]b4_yyerror_args["syntax error"); |
1105 |
} |
1106 |
|
1107 |
]b4_location_if([ yylerrsp = yylsp;])[ |
1108 |
|
1109 |
if (yyerrstatus == 3) |
1110 |
{ |
1111 |
/* If just tried and failed to reuse lookahead token after an |
1112 |
error, discard it. */ |
1113 |
|
1114 |
if (yychar <= YYEOF) |
1115 |
{ |
1116 |
/* If at end of input, pop the error token, |
1117 |
then the rest of the stack, then return failure. */ |
1118 |
if (yychar == YYEOF) |
1119 |
for (;;) |
1120 |
{ |
1121 |
YYPOPSTACK; |
1122 |
if (yyssp == yyss) |
1123 |
YYABORT; |
1124 |
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); |
1125 |
yydestruct (yystos[*yyssp], yyvsp]b4_location_if([, yylsp])[); |
1126 |
} |
1127 |
} |
1128 |
else |
1129 |
{ |
1130 |
YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc); |
1131 |
yydestruct (yytoken, &yylval]b4_location_if([, &yylloc])[); |
1132 |
yychar = YYEMPTY; |
1133 |
]b4_location_if([ *++yylerrsp = yylloc;])[ |
1134 |
} |
1135 |
} |
1136 |
|
1137 |
/* Else will try to reuse lookahead token after shifting the error |
1138 |
token. */ |
1139 |
goto yyerrlab1; |
1140 |
|
1141 |
|
1142 |
/*---------------------------------------------------. |
1143 |
| yyerrorlab -- error raised explicitly by YYERROR. | |
1144 |
`---------------------------------------------------*/ |
1145 |
yyerrorlab: |
1146 |
|
1147 |
#ifdef __GNUC__ |
1148 |
/* Pacify GCC when the user code never invokes YYERROR and the label |
1149 |
yyerrorlab therefore never appears in user code. */ |
1150 |
if (0) |
1151 |
goto yyerrorlab; |
1152 |
#endif |
1153 |
|
1154 |
yyvsp -= yylen; |
1155 |
yyssp -= yylen; |
1156 |
yystate = *yyssp; |
1157 |
]b4_location_if([yylerrsp = yylsp; |
1158 |
*++yylerrsp = yyloc; |
1159 |
yylsp -= yylen; |
1160 |
])[goto yyerrlab1; |
1161 |
|
1162 |
|
1163 |
/*-------------------------------------------------------------. |
1164 |
| yyerrlab1 -- common code for both syntax error and YYERROR. | |
1165 |
`-------------------------------------------------------------*/ |
1166 |
yyerrlab1: |
1167 |
yyerrstatus = 3; /* Each real token shifted decrements this. */ |
1168 |
|
1169 |
for (;;) |
1170 |
{ |
1171 |
yyn = yypact[yystate]; |
1172 |
if (yyn != YYPACT_NINF) |
1173 |
{ |
1174 |
yyn += YYTERROR; |
1175 |
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR) |
1176 |
{ |
1177 |
yyn = yytable[yyn]; |
1178 |
if (0 < yyn) |
1179 |
break; |
1180 |
} |
1181 |
} |
1182 |
|
1183 |
/* Pop the current state because it cannot handle the error token. */ |
1184 |
if (yyssp == yyss) |
1185 |
YYABORT; |
1186 |
|
1187 |
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp); |
1188 |
yydestruct (yystos[yystate], yyvsp]b4_location_if([, yylsp])[); |
1189 |
YYPOPSTACK; |
1190 |
yystate = *yyssp; |
1191 |
YY_STACK_PRINT (yyss, yyssp); |
1192 |
} |
1193 |
|
1194 |
if (yyn == YYFINAL) |
1195 |
YYACCEPT; |
1196 |
|
1197 |
YYDPRINTF ((stderr, "Shifting error token, ")); |
1198 |
|
1199 |
*++yyvsp = yylval; |
1200 |
]b4_location_if([ YYLLOC_DEFAULT (yyloc, yylsp, yylerrsp - yylsp); |
1201 |
*++yylsp = yyloc;])[ |
1202 |
|
1203 |
yystate = yyn; |
1204 |
goto yynewstate; |
1205 |
|
1206 |
|
1207 |
/*-------------------------------------. |
1208 |
| yyacceptlab -- YYACCEPT comes here. | |
1209 |
`-------------------------------------*/ |
1210 |
yyacceptlab: |
1211 |
yyresult = 0; |
1212 |
goto yyreturn; |
1213 |
|
1214 |
/*-----------------------------------. |
1215 |
| yyabortlab -- YYABORT comes here. | |
1216 |
`-----------------------------------*/ |
1217 |
yyabortlab: |
1218 |
yyresult = 1; |
1219 |
goto yyreturn; |
1220 |
|
1221 |
#ifndef yyoverflow |
1222 |
/*----------------------------------------------. |
1223 |
| yyoverflowlab -- parser overflow comes here. | |
1224 |
`----------------------------------------------*/ |
1225 |
yyoverflowlab: |
1226 |
yyerror (]b4_yyerror_args["parser stack overflow"); |
1227 |
yyresult = 2; |
1228 |
/* Fall through. */ |
1229 |
#endif |
1230 |
|
1231 |
yyreturn: |
1232 |
#ifndef yyoverflow |
1233 |
if (yyss != yyssa) |
1234 |
YYSTACK_FREE (yyss); |
1235 |
#endif |
1236 |
return yyresult; |
1237 |
]} |
1238 |
|
1239 |
|
1240 |
b4_epilogue |
1241 |
m4_if(b4_defines_flag, 0, [], |
1242 |
[@output @output_header_name@ |
1243 |
b4_copyright([Skeleton parser for Yacc-like parsing with Bison], |
1244 |
[1984, 1989, 1990, 2000, 2001, 2002, 2003]) |
1245 |
|
1246 |
/* As a special exception, when this file is copied by Bison into a |
1247 |
Bison output file, you may use that output file without restriction. |
1248 |
This special exception was added by the Free Software Foundation |
1249 |
in version 1.24 of Bison. */ |
1250 |
|
1251 |
b4_token_defines(b4_tokens) |
1252 |
|
1253 |
#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED) |
1254 |
m4_ifdef([b4_stype], |
1255 |
[b4_syncline([b4_stype_line], [b4_filename]) |
1256 |
typedef union m4_bregexp(b4_stype, [^{], [YYSTYPE ])b4_stype YYSTYPE; |
1257 |
/* Line __line__ of yacc.c. */ |
1258 |
b4_syncline([@oline@], [@ofile@])], |
1259 |
[typedef int YYSTYPE;]) |
1260 |
# define yystype YYSTYPE /* obsolescent; will be withdrawn */ |
1261 |
# define YYSTYPE_IS_DECLARED 1 |
1262 |
# define YYSTYPE_IS_TRIVIAL 1 |
1263 |
#endif |
1264 |
|
1265 |
b4_pure_if([], |
1266 |
[extern YYSTYPE b4_prefix[]lval;]) |
1267 |
|
1268 |
b4_location_if( |
1269 |
[#if ! defined (YYLTYPE) && ! defined (YYLTYPE_IS_DECLARED) |
1270 |
typedef struct YYLTYPE |
1271 |
{ |
1272 |
int first_line; |
1273 |
int first_column; |
1274 |
int last_line; |
1275 |
int last_column; |
1276 |
} YYLTYPE; |
1277 |
# define yyltype YYLTYPE /* obsolescent; will be withdrawn */ |
1278 |
# define YYLTYPE_IS_DECLARED 1 |
1279 |
# define YYLTYPE_IS_TRIVIAL 1 |
1280 |
#endif |
1281 |
|
1282 |
m4_if(b4_pure, [0], |
1283 |
[extern YYLTYPE b4_prefix[]lloc;]) |
1284 |
]) |
1285 |
]) |