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"
30 extern int yylex(void);
31 static void yyerror(const char *s);
33 #line 34 "stdin1.calc.c"
35 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
36 /* Default: YYSTYPE is the semantic value type. */
38 # define YYSTYPE_IS_DECLARED 1
41 /* compatibility with bison */
43 /* compatibility with FreeBSD */
44 # ifdef YYPARSE_PARAM_TYPE
45 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
47 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
50 # define YYPARSE_DECL() yyparse(void)
53 /* Parameters sent to lex. */
55 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
56 # define YYLEX yylex(YYLEX_PARAM)
58 # define YYLEX_DECL() yylex(void)
59 # define YYLEX yylex()
62 #if !(defined(yylex) || defined(YYSTATE))
66 /* Parameters sent to yyerror. */
68 #define YYERROR_DECL() yyerror(const char *s)
71 #define YYERROR_CALL(msg) yyerror(msg)
74 extern int YYPARSE_DECL();
81 static const YYINT yylhs[] = { -1,
82 0, 0, 0, 1, 1, 2, 2, 2, 2, 2,
83 2, 2, 2, 2, 2, 2, 3, 3,
85 static const YYINT yylen[] = { 2,
86 0, 3, 3, 1, 3, 3, 3, 3, 3, 3,
87 3, 3, 3, 2, 1, 1, 1, 2,
89 static const YYINT yydefred[] = { 1,
90 0, 0, 17, 0, 0, 0, 0, 0, 0, 3,
91 0, 15, 14, 0, 2, 0, 0, 0, 0, 0,
92 0, 0, 18, 0, 6, 0, 0, 0, 0, 9,
95 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
96 static const YYINT yystos[] = { 0,
97 261, 256, 257, 258, 45, 40, 262, 263, 264, 10,
98 61, 258, 263, 263, 10, 124, 38, 43, 45, 42,
99 47, 37, 257, 263, 41, 263, 263, 263, 263, 263,
102 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
103 static const YYINT yydgoto[] = { 1,
106 static const YYINT yysindex[] = { 0,
107 -40, -7, 0, -55, -38, -38, 1, -29, -247, 0,
108 -38, 0, 0, 22, 0, -38, -38, -38, -38, -38,
109 -38, -38, 0, -29, 0, 51, 60, -20, -20, 0,
112 static const YYINT yyrindex[] = { 0,
113 0, 0, 0, 2, 0, 0, 0, 9, -9, 0,
114 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
115 0, 0, 0, 10, 0, -6, 14, 5, 13, 0,
119 static const YYINT yycindex[] = { 0,
120 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
121 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
122 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
126 static const YYINT yygindex[] = { 0,
129 #define YYTABLESIZE 220
130 static const YYINT yytable[] = { 6,
131 16, 6, 10, 13, 5, 11, 5, 22, 17, 23,
132 15, 15, 20, 18, 7, 19, 22, 21, 4, 5,
133 0, 20, 8, 12, 0, 0, 21, 16, 16, 0,
134 0, 16, 16, 16, 13, 16, 0, 16, 15, 15,
135 0, 0, 7, 15, 15, 7, 15, 7, 15, 7,
136 8, 12, 0, 8, 12, 8, 0, 8, 22, 17,
137 0, 0, 25, 20, 18, 0, 19, 0, 21, 13,
138 14, 0, 0, 0, 0, 24, 0, 0, 0, 0,
139 26, 27, 28, 29, 30, 31, 32, 22, 17, 0,
140 0, 0, 20, 18, 16, 19, 22, 21, 0, 0,
141 0, 20, 18, 0, 19, 0, 21, 0, 0, 0,
142 0, 0, 0, 0, 16, 0, 0, 13, 0, 0,
143 0, 0, 0, 0, 0, 15, 0, 0, 7, 0,
144 0, 0, 0, 0, 0, 0, 8, 12, 0, 0,
145 0, 0, 0, 0, 0, 16, 0, 0, 0, 0,
146 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
147 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
148 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
149 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
150 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
151 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
152 0, 0, 0, 0, 0, 2, 3, 4, 3, 12,
154 static const YYINT yycheck[] = { 40,
155 10, 40, 10, 10, 45, 61, 45, 37, 38, 257,
156 10, 10, 42, 43, 10, 45, 37, 47, 10, 10,
157 -1, 42, 10, 10, -1, -1, 47, 37, 38, -1,
158 -1, 41, 42, 43, 41, 45, -1, 47, 37, 38,
159 -1, -1, 38, 42, 43, 41, 45, 43, 47, 45,
160 38, 38, -1, 41, 41, 43, -1, 45, 37, 38,
161 -1, -1, 41, 42, 43, -1, 45, -1, 47, 5,
162 6, -1, -1, -1, -1, 11, -1, -1, -1, -1,
163 16, 17, 18, 19, 20, 21, 22, 37, 38, -1,
164 -1, -1, 42, 43, 124, 45, 37, 47, -1, -1,
165 -1, 42, 43, -1, 45, -1, 47, -1, -1, -1,
166 -1, -1, -1, -1, 124, -1, -1, 124, -1, -1,
167 -1, -1, -1, -1, -1, 124, -1, -1, 124, -1,
168 -1, -1, -1, -1, -1, -1, 124, 124, -1, -1,
169 -1, -1, -1, -1, -1, 124, -1, -1, -1, -1,
170 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
171 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
172 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
173 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
174 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
175 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
176 -1, -1, -1, -1, -1, 256, 257, 258, 257, 258,
179 static const YYINT yyctable[] = { -1,
180 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
181 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
182 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
183 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
184 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
185 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
186 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
187 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
188 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
189 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
190 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
191 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
192 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
193 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
194 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
195 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
196 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
197 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
198 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
199 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
200 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
201 -1, -1, -1, -1, -1, -1, -1, -1, -1,
208 #define YYMAXTOKEN 259
209 #define YYUNDFTOKEN 265
210 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
212 static const char *const yyname[] = {
214 "$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,
215 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
216 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
217 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0,
218 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
219 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
220 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
221 0,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number",
224 static const char *const yyrule[] = {
227 "list : list stat '\\n'",
228 "list : list error '\\n'",
230 "stat : LETTER '=' expr",
231 "expr : '(' expr ')'",
232 "expr : expr '+' expr",
233 "expr : expr '-' expr",
234 "expr : expr '*' expr",
235 "expr : expr '/' expr",
236 "expr : expr '%' expr",
237 "expr : expr '&' expr",
238 "expr : expr '|' expr",
243 "number : number DIGIT",
258 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
259 YYLTYPE yyloc; /* position returned by actions */
260 YYLTYPE yylloc; /* position from the lexer */
263 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
264 #ifndef YYLLOC_DEFAULT
265 #define YYLLOC_DEFAULT(loc, rhs, n) \
270 (loc).first_line = YYRHSLOC(rhs, 0).last_line; \
271 (loc).first_column = YYRHSLOC(rhs, 0).last_column; \
272 (loc).last_line = YYRHSLOC(rhs, 0).last_line; \
273 (loc).last_column = YYRHSLOC(rhs, 0).last_column; \
277 (loc).first_line = YYRHSLOC(rhs, 1).first_line; \
278 (loc).first_column = YYRHSLOC(rhs, 1).first_column; \
279 (loc).last_line = YYRHSLOC(rhs, n).last_line; \
280 (loc).last_column = YYRHSLOC(rhs, n).last_column; \
283 #endif /* YYLLOC_DEFAULT */
284 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
287 #ifndef YYLVQUEUEGROWTH
288 #define YYLVQUEUEGROWTH 32
290 #endif /* YYBTYACC */
292 /* define the initial stack-sizes */
295 #define YYMAXDEPTH YYSTACKSIZE
298 #define YYSTACKSIZE YYMAXDEPTH
300 #define YYSTACKSIZE 10000
301 #define YYMAXDEPTH 10000
305 #ifndef YYINITSTACKSIZE
306 #define YYINITSTACKSIZE 200
316 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
323 struct YYParseState_s
325 struct YYParseState_s *save; /* Previously saved parser state */
326 YYSTACKDATA yystack; /* saved parser stack */
327 int state; /* saved parser state */
328 int errflag; /* saved error recovery status */
329 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
330 YYINT ctry; /* saved index in yyctable[] for this conflict */
332 typedef struct YYParseState_s YYParseState;
333 #endif /* YYBTYACC */
334 /* variables for the parser stack */
335 static YYSTACKDATA yystack;
338 /* Current parser state */
339 static YYParseState *yyps = 0;
341 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
342 static YYParseState *yypath = 0;
344 /* Base of the lexical value queue */
345 static YYSTYPE *yylvals = 0;
347 /* Current position at lexical value queue */
348 static YYSTYPE *yylvp = 0;
350 /* End position of lexical value queue */
351 static YYSTYPE *yylve = 0;
353 /* The last allocated position at the lexical value queue */
354 static YYSTYPE *yylvlim = 0;
356 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
357 /* Base of the lexical position queue */
358 static YYLTYPE *yylpsns = 0;
360 /* Current position at lexical position queue */
361 static YYLTYPE *yylpp = 0;
363 /* End position of lexical position queue */
364 static YYLTYPE *yylpe = 0;
366 /* The last allocated position at the lexical position queue */
367 static YYLTYPE *yylplim = 0;
370 /* Current position at lexical token queue */
371 static YYINT *yylexp = 0;
373 static YYINT *yylexemes = 0;
374 #endif /* YYBTYACC */
376 /* start of programs */
381 while(!feof(stdin)) {
388 yyerror(const char *s)
390 fprintf(stderr, "%s\n", s);
396 /* lexical analysis routine */
397 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
398 /* return DIGIT for a digit, yylval = 0 through 9 */
399 /* all other characters are returned immediately */
403 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
405 /* c is now nonblank */
417 #line 418 "stdin1.calc.c"
419 /* For use in generated program */
420 #define yydepth (int)(yystack.s_mark - yystack.s_base)
422 #define yytrial (yyps->save)
423 #endif /* YYBTYACC */
426 #include <stdio.h> /* needed for printf */
429 #include <stdlib.h> /* needed for malloc, etc */
430 #include <string.h> /* needed for memset */
432 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
433 static int yygrowstack(YYSTACKDATA *data)
439 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
443 if ((newsize = data->stacksize) == 0)
444 newsize = YYINITSTACKSIZE;
445 else if (newsize >= YYMAXDEPTH)
447 else if ((newsize *= 2) > YYMAXDEPTH)
448 newsize = YYMAXDEPTH;
450 i = (int) (data->s_mark - data->s_base);
451 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
455 data->s_base = newss;
456 data->s_mark = newss + i;
458 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
462 data->l_base = newvs;
463 data->l_mark = newvs + i;
465 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
466 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
470 data->p_base = newps;
471 data->p_mark = newps + i;
474 data->stacksize = newsize;
475 data->s_last = data->s_base + newsize - 1;
479 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
484 #if YYPURE || defined(YY_NO_LEAKS)
485 static void yyfreestack(YYSTACKDATA *data)
489 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
492 memset(data, 0, sizeof(*data));
495 #define yyfreestack(data) /* nothing */
496 #endif /* YYPURE || defined(YY_NO_LEAKS) */
499 static YYParseState *
500 yyNewState(unsigned size)
502 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
503 if (p == NULL) return NULL;
505 p->yystack.stacksize = size;
508 p->yystack.s_base = NULL;
509 p->yystack.l_base = NULL;
510 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
511 p->yystack.p_base = NULL;
515 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
516 if (p->yystack.s_base == NULL) return NULL;
517 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
518 if (p->yystack.l_base == NULL) return NULL;
519 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
520 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
521 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
522 if (p->yystack.p_base == NULL) return NULL;
523 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
530 yyFreeState(YYParseState *p)
532 yyfreestack(&p->yystack);
535 #endif /* YYBTYACC */
537 #define YYABORT goto yyabort
538 #define YYREJECT goto yyabort
539 #define YYACCEPT goto yyaccept
540 #define YYERROR goto yyerrlab
542 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
543 #define YYVALID_NESTED do { if (yyps->save && \
544 yyps->save->save == 0) goto yyvalid; } while(0)
545 #endif /* YYBTYACC */
550 int yym, yyn, yystate, yyresult;
553 YYParseState *yyerrctx = NULL;
554 #endif /* YYBTYACC */
555 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
556 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */
561 if ((yys = getenv("YYDEBUG")) != 0)
564 if (yyn >= '0' && yyn <= '9')
568 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
570 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
571 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
575 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
577 #endif /* YYBTYACC */
586 memset(&yystack, 0, sizeof(yystack));
589 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
590 yystack.s_mark = yystack.s_base;
591 yystack.l_mark = yystack.l_base;
592 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
593 yystack.p_mark = yystack.p_base;
599 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
606 /* we're currently re-reading tokens */
608 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
616 /* in trial mode; save scanner results for future parse attempts */
617 if (yylvp == yylvlim)
618 { /* Enlarge lexical value queue */
619 size_t p = (size_t) (yylvp - yylvals);
620 size_t s = (size_t) (yylvlim - yylvals);
622 s += YYLVQUEUEGROWTH;
623 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
624 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
625 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
626 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
628 yylvp = yylve = yylvals + p;
629 yylvlim = yylvals + s;
630 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
631 yylpp = yylpe = yylpsns + p;
632 yylplim = yylpsns + s;
634 yylexp = yylexemes + p;
636 *yylexp = (YYINT) YYLEX;
639 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
646 /* normal operation, no conflict encountered */
647 #endif /* YYBTYACC */
651 #endif /* YYBTYACC */
652 if (yychar < 0) yychar = YYEOF;
656 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
657 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
658 YYDEBUGSTR, yydepth, yystate, yychar, yys);
659 #ifdef YYSTYPE_TOSTRING
662 #endif /* YYBTYACC */
663 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
671 /* Do we have a conflict? */
672 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
673 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
682 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
683 YYDEBUGSTR, yydepth, yystate);
685 /* Switch to the next conflict context */
690 if (save->state != yystate) YYABORT;
697 /* Unresolved conflict - start/continue trial parse */
702 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
704 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
706 fputs("Starting trial parse.\n", stderr);
709 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
710 if (save == NULL) goto yyenomem;
711 save->save = yyps->save;
712 save->state = yystate;
713 save->errflag = yyerrflag;
714 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
715 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
716 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
717 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
718 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
719 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
720 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
723 if (yyctable[ctry] == -1)
726 if (yydebug && yychar >= YYEOF)
727 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
732 if (yyps->save == NULL)
734 /* If this is a first conflict in the stack, start saving lexemes */
737 yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
738 if (yylexemes == NULL) goto yyenomem;
739 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
740 if (yylvals == NULL) goto yyenomem;
741 yylvlim = yylvals + YYLVQUEUEGROWTH;
742 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
743 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
744 if (yylpsns == NULL) goto yyenomem;
745 yylplim = yylpsns + YYLVQUEUEGROWTH;
750 yylvp = yylve = yylvals;
751 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
752 yylpp = yylpe = yylpsns;
758 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
761 *yylexp = (YYINT) yychar;
769 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
775 save->lexeme = (int) (yylvp - yylvals);
778 if (yytable[yyn] == ctry)
782 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
783 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
788 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
793 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
795 yystate = yyctable[ctry];
796 *++yystack.s_mark = (YYINT) yystate;
797 *++yystack.l_mark = yylval;
798 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
799 *++yystack.p_mark = yylloc;
802 if (yyerrflag > 0) --yyerrflag;
807 yyn = yyctable[ctry];
810 } /* End of code dealing with conflicts */
811 #endif /* YYBTYACC */
812 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
813 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
817 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
818 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
820 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
821 yystate = yytable[yyn];
822 *++yystack.s_mark = yytable[yyn];
823 *++yystack.l_mark = yylval;
824 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
825 *++yystack.p_mark = yylloc;
828 if (yyerrflag > 0) --yyerrflag;
831 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
832 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
837 if (yyerrflag != 0) goto yyinrecovery;
842 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
845 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
846 * before looking for error recovery */
847 yystack.s_mark -= yym;
848 yystate = *yystack.s_mark;
849 yystack.l_mark -= yym;
850 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
851 yystack.p_mark -= yym;
859 YYParseState *save = yyps->save;
862 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
863 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
864 (int)(yylvp - yylvals - yyps->save->lexeme));
866 /* Memorize most forward-looking error state in case it's really an error. */
867 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
869 /* Free old saved error context state */
870 if (yyerrctx) yyFreeState(yyerrctx);
871 /* Create and fill out new saved error context state */
872 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
873 if (yyerrctx == NULL) goto yyenomem;
874 yyerrctx->save = yyps->save;
875 yyerrctx->state = yystate;
876 yyerrctx->errflag = yyerrflag;
877 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
878 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
879 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
880 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
881 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
882 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
883 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
885 yyerrctx->lexeme = (int) (yylvp - yylvals);
887 yylvp = yylvals + save->lexeme;
888 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
889 yylpp = yylpsns + save->lexeme;
891 yylexp = yylexemes + save->lexeme;
893 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
894 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
895 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
896 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
897 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
898 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
899 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
902 yystate = save->state;
903 /* We tried shift, try reduce now */
904 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
905 yyps->save = save->save;
909 /* Nothing left on the stack -- error */
914 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
917 /* Restore state as it was in the most forward-advanced error */
918 yylvp = yylvals + yyerrctx->lexeme;
919 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
920 yylpp = yylpsns + yyerrctx->lexeme;
922 yylexp = yylexemes + yyerrctx->lexeme;
925 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
928 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
929 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
930 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
931 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
932 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
933 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
934 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
936 yystate = yyerrctx->state;
937 yyFreeState(yyerrctx);
942 if (yynewerrflag == 0) goto yyinrecovery;
943 #endif /* YYBTYACC */
945 YYERROR_CALL("syntax error");
946 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
947 yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */
951 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
962 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
963 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
967 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
968 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
970 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
971 yystate = yytable[yyn];
972 *++yystack.s_mark = yytable[yyn];
973 *++yystack.l_mark = yylval;
974 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
975 /* lookahead position is error end position */
976 yyerror_loc_range[2] = yylloc;
977 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
978 *++yystack.p_mark = yyloc;
986 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
987 YYDEBUGSTR, yydepth, *yystack.s_mark);
989 if (yystack.s_mark <= yystack.s_base) goto yyabort;
990 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
991 /* the current TOS position is the error start position */
992 yyerror_loc_range[1] = *yystack.p_mark;
994 #if defined(YYDESTRUCT_CALL)
997 #endif /* YYBTYACC */
998 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
999 YYDESTRUCT_CALL("error: discarding state",
1000 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1002 YYDESTRUCT_CALL("error: discarding state",
1003 yystos[*yystack.s_mark], yystack.l_mark);
1004 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1005 #endif /* defined(YYDESTRUCT_CALL) */
1008 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1016 if (yychar == YYEOF) goto yyabort;
1020 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1021 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1022 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1025 #if defined(YYDESTRUCT_CALL)
1028 #endif /* YYBTYACC */
1029 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1030 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1032 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1033 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1034 #endif /* defined(YYDESTRUCT_CALL) */
1044 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1045 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1046 #ifdef YYSTYPE_TOSTRING
1049 #endif /* YYBTYACC */
1054 for (i = yym; i > 0; i--)
1056 if (i != yym) fputs(", ", stderr);
1057 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1058 yystack.l_mark[1-i]), stderr);
1063 fputc('\n', stderr);
1067 yyval = yystack.l_mark[1-yym];
1069 memset(&yyval, 0, sizeof yyval);
1070 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1072 /* Perform position reduction */
1073 memset(&yyloc, 0, sizeof(yyloc));
1076 #endif /* YYBTYACC */
1078 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);
1079 /* just in case YYERROR is invoked within the action, save
1080 the start of the rhs as the error start position */
1081 yyerror_loc_range[1] = yystack.p_mark[1-yym];
1093 { printf("%d\n",yystack.l_mark[0]);}
1097 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1101 { yyval = yystack.l_mark[-1]; }
1105 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1109 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1113 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1117 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1121 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1125 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1129 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1133 { yyval = - yystack.l_mark[0]; }
1137 { yyval = regs[yystack.l_mark[0]]; }
1141 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1145 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1147 #line 1148 "stdin1.calc.c"
1151 yystack.s_mark -= yym;
1152 yystate = *yystack.s_mark;
1153 yystack.l_mark -= yym;
1154 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1155 yystack.p_mark -= yym;
1158 if (yystate == 0 && yym == 0)
1163 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1164 #ifdef YYSTYPE_TOSTRING
1167 #endif /* YYBTYACC */
1168 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1170 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1174 *++yystack.s_mark = YYFINAL;
1175 *++yystack.l_mark = yyval;
1176 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1177 *++yystack.p_mark = yyloc;
1185 /* we're currently re-reading tokens */
1187 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1195 /* in trial mode; save scanner results for future parse attempts */
1196 if (yylvp == yylvlim)
1197 { /* Enlarge lexical value queue */
1198 size_t p = (size_t) (yylvp - yylvals);
1199 size_t s = (size_t) (yylvlim - yylvals);
1201 s += YYLVQUEUEGROWTH;
1202 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1204 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1206 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1207 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1210 yylvp = yylve = yylvals + p;
1211 yylvlim = yylvals + s;
1212 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1213 yylpp = yylpe = yylpsns + p;
1214 yylplim = yylpsns + s;
1216 yylexp = yylexemes + p;
1218 *yylexp = (YYINT) YYLEX;
1221 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1228 /* normal operation, no conflict encountered */
1229 #endif /* YYBTYACC */
1233 #endif /* YYBTYACC */
1234 if (yychar < 0) yychar = YYEOF;
1238 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1239 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1240 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1244 if (yychar == YYEOF) goto yyaccept;
1247 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1248 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1249 yystate = yytable[yyn];
1251 yystate = yydgoto[yym];
1255 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1256 #ifdef YYSTYPE_TOSTRING
1259 #endif /* YYBTYACC */
1260 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1262 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1265 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1266 *++yystack.s_mark = (YYINT) yystate;
1267 *++yystack.l_mark = yyval;
1268 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1269 *++yystack.p_mark = yyloc;
1274 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1276 if (yypath) YYABORT;
1279 YYParseState *save = yyps->save;
1280 yyps->save = save->save;
1281 save->save = yypath;
1286 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1287 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1291 yyFreeState(yyerrctx);
1294 yylvp = yylvals + yypath->lexeme;
1295 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1296 yylpp = yylpsns + yypath->lexeme;
1298 yylexp = yylexemes + yypath->lexeme;
1300 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1301 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1302 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1303 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1304 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1305 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1306 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1308 yystate = yypath->state;
1310 #endif /* YYBTYACC */
1313 YYERROR_CALL("yacc stack overflow");
1317 YYERROR_CALL("memory exhausted");
1319 #endif /* YYBTYACC */
1329 if (yyps->save) goto yyvalid;
1330 #endif /* YYBTYACC */
1334 #if defined(YYDESTRUCT_CALL)
1335 if (yychar != YYEOF && yychar != YYEMPTY)
1336 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1337 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1339 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1340 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1344 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1347 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1348 YYDESTRUCT_CALL("cleanup: discarding state",
1349 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1351 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1352 YYDESTRUCT_CALL("cleanup: discarding state",
1353 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1354 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1356 #endif /* defined(YYDESTRUCT_CALL) */
1361 yyFreeState(yyerrctx);
1366 YYParseState *save = yyps;
1373 YYParseState *save = yypath;
1374 yypath = save->save;
1378 #endif /* YYBTYACC */
1379 yyfreestack(&yystack);