# 2.11BSD#431 - /usr/src/bin/make/files.c

##### Functions

    clarch            X
    execat            X
    exists            X
    findfl            X
    fixname           X
    getarch           X
    lookarch          X
    meter             X
    openarch          X
    prestime          X
    srchdir           X

##### Variables

    FSTATIC           X
    arfile            X
    arfname           X
    arpos             X
    builtin           X
    meteron           X
    nbuf              X
    nbufend           X

##### Macros

    AR_ATOI           X
    DECIMAL           X
    OCTAL             X

##### typedef's

    HDR               X

       1: /* static	char *sccsid = "@(#)files.c	4.16.1 (2.11BSD) 1/3/94"; */
       2: #include <sys/param.h>
       3: #include <fcntl.h>
       4:
       5: /* UNIX DEPENDENT PROCEDURES */
       6:
       7: /* DEFAULT RULES FOR UNIX */
       8:
       9: char *builtin[] =
      10:     {
      11: #ifdef pwb
      12:     ".SUFFIXES : .L .out .a .o .c .f .e .r .y .yr .ye .l .s .z .x .t .h .cl",
      13: #else
      14:     ".SUFFIXES : .out .a .o .c .F .f .e .r .y .yr .ye .l .s .cl .p",
      15: #endif
      16:     "YACC=yacc",
      17:     "YACCR=yacc -r",
      18:     "YACCE=yacc -e",
      19:     "YFLAGS=",
      20:     "LEX=lex",
      21:     "LFLAGS=",
      22:     "CC=cc",
      23: #if defined(vax) || defined(sun) || defined(tahoe)
      24:     "AS=as",
      25: #else
      26:     "AS=as -",
      27: #endif
      28:     "PC=pc",
      29:     "PFLAGS=",
      30:     "CFLAGS=",
      31:     "RC=f77",
      32:     "RFLAGS=",
      33:     "FC=f77",
      34:     "EFLAGS=",
      35:     "FFLAGS=",
      36:     "LOADLIBES=",
      37: #ifdef pwb
      38:     "SCOMP=scomp",
      39:     "SCFLAGS=",
      40:     "CMDICT=cmdict",
      41:     "CMFLAGS=",
      42: #endif
      43:
      44:     ".c.a :",
      45:     "\t$(CC) $(CFLAGS) -c $<",
      46:     "\tar r $@ $*.o",
      47:     "\trm -f $*.o",
      48:
      49:     ".c.o :",
      50:     "\t$(CC) $(CFLAGS) -c $<",
      51:
      52:     ".p.o :",
      53:     "\t$(PC) $(PFLAGS) -c $<",
      54:
      55:     ".cl.o :",
      56:     "\tclass -c $<",
      57:
      58:     ".e.o .r.o .F.o .f.o :",
      59:     "\t$(FC) $(RFLAGS) $(EFLAGS) $(FFLAGS) -c $<",
      60:
      61:     ".s.o :",
      62:     "\t$(AS) -o $@ $<",
      63:
      64:     ".y.o :",
      65:     "\t$(YACC) $(YFLAGS) $<",
      66:     "\t$(CC) $(CFLAGS) -c y.tab.c",
      67:     "\trm y.tab.c",
      68:     "\tmv y.tab.o $@",
      69:
      70:     ".yr.o:",
      71:     "\t$(YACCR) $(YFLAGS) $<",
      72:     "\t$(RC) $(RFLAGS) -c y.tab.r",
      73:     "\trm y.tab.r",
      74:     "\tmv y.tab.o $@",
      75:
      76:     ".ye.o :",
      77:     "\t$(YACCE) $(YFLAGS) $<",
      78:     "\t$(EC) $(RFLAGS) -c y.tab.e",
      79:     "\trm y.tab.e",
      80:     "\tmv y.tab.o $@",
      81:
      82:     ".l.o :",
      83:     "\t$(LEX) $(LFLAGS) $<",
      84:     "\t$(CC) $(CFLAGS) -c lex.yy.c",
      85:     "\trm lex.yy.c",
      86:     "\tmv lex.yy.o $@",
      87:
      88:     ".y.c :",
      89:     "\t$(YACC) $(YFLAGS) $<",
      90:     "\tmv y.tab.c $@",
      91:
      92:     ".l.c :",
      93:     "\t$(LEX) $(LFLAGS) $<",
      94:     "\tmv lex.yy.c $@",
      95:
      96:     ".yr.r:",
      97:     "\t$(YACCR) $(YFLAGS) $<",
      98:     "\tmv y.tab.r $@",
      99:
     100:     ".ye.e :",
     101:     "\t$(YACCE) $(YFLAGS) $<",
     102:     "\tmv y.tab.e $@",
     103:
     104: #ifdef pwb
     105:     ".o.L .c.L .t.L:",
     106:     "\t$(SCOMP) $(SCFLAGS) $<",
     107:
     108:     ".t.o:",
     109:     "\t$(SCOMP) $(SCFLAGS) -c $<",
     110:
     111:     ".t.c:",
     112:     "\t$(SCOMP) $(SCFLAGS) -t $<",
     113:
     114:     ".h.z .t.z:",
     115:     "\t$(CMDICT) $(CMFLAGS) $<",
     116:
     117:     ".h.x .t.x:",
     118:     "\t$(CMDICT) $(CMFLAGS) -c $<",
     119: #endif
     120:
     121:     ".s.out .c.out .o.out :",
     122:     "\t$(CC) $(CFLAGS) $< $(LOADLIBES) -o $@",
     123:
     124:     ".f.out .F.out .r.out .e.out :",
     125:     "\t$(FC) $(EFLAGS) $(RFLAGS) $(FFLAGS) $< $(LOADLIBES) -o $@",
     126:     "\t-rm $*.o",
     127:
     128:     ".y.out :",
     129:     "\t$(YACC) $(YFLAGS) $<",
     130:     "\t$(CC) $(CFLAGS) y.tab.c $(LOADLIBES) -ly -o $@",
     131:     "\trm y.tab.c",
     132:
     133:     ".l.out :",
     134:     "\t$(LEX) $(LFLAGS) $<",
     135:     "\t$(CC) $(CFLAGS) lex.yy.c $(LOADLIBES) -ll -o $@",
     136:     "\trm lex.yy.c",
     137:
     138:     0 };
     139:
     140: #include "defs"
     141: #include <sys/stat.h>
     142:
     143:
     144:
     145: TIMETYPE
     146: exists(pname)
     147: struct nameblock *pname;
     148: {
     149: struct stat buf;
     150: register char *s, *filename;
     151: TIMETYPE lookarch();
     152: extern char *findfl();
     153:
     154: filename = pname->namep;
     155:
     156: for(s = filename ; *s!='\0' && *s!='(' ; ++s)
     157:     ;
     158:
     159: if(*s == '(')
     160:     return(lookarch(filename));
     161:
     162: if (stat(filename, &buf) < 0)
     163: {
     164:     s = findfl(filename);
     165:     if(s != (char *)-1)
     166:     {
     167:         pname->alias = copys(s);
     168:         if(stat(pname->alias, &buf) == 0)
     169:             return(buf.st_mtime);
     170:     }
     171:     return(0);
     172: }
     173: else    return(buf.st_mtime);
     174: }
     175:
     176:
     177: TIMETYPE prestime()
     178: {
     179: TIMETYPE t;
     180: time(&t);
     181: return(t);
     182: }
     183:
     184:
     185:
     186: FSTATIC char nbuf[MAXNAMLEN + 1];
     187: FSTATIC char *nbufend   = &nbuf[MAXNAMLEN];
     188:
     189:
     190:
     191: struct depblock *srchdir(pat, mkchain, nextdbl)
     192: register char *pat; /* pattern to be matched in directory */
     193: int mkchain;  /* nonzero if results to be remembered */
     194: struct depblock *nextdbl;  /* final value for chain */
     195: {
     196: register DIR *dirf;
     197: int cldir;
     198: char *dirname, *dirpref, *endir, *filepat, *p, temp[MAXPATHLEN];
     199: char fullname[MAXPATHLEN], *p1, *p2;
     200: struct nameblock *q;
     201: struct depblock *thisdbl;
     202: struct dirhdr *od;
     203: struct pattern *patp;
     204: struct varblock *cp, *varptr();
     205: char *path, pth[MAXPATHLEN], *strcpy();
     206: struct direct *dptr;
     207:
     208:
     209: thisdbl = 0;
     210:
     211: if(mkchain == NO)
     212:     for(patp=firstpat ; patp ; patp = patp->nxtpattern)
     213:         if(! unequal(pat, patp->patval)) return(0);
     214:
     215: patp = ALLOC(pattern);
     216: patp->nxtpattern = firstpat;
     217: firstpat = patp;
     218: patp->patval = copys(pat);
     219:
     220: endir = 0;
     221:
     222: for(p=pat; *p!='\0'; ++p)
     223:     if(*p=='/') endir = p;
     224:
     225: if(endir==0)
     226:     {
     227:     dirpref = "";
     228:     filepat = pat;
     229:     cp = varptr("VPATH");
     230:     if (cp->varval == NULL) path = ".";
     231:     else {
     232:            path = pth;
     233:            *path = '\0';
     234:         /*
     235: 		 * expand VPATH; this is almost surely not the place to do
     236: 		 * this, but I have no intention whatsoever of attempting
     237: 		 * to understand this code.
     238: 		 */
     239:            if (strncmp(cp->varval, ".:", 2) != 0) {
     240:             strcpy(pth,".:");
     241:             subst(cp->varval, pth + 2);
     242:         }
     243:         else
     244:             subst(cp->varval, pth);
     245:            }
     246:     }
     247: else    {
     248:     *endir = '\0';
     249:     path = strcpy(pth, pat);
     250:     dirpref = concat(pat, "/", temp);
     251:     filepat = endir+1;
     252:     }
     253:
     254: while (*path) {         /* Loop thru each VPATH directory */
     255:   dirname = path;
     256:   for (; *path; path++)
     257:     if (*path == ':') {
     258:       *path++ = '\0';
     259:       break;
     260:       }
     261:
     262: dirf = NULL;
     263: cldir = NO;
     264:
     265: for(od = firstod; od; od = od->nxtopendir)
     266:     if(! unequal(dirname, od->dirn) )
     267:         {
     268:         dirf = od->dirfc;
     269:         if (dirf != NULL)
     270:             rewinddir(dirf); /* start over at the beginning  */
     271:         break;
     272:         }
     273:
     274: if(dirf == NULL)
     275:     {
     276:     dirf = opendir(dirname);
     277:     if(nopdir >= MAXDIR)
     278:         cldir = YES;
     279:     else    {
     280:         ++nopdir;
     281:         od = ALLOC(dirhdr);
     282:         od->nxtopendir = firstod;
     283:         firstod = od;
     284:         od->dirfc = dirf;
     285:         od->dirn = copys(dirname);
     286:         fcntl(dirf->dd_fd, F_SETFD, 1);
     287:         }
     288:     }
     289:
     290: if(dirf == NULL)
     291:     {
     292:     fprintf(stderr, "Directory %s: ", dirname);
     293:     fatal("Cannot open");
     294:     }
     295:
     296: else for (dptr = readdir(dirf); dptr != NULL; dptr = readdir(dirf))
     297:     {
     298:     p1 = dptr->d_name;
     299:     p2 = nbuf;
     300:     while( (p2<nbufend) && (*p2++ = *p1++)!='\0' )
     301:         /* void */;
     302:     if( amatch(nbuf,filepat) )
     303:         {
     304:         concat(dirpref,nbuf,fullname);
     305:         if( (q=srchname(fullname)) ==0)
     306:             q = makename(copys(fullname));
     307:         if(mkchain)
     308:             {
     309:             thisdbl = ALLOC(depblock);
     310:             thisdbl->nxtdepblock = nextdbl;
     311:             thisdbl->depname = q;
     312:             nextdbl = thisdbl;
     313:             }
     314:         }
     315:     }
     316:
     317: if(endir != 0)  *endir = '/';
     318:
     319: if(cldir) {
     320:     closedir(dirf);
     321:     dirf = NULL;
     322: }
     323: } /* End of VPATH loop */
     324: return(thisdbl);
     325: }
     326:
     327: /* stolen from glob through find */
     328:
     329: static amatch(s, p)
     330: char *s, *p;
     331: {
     332:     register int cc, scc, k;
     333:     int c, lc;
     334:
     335:     scc = *s;
     336:     lc = 077777;
     337:     switch (c = *p) {
     338:
     339:     case '[':
     340:         k = 0;
     341:         while (cc = *++p) {
     342:             switch (cc) {
     343:
     344:             case ']':
     345:                 if (k)
     346:                     return(amatch(++s, ++p));
     347:                 else
     348:                     return(0);
     349:
     350:             case '-':
     351:                 k |= (lc <= scc)  & (scc <= (cc=p[1]) ) ;
     352:             }
     353:             if (scc==(lc=cc)) k++;
     354:         }
     355:         return(0);
     356:
     357:     case '?':
     358:     caseq:
     359:         if(scc) return(amatch(++s, ++p));
     360:         return(0);
     361:     case '*':
     362:         return(umatch(s, ++p));
     363:     case 0:
     364:         return(!scc);
     365:     }
     366:     if (c==scc) goto caseq;
     367:     return(0);
     368: }
     369:
     370: static umatch(s, p)
     371: char *s, *p;
     372: {
     373:     if(*p==0) return(1);
     374:     while(*s)
     375:         if (amatch(s++,p)) return(1);
     376:     return(0);
     377: }
     378:
     379: #ifdef METERFILE
     380: #include <pwd.h>
     381: int meteron = 0;    /* default: metering off */
     382:
     383: meter(file)
     384: char *file;
     385: {
     386: TIMETYPE tvec;
     387: char *p, *ctime();
     388: FILE * mout;
     389: struct passwd *pwd, *getpwuid();
     390:
     391: if(file==0 || meteron==0) return;
     392:
     393: pwd = getpwuid(getuid());
     394:
     395: time(&tvec);
     396:
     397: if( (mout=fopen(file,"a")) != NULL )
     398:     {
     399:     p = ctime(&tvec);
     400:     p[16] = '\0';
     401:     fprintf(mout,"User %s, %s\n",pwd->pw_name,p+4);
     402:     fclose(mout);
     403:     }
     404: }
     405: #endif
     406:
     407:
     408: /* look inside archive for notation a(b)
     409: 	a(b)	is file member   b   in archive a
     410: */
     411:
     412: #include <ar.h>
     413: #include "archive.h"    /* from 'ar's directory */
     414:
     415:     char arfile[MAXPATHLEN];
     416:     CHDR    chdr;
     417:     char *arfname = chdr.name;
     418:     FILE *arfd;
     419:     off_t arpos;
     420:
     421: TIMETYPE lookarch(filename)
     422:     char *filename;
     423:     {
     424:     char *p, *q, *send, s[MAXNAMLEN + 1];
     425:
     426:     for (p = filename; *p!= '(' ; ++p)
     427:         ;
     428:     *p = '\0';
     429:     strcpy(arfile, filename);
     430:     openarch(filename);
     431:     *p++ = '(';
     432:
     433:     send = s + sizeof(s);
     434:
     435:     for( q = s; q < send && *p!='\0' && *p!=')' ; *q++ = *p++)
     436:         ;
     437:     *q++ = '\0';
     438:     while   (getarch())
     439:         {
     440:         if  (!strcmp(arfname, s))
     441:             {
     442:             clarch();
     443:             return(chdr.date);
     444:             }
     445:         arpos += (chdr.size + (chdr.size + chdr.lname & 1));
     446:         arpos += sizeof (struct ar_hdr);
     447:         }
     448:     strcpy(chdr.name, s);
     449:     clarch();
     450:     return(0L);
     451:     }
     452:
     453:
     454: clarch()
     455: {
     456: if (arfd)
     457:     fclose( arfd );
     458: }
     459:
     460:
     461: openarch(f)
     462: register char *f;
     463:     {
     464:     char    magic[SARMAG];
     465:
     466:     arfd = fopen(f, "r");
     467:     if  (arfd == NULL)
     468:         return;
     469:
     470:     fseek(arfd, 0L, 0);
     471:     fread(magic, SARMAG, 1, arfd);
     472:     arpos = SARMAG;
     473:     if  (strncmp(magic, ARMAG, SARMAG))
     474:         fatal1("%s is not an archive", f);
     475:     }
     476:
     477: /*
     478:  * "borrowed" from 'ld' because we didn't want to drag in everything
     479:  * from 'ar'.  The error checking was also ripped out, basically if any
     480:  * of the criteria for being an archive are not met then a -1 is returned
     481:  * and the rest of 'make' figures out what to do (bails out).
     482: */
     483:
     484: typedef struct ar_hdr HDR;
     485: extern  long    strtol();
     486:
     487: /* Convert ar header field to an integer. */
     488: #define AR_ATOI(from, to, len, base) { \
     489:     bcopy(from, buf, len); \
     490:     buf[len] = '\0'; \
     491:     to = strtol(buf, (char **)NULL, base); \
     492: }
     493:
     494: getarch()
     495: {
     496:     char hb[sizeof(HDR) + 1];   /* real header */
     497:     struct ar_hdr arhead;
     498:     register HDR *hdr;
     499:     register int len;
     500:     int nr;
     501:     register char *p;
     502:     char buf[20];
     503:
     504:     if (!arfd)
     505:         return(0);
     506:     fseek(arfd, arpos, 0);
     507:
     508:     nr = fread(hb, 1, sizeof(HDR), arfd);
     509:     if (nr != sizeof(HDR))
     510:         return(0);
     511:
     512:     hdr = (HDR *)hb;
     513:     if (strncmp(hdr->ar_fmag, ARFMAG, sizeof(ARFMAG) - 1))
     514:         return(0);
     515:
     516:     /* Convert the header into the internal format. */
     517: #define DECIMAL 10
     518: #define OCTAL    8
     519:
     520:     AR_ATOI(hdr->ar_date, chdr.date, sizeof(hdr->ar_date), DECIMAL);
     521:     AR_ATOI(hdr->ar_uid, chdr.uid, sizeof(hdr->ar_uid), DECIMAL);
     522:     AR_ATOI(hdr->ar_gid, chdr.gid, sizeof(hdr->ar_gid), DECIMAL);
     523:     AR_ATOI(hdr->ar_mode, chdr.mode, sizeof(hdr->ar_mode), OCTAL);
     524:     AR_ATOI(hdr->ar_size, chdr.size, sizeof(hdr->ar_size), DECIMAL);
     525:
     526:     /* Leading spaces should never happen. */
     527:     if (hdr->ar_name[0] == ' ')
     528:         return(-1);
     529:
     530:     /*
     531: 	 * Long name support.  Set the "real" size of the file, and the
     532: 	 * long name flag/size.
     533: 	 */
     534:     if (!bcmp(hdr->ar_name, AR_EFMT1, sizeof(AR_EFMT1) - 1)) {
     535:         chdr.lname = len = atoi(hdr->ar_name + sizeof(AR_EFMT1) - 1);
     536:         if (len <= 0 || len > MAXNAMLEN)
     537:             return(-1);
     538:         nr = fread(chdr.name, 1, (size_t)len, arfd);
     539:         if (nr != len)
     540:             return(0);
     541:         chdr.name[len] = 0;
     542:         chdr.size -= len;
     543:     } else {
     544:         chdr.lname = 0;
     545:         bcopy(hdr->ar_name, chdr.name, sizeof(hdr->ar_name));
     546:
     547:         /* Strip trailing spaces, null terminate. */
     548:         for (p = chdr.name + sizeof(hdr->ar_name) - 1; *p == ' '; --p);
     549:         *++p = '\0';
     550:     }
     551:     return(1);
     552: }
     553:
     554: /*
     555:  *	findfl(name)	(like execvp, but does path search and finds files)
     556:  */
     557: static char fname[128];
     558:
     559: char *execat();
     560:
     561: char *findfl(name)
     562: register char *name;
     563: {
     564:     register char *p;
     565:     struct varblock *cp, *varptr();
     566:     struct stat buf;
     567:
     568:     for (p = name; *p; p++)
     569:         if(*p == '/') return(name);
     570:
     571:     cp = varptr("VPATH");
     572:     if(cp->varval == NULL || *cp->varval == 0)
     573:         p = ":";
     574:     else
     575:         p = cp->varval;
     576:
     577:     do
     578:     {
     579:         p = execat(p, name, fname);
     580:         if(stat(fname,&buf) >= 0)
     581:             return(fname);
     582:     } while (p);
     583:     return((char *)-1);
     584: }
     585:
     586: char *execat(s1, s2, si)
     587: register char *s1, *s2;
     588: char *si;
     589: {
     590:     register char *s;
     591:
     592:     s = si;
     593:     while (*s1 && *s1 != ':' && *s1 != '-')
     594:         *s++ = *s1++;
     595:     if (si != s)
     596:         *s++ = '/';
     597:     while (*s2)
     598:         *s++ = *s2++;
     599:     *s = '\0';
     600:     return(*s1? ++s1: 0);
     601: }
     602:
     603:
     604: /* copy s to d, changing file names to file aliases */
     605: fixname(s, d)
     606: char *s, *d;
     607: {
     608:     register char *r, *q;
     609:     struct nameblock *pn;
     610:     char name[MAXPATHLEN];
     611:
     612:     while (*s) {
     613:         if (isspace(*s)) *d++ = *s++;
     614:         else {
     615:             r = name;
     616:             while (*s) {
     617:                 if (isspace(*s)) break;
     618:                 *r++ = *s++;
     619:                 }
     620:             *r = '\0';
     621:
     622:             if (((pn = srchname(name)) != 0) && (pn->alias))
     623:                 q = pn->alias;
     624:             else q = name;
     625:
     626:             while (*q) *d++ = *q++;
     627:             }
     628:         }
     629:     *d = '\0';
     630: }

#### Defined functions

amatch defined in line 329; used 4 times

- in line 302, 346, 359, 375

clarch defined in line 454; used 2 times

- in line 442, 449

execat defined in line 586; used 2 times

- in line 559, 579

exists defined in line 145; used 4 times

- in /usr/src/bin/make/defs line 144
- in /usr/src/bin/make/doname.c line 88, 229
- in /usr/src/bin/make/main.c line 229

findfl defined in line 561; used 2 times

- in line 152, 164

fixname defined in line 605; used 1 times

- in /usr/src/bin/make/doname.c line 274

getarch defined in line 494; used 1 times

- in line 438

lookarch defined in line 421; used 2 times

- in line 151, 160

meter defined in line 383; used 1 times

- in /usr/src/bin/make/main.c line 73

openarch defined in line 461; used 1 times

- in line 430

prestime defined in line 177; used 4 times

- in /usr/src/bin/make/doname.c line 25, 132, 201, 230

srchdir defined in line 191; used 4 times

- in /usr/src/bin/make/doname.c line 27, 166, 341, 354

umatch defined in line 370; used 1 times

- in line 362

#### Defined variables

FSTATIC defined in line 186; never used
arfile defined in line 415; used 2 times

- in line 429
- in /usr/src/bin/make/doname.c line 202

arfname defined in line 417; used 2 times

- in line 440
- in /usr/src/bin/make/doname.c line 154

arpos defined in line 419; used 4 times

- in line 445-446(2), 472, 506

builtin defined in line 9; used 1 times

- in /usr/src/bin/make/main.c line 279

fname defined in line 557; used 3 times

- in line 579-581(3)

meteron defined in line 381; used 1 times

- in line 391

nbuf defined in line 186; used 4 times

- in line 187, 299-304(3)

nbufend defined in line 187; used 1 times

- in line 300

#### Defined typedef's

HDR defined in line 484; used 5 times

- in line 496-498(2), 508-512(3)

#### Defined macros

AR_ATOI defined in line 488; used 5 times

- in line 520-524(5)

DECIMAL defined in line 517; used 4 times

- in line 520-524(4)

OCTAL defined in line 518; used 1 times

- in line 523

Last modified: 1994-01-11 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 2209 |