1 /* original parser id follows */
2 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
3 /* (use YYMAJOR/YYMINOR for ifdefs dependent of 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,
272 static const YYINT calc2_ctable[] = { -1,
273 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
274 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
275 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
276 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
277 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
278 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
279 -1, -1, -1, -1, -1, -1, -1, -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, -1, -1, -1,
286 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
287 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
288 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
289 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
290 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
291 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
292 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
293 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
294 -1, -1, -1, -1, -1, -1, -1, -1, -1,
301 #define YYMAXTOKEN 259
302 #define YYUNDFTOKEN 265
303 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
305 static const char *const calc2_name[] = {
307 "$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,
308 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
309 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
310 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0,
311 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
312 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
313 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
314 0,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number",
317 static const char *const calc2_rule[] = {
320 "list : list stat '\\n'",
321 "list : list error '\\n'",
323 "stat : LETTER '=' expr",
324 "expr : '(' expr ')'",
325 "expr : expr '+' expr",
326 "expr : expr '-' expr",
327 "expr : expr '*' expr",
328 "expr : expr '/' expr",
329 "expr : expr '%' expr",
330 "expr : expr '&' expr",
331 "expr : expr '|' expr",
336 "number : number DIGIT",
348 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
349 YYLTYPE yyloc; /* position returned by actions */
350 YYLTYPE yylloc; /* position from the lexer */
353 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
354 #ifndef YYLLOC_DEFAULT
355 #define YYLLOC_DEFAULT(loc, rhs, n) \
360 (loc).first_line = ((rhs)[-1]).last_line; \
361 (loc).first_column = ((rhs)[-1]).last_column; \
362 (loc).last_line = ((rhs)[-1]).last_line; \
363 (loc).last_column = ((rhs)[-1]).last_column; \
367 (loc).first_line = ((rhs)[ 0 ]).first_line; \
368 (loc).first_column = ((rhs)[ 0 ]).first_column; \
369 (loc).last_line = ((rhs)[n-1]).last_line; \
370 (loc).last_column = ((rhs)[n-1]).last_column; \
373 #endif /* YYLLOC_DEFAULT */
374 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
377 #ifndef YYLVQUEUEGROWTH
378 #define YYLVQUEUEGROWTH 32
380 #endif /* YYBTYACC */
382 /* define the initial stack-sizes */
385 #define YYMAXDEPTH YYSTACKSIZE
388 #define YYSTACKSIZE YYMAXDEPTH
390 #define YYSTACKSIZE 10000
391 #define YYMAXDEPTH 10000
395 #ifndef YYINITSTACKSIZE
396 #define YYINITSTACKSIZE 200
406 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
413 struct YYParseState_s
415 struct YYParseState_s *save; /* Previously saved parser state */
416 YYSTACKDATA yystack; /* saved parser stack */
417 int state; /* saved parser state */
418 int errflag; /* saved error recovery status */
419 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
420 YYINT ctry; /* saved index in yyctable[] for this conflict */
422 typedef struct YYParseState_s YYParseState;
423 #endif /* YYBTYACC */
424 /* variables for the parser stack */
425 static YYSTACKDATA yystack;
428 /* Current parser state */
429 static YYParseState *yyps = 0;
431 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
432 static YYParseState *yypath = 0;
434 /* Base of the lexical value queue */
435 static YYSTYPE *yylvals = 0;
437 /* Current position at lexical value queue */
438 static YYSTYPE *yylvp = 0;
440 /* End position of lexical value queue */
441 static YYSTYPE *yylve = 0;
443 /* The last allocated position at the lexical value queue */
444 static YYSTYPE *yylvlim = 0;
446 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
447 /* Base of the lexical position queue */
448 static YYLTYPE *yylpsns = 0;
450 /* Current position at lexical position queue */
451 static YYLTYPE *yylpp = 0;
453 /* End position of lexical position queue */
454 static YYLTYPE *yylpe = 0;
456 /* The last allocated position at the lexical position queue */
457 static YYLTYPE *yylplim = 0;
460 /* Current position at lexical token queue */
461 static short *yylexp = 0;
463 static short *yylexemes = 0;
464 #endif /* YYBTYACC */
466 /* start of programs */
469 extern int YYLEX_DECL();
478 while(!feof(stdin)) {
479 yyparse(regs, &base);
484 #define UNUSED(x) ((void)(x))
489 UNUSED(regs); /* %parse-param regs is not actually used here */
490 UNUSED(base); /* %parse-param base is not actually used here */
491 fprintf(stderr, "%s\n", s);
497 /* lexical analysis routine */
498 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
499 /* return DIGIT for a digit, yylval = 0 through 9 */
500 /* all other characters are returned immediately */
504 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
506 /* c is now nonblank */
513 yylval = (c - '0') % (*base);
518 #line 519 "calc2.tab.c"
520 /* For use in generated program */
521 #define yydepth (int)(yystack.s_mark - yystack.s_base)
523 #define yytrial (yyps->save)
524 #endif /* YYBTYACC */
527 #include <stdio.h> /* needed for printf */
530 #include <stdlib.h> /* needed for malloc, etc */
531 #include <string.h> /* needed for memset */
533 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
534 static int yygrowstack(YYSTACKDATA *data)
540 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
544 if ((newsize = data->stacksize) == 0)
545 newsize = YYINITSTACKSIZE;
546 else if (newsize >= YYMAXDEPTH)
548 else if ((newsize *= 2) > YYMAXDEPTH)
549 newsize = YYMAXDEPTH;
551 i = (int) (data->s_mark - data->s_base);
552 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
556 data->s_base = newss;
557 data->s_mark = newss + i;
559 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
563 data->l_base = newvs;
564 data->l_mark = newvs + i;
566 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
567 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
571 data->p_base = newps;
572 data->p_mark = newps + i;
575 data->stacksize = newsize;
576 data->s_last = data->s_base + newsize - 1;
580 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
585 #if YYPURE || defined(YY_NO_LEAKS)
586 static void yyfreestack(YYSTACKDATA *data)
590 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
593 memset(data, 0, sizeof(*data));
596 #define yyfreestack(data) /* nothing */
597 #endif /* YYPURE || defined(YY_NO_LEAKS) */
600 static YYParseState *
601 yyNewState(unsigned size)
603 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
604 if (p == NULL) return NULL;
606 p->yystack.stacksize = size;
609 p->yystack.s_base = NULL;
610 p->yystack.l_base = NULL;
611 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
612 p->yystack.p_base = NULL;
616 p->yystack.s_base = (short *) malloc(size * sizeof(short));
617 if (p->yystack.s_base == NULL) return NULL;
618 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
619 if (p->yystack.l_base == NULL) return NULL;
620 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
621 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
622 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
623 if (p->yystack.p_base == NULL) return NULL;
624 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
631 yyFreeState(YYParseState *p)
633 yyfreestack(&p->yystack);
636 #endif /* YYBTYACC */
638 #define YYABORT goto yyabort
639 #define YYREJECT goto yyabort
640 #define YYACCEPT goto yyaccept
641 #define YYERROR goto yyerrlab
643 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
644 #define YYVALID_NESTED do { if (yyps->save && \
645 yyps->save->save == 0) goto yyvalid; } while(0)
646 #endif /* YYBTYACC */
651 int yym, yyn, yystate, yyresult;
654 YYParseState *yyerrctx = NULL;
655 #endif /* YYBTYACC */
656 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
657 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
662 if ((yys = getenv("YYDEBUG")) != 0)
665 if (yyn >= '0' && yyn <= '9')
669 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
673 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
675 #endif /* YYBTYACC */
682 memset(&yystack, 0, sizeof(yystack));
685 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
686 yystack.s_mark = yystack.s_base;
687 yystack.l_mark = yystack.l_base;
688 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
689 yystack.p_mark = yystack.p_base;
695 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
702 /* we're currently re-reading tokens */
704 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
712 /* in trial mode; save scanner results for future parse attempts */
713 if (yylvp == yylvlim)
714 { /* Enlarge lexical value queue */
715 size_t p = (size_t) (yylvp - yylvals);
716 size_t s = (size_t) (yylvlim - yylvals);
718 s += YYLVQUEUEGROWTH;
719 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
720 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
721 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
722 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
724 yylvp = yylve = yylvals + p;
725 yylvlim = yylvals + s;
726 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
727 yylpp = yylpe = yylpsns + p;
728 yylplim = yylpsns + s;
730 yylexp = yylexemes + p;
732 *yylexp = (short) YYLEX;
735 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
742 /* normal operation, no conflict encountered */
743 #endif /* YYBTYACC */
747 #endif /* YYBTYACC */
748 if (yychar < 0) yychar = YYEOF;
749 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
753 yys = yyname[YYTRANSLATE(yychar)];
754 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
755 YYDEBUGSTR, yydepth, yystate, yychar, yys);
756 #ifdef YYSTYPE_TOSTRING
759 #endif /* YYBTYACC */
760 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
768 /* Do we have a conflict? */
769 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
770 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
779 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
780 YYDEBUGSTR, yydepth, yystate);
782 /* Switch to the next conflict context */
787 if (save->state != yystate) YYABORT;
794 /* Unresolved conflict - start/continue trial parse */
799 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
801 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
803 fputs("Starting trial parse.\n", stderr);
806 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
807 if (save == NULL) goto yyenomem;
808 save->save = yyps->save;
809 save->state = yystate;
810 save->errflag = yyerrflag;
811 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
812 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
813 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
814 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
815 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
816 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
817 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
820 if (yyctable[ctry] == -1)
823 if (yydebug && yychar >= YYEOF)
824 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
829 if (yyps->save == NULL)
831 /* If this is a first conflict in the stack, start saving lexemes */
834 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));
835 if (yylexemes == NULL) goto yyenomem;
836 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
837 if (yylvals == NULL) goto yyenomem;
838 yylvlim = yylvals + YYLVQUEUEGROWTH;
839 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
840 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
841 if (yylpsns == NULL) goto yyenomem;
842 yylplim = yylpsns + YYLVQUEUEGROWTH;
847 yylvp = yylve = yylvals;
848 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
849 yylpp = yylpe = yylpsns;
855 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
858 *yylexp = (short) yychar;
866 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
872 save->lexeme = (int) (yylvp - yylvals);
875 if (yytable[yyn] == ctry)
879 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
880 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
885 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
890 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
892 yystate = yyctable[ctry];
893 *++yystack.s_mark = (short) yystate;
894 *++yystack.l_mark = yylval;
895 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
896 *++yystack.p_mark = yylloc;
899 if (yyerrflag > 0) --yyerrflag;
904 yyn = yyctable[ctry];
907 } /* End of code dealing with conflicts */
908 #endif /* YYBTYACC */
909 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
910 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
914 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
915 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
917 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
918 yystate = yytable[yyn];
919 *++yystack.s_mark = yytable[yyn];
920 *++yystack.l_mark = yylval;
921 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
922 *++yystack.p_mark = yylloc;
925 if (yyerrflag > 0) --yyerrflag;
928 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
929 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
934 if (yyerrflag != 0) goto yyinrecovery;
947 YYParseState *save = yyps->save;
950 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
951 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
952 (int)(yylvp - yylvals - yyps->save->lexeme));
954 /* Memorize most forward-looking error state in case it's really an error. */
955 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
957 /* Free old saved error context state */
958 if (yyerrctx) yyFreeState(yyerrctx);
959 /* Create and fill out new saved error context state */
960 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
961 if (yyerrctx == NULL) goto yyenomem;
962 yyerrctx->save = yyps->save;
963 yyerrctx->state = yystate;
964 yyerrctx->errflag = yyerrflag;
965 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
966 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
967 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
968 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
969 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
970 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
971 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
973 yyerrctx->lexeme = (int) (yylvp - yylvals);
975 yylvp = yylvals + save->lexeme;
976 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
977 yylpp = yylpsns + save->lexeme;
979 yylexp = yylexemes + save->lexeme;
981 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
982 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
983 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
984 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
985 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
986 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
987 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
990 yystate = save->state;
991 /* We tried shift, try reduce now */
992 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
993 yyps->save = save->save;
997 /* Nothing left on the stack -- error */
1002 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1005 /* Restore state as it was in the most forward-advanced error */
1006 yylvp = yylvals + yyerrctx->lexeme;
1007 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1008 yylpp = yylpsns + yyerrctx->lexeme;
1010 yylexp = yylexemes + yyerrctx->lexeme;
1011 yychar = yylexp[-1];
1013 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1016 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1017 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1018 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1019 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1020 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1021 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1022 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1024 yystate = yyerrctx->state;
1025 yyFreeState(yyerrctx);
1030 if (yynewerrflag == 0) goto yyinrecovery;
1031 #endif /* YYBTYACC */
1033 YYERROR_CALL("syntax error");
1034 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1035 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1050 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1051 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1055 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1056 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1058 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1059 yystate = yytable[yyn];
1060 *++yystack.s_mark = yytable[yyn];
1061 *++yystack.l_mark = yylval;
1062 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1063 /* lookahead position is error end position */
1064 yyerror_loc_range[1] = yylloc;
1065 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1066 *++yystack.p_mark = yyloc;
1074 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1075 YYDEBUGSTR, yydepth, *yystack.s_mark);
1077 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1078 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1079 /* the current TOS position is the error start position */
1080 yyerror_loc_range[0] = *yystack.p_mark;
1082 #if defined(YYDESTRUCT_CALL)
1085 #endif /* YYBTYACC */
1086 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1087 YYDESTRUCT_CALL("error: discarding state",
1088 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1090 YYDESTRUCT_CALL("error: discarding state",
1091 yystos[*yystack.s_mark], yystack.l_mark);
1092 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1093 #endif /* defined(YYDESTRUCT_CALL) */
1096 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1104 if (yychar == YYEOF) goto yyabort;
1108 yys = yyname[YYTRANSLATE(yychar)];
1109 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1110 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1113 #if defined(YYDESTRUCT_CALL)
1116 #endif /* YYBTYACC */
1117 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1118 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1120 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1121 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1122 #endif /* defined(YYDESTRUCT_CALL) */
1132 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1133 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1134 #ifdef YYSTYPE_TOSTRING
1137 #endif /* YYBTYACC */
1142 for (i = yym; i > 0; i--)
1144 if (i != yym) fputs(", ", stderr);
1145 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1146 yystack.l_mark[1-i]), stderr);
1151 fputc('\n', stderr);
1155 yyval = yystack.l_mark[1-yym];
1157 memset(&yyval, 0, sizeof yyval);
1158 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1160 /* Perform position reduction */
1161 memset(&yyloc, 0, sizeof(yyloc));
1164 #endif /* YYBTYACC */
1166 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1167 /* just in case YYERROR is invoked within the action, save
1168 the start of the rhs as the error start position */
1169 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1181 { printf("%d\n",yystack.l_mark[0]);}
1185 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1189 { yyval = yystack.l_mark[-1]; }
1193 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1197 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1201 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1205 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1209 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1213 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1217 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1221 { yyval = - yystack.l_mark[0]; }
1225 { yyval = regs[yystack.l_mark[0]]; }
1229 { yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; }
1233 { yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
1235 #line 1236 "calc2.tab.c"
1239 yystack.s_mark -= yym;
1240 yystate = *yystack.s_mark;
1241 yystack.l_mark -= yym;
1242 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1243 yystack.p_mark -= yym;
1246 if (yystate == 0 && yym == 0)
1251 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1252 #ifdef YYSTYPE_TOSTRING
1255 #endif /* YYBTYACC */
1256 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1258 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1262 *++yystack.s_mark = YYFINAL;
1263 *++yystack.l_mark = yyval;
1264 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1265 *++yystack.p_mark = yyloc;
1273 /* we're currently re-reading tokens */
1275 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1283 /* in trial mode; save scanner results for future parse attempts */
1284 if (yylvp == yylvlim)
1285 { /* Enlarge lexical value queue */
1286 size_t p = (size_t) (yylvp - yylvals);
1287 size_t s = (size_t) (yylvlim - yylvals);
1289 s += YYLVQUEUEGROWTH;
1290 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
1292 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1294 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1295 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1298 yylvp = yylve = yylvals + p;
1299 yylvlim = yylvals + s;
1300 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1301 yylpp = yylpe = yylpsns + p;
1302 yylplim = yylpsns + s;
1304 yylexp = yylexemes + p;
1306 *yylexp = (short) YYLEX;
1309 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1316 /* normal operation, no conflict encountered */
1317 #endif /* YYBTYACC */
1321 #endif /* YYBTYACC */
1322 if (yychar < 0) yychar = YYEOF;
1323 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
1327 yys = yyname[YYTRANSLATE(yychar)];
1328 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n",
1329 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1333 if (yychar == YYEOF) goto yyaccept;
1336 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1337 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1338 yystate = yytable[yyn];
1340 yystate = yydgoto[yym];
1344 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1345 #ifdef YYSTYPE_TOSTRING
1348 #endif /* YYBTYACC */
1349 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1351 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1354 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1355 *++yystack.s_mark = (short) yystate;
1356 *++yystack.l_mark = yyval;
1357 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1358 *++yystack.p_mark = yyloc;
1363 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1365 if (yypath) YYABORT;
1368 YYParseState *save = yyps->save;
1369 yyps->save = save->save;
1370 save->save = yypath;
1375 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1376 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1380 yyFreeState(yyerrctx);
1383 yylvp = yylvals + yypath->lexeme;
1384 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1385 yylpp = yylpsns + yypath->lexeme;
1387 yylexp = yylexemes + yypath->lexeme;
1389 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1390 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1391 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1392 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1393 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1394 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1395 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1397 yystate = yypath->state;
1399 #endif /* YYBTYACC */
1402 YYERROR_CALL("yacc stack overflow");
1406 YYERROR_CALL("memory exhausted");
1408 #endif /* YYBTYACC */
1418 if (yyps->save) goto yyvalid;
1419 #endif /* YYBTYACC */
1423 #if defined(YYDESTRUCT_CALL)
1424 if (yychar != YYEOF && yychar != YYEMPTY)
1425 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1426 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1428 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1429 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1433 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1436 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1437 YYDESTRUCT_CALL("cleanup: discarding state",
1438 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1440 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1441 YYDESTRUCT_CALL("cleanup: discarding state",
1442 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1443 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1445 #endif /* defined(YYDESTRUCT_CALL) */
1450 yyFreeState(yyerrctx);
1455 YYParseState *save = yyps;
1462 YYParseState *save = yypath;
1463 yypath = save->save;
1467 #endif /* YYBTYACC */
1468 yyfreestack(&yystack);