varsyntax_calc1.tab.c revision 1.2 
1/*	$NetBSD: varsyntax_calc1.tab.c,v 1.2 2017/02/11 19:33:13 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#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
329int      yydebug;
330int      yynerrs;
331
332int      yyerrflag;
333int      yychar;
334YYSTYPE  yyval;
335YYSTYPE  yylval;
336
337/* define the initial stack-sizes */
338#ifdef YYSTACKSIZE
339#undef YYMAXDEPTH
340#define YYMAXDEPTH  YYSTACKSIZE
341#else
342#ifdef YYMAXDEPTH
343#define YYSTACKSIZE YYMAXDEPTH
344#else
345#define YYSTACKSIZE 10000
346#define YYMAXDEPTH  10000
347#endif
348#endif
349
350#define YYINITSTACKSIZE 200
351
352typedef struct {
353    unsigned stacksize;
354    YYINT    *s_base;
355    YYINT    *s_mark;
356    YYINT    *s_last;
357    YYSTYPE  *l_base;
358    YYSTYPE  *l_mark;
359} YYSTACKDATA;
360/* variables for the parser stack */
361static YYSTACKDATA yystack;
362#line 178 "varsyntax_calc1.y"
363	/* beginning of subroutines section */
364
365#define BSZ 50			/* buffer size for floating point numbers */
366
367	/* lexical analysis */
368
369static void
370yyerror(const char *s)
371{
372    fprintf(stderr, "%s\n", s);
373}
374
375int
376yylex(void)
377{
378    int c;
379
380    while ((c = getchar()) == ' ')
381    {				/* skip over blanks */
382    }
383
384    if (isupper(c))
385    {
386	yylval.ival = c - 'A';
387	return (VREG);
388    }
389    if (islower(c))
390    {
391	yylval.ival = c - 'a';
392	return (DREG);
393    }
394
395    if (isdigit(c) || c == '.')
396    {
397	/* gobble up digits, points, exponents */
398	char buf[BSZ + 1], *cp = buf;
399	int dot = 0, expr = 0;
400
401	for (; (cp - buf) < BSZ; ++cp, c = getchar())
402	{
403
404	    *cp = (char) c;
405	    if (isdigit(c))
406		continue;
407	    if (c == '.')
408	    {
409		if (dot++ || expr)
410		    return ('.');	/* will cause syntax error */
411		continue;
412	    }
413
414	    if (c == 'e')
415	    {
416		if (expr++)
417		    return ('e');	/*  will  cause  syntax  error  */
418		continue;
419	    }
420
421	    /*  end  of  number  */
422	    break;
423	}
424	*cp = '\0';
425
426	if ((cp - buf) >= BSZ)
427	    printf("constant  too  long:  truncated\n");
428	else
429	    ungetc(c, stdin);	/*  push  back  last  char  read  */
430	yylval.dval = atof(buf);
431	return (CONST);
432    }
433    return (c);
434}
435
436static INTERVAL
437hilo(double a, double b, double c, double d)
438{
439    /*  returns  the  smallest  interval  containing  a,  b,  c,  and  d  */
440    /*  used  by  *,  /  routines  */
441    INTERVAL v;
442
443    if (a > b)
444    {
445	v.hi = a;
446	v.lo = b;
447    }
448    else
449    {
450	v.hi = b;
451	v.lo = a;
452    }
453
454    if (c > d)
455    {
456	if (c > v.hi)
457	    v.hi = c;
458	if (d < v.lo)
459	    v.lo = d;
460    }
461    else
462    {
463	if (d > v.hi)
464	    v.hi = d;
465	if (c < v.lo)
466	    v.lo = c;
467    }
468    return (v);
469}
470
471INTERVAL
472vmul(double a, double b, INTERVAL v)
473{
474    return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo));
475}
476
477int
478dcheck(INTERVAL v)
479{
480    if (v.hi >= 0. && v.lo <= 0.)
481    {
482	printf("divisor  interval  contains  0.\n");
483	return (1);
484    }
485    return (0);
486}
487
488INTERVAL
489vdiv(double a, double b, INTERVAL v)
490{
491    return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
492}
493#line 492 "varsyntax_calc1.tab.c"
494
495#if YYDEBUG
496#include <stdio.h>	/* needed for printf */
497#endif
498
499#include <stdlib.h>	/* needed for malloc, etc */
500#include <string.h>	/* needed for memset */
501
502/* allocate initial stack or double stack size, up to YYMAXDEPTH */
503static int yygrowstack(YYSTACKDATA *data)
504{
505    int i;
506    unsigned newsize;
507    YYINT *newss;
508    YYSTYPE *newvs;
509
510    if ((newsize = data->stacksize) == 0)
511        newsize = YYINITSTACKSIZE;
512    else if (newsize >= YYMAXDEPTH)
513        return YYENOMEM;
514    else if ((newsize *= 2) > YYMAXDEPTH)
515        newsize = YYMAXDEPTH;
516
517    i = (int) (data->s_mark - data->s_base);
518    newss = (YYINT *)realloc(data->s_base, newsize * sizeof(*newss));
519    if (newss == 0)
520        return YYENOMEM;
521
522    data->s_base = newss;
523    data->s_mark = newss + i;
524
525    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
526    if (newvs == 0)
527        return YYENOMEM;
528
529    data->l_base = newvs;
530    data->l_mark = newvs + i;
531
532    data->stacksize = newsize;
533    data->s_last = data->s_base + newsize - 1;
534    return 0;
535}
536
537#if YYPURE || defined(YY_NO_LEAKS)
538static void yyfreestack(YYSTACKDATA *data)
539{
540    free(data->s_base);
541    free(data->l_base);
542    memset(data, 0, sizeof(*data));
543}
544#else
545#define yyfreestack(data) /* nothing */
546#endif
547
548#define YYABORT  goto yyabort
549#define YYREJECT goto yyabort
550#define YYACCEPT goto yyaccept
551#define YYERROR  goto yyerrlab
552
553int
554YYPARSE_DECL()
555{
556    int yym, yyn, yystate;
557#if YYDEBUG
558    const char *yys;
559
560    if ((yys = getenv("YYDEBUG")) != 0)
561    {
562        yyn = *yys;
563        if (yyn >= '0' && yyn <= '9')
564            yydebug = yyn - '0';
565    }
566#endif
567
568    yym = 0;
569    yyn = 0;
570    yynerrs = 0;
571    yyerrflag = 0;
572    yychar = YYEMPTY;
573    yystate = 0;
574
575#if YYPURE
576    memset(&yystack, 0, sizeof(yystack));
577#endif
578
579    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
580    yystack.s_mark = yystack.s_base;
581    yystack.l_mark = yystack.l_base;
582    yystate = 0;
583    *yystack.s_mark = 0;
584
585yyloop:
586    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
587    if (yychar < 0)
588    {
589        yychar = YYLEX;
590        if (yychar < 0) yychar = YYEOF;
591#if YYDEBUG
592        if (yydebug)
593        {
594            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
595            printf("%sdebug: state %d, reading %d (%s)\n",
596                    YYPREFIX, yystate, yychar, yys);
597        }
598#endif
599    }
600    if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
601            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
602    {
603#if YYDEBUG
604        if (yydebug)
605            printf("%sdebug: state %d, shifting to state %d\n",
606                    YYPREFIX, yystate, yytable[yyn]);
607#endif
608        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
609        yystate = yytable[yyn];
610        *++yystack.s_mark = yytable[yyn];
611        *++yystack.l_mark = yylval;
612        yychar = YYEMPTY;
613        if (yyerrflag > 0)  --yyerrflag;
614        goto yyloop;
615    }
616    if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
617            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
618    {
619        yyn = yytable[yyn];
620        goto yyreduce;
621    }
622    if (yyerrflag != 0) goto yyinrecovery;
623
624    YYERROR_CALL("syntax error");
625
626    goto yyerrlab; /* redundant goto avoids 'unused label' warning */
627yyerrlab:
628    ++yynerrs;
629
630yyinrecovery:
631    if (yyerrflag < 3)
632    {
633        yyerrflag = 3;
634        for (;;)
635        {
636            if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
637                    yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) 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) goto yyoverflow;
645                yystate = yytable[yyn];
646                *++yystack.s_mark = yytable[yyn];
647                *++yystack.l_mark = yylval;
648                goto yyloop;
649            }
650            else
651            {
652#if YYDEBUG
653                if (yydebug)
654                    printf("%sdebug: error recovery discarding state %d\n",
655                            YYPREFIX, *yystack.s_mark);
656#endif
657                if (yystack.s_mark <= yystack.s_base) goto yyabort;
658                --yystack.s_mark;
659                --yystack.l_mark;
660            }
661        }
662    }
663    else
664    {
665        if (yychar == YYEOF) goto yyabort;
666#if YYDEBUG
667        if (yydebug)
668        {
669            if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
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 > 0)
686        yyval = yystack.l_mark[1-yym];
687    else
688        memset(&yyval, 0, sizeof yyval);
689
690    switch (yyn)
691    {
692case 3:
693#line 59 "varsyntax_calc1.y"
694	{
695		(void) printf("%15.8f\n", yystack.l_mark[-1].dval);
696	}
697break;
698case 4:
699#line 63 "varsyntax_calc1.y"
700	{
701		(void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[-1].vval.lo, yystack.l_mark[-1].vval.hi);
702	}
703break;
704case 5:
705#line 67 "varsyntax_calc1.y"
706	{
707		dreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].dval;
708	}
709break;
710case 6:
711#line 71 "varsyntax_calc1.y"
712	{
713		vreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].vval;
714	}
715break;
716case 7:
717#line 75 "varsyntax_calc1.y"
718	{
719		yyerrok;
720	}
721break;
722case 9:
723#line 82 "varsyntax_calc1.y"
724	{
725		yyval.dval = dreg[yystack.l_mark[0].ival]; /* $$ & $1 are sufficient here*/
726	}
727break;
728case 10:
729#line 86 "varsyntax_calc1.y"
730	{
731		yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval;
732	}
733break;
734case 11:
735#line 90 "varsyntax_calc1.y"
736	{
737		yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval;
738	}
739break;
740case 12:
741#line 94 "varsyntax_calc1.y"
742	{
743		yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval;
744	}
745break;
746case 13:
747#line 98 "varsyntax_calc1.y"
748	{
749		yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval;
750	}
751break;
752case 14:
753#line 102 "varsyntax_calc1.y"
754	{
755		yyval.dval = -yystack.l_mark[0].dval;
756	}
757break;
758case 15:
759#line 106 "varsyntax_calc1.y"
760	{
761		yyval.dval = yystack.l_mark[-1].dval;
762	}
763break;
764case 16:
765#line 112 "varsyntax_calc1.y"
766	{
767		yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval;
768	}
769break;
770case 17:
771#line 116 "varsyntax_calc1.y"
772	{
773		yyval.vval.lo = yystack.l_mark[-3].dval;
774		yyval.vval.hi = yystack.l_mark[-1].dval;
775		if ( yyval.vval.lo > yyval.vval.hi )
776		{
777			(void) printf("interval out of order\n");
778			YYERROR;
779		}
780	}
781break;
782case 18:
783#line 126 "varsyntax_calc1.y"
784	{
785		yyval.vval = vreg[yystack.l_mark[0].ival];
786	}
787break;
788case 19:
789#line 130 "varsyntax_calc1.y"
790	{
791		yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi;
792		yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo;
793	}
794break;
795case 20:
796#line 135 "varsyntax_calc1.y"
797	{
798		yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi;
799		yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo;
800	}
801break;
802case 21:
803#line 140 "varsyntax_calc1.y"
804	{
805		yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo;
806		yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi;
807	}
808break;
809case 22:
810#line 145 "varsyntax_calc1.y"
811	{
812		yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo;
813		yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi;
814	}
815break;
816case 23:
817#line 150 "varsyntax_calc1.y"
818	{
819		yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
820	}
821break;
822case 24:
823#line 154 "varsyntax_calc1.y"
824	{
825		yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
826	}
827break;
828case 25:
829#line 158 "varsyntax_calc1.y"
830	{
831		if (dcheck(yystack.l_mark[0].vval)) YYERROR;
832		yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
833	}
834break;
835case 26:
836#line 163 "varsyntax_calc1.y"
837	{
838		if (dcheck ( yystack.l_mark[0].vval )) YYERROR;
839		yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
840	}
841break;
842case 27:
843#line 168 "varsyntax_calc1.y"
844	{
845		yyval.vval.hi = -yystack.l_mark[0].vval.lo;
846		yyval.vval.lo = -yystack.l_mark[0].vval.hi;
847	}
848break;
849case 28:
850#line 173 "varsyntax_calc1.y"
851	{
852		yyval.vval = yystack.l_mark[-1].vval;
853	}
854break;
855#line 854 "varsyntax_calc1.tab.c"
856    }
857    yystack.s_mark -= yym;
858    yystate = *yystack.s_mark;
859    yystack.l_mark -= yym;
860    yym = yylhs[yyn];
861    if (yystate == 0 && yym == 0)
862    {
863#if YYDEBUG
864        if (yydebug)
865            printf("%sdebug: after reduction, shifting from state 0 to\
866 state %d\n", YYPREFIX, YYFINAL);
867#endif
868        yystate = YYFINAL;
869        *++yystack.s_mark = YYFINAL;
870        *++yystack.l_mark = yyval;
871        if (yychar < 0)
872        {
873            yychar = YYLEX;
874            if (yychar < 0) yychar = YYEOF;
875#if YYDEBUG
876            if (yydebug)
877            {
878                if ((yys = yyname[YYTRANSLATE(yychar)]) == NULL) yys = yyname[YYUNDFTOKEN];
879                printf("%sdebug: state %d, reading %d (%s)\n",
880                        YYPREFIX, YYFINAL, yychar, yys);
881            }
882#endif
883        }
884        if (yychar == YYEOF) goto yyaccept;
885        goto yyloop;
886    }
887    if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
888            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) 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) == YYENOMEM) goto yyoverflow;
898    *++yystack.s_mark = (YYINT) yystate;
899    *++yystack.l_mark = yyval;
900    goto yyloop;
901
902yyoverflow:
903    YYERROR_CALL("yacc stack overflow");
904
905yyabort:
906    yyfreestack(&yystack);
907    return (1);
908
909yyaccept:
910    yyfreestack(&yystack);
911    return (0);
912}
913