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