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",
374 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
375 #ifndef YYLLOC_DEFAULT
376 #define YYLLOC_DEFAULT(loc, rhs, n) \
381 (loc).first_line = ((rhs)[-1]).last_line; \
382 (loc).first_column = ((rhs)[-1]).last_column; \
383 (loc).last_line = ((rhs)[-1]).last_line; \
384 (loc).last_column = ((rhs)[-1]).last_column; \
388 (loc).first_line = ((rhs)[ 0 ]).first_line; \
389 (loc).first_column = ((rhs)[ 0 ]).first_column; \
390 (loc).last_line = ((rhs)[n-1]).last_line; \
391 (loc).last_column = ((rhs)[n-1]).last_column; \
394 #endif /* YYLLOC_DEFAULT */
395 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
398 #ifndef YYLVQUEUEGROWTH
399 #define YYLVQUEUEGROWTH 32
401 #endif /* YYBTYACC */
403 /* define the initial stack-sizes */
406 #define YYMAXDEPTH YYSTACKSIZE
409 #define YYSTACKSIZE YYMAXDEPTH
411 #define YYSTACKSIZE 10000
412 #define YYMAXDEPTH 10000
416 #ifndef YYINITSTACKSIZE
417 #define YYINITSTACKSIZE 200
427 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
434 struct YYParseState_s
436 struct YYParseState_s *save; /* Previously saved parser state */
437 YYSTACKDATA yystack; /* saved parser stack */
438 int state; /* saved parser state */
439 int errflag; /* saved error recovery status */
440 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
441 YYINT ctry; /* saved index in yyctable[] for this conflict */
443 typedef struct YYParseState_s YYParseState;
444 #endif /* YYBTYACC */
445 #line 104 "ok_syntax1.y"
446 /* start of programs */
449 extern int YYLEX_DECL();
458 while(!feof(stdin)) {
459 yyparse(regs, &base);
464 #define UNUSED(x) ((void)(x))
469 UNUSED(regs); /* %parse-param regs is not actually used here */
470 UNUSED(base); /* %parse-param base is not actually used here */
471 fprintf(stderr, "%s\n", s);
477 /* lexical analysis routine */
478 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
479 /* return DIGIT for a digit, yylval = 0 through 9 */
480 /* all other characters are returned immediately */
484 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
486 /* c is now nonblank */
489 yylval->ival = (c - 'a');
493 yylval->ival = (c - '0') % (*base);
498 #line 499 "ok_syntax1.tab.c"
500 /* For use in generated program */
501 #define yydepth (int)(yystack.s_mark - yystack.s_base)
503 #define yytrial (yyps->save)
504 #endif /* YYBTYACC */
507 #include <stdio.h> /* needed for printf */
510 #include <stdlib.h> /* needed for malloc, etc */
511 #include <string.h> /* needed for memset */
513 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
514 static int yygrowstack(YYSTACKDATA *data)
520 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
524 if ((newsize = data->stacksize) == 0)
525 newsize = YYINITSTACKSIZE;
526 else if (newsize >= YYMAXDEPTH)
528 else if ((newsize *= 2) > YYMAXDEPTH)
529 newsize = YYMAXDEPTH;
531 i = (int) (data->s_mark - data->s_base);
532 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
536 data->s_base = newss;
537 data->s_mark = newss + i;
539 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
543 data->l_base = newvs;
544 data->l_mark = newvs + i;
546 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
547 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
551 data->p_base = newps;
552 data->p_mark = newps + i;
555 data->stacksize = newsize;
556 data->s_last = data->s_base + newsize - 1;
560 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
565 #if YYPURE || defined(YY_NO_LEAKS)
566 static void yyfreestack(YYSTACKDATA *data)
570 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
573 memset(data, 0, sizeof(*data));
576 #define yyfreestack(data) /* nothing */
577 #endif /* YYPURE || defined(YY_NO_LEAKS) */
580 static YYParseState *
581 yyNewState(unsigned size)
583 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
584 if (p == NULL) return NULL;
586 p->yystack.stacksize = size;
589 p->yystack.s_base = NULL;
590 p->yystack.l_base = NULL;
591 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
592 p->yystack.p_base = NULL;
596 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
597 if (p->yystack.s_base == NULL) return NULL;
598 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
599 if (p->yystack.l_base == NULL) return NULL;
600 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
601 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
602 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
603 if (p->yystack.p_base == NULL) return NULL;
604 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
611 yyFreeState(YYParseState *p)
613 yyfreestack(&p->yystack);
616 #endif /* YYBTYACC */
618 #define YYABORT goto yyabort
619 #define YYREJECT goto yyabort
620 #define YYACCEPT goto yyaccept
621 #define YYERROR goto yyerrlab
623 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
624 #define YYVALID_NESTED do { if (yyps->save && \
625 yyps->save->save == 0) goto yyvalid; } while(0)
626 #endif /* YYBTYACC */
635 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
636 YYLTYPE yyloc; /* position returned by actions */
637 YYLTYPE yylloc; /* position from the lexer */
640 /* variables for the parser stack */
644 /* Current parser state */
645 static YYParseState *yyps = 0;
647 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
648 static YYParseState *yypath = 0;
650 /* Base of the lexical value queue */
651 static YYSTYPE *yylvals = 0;
653 /* Current position at lexical value queue */
654 static YYSTYPE *yylvp = 0;
656 /* End position of lexical value queue */
657 static YYSTYPE *yylve = 0;
659 /* The last allocated position at the lexical value queue */
660 static YYSTYPE *yylvlim = 0;
662 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
663 /* Base of the lexical position queue */
664 static YYLTYPE *yylpsns = 0;
666 /* Current position at lexical position queue */
667 static YYLTYPE *yylpp = 0;
669 /* End position of lexical position queue */
670 static YYLTYPE *yylpe = 0;
672 /* The last allocated position at the lexical position queue */
673 static YYLTYPE *yylplim = 0;
676 /* Current position at lexical token queue */
677 static YYINT *yylexp = 0;
679 static YYINT *yylexemes = 0;
680 #endif /* YYBTYACC */
681 int yym, yyn, yystate, yyresult;
684 YYParseState *yyerrctx = NULL;
685 #endif /* YYBTYACC */
686 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
687 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
692 if ((yys = getenv("YYDEBUG")) != 0)
695 if (yyn >= '0' && yyn <= '9')
699 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
701 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
702 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
707 memset(&yyval, 0, sizeof(yyval));
708 memset(&yylval, 0, sizeof(yylval));
709 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
710 memset(&yyloc, 0, sizeof(yyloc));
711 memset(&yylloc, 0, sizeof(yylloc));
715 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
717 #endif /* YYBTYACC */
726 memset(&yystack, 0, sizeof(yystack));
729 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
730 yystack.s_mark = yystack.s_base;
731 yystack.l_mark = yystack.l_base;
732 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
733 yystack.p_mark = yystack.p_base;
739 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
746 /* we're currently re-reading tokens */
748 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
756 /* in trial mode; save scanner results for future parse attempts */
757 if (yylvp == yylvlim)
758 { /* Enlarge lexical value queue */
759 size_t p = (size_t) (yylvp - yylvals);
760 size_t s = (size_t) (yylvlim - yylvals);
762 s += YYLVQUEUEGROWTH;
763 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
764 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
765 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
766 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
768 yylvp = yylve = yylvals + p;
769 yylvlim = yylvals + s;
770 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
771 yylpp = yylpe = yylpsns + p;
772 yylplim = yylpsns + s;
774 yylexp = yylexemes + p;
776 *yylexp = (YYINT) YYLEX;
779 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
786 /* normal operation, no conflict encountered */
787 #endif /* YYBTYACC */
791 #endif /* YYBTYACC */
792 if (yychar < 0) yychar = YYEOF;
796 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
797 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
798 YYDEBUGSTR, yydepth, yystate, yychar, yys);
799 #ifdef YYSTYPE_TOSTRING
802 #endif /* YYBTYACC */
803 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
811 /* Do we have a conflict? */
812 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
813 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
822 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
823 YYDEBUGSTR, yydepth, yystate);
825 /* Switch to the next conflict context */
830 if (save->state != yystate) YYABORT;
837 /* Unresolved conflict - start/continue trial parse */
842 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
844 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
846 fputs("Starting trial parse.\n", stderr);
849 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
850 if (save == NULL) goto yyenomem;
851 save->save = yyps->save;
852 save->state = yystate;
853 save->errflag = yyerrflag;
854 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
855 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
856 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
857 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
858 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
859 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
860 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
863 if (yyctable[ctry] == -1)
866 if (yydebug && yychar >= YYEOF)
867 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
872 if (yyps->save == NULL)
874 /* If this is a first conflict in the stack, start saving lexemes */
877 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
878 if (yylexemes == NULL) goto yyenomem;
879 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
880 if (yylvals == NULL) goto yyenomem;
881 yylvlim = yylvals + YYLVQUEUEGROWTH;
882 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
883 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
884 if (yylpsns == NULL) goto yyenomem;
885 yylplim = yylpsns + YYLVQUEUEGROWTH;
890 yylvp = yylve = yylvals;
891 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
892 yylpp = yylpe = yylpsns;
898 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
901 *yylexp = (YYINT) yychar;
909 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
915 save->lexeme = (int) (yylvp - yylvals);
918 if (yytable[yyn] == ctry)
922 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
923 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
928 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
933 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
935 yystate = yyctable[ctry];
936 *++yystack.s_mark = (YYINT) yystate;
937 *++yystack.l_mark = yylval;
938 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
939 *++yystack.p_mark = yylloc;
942 if (yyerrflag > 0) --yyerrflag;
947 yyn = yyctable[ctry];
950 } /* End of code dealing with conflicts */
951 #endif /* YYBTYACC */
952 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
953 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
957 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
958 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
960 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
961 yystate = yytable[yyn];
962 *++yystack.s_mark = yytable[yyn];
963 *++yystack.l_mark = yylval;
964 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
965 *++yystack.p_mark = yylloc;
968 if (yyerrflag > 0) --yyerrflag;
971 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
972 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
977 if (yyerrflag != 0) goto yyinrecovery;
982 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
985 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
986 * before looking for error recovery */
987 yystack.s_mark -= yym;
988 yystate = *yystack.s_mark;
989 yystack.l_mark -= yym;
990 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
991 yystack.p_mark -= yym;
999 YYParseState *save = yyps->save;
1002 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
1003 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
1004 (int)(yylvp - yylvals - yyps->save->lexeme));
1006 /* Memorize most forward-looking error state in case it's really an error. */
1007 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
1009 /* Free old saved error context state */
1010 if (yyerrctx) yyFreeState(yyerrctx);
1011 /* Create and fill out new saved error context state */
1012 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1013 if (yyerrctx == NULL) goto yyenomem;
1014 yyerrctx->save = yyps->save;
1015 yyerrctx->state = yystate;
1016 yyerrctx->errflag = yyerrflag;
1017 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1018 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1019 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1020 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1021 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1022 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1023 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1025 yyerrctx->lexeme = (int) (yylvp - yylvals);
1027 yylvp = yylvals + save->lexeme;
1028 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1029 yylpp = yylpsns + save->lexeme;
1031 yylexp = yylexemes + save->lexeme;
1033 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1034 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1035 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1036 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1037 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1038 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1039 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1041 ctry = ++save->ctry;
1042 yystate = save->state;
1043 /* We tried shift, try reduce now */
1044 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1045 yyps->save = save->save;
1049 /* Nothing left on the stack -- error */
1054 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1057 /* Restore state as it was in the most forward-advanced error */
1058 yylvp = yylvals + yyerrctx->lexeme;
1059 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1060 yylpp = yylpsns + yyerrctx->lexeme;
1062 yylexp = yylexemes + yyerrctx->lexeme;
1063 yychar = yylexp[-1];
1065 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1068 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1069 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1070 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1071 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1072 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1073 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1074 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1076 yystate = yyerrctx->state;
1077 yyFreeState(yyerrctx);
1082 if (yynewerrflag == 0) goto yyinrecovery;
1083 #endif /* YYBTYACC */
1085 YYERROR_CALL("syntax error");
1086 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1087 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1091 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1102 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1103 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1107 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1108 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1110 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1111 yystate = yytable[yyn];
1112 *++yystack.s_mark = yytable[yyn];
1113 *++yystack.l_mark = yylval;
1114 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1115 /* lookahead position is error end position */
1116 yyerror_loc_range[1] = yylloc;
1117 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1118 *++yystack.p_mark = yyloc;
1126 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1127 YYDEBUGSTR, yydepth, *yystack.s_mark);
1129 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1130 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1131 /* the current TOS position is the error start position */
1132 yyerror_loc_range[0] = *yystack.p_mark;
1134 #if defined(YYDESTRUCT_CALL)
1137 #endif /* YYBTYACC */
1138 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1139 YYDESTRUCT_CALL("error: discarding state",
1140 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1142 YYDESTRUCT_CALL("error: discarding state",
1143 yystos[*yystack.s_mark], yystack.l_mark);
1144 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1145 #endif /* defined(YYDESTRUCT_CALL) */
1148 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1156 if (yychar == YYEOF) goto yyabort;
1160 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1161 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1162 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1165 #if defined(YYDESTRUCT_CALL)
1168 #endif /* YYBTYACC */
1169 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1170 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1172 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1173 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1174 #endif /* defined(YYDESTRUCT_CALL) */
1184 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1185 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1186 #ifdef YYSTYPE_TOSTRING
1189 #endif /* YYBTYACC */
1194 for (i = yym; i > 0; i--)
1196 if (i != yym) fputs(", ", stderr);
1197 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1198 yystack.l_mark[1-i]), stderr);
1203 fputc('\n', stderr);
1207 yyval = yystack.l_mark[1-yym];
1209 memset(&yyval, 0, sizeof yyval);
1210 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1212 /* Perform position reduction */
1213 memset(&yyloc, 0, sizeof(yyloc));
1216 #endif /* YYBTYACC */
1218 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1219 /* just in case YYERROR is invoked within the action, save
1220 the start of the rhs as the error start position */
1221 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1228 #line 66 "ok_syntax1.y"
1232 #line 70 "ok_syntax1.y"
1233 { printf("%d\n",yystack.l_mark[0].ival);}
1236 #line 72 "ok_syntax1.y"
1237 { regs[yystack.l_mark[-2].ival] = yystack.l_mark[0].ival; }
1240 #line 76 "ok_syntax1.y"
1241 { yyval.ival = yystack.l_mark[-1].ival; }
1244 #line 78 "ok_syntax1.y"
1245 { yyval.ival = yystack.l_mark[-2].ival + yystack.l_mark[0].ival; }
1248 #line 80 "ok_syntax1.y"
1249 { yyval.ival = yystack.l_mark[-2].ival - yystack.l_mark[0].ival; }
1252 #line 82 "ok_syntax1.y"
1253 { yyval.ival = yystack.l_mark[-2].ival * yystack.l_mark[0].ival; }
1256 #line 84 "ok_syntax1.y"
1257 { yyval.ival = yystack.l_mark[-2].ival / yystack.l_mark[0].ival; }
1260 #line 86 "ok_syntax1.y"
1261 { yyval.ival = yystack.l_mark[-2].ival % yystack.l_mark[0].ival; }
1264 #line 88 "ok_syntax1.y"
1265 { yyval.ival = yystack.l_mark[-2].ival & yystack.l_mark[0].ival; }
1268 #line 90 "ok_syntax1.y"
1269 { yyval.ival = yystack.l_mark[-2].ival | yystack.l_mark[0].ival; }
1272 #line 92 "ok_syntax1.y"
1273 { yyval.ival = - yystack.l_mark[0].ival; }
1276 #line 94 "ok_syntax1.y"
1277 { yyval.ival = regs[yystack.l_mark[0].ival]; }
1280 #line 99 "ok_syntax1.y"
1281 { yyval.ival = yystack.l_mark[0].ival; (*base) = (yystack.l_mark[0].ival==0) ? 8 : 10; }
1284 #line 101 "ok_syntax1.y"
1285 { yyval.ival = (*base) * yystack.l_mark[-1].ival + yystack.l_mark[0].ival; }
1287 #line 1288 "ok_syntax1.tab.c"
1291 yystack.s_mark -= yym;
1292 yystate = *yystack.s_mark;
1293 yystack.l_mark -= yym;
1294 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1295 yystack.p_mark -= yym;
1298 if (yystate == 0 && yym == 0)
1303 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1304 #ifdef YYSTYPE_TOSTRING
1307 #endif /* YYBTYACC */
1308 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1310 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1314 *++yystack.s_mark = YYFINAL;
1315 *++yystack.l_mark = yyval;
1316 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1317 *++yystack.p_mark = yyloc;
1325 /* we're currently re-reading tokens */
1327 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1335 /* in trial mode; save scanner results for future parse attempts */
1336 if (yylvp == yylvlim)
1337 { /* Enlarge lexical value queue */
1338 size_t p = (size_t) (yylvp - yylvals);
1339 size_t s = (size_t) (yylvlim - yylvals);
1341 s += YYLVQUEUEGROWTH;
1342 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1344 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1346 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1347 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1350 yylvp = yylve = yylvals + p;
1351 yylvlim = yylvals + s;
1352 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1353 yylpp = yylpe = yylpsns + p;
1354 yylplim = yylpsns + s;
1356 yylexp = yylexemes + p;
1358 *yylexp = (YYINT) YYLEX;
1361 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1368 /* normal operation, no conflict encountered */
1369 #endif /* YYBTYACC */
1373 #endif /* YYBTYACC */
1374 if (yychar < 0) yychar = YYEOF;
1378 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1379 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1380 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1384 if (yychar == YYEOF) goto yyaccept;
1387 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1388 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1389 yystate = yytable[yyn];
1391 yystate = yydgoto[yym];
1395 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1396 #ifdef YYSTYPE_TOSTRING
1399 #endif /* YYBTYACC */
1400 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1402 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1405 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1406 *++yystack.s_mark = (YYINT) yystate;
1407 *++yystack.l_mark = yyval;
1408 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1409 *++yystack.p_mark = yyloc;
1414 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1416 if (yypath) YYABORT;
1419 YYParseState *save = yyps->save;
1420 yyps->save = save->save;
1421 save->save = yypath;
1426 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1427 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1431 yyFreeState(yyerrctx);
1434 yylvp = yylvals + yypath->lexeme;
1435 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1436 yylpp = yylpsns + yypath->lexeme;
1438 yylexp = yylexemes + yypath->lexeme;
1440 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1441 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1442 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1443 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1444 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1445 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1446 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1448 yystate = yypath->state;
1450 #endif /* YYBTYACC */
1453 YYERROR_CALL("yacc stack overflow");
1457 YYERROR_CALL("memory exhausted");
1459 #endif /* YYBTYACC */
1469 if (yyps->save) goto yyvalid;
1470 #endif /* YYBTYACC */
1474 #if defined(YYDESTRUCT_CALL)
1475 if (yychar != YYEOF && yychar != YYEMPTY)
1476 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1477 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1479 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1480 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1484 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1487 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1488 YYDESTRUCT_CALL("cleanup: discarding state",
1489 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1491 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1492 YYDESTRUCT_CALL("cleanup: discarding state",
1493 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1494 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1496 #endif /* defined(YYDESTRUCT_CALL) */
1501 yyFreeState(yyerrctx);
1506 YYParseState *save = yyps;
1513 YYParseState *save = yypath;
1514 yypath = save->save;
1518 #endif /* YYBTYACC */
1519 yyfreestack(&yystack);