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 calc3_parse
25 #define yylex calc3_lex
29 #define yyerror calc3_error
33 #define yychar calc3_char
37 #define yyval calc3_val
41 #define yylval calc3_lval
45 #define yydebug calc3_debug
49 #define yynerrs calc3_nerrs
53 #define yyerrflag calc3_errflag
54 #endif /* yyerrflag */
57 #define yylhs calc3_lhs
61 #define yylen calc3_len
65 #define yydefred calc3_defred
69 #define yystos calc3_stos
73 #define yydgoto calc3_dgoto
77 #define yysindex calc3_sindex
81 #define yyrindex calc3_rindex
85 #define yygindex calc3_gindex
89 #define yytable calc3_table
93 #define yycheck calc3_check
97 #define yyname calc3_name
101 #define yyrule calc3_rule
107 #define yycindex calc3_cindex
108 #endif /* yycindex */
111 #define yyctable calc3_ctable
112 #endif /* yyctable */
114 #endif /* YYBTYACC */
116 #define YYPREFIX "calc3_"
126 #define YYLEX_PARAM base
127 #define YYLEX_DECL() yylex(YYSTYPE *yylval, int *YYLEX_PARAM)
128 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
130 static void YYERROR_DECL();
133 #line 134 "calc3.tab.c"
135 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
136 /* Default: YYSTYPE is the semantic value type. */
138 # define YYSTYPE_IS_DECLARED 1
141 /* compatibility with bison */
143 /* compatibility with FreeBSD */
144 # ifdef YYPARSE_PARAM_TYPE
145 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
147 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
150 # define YYPARSE_DECL() yyparse(int regs[26], int *base)
153 /* Parameters sent to lex. */
155 # ifdef YYLEX_PARAM_TYPE
156 # define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
158 # define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
160 # define YYLEX yylex(&yylval, YYLEX_PARAM)
162 # define YYLEX_DECL() yylex(YYSTYPE *yylval, int *base)
163 # define YYLEX yylex(&yylval, base)
166 /* Parameters sent to yyerror. */
168 #define YYERROR_DECL() yyerror(int regs[26], int *base, const char *s)
171 #define YYERROR_CALL(msg) yyerror(regs, base, msg)
174 extern int YYPARSE_DECL();
179 #define YYERRCODE 256
181 static const YYINT calc3_lhs[] = { -1,
182 0, 0, 0, 1, 1, 2, 2, 2, 2, 2,
183 2, 2, 2, 2, 2, 2, 3, 3,
185 static const YYINT calc3_len[] = { 2,
186 0, 3, 3, 1, 3, 3, 3, 3, 3, 3,
187 3, 3, 3, 2, 1, 1, 1, 2,
189 static const YYINT calc3_defred[] = { 1,
190 0, 0, 17, 0, 0, 0, 0, 0, 0, 3,
191 0, 15, 14, 0, 2, 0, 0, 0, 0, 0,
192 0, 0, 18, 0, 6, 0, 0, 0, 0, 9,
195 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
196 static const YYINT calc3_stos[] = { 0,
197 261, 256, 257, 258, 45, 40, 262, 263, 264, 10,
198 61, 258, 263, 263, 10, 124, 38, 43, 45, 42,
199 47, 37, 257, 263, 41, 263, 263, 263, 263, 263,
202 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
203 static const YYINT calc3_dgoto[] = { 1,
206 static const YYINT calc3_sindex[] = { 0,
207 -40, -7, 0, -55, -38, -38, 1, -29, -247, 0,
208 -38, 0, 0, 22, 0, -38, -38, -38, -38, -38,
209 -38, -38, 0, -29, 0, 51, 60, -20, -20, 0,
212 static const YYINT calc3_rindex[] = { 0,
213 0, 0, 0, 2, 0, 0, 0, 9, -9, 0,
214 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
215 0, 0, 0, 10, 0, -6, 14, 5, 13, 0,
219 static const YYINT calc3_cindex[] = { 0,
220 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
221 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
222 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
226 static const YYINT calc3_gindex[] = { 0,
229 #define YYTABLESIZE 220
230 static const YYINT calc3_table[] = { 6,
231 16, 6, 10, 13, 5, 11, 5, 22, 17, 23,
232 15, 15, 20, 18, 7, 19, 22, 21, 4, 5,
233 0, 20, 8, 12, 0, 0, 21, 16, 16, 0,
234 0, 16, 16, 16, 13, 16, 0, 16, 15, 15,
235 0, 0, 7, 15, 15, 7, 15, 7, 15, 7,
236 8, 12, 0, 8, 12, 8, 0, 8, 22, 17,
237 0, 0, 25, 20, 18, 0, 19, 0, 21, 13,
238 14, 0, 0, 0, 0, 24, 0, 0, 0, 0,
239 26, 27, 28, 29, 30, 31, 32, 22, 17, 0,
240 0, 0, 20, 18, 16, 19, 22, 21, 0, 0,
241 0, 20, 18, 0, 19, 0, 21, 0, 0, 0,
242 0, 0, 0, 0, 16, 0, 0, 13, 0, 0,
243 0, 0, 0, 0, 0, 15, 0, 0, 7, 0,
244 0, 0, 0, 0, 0, 0, 8, 12, 0, 0,
245 0, 0, 0, 0, 0, 16, 0, 0, 0, 0,
246 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
247 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
248 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
249 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
250 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
251 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
252 0, 0, 0, 0, 0, 2, 3, 4, 3, 12,
254 static const YYINT calc3_check[] = { 40,
255 10, 40, 10, 10, 45, 61, 45, 37, 38, 257,
256 10, 10, 42, 43, 10, 45, 37, 47, 10, 10,
257 -1, 42, 10, 10, -1, -1, 47, 37, 38, -1,
258 -1, 41, 42, 43, 41, 45, -1, 47, 37, 38,
259 -1, -1, 38, 42, 43, 41, 45, 43, 47, 45,
260 38, 38, -1, 41, 41, 43, -1, 45, 37, 38,
261 -1, -1, 41, 42, 43, -1, 45, -1, 47, 5,
262 6, -1, -1, -1, -1, 11, -1, -1, -1, -1,
263 16, 17, 18, 19, 20, 21, 22, 37, 38, -1,
264 -1, -1, 42, 43, 124, 45, 37, 47, -1, -1,
265 -1, 42, 43, -1, 45, -1, 47, -1, -1, -1,
266 -1, -1, -1, -1, 124, -1, -1, 124, -1, -1,
267 -1, -1, -1, -1, -1, 124, -1, -1, 124, -1,
268 -1, -1, -1, -1, -1, -1, 124, 124, -1, -1,
269 -1, -1, -1, -1, -1, 124, -1, -1, -1, -1,
270 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
271 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
272 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
273 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
274 -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, 256, 257, 258, 257, 258,
279 static const YYINT calc3_ctable[] = { -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, -1,
295 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
296 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
297 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
298 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
299 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
300 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
301 -1, -1, -1, -1, -1, -1, -1, -1, -1,
308 #define YYMAXTOKEN 259
309 #define YYUNDFTOKEN 265
310 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
312 static const char *const calc3_name[] = {
314 "$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,
315 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
316 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
317 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0,
318 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
319 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
320 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
321 0,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number",
324 static const char *const calc3_rule[] = {
327 "list : list stat '\\n'",
328 "list : list error '\\n'",
330 "stat : LETTER '=' expr",
331 "expr : '(' expr ')'",
332 "expr : expr '+' expr",
333 "expr : expr '-' expr",
334 "expr : expr '*' expr",
335 "expr : expr '/' expr",
336 "expr : expr '%' expr",
337 "expr : expr '&' expr",
338 "expr : expr '|' expr",
343 "number : number DIGIT",
351 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
352 #ifndef YYLLOC_DEFAULT
353 #define YYLLOC_DEFAULT(loc, rhs, n) \
358 (loc).first_line = ((rhs)[-1]).last_line; \
359 (loc).first_column = ((rhs)[-1]).last_column; \
360 (loc).last_line = ((rhs)[-1]).last_line; \
361 (loc).last_column = ((rhs)[-1]).last_column; \
365 (loc).first_line = ((rhs)[ 0 ]).first_line; \
366 (loc).first_column = ((rhs)[ 0 ]).first_column; \
367 (loc).last_line = ((rhs)[n-1]).last_line; \
368 (loc).last_column = ((rhs)[n-1]).last_column; \
371 #endif /* YYLLOC_DEFAULT */
372 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
375 #ifndef YYLVQUEUEGROWTH
376 #define YYLVQUEUEGROWTH 32
378 #endif /* YYBTYACC */
380 /* define the initial stack-sizes */
383 #define YYMAXDEPTH YYSTACKSIZE
386 #define YYSTACKSIZE YYMAXDEPTH
388 #define YYSTACKSIZE 10000
389 #define YYMAXDEPTH 10000
393 #ifndef YYINITSTACKSIZE
394 #define YYINITSTACKSIZE 200
404 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
411 struct YYParseState_s
413 struct YYParseState_s *save; /* Previously saved parser state */
414 YYSTACKDATA yystack; /* saved parser stack */
415 int state; /* saved parser state */
416 int errflag; /* saved error recovery status */
417 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
418 YYINT ctry; /* saved index in yyctable[] for this conflict */
420 typedef struct YYParseState_s YYParseState;
421 #endif /* YYBTYACC */
423 /* start of programs */
426 extern int YYLEX_DECL();
435 while(!feof(stdin)) {
436 yyparse(regs, &base);
441 #define UNUSED(x) ((void)(x))
446 UNUSED(regs); /* %parse-param regs is not actually used here */
447 UNUSED(base); /* %parse-param base is not actually used here */
448 fprintf(stderr, "%s\n", s);
454 /* lexical analysis routine */
455 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
456 /* return DIGIT for a digit, yylval = 0 through 9 */
457 /* all other characters are returned immediately */
461 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
463 /* c is now nonblank */
470 *yylval = (c - '0') % (*base);
475 #line 476 "calc3.tab.c"
477 /* For use in generated program */
478 #define yydepth (int)(yystack.s_mark - yystack.s_base)
480 #define yytrial (yyps->save)
481 #endif /* YYBTYACC */
484 #include <stdio.h> /* needed for printf */
487 #include <stdlib.h> /* needed for malloc, etc */
488 #include <string.h> /* needed for memset */
490 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
491 static int yygrowstack(YYSTACKDATA *data)
497 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
501 if ((newsize = data->stacksize) == 0)
502 newsize = YYINITSTACKSIZE;
503 else if (newsize >= YYMAXDEPTH)
505 else if ((newsize *= 2) > YYMAXDEPTH)
506 newsize = YYMAXDEPTH;
508 i = (int) (data->s_mark - data->s_base);
509 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
513 data->s_base = newss;
514 data->s_mark = newss + i;
516 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
520 data->l_base = newvs;
521 data->l_mark = newvs + i;
523 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
524 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
528 data->p_base = newps;
529 data->p_mark = newps + i;
532 data->stacksize = newsize;
533 data->s_last = data->s_base + newsize - 1;
537 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
542 #if YYPURE || defined(YY_NO_LEAKS)
543 static void yyfreestack(YYSTACKDATA *data)
547 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
550 memset(data, 0, sizeof(*data));
553 #define yyfreestack(data) /* nothing */
554 #endif /* YYPURE || defined(YY_NO_LEAKS) */
557 static YYParseState *
558 yyNewState(unsigned size)
560 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
561 if (p == NULL) return NULL;
563 p->yystack.stacksize = size;
566 p->yystack.s_base = NULL;
567 p->yystack.l_base = NULL;
568 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
569 p->yystack.p_base = NULL;
573 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
574 if (p->yystack.s_base == NULL) return NULL;
575 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
576 if (p->yystack.l_base == NULL) return NULL;
577 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
578 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
579 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
580 if (p->yystack.p_base == NULL) return NULL;
581 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
588 yyFreeState(YYParseState *p)
590 yyfreestack(&p->yystack);
593 #endif /* YYBTYACC */
595 #define YYABORT goto yyabort
596 #define YYREJECT goto yyabort
597 #define YYACCEPT goto yyaccept
598 #define YYERROR goto yyerrlab
600 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
601 #define YYVALID_NESTED do { if (yyps->save && \
602 yyps->save->save == 0) goto yyvalid; } while(0)
603 #endif /* YYBTYACC */
612 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
613 YYLTYPE yyloc; /* position returned by actions */
614 YYLTYPE yylloc; /* position from the lexer */
617 /* variables for the parser stack */
621 /* Current parser state */
622 static YYParseState *yyps = 0;
624 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
625 static YYParseState *yypath = 0;
627 /* Base of the lexical value queue */
628 static YYSTYPE *yylvals = 0;
630 /* Current position at lexical value queue */
631 static YYSTYPE *yylvp = 0;
633 /* End position of lexical value queue */
634 static YYSTYPE *yylve = 0;
636 /* The last allocated position at the lexical value queue */
637 static YYSTYPE *yylvlim = 0;
639 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
640 /* Base of the lexical position queue */
641 static YYLTYPE *yylpsns = 0;
643 /* Current position at lexical position queue */
644 static YYLTYPE *yylpp = 0;
646 /* End position of lexical position queue */
647 static YYLTYPE *yylpe = 0;
649 /* The last allocated position at the lexical position queue */
650 static YYLTYPE *yylplim = 0;
653 /* Current position at lexical token queue */
654 static YYINT *yylexp = 0;
656 static YYINT *yylexemes = 0;
657 #endif /* YYBTYACC */
658 int yym, yyn, yystate, yyresult;
661 YYParseState *yyerrctx = NULL;
662 #endif /* YYBTYACC */
663 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
664 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
669 if ((yys = getenv("YYDEBUG")) != 0)
672 if (yyn >= '0' && yyn <= '9')
676 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
678 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
679 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
684 memset(&yyval, 0, sizeof(yyval));
685 memset(&yylval, 0, sizeof(yylval));
686 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
687 memset(&yyloc, 0, sizeof(yyloc));
688 memset(&yylloc, 0, sizeof(yylloc));
692 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
694 #endif /* YYBTYACC */
703 memset(&yystack, 0, sizeof(yystack));
706 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
707 yystack.s_mark = yystack.s_base;
708 yystack.l_mark = yystack.l_base;
709 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
710 yystack.p_mark = yystack.p_base;
716 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
723 /* we're currently re-reading tokens */
725 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
733 /* in trial mode; save scanner results for future parse attempts */
734 if (yylvp == yylvlim)
735 { /* Enlarge lexical value queue */
736 size_t p = (size_t) (yylvp - yylvals);
737 size_t s = (size_t) (yylvlim - yylvals);
739 s += YYLVQUEUEGROWTH;
740 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
741 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
742 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
743 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
745 yylvp = yylve = yylvals + p;
746 yylvlim = yylvals + s;
747 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
748 yylpp = yylpe = yylpsns + p;
749 yylplim = yylpsns + s;
751 yylexp = yylexemes + p;
753 *yylexp = (YYINT) YYLEX;
756 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
763 /* normal operation, no conflict encountered */
764 #endif /* YYBTYACC */
768 #endif /* YYBTYACC */
769 if (yychar < 0) yychar = YYEOF;
773 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
774 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
775 YYDEBUGSTR, yydepth, yystate, yychar, yys);
776 #ifdef YYSTYPE_TOSTRING
779 #endif /* YYBTYACC */
780 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
788 /* Do we have a conflict? */
789 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
790 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
799 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
800 YYDEBUGSTR, yydepth, yystate);
802 /* Switch to the next conflict context */
807 if (save->state != yystate) YYABORT;
814 /* Unresolved conflict - start/continue trial parse */
819 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
821 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
823 fputs("Starting trial parse.\n", stderr);
826 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
827 if (save == NULL) goto yyenomem;
828 save->save = yyps->save;
829 save->state = yystate;
830 save->errflag = yyerrflag;
831 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
832 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
833 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
834 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
835 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
836 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
837 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
840 if (yyctable[ctry] == -1)
843 if (yydebug && yychar >= YYEOF)
844 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
849 if (yyps->save == NULL)
851 /* If this is a first conflict in the stack, start saving lexemes */
854 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
855 if (yylexemes == NULL) goto yyenomem;
856 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
857 if (yylvals == NULL) goto yyenomem;
858 yylvlim = yylvals + YYLVQUEUEGROWTH;
859 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
860 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
861 if (yylpsns == NULL) goto yyenomem;
862 yylplim = yylpsns + YYLVQUEUEGROWTH;
867 yylvp = yylve = yylvals;
868 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
869 yylpp = yylpe = yylpsns;
875 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
878 *yylexp = (YYINT) yychar;
886 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
892 save->lexeme = (int) (yylvp - yylvals);
895 if (yytable[yyn] == ctry)
899 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
900 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
905 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
910 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
912 yystate = yyctable[ctry];
913 *++yystack.s_mark = (YYINT) yystate;
914 *++yystack.l_mark = yylval;
915 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
916 *++yystack.p_mark = yylloc;
919 if (yyerrflag > 0) --yyerrflag;
924 yyn = yyctable[ctry];
927 } /* End of code dealing with conflicts */
928 #endif /* YYBTYACC */
929 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
930 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
934 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
935 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
937 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
938 yystate = yytable[yyn];
939 *++yystack.s_mark = yytable[yyn];
940 *++yystack.l_mark = yylval;
941 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
942 *++yystack.p_mark = yylloc;
945 if (yyerrflag > 0) --yyerrflag;
948 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
949 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
954 if (yyerrflag != 0) goto yyinrecovery;
959 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
962 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
963 * before looking for error recovery */
964 yystack.s_mark -= yym;
965 yystate = *yystack.s_mark;
966 yystack.l_mark -= yym;
967 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
968 yystack.p_mark -= yym;
976 YYParseState *save = yyps->save;
979 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
980 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
981 (int)(yylvp - yylvals - yyps->save->lexeme));
983 /* Memorize most forward-looking error state in case it's really an error. */
984 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
986 /* Free old saved error context state */
987 if (yyerrctx) yyFreeState(yyerrctx);
988 /* Create and fill out new saved error context state */
989 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
990 if (yyerrctx == NULL) goto yyenomem;
991 yyerrctx->save = yyps->save;
992 yyerrctx->state = yystate;
993 yyerrctx->errflag = yyerrflag;
994 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
995 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
996 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
997 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
998 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
999 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1000 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1002 yyerrctx->lexeme = (int) (yylvp - yylvals);
1004 yylvp = yylvals + save->lexeme;
1005 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1006 yylpp = yylpsns + save->lexeme;
1008 yylexp = yylexemes + save->lexeme;
1010 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1011 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1012 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1013 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1014 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1015 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1016 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1018 ctry = ++save->ctry;
1019 yystate = save->state;
1020 /* We tried shift, try reduce now */
1021 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1022 yyps->save = save->save;
1026 /* Nothing left on the stack -- error */
1031 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1034 /* Restore state as it was in the most forward-advanced error */
1035 yylvp = yylvals + yyerrctx->lexeme;
1036 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1037 yylpp = yylpsns + yyerrctx->lexeme;
1039 yylexp = yylexemes + yyerrctx->lexeme;
1040 yychar = yylexp[-1];
1042 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1045 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1046 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1047 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1048 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1049 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1050 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1051 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1053 yystate = yyerrctx->state;
1054 yyFreeState(yyerrctx);
1059 if (yynewerrflag == 0) goto yyinrecovery;
1060 #endif /* YYBTYACC */
1062 YYERROR_CALL("syntax error");
1063 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1064 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1068 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1079 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1080 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1084 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1085 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1087 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1088 yystate = yytable[yyn];
1089 *++yystack.s_mark = yytable[yyn];
1090 *++yystack.l_mark = yylval;
1091 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1092 /* lookahead position is error end position */
1093 yyerror_loc_range[1] = yylloc;
1094 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1095 *++yystack.p_mark = yyloc;
1103 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1104 YYDEBUGSTR, yydepth, *yystack.s_mark);
1106 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1107 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1108 /* the current TOS position is the error start position */
1109 yyerror_loc_range[0] = *yystack.p_mark;
1111 #if defined(YYDESTRUCT_CALL)
1114 #endif /* YYBTYACC */
1115 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1116 YYDESTRUCT_CALL("error: discarding state",
1117 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1119 YYDESTRUCT_CALL("error: discarding state",
1120 yystos[*yystack.s_mark], yystack.l_mark);
1121 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1122 #endif /* defined(YYDESTRUCT_CALL) */
1125 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1133 if (yychar == YYEOF) goto yyabort;
1137 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1138 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1139 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1142 #if defined(YYDESTRUCT_CALL)
1145 #endif /* YYBTYACC */
1146 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1147 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1149 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1150 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1151 #endif /* defined(YYDESTRUCT_CALL) */
1161 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1162 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1163 #ifdef YYSTYPE_TOSTRING
1166 #endif /* YYBTYACC */
1171 for (i = yym; i > 0; i--)
1173 if (i != yym) fputs(", ", stderr);
1174 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1175 yystack.l_mark[1-i]), stderr);
1180 fputc('\n', stderr);
1184 yyval = yystack.l_mark[1-yym];
1186 memset(&yyval, 0, sizeof yyval);
1187 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1189 /* Perform position reduction */
1190 memset(&yyloc, 0, sizeof(yyloc));
1193 #endif /* YYBTYACC */
1195 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1196 /* just in case YYERROR is invoked within the action, save
1197 the start of the rhs as the error start position */
1198 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1210 { printf("%d\n",yystack.l_mark[0]);}
1214 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1218 { yyval = yystack.l_mark[-1]; }
1222 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1226 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1230 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1234 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1238 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1242 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1246 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1250 { yyval = - yystack.l_mark[0]; }
1254 { yyval = regs[yystack.l_mark[0]]; }
1258 { yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; }
1262 { yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
1264 #line 1265 "calc3.tab.c"
1268 yystack.s_mark -= yym;
1269 yystate = *yystack.s_mark;
1270 yystack.l_mark -= yym;
1271 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1272 yystack.p_mark -= yym;
1275 if (yystate == 0 && yym == 0)
1280 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1281 #ifdef YYSTYPE_TOSTRING
1284 #endif /* YYBTYACC */
1285 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1287 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1291 *++yystack.s_mark = YYFINAL;
1292 *++yystack.l_mark = yyval;
1293 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1294 *++yystack.p_mark = yyloc;
1302 /* we're currently re-reading tokens */
1304 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1312 /* in trial mode; save scanner results for future parse attempts */
1313 if (yylvp == yylvlim)
1314 { /* Enlarge lexical value queue */
1315 size_t p = (size_t) (yylvp - yylvals);
1316 size_t s = (size_t) (yylvlim - yylvals);
1318 s += YYLVQUEUEGROWTH;
1319 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1321 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1323 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1324 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1327 yylvp = yylve = yylvals + p;
1328 yylvlim = yylvals + s;
1329 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1330 yylpp = yylpe = yylpsns + p;
1331 yylplim = yylpsns + s;
1333 yylexp = yylexemes + p;
1335 *yylexp = (YYINT) YYLEX;
1338 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1345 /* normal operation, no conflict encountered */
1346 #endif /* YYBTYACC */
1350 #endif /* YYBTYACC */
1351 if (yychar < 0) yychar = YYEOF;
1355 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1356 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1357 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1361 if (yychar == YYEOF) goto yyaccept;
1364 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1365 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1366 yystate = yytable[yyn];
1368 yystate = yydgoto[yym];
1372 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1373 #ifdef YYSTYPE_TOSTRING
1376 #endif /* YYBTYACC */
1377 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1379 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1382 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1383 *++yystack.s_mark = (YYINT) yystate;
1384 *++yystack.l_mark = yyval;
1385 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1386 *++yystack.p_mark = yyloc;
1391 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1393 if (yypath) YYABORT;
1396 YYParseState *save = yyps->save;
1397 yyps->save = save->save;
1398 save->save = yypath;
1403 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1404 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1408 yyFreeState(yyerrctx);
1411 yylvp = yylvals + yypath->lexeme;
1412 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1413 yylpp = yylpsns + yypath->lexeme;
1415 yylexp = yylexemes + yypath->lexeme;
1417 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1418 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1419 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1420 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1421 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1422 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1423 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1425 yystate = yypath->state;
1427 #endif /* YYBTYACC */
1430 YYERROR_CALL("yacc stack overflow");
1434 YYERROR_CALL("memory exhausted");
1436 #endif /* YYBTYACC */
1446 if (yyps->save) goto yyvalid;
1447 #endif /* YYBTYACC */
1451 #if defined(YYDESTRUCT_CALL)
1452 if (yychar != YYEOF && yychar != YYEMPTY)
1453 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1454 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1456 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1457 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1461 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1464 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1465 YYDESTRUCT_CALL("cleanup: discarding state",
1466 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1468 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1469 YYDESTRUCT_CALL("cleanup: discarding state",
1470 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1471 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1473 #endif /* defined(YYDESTRUCT_CALL) */
1478 yyFreeState(yyerrctx);
1483 YYParseState *save = yyps;
1490 YYParseState *save = yypath;
1491 yypath = save->save;
1495 #endif /* YYBTYACC */
1496 yyfreestack(&yystack);