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