void Compat_Run(Lst targs) /* List of target nodes to re-create */ { GNode *gn = NULL; /* Current root target */ int errors; /* Number of targets not remade due to errors */ /* For each entry in the list of targets to create, call CompatMake on * it to create the thing. CompatMake will leave the 'built_status' * field of gn in one of several states: * UPTODATE gn was already up-to-date * MADE gn was recreated successfully * ERROR An error occurred while gn was being * created * ABORTED gn was not remade because one of its * inferiors could not be made due to errors. */ errors = 0; while ((gn = (GNode *)Lst_DeQueue(targs)) != NULL) { CompatMake(gn, NULL); if (gn->built_status == UPTODATE) printf("`%s' is up to date.\n", gn->name); else if (gn->built_status == ABORTED) { printf("`%s' not remade because of errors.\n", gn->name); errors++; } } /* If the user has defined a .END target, run its commands. */ if (errors == 0) run_gnode(end_node); }
static void handle_compat_interrupts(GNode *gn) { if (!Targ_Precious(gn)) { char *file = Var(TARGET_INDEX, gn); if (!noExecute && eunlink(file) != -1) Error("*** %s removed\n", file); } if (got_SIGINT) { signal(SIGINT, SIG_IGN); signal(SIGTERM, SIG_IGN); signal(SIGHUP, SIG_IGN); signal(SIGQUIT, SIG_IGN); got_signal = 0; got_SIGINT = 0; run_gnode(interrupt_node); exit(255); } exit(255); }
/*- *----------------------------------------------------------------------- * CompatMake -- * Make a target. * * Side Effects: * If an error is detected and not being ignored, the process exits. *----------------------------------------------------------------------- */ static void CompatMake(void *gnp, /* The node to make */ void *pgnp) /* Parent to abort if necessary */ { GNode *gn = (GNode *)gnp; GNode *pgn = (GNode *)pgnp; GNode *sib; bool cmdsOk; if (DEBUG(MAKE)) printf("CompatMake(%s, %s)\n", pgn ? pgn->name : "NULL", gn->name); /* XXX some loops are not loops, people write dependencies * between siblings to make sure they get built. * Also, we don't recognize direct loops. */ if (gn == pgn) return; /* handle .USE right away */ if (gn->type & OP_USE) { Make_HandleUse(gn, pgn); return; } look_harder_for_target(gn); if (pgn != NULL && is_sibling(gn, pgn)) return; if (pgn == NULL) pgn = gn; if (pgn->type & OP_MADE) { sib = gn; do { sib->mtime = gn->mtime; sib->built_status = UPTODATE; sib = sib->sibling; } while (sib != gn); } switch(gn->built_status) { case UNKNOWN: /* First mark ourselves to be made, then apply whatever * transformations the suffix module thinks are necessary. * Once that's done, we can descend and make all our children. * If any of them has an error but the -k flag was given, * our 'must_make' field will be set false again. This is our * signal to not attempt to do anything but abort our * parent as well. */ gn->must_make = true; gn->built_status = BEINGMADE; /* note that, in case we have siblings, we only check all * children for all siblings, but we don't try to apply * any other rule. */ sib = gn; do { Suff_FindDeps(sib); Lst_ForEach(&sib->children, CompatMake, gn); sib = sib->sibling; } while (sib != gn); if (!gn->must_make) { Error("Build for %s aborted", gn->name); gn->built_status = ABORTED; pgn->must_make = false; return; } /* All the children were made ok. Now youngest points to * the newest child, we need to find out * if we exist and when we were modified last. The criteria * for datedness are defined by the Make_OODate function. */ if (DEBUG(MAKE)) printf("Examining %s...", gn->name); if (!Make_OODate(gn)) { gn->built_status = UPTODATE; if (DEBUG(MAKE)) printf("up-to-date.\n"); return; } else if (DEBUG(MAKE)) printf("out-of-date.\n"); /* If the user is just seeing if something is out-of-date, * exit now to tell him/her "yes". */ if (queryFlag) exit(1); /* normally, we run the job, but if we can't find any * commands, we defer to siblings instead. */ sib = gn; do { /* We need to be re-made. We also have to make sure * we've got a $? variable. To be nice, we also define * the $> variable using Make_DoAllVar(). */ Make_DoAllVar(sib); cmdsOk = node_find_valid_commands(sib); if (cmdsOk || (gn->type & OP_OPTIONAL)) break; sib = sib->sibling; } while (sib != gn); if (cmdsOk) { /* Our commands are ok, but we still have to worry * about the -t flag... */ if (!touchFlag) run_gnode(sib); else { Job_Touch(sib); if (gn != sib) Job_Touch(gn); } } else { node_failure(gn); sib->built_status = ERROR; } /* copy over what we just did */ gn->built_status = sib->built_status; if (gn->built_status != ERROR) { /* If the node was made successfully, mark it so, * update its modification time and timestamp all * its parents. * This is to keep its state from affecting that of * its parent. */ gn->built_status = MADE; sib->built_status = MADE; /* This is what Make does and it's actually a good * thing, as it allows rules like * * cmp -s y.tab.h parse.h || cp y.tab.h parse.h * * to function as intended. Unfortunately, thanks to * the stateless nature of NFS (and the speed of * this program), there are times when the * modification time of a file created on a remote * machine will not be modified before the stat() * implied by the Dir_MTime occurs, thus leading us * to believe that the file is unchanged, wreaking * havoc with files that depend on this one. */ if (noExecute || is_out_of_date(Dir_MTime(gn))) clock_gettime(CLOCK_REALTIME, &gn->mtime); if (is_strictly_before(gn->mtime, gn->youngest->mtime)) gn->mtime = gn->youngest->mtime; if (sib != gn) { if (noExecute || is_out_of_date(Dir_MTime(sib))) clock_gettime(CLOCK_REALTIME, &sib->mtime); if (is_strictly_before(sib->mtime, sib->youngest->mtime)) sib->mtime = sib->youngest->mtime; } if (DEBUG(MAKE)) printf("update time: %s\n", time_to_string(&gn->mtime)); if (!(gn->type & OP_EXEC)) { pgn->childMade = true; Make_TimeStamp(pgn, gn); } } else if (keepgoing) pgn->must_make = false; else { print_errors(); exit(1); } break; case ERROR: /* Already had an error when making this beastie. Tell the * parent to abort. */ pgn->must_make = false; break; case BEINGMADE: Error("Graph cycles through %s", gn->name); gn->built_status = ERROR; pgn->must_make = false; break; case MADE: if ((gn->type & OP_EXEC) == 0) { pgn->childMade = true; Make_TimeStamp(pgn, gn); } break; case UPTODATE: if ((gn->type & OP_EXEC) == 0) Make_TimeStamp(pgn, gn); break; default: break; } }