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