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