#include "defs.h"

static int	hasslash(char *);
static int	haspercent(char *);
static void	rehash(void);

/* simple linear hash.  hash function is sum of
   characters mod hash table size.
*/
static int
hashloc(char *s)
{
int i;
int hashval;
char *t;

hashval = 0;

for(t=s; *t!='\0' ; ++t)
	hashval += *t;

hashval %= hashsize;

for(i=hashval;
	hashtab[i]!=0 && !equal(s,hashtab[i]->namep);
	i = i >= hashsize-1 ? 0 : i+1) ;

return i;
}


nameblkp
srchname(char *s)
{
return  hashtab[hashloc(s)] ;
}



nameblkp
makename(char *s)
{
nameblkp p;

if(nhashed > hashthresh)
	rehash();

++nhashed;
hashtab[hashloc(s)] = p = ALLOC(nameblock);
p->nxtnameblock = firstname;
p->namep = copys(s);	/* make a fresh copy of the string s */
/* p->linep = 0; p->done = 0; p->septype = 0; p->modtime = 0; */

firstname = p;
if(mainname==NULL && !haspercent(s) && (*s!='.' || hasslash(s)) )
	mainname = p;

return p;
}


static int
hasslash(char *s)
{
for( ; *s ; ++s)
	if(*s == '/')
		return YES;
return NO;
}

static int
haspercent(char *s)
{
for( ; *s ; ++s)
	if(*s == '%')
		return YES;
return NO;
}

int
hasparen(char *s)
{
for( ; *s ; ++s)
	if(*s == '(')
		return YES;
return NO;
}

static void
rehash(void)
{
nameblkp *ohash;
nameblkp p, *hp, *endohash;
hp = ohash = hashtab;
endohash = hashtab + hashsize;

newhash(2*hashsize);

while( hp<endohash )
	if(p = *hp++)
		hashtab[hashloc(p->namep)] = p;

free( (char *) ohash);
}


void
newhash(int newsize)
{
hashsize = newsize;
hashtab = (nameblkp *) ckalloc(hashsize * sizeof(nameblkp));
hashthresh = (2*hashsize)/3;
}



nameblkp chkname(char *s)
{
nameblkp p;
time_t k;
/*TEMP NEW */
if(hasparen(s))
	{
	k = lookarch(s);
/*TEMP	fprintf(stderr, "chkname(%s): look=%d\n", s, k); */
	if(k == 0)
		return NULL;
	}
if(p = srchname(s))
	return p;
dirsrch(s);
return srchname(s);
}



char *
copys(char *s)
{
char *t;

if( (t = malloc( strlen(s)+1 ) ) == NULL)
	fatal("out of memory");
strcpy(t, s);
return t;
}



char *
concat(char *a, char *b, char *c)   /* c = concatenation of a and b */
{
char *t;
t = c;

while(*t = *a++) t++;
while(*t++ = *b++);
return c;
}


int
suffix(char *a, char *b, char *p)  /* is b the suffix of a?  if so, set p = prefix */
{
char *a0,*b0;
a0 = a;
b0 = b;

while(*a++);
while(*b++);

if( (a-a0) < (b-b0) ) return 0;

while(b>b0)
	if(*--a != *--b) return 0;

while(a0<a) *p++ = *a0++;
*p = '\0';

return 1;
}

int *
ckalloc(int n)
{
int *p;

if( p = (int *) calloc(1,n) )
	return p;

fatal("out of memory");
/* NOTREACHED */
return 0;
}

/* copy string a into b, substituting for arguments */
char *
subst(char *a, char *b)
{
static depth	= 0;
char *s;
char vname[100];
struct varblock *vbp;
char closer;

if(++depth > 100)
	fatal("infinitely recursive macro?");
if(a)  while(*a)
	{
	if(*a!='$' || a[1]=='\0' || *++a=='$')
		/* if a non-macro character copy it.  if $$ or $\0, copy $ */
		*b++ = *a++;
	else	{
		s = vname;
		if( *a=='(' || *a=='{' )
			{
			closer = ( *a=='(' ? ')' : '}');
			++a;
			while(*a == ' ') ++a;
			while(*a!=' ' && *a!=closer && *a!='\0') *s++ = *a++;
			while(*a!=closer && *a!='\0') ++a;
			if(*a == closer) ++a;
			}
		else	*s++ = *a++;

		*s = '\0';
		if( (vbp = varptr(vname)) ->varval != 0)
			{
			b = subst(vbp->varval, b);
			vbp->used = YES;
			}
		}
	}

*b = '\0';
--depth;
return b;
}

void
setvar(char *v, char *s, int dyn)
{
struct varblock *p;

p = varptr(v);
if( ! p->noreset )
	{
	p->varval = s;
	p->noreset = inarglist;
	if(p->used && !dyn)
		fprintf(stderr, "Warning: %s changed after being used\n",v);
	if(p->export)
		{
		/* change string pointed to by environment to new v=s */
		char *t;
		int lenv;
		lenv = strlen(v);
		*(p->export) = t = (char *) ckalloc(lenv + strlen(s) + 2);
		strcpy(t,v);
		t[lenv] = '=';
		strcpy(t+lenv+1, s);
		}
	else
		p->export = envpp;
	}
}


/* for setting Bradford's *D and *F family of macros whens setting * etc */
void
set3var(char *macro, char *value)
{
char *s;
char macjunk[8], *lastslash, *dirpart, *filepart;

setvar(macro, value, YES);
if(value == CHNULL)
	dirpart = filepart = CHNULL;
else
	{
	lastslash = CHNULL;
	for(s = value; *s; ++s)
		if(*s == '/')
			lastslash = s;
	if(lastslash)
		{
		dirpart = copys(value);
		filepart = dirpart + (lastslash-value);
		filepart[-1] = '\0';
		}
	else
		{
		dirpart = "";
		filepart = value;
		}
	}
setvar(concat(macro, "D", macjunk), dirpart, YES);
setvar(concat(macro, "F", macjunk), filepart, YES);
}


int
eqsign(char *a)   /*look for arguments with equal signs but not colons */
{
char *s, *t;
char c;

while(*a == ' ') ++a;
for(s=a  ;   *s!='\0' && *s!=':'  ; ++s)
	if(*s == '=')
		{
		for(t = a ; *t!='=' && *t!=' ' && *t!='\t' ;  ++t );
		c = *t;
		*t = '\0';

		for(++s; *s==' ' || *s=='\t' ; ++s);
		setvar(a, copys(s), NO);
		*t = c;
		return YES;
		}

return NO;
}

struct varblock *
varptr(char *v)
{
struct varblock *vp;

/* for compatibility, $(TGS) = $^ */
if(equal(v, "TGS") )
	v = "^";
for(vp = firstvar; vp ; vp = vp->nxtvarblock)
	if(equal(v , vp->varname))
		return vp;

vp = ALLOC(varblock);
vp->nxtvarblock = firstvar;
firstvar = vp;
vp->varname = copys(v);
vp->varval = 0;
return vp;
}

int
dynmacro(char *line)
{
char *s;
char endc, *endp;
if(!isalpha(line[0]))
	return NO;
for(s=line+1 ; *s && (isalpha(*s) | isdigit(*s)) ; ++s)
	;
endp = s;
while( isspace(*s) )
	++s;
if(s[0]!=':' || s[1]!='=')
	return NO;

endc = *endp;
*endp = '\0';
setvar(line, copys(s+2), YES);
*endp = endc;

return YES;
}


void
fatal1(char *s, char *t)
{
char buf[100];
sprintf(buf, s, t);
fatal(buf);
}


void
fatal(char *s)
{
fflush(stdout);
if(s)
	fprintf(stderr, "Make: %s.  Stop.\n", s);
else
	fprintf(stderr, "\nStop.\n");

waitstack(0);
exit(1);
}



/* appends to the chain for $? and $^ */
chainp
appendq(chainp head, char *tail)
{
chainp p, q;

p = ALLOC(chain);
p->datap = tail;

if(head)
	{
	for(q = head ; q->nextp ; q = q->nextp)
		;
	q->nextp = p;
	return head;
	}
else
	return p;
}





/* builds the value for $? and $^ */
char *
mkqlist(chainp p, char *qbuf)
{
char *qbufp, *s;

if(p == NULL)
	return "";

qbufp = qbuf;

for( ; p ; p = p->nextp)
	{
	s = p->datap;
	if(qbufp+strlen(s) > &qbuf[QBUFMAX-3])
		{
		fprintf(stderr, "$? list too long\n");
		break;
		}
	while (*s)
		*qbufp++ = *s++;
	*qbufp++ = ' ';
	}
*--qbufp = '\0';
return qbuf;
}

wildp
iswild(char *name)
{
char *s;
wildp p;

for(s=name; *s; ++s)
	if(*s == '%')
		{
		p = ALLOC(wild);
		*s = '\0';
		p->left = copys(name);
		*s = '%';
		p->right = copys(s+1);
		p->llen = strlen(p->left);
		p->rlen = strlen(p->right);
		p->totlen = p->llen + p->rlen;
		return p;
		}
return NULL;
}


char *
wildmatch(wildp p, char *name, int len)
{
char *stem;
char *s;
char c;

if(len < p->totlen ||
   strncmp(name, p->left, p->llen) ||
   strncmp(s = name+len-p->rlen, p->right, p->rlen) )
	return CHNULL;

/*TEMP fprintf(stderr, "wildmatch(%s)=%s%%%s)\n", name,p->left,p->right); */
c = *s;
*s = '\0';
stem = copys(name + p->llen);
*s = c;
return stem;
}



/* substitute stem for any % marks */
char *
wildsub(char *pat, char *stem)
{
static char temp[100];
char *s, *t;

s = temp;
for(; *pat; ++pat)
	if(*pat == '%')
		for(t = stem ; *t; )
			*s++ = *t++;
	else
		*s++ = *pat;
*s = '\0';
return temp;
}