[unix-history] / usr / src / old / pcc / mip / fort.c

#ifndef lint
static char *sccsid ="@(#)fort.c	4.8 (Berkeley) 10/15/86";
#endif lint

# ifndef FORT
# define FORT
/* this may force larger trees, etc. */
# endif

# include "pass2.h"
# include "fort.h"

/*	masks for unpacking longs */

# ifndef FOP
# define FOP(x) (int)((x)&0377)
# endif

# ifndef VAL
# define VAL(x) (int)(((x)>>8)&0377)
# endif

# ifndef REST
# define REST(x) (((x)>>16)&0177777)
# endif

# ifndef FIXINT
# if SZINT == SZLONG
# define FIXINT(x) ((x) == LONG || (x) == ULONG ? (x) - 1 : (x))
# else
# if SZINT == SZSHORT
# define FIXINT(x) ((x) == SHORT || (x) == USHORT ? (x) + 1 : (x))
# else
# define FIXINT(x) (x)
# endif
# endif
# endif

FILE * lrd;  /* for default reading routines */

# if !defined(NOLNREAD) && defined(FLEXNAMES)
char *
lnread()
{
	char buf[BUFSIZ];
	register char *cp = buf;
	register char *limit = &buf[BUFSIZ];

	for (;;) {
		if (fread(cp, sizeof (long), 1, lrd) !=  1)
			cerror("intermediate file read error");
		cp += sizeof (long);
		if (cp[-1] == 0)
			break;
		if (cp >= limit)
			cerror("lnread overran string buffer");
	}
	return (tstr(buf));
}
#endif

# ifndef NOLREAD
long lread(){
	static long x;
	if( fread( (char *) &x, 4, 1, lrd ) <= 0 ) cerror( "intermediate file read error" );
	return( x );
	}
# endif

# ifndef NOLOPEN
lopen( s ) char *s; {
	/* if null, opens the standard input */
	if( *s ){
		lrd = fopen( s, "r" );
		if( lrd == NULL ) cerror( "cannot open intermediate file %s", s );
		}
	else  lrd = stdin;
	}
# endif

# ifndef NOLCREAD
lcread( cp, n ) char *cp; {
	if( n > 0 ){
		if( fread( cp, 4, n, lrd ) != n ) cerror( "intermediate file read error" );
		}
	}
# endif

# ifndef NOLCCOPY
lccopy( n ) register n; {
	register i;
	static char fbuf[BUFSIZ];
	if( n > 0 ){
		if( n > BUFSIZ/4 ) cerror( "lccopy asked to copy too much" );
		if( fread( fbuf, 4, n, lrd ) != n ) cerror( "intermediate file read error" );
		for( i=4*n; fbuf[i-1] == '\0' && i>0; --i ) { /* VOID */ }
		if( i ) {
			if( fwrite( fbuf, 1, i, stdout ) != i ) cerror( "output file error" );
			}
		}
	}
# endif

/*	stack for reading nodes in postfix form */

# define NSTACKSZ 250

NODE * fstack[NSTACKSZ];
NODE ** fsp;  /* points to next free position on the stack */

unsigned int offsz;
unsigned int caloff();
mainp2( argc, argv ) char *argv[]; {
	int files;
	register long x;
	register NODE *p;

	offsz = caloff();
	files = p2init( argc, argv );
	tinit();

		
	if( files ){
		while( files < argc && argv[files][0] == '-' ) {
			++files;
			}
		if( files > argc ) return( nerrors );
		lopen( argv[files] );
		}
	else lopen( "" );

	fsp = fstack;

	for(;;){
		/* read nodes, and go to work... */
		x = lread();

	if( xdebug ) fprintf( stderr, "op=%d, val = %d, rest = 0%o\n", FOP(x), VAL(x), (int)REST(x) );
		switch( (int)FOP(x) ){  /* switch on opcode */

		case 0:
			fprintf( stderr, "null opcode ignored\n" );
			continue;
		case FTEXT:
			lccopy( VAL(x) );
			printf( "\n" );
			continue;

		case FLBRAC:
			tmpoff = baseoff = lread();
			maxtreg = VAL(x);
			if( ftnno != REST(x) ){
				/* beginning of function */
				maxoff = baseoff;
				ftnno = REST(x);
				maxtemp = 0;
				}
			else {
				if( baseoff > maxoff ) maxoff = baseoff;
				/* maxoff at end of ftn is max of autos and temps 
				   over all blocks in the function */
				}
			setregs();
			continue;

		case FRBRAC:
			SETOFF( maxoff, ALSTACK );
			eobl2();
			continue;

		case FEOF:
			return( nerrors );

		case FSWITCH:
			uerror( "switch not yet done" );
			for( x=VAL(x); x>0; --x ) lread();
			continue;

		case ICON:
			p = talloc();
			p->in.op = ICON;
			p->in.type = FIXINT(REST(x));
			p->tn.rval = 0;
			p->tn.lval = lread();
			if( VAL(x) ){
#ifndef FLEXNAMES
				lcread( p->in.name, 2 );
#else
				p->in.name = lnread();
#endif
				}
#ifndef FLEXNAMES
			else p->in.name[0] = '\0';
#else
			else p->in.name = "";
#endif

		bump:
			p->in.su = 0;
			p->in.rall = NOPREF;
			*fsp++ = p;
			if( fsp >= &fstack[NSTACKSZ] ) uerror( "expression depth exceeded" );
			continue;

		case NAME:
			p = talloc();
			p->in.op = NAME;
			p->in.type = FIXINT(REST(x));
			p->tn.rval = 0;
			if( VAL(x) ) p->tn.lval = lread();
			else p->tn.lval = 0;
#ifndef FLEXNAMES
			lcread( p->in.name, 2 );
#else
			p->in.name = lnread();
#endif
			goto bump;

		case OREG:
			p = talloc();
			p->in.op = OREG;
			p->in.type = FIXINT(REST(x));
			p->tn.rval = VAL(x);
			rbusy( p->tn.rval, PTR | p->in.type );
			p->tn.lval = lread();
#ifndef FLEXNAMES
			lcread( p->in.name, 2 );
#else
			p->in.name = lnread();
#endif
			goto bump;

		case REG:
			p = talloc();
			p->in.op = REG;
			p->in.type = FIXINT(REST(x));
			p->tn.rval = VAL(x);
			rbusy( p->tn.rval, p->in.type );
			p->tn.lval = 0;
#ifndef FLEXNAMES
			p->in.name[0] = '\0';
#else
			p->in.name = "";
#endif
			goto bump;

		case FEXPR:
			lineno = REST(x);
			if( VAL(x) ) lcread( filename, VAL(x) );
			if( fsp == fstack ) continue;  /* filename only */
			if( --fsp != fstack ) uerror( "expression poorly formed" );
			if( lflag ) lineid( lineno, filename );
			tmpoff = baseoff;
			p = fstack[0];
			if( edebug ) fwalk( p, eprint, 0 );
# ifdef MYREADER
			MYREADER(p);
# endif

			nrecur = 0;
			delay( p );
			reclaim( p, RNULL, 0 );

			allchk();
			tcheck();
			continue;

		case FLABEL:
			if( VAL(x) ){
				tlabel();
				}
			else {
				label( (int) REST(x) );
				}
			continue;

		case GOTO:
			if( VAL(x) ) {
				cbgen( 0, (int) REST(x), 'I' );  /* unconditional branch */
				continue;
				}
			/* otherwise, treat as unary */
			goto def;

		case STASG:
		case STARG:
		case STCALL:
		case UNARY STCALL:
			    /*
			     * size and alignment come from next long words
			     */
			p = talloc();
			p -> stn.stsize = lread();
			p -> stn.stalign = lread();
			goto defa;
		default:
		def:
			p = talloc();
		defa:
			p->in.op = FOP(x);
			p->in.type = FIXINT(REST(x));

			switch( optype( p->in.op ) ){

			case BITYPE:
				p->in.right = *--fsp;
				p->in.left = *--fsp;
				goto bump;

			case UTYPE:
				p->in.left = *--fsp;
				p->tn.rval = 0;
				goto bump;

			case LTYPE:
				uerror( "illegal leaf node: %d", p->in.op );
				exit( 1 );
				}
			}
		}
	}
Commit	Line	Data
262eaf56	1	#ifndef lint
ca67e7b4	2	static char *sccsid ="@(#)fort.c 4.8 (Berkeley) 10/15/86";
262eaf56 RC	3	#endif lint
262eaf56 RC	4
36b4e17c	5	# ifndef FORT
2b5d4291	6	# define FORT
36b4e17c RC	7	/* this may force larger trees, etc. */
	8	# endif
	9
69023ebb	10	# include "pass2.h"
2b5d4291 SL	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
3464f46e KM	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
2b5d4291 SL	39	FILE * lrd; /* for default reading routines */
2b5d4291 SL	40
03881bcc	41	# if !defined(NOLNREAD) && defined(FLEXNAMES)
2b5d4291 SL	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	}
7360bc74	60	#endif
2b5d4291 SL	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;
908f2cec	92	static char fbuf[BUFSIZ];
2b5d4291	93	if( n > 0 ){
908f2cec	94	if( n > BUFSIZ/4 ) cerror( "lccopy asked to copy too much" );
2b5d4291 SL	95	if( fread( fbuf, 4, n, lrd ) != n ) cerror( "intermediate file read error" );
	96	for( i=4n; 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
2b5d4291 SL	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;
3464f46e	182	p->in.type = FIXINT(REST(x));
2b5d4291 SL	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;
3464f46e	208	p->in.type = FIXINT(REST(x));
2b5d4291 SL	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;
3464f46e	222	p->in.type = FIXINT(REST(x));
2b5d4291	223	p->tn.rval = VAL(x);
3464f46e	224	rbusy( p->tn.rval, PTR \| p->in.type );
2b5d4291 SL	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;
3464f46e	236	p->in.type = FIXINT(REST(x));
2b5d4291 SL	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
69023ebb	268	case FLABEL:
2b5d4291 SL	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);
3464f46e	301	p->in.type = FIXINT(REST(x));
2b5d4291 SL	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	}