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.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();
184 #define YYERRCODE 256
186 static const YYINT quote_calc2_lhs[] = { -1,
187 0, 0, 0, 1, 1, 2, 2, 2, 2, 2,
188 2, 2, 2, 2, 2, 2, 3, 3,
190 static const YYINT quote_calc2_len[] = { 2,
191 0, 3, 3, 1, 3, 3, 3, 3, 3, 3,
192 3, 3, 3, 2, 1, 1, 1, 2,
194 static const YYINT quote_calc2_defred[] = { 1,
195 0, 0, 0, 17, 0, 0, 0, 0, 0, 3,
196 15, 0, 0, 0, 2, 0, 0, 0, 0, 0,
197 0, 0, 18, 0, 6, 0, 0, 0, 0, 0,
200 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
201 static const YYINT quote_calc2_stos[] = { 0,
202 273, 256, 260, 269, 270, 40, 274, 275, 276, 10,
203 270, 275, 61, 275, 10, 258, 260, 262, 264, 266,
204 268, 124, 269, 275, 41, 275, 275, 275, 275, 275,
207 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
208 static const YYINT quote_calc2_dgoto[] = { 1,
211 static const YYINT quote_calc2_sindex[] = { 0,
212 -38, 4, -36, 0, -51, -36, 6, -121, -249, 0,
213 0, -243, -36, -23, 0, -36, -36, -36, -36, -36,
214 -36, -36, 0, -121, 0, -121, -121, -121, -121, -121,
217 static const YYINT quote_calc2_rindex[] = { 0,
218 0, 0, 0, 0, -9, 0, 0, 12, -10, 0,
219 0, -5, 0, 0, 0, 0, 0, 0, 0, 0,
220 0, 0, 0, 14, 0, -3, -2, -1, 1, 2,
224 static const YYINT quote_calc2_cindex[] = { 0,
225 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
226 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
227 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
231 static const YYINT quote_calc2_gindex[] = { 0,
234 #define YYTABLESIZE 259
235 static const YYINT quote_calc2_table[] = { 16,
236 15, 6, 22, 6, 14, 13, 7, 8, 9, 13,
237 10, 11, 12, 10, 16, 15, 17, 25, 18, 23,
238 19, 4, 20, 5, 21, 0, 0, 0, 0, 0,
239 16, 0, 0, 0, 0, 14, 13, 7, 8, 9,
240 0, 10, 11, 12, 12, 0, 0, 14, 0, 0,
241 0, 0, 0, 0, 24, 0, 0, 26, 27, 28,
242 29, 30, 31, 32, 0, 0, 0, 0, 0, 0,
243 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
244 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
245 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
246 22, 0, 0, 0, 0, 0, 0, 0, 0, 0,
247 0, 0, 0, 16, 15, 0, 0, 0, 14, 13,
248 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
249 0, 0, 0, 0, 0, 0, 16, 0, 17, 0,
250 18, 0, 19, 0, 20, 0, 21, 0, 0, 0,
251 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
253 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
254 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
255 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
256 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
257 0, 0, 0, 0, 0, 0, 0, 2, 0, 0,
258 0, 3, 0, 3, 0, 0, 0, 0, 0, 0,
259 4, 5, 4, 11, 16, 0, 17, 0, 18, 0,
260 19, 0, 20, 0, 21, 0, 0, 16, 15, 16,
261 15, 16, 15, 16, 15, 16, 15, 16, 15,
263 static const YYINT quote_calc2_check[] = { 10,
264 10, 40, 124, 40, 10, 10, 10, 10, 10, 61,
265 10, 10, 10, 10, 258, 10, 260, 41, 262, 269,
266 264, 10, 266, 10, 268, -1, -1, -1, -1, -1,
267 41, -1, -1, -1, -1, 41, 41, 41, 41, 41,
268 -1, 41, 41, 41, 3, -1, -1, 6, -1, -1,
269 -1, -1, -1, -1, 13, -1, -1, 16, 17, 18,
270 19, 20, 21, 22, -1, -1, -1, -1, -1, -1,
271 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
272 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
273 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
274 124, -1, -1, -1, -1, -1, -1, -1, -1, -1,
275 -1, -1, -1, 124, 124, -1, -1, -1, 124, 124,
276 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
277 -1, -1, -1, -1, -1, -1, 258, -1, 260, -1,
278 262, -1, 264, -1, 266, -1, 268, -1, -1, -1,
279 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
280 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
281 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
282 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
283 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
284 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
285 -1, -1, -1, -1, -1, -1, -1, 256, -1, -1,
286 -1, 260, -1, 260, -1, -1, -1, -1, -1, -1,
287 269, 270, 269, 270, 258, -1, 260, -1, 262, -1,
288 264, -1, 266, -1, 268, -1, -1, 258, 258, 260,
289 260, 262, 262, 264, 264, 266, 266, 268, 268,
292 static const YYINT quote_calc2_ctable[] = { -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, -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,
325 #define YYMAXTOKEN 271
326 #define YYUNDFTOKEN 277
327 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
329 static const char *const quote_calc2_name[] = {
331 "$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,
332 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
333 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
334 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0,
335 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
336 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
337 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
338 0,0,"error","OP_ADD","\"ADD\"","OP_SUB","\"SUB\"","OP_MUL","\"MUL\"","OP_DIV",
339 "\"DIV\"","OP_MOD","\"MOD\"","OP_AND","\"AND\"","DIGIT","LETTER","UMINUS",
340 "$accept","list","stat","expr","number","illegal-symbol",
342 static const char *const quote_calc2_rule[] = {
345 "list : list stat '\\n'",
346 "list : list error '\\n'",
348 "stat : LETTER '=' expr",
349 "expr : '(' expr ')'",
350 "expr : expr \"ADD\" expr",
351 "expr : expr \"SUB\" expr",
352 "expr : expr \"MUL\" expr",
353 "expr : expr \"DIV\" expr",
354 "expr : expr \"MOD\" expr",
355 "expr : expr \"AND\" expr",
356 "expr : expr '|' expr",
357 "expr : \"SUB\" expr",
361 "number : number DIGIT",
376 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
377 YYLTYPE yyloc; /* position returned by actions */
378 YYLTYPE yylloc; /* position from the lexer */
381 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
382 #ifndef YYLLOC_DEFAULT
383 #define YYLLOC_DEFAULT(loc, rhs, n) \
388 (loc).first_line = YYRHSLOC(rhs, 0).last_line; \
389 (loc).first_column = YYRHSLOC(rhs, 0).last_column; \
390 (loc).last_line = YYRHSLOC(rhs, 0).last_line; \
391 (loc).last_column = YYRHSLOC(rhs, 0).last_column; \
395 (loc).first_line = YYRHSLOC(rhs, 1).first_line; \
396 (loc).first_column = YYRHSLOC(rhs, 1).first_column; \
397 (loc).last_line = YYRHSLOC(rhs, n).last_line; \
398 (loc).last_column = YYRHSLOC(rhs, n).last_column; \
401 #endif /* YYLLOC_DEFAULT */
402 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
405 #ifndef YYLVQUEUEGROWTH
406 #define YYLVQUEUEGROWTH 32
408 #endif /* YYBTYACC */
410 /* define the initial stack-sizes */
413 #define YYMAXDEPTH YYSTACKSIZE
416 #define YYSTACKSIZE YYMAXDEPTH
418 #define YYSTACKSIZE 10000
419 #define YYMAXDEPTH 10000
423 #ifndef YYINITSTACKSIZE
424 #define YYINITSTACKSIZE 200
434 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
441 struct YYParseState_s
443 struct YYParseState_s *save; /* Previously saved parser state */
444 YYSTACKDATA yystack; /* saved parser stack */
445 int state; /* saved parser state */
446 int errflag; /* saved error recovery status */
447 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
448 YYINT ctry; /* saved index in yyctable[] for this conflict */
450 typedef struct YYParseState_s YYParseState;
451 #endif /* YYBTYACC */
452 /* variables for the parser stack */
453 static YYSTACKDATA yystack;
456 /* Current parser state */
457 static YYParseState *yyps = 0;
459 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
460 static YYParseState *yypath = 0;
462 /* Base of the lexical value queue */
463 static YYSTYPE *yylvals = 0;
465 /* Current position at lexical value queue */
466 static YYSTYPE *yylvp = 0;
468 /* End position of lexical value queue */
469 static YYSTYPE *yylve = 0;
471 /* The last allocated position at the lexical value queue */
472 static YYSTYPE *yylvlim = 0;
474 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
475 /* Base of the lexical position queue */
476 static YYLTYPE *yylpsns = 0;
478 /* Current position at lexical position queue */
479 static YYLTYPE *yylpp = 0;
481 /* End position of lexical position queue */
482 static YYLTYPE *yylpe = 0;
484 /* The last allocated position at the lexical position queue */
485 static YYLTYPE *yylplim = 0;
488 /* Current position at lexical token queue */
489 static YYINT *yylexp = 0;
491 static YYINT *yylexemes = 0;
492 #endif /* YYBTYACC */
493 #line 73 "quote_calc2.y"
494 /* start of programs */
499 while(!feof(stdin)) {
506 yyerror(const char *s)
508 fprintf(stderr, "%s\n", s);
513 /* lexical analysis routine */
514 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
515 /* return DIGIT for a digit, yylval = 0 through 9 */
516 /* all other characters are returned immediately */
520 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
522 /* c is now nonblank */
534 #line 535 "quote_calc2.tab.c"
536 /* For use in generated program */
537 #define yydepth (int)(yystack.s_mark - yystack.s_base)
539 #define yytrial (yyps->save)
540 #endif /* YYBTYACC */
543 #include <stdio.h> /* needed for printf */
546 #include <stdlib.h> /* needed for malloc, etc */
547 #include <string.h> /* needed for memset */
549 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
550 static int yygrowstack(YYSTACKDATA *data)
556 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
560 if ((newsize = data->stacksize) == 0)
561 newsize = YYINITSTACKSIZE;
562 else if (newsize >= YYMAXDEPTH)
564 else if ((newsize *= 2) > YYMAXDEPTH)
565 newsize = YYMAXDEPTH;
567 i = (int) (data->s_mark - data->s_base);
568 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
572 data->s_base = newss;
573 data->s_mark = newss + i;
575 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
579 data->l_base = newvs;
580 data->l_mark = newvs + i;
582 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
583 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
587 data->p_base = newps;
588 data->p_mark = newps + i;
591 data->stacksize = newsize;
592 data->s_last = data->s_base + newsize - 1;
596 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
601 #if YYPURE || defined(YY_NO_LEAKS)
602 static void yyfreestack(YYSTACKDATA *data)
606 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
609 memset(data, 0, sizeof(*data));
612 #define yyfreestack(data) /* nothing */
613 #endif /* YYPURE || defined(YY_NO_LEAKS) */
616 static YYParseState *
617 yyNewState(unsigned size)
619 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
620 if (p == NULL) return NULL;
622 p->yystack.stacksize = size;
625 p->yystack.s_base = NULL;
626 p->yystack.l_base = NULL;
627 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
628 p->yystack.p_base = NULL;
632 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
633 if (p->yystack.s_base == NULL) return NULL;
634 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
635 if (p->yystack.l_base == NULL) return NULL;
636 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
637 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
638 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
639 if (p->yystack.p_base == NULL) return NULL;
640 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
647 yyFreeState(YYParseState *p)
649 yyfreestack(&p->yystack);
652 #endif /* YYBTYACC */
654 #define YYABORT goto yyabort
655 #define YYREJECT goto yyabort
656 #define YYACCEPT goto yyaccept
657 #define YYERROR goto yyerrlab
659 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
660 #define YYVALID_NESTED do { if (yyps->save && \
661 yyps->save->save == 0) goto yyvalid; } while(0)
662 #endif /* YYBTYACC */
667 int yym, yyn, yystate, yyresult;
670 YYParseState *yyerrctx = NULL;
671 #endif /* YYBTYACC */
672 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
673 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */
678 if ((yys = getenv("YYDEBUG")) != 0)
681 if (yyn >= '0' && yyn <= '9')
685 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
687 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
688 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
692 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
694 #endif /* YYBTYACC */
703 memset(&yystack, 0, sizeof(yystack));
706 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
707 yystack.s_mark = yystack.s_base;
708 yystack.l_mark = yystack.l_base;
709 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
710 yystack.p_mark = yystack.p_base;
716 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
723 /* we're currently re-reading tokens */
725 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
733 /* in trial mode; save scanner results for future parse attempts */
734 if (yylvp == yylvlim)
735 { /* Enlarge lexical value queue */
736 size_t p = (size_t) (yylvp - yylvals);
737 size_t s = (size_t) (yylvlim - yylvals);
739 s += YYLVQUEUEGROWTH;
740 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
741 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
742 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
743 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
745 yylvp = yylve = yylvals + p;
746 yylvlim = yylvals + s;
747 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
748 yylpp = yylpe = yylpsns + p;
749 yylplim = yylpsns + s;
751 yylexp = yylexemes + p;
753 *yylexp = (YYINT) YYLEX;
756 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
763 /* normal operation, no conflict encountered */
764 #endif /* YYBTYACC */
768 #endif /* YYBTYACC */
769 if (yychar < 0) yychar = YYEOF;
773 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
774 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
775 YYDEBUGSTR, yydepth, yystate, yychar, yys);
776 #ifdef YYSTYPE_TOSTRING
779 #endif /* YYBTYACC */
780 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
788 /* Do we have a conflict? */
789 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
790 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
799 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
800 YYDEBUGSTR, yydepth, yystate);
802 /* Switch to the next conflict context */
807 if (save->state != yystate) YYABORT;
814 /* Unresolved conflict - start/continue trial parse */
819 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
821 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
823 fputs("Starting trial parse.\n", stderr);
826 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
827 if (save == NULL) goto yyenomem;
828 save->save = yyps->save;
829 save->state = yystate;
830 save->errflag = yyerrflag;
831 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
832 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
833 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
834 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
835 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
836 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
837 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
840 if (yyctable[ctry] == -1)
843 if (yydebug && yychar >= YYEOF)
844 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
849 if (yyps->save == NULL)
851 /* If this is a first conflict in the stack, start saving lexemes */
854 yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
855 if (yylexemes == NULL) goto yyenomem;
856 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
857 if (yylvals == NULL) goto yyenomem;
858 yylvlim = yylvals + YYLVQUEUEGROWTH;
859 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
860 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
861 if (yylpsns == NULL) goto yyenomem;
862 yylplim = yylpsns + YYLVQUEUEGROWTH;
867 yylvp = yylve = yylvals;
868 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
869 yylpp = yylpe = yylpsns;
875 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
878 *yylexp = (YYINT) yychar;
886 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
892 save->lexeme = (int) (yylvp - yylvals);
895 if (yytable[yyn] == ctry)
899 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
900 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
905 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
910 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
912 yystate = yyctable[ctry];
913 *++yystack.s_mark = (YYINT) yystate;
914 *++yystack.l_mark = yylval;
915 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
916 *++yystack.p_mark = yylloc;
919 if (yyerrflag > 0) --yyerrflag;
924 yyn = yyctable[ctry];
927 } /* End of code dealing with conflicts */
928 #endif /* YYBTYACC */
929 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
930 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
934 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
935 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
937 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
938 yystate = yytable[yyn];
939 *++yystack.s_mark = yytable[yyn];
940 *++yystack.l_mark = yylval;
941 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
942 *++yystack.p_mark = yylloc;
945 if (yyerrflag > 0) --yyerrflag;
948 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
949 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
954 if (yyerrflag != 0) goto yyinrecovery;
959 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
962 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
963 * before looking for error recovery */
964 yystack.s_mark -= yym;
965 yystate = *yystack.s_mark;
966 yystack.l_mark -= yym;
967 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
968 yystack.p_mark -= yym;
976 YYParseState *save = yyps->save;
979 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
980 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
981 (int)(yylvp - yylvals - yyps->save->lexeme));
983 /* Memorize most forward-looking error state in case it's really an error. */
984 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
986 /* Free old saved error context state */
987 if (yyerrctx) yyFreeState(yyerrctx);
988 /* Create and fill out new saved error context state */
989 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
990 if (yyerrctx == NULL) goto yyenomem;
991 yyerrctx->save = yyps->save;
992 yyerrctx->state = yystate;
993 yyerrctx->errflag = yyerrflag;
994 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
995 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
996 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
997 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
998 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
999 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1000 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1002 yyerrctx->lexeme = (int) (yylvp - yylvals);
1004 yylvp = yylvals + save->lexeme;
1005 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1006 yylpp = yylpsns + save->lexeme;
1008 yylexp = yylexemes + save->lexeme;
1010 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1011 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1012 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1013 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1014 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1015 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1016 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1018 ctry = ++save->ctry;
1019 yystate = save->state;
1020 /* We tried shift, try reduce now */
1021 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1022 yyps->save = save->save;
1026 /* Nothing left on the stack -- error */
1031 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1034 /* Restore state as it was in the most forward-advanced error */
1035 yylvp = yylvals + yyerrctx->lexeme;
1036 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1037 yylpp = yylpsns + yyerrctx->lexeme;
1039 yylexp = yylexemes + yyerrctx->lexeme;
1040 yychar = yylexp[-1];
1042 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1045 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1046 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1047 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1048 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1049 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1050 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1051 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1053 yystate = yyerrctx->state;
1054 yyFreeState(yyerrctx);
1059 if (yynewerrflag == 0) goto yyinrecovery;
1060 #endif /* YYBTYACC */
1062 YYERROR_CALL("syntax error");
1063 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1064 yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */
1068 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1079 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1080 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1084 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1085 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1087 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1088 yystate = yytable[yyn];
1089 *++yystack.s_mark = yytable[yyn];
1090 *++yystack.l_mark = yylval;
1091 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1092 /* lookahead position is error end position */
1093 yyerror_loc_range[2] = yylloc;
1094 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1095 *++yystack.p_mark = yyloc;
1103 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1104 YYDEBUGSTR, yydepth, *yystack.s_mark);
1106 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1107 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1108 /* the current TOS position is the error start position */
1109 yyerror_loc_range[1] = *yystack.p_mark;
1111 #if defined(YYDESTRUCT_CALL)
1114 #endif /* YYBTYACC */
1115 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1116 YYDESTRUCT_CALL("error: discarding state",
1117 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1119 YYDESTRUCT_CALL("error: discarding state",
1120 yystos[*yystack.s_mark], yystack.l_mark);
1121 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1122 #endif /* defined(YYDESTRUCT_CALL) */
1125 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1133 if (yychar == YYEOF) goto yyabort;
1137 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1138 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1139 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1142 #if defined(YYDESTRUCT_CALL)
1145 #endif /* YYBTYACC */
1146 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1147 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1149 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1150 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1151 #endif /* defined(YYDESTRUCT_CALL) */
1161 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1162 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1163 #ifdef YYSTYPE_TOSTRING
1166 #endif /* YYBTYACC */
1171 for (i = yym; i > 0; i--)
1173 if (i != yym) fputs(", ", stderr);
1174 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1175 yystack.l_mark[1-i]), stderr);
1180 fputc('\n', stderr);
1184 yyval = yystack.l_mark[1-yym];
1186 memset(&yyval, 0, sizeof yyval);
1187 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1189 /* Perform position reduction */
1190 memset(&yyloc, 0, sizeof(yyloc));
1193 #endif /* YYBTYACC */
1195 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);
1196 /* just in case YYERROR is invoked within the action, save
1197 the start of the rhs as the error start position */
1198 yyerror_loc_range[1] = yystack.p_mark[1-yym];
1205 #line 35 "quote_calc2.y"
1209 #line 39 "quote_calc2.y"
1210 { printf("%d\n",yystack.l_mark[0]);}
1213 #line 41 "quote_calc2.y"
1214 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1217 #line 45 "quote_calc2.y"
1218 { yyval = yystack.l_mark[-1]; }
1221 #line 47 "quote_calc2.y"
1222 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1225 #line 49 "quote_calc2.y"
1226 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1229 #line 51 "quote_calc2.y"
1230 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1233 #line 53 "quote_calc2.y"
1234 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1237 #line 55 "quote_calc2.y"
1238 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1241 #line 57 "quote_calc2.y"
1242 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1245 #line 59 "quote_calc2.y"
1246 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1249 #line 61 "quote_calc2.y"
1250 { yyval = - yystack.l_mark[0]; }
1253 #line 63 "quote_calc2.y"
1254 { yyval = regs[yystack.l_mark[0]]; }
1257 #line 68 "quote_calc2.y"
1258 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1261 #line 70 "quote_calc2.y"
1262 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1264 #line 1265 "quote_calc2.tab.c"
1268 yystack.s_mark -= yym;
1269 yystate = *yystack.s_mark;
1270 yystack.l_mark -= yym;
1271 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1272 yystack.p_mark -= yym;
1275 if (yystate == 0 && yym == 0)
1280 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1281 #ifdef YYSTYPE_TOSTRING
1284 #endif /* YYBTYACC */
1285 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1287 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1291 *++yystack.s_mark = YYFINAL;
1292 *++yystack.l_mark = yyval;
1293 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1294 *++yystack.p_mark = yyloc;
1302 /* we're currently re-reading tokens */
1304 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1312 /* in trial mode; save scanner results for future parse attempts */
1313 if (yylvp == yylvlim)
1314 { /* Enlarge lexical value queue */
1315 size_t p = (size_t) (yylvp - yylvals);
1316 size_t s = (size_t) (yylvlim - yylvals);
1318 s += YYLVQUEUEGROWTH;
1319 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1321 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1323 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1324 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1327 yylvp = yylve = yylvals + p;
1328 yylvlim = yylvals + s;
1329 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1330 yylpp = yylpe = yylpsns + p;
1331 yylplim = yylpsns + s;
1333 yylexp = yylexemes + p;
1335 *yylexp = (YYINT) YYLEX;
1338 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1345 /* normal operation, no conflict encountered */
1346 #endif /* YYBTYACC */
1350 #endif /* YYBTYACC */
1351 if (yychar < 0) yychar = YYEOF;
1355 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1356 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1357 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1361 if (yychar == YYEOF) goto yyaccept;
1364 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1365 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1366 yystate = yytable[yyn];
1368 yystate = yydgoto[yym];
1372 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1373 #ifdef YYSTYPE_TOSTRING
1376 #endif /* YYBTYACC */
1377 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1379 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1382 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1383 *++yystack.s_mark = (YYINT) yystate;
1384 *++yystack.l_mark = yyval;
1385 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1386 *++yystack.p_mark = yyloc;
1391 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1393 if (yypath) YYABORT;
1396 YYParseState *save = yyps->save;
1397 yyps->save = save->save;
1398 save->save = yypath;
1403 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1404 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1408 yyFreeState(yyerrctx);
1411 yylvp = yylvals + yypath->lexeme;
1412 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1413 yylpp = yylpsns + yypath->lexeme;
1415 yylexp = yylexemes + yypath->lexeme;
1417 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1418 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1419 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1420 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1421 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1422 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1423 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1425 yystate = yypath->state;
1427 #endif /* YYBTYACC */
1430 YYERROR_CALL("yacc stack overflow");
1434 YYERROR_CALL("memory exhausted");
1436 #endif /* YYBTYACC */
1446 if (yyps->save) goto yyvalid;
1447 #endif /* YYBTYACC */
1451 #if defined(YYDESTRUCT_CALL)
1452 if (yychar != YYEOF && yychar != YYEMPTY)
1453 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1454 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1456 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1457 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1461 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1464 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1465 YYDESTRUCT_CALL("cleanup: discarding state",
1466 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1468 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1469 YYDESTRUCT_CALL("cleanup: discarding state",
1470 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1471 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1473 #endif /* defined(YYDESTRUCT_CALL) */
1478 yyFreeState(yyerrctx);
1483 YYParseState *save = yyps;
1490 YYParseState *save = yypath;
1491 yypath = save->save;
1495 #endif /* YYBTYACC */
1496 yyfreestack(&yystack);