1 /* original parser id follows */
2 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
8 #define YYCHECK "yyyymmdd"
11 #define yyclearin (yychar = YYEMPTY)
12 #define yyerrok (yyerrflag = 0)
13 #define YYRECOVERING() (yyerrflag != 0)
18 #define YYDEBUGSTR YYPREFIX "debug"
21 #define yyparse ok_syntax1_parse
25 #define yylex ok_syntax1_lex
29 #define yyerror ok_syntax1_error
33 #define yychar ok_syntax1_char
37 #define yyval ok_syntax1_val
41 #define yylval ok_syntax1_lval
45 #define yydebug ok_syntax1_debug
49 #define yynerrs ok_syntax1_nerrs
53 #define yyerrflag ok_syntax1_errflag
54 #endif /* yyerrflag */
57 #define yylhs ok_syntax1_lhs
61 #define yylen ok_syntax1_len
65 #define yydefred ok_syntax1_defred
69 #define yystos ok_syntax1_stos
73 #define yydgoto ok_syntax1_dgoto
77 #define yysindex ok_syntax1_sindex
81 #define yyrindex ok_syntax1_rindex
85 #define yygindex ok_syntax1_gindex
89 #define yytable ok_syntax1_table
93 #define yycheck ok_syntax1_check
97 #define yyname ok_syntax1_name
101 #define yyrule ok_syntax1_rule
107 #define yycindex ok_syntax1_cindex
108 #endif /* yycindex */
111 #define yyctable ok_syntax1_ctable
112 #endif /* yyctable */
114 #endif /* YYBTYACC */
116 #define YYPREFIX "ok_syntax1_"
120 #line 9 "ok_syntax1.y"
126 #define YYLEX_PARAM base
127 #define YYLEX_DECL() yylex(YYSTYPE *yylval, int *YYLEX_PARAM)
128 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
130 static void YYERROR_DECL();
134 #undef YYSTYPE_IS_DECLARED
135 #define YYSTYPE_IS_DECLARED 1
137 #ifndef YYSTYPE_IS_DECLARED
138 #define YYSTYPE_IS_DECLARED 1
139 #line 43 "ok_syntax1.y"
146 #endif /* !YYSTYPE_IS_DECLARED */
147 #line 148 "ok_syntax1.tab.c"
149 /* compatibility with bison */
151 /* compatibility with FreeBSD */
152 # ifdef YYPARSE_PARAM_TYPE
153 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
155 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
158 # define YYPARSE_DECL() yyparse(int regs[26], int *base)
161 /* Parameters sent to lex. */
163 # ifdef YYLEX_PARAM_TYPE
164 # define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
166 # define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
168 # define YYLEX yylex(&yylval, YYLEX_PARAM)
170 # define YYLEX_DECL() yylex(YYSTYPE *yylval, int *base)
171 # define YYLEX yylex(&yylval, base)
174 /* Parameters sent to yyerror. */
176 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
179 #define YYERROR_CALL(msg) yyerror(regs, base, msg)
182 extern int YYPARSE_DECL();
200 #define YYERRCODE 256
202 static const YYINT ok_syntax1_lhs[] = { -1,
203 0, 0, 0, 1, 1, 2, 2, 2, 2, 2,
204 2, 2, 2, 2, 2, 2, 3, 3,
206 static const YYINT ok_syntax1_len[] = { 2,
207 0, 3, 3, 1, 3, 3, 3, 3, 3, 3,
208 3, 3, 3, 2, 1, 1, 1, 2,
210 static const YYINT ok_syntax1_defred[] = { 1,
211 0, 0, 17, 0, 0, 0, 0, 0, 0, 3,
212 0, 15, 14, 0, 2, 0, 0, 0, 0, 0,
213 0, 0, 18, 0, 6, 0, 0, 0, 0, 9,
216 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
217 static const YYINT ok_syntax1_stos[] = { 0,
218 275, 256, 257, 258, 45, 40, 276, 277, 278, 10,
219 61, 258, 277, 277, 10, 124, 38, 43, 45, 42,
220 47, 37, 257, 277, 41, 277, 277, 277, 277, 277,
223 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
224 static const YYINT ok_syntax1_dgoto[] = { 1,
227 static const YYINT ok_syntax1_sindex[] = { 0,
228 -40, -7, 0, -55, -38, -38, 1, -29, -247, 0,
229 -38, 0, 0, 22, 0, -38, -38, -38, -38, -38,
230 -38, -38, 0, -29, 0, 51, 60, -20, -20, 0,
233 static const YYINT ok_syntax1_rindex[] = { 0,
234 0, 0, 0, 2, 0, 0, 0, 9, -9, 0,
235 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
236 0, 0, 0, 10, 0, -6, 14, 5, 13, 0,
240 static const YYINT ok_syntax1_cindex[] = { 0,
241 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
242 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
243 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
247 static const YYINT ok_syntax1_gindex[] = { 0,
250 #define YYTABLESIZE 220
251 static const YYINT ok_syntax1_table[] = { 6,
252 16, 6, 10, 13, 5, 11, 5, 22, 17, 23,
253 15, 15, 20, 18, 7, 19, 22, 21, 4, 5,
254 0, 20, 8, 12, 0, 0, 21, 16, 16, 0,
255 0, 16, 16, 16, 13, 16, 0, 16, 15, 15,
256 0, 0, 7, 15, 15, 7, 15, 7, 15, 7,
257 8, 12, 0, 8, 12, 8, 0, 8, 22, 17,
258 0, 0, 25, 20, 18, 0, 19, 0, 21, 13,
259 14, 0, 0, 0, 0, 24, 0, 0, 0, 0,
260 26, 27, 28, 29, 30, 31, 32, 22, 17, 0,
261 0, 0, 20, 18, 16, 19, 22, 21, 0, 0,
262 0, 20, 18, 0, 19, 0, 21, 0, 0, 0,
263 0, 0, 0, 0, 16, 0, 0, 13, 0, 0,
264 0, 0, 0, 0, 0, 15, 0, 0, 7, 0,
265 0, 0, 0, 0, 0, 0, 8, 12, 0, 0,
266 0, 0, 0, 0, 0, 16, 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 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
272 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
273 0, 0, 0, 0, 0, 2, 3, 4, 3, 12,
275 static const YYINT ok_syntax1_check[] = { 40,
276 10, 40, 10, 10, 45, 61, 45, 37, 38, 257,
277 10, 10, 42, 43, 10, 45, 37, 47, 10, 10,
278 -1, 42, 10, 10, -1, -1, 47, 37, 38, -1,
279 -1, 41, 42, 43, 41, 45, -1, 47, 37, 38,
280 -1, -1, 38, 42, 43, 41, 45, 43, 47, 45,
281 38, 38, -1, 41, 41, 43, -1, 45, 37, 38,
282 -1, -1, 41, 42, 43, -1, 45, -1, 47, 5,
283 6, -1, -1, -1, -1, 11, -1, -1, -1, -1,
284 16, 17, 18, 19, 20, 21, 22, 37, 38, -1,
285 -1, -1, 42, 43, 124, 45, 37, 47, -1, -1,
286 -1, 42, 43, -1, 45, -1, 47, -1, -1, -1,
287 -1, -1, -1, -1, 124, -1, -1, 124, -1, -1,
288 -1, -1, -1, -1, -1, 124, -1, -1, 124, -1,
289 -1, -1, -1, -1, -1, -1, 124, 124, -1, -1,
290 -1, -1, -1, -1, -1, 124, -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 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
297 -1, -1, -1, -1, -1, 256, 257, 258, 257, 258,
300 static const YYINT ok_syntax1_ctable[] = { -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, -1, -1, -1, -1, -1, -1, -1, -1,
329 #define YYMAXTOKEN 273
330 #define YYUNDFTOKEN 279
331 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
333 static const char *const ok_syntax1_name[] = {
335 "$end",0,0,0,0,0,0,"'\\a'","'\\b'","'\\t'","'\\n'","'\\v'","'\\f'","'\\r'",0,0,
336 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,
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,
339 0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,"'~'","'\\177'",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,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
342 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,"'\\377'",
343 "error","DIGIT","LETTER","OCT1","HEX1","HEX2","HEX3","STR1",
344 "\"\\177\\177\\\\\\n\"","STR2","BELL","BS","NL","LF","CR","TAB","VT","UMINUS",
345 "$accept","list","stat","expr","number","illegal-symbol",
347 static const char *const ok_syntax1_rule[] = {
350 "list : list stat '\\n'",
351 "list : list error '\\n'",
353 "stat : LETTER '=' expr",
354 "expr : '(' expr ')'",
355 "expr : expr '+' expr",
356 "expr : expr '-' expr",
357 "expr : expr '*' expr",
358 "expr : expr '/' expr",
359 "expr : expr '%' expr",
360 "expr : expr '&' expr",
361 "expr : expr '|' expr",
366 "number : number DIGIT",
375 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
376 #ifndef YYLLOC_DEFAULT
377 #define YYLLOC_DEFAULT(loc, rhs, n) \
382 (loc).first_line = YYRHSLOC(rhs, 0).last_line; \
383 (loc).first_column = YYRHSLOC(rhs, 0).last_column; \
384 (loc).last_line = YYRHSLOC(rhs, 0).last_line; \
385 (loc).last_column = YYRHSLOC(rhs, 0).last_column; \
389 (loc).first_line = YYRHSLOC(rhs, 1).first_line; \
390 (loc).first_column = YYRHSLOC(rhs, 1).first_column; \
391 (loc).last_line = YYRHSLOC(rhs, n).last_line; \
392 (loc).last_column = YYRHSLOC(rhs, n).last_column; \
395 #endif /* YYLLOC_DEFAULT */
396 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
399 #ifndef YYLVQUEUEGROWTH
400 #define YYLVQUEUEGROWTH 32
402 #endif /* YYBTYACC */
404 /* define the initial stack-sizes */
407 #define YYMAXDEPTH YYSTACKSIZE
410 #define YYSTACKSIZE YYMAXDEPTH
412 #define YYSTACKSIZE 10000
413 #define YYMAXDEPTH 10000
417 #ifndef YYINITSTACKSIZE
418 #define YYINITSTACKSIZE 200
428 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
435 struct YYParseState_s
437 struct YYParseState_s *save; /* Previously saved parser state */
438 YYSTACKDATA yystack; /* saved parser stack */
439 int state; /* saved parser state */
440 int errflag; /* saved error recovery status */
441 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
442 YYINT ctry; /* saved index in yyctable[] for this conflict */
444 typedef struct YYParseState_s YYParseState;
445 #endif /* YYBTYACC */
446 #line 104 "ok_syntax1.y"
447 /* start of programs */
450 extern int YYLEX_DECL();
459 while(!feof(stdin)) {
460 yyparse(regs, &base);
465 #define UNUSED(x) ((void)(x))
470 UNUSED(regs); /* %parse-param regs is not actually used here */
471 UNUSED(base); /* %parse-param base is not actually used here */
472 fprintf(stderr, "%s\n", s);
478 /* lexical analysis routine */
479 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
480 /* return DIGIT for a digit, yylval = 0 through 9 */
481 /* all other characters are returned immediately */
485 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
487 /* c is now nonblank */
490 yylval->ival = (c - 'a');
494 yylval->ival = (c - '0') % (*base);
499 #line 500 "ok_syntax1.tab.c"
501 /* For use in generated program */
502 #define yydepth (int)(yystack.s_mark - yystack.s_base)
504 #define yytrial (yyps->save)
505 #endif /* YYBTYACC */
508 #include <stdio.h> /* needed for printf */
511 #include <stdlib.h> /* needed for malloc, etc */
512 #include <string.h> /* needed for memset */
514 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
515 static int yygrowstack(YYSTACKDATA *data)
521 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
525 if ((newsize = data->stacksize) == 0)
526 newsize = YYINITSTACKSIZE;
527 else if (newsize >= YYMAXDEPTH)
529 else if ((newsize *= 2) > YYMAXDEPTH)
530 newsize = YYMAXDEPTH;
532 i = (int) (data->s_mark - data->s_base);
533 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
537 data->s_base = newss;
538 data->s_mark = newss + i;
540 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
544 data->l_base = newvs;
545 data->l_mark = newvs + i;
547 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
548 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
552 data->p_base = newps;
553 data->p_mark = newps + i;
556 data->stacksize = newsize;
557 data->s_last = data->s_base + newsize - 1;
561 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
566 #if YYPURE || defined(YY_NO_LEAKS)
567 static void yyfreestack(YYSTACKDATA *data)
571 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
574 memset(data, 0, sizeof(*data));
577 #define yyfreestack(data) /* nothing */
578 #endif /* YYPURE || defined(YY_NO_LEAKS) */
581 static YYParseState *
582 yyNewState(unsigned size)
584 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
585 if (p == NULL) return NULL;
587 p->yystack.stacksize = size;
590 p->yystack.s_base = NULL;
591 p->yystack.l_base = NULL;
592 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
593 p->yystack.p_base = NULL;
597 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
598 if (p->yystack.s_base == NULL) return NULL;
599 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
600 if (p->yystack.l_base == NULL) return NULL;
601 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
602 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
603 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
604 if (p->yystack.p_base == NULL) return NULL;
605 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
612 yyFreeState(YYParseState *p)
614 yyfreestack(&p->yystack);
617 #endif /* YYBTYACC */
619 #define YYABORT goto yyabort
620 #define YYREJECT goto yyabort
621 #define YYACCEPT goto yyaccept
622 #define YYERROR goto yyerrlab
624 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
625 #define YYVALID_NESTED do { if (yyps->save && \
626 yyps->save->save == 0) goto yyvalid; } while(0)
627 #endif /* YYBTYACC */
638 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
639 YYLTYPE yyloc; /* position returned by actions */
640 YYLTYPE yylloc; /* position from the lexer */
643 /* variables for the parser stack */
647 /* Current parser state */
648 static YYParseState *yyps = 0;
650 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
651 static YYParseState *yypath = 0;
653 /* Base of the lexical value queue */
654 static YYSTYPE *yylvals = 0;
656 /* Current position at lexical value queue */
657 static YYSTYPE *yylvp = 0;
659 /* End position of lexical value queue */
660 static YYSTYPE *yylve = 0;
662 /* The last allocated position at the lexical value queue */
663 static YYSTYPE *yylvlim = 0;
665 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
666 /* Base of the lexical position queue */
667 static YYLTYPE *yylpsns = 0;
669 /* Current position at lexical position queue */
670 static YYLTYPE *yylpp = 0;
672 /* End position of lexical position queue */
673 static YYLTYPE *yylpe = 0;
675 /* The last allocated position at the lexical position queue */
676 static YYLTYPE *yylplim = 0;
679 /* Current position at lexical token queue */
680 static YYINT *yylexp = 0;
682 static YYINT *yylexemes = 0;
683 #endif /* YYBTYACC */
684 int yym, yyn, yystate, yyresult;
687 YYParseState *yyerrctx = NULL;
688 #endif /* YYBTYACC */
689 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
690 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */
695 if ((yys = getenv("YYDEBUG")) != 0)
698 if (yyn >= '0' && yyn <= '9')
702 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
704 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
705 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
710 memset(&yyval, 0, sizeof(yyval));
711 memset(&yylval, 0, sizeof(yylval));
712 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
713 memset(&yyloc, 0, sizeof(yyloc));
714 memset(&yylloc, 0, sizeof(yylloc));
718 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
720 #endif /* YYBTYACC */
729 memset(&yystack, 0, sizeof(yystack));
732 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
733 yystack.s_mark = yystack.s_base;
734 yystack.l_mark = yystack.l_base;
735 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
736 yystack.p_mark = yystack.p_base;
742 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
749 /* we're currently re-reading tokens */
751 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
759 /* in trial mode; save scanner results for future parse attempts */
760 if (yylvp == yylvlim)
761 { /* Enlarge lexical value queue */
762 size_t p = (size_t) (yylvp - yylvals);
763 size_t s = (size_t) (yylvlim - yylvals);
765 s += YYLVQUEUEGROWTH;
766 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
767 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
768 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
769 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
771 yylvp = yylve = yylvals + p;
772 yylvlim = yylvals + s;
773 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
774 yylpp = yylpe = yylpsns + p;
775 yylplim = yylpsns + s;
777 yylexp = yylexemes + p;
779 *yylexp = (YYINT) YYLEX;
782 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
789 /* normal operation, no conflict encountered */
790 #endif /* YYBTYACC */
794 #endif /* YYBTYACC */
795 if (yychar < 0) yychar = YYEOF;
799 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
800 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
801 YYDEBUGSTR, yydepth, yystate, yychar, yys);
802 #ifdef YYSTYPE_TOSTRING
805 #endif /* YYBTYACC */
806 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
814 /* Do we have a conflict? */
815 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
816 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
825 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
826 YYDEBUGSTR, yydepth, yystate);
828 /* Switch to the next conflict context */
833 if (save->state != yystate) YYABORT;
840 /* Unresolved conflict - start/continue trial parse */
845 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
847 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
849 fputs("Starting trial parse.\n", stderr);
852 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
853 if (save == NULL) goto yyenomem;
854 save->save = yyps->save;
855 save->state = yystate;
856 save->errflag = yyerrflag;
857 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
858 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
859 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
860 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
861 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
862 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
863 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
866 if (yyctable[ctry] == -1)
869 if (yydebug && yychar >= YYEOF)
870 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
875 if (yyps->save == NULL)
877 /* If this is a first conflict in the stack, start saving lexemes */
880 yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
881 if (yylexemes == NULL) goto yyenomem;
882 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
883 if (yylvals == NULL) goto yyenomem;
884 yylvlim = yylvals + YYLVQUEUEGROWTH;
885 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
886 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
887 if (yylpsns == NULL) goto yyenomem;
888 yylplim = yylpsns + YYLVQUEUEGROWTH;
893 yylvp = yylve = yylvals;
894 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
895 yylpp = yylpe = yylpsns;
901 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
904 *yylexp = (YYINT) yychar;
912 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
918 save->lexeme = (int) (yylvp - yylvals);
921 if (yytable[yyn] == ctry)
925 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
926 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
931 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
936 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
938 yystate = yyctable[ctry];
939 *++yystack.s_mark = (YYINT) yystate;
940 *++yystack.l_mark = yylval;
941 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
942 *++yystack.p_mark = yylloc;
945 if (yyerrflag > 0) --yyerrflag;
950 yyn = yyctable[ctry];
953 } /* End of code dealing with conflicts */
954 #endif /* YYBTYACC */
955 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
956 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
960 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
961 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
963 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
964 yystate = yytable[yyn];
965 *++yystack.s_mark = yytable[yyn];
966 *++yystack.l_mark = yylval;
967 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
968 *++yystack.p_mark = yylloc;
971 if (yyerrflag > 0) --yyerrflag;
974 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
975 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
980 if (yyerrflag != 0) goto yyinrecovery;
985 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
988 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
989 * before looking for error recovery */
990 yystack.s_mark -= yym;
991 yystate = *yystack.s_mark;
992 yystack.l_mark -= yym;
993 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
994 yystack.p_mark -= yym;
1002 YYParseState *save = yyps->save;
1005 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
1006 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
1007 (int)(yylvp - yylvals - yyps->save->lexeme));
1009 /* Memorize most forward-looking error state in case it's really an error. */
1010 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
1012 /* Free old saved error context state */
1013 if (yyerrctx) yyFreeState(yyerrctx);
1014 /* Create and fill out new saved error context state */
1015 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1016 if (yyerrctx == NULL) goto yyenomem;
1017 yyerrctx->save = yyps->save;
1018 yyerrctx->state = yystate;
1019 yyerrctx->errflag = yyerrflag;
1020 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1021 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1022 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1023 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1024 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1025 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1026 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1028 yyerrctx->lexeme = (int) (yylvp - yylvals);
1030 yylvp = yylvals + save->lexeme;
1031 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1032 yylpp = yylpsns + save->lexeme;
1034 yylexp = yylexemes + save->lexeme;
1036 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1037 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1038 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1039 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1040 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1041 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1042 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1044 ctry = ++save->ctry;
1045 yystate = save->state;
1046 /* We tried shift, try reduce now */
1047 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1048 yyps->save = save->save;
1052 /* Nothing left on the stack -- error */
1057 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1060 /* Restore state as it was in the most forward-advanced error */
1061 yylvp = yylvals + yyerrctx->lexeme;
1062 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1063 yylpp = yylpsns + yyerrctx->lexeme;
1065 yylexp = yylexemes + yyerrctx->lexeme;
1066 yychar = yylexp[-1];
1068 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1071 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1072 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1073 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1074 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1075 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1076 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1077 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1079 yystate = yyerrctx->state;
1080 yyFreeState(yyerrctx);
1085 if (yynewerrflag == 0) goto yyinrecovery;
1086 #endif /* YYBTYACC */
1088 YYERROR_CALL("syntax error");
1089 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1090 yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */
1094 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1105 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1106 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1110 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1111 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1113 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1114 yystate = yytable[yyn];
1115 *++yystack.s_mark = yytable[yyn];
1116 *++yystack.l_mark = yylval;
1117 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1118 /* lookahead position is error end position */
1119 yyerror_loc_range[2] = yylloc;
1120 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1121 *++yystack.p_mark = yyloc;
1129 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1130 YYDEBUGSTR, yydepth, *yystack.s_mark);
1132 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1133 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1134 /* the current TOS position is the error start position */
1135 yyerror_loc_range[1] = *yystack.p_mark;
1137 #if defined(YYDESTRUCT_CALL)
1140 #endif /* YYBTYACC */
1141 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1142 YYDESTRUCT_CALL("error: discarding state",
1143 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1145 YYDESTRUCT_CALL("error: discarding state",
1146 yystos[*yystack.s_mark], yystack.l_mark);
1147 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1148 #endif /* defined(YYDESTRUCT_CALL) */
1151 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1159 if (yychar == YYEOF) goto yyabort;
1163 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1164 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1165 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1168 #if defined(YYDESTRUCT_CALL)
1171 #endif /* YYBTYACC */
1172 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1173 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1175 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1176 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1177 #endif /* defined(YYDESTRUCT_CALL) */
1187 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1188 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1189 #ifdef YYSTYPE_TOSTRING
1192 #endif /* YYBTYACC */
1197 for (i = yym; i > 0; i--)
1199 if (i != yym) fputs(", ", stderr);
1200 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1201 yystack.l_mark[1-i]), stderr);
1206 fputc('\n', stderr);
1210 yyval = yystack.l_mark[1-yym];
1212 memset(&yyval, 0, sizeof yyval);
1213 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1215 /* Perform position reduction */
1216 memset(&yyloc, 0, sizeof(yyloc));
1219 #endif /* YYBTYACC */
1221 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);
1222 /* just in case YYERROR is invoked within the action, save
1223 the start of the rhs as the error start position */
1224 yyerror_loc_range[1] = yystack.p_mark[1-yym];
1231 #line 66 "ok_syntax1.y"
1235 #line 70 "ok_syntax1.y"
1236 { printf("%d\n",yystack.l_mark[0].ival);}
1239 #line 72 "ok_syntax1.y"
1240 { regs[yystack.l_mark[-2].ival] = yystack.l_mark[0].ival; }
1243 #line 76 "ok_syntax1.y"
1244 { yyval.ival = yystack.l_mark[-1].ival; }
1247 #line 78 "ok_syntax1.y"
1248 { yyval.ival = yystack.l_mark[-2].ival + yystack.l_mark[0].ival; }
1251 #line 80 "ok_syntax1.y"
1252 { yyval.ival = yystack.l_mark[-2].ival - yystack.l_mark[0].ival; }
1255 #line 82 "ok_syntax1.y"
1256 { yyval.ival = yystack.l_mark[-2].ival * yystack.l_mark[0].ival; }
1259 #line 84 "ok_syntax1.y"
1260 { yyval.ival = yystack.l_mark[-2].ival / yystack.l_mark[0].ival; }
1263 #line 86 "ok_syntax1.y"
1264 { yyval.ival = yystack.l_mark[-2].ival % yystack.l_mark[0].ival; }
1267 #line 88 "ok_syntax1.y"
1268 { yyval.ival = yystack.l_mark[-2].ival & yystack.l_mark[0].ival; }
1271 #line 90 "ok_syntax1.y"
1272 { yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival; }
1275 #line 92 "ok_syntax1.y"
1276 { yyval.ival = - yystack.l_mark[0].ival; }
1279 #line 94 "ok_syntax1.y"
1280 { yyval.ival = regs[yystack.l_mark[0].ival]; }
1283 #line 99 "ok_syntax1.y"
1284 { yyval.ival = yystack.l_mark[0].ival; (*base) = (yystack.l_mark[0].ival==0) ? 8 : 10; }
1287 #line 101 "ok_syntax1.y"
1288 { yyval.ival = (*base) * yystack.l_mark[-1].ival + yystack.l_mark[0].ival; }
1290 #line 1291 "ok_syntax1.tab.c"
1294 yystack.s_mark -= yym;
1295 yystate = *yystack.s_mark;
1296 yystack.l_mark -= yym;
1297 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1298 yystack.p_mark -= yym;
1301 if (yystate == 0 && yym == 0)
1306 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1307 #ifdef YYSTYPE_TOSTRING
1310 #endif /* YYBTYACC */
1311 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1313 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1317 *++yystack.s_mark = YYFINAL;
1318 *++yystack.l_mark = yyval;
1319 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1320 *++yystack.p_mark = yyloc;
1328 /* we're currently re-reading tokens */
1330 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1338 /* in trial mode; save scanner results for future parse attempts */
1339 if (yylvp == yylvlim)
1340 { /* Enlarge lexical value queue */
1341 size_t p = (size_t) (yylvp - yylvals);
1342 size_t s = (size_t) (yylvlim - yylvals);
1344 s += YYLVQUEUEGROWTH;
1345 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1347 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1349 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1350 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1353 yylvp = yylve = yylvals + p;
1354 yylvlim = yylvals + s;
1355 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1356 yylpp = yylpe = yylpsns + p;
1357 yylplim = yylpsns + s;
1359 yylexp = yylexemes + p;
1361 *yylexp = (YYINT) YYLEX;
1364 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1371 /* normal operation, no conflict encountered */
1372 #endif /* YYBTYACC */
1376 #endif /* YYBTYACC */
1377 if (yychar < 0) yychar = YYEOF;
1381 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1382 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1383 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1387 if (yychar == YYEOF) goto yyaccept;
1390 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1391 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1392 yystate = yytable[yyn];
1394 yystate = yydgoto[yym];
1398 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1399 #ifdef YYSTYPE_TOSTRING
1402 #endif /* YYBTYACC */
1403 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1405 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1408 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1409 *++yystack.s_mark = (YYINT) yystate;
1410 *++yystack.l_mark = yyval;
1411 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1412 *++yystack.p_mark = yyloc;
1417 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1419 if (yypath) YYABORT;
1422 YYParseState *save = yyps->save;
1423 yyps->save = save->save;
1424 save->save = yypath;
1429 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1430 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1434 yyFreeState(yyerrctx);
1437 yylvp = yylvals + yypath->lexeme;
1438 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1439 yylpp = yylpsns + yypath->lexeme;
1441 yylexp = yylexemes + yypath->lexeme;
1443 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1444 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1445 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1446 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1447 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1448 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1449 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1451 yystate = yypath->state;
1453 #endif /* YYBTYACC */
1456 YYERROR_CALL("yacc stack overflow");
1460 YYERROR_CALL("memory exhausted");
1462 #endif /* YYBTYACC */
1472 if (yyps->save) goto yyvalid;
1473 #endif /* YYBTYACC */
1477 #if defined(YYDESTRUCT_CALL)
1478 if (yychar != YYEOF && yychar != YYEMPTY)
1479 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1480 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1482 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1483 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1487 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1490 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1491 YYDESTRUCT_CALL("cleanup: discarding state",
1492 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1494 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1495 YYDESTRUCT_CALL("cleanup: discarding state",
1496 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1497 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1499 #endif /* defined(YYDESTRUCT_CALL) */
1504 yyFreeState(yyerrctx);
1509 YYParseState *save = yyps;
1516 YYParseState *save = yypath;
1517 yypath = save->save;
1521 #endif /* YYBTYACC */
1522 yyfreestack(&yystack);