1 #ifndef lint
2 #if 0
3 static char yysccsid[] = "@(#)yaccpar 1.9 (Berkeley) 02/21/93";
4 #else
5 static char yyrcsid[] = "$NetBSD: skeleton.c,v 1.10 1996/03/25 00:36:18 mrg Exp $";
6 #endif
7 #endif
8 #include <stdlib.h>
9 #define YYBYACC 1
10 #define YYMAJOR 1
11 #define YYMINOR 9
12 #define YYLEX yylex()
13 #define YYEMPTY -1
14 #define yyclearin (yychar=(YYEMPTY))
15 #define yyerrok (yyerrflag=0)
16 #define YYRECOVERING (yyerrflag!=0)
17 #define YYPREFIX "yy"
18 #line 27 "parser.y"
19
20 # define INCLUDE_CTYPE
21 # include "comp.h"
22 # include "str.h"
23 # include "array.h"
24 # include "object.h"
25 # include "xfloat.h"
26 # include "interpret.h"
27 # include "macro.h"
28 # include "token.h"
29 # include "ppcontrol.h"
30 # include "node.h"
31 # include "compile.h"
32
33 # define yylex pp_gettok
34 # define yyerror c_error
35
36 int nerrors; /* number of errors encountered so far */
37 static int ndeclarations; /* number of declarations */
38 static int nstatements; /* number of statements in current function */
39 static bool typechecking; /* does the current function have it? */
40
41 static void t_void (node*);
42 static bool t_unary (node*, char*);
43 static node *uassign (int, node*, char*);
44 static node *cast (node*, node*);
45 static node *idx (node*, node*);
46 static node *range (node*, node*, node*);
47 static node *bini (int, node*, node*, char*);
48 static node *bina (int, node*, node*, char*);
49 static node *mult (int, node*, node*, char*);
50 static node *mdiv (int, node*, node*, char*);
51 static node *mod (int, node*, node*, char*);
52 static node *add (int, node*, node*, char*);
53 static node *sub (int, node*, node*, char*);
54 static node *umin (node*);
55 static node *lshift (int, node*, node*, char*);
56 static node *rshift (int, node*, node*, char*);
57 static node *rel (int, node*, node*, char*);
58 static node *eq (node*, node*);
59 static node *and (int, node*, node*, char*);
60 static node *xor (int, node*, node*, char*);
61 static node *or (int, node*, node*, char*);
62 static node *land (node*, node*);
63 static node *lor (node*, node*);
64 static node *quest (node*, node*, node*);
65 static node *assign (node*, node*);
66 static node *comma (node*, node*);
67
68 #line 93 "parser.y"
69 typedef union {
70 Int number; /* lex input */
71 xfloat real; /* lex input */
72 unsigned short type; /* internal */
73 struct _node_ *node; /* internal */
74 } YYSTYPE;
75 #line 76 "y.tab.c"
76 #define GOTO 257
77 #define MAPPING 258
78 #define NOMASK 259
79 #define BREAK 260
80 #define ELSE 261
81 #define CASE 262
82 #define FOR 263
83 #define FLOAT 264
84 #define STATIC 265
85 #define CONTINUE 266
86 #define RLIMITS 267
87 #define DEFAULT 268
88 #define DO 269
89 #define MIXED 270
90 #define OBJECT 271
91 #define RETURN 272
92 #define FUNCTION 273
93 #define OPERATOR 274
94 #define IF 275
95 #define INT 276
96 #define PRIVATE 277
97 #define CATCH 278
98 #define SWITCH 279
99 #define INHERIT 280
100 #define WHILE 281
101 #define ATOMIC 282
102 #define STRING 283
103 #define VOID 284
104 #define VARARGS 285
105 #define NIL 286
106 #define LARROW 287
107 #define RARROW 288
108 #define PLUS_PLUS 289
109 #define MIN_MIN 290
110 #define LSHIFT 291
111 #define RSHIFT 292
112 #define LE 293
113 #define GE 294
114 #define EQ 295
115 #define NE 296
116 #define LAND 297
117 #define LOR 298
118 #define PLUS_EQ 299
119 #define MIN_EQ 300
120 #define MULT_EQ 301
121 #define DIV_EQ 302
122 #define MOD_EQ 303
123 #define LSHIFT_EQ 304
124 #define RSHIFT_EQ 305
125 #define AND_EQ 306
126 #define XOR_EQ 307
127 #define OR_EQ 308
128 #define COLON_COLON 309
129 #define DOT_DOT 310
130 #define ELLIPSIS 311
131 #define STRING_CONST 312
132 #define IDENTIFIER 313
133 #define INT_CONST 314
134 #define FLOAT_CONST 315
135 #define MARK 316
136 #define HASH 317
137 #define HASH_HASH 318
138 #define INCL_CONST 319
139 #define NR_TOKENS 320
140 #define YYERRCODE 256
141 short yylhs[] = { -1,
142 55, 0, 54, 54, 56, 56, 56, 7, 7, 53,
143 9, 9, 9, 8, 57, 59, 58, 60, 58, 61,
144 10, 10, 10, 10, 11, 11, 12, 12, 13, 13,
145 1, 1, 1, 2, 2, 3, 3, 4, 4, 5,
146 5, 5, 5, 14, 14, 14, 14, 14, 14, 14,
147 14, 14, 6, 6, 15, 16, 17, 17, 18, 18,
148 19, 19, 20, 20, 20, 62, 21, 22, 22, 22,
149 63, 22, 64, 22, 65, 22, 66, 22, 67, 22,
150 68, 69, 22, 70, 22, 71, 22, 72, 22, 73,
151 22, 22, 22, 22, 22, 74, 23, 24, 24, 25,
152 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
153 26, 26, 26, 26, 75, 26, 26, 26, 26, 27,
154 27, 27, 28, 28, 28, 29, 29, 29, 29, 29,
155 29, 29, 30, 30, 31, 31, 31, 31, 32, 32,
156 32, 33, 33, 33, 34, 34, 34, 34, 34, 35,
157 35, 35, 36, 36, 37, 37, 38, 38, 39, 39,
158 40, 40, 41, 76, 77, 41, 42, 42, 42, 42,
159 42, 42, 42, 42, 42, 42, 42, 42, 43, 43,
160 44, 44, 45, 46, 47, 47, 48, 48, 48, 49,
161 49, 49, 50, 51, 51, 52, 52, 52,
162 };
163 short yylen[] = { 2,
164 0, 2, 0, 2, 5, 1, 1, 0, 1, 1,
165 1, 3, 3, 1, 4, 0, 5, 0, 7, 4,
166 0, 1, 1, 2, 1, 3, 2, 1, 2, 1,
167 1, 1, 2, 1, 2, 1, 1, 0, 1, 1,
168 1, 1, 1, 1, 1, 1, 1, 2, 1, 1,
169 1, 1, 0, 2, 2, 5, 1, 1, 1, 3,
170 0, 2, 1, 1, 2, 0, 6, 2, 1, 1,
171 0, 4, 0, 8, 0, 6, 0, 10, 0, 8,
172 0, 0, 5, 0, 6, 0, 5, 0, 7, 0,
173 4, 2, 2, 3, 1, 0, 4, 0, 2, 1,
174 2, 3, 1, 1, 1, 1, 5, 5, 1, 3,
175 4, 5, 8, 7, 0, 5, 6, 3, 5, 1,
176 4, 6, 1, 2, 2, 1, 2, 2, 2, 2,
177 2, 2, 1, 5, 1, 3, 3, 3, 1, 3,
178 3, 1, 3, 3, 1, 3, 3, 3, 3, 1,
179 3, 3, 1, 3, 1, 3, 1, 3, 1, 3,
180 1, 3, 1, 0, 0, 7, 1, 3, 3, 3,
181 3, 3, 3, 3, 3, 3, 3, 3, 1, 3,
182 0, 1, 1, 1, 1, 3, 0, 1, 2, 0,
183 1, 2, 3, 1, 3, 0, 1, 2,
184 };
185 short yydefred[] = { 1,
186 0, 3, 0, 42, 40, 0, 41, 43, 0, 0,
187 0, 0, 4, 6, 7, 49, 45, 51, 0, 50,
188 44, 46, 52, 10, 53, 0, 36, 0, 34, 37,
189 0, 14, 0, 11, 0, 0, 57, 0, 59, 0,
190 0, 35, 0, 9, 0, 0, 54, 0, 0, 15,
191 53, 0, 0, 0, 0, 25, 28, 53, 30, 0,
192 13, 12, 0, 96, 17, 58, 60, 27, 18, 24,
193 0, 0, 29, 5, 0, 61, 0, 26, 55, 56,
194 0, 19, 0, 0, 0, 0, 0, 0, 0, 73,
195 0, 0, 0, 0, 0, 105, 0, 0, 0, 103,
196 104, 95, 0, 0, 97, 0, 0, 0, 0, 0,
197 31, 106, 62, 0, 64, 69, 0, 120, 0, 0,
198 133, 135, 0, 0, 0, 0, 0, 0, 0, 0,
199 0, 0, 0, 179, 0, 0, 63, 65, 92, 0,
200 0, 0, 93, 0, 90, 0, 0, 184, 0, 0,
201 115, 0, 0, 0, 127, 128, 101, 130, 0, 0,
202 0, 53, 0, 0, 0, 129, 131, 132, 53, 71,
203 0, 0, 0, 0, 124, 125, 0, 0, 0, 0,
204 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
205 0, 0, 0, 0, 164, 0, 0, 0, 0, 0,
206 0, 0, 0, 0, 0, 0, 68, 0, 0, 0,
207 86, 0, 0, 0, 0, 0, 94, 0, 0, 82,
208 0, 0, 0, 185, 0, 0, 0, 194, 0, 0,
209 0, 110, 0, 0, 0, 0, 0, 0, 0, 118,
210 0, 0, 0, 0, 136, 137, 138, 0, 0, 0,
211 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
212 0, 0, 0, 169, 170, 171, 172, 173, 174, 175,
213 176, 177, 178, 168, 180, 102, 0, 0, 0, 0,
214 91, 0, 66, 0, 0, 84, 75, 0, 0, 0,
215 0, 0, 0, 0, 0, 0, 20, 72, 189, 0,
216 111, 0, 0, 121, 0, 0, 88, 87, 0, 0,
217 0, 0, 116, 0, 83, 0, 0, 0, 186, 107,
218 193, 195, 108, 134, 0, 112, 119, 0, 0, 165,
219 0, 0, 79, 0, 67, 99, 85, 76, 0, 0,
220 117, 122, 0, 89, 0, 0, 0, 114, 0, 166,
221 77, 80, 74, 113, 0, 78,
222 };
223 short yydgoto[] = { 1,
224 9, 28, 10, 11, 12, 36, 43, 112, 35, 54,
225 55, 56, 57, 58, 37, 66, 39, 40, 81, 113,
226 114, 115, 116, 315, 117, 118, 119, 120, 121, 122,
227 123, 124, 125, 126, 127, 128, 129, 130, 131, 132,
228 133, 134, 135, 148, 214, 149, 237, 238, 226, 228,
229 229, 230, 136, 3, 2, 13, 14, 15, 49, 77,
230 137, 312, 236, 146, 317, 355, 346, 152, 285, 316,
231 278, 331, 215, 76, 219, 263, 343,
232 };
233 short yysindex[] = { 0,
234 0, 0, -198, 0, 0, 0, 0, 0, 325, -167,
235 -237, 0, 0, 0, 0, 0, 0, 0, -30, 0,
236 0, 0, 0, 0, 0, 13, 0, -167, 0, 0,
237 -225, 0, -30, 0, 87, -23, 0, 0, 0, 53,
238 -162, 0, -30, 0, 21, -236, 0, 95, 19, 0,
239 0, 0, 325, 116, -41, 0, 0, 0, 0, 4,
240 0, 0, -162, 0, 0, 0, 0, 0, 0, 0,
241 737, -23, 0, 0, 121, 0, 19, 0, 0, 0,
242 163, 0, 129, 131, 201, 135, 134, 140, 141, 0,
243 201, 149, 158, 160, 162, 0, 201, 201, -225, 0,
244 0, 0, 201, 359, 0, -38, 201, 201, 201, -97,
245 0, 0, 0, -57, 0, 0, 165, 0, -70, -196,
246 0, 0, 102, 103, -191, -42, -127, 169, 115, 86,
247 -85, -50, 155, 0, 61, -96, 0, 0, 0, 158,
248 -44, 201, 0, 201, 0, 298, 171, 0, 161, 201,
249 0, 19, 201, 201, 0, 0, 0, 0, 201, 201,
250 201, 0, 25, 177, 181, 0, 0, 0, 0, 0,
251 201, -29, -225, 201, 0, 0, 201, 201, 201, 201,
252 201, 201, 201, 201, 201, 201, 201, 201, 201, 201,
253 201, 201, 201, 201, 0, 201, 201, 201, 201, 201,
254 201, 201, 201, 201, 201, 201, 0, 201, -225, 201,
255 0, 172, 171, 173, 298, -53, 0, 183, 201, 0,
256 189, 195, 197, 0, 196, 120, 192, 0, 203, 164,
257 130, 0, 201, 201, 69, 298, -32, 212, -30, 0,
258 214, 171, 167, -48, 0, 0, 0, 102, 102, 103,
259 103, -191, -191, -191, -191, -42, -42, -127, 169, 115,
260 86, -85, 201, 0, 0, 0, 0, 0, 0, 0,
261 0, 0, 0, 0, 0, 0, 205, 298, 201, 201,
262 0, 224, 0, 31, 215, 0, 0, 253, 201, 254,
263 201, 201, 279, 201, 287, 291, 0, 0, 0, 201,
264 0, 109, 201, 0, 201, 33, 0, 0, 235, 292,
265 201, 298, 0, 298, 0, 19, 298, 201, 0, 0,
266 0, 0, 0, 0, 294, 0, 0, 296, 242, 0,
267 298, 201, 0, 299, 0, 0, 0, 0, 301, 201,
268 0, 0, 201, 0, 303, 19, 280, 0, 304, 0,
269 0, 0, 0, 0, 298, 0,
270 };
271 short yyrindex[] = { 0,
272 0, 0, 1, 0, 0, 699, 0, 0, 0, 0,
273 430, 619, 0, 0, 0, 0, 0, 0, -37, 0,
274 0, 0, 0, 0, 0, 0, 0, 1038, 0, 0,
275 -25, 0, 0, 0, -35, 0, 0, 6, 0, 0,
276 305, 0, 0, 0, 0, 0, 0, 88, 0, 0,
277 0, -33, 0, 0, 306, 0, 0, 0, 0, 0,
278 0, 0, 305, 0, 0, 0, 0, 0, 0, 0,
279 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
280 -15, 0, 0, 0, 0, 0, 0, 0, 0, 0,
281 289, 0, 227, 0, 0, 0, 0, 0, 0, 0,
282 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
283 0, 0, 0, 100, 0, 0, 0, 0, 617, 736,
284 0, 0, 762, 1081, 1195, 1579, 1651, 1719, 425, 1919,
285 2063, 2103, -19, 0, 0, 461, 0, 0, 0, 0,
286 0, 289, 0, 0, 0, 0, -11, 0, 0, 0,
287 0, 0, 0, 0, 0, 0, 0, 0, 0, 226,
288 268, 0, 0, 0, 0, 0, 0, 0, 0, 0,
289 333, 0, 0, 70, 0, 0, 0, 0, 0, 0,
290 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
291 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
292 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
293 0, 0, 11, 0, 0, 0, 0, 0, 0, 0,
294 0, 0, 0, 0, 262, 0, 0, 0, 295, 0,
295 0, 0, 0, 333, 0, 0, 350, 0, 0, 0,
296 0, -77, 0, 0, 0, 0, 0, 805, 893, 1118,
297 1169, 1223, 1269, 1308, 1497, 1603, 1627, 1695, 1770, 1795,
298 1990, 2079, 0, 0, 0, 0, 0, 0, 0, 0,
299 0, 0, 0, 0, 0, 0, 0, 0, 289, 0,
300 0, 0, 0, 0, 40, 0, 0, 0, 269, 0,
301 0, 300, 0, 0, 0, 0, 0, 0, 0, 0,
302 0, 0, 333, 0, 302, 0, 0, 0, 0, 0,
303 0, 0, 0, 0, 0, 0, 0, 333, 0, 0,
304 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
305 0, 355, 0, 0, 0, 0, 0, 0, 0, 333,
306 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
307 0, 0, 0, 0, 0, 0,
308 };
309 short yygindex[] = { 0,
310 317, 0, 32, 319, 58, -26, 0, -2, -10, 340,
311 0, 334, 353, 27, 349, 383, 360, 241, 0, 0,
312 0, -120, -49, 0, 0, 0, 0, 0, 0, -52,
313 -3, 2, -31, -6, 228, 225, 244, 234, 223, 0,
314 77, 2255, 565, -118, -116, -145, 273, -199, 0, 142,
315 0, 0, 18, 0, 0, 0, 0, 0, 0, 0,
316 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
317 0, 0, 0, 0, 0, 0, 0,
318 };
319 #define YYTABLESIZE 2595
320 short yytable[] = { 65,
321 2, 164, 71, 47, 47, 48, 48, 22, 52, 33,
322 239, 300, 195, 211, 8, 183, 34, 186, 47, 187,
323 174, 167, 45, 212, 167, 216, 26, 82, 244, 182,
324 34, 72, 60, 218, 296, 25, 221, 222, 167, 167,
325 34, 29, 31, 62, 155, 156, 46, 182, 44, 58,
326 158, 183, 41, 48, 166, 167, 168, 243, 59, 42,
327 4, 61, 74, 46, 58, 232, 5, 30, 208, 183,
328 59, 313, 98, 167, 208, 32, 208, 98, 6, 98,
329 59, 182, 98, 7, 98, 30, 8, 24, 59, 79,
330 330, 4, 175, 176, 281, 16, 51, 5, 98, 182,
331 183, 17, 220, 328, 208, 167, 223, 18, 19, 27,
332 20, 50, 51, 21, 7, 298, 157, 8, 339, 207,
333 22, 52, 53, 165, 245, 246, 247, 297, 16, 46,
334 162, 55, 70, 309, 63, 231, 169, 70, 179, 70,
335 349, 64, 70, 177, 70, 180, 55, 181, 178, 327,
336 24, 46, 252, 253, 254, 255, 69, 308, 70, 329,
337 16, 80, 98, 310, 98, 98, 17, 188, 189, 240,
338 294, 47, 18, 19, 142, 20, 248, 249, 21, 144,
339 295, 256, 257, 250, 251, 22, 23, 138, 150, 139,
340 241, 335, 143, 336, 334, 108, 338, 151, 145, 153,
341 106, 154, 104, 170, 171, 103, 190, 107, 191, 192,
342 344, 193, 209, 345, 208, 206, 172, 173, 233, 217,
343 234, 102, 70, 283, 70, 70, 276, 282, 302, 286,
344 279, 280, 182, 108, 356, 287, 34, 288, 106, 289,
345 104, 324, 38, 103, 290, 107, 292, 194, 38, 291,
346 184, 185, 301, 303, 38, 38, 293, 38, 38, 304,
347 38, 305, 307, 311, 38, 210, 337, 38, 38, 70,
348 38, 38, 314, 38, 24, 47, 38, 48, 299, 52,
349 38, 32, 32, 38, 38, 64, 8, 105, 109, 24,
350 167, 167, 318, 332, 320, 98, 352, 98, 98, 98,
351 98, 98, 98, 98, 98, 98, 98, 98, 98, 98,
352 98, 98, 98, 38, 98, 98, 98, 98, 98, 323,
353 98, 98, 98, 98, 98, 98, 109, 325, 98, 98,
354 108, 326, 333, 340, 342, 106, 341, 104, 353, 347,
355 103, 348, 107, 351, 354, 21, 23, 181, 98, 81,
356 190, 98, 98, 98, 98, 70, 102, 70, 70, 70,
357 196, 70, 70, 70, 70, 70, 70, 70, 70, 70,
358 70, 70, 70, 187, 70, 70, 70, 70, 70, 181,
359 70, 70, 70, 70, 70, 70, 191, 197, 70, 70,
360 188, 108, 198, 192, 181, 181, 106, 110, 104, 111,
361 159, 103, 75, 107, 78, 68, 73, 38, 70, 235,
362 67, 70, 70, 70, 70, 259, 262, 258, 83, 350,
363 64, 4, 84, 109, 85, 86, 261, 5, 87, 88,
364 89, 90, 225, 322, 91, 260, 0, 92, 0, 6,
365 93, 94, 0, 95, 7, 0, 0, 8, 96, 161,
366 0, 97, 98, 196, 197, 198, 199, 200, 201, 202,
367 203, 204, 205, 0, 0, 157, 0, 0, 157, 0,
368 0, 99, 0, 0, 32, 24, 100, 101, 140, 0,
369 0, 160, 157, 157, 109, 157, 96, 157, 0, 97,
370 98, 0, 0, 0, 0, 0, 0, 109, 109, 0,
371 100, 109, 109, 109, 109, 109, 0, 109, 0, 99,
372 0, 0, 32, 24, 100, 101, 0, 157, 109, 109,
373 109, 109, 109, 109, 0, 0, 0, 0, 0, 0,
374 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
375 0, 0, 0, 0, 0, 0, 0, 0, 157, 157,
376 0, 109, 0, 109, 109, 0, 0, 84, 0, 85,
377 86, 0, 0, 87, 88, 89, 90, 0, 0, 91,
378 0, 0, 92, 0, 0, 93, 94, 0, 95, 0,
379 0, 0, 16, 96, 109, 109, 97, 98, 17, 0,
380 0, 0, 0, 0, 18, 19, 0, 20, 0, 0,
381 21, 0, 0, 0, 0, 0, 99, 22, 23, 32,
382 24, 100, 101, 0, 0, 0, 16, 0, 0, 0,
383 0, 0, 17, 0, 0, 0, 0, 0, 18, 19,
384 0, 20, 0, 0, 21, 0, 140, 24, 0, 0,
385 0, 22, 23, 0, 96, 0, 0, 97, 98, 0,
386 0, 0, 0, 123, 123, 147, 0, 123, 123, 123,
387 123, 123, 0, 123, 0, 0, 0, 99, 163, 0,
388 32, 24, 100, 101, 123, 123, 123, 123, 123, 123,
389 0, 0, 0, 0, 0, 0, 0, 31, 0, 0,
390 0, 0, 0, 31, 0, 0, 0, 0, 0, 31,
391 31, 0, 31, 0, 0, 31, 147, 0, 213, 123,
392 123, 0, 31, 31, 213, 0, 0, 213, 213, 0,
393 0, 157, 157, 157, 157, 157, 157, 157, 157, 157,
394 157, 157, 157, 0, 157, 157, 0, 0, 242, 0,
395 123, 123, 31, 0, 0, 0, 0, 109, 109, 109,
396 109, 109, 109, 109, 109, 109, 109, 109, 109, 109,
397 109, 109, 109, 109, 109, 109, 109, 109, 109, 0,
398 109, 109, 126, 126, 0, 0, 126, 126, 126, 126,
399 126, 0, 126, 284, 0, 0, 0, 0, 0, 0,
400 0, 0, 0, 126, 126, 126, 126, 126, 126, 139,
401 0, 0, 139, 0, 139, 139, 139, 0, 0, 0,
402 0, 0, 0, 0, 0, 0, 0, 0, 0, 139,
403 139, 139, 139, 139, 139, 0, 0, 306, 126, 126,
404 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
405 0, 0, 140, 147, 213, 140, 0, 140, 140, 140,
406 0, 0, 0, 0, 139, 139, 0, 0, 0, 126,
407 126, 0, 140, 140, 140, 140, 140, 140, 0, 147,
408 0, 0, 0, 0, 0, 213, 32, 37, 0, 0,
409 0, 0, 32, 37, 0, 139, 139, 0, 32, 32,
410 0, 32, 0, 0, 32, 37, 147, 140, 140, 0,
411 37, 32, 32, 37, 0, 123, 123, 123, 123, 123,
412 123, 123, 123, 123, 123, 123, 123, 123, 123, 123,
413 123, 123, 123, 123, 123, 0, 123, 123, 140, 140,
414 141, 32, 0, 141, 0, 141, 141, 141, 0, 0,
415 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
416 141, 141, 141, 141, 141, 141, 39, 36, 0, 0,
417 0, 0, 39, 36, 0, 0, 0, 0, 39, 39,
418 0, 39, 0, 0, 39, 36, 0, 0, 39, 0,
419 36, 39, 39, 36, 0, 141, 141, 0, 0, 0,
420 0, 0, 0, 0, 16, 0, 0, 0, 0, 0,
421 17, 0, 0, 0, 0, 0, 18, 19, 0, 20,
422 0, 39, 21, 0, 0, 0, 141, 141, 0, 22,
423 23, 53, 0, 0, 0, 0, 126, 126, 126, 126,
424 126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
425 126, 126, 126, 126, 0, 126, 126, 0, 0, 24,
426 0, 0, 139, 139, 139, 139, 139, 139, 139, 139,
427 139, 139, 139, 139, 139, 139, 139, 139, 139, 139,
428 0, 139, 139, 0, 0, 0, 0, 0, 0, 0,
429 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
430 0, 0, 0, 0, 0, 140, 140, 140, 140, 140,
431 140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
432 140, 140, 140, 0, 140, 140, 0, 0, 142, 0,
433 0, 142, 0, 0, 142, 0, 0, 0, 0, 0,
434 0, 0, 0, 0, 0, 0, 0, 0, 142, 142,
435 142, 142, 142, 142, 0, 0, 0, 0, 0, 0,
436 0, 0, 0, 0, 0, 143, 0, 0, 143, 0,
437 0, 143, 0, 0, 0, 0, 0, 0, 0, 0,
438 0, 0, 0, 142, 142, 143, 143, 143, 143, 143,
439 143, 0, 0, 141, 141, 141, 141, 141, 141, 141,
440 141, 141, 141, 141, 141, 141, 141, 141, 141, 141,
441 141, 0, 141, 141, 142, 142, 144, 0, 0, 144,
442 143, 143, 144, 0, 0, 0, 0, 0, 0, 0,
443 0, 0, 0, 0, 0, 0, 144, 144, 144, 144,
444 144, 144, 145, 0, 0, 145, 0, 0, 145, 0,
445 0, 143, 143, 0, 0, 0, 0, 0, 0, 0,
446 0, 0, 145, 145, 145, 145, 145, 145, 0, 0,
447 148, 144, 144, 148, 0, 0, 148, 0, 0, 0,
448 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
449 148, 148, 148, 148, 148, 148, 0, 145, 145, 0,
450 0, 0, 144, 144, 0, 33, 0, 0, 0, 0,
451 0, 33, 0, 0, 0, 0, 149, 33, 33, 149,
452 33, 0, 149, 33, 0, 148, 148, 0, 145, 145,
453 33, 33, 0, 0, 0, 0, 149, 149, 149, 149,
454 149, 149, 0, 0, 0, 0, 0, 0, 0, 0,
455 0, 0, 0, 0, 0, 146, 148, 148, 146, 0,
456 33, 146, 0, 0, 0, 0, 0, 0, 0, 0,
457 0, 149, 149, 0, 0, 146, 146, 146, 146, 146,
458 146, 142, 142, 142, 142, 142, 142, 142, 142, 142,
459 142, 142, 142, 142, 142, 142, 142, 142, 142, 0,
460 142, 142, 149, 149, 0, 0, 0, 0, 0, 0,
461 146, 146, 0, 0, 0, 0, 0, 0, 143, 143,
462 143, 143, 143, 143, 143, 143, 143, 143, 143, 143,
463 143, 143, 143, 143, 143, 143, 0, 143, 143, 0,
464 0, 146, 146, 0, 0, 0, 0, 0, 0, 0,
465 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
466 0, 0, 0, 0, 0, 0, 0, 0, 0, 144,
467 144, 144, 144, 144, 144, 144, 144, 144, 144, 144,
468 144, 144, 144, 144, 144, 144, 144, 0, 144, 144,
469 0, 0, 0, 0, 0, 0, 0, 145, 145, 145,
470 145, 145, 145, 145, 145, 145, 145, 145, 145, 145,
471 145, 145, 145, 0, 145, 145, 0, 0, 0, 0,
472 0, 0, 0, 0, 0, 148, 148, 148, 148, 148,
473 148, 148, 148, 148, 148, 148, 148, 148, 148, 148,
474 148, 0, 148, 148, 147, 0, 0, 147, 0, 0,
475 147, 0, 0, 0, 0, 0, 0, 0, 0, 0,
476 0, 0, 0, 0, 147, 147, 147, 147, 147, 147,
477 0, 149, 149, 149, 149, 149, 149, 149, 149, 149,
478 149, 149, 149, 149, 149, 149, 149, 0, 149, 149,
479 0, 0, 0, 0, 0, 0, 0, 0, 0, 147,
480 147, 0, 0, 0, 0, 0, 0, 0, 0, 0,
481 146, 146, 146, 146, 146, 146, 146, 146, 146, 146,
482 146, 146, 146, 146, 146, 146, 150, 146, 146, 150,
483 147, 147, 150, 0, 0, 0, 0, 0, 0, 0,
484 0, 0, 0, 0, 0, 0, 150, 150, 0, 150,
485 151, 150, 0, 151, 0, 0, 151, 0, 0, 0,
486 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
487 151, 151, 0, 151, 152, 151, 0, 152, 0, 0,
488 152, 150, 150, 0, 0, 0, 0, 0, 0, 0,
489 0, 0, 0, 0, 152, 152, 0, 152, 153, 152,
490 0, 153, 0, 0, 153, 151, 151, 0, 0, 0,
491 0, 0, 150, 150, 0, 0, 0, 0, 153, 153,
492 0, 153, 0, 153, 0, 0, 0, 0, 0, 152,
493 152, 0, 0, 0, 0, 0, 151, 151, 0, 0,
494 0, 0, 154, 0, 0, 154, 0, 0, 154, 0,
495 0, 0, 0, 153, 153, 0, 0, 0, 0, 0,
496 152, 152, 154, 154, 0, 154, 0, 154, 0, 155,
497 0, 0, 155, 0, 0, 0, 0, 0, 0, 0,
498 0, 0, 0, 0, 153, 153, 155, 155, 0, 155,
499 0, 155, 0, 0, 0, 0, 0, 154, 154, 147,
500 147, 147, 147, 147, 147, 147, 147, 147, 147, 147,
501 147, 147, 147, 147, 147, 0, 147, 147, 0, 0,
502 156, 155, 155, 156, 0, 0, 0, 0, 154, 154,
503 0, 0, 0, 0, 0, 0, 0, 156, 156, 0,
504 156, 0, 156, 0, 0, 158, 0, 0, 158, 0,
505 0, 0, 155, 155, 0, 0, 0, 0, 0, 0,
506 0, 0, 158, 158, 0, 158, 0, 158, 0, 0,
507 0, 0, 156, 156, 0, 0, 0, 0, 0, 0,
508 0, 0, 0, 150, 150, 150, 150, 150, 150, 150,
509 150, 150, 150, 150, 150, 150, 150, 158, 150, 150,
510 0, 0, 0, 156, 156, 0, 0, 151, 151, 151,
511 151, 151, 151, 151, 151, 151, 151, 151, 151, 151,
512 151, 0, 151, 151, 0, 0, 0, 0, 158, 158,
513 0, 152, 152, 152, 152, 152, 152, 152, 152, 152,
514 152, 152, 152, 152, 152, 0, 152, 152, 0, 0,
515 0, 0, 0, 0, 0, 0, 0, 153, 153, 153,
516 153, 153, 153, 153, 153, 153, 153, 153, 153, 159,
517 153, 153, 159, 0, 0, 0, 0, 0, 0, 0,
518 0, 0, 0, 0, 0, 0, 159, 159, 0, 159,
519 0, 159, 0, 0, 0, 0, 0, 0, 0, 0,
520 0, 154, 154, 154, 154, 154, 154, 154, 154, 154,
521 154, 154, 154, 0, 154, 154, 0, 0, 0, 0,
522 0, 159, 0, 0, 0, 155, 155, 155, 155, 155,
523 155, 155, 155, 155, 155, 155, 155, 0, 155, 155,
524 160, 0, 0, 160, 0, 0, 0, 0, 0, 0,
525 0, 0, 0, 159, 0, 0, 0, 160, 160, 0,
526 160, 0, 160, 0, 0, 0, 0, 0, 0, 0,
527 0, 0, 0, 0, 0, 0, 156, 156, 156, 156,
528 156, 156, 156, 156, 156, 156, 156, 156, 0, 156,
529 156, 0, 160, 0, 0, 0, 0, 0, 0, 0,
530 0, 158, 158, 158, 158, 158, 158, 158, 158, 158,
531 158, 158, 158, 161, 158, 158, 161, 0, 0, 0,
532 0, 0, 0, 0, 160, 0, 0, 0, 0, 162,
533 161, 161, 162, 161, 0, 161, 0, 0, 0, 0,
534 0, 0, 0, 0, 0, 0, 162, 162, 0, 162,
535 0, 162, 0, 163, 0, 0, 163, 0, 0, 0,
536 0, 0, 0, 0, 0, 161, 0, 0, 0, 0,
537 163, 163, 0, 163, 0, 0, 0, 0, 0, 0,
538 0, 162, 0, 0, 0, 0, 0, 0, 0, 0,
539 0, 0, 0, 0, 0, 0, 0, 161, 0, 0,
540 0, 0, 0, 0, 0, 163, 0, 0, 0, 0,
541 0, 0, 0, 162, 0, 0, 0, 0, 0, 0,
542 0, 0, 0, 0, 0, 159, 159, 159, 159, 159,
543 159, 159, 159, 159, 159, 159, 159, 163, 159, 159,
544 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
545 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
546 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
547 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
548 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
549 0, 0, 0, 0, 0, 0, 160, 160, 160, 160,
550 160, 160, 160, 160, 160, 160, 160, 160, 0, 160,
551 160, 0, 0, 0, 0, 0, 0, 0, 0, 0,
552 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
553 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
554 0, 0, 0, 0, 0, 0, 0, 0, 0, 141,
555 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
556 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
557 161, 161, 161, 161, 161, 161, 161, 161, 161, 161,
558 161, 0, 161, 161, 0, 0, 162, 162, 162, 162,
559 162, 162, 162, 162, 162, 162, 162, 0, 162, 162,
560 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
561 0, 163, 163, 163, 163, 163, 163, 163, 163, 163,
562 163, 0, 163, 163, 224, 227, 0, 0, 0, 0,
563 0, 0, 0, 0, 0, 224, 0, 0, 0, 0,
564 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
565 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
566 264, 265, 266, 267, 268, 269, 270, 271, 272, 273,
567 274, 0, 275, 0, 277, 0, 0, 0, 0, 0,
568 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
569 0, 0, 0, 0, 0, 0, 0, 0, 224, 0,
570 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
571 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
572 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
573 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
574 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
575 0, 0, 0, 319, 0, 321, 227, 0, 0, 0,
576 0, 0, 0, 0, 319, 0, 0, 224, 0, 0,
577 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
578 0, 0, 224, 0, 0, 0, 0, 0, 0, 0,
579 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
580 0, 0, 0, 0, 224,
581 };
582 short yycheck[] = { 49,
583 0, 40, 44, 41, 42, 41, 42, 41, 42, 40,
584 40, 44, 63, 58, 40, 93, 19, 60, 42, 62,
585 91, 41, 33, 142, 44, 146, 9, 77, 174, 41,
586 33, 58, 43, 150, 234, 9, 153, 154, 58, 59,
587 43, 10, 280, 46, 97, 98, 43, 59, 31, 44,
588 103, 41, 40, 36, 107, 108, 109, 174, 41, 28,
589 259, 41, 59, 43, 59, 41, 265, 10, 44, 59,
590 53, 41, 33, 93, 44, 312, 44, 38, 277, 40,
591 63, 93, 43, 282, 45, 28, 285, 313, 71, 72,
592 58, 259, 289, 290, 215, 258, 44, 265, 59, 291,
593 292, 264, 152, 303, 44, 125, 159, 270, 271, 277,
594 273, 59, 44, 276, 282, 236, 99, 285, 318, 59,
595 283, 284, 285, 106, 177, 178, 179, 59, 123, 43,
596 104, 44, 33, 279, 40, 162, 110, 38, 37, 40,
597 340, 123, 43, 42, 45, 43, 59, 45, 47, 41,
598 313, 43, 184, 185, 186, 187, 41, 278, 59, 305,
599 258, 41, 123, 280, 125, 126, 264, 295, 296, 172,
600 41, 42, 270, 271, 40, 273, 180, 181, 276, 40,
601 233, 188, 189, 182, 183, 283, 284, 59, 40, 59,
602 173, 312, 59, 314, 311, 33, 317, 40, 58, 40,
603 38, 40, 40, 261, 40, 43, 38, 45, 94, 124,
604 331, 297, 309, 332, 44, 61, 287, 288, 42, 59,
605 40, 59, 123, 41, 125, 126, 209, 281, 239, 41,
606 59, 59, 310, 33, 355, 41, 239, 41, 38, 44,
607 40, 294, 258, 43, 125, 45, 44, 298, 264, 58,
608 293, 294, 41, 40, 270, 271, 93, 273, 258, 93,
609 276, 310, 58, 40, 264, 310, 316, 283, 284, 311,
610 270, 271, 58, 273, 313, 313, 276, 313, 311, 313,
611 280, 312, 312, 283, 284, 123, 312, 125, 126, 313,
612 310, 311, 40, 59, 41, 256, 346, 258, 259, 260,
613 261, 262, 263, 264, 265, 266, 267, 268, 269, 270,
614 271, 272, 273, 313, 275, 276, 277, 278, 279, 41,
615 281, 282, 283, 284, 285, 286, 126, 41, 289, 290,
616 33, 41, 41, 40, 93, 38, 41, 40, 59, 41,
617 43, 41, 45, 41, 41, 41, 41, 59, 309, 123,
618 125, 312, 313, 314, 315, 256, 59, 258, 259, 260,
619 93, 262, 263, 264, 265, 266, 267, 268, 269, 270,
620 271, 272, 273, 41, 275, 276, 277, 278, 279, 310,
621 281, 282, 283, 284, 285, 286, 125, 93, 289, 290,
622 41, 33, 93, 125, 93, 41, 38, 81, 40, 81,
623 42, 43, 63, 45, 71, 53, 58, 25, 309, 169,
624 51, 312, 313, 314, 315, 191, 194, 190, 256, 343,
625 123, 259, 260, 126, 262, 263, 193, 265, 266, 267,
626 268, 269, 160, 292, 272, 192, -1, 275, -1, 277,
627 278, 279, -1, 281, 282, -1, -1, 285, 286, 91,
628 -1, 289, 290, 299, 300, 301, 302, 303, 304, 305,
629 306, 307, 308, -1, -1, 41, -1, -1, 44, -1,
630 -1, 309, -1, -1, 312, 313, 314, 315, 278, -1,
631 -1, 123, 58, 59, 126, 61, 286, 63, -1, 289,
632 290, -1, -1, -1, -1, -1, -1, 37, 38, -1,
633 40, 41, 42, 43, 44, 45, -1, 47, -1, 309,
634 -1, -1, 312, 313, 314, 315, -1, 93, 58, 59,
635 60, 61, 62, 63, -1, -1, -1, -1, -1, -1,
636 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
637 -1, -1, -1, -1, -1, -1, -1, -1, 124, 125,
638 -1, 91, -1, 93, 94, -1, -1, 260, -1, 262,
639 263, -1, -1, 266, 267, 268, 269, -1, -1, 272,
640 -1, -1, 275, -1, -1, 278, 279, -1, 281, -1,
641 -1, -1, 258, 286, 124, 125, 289, 290, 264, -1,
642 -1, -1, -1, -1, 270, 271, -1, 273, -1, -1,
643 276, -1, -1, -1, -1, -1, 309, 283, 284, 312,
644 313, 314, 315, -1, -1, -1, 258, -1, -1, -1,
645 -1, -1, 264, -1, -1, -1, -1, -1, 270, 271,
646 -1, 273, -1, -1, 276, -1, 278, 313, -1, -1,
647 -1, 283, 284, -1, 286, -1, -1, 289, 290, -1,
648 -1, -1, -1, 37, 38, 91, -1, 41, 42, 43,
649 44, 45, -1, 47, -1, -1, -1, 309, 104, -1,
650 312, 313, 314, 315, 58, 59, 60, 61, 62, 63,
651 -1, -1, -1, -1, -1, -1, -1, 258, -1, -1,
652 -1, -1, -1, 264, -1, -1, -1, -1, -1, 270,
653 271, -1, 273, -1, -1, 276, 142, -1, 144, 93,
654 94, -1, 283, 284, 150, -1, -1, 153, 154, -1,
655 -1, 297, 298, 299, 300, 301, 302, 303, 304, 305,
656 306, 307, 308, -1, 310, 311, -1, -1, 174, -1,
657 124, 125, 313, -1, -1, -1, -1, 287, 288, 289,
658 290, 291, 292, 293, 294, 295, 296, 297, 298, 299,
659 300, 301, 302, 303, 304, 305, 306, 307, 308, -1,
660 310, 311, 37, 38, -1, -1, 41, 42, 43, 44,
661 45, -1, 47, 219, -1, -1, -1, -1, -1, -1,
662 -1, -1, -1, 58, 59, 60, 61, 62, 63, 38,
663 -1, -1, 41, -1, 43, 44, 45, -1, -1, -1,
664 -1, -1, -1, -1, -1, -1, -1, -1, -1, 58,
665 59, 60, 61, 62, 63, -1, -1, 263, 93, 94,
666 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
667 -1, -1, 38, 279, 280, 41, -1, 43, 44, 45,
668 -1, -1, -1, -1, 93, 94, -1, -1, -1, 124,
669 125, -1, 58, 59, 60, 61, 62, 63, -1, 305,
670 -1, -1, -1, -1, -1, 311, 258, 259, -1, -1,
671 -1, -1, 264, 265, -1, 124, 125, -1, 270, 271,
672 -1, 273, -1, -1, 276, 277, 332, 93, 94, -1,
673 282, 283, 284, 285, -1, 289, 290, 291, 292, 293,
674 294, 295, 296, 297, 298, 299, 300, 301, 302, 303,
675 304, 305, 306, 307, 308, -1, 310, 311, 124, 125,
676 38, 313, -1, 41, -1, 43, 44, 45, -1, -1,
677 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
678 58, 59, 60, 61, 62, 63, 258, 259, -1, -1,
679 -1, -1, 264, 265, -1, -1, -1, -1, 270, 271,
680 -1, 273, -1, -1, 276, 277, -1, -1, 280, -1,
681 282, 283, 284, 285, -1, 93, 94, -1, -1, -1,
682 -1, -1, -1, -1, 258, -1, -1, -1, -1, -1,
683 264, -1, -1, -1, -1, -1, 270, 271, -1, 273,
684 -1, 313, 276, -1, -1, -1, 124, 125, -1, 283,
685 284, 285, -1, -1, -1, -1, 291, 292, 293, 294,
686 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
687 305, 306, 307, 308, -1, 310, 311, -1, -1, 313,
688 -1, -1, 291, 292, 293, 294, 295, 296, 297, 298,
689 299, 300, 301, 302, 303, 304, 305, 306, 307, 308,
690 -1, 310, 311, -1, -1, -1, -1, -1, -1, -1,
691 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
692 -1, -1, -1, -1, -1, 291, 292, 293, 294, 295,
693 296, 297, 298, 299, 300, 301, 302, 303, 304, 305,
694 306, 307, 308, -1, 310, 311, -1, -1, 38, -1,
695 -1, 41, -1, -1, 44, -1, -1, -1, -1, -1,
696 -1, -1, -1, -1, -1, -1, -1, -1, 58, 59,
697 60, 61, 62, 63, -1, -1, -1, -1, -1, -1,
698 -1, -1, -1, -1, -1, 38, -1, -1, 41, -1,
699 -1, 44, -1, -1, -1, -1, -1, -1, -1, -1,
700 -1, -1, -1, 93, 94, 58, 59, 60, 61, 62,
701 63, -1, -1, 291, 292, 293, 294, 295, 296, 297,
702 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
703 308, -1, 310, 311, 124, 125, 38, -1, -1, 41,
704 93, 94, 44, -1, -1, -1, -1, -1, -1, -1,
705 -1, -1, -1, -1, -1, -1, 58, 59, 60, 61,
706 62, 63, 38, -1, -1, 41, -1, -1, 44, -1,
707 -1, 124, 125, -1, -1, -1, -1, -1, -1, -1,
708 -1, -1, 58, 59, 60, 61, 62, 63, -1, -1,
709 38, 93, 94, 41, -1, -1, 44, -1, -1, -1,
710 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
711 58, 59, 60, 61, 62, 63, -1, 93, 94, -1,
712 -1, -1, 124, 125, -1, 258, -1, -1, -1, -1,
713 -1, 264, -1, -1, -1, -1, 38, 270, 271, 41,
714 273, -1, 44, 276, -1, 93, 94, -1, 124, 125,
715 283, 284, -1, -1, -1, -1, 58, 59, 60, 61,
716 62, 63, -1, -1, -1, -1, -1, -1, -1, -1,
717 -1, -1, -1, -1, -1, 38, 124, 125, 41, -1,
718 313, 44, -1, -1, -1, -1, -1, -1, -1, -1,
719 -1, 93, 94, -1, -1, 58, 59, 60, 61, 62,
720 63, 291, 292, 293, 294, 295, 296, 297, 298, 299,
721 300, 301, 302, 303, 304, 305, 306, 307, 308, -1,
722 310, 311, 124, 125, -1, -1, -1, -1, -1, -1,
723 93, 94, -1, -1, -1, -1, -1, -1, 291, 292,
724 293, 294, 295, 296, 297, 298, 299, 300, 301, 302,
725 303, 304, 305, 306, 307, 308, -1, 310, 311, -1,
726 -1, 124, 125, -1, -1, -1, -1, -1, -1, -1,
727 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
728 -1, -1, -1, -1, -1, -1, -1, -1, -1, 291,
729 292, 293, 294, 295, 296, 297, 298, 299, 300, 301,
730 302, 303, 304, 305, 306, 307, 308, -1, 310, 311,
731 -1, -1, -1, -1, -1, -1, -1, 293, 294, 295,
732 296, 297, 298, 299, 300, 301, 302, 303, 304, 305,
733 306, 307, 308, -1, 310, 311, -1, -1, -1, -1,
734 -1, -1, -1, -1, -1, 293, 294, 295, 296, 297,
735 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
736 308, -1, 310, 311, 38, -1, -1, 41, -1, -1,
737 44, -1, -1, -1, -1, -1, -1, -1, -1, -1,
738 -1, -1, -1, -1, 58, 59, 60, 61, 62, 63,
739 -1, 293, 294, 295, 296, 297, 298, 299, 300, 301,
740 302, 303, 304, 305, 306, 307, 308, -1, 310, 311,
741 -1, -1, -1, -1, -1, -1, -1, -1, -1, 93,
742 94, -1, -1, -1, -1, -1, -1, -1, -1, -1,
743 293, 294, 295, 296, 297, 298, 299, 300, 301, 302,
744 303, 304, 305, 306, 307, 308, 38, 310, 311, 41,
745 124, 125, 44, -1, -1, -1, -1, -1, -1, -1,
746 -1, -1, -1, -1, -1, -1, 58, 59, -1, 61,
747 38, 63, -1, 41, -1, -1, 44, -1, -1, -1,
748 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
749 58, 59, -1, 61, 38, 63, -1, 41, -1, -1,
750 44, 93, 94, -1, -1, -1, -1, -1, -1, -1,
751 -1, -1, -1, -1, 58, 59, -1, 61, 38, 63,
752 -1, 41, -1, -1, 44, 93, 94, -1, -1, -1,
753 -1, -1, 124, 125, -1, -1, -1, -1, 58, 59,
754 -1, 61, -1, 63, -1, -1, -1, -1, -1, 93,
755 94, -1, -1, -1, -1, -1, 124, 125, -1, -1,
756 -1, -1, 38, -1, -1, 41, -1, -1, 44, -1,
757 -1, -1, -1, 93, 94, -1, -1, -1, -1, -1,
758 124, 125, 58, 59, -1, 61, -1, 63, -1, 41,
759 -1, -1, 44, -1, -1, -1, -1, -1, -1, -1,
760 -1, -1, -1, -1, 124, 125, 58, 59, -1, 61,
761 -1, 63, -1, -1, -1, -1, -1, 93, 94, 293,
762 294, 295, 296, 297, 298, 299, 300, 301, 302, 303,
763 304, 305, 306, 307, 308, -1, 310, 311, -1, -1,
764 41, 93, 94, 44, -1, -1, -1, -1, 124, 125,
765 -1, -1, -1, -1, -1, -1, -1, 58, 59, -1,
766 61, -1, 63, -1, -1, 41, -1, -1, 44, -1,
767 -1, -1, 124, 125, -1, -1, -1, -1, -1, -1,
768 -1, -1, 58, 59, -1, 61, -1, 63, -1, -1,
769 -1, -1, 93, 94, -1, -1, -1, -1, -1, -1,
770 -1, -1, -1, 295, 296, 297, 298, 299, 300, 301,
771 302, 303, 304, 305, 306, 307, 308, 93, 310, 311,
772 -1, -1, -1, 124, 125, -1, -1, 295, 296, 297,
773 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
774 308, -1, 310, 311, -1, -1, -1, -1, 124, 125,
775 -1, 295, 296, 297, 298, 299, 300, 301, 302, 303,
776 304, 305, 306, 307, 308, -1, 310, 311, -1, -1,
777 -1, -1, -1, -1, -1, -1, -1, 297, 298, 299,
778 300, 301, 302, 303, 304, 305, 306, 307, 308, 41,
779 310, 311, 44, -1, -1, -1, -1, -1, -1, -1,
780 -1, -1, -1, -1, -1, -1, 58, 59, -1, 61,
781 -1, 63, -1, -1, -1, -1, -1, -1, -1, -1,
782 -1, 297, 298, 299, 300, 301, 302, 303, 304, 305,
783 306, 307, 308, -1, 310, 311, -1, -1, -1, -1,
784 -1, 93, -1, -1, -1, 297, 298, 299, 300, 301,
785 302, 303, 304, 305, 306, 307, 308, -1, 310, 311,
786 41, -1, -1, 44, -1, -1, -1, -1, -1, -1,
787 -1, -1, -1, 125, -1, -1, -1, 58, 59, -1,
788 61, -1, 63, -1, -1, -1, -1, -1, -1, -1,
789 -1, -1, -1, -1, -1, -1, 297, 298, 299, 300,
790 301, 302, 303, 304, 305, 306, 307, 308, -1, 310,
791 311, -1, 93, -1, -1, -1, -1, -1, -1, -1,
792 -1, 297, 298, 299, 300, 301, 302, 303, 304, 305,
793 306, 307, 308, 41, 310, 311, 44, -1, -1, -1,
794 -1, -1, -1, -1, 125, -1, -1, -1, -1, 41,
795 58, 59, 44, 61, -1, 63, -1, -1, -1, -1,
796 -1, -1, -1, -1, -1, -1, 58, 59, -1, 61,
797 -1, 63, -1, 41, -1, -1, 44, -1, -1, -1,
798 -1, -1, -1, -1, -1, 93, -1, -1, -1, -1,
799 58, 59, -1, 61, -1, -1, -1, -1, -1, -1,
800 -1, 93, -1, -1, -1, -1, -1, -1, -1, -1,
801 -1, -1, -1, -1, -1, -1, -1, 125, -1, -1,
802 -1, -1, -1, -1, -1, 93, -1, -1, -1, -1,
803 -1, -1, -1, 125, -1, -1, -1, -1, -1, -1,
804 -1, -1, -1, -1, -1, 297, 298, 299, 300, 301,
805 302, 303, 304, 305, 306, 307, 308, 125, 310, 311,
806 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
807 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
808 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
809 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
810 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
811 -1, -1, -1, -1, -1, -1, 297, 298, 299, 300,
812 301, 302, 303, 304, 305, 306, 307, 308, -1, 310,
813 311, -1, -1, -1, -1, -1, -1, -1, -1, -1,
814 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
815 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
816 -1, -1, -1, -1, -1, -1, -1, -1, -1, 85,
817 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
818 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
819 298, 299, 300, 301, 302, 303, 304, 305, 306, 307,
820 308, -1, 310, 311, -1, -1, 298, 299, 300, 301,
821 302, 303, 304, 305, 306, 307, 308, -1, 310, 311,
822 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
823 -1, 299, 300, 301, 302, 303, 304, 305, 306, 307,
824 308, -1, 310, 311, 160, 161, -1, -1, -1, -1,
825 -1, -1, -1, -1, -1, 171, -1, -1, -1, -1,
826 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
827 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
828 196, 197, 198, 199, 200, 201, 202, 203, 204, 205,
829 206, -1, 208, -1, 210, -1, -1, -1, -1, -1,
830 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
831 -1, -1, -1, -1, -1, -1, -1, -1, 234, -1,
832 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
833 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
834 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
835 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
836 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
837 -1, -1, -1, 289, -1, 291, 292, -1, -1, -1,
838 -1, -1, -1, -1, 300, -1, -1, 303, -1, -1,
839 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
840 -1, -1, 318, -1, -1, -1, -1, -1, -1, -1,
841 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
842 -1, -1, -1, -1, 340,
843 };
844 #define YYFINAL 1
845 #ifndef YYDEBUG
846 #define YYDEBUG 0
847 #endif
848 #define YYMAXTOKEN 320
849 #if YYDEBUG
850 char *yyname[] = {
851 "end-of-file",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
852 "'!'",0,0,0,"'%'","'&'",0,"'('","')'","'*'","'+'","','","'-'",0,"'/'",0,0,0,0,0,
853 0,0,0,0,0,"':'","';'","'<'","'='","'>'","'?'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
854 0,0,0,0,0,0,0,0,0,0,"'['",0,"']'","'^'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
855 0,0,0,0,0,0,0,0,"'{'","'|'","'}'","'~'",0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
856 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
857 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
858 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,"GOTO","MAPPING",
859 "NOMASK","BREAK","ELSE","CASE","FOR","FLOAT","STATIC","CONTINUE","RLIMITS",
860 "DEFAULT","DO","MIXED","OBJECT","RETURN","FUNCTION","OPERATOR","IF","INT",
861 "PRIVATE","CATCH","SWITCH","INHERIT","WHILE","ATOMIC","STRING","VOID","VARARGS",
862 "NIL","LARROW","RARROW","PLUS_PLUS","MIN_MIN","LSHIFT","RSHIFT","LE","GE","EQ",
863 "NE","LAND","LOR","PLUS_EQ","MIN_EQ","MULT_EQ","DIV_EQ","MOD_EQ","LSHIFT_EQ",
864 "RSHIFT_EQ","AND_EQ","XOR_EQ","OR_EQ","COLON_COLON","DOT_DOT","ELLIPSIS",
865 "STRING_CONST","IDENTIFIER","INT_CONST","FLOAT_CONST","MARK","HASH","HASH_HASH",
866 "INCL_CONST","NR_TOKENS",
867 };
868 char *yyrule[] = {
869 "$accept : program",
870 "$$1 :",
871 "program : $$1 top_level_declarations",
872 "top_level_declarations :",
873 "top_level_declarations : top_level_declarations top_level_declaration",
874 "top_level_declaration : opt_private INHERIT opt_inherit_label composite_string ';'",
875 "top_level_declaration : data_declaration",
876 "top_level_declaration : function_declaration",
877 "opt_inherit_label :",
878 "opt_inherit_label : ident",
879 "ident : IDENTIFIER",
880 "composite_string : string",
881 "composite_string : composite_string '+' string",
882 "composite_string : '(' composite_string ')'",
883 "string : STRING_CONST",
884 "data_declaration : class_specifier_list type_specifier list_dcltr ';'",
885 "$$2 :",
886 "function_declaration : class_specifier_list type_specifier function_dcltr $$2 compound_stmt",
887 "$$3 :",
888 "function_declaration : class_specifier_list ident '(' formals_declaration ')' $$3 compound_stmt",
889 "local_data_declaration : class_specifier_list type_specifier list_dcltr ';'",
890 "formals_declaration :",
891 "formals_declaration : VOID",
892 "formals_declaration : formal_declaration_list",
893 "formals_declaration : formal_declaration_list ELLIPSIS",
894 "formal_declaration_list : varargs_formal_declaration",
895 "formal_declaration_list : formal_declaration_list ',' varargs_formal_declaration",
896 "varargs_formal_declaration : VARARGS formal_declaration",
897 "varargs_formal_declaration : formal_declaration",
898 "formal_declaration : type_specifier data_dcltr",
899 "formal_declaration : ident",
900 "class_specifier_list : opt_private",
901 "class_specifier_list : non_private",
902 "class_specifier_list : class_specifier class_specifier_list2",
903 "class_specifier_list2 : class_specifier",
904 "class_specifier_list2 : class_specifier_list2 class_specifier",
905 "class_specifier : PRIVATE",
906 "class_specifier : non_private",
907 "opt_private :",
908 "opt_private : PRIVATE",
909 "non_private : STATIC",
910 "non_private : ATOMIC",
911 "non_private : NOMASK",
912 "non_private : VARARGS",
913 "type_specifier : INT",
914 "type_specifier : FLOAT",
915 "type_specifier : STRING",
916 "type_specifier : OBJECT",
917 "type_specifier : OBJECT composite_string",
918 "type_specifier : MAPPING",
919 "type_specifier : FUNCTION",
920 "type_specifier : MIXED",
921 "type_specifier : VOID",
922 "star_list :",
923 "star_list : star_list '*'",
924 "data_dcltr : star_list ident",
925 "function_dcltr : star_list ident '(' formals_declaration ')'",
926 "dcltr : data_dcltr",
927 "dcltr : function_dcltr",
928 "list_dcltr : dcltr",
929 "list_dcltr : list_dcltr ',' dcltr",
930 "dcltr_or_stmt_list :",
931 "dcltr_or_stmt_list : dcltr_or_stmt_list dcltr_or_stmt",
932 "dcltr_or_stmt : local_data_declaration",
933 "dcltr_or_stmt : stmt",
934 "dcltr_or_stmt : error ';'",
935 "$$4 :",
936 "if_stmt : IF '(' f_list_exp ')' $$4 stmt",
937 "stmt : list_exp ';'",
938 "stmt : compound_stmt",
939 "stmt : if_stmt",
940 "$$5 :",
941 "stmt : if_stmt ELSE $$5 stmt",
942 "$$6 :",
943 "stmt : DO $$6 stmt WHILE '(' f_list_exp ')' ';'",
944 "$$7 :",
945 "stmt : WHILE '(' f_list_exp ')' $$7 stmt",
946 "$$8 :",
947 "stmt : FOR '(' opt_list_exp ';' f_opt_list_exp ';' opt_list_exp ')' $$8 stmt",
948 "$$9 :",
949 "stmt : RLIMITS '(' f_list_exp ';' f_list_exp ')' $$9 compound_stmt",
950 "$$10 :",
951 "$$11 :",
952 "stmt : CATCH $$10 compound_stmt $$11 opt_caught_stmt",
953 "$$12 :",
954 "stmt : SWITCH '(' f_list_exp ')' $$12 compound_stmt",
955 "$$13 :",
956 "stmt : CASE exp ':' $$13 stmt",
957 "$$14 :",
958 "stmt : CASE exp DOT_DOT exp ':' $$14 stmt",
959 "$$15 :",
960 "stmt : DEFAULT ':' $$15 stmt",
961 "stmt : BREAK ';'",
962 "stmt : CONTINUE ';'",
963 "stmt : RETURN f_opt_list_exp ';'",
964 "stmt : ';'",
965 "$$16 :",
966 "compound_stmt : '{' $$16 dcltr_or_stmt_list '}'",
967 "opt_caught_stmt :",
968 "opt_caught_stmt : ':' stmt",
969 "function_name : ident",
970 "function_name : COLON_COLON ident",
971 "function_name : ident COLON_COLON ident",
972 "primary_p1_exp : INT_CONST",
973 "primary_p1_exp : FLOAT_CONST",
974 "primary_p1_exp : NIL",
975 "primary_p1_exp : string",
976 "primary_p1_exp : '(' '{' opt_arg_list_comma '}' ')'",
977 "primary_p1_exp : '(' '[' opt_assoc_arg_list_comma ']' ')'",
978 "primary_p1_exp : ident",
979 "primary_p1_exp : '(' list_exp ')'",
980 "primary_p1_exp : function_name '(' opt_arg_list ')'",
981 "primary_p1_exp : '&' ident '(' opt_arg_list ')'",
982 "primary_p1_exp : '&' '(' '*' cast_exp ')' '(' opt_arg_list ')'",
983 "primary_p1_exp : '(' '*' cast_exp ')' '(' opt_arg_list ')'",
984 "$$17 :",
985 "primary_p1_exp : CATCH '(' $$17 list_exp ')'",
986 "primary_p1_exp : primary_p2_exp RARROW ident '(' opt_arg_list ')'",
987 "primary_p1_exp : primary_p2_exp LARROW string",
988 "primary_p1_exp : primary_p2_exp LARROW '(' composite_string ')'",
989 "primary_p2_exp : primary_p1_exp",
990 "primary_p2_exp : primary_p2_exp '[' f_list_exp ']'",
991 "primary_p2_exp : primary_p2_exp '[' f_opt_list_exp DOT_DOT f_opt_list_exp ']'",
992 "postfix_exp : primary_p2_exp",
993 "postfix_exp : postfix_exp PLUS_PLUS",
994 "postfix_exp : postfix_exp MIN_MIN",
995 "prefix_exp : postfix_exp",
996 "prefix_exp : PLUS_PLUS cast_exp",
997 "prefix_exp : MIN_MIN cast_exp",
998 "prefix_exp : '-' cast_exp",
999 "prefix_exp : '+' cast_exp",
1000 "prefix_exp : '!' cast_exp",
1001 "prefix_exp : '~' cast_exp",
1002 "cast_exp : prefix_exp",
1003 "cast_exp : '(' type_specifier star_list ')' cast_exp",
1004 "mult_oper_exp : cast_exp",
1005 "mult_oper_exp : mult_oper_exp '*' cast_exp",
1006 "mult_oper_exp : mult_oper_exp '/' cast_exp",
1007 "mult_oper_exp : mult_oper_exp '%' cast_exp",
1008 "add_oper_exp : mult_oper_exp",
1009 "add_oper_exp : add_oper_exp '+' mult_oper_exp",
1010 "add_oper_exp : add_oper_exp '-' mult_oper_exp",
1011 "shift_oper_exp : add_oper_exp",
1012 "shift_oper_exp : shift_oper_exp LSHIFT add_oper_exp",
1013 "shift_oper_exp : shift_oper_exp RSHIFT add_oper_exp",
1014 "rel_oper_exp : shift_oper_exp",
1015 "rel_oper_exp : rel_oper_exp '<' shift_oper_exp",
1016 "rel_oper_exp : rel_oper_exp '>' shift_oper_exp",
1017 "rel_oper_exp : rel_oper_exp LE shift_oper_exp",
1018 "rel_oper_exp : rel_oper_exp GE shift_oper_exp",
1019 "equ_oper_exp : rel_oper_exp",
1020 "equ_oper_exp : equ_oper_exp EQ rel_oper_exp",
1021 "equ_oper_exp : equ_oper_exp NE rel_oper_exp",
1022 "bitand_oper_exp : equ_oper_exp",
1023 "bitand_oper_exp : bitand_oper_exp '&' equ_oper_exp",
1024 "bitxor_oper_exp : bitand_oper_exp",
1025 "bitxor_oper_exp : bitxor_oper_exp '^' bitand_oper_exp",
1026 "bitor_oper_exp : bitxor_oper_exp",
1027 "bitor_oper_exp : bitor_oper_exp '|' bitxor_oper_exp",
1028 "and_oper_exp : bitor_oper_exp",
1029 "and_oper_exp : and_oper_exp LAND bitor_oper_exp",
1030 "or_oper_exp : and_oper_exp",
1031 "or_oper_exp : or_oper_exp LOR and_oper_exp",
1032 "cond_exp : or_oper_exp",
1033 "$$18 :",
1034 "$$19 :",
1035 "cond_exp : or_oper_exp '?' $$18 list_exp ':' $$19 cond_exp",
1036 "exp : cond_exp",
1037 "exp : cond_exp '=' exp",
1038 "exp : cond_exp PLUS_EQ exp",
1039 "exp : cond_exp MIN_EQ exp",
1040 "exp : cond_exp MULT_EQ exp",
1041 "exp : cond_exp DIV_EQ exp",
1042 "exp : cond_exp MOD_EQ exp",
1043 "exp : cond_exp LSHIFT_EQ exp",
1044 "exp : cond_exp RSHIFT_EQ exp",
1045 "exp : cond_exp AND_EQ exp",
1046 "exp : cond_exp XOR_EQ exp",
1047 "exp : cond_exp OR_EQ exp",
1048 "list_exp : exp",
1049 "list_exp : list_exp ',' exp",
1050 "opt_list_exp :",
1051 "opt_list_exp : list_exp",
1052 "f_list_exp : list_exp",
1053 "f_opt_list_exp : opt_list_exp",
1054 "arg_list : exp",
1055 "arg_list : arg_list ',' exp",
1056 "opt_arg_list :",
1057 "opt_arg_list : arg_list",
1058 "opt_arg_list : arg_list ELLIPSIS",
1059 "opt_arg_list_comma :",
1060 "opt_arg_list_comma : arg_list",
1061 "opt_arg_list_comma : arg_list ','",
1062 "assoc_exp : exp ':' exp",
1063 "assoc_arg_list : assoc_exp",
1064 "assoc_arg_list : assoc_arg_list ',' assoc_exp",
1065 "opt_assoc_arg_list_comma :",
1066 "opt_assoc_arg_list_comma : assoc_arg_list",
1067 "opt_assoc_arg_list_comma : assoc_arg_list ','",
1068 };
1069 #endif
1070 #ifdef YYSTACKSIZE
1071 #undef YYMAXDEPTH
1072 #define YYMAXDEPTH YYSTACKSIZE
1073 #else
1074 #ifdef YYMAXDEPTH
1075 #define YYSTACKSIZE YYMAXDEPTH
1076 #else
1077 #define YYSTACKSIZE 10000
1078 #define YYMAXDEPTH 10000
1079 #endif
1080 #endif
1081 int yydebug;
1082 int yynerrs;
1083 int yyerrflag;
1084 int yychar;
1085 short *yyssp;
1086 YYSTYPE *yyvsp;
1087 YYSTYPE yyval;
1088 YYSTYPE yylval;
1089 short yyss[YYSTACKSIZE];
1090 #define yysslim (&yyss[YYSTACKSIZE - 1])
1091 YYSTYPE yyvs[YYSTACKSIZE];
1092 #define yystacksize YYSTACKSIZE
1093 #line 858 "parser.y"
1094
1095 /*
1096 * NAME: t_void()
1097 * DESCRIPTION: if the argument is of type void, an error will result
1098 */
t_void(node * n)1099 static void t_void(node *n)
1100 {
1101 if (n != (node *) NULL && n->mod == T_VOID) {
1102 c_error("void value not ignored");
1103 n->mod = T_MIXED;
1104 }
1105 }
1106
1107 /*
1108 * NAME: t_unary()
1109 * DESCRIPTION: typecheck the argument of a unary operator
1110 */
t_unary(node * n,char * name)1111 static bool t_unary(node *n, char *name)
1112 {
1113 char tnbuf[TNBUFSIZE];
1114
1115 t_void(n);
1116 if (typechecking && !T_ARITHMETIC(n->mod) && n->mod != T_MIXED) {
1117 c_error("bad argument type for %s (%s)", name,
1118 i_typename(tnbuf, n->mod));
1119 n->mod = T_MIXED;
1120 return FALSE;
1121 }
1122 return TRUE;
1123 }
1124
1125 /*
1126 * NAME: uassign()
1127 * DESCRIPTION: handle a unary assignment operator
1128 */
uassign(int op,node * n,char * name)1129 static node *uassign(int op, node *n, char *name)
1130 {
1131 t_unary(n, name);
1132 return node_mon((n->mod == T_INT) ? op + 1 : op, n->mod, c_lvalue(n, name));
1133 }
1134
1135 /*
1136 * NAME: cast()
1137 * DESCRIPTION: cast an expression to a type
1138 */
cast(node * n,node * type)1139 static node *cast(node *n, node *type)
1140 {
1141 xfloat flt;
1142 Int i;
1143 char *p, buffer[18];
1144
1145 if (type->mod != n->mod) {
1146 switch (type->mod) {
1147 case T_INT:
1148 switch (n->type) {
1149 case N_FLOAT:
1150 /* cast float constant to int */
1151 NFLT_GET(n, flt);
1152 return node_int(flt_ftoi(&flt));
1153
1154 case N_STR:
1155 /* cast string to int */
1156 p = n->l.string->text;
1157 i = strtoint(&p);
1158 if (p == n->l.string->text + n->l.string->len) {
1159 return node_int(i);
1160 } else {
1161 c_error("cast of invalid string constant");
1162 n->mod = T_MIXED;
1163 }
1164 break;
1165
1166 case N_TOFLOAT:
1167 case N_TOSTRING:
1168 if (n->l.left->type == N_INT) {
1169 /* (int) (float) i, (int) (string) i */
1170 return n->l.left;
1171 }
1172 /* fall through */
1173 default:
1174 if (n->mod == T_FLOAT || n->mod == T_STRING ||
1175 n->mod == T_MIXED) {
1176 return node_mon(N_TOINT, T_INT, n);
1177 }
1178 break;
1179 }
1180 break;
1181
1182 case T_FLOAT:
1183 switch (n->type) {
1184 case N_INT:
1185 /* cast int constant to float */
1186 flt_itof(n->l.number, &flt);
1187 return node_float(&flt);
1188
1189 case N_STR:
1190 /* cast string to float */
1191 p = n->l.string->text;
1192 if (flt_atof(&p, &flt) &&
1193 p == n->l.string->text + n->l.string->len) {
1194 return node_float(&flt);
1195 } else {
1196 yyerror("cast of invalid string constant");
1197 n->mod = T_MIXED;
1198 }
1199 break;
1200
1201 case N_TOSTRING:
1202 if (n->l.left->mod == T_INT) {
1203 return node_mon(N_TOFLOAT, T_FLOAT, n->l.left);
1204 }
1205 /* fall through */
1206 default:
1207 if (n->mod == T_INT || n->mod == T_STRING || n->mod == T_MIXED)
1208 {
1209 return node_mon(N_TOFLOAT, T_FLOAT, n);
1210 }
1211 break;
1212 }
1213 break;
1214
1215 case T_STRING:
1216 switch (n->type) {
1217 case N_INT:
1218 /* cast int constant to string */
1219 sprintf(buffer, "%ld", (long) n->l.number);
1220 return node_str(str_new(buffer, (long) strlen(buffer)));
1221
1222 case N_FLOAT:
1223 /* cast float constant to string */
1224 NFLT_GET(n, flt);
1225 flt_ftoa(&flt, buffer);
1226 return node_str(str_new(buffer, (long) strlen(buffer)));
1227
1228 default:
1229 if (n->mod == T_INT || n->mod == T_FLOAT || n->mod == T_MIXED) {
1230 return node_mon(N_TOSTRING, T_STRING, n);
1231 }
1232 break;
1233 }
1234 break;
1235 }
1236
1237 if (type->mod == T_MIXED || (type->mod & T_TYPE) == T_VOID) {
1238 /* (mixed), (void), (void *) */
1239 c_error("cannot cast to %s", i_typename(buffer, type->mod));
1240 n->mod = T_MIXED;
1241 } else if ((type->mod & T_REF) < (n->mod & T_REF)) {
1242 /* (mixed *) of (mixed **) */
1243 c_error("illegal cast of array type (%s)",
1244 i_typename(buffer, n->mod));
1245 } else if ((n->mod & T_TYPE) != T_MIXED &&
1246 ((type->mod & T_TYPE) != T_CLASS ||
1247 ((n->mod & T_TYPE) != T_OBJECT &&
1248 (n->mod & T_TYPE) != T_CLASS) ||
1249 (type->mod & T_REF) != (n->mod & T_REF))) {
1250 /* can only cast from mixed, or object/class to class */
1251 c_error("cast of invalid type (%s)", i_typename(buffer, n->mod));
1252 } else {
1253 if ((type->mod & T_REF) == 0 || (n->mod & T_REF) == 0) {
1254 /* runtime cast */
1255 n = node_mon(N_CAST, type->mod, n);
1256 } else {
1257 n->mod = type->mod;
1258 }
1259 n->class = type->class;
1260 }
1261 } else if (type->mod == T_CLASS && str_cmp(type->class, n->class) != 0) {
1262 /*
1263 * cast to different object class
1264 */
1265 n = node_mon(N_CAST, type->mod, n);
1266 n->class = type->class;
1267 }
1268 return n;
1269 }
1270
1271 /*
1272 * NAME: idx()
1273 * DESCRIPTION: handle the [ ] operator
1274 */
idx(node * n1,node * n2)1275 static node *idx(node *n1, node *n2)
1276 {
1277 char tnbuf[TNBUFSIZE];
1278 unsigned short type;
1279
1280 if (n1->type == N_STR && n2->type == N_INT) {
1281 /* str [ int ] */
1282 if (n2->l.number < 0 || n2->l.number >= (Int) n1->l.string->len) {
1283 c_error("string index out of range");
1284 } else {
1285 n2->l.number =
1286 UCHAR(n1->l.string->text[str_index(n1->l.string,
1287 (long) n2->l.number)]);
1288 }
1289 return n2;
1290 }
1291
1292 if ((n1->mod & T_REF) != 0) {
1293 /*
1294 * array
1295 */
1296 if (typechecking) {
1297 type = n1->mod - (1 << REFSHIFT);
1298 if (n2->mod != T_INT && n2->mod != T_MIXED) {
1299 c_error("bad index type (%s)", i_typename(tnbuf, n2->mod));
1300 }
1301 if (type != T_MIXED) {
1302 /* you can't trust these arrays */
1303 n2 = node_mon(N_CAST, type, node_bin(N_INDEX, type, n1, n2));
1304 n2->class = n1->class;
1305 return n2;
1306 }
1307 }
1308 type = T_MIXED;
1309 } else if (n1->mod == T_STRING) {
1310 /*
1311 * string
1312 */
1313 if (typechecking && n2->mod != T_INT && n2->mod != T_MIXED) {
1314 c_error("bad index type (%s)", i_typename(tnbuf, n2->mod));
1315 }
1316 type = T_INT;
1317 } else {
1318 if (typechecking && n1->mod != T_MAPPING && n1->mod != T_MIXED) {
1319 c_error("bad indexed type (%s)", i_typename(tnbuf, n1->mod));
1320 }
1321 type = T_MIXED;
1322 }
1323 return node_bin(N_INDEX, type, n1, n2);
1324 }
1325
1326 /*
1327 * NAME: range()
1328 * DESCRIPTION: handle the [ .. ] operator
1329 */
range(node * n1,node * n2,node * n3)1330 static node *range(node *n1, node *n2, node *n3)
1331 {
1332 if (n1->type == N_STR && (n2 == (node *) NULL || n2->type == N_INT) &&
1333 (n3 == (node *) NULL || n3->type == N_INT)) {
1334 Int from, to;
1335
1336 /* str [ int .. int ] */
1337 from = (n2 == (node *) NULL) ? 0 : n2->l.number;
1338 to = (n3 == (node *) NULL) ? n1->l.string->len - 1 : n3->l.number;
1339 if (from < 0 || from > to + 1 || to >= n1->l.string->len) {
1340 c_error("invalid string range");
1341 } else {
1342 return node_str(str_range(n1->l.string, (long) from, (long) to));
1343 }
1344 }
1345
1346 if (typechecking && n1->mod != T_MAPPING && n1->mod != T_MIXED) {
1347 char tnbuf[TNBUFSIZE];
1348
1349 /* indices */
1350 if (n2 != (node *) NULL && n2->mod != T_INT && n2->mod != T_MIXED) {
1351 c_error("bad index type (%s)", i_typename(tnbuf, n2->mod));
1352 }
1353 if (n3 != (node *) NULL && n3->mod != T_INT && n3->mod != T_MIXED) {
1354 c_error("bad index type (%s)", i_typename(tnbuf, n3->mod));
1355 }
1356 /* range */
1357 if ((n1->mod & T_REF) == 0 && n1->mod != T_STRING) {
1358 c_error("bad indexed type (%s)", i_typename(tnbuf, n1->mod));
1359 }
1360 }
1361
1362 return node_bin(N_RANGE, n1->mod, n1, node_bin(N_PAIR, 0, n2, n3));
1363 }
1364
1365 /*
1366 * NAME: bini()
1367 * DESCRIPTION: handle a binary int operator
1368 */
bini(int op,node * n1,node * n2,char * name)1369 static node *bini(int op, node *n1, node *n2, char *name)
1370 {
1371 char tnbuf1[TNBUFSIZE], tnbuf2[TNBUFSIZE];
1372
1373 t_void(n1);
1374 t_void(n2);
1375
1376 if (typechecking &&
1377 ((n1->mod != T_INT && n1->mod != T_MIXED) ||
1378 (n2->mod != T_INT && n2->mod != T_MIXED))) {
1379 c_error("bad argument types for %s (%s, %s)", name,
1380 i_typename(tnbuf1, n1->mod), i_typename(tnbuf2, n2->mod));
1381 }
1382 if (n1->mod == T_INT && n2->mod == T_INT) {
1383 op++;
1384 }
1385 return node_bin(op, T_INT, n1, n2);
1386 }
1387
1388
1389 /*
1390 * NAME: bina()
1391 * DESCRIPTION: handle a binary arithmetic operator
1392 */
bina(int op,node * n1,node * n2,char * name)1393 static node *bina(int op, node *n1, node *n2, char *name)
1394 {
1395 char tnbuf1[TNBUFSIZE], tnbuf2[TNBUFSIZE];
1396 unsigned short type;
1397
1398 t_void(n1);
1399 t_void(n2);
1400
1401 type = T_MIXED;
1402 if (typechecking &&
1403 ((n1->mod != n2->mod && n1->mod != T_MIXED && n2->mod != T_MIXED) ||
1404 (!T_ARITHMETIC(n1->mod) && n1->mod != T_MIXED) ||
1405 (!T_ARITHMETIC(n2->mod) && n2->mod != T_MIXED))) {
1406 c_error("bad argument types for %s (%s, %s)", name,
1407 i_typename(tnbuf1, n1->mod), i_typename(tnbuf2, n2->mod));
1408 } else if (n1->mod == T_INT || n2->mod == T_INT) {
1409 if (n1->mod == T_INT && n2->mod == T_INT) {
1410 op++;
1411 }
1412 type = T_INT;
1413 } else if (n1->mod == T_FLOAT || n2->mod == T_FLOAT) {
1414 type = T_FLOAT;
1415 switch(op) {
1416 case N_ADD:
1417 case N_ADD_EQ:
1418 case N_ADD_EQ_1:
1419 case N_DIV:
1420 case N_DIV_EQ:
1421 case N_EQ:
1422 case N_GE:
1423 case N_GT:
1424 case N_LE:
1425 case N_LT:
1426 case N_MULT:
1427 case N_MULT_EQ:
1428 case N_NE:
1429 case N_SUB_EQ_1:
1430 case N_SUB_EQ:
1431 case N_MIN_MIN:
1432 case N_PLUS_PLUS:
1433 op+=2;
1434 break;
1435 default:
1436 break;
1437 }
1438 }
1439
1440 return node_bin(op, type, n1, n2);
1441 }
1442
1443 /*
1444 * NAME: mult()
1445 * DESCRIPTION: handle the * *= operators
1446 */
mult(int op,node * n1,node * n2,char * name)1447 static node *mult(int op, node *n1, node *n2, char *name)
1448 {
1449 xfloat f1, f2;
1450
1451 if (n1->type == N_INT && n2->type == N_INT) {
1452 /* i * i */
1453 n1->l.number *= n2->l.number;
1454 return n1;
1455 }
1456 if (n1->type == N_FLOAT && n2->type == N_FLOAT) {
1457 NFLT_GET(n1, f1);
1458 NFLT_GET(n2, f2);
1459 flt_mult(&f1, &f2);
1460 NFLT_PUT(n1, f1);
1461 return n1;
1462 }
1463 return bina(op, n1, n2, name);
1464 }
1465
1466 /*
1467 * NAME: mdiv()
1468 * DESCRIPTION: handle the / /= operators
1469 */
mdiv(int op,node * n1,node * n2,char * name)1470 static node *mdiv(int op, node *n1, node *n2, char *name)
1471 {
1472 xfloat f1, f2;
1473
1474 if (n1->type == N_INT && n2->type == N_INT) {
1475 Int i, d;
1476
1477 /* i / i */
1478 i = n1->l.number;
1479 d = n2->l.number;
1480 if (d == 0) {
1481 /* i / 0 */
1482 c_error("division by zero");
1483 return n1;
1484 }
1485 if ((d | i) < 0) {
1486 Int r;
1487
1488 r = ((Uint) ((i < 0) ? -i : i)) / ((Uint) ((d < 0) ? -d : d));
1489 n1->l.number = ((i ^ d) < 0) ? -r : r;
1490 } else {
1491 n1->l.number = ((Uint) i) / ((Uint) d);
1492 }
1493 return n1;
1494 } else if (n1->type == N_FLOAT && n2->type == N_FLOAT) {
1495 /* f / f */
1496 if (NFLT_ISZERO(n2)) {
1497 /* f / 0.0 */
1498 c_error("division by zero");
1499 return n1;
1500 }
1501 NFLT_GET(n1, f1);
1502 NFLT_GET(n2, f2);
1503 flt_div(&f1, &f2);
1504 NFLT_PUT(n1, f1);
1505 return n1;
1506 }
1507
1508 return bina(op, n1, n2, name);
1509 }
1510
1511 /*
1512 * NAME: mod()
1513 * DESCRIPTION: handle the % %= operators
1514 */
mod(int op,node * n1,node * n2,char * name)1515 static node *mod(int op, node *n1, node *n2, char *name)
1516 {
1517 if (n1->type == N_INT && n2->type == N_INT) {
1518 Int i, d;
1519
1520 /* i % i */
1521 i = n1->l.number;
1522 d = n2->l.number;
1523 if (d == 0) {
1524 /* i % 0 */
1525 c_error("modulus by zero");
1526 return n1;
1527 }
1528 if (d < 0) {
1529 d = -d;
1530 }
1531 if (i < 0) {
1532 n1->l.number = - (Int) (((Uint) -i) % ((Uint) d));
1533 } else {
1534 n1->l.number = ((Uint) i) % ((Uint) d);
1535 }
1536 return n1;
1537 }
1538
1539 return bini(op, n1, n2, name);
1540 }
1541
1542 /*
1543 * NAME: add()
1544 * DESCRIPTION: handle the + += operators, possibly rearranging the order
1545 * of the expression
1546 */
add(int op,node * n1,node * n2,char * name)1547 static node *add(int op, node *n1, node *n2, char *name)
1548 {
1549 char tnbuf1[TNBUFSIZE], tnbuf2[TNBUFSIZE];
1550 xfloat f1, f2;
1551 unsigned short type;
1552
1553 t_void(n1);
1554 t_void(n2);
1555
1556 if (n1->mod == T_STRING) {
1557 if (n2->mod == T_INT || n2->mod == T_FLOAT ||
1558 (n2->mod == T_MIXED && typechecking)) {
1559 n2 = cast(n2, node_type(T_STRING, (string *) NULL));
1560 }
1561 } else if (n2->mod == T_STRING && op == N_ADD) {
1562 if (n1->mod == T_INT || n1->mod == T_FLOAT ||
1563 (n1->mod == T_MIXED && typechecking)) {
1564 n1 = cast(n1, node_type(T_STRING, (string *) NULL));
1565 }
1566 }
1567
1568 if (n1->type == N_INT && n2->type == N_INT) {
1569 /* i + i */
1570 n1->l.number += n2->l.number;
1571 return n1;
1572 }
1573 if (n1->type == N_FLOAT && n2->type == N_FLOAT) {
1574 /* f + f */
1575 NFLT_GET(n1, f1);
1576 NFLT_GET(n2, f2);
1577 flt_add(&f1, &f2);
1578 NFLT_PUT(n1, f1);
1579 return n1;
1580 }
1581 if (n1->type == N_STR && n2->type == N_STR) {
1582 /* s + s */
1583 return node_str(str_add(n1->l.string, n2->l.string));
1584 }
1585
1586 type = c_tmatch(n1->mod, n2->mod);
1587 if (type == T_NIL || type == T_OBJECT || type == T_CLASS) {
1588 type = T_MIXED;
1589 if (typechecking) {
1590 c_error("bad argument types for %s (%s, %s)", name,
1591 i_typename(tnbuf1, n1->mod), i_typename(tnbuf2, n2->mod));
1592 }
1593 } else if (type == T_INT) {
1594 op++;
1595 } else if (op == N_ADD_EQ) {
1596 if (n1->mod == T_INT) {
1597 n2 = node_mon(N_CAST, T_INT, n2);
1598 type = T_INT;
1599 op++;
1600 } else if (n1->mod == T_FLOAT && n2->mod != T_FLOAT) {
1601 n2 = node_mon(N_CAST, T_FLOAT, n2);
1602 type = T_FLOAT;
1603 }
1604 }
1605 return node_bin(op, type, n1, n2);
1606 }
1607
1608 /*
1609 * NAME: sub()
1610 * DESCRIPTION: handle the - -= operators
1611 */
sub(int op,node * n1,node * n2,char * name)1612 static node *sub(int op, node *n1, node *n2, char *name)
1613 {
1614 char tnbuf1[TNBUFSIZE], tnbuf2[TNBUFSIZE];
1615 xfloat f1, f2;
1616 unsigned short type;
1617
1618 t_void(n1);
1619 t_void(n2);
1620
1621 if (n1->type == N_INT && n2->type == N_INT) {
1622 /* i - i */
1623 n1->l.number -= n2->l.number;
1624 return n1;
1625 }
1626 if (n1->type == N_FLOAT && n2->type == N_FLOAT) {
1627 /* f - f */
1628 NFLT_GET(n1, f1);
1629 NFLT_GET(n2, f2);
1630 flt_sub(&f1, &f2);
1631 NFLT_PUT(n1, f1);
1632 return n1;
1633 }
1634
1635 type = c_tmatch(n1->mod, n2->mod);
1636 if (type == T_NIL || type == T_STRING || type == T_OBJECT ||
1637 type == T_CLASS || type == T_MAPPING) {
1638 if ((type=n1->mod) != T_MAPPING ||
1639 (n2->mod != T_MIXED && (n2->mod & T_REF) == 0)) {
1640 type = T_MIXED;
1641 if (typechecking) {
1642 c_error("bad argument types for %s (%s, %s)", name,
1643 i_typename(tnbuf1, n1->mod),
1644 i_typename(tnbuf2, n2->mod));
1645 }
1646 }
1647 } else if (type == T_INT) {
1648 op++;
1649 } else if (type == T_MIXED) {
1650 type = (n1->mod == T_MIXED) ? n2->mod : n1->mod;
1651 } else if (n1->mod == T_MIXED && (n2->mod & T_REF)) {
1652 type = T_MIXED;
1653 }
1654 return node_bin(op, type, n1, n2);
1655 }
1656
1657 /*
1658 * NAME: umin()
1659 * DESCRIPTION: handle unary minus
1660 */
umin(node * n)1661 static node *umin(node *n)
1662 {
1663 xfloat flt;
1664
1665 if (t_unary(n, "unary -")) {
1666 if (n->mod == T_FLOAT) {
1667 FLT_ZERO(flt.high, flt.low);
1668 n = sub(N_SUB, node_float(&flt), n, "-");
1669 } else {
1670 n = sub(N_SUB, node_int((Int) 0), n, "-");
1671 }
1672 }
1673 return n;
1674 }
1675
1676 /*
1677 * NAME: lshift()
1678 * DESCRIPTION: handle the << <<= operators
1679 */
lshift(int op,node * n1,node * n2,char * name)1680 static node *lshift(int op, node *n1, node *n2, char *name)
1681 {
1682 if (n2->type == N_INT) {
1683 if (n2->l.number < 0) {
1684 c_error("negative left shift");
1685 n2->l.number = 0;
1686 }
1687 if (n1->type == N_INT) {
1688 /* i << i */
1689 n1->l.number = (n2->l.number < 32) ?
1690 (Uint) n1->l.number << n2->l.number : 0;
1691 return n1;
1692 }
1693 }
1694
1695 return bini(op, n1, n2, name);
1696 }
1697
1698 /*
1699 * NAME: rshift()
1700 * DESCRIPTION: handle the >> >>= operators
1701 */
rshift(int op,node * n1,node * n2,char * name)1702 static node *rshift(int op, node *n1, node *n2, char *name)
1703 {
1704 if (n2->type == N_INT) {
1705 if (n2->l.number < 0) {
1706 c_error("negative right shift");
1707 n2->l.number = 0;
1708 }
1709 if (n1->type == N_INT) {
1710 /* i >> i */
1711 n1->l.number = (n2->l.number < 32) ?
1712 (Uint) n1->l.number >> n2->l.number : 0;
1713 return n1;
1714 }
1715 }
1716
1717 return bini(op, n1, n2, name);
1718 }
1719
1720 /*
1721 * NAME: rel()
1722 * DESCRIPTION: handle the < > <= >= operators
1723 */
rel(int op,node * n1,node * n2,char * name)1724 static node *rel(int op, node *n1, node *n2, char *name)
1725 {
1726 char tnbuf1[TNBUFSIZE], tnbuf2[TNBUFSIZE];
1727
1728 t_void(n1);
1729 t_void(n2);
1730
1731 if (n1->type == N_INT && n2->type == N_INT) {
1732 /* i . i */
1733 switch (op) {
1734 case N_GE:
1735 n1->l.number = (n1->l.number >= n2->l.number);
1736 break;
1737
1738 case N_GT:
1739 n1->l.number = (n1->l.number > n2->l.number);
1740 break;
1741
1742 case N_LE:
1743 n1->l.number = (n1->l.number <= n2->l.number);
1744 break;
1745
1746 case N_LT:
1747 n1->l.number = (n1->l.number < n2->l.number);
1748 break;
1749 }
1750 return n1;
1751 }
1752 if (n1->type == N_FLOAT && n2->type == N_FLOAT) {
1753 xfloat f1, f2;
1754
1755 /* f . f */
1756 NFLT_GET(n1, f1);
1757 NFLT_GET(n2, f2);
1758
1759 switch (op) {
1760 case N_GE:
1761 return node_int((Int) (flt_cmp(&f1, &f2) >= 0));
1762
1763 case N_GT:
1764 return node_int((Int) (flt_cmp(&f1, &f2) > 0));
1765
1766 case N_LE:
1767 return node_int((Int) (flt_cmp(&f1, &f2) <= 0));
1768
1769 case N_LT:
1770 return node_int((Int) (flt_cmp(&f1, &f2) < 0));
1771 }
1772 return n1;
1773 }
1774 if (n1->type == N_STR && n2->type == N_STR) {
1775 /* s . s */
1776 switch (op) {
1777 case N_GE:
1778 return node_int((Int) (str_cmp(n1->l.string, n2->l.string) >= 0));
1779
1780 case N_GT:
1781 return node_int((Int) (str_cmp(n1->l.string, n2->l.string) > 0));
1782
1783 case N_LE:
1784 return node_int((Int) (str_cmp(n1->l.string, n2->l.string) <= 0));
1785
1786 case N_LT:
1787 return node_int((Int) (str_cmp(n1->l.string, n2->l.string) < 0));
1788 }
1789 }
1790
1791 if (typechecking &&
1792 ((n1->mod != n2->mod && n1->mod != T_MIXED && n2->mod != T_MIXED) ||
1793 (!T_ARITHSTR(n1->mod) && n1->mod != T_MIXED) ||
1794 (!T_ARITHSTR(n2->mod) && n2->mod != T_MIXED))) {
1795 c_error("bad argument types for %s (%s, %s)", name,
1796 i_typename(tnbuf1, n1->mod), i_typename(tnbuf2, n2->mod));
1797 } else if (n1->mod == T_INT && n2->mod == T_INT) {
1798 op++;
1799 }
1800 return node_bin(op, T_INT, n1, n2);
1801 }
1802
1803 /*
1804 * NAME: eq()
1805 * DESCRIPTION: handle the == operator
1806 */
eq(node * n1,node * n2)1807 static node *eq(node *n1, node *n2)
1808 {
1809 char tnbuf1[TNBUFSIZE], tnbuf2[TNBUFSIZE];
1810 xfloat f1, f2;
1811 int op;
1812
1813 t_void(n1);
1814 t_void(n2);
1815
1816 switch (n1->type) {
1817 case N_INT:
1818 if (n2->type == N_INT) {
1819 /* i == i */
1820 n1->l.number = (n1->l.number == n2->l.number);
1821 return n1;
1822 }
1823 if (nil_node == N_INT && n1->l.number == 0 && n2->type == N_STR) {
1824 /* nil == str */
1825 return node_int((Int) FALSE);
1826 }
1827 break;
1828
1829 case N_FLOAT:
1830 if (n2->type == N_FLOAT) {
1831 /* f == f */
1832 NFLT_GET(n1, f1);
1833 NFLT_GET(n2, f2);
1834 return node_int((Int) (flt_cmp(&f1, &f2) == 0));
1835 }
1836 break;
1837
1838 case N_STR:
1839 if (n2->type == N_STR) {
1840 /* s == s */
1841 return node_int((Int) (str_cmp(n1->l.string, n2->l.string) == 0));
1842 }
1843 if (n2->type == nil_node && n2->l.number == 0) {
1844 /* s == nil */
1845 return node_int((Int) FALSE);
1846 }
1847 break;
1848
1849 case N_NIL:
1850 if (n2->type == N_NIL) {
1851 /* nil == nil */
1852 return node_int((Int) TRUE);
1853 }
1854 if (n2->type == N_STR) {
1855 /* nil == str */
1856 return node_int((Int) FALSE);
1857 }
1858 break;
1859 }
1860
1861 op = N_EQ;
1862 if (c_tmatch(n1->mod, n2->mod) == T_NIL &&
1863 (!c_nil(n1) || !T_POINTER(n2->mod)) &&
1864 (!c_nil(n2) || !T_POINTER(n1->mod))) {
1865 if (typechecking) {
1866 c_error("incompatible types for equality (%s, %s)",
1867 i_typename(tnbuf1, n1->mod), i_typename(tnbuf2, n2->mod));
1868 }
1869 } else if (n1->mod == T_INT && n2->mod == T_INT) {
1870 op++;
1871 }
1872 return node_bin(op, T_INT, n1, n2);
1873 }
1874
1875 /*
1876 * NAME: and()
1877 * DESCRIPTION: handle the & &= operators
1878 */
and(int op,node * n1,node * n2,char * name)1879 static node *and(int op, node *n1, node *n2, char *name)
1880 {
1881 unsigned short type;
1882
1883 if (n1->type == N_INT && n2->type == N_INT) {
1884 /* i & i */
1885 n1->l.number &= n2->l.number;
1886 return n1;
1887 }
1888 if ((((type=n1->mod) == T_MIXED || type == T_MAPPING) &&
1889 ((n2->mod & T_REF) != 0 || n2->mod == T_MIXED)) ||
1890 ((type=c_tmatch(n1->mod, n2->mod)) & T_REF) != T_NIL) {
1891 /*
1892 * possibly array & array or mapping & array
1893 */
1894 return node_bin(op, type, n1, n2);
1895 }
1896 return bini(op, n1, n2, name);
1897 }
1898
1899 /*
1900 * NAME: xor()
1901 * DESCRIPTION: handle the ^ ^= operators
1902 */
xor(int op,node * n1,node * n2,char * name)1903 static node *xor(int op, node *n1, node *n2, char *name)
1904 {
1905 unsigned short type;
1906
1907 if (n1->type == N_INT && n2->type == N_INT) {
1908 /* i ^ i */
1909 n1->l.number ^= n2->l.number;
1910 return n1;
1911 }
1912 if (((type=n1->mod) == T_MIXED && n2->mod == T_MIXED) ||
1913 ((type=c_tmatch(n1->mod, n2->mod)) & T_REF) != T_NIL) {
1914 /*
1915 * possibly array ^ array
1916 */
1917 return node_bin(op, type, n1, n2);
1918 }
1919 return bini(op, n1, n2, name);
1920 }
1921
1922 /*
1923 * NAME: or()
1924 * DESCRIPTION: handle the | |= operators
1925 */
or(int op,node * n1,node * n2,char * name)1926 static node *or(int op, node *n1, node *n2, char *name)
1927 {
1928 unsigned short type;
1929
1930 if (n1->type == N_INT && n2->type == N_INT) {
1931 /* i | i */
1932 n1->l.number |= n2->l.number;
1933 return n1;
1934 }
1935 if (((type=n1->mod) == T_MIXED && n2->mod == T_MIXED) ||
1936 ((type=c_tmatch(n1->mod, n2->mod)) & T_REF) != T_NIL) {
1937 /*
1938 * possibly array | array
1939 */
1940 return node_bin(op, type, n1, n2);
1941 }
1942 return bini(op, n1, n2, name);
1943 }
1944
1945 /*
1946 * NAME: land()
1947 * DESCRIPTION: handle the && operator
1948 */
land(node * n1,node * n2)1949 static node *land(node *n1, node *n2)
1950 {
1951 t_void(n1);
1952 t_void(n2);
1953
1954 if ((n1->flags & F_CONST) && (n2->flags & F_CONST)) {
1955 n1 = c_tst(n1);
1956 n2 = c_tst(n2);
1957 n1->l.number &= n2->l.number;
1958 return n1;
1959 }
1960
1961 return node_bin(N_LAND, T_INT, n1, n2);
1962 }
1963
1964 /*
1965 * NAME: lor()
1966 * DESCRIPTION: handle the || operator
1967 */
lor(node * n1,node * n2)1968 static node *lor(node *n1, node *n2)
1969 {
1970 t_void(n1);
1971 t_void(n2);
1972
1973 if ((n1->flags & F_CONST) && (n2->flags & F_CONST)) {
1974 n1 = c_tst(n1);
1975 n2 = c_tst(n2);
1976 n1->l.number |= n2->l.number;
1977 return n1;
1978 }
1979
1980 return node_bin(N_LOR, T_INT, n1, n2);
1981 }
1982
1983 /*
1984 * NAME: quest()
1985 * DESCRIPTION: handle the ? : operator
1986 */
quest(node * n1,node * n2,node * n3)1987 static node *quest(node *n1, node *n2, node *n3)
1988 {
1989 unsigned short type;
1990
1991 t_void(n1);
1992
1993 if ((n2->flags & F_CONST) && n3->type == n2->type) {
1994 switch (n1->type) {
1995 case N_INT:
1996 return (n1->l.number == 0) ? n3 : n2;
1997
1998 case N_FLOAT:
1999 return (NFLT_ISZERO(n1)) ? n3 : n2;
2000
2001 case N_STR:
2002 return n2;
2003
2004 case N_NIL:
2005 return n3;
2006 }
2007 }
2008
2009 type = T_MIXED;
2010 if (c_nil(n2) && T_POINTER(n3->mod)) {
2011 /*
2012 * expr ? nil : expr
2013 */
2014 type = n3->mod;
2015 } else if (c_nil(n3) && T_POINTER(n2->mod)) {
2016 /*
2017 * expr ? expr : nil;
2018 */
2019 type = n2->mod;
2020 } else if (typechecking) {
2021 /*
2022 * typechecked
2023 */
2024 if (n2->mod == T_VOID || n3->mod == T_VOID) {
2025 /* result can never be used */
2026 type = T_VOID;
2027 } else {
2028 type = c_tmatch(n2->mod, n3->mod);
2029 if (type == T_NIL) {
2030 /* no typechecking here, just let the result be mixed */
2031 type = T_MIXED;
2032 }
2033 }
2034 }
2035
2036 n1 = node_bin(N_QUEST, type, n1, node_bin(N_PAIR, 0, n2, n3));
2037 if ((type & T_TYPE) == T_CLASS) {
2038 if (n2->class == (string *) NULL) {
2039 n1->class = n3->class;
2040 } else if (n3->class == (string *) NULL ||
2041 str_cmp(n2->class, n3->class) == 0) {
2042 n1->class = n2->class;
2043 } else {
2044 /* downgrade to object */
2045 n1->type = (n1->type & T_REF) | T_OBJECT;
2046 }
2047 }
2048 return n1;
2049 }
2050
2051 /*
2052 * NAME: assign()
2053 * DESCRIPTION: handle the assignment operator
2054 */
assign(node * n1,node * n2)2055 static node *assign(node *n1, node *n2)
2056 {
2057 char tnbuf1[TNBUFSIZE], tnbuf2[TNBUFSIZE];
2058 node *n, *m;
2059 unsigned short type;
2060
2061 if (n1->type == N_AGGR) {
2062 /*
2063 * ({ a, b }) = array;
2064 */
2065 if (typechecking) {
2066 type = n2->mod;
2067 if ((n2->mod & T_REF) != 0) {
2068 type -= 1 << REFSHIFT;
2069 if (type != T_MIXED) {
2070 n = node_mon(N_TYPE, type, (node *) NULL);
2071 n->class = n2->class;
2072 n1->r.right = n;
2073 }
2074 } else if (type != T_MIXED) {
2075 c_error("incompatible types for = (%s, %s)",
2076 i_typename(tnbuf1, n1->mod),
2077 i_typename(tnbuf2, type));
2078 type = T_MIXED;
2079 }
2080
2081 n = n1->l.left;
2082 while (n != (node *) NULL) {
2083 if (n->type == N_PAIR) {
2084 m = n->l.left;
2085 n = n->r.right;
2086 } else {
2087 m = n;
2088 n = (node *) NULL;
2089 }
2090 if (c_tmatch(m->mod, type) == T_NIL) {
2091 c_error("incompatible types for = (%s, %s)",
2092 i_typename(tnbuf1, m->mod),
2093 i_typename(tnbuf2, type));
2094 }
2095 }
2096 }
2097 n1 = node_bin(N_ASSIGN, n2->mod, n1, n2);
2098 n1->class = n2->class;
2099 return n1;
2100 } else {
2101 if (typechecking && (!c_nil(n2) || !T_POINTER(n1->mod))) {
2102 /*
2103 * typechecked
2104 */
2105 if (c_tmatch(n1->mod, n2->mod) == T_NIL) {
2106 c_error("incompatible types for = (%s, %s)",
2107 i_typename(tnbuf1, n1->mod),
2108 i_typename(tnbuf2, n2->mod));
2109 } else if ((n1->mod != T_MIXED && n2->mod == T_MIXED) ||
2110 (n1->mod == T_CLASS &&
2111 (n2->mod != T_CLASS ||
2112 str_cmp(n1->class, n2->class) != 0))) {
2113 n2 = node_mon(N_CAST, n1->mod, n2);
2114 n2->class = n1->class;
2115 }
2116 }
2117
2118 n2 = node_bin(N_ASSIGN, n1->mod, n1, n2);
2119 n2->class = n1->class;
2120 return n2;
2121 }
2122 }
2123
2124 /*
2125 * NAME: comma()
2126 * DESCRIPTION: handle the comma operator, rearranging the order of the
2127 * expression if needed
2128 */
comma(node * n1,node * n2)2129 static node *comma(node *n1, node *n2)
2130 {
2131 if (n2->type == N_COMMA) {
2132 /* a, (b, c) --> (a, b), c */
2133 n2->l.left = comma(n1, n2->l.left);
2134 return n2;
2135 } else {
2136 n1 = node_bin(N_COMMA, n2->mod, n1, n2);
2137 n1->class = n2->class;
2138 return n1;
2139 }
2140 }
2141 #line 2142 "y.tab.c"
2142 #define YYABORT goto yyabort
2143 #define YYREJECT goto yyabort
2144 #define YYACCEPT goto yyaccept
2145 #define YYERROR goto yyerrlab
2146 int
yyparse()2147 yyparse()
2148 {
2149 register int yym, yyn, yystate;
2150 #if YYDEBUG
2151 register char *yys;
2152
2153 if (yys = getenv("YYDEBUG"))
2154 {
2155 yyn = *yys;
2156 if (yyn >= '0' && yyn <= '9')
2157 yydebug = yyn - '0';
2158 }
2159 #endif
2160
2161 yynerrs = 0;
2162 yyerrflag = 0;
2163 yychar = (-1);
2164
2165 yyssp = yyss;
2166 yyvsp = yyvs;
2167 *yyssp = yystate = 0;
2168
2169 yyloop:
2170 if ((yyn = yydefred[yystate]) != 0) goto yyreduce;
2171 if (yychar < 0)
2172 {
2173 if ((yychar = yylex()) < 0) yychar = 0;
2174 #if YYDEBUG
2175 if (yydebug)
2176 {
2177 yys = 0;
2178 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
2179 if (!yys) yys = "illegal-symbol";
2180 printf("%sdebug: state %d, reading %d (%s)\n",
2181 YYPREFIX, yystate, yychar, yys);
2182 }
2183 #endif
2184 }
2185 if ((yyn = yysindex[yystate]) && (yyn += yychar) >= 0 &&
2186 yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
2187 {
2188 #if YYDEBUG
2189 if (yydebug)
2190 printf("%sdebug: state %d, shifting to state %d\n",
2191 YYPREFIX, yystate, yytable[yyn]);
2192 #endif
2193 if (yyssp >= yysslim)
2194 {
2195 goto yyoverflow;
2196 }
2197 *++yyssp = yystate = yytable[yyn];
2198 *++yyvsp = yylval;
2199 yychar = (-1);
2200 if (yyerrflag > 0) --yyerrflag;
2201 goto yyloop;
2202 }
2203 if ((yyn = yyrindex[yystate]) && (yyn += yychar) >= 0 &&
2204 yyn <= YYTABLESIZE && yycheck[yyn] == yychar)
2205 {
2206 yyn = yytable[yyn];
2207 goto yyreduce;
2208 }
2209 if (yyerrflag) goto yyinrecovery;
2210 #ifdef lint
2211 goto yynewerror;
2212 #endif
2213 yynewerror:
2214 yyerror("syntax error");
2215 #ifdef lint
2216 goto yyerrlab;
2217 #endif
2218 yyerrlab:
2219 ++yynerrs;
2220 yyinrecovery:
2221 if (yyerrflag < 3)
2222 {
2223 yyerrflag = 3;
2224 for (;;)
2225 {
2226 if ((yyn = yysindex[*yyssp]) && (yyn += YYERRCODE) >= 0 &&
2227 yyn <= YYTABLESIZE && yycheck[yyn] == YYERRCODE)
2228 {
2229 #if YYDEBUG
2230 if (yydebug)
2231 printf("%sdebug: state %d, error recovery shifting\
2232 to state %d\n", YYPREFIX, *yyssp, yytable[yyn]);
2233 #endif
2234 if (yyssp >= yysslim)
2235 {
2236 goto yyoverflow;
2237 }
2238 *++yyssp = yystate = yytable[yyn];
2239 *++yyvsp = yylval;
2240 goto yyloop;
2241 }
2242 else
2243 {
2244 #if YYDEBUG
2245 if (yydebug)
2246 printf("%sdebug: error recovery discarding state %d\n",
2247 YYPREFIX, *yyssp);
2248 #endif
2249 if (yyssp <= yyss) goto yyabort;
2250 --yyssp;
2251 --yyvsp;
2252 }
2253 }
2254 }
2255 else
2256 {
2257 if (yychar == 0) goto yyabort;
2258 #if YYDEBUG
2259 if (yydebug)
2260 {
2261 yys = 0;
2262 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
2263 if (!yys) yys = "illegal-symbol";
2264 printf("%sdebug: state %d, error recovery discards token %d (%s)\n",
2265 YYPREFIX, yystate, yychar, yys);
2266 }
2267 #endif
2268 yychar = (-1);
2269 goto yyloop;
2270 }
2271 yyreduce:
2272 #if YYDEBUG
2273 if (yydebug)
2274 printf("%sdebug: state %d, reducing by rule %d (%s)\n",
2275 YYPREFIX, yystate, yyn, yyrule[yyn]);
2276 #endif
2277 yym = yylen[yyn];
2278 yyval = yyvsp[1-yym];
2279 switch (yyn)
2280 {
2281 case 1:
2282 #line 131 "parser.y"
2283 {
2284 nerrors = 0;
2285 ndeclarations = 0;
2286 }
2287 break;
2288 case 2:
2289 #line 136 "parser.y"
2290 {
2291 if (nerrors > 0) {
2292 YYABORT;
2293 }
2294 }
2295 break;
2296 case 4:
2297 #line 146 "parser.y"
2298 {
2299 if (nerrors > 0) {
2300 YYABORT;
2301 }
2302 }
2303 break;
2304 case 5:
2305 #line 155 "parser.y"
2306 {
2307 if (ndeclarations > 0) {
2308 c_error("inherit must precede all declarations");
2309 } else if (nerrors > 0 ||
2310 !c_inherit(yyvsp[-1].node->l.string->text, yyvsp[-2].node, yyvsp[-4].type != 0)) {
2311 /*
2312 * The object to be inherited may have been compiled;
2313 * abort this compilation and possibly restart later.
2314 */
2315 YYABORT;
2316 }
2317 }
2318 break;
2319 case 6:
2320 #line 168 "parser.y"
2321 { ndeclarations++; }
2322 break;
2323 case 7:
2324 #line 170 "parser.y"
2325 { ndeclarations++; }
2326 break;
2327 case 8:
2328 #line 175 "parser.y"
2329 { yyval.node = (node *) NULL; }
2330 break;
2331 case 10:
2332 #line 181 "parser.y"
2333 { yyval.node = node_str(str_new(yytext, (long) yyleng)); }
2334 break;
2335 case 12:
2336 #line 187 "parser.y"
2337 { yyval.node = node_str(str_add(yyvsp[-2].node->l.string, yyvsp[0].node->l.string)); }
2338 break;
2339 case 13:
2340 #line 189 "parser.y"
2341 { yyval.node = yyvsp[-1].node; }
2342 break;
2343 case 14:
2344 #line 194 "parser.y"
2345 { yyval.node = node_str(str_new(yytext, (long) yyleng)); }
2346 break;
2347 case 15:
2348 #line 199 "parser.y"
2349 { c_global(yyvsp[-3].type, yyvsp[-2].node, yyvsp[-1].node); }
2350 break;
2351 case 16:
2352 #line 204 "parser.y"
2353 {
2354 typechecking = TRUE;
2355 c_function(yyvsp[-2].type, yyvsp[-1].node, yyvsp[0].node);
2356 }
2357 break;
2358 case 17:
2359 #line 209 "parser.y"
2360 {
2361 if (nerrors == 0) {
2362 c_funcbody(yyvsp[0].node);
2363 }
2364 }
2365 break;
2366 case 18:
2367 #line 215 "parser.y"
2368 {
2369 typechecking = c_typechecking();
2370 c_function(yyvsp[-4].type, node_type((typechecking) ? T_VOID : T_NIL,
2371 (string *) NULL),
2372 node_bin(N_FUNC, 0, yyvsp[-3].node, yyvsp[-1].node));
2373 }
2374 break;
2375 case 19:
2376 #line 222 "parser.y"
2377 {
2378 if (nerrors == 0) {
2379 c_funcbody(yyvsp[0].node);
2380 }
2381 }
2382 break;
2383 case 20:
2384 #line 231 "parser.y"
2385 { c_local(yyvsp[-3].type, yyvsp[-2].node, yyvsp[-1].node); }
2386 break;
2387 case 21:
2388 #line 236 "parser.y"
2389 { yyval.node = (node *) NULL; }
2390 break;
2391 case 22:
2392 #line 237 "parser.y"
2393 { yyval.node = (node *) NULL; }
2394 break;
2395 case 24:
2396 #line 240 "parser.y"
2397 {
2398 yyval.node = yyvsp[-1].node;
2399 yyval.node->flags |= F_ELLIPSIS;
2400 }
2401 break;
2402 case 26:
2403 #line 249 "parser.y"
2404 { yyval.node = node_bin(N_PAIR, 0, yyvsp[-2].node, yyvsp[0].node); }
2405 break;
2406 case 27:
2407 #line 254 "parser.y"
2408 {
2409 yyval.node = yyvsp[0].node;
2410 yyval.node->flags |= F_VARARGS;
2411 }
2412 break;
2413 case 29:
2414 #line 263 "parser.y"
2415 {
2416 yyval.node = yyvsp[0].node;
2417 yyval.node->mod |= yyvsp[-1].node->mod;
2418 yyval.node->class = yyvsp[-1].node->class;
2419 }
2420 break;
2421 case 30:
2422 #line 268 "parser.y"
2423 {
2424 yyval.node = yyvsp[0].node;
2425 yyval.node->mod = T_NIL; /* only if typechecking, though */
2426 }
2427 break;
2428 case 33:
2429 #line 278 "parser.y"
2430 { yyval.type = yyvsp[-1].type | yyvsp[0].type; }
2431 break;
2432 case 35:
2433 #line 284 "parser.y"
2434 { yyval.type = yyvsp[-1].type | yyvsp[0].type; }
2435 break;
2436 case 36:
2437 #line 289 "parser.y"
2438 { yyval.type = C_STATIC | C_PRIVATE; }
2439 break;
2440 case 38:
2441 #line 295 "parser.y"
2442 { yyval.type = 0; }
2443 break;
2444 case 39:
2445 #line 297 "parser.y"
2446 { yyval.type = C_STATIC | C_PRIVATE; }
2447 break;
2448 case 40:
2449 #line 302 "parser.y"
2450 { yyval.type = C_STATIC; }
2451 break;
2452 case 41:
2453 #line 304 "parser.y"
2454 { yyval.type = C_ATOMIC; }
2455 break;
2456 case 42:
2457 #line 306 "parser.y"
2458 { yyval.type = C_NOMASK; }
2459 break;
2460 case 43:
2461 #line 308 "parser.y"
2462 { yyval.type = C_VARARGS; }
2463 break;
2464 case 44:
2465 #line 312 "parser.y"
2466 { yyval.node = node_type(T_INT, (string *) NULL); }
2467 break;
2468 case 45:
2469 #line 313 "parser.y"
2470 { yyval.node = node_type(T_FLOAT, (string *) NULL); }
2471 break;
2472 case 46:
2473 #line 315 "parser.y"
2474 { yyval.node = node_type(T_STRING, (string *) NULL); }
2475 break;
2476 case 47:
2477 #line 317 "parser.y"
2478 { yyval.node = node_type(T_OBJECT, (string *) NULL); }
2479 break;
2480 case 48:
2481 #line 319 "parser.y"
2482 { yyval.node = node_type(T_CLASS, c_objecttype(yyvsp[0].node)); }
2483 break;
2484 case 49:
2485 #line 321 "parser.y"
2486 { yyval.node = node_type(T_MAPPING, (string *) NULL); }
2487 break;
2488 case 50:
2489 #line 323 "parser.y"
2490 {
2491 yyval.node = node_str(str_new("/" BIPREFIX "function",
2492 BIPREFIXLEN + 9));
2493 yyval.node = node_type(T_CLASS, c_objecttype(yyval.node));
2494 }
2495 break;
2496 case 51:
2497 #line 328 "parser.y"
2498 { yyval.node = node_type(T_MIXED, (string *) NULL); }
2499 break;
2500 case 52:
2501 #line 329 "parser.y"
2502 { yyval.node = node_type(T_VOID, (string *) NULL); }
2503 break;
2504 case 53:
2505 #line 334 "parser.y"
2506 { yyval.type = 0; }
2507 break;
2508 case 54:
2509 #line 336 "parser.y"
2510 {
2511 yyval.type = yyvsp[-1].type + 1;
2512 if (yyval.type == 1 << (8 - REFSHIFT)) {
2513 c_error("too deep indirection");
2514 }
2515 }
2516 break;
2517 case 55:
2518 #line 346 "parser.y"
2519 {
2520 yyval.node = yyvsp[0].node;
2521 yyval.node->mod = (yyvsp[-1].type << REFSHIFT) & T_REF;
2522 }
2523 break;
2524 case 56:
2525 #line 354 "parser.y"
2526 { yyval.node = node_bin(N_FUNC, (yyvsp[-4].type << REFSHIFT) & T_REF, yyvsp[-3].node, yyvsp[-1].node); }
2527 break;
2528 case 60:
2529 #line 365 "parser.y"
2530 { yyval.node = node_bin(N_PAIR, 0, yyvsp[-2].node, yyvsp[0].node); }
2531 break;
2532 case 61:
2533 #line 370 "parser.y"
2534 { yyval.node = (node *) NULL; }
2535 break;
2536 case 62:
2537 #line 372 "parser.y"
2538 { yyval.node = c_concat(yyvsp[-1].node, yyvsp[0].node); }
2539 break;
2540 case 63:
2541 #line 377 "parser.y"
2542 {
2543 if (nstatements > 0) {
2544 c_error("declaration after statement");
2545 }
2546 yyval.node = (node *) NULL;
2547 }
2548 break;
2549 case 64:
2550 #line 383 "parser.y"
2551 {
2552 nstatements++;
2553 yyval.node = yyvsp[0].node;
2554 }
2555 break;
2556 case 65:
2557 #line 388 "parser.y"
2558 {
2559 if (nerrors >= MAX_ERRORS) {
2560 YYABORT;
2561 }
2562 yyval.node = (node *) NULL;
2563 }
2564 break;
2565 case 66:
2566 #line 398 "parser.y"
2567 { c_startcond(); }
2568 break;
2569 case 67:
2570 #line 399 "parser.y"
2571 { yyval.node = c_if(yyvsp[-3].node, yyvsp[0].node); }
2572 break;
2573 case 68:
2574 #line 404 "parser.y"
2575 { yyval.node = c_exp_stmt(yyvsp[-1].node); }
2576 break;
2577 case 70:
2578 #line 407 "parser.y"
2579 {
2580 c_endcond();
2581 yyval.node = c_endif(yyvsp[0].node, (node *) NULL);
2582 }
2583 break;
2584 case 71:
2585 #line 413 "parser.y"
2586 { c_startcond2(); }
2587 break;
2588 case 72:
2589 #line 415 "parser.y"
2590 {
2591 c_matchcond();
2592 yyval.node = c_endif(yyvsp[-3].node, yyvsp[0].node);
2593 }
2594 break;
2595 case 73:
2596 #line 419 "parser.y"
2597 { c_loop(); }
2598 break;
2599 case 74:
2600 #line 421 "parser.y"
2601 { yyval.node = c_do(yyvsp[-2].node, yyvsp[-5].node); }
2602 break;
2603 case 75:
2604 #line 423 "parser.y"
2605 {
2606 c_loop();
2607 c_startcond();
2608 }
2609 break;
2610 case 76:
2611 #line 427 "parser.y"
2612 {
2613 c_endcond();
2614 yyval.node = c_while(yyvsp[-3].node, yyvsp[0].node);
2615 }
2616 break;
2617 case 77:
2618 #line 432 "parser.y"
2619 {
2620 c_loop();
2621 c_startcond();
2622 }
2623 break;
2624 case 78:
2625 #line 436 "parser.y"
2626 {
2627 c_endcond();
2628 yyval.node = c_for(c_exp_stmt(yyvsp[-7].node), yyvsp[-5].node, c_exp_stmt(yyvsp[-3].node), yyvsp[0].node);
2629 }
2630 break;
2631 case 79:
2632 #line 441 "parser.y"
2633 {
2634 if (typechecking) {
2635 char tnbuf[TNBUFSIZE];
2636
2637 if (yyvsp[-3].node->mod != T_INT && yyvsp[-3].node->mod != T_MIXED) {
2638 c_error("bad type for stack rlimit (%s)",
2639 i_typename(tnbuf, yyvsp[-3].node->mod));
2640 }
2641 if (yyvsp[-1].node->mod != T_INT && yyvsp[-1].node->mod != T_MIXED) {
2642 c_error("bad type for ticks rlimit (%s)",
2643 i_typename(tnbuf, yyvsp[-1].node->mod));
2644 }
2645 }
2646 c_startrlimits();
2647 }
2648 break;
2649 case 80:
2650 #line 457 "parser.y"
2651 { yyval.node = c_endrlimits(yyvsp[-5].node, yyvsp[-3].node, yyvsp[0].node); }
2652 break;
2653 case 81:
2654 #line 458 "parser.y"
2655 {
2656 c_startcatch();
2657 c_startcond();
2658 }
2659 break;
2660 case 82:
2661 #line 463 "parser.y"
2662 {
2663 c_endcond();
2664 c_endcatch();
2665 c_startcond();
2666 }
2667 break;
2668 case 83:
2669 #line 469 "parser.y"
2670 {
2671 c_endcond();
2672 yyval.node = c_donecatch(yyvsp[-2].node, yyvsp[0].node);
2673 }
2674 break;
2675 case 84:
2676 #line 474 "parser.y"
2677 {
2678 c_startswitch(yyvsp[-1].node, typechecking);
2679 c_startcond();
2680 }
2681 break;
2682 case 85:
2683 #line 479 "parser.y"
2684 {
2685 c_endcond();
2686 yyval.node = c_endswitch(yyvsp[-3].node, yyvsp[0].node);
2687 }
2688 break;
2689 case 86:
2690 #line 484 "parser.y"
2691 { yyvsp[-1].node = c_case(yyvsp[-1].node, (node *) NULL); }
2692 break;
2693 case 87:
2694 #line 485 "parser.y"
2695 {
2696 yyval.node = yyvsp[-3].node;
2697 if (yyval.node != (node *) NULL) {
2698 yyval.node->l.left = yyvsp[0].node;
2699 } else {
2700 yyval.node = yyvsp[0].node;
2701 }
2702 }
2703 break;
2704 case 88:
2705 #line 494 "parser.y"
2706 { yyvsp[-3].node = c_case(yyvsp[-3].node, yyvsp[-1].node); }
2707 break;
2708 case 89:
2709 #line 495 "parser.y"
2710 {
2711 yyval.node = yyvsp[-5].node;
2712 if (yyval.node != (node *) NULL) {
2713 yyval.node->l.left = yyvsp[0].node;
2714 } else {
2715 yyval.node = yyvsp[0].node;
2716 }
2717 }
2718 break;
2719 case 90:
2720 #line 504 "parser.y"
2721 { yyvsp[0].node = c_default(); }
2722 break;
2723 case 91:
2724 #line 505 "parser.y"
2725 {
2726 yyval.node = yyvsp[-2].node;
2727 if (yyval.node != (node *) NULL) {
2728 yyval.node->l.left = yyvsp[0].node;
2729 } else {
2730 yyval.node = yyvsp[0].node;
2731 }
2732 }
2733 break;
2734 case 92:
2735 #line 514 "parser.y"
2736 {
2737 yyval.node = c_break();
2738 }
2739 break;
2740 case 93:
2741 #line 518 "parser.y"
2742 {
2743 yyval.node = c_continue();
2744 }
2745 break;
2746 case 94:
2747 #line 522 "parser.y"
2748 { yyval.node = c_return(yyvsp[-1].node, typechecking); }
2749 break;
2750 case 95:
2751 #line 523 "parser.y"
2752 { yyval.node = (node *) NULL; }
2753 break;
2754 case 96:
2755 #line 527 "parser.y"
2756 {
2757 nstatements = 0;
2758 c_startcompound();
2759 }
2760 break;
2761 case 97:
2762 #line 532 "parser.y"
2763 {
2764 nstatements++;
2765 yyval.node = c_endcompound(yyvsp[-1].node);
2766 }
2767 break;
2768 case 98:
2769 #line 540 "parser.y"
2770 { yyval.node = (node *) NULL; }
2771 break;
2772 case 99:
2773 #line 542 "parser.y"
2774 { yyval.node = yyvsp[0].node; }
2775 break;
2776 case 100:
2777 #line 546 "parser.y"
2778 { yyval.node = c_flookup(yyvsp[0].node, typechecking); }
2779 break;
2780 case 101:
2781 #line 548 "parser.y"
2782 { yyval.node = c_iflookup(yyvsp[0].node, (node *) NULL); }
2783 break;
2784 case 102:
2785 #line 550 "parser.y"
2786 { yyval.node = c_iflookup(yyvsp[0].node, yyvsp[-2].node); }
2787 break;
2788 case 103:
2789 #line 555 "parser.y"
2790 { yyval.node = node_int(yyvsp[0].number); }
2791 break;
2792 case 104:
2793 #line 557 "parser.y"
2794 { yyval.node = node_float(&yyvsp[0].real); }
2795 break;
2796 case 105:
2797 #line 558 "parser.y"
2798 { yyval.node = node_nil(); }
2799 break;
2800 case 107:
2801 #line 561 "parser.y"
2802 { yyval.node = c_aggregate(yyvsp[-2].node, T_MIXED | (1 << REFSHIFT)); }
2803 break;
2804 case 108:
2805 #line 563 "parser.y"
2806 { yyval.node = c_aggregate(yyvsp[-2].node, T_MAPPING); }
2807 break;
2808 case 109:
2809 #line 564 "parser.y"
2810 {
2811 yyval.node = c_variable(yyvsp[0].node);
2812 if (typechecking) {
2813 if (yyval.node->type == N_GLOBAL && yyval.node->mod != T_MIXED &&
2814 !conf_typechecking()) {
2815 /*
2816 * global vars might be modified by untypechecked
2817 * functions...
2818 */
2819 yyval.node = node_mon(N_CAST, yyval.node->mod, yyval.node);
2820 yyval.node->class = yyval.node->l.left->class;
2821 }
2822 } else {
2823 /* the variable could be anything */
2824 yyval.node->mod = T_MIXED;
2825 }
2826 }
2827 break;
2828 case 110:
2829 #line 582 "parser.y"
2830 { yyval.node = yyvsp[-1].node; }
2831 break;
2832 case 111:
2833 #line 584 "parser.y"
2834 { yyval.node = c_checkcall(c_funcall(yyvsp[-3].node, yyvsp[-1].node), typechecking); }
2835 break;
2836 case 112:
2837 #line 586 "parser.y"
2838 { yyval.node = c_address(yyvsp[-3].node, yyvsp[-1].node, typechecking); }
2839 break;
2840 case 113:
2841 #line 588 "parser.y"
2842 { yyval.node = c_extend(yyvsp[-4].node, yyvsp[-1].node, typechecking); }
2843 break;
2844 case 114:
2845 #line 590 "parser.y"
2846 { yyval.node = c_call(yyvsp[-4].node, yyvsp[-1].node, typechecking); }
2847 break;
2848 case 115:
2849 #line 592 "parser.y"
2850 { c_startcond(); }
2851 break;
2852 case 116:
2853 #line 594 "parser.y"
2854 {
2855 c_endcond();
2856 yyval.node = node_mon(N_CATCH, T_STRING, yyvsp[-1].node);
2857 }
2858 break;
2859 case 117:
2860 #line 599 "parser.y"
2861 {
2862 t_void(yyvsp[-5].node);
2863 yyval.node = c_checkcall(c_arrow(yyvsp[-5].node, yyvsp[-3].node, yyvsp[-1].node), typechecking);
2864 }
2865 break;
2866 case 118:
2867 #line 604 "parser.y"
2868 { yyval.node = c_instanceof(yyvsp[-2].node, yyvsp[0].node); }
2869 break;
2870 case 119:
2871 #line 606 "parser.y"
2872 { yyval.node = c_instanceof(yyvsp[-4].node, yyvsp[-1].node); }
2873 break;
2874 case 121:
2875 #line 612 "parser.y"
2876 { yyval.node = idx(yyvsp[-3].node, yyvsp[-1].node); }
2877 break;
2878 case 122:
2879 #line 614 "parser.y"
2880 { yyval.node = range(yyvsp[-5].node, yyvsp[-3].node, yyvsp[-1].node); }
2881 break;
2882 case 124:
2883 #line 620 "parser.y"
2884 { yyval.node = uassign(N_PLUS_PLUS, yyvsp[-1].node, "++"); }
2885 break;
2886 case 125:
2887 #line 622 "parser.y"
2888 { yyval.node = uassign(N_MIN_MIN, yyvsp[-1].node, "--"); }
2889 break;
2890 case 127:
2891 #line 628 "parser.y"
2892 { yyval.node = uassign(N_ADD_EQ_1, yyvsp[0].node, "++"); }
2893 break;
2894 case 128:
2895 #line 630 "parser.y"
2896 { yyval.node = uassign(N_SUB_EQ_1, yyvsp[0].node, "--"); }
2897 break;
2898 case 129:
2899 #line 632 "parser.y"
2900 { yyval.node = umin(yyvsp[0].node); }
2901 break;
2902 case 130:
2903 #line 634 "parser.y"
2904 { yyval.node = yyvsp[0].node; }
2905 break;
2906 case 131:
2907 #line 636 "parser.y"
2908 {
2909 t_void(yyvsp[0].node);
2910 yyval.node = c_not(yyvsp[0].node);
2911 }
2912 break;
2913 case 132:
2914 #line 641 "parser.y"
2915 {
2916 yyval.node = yyvsp[0].node;
2917 t_void(yyval.node);
2918 if (typechecking && yyval.node->mod != T_INT && yyval.node->mod != T_MIXED) {
2919 char tnbuf[TNBUFSIZE];
2920
2921 c_error("bad argument type for ~ (%s)",
2922 i_typename(tnbuf, yyval.node->mod));
2923 yyval.node->mod = T_MIXED;
2924 } else {
2925 yyval.node = xor(N_XOR, yyval.node, node_int((Int) -1), "^");
2926 }
2927 }
2928 break;
2929 case 134:
2930 #line 659 "parser.y"
2931 {
2932 yyvsp[-3].node->mod |= (yyvsp[-2].type << REFSHIFT) & T_REF;
2933 yyval.node = cast(yyvsp[0].node, yyvsp[-3].node);
2934 }
2935 break;
2936 case 136:
2937 #line 668 "parser.y"
2938 { yyval.node = mult(N_MULT, yyvsp[-2].node, yyvsp[0].node, "*"); }
2939 break;
2940 case 137:
2941 #line 670 "parser.y"
2942 { yyval.node = mdiv(N_DIV, yyvsp[-2].node, yyvsp[0].node, "/"); }
2943 break;
2944 case 138:
2945 #line 672 "parser.y"
2946 { yyval.node = mod(N_MOD, yyvsp[-2].node, yyvsp[0].node, "%"); }
2947 break;
2948 case 140:
2949 #line 678 "parser.y"
2950 { yyval.node = add(N_ADD, yyvsp[-2].node, yyvsp[0].node, "+"); }
2951 break;
2952 case 141:
2953 #line 680 "parser.y"
2954 { yyval.node = sub(N_SUB, yyvsp[-2].node, yyvsp[0].node, "-"); }
2955 break;
2956 case 143:
2957 #line 686 "parser.y"
2958 { yyval.node = lshift(N_LSHIFT, yyvsp[-2].node, yyvsp[0].node, "<<"); }
2959 break;
2960 case 144:
2961 #line 688 "parser.y"
2962 { yyval.node = rshift(N_RSHIFT, yyvsp[-2].node, yyvsp[0].node, ">>"); }
2963 break;
2964 case 146:
2965 #line 694 "parser.y"
2966 { yyval.node = rel(N_LT, yyval.node, yyvsp[0].node, "<"); }
2967 break;
2968 case 147:
2969 #line 696 "parser.y"
2970 { yyval.node = rel(N_GT, yyval.node, yyvsp[0].node, ">"); }
2971 break;
2972 case 148:
2973 #line 698 "parser.y"
2974 { yyval.node = rel(N_LE, yyval.node, yyvsp[0].node, "<="); }
2975 break;
2976 case 149:
2977 #line 700 "parser.y"
2978 { yyval.node = rel(N_GE, yyval.node, yyvsp[0].node, ">="); }
2979 break;
2980 case 151:
2981 #line 706 "parser.y"
2982 { yyval.node = eq(yyvsp[-2].node, yyvsp[0].node); }
2983 break;
2984 case 152:
2985 #line 708 "parser.y"
2986 { yyval.node = c_not(eq(yyvsp[-2].node, yyvsp[0].node)); }
2987 break;
2988 case 154:
2989 #line 714 "parser.y"
2990 { yyval.node = and(N_AND, yyvsp[-2].node, yyvsp[0].node, "&"); }
2991 break;
2992 case 156:
2993 #line 720 "parser.y"
2994 { yyval.node = xor(N_XOR, yyvsp[-2].node, yyvsp[0].node, "^"); }
2995 break;
2996 case 158:
2997 #line 726 "parser.y"
2998 { yyval.node = or(N_OR, yyvsp[-2].node, yyvsp[0].node, "|"); }
2999 break;
3000 case 160:
3001 #line 732 "parser.y"
3002 { yyval.node = land(yyvsp[-2].node, yyvsp[0].node); }
3003 break;
3004 case 162:
3005 #line 738 "parser.y"
3006 { yyval.node = lor(yyvsp[-2].node, yyvsp[0].node); }
3007 break;
3008 case 164:
3009 #line 744 "parser.y"
3010 { c_startcond(); }
3011 break;
3012 case 165:
3013 #line 746 "parser.y"
3014 { c_startcond2(); }
3015 break;
3016 case 166:
3017 #line 748 "parser.y"
3018 {
3019 c_matchcond();
3020 yyval.node = quest(yyvsp[-6].node, yyvsp[-3].node, yyvsp[0].node);
3021 }
3022 break;
3023 case 168:
3024 #line 757 "parser.y"
3025 { yyval.node = assign(c_assign(yyvsp[-2].node), yyvsp[0].node); }
3026 break;
3027 case 169:
3028 #line 759 "parser.y"
3029 { yyval.node = add(N_ADD_EQ, c_lvalue(yyvsp[-2].node, "+="), yyvsp[0].node, "+="); }
3030 break;
3031 case 170:
3032 #line 761 "parser.y"
3033 { yyval.node = sub(N_SUB_EQ, c_lvalue(yyvsp[-2].node, "-="), yyvsp[0].node, "-="); }
3034 break;
3035 case 171:
3036 #line 763 "parser.y"
3037 { yyval.node = mult(N_MULT_EQ, c_lvalue(yyvsp[-2].node, "*="), yyvsp[0].node, "*="); }
3038 break;
3039 case 172:
3040 #line 765 "parser.y"
3041 { yyval.node = mdiv(N_DIV_EQ, c_lvalue(yyvsp[-2].node, "/="), yyvsp[0].node, "/="); }
3042 break;
3043 case 173:
3044 #line 767 "parser.y"
3045 { yyval.node = mod(N_MOD_EQ, c_lvalue(yyvsp[-2].node, "%="), yyvsp[0].node, "%="); }
3046 break;
3047 case 174:
3048 #line 769 "parser.y"
3049 { yyval.node = lshift(N_LSHIFT_EQ, c_lvalue(yyvsp[-2].node, "<<="), yyvsp[0].node, "<<="); }
3050 break;
3051 case 175:
3052 #line 771 "parser.y"
3053 { yyval.node = rshift(N_RSHIFT_EQ, c_lvalue(yyvsp[-2].node, ">>="), yyvsp[0].node, ">>="); }
3054 break;
3055 case 176:
3056 #line 773 "parser.y"
3057 { yyval.node = and(N_AND_EQ, c_lvalue(yyvsp[-2].node, "&="), yyvsp[0].node, "&="); }
3058 break;
3059 case 177:
3060 #line 775 "parser.y"
3061 { yyval.node = xor(N_XOR_EQ, c_lvalue(yyvsp[-2].node, "^="), yyvsp[0].node, "^="); }
3062 break;
3063 case 178:
3064 #line 777 "parser.y"
3065 { yyval.node = or(N_OR_EQ, c_lvalue(yyvsp[-2].node, "|="), yyvsp[0].node, "|="); }
3066 break;
3067 case 180:
3068 #line 783 "parser.y"
3069 { yyval.node = comma(yyvsp[-2].node, yyvsp[0].node); }
3070 break;
3071 case 181:
3072 #line 788 "parser.y"
3073 { yyval.node = (node *) NULL; }
3074 break;
3075 case 183:
3076 #line 794 "parser.y"
3077 { t_void(yyval.node = yyvsp[0].node); }
3078 break;
3079 case 184:
3080 #line 799 "parser.y"
3081 { t_void(yyval.node = yyvsp[0].node); }
3082 break;
3083 case 185:
3084 #line 803 "parser.y"
3085 { t_void(yyval.node = yyvsp[0].node); }
3086 break;
3087 case 186:
3088 #line 805 "parser.y"
3089 {
3090 t_void(yyvsp[0].node);
3091 yyval.node = node_bin(N_PAIR, 0, yyvsp[-2].node, yyvsp[0].node);
3092 }
3093 break;
3094 case 187:
3095 #line 813 "parser.y"
3096 { yyval.node = (node *) NULL; }
3097 break;
3098 case 189:
3099 #line 816 "parser.y"
3100 {
3101 yyval.node = yyvsp[-1].node;
3102 if (yyval.node->type == N_PAIR) {
3103 yyval.node->r.right = node_mon(N_SPREAD, -1, yyval.node->r.right);
3104 } else {
3105 yyval.node = node_mon(N_SPREAD, -1, yyval.node);
3106 }
3107 }
3108 break;
3109 case 190:
3110 #line 828 "parser.y"
3111 { yyval.node = (node *) NULL; }
3112 break;
3113 case 192:
3114 #line 831 "parser.y"
3115 { yyval.node = yyvsp[-1].node; }
3116 break;
3117 case 193:
3118 #line 836 "parser.y"
3119 {
3120 t_void(yyvsp[-2].node);
3121 t_void(yyvsp[0].node);
3122 yyval.node = node_bin(N_COMMA, 0, yyvsp[-2].node, yyvsp[0].node);
3123 }
3124 break;
3125 case 195:
3126 #line 846 "parser.y"
3127 { yyval.node = node_bin(N_PAIR, 0, yyvsp[-2].node, yyvsp[0].node); }
3128 break;
3129 case 196:
3130 #line 851 "parser.y"
3131 { yyval.node = (node *) NULL; }
3132 break;
3133 case 198:
3134 #line 854 "parser.y"
3135 { yyval.node = yyvsp[-1].node; }
3136 break;
3137 #line 3138 "y.tab.c"
3138 }
3139 yyssp -= yym;
3140 yystate = *yyssp;
3141 yyvsp -= yym;
3142 yym = yylhs[yyn];
3143 if (yystate == 0 && yym == 0)
3144 {
3145 #if YYDEBUG
3146 if (yydebug)
3147 printf("%sdebug: after reduction, shifting from state 0 to\
3148 state %d\n", YYPREFIX, YYFINAL);
3149 #endif
3150 yystate = YYFINAL;
3151 *++yyssp = YYFINAL;
3152 *++yyvsp = yyval;
3153 if (yychar < 0)
3154 {
3155 if ((yychar = yylex()) < 0) yychar = 0;
3156 #if YYDEBUG
3157 if (yydebug)
3158 {
3159 yys = 0;
3160 if (yychar <= YYMAXTOKEN) yys = yyname[yychar];
3161 if (!yys) yys = "illegal-symbol";
3162 printf("%sdebug: state %d, reading %d (%s)\n",
3163 YYPREFIX, YYFINAL, yychar, yys);
3164 }
3165 #endif
3166 }
3167 if (yychar == 0) goto yyaccept;
3168 goto yyloop;
3169 }
3170 if ((yyn = yygindex[yym]) && (yyn += yystate) >= 0 &&
3171 yyn <= YYTABLESIZE && yycheck[yyn] == yystate)
3172 yystate = yytable[yyn];
3173 else
3174 yystate = yydgoto[yym];
3175 #if YYDEBUG
3176 if (yydebug)
3177 printf("%sdebug: after reduction, shifting from state %d \
3178 to state %d\n", YYPREFIX, *yyssp, yystate);
3179 #endif
3180 if (yyssp >= yysslim)
3181 {
3182 goto yyoverflow;
3183 }
3184 *++yyssp = yystate;
3185 *++yyvsp = yyval;
3186 goto yyloop;
3187 yyoverflow:
3188 yyerror("yacc stack overflow");
3189 yyabort:
3190 return (1);
3191 yyaccept:
3192 return (0);
3193 }
3194