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