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 calc_parse
25 #define yylex calc_lex
29 #define yyerror calc_error
33 #define yychar calc_char
37 #define yyval calc_val
41 #define yylval calc_lval
45 #define yydebug calc_debug
49 #define yynerrs calc_nerrs
53 #define yyerrflag calc_errflag
54 #endif /* yyerrflag */
57 #define yylhs calc_lhs
61 #define yylen calc_len
65 #define yydefred calc_defred
69 #define yystos calc_stos
73 #define yydgoto calc_dgoto
77 #define yysindex calc_sindex
81 #define yyrindex calc_rindex
85 #define yygindex calc_gindex
89 #define yytable calc_table
93 #define yycheck calc_check
97 #define yyname calc_name
101 #define yyrule calc_rule
107 #define yycindex calc_cindex
108 #endif /* yycindex */
111 #define yyctable calc_ctable
112 #endif /* yyctable */
114 #endif /* YYBTYACC */
116 #define YYPREFIX "calc_"
127 extern int yylex(void);
128 static void yyerror(const char *s);
130 #line 131 "calc.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();
172 #define YYERRCODE 256
174 static const YYINT calc_lhs[] = { -1,
175 0, 0, 0, 1, 1, 2, 2, 2, 2, 2,
176 2, 2, 2, 2, 2, 2, 3, 3,
178 static const YYINT calc_len[] = { 2,
179 0, 3, 3, 1, 3, 3, 3, 3, 3, 3,
180 3, 3, 3, 2, 1, 1, 1, 2,
182 static const YYINT calc_defred[] = { 1,
183 0, 0, 17, 0, 0, 0, 0, 0, 0, 3,
184 0, 15, 14, 0, 2, 0, 0, 0, 0, 0,
185 0, 0, 18, 0, 6, 0, 0, 0, 0, 9,
188 static const YYINT calc_stos[] = { 0,
189 261, 256, 257, 258, 45, 40, 262, 263, 264, 10,
190 61, 258, 263, 263, 10, 124, 38, 43, 45, 42,
191 47, 37, 257, 263, 41, 263, 263, 263, 263, 263,
194 static const YYINT calc_dgoto[] = { 1,
197 static const YYINT calc_sindex[] = { 0,
198 -40, -7, 0, -55, -38, -38, 1, -29, -247, 0,
199 -38, 0, 0, 22, 0, -38, -38, -38, -38, -38,
200 -38, -38, 0, -29, 0, 51, 60, -20, -20, 0,
203 static const YYINT calc_rindex[] = { 0,
204 0, 0, 0, 2, 0, 0, 0, 9, -9, 0,
205 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
206 0, 0, 0, 10, 0, -6, 14, 5, 13, 0,
210 static const YYINT calc_cindex[] = { 0,
211 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
212 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
213 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
217 static const YYINT calc_gindex[] = { 0,
220 #define YYTABLESIZE 220
221 static const YYINT calc_table[] = { 6,
222 16, 6, 10, 13, 5, 11, 5, 22, 17, 23,
223 15, 15, 20, 18, 7, 19, 22, 21, 4, 5,
224 0, 20, 8, 12, 0, 0, 21, 16, 16, 0,
225 0, 16, 16, 16, 13, 16, 0, 16, 15, 15,
226 0, 0, 7, 15, 15, 7, 15, 7, 15, 7,
227 8, 12, 0, 8, 12, 8, 0, 8, 22, 17,
228 0, 0, 25, 20, 18, 0, 19, 0, 21, 13,
229 14, 0, 0, 0, 0, 24, 0, 0, 0, 0,
230 26, 27, 28, 29, 30, 31, 32, 22, 17, 0,
231 0, 0, 20, 18, 16, 19, 22, 21, 0, 0,
232 0, 20, 18, 0, 19, 0, 21, 0, 0, 0,
233 0, 0, 0, 0, 16, 0, 0, 13, 0, 0,
234 0, 0, 0, 0, 0, 15, 0, 0, 7, 0,
235 0, 0, 0, 0, 0, 0, 8, 12, 0, 0,
236 0, 0, 0, 0, 0, 16, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0,
241 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
242 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
243 0, 0, 0, 0, 0, 2, 3, 4, 3, 12,
245 static const YYINT calc_check[] = { 40,
246 10, 40, 10, 10, 45, 61, 45, 37, 38, 257,
247 10, 10, 42, 43, 10, 45, 37, 47, 10, 10,
248 -1, 42, 10, 10, -1, -1, 47, 37, 38, -1,
249 -1, 41, 42, 43, 41, 45, -1, 47, 37, 38,
250 -1, -1, 38, 42, 43, 41, 45, 43, 47, 45,
251 38, 38, -1, 41, 41, 43, -1, 45, 37, 38,
252 -1, -1, 41, 42, 43, -1, 45, -1, 47, 5,
253 6, -1, -1, -1, -1, 11, -1, -1, -1, -1,
254 16, 17, 18, 19, 20, 21, 22, 37, 38, -1,
255 -1, -1, 42, 43, 124, 45, 37, 47, -1, -1,
256 -1, 42, 43, -1, 45, -1, 47, -1, -1, -1,
257 -1, -1, -1, -1, 124, -1, -1, 124, -1, -1,
258 -1, -1, -1, -1, -1, 124, -1, -1, 124, -1,
259 -1, -1, -1, -1, -1, -1, 124, 124, -1, -1,
260 -1, -1, -1, -1, -1, 124, -1, -1, -1, -1,
261 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
262 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
263 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
264 -1, -1, -1, -1, -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, 256, 257, 258, 257, 258,
273 #define YYMAXTOKEN 259
274 #define YYUNDFTOKEN 265
275 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
277 static const char *const calc_name[] = {
279 "$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,
280 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
281 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
282 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0,
283 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
284 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
285 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
286 0,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number",
289 static const char *const calc_rule[] = {
292 "list : list stat '\\n'",
293 "list : list error '\\n'",
295 "stat : LETTER '=' expr",
296 "expr : '(' expr ')'",
297 "expr : expr '+' expr",
298 "expr : expr '-' expr",
299 "expr : expr '*' expr",
300 "expr : expr '/' expr",
301 "expr : expr '%' expr",
302 "expr : expr '&' expr",
303 "expr : expr '|' expr",
308 "number : number DIGIT",
320 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
321 YYLTYPE yyloc; /* position returned by actions */
322 YYLTYPE yylloc; /* position from the lexer */
325 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
326 #ifndef YYLLOC_DEFAULT
327 #define YYLLOC_DEFAULT(loc, rhs, n) \
332 (loc).first_line = ((rhs)[-1]).last_line; \
333 (loc).first_column = ((rhs)[-1]).last_column; \
334 (loc).last_line = ((rhs)[-1]).last_line; \
335 (loc).last_column = ((rhs)[-1]).last_column; \
339 (loc).first_line = ((rhs)[ 0 ]).first_line; \
340 (loc).first_column = ((rhs)[ 0 ]).first_column; \
341 (loc).last_line = ((rhs)[n-1]).last_line; \
342 (loc).last_column = ((rhs)[n-1]).last_column; \
345 #endif /* YYLLOC_DEFAULT */
346 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
349 #ifndef YYLVQUEUEGROWTH
350 #define YYLVQUEUEGROWTH 32
352 #endif /* YYBTYACC */
354 /* define the initial stack-sizes */
357 #define YYMAXDEPTH YYSTACKSIZE
360 #define YYSTACKSIZE YYMAXDEPTH
362 #define YYSTACKSIZE 10000
363 #define YYMAXDEPTH 10000
367 #ifndef YYINITSTACKSIZE
368 #define YYINITSTACKSIZE 200
378 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
385 struct YYParseState_s
387 struct YYParseState_s *save; /* Previously saved parser state */
388 YYSTACKDATA yystack; /* saved parser stack */
389 int state; /* saved parser state */
390 int errflag; /* saved error recovery status */
391 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
392 YYINT ctry; /* saved index in yyctable[] for this conflict */
394 typedef struct YYParseState_s YYParseState;
395 #endif /* YYBTYACC */
396 /* variables for the parser stack */
397 static YYSTACKDATA yystack;
400 /* Current parser state */
401 static YYParseState *yyps = 0;
403 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
404 static YYParseState *yypath = 0;
406 /* Base of the lexical value queue */
407 static YYSTYPE *yylvals = 0;
409 /* Current position at lexical value queue */
410 static YYSTYPE *yylvp = 0;
412 /* End position of lexical value queue */
413 static YYSTYPE *yylve = 0;
415 /* The last allocated position at the lexical value queue */
416 static YYSTYPE *yylvlim = 0;
418 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
419 /* Base of the lexical position queue */
420 static YYLTYPE *yylpsns = 0;
422 /* Current position at lexical position queue */
423 static YYLTYPE *yylpp = 0;
425 /* End position of lexical position queue */
426 static YYLTYPE *yylpe = 0;
428 /* The last allocated position at the lexical position queue */
429 static YYLTYPE *yylplim = 0;
432 /* Current position at lexical token queue */
433 static short *yylexp = 0;
435 static short *yylexemes = 0;
436 #endif /* YYBTYACC */
438 /* start of programs */
443 while(!feof(stdin)) {
450 yyerror(const char *s)
452 fprintf(stderr, "%s\n", s);
458 /* lexical analysis routine */
459 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
460 /* return DIGIT for a digit, yylval = 0 through 9 */
461 /* all other characters are returned immediately */
465 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
467 /* c is now nonblank */
479 #line 480 "calc.tab.c"
481 /* For use in generated program */
482 #define yydepth (int)(yystack.s_mark - yystack.s_base)
484 #define yytrial (yyps->save)
485 #endif /* YYBTYACC */
488 #include <stdio.h> /* needed for printf */
491 #include <stdlib.h> /* needed for malloc, etc */
492 #include <string.h> /* needed for memset */
494 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
495 static int yygrowstack(YYSTACKDATA *data)
501 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
505 if ((newsize = data->stacksize) == 0)
506 newsize = YYINITSTACKSIZE;
507 else if (newsize >= YYMAXDEPTH)
509 else if ((newsize *= 2) > YYMAXDEPTH)
510 newsize = YYMAXDEPTH;
512 i = (int) (data->s_mark - data->s_base);
513 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
517 data->s_base = newss;
518 data->s_mark = newss + i;
520 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
524 data->l_base = newvs;
525 data->l_mark = newvs + i;
527 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
528 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
532 data->p_base = newps;
533 data->p_mark = newps + i;
536 data->stacksize = newsize;
537 data->s_last = data->s_base + newsize - 1;
541 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
546 #if YYPURE || defined(YY_NO_LEAKS)
547 static void yyfreestack(YYSTACKDATA *data)
551 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
554 memset(data, 0, sizeof(*data));
557 #define yyfreestack(data) /* nothing */
558 #endif /* YYPURE || defined(YY_NO_LEAKS) */
561 static YYParseState *
562 yyNewState(unsigned size)
564 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
565 if (p == NULL) return NULL;
567 p->yystack.stacksize = size;
570 p->yystack.s_base = NULL;
571 p->yystack.l_base = NULL;
572 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
573 p->yystack.p_base = NULL;
577 p->yystack.s_base = (short *) malloc(size * sizeof(short));
578 if (p->yystack.s_base == NULL) return NULL;
579 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
580 if (p->yystack.l_base == NULL) return NULL;
581 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
582 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
583 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
584 if (p->yystack.p_base == NULL) return NULL;
585 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
592 yyFreeState(YYParseState *p)
594 yyfreestack(&p->yystack);
597 #endif /* YYBTYACC */
599 #define YYABORT goto yyabort
600 #define YYREJECT goto yyabort
601 #define YYACCEPT goto yyaccept
602 #define YYERROR goto yyerrlab
604 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
605 #define YYVALID_NESTED do { if (yyps->save && \
606 yyps->save->save == 0) goto yyvalid; } while(0)
607 #endif /* YYBTYACC */
612 int yym, yyn, yystate, yyresult;
615 YYParseState *yyerrctx = NULL;
616 #endif /* YYBTYACC */
617 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
618 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
623 if ((yys = getenv("YYDEBUG")) != 0)
626 if (yyn >= '0' && yyn <= '9')
630 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
634 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
636 #endif /* YYBTYACC */
643 memset(&yystack, 0, sizeof(yystack));
646 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
647 yystack.s_mark = yystack.s_base;
648 yystack.l_mark = yystack.l_base;
649 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
650 yystack.p_mark = yystack.p_base;
656 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
663 /* we're currently re-reading tokens */
665 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
673 /* in trial mode; save scanner results for future parse attempts */
674 if (yylvp == yylvlim)
675 { /* Enlarge lexical value queue */
676 int p = yylvp - yylvals;
677 int s = yylvlim - yylvals;
679 s += YYLVQUEUEGROWTH;
680 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
681 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
682 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
683 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
685 yylvp = yylve = yylvals + p;
686 yylvlim = yylvals + s;
687 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
688 yylpp = yylpe = yylpsns + p;
689 yylplim = yylpsns + s;
691 yylexp = yylexemes + p;
693 *yylexp = (short) YYLEX;
696 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
703 /* normal operation, no conflict encountered */
704 #endif /* YYBTYACC */
708 #endif /* YYBTYACC */
709 if (yychar < 0) yychar = YYEOF;
710 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
714 yys = yyname[YYTRANSLATE(yychar)];
715 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
716 YYDEBUGSTR, yydepth, yystate, yychar, yys);
717 #ifdef YYSTYPE_TOSTRING
720 #endif /* YYBTYACC */
721 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
729 /* Do we have a conflict? */
730 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
731 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
740 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
741 YYDEBUGSTR, yydepth, yystate);
743 /* Switch to the next conflict context */
748 if (save->state != yystate) YYABORT;
755 /* Unresolved conflict - start/continue trial parse */
760 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
762 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
764 fputs("Starting trial parse.\n", stderr);
767 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
768 if (save == NULL) goto yyenomem;
769 save->save = yyps->save;
770 save->state = yystate;
771 save->errflag = yyerrflag;
772 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
773 memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
774 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
775 memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
776 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
777 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
778 memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
781 if (yyctable[ctry] == -1)
784 if (yydebug && yychar >= YYEOF)
785 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
790 if (yyps->save == NULL)
792 /* If this is a first conflict in the stack, start saving lexemes */
795 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));
796 if (yylexemes == NULL) goto yyenomem;
797 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
798 if (yylvals == NULL) goto yyenomem;
799 yylvlim = yylvals + YYLVQUEUEGROWTH;
800 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
801 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
802 if (yylpsns == NULL) goto yyenomem;
803 yylplim = yylpsns + YYLVQUEUEGROWTH;
808 yylvp = yylve = yylvals;
809 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
810 yylpp = yylpe = yylpsns;
816 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
819 *yylexp = (short) yychar;
827 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
833 save->lexeme = yylvp - yylvals;
836 if (yytable[yyn] == ctry)
840 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
841 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
846 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
851 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
853 yystate = yyctable[ctry];
854 *++yystack.s_mark = (short) yystate;
855 *++yystack.l_mark = yylval;
856 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
857 *++yystack.p_mark = yylloc;
860 if (yyerrflag > 0) --yyerrflag;
865 yyn = yyctable[ctry];
868 } /* End of code dealing with conflicts */
869 #endif /* YYBTYACC */
870 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
871 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
875 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
876 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
878 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
879 yystate = yytable[yyn];
880 *++yystack.s_mark = yytable[yyn];
881 *++yystack.l_mark = yylval;
882 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
883 *++yystack.p_mark = yylloc;
886 if (yyerrflag > 0) --yyerrflag;
889 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
890 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
895 if (yyerrflag != 0) goto yyinrecovery;
908 YYParseState *save = yyps->save;
911 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
912 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
913 (int)(yylvp - yylvals - yyps->save->lexeme));
915 /* Memorize most forward-looking error state in case it's really an error. */
916 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
918 /* Free old saved error context state */
919 if (yyerrctx) yyFreeState(yyerrctx);
920 /* Create and fill out new saved error context state */
921 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
922 if (yyerrctx == NULL) goto yyenomem;
923 yyerrctx->save = yyps->save;
924 yyerrctx->state = yystate;
925 yyerrctx->errflag = yyerrflag;
926 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
927 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
928 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
929 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
930 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
931 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
932 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
934 yyerrctx->lexeme = yylvp - yylvals;
936 yylvp = yylvals + save->lexeme;
937 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
938 yylpp = yylpsns + save->lexeme;
940 yylexp = yylexemes + save->lexeme;
942 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
943 memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
944 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
945 memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
946 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
947 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
948 memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
951 yystate = save->state;
952 /* We tried shift, try reduce now */
953 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
954 yyps->save = save->save;
958 /* Nothing left on the stack -- error */
963 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
966 /* Restore state as it was in the most forward-advanced error */
967 yylvp = yylvals + yyerrctx->lexeme;
968 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
969 yylpp = yylpsns + yyerrctx->lexeme;
971 yylexp = yylexemes + yyerrctx->lexeme;
974 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
977 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
978 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
979 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
980 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
981 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
982 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
983 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
985 yystate = yyerrctx->state;
986 yyFreeState(yyerrctx);
991 if (yynewerrflag == 0) goto yyinrecovery;
992 #endif /* YYBTYACC */
994 YYERROR_CALL("syntax error");
995 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
996 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1011 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1012 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1016 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1017 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1019 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1020 yystate = yytable[yyn];
1021 *++yystack.s_mark = yytable[yyn];
1022 *++yystack.l_mark = yylval;
1023 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1024 /* lookahead position is error end position */
1025 yyerror_loc_range[1] = yylloc;
1026 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1027 *++yystack.p_mark = yyloc;
1035 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1036 YYDEBUGSTR, yydepth, *yystack.s_mark);
1038 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1039 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1040 /* the current TOS position is the error start position */
1041 yyerror_loc_range[0] = *yystack.p_mark;
1043 #if defined(YYDESTRUCT_CALL)
1046 #endif /* YYBTYACC */
1047 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1048 YYDESTRUCT_CALL("error: discarding state",
1049 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1051 YYDESTRUCT_CALL("error: discarding state",
1052 yystos[*yystack.s_mark], yystack.l_mark);
1053 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1054 #endif /* defined(YYDESTRUCT_CALL) */
1057 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1065 if (yychar == YYEOF) goto yyabort;
1069 yys = yyname[YYTRANSLATE(yychar)];
1070 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1071 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1074 #if defined(YYDESTRUCT_CALL)
1077 #endif /* YYBTYACC */
1078 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1079 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1081 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1082 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1083 #endif /* defined(YYDESTRUCT_CALL) */
1093 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1094 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1095 #ifdef YYSTYPE_TOSTRING
1098 #endif /* YYBTYACC */
1103 for (i = yym; i > 0; i--)
1105 if (i != yym) fputs(", ", stderr);
1106 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1107 yystack.l_mark[1-i]), stderr);
1112 fputc('\n', stderr);
1116 yyval = yystack.l_mark[1-yym];
1118 memset(&yyval, 0, sizeof yyval);
1119 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1121 /* Perform position reduction */
1122 memset(&yyloc, 0, sizeof(yyloc));
1125 #endif /* YYBTYACC */
1127 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1128 /* just in case YYERROR is invoked within the action, save
1129 the start of the rhs as the error start position */
1130 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1142 { printf("%d\n",yystack.l_mark[0]);}
1146 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1150 { yyval = yystack.l_mark[-1]; }
1154 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1158 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1162 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1166 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1170 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1174 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1178 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1182 { yyval = - yystack.l_mark[0]; }
1186 { yyval = regs[yystack.l_mark[0]]; }
1190 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1194 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1196 #line 1197 "calc.tab.c"
1200 yystack.s_mark -= yym;
1201 yystate = *yystack.s_mark;
1202 yystack.l_mark -= yym;
1203 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1204 yystack.p_mark -= yym;
1207 if (yystate == 0 && yym == 0)
1212 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1213 #ifdef YYSTYPE_TOSTRING
1216 #endif /* YYBTYACC */
1217 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1219 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1223 *++yystack.s_mark = YYFINAL;
1224 *++yystack.l_mark = yyval;
1225 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1226 *++yystack.p_mark = yyloc;
1234 /* we're currently re-reading tokens */
1236 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1244 /* in trial mode; save scanner results for future parse attempts */
1245 if (yylvp == yylvlim)
1246 { /* Enlarge lexical value queue */
1247 int p = yylvp - yylvals;
1248 int s = yylvlim - yylvals;
1250 s += YYLVQUEUEGROWTH;
1251 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
1253 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1255 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1256 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1259 yylvp = yylve = yylvals + p;
1260 yylvlim = yylvals + s;
1261 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1262 yylpp = yylpe = yylpsns + p;
1263 yylplim = yylpsns + s;
1265 yylexp = yylexemes + p;
1267 *yylexp = (short) YYLEX;
1270 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1277 /* normal operation, no conflict encountered */
1278 #endif /* YYBTYACC */
1282 #endif /* YYBTYACC */
1283 if (yychar < 0) yychar = YYEOF;
1284 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
1288 yys = yyname[YYTRANSLATE(yychar)];
1289 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n",
1290 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1294 if (yychar == YYEOF) goto yyaccept;
1297 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1298 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1299 yystate = yytable[yyn];
1301 yystate = yydgoto[yym];
1305 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1306 #ifdef YYSTYPE_TOSTRING
1309 #endif /* YYBTYACC */
1310 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1312 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1315 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1316 *++yystack.s_mark = (short) yystate;
1317 *++yystack.l_mark = yyval;
1318 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1319 *++yystack.p_mark = yyloc;
1324 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1326 if (yypath) YYABORT;
1329 YYParseState *save = yyps->save;
1330 yyps->save = save->save;
1331 save->save = yypath;
1336 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1337 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1341 yyFreeState(yyerrctx);
1344 yylvp = yylvals + yypath->lexeme;
1345 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1346 yylpp = yylpsns + yypath->lexeme;
1348 yylexp = yylexemes + yypath->lexeme;
1350 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1351 memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1352 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1353 memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1354 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1355 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1356 memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1358 yystate = yypath->state;
1360 #endif /* YYBTYACC */
1363 YYERROR_CALL("yacc stack overflow");
1367 YYERROR_CALL("memory exhausted");
1369 #endif /* YYBTYACC */
1379 if (yyps->save) goto yyvalid;
1380 #endif /* YYBTYACC */
1384 #if defined(YYDESTRUCT_CALL)
1385 if (yychar != YYEOF && yychar != YYEMPTY)
1386 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1387 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1389 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1390 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1394 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1397 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1398 YYDESTRUCT_CALL("cleanup: discarding state",
1399 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1401 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1402 YYDESTRUCT_CALL("cleanup: discarding state",
1403 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1404 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1406 #endif /* defined(YYDESTRUCT_CALL) */
1411 yyFreeState(yyerrctx);
1416 YYParseState *save = yyps;
1423 YYParseState *save = yypath;
1424 yypath = save->save;
1428 #endif /* YYBTYACC */
1429 yyfreestack(&yystack);