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