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

   1: static  char *sccsid = "@(#)gcos.c	4.3 (Berkeley) 85/08/30";
   2: /* GCOS DEPENDENT PROCEDURES */
   3: 
   4: 
   5: /* DEFAULT RULES FOR GCOS */
   6: 
   7: char *builtin[]
   8:     {
   9:     ".SUFFIXES : .d .c .y .lib",
  10:     ".d.c:",
  11:     "\t./dtgen $<",
  12:     ".y.c:",
  13:     "\t./yacc $<",
  14:     "\tcopy y.tab.c; /$@",
  15:     ".y.lib:",
  16:     "\t./yacc $<",
  17:     "\t./cc y.tab.c r=$@",
  18:     ".c.lib:",
  19:     "\t./cc $< r=$@",
  20:     0 };
  21: 
  22: # define MAXCSIZE 500
  23: # define YZERO 60
  24: 
  25: int gtcalled 0;
  26: 
  27: /* all kinds of static declarations that must be used.. */
  28: 
  29: static double day { 64*1000*60*60*24 };  /* length of day in clock ticks */
  30: 
  31: struct { int lhs:18, rhs:18; };
  32: struct catb {
  33:     int words[6],
  34:     name1, name2,
  35:     passw1, passw2,
  36:     word10, word11,
  37:     datcreat, datmod,  datused,
  38:     stuff[6],
  39:     jjjj:18, tused:18;
  40:     };
  41: struct { int :3, slot:18; };  /* slot where time from cat. block fits */
  42: 
  43: struct catdesc {
  44:     int cat1, cat2, cpass1, cpass2,
  45:         file1, file2, filep1, filep2,
  46:         endmark; };
  47: 
  48: extern int _q_reg, _a_reg;
  49: 
  50: 
  51: # define A10(x,y) 10*x + y
  52: 
  53: /*	interpret the mm/dd/yy format */
  54: 
  55: struct d9 { int :5, m1:4, :5, m2:4, :9,
  56:         :5, d1:4, :5, d2:4, :9,
  57:         :5, y1:4, :5, y2:4  ;};
  58: 
  59: struct d6 { int :2, m61:4, :2, m62:4,
  60:         :2, d61:4, :2, d62:4,
  61:         :2, y61:4, :2, y62:4; };
  62: 
  63: static day6( d6word ){ /* return the day number of a word in bci format */
  64:     int m, y, d;
  65: 
  66:     y = A10( d6word.y61, d6word.y62 );
  67:     m = A10( d6word.m61, d6word.m62 );
  68:     d = A10( d6word.d61, d6word.d62 );
  69: 
  70:     return( d + 31*( m + 12*(y-YZERO) ) );
  71:     }
  72: 
  73: static day9( p ) register int *p; {
  74: 
  75:     int m, y, d;
  76: 
  77:     y = A10( p->y1, p->y2 );
  78:     m = A10( p->m1, p->m2 );
  79:     d = A10( p->d1, p->d2 );
  80: 
  81:     return( d + 31*( m + 12*(y-YZERO) ) );
  82:     }
  83: 
  84: 
  85: static int dfold( dayno, timeno ){
  86:     int kk;
  87:     kk = ( day*dayno + timeno) / 32768.;
  88:     }
  89: 
  90: int prestime(){
  91:     int date[2];
  92:     drldrl( 021, date );
  93:     return( dfold( day9(date), _q_reg ) );
  94:     }
  95: 
  96: 
  97: 
  98: # define DODRL ar[0] = status; ar[1] = &b.cat1; drldrl(30,sp1,sp2); p=ar[0]<<18;
  99: 
 100: static struct { int fn1, fn2;  int ftm; } fbb[MAXCSIZE];
 101: static int catsiz;
 102: 
 103: getcat() {
 104: 
 105:     register i, *p, j;
 106:     int asname[4];
 107:     struct catdesc b;
 108:     int sp1, sp2, temp;
 109:     int ar[2], status[2];
 110:     int filbuf[380];
 111: 
 112:     gtcalled = 1;
 113: 
 114:     sp1 = ar;
 115:     sp1 =>> 18;
 116:     sp2 = filbuf;
 117:     sp2 =>>18;
 118:     sp2.lhs = 19;
 119: 
 120:     b.cat1 = b.cat2 = b.file1 = -1;
 121:     b.cpass1 = b.cpass2 = 0202020202020;
 122: 
 123:     DODRL
 124:     sp2.lhs++;
 125:     for( i=0; p!=0 && i<MAXCSIZE; ++i ){
 126: 
 127:         fbb[i].fn1 = b.file1 = p->name1;
 128:         fbb[i].fn2 = b.file2 = p->name2;
 129:         b.filep1 = p->passw1;
 130:         b.filep2 = p->passw2;
 131:         b.endmark = -1;
 132:         temp = 0;
 133:         temp.slot = p->tused;
 134:         fbb[i].ftm = dfold( day6(p->datmod), temp );
 135:         DODRL
 136:         }
 137:     catsiz = i;
 138:     }
 139: 
 140:  exists( p )
 141:  struct nameblock *p; {
 142:     char *s, *cp, name[13];
 143:     int i, *p, bcd[2];
 144: 
 145: /*
 146:    cheat about names with slashes -- try opening;
 147:    if it is openable, it exists, and assume it was made
 148:    at t=1 (long time ago); otherwise, assume it
 149:    does not exist
 150: */
 151: 
 152: cp = p->namep;
 153: 
 154: for(s=cp ; *s ; ++s)
 155:     if(*s == '/')
 156:         if(i = copen(cp,'r') < 0)
 157:             return(0);
 158:         else    {
 159:             cclose(i);
 160:             return(1);
 161:             }
 162: 
 163: if(gtcalled == 0)  getcat();
 164: 
 165:     p = name;
 166:     for( i=0; *cp; ++i ) name[i] = *cp++;
 167:     while( i<12 ) name[i++] = ' ';
 168:     f9to6( *p, bcd[0], 12 );
 169:     for ( i=0; i<catsiz; ++i ){
 170:         if( fbb[i].fn1 == bcd[0] && fbb[i].fn2 == bcd[1] )
 171:             return( fbb[i].ftm );
 172:         }
 173:     return( 0 );
 174:     }
 175: 
 176: 
 177: #include "defs"
 178: 
 179: static char n13[13];
 180: static char *n13end &n13[12];
 181: 
 182: 
 183: 
 184: struct depblock *srchdir(pat, mkchain, nextdbl)
 185: 
 186: char *pat; /* pattern to be matched in directory */
 187: int mkchain;  /* nonzero if results to be remembered */
 188: struct depblock *nextdbl;  /* final value for chain */
 189: {
 190: int dirf;
 191: int i, nread;
 192: char *dirname, *dirpref, *endir, *filepat, *p, temp[BUFSIZ];
 193: char fullname[BUFSIZ], *p1, *p2, *copys();
 194: struct nameblock *q;
 195: struct depblock *thisdbl;
 196: struct pattern *patp;
 197: int *intp1, *intp2;
 198: 
 199: if(gtcalled == 0)  getcat();
 200: thisdbl=0;
 201: 
 202: if(mkchain == 0)
 203:     for(patp=firstpat ; patp!=0 ; patp = patp->nxtpattern)
 204:         if(! unequal(pat, patp->patval)) return(0);
 205: 
 206: patp = ALLOC(pattern);
 207: patp->nxtpattern = firstpat;
 208: firstpat = patp;
 209: patp->patval = copys(pat);
 210: 
 211: endir = 0;
 212: 
 213: for(p=pat; *p!='\0'; ++p)
 214:     if(*p=='/') endir = p;
 215: 
 216: if(endir==0)
 217:     {
 218:     dirname = "";
 219:     dirpref = "";
 220:     filepat = pat;
 221:     }
 222: else    {
 223: fatal("File name has an embedded slash");
 224:     dirname = pat;
 225:     *endir = '\0';
 226:     dirpref = concat(dirname, "/", temp);
 227:     filepat = endir+1;
 228:     }
 229: 
 230: for(i=0;i<catsiz;++i)
 231:     {
 232:     intp1 = &fbb[i].fn1;
 233:     intp2 = n13;
 234:     f6to9(*intp1, *intp2, 12);
 235:     for(p1=n13; p1<n13end && *p1!=' ' ; ++p1)
 236:         if('A'<=*p1 && *p1<='Z') *p1 =+ ('a'-'A');
 237:         *p1 = '\0';
 238: 
 239:     if( amatch(n13,filepat) )
 240:         {
 241:         concat(dirpref,n13,fullname);
 242:         if( (q=srchname(fullname)) ==0)
 243:             q = makename(copys(fullname));
 244:         if(mkchain)
 245:             {
 246:             thisdbl = ALLOC(depblock);
 247:             thisdbl->nextp = nextdbl;
 248:             thisdbl->depname = q;
 249:             nextdbl = thisdbl;
 250:             }
 251:         }
 252:     }
 253: 
 254: if(endir != 0)  *endir = '/';
 255: 
 256: return(thisdbl);
 257: }
 258: 
 259: /* stolen from glob through find */
 260: 
 261: amatch(s, p)
 262: char *s, *p;
 263: {
 264:     register int cc, scc, k;
 265:     int c, lc;
 266: 
 267:     scc = *s;
 268:     lc = 077777;
 269:     switch (c = *p) {
 270: 
 271:     case '[':
 272:         k = 0;
 273:         while (cc = *++p) {
 274:             switch (cc) {
 275: 
 276:             case ']':
 277:                 if (k)
 278:                     return(amatch(++s, ++p));
 279:                 else
 280:                     return(0);
 281: 
 282:             case '-':
 283:                 k =| lc <= scc & scc <= (cc=p[1]);
 284:             }
 285:             if (scc==(lc=cc)) k++;
 286:         }
 287:         return(0);
 288: 
 289:     case '?':
 290:     caseq:
 291:         if(scc) return(amatch(++s, ++p));
 292:         return(0);
 293:     case '*':
 294:         return(umatch(s, ++p));
 295:     case 0:
 296:         return(!scc);
 297:     }
 298:     if (c==scc) goto caseq;
 299:     return(0);
 300: }
 301: 
 302: umatch(s, p)
 303: char *s, *p;
 304: {
 305:     if(*p==0) return(1);
 306:     while(*s)
 307:         if (amatch(s++,p)) return(1);
 308:     return(0);
 309: }
 310: 
 311: 
 312: 
 313: dosys(comstring,nohalt)
 314: char *comstring;
 315: int nohalt;
 316: {
 317: char *p;
 318: 
 319: for(p=comstring ; *p!='\0' ; ++p);
 320: if( p-comstring > 80)
 321:     fatal("Command string longer than 80 characters");
 322: 
 323: system(comstring);
 324: 
 325: return(0);
 326: }
 327: 
 328: 
 329: touch(s)
 330: char *s;
 331: {
 332: fprintf(stderr, "touch not yet implemented on GCOS\n");
 333: cexit(2);
 334: }

Defined functions

Defined variables

Defined struct's

Defined macros