1 /* $NetBSD: btyacc_destroy1.tab.c,v 1.1.1.1 2015/01/03 22:58:24 christos Exp $ */
2
3 /* original parser id follows */
4 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
5 /* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
6
7 #define YYBYACC 1
8 #define YYMAJOR 1
9 #define YYMINOR 9
10 #define YYCHECK "yyyymmdd"
11
12 #define YYEMPTY (-1)
13 #define yyclearin (yychar = YYEMPTY)
14 #define yyerrok (yyerrflag = 0)
15 #define YYRECOVERING() (yyerrflag != 0)
16 #define YYENOMEM (-2)
17 #define YYEOF 0
18 #undef YYBTYACC
19 #define YYBTYACC 1
20 #define YYDEBUGSTR (yytrial ? YYPREFIX "debug(trial)" : YYPREFIX "debug")
21
22 #ifndef yyparse
23 #define yyparse destroy1_parse
24 #endif /* yyparse */
25
26 #ifndef yylex
27 #define yylex destroy1_lex
28 #endif /* yylex */
29
30 #ifndef yyerror
31 #define yyerror destroy1_error
32 #endif /* yyerror */
33
34 #ifndef yychar
35 #define yychar destroy1_char
36 #endif /* yychar */
37
38 #ifndef yyval
39 #define yyval destroy1_val
40 #endif /* yyval */
41
42 #ifndef yylval
43 #define yylval destroy1_lval
44 #endif /* yylval */
45
46 #ifndef yydebug
47 #define yydebug destroy1_debug
48 #endif /* yydebug */
49
50 #ifndef yynerrs
51 #define yynerrs destroy1_nerrs
52 #endif /* yynerrs */
53
54 #ifndef yyerrflag
55 #define yyerrflag destroy1_errflag
56 #endif /* yyerrflag */
57
58 #ifndef yylhs
59 #define yylhs destroy1_lhs
60 #endif /* yylhs */
61
62 #ifndef yylen
63 #define yylen destroy1_len
64 #endif /* yylen */
65
66 #ifndef yydefred
67 #define yydefred destroy1_defred
68 #endif /* yydefred */
69
70 #ifndef yystos
71 #define yystos destroy1_stos
72 #endif /* yystos */
73
74 #ifndef yydgoto
75 #define yydgoto destroy1_dgoto
76 #endif /* yydgoto */
77
78 #ifndef yysindex
79 #define yysindex destroy1_sindex
80 #endif /* yysindex */
81
82 #ifndef yyrindex
83 #define yyrindex destroy1_rindex
84 #endif /* yyrindex */
85
86 #ifndef yygindex
87 #define yygindex destroy1_gindex
88 #endif /* yygindex */
89
90 #ifndef yytable
91 #define yytable destroy1_table
92 #endif /* yytable */
93
94 #ifndef yycheck
95 #define yycheck destroy1_check
96 #endif /* yycheck */
97
98 #ifndef yyname
99 #define yyname destroy1_name
100 #endif /* yyname */
101
102 #ifndef yyrule
103 #define yyrule destroy1_rule
104 #endif /* yyrule */
105
106 #if YYBTYACC
107
108 #ifndef yycindex
109 #define yycindex destroy1_cindex
110 #endif /* yycindex */
111
112 #ifndef yyctable
113 #define yyctable destroy1_ctable
114 #endif /* yyctable */
115
116 #endif /* YYBTYACC */
117
118 #define YYPREFIX "destroy1_"
119
120 #define YYPURE 0
121
122 #line 4 "btyacc_destroy1.y"
123 #include <stdlib.h>
124
125 typedef enum {cGLOBAL, cLOCAL} class;
126 typedef enum {tREAL, tINTEGER} type;
127 typedef char * name;
128
129 struct symbol { class c; type t; name id; };
130 typedef struct symbol symbol;
131
132 struct namelist { symbol *s; struct namelist *next; };
133 typedef struct namelist namelist;
134
135 struct parser_param {
136 int *rtrn;
137 symbol ss;
138 };
139
140 extern symbol *mksymbol(type t, class c, name id);
141
142 #ifdef YYBISON
143 #define YYLEX_DECL() yylex(void)
144 #define YYERROR_DECL() yyerror(const char *s)
145 #endif
146 #line 50 "btyacc_destroy1.y"
147 #ifdef YYSTYPE
148 #undef YYSTYPE_IS_DECLARED
149 #define YYSTYPE_IS_DECLARED 1
150 #endif
151 #ifndef YYSTYPE_IS_DECLARED
152 #define YYSTYPE_IS_DECLARED 1
153 typedef union
154 {
155 class cval;
156 type tval;
157 namelist * nlist;
158 name id;
159 } YYSTYPE;
160 #endif /* !YYSTYPE_IS_DECLARED */
161 #line 160 "btyacc_destroy1.tab.c"
162
163 /* compatibility with bison */
164 #ifdef YYPARSE_PARAM
165 /* compatibility with FreeBSD */
166 # ifdef YYPARSE_PARAM_TYPE
167 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
168 # else
169 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
170 # endif
171 #else
172 # define YYPARSE_DECL() yyparse(struct parser_param *param, int flag)
173 #endif
174
175 /* Parameters sent to lex. */
176 #ifdef YYLEX_PARAM
177 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
178 # define YYLEX yylex(YYLEX_PARAM)
179 #else
180 # define YYLEX_DECL() yylex(void)
181 # define YYLEX yylex()
182 #endif
183
184 /* Parameters sent to yyerror. */
185 #ifndef YYERROR_DECL
186 #define YYERROR_DECL() yyerror(struct parser_param *param, int flag, const char *s)
187 #endif
188 #ifndef YYERROR_CALL
189 #define YYERROR_CALL(msg) yyerror(param, flag, msg)
190 #endif
191
192 #ifndef YYDESTRUCT_DECL
193 #define YYDESTRUCT_DECL() yydestruct(const char *msg, int psymb, YYSTYPE *val, struct parser_param *param, int flag)
194 #endif
195 #ifndef YYDESTRUCT_CALL
196 #define YYDESTRUCT_CALL(msg, psymb, val) yydestruct(msg, psymb, val, param, flag)
197 #endif
198
199 extern int YYPARSE_DECL();
200
201 #define GLOBAL 257
202 #define LOCAL 258
203 #define REAL 259
204 #define INTEGER 260
205 #define NAME 261
206 #define YYERRCODE 256
207 typedef short YYINT;
208 static const YYINT destroy1_lhs[] = { -1,
209 0, 0, 2, 2, 3, 3, 4, 4, 1,
210 };
211 static const YYINT destroy1_len[] = { 2,
212 8, 5, 1, 1, 1, 1, 2, 1, 6,
213 };
214 static const YYINT destroy1_defred[] = { 0,
215 3, 4, 5, 6, 0, 0, 0, 0, 8, 0,
216 0, 0, 0, 7, 0, 0, 0, 0, 0, 2,
217 0, 0, 0, 0, 9, 1,
218 };
219 static const YYINT destroy1_stos[] = { 0,
220 257, 258, 259, 260, 263, 265, 266, 266, 261, 264,
221 267, 267, 40, 261, 40, 40, 265, 258, 265, 41,
222 44, 44, 266, 266, 41, 41,
223 };
224 static const YYINT destroy1_dgoto[] = { 5,
225 10, 6, 7, 11,
226 };
227 static const YYINT destroy1_sindex[] = { -254,
228 0, 0, 0, 0, 0, -251, -248, -248, 0, -26,
229 -40, -39, -246, 0, -243, -246, -25, -24, -23, 0,
230 -251, -251, -22, -19, 0, 0,
231 };
232 static const YYINT destroy1_rindex[] = { 0,
233 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
234 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
235 0, 0, 0, 0, 0, 0,
236 };
237 #if YYBTYACC
238 static const YYINT destroy1_cindex[] = { 0,
239 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
241 0, 0, 0, 0, 0, 0,
242 };
243 #endif
244 static const YYINT destroy1_gindex[] = { 0,
245 0, -6, -4, 15,
246 };
247 #define YYTABLESIZE 222
248 static const YYINT destroy1_table[] = { 15,
249 16, 8, 1, 2, 3, 4, 17, 3, 4, 19,
250 1, 2, 9, 13, 18, 20, 23, 24, 25, 21,
251 22, 26, 12, 0, 0, 0, 0, 0, 0, 0,
252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
253 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
254 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
256 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
257 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
258 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
259 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
260 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
261 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
262 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
263 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
264 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
265 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
266 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
267 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
268 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
269 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
270 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
271 14, 14,
272 };
273 static const YYINT destroy1_check[] = { 40,
274 40, 6, 257, 258, 259, 260, 13, 259, 260, 16,
275 257, 258, 261, 40, 258, 41, 21, 22, 41, 44,
276 44, 41, 8, -1, -1, -1, -1, -1, -1, -1,
277 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
278 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
279 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
280 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
281 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
282 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
283 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
284 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
285 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
286 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
287 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
288 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
289 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
290 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
291 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
292 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
293 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
294 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
295 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
296 261, 261,
297 };
298 #if YYBTYACC
299 static const YYINT destroy1_ctable[] = { -1,
300 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
301 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
302 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
303 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
304 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
305 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
306 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
307 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
308 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
309 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
310 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
311 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
312 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
313 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
314 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
315 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
316 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
317 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
318 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
319 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
320 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
321 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
322 -1,
323 };
324 #endif
325 #define YYFINAL 5
326 #ifndef YYDEBUG
327 #define YYDEBUG 0
328 #endif
329 #define YYMAXTOKEN 261
330 #define YYUNDFTOKEN 268
331 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
332 #if YYDEBUG
333 static const char *const destroy1_name[] = {
334
335 "$end",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
336 0,0,0,"'('","')'",0,0,"','",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
337 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
338 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
339 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
340 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
341 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"error","GLOBAL","LOCAL",
342 "REAL","INTEGER","NAME","$accept","declaration","locnamelist","class","type",
343 "namelist","illegal-symbol",
344 };
345 static const char *const destroy1_rule[] = {
346 "$accept : declaration",
347 "declaration : class type namelist '(' class ',' type ')'",
348 "declaration : type locnamelist '(' class ')'",
349 "class : GLOBAL",
350 "class : LOCAL",
351 "type : REAL",
352 "type : INTEGER",
353 "namelist : namelist NAME",
354 "namelist : NAME",
355 "locnamelist : namelist '(' LOCAL ',' type ')'",
356
357 };
358 #endif
359
360 int yydebug;
361 int yynerrs;
362
363 int yyerrflag;
364 int yychar;
365 YYSTYPE yyval;
366 YYSTYPE yylval;
367 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
368 YYLTYPE yyloc; /* position returned by actions */
369 YYLTYPE yylloc; /* position from the lexer */
370 #endif
371
372 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
373 #ifndef YYLLOC_DEFAULT
374 #define YYLLOC_DEFAULT(loc, rhs, n) \
375 do \
376 { \
377 if (n == 0) \
378 { \
379 (loc).first_line = ((rhs)[-1]).last_line; \
380 (loc).first_column = ((rhs)[-1]).last_column; \
381 (loc).last_line = ((rhs)[-1]).last_line; \
382 (loc).last_column = ((rhs)[-1]).last_column; \
383 } \
384 else \
385 { \
386 (loc).first_line = ((rhs)[ 0 ]).first_line; \
387 (loc).first_column = ((rhs)[ 0 ]).first_column; \
388 (loc).last_line = ((rhs)[n-1]).last_line; \
389 (loc).last_column = ((rhs)[n-1]).last_column; \
390 } \
391 } while (0)
392 #endif /* YYLLOC_DEFAULT */
393 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
394 #if YYBTYACC
395
396 #ifndef YYLVQUEUEGROWTH
397 #define YYLVQUEUEGROWTH 32
398 #endif
399 #endif /* YYBTYACC */
400
401 /* define the initial stack-sizes */
402 #ifdef YYSTACKSIZE
403 #undef YYMAXDEPTH
404 #define YYMAXDEPTH YYSTACKSIZE
405 #else
406 #ifdef YYMAXDEPTH
407 #define YYSTACKSIZE YYMAXDEPTH
408 #else
409 #define YYSTACKSIZE 10000
410 #define YYMAXDEPTH 10000
411 #endif
412 #endif
413
414 #ifndef YYINITSTACKSIZE
415 #define YYINITSTACKSIZE 200
416 #endif
417
418 typedef struct {
419 unsigned stacksize;
420 short *s_base;
421 short *s_mark;
422 short *s_last;
423 YYSTYPE *l_base;
424 YYSTYPE *l_mark;
425 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
426 YYLTYPE *p_base;
427 YYLTYPE *p_mark;
428 #endif
429 } YYSTACKDATA;
430 #if YYBTYACC
431
432 struct YYParseState_s
433 {
434 struct YYParseState_s *save; /* Previously saved parser state */
435 YYSTACKDATA yystack; /* saved parser stack */
436 int state; /* saved parser state */
437 int errflag; /* saved error recovery status */
438 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
439 YYINT ctry; /* saved index in yyctable[] for this conflict */
440 };
441 typedef struct YYParseState_s YYParseState;
442 #endif /* YYBTYACC */
443 /* variables for the parser stack */
444 static YYSTACKDATA yystack;
445 #if YYBTYACC
446
447 /* Current parser state */
448 static YYParseState *yyps = 0;
449
450 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
451 static YYParseState *yypath = 0;
452
453 /* Base of the lexical value queue */
454 static YYSTYPE *yylvals = 0;
455
456 /* Current position at lexical value queue */
457 static YYSTYPE *yylvp = 0;
458
459 /* End position of lexical value queue */
460 static YYSTYPE *yylve = 0;
461
462 /* The last allocated position at the lexical value queue */
463 static YYSTYPE *yylvlim = 0;
464
465 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
466 /* Base of the lexical position queue */
467 static YYLTYPE *yylpsns = 0;
468
469 /* Current position at lexical position queue */
470 static YYLTYPE *yylpp = 0;
471
472 /* End position of lexical position queue */
473 static YYLTYPE *yylpe = 0;
474
475 /* The last allocated position at the lexical position queue */
476 static YYLTYPE *yylplim = 0;
477 #endif
478
479 /* Current position at lexical token queue */
480 static short *yylexp = 0;
481
482 static short *yylexemes = 0;
483 #endif /* YYBTYACC */
484 #line 89 "btyacc_destroy1.y"
485
486 extern int YYLEX_DECL();
487 extern void YYERROR_DECL();
488 #line 487 "btyacc_destroy1.tab.c"
489
490 /* Release memory associated with symbol. */
491 #if ! defined YYDESTRUCT_IS_DECLARED
492 static void
YYDESTRUCT_DECL()493 YYDESTRUCT_DECL()
494 {
495 switch (psymb)
496 {
497 case 263:
498 #line 41 "btyacc_destroy1.y"
499 {
500 namelist *p = (*val).nlist;
501 while (p != NULL)
502 { namelist *pp = p;
503 p = p->next;
504 free(pp->s); free(pp);
505 }
506 }
507 break;
508 #line 507 "btyacc_destroy1.tab.c"
509 }
510 }
511 #define YYDESTRUCT_IS_DECLARED 1
512 #endif
513
514 /* For use in generated program */
515 #define yydepth (int)(yystack.s_mark - yystack.s_base)
516 #if YYBTYACC
517 #define yytrial (yyps->save)
518 #endif /* YYBTYACC */
519
520 #if YYDEBUG
521 #include <stdio.h> /* needed for printf */
522 #endif
523
524 #include <stdlib.h> /* needed for malloc, etc */
525 #include <string.h> /* needed for memset */
526
527 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
yygrowstack(YYSTACKDATA * data)528 static int yygrowstack(YYSTACKDATA *data)
529 {
530 int i;
531 unsigned newsize;
532 short *newss;
533 YYSTYPE *newvs;
534 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
535 YYLTYPE *newps;
536 #endif
537
538 if ((newsize = data->stacksize) == 0)
539 newsize = YYINITSTACKSIZE;
540 else if (newsize >= YYMAXDEPTH)
541 return YYENOMEM;
542 else if ((newsize *= 2) > YYMAXDEPTH)
543 newsize = YYMAXDEPTH;
544
545 i = (int) (data->s_mark - data->s_base);
546 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
547 if (newss == 0)
548 return YYENOMEM;
549
550 data->s_base = newss;
551 data->s_mark = newss + i;
552
553 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
554 if (newvs == 0)
555 return YYENOMEM;
556
557 data->l_base = newvs;
558 data->l_mark = newvs + i;
559
560 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
561 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
562 if (newps == 0)
563 return YYENOMEM;
564
565 data->p_base = newps;
566 data->p_mark = newps + i;
567 #endif
568
569 data->stacksize = newsize;
570 data->s_last = data->s_base + newsize - 1;
571
572 #if YYDEBUG
573 if (yydebug)
574 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
575 #endif
576 return 0;
577 }
578
579 #if YYPURE || defined(YY_NO_LEAKS)
yyfreestack(YYSTACKDATA * data)580 static void yyfreestack(YYSTACKDATA *data)
581 {
582 free(data->s_base);
583 free(data->l_base);
584 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
585 free(data->p_base);
586 #endif
587 memset(data, 0, sizeof(*data));
588 }
589 #else
590 #define yyfreestack(data) /* nothing */
591 #endif /* YYPURE || defined(YY_NO_LEAKS) */
592 #if YYBTYACC
593
594 static YYParseState *
yyNewState(unsigned size)595 yyNewState(unsigned size)
596 {
597 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
598 if (p == NULL) return NULL;
599
600 p->yystack.stacksize = size;
601 if (size == 0)
602 {
603 p->yystack.s_base = NULL;
604 p->yystack.l_base = NULL;
605 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
606 p->yystack.p_base = NULL;
607 #endif
608 return p;
609 }
610 p->yystack.s_base = (short *) malloc(size * sizeof(short));
611 if (p->yystack.s_base == NULL) return NULL;
612 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
613 if (p->yystack.l_base == NULL) return NULL;
614 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
615 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
616 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
617 if (p->yystack.p_base == NULL) return NULL;
618 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
619 #endif
620
621 return p;
622 }
623
624 static void
yyFreeState(YYParseState * p)625 yyFreeState(YYParseState *p)
626 {
627 yyfreestack(&p->yystack);
628 free(p);
629 }
630 #endif /* YYBTYACC */
631
632 #define YYABORT goto yyabort
633 #define YYREJECT goto yyabort
634 #define YYACCEPT goto yyaccept
635 #define YYERROR goto yyerrlab
636 #if YYBTYACC
637 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
638 #define YYVALID_NESTED do { if (yyps->save && \
639 yyps->save->save == 0) goto yyvalid; } while(0)
640 #endif /* YYBTYACC */
641
642 int
YYPARSE_DECL()643 YYPARSE_DECL()
644 {
645 int yym, yyn, yystate, yyresult;
646 #if YYBTYACC
647 int yynewerrflag;
648 YYParseState *yyerrctx = NULL;
649 #endif /* YYBTYACC */
650 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
651 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
652 #endif
653 #if YYDEBUG
654 const char *yys;
655
656 if ((yys = getenv("YYDEBUG")) != 0)
657 {
658 yyn = *yys;
659 if (yyn >= '0' && yyn <= '9')
660 yydebug = yyn - '0';
661 }
662 if (yydebug)
663 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
664 #endif
665
666 #if YYBTYACC
667 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
668 yyps->save = 0;
669 #endif /* YYBTYACC */
670 yynerrs = 0;
671 yyerrflag = 0;
672 yychar = YYEMPTY;
673 yystate = 0;
674
675 #if YYPURE
676 memset(&yystack, 0, sizeof(yystack));
677 #endif
678
679 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
680 yystack.s_mark = yystack.s_base;
681 yystack.l_mark = yystack.l_base;
682 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
683 yystack.p_mark = yystack.p_base;
684 #endif
685 yystate = 0;
686 *yystack.s_mark = 0;
687
688 yyloop:
689 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
690 if (yychar < 0)
691 {
692 #if YYBTYACC
693 do {
694 if (yylvp < yylve)
695 {
696 /* we're currently re-reading tokens */
697 yylval = *yylvp++;
698 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
699 yylloc = *yylpp++;
700 #endif
701 yychar = *yylexp++;
702 break;
703 }
704 if (yyps->save)
705 {
706 /* in trial mode; save scanner results for future parse attempts */
707 if (yylvp == yylvlim)
708 { /* Enlarge lexical value queue */
709 size_t p = (size_t) (yylvp - yylvals);
710 size_t s = (size_t) (yylvlim - yylvals);
711
712 s += YYLVQUEUEGROWTH;
713 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
714 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
715 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
716 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
717 #endif
718 yylvp = yylve = yylvals + p;
719 yylvlim = yylvals + s;
720 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
721 yylpp = yylpe = yylpsns + p;
722 yylplim = yylpsns + s;
723 #endif
724 yylexp = yylexemes + p;
725 }
726 *yylexp = (short) YYLEX;
727 *yylvp++ = yylval;
728 yylve++;
729 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
730 *yylpp++ = yylloc;
731 yylpe++;
732 #endif
733 yychar = *yylexp++;
734 break;
735 }
736 /* normal operation, no conflict encountered */
737 #endif /* YYBTYACC */
738 yychar = YYLEX;
739 #if YYBTYACC
740 } while (0);
741 #endif /* YYBTYACC */
742 if (yychar < 0) yychar = YYEOF;
743 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
744 #if YYDEBUG
745 if (yydebug)
746 {
747 yys = yyname[YYTRANSLATE(yychar)];
748 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
749 YYDEBUGSTR, yydepth, yystate, yychar, yys);
750 #ifdef YYSTYPE_TOSTRING
751 #if YYBTYACC
752 if (!yytrial)
753 #endif /* YYBTYACC */
754 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
755 #endif
756 fputc('\n', stderr);
757 }
758 #endif
759 }
760 #if YYBTYACC
761
762 /* Do we have a conflict? */
763 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
764 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
765 {
766 YYINT ctry;
767
768 if (yypath)
769 {
770 YYParseState *save;
771 #if YYDEBUG
772 if (yydebug)
773 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
774 YYDEBUGSTR, yydepth, yystate);
775 #endif
776 /* Switch to the next conflict context */
777 save = yypath;
778 yypath = save->save;
779 save->save = NULL;
780 ctry = save->ctry;
781 if (save->state != yystate) YYABORT;
782 yyFreeState(save);
783
784 }
785 else
786 {
787
788 /* Unresolved conflict - start/continue trial parse */
789 YYParseState *save;
790 #if YYDEBUG
791 if (yydebug)
792 {
793 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
794 if (yyps->save)
795 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
796 else
797 fputs("Starting trial parse.\n", stderr);
798 }
799 #endif
800 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
801 if (save == NULL) goto yyenomem;
802 save->save = yyps->save;
803 save->state = yystate;
804 save->errflag = yyerrflag;
805 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
806 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
807 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
808 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
809 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
810 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
811 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
812 #endif
813 ctry = yytable[yyn];
814 if (yyctable[ctry] == -1)
815 {
816 #if YYDEBUG
817 if (yydebug && yychar >= YYEOF)
818 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
819 #endif
820 ctry++;
821 }
822 save->ctry = ctry;
823 if (yyps->save == NULL)
824 {
825 /* If this is a first conflict in the stack, start saving lexemes */
826 if (!yylexemes)
827 {
828 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));
829 if (yylexemes == NULL) goto yyenomem;
830 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
831 if (yylvals == NULL) goto yyenomem;
832 yylvlim = yylvals + YYLVQUEUEGROWTH;
833 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
834 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
835 if (yylpsns == NULL) goto yyenomem;
836 yylplim = yylpsns + YYLVQUEUEGROWTH;
837 #endif
838 }
839 if (yylvp == yylve)
840 {
841 yylvp = yylve = yylvals;
842 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
843 yylpp = yylpe = yylpsns;
844 #endif
845 yylexp = yylexemes;
846 if (yychar >= YYEOF)
847 {
848 *yylve++ = yylval;
849 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
850 *yylpe++ = yylloc;
851 #endif
852 *yylexp = (short) yychar;
853 yychar = YYEMPTY;
854 }
855 }
856 }
857 if (yychar >= YYEOF)
858 {
859 yylvp--;
860 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
861 yylpp--;
862 #endif
863 yylexp--;
864 yychar = YYEMPTY;
865 }
866 save->lexeme = (int) (yylvp - yylvals);
867 yyps->save = save;
868 }
869 if (yytable[yyn] == ctry)
870 {
871 #if YYDEBUG
872 if (yydebug)
873 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
874 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
875 #endif
876 if (yychar < 0)
877 {
878 yylvp++;
879 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
880 yylpp++;
881 #endif
882 yylexp++;
883 }
884 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
885 goto yyoverflow;
886 yystate = yyctable[ctry];
887 *++yystack.s_mark = (short) yystate;
888 *++yystack.l_mark = yylval;
889 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
890 *++yystack.p_mark = yylloc;
891 #endif
892 yychar = YYEMPTY;
893 if (yyerrflag > 0) --yyerrflag;
894 goto yyloop;
895 }
896 else
897 {
898 yyn = yyctable[ctry];
899 goto yyreduce;
900 }
901 } /* End of code dealing with conflicts */
902 #endif /* YYBTYACC */
903 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
904 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
905 {
906 #if YYDEBUG
907 if (yydebug)
908 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
909 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
910 #endif
911 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
912 yystate = yytable[yyn];
913 *++yystack.s_mark = yytable[yyn];
914 *++yystack.l_mark = yylval;
915 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
916 *++yystack.p_mark = yylloc;
917 #endif
918 yychar = YYEMPTY;
919 if (yyerrflag > 0) --yyerrflag;
920 goto yyloop;
921 }
922 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
923 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
924 {
925 yyn = yytable[yyn];
926 goto yyreduce;
927 }
928 if (yyerrflag != 0) goto yyinrecovery;
929 #if YYBTYACC
930
931 yynewerrflag = 1;
932 goto yyerrhandler;
933 goto yyerrlab;
934
935 yyerrlab:
936 yynewerrflag = 0;
937 yyerrhandler:
938 while (yyps->save)
939 {
940 int ctry;
941 YYParseState *save = yyps->save;
942 #if YYDEBUG
943 if (yydebug)
944 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
945 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
946 (int)(yylvp - yylvals - yyps->save->lexeme));
947 #endif
948 /* Memorize most forward-looking error state in case it's really an error. */
949 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
950 {
951 /* Free old saved error context state */
952 if (yyerrctx) yyFreeState(yyerrctx);
953 /* Create and fill out new saved error context state */
954 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
955 if (yyerrctx == NULL) goto yyenomem;
956 yyerrctx->save = yyps->save;
957 yyerrctx->state = yystate;
958 yyerrctx->errflag = yyerrflag;
959 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
960 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
961 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
962 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
963 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
964 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
965 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
966 #endif
967 yyerrctx->lexeme = (int) (yylvp - yylvals);
968 }
969 yylvp = yylvals + save->lexeme;
970 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
971 yylpp = yylpsns + save->lexeme;
972 #endif
973 yylexp = yylexemes + save->lexeme;
974 yychar = YYEMPTY;
975 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
976 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
977 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
978 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
979 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
980 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
981 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
982 #endif
983 ctry = ++save->ctry;
984 yystate = save->state;
985 /* We tried shift, try reduce now */
986 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
987 yyps->save = save->save;
988 save->save = NULL;
989 yyFreeState(save);
990
991 /* Nothing left on the stack -- error */
992 if (!yyps->save)
993 {
994 #if YYDEBUG
995 if (yydebug)
996 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
997 YYPREFIX, yydepth);
998 #endif
999 /* Restore state as it was in the most forward-advanced error */
1000 yylvp = yylvals + yyerrctx->lexeme;
1001 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1002 yylpp = yylpsns + yyerrctx->lexeme;
1003 #endif
1004 yylexp = yylexemes + yyerrctx->lexeme;
1005 yychar = yylexp[-1];
1006 yylval = yylvp[-1];
1007 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1008 yylloc = yylpp[-1];
1009 #endif
1010 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1011 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1012 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1013 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1014 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1015 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1016 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1017 #endif
1018 yystate = yyerrctx->state;
1019 yyFreeState(yyerrctx);
1020 yyerrctx = NULL;
1021 }
1022 yynewerrflag = 1;
1023 }
1024 if (yynewerrflag == 0) goto yyinrecovery;
1025 #endif /* YYBTYACC */
1026
1027 YYERROR_CALL("syntax error");
1028 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1029 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1030 #endif
1031
1032 #if !YYBTYACC
1033 goto yyerrlab;
1034 yyerrlab:
1035 #endif
1036 ++yynerrs;
1037
1038 yyinrecovery:
1039 if (yyerrflag < 3)
1040 {
1041 yyerrflag = 3;
1042 for (;;)
1043 {
1044 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1045 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1046 {
1047 #if YYDEBUG
1048 if (yydebug)
1049 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1050 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1051 #endif
1052 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1053 yystate = yytable[yyn];
1054 *++yystack.s_mark = yytable[yyn];
1055 *++yystack.l_mark = yylval;
1056 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1057 /* lookahead position is error end position */
1058 yyerror_loc_range[1] = yylloc;
1059 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1060 *++yystack.p_mark = yyloc;
1061 #endif
1062 goto yyloop;
1063 }
1064 else
1065 {
1066 #if YYDEBUG
1067 if (yydebug)
1068 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1069 YYDEBUGSTR, yydepth, *yystack.s_mark);
1070 #endif
1071 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1072 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1073 /* the current TOS position is the error start position */
1074 yyerror_loc_range[0] = *yystack.p_mark;
1075 #endif
1076 #if defined(YYDESTRUCT_CALL)
1077 #if YYBTYACC
1078 if (!yytrial)
1079 #endif /* YYBTYACC */
1080 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1081 YYDESTRUCT_CALL("error: discarding state",
1082 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1083 #else
1084 YYDESTRUCT_CALL("error: discarding state",
1085 yystos[*yystack.s_mark], yystack.l_mark);
1086 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1087 #endif /* defined(YYDESTRUCT_CALL) */
1088 --yystack.s_mark;
1089 --yystack.l_mark;
1090 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1091 --yystack.p_mark;
1092 #endif
1093 }
1094 }
1095 }
1096 else
1097 {
1098 if (yychar == YYEOF) goto yyabort;
1099 #if YYDEBUG
1100 if (yydebug)
1101 {
1102 yys = yyname[YYTRANSLATE(yychar)];
1103 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1104 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1105 }
1106 #endif
1107 #if defined(YYDESTRUCT_CALL)
1108 #if YYBTYACC
1109 if (!yytrial)
1110 #endif /* YYBTYACC */
1111 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1112 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1113 #else
1114 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1115 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1116 #endif /* defined(YYDESTRUCT_CALL) */
1117 yychar = YYEMPTY;
1118 goto yyloop;
1119 }
1120
1121 yyreduce:
1122 yym = yylen[yyn];
1123 #if YYDEBUG
1124 if (yydebug)
1125 {
1126 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1127 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1128 #ifdef YYSTYPE_TOSTRING
1129 #if YYBTYACC
1130 if (!yytrial)
1131 #endif /* YYBTYACC */
1132 if (yym > 0)
1133 {
1134 int i;
1135 fputc('<', stderr);
1136 for (i = yym; i > 0; i--)
1137 {
1138 if (i != yym) fputs(", ", stderr);
1139 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1140 yystack.l_mark[1-i]), stderr);
1141 }
1142 fputc('>', stderr);
1143 }
1144 #endif
1145 fputc('\n', stderr);
1146 }
1147 #endif
1148 if (yym > 0)
1149 yyval = yystack.l_mark[1-yym];
1150 else
1151 memset(&yyval, 0, sizeof yyval);
1152 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1153
1154 /* Perform position reduction */
1155 memset(&yyloc, 0, sizeof(yyloc));
1156 #if YYBTYACC
1157 if (!yytrial)
1158 #endif /* YYBTYACC */
1159 {
1160 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1161 /* just in case YYERROR is invoked within the action, save
1162 the start of the rhs as the error start position */
1163 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1164 }
1165 #endif
1166
1167 switch (yyn)
1168 {
1169 case 1:
1170 if (!yytrial)
1171 #line 62 "btyacc_destroy1.y"
1172 { yyval.nlist = yystack.l_mark[-5].nlist; }
1173 break;
1174 case 2:
1175 if (!yytrial)
1176 #line 64 "btyacc_destroy1.y"
1177 { yyval.nlist = yystack.l_mark[-3].nlist; }
1178 break;
1179 case 3:
1180 if (!yytrial)
1181 #line 67 "btyacc_destroy1.y"
1182 { yyval.cval = cGLOBAL; }
1183 break;
1184 case 4:
1185 if (!yytrial)
1186 #line 68 "btyacc_destroy1.y"
1187 { yyval.cval = cLOCAL; }
1188 break;
1189 case 5:
1190 if (!yytrial)
1191 #line 71 "btyacc_destroy1.y"
1192 { yyval.tval = tREAL; }
1193 break;
1194 case 6:
1195 if (!yytrial)
1196 #line 72 "btyacc_destroy1.y"
1197 { yyval.tval = tINTEGER; }
1198 break;
1199 case 7:
1200 if (!yytrial)
1201 #line 76 "btyacc_destroy1.y"
1202 { yyval.nlist->s = mksymbol(yystack.l_mark[-2].tval, yystack.l_mark[-2].cval, yystack.l_mark[0].id);
1203 yyval.nlist->next = yystack.l_mark[-1].nlist;
1204 }
1205 break;
1206 case 8:
1207 if (!yytrial)
1208 #line 80 "btyacc_destroy1.y"
1209 { yyval.nlist->s = mksymbol(0, 0, yystack.l_mark[0].id);
1210 yyval.nlist->next = NULL;
1211 }
1212 break;
1213 case 9:
1214 if (!yytrial)
1215 #line 86 "btyacc_destroy1.y"
1216 { yyval.nlist = yystack.l_mark[-5].nlist; }
1217 break;
1218 #line 1217 "btyacc_destroy1.tab.c"
1219 default:
1220 break;
1221 }
1222 yystack.s_mark -= yym;
1223 yystate = *yystack.s_mark;
1224 yystack.l_mark -= yym;
1225 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1226 yystack.p_mark -= yym;
1227 #endif
1228 yym = yylhs[yyn];
1229 if (yystate == 0 && yym == 0)
1230 {
1231 #if YYDEBUG
1232 if (yydebug)
1233 {
1234 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1235 #ifdef YYSTYPE_TOSTRING
1236 #if YYBTYACC
1237 if (!yytrial)
1238 #endif /* YYBTYACC */
1239 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1240 #endif
1241 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1242 }
1243 #endif
1244 yystate = YYFINAL;
1245 *++yystack.s_mark = YYFINAL;
1246 *++yystack.l_mark = yyval;
1247 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1248 *++yystack.p_mark = yyloc;
1249 #endif
1250 if (yychar < 0)
1251 {
1252 #if YYBTYACC
1253 do {
1254 if (yylvp < yylve)
1255 {
1256 /* we're currently re-reading tokens */
1257 yylval = *yylvp++;
1258 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1259 yylloc = *yylpp++;
1260 #endif
1261 yychar = *yylexp++;
1262 break;
1263 }
1264 if (yyps->save)
1265 {
1266 /* in trial mode; save scanner results for future parse attempts */
1267 if (yylvp == yylvlim)
1268 { /* Enlarge lexical value queue */
1269 size_t p = (size_t) (yylvp - yylvals);
1270 size_t s = (size_t) (yylvlim - yylvals);
1271
1272 s += YYLVQUEUEGROWTH;
1273 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
1274 goto yyenomem;
1275 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1276 goto yyenomem;
1277 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1278 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1279 goto yyenomem;
1280 #endif
1281 yylvp = yylve = yylvals + p;
1282 yylvlim = yylvals + s;
1283 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1284 yylpp = yylpe = yylpsns + p;
1285 yylplim = yylpsns + s;
1286 #endif
1287 yylexp = yylexemes + p;
1288 }
1289 *yylexp = (short) YYLEX;
1290 *yylvp++ = yylval;
1291 yylve++;
1292 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1293 *yylpp++ = yylloc;
1294 yylpe++;
1295 #endif
1296 yychar = *yylexp++;
1297 break;
1298 }
1299 /* normal operation, no conflict encountered */
1300 #endif /* YYBTYACC */
1301 yychar = YYLEX;
1302 #if YYBTYACC
1303 } while (0);
1304 #endif /* YYBTYACC */
1305 if (yychar < 0) yychar = YYEOF;
1306 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
1307 #if YYDEBUG
1308 if (yydebug)
1309 {
1310 yys = yyname[YYTRANSLATE(yychar)];
1311 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n",
1312 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1313 }
1314 #endif
1315 }
1316 if (yychar == YYEOF) goto yyaccept;
1317 goto yyloop;
1318 }
1319 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1320 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1321 yystate = yytable[yyn];
1322 else
1323 yystate = yydgoto[yym];
1324 #if YYDEBUG
1325 if (yydebug)
1326 {
1327 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1328 #ifdef YYSTYPE_TOSTRING
1329 #if YYBTYACC
1330 if (!yytrial)
1331 #endif /* YYBTYACC */
1332 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1333 #endif
1334 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1335 }
1336 #endif
1337 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1338 *++yystack.s_mark = (short) yystate;
1339 *++yystack.l_mark = yyval;
1340 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1341 *++yystack.p_mark = yyloc;
1342 #endif
1343 goto yyloop;
1344 #if YYBTYACC
1345
1346 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1347 yyvalid:
1348 if (yypath) YYABORT;
1349 while (yyps->save)
1350 {
1351 YYParseState *save = yyps->save;
1352 yyps->save = save->save;
1353 save->save = yypath;
1354 yypath = save;
1355 }
1356 #if YYDEBUG
1357 if (yydebug)
1358 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1359 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1360 #endif
1361 if (yyerrctx)
1362 {
1363 yyFreeState(yyerrctx);
1364 yyerrctx = NULL;
1365 }
1366 yylvp = yylvals + yypath->lexeme;
1367 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1368 yylpp = yylpsns + yypath->lexeme;
1369 #endif
1370 yylexp = yylexemes + yypath->lexeme;
1371 yychar = YYEMPTY;
1372 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1373 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1374 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1375 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1376 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1377 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1378 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1379 #endif
1380 yystate = yypath->state;
1381 goto yyloop;
1382 #endif /* YYBTYACC */
1383
1384 yyoverflow:
1385 YYERROR_CALL("yacc stack overflow");
1386 #if YYBTYACC
1387 goto yyabort_nomem;
1388 yyenomem:
1389 YYERROR_CALL("memory exhausted");
1390 yyabort_nomem:
1391 #endif /* YYBTYACC */
1392 yyresult = 2;
1393 goto yyreturn;
1394
1395 yyabort:
1396 yyresult = 1;
1397 goto yyreturn;
1398
1399 yyaccept:
1400 #if YYBTYACC
1401 if (yyps->save) goto yyvalid;
1402 #endif /* YYBTYACC */
1403 yyresult = 0;
1404
1405 yyreturn:
1406 #if defined(YYDESTRUCT_CALL)
1407 if (yychar != YYEOF && yychar != YYEMPTY)
1408 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1409 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1410 #else
1411 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1412 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1413
1414 {
1415 YYSTYPE *pv;
1416 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1417 YYLTYPE *pp;
1418
1419 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1420 YYDESTRUCT_CALL("cleanup: discarding state",
1421 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1422 #else
1423 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1424 YYDESTRUCT_CALL("cleanup: discarding state",
1425 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1426 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1427 }
1428 #endif /* defined(YYDESTRUCT_CALL) */
1429
1430 #if YYBTYACC
1431 if (yyerrctx)
1432 {
1433 yyFreeState(yyerrctx);
1434 yyerrctx = NULL;
1435 }
1436 while (yyps)
1437 {
1438 YYParseState *save = yyps;
1439 yyps = save->save;
1440 save->save = NULL;
1441 yyFreeState(save);
1442 }
1443 while (yypath)
1444 {
1445 YYParseState *save = yypath;
1446 yypath = save->save;
1447 save->save = NULL;
1448 yyFreeState(save);
1449 }
1450 #endif /* YYBTYACC */
1451 yyfreestack(&yystack);
1452 return (yyresult);
1453 }
1454