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_calc4_parse
25 #define yylex quote_calc4_lex
29 #define yyerror quote_calc4_error
33 #define yychar quote_calc4_char
37 #define yyval quote_calc4_val
41 #define yylval quote_calc4_lval
45 #define yydebug quote_calc4_debug
49 #define yynerrs quote_calc4_nerrs
53 #define yyerrflag quote_calc4_errflag
54 #endif /* yyerrflag */
57 #define yylhs quote_calc4_lhs
61 #define yylen quote_calc4_len
65 #define yydefred quote_calc4_defred
69 #define yystos quote_calc4_stos
73 #define yydgoto quote_calc4_dgoto
77 #define yysindex quote_calc4_sindex
81 #define yyrindex quote_calc4_rindex
85 #define yygindex quote_calc4_gindex
89 #define yytable quote_calc4_table
93 #define yycheck quote_calc4_check
97 #define yyname quote_calc4_name
101 #define yyrule quote_calc4_rule
107 #define yycindex quote_calc4_cindex
108 #endif /* yycindex */
111 #define yyctable quote_calc4_ctable
112 #endif /* yyctable */
114 #endif /* YYBTYACC */
116 #define YYPREFIX "quote_calc4_"
120 #line 2 "quote_calc4.y"
128 static void yyerror(const char *s);
130 #line 131 "quote_calc4-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_calc4_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_calc4_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_calc4_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_calc4_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_calc4_dgoto[] = { 1,
205 static const YYINT quote_calc4_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_calc4_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_calc4_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_calc4_gindex[] = { 0,
228 #define YYTABLESIZE 259
229 static const YYINT quote_calc4_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_calc4_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_calc4_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_calc4_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-operator\"","OP_SUB","\"SUB-operator\"","OP_MUL",
333 "\"MUL-operator\"","OP_DIV","\"DIV-operator\"","OP_MOD","\"MOD-operator\"",
334 "OP_AND","\"AND-operator\"","DIGIT","LETTER","UMINUS","$accept","list","stat",
335 "expr","number","illegal-symbol",
337 static const char *const quote_calc4_rule[] = {
340 "list : list stat '\\n'",
341 "list : list error '\\n'",
343 "stat : LETTER '=' expr",
344 "expr : '(' expr ')'",
345 "expr : expr \"ADD-operator\" expr",
346 "expr : expr \"SUB-operator\" expr",
347 "expr : expr \"MUL-operator\" expr",
348 "expr : expr \"DIV-operator\" expr",
349 "expr : expr \"MOD-operator\" expr",
350 "expr : expr \"AND-operator\" expr",
351 "expr : expr '|' expr",
352 "expr : \"SUB-operator\" expr",
356 "number : number DIGIT",
371 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
372 YYLTYPE yyloc; /* position returned by actions */
373 YYLTYPE yylloc; /* position from the lexer */
376 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
377 #ifndef YYLLOC_DEFAULT
378 #define YYLLOC_DEFAULT(loc, rhs, n) \
383 (loc).first_line = YYRHSLOC(rhs, 0).last_line; \
384 (loc).first_column = YYRHSLOC(rhs, 0).last_column; \
385 (loc).last_line = YYRHSLOC(rhs, 0).last_line; \
386 (loc).last_column = YYRHSLOC(rhs, 0).last_column; \
390 (loc).first_line = YYRHSLOC(rhs, 1).first_line; \
391 (loc).first_column = YYRHSLOC(rhs, 1).first_column; \
392 (loc).last_line = YYRHSLOC(rhs, n).last_line; \
393 (loc).last_column = YYRHSLOC(rhs, n).last_column; \
396 #endif /* YYLLOC_DEFAULT */
397 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
400 #ifndef YYLVQUEUEGROWTH
401 #define YYLVQUEUEGROWTH 32
403 #endif /* YYBTYACC */
405 /* define the initial stack-sizes */
408 #define YYMAXDEPTH YYSTACKSIZE
411 #define YYSTACKSIZE YYMAXDEPTH
413 #define YYSTACKSIZE 10000
414 #define YYMAXDEPTH 10000
418 #ifndef YYINITSTACKSIZE
419 #define YYINITSTACKSIZE 200
429 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
436 struct YYParseState_s
438 struct YYParseState_s *save; /* Previously saved parser state */
439 YYSTACKDATA yystack; /* saved parser stack */
440 int state; /* saved parser state */
441 int errflag; /* saved error recovery status */
442 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
443 YYINT ctry; /* saved index in yyctable[] for this conflict */
445 typedef struct YYParseState_s YYParseState;
446 #endif /* YYBTYACC */
447 /* variables for the parser stack */
448 static YYSTACKDATA yystack;
451 /* Current parser state */
452 static YYParseState *yyps = 0;
454 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
455 static YYParseState *yypath = 0;
457 /* Base of the lexical value queue */
458 static YYSTYPE *yylvals = 0;
460 /* Current position at lexical value queue */
461 static YYSTYPE *yylvp = 0;
463 /* End position of lexical value queue */
464 static YYSTYPE *yylve = 0;
466 /* The last allocated position at the lexical value queue */
467 static YYSTYPE *yylvlim = 0;
469 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
470 /* Base of the lexical position queue */
471 static YYLTYPE *yylpsns = 0;
473 /* Current position at lexical position queue */
474 static YYLTYPE *yylpp = 0;
476 /* End position of lexical position queue */
477 static YYLTYPE *yylpe = 0;
479 /* The last allocated position at the lexical position queue */
480 static YYLTYPE *yylplim = 0;
483 /* Current position at lexical token queue */
484 static YYINT *yylexp = 0;
486 static YYINT *yylexemes = 0;
487 #endif /* YYBTYACC */
488 #line 73 "quote_calc4.y"
489 /* start of programs */
494 while(!feof(stdin)) {
501 yyerror(const char *s)
503 fprintf(stderr, "%s\n", s);
508 /* lexical analysis routine */
509 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
510 /* return DIGIT for a digit, yylval = 0 through 9 */
511 /* all other characters are returned immediately */
515 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
517 /* c is now nonblank */
529 #line 530 "quote_calc4-s.tab.c"
531 /* For use in generated program */
532 #define yydepth (int)(yystack.s_mark - yystack.s_base)
534 #define yytrial (yyps->save)
535 #endif /* YYBTYACC */
538 #include <stdio.h> /* needed for printf */
541 #include <stdlib.h> /* needed for malloc, etc */
542 #include <string.h> /* needed for memset */
544 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
545 static int yygrowstack(YYSTACKDATA *data)
551 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
555 if ((newsize = data->stacksize) == 0)
556 newsize = YYINITSTACKSIZE;
557 else if (newsize >= YYMAXDEPTH)
559 else if ((newsize *= 2) > YYMAXDEPTH)
560 newsize = YYMAXDEPTH;
562 i = (int) (data->s_mark - data->s_base);
563 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
567 data->s_base = newss;
568 data->s_mark = newss + i;
570 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
574 data->l_base = newvs;
575 data->l_mark = newvs + i;
577 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
578 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
582 data->p_base = newps;
583 data->p_mark = newps + i;
586 data->stacksize = newsize;
587 data->s_last = data->s_base + newsize - 1;
591 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
596 #if YYPURE || defined(YY_NO_LEAKS)
597 static void yyfreestack(YYSTACKDATA *data)
601 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
604 memset(data, 0, sizeof(*data));
607 #define yyfreestack(data) /* nothing */
608 #endif /* YYPURE || defined(YY_NO_LEAKS) */
611 static YYParseState *
612 yyNewState(unsigned size)
614 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
615 if (p == NULL) return NULL;
617 p->yystack.stacksize = size;
620 p->yystack.s_base = NULL;
621 p->yystack.l_base = NULL;
622 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
623 p->yystack.p_base = NULL;
627 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
628 if (p->yystack.s_base == NULL) return NULL;
629 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
630 if (p->yystack.l_base == NULL) return NULL;
631 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
632 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
633 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
634 if (p->yystack.p_base == NULL) return NULL;
635 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
642 yyFreeState(YYParseState *p)
644 yyfreestack(&p->yystack);
647 #endif /* YYBTYACC */
649 #define YYABORT goto yyabort
650 #define YYREJECT goto yyabort
651 #define YYACCEPT goto yyaccept
652 #define YYERROR goto yyerrlab
654 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
655 #define YYVALID_NESTED do { if (yyps->save && \
656 yyps->save->save == 0) goto yyvalid; } while(0)
657 #endif /* YYBTYACC */
662 int yym, yyn, yystate, yyresult;
665 YYParseState *yyerrctx = NULL;
666 #endif /* YYBTYACC */
667 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
668 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */
673 if ((yys = getenv("YYDEBUG")) != 0)
676 if (yyn >= '0' && yyn <= '9')
680 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
682 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
683 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
687 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
689 #endif /* YYBTYACC */
698 memset(&yystack, 0, sizeof(yystack));
701 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
702 yystack.s_mark = yystack.s_base;
703 yystack.l_mark = yystack.l_base;
704 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
705 yystack.p_mark = yystack.p_base;
711 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
718 /* we're currently re-reading tokens */
720 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
728 /* in trial mode; save scanner results for future parse attempts */
729 if (yylvp == yylvlim)
730 { /* Enlarge lexical value queue */
731 size_t p = (size_t) (yylvp - yylvals);
732 size_t s = (size_t) (yylvlim - yylvals);
734 s += YYLVQUEUEGROWTH;
735 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
736 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
737 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
738 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
740 yylvp = yylve = yylvals + p;
741 yylvlim = yylvals + s;
742 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
743 yylpp = yylpe = yylpsns + p;
744 yylplim = yylpsns + s;
746 yylexp = yylexemes + p;
748 *yylexp = (YYINT) YYLEX;
751 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
758 /* normal operation, no conflict encountered */
759 #endif /* YYBTYACC */
763 #endif /* YYBTYACC */
764 if (yychar < 0) yychar = YYEOF;
768 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
769 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
770 YYDEBUGSTR, yydepth, yystate, yychar, yys);
771 #ifdef YYSTYPE_TOSTRING
774 #endif /* YYBTYACC */
775 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
783 /* Do we have a conflict? */
784 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
785 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
794 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
795 YYDEBUGSTR, yydepth, yystate);
797 /* Switch to the next conflict context */
802 if (save->state != yystate) YYABORT;
809 /* Unresolved conflict - start/continue trial parse */
814 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
816 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
818 fputs("Starting trial parse.\n", stderr);
821 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
822 if (save == NULL) goto yyenomem;
823 save->save = yyps->save;
824 save->state = yystate;
825 save->errflag = yyerrflag;
826 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
827 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
828 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
829 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
830 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
831 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
832 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
835 if (yyctable[ctry] == -1)
838 if (yydebug && yychar >= YYEOF)
839 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
844 if (yyps->save == NULL)
846 /* If this is a first conflict in the stack, start saving lexemes */
849 yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
850 if (yylexemes == NULL) goto yyenomem;
851 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
852 if (yylvals == NULL) goto yyenomem;
853 yylvlim = yylvals + YYLVQUEUEGROWTH;
854 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
855 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
856 if (yylpsns == NULL) goto yyenomem;
857 yylplim = yylpsns + YYLVQUEUEGROWTH;
862 yylvp = yylve = yylvals;
863 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
864 yylpp = yylpe = yylpsns;
870 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
873 *yylexp = (YYINT) yychar;
881 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
887 save->lexeme = (int) (yylvp - yylvals);
890 if (yytable[yyn] == ctry)
894 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
895 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
900 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
905 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
907 yystate = yyctable[ctry];
908 *++yystack.s_mark = (YYINT) yystate;
909 *++yystack.l_mark = yylval;
910 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
911 *++yystack.p_mark = yylloc;
914 if (yyerrflag > 0) --yyerrflag;
919 yyn = yyctable[ctry];
922 } /* End of code dealing with conflicts */
923 #endif /* YYBTYACC */
924 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
925 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
929 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
930 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
932 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
933 yystate = yytable[yyn];
934 *++yystack.s_mark = yytable[yyn];
935 *++yystack.l_mark = yylval;
936 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
937 *++yystack.p_mark = yylloc;
940 if (yyerrflag > 0) --yyerrflag;
943 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
944 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
949 if (yyerrflag != 0) goto yyinrecovery;
954 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
957 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
958 * before looking for error recovery */
959 yystack.s_mark -= yym;
960 yystate = *yystack.s_mark;
961 yystack.l_mark -= yym;
962 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
963 yystack.p_mark -= yym;
971 YYParseState *save = yyps->save;
974 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
975 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
976 (int)(yylvp - yylvals - yyps->save->lexeme));
978 /* Memorize most forward-looking error state in case it's really an error. */
979 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
981 /* Free old saved error context state */
982 if (yyerrctx) yyFreeState(yyerrctx);
983 /* Create and fill out new saved error context state */
984 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
985 if (yyerrctx == NULL) goto yyenomem;
986 yyerrctx->save = yyps->save;
987 yyerrctx->state = yystate;
988 yyerrctx->errflag = yyerrflag;
989 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
990 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
991 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
992 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
993 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
994 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
995 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
997 yyerrctx->lexeme = (int) (yylvp - yylvals);
999 yylvp = yylvals + save->lexeme;
1000 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1001 yylpp = yylpsns + save->lexeme;
1003 yylexp = yylexemes + save->lexeme;
1005 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1006 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1007 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1008 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1009 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1010 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1011 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1013 ctry = ++save->ctry;
1014 yystate = save->state;
1015 /* We tried shift, try reduce now */
1016 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1017 yyps->save = save->save;
1021 /* Nothing left on the stack -- error */
1026 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1029 /* Restore state as it was in the most forward-advanced error */
1030 yylvp = yylvals + yyerrctx->lexeme;
1031 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1032 yylpp = yylpsns + yyerrctx->lexeme;
1034 yylexp = yylexemes + yyerrctx->lexeme;
1035 yychar = yylexp[-1];
1037 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1040 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1041 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1042 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1043 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1044 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1045 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1046 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1048 yystate = yyerrctx->state;
1049 yyFreeState(yyerrctx);
1054 if (yynewerrflag == 0) goto yyinrecovery;
1055 #endif /* YYBTYACC */
1057 YYERROR_CALL("syntax error");
1058 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1059 yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */
1063 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1074 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1075 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1079 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1080 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1082 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1083 yystate = yytable[yyn];
1084 *++yystack.s_mark = yytable[yyn];
1085 *++yystack.l_mark = yylval;
1086 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1087 /* lookahead position is error end position */
1088 yyerror_loc_range[2] = yylloc;
1089 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1090 *++yystack.p_mark = yyloc;
1098 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1099 YYDEBUGSTR, yydepth, *yystack.s_mark);
1101 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1102 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1103 /* the current TOS position is the error start position */
1104 yyerror_loc_range[1] = *yystack.p_mark;
1106 #if defined(YYDESTRUCT_CALL)
1109 #endif /* YYBTYACC */
1110 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1111 YYDESTRUCT_CALL("error: discarding state",
1112 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1114 YYDESTRUCT_CALL("error: discarding state",
1115 yystos[*yystack.s_mark], yystack.l_mark);
1116 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1117 #endif /* defined(YYDESTRUCT_CALL) */
1120 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1128 if (yychar == YYEOF) goto yyabort;
1132 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1133 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1134 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1137 #if defined(YYDESTRUCT_CALL)
1140 #endif /* YYBTYACC */
1141 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1142 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1144 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1145 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1146 #endif /* defined(YYDESTRUCT_CALL) */
1156 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1157 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1158 #ifdef YYSTYPE_TOSTRING
1161 #endif /* YYBTYACC */
1166 for (i = yym; i > 0; i--)
1168 if (i != yym) fputs(", ", stderr);
1169 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1170 yystack.l_mark[1-i]), stderr);
1175 fputc('\n', stderr);
1179 yyval = yystack.l_mark[1-yym];
1181 memset(&yyval, 0, sizeof yyval);
1182 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1184 /* Perform position reduction */
1185 memset(&yyloc, 0, sizeof(yyloc));
1188 #endif /* YYBTYACC */
1190 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);
1191 /* just in case YYERROR is invoked within the action, save
1192 the start of the rhs as the error start position */
1193 yyerror_loc_range[1] = yystack.p_mark[1-yym];
1200 #line 35 "quote_calc4.y"
1204 #line 39 "quote_calc4.y"
1205 { printf("%d\n",yystack.l_mark[0]);}
1208 #line 41 "quote_calc4.y"
1209 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1212 #line 45 "quote_calc4.y"
1213 { yyval = yystack.l_mark[-1]; }
1216 #line 47 "quote_calc4.y"
1217 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1220 #line 49 "quote_calc4.y"
1221 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1224 #line 51 "quote_calc4.y"
1225 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1228 #line 53 "quote_calc4.y"
1229 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1232 #line 55 "quote_calc4.y"
1233 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1236 #line 57 "quote_calc4.y"
1237 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1240 #line 59 "quote_calc4.y"
1241 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1244 #line 61 "quote_calc4.y"
1245 { yyval = - yystack.l_mark[0]; }
1248 #line 63 "quote_calc4.y"
1249 { yyval = regs[yystack.l_mark[0]]; }
1252 #line 68 "quote_calc4.y"
1253 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1256 #line 70 "quote_calc4.y"
1257 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1259 #line 1260 "quote_calc4-s.tab.c"
1263 yystack.s_mark -= yym;
1264 yystate = *yystack.s_mark;
1265 yystack.l_mark -= yym;
1266 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1267 yystack.p_mark -= yym;
1270 if (yystate == 0 && yym == 0)
1275 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1276 #ifdef YYSTYPE_TOSTRING
1279 #endif /* YYBTYACC */
1280 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1282 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1286 *++yystack.s_mark = YYFINAL;
1287 *++yystack.l_mark = yyval;
1288 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1289 *++yystack.p_mark = yyloc;
1297 /* we're currently re-reading tokens */
1299 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1307 /* in trial mode; save scanner results for future parse attempts */
1308 if (yylvp == yylvlim)
1309 { /* Enlarge lexical value queue */
1310 size_t p = (size_t) (yylvp - yylvals);
1311 size_t s = (size_t) (yylvlim - yylvals);
1313 s += YYLVQUEUEGROWTH;
1314 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1316 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1318 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1319 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1322 yylvp = yylve = yylvals + p;
1323 yylvlim = yylvals + s;
1324 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1325 yylpp = yylpe = yylpsns + p;
1326 yylplim = yylpsns + s;
1328 yylexp = yylexemes + p;
1330 *yylexp = (YYINT) YYLEX;
1333 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1340 /* normal operation, no conflict encountered */
1341 #endif /* YYBTYACC */
1345 #endif /* YYBTYACC */
1346 if (yychar < 0) yychar = YYEOF;
1350 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1351 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1352 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1356 if (yychar == YYEOF) goto yyaccept;
1359 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1360 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1361 yystate = yytable[yyn];
1363 yystate = yydgoto[yym];
1367 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1368 #ifdef YYSTYPE_TOSTRING
1371 #endif /* YYBTYACC */
1372 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1374 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1377 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1378 *++yystack.s_mark = (YYINT) yystate;
1379 *++yystack.l_mark = yyval;
1380 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1381 *++yystack.p_mark = yyloc;
1386 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1388 if (yypath) YYABORT;
1391 YYParseState *save = yyps->save;
1392 yyps->save = save->save;
1393 save->save = yypath;
1398 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1399 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1403 yyFreeState(yyerrctx);
1406 yylvp = yylvals + yypath->lexeme;
1407 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1408 yylpp = yylpsns + yypath->lexeme;
1410 yylexp = yylexemes + yypath->lexeme;
1412 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1413 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1414 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1415 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1416 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1417 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1418 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1420 yystate = yypath->state;
1422 #endif /* YYBTYACC */
1425 YYERROR_CALL("yacc stack overflow");
1429 YYERROR_CALL("memory exhausted");
1431 #endif /* YYBTYACC */
1441 if (yyps->save) goto yyvalid;
1442 #endif /* YYBTYACC */
1446 #if defined(YYDESTRUCT_CALL)
1447 if (yychar != YYEOF && yychar != YYEMPTY)
1448 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1449 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1451 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1452 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1456 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1459 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1460 YYDESTRUCT_CALL("cleanup: discarding state",
1461 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1463 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1464 YYDESTRUCT_CALL("cleanup: discarding state",
1465 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1466 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1468 #endif /* defined(YYDESTRUCT_CALL) */
1473 yyFreeState(yyerrctx);
1478 YYParseState *save = yyps;
1485 YYParseState *save = yypath;
1486 yypath = save->save;
1490 #endif /* YYBTYACC */
1491 yyfreestack(&yystack);