Annotation of src/usr.bin/make/engine.c, Revision 1.45
1.45 ! espie 1: /* $OpenBSD: engine.c,v 1.44 2013/05/25 11:54:14 espie Exp $ */
1.33 espie 2: /*
3: * Copyright (c) 2012 Marc Espie.
4: *
5: * Extensive code modifications for the OpenBSD project.
6: *
7: * Redistribution and use in source and binary forms, with or without
8: * modification, are permitted provided that the following conditions
9: * are met:
10: * 1. Redistributions of source code must retain the above copyright
11: * notice, this list of conditions and the following disclaimer.
12: * 2. Redistributions in binary form must reproduce the above copyright
13: * notice, this list of conditions and the following disclaimer in the
14: * documentation and/or other materials provided with the distribution.
15: *
16: * THIS SOFTWARE IS PROVIDED BY THE OPENBSD PROJECT AND CONTRIBUTORS
17: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18: * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19: * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBSD
20: * PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21: * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22: * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26: * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27: */
1.1 espie 28: /*
29: * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
30: * Copyright (c) 1988, 1989 by Adam de Boor
31: * Copyright (c) 1989 by Berkeley Softworks
32: * All rights reserved.
33: *
34: * This code is derived from software contributed to Berkeley by
35: * Adam de Boor.
36: *
37: * Redistribution and use in source and binary forms, with or without
38: * modification, are permitted provided that the following conditions
39: * are met:
40: * 1. Redistributions of source code must retain the above copyright
41: * notice, this list of conditions and the following disclaimer.
42: * 2. Redistributions in binary form must reproduce the above copyright
43: * notice, this list of conditions and the following disclaimer in the
44: * documentation and/or other materials provided with the distribution.
45: * 3. Neither the name of the University nor the names of its contributors
46: * may be used to endorse or promote products derived from this software
47: * without specific prior written permission.
48: *
49: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
50: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
51: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
52: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
53: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
54: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
55: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
56: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
57: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
58: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
59: * SUCH DAMAGE.
60: */
61:
1.10 espie 62: #include <sys/types.h>
1.33 espie 63: #include <sys/time.h>
1.10 espie 64: #include <sys/wait.h>
1.20 espie 65: #include <assert.h>
1.41 espie 66: #include <ctype.h>
67: #include <errno.h>
68: #include <fcntl.h>
1.1 espie 69: #include <limits.h>
1.41 espie 70: #include <signal.h>
71: #include <stdint.h>
1.1 espie 72: #include <stdio.h>
1.10 espie 73: #include <stdlib.h>
1.41 espie 74: #include <string.h>
1.1 espie 75: #include <unistd.h>
76: #include "config.h"
77: #include "defines.h"
78: #include "dir.h"
79: #include "engine.h"
80: #include "arch.h"
81: #include "gnode.h"
82: #include "targ.h"
83: #include "var.h"
84: #include "extern.h"
85: #include "lst.h"
86: #include "timestamp.h"
87: #include "make.h"
1.10 espie 88: #include "pathnames.h"
89: #include "error.h"
90: #include "str.h"
91: #include "memory.h"
1.16 espie 92: #include "buf.h"
1.24 espie 93: #include "job.h"
1.33 espie 94: #include "lowparse.h"
1.1 espie 95:
96: static void MakeTimeStamp(void *, void *);
1.6 espie 97: static int rewrite_time(const char *);
1.10 espie 98: static void setup_meta(void);
1.33 espie 99: static void setup_engine(void);
1.10 espie 100: static char **recheck_command_for_shell(char **);
1.34 espie 101: static void list_parents(GNode *, FILE *);
1.10 espie 102:
1.36 espie 103: /* XXX due to a bug in make's logic, targets looking like *.a or -l*
104: * have been silently dropped when make couldn't figure them out.
105: * Now, we warn about them until all Makefile bugs have been fixed.
106: */
107: static bool
108: drop_silently(const char *s)
109: {
110: size_t len;
111:
112: if (s[0] == '-' && s[1] == 'l')
113: return true;
114:
115: len = strlen(s);
116: if (len >=2 && s[len-2] == '.' && s[len-1] == 'a')
117: return true;
118: return false;
119: }
120:
1.1 espie 121: bool
1.33 espie 122: node_find_valid_commands(GNode *gn)
1.1 espie 123: {
1.11 espie 124: /* Alter our type to tell if errors should be ignored or things
1.21 espie 125: * should not be printed so setup_and_run_command knows what to do.
1.11 espie 126: */
127: if (Targ_Ignore(gn))
128: gn->type |= OP_IGNORE;
129: if (Targ_Silent(gn))
130: gn->type |= OP_SILENT;
131:
1.37 espie 132: if (DEBUG(DOUBLE) && (gn->type & OP_DOUBLE))
133: fprintf(stderr, "Warning: target %s had >1 lists of "
134: "shell commands (ignoring later ones)\n", gn->name);
1.34 espie 135: if (OP_NOP(gn->type) && Lst_IsEmpty(&gn->commands)) {
1.36 espie 136: if (drop_silently(gn->name)) {
1.34 espie 137: printf("Warning: target %s", gn->name);
138: list_parents(gn, stdout);
1.36 espie 139: printf(" does not have any command (BUG)\n");
1.34 espie 140: return true;
141: }
1.3 espie 142: /*
143: * No commands. Look for .DEFAULT rule from which we might infer
144: * commands
145: */
1.28 espie 146: if ((gn->type & OP_NODEFAULT) == 0 &&
1.18 espie 147: (DEFAULT->type & OP_DUMMY) == 0 &&
1.9 espie 148: !Lst_IsEmpty(&DEFAULT->commands)) {
1.3 espie 149: /*
150: * Make only looks for a .DEFAULT if the node was never
151: * the target of an operator, so that's what we do too.
152: * If a .DEFAULT was given, we substitute its commands
153: * for gn's commands and set the IMPSRC variable to be
154: * the target's name The DEFAULT node acts like a
155: * transformation rule, in that gn also inherits any
156: * attributes or sources attached to .DEFAULT itself.
157: */
158: Make_HandleUse(DEFAULT, gn);
1.16 espie 159: Var(IMPSRC_INDEX, gn) = Var(TARGET_INDEX, gn);
1.3 espie 160: } else if (is_out_of_date(Dir_MTime(gn))) {
161: /*
162: * The node wasn't the target of an operator we have no
163: * .DEFAULT rule to go on and the target doesn't
164: * already exist. There's nothing more we can do for
1.28 espie 165: * this branch.
1.3 espie 166: */
1.20 espie 167: return false;
168: }
1.1 espie 169: }
1.3 espie 170: return true;
1.1 espie 171: }
172:
1.34 espie 173: static void
174: list_parents(GNode *gn, FILE *out)
175: {
176: LstNode ln;
177: bool first = true;
178:
179: for (ln = Lst_First(&gn->parents); ln != NULL; ln = Lst_Adv(ln)) {
180: GNode *p = Lst_Datum(ln);
181: if (!p->must_make)
182: continue;
183: if (first) {
184: fprintf(out, " (prerequisite of:");
185: first = false;
186: }
187: fprintf(out, " %s", p->name);
188: }
189: if (!first)
190: fprintf(out, ")");
191: }
192:
1.20 espie 193: void
1.33 espie 194: node_failure(GNode *gn)
1.20 espie 195: {
196: /*
197: If the -k flag wasn't given, we stop in
198: * our tracks, otherwise we just don't update this
199: * node's parents so they never get examined.
200: */
1.34 espie 201: const char *diag;
202: FILE *out;
1.20 espie 203:
204: if (gn->type & OP_OPTIONAL) {
1.34 espie 205: out = stdout;
206: diag = "(ignored)";
1.20 espie 207: } else if (keepgoing) {
1.34 espie 208: out = stdout;
209: diag = "(continuing)";
1.20 espie 210: } else {
1.34 espie 211: out = stderr;
212: diag = "";
213: }
214: fprintf(out, "make: don't know how to make %s", gn->name);
215: list_parents(gn, out);
216: fprintf(out, "%s\n", diag);
217: if (out == stdout)
218: fflush(stdout);
219: else {
1.33 espie 220: print_errors();
221: Punt(NULL);
1.20 espie 222: }
223: }
1.33 espie 224:
1.6 espie 225: /* touch files the hard way, by writing stuff to them */
226: static int
227: rewrite_time(const char *name)
228: {
229: int fd;
230: char c;
231:
232: fd = open(name, O_RDWR | O_CREAT, 0666);
233: if (fd < 0)
234: return -1;
235: /*
236: * Read and write a byte to the file to change
237: * the modification time.
238: */
239: if (read(fd, &c, 1) == 1) {
240: (void)lseek(fd, 0, SEEK_SET);
241: (void)write(fd, &c, 1);
242: }
243:
244: (void)close(fd);
245: return 0;
246: }
247:
1.1 espie 248: void
1.12 espie 249: Job_Touch(GNode *gn)
1.1 espie 250: {
1.33 espie 251: handle_all_signals();
1.26 espie 252: if (gn->type & (OP_JOIN|OP_USE|OP_EXEC|OP_OPTIONAL|OP_PHONY)) {
1.3 espie 253: /*
1.9 espie 254: * .JOIN, .USE, and .OPTIONAL targets are "virtual" targets
255: * and, as such, shouldn't really be created.
1.26 espie 256: * Likewise, .PHONY targets are not really files
1.3 espie 257: */
258: return;
259: }
1.1 espie 260:
1.12 espie 261: if (!(gn->type & OP_SILENT)) {
1.3 espie 262: (void)fprintf(stdout, "touch %s\n", gn->name);
263: (void)fflush(stdout);
264: }
1.1 espie 265:
1.3 espie 266: if (noExecute) {
267: return;
268: }
1.1 espie 269:
1.3 espie 270: if (gn->type & OP_ARCHV) {
271: Arch_Touch(gn);
272: } else {
273: const char *file = gn->path != NULL ? gn->path : gn->name;
274:
275: if (set_times(file) == -1){
1.6 espie 276: if (rewrite_time(file) == -1) {
1.5 espie 277: (void)fprintf(stdout,
278: "*** couldn't touch %s: %s", file,
1.3 espie 279: strerror(errno));
280: (void)fflush(stdout);
1.9 espie 281: }
1.1 espie 282: }
283: }
284: }
285:
286: void
1.7 espie 287: Make_TimeStamp(GNode *parent, GNode *child)
1.1 espie 288: {
1.45 ! espie 289: if (is_strictly_before(parent->youngest->mtime, child->mtime)) {
1.44 espie 290: parent->youngest = child;
1.42 espie 291: }
1.1 espie 292: }
293:
294: void
1.9 espie 295: Make_HandleUse(GNode *cgn, /* The .USE node */
1.1 espie 296: GNode *pgn) /* The target of the .USE node */
297: {
1.3 espie 298: GNode *gn; /* A child of the .USE node */
299: LstNode ln; /* An element in the children list */
1.1 espie 300:
1.20 espie 301:
302: assert(cgn->type & (OP_USE|OP_TRANSFORM));
303:
304: if ((cgn->type & OP_USE) || Lst_IsEmpty(&pgn->commands)) {
305: /* .USE or transformation and target has no commands
306: * -- append the child's commands to the parent. */
307: Lst_Concat(&pgn->commands, &cgn->commands);
308: }
309:
310: for (ln = Lst_First(&cgn->children); ln != NULL;
311: ln = Lst_Adv(ln)) {
312: gn = (GNode *)Lst_Datum(ln);
313:
314: if (Lst_AddNew(&pgn->children, gn)) {
315: Lst_AtEnd(&gn->parents, pgn);
316: pgn->unmade++;
1.3 espie 317: }
1.20 espie 318: }
1.1 espie 319:
1.37 espie 320: if (DEBUG(DOUBLE) && (cgn->type & OP_DOUBLE))
321: fprintf(stderr,
322: "Warning: .USE %s expanded in %s had >1 lists of "
323: "shell commands (ignoring later ones)\n",
324: cgn->name, pgn->name);
325: pgn->type |= cgn->type & ~(OP_OPMASK|OP_USE|OP_TRANSFORM|OP_DOUBLE);
1.1 espie 326:
1.20 espie 327: /*
328: * This child node is now "made", so we decrement the count of
329: * unmade children in the parent... We also remove the child
330: * from the parent's list to accurately reflect the number of
331: * decent children the parent has. This is used by Make_Run to
332: * decide whether to queue the parent or examine its children...
333: */
334: if (cgn->type & OP_USE)
335: pgn->unmade--;
1.1 espie 336: }
337:
1.16 espie 338: void
339: Make_DoAllVar(GNode *gn)
1.1 espie 340: {
1.16 espie 341: GNode *child;
342: LstNode ln;
343: BUFFER allsrc, oodate;
344: char *target;
345: bool do_oodate;
346: int oodate_count, allsrc_count = 0;
347:
348: oodate_count = 0;
349: allsrc_count = 0;
1.39 espie 350:
351: Var(OODATE_INDEX, gn) = "";
352: Var(ALLSRC_INDEX, gn) = "";
1.16 espie 353:
354: for (ln = Lst_First(&gn->children); ln != NULL; ln = Lst_Adv(ln)) {
355: child = (GNode *)Lst_Datum(ln);
356: if ((child->type & (OP_EXEC|OP_USE|OP_INVISIBLE)) != 0)
357: continue;
1.9 espie 358: if (OP_NOP(child->type) ||
1.16 espie 359: (target = Var(TARGET_INDEX, child)) == NULL) {
1.3 espie 360: /*
361: * this node is only source; use the specific pathname
362: * for it
363: */
1.9 espie 364: target = child->path != NULL ? child->path :
365: child->name;
1.3 espie 366: }
1.1 espie 367:
1.16 espie 368: /*
369: * It goes in the OODATE variable if the parent is younger than
370: * the child or if the child has been modified more recently
371: * than the start of the make. This is to keep make from
372: * getting confused if something else updates the parent after
373: * the make starts (shouldn't happen, I know, but sometimes it
374: * does). In such a case, if we've updated the kid, the parent
375: * is likely to have a modification time later than that of the
376: * kid and anything that relies on the OODATE variable will be
377: * hosed.
378: */
379: do_oodate = false;
380: if (gn->type & OP_JOIN) {
1.14 espie 381: if (child->built_status == MADE)
1.16 espie 382: do_oodate = true;
383: } else if (is_strictly_before(gn->mtime, child->mtime) ||
1.43 espie 384: (!is_strictly_before(child->mtime, starttime) &&
1.16 espie 385: child->built_status == MADE))
386: do_oodate = true;
387: if (do_oodate) {
388: oodate_count++;
389: if (oodate_count == 1)
390: Var(OODATE_INDEX, gn) = target;
391: else {
392: if (oodate_count == 2) {
393: Buf_Init(&oodate, 0);
1.28 espie 394: Buf_AddString(&oodate,
1.16 espie 395: Var(OODATE_INDEX, gn));
396: }
397: Buf_AddSpace(&oodate);
398: Buf_AddString(&oodate, target);
399: }
400: }
401: allsrc_count++;
402: if (allsrc_count == 1)
403: Var(ALLSRC_INDEX, gn) = target;
404: else {
405: if (allsrc_count == 2) {
406: Buf_Init(&allsrc, 0);
1.28 espie 407: Buf_AddString(&allsrc,
1.16 espie 408: Var(ALLSRC_INDEX, gn));
409: }
410: Buf_AddSpace(&allsrc);
411: Buf_AddString(&allsrc, target);
1.3 espie 412: }
1.1 espie 413: }
414:
1.16 espie 415: if (allsrc_count > 1)
416: Var(ALLSRC_INDEX, gn) = Buf_Retrieve(&allsrc);
417: if (oodate_count > 1)
418: Var(OODATE_INDEX, gn) = Buf_Retrieve(&oodate);
1.1 espie 419:
1.13 espie 420: if (gn->impliedsrc)
1.16 espie 421: Var(IMPSRC_INDEX, gn) = Var(TARGET_INDEX, gn->impliedsrc);
1.28 espie 422:
1.3 espie 423: if (gn->type & OP_JOIN)
1.16 espie 424: Var(TARGET_INDEX, gn) = Var(ALLSRC_INDEX, gn);
1.1 espie 425: }
426:
427: /* Wrapper to call Make_TimeStamp from a forEach loop. */
428: static void
1.9 espie 429: MakeTimeStamp(void *parent, void *child)
1.1 espie 430: {
1.9 espie 431: Make_TimeStamp((GNode *)parent, (GNode *)child);
1.1 espie 432: }
433:
434: bool
1.9 espie 435: Make_OODate(GNode *gn)
1.1 espie 436: {
1.9 espie 437: bool oodate;
1.1 espie 438:
439: /*
1.3 espie 440: * Certain types of targets needn't even be sought as their datedness
441: * doesn't depend on their modification time...
1.1 espie 442: */
1.15 espie 443: if ((gn->type & (OP_JOIN|OP_USE|OP_EXEC|OP_PHONY)) == 0) {
1.3 espie 444: (void)Dir_MTime(gn);
445: if (DEBUG(MAKE)) {
1.9 espie 446: if (!is_out_of_date(gn->mtime))
1.5 espie 447: printf("modified %s...",
1.43 espie 448: time_to_string(&gn->mtime));
1.9 espie 449: else
1.3 espie 450: printf("non-existent...");
451: }
1.1 espie 452: }
453:
454: /*
1.3 espie 455: * A target is remade in one of the following circumstances:
1.9 espie 456: * - its modification time is smaller than that of its youngest child
457: * and it would actually be run (has commands or type OP_NOP)
458: * - it's the object of a force operator
459: * - it has no children, was on the lhs of an operator and doesn't
460: * exist already.
1.3 espie 461: *
1.1 espie 462: */
1.3 espie 463: if (gn->type & OP_USE) {
464: /*
465: * If the node is a USE node it is *never* out of date
466: * no matter *what*.
467: */
1.9 espie 468: if (DEBUG(MAKE))
1.3 espie 469: printf(".USE node...");
470: oodate = false;
471: } else if (gn->type & OP_JOIN) {
472: /*
473: * A target with the .JOIN attribute is only considered
474: * out-of-date if any of its children was out-of-date.
475: */
1.9 espie 476: if (DEBUG(MAKE))
1.3 espie 477: printf(".JOIN node...");
478: oodate = gn->childMade;
479: } else if (gn->type & (OP_FORCE|OP_EXEC|OP_PHONY)) {
480: /*
1.9 espie 481: * A node which is the object of the force (!) operator or which
482: * has the .EXEC attribute is always considered out-of-date.
1.3 espie 483: */
484: if (DEBUG(MAKE)) {
1.9 espie 485: if (gn->type & OP_FORCE)
1.3 espie 486: printf("! operator...");
1.9 espie 487: else if (gn->type & OP_PHONY)
1.3 espie 488: printf(".PHONY node...");
1.9 espie 489: else
1.3 espie 490: printf(".EXEC node...");
491: }
492: oodate = true;
1.45 ! espie 493: } else if (is_strictly_before(gn->mtime, gn->youngest->mtime) ||
! 494: (gn == gn->youngest &&
1.3 espie 495: (is_out_of_date(gn->mtime) || (gn->type & OP_DOUBLEDEP)))) {
496: /*
497: * A node whose modification time is less than that of its
1.45 ! espie 498: * youngest child or that has no children (gn->youngest == gn)
! 499: * and either doesn't exist (mtime == OUT_OF_DATE)
1.9 espie 500: * or was the object of a :: operator is out-of-date.
1.3 espie 501: */
502: if (DEBUG(MAKE)) {
1.45 ! espie 503: if (is_strictly_before(gn->mtime, gn->youngest->mtime))
1.42 espie 504: printf("modified before source(%s)...",
505: gn->youngest->name);
1.9 espie 506: else if (is_out_of_date(gn->mtime))
1.3 espie 507: printf("non-existent and no sources...");
1.9 espie 508: else
1.3 espie 509: printf(":: operator and no sources...");
510: }
511: oodate = true;
512: } else {
513: oodate = false;
514: }
1.1 espie 515:
1.3 espie 516: /*
517: * If the target isn't out-of-date, the parents need to know its
518: * modification time. Note that targets that appear to be out-of-date
519: * but aren't, because they have no commands and aren't of type OP_NOP,
520: * have their mtime stay below their children's mtime to keep parents
521: * from thinking they're out-of-date.
522: */
523: if (!oodate)
524: Lst_ForEach(&gn->parents, MakeTimeStamp, gn);
1.1 espie 525:
1.3 espie 526: return oodate;
1.1 espie 527: }
528:
1.10 espie 529: /* The following array is used to make a fast determination of which
530: * characters are interpreted specially by the shell. If a command
531: * contains any of these characters, it is executed by the shell, not
532: * directly by us. */
533: static char meta[256];
534:
535: void
536: setup_meta(void)
537: {
538: char *p;
539:
1.32 espie 540: for (p = "#=|^(){};&<>*?[]:$`\\\n"; *p != '\0'; p++)
1.10 espie 541: meta[(unsigned char) *p] = 1;
542: /* The null character serves as a sentinel in the string. */
543: meta[0] = 1;
544: }
545:
546: static char **
547: recheck_command_for_shell(char **av)
548: {
549: char *runsh[] = {
1.32 espie 550: "!", "alias", "cd", "eval", "exit", "read", "set", "ulimit",
1.10 espie 551: "unalias", "unset", "wait", "umask", NULL
552: };
553:
554: char **p;
555:
556: /* optimization: if exec cmd, we avoid the intermediate shell */
557: if (strcmp(av[0], "exec") == 0)
558: av++;
559:
560: for (p = runsh; *p; p++)
561: if (strcmp(av[0], *p) == 0)
562: return NULL;
563:
564: return av;
565: }
566:
1.40 espie 567: static void
1.10 espie 568: run_command(const char *cmd, bool errCheck)
569: {
570: const char *p;
571: char *shargv[4];
572: char **todo;
573:
574: shargv[0] = _PATH_BSHELL;
575:
576: shargv[1] = errCheck ? "-ec" : "-c";
577: shargv[2] = (char *)cmd;
578: shargv[3] = NULL;
579:
580: todo = shargv;
581:
582:
583: /* Search for meta characters in the command. If there are no meta
584: * characters, there's no need to execute a shell to execute the
585: * command. */
586: for (p = cmd; !meta[(unsigned char)*p]; p++)
587: continue;
588: if (*p == '\0') {
589: char *bp;
590: char **av;
591: int argc;
592: /* No meta-characters, so probably no need to exec a shell.
593: * Break the command into words to form an argument vector
594: * we can execute. */
595: av = brk_string(cmd, &argc, &bp);
596: av = recheck_command_for_shell(av);
597: if (av != NULL)
598: todo = av;
599: }
600: execvp(todo[0], todo);
601:
602: if (errno == ENOENT)
603: fprintf(stderr, "%s: not found\n", todo[0]);
604: else
605: perror(todo[0]);
606: _exit(1);
607: }
608:
1.33 espie 609: static Job myjob;
610:
611: void
612: job_attach_node(Job *job, GNode *node)
613: {
614: job->node = node;
1.34 espie 615: job->node->built_status = BUILDING;
1.33 espie 616: job->next_cmd = Lst_First(&node->commands);
617: job->exit_type = JOB_EXIT_OKAY;
618: job->location = NULL;
619: job->flags = 0;
620: }
621:
622: void
623: job_handle_status(Job *job, int status)
624: {
1.36 espie 625: bool silent;
1.38 espie 626: int dying;
1.36 espie 627:
628: /* if there's one job running and we don't keep going, no need
629: * to report right now.
630: */
631: if ((job->flags & JOB_ERRCHECK) && !keepgoing && runningJobs == NULL)
632: silent = !DEBUG(JOB);
633: else
634: silent = false;
635:
1.33 espie 636: debug_job_printf("Process %ld (%s) exited with status %d.\n",
637: (long)job->pid, job->node->name, status);
638:
639: /* classify status */
640: if (WIFEXITED(status)) {
641: job->code = WEXITSTATUS(status);/* exited */
1.38 espie 642: if (job->code != 0) {
643: /* if we're already dying from that signal, be silent */
644: if (!silent && job->code > 128
645: && job->code <= 128 + _NSIG) {
646: dying = check_dying_signal();
647: silent = dying && job->code == dying + 128;
648: }
1.36 espie 649: if (!silent)
650: printf("*** Error %d", job->code);
1.33 espie 651: job->exit_type = JOB_EXIT_BAD;
652: } else
653: job->exit_type = JOB_EXIT_OKAY;
654: } else {
655: job->exit_type = JOB_SIGNALED;
656: job->code = WTERMSIG(status); /* signaled */
1.38 espie 657: /* if we're already dying from that signal, be silent */
658: if (!silent) {
659: dying = check_dying_signal();
660: silent = dying && job->code == dying;
661: }
1.36 espie 662: if (!silent)
663: printf("*** Signal %d", job->code);
1.33 espie 664: }
665:
666: /* if there is a problem, what's going on ? */
667: if (job->exit_type != JOB_EXIT_OKAY) {
1.36 espie 668: if (!silent)
669: printf(" in target '%s'", job->node->name);
1.33 espie 670: if (job->flags & JOB_ERRCHECK) {
671: job->node->built_status = ERROR;
672: /* compute expensive status if we really want it */
673: if ((job->flags & JOB_SILENT) && job == &myjob)
674: determine_expensive_job(job);
675: if (!keepgoing) {
1.36 espie 676: if (!silent)
677: printf("\n");
1.33 espie 678: job->next = errorJobs;
679: errorJobs = job;
680: /* XXX don't free the command */
681: return;
682: }
683: printf(", line %lu of %s", job->location->lineno,
684: job->location->fname);
685: if ((job->flags & (JOB_SILENT | JOB_IS_EXPENSIVE))
686: == JOB_SILENT)
687: printf(": %s", job->cmd);
688: /* Abort the current target,
689: * but let others continue. */
690: printf(" (continuing)\n");
691: } else {
692: /* Continue executing commands for
693: * this target. If we return 0,
694: * this will happen... */
695: printf(" (ignored)\n");
696: job->exit_type = JOB_EXIT_OKAY;
697: }
698: }
699: free(job->cmd);
700: }
701:
702: int
703: run_gnode(GNode *gn)
704: {
705: if (!gn || (gn->type & OP_DUMMY))
706: return NOSUCHNODE;
707:
708: gn->built_status = MADE;
709:
710: job_attach_node(&myjob, gn);
711: while (myjob.exit_type == JOB_EXIT_OKAY) {
712: bool finished = job_run_next(&myjob);
713: if (finished)
714: break;
715: handle_one_job(&myjob);
716: }
717:
718: return gn->built_status;
719: }
720:
721:
722: static void
723: setup_engine(void)
724: {
725: static int already_setup = 0;
726:
727: if (!already_setup) {
728: setup_meta();
729: already_setup = 1;
730: }
731: }
732:
733: static bool
734: do_run_command(Job *job)
1.10 espie 735: {
736: bool silent; /* Don't print command */
737: bool doExecute; /* Execute the command */
738: bool errCheck; /* Check errors */
1.33 espie 739: pid_t cpid; /* Child pid */
740:
741: const char *cmd = job->cmd;
742: silent = job->node->type & OP_SILENT;
743: errCheck = !(job->node->type & OP_IGNORE);
744: if (job->node->type & OP_MAKE)
745: doExecute = true;
746: else
747: doExecute = !noExecute;
1.10 espie 748:
749: /* How can we execute a null command ? we warn the user that the
750: * command expanded to nothing (is this the right thing to do?). */
1.19 espie 751: if (*cmd == '\0') {
1.10 espie 752: Error("%s expands to empty string", cmd);
1.33 espie 753: return false;
1.28 espie 754: }
1.10 espie 755:
756: for (;; cmd++) {
757: if (*cmd == '@')
758: silent = DEBUG(LOUD) ? false : true;
759: else if (*cmd == '-')
760: errCheck = false;
761: else if (*cmd == '+')
762: doExecute = true;
763: else
764: break;
765: }
766: while (isspace(*cmd))
767: cmd++;
1.33 espie 768: /* Print the command before fork if make -n or !silent*/
769: if ( noExecute || !silent)
1.10 espie 770: printf("%s\n", cmd);
1.33 espie 771:
772: if (silent)
773: job->flags |= JOB_SILENT;
774: else
775: job->flags &= ~JOB_SILENT;
776:
1.10 espie 777: /* If we're not supposed to execute any commands, this is as far as
778: * we go... */
779: if (!doExecute)
1.33 espie 780: return false;
781: /* always flush for other stuff */
782: fflush(stdout);
1.10 espie 783:
784: /* Fork and execute the single command. If the fork fails, we abort. */
785: switch (cpid = fork()) {
786: case -1:
1.33 espie 787: Punt("Could not fork");
1.10 espie 788: /*NOTREACHED*/
789: case 0:
1.34 espie 790: /* put a random delay unless we're the only job running
791: * and there's nothing left to do.
792: */
793: if (random_delay)
794: if (!(runningJobs == NULL && no_jobs_left()))
795: usleep(random() % random_delay);
1.10 espie 796: run_command(cmd, errCheck);
797: /*NOTREACHED*/
798: default:
1.33 espie 799: job->pid = cpid;
800: job->next = runningJobs;
801: runningJobs = job;
802: if (errCheck)
803: job->flags |= JOB_ERRCHECK;
804: else
805: job->flags &= ~JOB_ERRCHECK;
806: debug_job_printf("Running %ld (%s) %s\n", (long)job->pid,
807: job->node->name, (noExecute || !silent) ? "" : cmd);
808: return true;
1.10 espie 809: }
810: }
811:
1.33 espie 812: bool
813: job_run_next(Job *job)
1.10 espie 814: {
1.33 espie 815: bool started;
816: GNode *gn = job->node;
1.19 espie 817:
1.33 espie 818: setup_engine();
819: while (job->next_cmd != NULL) {
820: struct command *command = Lst_Datum(job->next_cmd);
821:
822: handle_all_signals();
823: job->location = &command->location;
824: Parse_SetLocation(job->location);
825: job->cmd = Var_Subst(command->string, &gn->context, false);
826: job->next_cmd = Lst_Adv(job->next_cmd);
1.30 espie 827: if (fatal_errors)
1.33 espie 828: Punt(NULL);
829: started = do_run_command(job);
830: if (started)
831: return false;
832: else
833: free(job->cmd);
1.19 espie 834: }
1.33 espie 835: job->exit_type = JOB_EXIT_OKAY;
836: return true;
1.19 espie 837: }
838:
![[BACK]](/icons/back.gif){kind=icon}
Return to engine.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / make