calc1.tab.c revision 272955 
1/* original parser id follows */
2/* yysccsid[] = "@(#)yaccpar	1.9 (Berkeley) 02/21/93" */
3/* (use YYMAJOR/YYMINOR for ifdefs dependent of parser version) */
4
5#define YYBYACC 1
6#define YYMAJOR 1
7#define YYMINOR 9
8#define YYCHECK "yyyymmdd"
9
10#define YYEMPTY        (-1)
11#define yyclearin      (yychar = YYEMPTY)
12#define yyerrok        (yyerrflag = 0)
13#define YYRECOVERING() (yyerrflag != 0)
14#define YYENOMEM       (-2)
15#define YYEOF          0
16#undef YYBTYACC
17#define YYBTYACC 0
18#define YYDEBUGSTR YYPREFIX "debug"
19
20#ifndef yyparse
21#define yyparse    calc1_parse
22#endif /* yyparse */
23
24#ifndef yylex
25#define yylex      calc1_lex
26#endif /* yylex */
27
28#ifndef yyerror
29#define yyerror    calc1_error
30#endif /* yyerror */
31
32#ifndef yychar
33#define yychar     calc1_char
34#endif /* yychar */
35
36#ifndef yyval
37#define yyval      calc1_val
38#endif /* yyval */
39
40#ifndef yylval
41#define yylval     calc1_lval
42#endif /* yylval */
43
44#ifndef yydebug
45#define yydebug    calc1_debug
46#endif /* yydebug */
47
48#ifndef yynerrs
49#define yynerrs    calc1_nerrs
50#endif /* yynerrs */
51
52#ifndef yyerrflag
53#define yyerrflag  calc1_errflag
54#endif /* yyerrflag */
55
56#ifndef yylhs
57#define yylhs      calc1_lhs
58#endif /* yylhs */
59
60#ifndef yylen
61#define yylen      calc1_len
62#endif /* yylen */
63
64#ifndef yydefred
65#define yydefred   calc1_defred
66#endif /* yydefred */
67
68#ifndef yystos
69#define yystos     calc1_stos
70#endif /* yystos */
71
72#ifndef yydgoto
73#define yydgoto    calc1_dgoto
74#endif /* yydgoto */
75
76#ifndef yysindex
77#define yysindex   calc1_sindex
78#endif /* yysindex */
79
80#ifndef yyrindex
81#define yyrindex   calc1_rindex
82#endif /* yyrindex */
83
84#ifndef yygindex
85#define yygindex   calc1_gindex
86#endif /* yygindex */
87
88#ifndef yytable
89#define yytable    calc1_table
90#endif /* yytable */
91
92#ifndef yycheck
93#define yycheck    calc1_check
94#endif /* yycheck */
95
96#ifndef yyname
97#define yyname     calc1_name
98#endif /* yyname */
99
100#ifndef yyrule
101#define yyrule     calc1_rule
102#endif /* yyrule */
103
104#if YYBTYACC
105
106#ifndef yycindex
107#define yycindex   calc1_cindex
108#endif /* yycindex */
109
110#ifndef yyctable
111#define yyctable   calc1_ctable
112#endif /* yyctable */
113
114#endif /* YYBTYACC */
115
116#define YYPREFIX "calc1_"
117
118#define YYPURE 0
119
120#line 2 "calc1.y"
121
122/* http://dinosaur.compilertools.net/yacc/index.html */
123
124#include <stdlib.h>
125#include <stdio.h>
126#include <ctype.h>
127#include <math.h>
128
129typedef struct interval
130{
131    double lo, hi;
132}
133INTERVAL;
134
135INTERVAL vmul(double, double, INTERVAL);
136INTERVAL vdiv(double, double, INTERVAL);
137
138extern int yylex(void);
139static void yyerror(const char *s);
140
141int dcheck(INTERVAL);
142
143double dreg[26];
144INTERVAL vreg[26];
145
146#line 31 "calc1.y"
147#ifdef YYSTYPE
148#undef  YYSTYPE_IS_DECLARED
149#define YYSTYPE_IS_DECLARED 1
150#endif
151#ifndef YYSTYPE_IS_DECLARED
152#define YYSTYPE_IS_DECLARED 1
153typedef union
154{
155	int ival;
156	double dval;
157	INTERVAL vval;
158} YYSTYPE;
159#endif /* !YYSTYPE_IS_DECLARED */
160#line 161 "calc1.tab.c"
161
162/* compatibility with bison */
163#ifdef YYPARSE_PARAM
164/* compatibility with FreeBSD */
165# ifdef YYPARSE_PARAM_TYPE
166#  define YYPARSE_DECL() yyparse(YYPARSE_PARAM_TYPE YYPARSE_PARAM)
167# else
168#  define YYPARSE_DECL() yyparse(void *YYPARSE_PARAM)
169# endif
170#else
171# define YYPARSE_DECL() yyparse(void)
172#endif
173
174/* Parameters sent to lex. */
175#ifdef YYLEX_PARAM
176# define YYLEX_DECL() yylex(void *YYLEX_PARAM)
177# define YYLEX yylex(YYLEX_PARAM)
178#else
179# define YYLEX_DECL() yylex(void)
180# define YYLEX yylex()
181#endif
182
183/* Parameters sent to yyerror. */
184#ifndef YYERROR_DECL
185#define YYERROR_DECL() yyerror(const char *s)
186#endif
187#ifndef YYERROR_CALL
188#define YYERROR_CALL(msg) yyerror(msg)
189#endif
190
191extern int YYPARSE_DECL();
192
193#define DREG 257
194#define VREG 258
195#define CONST 259
196#define UMINUS 260
197#define YYERRCODE 256
198typedef short YYINT;
199static const YYINT calc1_lhs[] = {                       -1,
200    3,    3,    0,    0,    0,    0,    0,    1,    1,    1,
201    1,    1,    1,    1,    1,    2,    2,    2,    2,    2,
202    2,    2,    2,    2,    2,    2,    2,    2,
203};
204static const YYINT calc1_len[] = {                        2,
205    0,    2,    2,    2,    4,    4,    2,    1,    1,    3,
206    3,    3,    3,    2,    3,    1,    5,    1,    3,    3,
207    3,    3,    3,    3,    3,    3,    2,    3,
208};
209static const YYINT calc1_defred[] = {                     0,
210    0,    0,    0,    8,    0,    0,    0,    0,    0,    7,
211    0,    0,    9,   18,   14,   27,    0,    0,    0,    0,
212    0,    0,    3,    0,    0,    0,    0,    4,    0,    0,
213    0,    0,    0,   15,    0,   28,    0,    0,    0,    0,
214   12,   24,   13,   26,    0,    0,   23,   25,   14,    0,
215    0,    0,    0,    0,    5,    6,    0,    0,    0,   12,
216   13,   17,
217};
218static const YYINT calc1_stos[] = {                       0,
219  256,  257,  258,  259,   45,   40,  262,  263,  264,   10,
220   61,   61,  257,  258,  263,  264,  263,  264,   43,   45,
221   42,   47,   10,   43,   45,   42,   47,   10,   45,   40,
222  263,  263,  264,   41,   44,   41,  263,  264,  263,  264,
223  263,  264,  263,  264,  264,  264,  264,  264,  263,  263,
224   43,   45,   42,   47,   10,   10,  263,  263,  263,  263,
225  263,   41,
226};
227static const YYINT calc1_dgoto[] = {                      7,
228   32,    9,    0,
229};
230static const YYINT calc1_sindex[] = {                   -40,
231   -8,  -48,  -47,    0,  -37,  -37,    0,    2,   17,    0,
232  -34,  -37,    0,    0,    0,    0,  -25,   90,  -37,  -37,
233  -37,  -37,    0,  -37,  -37,  -37,  -37,    0,  -34,  -34,
234   25,  125,   31,    0,  -34,    0,  -11,   37,  -11,   37,
235    0,    0,    0,    0,   37,   37,    0,    0,    0,  111,
236  -34,  -34,  -34,  -34,    0,    0,  118,   69,   69,    0,
237    0,    0,
238};
239static const YYINT calc1_rindex[] = {                     0,
240    0,   38,   44,    0,    0,    0,    0,    0,    0,    0,
241    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
242    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
243    0,   -9,    0,    0,    0,    0,   51,   -3,   56,   61,
244    0,    0,    0,    0,   67,   72,    0,    0,    0,    0,
245    0,    0,    0,    0,    0,    0,    0,   78,   83,    0,
246    0,    0,
247};
248#if YYBTYACC
249static const YYINT calc1_cindex[] = {                     0,
250    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
251    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
252    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
253    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
254    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
255    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
256    0,    0,
257};
258#endif
259static const YYINT calc1_gindex[] = {                     0,
260    4,  124,    0,
261};
262#define YYTABLESIZE 225
263static const YYINT calc1_table[] = {                      6,
264   16,   10,    6,    8,    5,   30,   20,    5,   15,   17,
265   29,   23,   11,   12,   31,   34,   21,   19,   35,   20,
266    0,   22,   37,   39,   41,   43,   28,    0,    0,    0,
267   21,   16,   49,   50,   55,   22,    0,   20,   57,   20,
268   56,   20,    0,   21,   19,    0,   20,    9,   22,    0,
269    0,    0,    0,   18,   58,   59,   60,   61,   26,   24,
270   10,   25,    0,   27,    0,   11,   53,   51,    0,   52,
271   22,   54,   26,   24,    0,   25,   19,   27,   26,    9,
272    9,   21,    9,   27,    9,   18,   18,   10,   18,    0,
273   18,   10,   11,   10,   10,   10,   11,    0,   11,   11,
274   11,   22,    0,   22,    0,   22,    0,   19,    0,   19,
275   53,   19,   21,    0,   21,   54,   21,    0,   10,    0,
276   10,    0,   10,   11,    0,   11,    0,   11,   16,   18,
277   36,   26,   24,    0,   25,   33,   27,    0,    0,    0,
278    0,    0,   38,   40,   42,   44,    0,   45,   46,   47,
279   48,   34,   53,   51,    0,   52,    0,   54,   62,   53,
280   51,    0,   52,    0,   54,    0,   21,   19,    0,   20,
281    0,   22,    0,    0,    0,    0,    0,    0,    0,    0,
282    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
283    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
284    0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
285    0,    0,    0,    0,    0,    1,    2,    3,    4,   13,
286   14,    4,   13,    0,    4,
287};
288static const YYINT calc1_check[] = {                     40,
289   10,   10,   40,    0,   45,   40,   10,   45,    5,    6,
290   45,   10,   61,   61,   11,   41,   42,   43,   44,   45,
291   -1,   47,   19,   20,   21,   22,   10,   -1,   -1,   -1,
292   42,   41,   29,   30,   10,   47,   -1,   41,   35,   43,
293   10,   45,   -1,   42,   43,   -1,   45,   10,   47,   -1,
294   -1,   -1,   -1,   10,   51,   52,   53,   54,   42,   43,
295   10,   45,   -1,   47,   -1,   10,   42,   43,   -1,   45,
296   10,   47,   42,   43,   -1,   45,   10,   47,   42,   42,
297   43,   10,   45,   47,   47,   42,   43,   10,   45,   -1,
298   47,   41,   10,   43,   44,   45,   41,   -1,   43,   44,
299   45,   41,   -1,   43,   -1,   45,   -1,   41,   -1,   43,
300   42,   45,   41,   -1,   43,   47,   45,   -1,   41,   -1,
301   43,   -1,   45,   41,   -1,   43,   -1,   45,    5,    6,
302   41,   42,   43,   -1,   45,   12,   47,   -1,   -1,   -1,
303   -1,   -1,   19,   20,   21,   22,   -1,   24,   25,   26,
304   27,   41,   42,   43,   -1,   45,   -1,   47,   41,   42,
305   43,   -1,   45,   -1,   47,   -1,   42,   43,   -1,   45,
306   -1,   47,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
307   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
308   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
309   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
310   -1,   -1,   -1,   -1,   -1,  256,  257,  258,  259,  257,
311  258,  259,  257,   -1,  259,
312};
313#if YYBTYACC
314static const YYINT calc1_ctable[] = {                    -1,
315   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
316   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
317   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
318   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
319   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
320   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
321   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
322   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
323   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
324   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
325   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
326   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
327   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
328   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
329   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
330   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
331   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
332   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
333   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
334   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
335   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
336   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,   -1,
337   -1,   -1,   -1,   -1,
338};
339#endif
340#define YYFINAL 7
341#ifndef YYDEBUG
342#define YYDEBUG 0
343#endif
344#define YYMAXTOKEN 260
345#define YYUNDFTOKEN 266
346#define YYTRANSLATE(a) ((a) > YYMAXTOKEN ? YYUNDFTOKEN : (a))
347#if YYDEBUG
348static const char *const calc1_name[] = {
349
350"$end",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,0,0,0,
3510,0,0,0,0,0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,0,0,0,0,0,0,0,
3520,"'='",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3530,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3540,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3550,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
3560,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
357"error","DREG","VREG","CONST","UMINUS","$accept","line","dexp","vexp","lines",
358"illegal-symbol",
359};
360static const char *const calc1_rule[] = {
361"$accept : line",
362"lines :",
363"lines : lines line",
364"line : dexp '\\n'",
365"line : vexp '\\n'",
366"line : DREG '=' dexp '\\n'",
367"line : VREG '=' vexp '\\n'",
368"line : error '\\n'",
369"dexp : CONST",
370"dexp : DREG",
371"dexp : dexp '+' dexp",
372"dexp : dexp '-' dexp",
373"dexp : dexp '*' dexp",
374"dexp : dexp '/' dexp",
375"dexp : '-' dexp",
376"dexp : '(' dexp ')'",
377"vexp : dexp",
378"vexp : '(' dexp ',' dexp ')'",
379"vexp : VREG",
380"vexp : vexp '+' vexp",
381"vexp : dexp '+' vexp",
382"vexp : vexp '-' vexp",
383"vexp : dexp '-' vexp",
384"vexp : vexp '*' vexp",
385"vexp : dexp '*' vexp",
386"vexp : vexp '/' vexp",
387"vexp : dexp '/' vexp",
388"vexp : '-' vexp",
389"vexp : '(' vexp ')'",
390
391};
392#endif
393
394int      yydebug;
395int      yynerrs;
396
397int      yyerrflag;
398int      yychar;
399YYSTYPE  yyval;
400YYSTYPE  yylval;
401#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
402YYLTYPE  yyloc; /* position returned by actions */
403YYLTYPE  yylloc; /* position from the lexer */
404#endif
405
406#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
407#ifndef YYLLOC_DEFAULT
408#define YYLLOC_DEFAULT(loc, rhs, n) \
409do \
410{ \
411    if (n == 0) \
412    { \
413        (loc).first_line   = ((rhs)[-1]).last_line; \
414        (loc).first_column = ((rhs)[-1]).last_column; \
415        (loc).last_line    = ((rhs)[-1]).last_line; \
416        (loc).last_column  = ((rhs)[-1]).last_column; \
417    } \
418    else \
419    { \
420        (loc).first_line   = ((rhs)[ 0 ]).first_line; \
421        (loc).first_column = ((rhs)[ 0 ]).first_column; \
422        (loc).last_line    = ((rhs)[n-1]).last_line; \
423        (loc).last_column  = ((rhs)[n-1]).last_column; \
424    } \
425} while (0)
426#endif /* YYLLOC_DEFAULT */
427#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
428#if YYBTYACC
429
430#ifndef YYLVQUEUEGROWTH
431#define YYLVQUEUEGROWTH 32
432#endif
433#endif /* YYBTYACC */
434
435/* define the initial stack-sizes */
436#ifdef YYSTACKSIZE
437#undef YYMAXDEPTH
438#define YYMAXDEPTH  YYSTACKSIZE
439#else
440#ifdef YYMAXDEPTH
441#define YYSTACKSIZE YYMAXDEPTH
442#else
443#define YYSTACKSIZE 10000
444#define YYMAXDEPTH  10000
445#endif
446#endif
447
448#ifndef YYINITSTACKSIZE
449#define YYINITSTACKSIZE 200
450#endif
451
452typedef struct {
453    unsigned stacksize;
454    short    *s_base;
455    short    *s_mark;
456    short    *s_last;
457    YYSTYPE  *l_base;
458    YYSTYPE  *l_mark;
459#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
460    YYLTYPE  *p_base;
461    YYLTYPE  *p_mark;
462#endif
463} YYSTACKDATA;
464#if YYBTYACC
465
466struct YYParseState_s
467{
468    struct YYParseState_s *save;    /* Previously saved parser state */
469    YYSTACKDATA            yystack; /* saved parser stack */
470    int                    state;   /* saved parser state */
471    int                    errflag; /* saved error recovery status */
472    int                    lexeme;  /* saved index of the conflict lexeme in the lexical queue */
473    YYINT                  ctry;    /* saved index in yyctable[] for this conflict */
474};
475typedef struct YYParseState_s YYParseState;
476#endif /* YYBTYACC */
477/* variables for the parser stack */
478static YYSTACKDATA yystack;
479#if YYBTYACC
480
481/* Current parser state */
482static YYParseState *yyps = 0;
483
484/* yypath != NULL: do the full parse, starting at *yypath parser state. */
485static YYParseState *yypath = 0;
486
487/* Base of the lexical value queue */
488static YYSTYPE *yylvals = 0;
489
490/* Current position at lexical value queue */
491static YYSTYPE *yylvp = 0;
492
493/* End position of lexical value queue */
494static YYSTYPE *yylve = 0;
495
496/* The last allocated position at the lexical value queue */
497static YYSTYPE *yylvlim = 0;
498
499#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
500/* Base of the lexical position queue */
501static YYLTYPE *yylpsns = 0;
502
503/* Current position at lexical position queue */
504static YYLTYPE *yylpp = 0;
505
506/* End position of lexical position queue */
507static YYLTYPE *yylpe = 0;
508
509/* The last allocated position at the lexical position queue */
510static YYLTYPE *yylplim = 0;
511#endif
512
513/* Current position at lexical token queue */
514static short  *yylexp = 0;
515
516static short  *yylexemes = 0;
517#endif /* YYBTYACC */
518#line 176 "calc1.y"
519	/* beginning of subroutines section */
520
521#define BSZ 50			/* buffer size for floating point numbers */
522
523	/* lexical analysis */
524
525static void
526yyerror(const char *s)
527{
528    fprintf(stderr, "%s\n", s);
529}
530
531int
532yylex(void)
533{
534    int c;
535
536    while ((c = getchar()) == ' ')
537    {				/* skip over blanks */
538    }
539
540    if (isupper(c))
541    {
542	yylval.ival = c - 'A';
543	return (VREG);
544    }
545    if (islower(c))
546    {
547	yylval.ival = c - 'a';
548	return (DREG);
549    }
550
551    if (isdigit(c) || c == '.')
552    {
553	/* gobble up digits, points, exponents */
554	char buf[BSZ + 1], *cp = buf;
555	int dot = 0, expr = 0;
556
557	for (; (cp - buf) < BSZ; ++cp, c = getchar())
558	{
559
560	    *cp = (char) c;
561	    if (isdigit(c))
562		continue;
563	    if (c == '.')
564	    {
565		if (dot++ || expr)
566		    return ('.');	/* will cause syntax error */
567		continue;
568	    }
569
570	    if (c == 'e')
571	    {
572		if (expr++)
573		    return ('e');	/*  will  cause  syntax  error  */
574		continue;
575	    }
576
577	    /*  end  of  number  */
578	    break;
579	}
580	*cp = '\0';
581
582	if ((cp - buf) >= BSZ)
583	    printf("constant  too  long:  truncated\n");
584	else
585	    ungetc(c, stdin);	/*  push  back  last  char  read  */
586	yylval.dval = atof(buf);
587	return (CONST);
588    }
589    return (c);
590}
591
592static INTERVAL
593hilo(double a, double b, double c, double d)
594{
595    /*  returns  the  smallest  interval  containing  a,  b,  c,  and  d  */
596    /*  used  by  *,  /  routines  */
597    INTERVAL v;
598
599    if (a > b)
600    {
601	v.hi = a;
602	v.lo = b;
603    }
604    else
605    {
606	v.hi = b;
607	v.lo = a;
608    }
609
610    if (c > d)
611    {
612	if (c > v.hi)
613	    v.hi = c;
614	if (d < v.lo)
615	    v.lo = d;
616    }
617    else
618    {
619	if (d > v.hi)
620	    v.hi = d;
621	if (c < v.lo)
622	    v.lo = c;
623    }
624    return (v);
625}
626
627INTERVAL
628vmul(double a, double b, INTERVAL v)
629{
630    return (hilo(a * v.hi, a * v.lo, b * v.hi, b * v.lo));
631}
632
633int
634dcheck(INTERVAL v)
635{
636    if (v.hi >= 0. && v.lo <= 0.)
637    {
638	printf("divisor  interval  contains  0.\n");
639	return (1);
640    }
641    return (0);
642}
643
644INTERVAL
645vdiv(double a, double b, INTERVAL v)
646{
647    return (hilo(a / v.hi, a / v.lo, b / v.hi, b / v.lo));
648}
649#line 650 "calc1.tab.c"
650
651/* For use in generated program */
652#define yydepth (int)(yystack.s_mark - yystack.s_base)
653#if YYBTYACC
654#define yytrial (yyps->save)
655#endif /* YYBTYACC */
656
657#if YYDEBUG
658#include <stdio.h>         /* needed for printf */
659#endif
660
661#include <stdlib.h>        /* needed for malloc, etc */
662#include <string.h>        /* needed for memset */
663
664/* allocate initial stack or double stack size, up to YYMAXDEPTH */
665static int yygrowstack(YYSTACKDATA *data)
666{
667    int i;
668    unsigned newsize;
669    short *newss;
670    YYSTYPE *newvs;
671#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
672    YYLTYPE *newps;
673#endif
674
675    if ((newsize = data->stacksize) == 0)
676        newsize = YYINITSTACKSIZE;
677    else if (newsize >= YYMAXDEPTH)
678        return YYENOMEM;
679    else if ((newsize *= 2) > YYMAXDEPTH)
680        newsize = YYMAXDEPTH;
681
682    i = (int) (data->s_mark - data->s_base);
683    newss = (short *)realloc(data->s_base, newsize * sizeof(*newss));
684    if (newss == 0)
685        return YYENOMEM;
686
687    data->s_base = newss;
688    data->s_mark = newss + i;
689
690    newvs = (YYSTYPE *)realloc(data->l_base, newsize * sizeof(*newvs));
691    if (newvs == 0)
692        return YYENOMEM;
693
694    data->l_base = newvs;
695    data->l_mark = newvs + i;
696
697#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
698    newps = (YYLTYPE *)realloc(data->p_base, newsize * sizeof(*newps));
699    if (newps == 0)
700        return YYENOMEM;
701
702    data->p_base = newps;
703    data->p_mark = newps + i;
704#endif
705
706    data->stacksize = newsize;
707    data->s_last = data->s_base + newsize - 1;
708
709#if YYDEBUG
710    if (yydebug)
711        fprintf(stderr, "%sdebug: stack size increased to %d\n", YYPREFIX, newsize);
712#endif
713    return 0;
714}
715
716#if YYPURE || defined(YY_NO_LEAKS)
717static void yyfreestack(YYSTACKDATA *data)
718{
719    free(data->s_base);
720    free(data->l_base);
721#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
722    free(data->p_base);
723#endif
724    memset(data, 0, sizeof(*data));
725}
726#else
727#define yyfreestack(data) /* nothing */
728#endif /* YYPURE || defined(YY_NO_LEAKS) */
729#if YYBTYACC
730
731static YYParseState *
732yyNewState(unsigned size)
733{
734    YYParseState *p = (YYParseState *) malloc(sizeof(YYParseState));
735    if (p == NULL) return NULL;
736
737    p->yystack.stacksize = size;
738    if (size == 0)
739    {
740        p->yystack.s_base = NULL;
741        p->yystack.l_base = NULL;
742#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
743        p->yystack.p_base = NULL;
744#endif
745        return p;
746    }
747    p->yystack.s_base    = (short *) malloc(size * sizeof(short));
748    if (p->yystack.s_base == NULL) return NULL;
749    p->yystack.l_base    = (YYSTYPE *) malloc(size * sizeof(YYSTYPE));
750    if (p->yystack.l_base == NULL) return NULL;
751    memset(p->yystack.l_base, 0, size * sizeof(YYSTYPE));
752#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
753    p->yystack.p_base    = (YYLTYPE *) malloc(size * sizeof(YYLTYPE));
754    if (p->yystack.p_base == NULL) return NULL;
755    memset(p->yystack.p_base, 0, size * sizeof(YYLTYPE));
756#endif
757
758    return p;
759}
760
761static void
762yyFreeState(YYParseState *p)
763{
764    yyfreestack(&p->yystack);
765    free(p);
766}
767#endif /* YYBTYACC */
768
769#define YYABORT  goto yyabort
770#define YYREJECT goto yyabort
771#define YYACCEPT goto yyaccept
772#define YYERROR  goto yyerrlab
773#if YYBTYACC
774#define YYVALID        do { if (yyps->save)            goto yyvalid; } while(0)
775#define YYVALID_NESTED do { if (yyps->save && \
776                                yyps->save->save == 0) goto yyvalid; } while(0)
777#endif /* YYBTYACC */
778
779int
780YYPARSE_DECL()
781{
782    int yym, yyn, yystate, yyresult;
783#if YYBTYACC
784    int yynewerrflag;
785    YYParseState *yyerrctx = NULL;
786#endif /* YYBTYACC */
787#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
788    YYLTYPE  yyerror_loc_range[2]; /* position of error start & end */
789#endif
790#if YYDEBUG
791    const char *yys;
792
793    if ((yys = getenv("YYDEBUG")) != 0)
794    {
795        yyn = *yys;
796        if (yyn >= '0' && yyn <= '9')
797            yydebug = yyn - '0';
798    }
799    if (yydebug)
800        fprintf(stderr, "%sdebug[<# of symbols on state stack>]\n", YYPREFIX);
801#endif
802
803#if YYBTYACC
804    yyps = yyNewState(0); if (yyps == 0) goto yyenomem;
805    yyps->save = 0;
806#endif /* YYBTYACC */
807    yynerrs = 0;
808    yyerrflag = 0;
809    yychar = YYEMPTY;
810    yystate = 0;
811
812#if YYPURE
813    memset(&yystack, 0, sizeof(yystack));
814#endif
815
816    if (yystack.s_base == NULL && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
817    yystack.s_mark = yystack.s_base;
818    yystack.l_mark = yystack.l_base;
819#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
820    yystack.p_mark = yystack.p_base;
821#endif
822    yystate = 0;
823    *yystack.s_mark = 0;
824
825yyloop:
826    if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
827    if (yychar < 0)
828    {
829#if YYBTYACC
830        do {
831        if (yylvp < yylve)
832        {
833            /* we're currently re-reading tokens */
834            yylval = *yylvp++;
835#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
836            yylloc = *yylpp++;
837#endif
838            yychar = *yylexp++;
839            break;
840        }
841        if (yyps->save)
842        {
843            /* in trial mode; save scanner results for future parse attempts */
844            if (yylvp == yylvlim)
845            {   /* Enlarge lexical value queue */
846                size_t p = (size_t) (yylvp - yylvals);
847                size_t s = (size_t) (yylvlim - yylvals);
848
849                s += YYLVQUEUEGROWTH;
850                if ((yylexemes = (short *)   realloc(yylexemes, s * sizeof(short))) == NULL) goto yyenomem;
851                if ((yylvals   = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL) goto yyenomem;
852#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
853                if ((yylpsns   = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL) goto yyenomem;
854#endif
855                yylvp   = yylve = yylvals + p;
856                yylvlim = yylvals + s;
857#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
858                yylpp   = yylpe = yylpsns + p;
859                yylplim = yylpsns + s;
860#endif
861                yylexp  = yylexemes + p;
862            }
863            *yylexp = (short) YYLEX;
864            *yylvp++ = yylval;
865            yylve++;
866#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
867            *yylpp++ = yylloc;
868            yylpe++;
869#endif
870            yychar = *yylexp++;
871            break;
872        }
873        /* normal operation, no conflict encountered */
874#endif /* YYBTYACC */
875        yychar = YYLEX;
876#if YYBTYACC
877        } while (0);
878#endif /* YYBTYACC */
879        if (yychar < 0) yychar = YYEOF;
880        /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
881#if YYDEBUG
882        if (yydebug)
883        {
884            yys = yyname[YYTRANSLATE(yychar)];
885            fprintf(stderr, "%s[%d]: state %d, reading token %d (%s)",
886                            YYDEBUGSTR, yydepth, yystate, yychar, yys);
887#ifdef YYSTYPE_TOSTRING
888#if YYBTYACC
889            if (!yytrial)
890#endif /* YYBTYACC */
891                fprintf(stderr, " <%s>", YYSTYPE_TOSTRING(yychar, yylval));
892#endif
893            fputc('\n', stderr);
894        }
895#endif
896    }
897#if YYBTYACC
898
899    /* Do we have a conflict? */
900    if (((yyn = yycindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
901        yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
902    {
903        YYINT ctry;
904
905        if (yypath)
906        {
907            YYParseState *save;
908#if YYDEBUG
909            if (yydebug)
910                fprintf(stderr, "%s[%d]: CONFLICT in state %d: following successful trial parse\n",
911                                YYDEBUGSTR, yydepth, yystate);
912#endif
913            /* Switch to the next conflict context */
914            save = yypath;
915            yypath = save->save;
916            save->save = NULL;
917            ctry = save->ctry;
918            if (save->state != yystate) YYABORT;
919            yyFreeState(save);
920
921        }
922        else
923        {
924
925            /* Unresolved conflict - start/continue trial parse */
926            YYParseState *save;
927#if YYDEBUG
928            if (yydebug)
929            {
930                fprintf(stderr, "%s[%d]: CONFLICT in state %d. ", YYDEBUGSTR, yydepth, yystate);
931                if (yyps->save)
932                    fputs("ALREADY in conflict, continuing trial parse.\n", stderr);
933                else
934                    fputs("Starting trial parse.\n", stderr);
935            }
936#endif
937            save                  = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
938            if (save == NULL) goto yyenomem;
939            save->save            = yyps->save;
940            save->state           = yystate;
941            save->errflag         = yyerrflag;
942            save->yystack.s_mark  = save->yystack.s_base + (yystack.s_mark - yystack.s_base);
943            memcpy (save->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
944            save->yystack.l_mark  = save->yystack.l_base + (yystack.l_mark - yystack.l_base);
945            memcpy (save->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
946#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
947            save->yystack.p_mark  = save->yystack.p_base + (yystack.p_mark - yystack.p_base);
948            memcpy (save->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
949#endif
950            ctry                  = yytable[yyn];
951            if (yyctable[ctry] == -1)
952            {
953#if YYDEBUG
954                if (yydebug && yychar >= YYEOF)
955                    fprintf(stderr, "%s[%d]: backtracking 1 token\n", YYDEBUGSTR, yydepth);
956#endif
957                ctry++;
958            }
959            save->ctry = ctry;
960            if (yyps->save == NULL)
961            {
962                /* If this is a first conflict in the stack, start saving lexemes */
963                if (!yylexemes)
964                {
965                    yylexemes = (short *) malloc((YYLVQUEUEGROWTH) * sizeof(short));
966                    if (yylexemes == NULL) goto yyenomem;
967                    yylvals   = (YYSTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYSTYPE));
968                    if (yylvals == NULL) goto yyenomem;
969                    yylvlim   = yylvals + YYLVQUEUEGROWTH;
970#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
971                    yylpsns   = (YYLTYPE *) malloc((YYLVQUEUEGROWTH) * sizeof(YYLTYPE));
972                    if (yylpsns == NULL) goto yyenomem;
973                    yylplim   = yylpsns + YYLVQUEUEGROWTH;
974#endif
975                }
976                if (yylvp == yylve)
977                {
978                    yylvp  = yylve = yylvals;
979#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
980                    yylpp  = yylpe = yylpsns;
981#endif
982                    yylexp = yylexemes;
983                    if (yychar >= YYEOF)
984                    {
985                        *yylve++ = yylval;
986#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
987                        *yylpe++ = yylloc;
988#endif
989                        *yylexp  = (short) yychar;
990                        yychar   = YYEMPTY;
991                    }
992                }
993            }
994            if (yychar >= YYEOF)
995            {
996                yylvp--;
997#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
998                yylpp--;
999#endif
1000                yylexp--;
1001                yychar = YYEMPTY;
1002            }
1003            save->lexeme = (int) (yylvp - yylvals);
1004            yyps->save   = save;
1005        }
1006        if (yytable[yyn] == ctry)
1007        {
1008#if YYDEBUG
1009            if (yydebug)
1010                fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1011                                YYDEBUGSTR, yydepth, yystate, yyctable[ctry]);
1012#endif
1013            if (yychar < 0)
1014            {
1015                yylvp++;
1016#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1017                yylpp++;
1018#endif
1019                yylexp++;
1020            }
1021            if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM)
1022                goto yyoverflow;
1023            yystate = yyctable[ctry];
1024            *++yystack.s_mark = (short) yystate;
1025            *++yystack.l_mark = yylval;
1026#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1027            *++yystack.p_mark = yylloc;
1028#endif
1029            yychar  = YYEMPTY;
1030            if (yyerrflag > 0) --yyerrflag;
1031            goto yyloop;
1032        }
1033        else
1034        {
1035            yyn = yyctable[ctry];
1036            goto yyreduce;
1037        }
1038    } /* End of code dealing with conflicts */
1039#endif /* YYBTYACC */
1040    if (((yyn = yysindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1041            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1042    {
1043#if YYDEBUG
1044        if (yydebug)
1045            fprintf(stderr, "%s[%d]: state %d, shifting to state %d\n",
1046                            YYDEBUGSTR, yydepth, yystate, yytable[yyn]);
1047#endif
1048        if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1049        yystate = yytable[yyn];
1050        *++yystack.s_mark = yytable[yyn];
1051        *++yystack.l_mark = yylval;
1052#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1053        *++yystack.p_mark = yylloc;
1054#endif
1055        yychar = YYEMPTY;
1056        if (yyerrflag > 0)  --yyerrflag;
1057        goto yyloop;
1058    }
1059    if (((yyn = yyrindex[yystate]) != 0) && (yyn += yychar) >= 0 &&
1060            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yychar)
1061    {
1062        yyn = yytable[yyn];
1063        goto yyreduce;
1064    }
1065    if (yyerrflag != 0) goto yyinrecovery;
1066#if YYBTYACC
1067
1068    yynewerrflag = 1;
1069    goto yyerrhandler;
1070    goto yyerrlab;
1071
1072yyerrlab:
1073    yynewerrflag = 0;
1074yyerrhandler:
1075    while (yyps->save)
1076    {
1077        int ctry;
1078        YYParseState *save = yyps->save;
1079#if YYDEBUG
1080        if (yydebug)
1081            fprintf(stderr, "%s[%d]: ERROR in state %d, CONFLICT BACKTRACKING to state %d, %d tokens\n",
1082                            YYDEBUGSTR, yydepth, yystate, yyps->save->state,
1083                    (int)(yylvp - yylvals - yyps->save->lexeme));
1084#endif
1085        /* Memorize most forward-looking error state in case it's really an error. */
1086        if (yyerrctx == NULL || yyerrctx->lexeme < yylvp - yylvals)
1087        {
1088            /* Free old saved error context state */
1089            if (yyerrctx) yyFreeState(yyerrctx);
1090            /* Create and fill out new saved error context state */
1091            yyerrctx                 = yyNewState((unsigned)(yystack.s_mark - yystack.s_base + 1));
1092            if (yyerrctx == NULL) goto yyenomem;
1093            yyerrctx->save           = yyps->save;
1094            yyerrctx->state          = yystate;
1095            yyerrctx->errflag        = yyerrflag;
1096            yyerrctx->yystack.s_mark = yyerrctx->yystack.s_base + (yystack.s_mark - yystack.s_base);
1097            memcpy (yyerrctx->yystack.s_base, yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1098            yyerrctx->yystack.l_mark = yyerrctx->yystack.l_base + (yystack.l_mark - yystack.l_base);
1099            memcpy (yyerrctx->yystack.l_base, yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1100#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1101            yyerrctx->yystack.p_mark = yyerrctx->yystack.p_base + (yystack.p_mark - yystack.p_base);
1102            memcpy (yyerrctx->yystack.p_base, yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1103#endif
1104            yyerrctx->lexeme         = (int) (yylvp - yylvals);
1105        }
1106        yylvp          = yylvals   + save->lexeme;
1107#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1108        yylpp          = yylpsns   + save->lexeme;
1109#endif
1110        yylexp         = yylexemes + save->lexeme;
1111        yychar         = YYEMPTY;
1112        yystack.s_mark = yystack.s_base + (save->yystack.s_mark - save->yystack.s_base);
1113        memcpy (yystack.s_base, save->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1114        yystack.l_mark = yystack.l_base + (save->yystack.l_mark - save->yystack.l_base);
1115        memcpy (yystack.l_base, save->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1116#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1117        yystack.p_mark = yystack.p_base + (save->yystack.p_mark - save->yystack.p_base);
1118        memcpy (yystack.p_base, save->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1119#endif
1120        ctry           = ++save->ctry;
1121        yystate        = save->state;
1122        /* We tried shift, try reduce now */
1123        if ((yyn = yyctable[ctry]) >= 0) goto yyreduce;
1124        yyps->save     = save->save;
1125        save->save     = NULL;
1126        yyFreeState(save);
1127
1128        /* Nothing left on the stack -- error */
1129        if (!yyps->save)
1130        {
1131#if YYDEBUG
1132            if (yydebug)
1133                fprintf(stderr, "%sdebug[%d,trial]: trial parse FAILED, entering ERROR mode\n",
1134                                YYPREFIX, yydepth);
1135#endif
1136            /* Restore state as it was in the most forward-advanced error */
1137            yylvp          = yylvals   + yyerrctx->lexeme;
1138#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1139            yylpp          = yylpsns   + yyerrctx->lexeme;
1140#endif
1141            yylexp         = yylexemes + yyerrctx->lexeme;
1142            yychar         = yylexp[-1];
1143            yylval         = yylvp[-1];
1144#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1145            yylloc         = yylpp[-1];
1146#endif
1147            yystack.s_mark = yystack.s_base + (yyerrctx->yystack.s_mark - yyerrctx->yystack.s_base);
1148            memcpy (yystack.s_base, yyerrctx->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1149            yystack.l_mark = yystack.l_base + (yyerrctx->yystack.l_mark - yyerrctx->yystack.l_base);
1150            memcpy (yystack.l_base, yyerrctx->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1151#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1152            yystack.p_mark = yystack.p_base + (yyerrctx->yystack.p_mark - yyerrctx->yystack.p_base);
1153            memcpy (yystack.p_base, yyerrctx->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1154#endif
1155            yystate        = yyerrctx->state;
1156            yyFreeState(yyerrctx);
1157            yyerrctx       = NULL;
1158        }
1159        yynewerrflag = 1;
1160    }
1161    if (yynewerrflag == 0) goto yyinrecovery;
1162#endif /* YYBTYACC */
1163
1164    YYERROR_CALL("syntax error");
1165#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1166    yyerror_loc_range[0] = yylloc; /* lookahead position is error start position */
1167#endif
1168
1169#if !YYBTYACC
1170    goto yyerrlab;
1171yyerrlab:
1172#endif
1173    ++yynerrs;
1174
1175yyinrecovery:
1176    if (yyerrflag < 3)
1177    {
1178        yyerrflag = 3;
1179        for (;;)
1180        {
1181            if (((yyn = yysindex[*yystack.s_mark]) != 0) && (yyn += YYERRCODE) >= 0 &&
1182                    yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) YYERRCODE)
1183            {
1184#if YYDEBUG
1185                if (yydebug)
1186                    fprintf(stderr, "%s[%d]: state %d, error recovery shifting to state %d\n",
1187                                    YYDEBUGSTR, yydepth, *yystack.s_mark, yytable[yyn]);
1188#endif
1189                if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1190                yystate = yytable[yyn];
1191                *++yystack.s_mark = yytable[yyn];
1192                *++yystack.l_mark = yylval;
1193#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1194                /* lookahead position is error end position */
1195                yyerror_loc_range[1] = yylloc;
1196                YYLLOC_DEFAULT(yyloc, yyerror_loc_range, 2); /* position of error span */
1197                *++yystack.p_mark = yyloc;
1198#endif
1199                goto yyloop;
1200            }
1201            else
1202            {
1203#if YYDEBUG
1204                if (yydebug)
1205                    fprintf(stderr, "%s[%d]: error recovery discarding state %d\n",
1206                                    YYDEBUGSTR, yydepth, *yystack.s_mark);
1207#endif
1208                if (yystack.s_mark <= yystack.s_base) goto yyabort;
1209#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1210                /* the current TOS position is the error start position */
1211                yyerror_loc_range[0] = *yystack.p_mark;
1212#endif
1213#if defined(YYDESTRUCT_CALL)
1214#if YYBTYACC
1215                if (!yytrial)
1216#endif /* YYBTYACC */
1217#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1218                    YYDESTRUCT_CALL("error: discarding state",
1219                                    yystos[*yystack.s_mark], yystack.l_mark, yystack.p_mark);
1220#else
1221                    YYDESTRUCT_CALL("error: discarding state",
1222                                    yystos[*yystack.s_mark], yystack.l_mark);
1223#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1224#endif /* defined(YYDESTRUCT_CALL) */
1225                --yystack.s_mark;
1226                --yystack.l_mark;
1227#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1228                --yystack.p_mark;
1229#endif
1230            }
1231        }
1232    }
1233    else
1234    {
1235        if (yychar == YYEOF) goto yyabort;
1236#if YYDEBUG
1237        if (yydebug)
1238        {
1239            yys = yyname[YYTRANSLATE(yychar)];
1240            fprintf(stderr, "%s[%d]: state %d, error recovery discarding token %d (%s)\n",
1241                            YYDEBUGSTR, yydepth, yystate, yychar, yys);
1242        }
1243#endif
1244#if defined(YYDESTRUCT_CALL)
1245#if YYBTYACC
1246        if (!yytrial)
1247#endif /* YYBTYACC */
1248#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1249            YYDESTRUCT_CALL("error: discarding token", yychar, &yylval, &yylloc);
1250#else
1251            YYDESTRUCT_CALL("error: discarding token", yychar, &yylval);
1252#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1253#endif /* defined(YYDESTRUCT_CALL) */
1254        yychar = YYEMPTY;
1255        goto yyloop;
1256    }
1257
1258yyreduce:
1259    yym = yylen[yyn];
1260#if YYDEBUG
1261    if (yydebug)
1262    {
1263        fprintf(stderr, "%s[%d]: state %d, reducing by rule %d (%s)",
1264                        YYDEBUGSTR, yydepth, yystate, yyn, yyrule[yyn]);
1265#ifdef YYSTYPE_TOSTRING
1266#if YYBTYACC
1267        if (!yytrial)
1268#endif /* YYBTYACC */
1269            if (yym > 0)
1270            {
1271                int i;
1272                fputc('<', stderr);
1273                for (i = yym; i > 0; i--)
1274                {
1275                    if (i != yym) fputs(", ", stderr);
1276                    fputs(YYSTYPE_TOSTRING(yystos[yystack.s_mark[1-i]],
1277                                           yystack.l_mark[1-i]), stderr);
1278                }
1279                fputc('>', stderr);
1280            }
1281#endif
1282        fputc('\n', stderr);
1283    }
1284#endif
1285    if (yym > 0)
1286        yyval = yystack.l_mark[1-yym];
1287    else
1288        memset(&yyval, 0, sizeof yyval);
1289#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1290
1291    /* Perform position reduction */
1292    memset(&yyloc, 0, sizeof(yyloc));
1293#if YYBTYACC
1294    if (!yytrial)
1295#endif /* YYBTYACC */
1296    {
1297        YYLLOC_DEFAULT(yyloc, &yystack.p_mark[1-yym], yym);
1298        /* just in case YYERROR is invoked within the action, save
1299           the start of the rhs as the error start position */
1300        yyerror_loc_range[0] = yystack.p_mark[1-yym];
1301    }
1302#endif
1303
1304    switch (yyn)
1305    {
1306case 3:
1307#line 57 "calc1.y"
1308	{
1309		(void) printf("%15.8f\n", yystack.l_mark[-1].dval);
1310	}
1311break;
1312case 4:
1313#line 61 "calc1.y"
1314	{
1315		(void) printf("(%15.8f, %15.8f)\n", yystack.l_mark[-1].vval.lo, yystack.l_mark[-1].vval.hi);
1316	}
1317break;
1318case 5:
1319#line 65 "calc1.y"
1320	{
1321		dreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].dval;
1322	}
1323break;
1324case 6:
1325#line 69 "calc1.y"
1326	{
1327		vreg[yystack.l_mark[-3].ival] = yystack.l_mark[-1].vval;
1328	}
1329break;
1330case 7:
1331#line 73 "calc1.y"
1332	{
1333		yyerrok;
1334	}
1335break;
1336case 9:
1337#line 80 "calc1.y"
1338	{
1339		yyval.dval = dreg[yystack.l_mark[0].ival];
1340	}
1341break;
1342case 10:
1343#line 84 "calc1.y"
1344	{
1345		yyval.dval = yystack.l_mark[-2].dval + yystack.l_mark[0].dval;
1346	}
1347break;
1348case 11:
1349#line 88 "calc1.y"
1350	{
1351		yyval.dval = yystack.l_mark[-2].dval - yystack.l_mark[0].dval;
1352	}
1353break;
1354case 12:
1355#line 92 "calc1.y"
1356	{
1357		yyval.dval = yystack.l_mark[-2].dval * yystack.l_mark[0].dval;
1358	}
1359break;
1360case 13:
1361#line 96 "calc1.y"
1362	{
1363		yyval.dval = yystack.l_mark[-2].dval / yystack.l_mark[0].dval;
1364	}
1365break;
1366case 14:
1367#line 100 "calc1.y"
1368	{
1369		yyval.dval = -yystack.l_mark[0].dval;
1370	}
1371break;
1372case 15:
1373#line 104 "calc1.y"
1374	{
1375		yyval.dval = yystack.l_mark[-1].dval;
1376	}
1377break;
1378case 16:
1379#line 110 "calc1.y"
1380	{
1381		yyval.vval.hi = yyval.vval.lo = yystack.l_mark[0].dval;
1382	}
1383break;
1384case 17:
1385#line 114 "calc1.y"
1386	{
1387		yyval.vval.lo = yystack.l_mark[-3].dval;
1388		yyval.vval.hi = yystack.l_mark[-1].dval;
1389		if ( yyval.vval.lo > yyval.vval.hi )
1390		{
1391			(void) printf("interval out of order\n");
1392			YYERROR;
1393		}
1394	}
1395break;
1396case 18:
1397#line 124 "calc1.y"
1398	{
1399		yyval.vval = vreg[yystack.l_mark[0].ival];
1400	}
1401break;
1402case 19:
1403#line 128 "calc1.y"
1404	{
1405		yyval.vval.hi = yystack.l_mark[-2].vval.hi + yystack.l_mark[0].vval.hi;
1406		yyval.vval.lo = yystack.l_mark[-2].vval.lo + yystack.l_mark[0].vval.lo;
1407	}
1408break;
1409case 20:
1410#line 133 "calc1.y"
1411	{
1412		yyval.vval.hi = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.hi;
1413		yyval.vval.lo = yystack.l_mark[-2].dval + yystack.l_mark[0].vval.lo;
1414	}
1415break;
1416case 21:
1417#line 138 "calc1.y"
1418	{
1419		yyval.vval.hi = yystack.l_mark[-2].vval.hi - yystack.l_mark[0].vval.lo;
1420		yyval.vval.lo = yystack.l_mark[-2].vval.lo - yystack.l_mark[0].vval.hi;
1421	}
1422break;
1423case 22:
1424#line 143 "calc1.y"
1425	{
1426		yyval.vval.hi = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.lo;
1427		yyval.vval.lo = yystack.l_mark[-2].dval - yystack.l_mark[0].vval.hi;
1428	}
1429break;
1430case 23:
1431#line 148 "calc1.y"
1432	{
1433		yyval.vval = vmul( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
1434	}
1435break;
1436case 24:
1437#line 152 "calc1.y"
1438	{
1439		yyval.vval = vmul (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
1440	}
1441break;
1442case 25:
1443#line 156 "calc1.y"
1444	{
1445		if (dcheck(yystack.l_mark[0].vval)) YYERROR;
1446		yyval.vval = vdiv ( yystack.l_mark[-2].vval.lo, yystack.l_mark[-2].vval.hi, yystack.l_mark[0].vval );
1447	}
1448break;
1449case 26:
1450#line 161 "calc1.y"
1451	{
1452		if (dcheck ( yystack.l_mark[0].vval )) YYERROR;
1453		yyval.vval = vdiv (yystack.l_mark[-2].dval, yystack.l_mark[-2].dval, yystack.l_mark[0].vval );
1454	}
1455break;
1456case 27:
1457#line 166 "calc1.y"
1458	{
1459		yyval.vval.hi = -yystack.l_mark[0].vval.lo;
1460		yyval.vval.lo = -yystack.l_mark[0].vval.hi;
1461	}
1462break;
1463case 28:
1464#line 171 "calc1.y"
1465	{
1466		yyval.vval = yystack.l_mark[-1].vval;
1467	}
1468break;
1469#line 1470 "calc1.tab.c"
1470    default:
1471        break;
1472    }
1473    yystack.s_mark -= yym;
1474    yystate = *yystack.s_mark;
1475    yystack.l_mark -= yym;
1476#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1477    yystack.p_mark -= yym;
1478#endif
1479    yym = yylhs[yyn];
1480    if (yystate == 0 && yym == 0)
1481    {
1482#if YYDEBUG
1483        if (yydebug)
1484        {
1485            fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1486#ifdef YYSTYPE_TOSTRING
1487#if YYBTYACC
1488            if (!yytrial)
1489#endif /* YYBTYACC */
1490                fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[YYFINAL], yyval));
1491#endif
1492            fprintf(stderr, "shifting from state 0 to final state %d\n", YYFINAL);
1493        }
1494#endif
1495        yystate = YYFINAL;
1496        *++yystack.s_mark = YYFINAL;
1497        *++yystack.l_mark = yyval;
1498#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1499        *++yystack.p_mark = yyloc;
1500#endif
1501        if (yychar < 0)
1502        {
1503#if YYBTYACC
1504            do {
1505            if (yylvp < yylve)
1506            {
1507                /* we're currently re-reading tokens */
1508                yylval = *yylvp++;
1509#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1510                yylloc = *yylpp++;
1511#endif
1512                yychar = *yylexp++;
1513                break;
1514            }
1515            if (yyps->save)
1516            {
1517                /* in trial mode; save scanner results for future parse attempts */
1518                if (yylvp == yylvlim)
1519                {   /* Enlarge lexical value queue */
1520                    size_t p = (size_t) (yylvp - yylvals);
1521                    size_t s = (size_t) (yylvlim - yylvals);
1522
1523                    s += YYLVQUEUEGROWTH;
1524                    if ((yylexemes = (short *)   realloc(yylexemes, s * sizeof(short))) == NULL)
1525                        goto yyenomem;
1526                    if ((yylvals   = (YYSTYPE *) realloc(yylvals, s * sizeof(YYSTYPE))) == NULL)
1527                        goto yyenomem;
1528#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1529                    if ((yylpsns   = (YYLTYPE *) realloc(yylpsns, s * sizeof(YYLTYPE))) == NULL)
1530                        goto yyenomem;
1531#endif
1532                    yylvp   = yylve = yylvals + p;
1533                    yylvlim = yylvals + s;
1534#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1535                    yylpp   = yylpe = yylpsns + p;
1536                    yylplim = yylpsns + s;
1537#endif
1538                    yylexp  = yylexemes + p;
1539                }
1540                *yylexp = (short) YYLEX;
1541                *yylvp++ = yylval;
1542                yylve++;
1543#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1544                *yylpp++ = yylloc;
1545                yylpe++;
1546#endif
1547                yychar = *yylexp++;
1548                break;
1549            }
1550            /* normal operation, no conflict encountered */
1551#endif /* YYBTYACC */
1552            yychar = YYLEX;
1553#if YYBTYACC
1554            } while (0);
1555#endif /* YYBTYACC */
1556            if (yychar < 0) yychar = YYEOF;
1557            /* if ((yychar = YYLEX) < 0) yychar = YYEOF; */
1558#if YYDEBUG
1559            if (yydebug)
1560            {
1561                yys = yyname[YYTRANSLATE(yychar)];
1562                fprintf(stderr, "%s[%d]: state %d, reading %d (%s)\n",
1563                                YYDEBUGSTR, yydepth, YYFINAL, yychar, yys);
1564            }
1565#endif
1566        }
1567        if (yychar == YYEOF) goto yyaccept;
1568        goto yyloop;
1569    }
1570    if (((yyn = yygindex[yym]) != 0) && (yyn += yystate) >= 0 &&
1571            yyn <= YYTABLESIZE && yycheck[yyn] == (YYINT) yystate)
1572        yystate = yytable[yyn];
1573    else
1574        yystate = yydgoto[yym];
1575#if YYDEBUG
1576    if (yydebug)
1577    {
1578        fprintf(stderr, "%s[%d]: after reduction, ", YYDEBUGSTR, yydepth);
1579#ifdef YYSTYPE_TOSTRING
1580#if YYBTYACC
1581        if (!yytrial)
1582#endif /* YYBTYACC */
1583            fprintf(stderr, "result is <%s>, ", YYSTYPE_TOSTRING(yystos[yystate], yyval));
1584#endif
1585        fprintf(stderr, "shifting from state %d to state %d\n", *yystack.s_mark, yystate);
1586    }
1587#endif
1588    if (yystack.s_mark >= yystack.s_last && yygrowstack(&yystack) == YYENOMEM) goto yyoverflow;
1589    *++yystack.s_mark = (short) yystate;
1590    *++yystack.l_mark = yyval;
1591#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1592    *++yystack.p_mark = yyloc;
1593#endif
1594    goto yyloop;
1595#if YYBTYACC
1596
1597    /* Reduction declares that this path is valid. Set yypath and do a full parse */
1598yyvalid:
1599    if (yypath) YYABORT;
1600    while (yyps->save)
1601    {
1602        YYParseState *save = yyps->save;
1603        yyps->save = save->save;
1604        save->save = yypath;
1605        yypath = save;
1606    }
1607#if YYDEBUG
1608    if (yydebug)
1609        fprintf(stderr, "%s[%d]: state %d, CONFLICT trial successful, backtracking to state %d, %d tokens\n",
1610                        YYDEBUGSTR, yydepth, yystate, yypath->state, (int)(yylvp - yylvals - yypath->lexeme));
1611#endif
1612    if (yyerrctx)
1613    {
1614        yyFreeState(yyerrctx);
1615        yyerrctx = NULL;
1616    }
1617    yylvp          = yylvals + yypath->lexeme;
1618#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1619    yylpp          = yylpsns + yypath->lexeme;
1620#endif
1621    yylexp         = yylexemes + yypath->lexeme;
1622    yychar         = YYEMPTY;
1623    yystack.s_mark = yystack.s_base + (yypath->yystack.s_mark - yypath->yystack.s_base);
1624    memcpy (yystack.s_base, yypath->yystack.s_base, (size_t) (yystack.s_mark - yystack.s_base + 1) * sizeof(short));
1625    yystack.l_mark = yystack.l_base + (yypath->yystack.l_mark - yypath->yystack.l_base);
1626    memcpy (yystack.l_base, yypath->yystack.l_base, (size_t) (yystack.l_mark - yystack.l_base + 1) * sizeof(YYSTYPE));
1627#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1628    yystack.p_mark = yystack.p_base + (yypath->yystack.p_mark - yypath->yystack.p_base);
1629    memcpy (yystack.p_base, yypath->yystack.p_base, (size_t) (yystack.p_mark - yystack.p_base + 1) * sizeof(YYLTYPE));
1630#endif
1631    yystate        = yypath->state;
1632    goto yyloop;
1633#endif /* YYBTYACC */
1634
1635yyoverflow:
1636    YYERROR_CALL("yacc stack overflow");
1637#if YYBTYACC
1638    goto yyabort_nomem;
1639yyenomem:
1640    YYERROR_CALL("memory exhausted");
1641yyabort_nomem:
1642#endif /* YYBTYACC */
1643    yyresult = 2;
1644    goto yyreturn;
1645
1646yyabort:
1647    yyresult = 1;
1648    goto yyreturn;
1649
1650yyaccept:
1651#if YYBTYACC
1652    if (yyps->save) goto yyvalid;
1653#endif /* YYBTYACC */
1654    yyresult = 0;
1655
1656yyreturn:
1657#if defined(YYDESTRUCT_CALL)
1658    if (yychar != YYEOF && yychar != YYEMPTY)
1659#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1660        YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval, &yylloc);
1661#else
1662        YYDESTRUCT_CALL("cleanup: discarding token", yychar, &yylval);
1663#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1664
1665    {
1666        YYSTYPE *pv;
1667#if defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED)
1668        YYLTYPE *pp;
1669
1670        for (pv = yystack.l_base, pp = yystack.p_base; pv <= yystack.l_mark; ++pv, ++pp)
1671             YYDESTRUCT_CALL("cleanup: discarding state",
1672                             yystos[*(yystack.s_base + (pv - yystack.l_base))], pv, pp);
1673#else
1674        for (pv = yystack.l_base; pv <= yystack.l_mark; ++pv)
1675             YYDESTRUCT_CALL("cleanup: discarding state",
1676                             yystos[*(yystack.s_base + (pv - yystack.l_base))], pv);
1677#endif /* defined(YYLTYPE) || defined(YYLTYPE_IS_DECLARED) */
1678    }
1679#endif /* defined(YYDESTRUCT_CALL) */
1680
1681#if YYBTYACC
1682    if (yyerrctx)
1683    {
1684        yyFreeState(yyerrctx);
1685        yyerrctx = NULL;
1686    }
1687    while (yyps)
1688    {
1689        YYParseState *save = yyps;
1690        yyps = save->save;
1691        save->save = NULL;
1692        yyFreeState(save);
1693    }
1694    while (yypath)
1695    {
1696        YYParseState *save = yypath;
1697        yypath = save->save;
1698        save->save = NULL;
1699        yyFreeState(save);
1700    }
1701#endif /* YYBTYACC */
1702    yyfreestack(&yystack);
1703    return (yyresult);
1704}
1705