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",
373 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
374 YYLTYPE yyloc; /* position returned by actions */
375 YYLTYPE yylloc; /* position from the lexer */
378 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
379 #ifndef YYLLOC_DEFAULT
380 #define YYLLOC_DEFAULT(loc, rhs, n) \
385 (loc).first_line = ((rhs)[-1]).last_line; \
386 (loc).first_column = ((rhs)[-1]).last_column; \
387 (loc).last_line = ((rhs)[-1]).last_line; \
388 (loc).last_column = ((rhs)[-1]).last_column; \
392 (loc).first_line = ((rhs)[ 0 ]).first_line; \
393 (loc).first_column = ((rhs)[ 0 ]).first_column; \
394 (loc).last_line = ((rhs)[n-1]).last_line; \
395 (loc).last_column = ((rhs)[n-1]).last_column; \
398 #endif /* YYLLOC_DEFAULT */
399 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
402 #ifndef YYLVQUEUEGROWTH
403 #define YYLVQUEUEGROWTH 32
405 #endif /* YYBTYACC */
407 /* define the initial stack-sizes */
410 #define YYMAXDEPTH YYSTACKSIZE
413 #define YYSTACKSIZE YYMAXDEPTH
415 #define YYSTACKSIZE 10000
416 #define YYMAXDEPTH 10000
420 #ifndef YYINITSTACKSIZE
421 #define YYINITSTACKSIZE 200
431 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
438 struct YYParseState_s
440 struct YYParseState_s *save; /* Previously saved parser state */
441 YYSTACKDATA yystack; /* saved parser stack */
442 int state; /* saved parser state */
443 int errflag; /* saved error recovery status */
444 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
445 YYINT ctry; /* saved index in yyctable[] for this conflict */
447 typedef struct YYParseState_s YYParseState;
448 #endif /* YYBTYACC */
449 /* variables for the parser stack */
450 static YYSTACKDATA yystack;
453 /* Current parser state */
454 static YYParseState *yyps = 0;
456 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
457 static YYParseState *yypath = 0;
459 /* Base of the lexical value queue */
460 static YYSTYPE *yylvals = 0;
462 /* Current position at lexical value queue */
463 static YYSTYPE *yylvp = 0;
465 /* End position of lexical value queue */
466 static YYSTYPE *yylve = 0;
468 /* The last allocated position at the lexical value queue */
469 static YYSTYPE *yylvlim = 0;
471 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
472 /* Base of the lexical position queue */
473 static YYLTYPE *yylpsns = 0;
475 /* Current position at lexical position queue */
476 static YYLTYPE *yylpp = 0;
478 /* End position of lexical position queue */
479 static YYLTYPE *yylpe = 0;
481 /* The last allocated position at the lexical position queue */
482 static YYLTYPE *yylplim = 0;
485 /* Current position at lexical token queue */
486 static YYINT *yylexp = 0;
488 static YYINT *yylexemes = 0;
489 #endif /* YYBTYACC */
490 #line 73 "quote_calc2.y"
491 /* start of programs */
496 while(!feof(stdin)) {
503 yyerror(const char *s)
505 fprintf(stderr, "%s\n", s);
510 /* lexical analysis routine */
511 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
512 /* return DIGIT for a digit, yylval = 0 through 9 */
513 /* all other characters are returned immediately */
517 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
519 /* c is now nonblank */
531 #line 532 "quote_calc2.tab.c"
533 /* For use in generated program */
534 #define yydepth (int)(yystack.s_mark - yystack.s_base)
536 #define yytrial (yyps->save)
537 #endif /* YYBTYACC */
540 #include <stdio.h> /* needed for printf */
543 #include <stdlib.h> /* needed for malloc, etc */
544 #include <string.h> /* needed for memset */
546 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
547 static int yygrowstack(YYSTACKDATA *data)
553 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
557 if ((newsize = data->stacksize) == 0)
558 newsize = YYINITSTACKSIZE;
559 else if (newsize >= YYMAXDEPTH)
561 else if ((newsize *= 2) > YYMAXDEPTH)
562 newsize = YYMAXDEPTH;
564 i = (int) (data->s_mark - data->s_base);
565 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
569 data->s_base = newss;
570 data->s_mark = newss + i;
572 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
576 data->l_base = newvs;
577 data->l_mark = newvs + i;
579 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
580 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
584 data->p_base = newps;
585 data->p_mark = newps + i;
588 data->stacksize = newsize;
589 data->s_last = data->s_base + newsize - 1;
593 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
598 #if YYPURE || defined(YY_NO_LEAKS)
599 static void yyfreestack(YYSTACKDATA *data)
603 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
606 memset(data, 0, sizeof(*data));
609 #define yyfreestack(data) /* nothing */
610 #endif /* YYPURE || defined(YY_NO_LEAKS) */
613 static YYParseState *
614 yyNewState(unsigned size)
616 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
617 if (p == NULL) return NULL;
619 p->yystack.stacksize = size;
622 p->yystack.s_base = NULL;
623 p->yystack.l_base = NULL;
624 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
625 p->yystack.p_base = NULL;
629 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
630 if (p->yystack.s_base == NULL) return NULL;
631 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
632 if (p->yystack.l_base == NULL) return NULL;
633 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
634 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
635 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
636 if (p->yystack.p_base == NULL) return NULL;
637 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
644 yyFreeState(YYParseState *p)
646 yyfreestack(&p->yystack);
649 #endif /* YYBTYACC */
651 #define YYABORT goto yyabort
652 #define YYREJECT goto yyabort
653 #define YYACCEPT goto yyaccept
654 #define YYERROR goto yyerrlab
656 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
657 #define YYVALID_NESTED do { if (yyps->save && \
658 yyps->save->save == 0) goto yyvalid; } while(0)
659 #endif /* YYBTYACC */
664 int yym, yyn, yystate, yyresult;
667 YYParseState *yyerrctx = NULL;
668 #endif /* YYBTYACC */
669 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
670 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
675 if ((yys = getenv("YYDEBUG")) != 0)
678 if (yyn >= '0' && yyn <= '9')
682 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
684 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
685 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
689 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
691 #endif /* YYBTYACC */
700 memset(&yystack, 0, sizeof(yystack));
703 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
704 yystack.s_mark = yystack.s_base;
705 yystack.l_mark = yystack.l_base;
706 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
707 yystack.p_mark = yystack.p_base;
713 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
720 /* we're currently re-reading tokens */
722 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
730 /* in trial mode; save scanner results for future parse attempts */
731 if (yylvp == yylvlim)
732 { /* Enlarge lexical value queue */
733 size_t p = (size_t) (yylvp - yylvals);
734 size_t s = (size_t) (yylvlim - yylvals);
736 s += YYLVQUEUEGROWTH;
737 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
738 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
739 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
740 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
742 yylvp = yylve = yylvals + p;
743 yylvlim = yylvals + s;
744 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
745 yylpp = yylpe = yylpsns + p;
746 yylplim = yylpsns + s;
748 yylexp = yylexemes + p;
750 *yylexp = (YYINT) YYLEX;
753 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
760 /* normal operation, no conflict encountered */
761 #endif /* YYBTYACC */
765 #endif /* YYBTYACC */
766 if (yychar < 0) yychar = YYEOF;
770 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
771 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
772 YYDEBUGSTR, yydepth, yystate, yychar, yys);
773 #ifdef YYSTYPE_TOSTRING
776 #endif /* YYBTYACC */
777 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
785 /* Do we have a conflict? */
786 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
787 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
796 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
797 YYDEBUGSTR, yydepth, yystate);
799 /* Switch to the next conflict context */
804 if (save->state != yystate) YYABORT;
811 /* Unresolved conflict - start/continue trial parse */
816 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
818 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
820 fputs("Starting trial parse.\n", stderr);
823 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
824 if (save == NULL) goto yyenomem;
825 save->save = yyps->save;
826 save->state = yystate;
827 save->errflag = yyerrflag;
828 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
829 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
830 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
831 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
832 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
833 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
834 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
837 if (yyctable[ctry] == -1)
840 if (yydebug && yychar >= YYEOF)
841 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
846 if (yyps->save == NULL)
848 /* If this is a first conflict in the stack, start saving lexemes */
851 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
852 if (yylexemes == NULL) goto yyenomem;
853 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
854 if (yylvals == NULL) goto yyenomem;
855 yylvlim = yylvals + YYLVQUEUEGROWTH;
856 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
857 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
858 if (yylpsns == NULL) goto yyenomem;
859 yylplim = yylpsns + YYLVQUEUEGROWTH;
864 yylvp = yylve = yylvals;
865 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
866 yylpp = yylpe = yylpsns;
872 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
875 *yylexp = (YYINT) yychar;
883 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
889 save->lexeme = (int) (yylvp - yylvals);
892 if (yytable[yyn] == ctry)
896 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
897 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
902 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
907 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
909 yystate = yyctable[ctry];
910 *++yystack.s_mark = (YYINT) yystate;
911 *++yystack.l_mark = yylval;
912 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
913 *++yystack.p_mark = yylloc;
916 if (yyerrflag > 0) --yyerrflag;
921 yyn = yyctable[ctry];
924 } /* End of code dealing with conflicts */
925 #endif /* YYBTYACC */
926 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
927 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
931 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
932 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
934 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
935 yystate = yytable[yyn];
936 *++yystack.s_mark = yytable[yyn];
937 *++yystack.l_mark = yylval;
938 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
939 *++yystack.p_mark = yylloc;
942 if (yyerrflag > 0) --yyerrflag;
945 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
946 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
951 if (yyerrflag != 0) goto yyinrecovery;
956 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
959 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
960 * before looking for error recovery */
961 yystack.s_mark -= yym;
962 yystate = *yystack.s_mark;
963 yystack.l_mark -= yym;
964 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
965 yystack.p_mark -= yym;
973 YYParseState *save = yyps->save;
976 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
977 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
978 (int)(yylvp - yylvals - yyps->save->lexeme));
980 /* Memorize most forward-looking error state in case it's really an error. */
981 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
983 /* Free old saved error context state */
984 if (yyerrctx) yyFreeState(yyerrctx);
985 /* Create and fill out new saved error context state */
986 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
987 if (yyerrctx == NULL) goto yyenomem;
988 yyerrctx->save = yyps->save;
989 yyerrctx->state = yystate;
990 yyerrctx->errflag = yyerrflag;
991 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
992 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
993 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
994 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
995 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
996 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
997 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
999 yyerrctx->lexeme = (int) (yylvp - yylvals);
1001 yylvp = yylvals + save->lexeme;
1002 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1003 yylpp = yylpsns + save->lexeme;
1005 yylexp = yylexemes + save->lexeme;
1007 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1008 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1009 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1010 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1011 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1012 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1013 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1015 ctry = ++save->ctry;
1016 yystate = save->state;
1017 /* We tried shift, try reduce now */
1018 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1019 yyps->save = save->save;
1023 /* Nothing left on the stack -- error */
1028 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1031 /* Restore state as it was in the most forward-advanced error */
1032 yylvp = yylvals + yyerrctx->lexeme;
1033 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1034 yylpp = yylpsns + yyerrctx->lexeme;
1036 yylexp = yylexemes + yyerrctx->lexeme;
1037 yychar = yylexp[-1];
1039 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1042 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1043 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1044 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1045 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1046 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1047 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1048 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1050 yystate = yyerrctx->state;
1051 yyFreeState(yyerrctx);
1056 if (yynewerrflag == 0) goto yyinrecovery;
1057 #endif /* YYBTYACC */
1059 YYERROR_CALL("syntax error");
1060 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1061 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1065 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1076 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1077 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1081 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1082 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1084 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1085 yystate = yytable[yyn];
1086 *++yystack.s_mark = yytable[yyn];
1087 *++yystack.l_mark = yylval;
1088 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1089 /* lookahead position is error end position */
1090 yyerror_loc_range[1] = yylloc;
1091 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1092 *++yystack.p_mark = yyloc;
1100 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1101 YYDEBUGSTR, yydepth, *yystack.s_mark);
1103 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1104 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1105 /* the current TOS position is the error start position */
1106 yyerror_loc_range[0] = *yystack.p_mark;
1108 #if defined(YYDESTRUCT_CALL)
1111 #endif /* YYBTYACC */
1112 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1113 YYDESTRUCT_CALL("error: discarding state",
1114 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1116 YYDESTRUCT_CALL("error: discarding state",
1117 yystos[*yystack.s_mark], yystack.l_mark);
1118 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1119 #endif /* defined(YYDESTRUCT_CALL) */
1122 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1130 if (yychar == YYEOF) goto yyabort;
1134 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1135 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1136 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1139 #if defined(YYDESTRUCT_CALL)
1142 #endif /* YYBTYACC */
1143 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1144 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1146 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1147 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1148 #endif /* defined(YYDESTRUCT_CALL) */
1158 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1159 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1160 #ifdef YYSTYPE_TOSTRING
1163 #endif /* YYBTYACC */
1168 for (i = yym; i > 0; i--)
1170 if (i != yym) fputs(", ", stderr);
1171 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1172 yystack.l_mark[1-i]), stderr);
1177 fputc('\n', stderr);
1181 yyval = yystack.l_mark[1-yym];
1183 memset(&yyval, 0, sizeof yyval);
1184 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1186 /* Perform position reduction */
1187 memset(&yyloc, 0, sizeof(yyloc));
1190 #endif /* YYBTYACC */
1192 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1193 /* just in case YYERROR is invoked within the action, save
1194 the start of the rhs as the error start position */
1195 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1202 #line 35 "quote_calc2.y"
1206 #line 39 "quote_calc2.y"
1207 { printf("%d\n",yystack.l_mark[0]);}
1210 #line 41 "quote_calc2.y"
1211 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1214 #line 45 "quote_calc2.y"
1215 { yyval = yystack.l_mark[-1]; }
1218 #line 47 "quote_calc2.y"
1219 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1222 #line 49 "quote_calc2.y"
1223 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1226 #line 51 "quote_calc2.y"
1227 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1230 #line 53 "quote_calc2.y"
1231 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1234 #line 55 "quote_calc2.y"
1235 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1238 #line 57 "quote_calc2.y"
1239 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1242 #line 59 "quote_calc2.y"
1243 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1246 #line 61 "quote_calc2.y"
1247 { yyval = - yystack.l_mark[0]; }
1250 #line 63 "quote_calc2.y"
1251 { yyval = regs[yystack.l_mark[0]]; }
1254 #line 68 "quote_calc2.y"
1255 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1258 #line 70 "quote_calc2.y"
1259 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1261 #line 1262 "quote_calc2.tab.c"
1265 yystack.s_mark -= yym;
1266 yystate = *yystack.s_mark;
1267 yystack.l_mark -= yym;
1268 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1269 yystack.p_mark -= yym;
1272 if (yystate == 0 && yym == 0)
1277 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1278 #ifdef YYSTYPE_TOSTRING
1281 #endif /* YYBTYACC */
1282 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1284 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1288 *++yystack.s_mark = YYFINAL;
1289 *++yystack.l_mark = yyval;
1290 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1291 *++yystack.p_mark = yyloc;
1299 /* we're currently re-reading tokens */
1301 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1309 /* in trial mode; save scanner results for future parse attempts */
1310 if (yylvp == yylvlim)
1311 { /* Enlarge lexical value queue */
1312 size_t p = (size_t) (yylvp - yylvals);
1313 size_t s = (size_t) (yylvlim - yylvals);
1315 s += YYLVQUEUEGROWTH;
1316 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1318 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1320 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1321 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1324 yylvp = yylve = yylvals + p;
1325 yylvlim = yylvals + s;
1326 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1327 yylpp = yylpe = yylpsns + p;
1328 yylplim = yylpsns + s;
1330 yylexp = yylexemes + p;
1332 *yylexp = (YYINT) YYLEX;
1335 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1342 /* normal operation, no conflict encountered */
1343 #endif /* YYBTYACC */
1347 #endif /* YYBTYACC */
1348 if (yychar < 0) yychar = YYEOF;
1352 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1353 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1354 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1358 if (yychar == YYEOF) goto yyaccept;
1361 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1362 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1363 yystate = yytable[yyn];
1365 yystate = yydgoto[yym];
1369 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1370 #ifdef YYSTYPE_TOSTRING
1373 #endif /* YYBTYACC */
1374 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1376 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1379 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1380 *++yystack.s_mark = (YYINT) yystate;
1381 *++yystack.l_mark = yyval;
1382 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1383 *++yystack.p_mark = yyloc;
1388 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1390 if (yypath) YYABORT;
1393 YYParseState *save = yyps->save;
1394 yyps->save = save->save;
1395 save->save = yypath;
1400 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1401 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1405 yyFreeState(yyerrctx);
1408 yylvp = yylvals + yypath->lexeme;
1409 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1410 yylpp = yylpsns + yypath->lexeme;
1412 yylexp = yylexemes + yypath->lexeme;
1414 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1415 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1416 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1417 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1418 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1419 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1420 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1422 yystate = yypath->state;
1424 #endif /* YYBTYACC */
1427 YYERROR_CALL("yacc stack overflow");
1431 YYERROR_CALL("memory exhausted");
1433 #endif /* YYBTYACC */
1443 if (yyps->save) goto yyvalid;
1444 #endif /* YYBTYACC */
1448 #if defined(YYDESTRUCT_CALL)
1449 if (yychar != YYEOF && yychar != YYEMPTY)
1450 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1451 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1453 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1454 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1458 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1461 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1462 YYDESTRUCT_CALL("cleanup: discarding state",
1463 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1465 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1466 YYDESTRUCT_CALL("cleanup: discarding state",
1467 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1468 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1470 #endif /* defined(YYDESTRUCT_CALL) */
1475 yyFreeState(yyerrctx);
1480 YYParseState *save = yyps;
1487 YYParseState *save = yypath;
1488 yypath = save->save;
1492 #endif /* YYBTYACC */
1493 yyfreestack(&yystack);