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