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 quote_calc2_parse
25 #define yylex quote_calc2_lex
29 #define yyerror quote_calc2_error
33 #define yychar quote_calc2_char
37 #define yyval quote_calc2_val
41 #define yylval quote_calc2_lval
45 #define yydebug quote_calc2_debug
49 #define yynerrs quote_calc2_nerrs
53 #define yyerrflag quote_calc2_errflag
54 #endif /* yyerrflag */
57 #define yylhs quote_calc2_lhs
61 #define yylen quote_calc2_len
65 #define yydefred quote_calc2_defred
69 #define yystos quote_calc2_stos
73 #define yydgoto quote_calc2_dgoto
77 #define yysindex quote_calc2_sindex
81 #define yyrindex quote_calc2_rindex
85 #define yygindex quote_calc2_gindex
89 #define yytable quote_calc2_table
93 #define yycheck quote_calc2_check
97 #define yyname quote_calc2_name
101 #define yyrule quote_calc2_rule
107 #define yycindex quote_calc2_cindex
108 #endif /* yycindex */
111 #define yyctable quote_calc2_ctable
112 #endif /* yyctable */
114 #endif /* YYBTYACC */
116 #define YYPREFIX "quote_calc2_"
120 #line 2 "quote_calc2.y"
128 static void yyerror(const char *s);
130 #line 131 "quote_calc2-s.tab.c"
132 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
133 /* Default: YYSTYPE is the semantic value type. */
135 # define YYSTYPE_IS_DECLARED 1
138 /* compatibility with bison */
140 /* compatibility with FreeBSD */
141 # ifdef YYPARSE_PARAM_TYPE
142 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
144 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
147 # define YYPARSE_DECL() yyparse(void)
150 /* Parameters sent to lex. */
152 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
153 # define YYLEX yylex(YYLEX_PARAM)
155 # define YYLEX_DECL() yylex(void)
156 # define YYLEX yylex()
159 /* Parameters sent to yyerror. */
161 #define YYERROR_DECL() yyerror(const char *s)
164 #define YYERROR_CALL(msg) yyerror(msg)
167 extern int YYPARSE_DECL();
178 #define YYERRCODE 256
180 static const YYINT quote_calc2_lhs[] = { -1,
181 0, 0, 0, 1, 1, 2, 2, 2, 2, 2,
182 2, 2, 2, 2, 2, 2, 3, 3,
184 static const YYINT quote_calc2_len[] = { 2,
185 0, 3, 3, 1, 3, 3, 3, 3, 3, 3,
186 3, 3, 3, 2, 1, 1, 1, 2,
188 static const YYINT quote_calc2_defred[] = { 1,
189 0, 0, 0, 17, 0, 0, 0, 0, 0, 3,
190 15, 0, 0, 0, 2, 0, 0, 0, 0, 0,
191 0, 0, 18, 0, 6, 0, 0, 0, 0, 0,
194 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
195 static const YYINT quote_calc2_stos[] = { 0,
196 273, 256, 260, 269, 270, 40, 274, 275, 276, 10,
197 270, 275, 61, 275, 10, 258, 260, 262, 264, 266,
198 268, 124, 269, 275, 41, 275, 275, 275, 275, 275,
201 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
202 static const YYINT quote_calc2_dgoto[] = { 1,
205 static const YYINT quote_calc2_sindex[] = { 0,
206 -38, 4, -36, 0, -51, -36, 6, -121, -249, 0,
207 0, -243, -36, -23, 0, -36, -36, -36, -36, -36,
208 -36, -36, 0, -121, 0, -121, -121, -121, -121, -121,
211 static const YYINT quote_calc2_rindex[] = { 0,
212 0, 0, 0, 0, -9, 0, 0, 12, -10, 0,
213 0, -5, 0, 0, 0, 0, 0, 0, 0, 0,
214 0, 0, 0, 14, 0, -3, -2, -1, 1, 2,
218 static const YYINT quote_calc2_cindex[] = { 0,
219 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
220 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
221 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
225 static const YYINT quote_calc2_gindex[] = { 0,
228 #define YYTABLESIZE 259
229 static const YYINT quote_calc2_table[] = { 16,
230 15, 6, 22, 6, 14, 13, 7, 8, 9, 13,
231 10, 11, 12, 10, 16, 15, 17, 25, 18, 23,
232 19, 4, 20, 5, 21, 0, 0, 0, 0, 0,
233 16, 0, 0, 0, 0, 14, 13, 7, 8, 9,
234 0, 10, 11, 12, 12, 0, 0, 14, 0, 0,
235 0, 0, 0, 0, 24, 0, 0, 26, 27, 28,
236 29, 30, 31, 32, 0, 0, 0, 0, 0, 0,
237 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
238 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
239 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
240 22, 0, 0, 0, 0, 0, 0, 0, 0, 0,
241 0, 0, 0, 16, 15, 0, 0, 0, 14, 13,
242 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
243 0, 0, 0, 0, 0, 0, 16, 0, 17, 0,
244 18, 0, 19, 0, 20, 0, 21, 0, 0, 0,
245 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
246 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
247 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
248 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
249 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
250 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
251 0, 0, 0, 0, 0, 0, 0, 2, 0, 0,
252 0, 3, 0, 3, 0, 0, 0, 0, 0, 0,
253 4, 5, 4, 11, 16, 0, 17, 0, 18, 0,
254 19, 0, 20, 0, 21, 0, 0, 16, 15, 16,
255 15, 16, 15, 16, 15, 16, 15, 16, 15,
257 static const YYINT quote_calc2_check[] = { 10,
258 10, 40, 124, 40, 10, 10, 10, 10, 10, 61,
259 10, 10, 10, 10, 258, 10, 260, 41, 262, 269,
260 264, 10, 266, 10, 268, -1, -1, -1, -1, -1,
261 41, -1, -1, -1, -1, 41, 41, 41, 41, 41,
262 -1, 41, 41, 41, 3, -1, -1, 6, -1, -1,
263 -1, -1, -1, -1, 13, -1, -1, 16, 17, 18,
264 19, 20, 21, 22, -1, -1, -1, -1, -1, -1,
265 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
266 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
267 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
268 124, -1, -1, -1, -1, -1, -1, -1, -1, -1,
269 -1, -1, -1, 124, 124, -1, -1, -1, 124, 124,
270 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
271 -1, -1, -1, -1, -1, -1, 258, -1, 260, -1,
272 262, -1, 264, -1, 266, -1, 268, -1, -1, -1,
273 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
274 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
275 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
276 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
277 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
278 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
279 -1, -1, -1, -1, -1, -1, -1, 256, -1, -1,
280 -1, 260, -1, 260, -1, -1, -1, -1, -1, -1,
281 269, 270, 269, 270, 258, -1, 260, -1, 262, -1,
282 264, -1, 266, -1, 268, -1, -1, 258, 258, 260,
283 260, 262, 262, 264, 264, 266, 266, 268, 268,
286 static const YYINT quote_calc2_ctable[] = { -1,
287 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
288 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
289 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
290 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
291 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
292 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
293 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
294 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
295 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
296 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
297 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
298 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
299 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
300 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
301 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
302 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
303 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
304 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
305 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
306 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
307 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
308 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
309 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
310 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
311 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
312 -1, -1, -1, -1, -1, -1, -1, -1,
319 #define YYMAXTOKEN 271
320 #define YYUNDFTOKEN 277
321 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
323 static const char *const quote_calc2_name[] = {
325 "$end",0,0,0,0,0,0,0,0,0,"'\\n'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
326 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
327 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
328 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0,
329 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
330 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
331 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
332 0,0,"error","OP_ADD","\"ADD\"","OP_SUB","\"SUB\"","OP_MUL","\"MUL\"","OP_DIV",
333 "\"DIV\"","OP_MOD","\"MOD\"","OP_AND","\"AND\"","DIGIT","LETTER","UMINUS",
334 "$accept","list","stat","expr","number","illegal-symbol",
336 static const char *const quote_calc2_rule[] = {
339 "list : list stat '\\n'",
340 "list : list error '\\n'",
342 "stat : LETTER '=' expr",
343 "expr : '(' expr ')'",
344 "expr : expr \"ADD\" expr",
345 "expr : expr \"SUB\" expr",
346 "expr : expr \"MUL\" expr",
347 "expr : expr \"DIV\" expr",
348 "expr : expr \"MOD\" expr",
349 "expr : expr \"AND\" expr",
350 "expr : expr '|' expr",
351 "expr : \"SUB\" expr",
355 "number : number DIGIT",
370 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
371 YYLTYPE yyloc; /* position returned by actions */
372 YYLTYPE yylloc; /* position from the lexer */
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 /* variables for the parser stack */
447 static YYSTACKDATA yystack;
450 /* Current parser state */
451 static YYParseState *yyps = 0;
453 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
454 static YYParseState *yypath = 0;
456 /* Base of the lexical value queue */
457 static YYSTYPE *yylvals = 0;
459 /* Current position at lexical value queue */
460 static YYSTYPE *yylvp = 0;
462 /* End position of lexical value queue */
463 static YYSTYPE *yylve = 0;
465 /* The last allocated position at the lexical value queue */
466 static YYSTYPE *yylvlim = 0;
468 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
469 /* Base of the lexical position queue */
470 static YYLTYPE *yylpsns = 0;
472 /* Current position at lexical position queue */
473 static YYLTYPE *yylpp = 0;
475 /* End position of lexical position queue */
476 static YYLTYPE *yylpe = 0;
478 /* The last allocated position at the lexical position queue */
479 static YYLTYPE *yylplim = 0;
482 /* Current position at lexical token queue */
483 static YYINT *yylexp = 0;
485 static YYINT *yylexemes = 0;
486 #endif /* YYBTYACC */
487 #line 73 "quote_calc2.y"
488 /* start of programs */
493 while(!feof(stdin)) {
500 yyerror(const char *s)
502 fprintf(stderr, "%s\n", s);
507 /* lexical analysis routine */
508 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
509 /* return DIGIT for a digit, yylval = 0 through 9 */
510 /* all other characters are returned immediately */
514 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
516 /* c is now nonblank */
528 #line 529 "quote_calc2-s.tab.c"
530 /* For use in generated program */
531 #define yydepth (int)(yystack.s_mark - yystack.s_base)
533 #define yytrial (yyps->save)
534 #endif /* YYBTYACC */
537 #include <stdio.h> /* needed for printf */
540 #include <stdlib.h> /* needed for malloc, etc */
541 #include <string.h> /* needed for memset */
543 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
544 static int yygrowstack(YYSTACKDATA *data)
550 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
554 if ((newsize = data->stacksize) == 0)
555 newsize = YYINITSTACKSIZE;
556 else if (newsize >= YYMAXDEPTH)
558 else if ((newsize *= 2) > YYMAXDEPTH)
559 newsize = YYMAXDEPTH;
561 i = (int) (data->s_mark - data->s_base);
562 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
566 data->s_base = newss;
567 data->s_mark = newss + i;
569 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
573 data->l_base = newvs;
574 data->l_mark = newvs + i;
576 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
577 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
581 data->p_base = newps;
582 data->p_mark = newps + i;
585 data->stacksize = newsize;
586 data->s_last = data->s_base + newsize - 1;
590 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
595 #if YYPURE || defined(YY_NO_LEAKS)
596 static void yyfreestack(YYSTACKDATA *data)
600 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
603 memset(data, 0, sizeof(*data));
606 #define yyfreestack(data) /* nothing */
607 #endif /* YYPURE || defined(YY_NO_LEAKS) */
610 static YYParseState *
611 yyNewState(unsigned size)
613 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
614 if (p == NULL) return NULL;
616 p->yystack.stacksize = size;
619 p->yystack.s_base = NULL;
620 p->yystack.l_base = NULL;
621 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
622 p->yystack.p_base = NULL;
626 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
627 if (p->yystack.s_base == NULL) return NULL;
628 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
629 if (p->yystack.l_base == NULL) return NULL;
630 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
631 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
632 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
633 if (p->yystack.p_base == NULL) return NULL;
634 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
641 yyFreeState(YYParseState *p)
643 yyfreestack(&p->yystack);
646 #endif /* YYBTYACC */
648 #define YYABORT goto yyabort
649 #define YYREJECT goto yyabort
650 #define YYACCEPT goto yyaccept
651 #define YYERROR goto yyerrlab
653 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
654 #define YYVALID_NESTED do { if (yyps->save && \
655 yyps->save->save == 0) goto yyvalid; } while(0)
656 #endif /* YYBTYACC */
661 int yym, yyn, yystate, yyresult;
664 YYParseState *yyerrctx = NULL;
665 #endif /* YYBTYACC */
666 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
667 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */
672 if ((yys = getenv("YYDEBUG")) != 0)
675 if (yyn >= '0' && yyn <= '9')
679 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
681 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
682 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
686 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
688 #endif /* YYBTYACC */
697 memset(&yystack, 0, sizeof(yystack));
700 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
701 yystack.s_mark = yystack.s_base;
702 yystack.l_mark = yystack.l_base;
703 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
704 yystack.p_mark = yystack.p_base;
710 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
717 /* we're currently re-reading tokens */
719 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
727 /* in trial mode; save scanner results for future parse attempts */
728 if (yylvp == yylvlim)
729 { /* Enlarge lexical value queue */
730 size_t p = (size_t) (yylvp - yylvals);
731 size_t s = (size_t) (yylvlim - yylvals);
733 s += YYLVQUEUEGROWTH;
734 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
735 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
736 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
737 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
739 yylvp = yylve = yylvals + p;
740 yylvlim = yylvals + s;
741 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
742 yylpp = yylpe = yylpsns + p;
743 yylplim = yylpsns + s;
745 yylexp = yylexemes + p;
747 *yylexp = (YYINT) YYLEX;
750 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
757 /* normal operation, no conflict encountered */
758 #endif /* YYBTYACC */
762 #endif /* YYBTYACC */
763 if (yychar < 0) yychar = YYEOF;
767 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
768 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
769 YYDEBUGSTR, yydepth, yystate, yychar, yys);
770 #ifdef YYSTYPE_TOSTRING
773 #endif /* YYBTYACC */
774 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
782 /* Do we have a conflict? */
783 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
784 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
793 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
794 YYDEBUGSTR, yydepth, yystate);
796 /* Switch to the next conflict context */
801 if (save->state != yystate) YYABORT;
808 /* Unresolved conflict - start/continue trial parse */
813 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
815 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
817 fputs("Starting trial parse.\n", stderr);
820 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
821 if (save == NULL) goto yyenomem;
822 save->save = yyps->save;
823 save->state = yystate;
824 save->errflag = yyerrflag;
825 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
826 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
827 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
828 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
829 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
830 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
831 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
834 if (yyctable[ctry] == -1)
837 if (yydebug && yychar >= YYEOF)
838 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
843 if (yyps->save == NULL)
845 /* If this is a first conflict in the stack, start saving lexemes */
848 yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
849 if (yylexemes == NULL) goto yyenomem;
850 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
851 if (yylvals == NULL) goto yyenomem;
852 yylvlim = yylvals + YYLVQUEUEGROWTH;
853 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
854 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
855 if (yylpsns == NULL) goto yyenomem;
856 yylplim = yylpsns + YYLVQUEUEGROWTH;
861 yylvp = yylve = yylvals;
862 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
863 yylpp = yylpe = yylpsns;
869 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
872 *yylexp = (YYINT) yychar;
880 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
886 save->lexeme = (int) (yylvp - yylvals);
889 if (yytable[yyn] == ctry)
893 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
894 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
899 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
904 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
906 yystate = yyctable[ctry];
907 *++yystack.s_mark = (YYINT) yystate;
908 *++yystack.l_mark = yylval;
909 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
910 *++yystack.p_mark = yylloc;
913 if (yyerrflag > 0) --yyerrflag;
918 yyn = yyctable[ctry];
921 } /* End of code dealing with conflicts */
922 #endif /* YYBTYACC */
923 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
924 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
928 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
929 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
931 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
932 yystate = yytable[yyn];
933 *++yystack.s_mark = yytable[yyn];
934 *++yystack.l_mark = yylval;
935 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
936 *++yystack.p_mark = yylloc;
939 if (yyerrflag > 0) --yyerrflag;
942 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
943 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
948 if (yyerrflag != 0) goto yyinrecovery;
953 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
956 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
957 * before looking for error recovery */
958 yystack.s_mark -= yym;
959 yystate = *yystack.s_mark;
960 yystack.l_mark -= yym;
961 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
962 yystack.p_mark -= yym;
970 YYParseState *save = yyps->save;
973 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
974 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
975 (int)(yylvp - yylvals - yyps->save->lexeme));
977 /* Memorize most forward-looking error state in case it's really an error. */
978 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
980 /* Free old saved error context state */
981 if (yyerrctx) yyFreeState(yyerrctx);
982 /* Create and fill out new saved error context state */
983 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
984 if (yyerrctx == NULL) goto yyenomem;
985 yyerrctx->save = yyps->save;
986 yyerrctx->state = yystate;
987 yyerrctx->errflag = yyerrflag;
988 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
989 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
990 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
991 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
992 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
993 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
994 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
996 yyerrctx->lexeme = (int) (yylvp - yylvals);
998 yylvp = yylvals + save->lexeme;
999 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1000 yylpp = yylpsns + save->lexeme;
1002 yylexp = yylexemes + save->lexeme;
1004 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1005 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1006 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1007 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1008 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1009 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1010 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1012 ctry = ++save->ctry;
1013 yystate = save->state;
1014 /* We tried shift, try reduce now */
1015 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1016 yyps->save = save->save;
1020 /* Nothing left on the stack -- error */
1025 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1028 /* Restore state as it was in the most forward-advanced error */
1029 yylvp = yylvals + yyerrctx->lexeme;
1030 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1031 yylpp = yylpsns + yyerrctx->lexeme;
1033 yylexp = yylexemes + yyerrctx->lexeme;
1034 yychar = yylexp[-1];
1036 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1039 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1040 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1041 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1042 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1043 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1044 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1045 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1047 yystate = yyerrctx->state;
1048 yyFreeState(yyerrctx);
1053 if (yynewerrflag == 0) goto yyinrecovery;
1054 #endif /* YYBTYACC */
1056 YYERROR_CALL("syntax error");
1057 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1058 yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */
1062 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1073 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1074 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1078 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1079 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1081 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1082 yystate = yytable[yyn];
1083 *++yystack.s_mark = yytable[yyn];
1084 *++yystack.l_mark = yylval;
1085 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1086 /* lookahead position is error end position */
1087 yyerror_loc_range[2] = yylloc;
1088 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1089 *++yystack.p_mark = yyloc;
1097 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1098 YYDEBUGSTR, yydepth, *yystack.s_mark);
1100 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1101 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1102 /* the current TOS position is the error start position */
1103 yyerror_loc_range[1] = *yystack.p_mark;
1105 #if defined(YYDESTRUCT_CALL)
1108 #endif /* YYBTYACC */
1109 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1110 YYDESTRUCT_CALL("error: discarding state",
1111 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1113 YYDESTRUCT_CALL("error: discarding state",
1114 yystos[*yystack.s_mark], yystack.l_mark);
1115 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1116 #endif /* defined(YYDESTRUCT_CALL) */
1119 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1127 if (yychar == YYEOF) goto yyabort;
1131 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1132 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1133 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1136 #if defined(YYDESTRUCT_CALL)
1139 #endif /* YYBTYACC */
1140 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1141 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1143 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1144 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1145 #endif /* defined(YYDESTRUCT_CALL) */
1155 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1156 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1157 #ifdef YYSTYPE_TOSTRING
1160 #endif /* YYBTYACC */
1165 for (i = yym; i > 0; i--)
1167 if (i != yym) fputs(", ", stderr);
1168 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1169 yystack.l_mark[1-i]), stderr);
1174 fputc('\n', stderr);
1178 yyval = yystack.l_mark[1-yym];
1180 memset(&yyval, 0, sizeof yyval);
1181 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1183 /* Perform position reduction */
1184 memset(&yyloc, 0, sizeof(yyloc));
1187 #endif /* YYBTYACC */
1189 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);
1190 /* just in case YYERROR is invoked within the action, save
1191 the start of the rhs as the error start position */
1192 yyerror_loc_range[1] = yystack.p_mark[1-yym];
1199 #line 35 "quote_calc2.y"
1203 #line 39 "quote_calc2.y"
1204 { printf("%d\n",yystack.l_mark[0]);}
1207 #line 41 "quote_calc2.y"
1208 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1211 #line 45 "quote_calc2.y"
1212 { yyval = yystack.l_mark[-1]; }
1215 #line 47 "quote_calc2.y"
1216 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1219 #line 49 "quote_calc2.y"
1220 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1223 #line 51 "quote_calc2.y"
1224 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1227 #line 53 "quote_calc2.y"
1228 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1231 #line 55 "quote_calc2.y"
1232 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1235 #line 57 "quote_calc2.y"
1236 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1239 #line 59 "quote_calc2.y"
1240 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1243 #line 61 "quote_calc2.y"
1244 { yyval = - yystack.l_mark[0]; }
1247 #line 63 "quote_calc2.y"
1248 { yyval = regs[yystack.l_mark[0]]; }
1251 #line 68 "quote_calc2.y"
1252 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1255 #line 70 "quote_calc2.y"
1256 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1258 #line 1259 "quote_calc2-s.tab.c"
1262 yystack.s_mark -= yym;
1263 yystate = *yystack.s_mark;
1264 yystack.l_mark -= yym;
1265 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1266 yystack.p_mark -= yym;
1269 if (yystate == 0 && yym == 0)
1274 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1275 #ifdef YYSTYPE_TOSTRING
1278 #endif /* YYBTYACC */
1279 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1281 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1285 *++yystack.s_mark = YYFINAL;
1286 *++yystack.l_mark = yyval;
1287 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1288 *++yystack.p_mark = yyloc;
1296 /* we're currently re-reading tokens */
1298 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1306 /* in trial mode; save scanner results for future parse attempts */
1307 if (yylvp == yylvlim)
1308 { /* Enlarge lexical value queue */
1309 size_t p = (size_t) (yylvp - yylvals);
1310 size_t s = (size_t) (yylvlim - yylvals);
1312 s += YYLVQUEUEGROWTH;
1313 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1315 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1317 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1318 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1321 yylvp = yylve = yylvals + p;
1322 yylvlim = yylvals + s;
1323 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1324 yylpp = yylpe = yylpsns + p;
1325 yylplim = yylpsns + s;
1327 yylexp = yylexemes + p;
1329 *yylexp = (YYINT) YYLEX;
1332 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1339 /* normal operation, no conflict encountered */
1340 #endif /* YYBTYACC */
1344 #endif /* YYBTYACC */
1345 if (yychar < 0) yychar = YYEOF;
1349 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1350 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1351 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1355 if (yychar == YYEOF) goto yyaccept;
1358 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1359 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1360 yystate = yytable[yyn];
1362 yystate = yydgoto[yym];
1366 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1367 #ifdef YYSTYPE_TOSTRING
1370 #endif /* YYBTYACC */
1371 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1373 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1376 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1377 *++yystack.s_mark = (YYINT) yystate;
1378 *++yystack.l_mark = yyval;
1379 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1380 *++yystack.p_mark = yyloc;
1385 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1387 if (yypath) YYABORT;
1390 YYParseState *save = yyps->save;
1391 yyps->save = save->save;
1392 save->save = yypath;
1397 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1398 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1402 yyFreeState(yyerrctx);
1405 yylvp = yylvals + yypath->lexeme;
1406 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1407 yylpp = yylpsns + yypath->lexeme;
1409 yylexp = yylexemes + yypath->lexeme;
1411 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1412 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1413 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1414 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1415 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1416 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1417 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1419 yystate = yypath->state;
1421 #endif /* YYBTYACC */
1424 YYERROR_CALL("yacc stack overflow");
1428 YYERROR_CALL("memory exhausted");
1430 #endif /* YYBTYACC */
1440 if (yyps->save) goto yyvalid;
1441 #endif /* YYBTYACC */
1445 #if defined(YYDESTRUCT_CALL)
1446 if (yychar != YYEOF && yychar != YYEMPTY)
1447 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1448 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1450 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1451 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1455 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1458 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1459 YYDESTRUCT_CALL("cleanup: discarding state",
1460 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1462 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1463 YYDESTRUCT_CALL("cleanup: discarding state",
1464 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1465 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1467 #endif /* defined(YYDESTRUCT_CALL) */
1472 yyFreeState(yyerrctx);
1477 YYParseState *save = yyps;
1484 YYParseState *save = yypath;
1485 yypath = save->save;
1489 #endif /* YYBTYACC */
1490 yyfreestack(&yystack);