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