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 ')'",
403 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
404 YYLTYPE yyloc; /* position returned by actions */
405 YYLTYPE yylloc; /* position from the lexer */
408 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
409 #ifndef YYLLOC_DEFAULT
410 #define YYLLOC_DEFAULT(loc, rhs, n) \
415 (loc).first_line = ((rhs)[-1]).last_line; \
416 (loc).first_column = ((rhs)[-1]).last_column; \
417 (loc).last_line = ((rhs)[-1]).last_line; \
418 (loc).last_column = ((rhs)[-1]).last_column; \
422 (loc).first_line = ((rhs)[ 0 ]).first_line; \
423 (loc).first_column = ((rhs)[ 0 ]).first_column; \
424 (loc).last_line = ((rhs)[n-1]).last_line; \
425 (loc).last_column = ((rhs)[n-1]).last_column; \
428 #endif /* YYLLOC_DEFAULT */
429 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
432 #ifndef YYLVQUEUEGROWTH
433 #define YYLVQUEUEGROWTH 32
435 #endif /* YYBTYACC */
437 /* define the initial stack-sizes */
440 #define YYMAXDEPTH YYSTACKSIZE
443 #define YYSTACKSIZE YYMAXDEPTH
445 #define YYSTACKSIZE 10000
446 #define YYMAXDEPTH 10000
450 #ifndef YYINITSTACKSIZE
451 #define YYINITSTACKSIZE 200
461 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
468 struct YYParseState_s
470 struct YYParseState_s *save; /* Previously saved parser state */
471 YYSTACKDATA yystack; /* saved parser stack */
472 int state; /* saved parser state */
473 int errflag; /* saved error recovery status */
474 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
475 YYINT ctry; /* saved index in yyctable[] for this conflict */
477 typedef struct YYParseState_s YYParseState;
478 #endif /* YYBTYACC */
479 /* variables for the parser stack */
480 static YYSTACKDATA yystack;
483 /* Current parser state */
484 static YYParseState *yyps = 0;
486 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
487 static YYParseState *yypath = 0;
489 /* Base of the lexical value queue */
490 static YYSTYPE *yylvals = 0;
492 /* Current position at lexical value queue */
493 static YYSTYPE *yylvp = 0;
495 /* End position of lexical value queue */
496 static YYSTYPE *yylve = 0;
498 /* The last allocated position at the lexical value queue */
499 static YYSTYPE *yylvlim = 0;
501 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
502 /* Base of the lexical position queue */
503 static YYLTYPE *yylpsns = 0;
505 /* Current position at lexical position queue */
506 static YYLTYPE *yylpp = 0;
508 /* End position of lexical position queue */
509 static YYLTYPE *yylpe = 0;
511 /* The last allocated position at the lexical position queue */
512 static YYLTYPE *yylplim = 0;
515 /* Current position at lexical token queue */
516 static YYINT *yylexp = 0;
518 static YYINT *yylexemes = 0;
519 #endif /* YYBTYACC */
521 /* beginning of subroutines section */
523 #define BSZ 50 /* buffer size for floating point numbers */
525 /* lexical analysis */
528 yyerror(const char *s)
530 fprintf(stderr, "%s\n", s);
538 while ((c = getchar()) == ' ')
539 { /* skip over blanks */
544 yylval.ival = c - 'A';
549 yylval.ival = c - 'a';
553 if (isdigit(c) || c == '.')
555 /* gobble up digits, points, exponents */
556 char buf[BSZ + 1], *cp = buf;
557 int dot = 0, expr = 0;
559 for (; (cp - buf) < BSZ; ++cp, c = getchar())
568 return ('.'); /* will cause syntax error */
575 return ('e'); /* will cause syntax error */
584 if ((cp - buf) >= BSZ)
585 printf("constant too long: truncated\n");
587 ungetc(c, stdin); /* push back last char read */
588 yylval.dval = atof(buf);
595 hilo(double a, double b, double c, double d)
597 /* returns the smallest interval containing a, b, c, and d */
598 /* used by *, / routines */
630 vmul(double a, double b, INTERVAL v)
632 return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo));
638 if (v.hi >= 0. && v.lo <= 0.)
640 printf("divisor interval contains 0.\n");
647 vdiv(double a, double b, INTERVAL v)
649 return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
651 #line 652 "calc1.tab.c"
653 /* For use in generated program */
654 #define yydepth (int)(yystack.s_mark - yystack.s_base)
656 #define yytrial (yyps->save)
657 #endif /* YYBTYACC */
660 #include <stdio.h> /* needed for printf */
663 #include <stdlib.h> /* needed for malloc, etc */
664 #include <string.h> /* needed for memset */
666 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
667 static int yygrowstack(YYSTACKDATA *data)
673 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
677 if ((newsize = data->stacksize) == 0)
678 newsize = YYINITSTACKSIZE;
679 else if (newsize >= YYMAXDEPTH)
681 else if ((newsize *= 2) > YYMAXDEPTH)
682 newsize = YYMAXDEPTH;
684 i = (int) (data->s_mark - data->s_base);
685 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
689 data->s_base = newss;
690 data->s_mark = newss + i;
692 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
696 data->l_base = newvs;
697 data->l_mark = newvs + i;
699 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
700 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
704 data->p_base = newps;
705 data->p_mark = newps + i;
708 data->stacksize = newsize;
709 data->s_last = data->s_base + newsize - 1;
713 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
718 #if YYPURE || defined(YY_NO_LEAKS)
719 static void yyfreestack(YYSTACKDATA *data)
723 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
726 memset(data, 0, sizeof(*data));
729 #define yyfreestack(data) /* nothing */
730 #endif /* YYPURE || defined(YY_NO_LEAKS) */
733 static YYParseState *
734 yyNewState(unsigned size)
736 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
737 if (p == NULL) return NULL;
739 p->yystack.stacksize = size;
742 p->yystack.s_base = NULL;
743 p->yystack.l_base = NULL;
744 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
745 p->yystack.p_base = NULL;
749 p->yystack.s_base = (YYINT *) malloc(size * sizeof(YYINT));
750 if (p->yystack.s_base == NULL) return NULL;
751 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
752 if (p->yystack.l_base == NULL) return NULL;
753 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
754 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
755 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
756 if (p->yystack.p_base == NULL) return NULL;
757 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
764 yyFreeState(YYParseState *p)
766 yyfreestack(&p->yystack);
769 #endif /* YYBTYACC */
771 #define YYABORT goto yyabort
772 #define YYREJECT goto yyabort
773 #define YYACCEPT goto yyaccept
774 #define YYERROR goto yyerrlab
776 #define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
777 #define YYVALID_NESTED do { if (yyps->save && \
778 yyps->save->save == 0) goto yyvalid; } while(0)
779 #endif /* YYBTYACC */
784 int yym, yyn, yystate, yyresult;
787 YYParseState *yyerrctx = NULL;
788 #endif /* YYBTYACC */
789 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
790 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
795 if ((yys = getenv("YYDEBUG")) != 0)
798 if (yyn >= '0' && yyn <= '9')
802 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
804 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
805 memset(yyerror_loc_range, 0, sizeof(yyerror_loc_range));
809 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
811 #endif /* YYBTYACC */
820 memset(&yystack, 0, sizeof(yystack));
823 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
824 yystack.s_mark = yystack.s_base;
825 yystack.l_mark = yystack.l_base;
826 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
827 yystack.p_mark = yystack.p_base;
833 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
840 /* we're currently re-reading tokens */
842 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
850 /* in trial mode; save scanner results for future parse attempts */
851 if (yylvp == yylvlim)
852 { /* Enlarge lexical value queue */
853 size_t p = (size_t) (yylvp - yylvals);
854 size_t s = (size_t) (yylvlim - yylvals);
856 s += YYLVQUEUEGROWTH;
857 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
858 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
859 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
860 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
862 yylvp = yylve = yylvals + p;
863 yylvlim = yylvals + s;
864 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
865 yylpp = yylpe = yylpsns + p;
866 yylplim = yylpsns + s;
868 yylexp = yylexemes + p;
870 *yylexp = (YYINT) YYLEX;
873 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
880 /* normal operation, no conflict encountered */
881 #endif /* YYBTYACC */
885 #endif /* YYBTYACC */
886 if (yychar < 0) yychar = YYEOF;
890 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
891 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
892 YYDEBUGSTR, yydepth, yystate, yychar, yys);
893 #ifdef YYSTYPE_TOSTRING
896 #endif /* YYBTYACC */
897 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
905 /* Do we have a conflict? */
906 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
907 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
916 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
917 YYDEBUGSTR, yydepth, yystate);
919 /* Switch to the next conflict context */
924 if (save->state != yystate) YYABORT;
931 /* Unresolved conflict - start/continue trial parse */
936 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
938 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
940 fputs("Starting trial parse.\n", stderr);
943 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
944 if (save == NULL) goto yyenomem;
945 save->save = yyps->save;
946 save->state = yystate;
947 save->errflag = yyerrflag;
948 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
949 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
950 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
951 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
952 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
953 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
954 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
957 if (yyctable[ctry] == -1)
960 if (yydebug && yychar >= YYEOF)
961 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
966 if (yyps->save == NULL)
968 /* If this is a first conflict in the stack, start saving lexemes */
971 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
972 if (yylexemes == NULL) goto yyenomem;
973 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
974 if (yylvals == NULL) goto yyenomem;
975 yylvlim = yylvals + YYLVQUEUEGROWTH;
976 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
977 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
978 if (yylpsns == NULL) goto yyenomem;
979 yylplim = yylpsns + YYLVQUEUEGROWTH;
984 yylvp = yylve = yylvals;
985 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
986 yylpp = yylpe = yylpsns;
992 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
995 *yylexp = (YYINT) yychar;
1000 if (yychar >= YYEOF)
1003 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1009 save->lexeme = (int) (yylvp - yylvals);
1012 if (yytable[yyn] == ctry)
1016 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1017 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
1022 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1027 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
1029 yystate = yyctable[ctry];
1030 *++yystack.s_mark = (YYINT) yystate;
1031 *++yystack.l_mark = yylval;
1032 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1033 *++yystack.p_mark = yylloc;
1036 if (yyerrflag > 0) --yyerrflag;
1041 yyn = yyctable[ctry];
1044 } /* End of code dealing with conflicts */
1045 #endif /* YYBTYACC */
1046 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1047 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1051 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1052 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
1054 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1055 yystate = yytable[yyn];
1056 *++yystack.s_mark = yytable[yyn];
1057 *++yystack.l_mark = yylval;
1058 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1059 *++yystack.p_mark = yylloc;
1062 if (yyerrflag > 0) --yyerrflag;
1065 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1066 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1071 if (yyerrflag != 0) goto yyinrecovery;
1076 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1079 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
1080 * before looking for error recovery */
1081 yystack.s_mark -= yym;
1082 yystate = *yystack.s_mark;
1083 yystack.l_mark -= yym;
1084 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1085 yystack.p_mark -= yym;
1093 YYParseState *save = yyps->save;
1096 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
1097 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
1098 (int)(yylvp - yylvals - yyps->save->lexeme));
1100 /* Memorize most forward-looking error state in case it's really an error. */
1101 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
1103 /* Free old saved error context state */
1104 if (yyerrctx) yyFreeState(yyerrctx);
1105 /* Create and fill out new saved error context state */
1106 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1107 if (yyerrctx == NULL) goto yyenomem;
1108 yyerrctx->save = yyps->save;
1109 yyerrctx->state = yystate;
1110 yyerrctx->errflag = yyerrflag;
1111 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1112 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1113 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1114 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1115 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1116 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1117 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1119 yyerrctx->lexeme = (int) (yylvp - yylvals);
1121 yylvp = yylvals + save->lexeme;
1122 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1123 yylpp = yylpsns + save->lexeme;
1125 yylexp = yylexemes + save->lexeme;
1127 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1128 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1129 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1130 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1131 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1132 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1133 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1135 ctry = ++save->ctry;
1136 yystate = save->state;
1137 /* We tried shift, try reduce now */
1138 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1139 yyps->save = save->save;
1143 /* Nothing left on the stack -- error */
1148 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1151 /* Restore state as it was in the most forward-advanced error */
1152 yylvp = yylvals + yyerrctx->lexeme;
1153 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1154 yylpp = yylpsns + yyerrctx->lexeme;
1156 yylexp = yylexemes + yyerrctx->lexeme;
1157 yychar = yylexp[-1];
1159 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1162 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1163 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1164 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1165 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1166 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1167 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1168 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1170 yystate = yyerrctx->state;
1171 yyFreeState(yyerrctx);
1176 if (yynewerrflag == 0) goto yyinrecovery;
1177 #endif /* YYBTYACC */
1179 YYERROR_CALL("syntax error");
1180 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1181 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1185 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1196 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1197 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1201 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1202 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1204 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1205 yystate = yytable[yyn];
1206 *++yystack.s_mark = yytable[yyn];
1207 *++yystack.l_mark = yylval;
1208 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1209 /* lookahead position is error end position */
1210 yyerror_loc_range[1] = yylloc;
1211 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1212 *++yystack.p_mark = yyloc;
1220 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1221 YYDEBUGSTR, yydepth, *yystack.s_mark);
1223 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1224 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1225 /* the current TOS position is the error start position */
1226 yyerror_loc_range[0] = *yystack.p_mark;
1228 #if defined(YYDESTRUCT_CALL)
1231 #endif /* YYBTYACC */
1232 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1233 YYDESTRUCT_CALL("error: discarding state",
1234 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1236 YYDESTRUCT_CALL("error: discarding state",
1237 yystos[*yystack.s_mark], yystack.l_mark);
1238 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1239 #endif /* defined(YYDESTRUCT_CALL) */
1242 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1250 if (yychar == YYEOF) goto yyabort;
1254 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1255 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1256 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1259 #if defined(YYDESTRUCT_CALL)
1262 #endif /* YYBTYACC */
1263 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1264 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1266 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1267 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1268 #endif /* defined(YYDESTRUCT_CALL) */
1278 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1279 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1280 #ifdef YYSTYPE_TOSTRING
1283 #endif /* YYBTYACC */
1288 for (i = yym; i > 0; i--)
1290 if (i != yym) fputs(", ", stderr);
1291 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1292 yystack.l_mark[1-i]), stderr);
1297 fputc('\n', stderr);
1301 yyval = yystack.l_mark[1-yym];
1303 memset(&yyval, 0, sizeof yyval);
1304 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1306 /* Perform position reduction */
1307 memset(&yyloc, 0, sizeof(yyloc));
1310 #endif /* YYBTYACC */
1312 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1313 /* just in case YYERROR is invoked within the action, save
1314 the start of the rhs as the error start position */
1315 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1324 (void) printf("%15.8f\n", yystack.l_mark[-1].dval);
1330 (void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[-1].vval.lo, yystack.l_mark[-1].vval.hi);
1336 dreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].dval;
1342 vreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].vval;
1354 yyval.dval = dreg[yystack.l_mark[0].ival];
1360 yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval;
1366 yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval;
1372 yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval;
1378 yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval;
1384 yyval.dval = -yystack.l_mark[0].dval;
1390 yyval.dval = yystack.l_mark[-1].dval;
1396 yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval;
1402 yyval.vval.lo = yystack.l_mark[-3].dval;
1403 yyval.vval.hi = yystack.l_mark[-1].dval;
1404 if ( yyval.vval.lo > yyval.vval.hi )
1406 (void) printf("interval out of order\n");
1414 yyval.vval = vreg[yystack.l_mark[0].ival];
1420 yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi;
1421 yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo;
1427 yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi;
1428 yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo;
1434 yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo;
1435 yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi;
1441 yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo;
1442 yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi;
1448 yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
1454 yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
1460 if (dcheck(yystack.l_mark[0].vval)) YYERROR;
1461 yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
1467 if (dcheck ( yystack.l_mark[0].vval )) YYERROR;
1468 yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
1474 yyval.vval.hi = -yystack.l_mark[0].vval.lo;
1475 yyval.vval.lo = -yystack.l_mark[0].vval.hi;
1481 yyval.vval = yystack.l_mark[-1].vval;
1484 #line 1485 "calc1.tab.c"
1488 yystack.s_mark -= yym;
1489 yystate = *yystack.s_mark;
1490 yystack.l_mark -= yym;
1491 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1492 yystack.p_mark -= yym;
1495 if (yystate == 0 && yym == 0)
1500 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1501 #ifdef YYSTYPE_TOSTRING
1504 #endif /* YYBTYACC */
1505 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1507 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1511 *++yystack.s_mark = YYFINAL;
1512 *++yystack.l_mark = yyval;
1513 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1514 *++yystack.p_mark = yyloc;
1522 /* we're currently re-reading tokens */
1524 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1532 /* in trial mode; save scanner results for future parse attempts */
1533 if (yylvp == yylvlim)
1534 { /* Enlarge lexical value queue */
1535 size_t p = (size_t) (yylvp - yylvals);
1536 size_t s = (size_t) (yylvlim - yylvals);
1538 s += YYLVQUEUEGROWTH;
1539 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1541 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1543 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1544 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1547 yylvp = yylve = yylvals + p;
1548 yylvlim = yylvals + s;
1549 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1550 yylpp = yylpe = yylpsns + p;
1551 yylplim = yylpsns + s;
1553 yylexp = yylexemes + p;
1555 *yylexp = (YYINT) YYLEX;
1558 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1565 /* normal operation, no conflict encountered */
1566 #endif /* YYBTYACC */
1570 #endif /* YYBTYACC */
1571 if (yychar < 0) yychar = YYEOF;
1575 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1576 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1577 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1581 if (yychar == YYEOF) goto yyaccept;
1584 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1585 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1586 yystate = yytable[yyn];
1588 yystate = yydgoto[yym];
1592 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1593 #ifdef YYSTYPE_TOSTRING
1596 #endif /* YYBTYACC */
1597 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1599 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1602 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1603 *++yystack.s_mark = (YYINT) yystate;
1604 *++yystack.l_mark = yyval;
1605 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1606 *++yystack.p_mark = yyloc;
1611 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1613 if (yypath) YYABORT;
1616 YYParseState *save = yyps->save;
1617 yyps->save = save->save;
1618 save->save = yypath;
1623 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1624 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1628 yyFreeState(yyerrctx);
1631 yylvp = yylvals + yypath->lexeme;
1632 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1633 yylpp = yylpsns + yypath->lexeme;
1635 yylexp = yylexemes + yypath->lexeme;
1637 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1638 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1639 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1640 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1641 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1642 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1643 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1645 yystate = yypath->state;
1647 #endif /* YYBTYACC */
1650 YYERROR_CALL("yacc stack overflow");
1654 YYERROR_CALL("memory exhausted");
1656 #endif /* YYBTYACC */
1666 if (yyps->save) goto yyvalid;
1667 #endif /* YYBTYACC */
1671 #if defined(YYDESTRUCT_CALL)
1672 if (yychar != YYEOF && yychar != YYEMPTY)
1673 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1674 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1676 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1677 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1681 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1684 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1685 YYDESTRUCT_CALL("cleanup: discarding state",
1686 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1688 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1689 YYDESTRUCT_CALL("cleanup: discarding state",
1690 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1691 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1693 #endif /* defined(YYDESTRUCT_CALL) */
1698 yyFreeState(yyerrctx);
1703 YYParseState *save = yyps;
1710 YYParseState *save = yypath;
1711 yypath = save->save;
1715 #endif /* YYBTYACC */
1716 yyfreestack(&yystack);