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);
806 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
808 #endif /* YYBTYACC */
817 memset(&yystack, 0, sizeof(yystack));
820 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
821 yystack.s_mark = yystack.s_base;
822 yystack.l_mark = yystack.l_base;
823 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
824 yystack.p_mark = yystack.p_base;
830 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
837 /* we're currently re-reading tokens */
839 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
847 /* in trial mode; save scanner results for future parse attempts */
848 if (yylvp == yylvlim)
849 { /* Enlarge lexical value queue */
850 size_t p = (size_t) (yylvp - yylvals);
851 size_t s = (size_t) (yylvlim - yylvals);
853 s += YYLVQUEUEGROWTH;
854 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL) goto yyenomem;
855 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
856 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
857 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
859 yylvp = yylve = yylvals + p;
860 yylvlim = yylvals + s;
861 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
862 yylpp = yylpe = yylpsns + p;
863 yylplim = yylpsns + s;
865 yylexp = yylexemes + p;
867 *yylexp = (YYINT) YYLEX;
870 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
877 /* normal operation, no conflict encountered */
878 #endif /* YYBTYACC */
882 #endif /* YYBTYACC */
883 if (yychar < 0) yychar = YYEOF;
887 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
888 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
889 YYDEBUGSTR, yydepth, yystate, yychar, yys);
890 #ifdef YYSTYPE_TOSTRING
893 #endif /* YYBTYACC */
894 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
902 /* Do we have a conflict? */
903 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
904 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
913 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
914 YYDEBUGSTR, yydepth, yystate);
916 /* Switch to the next conflict context */
921 if (save->state != yystate) YYABORT;
928 /* Unresolved conflict - start/continue trial parse */
933 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
935 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
937 fputs("Starting trial parse.\n", stderr);
940 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
941 if (save == NULL) goto yyenomem;
942 save->save = yyps->save;
943 save->state = yystate;
944 save->errflag = yyerrflag;
945 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
946 memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
947 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
948 memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
949 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
950 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
951 memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
954 if (yyctable[ctry] == -1)
957 if (yydebug && yychar >= YYEOF)
958 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
963 if (yyps->save == NULL)
965 /* If this is a first conflict in the stack, start saving lexemes */
968 yylexemes = malloc((YYLVQUEUEGROWTH) * sizeof(YYINT));
969 if (yylexemes == NULL) goto yyenomem;
970 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
971 if (yylvals == NULL) goto yyenomem;
972 yylvlim = yylvals + YYLVQUEUEGROWTH;
973 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
974 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
975 if (yylpsns == NULL) goto yyenomem;
976 yylplim = yylpsns + YYLVQUEUEGROWTH;
981 yylvp = yylve = yylvals;
982 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
983 yylpp = yylpe = yylpsns;
989 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
992 *yylexp = (YYINT) yychar;
1000 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1006 save->lexeme = (int) (yylvp - yylvals);
1009 if (yytable[yyn] == ctry)
1013 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1014 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
1019 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1024 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
1026 yystate = yyctable[ctry];
1027 *++yystack.s_mark = (YYINT) yystate;
1028 *++yystack.l_mark = yylval;
1029 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1030 *++yystack.p_mark = yylloc;
1033 if (yyerrflag > 0) --yyerrflag;
1038 yyn = yyctable[ctry];
1041 } /* End of code dealing with conflicts */
1042 #endif /* YYBTYACC */
1043 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1044 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1048 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1049 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
1051 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1052 yystate = yytable[yyn];
1053 *++yystack.s_mark = yytable[yyn];
1054 *++yystack.l_mark = yylval;
1055 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1056 *++yystack.p_mark = yylloc;
1059 if (yyerrflag > 0) --yyerrflag;
1062 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1063 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1068 if (yyerrflag != 0) goto yyinrecovery;
1073 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1076 /* explicit YYERROR from an action -- pop the rhs of the rule reduced
1077 * before looking for error recovery */
1078 yystack.s_mark -= yym;
1079 yystate = *yystack.s_mark;
1080 yystack.l_mark -= yym;
1081 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1082 yystack.p_mark -= yym;
1090 YYParseState *save = yyps->save;
1093 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
1094 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
1095 (int)(yylvp - yylvals - yyps->save->lexeme));
1097 /* Memorize most forward-looking error state in case it's really an error. */
1098 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
1100 /* Free old saved error context state */
1101 if (yyerrctx) yyFreeState(yyerrctx);
1102 /* Create and fill out new saved error context state */
1103 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1104 if (yyerrctx == NULL) goto yyenomem;
1105 yyerrctx->save = yyps->save;
1106 yyerrctx->state = yystate;
1107 yyerrctx->errflag = yyerrflag;
1108 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1109 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1110 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1111 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1112 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1113 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1114 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1116 yyerrctx->lexeme = (int) (yylvp - yylvals);
1118 yylvp = yylvals + save->lexeme;
1119 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1120 yylpp = yylpsns + save->lexeme;
1122 yylexp = yylexemes + save->lexeme;
1124 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1125 memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1126 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1127 memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1128 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1129 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1130 memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1132 ctry = ++save->ctry;
1133 yystate = save->state;
1134 /* We tried shift, try reduce now */
1135 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1136 yyps->save = save->save;
1140 /* Nothing left on the stack -- error */
1145 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1148 /* Restore state as it was in the most forward-advanced error */
1149 yylvp = yylvals + yyerrctx->lexeme;
1150 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1151 yylpp = yylpsns + yyerrctx->lexeme;
1153 yylexp = yylexemes + yyerrctx->lexeme;
1154 yychar = yylexp[-1];
1156 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1159 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1160 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1161 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1162 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1163 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1164 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1165 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1167 yystate = yyerrctx->state;
1168 yyFreeState(yyerrctx);
1173 if (yynewerrflag == 0) goto yyinrecovery;
1174 #endif /* YYBTYACC */
1176 YYERROR_CALL("syntax error");
1177 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1178 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1182 goto yyerrlab; /* redundant goto avoids 'unused label' warning */
1193 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1194 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1198 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1199 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1201 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1202 yystate = yytable[yyn];
1203 *++yystack.s_mark = yytable[yyn];
1204 *++yystack.l_mark = yylval;
1205 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1206 /* lookahead position is error end position */
1207 yyerror_loc_range[1] = yylloc;
1208 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1209 *++yystack.p_mark = yyloc;
1217 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1218 YYDEBUGSTR, yydepth, *yystack.s_mark);
1220 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1221 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1222 /* the current TOS position is the error start position */
1223 yyerror_loc_range[0] = *yystack.p_mark;
1225 #if defined(YYDESTRUCT_CALL)
1228 #endif /* YYBTYACC */
1229 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1230 YYDESTRUCT_CALL("error: discarding state",
1231 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1233 YYDESTRUCT_CALL("error: discarding state",
1234 yystos[*yystack.s_mark], yystack.l_mark);
1235 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1236 #endif /* defined(YYDESTRUCT_CALL) */
1239 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1247 if (yychar == YYEOF) goto yyabort;
1251 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1252 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1253 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1256 #if defined(YYDESTRUCT_CALL)
1259 #endif /* YYBTYACC */
1260 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1261 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1263 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1264 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1265 #endif /* defined(YYDESTRUCT_CALL) */
1275 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1276 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1277 #ifdef YYSTYPE_TOSTRING
1280 #endif /* YYBTYACC */
1285 for (i = yym; i > 0; i--)
1287 if (i != yym) fputs(", ", stderr);
1288 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1289 yystack.l_mark[1-i]), stderr);
1294 fputc('\n', stderr);
1298 yyval = yystack.l_mark[1-yym];
1300 memset(&yyval, 0, sizeof yyval);
1301 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1303 /* Perform position reduction */
1304 memset(&yyloc, 0, sizeof(yyloc));
1307 #endif /* YYBTYACC */
1309 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1310 /* just in case YYERROR is invoked within the action, save
1311 the start of the rhs as the error start position */
1312 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1321 (void) printf("%15.8f\n", yystack.l_mark[-1].dval);
1327 (void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[-1].vval.lo, yystack.l_mark[-1].vval.hi);
1333 dreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].dval;
1339 vreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].vval;
1351 yyval.dval = dreg[yystack.l_mark[0].ival];
1357 yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval;
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[0].dval;
1387 yyval.dval = yystack.l_mark[-1].dval;
1393 yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval;
1399 yyval.vval.lo = yystack.l_mark[-3].dval;
1400 yyval.vval.hi = yystack.l_mark[-1].dval;
1401 if ( yyval.vval.lo > yyval.vval.hi )
1403 (void) printf("interval out of order\n");
1411 yyval.vval = vreg[yystack.l_mark[0].ival];
1417 yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi;
1418 yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo;
1424 yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi;
1425 yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo;
1431 yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo;
1432 yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi;
1438 yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo;
1439 yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi;
1445 yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
1451 yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
1457 if (dcheck(yystack.l_mark[0].vval)) YYERROR;
1458 yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
1464 if (dcheck ( yystack.l_mark[0].vval )) YYERROR;
1465 yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
1471 yyval.vval.hi = -yystack.l_mark[0].vval.lo;
1472 yyval.vval.lo = -yystack.l_mark[0].vval.hi;
1478 yyval.vval = yystack.l_mark[-1].vval;
1481 #line 1482 "calc1.tab.c"
1485 yystack.s_mark -= yym;
1486 yystate = *yystack.s_mark;
1487 yystack.l_mark -= yym;
1488 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1489 yystack.p_mark -= yym;
1492 if (yystate == 0 && yym == 0)
1497 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1498 #ifdef YYSTYPE_TOSTRING
1501 #endif /* YYBTYACC */
1502 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1504 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1508 *++yystack.s_mark = YYFINAL;
1509 *++yystack.l_mark = yyval;
1510 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1511 *++yystack.p_mark = yyloc;
1519 /* we're currently re-reading tokens */
1521 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1529 /* in trial mode; save scanner results for future parse attempts */
1530 if (yylvp == yylvlim)
1531 { /* Enlarge lexical value queue */
1532 size_t p = (size_t) (yylvp - yylvals);
1533 size_t s = (size_t) (yylvlim - yylvals);
1535 s += YYLVQUEUEGROWTH;
1536 if ((yylexemes = realloc(yylexemes, s * sizeof(YYINT))) == NULL)
1538 if ((yylvals = realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1540 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1541 if ((yylpsns = realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1544 yylvp = yylve = yylvals + p;
1545 yylvlim = yylvals + s;
1546 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1547 yylpp = yylpe = yylpsns + p;
1548 yylplim = yylpsns + s;
1550 yylexp = yylexemes + p;
1552 *yylexp = (YYINT) YYLEX;
1555 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1562 /* normal operation, no conflict encountered */
1563 #endif /* YYBTYACC */
1567 #endif /* YYBTYACC */
1568 if (yychar < 0) yychar = YYEOF;
1572 if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
1573 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)\n",
1574 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1578 if (yychar == YYEOF) goto yyaccept;
1581 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1582 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1583 yystate = yytable[yyn];
1585 yystate = yydgoto[yym];
1589 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1590 #ifdef YYSTYPE_TOSTRING
1593 #endif /* YYBTYACC */
1594 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1596 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1599 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1600 *++yystack.s_mark = (YYINT) yystate;
1601 *++yystack.l_mark = yyval;
1602 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1603 *++yystack.p_mark = yyloc;
1608 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1610 if (yypath) YYABORT;
1613 YYParseState *save = yyps->save;
1614 yyps->save = save->save;
1615 save->save = yypath;
1620 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1621 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1625 yyFreeState(yyerrctx);
1628 yylvp = yylvals + yypath->lexeme;
1629 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1630 yylpp = yylpsns + yypath->lexeme;
1632 yylexp = yylexemes + yypath->lexeme;
1634 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1635 memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(YYINT));
1636 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1637 memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1638 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1639 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1640 memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1642 yystate = yypath->state;
1644 #endif /* YYBTYACC */
1647 YYERROR_CALL("yacc stack overflow");
1651 YYERROR_CALL("memory exhausted");
1653 #endif /* YYBTYACC */
1663 if (yyps->save) goto yyvalid;
1664 #endif /* YYBTYACC */
1668 #if defined(YYDESTRUCT_CALL)
1669 if (yychar != YYEOF && yychar != YYEMPTY)
1670 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1671 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1673 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1674 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1678 #if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1681 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1682 YYDESTRUCT_CALL("cleanup: discarding state",
1683 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1685 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1686 YYDESTRUCT_CALL("cleanup: discarding state",
1687 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1688 #endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1690 #endif /* defined(YYDESTRUCT_CALL) */
1695 yyFreeState(yyerrctx);
1700 YYParseState *save = yyps;
1707 YYParseState *save = yypath;
1708 yypath = save->save;
1712 #endif /* YYBTYACC */
1713 yyfreestack(&yystack);