 @@ -1,1469 +1,1463 @@
-/*	$NetBSD: var.c,v 1.882 2021/03/14 20:18:33 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.883 2021/03/14 20:23:29 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
  *	Var_SetExpand
  *			Set the value of the variable, creating it if
  *			necessary.
+ *
  *	Var_Append
  *	Var_AppendExpand
  *			Append more characters to the variable, creating it if
  *			necessary. A space is placed between the old value and
  *			the new one.
+ *
  *	Var_Exists
  *	Var_ExistsExpand
  *			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
  *	Var_DeleteExpand
  *			Delete a variable.
+ *
  *	Var_ReexportVars
  *			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 scope.
+ *
  * XXX: There's a lot of almost duplicate code in these functions that only
  *  differs in subtle details that are not mentioned in the manual page.
  */
 #include <sys/stat.h>
 #ifndef NO_REGEX
 #include <sys/types.h>
 #include <regex.h>
 #endif
 #include <errno.h>
 #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.882 2021/03/14 20:18:33 rillig Exp $");
+MAKE_RCSID("$NetBSD: var.c,v 1.883 2021/03/14 20:23:29 rillig Exp $");
 typedef enum VarFlags {
 	VFL_NONE	= 0,
 	/*
 	 * The variable's value is currently being used by Var_Parse or
 	 * Var_Subst.  This marker is used to avoid endless recursion.
 	 */
 	VFL_IN_USE	= 1 << 0,
 	/*
 	 * 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.
 	 */
 	VFL_FROM_ENV	= 1 << 1,
 	/*
 	 * The variable is exported to the environment, to be used by child
 	 * processes.
 	 */
 	VFL_EXPORTED	= 1 << 2,
 	/*
 	 * 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.
 	 */
 	VFL_REEXPORT	= 1 << 3,
 	/* The variable came from the command line. */
 	VFL_FROM_CMD	= 1 << 4,
 	/*
 	 * The variable value cannot be changed anymore, and the variable
 	 * cannot be deleted.  Any attempts to do so are silently ignored,
 	 * they are logged with -dv though.
+	 *
 	 * See VAR_SET_READONLY.
 	 */
 	VFL_READONLY	= 1 << 5
 } VarFlags;
 /*
  * 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: scope variables, environment variables,
  * undefined variables.
+ *
  * Scope variables are stored in a GNode.scope.  The only way to undefine
  * a scope 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 scope variables, it aliases the corresponding HashEntry name.
 	 * For environment and undefined variables, it is allocated.
 	 */
 	FStr name;
 	/* The unexpanded value of the variable. */
 	Buffer val;
 	/* Miscellaneous status flags. */
 	VarFlags flags;
 } Var;
 /*
  * Exporting variables is expensive and may leak memory, so skip it if we
  * can.
+ *
  * To avoid this, it might be worth encapsulating the environment variables
  * in a separate data structure called EnvVars.
  */
 typedef enum VarExportedMode {
 	VAR_EXPORTED_NONE,
 	VAR_EXPORTED_SOME,
 	VAR_EXPORTED_ALL
 } VarExportedMode;
 typedef enum UnexportWhat {
 	/* Unexport the variables given by name. */
 	UNEXPORT_NAMED,
 	/*
 	 * Unexport all globals previously exported, but keep the environment
 	 * inherited from the parent.
 	 */
 	UNEXPORT_ALL,
 	/*
 	 * Unexport all globals previously exported and clear the environment
 	 * inherited from the parent.
 	 */
 	UNEXPORT_ENV
 } UnexportWhat;
 /* Flags for pattern matching in the :S and :C modifiers */
 typedef struct VarPatternFlags {
 	/* Replace as often as possible ('g') */
 	Boolean subGlobal: 1;
 	/* Replace only once ('1') */
 	Boolean subOnce: 1;
 	/* Match at start of word ('^') */
 	Boolean anchorStart: 1;
 	/* Match at end of word ('$') */
 	Boolean anchorEnd: 1;
 } VarPatternFlags;
 /* SepBuf builds a string from words interleaved with separators. */
 typedef struct SepBuf {
 	Buffer buf;
 	Boolean needSep;
 	/* Usually ' ', but see the ':ts' modifier. */
 	char sep;
 } SepBuf;
 ENUM_FLAGS_RTTI_4(VarEvalFlags,
 		  VARE_UNDEFERR, VARE_WANTRES, VARE_KEEP_DOLLAR,
 		  VARE_KEEP_UNDEF);
 /*
  * 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.
+ *
  * See VARE_KEEP_UNDEF.
  */
 static char varUndefined[] = "";
 /*
  * 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;
 /*
  * A scope collects variable names and their values.
+ *
  * The main scope is SCOPE_GLOBAL, which contains the variables that are set
  * in the makefiles.  SCOPE_INTERNAL acts as a fallback for SCOPE_GLOBAL and
  * contains some internal make variables.  These internal variables can thus
  * be overridden, they can also be restored by undefining the overriding
  * variable.
+ *
  * SCOPE_CMDLINE contains variables from the command line arguments.  These
  * override variables from SCOPE_GLOBAL.
+ *
  * There is no scope for environment variables, these are generated on-the-fly
  * whenever they are referenced.  If there were such a scope, each change to
  * environment variables would have to be reflected in that scope, which may
  * be simpler or more complex than the current implementation.
+ *
  * Each target has its own scope, containing the 7 target-local variables
  * .TARGET, .ALLSRC, etc.  No other variables are in these scopes.
  */
 GNode *SCOPE_CMDLINE;
 GNode *SCOPE_GLOBAL;
 GNode *SCOPE_INTERNAL;
 ENUM_FLAGS_RTTI_6(VarFlags,
 		  VFL_IN_USE, VFL_FROM_ENV,
 		  VFL_EXPORTED, VFL_REEXPORT, VFL_FROM_CMD, VFL_READONLY);
 static VarExportedMode var_exportedVars = VAR_EXPORTED_NONE;
 static Var *
 VarNew(FStr name, const char *value, VarFlags flags)
+{
 	size_t value_len = strlen(value);
 	Var *var = bmake_malloc(sizeof *var);
 	var->name = name;
 	Buf_InitSize(&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 == NULL)
 					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 *scope, const char *varname, unsigned int hash)
+{
 	return HashTable_FindValueHash(&scope->vars, varname, hash);
+}
 /*
  * Find the variable in the scope, and maybe in other scopes as well.
+ *
  * Input:
  *	name		name to find, is not expanded any further
  *	scope		scope in which to look first
  *	elsewhere	TRUE to look in other scopes as well
+ *
  * Results:
  *	The found variable, or 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 *scope, Boolean elsewhere)
+{
 	Var *var;
 	unsigned int nameHash;
 	/* Replace '.TARGET' with '@', likewise for other local variables. */
 	name = CanonicalVarname(name);
 	nameHash = Hash_Hash(name);
 	var = GNode_FindVar(scope, name, nameHash);
 	if (!elsewhere)
 		return var;
 	if (var == NULL && scope != SCOPE_CMDLINE)
 		var = GNode_FindVar(SCOPE_CMDLINE, name, nameHash);
 	if (!opts.checkEnvFirst && var == NULL && scope != SCOPE_GLOBAL) {
 		var = GNode_FindVar(SCOPE_GLOBAL, name, nameHash);
 		if (var == NULL && scope != SCOPE_INTERNAL) {
 			/* SCOPE_INTERNAL is subordinate to SCOPE_GLOBAL */
 			var = GNode_FindVar(SCOPE_INTERNAL, name, nameHash);
+		}
+	}
 	if (var == NULL) {
 		char *env;
 		if ((env = getenv(name)) != NULL) {
 			char *varname = bmake_strdup(name);
 			return VarNew(FStr_InitOwn(varname), env, VFL_FROM_ENV);
+		}
 		if (opts.checkEnvFirst && scope != SCOPE_GLOBAL) {
 			var = GNode_FindVar(SCOPE_GLOBAL, name, nameHash);
 			if (var == NULL && scope != SCOPE_INTERNAL)
 				var = GNode_FindVar(SCOPE_INTERNAL, name,
 				    nameHash);
 			return var;
+		}
 		return NULL;
+	}
 	return var;
+}
-/*
+/* If the variable is an environment variable, free it, including its value. */
  * If the variable is an environment variable, free it, including its value.
  * Results:
  *	TRUE if it was an environment variable,
  *	FALSE if it is still a regular variable.
  */
 static void
 VarFreeEnv(Var *v)
+{
 	if (!(v->flags & VFL_FROM_ENV))
 		return;
 	FStr_Done(&v->name);
 	Buf_Done(&v->val);
 	free(v);
+}
 /* Add a new variable of the given name and value to the given scope. */
 static Var *
 VarAdd(const char *name, const char *value, GNode *scope, VarSetFlags flags)
+{
 	HashEntry *he = HashTable_CreateEntry(&scope->vars, name, NULL);
 	Var *v = VarNew(FStr_InitRefer(/* aliased to */ he->key), value,
 	    flags & VAR_SET_READONLY ? VFL_READONLY : VFL_NONE);
 	HashEntry_Set(he, v);
 	DEBUG3(VAR, "%s:%s = %s\n", scope->name, name, value);
 	return v;
+}
 /*
  * Remove a variable from a scope, freeing all related memory as well.
  * The variable name is kept as-is, it is not expanded.
  */
 void
 Var_Delete(GNode *scope, const char *varname)
+{
 	HashEntry *he = HashTable_FindEntry(&scope->vars, varname);
 	Var *v;
 	if (he == NULL) {
 		DEBUG2(VAR, "%s:delete %s (not found)\n", scope->name, varname);
 		return;
+	}
 	DEBUG2(VAR, "%s:delete %s\n", scope->name, varname);
 	v = he->value;
 	if (v->flags & VFL_EXPORTED)
 		unsetenv(v->name.str);
 	if (strcmp(v->name.str, MAKE_EXPORTED) == 0)
 		var_exportedVars = VAR_EXPORTED_NONE;
 	assert(v->name.freeIt == NULL);
 	HashTable_DeleteEntry(&scope->vars, he);
 	Buf_Done(&v->val);
 	free(v);
+}
 /*
  * Remove a variable from a scope, freeing all related memory as well.
  * The variable name is expanded once.
  */
 void
 Var_DeleteExpand(GNode *scope, const char *name)
+{
 	FStr varname = FStr_InitRefer(name);
 	if (strchr(varname.str, '$') != NULL) {
 		char *expanded;
 		(void)Var_Subst(varname.str, SCOPE_GLOBAL, VARE_WANTRES,
 		    &expanded);
 		/* TODO: handle errors */
 		varname = FStr_InitOwn(expanded);
+	}
 	Var_Delete(scope, varname.str);
 	FStr_Done(&varname);
+}
 /*
  * Undefine one or more variables from the global scope.
  * The argument is expanded exactly once and then split into words.
  */
 void
 Var_Undef(const char *arg)
+{
 	VarParseResult vpr;
 	char *expanded;
 	Words varnames;
 	size_t i;
 	if (arg[0] == '\0') {
 		Parse_Error(PARSE_FATAL,
 		    "The .undef directive requires an argument");
 		return;
+	}
 	vpr = Var_Subst(arg, SCOPE_GLOBAL, VARE_WANTRES, &expanded);
 	if (vpr != VPR_OK) {
 		Parse_Error(PARSE_FATAL,
 		    "Error in variable names to be undefined");
 		return;
+	}
 	varnames = Str_Words(expanded, FALSE);
 	if (varnames.len == 1 && varnames.words[0][0] == '\0')
 		varnames.len = 0;
 	for (i = 0; i < varnames.len; i++) {
 		const char *varname = varnames.words[i];
 		Global_Delete(varname);
+	}
 	Words_Free(varnames);
 	free(expanded);
+}
 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 variables that should only appear in
 		 * local scope, skip it, else we can get Var_Subst
 		 * into a loop.
 		 */
 		switch (name[0]) {
 		case '@':
 		case '%':
 		case '*':
 		case '!':
 			return FALSE;
+		}
+	}
 	return TRUE;
+}
 static Boolean
 ExportVarEnv(Var *v)
+{
 	const char *name = v->name.str;
 	char *val = v->val.data;
 	char *expr;
 	if ((v->flags & VFL_EXPORTED) && !(v->flags & VFL_REEXPORT))
 		return FALSE;	/* nothing to do */
 	if (strchr(val, '$') == NULL) {
 		if (!(v->flags & VFL_EXPORTED))
 			setenv(name, val, 1);
 		return TRUE;
+	}
 	if (v->flags & VFL_IN_USE) {
 		/*
 		 * We recursed while exporting in a child.
 		 * This isn't going to end well, just skip it.
 		 */
 		return FALSE;
+	}
 	/* XXX: name is injected without escaping it */
 	expr = str_concat3("${", name, "}");
 	(void)Var_Subst(expr, SCOPE_GLOBAL, VARE_WANTRES, &val);
 	/* TODO: handle errors */
 	setenv(name, val, 1);
 	free(val);
 	free(expr);
 	return TRUE;
+}
 static Boolean
 ExportVarPlain(Var *v)
+{
 	if (strchr(v->val.data, '$') == NULL) {
 		setenv(v->name.str, v->val.data, 1);
 		v->flags |= VFL_EXPORTED;
 		v->flags &= ~(unsigned)VFL_REEXPORT;
 		return TRUE;
+	}
 	/*
 	 * Flag the variable as something we need to re-export.
 	 * No point actually exporting it now though,
 	 * the child process can do it at the last minute.
 	 * Avoid calling setenv more often than necessary since it can leak.
 	 */
 	v->flags |= VFL_EXPORTED | VFL_REEXPORT;
 	return TRUE;
+}
 static Boolean
 ExportVarLiteral(Var *v)
+{
 	if ((v->flags & VFL_EXPORTED) && !(v->flags & VFL_REEXPORT))
 		return FALSE;
 	if (!(v->flags & VFL_EXPORTED))
 		setenv(v->name.str, v->val.data, 1);
 	return TRUE;
+}
 /*
  * Mark a single variable to be exported later for subprocesses.
+ *
  * Internal variables (those starting with '.') are not exported.
  */
 static Boolean
 ExportVar(const char *name, VarExportMode mode)
+{
 	Var *v;
 	if (!MayExport(name))
 		return FALSE;
 	v = VarFind(name, SCOPE_GLOBAL, FALSE);
 	if (v == NULL)
 		return FALSE;
 	if (mode == VEM_ENV)
 		return ExportVarEnv(v);
 	else if (mode == VEM_PLAIN)
 		return ExportVarPlain(v);
 	else
 		return ExportVarLiteral(v);
+}
 /*
  * Actually export the variables that have been marked as needing to be
  * re-exported.
  */
 void
 Var_ReexportVars(void)
+{
 	char *xvarnames;
 	/*
 	 * Several make implementations 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[21];
 	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, &SCOPE_GLOBAL->vars);
 		while (HashIter_Next(&hi) != NULL) {
 			Var *var = hi.entry->value;
 			ExportVar(var->name.str, VEM_ENV);
+		}
 		return;
+	}
 	(void)Var_Subst("${" MAKE_EXPORTED ":O:u}", SCOPE_GLOBAL, VARE_WANTRES,
 	    &xvarnames);
 	/* TODO: handle errors */
 	if (xvarnames[0] != '\0') {
 		Words varnames = Str_Words(xvarnames, FALSE);
 		size_t i;
 		for (i = 0; i < varnames.len; i++)
 			ExportVar(varnames.words[i], VEM_ENV);
 		Words_Free(varnames);
+	}
 	free(xvarnames);
+}
 static void
 ExportVars(const char *varnames, Boolean isExport, VarExportMode mode)
 /* TODO: try to combine the parameters 'isExport' and 'mode'. */
+{
 	Words words = Str_Words(varnames, FALSE);
 	size_t i;
 	if (words.len == 1 && words.words[0][0] == '\0')
 		words.len = 0;
 	for (i = 0; i < words.len; i++) {
 		const char *varname = words.words[i];
 		if (!ExportVar(varname, mode))
 			continue;
 		if (var_exportedVars == VAR_EXPORTED_NONE)
 			var_exportedVars = VAR_EXPORTED_SOME;
 		if (isExport && mode == VEM_PLAIN)
 			Global_Append(MAKE_EXPORTED, varname);
+	}
 	Words_Free(words);
+}
 static void
 ExportVarsExpand(const char *uvarnames, Boolean isExport, VarExportMode mode)
+{
 	char *xvarnames;
 	(void)Var_Subst(uvarnames, SCOPE_GLOBAL, VARE_WANTRES, &xvarnames);
 	/* TODO: handle errors */
 	ExportVars(xvarnames, isExport, mode);
 	free(xvarnames);
+}
 /* Export the named variables, or all variables. */
 void
 Var_Export(VarExportMode mode, const char *varnames)
+{
 	if (mode == VEM_PLAIN && varnames[0] == '\0') {
 		var_exportedVars = VAR_EXPORTED_ALL; /* use with caution! */
 		return;
+	}
 	ExportVarsExpand(varnames, TRUE, mode);
+}
 void
 Var_ExportVars(const char *varnames)
+{
 	ExportVarsExpand(varnames, FALSE, VEM_PLAIN);
+}
 extern char **environ;
 static void
 ClearEnv(void)
+{
 	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 != NULL) {
 			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 != NULL && *cp != '\0')
 		setenv(MAKE_LEVEL_ENV, cp, 1);
+}
 static void
 GetVarnamesToUnexport(Boolean isEnv, const char *arg,
 		      FStr *out_varnames, UnexportWhat *out_what)
+{
 	UnexportWhat what;
 	FStr varnames = FStr_InitRefer("");
 	if (isEnv) {
 		if (arg[0] != '\0') {
 			Parse_Error(PARSE_FATAL,
 			    "The directive .unexport-env does not take "
 			    "arguments");
 			/* continue anyway */
+		}
 		what = UNEXPORT_ENV;
 	} else {
 		what = arg[0] != '\0' ? UNEXPORT_NAMED : UNEXPORT_ALL;
 		if (what == UNEXPORT_NAMED)
 			varnames = FStr_InitRefer(arg);
+	}
 	if (what != UNEXPORT_NAMED) {
 		char *expanded;
 		/* Using .MAKE.EXPORTED */
 		(void)Var_Subst("${" MAKE_EXPORTED ":O:u}", SCOPE_GLOBAL,
 		    VARE_WANTRES, &expanded);
 		/* TODO: handle errors */
 		varnames = FStr_InitOwn(expanded);
+	}
 	*out_varnames = varnames;
 	*out_what = what;
+}
 static void
 UnexportVar(const char *varname, UnexportWhat what)
+{
 	Var *v = VarFind(varname, SCOPE_GLOBAL, FALSE);
 	if (v == NULL) {
 		DEBUG1(VAR, "Not unexporting \"%s\" (not found)\n", varname);
 		return;
+	}
 	DEBUG1(VAR, "Unexporting \"%s\"\n", varname);
 	if (what != UNEXPORT_ENV &&
 	    (v->flags & VFL_EXPORTED) && !(v->flags & VFL_REEXPORT))
 		unsetenv(v->name.str);
 	v->flags &= ~(unsigned)(VFL_EXPORTED | VFL_REEXPORT);
 	if (what == UNEXPORT_NAMED) {
 		/* Remove the variable names from .MAKE.EXPORTED. */
 		/* XXX: v->name is injected without escaping it */
 		char *expr = str_concat3("${" MAKE_EXPORTED ":N",
 		    v->name.str, "}");
 		char *cp;
 		(void)Var_Subst(expr, SCOPE_GLOBAL, VARE_WANTRES, &cp);
 		/* TODO: handle errors */
 		Global_Set(MAKE_EXPORTED, cp);
 		free(cp);
 		free(expr);
+	}
+}
 static void
 UnexportVars(FStr *varnames, UnexportWhat what)
+{
 	size_t i;
 	Words words;
 	if (what == UNEXPORT_ENV)
 		ClearEnv();
 	words = Str_Words(varnames->str, FALSE);
 	for (i = 0; i < words.len; i++) {
 		const char *varname = words.words[i];
 		UnexportVar(varname, what);
+	}
 	Words_Free(words);
 	if (what != UNEXPORT_NAMED)
 		Global_Delete(MAKE_EXPORTED);
+}
 /*
  * This is called when .unexport[-env] is seen.
+ *
  * str must have the form "unexport[-env] varname...".
  */
 void
 Var_UnExport(Boolean isEnv, const char *arg)
+{
 	UnexportWhat what;
 	FStr varnames;
 	GetVarnamesToUnexport(isEnv, arg, &varnames, &what);
 	UnexportVars(&varnames, what);
 	FStr_Done(&varnames);
+}
 /*
  * When there is a variable of the same name in the command line scope, the
  * global variable would not be visible anywhere.  Therefore there is no
  * point in setting it at all.
+ *
  * See 'scope == SCOPE_CMDLINE' in Var_SetWithFlags.
  */
 static Boolean
 ExistsInCmdline(const char *name, const char *val)
+{
 	Var *v;
 	v = VarFind(name, SCOPE_CMDLINE, FALSE);
 	if (v == NULL)
 		return FALSE;
 	if (v->flags & VFL_FROM_CMD) {
 		DEBUG3(VAR, "%s:%s = %s ignored!\n",
 		    SCOPE_GLOBAL->name, name, val);
 		return TRUE;
+	}
 	VarFreeEnv(v);
 	return FALSE;
+}
 /* Set the variable to the value; the name is not expanded. */
 void
 Var_SetWithFlags(GNode *scope, const char *name, const char *val,
 		 VarSetFlags flags)
+{
 	Var *v;
 	assert(val != NULL);
 	if (name[0] == '\0') {
 		DEBUG0(VAR, "SetVar: variable name is empty - ignored\n");
 		return;
+	}
 	if (scope == SCOPE_GLOBAL && ExistsInCmdline(name, val))
 		return;
 	/*
 	 * Only look for a variable in the given scope since anything set
 	 * here will override anything in a lower scope, so there's not much
 	 * point in searching them all.
 	 */
 	v = VarFind(name, scope, FALSE);
 	if (v == NULL) {
 		if (scope == SCOPE_CMDLINE && !(flags & VAR_SET_NO_EXPORT)) {
 			/*
 			 * This var would normally prevent the same name being
 			 * added to SCOPE_GLOBAL, so delete it from there if
 			 * needed. Otherwise -V name may show the wrong value.
+			 *
 			 * See ExistsInCmdline.
 			 */
 			Var_Delete(SCOPE_GLOBAL, name);
+		}
 		v = VarAdd(name, val, scope, flags);
 	} else {
 		if ((v->flags & VFL_READONLY) && !(flags & VAR_SET_READONLY)) {
 			DEBUG3(VAR, "%s:%s = %s ignored (read-only)\n",
 			    scope->name, name, val);
 			return;
+		}
 		Buf_Empty(&v->val);
 		Buf_AddStr(&v->val, val);
 		DEBUG3(VAR, "%s:%s = %s\n", scope->name, name, val);
 		if (v->flags & VFL_EXPORTED)
 			ExportVar(name, VEM_PLAIN);
+	}
 	/*
 	 * Any variables given on the command line are automatically exported
 	 * to the environment (as per POSIX standard), except for internals.
 	 */
 	if (scope == SCOPE_CMDLINE && !(flags & VAR_SET_NO_EXPORT) &&
 	    name[0] != '.') {
 		v->flags |= VFL_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, 1);
 		/* XXX: What about .MAKE.EXPORTED? */
 		/* XXX: Why not just mark the variable for needing export,
 		 *  as in ExportVarPlain? */
 		Global_Append(MAKEOVERRIDES, name);
+	}
 	if (name[0] == '.' && strcmp(name, MAKE_SAVE_DOLLARS) == 0)
 		save_dollars = ParseBoolean(val, save_dollars);
 	if (v != NULL)
 		VarFreeEnv(v);
+}
 /* See Var_Set for documentation. */
 void
 Var_SetExpandWithFlags(GNode *scope, const char *name, const char *val,
 		       VarSetFlags flags)
+{
 	const char *unexpanded_name = name;
 	FStr varname = FStr_InitRefer(name);
 	assert(val != NULL);
 	if (strchr(varname.str, '$') != NULL) {
 		char *expanded;
 		(void)Var_Subst(varname.str, scope, VARE_WANTRES, &expanded);
 		/* TODO: handle errors */
 		varname = FStr_InitOwn(expanded);
+	}
 	if (varname.str[0] == '\0') {
 		DEBUG2(VAR, "Var_Set(\"%s\", \"%s\", ...) "
 			    "name expands to empty string - ignored\n",
 		    unexpanded_name, val);
 	} else
 		Var_SetWithFlags(scope, varname.str, val, flags);
 	FStr_Done(&varname);
+}
 void
 Var_Set(GNode *scope, const char *name, const char *val)
+{
 	Var_SetWithFlags(scope, name, val, VAR_SET_NONE);
+}
 /*
  * Set the variable name to the value val in the given scope.
+ *
  * If the variable doesn't yet exist, it is created.
  * Otherwise the new value overwrites and replaces the old value.
+ *
  * Input:
  *	name		name of the variable to set, is expanded once
  *	val		value to give to the variable
  *	scope		scope in which to set it
  */
 void
 Var_SetExpand(GNode *scope, const char *name, const char *val)
+{
 	Var_SetExpandWithFlags(scope, name, val, VAR_SET_NONE);
+}
 void
 Global_Set(const char *name, const char *value)
+{
 	Var_Set(SCOPE_GLOBAL, name, value);
+}
 void
 Global_SetExpand(const char *name, const char *value)
+{
 	Var_SetExpand(SCOPE_GLOBAL, name, value);
+}
 void
 Global_Delete(const char *name)
+{
 	Var_Delete(SCOPE_GLOBAL, name);
+}
 /*
  * Append the value to the named variable.
+ *
  * If the variable doesn't exist, it is created.  Otherwise a single space
  * and the given value are appended.
  */
 void
 Var_Append(GNode *scope, const char *name, const char *val)
+{
 	Var *v;
 	v = VarFind(name, scope, scope == SCOPE_GLOBAL);
 	if (v == NULL) {
 		Var_SetWithFlags(scope, name, val, VAR_SET_NONE);
 	} else if (v->flags & VFL_READONLY) {
 		DEBUG1(VAR, "Ignoring append to %s since it is read-only\n",
 		    name);
 	} else if (scope == SCOPE_CMDLINE || !(v->flags & VFL_FROM_CMD)) {
 		Buf_AddByte(&v->val, ' ');
 		Buf_AddStr(&v->val, val);
 		DEBUG3(VAR, "%s:%s = %s\n", scope->name, name, v->val.data);
 		if (v->flags & VFL_FROM_ENV) {
 			/*
 			 * If the original variable came from the environment,
 			 * we have to install it in the global scope (we
 			 * could place it in the environment, but then we
 			 * should provide a way to export other variables...)
 			 */
 			v->flags &= ~(unsigned)VFL_FROM_ENV;
 			/*
 			 * This is the only place where a variable is
 			 * created whose v->name is not the same as
 			 * scope->vars->key.
 			 */
 			HashTable_Set(&scope->vars, name, v);
+		}
+	}
+}
 /*
  * The variable of the given name has the given value appended to it in the
  * given scope.
+ *
  * If the variable doesn't exist, it is created. Otherwise the strings are
  * concatenated, with a space in between.
+ *
  * Input:
  *	name		name of the variable to modify, is expanded once
  *	val		string to append to it
  *	scope		scope in which this should occur
+ *
  * Notes:
  *	Only if the variable is being sought in the global scope is the
  *	environment searched.
  *	XXX: Knows its calling circumstances in that if called with scope
  *	an actual target, it will only search that scope since only
  *	a local variable could be being appended to. This is actually
  *	a big win and must be tolerated.
  */
 void
 Var_AppendExpand(GNode *scope, const char *name, const char *val)
+{
 	FStr xname = FStr_InitRefer(name);
 	assert(val != NULL);
 	if (strchr(name, '$') != NULL) {
 		char *expanded;
 		(void)Var_Subst(name, scope, VARE_WANTRES, &expanded);
 		/* TODO: handle errors */
 		xname = FStr_InitOwn(expanded);
 		if (expanded[0] == '\0') {
 			/* TODO: update function name in the debug message */
 			DEBUG2(VAR, "Var_Append(\"%s\", \"%s\", ...) "
 				    "name expands to empty string - ignored\n",
 			    name, val);
 			FStr_Done(&xname);
 			return;
+		}
+	}
 	Var_Append(scope, xname.str, val);
 	FStr_Done(&xname);
+}
 void
 Global_Append(const char *name, const char *value)
+{
 	Var_Append(SCOPE_GLOBAL, name, value);
+}
 Boolean
 Var_Exists(GNode *scope, const char *name)
+{
 	Var *v = VarFind(name, scope, TRUE);
 	if (v == NULL)
 		return FALSE;
 	VarFreeEnv(v);
 	return TRUE;
+}
 /*
  * See if the given variable exists, in the given scope or in other
  * fallback scopes.
+ *
  * Input:
  *	name		Variable to find, is expanded once
  *	scope		Scope in which to start search
  */
 Boolean
 Var_ExistsExpand(GNode *scope, const char *name)
+{
 	FStr varname = FStr_InitRefer(name);
 	Boolean exists;
 	if (strchr(varname.str, '$') != NULL) {
 		char *expanded;
 		(void)Var_Subst(varname.str, scope, VARE_WANTRES, &expanded);
 		/* TODO: handle errors */
 		varname = FStr_InitOwn(expanded);
+	}
 	exists = Var_Exists(scope, varname.str);
 	FStr_Done(&varname);
 	return exists;
+}
 /*
  * Return the unexpanded value of the given variable in the given scope,
  * or the usual scopes.
+ *
  * Input:
  *	name		name to find, is not expanded any further
  *	scope		scope in which to search for it
+ *
  * Results:
  *	The value if the variable exists, NULL if it doesn't.
  *	The value is valid until the next modification to any variable.
  */
 FStr
 Var_Value(GNode *scope, const char *name)
+{
 	Var *v = VarFind(name, scope, TRUE);
 	char *value;
 	if (v == NULL)
 		return FStr_InitRefer(NULL);
 	if (!(v->flags & VFL_FROM_ENV))
 		return FStr_InitRefer(v->val.data);
 	/* Since environment variables are short-lived, free it now. */
 	FStr_Done(&v->name);
 	value = Buf_DoneData(&v->val);
 	free(v);
 	return FStr_InitOwn(value);
+}
 /*
  * Return the unexpanded variable value from this node, without trying to look
  * up the variable in any other scope.
  */
 const char *
 GNode_ValueDirect(GNode *gn, const char *name)
+{
 	Var *v = VarFind(name, gn, FALSE);
 	return v != NULL ? v->val.data : NULL;
+}
 static void
 SepBuf_Init(SepBuf *buf, char sep)
+{
 	Buf_InitSize(&buf->buf, 32);
 	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_DoneData(SepBuf *buf)
+{
 	return Buf_DoneData(&buf->buf);
+}
 /*
  * This callback for ModifyWords gets a single word from a variable expression
  * and typically adds a modification of this word to the buffer. It may also
  * do nothing or add several words.
+ *
  * For example, when evaluating the modifier ':M*b' in ${:Ua b c:M*b}, the
  * callback is called 3 times, once for "a", "b" and "c".
  */
 typedef void (*ModifyWordProc)(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.
  */
 /*ARGSUSED*/
 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.
  */
 /*ARGSUSED*/
 static void
 ModifyWord_Tail(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
 	SepBuf_AddStr(buf, str_basename(word));
+}
 /*
  * Callback for ModifyWords to implement the :E modifier.
  * Add the filename suffix of the given word to the buffer, if it exists.
  */
 /*ARGSUSED*/
 static void
 ModifyWord_Suffix(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
 	const char *lastDot = strrchr(word, '.');
 	if (lastDot != NULL)
 		SepBuf_AddStr(buf, lastDot + 1);
+}
 /*
  * Callback for ModifyWords to implement the :R modifier.
  * Add the filename without extension of the given word to the buffer.
  */
 /*ARGSUSED*/
 static void
 ModifyWord_Root(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
 	const char *lastDot = strrchr(word, '.');
 	size_t len = lastDot != NULL ? (size_t)(lastDot - 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;
 	DEBUG2(VAR, "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
 /*
  * Check word against pattern for a match (% is a wildcard).
+ *
  * Input:
  *	word		Word to examine
  *	pattern		Pattern to examine against
+ *
  * Results:
  *	Returns the start of the match, or NULL.
  *	out_match_len returns the length of the match, if any.
  *	out_hasPercent returns whether the pattern contains a percent.
  */
 static const char *
 SysVMatch(const char *word, const char *pattern,
 	  size_t *out_match_len, Boolean *out_hasPercent)
+{
 	const char *p = pattern;
 	const char *w = word;
 	const char *percent;
 	size_t w_len;
 	size_t p_len;
 	const char *w_tail;
 	*out_hasPercent = FALSE;
 	percent = strchr(p, '%');
 	if (percent != NULL) {		/* ${VAR:...%...=...} */
 		*out_hasPercent = TRUE;
 		if (w[0] == '\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 */
 			*out_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;
 	*out_match_len = (size_t)(w_tail - w);
 	return w;
+}
 struct ModifyWord_SYSVSubstArgs {
 	GNode *scope;
 	const char *lhs;
 	const char *rhs;