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_calc3_parse
25 #define yylex quote_calc3_lex
29 #define yyerror quote_calc3_error
33 #define yychar quote_calc3_char
37 #define yyval quote_calc3_val
41 #define yylval quote_calc3_lval
45 #define yydebug quote_calc3_debug
49 #define yynerrs quote_calc3_nerrs
53 #define yyerrflag quote_calc3_errflag
54 #endif /* yyerrflag */
57 #define yylhs quote_calc3_lhs
61 #define yylen quote_calc3_len
65 #define yydefred quote_calc3_defred
69 #define yystos quote_calc3_stos
73 #define yydgoto quote_calc3_dgoto
77 #define yysindex quote_calc3_sindex
81 #define yyrindex quote_calc3_rindex
85 #define yygindex quote_calc3_gindex
89 #define yytable quote_calc3_table
93 #define yycheck quote_calc3_check
97 #define yyname quote_calc3_name
101 #define yyrule quote_calc3_rule
107 #define yycindex quote_calc3_cindex
108 #endif /* yycindex */
111 #define yyctable quote_calc3_ctable
112 #endif /* yyctable */
114 #endif /* YYBTYACC */
116 #define YYPREFIX "quote_calc3_"
120 #line 2 "quote_calc3.y"
128 static void yyerror(const char *s);
130 #line 131 "quote_calc3.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_calc3_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_calc3_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_calc3_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_calc3_stos[] = { 0,
196 273, 256, 259, 269, 270, 40, 274, 275, 276, 10,
197 270, 275, 61, 275, 10, 257, 259, 261, 263, 265,
198 267, 124, 269, 275, 41, 275, 275, 275, 275, 275,
201 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
202 static const YYINT quote_calc3_dgoto[] = { 1,
205 static const YYINT quote_calc3_sindex[] = { 0,
206 -38, 5, -36, 0, -51, -36, 7, -121, -248, 0,
207 0, -243, -36, -22, 0, -36, -36, -36, -36, -36,
208 -36, -36, 0, -121, 0, -121, -121, -121, -121, -121,
211 static const YYINT quote_calc3_rindex[] = { 0,
212 0, 0, 0, 0, -9, 0, 0, 13, -10, 0,
213 0, -5, 0, 0, 0, 0, 0, 0, 0, 0,
214 0, 0, 0, 15, 0, -3, -2, -1, 1, 2,
218 static const YYINT quote_calc3_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_calc3_gindex[] = { 0,
228 #define YYTABLESIZE 258
229 static const YYINT quote_calc3_table[] = { 16,
230 15, 6, 22, 6, 14, 13, 7, 8, 9, 13,
231 10, 11, 12, 16, 10, 17, 15, 18, 25, 19,
232 23, 20, 4, 21, 5, 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 0, 22, 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, 16, 0, 17, 0, 18,
244 0, 19, 0, 20, 0, 21, 0, 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 3, 0, 3, 0, 0, 0, 0, 0, 0, 0,
253 4, 5, 4, 11, 16, 0, 17, 0, 18, 0,
254 19, 0, 20, 0, 21, 0, 16, 15, 16, 15,
255 16, 15, 16, 15, 16, 15, 16, 15,
257 static const YYINT quote_calc3_check[] = { 10,
258 10, 40, 124, 40, 10, 10, 10, 10, 10, 61,
259 10, 10, 10, 257, 10, 259, 10, 261, 41, 263,
260 269, 265, 10, 267, 10, -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 -1, 124, -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, 257, -1, 259, -1, 261,
272 -1, 263, -1, 265, -1, 267, -1, -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 259, -1, 259, -1, -1, -1, -1, -1, -1, -1,
281 269, 270, 269, 270, 257, -1, 259, -1, 261, -1,
282 263, -1, 265, -1, 267, -1, 257, 257, 259, 259,
283 261, 261, 263, 263, 265, 265, 267, 267,
286 static const YYINT quote_calc3_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,
319 #define YYMAXTOKEN 271
320 #define YYUNDFTOKEN 277
321 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
323 static const char *const quote_calc3_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_calc3_rule[] = {
340 "list : list stat '\\n'",
341 "list : list error '\\n'",
343 "stat : LETTER '=' expr",
344 "expr : '(' expr ')'",
345 "expr : expr OP_ADD expr",
346 "expr : expr OP_SUB expr",
347 "expr : expr OP_MUL expr",
348 "expr : expr OP_DIV expr",
349 "expr : expr OP_MOD expr",
350 "expr : expr OP_AND expr",
351 "expr : expr '|' expr",
352 "expr : OP_SUB expr",
356 "number : number DIGIT",
368 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
369 YYLTYPE yyloc; /* position returned by actions */
370 YYLTYPE yylloc; /* position from the lexer */
373 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
374 #ifndef YYLLOC_DEFAULT
375 #define YYLLOC_DEFAULT(loc, rhs, n) \
380 (loc).first_line = ((rhs)[-1]).last_line; \
381 (loc).first_column = ((rhs)[-1]).last_column; \
382 (loc).last_line = ((rhs)[-1]).last_line; \
383 (loc).last_column = ((rhs)[-1]).last_column; \
387 (loc).first_line = ((rhs)[ 0 ]).first_line; \
388 (loc).first_column = ((rhs)[ 0 ]).first_column; \
389 (loc).last_line = ((rhs)[n-1]).last_line; \
390 (loc).last_column = ((rhs)[n-1]).last_column; \
393 #endif /* YYLLOC_DEFAULT */
394 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
397 #ifndef YYLVQUEUEGROWTH
398 #define YYLVQUEUEGROWTH 32
400 #endif /* YYBTYACC */
402 /* define the initial stack-sizes */
405 #define YYMAXDEPTH YYSTACKSIZE
408 #define YYSTACKSIZE YYMAXDEPTH
410 #define YYSTACKSIZE 10000
411 #define YYMAXDEPTH 10000
415 #ifndef YYINITSTACKSIZE
416 #define YYINITSTACKSIZE 200
426 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
433 struct YYParseState_s
435 struct YYParseState_s *save; /* Previously saved parser state */
436 YYSTACKDATA yystack; /* saved parser stack */
437 int state; /* saved parser state */
438 int errflag; /* saved error recovery status */
439 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
440 YYINT ctry; /* saved index in yyctable[] for this conflict */
442 typedef struct YYParseState_s YYParseState;
443 #endif /* YYBTYACC */
444 /* variables for the parser stack */
445 static YYSTACKDATA yystack;
448 /* Current parser state */
449 static YYParseState *yyps = 0;
451 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
452 static YYParseState *yypath = 0;
454 /* Base of the lexical value queue */
455 static YYSTYPE *yylvals = 0;
457 /* Current position at lexical value queue */
458 static YYSTYPE *yylvp = 0;
460 /* End position of lexical value queue */
461 static YYSTYPE *yylve = 0;
463 /* The last allocated position at the lexical value queue */
464 static YYSTYPE *yylvlim = 0;
466 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
467 /* Base of the lexical position queue */
468 static YYLTYPE *yylpsns = 0;
470 /* Current position at lexical position queue */
471 static YYLTYPE *yylpp = 0;
473 /* End position of lexical position queue */
474 static YYLTYPE *yylpe = 0;
476 /* The last allocated position at the lexical position queue */
477 static YYLTYPE *yylplim = 0;
480 /* Current position at lexical token queue */
481 static YYINT *yylexp = 0;
483 static YYINT *yylexemes = 0;
484 #endif /* YYBTYACC */
485 #line 73 "quote_calc3.y"
486 /* start of programs */
491 while(!feof(stdin)) {
498 yyerror(const char *s)
500 fprintf(stderr, "%s\n", s);
505 /* lexical analysis routine */
506 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
507 /* return DIGIT for a digit, yylval = 0 through 9 */
508 /* all other characters are returned immediately */
512 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
514 /* c is now nonblank */
526 #line 527 "quote_calc3.tab.c"
528 /* For use in generated program */
529 #define yydepth (int)(yystack.s_mark - yystack.s_base)
531 #define yytrial (yyps->save)
532 #endif /* YYBTYACC */
535 #include <stdio.h> /* needed for printf */
538 #include <stdlib.h> /* needed for malloc, etc */
539 #include <string.h> /* needed for memset */
541 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
542 static int yygrowstack(YYSTACKDATA *data)
548 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
552 if ((newsize = data->stacksize) == 0)
553 newsize = YYINITSTACKSIZE;
554 else if (newsize >= YYMAXDEPTH)
556 else if ((newsize *= 2) > YYMAXDEPTH)
557 newsize = YYMAXDEPTH;
559 i = (int) (data->s_mark - data->s_base);
560 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
564 data->s_base = newss;
565 data->s_mark = newss + i;
567 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
571 data->l_base = newvs;
572 data->l_mark = newvs + i;
574 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
575 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
579 data->p_base = newps;
580 data->p_mark = newps + i;
583 data->stacksize = newsize;
584 data->s_last = data->s_base + newsize - 1;
588 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
593 #if YYPURE || defined(YY_NO_LEAKS)
594 static void yyfreestack(YYSTACKDATA *data)
598 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
601 memset(data, 0, sizeof(*data));
604 #define yyfreestack(data) /* nothing */
605 #endif /* YYPURE || defined(YY_NO_LEAKS) */
608 static YYParseState *
609 yyNewState(unsigned size)
611 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
612 if (p == NULL) return NULL;
614 p->yystack.stacksize = size;
617 p->yystack.s_base = NULL;
618 p->yystack.l_base = NULL;
619 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
620 p->yystack.p_base = NULL;
624 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
625 if (p->yystack.s_base == NULL) return NULL;
626 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
627 if (p->yystack.l_base == NULL) return NULL;
628 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
629 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
630 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
631 if (p->yystack.p_base == NULL) return NULL;
632 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
639 yyFreeState(YYParseState *p)
641 yyfreestack(&p->yystack);
644 #endif /* YYBTYACC */
646 #define YYABORT goto yyabort
647 #define YYREJECT goto yyabort
648 #define YYACCEPT goto yyaccept
649 #define YYERROR goto yyerrlab
651 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
652 #define YYVALID_NESTED do { if (yyps->save && \
653 yyps->save->save == 0) goto yyvalid; } while(0)
654 #endif /* YYBTYACC */
659 int yym, yyn, yystate, yyresult;
662 YYParseState *yyerrctx = NULL;
663 #endif /* YYBTYACC */
664 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
665 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
670 if ((yys = getenv("YYDEBUG")) != 0)
673 if (yyn >= '0' && yyn <= '9')
677 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
679 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
680 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
684 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
686 #endif /* YYBTYACC */
695 memset(&yystack, 0, sizeof(yystack));
698 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
699 yystack.s_mark = yystack.s_base;
700 yystack.l_mark = yystack.l_base;
701 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
702 yystack.p_mark = yystack.p_base;
708 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
715 /* we're currently re-reading tokens */
717 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
725 /* in trial mode; save scanner results for future parse attempts */
726 if (yylvp == yylvlim)
727 { /* Enlarge lexical value queue */
728 size_t p = (size_t) (yylvp - yylvals);
729 size_t s = (size_t) (yylvlim - yylvals);
731 s += YYLVQUEUEGROWTH;
732 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
733 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
734 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
735 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
737 yylvp = yylve = yylvals + p;
738 yylvlim = yylvals + s;
739 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
740 yylpp = yylpe = yylpsns + p;
741 yylplim = yylpsns + s;
743 yylexp = yylexemes + p;
745 *yylexp = (YYINT) YYLEX;
748 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
755 /* normal operation, no conflict encountered */
756 #endif /* YYBTYACC */
760 #endif /* YYBTYACC */
761 if (yychar < 0) yychar = YYEOF;
765 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
766 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
767 YYDEBUGSTR, yydepth, yystate, yychar, yys);
768 #ifdef YYSTYPE_TOSTRING
771 #endif /* YYBTYACC */
772 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
780 /* Do we have a conflict? */
781 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
782 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
791 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
792 YYDEBUGSTR, yydepth, yystate);
794 /* Switch to the next conflict context */
799 if (save->state != yystate) YYABORT;
806 /* Unresolved conflict - start/continue trial parse */
811 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
813 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
815 fputs("Starting trial parse.\n", stderr);
818 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
819 if (save == NULL) goto yyenomem;
820 save->save = yyps->save;
821 save->state = yystate;
822 save->errflag = yyerrflag;
823 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
824 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
825 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
826 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
827 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
828 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
829 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
832 if (yyctable[ctry] == -1)
835 if (yydebug && yychar >= YYEOF)
836 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
841 if (yyps->save == NULL)
843 /* If this is a first conflict in the stack, start saving lexemes */
846 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
847 if (yylexemes == NULL) goto yyenomem;
848 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
849 if (yylvals == NULL) goto yyenomem;
850 yylvlim = yylvals + YYLVQUEUEGROWTH;
851 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
852 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
853 if (yylpsns == NULL) goto yyenomem;
854 yylplim = yylpsns + YYLVQUEUEGROWTH;
859 yylvp = yylve = yylvals;
860 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
861 yylpp = yylpe = yylpsns;
867 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
870 *yylexp = (YYINT) yychar;
878 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
884 save->lexeme = (int) (yylvp - yylvals);
887 if (yytable[yyn] == ctry)
891 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
892 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
897 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
902 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
904 yystate = yyctable[ctry];
905 *++yystack.s_mark = (YYINT) yystate;
906 *++yystack.l_mark = yylval;
907 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
908 *++yystack.p_mark = yylloc;
911 if (yyerrflag > 0) --yyerrflag;
916 yyn = yyctable[ctry];
919 } /* End of code dealing with conflicts */
920 #endif /* YYBTYACC */
921 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
922 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
926 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
927 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
929 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
930 yystate = yytable[yyn];
931 *++yystack.s_mark = yytable[yyn];
932 *++yystack.l_mark = yylval;
933 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
934 *++yystack.p_mark = yylloc;
937 if (yyerrflag > 0) --yyerrflag;
940 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
941 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
946 if (yyerrflag != 0) goto yyinrecovery;
951 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
954 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
955 * before looking for error recovery */
956 yystack.s_mark -= yym;
957 yystate = *yystack.s_mark;
958 yystack.l_mark -= yym;
959 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
960 yystack.p_mark -= yym;
968 YYParseState *save = yyps->save;
971 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
972 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
973 (int)(yylvp - yylvals - yyps->save->lexeme));
975 /* Memorize most forward-looking error state in case it's really an error. */
976 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
978 /* Free old saved error context state */
979 if (yyerrctx) yyFreeState(yyerrctx);
980 /* Create and fill out new saved error context state */
981 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
982 if (yyerrctx == NULL) goto yyenomem;
983 yyerrctx->save = yyps->save;
984 yyerrctx->state = yystate;
985 yyerrctx->errflag = yyerrflag;
986 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
987 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
988 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
989 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
990 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
991 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
992 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
994 yyerrctx->lexeme = (int) (yylvp - yylvals);
996 yylvp = yylvals + save->lexeme;
997 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
998 yylpp = yylpsns + save->lexeme;
1000 yylexp = yylexemes + save->lexeme;
1002 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1003 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1004 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1005 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1006 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1007 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1008 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1010 ctry = ++save->ctry;
1011 yystate = save->state;
1012 /* We tried shift, try reduce now */
1013 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1014 yyps->save = save->save;
1018 /* Nothing left on the stack -- error */
1023 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1026 /* Restore state as it was in the most forward-advanced error */
1027 yylvp = yylvals + yyerrctx->lexeme;
1028 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1029 yylpp = yylpsns + yyerrctx->lexeme;
1031 yylexp = yylexemes + yyerrctx->lexeme;
1032 yychar = yylexp[-1];
1034 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1037 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1038 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1039 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1040 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1041 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1042 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1043 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1045 yystate = yyerrctx->state;
1046 yyFreeState(yyerrctx);
1051 if (yynewerrflag == 0) goto yyinrecovery;
1052 #endif /* YYBTYACC */
1054 YYERROR_CALL("syntax error");
1055 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1056 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1060 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1071 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1072 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1076 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1077 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1079 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1080 yystate = yytable[yyn];
1081 *++yystack.s_mark = yytable[yyn];
1082 *++yystack.l_mark = yylval;
1083 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1084 /* lookahead position is error end position */
1085 yyerror_loc_range[1] = yylloc;
1086 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1087 *++yystack.p_mark = yyloc;
1095 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1096 YYDEBUGSTR, yydepth, *yystack.s_mark);
1098 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1099 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1100 /* the current TOS position is the error start position */
1101 yyerror_loc_range[0] = *yystack.p_mark;
1103 #if defined(YYDESTRUCT_CALL)
1106 #endif /* YYBTYACC */
1107 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1108 YYDESTRUCT_CALL("error: discarding state",
1109 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1111 YYDESTRUCT_CALL("error: discarding state",
1112 yystos[*yystack.s_mark], yystack.l_mark);
1113 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1114 #endif /* defined(YYDESTRUCT_CALL) */
1117 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1125 if (yychar == YYEOF) goto yyabort;
1129 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1130 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1131 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1134 #if defined(YYDESTRUCT_CALL)
1137 #endif /* YYBTYACC */
1138 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1139 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1141 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1142 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1143 #endif /* defined(YYDESTRUCT_CALL) */
1153 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1154 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1155 #ifdef YYSTYPE_TOSTRING
1158 #endif /* YYBTYACC */
1163 for (i = yym; i > 0; i--)
1165 if (i != yym) fputs(", ", stderr);
1166 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1167 yystack.l_mark[1-i]), stderr);
1172 fputc('\n', stderr);
1176 yyval = yystack.l_mark[1-yym];
1178 memset(&yyval, 0, sizeof yyval);
1179 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1181 /* Perform position reduction */
1182 memset(&yyloc, 0, sizeof(yyloc));
1185 #endif /* YYBTYACC */
1187 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1188 /* just in case YYERROR is invoked within the action, save
1189 the start of the rhs as the error start position */
1190 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1197 #line 35 "quote_calc3.y"
1201 #line 39 "quote_calc3.y"
1202 { printf("%d\n",yystack.l_mark[0]);}
1205 #line 41 "quote_calc3.y"
1206 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1209 #line 45 "quote_calc3.y"
1210 { yyval = yystack.l_mark[-1]; }
1213 #line 47 "quote_calc3.y"
1214 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1217 #line 49 "quote_calc3.y"
1218 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1221 #line 51 "quote_calc3.y"
1222 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1225 #line 53 "quote_calc3.y"
1226 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1229 #line 55 "quote_calc3.y"
1230 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1233 #line 57 "quote_calc3.y"
1234 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1237 #line 59 "quote_calc3.y"
1238 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1241 #line 61 "quote_calc3.y"
1242 { yyval = - yystack.l_mark[0]; }
1245 #line 63 "quote_calc3.y"
1246 { yyval = regs[yystack.l_mark[0]]; }
1249 #line 68 "quote_calc3.y"
1250 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1253 #line 70 "quote_calc3.y"
1254 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1256 #line 1257 "quote_calc3.tab.c"
1260 yystack.s_mark -= yym;
1261 yystate = *yystack.s_mark;
1262 yystack.l_mark -= yym;
1263 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1264 yystack.p_mark -= yym;
1267 if (yystate == 0 && yym == 0)
1272 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1273 #ifdef YYSTYPE_TOSTRING
1276 #endif /* YYBTYACC */
1277 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1279 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1283 *++yystack.s_mark = YYFINAL;
1284 *++yystack.l_mark = yyval;
1285 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1286 *++yystack.p_mark = yyloc;
1294 /* we're currently re-reading tokens */
1296 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1304 /* in trial mode; save scanner results for future parse attempts */
1305 if (yylvp == yylvlim)
1306 { /* Enlarge lexical value queue */
1307 size_t p = (size_t) (yylvp - yylvals);
1308 size_t s = (size_t) (yylvlim - yylvals);
1310 s += YYLVQUEUEGROWTH;
1311 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1313 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1315 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1316 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1319 yylvp = yylve = yylvals + p;
1320 yylvlim = yylvals + s;
1321 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1322 yylpp = yylpe = yylpsns + p;
1323 yylplim = yylpsns + s;
1325 yylexp = yylexemes + p;
1327 *yylexp = (YYINT) YYLEX;
1330 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1337 /* normal operation, no conflict encountered */
1338 #endif /* YYBTYACC */
1342 #endif /* YYBTYACC */
1343 if (yychar < 0) yychar = YYEOF;
1347 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1348 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1349 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1353 if (yychar == YYEOF) goto yyaccept;
1356 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1357 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1358 yystate = yytable[yyn];
1360 yystate = yydgoto[yym];
1364 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1365 #ifdef YYSTYPE_TOSTRING
1368 #endif /* YYBTYACC */
1369 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1371 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1374 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1375 *++yystack.s_mark = (YYINT) yystate;
1376 *++yystack.l_mark = yyval;
1377 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1378 *++yystack.p_mark = yyloc;
1383 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1385 if (yypath) YYABORT;
1388 YYParseState *save = yyps->save;
1389 yyps->save = save->save;
1390 save->save = yypath;
1395 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1396 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1400 yyFreeState(yyerrctx);
1403 yylvp = yylvals + yypath->lexeme;
1404 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1405 yylpp = yylpsns + yypath->lexeme;
1407 yylexp = yylexemes + yypath->lexeme;
1409 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1410 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1411 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1412 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1413 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1414 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1415 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1417 yystate = yypath->state;
1419 #endif /* YYBTYACC */
1422 YYERROR_CALL("yacc stack overflow");
1426 YYERROR_CALL("memory exhausted");
1428 #endif /* YYBTYACC */
1438 if (yyps->save) goto yyvalid;
1439 #endif /* YYBTYACC */
1443 #if defined(YYDESTRUCT_CALL)
1444 if (yychar != YYEOF && yychar != YYEMPTY)
1445 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1446 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1448 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1449 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1453 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1456 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1457 YYDESTRUCT_CALL("cleanup: discarding state",
1458 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1460 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1461 YYDESTRUCT_CALL("cleanup: discarding state",
1462 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1463 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1465 #endif /* defined(YYDESTRUCT_CALL) */
1470 yyFreeState(yyerrctx);
1475 YYParseState *save = yyps;
1482 YYParseState *save = yypath;
1483 yypath = save->save;
1487 #endif /* YYBTYACC */
1488 yyfreestack(&yystack);