![[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] / 43BSD / lib / mip|
Return to fort.c CVS log | Up to [CSRG BSD Unix] / 43BSD / lib / mip |
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 n; { ! 93: register 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: tmpoff = baseoff = lread(); ! 153: maxtreg = VAL(x); ! 154: if( ftnno != REST(x) ){ ! 155: /* beginning of function */ ! 156: maxoff = baseoff; ! 157: ftnno = REST(x); ! 158: maxtemp = 0; ! 159: } ! 160: else { ! 161: if( baseoff > maxoff ) maxoff = baseoff; ! 162: /* maxoff at end of ftn is max of autos and temps ! 163: over all blocks in the function */ ! 164: } ! 165: setregs(); ! 166: continue; ! 167: ! 168: case FRBRAC: ! 169: SETOFF( maxoff, ALSTACK ); ! 170: eobl2(); ! 171: continue; ! 172: ! 173: case FEOF: ! 174: return( nerrors ); ! 175: ! 176: case FSWITCH: ! 177: uerror( "switch not yet done" ); ! 178: for( x=VAL(x); x>0; --x ) lread(); ! 179: continue; ! 180: ! 181: case ICON: ! 182: p = talloc(); ! 183: p->in.op = ICON; ! 184: p->in.type = FIXINT(REST(x)); ! 185: p->tn.rval = 0; ! 186: p->tn.lval = lread(); ! 187: if( VAL(x) ){ ! 188: #ifndef FLEXNAMES ! 189: lcread( p->in.name, 2 ); ! 190: #else ! 191: p->in.name = lnread(); ! 192: #endif ! 193: } ! 194: #ifndef FLEXNAMES ! 195: else p->in.name[0] = '\0'; ! 196: #else ! 197: else p->in.name = ""; ! 198: #endif ! 199: ! 200: bump: ! 201: p->in.su = 0; ! 202: p->in.rall = NOPREF; ! 203: *fsp++ = p; ! 204: if( fsp >= &fstack[NSTACKSZ] ) uerror( "expression depth exceeded" ); ! 205: continue; ! 206: ! 207: case NAME: ! 208: p = talloc(); ! 209: p->in.op = NAME; ! 210: p->in.type = FIXINT(REST(x)); ! 211: p->tn.rval = 0; ! 212: if( VAL(x) ) p->tn.lval = lread(); ! 213: else p->tn.lval = 0; ! 214: #ifndef FLEXNAMES ! 215: lcread( p->in.name, 2 ); ! 216: #else ! 217: p->in.name = lnread(); ! 218: #endif ! 219: goto bump; ! 220: ! 221: case OREG: ! 222: p = talloc(); ! 223: p->in.op = OREG; ! 224: p->in.type = FIXINT(REST(x)); ! 225: p->tn.rval = VAL(x); ! 226: rbusy( p->tn.rval, PTR | p->in.type ); ! 227: p->tn.lval = lread(); ! 228: #ifndef FLEXNAMES ! 229: lcread( p->in.name, 2 ); ! 230: #else ! 231: p->in.name = lnread(); ! 232: #endif ! 233: goto bump; ! 234: ! 235: case REG: ! 236: p = talloc(); ! 237: p->in.op = REG; ! 238: p->in.type = FIXINT(REST(x)); ! 239: p->tn.rval = VAL(x); ! 240: rbusy( p->tn.rval, p->in.type ); ! 241: p->tn.lval = 0; ! 242: #ifndef FLEXNAMES ! 243: p->in.name[0] = '\0'; ! 244: #else ! 245: p->in.name = ""; ! 246: #endif ! 247: goto bump; ! 248: ! 249: case FEXPR: ! 250: lineno = REST(x); ! 251: if( VAL(x) ) lcread( filename, VAL(x) ); ! 252: if( fsp == fstack ) continue; /* filename only */ ! 253: if( --fsp != fstack ) uerror( "expression poorly formed" ); ! 254: if( lflag ) lineid( lineno, filename ); ! 255: tmpoff = baseoff; ! 256: p = fstack[0]; ! 257: if( edebug ) fwalk( p, eprint, 0 ); ! 258: # ifdef MYREADER ! 259: MYREADER(p); ! 260: # endif ! 261: ! 262: nrecur = 0; ! 263: delay( p ); ! 264: reclaim( p, RNULL, 0 ); ! 265: ! 266: allchk(); ! 267: tcheck(); ! 268: continue; ! 269: ! 270: case FLABEL: ! 271: if( VAL(x) ){ ! 272: tlabel(); ! 273: } ! 274: else { ! 275: label( (int) REST(x) ); ! 276: } ! 277: continue; ! 278: ! 279: case GOTO: ! 280: if( VAL(x) ) { ! 281: cbgen( 0, (int) REST(x), 'I' ); /* unconditional branch */ ! 282: continue; ! 283: } ! 284: /* otherwise, treat as unary */ ! 285: goto def; ! 286: ! 287: case STASG: ! 288: case STARG: ! 289: case STCALL: ! 290: case UNARY STCALL: ! 291: /* ! 292: * size and alignment come from next long words ! 293: */ ! 294: p = talloc(); ! 295: p -> stn.stsize = lread(); ! 296: p -> stn.stalign = lread(); ! 297: goto defa; ! 298: default: ! 299: def: ! 300: p = talloc(); ! 301: defa: ! 302: p->in.op = FOP(x); ! 303: p->in.type = FIXINT(REST(x)); ! 304: ! 305: switch( optype( p->in.op ) ){ ! 306: ! 307: case BITYPE: ! 308: p->in.right = *--fsp; ! 309: p->in.left = *--fsp; ! 310: goto bump; ! 311: ! 312: case UTYPE: ! 313: p->in.left = *--fsp; ! 314: p->tn.rval = 0; ! 315: goto bump; ! 316: ! 317: case LTYPE: ! 318: uerror( "illegal leaf node: %d", p->in.op ); ! 319: exit( 1 ); ! 320: } ! 321: } ! 322: } ! 323: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.