1/* original parser id follows */
2/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
3/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
4
5#define YYBYACC 1
6#define YYMAJOR 1
7#define YYMINOR 9
8#define YYCHECK "yyyymmdd"
9
10#define YYEMPTY (-1)
11#define yyclearin (yychar = YYEMPTY)
12#define yyerrok (yyerrflag = 0)
13#define YYRECOVERING() (yyerrflag != 0)
14#define YYENOMEM (-2)
15#define YYEOF 0
16#undef YYBTYACC
17#define YYBTYACC 1
18#define YYDEBUGSTR (yytrial ? YYPREFIX "debug(trial)" : YYPREFIX "debug")
19
20#ifndef yyparse
21#define yyparse calc1_parse
22#endif /* yyparse */
23
24#ifndef yylex
25#define yylex calc1_lex
26#endif /* yylex */
27
28#ifndef yyerror
29#define yyerror calc1_error
30#endif /* yyerror */
31
32#ifndef yychar
33#define yychar calc1_char
34#endif /* yychar */
35
36#ifndef yyval
37#define yyval calc1_val
38#endif /* yyval */
39
40#ifndef yylval
41#define yylval calc1_lval
42#endif /* yylval */
43
44#ifndef yydebug
45#define yydebug calc1_debug
46#endif /* yydebug */
47
48#ifndef yynerrs
49#define yynerrs calc1_nerrs
50#endif /* yynerrs */
51
52#ifndef yyerrflag
53#define yyerrflag calc1_errflag
54#endif /* yyerrflag */
55
56#ifndef yylhs
57#define yylhs calc1_lhs
58#endif /* yylhs */
59
60#ifndef yylen
61#define yylen calc1_len
62#endif /* yylen */
63
64#ifndef yydefred
65#define yydefred calc1_defred
66#endif /* yydefred */
67
68#ifndef yystos
69#define yystos calc1_stos
70#endif /* yystos */
71
72#ifndef yydgoto
73#define yydgoto calc1_dgoto
74#endif /* yydgoto */
75
76#ifndef yysindex
77#define yysindex calc1_sindex
78#endif /* yysindex */
79
80#ifndef yyrindex
81#define yyrindex calc1_rindex
82#endif /* yyrindex */
83
84#ifndef yygindex
85#define yygindex calc1_gindex
86#endif /* yygindex */
87
88#ifndef yytable
89#define yytable calc1_table
90#endif /* yytable */
91
92#ifndef yycheck
93#define yycheck calc1_check
94#endif /* yycheck */
95
96#ifndef yyname
97#define yyname calc1_name
98#endif /* yyname */
99
100#ifndef yyrule
101#define yyrule calc1_rule
102#endif /* yyrule */
103
104#if YYBTYACC
105
106#ifndef yycindex
107#define yycindex calc1_cindex
108#endif /* yycindex */
109
110#ifndef yyctable
111#define yyctable calc1_ctable
112#endif /* yyctable */
113
114#endif /* YYBTYACC */
115
116#define YYPREFIX "calc1_"
117
118#define YYPURE 1
119
120#line 3 "btyacc_calc1.y"
121
122/* http://dinosaur.compilertools.net/yacc/index.html */
123
124#include <stdlib.h>
125#include <stdio.h>
126#include <ctype.h>
127#include <math.h>
128
129typedef struct interval
130{
131 double lo, hi;
132}
133INTERVAL;
134
135INTERVAL vmul(double, double, INTERVAL);
136INTERVAL vdiv(double, double, INTERVAL);
137
138int dcheck(INTERVAL);
139
140double dreg[26];
141INTERVAL vreg[26];
142
143#line 29 "btyacc_calc1.y"
144#ifdef YYSTYPE
145#undef YYSTYPE_IS_DECLARED
146#define YYSTYPE_IS_DECLARED 1
147#endif
148#ifndef YYSTYPE_IS_DECLARED
149#define YYSTYPE_IS_DECLARED 1
150typedef union
151{
152 int ival;
153 double dval;
154 INTERVAL vval;
155} YYSTYPE;
156#endif /* !YYSTYPE_IS_DECLARED */
157#line 158 "btyacc_calc1.tab.c"
158
159/* compatibility with bison */
160#ifdef YYPARSE_PARAM
161/* compatibility with FreeBSD */
162# ifdef YYPARSE_PARAM_TYPE
163# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
164# else
165# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
166# endif
167#else
168# define YYPARSE_DECL() yyparse(void)
169#endif
170
171/* Parameters sent to lex. */
172#ifdef YYLEX_PARAM
173# ifdef YYLEX_PARAM_TYPE
174# define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
175# else
176# define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
177# endif
178# define YYLEX yylex(&yylval, YYLEX_PARAM)
179#else
180# define YYLEX_DECL() yylex(YYSTYPE *yylval)
181# define YYLEX yylex(&yylval)
182#endif
183
184/* Parameters sent to yyerror. */
185#ifndef YYERROR_DECL
186#define YYERROR_DECL() yyerror(const char *s)
187#endif
188#ifndef YYERROR_CALL
189#define YYERROR_CALL(msg) yyerror(msg)
190#endif
191
192extern int YYPARSE_DECL();
193
194#define DREG 257
195#define VREG 258
196#define CONST 259
197#define UMINUS 260
198#define YYERRCODE 256
199typedef short YYINT;
200static const YYINT calc1_lhs[] = { -1,
201 0, 0, 0, 3, 3, 3, 3, 1, 1, 1,
202 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
203 2, 2, 2, 2, 2, 2, 2, 2,
204};
205static const YYINT calc1_len[] = { 2,
206 0, 3, 3, 1, 1, 3, 3, 1, 1, 3,
207 3, 3, 3, 2, 3, 1, 5, 1, 3, 3,
208 3, 3, 3, 3, 3, 3, 2, 3,
209};
210static const YYINT calc1_defred[] = { 1,
211 0, 0, 0, 0, 8, 0, 0, 0, 0, 0,
212 3, 0, 0, 9, 18, 0, 27, 0, 0, 0,
213 0, 0, 0, 0, 0, 0, 0, 2, 0, 0,
214 0, 0, 0, 15, 0, 28, 0, 0, 0, 0,
215 0, 24, 0, 26, 0, 0, 23, 25, 14, 0,
216 0, 0, 0, 0, 0, 0, 0, 12, 13, 17,
217};
218static const YYINT calc1_stos[] = { 0,
219 262, 256, 257, 258, 259, 45, 40, 263, 264, 265,
220 10, 61, 61, 257, 258, 263, 264, 263, 264, 43,
221 45, 42, 47, 43, 45, 42, 47, 10, 45, 40,
222 263, 263, 264, 41, 44, 41, 263, 264, 263, 264,
223 263, 264, 263, 264, 264, 264, 264, 264, 263, 263,
224 43, 45, 42, 47, 263, 263, 263, 263, 263, 41,
225};
226static const YYINT calc1_dgoto[] = { 1,
227 32, 9, 10,
228};
229static const YYINT calc1_sindex[] = { 0,
230 -40, -9, -59, -54, 0, -37, -37, 0, 82, 4,
231 0, -34, -37, 0, 0, 0, 0, -31, -25, -37,
232 -37, -37, -37, -37, -37, -37, -37, 0, -34, -34,
233 132, 0, 82, 0, -34, 0, 0, -12, 0, -12,
234 0, 0, 0, 0, -12, -12, 0, 0, 0, 112,
235 -34, -34, -34, -34, 119, -11, -11, 0, 0, 0,
236};
237static const YYINT calc1_rindex[] = { 0,
238 0, 0, 51, 58, 0, 0, 0, 0, 11, 0,
239 0, 0, 0, 0, 0, -16, 0, 0, 0, 0,
240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
241 19, 9, 27, 0, 0, 0, -5, 41, -4, 77,
242 -2, 0, 8, 0, 78, 85, 0, 0, 0, 0,
243 0, 0, 0, 0, 0, 92, 99, 0, 0, 0,
244};
245#if YYBTYACC
246static const YYINT calc1_cindex[] = { 0,
247 0, 0, 0, 0, 0, 0, 0, 65, 0, 0,
248 0, 0, 0, 0, 0, 2, 0, 126, 0, 0,
249 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
250 0, 138, 0, 0, 0, 0, 17, 0, 24, 0,
251 31, 0, 38, 0, 0, 0, 0, 0, 0, 0,
252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
253};
254#endif
255static const YYINT calc1_gindex[] = { 0,
256 3, 125, 0,
257};
258#define YYTABLESIZE 225
259static const YYINT calc1_table[] = { 7,
260 11, 12, 7, 8, 6, 30, 13, 6, 16, 18,
261 29, 14, 35, 28, 31, 36, 26, 24, 16, 25,
262 5, 27, 37, 39, 41, 43, 20, 14, 6, 26,
263 53, 49, 50, 23, 27, 54, 7, 55, 10, 11,
264 26, 12, 14, 14, 14, 0, 14, 29, 14, 16,
265 20, 13, 0, 56, 57, 58, 59, 20, 6, 20,
266 9, 20, 0, 9, 23, 6, 23, 18, 23, 0,
267 9, 26, 26, 26, 11, 26, 0, 26, 29, 29,
268 29, 20, 29, 20, 29, 20, 22, 19, 0, 0,
269 0, 0, 9, 9, 21, 9, 0, 9, 0, 18,
270 18, 10, 18, 0, 18, 0, 6, 0, 11, 3,
271 0, 9, 0, 0, 0, 0, 0, 22, 19, 22,
272 19, 22, 19, 26, 24, 21, 25, 21, 27, 21,
273 17, 19, 10, 0, 10, 0, 10, 33, 0, 11,
274 0, 11, 0, 11, 38, 40, 42, 44, 45, 46,
275 47, 48, 34, 53, 51, 0, 52, 0, 54, 60,
276 53, 51, 0, 52, 0, 54, 18, 6, 0, 0,
277 3, 0, 9, 53, 51, 0, 52, 0, 54, 6,
278 0, 0, 3, 0, 9, 0, 0, 0, 0, 0,
279 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
280 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
281 0, 0, 0, 0, 0, 2, 3, 4, 5, 14,
282 15, 5, 14, 0, 5,
283};
284static const YYINT calc1_check[] = { 40,
285 10, 61, 40, 1, 45, 40, 61, 45, 6, 7,
286 45, 10, 44, 10, 12, 41, 42, 43, 10, 45,
287 10, 47, 20, 21, 22, 23, 10, 44, 10, 42,
288 42, 29, 30, 10, 47, 47, 10, 35, 44, 44,
289 10, 44, 41, 42, 43, -1, 45, 10, 47, 41,
290 10, 44, -1, 51, 52, 53, 54, 41, 42, 43,
291 10, 45, -1, 47, 41, 42, 43, 10, 45, -1,
292 47, 41, 42, 43, 10, 45, -1, 47, 41, 42,
293 43, 41, 45, 43, 47, 45, 10, 10, -1, -1,
294 -1, -1, 42, 43, 10, 45, -1, 47, -1, 42,
295 43, 10, 45, -1, 47, -1, 42, 43, 10, 45,
296 -1, 47, -1, -1, -1, -1, -1, 41, 41, 43,
297 43, 45, 45, 42, 43, 41, 45, 43, 47, 45,
298 6, 7, 41, -1, 43, -1, 45, 13, -1, 41,
299 -1, 43, -1, 45, 20, 21, 22, 23, 24, 25,
300 26, 27, 41, 42, 43, -1, 45, -1, 47, 41,
301 42, 43, -1, 45, -1, 47, 41, 42, 43, -1,
302 45, -1, 47, 42, 43, -1, 45, -1, 47, 42,
303 43, -1, 45, -1, 47, -1, -1, -1, -1, -1,
304 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
305 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
306 -1, -1, -1, -1, -1, 256, 257, 258, 259, 257,
307 258, 259, 257, -1, 259,
308};
309#if YYBTYACC
310static const YYINT calc1_ctable[] = { 20,
311 16, -1, 21, 16, -1, 22, 16, -1, 23, 16,
312 -1, 4, 16, -1, 14, 16, -1, 34, 16, -1,
313 10, 16, -1, 11, 16, -1, 12, 16, -1, 13,
314 16, -1,
315};
316#endif
317#define YYFINAL 1
318#ifndef YYDEBUG
319#define YYDEBUG 0
320#endif
321#define YYMAXTOKEN 260
322#define YYUNDFTOKEN 266
323#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
324#if YYDEBUG
325static const char *const calc1_name[] = {
326
327"$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,
3280,0,0,0,0,0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0,
3290,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3300,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3310,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3320,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3330,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
334"error","DREG","VREG","CONST","UMINUS","$accept","lines","dexp","vexp","line",
335"illegal-symbol",
336};
337static const char *const calc1_rule[] = {
338"$accept : lines",
339"lines :",
340"lines : lines line '\\n'",
341"lines : lines error '\\n'",
342"line : dexp",
343"line : vexp",
344"line : DREG '=' dexp",
345"line : VREG '=' vexp",
346"dexp : CONST",
347"dexp : DREG",
348"dexp : dexp '+' dexp",
349"dexp : dexp '-' dexp",
350"dexp : dexp '*' dexp",
351"dexp : dexp '/' dexp",
352"dexp : '-' dexp",
353"dexp : '(' dexp ')'",
354"vexp : dexp",
355"vexp : '(' dexp ',' dexp ')'",
356"vexp : VREG",
357"vexp : vexp '+' vexp",
358"vexp : dexp '+' vexp",
359"vexp : vexp '-' vexp",
360"vexp : dexp '-' vexp",
361"vexp : vexp '*' vexp",
362"vexp : dexp '*' vexp",
363"vexp : vexp '/' vexp",
364"vexp : dexp '/' vexp",
365"vexp : '-' vexp",
366"vexp : '(' vexp ')'",
367
368};
369#endif
370
371int yydebug;
372int yynerrs;
373
374#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
375#ifndef YYLLOC_DEFAULT
376#define YYLLOC_DEFAULT(loc, rhs, n) \
377do \
378{ \
379 if (n == 0) \
380 { \
381 (loc).first_line = ((rhs)[-1]).last_line; \
382 (loc).first_column = ((rhs)[-1]).last_column; \
383 (loc).last_line = ((rhs)[-1]).last_line; \
384 (loc).last_column = ((rhs)[-1]).last_column; \
385 } \
386 else \
387 { \
388 (loc).first_line = ((rhs)[ 0 ]).first_line; \
389 (loc).first_column = ((rhs)[ 0 ]).first_column; \
390 (loc).last_line = ((rhs)[n-1]).last_line; \
391 (loc).last_column = ((rhs)[n-1]).last_column; \
392 } \
393} while (0)
394#endif /* YYLLOC_DEFAULT */
395#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
396#if YYBTYACC
397
398#ifndef YYLVQUEUEGROWTH
399#define YYLVQUEUEGROWTH 32
400#endif
401#endif /* YYBTYACC */
402
403/* define the initial stack-sizes */
404#ifdef YYSTACKSIZE
405#undef YYMAXDEPTH
406#define YYMAXDEPTH YYSTACKSIZE
407#else
408#ifdef YYMAXDEPTH
409#define YYSTACKSIZE YYMAXDEPTH
410#else
411#define YYSTACKSIZE 10000
412#define YYMAXDEPTH 10000
413#endif
414#endif
415
416#ifndef YYINITSTACKSIZE
417#define YYINITSTACKSIZE 200
418#endif
419
420typedef struct {
421 unsigned stacksize;
422 short *s_base;
423 short *s_mark;
424 short *s_last;
425 YYSTYPE *l_base;
426 YYSTYPE *l_mark;
427#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
428 YYLTYPE *p_base;
429 YYLTYPE *p_mark;
430#endif
431} YYSTACKDATA;
432#if YYBTYACC
433
434struct YYParseState_s
435{
436 struct YYParseState_s *save; /* Previously saved parser state */
437 YYSTACKDATA yystack; /* saved parser stack */
438 int state; /* saved parser state */
439 int errflag; /* saved error recovery status */
440 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
441 YYINT ctry; /* saved index in yyctable[] for this conflict */
442};
443typedef struct YYParseState_s YYParseState;
444#endif /* YYBTYACC */
445#line 174 "btyacc_calc1.y"
446 /* beginning of subroutines section */
447
448int
449main (void)
450{
451 while(!feof(stdin)) {
452 yyparse();
453 }
454 return 0;
455}
456
457#define BSZ 50 /* buffer size for floating point numbers */
458
459static void
460YYERROR_DECL()
461{
462 fprintf(stderr, "%s\n", s);
463}
464
465 /* lexical analysis */
466
467static int
468YYLEX_DECL()
469{
470 int c;
471
472 while ((c = getchar()) == ' ')
473 { /* skip over blanks */
474 }
475
476 if (isupper(c))
477 {
478#if YYPURE
479 (*yylval).ival = c - 'A';
480#else
481 yylval.ival = c - 'A';
482#endif
483 return (VREG);
484 }
485 if (islower(c))
486 {
487#if YYPURE
488 (*yylval).ival = c - 'a';
489#else
490 yylval.ival = c - 'a';
491#endif
492 return (DREG);
493 }
494
495 if (isdigit(c) || c == '.')
496 {
497 /* gobble up digits, points, exponents */
498 char buf[BSZ + 1], *cp = buf;
499 int dot = 0, expr = 0;
500
501 for (; (cp - buf) < BSZ; ++cp, c = getchar())
502 {
503
504 *cp = (char) c;
505 if (isdigit(c))
506 continue;
507 if (c == '.')
508 {
509 if (dot++ || expr)
510 return ('.'); /* will cause syntax error */
511 continue;
512 }
513
514 if (c == 'e')
515 {
516 if (expr++)
517 return ('e'); /* will cause syntax error */
518 continue;
519 }
520
521 /* end of number */
522 break;
523 }
524 *cp = '\0';
525
526 if ((cp - buf) >= BSZ)
527 printf("constant too long: truncated\n");
528 else
529 ungetc(c, stdin); /* push back last char read */
530#if YYPURE
531 (*yylval).dval = atof(buf);
532#else
533 yylval.dval = atof(buf);
534#endif
535 return (CONST);
536 }
537 return (c);
538}
539
540static INTERVAL
541hilo(double a, double b, double c, double d)
542{
543 /* returns the smallest interval containing a, b, c, and d */
544 /* used by *, / routines */
545 INTERVAL v;
546
547 if (a > b)
548 {
549 v.hi = a;
550 v.lo = b;
551 }
552 else
553 {
554 v.hi = b;
555 v.lo = a;
556 }
557
558 if (c > d)
559 {
560 if (c > v.hi)
561 v.hi = c;
562 if (d < v.lo)
563 v.lo = d;
564 }
565 else
566 {
567 if (d > v.hi)
568 v.hi = d;
569 if (c < v.lo)
570 v.lo = c;
571 }
572 return (v);
573}
574
575INTERVAL
576vmul(double a, double b, INTERVAL v)
577{
578 return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo));
579}
580
581int
582dcheck(INTERVAL v)
583{
584 if (v.hi >= 0. && v.lo <= 0.)
585 {
586 printf("divisor interval contains 0.\n");
587 return (1);
588 }
589 return (0);
590}
591
592INTERVAL
593vdiv(double a, double b, INTERVAL v)
594{
595 return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
596}
597#line 598 "btyacc_calc1.tab.c"
598
599/* For use in generated program */
600#define yydepth (int)(yystack.s_mark - yystack.s_base)
601#if YYBTYACC
602#define yytrial (yyps->save)
603#endif /* YYBTYACC */
604
605#if YYDEBUG
606#include <stdio.h> /* needed for printf */
607#endif
608
609#include <stdlib.h> /* needed for malloc, etc */
610#include <string.h> /* needed for memset */
611
612/* allocate initial stack or double stack size, up to YYMAXDEPTH */
613static int yygrowstack(YYSTACKDATA *data)
614{
615 int i;
616 unsigned newsize;
617 short *newss;
618 YYSTYPE *newvs;
619#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
620 YYLTYPE *newps;
621#endif
622
623 if ((newsize = data->stacksize) == 0)
624 newsize = YYINITSTACKSIZE;
625 else if (newsize >= YYMAXDEPTH)
626 return YYENOMEM;
627 else if ((newsize *= 2) > YYMAXDEPTH)
628 newsize = YYMAXDEPTH;
629
630 i = (int) (data->s_mark - data->s_base);
631 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
632 if (newss == 0)
633 return YYENOMEM;
634
635 data->s_base = newss;
636 data->s_mark = newss + i;
637
638 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
639 if (newvs == 0)
640 return YYENOMEM;
641
642 data->l_base = newvs;
643 data->l_mark = newvs + i;
644
645#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
646 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
647 if (newps == 0)
648 return YYENOMEM;
649
650 data->p_base = newps;
651 data->p_mark = newps + i;
652#endif
653
654 data->stacksize = newsize;
655 data->s_last = data->s_base + newsize - 1;
656
657#if YYDEBUG
658 if (yydebug)
659 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
660#endif
661 return 0;
662}
663
664#if YYPURE || defined(YY_NO_LEAKS)
665static void yyfreestack(YYSTACKDATA *data)
666{
667 free(data->s_base);
668 free(data->l_base);
669#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
670 free(data->p_base);
671#endif
672 memset(data, 0, sizeof(*data));
673}
674#else
675#define yyfreestack(data) /* nothing */
676#endif /* YYPURE || defined(YY_NO_LEAKS) */
677#if YYBTYACC
678
679static YYParseState *
680yyNewState(unsigned size)
681{
682 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
683 if (p == NULL) return NULL;
684
685 p->yystack.stacksize = size;
686 if (size == 0)
687 {
688 p->yystack.s_base = NULL;
689 p->yystack.l_base = NULL;
690#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
691 p->yystack.p_base = NULL;
692#endif
693 return p;
694 }
695 p->yystack.s_base = (short *) malloc(size * sizeof(short));
696 if (p->yystack.s_base == NULL) return NULL;
697 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
698 if (p->yystack.l_base == NULL) return NULL;
699 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
700#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
701 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
702 if (p->yystack.p_base == NULL) return NULL;
703 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
704#endif
705
706 return p;
707}
708
709static void
710yyFreeState(YYParseState *p)
711{
712 yyfreestack(&p->yystack);
713 free(p);
714}
715#endif /* YYBTYACC */
716
717#define YYABORT goto yyabort
718#define YYREJECT goto yyabort
719#define YYACCEPT goto yyaccept
720#define YYERROR goto yyerrlab
721#if YYBTYACC
722#define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
723#define YYVALID_NESTED do { if (yyps->save && \
724 yyps->save->save == 0) goto yyvalid; } while(0)
725#endif /* YYBTYACC */
726
727int
728YYPARSE_DECL()
729{
730 int yyerrflag;
731 int yychar;
732 YYSTYPE yyval;
733 YYSTYPE yylval;
734#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
735 YYLTYPE yyloc; /* position returned by actions */
736 YYLTYPE yylloc; /* position from the lexer */
737#endif
738
739 /* variables for the parser stack */
740 YYSTACKDATA yystack;
741#if YYBTYACC
742
743 /* Current parser state */
744 static YYParseState *yyps = 0;
745
746 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
747 static YYParseState *yypath = 0;
748
749 /* Base of the lexical value queue */
750 static YYSTYPE *yylvals = 0;
751
752 /* Current position at lexical value queue */
753 static YYSTYPE *yylvp = 0;
754
755 /* End position of lexical value queue */
756 static YYSTYPE *yylve = 0;
757
758 /* The last allocated position at the lexical value queue */
759 static YYSTYPE *yylvlim = 0;
760
761#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
762 /* Base of the lexical position queue */
763 static YYLTYPE *yylpsns = 0;
764
765 /* Current position at lexical position queue */
766 static YYLTYPE *yylpp = 0;
767
768 /* End position of lexical position queue */
769 static YYLTYPE *yylpe = 0;
770
771 /* The last allocated position at the lexical position queue */
772 static YYLTYPE *yylplim = 0;
773#endif
774
775 /* Current position at lexical token queue */
776 static short *yylexp = 0;
777
778 static short *yylexemes = 0;
779#endif /* YYBTYACC */
780 int yym, yyn, yystate, yyresult;
781#if YYBTYACC
782 int yynewerrflag;
783 YYParseState *yyerrctx = NULL;
784#endif /* YYBTYACC */
785#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
786 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
787#endif
788#if YYDEBUG
789 const char *yys;
790
791 if ((yys = getenv("YYDEBUG")) != 0)
792 {
793 yyn = *yys;
794 if (yyn >= '0' && yyn <= '9')
795 yydebug = yyn - '0';
796 }
797 if (yydebug)
798 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
799#endif
800
801#if YYBTYACC
802 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
803 yyps->save = 0;
804#endif /* YYBTYACC */
805 yynerrs = 0;
806 yyerrflag = 0;
807 yychar = YYEMPTY;
808 yystate = 0;
809
810#if YYPURE
811 memset(&yystack, 0, sizeof(yystack));
812#endif
813
814 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
815 yystack.s_mark = yystack.s_base;
816 yystack.l_mark = yystack.l_base;
817#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
818 yystack.p_mark = yystack.p_base;
819#endif
820 yystate = 0;
821 *yystack.s_mark = 0;
822
823yyloop:
824 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
825 if (yychar < 0)
826 {
827#if YYBTYACC
828 do {
829 if (yylvp < yylve)
830 {
831 /* we're currently re-reading tokens */
832 yylval = *yylvp++;
833#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
834 yylloc = *yylpp++;
835#endif
836 yychar = *yylexp++;
837 break;
838 }
839 if (yyps->save)
840 {
841 /* in trial mode; save scanner results for future parse attempts */
842 if (yylvp == yylvlim)
843 { /* Enlarge lexical value queue */
844 int p = yylvp - yylvals;
845 int s = yylvlim - yylvals;
846
847 s += YYLVQUEUEGROWTH;
848 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
849 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
850#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
851 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
852#endif
853 yylvp = yylve = yylvals + p;
854 yylvlim = yylvals + s;
855#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
856 yylpp = yylpe = yylpsns + p;
857 yylplim = yylpsns + s;
858#endif
859 yylexp = yylexemes + p;
860 }
861 *yylexp = (short) YYLEX;
862 *yylvp++ = yylval;
863 yylve++;
864#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
865 *yylpp++ = yylloc;
866 yylpe++;
867#endif
868 yychar = *yylexp++;
869 break;
870 }
871 /* normal operation, no conflict encountered */
872#endif /* YYBTYACC */
873 yychar = YYLEX;
874#if YYBTYACC
875 } while (0);
876#endif /* YYBTYACC */
877 if (yychar < 0) yychar = YYEOF;
878 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
879#if YYDEBUG
880 if (yydebug)
881 {
882 yys = yyname[YYTRANSLATE(yychar)];
883 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
884 YYDEBUGSTR, yydepth, yystate, yychar, yys);
885#ifdef YYSTYPE_TOSTRING
886#if YYBTYACC
887 if (!yytrial)
888#endif /* YYBTYACC */
889 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
890#endif
891 fputc('\n', stderr);
892 }
893#endif
894 }
895#if YYBTYACC
896
897 /* Do we have a conflict? */
898 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
899 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
900 {
901 YYINT ctry;
902
903 if (yypath)
904 {
905 YYParseState *save;
906#if YYDEBUG
907 if (yydebug)
908 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
909 YYDEBUGSTR, yydepth, yystate);
910#endif
911 /* Switch to the next conflict context */
912 save = yypath;
913 yypath = save->save;
914 save->save = NULL;
915 ctry = save->ctry;
916 if (save->state != yystate) YYABORT;
917 yyFreeState(save);
918
919 }
920 else
921 {
922
923 /* Unresolved conflict - start/continue trial parse */
924 YYParseState *save;
925#if YYDEBUG
926 if (yydebug)
927 {
928 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
929 if (yyps->save)
930 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
931 else
932 fputs("Starting trial parse.\n", stderr);
933 }
934#endif
935 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
936 if (save == NULL) goto yyenomem;
937 save->save = yyps->save;
938 save->state = yystate;
939 save->errflag = yyerrflag;
940 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
941 memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
942 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
943 memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
944#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
945 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
946 memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
947#endif
948 ctry = yytable[yyn];
949 if (yyctable[ctry] == -1)
950 {
951#if YYDEBUG
952 if (yydebug && yychar >= YYEOF)
953 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
954#endif
955 ctry++;
956 }
957 save->ctry = ctry;
958 if (yyps->save == NULL)
959 {
960 /* If this is a first conflict in the stack, start saving lexemes */
961 if (!yylexemes)
962 {
963 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));
964 if (yylexemes == NULL) goto yyenomem;
965 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
966 if (yylvals == NULL) goto yyenomem;
967 yylvlim = yylvals + YYLVQUEUEGROWTH;
968#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
969 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
970 if (yylpsns == NULL) goto yyenomem;
971 yylplim = yylpsns + YYLVQUEUEGROWTH;
972#endif
973 }
974 if (yylvp == yylve)
975 {
976 yylvp = yylve = yylvals;
977#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
978 yylpp = yylpe = yylpsns;
979#endif
980 yylexp = yylexemes;
981 if (yychar >= YYEOF)
982 {
983 *yylve++ = yylval;
984#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
985 *yylpe++ = yylloc;
986#endif
987 *yylexp = (short) yychar;
988 yychar = YYEMPTY;
989 }
990 }
991 }
992 if (yychar >= YYEOF)
993 {
994 yylvp--;
995#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
996 yylpp--;
997#endif
998 yylexp--;
999 yychar = YYEMPTY;
1000 }
1001 save->lexeme = yylvp - yylvals;
1002 yyps->save = save;
1003 }
1004 if (yytable[yyn] == ctry)
1005 {
1006#if YYDEBUG
1007 if (yydebug)
1008 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1009 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
1010#endif
1011 if (yychar < 0)
1012 {
1013 yylvp++;
1014#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1015 yylpp++;
1016#endif
1017 yylexp++;
1018 }
1019 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
1020 goto yyoverflow;
1021 yystate = yyctable[ctry];
1022 *++yystack.s_mark = (short) yystate;
1023 *++yystack.l_mark = yylval;
1024#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1025 *++yystack.p_mark = yylloc;
1026#endif
1027 yychar = YYEMPTY;
1028 if (yyerrflag > 0) --yyerrflag;
1029 goto yyloop;
1030 }
1031 else
1032 {
1033 yyn = yyctable[ctry];
1034 goto yyreduce;
1035 }
1036 } /* End of code dealing with conflicts */
1037#endif /* YYBTYACC */
1038 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1039 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1040 {
1041#if YYDEBUG
1042 if (yydebug)
1043 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1044 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
1045#endif
1046 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1047 yystate = yytable[yyn];
1048 *++yystack.s_mark = yytable[yyn];
1049 *++yystack.l_mark = yylval;
1050#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1051 *++yystack.p_mark = yylloc;
1052#endif
1053 yychar = YYEMPTY;
1054 if (yyerrflag > 0) --yyerrflag;
1055 goto yyloop;
1056 }
1057 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1058 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1059 {
1060 yyn = yytable[yyn];
1061 goto yyreduce;
1062 }
1063 if (yyerrflag != 0) goto yyinrecovery;
1064#if YYBTYACC
1065
1066 yynewerrflag = 1;
1067 goto yyerrhandler;
1068 goto yyerrlab;
1069
1070yyerrlab:
1071 yynewerrflag = 0;
1072yyerrhandler:
1073 while (yyps->save)
1074 {
1075 int ctry;
1076 YYParseState *save = yyps->save;
1077#if YYDEBUG
1078 if (yydebug)
1079 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
1080 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
1081 (int)(yylvp - yylvals - yyps->save->lexeme));
1082#endif
1083 /* Memorize most forward-looking error state in case it's really an error. */
1084 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
1085 {
1086 /* Free old saved error context state */
1087 if (yyerrctx) yyFreeState(yyerrctx);
1088 /* Create and fill out new saved error context state */
1089 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1090 if (yyerrctx == NULL) goto yyenomem;
1091 yyerrctx->save = yyps->save;
1092 yyerrctx->state = yystate;
1093 yyerrctx->errflag = yyerrflag;
1094 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1095 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1096 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1097 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1098#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1099 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1100 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1101#endif
1102 yyerrctx->lexeme = yylvp - yylvals;
1103 }
1104 yylvp = yylvals + save->lexeme;
1105#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1106 yylpp = yylpsns + save->lexeme;
1107#endif
1108 yylexp = yylexemes + save->lexeme;
1109 yychar = YYEMPTY;
1110 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1111 memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1112 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1113 memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1114#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1115 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1116 memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1117#endif
1118 ctry = ++save->ctry;
1119 yystate = save->state;
1120 /* We tried shift, try reduce now */
1121 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1122 yyps->save = save->save;
1123 save->save = NULL;
1124 yyFreeState(save);
1125
1126 /* Nothing left on the stack -- error */
1127 if (!yyps->save)
1128 {
1129#if YYDEBUG
1130 if (yydebug)
1131 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1132 YYPREFIX, yydepth);
1133#endif
1134 /* Restore state as it was in the most forward-advanced error */
1135 yylvp = yylvals + yyerrctx->lexeme;
1136#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1137 yylpp = yylpsns + yyerrctx->lexeme;
1138#endif
1139 yylexp = yylexemes + yyerrctx->lexeme;
1140 yychar = yylexp[-1];
1141 yylval = yylvp[-1];
1142#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1143 yylloc = yylpp[-1];
1144#endif
1145 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1146 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1147 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1148 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1149#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1150 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1151 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1152#endif
1153 yystate = yyerrctx->state;
1154 yyFreeState(yyerrctx);
1155 yyerrctx = NULL;
1156 }
1157 yynewerrflag = 1;
1158 }
1159 if (yynewerrflag == 0) goto yyinrecovery;
1160#endif /* YYBTYACC */
1161
1162 YYERROR_CALL("syntax error");
1163#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1164 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1165#endif
1166
1167#if !YYBTYACC
1168 goto yyerrlab;
1169yyerrlab:
1170#endif
1171 ++yynerrs;
1172
1173yyinrecovery:
1174 if (yyerrflag < 3)
1175 {
1176 yyerrflag = 3;
1177 for (;;)
1178 {
1179 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1180 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1181 {
1182#if YYDEBUG
1183 if (yydebug)
1184 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1185 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1186#endif
1187 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1188 yystate = yytable[yyn];
1189 *++yystack.s_mark = yytable[yyn];
1190 *++yystack.l_mark = yylval;
1191#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1192 /* lookahead position is error end position */
1193 yyerror_loc_range[1] = yylloc;
1194 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1195 *++yystack.p_mark = yyloc;
1196#endif
1197 goto yyloop;
1198 }
1199 else
1200 {
1201#if YYDEBUG
1202 if (yydebug)
1203 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1204 YYDEBUGSTR, yydepth, *yystack.s_mark);
1205#endif
1206 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1207#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1208 /* the current TOS position is the error start position */
1209 yyerror_loc_range[0] = *yystack.p_mark;
1210#endif
1211#if defined(YYDESTRUCT_CALL)
1212#if YYBTYACC
1213 if (!yytrial)
1214#endif /* YYBTYACC */
1215#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1216 YYDESTRUCT_CALL("error: discarding state",
1217 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1218#else
1219 YYDESTRUCT_CALL("error: discarding state",
1220 yystos[*yystack.s_mark], yystack.l_mark);
1221#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1222#endif /* defined(YYDESTRUCT_CALL) */
1223 --yystack.s_mark;
1224 --yystack.l_mark;
1225#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1226 --yystack.p_mark;
1227#endif
1228 }
1229 }
1230 }
1231 else
1232 {
1233 if (yychar == YYEOF) goto yyabort;
1234#if YYDEBUG
1235 if (yydebug)
1236 {
1237 yys = yyname[YYTRANSLATE(yychar)];
1238 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1239 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1240 }
1241#endif
1242#if defined(YYDESTRUCT_CALL)
1243#if YYBTYACC
1244 if (!yytrial)
1245#endif /* YYBTYACC */
1246#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1247 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1248#else
1249 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1250#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1251#endif /* defined(YYDESTRUCT_CALL) */
1252 yychar = YYEMPTY;
1253 goto yyloop;
1254 }
1255
1256yyreduce:
1257 yym = yylen[yyn];
1258#if YYDEBUG
1259 if (yydebug)
1260 {
1261 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1262 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1263#ifdef YYSTYPE_TOSTRING
1264#if YYBTYACC
1265 if (!yytrial)
1266#endif /* YYBTYACC */
1267 if (yym > 0)
1268 {
1269 int i;
1270 fputc('<', stderr);
1271 for (i = yym; i > 0; i--)
1272 {
1273 if (i != yym) fputs(", ", stderr);
1274 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1275 yystack.l_mark[1-i]), stderr);
1276 }
1277 fputc('>', stderr);
1278 }
1279#endif
1280 fputc('\n', stderr);
1281 }
1282#endif
1283 if (yym > 0)
1284 yyval = yystack.l_mark[1-yym];
1285 else
1286 memset(&yyval, 0, sizeof yyval);
1287#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1288
1289 /* Perform position reduction */
1290 memset(&yyloc, 0, sizeof(yyloc));
1291#if YYBTYACC
1292 if (!yytrial)
1293#endif /* YYBTYACC */
1294 {
1295 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1296 /* just in case YYERROR is invoked within the action, save
1297 the start of the rhs as the error start position */
1298 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1299 }
1300#endif
1301
1302 switch (yyn)
1303 {
1304case 2:
1305#line 51 "btyacc_calc1.y"
1306{YYVALID;}
1307break;
1308case 3:
1309#line 52 "btyacc_calc1.y"
1310{YYVALID;} if (!yytrial)
1311#line 53 "btyacc_calc1.y"
1312{
1313 yyerrok;
1314 }
1315break;
1316case 4:
1317 if (!yytrial)
1318#line 59 "btyacc_calc1.y"
1319 {
1320 (void) printf("%15.8f\n", yystack.l_mark[0].dval);
1321 }
1322break;
1323case 5:
1324 if (!yytrial)
1325#line 63 "btyacc_calc1.y"
1326 {
1327 (void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[0].vval.lo, yystack.l_mark[0].vval.hi);
1328 }
1329break;
1330case 6:
1331 if (!yytrial)
1332#line 67 "btyacc_calc1.y"
1333 {
1334 dreg[yystack.l_mark[-2].ival] = yystack.l_mark[0].dval;
1335 }
1336break;
1337case 7:
1338 if (!yytrial)
1339#line 71 "btyacc_calc1.y"
1340 {
1341 vreg[yystack.l_mark[-2].ival] = yystack.l_mark[0].vval;
1342 }
1343break;
1344case 9:
1345 if (!yytrial)
1346#line 78 "btyacc_calc1.y"
1347 {
1348 yyval.dval = dreg[yystack.l_mark[0].ival];
1349 }
1350break;
1351case 10:
1352 if (!yytrial)
1353#line 82 "btyacc_calc1.y"
1354 {
1355 yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval;
1356 }
1357break;
1358case 11:
1359 if (!yytrial)
1360#line 86 "btyacc_calc1.y"
1361 {
1362 yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval;
1363 }
1364break;
1365case 12:
1366 if (!yytrial)
1367#line 90 "btyacc_calc1.y"
1368 {
1369 yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval;
1370 }
1371break;
1372case 13:
1373 if (!yytrial)
1374#line 94 "btyacc_calc1.y"
1375 {
1376 yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval;
1377 }
1378break;
1379case 14:
1380 if (!yytrial)
1381#line 98 "btyacc_calc1.y"
1382 {
1383 yyval.dval = -yystack.l_mark[0].dval;
1384 }
1385break;
1386case 15:
1387 if (!yytrial)
1388#line 102 "btyacc_calc1.y"
1389 {
1390 yyval.dval = yystack.l_mark[-1].dval;
1391 }
1392break;
1393case 16:
1394 if (!yytrial)
1395#line 108 "btyacc_calc1.y"
1396 {
1397 yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval;
1398 }
1399break;
1400case 17:
1401 if (!yytrial)
1402#line 112 "btyacc_calc1.y"
1403 {
1404 yyval.vval.lo = yystack.l_mark[-3].dval;
1405 yyval.vval.hi = yystack.l_mark[-1].dval;
1406 if ( yyval.vval.lo > yyval.vval.hi )
1407 {
1408 (void) printf("interval out of order\n");
1409 YYERROR;
1410 }
1411 }
1412break;
1413case 18:
1414 if (!yytrial)
1415#line 122 "btyacc_calc1.y"
1416 {
1417 yyval.vval = vreg[yystack.l_mark[0].ival];
1418 }
1419break;
1420case 19:
1421 if (!yytrial)
1422#line 126 "btyacc_calc1.y"
1423 {
1424 yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi;
1425 yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo;
1426 }
1427break;
1428case 20:
1429 if (!yytrial)
1430#line 131 "btyacc_calc1.y"
1431 {
1432 yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi;
1433 yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo;
1434 }
1435break;
1436case 21:
1437 if (!yytrial)
1438#line 136 "btyacc_calc1.y"
1439 {
1440 yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo;
1441 yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi;
1442 }
1443break;
1444case 22:
1445 if (!yytrial)
1446#line 141 "btyacc_calc1.y"
1447 {
1448 yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo;
1449 yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi;
1450 }
1451break;
1452case 23:
1453 if (!yytrial)
1454#line 146 "btyacc_calc1.y"
1455 {
1456 yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
1457 }
1458break;
1459case 24:
1460 if (!yytrial)
1461#line 150 "btyacc_calc1.y"
1462 {
1463 yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
1464 }
1465break;
1466case 25:
1467 if (!yytrial)
1468#line 154 "btyacc_calc1.y"
1469 {
1470 if (dcheck(yystack.l_mark[0].vval)) YYERROR;
1471 yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
1472 }
1473break;
1474case 26:
1475 if (!yytrial)
1476#line 159 "btyacc_calc1.y"
1477 {
1478 if (dcheck ( yystack.l_mark[0].vval )) YYERROR;
1479 yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
1480 }
1481break;
1482case 27:
1483 if (!yytrial)
1484#line 164 "btyacc_calc1.y"
1485 {
1486 yyval.vval.hi = -yystack.l_mark[0].vval.lo;
1487 yyval.vval.lo = -yystack.l_mark[0].vval.hi;
1488 }
1489break;
1490case 28:
1491 if (!yytrial)
1492#line 169 "btyacc_calc1.y"
1493 {
1494 yyval.vval = yystack.l_mark[-1].vval;
1495 }
1496break;
1497#line 1498 "btyacc_calc1.tab.c"
1498 default:
1499 break;
1500 }
1501 yystack.s_mark -= yym;
1502 yystate = *yystack.s_mark;
1503 yystack.l_mark -= yym;
1504#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1505 yystack.p_mark -= yym;
1506#endif
1507 yym = yylhs[yyn];
1508 if (yystate == 0 && yym == 0)
1509 {
1510#if YYDEBUG
1511 if (yydebug)
1512 {
1513 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1514#ifdef YYSTYPE_TOSTRING
1515#if YYBTYACC
1516 if (!yytrial)
1517#endif /* YYBTYACC */
1518 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1519#endif
1520 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1521 }
1522#endif
1523 yystate = YYFINAL;
1524 *++yystack.s_mark = YYFINAL;
1525 *++yystack.l_mark = yyval;
1526#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1527 *++yystack.p_mark = yyloc;
1528#endif
1529 if (yychar < 0)
1530 {
1531#if YYBTYACC
1532 do {
1533 if (yylvp < yylve)
1534 {
1535 /* we're currently re-reading tokens */
1536 yylval = *yylvp++;
1537#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1538 yylloc = *yylpp++;
1539#endif
1540 yychar = *yylexp++;
1541 break;
1542 }
1543 if (yyps->save)
1544 {
1545 /* in trial mode; save scanner results for future parse attempts */
1546 if (yylvp == yylvlim)
1547 { /* Enlarge lexical value queue */
1548 int p = yylvp - yylvals;
1549 int s = yylvlim - yylvals;
1550
1551 s += YYLVQUEUEGROWTH;
1552 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
1553 goto yyenomem;
1554 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1555 goto yyenomem;
1556#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1557 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1558 goto yyenomem;
1559#endif
1560 yylvp = yylve = yylvals + p;
1561 yylvlim = yylvals + s;
1562#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1563 yylpp = yylpe = yylpsns + p;
1564 yylplim = yylpsns + s;
1565#endif
1566 yylexp = yylexemes + p;
1567 }
1568 *yylexp = (short) YYLEX;
1569 *yylvp++ = yylval;
1570 yylve++;
1571#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1572 *yylpp++ = yylloc;
1573 yylpe++;
1574#endif
1575 yychar = *yylexp++;
1576 break;
1577 }
1578 /* normal operation, no conflict encountered */
1579#endif /* YYBTYACC */
1580 yychar = YYLEX;
1581#if YYBTYACC
1582 } while (0);
1583#endif /* YYBTYACC */
1584 if (yychar < 0) yychar = YYEOF;
1585 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
1586#if YYDEBUG
1587 if (yydebug)
1588 {
1589 yys = yyname[YYTRANSLATE(yychar)];
1590 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n",
1591 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1592 }
1593#endif
1594 }
1595 if (yychar == YYEOF) goto yyaccept;
1596 goto yyloop;
1597 }
1598 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1599 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1600 yystate = yytable[yyn];
1601 else
1602 yystate = yydgoto[yym];
1603#if YYDEBUG
1604 if (yydebug)
1605 {
1606 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1607#ifdef YYSTYPE_TOSTRING
1608#if YYBTYACC
1609 if (!yytrial)
1610#endif /* YYBTYACC */
1611 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1612#endif
1613 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1614 }
1615#endif
1616 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1617 *++yystack.s_mark = (short) yystate;
1618 *++yystack.l_mark = yyval;
1619#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1620 *++yystack.p_mark = yyloc;
1621#endif
1622 goto yyloop;
1623#if YYBTYACC
1624
1625 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1626yyvalid:
1627 if (yypath) YYABORT;
1628 while (yyps->save)
1629 {
1630 YYParseState *save = yyps->save;
1631 yyps->save = save->save;
1632 save->save = yypath;
1633 yypath = save;
1634 }
1635#if YYDEBUG
1636 if (yydebug)
1637 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1638 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1639#endif
1640 if (yyerrctx)
1641 {
1642 yyFreeState(yyerrctx);
1643 yyerrctx = NULL;
1644 }
1645 yylvp = yylvals + yypath->lexeme;
1646#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1647 yylpp = yylpsns + yypath->lexeme;
1648#endif
1649 yylexp = yylexemes + yypath->lexeme;
1650 yychar = YYEMPTY;
1651 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1652 memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1653 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1654 memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1655#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1656 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1657 memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1658#endif
1659 yystate = yypath->state;
1660 goto yyloop;
1661#endif /* YYBTYACC */
1662
1663yyoverflow:
1664 YYERROR_CALL("yacc stack overflow");
1665#if YYBTYACC
1666 goto yyabort_nomem;
1667yyenomem:
1668 YYERROR_CALL("memory exhausted");
1669yyabort_nomem:
1670#endif /* YYBTYACC */
1671 yyresult = 2;
1672 goto yyreturn;
1673
1674yyabort:
1675 yyresult = 1;
1676 goto yyreturn;
1677
1678yyaccept:
1679#if YYBTYACC
1680 if (yyps->save) goto yyvalid;
1681#endif /* YYBTYACC */
1682 yyresult = 0;
1683
1684yyreturn:
1685#if defined(YYDESTRUCT_CALL)
1686 if (yychar != YYEOF && yychar != YYEMPTY)
1687#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1688 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1689#else
1690 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1691#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1692
1693 {
1694 YYSTYPE *pv;
1695#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1696 YYLTYPE *pp;
1697
1698 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1699 YYDESTRUCT_CALL("cleanup: discarding state",
1700 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1701#else
1702 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1703 YYDESTRUCT_CALL("cleanup: discarding state",
1704 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1705#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1706 }
1707#endif /* defined(YYDESTRUCT_CALL) */
1708
1709#if YYBTYACC
1710 if (yyerrctx)
1711 {
1712 yyFreeState(yyerrctx);
1713 yyerrctx = NULL;
1714 }
1715 while (yyps)
1716 {
1717 YYParseState *save = yyps;
1718 yyps = save->save;
1719 save->save = NULL;
1720 yyFreeState(save);
1721 }
1722 while (yypath)
1723 {
1724 YYParseState *save = yypath;
1725 yypath = save->save;
1726 save->save = NULL;
1727 yyFreeState(save);
1728 }
1729#endif /* YYBTYACC */
1730 yyfreestack(&yystack);
1731 return (yyresult);
1732}
2/* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
3/* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
4
5#define YYBYACC 1
6#define YYMAJOR 1
7#define YYMINOR 9
8#define YYCHECK "yyyymmdd"
9
10#define YYEMPTY (-1)
11#define yyclearin (yychar = YYEMPTY)
12#define yyerrok (yyerrflag = 0)
13#define YYRECOVERING() (yyerrflag != 0)
14#define YYENOMEM (-2)
15#define YYEOF 0
16#undef YYBTYACC
17#define YYBTYACC 1
18#define YYDEBUGSTR (yytrial ? YYPREFIX "debug(trial)" : YYPREFIX "debug")
19
20#ifndef yyparse
21#define yyparse calc1_parse
22#endif /* yyparse */
23
24#ifndef yylex
25#define yylex calc1_lex
26#endif /* yylex */
27
28#ifndef yyerror
29#define yyerror calc1_error
30#endif /* yyerror */
31
32#ifndef yychar
33#define yychar calc1_char
34#endif /* yychar */
35
36#ifndef yyval
37#define yyval calc1_val
38#endif /* yyval */
39
40#ifndef yylval
41#define yylval calc1_lval
42#endif /* yylval */
43
44#ifndef yydebug
45#define yydebug calc1_debug
46#endif /* yydebug */
47
48#ifndef yynerrs
49#define yynerrs calc1_nerrs
50#endif /* yynerrs */
51
52#ifndef yyerrflag
53#define yyerrflag calc1_errflag
54#endif /* yyerrflag */
55
56#ifndef yylhs
57#define yylhs calc1_lhs
58#endif /* yylhs */
59
60#ifndef yylen
61#define yylen calc1_len
62#endif /* yylen */
63
64#ifndef yydefred
65#define yydefred calc1_defred
66#endif /* yydefred */
67
68#ifndef yystos
69#define yystos calc1_stos
70#endif /* yystos */
71
72#ifndef yydgoto
73#define yydgoto calc1_dgoto
74#endif /* yydgoto */
75
76#ifndef yysindex
77#define yysindex calc1_sindex
78#endif /* yysindex */
79
80#ifndef yyrindex
81#define yyrindex calc1_rindex
82#endif /* yyrindex */
83
84#ifndef yygindex
85#define yygindex calc1_gindex
86#endif /* yygindex */
87
88#ifndef yytable
89#define yytable calc1_table
90#endif /* yytable */
91
92#ifndef yycheck
93#define yycheck calc1_check
94#endif /* yycheck */
95
96#ifndef yyname
97#define yyname calc1_name
98#endif /* yyname */
99
100#ifndef yyrule
101#define yyrule calc1_rule
102#endif /* yyrule */
103
104#if YYBTYACC
105
106#ifndef yycindex
107#define yycindex calc1_cindex
108#endif /* yycindex */
109
110#ifndef yyctable
111#define yyctable calc1_ctable
112#endif /* yyctable */
113
114#endif /* YYBTYACC */
115
116#define YYPREFIX "calc1_"
117
118#define YYPURE 1
119
120#line 3 "btyacc_calc1.y"
121
122/* http://dinosaur.compilertools.net/yacc/index.html */
123
124#include <stdlib.h>
125#include <stdio.h>
126#include <ctype.h>
127#include <math.h>
128
129typedef struct interval
130{
131 double lo, hi;
132}
133INTERVAL;
134
135INTERVAL vmul(double, double, INTERVAL);
136INTERVAL vdiv(double, double, INTERVAL);
137
138int dcheck(INTERVAL);
139
140double dreg[26];
141INTERVAL vreg[26];
142
143#line 29 "btyacc_calc1.y"
144#ifdef YYSTYPE
145#undef YYSTYPE_IS_DECLARED
146#define YYSTYPE_IS_DECLARED 1
147#endif
148#ifndef YYSTYPE_IS_DECLARED
149#define YYSTYPE_IS_DECLARED 1
150typedef union
151{
152 int ival;
153 double dval;
154 INTERVAL vval;
155} YYSTYPE;
156#endif /* !YYSTYPE_IS_DECLARED */
157#line 158 "btyacc_calc1.tab.c"
158
159/* compatibility with bison */
160#ifdef YYPARSE_PARAM
161/* compatibility with FreeBSD */
162# ifdef YYPARSE_PARAM_TYPE
163# define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
164# else
165# define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
166# endif
167#else
168# define YYPARSE_DECL() yyparse(void)
169#endif
170
171/* Parameters sent to lex. */
172#ifdef YYLEX_PARAM
173# ifdef YYLEX_PARAM_TYPE
174# define YYLEX_DECL() yylex(YYSTYPE *yylval, YYLEX_PARAM_TYPE YYLEX_PARAM)
175# else
176# define YYLEX_DECL() yylex(YYSTYPE *yylval, void * YYLEX_PARAM)
177# endif
178# define YYLEX yylex(&yylval, YYLEX_PARAM)
179#else
180# define YYLEX_DECL() yylex(YYSTYPE *yylval)
181# define YYLEX yylex(&yylval)
182#endif
183
184/* Parameters sent to yyerror. */
185#ifndef YYERROR_DECL
186#define YYERROR_DECL() yyerror(const char *s)
187#endif
188#ifndef YYERROR_CALL
189#define YYERROR_CALL(msg) yyerror(msg)
190#endif
191
192extern int YYPARSE_DECL();
193
194#define DREG 257
195#define VREG 258
196#define CONST 259
197#define UMINUS 260
198#define YYERRCODE 256
199typedef short YYINT;
200static const YYINT calc1_lhs[] = { -1,
201 0, 0, 0, 3, 3, 3, 3, 1, 1, 1,
202 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
203 2, 2, 2, 2, 2, 2, 2, 2,
204};
205static const YYINT calc1_len[] = { 2,
206 0, 3, 3, 1, 1, 3, 3, 1, 1, 3,
207 3, 3, 3, 2, 3, 1, 5, 1, 3, 3,
208 3, 3, 3, 3, 3, 3, 2, 3,
209};
210static const YYINT calc1_defred[] = { 1,
211 0, 0, 0, 0, 8, 0, 0, 0, 0, 0,
212 3, 0, 0, 9, 18, 0, 27, 0, 0, 0,
213 0, 0, 0, 0, 0, 0, 0, 2, 0, 0,
214 0, 0, 0, 15, 0, 28, 0, 0, 0, 0,
215 0, 24, 0, 26, 0, 0, 23, 25, 14, 0,
216 0, 0, 0, 0, 0, 0, 0, 12, 13, 17,
217};
218static const YYINT calc1_stos[] = { 0,
219 262, 256, 257, 258, 259, 45, 40, 263, 264, 265,
220 10, 61, 61, 257, 258, 263, 264, 263, 264, 43,
221 45, 42, 47, 43, 45, 42, 47, 10, 45, 40,
222 263, 263, 264, 41, 44, 41, 263, 264, 263, 264,
223 263, 264, 263, 264, 264, 264, 264, 264, 263, 263,
224 43, 45, 42, 47, 263, 263, 263, 263, 263, 41,
225};
226static const YYINT calc1_dgoto[] = { 1,
227 32, 9, 10,
228};
229static const YYINT calc1_sindex[] = { 0,
230 -40, -9, -59, -54, 0, -37, -37, 0, 82, 4,
231 0, -34, -37, 0, 0, 0, 0, -31, -25, -37,
232 -37, -37, -37, -37, -37, -37, -37, 0, -34, -34,
233 132, 0, 82, 0, -34, 0, 0, -12, 0, -12,
234 0, 0, 0, 0, -12, -12, 0, 0, 0, 112,
235 -34, -34, -34, -34, 119, -11, -11, 0, 0, 0,
236};
237static const YYINT calc1_rindex[] = { 0,
238 0, 0, 51, 58, 0, 0, 0, 0, 11, 0,
239 0, 0, 0, 0, 0, -16, 0, 0, 0, 0,
240 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
241 19, 9, 27, 0, 0, 0, -5, 41, -4, 77,
242 -2, 0, 8, 0, 78, 85, 0, 0, 0, 0,
243 0, 0, 0, 0, 0, 92, 99, 0, 0, 0,
244};
245#if YYBTYACC
246static const YYINT calc1_cindex[] = { 0,
247 0, 0, 0, 0, 0, 0, 0, 65, 0, 0,
248 0, 0, 0, 0, 0, 2, 0, 126, 0, 0,
249 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
250 0, 138, 0, 0, 0, 0, 17, 0, 24, 0,
251 31, 0, 38, 0, 0, 0, 0, 0, 0, 0,
252 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
253};
254#endif
255static const YYINT calc1_gindex[] = { 0,
256 3, 125, 0,
257};
258#define YYTABLESIZE 225
259static const YYINT calc1_table[] = { 7,
260 11, 12, 7, 8, 6, 30, 13, 6, 16, 18,
261 29, 14, 35, 28, 31, 36, 26, 24, 16, 25,
262 5, 27, 37, 39, 41, 43, 20, 14, 6, 26,
263 53, 49, 50, 23, 27, 54, 7, 55, 10, 11,
264 26, 12, 14, 14, 14, 0, 14, 29, 14, 16,
265 20, 13, 0, 56, 57, 58, 59, 20, 6, 20,
266 9, 20, 0, 9, 23, 6, 23, 18, 23, 0,
267 9, 26, 26, 26, 11, 26, 0, 26, 29, 29,
268 29, 20, 29, 20, 29, 20, 22, 19, 0, 0,
269 0, 0, 9, 9, 21, 9, 0, 9, 0, 18,
270 18, 10, 18, 0, 18, 0, 6, 0, 11, 3,
271 0, 9, 0, 0, 0, 0, 0, 22, 19, 22,
272 19, 22, 19, 26, 24, 21, 25, 21, 27, 21,
273 17, 19, 10, 0, 10, 0, 10, 33, 0, 11,
274 0, 11, 0, 11, 38, 40, 42, 44, 45, 46,
275 47, 48, 34, 53, 51, 0, 52, 0, 54, 60,
276 53, 51, 0, 52, 0, 54, 18, 6, 0, 0,
277 3, 0, 9, 53, 51, 0, 52, 0, 54, 6,
278 0, 0, 3, 0, 9, 0, 0, 0, 0, 0,
279 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
280 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
281 0, 0, 0, 0, 0, 2, 3, 4, 5, 14,
282 15, 5, 14, 0, 5,
283};
284static const YYINT calc1_check[] = { 40,
285 10, 61, 40, 1, 45, 40, 61, 45, 6, 7,
286 45, 10, 44, 10, 12, 41, 42, 43, 10, 45,
287 10, 47, 20, 21, 22, 23, 10, 44, 10, 42,
288 42, 29, 30, 10, 47, 47, 10, 35, 44, 44,
289 10, 44, 41, 42, 43, -1, 45, 10, 47, 41,
290 10, 44, -1, 51, 52, 53, 54, 41, 42, 43,
291 10, 45, -1, 47, 41, 42, 43, 10, 45, -1,
292 47, 41, 42, 43, 10, 45, -1, 47, 41, 42,
293 43, 41, 45, 43, 47, 45, 10, 10, -1, -1,
294 -1, -1, 42, 43, 10, 45, -1, 47, -1, 42,
295 43, 10, 45, -1, 47, -1, 42, 43, 10, 45,
296 -1, 47, -1, -1, -1, -1, -1, 41, 41, 43,
297 43, 45, 45, 42, 43, 41, 45, 43, 47, 45,
298 6, 7, 41, -1, 43, -1, 45, 13, -1, 41,
299 -1, 43, -1, 45, 20, 21, 22, 23, 24, 25,
300 26, 27, 41, 42, 43, -1, 45, -1, 47, 41,
301 42, 43, -1, 45, -1, 47, 41, 42, 43, -1,
302 45, -1, 47, 42, 43, -1, 45, -1, 47, 42,
303 43, -1, 45, -1, 47, -1, -1, -1, -1, -1,
304 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
305 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
306 -1, -1, -1, -1, -1, 256, 257, 258, 259, 257,
307 258, 259, 257, -1, 259,
308};
309#if YYBTYACC
310static const YYINT calc1_ctable[] = { 20,
311 16, -1, 21, 16, -1, 22, 16, -1, 23, 16,
312 -1, 4, 16, -1, 14, 16, -1, 34, 16, -1,
313 10, 16, -1, 11, 16, -1, 12, 16, -1, 13,
314 16, -1,
315};
316#endif
317#define YYFINAL 1
318#ifndef YYDEBUG
319#define YYDEBUG 0
320#endif
321#define YYMAXTOKEN 260
322#define YYUNDFTOKEN 266
323#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
324#if YYDEBUG
325static const char *const calc1_name[] = {
326
327"$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,
3280,0,0,0,0,0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0,
3290,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3300,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3310,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3320,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3330,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
334"error","DREG","VREG","CONST","UMINUS","$accept","lines","dexp","vexp","line",
335"illegal-symbol",
336};
337static const char *const calc1_rule[] = {
338"$accept : lines",
339"lines :",
340"lines : lines line '\\n'",
341"lines : lines error '\\n'",
342"line : dexp",
343"line : vexp",
344"line : DREG '=' dexp",
345"line : VREG '=' vexp",
346"dexp : CONST",
347"dexp : DREG",
348"dexp : dexp '+' dexp",
349"dexp : dexp '-' dexp",
350"dexp : dexp '*' dexp",
351"dexp : dexp '/' dexp",
352"dexp : '-' dexp",
353"dexp : '(' dexp ')'",
354"vexp : dexp",
355"vexp : '(' dexp ',' dexp ')'",
356"vexp : VREG",
357"vexp : vexp '+' vexp",
358"vexp : dexp '+' vexp",
359"vexp : vexp '-' vexp",
360"vexp : dexp '-' vexp",
361"vexp : vexp '*' vexp",
362"vexp : dexp '*' vexp",
363"vexp : vexp '/' vexp",
364"vexp : dexp '/' vexp",
365"vexp : '-' vexp",
366"vexp : '(' vexp ')'",
367
368};
369#endif
370
371int yydebug;
372int yynerrs;
373
374#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
375#ifndef YYLLOC_DEFAULT
376#define YYLLOC_DEFAULT(loc, rhs, n) \
377do \
378{ \
379 if (n == 0) \
380 { \
381 (loc).first_line = ((rhs)[-1]).last_line; \
382 (loc).first_column = ((rhs)[-1]).last_column; \
383 (loc).last_line = ((rhs)[-1]).last_line; \
384 (loc).last_column = ((rhs)[-1]).last_column; \
385 } \
386 else \
387 { \
388 (loc).first_line = ((rhs)[ 0 ]).first_line; \
389 (loc).first_column = ((rhs)[ 0 ]).first_column; \
390 (loc).last_line = ((rhs)[n-1]).last_line; \
391 (loc).last_column = ((rhs)[n-1]).last_column; \
392 } \
393} while (0)
394#endif /* YYLLOC_DEFAULT */
395#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
396#if YYBTYACC
397
398#ifndef YYLVQUEUEGROWTH
399#define YYLVQUEUEGROWTH 32
400#endif
401#endif /* YYBTYACC */
402
403/* define the initial stack-sizes */
404#ifdef YYSTACKSIZE
405#undef YYMAXDEPTH
406#define YYMAXDEPTH YYSTACKSIZE
407#else
408#ifdef YYMAXDEPTH
409#define YYSTACKSIZE YYMAXDEPTH
410#else
411#define YYSTACKSIZE 10000
412#define YYMAXDEPTH 10000
413#endif
414#endif
415
416#ifndef YYINITSTACKSIZE
417#define YYINITSTACKSIZE 200
418#endif
419
420typedef struct {
421 unsigned stacksize;
422 short *s_base;
423 short *s_mark;
424 short *s_last;
425 YYSTYPE *l_base;
426 YYSTYPE *l_mark;
427#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
428 YYLTYPE *p_base;
429 YYLTYPE *p_mark;
430#endif
431} YYSTACKDATA;
432#if YYBTYACC
433
434struct YYParseState_s
435{
436 struct YYParseState_s *save; /* Previously saved parser state */
437 YYSTACKDATA yystack; /* saved parser stack */
438 int state; /* saved parser state */
439 int errflag; /* saved error recovery status */
440 int lexeme; /* saved index of the conflict lexeme in the lexical queue */
441 YYINT ctry; /* saved index in yyctable[] for this conflict */
442};
443typedef struct YYParseState_s YYParseState;
444#endif /* YYBTYACC */
445#line 174 "btyacc_calc1.y"
446 /* beginning of subroutines section */
447
448int
449main (void)
450{
451 while(!feof(stdin)) {
452 yyparse();
453 }
454 return 0;
455}
456
457#define BSZ 50 /* buffer size for floating point numbers */
458
459static void
460YYERROR_DECL()
461{
462 fprintf(stderr, "%s\n", s);
463}
464
465 /* lexical analysis */
466
467static int
468YYLEX_DECL()
469{
470 int c;
471
472 while ((c = getchar()) == ' ')
473 { /* skip over blanks */
474 }
475
476 if (isupper(c))
477 {
478#if YYPURE
479 (*yylval).ival = c - 'A';
480#else
481 yylval.ival = c - 'A';
482#endif
483 return (VREG);
484 }
485 if (islower(c))
486 {
487#if YYPURE
488 (*yylval).ival = c - 'a';
489#else
490 yylval.ival = c - 'a';
491#endif
492 return (DREG);
493 }
494
495 if (isdigit(c) || c == '.')
496 {
497 /* gobble up digits, points, exponents */
498 char buf[BSZ + 1], *cp = buf;
499 int dot = 0, expr = 0;
500
501 for (; (cp - buf) < BSZ; ++cp, c = getchar())
502 {
503
504 *cp = (char) c;
505 if (isdigit(c))
506 continue;
507 if (c == '.')
508 {
509 if (dot++ || expr)
510 return ('.'); /* will cause syntax error */
511 continue;
512 }
513
514 if (c == 'e')
515 {
516 if (expr++)
517 return ('e'); /* will cause syntax error */
518 continue;
519 }
520
521 /* end of number */
522 break;
523 }
524 *cp = '\0';
525
526 if ((cp - buf) >= BSZ)
527 printf("constant too long: truncated\n");
528 else
529 ungetc(c, stdin); /* push back last char read */
530#if YYPURE
531 (*yylval).dval = atof(buf);
532#else
533 yylval.dval = atof(buf);
534#endif
535 return (CONST);
536 }
537 return (c);
538}
539
540static INTERVAL
541hilo(double a, double b, double c, double d)
542{
543 /* returns the smallest interval containing a, b, c, and d */
544 /* used by *, / routines */
545 INTERVAL v;
546
547 if (a > b)
548 {
549 v.hi = a;
550 v.lo = b;
551 }
552 else
553 {
554 v.hi = b;
555 v.lo = a;
556 }
557
558 if (c > d)
559 {
560 if (c > v.hi)
561 v.hi = c;
562 if (d < v.lo)
563 v.lo = d;
564 }
565 else
566 {
567 if (d > v.hi)
568 v.hi = d;
569 if (c < v.lo)
570 v.lo = c;
571 }
572 return (v);
573}
574
575INTERVAL
576vmul(double a, double b, INTERVAL v)
577{
578 return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo));
579}
580
581int
582dcheck(INTERVAL v)
583{
584 if (v.hi >= 0. && v.lo <= 0.)
585 {
586 printf("divisor interval contains 0.\n");
587 return (1);
588 }
589 return (0);
590}
591
592INTERVAL
593vdiv(double a, double b, INTERVAL v)
594{
595 return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
596}
597#line 598 "btyacc_calc1.tab.c"
598
599/* For use in generated program */
600#define yydepth (int)(yystack.s_mark - yystack.s_base)
601#if YYBTYACC
602#define yytrial (yyps->save)
603#endif /* YYBTYACC */
604
605#if YYDEBUG
606#include <stdio.h> /* needed for printf */
607#endif
608
609#include <stdlib.h> /* needed for malloc, etc */
610#include <string.h> /* needed for memset */
611
612/* allocate initial stack or double stack size, up to YYMAXDEPTH */
613static int yygrowstack(YYSTACKDATA *data)
614{
615 int i;
616 unsigned newsize;
617 short *newss;
618 YYSTYPE *newvs;
619#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
620 YYLTYPE *newps;
621#endif
622
623 if ((newsize = data->stacksize) == 0)
624 newsize = YYINITSTACKSIZE;
625 else if (newsize >= YYMAXDEPTH)
626 return YYENOMEM;
627 else if ((newsize *= 2) > YYMAXDEPTH)
628 newsize = YYMAXDEPTH;
629
630 i = (int) (data->s_mark - data->s_base);
631 newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
632 if (newss == 0)
633 return YYENOMEM;
634
635 data->s_base = newss;
636 data->s_mark = newss + i;
637
638 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
639 if (newvs == 0)
640 return YYENOMEM;
641
642 data->l_base = newvs;
643 data->l_mark = newvs + i;
644
645#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
646 newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
647 if (newps == 0)
648 return YYENOMEM;
649
650 data->p_base = newps;
651 data->p_mark = newps + i;
652#endif
653
654 data->stacksize = newsize;
655 data->s_last = data->s_base + newsize - 1;
656
657#if YYDEBUG
658 if (yydebug)
659 fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
660#endif
661 return 0;
662}
663
664#if YYPURE || defined(YY_NO_LEAKS)
665static void yyfreestack(YYSTACKDATA *data)
666{
667 free(data->s_base);
668 free(data->l_base);
669#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
670 free(data->p_base);
671#endif
672 memset(data, 0, sizeof(*data));
673}
674#else
675#define yyfreestack(data) /* nothing */
676#endif /* YYPURE || defined(YY_NO_LEAKS) */
677#if YYBTYACC
678
679static YYParseState *
680yyNewState(unsigned size)
681{
682 YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
683 if (p == NULL) return NULL;
684
685 p->yystack.stacksize = size;
686 if (size == 0)
687 {
688 p->yystack.s_base = NULL;
689 p->yystack.l_base = NULL;
690#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
691 p->yystack.p_base = NULL;
692#endif
693 return p;
694 }
695 p->yystack.s_base = (short *) malloc(size * sizeof(short));
696 if (p->yystack.s_base == NULL) return NULL;
697 p->yystack.l_base = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
698 if (p->yystack.l_base == NULL) return NULL;
699 memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
700#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
701 p->yystack.p_base = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
702 if (p->yystack.p_base == NULL) return NULL;
703 memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
704#endif
705
706 return p;
707}
708
709static void
710yyFreeState(YYParseState *p)
711{
712 yyfreestack(&p->yystack);
713 free(p);
714}
715#endif /* YYBTYACC */
716
717#define YYABORT goto yyabort
718#define YYREJECT goto yyabort
719#define YYACCEPT goto yyaccept
720#define YYERROR goto yyerrlab
721#if YYBTYACC
722#define YYVALID do { if (yyps->save) goto yyvalid; } while(0)
723#define YYVALID_NESTED do { if (yyps->save && \
724 yyps->save->save == 0) goto yyvalid; } while(0)
725#endif /* YYBTYACC */
726
727int
728YYPARSE_DECL()
729{
730 int yyerrflag;
731 int yychar;
732 YYSTYPE yyval;
733 YYSTYPE yylval;
734#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
735 YYLTYPE yyloc; /* position returned by actions */
736 YYLTYPE yylloc; /* position from the lexer */
737#endif
738
739 /* variables for the parser stack */
740 YYSTACKDATA yystack;
741#if YYBTYACC
742
743 /* Current parser state */
744 static YYParseState *yyps = 0;
745
746 /* yypath != NULL: do the full parse, starting at *yypath parser state. */
747 static YYParseState *yypath = 0;
748
749 /* Base of the lexical value queue */
750 static YYSTYPE *yylvals = 0;
751
752 /* Current position at lexical value queue */
753 static YYSTYPE *yylvp = 0;
754
755 /* End position of lexical value queue */
756 static YYSTYPE *yylve = 0;
757
758 /* The last allocated position at the lexical value queue */
759 static YYSTYPE *yylvlim = 0;
760
761#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
762 /* Base of the lexical position queue */
763 static YYLTYPE *yylpsns = 0;
764
765 /* Current position at lexical position queue */
766 static YYLTYPE *yylpp = 0;
767
768 /* End position of lexical position queue */
769 static YYLTYPE *yylpe = 0;
770
771 /* The last allocated position at the lexical position queue */
772 static YYLTYPE *yylplim = 0;
773#endif
774
775 /* Current position at lexical token queue */
776 static short *yylexp = 0;
777
778 static short *yylexemes = 0;
779#endif /* YYBTYACC */
780 int yym, yyn, yystate, yyresult;
781#if YYBTYACC
782 int yynewerrflag;
783 YYParseState *yyerrctx = NULL;
784#endif /* YYBTYACC */
785#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
786 YYLTYPE yyerror_loc_range[2]; /* position of error start & end */
787#endif
788#if YYDEBUG
789 const char *yys;
790
791 if ((yys = getenv("YYDEBUG")) != 0)
792 {
793 yyn = *yys;
794 if (yyn >= '0' && yyn <= '9')
795 yydebug = yyn - '0';
796 }
797 if (yydebug)
798 fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
799#endif
800
801#if YYBTYACC
802 yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
803 yyps->save = 0;
804#endif /* YYBTYACC */
805 yynerrs = 0;
806 yyerrflag = 0;
807 yychar = YYEMPTY;
808 yystate = 0;
809
810#if YYPURE
811 memset(&yystack, 0, sizeof(yystack));
812#endif
813
814 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
815 yystack.s_mark = yystack.s_base;
816 yystack.l_mark = yystack.l_base;
817#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
818 yystack.p_mark = yystack.p_base;
819#endif
820 yystate = 0;
821 *yystack.s_mark = 0;
822
823yyloop:
824 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
825 if (yychar < 0)
826 {
827#if YYBTYACC
828 do {
829 if (yylvp < yylve)
830 {
831 /* we're currently re-reading tokens */
832 yylval = *yylvp++;
833#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
834 yylloc = *yylpp++;
835#endif
836 yychar = *yylexp++;
837 break;
838 }
839 if (yyps->save)
840 {
841 /* in trial mode; save scanner results for future parse attempts */
842 if (yylvp == yylvlim)
843 { /* Enlarge lexical value queue */
844 int p = yylvp - yylvals;
845 int s = yylvlim - yylvals;
846
847 s += YYLVQUEUEGROWTH;
848 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
849 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
850#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
851 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
852#endif
853 yylvp = yylve = yylvals + p;
854 yylvlim = yylvals + s;
855#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
856 yylpp = yylpe = yylpsns + p;
857 yylplim = yylpsns + s;
858#endif
859 yylexp = yylexemes + p;
860 }
861 *yylexp = (short) YYLEX;
862 *yylvp++ = yylval;
863 yylve++;
864#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
865 *yylpp++ = yylloc;
866 yylpe++;
867#endif
868 yychar = *yylexp++;
869 break;
870 }
871 /* normal operation, no conflict encountered */
872#endif /* YYBTYACC */
873 yychar = YYLEX;
874#if YYBTYACC
875 } while (0);
876#endif /* YYBTYACC */
877 if (yychar < 0) yychar = YYEOF;
878 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
879#if YYDEBUG
880 if (yydebug)
881 {
882 yys = yyname[YYTRANSLATE(yychar)];
883 fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
884 YYDEBUGSTR, yydepth, yystate, yychar, yys);
885#ifdef YYSTYPE_TOSTRING
886#if YYBTYACC
887 if (!yytrial)
888#endif /* YYBTYACC */
889 fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
890#endif
891 fputc('\n', stderr);
892 }
893#endif
894 }
895#if YYBTYACC
896
897 /* Do we have a conflict? */
898 if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
899 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
900 {
901 YYINT ctry;
902
903 if (yypath)
904 {
905 YYParseState *save;
906#if YYDEBUG
907 if (yydebug)
908 fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
909 YYDEBUGSTR, yydepth, yystate);
910#endif
911 /* Switch to the next conflict context */
912 save = yypath;
913 yypath = save->save;
914 save->save = NULL;
915 ctry = save->ctry;
916 if (save->state != yystate) YYABORT;
917 yyFreeState(save);
918
919 }
920 else
921 {
922
923 /* Unresolved conflict - start/continue trial parse */
924 YYParseState *save;
925#if YYDEBUG
926 if (yydebug)
927 {
928 fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
929 if (yyps->save)
930 fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
931 else
932 fputs("Starting trial parse.\n", stderr);
933 }
934#endif
935 save = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
936 if (save == NULL) goto yyenomem;
937 save->save = yyps->save;
938 save->state = yystate;
939 save->errflag = yyerrflag;
940 save->yystack.s_mark = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
941 memcpy (save->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
942 save->yystack.l_mark = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
943 memcpy (save->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
944#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
945 save->yystack.p_mark = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
946 memcpy (save->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
947#endif
948 ctry = yytable[yyn];
949 if (yyctable[ctry] == -1)
950 {
951#if YYDEBUG
952 if (yydebug && yychar >= YYEOF)
953 fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
954#endif
955 ctry++;
956 }
957 save->ctry = ctry;
958 if (yyps->save == NULL)
959 {
960 /* If this is a first conflict in the stack, start saving lexemes */
961 if (!yylexemes)
962 {
963 yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));
964 if (yylexemes == NULL) goto yyenomem;
965 yylvals = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
966 if (yylvals == NULL) goto yyenomem;
967 yylvlim = yylvals + YYLVQUEUEGROWTH;
968#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
969 yylpsns = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
970 if (yylpsns == NULL) goto yyenomem;
971 yylplim = yylpsns + YYLVQUEUEGROWTH;
972#endif
973 }
974 if (yylvp == yylve)
975 {
976 yylvp = yylve = yylvals;
977#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
978 yylpp = yylpe = yylpsns;
979#endif
980 yylexp = yylexemes;
981 if (yychar >= YYEOF)
982 {
983 *yylve++ = yylval;
984#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
985 *yylpe++ = yylloc;
986#endif
987 *yylexp = (short) yychar;
988 yychar = YYEMPTY;
989 }
990 }
991 }
992 if (yychar >= YYEOF)
993 {
994 yylvp--;
995#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
996 yylpp--;
997#endif
998 yylexp--;
999 yychar = YYEMPTY;
1000 }
1001 save->lexeme = yylvp - yylvals;
1002 yyps->save = save;
1003 }
1004 if (yytable[yyn] == ctry)
1005 {
1006#if YYDEBUG
1007 if (yydebug)
1008 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1009 YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
1010#endif
1011 if (yychar < 0)
1012 {
1013 yylvp++;
1014#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1015 yylpp++;
1016#endif
1017 yylexp++;
1018 }
1019 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
1020 goto yyoverflow;
1021 yystate = yyctable[ctry];
1022 *++yystack.s_mark = (short) yystate;
1023 *++yystack.l_mark = yylval;
1024#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1025 *++yystack.p_mark = yylloc;
1026#endif
1027 yychar = YYEMPTY;
1028 if (yyerrflag > 0) --yyerrflag;
1029 goto yyloop;
1030 }
1031 else
1032 {
1033 yyn = yyctable[ctry];
1034 goto yyreduce;
1035 }
1036 } /* End of code dealing with conflicts */
1037#endif /* YYBTYACC */
1038 if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1039 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1040 {
1041#if YYDEBUG
1042 if (yydebug)
1043 fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1044 YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
1045#endif
1046 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1047 yystate = yytable[yyn];
1048 *++yystack.s_mark = yytable[yyn];
1049 *++yystack.l_mark = yylval;
1050#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1051 *++yystack.p_mark = yylloc;
1052#endif
1053 yychar = YYEMPTY;
1054 if (yyerrflag > 0) --yyerrflag;
1055 goto yyloop;
1056 }
1057 if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1058 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1059 {
1060 yyn = yytable[yyn];
1061 goto yyreduce;
1062 }
1063 if (yyerrflag != 0) goto yyinrecovery;
1064#if YYBTYACC
1065
1066 yynewerrflag = 1;
1067 goto yyerrhandler;
1068 goto yyerrlab;
1069
1070yyerrlab:
1071 yynewerrflag = 0;
1072yyerrhandler:
1073 while (yyps->save)
1074 {
1075 int ctry;
1076 YYParseState *save = yyps->save;
1077#if YYDEBUG
1078 if (yydebug)
1079 fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
1080 YYDEBUGSTR, yydepth, yystate, yyps->save->state,
1081 (int)(yylvp - yylvals - yyps->save->lexeme));
1082#endif
1083 /* Memorize most forward-looking error state in case it's really an error. */
1084 if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
1085 {
1086 /* Free old saved error context state */
1087 if (yyerrctx) yyFreeState(yyerrctx);
1088 /* Create and fill out new saved error context state */
1089 yyerrctx = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1090 if (yyerrctx == NULL) goto yyenomem;
1091 yyerrctx->save = yyps->save;
1092 yyerrctx->state = yystate;
1093 yyerrctx->errflag = yyerrflag;
1094 yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1095 memcpy (yyerrctx->yystack.s_base, yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1096 yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1097 memcpy (yyerrctx->yystack.l_base, yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1098#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1099 yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1100 memcpy (yyerrctx->yystack.p_base, yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1101#endif
1102 yyerrctx->lexeme = yylvp - yylvals;
1103 }
1104 yylvp = yylvals + save->lexeme;
1105#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1106 yylpp = yylpsns + save->lexeme;
1107#endif
1108 yylexp = yylexemes + save->lexeme;
1109 yychar = YYEMPTY;
1110 yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1111 memcpy (yystack.s_base, save->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1112 yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1113 memcpy (yystack.l_base, save->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1114#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1115 yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1116 memcpy (yystack.p_base, save->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1117#endif
1118 ctry = ++save->ctry;
1119 yystate = save->state;
1120 /* We tried shift, try reduce now */
1121 if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1122 yyps->save = save->save;
1123 save->save = NULL;
1124 yyFreeState(save);
1125
1126 /* Nothing left on the stack -- error */
1127 if (!yyps->save)
1128 {
1129#if YYDEBUG
1130 if (yydebug)
1131 fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1132 YYPREFIX, yydepth);
1133#endif
1134 /* Restore state as it was in the most forward-advanced error */
1135 yylvp = yylvals + yyerrctx->lexeme;
1136#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1137 yylpp = yylpsns + yyerrctx->lexeme;
1138#endif
1139 yylexp = yylexemes + yyerrctx->lexeme;
1140 yychar = yylexp[-1];
1141 yylval = yylvp[-1];
1142#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1143 yylloc = yylpp[-1];
1144#endif
1145 yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1146 memcpy (yystack.s_base, yyerrctx->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1147 yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1148 memcpy (yystack.l_base, yyerrctx->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1149#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1150 yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1151 memcpy (yystack.p_base, yyerrctx->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1152#endif
1153 yystate = yyerrctx->state;
1154 yyFreeState(yyerrctx);
1155 yyerrctx = NULL;
1156 }
1157 yynewerrflag = 1;
1158 }
1159 if (yynewerrflag == 0) goto yyinrecovery;
1160#endif /* YYBTYACC */
1161
1162 YYERROR_CALL("syntax error");
1163#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1164 yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1165#endif
1166
1167#if !YYBTYACC
1168 goto yyerrlab;
1169yyerrlab:
1170#endif
1171 ++yynerrs;
1172
1173yyinrecovery:
1174 if (yyerrflag < 3)
1175 {
1176 yyerrflag = 3;
1177 for (;;)
1178 {
1179 if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1180 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1181 {
1182#if YYDEBUG
1183 if (yydebug)
1184 fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1185 YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1186#endif
1187 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1188 yystate = yytable[yyn];
1189 *++yystack.s_mark = yytable[yyn];
1190 *++yystack.l_mark = yylval;
1191#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1192 /* lookahead position is error end position */
1193 yyerror_loc_range[1] = yylloc;
1194 YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1195 *++yystack.p_mark = yyloc;
1196#endif
1197 goto yyloop;
1198 }
1199 else
1200 {
1201#if YYDEBUG
1202 if (yydebug)
1203 fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1204 YYDEBUGSTR, yydepth, *yystack.s_mark);
1205#endif
1206 if (yystack.s_mark <= yystack.s_base) goto yyabort;
1207#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1208 /* the current TOS position is the error start position */
1209 yyerror_loc_range[0] = *yystack.p_mark;
1210#endif
1211#if defined(YYDESTRUCT_CALL)
1212#if YYBTYACC
1213 if (!yytrial)
1214#endif /* YYBTYACC */
1215#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1216 YYDESTRUCT_CALL("error: discarding state",
1217 yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1218#else
1219 YYDESTRUCT_CALL("error: discarding state",
1220 yystos[*yystack.s_mark], yystack.l_mark);
1221#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1222#endif /* defined(YYDESTRUCT_CALL) */
1223 --yystack.s_mark;
1224 --yystack.l_mark;
1225#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1226 --yystack.p_mark;
1227#endif
1228 }
1229 }
1230 }
1231 else
1232 {
1233 if (yychar == YYEOF) goto yyabort;
1234#if YYDEBUG
1235 if (yydebug)
1236 {
1237 yys = yyname[YYTRANSLATE(yychar)];
1238 fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1239 YYDEBUGSTR, yydepth, yystate, yychar, yys);
1240 }
1241#endif
1242#if defined(YYDESTRUCT_CALL)
1243#if YYBTYACC
1244 if (!yytrial)
1245#endif /* YYBTYACC */
1246#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1247 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1248#else
1249 YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1250#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1251#endif /* defined(YYDESTRUCT_CALL) */
1252 yychar = YYEMPTY;
1253 goto yyloop;
1254 }
1255
1256yyreduce:
1257 yym = yylen[yyn];
1258#if YYDEBUG
1259 if (yydebug)
1260 {
1261 fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1262 YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1263#ifdef YYSTYPE_TOSTRING
1264#if YYBTYACC
1265 if (!yytrial)
1266#endif /* YYBTYACC */
1267 if (yym > 0)
1268 {
1269 int i;
1270 fputc('<', stderr);
1271 for (i = yym; i > 0; i--)
1272 {
1273 if (i != yym) fputs(", ", stderr);
1274 fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1275 yystack.l_mark[1-i]), stderr);
1276 }
1277 fputc('>', stderr);
1278 }
1279#endif
1280 fputc('\n', stderr);
1281 }
1282#endif
1283 if (yym > 0)
1284 yyval = yystack.l_mark[1-yym];
1285 else
1286 memset(&yyval, 0, sizeof yyval);
1287#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1288
1289 /* Perform position reduction */
1290 memset(&yyloc, 0, sizeof(yyloc));
1291#if YYBTYACC
1292 if (!yytrial)
1293#endif /* YYBTYACC */
1294 {
1295 YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1296 /* just in case YYERROR is invoked within the action, save
1297 the start of the rhs as the error start position */
1298 yyerror_loc_range[0] = yystack.p_mark[1-yym];
1299 }
1300#endif
1301
1302 switch (yyn)
1303 {
1304case 2:
1305#line 51 "btyacc_calc1.y"
1306{YYVALID;}
1307break;
1308case 3:
1309#line 52 "btyacc_calc1.y"
1310{YYVALID;} if (!yytrial)
1311#line 53 "btyacc_calc1.y"
1312{
1313 yyerrok;
1314 }
1315break;
1316case 4:
1317 if (!yytrial)
1318#line 59 "btyacc_calc1.y"
1319 {
1320 (void) printf("%15.8f\n", yystack.l_mark[0].dval);
1321 }
1322break;
1323case 5:
1324 if (!yytrial)
1325#line 63 "btyacc_calc1.y"
1326 {
1327 (void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[0].vval.lo, yystack.l_mark[0].vval.hi);
1328 }
1329break;
1330case 6:
1331 if (!yytrial)
1332#line 67 "btyacc_calc1.y"
1333 {
1334 dreg[yystack.l_mark[-2].ival] = yystack.l_mark[0].dval;
1335 }
1336break;
1337case 7:
1338 if (!yytrial)
1339#line 71 "btyacc_calc1.y"
1340 {
1341 vreg[yystack.l_mark[-2].ival] = yystack.l_mark[0].vval;
1342 }
1343break;
1344case 9:
1345 if (!yytrial)
1346#line 78 "btyacc_calc1.y"
1347 {
1348 yyval.dval = dreg[yystack.l_mark[0].ival];
1349 }
1350break;
1351case 10:
1352 if (!yytrial)
1353#line 82 "btyacc_calc1.y"
1354 {
1355 yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval;
1356 }
1357break;
1358case 11:
1359 if (!yytrial)
1360#line 86 "btyacc_calc1.y"
1361 {
1362 yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval;
1363 }
1364break;
1365case 12:
1366 if (!yytrial)
1367#line 90 "btyacc_calc1.y"
1368 {
1369 yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval;
1370 }
1371break;
1372case 13:
1373 if (!yytrial)
1374#line 94 "btyacc_calc1.y"
1375 {
1376 yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval;
1377 }
1378break;
1379case 14:
1380 if (!yytrial)
1381#line 98 "btyacc_calc1.y"
1382 {
1383 yyval.dval = -yystack.l_mark[0].dval;
1384 }
1385break;
1386case 15:
1387 if (!yytrial)
1388#line 102 "btyacc_calc1.y"
1389 {
1390 yyval.dval = yystack.l_mark[-1].dval;
1391 }
1392break;
1393case 16:
1394 if (!yytrial)
1395#line 108 "btyacc_calc1.y"
1396 {
1397 yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval;
1398 }
1399break;
1400case 17:
1401 if (!yytrial)
1402#line 112 "btyacc_calc1.y"
1403 {
1404 yyval.vval.lo = yystack.l_mark[-3].dval;
1405 yyval.vval.hi = yystack.l_mark[-1].dval;
1406 if ( yyval.vval.lo > yyval.vval.hi )
1407 {
1408 (void) printf("interval out of order\n");
1409 YYERROR;
1410 }
1411 }
1412break;
1413case 18:
1414 if (!yytrial)
1415#line 122 "btyacc_calc1.y"
1416 {
1417 yyval.vval = vreg[yystack.l_mark[0].ival];
1418 }
1419break;
1420case 19:
1421 if (!yytrial)
1422#line 126 "btyacc_calc1.y"
1423 {
1424 yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi;
1425 yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo;
1426 }
1427break;
1428case 20:
1429 if (!yytrial)
1430#line 131 "btyacc_calc1.y"
1431 {
1432 yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi;
1433 yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo;
1434 }
1435break;
1436case 21:
1437 if (!yytrial)
1438#line 136 "btyacc_calc1.y"
1439 {
1440 yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo;
1441 yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi;
1442 }
1443break;
1444case 22:
1445 if (!yytrial)
1446#line 141 "btyacc_calc1.y"
1447 {
1448 yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo;
1449 yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi;
1450 }
1451break;
1452case 23:
1453 if (!yytrial)
1454#line 146 "btyacc_calc1.y"
1455 {
1456 yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
1457 }
1458break;
1459case 24:
1460 if (!yytrial)
1461#line 150 "btyacc_calc1.y"
1462 {
1463 yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
1464 }
1465break;
1466case 25:
1467 if (!yytrial)
1468#line 154 "btyacc_calc1.y"
1469 {
1470 if (dcheck(yystack.l_mark[0].vval)) YYERROR;
1471 yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
1472 }
1473break;
1474case 26:
1475 if (!yytrial)
1476#line 159 "btyacc_calc1.y"
1477 {
1478 if (dcheck ( yystack.l_mark[0].vval )) YYERROR;
1479 yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
1480 }
1481break;
1482case 27:
1483 if (!yytrial)
1484#line 164 "btyacc_calc1.y"
1485 {
1486 yyval.vval.hi = -yystack.l_mark[0].vval.lo;
1487 yyval.vval.lo = -yystack.l_mark[0].vval.hi;
1488 }
1489break;
1490case 28:
1491 if (!yytrial)
1492#line 169 "btyacc_calc1.y"
1493 {
1494 yyval.vval = yystack.l_mark[-1].vval;
1495 }
1496break;
1497#line 1498 "btyacc_calc1.tab.c"
1498 default:
1499 break;
1500 }
1501 yystack.s_mark -= yym;
1502 yystate = *yystack.s_mark;
1503 yystack.l_mark -= yym;
1504#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1505 yystack.p_mark -= yym;
1506#endif
1507 yym = yylhs[yyn];
1508 if (yystate == 0 && yym == 0)
1509 {
1510#if YYDEBUG
1511 if (yydebug)
1512 {
1513 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1514#ifdef YYSTYPE_TOSTRING
1515#if YYBTYACC
1516 if (!yytrial)
1517#endif /* YYBTYACC */
1518 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1519#endif
1520 fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1521 }
1522#endif
1523 yystate = YYFINAL;
1524 *++yystack.s_mark = YYFINAL;
1525 *++yystack.l_mark = yyval;
1526#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1527 *++yystack.p_mark = yyloc;
1528#endif
1529 if (yychar < 0)
1530 {
1531#if YYBTYACC
1532 do {
1533 if (yylvp < yylve)
1534 {
1535 /* we're currently re-reading tokens */
1536 yylval = *yylvp++;
1537#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1538 yylloc = *yylpp++;
1539#endif
1540 yychar = *yylexp++;
1541 break;
1542 }
1543 if (yyps->save)
1544 {
1545 /* in trial mode; save scanner results for future parse attempts */
1546 if (yylvp == yylvlim)
1547 { /* Enlarge lexical value queue */
1548 int p = yylvp - yylvals;
1549 int s = yylvlim - yylvals;
1550
1551 s += YYLVQUEUEGROWTH;
1552 if ((yylexemes = (short *) realloc(yylexemes, s * sizeof(short))) == NULL)
1553 goto yyenomem;
1554 if ((yylvals = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1555 goto yyenomem;
1556#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1557 if ((yylpsns = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1558 goto yyenomem;
1559#endif
1560 yylvp = yylve = yylvals + p;
1561 yylvlim = yylvals + s;
1562#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1563 yylpp = yylpe = yylpsns + p;
1564 yylplim = yylpsns + s;
1565#endif
1566 yylexp = yylexemes + p;
1567 }
1568 *yylexp = (short) YYLEX;
1569 *yylvp++ = yylval;
1570 yylve++;
1571#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1572 *yylpp++ = yylloc;
1573 yylpe++;
1574#endif
1575 yychar = *yylexp++;
1576 break;
1577 }
1578 /* normal operation, no conflict encountered */
1579#endif /* YYBTYACC */
1580 yychar = YYLEX;
1581#if YYBTYACC
1582 } while (0);
1583#endif /* YYBTYACC */
1584 if (yychar < 0) yychar = YYEOF;
1585 /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
1586#if YYDEBUG
1587 if (yydebug)
1588 {
1589 yys = yyname[YYTRANSLATE(yychar)];
1590 fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n",
1591 YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1592 }
1593#endif
1594 }
1595 if (yychar == YYEOF) goto yyaccept;
1596 goto yyloop;
1597 }
1598 if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1599 yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1600 yystate = yytable[yyn];
1601 else
1602 yystate = yydgoto[yym];
1603#if YYDEBUG
1604 if (yydebug)
1605 {
1606 fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1607#ifdef YYSTYPE_TOSTRING
1608#if YYBTYACC
1609 if (!yytrial)
1610#endif /* YYBTYACC */
1611 fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1612#endif
1613 fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1614 }
1615#endif
1616 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1617 *++yystack.s_mark = (short) yystate;
1618 *++yystack.l_mark = yyval;
1619#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1620 *++yystack.p_mark = yyloc;
1621#endif
1622 goto yyloop;
1623#if YYBTYACC
1624
1625 /* Reduction declares that this path is valid. Set yypath and do a full parse */
1626yyvalid:
1627 if (yypath) YYABORT;
1628 while (yyps->save)
1629 {
1630 YYParseState *save = yyps->save;
1631 yyps->save = save->save;
1632 save->save = yypath;
1633 yypath = save;
1634 }
1635#if YYDEBUG
1636 if (yydebug)
1637 fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1638 YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1639#endif
1640 if (yyerrctx)
1641 {
1642 yyFreeState(yyerrctx);
1643 yyerrctx = NULL;
1644 }
1645 yylvp = yylvals + yypath->lexeme;
1646#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1647 yylpp = yylpsns + yypath->lexeme;
1648#endif
1649 yylexp = yylexemes + yypath->lexeme;
1650 yychar = YYEMPTY;
1651 yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1652 memcpy (yystack.s_base, yypath->yystack.s_base, (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1653 yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1654 memcpy (yystack.l_base, yypath->yystack.l_base, (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1655#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1656 yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1657 memcpy (yystack.p_base, yypath->yystack.p_base, (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1658#endif
1659 yystate = yypath->state;
1660 goto yyloop;
1661#endif /* YYBTYACC */
1662
1663yyoverflow:
1664 YYERROR_CALL("yacc stack overflow");
1665#if YYBTYACC
1666 goto yyabort_nomem;
1667yyenomem:
1668 YYERROR_CALL("memory exhausted");
1669yyabort_nomem:
1670#endif /* YYBTYACC */
1671 yyresult = 2;
1672 goto yyreturn;
1673
1674yyabort:
1675 yyresult = 1;
1676 goto yyreturn;
1677
1678yyaccept:
1679#if YYBTYACC
1680 if (yyps->save) goto yyvalid;
1681#endif /* YYBTYACC */
1682 yyresult = 0;
1683
1684yyreturn:
1685#if defined(YYDESTRUCT_CALL)
1686 if (yychar != YYEOF && yychar != YYEMPTY)
1687#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1688 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1689#else
1690 YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1691#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1692
1693 {
1694 YYSTYPE *pv;
1695#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1696 YYLTYPE *pp;
1697
1698 for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1699 YYDESTRUCT_CALL("cleanup: discarding state",
1700 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1701#else
1702 for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1703 YYDESTRUCT_CALL("cleanup: discarding state",
1704 yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1705#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1706 }
1707#endif /* defined(YYDESTRUCT_CALL) */
1708
1709#if YYBTYACC
1710 if (yyerrctx)
1711 {
1712 yyFreeState(yyerrctx);
1713 yyerrctx = NULL;
1714 }
1715 while (yyps)
1716 {
1717 YYParseState *save = yyps;
1718 yyps = save->save;
1719 save->save = NULL;
1720 yyFreeState(save);
1721 }
1722 while (yypath)
1723 {
1724 YYParseState *save = yypath;
1725 yypath = save->save;
1726 save->save = NULL;
1727 yyFreeState(save);
1728 }
1729#endif /* YYBTYACC */
1730 yyfreestack(&yystack);
1731 return (yyresult);
1732}