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_"
120 #line 2 "pure_calc.y"
129 #define YYLEX_PARAM &yylval
130 #define YYLEX_DECL() yylex(YYSTYPE *yylval)
131 #define YYERROR_DECL() yyerror(const char *s)
133 static void YYERROR_DECL();
136 #line 137 "pure_calc.tab.c"
138 #if ! defined(YYSTYPE) && ! defined(YYSTYPE_IS_DECLARED)
139 /* Default: YYSTYPE is the semantic value type. */
141 # define YYSTYPE_IS_DECLARED 1
144 /* compatibility with bison */
146 /* compatibility with FreeBSD */
147 # ifdef YYPARSE_PARAM_TYPE
148 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
150 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
153 # define YYPARSE_DECL() yyparse(void)
156 /* Parameters sent to lex. */
158 # ifdef YYLEX_PARAM_TYPE
159 # define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
161 # define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
163 # define YYLEX yylex(&yylval, YYLEX_PARAM)
165 # define YYLEX_DECL() yylex(YYSTYPE *yylval)
166 # define YYLEX yylex(&yylval)
169 /* Parameters sent to yyerror. */
171 #define YYERROR_DECL() yyerror(const char *s)
174 #define YYERROR_CALL(msg) yyerror(msg)
177 extern int YYPARSE_DECL();
182 #define YYERRCODE 256
184 static const YYINT calc_lhs[] = { -1,
185 0, 0, 0, 1, 1, 2, 2, 2, 2, 2,
186 2, 2, 2, 2, 2, 2, 3, 3,
188 static const YYINT calc_len[] = { 2,
189 0, 3, 3, 1, 3, 3, 3, 3, 3, 3,
190 3, 3, 3, 2, 1, 1, 1, 2,
192 static const YYINT calc_defred[] = { 1,
193 0, 0, 17, 0, 0, 0, 0, 0, 0, 3,
194 0, 15, 14, 0, 2, 0, 0, 0, 0, 0,
195 0, 0, 18, 0, 6, 0, 0, 0, 0, 9,
198 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
199 static const YYINT calc_stos[] = { 0,
200 261, 256, 257, 258, 45, 40, 262, 263, 264, 10,
201 61, 258, 263, 263, 10, 124, 38, 43, 45, 42,
202 47, 37, 257, 263, 41, 263, 263, 263, 263, 263,
205 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
206 static const YYINT calc_dgoto[] = { 1,
209 static const YYINT calc_sindex[] = { 0,
210 -40, -7, 0, -55, -38, -38, 1, -29, -247, 0,
211 -38, 0, 0, 22, 0, -38, -38, -38, -38, -38,
212 -38, -38, 0, -29, 0, 51, 60, -20, -20, 0,
215 static const YYINT calc_rindex[] = { 0,
216 0, 0, 0, 2, 0, 0, 0, 9, -9, 0,
217 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
218 0, 0, 0, 10, 0, -6, 14, 5, 13, 0,
222 static const YYINT calc_cindex[] = { 0,
223 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
224 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
225 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
229 static const YYINT calc_gindex[] = { 0,
232 #define YYTABLESIZE 220
233 static const YYINT calc_table[] = { 6,
234 16, 6, 10, 13, 5, 11, 5, 22, 17, 23,
235 15, 15, 20, 18, 7, 19, 22, 21, 4, 5,
236 0, 20, 8, 12, 0, 0, 21, 16, 16, 0,
237 0, 16, 16, 16, 13, 16, 0, 16, 15, 15,
238 0, 0, 7, 15, 15, 7, 15, 7, 15, 7,
239 8, 12, 0, 8, 12, 8, 0, 8, 22, 17,
240 0, 0, 25, 20, 18, 0, 19, 0, 21, 13,
241 14, 0, 0, 0, 0, 24, 0, 0, 0, 0,
242 26, 27, 28, 29, 30, 31, 32, 22, 17, 0,
243 0, 0, 20, 18, 16, 19, 22, 21, 0, 0,
244 0, 20, 18, 0, 19, 0, 21, 0, 0, 0,
245 0, 0, 0, 0, 16, 0, 0, 13, 0, 0,
246 0, 0, 0, 0, 0, 15, 0, 0, 7, 0,
247 0, 0, 0, 0, 0, 0, 8, 12, 0, 0,
248 0, 0, 0, 0, 0, 16, 0, 0, 0, 0,
249 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
250 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
251 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
253 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
254 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
255 0, 0, 0, 0, 0, 2, 3, 4, 3, 12,
257 static const YYINT calc_check[] = { 40,
258 10, 40, 10, 10, 45, 61, 45, 37, 38, 257,
259 10, 10, 42, 43, 10, 45, 37, 47, 10, 10,
260 -1, 42, 10, 10, -1, -1, 47, 37, 38, -1,
261 -1, 41, 42, 43, 41, 45, -1, 47, 37, 38,
262 -1, -1, 38, 42, 43, 41, 45, 43, 47, 45,
263 38, 38, -1, 41, 41, 43, -1, 45, 37, 38,
264 -1, -1, 41, 42, 43, -1, 45, -1, 47, 5,
265 6, -1, -1, -1, -1, 11, -1, -1, -1, -1,
266 16, 17, 18, 19, 20, 21, 22, 37, 38, -1,
267 -1, -1, 42, 43, 124, 45, 37, 47, -1, -1,
268 -1, 42, 43, -1, 45, -1, 47, -1, -1, -1,
269 -1, -1, -1, -1, 124, -1, -1, 124, -1, -1,
270 -1, -1, -1, -1, -1, 124, -1, -1, 124, -1,
271 -1, -1, -1, -1, -1, -1, 124, 124, -1, -1,
272 -1, -1, -1, -1, -1, 124, -1, -1, -1, -1,
273 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
274 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
275 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
276 -1, -1, -1, -1, -1, -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, 256, 257, 258, 257, 258,
282 static const YYINT calc_ctable[] = { -1,
283 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
284 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
285 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
286 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
287 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
288 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
289 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
290 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
291 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
292 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
293 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
294 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
295 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
296 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
297 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
298 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
299 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
300 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
301 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
302 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
303 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
304 -1, -1, -1, -1, -1, -1, -1, -1, -1,
311 #define YYMAXTOKEN 259
312 #define YYUNDFTOKEN 265
313 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
315 static const char *const calc_name[] = {
317 "$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,
318 0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'",0,"'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,
319 0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
320 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"'|'",0,0,0,0,0,0,0,0,0,
321 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
322 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
323 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
324 0,0,"error","DIGIT","LETTER","UMINUS","$accept","list","stat","expr","number",
327 static const char *const calc_rule[] = {
330 "list : list stat '\\n'",
331 "list : list error '\\n'",
333 "stat : LETTER '=' expr",
334 "expr : '(' expr ')'",
335 "expr : expr '+' expr",
336 "expr : expr '-' expr",
337 "expr : expr '*' expr",
338 "expr : expr '/' expr",
339 "expr : expr '%' expr",
340 "expr : expr '&' expr",
341 "expr : expr '|' expr",
346 "number : number DIGIT",
354 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
355 #ifndef YYLLOC_DEFAULT
356 #define YYLLOC_DEFAULT(loc, rhs, n) \
361 (loc).first_line = ((rhs)[-1]).last_line; \
362 (loc).first_column = ((rhs)[-1]).last_column; \
363 (loc).last_line = ((rhs)[-1]).last_line; \
364 (loc).last_column = ((rhs)[-1]).last_column; \
368 (loc).first_line = ((rhs)[ 0 ]).first_line; \
369 (loc).first_column = ((rhs)[ 0 ]).first_column; \
370 (loc).last_line = ((rhs)[n-1]).last_line; \
371 (loc).last_column = ((rhs)[n-1]).last_column; \
374 #endif /* YYLLOC_DEFAULT */
375 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
378 #ifndef YYLVQUEUEGROWTH
379 #define YYLVQUEUEGROWTH 32
381 #endif /* YYBTYACC */
383 /* define the initial stack-sizes */
386 #define YYMAXDEPTH YYSTACKSIZE
389 #define YYSTACKSIZE YYMAXDEPTH
391 #define YYSTACKSIZE 10000
392 #define YYMAXDEPTH 10000
396 #ifndef YYINITSTACKSIZE
397 #define YYINITSTACKSIZE 200
407 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
414 struct YYParseState_s
416 struct YYParseState_s *save; /* Previously saved parser state */
417 YYSTACKDATA yystack; /* saved parser stack */
418 int state; /* saved parser state */
419 int errflag; /* saved error recovery status */
420 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
421 YYINT ctry; /* saved index in yyctable[] for this conflict */
423 typedef struct YYParseState_s YYParseState;
424 #endif /* YYBTYACC */
425 #line 72 "pure_calc.y"
426 /* start of programs */
429 static int YYLEX_DECL();
435 while(!feof(stdin)) {
444 fprintf(stderr, "%s\n", s);
450 /* lexical analysis routine */
451 /* returns LETTER for a lower case letter, yylval = 0 through 25 */
452 /* return DIGIT for a digit, yylval = 0 through 9 */
453 /* all other characters are returned immediately */
457 while( (c=getchar()) == ' ' ) { /* skip blanks */ }
459 /* c is now nonblank */
471 #line 472 "pure_calc.tab.c"
473 /* For use in generated program */
474 #define yydepth (int)(yystack.s_mark - yystack.s_base)
476 #define yytrial (yyps->save)
477 #endif /* YYBTYACC */
480 #include <stdio.h> /* needed for printf */
483 #include <stdlib.h> /* needed for malloc, etc */
484 #include <string.h> /* needed for memset */
486 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
487 static int yygrowstack(YYSTACKDATA *data)
493 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
497 if ((newsize = data->stacksize) == 0)
498 newsize = YYINITSTACKSIZE;
499 else if (newsize >= YYMAXDEPTH)
501 else if ((newsize *= 2) > YYMAXDEPTH)
502 newsize = YYMAXDEPTH;
504 i = (int) (data->s_mark - data->s_base);
505 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
509 data->s_base = newss;
510 data->s_mark = newss + i;
512 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
516 data->l_base = newvs;
517 data->l_mark = newvs + i;
519 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
520 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
524 data->p_base = newps;
525 data->p_mark = newps + i;
528 data->stacksize = newsize;
529 data->s_last = data->s_base + newsize - 1;
533 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
538 #if YYPURE || defined(YY_NO_LEAKS)
539 static void yyfreestack(YYSTACKDATA *data)
543 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
546 memset(data, 0, sizeof(*data));
549 #define yyfreestack(data) /* nothing */
550 #endif /* YYPURE || defined(YY_NO_LEAKS) */
553 static YYParseState *
554 yyNewState(unsigned size)
556 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
557 if (p == NULL) return NULL;
559 p->yystack.stacksize = size;
562 p->yystack.s_base = NULL;
563 p->yystack.l_base = NULL;
564 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
565 p->yystack.p_base = NULL;
569 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
570 if (p->yystack.s_base == NULL) return NULL;
571 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
572 if (p->yystack.l_base == NULL) return NULL;
573 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
574 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
575 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
576 if (p->yystack.p_base == NULL) return NULL;
577 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
584 yyFreeState(YYParseState *p)
586 yyfreestack(&p->yystack);
589 #endif /* YYBTYACC */
591 #define YYABORT goto yyabort
592 #define YYREJECT goto yyabort
593 #define YYACCEPT goto yyaccept
594 #define YYERROR goto yyerrlab
596 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
597 #define YYVALID_NESTED do { if (yyps->save && \
598 yyps->save->save == 0) goto yyvalid; } while(0)
599 #endif /* YYBTYACC */
608 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
609 YYLTYPE yyloc; /* position returned by actions */
610 YYLTYPE yylloc; /* position from the lexer */
613 /* variables for the parser stack */
617 /* Current parser state */
618 static YYParseState *yyps = 0;
620 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
621 static YYParseState *yypath = 0;
623 /* Base of the lexical value queue */
624 static YYSTYPE *yylvals = 0;
626 /* Current position at lexical value queue */
627 static YYSTYPE *yylvp = 0;
629 /* End position of lexical value queue */
630 static YYSTYPE *yylve = 0;
632 /* The last allocated position at the lexical value queue */
633 static YYSTYPE *yylvlim = 0;
635 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
636 /* Base of the lexical position queue */
637 static YYLTYPE *yylpsns = 0;
639 /* Current position at lexical position queue */
640 static YYLTYPE *yylpp = 0;
642 /* End position of lexical position queue */
643 static YYLTYPE *yylpe = 0;
645 /* The last allocated position at the lexical position queue */
646 static YYLTYPE *yylplim = 0;
649 /* Current position at lexical token queue */
650 static YYINT *yylexp = 0;
652 static YYINT *yylexemes = 0;
653 #endif /* YYBTYACC */
654 int yym, yyn, yystate, yyresult;
657 YYParseState *yyerrctx = NULL;
658 #endif /* YYBTYACC */
659 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
660 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
665 if ((yys = getenv("YYDEBUG")) != 0)
668 if (yyn >= '0' && yyn <= '9')
672 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
674 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
675 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
680 memset(&yyval, 0, sizeof(yyval));
681 memset(&yylval, 0, sizeof(yylval));
682 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
683 memset(&yyloc, 0, sizeof(yyloc));
684 memset(&yylloc, 0, sizeof(yylloc));
688 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
690 #endif /* YYBTYACC */
699 memset(&yystack, 0, sizeof(yystack));
702 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
703 yystack.s_mark = yystack.s_base;
704 yystack.l_mark = yystack.l_base;
705 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
706 yystack.p_mark = yystack.p_base;
712 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
719 /* we're currently re-reading tokens */
721 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
729 /* in trial mode; save scanner results for future parse attempts */
730 if (yylvp == yylvlim)
731 { /* Enlarge lexical value queue */
732 size_t p = (size_t) (yylvp - yylvals);
733 size_t s = (size_t) (yylvlim - yylvals);
735 s += YYLVQUEUEGROWTH;
736 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
737 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
738 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
739 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
741 yylvp = yylve = yylvals + p;
742 yylvlim = yylvals + s;
743 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
744 yylpp = yylpe = yylpsns + p;
745 yylplim = yylpsns + s;
747 yylexp = yylexemes + p;
749 *yylexp = (YYINT) YYLEX;
752 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
759 /* normal operation, no conflict encountered */
760 #endif /* YYBTYACC */
764 #endif /* YYBTYACC */
765 if (yychar < 0) yychar = YYEOF;
769 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
770 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
771 YYDEBUGSTR, yydepth, yystate, yychar, yys);
772 #ifdef YYSTYPE_TOSTRING
775 #endif /* YYBTYACC */
776 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
784 /* Do we have a conflict? */
785 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
786 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
795 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
796 YYDEBUGSTR, yydepth, yystate);
798 /* Switch to the next conflict context */
803 if (save->state != yystate) YYABORT;
810 /* Unresolved conflict - start/continue trial parse */
815 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
817 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
819 fputs("Starting trial parse.\n", stderr);
822 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
823 if (save == NULL) goto yyenomem;
824 save->save = yyps->save;
825 save->state = yystate;
826 save->errflag = yyerrflag;
827 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
828 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
829 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
830 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
831 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
832 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
833 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
836 if (yyctable[ctry] == -1)
839 if (yydebug && yychar >= YYEOF)
840 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
845 if (yyps->save == NULL)
847 /* If this is a first conflict in the stack, start saving lexemes */
850 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
851 if (yylexemes == NULL) goto yyenomem;
852 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
853 if (yylvals == NULL) goto yyenomem;
854 yylvlim = yylvals + YYLVQUEUEGROWTH;
855 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
856 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
857 if (yylpsns == NULL) goto yyenomem;
858 yylplim = yylpsns + YYLVQUEUEGROWTH;
863 yylvp = yylve = yylvals;
864 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
865 yylpp = yylpe = yylpsns;
871 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
874 *yylexp = (YYINT) yychar;
882 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
888 save->lexeme = (int) (yylvp - yylvals);
891 if (yytable[yyn] == ctry)
895 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
896 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
901 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
906 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
908 yystate = yyctable[ctry];
909 *++yystack.s_mark = (YYINT) yystate;
910 *++yystack.l_mark = yylval;
911 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
912 *++yystack.p_mark = yylloc;
915 if (yyerrflag > 0) --yyerrflag;
920 yyn = yyctable[ctry];
923 } /* End of code dealing with conflicts */
924 #endif /* YYBTYACC */
925 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
926 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
930 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
931 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
933 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
934 yystate = yytable[yyn];
935 *++yystack.s_mark = yytable[yyn];
936 *++yystack.l_mark = yylval;
937 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
938 *++yystack.p_mark = yylloc;
941 if (yyerrflag > 0) --yyerrflag;
944 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
945 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
950 if (yyerrflag != 0) goto yyinrecovery;
955 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
958 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
959 * before looking for error recovery */
960 yystack.s_mark -= yym;
961 yystate = *yystack.s_mark;
962 yystack.l_mark -= yym;
963 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
964 yystack.p_mark -= yym;
972 YYParseState *save = yyps->save;
975 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
976 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
977 (int)(yylvp - yylvals - yyps->save->lexeme));
979 /* Memorize most forward-looking error state in case it's really an error. */
980 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
982 /* Free old saved error context state */
983 if (yyerrctx) yyFreeState(yyerrctx);
984 /* Create and fill out new saved error context state */
985 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
986 if (yyerrctx == NULL) goto yyenomem;
987 yyerrctx->save = yyps->save;
988 yyerrctx->state = yystate;
989 yyerrctx->errflag = yyerrflag;
990 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
991 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
992 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
993 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
994 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
995 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
996 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
998 yyerrctx->lexeme = (int) (yylvp - yylvals);
1000 yylvp = yylvals + save->lexeme;
1001 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1002 yylpp = yylpsns + save->lexeme;
1004 yylexp = yylexemes + save->lexeme;
1006 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1007 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1008 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1009 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1010 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1011 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1012 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1014 ctry = ++save->ctry;
1015 yystate = save->state;
1016 /* We tried shift, try reduce now */
1017 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1018 yyps->save = save->save;
1022 /* Nothing left on the stack -- error */
1027 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1030 /* Restore state as it was in the most forward-advanced error */
1031 yylvp = yylvals + yyerrctx->lexeme;
1032 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1033 yylpp = yylpsns + yyerrctx->lexeme;
1035 yylexp = yylexemes + yyerrctx->lexeme;
1036 yychar = yylexp[-1];
1038 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1041 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1042 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1043 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1044 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1045 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1046 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1047 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1049 yystate = yyerrctx->state;
1050 yyFreeState(yyerrctx);
1055 if (yynewerrflag == 0) goto yyinrecovery;
1056 #endif /* YYBTYACC */
1058 YYERROR_CALL("syntax error");
1059 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1060 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1064 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1075 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1076 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1080 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1081 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1083 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1084 yystate = yytable[yyn];
1085 *++yystack.s_mark = yytable[yyn];
1086 *++yystack.l_mark = yylval;
1087 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1088 /* lookahead position is error end position */
1089 yyerror_loc_range[1] = yylloc;
1090 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1091 *++yystack.p_mark = yyloc;
1099 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1100 YYDEBUGSTR, yydepth, *yystack.s_mark);
1102 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1103 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1104 /* the current TOS position is the error start position */
1105 yyerror_loc_range[0] = *yystack.p_mark;
1107 #if defined(YYDESTRUCT_CALL)
1110 #endif /* YYBTYACC */
1111 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1112 YYDESTRUCT_CALL("error: discarding state",
1113 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1115 YYDESTRUCT_CALL("error: discarding state",
1116 yystos[*yystack.s_mark], yystack.l_mark);
1117 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1118 #endif /* defined(YYDESTRUCT_CALL) */
1121 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1129 if (yychar == YYEOF) goto yyabort;
1133 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1134 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1135 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1138 #if defined(YYDESTRUCT_CALL)
1141 #endif /* YYBTYACC */
1142 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1143 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1145 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1146 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1147 #endif /* defined(YYDESTRUCT_CALL) */
1157 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1158 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1159 #ifdef YYSTYPE_TOSTRING
1162 #endif /* YYBTYACC */
1167 for (i = yym; i > 0; i--)
1169 if (i != yym) fputs(", ", stderr);
1170 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1171 yystack.l_mark[1-i]), stderr);
1176 fputc('\n', stderr);
1180 yyval = yystack.l_mark[1-yym];
1182 memset(&yyval, 0, sizeof yyval);
1183 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1185 /* Perform position reduction */
1186 memset(&yyloc, 0, sizeof(yyloc));
1189 #endif /* YYBTYACC */
1191 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1192 /* just in case YYERROR is invoked within the action, save
1193 the start of the rhs as the error start position */
1194 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1201 #line 34 "pure_calc.y"
1205 #line 38 "pure_calc.y"
1206 { printf("%d\n",yystack.l_mark[0]);}
1209 #line 40 "pure_calc.y"
1210 { regs[yystack.l_mark[-2]] = yystack.l_mark[0]; }
1213 #line 44 "pure_calc.y"
1214 { yyval = yystack.l_mark[-1]; }
1217 #line 46 "pure_calc.y"
1218 { yyval = yystack.l_mark[-2] + yystack.l_mark[0]; }
1221 #line 48 "pure_calc.y"
1222 { yyval = yystack.l_mark[-2] - yystack.l_mark[0]; }
1225 #line 50 "pure_calc.y"
1226 { yyval = yystack.l_mark[-2] * yystack.l_mark[0]; }
1229 #line 52 "pure_calc.y"
1230 { yyval = yystack.l_mark[-2] / yystack.l_mark[0]; }
1233 #line 54 "pure_calc.y"
1234 { yyval = yystack.l_mark[-2] % yystack.l_mark[0]; }
1237 #line 56 "pure_calc.y"
1238 { yyval = yystack.l_mark[-2] & yystack.l_mark[0]; }
1241 #line 58 "pure_calc.y"
1242 { yyval = yystack.l_mark[-2] | yystack.l_mark[0]; }
1245 #line 60 "pure_calc.y"
1246 { yyval = - yystack.l_mark[0]; }
1249 #line 62 "pure_calc.y"
1250 { yyval = regs[yystack.l_mark[0]]; }
1253 #line 67 "pure_calc.y"
1254 { yyval = yystack.l_mark[0]; base = (yystack.l_mark[0]==0) ? 8 : 10; }
1257 #line 69 "pure_calc.y"
1258 { yyval = base * yystack.l_mark[-1] + yystack.l_mark[0]; }
1260 #line 1261 "pure_calc.tab.c"
1264 yystack.s_mark -= yym;
1265 yystate = *yystack.s_mark;
1266 yystack.l_mark -= yym;
1267 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1268 yystack.p_mark -= yym;
1271 if (yystate == 0 && yym == 0)
1276 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1277 #ifdef YYSTYPE_TOSTRING
1280 #endif /* YYBTYACC */
1281 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1283 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1287 *++yystack.s_mark = YYFINAL;
1288 *++yystack.l_mark = yyval;
1289 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1290 *++yystack.p_mark = yyloc;
1298 /* we're currently re-reading tokens */
1300 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1308 /* in trial mode; save scanner results for future parse attempts */
1309 if (yylvp == yylvlim)
1310 { /* Enlarge lexical value queue */
1311 size_t p = (size_t) (yylvp - yylvals);
1312 size_t s = (size_t) (yylvlim - yylvals);
1314 s += YYLVQUEUEGROWTH;
1315 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1317 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1319 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1320 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1323 yylvp = yylve = yylvals + p;
1324 yylvlim = yylvals + s;
1325 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1326 yylpp = yylpe = yylpsns + p;
1327 yylplim = yylpsns + s;
1329 yylexp = yylexemes + p;
1331 *yylexp = (YYINT) YYLEX;
1334 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1341 /* normal operation, no conflict encountered */
1342 #endif /* YYBTYACC */
1346 #endif /* YYBTYACC */
1347 if (yychar < 0) yychar = YYEOF;
1351 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1352 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1353 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1357 if (yychar == YYEOF) goto yyaccept;
1360 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1361 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1362 yystate = yytable[yyn];
1364 yystate = yydgoto[yym];
1368 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1369 #ifdef YYSTYPE_TOSTRING
1372 #endif /* YYBTYACC */
1373 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1375 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1378 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1379 *++yystack.s_mark = (YYINT) yystate;
1380 *++yystack.l_mark = yyval;
1381 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1382 *++yystack.p_mark = yyloc;
1387 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1389 if (yypath) YYABORT;
1392 YYParseState *save = yyps->save;
1393 yyps->save = save->save;
1394 save->save = yypath;
1399 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1400 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1404 yyFreeState(yyerrctx);
1407 yylvp = yylvals + yypath->lexeme;
1408 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1409 yylpp = yylpsns + yypath->lexeme;
1411 yylexp = yylexemes + yypath->lexeme;
1413 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1414 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1415 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1416 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1417 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1418 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1419 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1421 yystate = yypath->state;
1423 #endif /* YYBTYACC */
1426 YYERROR_CALL("yacc stack overflow");
1430 YYERROR_CALL("memory exhausted");
1432 #endif /* YYBTYACC */
1442 if (yyps->save) goto yyvalid;
1443 #endif /* YYBTYACC */
1447 #if defined(YYDESTRUCT_CALL)
1448 if (yychar != YYEOF && yychar != YYEMPTY)
1449 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1450 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1452 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1453 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1457 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1460 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1461 YYDESTRUCT_CALL("cleanup: discarding state",
1462 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1464 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1465 YYDESTRUCT_CALL("cleanup: discarding state",
1466 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1467 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1469 #endif /* defined(YYDESTRUCT_CALL) */
1474 yyFreeState(yyerrctx);
1479 YYParseState *save = yyps;
1486 YYParseState *save = yypath;
1487 yypath = save->save;
1491 #endif /* YYBTYACC */
1492 yyfreestack(&yystack);