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