 @@ -1,711 +1,711 @@
-/*	$NetBSD: make.h,v 1.176 2020/10/30 07:19:30 rillig Exp $	*/
+/*	$NetBSD: make.h,v 1.177 2020/10/30 17:10:48 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 <sys/stat.h>
 #include <assert.h>
 #include <ctype.h>
 #include <fcntl.h>
 #include <stdarg.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, for historic reasons.
  * The only allowed values are the constants TRUE and FALSE (1 and 0).
  */
 #ifdef USE_DOUBLE_BOOLEAN
 /* During development, to find type mismatches in function declarations. */
 typedef double Boolean;
 #define TRUE 1.0
 #define FALSE 0.0
 #elif defined(USE_UCHAR_BOOLEAN)
 /* During development, to find code that depends on the exact value of TRUE or
  * that stores other values in Boolean variables. */
 typedef unsigned char Boolean;
 #define TRUE ((unsigned char)0xFF)
 #define FALSE ((unsigned char)0x00)
 #elif defined(USE_CHAR_BOOLEAN)
 /* During development, to find code that uses a boolean as array index, via
  * -Wchar-subscripts. */
 typedef char Boolean;
 #define TRUE ((char)-1)
 #define FALSE ((char)0x00)
 #elif defined(USE_ENUM_BOOLEAN)
 typedef enum Boolean { FALSE, TRUE } Boolean;
 #else
 typedef int Boolean;
 #ifndef TRUE
 #define TRUE	1
 #endif
 #ifndef FALSE
 #define FALSE	0
 #endif
 #endif
 #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.
+ *
  * Some of the OP_ constants can be combined, others cannot. */
 typedef enum GNodeType {
     /* The dependency operator ':' is the most common one.  The commands of
      * this node are executed if any child is out-of-date. */
     OP_DEPENDS		= 1 << 0,
     /* The dependency operator '!' always executes its commands, even if
      * its children are up-to-date. */
     OP_FORCE		= 1 << 1,
     /* The dependency operator '::' behaves like ':', except that it allows
      * multiple dependency groups to be defined.  Each of these groups is
      * executed on its own, independently from the others. */
     OP_DOUBLEDEP	= 1 << 2,
     /* Matches the dependency operators ':', '!' and '::'. */
     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 non-zero exit status from shell commands 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 */
     /* XXX: How does this differ from OP_ARCHV? */
     OP_MEMBER		= 1 << 30,
     /* The node is a library,
      * its name has the form "-l<libname>" */
     OP_LIB		= 1 << 29,
     /* The node is an archive member,
      * its name has the form "archive(member)" */
     /* XXX: How does this differ from OP_MEMBER? */
     OP_ARCHV		= 1 << 28,
     /* Target has all the commands it should. Used when parsing to catch
      * multiple command groups for a target.  Only applies to the dependency
      * operators ':' and '!', but not to '::'. */
     OP_HAS_COMMANDS	= 1 << 27,
     /* The special command "..." has been seen. All further commands from
      * this node will be saved on the .END node instead, to be executed at
      * the very end. */
     OP_SAVE_CMDS	= 1 << 26,
     /* Already processed by Suff_FindDeps */
     OP_DEPS_FOUND	= 1 << 25,
     /* Node found while expanding .ALLSRC */
     OP_MARK		= 1 << 24,
     OP_NOTARGET		= OP_NOTMAIN | OP_USE | OP_EXEC | OP_TRANSFORM
 } GNodeType;
 typedef enum GNodeFlags {
     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;
 typedef struct List StringList;
 typedef struct ListNode StringListNode;
 typedef struct List GNodeList;
 typedef struct ListNode GNodeListNode;
 typedef struct List /* of CachedDir */ SearchPath;
 /* 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;
     GNodeFlags flags;
     /* The state of processing on this node */
     GNodeMade made;
     int unmade;			/* The number of unmade children */
     /* The modification time; 0 means the node does not have a corresponding
      * file; see Make_OODate. */
     time_t mtime;
     struct GNode *youngestChild;
     /* The GNodes for which this node is an implied source. May be empty.
      * For example, when there is an inference rule for .c.o, the node for
      * file.c has the node for file.o in this list. */
     GNodeList *implicitParents;
     /* Other nodes of the same name, for the '::' operator. */
     GNodeList *cohorts;
     /* The nodes that depend on this one, or in other words, the nodes for
      * which this is a source. */
     GNodeList *parents;
     /* The nodes on which this one depends. */
     GNodeList *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. */
     GNodeList *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. */
     GNodeList *order_succ;
     /* The "#n" suffix for this cohort, or "" for other nodes */
     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 list */
     struct GNode *centurion;
     /* Last time (sequence number) we tried to make this node */
     unsigned int checked_seqno;
     /* The "local" variables that are specific to this target and this target
      * only, such as $@, $<, $?.
+     *
      * Also used for the global variable scopes VAR_GLOBAL, VAR_CMDLINE,
      * VAR_INTERNAL, which contain variables with arbitrary names. */
-    HashTable context;
+    HashTable /* of Var pointer */ context;
     /* The commands to be given to a shell to create this target. */
     StringList *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;
 /*
  * Error levels for parsing. PARSE_FATAL means the process cannot continue
  * once the top-level makefile has been parsed. PARSE_WARNING and PARSE_INFO
  * mean it can.
  */
 typedef enum ParseErrorLevel {
     PARSE_FATAL = 1,
     PARSE_WARNING,
     PARSE_INFO
 } ParseErrorLevel;
 /*
  * Values returned by Cond_EvalLine and Cond_EvalCondition.
  */
 typedef enum CondEvalResult {
     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 SearchPath *dirSearchPath;
 				/* The list of directories to search when
 				 * looking for targets */
 extern Boolean  allPrecious;	/* True if every target is precious */
 extern Boolean  deleteOnError;	/* True if failed targets should be deleted */
 extern Boolean	doing_depend;	/* TRUE if processing .depend */
 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_CMDLINE;	/* 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 SearchPath *sysIncPath;	/* The system include path. */
 extern SearchPath *defSysIncPath; /* The default system 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 makefiles already loaded */
 #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
 typedef enum DebugFlags {
     DEBUG_ARCH		= 1 << 0,
     DEBUG_COND		= 1 << 1,
     DEBUG_DIR		= 1 << 2,
     DEBUG_GRAPH1	= 1 << 3,
     DEBUG_GRAPH2	= 1 << 4,
     DEBUG_JOB		= 1 << 5,
     DEBUG_MAKE		= 1 << 6,
     DEBUG_SUFF		= 1 << 7,
     DEBUG_TARG		= 1 << 8,
     DEBUG_VAR		= 1 << 9,
     DEBUG_FOR		= 1 << 10,
     DEBUG_SHELL		= 1 << 11,
     DEBUG_ERROR		= 1 << 12,
     DEBUG_LOUD		= 1 << 13,
     DEBUG_META		= 1 << 14,
     DEBUG_HASH		= 1 << 15,
     DEBUG_GRAPH3	= 1 << 16,
     DEBUG_SCRIPT	= 1 << 17,
     DEBUG_PARSE		= 1 << 18,
     DEBUG_CWD		= 1 << 19,
     DEBUG_LINT		= 1 << 20
 } DebugFlags;
 #define CONCAT(a,b)	a##b
 #define	DEBUG(module)	(opts.debug & CONCAT(DEBUG_,module))
 void debug_printf(const char *, ...) MAKE_ATTR_PRINTFLIKE(1, 2);
 #define DEBUG0(module, text) \
     if (!DEBUG(module)) (void)0; \
     else debug_printf("%s", text)
 #define DEBUG1(module, fmt, arg1) \
     if (!DEBUG(module)) (void)0; \
     else debug_printf(fmt, arg1)
 #define DEBUG2(module, fmt, arg1, arg2) \
     if (!DEBUG(module)) (void)0; \
     else debug_printf(fmt, arg1, arg2)
 #define DEBUG3(module, fmt, arg1, arg2, arg3) \
     if (!DEBUG(module)) (void)0; \
     else debug_printf(fmt, arg1, arg2, arg3)
 #define DEBUG4(module, fmt, arg1, arg2, arg3, arg4) \
     if (!DEBUG(module)) (void)0; \
     else debug_printf(fmt, arg1, arg2, arg3, arg4)
 #define DEBUG5(module, fmt, arg1, arg2, arg3, arg4, arg5) \
     if (!DEBUG(module)) (void)0; \
     else debug_printf(fmt, arg1, arg2, arg3, arg4, arg5)
 typedef enum PrintVarsMode {
     COMPAT_VARS = 1,
     EXPAND_VARS
 } PrintVarsMode;
 /* Command line options */
 typedef struct CmdOpts {
     /* -B: whether we are make compatible */
     Boolean compatMake;
     /* -d: debug control: There is one bit per module.  It is up to the
      * module what debug information to print. */
     DebugFlags debug;
     /* -df: debug output is written here - default stderr */
     FILE *debug_file;
     /* -dV: for the -V option, print unexpanded variable values */
     Boolean debugVflag;
     /* -e: check environment variables before global variables */
     Boolean checkEnvFirst;
     /* -f: the makefiles to read */
     StringList *makefiles;
     /* -i: if true, ignore all errors from shell commands */
     Boolean ignoreErrors;
     /* -j: the maximum number of jobs that can run in parallel;
      * this is coordinated with the submakes */
     int maxJobs;
     /* -k: if true, continue on unaffected portions of the graph when an
      * error occurs in one portion */
     Boolean keepgoing;
     /* -N: execute no commands from the targets */
     Boolean noRecursiveExecute;
     /* -n: execute almost no commands from the targets */
     Boolean noExecute;
     /* -q: if true, we aren't supposed to really make anything, just see if
      * the targets are out-of-date */
     Boolean queryFlag;
     /* -r: raw mode, without loading the builtin rules. */
     Boolean noBuiltins;
     /* -s: don't echo the shell commands before executing them */
     Boolean beSilent;
     /* -t: touch the targets if they are out-of-date, but don't actually
      * make them */
     Boolean touchFlag;
     /* -[Vv]: print expanded or unexpanded selected variables */
     PrintVarsMode printVars;
     /* -[Vv]: the variables to print */
     StringList *variables;
     /* -W: if true, makefile parsing warnings are treated as errors */
     Boolean parseWarnFatal;
     /* -w: print Entering and Leaving for submakes */
     Boolean enterFlag;
     /* -X: if true, do not export variables set on the command line to the
      * environment. */
     Boolean varNoExportEnv;
     /* The target names specified on the command line.
      * Used to resolve .if make(...) statements. */
     StringList *create;
 } CmdOpts;
 extern CmdOpts opts;
 #include "nonints.h"
 void Make_TimeStamp(GNode *, GNode *);
 Boolean Make_OODate(GNode *);
 void Make_ExpandUse(GNodeList *);
 time_t Make_Recheck(GNode *);
 void Make_HandleUse(GNode *, GNode *);
 void Make_Update(GNode *);
 void Make_DoAllVar(GNode *);
 Boolean Make_Run(GNodeList *);
 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(StringList *, char *, const char *);
 void GNode_FprintDetails(FILE *, const char *, const GNode *, const char *);
 Boolean NoExecute(GNode *gn);
 /* See if the node was seen on the left-hand side of a dependency operator. */
 static MAKE_ATTR_UNUSED Boolean
 GNode_IsTarget(const GNode *gn)
+{
     return (gn->type & OP_OPMASK) != 0;
+}
 static MAKE_ATTR_UNUSED const char *
 GNode_Path(const GNode *gn)
+{
     return gn->path != NULL ? gn->path : gn->name;
+}
 #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
 /* 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
 static inline MAKE_ATTR_UNUSED Boolean ch_isalnum(char ch)
 { return isalnum((unsigned char)ch) != 0; }
 static inline MAKE_ATTR_UNUSED Boolean ch_isalpha(char ch)
 { return isalpha((unsigned char)ch) != 0; }
 static inline MAKE_ATTR_UNUSED Boolean ch_isdigit(char ch)
 { return isdigit((unsigned char)ch) != 0; }
 static inline MAKE_ATTR_UNUSED Boolean ch_isspace(char ch)
 { return isspace((unsigned char)ch) != 0; }
 static inline MAKE_ATTR_UNUSED Boolean ch_isupper(char ch)
 { return isupper((unsigned char)ch) != 0; }
 static inline MAKE_ATTR_UNUSED char ch_tolower(char ch)
 { return (char)tolower((unsigned char)ch); }
 static inline MAKE_ATTR_UNUSED char ch_toupper(char ch)
 { return (char)toupper((unsigned char)ch); }
 static inline MAKE_ATTR_UNUSED void
 cpp_skip_whitespace(const char **pp)
+{
     while (ch_isspace(**pp))
 	(*pp)++;
+}
 static inline MAKE_ATTR_UNUSED void
 pp_skip_whitespace(char **pp)
+{
     while (ch_isspace(**pp))
 	(*pp)++;
+}
 #ifdef MAKE_NATIVE
 #  include <sys/cdefs.h>
 #  ifndef lint
 #    define MAKE_RCSID(id) __RCSID(id)
 #  endif
 #else
 #  define MAKE_RCSID(id) static volatile char rcsid[] = id
 #endif
 #endif /* MAKE_MAKE_H */

 @@ -1,1582 +1,1574 @@
-/*	$NetBSD: var.c,v 1.604 2020/10/30 16:54:38 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.605 2020/10/30 17:10:48 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.
  */
 /*
  * Handling of variables and the expressions formed from them.
+ *
  * Variables are set using lines of the form VAR=value.  Both the variable
  * name and the value can contain references to other variables, by using
  * expressions like ${VAR}, ${VAR:Modifiers}, ${${VARNAME}} or ${VAR:${MODS}}.
+ *
  * Interface:
  *	Var_Init	Initialize this module.
+ *
  *	Var_End		Clean up the module.
+ *
  *	Var_Set		Set the value of the variable, creating it if
  *			necessary.
+ *
  *	Var_Append	Append more characters to the variable, creating it if
  *			necessary. A space is placed between the old value and
  *			the new one.
+ *
  *	Var_Exists	See if a variable exists.
+ *
  *	Var_Value	Return the unexpanded value of a variable, or NULL if
  *			the variable is undefined.
+ *
  *	Var_Subst	Substitute all variable expressions in a string.
+ *
  *	Var_Parse	Parse a variable expression such as ${VAR:Mpattern}.
+ *
  *	Var_Delete	Delete a variable.
+ *
  *	Var_ExportVars	Export some or even all variables to the environment
  *			of this process and its child processes.
+ *
  *	Var_Export	Export the variable to the environment of this process
  *			and its child processes.
+ *
  *	Var_UnExport	Don't export the variable anymore.
+ *
  * Debugging:
  *	Var_Stats	Print out hashing statistics if in -dh mode.
+ *
  *	Var_Dump	Print out all variables defined in the given context.
+ *
  * XXX: There's a lot of duplication in these functions.
  */
 #include    <sys/stat.h>
 #ifndef NO_REGEX
 #include    <sys/types.h>
 #include    <regex.h>
 #endif
 #include    <inttypes.h>
 #include    <limits.h>
 #include    <time.h>
 #include    "make.h"
 #include    "dir.h"
 #include    "job.h"
 #include    "metachar.h"
 /*	"@(#)var.c	8.3 (Berkeley) 3/19/94" */
-MAKE_RCSID("$NetBSD: var.c,v 1.604 2020/10/30 16:54:38 rillig Exp $");
+MAKE_RCSID("$NetBSD: var.c,v 1.605 2020/10/30 17:10:48 rillig Exp $");
 #define VAR_DEBUG1(fmt, arg1) DEBUG1(VAR, fmt, arg1)
 #define VAR_DEBUG2(fmt, arg1, arg2) DEBUG2(VAR, fmt, arg1, arg2)
 #define VAR_DEBUG3(fmt, arg1, arg2, arg3) DEBUG3(VAR, fmt, arg1, arg2, arg3)
 #define VAR_DEBUG4(fmt, arg1, arg2, arg3, arg4) DEBUG4(VAR, fmt, arg1, arg2, arg3, arg4)
 ENUM_FLAGS_RTTI_3(VarEvalFlags,
 		  VARE_UNDEFERR, VARE_WANTRES, VARE_ASSIGN);
 /*
  * This lets us tell if we have replaced the original environ
  * (which we cannot free).
  */
 char **savedEnv = NULL;
 /* Special return value for Var_Parse, indicating a parse error.  It may be
  * caused by an undefined variable, a syntax error in a modifier or
  * something entirely different. */
 char var_Error[] = "";
 /* Special return value for Var_Parse, indicating an undefined variable in
  * a case where VARE_UNDEFERR is not set.  This undefined variable is
  * typically a dynamic variable such as ${.TARGET}, whose expansion needs to
  * be deferred until it is defined in an actual target. */
 static char varUndefined[] = "";
 /* Special return value for Var_Parse, just to avoid allocating empty strings.
  * In contrast to var_Error and varUndefined, this is not an error marker but
  * just an ordinary successful return value. */
 static char emptyString[] = "";
 /*
  * Traditionally this make consumed $$ during := like any other expansion.
  * Other make's do not, and this make follows straight since 2016-01-09.
+ *
  * This knob allows controlling the behavior.
  * FALSE to consume $$ during := assignment.
  * TRUE to preserve $$ during := assignment.
  */
 #define MAKE_SAVE_DOLLARS ".MAKE.SAVE_DOLLARS"
 static Boolean save_dollars = TRUE;
 /*
  * Internally, variables are contained in four different contexts.
  *	1) the environment. They cannot be changed. If an environment
  *	   variable is appended to, the result is placed in the global
  *	   context.
  *	2) the global context. Variables set in the makefiles are located
  *	   here.
  *	3) the command-line context. All variables set on the command line
  *	   are placed in this context.
  *	4) the local context. Each target has associated with it a context
  *	   list. On this list are located the structures describing such
  *	   local variables as $(@) and $(*)
  * The four contexts are searched in the reverse order from which they are
  * listed (but see opts.checkEnvFirst).
  */
 GNode          *VAR_INTERNAL;	/* variables from make itself */
 GNode          *VAR_GLOBAL;	/* variables from the makefile */
 GNode          *VAR_CMDLINE;	/* variables defined on the command-line */
 typedef enum VarFlags {
     /* The variable's value is currently being used by Var_Parse or Var_Subst.
      * This marker is used to avoid endless recursion. */
     VAR_IN_USE = 0x01,
     /* The variable comes from the environment.
      * These variables are not registered in any GNode, therefore they must
      * be freed as soon as they are not used anymore. */
     VAR_FROM_ENV = 0x02,
     /* The variable is exported to the environment, to be used by child
      * processes. */
     VAR_EXPORTED = 0x10,
     /* At the point where this variable was exported, it contained an
      * unresolved reference to another variable.  Before any child process is
      * started, it needs to be exported again, in the hope that the referenced
      * variable can then be resolved. */
     VAR_REEXPORT = 0x20,
     /* The variable came from the command line. */
     VAR_FROM_CMD = 0x40,
     /* The variable value cannot be changed anymore, and the variable cannot
      * be deleted.  Any attempts to do so are ignored. */
     VAR_READONLY = 0x80
 } VarFlags;
 ENUM_FLAGS_RTTI_6(VarFlags,
 		  VAR_IN_USE, VAR_FROM_ENV,
 		  VAR_EXPORTED, VAR_REEXPORT, VAR_FROM_CMD, VAR_READONLY);
 /* Variables are defined using one of the VAR=value assignments.  Their
  * value can be queried by expressions such as $V, ${VAR}, or with modifiers
  * such as ${VAR:S,from,to,g:Q}.
+ *
  * There are 3 kinds of variables: context variables, environment variables,
  * undefined variables.
+ *
  * Context variables are stored in a GNode.context.  The only way to undefine
  * a context variable is using the .undef directive.  In particular, it must
  * not be possible to undefine a variable during the evaluation of an
  * expression, or Var.name might point nowhere.
+ *
  * Environment variables are temporary.  They are returned by VarFind, and
  * after using them, they must be freed using VarFreeEnv.
+ *
  * Undefined variables occur during evaluation of variable expressions such
  * as ${UNDEF:Ufallback} in Var_Parse and ApplyModifiers.
  */
 typedef struct Var {
     /* The name of the variable, once set, doesn't change anymore.
      * For context variables, it aliases the corresponding HashEntry name.
      * For environment and undefined variables, it is allocated. */
     const char *name;
     void *name_freeIt;
     Buffer	  val;		/* its value */
     VarFlags	  flags;	/* miscellaneous status flags */
 } Var;
 /*
  * Exporting vars is expensive so skip it if we can
  */
 typedef enum VarExportedMode {
     VAR_EXPORTED_NONE,
     VAR_EXPORTED_SOME,
     VAR_EXPORTED_ALL
 } VarExportedMode;
 static VarExportedMode var_exportedVars = VAR_EXPORTED_NONE;
 typedef enum VarExportFlags {
     /*
      * We pass this to Var_Export when doing the initial export
      * or after updating an exported var.
      */
     VAR_EXPORT_PARENT	= 0x01,
     /*
      * We pass this to Var_Export1 to tell it to leave the value alone.
      */
     VAR_EXPORT_LITERAL	= 0x02
 } VarExportFlags;
 /* Flags for pattern matching in the :S and :C modifiers */
 typedef enum VarPatternFlags {
     VARP_SUB_GLOBAL	= 0x01,	/* Replace as often as possible ('g') */
     VARP_SUB_ONE	= 0x02,	/* Replace only once ('1') */
     VARP_ANCHOR_START	= 0x04,	/* Match at start of word ('^') */
     VARP_ANCHOR_END	= 0x08	/* Match at end of word ('$') */
 } VarPatternFlags;
 static Var *
 VarNew(const char *name, void *name_freeIt, const char *value, VarFlags flags)
+{
     size_t value_len = strlen(value);
     Var *var = bmake_malloc(sizeof *var);
     var->name = name;
     var->name_freeIt = name_freeIt;
     Buf_Init(&var->val, value_len + 1);
     Buf_AddBytes(&var->val, value, value_len);
     var->flags = flags;
     return var;
+}
 static const char *
 CanonicalVarname(const char *name)
+{
     if (*name == '.' && ch_isupper(name[1])) {
 	switch (name[1]) {
 	case 'A':
 	    if (strcmp(name, ".ALLSRC") == 0)
 		name = ALLSRC;
 	    if (strcmp(name, ".ARCHIVE") == 0)
 		name = ARCHIVE;
 	    break;
 	case 'I':
 	    if (strcmp(name, ".IMPSRC") == 0)
 		name = IMPSRC;
 	    break;
 	case 'M':
 	    if (strcmp(name, ".MEMBER") == 0)
 		name = MEMBER;
 	    break;
 	case 'O':
 	    if (strcmp(name, ".OODATE") == 0)
 		name = OODATE;
 	    break;
 	case 'P':
 	    if (strcmp(name, ".PREFIX") == 0)
 		name = PREFIX;
 	    break;
 	case 'S':
 	    if (strcmp(name, ".SHELL") == 0) {
 		if (!shellPath)
 		    Shell_Init();
+	    }
 	    break;
 	case 'T':
 	    if (strcmp(name, ".TARGET") == 0)
 		name = TARGET;
 	    break;
+	}
+    }
     /* GNU make has an additional alias $^ == ${.ALLSRC}. */
     return name;
+}
 static Var *
 GNode_FindVar(GNode *ctxt, const char *varname, unsigned int hash)
+{
     return HashTable_FindValueHash(&ctxt->context, varname, hash);
+}
-/*-
+/* Find the variable in the context, and maybe in other contexts as well.
  *-----------------------------------------------------------------------
  * VarFind --
  *	Find the given variable in the given context and any other contexts
  *	indicated.
+ *
  * Input:
  *	name		name to find
- *	ctxt		context in which to find it
+ *	ctxt		context in which to look first
- *	elsewhere	to look in other contexts as well
+ *	elsewhere	TRUE to look in other contexts as well
+ *
  * Results:
- *	A pointer to the structure describing the desired variable or
+ *	The found variable, or NULL if the variable does not exist.
- *	NULL if the variable does not exist.
+ *	If the variable is an environment variable, it must be freed using
- *-----------------------------------------------------------------------
+ *	VarFreeEnv after use.
  */
 static Var *
 VarFind(const char *name, GNode *ctxt, Boolean elsewhere)
+{
     Var *var;
     unsigned int nameHash;
     /*
      * If the variable name begins with a '.', it could very well be one of
      * the local ones.  We check the name against all the local variables
      * and substitute the short version in for 'name' if it matches one of
      * them.
      */
     name = CanonicalVarname(name);
     nameHash = Hash_Hash(name);
-    /*
+    /* First look for the variable in the given context. */
      * First look for the variable in the given context. If it's not there,
      * look for it in VAR_CMDLINE, VAR_GLOBAL and the environment, in that order,
      * depending on the FIND_* flags in 'flags'
      */
     var = GNode_FindVar(ctxt, name, nameHash);
     if (!elsewhere)
 	return var;
     /* The variable was not found in the given context.  Now look for it in
      * the other contexts as well. */
     if (var == NULL && ctxt != VAR_CMDLINE)
 	var = GNode_FindVar(VAR_CMDLINE, name, nameHash);
     if (!opts.checkEnvFirst && var == NULL && ctxt != VAR_GLOBAL) {
 	var = GNode_FindVar(VAR_GLOBAL, name, nameHash);
 	if (var == NULL && ctxt != VAR_INTERNAL) {
 	    /* VAR_INTERNAL is subordinate to VAR_GLOBAL */
 	    var = GNode_FindVar(VAR_INTERNAL, name, nameHash);
+	}
+    }
     if (var == NULL) {
 	char *env;
 	if ((env = getenv(name)) != NULL) {
 	    char *varname = bmake_strdup(name);
 	    return VarNew(varname, varname, env, VAR_FROM_ENV);
+	}
 	if (opts.checkEnvFirst && ctxt != VAR_GLOBAL) {
 	    var = GNode_FindVar(VAR_GLOBAL, name, nameHash);
 	    if (var == NULL && ctxt != VAR_INTERNAL)
 		var = GNode_FindVar(VAR_INTERNAL, name, nameHash);
 	    return var;
+	}
 	return NULL;
+    }
     return var;
+}
-/*-
+/* If the variable is an environment variable, free it.
  *-----------------------------------------------------------------------
  * VarFreeEnv  --
  *	If the variable is an environment variable, free it
+ *
  * Input:
  *	v		the variable
- *	destroy		true if the value buffer should be destroyed.
+ *	freeValue	true if the variable value should be freed as well
+ *
  * Results:
  *	TRUE if it is an environment variable, FALSE otherwise.
  *-----------------------------------------------------------------------
  */
 static Boolean
-VarFreeEnv(Var *v, Boolean destroy)
+VarFreeEnv(Var *v, Boolean freeValue)
+{
     if (!(v->flags & VAR_FROM_ENV))
 	return FALSE;
     free(v->name_freeIt);
-    Buf_Destroy(&v->val, destroy);
+    Buf_Destroy(&v->val, freeValue);
     free(v);
     return TRUE;
+}
 /* Add a new variable of the given name and value to the given context.
  * The name and val arguments are duplicated so they may safely be freed. */
 static void
 VarAdd(const char *name, const char *val, GNode *ctxt, VarSet_Flags flags)
+{
     HashEntry *he = HashTable_CreateEntry(&ctxt->context, name, NULL);
-    Var *v = VarNew(he->key, NULL, val,
+    Var *v = VarNew(he->key /* aliased */, NULL, val,
 		    flags & VAR_SET_READONLY ? VAR_READONLY : 0);
     HashEntry_Set(he, v);
     if (!(ctxt->flags & INTERNAL)) {
 	VAR_DEBUG3("%s:%s = %s\n", ctxt->name, name, val);
+    }
+}
-/* Remove a variable from a context, freeing the Var structure as well. */
+/* Remove a variable from a context, freeing all related memory as well. */
 void
 Var_Delete(const char *name, GNode *ctxt)
+{
     char *name_freeIt = NULL;
     HashEntry *he;
     if (strchr(name, '$') != NULL) {
 	(void)Var_Subst(name, VAR_GLOBAL, VARE_WANTRES, &name_freeIt);
 	/* TODO: handle errors */
 	name = name_freeIt;
+    }
     he = HashTable_FindEntry(&ctxt->context, name);
     VAR_DEBUG3("%s:delete %s%s\n",
 	       ctxt->name, name, he != NULL ? "" : " (not found)");
     free(name_freeIt);
     if (he != NULL) {
 	Var *v = HashEntry_Get(he);
 	if (v->flags & VAR_EXPORTED)
 	    unsetenv(v->name);
 	if (strcmp(v->name, MAKE_EXPORTED) == 0)
 	    var_exportedVars = VAR_EXPORTED_NONE;
 	assert(v->name_freeIt == NULL);
 	HashTable_DeleteEntry(&ctxt->context, he);
 	Buf_Destroy(&v->val, TRUE);
 	free(v);
+    }
+}
 static Boolean
 MayExport(const char *name)
+{
     if (name[0] == '.')
 	return FALSE;		/* skip internals */
     if (name[0] == '-')
 	return FALSE;		/* skip misnamed variables */
     if (name[1] == '\0') {
 	/*
 	 * A single char.
 	 * If it is one of the vars that should only appear in
 	 * local context, skip it, else we can get Var_Subst
 	 * into a loop.
 	 */
 	switch (name[0]) {
 	case '@':
 	case '%':
 	case '*':
 	case '!':
 	    return FALSE;
+	}
+    }
     return TRUE;
+}
 /*
  * Export a single variable.
  * We ignore make internal variables (those which start with '.').
  * Also we jump through some hoops to avoid calling setenv
  * more than necessary since it can leak.
  * We only manipulate flags of vars if 'parent' is set.
  */
 static Boolean
 Var_Export1(const char *name, VarExportFlags flags)
+{
     VarExportFlags parent = flags & VAR_EXPORT_PARENT;
     Var *v;
     char *val;
     if (!MayExport(name))
 	return FALSE;
     v = VarFind(name, VAR_GLOBAL, 0);
     if (v == NULL)
 	return FALSE;
     if (!parent && (v->flags & VAR_EXPORTED) && !(v->flags & VAR_REEXPORT))
 	return FALSE;		/* nothing to do */
     val = Buf_GetAll(&v->val, NULL);
     if (!(flags & VAR_EXPORT_LITERAL) && strchr(val, '$') != NULL) {
 	char *expr;
 	if (parent) {
 	    /*
-	     * Flag this as something we need to re-export.
+	     * Flag the variable as something we need to re-export.
 	     * No point actually exporting it now though,
-	     * the child can do it at the last minute.
+	     * the child process can do it at the last minute.
 	     */
 	    v->flags |= VAR_EXPORTED | VAR_REEXPORT;
 	    return TRUE;
+	}
 	if (v->flags & VAR_IN_USE) {
 	    /*
 	     * We recursed while exporting in a child.
 	     * This isn't going to end well, just skip it.
 	     */
 	    return FALSE;
+	}
 	expr = str_concat3("${", name, "}");
 	(void)Var_Subst(expr, VAR_GLOBAL, VARE_WANTRES, &val);
 	/* TODO: handle errors */
 	setenv(name, val, 1);
 	free(val);
 	free(expr);
     } else {
 	if (parent)
 	    v->flags &= ~(unsigned)VAR_REEXPORT;	/* once will do */
 	if (parent || !(v->flags & VAR_EXPORTED))
 	    setenv(name, val, 1);
+    }
     /*
      * This is so Var_Set knows to call Var_Export again...
      */
     if (parent) {
 	v->flags |= VAR_EXPORTED;
+    }
     return TRUE;
+}
 /*
- * This gets called from our children.
+ * This gets called from our child processes.
  */
 void
 Var_ExportVars(void)
+{
     char *val;
     /*
      * Several make's support this sort of mechanism for tracking
      * recursion - but each uses a different name.
      * We allow the makefiles to update MAKELEVEL and ensure
      * children see a correctly incremented value.
      */
     char tmp[BUFSIZ];
     snprintf(tmp, sizeof(tmp), "%d", makelevel + 1);
     setenv(MAKE_LEVEL_ENV, tmp, 1);
     if (var_exportedVars == VAR_EXPORTED_NONE)
 	return;
     if (var_exportedVars == VAR_EXPORTED_ALL) {
 	HashIter hi;
 	/* Ouch! Exporting all variables at once is crazy... */
 	HashIter_Init(&hi, &VAR_GLOBAL->context);
 	while (HashIter_Next(&hi) != NULL) {
 	    Var *var = hi.entry->value;
 	    Var_Export1(var->name, 0);
+	}
 	return;
+    }
     (void)Var_Subst("${" MAKE_EXPORTED ":O:u}", VAR_GLOBAL, VARE_WANTRES, &val);
     /* TODO: handle errors */
     if (*val) {
 	Words words = Str_Words(val, FALSE);
 	size_t i;
 	for (i = 0; i < words.len; i++)
 	    Var_Export1(words.words[i], 0);
 	Words_Free(words);
+    }
     free(val);
+}
 /*
  * This is called when .export is seen or .MAKE.EXPORTED is modified.
+ *
  * It is also called when any exported variable is modified.
  * XXX: Is it really?
+ *
  * str has the format "[-env|-literal] varname...".
  */
 void
 Var_Export(const char *str, Boolean isExport)
+{
     VarExportFlags flags;
     char *val;
     if (isExport && str[0] == '\0') {
 	var_exportedVars = VAR_EXPORTED_ALL; /* use with caution! */
 	return;
+    }
     if (isExport && strncmp(str, "-env", 4) == 0) {
 	str += 4;
 	flags = 0;
     } else if (isExport && strncmp(str, "-literal", 8) == 0) {
 	str += 8;
 	flags = VAR_EXPORT_LITERAL;
     } else {
 	flags = VAR_EXPORT_PARENT;
+    }
     (void)Var_Subst(str, VAR_GLOBAL, VARE_WANTRES, &val);
     /* TODO: handle errors */
     if (val[0] != '\0') {
 	Words words = Str_Words(val, FALSE);
 	size_t i;
 	for (i = 0; i < words.len; i++) {
 	    const char *name = words.words[i];
 	    if (Var_Export1(name, flags)) {
 		if (var_exportedVars == VAR_EXPORTED_NONE)
 		    var_exportedVars = VAR_EXPORTED_SOME;
 		if (isExport && (flags & VAR_EXPORT_PARENT)) {
 		    Var_Append(MAKE_EXPORTED, name, VAR_GLOBAL);
+		}
+	    }
+	}
 	Words_Free(words);
+    }
     free(val);
+}
 extern char **environ;
 /*
  * This is called when .unexport[-env] is seen.
+ *
  * str must have the form "unexport[-env] varname...".
  */
 void
 Var_UnExport(const char *str)
+{
     const char *varnames;
     char *varnames_freeIt;
     Boolean unexport_env;
     varnames = NULL;
     varnames_freeIt = NULL;
     str += strlen("unexport");
     unexport_env = strncmp(str, "-env", 4) == 0;
     if (unexport_env) {
 	const char *cp;
 	char **newenv;
 	cp = getenv(MAKE_LEVEL_ENV);	/* we should preserve this */
 	if (environ == savedEnv) {
 	    /* we have been here before! */
 	    newenv = bmake_realloc(environ, 2 * sizeof(char *));
 	} else {
 	    if (savedEnv) {
 		free(savedEnv);
 		savedEnv = NULL;
+	    }
 	    newenv = bmake_malloc(2 * sizeof(char *));
+	}
 	/* Note: we cannot safely free() the original environ. */
 	environ = savedEnv = newenv;
 	newenv[0] = NULL;
 	newenv[1] = NULL;
 	if (cp && *cp)
 	    setenv(MAKE_LEVEL_ENV, cp, 1);
     } else {
 	cpp_skip_whitespace(&str);
 	if (str[0] != '\0')
 	    varnames = str;
+    }
     if (varnames == NULL) {
 	/* Using .MAKE.EXPORTED */
 	(void)Var_Subst("${" MAKE_EXPORTED ":O:u}", VAR_GLOBAL, VARE_WANTRES,
 			&varnames_freeIt);
 	/* TODO: handle errors */
 	varnames = varnames_freeIt;
+    }
+    {
 	Var *v;
 	size_t i;
 	Words words = Str_Words(varnames, FALSE);
 	for (i = 0; i < words.len; i++) {
 	    const char *varname = words.words[i];
 	    v = VarFind(varname, VAR_GLOBAL, 0);
 	    if (v == NULL) {
 		VAR_DEBUG1("Not unexporting \"%s\" (not found)\n", varname);
 		continue;
+	    }
 	    VAR_DEBUG1("Unexporting \"%s\"\n", varname);
 	    if (!unexport_env && (v->flags & VAR_EXPORTED) &&
 		!(v->flags & VAR_REEXPORT))
 		unsetenv(v->name);
 	    v->flags &= ~(unsigned)(VAR_EXPORTED | VAR_REEXPORT);
 	    /*
 	     * If we are unexporting a list,
 	     * remove each one from .MAKE.EXPORTED.
 	     * If we are removing them all,
 	     * just delete .MAKE.EXPORTED below.
 	     */
 	    if (varnames == str) {
 		char *expr = str_concat3("${" MAKE_EXPORTED ":N", v->name, "}");
 		char *cp;
 		(void)Var_Subst(expr, VAR_GLOBAL, VARE_WANTRES, &cp);
 		/* TODO: handle errors */
 		Var_Set(MAKE_EXPORTED, cp, VAR_GLOBAL);
 		free(cp);
 		free(expr);
+	    }
+	}
 	Words_Free(words);
 	if (varnames != str) {
 	    Var_Delete(MAKE_EXPORTED, VAR_GLOBAL);
 	    free(varnames_freeIt);
+	}
+    }
+}
 /* See Var_Set for documentation. */
 void
 Var_Set_with_flags(const char *name, const char *val, GNode *ctxt,
 		   VarSet_Flags flags)
+{
     const char *unexpanded_name = name;
     char *name_freeIt = NULL;
     Var *v;
     assert(val != NULL);
     if (strchr(name, '$') != NULL) {
 	(void)Var_Subst(name, ctxt, VARE_WANTRES, &name_freeIt);
 	/* TODO: handle errors */
 	name = name_freeIt;
+    }
     if (name[0] == '\0') {
 	VAR_DEBUG2("Var_Set(\"%s\", \"%s\", ...) "
 		   "name expands to empty string - ignored\n",
 		   unexpanded_name, val);
 	free(name_freeIt);
 	return;
+    }
     if (ctxt == VAR_GLOBAL) {
 	v = VarFind(name, VAR_CMDLINE, 0);
 	if (v != NULL) {
 	    if (v->flags & VAR_FROM_CMD) {
 		VAR_DEBUG3("%s:%s = %s ignored!\n", ctxt->name, name, val);
 		goto out;
+	    }
 	    VarFreeEnv(v, TRUE);
+	}
+    }
     /*
      * We only look for a variable in the given context since anything set
      * here will override anything in a lower context, so there's not much
      * point in searching them all just to save a bit of memory...
      */
     v = VarFind(name, ctxt, 0);
     if (v == NULL) {
 	if (ctxt == VAR_CMDLINE && !(flags & VAR_NO_EXPORT)) {
 	    /*
 	     * This var would normally prevent the same name being added
 	     * to VAR_GLOBAL, so delete it from there if needed.
 	     * Otherwise -V name may show the wrong value.
 	     */
 	    Var_Delete(name, VAR_GLOBAL);
+	}
 	VarAdd(name, val, ctxt, flags);
     } else {
 	if ((v->flags & VAR_READONLY) && !(flags & VAR_SET_READONLY)) {
 	    VAR_DEBUG3("%s:%s = %s ignored (read-only)\n",
 		       ctxt->name, name, val);
 	    goto out;
+	}
 	Buf_Empty(&v->val);
 	if (val)
 	    Buf_AddStr(&v->val, val);
 	VAR_DEBUG3("%s:%s = %s\n", ctxt->name, name, val);
 	if (v->flags & VAR_EXPORTED) {
 	    Var_Export1(name, VAR_EXPORT_PARENT);
+	}
+    }
     /*
      * Any variables given on the command line are automatically exported
      * to the environment (as per POSIX standard)
      * Other than internals.
      */
     if (ctxt == VAR_CMDLINE && !(flags & VAR_NO_EXPORT) && name[0] != '.') {
 	if (v == NULL) {
 	    /* we just added it */
 	    v = VarFind(name, ctxt, 0);
+	}
 	if (v != NULL)
 	    v->flags |= VAR_FROM_CMD;
 	/*
 	 * If requested, don't export these in the environment
 	 * individually.  We still put them in MAKEOVERRIDES so
 	 * that the command-line settings continue to override
 	 * Makefile settings.
 	 */
 	if (!opts.varNoExportEnv)
 	    setenv(name, val ? val : "", 1);
 	Var_Append(MAKEOVERRIDES, name, VAR_GLOBAL);
+    }
     if (name[0] == '.' && strcmp(name, MAKE_SAVE_DOLLARS) == 0)
 	save_dollars = s2Boolean(val, save_dollars);
 out:
     free(name_freeIt);
     if (v != NULL)
 	VarFreeEnv(v, TRUE);
+}
 /*-
  *-----------------------------------------------------------------------
  * Var_Set --
  *	Set the variable name to the value val in the given context.
+ *
  *	If the variable doesn't yet exist, it is created.
  *	Otherwise the new value overwrites and replaces the old value.
+ *
  * Input:
  *	name		name of variable to set
  *	val		value to give to the variable
  *	ctxt		context in which to set it
+ *
  * Notes:
  *	The variable is searched for only in its context before being
  *	created in that context. I.e. if the context is VAR_GLOBAL,
  *	only VAR_GLOBAL->context is searched. Likewise if it is VAR_CMDLINE,
  *	only VAR_CMDLINE->context is searched. This is done to avoid the
  *	literally thousands of unnecessary strcmp's that used to be done to
  *	set, say, $(@) or $(<).
  *	If the context is VAR_GLOBAL though, we check if the variable
  *	was set in VAR_CMDLINE from the command line and skip it if so.
  *-----------------------------------------------------------------------
  */
 void
 Var_Set(const char *name, const char *val, GNode *ctxt)
+{
     Var_Set_with_flags(name, val, ctxt, 0);
+}
 /*-
  *-----------------------------------------------------------------------
  * Var_Append --
  *	The variable of the given name has the given value appended to it in
  *	the given context.
+ *
  *	If the variable doesn't exist, it is created. Otherwise the strings
  *	are concatenated, with a space in between.
+ *
  * Input:
  *	name		name of variable to modify
  *	val		string to append to it
  *	ctxt		context in which this should occur
+ *
  * Notes:
  *	Only if the variable is being sought in the global context is the
  *	environment searched.
  *	XXX: Knows its calling circumstances in that if called with ctxt
  *	an actual target, it will only search that context since only
  *	a local variable could be being appended to. This is actually
  *	a big win and must be tolerated.
  *-----------------------------------------------------------------------
  */
 void
 Var_Append(const char *name, const char *val, GNode *ctxt)
+{
     char *name_freeIt = NULL;
     Var *v;
     assert(val != NULL);
     if (strchr(name, '$') != NULL) {
 	const char *unexpanded_name = name;
 	(void)Var_Subst(name, ctxt, VARE_WANTRES, &name_freeIt);
 	/* TODO: handle errors */
 	name = name_freeIt;
 	if (name[0] == '\0') {
 	    VAR_DEBUG2("Var_Append(\"%s\", \"%s\", ...) "
 		       "name expands to empty string - ignored\n",
 		       unexpanded_name, val);
 	    free(name_freeIt);
 	    return;
+	}
+    }
     v = VarFind(name, ctxt, ctxt == VAR_GLOBAL);
     if (v == NULL) {
 	Var_Set(name, val, ctxt);
     } else if (v->flags & VAR_READONLY) {
         VAR_DEBUG1("Ignoring append to %s since it is read-only\n", name);
     } else if (ctxt == VAR_CMDLINE || !(v->flags & VAR_FROM_CMD)) {
 	Buf_AddByte(&v->val, ' ');
 	Buf_AddStr(&v->val, val);
 	VAR_DEBUG3("%s:%s = %s\n",
 		   ctxt->name, name, Buf_GetAll(&v->val, NULL));
 	if (v->flags & VAR_FROM_ENV) {
 	    HashEntry *h;
 	    /*
 	     * If the original variable came from the environment, we
 	     * have to install it in the global context (we could place
 	     * it in the environment, but then we should provide a way to
 	     * export other variables...)
 	     */
 	    v->flags &= ~(unsigned)VAR_FROM_ENV;
 	    h = HashTable_CreateEntry(&ctxt->context, name, NULL);
 	    HashEntry_Set(h, v);
+	}
+    }
     free(name_freeIt);
+}
 /* See if the given variable exists, in the given context or in other
  * fallback contexts.
+ *
  * Input:
  *	name		Variable to find
  *	ctxt		Context in which to start search
  */
 Boolean
 Var_Exists(const char *name, GNode *ctxt)
+{
     char *name_freeIt = NULL;
     Var *v;
     if (strchr(name, '$') != NULL) {
 	(void)Var_Subst(name, ctxt, VARE_WANTRES, &name_freeIt);
 	/* TODO: handle errors */
 	name = name_freeIt;
+    }
     v = VarFind(name, ctxt, TRUE);
     free(name_freeIt);
     if (v == NULL)
 	return FALSE;
     (void)VarFreeEnv(v, TRUE);
     return TRUE;
+}
 /*-
  *-----------------------------------------------------------------------
  * Var_Value --
  *	Return the unexpanded value of the given variable in the given
  *	context, or the usual contexts.
+ *
  * Input:
  *	name		name to find
  *	ctxt		context in which to search for it
+ *
  * Results:
  *	The value if the variable exists, NULL if it doesn't.
  *	If the returned value is not NULL, the caller must free *freeIt
  *	as soon as the returned value is no longer needed.
  *-----------------------------------------------------------------------
  */
 const char *
 Var_Value(const char *name, GNode *ctxt, char **freeIt)
+{
     Var *v = VarFind(name, ctxt, TRUE);
     char *p;
     *freeIt = NULL;
     if (v == NULL)
 	return NULL;
     p = Buf_GetAll(&v->val, NULL);
     if (VarFreeEnv(v, FALSE))
 	*freeIt = p;
     return p;
+}
 /* SepBuf is a string being built from "words", interleaved with separators. */
 typedef struct SepBuf {
     Buffer buf;
     Boolean needSep;
     char sep;			/* usually ' ', but see the :ts modifier */
 } SepBuf;
 static void
 SepBuf_Init(SepBuf *buf, char sep)
+{
     Buf_Init(&buf->buf, 32 /* bytes */);
     buf->needSep = FALSE;
     buf->sep = sep;
+}
 static void
 SepBuf_Sep(SepBuf *buf)
+{
     buf->needSep = TRUE;
+}
 static void
 SepBuf_AddBytes(SepBuf *buf, const char *mem, size_t mem_size)
+{
     if (mem_size == 0)
 	return;
     if (buf->needSep && buf->sep != '\0') {
 	Buf_AddByte(&buf->buf, buf->sep);
 	buf->needSep = FALSE;
+    }
     Buf_AddBytes(&buf->buf, mem, mem_size);
+}
 static void
 SepBuf_AddBytesBetween(SepBuf *buf, const char *start, const char *end)
+{
     SepBuf_AddBytes(buf, start, (size_t)(end - start));
+}
 static void
 SepBuf_AddStr(SepBuf *buf, const char *str)
+{
     SepBuf_AddBytes(buf, str, strlen(str));
+}
 static char *
 SepBuf_Destroy(SepBuf *buf, Boolean free_buf)
+{
     return Buf_Destroy(&buf->buf, free_buf);
+}
 /* This callback for ModifyWords gets a single word from an expression and
  * typically adds a modification of this word to the buffer. It may also do
  * nothing or add several words. */
 typedef void (*ModifyWordsCallback)(const char *word, SepBuf *buf, void *data);
 /* Callback for ModifyWords to implement the :H modifier.
  * Add the dirname of the given word to the buffer. */
 static void
 ModifyWord_Head(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
     const char *slash = strrchr(word, '/');
     if (slash != NULL)
 	SepBuf_AddBytesBetween(buf, word, slash);
     else
 	SepBuf_AddStr(buf, ".");
+}
 /* Callback for ModifyWords to implement the :T modifier.
  * Add the basename of the given word to the buffer. */
 static void
 ModifyWord_Tail(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
     const char *slash = strrchr(word, '/');
     const char *base = slash != NULL ? slash + 1 : word;
     SepBuf_AddStr(buf, base);
+}
 /* Callback for ModifyWords to implement the :E modifier.
  * Add the filename suffix of the given word to the buffer, if it exists. */
 static void
 ModifyWord_Suffix(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
     const char *dot = strrchr(word, '.');
     if (dot != NULL)
 	SepBuf_AddStr(buf, dot + 1);
+}
 /* Callback for ModifyWords to implement the :R modifier.
  * Add the basename of the given word to the buffer. */
 static void
 ModifyWord_Root(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
     const char *dot = strrchr(word, '.');
     size_t len = dot != NULL ? (size_t)(dot - word) : strlen(word);
     SepBuf_AddBytes(buf, word, len);
+}
 /* Callback for ModifyWords to implement the :M modifier.
  * Place the word in the buffer if it matches the given pattern. */
 static void
 ModifyWord_Match(const char *word, SepBuf *buf, void *data)
+{
     const char *pattern = data;
     VAR_DEBUG2("VarMatch [%s] [%s]\n", word, pattern);
     if (Str_Match(word, pattern))
 	SepBuf_AddStr(buf, word);
+}
 /* Callback for ModifyWords to implement the :N modifier.
  * Place the word in the buffer if it doesn't match the given pattern. */
 static void
 ModifyWord_NoMatch(const char *word, SepBuf *buf, void *data)
+{
     const char *pattern = data;
     if (!Str_Match(word, pattern))
 	SepBuf_AddStr(buf, word);
+}
 #ifdef SYSVVARSUB
 /*-
  *-----------------------------------------------------------------------
  * Str_SYSVMatch --
  *	Check word against pattern for a match (% is wild),
+ *
  * Input:
  *	word		Word to examine
  *	pattern		Pattern to examine against
+ *
  * Results:
  *	Returns the start of the match, or NULL.
  *	*match_len returns the length of the match, if any.
  *	*hasPercent returns whether the pattern contains a percent.
  *-----------------------------------------------------------------------
  */
 static const char *
 Str_SYSVMatch(const char *word, const char *pattern, size_t *match_len,
 	      Boolean *hasPercent)
+{
     const char *p = pattern;
     const char *w = word;
     const char *percent;
     size_t w_len;
     size_t p_len;
     const char *w_tail;
     *hasPercent = FALSE;
     if (*p == '\0') {		/* ${VAR:=suffix} */
 	*match_len = strlen(w);	/* Null pattern is the whole string */
 	return w;
+    }
     percent = strchr(p, '%');
     if (percent != NULL) {	/* ${VAR:...%...=...} */
 	*hasPercent = TRUE;
 	if (*w == '\0')
 	    return NULL;	/* empty word does not match pattern */
 	/* check that the prefix matches */
 	for (; p != percent && *w != '\0' && *w == *p; w++, p++)
 	    continue;
 	if (p != percent)
 	    return NULL;	/* No match */
 	p++;			/* Skip the percent */
 	if (*p == '\0') {
 	    /* No more pattern, return the rest of the string */
 	    *match_len = strlen(w);
 	    return w;
+	}
+    }
     /* Test whether the tail matches */
     w_len = strlen(w);
     p_len = strlen(p);
     if (w_len < p_len)
 	return NULL;
     w_tail = w + w_len - p_len;
     if (memcmp(p, w_tail, p_len) != 0)
 	return NULL;
     *match_len = (size_t)(w_tail - w);
     return w;
+}
 struct ModifyWord_SYSVSubstArgs {
     GNode *ctx;
     const char *lhs;
     const char *rhs;
 };
 /* Callback for ModifyWords to implement the :%.from=%.to modifier. */
 static void
 ModifyWord_SYSVSubst(const char *word, SepBuf *buf, void *data)
+{
     const struct ModifyWord_SYSVSubstArgs *args = data;
     char *rhs_expanded;
     const char *rhs;
     const char *percent;
     size_t match_len;
     Boolean lhsPercent;
     const char *match = Str_SYSVMatch(word, args->lhs, &match_len, &lhsPercent);
     if (match == NULL) {
 	SepBuf_AddStr(buf, word);
 	return;
+    }
     /* Append rhs to the buffer, substituting the first '%' with the
      * match, but only if the lhs had a '%' as well. */
     (void)Var_Subst(args->rhs, args->ctx, VARE_WANTRES, &rhs_expanded);
     /* TODO: handle errors */
     rhs = rhs_expanded;
     percent = strchr(rhs, '%');
     if (percent != NULL && lhsPercent) {
 	/* Copy the prefix of the replacement pattern */
 	SepBuf_AddBytesBetween(buf, rhs, percent);
 	rhs = percent + 1;
+    }
     if (percent != NULL || !lhsPercent)
 	SepBuf_AddBytes(buf, match, match_len);
     /* Append the suffix of the replacement pattern */
     SepBuf_AddStr(buf, rhs);
     free(rhs_expanded);
+}
 #endif
 struct ModifyWord_SubstArgs {
     const char	*lhs;
     size_t	lhsLen;
     const char	*rhs;
     size_t	rhsLen;
     VarPatternFlags pflags;
     Boolean	matched;
 };
 /* Callback for ModifyWords to implement the :S,from,to, modifier.
  * Perform a string substitution on the given word. */
 static void
 ModifyWord_Subst(const char *word, SepBuf *buf, void *data)
+{
     size_t wordLen = strlen(word);
     struct ModifyWord_SubstArgs *args = data;
     const char *match;
     if ((args->pflags & VARP_SUB_ONE) && args->matched)
 	goto nosub;
     if (args->pflags & VARP_ANCHOR_START) {
 	if (wordLen < args->lhsLen ||
 	    memcmp(word, args->lhs, args->lhsLen) != 0)
 	    goto nosub;
 	if (args->pflags & VARP_ANCHOR_END) {
 	    if (wordLen != args->lhsLen)
 		goto nosub;
 	    /* :S,^whole$,replacement, */
 	    SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
 	    args->matched = TRUE;
 	} else {
 	    /* :S,^prefix,replacement, */
 	    SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
 	    SepBuf_AddBytes(buf, word + args->lhsLen, wordLen - args->lhsLen);
 	    args->matched = TRUE;
+	}
 	return;
+    }
     if (args->pflags & VARP_ANCHOR_END) {
 	const char *start;
 	if (wordLen < args->lhsLen)
 	    goto nosub;
 	start = word + (wordLen - args->lhsLen);
 	if (memcmp(start, args->lhs, args->lhsLen) != 0)
 	    goto nosub;
 	/* :S,suffix$,replacement, */
 	SepBuf_AddBytesBetween(buf, word, start);
 	SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
 	args->matched = TRUE;
 	return;
+    }
     if (args->lhs[0] == '\0')
 	goto nosub;
     /* unanchored case, may match more than once */
     while ((match = strstr(word, args->lhs)) != NULL) {
 	SepBuf_AddBytesBetween(buf, word, match);
 	SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
 	args->matched = TRUE;
 	wordLen -= (size_t)(match - word) + args->lhsLen;
 	word += (size_t)(match - word) + args->lhsLen;
 	if (wordLen == 0 || !(args->pflags & VARP_SUB_GLOBAL))
 	    break;
+    }
 nosub:
     SepBuf_AddBytes(buf, word, wordLen);
+}
 #ifndef NO_REGEX
 /* Print the error caused by a regcomp or regexec call. */
 static void
 VarREError(int reerr, regex_t *pat, const char *str)
+{
     size_t errlen = regerror(reerr, pat, 0, 0);
     char *errbuf = bmake_malloc(errlen);
     regerror(reerr, pat, errbuf, errlen);
     Error("%s: %s", str, errbuf);
     free(errbuf);
+}
 struct ModifyWord_SubstRegexArgs {
     regex_t re;
     size_t nsub;
     char *replace;
     VarPatternFlags pflags;
     Boolean matched;
 };
 /* Callback for ModifyWords to implement the :C/from/to/ modifier.
  * Perform a regex substitution on the given word. */
 static void
 ModifyWord_SubstRegex(const char *word, SepBuf *buf, void *data)
+{
     struct ModifyWord_SubstRegexArgs *args = data;
     int xrv;
     const char *wp = word;
     char *rp;
     int flags = 0;
     regmatch_t m[10];
     if ((args->pflags & VARP_SUB_ONE) && args->matched)
 	goto nosub;
 tryagain:
     xrv = regexec(&args->re, wp, args->nsub, m, flags);
     switch (xrv) {
     case 0:
 	args->matched = TRUE;
 	SepBuf_AddBytes(buf, wp, (size_t)m[0].rm_so);
 	for (rp = args->replace; *rp; rp++) {
 	    if (*rp == '\\' && (rp[1] == '&' || rp[1] == '\\')) {
 		SepBuf_AddBytes(buf, rp + 1, 1);
 		rp++;
 		continue;
+	    }
 	    if (*rp == '&') {
 		SepBuf_AddBytesBetween(buf, wp + m[0].rm_so, wp + m[0].rm_eo);
 		continue;
+	    }
 	    if (*rp != '\\' || !ch_isdigit(rp[1])) {
 		SepBuf_AddBytes(buf, rp, 1);
 		continue;
+	    }
 	    {			/* \0 to \9 backreference */
 		size_t n = (size_t)(rp[1] - '0');
 		rp++;
 		if (n >= args->nsub) {
 		    Error("No subexpression \\%zu", n);
 		} else if (m[n].rm_so == -1 && m[n].rm_eo == -1) {
 		    Error("No match for subexpression \\%zu", n);
 		} else {
 		    SepBuf_AddBytesBetween(buf, wp + m[n].rm_so,
 					   wp + m[n].rm_eo);
+		}
+	    }
+	}
 	wp += m[0].rm_eo;
 	if (args->pflags & VARP_SUB_GLOBAL) {
 	    flags |= REG_NOTBOL;
 	    if (m[0].rm_so == 0 && m[0].rm_eo == 0) {
 		SepBuf_AddBytes(buf, wp, 1);
 		wp++;
+	    }
 	    if (*wp)
 		goto tryagain;
+	}
 	if (*wp) {
 	    SepBuf_AddStr(buf, wp);
+	}
 	break;
     default:
 	VarREError(xrv, &args->re, "Unexpected regex error");
 	/* FALLTHROUGH */
     case REG_NOMATCH:
     nosub:
 	SepBuf_AddStr(buf, wp);
 	break;
+    }
+}
 #endif
 struct ModifyWord_LoopArgs {
     GNode	*ctx;
     char	*tvar;		/* name of temporary variable */
     char	*str;		/* string to expand */
     VarEvalFlags eflags;
 };
 /* Callback for ModifyWords to implement the :@var@...@ modifier of ODE make. */
 static void
 ModifyWord_Loop(const char *word, SepBuf *buf, void *data)
+{
     const struct ModifyWord_LoopArgs *args;
     char *s;
     if (word[0] == '\0')
 	return;
     args = data;
     Var_Set_with_flags(args->tvar, word, args->ctx, VAR_NO_EXPORT);
     (void)Var_Subst(args->str, args->ctx, args->eflags, &s);
     /* TODO: handle errors */
     VAR_DEBUG4("ModifyWord_Loop: in \"%s\", replace \"%s\" with \"%s\" "
 	       "to \"%s\"\n",
 	       word, args->tvar, args->str, s);
     if (s[0] == '\n' || Buf_EndsWith(&buf->buf, '\n'))
 	buf->needSep = FALSE;
     SepBuf_AddStr(buf, s);
     free(s);
+}
 /*-
  * Implements the :[first..last] modifier.
  * This is a special case of ModifyWords since we want to be able
  * to scan the list backwards if first > last.
  */
 static char *
 VarSelectWords(char sep, Boolean oneBigWord, const char *str, int first,
 	       int last)
+{
     Words words;
     int len, start, end, step;
     int i;
     SepBuf buf;
     SepBuf_Init(&buf, sep);
     if (oneBigWord) {
 	/* fake what Str_Words() would do if there were only one word */
 	words.len = 1;
 	words.words = bmake_malloc((words.len + 1) * sizeof(char *));
 	words.freeIt = bmake_strdup(str);
 	words.words[0] = words.freeIt;
 	words.words[1] = NULL;
     } else {
 	words = Str_Words(str, FALSE);
+    }
     /*
      * Now sanitize the given range.
      * If first or last are negative, convert them to the positive equivalents
      * (-1 gets converted to ac, -2 gets converted to (ac - 1), etc.).
      */
     len = (int)words.len;
     if (first < 0)
 	first += len + 1;
     if (last < 0)
 	last += len + 1;
     /*
      * We avoid scanning more of the list than we need to.
      */
     if (first > last) {
 	start = (first > len ? len : first) - 1;
 	end = last < 1 ? 0 : last - 1;
 	step = -1;
     } else {
 	start = first < 1 ? 0 : first - 1;
 	end = last > len ? len : last;
 	step = 1;
+    }
     for (i = start; (step < 0) == (i >= end); i += step) {
 	SepBuf_AddStr(&buf, words.words[i]);
 	SepBuf_Sep(&buf);
+    }
     Words_Free(words);
     return SepBuf_Destroy(&buf, FALSE);
+}
 /* Callback for ModifyWords to implement the :tA modifier.
  * Replace each word with the result of realpath() if successful. */
 static void
 ModifyWord_Realpath(const char *word, SepBuf *buf, void *data MAKE_ATTR_UNUSED)
+{
     struct stat st;
     char rbuf[MAXPATHLEN];
     const char *rp = cached_realpath(word, rbuf);
     if (rp != NULL && *rp == '/' && stat(rp, &st) == 0)
 	word = rp;
     SepBuf_AddStr(buf, word);
+}
 /*-
  *-----------------------------------------------------------------------
  * Modify each of the words of the passed string using the given function.
+ *
  * Input:
  *	str		String whose words should be modified
  *	modifyWord	Function that modifies a single word
  *	modifyWord_args Custom arguments for modifyWord
+ *
  * Results:
  *	A string of all the words modified appropriately.
  *-----------------------------------------------------------------------
  */
 static char *
 ModifyWords(GNode *ctx, char sep, Boolean oneBigWord, const char *str,
 	    ModifyWordsCallback modifyWord, void *modifyWord_args)
+{
     SepBuf result;