 @@ -1,582 +1,582 @@
-/*	$NetBSD: make.h,v 1.128 2020/08/28 03:35:45 rillig Exp $	*/
+/*	$NetBSD: make.h,v 1.129 2020/08/28 19:14:07 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	from: @(#)make.h	8.3 (Berkeley) 6/13/95
  */
 /*
  * Copyright (c) 1989 by Berkeley Softworks
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by the University of
  *	California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
+ *
  *	from: @(#)make.h	8.3 (Berkeley) 6/13/95
  */
 /*-
  * make.h --
  *	The global definitions for pmake
  */
 #ifndef MAKE_MAKE_H
 #define MAKE_MAKE_H
 #include <sys/types.h>
 #include <sys/param.h>
 #include <assert.h>
 #include <ctype.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #ifdef BSD4_4
 # include <sys/cdefs.h>
 #endif
 #ifndef FD_CLOEXEC
 #define FD_CLOEXEC 1
 #endif
 #if defined(__GNUC__)
 #define	MAKE_GNUC_PREREQ(x, y)						\
 	((__GNUC__ == (x) && __GNUC_MINOR__ >= (y)) ||			\
 	 (__GNUC__ > (x)))
 #else /* defined(__GNUC__) */
 #define	MAKE_GNUC_PREREQ(x, y)	0
 #endif /* defined(__GNUC__) */
 #if MAKE_GNUC_PREREQ(2, 7)
 #define	MAKE_ATTR_UNUSED	__attribute__((__unused__))
 #else
 #define	MAKE_ATTR_UNUSED	/* delete */
 #endif
 #if MAKE_GNUC_PREREQ(2, 5)
 #define	MAKE_ATTR_DEAD		__attribute__((__noreturn__))
 #elif defined(__GNUC__)
 #define	MAKE_ATTR_DEAD		__volatile
 #else
 #define	MAKE_ATTR_DEAD		/* delete */
 #endif
 #if MAKE_GNUC_PREREQ(2, 7)
 #define MAKE_ATTR_PRINTFLIKE(fmtarg, firstvararg)	\
 	    __attribute__((__format__ (__printf__, fmtarg, firstvararg)))
 #else
 #define MAKE_ATTR_PRINTFLIKE(fmtarg, firstvararg)	/* delete */
 #endif
 /*
  * A boolean type is defined as an integer, not an enum. This allows a
  * boolean argument to be an expression that isn't strictly 0 or 1 valued.
  */
 typedef int Boolean;
 #ifndef TRUE
 #define TRUE	1
 #endif /* TRUE */
 #ifndef FALSE
 #define FALSE	0
 #endif /* FALSE */
 /*
  * Functions that must return a status can return a ReturnStatus to
  * indicate success or type of failure.
  */
 typedef int  ReturnStatus;
 /*
  * The following statuses overlap with the first 2 generic statuses
  * defined in status.h:
+ *
  * SUCCESS			There was no error.
  * FAILURE			There was a general error.
  */
 #define	SUCCESS			0x00000000
 #define	FAILURE			0x00000001
 #include "lst.h"
 #include "enum.h"
 #include "hash.h"
 #include "config.h"
 #include "buf.h"
 #include "make_malloc.h"
 typedef enum  {
     UNMADE,			/* Not examined yet */
     DEFERRED,			/* Examined once (building child) */
     REQUESTED,			/* on toBeMade list */
     BEINGMADE,			/* Target is already being made.
 				 * Indicates a cycle in the graph. */
     MADE,			/* Was out-of-date and has been made */
     UPTODATE,			/* Was already up-to-date */
     ERROR,			/* An error occurred while it was being
 				 * made (used only in compat mode) */
     ABORTED			/* The target was aborted due to an error
 				 * making an inferior (compat). */
 } GNodeMade;
 /* The OP_ constants are used when parsing a dependency line as a way of
  * communicating to other parts of the program the way in which a target
  * should be made.
+ *
  * These constants are bitwise-OR'ed together and placed in the 'type' field
  * of each node. Any node that has a 'type' field which satisfies the OP_NOP
  * function was never never on the left-hand side of an operator, though it
  * may have been on the right-hand side... */
 typedef enum {
     /* Execution of commands depends on children (:) */
     OP_DEPENDS		= 1 << 0,
     /* Always execute commands (!) */
     OP_FORCE		= 1 << 1,
     /* Execution of commands depends on children per line (::) */
     OP_DOUBLEDEP	= 1 << 2,
     OP_OPMASK		= OP_DEPENDS|OP_FORCE|OP_DOUBLEDEP,
     /* Don't care if the target doesn't exist and can't be created */
     OP_OPTIONAL		= 1 << 3,
     /* Use associated commands for parents */
     OP_USE		= 1 << 4,
     /* Target is never out of date, but always execute commands anyway.
      * Its time doesn't matter, so it has none...sort of */
     OP_EXEC	  	= 1 << 5,
     /* Ignore errors when creating the node */
     OP_IGNORE		= 1 << 6,
     /* Don't remove the target when interrupted */
     OP_PRECIOUS		= 1 << 7,
     /* Don't echo commands when executed */
     OP_SILENT		= 1 << 8,
     /* Target is a recursive make so its commands should always be executed
      * when it is out of date, regardless of the state of the -n or -t flags */
     OP_MAKE		= 1 << 9,
     /* Target is out-of-date only if any of its children was out-of-date */
     OP_JOIN		= 1 << 10,
     /* Assume the children of the node have been already made */
     OP_MADE		= 1 << 11,
     /* Special .BEGIN, .END, .INTERRUPT */
     OP_SPECIAL		= 1 << 12,
     /* Like .USE, only prepend commands */
     OP_USEBEFORE	= 1 << 13,
     /* The node is invisible to its parents. I.e. it doesn't show up in the
      * parents' local variables. */
     OP_INVISIBLE	= 1 << 14,
     /* The node is exempt from normal 'main target' processing in parse.c */
     OP_NOTMAIN		= 1 << 15,
     /* Not a file target; run always */
     OP_PHONY		= 1 << 16,
     /* Don't search for file in the path */
     OP_NOPATH		= 1 << 17,
     /* .WAIT phony node */
     OP_WAIT		= 1 << 18,
     /* .NOMETA do not create a .meta file */
     OP_NOMETA		= 1 << 19,
     /* .META we _do_ want a .meta file */
     OP_META		= 1 << 20,
     /* Do not compare commands in .meta file */
     OP_NOMETA_CMP	= 1 << 21,
     /* Possibly a submake node */
     OP_SUBMAKE		= 1 << 22,
     /* Attributes applied by PMake */
     /* The node is a transformation rule */
     OP_TRANSFORM	= 1 << 31,
     /* Target is a member of an archive */
     OP_MEMBER		= 1 << 30,
     /* Target is a library */
     OP_LIB		= 1 << 29,
     /* Target is an archive construct */
     OP_ARCHV		= 1 << 28,
     /* Target has all the commands it should. Used when parsing to catch
      * multiple commands for a target. */
     OP_HAS_COMMANDS	= 1 << 27,
     /* Saving commands on .END (Compat) */
     OP_SAVE_CMDS	= 1 << 26,
     /* Already processed by Suff_FindDeps */
     OP_DEPS_FOUND	= 1 << 25,
     /* Node found while expanding .ALLSRC */
     OP_MARK		= 1 << 24
 } GNodeType;
 typedef enum {
     REMAKE	= 0x0001,	/* this target needs to be (re)made */
     CHILDMADE	= 0x0002,	/* children of this target were made */
     FORCE	= 0x0004,	/* children don't exist, and we pretend made */
     DONE_WAIT	= 0x0008,	/* Set by Make_ProcessWait() */
     DONE_ORDER	= 0x0010,	/* Build requested by .ORDER processing */
     FROM_DEPEND	= 0x0020,	/* Node created from .depend */
     DONE_ALLSRC	= 0x0040,	/* We do it once only */
     CYCLE	= 0x1000,	/* Used by MakePrintStatus */
     DONECYCLE	= 0x2000,	/* Used by MakePrintStatus */
     INTERNAL	= 0x4000	/* Internal use only */
 } GNodeFlags;
 /* A graph node represents a target that can possibly be made, including its
  * relation to other targets and a lot of other details. */
 typedef struct GNode {
     /* The target's name, such as "clean" or "make.c" */
     char *name;
     /* The unexpanded name of a .USE node */
     char *uname;
     /* The full pathname of the file belonging to the target.
      * XXX: What about .PHONY targets? These don't have an associated path. */
     char *path;
     /* The type of operator used to define the sources (see the OP flags below).
      * XXX: This looks like a wild mixture of type and flags. */
     GNodeType type;
     /* whether it is involved in this invocation of make */
     GNodeFlags flags;
     /* The state of processing on this node */
     GNodeMade made;
     int unmade;			/* The number of unmade children */
     time_t mtime;		/* Its modification time */
     struct GNode *cmgn;		/* The youngest child */
     /* Links to parents for which this is an implied source. May be empty.
      * Nodes that depend on this, as gleaned from the transformation rules. */
     Lst iParents;
     /* Other nodes of the same name for the :: operator. */
     Lst cohorts;
     /* The nodes that depend on this one, or in other words, the nodes for
      * which this is a source. */
     Lst parents;
     /* The nodes on which this one depends. */
     Lst children;
     /* .ORDER nodes we need made. The nodes that must be made (if they're
      * made) before this node can be made, but that do not enter into the
      * datedness of this node. */
     Lst order_pred;
     /* .ORDER nodes who need us. The nodes that must be made (if they're made
      * at all) after this node is made, but that do not depend on this node,
      * in the normal sense. */
     Lst order_succ;
     /* #n for this cohort */
     char cohort_num[8];
     /* The number of unmade instances on the cohorts list */
     int unmade_cohorts;
-    /* Pointer to the first instance of a :: node; only set when on a cohorts
+    /* Pointer to the first instance of a '::' node; only set when on a
-     * list */
+     * cohorts list */
     struct GNode *centurion;
     /* Last time (sequence number) we tried to make this node */
     unsigned int checked;
     /* The "local" variables that are specific to this target and this target
      * only, such as $@, $<, $?. */
     Hash_Table context;
     /* The commands to be given to a shell to create this target. */
     Lst commands;
     /* Suffix for the node (determined by Suff_FindDeps and opaque to everyone
      * but the Suff module) */
     struct Suff *suffix;
     /* filename where the GNode got defined */
     const char *fname;
     /* line number where the GNode got defined */
     int lineno;
 } GNode;
 #define NoExecute(gn) ((gn->type & OP_MAKE) ? noRecursiveExecute : noExecute)
 /*
  * OP_NOP will return TRUE if the node with the given type was not the
  * object of a dependency operator
  */
 #define OP_NOP(t)	(((t) & OP_OPMASK) == 0x00000000)
 #define OP_NOTARGET (OP_NOTMAIN|OP_USE|OP_EXEC|OP_TRANSFORM)
 /*
  * The TARG_ constants are used when calling the Targ_FindNode and
  * Targ_FindList functions in targ.c. They simply tell the functions what to
  * do if the desired node(s) is (are) not found. If the TARG_CREATE constant
  * is given, a new, empty node will be created for the target, placed in the
  * table of all targets and its address returned. If TARG_NOCREATE is given,
  * a NULL pointer will be returned.
  */
 #define TARG_NOCREATE	0x00	  /* don't create it */
 #define TARG_CREATE	0x01	  /* create node if not found */
 #define TARG_NOHASH	0x02	  /* don't look in/add to hash table */
 /*
  * Error levels for parsing. PARSE_FATAL means the process cannot continue
  * once the makefile has been parsed. PARSE_WARNING means it can. Passed
  * as the first argument to Parse_Error.
  */
 #define PARSE_INFO	3
 #define PARSE_WARNING	2
 #define PARSE_FATAL	1
 /*
  * Values returned by Cond_Eval.
  */
 typedef enum {
     COND_PARSE,			/* Parse the next lines */
     COND_SKIP,			/* Skip the next lines */
     COND_INVALID		/* Not a conditional statement */
 } CondEvalResult;
 /*
  * Definitions for the "local" variables. Used only for clarity.
  */
 #define TARGET	  	  "@" 	/* Target of dependency */
 #define OODATE	  	  "?" 	/* All out-of-date sources */
 #define ALLSRC	  	  ">" 	/* All sources */
 #define IMPSRC	  	  "<" 	/* Source implied by transformation */
 #define PREFIX	  	  "*" 	/* Common prefix */
 #define ARCHIVE	  	  "!" 	/* Archive in "archive(member)" syntax */
 #define MEMBER	  	  "%" 	/* Member in "archive(member)" syntax */
 #define FTARGET           "@F"  /* file part of TARGET */
 #define DTARGET           "@D"  /* directory part of TARGET */
 #define FIMPSRC           "<F"  /* file part of IMPSRC */
 #define DIMPSRC           "<D"  /* directory part of IMPSRC */
 #define FPREFIX           "*F"  /* file part of PREFIX */
 #define DPREFIX           "*D"  /* directory part of PREFIX */
 /*
  * Global Variables
  */
 extern Lst  	create;	    	/* The list of target names specified on the
 				 * command line. used to resolve #if
 				 * make(...) statements */
 extern Lst     	dirSearchPath; 	/* The list of directories to search when
 				 * looking for targets */
 extern Boolean	compatMake;	/* True if we are make compatible */
 extern Boolean	ignoreErrors;  	/* True if should ignore all errors */
 extern Boolean  beSilent;    	/* True if should print no commands */
 extern Boolean  noExecute;    	/* True if should execute nothing */
 extern Boolean  noRecursiveExecute;    	/* True if should execute nothing */
 extern Boolean  allPrecious;   	/* True if every target is precious */
 extern Boolean  deleteOnError;	/* True if failed targets should be deleted */
 extern Boolean  keepgoing;    	/* True if should continue on unaffected
 				 * portions of the graph when have an error
 				 * in one portion */
 extern Boolean 	touchFlag;    	/* TRUE if targets should just be 'touched'
 				 * if out of date. Set by the -t flag */
 extern Boolean 	queryFlag;    	/* TRUE if we aren't supposed to really make
 				 * anything, just see if the targets are out-
 				 * of-date */
 extern Boolean	doing_depend;	/* TRUE if processing .depend */
 extern Boolean	checkEnvFirst;	/* TRUE if environment should be searched for
 				 * variables before the global context */
 extern Boolean	parseWarnFatal;	/* TRUE if makefile parsing warnings are
 				 * treated as errors */
 extern Boolean	varNoExportEnv;	/* TRUE if we should not export variables
 				 * set on the command line to the env. */
 extern GNode    *DEFAULT;    	/* .DEFAULT rule */
 extern GNode	*VAR_INTERNAL;	/* Variables defined internally by make
 				 * which should not override those set by
 				 * makefiles.
 				 */
 extern GNode    *VAR_GLOBAL;   	/* Variables defined in a global context, e.g
 				 * in the Makefile itself */
 extern GNode    *VAR_CMD;    	/* Variables defined on the command line */
 extern char    	var_Error[];   	/* Value returned by Var_Parse when an error
 				 * is encountered. It actually points to
 				 * an empty string, so naive callers needn't
 				 * worry about it. */
 extern time_t 	now;	    	/* The time at the start of this whole
 				 * process */
 extern Boolean	oldVars;    	/* Do old-style variable substitution */
 extern Lst	sysIncPath;	/* The system include path. */
 extern Lst	defIncPath;	/* The default include path. */
 extern char	curdir[];	/* Startup directory */
 extern char	*progname;	/* The program name */
 extern char	*makeDependfile; /* .depend */
 extern char	**savedEnv;	 /* if we replaced environ this will be non-NULL */
 extern int	makelevel;
 /*
  * We cannot vfork() in a child of vfork().
  * Most systems do not enforce this but some do.
  */
 #define vFork() ((getpid() == myPid) ? vfork() : fork())
 extern pid_t	myPid;
 #define	MAKEFLAGS	".MAKEFLAGS"
 #define	MAKEOVERRIDES	".MAKEOVERRIDES"
 #define	MAKE_JOB_PREFIX	".MAKE.JOB.PREFIX" /* prefix for job target output */
 #define	MAKE_EXPORTED	".MAKE.EXPORTED"   /* variables we export */
 #define	MAKE_MAKEFILES	".MAKE.MAKEFILES"  /* all the makefiles we read */
 #define	MAKE_LEVEL	".MAKE.LEVEL"	   /* recursion level */
 #define MAKEFILE_PREFERENCE ".MAKE.MAKEFILE_PREFERENCE"
 #define MAKE_DEPENDFILE	".MAKE.DEPENDFILE" /* .depend */
 #define MAKE_MODE	".MAKE.MODE"
 #ifndef MAKE_LEVEL_ENV
 # define MAKE_LEVEL_ENV	"MAKELEVEL"
 #endif
 /*
  * debug control:
  *	There is one bit per module.  It is up to the module what debug
  *	information to print.
  */
 extern FILE *debug_file;	/* Output is written here - default stderr */
 extern int debug;
 #define	DEBUG_ARCH	0x00001
 #define	DEBUG_COND	0x00002
 #define	DEBUG_DIR	0x00004
 #define	DEBUG_GRAPH1	0x00008
 #define	DEBUG_GRAPH2	0x00010
 #define	DEBUG_JOB	0x00020
 #define	DEBUG_MAKE	0x00040
 #define	DEBUG_SUFF	0x00080
 #define	DEBUG_TARG	0x00100
 #define	DEBUG_VAR	0x00200
 #define DEBUG_FOR	0x00400
 #define DEBUG_SHELL	0x00800
 #define DEBUG_ERROR	0x01000
 #define DEBUG_LOUD	0x02000
 #define DEBUG_META	0x04000
 #define DEBUG_HASH	0x08000
 #define DEBUG_GRAPH3	0x10000
 #define DEBUG_SCRIPT	0x20000
 #define DEBUG_PARSE	0x40000
 #define DEBUG_CWD	0x80000
 #define DEBUG_LINT	0x100000
 #define CONCAT(a,b)	a##b
 #define	DEBUG(module)	(debug & CONCAT(DEBUG_,module))
 #include "nonints.h"
 int Make_TimeStamp(GNode *, GNode *);
 Boolean Make_OODate(GNode *);
 void Make_ExpandUse(Lst);
 time_t Make_Recheck(GNode *);
 void Make_HandleUse(GNode *, GNode *);
 void Make_Update(GNode *);
 void Make_DoAllVar(GNode *);
 Boolean Make_Run(Lst);
 int dieQuietly(GNode *, int);
 void PrintOnError(GNode *, const char *);
 void Main_ExportMAKEFLAGS(Boolean);
 Boolean Main_SetObjdir(const char *, ...) MAKE_ATTR_PRINTFLIKE(1, 2);
 int mkTempFile(const char *, char **);
 int str2Lst_Append(Lst, char *, const char *);
 int cached_lstat(const char *, void *);
 int cached_stat(const char *, void *);
 void GNode_FprintDetails(FILE *, const char *, const GNode *, const char *);
 #ifdef __GNUC__
 #define UNCONST(ptr)	({ 		\
     union __unconst {			\
 	const void *__cp;		\
 	void *__p;			\
     } __d;				\
     __d.__cp = ptr, __d.__p; })
 #else
 #define UNCONST(ptr)	(void *)(ptr)
 #endif
 #ifndef MIN
 #define MIN(a, b) ((a < b) ? a : b)
 #endif
 #ifndef MAX
 #define MAX(a, b) ((a > b) ? a : b)
 #endif
 /* At least GNU/Hurd systems lack hardcoded MAXPATHLEN/PATH_MAX */
 #include <limits.h>
 #ifndef MAXPATHLEN
 #define MAXPATHLEN	4096
 #endif
 #ifndef PATH_MAX
 #define PATH_MAX	MAXPATHLEN
 #endif
 #if defined(SYSV)
 #define KILLPG(pid, sig)	kill(-(pid), (sig))
 #else
 #define KILLPG(pid, sig)	killpg((pid), (sig))
 #endif
 #endif /* MAKE_MAKE_H */

 @@ -1,851 +1,632 @@
-/*	$NetBSD: targ.c,v 1.76 2020/08/28 04:48:57 rillig Exp $	*/
+/*	$NetBSD: targ.c,v 1.77 2020/08/28 19:14:07 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 /*
  * Copyright (c) 1989 by Berkeley Softworks
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by the University of
  *	California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: targ.c,v 1.76 2020/08/28 04:48:57 rillig Exp $";
+static char rcsid[] = "$NetBSD: targ.c,v 1.77 2020/08/28 19:14:07 rillig Exp $";
 #else
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)targ.c	8.2 (Berkeley) 3/19/94";
 #else
-__RCSID("$NetBSD: targ.c,v 1.76 2020/08/28 04:48:57 rillig Exp $");
+__RCSID("$NetBSD: targ.c,v 1.77 2020/08/28 19:14:07 rillig Exp $");
 #endif
 #endif /* not lint */
 #endif
 /*-
  * targ.c --
  *	Functions for maintaining the Lst allTargets. Target nodes are
- * kept in two structures: a Lst, maintained by the list library, and a
+ *	kept in two structures: a Lst and a hash table.
  * hash table, maintained by the hash library.
+ *
  * Interface:
  *	Targ_Init 	    	Initialization procedure.
+ *
  *	Targ_End 	    	Cleanup the module
+ *
  *	Targ_List 	    	Return the list of all targets so far.
+ *
  *	Targ_NewGN	    	Create a new GNode for the passed target
  *	    	  	    	(string). The node is *not* placed in the
  *	    	  	    	hash table, though all its fields are
  *	    	  	    	initialized.
+ *
  *	Targ_FindNode	    	Find the node for a given target, creating
  *	    	  	    	and storing it if it doesn't exist and the
  *	    	  	    	flags are right (TARG_CREATE)
+ *
  *	Targ_FindList	    	Given a list of names, find nodes for all
  *	    	  	    	of them. If a name doesn't exist and the
  *	    	  	    	TARG_NOCREATE flag was given, an error message
  *	    	  	    	is printed. Else, if a name doesn't exist,
  *	    	  	    	its node is created.
+ *
  *	Targ_Ignore	    	Return TRUE if errors should be ignored when
  *	    	  	    	creating the given target.
+ *
  *	Targ_Silent	    	Return TRUE if we should be silent when
  *	    	  	    	creating the given target.
+ *
  *	Targ_Precious	    	Return TRUE if the target is precious and
  *	    	  	    	should not be removed if we are interrupted.
+ *
  *	Targ_Propagate		Propagate information between related
  *				nodes.	Should be called after the
  *				makefiles are parsed but before any
  *				action is taken.
+ *
  * Debugging:
  *	Targ_PrintGraph	    	Print out the entire graphm all variables
  *	    	  	    	and statistics for the directory cache. Should
  *	    	  	    	print something for suffixes, too, but...
  */
 #include	  <stdio.h>
 #include	  <time.h>
 #include	  "make.h"
 #include	  "hash.h"
 #include	  "dir.h"
 static Lst        allTargets;	/* the list of all targets found so far */
 #ifdef CLEANUP
 static Lst	  allGNs;	/* List of all the GNodes */
 #endif
 static Hash_Table targets;	/* a hash table of same */
 #define HTSIZE	191		/* initial size of hash table */
 static int TargPrintOnlySrc(void *, void *);
 static int TargPrintName(void *, void *);
 #ifdef CLEANUP
 static void TargFreeGN(void *);
 #endif
 static int TargPropagateCohort(void *, void *);
 static int TargPropagateNode(void *, void *);
 /*-
  *-----------------------------------------------------------------------
  * Targ_Init --
  *	Initialize this module
  * Results:
  *	None
  * Side Effects:
  *	The allTargets list and the targets hash table are initialized
  *-----------------------------------------------------------------------
  */
 void
 Targ_Init(void)
+{
     allTargets = Lst_Init();
     Hash_InitTable(&targets, HTSIZE);
+}
 /*-
  *-----------------------------------------------------------------------
  * Targ_End --
  *	Finalize this module
  * Results:
  *	None
  * Side Effects:
  *	All lists and gnodes are cleared
  *-----------------------------------------------------------------------
  */
 void
 Targ_End(void)
+{
     Targ_Stats();
 #ifdef CLEANUP
     Lst_Free(allTargets);
     if (allGNs != NULL)
 	Lst_Destroy(allGNs, TargFreeGN);
     Hash_DeleteTable(&targets);
 #endif
+}
 void
 Targ_Stats(void)
+{
     Hash_DebugStats(&targets, "targets");
+}
-/*-
+/* Return the list of all targets. */
  *-----------------------------------------------------------------------
  * Targ_List --
  *	Return the list of all targets
  * Results:
  *	The list of all targets.
  * Side Effects:
  *	None
  *-----------------------------------------------------------------------
  */
 Lst
 Targ_List(void)
+{
     return allTargets;
+}
-/*-
+/* Create and initialize a new graph node. The gnode is added to the list of
- *-----------------------------------------------------------------------
+ * all gnodes.
  * Targ_NewGN  --
  *	Create and initialize a new graph node
+ *
  * Input:
- *	name		the name to stick in the new node
+ *	name		the name of the node, such as "clean", "src.c"
  * Results:
  *	An initialized graph node with the name field filled with a copy
  *	of the passed name
  * Side Effects:
  *	The gnode is added to the list of all gnodes.
  *-----------------------------------------------------------------------
  */
 GNode *
 Targ_NewGN(const char *name)
+{
     GNode *gn;
     gn = bmake_malloc(sizeof(GNode));
     gn->name = bmake_strdup(name);
     gn->uname = NULL;
     gn->path = NULL;
-    if (name[0] == '-' && name[1] == 'l') {
+    gn->type = name[0] == '-' && name[1] == 'l' ? OP_LIB : 0;
 	gn->type = OP_LIB;
     } else {
 	gn->type = 0;
     gn->unmade =    	0;
     gn->unmade_cohorts = 0;
     gn->cohort_num[0] = 0;
     gn->centurion =    	NULL;
     gn->made = 	    	UNMADE;
     gn->flags = 	0;
     gn->checked =	0;
     gn->mtime =		0;
     gn->cmgn =		NULL;
     gn->iParents =  	Lst_Init();
     gn->cohorts =   	Lst_Init();
     gn->parents =   	Lst_Init();
     gn->children =  	Lst_Init();
     gn->order_pred =  	Lst_Init();
     gn->order_succ =  	Lst_Init();
     Hash_InitTable(&gn->context, 0);
     gn->commands =  	Lst_Init();
     gn->suffix =	NULL;
     gn->lineno =	0;
     gn->fname = 	NULL;
     gn->lineno =	0;
 #ifdef CLEANUP
     if (allGNs == NULL)
 	allGNs = Lst_Init();
     Lst_Append(allGNs, gn);
 #endif
     return gn;
+}
 #ifdef CLEANUP
 /*-
  *-----------------------------------------------------------------------
  * TargFreeGN  --
  *	Destroy a GNode
  * Results:
  *	None.
  * Side Effects:
  *	None.
  *-----------------------------------------------------------------------
  */
 static void
 TargFreeGN(void *gnp)
+{
     GNode *gn = (GNode *)gnp;
     free(gn->name);
     free(gn->uname);
     free(gn->path);
     /* gn->fname points to name allocated when file was opened, don't free */
     Lst_Free(gn->iParents);
     Lst_Free(gn->cohorts);
     Lst_Free(gn->parents);
     Lst_Free(gn->children);
     Lst_Free(gn->order_succ);
     Lst_Free(gn->order_pred);
     Hash_DeleteTable(&gn->context);
     Lst_Free(gn->commands);
     /* XXX: does gn->suffix need to be freed? It is reference-counted. */
     /* gn->fname points to name allocated when file was opened, don't free */
     free(gn);
+}
 #endif
-/*-
+/* Find a node in the list using the given name for matching.
- *-----------------------------------------------------------------------
+ * If the node is created, it is added to the .ALLTARGETS list.
  * Targ_FindNode  --
  *	Find a node in the list using the given name for matching
+ *
  * Input:
  *	name		the name to find
- *	flags		flags governing events when target not
+ *	flags		flags governing events when target not found
  *			found
+ *
  * Results:
- *	The node in the list if it was. If it wasn't, return NULL of
+ *	The node in the list if it was. If it wasn't, return NULL if
  *	flags was TARG_NOCREATE or the newly created and initialized node
  *	if it was TARG_CREATE
  * Side Effects:
  *	Sometimes a node is created and added to the list
  *-----------------------------------------------------------------------
  */
 GNode *
 Targ_FindNode(const char *name, int flags)
+{
     GNode         *gn;	      /* node in that element */
     Hash_Entry	  *he = NULL; /* New or used hash entry for node */
     Boolean	  isNew;      /* Set TRUE if Hash_CreateEntry had to create */
 			      /* an entry for the node */
     if (!(flags & (TARG_CREATE | TARG_NOHASH))) {
 	he = Hash_FindEntry(&targets, name);
 	if (he == NULL)
 	    return NULL;
 	return (GNode *)Hash_GetValue(he);
+    }
     if (!(flags & TARG_NOHASH)) {
 	he = Hash_CreateEntry(&targets, name, &isNew);
 	if (!isNew)
 	    return (GNode *)Hash_GetValue(he);
+    }
     gn = Targ_NewGN(name);
     if (!(flags & TARG_NOHASH))
 	Hash_SetValue(he, gn);
     Var_Append(".ALLTARGETS", name, VAR_GLOBAL);
     Lst_Append(allTargets, gn);
     if (doing_depend)
 	gn->flags |= FROM_DEPEND;
     return gn;
+}
-/*-
+/* Make a complete list of GNodes from the given list of names.
- *-----------------------------------------------------------------------
+ * If flags is TARG_CREATE, nodes will be created for all names in
- * Targ_FindList --
+ * names which do not yet have graph nodes. If flags is TARG_NOCREATE,
- *	Make a complete list of GNodes from the given list of names
+ * an error message will be printed for each name which can't be found.
+ *
  * 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();
     Lst_Open(names);
     while ((ln = Lst_Next(names)) != NULL) {
 	name = Lst_Datum(ln);
 	gn = Targ_FindNode(name, flags);
 	if (gn != NULL) {
 	    /*
 	     * Note: Lst_Append 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.
 	     */
 	    Lst_Append(nodes, gn);
 	} else if (flags == TARG_NOCREATE) {
 	    Error("\"%s\" -- target unknown.", name);
+	}
+    }
     Lst_Close(names);
     return nodes;
+}
-/*-
+/* Return true if should ignore errors when creating gn. */
  *-----------------------------------------------------------------------
  * Targ_Ignore  --
  *	Return true if should ignore errors when creating gn
  * Input:
  *	gn		node to check for
  * Results:
  *	TRUE if should ignore errors
  * Side Effects:
  *	None
  *-----------------------------------------------------------------------
  */
 Boolean
 Targ_Ignore(GNode *gn)
+{
-    if (ignoreErrors || gn->type & OP_IGNORE) {
+    return ignoreErrors || gn->type & OP_IGNORE;
 	return TRUE;
     } else {
 	return FALSE;
+}
-/*-
+/* Return true if be silent when creating gn. */
  *-----------------------------------------------------------------------
  * Targ_Silent  --
  *	Return true if be silent when creating gn
  * Input:
  *	gn		node to check for
  * Results:
  *	TRUE if should be silent
  * Side Effects:
  *	None
  *-----------------------------------------------------------------------
  */
 Boolean
 Targ_Silent(GNode *gn)
+{
-    if (beSilent || gn->type & OP_SILENT) {
+    return beSilent || gn->type & OP_SILENT;
 	return TRUE;
     } else {
 	return FALSE;
+}
-/*-
+/* See if the given target is precious. */
  *-----------------------------------------------------------------------
  * Targ_Precious --
  *	See if the given target is precious
  * Input:
  *	gn		the node to check
  * Results:
  *	TRUE if it is precious. FALSE otherwise
  * Side Effects:
  *	None
  *-----------------------------------------------------------------------
  */
 Boolean
 Targ_Precious(GNode *gn)
+{
-    if (allPrecious || (gn->type & (OP_PRECIOUS|OP_DOUBLEDEP))) {
+    return allPrecious || gn->type & (OP_PRECIOUS | OP_DOUBLEDEP);
 	return TRUE;
     } else {
 	return FALSE;
+}
 /******************* DEBUG INFO PRINTING ****************/
 static GNode	  *mainTarg;	/* the main target, as set by Targ_SetMain */
 /*-
- *-----------------------------------------------------------------------
+/* Set our idea of the main target we'll be creating. Used for debugging
- * Targ_SetMain --
+ * output. */
  *	Set our idea of the main target we'll be creating. Used for
  *	debugging output.
  * Input:
  *	gn		The main target we'll create
  * Results:
  *	None.
  * Side Effects:
  *	"mainTarg" is set to the main target's node.
  *-----------------------------------------------------------------------
  */
 void
 Targ_SetMain(GNode *gn)
+{
     mainTarg = gn;
+}
 static int
 TargPrintName(void *gnp, void *pflags MAKE_ATTR_UNUSED)
+{
     GNode *gn = (GNode *)gnp;
     fprintf(debug_file, "%s%s ", gn->name, gn->cohort_num);
     return 0;
+}
 int
 Targ_PrintCmd(void *cmd, void *dummy MAKE_ATTR_UNUSED)
+{
     fprintf(debug_file, "\t%s\n", (char *)cmd);
     return 0;
+}
-/*-
+/* Format a modification time in some reasonable way and return it.
- *-----------------------------------------------------------------------
+ * The time is placed in a static area, so it is overwritten with each call. */
  * Targ_FmtTime --
  *	Format a modification time in some reasonable way and return it.
  * Results:
  *	The time reformatted.
  * Side Effects:
  *	The time is placed in a static area, so it is overwritten
  *	with each call.
  *-----------------------------------------------------------------------
  */
 char *
 Targ_FmtTime(time_t tm)
+{
     struct tm	  	*parts;
     static char	  	buf[128];
     parts = localtime(&tm);
     (void)strftime(buf, sizeof buf, "%k:%M:%S %b %d, %Y", parts);
     return buf;
+}
-/*-
+/* Print out a type field giving only those attributes the user can set. */
  *-----------------------------------------------------------------------
  * Targ_PrintType --
  *	Print out a type field giving only those attributes the user can
  *	set.
  * Results:
  * Side Effects:
  *-----------------------------------------------------------------------
  */
 void
 Targ_PrintType(int type)
+{
     int    tbit;
 #define PRINTBIT(attr)	case CONCAT(OP_,attr): fprintf(debug_file, "." #attr " "); break
 #define PRINTDBIT(attr) case CONCAT(OP_,attr): if (DEBUG(TARG))fprintf(debug_file, "." #attr " "); break
     type &= ~OP_OPMASK;
     while (type) {
 	tbit = 1 << (ffs(type) - 1);
 	type &= ~tbit;
 	switch(tbit) {
 	    PRINTBIT(OPTIONAL);
 	    PRINTBIT(USE);
 	    PRINTBIT(EXEC);
 	    PRINTBIT(IGNORE);
 	    PRINTBIT(PRECIOUS);
 	    PRINTBIT(SILENT);
 	    PRINTBIT(MAKE);
 	    PRINTBIT(JOIN);
 	    PRINTBIT(INVISIBLE);
 	    PRINTBIT(NOTMAIN);
 	    PRINTDBIT(LIB);
 	    /*XXX: MEMBER is defined, so CONCAT(OP_,MEMBER) gives OP_"%" */
 	    case OP_MEMBER: if (DEBUG(TARG))fprintf(debug_file, ".MEMBER "); break;
 	    PRINTDBIT(ARCHV);
 	    PRINTDBIT(MADE);
 	    PRINTDBIT(PHONY);
+	}
+    }
+}
 static const char *
 made_name(GNodeMade made)
+{
     switch (made) {
     case UNMADE:     return "unmade";
     case DEFERRED:   return "deferred";
     case REQUESTED:  return "requested";
     case BEINGMADE:  return "being made";
     case MADE:       return "made";
     case UPTODATE:   return "up-to-date";
     case ERROR:      return "error when made";
     case ABORTED:    return "aborted";
     default:         return "unknown enum_made value";
+    }
+}
-/*-
+/* Print the contents of a node. */
  *-----------------------------------------------------------------------
  * TargPrintNode --
  *	print the contents of a node
  *-----------------------------------------------------------------------
  */
 int
 Targ_PrintNode(void *gnp, void *passp)
+{
     GNode         *gn = (GNode *)gnp;
     int	    	  pass = passp ? *(int *)passp : 0;
     fprintf(debug_file, "# %s%s", gn->name, gn->cohort_num);
     GNode_FprintDetails(debug_file, ", ", gn, "\n");
     if (gn->flags == 0)
 	return 0;
     if (!OP_NOP(gn->type)) {
 	fprintf(debug_file, "#\n");
 	if (gn == mainTarg) {
 	    fprintf(debug_file, "# *** MAIN TARGET ***\n");
+	}
 	if (pass >= 2) {
 	    if (gn->unmade) {
 		fprintf(debug_file, "# %d unmade children\n", gn->unmade);
 	    } else {
 		fprintf(debug_file, "# No unmade children\n");
+	    }
 	    if (! (gn->type & (OP_JOIN|OP_USE|OP_USEBEFORE|OP_EXEC))) {
 		if (gn->mtime != 0) {
 		    fprintf(debug_file, "# last modified %s: %s\n",
 			      Targ_FmtTime(gn->mtime),
 			      made_name(gn->made));
 		} else if (gn->made != UNMADE) {
 		    fprintf(debug_file, "# non-existent (maybe): %s\n",
 			      made_name(gn->made));
 		} else {
 		    fprintf(debug_file, "# unmade\n");
+		}
+	    }
 	    if (!Lst_IsEmpty(gn->iParents)) {
 		fprintf(debug_file, "# implicit parents: ");
 		Lst_ForEach(gn->iParents, TargPrintName, NULL);
 		fprintf(debug_file, "\n");
+	    }
 	} else {
 	    if (gn->unmade)
 		fprintf(debug_file, "# %d unmade children\n", gn->unmade);
+	}
 	if (!Lst_IsEmpty(gn->parents)) {
 	    fprintf(debug_file, "# parents: ");
 	    Lst_ForEach(gn->parents, TargPrintName, NULL);
 	    fprintf(debug_file, "\n");
+	}
 	if (!Lst_IsEmpty(gn->order_pred)) {
 	    fprintf(debug_file, "# order_pred: ");
 	    Lst_ForEach(gn->order_pred, TargPrintName, NULL);
 	    fprintf(debug_file, "\n");
+	}
 	if (!Lst_IsEmpty(gn->order_succ)) {
 	    fprintf(debug_file, "# order_succ: ");
 	    Lst_ForEach(gn->order_succ, TargPrintName, NULL);
 	    fprintf(debug_file, "\n");
+	}
 	fprintf(debug_file, "%-16s", gn->name);
 	switch (gn->type & OP_OPMASK) {
 	    case OP_DEPENDS:
 		fprintf(debug_file, ": "); break;
 	    case OP_FORCE:
 		fprintf(debug_file, "! "); break;
 	    case OP_DOUBLEDEP:
 		fprintf(debug_file, ":: "); break;
+	}
 	Targ_PrintType(gn->type);
 	Lst_ForEach(gn->children, TargPrintName, NULL);
 	fprintf(debug_file, "\n");
 	Lst_ForEach(gn->commands, Targ_PrintCmd, NULL);
 	fprintf(debug_file, "\n\n");
 	if (gn->type & OP_DOUBLEDEP) {
 	    Lst_ForEach(gn->cohorts, Targ_PrintNode, &pass);
+	}
+    }
     return 0;
+}
-/*-
+/* Print only those targets that are just a source.
- *-----------------------------------------------------------------------
+ * The name of each file is printed, preceded by #\t. */
  * TargPrintOnlySrc --
  *	Print only those targets that are just a source.
  * Results:
  *	0.
  * Side Effects:
  *	The name of each file is printed preceded by #\t
  *-----------------------------------------------------------------------
  */
 static int
 TargPrintOnlySrc(void *gnp, void *dummy MAKE_ATTR_UNUSED)
+{
     GNode   	  *gn = (GNode *)gnp;
     if (!OP_NOP(gn->type))
 	return 0;
     fprintf(debug_file, "#\t%s [%s] ",
 	    gn->name, gn->path ? gn->path : gn->name);
     Targ_PrintType(gn->type);
     fprintf(debug_file, "\n");
     return 0;
+}
-/*-
+/* Input:
- *-----------------------------------------------------------------------
+ *	pass		1 => before processing
- * Targ_PrintGraph --
+ *			2 => after processing
- *	print the entire graph. heh heh
+ *			3 => after processing, an error occurred
  * Input:
  *	pass		Which pass this is. 1 => no processing
  *			2 => processing done
  * Results:
  *	none
  * Side Effects:
  *	lots o' output
  *-----------------------------------------------------------------------
  */
 void
 Targ_PrintGraph(int pass)
+{
     fprintf(debug_file, "#*** Input graph:\n");
     Lst_ForEach(allTargets, Targ_PrintNode, &pass);
     fprintf(debug_file, "\n\n");
     fprintf(debug_file, "#\n#   Files that are only sources:\n");
     Lst_ForEach(allTargets, TargPrintOnlySrc, NULL);
     fprintf(debug_file, "#*** Global Variables:\n");
     Var_Dump(VAR_GLOBAL);
     fprintf(debug_file, "#*** Command-line Variables:\n");
     Var_Dump(VAR_CMD);
     fprintf(debug_file, "\n");
     Dir_PrintDirectories();
     fprintf(debug_file, "\n");
     Suff_PrintAll();
+}
-/*-
+/* Propagate information from a single node to related nodes if appropriate.
  *-----------------------------------------------------------------------
- * TargPropagateNode --
+ * Information is propagated from this node to cohort nodes.
  *	Propagate information from a single node to related nodes if
- *	appropriate.
+ * If the node was defined with "::", then TargPropagateCohort() will be
  * called for each cohort node.
+ *
  * Input:
  *	gnp		The node that we are processing.
+ *
  * Results:
  *	Always returns 0, for the benefit of Lst_ForEach().
  * Side Effects:
  *	Information is propagated from this node to cohort or child
  *	nodes.
  *	If the node was defined with "::", then TargPropagateCohort()
  *	will be called for each cohort node.
  *	If the node has recursive predecessors, then
  *	TargPropagateRecpred() will be called for each recursive
  *	predecessor.
  *-----------------------------------------------------------------------
  */
 static int
 TargPropagateNode(void *gnp, void *junk MAKE_ATTR_UNUSED)
+{
     GNode	  *gn = (GNode *)gnp;
     if (gn->type & OP_DOUBLEDEP)
 	Lst_ForEach(gn->cohorts, TargPropagateCohort, gnp);
     return 0;
+}
-/*-
+/* Propagate some bits in the type mask from a node to a related cohort node.
- *-----------------------------------------------------------------------
+ * cnp's type bitmask is modified to incorporate some of the bits from gnp's
- * TargPropagateCohort --
+ * type bitmask.  (XXX need a better explanation.)
  *	Propagate some bits in the type mask from a node to
  *	a related cohort node.
+ *
  * Input:
  *	cnp		The node that we are processing.
  *	gnp		Another node that has cnp as a cohort.
+ *
  * Results:
  *	Always returns 0, for the benefit of Lst_ForEach().
  * Side Effects:
  *	cnp's type bitmask is modified to incorporate some of the
  *	bits from gnp's type bitmask.  (XXX need a better explanation.)
  *-----------------------------------------------------------------------
  */
 static int
 TargPropagateCohort(void *cgnp, void *pgnp)
+{
     GNode	  *cgn = (GNode *)cgnp;
     GNode	  *pgn = (GNode *)pgnp;
     cgn->type |= pgn->type & ~OP_OPMASK;
     return 0;
+}
-/*-
+/* Propagate information between related nodes.  Should be called after the
- *-----------------------------------------------------------------------
+ * makefiles are parsed but before any action is taken.
  * Targ_Propagate --
  *	Propagate information between related nodes.  Should be called
  *	after the makefiles are parsed but before any action is taken.
+ *
- * Results:
+ * Information is propagated between related nodes throughout the graph. */
  *	none
  * Side Effects:
  *	Information is propagated between related nodes throughout the
  *	graph.
  *-----------------------------------------------------------------------
  */
 void
 Targ_Propagate(void)
+{
     Lst_ForEach(allTargets, TargPropagateNode, NULL);
+}