# 2.11BSD#431 - /usr/src/lib/mip/fort.c

##### Functions

    lccopy            X
    lcread            X
    lnread            X
    lopen             X
    lread             X
    mainp2            X

##### Variables

    fsp               X
    fstack            X

##### Macros

    FIXINT            X
    FOP               X
    FORT              X
    NSTACKSZ          X
    REST              X
    VAL               X

       1: #if !defined(lint) && defined(DOSCCS)
       2: static char *sccsid ="@(#)fort.c	4.7.1 (2.11BSD GTE) 1/17/95";
       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[128];
      95:     if( n > 0 ){
      96:         if( n > sizeof(fbuf)/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: OFFSZ offsz;
     114: OFFSZ 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:     }

#### Defined functions

lccopy defined in line 92; used 1 times

- in line 147

lcread defined in line 84; used 4 times

- in line 189, 215, 229, 251

lnread defined in line 43; used 3 times

- in line 191, 217, 231

lopen defined in line 73; used 2 times

- in line 130-132(2)

lread defined in line 65; used 8 times

- in line 138, 152, 178, 186, 212, 227, 295-296(2)

mainp2 defined in line 115; never used

#### Defined variables

fsp defined in line 111; used 8 times

- in line 134, 203-204(2), 252-253(2), 308-313(3)

fstack defined in line 110; used 5 times

- in line 134, 204, 252-256(3)

sccsid defined in line 2; never used

#### Defined macros

FIXINT defined in line 34; used 6 times

- in line 27, 184, 210, 224, 238, 303

FOP defined in line 16; used 4 times

- in line 15, 140-141(2), 302

FORT defined in line 6; used 1 times

- in line 5

NSTACKSZ defined in line 108; used 2 times

- in line 110, 204

REST defined in line 24; used 12 times

- in line 23, 140, 154-157(2), 184, 210, 224, 238, 250, 275, 281, 303

VAL defined in line 20; used 13 times

- in line 19, 140, 147, 153, 178, 187, 212, 225, 239, 251(2), 271, 280

Last modified: 1995-01-18 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1548 |