ref: ec73849b6936d839410ccb239d14b2f7c7ca3d6f
dir: /sys/src/ape/cmd/make/misc.c/
#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");
return 0;/* NOTREACHED */
}
/* 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;
}