head     56.1;
access   paws bayes jws quist brad dew jwh;
symbols  ;
locks    ; strict;
comment  @# @;


56.1
date     91.11.05.09.26.57;  author jwh;  state Exp;
branches ;
next     55.1;

55.1
date     91.08.25.10.04.29;  author jwh;  state Exp;
branches ;
next     54.1;

54.1
date     91.03.18.15.14.07;  author jwh;  state Exp;
branches ;
next     53.1;

53.1
date     91.03.11.19.14.51;  author jwh;  state Exp;
branches ;
next     52.1;

52.1
date     91.02.19.08.59.58;  author jwh;  state Exp;
branches ;
next     51.1;

51.1
date     91.01.30.15.58.54;  author jwh;  state Exp;
branches ;
next     50.1;

50.1
date     90.10.29.16.11.48;  author jwh;  state Exp;
branches ;
next     49.1;

49.1
date     90.08.14.14.01.01;  author jwh;  state Exp;
branches ;
next     48.1;

48.1
date     90.07.26.11.06.37;  author jwh;  state Exp;
branches ;
next     47.1;

47.1
date     90.05.14.10.41.56;  author dew;  state Exp;
branches ;
next     46.1;

46.1
date     90.05.07.08.31.02;  author jwh;  state Exp;
branches ;
next     45.1;

45.1
date     90.04.19.15.38.00;  author jwh;  state Exp;
branches ;
next     44.1;

44.1
date     90.04.01.21.55.45;  author jwh;  state Exp;
branches ;
next     43.1;

43.1
date     90.03.20.13.45.38;  author jwh;  state Exp;
branches ;
next     42.1;

42.1
date     90.01.23.17.31.11;  author jwh;  state Exp;
branches ;
next     41.1;

41.1
date     89.12.22.11.13.35;  author jwh;  state Exp;
branches ;
next     40.1;

40.1
date     89.09.29.11.36.36;  author jwh;  state Exp;
branches ;
next     39.1;

39.1
date     89.09.26.16.22.00;  author dew;  state Exp;
branches ;
next     38.1;

38.1
date     89.08.29.11.12.05;  author jwh;  state Exp;
branches ;
next     37.1;

37.1
date     89.05.12.11.25.10;  author dew;  state Exp;
branches ;
next     36.1;

36.1
date     89.02.06.10.04.08;  author dew;  state Exp;
branches ;
next     35.1;

35.1
date     89.02.02.13.14.15;  author dew;  state Exp;
branches ;
next     34.1;

34.1
date     89.01.23.15.50.09;  author jwh;  state Exp;
branches ;
next     33.1;

33.1
date     89.01.16.11.26.12;  author dew;  state Exp;
branches ;
next     32.1;

32.1
date     89.01.10.11.31.20;  author bayes;  state Exp;
branches ;
next     31.1;

31.1
date     88.12.14.17.52.17;  author bayes;  state Exp;
branches ;
next     30.1;

30.1
date     88.12.09.13.30.28;  author dew;  state Exp;
branches ;
next     29.1;

29.1
date     88.10.31.15.14.47;  author bayes;  state Exp;
branches ;
next     28.1;

28.1
date     88.10.06.10.45.07;  author dew;  state Exp;
branches ;
next     27.1;

27.1
date     88.09.29.11.08.20;  author bayes;  state Exp;
branches ;
next     26.1;

26.1
date     88.09.28.12.22.18;  author bayes;  state Exp;
branches ;
next     25.1;

25.1
date     88.03.02.09.01.34;  author bayes;  state Exp;
branches ;
next     24.1;

24.1
date     87.08.31.09.03.39;  author jws;  state Exp;
branches ;
next     23.1;

23.1
date     87.08.26.09.41.09;  author bayes;  state Exp;
branches ;
next     22.1;

22.1
date     87.08.17.10.18.40;  author bayes;  state Exp;
branches ;
next     21.1;

21.1
date     87.08.12.13.08.23;  author bayes;  state Exp;
branches ;
next     20.1;

20.1
date     87.07.30.10.18.08;  author bayes;  state Exp;
branches ;
next     19.1;

19.1
date     87.06.01.07.38.09;  author jws;  state Exp;
branches ;
next     18.1;

18.1
date     87.05.20.14.30.17;  author bayes;  state Exp;
branches ;
next     17.1;

17.1
date     87.04.30.09.46.18;  author jws;  state Exp;
branches ;
next     16.1;

16.1
date     87.04.26.15.04.48;  author jws;  state Exp;
branches ;
next     15.1;

15.1
date     87.04.13.08.27.18;  author jws;  state Exp;
branches ;
next     14.1;

14.1
date     87.04.01.14.14.29;  author jws;  state Exp;
branches ;
next     13.1;

13.1
date     87.02.28.17.55.15;  author jws;  state Exp;
branches ;
next     12.1;

12.1
date     87.02.02.12.40.14;  author jws;  state Exp;
branches ;
next     11.1;

11.1
date     87.01.19.09.06.38;  author jws;  state Exp;
branches ;
next     10.1;

10.1
date     86.12.24.10.10.22;  author jws;  state Exp;
branches ;
next     9.1;

9.1
date     86.12.12.13.29.09;  author bayes;  state Exp;
branches ;
next     8.1;

8.1
date     86.11.27.11.08.44;  author jws;  state Exp;
branches ;
next     7.1;

7.1
date     86.11.20.12.53.59;  author hal;  state Exp;
branches ;
next     6.1;

6.1
date     86.11.04.16.48.34;  author paws;  state Exp;
branches ;
next     5.1;

5.1
date     86.10.28.14.10.37;  author hal;  state Exp;
branches ;
next     1.1;

1.1
date     86.10.23.15.21.08;  author geli;  state tmp;
branches ;
next     ;


desc
@Base file for PWS 3.2 release.

@


56.1
log
@Automatic bump of revision number for PWS version 3.25
@
text
@/*      SCCS    REV(31.3);      DATE(85/08/13   14:32:04) */
/* KLEENIX_ID @@(#)common        31.3 85/07/30 */

# ifndef EXIT
# define EXIT exit
# endif

#ifndef NONAME
#       define NONAME   040000  /* must be the same as in mfile1 */
#endif

extern char *malloc();
extern FILE *stmpf;

short nerrors;          /* number of errors */
NODE *node;
int maxsymtsz = SYMTSZ;
int maxtascizsz = TASCIZSZ;
int maxnodesz = TREESZ;


# ifndef FORT
int maxbcsz = BCSZ;
int maxdimtabsz = DIMTABSZ;
int maxparamsz = PARAMSZ;
int maxswitsz = SWITSZ;
int *asavbc;            /* alloced in inittabs() */
int *dimtab;            /* alloced in inittabs() */
int *paramstk;          /* alloced in inittabs() */
struct sw *swtab;       /* alloced in inittabs() */
struct symtab *stab;    /* alloced in inittabs() */
int *psavbc;
flag singleflag = 0;    /* true iff 32 bit float ops for C */
# endif

LOCAL maxascizsz = ASCIZSZ;
LOCAL   char    *taz;
char    *treeasciz;             /* asciz table for syms in tree nodes */
char    *lasttac;               /* ptr to first free char in treeasciz */

#ifndef PWS
unsigned int offsz;
#endif

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, b ) 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, b );
	fprintf( stderr, "\n" );
	if( nerrors > MAXUSEFULERRS ) cerror( "too many errors");
	}




	/* VARARGS1 */
cerror( s, a, b, c ) char *s; { /* compiler error: die */
	where('c');
# ifdef LINT
	fprintf( stderr, "\n\t**** cannot recover from this error ****\n\n");
# else
	if( nerrors && nerrors <= MAXUSEFULERRS ){
		/* 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" );
		}
# endif
	EXIT(1);
	}






	/* VARARGS1 */
werror( s, a, b ) char *s; {  /* warning */
# ifndef CXREF
	where('w');
	fprintf( stderr, "warning: " );
	fprintf( stderr, s, a, b );
	fprintf( stderr, "\n" );
# endif
	}






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

	register NODE *p;

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

	}






# define TNEXT(p) (p== &node[maxnodesz-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 )
			{
			p->in.onebit = 0;       /* initialize it */
			return(lastfree=p);
			}

#ifdef FORT
	cerror( "out of tree space; simplify expression or try +Ne option");
#else
	cerror( "out of tree space; simplify expression or try -Wc,-Ne option");
#endif
	/* NOTREACHED */
	}




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

	register NODE *p;

	if( !nerrors )
		for( p=node; p<= &node[maxnodesz-1]; ++p )
			if( p->in.op != FREE ) cerror( "wasted space: %x", p );
	tinit();
	}



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;
	}



NODE *
bcon( i, t )    register int i; TWORD t;{ /* make a constant node with value i */
	register NODE *p;

	p = block( ICON, NIL, NIL, INT, 0, INT );
	if (t) p->in.type = t;
	else
		{
		if (i>=-128 && i<=127) p->tn.type = CHAR;
		else if (i>=-32768 && i<=32767) p->tn.type = SHORT;
		else p->tn.type = INT;
		}
	p->tn.lval = i;
	p->tn.rval = NONAME;
#if (defined(ONEPASS) || defined(FORT))
	p->in.name = NULL;
#endif
	return( p );    /* used to call clocal - but that doesn't do anything */
	}




NODE * block( o, l, r, t, d, s ) short o; NODE *l, *r; TWORD t; {

	register NODE *p;

	p = talloc();
	p->in.op = o;
# ifdef LINT
	p->in.cdim = d;
# else
	p->in.rall = d;
# endif
	p->in.left = l;
	p->in.right = r;
	p->in.type = t;
#ifdef FORT
	p->in.fhwside = 0;
#else
	p->fn.csiz = s;
#endif  /* FORT */
	return(p);
	}




/* fwalk() is a prefix tree traversal routine that visits nodes in the order
   P - L - R.
*/
fwalk( t, f, down ) register NODE *t; int (*f)(); {

	int down1, down2;

more:
	down1 = 0; 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;

		}
	}



/* walkf() is a postfix tree traversal routine that traverses the tree in the
   order L - R - P.
*/
walkf( t, f ) register NODE *t;  int (*f)(); {
	register short opty;

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

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



/* incref inserts a type into the type word while doing an expanded check for
   type overflow.
*/
incref(x) register x;
{
	if (LTMASK & x)
		{
		uerror("type too complex");
		return(0);
		}
	else
		return( (((x&~BTMASK) << TSHIFT)|PTR|(x&BTMASK)) );
}



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

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

	NAME, "NAME", LTYPE,
	STRING, "STRING", LTYPE,
	REG, "REG", LTYPE,
	OREG, "OREG", LTYPE,
	ICON, "ICON", LTYPE,
	FCON, "FCON", LTYPE,
	CCODES, "CCODES", LTYPE,
	UNARY MINUS, "U-", UTYPE|FLOFLG,
	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|FHWFLG|FLOFLG,
	PCONV, "PCONV", UTYPE,
	PLUS, "+", BITYPE|FLOFLG|SIMPFLG|COMMFLG|FHWFLG,
	ASG PLUS, "+=", BITYPE|ASGFLG|ASGOPFLG|FLOFLG|SIMPFLG|COMMFLG,
	MINUS, "-", BITYPE|FLOFLG|SIMPFLG|FHWFLG,
	ASG MINUS, "-=", BITYPE|FLOFLG|SIMPFLG|ASGFLG|ASGOPFLG,
	MUL, "*", BITYPE|FLOFLG|MULFLG|FHWFLG,
	ASG MUL, "*=", BITYPE|FLOFLG|MULFLG|ASGFLG|ASGOPFLG,
	AND, "&", BITYPE|SIMPFLG|COMMFLG|LTYFLG,
	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|FHWFLG,
	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|LTYFLG,
	ASG OR, "|=", BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG,
	ER, "^", BITYPE|COMMFLG,
	ASG ER, "^=", BITYPE|COMMFLG|ASGFLG|ASGOPFLG,
	INCR, "++", BITYPE|ASGFLG|FLOFLG,
	DECR, "--", BITYPE|ASGFLG|FLOFLG,
	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,
	ARS, "A>>", BITYPE,
	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|FHWFLG,
	GOTO, "GOTO", UTYPE,
	STASG, "STASG", BITYPE|ASGFLG,
	STARG, "STARG", UTYPE,
	STCALL, "STCALL", BITYPE|CALLFLG,
	UNARY STCALL, "USTCALL", UTYPE|CALLFLG,
	BICCODES, "BICCODES", BITYPE,

-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 )  register 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) ) fprintf( outfile, "PTR " );
		else if( ISFTN(t) ) fprintf( outfile, "FTN " );
		else if( ISARY(t) ) fprintf( outfile, "ARY " );
		else {
			fprintf( outfile, "%s", tnames[t] );
			return;
			}
		}
	}
# endif
ttprint( t )   register TWORD t; {/* output a nice description of the type of t */

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

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

		if( ISPTR(t) ) {
			fprintf( stmpf, "ANYPTR" );
			return;
			}
		else if( ISFTN(t) ) ;
		else if( ISARY(t) ) {
			fprintf( stmpf, "ANYPTR" );
			return;
			}
		else {
			fprintf( stmpf, "%s", tnames[t] );
			return;
			}
		}
	}



tgprint( t )   register TWORD t; {/* output a nice description of the type of t */

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

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

		if( ISPTR(t) ) {
			fprintf( stmpf, "ANYPTR" );
			return;
			}
		else if( ISFTN(t) ) ;
		else if( ISARY(t) ) {
			fprintf( stmpf, "ANYPTR" );
			return;
			}
		else {
			fprintf( stmpf, "%s", tnames[t] );
			return;
			}
		}
	}






/* addtreeasciz adds an asciz symbol to the treeasciz array after first
   checking for overflow. It updates lasttac to point to the next free
   char. The routine is typically used to fill tree node names in the
   second pass routines.
*/

char    *addtreeasciz(cp)       char    *cp;
{
	register short i;
	register char   *lcp = cp;
	extern char     *strcpy();

	for (i=1; *lcp++; i++) /* NULL */ ;     /* count the chars */
	lcp = lasttac;                          /* save it */
	if (i > TASCIZSZ - (lasttac-treeasciz))
		many("tree asciz", 't');
	lasttac += i;
	return ( strcpy(lcp, cp) );
}



nncon( p ) NODE *p; {
	/* is p a constant without a name */
	return( p->in.op == ICON && p->tn.rval == NONAME );
	}



many(s, c)
char *s, c;
{
#ifdef FORT
	fprintf(stderr,"%s table overflow. Try the +N%c option\n", s, c);
#else
	fprintf(stderr,"%s table overflow. Try the -Wc,-N%c option\n", s, c);
#endif
	EXIT(1);
}




resettablesize(cp, newsize)     char *cp; int newsize;
{
	int *up;

	switch (*cp)
		{
		case 'a':
			up = &maxascizsz;
			break;
		case 'e':
			up = &maxnodesz;
			break;
		case 's':
			up = &maxsymtsz;
			break;
		case 't':
			up = &maxtascizsz;
			break;
# ifndef FORT
		case 'b':
			up = &maxbcsz;
			break;
		case 'd':
			up = &maxdimtabsz;
			break;
		case 'p':
			up = &maxparamsz;
			break;
		case 'w':
			up = &maxswitsz;
			break;
# endif
		default:
			werror("Unknown table specifier (ignored)");
			up = (int *)NIL;
			break;
		}

	if (up) *up = newsize;
}


ptr ckalloc(n)
int n;  /* total # of bytes needed in the contiguous space */
{
	register ptr p;

	if (p = (ptr) malloc(n)) return (p);
	cerror("out of space - unable to allocate memory for internal use");
}


#ifndef FORT

char *lastac;
char *asciz;
/* addasciz takes a ptr to a char string containing a name, finds the next
   available spot in the asciz table, copies the string into the asciz array,
   and returns the address of the first char. Names are assumed null terminated.
   If the remaining space is insufficient, it makes an effort to rewrite the
   asciz table; if unsuccessful, it reports a cerror.
*/
char    *addasciz(cp)   char    *cp;
{
	register i;
	register char   *lcp = cp;
	extern char     *strcpy();

	for (i=1; *lcp++; i++) /* NULL */ ;     /* count the chars */
# ifdef LINT_TRY
	/* for lint do not remove local symbols from the ascii table */
	if (i > (maxascizsz - (lastac-asciz))) many("asciz", 'a');
# else
	if (i > maxascizsz - (lastac-asciz)) newasciz(1);
# endif
	lcp = lastac;                           /* save it */
	lastac += i;
	return ( strcpy(lcp, cp) );
}



LOCAL flag      ascizrecursed;


/* newasciz makes a new asciz table and inits it. The idea behind re-
   allocating a new table is that as entries are removed, the table
   becomes increasingly sparse. By reallocating a new table and
   recopying the symbol table, it is made dense once again.
*/

newasciz(replacing)     flag replacing;
{
	register int i;
	register struct symtab  *sp;
	register TWORD null = TNULL;    /* just for a faster comparison */
	char    *lp = asciz;

	if (ascizrecursed++) cerror("logic error in newasciz-recursion");

	if (replacing) maxascizsz += 2000;
	if ( (lastac = asciz = malloc(maxascizsz) ) == NULL)
		many("asciz", 'a');
	if (replacing)
	{
		for ( i=0, sp=stab; i < maxsymtsz; i++, sp++)
		{
			if (sp->stype == null) continue;
			sp->sname = addasciz(sp->sname);
		}
		free(lp);               /* throw away the old table now */
	}
	ascizrecursed--;
}


/* inittabs initializes internal pass 1 storage tables */
inittabs()
{
	psavbc = asavbc = ckalloc (maxbcsz * sizeof(int) );
	dimtab = ckalloc( maxdimtabsz * sizeof(int) );
	swtab  = (struct sw *) ckalloc( maxswitsz * sizeof (struct sw) );
	taz = (char *)ckalloc( maxtascizsz * sizeof(char));
	stab= (struct symtab *) ckalloc( (1+maxsymtsz) * sizeof (struct symtab) );
	node = (NODE *) ckalloc ( maxnodesz * sizeof (NODE) );
	paramstk = ckalloc( maxparamsz * sizeof(int) );
# ifdef HPCDB
	if (cdbflag)
		{
		atype_dntt= (unsigned long *) ckalloc ( maxparamsz * sizeof(long) );
		}
# endif
	/* others will be done later */
}





# else

inittaz()
{
	node = (NODE *) ckalloc ( maxnodesz * sizeof (NODE) );
	taz =  (char *) ckalloc ( maxtascizsz * sizeof(char) );
}

# endif /* ifndef FORT */
@


55.1
log
@Automatic bump of revision number for PWS version 3.25A
@
text
@@


54.1
log
@Automatic bump of revision number for PWS version 3.24
@
text
@@


53.1
log
@Automatic bump of revision number for PWS version 3.24B
@
text
@@


52.1
log
@Automatic bump of revision number for PWS version 3.24A
@
text
@@


51.1
log
@Automatic bump of revision number for PWS version 3.24d
@
text
@@


50.1
log
@Automatic bump of revision number for PWS version 3.23c
@
text
@@


49.1
log
@Automatic bump of revision number for PWS version 3.24b
@
text
@@


48.1
log
@Automatic bump of revision number for PWS version 3.24a
@
text
@@


47.1
log
@Automatic bump of revision number for PWS version 3.23
@
text
@@


46.1
log
@Automatic bump of revision number for PWS version 3.23
@
text
@@


45.1
log
@Automatic bump of revision number for PWS version 3.23C
@
text
@@


44.1
log
@Automatic bump of revision number for PWS version 3.23B
@
text
@@


43.1
log
@Automatic bump of revision number for PWS version 3.23aA
@
text
@@


42.1
log
@Automatic bump of revision number for PWS version 3.23e
@
text
@@


41.1
log
@Automatic bump of revision number for PWS version 3.23d
@
text
@@


40.1
log
@Automatic bump of revision number for PWS version 3.23c
@
text
@@


39.1
log
@Automatic bump of revision number for PWS version 3.23b
@
text
@@


38.1
log
@Automatic bump of revision number for PWS version 3.23a
@
text
@@


37.1
log
@Automatic bump of revision number for PWS version 3.3a
@
text
@@


36.1
log
@Automatic bump of revision number for PWS version 3.22
@
text
@@


35.1
log
@Automatic bump of revision number for PWS version 3.22
@
text
@@


34.1
log
@Automatic bump of revision number for PWS version 3.22
@
text
@@


33.1
log
@Automatic bump of revision number for PWS version 3.22D
@
text
@@


32.1
log
@Automatic bump of revision number for PWS version 3.22C
@
text
@@


31.1
log
@Automatic bump of revision number for PWS version 3.22B
@
text
@@


30.1
log
@Automatic bump of revision number for PWS version 3.22A
@
text
@@


29.1
log
@Automatic bump of revision number for PWS version 3.22b
@
text
@@


28.1
log
@Automatic bump of revision number for PWS version 3.3b
@
text
@@


27.1
log
@Automatic bump of revision number for PWS version 3.3a
@
text
@@


26.1
log
@Automatic bump of revision number for PWS version 3.3 Synch
@
text
@@


25.1
log
@Automatic bump of revision number for PWS version 3.2Y
@
text
@@


24.1
log
@Automatic bump of revision number for PWS version 3.2
@
text
@@


23.1
log
@Automatic bump of revision number for PWS version 3.2P
@
text
@@


22.1
log
@Automatic bump of revision number for PWS version 3.2N
@
text
@@


21.1
log
@Automatic bump of revision number for PWS version 3.2M
@
text
@@


20.1
log
@Automatic bump of revision number for PWS version 3.2L
@
text
@@


19.1
log
@Automatic bump of revision number for PWS version 3.2K
@
text
@@


18.1
log
@Automatic bump of revision number for PWS version 3.2J
@
text
@@


17.1
log
@Automatic bump of revision number for PWS version 3.2I+
@
text
@@


16.1
log
@Automatic bump of revision number for PWS version 3.2I
@
text
@@


15.1
log
@Automatic bump of revision number for PWS version 3.2H
@
text
@@


14.1
log
@Automatic bump of revision number for PWS version 3.2G
@
text
@@


13.1
log
@Automatic bump of revision number for PWS version 3.2F
@
text
@@


12.1
log
@Automatic bump of revision number for PWS version 3.2E
@
text
@@


11.1
log
@Automatic bump of revision number for PWS version 3.2D
@
text
@@


10.1
log
@Automatic bump of revision number for PWS version 3.2C
@
text
@@


9.1
log
@Automatic bump of revision number for PWS version 3.2B
@
text
@@


8.1
log
@Automatic bump of revision number for PWS version 3.2A
@
text
@@


7.1
log
@Automatic bump of revision number for PWS version 3.2l
@
text
@@


6.1
log
@Automatic bump of revision number for PWS version 3.2k
@
text
@@


5.1
log
@Automatic bump of revision number for PWS version 3.2j
@
text
@@


1.1
log
@Initial revision
@
text
@@
