![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to make.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / make|
Return to make.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / make |
1.1 ! root 1: /* ! 2: * make -- maintain program groups ! 3: * td 80.09.17 ! 4: * things done: ! 5: * 20-Oct-82 Made nextc properly translate "\\\n[ ]*" to ' '. ! 6: * 15-Jan-85 Made portable enough for z-8000, readable enough for ! 7: * human beings. ! 8: * 06-Nov-85 Added free(t) to make() to free used space. ! 9: * 07-Nov-85 Modified docmd() to call varexp() only if 'cmd' ! 10: * actually contains macros, for efficiency. ! 11: * 24-Feb-86 Minor fixes by rec to many things. Deferred ! 12: * macro expansion in actions until needed, deferred ! 13: * getmdate() until needed, added canonicalization in ! 14: * archive searches, allowed ${NAME} in actions for ! 15: * shell to expand, put macro definitions in malloc, ! 16: * entered environ into macros. ! 17: * 17-Oct-86 Very minor MS-DOS changes by steve: add _cmdname[], ! 18: * conditionalize archive code as #if COHERENT || GEMDOS. ! 19: * 8-Dec-86 Rec makes inpath() search current directory first, ! 20: * and allows : in dependency list under MSDOS && GEMDOS. ! 21: * 8-Feb-91 steve: fix comment handling, allow "\#", allow ${VAR}. ! 22: * Add docmd0() to make $< and $* work in Makefiles. ! 23: * 12-Feb-91 steve: add $SRCPATH source path searching. ! 24: * 1-Nov-91 steve: fix bug in nextc() to handle "\n\t\n" correctly ! 25: * 29-Sep-92 michael: fix problem with defining a rule that also ! 26: * exists in the ACTIONFILE. ! 27: * 08-Oct-92 michael: fix problem with making targets with no ! 28: * specified actions (empty productions). ! 29: */ ! 30: ! 31: #include "make.h" ! 32: ! 33: #if MSDOS ! 34: char _cmdname[] = "make"; ! 35: #endif ! 36: ! 37: char usage[] = "Usage: make [-deinpqrst] [-f file] [macro=value] [target]"; ! 38: char nospace[] = "out of space"; ! 39: char badmac[] = "bad macro name"; ! 40: char incomp[] = "incomplete line at end of file"; ! 41: ! 42: /* Command line flags. */ ! 43: int iflag; /* ignore command errors */ ! 44: int sflag; /* don't print command lines */ ! 45: int rflag; /* don't read built-in rules */ ! 46: int nflag; /* don't execute commands */ ! 47: int tflag; /* touch files rather than run commands */ ! 48: int qflag; /* zero exit status if file up to date */ ! 49: int pflag; /* print macro defns, target descriptions */ ! 50: int dflag; /* debug mode -- verbose printout */ ! 51: int eflag; /* make environ macros protected */ ! 52: ! 53: /* Globals. */ ! 54: unsigned char backup[NBACKUP]; ! 55: int defining; /* nonzero => do not expand macros */ ! 56: int instring; /* Are we in the middle of a string? */ ! 57: SYM *deflt; ! 58: char *deftarget; ! 59: FILE *fd; ! 60: int lastc; ! 61: int lineno; ! 62: MACRO *macro; ! 63: char macroname[NMACRONAME+1]; ! 64: char *mvarval[4]; /* list of macro variable values */ ! 65: int nbackup; ! 66: time_t now; ! 67: char *srcpath; ! 68: struct stat statbuf; ! 69: SYM *suffixes; ! 70: SYM *sym; ! 71: char tokbuf[NTOKBUF]; ! 72: char *token; ! 73: int toklen; ! 74: char *tokp; ! 75: int inactionfile = 0; ! 76: ! 77: /* Forward function declarations. */ ! 78: DEP *adddep(); ! 79: SYM *dexists(); ! 80: char *extend(); ! 81: char *fpath(); ! 82: TOKEN *listtoken(); ! 83: SYM *lookup(); ! 84: char *mexists(); ! 85: char *mmalloc(); ! 86: SYM *sexists(); ! 87: ! 88: /* cry and die */ ! 89: /* VARARGS */ ! 90: die(s) char *s; ! 91: { ! 92: fflush(stdout); ! 93: fprintf(stderr, "make: %r\n", &s); ! 94: exit(ERROR); ! 95: } ! 96: ! 97: /* print lineno, cry and die */ ! 98: /* VARARGS */ ! 99: err(s) char *s; ! 100: { ! 101: fprintf(stderr, "make: %d: %r\n", lineno, &s); ! 102: exit(ERROR); ! 103: } ! 104: ! 105: /* Malloc nbytes and abort on failure */ ! 106: char * ! 107: mmalloc(n) int n; ! 108: { ! 109: char *p; ! 110: if (p = malloc(n)) ! 111: return p; ! 112: err(nospace); ! 113: } ! 114: ! 115: /* read characters from backup (where macros have been expanded) or from ! 116: * whatever the open file of the moment is. keep track of line #s. ! 117: */ ! 118: readc() ! 119: { ! 120: if (nbackup!=0) ! 121: return(backup[--nbackup]); ! 122: if (lastc=='\n') ! 123: lineno++; ! 124: lastc=getc(fd); ! 125: return(lastc); ! 126: } ! 127: ! 128: /* put c into backup[] */ ! 129: putback(c) ! 130: { ! 131: if (c==EOF) ! 132: return; ! 133: if (nbackup == NBACKUP) ! 134: err("macro definition too long"); ! 135: backup[nbackup++]=c; ! 136: } ! 137: ! 138: /* put s into backup */ ! 139: unreads(s) register char *s; ! 140: { ! 141: register char *t; ! 142: ! 143: t = &s[strlen(s)]; ! 144: while (t > s) ! 145: putback(*--t); ! 146: } ! 147: ! 148: /* return a pointer to the macro definition assigned to macro name s. ! 149: * return NULL if the macro has not been defined. ! 150: */ ! 151: char * ! 152: mexists(s) register char *s; ! 153: { ! 154: register MACRO *i; ! 155: ! 156: for (i = macro; i != NULL; i=i->next) ! 157: if (Streq(s, i->name)) ! 158: return (i->value); ! 159: ! 160: return (NULL); ! 161: } ! 162: ! 163: /* install macro with name name and value value in macro[]. Overwrite an ! 164: * existing value if it is not protected. ! 165: */ ! 166: define(name, value, protected) register char *name, *value; int protected; ! 167: { ! 168: register MACRO *i; ! 169: ! 170: if (dflag) ! 171: printf("define %s = %s\n", name, value); ! 172: for (i = macro; i != NULL; i=i->next) ! 173: if (Streq(name, i->name)) { ! 174: if (!i->protected) { ! 175: free(i->value); ! 176: i->value = value; ! 177: i->protected = protected; ! 178: } else if (dflag) ! 179: printf("... definition suppressed\n"); ! 180: return; ! 181: } ! 182: i = (MACRO *)mmalloc(sizeof(*i)); ! 183: i->name = name; ! 184: i->value = value; ! 185: i->protected = protected; ! 186: i->next = macro; ! 187: macro = i; ! 188: } ! 189: ! 190: /* Accept single letter user defined macros */ ! 191: ismacro(c) register int c; ! 192: { ! 193: return ((c>='0'&&c<='9') ! 194: || (c>='a'&&c<='z') ! 195: || (c>='A'&&c<='Z')); ! 196: } ! 197: ! 198: /* ! 199: * Return the next character from the input file. ! 200: * Eat comments. ! 201: * Return EOS for newline not followed by an action. ! 202: * Return '\n' for newline followed by an action. ! 203: * If not in a macro definition or action specification, ! 204: * then expand macro in backup or complain about the name. ! 205: */ ! 206: nextc() ! 207: { ! 208: register char *s; ! 209: register int c, endc; ! 210: ! 211: Again: ! 212: if ((c = readc()) == '\\') { ! 213: c = readc(); ! 214: if (c == '\n') { /* escaped newline */ ! 215: while ((c=readc())==' ' || c=='\t') ! 216: ; /* eat following whitespace */ ! 217: putback(c); ! 218: return(' '); ! 219: } else if (c == '#') ! 220: return c; /* "\#" means literal '#' */ ! 221: putback(c); ! 222: return '\\'; ! 223: } ! 224: if ((c=='#') && !instring) { ! 225: do ! 226: c = readc(); ! 227: while (c != '\n' && c != EOF); ! 228: } ! 229: if ((c=='"') || (c=='\'')) ! 230: { ! 231: instring = !instring; ! 232: return c; ! 233: } ! 234: if (c == '\n') { ! 235: instring = 0; ! 236: Again2: ! 237: if ((c = readc()) != ' ' && c != '\t') { ! 238: putback(c); ! 239: if (c == '#') ! 240: goto Again; /* "\n# comment" */ ! 241: return EOS; /* no action follows */ ! 242: } ! 243: do ! 244: c = readc(); ! 245: while (c == ' ' || c == '\t'); /* skip whitespace */ ! 246: if (c == '\n') ! 247: goto Again2; /* "\n\t\n" */ ! 248: putback(c); ! 249: if (c == '#') ! 250: goto Again; /* "\n\t# comment" */ ! 251: return '\n'; /* action follows */ ! 252: } ! 253: if (!defining && c=='$'){ ! 254: c=readc(); ! 255: if (c == '(' || c == '{') { ! 256: endc = (c == '(') ? ')' : '}'; ! 257: s = macroname; ! 258: while (' ' < (c = readc()) && c < 0177 && c != endc) ! 259: if (s != ¯oname[NMACRONAME]) ! 260: *s++=c; ! 261: if (c != endc) ! 262: err(badmac); ! 263: *s++ = '\0'; ! 264: } else if (ismacro(c)) { ! 265: macroname[0]=c; ! 266: macroname[1]='\0'; ! 267: } else ! 268: err(badmac); ! 269: if ((s=mexists(macroname))!=NULL) ! 270: unreads(s); ! 271: goto Again; ! 272: } ! 273: ! 274: return(c); ! 275: } ! 276: ! 277: /* Get a block of l0+l1 bytes copy s0 and s1 into it, and return a pointer to ! 278: * the beginning of the block. ! 279: */ ! 280: char * ! 281: extend(s0, l0, s1, l1) char *s0, *s1; int l0, l1; ! 282: { ! 283: register char *t; ! 284: ! 285: if (s0 == NULL) ! 286: t = mmalloc(l1); ! 287: else { ! 288: if ((t = realloc(s0, l0 + l1)) == NULL) ! 289: err(nospace); ! 290: } ! 291: strncpy(t+l0, s1, l1); ! 292: return(t); ! 293: } ! 294: ! 295: /* Return 1 if c is EOS, EOF, or one of the characters in s */ ! 296: delim(c, s) register char c; char *s; ! 297: { ! 298: return (c == EOS || c == EOF || index(s, c) != NULL); ! 299: } ! 300: ! 301: /* Prepare to copy a new token string into the token buffer; if the old value ! 302: * in token wasn't saved, tough matzohs. ! 303: */ ! 304: starttoken() ! 305: { ! 306: token=NULL; ! 307: tokp=tokbuf; ! 308: toklen=0; ! 309: } ! 310: ! 311: /* Put c in the token buffer; if the buffer is full, copy its contents into ! 312: * token and start agin at the beginning of the buffer. ! 313: */ ! 314: addtoken(c) ! 315: { ! 316: if (tokp==&tokbuf[NTOKBUF]){ ! 317: token=extend(token, toklen-NTOKBUF, tokbuf, NTOKBUF); ! 318: tokp=tokbuf; ! 319: } ! 320: *tokp++=c; ! 321: toklen++; ! 322: } ! 323: ! 324: /* mark the end of the token in the buffer and save it in token. */ ! 325: endtoken() ! 326: { ! 327: addtoken('\0'); ! 328: token=extend(token, toklen-(tokp-tokbuf), tokbuf, tokp-tokbuf); ! 329: } ! 330: ! 331: /* Install value at the end of the token list which begins with next; return ! 332: * a pointer to the beginning of the list, which is the one just installed if ! 333: * next was NULL. ! 334: */ ! 335: TOKEN * ! 336: listtoken(value, next) char *value; TOKEN *next; ! 337: { ! 338: register TOKEN *p; ! 339: register TOKEN *t; ! 340: ! 341: t=(TOKEN *)mmalloc(sizeof *t); /*Necessaire ou le contraire?*/ ! 342: t->value=value; ! 343: t->next=NULL; ! 344: if (next==NULL) ! 345: return(t); ! 346: for(p=next;p->next!=NULL;p=p->next); ! 347: p->next=t; ! 348: return(next); ! 349: } ! 350: ! 351: /* Free the overhead of a token list */ ! 352: TOKEN * ! 353: freetoken(t) register TOKEN *t; ! 354: { ! 355: register TOKEN *tp; ! 356: while (t != NULL) { ! 357: tp = t->next; ! 358: free(t); ! 359: t = tp; ! 360: } ! 361: return t; ! 362: } ! 363: ! 364: /* Read macros, dependencies, and actions from the file with name file, or ! 365: * from whatever file is already open. The first string of tokens is saved ! 366: * in a list pointed to by tp; if it was a macro, the definition goes in ! 367: * token, and we install it in macro[]; if tp points to a string of targets, ! 368: * its depedencies go in a list pointed to by dp, and the action to recreate ! 369: * it in token, and the whole shmear is installed. ! 370: */ ! 371: input(file) char *file; ! 372: { ! 373: TOKEN *tp = NULL, *dp = NULL; ! 374: register c; ! 375: char *action; ! 376: int twocolons; ! 377: ! 378: if (file!=NULL && (fd=fopen(file, "r"))==NULL) ! 379: die("cannot open %s", file); ! 380: lineno=1; ! 381: lastc=EOF; ! 382: for(;;){ ! 383: c=nextc(); ! 384: for(;;){ ! 385: while(c==' ' || c=='\t') ! 386: c=nextc(); ! 387: if (delim(c, "=:;\n")) ! 388: break; ! 389: starttoken(); ! 390: while(!delim(c, " \t\n=:;")){ ! 391: addtoken(c); ! 392: c=nextc(); ! 393: } ! 394: endtoken(); ! 395: tp=listtoken(token, tp); ! 396: } ! 397: switch(c){ ! 398: case EOF: ! 399: if (tp!=NULL) ! 400: err(incomp); ! 401: fclose(fd); ! 402: return; ! 403: case EOS: ! 404: if (tp==NULL) ! 405: break; ! 406: case '\n': ! 407: err("newline after target or macroname"); ! 408: case ';': ! 409: err("; after target or macroname"); ! 410: case '=': ! 411: if (tp==NULL || tp->next!=NULL) ! 412: err("= without macro name or in token list"); ! 413: defining++; ! 414: while((c=nextc())==' ' || c=='\t'); ! 415: starttoken(); ! 416: while(c!=EOS && c!=EOF) { ! 417: addtoken(c); ! 418: c=nextc(); ! 419: } ! 420: endtoken(); ! 421: define(tp->value, token, 0); ! 422: defining=0; ! 423: break; ! 424: case ':': ! 425: if (tp==NULL) ! 426: err(": without preceding target"); ! 427: c=nextc(); ! 428: if (c==':'){ ! 429: twocolons=1; ! 430: c=nextc(); ! 431: } else ! 432: twocolons=0; ! 433: for(;;){ ! 434: while(c==' ' || c=='\t') ! 435: c=nextc(); ! 436: if (delim(c, "=:;\n")) ! 437: break; ! 438: starttoken(); ! 439: while(!delim(c, TDELIM)){ ! 440: addtoken(c); ! 441: c=nextc(); ! 442: } ! 443: endtoken(); ! 444: dp=listtoken(token, dp); ! 445: } ! 446: switch(c){ ! 447: #if !MSDOS && !GEMDOS ! 448: case ':': ! 449: err("::: or : in or after dependency list"); ! 450: #endif ! 451: case '=': ! 452: err("= in or after dependency"); ! 453: case EOF: ! 454: err(incomp); ! 455: case ';': ! 456: case '\n': ! 457: ++defining; ! 458: starttoken(); ! 459: while((c=nextc())!=EOS && c!=EOF) ! 460: addtoken(c); ! 461: endtoken(); ! 462: defining = 0; ! 463: action=token; ! 464: break; ! 465: case EOS: ! 466: action=NULL; ! 467: } ! 468: install(tp, dp, action, twocolons); ! 469: } ! 470: tp = freetoken(tp); ! 471: dp = freetoken(dp); ! 472: dp = NULL; ! 473: } ! 474: } ! 475: ! 476: /* Input with library lookup */ ! 477: inlib(file) char *file; ! 478: { ! 479: register char *p, *cp; ! 480: if ((p = getenv("LIBPATH")) == NULL) ! 481: p = DEFLIBPATH; ! 482: cp = path(p, file, AREAD); ! 483: input(cp ? cp : file); ! 484: } ! 485: ! 486: /* Input first file in list which is found via SRCPATH. */ ! 487: /* Look in current directory first */ ! 488: inpath(file) char *file; ! 489: { ! 490: register char **vp, *cp; ! 491: ! 492: cp = NULL; ! 493: for (vp = &file; *vp != NULL; vp += 1) ! 494: if (access(*vp, AREAD) >= 0) { ! 495: cp = *vp; ! 496: break; ! 497: } ! 498: if ( ! cp) ! 499: for (vp = &file; *vp != NULL; vp += 1) ! 500: if ((cp = path(srcpath, *vp, AREAD)) != NULL) ! 501: break; ! 502: input(cp ? cp : file); ! 503: } ! 504: ! 505: /* Return the last modified date of file with name name. If it's an archive, ! 506: * open it up and read the insertion date of the pertinent member. ! 507: */ ! 508: time_t ! 509: getmdate(name) char *name; ! 510: { ! 511: #if _I386 ! 512: char *subname; ! 513: char *lwa; ! 514: int fd, x; ! 515: char magic[SARMAG]; ! 516: int size; ! 517: ! 518: time_t result; ! 519: struct ar_hdr hdrbuf; ! 520: #endif ! 521: ! 522: if (stat(name, &statbuf) == 0) ! 523: return(statbuf.st_mtime); ! 524: ! 525: ! 526: #if _I386 ! 527: subname = index(name, '('); ! 528: if (subname == NULL) ! 529: return (0); ! 530: lwa = &name[strlen(name) - 1]; ! 531: if (*lwa != ')') ! 532: return (0); ! 533: *subname = NUL; ! 534: fd = open(name, READ); ! 535: *subname++ = '('; ! 536: if (fd == EOF) ! 537: return (0); ! 538: if (read(fd, magic, SARMAG) != SARMAG) ! 539: { ! 540: close(fd); ! 541: return (0); ! 542: } ! 543: if (!strcmp(magic, ARMAG)) { ! 544: close(fd); ! 545: return (0); ! 546: } ! 547: *lwa = NUL; ! 548: result = 0; ! 549: while (read(fd, &hdrbuf, sizeof hdrbuf) == sizeof hdrbuf) { ! 550: if ((strncmp(hdrbuf.ar_name, subname, x = strlen(subname)) == 0) ! 551: && (hdrbuf.ar_name[x] == '/')) ! 552: { ! 553: result = atoi(hdrbuf.ar_date); ! 554: break; ! 555: } ! 556: size = atoi(hdrbuf.ar_size); ! 557: lseek(fd, size, SEEK_CUR); ! 558: } ! 559: *lwa = ')'; ! 560: ! 561: return (result); ! 562: #else ! 563: return 0; ! 564: #endif ! 565: } ! 566: ! 567: ! 568: /* Does file name exist? */ ! 569: fexists(name) char *name; ! 570: { ! 571: #if 0 ! 572: if (dflag) ! 573: printf("fexists(%s) = %d getmdate(name) = %d\n", name, ! 574: getmdate(name) != 0, getmdate(name)); ! 575: #endif ! 576: return getmdate(name) != 0; ! 577: } ! 578: ! 579: /* ! 580: * Find name on srcpath. ! 581: * Return 'name' unchanged if file exists as 'name', 'name' is absolute, ! 582: * or 'name' not found on sourcepath. ! 583: * If successful, return pointer to allocated copy. ! 584: */ ! 585: char * ! 586: fpath(name) char *name; ! 587: { ! 588: register char *s; ! 589: ! 590: if (fexists(name) ! 591: || *name == PATHSEP ! 592: || srcpath == NULL ! 593: || (s = path(srcpath, name, AREAD)) == NULL) ! 594: return name; ! 595: starttoken(); ! 596: while (*s) ! 597: addtoken(*s++); ! 598: endtoken(); ! 599: return token; ! 600: } ! 601: ! 602: /* Return a pointer to the symbol table entry with name "name", NULL if it's ! 603: * not there. ! 604: */ ! 605: SYM * ! 606: sexists(name) register char *name; ! 607: { ! 608: register SYM *sp; ! 609: ! 610: for(sp=sym;sp!=NULL;sp=sp->next) ! 611: if (Streq(name, sp->name)) ! 612: return(sp); ! 613: return(NULL); ! 614: } ! 615: ! 616: /* ! 617: * Return a pointer to the member of deplist which has name as the last ! 618: * part of it's pathname, otherwise return NULL. ! 619: */ ! 620: SYM * ! 621: dexists(name, dp) register char *name; register DEP *dp; ! 622: { ! 623: register char *p; ! 624: while (dp != NULL) { ! 625: if ((p = rindex(dp->symbol->name, PATHSEP)) && Streq(name, p+1)) ! 626: return dp->symbol; ! 627: else ! 628: dp = dp->next; ! 629: } ! 630: return NULL; ! 631: } ! 632: ! 633: /* Look for symbol with name "name" in the symbol table; install it if it's ! 634: * not there; initialize the action and dependency lists to NULL, the type to ! 635: * unknown, zero the modification date, and return a pointer to the entry. ! 636: */ ! 637: SYM * ! 638: lookup(name) char *name; ! 639: { ! 640: register SYM *sp; ! 641: ! 642: if ((sp=sexists(name))!=NULL) ! 643: return(sp); ! 644: sp = (SYM *)mmalloc(sizeof (*sp)); /*necessary?*/ ! 645: sp->name=name; ! 646: sp->filename=fpath(name); ! 647: sp->action=NULL; ! 648: sp->deplist=NULL; ! 649: sp->type=T_UNKNOWN; ! 650: sp->moddate=0; ! 651: sp->next=sym; ! 652: sym=sp; ! 653: return(sp); ! 654: } ! 655: ! 656: /* Install a dependency with symbol having name "name", action "action" in ! 657: * the end of the dependency list pointed to by next. If s has already ! 658: * been noted as a file in the dependency list, install action. Return a ! 659: * pointer to the beginning of the dependency list. ! 660: */ ! 661: DEP * ! 662: adddep(name, action, next) char *name, *action; DEP *next; ! 663: { ! 664: register DEP *v; ! 665: register SYM *s; ! 666: DEP *dp; ! 667: ! 668: s=lookup(name); ! 669: for(v=next;v!=NULL;v=v->next) ! 670: if (s==v->symbol){ ! 671: if (action != NULL) { ! 672: if (v->action!=NULL) ! 673: err("multiple detailed actions for %s", ! 674: s->name); ! 675: v->action=action; ! 676: } ! 677: return(next); ! 678: } ! 679: v = (DEP *)malloc(sizeof (*v)); /*necessary?*/ ! 680: v->symbol=s; ! 681: v->action=action; ! 682: v->next=NULL; ! 683: if (next==NULL) ! 684: return(v); ! 685: for(dp=next;dp->next!=NULL;dp=dp->next); ! 686: dp->next=v; ! 687: return(next); ! 688: } ! 689: ! 690: /* Do everything for a dependency with left-hand side cons, r.h.s. ante, ! 691: * action "action", and one or two colons. If cons is the first target in the ! 692: * file, it becomes the default target. Mark each target in cons as detailed ! 693: * if twocolons, undetailed if not, and install action in the symbol table ! 694: * action slot for cons in the latter case. Call adddep() to actually create ! 695: * the dependency list. ! 696: */ ! 697: install(cons, ante, action, twocolons) TOKEN *ante, *cons; char *action; ! 698: { ! 699: SYM *cp; ! 700: TOKEN *ap; ! 701: ! 702: if (deftarget==NULL && cons->value[0]!='.') ! 703: deftarget=cons->value; ! 704: if (dflag){ ! 705: printf("Ante:"); ! 706: ap=ante; ! 707: while(ap!=NULL){ ! 708: printf(" %s", ap->value); ! 709: ap=ap->next; ! 710: } ! 711: printf("\nCons:"); ! 712: ap=cons; ! 713: while(ap!=NULL){ ! 714: printf(" %s", ap->value); ! 715: ap=ap->next; ! 716: } ! 717: printf("\n"); ! 718: if (action!=NULL) ! 719: printf("Action: '%s'\n", action); ! 720: if (twocolons) ! 721: printf("two colons\n"); ! 722: } ! 723: for (; cons != NULL; cons = cons->next) { ! 724: cp=lookup(cons->value); ! 725: if (cp==suffixes && ante==NULL) ! 726: cp->deplist=NULL; ! 727: else{ ! 728: if (twocolons){ ! 729: if (cp->type==T_UNKNOWN) ! 730: cp->type=T_DETAIL; ! 731: else if (cp->type!=T_DETAIL) ! 732: err("'::' not allowed for %s", ! 733: cp->name); ! 734: } else { ! 735: if (cp->type==T_UNKNOWN) ! 736: cp->type=T_NODETAIL; ! 737: else if (cp->type!=T_NODETAIL) ! 738: err("must use '::' for %s", cp->name); ! 739: if (action != NULL) { ! 740: if (cp->action != NULL) ! 741: { ! 742: if (!inactionfile) ! 743: err("multiple action" ! 744: "s for %s", cp->name); ! 745: } ! 746: else ! 747: cp->action = action; ! 748: } ! 749: } ! 750: for(ap=ante;ap!=NULL;ap=ap->next) ! 751: cp->deplist=adddep(ap->value, ! 752: twocolons?action:NULL, cp->deplist); ! 753: } ! 754: } ! 755: } ! 756: ! 757: /* Make s; first, make everything s depends on; if the target has detailed ! 758: * actions, execute any implicit actions associated with it, then execute ! 759: * the actions associated with the dependencies which are newer than s. ! 760: * Otherwise, put the dependencies that are newer than s in token ($?), ! 761: * make s if it doesn't exist, and call docmd. ! 762: */ ! 763: make(s) register SYM *s; ! 764: { ! 765: register DEP *dep; ! 766: register char *t, *name; ! 767: int update; ! 768: int type; ! 769: ! 770: if (s->type==T_DONE) ! 771: return; ! 772: name = s->filename; ! 773: if (dflag) { ! 774: if (s->name == name) ! 775: printf("Making %s\n", name); ! 776: else ! 777: printf("Making %s (file %s)\n", s->name, name); ! 778: } ! 779: type=s->type; ! 780: s->type=T_DONE; ! 781: s->moddate=getmdate(name); ! 782: for(dep=s->deplist;dep!=NULL;dep=dep->next) ! 783: make(dep->symbol); ! 784: if (type==T_DETAIL){ ! 785: implicit(s, "", 0); ! 786: for(dep=s->deplist;dep!=NULL;dep=dep->next) ! 787: if (dep->symbol->moddate>s->moddate) ! 788: docmd0(s, dep->action, name, dep->symbol->filename); ! 789: } else { ! 790: update=0; ! 791: starttoken(); ! 792: for(dep=s->deplist;dep!=NULL;dep=dep->next){ ! 793: if (dflag) ! 794: printf("%s time=%ld %s time=%ld\n", ! 795: dep->symbol->filename, dep->symbol->moddate, ! 796: name, s->moddate); ! 797: if (dep->symbol->moddate>s->moddate){ ! 798: update++; ! 799: addtoken(' '); ! 800: for(t=dep->symbol->filename;*t;t++) ! 801: addtoken(*t); ! 802: } ! 803: } ! 804: endtoken(); ! 805: t = token; ! 806: if (!update && !fexists(name)) { ! 807: update = TRUE; ! 808: if (dflag) ! 809: printf("'%s' made due to non-existence\n", ! 810: name); ! 811: } ! 812: if (s->action==NULL) ! 813: implicit(s, t, update); ! 814: else if (update) ! 815: docmd0(s, s->action, name, t); ! 816: free(t); ! 817: } ! 818: } ! 819: ! 820: /* ! 821: * Expand substitutes the macros in actions and returns the string. ! 822: */ ! 823: expand(str) register char *str; ! 824: { ! 825: register int c; ! 826: register char *p; ! 827: int endc; ! 828: ! 829: while (c = *str++) { ! 830: if (c == '$') { ! 831: c = *str++; ! 832: switch (c) { ! 833: case '\0': err(badmac); ! 834: case '$': addtoken(c); continue; ! 835: case '@': p = mvarval[0]; break; ! 836: case '?': p = mvarval[1]; break; ! 837: case '<': p = mvarval[2]; break; ! 838: case '*': p = mvarval[3]; break; ! 839: case '{': ! 840: case '(': ! 841: endc = (c == '(') ? ')' : '}'; ! 842: c = '('; ! 843: p = str; ! 844: do c = *str++; while (c != 0 && c != endc); ! 845: if (c == 0) ! 846: err(badmac); ! 847: *--str = 0; ! 848: p = mexists(p); ! 849: *str++ = endc; ! 850: break; ! 851: default: ! 852: if ( ! ismacro(c)) ! 853: err(badmac); ! 854: c = *str; ! 855: *str = 0; ! 856: p = mexists(str-1); ! 857: *str = c; ! 858: break; ! 859: } ! 860: if (p != NULL) ! 861: expand(p); ! 862: } else ! 863: addtoken(c); ! 864: } ! 865: } ! 866: ! 867: /* Like docmd(), except builds its own dependency list and prefix args. */ ! 868: docmd0(s, cmd, at, ques) SYM *s; char *cmd, *at, *ques; ! 869: { ! 870: register char *cp; ! 871: register DEP *dep; ! 872: char *less, *prefix; ! 873: ! 874: /* Build dependency list. */ ! 875: starttoken(); ! 876: for (dep = s->deplist; dep != NULL; dep = dep->next) { ! 877: addtoken(' '); ! 878: for (cp = dep->symbol->filename; *cp; cp++) ! 879: addtoken(*cp); ! 880: } ! 881: endtoken(); ! 882: less = token; ! 883: ! 884: /* Build prefix. */ ! 885: starttoken(); ! 886: for (cp = s->name; *cp; cp++) ! 887: addtoken(*cp); ! 888: endtoken(); ! 889: prefix = token; ! 890: ! 891: if ((cp = rindex(prefix, '.')) != NULL) ! 892: *cp = '\0'; ! 893: docmd(s, cmd, at, ques, less, prefix); ! 894: free(less); ! 895: free(prefix); ! 896: } ! 897: ! 898: /* Mark s as modified; if tflag, touch s, otherwise execute the necessary ! 899: * commands. ! 900: */ ! 901: docmd(s, cmd, at, ques, less, star) SYM *s; char *cmd, *at, *ques, *less, *star; ! 902: { ! 903: if (dflag) ! 904: printf("ex '%s'\n\t$@='%s'\n\t$?='%s'\n\t$<='%s'\n\t$*='%s'\n", ! 905: cmd, at, ques, less, star); ! 906: if (qflag) ! 907: exit(NOTUTD); ! 908: s->moddate = now; ! 909: if (tflag) ! 910: cmd = "touch $@"; ! 911: if (cmd == NULL) ! 912: return; ! 913: mvarval[0] = at; ! 914: mvarval[1] = ques; ! 915: mvarval[2] = less; ! 916: mvarval[3] = star; ! 917: starttoken(); ! 918: expand(cmd); ! 919: endtoken(); ! 920: doit(token); ! 921: free(token); ! 922: } ! 923: ! 924: ! 925: /* look for '-' (ignore errors) and '@' (silent) in cmd, then execute it ! 926: * and note the return status. ! 927: */ ! 928: doit(cmd) register char *cmd; ! 929: { ! 930: register char *mark; ! 931: int sflg, iflg, rstat; ! 932: ! 933: if (nflag) { ! 934: printf("%s\n", cmd); ! 935: return; ! 936: } ! 937: do { ! 938: mark = index(cmd, '\n'); ! 939: if (mark != NULL) ! 940: *mark = NUL; ! 941: if (*cmd == '-') { ! 942: ++cmd; ! 943: iflg = TRUE; ! 944: } else ! 945: iflg = iflag; ! 946: if (*cmd == '@') { ! 947: ++cmd; ! 948: sflg = TRUE; ! 949: } else ! 950: sflg = sflag; ! 951: if (!sflg) ! 952: printf("%s\n", cmd); ! 953: fflush(stdout); ! 954: rstat = system(cmd); ! 955: if (rstat != 0 && !iflg) ! 956: if (sflg) ! 957: die("%s exited with status %d", ! 958: cmd, rstat); ! 959: else ! 960: die(" exited with status %d", rstat); ! 961: cmd = mark + 1; ! 962: } while (mark != NULL && *cmd != NUL); ! 963: } ! 964: ! 965: ! 966: /* Find the implicit rule to generate obj and execute it. Put the name of ! 967: * obj up to '.' in prefix, and look for the rest in the dependency list ! 968: * of .SUFFIXES. Find the file "prefix.foo" upon which obj depends, where ! 969: * foo appears in the dependency list of suffixes after the suffix of obj. ! 970: * Then make obj according to the rule from makeactions. If we can't find ! 971: * any rules, use .DEFAULT, provided we're definite. ! 972: */ ! 973: implicit(obj, ques, definite) SYM *obj; char *ques; int definite; ! 974: { ! 975: register char *s; ! 976: register DEP *d; ! 977: char *prefix, *file, *rulename, *suffix; ! 978: SYM *rule; ! 979: SYM *subj; ! 980: ! 981: if (dflag) ! 982: printf("Implicit %s (%s)\n", obj->name, ques); ! 983: if ((suffix=rindex(obj->name, '.')) == NULL ! 984: || suffix==obj->name) { ! 985: if (definite) ! 986: defalt(obj, ques); ! 987: return; ! 988: } ! 989: starttoken(); ! 990: for(s=obj->name; s<suffix; s++) ! 991: addtoken(*s); ! 992: endtoken(); ! 993: prefix=token; ! 994: for(d=suffixes->deplist;d!=NULL;d=d->next) ! 995: if (Streq(suffix, d->symbol->name)) ! 996: break; ! 997: if (d==NULL){ ! 998: free(prefix); ! 999: if (definite) ! 1000: defalt(obj, ques); ! 1001: return; ! 1002: } ! 1003: while((d=d->next)!=NULL){ ! 1004: starttoken(); ! 1005: for(s=obj->name; s!=suffix; s++) ! 1006: addtoken(*s); ! 1007: for(s=d->symbol->name;*s;s++) ! 1008: addtoken(*s); ! 1009: endtoken(); ! 1010: file=token; ! 1011: if ((s = fpath(file)) != file) { ! 1012: free(file); ! 1013: file = s; ! 1014: } ! 1015: subj=NULL; ! 1016: if (fexists(file) || (subj=dexists(file, obj->deplist))){ ! 1017: starttoken(); ! 1018: for(s=d->symbol->filename;*s!='\0';s++) ! 1019: addtoken(*s); ! 1020: for(s=suffix;*s!='\0';s++) ! 1021: addtoken(*s); ! 1022: endtoken(); ! 1023: rulename=token; ! 1024: if ((rule=sexists(rulename))!=NULL){ ! 1025: if (subj != NULL || (subj=sexists(file))) { ! 1026: free(file); ! 1027: file=subj->name; ! 1028: } else ! 1029: subj=lookup(file); ! 1030: make(subj); ! 1031: if (definite || subj->moddate>obj->moddate) ! 1032: docmd(obj, rule->action, ! 1033: obj->name, ques, file, prefix); ! 1034: free(prefix); ! 1035: free(rulename); ! 1036: return; ! 1037: } ! 1038: free(rulename); ! 1039: } ! 1040: free(file); ! 1041: } ! 1042: free(prefix); ! 1043: if (definite) ! 1044: defalt(obj, ques); ! 1045: } ! 1046: ! 1047: /* ! 1048: * Deflt uses the commands associated to '.DEFAULT' to make the object ! 1049: * 'obj'. ! 1050: */ ! 1051: defalt(obj, ques) SYM *obj; char *ques; ! 1052: { ! 1053: if (deflt == NULL) ! 1054: { ! 1055: if (obj->deplist == NULL) ! 1056: die("do not know how to make %s", obj->name); ! 1057: } ! 1058: else ! 1059: docmd0(obj, deflt->action, obj->name, ques); ! 1060: } ! 1061: ! 1062: main(argc, argv, envp) int argc; char *argv[], *envp[]; ! 1063: { ! 1064: register char *s, *value; ! 1065: register char *namesave; ! 1066: register int c; ! 1067: int len, numtargets = 0; ! 1068: char **dtarget; ! 1069: TOKEN *fp = NULL; ! 1070: SYM *sp; ! 1071: DEP *d; ! 1072: MACRO *mp; ! 1073: ! 1074: ! 1075: if ((dtarget = malloc(argc * sizeof(char *))) == NULL) ! 1076: err(nospace); ! 1077: ! 1078: time(&now); ! 1079: ++argv; ! 1080: --argc; ! 1081: ! 1082: while (argc > 0) ! 1083: { ! 1084: if (argv[0][0] == '-') ! 1085: { ! 1086: for (--argc, s = *argv++; *++s != NUL;) ! 1087: switch (*s) { ! 1088: case 'd': dflag++; break; ! 1089: case 'e': eflag++; break; ! 1090: case 'i': iflag++; break; ! 1091: case 'n': nflag++; break; ! 1092: case 'p': pflag++; break; ! 1093: case 'q': qflag++; break; ! 1094: case 'r': rflag++; break; ! 1095: case 's': sflag++; break; ! 1096: case 't': tflag++; break; ! 1097: case 'f': ! 1098: if (--argc < 0) ! 1099: Usage(); ! 1100: fp=listtoken(*argv++, fp); ! 1101: break; ! 1102: default: ! 1103: Usage(); ! 1104: } ! 1105: } ! 1106: else if ((value = index(*argv, '=')) != NULL) ! 1107: { ! 1108: s = *argv; ! 1109: while (*s != ' ' && *s != '\t' && *s != '=') ! 1110: ++s; ! 1111: *s = '\0'; ! 1112: define(*argv++, value+1, 1); ! 1113: --argc; ! 1114: } ! 1115: else ! 1116: { ! 1117: dtarget[numtargets++] = *argv++; ! 1118: --argc; ! 1119: } ! 1120: } ! 1121: while (*envp != NULL) { ! 1122: if ((value = index(*envp, '=')) != NULL ! 1123: && index(value, '$') == NULL) { ! 1124: s = *envp; ! 1125: while ((c=*s) != ' ' && c != '\t' && c != '=') ! 1126: ++s; ! 1127: ! 1128: len = s - *envp; ! 1129: namesave=mmalloc(len+1); ! 1130: strncpy(namesave, *envp, len); ! 1131: namesave[len] = '\0'; ! 1132: ! 1133: if (eflag) ! 1134: define(namesave, value+1, 1); ! 1135: else { ! 1136: starttoken(); ! 1137: while (*++value) addtoken(*value); ! 1138: endtoken(); ! 1139: define(namesave, token, 0); ! 1140: } ! 1141: } ! 1142: ++envp; ! 1143: } ! 1144: srcpath = mexists("SRCPATH"); ! 1145: suffixes=lookup(".SUFFIXES"); ! 1146: if (!rflag) ! 1147: inlib(MACROFILE); ! 1148: deftarget = NULL; ! 1149: if (fp == NULL) ! 1150: inpath("makefile", "Makefile", NULL); ! 1151: else { ! 1152: fd = stdin; ! 1153: do { ! 1154: input( strcmp(fp->value, "-") == 0 ? NULL : fp->value); ! 1155: fp = fp->next; ! 1156: } while (fp != NULL); ! 1157: } ! 1158: if (!rflag) ! 1159: { ! 1160: inactionfile = 1; ! 1161: inlib(ACTIONFILE); ! 1162: inactionfile = 0; ! 1163: } ! 1164: ! 1165: if (sexists(".IGNORE") != NULL) ! 1166: ++iflag; ! 1167: if (sexists(".SILENT") != NULL) ! 1168: ++sflag; ! 1169: deflt = sexists(".DEFAULT"); ! 1170: if (pflag){ ! 1171: if (macro != NULL) { ! 1172: printf("Macros:\n"); ! 1173: for (mp = macro; mp != NULL; mp=mp->next) ! 1174: printf("%s=%s\n", mp->name, mp->value); ! 1175: } ! 1176: printf("Rules:\n"); ! 1177: for(sp=sym;sp!=NULL;sp=sp->next){ ! 1178: if (sp->type!=T_UNKNOWN){ ! 1179: printf("%s:", sp->name); ! 1180: if (sp->type==T_DETAIL) ! 1181: putchar(':'); ! 1182: for(d=sp->deplist;d!=NULL;d=d->next) ! 1183: printf(" %s", d->symbol->name); ! 1184: printf("\n"); ! 1185: if (sp->action) ! 1186: printf("\t%s\n", sp->action); ! 1187: } ! 1188: } ! 1189: } ! 1190: if (numtargets) ! 1191: ! 1192: { ! 1193: int i; ! 1194: ! 1195: for (i=0;i<numtargets;i++) ! 1196: make(lookup(dtarget[i])); ! 1197: } else ! 1198: make(lookup(deftarget)); ! 1199: ! 1200: exit(ALLOK); ! 1201: } ! 1202: ! 1203: /* Whine about usage and then quit */ ! 1204: Usage() ! 1205: { ! 1206: fprintf(stderr, "%s\n", usage); ! 1207: exit(1); ! 1208: } ! 1209: ! 1210: /* end of make.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.