1 /* $NetBSD: calc1.tab.c,v 1.1.1.1 2015/01/03 22:58:24 christos Exp $ */
2
3 /* original parser id follows */
4 /* yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93" */
5 /* (use YYMAJOR/YYMINOR for ifdefs dependent on parser version) */
6
7 #define YYBYACC 1
8 #define YYMAJOR 1
9 #define YYMINOR 9
10 #define YYCHECK "yyyymmdd"
11
12 #define YYEMPTY (-1)
13 #define yyclearin (yychar = YYEMPTY)
14 #define yyerrok (yyerrflag = 0)
15 #define YYRECOVERING() (yyerrflag != 0)
16 #define YYENOMEM (-2)
17 #define YYEOF 0
18
19 #ifndef yyparse
20 #define yyparse calc1_parse
21 #endif /* yyparse */
22
23 #ifndef yylex
24 #define yylex calc1_lex
25 #endif /* yylex */
26
27 #ifndef yyerror
28 #define yyerror calc1_error
29 #endif /* yyerror */
30
31 #ifndef yychar
32 #define yychar calc1_char
33 #endif /* yychar */
34
35 #ifndef yyval
36 #define yyval calc1_val
37 #endif /* yyval */
38
39 #ifndef yylval
40 #define yylval calc1_lval
41 #endif /* yylval */
42
43 #ifndef yydebug
44 #define yydebug calc1_debug
45 #endif /* yydebug */
46
47 #ifndef yynerrs
48 #define yynerrs calc1_nerrs
49 #endif /* yynerrs */
50
51 #ifndef yyerrflag
52 #define yyerrflag calc1_errflag
53 #endif /* yyerrflag */
54
55 #ifndef yylhs
56 #define yylhs calc1_lhs
57 #endif /* yylhs */
58
59 #ifndef yylen
60 #define yylen calc1_len
61 #endif /* yylen */
62
63 #ifndef yydefred
64 #define yydefred calc1_defred
65 #endif /* yydefred */
66
67 #ifndef yydgoto
68 #define yydgoto calc1_dgoto
69 #endif /* yydgoto */
70
71 #ifndef yysindex
72 #define yysindex calc1_sindex
73 #endif /* yysindex */
74
75 #ifndef yyrindex
76 #define yyrindex calc1_rindex
77 #endif /* yyrindex */
78
79 #ifndef yygindex
80 #define yygindex calc1_gindex
81 #endif /* yygindex */
82
83 #ifndef yytable
84 #define yytable calc1_table
85 #endif /* yytable */
86
87 #ifndef yycheck
88 #define yycheck calc1_check
89 #endif /* yycheck */
90
91 #ifndef yyname
92 #define yyname calc1_name
93 #endif /* yyname */
94
95 #ifndef yyrule
96 #define yyrule calc1_rule
97 #endif /* yyrule */
98 #define YYPREFIX "calc1_"
99
100 #define YYPURE 0
101
102 #line 2 "calc1.y"
103
104 /* http://dinosaur.compilertools.net/yacc/index.html */
105
106 #include <stdlib.h>
107 #include <stdio.h>
108 #include <ctype.h>
109 #include <math.h>
110
111 typedef struct interval
112 {
113 double lo, hi;
114 }
115 INTERVAL;
116
117 INTERVAL vmul(double, double, INTERVAL);
118 INTERVAL vdiv(double, double, INTERVAL);
119
120 extern int yylex(void);
121 static void yyerror(const char *s);
122
123 int dcheck(INTERVAL);
124
125 double dreg[26];
126 INTERVAL vreg[26];
127
128 #line 31 "calc1.y"
129 #ifdef YYSTYPE
130 #undef YYSTYPE_IS_DECLARED
131 #define YYSTYPE_IS_DECLARED 1
132 #endif
133 #ifndef YYSTYPE_IS_DECLARED
134 #define YYSTYPE_IS_DECLARED 1
135 typedef union
136 {
137 int ival;
138 double dval;
139 INTERVAL vval;
140 } YYSTYPE;
141 #endif /* !YYSTYPE_IS_DECLARED */
142 #line 141 "calc1.tab.c"
143
144 /* compatibility with bison */
145 #ifdef YYPARSE_PARAM
146 /* compatibility with FreeBSD */
147 # ifdef YYPARSE_PARAM_TYPE
148 # define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
149 # else
150 # define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
151 # endif
152 #else
153 # define YYPARSE_DECL() yyparse(void)
154 #endif
155
156 /* Parameters sent to lex. */
157 #ifdef YYLEX_PARAM
158 # define YYLEX_DECL() yylex(void *YYLEX_PARAM)
159 # define YYLEX yylex(YYLEX_PARAM)
160 #else
161 # define YYLEX_DECL() yylex(void)
162 # define YYLEX yylex()
163 #endif
164
165 /* Parameters sent to yyerror. */
166 #ifndef YYERROR_DECL
167 #define YYERROR_DECL() yyerror(const char *s)
168 #endif
169 #ifndef YYERROR_CALL
170 #define YYERROR_CALL(msg) yyerror(msg)
171 #endif
172
173 extern int YYPARSE_DECL();
174
175 #define DREG 257
176 #define VREG 258
177 #define CONST 259
178 #define UMINUS 260
179 #define YYERRCODE 256
180 typedef short YYINT;
181 static const YYINT calc1_lhs[] = { -1,
182 3, 3, 0, 0, 0, 0, 0, 1, 1, 1,
183 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
184 2, 2, 2, 2, 2, 2, 2, 2,
185 };
186 static const YYINT calc1_len[] = { 2,
187 0, 2, 2, 2, 4, 4, 2, 1, 1, 3,
188 3, 3, 3, 2, 3, 1, 5, 1, 3, 3,
189 3, 3, 3, 3, 3, 3, 2, 3,
190 };
191 static const YYINT calc1_defred[] = { 0,
192 0, 0, 0, 8, 0, 0, 0, 0, 0, 7,
193 0, 0, 9, 18, 14, 27, 0, 0, 0, 0,
194 0, 0, 3, 0, 0, 0, 0, 4, 0, 0,
195 0, 0, 0, 15, 0, 28, 0, 0, 0, 0,
196 12, 24, 13, 26, 0, 0, 23, 25, 14, 0,
197 0, 0, 0, 0, 5, 6, 0, 0, 0, 12,
198 13, 17,
199 };
200 static const YYINT calc1_dgoto[] = { 7,
201 32, 9, 0,
202 };
203 static const YYINT calc1_sindex[] = { -40,
204 -8, -48, -47, 0, -37, -37, 0, 2, 17, 0,
205 -34, -37, 0, 0, 0, 0, -25, 90, -37, -37,
206 -37, -37, 0, -37, -37, -37, -37, 0, -34, -34,
207 25, 125, 31, 0, -34, 0, -11, 37, -11, 37,
208 0, 0, 0, 0, 37, 37, 0, 0, 0, 111,
209 -34, -34, -34, -34, 0, 0, 118, 69, 69, 0,
210 0, 0,
211 };
212 static const YYINT calc1_rindex[] = { 0,
213 0, 38, 44, 0, 0, 0, 0, 0, 0, 0,
214 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
215 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
216 0, -9, 0, 0, 0, 0, 51, -3, 56, 61,
217 0, 0, 0, 0, 67, 72, 0, 0, 0, 0,
218 0, 0, 0, 0, 0, 0, 0, 78, 83, 0,
219 0, 0,
220 };
221 static const YYINT calc1_gindex[] = { 0,
222 4, 124, 0,
223 };
224 #define YYTABLESIZE 225
225 static const YYINT calc1_table[] = { 6,
226 16, 10, 6, 8, 5, 30, 20, 5, 15, 17,
227 29, 23, 11, 12, 31, 34, 21, 19, 35, 20,
228 0, 22, 37, 39, 41, 43, 28, 0, 0, 0,
229 21, 16, 49, 50, 55, 22, 0, 20, 57, 20,
230 56, 20, 0, 21, 19, 0, 20, 9, 22, 0,
231 0, 0, 0, 18, 58, 59, 60, 61, 26, 24,
232 10, 25, 0, 27, 0, 11, 53, 51, 0, 52,
233 22, 54, 26, 24, 0, 25, 19, 27, 26, 9,
234 9, 21, 9, 27, 9, 18, 18, 10, 18, 0,
235 18, 10, 11, 10, 10, 10, 11, 0, 11, 11,
236 11, 22, 0, 22, 0, 22, 0, 19, 0, 19,
237 53, 19, 21, 0, 21, 54, 21, 0, 10, 0,
238 10, 0, 10, 11, 0, 11, 0, 11, 16, 18,
239 36, 26, 24, 0, 25, 33, 27, 0, 0, 0,
240 0, 0, 38, 40, 42, 44, 0, 45, 46, 47,
241 48, 34, 53, 51, 0, 52, 0, 54, 62, 53,
242 51, 0, 52, 0, 54, 0, 21, 19, 0, 20,
243 0, 22, 0, 0, 0, 0, 0, 0, 0, 0,
244 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
245 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
246 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
247 0, 0, 0, 0, 0, 1, 2, 3, 4, 13,
248 14, 4, 13, 0, 4,
249 };
250 static const YYINT calc1_check[] = { 40,
251 10, 10, 40, 0, 45, 40, 10, 45, 5, 6,
252 45, 10, 61, 61, 11, 41, 42, 43, 44, 45,
253 -1, 47, 19, 20, 21, 22, 10, -1, -1, -1,
254 42, 41, 29, 30, 10, 47, -1, 41, 35, 43,
255 10, 45, -1, 42, 43, -1, 45, 10, 47, -1,
256 -1, -1, -1, 10, 51, 52, 53, 54, 42, 43,
257 10, 45, -1, 47, -1, 10, 42, 43, -1, 45,
258 10, 47, 42, 43, -1, 45, 10, 47, 42, 42,
259 43, 10, 45, 47, 47, 42, 43, 10, 45, -1,
260 47, 41, 10, 43, 44, 45, 41, -1, 43, 44,
261 45, 41, -1, 43, -1, 45, -1, 41, -1, 43,
262 42, 45, 41, -1, 43, 47, 45, -1, 41, -1,
263 43, -1, 45, 41, -1, 43, -1, 45, 5, 6,
264 41, 42, 43, -1, 45, 12, 47, -1, -1, -1,
265 -1, -1, 19, 20, 21, 22, -1, 24, 25, 26,
266 27, 41, 42, 43, -1, 45, -1, 47, 41, 42,
267 43, -1, 45, -1, 47, -1, 42, 43, -1, 45,
268 -1, 47, -1, -1, -1, -1, -1, -1, -1, -1,
269 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
270 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
271 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
272 -1, -1, -1, -1, -1, 256, 257, 258, 259, 257,
273 258, 259, 257, -1, 259,
274 };
275 #define YYFINAL 7
276 #ifndef YYDEBUG
277 #define YYDEBUG 0
278 #endif
279 #define YYMAXTOKEN 260
280 #define YYUNDFTOKEN 266
281 #define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
282 #if YYDEBUG
283 static const char *const calc1_name[] = {
284
285 "end-of-file",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,
286 0,0,0,0,0,0,0,0,0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,0,0,0,0,
287 0,0,0,0,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
288 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
289 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
290 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
291 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
292 0,0,"DREG","VREG","CONST","UMINUS",0,0,0,0,0,"illegal-symbol",
293 };
294 static const char *const calc1_rule[] = {
295 "$accept : line",
296 "lines :",
297 "lines : lines line",
298 "line : dexp '\\n'",
299 "line : vexp '\\n'",
300 "line : DREG '=' dexp '\\n'",
301 "line : VREG '=' vexp '\\n'",
302 "line : error '\\n'",
303 "dexp : CONST",
304 "dexp : DREG",
305 "dexp : dexp '+' dexp",
306 "dexp : dexp '-' dexp",
307 "dexp : dexp '*' dexp",
308 "dexp : dexp '/' dexp",
309 "dexp : '-' dexp",
310 "dexp : '(' dexp ')'",
311 "vexp : dexp",
312 "vexp : '(' dexp ',' dexp ')'",
313 "vexp : VREG",
314 "vexp : vexp '+' vexp",
315 "vexp : dexp '+' vexp",
316 "vexp : vexp '-' vexp",
317 "vexp : dexp '-' vexp",
318 "vexp : vexp '*' vexp",
319 "vexp : dexp '*' vexp",
320 "vexp : vexp '/' vexp",
321 "vexp : dexp '/' vexp",
322 "vexp : '-' vexp",
323 "vexp : '(' vexp ')'",
324
325 };
326 #endif
327
328 int yydebug;
329 int yynerrs;
330
331 int yyerrflag;
332 int yychar;
333 YYSTYPE yyval;
334 YYSTYPE yylval;
335
336 /* define the initial stack-sizes */
337 #ifdef YYSTACKSIZE
338 #undef YYMAXDEPTH
339 #define YYMAXDEPTH YYSTACKSIZE
340 #else
341 #ifdef YYMAXDEPTH
342 #define YYSTACKSIZE YYMAXDEPTH
343 #else
344 #define YYSTACKSIZE 10000
345 #define YYMAXDEPTH 10000
346 #endif
347 #endif
348
349 #define YYINITSTACKSIZE 200
350
351 typedef struct {
352 unsigned stacksize;
353 YYINT *s_base;
354 YYINT *s_mark;
355 YYINT *s_last;
356 YYSTYPE *l_base;
357 YYSTYPE *l_mark;
358 } YYSTACKDATA;
359 /* variables for the parser stack */
360 static YYSTACKDATA yystack;
361 #line 176 "calc1.y"
362 /* beginning of subroutines section */
363
364 #define BSZ 50 /* buffer size for floating point numbers */
365
366 /* lexical analysis */
367
368 static void
yyerror(const char * s)369 yyerror(const char *s)
370 {
371 fprintf(stderr, "%s\n", s);
372 }
373
374 int
yylex(void)375 yylex(void)
376 {
377 int c;
378
379 while ((c = getchar()) == ' ')
380 { /* skip over blanks */
381 }
382
383 if (isupper(c))
384 {
385 yylval.ival = c - 'A';
386 return (VREG);
387 }
388 if (islower(c))
389 {
390 yylval.ival = c - 'a';
391 return (DREG);
392 }
393
394 if (isdigit(c) || c == '.')
395 {
396 /* gobble up digits, points, exponents */
397 char buf[BSZ + 1], *cp = buf;
398 int dot = 0, expr = 0;
399
400 for (; (cp - buf) < BSZ; ++cp, c = getchar())
401 {
402
403 *cp = (char) c;
404 if (isdigit(c))
405 continue;
406 if (c == '.')
407 {
408 if (dot++ || expr)
409 return ('.'); /* will cause syntax error */
410 continue;
411 }
412
413 if (c == 'e')
414 {
415 if (expr++)
416 return ('e'); /* will cause syntax error */
417 continue;
418 }
419
420 /* end of number */
421 break;
422 }
423 *cp = '\0';
424
425 if ((cp - buf) >= BSZ)
426 printf("constant too long: truncated\n");
427 else
428 ungetc(c, stdin); /* push back last char read */
429 yylval.dval = atof(buf);
430 return (CONST);
431 }
432 return (c);
433 }
434
435 static INTERVAL
hilo(double a,double b,double c,double d)436 hilo(double a, double b, double c, double d)
437 {
438 /* returns the smallest interval containing a, b, c, and d */
439 /* used by *, / routines */
440 INTERVAL v;
441
442 if (a > b)
443 {
444 v.hi = a;
445 v.lo = b;
446 }
447 else
448 {
449 v.hi = b;
450 v.lo = a;
451 }
452
453 if (c > d)
454 {
455 if (c > v.hi)
456 v.hi = c;
457 if (d < v.lo)
458 v.lo = d;
459 }
460 else
461 {
462 if (d > v.hi)
463 v.hi = d;
464 if (c < v.lo)
465 v.lo = c;
466 }
467 return (v);
468 }
469
470 INTERVAL
vmul(double a,double b,INTERVAL v)471 vmul(double a, double b, INTERVAL v)
472 {
473 return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo));
474 }
475
476 int
dcheck(INTERVAL v)477 dcheck(INTERVAL v)
478 {
479 if (v.hi >= 0. && v.lo <= 0.)
480 {
481 printf("divisor interval contains 0.\n");
482 return (1);
483 }
484 return (0);
485 }
486
487 INTERVAL
vdiv(double a,double b,INTERVAL v)488 vdiv(double a, double b, INTERVAL v)
489 {
490 return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
491 }
492 #line 491 "calc1.tab.c"
493
494 #if YYDEBUG
495 #include <stdio.h> /* needed for printf */
496 #endif
497
498 #include <stdlib.h> /* needed for malloc, etc */
499 #include <string.h> /* needed for memset */
500
501 /* allocate initial stack or double stack size, up to YYMAXDEPTH */
yygrowstack(YYSTACKDATA * data)502 static int yygrowstack(YYSTACKDATA *data)
503 {
504 int i;
505 unsigned newsize;
506 YYINT *newss;
507 YYSTYPE *newvs;
508
509 if ((newsize = data->stacksize) == 0)
510 newsize = YYINITSTACKSIZE;
511 else if (newsize >= YYMAXDEPTH)
512 return YYENOMEM;
513 else if ((newsize *= 2) > YYMAXDEPTH)
514 newsize = YYMAXDEPTH;
515
516 i = (int) (data->s_mark - data->s_base);
517 newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
518 if (newss == 0)
519 return YYENOMEM;
520
521 data->s_base = newss;
522 data->s_mark = newss + i;
523
524 newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
525 if (newvs == 0)
526 return YYENOMEM;
527
528 data->l_base = newvs;
529 data->l_mark = newvs + i;
530
531 data->stacksize = newsize;
532 data->s_last = data->s_base + newsize - 1;
533 return 0;
534 }
535
536 #if YYPURE || defined(YY_NO_LEAKS)
yyfreestack(YYSTACKDATA * data)537 static void yyfreestack(YYSTACKDATA *data)
538 {
539 free(data->s_base);
540 free(data->l_base);
541 memset(data, 0, sizeof(*data));
542 }
543 #else
544 #define yyfreestack(data) /* nothing */
545 #endif
546
547 #define YYABORT goto yyabort
548 #define YYREJECT goto yyabort
549 #define YYACCEPT goto yyaccept
550 #define YYERROR goto yyerrlab
551
552 int
YYPARSE_DECL()553 YYPARSE_DECL()
554 {
555 int yym, yyn, yystate;
556 #if YYDEBUG
557 const char *yys;
558
559 if ((yys = getenv("YYDEBUG")) != 0)
560 {
561 yyn = *yys;
562 if (yyn >= '0' && yyn <= '9')
563 yydebug = yyn - '0';
564 }
565 #endif
566
567 yynerrs = 0;
568 yyerrflag = 0;
569 yychar = YYEMPTY;
570 yystate = 0;
571
572 #if YYPURE
573 memset(&yystack, 0, sizeof(yystack));
574 #endif
575
576 if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
577 yystack.s_mark = yystack.s_base;
578 yystack.l_mark = yystack.l_base;
579 yystate = 0;
580 *yystack.s_mark = 0;
581
582 yyloop:
583 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
584 if (yychar < 0)
585 {
586 if ((yychar = YYLEX) < 0) yychar = YYEOF;
587 #if YYDEBUG
588 if (yydebug)
589 {
590 yys = yyname[YYTRANSLATE(yychar)];
591 printf("%sdebug: state %d, reading %d (%s)\n",
592 YYPREFIX, yystate, yychar, yys);
593 }
594 #endif
595 }
596 if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
597 yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
598 {
599 #if YYDEBUG
600 if (yydebug)
601 printf("%sdebug: state %d, shifting to state %d\n",
602 YYPREFIX, yystate, yytable[yyn]);
603 #endif
604 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
605 {
606 goto yyoverflow;
607 }
608 yystate = yytable[yyn];
609 *++yystack.s_mark = yytable[yyn];
610 *++yystack.l_mark = yylval;
611 yychar = YYEMPTY;
612 if (yyerrflag > 0) --yyerrflag;
613 goto yyloop;
614 }
615 if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
616 yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
617 {
618 yyn = yytable[yyn];
619 goto yyreduce;
620 }
621 if (yyerrflag) goto yyinrecovery;
622
623 YYERROR_CALL("syntax error");
624
625 goto yyerrlab;
626
627 yyerrlab:
628 ++yynerrs;
629
630 yyinrecovery:
631 if (yyerrflag < 3)
632 {
633 yyerrflag = 3;
634 for (;;)
635 {
636 if ((yyn = yysindex[*yystack.s_mark]) && (yyn += YYERRCODE) >= 0 &&
637 yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
638 {
639 #if YYDEBUG
640 if (yydebug)
641 printf("%sdebug: state %d, error recovery shifting\
642 to state %d\n", YYPREFIX, *yystack.s_mark, yytable[yyn]);
643 #endif
644 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
645 {
646 goto yyoverflow;
647 }
648 yystate = yytable[yyn];
649 *++yystack.s_mark = yytable[yyn];
650 *++yystack.l_mark = yylval;
651 goto yyloop;
652 }
653 else
654 {
655 #if YYDEBUG
656 if (yydebug)
657 printf("%sdebug: error recovery discarding state %d\n",
658 YYPREFIX, *yystack.s_mark);
659 #endif
660 if (yystack.s_mark <= yystack.s_base) goto yyabort;
661 --yystack.s_mark;
662 --yystack.l_mark;
663 }
664 }
665 }
666 else
667 {
668 if (yychar == YYEOF) goto yyabort;
669 #if YYDEBUG
670 if (yydebug)
671 {
672 yys = yyname[YYTRANSLATE(yychar)];
673 printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
674 YYPREFIX, yystate, yychar, yys);
675 }
676 #endif
677 yychar = YYEMPTY;
678 goto yyloop;
679 }
680
681 yyreduce:
682 #if YYDEBUG
683 if (yydebug)
684 printf("%sdebug: state %d, reducing by rule %d (%s)\n",
685 YYPREFIX, yystate, yyn, yyrule[yyn]);
686 #endif
687 yym = yylen[yyn];
688 if (yym)
689 yyval = yystack.l_mark[1-yym];
690 else
691 memset(&yyval, 0, sizeof yyval);
692 switch (yyn)
693 {
694 case 3:
695 #line 57 "calc1.y"
696 {
697 (void) printf("%15.8f\n", yystack.l_mark[-1].dval);
698 }
699 break;
700 case 4:
701 #line 61 "calc1.y"
702 {
703 (void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[-1].vval.lo, yystack.l_mark[-1].vval.hi);
704 }
705 break;
706 case 5:
707 #line 65 "calc1.y"
708 {
709 dreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].dval;
710 }
711 break;
712 case 6:
713 #line 69 "calc1.y"
714 {
715 vreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].vval;
716 }
717 break;
718 case 7:
719 #line 73 "calc1.y"
720 {
721 yyerrok;
722 }
723 break;
724 case 9:
725 #line 80 "calc1.y"
726 {
727 yyval.dval = dreg[yystack.l_mark[0].ival];
728 }
729 break;
730 case 10:
731 #line 84 "calc1.y"
732 {
733 yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval;
734 }
735 break;
736 case 11:
737 #line 88 "calc1.y"
738 {
739 yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval;
740 }
741 break;
742 case 12:
743 #line 92 "calc1.y"
744 {
745 yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval;
746 }
747 break;
748 case 13:
749 #line 96 "calc1.y"
750 {
751 yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval;
752 }
753 break;
754 case 14:
755 #line 100 "calc1.y"
756 {
757 yyval.dval = -yystack.l_mark[0].dval;
758 }
759 break;
760 case 15:
761 #line 104 "calc1.y"
762 {
763 yyval.dval = yystack.l_mark[-1].dval;
764 }
765 break;
766 case 16:
767 #line 110 "calc1.y"
768 {
769 yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval;
770 }
771 break;
772 case 17:
773 #line 114 "calc1.y"
774 {
775 yyval.vval.lo = yystack.l_mark[-3].dval;
776 yyval.vval.hi = yystack.l_mark[-1].dval;
777 if ( yyval.vval.lo > yyval.vval.hi )
778 {
779 (void) printf("interval out of order\n");
780 YYERROR;
781 }
782 }
783 break;
784 case 18:
785 #line 124 "calc1.y"
786 {
787 yyval.vval = vreg[yystack.l_mark[0].ival];
788 }
789 break;
790 case 19:
791 #line 128 "calc1.y"
792 {
793 yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi;
794 yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo;
795 }
796 break;
797 case 20:
798 #line 133 "calc1.y"
799 {
800 yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi;
801 yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo;
802 }
803 break;
804 case 21:
805 #line 138 "calc1.y"
806 {
807 yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo;
808 yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi;
809 }
810 break;
811 case 22:
812 #line 143 "calc1.y"
813 {
814 yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo;
815 yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi;
816 }
817 break;
818 case 23:
819 #line 148 "calc1.y"
820 {
821 yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
822 }
823 break;
824 case 24:
825 #line 152 "calc1.y"
826 {
827 yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
828 }
829 break;
830 case 25:
831 #line 156 "calc1.y"
832 {
833 if (dcheck(yystack.l_mark[0].vval)) YYERROR;
834 yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
835 }
836 break;
837 case 26:
838 #line 161 "calc1.y"
839 {
840 if (dcheck ( yystack.l_mark[0].vval )) YYERROR;
841 yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
842 }
843 break;
844 case 27:
845 #line 166 "calc1.y"
846 {
847 yyval.vval.hi = -yystack.l_mark[0].vval.lo;
848 yyval.vval.lo = -yystack.l_mark[0].vval.hi;
849 }
850 break;
851 case 28:
852 #line 171 "calc1.y"
853 {
854 yyval.vval = yystack.l_mark[-1].vval;
855 }
856 break;
857 #line 856 "calc1.tab.c"
858 }
859 yystack.s_mark -= yym;
860 yystate = *yystack.s_mark;
861 yystack.l_mark -= yym;
862 yym = yylhs[yyn];
863 if (yystate == 0 && yym == 0)
864 {
865 #if YYDEBUG
866 if (yydebug)
867 printf("%sdebug: after reduction, shifting from state 0 to\
868 state %d\n", YYPREFIX, YYFINAL);
869 #endif
870 yystate = YYFINAL;
871 *++yystack.s_mark = YYFINAL;
872 *++yystack.l_mark = yyval;
873 if (yychar < 0)
874 {
875 if ((yychar = YYLEX) < 0) yychar = YYEOF;
876 #if YYDEBUG
877 if (yydebug)
878 {
879 yys = yyname[YYTRANSLATE(yychar)];
880 printf("%sdebug: state %d, reading %d (%s)\n",
881 YYPREFIX, YYFINAL, yychar, yys);
882 }
883 #endif
884 }
885 if (yychar == YYEOF) goto yyaccept;
886 goto yyloop;
887 }
888 if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
889 yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
890 yystate = yytable[yyn];
891 else
892 yystate = yydgoto[yym];
893 #if YYDEBUG
894 if (yydebug)
895 printf("%sdebug: after reduction, shifting from state %d \
896 to state %d\n", YYPREFIX, *yystack.s_mark, yystate);
897 #endif
898 if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
899 {
900 goto yyoverflow;
901 }
902 *++yystack.s_mark = (YYINT) yystate;
903 *++yystack.l_mark = yyval;
904 goto yyloop;
905
906 yyoverflow:
907 YYERROR_CALL("yacc stack overflow");
908
909 yyabort:
910 yyfreestack(&yystack);
911 return (1);
912
913 yyaccept:
914 yyfreestack(&yystack);
915 return (0);
916 }
917