/*-
*-----------------------------------------------------------------------
* Targ_FindList --
* Make a complete list of GNodes from the given list of names
*
* Results:
* A complete list of graph nodes corresponding to all instances of all
* the names in names.
*
* Side Effects:
* If flags is TARG_CREATE, nodes will be created for all names in
* names which do not yet have graph nodes. If flags is TARG_NOCREATE,
* an error message will be printed for each name which can't be found.
* -----------------------------------------------------------------------
*/
Lst
Targ_FindList (
Lst names, /* list of names to find */
int flags) /* flags used if no node is found for a given
* name */
{
Lst nodes; /* result list */
register LstNode ln; /* name list element */
register GNode *gn; /* node in tLn */
string_t name;
nodes = Lst_Init();
Lst_Open (names);
while ((ln = Lst_Next (names)) != NILLNODE) {
name = (string_t)Lst_Datum(ln);
gn = Targ_FindNode (name, flags);
if (gn != NILGNODE) {
/*
* Note: Lst_AtEnd must come before the Lst_Concat so the nodes
* are added to the list in the order in which they were
* encountered in the makefile.
*/
(void) Lst_AtEnd (nodes, (ClientData)gn);
if (gn->type & OP_DOUBLEDEP) {
(void)Lst_Concat (nodes, gn->cohorts, LST_CONCNEW);
}
} else if (flags == TARG_NOCREATE) {
Error ("\"%s\" -- target unknown.", name->data);
}
}
Lst_Close (names);
return (nodes);
}
/*-
*-----------------------------------------------------------------------
* Targ_FindList --
* Make a complete list of GNodes from the given list of names
*
* Input:
* name list of names to find
* flags flags used if no node is found for a given name
*
* Results:
* A complete list of graph nodes corresponding to all instances of all
* the names in names.
*
* Side Effects:
* If flags is TARG_CREATE, nodes will be created for all names in
* names which do not yet have graph nodes. If flags is TARG_NOCREATE,
* an error message will be printed for each name which can't be found.
* -----------------------------------------------------------------------
*/
Lst
Targ_FindList(Lst names, int flags)
{
Lst nodes; /* result list */
LstNode ln; /* name list element */
GNode *gn; /* node in tLn */
char *name;
nodes = Lst_Init(FALSE);
if (Lst_Open(names) == FAILURE) {
return (nodes);
}
while ((ln = Lst_Next(names)) != NULL) {
name = (char *)Lst_Datum(ln);
gn = Targ_FindNode(name, flags);
if (gn != NULL) {
/*
* Note: Lst_AtEnd must come before the Lst_Concat so the nodes
* are added to the list in the order in which they were
* encountered in the makefile.
*/
(void)Lst_AtEnd(nodes, gn);
} else if (flags == TARG_NOCREATE) {
Error("\"%s\" -- target unknown.", name);
}
}
Lst_Close(names);
return (nodes);
}
/*-
*-----------------------------------------------------------------------
* Arch_MemMTime --
* Given a non-existent archive member's node, get its modification
* time from its archived form, if it exists.
*
* Results:
* The modification time.
*
* Side Effects:
* The mtime field is filled in.
*
*-----------------------------------------------------------------------
*/
time_t
Arch_MemMTime(GNode *gn)
{
LstNode ln;
GNode *pgn;
char *nameStart,
*nameEnd;
if (Lst_Open(gn->parents) != SUCCESS) {
gn->mtime = 0;
return (0);
}
while ((ln = Lst_Next(gn->parents)) != NULL) {
pgn = (GNode *)Lst_Datum(ln);
if (pgn->type & OP_ARCHV) {
/*
* If the parent is an archive specification and is being made
* and its member's name matches the name of the node we were
* given, record the modification time of the parent in the
* child. We keep searching its parents in case some other
* parent requires this child to exist...
*/
nameStart = strchr(pgn->name, '(') + 1;
nameEnd = strchr(nameStart, ')');
if ((pgn->flags & REMAKE) &&
strncmp(nameStart, gn->name, nameEnd - nameStart) == 0) {
gn->mtime = Arch_MTime(pgn);
}
} else if (pgn->flags & REMAKE) {
/*
* Something which isn't a library depends on the existence of
* this target, so it needs to exist.
*/
gn->mtime = 0;
break;
}
}
Lst_Close(gn->parents);
return (gn->mtime);
}
/*-
*-----------------------------------------------------------------------
* 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.
*
* Input:
* cgn the child 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 flag CHILDMADE field will be
* set true.
*
* If the child is not up-to-date and still does not exist,
* set the FORCE flag on the parents.
*
* If the child wasn't made, the cmgn field of the parent will be
* altered if the child's mtime is big enough.
*
* Finally, if the child is the implied source for the parent, the
* parent's IMPSRC variable is set appropriately.
*
*-----------------------------------------------------------------------
*/
void
Make_Update(GNode *cgn)
{
GNode *pgn; /* the parent node */
char *cname; /* the child's name */
LstNode ln; /* Element in parents and iParents lists */
time_t mtime = -1;
char *p1;
Lst parents;
GNode *centurion;
/* It is save to re-examine any nodes again */
checked++;
cname = Var_Value(TARGET, cgn, &p1);
free(p1);
if (DEBUG(MAKE))
fprintf(debug_file, "Make_Update: %s%s\n", cgn->name, cgn->cohort_num);
/*
* 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->made != UPTODATE) {
mtime = Make_Recheck(cgn);
}
/*
* If this is a `::' node, we must consult its first instance
* which is where all parents are linked.
*/
if ((centurion = cgn->centurion) != NULL) {
if (!Lst_IsEmpty(cgn->parents))
Punt("%s%s: cohort has parents", cgn->name, cgn->cohort_num);
centurion->unmade_cohorts -= 1;
if (centurion->unmade_cohorts < 0)
Error("Graph cycles through centurion %s", centurion->name);
} else {
centurion = cgn;
}
parents = centurion->parents;
/* If this was a .ORDER node, schedule the RHS */
Lst_ForEach(centurion->order_succ, MakeBuildParent, Lst_First(toBeMade));
/* Now mark all the parents as having one less unmade child */
if (Lst_Open(parents) == SUCCESS) {
while ((ln = Lst_Next(parents)) != NULL) {
pgn = (GNode *)Lst_Datum(ln);
if (DEBUG(MAKE))
fprintf(debug_file, "inspect parent %s%s: flags %x, "
"type %x, made %d, unmade %d ",
pgn->name, pgn->cohort_num, pgn->flags,
pgn->type, pgn->made, pgn->unmade-1);
if (!(pgn->flags & REMAKE)) {
/* This parent isn't needed */
if (DEBUG(MAKE))
fprintf(debug_file, "- not needed\n");
continue;
}
if (mtime == 0 && !(cgn->type & OP_WAIT))
pgn->flags |= FORCE;
/*
* If the parent has the .MADE attribute, its timestamp got
* updated to that of its newest child, and its unmake
* child count got set to zero in Make_ExpandUse().
* However other things might cause us to build one of its
* children - and so we mustn't do any processing here when
* the child build finishes.
*/
if (pgn->type & OP_MADE) {
if (DEBUG(MAKE))
fprintf(debug_file, "- .MADE\n");
continue;
}
if ( ! (cgn->type & (OP_EXEC|OP_USE|OP_USEBEFORE))) {
if (cgn->made == MADE)
pgn->flags |= CHILDMADE;
(void)Make_TimeStamp(pgn, cgn);
}
/*
* A parent must wait for the completion of all instances
* of a `::' dependency.
*/
if (centurion->unmade_cohorts != 0 || centurion->made < MADE) {
if (DEBUG(MAKE))
fprintf(debug_file,
"- centurion made %d, %d unmade cohorts\n",
centurion->made, centurion->unmade_cohorts);
continue;
}
/* One more child of this parent is now made */
pgn->unmade -= 1;
if (pgn->unmade < 0) {
if (DEBUG(MAKE)) {
fprintf(debug_file, "Graph cycles through %s%s\n",
pgn->name, pgn->cohort_num);
Targ_PrintGraph(2);
}
Error("Graph cycles through %s%s", pgn->name, pgn->cohort_num);
}
/* We must always rescan the parents of .WAIT and .ORDER nodes. */
if (pgn->unmade != 0 && !(centurion->type & OP_WAIT)
&& !(centurion->flags & DONE_ORDER)) {
if (DEBUG(MAKE))
fprintf(debug_file, "- unmade children\n");
continue;
}
if (pgn->made != DEFERRED) {
/*
* Either this parent is on a different branch of the tree,
* or it on the RHS of a .WAIT directive
* or it is already on the toBeMade list.
*/
if (DEBUG(MAKE))
fprintf(debug_file, "- not deferred\n");
continue;
}
if (pgn->order_pred
&& Lst_ForEach(pgn->order_pred, MakeCheckOrder, 0)) {
/* A .ORDER rule stops us building this */
continue;
}
if (DEBUG(MAKE)) {
static int two = 2;
fprintf(debug_file, "- %s%s made, schedule %s%s (made %d)\n",
cgn->name, cgn->cohort_num,
pgn->name, pgn->cohort_num, pgn->made);
Targ_PrintNode(pgn, &two);
}
/* Ok, we can schedule the parent again */
pgn->made = REQUESTED;
(void)Lst_EnQueue(toBeMade, pgn);
}
Lst_Close(parents);
}
/*
* Set the .PREFIX and .IMPSRC variables for all the implied parents
* of this node.
*/
if (Lst_Open(cgn->iParents) == SUCCESS) {
char *cpref = Var_Value(PREFIX, cgn, &p1);
while ((ln = Lst_Next(cgn->iParents)) != NULL) {
pgn = (GNode *)Lst_Datum(ln);
if (pgn->flags & REMAKE) {
Var_Set(IMPSRC, cname, pgn, 0);
if (cpref != NULL)
Var_Set(PREFIX, cpref, pgn, 0);
}
}
free(p1);
Lst_Close(cgn->iParents);
}
}
/*-
*-----------------------------------------------------------------------
* Make_HandleUse --
* Function called by Make_Run and SuffApplyTransform on the downward
* pass to handle .USE and transformation nodes. It implements the
* .USE and transformation functionality by copying the node's commands,
* type flags and children to the parent node.
*
* A .USE node is much like an explicit transformation rule, except
* its commands are always added to the target node, even if the
* target already has commands.
*
* Input:
* cgn The .USE node
* pgn The target of the .USE node
*
* Results:
* none
*
* Side Effects:
* Children and commands may be added to the parent and the parent's
* type may be changed.
*
*-----------------------------------------------------------------------
*/
void
Make_HandleUse(GNode *cgn, GNode *pgn)
{
LstNode ln; /* An element in the children list */
#ifdef DEBUG_SRC
if ((cgn->type & (OP_USE|OP_USEBEFORE|OP_TRANSFORM)) == 0) {
fprintf(debug_file, "Make_HandleUse: called for plain node %s\n", cgn->name);
return;
}
#endif
if ((cgn->type & (OP_USE|OP_USEBEFORE)) || Lst_IsEmpty(pgn->commands)) {
if (cgn->type & OP_USEBEFORE) {
/*
* .USEBEFORE --
* prepend the child's commands to the parent.
*/
Lst cmds = pgn->commands;
pgn->commands = Lst_Duplicate(cgn->commands, NULL);
(void)Lst_Concat(pgn->commands, cmds, LST_CONCNEW);
Lst_Destroy(cmds, NULL);
} else {
/*
* .USE or target has no commands --
* append the child's commands to the parent.
*/
(void)Lst_Concat(pgn->commands, cgn->commands, LST_CONCNEW);
}
}
if (Lst_Open(cgn->children) == SUCCESS) {
while ((ln = Lst_Next(cgn->children)) != NULL) {
GNode *tgn, *gn = (GNode *)Lst_Datum(ln);
/*
* Expand variables in the .USE node's name
* and save the unexpanded form.
* We don't need to do this for commands.
* They get expanded properly when we execute.
*/
if (gn->uname == NULL) {
gn->uname = gn->name;
} else {
free(gn->name);
}
gn->name = Var_Subst(NULL, gn->uname, pgn, VARF_WANTRES);
if (gn->name && gn->uname && strcmp(gn->name, gn->uname) != 0) {
/* See if we have a target for this node. */
tgn = Targ_FindNode(gn->name, TARG_NOCREATE);
if (tgn != NULL)
gn = tgn;
}
(void)Lst_AtEnd(pgn->children, gn);
(void)Lst_AtEnd(gn->parents, pgn);
pgn->unmade += 1;
}
Lst_Close(cgn->children);
}
pgn->type |= cgn->type & ~(OP_OPMASK|OP_USE|OP_USEBEFORE|OP_TRANSFORM);
}