d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace another bunch of Lst_ForEachs by LST_FOREACHs and simplify code.

Browse Source
This commit is contained in:
harti 2005-03-16 12:22:15 +00:00
parent 172eba2632
commit cbbd172aea
1 changed files with 98 additions and 144 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

242
usr.bin/make/make.c
View File

@ -96,18 +96,13 @@ static int numNodes; /* Number of nodes to be processed. If this
* is non-zero when Job_Empty() returns
* TRUE, there's a cycle in the graph */
static int MakeAddChild(void *, void *);
static int MakeAddAllSrc(void *, void *);
static int MakeTimeStamp(void *, void *);
static int MakeHandleUse(void *, void *);
static Boolean MakeStartJobs(void);
static int MakePrintStatus(void *, void *);
/*-
*-----------------------------------------------------------------------
* Make_TimeStamp --
* Set the cmtime field of a parent node based on the mtime stamp in its
* child. Called from MakeOODate via Lst_ForEach.
* child. Called from MakeOODate via LST_FOREACH.
*
* Results:
* Always returns 0.
@ -127,13 +122,6 @@ Make_TimeStamp(GNode *pgn, GNode *cgn)
return (0);
}
static int
MakeTimeStamp(void *pgn, void *cgn)
{
return (Make_TimeStamp(pgn, cgn));
}
/*-
*-----------------------------------------------------------------------
* Make_OODate --
@ -156,6 +144,7 @@ Boolean
Make_OODate(GNode *gn)
{
Boolean oodate;
LstNode *ln;
/*
* Certain types of targets needn't even be sought as their datedness
@ -250,46 +239,23 @@ Make_OODate(GNode *gn)
* thinking they're out-of-date.
*/
if (!oodate) {
Lst_ForEach(&gn->parents, MakeTimeStamp, gn);
LST_FOREACH(ln, &gn->parents)
if (Make_TimeStamp(Lst_Datum(ln), gn))
break;
}
return (oodate);
}
/*-
*-----------------------------------------------------------------------
* MakeAddChild --
* Function used by Make_Run to add a child to the list l.
* It will only add the child if its make field is FALSE.
*
* Results:
* Always returns 0
*
* Side Effects:
* The given list is extended
*-----------------------------------------------------------------------
*/
static int
MakeAddChild(void *gnp, void *lp)
{
GNode *gn = gnp;
Lst *l = lp;
if (!gn->make && !(gn->type & OP_USE)) {
Lst_EnQueue(l, gn);
}
return (0);
}
/*-
*-----------------------------------------------------------------------
* Make_HandleUse --
* Function called by Make_Run and SuffApplyTransform on the downward
* pass to handle .USE and transformation nodes. A callback function
* for Lst_ForEach, it implements the .USE and transformation
* for LST_FOREACH, it implements the .USE and transformation
* functionality by copying the node's commands, type flags
* and children to the parent node. Should be called before the
* children are enqueued to be looked at by MakeAddChild.
* children are enqueued to be looked at.
*
* A .USE node is much like an explicit transformation rule, except
* its commands are always added to the target node, even if the
@ -345,13 +311,6 @@ Make_HandleUse(GNode *cgn, GNode *pgn)
return (0);
}
static int
MakeHandleUse(void *pgn, void *cgn)
{
return (Make_HandleUse(pgn, cgn));
}
/*-
*-----------------------------------------------------------------------
* Make_Update --
@ -513,75 +472,6 @@ Make_Update(GNode *cgn)
free(ptr);
}
/*-
*-----------------------------------------------------------------------
* MakeAddAllSrc --
* Add a child's name to the ALLSRC and OODATE variables of the given
* node. Called from Make_DoAllVar via Lst_ForEach. A child is added only
* if it has not been given the .EXEC, .USE or .INVISIBLE attributes.
* .EXEC and .USE children are very rarely going to be files, so...
* A child is added to the OODATE variable if its modification time is
* later than that of its parent, as defined by Make, except if the
* parent is a .JOIN node. In that case, it is only added to the OODATE
* variable if it was actually made (since .JOIN nodes don't have
* modification times, the comparison is rather unfair...)..
*
* Results:
* Always returns 0
*
* Side Effects:
* The ALLSRC variable for the given node is extended.
*-----------------------------------------------------------------------
*/
static int
MakeAddAllSrc(void *cgnp, void *pgnp)
{
GNode *cgn = (GNode *) cgnp;
GNode *pgn = (GNode *) pgnp;
if ((cgn->type & (OP_EXEC | OP_USE | OP_INVISIBLE)) == 0) {
char *child;
char *p1 = NULL;
if (OP_NOP(cgn->type)) {
/*
* this node is only source; use the specific pathname for it
*/
child = cgn->path ? cgn->path : cgn->name;
}
else
child = Var_Value(TARGET, cgn, &p1);
Var_Append(ALLSRC, child, pgn);
if (pgn->type & OP_JOIN) {
if (cgn->made == MADE) {
Var_Append(OODATE, child, pgn);
}
} else if ((pgn->mtime < cgn->mtime) ||
(cgn->mtime >= now && cgn->made == MADE))
{
/*
* 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 pmake 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.
*
* XXX: This will cause all made children to go in the OODATE
* variable, even if they're not touched, if RECHECK isn't defined,
* since cgn->mtime is set to now in Make_Update. According to
* some people, this is good...
*/
Var_Append(OODATE, child, pgn);
}
free(p1);
}
return (0);
}
/*-
*-----------------------------------------------------------------------
* Make_DoAllVar --
@ -607,22 +497,80 @@ MakeAddAllSrc(void *cgnp, void *pgnp)
void
Make_DoAllVar(GNode *gn)
{
LstNode *ln;
GNode *cgn;
char *child;
char *p1;
Lst_ForEach(&gn->children, MakeAddAllSrc, gn);
LST_FOREACH(ln, &gn->children) {
/*
* Add the child's name to the ALLSRC and OODATE variables of
* the given node. The child is added only if it has not been
* given the .EXEC, .USE or .INVISIBLE attributes. .EXEC and
* .USE children are very rarely going to be files, so...
*
* A child is added to the OODATE variable if its modification
* time is later than that of its parent, as defined by Make,
* except if the parent is a .JOIN node. In that case, it is
* only added to the OODATE variable if it was actually made
* (since .JOIN nodes don't have modification times, the
* comparison is rather unfair...).
*/
cgn = Lst_Datum(ln);
if (!Var_Exists (OODATE, gn)) {
Var_Set(OODATE, "", gn);
}
if (!Var_Exists (ALLSRC, gn)) {
Var_Set(ALLSRC, "", gn);
}
if ((cgn->type & (OP_EXEC | OP_USE | OP_INVISIBLE)) == 0) {
p1 = NULL;
if (OP_NOP(cgn->type)) {
/*
* this node is only source; use the specific
* pathname for it
*/
child = cgn->path ? cgn->path : cgn->name;
} else
child = Var_Value(TARGET, cgn, &p1);
Var_Append(ALLSRC, child, gn);
if (gn->type & OP_JOIN) {
if (cgn->made == MADE) {
Var_Append(OODATE, child, gn);
}
} else if (gn->mtime < cgn->mtime ||
(cgn->mtime >= now && cgn->made == MADE)) {
/*
* 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 pmake 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.
*
* XXX: This will cause all made children to
* go in the OODATE variable, even if they're
* not touched, if RECHECK isn't defined, since
* cgn->mtime is set to now in Make_Update.
* According to some people, this is good...
*/
Var_Append(OODATE, child, gn);
}
free(p1);
}
}
if (gn->type & OP_JOIN) {
char *p1;
if (!Var_Exists (OODATE, gn)) {
Var_Set(OODATE, "", gn);
}
if (!Var_Exists (ALLSRC, gn)) {
Var_Set(ALLSRC, "", gn);
}
Var_Set(TARGET, Var_Value(ALLSRC, gn, &p1), gn);
free(p1);
}
if (gn->type & OP_JOIN) {
Var_Set(TARGET, Var_Value(ALLSRC, gn, &p1), gn);
free(p1);
}
}
/*-
@ -707,29 +655,24 @@ MakeStartJobs(void)
* MakePrintStatus --
* Print the status of a top-level node, viz. it being up-to-date
* already or not created due to an error in a lower level.
* Callback function for Make_Run via Lst_ForEach. If gn->unmade is
* Callback function for Make_Run via LST_FOREACH. If gn->unmade is
* nonzero and that is meant to imply a cycle in the graph, then
* cycle is TRUE.
*
* Results:
* Always returns 0.
*
* Side Effects:
* A message may be printed.
*
*-----------------------------------------------------------------------
*/
static int
MakePrintStatus(void *gnp, void *cyclep)
static void
MakePrintStatus(GNode *gn, Boolean cycle)
{
GNode *gn = gnp;
Boolean cycle = *(Boolean *)cyclep;
LstNode *ln;
if (gn->made == UPTODATE) {
printf("`%s' is up to date.\n", gn->name);
} else if (gn->unmade != 0) {
if (cycle) {
Boolean t = TRUE;
/*
* If printing cycles and came to one that has unmade children,
* print out the cycle by recursing on its children. Note a
@ -743,17 +686,18 @@ MakePrintStatus(void *gnp, void *cyclep)
if (gn->made == CYCLE) {
Error("Graph cycles through `%s'", gn->name);
gn->made = ENDCYCLE;
Lst_ForEach(&gn->children, MakePrintStatus, &t);
LST_FOREACH(ln, &gn->children)
MakePrintStatus(Lst_Datum(ln), TRUE);
gn->made = UNMADE;
} else if (gn->made != ENDCYCLE) {
gn->made = CYCLE;
Lst_ForEach(&gn->children, MakePrintStatus, &t);
LST_FOREACH(ln, &gn->children)
MakePrintStatus(Lst_Datum(ln), TRUE);
}
} else {
printf("`%s' not remade because of errors.\n", gn->name);
}
}
return (0);
}
/*-
@ -781,8 +725,10 @@ Boolean
Make_Run(Lst *targs)
{
GNode *gn; /* a temporary pointer */
GNode *cgn;
Lst examine; /* List of targets to examine */
int errors; /* Number of errors the Job module reports */
LstNode *ln;
Lst_Init(&examine);
Lst_Duplicate(&examine, targs, NOCOPY);
@ -807,11 +753,18 @@ Make_Run(Lst *targs)
* Apply any .USE rules before looking for implicit dependencies
* to make sure everything has commands that should...
*/
Lst_ForEach(&gn->children, MakeHandleUse, gn);
LST_FOREACH(ln, &gn->children)
if (Make_HandleUse(Lst_Datum(ln), gn))
break;
Suff_FindDeps(gn);
if (gn->unmade != 0) {
Lst_ForEach(&gn->children, MakeAddChild, &examine);
LST_FOREACH(ln, &gn->children) {
cgn = Lst_Datum(ln);
if (!cgn->make && !(cgn->type & OP_USE))
Lst_EnQueue(&examine, cgn);
}
} else {
Lst_EnQueue(&toBeMade, gn);
}
@ -859,7 +812,8 @@ Make_Run(Lst *targs)
* because some inferior reported an error.
*/
errors = ((errors == 0) && (numNodes != 0));
Lst_ForEach(targs, MakePrintStatus, &errors);
LST_FOREACH(ln, targs)
MakePrintStatus(Lst_Datum(ln), errors);
return (TRUE);
}