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