Subversion Repositories planix.SVN

/* POSIX DEPENDENT PROCEDURES */
#include "defs.h"
#include <sys/stat.h>
#include <ar.h>

#define NAMESPERBLOCK   32

/* DEFAULT RULES FOR POSIX */

char *dfltmacro[] =
        {
        ".SUFFIXES : .o .c .y .l .a .sh .f",
        "MAKE=make",
        "AR=ar",
        "ARFLAGS=rv",
        "YACC=yacc",
        "YFLAGS=",
        "LEX=lex",
        "LFLAGS=",
        "LDFLAGS=",
        "CC=c89",
        "CFLAGS=-O",
        "FC=fort77",
        "FFLAGS=-O 1",
        0 };

char *dfltpat[] =
        {
        "%.o : %.c",
        "\t$(CC) $(CFLAGS) -c $<",

        "%.o : %.y",
        "\t$(YACC) $(YFLAGS) $<",
        "\t$(CC) $(CFLAGS) -c y.tab.c",
        "\trm y.tab.c",
        "\tmv y.tab.o $@",

        "%.o : %.l",
        "\t$(LEX) $(LFLAGS) $<",
        "\t$(CC) $(CFLAGS) -c lex.yy.c",
        "\trm lex.yy.c",
        "\tmv lex.yy.o $@",

        "%.c : %.y",
        "\t$(YACC) $(YFLAGS) $<",
        "\tmv y.tab.c $@",

        "%.c : %.l",
        "\t$(LEX) $(LFLAGS) $<",
        "\tmv lex.yy.c $@",

        "% : %.o",
        "\t$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<",

        "% : %.c",
        "\t$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<",

        0 };



char *dfltsuff[] =
        {
        ".SUFFIXES : .o .c .y .l .a .sh .f",
        ".c.o :",
        "\t$(CC) $(CFLAGS) -c $<",

        ".f.o :",
        "\t$(FC) $(FFLAGS) -c $<",

        ".y.o :",
        "\t$(YACC) $(YFLAGS) $<",
        "\t$(CC) $(CFLAGS) -c y.tab.c",
        "\trm -f y.tab.c",
        "\tmv y.tab.o $@",

        ".l.o :",
        "\t$(LEX) $(LFLAGS) $<",
        "\t$(CC) $(CFLAGS) -c lex.yy.c",
        "\trm -f lex.yy.c",
        "\tmv lex.yy.o $@",

        ".y.c :",
        "\t$(YACC) $(YFLAGS) $<",
        "\tmv y.tab.c $@",

        ".l.c :",
        "\t$(LEX) $(LFLAGS) $<",
        "\tmv lex.yy.c $@",

        ".c.a:",
        "\t$(CC) -c $(CFLAGS) $<",
        "\t$(AR) $(ARFLAGS) $@ $*.o",
        "\trm -f $*.o",

        ".f.a:",
        "\t$(FC) -c $(FFLAGS) $<",
        "\t$(AR) $(ARFLAGS) $@ $*.o",
        "\trm -f $*.o",

        ".c:",
        "\t$(CC) $(CFLAGS) $(LDFLAGS) -o $@ $<",

        ".f:",
        "\t$(FC) $(FFLAGS) $(LDFLAGS) -o $@ $<",

        ".sh:",
        "\tcp $< $@",
        "\tchmod a+x $@",

        0 };


static struct dirhd     *opdir(char *, int);
static void             cldir(struct dirhd *, int);
static int              amatch(char *, char *);
static int              umatch(char *, char *);
static void             clarch(void);
static int              openarch(char *);
static int              getarch(void);

time_t
exists(char *filename)
{
struct stat buf;
char *s;

for(s = filename ; *s!='\0' && *s!='(' &&  *s!=')' ; ++s)
        ;

if(*s != '\0')
        return lookarch(filename);

if(stat(filename,&buf) < 0) 
        return 0;
else    return buf.st_mtime;
}


time_t
prestime(void)
{
time_t t;
time(&t);
return t;
}

static char nmtemp[MAXNAMLEN+1];        /* guarantees a null after the name */
static char *tempend = nmtemp + MAXNAMLEN;



depblkp
srchdir(char *pat, int mkchain, depblkp nextdbl)
{
DIR *dirf;
struct dirhd *dirptr;
char *dirname, *dirpref, *endir, *filepat, *p, temp[100];
char fullname[100];
nameblkp q;
depblkp thisdbl;
struct pattern *patp;

struct dirent *dptr;

thisdbl = 0;

if(mkchain == NO)
        for(patp=firstpat ; patp ; patp = patp->nxtpattern)
                if(equal(pat, patp->patval)) return 0;

patp = ALLOC(pattern);
patp->nxtpattern = firstpat;
firstpat = patp;
patp->patval = copys(pat);

endir = 0;

for(p=pat; *p!='\0'; ++p)
        if(*p=='/') endir = p;

if(endir==0)
        {
        dirname = ".";
        dirpref = "";
        filepat = pat;
        }
else    {
        dirname = pat;
        *endir = '\0';
        dirpref = concat(dirname, "/", temp);
        filepat = endir+1;
        }

dirptr = opdir(dirname,YES);
dirf = dirptr->dirfc;

for( dptr = readdir(dirf) ; dptr ; dptr = readdir(dirf) )
        {
        char *p1, *p2;
        p1 = dptr->d_name;
        p2 = nmtemp;
        while( (p2<tempend) && (*p2++ = *p1++)!='\0')
                ;
        if( amatch(nmtemp,filepat) )
                {
                concat(dirpref,nmtemp,fullname);
                if( (q=srchname(fullname)) ==0)
                        q = makename(copys(fullname));
                if(mkchain)
                        {
                        thisdbl = ALLOC(depblock);
                        thisdbl->nxtdepblock = nextdbl;
                        thisdbl->depname = q;
                        nextdbl = thisdbl;
                        }
                }
        }


if(endir)
        *endir = '/';

cldir(dirptr, YES);

return thisdbl;
}

static struct dirhd *
opdir(char *dirname, int stopifbad)
{
struct dirhd *od;

for(od = firstod; od; od = od->nxtdirhd)
        if(equal(dirname, od->dirn) )
                break;

if(od == NULL)
        {
        ++nopdir;
        od = ALLOC(dirhd);
        od->nxtdirhd = firstod;
        firstod = od;
        od->dirn = copys(dirname);
        }

if(od->dirfc==NULL && (od->dirfc = opendir(dirname)) == NULL && stopifbad)
        {
        fprintf(stderr, "Directory %s: ", dirname);
        fatal("Cannot open");
        }

return od;
}


static void
cldir(struct dirhd *dp, int used)
{
if(nopdir >= MAXDIR)
        {
        closedir(dp->dirfc);
        dp->dirfc = NULL;
        }
else if(used)
        rewinddir(dp->dirfc); /* start over at the beginning  */
}

/* stolen from glob through find */

static int
amatch(char *s, char *p)
{
        int cc, scc, k;
        int c, lc;

        scc = *s;
        lc = 077777;
        switch (c = *p) {

        case '[':
                k = 0;
                while (cc = *++p) {
                        switch (cc) {

                        case ']':
                                if (k)
                                        return amatch(++s, ++p);
                                else
                                        return 0;

                        case '-':
                                k |= (lc <= scc)  & (scc <= (cc=p[1]) ) ;
                        }
                        if (scc==(lc=cc)) k++;
                }
                return 0;

        case '?':
        caseq:
                if(scc) return amatch(++s, ++p);
                return 0;
        case '*':
                return umatch(s, ++p);
        case 0:
                return !scc;
        }
        if (c==scc) goto caseq;
        return 0;
}

static int
umatch(char *s, char *p)
{
        if(*p==0) return 1;
        while(*s)
                if (amatch(s++,p)) return 1;
        return 0;
}

#ifdef METERFILE
#include <pwd.h>
int meteron     = 0;    /* default: metering off */

extern void meter(char *file)
{
time_t tvec;
char *p;
FILE * mout;
struct passwd *pwd;

if(file==0 || meteron==0) return;

pwd = getpwuid(getuid());

time(&tvec);

if( mout = fopen(file,"a") )
        {
        p = ctime(&tvec);
        p[16] = '\0';
        fprintf(mout, "User %s, %s\n", pwd->pw_name, p+4);
        fclose(mout);
        }
}
#endif


/* look inside archives for notation a(b)
        a(b)    is file member   b   in archive a
*/

static long arflen;
static long arfdate;
static char arfname[16];
FILE *arfd;
long int arpos, arlen;

time_t
lookarch(char *filename)
{
char *p, *q, *send, s[15], pad;
int i, nc, nsym;

for(p = filename; *p!= '(' ; ++p)
        ;

*p = '\0';
if( ! openarch(filename) )
        {
        *p = '(';
        return 0L;
        }
*p++ = '(';
nc = 14;
pad = ' ';

send = s + nc;
for( q = s ; q<send && *p!='\0' && *p!=')' ; *q++ = *p++ )
        ;
if(p[0]==')' && p[1]!='\0')     /* forbid stuff after the paren */
        {
        clarch();
        return 0L;
        }
while(q < send)
        *q++ = pad;
while(getarch())
        {
        if( !strncmp(arfname, s, nc))
                {
                clarch();
/*TEMP fprintf(stderr, "found archive member %14s, time=%d\n", s, arfdate); */
                return arfdate;
                }
        }

clarch();
return  0L;
}

static void
clarch(void)
{
fclose( arfd );
}

static int
openarch(char *f)
{
char magic[SARMAG];
int word;
struct stat buf;
nameblkp p;

stat(f, &buf);
arlen = buf.st_size;

arfd = fopen(f, "r");
if(arfd == NULL)
        return NO;
        /* fatal1("cannot open %s", f); */

fread( (char *) &word, sizeof(word), 1, arfd);

fseek(arfd, 0L, 0);
fread(magic, SARMAG, 1, arfd);
arpos = SARMAG;
if( strncmp(magic, ARMAG, SARMAG) )
        fatal1("%s is not an archive", f);

if( !(p = srchname(f)) )
        p = makename( copys(f) );
p->isarch = YES;
arflen = 0;
return YES;
}


static int
getarch(void)
{
struct ar_hdr arhead;

arpos += (arflen + 1) & ~1L;    /* round archived file length up to even */
if(arpos >= arlen)
        return 0;
fseek(arfd, arpos, 0);

fread( (char *) &arhead, sizeof(arhead), 1, arfd);
arpos += sizeof(arhead);
arflen = atol(arhead.ar_size);
arfdate = atol(arhead.ar_date);
strncpy(arfname, arhead.ar_name, sizeof(arhead.ar_name));
return 1;
}

/* find the directory containing name.
   read it into the hash table if it hasn't been used before or if
   if might have changed since last reference
*/

void
dirsrch(char *name)
{
DIR *dirf;
struct dirhd *dirp;
time_t dirt, objt;
int dirused, hasparen;
char *dirname, *lastslash;
char *fullname, *filepart, *fileend, *s;
struct dirent *dptr;

lastslash = NULL;
hasparen = NO;

for(s=name; *s; ++s)
        if(*s == '/')
                lastslash = s;
        else if(*s=='(' || *s==')')
                hasparen = YES;

if(hasparen)
        {
        if(objt = lookarch(name))
                makename(name)->modtime = objt;
        return;
        }

if(lastslash)
        {
        dirname = name;
        *lastslash = '\0';
        }
else
        dirname = ".";

dirused = NO;
dirp = opdir(dirname, NO);
dirf = dirp->dirfc;
if(dirp->dirok || !dirf)
        goto ret;
dirt = exists(dirname);
if(dirp->dirtime == dirt)
        goto ret;

dirp->dirok = YES;
dirp->dirtime = dirt;
dirused = YES;

/* allocate buffer to hold full file name */
if(lastslash)
        {
        fullname = (char *) ckalloc(strlen(dirname)+MAXNAMLEN+2);
        concat(dirname, "/", fullname);
        filepart = fullname + strlen(fullname);
        }
else
        filepart = fullname = (char *) ckalloc(MAXNAMLEN+1);


fileend = filepart + MAXNAMLEN;
*fileend = '\0';
for(dptr = readdir(dirf) ; dptr ; dptr = readdir(dirf) )
        {
        char *p1, *p2;
        p1 = dptr->d_name;
        p2 = filepart;
        while( (p2<fileend) && (*p2++ = *p1++)!='\0')
                ;
        if( ! srchname(fullname) )
                (void) makename(copys(fullname));
        }

free(fullname);

ret:
        cldir(dirp, dirused);
        if(lastslash)
                *lastslash = '/';
}



void
baddirs(void)
{
struct dirhd *od;

for(od = firstod; od; od = od->nxtdirhd)
        od->dirok = NO;
}