/*-
*-----------------------------------------------------------------------
* Make_Update --
* Perform update on the parents of a node. Used by JobFinish once
* a node has been dealt with and by MakeStartJobs if it finds an
* up-to-date node.
*
* Results:
* Always returns 0
*
* Side Effects:
* The unmade field of pgn is decremented and pgn may be placed on
* the toBeMade queue if this field becomes 0.
*
* If the child was made, the parent's childMade field will be set true
* and its cmtime set to now.
*
* If the child wasn't made, the cmtime field of the parent will be
* altered if the child's mtime is big enough.
*
*-----------------------------------------------------------------------
*/
void
Make_Update(GNode *cgn) /* the child node */
{
GNode *pgn; /* the parent node */
LstNode ln; /* Element in parents list */
/*
* If the child was actually made, see what its modification time is
* now -- some rules won't actually update the file. If the file still
* doesn't exist, make its mtime now.
*/
if (cgn->built_status != UPTODATE) {
/*
* 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, there are times when the
* modification time of a file created on a remote machine
* will not be modified before the local 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(cgn)))
ts_set_from_now(cgn->mtime);
if (DEBUG(MAKE))
printf("update time: %s\n", time_to_string(cgn->mtime));
}
/* SIB: this is where I should mark the build as finished */
cgn->build_lock = false;
for (ln = Lst_First(&cgn->parents); ln != NULL; ln = Lst_Adv(ln)) {
pgn = (GNode *)Lst_Datum(ln);
/* SIB: there should be a siblings loop there */
pgn->unmade--;
if (pgn->must_make) {
if (DEBUG(MAKE))
printf("%s--=%d ",
pgn->name, pgn->unmade);
if ( ! (cgn->type & (OP_EXEC|OP_USE))) {
if (cgn->built_status == MADE) {
pgn->childMade = true;
if (is_strictly_before(pgn->cmtime,
cgn->mtime))
pgn->cmtime = cgn->mtime;
} else {
(void)Make_TimeStamp(pgn, cgn);
}
}
if (pgn->unmade == 0) {
/*
* Queue the node up -- any unmade
* predecessors will be dealt with in
* MakeStartJobs.
*/
if (DEBUG(MAKE))
printf("QUEUING ");
Array_Push(&toBeMade, pgn);
} else if (pgn->unmade < 0) {
Error("Child %s discovered graph cycles through %s", cgn->name, pgn->name);
}
}
}
if (DEBUG(MAKE))
printf("\n");
requeue_successors(cgn);
}
bool
Make_OODate(GNode *gn)
{
bool oodate;
/*
* Certain types of targets needn't even be sought as their datedness
* doesn't depend on their modification time...
*/
if ((gn->type & (OP_JOIN|OP_USE|OP_EXEC|OP_PHONY)) == 0) {
(void)Dir_MTime(gn);
if (DEBUG(MAKE)) {
if (!is_out_of_date(gn->mtime))
printf("modified %s...",
time_to_string(gn->mtime));
else
printf("non-existent...");
}
}
/*
* A target is remade in one of the following circumstances:
* - its modification time is smaller than that of its youngest child
* and it would actually be run (has commands or type OP_NOP)
* - it's the object of a force operator
* - it has no children, was on the lhs of an operator and doesn't
* exist already.
*
* Libraries are only considered out-of-date if the archive module says
* they are.
*/
if (gn->type & OP_USE) {
/*
* If the node is a USE node it is *never* out of date
* no matter *what*.
*/
if (DEBUG(MAKE))
printf(".USE node...");
oodate = false;
} else if ((gn->type & OP_LIB) && Arch_IsLib(gn)) {
if (DEBUG(MAKE))
printf("library...");
/* always out of date if no children and :: target */
oodate = Arch_LibOODate(gn) ||
(is_out_of_date(gn->cmtime) && (gn->type & OP_DOUBLEDEP));
} else if (gn->type & OP_JOIN) {
/*
* A target with the .JOIN attribute is only considered
* out-of-date if any of its children was out-of-date.
*/
if (DEBUG(MAKE))
printf(".JOIN node...");
oodate = gn->childMade;
} else if (gn->type & (OP_FORCE|OP_EXEC|OP_PHONY)) {
/*
* A node which is the object of the force (!) operator or which
* has the .EXEC attribute is always considered out-of-date.
*/
if (DEBUG(MAKE)) {
if (gn->type & OP_FORCE)
printf("! operator...");
else if (gn->type & OP_PHONY)
printf(".PHONY node...");
else
printf(".EXEC node...");
}
oodate = true;
} else if (is_strictly_before(gn->mtime, gn->cmtime) ||
(is_out_of_date(gn->cmtime) &&
(is_out_of_date(gn->mtime) || (gn->type & OP_DOUBLEDEP)))) {
/*
* A node whose modification time is less than that of its
* youngest child or that has no children (cmtime ==
* OUT_OF_DATE) and either doesn't exist (mtime == OUT_OF_DATE)
* or was the object of a :: operator is out-of-date.
*/
if (DEBUG(MAKE)) {
if (is_strictly_before(gn->mtime, gn->cmtime))
printf("modified before source...");
else if (is_out_of_date(gn->mtime))
printf("non-existent and no sources...");
else
printf(":: operator and no sources...");
}
oodate = true;
} else {
oodate = false;
}
/*
* If the target isn't out-of-date, the parents need to know its
* modification time. Note that targets that appear to be out-of-date
* but aren't, because they have no commands and aren't of type OP_NOP,
* have their mtime stay below their children's mtime to keep parents
* from thinking they're out-of-date.
*/
if (!oodate)
Lst_ForEach(&gn->parents, MakeTimeStamp, gn);
return oodate;
}
void
Make_TimeStamp(GNode *parent, GNode *child)
{
if (is_strictly_before(parent->cmtime, child->mtime))
parent->cmtime = child->mtime;
}
void
Make_DoAllVar(GNode *gn)
{
GNode *child;
LstNode ln;
BUFFER allsrc, oodate;
char *target;
bool do_oodate;
int oodate_count, allsrc_count = 0;
oodate_count = 0;
allsrc_count = 0;
for (ln = Lst_First(&gn->children); ln != NULL; ln = Lst_Adv(ln)) {
child = (GNode *)Lst_Datum(ln);
if ((child->type & (OP_EXEC|OP_USE|OP_INVISIBLE)) != 0)
continue;
if (OP_NOP(child->type) ||
(target = Var(TARGET_INDEX, child)) == NULL) {
/*
* this node is only source; use the specific pathname
* for it
*/
target = child->path != NULL ? child->path :
child->name;
}
/*
* It goes in the OODATE variable if the parent is younger than
* the child or if the child has been modified more recently
* than the start of the make. This is to keep make from
* getting confused if something else updates the parent after
* the make starts (shouldn't happen, I know, but sometimes it
* does). In such a case, if we've updated the kid, the parent
* is likely to have a modification time later than that of the
* kid and anything that relies on the OODATE variable will be
* hosed.
*/
do_oodate = false;
if (gn->type & OP_JOIN) {
if (child->built_status == MADE)
do_oodate = true;
} else if (is_strictly_before(gn->mtime, child->mtime) ||
(!is_strictly_before(child->mtime, now) &&
child->built_status == MADE))
do_oodate = true;
if (do_oodate) {
oodate_count++;
if (oodate_count == 1)
Var(OODATE_INDEX, gn) = target;
else {
if (oodate_count == 2) {
Buf_Init(&oodate, 0);
Buf_AddString(&oodate,
Var(OODATE_INDEX, gn));
}
Buf_AddSpace(&oodate);
Buf_AddString(&oodate, target);
}
}
allsrc_count++;
if (allsrc_count == 1)
Var(ALLSRC_INDEX, gn) = target;
else {
if (allsrc_count == 2) {
Buf_Init(&allsrc, 0);
Buf_AddString(&allsrc,
Var(ALLSRC_INDEX, gn));
}
Buf_AddSpace(&allsrc);
Buf_AddString(&allsrc, target);
}
}
if (allsrc_count > 1)
Var(ALLSRC_INDEX, gn) = Buf_Retrieve(&allsrc);
if (oodate_count > 1)
Var(OODATE_INDEX, gn) = Buf_Retrieve(&oodate);
if (gn->impliedsrc)
Var(IMPSRC_INDEX, gn) = Var(TARGET_INDEX, gn->impliedsrc);
if (gn->type & OP_JOIN)
Var(TARGET_INDEX, gn) = Var(ALLSRC_INDEX, gn);
}
/*-
*-----------------------------------------------------------------------
* 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;
}
}
