![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to misc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / usgmake|
Return to misc.c CVS log | Up to [Research Unix] / researchv10dc / cmd / usgmake |
1.1 ! root 1: /* @(#)/usr/src/cmd/make/misc.c 3.4 */ ! 2: ! 3: /* @(#)misc.c 3.2 */ ! 4: ! 5: #include "defs" ! 6: #include "ctype.h" ! 7: ! 8: ! 9: ! 10: FSTATIC CHARSTAR nextchar=0; ! 11: FSTATIC CHARSTAR lastchar=0; ! 12: ! 13: FSTATIC int *nextint=0; ! 14: FSTATIC int *lastint=0; ! 15: ! 16: FSTATIC NAMEBLOCK hashtab[HASHSIZE]; ! 17: int nhashed=0; ! 18: ! 19: ! 20: /* simple linear hash. hash function is sum of ! 21: characters mod hash table size. ! 22: */ ! 23: hashloc(s) ! 24: CHARSTAR s; ! 25: { ! 26: register int i; ! 27: register int hashval; ! 28: register CHARSTAR t; ! 29: ! 30: hashval = 0; ! 31: ! 32: for(t=s; *t!=CNULL ; ++t) ! 33: hashval += *t; ! 34: ! 35: hashval %= HASHSIZE; ! 36: ! 37: for(i=hashval; ! 38: hashtab[i]!=0 && !equal(s,hashtab[i]->namep); ! 39: i = (i+1)%HASHSIZE ) ; ! 40: ! 41: return(i); ! 42: } ! 43: ! 44: ! 45: NAMEBLOCK srchname(s) ! 46: register CHARSTAR s; ! 47: { ! 48: return( hashtab[hashloc(s)] ); ! 49: } ! 50: ! 51: ! 52: ! 53: ! 54: NAMEBLOCK makename(s) ! 55: register CHARSTAR s; ! 56: { ! 57: /* make a name entry; `s' is presumed to already to have been saved */ ! 58: ! 59: register NAMEBLOCK p; ! 60: register CHARSTAR t; ! 61: ! 62: if(nhashed++ > HASHSIZE-3) ! 63: fatal("Hash table overflow"); ! 64: ! 65: p = ALLOC(nameblock); ! 66: p->nextname = firstname; ! 67: p->backname = NULL; ! 68: ! 69: p->namep = s; ! 70: p->linep = 0; ! 71: p->done = 0; ! 72: p->septype = 0; ! 73: p->rundep = 0; ! 74: p->modtime = 0; ! 75: ! 76: firstname = p; ! 77: ! 78: hashtab[hashloc(s)] = p; ! 79: ! 80: return(p); ! 81: } ! 82: ! 83: ! 84: ! 85: ! 86: ! 87: ! 88: ! 89: #define NOTSHORT sizeof (struct nameblock) ! 90: ! 91: extern CHARSTAR end; /* loader value of end of core */ ! 92: ! 93: CHARSTAR copys(s) ! 94: register CHARSTAR s; ! 95: { ! 96: register CHARSTAR t; ! 97: register struct ! 98: { ! 99: int i_i; ! 100: CHARSTAR i_s; ! 101: } i; ! 102: ! 103: i.i_i = strlen(s) + 1; ! 104: if(i.i_i > NOTSHORT) ! 105: { ! 106: i.i_i = (i.i_i + 1)&~1; ! 107: t = (CHARSTAR )calloc(i.i_i, sizeof (*s)); ! 108: if(t == NULL) ! 109: goto fat; ! 110: i.i_s = t; ! 111: while(*t++ = *s++); ! 112: return(i.i_s); ! 113: } ! 114: ! 115: if( i.i_i >= (lastchar-nextchar) ) ! 116: { ! 117: i.i_i = (i.i_i + 1)&~1; ! 118: if( (nextchar=(CHARSTAR )calloc(i.i_i, sizeof (*s) )) == NULL) ! 119: fat: ! 120: fatal("Cannot allocate memory"); ! 121: lastchar = nextchar + i.i_i; ! 122: } ! 123: ! 124: t = nextchar; ! 125: while(*nextchar++ = *s++); ! 126: return(t); ! 127: } ! 128: ! 129: ! 130: CHARSTAR concat(a,b,c) /* c = concatenation of a and b */ ! 131: register CHARSTAR a, b; ! 132: register CHARSTAR c; ! 133: { ! 134: register CHARSTAR t; ! 135: t = c; ! 136: ! 137: while(*t = *a++) t++; ! 138: while(*t++ = *b++); ! 139: return(c); ! 140: } ! 141: ! 142: suffix(a,b,p) /* is b the suffix of a? if so, set p = prefix */ ! 143: register CHARSTAR a, b, p; ! 144: { ! 145: CHARSTAR a0, b0; ! 146: a0 = a; ! 147: b0 = b; ! 148: ! 149: if(!a || !b) ! 150: return(0); ! 151: ! 152: while(*a++); ! 153: while(*b++); ! 154: ! 155: if( (a-a0) < (b-b0) ) ! 156: return(0); ! 157: ! 158: while(b>b0) ! 159: if(*--a != *--b) ! 160: return(0); ! 161: ! 162: while(a0<a) ! 163: *p++ = *a0++; ! 164: *p = CNULL; ! 165: ! 166: return(1); ! 167: } ! 168: ! 169: ! 170: ! 171: int *intalloc(n) ! 172: register int n; ! 173: { ! 174: register INTSTAR p; ! 175: ! 176: if( p = (int *) calloc(1,n) ) ! 177: return(p); ! 178: ! 179: fatal("out of memory"); ! 180: } ! 181: ! 182: /* copy string a into b, substituting for arguments */ ! 183: extern NAMEBLOCK cur_name; ! 184: ! 185: CHARSTAR subst(a,b) ! 186: register CHARSTAR a, b; ! 187: { ! 188: register CHARSTAR s; ! 189: register VARBLOCK vbp; ! 190: static depth=0; ! 191: char vname[100]; ! 192: char closer; ! 193: ! 194: if(++depth > 100) ! 195: fatal("infinitely recursive macro?"); ! 196: if(a!=0) ! 197: { ! 198: while(*a) ! 199: { ! 200: if(*a != DOLLAR) ! 201: *b++ = *a++; ! 202: else if(*++a==CNULL || *a==DOLLAR) ! 203: *b++ = *a++; ! 204: else ! 205: { ! 206: s = vname; ! 207: if( *a==LPAREN || *a==LCURLY ) ! 208: { ! 209: closer=(*a==LPAREN ? RPAREN : RCURLY); ! 210: ++a; ! 211: while(*a == BLANK) ! 212: ++a; ! 213: while( *a!=BLANK && ! 214: *a!=closer && ! 215: *a!=CNULL) ! 216: *s++ = *a++; ! 217: while(*a!=closer && *a!=CNULL) ! 218: ++a; ! 219: if(*a == closer) ! 220: ++a; ! 221: } ! 222: else ! 223: *s++ = *a++; ! 224: ! 225: *s = CNULL; ! 226: if(amatch(&vname[0], "*:*=*")) ! 227: { ! 228: b = colontrans(b, vname); ! 229: } ! 230: else if(amatch(vname, "[@*<%][DF]")) ! 231: { ! 232: b = dftrans(b, vname); ! 233: } ! 234: else ! 235: { ! 236: b = straightrans(b, vname); ! 237: } ! 238: } ! 239: } ! 240: } ! 241: ! 242: *b = CNULL; ! 243: --depth; ! 244: return(b); ! 245: } ! 246: ! 247: ! 248: /* ! 249: * Translate the $(name:*=*) type things. ! 250: */ ! 251: ! 252: CHARSTAR colontrans(b, vname) ! 253: register CHARSTAR b; ! 254: char vname[]; ! 255: { ! 256: register int i; ! 257: register CHARSTAR ps1; ! 258: int fromlen; ! 259: char from[30], to[70]; ! 260: char dftemp[128]; ! 261: char tmp, nextchr; ! 262: CHARSTAR psave, pcolon; ! 263: VARBLOCK vbp; ! 264: ! 265: /* ! 266: * Mark off the name (up to colon), the from expression (up to '='), ! 267: * and the to expresion (up to CNULL). ! 268: */ ! 269: i = 0; ! 270: for(ps1 = &vname[0]; *ps1 != KOLON; ps1++); ! 271: pcolon = ps1; ! 272: *pcolon = CNULL; ! 273: while(*++ps1 != EQUALS) ! 274: from[i++] = *ps1; ! 275: from[i] = CNULL; ! 276: fromlen = i; ! 277: i = 0; ! 278: while(*++ps1) ! 279: to[i++] = *ps1; ! 280: to[i] = CNULL; ! 281: ! 282: /* ! 283: * Now, tanslate. ! 284: */ ! 285: ! 286: if(amatch(vname, "[@*<%][DF]")) ! 287: { ! 288: dftrans(dftemp, vname); ! 289: ps1 = dftemp; ! 290: } ! 291: else ! 292: { ! 293: if((vbp = srchvar(vname)) == NULL) ! 294: { ! 295: return(b); ! 296: } ! 297: ps1 = vbp->varval; ! 298: } ! 299: if(ps1 != NULL && *ps1 != NULL) ! 300: { ! 301: psave = ps1; ! 302: while((i = sindex(ps1, from)) >= 0) ! 303: { ! 304: ps1 = &ps1[i]; ! 305: tmp = *ps1; ! 306: *ps1 = CNULL; ! 307: nextchr = *(ps1+fromlen); ! 308: if( nextchr == TAB || ! 309: nextchr == BLANK || ! 310: nextchr == CNULL) ! 311: { ! 312: b = copstr(b, psave); ! 313: b = copstr(b, to); ! 314: *ps1 = tmp; ! 315: ps1 += fromlen; ! 316: } ! 317: else ! 318: { ! 319: b = copstr(b, psave); ! 320: *b++ = tmp; ! 321: *ps1 = tmp; ! 322: ps1++; ! 323: } ! 324: psave = ps1; ! 325: } ! 326: b = copstr(b, ps1); ! 327: } ! 328: *pcolon = KOLON; ! 329: return(b); ! 330: } ! 331: ! 332: /* ! 333: * Do the $(@D) type translations. ! 334: */ ! 335: ! 336: CHARSTAR dftrans(b, vname) ! 337: register CHARSTAR b; ! 338: char vname[]; ! 339: { ! 340: char c, c1; ! 341: CHARSTAR p1, p2; ! 342: VARBLOCK vbp; ! 343: ! 344: c1 = vname[1]; ! 345: vname[1] = CNULL; ! 346: vbp = srchvar(vname); ! 347: if(vbp != 0 && vbp->varval != 0) ! 348: { ! 349: for(p1=p2=vbp->varval;*p1;p1++) ! 350: if(*p1 == SLASH) ! 351: p2 = p1; ! 352: if(*p2 == SLASH) ! 353: { ! 354: if(c1 == 'D') ! 355: { ! 356: if(p2 == vbp->varval) ! 357: p2++; ! 358: c = *p2; ! 359: *p2 = CNULL; ! 360: b = copstr(b,vbp->varval); ! 361: *p2 = c; ! 362: } ! 363: else ! 364: { ! 365: b = copstr(b, p2+1); ! 366: } ! 367: } ! 368: else ! 369: { ! 370: if(c1 == 'D') ! 371: b = copstr(b, "."); ! 372: else ! 373: b = copstr(b, p2); ! 374: } ! 375: } ! 376: vname[1] = c1; ! 377: return(b); ! 378: } ! 379: ! 380: ! 381: /* ! 382: * Standard trnaslation, nothing fancy. ! 383: */ ! 384: ! 385: CHARSTAR straightrans(b, vname) ! 386: register CHARSTAR b; ! 387: char vname[]; ! 388: { ! 389: register VARBLOCK vbp; ! 390: register CHAIN pchain; ! 391: register NAMEBLOCK pn; ! 392: ! 393: vbp = srchvar(vname); ! 394: if( vbp != 0 && vbp->varval != 0) ! 395: { ! 396: if(vbp->v_aflg == YES) ! 397: { ! 398: pchain = (CHAIN)vbp->varval; ! 399: for(; pchain; pchain = pchain->nextchain) ! 400: { ! 401: pn = (NAMEBLOCK)pchain->datap; ! 402: if(pn->alias) ! 403: b=copstr(b, pn->alias); ! 404: else ! 405: b=copstr(b,pn->namep); ! 406: *b++ = BLANK; ! 407: } ! 408: } ! 409: else ! 410: { ! 411: b = subst(vbp->varval, b); ! 412: } ! 413: vbp->used = YES; ! 414: } ! 415: return(b); ! 416: } ! 417: ! 418: ! 419: ! 420: /* copy s into t, return the location of the next free character in s */ ! 421: CHARSTAR copstr(s, t) ! 422: register CHARSTAR s, t; ! 423: { ! 424: if(t == 0) ! 425: return(s); ! 426: while (*t) ! 427: *s++ = *t++; ! 428: *s = CNULL; ! 429: return(s); ! 430: } ! 431: ! 432: setvar(v,s) ! 433: register CHARSTAR v, s; ! 434: { ! 435: register VARBLOCK p; ! 436: ! 437: p = srchvar(v); ! 438: if(p == 0) ! 439: { ! 440: p = varptr(v); ! 441: } ! 442: if (p->noreset == NO) ! 443: { ! 444: if(IS_ON(EXPORT)) ! 445: p->envflg = YES; ! 446: p->varval = s; ! 447: if(IS_ON(INARGS) || IS_ON(ENVOVER)) ! 448: p->noreset = YES; ! 449: else ! 450: p->noreset = NO; ! 451: if(IS_ON(DBUG))printf("setvar: %s = %s noreset = %d envflg = %d Mflags = 0%o\n", ! 452: v, p->varval, p->noreset, p->envflg, Mflags); ! 453: ! 454: if(p->used && !amatch(v, "[@*<?!%]") ) ! 455: if(IS_ON(DBUG)) ! 456: fprintf(stderr, "Warning: %s changed after being used\n",v); ! 457: } ! 458: } ! 459: ! 460: ! 461: eqsign(a) ! 462: register CHARSTAR a; ! 463: { ! 464: register CHARSTAR p; ! 465: ! 466: for(p = ":;=$\n\t"; *p; p++) ! 467: if(any(a, *p)) ! 468: { ! 469: callyacc(a); ! 470: return(YES); ! 471: } ! 472: return(NO); ! 473: } ! 474: ! 475: ! 476: VARBLOCK varptr(v) ! 477: register CHARSTAR v; ! 478: { ! 479: register VARBLOCK vp; ! 480: ! 481: if((vp = srchvar(v)) != 0) ! 482: return(vp); ! 483: ! 484: vp = ALLOC(varblock); ! 485: vp->nextvar = firstvar; ! 486: firstvar = vp; ! 487: vp->varname = copys(v); ! 488: vp->varval = 0; ! 489: return(vp); ! 490: } ! 491: ! 492: VARBLOCK srchvar(vname) ! 493: register CHARSTAR vname; ! 494: { ! 495: register VARBLOCK vp; ! 496: ! 497: for(vp=firstvar; vp != 0 ; vp = vp->nextvar) ! 498: if(equal(vname, vp->varname)) ! 499: return(vp); ! 500: return(NO); ! 501: } ! 502: ! 503: ! 504: fatal1(s,t) ! 505: CHARSTAR s, t; ! 506: { ! 507: char buf[100]; ! 508: sprintf(buf, s, t); ! 509: fatal(buf); ! 510: } ! 511: ! 512: ! 513: ! 514: fatal(s) ! 515: CHARSTAR s; ! 516: { ! 517: if(s) ! 518: fprintf(stderr, "Make: %s. Stop.\n", s); ! 519: else ! 520: fprintf(stderr, "\nStop.\n"); ! 521: #ifdef unix ! 522: exit(1); ! 523: #endif ! 524: #ifdef gcos ! 525: exit(0); ! 526: #endif ! 527: } ! 528: ! 529: ! 530: ! 531: yyerror(s) ! 532: CHARSTAR s; ! 533: { ! 534: char buf[50]; ! 535: extern int yylineno; ! 536: ! 537: sprintf(buf, "line %d: %s", yylineno, s); ! 538: fatal(buf); ! 539: } ! 540: ! 541: ! 542: ! 543: CHAIN appendq(head,tail) ! 544: register CHAIN head; ! 545: register CHARSTAR tail; ! 546: { ! 547: register CHAIN p; ! 548: ! 549: p = ALLOC(chain); ! 550: p->datap = tail; ! 551: while(head->nextchain) ! 552: head = head->nextchain; ! 553: head->nextchain = p; ! 554: } ! 555: ! 556: ! 557: ! 558: ! 559: ! 560: CHARSTAR mkqlist(p) ! 561: register CHAIN p; ! 562: { ! 563: register CHARSTAR qbufp, s; ! 564: static char qbuf[OUTMAX]; ! 565: ! 566: qbufp = qbuf; ! 567: ! 568: for( ; p ; p = p->nextchain) ! 569: { ! 570: s = p->datap; ! 571: if(qbufp != qbuf) ! 572: *qbufp++ = BLANK; ! 573: if(qbufp+strlen(s) > &qbuf[OUTMAX-3]) ! 574: { ! 575: fprintf(stderr, "$? list too long\n"); ! 576: break; ! 577: } ! 578: while (*s) ! 579: *qbufp++ = *s++; ! 580: } ! 581: *qbufp = CNULL; ! 582: return(qbuf); ! 583: } ! 584: ! 585: any(s,c) ! 586: register CHARSTAR s; ! 587: register char c; ! 588: { ! 589: register char d; ! 590: ! 591: while(d = *s++) ! 592: { ! 593: if(d==c) ! 594: return(1); ! 595: } ! 596: return(0); ! 597: } ! 598: ! 599: ! 600: sindex(s1,s2) ! 601: CHARSTAR s1; ! 602: CHARSTAR s2; ! 603: { ! 604: register CHARSTAR p1; ! 605: register CHARSTAR p2; ! 606: register int flag; ! 607: int ii; ! 608: ! 609: p1 = &s1[0]; ! 610: p2 = &s2[0]; ! 611: flag = -1; ! 612: for(ii = 0; ; ii++) ! 613: { ! 614: while(*p1 == *p2) ! 615: { ! 616: if(flag < 0) ! 617: flag = ii; ! 618: if(*p1++ == CNULL) ! 619: return(flag); ! 620: p2++; ! 621: } ! 622: if(*p2 == CNULL) ! 623: return(flag); ! 624: if(flag >= 0) ! 625: { ! 626: flag = -1; ! 627: p2 = &s2[0]; ! 628: } ! 629: if(*s1++ == CNULL) ! 630: return(flag); ! 631: p1 = s1; ! 632: } ! 633: } ! 634: ! 635: ! 636: #include "sys/types.h" ! 637: #include "sys/stat.h" ! 638: ! 639: /* ! 640: * findfl(name) (like execvp, but does path search and finds files) ! 641: */ ! 642: static char fname[128]; ! 643: ! 644: char *execat(); ! 645: ! 646: CHARSTAR findfl(name) ! 647: register CHARSTAR name; ! 648: { ! 649: register CHARSTAR p; ! 650: register VARBLOCK cp; ! 651: ! 652: if(name[0] == SLASH) ! 653: return(name); ! 654: cp = varptr("VPATH"); ! 655: if(cp->varval == 0) ! 656: p = ":"; ! 657: else ! 658: p = cp->varval; ! 659: ! 660: do ! 661: { ! 662: p = execat(p, name, fname); ! 663: if(access(fname, 4) == 0) ! 664: return(fname); ! 665: } while (p); ! 666: return((CHARSTAR )-1); ! 667: } ! 668: ! 669: CHARSTAR execat(s1, s2, si) ! 670: register CHARSTAR s1, s2; ! 671: CHARSTAR si; ! 672: { ! 673: register CHARSTAR s; ! 674: ! 675: s = si; ! 676: while (*s1 && *s1 != KOLON && *s1 != MINUS) ! 677: *s++ = *s1++; ! 678: if (si != s) ! 679: *s++ = SLASH; ! 680: while (*s2) ! 681: *s++ = *s2++; ! 682: *s = CNULL; ! 683: return(*s1? ++s1: 0); ! 684: } ! 685: ! 686: ! 687: /* ! 688: * change xx to s.xx or /x/y/z to /x/y/s.z ! 689: */ ! 690: CHARSTAR trysccs(str) ! 691: register CHARSTAR str; ! 692: { ! 693: register CHARSTAR sstr; ! 694: register int i = 2; ! 695: ! 696: sstr = str; ! 697: for(; *str; str++); ! 698: str[2] = CNULL; ! 699: str--; ! 700: for(;str >= sstr; str--) ! 701: { ! 702: if(*str == SLASH) ! 703: if(i == 2) ! 704: { ! 705: i = 0; ! 706: *(str+2) = DOT; ! 707: *(str+1) = 's'; ! 708: } ! 709: *(str+i) = *str; ! 710: } ! 711: if(i == 2) ! 712: { ! 713: *(str+2) = DOT; ! 714: *(str+1) = 's'; ! 715: } ! 716: return(sstr); ! 717: } ! 718: ! 719: ! 720: is_sccs(filename) ! 721: register CHARSTAR filename; ! 722: { ! 723: register CHARSTAR p; ! 724: ! 725: for(p = filename; *p; p++) ! 726: if(*p == 's') ! 727: if(p == filename && p[1] == DOT) ! 728: return(YES); ! 729: else if(p[-1] == SLASH && p[1] == DOT) ! 730: return(YES); ! 731: return(NO); ! 732: } ! 733: ! 734: /* ! 735: * change pfx to /xxx/yy/*zz.* or *zz.* ! 736: */ ! 737: CHARSTAR addstars(pfx) ! 738: register CHARSTAR pfx; ! 739: { ! 740: register CHARSTAR p1, p2; ! 741: ! 742: for(p1 = pfx; *p1; p1++); ! 743: p2 = p1 + 3; /* 3 characters, '*', '.', and '*'. */ ! 744: p1--; ! 745: ! 746: *p2-- = CNULL; ! 747: *p2-- = STAR; ! 748: *p2-- = DOT; ! 749: while(p1 >= pfx) ! 750: { ! 751: if(*p1 == SLASH) ! 752: { ! 753: *p2 = STAR; ! 754: return(pfx); ! 755: } ! 756: *p2-- = *p1--; ! 757: } ! 758: *p2 = STAR; ! 759: return(p2); ! 760: } ! 761: ! 762: ! 763: #define NENV 300 ! 764: extern CHARSTAR *environ; ! 765: ! 766: /* ! 767: * This routine is called just before and exec. ! 768: */ ! 769: ! 770: setenv() ! 771: { ! 772: register CHARSTAR *ea; ! 773: register int nenv = 0; ! 774: register CHARSTAR p; ! 775: CHARSTAR *es; ! 776: VARBLOCK vp; ! 777: int length; ! 778: ! 779: if(firstvar == 0) ! 780: return; ! 781: ! 782: es=ea=(CHARSTAR *)calloc(NENV, sizeof *ea); ! 783: if(es == (CHARSTAR *)-1) ! 784: fatal("Cannot alloc mem for envp."); ! 785: ! 786: for(vp=firstvar; vp != 0; vp=vp->nextvar) ! 787: if(vp->envflg) ! 788: { ! 789: if(++nenv >= NENV) ! 790: fatal("Too many env parameters."); ! 791: length = strlen(vp->varname) + strlen(vp->varval) + 2; ! 792: if((*ea = (CHARSTAR )calloc(length, sizeof **ea)) == (CHARSTAR )-1) ! 793: fatal("Cannot alloc mem for env."); ! 794: p = copstr(*ea++, vp->varname); ! 795: p = copstr(p, "="); ! 796: p = copstr(p, vp->varval); ! 797: } ! 798: *ea = 0; ! 799: if(nenv > 0) ! 800: environ=es; ! 801: if(IS_ON(DBUG)) ! 802: printf("nenv = %d\n", nenv); ! 803: } ! 804: ! 805: ! 806: /* ! 807: * Called in main ! 808: * If a string like "CC=" occurs then CC is not put in environment. ! 809: * This is because there is no good way to remove a variable ! 810: * from the environment within the shell. ! 811: */ ! 812: ! 813: readenv() ! 814: { ! 815: register CHARSTAR *ea; ! 816: register CHARSTAR p; ! 817: ! 818: ea=environ; ! 819: for(;*ea; ea++) ! 820: { ! 821: for(p = *ea; *p && *p != EQUALS; p++); ! 822: if(*p == EQUALS) ! 823: if(*(p+1)) ! 824: eqsign(*ea); ! 825: } ! 826: } ! 827: ! 828: ! 829: sccstrip(pstr) ! 830: register CHARSTAR pstr; ! 831: { ! 832: register CHARSTAR p2; ! 833: register CHARSTAR sstr; ! 834: ! 835: sstr = pstr; ! 836: for(; *pstr ; pstr++) ! 837: if(*pstr == RCURLY) ! 838: { ! 839: if(isdigit(pstr[1])) ! 840: if(pstr != sstr) ! 841: if(pstr[-1] != DOLLAR) ! 842: { ! 843: for(p2 = pstr; *p2 && (*p2 != LCURLY); p2++); ! 844: if(*p2 == CNULL) ! 845: break; ! 846: strshift(pstr, -(int)(p2-pstr+1) ); ! 847: } ! 848: } ! 849: } ! 850: ! 851: /* ! 852: * Shift a string `pstr' count places. negative is left, pos is right ! 853: * Negative shifts cause char's at front to be lost. ! 854: * Positive shifts assume enough space! ! 855: */ ! 856: CHARSTAR strshift(pstr, count) ! 857: register CHARSTAR pstr; ! 858: register int count; ! 859: { ! 860: register CHARSTAR sstr; ! 861: ! 862: sstr = pstr; ! 863: if(count < 0) ! 864: { ! 865: count = -count; ! 866: while(pstr[count]) ! 867: *pstr = pstr++[count]; ! 868: *pstr = 0; ! 869: return(sstr); ! 870: } ! 871: for(; *pstr; pstr++); ! 872: pstr--[count] = 0; ! 873: while(pstr != sstr) ! 874: pstr[count] = *pstr--; ! 875: pstr[count] = *pstr; ! 876: ! 877: return(sstr); ! 878: ! 879: } ! 880: ! 881: ! 882: /* ! 883: * execlp(name, arg,...,0) (like execl, but does path search) ! 884: * execvp(name, argv) (like execv, but does path search) ! 885: */ ! 886: #include <errno.h> ! 887: ! 888: CHARSTAR execat(); ! 889: extern errno; ! 890: ! 891: execlp(name, argv) ! 892: CHARSTAR name, argv; ! 893: { ! 894: return(execvp(name, &argv)); ! 895: } ! 896: ! 897: execvp(name, argv) ! 898: CHARSTAR name, *argv; ! 899: { ! 900: register etxtbsy = 1; ! 901: register eacces = 0; ! 902: register CHARSTAR cp; ! 903: CHARSTAR pathstr; ! 904: CHARSTAR shell; ! 905: char fname[128]; ! 906: ! 907: pathstr = varptr("PATH")->varval; ! 908: if(pathstr == 0 || *pathstr == CNULL) ! 909: pathstr = ":/bin:/usr/bin"; ! 910: shell = varptr("SHELL")->varval; ! 911: if(shell == 0 || *shell == CNULL) ! 912: shell = "/bin/sh"; ! 913: cp = strchr(name, SLASH)? "": pathstr; ! 914: ! 915: do ! 916: { ! 917: cp = execat(cp, name, fname); ! 918: retry: ! 919: execv(fname, argv); ! 920: switch(errno) ! 921: { ! 922: case ENOEXEC: ! 923: *argv = fname; ! 924: *--argv = "sh"; ! 925: execv(shell, argv); ! 926: return(-1); ! 927: case ETXTBSY: ! 928: if (++etxtbsy > 5) ! 929: return(-1); ! 930: sleep(etxtbsy); ! 931: goto retry; ! 932: case EACCES: ! 933: eacces++; ! 934: break; ! 935: case ENOMEM: ! 936: case E2BIG: ! 937: return(-1); ! 938: } ! 939: } while (cp); ! 940: if (eacces) ! 941: errno = EACCES; ! 942: return(-1); ! 943: } ! 944: ! 945: /* ! 946: * get() does an SCCS get on the file ssfile. ! 947: * For the get command, get() uses the value of the variable "GET". ! 948: * If ssfile has a slash in it, get() does a "chdir" to the appropriate ! 949: * directory if the cdflag is set to CD. This assures ! 950: * the program finds the ssfile where it belongs when necessary. ! 951: * If the rlse string variable is set, get() uses it in the ! 952: * get command sequence. ! 953: * Thus a possible sequence is: ! 954: * set -x; ! 955: * cd ../sys/head; ! 956: * get -r2.3.4.5 s.stdio.h ! 957: * ! 958: */ ! 959: ! 960: /* ! 961: * The gothead and gotf structures are used to remember ! 962: * the names of the files `make' automatically gets so ! 963: * `make' can remove them upon exit. ! 964: */ ! 965: GOTHEAD gotfiles; ! 966: ! 967: get(ssfile, cdflag, rlse) ! 968: register CHARSTAR ssfile; ! 969: int cdflag; ! 970: CHARSTAR rlse; ! 971: { ! 972: register CHARSTAR pr; ! 973: register CHARSTAR pr1; ! 974: char gbuf[128]; ! 975: char sfile[128]; ! 976: int retval; ! 977: GOTF gf; ! 978: ! 979: copstr(sfile, ssfile); ! 980: if(!is_sccs(sfile)) ! 981: trysccs(sfile); ! 982: if(access(sfile, 4) != 0 && IS_OFF(GET)) ! 983: return(NO); ! 984: ! 985: pr = gbuf; ! 986: if(IS_OFF(SIL)) ! 987: pr = copstr(pr, "set -x;\n"); ! 988: ! 989: if(cdflag == CD) ! 990: if(any(sfile, SLASH)) ! 991: { ! 992: pr = copstr(pr, "cd "); ! 993: for(pr1 = sfile; *pr1; pr1++); ! 994: while(*pr1 != SLASH) ! 995: pr1--; ! 996: *pr1 = CNULL; ! 997: pr = copstr(pr, sfile); ! 998: pr = copstr(pr, ";\n"); ! 999: *pr1 = SLASH; ! 1000: } ! 1001: ! 1002: pr = copstr(pr, varptr("GET")->varval); ! 1003: pr = copstr(pr, " "); ! 1004: pr = copstr(pr, varptr("GFLAGS")->varval); ! 1005: pr = copstr(pr, " "); ! 1006: ! 1007: pr1 = rlse; ! 1008: if(pr1 != NULL && pr1[0] != CNULL) ! 1009: { ! 1010: if(pr1[0] != MINUS) /* RELEASE doesn't have '-r' */ ! 1011: pr = copstr(pr, "-r"); ! 1012: pr = copstr(pr, pr1); ! 1013: pr = copstr(pr, " "); ! 1014: } ! 1015: ! 1016: pr = copstr(pr, sfile); ! 1017: /* ! 1018: * exit codes are opposite of error codes so do the following: ! 1019: */ ! 1020: retval = (system(gbuf) == 0) ? YES : NO ; ! 1021: if(retval == YES) ! 1022: { ! 1023: if(gotfiles == 0) ! 1024: { ! 1025: gotfiles = ALLOC(gothead); ! 1026: gf = (GOTF)gotfiles; ! 1027: gotfiles->gnextp = 0; ! 1028: gotfiles->endp = (GOTF)gotfiles; ! 1029: } ! 1030: else ! 1031: { ! 1032: gf = gotfiles->endp; ! 1033: gf->gnextp = ALLOC(gotf); ! 1034: gf = gf->gnextp; ! 1035: gf->gnextp = 0; ! 1036: } ! 1037: gf->gnamep = copys(sfile+2); /* `+2' skips `s.' */ ! 1038: gotfiles->endp = gf; ! 1039: } ! 1040: return(retval); ! 1041: } ! 1042: ! 1043: /* ! 1044: * subroutine to actually remove to gotten files. ! 1045: */ ! 1046: rm_gots() ! 1047: { ! 1048: register GOTF gf; ! 1049: ! 1050: if(IS_ON(GF_KEEP)) ! 1051: return; ! 1052: for(gf = (GOTF)gotfiles; gf ; gf=gf->gnextp) ! 1053: if(gf->gnamep) ! 1054: { ! 1055: if(IS_ON(DBUG))printf("rm_got: %s\n", gf->gnamep); ! 1056: unlink(gf->gnamep); ! 1057: } ! 1058: } ! 1059: callyacc(str) ! 1060: register CHARSTAR str; ! 1061: { ! 1062: CHARSTAR lines[2]; ! 1063: FILE *finsave; ! 1064: CHARSTAR *lpsave; ! 1065: ! 1066: finsave = fin; ! 1067: lpsave = linesptr; ! 1068: fin = 0; ! 1069: lines[0] = str; ! 1070: lines[1] = 0; ! 1071: linesptr = lines; ! 1072: yyparse(); ! 1073: fin = finsave; ! 1074: linesptr = lpsave; ! 1075: } ! 1076: ! 1077: /* ! 1078: * exit routine for removing the files `make' automatically ! 1079: * got. ! 1080: */ ! 1081: exit(arg) ! 1082: { ! 1083: rm_gots(); ! 1084: if(IS_ON(MEMMAP)) ! 1085: { ! 1086: prtmem(); ! 1087: } ! 1088: _cleanup(); ! 1089: _exit(arg); ! 1090: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.