1 /* original parser id follows */
2 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
3 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
8 #define YYCHECK "yyyymmdd"
11 #define yyclearin (yychar = YYEMPTY)
12 #define yyerrok (yyerrflag = 0)
13 #define YYRECOVERING() (yyerrflag != 0)
18 #define YYDEBUGSTR YYPREFIX "debug"
21 #define yyparse calc_parse
25 #define yylex calc_lex
29 #define yyerror calc_error
33 #define yychar calc_char
37 #define yyval calc_val
41 #define yylval calc_lval
45 #define yydebug calc_debug
49 #define yynerrs calc_nerrs
53 #define yyerrflag calc_errflag
54 #endif /* yyerrflag */
57 #define yylhs calc_lhs
61 #define yylen calc_len
65 #define yydefred calc_defred
69 #define yystos calc_stos
73 #define yydgoto calc_dgoto
77 #define yysindex calc_sindex
81 #define yyrindex calc_rindex
85 #define yygindex calc_gindex
89 #define yytable calc_table
93 #define yycheck calc_check
97 #define yyname calc_name
101 #define yyrule calc_rule
107 #define yycindex calc_cindex
108 #endif /* yycindex */
111 #define yyctable calc_ctable
112 #endif /* yyctable */
114 #endif /* YYBTYACC */
116 #define YYPREFIX "calc_"
127 extern int yylex(void);
128 static void yyerror(const char *s);
130 #line 131 "calc.tab.c"
132 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
133 /* Default: YYSTYPE is the semantic value type. */
135 # define YYSTYPE_IS_DECLARED 1
138 /* compatibility with bison */
140 /* compatibility with FreeBSD */
141 # ifdef YYPARSE_PARAM_TYPE
142 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
144 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
147 # define YYPARSE_DECL() yyparse(void)
150 /* Parameters sent to lex. */
152 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
153 # define YYLEX yylex(YYLEX_PARAM)
155 # define YYLEX_DECL() yylex(void)
156 # define YYLEX yylex()
159 /* Parameters sent to yyerror. */
161 #define YYERROR_DECL() yyerror(const char *s)
164 #define YYERROR_CALL(msg) yyerror(msg)
167 extern int YYPARSE_DECL();
172 #define YYERRCODE 256
174 static const YYINT calc_lhs[] = { -1,
175 0, 0, 0, 1, 1, 2, 2, 2, 2, 2,
176 2, 2, 2, 2, 2, 2, 3, 3,
178 static const YYINT calc_len[] = { 2,
179 0, 3, 3, 1, 3, 3, 3, 3, 3, 3,
180 3, 3, 3, 2, 1, 1, 1, 2,
182 static const YYINT calc_defred[] = { 1,
183 0, 0, 17, 0, 0, 0, 0, 0, 0, 3,
184 0, 15, 14, 0, 2, 0, 0, 0, 0, 0,
185 0, 0, 18, 0, 6, 0, 0, 0, 0, 9,
188 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
189 static const YYINT calc_stos[] = { 0,
190 261, 256, 257, 258, 45, 40, 262, 263, 264, 10,
191 61, 258, 263, 263, 10, 124, 38, 43, 45, 42,
192 47, 37, 257, 263, 41, 263, 263, 263, 263, 263,
195 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
196 static const YYINT calc_dgoto[] = { 1,
199 static const YYINT calc_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 calc_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 calc_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 calc_gindex[] = { 0,
222 #define YYTABLESIZE 220
223 static const YYINT calc_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 calc_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 calc_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 calc_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 calc_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 YYINT *yylexp = 0;
463 static YYINT *yylexemes = 0;
464 #endif /* YYBTYACC */
466 /* start of programs */
471 while(!feof(stdin)) {
478 yyerror(const char *s)
480 fprintf(stderr, "%s\n", s);
486 /* lexical analysis routine */
487 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
488 /* return DIGIT for a digit, yylval = 0 through 9 */
489 /* all other characters are returned immediately */
493 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
495 /* c is now nonblank */
507 #line 508 "calc.tab.c"
509 /* For use in generated program */
510 #define yydepth (int)(yystack.s_mark - yystack.s_base)
512 #define yytrial (yyps->save)
513 #endif /* YYBTYACC */
516 #include <stdio.h> /* needed for printf */
519 #include <stdlib.h> /* needed for malloc, etc */
520 #include <string.h> /* needed for memset */
522 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
523 static int yygrowstack(YYSTACKDATA *data)
529 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
533 if ((newsize = data->stacksize) == 0)
534 newsize = YYINITSTACKSIZE;
535 else if (newsize >= YYMAXDEPTH)
537 else if ((newsize *= 2) > YYMAXDEPTH)
538 newsize = YYMAXDEPTH;
540 i = (int) (data->s_mark - data->s_base);
541 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
545 data->s_base = newss;
546 data->s_mark = newss + i;
548 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
552 data->l_base = newvs;
553 data->l_mark = newvs + i;
555 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
556 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
560 data->p_base = newps;
561 data->p_mark = newps + i;
564 data->stacksize = newsize;
565 data->s_last = data->s_base + newsize - 1;
569 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
574 #if YYPURE || defined(YY_NO_LEAKS)
575 static void yyfreestack(YYSTACKDATA *data)
579 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
582 memset(data, 0, sizeof(*data));
585 #define yyfreestack(data) /* nothing */
586 #endif /* YYPURE || defined(YY_NO_LEAKS) */
589 static YYParseState *
590 yyNewState(unsigned size)
592 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
593 if (p == NULL) return NULL;
595 p->yystack.stacksize = size;
598 p->yystack.s_base = NULL;
599 p->yystack.l_base = NULL;
600 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
601 p->yystack.p_base = NULL;
605 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
606 if (p->yystack.s_base == NULL) return NULL;
607 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
608 if (p->yystack.l_base == NULL) return NULL;
609 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
610 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
611 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
612 if (p->yystack.p_base == NULL) return NULL;
613 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
620 yyFreeState(YYParseState *p)
622 yyfreestack(&p->yystack);
625 #endif /* YYBTYACC */
627 #define YYABORT goto yyabort
628 #define YYREJECT goto yyabort
629 #define YYACCEPT goto yyaccept
630 #define YYERROR goto yyerrlab
632 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
633 #define YYVALID_NESTED do { if (yyps->save && \
634 yyps->save->save == 0) goto yyvalid; } while(0)
635 #endif /* YYBTYACC */
640 int yym, yyn, yystate, yyresult;
643 YYParseState *yyerrctx = NULL;
644 #endif /* YYBTYACC */
645 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
646 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
651 if ((yys = getenv("YYDEBUG")) != 0)
654 if (yyn >= '0' && yyn <= '9')
658 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
662 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
664 #endif /* YYBTYACC */
673 memset(&yystack, 0, sizeof(yystack));
676 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
677 yystack.s_mark = yystack.s_base;
678 yystack.l_mark = yystack.l_base;
679 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
680 yystack.p_mark = yystack.p_base;
686 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
693 /* we're currently re-reading tokens */
695 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
703 /* in trial mode; save scanner results for future parse attempts */
704 if (yylvp == yylvlim)
705 { /* Enlarge lexical value queue */
706 size_t p = (size_t) (yylvp - yylvals);
707 size_t s = (size_t) (yylvlim - yylvals);
709 s += YYLVQUEUEGROWTH;
710 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
711 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
712 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
713 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
715 yylvp = yylve = yylvals + p;
716 yylvlim = yylvals + s;
717 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
718 yylpp = yylpe = yylpsns + p;
719 yylplim = yylpsns + s;
721 yylexp = yylexemes + p;
723 *yylexp = (YYINT) YYLEX;
726 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
733 /* normal operation, no conflict encountered */
734 #endif /* YYBTYACC */
738 #endif /* YYBTYACC */
739 if (yychar < 0) yychar = YYEOF;
743 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
744 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
745 YYDEBUGSTR, yydepth, yystate, yychar, yys);
746 #ifdef YYSTYPE_TOSTRING
749 #endif /* YYBTYACC */
750 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
758 /* Do we have a conflict? */
759 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
760 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
769 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
770 YYDEBUGSTR, yydepth, yystate);
772 /* Switch to the next conflict context */
777 if (save->state != yystate) YYABORT;
784 /* Unresolved conflict - start/continue trial parse */
789 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
791 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
793 fputs("Starting trial parse.\n", stderr);
796 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
797 if (save == NULL) goto yyenomem;
798 save->save = yyps->save;
799 save->state = yystate;
800 save->errflag = yyerrflag;
801 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
802 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
803 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
804 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
805 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
806 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
807 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
810 if (yyctable[ctry] == -1)
813 if (yydebug && yychar >= YYEOF)
814 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
819 if (yyps->save == NULL)
821 /* If this is a first conflict in the stack, start saving lexemes */
824 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
825 if (yylexemes == NULL) goto yyenomem;
826 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
827 if (yylvals == NULL) goto yyenomem;
828 yylvlim = yylvals + YYLVQUEUEGROWTH;
829 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
830 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
831 if (yylpsns == NULL) goto yyenomem;
832 yylplim = yylpsns + YYLVQUEUEGROWTH;
837 yylvp = yylve = yylvals;
838 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
839 yylpp = yylpe = yylpsns;
845 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
848 *yylexp = (YYINT) yychar;
856 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
862 save->lexeme = (int) (yylvp - yylvals);
865 if (yytable[yyn] == ctry)
869 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
870 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
875 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
880 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
882 yystate = yyctable[ctry];
883 *++yystack.s_mark = (YYINT) yystate;
884 *++yystack.l_mark = yylval;
885 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
886 *++yystack.p_mark = yylloc;
889 if (yyerrflag > 0) --yyerrflag;
894 yyn = yyctable[ctry];
897 } /* End of code dealing with conflicts */
898 #endif /* YYBTYACC */
899 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
900 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
904 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
905 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
907 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
908 yystate = yytable[yyn];
909 *++yystack.s_mark = yytable[yyn];
910 *++yystack.l_mark = yylval;
911 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
912 *++yystack.p_mark = yylloc;
915 if (yyerrflag > 0) --yyerrflag;
918 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
919 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
924 if (yyerrflag != 0) goto yyinrecovery;
929 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
932 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
933 * before looking for error recovery */
934 yystack.s_mark -= yym;
935 yystate = *yystack.s_mark;
936 yystack.l_mark -= yym;
937 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
938 yystack.p_mark -= yym;
946 YYParseState *save = yyps->save;
949 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
950 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
951 (int)(yylvp - yylvals - yyps->save->lexeme));
953 /* Memorize most forward-looking error state in case it's really an error. */
954 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
956 /* Free old saved error context state */
957 if (yyerrctx) yyFreeState(yyerrctx);
958 /* Create and fill out new saved error context state */
959 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
960 if (yyerrctx == NULL) goto yyenomem;
961 yyerrctx->save = yyps->save;
962 yyerrctx->state = yystate;
963 yyerrctx->errflag = yyerrflag;
964 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
965 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
966 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
967 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
968 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
969 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
970 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
972 yyerrctx->lexeme = (int) (yylvp - yylvals);
974 yylvp = yylvals + save->lexeme;
975 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
976 yylpp = yylpsns + save->lexeme;
978 yylexp = yylexemes + save->lexeme;
980 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
981 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
982 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
983 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
984 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
985 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
986 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
989 yystate = save->state;
990 /* We tried shift, try reduce now */
991 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
992 yyps->save = save->save;
996 /* Nothing left on the stack -- error */
1001 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1004 /* Restore state as it was in the most forward-advanced error */
1005 yylvp = yylvals + yyerrctx->lexeme;
1006 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1007 yylpp = yylpsns + yyerrctx->lexeme;
1009 yylexp = yylexemes + yyerrctx->lexeme;
1010 yychar = yylexp[-1];
1012 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1015 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1016 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1017 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1018 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1019 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1020 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1021 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1023 yystate = yyerrctx->state;
1024 yyFreeState(yyerrctx);
1029 if (yynewerrflag == 0) goto yyinrecovery;
1030 #endif /* YYBTYACC */
1032 YYERROR_CALL("syntax error");
1033 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1034 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1038 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1049 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1050 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1054 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1055 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1057 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1058 yystate = yytable[yyn];
1059 *++yystack.s_mark = yytable[yyn];
1060 *++yystack.l_mark = yylval;
1061 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1062 /* lookahead position is error end position */
1063 yyerror_loc_range[1] = yylloc;
1064 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1065 *++yystack.p_mark = yyloc;
1073 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1074 YYDEBUGSTR, yydepth, *yystack.s_mark);
1076 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1077 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1078 /* the current TOS position is the error start position */
1079 yyerror_loc_range[0] = *yystack.p_mark;
1081 #if defined(YYDESTRUCT_CALL)
1084 #endif /* YYBTYACC */
1085 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1086 YYDESTRUCT_CALL("error: discarding state",
1087 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1089 YYDESTRUCT_CALL("error: discarding state",
1090 yystos[*yystack.s_mark], yystack.l_mark);
1091 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1092 #endif /* defined(YYDESTRUCT_CALL) */
1095 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1103 if (yychar == YYEOF) goto yyabort;
1107 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1108 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1109 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1112 #if defined(YYDESTRUCT_CALL)
1115 #endif /* YYBTYACC */
1116 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1117 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1119 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1120 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1121 #endif /* defined(YYDESTRUCT_CALL) */
1131 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1132 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1133 #ifdef YYSTYPE_TOSTRING
1136 #endif /* YYBTYACC */
1141 for (i = yym; i > 0; i--)
1143 if (i != yym) fputs(", ", stderr);
1144 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1145 yystack.l_mark[1-i]), stderr);
1150 fputc('\n', stderr);
1154 yyval = yystack.l_mark[1-yym];
1156 memset(&yyval, 0, sizeof yyval);
1157 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1159 /* Perform position reduction */
1160 memset(&yyloc, 0, sizeof(yyloc));
1163 #endif /* YYBTYACC */
1165 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1166 /* just in case YYERROR is invoked within the action, save
1167 the start of the rhs as the error start position */
1168 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1180 { printf("%d\n",yystack.l_mark[0]);}
1184 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1188 { yyval = yystack.l_mark[-1]; }
1192 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1196 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1200 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1204 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1208 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1212 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1216 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1220 { yyval = - yystack.l_mark[0]; }
1224 { yyval = regs[yystack.l_mark[0]]; }
1228 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1232 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1234 #line 1235 "calc.tab.c"
1238 yystack.s_mark -= yym;
1239 yystate = *yystack.s_mark;
1240 yystack.l_mark -= yym;
1241 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1242 yystack.p_mark -= yym;
1245 if (yystate == 0 && yym == 0)
1250 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1251 #ifdef YYSTYPE_TOSTRING
1254 #endif /* YYBTYACC */
1255 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1257 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1261 *++yystack.s_mark = YYFINAL;
1262 *++yystack.l_mark = yyval;
1263 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1264 *++yystack.p_mark = yyloc;
1272 /* we're currently re-reading tokens */
1274 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1282 /* in trial mode; save scanner results for future parse attempts */
1283 if (yylvp == yylvlim)
1284 { /* Enlarge lexical value queue */
1285 size_t p = (size_t) (yylvp - yylvals);
1286 size_t s = (size_t) (yylvlim - yylvals);
1288 s += YYLVQUEUEGROWTH;
1289 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1291 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1293 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1294 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1297 yylvp = yylve = yylvals + p;
1298 yylvlim = yylvals + s;
1299 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1300 yylpp = yylpe = yylpsns + p;
1301 yylplim = yylpsns + s;
1303 yylexp = yylexemes + p;
1305 *yylexp = (YYINT) YYLEX;
1308 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1315 /* normal operation, no conflict encountered */
1316 #endif /* YYBTYACC */
1320 #endif /* YYBTYACC */
1321 if (yychar < 0) yychar = YYEOF;
1325 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1326 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1327 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1331 if (yychar == YYEOF) goto yyaccept;
1334 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1335 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1336 yystate = yytable[yyn];
1338 yystate = yydgoto[yym];
1342 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1343 #ifdef YYSTYPE_TOSTRING
1346 #endif /* YYBTYACC */
1347 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1349 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1352 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1353 *++yystack.s_mark = (YYINT) yystate;
1354 *++yystack.l_mark = yyval;
1355 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1356 *++yystack.p_mark = yyloc;
1361 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1363 if (yypath) YYABORT;
1366 YYParseState *save = yyps->save;
1367 yyps->save = save->save;
1368 save->save = yypath;
1373 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1374 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1378 yyFreeState(yyerrctx);
1381 yylvp = yylvals + yypath->lexeme;
1382 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1383 yylpp = yylpsns + yypath->lexeme;
1385 yylexp = yylexemes + yypath->lexeme;
1387 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1388 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1389 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1390 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1391 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1392 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1393 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1395 yystate = yypath->state;
1397 #endif /* YYBTYACC */
1400 YYERROR_CALL("yacc stack overflow");
1404 YYERROR_CALL("memory exhausted");
1406 #endif /* YYBTYACC */
1416 if (yyps->save) goto yyvalid;
1417 #endif /* YYBTYACC */
1421 #if defined(YYDESTRUCT_CALL)
1422 if (yychar != YYEOF && yychar != YYEMPTY)
1423 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1424 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1426 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1427 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1431 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1434 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1435 YYDESTRUCT_CALL("cleanup: discarding state",
1436 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1438 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1439 YYDESTRUCT_CALL("cleanup: discarding state",
1440 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1441 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1443 #endif /* defined(YYDESTRUCT_CALL) */
1448 yyFreeState(yyerrctx);
1453 YYParseState *save = yyps;
1460 YYParseState *save = yypath;
1461 yypath = save->save;
1465 #endif /* YYBTYACC */
1466 yyfreestack(&yystack);