![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fort.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / cmd / sun / mip|
Return to fort.c CVS log | Up to [Research Unix] / researchv9 / cmd / sun / mip |
1.1 root 1: #ifndef lint
2: static char sccsid[] = "@(#)fort.c 1.1 86/02/03 SMI";
3: #endif
4:
5: # define FORT
6: /* this forces larger trees, etc. */
7: # include "cpass2.h"
8: # include "fort.h"
9:
10: /* masks for unpacking longs */
11:
12: # ifndef FOP
13: # define FOP(x) (int)((x)&0377)
14: # endif
15:
16: # ifndef VAL
17: # define VAL(x) (int)(((x)>>8)&0377)
18: # endif
19:
20: # ifndef REST
21: # define REST(x) (((x)>>16)&0177777)
22: # endif
23:
24: FILE * lrd; /* for default reading routines */
25:
26: # ifndef NOLNREAD
27: #ifdef FLEXNAMES
28: char *
29: lnread()
30: {
31: char buf[BUFSIZ];
32: register char *cp = buf;
33: register char *limit = &buf[BUFSIZ];
34:
35: for (;;) {
36: if (fread(cp, sizeof (long), 1, lrd) != 1)
37: cerror("intermediate file read error");
38: cp += sizeof (long);
39: if (cp[-1] == 0)
40: break;
41: if (cp >= limit)
42: cerror("lnread overran string buffer");
43: }
44: return (tstr(buf));
45: }
46: #endif FLEXNAMES
47: # endif NOLNREAD
48:
49: # ifndef NOLREAD
50: long lread(){
51: static long x;
52: if( fread( (char *) &x, 4, 1, lrd ) <= 0 ) cerror( "intermediate file read error" );
53: return( x );
54: }
55: # endif
56:
57: # ifndef NOLOPEN
58: lopen( s ) char *s; {
59: /* if null, opens the standard input */
60: if( *s ){
61: lrd = fopen( s, "r" );
62: if( lrd == NULL ) cerror( "cannot open intermediate file %s", s );
63: }
64: else lrd = stdin;
65: }
66: # endif
67:
68: # ifndef NOLCREAD
69: lcread( cp, n ) char *cp; {
70: if( n > 0 ){
71: if( fread( cp, 4, n, lrd ) != n ) cerror( "intermediate file read error" );
72: }
73: }
74: # endif
75:
76: # ifndef NOLCCOPY
77: lccopy( n ) register n; {
78: register i;
79: static char fbuf[32*4];
80: if( n > 0 ){
81: while ( n > 32){
82: if ( fread( fbuf, 4, 32, lrd ) != 32)
83: cerror( "intermediate file read error" );
84: if ( fwrite( fbuf, 4, 32, stdout ) != 32 )
85: cerror( "output file error" );
86: n -= 32;
87: }
88: if( fread( fbuf, 4, n, lrd ) != n )
89: cerror( "intermediate file read error" );
90: for( i=4*n; fbuf[i-1] == '\0' && i>0; --i ) { /* VOID */ }
91: if( i ) {
92: if( fwrite( fbuf, 1, i, stdout ) != i ) cerror( "output file error" );
93: }
94: }
95: }
96: # endif
97:
98: /* new opcode definitions */
99:
100: # define FORTOPS 200
101: # define FTEXT 200
102: # define FEXPR 201
103: # define FSWITCH 202
104: # define FLBRAC 203
105: # define FRBRAC 204
106: # define FEOF 205
107: # define FARIF 206
108: # define LABEL 207
109:
110: /* code generator flags */
111:
112: # define ENTRY_FLAG 0x1
113: # define CHECK_FLAG 0x2
114:
115: /* stack for reading nodes in postfix form */
116:
117: # define NSTACKSZ 250
118:
119: NODE * fstack[NSTACKSZ];
120: NODE ** fsp; /* points to next free position on the stack */
121:
122: unsigned int offsz;
123: unsigned int caloff();
124: mainp2( argc, argv ) char *argv[]; {
125: int files;
126: register long x;
127: register NODE *p;
128: int flags;
129:
130: offsz = caloff();
131: files = p2init( argc, argv );
132: tinit();
133:
134:
135: if( files ){
136: while( files < argc && argv[files][0] == '-' ) {
137: ++files;
138: }
139: if( files > argc ) return( nerrors );
140: lopen( argv[files] );
141: }
142: else lopen( "" );
143:
144: fsp = fstack;
145:
146: for(;;){
147: /* read nodes, and go to work... */
148: x = lread();
149:
150: if( xdebug ) fprintf( stderr, "op=%d, val = %d, rest = 0%o\n", FOP(x), VAL(x), (int)REST(x) );
151: switch( (int)FOP(x) ){ /* switch on opcode */
152:
153: case 0:
154: fprintf( stderr, "null opcode ignored\n" );
155: continue;
156: case FTEXT:
157: lccopy( VAL(x) );
158: putchar('\n');
159: continue;
160:
161: case FLBRAC:
162: flags = VAL(x);
163: ftnno = REST(x);
164: maxtreg = lread();
165: tmpoff = baseoff = lread();
166: if (tmpoff%ALSTACK)
167: cerror("intermediate file-stack misalignment");
168: /* enable/disable range checking */
169: if( flags & CHECK_FLAG ){
170: chk_ovfl = 1;
171: } else {
172: chk_ovfl = 0;
173: }
174: if( flags & ENTRY_FLAG ){
175: /* beginning of function */
176: maxoff = baseoff;
177: maxtemp = 0;
178: saveregs();
179: }
180: else {
181: if( baseoff > maxoff ) maxoff = baseoff;
182: /* maxoff at end of ftn is max of autos and temps
183: over all blocks in the function */
184: }
185: setregs();
186: continue;
187:
188: case FRBRAC:
189: SETOFF( maxoff, ALSTACK );
190: eobl2();
191: continue;
192:
193: case FEOF:
194: return( nerrors );
195:
196: case FSWITCH:
197: uerror( "switch not yet done" );
198: for( x=VAL(x); x>0; --x ) lread();
199: continue;
200:
201: case FCON: /* floating point constant */
202: p = talloc();
203: p->in.op = FCON;
204: p->fpn.type = REST(x);
205: lcread( (char*)&p->fpn.dval, 2 );
206: goto bump;
207:
208: case ICON:
209: p = talloc();
210: p->in.op = ICON;
211: p->in.type = REST(x);
212: p->tn.rval = 0;
213: p->tn.lval = lread();
214: if( VAL(x) ){
215: #ifndef FLEXNAMES
216: lcread( p->in.name, 2 );
217: #else
218: p->in.name = lnread();
219: #endif
220: }
221: #ifndef FLEXNAMES
222: else p->in.name[0] = '\0';
223: #else
224: else p->in.name = "";
225: #endif
226:
227: bump:
228: /* p->in.su = 0; */
229: p->in.rall = NOPREF;
230: *fsp++ = p;
231: if( fsp >= &fstack[NSTACKSZ] ) uerror( "expression depth exceeded" );
232: continue;
233:
234: case NAME:
235: p = talloc();
236: p->in.op = NAME;
237: p->in.type = REST(x);
238: p->tn.rval = 0;
239: if( VAL(x) ) p->tn.lval = lread();
240: else p->tn.lval = 0;
241: #ifndef FLEXNAMES
242: lcread( p->in.name, 2 );
243: #else
244: p->in.name = lnread();
245: #endif
246: goto bump;
247:
248: case OREG:
249: p = talloc();
250: p->in.op = OREG;
251: p->in.type = REST(x);
252: p->tn.rval = VAL(x);
253: p->tn.lval = lread();
254: #ifndef FLEXNAMES
255: lcread( p->in.name, 2 );
256: #else
257: p->in.name = lnread();
258: #endif
259: goto bump;
260:
261: case REG:
262: p = talloc();
263: p->in.op = REG;
264: p->in.type = REST(x);
265: p->tn.rval = VAL(x);
266: rbusy( p->tn.rval, p->in.type );
267: p->tn.lval = 0;
268: #ifndef FLEXNAMES
269: p->in.name[0] = '\0';
270: #else
271: p->in.name = "";
272: #endif
273: goto bump;
274:
275: case FEXPR:
276: lineno = REST(x);
277: if( VAL(x) ) lcread( filename, VAL(x) );
278: if( fsp == fstack ) continue; /* filename only */
279: if( --fsp != fstack ) uerror( "expression poorly formed" );
280: if( lflag ) lineid( lineno, filename );
281: tmpoff = baseoff;
282: p = fstack[0];
283: if( edebug ) fwalk( p, eprint, 0 );
284: # ifdef MYREADER
285: MYREADER(p);
286: # endif
287:
288: nrecur = 0;
289: delay( p );
290: reclaim( p, RNULL, 0 );
291:
292: allchk();
293: tcheck();
294: continue;
295:
296: case LABEL:
297: if( VAL(x) ){
298: tlabel();
299: }
300: else {
301: label( (int) REST(x) );
302: }
303: continue;
304:
305: case GOTO:
306: if( VAL(x) ) {
307: branch( (int) REST(x) );
308: continue;
309: }
310: /* otherwise, treat as unary */
311: goto def;
312:
313: case EQ:
314: case NE:
315: case LT:
316: case LE:
317: case GT:
318: case GE:
319: case ULT:
320: case ULE:
321: case UGT:
322: case UGE:
323: p = talloc();
324: p->bn.op = FOP(x);
325: p->bn.type = REST(x);
326: p->bn.reversed = 0;
327: p->in.right = *--fsp;
328: p->in.left = *--fsp;
329: goto bump;
330:
331: case STASG:
332: case STARG:
333: case STCALL:
334: case UNARY STCALL:
335: /*
336: * size and alignment come from next long words
337: */
338: p = talloc();
339: p -> stn.stsize = lread();
340: p -> stn.stalign = lread();
341: goto defa;
342: default:
343: def:
344: p = talloc();
345: defa:
346: p->in.op = FOP(x);
347: p->in.type = REST(x);
348:
349: switch( optype( p->in.op ) ){
350:
351: case BITYPE:
352: p->in.right = *--fsp;
353: p->in.left = *--fsp;
354: goto bump;
355:
356: case UTYPE:
357: p->in.left = *--fsp;
358: p->tn.rval = 0;
359: goto bump;
360:
361: case LTYPE:
362: uerror( "illegal leaf node: %d", p->in.op );
363: exit( 1 );
364: }
365: }
366: }
367: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.