/* Add stuff to the toBeMade queue. we try to sort things so that stuff
* that can be done directly is done right away. This won't be perfect,
* since some dependencies are only discovered later (e.g., SuffFindDeps).
*/
static void
add_targets_to_make(Lst todo)
{
GNode *gn;
unsigned int slot;
AppendList2Array(todo, &examine);
while ((gn = Array_Pop(&examine)) != NULL) {
if (gn->must_make) /* already known */
continue;
gn->must_make = true;
slot = ohash_qlookup(&targets, gn->name);
if (!ohash_find(&targets, slot))
ohash_insert(&targets, slot, gn);
look_harder_for_target(gn);
kludge_look_harder_for_target(gn);
/*
* Apply any .USE rules before looking for implicit
* dependencies to make sure everything that should have
* commands has commands ...
*/
Lst_ForEach(&gn->children, MakeHandleUse, gn);
expand_all_children(gn);
if (gn->unmade != 0) {
if (DEBUG(MAKE))
printf("%s: not queuing (%d unmade children)\n",
gn->name, gn->unmade);
Lst_ForEach(&gn->children, MakeAddChild,
&examine);
} else {
if (DEBUG(MAKE))
printf("%s: queuing\n", gn->name);
Array_Push(&toBeMade, gn);
}
}
if (randomize_queue)
randomize_garray(&toBeMade);
}
/*-
*-----------------------------------------------------------------------
* 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;
}
}
