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 calc2_parse
25 #define yylex calc2_lex
29 #define yyerror calc2_error
33 #define yychar calc2_char
37 #define yyval calc2_val
41 #define yylval calc2_lval
45 #define yydebug calc2_debug
49 #define yynerrs calc2_nerrs
53 #define yyerrflag calc2_errflag
54 #endif /* yyerrflag */
57 #define yylhs calc2_lhs
61 #define yylen calc2_len
65 #define yydefred calc2_defred
69 #define yystos calc2_stos
73 #define yydgoto calc2_dgoto
77 #define yysindex calc2_sindex
81 #define yyrindex calc2_rindex
85 #define yygindex calc2_gindex
89 #define yytable calc2_table
93 #define yycheck calc2_check
97 #define yyname calc2_name
101 #define yyrule calc2_rule
107 #define yycindex calc2_cindex
108 #endif /* yycindex */
111 #define yyctable calc2_ctable
112 #endif /* yyctable */
114 #endif /* YYBTYACC */
116 #define YYPREFIX "calc2_"
125 #define YYLEX_PARAM base
126 #define YYLEX_DECL() yylex(int *YYLEX_PARAM)
127 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
129 static void YYERROR_DECL();
132 #line 133 "calc2.tab.c"
134 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
135 /* Default: YYSTYPE is the semantic value type. */
137 # define YYSTYPE_IS_DECLARED 1
140 /* compatibility with bison */
142 /* compatibility with FreeBSD */
143 # ifdef YYPARSE_PARAM_TYPE
144 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
146 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
149 # define YYPARSE_DECL() yyparse(int regs[26], int * base)
152 /* Parameters sent to lex. */
154 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
155 # define YYLEX yylex(YYLEX_PARAM)
157 # define YYLEX_DECL() yylex(int * base)
158 # define YYLEX yylex(base)
161 /* Parameters sent to yyerror. */
163 #define YYERROR_DECL() yyerror(int regs[26], int * base, const char *s)
166 #define YYERROR_CALL(msg) yyerror(regs, base, msg)
169 extern int YYPARSE_DECL();
174 #define YYERRCODE 256
176 static const YYINT calc2_lhs[] = { -1,
177 0, 0, 0, 1, 1, 2, 2, 2, 2, 2,
178 2, 2, 2, 2, 2, 2, 3, 3,
180 static const YYINT calc2_len[] = { 2,
181 0, 3, 3, 1, 3, 3, 3, 3, 3, 3,
182 3, 3, 3, 2, 1, 1, 1, 2,
184 static const YYINT calc2_defred[] = { 1,
185 0, 0, 17, 0, 0, 0, 0, 0, 0, 3,
186 0, 15, 14, 0, 2, 0, 0, 0, 0, 0,
187 0, 0, 18, 0, 6, 0, 0, 0, 0, 9,
190 static const YYINT calc2_stos[] = { 0,
191 261, 256, 257, 258, 45, 40, 262, 263, 264, 10,
192 61, 258, 263, 263, 10, 124, 38, 43, 45, 42,
193 47, 37, 257, 263, 41, 263, 263, 263, 263, 263,
196 static const YYINT calc2_dgoto[] = { 1,
199 static const YYINT calc2_sindex[] = { 0,
200 -40, -7, 0, -55, -38, -38, 1, -29, -247, 0,
201 -38, 0, 0, 22, 0, -38, -38, -38, -38, -38,
202 -38, -38, 0, -29, 0, 51, 60, -20, -20, 0,
205 static const YYINT calc2_rindex[] = { 0,
206 0, 0, 0, 2, 0, 0, 0, 9, -9, 0,
207 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
208 0, 0, 0, 10, 0, -6, 14, 5, 13, 0,
212 static const YYINT calc2_cindex[] = { 0,
213 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
214 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
215 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
219 static const YYINT calc2_gindex[] = { 0,
222 #define YYTABLESIZE 220
223 static const YYINT calc2_table[] = { 6,
224 16, 6, 10, 13, 5, 11, 5, 22, 17, 23,
225 15, 15, 20, 18, 7, 19, 22, 21, 4, 5,
226 0, 20, 8, 12, 0, 0, 21, 16, 16, 0,
227 0, 16, 16, 16, 13, 16, 0, 16, 15, 15,
228 0, 0, 7, 15, 15, 7, 15, 7, 15, 7,
229 8, 12, 0, 8, 12, 8, 0, 8, 22, 17,
230 0, 0, 25, 20, 18, 0, 19, 0, 21, 13,
231 14, 0, 0, 0, 0, 24, 0, 0, 0, 0,
232 26, 27, 28, 29, 30, 31, 32, 22, 17, 0,
233 0, 0, 20, 18, 16, 19, 22, 21, 0, 0,
234 0, 20, 18, 0, 19, 0, 21, 0, 0, 0,
235 0, 0, 0, 0, 16, 0, 0, 13, 0, 0,
236 0, 0, 0, 0, 0, 15, 0, 0, 7, 0,
237 0, 0, 0, 0, 0, 0, 8, 12, 0, 0,
238 0, 0, 0, 0, 0, 16, 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, 0, 0, 0, 0, 0,
244 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
245 0, 0, 0, 0, 0, 2, 3, 4, 3, 12,
247 static const YYINT calc2_check[] = { 40,
248 10, 40, 10, 10, 45, 61, 45, 37, 38, 257,
249 10, 10, 42, 43, 10, 45, 37, 47, 10, 10,
250 -1, 42, 10, 10, -1, -1, 47, 37, 38, -1,
251 -1, 41, 42, 43, 41, 45, -1, 47, 37, 38,
252 -1, -1, 38, 42, 43, 41, 45, 43, 47, 45,
253 38, 38, -1, 41, 41, 43, -1, 45, 37, 38,
254 -1, -1, 41, 42, 43, -1, 45, -1, 47, 5,
255 6, -1, -1, -1, -1, 11, -1, -1, -1, -1,
256 16, 17, 18, 19, 20, 21, 22, 37, 38, -1,
257 -1, -1, 42, 43, 124, 45, 37, 47, -1, -1,
258 -1, 42, 43, -1, 45, -1, 47, -1, -1, -1,
259 -1, -1, -1, -1, 124, -1, -1, 124, -1, -1,
260 -1, -1, -1, -1, -1, 124, -1, -1, 124, -1,
261 -1, -1, -1, -1, -1, -1, 124, 124, -1, -1,
262 -1, -1, -1, -1, -1, 124, -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, -1, -1, -1, -1, -1,
268 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
269 -1, -1, -1, -1, -1, 256, 257, 258, 257, 258,
275 #define YYMAXTOKEN 259
276 #define YYUNDFTOKEN 265
277 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
279 static const char *const calc2_name[] = {
281 "$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,
282 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,
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,
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,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
287 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
288 0,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number",
291 static const char *const calc2_rule[] = {
294 "list : list stat '\\n'",
295 "list : list error '\\n'",
297 "stat : LETTER '=' expr",
298 "expr : '(' expr ')'",
299 "expr : expr '+' expr",
300 "expr : expr '-' expr",
301 "expr : expr '*' expr",
302 "expr : expr '/' expr",
303 "expr : expr '%' expr",
304 "expr : expr '&' expr",
305 "expr : expr '|' expr",
310 "number : number DIGIT",
322 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
323 YYLTYPE yyloc; /* position returned by actions */
324 YYLTYPE yylloc; /* position from the lexer */
327 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
328 #ifndef YYLLOC_DEFAULT
329 #define YYLLOC_DEFAULT(loc, rhs, n) \
334 (loc).first_line = ((rhs)[-1]).last_line; \
335 (loc).first_column = ((rhs)[-1]).last_column; \
336 (loc).last_line = ((rhs)[-1]).last_line; \
337 (loc).last_column = ((rhs)[-1]).last_column; \
341 (loc).first_line = ((rhs)[ 0 ]).first_line; \
342 (loc).first_column = ((rhs)[ 0 ]).first_column; \
343 (loc).last_line = ((rhs)[n-1]).last_line; \
344 (loc).last_column = ((rhs)[n-1]).last_column; \
347 #endif /* YYLLOC_DEFAULT */
348 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
351 #ifndef YYLVQUEUEGROWTH
352 #define YYLVQUEUEGROWTH 32
354 #endif /* YYBTYACC */
356 /* define the initial stack-sizes */
359 #define YYMAXDEPTH YYSTACKSIZE
362 #define YYSTACKSIZE YYMAXDEPTH
364 #define YYSTACKSIZE 10000
365 #define YYMAXDEPTH 10000
369 #ifndef YYINITSTACKSIZE
370 #define YYINITSTACKSIZE 200
380 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
387 struct YYParseState_s
389 struct YYParseState_s *save; /* Previously saved parser state */
390 YYSTACKDATA yystack; /* saved parser stack */
391 int state; /* saved parser state */
392 int errflag; /* saved error recovery status */
393 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
394 YYINT ctry; /* saved index in yyctable[] for this conflict */
396 typedef struct YYParseState_s YYParseState;
397 #endif /* YYBTYACC */
398 /* variables for the parser stack */
399 static YYSTACKDATA yystack;
402 /* Current parser state */
403 static YYParseState *yyps = 0;
405 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
406 static YYParseState *yypath = 0;
408 /* Base of the lexical value queue */
409 static YYSTYPE *yylvals = 0;
411 /* Current position at lexical value queue */
412 static YYSTYPE *yylvp = 0;
414 /* End position of lexical value queue */
415 static YYSTYPE *yylve = 0;
417 /* The last allocated position at the lexical value queue */
418 static YYSTYPE *yylvlim = 0;
420 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
421 /* Base of the lexical position queue */
422 static YYLTYPE *yylpsns = 0;
424 /* Current position at lexical position queue */
425 static YYLTYPE *yylpp = 0;
427 /* End position of lexical position queue */
428 static YYLTYPE *yylpe = 0;
430 /* The last allocated position at the lexical position queue */
431 static YYLTYPE *yylplim = 0;
434 /* Current position at lexical token queue */
435 static short *yylexp = 0;
437 static short *yylexemes = 0;
438 #endif /* YYBTYACC */
440 /* start of programs */
443 extern int YYLEX_DECL();
452 while(!feof(stdin)) {
453 yyparse(regs, &base);
458 #define UNUSED(x) ((void)(x))
463 UNUSED(regs); /* %parse-param regs is not actually used here */
464 UNUSED(base); /* %parse-param base is not actually used here */
465 fprintf(stderr, "%s\n", s);
471 /* lexical analysis routine */
472 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
473 /* return DIGIT for a digit, yylval = 0 through 9 */
474 /* all other characters are returned immediately */
478 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
480 /* c is now nonblank */
487 yylval = (c - '0') % (*base);
492 #line 493 "calc2.tab.c"
494 /* For use in generated program */
495 #define yydepth (int)(yystack.s_mark - yystack.s_base)
497 #define yytrial (yyps->save)
498 #endif /* YYBTYACC */
501 #include <stdio.h> /* needed for printf */
504 #include <stdlib.h> /* needed for malloc, etc */
505 #include <string.h> /* needed for memset */
507 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
508 static int yygrowstack(YYSTACKDATA *data)
514 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
518 if ((newsize = data->stacksize) == 0)
519 newsize = YYINITSTACKSIZE;
520 else if (newsize >= YYMAXDEPTH)
522 else if ((newsize *= 2) > YYMAXDEPTH)
523 newsize = YYMAXDEPTH;
525 i = (int) (data->s_mark - data->s_base);
526 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
530 data->s_base = newss;
531 data->s_mark = newss + i;
533 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
537 data->l_base = newvs;
538 data->l_mark = newvs + i;
540 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
541 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
545 data->p_base = newps;
546 data->p_mark = newps + i;
549 data->stacksize = newsize;
550 data->s_last = data->s_base + newsize - 1;
554 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
559 #if YYPURE || defined(YY_NO_LEAKS)
560 static void yyfreestack(YYSTACKDATA *data)
564 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
567 memset(data, 0, sizeof(*data));
570 #define yyfreestack(data) /* nothing */
571 #endif /* YYPURE || defined(YY_NO_LEAKS) */
574 static YYParseState *
575 yyNewState(unsigned size)
577 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
578 if (p == NULL) return NULL;
580 p->yystack.stacksize = size;
583 p->yystack.s_base = NULL;
584 p->yystack.l_base = NULL;
585 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
586 p->yystack.p_base = NULL;
590 p->yystack.s_base = (short *) malloc(size * sizeof(short));
591 if (p->yystack.s_base == NULL) return NULL;
592 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
593 if (p->yystack.l_base == NULL) return NULL;
594 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
595 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
596 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
597 if (p->yystack.p_base == NULL) return NULL;
598 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
605 yyFreeState(YYParseState *p)
607 yyfreestack(&p->yystack);
610 #endif /* YYBTYACC */
612 #define YYABORT goto yyabort
613 #define YYREJECT goto yyabort
614 #define YYACCEPT goto yyaccept
615 #define YYERROR goto yyerrlab
617 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
618 #define YYVALID_NESTED do { if (yyps->save && \
619 yyps->save->save == 0) goto yyvalid; } while(0)
620 #endif /* YYBTYACC */
625 int yym, yyn, yystate, yyresult;
628 YYParseState *yyerrctx = NULL;
629 #endif /* YYBTYACC */
630 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
631 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
636 if ((yys = getenv("YYDEBUG")) != 0)
639 if (yyn >= '0' && yyn <= '9')
643 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
647 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
649 #endif /* YYBTYACC */
656 memset(&yystack, 0, sizeof(yystack));
659 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
660 yystack.s_mark = yystack.s_base;
661 yystack.l_mark = yystack.l_base;
662 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
663 yystack.p_mark = yystack.p_base;
669 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
676 /* we're currently re-reading tokens */
678 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
686 /* in trial mode; save scanner results for future parse attempts */
687 if (yylvp == yylvlim)
688 { /* Enlarge lexical value queue */
689 int p = yylvp - yylvals;
690 int s = yylvlim - yylvals;
692 s += YYLVQUEUEGROWTH;
693 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
694 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
695 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
696 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
698 yylvp = yylve = yylvals + p;
699 yylvlim = yylvals + s;
700 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
701 yylpp = yylpe = yylpsns + p;
702 yylplim = yylpsns + s;
704 yylexp = yylexemes + p;
706 *yylexp = (short) YYLEX;
709 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
716 /* normal operation, no conflict encountered */
717 #endif /* YYBTYACC */
721 #endif /* YYBTYACC */
722 if (yychar < 0) yychar = YYEOF;
723 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
727 yys = yyname[YYTRANSLATE(yychar)];
728 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
729 YYDEBUGSTR, yydepth, yystate, yychar, yys);
730 #ifdef YYSTYPE_TOSTRING
733 #endif /* YYBTYACC */
734 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
742 /* Do we have a conflict? */
743 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
744 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
753 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
754 YYDEBUGSTR, yydepth, yystate);
756 /* Switch to the next conflict context */
761 if (save->state != yystate) YYABORT;
768 /* Unresolved conflict - start/continue trial parse */
773 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
775 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
777 fputs("Starting trial parse.\n", stderr);
780 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
781 if (save == NULL) goto yyenomem;
782 save->save = yyps->save;
783 save->state = yystate;
784 save->errflag = yyerrflag;
785 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
786 memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
787 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
788 memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
789 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
790 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
791 memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
794 if (yyctable[ctry] == -1)
797 if (yydebug && yychar >= YYEOF)
798 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
803 if (yyps->save == NULL)
805 /* If this is a first conflict in the stack, start saving lexemes */
808 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));
809 if (yylexemes == NULL) goto yyenomem;
810 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
811 if (yylvals == NULL) goto yyenomem;
812 yylvlim = yylvals + YYLVQUEUEGROWTH;
813 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
814 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
815 if (yylpsns == NULL) goto yyenomem;
816 yylplim = yylpsns + YYLVQUEUEGROWTH;
821 yylvp = yylve = yylvals;
822 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
823 yylpp = yylpe = yylpsns;
829 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
832 *yylexp = (short) yychar;
840 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
846 save->lexeme = yylvp - yylvals;
849 if (yytable[yyn] == ctry)
853 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
854 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
859 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
864 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
866 yystate = yyctable[ctry];
867 *++yystack.s_mark = (short) yystate;
868 *++yystack.l_mark = yylval;
869 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
870 *++yystack.p_mark = yylloc;
873 if (yyerrflag > 0) --yyerrflag;
878 yyn = yyctable[ctry];
881 } /* End of code dealing with conflicts */
882 #endif /* YYBTYACC */
883 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
884 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
888 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
889 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
891 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
892 yystate = yytable[yyn];
893 *++yystack.s_mark = yytable[yyn];
894 *++yystack.l_mark = yylval;
895 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
896 *++yystack.p_mark = yylloc;
899 if (yyerrflag > 0) --yyerrflag;
902 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
903 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
908 if (yyerrflag != 0) goto yyinrecovery;
921 YYParseState *save = yyps->save;
924 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
925 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
926 (int)(yylvp - yylvals - yyps->save->lexeme));
928 /* Memorize most forward-looking error state in case it's really an error. */
929 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
931 /* Free old saved error context state */
932 if (yyerrctx) yyFreeState(yyerrctx);
933 /* Create and fill out new saved error context state */
934 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
935 if (yyerrctx == NULL) goto yyenomem;
936 yyerrctx->save = yyps->save;
937 yyerrctx->state = yystate;
938 yyerrctx->errflag = yyerrflag;
939 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
940 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
941 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
942 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
943 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
944 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
945 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
947 yyerrctx->lexeme = yylvp - yylvals;
949 yylvp = yylvals + save->lexeme;
950 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
951 yylpp = yylpsns + save->lexeme;
953 yylexp = yylexemes + save->lexeme;
955 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
956 memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
957 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
958 memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
959 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
960 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
961 memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
964 yystate = save->state;
965 /* We tried shift, try reduce now */
966 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
967 yyps->save = save->save;
971 /* Nothing left on the stack -- error */
976 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
979 /* Restore state as it was in the most forward-advanced error */
980 yylvp = yylvals + yyerrctx->lexeme;
981 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
982 yylpp = yylpsns + yyerrctx->lexeme;
984 yylexp = yylexemes + yyerrctx->lexeme;
987 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
990 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
991 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
992 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
993 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
994 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
995 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
996 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
998 yystate = yyerrctx->state;
999 yyFreeState(yyerrctx);
1004 if (yynewerrflag == 0) goto yyinrecovery;
1005 #endif /* YYBTYACC */
1007 YYERROR_CALL("syntax error");
1008 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1009 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1024 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1025 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1029 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1030 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1032 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1033 yystate = yytable[yyn];
1034 *++yystack.s_mark = yytable[yyn];
1035 *++yystack.l_mark = yylval;
1036 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1037 /* lookahead position is error end position */
1038 yyerror_loc_range[1] = yylloc;
1039 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1040 *++yystack.p_mark = yyloc;
1048 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1049 YYDEBUGSTR, yydepth, *yystack.s_mark);
1051 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1052 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1053 /* the current TOS position is the error start position */
1054 yyerror_loc_range[0] = *yystack.p_mark;
1056 #if defined(YYDESTRUCT_CALL)
1059 #endif /* YYBTYACC */
1060 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1061 YYDESTRUCT_CALL("error: discarding state",
1062 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1064 YYDESTRUCT_CALL("error: discarding state",
1065 yystos[*yystack.s_mark], yystack.l_mark);
1066 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1067 #endif /* defined(YYDESTRUCT_CALL) */
1070 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1078 if (yychar == YYEOF) goto yyabort;
1082 yys = yyname[YYTRANSLATE(yychar)];
1083 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1084 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1087 #if defined(YYDESTRUCT_CALL)
1090 #endif /* YYBTYACC */
1091 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1092 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1094 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1095 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1096 #endif /* defined(YYDESTRUCT_CALL) */
1106 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1107 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1108 #ifdef YYSTYPE_TOSTRING
1111 #endif /* YYBTYACC */
1116 for (i = yym; i > 0; i--)
1118 if (i != yym) fputs(", ", stderr);
1119 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1120 yystack.l_mark[1-i]), stderr);
1125 fputc('\n', stderr);
1129 yyval = yystack.l_mark[1-yym];
1131 memset(&yyval, 0, sizeof yyval);
1132 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1134 /* Perform position reduction */
1135 memset(&yyloc, 0, sizeof(yyloc));
1138 #endif /* YYBTYACC */
1140 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1141 /* just in case YYERROR is invoked within the action, save
1142 the start of the rhs as the error start position */
1143 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1155 { printf("%d\n",yystack.l_mark[0]);}
1159 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1163 { yyval = yystack.l_mark[-1]; }
1167 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1171 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1175 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1179 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1183 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1187 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1191 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1195 { yyval = - yystack.l_mark[0]; }
1199 { yyval = regs[yystack.l_mark[0]]; }
1203 { yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; }
1207 { yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
1209 #line 1210 "calc2.tab.c"
1213 yystack.s_mark -= yym;
1214 yystate = *yystack.s_mark;
1215 yystack.l_mark -= yym;
1216 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1217 yystack.p_mark -= yym;
1220 if (yystate == 0 && yym == 0)
1225 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1226 #ifdef YYSTYPE_TOSTRING
1229 #endif /* YYBTYACC */
1230 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1232 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1236 *++yystack.s_mark = YYFINAL;
1237 *++yystack.l_mark = yyval;
1238 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1239 *++yystack.p_mark = yyloc;
1247 /* we're currently re-reading tokens */
1249 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1257 /* in trial mode; save scanner results for future parse attempts */
1258 if (yylvp == yylvlim)
1259 { /* Enlarge lexical value queue */
1260 int p = yylvp - yylvals;
1261 int s = yylvlim - yylvals;
1263 s += YYLVQUEUEGROWTH;
1264 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
1266 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1268 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1269 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1272 yylvp = yylve = yylvals + p;
1273 yylvlim = yylvals + s;
1274 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1275 yylpp = yylpe = yylpsns + p;
1276 yylplim = yylpsns + s;
1278 yylexp = yylexemes + p;
1280 *yylexp = (short) YYLEX;
1283 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1290 /* normal operation, no conflict encountered */
1291 #endif /* YYBTYACC */
1295 #endif /* YYBTYACC */
1296 if (yychar < 0) yychar = YYEOF;
1297 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
1301 yys = yyname[YYTRANSLATE(yychar)];
1302 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n",
1303 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1307 if (yychar == YYEOF) goto yyaccept;
1310 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1311 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1312 yystate = yytable[yyn];
1314 yystate = yydgoto[yym];
1318 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1319 #ifdef YYSTYPE_TOSTRING
1322 #endif /* YYBTYACC */
1323 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1325 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1328 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1329 *++yystack.s_mark = (short) yystate;
1330 *++yystack.l_mark = yyval;
1331 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1332 *++yystack.p_mark = yyloc;
1337 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1339 if (yypath) YYABORT;
1342 YYParseState *save = yyps->save;
1343 yyps->save = save->save;
1344 save->save = yypath;
1349 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1350 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1354 yyFreeState(yyerrctx);
1357 yylvp = yylvals + yypath->lexeme;
1358 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1359 yylpp = yylpsns + yypath->lexeme;
1361 yylexp = yylexemes + yypath->lexeme;
1363 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1364 memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1365 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1366 memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1367 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1368 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1369 memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1371 yystate = yypath->state;
1373 #endif /* YYBTYACC */
1376 YYERROR_CALL("yacc stack overflow");
1380 YYERROR_CALL("memory exhausted");
1382 #endif /* YYBTYACC */
1392 if (yyps->save) goto yyvalid;
1393 #endif /* YYBTYACC */
1397 #if defined(YYDESTRUCT_CALL)
1398 if (yychar != YYEOF && yychar != YYEMPTY)
1399 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1400 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1402 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1403 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1407 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1410 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1411 YYDESTRUCT_CALL("cleanup: discarding state",
1412 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1414 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1415 YYDESTRUCT_CALL("cleanup: discarding state",
1416 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1417 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1419 #endif /* defined(YYDESTRUCT_CALL) */
1424 yyFreeState(yyerrctx);
1429 YYParseState *save = yyps;
1436 YYParseState *save = yypath;
1437 yypath = save->save;
1441 #endif /* YYBTYACC */
1442 yyfreestack(&yystack);