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
yyerror(const char * s)532 yyerror(const char *s)
533 {
534 fprintf(stderr, "%s\n", s);
535 }
536
537 int
yylex(void)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
hilo(double a,double b,double c,double d)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
vmul(double a,double b,INTERVAL v)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
dcheck(INTERVAL v)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
vdiv(double a,double b,INTERVAL v)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 */
yygrowstack(YYSTACKDATA * data)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)
yyfreestack(YYSTACKDATA * data)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 *
yyNewState(unsigned size)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
yyFreeState(YYParseState * p)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
YYPARSE_DECL()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