Style: indentation.

1 files changed, 473 insertions, 475 deletions

diff --git a/usr.bin/make/make.c b/usr.bin/make/make.c
index 7d14271..e674608 100644
--- a/usr.bin/make/make.c
+++ b/usr.bin/make/make.c
@@ -41,36 +41,35 @@
 #include <sys/cdefs.h>
 __FBSDID("$FreeBSD$");
 
-/*-
- * make.c --
+/*
+ * make.c
  *	The functions which perform the examination of targets and
  *	their suitability for creation
  *
  * Interface:
- *	Make_Run 	    	Initialize things for the module and recreate
- *	    	  	    	whatever needs recreating. Returns TRUE if
- *	    	    	    	work was (or would have been) done and FALSE
- *	    	  	    	otherwise.
+ *	Make_Run	Initialize things for the module and recreate
+ *			whatever needs recreating. Returns TRUE if
+ *			work was (or would have been) done and FALSE
+ *			otherwise.
  *
- *	Make_Update	    	Update all parents of a given child. Performs
- *	    	  	    	various bookkeeping chores like the updating
- *	    	  	    	of the cmtime field of the parent, filling
- *	    	  	    	of the IMPSRC context variable, etc. It will
- *	    	  	    	place the parent on the toBeMade queue if it
- *	    	  	    	should be.
+ *	Make_Update	Update all parents of a given child. Performs
+ *			various bookkeeping chores like the updating
+ *			of the cmtime field of the parent, filling
+ *			of the IMPSRC context variable, etc. It will
+ *			place the parent on the toBeMade queue if it should be.
  *
- *	Make_TimeStamp	    	Function to set the parent's cmtime field
- *	    	  	    	based on a child's modification time.
+ *	Make_TimeStamp	Function to set the parent's cmtime field
+ *			based on a child's modification time.
  *
- *	Make_DoAllVar	    	Set up the various local variables for a
- *	    	  	    	target, including the .ALLSRC variable, making
- *	    	  	    	sure that any variable that needs to exist
- *	    	  	    	at the very least has the empty value.
+ *	Make_DoAllVar	Set up the various local variables for a
+ *			target, including the .ALLSRC variable, making
+ *			sure that any variable that needs to exist
+ *			at the very least has the empty value.
  *
- *	Make_OODate 	    	Determine if a target is out-of-date.
+ *	Make_OODate	Determine if a target is out-of-date.
  *
- *	Make_HandleUse		See if a child is a .USE node for a parent
- *				and perform the .USE actions if so.
+ *	Make_HandleUse	See if a child is a .USE node for a parent
+ *			and perform the .USE actions if so.
  */
 
 #include <stdlib.h>
@@ -92,15 +91,16 @@ __FBSDID("$FreeBSD$");
  * MakeStartJobs */
 static Lst toBeMade = Lst_Initializer(toBeMade);
 
-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 */
+/*
+ * 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 numNodes;
 
 static Boolean MakeStartJobs(void);
 
-/*-
- *-----------------------------------------------------------------------
- * Make_TimeStamp --
+/**
+ * Make_TimeStamp
  *	Set the cmtime field of a parent node based on the mtime stamp in its
  *	child. Called from MakeOODate via LST_FOREACH.
  *
@@ -110,21 +110,19 @@ static Boolean MakeStartJobs(void);
  * Side Effects:
  *	The cmtime of the parent node will be changed if the mtime
  *	field of the child is greater than it.
- *-----------------------------------------------------------------------
  */
 int
 Make_TimeStamp(GNode *pgn, GNode *cgn)
 {
 
-    if (cgn->mtime > pgn->cmtime) {
-	pgn->cmtime = cgn->mtime;
-    }
-    return (0);
+	if (cgn->mtime > pgn->cmtime) {
+		pgn->cmtime = cgn->mtime;
+	}
+	return (0);
 }
 
-/*-
- *-----------------------------------------------------------------------
- * Make_OODate --
+/**
+ * Make_OODate
  *	See if a given node is out of date with respect to its sources.
  *	Used by Make_Run when deciding which nodes to place on the
  *	toBeMade queue initially and by Make_Update to screen out USE and
@@ -138,118 +136,120 @@ Make_TimeStamp(GNode *pgn, GNode *cgn)
  * Side Effects:
  *	The mtime field of the node and the cmtime field of its parents
  *	will/may be changed.
- *-----------------------------------------------------------------------
  */
 Boolean
 Make_OODate(GNode *gn)
 {
-    Boolean         oodate;
-    LstNode	    *ln;
-
-    /*
-     * 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)) == 0) {
-	Dir_MTime(gn);
-	if (gn->mtime != 0) {
-	    DEBUGF(MAKE, ("modified %s...", Targ_FmtTime(gn->mtime)));
-	} else {
-	    DEBUGF(MAKE, ("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.
-     *
-     * These weird rules are brought to you by Backward-Compatability and
-     * the strange people who wrote 'Make'.
-     */
-    if (gn->type & OP_USE) {
-	/*
-	 * If the node is a USE node it is *never* out of date
-	 * no matter *what*.
-	 */
-	DEBUGF(MAKE, (".USE node..."));
-	oodate = FALSE;
-    } else if (gn->type & OP_LIB) {
-	DEBUGF(MAKE, ("library..."));
+	Boolean	oodate;
+	LstNode	*ln;
 
 	/*
-	 * always out of date if no children and :: target
+	 * 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)) == 0) {
+		Dir_MTime(gn);
+		if (gn->mtime != 0) {
+			DEBUGF(MAKE, ("modified %s...",
+			    Targ_FmtTime(gn->mtime)));
+		} else {
+			DEBUGF(MAKE, ("non-existent..."));
+		}
+	}
 
-	oodate = Arch_LibOODate(gn) ||
-	    ((gn->cmtime == 0) && (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.
-	 */
-	DEBUGF(MAKE, (".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.
+	 * 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.
+	 *
+	 * These weird rules are brought to you by Backward-Compatibility and
+	 * the strange people who wrote 'Make'.
 	 */
-	if (gn->type & OP_FORCE) {
-	    DEBUGF(MAKE, ("! operator..."));
-	} else if (gn->type & OP_PHONY) {
-	    DEBUGF(MAKE, (".PHONY node..."));
-	} else {
-	    DEBUGF(MAKE, (".EXEC node..."));
-	}
-	oodate = TRUE;
-    } else if ((gn->mtime < gn->cmtime) ||
-	       ((gn->cmtime == 0) &&
-		((gn->mtime==0) || (gn->type & OP_DOUBLEDEP))))
-    {
+	if (gn->type & OP_USE) {
+		/*
+		 * If the node is a USE node it is *never* out of date
+		 * no matter *what*.
+		 */
+		DEBUGF(MAKE, (".USE node..."));
+		oodate = FALSE;
+
+	} else if (gn->type & OP_LIB) {
+		DEBUGF(MAKE, ("library..."));
+
+		/*
+		 * always out of date if no children and :: target
+		 */
+		oodate = Arch_LibOODate(gn) ||
+		    ((gn->cmtime == 0) && (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.
+		 */
+		DEBUGF(MAKE, (".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 (gn->type & OP_FORCE) {
+			DEBUGF(MAKE, ("! operator..."));
+		} else if (gn->type & OP_PHONY) {
+			DEBUGF(MAKE, (".PHONY node..."));
+		} else {
+			DEBUGF(MAKE, (".EXEC node..."));
+		}
+		oodate = TRUE;
+
+	} else if ((gn->mtime < gn->cmtime) ||
+	    ((gn->cmtime == 0) &&
+	    ((gn->mtime==0) || (gn->type & OP_DOUBLEDEP)))) {
+		/*
+		 * A node whose modification time is less than that of its
+		 * youngest child or that has no children (cmtime == 0) and
+		 * either doesn't exist (mtime == 0) or was the object of a
+		 * :: operator is out-of-date. Why? Because that's the way
+		 * Make does it.
+		 */
+		if (gn->mtime < gn->cmtime) {
+			DEBUGF(MAKE, ("modified before source..."));
+		} else if (gn->mtime == 0) {
+			DEBUGF(MAKE, ("non-existent and no sources..."));
+		} else {
+			DEBUGF(MAKE, (":: operator and no sources..."));
+		}
+		oodate = TRUE;
+	} else
+		oodate = FALSE;
+
 	/*
-	 * A node whose modification time is less than that of its
-	 * youngest child or that has no children (cmtime == 0) and
-	 * either doesn't exist (mtime == 0) or was the object of a
-	 * :: operator is out-of-date. Why? Because that's the way Make does
-	 * it.
+	 * 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 (gn->mtime < gn->cmtime) {
-	    DEBUGF(MAKE, ("modified before source..."));
-	} else if (gn->mtime == 0) {
-	    DEBUGF(MAKE, ("non-existent and no sources..."));
-	} else {
-	    DEBUGF(MAKE, (":: operator and no sources..."));
+	if (!oodate) {
+		LST_FOREACH(ln, &gn->parents)
+			if (Make_TimeStamp(Lst_Datum(ln), gn))
+				break;
 	}
-	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(ln, &gn->parents)
-	    if (Make_TimeStamp(Lst_Datum(ln), gn))
-		break;
-    }
-
-    return (oodate);
+
+	return (oodate);
 }
 
-/*-
- *-----------------------------------------------------------------------
- * Make_HandleUse --
+/**
+ * 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
@@ -273,47 +273,47 @@ Make_OODate(GNode *gn)
 int
 Make_HandleUse(GNode *cgn, GNode *pgn)
 {
-    GNode	*gn;	 	/* A child of the .USE node */
-    LstNode	*ln;	 	/* An element in the children list */
-
-    if (cgn->type & (OP_USE | OP_TRANSFORM)) {
-	if ((cgn->type & OP_USE) || Lst_IsEmpty(&pgn->commands)) {
-	    /*
-	     * .USE or transformation and target has no commands -- append
-	     * the child's commands to the parent.
-	     */
-	     Lst_Concat(&pgn->commands, &cgn->commands, LST_CONCNEW);
-	}
+	GNode	*gn;	/* A child of the .USE node */
+	LstNode	*ln;	/* An element in the children list */
+
+	if (cgn->type & (OP_USE | OP_TRANSFORM)) {
+		if ((cgn->type & OP_USE) || Lst_IsEmpty(&pgn->commands)) {
+			/*
+			 * .USE or transformation and target has no commands --
+			 * append the child's commands to the parent.
+			 */
+			Lst_Concat(&pgn->commands, &cgn->commands, LST_CONCNEW);
+		}
 
-	for (ln = Lst_First(&cgn->children); ln != NULL; ln = Lst_Succ(ln)) {
-	    gn = Lst_Datum(ln);
+		for (ln = Lst_First(&cgn->children); ln != NULL;
+		    ln = Lst_Succ(ln)) {
+			gn = Lst_Datum(ln);
 
-	    if (Lst_Member(&pgn->children, gn) == NULL) {
-		Lst_AtEnd(&pgn->children, gn);
-		Lst_AtEnd(&gn->parents, pgn);
-		pgn->unmade += 1;
-	    }
-	}
+			if (Lst_Member(&pgn->children, gn) == NULL) {
+				Lst_AtEnd(&pgn->children, gn);
+				Lst_AtEnd(&gn->parents, pgn);
+				pgn->unmade += 1;
+			}
+		}
 
-	pgn->type |= cgn->type & ~(OP_OPMASK | OP_USE | OP_TRANSFORM);
+		pgn->type |= cgn->type & ~(OP_OPMASK | OP_USE | OP_TRANSFORM);
 
-	/*
-	 * This child node is now "made", so we decrement the count of
-	 * unmade children in the parent... We also remove the child
-	 * from the parent's list to accurately reflect the number of decent
-	 * children the parent has. This is used by Make_Run to decide
-	 * whether to queue the parent or examine its children...
-	 */
-	if (cgn->type & OP_USE) {
-	    pgn->unmade--;
+		/*
+		 * This child node is now "made", so we decrement the count of
+		 * unmade children in the parent... We also remove the child
+		 * from the parent's list to accurately reflect the number of
+		 * decent children the parent has. This is used by Make_Run to
+		 * decide whether to queue the parent or examine its children...
+		 */
+		if (cgn->type & OP_USE) {
+			pgn->unmade--;
+		}
 	}
-    }
-    return (0);
+	return (0);
 }
 
-/*-
- *-----------------------------------------------------------------------
- * Make_Update  --
+/**
+ * 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.
@@ -333,148 +333,149 @@ Make_HandleUse(GNode *cgn, GNode *pgn)
  *
  *	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 */
-    char	*p1;
-    char        *ptr;
-    char	*cpref;
-
-    cname = Var_Value(TARGET, cgn, &p1);
-    free(p1);
-
-    /*
-     * 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) {
-#ifndef RECHECK
+	GNode	*pgn;	/* the parent node */
+	char	*cname;	/* the child's name */
+	LstNode	*ln;	/* Element in parents and iParents lists */
+	char	*p1;
+	char	*ptr;
+	char	*cpref;
+
+	cname = Var_Value(TARGET, cgn, &p1);
+	free(p1);
+
 	/*
-	 * We can't re-stat the thing, but we can at least take care of rules
-	 * where a target depends on a source that actually creates the
-	 * target, but only if it has changed, e.g.
-	 *
-	 * parse.h : parse.o
-	 *
-	 * parse.o : parse.y
-	 *  	yacc -d parse.y
-	 *  	cc -c y.tab.c
-	 *  	mv y.tab.o parse.o
-	 *  	cmp -s y.tab.h parse.h || mv y.tab.h parse.h
-	 *
-	 * In this case, if the definitions produced by yacc haven't changed
-	 * from before, parse.h won't have been updated and cgn->mtime will
-	 * reflect the current modification time for parse.h. This is
-	 * something of a kludge, I admit, but it's a useful one..
-	 * XXX: People like to use a rule like
-	 *
-	 * FRC:
-	 *
-	 * To force things that depend on FRC to be made, so we have to
-	 * check for gn->children being empty as well...
+	 * 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 (!Lst_IsEmpty(&cgn->commands) || Lst_IsEmpty(&cgn->children)) {
-	    cgn->mtime = now;
+	if (cgn->made != UPTODATE) {
+#ifndef RECHECK
+		/*
+		 * We can't re-stat the thing, but we can at least take care
+		 * of rules where a target depends on a source that actually
+		 * creates the target, but only if it has changed, e.g.
+		 *
+		 * parse.h : parse.o
+		 *
+		 * parse.o : parse.y
+		 *  	yacc -d parse.y
+		 *  	cc -c y.tab.c
+		 *  	mv y.tab.o parse.o
+		 *  	cmp -s y.tab.h parse.h || mv y.tab.h parse.h
+		 *
+		 * In this case, if the definitions produced by yacc haven't
+		 * changed from before, parse.h won't have been updated and
+		 * cgn->mtime will reflect the current modification time for
+		 * parse.h. This is something of a kludge, I admit, but it's a
+		 * useful one..
+		 * XXX: People like to use a rule like
+		 *
+		 * FRC:
+		 *
+		 * To force things that depend on FRC to be made, so we have to
+		 * check for gn->children being empty as well...
+		 */
+		if (!Lst_IsEmpty(&cgn->commands) ||
+		    Lst_IsEmpty(&cgn->children)) {
+			cgn->mtime = now;
+		}
+	#else
+		/*
+		 * 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 (by which I mean the loose coupling
+		 * of two clients using the same file from a common server),
+		 * 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.
+		 *
+		 * I have decided it is better to make too much than to make too
+		 * little, so this stuff is commented out unless you're sure
+		 * it's ok.
+		 * -- ardeb 1/12/88
+		 */
+		/*
+		 * Christos, 4/9/92: If we are  saving commands pretend that
+		 * the target is made now. Otherwise archives with ... rules
+		 * don't work!
+		 */
+		if (noExecute || (cgn->type & OP_SAVE_CMDS) ||
+		    Dir_MTime(cgn) == 0) {
+			cgn->mtime = now;
+		}
+		DEBUGF(MAKE, ("update time: %s\n", Targ_FmtTime(cgn->mtime)));
+#endif
+	}
+
+	for (ln = Lst_First(&cgn->parents); ln != NULL; ln = Lst_Succ(ln)) {
+		pgn = Lst_Datum(ln);
+		if (pgn->make) {
+			pgn->unmade -= 1;
+
+			if (!(cgn->type & (OP_EXEC | OP_USE))) {
+				if (cgn->made == MADE) {
+					pgn->childMade = TRUE;
+					if (pgn->cmtime < cgn->mtime) {
+						pgn->cmtime = cgn->mtime;
+					}
+				} else {
+					Make_TimeStamp(pgn, cgn);
+				}
+			}
+			if (pgn->unmade == 0) {
+				/*
+				 * Queue the node up -- any unmade predecessors
+				 * will be dealt with in MakeStartJobs.
+				 */
+				Lst_EnQueue(&toBeMade, pgn);
+			} else if (pgn->unmade < 0) {
+				Error("Graph cycles through %s", pgn->name);
+			}
+		}
 	}
-#else
+
 	/*
-	 * 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 (by which I mean the loose coupling of two clients
-	 * using the same file from a common server), 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.
-	 *
-	 * I have decided it is better to make too much than to make too
-	 * little, so this stuff is commented out unless you're sure it's ok.
-	 * -- ardeb 1/12/88
+	 * Deal with successor nodes. If any is marked for making and has an
+	 * unmade count of 0, has not been made and isn't in the examination
+	 * queue, it means we need to place it in the queue as it restrained
+	 * itself before.
 	 */
+	for (ln = Lst_First(&cgn->successors); ln != NULL; ln = Lst_Succ(ln)) {
+		GNode	*succ = Lst_Datum(ln);
+
+		if (succ->make && succ->unmade == 0 && succ->made == UNMADE &&
+		    Lst_Member(&toBeMade, succ) == NULL) {
+			Lst_EnQueue(&toBeMade, succ);
+		}
+	}
+
 	/*
-	 * Christos, 4/9/92: If we are  saving commands pretend that
-	 * the target is made now. Otherwise archives with ... rules
-	 * don't work!
+	 * Set the .PREFIX and .IMPSRC variables for all the implied parents
+	 * of this node.
 	 */
-	if (noExecute || (cgn->type & OP_SAVE_CMDS) || Dir_MTime(cgn) == 0) {
-	    cgn->mtime = now;
-	}
-	DEBUGF(MAKE, ("update time: %s\n", Targ_FmtTime(cgn->mtime)));
-#endif
-    }
-
-    for (ln = Lst_First(&cgn->parents); ln != NULL; ln = Lst_Succ(ln)) {
-	pgn = Lst_Datum(ln);
-	if (pgn->make) {
-	    pgn->unmade -= 1;
-
-	    if (!(cgn->type & (OP_EXEC | OP_USE))) {
-		if (cgn->made == MADE) {
-		    pgn->childMade = TRUE;
-		    if (pgn->cmtime < cgn->mtime) {
-			pgn->cmtime = cgn->mtime;
-		    }
-		} else {
-		    Make_TimeStamp(pgn, cgn);
+	cpref = Var_Value(PREFIX, cgn, &ptr);
+	for (ln = Lst_First(&cgn->iParents); ln != NULL; ln = Lst_Succ(ln)) {
+		pgn = Lst_Datum(ln);
+		if (pgn->make) {
+			Var_Set(IMPSRC, cname, pgn);
+			Var_Set(PREFIX, cpref, pgn);
 		}
-	    }
-	    if (pgn->unmade == 0) {
-		/*
-		 * Queue the node up -- any unmade predecessors will
-		 * be dealt with in MakeStartJobs.
-		 */
-		Lst_EnQueue(&toBeMade, pgn);
-	    } else if (pgn->unmade < 0) {
-		Error("Graph cycles through %s", pgn->name);
-	    }
-	}
-    }
-
-    /*
-     * Deal with successor nodes. If any is marked for making and has an unmade
-     * count of 0, has not been made and isn't in the examination queue,
-     * it means we need to place it in the queue as it restrained itself
-     * before.
-     */
-    for (ln = Lst_First(&cgn->successors); ln != NULL; ln = Lst_Succ(ln)) {
-	GNode	*succ = Lst_Datum(ln);
-
-	if (succ->make && succ->unmade == 0 && succ->made == UNMADE &&
-	    Lst_Member(&toBeMade, succ) == NULL)
-	{
-	    Lst_EnQueue(&toBeMade, succ);
 	}
-    }
-
-    /*
-     * Set the .PREFIX and .IMPSRC variables for all the implied parents
-     * of this node.
-     */
-    cpref = Var_Value(PREFIX, cgn, &ptr);
-    for (ln = Lst_First(&cgn->iParents); ln != NULL; ln = Lst_Succ(ln)) {
-	pgn = Lst_Datum(ln);
-	if (pgn->make) {
-	    Var_Set(IMPSRC, cname, pgn);
-	    Var_Set(PREFIX, cpref, pgn);
-	}
-    }
-    free(ptr);
+	free(ptr);
 }
 
-/*-
- *-----------------------------------------------------------------------
- * Make_DoAllVar --
+/**
+ * Make_DoAllVar
  *	Set up the ALLSRC and OODATE variables. Sad to say, it must be
  *	done separately, rather than while traversing the graph. This is
  *	because Make defined OODATE to contain all sources whose modification
@@ -485,14 +486,10 @@ Make_Update(GNode *cgn)
  *	variable. As for ALLSRC, the ordering is important and not
  *	guaranteed when in native mode, so it must be set here, too.
  *
- * Results:
- *	None
- *
  * Side Effects:
  *	The ALLSRC and OODATE variables of the given node is filled in.
  *	If the node is a .JOIN node, its TARGET variable will be set to
  * 	match its ALLSRC variable.
- *-----------------------------------------------------------------------
  */
 void
 Make_DoAllVar(GNode *gn)
@@ -573,9 +570,8 @@ Make_DoAllVar(GNode *gn)
 	}
 }
 
-/*-
- *-----------------------------------------------------------------------
- * MakeStartJobs --
+/**
+ * MakeStartJobs
  *	Start as many jobs as possible.
  *
  * Results:
@@ -586,73 +582,75 @@ Make_DoAllVar(GNode *gn)
  * Side Effects:
  *	Nodes are removed from the toBeMade queue and job table slots
  *	are filled.
- *
- *-----------------------------------------------------------------------
  */
 static Boolean
 MakeStartJobs(void)
 {
-    GNode	*gn;
+	GNode	*gn;
 
-    while (!Lst_IsEmpty(&toBeMade) && !Job_Full()) {
-	gn = Lst_DeQueue(&toBeMade);
-	DEBUGF(MAKE, ("Examining %s...", gn->name));
-	/*
-	 * Make sure any and all predecessors that are going to be made,
-	 * have been.
-	 */
-	if (!Lst_IsEmpty(&gn->preds)) {
-	    LstNode *ln;
+	while (!Lst_IsEmpty(&toBeMade) && !Job_Full()) {
+		gn = Lst_DeQueue(&toBeMade);
+		DEBUGF(MAKE, ("Examining %s...", gn->name));
 
-	    for (ln = Lst_First(&gn->preds); ln != NULL; ln = Lst_Succ(ln)){
-		GNode	*pgn = Lst_Datum(ln);
+		/*
+		 * Make sure any and all predecessors that are going to be made,
+		 * have been.
+		 */
+		if (!Lst_IsEmpty(&gn->preds)) {
+			LstNode *ln;
 
-		if (pgn->make && pgn->made == UNMADE) {
-		    DEBUGF(MAKE, ("predecessor %s not made yet.\n", pgn->name));
-		    break;
+			for (ln = Lst_First(&gn->preds); ln != NULL;
+			    ln = Lst_Succ(ln)){
+				GNode	*pgn = Lst_Datum(ln);
+
+				if (pgn->make && pgn->made == UNMADE) {
+					DEBUGF(MAKE, ("predecessor %s not made "
+					    "yet.\n", pgn->name));
+					break;
+				}
+			}
+			/*
+			 * If ln isn't NULL, there's a predecessor as yet
+			 * unmade, so we just drop this node on the floor.
+			 * When the node in question has been made, it will
+			 * notice this node as being ready to make but as yet
+			 * unmade and will place the node on the queue.
+			 */
+			if (ln != NULL) {
+				continue;
+			}
 		}
-	    }
-	    /*
-	     * If ln isn't NULL, there's a predecessor as yet unmade, so we
-	     * just drop this node on the floor. When the node in question
-	     * has been made, it will notice this node as being ready to
-	     * make but as yet unmade and will place the node on the queue.
-	     */
-	    if (ln != NULL) {
-		continue;
-	    }
-	}
 
-	numNodes--;
-	if (Make_OODate(gn)) {
-	    DEBUGF(MAKE, ("out-of-date\n"));
-	    if (queryFlag) {
-		return (TRUE);
-	    }
-	    Make_DoAllVar(gn);
-	    Job_Make(gn);
-	} else {
-	    DEBUGF(MAKE, ("up-to-date\n"));
-	    gn->made = UPTODATE;
-	    if (gn->type & OP_JOIN) {
-		/*
-		 * Even for an up-to-date .JOIN node, we need it to have its
-		 * context variables so references to it get the correct
-		 * value for .TARGET when building up the context variables
-		 * of its parent(s)...
-		 */
-		Make_DoAllVar(gn);
-	    }
+		numNodes--;
+		if (Make_OODate(gn)) {
+			DEBUGF(MAKE, ("out-of-date\n"));
+			if (queryFlag) {
+				return (TRUE);
+			}
+			Make_DoAllVar(gn);
+			Job_Make(gn);
+		} else {
+			DEBUGF(MAKE, ("up-to-date\n"));
+			gn->made = UPTODATE;
+			if (gn->type & OP_JOIN) {
+				/*
+				 * Even for an up-to-date .JOIN node, we need
+				 * it to have its context variables so
+				 * references to it get the correct value for
+				 * .TARGET when building up the context
+				 * variables of its parent(s)...
+				 */
+				Make_DoAllVar(gn);
+			}
 
-	    Make_Update(gn);
+			Make_Update(gn);
+		}
 	}
-    }
-    return (FALSE);
+	return (FALSE);
 }
 
-/*-
- *-----------------------------------------------------------------------
- * MakePrintStatus --
+/**
+ * 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
@@ -661,48 +659,47 @@ MakeStartJobs(void)
  *
  * Side Effects:
  *	A message may be printed.
- *
- *-----------------------------------------------------------------------
  */
 static void
 MakePrintStatus(GNode *gn, Boolean cycle)
 {
-    LstNode *ln;
-
-    if (gn->made == UPTODATE) {
-	printf("`%s' is up to date.\n", gn->name);
-    } else if (gn->unmade != 0) {
-	if (cycle) {
-	    /*
-	     * If printing cycles and came to one that has unmade children,
-	     * print out the cycle by recursing on its children. Note a
-	     * cycle like:
-	     *	a : b
-	     *	b : c
-	     *	c : b
-	     * will cause this to erroneously complain about a being in
-	     * the cycle, but this is a good approximation.
-	     */
-	    if (gn->made == CYCLE) {
-		Error("Graph cycles through `%s'", gn->name);
-		gn->made = ENDCYCLE;
-		LST_FOREACH(ln, &gn->children)
-		    MakePrintStatus(Lst_Datum(ln), TRUE);
-		gn->made = UNMADE;
-	    } else if (gn->made != ENDCYCLE) {
-		gn->made = CYCLE;
-		LST_FOREACH(ln, &gn->children)
-		    MakePrintStatus(Lst_Datum(ln), TRUE);
-	    }
-	} else {
-	    printf("`%s' not remade because of errors.\n", gn->name);
+	LstNode	*ln;
+
+	if (gn->made == UPTODATE) {
+		printf("`%s' is up to date.\n", gn->name);
+
+	} else if (gn->unmade != 0) {
+		if (cycle) {
+			/*
+			 * If printing cycles and came to one that has unmade
+			 * children, print out the cycle by recursing on its
+			 * children. Note a cycle like:
+			 *	a : b
+			 *	b : c
+			 *	c : b
+			 * will cause this to erroneously complain about a
+			 * being in the cycle, but this is a good approximation.
+			 */
+			if (gn->made == CYCLE) {
+				Error("Graph cycles through `%s'", gn->name);
+				gn->made = ENDCYCLE;
+				LST_FOREACH(ln, &gn->children)
+					MakePrintStatus(Lst_Datum(ln), TRUE);
+				gn->made = UNMADE;
+			} else if (gn->made != ENDCYCLE) {
+				gn->made = CYCLE;
+				LST_FOREACH(ln, &gn->children)
+					MakePrintStatus(Lst_Datum(ln), TRUE);
+			}
+		} else {
+			printf("`%s' not remade because of errors.\n",
+			    gn->name);
+		}
 	}
-    }
 }
 
-/*-
- *-----------------------------------------------------------------------
- * Make_Run --
+/**
+ * Make_Run
  *	Initialize the nodes to remake and the list of nodes which are
  *	ready to be made by doing a breadth-first traversal of the graph
  *	starting from the nodes in the given list. Once this traversal
@@ -719,101 +716,102 @@ MakePrintStatus(GNode *gn, Boolean cycle)
  *	The make field of all nodes involved in the creation of the given
  *	targets is set to 1. The toBeMade list is set to contain all the
  *	'leaves' of these subgraphs.
- *-----------------------------------------------------------------------
  */
 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);
-    numNodes = 0;
-
-    /*
-     * Make an initial downward pass over the graph, marking nodes to be made
-     * as we go down. We call Suff_FindDeps to find where a node is and
-     * to get some children for it if it has none and also has no commands.
-     * If the node is a leaf, we stick it on the toBeMade queue to
-     * be looked at in a minute, otherwise we add its children to our queue
-     * and go on about our business.
-     */
-    while (!Lst_IsEmpty(&examine)) {
-	gn = Lst_DeQueue(&examine);
-
-	if (!gn->make) {
-	    gn->make = TRUE;
-	    numNodes++;
-
-	    /*
-	     * Apply any .USE rules before looking for implicit dependencies
-	     * to make sure everything has commands that should...
-	     */
-	    LST_FOREACH(ln, &gn->children)
-		if (Make_HandleUse(Lst_Datum(ln), gn))
-		    break;
-
-	    Suff_FindDeps(gn);
-
-	    if (gn->unmade != 0) {
-		LST_FOREACH(ln, &gn->children) {
-		    cgn = Lst_Datum(ln);
-		    if (!cgn->make && !(cgn->type & OP_USE))
-			Lst_EnQueue(&examine, cgn);
+	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);
+	numNodes = 0;
+
+	/*
+	 * Make an initial downward pass over the graph, marking nodes to be
+	 * made as we go down. We call Suff_FindDeps to find where a node is and
+	 * to get some children for it if it has none and also has no commands.
+	 * If the node is a leaf, we stick it on the toBeMade queue to
+	 * be looked at in a minute, otherwise we add its children to our queue
+	 * and go on about our business.
+	 */
+	while (!Lst_IsEmpty(&examine)) {
+		gn = Lst_DeQueue(&examine);
+
+		if (!gn->make) {
+			gn->make = TRUE;
+			numNodes++;
+
+			/*
+			 * Apply any .USE rules before looking for implicit
+			 * dependencies to make sure everything has commands
+			 * that should...
+			 */
+			LST_FOREACH(ln, &gn->children)
+				if (Make_HandleUse(Lst_Datum(ln), gn))
+					break;
+
+			Suff_FindDeps(gn);
+
+			if (gn->unmade != 0) {
+				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);
+			}
 		}
-	    } else {
-		Lst_EnQueue(&toBeMade, gn);
-	    }
 	}
-    }
 
-    if (queryFlag) {
+	if (queryFlag) {
+		/*
+		 * We wouldn't do any work unless we could start some jobs in
+		 * the next loop... (we won't actually start any, of course,
+		 * this is just to see if any of the targets was out of date)
+		 */
+		return (MakeStartJobs());
+
+	} else {
+		/*
+		 * Initialization. At the moment, no jobs are running and
+		 * until some get started, nothing will happen since the
+		 * remaining upward traversal of the graph is performed by the
+		 * routines in job.c upon the finishing of a job. So we fill
+		 * the Job table as much as we can before going into our loop.
+		 */
+		MakeStartJobs();
+	}
+
 	/*
-	 * We wouldn't do any work unless we could start some jobs in the
-	 * next loop... (we won't actually start any, of course, this is just
-	 * to see if any of the targets was out of date)
+	 * Main Loop: The idea here is that the ending of jobs will take
+	 * care of the maintenance of data structures and the waiting for output
+	 * will cause us to be idle most of the time while our children run as
+	 * much as possible. Because the job table is kept as full as possible,
+	 * the only time when it will be empty is when all the jobs which need
+	 * running have been run, so that is the end condition of this loop.
+	 * Note that the Job module will exit if there were any errors unless
+	 * the keepgoing flag was given.
 	 */
-	return (MakeStartJobs());
-    } else {
+	while (!Job_Empty()) {
+		Job_CatchOutput(!Lst_IsEmpty(&toBeMade));
+		Job_CatchChildren(!usePipes);
+		MakeStartJobs();
+	}
+
+	errors = Job_Finish();
+
 	/*
-	 * Initialization. At the moment, no jobs are running and until some
-	 * get started, nothing will happen since the remaining upward
-	 * traversal of the graph is performed by the routines in job.c upon
-	 * the finishing of a job. So we fill the Job table as much as we can
-	 * before going into our loop.
+	 * Print the final status of each target. E.g. if it wasn't made
+	 * because some inferior reported an error.
 	 */
-	 MakeStartJobs();
-    }
-
-    /*
-     * Main Loop: The idea here is that the ending of jobs will take
-     * care of the maintenance of data structures and the waiting for output
-     * will cause us to be idle most of the time while our children run as
-     * much as possible. Because the job table is kept as full as possible,
-     * the only time when it will be empty is when all the jobs which need
-     * running have been run, so that is the end condition of this loop.
-     * Note that the Job module will exit if there were any errors unless the
-     * keepgoing flag was given.
-     */
-    while (!Job_Empty ()) {
-	Job_CatchOutput(!Lst_IsEmpty(&toBeMade));
-	Job_CatchChildren(!usePipes);
-	MakeStartJobs();
-    }
-
-    errors = Job_Finish();
-
-    /*
-     * Print the final status of each target. E.g. if it wasn't made
-     * because some inferior reported an error.
-     */
-    errors = ((errors == 0) && (numNodes != 0));
-    LST_FOREACH(ln, targs)
-	MakePrintStatus(Lst_Datum(ln), errors);
-
-    return (TRUE);
+	errors = ((errors == 0) && (numNodes != 0));
+	LST_FOREACH(ln, targs)
+		MakePrintStatus(Lst_Datum(ln), errors);
+
+	return (TRUE);
 }