![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cgram.i CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / vax|
Return to cgram.i CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / vax |
1.1 root 1:
2:
3: static char SCCSID[] = "@(#) cgram.y: 2.1 83/08/02";
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57: extern int yychar;
58: extern short yyerrflag;
59:
60:
61:
62: YYSTYPE yylval, yyval;
63:
64:
65: extern int wloop_level;
66: extern int floop_level;
67: static int fake = 0;
68: static char fakename[NCHNAM+1];
69:
70:
71:
72:
73:
74: NODE *
75: mkty( t, d, s ) unsigned t; {
76: return( block( 33, NIL, NIL, t, d, s ) );
77: }
78:
79: NODE *
80: bdty( op, p, v ) NODE *p; {
81: register NODE *q;
82:
83: q = block( op, p, NIL, INT, 0, INT );
84:
85: switch( op ){
86:
87: case UNARY 11:
88: case UNARY CALL:
89: break;
90:
91: case 54:
92: q->in.right = bcon(v);
93: break;
94:
95: case 2:
96: q->tn.rval = v;
97: break;
98:
99: default:
100: cerror( "bad bdty" );
101: }
102:
103: return( q );
104: }
105:
106: dstash( n ){
107: if( curdim >= DIMTABSZ-1 ){
108: cerror( "dimension table overflow");
109: }
110: dimtab[ curdim++ ] = n;
111: }
112:
113: savebc() {
114: if( psavbc > & asavbc[BCSZ-4 ] ){
115: cerror( "whiles, fors, etc. too deeply nested");
116: }
117: *psavbc++ = brklab;
118: *psavbc++ = contlab;
119: *psavbc++ = flostat;
120: *psavbc++ = swx;
121:
122: flostat = 0;
123: }
124:
125: resetbc(mask){
126:
127:
128: swx = *--psavbc;
129: flostat = *--psavbc | (flostat&mask);
130: contlab = *--psavbc;
131: brklab = *--psavbc;
132:
133: }
134:
135: addcase(p) NODE *p; {
136:
137: p = optim( p );
138: if( p->in.op != 4 || p->tn.rval != NONAME){
139: uerror( "non-constant case expression");
140: return;
141: }
142: if( swp == swtab ){
143: uerror( "case not in switch");
144: return;
145: }
146: if( swp >= &swtab[SWITSZ] ){
147: cerror( "switch table overflow");
148: }
149: swp->sval = p->tn.lval;
150: deflab( swp->slab = getlab() );
151: ++swp;
152: tfree(p);
153: }
154:
155: adddef(){
156: if( swtab[swx].slab >= 0 ){
157: uerror( "duplicate default in switch");
158: return;
159: }
160: if( swp == swtab ){
161: uerror( "default not inside switch");
162: return;
163: }
164: deflab( swtab[swx].slab = getlab() );
165: }
166:
167: swstart(){
168:
169: if( swp >= &swtab[SWITSZ] ){
170: cerror( "switch table overflow");
171: }
172: swx = swp - swtab;
173: swp->slab = -1;
174: ++swp;
175: }
176:
177: swend(){
178:
179: register struct sw *swbeg, *p, *q, *r, *r1;
180: CONSZ temp;
181: int tempi;
182:
183: swbeg = &swtab[swx+1];
184:
185:
186:
187: r1 = swbeg;
188: r = swp-1;
189:
190: while( swbeg < r ){
191:
192: for( q=swbeg; q<r; ++q ){
193: if( q->sval > (q+1)->sval ){
194:
195: r1 = q+1;
196: temp = q->sval;
197: q->sval = r1->sval;
198: r1->sval = temp;
199: tempi = q->slab;
200: q->slab = r1->slab;
201: r1->slab = tempi;
202: }
203: }
204: r = r1;
205: r1 = swbeg;
206: }
207:
208:
209:
210: for( p = swbeg+1; p<swp; ++p ){
211: if( p->sval == (p-1)->sval ){
212: uerror( "duplicate case in switch, %d", tempi=p->sval );
213: return;
214: }
215: }
216:
217: reached = 1;
218: genswitch( swbeg-1, (int)(swp-swbeg) );
219: swp = swbeg-1;
220: }
221: short yyexca[] ={
222: -1, 1,
223: 0, -1,
224: 2, 20,
225: 11, 20,
226: 50, 20,
227: 57, 20,
228: -2, 0,
229: -1, 21,
230: 56, 80,
231: 57, 80,
232: -2, 8,
233: -1, 25,
234: 51, 68,
235: -2, 66,
236: -1, 26,
237: 58, 77,
238: -2, 79,
239: -1, 28,
240: 58, 78,
241: -2, 83,
242: -1, 34,
243: 52, 43,
244: -2, 41,
245: -1, 36,
246: 52, 35,
247: -2, 33,
248: -1, 56,
249: 53, 47,
250: 57, 47,
251: -2, 0,
252: };
253:
254:
255: short yyact[]={
256:
257: 234, 232, 70, 20, 290, 11, 10, 15, 78, 94,
258: 101, 198, 7, 99, 253, 90, 88, 89, 29, 147,
259: 81, 17, 98, 79, 132, 131, 80, 23, 29, 29,
260: 311, 5, 93, 96, 236, 103, 58, 23, 23, 55,
261: 22, 277, 83, 82, 50, 276, 65, 310, 245, 246,
262: 250, 76, 252, 243, 244, 239, 251, 241, 255, 254,
263: 84, 100, 85, 300, 109, 233, 24, 111, 163, 247,
264: 293, 235, 9, 230, 272, 107, 24, 24, 133, 38,
265: 262, 30, 271, 19, 191, 99, 148, 152, 140, 141,
266: 142, 143, 144, 145, 98, 264, 75, 106, 156, 205,
267: 92, 104, 38, 37, 52, 96, 56, 202, 112, 18,
268: 156, 102, 201, 113, 285, 259, 166, 167, 168, 170,
269: 172, 174, 176, 178, 179, 181, 183, 185, 186, 187,
270: 188, 189, 155, 100, 114, 133, 110, 26, 193, 160,
271: 162, 157, 190, 158, 136, 261, 138, 148, 224, 224,
272: 161, 87, 90, 88, 89, 40, 68, 74, 149, 41,
273: 192, 42, 44, 40, 139, 56, 195, 41, 137, 48,
274: 208, 48, 209, 49, 210, 49, 211, 206, 212, 83,
275: 82, 213, 64, 214, 257, 215, 48, 67, 217, 99,
276: 49, 159, 133, 200, 95, 154, 35, 84, 98, 85,
277: 33, 314, 228, 219, 204, 223, 29, 11, 10, 15,
278: 231, 226, 227, 229, 297, 23, 218, 256, 222, 149,
279: 196, 73, 258, 17, 281, 11, 109, 15, 4, 72,
280: 63, 223, 199, 225, 200, 299, 42, 100, 44, 265,
281: 266, 17, 268, 288, 270, 95, 274, 286, 11, 10,
282: 15, 278, 153, 280, 24, 282, 71, 87, 90, 88,
283: 89, 279, 269, 81, 17, 289, 79, 97, 248, 80,
284: 291, 260, 28, 199, 153, 51, 287, 10, 53, 32,
285: 294, 295, 28, 28, 121, 83, 82, 283, 8, 298,
286: 253, 90, 88, 89, 275, 194, 81, 105, 31, 79,
287: 304, 117, 80, 84, 21, 85, 291, 165, 309, 59,
288: 308, 36, 273, 291, 34, 66, 315, 313, 83, 82,
289: 249, 43, 45, 312, 245, 246, 250, 305, 252, 243,
290: 244, 239, 251, 241, 255, 254, 84, 306, 85, 97,
291: 109, 95, 267, 108, 118, 247, 119, 235, 134, 121,
292: 27, 60, 123, 47, 69, 124, 46, 125, 203, 128,
293: 221, 126, 127, 129, 115, 122, 117, 120, 118, 91,
294: 119, 54, 57, 121, 164, 118, 123, 119, 207, 124,
295: 121, 125, 62, 128, 61, 126, 127, 129, 115, 122,
296: 117, 120, 39, 220, 116, 115, 130, 117, 120, 3,
297: 2, 151, 86, 12, 118, 13, 119, 6, 25, 121,
298: 14, 16, 123, 307, 242, 124, 240, 125, 116, 128,
299: 130, 126, 127, 129, 115, 122, 117, 120, 118, 237,
300: 119, 238, 1, 121, 0, 0, 0, 0, 0, 0,
301: 118, 0, 119, 0, 0, 121, 0, 0, 123, 303,
302: 117, 124, 0, 125, 116, 128, 130, 126, 127, 129,
303: 115, 122, 117, 120, 0, 0, 0, 0, 0, 0,
304: 0, 0, 0, 0, 0, 0, 118, 0, 119, 0,
305: 0, 121, 0, 0, 123, 302, 0, 124, 0, 125,
306: 116, 128, 130, 126, 127, 129, 115, 122, 117, 120,
307: 0, 118, 0, 119, 0, 0, 121, 0, 0, 0,
308: 0, 0, 0, 0, 118, 0, 119, 0, 0, 121,
309: 0, 301, 123, 117, 120, 124, 116, 125, 130, 128,
310: 296, 126, 127, 129, 115, 122, 117, 120, 118, 0,
311: 119, 0, 0, 121, 248, 0, 123, 0, 0, 124,
312: 0, 125, 0, 128, 0, 126, 127, 129, 115, 122,
313: 117, 120, 0, 118, 116, 119, 130, 0, 121, 0,
314: 0, 123, 0, 0, 124, 0, 125, 0, 128, 0,
315: 126, 127, 129, 115, 122, 117, 120, 0, 116, 292,
316: 130, 0, 0, 0, 0, 0, 0, 0, 0, 0,
317: 0, 0, 0, 118, 0, 119, 0, 0, 121, 0,
318: 0, 123, 284, 116, 124, 130, 125, 0, 128, 0,
319: 126, 127, 129, 115, 122, 117, 120, 118, 0, 119,
320: 0, 0, 121, 0, 0, 123, 0, 0, 124, 0,
321: 125, 0, 128, 216, 126, 127, 129, 115, 122, 117,
322: 120, 0, 0, 116, 263, 130, 0, 0, 0, 0,
323: 0, 0, 0, 118, 0, 119, 0, 118, 121, 119,
324: 0, 123, 121, 0, 124, 123, 125, 116, 128, 130,
325: 126, 127, 129, 115, 122, 117, 120, 115, 122, 117,
326: 120, 0, 0, 0, 0, 0, 0, 0, 0, 118,
327: 0, 119, 0, 0, 121, 0, 0, 123, 197, 0,
328: 124, 0, 125, 116, 128, 130, 126, 127, 129, 115,
329: 122, 117, 120, 118, 0, 119, 0, 0, 121, 0,
330: 0, 123, 0, 0, 124, 0, 125, 0, 128, 0,
331: 126, 127, 129, 115, 122, 117, 120, 0, 0, 116,
332: 0, 130, 87, 90, 88, 89, 0, 0, 81, 0,
333: 0, 79, 0, 0, 80, 87, 90, 88, 89, 0,
334: 0, 81, 0, 0, 79, 130, 0, 80, 0, 0,
335: 83, 82, 0, 0, 0, 0, 0, 0, 0, 0,
336: 0, 0, 0, 83, 82, 0, 0, 0, 84, 0,
337: 85, 0, 0, 87, 90, 88, 89, 0, 184, 81,
338: 0, 84, 79, 85, 0, 80, 87, 90, 88, 89,
339: 0, 182, 81, 0, 0, 79, 0, 0, 80, 0,
340: 0, 83, 82, 0, 0, 0, 0, 0, 0, 0,
341: 0, 0, 0, 0, 83, 82, 0, 0, 0, 84,
342: 0, 85, 0, 0, 87, 90, 88, 89, 0, 180,
343: 81, 0, 84, 79, 85, 0, 80, 87, 90, 88,
344: 89, 0, 177, 81, 0, 0, 79, 0, 0, 80,
345: 0, 0, 83, 82, 0, 0, 0, 0, 0, 0,
346: 0, 0, 0, 0, 0, 83, 82, 0, 0, 0,
347: 84, 0, 85, 0, 0, 87, 90, 88, 89, 0,
348: 175, 81, 0, 84, 79, 85, 0, 80, 87, 90,
349: 88, 89, 0, 173, 81, 0, 0, 79, 0, 0,
350: 80, 0, 0, 83, 82, 0, 0, 0, 0, 0,
351: 0, 0, 0, 0, 0, 0, 83, 82, 0, 0,
352: 0, 84, 0, 85, 0, 0, 87, 90, 88, 89,
353: 0, 171, 81, 0, 84, 79, 85, 0, 80, 0,
354: 87, 90, 88, 89, 169, 0, 81, 0, 0, 79,
355: 0, 0, 80, 0, 83, 82, 0, 118, 0, 119,
356: 0, 118, 121, 119, 0, 123, 121, 0, 83, 82,
357: 125, 11, 84, 15, 85, 0, 135, 115, 122, 117,
358: 120, 115, 122, 117, 120, 0, 84, 17, 85, 87,
359: 90, 88, 89, 0, 0, 81, 0, 0, 79, 0,
360: 0, 80, 87, 90, 88, 89, 0, 0, 81, 0,
361: 0, 79, 0, 0, 80, 0, 0, 83, 82, 0,
362: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
363: 83, 82, 0, 0, 0, 84, 0, 85, 0, 77,
364: 87, 90, 88, 89, 0, 0, 81, 0, 84, 79,
365: 85, 150, 80, 87, 90, 88, 89, 0, 0, 81,
366: 0, 0, 79, 0, 0, 80, 0, 0, 83, 82,
367: 0, 0, 118, 0, 119, 0, 0, 121, 0, 0,
368: 123, 83, 82, 124, 0, 125, 84, 128, 85, 126,
369: 127, 0, 115, 122, 117, 120, 0, 0, 118, 84,
370: 119, 146, 0, 121, 0, 0, 123, 0, 0, 124,
371: 0, 125, 0, 0, 0, 126, 0, 0, 115, 122,
372: 117, 120, 118, 0, 119, 0, 0, 121, 0, 0,
373: 123, 0, 0, 124, 0, 125, 0, 0, 0, 0,
374: 0, 0, 115, 122, 117, 120 };
375: short yypact[]={
376:
377: -1000, -28,-1000,-1000,-1000, 52, 26,-1000, 192, 243,
378: -1000, 246,-1000,-1000, 148, 312, 144, 309,-1000,-1000,
379: 46, 113,-1000, 204, 204,-1000, 121, -14,-1000, 225,
380: -1000, 192, 245, 192,-1000, 307,-1000,-1000,-1000,-1000,
381: 179, 127, 121, 113, 136, 105, 0, 178, 170, 102,
382: 1017,-1000,-1000,-1000, 43,-1000, 83, 55,-1000, -23,
383: 27,-1000, 174,-1000,-1000, 81,1068,-1000,-1000, 57,
384: -1000,-1000,-1000,-1000,-1000, 79, 717, 954, 114,1068,
385: 1068,1068,1068,1068,1081, 968,1030, 224,-1000,-1000,
386: -1000, 142, 192, 54,-1000, 119,-1000,-1000, 187,-1000,
387: 187, 138, 307,-1000,-1000, 113,-1000, 11,-1000,-1000,
388: -1000, 717,-1000, 305,-1000,1068,1068, 916, 903, 865,
389: 852, 814,1068, 801, 763, 750,1068,1068,1068,1068,
390: 1068, 28,-1000, 717, 954,-1000,-1000,1068, 293,-1000,
391: 114, 114, 114, 114, 114, 114, 968, 169, 657, 223,
392: -1000, 56, 717,-1000,-1000,-1000,-1000,-1000,-1000,-1000,
393: -1000,-1000, 42,-1000, 215,-1000, 495, 717,-1000,1068,
394: 273,1068, 273,1068, 422,1068,-1000,1068, 369, 985,
395: 1068, 981,1068, 661,1068,1146,1122, 621, 717, 717,
396: 135, 954, 28, 338,-1000, 167,1068,-1000, 95, 182,
397: 223,1068,-1000, 83,-1000,-1000, 16, 12, 717, 717,
398: 717, 717, 717, 717, 717, 717,1068,-1000,-1000, 131,
399: -1000,1068, 149, 114, 60,-1000, 94, 95, 717,-1000,
400: -1000, 23,-1000,-1000, 597, 38,-1000, 288, 288,-1000,
401: 288, 212, 288, 25, 17, 255, 292,-1000, -12, 288,
402: 211,-1000, 203, 202,1068, 265,1096,-1000, 557,-1000,
403: 59, 197,-1000,-1000,-1000, 237,-1000, 193, 222,1068,
404: -1000,-1000,-1000,-1000, 532, 13,-1000,-1000,-1000,1068,
405: 1068,-1000, 508,-1000,-1000,-1000, 163,-1000,1068, 185,
406: 6, 693,-1000,-1000, 470, 434,-1000,-1000, 398,1068,
407: -1000,-1000,-1000,-1000, 362,1068, 288, -10, -27,-1000,
408: -1000,-1000,1068, 150, 288,-1000 };
409: short yypgo[]={
410:
411: 0, 432, 46, 431, 429, 416, 414, 411, 410, 408,
412: 0, 4, 8, 12, 407, 72, 405, 403, 19, 11,
413: 402, 9, 297, 137, 401, 400, 399, 3, 392, 384,
414: 382, 34, 32, 378, 1, 374, 288, 372, 10, 36,
415: 371, 369, 39, 358, 356, 354, 353, 40, 351, 350,
416: 25, 24, 348, 343, 342, 337, 327, 323, 320, 315 };
417: short yyr1[]={
418:
419: 0, 1, 1, 25, 25, 25, 26, 26, 28, 26,
420: 29, 30, 30, 30, 33, 33, 35, 35, 35, 14,
421: 14, 13, 13, 13, 13, 13, 36, 15, 15, 15,
422: 15, 15, 16, 16, 7, 7, 37, 37, 39, 39,
423: 17, 17, 8, 8, 40, 40, 42, 42, 32, 43,
424: 32, 21, 21, 21, 21, 23, 23, 23, 23, 23,
425: 23, 22, 22, 22, 22, 22, 44, 22, 46, 22,
426: 9, 45, 45, 45, 27, 48, 27, 49, 49, 47,
427: 47, 47, 47, 47, 50, 50, 51, 51, 38, 38,
428: 41, 41, 52, 31, 53, 34, 34, 34, 34, 34,
429: 54, 55, 34, 34, 56, 57, 34, 34, 34, 34,
430: 34, 34, 34, 34, 34, 34, 34, 58, 58, 58,
431: 5, 4, 3, 6, 59, 2, 11, 11, 24, 24,
432: 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
433: 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
434: 10, 10, 10, 10, 10, 12, 12, 12, 12, 12,
435: 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
436: 12, 12, 12, 12, 18, 19, 19, 19, 19, 19,
437: 19, 19, 20, 20 };
438: short yyr2[]={
439:
440: 0, 2, 0, 1, 1, 2, 2, 3, 0, 4,
441: 2, 4, 3, 0, 2, 0, 3, 4, 0, 1,
442: 0, 2, 2, 1, 1, 3, 1, 1, 2, 3,
443: 1, 1, 5, 2, 1, 2, 1, 3, 1, 3,
444: 5, 2, 1, 2, 1, 3, 2, 1, 1, 0,
445: 4, 1, 3, 2, 1, 2, 3, 3, 4, 1,
446: 3, 2, 3, 3, 4, 3, 0, 4, 0, 3,
447: 2, 1, 3, 1, 1, 0, 4, 1, 1, 1,
448: 1, 3, 6, 1, 1, 3, 1, 4, 0, 1,
449: 0, 1, 1, 4, 1, 2, 2, 1, 2, 2,
450: 0, 0, 7, 7, 0, 0, 11, 2, 2, 2,
451: 2, 3, 3, 1, 2, 2, 2, 2, 3, 2,
452: 1, 4, 3, 4, 0, 2, 1, 0, 1, 3,
453: 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
454: 3, 3, 3, 4, 4, 4, 4, 4, 4, 4,
455: 4, 5, 3, 3, 1, 2, 2, 2, 2, 2,
456: 2, 2, 4, 4, 4, 6, 2, 3, 3, 1,
457: 1, 1, 1, 3, 2, 0, 2, 5, 2, 3,
458: 4, 3, 2, 2 };
459: short yychk[]={
460:
461: -1000, -1, -25, -26, 256, 59, -14, -13, -36, -15,
462: 34, 33, -17, -16, -8, 35, -7, 49, 57, 57,
463: -27, -22, -47, 11, 50, -9, -23, -49, 256, 2,
464: -15, -36, 33, 52, 2, 52, 2, 57, 56, -28,
465: 50, 54, -23, -22, -23, -22, -44, -46, 50, 54,
466: 58, 50, -15, 33, -40, -42, -15, -37, -39, 2,
467: -48, -29, -30, 51, 55, -2, -59, 51, 51, -45,
468: 2, 256, 51, 51, 55, -2, -10, 52, -12, 11,
469: 14, 8, 31, 30, 48, 50, -20, 2, 4, 5,
470: 3, -41, 57, -32, -21, -23, 22, 256, 11, 2,
471: 50, -38, 56, 58, -47, -22, -31, -13, -53, 52,
472: 55, -10, 51, 56, 55, 26, 56, 28, 6, 8,
473: 29, 11, 27, 14, 17, 19, 23, 24, 21, 25,
474: 58, -50, -51, -10, -52, 52, 30, 54, 32, 50,
475: -12, -12, -12, -12, -12, -12, 50, -18, -10, -15,
476: 51, -24, -10, 50, 53, -42, 56, 22, -2, 53,
477: -39, -2, -32, 57, -35, 2, -10, -10, -10, 58,
478: -10, 58, -10, 58, -10, 58, -10, 58, -10, -10,
479: 58, -10, 58, -10, 58, -10, -10, -10, -10, -10,
480: -38, 56, -50, -10, 2, -18, 51, 51, -19, 50,
481: 11, 56, 51, -43, -2, 57, -13, -33, -10, -10,
482: -10, -10, -10, -10, -10, -10, 22, 53, -51, -38,
483: 55, 22, 51, -12, 54, 51, -19, -19, -10, -21,
484: 57, -27, -34, 53, -10, 59, -31, -4, -3, 43,
485: -5, 45, -6, 41, 42, 36, 37, 57, 256, -58,
486: 38, 44, 40, 2, 47, 46, -10, 53, -10, 55,
487: -2, 51, 57, 57, 57, -34, -34, -54, -34, 50,
488: -34, 57, 57, 57, -10, 2, 57, 53, -34, 50,
489: 50, 22, -10, 22, 55, 55, 50, 39, 50, 43,
490: -11, -10, 57, 57, -10, -10, 22, 51, -10, 50,
491: 57, 51, 51, 51, -10, -56, -55, 51, -11, -34,
492: 57, 57, -57, -11, 51, -34 };
493: short yydef[]={
494:
495: 2, -2, 1, 3, 4, 0, 0, 19, 23, 24,
496: 26, 27, 30, 31, 0, 42, 0, 34, 5, 6,
497: 0, -2, 74, 0, 0, -2, -2, 0, -2, 59,
498: 21, 22, 28, 0, -2, 0, -2, 7, 75, 13,
499: 0, 124, 55, 61, 0, 0, 0, 0, 0, 124,
500: 0, 70, 25, 29, 90, 44, -2, 88, 36, 38,
501: 0, 9, 0, 62, 63, 0, 0, 60, 65, 0,
502: 71, 73, 69, 56, 57, 0, 81, 0, 154, 0,
503: 0, 0, 0, 0, 0, 0, 0, 169, 170, 171,
504: 172, 0, 91, 46, 48, 51, 124, 54, 0, 59,
505: 0, 0, 89, 124, 76, 80, 10, 0, 18, 94,
506: 64, 125, 67, 0, 58, 0, 0, 0, 0, 0,
507: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
508: 0, 88, 84, 86, 0, 92, 155, 0, 0, 183,
509: 156, 157, 158, 159, 160, 161, 0, 0, 0, 175,
510: 166, 0, 128, 182, 40, 45, 49, 124, 53, 32,
511: 37, 39, 0, 12, 15, 72, 130, 131, 132, 0,
512: 133, 0, 134, 0, 135, 0, 136, 0, 137, 138,
513: 0, 139, 0, 140, 0, 141, 142, 0, 152, 153,
514: 0, 89, 88, 0, 168, 0, 0, 173, 174, 175,
515: 175, 0, 167, 0, 52, 11, 0, 0, 144, 145,
516: 146, 147, 143, 148, 149, 150, 0, 82, 85, 0,
517: 164, 0, 163, 162, 124, 176, 0, 178, 129, 50,
518: 16, 0, 14, 93, 0, 0, 97, 0, 0, 100,
519: 0, 0, 0, 0, 0, 0, 0, 113, 0, 0,
520: 0, 120, 0, 169, 0, 0, 151, 87, 0, 179,
521: 0, 181, 17, 95, 96, 98, 99, 0, 0, 127,
522: 107, 108, 109, 110, 0, 0, 114, 115, 116, 0,
523: 0, 117, 0, 119, 165, 180, 0, 122, 0, 0,
524: 0, 126, 111, 112, 0, 0, 118, 177, 0, 0,
525: 104, 121, 123, 101, 0, 127, 0, 0, 0, 102,
526: 103, 105, 127, 0, 0, 106 };
527:
528:
529:
530:
531:
532:
533:
534:
535:
536:
537: YYSTYPE yyv[150];
538: int yychar = -1;
539: int yynerrs = 0;
540: short yyerrflag = 0;
541:
542: yyparse()
543: { short yys[150];
544: int yyj, yym;
545: register YYSTYPE *yypvt;
546: register int yystate, yyn;
547: register short *yyps;
548: register YYSTYPE *yypv;
549: register short *yyxi;
550:
551: yystate = 0;
552: yychar = -1;
553: yynerrs = 0;
554: yyerrflag = 0;
555: yyps= &yys[-1];
556: yypv= &yyv[-1];
557:
558: yystack:
559:
560: if( ++yyps >= &yys[150] ) {
561: yyerror( "yacc stack overflow" );
562: return(1);
563: }
564: *yyps = yystate;
565: ++yypv;
566: *yypv = yyval;
567: yynewstate:
568: yyn = yypact[yystate];
569: if(yyn <= -1000) goto yydefault;
570: if(yychar<0) {
571: yychar = yylex();
572:
573: if(yychar < 0)
574: yychar = 0;
575: }
576: if((yyn += yychar) < 0 || yyn >= 1176)
577: goto yydefault;
578: if( yychk[ yyn=yyact[ yyn ] ] == yychar ){
579: yychar = -1;
580: yyval = yylval;
581: yystate = yyn;
582: if( yyerrflag > 0 ) --yyerrflag;
583: goto yystack;
584: }
585: yydefault:
586:
587: if( (yyn=yydef[yystate]) == -2 ) {
588: if(yychar < 0) {
589: yychar = yylex();
590:
591: if(yychar < 0)
592: yychar = 0;
593: }
594:
595: for(yyxi=yyexca; (*yyxi!= (-1)) || (yyxi[1]!=yystate);
596: yyxi += 2 ) ;
597: while( *(yyxi+=2) >= 0 ){
598: if( *yyxi == yychar ) break;
599: }
600: if( (yyn = yyxi[1]) < 0 ) return(0);
601: }
602: if( yyn == 0 ){
603:
604: switch( yyerrflag ){
605: case 0:
606:
607: yyerror( "syntax error" );
608:
609: yyerrlab:
610: ++yynerrs;
611: case 1:
612: case 2:
613: yyerrflag = 3;
614:
615: while ( yyps >= yys ) {
616: yyn = yypact[*yyps] + 256;
617: if( yyn>= 0 && yyn < 1176 && yychk[yyact[yyn]] == 256 ){
618: yystate = yyact[yyn];
619: goto yystack;
620: }
621: yyn = yypact[*yyps];
622:
623:
624: --yyps;
625: --yypv;
626: }
627:
628: yyabort:
629: return(1);
630: case 3:
631:
632: if( yychar == 0 ) goto yyabort;
633: yychar = -1;
634: goto yynewstate;
635: }
636: }
637:
638:
639: yyps -= yyr2[yyn];
640: yypvt = yypv;
641: yypv -= yyr2[yyn];
642: yyval = yypv[1];
643: yym=yyn;
644:
645: yyn = yyr1[yyn];
646: yyj = yypgo[yyn] + *yyps + 1;
647: if( yyj>=1176 || yychk[ yystate = yyact[yyj] ] != -yyn ) yystate = yyact[yypgo[yyn]];
648: switch(yym){
649:
650: case 2:
651:
652: {
653:
654: beg_file();
655:
656: ftnend();
657: } break;
658: case 3:
659:
660: { curclass = SNULL; blevel = 0; } break;
661: case 4:
662:
663: { curclass = SNULL; blevel = 0; } break;
664: case 5:
665:
666: { asmout(); curclass = SNULL; blevel = 0; } break;
667: case 6:
668:
669: { yypvt[-1].nodep->in.op = FREE; } break;
670: case 7:
671:
672: { yypvt[-2].nodep->in.op = FREE; } break;
673: case 8:
674:
675: { defid( tymerge(yypvt[-1].nodep,yypvt[-0].nodep),
676: curclass==STATIC?STATIC:EXTDEF ); } break;
677: case 9:
678:
679: {
680: if( blevel ) cerror( "function level error" );
681: if( reached ) retstat |= NRETVAL;
682: yypvt[-3].nodep->in.op = FREE;
683: ftnend();
684: } break;
685: case 10:
686:
687: { regvar = 0; } break;
688: case 11:
689:
690: { curclass = SNULL; yypvt[-2].nodep->in.op = FREE; } break;
691: case 12:
692:
693: { curclass = SNULL; yypvt[-1].nodep->in.op = FREE; } break;
694: case 13:
695:
696: { blevel = 1; } break;
697: case 15:
698:
699: { bccode();
700: locctr(PROG);
701: } break;
702: case 16:
703:
704: { yypvt[-1].nodep->in.op = FREE; } break;
705: case 17:
706:
707: { yypvt[-2].nodep->in.op = FREE; } break;
708: case 20:
709:
710: { yyval.nodep = mkty(INT,0,INT); curclass = SNULL; } break;
711: case 21:
712:
713: { yyval.nodep = yypvt[-0].nodep; } break;
714: case 23:
715:
716: { yyval.nodep = mkty(INT,0,INT); } break;
717: case 24:
718:
719: { curclass = SNULL ; } break;
720: case 25:
721:
722: { yypvt[-2].nodep->in.type = types( yypvt[-2].nodep->in.type, yypvt[-0].nodep->in.type,
723: UNDEF );
724: yypvt[-0].nodep->in.op = FREE;
725: } break;
726: case 26:
727:
728: { curclass = yypvt[-0].intval; } break;
729: case 28:
730:
731: { yypvt[-1].nodep->in.type = types( yypvt[-1].nodep->in.type, yypvt[-0].nodep->in.type, UNDEF );
732: yypvt[-0].nodep->in.op = FREE;
733: } break;
734: case 29:
735:
736: { yypvt[-2].nodep->in.type = types( yypvt[-2].nodep->in.type, yypvt[-1].nodep->in.type, yypvt[-0].nodep->in.type );
737: yypvt[-1].nodep->in.op = yypvt[-0].nodep->in.op = FREE;
738: } break;
739: case 32:
740:
741: { yyval.nodep = dclstruct(yypvt[-4].intval); } break;
742: case 33:
743:
744: { yyval.nodep = rstruct(yypvt[-0].intval,0); stwart = instruct; } break;
745: case 34:
746:
747: { yyval.intval = bstruct(-1,0); stwart = SEENAME; } break;
748: case 35:
749:
750: { yyval.intval = bstruct(yypvt[-0].intval,0); stwart = SEENAME; } break;
751: case 38:
752:
753: { moedef( yypvt[-0].intval ); } break;
754: case 39:
755:
756: { strucoff = yypvt[-0].intval; moedef( yypvt[-2].intval ); } break;
757: case 40:
758:
759: { yyval.nodep = dclstruct(yypvt[-4].intval); } break;
760: case 41:
761:
762: { yyval.nodep = rstruct(yypvt[-0].intval,yypvt[-1].intval); } break;
763: case 42:
764:
765: { yyval.intval = bstruct(-1,yypvt[-0].intval); stwart=0; } break;
766: case 43:
767:
768: { yyval.intval = bstruct(yypvt[-0].intval,yypvt[-1].intval); stwart=0; } break;
769: case 46:
770:
771: { curclass = SNULL; stwart=0; yypvt[-1].nodep->in.op = FREE; } break;
772: case 47:
773:
774: { if( curclass != MOU ){
775: curclass = SNULL;
776: }
777: else {
778: sprintf( fakename, "$%dFAKE", fake++ );
779: defid( tymerge(yypvt[-0].nodep, bdty(2,NIL,
780: lookup( fakename, SMOS ))), curclass );
781: werror("union member must be named");
782: }
783: stwart = 0;
784: yypvt[-0].nodep->in.op = FREE;
785: } break;
786: case 48:
787:
788: { defid( tymerge(yypvt[-1].nodep,yypvt[-0].nodep), curclass);
789: stwart = instruct; } break;
790: case 49:
791:
792: {yyval.nodep=yypvt[-2].nodep;} break;
793: case 50:
794:
795: { defid( tymerge(yypvt[-4].nodep,yypvt[-0].nodep), curclass);
796: stwart = instruct; } break;
797: case 52:
798:
799: { if( !(instruct&INSTRUCT) )
800: uerror( "field outside of structure" );
801: if( yypvt[-0].intval<0 || yypvt[-0].intval >= FIELD ){
802: uerror( "illegal field size" );
803: yypvt[-0].intval = 1;
804: }
805: defid( tymerge(yypvt[-3].nodep,yypvt[-2].nodep), FIELD|yypvt[-0].intval );
806: yyval.nodep = NIL;
807: } break;
808: case 53:
809:
810: { if( !(instruct&INSTRUCT) )
811: uerror( "field outside of structure" );
812:
813: falloc( stab, yypvt[-0].intval, -1, yypvt[-2].nodep );
814: yyval.nodep = NIL;
815: } break;
816: case 54:
817:
818: { yyval.nodep = NIL; } break;
819: case 55:
820:
821: { umul:
822: yyval.nodep = bdty( UNARY 11, yypvt[-0].nodep, 0 ); } break;
823: case 56:
824:
825: { uftn:
826: yyval.nodep = bdty( UNARY CALL, yypvt[-2].nodep, 0 ); } break;
827: case 57:
828:
829: { uary:
830: yyval.nodep = bdty( 54, yypvt[-2].nodep, 0 ); } break;
831: case 58:
832:
833: { bary:
834: if( (int)yypvt[-1].intval <= 0 )
835: werror( "zero or negative subscript" );
836: yyval.nodep = bdty( 54, yypvt[-3].nodep, yypvt[-1].intval ); } break;
837: case 59:
838:
839: { yyval.nodep = bdty( 2, NIL, yypvt[-0].intval ); } break;
840: case 60:
841:
842: { yyval.nodep=yypvt[-1].nodep; } break;
843: case 61:
844:
845: { goto umul; } break;
846: case 62:
847:
848: { goto uftn; } break;
849: case 63:
850:
851: { goto uary; } break;
852: case 64:
853:
854: { goto bary; } break;
855: case 65:
856:
857: { yyval.nodep = yypvt[-1].nodep; } break;
858: case 66:
859:
860: { if (paramno)
861: uerror("arg list in declaration"); } break;
862: case 67:
863:
864: {
865: if( blevel!=0 )
866: uerror(
867: "function declaration in bad context");
868: yyval.nodep = bdty( UNARY CALL, bdty(2,NIL,yypvt[-3].intval), 0 );
869: stwart = 0;
870: } break;
871: case 68:
872:
873: { if (paramno)
874: uerror("arg list in declaration"); } break;
875: case 69:
876:
877: {
878: yyval.nodep = bdty( UNARY CALL, bdty(2,NIL,yypvt[-2].intval), 0 );
879: stwart = 0;
880: } break;
881: case 70:
882:
883: {
884:
885: stwart = SEENAME;
886: if( stab[yypvt[-1].intval].sclass == SNULL )
887: stab[yypvt[-1].intval].stype = FTN;
888: } break;
889: case 71:
890:
891: { ftnarg( yypvt[-0].intval ); stwart = SEENAME; } break;
892: case 72:
893:
894: { ftnarg( yypvt[-0].intval ); stwart = SEENAME; } break;
895: case 75:
896:
897: {yyval.nodep=yypvt[-2].nodep;} break;
898: case 77:
899:
900: { defid( yypvt[-0].nodep = tymerge(yypvt[-1].nodep,yypvt[-0].nodep), curclass);
901: beginit(yypvt[-0].nodep->tn.rval);
902: } break;
903: case 79:
904:
905: { nidcl( tymerge(yypvt[-1].nodep,yypvt[-0].nodep) ); } break;
906: case 80:
907:
908: { defid( tymerge(yypvt[-1].nodep,yypvt[-0].nodep), uclass(curclass) );
909: } break;
910: case 81:
911:
912: { doinit( yypvt[-0].nodep );
913: endinit(); } break;
914: case 82:
915:
916: { endinit(); } break;
917: case 86:
918:
919: { doinit( yypvt[-0].nodep ); } break;
920: case 87:
921:
922: { irbrace(); } break;
923: case 92:
924:
925: { ilbrace(); } break;
926: case 93:
927:
928: {
929: clearst(blevel);
930: if (--blevel == 1)
931: {
932: clearst(blevel);
933: blevel = 0;
934: }
935: checkst(blevel);
936: autooff = *--psavbc;
937: regvar = *--psavbc;
938: } break;
939: case 94:
940:
941: { if( blevel == 1 ) dclargs();
942: uplevel();
943: if( psavbc > &asavbc[BCSZ-2] )
944: cerror( "nesting too deep" );
945: *psavbc++ = regvar;
946: *psavbc++ = autooff;
947: } break;
948: case 95:
949:
950: { ecomp(yypvt[-1].nodep); } break;
951: case 96:
952:
953: { asmout(); } break;
954: case 98:
955:
956: { deflab(yypvt[-1].intval);
957: reached = 1;
958:
959: } break;
960: case 99:
961:
962: { if( yypvt[-1].intval != NOLAB ){
963: deflab( yypvt[-1].intval );
964: reached = 1;
965: }
966:
967: } break;
968: case 100:
969:
970: {
971:
972: } break;
973: case 101:
974:
975: {
976: savebc();
977: if (!reached)
978: werror("loop not entered at top");
979: reached = 1;
980: brklab = getlab();
981: contlab = getlab();
982: switch (wloop_level) {
983: default:
984: cerror("bad while loop code gen value");
985:
986: case LL_TOP:
987: deflab(contlab);
988: if (yypvt[-1].nodep->in.op == 4 && yypvt[-1].nodep->tn.lval) {
989: flostat = FLOOP;
990: tfree(yypvt[-1].nodep);
991: } else {
992: yypvt[-1].nodep->ln.lineno = yypvt[-4].lineno;
993: ecomp(buildtree(CBRANCH, yypvt[-1].nodep,
994: bcon(brklab)));
995: }
996: break;
997: case LL_BOT:
998: if (yypvt[-1].nodep->in.op == 4 && yypvt[-1].nodep->tn.lval) {
999: flostat = FLOOP;
1000: tfree(yypvt[-1].nodep);
1001: deflab(contlab);
1002: } else {
1003: branch(contlab);
1004: deflab(yyval.intval = getlab());
1005: }
1006: break;
1007: case LL_DUP:
1008: if (yypvt[-1].nodep->in.op == 4 && yypvt[-1].nodep->tn.lval) {
1009: flostat = FLOOP;
1010: tfree(yypvt[-1].nodep);
1011: deflab(yyval.intval = contlab);
1012: } else {
1013: register NODE *sav;
1014: extern NODE *treecpy();
1015: sav = treecpy(yypvt[-1].nodep);
1016: ecomp(buildtree(CBRANCH,yypvt[-1].nodep,
1017: bcon(brklab)));
1018: yypvt[-1].nodep = sav;
1019: deflab(yyval.intval = getlab());
1020: }
1021: break;
1022: }
1023: } break;
1024: case 102:
1025:
1026: {
1027: switch (wloop_level) {
1028: default:
1029: cerror("bad while loop code gen. value");
1030:
1031: case LL_TOP:
1032: branch(contlab);
1033: break;
1034: case LL_BOT:
1035: if (flostat & FLOOP)
1036: branch(contlab);
1037: else {
1038: reached = 1;
1039: deflab(contlab);
1040: ecomp(buildtree(CBRANCH,
1041: buildtree(NOT, yypvt[-3].nodep, NIL),
1042: bcon(yypvt[-1].intval)));
1043: }
1044: break;
1045: case LL_DUP:
1046: if (flostat & FLOOP)
1047: branch(contlab);
1048: else {
1049: if (flostat & FCONT) {
1050: reached = 1;
1051: deflab(contlab);
1052: }
1053: ecomp(buildtree(CBRANCH,
1054: buildtree(NOT, yypvt[-3].nodep, NIL),
1055: bcon(yypvt[-1].intval)));
1056: }
1057: break;
1058: }
1059: if ((flostat & FBRK) || !(flostat & FLOOP))
1060: reached = 1;
1061: else
1062: reached = 0;
1063: deflab(brklab);
1064: resetbc(0);
1065:
1066: } break;
1067: case 103:
1068:
1069: { deflab( contlab );
1070: if( flostat & FCONT ) reached = 1;
1071: yypvt[-2].nodep->ln.lineno = yypvt[-4].lineno;
1072: ecomp( buildtree(CBRANCH,
1073: buildtree(NOT, yypvt[-2].nodep, NIL), bcon(yypvt[-6].intval)));
1074: deflab( brklab );
1075: reached = 1;
1076: resetbc(0);
1077:
1078: } break;
1079: case 104:
1080:
1081: {
1082:
1083: } break;
1084: case 105:
1085:
1086: {
1087: if (yypvt[-4].nodep) {
1088: yypvt[-4].nodep->ln.lineno = yypvt[-6].lineno;
1089: ecomp(yypvt[-4].nodep);
1090: } else if (!reached)
1091: werror("loop not entered at top");
1092: savebc();
1093: contlab = getlab();
1094: brklab = getlab();
1095: reached = 1;
1096: switch (floop_level) {
1097: default:
1098: cerror("bad for loop code gen. value");
1099:
1100: case LL_TOP:
1101: deflab(yyval.intval = getlab());
1102: if (!yypvt[-1].nodep)
1103: flostat |= FLOOP;
1104: else if (yypvt[-1].nodep->in.op == 4 && yypvt[-1].nodep->tn.lval) {
1105: flostat |= FLOOP;
1106: tfree(yypvt[-1].nodep);
1107: yypvt[-1].nodep = (NODE *)0;
1108: } else {
1109: if (!yypvt[-4].nodep)
1110: yypvt[-1].nodep->ln.lineno = yypvt[-6].lineno;
1111: ecomp(buildtree(CBRANCH, yypvt[-1].nodep,
1112: bcon(brklab)));
1113: }
1114: break;
1115: case LL_BOT:
1116: if (!yypvt[-1].nodep)
1117: flostat |= FLOOP;
1118: else if (yypvt[-1].nodep->in.op == 4 && yypvt[-1].nodep->tn.lval) {
1119: flostat |= FLOOP;
1120: tfree(yypvt[-1].nodep);
1121: yypvt[-1].nodep = (NODE *)0;
1122: } else
1123: branch(yypvt[-6].intval = getlab());
1124: deflab(yyval.intval = getlab());
1125: break;
1126: case LL_DUP:
1127: if (!yypvt[-1].nodep)
1128: flostat |= FLOOP;
1129: else if (yypvt[-1].nodep->in.op == 4 && yypvt[-1].nodep->tn.lval) {
1130: flostat |= FLOOP;
1131: tfree(yypvt[-1].nodep);
1132: yypvt[-1].nodep = (NODE *)0;
1133: } else {
1134: register NODE *sav;
1135: extern NODE *treecpy();
1136: sav = treecpy(yypvt[-1].nodep);
1137: ecomp(buildtree(CBRANCH, yypvt[-1].nodep,
1138: bcon(brklab)));
1139: yypvt[-1].nodep = sav;
1140: }
1141: deflab(yyval.intval = getlab());
1142: break;
1143: }
1144: } break;
1145: case 106:
1146:
1147: {
1148: if (flostat & FCONT) {
1149: deflab(contlab);
1150: reached = 1;
1151: }
1152: if (yypvt[-2].nodep)
1153: yypvt[-2].nodep->ln.lineno = lineno, ecomp(yypvt[-2].nodep);
1154: switch (floop_level) {
1155: default:
1156: cerror("bad for loop code gen. value");
1157:
1158: case LL_TOP:
1159: branch(yypvt[-3].intval);
1160: break;
1161: case LL_BOT:
1162: if (yypvt[-5].nodep)
1163: deflab(yypvt[-10].intval);
1164:
1165: case LL_DUP:
1166: if (yypvt[-5].nodep) {
1167: ecomp(buildtree(CBRANCH,
1168: buildtree(NOT, yypvt[-5].nodep, NIL),
1169: bcon(yypvt[-3].intval)));
1170: } else
1171: branch(yypvt[-3].intval);
1172: break;
1173: }
1174: deflab(brklab);
1175: if ((flostat & FBRK) || !(flostat & FLOOP))
1176: reached = 1;
1177: else
1178: reached = 0;
1179: resetbc(0);
1180:
1181: } break;
1182: case 107:
1183:
1184: { if( reached ) branch( brklab );
1185: deflab( yypvt[-1].intval );
1186: swend();
1187: deflab(brklab);
1188: if( (flostat&FBRK) || !(flostat&FDEF) ) reached=1;
1189: resetbc(FCONT);
1190:
1191: } break;
1192: case 108:
1193:
1194: { if( brklab == NOLAB ) uerror( "illegal break");
1195: else if(reached) {
1196: slineno = yypvt[-1].lineno; dbline();
1197: branch( brklab );
1198: }
1199: flostat |= FBRK;
1200: if( brkflag ) goto rch;
1201: reached = 0;
1202: } break;
1203: case 109:
1204:
1205: { if( contlab == NOLAB ) uerror( "illegal continue");
1206: else {
1207: slineno = yypvt[-1].lineno; dbline();
1208: branch( contlab );
1209: }
1210: flostat |= FCONT;
1211: goto rch;
1212: } break;
1213: case 110:
1214:
1215: { retstat |= NRETVAL;
1216: slineno = yypvt[-1].lineno; dbline();
1217: branch( retlab );
1218: rch:
1219: if( !reached ) werror( "statement not reached");
1220: reached = 0;
1221: } break;
1222: case 111:
1223:
1224: { register NODE *temp;
1225: TWORD indtype();
1226: idname = curftn;
1227: temp = buildtree( 2, NIL, NIL );
1228: temp->in.type = DECREF(temp->in.type);
1229: if(temp->in.type == (FTN|VOID))
1230: uerror(
1231: "void function %s cannot return value",
1232: stab[idname].sname);
1233: temp->tn.op = RNODE;
1234: yypvt[-1].nodep = makety( yypvt[-1].nodep, temp->fn.type,
1235: temp->fn.cdim, temp->fn.csiz );
1236: temp->in.type = indtype( temp->in.type );
1237: temp = buildtree( 58, temp, yypvt[-1].nodep );
1238: temp->ln.lineno = yypvt[-2].lineno;
1239: ecomp( temp );
1240: retstat |= RETVAL;
1241: branch( retlab );
1242: reached = 0;
1243: } break;
1244: case 112:
1245:
1246: { register NODE *q;
1247: q = block( FREE, NIL, NIL, INT|ARY, 0, INT );
1248: q->tn.rval = idname = yypvt[-1].intval;
1249: defid( q, ULABEL );
1250: stab[idname].suse = -lineno;
1251: slineno = yypvt[-2].lineno; dbline();
1252: branch( stab[idname].offset );
1253: goto rch;
1254: } break;
1255: case 117:
1256:
1257: { register NODE *q;
1258: q = block( FREE, NIL, NIL, INT|ARY, 0, LABEL );
1259: q->tn.rval = yypvt[-1].intval;
1260: defid( q, LABEL );
1261: reached = 1;
1262: } break;
1263: case 118:
1264:
1265: { addcase(yypvt[-1].nodep);
1266: reached = 1;
1267: } break;
1268: case 119:
1269:
1270: { reached = 1;
1271: adddef();
1272: flostat |= FDEF;
1273: } break;
1274: case 120:
1275:
1276: { savebc();
1277: if( !reached ) werror( "loop not entered at top");
1278: brklab = getlab();
1279: contlab = getlab();
1280: deflab( yyval.intval = getlab() );
1281: reached = 1;
1282:
1283: } break;
1284: case 121:
1285:
1286: { yypvt[-1].nodep->ln.lineno = yypvt[-3].lineno;
1287: ecomp(buildtree(CBRANCH, yypvt[-1].nodep, bcon(yyval.intval=getlab()))) ;
1288: reached = 1;
1289:
1290: } break;
1291: case 122:
1292:
1293: { if( reached ) branch( yyval.intval = getlab() );
1294: else yyval.intval = NOLAB;
1295: deflab( yypvt[-2].intval );
1296: reached = 1;
1297: } break;
1298: case 123:
1299:
1300: { register NODE *temp;
1301: savebc();
1302: temp = block( SNODE, NIL, NIL, INT, 0, INT );
1303: temp = buildtree( 58, temp, yypvt[-1].nodep );
1304:
1305: brklab = getlab();
1306: temp->ln.lineno = yypvt[-3].lineno;
1307: ecomp( temp );
1308: branch( yyval.intval = getlab() );
1309: swstart();
1310: reached = 0;
1311:
1312: } break;
1313: case 124:
1314:
1315: { yyval.intval=instruct; stwart=instruct=0; } break;
1316: case 125:
1317:
1318: { yyval.intval = icons( yypvt[-0].nodep ); instruct=yypvt[-1].intval; } break;
1319: case 127:
1320:
1321: { yyval.nodep = 0; } break;
1322: case 129:
1323:
1324: { goto bop; } break;
1325: case 130:
1326:
1327: {
1328: preconf:
1329: if( yychar==26 || yychar==27 || yychar==14
1330: || yychar==17 || yychar==19 ){
1331: precplaint:
1332: if( hflag ) werror(
1333: "precedence confusion possible: parenthesize!"
1334: );
1335: }
1336: bop:
1337: yyval.nodep = buildtree( yypvt[-1].intval, yypvt[-2].nodep, yypvt[-0].nodep );
1338: } break;
1339: case 131:
1340:
1341: { yypvt[-1].intval = COMOP;
1342: goto bop;
1343: } break;
1344: case 132:
1345:
1346: { goto bop; } break;
1347: case 133:
1348:
1349: { if(yychar==29) goto precplaint; else goto bop; } break;
1350: case 134:
1351:
1352: { if(yychar==29 ) goto precplaint; else goto bop; } break;
1353: case 135:
1354:
1355: { if(yychar==6||yychar==8) goto precplaint; else goto bop; } break;
1356: case 136:
1357:
1358: { goto bop; } break;
1359: case 137:
1360:
1361: { goto preconf; } break;
1362: case 138:
1363:
1364: { if( yychar==26||yychar==27 ) goto preconf; else goto bop; } break;
1365: case 139:
1366:
1367: { if(yychar==26||yychar==27) goto preconf; else goto bop; } break;
1368: case 140:
1369:
1370: { if(yychar==26||yychar==27) goto preconf; else goto bop; } break;
1371: case 141:
1372:
1373: { goto bop; } break;
1374: case 142:
1375:
1376: { goto bop; } break;
1377: case 143:
1378:
1379: { abop:
1380: yyval.nodep = buildtree( ASG yypvt[-2].intval, yypvt[-3].nodep, yypvt[-0].nodep );
1381: } break;
1382: case 144:
1383:
1384: { goto abop; } break;
1385: case 145:
1386:
1387: { goto abop; } break;
1388: case 146:
1389:
1390: { goto abop; } break;
1391: case 147:
1392:
1393: { goto abop; } break;
1394: case 148:
1395:
1396: { goto abop; } break;
1397: case 149:
1398:
1399: { goto abop; } break;
1400: case 150:
1401:
1402: { goto abop; } break;
1403: case 151:
1404:
1405: { yyval.nodep=buildtree(21, yypvt[-4].nodep, buildtree( 22, yypvt[-2].nodep, yypvt[-0].nodep ) );
1406: } break;
1407: case 152:
1408:
1409: { werror( "old-fashioned assignment operator" );
1410: goto bop; } break;
1411: case 153:
1412:
1413: { goto bop; } break;
1414: case 155:
1415:
1416: { yyval.nodep = buildtree( yypvt[-0].intval, yypvt[-1].nodep, bcon(1) ); } break;
1417: case 156:
1418:
1419: { ubop:
1420: yyval.nodep = buildtree( UNARY yypvt[-1].intval, yypvt[-0].nodep, NIL );
1421: } break;
1422: case 157:
1423:
1424: {
1425:
1426: if( ISFTN(yypvt[-0].nodep->in.type) || ISARY(yypvt[-0].nodep->in.type) ){
1427: werror( "& before array or function: ignored" );
1428: yyval.nodep = yypvt[-0].nodep;
1429: }
1430: else goto ubop;
1431: } break;
1432: case 158:
1433:
1434: { goto ubop; } break;
1435: case 159:
1436:
1437: {
1438: yyval.nodep = buildtree( yypvt[-1].intval, yypvt[-0].nodep, NIL );
1439: } break;
1440: case 160:
1441:
1442: { yyval.nodep = buildtree( yypvt[-1].intval==INCR ? ASG 6 : ASG 8,
1443: yypvt[-0].nodep,
1444: bcon(1) );
1445: } break;
1446: case 161:
1447:
1448: { yyval.nodep = doszof( yypvt[-0].nodep ); } break;
1449: case 162:
1450:
1451: { yyval.nodep = buildtree( CAST, yypvt[-2].nodep, yypvt[-0].nodep );
1452: yyval.nodep->in.left->in.op = FREE;
1453: yyval.nodep->in.op = FREE;
1454: yyval.nodep = yyval.nodep->in.right;
1455: } break;
1456: case 163:
1457:
1458: { yyval.nodep = doszof( yypvt[-1].nodep ); } break;
1459: case 164:
1460:
1461: { yyval.nodep = buildtree( 54, yypvt[-3].nodep, yypvt[-1].nodep ); } break;
1462: case 165:
1463:
1464: { yyval.nodep = xicolon( yypvt[-5].nodep, yypvt[-3].nodep, yypvt[-1].nodep ); } break;
1465: case 166:
1466:
1467: { yyval.nodep=buildtree(UNARY CALL,yypvt[-1].nodep,NIL);
1468: } break;
1469: case 167:
1470:
1471: { yyval.nodep=buildtree(CALL,yypvt[-2].nodep,yypvt[-1].nodep); } break;
1472: case 168:
1473:
1474: { if( yypvt[-1].intval == DOT ){
1475: if( notlval( yypvt[-2].nodep ) )werror(
1476: "structure reference must be addressable"
1477: );
1478: yypvt[-2].nodep = buildtree( UNARY 14, yypvt[-2].nodep, NIL );
1479: }
1480: idname = yypvt[-0].intval;
1481: yyval.nodep = buildtree( STREF, yypvt[-2].nodep,
1482: buildtree( 2, NIL, NIL ) );
1483: } break;
1484: case 169:
1485:
1486: { idname = yypvt[-0].intval;
1487:
1488: if( blevel==0 && stab[idname].stype == UNDEF ) {
1489: register NODE *q;
1490: werror( "undeclared initializer name %s",
1491: stab[idname].sname );
1492: q = block( FREE, NIL, NIL, INT, 0, INT );
1493: q->tn.rval = idname;
1494: defid( q, EXTERN );
1495: }
1496: yyval.nodep=buildtree(2,NIL,NIL);
1497: stab[yypvt[-0].intval].suse = -lineno;
1498: } break;
1499: case 170:
1500:
1501: { yyval.nodep=bcon(0);
1502: yyval.nodep->tn.lval = lastcon;
1503: yyval.nodep->tn.rval = NONAME;
1504: if( yypvt[-0].intval ) yyval.nodep->fn.csiz = yyval.nodep->in.type = ctype(LONG);
1505: } break;
1506: case 171:
1507:
1508: { yyval.nodep=buildtree(5,NIL,NIL);
1509: yyval.nodep->fpn.dval = dcon;
1510: } break;
1511: case 172:
1512:
1513: { yyval.nodep = getstr(); } break;
1514: case 173:
1515:
1516: { yyval.nodep=yypvt[-1].nodep; } break;
1517: case 174:
1518:
1519: {
1520: yyva
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.