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;
}
}
