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