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 calc1_parse
25 #define yylex calc1_lex
29 #define yyerror calc1_error
33 #define yychar calc1_char
37 #define yyval calc1_val
41 #define yylval calc1_lval
45 #define yydebug calc1_debug
49 #define yynerrs calc1_nerrs
53 #define yyerrflag calc1_errflag
54 #endif /* yyerrflag */
57 #define yylhs calc1_lhs
61 #define yylen calc1_len
65 #define yydefred calc1_defred
69 #define yystos calc1_stos
73 #define yydgoto calc1_dgoto
77 #define yysindex calc1_sindex
81 #define yyrindex calc1_rindex
85 #define yygindex calc1_gindex
89 #define yytable calc1_table
93 #define yycheck calc1_check
97 #define yyname calc1_name
101 #define yyrule calc1_rule
107 #define yycindex calc1_cindex
108 #endif /* yycindex */
111 #define yyctable calc1_ctable
112 #endif /* yyctable */
114 #endif /* YYBTYACC */
116 #define YYPREFIX "calc1_"
122 /* http://dinosaur.compilertools.net/yacc/index.html */
129 typedef struct interval
135 INTERVAL vmul(double, double, INTERVAL);
136 INTERVAL vdiv(double, double, INTERVAL);
138 extern int yylex(void);
139 static void yyerror(const char *s);
141 int dcheck(INTERVAL);
147 #undef YYSTYPE_IS_DECLARED
148 #define YYSTYPE_IS_DECLARED 1
150 #ifndef YYSTYPE_IS_DECLARED
151 #define YYSTYPE_IS_DECLARED 1
159 #endif /* !YYSTYPE_IS_DECLARED */
160 #line 161 "calc1.tab.c"
162 /* compatibility with bison */
164 /* compatibility with FreeBSD */
165 # ifdef YYPARSE_PARAM_TYPE
166 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
168 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
171 # define YYPARSE_DECL() yyparse(void)
174 /* Parameters sent to lex. */
176 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
177 # define YYLEX yylex(YYLEX_PARAM)
179 # define YYLEX_DECL() yylex(void)
180 # define YYLEX yylex()
183 /* Parameters sent to yyerror. */
185 #define YYERROR_DECL() yyerror(const char *s)
188 #define YYERROR_CALL(msg) yyerror(msg)
191 extern int YYPARSE_DECL();
197 #define YYERRCODE 256
199 static const YYINT calc1_lhs[] = { -1,
200 3, 3, 0, 0, 0, 0, 0, 1, 1, 1,
201 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
202 2, 2, 2, 2, 2, 2, 2, 2,
204 static const YYINT calc1_len[] = { 2,
205 0, 2, 2, 2, 4, 4, 2, 1, 1, 3,
206 3, 3, 3, 2, 3, 1, 5, 1, 3, 3,
207 3, 3, 3, 3, 3, 3, 2, 3,
209 static const YYINT calc1_defred[] = { 0,
210 0, 0, 0, 8, 0, 0, 0, 0, 0, 7,
211 0, 0, 9, 18, 14, 27, 0, 0, 0, 0,
212 0, 0, 3, 0, 0, 0, 0, 4, 0, 0,
213 0, 0, 0, 15, 0, 28, 0, 0, 0, 0,
214 12, 24, 13, 26, 0, 0, 23, 25, 14, 0,
215 0, 0, 0, 0, 5, 6, 0, 0, 0, 12,
218 #if defined(YYDESTRUCT_CALL) || defined(YYSTYPE_TOSTRING)
219 static const YYINT calc1_stos[] = { 0,
220 256, 257, 258, 259, 45, 40, 262, 263, 264, 10,
221 61, 61, 257, 258, 263, 264, 263, 264, 43, 45,
222 42, 47, 10, 43, 45, 42, 47, 10, 45, 40,
223 263, 263, 264, 41, 44, 41, 263, 264, 263, 264,
224 263, 264, 263, 264, 264, 264, 264, 264, 263, 263,
225 43, 45, 42, 47, 10, 10, 263, 263, 263, 263,
228 #endif /* YYDESTRUCT_CALL || YYSTYPE_TOSTRING */
229 static const YYINT calc1_dgoto[] = { 7,
232 static const YYINT calc1_sindex[] = { -40,
233 -8, -48, -47, 0, -37, -37, 0, 2, 17, 0,
234 -34, -37, 0, 0, 0, 0, -25, 90, -37, -37,
235 -37, -37, 0, -37, -37, -37, -37, 0, -34, -34,
236 25, 125, 31, 0, -34, 0, -11, 37, -11, 37,
237 0, 0, 0, 0, 37, 37, 0, 0, 0, 111,
238 -34, -34, -34, -34, 0, 0, 118, 69, 69, 0,
241 static const YYINT calc1_rindex[] = { 0,
242 0, 38, 44, 0, 0, 0, 0, 0, 0, 0,
243 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
244 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
245 0, -9, 0, 0, 0, 0, 51, -3, 56, 61,
246 0, 0, 0, 0, 67, 72, 0, 0, 0, 0,
247 0, 0, 0, 0, 0, 0, 0, 78, 83, 0,
251 static const YYINT calc1_cindex[] = { 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, 0, 0, 0, 0, 0,
256 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
257 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
261 static const YYINT calc1_gindex[] = { 0,
264 #define YYTABLESIZE 225
265 static const YYINT calc1_table[] = { 6,
266 16, 10, 6, 8, 5, 30, 20, 5, 15, 17,
267 29, 23, 11, 12, 31, 34, 21, 19, 35, 20,
268 0, 22, 37, 39, 41, 43, 28, 0, 0, 0,
269 21, 16, 49, 50, 55, 22, 0, 20, 57, 20,
270 56, 20, 0, 21, 19, 0, 20, 9, 22, 0,
271 0, 0, 0, 18, 58, 59, 60, 61, 26, 24,
272 10, 25, 0, 27, 0, 11, 53, 51, 0, 52,
273 22, 54, 26, 24, 0, 25, 19, 27, 26, 9,
274 9, 21, 9, 27, 9, 18, 18, 10, 18, 0,
275 18, 10, 11, 10, 10, 10, 11, 0, 11, 11,
276 11, 22, 0, 22, 0, 22, 0, 19, 0, 19,
277 53, 19, 21, 0, 21, 54, 21, 0, 10, 0,
278 10, 0, 10, 11, 0, 11, 0, 11, 16, 18,
279 36, 26, 24, 0, 25, 33, 27, 0, 0, 0,
280 0, 0, 38, 40, 42, 44, 0, 45, 46, 47,
281 48, 34, 53, 51, 0, 52, 0, 54, 62, 53,
282 51, 0, 52, 0, 54, 0, 21, 19, 0, 20,
283 0, 22, 0, 0, 0, 0, 0, 0, 0, 0,
284 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
285 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
286 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
287 0, 0, 0, 0, 0, 1, 2, 3, 4, 13,
290 static const YYINT calc1_check[] = { 40,
291 10, 10, 40, 0, 45, 40, 10, 45, 5, 6,
292 45, 10, 61, 61, 11, 41, 42, 43, 44, 45,
293 -1, 47, 19, 20, 21, 22, 10, -1, -1, -1,
294 42, 41, 29, 30, 10, 47, -1, 41, 35, 43,
295 10, 45, -1, 42, 43, -1, 45, 10, 47, -1,
296 -1, -1, -1, 10, 51, 52, 53, 54, 42, 43,
297 10, 45, -1, 47, -1, 10, 42, 43, -1, 45,
298 10, 47, 42, 43, -1, 45, 10, 47, 42, 42,
299 43, 10, 45, 47, 47, 42, 43, 10, 45, -1,
300 47, 41, 10, 43, 44, 45, 41, -1, 43, 44,
301 45, 41, -1, 43, -1, 45, -1, 41, -1, 43,
302 42, 45, 41, -1, 43, 47, 45, -1, 41, -1,
303 43, -1, 45, 41, -1, 43, -1, 45, 5, 6,
304 41, 42, 43, -1, 45, 12, 47, -1, -1, -1,
305 -1, -1, 19, 20, 21, 22, -1, 24, 25, 26,
306 27, 41, 42, 43, -1, 45, -1, 47, 41, 42,
307 43, -1, 45, -1, 47, -1, 42, 43, -1, 45,
308 -1, 47, -1, -1, -1, -1, -1, -1, -1, -1,
309 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
310 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
311 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
312 -1, -1, -1, -1, -1, 256, 257, 258, 259, 257,
313 258, 259, 257, -1, 259,
316 static const YYINT calc1_ctable[] = { -1,
317 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
318 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
319 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
320 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
321 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
322 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
323 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
324 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
325 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
326 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
327 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
328 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
329 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
330 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
331 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
332 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
333 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
334 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
335 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
336 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
337 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
338 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
346 #define YYMAXTOKEN 260
347 #define YYUNDFTOKEN 266
348 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
350 static const char *const calc1_name[] = {
352 "$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,
353 0,0,0,0,0,0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0,
354 0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
355 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
356 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
357 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
358 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
359 "error","DREG","VREG","CONST","UMINUS","$accept","line","dexp","vexp","lines",
362 static const char *const calc1_rule[] = {
365 "lines : lines line",
368 "line : DREG '=' dexp '\\n'",
369 "line : VREG '=' vexp '\\n'",
370 "line : error '\\n'",
373 "dexp : dexp '+' dexp",
374 "dexp : dexp '-' dexp",
375 "dexp : dexp '*' dexp",
376 "dexp : dexp '/' dexp",
378 "dexp : '(' dexp ')'",
380 "vexp : '(' dexp ',' dexp ')'",
382 "vexp : vexp '+' vexp",
383 "vexp : dexp '+' vexp",
384 "vexp : vexp '-' vexp",
385 "vexp : dexp '-' vexp",
386 "vexp : vexp '*' vexp",
387 "vexp : dexp '*' vexp",
388 "vexp : vexp '/' vexp",
389 "vexp : dexp '/' vexp",
391 "vexp : '(' vexp ')'",
406 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
407 YYLTYPE yyloc; /* position returned by actions */
408 YYLTYPE yylloc; /* position from the lexer */
411 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
412 #ifndef YYLLOC_DEFAULT
413 #define YYLLOC_DEFAULT(loc, rhs, n) \
418 (loc).first_line = YYRHSLOC(rhs, 0).last_line; \
419 (loc).first_column = YYRHSLOC(rhs, 0).last_column; \
420 (loc).last_line = YYRHSLOC(rhs, 0).last_line; \
421 (loc).last_column = YYRHSLOC(rhs, 0).last_column; \
425 (loc).first_line = YYRHSLOC(rhs, 1).first_line; \
426 (loc).first_column = YYRHSLOC(rhs, 1).first_column; \
427 (loc).last_line = YYRHSLOC(rhs, n).last_line; \
428 (loc).last_column = YYRHSLOC(rhs, n).last_column; \
431 #endif /* YYLLOC_DEFAULT */
432 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
435 #ifndef YYLVQUEUEGROWTH
436 #define YYLVQUEUEGROWTH 32
438 #endif /* YYBTYACC */
440 /* define the initial stack-sizes */
443 #define YYMAXDEPTH YYSTACKSIZE
446 #define YYSTACKSIZE YYMAXDEPTH
448 #define YYSTACKSIZE 10000
449 #define YYMAXDEPTH 10000
453 #ifndef YYINITSTACKSIZE
454 #define YYINITSTACKSIZE 200
464 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
471 struct YYParseState_s
473 struct YYParseState_s *save; /* Previously saved parser state */
474 YYSTACKDATA yystack; /* saved parser stack */
475 int state; /* saved parser state */
476 int errflag; /* saved error recovery status */
477 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
478 YYINT ctry; /* saved index in yyctable[] for this conflict */
480 typedef struct YYParseState_s YYParseState;
481 #endif /* YYBTYACC */
482 /* variables for the parser stack */
483 static YYSTACKDATA yystack;
486 /* Current parser state */
487 static YYParseState *yyps = 0;
489 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
490 static YYParseState *yypath = 0;
492 /* Base of the lexical value queue */
493 static YYSTYPE *yylvals = 0;
495 /* Current position at lexical value queue */
496 static YYSTYPE *yylvp = 0;
498 /* End position of lexical value queue */
499 static YYSTYPE *yylve = 0;
501 /* The last allocated position at the lexical value queue */
502 static YYSTYPE *yylvlim = 0;
504 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
505 /* Base of the lexical position queue */
506 static YYLTYPE *yylpsns = 0;
508 /* Current position at lexical position queue */
509 static YYLTYPE *yylpp = 0;
511 /* End position of lexical position queue */
512 static YYLTYPE *yylpe = 0;
514 /* The last allocated position at the lexical position queue */
515 static YYLTYPE *yylplim = 0;
518 /* Current position at lexical token queue */
519 static YYINT *yylexp = 0;
521 static YYINT *yylexemes = 0;
522 #endif /* YYBTYACC */
524 /* beginning of subroutines section */
526 #define BSZ 50 /* buffer size for floating point numbers */
528 /* lexical analysis */
531 yyerror(const char *s)
533 fprintf(stderr, "%s\n", s);
541 while ((c = getchar()) == ' ')
542 { /* skip over blanks */
547 yylval.ival = c - 'A';
552 yylval.ival = c - 'a';
556 if (isdigit(c) || c == '.')
558 /* gobble up digits, points, exponents */
559 char buf[BSZ + 1], *cp = buf;
560 int dot = 0, expr = 0;
562 for (; (cp - buf) < BSZ; ++cp, c = getchar())
571 return ('.'); /* will cause syntax error */
578 return ('e'); /* will cause syntax error */
587 if ((cp - buf) >= BSZ)
588 printf("constant too long: truncated\n");
590 ungetc(c, stdin); /* push back last char read */
591 yylval.dval = atof(buf);
598 hilo(double a, double b, double c, double d)
600 /* returns the smallest interval containing a, b, c, and d */
601 /* used by *, / routines */
633 vmul(double a, double b, INTERVAL v)
635 return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo));
641 if (v.hi >= 0. && v.lo <= 0.)
643 printf("divisor interval contains 0.\n");
650 vdiv(double a, double b, INTERVAL v)
652 return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
654 #line 655 "calc1.tab.c"
656 /* For use in generated program */
657 #define yydepth (int)(yystack.s_mark - yystack.s_base)
659 #define yytrial (yyps->save)
660 #endif /* YYBTYACC */
663 #include <stdio.h> /* needed for printf */
666 #include <stdlib.h> /* needed for malloc, etc */
667 #include <string.h> /* needed for memset */
669 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
670 static int yygrowstack(YYSTACKDATA *data)
676 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
680 if ((newsize = data->stacksize) == 0)
681 newsize = YYINITSTACKSIZE;
682 else if (newsize >= YYMAXDEPTH)
684 else if ((newsize *= 2) > YYMAXDEPTH)
685 newsize = YYMAXDEPTH;
687 i = (int) (data->s_mark - data->s_base);
688 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
692 data->s_base = newss;
693 data->s_mark = newss + i;
695 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
699 data->l_base = newvs;
700 data->l_mark = newvs + i;
702 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
703 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
707 data->p_base = newps;
708 data->p_mark = newps + i;
711 data->stacksize = newsize;
712 data->s_last = data->s_base + newsize - 1;
716 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
721 #if YYPURE || defined(YY_NO_LEAKS)
722 static void yyfreestack(YYSTACKDATA *data)
726 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
729 memset(data, 0, sizeof(*data));
732 #define yyfreestack(data) /* nothing */
733 #endif /* YYPURE || defined(YY_NO_LEAKS) */
736 static YYParseState *
737 yyNewState(unsigned size)
739 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
740 if (p == NULL) return NULL;
742 p->yystack.stacksize = size;
745 p->yystack.s_base = NULL;
746 p->yystack.l_base = NULL;
747 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
748 p->yystack.p_base = NULL;
752 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
753 if (p->yystack.s_base == NULL) return NULL;
754 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
755 if (p->yystack.l_base == NULL) return NULL;
756 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
757 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
758 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
759 if (p->yystack.p_base == NULL) return NULL;
760 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
767 yyFreeState(YYParseState *p)
769 yyfreestack(&p->yystack);
772 #endif /* YYBTYACC */
774 #define YYABORT goto yyabort
775 #define YYREJECT goto yyabort
776 #define YYACCEPT goto yyaccept
777 #define YYERROR goto yyerrlab
779 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
780 #define YYVALID_NESTED do { if (yyps->save && \
781 yyps->save->save == 0) goto yyvalid; } while(0)
782 #endif /* YYBTYACC */
787 int yym, yyn, yystate, yyresult;
790 YYParseState *yyerrctx = NULL;
791 #endif /* YYBTYACC */
792 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
793 YYLTYPE yyerror_loc_range[3]; /* position of error start/end (0 unused) */
798 if ((yys = getenv("YYDEBUG")) != 0)
801 if (yyn >= '0' && yyn <= '9')
805 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
807 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
808 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
812 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
814 #endif /* YYBTYACC */
823 memset(&yystack, 0, sizeof(yystack));
826 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
827 yystack.s_mark = yystack.s_base;
828 yystack.l_mark = yystack.l_base;
829 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
830 yystack.p_mark = yystack.p_base;
836 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
843 /* we're currently re-reading tokens */
845 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
853 /* in trial mode; save scanner results for future parse attempts */
854 if (yylvp == yylvlim)
855 { /* Enlarge lexical value queue */
856 size_t p = (size_t) (yylvp - yylvals);
857 size_t s = (size_t) (yylvlim - yylvals);
859 s += YYLVQUEUEGROWTH;
860 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
861 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
862 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
863 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
865 yylvp = yylve = yylvals + p;
866 yylvlim = yylvals + s;
867 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
868 yylpp = yylpe = yylpsns + p;
869 yylplim = yylpsns + s;
871 yylexp = yylexemes + p;
873 *yylexp = (YYINT) YYLEX;
876 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
883 /* normal operation, no conflict encountered */
884 #endif /* YYBTYACC */
888 #endif /* YYBTYACC */
889 if (yychar < 0) yychar = YYEOF;
893 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
894 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
895 YYDEBUGSTR, yydepth, yystate, yychar, yys);
896 #ifdef YYSTYPE_TOSTRING
899 #endif /* YYBTYACC */
900 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
908 /* Do we have a conflict? */
909 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
910 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
919 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
920 YYDEBUGSTR, yydepth, yystate);
922 /* Switch to the next conflict context */
927 if (save->state != yystate) YYABORT;
934 /* Unresolved conflict - start/continue trial parse */
939 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
941 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
943 fputs("Starting trial parse.\n", stderr);
946 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
947 if (save == NULL) goto yyenomem;
948 save->save = yyps->save;
949 save->state = yystate;
950 save->errflag = yyerrflag;
951 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
952 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
953 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
954 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
955 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
956 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
957 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
960 if (yyctable[ctry] == -1)
963 if (yydebug && yychar >= YYEOF)
964 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
969 if (yyps->save == NULL)
971 /* If this is a first conflict in the stack, start saving lexemes */
974 yylexemes = (YYINT *) malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
975 if (yylexemes == NULL) goto yyenomem;
976 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
977 if (yylvals == NULL) goto yyenomem;
978 yylvlim = yylvals + YYLVQUEUEGROWTH;
979 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
980 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
981 if (yylpsns == NULL) goto yyenomem;
982 yylplim = yylpsns + YYLVQUEUEGROWTH;
987 yylvp = yylve = yylvals;
988 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
989 yylpp = yylpe = yylpsns;
995 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
998 *yylexp = (YYINT) yychar;
1003 if (yychar >= YYEOF)
1006 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1012 save->lexeme = (int) (yylvp - yylvals);
1015 if (yytable[yyn] == ctry)
1019 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1020 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
1025 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1030 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
1032 yystate = yyctable[ctry];
1033 *++yystack.s_mark = (YYINT) yystate;
1034 *++yystack.l_mark = yylval;
1035 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1036 *++yystack.p_mark = yylloc;
1039 if (yyerrflag > 0) --yyerrflag;
1044 yyn = yyctable[ctry];
1047 } /* End of code dealing with conflicts */
1048 #endif /* YYBTYACC */
1049 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1050 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1054 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1055 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
1057 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1058 yystate = yytable[yyn];
1059 *++yystack.s_mark = yytable[yyn];
1060 *++yystack.l_mark = yylval;
1061 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1062 *++yystack.p_mark = yylloc;
1065 if (yyerrflag > 0) --yyerrflag;
1068 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1069 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1074 if (yyerrflag != 0) goto yyinrecovery;
1079 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1082 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
1083 * before looking for error recovery */
1084 yystack.s_mark -= yym;
1085 yystate = *yystack.s_mark;
1086 yystack.l_mark -= yym;
1087 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1088 yystack.p_mark -= yym;
1096 YYParseState *save = yyps->save;
1099 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
1100 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
1101 (int)(yylvp - yylvals - yyps->save->lexeme));
1103 /* Memorize most forward-looking error state in case it's really an error. */
1104 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
1106 /* Free old saved error context state */
1107 if (yyerrctx) yyFreeState(yyerrctx);
1108 /* Create and fill out new saved error context state */
1109 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1110 if (yyerrctx == NULL) goto yyenomem;
1111 yyerrctx->save = yyps->save;
1112 yyerrctx->state = yystate;
1113 yyerrctx->errflag = yyerrflag;
1114 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1115 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1116 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1117 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1118 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1119 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1120 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1122 yyerrctx->lexeme = (int) (yylvp - yylvals);
1124 yylvp = yylvals + save->lexeme;
1125 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1126 yylpp = yylpsns + save->lexeme;
1128 yylexp = yylexemes + save->lexeme;
1130 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1131 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1132 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1133 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1134 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1135 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1136 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1138 ctry = ++save->ctry;
1139 yystate = save->state;
1140 /* We tried shift, try reduce now */
1141 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1142 yyps->save = save->save;
1146 /* Nothing left on the stack -- error */
1151 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1154 /* Restore state as it was in the most forward-advanced error */
1155 yylvp = yylvals + yyerrctx->lexeme;
1156 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1157 yylpp = yylpsns + yyerrctx->lexeme;
1159 yylexp = yylexemes + yyerrctx->lexeme;
1160 yychar = yylexp[-1];
1162 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1165 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1166 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1167 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1168 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1169 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1170 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1171 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1173 yystate = yyerrctx->state;
1174 yyFreeState(yyerrctx);
1179 if (yynewerrflag == 0) goto yyinrecovery;
1180 #endif /* YYBTYACC */
1182 YYERROR_CALL("syntax error");
1183 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1184 yyerror_loc_range[1] = yylloc; /* lookahead position is error start position */
1188 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1199 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1200 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1204 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1205 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1207 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1208 yystate = yytable[yyn];
1209 *++yystack.s_mark = yytable[yyn];
1210 *++yystack.l_mark = yylval;
1211 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1212 /* lookahead position is error end position */
1213 yyerror_loc_range[2] = yylloc;
1214 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1215 *++yystack.p_mark = yyloc;
1223 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1224 YYDEBUGSTR, yydepth, *yystack.s_mark);
1226 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1227 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1228 /* the current TOS position is the error start position */
1229 yyerror_loc_range[1] = *yystack.p_mark;
1231 #if defined(YYDESTRUCT_CALL)
1234 #endif /* YYBTYACC */
1235 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1236 YYDESTRUCT_CALL("error: discarding state",
1237 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1239 YYDESTRUCT_CALL("error: discarding state",
1240 yystos[*yystack.s_mark], yystack.l_mark);
1241 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1242 #endif /* defined(YYDESTRUCT_CALL) */
1245 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1253 if (yychar == YYEOF) goto yyabort;
1257 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1258 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1259 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1262 #if defined(YYDESTRUCT_CALL)
1265 #endif /* YYBTYACC */
1266 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1267 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1269 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1270 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1271 #endif /* defined(YYDESTRUCT_CALL) */
1281 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1282 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1283 #ifdef YYSTYPE_TOSTRING
1286 #endif /* YYBTYACC */
1291 for (i = yym; i > 0; i--)
1293 if (i != yym) fputs(", ", stderr);
1294 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1295 yystack.l_mark[1-i]), stderr);
1300 fputc('\n', stderr);
1304 yyval = yystack.l_mark[1-yym];
1306 memset(&yyval, 0, sizeof yyval);
1307 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1309 /* Perform position reduction */
1310 memset(&yyloc, 0, sizeof(yyloc));
1313 #endif /* YYBTYACC */
1315 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[-yym], yym);
1316 /* just in case YYERROR is invoked within the action, save
1317 the start of the rhs as the error start position */
1318 yyerror_loc_range[1] = yystack.p_mark[1-yym];
1327 (void) printf("%15.8f\n", yystack.l_mark[-1].dval);
1333 (void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[-1].vval.lo, yystack.l_mark[-1].vval.hi);
1339 dreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].dval;
1345 vreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].vval;
1357 yyval.dval = dreg[yystack.l_mark[0].ival];
1363 yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval;
1369 yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval;
1375 yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval;
1381 yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval;
1387 yyval.dval = -yystack.l_mark[0].dval;
1393 yyval.dval = yystack.l_mark[-1].dval;
1399 yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval;
1405 yyval.vval.lo = yystack.l_mark[-3].dval;
1406 yyval.vval.hi = yystack.l_mark[-1].dval;
1407 if ( yyval.vval.lo > yyval.vval.hi )
1409 (void) printf("interval out of order\n");
1417 yyval.vval = vreg[yystack.l_mark[0].ival];
1423 yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi;
1424 yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo;
1430 yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi;
1431 yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo;
1437 yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo;
1438 yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi;
1444 yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo;
1445 yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi;
1451 yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
1457 yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
1463 if (dcheck(yystack.l_mark[0].vval)) YYERROR;
1464 yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
1470 if (dcheck ( yystack.l_mark[0].vval )) YYERROR;
1471 yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
1477 yyval.vval.hi = -yystack.l_mark[0].vval.lo;
1478 yyval.vval.lo = -yystack.l_mark[0].vval.hi;
1484 yyval.vval = yystack.l_mark[-1].vval;
1487 #line 1488 "calc1.tab.c"
1491 yystack.s_mark -= yym;
1492 yystate = *yystack.s_mark;
1493 yystack.l_mark -= yym;
1494 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1495 yystack.p_mark -= yym;
1498 if (yystate == 0 && yym == 0)
1503 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1504 #ifdef YYSTYPE_TOSTRING
1507 #endif /* YYBTYACC */
1508 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1510 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1514 *++yystack.s_mark = YYFINAL;
1515 *++yystack.l_mark = yyval;
1516 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1517 *++yystack.p_mark = yyloc;
1525 /* we're currently re-reading tokens */
1527 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1535 /* in trial mode; save scanner results for future parse attempts */
1536 if (yylvp == yylvlim)
1537 { /* Enlarge lexical value queue */
1538 size_t p = (size_t) (yylvp - yylvals);
1539 size_t s = (size_t) (yylvlim - yylvals);
1541 s += YYLVQUEUEGROWTH;
1542 if ((yylexemes = (YYINT *)realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1544 if ((yylvals = (YYSTYPE *)realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1546 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1547 if ((yylpsns = (YYLTYPE *)realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1550 yylvp = yylve = yylvals + p;
1551 yylvlim = yylvals + s;
1552 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1553 yylpp = yylpe = yylpsns + p;
1554 yylplim = yylpsns + s;
1556 yylexp = yylexemes + p;
1558 *yylexp = (YYINT) YYLEX;
1561 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1568 /* normal operation, no conflict encountered */
1569 #endif /* YYBTYACC */
1573 #endif /* YYBTYACC */
1574 if (yychar < 0) yychar = YYEOF;
1578 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1579 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1580 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1584 if (yychar == YYEOF) goto yyaccept;
1587 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1588 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1589 yystate = yytable[yyn];
1591 yystate = yydgoto[yym];
1595 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1596 #ifdef YYSTYPE_TOSTRING
1599 #endif /* YYBTYACC */
1600 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1602 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1605 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1606 *++yystack.s_mark = (YYINT) yystate;
1607 *++yystack.l_mark = yyval;
1608 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1609 *++yystack.p_mark = yyloc;
1614 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1616 if (yypath) YYABORT;
1619 YYParseState *save = yyps->save;
1620 yyps->save = save->save;
1621 save->save = yypath;
1626 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1627 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1631 yyFreeState(yyerrctx);
1634 yylvp = yylvals + yypath->lexeme;
1635 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1636 yylpp = yylpsns + yypath->lexeme;
1638 yylexp = yylexemes + yypath->lexeme;
1640 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1641 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1642 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1643 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1644 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1645 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1646 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1648 yystate = yypath->state;
1650 #endif /* YYBTYACC */
1653 YYERROR_CALL("yacc stack overflow");
1657 YYERROR_CALL("memory exhausted");
1659 #endif /* YYBTYACC */
1669 if (yyps->save) goto yyvalid;
1670 #endif /* YYBTYACC */
1674 #if defined(YYDESTRUCT_CALL)
1675 if (yychar != YYEOF && yychar != YYEMPTY)
1676 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1677 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1679 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1680 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1684 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1687 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1688 YYDESTRUCT_CALL("cleanup: discarding state",
1689 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1691 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1692 YYDESTRUCT_CALL("cleanup: discarding state",
1693 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1694 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1696 #endif /* defined(YYDESTRUCT_CALL) */
1701 yyFreeState(yyerrctx);
1706 YYParseState *save = yyps;
1713 YYParseState *save = yypath;
1714 yypath = save->save;
1718 #endif /* YYBTYACC */
1719 yyfreestack(&yystack);