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