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