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