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

/*	common.c	4.5	88/05/11	*/

#ifdef PASS1COMMON
#include "pass1.h"
#else
#ifdef PASS2COMMON
#include "pass2.h"
#endif
#endif

#ifdef FORT
#undef BUFSTDERR
#endif
#ifndef ONEPASS
#undef BUFSTDERR
#endif
# ifndef EXIT
# define EXIT exit
# endif

int nerrors = 0;  /* number of errors */

extern unsigned int offsz;

unsigned caloff(){
	register i;
	unsigned int temp;
	unsigned int off;
	temp = 1;
	i = 0;
	do {
		temp <<= 1;
		++i;
		} while( temp != 0 );
	off = 1 << (i-1);
	return (off);
	}

NODE *lastfree;  /* pointer to last free node; (for allocator) */

	/* VARARGS1 */
uerror( s, a ) char *s; { /* nonfatal error message */
	/* the routine where is different for pass 1 and pass 2;
	/*  it tells where the error took place */

	++nerrors;
	where('u');
	fprintf( stderr, s, a );
	fprintf( stderr, "\n" );
#ifdef BUFSTDERR
	fflush(stderr);
#endif
	if( nerrors > 30 ) cerror( "too many errors");
	}

	/* VARARGS1 */
cerror( s, a, b, c ) char *s; { /* compiler error: die */
	where('c');
	if( nerrors && nerrors <= 30 ){ /* give the compiler the benefit of the doubt */
		fprintf( stderr, "cannot recover from earlier errors: goodbye!\n" );
		}
	else {
		fprintf( stderr, "compiler error: " );
		fprintf( stderr, s, a, b, c );
		fprintf( stderr, "\n" );
		}
#ifdef BUFSTDERR
	fflush(stderr);
#endif
	EXIT(1);
	}

int Wflag = 0; /* Non-zero means do not print warnings */

	/* VARARGS1 */
werror( s, a, b ) char *s; {  /* warning */
	if(Wflag) return;
	where('w');
	fprintf( stderr, "warning: " );
	fprintf( stderr, s, a, b );
	fprintf( stderr, "\n" );
#ifdef BUFSTDERR
	fflush(stderr);
#endif
	}

tinit(){ /* initialize expression tree search */

	register NODE *p;

	for( p=node; p<= &node[TREESZ-1]; ++p ) p->in.op = FREE;
	lastfree = node;

	}

# define TNEXT(p) (p== &node[TREESZ-1]?node:p+1)

NODE *
talloc(){
	register NODE *p, *q;

	q = lastfree;
	for( p = TNEXT(q); p!=q; p= TNEXT(p))
		if( p->in.op ==FREE )
			return(lastfree=p);

	cerror( "out of tree space; simplify expression");
	/* NOTREACHED */
	}

tcheck(){ /* ensure that all nodes have been freed */

	register NODE *p;

	if( !nerrors )
		for( p=node; p<= &node[TREESZ-1]; ++p )
			if( p->in.op != FREE )
				cerror( "wasted space: %o", p );
	tinit();
#ifdef FLEXNAMES
	freetstr();
#endif
	}
tfree( p )  NODE *p; {
	/* free the tree p */
	extern tfree1();

	if( p->in.op != FREE ) walkf( p, tfree1 );

	}

tfree1(p)  NODE *p; {
	if( p == 0 ) cerror( "freeing blank tree!");
	else p->in.op = FREE;
	}

fwalk( t, f, down ) register NODE *t; int (*f)(); {

	int down1, down2;

	more:
	down1 = down2 = 0;

	(*f)( t, down, &down1, &down2 );

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

	case BITYPE:
		fwalk( t->in.left, f, down1 );
		t = t->in.right;
		down = down2;
		goto more;

	case UTYPE:
		t = t->in.left;
		down = down1;
		goto more;

		}
	}

#ifndef vax
walkf( t, f ) register NODE *t;  int (*f)(); {
	register opty;

	opty = optype(t->in.op);

	if( opty != LTYPE ) walkf( t->in.left, f );
	if( opty == BITYPE ) walkf( t->in.right, f );
	(*f)( t );
	}
#else
#define	NR	32

/*
 * Deliberately avoids recursion -- use this version on machines with
 * expensive procedure calls.
 */
walkf(t, f)
	register NODE *t;
	register int (*f)();
{
	NODE *Aat[NR];
	int Aao[NR];
	register int i = 1;
	register int opty = optype(t->in.op);
	register NODE **at = Aat;
	register int *ao = Aao;

#define	PUSH(dir, state) \
	(ao[i] = state, at[i++] = t, t = t->in.dir, opty = optype(t->in.op))
#define	POP() \
	(opty = ao[--i], t = at[i])

	do {
		switch (opty) {
		case LTYPE:	(*f)(t); POP(); break;
		case UTYPE:	PUSH(left, LTYPE); break;
		case BITYPE:	PUSH(left, BITYPE+1); break;
		case BITYPE+1:	PUSH(right, LTYPE); break;
		default:
			cerror("bad op type in walkf");
		}
		if (i >= NR) {
			walkf(t, f);
			POP();
		}
	} while (i > 0);
}
#undef NR
#undef PUSH
#undef POP
#endif


int dope[ DSIZE ];
char *opst[DSIZE];

struct dopest { int dopeop; char opst[8]; int dopeval; } indope[] = {

	NAME, "NAME", LTYPE,
	STRING, "STRING", LTYPE,
	REG, "REG", LTYPE,
	OREG, "OREG", LTYPE,
	ICON, "ICON", LTYPE,
	FCON, "FCON", LTYPE,
	DCON, "DCON", LTYPE,
	CCODES, "CCODES", LTYPE,
	UNARY MINUS, "U-", UTYPE,
	UNARY MUL, "U*", UTYPE,
	UNARY AND, "U&", UTYPE,
	UNARY CALL, "UCALL", UTYPE|CALLFLG,
	UNARY FORTCALL, "UFCALL", UTYPE|CALLFLG,
	NOT, "!", UTYPE|LOGFLG,
	COMPL, "~", UTYPE,
	FORCE, "FORCE", UTYPE,
	INIT, "INIT", UTYPE,
	SCONV, "SCONV", UTYPE,
	PCONV, "PCONV", UTYPE,
	PLUS, "+", BITYPE|FLOFLG|SIMPFLG|COMMFLG,
	ASG PLUS, "+=", BITYPE|ASGFLG|ASGOPFLG|FLOFLG|SIMPFLG|COMMFLG,
	MINUS, "-", BITYPE|FLOFLG|SIMPFLG,
	ASG MINUS, "-=", BITYPE|FLOFLG|SIMPFLG|ASGFLG|ASGOPFLG,
	MUL, "*", BITYPE|FLOFLG|MULFLG,
	ASG MUL, "*=", BITYPE|FLOFLG|MULFLG|ASGFLG|ASGOPFLG,
	AND, "&", BITYPE|SIMPFLG|COMMFLG,
	ASG AND, "&=", BITYPE|SIMPFLG|COMMFLG|ASGFLG|ASGOPFLG,
	QUEST, "?", BITYPE,
	COLON, ":", BITYPE,
	ANDAND, "&&", BITYPE|LOGFLG,
	OROR, "||", BITYPE|LOGFLG,
	CM, ",", BITYPE,
	COMOP, ",OP", BITYPE,
	ASSIGN, "=", BITYPE|ASGFLG,
	DIV, "/", BITYPE|FLOFLG|MULFLG|DIVFLG,
	ASG DIV, "/=", BITYPE|FLOFLG|MULFLG|DIVFLG|ASGFLG|ASGOPFLG,
	MOD, "%", BITYPE|DIVFLG,
	ASG MOD, "%=", BITYPE|DIVFLG|ASGFLG|ASGOPFLG,
	LS, "<<", BITYPE|SHFFLG,
	ASG LS, "<<=", BITYPE|SHFFLG|ASGFLG|ASGOPFLG,
	RS, ">>", BITYPE|SHFFLG,
	ASG RS, ">>=", BITYPE|SHFFLG|ASGFLG|ASGOPFLG,
	OR, "|", BITYPE|COMMFLG|SIMPFLG,
	ASG OR, "|=", BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG,
	ER, "^", BITYPE|COMMFLG|SIMPFLG,
	ASG ER, "^=", BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG,
	INCR, "++", BITYPE|ASGFLG,
	DECR, "--", BITYPE|ASGFLG,
	STREF, "->", BITYPE,
	CALL, "CALL", BITYPE|CALLFLG,
	FORTCALL, "FCALL", BITYPE|CALLFLG,
	EQ, "==", BITYPE|LOGFLG,
	NE, "!=", BITYPE|LOGFLG,
	LE, "<=", BITYPE|LOGFLG,
	LT, "<", BITYPE|LOGFLG,
	GE, ">", BITYPE|LOGFLG,
	GT, ">", BITYPE|LOGFLG,
	UGT, "UGT", BITYPE|LOGFLG,
	UGE, "UGE", BITYPE|LOGFLG,
	ULT, "ULT", BITYPE|LOGFLG,
	ULE, "ULE", BITYPE|LOGFLG,
#ifdef ARS
	ARS, "A>>", BITYPE,
#endif
	TYPE, "TYPE", LTYPE,
	LB, "[", BITYPE,
	CBRANCH, "CBRANCH", BITYPE,
	FLD, "FLD", UTYPE,
	PMCONV, "PMCONV", BITYPE,
	PVCONV, "PVCONV", BITYPE,
	RETURN, "RETURN", BITYPE|ASGFLG|ASGOPFLG,
	CAST, "CAST", BITYPE|ASGFLG|ASGOPFLG,
	GOTO, "GOTO", UTYPE,
	STASG, "STASG", BITYPE|ASGFLG,
	STARG, "STARG", UTYPE,
	STCALL, "STCALL", BITYPE|CALLFLG,
	UNARY STCALL, "USTCALL", UTYPE|CALLFLG,

	-1,	"",	0
};

mkdope(){
	register struct dopest *q;

	for( q = indope; q->dopeop >= 0; ++q ){
		dope[q->dopeop] = q->dopeval;
		opst[q->dopeop] = q->opst;
		}
	}
# ifndef BUG4
tprint( t )  TWORD t; { /* output a nice description of the type of t */

	static char * tnames[] = {
		"undef",
		"farg",
		"char",
		"short",
		"int",
		"long",
		"float",
		"double",
		"strty",
		"unionty",
		"enumty",
		"moety",
		"uchar",
		"ushort",
		"unsigned",
		"ulong",
		"?", "?"
		};

	for(;; t = DECREF(t) ){

		if( ISPTR(t) ) printf( "PTR " );
		else if( ISFTN(t) ) printf( "FTN " );
		else if( ISARY(t) ) printf( "ARY " );
		else {
			printf( "%s", tnames[t] );
			return;
			}
		}
	}
# endif

#ifdef FLEXNAMES
#define	NTSTRBUF	40
#define	TSTRSZ		2048
char	itstrbuf[TSTRSZ];
char	*tstrbuf[NTSTRBUF] = { itstrbuf };
char	**curtstr = tstrbuf;
int	tstrused;
char	*malloc();
char	*strcpy();

char *
tstr(cp)
	register char *cp;
{
	register int i = strlen(cp);
	register char *dp;
	
	if (tstrused + i >= TSTRSZ) {
		if (++curtstr >= &tstrbuf[NTSTRBUF])
			cerror("out of temporary string space");
		tstrused = 0;
		if (*curtstr == 0) {
			dp = malloc(TSTRSZ);
			if (dp == 0)
				cerror("out of memory (tstr)");
			*curtstr = dp;
		}
	}
	(void) strcpy(dp = *curtstr+tstrused, cp);
	tstrused += i + 1;
	return (dp);
}
#endif
Commit	Line	Data
758d36cd	1	/* common.c 4.5 88/05/11 */
ae51d042 RC	2
	3	#ifdef PASS1COMMON
	4	#include "pass1.h"
	5	#else
	6	#ifdef PASS2COMMON
	7	#include "pass2.h"
	8	#endif
	9	#endif
	10
	11	#ifdef FORT
	12	#undef BUFSTDERR
	13	#endif
	14	#ifndef ONEPASS
	15	#undef BUFSTDERR
	16	#endif
	17	# ifndef EXIT
	18	# define EXIT exit
	19	# endif
	20
	21	int nerrors = 0; /* number of errors */
	22
	23	extern unsigned int offsz;
	24
	25	unsigned caloff(){
	26	register i;
	27	unsigned int temp;
	28	unsigned int off;
	29	temp = 1;
	30	i = 0;
	31	do {
	32	temp <<= 1;
	33	++i;
	34	} while( temp != 0 );
	35	off = 1 << (i-1);
	36	return (off);
	37	}
	38
	39	NODE lastfree; / pointer to last free node; (for allocator) */
	40
	41	/* VARARGS1 */
	42	uerror( s, a ) char s; { / nonfatal error message */
	43	/* the routine where is different for pass 1 and pass 2;
	44	/* it tells where the error took place */
	45
	46	++nerrors;
	47	where('u');
	48	fprintf( stderr, s, a );
	49	fprintf( stderr, "\n" );
	50	#ifdef BUFSTDERR
	51	fflush(stderr);
	52	#endif
	53	if( nerrors > 30 ) cerror( "too many errors");
	54	}
	55
	56	/* VARARGS1 */
	57	cerror( s, a, b, c ) char s; { / compiler error: die */
	58	where('c');
	59	if( nerrors && nerrors <= 30 ){ /* give the compiler the benefit of the doubt */
	60	fprintf( stderr, "cannot recover from earlier errors: goodbye!\n" );
	61	}
	62	else {
	63	fprintf( stderr, "compiler error: " );
	64	fprintf( stderr, s, a, b, c );
	65	fprintf( stderr, "\n" );
66	}
67	#ifdef BUFSTDERR
68	fflush(stderr);
69	#endif
70	EXIT(1);
71	}
72
73	int Wflag = 0; /* Non-zero means do not print warnings */
74
75	/* VARARGS1 */
76	werror( s, a, b ) char s; { / warning */
77	if(Wflag) return;
78	where('w');
79	fprintf( stderr, "warning: " );
80	fprintf( stderr, s, a, b );
81	fprintf( stderr, "\n" );
82	#ifdef BUFSTDERR
83	fflush(stderr);
84	#endif
85	}
86
87	tinit(){ /* initialize expression tree search */
88
3464f46e	89	register NODE *p;
ae51d042 RC	90
	91	for( p=node; p<= &node[TREESZ-1]; ++p ) p->in.op = FREE;
	92	lastfree = node;
	93
	94	}
	95
	96	# define TNEXT(p) (p== &node[TREESZ-1]?node:p+1)
	97
	98	NODE *
	99	talloc(){
3464f46e	100	register NODE p, q;
ae51d042 RC	101
	102	q = lastfree;
	103	for( p = TNEXT(q); p!=q; p= TNEXT(p))
79e776a3 DS	104	if( p->in.op ==FREE )
79e776a3 DS	105	return(lastfree=p);
ae51d042 RC	106
	107	cerror( "out of tree space; simplify expression");
	108	/* NOTREACHED */
	109	}
	110
	111	tcheck(){ /* ensure that all nodes have been freed */
	112
3464f46e	113	register NODE *p;
ae51d042 RC	114
	115	if( !nerrors )
	116	for( p=node; p<= &node[TREESZ-1]; ++p )
79e776a3 DS	117	if( p->in.op != FREE )
79e776a3 DS	118	cerror( "wasted space: %o", p );
ae51d042 RC	119	tinit();
	120	#ifdef FLEXNAMES
	121	freetstr();
	122	#endif
	123	}
	124	tfree( p ) NODE *p; {
	125	/* free the tree p */
	126	extern tfree1();
	127
	128	if( p->in.op != FREE ) walkf( p, tfree1 );
	129
	130	}
	131
	132	tfree1(p) NODE *p; {
	133	if( p == 0 ) cerror( "freeing blank tree!");
	134	else p->in.op = FREE;
	135	}
	136
	137	fwalk( t, f, down ) register NODE t; int (f)(); {
	138
	139	int down1, down2;
	140
	141	more:
	142	down1 = down2 = 0;
	143
	144	(*f)( t, down, &down1, &down2 );
	145
	146	switch( optype( t->in.op ) ){
	147
	148	case BITYPE:
	149	fwalk( t->in.left, f, down1 );
	150	t = t->in.right;
	151	down = down2;
	152	goto more;
	153
	154	case UTYPE:
	155	t = t->in.left;
	156	down = down1;
	157	goto more;
	158
	159	}
	160	}
	161
3464f46e	162	#ifndef vax
ae51d042 RC	163	walkf( t, f ) register NODE t; int (f)(); {
	164	register opty;
	165
	166	opty = optype(t->in.op);
	167
	168	if( opty != LTYPE ) walkf( t->in.left, f );
	169	if( opty == BITYPE ) walkf( t->in.right, f );
	170	(*f)( t );
	171	}
3464f46e	172	#else
758d36cd	173	#define NR 32
3464f46e KM	174
	175	/*
	176	* Deliberately avoids recursion -- use this version on machines with
	177	* expensive procedure calls.
	178	*/
	179	walkf(t, f)
	180	register NODE *t;
	181	register int (*f)();
	182	{
758d36cd DS	183	NODE *Aat[NR];
758d36cd DS	184	int Aao[NR];
3464f46e KM	185	register int i = 1;
3464f46e KM	186	register int opty = optype(t->in.op);
758d36cd DS	187	register NODE **at = Aat;
758d36cd DS	188	register int *ao = Aao;
3464f46e KM	189
	190	#define PUSH(dir, state) \
	191	(ao[i] = state, at[i++] = t, t = t->in.dir, opty = optype(t->in.op))
	192	#define POP() \
	193	(opty = ao[--i], t = at[i])
	194
	195	do {
	196	switch (opty) {
	197	case LTYPE: (*f)(t); POP(); break;
	198	case UTYPE: PUSH(left, LTYPE); break;
	199	case BITYPE: PUSH(left, BITYPE+1); break;
	200	case BITYPE+1: PUSH(right, LTYPE); break;
	201	default:
	202	cerror("bad op type in walkf");
	203	}
	204	if (i >= NR) {
	205	walkf(t, f);
	206	POP();
	207	}
	208	} while (i > 0);
	209	}
	210	#undef NR
	211	#undef PUSH
	212	#undef POP
	213	#endif
ae51d042 RC	214
	215
	216
	217	int dope[ DSIZE ];
	218	char *opst[DSIZE];
	219
	220	struct dopest { int dopeop; char opst[8]; int dopeval; } indope[] = {
	221
	222	NAME, "NAME", LTYPE,
	223	STRING, "STRING", LTYPE,
	224	REG, "REG", LTYPE,
	225	OREG, "OREG", LTYPE,
	226	ICON, "ICON", LTYPE,
	227	FCON, "FCON", LTYPE,
	228	DCON, "DCON", LTYPE,
	229	CCODES, "CCODES", LTYPE,
	230	UNARY MINUS, "U-", UTYPE,
	231	UNARY MUL, "U*", UTYPE,
	232	UNARY AND, "U&", UTYPE,
	233	UNARY CALL, "UCALL", UTYPE\|CALLFLG,
	234	UNARY FORTCALL, "UFCALL", UTYPE\|CALLFLG,
	235	NOT, "!", UTYPE\|LOGFLG,
	236	COMPL, "~", UTYPE,
	237	FORCE, "FORCE", UTYPE,
	238	INIT, "INIT", UTYPE,
	239	SCONV, "SCONV", UTYPE,
	240	PCONV, "PCONV", UTYPE,
	241	PLUS, "+", BITYPE\|FLOFLG\|SIMPFLG\|COMMFLG,
	242	ASG PLUS, "+=", BITYPE\|ASGFLG\|ASGOPFLG\|FLOFLG\|SIMPFLG\|COMMFLG,
	243	MINUS, "-", BITYPE\|FLOFLG\|SIMPFLG,
	244	ASG MINUS, "-=", BITYPE\|FLOFLG\|SIMPFLG\|ASGFLG\|ASGOPFLG,
	245	MUL, "*", BITYPE\|FLOFLG\|MULFLG,
	246	ASG MUL, "*=", BITYPE\|FLOFLG\|MULFLG\|ASGFLG\|ASGOPFLG,
	247	AND, "&", BITYPE\|SIMPFLG\|COMMFLG,
	248	ASG AND, "&=", BITYPE\|SIMPFLG\|COMMFLG\|ASGFLG\|ASGOPFLG,
	249	QUEST, "?", BITYPE,
	250	COLON, ":", BITYPE,
	251	ANDAND, "&&", BITYPE\|LOGFLG,
	252	OROR, "\|\|", BITYPE\|LOGFLG,
	253	CM, ",", BITYPE,
	254	COMOP, ",OP", BITYPE,
	255	ASSIGN, "=", BITYPE\|ASGFLG,
	256	DIV, "/", BITYPE\|FLOFLG\|MULFLG\|DIVFLG,
	257	ASG DIV, "/=", BITYPE\|FLOFLG\|MULFLG\|DIVFLG\|ASGFLG\|ASGOPFLG,
	258	MOD, "%", BITYPE\|DIVFLG,
	259	ASG MOD, "%=", BITYPE\|DIVFLG\|ASGFLG\|ASGOPFLG,
	260	LS, "<<", BITYPE\|SHFFLG,
	261	ASG LS, "<<=", BITYPE\|SHFFLG\|ASGFLG\|ASGOPFLG,
	262	RS, ">>", BITYPE\|SHFFLG,
	263	ASG RS, ">>=", BITYPE\|SHFFLG\|ASGFLG\|ASGOPFLG,
	264	OR, "\|", BITYPE\|COMMFLG\|SIMPFLG,
	265	ASG OR, "\|=", BITYPE\|COMMFLG\|SIMPFLG\|ASGFLG\|ASGOPFLG,
	266	ER, "^", BITYPE\|COMMFLG\|SIMPFLG,
	267	ASG ER, "^=", BITYPE\|COMMFLG\|SIMPFLG\|ASGFLG\|ASGOPFLG,
	268	INCR, "++", BITYPE\|ASGFLG,
	269	DECR, "--", BITYPE\|ASGFLG,
	270	STREF, "->", BITYPE,
	271	CALL, "CALL", BITYPE\|CALLFLG,
	272	FORTCALL, "FCALL", BITYPE\|CALLFLG,
	273	EQ, "==", BITYPE\|LOGFLG,
	274	NE, "!=", BITYPE\|LOGFLG,
	275	LE, "<=", BITYPE\|LOGFLG,
	276	LT, "<", BITYPE\|LOGFLG,
	277	GE, ">", BITYPE\|LOGFLG,
278	GT, ">", BITYPE\|LOGFLG,
279	UGT, "UGT", BITYPE\|LOGFLG,
280	UGE, "UGE", BITYPE\|LOGFLG,
281	ULT, "ULT", BITYPE\|LOGFLG,
282	ULE, "ULE", BITYPE\|LOGFLG,
283	#ifdef ARS
284	ARS, "A>>", BITYPE,
285	#endif
286	TYPE, "TYPE", LTYPE,
287	LB, "[", BITYPE,
288	CBRANCH, "CBRANCH", BITYPE,
289	FLD, "FLD", UTYPE,
290	PMCONV, "PMCONV", BITYPE,
291	PVCONV, "PVCONV", BITYPE,
292	RETURN, "RETURN", BITYPE\|ASGFLG\|ASGOPFLG,
293	CAST, "CAST", BITYPE\|ASGFLG\|ASGOPFLG,
294	GOTO, "GOTO", UTYPE,
295	STASG, "STASG", BITYPE\|ASGFLG,
296	STARG, "STARG", UTYPE,
297	STCALL, "STCALL", BITYPE\|CALLFLG,
298	UNARY STCALL, "USTCALL", UTYPE\|CALLFLG,
299
300	-1, "", 0
301	};
302
303	mkdope(){
304	register struct dopest *q;
305
306	for( q = indope; q->dopeop >= 0; ++q ){
307	dope[q->dopeop] = q->dopeval;
308	opst[q->dopeop] = q->opst;
309	}
310	}
311	# ifndef BUG4
312	tprint( t ) TWORD t; { /* output a nice description of the type of t */
313
314	static char * tnames[] = {
315	"undef",
316	"farg",
317	"char",
318	"short",
319	"int",
320	"long",
321	"float",
322	"double",
323	"strty",
324	"unionty",
325	"enumty",
326	"moety",
327	"uchar",
328	"ushort",
329	"unsigned",
330	"ulong",
331	"?", "?"
332	};
333
334	for(;; t = DECREF(t) ){
335
336	if( ISPTR(t) ) printf( "PTR " );
337	else if( ISFTN(t) ) printf( "FTN " );
338	else if( ISARY(t) ) printf( "ARY " );
339	else {
340	printf( "%s", tnames[t] );
341	return;
342	}
343	}
344	}
345	# endif
346
347	#ifdef FLEXNAMES
348	#define NTSTRBUF 40
349	#define TSTRSZ 2048
350	char itstrbuf[TSTRSZ];
351	char *tstrbuf[NTSTRBUF] = { itstrbuf };
352	char **curtstr = tstrbuf;
353	int tstrused;
3a4907d0 DS	354	char *malloc();
3a4907d0 DS	355	char *strcpy();
ae51d042 RC	356
	357	char *
	358	tstr(cp)
	359	register char *cp;
	360	{
	361	register int i = strlen(cp);
	362	register char *dp;
	363
	364	if (tstrused + i >= TSTRSZ) {
	365	if (++curtstr >= &tstrbuf[NTSTRBUF])
	366	cerror("out of temporary string space");
	367	tstrused = 0;
	368	if (*curtstr == 0) {
3a4907d0	369	dp = malloc(TSTRSZ);
ae51d042 RC	370	if (dp == 0)
	371	cerror("out of memory (tstr)");
	372	*curtstr = dp;
	373	}
	374	}
3a4907d0	375	(void) strcpy(dp = *curtstr+tstrused, cp);
ae51d042 RC	376	tstrused += i + 1;
	377	return (dp);
	378	}
	379	#endif