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