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