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 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 static const YYINT calc3_stos[] = { 0,
196 261, 256, 257, 258, 45, 40, 262, 263, 264, 10,
197 61, 258, 263, 263, 10, 124, 38, 43, 45, 42,
198 47, 37, 257, 263, 41, 263, 263, 263, 263, 263,
201 static const YYINT calc3_dgoto[] = { 1,
204 static const YYINT calc3_sindex[] = { 0,
205 -40, -7, 0, -55, -38, -38, 1, -29, -247, 0,
206 -38, 0, 0, 22, 0, -38, -38, -38, -38, -38,
207 -38, -38, 0, -29, 0, 51, 60, -20, -20, 0,
210 static const YYINT calc3_rindex[] = { 0,
211 0, 0, 0, 2, 0, 0, 0, 9, -9, 0,
212 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
213 0, 0, 0, 10, 0, -6, 14, 5, 13, 0,
217 static const YYINT calc3_cindex[] = { 0,
218 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
219 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
220 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
224 static const YYINT calc3_gindex[] = { 0,
227 #define YYTABLESIZE 220
228 static const YYINT calc3_table[] = { 6,
229 16, 6, 10, 13, 5, 11, 5, 22, 17, 23,
230 15, 15, 20, 18, 7, 19, 22, 21, 4, 5,
231 0, 20, 8, 12, 0, 0, 21, 16, 16, 0,
232 0, 16, 16, 16, 13, 16, 0, 16, 15, 15,
233 0, 0, 7, 15, 15, 7, 15, 7, 15, 7,
234 8, 12, 0, 8, 12, 8, 0, 8, 22, 17,
235 0, 0, 25, 20, 18, 0, 19, 0, 21, 13,
236 14, 0, 0, 0, 0, 24, 0, 0, 0, 0,
237 26, 27, 28, 29, 30, 31, 32, 22, 17, 0,
238 0, 0, 20, 18, 16, 19, 22, 21, 0, 0,
239 0, 20, 18, 0, 19, 0, 21, 0, 0, 0,
240 0, 0, 0, 0, 16, 0, 0, 13, 0, 0,
241 0, 0, 0, 0, 0, 15, 0, 0, 7, 0,
242 0, 0, 0, 0, 0, 0, 8, 12, 0, 0,
243 0, 0, 0, 0, 0, 16, 0, 0, 0, 0,
244 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
245 0, 0, 0, 0, 0, 0, 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, 2, 3, 4, 3, 12,
252 static const YYINT calc3_check[] = { 40,
253 10, 40, 10, 10, 45, 61, 45, 37, 38, 257,
254 10, 10, 42, 43, 10, 45, 37, 47, 10, 10,
255 -1, 42, 10, 10, -1, -1, 47, 37, 38, -1,
256 -1, 41, 42, 43, 41, 45, -1, 47, 37, 38,
257 -1, -1, 38, 42, 43, 41, 45, 43, 47, 45,
258 38, 38, -1, 41, 41, 43, -1, 45, 37, 38,
259 -1, -1, 41, 42, 43, -1, 45, -1, 47, 5,
260 6, -1, -1, -1, -1, 11, -1, -1, -1, -1,
261 16, 17, 18, 19, 20, 21, 22, 37, 38, -1,
262 -1, -1, 42, 43, 124, 45, 37, 47, -1, -1,
263 -1, 42, 43, -1, 45, -1, 47, -1, -1, -1,
264 -1, -1, -1, -1, 124, -1, -1, 124, -1, -1,
265 -1, -1, -1, -1, -1, 124, -1, -1, 124, -1,
266 -1, -1, -1, -1, -1, -1, 124, 124, -1, -1,
267 -1, -1, -1, -1, -1, 124, -1, -1, -1, -1,
268 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
269 -1, -1, -1, -1, -1, -1, -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, 256, 257, 258, 257, 258,
277 static const YYINT calc3_ctable[] = { -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, -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,
306 #define YYMAXTOKEN 259
307 #define YYUNDFTOKEN 265
308 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
310 static const char *const calc3_name[] = {
312 "$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,
313 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
314 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,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,0,0,0,0,0,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,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,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,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number",
322 static const char *const calc3_rule[] = {
325 "list : list stat '\\n'",
326 "list : list error '\\n'",
328 "stat : LETTER '=' expr",
329 "expr : '(' expr ')'",
330 "expr : expr '+' expr",
331 "expr : expr '-' expr",
332 "expr : expr '*' expr",
333 "expr : expr '/' expr",
334 "expr : expr '%' expr",
335 "expr : expr '&' expr",
336 "expr : expr '|' expr",
341 "number : number DIGIT",
349 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
350 #ifndef YYLLOC_DEFAULT
351 #define YYLLOC_DEFAULT(loc, rhs, n) \
356 (loc).first_line = ((rhs)[-1]).last_line; \
357 (loc).first_column = ((rhs)[-1]).last_column; \
358 (loc).last_line = ((rhs)[-1]).last_line; \
359 (loc).last_column = ((rhs)[-1]).last_column; \
363 (loc).first_line = ((rhs)[ 0 ]).first_line; \
364 (loc).first_column = ((rhs)[ 0 ]).first_column; \
365 (loc).last_line = ((rhs)[n-1]).last_line; \
366 (loc).last_column = ((rhs)[n-1]).last_column; \
369 #endif /* YYLLOC_DEFAULT */
370 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
373 #ifndef YYLVQUEUEGROWTH
374 #define YYLVQUEUEGROWTH 32
376 #endif /* YYBTYACC */
378 /* define the initial stack-sizes */
381 #define YYMAXDEPTH YYSTACKSIZE
384 #define YYSTACKSIZE YYMAXDEPTH
386 #define YYSTACKSIZE 10000
387 #define YYMAXDEPTH 10000
391 #ifndef YYINITSTACKSIZE
392 #define YYINITSTACKSIZE 200
402 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
409 struct YYParseState_s
411 struct YYParseState_s *save; /* Previously saved parser state */
412 YYSTACKDATA yystack; /* saved parser stack */
413 int state; /* saved parser state */
414 int errflag; /* saved error recovery status */
415 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
416 YYINT ctry; /* saved index in yyctable[] for this conflict */
418 typedef struct YYParseState_s YYParseState;
419 #endif /* YYBTYACC */
421 /* start of programs */
424 extern int YYLEX_DECL();
433 while(!feof(stdin)) {
434 yyparse(regs, &base);
439 #define UNUSED(x) ((void)(x))
444 UNUSED(regs); /* %parse-param regs is not actually used here */
445 UNUSED(base); /* %parse-param base is not actually used here */
446 fprintf(stderr, "%s\n", s);
452 /* lexical analysis routine */
453 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
454 /* return DIGIT for a digit, yylval = 0 through 9 */
455 /* all other characters are returned immediately */
459 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
461 /* c is now nonblank */
468 *yylval = (c - '0') % (*base);
473 #line 474 "calc3.tab.c"
475 /* For use in generated program */
476 #define yydepth (int)(yystack.s_mark - yystack.s_base)
478 #define yytrial (yyps->save)
479 #endif /* YYBTYACC */
482 #include <stdio.h> /* needed for printf */
485 #include <stdlib.h> /* needed for malloc, etc */
486 #include <string.h> /* needed for memset */
488 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
489 static int yygrowstack(YYSTACKDATA *data)
495 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
499 if ((newsize = data->stacksize) == 0)
500 newsize = YYINITSTACKSIZE;
501 else if (newsize >= YYMAXDEPTH)
503 else if ((newsize *= 2) > YYMAXDEPTH)
504 newsize = YYMAXDEPTH;
506 i = (int) (data->s_mark - data->s_base);
507 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
511 data->s_base = newss;
512 data->s_mark = newss + i;
514 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
518 data->l_base = newvs;
519 data->l_mark = newvs + i;
521 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
522 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
526 data->p_base = newps;
527 data->p_mark = newps + i;
530 data->stacksize = newsize;
531 data->s_last = data->s_base + newsize - 1;
535 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
540 #if YYPURE || defined(YY_NO_LEAKS)
541 static void yyfreestack(YYSTACKDATA *data)
545 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
548 memset(data, 0, sizeof(*data));
551 #define yyfreestack(data) /* nothing */
552 #endif /* YYPURE || defined(YY_NO_LEAKS) */
555 static YYParseState *
556 yyNewState(unsigned size)
558 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
559 if (p == NULL) return NULL;
561 p->yystack.stacksize = size;
564 p->yystack.s_base = NULL;
565 p->yystack.l_base = NULL;
566 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
567 p->yystack.p_base = NULL;
571 p->yystack.s_base = (short *) malloc(size * sizeof(short));
572 if (p->yystack.s_base == NULL) return NULL;
573 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
574 if (p->yystack.l_base == NULL) return NULL;
575 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
576 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
577 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
578 if (p->yystack.p_base == NULL) return NULL;
579 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
586 yyFreeState(YYParseState *p)
588 yyfreestack(&p->yystack);
591 #endif /* YYBTYACC */
593 #define YYABORT goto yyabort
594 #define YYREJECT goto yyabort
595 #define YYACCEPT goto yyaccept
596 #define YYERROR goto yyerrlab
598 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
599 #define YYVALID_NESTED do { if (yyps->save && \
600 yyps->save->save == 0) goto yyvalid; } while(0)
601 #endif /* YYBTYACC */
610 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
611 YYLTYPE yyloc; /* position returned by actions */
612 YYLTYPE yylloc; /* position from the lexer */
615 /* variables for the parser stack */
619 /* Current parser state */
620 static YYParseState *yyps = 0;
622 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
623 static YYParseState *yypath = 0;
625 /* Base of the lexical value queue */
626 static YYSTYPE *yylvals = 0;
628 /* Current position at lexical value queue */
629 static YYSTYPE *yylvp = 0;
631 /* End position of lexical value queue */
632 static YYSTYPE *yylve = 0;
634 /* The last allocated position at the lexical value queue */
635 static YYSTYPE *yylvlim = 0;
637 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
638 /* Base of the lexical position queue */
639 static YYLTYPE *yylpsns = 0;
641 /* Current position at lexical position queue */
642 static YYLTYPE *yylpp = 0;
644 /* End position of lexical position queue */
645 static YYLTYPE *yylpe = 0;
647 /* The last allocated position at the lexical position queue */
648 static YYLTYPE *yylplim = 0;
651 /* Current position at lexical token queue */
652 static short *yylexp = 0;
654 static short *yylexemes = 0;
655 #endif /* YYBTYACC */
656 int yym, yyn, yystate, yyresult;
659 YYParseState *yyerrctx = NULL;
660 #endif /* YYBTYACC */
661 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
662 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
667 if ((yys = getenv("YYDEBUG")) != 0)
670 if (yyn >= '0' && yyn <= '9')
674 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
678 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
680 #endif /* YYBTYACC */
687 memset(&yystack, 0, sizeof(yystack));
690 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
691 yystack.s_mark = yystack.s_base;
692 yystack.l_mark = yystack.l_base;
693 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
694 yystack.p_mark = yystack.p_base;
700 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
707 /* we're currently re-reading tokens */
709 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
717 /* in trial mode; save scanner results for future parse attempts */
718 if (yylvp == yylvlim)
719 { /* Enlarge lexical value queue */
720 size_t p = (size_t) (yylvp - yylvals);
721 size_t s = (size_t) (yylvlim - yylvals);
723 s += YYLVQUEUEGROWTH;
724 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
725 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
726 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
727 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
729 yylvp = yylve = yylvals + p;
730 yylvlim = yylvals + s;
731 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
732 yylpp = yylpe = yylpsns + p;
733 yylplim = yylpsns + s;
735 yylexp = yylexemes + p;
737 *yylexp = (short) YYLEX;
740 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
747 /* normal operation, no conflict encountered */
748 #endif /* YYBTYACC */
752 #endif /* YYBTYACC */
753 if (yychar < 0) yychar = YYEOF;
754 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
758 yys = yyname[YYTRANSLATE(yychar)];
759 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
760 YYDEBUGSTR, yydepth, yystate, yychar, yys);
761 #ifdef YYSTYPE_TOSTRING
764 #endif /* YYBTYACC */
765 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
773 /* Do we have a conflict? */
774 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
775 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
784 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
785 YYDEBUGSTR, yydepth, yystate);
787 /* Switch to the next conflict context */
792 if (save->state != yystate) YYABORT;
799 /* Unresolved conflict - start/continue trial parse */
804 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
806 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
808 fputs("Starting trial parse.\n", stderr);
811 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
812 if (save == NULL) goto yyenomem;
813 save->save = yyps->save;
814 save->state = yystate;
815 save->errflag = yyerrflag;
816 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
817 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
818 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
819 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
820 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
821 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
822 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
825 if (yyctable[ctry] == -1)
828 if (yydebug && yychar >= YYEOF)
829 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
834 if (yyps->save == NULL)
836 /* If this is a first conflict in the stack, start saving lexemes */
839 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));
840 if (yylexemes == NULL) goto yyenomem;
841 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
842 if (yylvals == NULL) goto yyenomem;
843 yylvlim = yylvals + YYLVQUEUEGROWTH;
844 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
845 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
846 if (yylpsns == NULL) goto yyenomem;
847 yylplim = yylpsns + YYLVQUEUEGROWTH;
852 yylvp = yylve = yylvals;
853 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
854 yylpp = yylpe = yylpsns;
860 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
863 *yylexp = (short) yychar;
871 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
877 save->lexeme = (int) (yylvp - yylvals);
880 if (yytable[yyn] == ctry)
884 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
885 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
890 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
895 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
897 yystate = yyctable[ctry];
898 *++yystack.s_mark = (short) yystate;
899 *++yystack.l_mark = yylval;
900 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
901 *++yystack.p_mark = yylloc;
904 if (yyerrflag > 0) --yyerrflag;
909 yyn = yyctable[ctry];
912 } /* End of code dealing with conflicts */
913 #endif /* YYBTYACC */
914 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
915 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
919 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
920 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
922 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
923 yystate = yytable[yyn];
924 *++yystack.s_mark = yytable[yyn];
925 *++yystack.l_mark = yylval;
926 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
927 *++yystack.p_mark = yylloc;
930 if (yyerrflag > 0) --yyerrflag;
933 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
934 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
939 if (yyerrflag != 0) goto yyinrecovery;
952 YYParseState *save = yyps->save;
955 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
956 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
957 (int)(yylvp - yylvals - yyps->save->lexeme));
959 /* Memorize most forward-looking error state in case it's really an error. */
960 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
962 /* Free old saved error context state */
963 if (yyerrctx) yyFreeState(yyerrctx);
964 /* Create and fill out new saved error context state */
965 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
966 if (yyerrctx == NULL) goto yyenomem;
967 yyerrctx->save = yyps->save;
968 yyerrctx->state = yystate;
969 yyerrctx->errflag = yyerrflag;
970 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
971 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
972 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
973 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
974 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
975 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
976 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
978 yyerrctx->lexeme = (int) (yylvp - yylvals);
980 yylvp = yylvals + save->lexeme;
981 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
982 yylpp = yylpsns + save->lexeme;
984 yylexp = yylexemes + save->lexeme;
986 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
987 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
988 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
989 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
990 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
991 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
992 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
995 yystate = save->state;
996 /* We tried shift, try reduce now */
997 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
998 yyps->save = save->save;
1002 /* Nothing left on the stack -- error */
1007 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1010 /* Restore state as it was in the most forward-advanced error */
1011 yylvp = yylvals + yyerrctx->lexeme;
1012 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1013 yylpp = yylpsns + yyerrctx->lexeme;
1015 yylexp = yylexemes + yyerrctx->lexeme;
1016 yychar = yylexp[-1];
1018 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1021 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1022 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1023 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1024 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1025 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1026 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1027 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1029 yystate = yyerrctx->state;
1030 yyFreeState(yyerrctx);
1035 if (yynewerrflag == 0) goto yyinrecovery;
1036 #endif /* YYBTYACC */
1038 YYERROR_CALL("syntax error");
1039 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1040 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1055 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1056 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1060 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1061 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1063 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1064 yystate = yytable[yyn];
1065 *++yystack.s_mark = yytable[yyn];
1066 *++yystack.l_mark = yylval;
1067 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1068 /* lookahead position is error end position */
1069 yyerror_loc_range[1] = yylloc;
1070 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1071 *++yystack.p_mark = yyloc;
1079 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1080 YYDEBUGSTR, yydepth, *yystack.s_mark);
1082 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1083 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1084 /* the current TOS position is the error start position */
1085 yyerror_loc_range[0] = *yystack.p_mark;
1087 #if defined(YYDESTRUCT_CALL)
1090 #endif /* YYBTYACC */
1091 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1092 YYDESTRUCT_CALL("error: discarding state",
1093 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1095 YYDESTRUCT_CALL("error: discarding state",
1096 yystos[*yystack.s_mark], yystack.l_mark);
1097 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1098 #endif /* defined(YYDESTRUCT_CALL) */
1101 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1109 if (yychar == YYEOF) goto yyabort;
1113 yys = yyname[YYTRANSLATE(yychar)];
1114 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1115 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1118 #if defined(YYDESTRUCT_CALL)
1121 #endif /* YYBTYACC */
1122 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1123 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1125 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1126 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1127 #endif /* defined(YYDESTRUCT_CALL) */
1137 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1138 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1139 #ifdef YYSTYPE_TOSTRING
1142 #endif /* YYBTYACC */
1147 for (i = yym; i > 0; i--)
1149 if (i != yym) fputs(", ", stderr);
1150 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1151 yystack.l_mark[1-i]), stderr);
1156 fputc('\n', stderr);
1160 yyval = yystack.l_mark[1-yym];
1162 memset(&yyval, 0, sizeof yyval);
1163 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1165 /* Perform position reduction */
1166 memset(&yyloc, 0, sizeof(yyloc));
1169 #endif /* YYBTYACC */
1171 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1172 /* just in case YYERROR is invoked within the action, save
1173 the start of the rhs as the error start position */
1174 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1186 { printf("%d\n",yystack.l_mark[0]);}
1190 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1194 { yyval = yystack.l_mark[-1]; }
1198 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1202 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1206 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1210 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1214 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1218 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1222 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1226 { yyval = - yystack.l_mark[0]; }
1230 { yyval = regs[yystack.l_mark[0]]; }
1234 { yyval = yystack.l_mark[0]; (*base) = (yystack.l_mark[0]==0) ? 8 : 10; }
1238 { yyval = (*base) * yystack.l_mark[-1] + yystack.l_mark[0]; }
1240 #line 1241 "calc3.tab.c"
1244 yystack.s_mark -= yym;
1245 yystate = *yystack.s_mark;
1246 yystack.l_mark -= yym;
1247 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1248 yystack.p_mark -= yym;
1251 if (yystate == 0 && yym == 0)
1256 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1257 #ifdef YYSTYPE_TOSTRING
1260 #endif /* YYBTYACC */
1261 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1263 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1267 *++yystack.s_mark = YYFINAL;
1268 *++yystack.l_mark = yyval;
1269 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1270 *++yystack.p_mark = yyloc;
1278 /* we're currently re-reading tokens */
1280 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1288 /* in trial mode; save scanner results for future parse attempts */
1289 if (yylvp == yylvlim)
1290 { /* Enlarge lexical value queue */
1291 size_t p = (size_t) (yylvp - yylvals);
1292 size_t s = (size_t) (yylvlim - yylvals);
1294 s += YYLVQUEUEGROWTH;
1295 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
1297 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1299 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1300 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1303 yylvp = yylve = yylvals + p;
1304 yylvlim = yylvals + s;
1305 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1306 yylpp = yylpe = yylpsns + p;
1307 yylplim = yylpsns + s;
1309 yylexp = yylexemes + p;
1311 *yylexp = (short) YYLEX;
1314 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1321 /* normal operation, no conflict encountered */
1322 #endif /* YYBTYACC */
1326 #endif /* YYBTYACC */
1327 if (yychar < 0) yychar = YYEOF;
1328 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
1332 yys = yyname[YYTRANSLATE(yychar)];
1333 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n",
1334 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1338 if (yychar == YYEOF) goto yyaccept;
1341 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1342 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1343 yystate = yytable[yyn];
1345 yystate = yydgoto[yym];
1349 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1350 #ifdef YYSTYPE_TOSTRING
1353 #endif /* YYBTYACC */
1354 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1356 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1359 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1360 *++yystack.s_mark = (short) yystate;
1361 *++yystack.l_mark = yyval;
1362 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1363 *++yystack.p_mark = yyloc;
1368 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1370 if (yypath) YYABORT;
1373 YYParseState *save = yyps->save;
1374 yyps->save = save->save;
1375 save->save = yypath;
1380 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1381 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1385 yyFreeState(yyerrctx);
1388 yylvp = yylvals + yypath->lexeme;
1389 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1390 yylpp = yylpsns + yypath->lexeme;
1392 yylexp = yylexemes + yypath->lexeme;
1394 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1395 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1396 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1397 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1398 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1399 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1400 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1402 yystate = yypath->state;
1404 #endif /* YYBTYACC */
1407 YYERROR_CALL("yacc stack overflow");
1411 YYERROR_CALL("memory exhausted");
1413 #endif /* YYBTYACC */
1423 if (yyps->save) goto yyvalid;
1424 #endif /* YYBTYACC */
1428 #if defined(YYDESTRUCT_CALL)
1429 if (yychar != YYEOF && yychar != YYEMPTY)
1430 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1431 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1433 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1434 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1438 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1441 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1442 YYDESTRUCT_CALL("cleanup: discarding state",
1443 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1445 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1446 YYDESTRUCT_CALL("cleanup: discarding state",
1447 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1448 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1450 #endif /* defined(YYDESTRUCT_CALL) */
1455 yyFreeState(yyerrctx);
1460 YYParseState *save = yyps;
1467 YYParseState *save = yypath;
1468 yypath = save->save;
1472 #endif /* YYBTYACC */
1473 yyfreestack(&yystack);