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