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