 @@ -1,1246 +1,1245 @@
-/*	$NetBSD: cond.c,v 1.362 2024/02/07 07:21:22 rillig Exp $	*/
+/*	$NetBSD: cond.c,v 1.363 2024/04/23 22:51:28 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 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) 1988, 1989 by Adam de Boor
  * 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 conditionals in a makefile.
+ *
  * Interface:
  *	Cond_EvalLine   Evaluate the conditional directive, such as
  *			'.if <cond>', '.elifnmake <cond>', '.else', '.endif'.
+ *
  *	Cond_EvalCondition
  *			Evaluate the conditional, which is either the argument
  *			of one of the .if directives or the condition in a
  *			':?then:else' variable modifier.
+ *
  *	Cond_EndFile	At the end of reading a makefile, ensure that the
  *			conditional directives are well-balanced.
  */
 #include <errno.h>
 #include "make.h"
 #include "dir.h"
 /*	"@(#)cond.c	8.2 (Berkeley) 1/2/94"	*/
-MAKE_RCSID("$NetBSD: cond.c,v 1.362 2024/02/07 07:21:22 rillig Exp $");
+MAKE_RCSID("$NetBSD: cond.c,v 1.363 2024/04/23 22:51:28 rillig Exp $");
 /*
  * Conditional expressions conform to this grammar:
  *	Or -> And ('||' And)*
  *	And -> Term ('&&' Term)*
  *	Term -> Function '(' Argument ')'
  *	Term -> Leaf Operator Leaf
  *	Term -> Leaf
  *	Term -> '(' Or ')'
  *	Term -> '!' Term
  *	Leaf -> "string"
  *	Leaf -> Number
  *	Leaf -> VariableExpression
  *	Leaf -> BareWord
  *	Operator -> '==' | '!=' | '>' | '<' | '>=' | '<='
+ *
  * BareWord is an unquoted string literal, its evaluation depends on the kind
  * of '.if' directive.
+ *
  * The tokens are scanned by CondParser_Token, which returns:
  *	TOK_AND		for '&&'
  *	TOK_OR		for '||'
  *	TOK_NOT		for '!'
  *	TOK_LPAREN	for '('
  *	TOK_RPAREN	for ')'
+ *
  * Other terminal symbols are evaluated using either the default function or
  * the function given in the terminal, they return either TOK_TRUE, TOK_FALSE
  * or TOK_ERROR.
  */
 typedef enum Token {
 	TOK_FALSE, TOK_TRUE, TOK_AND, TOK_OR, TOK_NOT,
 	TOK_LPAREN, TOK_RPAREN, TOK_EOF, TOK_NONE, TOK_ERROR
 } Token;
 typedef enum ComparisonOp {
 	LT, LE, GT, GE, EQ, NE
 } ComparisonOp;
 typedef struct CondParser {
 	/*
 	 * The plain '.if ${VAR}' evaluates to true if the value of the
 	 * expression has length > 0 and is not numerically zero.  The other
 	 * '.if' variants delegate to evalBare instead, for example '.ifdef
 	 * ${VAR}' is equivalent to '.if defined(${VAR})', checking whether
 	 * the variable named by the expression '${VAR}' is defined.
 	 */
 	bool plain;
 	/* The function to apply on unquoted bare words. */
 	bool (*evalBare)(const char *);
 	bool negateEvalBare;
 	/*
 	 * Whether the left-hand side of a comparison may be an unquoted
 	 * string.  This is allowed for expressions of the form
 	 * ${condition:?:}, see ApplyModifier_IfElse.  Such a condition is
 	 * expanded before it is evaluated, due to ease of implementation.
 	 * This means that at the point where the condition is evaluated,
 	 * make cannot know anymore whether the left-hand side had originally
 	 * been an expression or a plain word.
+	 *
 	 * In conditional directives like '.if', the left-hand side must
 	 * either be an expression, a quoted string or a number.
 	 */
 	bool leftUnquotedOK;
 	const char *p;		/* The remaining condition to parse */
 	Token curr;		/* Single push-back token used in parsing */
 	/*
 	 * Whether an error message has already been printed for this
 	 * condition.
 	 */
 	bool printedError;
 } CondParser;
 static CondResult CondParser_Or(CondParser *, bool);
 unsigned int cond_depth = 0;	/* current .if nesting level */
 /* Names for ComparisonOp. */
 static const char opname[][3] = { "<", "<=", ">", ">=", "==", "!=" };
 MAKE_INLINE bool
 skip_string(const char **pp, const char *str)
+{
 	size_t len = strlen(str);
 	bool ok = strncmp(*pp, str, len) == 0;
 	if (ok)
 		*pp += len;
 	return ok;
+}
 static Token
 ToToken(bool cond)
+{
 	return cond ? TOK_TRUE : TOK_FALSE;
+}
 static void
 CondParser_SkipWhitespace(CondParser *par)
+{
 	cpp_skip_whitespace(&par->p);
+}
 /*
  * Parse a single word, taking into account balanced parentheses as well as
  * embedded expressions.  Used for the argument of a built-in function as
  * well as for bare words, which are then passed to the default function.
  */
 static char *
 ParseWord(const char **pp, bool doEval)
+{
 	const char *p = *pp;
 	Buffer word;
 	int depth;
 	Buf_Init(&word);
 	depth = 0;
 	for (;;) {
 		char ch = *p;
 		if (ch == '\0' || ch == ' ' || ch == '\t')
 			break;
 		if ((ch == '&' || ch == '|') && depth == 0)
 			break;
 		if (ch == '$') {
 			VarEvalMode emode = doEval
 			    ? VARE_UNDEFERR
 			    : VARE_PARSE_ONLY;
 			/*
 			 * TODO: make Var_Parse complain about undefined
 			 * variables.
 			 */
 			FStr nestedVal = Var_Parse(&p, SCOPE_CMDLINE, emode);
 			/* TODO: handle errors */
 			Buf_AddStr(&word, nestedVal.str);
 			FStr_Done(&nestedVal);
 			continue;
+		}
 		if (ch == '(')
 			depth++;
 		else if (ch == ')' && --depth < 0)
 			break;
 		Buf_AddByte(&word, ch);
 		p++;
+	}
 	cpp_skip_hspace(&p);
 	*pp = p;
 	return Buf_DoneData(&word);
+}
 /* Parse the function argument, including the surrounding parentheses. */
 static char *
 ParseFuncArg(CondParser *par, const char **pp, bool doEval, const char *func)
+{
 	const char *p = *pp;
 	char *res;
 	p++;			/* skip the '(' */
 	cpp_skip_hspace(&p);
 	res = ParseWord(&p, doEval);
 	cpp_skip_hspace(&p);
 	if (*p++ != ')') {
 		int len = 0;
 		while (ch_isalpha(func[len]))
 			len++;
 		Parse_Error(PARSE_FATAL,
 		    "Missing closing parenthesis for %.*s()", len, func);
 		par->printedError = true;
 		free(res);
 		return NULL;
+	}
 	*pp = p;
 	return res;
+}
 /* See if the given variable is defined. */
 static bool
 FuncDefined(const char *var)
+{
 	return Var_Exists(SCOPE_CMDLINE, var);
+}
 /* See if a target matching targetPattern is requested to be made. */
 static bool
 FuncMake(const char *targetPattern)
+{
 	StringListNode *ln;
 	bool warned = false;
 	for (ln = opts.create.first; ln != NULL; ln = ln->next) {
 		StrMatchResult res = Str_Match(ln->datum, targetPattern);
 		if (res.error != NULL && !warned) {
 			warned = true;
 			Parse_Error(PARSE_WARNING,
 			    "%s in pattern argument '%s' to function 'make'",
 			    res.error, targetPattern);
+		}
 		if (res.matched)
 			return true;
+	}
 	return false;
+}
 /* See if the given file exists. */
 static bool
 FuncExists(const char *file)
+{
 	bool result;
 	char *path;
 	path = Dir_FindFile(file, &dirSearchPath);
 	DEBUG2(COND, "exists(%s) result is \"%s\"\n",
 	    file, path != NULL ? path : "");
 	result = path != NULL;
 	free(path);
 	return result;
+}
 /* See if the given node exists and is an actual target. */
 static bool
 FuncTarget(const char *node)
+{
 	GNode *gn = Targ_FindNode(node);
 	return gn != NULL && GNode_IsTarget(gn);
+}
 /*
  * See if the given node exists and is an actual target with commands
  * associated with it.
  */
 static bool
 FuncCommands(const char *node)
+{
 	GNode *gn = Targ_FindNode(node);
 	return gn != NULL && GNode_IsTarget(gn) &&
 	       !Lst_IsEmpty(&gn->commands);
+}
 /*
  * Convert the string to a floating point number.  Accepted formats are
  * base-10 integer, base-16 integer and finite floating point numbers.
  */
 static bool
 TryParseNumber(const char *str, double *out_value)
+{
 	char *end;
 	unsigned long ul_val;
 	double dbl_val;
 	if (str[0] == '\0') {	/* XXX: why is an empty string a number? */
 		*out_value = 0.0;
 		return true;
+	}
 	errno = 0;
 	ul_val = strtoul(str, &end, str[1] == 'x' ? 16 : 10);
 	if (*end == '\0' && errno != ERANGE) {
 		*out_value = str[0] == '-' ? -(double)-ul_val : (double)ul_val;
 		return true;
+	}
 	if (*end != '\0' && *end != '.' && *end != 'e' && *end != 'E')
 		return false;	/* skip the expensive strtod call */
 	dbl_val = strtod(str, &end);
 	if (*end != '\0')
 		return false;
 	*out_value = dbl_val;
 	return true;
+}
 static bool
 is_separator(char ch)
+{
 	return ch == '\0' || ch_isspace(ch) || ch == '!' || ch == '=' ||
 	       ch == '>' || ch == '<' || ch == ')' /* but not '(' */;
+}
 /*
  * In a quoted or unquoted string literal or a number, parse an
  * expression and add its value to the buffer.
+ *
  * Return whether to continue parsing the leaf.
+ *
  * Example: .if x${CENTER}y == "${PREFIX}${SUFFIX}" || 0x${HEX}
  */
 static bool
 CondParser_StringExpr(CondParser *par, const char *start,
 		      bool doEval, bool quoted,
 		      Buffer *buf, FStr *inout_str)
+{
 	VarEvalMode emode;
 	const char *p;
 	bool atStart;		/* true means an expression outside quotes */
 	emode = doEval && quoted ? VARE_WANTRES
 	    : doEval ? VARE_UNDEFERR
 	    : VARE_PARSE_ONLY;
 	p = par->p;
 	atStart = p == start;
 	*inout_str = Var_Parse(&p, SCOPE_CMDLINE, emode);
 	/* TODO: handle errors */
 	if (inout_str->str == var_Error) {
 		FStr_Done(inout_str);
 		*inout_str = FStr_InitRefer(NULL);
 		return false;
+	}
 	par->p = p;
 	if (atStart && is_separator(par->p[0]))
 		return false;
 	Buf_AddStr(buf, inout_str->str);
 	FStr_Done(inout_str);
 	*inout_str = FStr_InitRefer(NULL);	/* not finished yet */
 	return true;
+}
 /*
  * Parse a string from an expression or an optionally quoted string,
  * on the left-hand and right-hand sides of comparisons.
+ *
- * Results:
+ * Return the string without any enclosing quotes, or NULL on error.
- *	Returns the string without any enclosing quotes, or NULL on error.
+ * Sets out_quoted if the leaf was a quoted string literal.
  *	Sets out_quoted if the leaf was a quoted string literal.
  */
-static void
+static FStr
 CondParser_Leaf(CondParser *par, bool doEval, bool unquotedOK,
-		  FStr *out_str, bool *out_quoted)
+		bool *out_quoted)
+{
 	Buffer buf;
 	FStr str;
 	bool quoted;
 	const char *start;
 	Buf_Init(&buf);
 	str = FStr_InitRefer(NULL);
 	*out_quoted = quoted = par->p[0] == '"';
 	start = par->p;
 	if (quoted)
 		par->p++;
 	while (par->p[0] != '\0' && str.str == NULL) {
 		switch (par->p[0]) {
 		case '\\':
 			par->p++;
 			if (par->p[0] != '\0') {
 				Buf_AddByte(&buf, par->p[0]);
 				par->p++;
+			}
 			continue;
 		case '"':
 			par->p++;
 			if (quoted)
 				goto return_buf;	/* skip the closing quote */
 			Buf_AddByte(&buf, '"');
 			continue;
 		case ')':	/* see is_separator */
 		case '!':
 		case '=':
 		case '>':
 		case '<':
 		case ' ':
 		case '\t':
 			if (!quoted)
 				goto return_buf;
 			Buf_AddByte(&buf, par->p[0]);
 			par->p++;
 			continue;
 		case '$':
 			if (!CondParser_StringExpr(par,
 			    start, doEval, quoted, &buf, &str))
 				goto return_str;
 			continue;
 		default:
 			if (!unquotedOK && !quoted && *start != '$' &&
 			    !ch_isdigit(*start)) {
 				str = FStr_InitRefer(NULL);
 				goto return_str;
+			}
 			Buf_AddByte(&buf, par->p[0]);
 			par->p++;
 			continue;
+		}
+	}
 return_buf:
 	str = FStr_InitOwn(buf.data);
 	buf.data = NULL;
 return_str:
 	Buf_Done(&buf);
-	*out_str = str;
+	return str;
+}
 /*
  * Evaluate a "comparison without operator", such as in ".if ${VAR}" or
  * ".if 0".
  */
 static bool
 EvalTruthy(CondParser *par, const char *value, bool quoted)
+{
 	double num;
 	if (quoted)
 		return value[0] != '\0';
 	if (TryParseNumber(value, &num))
 		return num != 0.0;
 	if (par->plain)
 		return value[0] != '\0';
 	return par->evalBare(value) != par->negateEvalBare;
+}
 /* Evaluate a numerical comparison, such as in ".if ${VAR} >= 9". */
 static bool
 EvalCompareNum(double lhs, ComparisonOp op, double rhs)
+{
 	DEBUG3(COND, "Comparing %f %s %f\n", lhs, opname[op], rhs);
 	switch (op) {
 	case LT:
 		return lhs < rhs;
 	case LE:
 		return lhs <= rhs;
 	case GT:
 		return lhs > rhs;
 	case GE:
 		return lhs >= rhs;
 	case EQ:
 		return lhs == rhs;
 	default:
 		return lhs != rhs;
+	}
+}
 static Token
 EvalCompareStr(CondParser *par, const char *lhs,
 	       ComparisonOp op, const char *rhs)
+{
 	if (op != EQ && op != NE) {
 		Parse_Error(PARSE_FATAL,
 		    "Comparison with '%s' requires both operands "
 		    "'%s' and '%s' to be numeric",
 		    opname[op], lhs, rhs);
 		par->printedError = true;
 		return TOK_ERROR;
+	}
 	DEBUG3(COND, "Comparing \"%s\" %s \"%s\"\n", lhs, opname[op], rhs);
 	return ToToken((op == EQ) == (strcmp(lhs, rhs) == 0));
+}
 /* Evaluate a comparison, such as "${VAR} == 12345". */
 static Token
 EvalCompare(CondParser *par, const char *lhs, bool lhsQuoted,
 	    ComparisonOp op, const char *rhs, bool rhsQuoted)
+{
 	double left, right;
 	if (!rhsQuoted && !lhsQuoted)
 		if (TryParseNumber(lhs, &left) && TryParseNumber(rhs, &right))
 			return ToToken(EvalCompareNum(left, op, right));
 	return EvalCompareStr(par, lhs, op, rhs);
+}
 static bool
 CondParser_ComparisonOp(CondParser *par, ComparisonOp *out_op)
+{
 	const char *p = par->p;
 	if (p[0] == '<' && p[1] == '=')
 		return par->p += 2, *out_op = LE, true;
 	if (p[0] == '<')
 		return par->p += 1, *out_op = LT, true;
 	if (p[0] == '>' && p[1] == '=')
 		return par->p += 2, *out_op = GE, true;
 	if (p[0] == '>')
 		return par->p += 1, *out_op = GT, true;
 	if (p[0] == '=' && p[1] == '=')
 		return par->p += 2, *out_op = EQ, true;
 	if (p[0] == '!' && p[1] == '=')
 		return par->p += 2, *out_op = NE, true;
 	return false;
+}
 /*
  * Parse a comparison condition such as:
+ *
  *	0
  *	${VAR:Mpattern}
  *	${VAR} == value
  *	${VAR:U0} < 12345
  */
 static Token
 CondParser_Comparison(CondParser *par, bool doEval)
+{
 	Token t = TOK_ERROR;
 	FStr lhs, rhs;
 	ComparisonOp op;
 	bool lhsQuoted, rhsQuoted;
-	CondParser_Leaf(par, doEval, par->leftUnquotedOK, &lhs, &lhsQuoted);
+	lhs = CondParser_Leaf(par, doEval, par->leftUnquotedOK, &lhsQuoted);
 	if (lhs.str == NULL)
 		goto done_lhs;
 	CondParser_SkipWhitespace(par);
 	if (!CondParser_ComparisonOp(par, &op)) {
 		t = ToToken(doEval && EvalTruthy(par, lhs.str, lhsQuoted));
 		goto done_lhs;
+	}
 	CondParser_SkipWhitespace(par);
 	if (par->p[0] == '\0') {
 		Parse_Error(PARSE_FATAL,
 		    "Missing right-hand side of operator '%s'", opname[op]);
 		par->printedError = true;
 		goto done_lhs;
+	}
-	CondParser_Leaf(par, doEval, true, &rhs, &rhsQuoted);
+	rhs = CondParser_Leaf(par, doEval, true, &rhsQuoted);
 	t = rhs.str == NULL ? TOK_ERROR
 	    : !doEval ? TOK_FALSE
 	    : EvalCompare(par, lhs.str, lhsQuoted, op, rhs.str, rhsQuoted);
 	FStr_Done(&rhs);
 done_lhs:
 	FStr_Done(&lhs);
 	return t;
+}
 /*
  * The argument to empty() is a variable name, optionally followed by
  * variable modifiers.
  */
 static bool
 CondParser_FuncCallEmpty(CondParser *par, bool doEval, Token *out_token)
+{
 	const char *p = par->p;
 	Token tok;
 	FStr val;
 	if (!skip_string(&p, "empty"))
 		return false;
 	cpp_skip_whitespace(&p);
 	if (*p != '(')
 		return false;
 	p--;			/* Make p[1] point to the '('. */
 	val = Var_Parse(&p, SCOPE_CMDLINE,
 	    doEval ? VARE_WANTRES : VARE_PARSE_ONLY);
 	/* TODO: handle errors */
 	if (val.str == var_Error)
 		tok = TOK_ERROR;
 	else {
 		cpp_skip_whitespace(&val.str);
 		tok = ToToken(doEval && val.str[0] == '\0');
+	}
 	FStr_Done(&val);
 	*out_token = tok;
 	par->p = p;
 	return true;
+}
 /* Parse a function call expression, such as 'exists(${file})'. */
 static bool
 CondParser_FuncCall(CondParser *par, bool doEval, Token *out_token)
+{
 	char *arg;
 	const char *p = par->p;
 	bool (*fn)(const char *);
 	const char *fn_name = p;
 	if (skip_string(&p, "defined"))
 		fn = FuncDefined;
 	else if (skip_string(&p, "make"))
 		fn = FuncMake;
 	else if (skip_string(&p, "exists"))
 		fn = FuncExists;
 	else if (skip_string(&p, "target"))
 		fn = FuncTarget;
 	else if (skip_string(&p, "commands"))
 		fn = FuncCommands;
 	else
 		return false;
 	cpp_skip_whitespace(&p);
 	if (*p != '(')
 		return false;
 	arg = ParseFuncArg(par, &p, doEval, fn_name);
 	*out_token = ToToken(doEval &&
 	    arg != NULL && arg[0] != '\0' && fn(arg));
 	free(arg);
 	par->p = p;
 	return true;
+}
 /*
  * Parse a comparison that neither starts with '"' nor '$', such as the
  * unusual 'bare == right' or '3 == ${VAR}', or a simple leaf without
  * operator, which is a number, an expression or a string literal.
+ *
  * TODO: Can this be merged into CondParser_Comparison?
  */
 static Token
 CondParser_ComparisonOrLeaf(CondParser *par, bool doEval)
+{
 	Token t;
 	char *arg;
 	const char *p;
 	p = par->p;
 	if (ch_isdigit(p[0]) || p[0] == '-' || p[0] == '+')
 		return CondParser_Comparison(par, doEval);
 	/*
 	 * Most likely we have a bare word to apply the default function to.
 	 * However, ".if a == b" gets here when the "a" is unquoted and
 	 * doesn't start with a '$'. This surprises people.
 	 * If what follows the function argument is a '=' or '!' then the
 	 * syntax would be invalid if we did "defined(a)" - so instead treat
 	 * as an expression.
 	 */
 	/*
 	 * XXX: In edge cases, an expression may be evaluated twice,
 	 *  see cond-token-plain.mk, keyword 'twice'.
 	 */
 	arg = ParseWord(&p, doEval);
 	assert(arg[0] != '\0');
 	if (*p == '=' || *p == '!' || *p == '<' || *p == '>')
 		return CondParser_Comparison(par, doEval);
 	par->p = p;
 	/*
 	 * Evaluate the argument using the default function.
 	 * This path always treats .if as .ifdef. To get here, the character
 	 * after .if must have been taken literally, so the argument cannot
 	 * be empty - even if it contained an expression.
 	 */
 	t = ToToken(doEval && par->evalBare(arg) != par->negateEvalBare);
 	free(arg);
 	return t;
+}
 /* Return the next token or comparison result from the parser. */
 static Token
 CondParser_Token(CondParser *par, bool doEval)
+{
 	Token t;
 	t = par->curr;
 	if (t != TOK_NONE) {
 		par->curr = TOK_NONE;
 		return t;
+	}
 	cpp_skip_hspace(&par->p);
 	switch (par->p[0]) {
 	case '(':
 		par->p++;
 		return TOK_LPAREN;
 	case ')':
 		par->p++;
 		return TOK_RPAREN;
 	case '|':
 		par->p++;
 		if (par->p[0] == '|')
 			par->p++;
 		else if (opts.strict) {
 			Parse_Error(PARSE_FATAL, "Unknown operator '|'");
 			par->printedError = true;
 			return TOK_ERROR;
+		}
 		return TOK_OR;
 	case '&':
 		par->p++;
 		if (par->p[0] == '&')
 			par->p++;
 		else if (opts.strict) {
 			Parse_Error(PARSE_FATAL, "Unknown operator '&'");
 			par->printedError = true;
 			return TOK_ERROR;
+		}
 		return TOK_AND;
 	case '!':
 		par->p++;
 		return TOK_NOT;
 	case '#':		/* XXX: see unit-tests/cond-token-plain.mk */
 	case '\n':		/* XXX: why should this end the condition? */
 		/* Probably obsolete now, from 1993-03-21. */
 	case '\0':
 		return TOK_EOF;
 	case '"':
 	case '$':
 		return CondParser_Comparison(par, doEval);
 	default:
 		if (CondParser_FuncCallEmpty(par, doEval, &t))
 			return t;
 		if (CondParser_FuncCall(par, doEval, &t))
 			return t;
 		return CondParser_ComparisonOrLeaf(par, doEval);
+	}
+}
 /* Skip the next token if it equals t. */
 static bool
 CondParser_Skip(CondParser *par, Token t)
+{
 	Token actual;
 	actual = CondParser_Token(par, false);
 	if (actual == t)
 		return true;
 	assert(par->curr == TOK_NONE);
 	assert(actual != TOK_NONE);
 	par->curr = actual;
 	return false;
+}
 /*
  * Term -> '(' Or ')'
  * Term -> '!' Term
  * Term -> Leaf Operator Leaf
  * Term -> Leaf
  */
 static CondResult
 CondParser_Term(CondParser *par, bool doEval)
+{
 	CondResult res;
 	Token t;
 	bool neg = false;
 	while ((t = CondParser_Token(par, doEval)) == TOK_NOT)
 		neg = !neg;
 	if (t == TOK_TRUE || t == TOK_FALSE)
 		return neg == (t == TOK_FALSE) ? CR_TRUE : CR_FALSE;
 	if (t == TOK_LPAREN) {
 		res = CondParser_Or(par, doEval);
 		if (res == CR_ERROR)
 			return CR_ERROR;
 		if (CondParser_Token(par, doEval) != TOK_RPAREN)
 			return CR_ERROR;
 		return neg == (res == CR_FALSE) ? CR_TRUE : CR_FALSE;
+	}
 	return CR_ERROR;
+}
 /*
  * And -> Term ('&&' Term)*
  */
 static CondResult
 CondParser_And(CondParser *par, bool doEval)
+{
 	CondResult res, rhs;
 	res = CR_TRUE;
 	do {
 		if ((rhs = CondParser_Term(par, doEval)) == CR_ERROR)
 			return CR_ERROR;
 		if (rhs == CR_FALSE) {
 			res = CR_FALSE;
 			doEval = false;
+		}
 	} while (CondParser_Skip(par, TOK_AND));
 	return res;
+}
 /*
  * Or -> And ('||' And)*
  */
 static CondResult
 CondParser_Or(CondParser *par, bool doEval)
+{
 	CondResult res, rhs;
 	res = CR_FALSE;
 	do {
 		if ((rhs = CondParser_And(par, doEval)) == CR_ERROR)
 			return CR_ERROR;
 		if (rhs == CR_TRUE) {
 			res = CR_TRUE;
 			doEval = false;
+		}
 	} while (CondParser_Skip(par, TOK_OR));
 	return res;
+}
 /*
  * Evaluate the condition, including any side effects from the
  * expressions in the condition. The condition consists of &&, ||, !,
  * function(arg), comparisons and parenthetical groupings thereof.
  */
 static CondResult
 CondEvalExpression(const char *cond, bool plain,
 		   bool (*evalBare)(const char *), bool negate,
 		   bool eprint, bool leftUnquotedOK)
+{
 	CondParser par;
 	CondResult rval;
 	cpp_skip_hspace(&cond);
 	par.plain = plain;
 	par.evalBare = evalBare;
 	par.negateEvalBare = negate;
 	par.leftUnquotedOK = leftUnquotedOK;
 	par.p = cond;
 	par.curr = TOK_NONE;
 	par.printedError = false;
 	DEBUG1(COND, "CondParser_Eval: %s\n", par.p);
 	rval = CondParser_Or(&par, true);
 	if (par.curr != TOK_EOF)
 		rval = CR_ERROR;
 	if (rval == CR_ERROR && eprint && !par.printedError)
 		Parse_Error(PARSE_FATAL, "Malformed conditional (%s)", cond);
 	return rval;
+}
 /*
  * Evaluate a condition in a :? modifier, such as
  * ${"${VAR}" == value:?yes:no}.
  */
 CondResult
 Cond_EvalCondition(const char *cond)
+{
 	return CondEvalExpression(cond, true,
 	    FuncDefined, false, false, true);
+}
 static bool
 IsEndif(const char *p)
+{
 	return p[0] == 'e' && p[1] == 'n' && p[2] == 'd' &&
 	       p[3] == 'i' && p[4] == 'f' && !ch_isalpha(p[5]);
+}
 static bool
 DetermineKindOfConditional(const char **pp, bool *out_plain,
 			   bool (**out_evalBare)(const char *),
 			   bool *out_negate)
+{
 	const char *p = *pp + 2;
 	*out_plain = false;
 	*out_evalBare = FuncDefined;
 	*out_negate = skip_string(&p, "n");
 	if (skip_string(&p, "def")) {		/* .ifdef and .ifndef */
 	} else if (skip_string(&p, "make"))	/* .ifmake and .ifnmake */
 		*out_evalBare = FuncMake;
 	else if (!*out_negate)			/* plain .if */
 		*out_plain = true;
 	else
 		goto unknown_directive;
 	if (ch_isalpha(*p))
 		goto unknown_directive;
 	*pp = p;
 	return true;
 unknown_directive:
 	return false;
+}
 /*
  * Evaluate the conditional directive in the line, which is one of:
+ *
  *	.if <cond>
  *	.ifmake <cond>
  *	.ifnmake <cond>
  *	.ifdef <cond>
  *	.ifndef <cond>
  *	.elif <cond>
  *	.elifmake <cond>
  *	.elifnmake <cond>
  *	.elifdef <cond>
  *	.elifndef <cond>
  *	.else
  *	.endif
+ *
  * In these directives, <cond> consists of &&, ||, !, function(arg),
  * comparisons, expressions, bare words, numbers and strings, and
  * parenthetical groupings thereof.
+ *
  * Results:
  *	CR_TRUE		to continue parsing the lines that follow the
  *			conditional (when <cond> evaluates to true)
  *	CR_FALSE	to skip the lines after the conditional
  *			(when <cond> evaluates to false, or when a previous
  *			branch was already taken)
  *	CR_ERROR	if the conditional was not valid, either because of
  *			a syntax error or because some variable was undefined
  *			or because the condition could not be evaluated
  */
 CondResult
 Cond_EvalLine(const char *line)
+{
 	typedef enum IfState {
 		/* None of the previous <cond> evaluated to true. */
 		IFS_INITIAL	= 0,
 		/*
 		 * The previous <cond> evaluated to true. The lines following
 		 * this condition are interpreted.
 		 */
 		IFS_ACTIVE	= 1 << 0,
 		/* The previous directive was an '.else'. */
 		IFS_SEEN_ELSE	= 1 << 1,
 		/* One of the previous <cond> evaluated to true. */
 		IFS_WAS_ACTIVE	= 1 << 2
 	} IfState;
 	static enum IfState *cond_states = NULL;
 	static unsigned int cond_states_cap = 128;
 	bool plain;
 	bool (*evalBare)(const char *);
 	bool negate;
 	bool isElif;
 	CondResult res;
 	IfState state;
 	const char *p = line;
 	if (cond_states == NULL) {
 		cond_states = bmake_malloc(
 		    cond_states_cap * sizeof *cond_states);
 		cond_states[0] = IFS_ACTIVE;
+	}
 	p++;			/* skip the leading '.' */
 	cpp_skip_hspace(&p);
 	if (IsEndif(p)) {
 		if (p[5] != '\0') {
 			Parse_Error(PARSE_FATAL,
 			    "The .endif directive does not take arguments");
+		}
 		if (cond_depth == CurFile_CondMinDepth()) {
 			Parse_Error(PARSE_FATAL, "if-less endif");
 			return CR_TRUE;
+		}
 		/* Return state for previous conditional */
 		cond_depth--;
 		Parse_GuardEndif();
 		return cond_states[cond_depth] & IFS_ACTIVE
 		    ? CR_TRUE : CR_FALSE;
+	}
 	/* Parse the name of the directive, such as 'if', 'elif', 'endif'. */
 	if (p[0] == 'e') {
 		if (p[1] != 'l')
 			return CR_ERROR;
 		/* Quite likely this is 'else' or 'elif' */
 		p += 2;
 		if (strncmp(p, "se", 2) == 0 && !ch_isalpha(p[2])) {
 			if (p[2] != '\0')
 				Parse_Error(PARSE_FATAL,
 				    "The .else directive "
 				    "does not take arguments");
 			if (cond_depth == CurFile_CondMinDepth()) {
 				Parse_Error(PARSE_FATAL, "if-less else");
 				return CR_TRUE;
+			}
 			Parse_GuardElse();
 			state = cond_states[cond_depth];
 			if (state == IFS_INITIAL) {
 				state = IFS_ACTIVE | IFS_SEEN_ELSE;
 			} else {
 				if (state & IFS_SEEN_ELSE)
 					Parse_Error(PARSE_WARNING,
 					    "extra else");
 				state = IFS_WAS_ACTIVE | IFS_SEEN_ELSE;
+			}
 			cond_states[cond_depth] = state;
 			return state & IFS_ACTIVE ? CR_TRUE : CR_FALSE;
+		}
 		/* Assume for now it is an elif */
 		isElif = true;
 	} else
 		isElif = false;
 	if (p[0] != 'i' || p[1] != 'f')
 		return CR_ERROR;
 	if (!DetermineKindOfConditional(&p, &plain, &evalBare, &negate))
 		return CR_ERROR;
 	if (isElif) {
 		if (cond_depth == CurFile_CondMinDepth()) {
 			Parse_Error(PARSE_FATAL, "if-less elif");
 			return CR_TRUE;
+		}
 		Parse_GuardElse();
 		state = cond_states[cond_depth];
 		if (state & IFS_SEEN_ELSE) {
 			Parse_Error(PARSE_WARNING, "extra elif");
 			cond_states[cond_depth] =
 			    IFS_WAS_ACTIVE | IFS_SEEN_ELSE;
 			return CR_FALSE;
+		}
 		if (state != IFS_INITIAL) {
 			cond_states[cond_depth] = IFS_WAS_ACTIVE;
 			return CR_FALSE;
+		}
 	} else {
 		/* Normal .if */
 		if (cond_depth + 1 >= cond_states_cap) {
 			/*
 			 * This is rare, but not impossible.
 			 * In meta mode, dirdeps.mk (only runs at level 0)
 			 * can need more than the default.
 			 */
 			cond_states_cap += 32;
 			cond_states = bmake_realloc(cond_states,
 			    cond_states_cap * sizeof *cond_states);
+		}
 		state = cond_states[cond_depth];
 		cond_depth++;
 		if (!(state & IFS_ACTIVE)) {
 			cond_states[cond_depth] = IFS_WAS_ACTIVE;
 			return CR_FALSE;
+		}
+	}
 	res = CondEvalExpression(p, plain, evalBare, negate, true, false);
 	if (res == CR_ERROR) {
 		/* Syntax error, error message already output. */
 		/* Skip everything to the matching '.endif'. */
 		/* An extra '.else' is not detected in this case. */
 		cond_states[cond_depth] = IFS_WAS_ACTIVE;
 		return CR_FALSE;
+	}
 	cond_states[cond_depth] = res == CR_TRUE ? IFS_ACTIVE : IFS_INITIAL;
 	return res;
+}
 static bool
 ParseVarnameGuard(const char **pp, const char **varname)
+{
 	const char *p = *pp;
 	if (ch_isalpha(*p) || *p == '_') {
 		while (ch_isalnum(*p) || *p == '_')
 			p++;
 		*varname = *pp;
 		*pp = p;
 		return true;
+	}
 	return false;
+}
 /* Extracts the multiple-inclusion guard from a conditional, if any. */
 Guard *
 Cond_ExtractGuard(const char *line)
+{
 	const char *p, *varname;
 	Substring dir;
 	Guard *guard;
 	p = line + 1;		/* skip the '.' */
 	cpp_skip_hspace(&p);
 	dir.start = p;
 	while (ch_isalpha(*p))
 		p++;
 	dir.end = p;
 	cpp_skip_hspace(&p);
 	if (Substring_Equals(dir, "if")) {
 		if (skip_string(&p, "!defined(")) {
 			if (ParseVarnameGuard(&p, &varname)
 			    && strcmp(p, ")") == 0)
 				goto found_variable;
 		} else if (skip_string(&p, "!target(")) {
 			const char *arg_p = p;
 			free(ParseWord(&p, false));
 			if (strcmp(p, ")") == 0) {
 				guard = bmake_malloc(sizeof(*guard));
 				guard->kind = GK_TARGET;
 				guard->name = ParseWord(&arg_p, true);
 				return guard;
+			}
+		}
 	} else if (Substring_Equals(dir, "ifndef")) {
 		if (ParseVarnameGuard(&p, &varname) && *p == '\0')
 			goto found_variable;
+	}
 	return NULL;
 found_variable:
 	guard = bmake_malloc(sizeof(*guard));
 	guard->kind = GK_VARIABLE;
 	guard->name = bmake_strsedup(varname, p);
 	return guard;
+}
 void
 Cond_EndFile(void)
+{
 	unsigned int open_conds = cond_depth - CurFile_CondMinDepth();
 	if (open_conds != 0) {
 		Parse_Error(PARSE_FATAL, "%u open conditional%s",
 		    open_conds, open_conds == 1 ? "" : "s");
 		cond_depth = CurFile_CondMinDepth();
+	}
+}

 @@ -1,1214 +1,1214 @@
-/*	$NetBSD: make.h,v 1.330 2024/04/20 10:18:55 rillig Exp $	*/
+/*	$NetBSD: make.h,v 1.331 2024/04/23 22:51:28 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 make
  */
 #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
 #define MAKE_GNUC_PREREQ(x, y)	0
 #endif
 #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
 #if MAKE_GNUC_PREREQ(4, 0)
 #define MAKE_ATTR_USE		__attribute__((__warn_unused_result__))
 #else
 #define MAKE_ATTR_USE		/* delete */
 #endif
 #if __STDC_VERSION__ >= 199901L || defined(lint)
 #define MAKE_INLINE static inline MAKE_ATTR_UNUSED
 #else
 #define MAKE_INLINE static MAKE_ATTR_UNUSED
 #endif
 /* MAKE_STATIC marks a function that may or may not be inlined. */
 #if defined(lint)
 /* As of 2021-07-31, NetBSD lint ignores __attribute__((unused)). */
 #define MAKE_STATIC MAKE_INLINE
 #else
 #define MAKE_STATIC static MAKE_ATTR_UNUSED
 #endif
 #if __STDC_VERSION__ >= 199901L || defined(lint) || defined(USE_C99_BOOLEAN)
 #include <stdbool.h>
 #elif defined(__bool_true_false_are_defined)
 /*
  * All files of make must be compiled with the same definition of bool.
  * Since one of the files includes <stdbool.h>, that means the header is
  * available on this platform.  Recompile everything with -DUSE_C99_BOOLEAN.
  */
 #error "<stdbool.h> is included in pre-C99 mode"
 #elif defined(bool) || defined(true) || defined(false)
 /*
  * In pre-C99 mode, make does not expect that bool is already defined.
  * You need to ensure that all translation units use the same definition for
  * bool.
  */
 #error "bool/true/false is defined in pre-C99 mode"
 #else
 typedef unsigned char bool;
 #define true	1
 #define false	0
 #endif
 #include "lst.h"
 #include "make_malloc.h"
 #include "str.h"
 #include "hash.h"
 #include "config.h"
 #include "buf.h"
 /*
  * The typical flow of states is:
+ *
  * The direct successful path:
  * UNMADE -> BEINGMADE -> MADE.
+ *
  * The direct error path:
  * UNMADE -> BEINGMADE -> ERROR.
+ *
  * The successful path when dependencies need to be made first:
  * UNMADE -> DEFERRED -> REQUESTED -> BEINGMADE -> MADE.
+ *
  * A node that has dependencies, and one of the dependencies cannot be made:
  * UNMADE -> DEFERRED -> ABORTED.
+ *
  * A node that turns out to be up-to-date:
  * UNMADE -> BEINGMADE -> UPTODATE.
  */
 typedef enum GNodeMade {
 	/* Not examined yet. */
 	UNMADE,
 	/*
 	 * The node has been examined but is not yet ready since its
 	 * dependencies have to be made first.
 	 */
 	DEFERRED,
 	/* The node is on the toBeMade list. */
 	REQUESTED,
 	/*
 	 * The node is already being made. Trying to build a node in this
 	 * state indicates a cycle in the graph.
 	 */
 	BEINGMADE,
 	/* Was out-of-date and has been made. */
 	MADE,
 	/* Was already up-to-date, does not need to be made. */
 	UPTODATE,
 	/*
 	 * An error occurred while it was being made. Used only in compat
 	 * mode.
 	 */
 	ERROR,
 	/*
 	 * The target was aborted due to an error making a dependency. Used
 	 * only in compat mode.
 	 */
 	ABORTED
 } 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.
+ *
  * See the tests depsrc-*.mk and deptgt-*.mk.
  */
 typedef enum GNodeType {
 	OP_NONE		= 0,
 	/*
 	 * 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. Each
 	 * individual dependency group is called a cohort.
 	 */
 	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 or .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 (.IMPSRC, .ALLSRC).
 	 */
 	OP_INVISIBLE	= 1 << 14,
 	/*
 	 * The node does not become the main target, even if it is the first
 	 * target in the first makefile.
 	 */
 	OP_NOTMAIN	= 1 << 15,
 	/* Not a file target; run always. */
 	OP_PHONY	= 1 << 16,
 	/* Don't search for the file in the path. */
 	OP_NOPATH	= 1 << 17,
 	/*
 	 * In a dependency line "target: source1 .WAIT source2", source1 is
 	 * made first, including its children.  Once that is finished,
 	 * source2 is made, including its children.  The .WAIT keyword may
 	 * appear more than once in a single dependency declaration.
 	 */
 	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, such as ".c.o". */
 	OP_TRANSFORM	= 1 << 30,
 	/* Target is a member of an archive */
 	/* XXX: How does this differ from OP_ARCHV? */
 	OP_MEMBER	= 1 << 29,
 	/*
 	 * The node is a library, its name has the form "-l<libname>".
 	 */
 	OP_LIB		= 1 << 28,
 	/*
 	 * The node is an archive member, its name has the form
 	 * "archive(member)".
 	 */
 	/* XXX: How does this differ from OP_MEMBER? */
 	OP_ARCHV	= 1 << 27,
 	/*
 	 * 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 << 26,
 	/*
 	 * 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 << 25,
 	/*
 	 * Already processed by Suff_FindDeps, to find dependencies from
 	 * suffix transformation rules.
 	 */
 	OP_DEPS_FOUND	= 1 << 24,
 	/* Node found while expanding .ALLSRC */
 	OP_MARK		= 1 << 23
 } GNodeType;
 typedef struct GNodeFlags {
 	/* this target needs to be (re)made */
 	bool remake:1;
 	/* children of this target were made */
 	bool childMade:1;
 	/* children don't exist, and we pretend made */
 	bool force:1;
 	/* Set by Make_ProcessWait() */
 	bool doneWait:1;
 	/* Build requested by .ORDER processing */
 	bool doneOrder:1;
 	/* Node created from .depend */
 	bool fromDepend:1;
 	/* We do it once only */
 	bool doneAllsrc:1;
 	/* Used by MakePrintStatus */
 	bool cycle:1;
 	/* Used by MakePrintStatus */
 	bool doneCycle:1;
 } GNodeFlags;
 typedef struct List StringList;
 typedef struct ListNode StringListNode;
 typedef struct List GNodeList;
 typedef struct ListNode GNodeListNode;
 typedef struct SearchPath {
 	List /* of CachedDir */ dirs;
 } SearchPath;
 /*
  * A graph node represents a target that can possibly be made, including its
- * relation to other targets and a lot of other details.
+ * relation to other targets.
  */
 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;
 	/* The number of unmade children */
 	int unmade;
 	/*
 	 * The modification time; 0 means the node does not have a
 	 * corresponding file; see GNode_IsOODate.
 	 */
 	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;
 	/*
 	 * 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;
 	/*
 	 * Other nodes of the same name, for targets that were defined using
 	 * the '::' dependency operator (OP_DOUBLEDEP).
 	 */
 	GNodeList cohorts;
 	/* 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 SCOPE_GLOBAL,
 	 * SCOPE_CMDLINE, SCOPE_INTERNAL, which contain variables with
 	 * arbitrary names.
 	 */
 	HashTable /* of Var pointer */ vars;
 	/* 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 Suffix *suffix;
 	/* Filename where the GNode got defined, unlimited lifetime */
 	const char *fname;
 	/* Line number where the GNode got defined, 1-based */
 	unsigned lineno;
 	int exit_status;
 } GNode;
 /*
  * Keep track of whether to include <posix.mk> when parsing the line
  * '.POSIX:'.
  */
 extern enum PosixState {
 	PS_NOT_YET,
 	PS_MAYBE_NEXT_LINE,
 	PS_NOW_OR_NEVER,
 	PS_TOO_LATE
 } posix_state;
 /* Error levels for diagnostics during parsing. */
 typedef enum ParseErrorLevel {
 	/*
 	 * Exit when the current top-level makefile has been parsed
 	 * completely.
 	 */
 	PARSE_FATAL = 1,
 	/* Print "warning"; may be upgraded to fatal by the -w option. */
 	PARSE_WARNING,
 	/* Informational, mainly used during development of makefiles. */
 	PARSE_INFO
 } ParseErrorLevel;
 /*
  * Values returned by Cond_EvalLine and Cond_EvalCondition.
  */
 typedef enum CondResult {
 	CR_TRUE,		/* Parse the next lines */
 	CR_FALSE,		/* Skip the next lines */
 	CR_ERROR		/* Unknown directive or parse error */
 } CondResult;
 typedef struct {
 	enum GuardKind {
 		GK_VARIABLE,
 		GK_TARGET
 	} kind;
 	char *name;
 } Guard;
 /* Names of the variables that are "local" to a specific target. */
 #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 */
 /*
  * Global Variables
  */
 /* True if every target is precious */
 extern bool allPrecious;
 /* True if failed targets should be deleted */
 extern bool deleteOnError;
 /* true while processing .depend */
 extern bool doing_depend;
 /* .DEFAULT rule */
 extern GNode *defaultNode;
 /*
  * Variables defined internally by make which should not override those set
  * by makefiles.
  */
 extern GNode *SCOPE_INTERNAL;
 /* Variables defined in a global scope, e.g in the makefile itself. */
 extern GNode *SCOPE_GLOBAL;
 /* Variables defined on the command line. */
 extern GNode *SCOPE_CMDLINE;
 /*
- * Value returned by Var_Parse when an error is encountered. It actually
+ * Value returned by Var_Parse when an error is encountered. It points to an
- * points to an empty string, so naive callers needn't worry about it.
+ * empty string, so naive callers needn't worry about it.
  */
 extern char var_Error[];
 /* The time at the start of this whole process */
 extern time_t now;
 /*
  * The list of directories to search when looking for targets (set by the
  * special target .PATH).
  */
 extern SearchPath dirSearchPath;
 /* Used for .include "...". */
 extern SearchPath *parseIncPath;
 /*
  * Used for .include <...>, for the built-in sys.mk and for makefiles from
  * the command line arguments.
  */
 extern SearchPath *sysIncPath;
 /* The default for sysIncPath. */
 extern SearchPath *defSysIncPath;
 /* Startup directory */
 extern char curdir[];
 /* The basename of the program name, suffixed with [n] for sub-makes.  */
 extern const char *progname;
 extern int makelevel;
 /* Name of the .depend makefile */
 extern char *makeDependfile;
 /* If we replaced environ, this will be non-NULL. */
 extern char **savedEnv;
 extern GNode *mainNode;
 extern pid_t myPid;
 #define MAKEFLAGS	".MAKEFLAGS"
 #ifndef MAKE_LEVEL_ENV
 # define MAKE_LEVEL_ENV	"MAKELEVEL"
 #endif
 typedef struct DebugFlags {
 	bool DEBUG_ARCH:1;
 	bool DEBUG_COND:1;
 	bool DEBUG_CWD:1;
 	bool DEBUG_DIR:1;
 	bool DEBUG_ERROR:1;
 	bool DEBUG_FOR:1;
 	bool DEBUG_GRAPH1:1;
 	bool DEBUG_GRAPH2:1;
 	bool DEBUG_GRAPH3:1;
 	bool DEBUG_HASH:1;
 	bool DEBUG_JOB:1;
 	bool DEBUG_LOUD:1;
 	bool DEBUG_MAKE:1;
 	bool DEBUG_META:1;
 	bool DEBUG_PARSE:1;
 	bool DEBUG_SCRIPT:1;
 	bool DEBUG_SHELL:1;
 	bool DEBUG_SUFF:1;
 	bool DEBUG_TARG:1;
 	bool DEBUG_VAR:1;
 } 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 DEBUG_IMPL(module, args) \
 	do { \
 		if (DEBUG(module)) \
 			debug_printf args; \
 	} while (false)
 #define DEBUG0(module, fmt) \
 	DEBUG_IMPL(module, (fmt))
 #define DEBUG1(module, fmt, arg1) \
 	DEBUG_IMPL(module, (fmt, arg1))
 #define DEBUG2(module, fmt, arg1, arg2) \
 	DEBUG_IMPL(module, (fmt, arg1, arg2))
 #define DEBUG3(module, fmt, arg1, arg2, arg3) \
 	DEBUG_IMPL(module, (fmt, arg1, arg2, arg3))
 #define DEBUG4(module, fmt, arg1, arg2, arg3, arg4) \
 	DEBUG_IMPL(module, (fmt, arg1, arg2, arg3, arg4))
 #define DEBUG5(module, fmt, arg1, arg2, arg3, arg4, arg5) \
 	DEBUG_IMPL(module, (fmt, arg1, arg2, arg3, arg4, arg5))
 typedef enum PrintVarsMode {
 	PVM_NONE,
 	PVM_UNEXPANDED,
 	PVM_EXPANDED
 } PrintVarsMode;
 /* Command line options */
 typedef struct CmdOpts {
-	/* -B: whether we are make compatible */
+	/* -B: whether to be compatible to traditional make */
 	bool compatMake;
 	/*
-	 * -d: debug control: There is one bit per module.  It is up to the
+	 * -d: debug control: There is one flag 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;
 	/*
 	 * -dL: lint mode
+	 *
 	 * Runs make in strict mode, with additional checks and better error
 	 * handling.
 	 */
 	bool strict;
 	/* -dV: for the -V option, print unexpanded variable values */
 	bool debugVflag;
 	/* -e: check environment variables before global variables */
 	bool checkEnvFirst;
 	/* -f: the makefiles to read */
 	StringList makefiles;
 	/* -i: if true, ignore all errors from shell commands */
 	bool ignoreErrors;
 	/*
 	 * -j: the maximum number of jobs that can run in parallel; this is
 	 * coordinated with the submakes
 	 */
 	int maxJobs;
 	/*
 	 * -k: if true and an error occurs while making a node, continue
 	 * making nodes that do not depend on the erroneous node
 	 */
 	bool keepgoing;
 	/* -N: execute no commands from the targets */
 	bool noRecursiveExecute;
 	/* -n: execute almost no commands from the targets */
 	bool noExecute;
 	/*
 	 * -q: if true, do not really make anything, just see if the targets
 	 * are out-of-date
 	 */
 	bool query;
 	/* -r: raw mode, do not load the builtin rules. */
 	bool noBuiltins;
 	/* -s: don't echo the shell commands before executing them */
 	bool silent;
 	/*
 	 * -t: touch the targets if they are out-of-date, but don't actually
 	 * make them
 	 */
 	bool touch;
 	/* -[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 */
 	bool parseWarnFatal;
 	/* -w: print 'Entering' and 'Leaving' for submakes */
 	bool enterFlag;
 	/*
 	 * -X: if true, do not export variables set on the command line to
 	 * the environment.
 	 */
 	bool varNoExportEnv;
 	/*
 	 * The target names specified on the command line. Used to resolve
 	 * .if make(...) statements.
 	 */
 	StringList create;
 	/*
 	 * Randomize the order in which the targets from toBeMade are made,
 	 * to catch undeclared dependencies.
 	 */
 	bool randomizeTargets;
 } CmdOpts;
 extern CmdOpts opts;
 extern bool forceJobs;
 extern char **environ;
 /* arch.c */
 void Arch_Init(void);
 void Arch_End(void);
 bool Arch_ParseArchive(char **, GNodeList *, GNode *);
 void Arch_Touch(GNode *);
 void Arch_TouchLib(GNode *);
 void Arch_UpdateMTime(GNode *);
 void Arch_UpdateMemberMTime(GNode *);
 void Arch_FindLib(GNode *, SearchPath *);
 bool Arch_LibOODate(GNode *) MAKE_ATTR_USE;
 bool Arch_IsLib(GNode *) MAKE_ATTR_USE;
 /* compat.c */
 bool Compat_RunCommand(const char *, GNode *, StringListNode *);
 void Compat_MakeAll(GNodeList *);
 void Compat_Make(GNode *, GNode *);
 /* cond.c */
 extern unsigned int cond_depth;
 CondResult Cond_EvalCondition(const char *) MAKE_ATTR_USE;
 CondResult Cond_EvalLine(const char *) MAKE_ATTR_USE;
 Guard *Cond_ExtractGuard(const char *) MAKE_ATTR_USE;
 void Cond_EndFile(void);
 /* dir.c; see also dir.h */
 MAKE_INLINE const char * MAKE_ATTR_USE
 str_basename(const char *pathname)
+{
 	const char *lastSlash = strrchr(pathname, '/');
 	return lastSlash != NULL ? lastSlash + 1 : pathname;
+}
 MAKE_INLINE SearchPath * MAKE_ATTR_USE
 SearchPath_New(void)
+{
 	SearchPath *path = bmake_malloc(sizeof *path);
 	Lst_Init(&path->dirs);
 	return path;
+}
 void SearchPath_Free(SearchPath *);
 /* for.c */
 struct ForLoop;
 int For_Eval(const char *) MAKE_ATTR_USE;
 bool For_Accum(const char *, int *) MAKE_ATTR_USE;
 void For_Run(unsigned, unsigned);
 bool For_NextIteration(struct ForLoop *, Buffer *);
 char *ForLoop_Details(const struct ForLoop *);
 void ForLoop_Free(struct ForLoop *);
 void For_Break(struct ForLoop *);
 /* job.c */
 void JobReapChild(pid_t, int, bool);
 /* main.c */
 void Main_ParseArgLine(const char *);
 char *Cmd_Exec(const char *, char **) MAKE_ATTR_USE;
 void Error(const char *, ...) MAKE_ATTR_PRINTFLIKE(1, 2);
 void Fatal(const char *, ...) MAKE_ATTR_PRINTFLIKE(1, 2) MAKE_ATTR_DEAD;
 void Punt(const char *, ...) MAKE_ATTR_PRINTFLIKE(1, 2) MAKE_ATTR_DEAD;
 void DieHorribly(void) MAKE_ATTR_DEAD;
 void Finish(int) MAKE_ATTR_DEAD;
 int unlink_file(const char *) MAKE_ATTR_USE;
 void execDie(const char *, const char *);
 char *getTmpdir(void) MAKE_ATTR_USE;
 bool ParseBoolean(const char *, bool) MAKE_ATTR_USE;
 const char *cached_realpath(const char *, char *);
 bool GetBooleanExpr(const char *, bool);
 /* parse.c */
 void Parse_Init(void);
 void Parse_End(void);
 void PrintLocation(FILE *, bool, const GNode *);
 void PrintStackTrace(bool);
 void Parse_Error(ParseErrorLevel, const char *, ...) MAKE_ATTR_PRINTFLIKE(2, 3);
 bool Parse_VarAssign(const char *, bool, GNode *) MAKE_ATTR_USE;
 void Parse_File(const char *, int);
 void Parse_PushInput(const char *, unsigned, unsigned, Buffer,
 		     struct ForLoop *);
 void Parse_MainName(GNodeList *);
 int Parse_NumErrors(void) MAKE_ATTR_USE;
 unsigned int CurFile_CondMinDepth(void) MAKE_ATTR_USE;
 void Parse_GuardElse(void);
 void Parse_GuardEndif(void);
 /* suff.c */
 void Suff_Init(void);
 void Suff_End(void);
 void Suff_ClearSuffixes(void);
 bool Suff_IsTransform(const char *) MAKE_ATTR_USE;
 GNode *Suff_AddTransform(const char *);
 void Suff_EndTransform(GNode *);
 void Suff_AddSuffix(const char *);
 SearchPath *Suff_GetPath(const char *) MAKE_ATTR_USE;
 void Suff_ExtendPaths(void);
 void Suff_AddInclude(const char *);
 void Suff_AddLib(const char *);
 void Suff_FindDeps(GNode *);
 SearchPath *Suff_FindPath(GNode *) MAKE_ATTR_USE;
 void Suff_SetNull(const char *);
 void Suff_PrintAll(void);
 char *Suff_NamesStr(void) MAKE_ATTR_USE;
 /* targ.c */
 void Targ_Init(void);
 void Targ_End(void);
 void Targ_Stats(void);
 GNodeList *Targ_List(void) MAKE_ATTR_USE;
 GNode *GNode_New(const char *) MAKE_ATTR_USE;
 GNode *Targ_FindNode(const char *) MAKE_ATTR_USE;
 GNode *Targ_GetNode(const char *) MAKE_ATTR_USE;
 GNode *Targ_NewInternalNode(const char *) MAKE_ATTR_USE;
 GNode *Targ_GetEndNode(void);
 void Targ_FindList(GNodeList *, StringList *);
 void Targ_PrintCmds(GNode *);
 void Targ_PrintNode(GNode *, int);
 void Targ_PrintNodes(GNodeList *, int);
 const char *Targ_FmtTime(time_t) MAKE_ATTR_USE;
 void Targ_PrintType(GNodeType);
 void Targ_PrintGraph(int);
 void Targ_Propagate(void);
 const char *GNodeMade_Name(GNodeMade) MAKE_ATTR_USE;
 /* var.c */
 void Var_Init(void);
 void Var_End(void);
 typedef enum VarEvalMode {
 	/*
 	 * Only parse the expression but don't evaluate any part of it.
+	 *
 	 * TODO: Document what Var_Parse and Var_Subst return in this mode.
 	 *  As of 2021-03-15, they return unspecified, inconsistent results.
 	 */
 	VARE_PARSE_ONLY,
 	/*
 	 * Parse text in which '${...}' and '$(...)' are not parsed as
 	 * subexpressions (with all their individual escaping rules) but
 	 * instead simply as text with balanced '${}' or '$()'.  Other '$'
 	 * are copied verbatim.
 	 */
 	VARE_PARSE_BALANCED,
 	/* Parse and evaluate the expression. */
 	VARE_WANTRES,
 	/*
 	 * Parse and evaluate the expression.  It is an error if a
 	 * subexpression evaluates to undefined.
 	 */
 	VARE_UNDEFERR,
 	/*
 	 * Parse and evaluate the expression.  Keep '$$' as '$$' instead of
 	 * reducing it to a single '$'.  Subexpressions that evaluate to
 	 * undefined expand to an empty string.
+	 *
 	 * Used in variable assignments using the ':=' operator.  It allows
 	 * multiple such assignments to be chained without accidentally
 	 * expanding '$$file' to '$file' in the first assignment and
 	 * interpreting it as '${f}' followed by 'ile' in the next assignment.
 	 */
 	VARE_EVAL_KEEP_DOLLAR,
 	/*
 	 * Parse and evaluate the expression.  Keep undefined variables as-is
 	 * instead of expanding them to an empty string.
+	 *
 	 * Example for a ':=' assignment:
 	 *	CFLAGS = $(.INCLUDES)
 	 *	CFLAGS := -I.. $(CFLAGS)
 	 *	# If .INCLUDES (an undocumented special variable, by the
 	 *	# way) is still undefined, the updated CFLAGS becomes
 	 *	# "-I.. $(.INCLUDES)".
 	 */
 	VARE_EVAL_KEEP_UNDEF,
 	/*
 	 * Parse and evaluate the expression.  Keep '$$' as '$$' and preserve
 	 * undefined subexpressions.
 	 */
 	VARE_KEEP_DOLLAR_UNDEF
 } VarEvalMode;
 typedef enum VarSetFlags {
 	VAR_SET_NONE		= 0,
 	/* do not export */
 	VAR_SET_NO_EXPORT	= 1 << 0,
 	/*
 	 * Make the variable read-only. No further modification is possible,
 	 * except for another call to Var_Set with the same flag. See the
 	 * special targets '.NOREADONLY' and '.READONLY'.
 	 */
 	VAR_SET_READONLY	= 1 << 1
 } VarSetFlags;
 typedef enum VarExportMode {
 	/* .export-env */
 	VEM_ENV,
 	/* .export: Initial export or update an already exported variable. */
 	VEM_PLAIN,
 	/* .export-literal: Do not expand the variable value. */
 	VEM_LITERAL
 } VarExportMode;
 void Var_Delete(GNode *, const char *);
 void Var_Undef(const char *);
 void Var_Set(GNode *, const char *, const char *);
 void Var_SetExpand(GNode *, const char *, const char *);
 void Var_SetWithFlags(GNode *, const char *, const char *, VarSetFlags);
 void Var_Append(GNode *, const char *, const char *);
 void Var_AppendExpand(GNode *, const char *, const char *);
 bool Var_Exists(GNode *, const char *) MAKE_ATTR_USE;
 bool Var_ExistsExpand(GNode *, const char *) MAKE_ATTR_USE;
 FStr Var_Value(GNode *, const char *) MAKE_ATTR_USE;
 const char *GNode_ValueDirect(GNode *, const char *) MAKE_ATTR_USE;
 FStr Var_Parse(const char **, GNode *, VarEvalMode);
 char *Var_Subst(const char *, GNode *, VarEvalMode);
 void Var_Expand(FStr *, GNode *, VarEvalMode);
 void Var_Stats(void);
 void Var_Dump(GNode *);
 void Var_ReexportVars(GNode *);
 void Var_Export(VarExportMode, const char *);
 void Var_ExportVars(const char *);
 void Var_UnExport(bool, const char *);
 void Var_ReadOnly(const char *, bool);
 void Global_Set(const char *, const char *);
 void Global_Append(const char *, const char *);
 void Global_Delete(const char *);
 void Global_Set_ReadOnly(const char *, const char *);
 void EvalStack_Push(const char *, const char *, const char *);
 void EvalStack_Pop(void);
 const char *EvalStack_Details(void);
 /* util.c */
 typedef void (*SignalProc)(int);
 SignalProc bmake_signal(int, SignalProc);
 /* make.c */
 void GNode_UpdateYoungestChild(GNode *, GNode *);
 bool GNode_IsOODate(GNode *) MAKE_ATTR_USE;
 void Make_ExpandUse(GNodeList *);
 time_t Make_Recheck(GNode *) MAKE_ATTR_USE;
 void Make_HandleUse(GNode *, GNode *);
 void Make_Update(GNode *);
 void GNode_SetLocalVars(GNode *);
 bool Make_Run(GNodeList *);
 bool shouldDieQuietly(GNode *, int) MAKE_ATTR_USE;
 void PrintOnError(GNode *, const char *);
 void Main_ExportMAKEFLAGS(bool);
 bool Main_SetObjdir(bool, const char *, ...) MAKE_ATTR_PRINTFLIKE(2, 3);
 int mkTempFile(const char *, char *, size_t) MAKE_ATTR_USE;
 void AppendWords(StringList *, char *);
 void GNode_FprintDetails(FILE *, const char *, const GNode *, const char *);
 bool GNode_ShouldExecute(GNode *gn) MAKE_ATTR_USE;
 /* See if the node was seen on the left-hand side of a dependency operator. */
 MAKE_INLINE bool MAKE_ATTR_USE
 GNode_IsTarget(const GNode *gn)
+{
 	return (gn->type & OP_OPMASK) != OP_NONE;
+}
 MAKE_INLINE const char * MAKE_ATTR_USE
 GNode_Path(const GNode *gn)
+{
 	return gn->path != NULL ? gn->path : gn->name;
+}
 MAKE_INLINE bool MAKE_ATTR_USE
 GNode_IsWaitingFor(const GNode *gn)
+{
 	return gn->flags.remake && gn->made <= REQUESTED;
+}
 MAKE_INLINE bool MAKE_ATTR_USE
 GNode_IsReady(const GNode *gn)
+{
 	return gn->made > DEFERRED;
+}
 MAKE_INLINE bool MAKE_ATTR_USE
 GNode_IsDone(const GNode *gn)
+{
 	return gn->made >= MADE;
+}
 MAKE_INLINE bool MAKE_ATTR_USE
 GNode_IsError(const GNode *gn)
+{
 	return gn->made == ERROR || gn->made == ABORTED;
+}
 MAKE_INLINE bool MAKE_ATTR_USE
 GNode_IsMainCandidate(const GNode *gn)
+{
 	return (gn->type & (OP_NOTMAIN | OP_USE | OP_USEBEFORE |
 			    OP_EXEC | OP_TRANSFORM)) == 0;
+}
 /* Return whether the target file should be preserved on interrupt. */
 MAKE_INLINE bool MAKE_ATTR_USE
 GNode_IsPrecious(const GNode *gn)
+{
 	/* XXX: Why are '::' targets precious? */
 	return allPrecious || gn->type & (OP_PRECIOUS | OP_DOUBLEDEP);
+}
 MAKE_INLINE const char * MAKE_ATTR_USE
 GNode_VarTarget(GNode *gn) { return GNode_ValueDirect(gn, TARGET); }
 MAKE_INLINE const char * MAKE_ATTR_USE
 GNode_VarOodate(GNode *gn) { return GNode_ValueDirect(gn, OODATE); }
 MAKE_INLINE const char * MAKE_ATTR_USE
 GNode_VarAllsrc(GNode *gn) { return GNode_ValueDirect(gn, ALLSRC); }
 MAKE_INLINE const char * MAKE_ATTR_USE
 GNode_VarImpsrc(GNode *gn) { return GNode_ValueDirect(gn, IMPSRC); }
 MAKE_INLINE const char * MAKE_ATTR_USE
 GNode_VarPrefix(GNode *gn) { return GNode_ValueDirect(gn, PREFIX); }
 MAKE_INLINE const char * MAKE_ATTR_USE
 GNode_VarArchive(GNode *gn) { return GNode_ValueDirect(gn, ARCHIVE); }
 MAKE_INLINE const char * MAKE_ATTR_USE
 GNode_VarMember(GNode *gn) { return GNode_ValueDirect(gn, MEMBER); }
 MAKE_INLINE void * MAKE_ATTR_USE
 UNCONST(const void *ptr)
+{
 	void *ret;
 	memcpy(&ret, &ptr, sizeof(ret));
 	return ret;
+}
 /* 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
 MAKE_INLINE bool MAKE_ATTR_USE
 ch_isalnum(char ch) { return isalnum((unsigned char)ch) != 0; }
 MAKE_INLINE bool MAKE_ATTR_USE
 ch_isalpha(char ch) { return isalpha((unsigned char)ch) != 0; }
 MAKE_INLINE bool MAKE_ATTR_USE
 ch_isdigit(char ch) { return isdigit((unsigned char)ch) != 0; }
 MAKE_INLINE bool MAKE_ATTR_USE
 ch_islower(char ch) { return islower((unsigned char)ch) != 0; }
 MAKE_INLINE bool MAKE_ATTR_USE
 ch_isspace(char ch) { return isspace((unsigned char)ch) != 0; }
 MAKE_INLINE bool MAKE_ATTR_USE
 ch_isupper(char ch) { return isupper((unsigned char)ch) != 0; }
 MAKE_INLINE char MAKE_ATTR_USE
 ch_tolower(char ch) { return (char)tolower((unsigned char)ch); }
 MAKE_INLINE char MAKE_ATTR_USE
 ch_toupper(char ch) { return (char)toupper((unsigned char)ch); }
 MAKE_INLINE void
 cpp_skip_whitespace(const char **pp)
+{
 	while (ch_isspace(**pp))
 		(*pp)++;
+}
 MAKE_INLINE void
 cpp_skip_hspace(const char **pp)
+{
 	while (**pp == ' ' || **pp == '\t')
 		(*pp)++;
+}
 MAKE_INLINE bool
 cpp_skip_string(const char **pp, const char *s)
+{
 	const char *p = *pp;
 	while (*p == *s && *s != '\0')
 		p++, s++;
 	if (*s == '\0')
 		*pp = p;
 	return *s == '\0';
+}
 MAKE_INLINE void
 pp_skip_whitespace(char **pp)
+{
 	while (ch_isspace(**pp))
 		(*pp)++;
+}
 MAKE_INLINE void
 pp_skip_hspace(char **pp)
+{
 	while (**pp == ' ' || **pp == '\t')
 		(*pp)++;
+}
 #if defined(lint)
 void do_not_define_rcsid(void); /* for lint */
 # define MAKE_RCSID(id) void do_not_define_rcsid(void)
 #elif defined(MAKE_NATIVE)
 # include <sys/cdefs.h>
 # define MAKE_RCSID(id) __RCSID(id)
 #elif defined(MAKE_ALL_IN_ONE) && defined(__COUNTER__)
 # define MAKE_RCSID_CONCAT(x, y) CONCAT(x, y)
 # define MAKE_RCSID(id) static volatile char \
 	MAKE_RCSID_CONCAT(rcsid_, __COUNTER__)[] = id
 #elif defined(MAKE_ALL_IN_ONE)
 # define MAKE_RCSID(id) void do_not_define_rcsid(void)
 #else
 # define MAKE_RCSID(id) static volatile char rcsid[] = id
 #endif
 #endif

 @@ -1,2653 +1,2653 @@
-/*	$NetBSD: parse.c,v 1.720 2024/04/20 10:18:55 rillig Exp $	*/
+/*	$NetBSD: parse.c,v 1.721 2024/04/23 22:51:28 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.
  */
 /*
  * Parsing of makefiles.
+ *
  * Parse_File is the main entry point and controls most of the other
  * functions in this module.
+ *
  * Interface:
  *	Parse_Init	Initialize the module
+ *
  *	Parse_End	Clean up the module
+ *
  *	Parse_File	Parse a top-level makefile.  Included files are
  *			handled by IncludeFile instead.
+ *
  *	Parse_VarAssign
  *			Try to parse the given line as a variable assignment.
  *			Used by MainParseArgs to determine if an argument is
  *			a target or a variable assignment.  Used internally
  *			for pretty much the same thing.
+ *
  *	Parse_Error	Report a parse error, a warning or an informational
  *			message.
+ *
  *	Parse_MainName	Populate the list of targets to create.
  */
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <errno.h>
 #include <stdarg.h>
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #include "pathnames.h"
 /*	"@(#)parse.c	8.3 (Berkeley) 3/19/94"	*/
-MAKE_RCSID("$NetBSD: parse.c,v 1.720 2024/04/20 10:18:55 rillig Exp $");
+MAKE_RCSID("$NetBSD: parse.c,v 1.721 2024/04/23 22:51:28 rillig Exp $");
 /* Detects a multiple-inclusion guard in a makefile. */
 typedef enum {
 	GS_START,		/* at the beginning of the file */
 	GS_COND,		/* after the guard condition */
 	GS_DONE,		/* after the closing .endif */
 	GS_NO			/* the file is not guarded */
 } GuardState;
 /* A file being parsed. */
 typedef struct IncludedFile {
 	FStr name;		/* absolute or relative to the cwd */
 	unsigned lineno;	/* 1-based */
 	unsigned readLines;	/* the number of physical lines that have
 				 * been read from the file */
 	unsigned forHeadLineno;	/* 1-based */
 	unsigned forBodyReadLines; /* the number of physical lines that have
 				 * been read from the file above the body of
 				 * the .for loop */
 	unsigned int condMinDepth; /* depth of nested 'if' directives, at the
 				 * beginning of the file */
 	bool depending;		/* state of doing_depend on EOF */
 	Buffer buf;		/* the file's content or the body of the .for
 				 * loop; either empty or ends with '\n' */
 	char *buf_ptr;		/* next char to be read from buf */
 	char *buf_end;		/* buf_end[-1] == '\n' */
 	GuardState guardState;
 	Guard *guard;
 	struct ForLoop *forLoop;
 } IncludedFile;
 /* Special attributes for target nodes. */
 typedef enum ParseSpecial {
 	SP_ATTRIBUTE,	/* Generic attribute */
 	SP_BEGIN,	/* .BEGIN */
 	SP_DEFAULT,	/* .DEFAULT */
 	SP_DELETE_ON_ERROR, /* .DELETE_ON_ERROR */
 	SP_END,		/* .END */
 	SP_ERROR,	/* .ERROR */
 	SP_IGNORE,	/* .IGNORE */
 	SP_INCLUDES,	/* .INCLUDES; not mentioned in the manual page */
 	SP_INTERRUPT,	/* .INTERRUPT */
 	SP_LIBS,	/* .LIBS; not mentioned in the manual page */
 	SP_MAIN,	/* .MAIN and no user-specified targets to make */
 	SP_META,	/* .META */
 	SP_MFLAGS,	/* .MFLAGS or .MAKEFLAGS */
 	SP_NOMETA,	/* .NOMETA */
 	SP_NOMETA_CMP,	/* .NOMETA_CMP */
 	SP_NOPATH,	/* .NOPATH */
 	SP_NOREADONLY,	/* .NOREADONLY */
 	SP_NOT,		/* Not special */
 	SP_NOTPARALLEL,	/* .NOTPARALLEL or .NO_PARALLEL */
 	SP_NULL,	/* .NULL; not mentioned in the manual page */
 	SP_OBJDIR,	/* .OBJDIR */
 	SP_ORDER,	/* .ORDER */
 	SP_PARALLEL,	/* .PARALLEL; not mentioned in the manual page */
 	SP_PATH,	/* .PATH or .PATH.suffix */
 	SP_PHONY,	/* .PHONY */
 	SP_POSIX,	/* .POSIX; not mentioned in the manual page */
 	SP_PRECIOUS,	/* .PRECIOUS */
 	SP_READONLY,	/* .READONLY */
 	SP_SHELL,	/* .SHELL */
 	SP_SILENT,	/* .SILENT */
 	SP_SINGLESHELL,	/* .SINGLESHELL; not mentioned in the manual page */
 	SP_STALE,	/* .STALE */
 	SP_SUFFIXES,	/* .SUFFIXES */
 	SP_SYSPATH,	/* .SYSPATH */
 	SP_WAIT		/* .WAIT */
 } ParseSpecial;
 typedef List SearchPathList;
 typedef ListNode SearchPathListNode;
 typedef enum VarAssignOp {
 	VAR_NORMAL,		/* = */
 	VAR_APPEND,		/* += */
 	VAR_DEFAULT,		/* ?= */
 	VAR_SUBST,		/* := */
 	VAR_SHELL		/* != or :sh= */
 } VarAssignOp;
 typedef struct VarAssign {
 	char *varname;		/* unexpanded */
 	VarAssignOp op;
 	const char *value;	/* unexpanded */
 } VarAssign;
 static bool Parse_IsVar(const char *, VarAssign *);
 static void Parse_Var(VarAssign *, GNode *);
 /*
  * The target to be made if no targets are specified in the command line.
  * This is the first target defined in any of the makefiles.
  */
 GNode *mainNode;
 /*
  * During parsing, the targets from the left-hand side of the currently
  * active dependency line, or NULL if the current line does not belong to a
  * dependency line, for example because it is a variable assignment.
+ *
  * See unit-tests/deptgt.mk, keyword "parse.c:targets".
  */
 static GNodeList *targets;
 #ifdef CLEANUP
 /*
  * All shell commands for all targets, in no particular order and possibly
  * with duplicates.  Kept in a separate list since the commands from .USE or
  * .USEBEFORE nodes are shared with other GNodes, thereby giving up the
  * easily understandable ownership over the allocated strings.
  */
 static StringList targCmds = LST_INIT;
 #endif
 /*
  * Predecessor node for handling .ORDER. Initialized to NULL when .ORDER
  * is seen, then set to each successive source on the line.
  */
 static GNode *order_pred;
 static int parseErrors;
 /*
  * The include chain of makefiles.  At index 0 is the top-level makefile from
  * the command line, followed by the included files or .for loops, up to and
  * including the current file.
+ *
  * See PrintStackTrace for how to interpret the data.
  */
 static Vector /* of IncludedFile */ includes;
 SearchPath *parseIncPath;	/* directories for "..." includes */
 SearchPath *sysIncPath;		/* directories for <...> includes */
 SearchPath *defSysIncPath;	/* default for sysIncPath */
 /*
  * The parseKeywords table is searched using binary search when deciding
  * if a target or source is special.
  */
 static const struct {
 	const char name[17];
 	ParseSpecial special;	/* when used as a target */
 	GNodeType targetAttr;	/* when used as a source */
 } parseKeywords[] = {
     { ".BEGIN",		SP_BEGIN,	OP_NONE },
     { ".DEFAULT",	SP_DEFAULT,	OP_NONE },
     { ".DELETE_ON_ERROR", SP_DELETE_ON_ERROR, OP_NONE },
     { ".END",		SP_END,		OP_NONE },
     { ".ERROR",		SP_ERROR,	OP_NONE },
     { ".EXEC",		SP_ATTRIBUTE,	OP_EXEC },
     { ".IGNORE",	SP_IGNORE,	OP_IGNORE },
     { ".INCLUDES",	SP_INCLUDES,	OP_NONE },
     { ".INTERRUPT",	SP_INTERRUPT,	OP_NONE },
     { ".INVISIBLE",	SP_ATTRIBUTE,	OP_INVISIBLE },
     { ".JOIN",		SP_ATTRIBUTE,	OP_JOIN },
     { ".LIBS",		SP_LIBS,	OP_NONE },
     { ".MADE",		SP_ATTRIBUTE,	OP_MADE },
     { ".MAIN",		SP_MAIN,	OP_NONE },
     { ".MAKE",		SP_ATTRIBUTE,	OP_MAKE },
     { ".MAKEFLAGS",	SP_MFLAGS,	OP_NONE },
     { ".META",		SP_META,	OP_META },
     { ".MFLAGS",	SP_MFLAGS,	OP_NONE },
     { ".NOMETA",	SP_NOMETA,	OP_NOMETA },
     { ".NOMETA_CMP",	SP_NOMETA_CMP,	OP_NOMETA_CMP },
     { ".NOPATH",	SP_NOPATH,	OP_NOPATH },
     { ".NOREADONLY",	SP_NOREADONLY,	OP_NONE },
     { ".NOTMAIN",	SP_ATTRIBUTE,	OP_NOTMAIN },
     { ".NOTPARALLEL",	SP_NOTPARALLEL,	OP_NONE },
     { ".NO_PARALLEL",	SP_NOTPARALLEL,	OP_NONE },
     { ".NULL",		SP_NULL,	OP_NONE },
     { ".OBJDIR",	SP_OBJDIR,	OP_NONE },
     { ".OPTIONAL",	SP_ATTRIBUTE,	OP_OPTIONAL },
     { ".ORDER",		SP_ORDER,	OP_NONE },
     { ".PARALLEL",	SP_PARALLEL,	OP_NONE },
     { ".PATH",		SP_PATH,	OP_NONE },
     { ".PHONY",		SP_PHONY,	OP_PHONY },
     { ".POSIX",		SP_POSIX,	OP_NONE },
     { ".PRECIOUS",	SP_PRECIOUS,	OP_PRECIOUS },
     { ".READONLY",	SP_READONLY,	OP_NONE },
     { ".RECURSIVE",	SP_ATTRIBUTE,	OP_MAKE },
     { ".SHELL",		SP_SHELL,	OP_NONE },
     { ".SILENT",	SP_SILENT,	OP_SILENT },
     { ".SINGLESHELL",	SP_SINGLESHELL,	OP_NONE },
     { ".STALE",		SP_STALE,	OP_NONE },
     { ".SUFFIXES",	SP_SUFFIXES,	OP_NONE },
     { ".SYSPATH",	SP_SYSPATH,	OP_NONE },
     { ".USE",		SP_ATTRIBUTE,	OP_USE },
     { ".USEBEFORE",	SP_ATTRIBUTE,	OP_USEBEFORE },
     { ".WAIT",		SP_WAIT,	OP_NONE },
 };
 enum PosixState posix_state = PS_NOT_YET;
 static HashTable /* full file name -> Guard */ guards;
 static List *
 Lst_New(void)
+{
 	List *list = bmake_malloc(sizeof *list);
 	Lst_Init(list);
 	return list;
+}
 static void
 Lst_Free(List *list)
+{
 	Lst_Done(list);
 	free(list);
+}
 static IncludedFile *
 GetInclude(size_t i)
+{
 	assert(i < includes.len);
 	return Vector_Get(&includes, i);
+}
 /* The makefile or the body of a .for loop that is currently being read. */
 static IncludedFile *
 CurFile(void)
+{
 	return GetInclude(includes.len - 1);
+}
 unsigned int
 CurFile_CondMinDepth(void)
+{
 	return CurFile()->condMinDepth;
+}
 static Buffer
 LoadFile(const char *path, int fd)
+{
 	ssize_t n;
 	Buffer buf;
 	size_t bufSize;
 	struct stat st;
 	bufSize = fstat(fd, &st) == 0 && S_ISREG(st.st_mode) &&
 		  st.st_size > 0 && st.st_size < 1024 * 1024 * 1024
 	    ? (size_t)st.st_size : 1024;
 	Buf_InitSize(&buf, bufSize);
 	for (;;) {
 		if (buf.len == buf.cap) {
 			if (buf.cap >= 512 * 1024 * 1024) {
 				Error("%s: file too large", path);
 				exit(2); /* Not 1 so -q can distinguish error */
+			}
 			Buf_Expand(&buf);
+		}
 		assert(buf.len < buf.cap);
 		n = read(fd, buf.data + buf.len, buf.cap - buf.len);
 		if (n < 0) {
 			Error("%s: read error: %s", path, strerror(errno));
 			exit(2);	/* Not 1 so -q can distinguish error */
+		}
 		if (n == 0)
 			break;
 		buf.len += (size_t)n;
+	}
 	assert(buf.len <= buf.cap);
 	if (buf.len > 0 && !Buf_EndsWith(&buf, '\n'))
 		Buf_AddByte(&buf, '\n');
 	return buf;		/* may not be null-terminated */
+}
 /*
  * Print the current chain of .include and .for directives.  In Parse_Fatal
  * or other functions that already print the location, includingInnermost
  * would be redundant, but in other cases like Error or Fatal it needs to be
  * included.
  */
 void
 PrintStackTrace(bool includingInnermost)
+{
 	const IncludedFile *entries;
 	size_t i, n;
 	n = includes.len;
 	if (n == 0)
 		return;
 	entries = GetInclude(0);
 	if (!includingInnermost && entries[n - 1].forLoop == NULL)
 		n--;		/* already in the diagnostic */
 	for (i = n; i-- > 0;) {
 		const IncludedFile *entry = entries + i;
 		const char *fname = entry->name.str;
 		char dirbuf[MAXPATHLEN + 1];
 		if (fname[0] != '/' && strcmp(fname, "(stdin)") != 0) {
 			const char *realPath = realpath(fname, dirbuf);
 			if (realPath != NULL)
 				fname = realPath;
+		}
 		if (entry->forLoop != NULL) {
 			char *details = ForLoop_Details(entry->forLoop);
 			debug_printf("\tin .for loop from %s:%u with %s\n",
 			    fname, entry->forHeadLineno, details);
 			free(details);
 		} else if (i + 1 < n && entries[i + 1].forLoop != NULL) {
 			/* entry->lineno is not a useful line number */
 		} else
 			debug_printf("\tin %s:%u\n", fname, entry->lineno);
+	}
+}
 /* Check if the current character is escaped on the current line. */
 static bool
 IsEscaped(const char *line, const char *p)
+{
 	bool escaped = false;
 	while (p > line && *--p == '\\')
 		escaped = !escaped;
 	return escaped;
+}
 /*
  * Remember the location (filename and lineno) where the last command was
  * added or where the node was mentioned in a .depend file.
  */
 static void
 RememberLocation(GNode *gn)
+{
 	IncludedFile *curFile = CurFile();
 	gn->fname = Str_Intern(curFile->name.str);
 	gn->lineno = curFile->lineno;
+}
 /*
  * Look in the table of keywords for one matching the given string.
  * Return the index of the keyword, or -1 if it isn't there.
  */
 static int
 FindKeyword(const char *str)
+{
 	int start = 0;
 	int end = sizeof parseKeywords / sizeof parseKeywords[0] - 1;
 	while (start <= end) {
 		int curr = start + (end - start) / 2;
 		int diff = strcmp(str, parseKeywords[curr].name);
 		if (diff == 0)
 			return curr;
 		if (diff < 0)
 			end = curr - 1;
 		else
 			start = curr + 1;
+	}
 	return -1;
+}
 void
 PrintLocation(FILE *f, bool useVars, const GNode *gn)
+{
 	char dirbuf[MAXPATHLEN + 1];
 	FStr dir, base;
 	const char *fname;
 	unsigned lineno;
 	if (gn != NULL) {
 		fname = gn->fname;
 		lineno = gn->lineno;
 	} else if (includes.len > 0) {
 		IncludedFile *curFile = CurFile();
 		fname = curFile->name.str;
 		lineno = curFile->lineno;
 	} else
 		return;
 	if (!useVars || fname[0] == '/' || strcmp(fname, "(stdin)") == 0) {
 		(void)fprintf(f, "\"%s\" line %u: ", fname, lineno);
 		return;
+	}
 	dir = Var_Value(SCOPE_GLOBAL, ".PARSEDIR");
 	if (dir.str == NULL)
 		dir.str = ".";
 	if (dir.str[0] != '/')
 		dir.str = realpath(dir.str, dirbuf);
 	base = Var_Value(SCOPE_GLOBAL, ".PARSEFILE");
 	if (base.str == NULL)
 		base.str = str_basename(fname);
 	(void)fprintf(f, "\"%s/%s\" line %u: ", dir.str, base.str, lineno);
 	FStr_Done(&base);
 	FStr_Done(&dir);
+}
 static void MAKE_ATTR_PRINTFLIKE(5, 0)
 ParseVErrorInternal(FILE *f, bool useVars, const GNode *gn,
 		    ParseErrorLevel level, const char *fmt, va_list ap)
+{
 	static bool fatal_warning_error_printed = false;
 	(void)fprintf(f, "%s: ", progname);
 	PrintLocation(f, useVars, gn);
 	fprintf(f, "%s", EvalStack_Details());
 	if (level == PARSE_WARNING)
 		(void)fprintf(f, "warning: ");
 	(void)vfprintf(f, fmt, ap);
 	(void)fprintf(f, "\n");
 	(void)fflush(f);
 	if (level == PARSE_FATAL)
 		parseErrors++;
 	if (level == PARSE_WARNING && opts.parseWarnFatal) {
 		if (!fatal_warning_error_printed) {
 			Error("parsing warnings being treated as errors");
 			fatal_warning_error_printed = true;
+		}
 		parseErrors++;
+	}
 	if (DEBUG(PARSE))
 		PrintStackTrace(false);
+}
 static void MAKE_ATTR_PRINTFLIKE(3, 4)
 ParseErrorInternal(const GNode *gn,
 		   ParseErrorLevel level, const char *fmt, ...)
+{
 	va_list ap;
 	(void)fflush(stdout);
 	va_start(ap, fmt);
 	ParseVErrorInternal(stderr, false, gn, level, fmt, ap);
 	va_end(ap);
 	if (opts.debug_file != stdout && opts.debug_file != stderr) {
 		va_start(ap, fmt);
 		ParseVErrorInternal(opts.debug_file, false, gn,
 		    level, fmt, ap);
 		va_end(ap);
+	}
+}
 /*
  * Print a message, including location information.
+ *
  * If the level is PARSE_FATAL, continue parsing until the end of the
  * current top-level makefile, then exit (see Parse_File).
+ *
  * Fmt is given without a trailing newline.
  */
 void
 Parse_Error(ParseErrorLevel level, const char *fmt, ...)
+{
 	va_list ap;
 	(void)fflush(stdout);
 	va_start(ap, fmt);
 	ParseVErrorInternal(stderr, true, NULL, level, fmt, ap);
 	va_end(ap);
 	if (opts.debug_file != stdout && opts.debug_file != stderr) {
 		va_start(ap, fmt);
 		ParseVErrorInternal(opts.debug_file, true, NULL,
 		    level, fmt, ap);
 		va_end(ap);
+	}
+}
 /*
  * Handle an .info, .warning or .error directive.  For an .error directive,
  * exit immediately.
  */
 static void
 HandleMessage(ParseErrorLevel level, const char *levelName, const char *umsg)
+{
 	char *xmsg;
 	if (umsg[0] == '\0') {
 		Parse_Error(PARSE_FATAL, "Missing argument for \".%s\"",
 		    levelName);
 		return;
+	}
 	xmsg = Var_Subst(umsg, SCOPE_CMDLINE, VARE_WANTRES);
 	/* TODO: handle errors */
 	Parse_Error(level, "%s", xmsg);
 	free(xmsg);
 	if (level == PARSE_FATAL) {
 		PrintOnError(NULL, "\n");
 		exit(1);
+	}
+}
 /*
  * Add the child to the parent's children, and for non-special targets, vice
  * versa.
  */
 static void
 LinkSource(GNode *pgn, GNode *cgn, bool isSpecial)
+{
 	if ((pgn->type & OP_DOUBLEDEP) && !Lst_IsEmpty(&pgn->cohorts))
 		pgn = pgn->cohorts.last->datum;
 	Lst_Append(&pgn->children, cgn);
 	pgn->unmade++;
 	/*
 	 * Special targets like .END do not need to be informed once the child
 	 * target has been made.
 	 */
 	if (!isSpecial)
 		Lst_Append(&cgn->parents, pgn);
 	if (DEBUG(PARSE)) {
 		debug_printf("# LinkSource: added child %s - %s\n",
 		    pgn->name, cgn->name);
 		Targ_PrintNode(pgn, 0);
 		Targ_PrintNode(cgn, 0);
+	}
+}
 /* Add the node to each target from the current dependency group. */
 static void
 LinkToTargets(GNode *gn, bool isSpecial)
+{
 	GNodeListNode *ln;
 	for (ln = targets->first; ln != NULL; ln = ln->next)
 		LinkSource(ln->datum, gn, isSpecial);
+}
 static bool
 TryApplyDependencyOperator(GNode *gn, GNodeType op)
+{
 	/*
 	 * If the node occurred on the left-hand side of a dependency and the
 	 * operator also defines a dependency, they must match.
 	 */
 	if ((op & OP_OPMASK) && (gn->type & OP_OPMASK) &&
 	    ((op & OP_OPMASK) != (gn->type & OP_OPMASK))) {
 		Parse_Error(PARSE_FATAL, "Inconsistent operator for %s",
 		    gn->name);
 		return false;
+	}
 	if (op == OP_DOUBLEDEP && (gn->type & OP_OPMASK) == OP_DOUBLEDEP) {
 		/*
 		 * If the node was on the left-hand side of a '::' operator,
 		 * create a new node for the children and commands on this
 		 * dependency line, since each of these dependency groups has
 		 * its own attributes and commands, separate from the others.
+		 *
 		 * The new instance is placed on the 'cohorts' list of the
 		 * initial one (note the initial one is not on its own
 		 * cohorts list) and the new instance is linked to all
 		 * parents of the initial instance.
 		 */
 		GNode *cohort;
 		/*
 		 * Propagate copied bits to the initial node.  They'll be
 		 * propagated back to the rest of the cohorts later.
 		 */
 		gn->type |= op & (unsigned)~OP_OPMASK;
 		cohort = Targ_NewInternalNode(gn->name);
 		if (doing_depend)
 			RememberLocation(cohort);
 		/*
 		 * Make the cohort invisible to avoid duplicating it
 		 * into other variables. True, parents of this target won't
 		 * tend to do anything with their local variables, but better
 		 * safe than sorry.
+		 *
 		 * (I think this is pointless now, since the relevant list
 		 * traversals will no longer see this node anyway. -mycroft)
 		 */
 		cohort->type = op | OP_INVISIBLE;
 		Lst_Append(&gn->cohorts, cohort);
 		cohort->centurion = gn;
 		gn->unmade_cohorts++;
 		snprintf(cohort->cohort_num, sizeof cohort->cohort_num, "#%d",
 		    (unsigned int)gn->unmade_cohorts % 1000000);
 	} else {
 		gn->type |= op;	/* preserve any previous flags */
+	}
 	return true;
+}
 static void
 ApplyDependencyOperator(GNodeType op)
+{
 	GNodeListNode *ln;
 	for (ln = targets->first; ln != NULL; ln = ln->next)
 		if (!TryApplyDependencyOperator(ln->datum, op))
 			break;
+}
 /*
  * Add a .WAIT node in the dependency list. After any dynamic dependencies
  * (and filename globbing) have happened, it is given a dependency on each
  * previous child, back until the previous .WAIT node. The next child won't
  * be scheduled until the .WAIT node is built.
+ *
  * Give each .WAIT node a unique name (mainly for diagnostics).
  */
 static void
 ApplyDependencySourceWait(bool isSpecial)
+{
 	static unsigned wait_number = 0;
 	char name[6 + 10 + 1];
 	GNode *gn;
 	snprintf(name, sizeof name, ".WAIT_%u", ++wait_number);
 	gn = Targ_NewInternalNode(name);
 	if (doing_depend)
 		RememberLocation(gn);
 	gn->type = OP_WAIT | OP_PHONY | OP_DEPENDS | OP_NOTMAIN;
 	LinkToTargets(gn, isSpecial);
+}
 static bool
 ApplyDependencySourceKeyword(const char *src, ParseSpecial special)
+{
 	int keywd;
 	GNodeType targetAttr;
 	if (*src != '.' || !ch_isupper(src[1]))
 		return false;
 	keywd = FindKeyword(src);
 	if (keywd == -1)
 		return false;
 	targetAttr = parseKeywords[keywd].targetAttr;
 	if (targetAttr != OP_NONE) {
 		ApplyDependencyOperator(targetAttr);
 		return true;
+	}
 	if (parseKeywords[keywd].special == SP_WAIT) {
 		ApplyDependencySourceWait(special != SP_NOT);
 		return true;
+	}
 	return false;
+}
 /*
  * In a line like ".MAIN: source1 source2", add all sources to the list of
  * things to create, but only if the user didn't specify a target on the
  * command line and .MAIN occurs for the first time.
+ *
  * See HandleDependencyTargetSpecial, branch SP_MAIN.
  * See unit-tests/cond-func-make-main.mk.
  */
 static void
 ApplyDependencySourceMain(const char *src)
+{
 	Lst_Append(&opts.create, bmake_strdup(src));
 	/*
 	 * Add the name to the .TARGETS variable as well, so the user can
 	 * employ that, if desired.
 	 */
 	Global_Append(".TARGETS", src);
+}
 /*
  * For the sources of a .ORDER target, create predecessor/successor links
  * between the previous source and the current one.
  */
 static void
 ApplyDependencySourceOrder(const char *src)
+{
 	GNode *gn;
 	gn = Targ_GetNode(src);
 	if (doing_depend)
 		RememberLocation(gn);
 	if (order_pred != NULL) {
 		Lst_Append(&order_pred->order_succ, gn);
 		Lst_Append(&gn->order_pred, order_pred);
 		if (DEBUG(PARSE)) {
 			debug_printf(
 			    "# .ORDER forces '%s' to be made before '%s'\n",
 			    order_pred->name, gn->name);
 			Targ_PrintNode(order_pred, 0);
 			Targ_PrintNode(gn, 0);
+		}
+	}
 	/* The current source now becomes the predecessor for the next one. */
 	order_pred = gn;
+}
 /* The source is not an attribute, so find/create a node for it. */
 static void
 ApplyDependencySourceOther(const char *src, GNodeType targetAttr,
 			   ParseSpecial special)
+{
 	GNode *gn;
 	gn = Targ_GetNode(src);
 	if (doing_depend)
 		RememberLocation(gn);
 	if (targetAttr != OP_NONE)
 		gn->type |= targetAttr;
 	else
 		LinkToTargets(gn, special != SP_NOT);
+}
 /*
  * Given the name of a source in a dependency line, figure out if it is an
  * attribute (such as .SILENT) and if so, apply it to all targets. Otherwise
  * decide if there is some attribute which should be applied *to* the source
  * because of some special target (such as .PHONY) and apply it if so.
  * Otherwise, make the source a child of the targets.
  */
 static void
 ApplyDependencySource(GNodeType targetAttr, const char *src,
 		      ParseSpecial special)
+{
 	if (ApplyDependencySourceKeyword(src, special))
 		return;
 	if (special == SP_MAIN)
 		ApplyDependencySourceMain(src);
 	else if (special == SP_ORDER)
 		ApplyDependencySourceOrder(src);
 	else
 		ApplyDependencySourceOther(src, targetAttr, special);
+}
 /*
  * If we have yet to decide on a main target to make, in the absence of any
  * user input, we want the first target on the first dependency line that is
  * actually a real target (i.e. isn't a .USE or .EXEC rule) to be made.
  */
 static void
 MaybeUpdateMainTarget(void)
+{
 	GNodeListNode *ln;
 	if (mainNode != NULL)
 		return;
 	for (ln = targets->first; ln != NULL; ln = ln->next) {
 		GNode *gn = ln->datum;
 		if (GNode_IsMainCandidate(gn)) {
 			DEBUG1(MAKE, "Setting main node to \"%s\"\n",
 			    gn->name);
 			mainNode = gn;
 			return;
+		}
+	}
+}
 static void
 InvalidLineType(const char *line, const char *unexpanded_line)
+{
 	if (unexpanded_line[0] == '.') {
 		const char *dirstart = unexpanded_line + 1;
 		const char *dirend;
 		cpp_skip_whitespace(&dirstart);
 		dirend = dirstart;
 		while (ch_isalnum(*dirend) || *dirend == '-')
 			dirend++;
 		Parse_Error(PARSE_FATAL, "Unknown directive \"%.*s\"",
 		    (int)(dirend - dirstart), dirstart);
 	} else if (strcmp(line, unexpanded_line) == 0)
 		Parse_Error(PARSE_FATAL, "Invalid line '%s'", line);
 	else
 		Parse_Error(PARSE_FATAL,
 		    "Invalid line '%s', expanded to '%s'",
 		    unexpanded_line, line);
+}
 static void
 ParseDependencyTargetWord(char **pp, const char *lstart)
+{
 	const char *p = *pp;
 	while (*p != '\0') {
 		if ((ch_isspace(*p) || *p == '!' || *p == ':' || *p == '(')
 		    && !IsEscaped(lstart, p))
 			break;
 		if (*p == '$') {
 			FStr val = Var_Parse(&p, SCOPE_CMDLINE,
 			    VARE_PARSE_ONLY);
 			/* TODO: handle errors */
 			FStr_Done(&val);
 		} else
 			p++;
+	}
 	*pp += p - *pp;
+}
 /*
  * Handle special targets like .PATH, .DEFAULT, .BEGIN, .ORDER.
+ *
  * See the tests deptgt-*.mk.
  */
 static void
 HandleDependencyTargetSpecial(const char *targetName,
 			      ParseSpecial *inout_special,
 			      SearchPathList **inout_paths)
+{
 	switch (*inout_special) {
 	case SP_PATH:
 		if (*inout_paths == NULL)
 			*inout_paths = Lst_New();
 		Lst_Append(*inout_paths, &dirSearchPath);
 		break;
 	case SP_SYSPATH:
 		if (*inout_paths == NULL)
 			*inout_paths = Lst_New();
 		Lst_Append(*inout_paths, sysIncPath);
 		break;
 	case SP_MAIN:
 		/*
 		 * Allow targets from the command line to override the
 		 * .MAIN node.
 		 */
 		if (!Lst_IsEmpty(&opts.create))
 			*inout_special = SP_NOT;
 		break;
 	case SP_BEGIN:
 	case SP_END:
 	case SP_STALE:
 	case SP_ERROR:
 	case SP_INTERRUPT: {
 		GNode *gn = Targ_GetNode(targetName);
 		if (doing_depend)
 			RememberLocation(gn);
 		gn->type |= OP_NOTMAIN | OP_SPECIAL;
 		Lst_Append(targets, gn);
 		break;
+	}
 	case SP_DEFAULT: {
 		/*
 		 * Need to create a node to hang commands on, but we don't
 		 * want it in the graph, nor do we want it to be the Main
 		 * Target. We claim the node is a transformation rule to make
 		 * life easier later, when we'll use Make_HandleUse to
 		 * actually apply the .DEFAULT commands.
 		 */
 		GNode *gn = GNode_New(".DEFAULT");
 		gn->type |= OP_NOTMAIN | OP_TRANSFORM;
 		Lst_Append(targets, gn);
 		defaultNode = gn;
 		break;
+	}
 	case SP_DELETE_ON_ERROR:
 		deleteOnError = true;
 		break;
 	case SP_NOTPARALLEL:
 		opts.maxJobs = 1;
 		break;
 	case SP_SINGLESHELL:
 		opts.compatMake = true;
 		break;
 	case SP_ORDER:
 		order_pred = NULL;
 		break;
 	default:
 		break;
+	}
+}
 static bool
 HandleDependencyTargetPath(const char *suffixName,
 			   SearchPathList **inout_paths)
+{
 	SearchPath *path;
 	path = Suff_GetPath(suffixName);
 	if (path == NULL) {
 		Parse_Error(PARSE_FATAL,
 		    "Suffix '%s' not defined (yet)", suffixName);
 		return false;
+	}
 	if (*inout_paths == NULL)
 		*inout_paths = Lst_New();
 	Lst_Append(*inout_paths, path);
 	return true;
+}
 /* See if it's a special target and if so set inout_special to match it. */
 static bool
 HandleDependencyTarget(const char *targetName,
 		       ParseSpecial *inout_special,
 		       GNodeType *inout_targetAttr,
 		       SearchPathList **inout_paths)
+{
 	int keywd;
 	if (!(targetName[0] == '.' && ch_isupper(targetName[1])))
 		return true;
 	/*
 	 * See if the target is a special target that must have it
 	 * or its sources handled specially.
 	 */
 	keywd = FindKeyword(targetName);
 	if (keywd != -1) {
 		if (*inout_special == SP_PATH &&
 		    parseKeywords[keywd].special != SP_PATH) {
 			Parse_Error(PARSE_FATAL, "Mismatched special targets");
 			return false;
+		}
 		*inout_special = parseKeywords[keywd].special;
 		*inout_targetAttr = parseKeywords[keywd].targetAttr;
 		HandleDependencyTargetSpecial(targetName, inout_special,
 		    inout_paths);
 	} else if (strncmp(targetName, ".PATH", 5) == 0) {
 		*inout_special = SP_PATH;
 		if (!HandleDependencyTargetPath(targetName + 5, inout_paths))
 			return false;
+	}
 	return true;
+}
 static void
 HandleSingleDependencyTargetMundane(const char *name)
+{
 	GNode *gn = Suff_IsTransform(name)
 	    ? Suff_AddTransform(name)
 	    : Targ_GetNode(name);
 	if (doing_depend)
 		RememberLocation(gn);
 	Lst_Append(targets, gn);
+}
 static void
 HandleDependencyTargetMundane(const char *targetName)
+{
 	if (Dir_HasWildcards(targetName)) {
 		StringList targetNames = LST_INIT;
 		SearchPath *emptyPath = SearchPath_New();
 		SearchPath_Expand(emptyPath, targetName, &targetNames);
 		SearchPath_Free(emptyPath);
 		while (!Lst_IsEmpty(&targetNames)) {
 			char *targName = Lst_Dequeue(&targetNames);
 			HandleSingleDependencyTargetMundane(targName);
 			free(targName);
+		}
 	} else
 		HandleSingleDependencyTargetMundane(targetName);
+}
 static void
 SkipExtraTargets(char **pp, const char *lstart)
+{
 	bool warning = false;
 	const char *p = *pp;
 	while (*p != '\0') {
 		if (!IsEscaped(lstart, p) && (*p == '!' || *p == ':'))
 			break;
 		if (IsEscaped(lstart, p) || (*p != ' ' && *p != '\t'))
 			warning = true;
 		p++;
+	}
 	if (warning) {
 		const char *start = *pp;
 		cpp_skip_whitespace(&start);
 		Parse_Error(PARSE_WARNING, "Extra target '%.*s' ignored",
 		    (int)(p - start), start);
+	}
 	*pp += p - *pp;
+}
 static void
 CheckSpecialMundaneMixture(ParseSpecial special)
+{
 	switch (special) {
 	case SP_DEFAULT:
 	case SP_STALE:
 	case SP_BEGIN:
 	case SP_END:
 	case SP_ERROR:
 	case SP_INTERRUPT:
 		/*
 		 * These create nodes on which to hang commands, so targets
 		 * shouldn't be empty.
 		 */
 	case SP_NOT:
 		/* Nothing special here -- targets may be empty. */
 		break;
 	default:
 		Parse_Error(PARSE_WARNING,
 		    "Special and mundane targets don't mix. "
 		    "Mundane ones ignored");
 		break;
+	}
+}
 /*
  * In a dependency line like 'targets: sources' or 'targets! sources', parse
  * the operator ':', '::' or '!' from between the targets and the sources.
  */
 static GNodeType
 ParseDependencyOp(char **pp)
+{
 	if (**pp == '!')
 		return (*pp)++, OP_FORCE;
 	if (**pp == ':' && (*pp)[1] == ':')
 		return *pp += 2, OP_DOUBLEDEP;
 	else if (**pp == ':')
 		return (*pp)++, OP_DEPENDS;
 	else
 		return OP_NONE;
+}
 static void
 ClearPaths(ParseSpecial special, SearchPathList *paths)
+{
 	if (paths != NULL) {
 		SearchPathListNode *ln;
 		for (ln = paths->first; ln != NULL; ln = ln->next)
 			SearchPath_Clear(ln->datum);
+	}
 	if (special == SP_SYSPATH)
 		Dir_SetSYSPATH();
 	else
 		Dir_SetPATH();
+}
 static char *
 FindInDirOfIncludingFile(const char *file)
+{
 	char *fullname, *incdir, *slash, *newName;
 	int i;
 	fullname = NULL;
 	incdir = bmake_strdup(CurFile()->name.str);
 	slash = strrchr(incdir, '/');
 	if (slash != NULL) {
 		*slash = '\0';
 		/*
 		 * Now do lexical processing of leading "../" on the
 		 * filename.
 		 */
 		for (i = 0; strncmp(file + i, "../", 3) == 0; i += 3) {
 			slash = strrchr(incdir + 1, '/');
 			if (slash == NULL || strcmp(slash, "/..") == 0)
 				break;
 			*slash = '\0';
+		}
 		newName = str_concat3(incdir, "/", file + i);
 		fullname = Dir_FindFile(newName, parseIncPath);
 		if (fullname == NULL)
 			fullname = Dir_FindFile(newName, &dirSearchPath);
 		free(newName);
+	}
 	free(incdir);
 	return fullname;
+}
 static char *
 FindInQuotPath(const char *file)
+{
 	const char *suff;
 	SearchPath *suffPath;
 	char *fullname;
 	fullname = FindInDirOfIncludingFile(file);
 	if (fullname == NULL &&
 	    (suff = strrchr(file, '.')) != NULL &&
 	    (suffPath = Suff_GetPath(suff)) != NULL)
 		fullname = Dir_FindFile(file, suffPath);
 	if (fullname == NULL)
 		fullname = Dir_FindFile(file, parseIncPath);
 	if (fullname == NULL)
 		fullname = Dir_FindFile(file, &dirSearchPath);
 	return fullname;
+}
 static bool
 SkipGuarded(const char *fullname)
+{
 	Guard *guard = HashTable_FindValue(&guards, fullname);
 	if (guard != NULL && guard->kind == GK_VARIABLE
 	    && GNode_ValueDirect(SCOPE_GLOBAL, guard->name) != NULL)
 		goto skip;
 	if (guard != NULL && guard->kind == GK_TARGET
 	    && Targ_FindNode(guard->name) != NULL)
 		goto skip;
 	return false;
 skip:
 	DEBUG2(PARSE, "Skipping '%s' because '%s' is defined\n",
 	    fullname, guard->name);
 	return true;
+}
 /*
  * Handle one of the .[-ds]include directives by remembering the current file
  * and pushing the included file on the stack.  After the included file has
  * finished, parsing continues with the including file; see Parse_PushInput
  * and ParseEOF.
+ *
  * System includes are looked up in sysIncPath, any other includes are looked
  * up in the parsedir and then in the directories specified by the -I command
  * line options.
  */
 static void
 IncludeFile(const char *file, bool isSystem, bool depinc, bool silent)
+{
 	Buffer buf;
 	char *fullname;		/* full pathname of file */
 	int fd;
 	fullname = file[0] == '/' ? bmake_strdup(file) : NULL;
 	if (fullname == NULL && !isSystem)
 		fullname = FindInQuotPath(file);
 	if (fullname == NULL) {
 		SearchPath *path = Lst_IsEmpty(&sysIncPath->dirs)
 		    ? defSysIncPath : sysIncPath;
 		fullname = Dir_FindFile(file, path);
+	}
 	if (fullname == NULL) {
 		if (!silent)
 			Parse_Error(PARSE_FATAL, "Could not find %s", file);
 		return;
+	}
 	if (SkipGuarded(fullname))
 		return;
 	if ((fd = open(fullname, O_RDONLY)) == -1) {
 		if (!silent)
 			Parse_Error(PARSE_FATAL, "Cannot open %s", fullname);
 		free(fullname);
 		return;
+	}
 	buf = LoadFile(fullname, fd);
 	(void)close(fd);
 	Parse_PushInput(fullname, 1, 0, buf, NULL);
 	if (depinc)
 		doing_depend = depinc;	/* only turn it on */
 	free(fullname);
+}
 /* Handle a "dependency" line like '.SPECIAL:' without any sources. */
 static void
 HandleDependencySourcesEmpty(ParseSpecial special, SearchPathList *paths)
+{
 	switch (special) {
 	case SP_SUFFIXES:
 		Suff_ClearSuffixes();
 		break;
 	case SP_PRECIOUS:
 		allPrecious = true;
 		break;
 	case SP_IGNORE:
 		opts.ignoreErrors = true;
 		break;
 	case SP_SILENT:
 		opts.silent = true;
 		break;
 	case SP_PATH:
 	case SP_SYSPATH:
 		ClearPaths(special, paths);
 		break;
 	case SP_POSIX:
 		if (posix_state == PS_NOW_OR_NEVER) {
 			/*
 			 * With '-r', 'posix.mk' (if it exists)
 			 * can effectively substitute for 'sys.mk',
 			 * otherwise it is an extension.
 			 */
 			Global_Set("%POSIX", "1003.2");
 			IncludeFile("posix.mk", true, false, true);
+		}
 		break;
 	default:
 		break;
+	}
+}
 static void
 AddToPaths(const char *dir, SearchPathList *paths)
+{
 	if (paths != NULL) {
 		SearchPathListNode *ln;
 		for (ln = paths->first; ln != NULL; ln = ln->next)
 			(void)SearchPath_Add(ln->datum, dir);
+	}
+}
 /*
  * If the target was one that doesn't take files as its sources but takes
  * something like suffixes, we take each space-separated word on the line as
  * a something and deal with it accordingly.
  */
 static void
 ParseDependencySourceSpecial(ParseSpecial special, const char *word,
 			     SearchPathList *paths)
+{
 	switch (special) {
 	case SP_SUFFIXES:
 		Suff_AddSuffix(word);
 		break;
 	case SP_PATH:
 	case SP_SYSPATH:
 		AddToPaths(word, paths);
 		break;
 	case SP_INCLUDES:
 		Suff_AddInclude(word);
 		break;
 	case SP_LIBS:
 		Suff_AddLib(word);
 		break;
 	case SP_NOREADONLY:
 		Var_ReadOnly(word, false);
 		break;
 	case SP_NULL:
 		Suff_SetNull(word);
 		break;
 	case SP_OBJDIR:
 		Main_SetObjdir(false, "%s", word);
 		break;
 	case SP_READONLY:
 		Var_ReadOnly(word, true);
 		break;
 	default:
 		break;
+	}
+}
 static bool
 ApplyDependencyTarget(char *name, char *nameEnd, ParseSpecial *inout_special,
 		      GNodeType *inout_targetAttr,
 		      SearchPathList **inout_paths)
+{
 	char savedNameEnd = *nameEnd;
 	*nameEnd = '\0';
 	if (!HandleDependencyTarget(name, inout_special,
 	    inout_targetAttr, inout_paths))
 		return false;
 	if (*inout_special == SP_NOT && *name != '\0')
 		HandleDependencyTargetMundane(name);
 	else if (*inout_special == SP_PATH && *name != '.' && *name != '\0')
 		Parse_Error(PARSE_WARNING, "Extra target (%s) ignored", name);
 	*nameEnd = savedNameEnd;
 	return true;
+}
 static bool
 ParseDependencyTargets(char **pp,
 		       const char *lstart,
 		       ParseSpecial *inout_special,
 		       GNodeType *inout_targetAttr,
 		       SearchPathList **inout_paths,
 		       const char *unexpanded_line)
+{
 	char *p = *pp;
 	for (;;) {
 		char *tgt = p;
 		ParseDependencyTargetWord(&p, lstart);
 		/*
 		 * If the word is followed by a left parenthesis, it's the
 		 * name of one or more files inside an archive.
 		 */
 		if (!IsEscaped(lstart, p) && *p == '(') {
 			p = tgt;
 			if (!Arch_ParseArchive(&p, targets, SCOPE_CMDLINE)) {
 				Parse_Error(PARSE_FATAL,
 				    "Error in archive specification: \"%s\"",
 				    tgt);
 				return false;
+			}
 			continue;
+		}
 		if (*p == '\0') {
 			InvalidLineType(lstart, unexpanded_line);
 			return false;
+		}
 		if (!ApplyDependencyTarget(tgt, p, inout_special,
 		    inout_targetAttr, inout_paths))
 			return false;
 		if (*inout_special != SP_NOT && *inout_special != SP_PATH)
 			SkipExtraTargets(&p, lstart);
 		else
 			pp_skip_whitespace(&p);
 		if (*p == '\0')
 			break;
 		if ((*p == '!' || *p == ':') && !IsEscaped(lstart, p))
 			break;
+	}
 	*pp = p;
 	return true;
+}
 static void
 ParseDependencySourcesSpecial(char *start,
 			      ParseSpecial special, SearchPathList *paths)
+{
 	while (*start != '\0') {
 		char savedEnd;
 		char *end = start;
 		while (*end != '\0' && !ch_isspace(*end))
 			end++;
 		savedEnd = *end;
 		*end = '\0';
 		ParseDependencySourceSpecial(special, start, paths);
 		*end = savedEnd;
 		if (savedEnd != '\0')
 			end++;
 		pp_skip_whitespace(&end);
 		start = end;
+	}
+}
 static void
 LinkVarToTargets(VarAssign *var)
+{
 	GNodeListNode *ln;
 	for (ln = targets->first; ln != NULL; ln = ln->next)
 		Parse_Var(var, ln->datum);
+}
 static bool
 ParseDependencySourcesMundane(char *start,
 			      ParseSpecial special, GNodeType targetAttr)
+{
 	while (*start != '\0') {
 		char *end = start;
 		VarAssign var;
 		/*
 		 * Check for local variable assignment,
 		 * rest of the line is the value.
 		 */
 		if (Parse_IsVar(start, &var)) {
 			bool targetVarsEnabled = GetBooleanExpr(
 			    "${.MAKE.TARGET_LOCAL_VARIABLES}", true);
 			if (targetVarsEnabled)
 				LinkVarToTargets(&var);
 			free(var.varname);
 			if (targetVarsEnabled)
 				return true;
+		}
 		/*
 		 * The targets take real sources, so we must beware of archive
 		 * specifications (i.e. things with left parentheses in them)
 		 * and handle them accordingly.
 		 */
 		for (; *end != '\0' && !ch_isspace(*end); end++) {
 			if (*end == '(' && end > start && end[-1] != '$') {
 				/*
 				 * Only stop for a left parenthesis if it
 				 * isn't at the start of a word (that'll be
 				 * for variable changes later) and isn't
 				 * preceded by a dollar sign (a dynamic
 				 * source).
 				 */
 				break;
+			}
+		}
 		if (*end == '(') {
 			GNodeList sources = LST_INIT;
 			if (!Arch_ParseArchive(&start, &sources,
 			    SCOPE_CMDLINE)) {
 				Parse_Error(PARSE_FATAL,
 				    "Error in source archive spec \"%s\"",
 				    start);
 				return false;
+			}
 			while (!Lst_IsEmpty(&sources)) {
 				GNode *gn = Lst_Dequeue(&sources);
 				ApplyDependencySource(targetAttr, gn->name,
 				    special);
+			}
 			Lst_Done(&sources);
 			end = start;
 		} else {
 			if (*end != '\0') {
 				*end = '\0';
 				end++;
+			}
 			ApplyDependencySource(targetAttr, start, special);
+		}
 		pp_skip_whitespace(&end);
 		start = end;
+	}
 	return true;
+}
 /*
  * From a dependency line like 'targets: sources', parse the sources.
+ *
  * See the tests depsrc-*.mk.
  */
 static void
 ParseDependencySources(char *p, GNodeType targetAttr,
 		       ParseSpecial special, SearchPathList **inout_paths)
+{
 	if (*p == '\0') {
 		HandleDependencySourcesEmpty(special, *inout_paths);
 	} else if (special == SP_MFLAGS) {
 		Main_ParseArgLine(p);
 		return;
 	} else if (special == SP_SHELL) {
 		if (!Job_ParseShell(p)) {
 			Parse_Error(PARSE_FATAL,
 			    "improper shell specification");
 			return;
+		}
 		return;
 	} else if (special == SP_NOTPARALLEL || special == SP_SINGLESHELL ||
 		   special == SP_DELETE_ON_ERROR) {
 		return;
+	}
 	switch (special) {
 	case SP_INCLUDES:
 	case SP_LIBS:
 	case SP_NOREADONLY:
 	case SP_NULL:
 	case SP_OBJDIR:
 	case SP_PATH:
 	case SP_READONLY:
 	case SP_SUFFIXES:
 	case SP_SYSPATH:
 		ParseDependencySourcesSpecial(p, special, *inout_paths);
 		if (*inout_paths != NULL) {
 			Lst_Free(*inout_paths);
 			*inout_paths = NULL;
+		}
 		if (special == SP_PATH)
 			Dir_SetPATH();
 		if (special == SP_SYSPATH)
 			Dir_SetSYSPATH();
 		break;
 	default:
 		assert(*inout_paths == NULL);
 		if (!ParseDependencySourcesMundane(p, special, targetAttr))
 			return;
 		break;
+	}
 	MaybeUpdateMainTarget();
+}
 /*
  * Parse a dependency line consisting of targets, followed by a dependency
  * operator, optionally followed by sources.
+ *
  * The nodes of the sources are linked as children to the nodes of the
  * targets. Nodes are created as necessary.
+ *
  * The operator is applied to each node in the global 'targets' list,
  * which is where the nodes found for the targets are kept.
+ *
  * The sources are parsed in much the same way as the targets, except
  * that they are expanded using the wildcarding scheme of the C-Shell,
  * and a target is created for each expanded word. Each of the resulting
  * nodes is then linked to each of the targets as one of its children.
+ *
  * Certain targets and sources such as .PHONY or .PRECIOUS are handled
  * specially, see ParseSpecial.
+ *
  * Transformation rules such as '.c.o' are also handled here, see
  * Suff_AddTransform.
+ *
- * Upon return, the value of the line is unspecified.
+ * Upon return, the value of expandedLine is unspecified.
  */
 static void
-ParseDependency(char *line, const char *unexpanded_line)
+ParseDependency(char *expandedLine, const char *unexpandedLine)
+{
 	char *p;
 	SearchPathList *paths;	/* search paths to alter when parsing a list
 				 * of .PATH targets */
 	GNodeType targetAttr;	/* from special sources */
 	ParseSpecial special;	/* in special targets, the children are
 				 * linked as children of the parent but not
 				 * vice versa */
 	GNodeType op;
-	DEBUG1(PARSE, "ParseDependency(%s)\n", line);
+	DEBUG1(PARSE, "ParseDependency(%s)\n", expandedLine);
-	p = line;
+	p = expandedLine;
 	paths = NULL;
 	targetAttr = OP_NONE;
 	special = SP_NOT;
-	if (!ParseDependencyTargets(&p, line, &special, &targetAttr, &paths,
+	if (!ParseDependencyTargets(&p, expandedLine, &special, &targetAttr,
-	    unexpanded_line))
+	    &paths, unexpandedLine))
 		goto out;
 	if (!Lst_IsEmpty(targets))
 		CheckSpecialMundaneMixture(special);
 	op = ParseDependencyOp(&p);
 	if (op == OP_NONE) {
-		InvalidLineType(line, unexpanded_line);
+		InvalidLineType(expandedLine, unexpandedLine);
 		goto out;
+	}
 	ApplyDependencyOperator(op);
 	pp_skip_whitespace(&p);
 	ParseDependencySources(p, targetAttr, special, &paths);
 out:
 	if (paths != NULL)
 		Lst_Free(paths);
+}
 /*
  * Determine the assignment operator and adjust the end of the variable
  * name accordingly.
  */
 static VarAssign
 AdjustVarassignOp(const char *name, const char *nameEnd, const char *op,
 		  const char *value)
+{
 	VarAssignOp type;
 	VarAssign va;
 	if (op > name && op[-1] == '+') {
 		op--;
 		type = VAR_APPEND;
 	} else if (op > name && op[-1] == '?') {
 		op--;
 		type = VAR_DEFAULT;
 	} else if (op > name && op[-1] == ':') {
 		op--;
 		type = VAR_SUBST;
 	} else if (op > name && op[-1] == '!') {
 		op--;
 		type = VAR_SHELL;
 	} else {
 		type = VAR_NORMAL;
 		while (op > name && ch_isspace(op[-1]))
 			op--;
 		if (op - name >= 3 && memcmp(op - 3, ":sh", 3) == 0) {
 			op -= 3;
 			type = VAR_SHELL;
+		}
+	}
 	va.varname = bmake_strsedup(name, nameEnd < op ? nameEnd : op);
 	va.op = type;
 	va.value = value;
 	return va;
+}
 /*
  * Parse a variable assignment, consisting of a single-word variable name,
  * optional whitespace, an assignment operator, optional whitespace and the
  * variable value.
+ *
  * Note: There is a lexical ambiguity with assignment modifier characters
  * in variable names. This routine interprets the character before the =
  * as a modifier. Therefore, an assignment like
  *	C++=/usr/bin/CC
  * is interpreted as "C+ +=" instead of "C++ =".
+ *
  * Used for both lines in a file and command line arguments.
  */
 static bool
 Parse_IsVar(const char *p, VarAssign *out_var)
+{
 	const char *nameStart, *nameEnd, *firstSpace, *eq;
 	int level = 0;
 	cpp_skip_hspace(&p);	/* Skip to variable name */
 	/*
 	 * During parsing, the '+' of the operator '+=' is initially parsed
 	 * as part of the variable name.  It is later corrected, as is the
 	 * ':sh' modifier. Of these two (nameEnd and eq), the earlier one
 	 * determines the actual end of the variable name.
 	 */
 	nameStart = p;
 	firstSpace = NULL;
 	/* Scan for one of the assignment operators outside an expression. */
 	while (*p != '\0') {
 		char ch = *p++;
 		if (ch == '(' || ch == '{') {
 			level++;
 			continue;
+		}
 		if (ch == ')' || ch == '}') {
 			level--;
 			continue;
+		}
 		if (level != 0)
 			continue;
 		if ((ch == ' ' || ch == '\t') && firstSpace == NULL)
 			firstSpace = p - 1;
 		while (ch == ' ' || ch == '\t')
 			ch = *p++;
 		if (ch == '\0')
 			return false;
 		if (ch == ':' && p[0] == 's' && p[1] == 'h') {
 			p += 2;
 			continue;
+		}
 		if (ch == '=')
 			eq = p - 1;
 		else if (*p == '=' &&
 		    (ch == '+' || ch == ':' || ch == '?' || ch == '!'))
 			eq = p;
 		else if (firstSpace != NULL)
 			return false;
 		else
 			continue;
 		nameEnd = firstSpace != NULL ? firstSpace : eq;
 		p = eq + 1;
 		cpp_skip_whitespace(&p);
 		*out_var = AdjustVarassignOp(nameStart, nameEnd, eq, p);
 		return true;
+	}
 	return false;
+}
 /*
  * Check for syntax errors such as unclosed expressions or unknown modifiers.
  */
 static void
 VarCheckSyntax(VarAssignOp op, const char *uvalue, GNode *scope)
+{
 	if (opts.strict) {
 		if (op != VAR_SUBST && strchr(uvalue, '$') != NULL) {
 			char *parsedValue = Var_Subst(uvalue,
 			    scope, VARE_PARSE_ONLY);
 			/* TODO: handle errors */
 			free(parsedValue);
+		}
+	}
+}
 /* Perform a variable assignment that uses the operator ':='. */
 static void
 VarAssign_EvalSubst(GNode *scope, const char *name, const char *uvalue,
 		    FStr *out_avalue)
+{
 	char *evalue;
 	/*
 	 * Make sure that we set the variable the first time to nothing
 	 * so that it gets substituted.
+	 *
 	 * TODO: Add a test that demonstrates why this code is needed,
 	 *  apart from making the debug log longer.
+	 *
 	 * XXX: The variable name is expanded up to 3 times.
 	 */
 	if (!Var_ExistsExpand(scope, name))
 		Var_SetExpand(scope, name, "");
 	evalue = Var_Subst(uvalue, scope, VARE_KEEP_DOLLAR_UNDEF);
 	/* TODO: handle errors */
 	Var_SetExpand(scope, name, evalue);
 	*out_avalue = FStr_InitOwn(evalue);
+}
 /* Perform a variable assignment that uses the operator '!='. */
 static void
 VarAssign_EvalShell(const char *name, const char *uvalue, GNode *scope,
 		    FStr *out_avalue)
+{
 	FStr cmd;
 	char *output, *error;
 	cmd = FStr_InitRefer(uvalue);
 	Var_Expand(&cmd, SCOPE_CMDLINE, VARE_UNDEFERR);
 	output = Cmd_Exec(cmd.str, &error);
 	Var_SetExpand(scope, name, output);
 	*out_avalue = FStr_InitOwn(output);
 	if (error != NULL) {
 		Parse_Error(PARSE_WARNING, "%s", error);
 		free(error);
+	}
 	FStr_Done(&cmd);
+}
 /*
  * Perform a variable assignment.
+ *
  * The actual value of the variable is returned in *out_true_avalue.
  * Especially for VAR_SUBST and VAR_SHELL this can differ from the literal
  * value.
+ *
  * Return whether the assignment was actually performed, which is usually
  * the case.  It is only skipped if the operator is '?=' and the variable
  * already exists.
  */
 static bool
 VarAssign_Eval(const char *name, VarAssignOp op, const char *uvalue,
 	       GNode *scope, FStr *out_true_avalue)
+{
 	FStr avalue = FStr_InitRefer(uvalue);
 	if (op == VAR_APPEND)
 		Var_AppendExpand(scope, name, uvalue);
 	else if (op == VAR_SUBST)
 		VarAssign_EvalSubst(scope, name, uvalue, &avalue);
 	else if (op == VAR_SHELL)
 		VarAssign_EvalShell(name, uvalue, scope, &avalue);
 	else {
 		/* XXX: The variable name is expanded up to 2 times. */
 		if (op == VAR_DEFAULT && Var_ExistsExpand(scope, name))
 			return false;
 		/* Normal assignment -- just do it. */
 		Var_SetExpand(scope, name, uvalue);
+	}
 	*out_true_avalue = avalue;
 	return true;
+}
 static void
 VarAssignSpecial(const char *name, const char *avalue)
+{
 	if (strcmp(name, ".MAKEOVERRIDES") == 0)
 		Main_ExportMAKEFLAGS(false);	/* re-export MAKEFLAGS */
 	else if (strcmp(name, ".CURDIR") == 0) {
 		/*
 		 * Someone is being (too?) clever...
 		 * Let's pretend they know what they are doing and
 		 * re-initialize the 'cur' CachedDir.
 		 */
 		Dir_InitCur(avalue);
 		Dir_SetPATH();
 	} else if (strcmp(name, ".MAKE.JOB.PREFIX") == 0)
 		Job_SetPrefix();
 	else if (strcmp(name, ".MAKE.EXPORTED") == 0)
 		Var_ExportVars(avalue);
+}
 /* Perform the variable assignment in the given scope. */
 static void
 Parse_Var(VarAssign *var, GNode *scope)
+{
 	FStr avalue;		/* actual value (maybe expanded) */
 	VarCheckSyntax(var->op, var->value, scope);
 	if (VarAssign_Eval(var->varname, var->op, var->value, scope, &avalue)) {
 		VarAssignSpecial(var->varname, avalue.str);
 		FStr_Done(&avalue);
+	}
+}
 /*
  * See if the command possibly calls a sub-make by using the
  * expressions ${.MAKE}, ${MAKE} or the plain word "make".
  */
 static bool
 MaybeSubMake(const char *cmd)
+{
 	const char *start;
 	for (start = cmd; *start != '\0'; start++) {
 		const char *p = start;
 		char endc;
 		/* XXX: What if progname != "make"? */
 		if (strncmp(p, "make", 4) == 0)
 			if (start == cmd || !ch_isalnum(p[-1]))
 				if (!ch_isalnum(p[4]))
 					return true;
 		if (*p != '$')
 			continue;
 		p++;
 		if (*p == '{')
 			endc = '}';
 		else if (*p == '(')
 			endc = ')';
 		else
 			continue;
 		p++;
 		if (*p == '.')	/* Accept either ${.MAKE} or ${MAKE}. */
 			p++;
 		if (strncmp(p, "MAKE", 4) == 0 && p[4] == endc)
 			return true;
+	}
 	return false;
+}
 /* Append the command to the target node. */
 static void
 GNode_AddCommand(GNode *gn, char *cmd)
+{
 	if ((gn->type & OP_DOUBLEDEP) && gn->cohorts.last != NULL)
 		gn = gn->cohorts.last->datum;
 	/* if target already supplied, ignore commands */
 	if (!(gn->type & OP_HAS_COMMANDS)) {
 		Lst_Append(&gn->commands, cmd);
 		if (MaybeSubMake(cmd))
 			gn->type |= OP_SUBMAKE;
 		RememberLocation(gn);
 	} else {
 		Parse_Error(PARSE_WARNING,
 		    "duplicate script for target \"%s\" ignored",
 		    gn->name);
 		ParseErrorInternal(gn, PARSE_WARNING,
 		    "using previous script for \"%s\" defined here",
 		    gn->name);
+	}
+}
 /*
  * Parse a directive like '.include' or '.-include'.
+ *
  * .include "user-makefile.mk"
  * .include <system-makefile.mk>
  */
 static void
 ParseInclude(char *directive)
+{
 	char endc;		/* '>' or '"' */
 	char *p;
 	bool silent = directive[0] != 'i';
 	FStr file;
 	p = directive + (silent ? 8 : 7);
 	pp_skip_hspace(&p);
 	if (*p != '"' && *p != '<') {
 		Parse_Error(PARSE_FATAL,
 		    ".include filename must be delimited by '\"' or '<'");
 		return;
+	}
 	endc = *p++ == '<' ? '>' : '"';
 	file = FStr_InitRefer(p);
 	while (*p != '\0' && *p != endc)
 		p++;
 	if (*p != endc) {
 		Parse_Error(PARSE_FATAL,
 		    "Unclosed .include filename. '%c' expected", endc);
 		return;
+	}
 	*p = '\0';
 	Var_Expand(&file, SCOPE_CMDLINE, VARE_WANTRES);
 	IncludeFile(file.str, endc == '>', directive[0] == 'd', silent);
 	FStr_Done(&file);
+}
 /*
  * Split filename into dirname + basename, then assign these to the
  * given variables.
  */
 static void
 SetFilenameVars(const char *filename, const char *dirvar, const char *filevar)
+{
 	const char *slash, *basename;
 	FStr dirname;
 	slash = strrchr(filename, '/');
 	if (slash == NULL) {
 		dirname = FStr_InitRefer(curdir);
 		basename = filename;
 	} else {
 		dirname = FStr_InitOwn(bmake_strsedup(filename, slash));
 		basename = slash + 1;
+	}
 	Global_Set(dirvar, dirname.str);
 	Global_Set(filevar, basename);
 	DEBUG4(PARSE, "SetFilenameVars: ${%s} = `%s' ${%s} = `%s'\n",
 	    dirvar, dirname.str, filevar, basename);
 	FStr_Done(&dirname);
+}
 /*
  * Return the immediately including file.
+ *
  * This is made complicated since the .for loop is implemented as a special
  * kind of .include; see For_Run.
  */
 static const char *
 GetActuallyIncludingFile(void)
+{
 	size_t i;
 	const IncludedFile *incs = GetInclude(0);
 	for (i = includes.len; i >= 2; i--)
 		if (incs[i - 1].forLoop == NULL)
 			return incs[i - 2].name.str;
 	return NULL;
+}
 /* Set .PARSEDIR, .PARSEFILE, .INCLUDEDFROMDIR and .INCLUDEDFROMFILE. */
 static void
 SetParseFile(const char *filename)
+{
 	const char *including;
 	SetFilenameVars(filename, ".PARSEDIR", ".PARSEFILE");
 	including = GetActuallyIncludingFile();
 	if (including != NULL) {
 		SetFilenameVars(including,
 		    ".INCLUDEDFROMDIR", ".INCLUDEDFROMFILE");
 	} else {
 		Global_Delete(".INCLUDEDFROMDIR");
 		Global_Delete(".INCLUDEDFROMFILE");
+	}
+}
 static bool
 StrContainsWord(const char *str, const char *word)
+{
 	size_t strLen = strlen(str);
 	size_t wordLen = strlen(word);
 	const char *p;
 	if (strLen < wordLen)
 		return false;
 	for (p = str; p != NULL; p = strchr(p, ' ')) {
 		if (*p == ' ')
 			p++;
 		if (p > str + strLen - wordLen)
 			return false;
 		if (memcmp(p, word, wordLen) == 0 &&
 		    (p[wordLen] == '\0' || p[wordLen] == ' '))
 			return true;
+	}
 	return false;
+}
 /*
  * XXX: Searching through a set of words with this linear search is
  * inefficient for variables that contain thousands of words.
+ *
  * XXX: The paths in this list don't seem to be normalized in any way.
  */
 static bool
 VarContainsWord(const char *varname, const char *word)
+{
 	FStr val = Var_Value(SCOPE_GLOBAL, varname);
 	bool found = val.str != NULL && StrContainsWord(val.str, word);
 	FStr_Done(&val);
 	return found;
+}
 /*
  * Track the makefiles we read - so makefiles can set dependencies on them.
  * Avoid adding anything more than once.
+ *
  * Time complexity: O(n) per call, in total O(n^2), where n is the number
  * of makefiles that have been loaded.
  */
 static void
 TrackInput(const char *name)
+{
 	if (!VarContainsWord(".MAKE.MAKEFILES", name))
 		Global_Append(".MAKE.MAKEFILES", name);
+}
 /* Parse from the given buffer, later return to the current file. */
 void
 Parse_PushInput(const char *name, unsigned lineno, unsigned readLines,
 		Buffer buf, struct ForLoop *forLoop)
+{
 	IncludedFile *curFile;
 	if (forLoop != NULL)
 		name = CurFile()->name.str;
 	else
 		TrackInput(name);
 	DEBUG3(PARSE, "Parse_PushInput: %s %s, line %u\n",
 	    forLoop != NULL ? ".for loop in": "file", name, lineno);
 	curFile = Vector_Push(&includes);
 	curFile->name = FStr_InitOwn(bmake_strdup(name));
 	curFile->lineno = lineno;
 	curFile->readLines = readLines;
 	curFile->forHeadLineno = lineno;
 	curFile->forBodyReadLines = readLines;
 	curFile->buf = buf;
 	curFile->depending = doing_depend;	/* restore this on EOF */
 	curFile->guardState = forLoop == NULL ? GS_START : GS_NO;
 	curFile->guard = NULL;
 	curFile->forLoop = forLoop;
 	if (forLoop != NULL && !For_NextIteration(forLoop, &curFile->buf))
 		abort();	/* see For_Run */
 	curFile->buf_ptr = curFile->buf.data;
 	curFile->buf_end = curFile->buf.data + curFile->buf.len;
 	curFile->condMinDepth = cond_depth;
 	SetParseFile(name);
+}
 /* Check if the directive is an include directive. */
 static bool
 IsInclude(const char *dir, bool sysv)
+{
 	if (dir[0] == 's' || dir[0] == '-' || (dir[0] == 'd' && !sysv))
 		dir++;
 	if (strncmp(dir, "include", 7) != 0)
 		return false;
 	/* Space is not mandatory for BSD .include */
 	return !sysv || ch_isspace(dir[7]);
+}
 /* Check if the line is a SYSV include directive. */
 static bool
 IsSysVInclude(const char *line)
+{
 	const char *p;
 	if (!IsInclude(line, true))
 		return false;
 	/* Avoid interpreting a dependency line as an include */
 	for (p = line; (p = strchr(p, ':')) != NULL;) {
 		/* end of line -> it's a dependency */
 		if (*++p == '\0')
 			return false;
 		/* '::' operator or ': ' -> it's a dependency */
 		if (*p == ':' || ch_isspace(*p))
 			return false;
+	}
 	return true;
+}
 /* Push to another file.  The line points to the word "include". */
 static void
 ParseTraditionalInclude(char *line)
+{
 	char *p;		/* current position in file spec */
 	bool done = false;
 	bool silent = line[0] != 'i';
 	char *file = line + (silent ? 8 : 7);
 	char *all_files;
 	DEBUG1(PARSE, "ParseTraditionalInclude: %s\n", file);
 	pp_skip_whitespace(&file);
 	all_files = Var_Subst(file, SCOPE_CMDLINE, VARE_WANTRES);
 	/* TODO: handle errors */
 	for (file = all_files; !done; file = p + 1) {
 		/* Skip to end of line or next whitespace */
 		for (p = file; *p != '\0' && !ch_isspace(*p); p++)
 			continue;
 		if (*p != '\0')
 			*p = '\0';
 		else
 			done = true;
 		IncludeFile(file, false, false, silent);
+	}
 	free(all_files);
+}
 /* Parse "export <variable>=<value>", and actually export it. */
 static void
 ParseGmakeExport(char *line)
+{
 	char *variable = line + 6;
 	char *value;
 	DEBUG1(PARSE, "ParseGmakeExport: %s\n", variable);
 	pp_skip_whitespace(&variable);
 	for (value = variable; *value != '\0' && *value != '='; value++)
 		continue;
 	if (*value != '=') {
 		Parse_Error(PARSE_FATAL,
 		    "Variable/Value missing from \"export\"");
 		return;
+	}
 	*value++ = '\0';	/* terminate variable */
 	/*
 	 * Expand the value before putting it in the environment.
 	 */
 	value = Var_Subst(value, SCOPE_CMDLINE, VARE_WANTRES);
 	/* TODO: handle errors */
 	setenv(variable, value, 1);
 	free(value);
+}
 /*
  * When the end of the current file or .for loop is reached, continue reading
  * the previous file at the previous location.
+ *
  * Results:
  *	true to continue parsing, i.e. it had only reached the end of an
  *	included file, false if the main file has been parsed completely.
  */
 static bool
 ParseEOF(void)
+{
 	IncludedFile *curFile = CurFile();
 	doing_depend = curFile->depending;
 	if (curFile->forLoop != NULL &&
 	    For_NextIteration(curFile->forLoop, &curFile->buf)) {
 		curFile->buf_ptr = curFile->buf.data;
 		curFile->buf_end = curFile->buf.data + curFile->buf.len;
 		curFile->readLines = curFile->forBodyReadLines;
 		return true;
+	}
 	Cond_EndFile();
 	if (curFile->guardState == GS_DONE)
 		HashTable_Set(&guards, curFile->name.str, curFile->guard);
 	else if (curFile->guard != NULL) {
 		free(curFile->guard->name);
 		free(curFile->guard);
+	}
 	FStr_Done(&curFile->name);
 	Buf_Done(&curFile->buf);
 	if (curFile->forLoop != NULL)
 		ForLoop_Free(curFile->forLoop);
 	Vector_Pop(&includes);
 	if (includes.len == 0) {
 		/* We've run out of input */
 		Global_Delete(".PARSEDIR");
 		Global_Delete(".PARSEFILE");
 		Global_Delete(".INCLUDEDFROMDIR");
 		Global_Delete(".INCLUDEDFROMFILE");
 		return false;
+	}
 	curFile = CurFile();
 	DEBUG2(PARSE, "ParseEOF: returning to file %s, line %u\n",
 	    curFile->name.str, curFile->readLines + 1);
 	SetParseFile(curFile->name.str);
 	return true;
+}
 typedef enum ParseRawLineResult {
 	PRLR_LINE,
 	PRLR_EOF,
 	PRLR_ERROR
 } ParseRawLineResult;
 /*
  * Parse until the end of a line, taking into account lines that end with
  * backslash-newline.  The resulting line goes from out_line to out_line_end;
  * the line is not null-terminated.
  */
 static ParseRawLineResult
 ParseRawLine(IncludedFile *curFile, char **out_line, char **out_line_end,
 	     char **out_firstBackslash, char **out_commentLineEnd)
+{
 	char *line = curFile->buf_ptr;
 	char *buf_end = curFile->buf_end;
 	char *p = line;
 	char *line_end = line;
 	char *firstBackslash = NULL;
 	char *commentLineEnd = NULL;
 	ParseRawLineResult res = PRLR_LINE;
 	curFile->readLines++;
 	for (;;) {
 		char ch;
 		if (p == buf_end) {
 			res = PRLR_EOF;
 			break;
+		}
 		ch = *p;
 		if (ch == '\0' || (ch == '\\' && p[1] == '\0')) {
 			Parse_Error(PARSE_FATAL, "Zero byte read from file");
 			exit(2);
+		}
 		/* Treat next character after '\' as literal. */
 		if (ch == '\\') {
 			if (firstBackslash == NULL)
 				firstBackslash = p;
 			if (p[1] == '\n') {
 				curFile->readLines++;
 				if (p + 2 == buf_end) {
 					line_end = p;
 					*line_end = '\n';
 					p += 2;
 					continue;
+				}
+			}
 			p += 2;
 			line_end = p;
 			assert(p <= buf_end);
 			continue;
+		}
 		/*
 		 * Remember the first '#' for comment stripping, unless
 		 * the previous char was '[', as in the modifier ':[#]'.
 		 */
 		if (ch == '#' && commentLineEnd == NULL &&
 		    !(p > line && p[-1] == '['))
 			commentLineEnd = line_end;
 		p++;
 		if (ch == '\n')
 			break;
 		/* We are not interested in trailing whitespace. */
 		if (!ch_isspace(ch))
 			line_end = p;
+	}
 	curFile->buf_ptr = p;
 	*out_line = line;
 	*out_line_end = line_end;
 	*out_firstBackslash = firstBackslash;
 	*out_commentLineEnd = commentLineEnd;
 	return res;
+}
 /*
  * Beginning at start, unescape '\#' to '#' and replace backslash-newline
  * with a single space.
  */
 static void
 UnescapeBackslash(char *line, char *start)
+{
 	const char *src = start;
 	char *dst = start;
 	char *spaceStart = line;
 	for (;;) {
 		char ch = *src++;
 		if (ch != '\\') {
 			if (ch == '\0')
 				break;
 			*dst++ = ch;
 			continue;
+		}
 		ch = *src++;
 		if (ch == '\0') {
 			/* Delete '\\' at the end of the buffer. */
 			dst--;
 			break;
+		}
 		/* Delete '\\' from before '#' on non-command lines. */
 		if (ch == '#' && line[0] != '\t')
 			*dst++ = ch;
 		else if (ch == '\n') {
 			cpp_skip_hspace(&src);
 			*dst++ = ' ';
 		} else {
 			/* Leave '\\' in the buffer for later. */
 			*dst++ = '\\';
 			*dst++ = ch;
 			/* Keep an escaped ' ' at the line end. */
 			spaceStart = dst;
+		}
+	}
 	/* Delete any trailing spaces - eg from empty continuations */
 	while (dst > spaceStart && ch_isspace(dst[-1]))
 		dst--;
 	*dst = '\0';
+}
 typedef enum LineKind {
 	/*
 	 * Return the next line that is neither empty nor a comment.
 	 * Backslash line continuations are folded into a single space.
 	 * A trailing comment, if any, is discarded.
 	 */
 	LK_NONEMPTY,
 	/*
 	 * Return the next line, even if it is empty or a comment.
 	 * Preserve backslash-newline to keep the line numbers correct.
+	 *
 	 * Used in .for loops to collect the body of the loop while waiting
 	 * for the corresponding .endfor.
 	 */
 	LK_FOR_BODY,
 	/*
 	 * Return the next line that starts with a dot.
 	 * Backslash line continuations are folded into a single space.
 	 * A trailing comment, if any, is discarded.
+	 *
 	 * Used in .if directives to skip over irrelevant branches while
 	 * waiting for the corresponding .endif.
 	 */
 	LK_DOT
 } LineKind;
 /*
  * Return the next "interesting" logical line from the current file.  The
  * returned string will be freed at the end of including the file.
  */
 static char *
 ReadLowLevelLine(LineKind kind)
+{
 	IncludedFile *curFile = CurFile();
 	ParseRawLineResult res;
 	char *line;
 	char *line_end;
 	char *firstBackslash;
 	char *commentLineEnd;
 	for (;;) {
 		curFile->lineno = curFile->readLines + 1;
 		res = ParseRawLine(curFile,
 		    &line, &line_end, &firstBackslash, &commentLineEnd);
 		if (res == PRLR_ERROR)
 			return NULL;
 		if (line == line_end || line == commentLineEnd) {
 			if (res == PRLR_EOF)
 				return NULL;
 			if (kind != LK_FOR_BODY)
 				continue;
+		}
 		/* We now have a line of data */
 		assert(ch_isspace(*line_end));
 		*line_end = '\0';
 		if (kind == LK_FOR_BODY)
 			return line;	/* Don't join the physical lines. */
 		if (kind == LK_DOT && line[0] != '.')
 			continue;
 		break;
+	}
 	if (commentLineEnd != NULL && line[0] != '\t')
 		*commentLineEnd = '\0';
 	if (firstBackslash != NULL)
 		UnescapeBackslash(line, firstBackslash);
 	return line;
+}
 static bool
 SkipIrrelevantBranches(void)
+{
 	const char *line;
 	while ((line = ReadLowLevelLine(LK_DOT)) != NULL)
 		if (Cond_EvalLine(line) == CR_TRUE)
 			return true;
 	return false;
+}
 static bool
 ParseForLoop(const char *line)
+{
 	int rval;
 	unsigned forHeadLineno;
 	unsigned bodyReadLines;
 	int forLevel;
 	rval = For_Eval(line);
 	if (rval == 0)
 		return false;	/* Not a .for line */
 	if (rval < 0)
 		return true;	/* Syntax error - error printed, ignore line */
 	forHeadLineno = CurFile()->lineno;
 	bodyReadLines = CurFile()->readLines;
 	/* Accumulate the loop body until the matching '.endfor'. */
 	forLevel = 1;
 	do {
 		line = ReadLowLevelLine(LK_FOR_BODY);
 		if (line == NULL) {
 			Parse_Error(PARSE_FATAL,
 			    "Unexpected end of file in .for loop");
 			break;
+		}
 	} while (For_Accum(line, &forLevel));
 	For_Run(forHeadLineno, bodyReadLines);
 	return true;
+}
 /*
  * Read an entire line from the input file.
+ *
  * Empty lines, .if and .for are handled by this function, while variable
  * assignments, other directives, dependency lines and shell commands are
  * handled by the caller.
+ *
  * Return a line without trailing whitespace, or NULL for EOF.  The returned
  * string will be freed at the end of including the file.
  */
 static char *
 ReadHighLevelLine(void)
+{
 	char *line;
 	CondResult condResult;
 	for (;;) {
 		IncludedFile *curFile = CurFile();
 		line = ReadLowLevelLine(LK_NONEMPTY);
 		if (posix_state == PS_MAYBE_NEXT_LINE)
 			posix_state = PS_NOW_OR_NEVER;
 		else
 			posix_state = PS_TOO_LATE;
 		if (line == NULL)
 			return NULL;
 		DEBUG2(PARSE, "Parsing line %u: %s\n", curFile->lineno, line);
 		if (curFile->guardState != GS_NO
 		    && ((curFile->guardState == GS_START && line[0] != '.')
 			|| curFile->guardState == GS_DONE))
 			curFile->guardState = GS_NO;
 		if (line[0] != '.')
 			return line;
 		condResult = Cond_EvalLine(line);
 		if (curFile->guardState == GS_START) {
 			Guard *guard;
 			if (condResult != CR_ERROR
 			    && (guard = Cond_ExtractGuard(line)) != NULL) {
 				curFile->guardState = GS_COND;
 				curFile->guard = guard;
 			} else
 				curFile->guardState = GS_NO;
+		}
 		switch (condResult) {
 		case CR_FALSE:	/* May also mean a syntax error. */
 			if (!SkipIrrelevantBranches())
 				return NULL;
 			continue;
 		case CR_TRUE:
 			continue;
 		case CR_ERROR:	/* Not a conditional line */
 			if (ParseForLoop(line))
 				continue;
 			break;
+		}
 		return line;
+	}
+}
 static void
 FinishDependencyGroup(void)
+{
 	GNodeListNode *ln;
 	if (targets == NULL)
 		return;
 	for (ln = targets->first; ln != NULL; ln = ln->next) {

 @@ -1,2008 +1,2001 @@
-/*	$NetBSD: var.c,v 1.1104 2024/04/21 21:59:48 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.1105 2024/04/23 22:51:28 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
+ *	Var_SetExpand	Set the value of the variable, creating it if
  *			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 expressions in a string.
+ *
  *	Var_Parse	Parse an expression such as ${VAR:Mpattern}.
+ *
- *	Var_Delete
+ *	Var_Delete	Delete a variable.
  *			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>
 #include <sys/types.h>
 #include <regex.h>
 #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.1104 2024/04/21 21:59:48 rillig Exp $");
+MAKE_RCSID("$NetBSD: var.c,v 1.1105 2024/04/23 22:51:28 rillig Exp $");
 /*
  * 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
+ * Scope variables are stored in GNode.vars.  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.  (There is another,
  * unintended way to undefine a scope variable, see varmod-loop-delete.mk.)
+ *
  * Environment variables are short-lived.  They are returned by VarFind, and
  * after using them, they must be freed using VarFreeShortLived.
+ *
  * Undefined variables occur during evaluation of 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;
 	/* The variable came from the command line. */
 	bool fromCmd:1;
 	/*
 	 * The variable is short-lived.
 	 * These variables are not registered in any GNode, therefore they
 	 * must be freed after use.
 	 */
 	bool shortLived:1;
 	/*
 	 * The variable comes from the environment.
-	 * Appending to its value moves the variable to the global scope.
+	 * Appending to its value depends on the scope, see var-op-append.mk.
 	 */
 	bool fromEnvironment:1;
 	/*
 	 * 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.
 	 * Use .[NO]READONLY: to adjust.
+	 *
 	 * See VAR_SET_READONLY.
 	 */
 	bool readOnly:1;
 	/*
 	 * The variable is currently being accessed by Var_Parse or Var_Subst.
 	 * This temporary marker is used to avoid endless recursion.
 	 */
 	bool inUse:1;
 	/*
 	 * The variable is exported to the environment, to be used by child
 	 * processes.
 	 */
 	bool exported:1;
 	/*
 	 * 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 actually exported, resolving
 	 * the referenced variable just in time.
 	 */
 	bool reexport:1;
 } Var;
 /*
  * Exporting variables is expensive and may leak memory, so skip it if we
  * can.
  */
 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 PatternFlags {
 	bool subGlobal:1;	/* 'g': replace as often as possible */
 	bool subOnce:1;		/* '1': replace only once */
 	bool anchorStart:1;	/* '^': match only at start of word */
 	bool anchorEnd:1;	/* '$': match only at end of word */
 } PatternFlags;
 /* SepBuf builds a string from words interleaved with separators. */
 typedef struct SepBuf {
 	Buffer buf;
 	bool needSep;
 	/* Usually ' ', but see the ':ts' modifier. */
 	char sep;
 } SepBuf;
 typedef struct {
 	const char *target;
 	const char *varname;
 	const char *expr;
 } EvalStackElement;
 typedef struct {
 	EvalStackElement *elems;
 	size_t len;
 	size_t cap;
 	Buffer details;
 } EvalStack;
 /* Whether 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_EVAL_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 bool 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.
+ *
  * Each target has its own scope, containing the 7 target-local variables
  * .TARGET, .ALLSRC, etc.  Variables set on dependency lines also go in
  * this scope.
  */
 GNode *SCOPE_CMDLINE;
 GNode *SCOPE_GLOBAL;
 GNode *SCOPE_INTERNAL;
 static VarExportedMode var_exportedVars = VAR_EXPORTED_NONE;
 static const char VarEvalMode_Name[][32] = {
 	"parse-only",
 	"parse-balanced",
 	"eval",
 	"eval-defined",
 	"eval-keep-dollar",
 	"eval-keep-undefined",
 	"eval-keep-dollar-and-undefined",
 };
 static EvalStack evalStack;
 void
 EvalStack_Push(const char *target, const char *expr, const char *varname)
+{
 	if (evalStack.len >= evalStack.cap) {
 		evalStack.cap = 16 + 2 * evalStack.cap;
 		evalStack.elems = bmake_realloc(evalStack.elems,
 		    evalStack.cap * sizeof(*evalStack.elems));
+	}
 	evalStack.elems[evalStack.len].target = target;
 	evalStack.elems[evalStack.len].expr = expr;
 	evalStack.elems[evalStack.len].varname = varname;
 	evalStack.len++;
+}
 void
 EvalStack_Pop(void)
+{
 	assert(evalStack.len > 0);
 	evalStack.len--;
+}
 const char *
 EvalStack_Details(void)
+{
 	size_t i;
 	Buffer *buf = &evalStack.details;
 	buf->len = 0;
 	for (i = 0; i < evalStack.len; i++) {
 		EvalStackElement *elem = evalStack.elems + i;
 		if (elem->target != NULL) {
 			Buf_AddStr(buf, "in target \"");
 			Buf_AddStr(buf, elem->target);
 			Buf_AddStr(buf, "\": ");
+		}
 		if (elem->expr != NULL) {
 			Buf_AddStr(buf, "while evaluating \"");
 			Buf_AddStr(buf, elem->expr);
 			Buf_AddStr(buf, "\": ");
+		}
 		if (elem->varname != NULL) {
 			Buf_AddStr(buf, "while evaluating variable \"");
 			Buf_AddStr(buf, elem->varname);
 			Buf_AddStr(buf, "\": ");
+		}
+	}
 	return buf->len > 0 ? buf->data : "";
+}
 static Var *
 VarNew(FStr name, const char *value,
        bool shortLived, bool fromEnvironment, bool readOnly)
+{
 	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->fromCmd = false;
 	var->shortLived = shortLived;
 	var->fromEnvironment = fromEnvironment;
 	var->readOnly = readOnly;
 	var->inUse = false;
 	var->exported = false;
 	var->reexport = false;
 	return var;
+}
 static Substring
 CanonicalVarname(Substring name)
+{
 	if (!(Substring_Length(name) > 0 && name.start[0] == '.'))
 		return name;
 	if (Substring_Equals(name, ".ALLSRC"))
 		return Substring_InitStr(ALLSRC);
 	if (Substring_Equals(name, ".ARCHIVE"))
 		return Substring_InitStr(ARCHIVE);
 	if (Substring_Equals(name, ".IMPSRC"))
 		return Substring_InitStr(IMPSRC);
 	if (Substring_Equals(name, ".MEMBER"))
 		return Substring_InitStr(MEMBER);
 	if (Substring_Equals(name, ".OODATE"))
 		return Substring_InitStr(OODATE);
 	if (Substring_Equals(name, ".PREFIX"))
 		return Substring_InitStr(PREFIX);
 	if (Substring_Equals(name, ".TARGET"))
 		return Substring_InitStr(TARGET);
 	/* GNU make has an additional alias $^ == ${.ALLSRC}. */
 	if (Substring_Equals(name, ".SHELL") && shellPath == NULL)
 		Shell_Init();
 	return name;
+}
 static Var *
 GNode_FindVar(GNode *scope, Substring varname, unsigned int hash)
+{
 	return HashTable_FindValueBySubstringHash(&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 short-lived (such as environment variables), it
  *	must be freed using VarFreeShortLived after use.
  */
 static Var *
 VarFindSubstring(Substring name, GNode *scope, bool elsewhere)
+{
 	Var *var;
 	unsigned int nameHash;
 	/* Replace '.TARGET' with '@', likewise for other local variables. */
 	name = CanonicalVarname(name);
 	nameHash = Hash_Substring(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) {
-		FStr envName;
+		FStr envName = Substring_Str(name);
-		const char *envValue;
+		const char *envValue = getenv(envName.str);
 		envName = Substring_Str(name);
 		envValue = getenv(envName.str);
 		if (envValue != NULL)
 			return VarNew(envName, envValue, true, true, false);
 		FStr_Done(&envName);
 		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;
+}
 static Var *
 VarFind(const char *name, GNode *scope, bool elsewhere)
+{
 	return VarFindSubstring(Substring_InitStr(name), scope, elsewhere);
+}
 /* If the variable is short-lived, free it, including its value. */
 static void
 VarFreeShortLived(Var *v)
+{
 	if (!v->shortLived)
 		return;
 	FStr_Done(&v->name);
 	Buf_Done(&v->val);
 	free(v);
+}
 static const char *
 ValueDescription(const char *value)
+{
 	if (value[0] == '\0')
 		return "# (empty)";
 	if (ch_isspace(value[strlen(value) - 1]))
 		return "# (ends with space)";
 	return "";
+}
 /* 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,
 	    false, false, (flags & VAR_SET_READONLY) != 0);
 	HashEntry_Set(he, v);
 	DEBUG4(VAR, "%s: %s = %s%s\n",
 	    scope->name, name, value, ValueDescription(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: ignoring delete '%s' as it is not found\n",
 		    scope->name, varname);
 		return;
+	}
 	v = he->value;
 	if (v->readOnly) {
 		DEBUG2(VAR, "%s: ignoring delete '%s' as it is read-only\n",
 		    scope->name, varname);
 		return;
+	}
 	if (v->inUse) {
 		Parse_Error(PARSE_FATAL,
 		    "Cannot delete variable \"%s\" while it is used",
 		    v->name.str);
 		return;
+	}
 	DEBUG2(VAR, "%s: delete %s\n", scope->name, varname);
 	if (v->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);
+}
 /*
  * 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)
+{
 	char *expanded;
 	Words varnames;
 	size_t i;
 	if (arg[0] == '\0') {
 		Parse_Error(PARSE_FATAL,
 		    "The .undef directive requires an argument");
 		return;
+	}
 	expanded = Var_Subst(arg, SCOPE_GLOBAL, VARE_WANTRES);
 	if (expanded == var_Error) {
 		/* TODO: Make this part of the code reachable. */
 		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 bool
 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 bool
 ExportVarEnv(Var *v, GNode *scope)
+{
 	const char *name = v->name.str;
 	char *val = v->val.data;
 	char *expr;
 	if (v->exported && !v->reexport)
 		return false;	/* nothing to do */
 	if (strchr(val, '$') == NULL) {
 		if (!v->exported)
 			setenv(name, val, 1);
 		return true;
+	}
 	if (v->inUse)
 		return false;	/* see EMPTY_SHELL in directive-export.mk */
 	/* XXX: name is injected without escaping it */
 	expr = str_concat3("${", name, "}");
 	val = Var_Subst(expr, scope, VARE_WANTRES);
 	if (scope != SCOPE_GLOBAL) {
 		/* we will need to re-export the global version */
 		v = VarFind(name, SCOPE_GLOBAL, false);
 		if (v != NULL)
 			v->exported = false;
+	}
 	/* TODO: handle errors */
 	setenv(name, val, 1);
 	free(val);
 	free(expr);
 	return true;
+}
 static bool
 ExportVarPlain(Var *v)
+{
 	if (strchr(v->val.data, '$') == NULL) {
 		setenv(v->name.str, v->val.data, 1);
 		v->exported = true;
 		v->reexport = false;
 		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->exported = true;
 	v->reexport = true;
 	return true;
+}
 static bool
 ExportVarLiteral(Var *v)
+{
 	if (v->exported && !v->reexport)
 		return false;
 	if (!v->exported)
 		setenv(v->name.str, v->val.data, 1);
 	return true;
+}
 /*
  * Mark a single variable to be exported later for subprocesses.
+ *
  * Internal variables are not exported.
  */
 static bool
 ExportVar(const char *name, GNode *scope, VarExportMode mode)
+{
 	Var *v;
 	if (!MayExport(name))
 		return false;
 	v = VarFind(name, scope, false);
 	if (v == NULL && scope != SCOPE_GLOBAL)
 		v = VarFind(name, SCOPE_GLOBAL, false);
 	if (v == NULL)
 		return false;
 	if (mode == VEM_ENV)
 		return ExportVarEnv(v, scope);
 	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(GNode *scope)
+{
 	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 level_buf[21];
 	snprintf(level_buf, sizeof level_buf, "%d", makelevel + 1);
 	setenv(MAKE_LEVEL_ENV, level_buf, 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, scope, VEM_ENV);
+		}
 		return;
+	}
 	xvarnames = Var_Subst("${.MAKE.EXPORTED:O:u}", SCOPE_GLOBAL,
 	    VARE_WANTRES);
 	/* 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], scope, VEM_ENV);
 		Words_Free(varnames);
+	}
 	free(xvarnames);
+}
 static void
 ExportVars(const char *varnames, bool 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, SCOPE_GLOBAL, 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, bool isExport, VarExportMode mode)
+{
 	char *xvarnames = Var_Subst(uvarnames, SCOPE_GLOBAL, VARE_WANTRES);
 	/* 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);
+}
 static void
 ClearEnv(void)
+{
 	const char *level;
 	char **newenv;
 	level = 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 (level != NULL && *level != '\0')
 		setenv(MAKE_LEVEL_ENV, level, 1);
+}
 static void
 GetVarnamesToUnexport(bool 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 = Var_Subst("${.MAKE.EXPORTED:O:u}",
 		    SCOPE_GLOBAL, VARE_WANTRES);
 		/* TODO: handle errors */
 		varnames = FStr_InitOwn(expanded);
+	}
 	*out_varnames = varnames;
 	*out_what = what;
+}
 static void
 UnexportVar(Substring varname, UnexportWhat what)
+{
 	Var *v = VarFindSubstring(varname, SCOPE_GLOBAL, false);
 	if (v == NULL) {
 		DEBUG2(VAR, "Not unexporting \"%.*s\" (not found)\n",
 		    (int)Substring_Length(varname), varname.start);
 		return;
+	}
 	DEBUG2(VAR, "Unexporting \"%.*s\"\n",
 	    (int)Substring_Length(varname), varname.start);
 	if (what != UNEXPORT_ENV && v->exported && !v->reexport)
 		unsetenv(v->name.str);
 	v->exported = false;
 	v->reexport = false;
 	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 *filtered = Var_Subst(expr, SCOPE_GLOBAL, VARE_WANTRES);
 		/* TODO: handle errors */
 		Global_Set(".MAKE.EXPORTED", filtered);
 		free(filtered);
 		free(expr);
+	}
+}
 static void
 UnexportVars(FStr *varnames, UnexportWhat what)
+{
 	size_t i;
 	SubstringWords words;
 	if (what == UNEXPORT_ENV)
 		ClearEnv();
 	words = Substring_Words(varnames->str, false);
 	for (i = 0; i < words.len; i++)
 		UnexportVar(words.words[i], what);
 	SubstringWords_Free(words);
 	if (what != UNEXPORT_NAMED)
 		Global_Delete(".MAKE.EXPORTED");
+}
 /* Handle the .unexport and .unexport-env directives. */
 void
 Var_UnExport(bool isEnv, const char *arg)
+{
 	UnexportWhat what;
 	FStr varnames;
 	GetVarnamesToUnexport(isEnv, arg, &varnames, &what);
 	UnexportVars(&varnames, what);
 	FStr_Done(&varnames);
+}
 /* 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') {
 		DEBUG3(VAR,
 		    "%s: ignoring '%s = %s' as the variable name is empty\n",
 		    scope->name, name, val);
 		return;
+	}
 	if (scope == SCOPE_GLOBAL
 	    && VarFind(name, SCOPE_CMDLINE, false) != NULL) {
 		/*
 		 * The global variable would not be visible anywhere.
 		 * Therefore, there is no point in setting it at all.
 		 */
 		DEBUG3(VAR,
 		    "%s: ignoring '%s = %s' "
 		    "due to a command line variable of the same name\n",
 		    scope->name, 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
+			 * This variable would normally prevent the same name
-			 * added to SCOPE_GLOBAL, so delete it from there if
+			 * being added to SCOPE_GLOBAL, so delete it from
-			 * needed. Otherwise -V name may show the wrong value.
+			 * there if needed. Otherwise -V name may show the
 			 * wrong value.
+			 *
 			 * See ExistsInCmdline.
 			 */
 			Var_Delete(SCOPE_GLOBAL, name);
+		}
 		if (strcmp(name, ".SUFFIXES") == 0) {
 			/* special: treat as read-only */
 			DEBUG3(VAR,
 			    "%s: ignoring '%s = %s' as it is read-only\n",
 			    scope->name, name, val);
 			return;
+		}
 		v = VarAdd(name, val, scope, flags);
 	} else {
 		if (v->readOnly && !(flags & VAR_SET_READONLY)) {
 			DEBUG3(VAR,
 			    "%s: ignoring '%s = %s' as it is read-only\n",
 			    scope->name, name, val);
 			return;
+		}
 		Buf_Clear(&v->val);
 		Buf_AddStr(&v->val, val);
 		DEBUG4(VAR, "%s: %s = %s%s\n",
 		    scope->name, name, val, ValueDescription(val));
 		if (v->exported)
 			ExportVar(name, scope, VEM_PLAIN);
+	}
 	if (scope == SCOPE_CMDLINE) {
 		v->fromCmd = true;
 		/*
 		 * Any variables given on the command line are automatically
 		 * exported to the environment (as per POSIX standard), except
 		 * for internals.
 		 */
 		if (!(flags & VAR_SET_NO_EXPORT) && name[0] != '.') {
 			/*
 			 * 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)
 		VarFreeShortLived(v);
+}
 void
 Var_Set(GNode *scope, const char *name, const char *val)
+{
 	Var_SetWithFlags(scope, name, val, VAR_SET_NONE);
+}
 /*
  * In the scope, expand the variable name once, then create the variable or
  * replace its value.
  */
 void
 Var_SetExpand(GNode *scope, const char *name, const char *val)
+{
 	FStr varname = FStr_InitRefer(name);
 	assert(val != NULL);
 	Var_Expand(&varname, scope, VARE_WANTRES);
 	if (varname.str[0] == '\0') {
 		DEBUG4(VAR,
 		    "%s: ignoring '%s = %s' "
 		    "as the variable name '%s' expands to empty\n",
 		    scope->name, varname.str, val, name);
 	} else
 		Var_SetWithFlags(scope, varname.str, val, VAR_SET_NONE);
 	FStr_Done(&varname);
+}
 void
 Global_Set(const char *name, const char *value)
+{
 	Var_Set(SCOPE_GLOBAL, name, value);
+}
 void
 Global_Delete(const char *name)
+{
 	Var_Delete(SCOPE_GLOBAL, name);
+}
 void
 Global_Set_ReadOnly(const char *name, const char *value)
+{
 	Var_SetWithFlags(SCOPE_GLOBAL, name, value, VAR_SET_READONLY);
+}
 /*
  * 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->readOnly) {
 		DEBUG3(VAR, "%s: ignoring '%s += %s' as it is read-only\n",
 		    scope->name, name, val);
 	} else if (scope == SCOPE_CMDLINE || !v->fromCmd) {
 		Buf_AddByte(&v->val, ' ');
 		Buf_AddStr(&v->val, val);
 		DEBUG3(VAR, "%s: %s = %s\n", scope->name, name, v->val.data);
 		if (v->fromEnvironment) {
 			/* See VarAdd. */
 			HashEntry *he =
 			    HashTable_CreateEntry(&scope->vars, name, NULL);
 			HashEntry_Set(he, v);
 			FStr_Done(&v->name);
 			v->name = FStr_InitRefer(/* aliased to */ he->key);
 			v->shortLived = false;
 			v->fromEnvironment = false;
+		}
+	}
+}
 /*
  * In the scope, expand the variable name once.  If the variable exists in the
  * scope, add a space and the value, otherwise set the variable to the value.
+ *
  * Appending to an environment variable only works in the global scope, that
  * is, for variable assignments in makefiles, but not inside conditions or the
  * commands of a target.
  */
 void
 Var_AppendExpand(GNode *scope, const char *name, const char *val)
+{
 	FStr xname = FStr_InitRefer(name);
 	assert(val != NULL);
 	Var_Expand(&xname, scope, VARE_WANTRES);
 	if (xname.str != name && xname.str[0] == '\0')
 		DEBUG4(VAR,
 		    "%s: ignoring '%s += %s' "
 		    "as the variable name '%s' expands to empty\n",
 		    scope->name, xname.str, val, name);
 	else
 		Var_Append(scope, xname.str, val);
 	FStr_Done(&xname);
+}
 void
 Global_Append(const char *name, const char *value)
+{
 	Var_Append(SCOPE_GLOBAL, name, value);
+}
 bool
 Var_Exists(GNode *scope, const char *name)
+{
 	Var *v = VarFind(name, scope, true);
 	if (v == NULL)
 		return false;
 	VarFreeShortLived(v);
 	return true;
+}
 /*
  * See if the given variable exists, in the given scope or in other
  * fallback scopes.
+ *
  * Input:
  *	scope		scope in which to start search
  *	name		name of the variable to find, is expanded once
  */
 bool
 Var_ExistsExpand(GNode *scope, const char *name)
+{
 	FStr varname = FStr_InitRefer(name);
 	bool exists;
 	Var_Expand(&varname, scope, VARE_WANTRES);
 	exists = Var_Exists(scope, varname.str);
 	FStr_Done(&varname);
 	return exists;
+}
 /*
  * Return the unexpanded value of the given variable in the given scope,
  * falling back to the command, global and environment scopes, in this order,
  * but see the -e option.
+ *
  * Input:
  *	name		the name to find, is not expanded any further
+ *
  * 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->shortLived)
 		return FStr_InitRefer(v->val.data);
 	value = v->val.data;
 	v->val.data = NULL;
 	VarFreeShortLived(v);
 	return FStr_InitOwn(value);
+}
 /* Set or clear the read-only attribute of the variable if it exists. */
 void
 Var_ReadOnly(const char *name, bool bf)
+{
 	Var *v;
 	v = VarFind(name, SCOPE_GLOBAL, false);
 	if (v == NULL) {
 		DEBUG1(VAR, "Var_ReadOnly: %s not found\n", name);
 		return;
+	}
 	v->readOnly = bf;
 	DEBUG2(VAR, "Var_ReadOnly: %s %s\n", name, bf ? "true" : "false");
+}
 /*
  * 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 VarEvalMode
 VarEvalMode_WithoutKeepDollar(VarEvalMode emode)
+{
 	if (emode == VARE_KEEP_DOLLAR_UNDEF)
 		return VARE_EVAL_KEEP_UNDEF;
 	if (emode == VARE_EVAL_KEEP_DOLLAR)
 		return VARE_WANTRES;
 	return emode;
+}
 static VarEvalMode
 VarEvalMode_UndefOk(VarEvalMode emode)
+{
 	return emode == VARE_UNDEFERR ? VARE_WANTRES : emode;
+}
 static bool
 VarEvalMode_ShouldEval(VarEvalMode emode)
+{
 	return emode != VARE_PARSE_ONLY;
+}
 static bool
 VarEvalMode_ShouldKeepUndef(VarEvalMode emode)
+{
 	return emode == VARE_EVAL_KEEP_UNDEF ||
 	       emode == VARE_KEEP_DOLLAR_UNDEF;
+}
 static bool
 VarEvalMode_ShouldKeepDollar(VarEvalMode emode)
+{
 	return emode == VARE_EVAL_KEEP_DOLLAR ||
 	       emode == VARE_KEEP_DOLLAR_UNDEF;
+}
 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_AddRange(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 void
 SepBuf_AddSubstring(SepBuf *buf, Substring sub)
+{
 	SepBuf_AddRange(buf, sub.start, sub.end);
+}
 static char *
 SepBuf_DoneData(SepBuf *buf)
+{
 	return Buf_DoneData(&buf->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.
+ *
  * 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".
+ *
  * Some ModifyWord functions assume that they are always passed a
  * null-terminated substring, which is currently guaranteed but may change in
  * the future.
  */
 typedef void (*ModifyWordProc)(Substring word, SepBuf *buf, void *data);
 /*ARGSUSED*/
 static void
 ModifyWord_Head(Substring word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
 	SepBuf_AddSubstring(buf, Substring_Dirname(word));
+}
 /*ARGSUSED*/
 static void
 ModifyWord_Tail(Substring word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
 	SepBuf_AddSubstring(buf, Substring_Basename(word));
+}
 /*ARGSUSED*/
 static void
 ModifyWord_Suffix(Substring word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
 	const char *lastDot = Substring_FindLast(word, '.');
 	if (lastDot != NULL)
 		SepBuf_AddRange(buf, lastDot + 1, word.end);
+}
 /*ARGSUSED*/
 static void
 ModifyWord_Root(Substring word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
 	const char *lastDot, *end;
 	lastDot = Substring_FindLast(word, '.');
 	end = lastDot != NULL ? lastDot : word.end;
 	SepBuf_AddRange(buf, word.start, end);
+}
 struct ModifyWord_SysVSubstArgs {
 	GNode *scope;
 	Substring lhsPrefix;
 	bool lhsPercent;
 	Substring lhsSuffix;
 	const char *rhs;
 };
 static void
 ModifyWord_SysVSubst(Substring word, SepBuf *buf, void *data)
+{
 	const struct ModifyWord_SysVSubstArgs *args = data;
 	FStr rhs;
 	const char *percent;
 	if (Substring_IsEmpty(word))
 		return;
 	if (!Substring_HasPrefix(word, args->lhsPrefix) ||
 	    !Substring_HasSuffix(word, args->lhsSuffix)) {
 		SepBuf_AddSubstring(buf, word);
 		return;
+	}
 	rhs = FStr_InitRefer(args->rhs);
 	Var_Expand(&rhs, args->scope, VARE_WANTRES);
 	percent = args->lhsPercent ? strchr(rhs.str, '%') : NULL;
 	if (percent != NULL)
 		SepBuf_AddRange(buf, rhs.str, percent);
 	if (percent != NULL || !args->lhsPercent)
 		SepBuf_AddRange(buf,
 		    word.start + Substring_Length(args->lhsPrefix),
 		    word.end - Substring_Length(args->lhsSuffix));
 	SepBuf_AddStr(buf, percent != NULL ? percent + 1 : rhs.str);
 	FStr_Done(&rhs);
+}
 static const char *
 Substring_Find(Substring haystack, Substring needle)
+{
 	size_t len, needleLen, i;
 	len = Substring_Length(haystack);
 	needleLen = Substring_Length(needle);
 	for (i = 0; i + needleLen <= len; i++)
 		if (memcmp(haystack.start + i, needle.start, needleLen) == 0)
 			return haystack.start + i;
 	return NULL;
+}
 struct ModifyWord_SubstArgs {
 	Substring lhs;
 	Substring rhs;
 	PatternFlags pflags;
 	bool matched;
 };
 static void
 ModifyWord_Subst(Substring word, SepBuf *buf, void *data)
+{
 	struct ModifyWord_SubstArgs *args = data;
 	size_t wordLen, lhsLen;
 	const char *match;
 	wordLen = Substring_Length(word);
 	if (args->pflags.subOnce && args->matched)
 		goto nosub;
 	lhsLen = Substring_Length(args->lhs);
 	if (args->pflags.anchorStart) {
 		if (wordLen < lhsLen ||
 		    memcmp(word.start, args->lhs.start, lhsLen) != 0)
 			goto nosub;
 		if (args->pflags.anchorEnd && wordLen != lhsLen)
 			goto nosub;
 		/* :S,^prefix,replacement, or :S,^whole$,replacement, */
 		SepBuf_AddSubstring(buf, args->rhs);
 		SepBuf_AddRange(buf, word.start + lhsLen, word.end);
 		args->matched = true;
 		return;
+	}
 	if (args->pflags.anchorEnd) {
 		if (wordLen < lhsLen)
 			goto nosub;
 		if (memcmp(word.end - lhsLen, args->lhs.start, lhsLen) != 0)
 			goto nosub;
 		/* :S,suffix$,replacement, */
 		SepBuf_AddRange(buf, word.start, word.end - lhsLen);
 		SepBuf_AddSubstring(buf, args->rhs);
 		args->matched = true;
 		return;
+	}
 	if (Substring_IsEmpty(args->lhs))
 		goto nosub;
 	/* unanchored case, may match more than once */
 	while ((match = Substring_Find(word, args->lhs)) != NULL) {
 		SepBuf_AddRange(buf, word.start, match);
 		SepBuf_AddSubstring(buf, args->rhs);
 		args->matched = true;
 		word.start = match + lhsLen;
 		if (Substring_IsEmpty(word) || !args->pflags.subGlobal)
 			break;
+	}
 nosub:
 	SepBuf_AddSubstring(buf, word);
+}
 /* Print the error caused by a regcomp or regexec call. */
 static void
 RegexError(int reerr, const regex_t *pat, const char *str)
+{
 	size_t errlen = regerror(reerr, pat, NULL, 0);
 	char *errbuf = bmake_malloc(errlen);
 	regerror(reerr, pat, errbuf, errlen);
 	Error("%s: %s", str, errbuf);
 	free(errbuf);
+}
 /* In the modifier ':C', replace a backreference from \0 to \9. */
 static void
 RegexReplaceBackref(char ref, SepBuf *buf, const char *wp,
 		    const regmatch_t *m, size_t nsub)
+{
 	unsigned int n = (unsigned)ref - '0';
 	if (n >= nsub)
 		Error("No subexpression \\%u", n);
 	else if (m[n].rm_so == -1) {
 		if (opts.strict)
 			Error("No match for subexpression \\%u", n);
 	} else {
 		SepBuf_AddRange(buf,
 		    wp + (size_t)m[n].rm_so,
 		    wp + (size_t)m[n].rm_eo);
+	}
+}
 /*
  * The regular expression matches the word; now add the replacement to the
  * buffer, taking back-references from 'wp'.
  */
 static void
 RegexReplace(Substring replace, SepBuf *buf, const char *wp,
 	     const regmatch_t *m, size_t nsub)
+{
 	const char *rp;
 	for (rp = replace.start; rp != replace.end; rp++) {
 		if (*rp == '\\' && rp + 1 != replace.end &&
 		    (rp[1] == '&' || rp[1] == '\\'))
 			SepBuf_AddBytes(buf, ++rp, 1);
 		else if (*rp == '\\' && rp + 1 != replace.end &&
 			 ch_isdigit(rp[1]))
 			RegexReplaceBackref(*++rp, buf, wp, m, nsub);
 		else if (*rp == '&') {
 			SepBuf_AddRange(buf,
 			    wp + (size_t)m[0].rm_so,
 			    wp + (size_t)m[0].rm_eo);
 		} else
 			SepBuf_AddBytes(buf, rp, 1);
+	}
+}
 struct ModifyWord_SubstRegexArgs {
 	regex_t re;
 	size_t nsub;
 	Substring replace;
 	PatternFlags pflags;
 	bool matched;
 };
 static void
 ModifyWord_SubstRegex(Substring word, SepBuf *buf, void *data)
+{
 	struct ModifyWord_SubstRegexArgs *args = data;
 	int xrv;
 	const char *wp;
 	int flags = 0;
 	regmatch_t m[10];
 	assert(word.end[0] == '\0');	/* assume null-terminated word */
 	wp = word.start;
 	if (args->pflags.subOnce && args->matched)
 		goto no_match;
 again:
 	xrv = regexec(&args->re, wp, args->nsub, m, flags);
 	if (xrv == 0)
 		goto ok;
 	if (xrv != REG_NOMATCH)
 		RegexError(xrv, &args->re, "Unexpected regex error");
 no_match:
 	SepBuf_AddRange(buf, wp, word.end);
 	return;
 ok:
 	args->matched = true;
 	SepBuf_AddBytes(buf, wp, (size_t)m[0].rm_so);
 	RegexReplace(args->replace, buf, wp, m, args->nsub);
 	wp += (size_t)m[0].rm_eo;
 	if (args->pflags.subGlobal) {
 		flags |= REG_NOTBOL;
 		if (m[0].rm_so == 0 && m[0].rm_eo == 0 && *wp != '\0') {
 			SepBuf_AddBytes(buf, wp, 1);
 			wp++;
+		}
 		if (*wp != '\0')
 			goto again;
+	}
 	if (*wp != '\0')
 		SepBuf_AddStr(buf, wp);
+}
 struct ModifyWord_LoopArgs {
 	GNode *scope;
 	const char *var;	/* name of the temporary variable */
 	const char *body;	/* string to expand */
 	VarEvalMode emode;
 };
 static void
 ModifyWord_Loop(Substring word, SepBuf *buf, void *data)
+{
 	const struct ModifyWord_LoopArgs *args;
 	char *s;
 	if (Substring_IsEmpty(word))
 		return;
 	args = data;
 	assert(word.end[0] == '\0');	/* assume null-terminated word */
 	Var_SetWithFlags(args->scope, args->var, word.start,
 	    VAR_SET_NO_EXPORT);
 	s = Var_Subst(args->body, args->scope, args->emode);
 	/* TODO: handle errors */
 	DEBUG2(VAR, "ModifyWord_Loop: expand \"%s\" to \"%s\"\n",
 	    args->body, s);
 	if (s[0] == '\n' || Buf_EndsWith(&buf->buf, '\n'))
 		buf->needSep = false;
 	SepBuf_AddStr(buf, s);
 	free(s);
+}
 /*
  * The :[first..last] modifier selects words from the expression.
  * It can also reverse the words.
  */
 static char *
 VarSelectWords(const char *str, int first, int last,
 	       char sep, bool oneBigWord)
+{
 	SubstringWords words;
 	int len, start, end, step;
 	int i;
 	SepBuf buf;
 	SepBuf_Init(&buf, sep);
 	if (oneBigWord) {
 		/* fake what Substring_Words() would do */
 		words.len = 1;
 		words.words = bmake_malloc(sizeof(words.words[0]));
 		words.freeIt = NULL;
 		words.words[0] = Substring_InitStr(str); /* no need to copy */
 	} else {
 		words = Substring_Words(str, false);
+	}
 	/* Convert -1 to len, -2 to (len - 1), etc. */
 	len = (int)words.len;
 	if (first < 0)
 		first += len + 1;
 	if (last < 0)
 		last += len + 1;
 	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_AddSubstring(&buf, words.words[i]);
 		SepBuf_Sep(&buf);
+	}
 	SubstringWords_Free(words);
 	return SepBuf_DoneData(&buf);
+}
 /*ARGSUSED*/
 static void
 ModifyWord_Realpath(Substring word, SepBuf *buf, void *data MAKE_ATTR_UNUSED)
+{
 	struct stat st;
 	char rbuf[MAXPATHLEN];
 	const char *rp;
 	assert(word.end[0] == '\0');	/* assume null-terminated word */
 	rp = cached_realpath(word.start, rbuf);
 	if (rp != NULL && *rp == '/' && stat(rp, &st) == 0)
 		SepBuf_AddStr(buf, rp);
 	else
 		SepBuf_AddSubstring(buf, word);
+}
 static char *
 SubstringWords_JoinFree(SubstringWords words)
+{
 	Buffer buf;
 	size_t i;
 	Buf_Init(&buf);
 	for (i = 0; i < words.len; i++) {
 		if (i != 0) {
 			/*
 			 * XXX: Use ch->sep instead of ' ', for consistency.
 			 */
 			Buf_AddByte(&buf, ' ');
+		}
 		Buf_AddRange(&buf, words.words[i].start, words.words[i].end);
+	}
 	SubstringWords_Free(words);
 	return Buf_DoneData(&buf);
+}
 /*
  * Quote shell meta-characters and space characters in the string.
  * If quoteDollar is set, also quote and double any '$' characters.
  */
 static void
 QuoteShell(const char *str, bool quoteDollar, LazyBuf *buf)
+{
 	const char *p;
 	LazyBuf_Init(buf, str);
 	for (p = str; *p != '\0'; p++) {
 		if (*p == '\n') {
 			const char *newline = Shell_GetNewline();
 			if (newline == NULL)
 				newline = "\\\n";
 			LazyBuf_AddStr(buf, newline);
 			continue;
+		}
 		if (ch_isspace(*p) || ch_is_shell_meta(*p))
 			LazyBuf_Add(buf, '\\');
 		LazyBuf_Add(buf, *p);
 		if (quoteDollar && *p == '$')
 			LazyBuf_AddStr(buf, "\\$");
+	}
+}
 /*
  * Compute the 32-bit hash of the given string, using the MurmurHash3
  * algorithm. Output is encoded as 8 hex digits, in Little Endian order.
  */
 static char *
 Hash(const char *str)
+{
 	static const char hexdigits[16] = "0123456789abcdef";
 	const unsigned char *ustr = (const unsigned char *)str;
 	uint32_t h = 0x971e137bU;
 	uint32_t c1 = 0x95543787U;
 	uint32_t c2 = 0x2ad7eb25U;
 	size_t len2 = strlen(str);
 	char *buf;
 	size_t i;
 	size_t len;
 	for (len = len2; len != 0;) {
 		uint32_t k = 0;
 		switch (len) {
 		default:
 			k = ((uint32_t)ustr[3] << 24) |
 			    ((uint32_t)ustr[2] << 16) |
 			    ((uint32_t)ustr[1] << 8) |
 			    (uint32_t)ustr[0];
 			len -= 4;
 			ustr += 4;
 			break;
 		case 3:
 			k |= (uint32_t)ustr[2] << 16;
 			/* FALLTHROUGH */
 		case 2:
 			k |= (uint32_t)ustr[1] << 8;
 			/* FALLTHROUGH */
 		case 1:
 			k |= (uint32_t)ustr[0];
 			len = 0;
+		}
 		c1 = c1 * 5 + 0x7b7d159cU;
 		c2 = c2 * 5 + 0x6bce6396U;
 		k *= c1;
 		k = (k << 11) ^ (k >> 21);
 		k *= c2;
 		h = (h << 13) ^ (h >> 19);
 		h = h * 5 + 0x52dce729U;
 		h ^= k;
+	}
 	h ^= (uint32_t)len2;
 	h *= 0x85ebca6b;
 	h ^= h >> 13;
 	h *= 0xc2b2ae35;
 	h ^= h >> 16;
 	buf = bmake_malloc(9);
 	for (i = 0; i < 8; i++) {
 		buf[i] = hexdigits[h & 0x0f];
 		h >>= 4;
+	}
 	buf[8] = '\0';
 	return buf;
+}
 static char *
 FormatTime(const char *fmt, time_t t, bool gmt)
+{
 	char buf[BUFSIZ];
 	if (t == 0)
 		time(&t);
 	if (*fmt == '\0')
 		fmt = "%c";
 	if (gmt && strchr(fmt, 's') != NULL) {
 		/* strftime "%s" only works with localtime, not with gmtime. */
 		const char *prev_tz_env = getenv("TZ");
 		char *prev_tz = prev_tz_env != NULL
 		    ? bmake_strdup(prev_tz_env) : NULL;
 		setenv("TZ", "UTC", 1);
 		strftime(buf, sizeof buf, fmt, localtime(&t));
 		if (prev_tz != NULL) {
 			setenv("TZ", prev_tz, 1);
 			free(prev_tz);
 		} else
 			unsetenv("TZ");
 	} else
 		strftime(buf, sizeof buf, fmt, (gmt ? gmtime : localtime)(&t));
 	buf[sizeof buf - 1] = '\0';
 	return bmake_strdup(buf);
+}
 /*
  * The ApplyModifier functions take an expression that is being evaluated.
  * Their task is to apply a single modifier to the expression.  This involves
  * parsing the modifier, evaluating it and finally updating the value of the
  * expression.
+ *
  * Parsing the modifier
+ *
  * If parsing succeeds, the parsing position *pp is updated to point to the
  * first character following the modifier, which typically is either ':' or
  * ch->endc.  The modifier doesn't have to check for this delimiter character,
  * this is done by ApplyModifiers.
+ *
  * XXX: As of 2020-11-15, some modifiers such as :S, :C, :P, :L do not
  * need to be followed by a ':' or endc; this was an unintended mistake.
+ *
  * If parsing fails because of a missing delimiter after a modifier part (as
  * in the :S, :C or :@ modifiers), return AMR_CLEANUP.
+ *
  * If parsing fails because the modifier is unknown, return AMR_UNKNOWN to
  * try the SysV modifier ':from=to' as fallback.  This should only be
  * done as long as there have been no side effects from evaluating nested
  * variables, to avoid evaluating them more than once.  In this case, the
  * parsing position may or may not be updated.  (XXX: Why not? The original
  * parsing position is well-known in ApplyModifiers.)
+ *
  * If parsing fails and the SysV modifier ${VAR:from=to} should not be used
  * as a fallback, issue an error message using Parse_Error (preferred over
  * Error) and then return AMR_CLEANUP, which stops processing the expression.
  * (XXX: As of 2020-08-23, evaluation of the string continues nevertheless
  * after skipping a few bytes, which results in garbage.)
+ *
  * Evaluating the modifier
+ *
  * After parsing, the modifier is evaluated.  The side effects from evaluating
  * nested expressions in the modifier text often already happen
  * during parsing though.  For most modifiers this doesn't matter since their
  * only noticeable effect is that they update the value of the expression.
  * Some modifiers such as ':sh' or '::=' have noticeable side effects though.
+ *
  * Evaluating the modifier usually takes the current value of the
  * expression from ch->expr->value, or the variable name from ch->var->name,
  * and stores the result back in ch->expr->value via Expr_SetValueOwn or
  * Expr_SetValueRefer.
+ *
  * If evaluating fails, the fallback error message "Bad modifier" is printed
  * using Error.  This function has no side effects, it really just prints the
  * error message, continuing as if nothing had happened.  TODO: This should be
  * fixed by adding proper error handling to Var_Subst, Var_Parse,
  * ApplyModifiers and ModifyWords.
+ *
  * Some modifiers such as :D and :U turn undefined expressions into defined
  * expressions using Expr_Define.
  */
 typedef enum ExprDefined {
 	/* The expression is based on a regular, defined variable. */
 	DEF_REGULAR,
 	/* The expression is based on an undefined variable. */
 	DEF_UNDEF,
 	/*
 	 * The expression started as an undefined expression, but one
 	 * of the modifiers (such as ':D' or ':U') has turned the expression
 	 * from undefined to defined.
 	 */
 	DEF_DEFINED
 } ExprDefined;
 static const char ExprDefined_Name[][10] = {
 	"regular",
 	"undefined",
 	"defined"
 };
 #if __STDC_VERSION__ >= 199901L
 #define const_member		const
 #else
 #define const_member		/* no const possible */
 #endif
 /* An expression based on a variable, such as $@ or ${VAR:Mpattern:Q}. */
 typedef struct Expr {
 	const char *name;
 	FStr value;
 	VarEvalMode const_member emode;
 	GNode *const_member scope;
 	ExprDefined defined;
 } Expr;
 /*
  * The status of applying a chain of modifiers to an expression.
+ *
  * The modifiers of an expression are broken into chains of modifiers,
  * starting a new nested chain whenever an indirect modifier starts.  There
  * are at most 2 nesting levels: the outer one for the direct modifiers, and
  * the inner one for the indirect modifiers.
+ *
  * For example, the expression ${VAR:M*:${IND1}:${IND2}:O:u} has 3 chains of
  * modifiers:
+ *
  *	Chain 1 starts with the single modifier ':M*'.
  *	  Chain 2 starts with all modifiers from ${IND1}.
  *	  Chain 2 ends at the ':' between ${IND1} and ${IND2}.
  *	  Chain 3 starts with all modifiers from ${IND2}.
  *	  Chain 3 ends at the ':' after ${IND2}.
  *	Chain 1 continues with the 2 modifiers ':O' and ':u'.
  *	Chain 1 ends at the final '}' of the expression.
+ *
  * After such a chain ends, its properties no longer have any effect.
+ *
  * See varmod-indirect.mk.
  */
 typedef struct ModChain {
 	Expr *expr;
 	/* '\0' or '{' or '(' */
 	char const_member startc;
 	/* '\0' or '}' or ')' */
 	char const_member endc;
 	/* Separator when joining words (see the :ts modifier). */
 	char sep;
 	/*
 	 * Whether some modifiers that otherwise split the variable value
 @@ -3720,1102 +3713,1101 @@ ApplyModifier_SysV(const char **pp, ModC
 	args.rhs = rhs.str;
 	ModifyWords(ch, ModifyWord_SysVSubst, &args, ch->oneBigWord);
 done:
 	LazyBuf_Done(&lhsBuf);
 	FStr_Done(&rhs);
 	return AMR_OK;
+}
 /* :sh */
 static ApplyModifierResult
 ApplyModifier_SunShell(const char **pp, ModChain *ch)
+{
 	Expr *expr = ch->expr;
 	const char *p = *pp;
 	if (!(p[1] == 'h' && IsDelimiter(p[2], ch)))
 		return AMR_UNKNOWN;
 	*pp = p + 2;
 	if (Expr_ShouldEval(expr)) {
 		char *output, *error;
 		output = Cmd_Exec(Expr_Str(expr), &error);
 		if (error != NULL) {
 			Error("%s", error);
 			free(error);
+		}
 		Expr_SetValueOwn(expr, output);
+	}
 	return AMR_OK;
+}
 /*
  * In cases where the evaluation mode and the definedness are the "standard"
  * ones, don't log them, to keep the logs readable.
  */
 static bool
 ShouldLogInSimpleFormat(const Expr *expr)
+{
 	return (expr->emode == VARE_WANTRES ||
 		expr->emode == VARE_UNDEFERR) &&
 	       expr->defined == DEF_REGULAR;
+}
 static void
 LogBeforeApply(const ModChain *ch, const char *mod)
+{
 	const Expr *expr = ch->expr;
 	bool is_single_char = mod[0] != '\0' && IsDelimiter(mod[1], ch);
 	/*
 	 * At this point, only the first character of the modifier can
 	 * be used since the end of the modifier is not yet known.
 	 */
 	if (!Expr_ShouldEval(expr)) {
 		debug_printf("Parsing modifier ${%s:%c%s}\n",
 		    expr->name, mod[0], is_single_char ? "" : "...");
 		return;
+	}
 	if (ShouldLogInSimpleFormat(expr)) {
 		debug_printf(
 		    "Evaluating modifier ${%s:%c%s} on value \"%s\"\n",
 		    expr->name, mod[0], is_single_char ? "" : "...",
 		    Expr_Str(expr));
 		return;
+	}
 	debug_printf(
 	    "Evaluating modifier ${%s:%c%s} on value \"%s\" (%s, %s)\n",
 	    expr->name, mod[0], is_single_char ? "" : "...", Expr_Str(expr),
 	    VarEvalMode_Name[expr->emode], ExprDefined_Name[expr->defined]);
+}
 static void
 LogAfterApply(const ModChain *ch, const char *p, const char *mod)
+{
 	const Expr *expr = ch->expr;
 	const char *value = Expr_Str(expr);
 	const char *quot = value == var_Error ? "" : "\"";
 	if (ShouldLogInSimpleFormat(expr)) {
 		debug_printf("Result of ${%s:%.*s} is %s%s%s\n",
 		    expr->name, (int)(p - mod), mod,
 		    quot, value == var_Error ? "error" : value, quot);
 		return;
+	}
 	debug_printf("Result of ${%s:%.*s} is %s%s%s (%s, %s)\n",
 	    expr->name, (int)(p - mod), mod,
 	    quot, value == var_Error ? "error" : value, quot,
 	    VarEvalMode_Name[expr->emode],
 	    ExprDefined_Name[expr->defined]);
+}
 static ApplyModifierResult
 ApplyModifier(const char **pp, ModChain *ch)
+{
 	switch (**pp) {
 	case '!':
 		return ApplyModifier_ShellCommand(pp, ch);
 	case ':':
 		return ApplyModifier_Assign(pp, ch);
 	case '?':
 		return ApplyModifier_IfElse(pp, ch);
 	case '@':
 		return ApplyModifier_Loop(pp, ch);
 	case '[':
 		return ApplyModifier_Words(pp, ch);
 	case '_':
 		return ApplyModifier_Remember(pp, ch);
 	case 'C':
 		return ApplyModifier_Regex(pp, ch);
 	case 'D':
 	case 'U':
 		return ApplyModifier_Defined(pp, ch);
 	case 'E':
 		return ApplyModifier_WordFunc(pp, ch, ModifyWord_Suffix);
 	case 'g':
 	case 'l':
 		return ApplyModifier_Time(pp, ch);
 	case 'H':
 		return ApplyModifier_WordFunc(pp, ch, ModifyWord_Head);
 	case 'h':
 		return ApplyModifier_Hash(pp, ch);
 	case 'L':
 		return ApplyModifier_Literal(pp, ch);
 	case 'M':
 	case 'N':
 		return ApplyModifier_Match(pp, ch);
 	case 'm':
 		return ApplyModifier_Mtime(pp, ch);
 	case 'O':
 		return ApplyModifier_Order(pp, ch);
 	case 'P':
 		return ApplyModifier_Path(pp, ch);
 	case 'Q':
 	case 'q':
 		return ApplyModifier_Quote(pp, ch);
 	case 'R':
 		return ApplyModifier_WordFunc(pp, ch, ModifyWord_Root);
 	case 'r':
 		return ApplyModifier_Range(pp, ch);
 	case 'S':
 		return ApplyModifier_Subst(pp, ch);
 	case 's':
 		return ApplyModifier_SunShell(pp, ch);
 	case 'T':
 		return ApplyModifier_WordFunc(pp, ch, ModifyWord_Tail);
 	case 't':
 		return ApplyModifier_To(pp, ch);
 	case 'u':
 		return ApplyModifier_Unique(pp, ch);
 	default:
 		return AMR_UNKNOWN;
+	}
+}
 static void ApplyModifiers(Expr *, const char **, char, char);
 typedef enum ApplyModifiersIndirectResult {
 	/* The indirect modifiers have been applied successfully. */
 	AMIR_CONTINUE,
 	/* Fall back to the SysV modifier. */
 	AMIR_SYSV,
 	/* Error out. */
 	AMIR_OUT
 } ApplyModifiersIndirectResult;
 /*
  * While expanding an expression, expand and apply indirect modifiers,
  * such as in ${VAR:${M_indirect}}.
+ *
  * All indirect modifiers of a group must come from a single
  * expression.  ${VAR:${M1}} is valid but ${VAR:${M1}${M2}} is not.
+ *
  * Multiple groups of indirect modifiers can be chained by separating them
  * with colons.  ${VAR:${M1}:${M2}} contains 2 indirect modifiers.
+ *
  * If the expression is not followed by ch->endc or ':', fall
  * back to trying the SysV modifier, such as in ${VAR:${FROM}=${TO}}.
  */
 static ApplyModifiersIndirectResult
 ApplyModifiersIndirect(ModChain *ch, const char **pp)
+{
 	Expr *expr = ch->expr;
 	const char *p = *pp;
 	FStr mods = Var_Parse(&p, expr->scope, expr->emode);
 	/* TODO: handle errors */
 	if (mods.str[0] != '\0' && !IsDelimiter(*p, ch)) {
 		FStr_Done(&mods);
 		return AMIR_SYSV;
+	}
 	DEBUG3(VAR, "Indirect modifier \"%s\" from \"%.*s\"\n",
 	    mods.str, (int)(p - *pp), *pp);
 	if (ModChain_ShouldEval(ch) && mods.str[0] != '\0') {
 		const char *modsp = mods.str;
 		ApplyModifiers(expr, &modsp, '\0', '\0');
 		if (Expr_Str(expr) == var_Error || *modsp != '\0') {
 			FStr_Done(&mods);
 			*pp = p;
 			return AMIR_OUT;	/* error already reported */
+		}
+	}
 	FStr_Done(&mods);
 	if (*p == ':')
 		p++;
 	else if (*p == '\0' && ch->endc != '\0') {
 		Error("Unclosed expression after indirect modifier, "
 		      "expecting '%c' for variable \"%s\"",
 		    ch->endc, expr->name);
 		*pp = p;
 		return AMIR_OUT;
+	}
 	*pp = p;
 	return AMIR_CONTINUE;
+}
 static ApplyModifierResult
 ApplySingleModifier(const char **pp, ModChain *ch)
+{
 	ApplyModifierResult res;
 	const char *mod = *pp;
 	const char *p = *pp;
 	if (DEBUG(VAR))
 		LogBeforeApply(ch, mod);
 	res = ApplyModifier(&p, ch);
 	if (res == AMR_UNKNOWN) {
 		assert(p == mod);
 		res = ApplyModifier_SysV(&p, ch);
+	}
 	if (res == AMR_UNKNOWN) {
 		/*
 		 * Guess the end of the current modifier.
 		 * XXX: Skipping the rest of the modifier hides
 		 * errors and leads to wrong results.
 		 * Parsing should rather stop here.
 		 */
 		for (p++; !IsDelimiter(*p, ch); p++)
 			continue;
 		Parse_Error(PARSE_FATAL, "Unknown modifier \"%.*s\"",
 		    (int)(p - mod), mod);
 		Expr_SetValueRefer(ch->expr, var_Error);
+	}
 	if (res == AMR_CLEANUP || res == AMR_BAD) {
 		*pp = p;
 		return res;
+	}
 	if (DEBUG(VAR))
 		LogAfterApply(ch, p, mod);
 	if (*p == '\0' && ch->endc != '\0') {
 		Error(
 		    "Unclosed expression, expecting '%c' for "
 		    "modifier \"%.*s\" of variable \"%s\" with value \"%s\"",
 		    ch->endc,
 		    (int)(p - mod), mod,
 		    ch->expr->name, Expr_Str(ch->expr));
 	} else if (*p == ':') {
 		p++;
 	} else if (opts.strict && *p != '\0' && *p != ch->endc) {
 		Parse_Error(PARSE_FATAL,
 		    "Missing delimiter ':' after modifier \"%.*s\"",
 		    (int)(p - mod), mod);
 		/*
 		 * TODO: propagate parse error to the enclosing
 		 * expression
 		 */
+	}
 	*pp = p;
 	return AMR_OK;
+}
 #if __STDC_VERSION__ >= 199901L
 #define ModChain_Init(expr, startc, endc, sep, oneBigWord) \
 	(ModChain) { expr, startc, endc, sep, oneBigWord }
 #else
 MAKE_INLINE ModChain
 ModChain_Init(Expr *expr, char startc, char endc, char sep, bool oneBigWord)
+{
 	ModChain ch;
 	ch.expr = expr;
 	ch.startc = startc;
 	ch.endc = endc;
 	ch.sep = sep;
 	ch.oneBigWord = oneBigWord;
 	return ch;
+}
 #endif
 /* Apply any modifiers (such as :Mpattern or :@var@loop@ or :Q or ::=value). */
 static void
 ApplyModifiers(
     Expr *expr,
     const char **pp,	/* the parsing position, updated upon return */
     char startc,	/* '(' or '{'; or '\0' for indirect modifiers */
     char endc		/* ')' or '}'; or '\0' for indirect modifiers */
+)
+{
 	ModChain ch = ModChain_Init(expr, startc, endc, ' ', false);
 	const char *p;
 	const char *mod;
 	assert(startc == '(' || startc == '{' || startc == '\0');
 	assert(endc == ')' || endc == '}' || endc == '\0');
 	assert(Expr_Str(expr) != NULL);
 	p = *pp;
 	if (*p == '\0' && endc != '\0') {
 		Error(
 		    "Unclosed expression, expecting '%c' for \"%s\"",
 		    ch.endc, expr->name);
 		goto cleanup;
+	}
 	while (*p != '\0' && *p != endc) {
 		ApplyModifierResult res;
 		if (*p == '$') {
 			/*
 			 * TODO: Only evaluate the expression once, no matter
 			 * whether it's an indirect modifier or the initial
 			 * part of a SysV modifier.
 			 */
 			ApplyModifiersIndirectResult amir =
 			    ApplyModifiersIndirect(&ch, &p);
 			if (amir == AMIR_CONTINUE)
 				continue;
 			if (amir == AMIR_OUT)
 				break;
+		}
 		mod = p;
 		res = ApplySingleModifier(&p, &ch);
 		if (res == AMR_CLEANUP)
 			goto cleanup;
 		if (res == AMR_BAD)
 			goto bad_modifier;
+	}
 	*pp = p;
 	assert(Expr_Str(expr) != NULL);	/* Use var_Error or varUndefined. */
 	return;
 bad_modifier:
 	/* Take a guess at where the modifier ends. */
 	Error("Bad modifier \":%.*s\" for variable \"%s\"",
 	    (int)strcspn(mod, ":)}"), mod, expr->name);
 cleanup:
 	/*
 	 * TODO: Use p + strlen(p) instead, to stop parsing immediately.
+	 *
 	 * In the unit tests, this generates a few shell commands with
 	 * unbalanced quotes.  Instead of producing these incomplete strings,
 	 * commands with evaluation errors should not be run at all.
+	 *
 	 * To make that happen, Var_Subst must report the actual errors
 	 * instead of returning the resulting string unconditionally.
 	 */
 	*pp = p;
 	Expr_SetValueRefer(expr, var_Error);
+}
 /*
  * Only 4 of the 7 built-in local variables are treated specially as they are
  * the only ones that will be set when dynamic sources are expanded.
  */
 static bool
 VarnameIsDynamic(Substring varname)
+{
 	const char *name;
 	size_t len;
 	name = varname.start;
 	len = Substring_Length(varname);
 	if (len == 1 || (len == 2 && (name[1] == 'F' || name[1] == 'D'))) {
 		switch (name[0]) {
 		case '@':
 		case '%':
 		case '*':
 		case '!':
 			return true;
+		}
 		return false;
+	}
 	if ((len == 7 || len == 8) && name[0] == '.' && ch_isupper(name[1])) {
 		return Substring_Equals(varname, ".TARGET") ||
 		       Substring_Equals(varname, ".ARCHIVE") ||
 		       Substring_Equals(varname, ".PREFIX") ||
 		       Substring_Equals(varname, ".MEMBER");
+	}
 	return false;
+}
 static const char *
 UndefinedShortVarValue(char varname, const GNode *scope)
+{
 	if (scope == SCOPE_CMDLINE || scope == SCOPE_GLOBAL) {
 		/*
 		 * If substituting a local variable in a non-local scope,
 		 * assume it's for dynamic source stuff. We have to handle
 		 * this specially and return the longhand for the variable
 		 * with the dollar sign escaped so it makes it back to the
 		 * caller. Only four of the local variables are treated
 		 * specially as they are the only four that will be set
 		 * when dynamic sources are expanded.
 		 */
 		switch (varname) {
 		case '@':
 			return "$(.TARGET)";
 		case '%':
 			return "$(.MEMBER)";
 		case '*':
 			return "$(.PREFIX)";
 		case '!':
 			return "$(.ARCHIVE)";
+		}
+	}
 	return NULL;
+}
 /*
  * Parse a variable name, until the end character or a colon, whichever
  * comes first.
  */
 static void
 ParseVarname(const char **pp, char startc, char endc,
 	     GNode *scope, VarEvalMode emode,
 	     LazyBuf *buf)
+{
 	const char *p = *pp;
 	int depth = 0;
 	LazyBuf_Init(buf, p);
 	while (*p != '\0') {
 		if ((*p == endc || *p == ':') && depth == 0)
 			break;
 		if (*p == startc)
 			depth++;
 		if (*p == endc)
 			depth--;
 		if (*p == '$') {
 			FStr nested_val = Var_Parse(&p, scope, emode);
 			/* TODO: handle errors */
 			LazyBuf_AddStr(buf, nested_val.str);
 			FStr_Done(&nested_val);
 		} else {
 			LazyBuf_Add(buf, *p);
 			p++;
+		}
+	}
 	*pp = p;
+}
 static bool
 IsShortVarnameValid(char varname, const char *start)
+{
 	if (varname != '$' && varname != ':' && varname != '}' &&
 	    varname != ')' && varname != '\0')
 		return true;
 	if (!opts.strict)
 		return false;	/* XXX: Missing error message */
 	if (varname == '$' && save_dollars)
 		Parse_Error(PARSE_FATAL,
 		    "To escape a dollar, use \\$, not $$, at \"%s\"", start);
 	else if (varname == '\0')
 		Parse_Error(PARSE_FATAL, "Dollar followed by nothing");
 	else if (save_dollars)
 		Parse_Error(PARSE_FATAL,
 		    "Invalid variable name '%c', at \"%s\"", varname, start);
 	return false;
+}
 /*
  * Parse a single-character variable name such as in $V or $@.
  * Return whether to continue parsing.
  */
 static bool
 ParseVarnameShort(char varname, const char **pp, GNode *scope,
 		  VarEvalMode emode,
 		  const char **out_false_val,
 		  Var **out_true_var)
+{
 	char name[2];
 	Var *v;
 	const char *val;
 	if (!IsShortVarnameValid(varname, *pp)) {
 		(*pp)++;	/* only skip the '$' */
 		*out_false_val = var_Error;
 		return false;
+	}
 	name[0] = varname;
 	name[1] = '\0';
 	v = VarFind(name, scope, true);
 	if (v != NULL) {
 		/* No need to advance *pp, the calling code handles this. */
 		*out_true_var = v;
 		return true;
+	}
 	*pp += 2;
 	val = UndefinedShortVarValue(varname, scope);
 	if (val == NULL)
 		val = emode == VARE_UNDEFERR ? var_Error : varUndefined;
 	if (opts.strict && val == var_Error) {
 		Parse_Error(PARSE_FATAL,
 		    "Variable \"%s\" is undefined", name);
+	}
 	*out_false_val = val;
 	return false;
+}
 /* Find variables like @F or <D. */
 static Var *
 FindLocalLegacyVar(Substring varname, GNode *scope,
 		   const char **out_extraModifiers)
+{
 	Var *v;
 	/* Only resolve these variables if scope is a "real" target. */
 	if (scope == SCOPE_CMDLINE || scope == SCOPE_GLOBAL)
 		return NULL;
 	if (Substring_Length(varname) != 2)
 		return NULL;
 	if (varname.start[1] != 'F' && varname.start[1] != 'D')
 		return NULL;
 	if (strchr("@%?*!<>", varname.start[0]) == NULL)
 		return NULL;
 	v = VarFindSubstring(Substring_Init(varname.start, varname.start + 1),
 	    scope, false);
 	if (v == NULL)
 		return NULL;
 	*out_extraModifiers = varname.start[1] == 'D' ? "H:" : "T:";
 	return v;
+}
 static FStr
 EvalUndefined(bool dynamic, const char *start, const char *p,
 	      Substring varname, VarEvalMode emode)
+{
 	if (dynamic)
 		return FStr_InitOwn(bmake_strsedup(start, p));
 	if (emode == VARE_UNDEFERR && opts.strict) {
 		Parse_Error(PARSE_FATAL,
 		    "Variable \"%.*s\" is undefined",
 		    (int)Substring_Length(varname), varname.start);
 		return FStr_InitRefer(var_Error);
+	}
 	return FStr_InitRefer(
 	    emode == VARE_UNDEFERR ? var_Error : varUndefined);
+}
 /*
  * Parse a long variable name enclosed in braces or parentheses such as $(VAR)
  * or ${VAR}, up to the closing brace or parenthesis, or in the case of
  * ${VAR:Modifiers}, up to the ':' that starts the modifiers.
  * Return whether to continue parsing.
  */
 static bool
 ParseVarnameLong(
 	const char **pp,
 	char startc,
 	GNode *scope,
 	VarEvalMode emode,
 	const char **out_false_pp,
 	FStr *out_false_val,
 	char *out_true_endc,
 	Var **out_true_v,
 	bool *out_true_haveModifier,
 	const char **out_true_extraModifiers,
 	bool *out_true_dynamic,
 	ExprDefined *out_true_exprDefined
+)
+{
 	LazyBuf varname;
 	Substring name;
 	Var *v;
 	bool haveModifier;
 	bool dynamic = false;
 	const char *p = *pp;
 	const char *start = p;
 	char endc = startc == '(' ? ')' : '}';
 	p += 2;			/* skip "${" or "$(" or "y(" */
 	ParseVarname(&p, startc, endc, scope, emode, &varname);
 	name = LazyBuf_Get(&varname);
 	if (*p == ':')
 		haveModifier = true;
 	else if (*p == endc)
 		haveModifier = false;
 	else {
 		Parse_Error(PARSE_FATAL, "Unclosed variable \"%.*s\"",
 		    (int)Substring_Length(name), name.start);
 		LazyBuf_Done(&varname);
 		*out_false_pp = p;
 		*out_false_val = FStr_InitRefer(var_Error);
 		return false;
+	}
 	v = VarFindSubstring(name, scope, true);
 	/*
 	 * At this point, p points just after the variable name, either at
 	 * ':' or at endc.
 	 */
 	if (v == NULL && Substring_Equals(name, ".SUFFIXES")) {
 		char *suffixes = Suff_NamesStr();
 		v = VarNew(FStr_InitRefer(".SUFFIXES"), suffixes,
 		    true, false, true);
 		free(suffixes);
 	} else if (v == NULL)
 		v = FindLocalLegacyVar(name, scope, out_true_extraModifiers);
 	if (v == NULL) {
 		/*
 		 * Defer expansion of dynamic variables if they appear in
 		 * non-local scope since they are not defined there.
 		 */
 		dynamic = VarnameIsDynamic(name) &&
 			  (scope == SCOPE_CMDLINE || scope == SCOPE_GLOBAL);
 		if (!haveModifier) {
 			p++;	/* skip endc */
 			*out_false_pp = p;
 			*out_false_val = EvalUndefined(dynamic, start, p,
 			    name, emode);
 			LazyBuf_Done(&varname);
 			return false;
+		}
 		/*
 		 * The expression is based on an undefined variable.
 		 * Nevertheless it needs a Var, for modifiers that access the
 		 * variable name, such as :L or :?.
+		 *
 		 * Most modifiers leave this expression in the "undefined"
 		 * state (DEF_UNDEF), only a few modifiers like :D, :U, :L,
 		 * :P turn this undefined expression into a defined
 		 * expression (DEF_DEFINED).
+		 *
 		 * In the end, after applying all modifiers, if the expression
 		 * is still undefined, Var_Parse will return an empty string
 		 * instead of the actually computed value.
 		 */
 		v = VarNew(LazyBuf_DoneGet(&varname), "",
 		    true, false, false);
 		*out_true_exprDefined = DEF_UNDEF;
 	} else
 		LazyBuf_Done(&varname);
 	*pp = p;
 	*out_true_endc = endc;
 	*out_true_v = v;
 	*out_true_haveModifier = haveModifier;
 	*out_true_dynamic = dynamic;
 	return true;
+}
 #if __STDC_VERSION__ >= 199901L
 #define Expr_Init(name, value, emode, scope, defined) \
 	(Expr) { name, value, emode, scope, defined }
 #else
 MAKE_INLINE Expr
 Expr_Init(const char *name, FStr value,
 	  VarEvalMode emode, GNode *scope, ExprDefined defined)
+{
 	Expr expr;
 	expr.name = name;
 	expr.value = value;
 	expr.emode = emode;
 	expr.scope = scope;
 	expr.defined = defined;
 	return expr;
+}
 #endif
 /*
  * Expressions of the form ${:U...} with a trivial value are often generated
  * by .for loops and are boring, so evaluate them without debug logging.
  */
 static bool
 Var_Parse_FastLane(const char **pp, VarEvalMode emode, FStr *out_value)
+{
 	const char *p;
 	p = *pp;
 	if (!(p[0] == '$' && p[1] == '{' && p[2] == ':' && p[3] == 'U'))
 		return false;
 	p += 4;
 	while (*p != '$' && *p != '{' && *p != ':' && *p != '\\' &&
 	       *p != '}' && *p != '\0')
 		p++;
 	if (*p != '}')
 		return false;
 	*out_value = emode == VARE_PARSE_ONLY
 	    ? FStr_InitRefer("")
 	    : FStr_InitOwn(bmake_strsedup(*pp + 4, p));
 	*pp = p + 1;
 	return true;
+}
 /*
  * Given the start of an expression (such as $v, $(VAR), ${VAR:Mpattern}),
  * extract the variable name and the modifiers, if any.  While parsing, apply
  * the modifiers to the value of the expression.
+ *
  * Input:
  *	*pp		The string to parse.
  *			When called from CondParser_FuncCallEmpty, it can
  *			also point to the "y" of "empty(VARNAME:Modifiers)".
  *	scope		The scope for finding variables.
  *	emode		Controls the exact details of parsing and evaluation.
+ *
  * Output:
  *	*pp		The position where to continue parsing.
  *			TODO: After a parse error, the value of *pp is
  *			unspecified.  It may not have been updated at all,
  *			point to some random character in the string, to the
  *			location of the parse error, or at the end of the
  *			string.
  *	return		The value of the expression, never NULL.
  *	return		var_Error if there was a parse error.
  *	return		var_Error if the base variable of the expression was
  *			undefined, emode is VARE_UNDEFERR, and none of
  *			the modifiers turned the undefined expression into a
  *			defined expression.
  *			XXX: It is not guaranteed that an error message has
  *			been printed.
  *	return		varUndefined if the base variable of the expression
  *			was undefined, emode was not VARE_UNDEFERR,
  *			and none of the modifiers turned the undefined
  *			expression into a defined expression.
  *			XXX: It is not guaranteed that an error message has
  *			been printed.
  */
 FStr
 Var_Parse(const char **pp, GNode *scope, VarEvalMode emode)
+{
 	const char *p = *pp;
 	const char *const start = p;
 	bool haveModifier;	/* true for ${VAR:...}, false for ${VAR} */
 	char startc;		/* the actual '{' or '(' or '\0' */
 	char endc;		/* the expected '}' or ')' or '\0' */
 	/*
 	 * true if the expression is based on one of the 7 predefined
 	 * variables that are local to a target, and the expression is
 	 * expanded in a non-local scope.  The result is the text of the
 	 * expression, unaltered.  This is needed to support dynamic sources.
 	 */
 	bool dynamic;
 	const char *extramodifiers;
 	Var *v;
 	Expr expr = Expr_Init(NULL, FStr_InitRefer(NULL), emode,
 	    scope, DEF_REGULAR);
 	FStr val;
 	if (Var_Parse_FastLane(pp, emode, &val))
 		return val;
 	DEBUG2(VAR, "Var_Parse: %s (%s)\n", start, VarEvalMode_Name[emode]);
 	val = FStr_InitRefer(NULL);
 	extramodifiers = NULL;	/* extra modifiers to apply first */
 	dynamic = false;
 	endc = '\0';		/* Appease GCC. */
 	startc = p[1];
 	if (startc != '(' && startc != '{') {
 		if (!ParseVarnameShort(startc, pp, scope, emode, &val.str, &v))
 			return val;
 		haveModifier = false;
 		p++;
 	} else {
 		if (!ParseVarnameLong(&p, startc, scope, emode,
 		    pp, &val,
 		    &endc, &v, &haveModifier, &extramodifiers,
 		    &dynamic, &expr.defined))
 			return val;
+	}
 	expr.name = v->name.str;
 	if (v->inUse && VarEvalMode_ShouldEval(emode)) {
 		if (scope->fname != NULL) {
 			fprintf(stderr, "In a command near ");
 			PrintLocation(stderr, false, scope);
+		}
 		Fatal("Variable %s is recursive.", v->name.str);
+	}
 	/*
 	 * FIXME: This assignment creates an alias to the current value of the
 	 * variable.  This means that as long as the value of the expression
 	 * stays the same, the value of the variable must not change, and the
 	 * variable must not be deleted.  Using the ':@' modifier, it is
 	 * possible (since var.c 1.212 from 2017-02-01) to delete the variable
 	 * while its value is still being used:
+	 *
 	 *	VAR=	value
 	 *	_:=	${VAR:${:U@VAR@loop@}:S,^,prefix,}
+	 *
 	 * The same effect might be achievable using the '::=' or the ':_'
 	 * modifiers.
+	 *
 	 * At the bottom of this function, the resulting value is compared to
 	 * the then-current value of the variable.  This might also invoke
 	 * undefined behavior.
 	 */
 	expr.value = FStr_InitRefer(v->val.data);
 	if (expr.name[0] != '\0')
 		EvalStack_Push(NULL, NULL, expr.name);
 	else
 		EvalStack_Push(NULL, start, NULL);
 	/*
 	 * Before applying any modifiers, expand any nested expressions from
 	 * the variable value.
 	 */
 	if (VarEvalMode_ShouldEval(emode) &&
 	    strchr(Expr_Str(&expr), '$') != NULL) {
 		char *expanded;
 		VarEvalMode nested_emode = emode;
 		if (opts.strict)
 			nested_emode = VarEvalMode_UndefOk(nested_emode);
 		v->inUse = true;
 		expanded = Var_Subst(Expr_Str(&expr), scope, nested_emode);
 		v->inUse = false;
 		/* TODO: handle errors */
 		Expr_SetValueOwn(&expr, expanded);
+	}
 	if (extramodifiers != NULL) {
 		const char *em = extramodifiers;
 		ApplyModifiers(&expr, &em, '\0', '\0');
+	}
 	if (haveModifier) {
 		p++;		/* Skip initial colon. */
 		ApplyModifiers(&expr, &p, startc, endc);
+	}
 	if (*p != '\0')		/* Skip past endc if possible. */
 		p++;
 	*pp = p;
 	if (expr.defined == DEF_UNDEF) {
 		if (dynamic)
 			Expr_SetValueOwn(&expr, bmake_strsedup(start, p));
 		else {
 			/*
 			 * The expression is still undefined, therefore
 			 * discard the actual value and return an error marker
 			 * instead.
 			 */
 			Expr_SetValueRefer(&expr,
 			    emode == VARE_UNDEFERR
 				? var_Error : varUndefined);
+		}
+	}
 	if (v->shortLived) {
 		if (expr.value.str == v->val.data) {
 			/* move ownership */
 			expr.value.freeIt = v->val.data;
 			v->val.data = NULL;
+		}
 		VarFreeShortLived(v);
+	}
 	EvalStack_Pop();
 	return expr.value;
+}
 static void
 VarSubstDollarDollar(const char **pp, Buffer *res, VarEvalMode emode)
+{
 	/* A dollar sign may be escaped with another dollar sign. */
 	if (save_dollars && VarEvalMode_ShouldKeepDollar(emode))
 		Buf_AddByte(res, '$');
 	Buf_AddByte(res, '$');
 	*pp += 2;
+}
 static void
 VarSubstExpr(const char **pp, Buffer *buf, GNode *scope,
 	     VarEvalMode emode, bool *inout_errorReported)
+{
 	const char *p = *pp;
 	const char *nested_p = p;
 	FStr val = Var_Parse(&nested_p, scope, emode);
 	/* TODO: handle errors */
 	if (val.str == var_Error || val.str == varUndefined) {
 		if (!VarEvalMode_ShouldKeepUndef(emode)) {
 			p = nested_p;
 		} else if (val.str == var_Error) {
 			/*
 			 * FIXME: The condition 'val.str == var_Error' doesn't
 			 * mean there was an undefined variable.  It could
 			 * equally well be a parse error; see
 			 * unit-tests/varmod-order.mk.
 			 */
 			/*
 			 * If variable is undefined, complain and skip the
 			 * variable. The complaint will stop us from doing
 			 * anything when the file is parsed.
 			 */
 			if (!*inout_errorReported) {
 				Parse_Error(PARSE_FATAL,
 				    "Undefined variable \"%.*s\"",
 				    (int)(nested_p - p), p);
 				*inout_errorReported = true;
+			}
 			p = nested_p;
 		} else {
 			/*
 			 * Copy the initial '$' of the undefined expression,
 			 * thereby deferring expansion of the expression, but
 			 * expand nested expressions if already possible. See
 			 * unit-tests/varparse-undef-partial.mk.
 			 */
 			Buf_AddByte(buf, *p);
 			p++;
+		}
 	} else {
 		p = nested_p;
 		Buf_AddStr(buf, val.str);
+	}
 	FStr_Done(&val);
 	*pp = p;
+}
 /*
  * Skip as many characters as possible -- either to the end of the string,
  * or to the next dollar sign, which may start an expression.
  */
 static void
 VarSubstPlain(const char **pp, Buffer *res)
+{
 	const char *p = *pp;
 	const char *start = p;
 	for (p++; *p != '$' && *p != '\0'; p++)
 		continue;
 	Buf_AddRange(res, start, p);
 	*pp = p;
+}
 /*
  * Expand all expressions like $V, ${VAR}, $(VAR:Modifiers) in the
  * given string.
+ *
  * Input:
- *	str		The string in which the expressions are
+ *	str		The string in which the expressions are expanded.
- *			expanded.
+ *	scope		The scope in which to start searching for variables.
- *	scope		The scope in which to start searching for
+ *			The other scopes are searched as well.
  *			variables.  The other scopes are searched as well.
  *	emode		The mode for parsing or evaluating subexpressions.
  */
 char *
 Var_Subst(const char *str, GNode *scope, VarEvalMode emode)
+{
 	const char *p = str;
 	Buffer res;
 	/*
 	 * Set true if an error has already been reported, to prevent a
 	 * plethora of messages when recursing
 	 */
 	static bool errorReported;
 	Buf_Init(&res);
 	errorReported = false;
 	while (*p != '\0') {
 		if (p[0] == '$' && p[1] == '$')
 			VarSubstDollarDollar(&p, &res, emode);
 		else if (p[0] == '$')
 			VarSubstExpr(&p, &res, scope, emode, &errorReported);
 		else
 			VarSubstPlain(&p, &res);
+	}
 	return Buf_DoneDataCompact(&res);
+}
 void
 Var_Expand(FStr *str, GNode *scope, VarEvalMode emode)
+{
 	char *expanded;
 	if (strchr(str->str, '$') == NULL)
 		return;
 	expanded = Var_Subst(str->str, scope, emode);
 	/* TODO: handle errors */
 	FStr_Done(str);
 	*str = FStr_InitOwn(expanded);
+}
 /* Initialize the variables module. */
 void
 Var_Init(void)
+{
 	SCOPE_INTERNAL = GNode_New("Internal");
 	SCOPE_GLOBAL = GNode_New("Global");
 	SCOPE_CMDLINE = GNode_New("Command");
+}
 /* Clean up the variables module. */
 void
 Var_End(void)
+{
 	Var_Stats();
+}
 void
 Var_Stats(void)
+{
 	HashTable_DebugStats(&SCOPE_GLOBAL->vars, "Global variables");
+}
 static int
 StrAsc(const void *sa, const void *sb)
+{
 	return strcmp(
 	    *((const char *const *)sa), *((const char *const *)sb));
+}
 /* Print all variables in a scope, sorted by name. */
 void
 Var_Dump(GNode *scope)
+{
 	Vector /* of const char * */ vec;
 	HashIter hi;
 	size_t i;
 	const char **varnames;
 	Vector_Init(&vec, sizeof(const char *));
 	HashIter_Init(&hi, &scope->vars);
 	while (HashIter_Next(&hi) != NULL)
 		*(const char **)Vector_Push(&vec) = hi.entry->key;
 	varnames = vec.items;
 	qsort(varnames, vec.len, sizeof varnames[0], StrAsc);
 	for (i = 0; i < vec.len; i++) {
 		const char *varname = varnames[i];
 		const Var *var = HashTable_FindValue(&scope->vars, varname);
 		debug_printf("%-16s = %s%s\n", varname,
 		    var->val.data, ValueDescription(var->val.data));
+	}
 	Vector_Done(&vec);
+}

 @@ -1,9 +1,9 @@
 : undefined--eol
-make: in target "unclosed-variable": Unclosed variable "UNCLOSED"
+make: in target "unclosed-expression": Unclosed variable "UNCLOSED"
-: unclosed-variable-
+: unclosed-expression-
 make: Unclosed expression, expecting '}' for "UNCLOSED"
 : unclosed-modifier-
 make: in target "unknown-modifier": while evaluating variable "UNKNOWN": Unknown modifier "Z"
 : unknown-modifier--eol
 : end-eol
 exit status 0

 @@ -1,9 +1,9 @@
 : undefined
-make: in target "unclosed-variable": Unclosed variable "UNCLOSED"
+make: in target "unclosed-expression": Unclosed variable "UNCLOSED"
-: unclosed-variable
+: unclosed-expression
 make: Unclosed expression, expecting '}' for "UNCLOSED"
 : unclosed-modifier
 make: in target "unknown-modifier": while evaluating variable "UNKNOWN": Unknown modifier "Z"
 : unknown-modifier
 : end
 exit status 2

 @@ -1,38 +1,39 @@
-# $NetBSD: cmd-errors-jobs.mk,v 1.3 2024/04/20 10:18:55 rillig Exp $
+# $NetBSD: cmd-errors-jobs.mk,v 1.4 2024/04/23 22:51:28 rillig Exp $
+#
-# Demonstrate how errors in variable expansions affect whether the commands
+# Demonstrate how errors in expressions affect whether the commands
 # are actually executed in jobs mode.
 .MAKEFLAGS: -j1
-all: undefined unclosed-variable unclosed-modifier unknown-modifier end
+all: undefined unclosed-expression unclosed-modifier unknown-modifier end
-# Undefined variables are not an error.  They expand to empty strings.
+# Undefined variables in expressions are not an error.  They expand to empty
 # strings.
 # expect: : undefined--eol
 undefined:
 	: $@-${UNDEFINED}-eol
 # XXX: This command is executed even though it contains parse errors.
-# expect: make: in target "unclosed-variable": Unclosed variable "UNCLOSED"
+# expect: make: in target "unclosed-expression": Unclosed variable "UNCLOSED"
-# expect: : unclosed-variable-
+# expect: : unclosed-expression-
-unclosed-variable:
+unclosed-expression:
 	: $@-${UNCLOSED
 # XXX: This command is executed even though it contains parse errors.
 # expect: make: Unclosed expression, expecting '}' for "UNCLOSED"
 # expect: : unclosed-modifier-
 unclosed-modifier:
 	: $@-${UNCLOSED:
 # XXX: This command is executed even though it contains parse errors.
 # expect: make: in target "unknown-modifier": while evaluating variable "UNKNOWN": Unknown modifier "Z"
 # expect: : unknown-modifier--eol
 unknown-modifier:
 	: $@-${UNKNOWN:Z}-eol
 # expect: : end-eol
 end:
 	: $@-eol
 # XXX: Despite the parse errors, the exit status is 0.
 # expect: exit status 0

 @@ -1,9 +1,9 @@
 : undefined--eol
-make: in target "unclosed-variable": Unclosed variable "UNCLOSED"
+make: in target "unclosed-expression": Unclosed variable "UNCLOSED"
-: unclosed-variable-
+: unclosed-expression-
 make: Unclosed expression, expecting '}' for "UNCLOSED"
 : unclosed-modifier-
 make: in target "unknown-modifier": while evaluating variable "UNKNOWN": Unknown modifier "Z"
 : unknown-modifier--eol
 : end-eol
 exit status 0

 @@ -1,8 +1,5 @@
 make: "cond-func-defined.mk" line 24: Missing closing parenthesis for defined()
 make: "cond-func-defined.mk" line 34: Missing closing parenthesis for defined()
 make: "cond-func-defined.mk" line 47: In .for loops, expressions for the loop variables are
 make: "cond-func-defined.mk" line 49: substituted at evaluation time.  There is no actual variable
 make: "cond-func-defined.mk" line 51: involved, even if it feels like it.
 make: Fatal errors encountered -- cannot continue
 make: stopped in unit-tests
 exit status 1

 @@ -1,32 +1,33 @@
-# $NetBSD: cmd-errors-lint.mk,v 1.1 2020/11/02 20:43:27 rillig Exp $
+# $NetBSD: cmd-errors-lint.mk,v 1.2 2024/04/23 22:51:28 rillig Exp $
+#
-# Demonstrate how errors in variable expansions affect whether the commands
+# Demonstrate how errors in expressions affect whether the commands
 # are actually executed.
 .MAKEFLAGS: -dL
-all: undefined unclosed-variable unclosed-modifier unknown-modifier end
+all: undefined unclosed-expression unclosed-modifier unknown-modifier end
-# Undefined variables are not an error.  They expand to empty strings.
+# Undefined variables in expressions are not an error.  They expand to empty
 # strings.
 undefined:
 	: $@ ${UNDEFINED}
 # XXX: As of 2020-11-01, this obvious syntax error is not detected.
 # XXX: As of 2020-11-01, this command is executed even though it contains
 # parse errors.
-unclosed-variable:
+unclosed-expression:
 	: $@ ${UNCLOSED
 # XXX: As of 2020-11-01, this obvious syntax error is not detected.
 # XXX: As of 2020-11-01, this command is executed even though it contains
 # parse errors.
 unclosed-modifier:
 	: $@ ${UNCLOSED:
 # XXX: As of 2020-11-01, this command is executed even though it contains
 # parse errors.
 unknown-modifier:
 	: $@ ${UNKNOWN:Z}
 end:
 	: $@

 @@ -1,52 +1,52 @@
-# $NetBSD: cmdline-undefined.mk,v 1.4 2023/11/19 21:47:52 rillig Exp $
+# $NetBSD: cmdline-undefined.mk,v 1.5 2024/04/23 22:51:28 rillig Exp $
+#
-# Tests for undefined expressions in the command line.
+# Tests for undefined variables in expressions in the command line.
 all:
 	# When the command line is parsed, variable assignments using the
 	# '=' assignment operator do get their variable name expanded
 	# (which probably occurs rarely in practice, if at all), but their
 	# variable value is not expanded, as usual.
+	#
 	@echo 'The = assignment operator'
 	@${.MAKE} -f ${MAKEFILE} print-undefined \
 		CMDLINE='Undefined is $${UNDEFINED}.'
 	@echo
 	# The interesting case is using the ':=' assignment operator, which
 	# expands its right-hand side.  But only those variables that are
 	# defined.
 	@echo 'The := assignment operator'
 	@${.MAKE} -f ${MAKEFILE} print-undefined \
 		CMDLINE:='Undefined is $${UNDEFINED}.'
 	@echo
 .if make(print-undefined)
 .MAKEFLAGS: MAKEFLAGS_ASSIGN='Undefined is $${UNDEFINED}.'
 .MAKEFLAGS: MAKEFLAGS_SUBST:='Undefined is $${UNDEFINED}.'
 # expect+2: From the command line: Undefined is .
 # expect+1: From the command line: Undefined is .
 .info From the command line: ${CMDLINE}
 # expect+2: From .MAKEFLAGS '=': Undefined is .
 # expect+1: From .MAKEFLAGS '=': Undefined is .
 .info From .MAKEFLAGS '=': ${MAKEFLAGS_ASSIGN}
 # expect+2: From .MAKEFLAGS ':=': Undefined is .
 # expect+1: From .MAKEFLAGS ':=': Undefined is .
 .info From .MAKEFLAGS ':=': ${MAKEFLAGS_SUBST}
 UNDEFINED?=	now defined
 # expect+2: From the command line: Undefined is now defined.
 # expect+1: From the command line: Undefined is now defined.
 .info From the command line: ${CMDLINE}
 # expect+2: From .MAKEFLAGS '=': Undefined is now defined.
 # expect+1: From .MAKEFLAGS '=': Undefined is now defined.
 .info From .MAKEFLAGS '=': ${MAKEFLAGS_ASSIGN}
 # expect+2: From .MAKEFLAGS ':=': Undefined is now defined.
 # expect+1: From .MAKEFLAGS ':=': Undefined is now defined.
 .info From .MAKEFLAGS ':=': ${MAKEFLAGS_SUBST}
 print-undefined:
 .endif

 @@ -1,58 +1,58 @@
-# $NetBSD: cmdline.mk,v 1.4 2022/06/10 18:58:07 rillig Exp $
+# $NetBSD: cmdline.mk,v 1.5 2024/04/23 22:51:28 rillig Exp $
+#
 # Tests for command line parsing and related special variables.
 TMPBASE?=	${TMPDIR:U/tmp/uid${.MAKE.UID}}
 SUB1=		a7b41170-53f8-4cc2-bc5c-e4c3dd93ec45	# just a random UUID
 SUB2=		6a8899d2-d227-4b55-9b6b-f3c8eeb83fd5	# just a random UUID
 MAKE_CMD=	env TMPBASE=${TMPBASE}/${SUB1} ${.MAKE} -f ${MAKEFILE} -r
 DIR2=		${TMPBASE}/${SUB2}
 DIR12=		${TMPBASE}/${SUB1}/${SUB2}
 all: prepare-dirs
 all: makeobjdir-direct makeobjdir-indirect
 all: space-and-comment
 prepare-dirs:
 	@rm -rf ${DIR2} ${DIR12}
 	@mkdir -p ${DIR2} ${DIR12}
 # The .OBJDIR can be set via the MAKEOBJDIR command line variable.
 # It must be a command line variable; an environment variable would not work.
 makeobjdir-direct:
 	@echo $@:
 	@${MAKE_CMD} MAKEOBJDIR=${DIR2} show-objdir
 # The .OBJDIR can be set via the MAKEOBJDIR command line variable,
-# and that variable could even contain the usual modifiers.
+# and expressions based on that variable can contain the usual modifiers.
 # Since the .OBJDIR=MAKEOBJDIR assignment happens very early,
 # the SUB2 variable in the modifier is not defined yet and is therefore empty.
 # The SUB1 in the resulting path comes from the environment variable TMPBASE,
 # see MAKE_CMD.
 makeobjdir-indirect:
 	@echo $@:
 	@${MAKE_CMD} MAKEOBJDIR='$${TMPBASE}/$${SUB2}' show-objdir
 show-objdir:
 	@echo $@: ${.OBJDIR:Q}
 # Variable assignments in the command line are handled differently from
 # variable assignments in makefiles.  In the command line, trailing whitespace
 # is preserved, and the '#' does not start a comment.  This is because the
 # low-level parsing from ParseRawLine does not take place.
+#
 # Preserving '#' and trailing whitespace has the benefit that when passing
 # such values to sub-makes via MAKEFLAGS, no special encoding is needed.
 # Leading whitespace in the variable value is discarded though, which makes
 # the behavior inconsistent.
 space-and-comment: .PHONY
 	@echo $@:
 	@env -i \
 	    ${MAKE} -r -f /dev/null ' VAR= value # no comment ' -v VAR \
 	| sed 's,$$,$$,'
 	@env -i MAKEFLAGS="' VAR= value # no comment '" \
 	    ${MAKE} -r -f /dev/null -v VAR \
 	| sed 's,$$,$$,'

 @@ -1,80 +1,80 @@
-# $NetBSD: comment.mk,v 1.6 2023/11/19 21:47:52 rillig Exp $
+# $NetBSD: comment.mk,v 1.7 2024/04/23 22:51:28 rillig Exp $
+#
 # Demonstrate how comments are written in makefiles.
 # This is a comment.
 #\
 This is a multiline comment.
 # Another multiline comment \
 that \
 goes \
 on and on.
  # Comments can be indented with spaces, but that is rather unusual.
 	# Comments can be indented with a tab.
 	# Since parse.c 1.127 from 2007-01-01, these are not shell commands,
 	# they are just makefile comments.  Before that commit, these comments
 	# triggered the error message "Unassociated shell command".
 .if 1			# There can be comments after conditions.
 .endif			# And after the closing directive.
 VAR=			# This comment makes the variable value empty.
 			# ParseRawLine removes any whitespace before the
 			# comment.
 .if ${VAR} != ""
 .  error
 .endif
 # The comment does not need to start at the beginning of a word (as in the
 # shell), it can start anywhere.
 VAR=# defined but empty
 # The space before the comment is always trimmed.
 VAR=	value
 .if ${VAR} != "value"
 .  error
 .endif
 # This comment ends with 2 backslashes.  An even number of backslashes does
 # not count as a line continuation, therefore the variable assignment that
 # follows is actively interpreted. \\
 VAR=	not part of the comment
 .if ${VAR} != "not part of the comment"
 .  error
 .endif
 # To escape a comment sign, precede it with a backslash.
 VAR=	\#		# Both in the assignment.
 .if ${VAR} != "\#"	# And in the comparison.
 .  error
 .endif
-# Since 2012-03-24 the variable modifier :[#] does not need to be escaped.
+# Since 2012-03-24 the modifier :[#] does not need to be escaped.
-# To keep the parsing code simple, any "[#" does not start a comment, even
+# To keep the parsing code simple, the "#" in "[#" does not start a comment,
-# outside of an expression.
+# regardless of the syntactical context it appears in.
 WORDS=	${VAR:[#]} [#
 .if ${WORDS} != "1 [#"
 .  error
 .endif
 # An odd number of backslashes makes a line continuation, \\\
 no matter if it is 3 or 5 \\\\\
 or 9 backslashes. \\\\\\\\\
 This is the last line of the comment.
 VAR=	no comment anymore
 .if ${VAR} != "no comment anymore"
 .  error
 .endif
 all:
 # In the commands associated with a target, the '#' does not start a makefile
 # comment.  The '#' is just passed to the shell, like any ordinary character.
 	echo This is a shell comment: # comment
 # If the '#' were to start a makefile comment, the following shell command
 # would have unbalanced quotes.
 	echo This is not a shell comment: '# comment'
 	@echo A shell comment can#not start in the middle of a word.

 @@ -1,154 +1,154 @@
-# $NetBSD: cond-cmp-string.mk,v 1.18 2023/11/19 21:47:52 rillig Exp $
+# $NetBSD: cond-cmp-string.mk,v 1.19 2024/04/23 22:51:28 rillig Exp $
+#
 # Tests for string comparisons in .if conditions.
 # This is a simple comparison of string literals.
 # Nothing surprising here.
 .if "str" != "str"
 .  error
 .endif
 # The right-hand side of the comparison may be written without quotes.
 .if "str" != str
 .  error
 .endif
 # The left-hand side of the comparison must be enclosed in quotes.
 # This one is not enclosed in quotes and thus generates an error message.
 # expect+1: Malformed conditional (str != str)
 .if str != str
 .  error
 .endif
-# The left-hand side of the comparison requires that any expression
+# An expression that occurs on the left-hand side of the comparison must be
-# is defined.
+# defined.
+#
 # The variable named "" is never defined, nevertheless it can be used as a
-# starting point for expressions.  Applying the :U modifier to such
+# starting point for an expression.  Applying the :U modifier to such an
-# an undefined expression turns it into a defined expression.
+# undefined expression turns it into a defined expression.
+#
 # See ApplyModifier_Defined and DEF_DEFINED.
 .if ${:Ustr} != "str"
 .  error
 .endif
 # Any character in a string literal may be escaped using a backslash.
 # This means that "\n" does not mean a newline but a simple "n".
 .if "string" != "\s\t\r\i\n\g"
 .  error
 .endif
 # It is not possible to concatenate two string literals to form a single
 # string.  In C, Python and the shell this is possible, but not in make.
 # expect+1: Malformed conditional ("string" != "str""ing")
 .if "string" != "str""ing"
 .  error
 .else
 .  error
 .endif
 # There is no = operator for strings.
 # expect+1: Malformed conditional (!("value" = "value"))
 .if !("value" = "value")
 .  error
 .else
 .  error
 .endif
 # There is no === operator for strings either.
 # expect+1: Malformed conditional (!("value" === "value"))
 .if !("value" === "value")
 .  error
 .else
 .  error
 .endif
 # An expression can be enclosed in double quotes.
 .if ${:Uword} != "${:Uword}"
 .  error
 .endif
 # Between 2003-01-01 (maybe even earlier) and 2020-10-30, adding one of the
-# characters " \t!=><" directly after an expression resulted in a
+# characters " \t!=><" directly after an expression in a string literal
-# "Malformed conditional", even though the string was well-formed.
+# resulted in a "Malformed conditional", even though the string was
 # well-formed.
 .if ${:Uword } != "${:Uword} "
 .  error
 .endif
 # Some other characters worked though, and some didn't.
 # Those that are mentioned in is_separator didn't work.
 .if ${:Uword0} != "${:Uword}0"
 .  error
 .endif
 .if ${:Uword&} != "${:Uword}&"
 .  error
 .endif
 .if ${:Uword!} != "${:Uword}!"
 .  error
 .endif
 .if ${:Uword<} != "${:Uword}<"
 .  error
 .endif
 # Adding another expression to the string literal works though.
 .if ${:Uword} != "${:Uwo}${:Urd}"
 .  error
 .endif
-# Adding a space at the beginning of the quoted expression works
+# Adding a space at the beginning of the quoted expression works though.
 # though.
 .if ${:U word } != " ${:Uword} "
 .  error
 .endif
 # If at least one side of the comparison is a string literal, the string
 # comparison is performed.
 .if 12345 != "12345"
 .  error
 .endif
 # If at least one side of the comparison is a string literal, the string
 # comparison is performed.  The ".0" in the left-hand side makes the two
 # sides of the equation unequal.
 .if 12345.0 == "12345"
 .  error
 .endif
 # Strings cannot be compared relationally, only for equality.
 # expect+1: Comparison with '<' requires both operands 'string' and 'string' to be numeric
 .if "string" < "string"
 .  error
 .else
 .  error
 .endif
 # Strings cannot be compared relationally, only for equality.
 # expect+1: Comparison with '<=' requires both operands 'string' and 'string' to be numeric
 .if "string" <= "string"
 .  error
 .else
 .  error
 .endif
 # Strings cannot be compared relationally, only for equality.
 # expect+1: Comparison with '>' requires both operands 'string' and 'string' to be numeric
 .if "string" > "string"
 .  error
 .else
 .  error
 .endif
 # Strings cannot be compared relationally, only for equality.
 # expect+1: Comparison with '>=' requires both operands 'string' and 'string' to be numeric
 .if "string" >= "string"
 .  error
 .else
 .  error
 .endif
-# Two variables with different values compare unequal.
+# Two expressions with different values compare unequal.
 VAR1=	value1
 VAR2=	value2
 .if ${VAR1} != ${VAR2}
 .else
 .  error
 .endif

 @@ -1,61 +1,58 @@
-# $NetBSD: cond-func-defined.mk,v 1.11 2023/11/19 21:47:52 rillig Exp $
+# $NetBSD: cond-func-defined.mk,v 1.12 2024/04/23 22:51:28 rillig Exp $
+#
 # Tests for the defined() function in .if conditions.
 DEF=		defined
 ${:UA B}=	variable name with spaces
 .if !defined(DEF)
 .  error
 .endif
 # Horizontal whitespace (space tab) after the opening parenthesis is ignored.
 .if !defined( 	DEF)
 .  error
 .endif
 # Horizontal whitespace (space tab) before the closing parenthesis is ignored.
 .if !defined(DEF 	)
 .  error
 .endif
 # The argument of a function must not directly contain whitespace.
 # expect+1: Missing closing parenthesis for defined()
 .if !defined(A B)
 .  error
 .endif
 # If necessary, the whitespace can be generated by an expression.
 .if !defined(${:UA B})
 .  error
 .endif
 # expect+1: Missing closing parenthesis for defined()
 .if defined(DEF
 .  error
 .else
 .  error
 .endif
 # Variables from .for loops are not defined.
 # See directive-for.mk for more details.
 .for var in value
 .  if defined(var)
 .    error
 .  else
-# expect+1: In .for loops, expressions for the loop variables are
+# In .for loops, expressions based on the loop variables are substituted at
-.    info In .for loops, expressions for the loop variables are
+# evaluation time.  There is no actual variable involved, even if the code in
-# expect+1: substituted at evaluation time.  There is no actual variable
+# the makefiles looks like it.
 .    info substituted at evaluation time.  There is no actual variable
 # expect+1: involved, even if it feels like it.
 .    info involved, even if it feels like it.
 .  endif
 .endfor
 # Neither of the conditions is true.  Before July 2020, the right-hand
 # condition was evaluated even though it was irrelevant.
 .if defined(UNDEF) && ${UNDEF:Mx} != ""
 .  error
 .endif
 all: .PHONY

 @@ -1,307 +1,307 @@
-# $NetBSD: varmod-ifelse.mk,v 1.27 2024/04/20 10:18:55 rillig Exp $
+# $NetBSD: varmod-ifelse.mk,v 1.28 2024/04/23 22:51:28 rillig Exp $
+#
 # Tests for the ${cond:?then:else} variable modifier, which evaluates either
 # the then-expression or the else-expression, depending on the condition.
+#
 # The modifier was added on 1998-04-01.
+#
 # Until 2015-10-11, the modifier always evaluated both the "then" and the
 # "else" expressions.
 # TODO: Implementation
 # The variable name of the expression is expanded and then taken as the
 # condition.  In the below example it becomes:
+#
 #	bare words == "literal"
+#
 # This confuses the parser, which expects an operator instead of the bare
 # word "expression".  If the name were expanded lazily, everything would be
 # fine since the condition would be:
+#
 #	${:Ubare words} == "literal"
+#
 # Evaluating the variable name lazily would require additional code in
 # Var_Parse and ParseVarname, it would be more useful and predictable
 # though.
 # expect+1: Malformed conditional (${${:Ubare words} == "literal":?bad:bad})
 .if ${${:Ubare words} == "literal":?bad:bad}
 .  error
 .else
 .  error
 .endif
 # In a variable assignment, undefined variables are not an error.
 # Because of the early expansion, the whole condition evaluates to
 # ' == ""' though, which cannot be parsed because the left-hand side looks
 # empty.
 COND:=	${${UNDEF} == "":?bad-assign:bad-assign}
 # In a condition, undefined variables generate a "Malformed conditional"
 # error.  That error message is wrong though.  In lint mode, the correct
 # "Undefined variable" error message is generated.
 # The difference to the ':=' variable assignment is the additional
 # "Malformed conditional" error message.
 # expect+1: Malformed conditional (${${UNDEF} == "":?bad-cond:bad-cond})
 .if ${${UNDEF} == "":?bad-cond:bad-cond}
 .  error
 .else
 .  error
 .endif
 # When the :? is parsed, it is greedy.  The else branch spans all the
 # text, up until the closing character '}', even if the text looks like
 # another modifier.
 .if ${1:?then:else:Q} != "then"
 .  error
 .endif
 .if ${0:?then:else:Q} != "else:Q"
 .  error
 .endif
 # This line generates 2 error messages.  The first comes from evaluating the
 # malformed conditional "1 == == 2", which is reported as "Bad conditional
 # expression" by ApplyModifier_IfElse.  The expression containing that
 # conditional therefore returns a parse error from Var_Parse, and this parse
 # error propagates to CondEvalExpression, where the "Malformed conditional"
 # comes from.
 # expect+1: Malformed conditional (${1 == == 2:?yes:no} != "")
 .if ${1 == == 2:?yes:no} != ""
 .  error
 .else
 .  error
 .endif
 # If the "Bad conditional expression" appears in a quoted string literal, the
 # error message "Malformed conditional" is not printed, leaving only the "Bad
 # conditional expression".
+#
 # XXX: The left-hand side is enclosed in quotes.  This results in Var_Parse
 # being called without VARE_UNDEFERR.  When ApplyModifier_IfElse
 # returns AMR_CLEANUP as result, Var_Parse returns varUndefined since the
 # value of the expression is still undefined.  CondParser_String is
 # then supposed to do proper error handling, but since varUndefined is local
 # to var.c, it cannot distinguish this return value from an ordinary empty
 # string.  The left-hand side of the comparison is therefore just an empty
 # string, which is obviously equal to the empty string on the right-hand side.
+#
 # XXX: The debug log for -dc shows a comparison between 1.0 and 0.0.  The
 # condition should be detected as being malformed before any comparison is
 # done since there is no well-formed comparison in the condition at all.
 .MAKEFLAGS: -dc
 .if "${1 == == 2:?yes:no}" != ""
 .  error
 .else
 # expect+1: warning: Oops, the parse error should have been propagated.
 .  warning Oops, the parse error should have been propagated.
 .endif
 .MAKEFLAGS: -d0
 # As of 2020-12-10, the variable "VAR" is first expanded, and the result of
 # this expansion is then taken as the condition.  To force the
 # expression in the condition to be evaluated at exactly the right point,
 # the '$' of the intended '${VAR}' escapes from the parser in form of the
 # expression ${:U\$}.  Because of this escaping, the variable "VAR" and thus
 # the condition ends up as "${VAR} == value", just as intended.
+#
 # This hack does not work for variables from .for loops since these are
 # expanded at parse time to their corresponding ${:Uvalue} expressions.
 # Making the '$' of the '${VAR}' expression indirect hides this expression
 # from the parser of the .for loop body.  See ForLoop_SubstVarLong.
 .MAKEFLAGS: -dc
 VAR=	value
 .if ${ ${:U\$}{VAR} == value:?ok:bad} != "ok"
 .  error
 .endif
 .MAKEFLAGS: -d0
 # On 2021-04-19, when building external/bsd/tmux with HAVE_LLVM=yes and
 # HAVE_GCC=no, the following conditional generated this error message:
+#
 #	make: Bad conditional expression 'string == "literal" && no >= 10'
 #	    in 'string == "literal" && no >= 10?yes:no'
+#
 # Despite the error message (which was not clearly marked with "error:"),
 # the build continued, for historical reasons, see main_Exit.
+#
 # The tricky detail here is that the condition that looks so obvious in the
 # form written in the makefile becomes tricky when it is actually evaluated.
 # This is because the condition is written in the place of the variable name
 # of the expression, and in an expression, the variable name is always
 # expanded first, before even looking at the modifiers.  This happens for the
 # modifier ':?' as well, so when CondEvalExpression gets to see the
 # expression, it already looks like this:
+#
 #	string == "literal" && no >= 10
+#
 # When parsing such an expression, the parser used to be strict.  It first
 # evaluated the left-hand side of the operator '&&' and then started parsing
 # the right-hand side 'no >= 10'.  The word 'no' is obviously a string
 # literal, not enclosed in quotes, which is OK, even on the left-hand side of
 # the comparison operator, but only because this is a condition in the
 # modifier ':?'.  In an ordinary directive '.if', this would be a parse error.
 # For strings, only the comparison operators '==' and '!=' are defined,
 # therefore parsing stopped at the '>', producing the 'Bad conditional
 # expression'.
+#
 # Ideally, the conditional expression would not be expanded before parsing
 # it.  This would allow to write the conditions exactly as seen below.  That
 # change has a high chance of breaking _some_ existing code and would need
 # to be thoroughly tested.
+#
 # Since cond.c 1.262 from 2021-04-20, make reports a more specific error
 # message in situations like these, pointing directly to the specific problem
 # instead of just saying that the whole condition is bad.
 STRING=		string
 NUMBER=		no		# not really a number
 # expect+1: no.
 .info ${${STRING} == "literal" && ${NUMBER} >= 10:?yes:no}.
 # expect+3: while evaluating variable "string == "literal" || no >= 10": Comparison with '>=' requires both operands 'no' and '10' to be numeric
 # expect: make: Bad conditional expression 'string == "literal" || no >= 10' before '?yes:no'
 # expect+1: .
 .info ${${STRING} == "literal" || ${NUMBER} >= 10:?yes:no}.
 # The following situation occasionally occurs with MKINET6 or similar
 # variables.
 NUMBER=		# empty, not really a number either
 # expect: make: Bad conditional expression 'string == "literal" &&  >= 10' before '?yes:no'
 # expect+1: .
 .info ${${STRING} == "literal" && ${NUMBER} >= 10:?yes:no}.
 # expect: make: Bad conditional expression 'string == "literal" ||  >= 10' before '?yes:no'
 # expect+1: .
 .info ${${STRING} == "literal" || ${NUMBER} >= 10:?yes:no}.
 # CondParser_LeafToken handles [0-9-+] specially, treating them as a number.
 PLUS=		+
 ASTERISK=	*
 EMPTY=		# empty
 # "true" since "+" is not the empty string.
 # expect+1: <true>
 .info <${${PLUS}		:?true:false}>
 # "false" since the variable named "*" is not defined.
 # expect+1: <false>
 .info <${${ASTERISK}	:?true:false}>
 # syntax error since the condition is completely blank.
 # expect+1: <>
 .info <${${EMPTY}	:?true:false}>
 # Since the condition of the '?:' modifier is expanded before being parsed and
 # evaluated, it is common practice to enclose expressions in quotes, to avoid
 # producing syntactically invalid conditions such as ' == value'.  This only
 # works if the expanded values neither contain quotes nor backslashes.  For
 # strings containing quotes or backslashes, the '?:' modifier should not be
 # used.
 PRIMES=	2 3 5 7 11
 .if ${1 2 3 4 5:L:@n@$n:${ ("${PRIMES:M$n}" != "") :?prime:not_prime}@} != \
   "1:not_prime 2:prime 3:prime 4:not_prime 5:prime"
 .  error
 .endif
 # When parsing the modifier ':?', there are 3 possible cases:
+#
 #	1. The whole expression is only parsed.
 #	2. The expression is parsed and the 'then' branch is evaluated.
 #	3. The expression is parsed and the 'else' branch is evaluated.
+#
 # In all of these cases, the expression must be parsed in the same way,
 # especially when one of the branches contains unbalanced '{}' braces.
+#
 # At 2020-01-01, the expressions from the 'then' and 'else' branches were
 # parsed differently, depending on whether the branch was taken or not.  When
 # the branch was taken, the parser recognized that in the modifier ':S,}},,',
 # the '}}' were ordinary characters.  When the branch was not taken, the
 # parser only counted balanced '{' and '}', ignoring any escaping or other
 # changes in the interpretation.
+#
 # In var.c 1.285 from 2020-07-20, the parsing of the expressions changed so
 # that in both cases the expression is parsed in the same way, taking the
 # unbalanced braces in the ':S' modifiers into account.  This change was not
 # on purpose, the commit message mentioned 'has the same effect', which was a
 # wrong assumption.
+#
 # In var.c 1.323 from 2020-07-26, the unintended fix from var.c 1.285 was
 # reverted, still not knowing about the difference between regular parsing and
 # balanced-mode parsing.
+#
 # In var.c 1.1028 from 2022-08-08, there was another attempt at fixing this
 # inconsistency in parsing, but since that broke parsing of the modifier ':@',
 # it was reverted in var.c 1.1029 from 2022-08-23.
+#
 # In var.c 1.1047 from 2023-02-18, the inconsistency in parsing was finally
 # fixed.  The modifier ':@' now parses the body in balanced mode, while
 # everywhere else the modifier parts have their subexpressions parsed in the
 # same way, no matter whether they are evaluated or not.
+#
 # The modifiers ':@' and ':?' are similar in that they conceptually contain
 # text to be evaluated later or conditionally, still they parse that text
 # differently.  The crucial difference is that the body of the modifier ':@'
 # is always parsed using balanced mode.  The modifier ':?', on the other hand,
 # must parse both of its branches in the same way, no matter whether they are
 # evaluated or not.  Since balanced mode and standard mode are incompatible,
 # it's impossible to use balanced mode in the modifier ':?'.
 .MAKEFLAGS: -dc
 .if 0 && ${1:?${:Uthen0:S,}},,}:${:Uelse0:S,}},,}} != "not evaluated"
 # At 2020-01-07, the expression evaluated to 'then0,,}}', even though it was
 # irrelevant as the '0' had already been evaluated to 'false'.
 .  error
 .endif
 .if 1 && ${0:?${:Uthen1:S,}},,}:${:Uelse1:S,}},,}} != "else1"
 .  error
 .endif
 .if 2 && ${1:?${:Uthen2:S,}},,}:${:Uelse2:S,}},,}} != "then2"
 # At 2020-01-07, the whole expression evaluated to 'then2,,}}' instead of the
 # expected 'then2'.  The 'then' branch of the ':?' modifier was parsed
 # normally, parsing and evaluating the ':S' modifier, thereby treating the
 # '}}' as ordinary characters and resulting in 'then2'.  The 'else' branch was
 # parsed in balanced mode, ignoring that the inner '}}' were ordinary
 # characters.  The '}}' were thus interpreted as the end of the 'else' branch
 # and the whole expression.  This left the trailing ',,}}', which together
 # with the 'then2' formed the result 'then2,,}}'.
 .  error
 .endif
 # Since the condition is taken from the variable name of the expression, not
 # from its value, it is evaluated early.  It is possible though to construct
 # conditions that are evaluated lazily, at exactly the right point.  There is
 # no way to escape a '$' directly in the variable name, but there are
 # alternative ways to bring a '$' into the condition.
+#
 #	In an indirect condition using the ':U' modifier, each '$', ':' and
 #	'}' must be escaped as '\$', '\:' and '\}', respectively, but '{' must
 #	not be escaped.
+#
 #	In an indirect condition using a separate variable, each '$' must be
 #	escaped as '$$'.
+#
 # These two forms allow the variables to contain arbitrary characters, as the
 # condition parser does not see them.
 DELAYED=	two
 # expect+1: no
 .info ${ ${:U \${DELAYED\} == "one"}:?yes:no}
 # expect+1: yes
 .info ${ ${:U \${DELAYED\} == "two"}:?yes:no}
 INDIRECT_COND1=	$${DELAYED} == "one"
 # expect+1: no
 .info ${ ${INDIRECT_COND1}:?yes:no}
 INDIRECT_COND2=	$${DELAYED} == "two"
 # expect+1: yes
 .info ${ ${INDIRECT_COND2}:?yes:no}
 .MAKEFLAGS: -d0
 # In the modifier parts for the 'then' and 'else' branches, subexpressions are
-# parsed in by inspecting the actual modifiers.  In 2008, 2015, 2020, 2022 and
+# parsed by inspecting the actual modifiers.  In 2008, 2015, 2020, 2022 and
 # 2023, the exact parsing algorithm switched a few times, counting balanced
 # braces instead of proper subexpressions, which meant that unbalanced braces
 # were parsed differently, depending on whether the branch was active or not.
 BRACES=	}}}
 NO=	${0:?${BRACES:S,}}},yes,}:${BRACES:S,}}},no,}}
 YES=	${1:?${BRACES:S,}}},yes,}:${BRACES:S,}}},no,}}
 BOTH=	<${YES}> <${NO}>
 .if ${BOTH} != "<yes> <no>"
 .  error
 .endif

 @@ -1,14 +1,14 @@
-make: "varmod-match.mk" line 289: while evaluating variable "WORDS": warning: Unfinished character list in pattern 'a[' of modifier ':M'
+make: "varmod-match.mk" line 290: while evaluating variable "WORDS": warning: Unfinished character list in pattern 'a[' of modifier ':M'
-make: "varmod-match.mk" line 297: while evaluating variable "WORDS": warning: Unfinished character list in pattern 'a[^' of modifier ':M'
+make: "varmod-match.mk" line 298: while evaluating variable "WORDS": warning: Unfinished character list in pattern 'a[^' of modifier ':M'
-make: "varmod-match.mk" line 305: while evaluating variable "WORDS": warning: Unfinished character list in pattern '[-x1-3' of modifier ':M'
+make: "varmod-match.mk" line 306: while evaluating variable "WORDS": warning: Unfinished character list in pattern '[-x1-3' of modifier ':M'
-make: "varmod-match.mk" line 313: while evaluating variable "WORDS": warning: Unfinished character list in pattern '*[-x1-3' of modifier ':M'
+make: "varmod-match.mk" line 314: while evaluating variable "WORDS": warning: Unfinished character list in pattern '*[-x1-3' of modifier ':M'
-make: "varmod-match.mk" line 322: while evaluating variable "WORDS": warning: Unfinished character list in pattern '[^-x1-3' of modifier ':M'
+make: "varmod-match.mk" line 323: while evaluating variable "WORDS": warning: Unfinished character list in pattern '[^-x1-3' of modifier ':M'
-make: "varmod-match.mk" line 336: while evaluating variable "WORDS": warning: Unfinished character list in pattern '?[\' of modifier ':M'
+make: "varmod-match.mk" line 337: while evaluating variable "WORDS": warning: Unfinished character list in pattern '?[\' of modifier ':M'
-make: "varmod-match.mk" line 344: while evaluating variable "WORDS": warning: Unfinished character range in pattern '[x-' of modifier ':M'
+make: "varmod-match.mk" line 345: while evaluating variable "WORDS": warning: Unfinished character range in pattern '[x-' of modifier ':M'
-make: "varmod-match.mk" line 356: while evaluating variable "WORDS": warning: Unfinished character range in pattern '[^x-' of modifier ':M'
+make: "varmod-match.mk" line 357: while evaluating variable "WORDS": warning: Unfinished character range in pattern '[^x-' of modifier ':M'
-make: "varmod-match.mk" line 364: while evaluating variable " : :: ": warning: Unfinished character list in pattern '[' of modifier ':M'
+make: "varmod-match.mk" line 365: while evaluating variable " : :: ": warning: Unfinished character list in pattern '[' of modifier ':M'
-make: "varmod-match.mk" line 364: while evaluating variable " : :: ": Unknown modifier "]"
+make: "varmod-match.mk" line 365: while evaluating variable " : :: ": Unknown modifier "]"
-make: "varmod-match.mk" line 364: Malformed conditional (${ ${:U\:} ${:U\:\:} :L:M[:]} != ":")
+make: "varmod-match.mk" line 365: Malformed conditional (${ ${:U\:} ${:U\:\:} :L:M[:]} != ":")
 make: Fatal errors encountered -- cannot continue
 make: stopped in unit-tests
 exit status 1

 @@ -1,380 +1,388 @@
-# $NetBSD: varmod-match.mk,v 1.21 2024/04/20 10:18:55 rillig Exp $
+# $NetBSD: varmod-match.mk,v 1.22 2024/04/23 22:51:28 rillig Exp $
+#
 # Tests for the ':M' modifier, which keeps only those words that match the
 # given pattern.
+#
 # Table of contents
+#
 # 1. Pattern characters '*', '?' and '\'
 # 2. Character lists and character ranges
 # 3. Parsing and escaping
 # 4. Interaction with other modifiers
 # 5. Performance
 # 6. Error handling
 # 7. Historical bugs
+#
 # See ApplyModifier_Match, ParseModifier_Match, ModifyWord_Match and
 # Str_Match.
 # 1. Pattern characters '*', '?' and '\'
+#
 #	*	matches 0 or more characters
 #	?	matches 1 character
 #	\x	matches the character 'x'
 # The pattern is anchored both at the beginning and at the end of the word.
 # Since the pattern 'e' does not contain any pattern matching characters, it
 # matches exactly the word 'e', twice.
 .if ${a c e aa cc ee e f g:L:Me} != "e e"
 .  error
 .endif
 # The pattern character '?' matches exactly 1 character, the pattern character
 # '*' matches 0 or more characters.  The whole pattern matches all words that
 # start with 's' and have 3 or more characters.
-.if ${One Two Three Four five six seven:L:Ms??*} != "six seven"
+.if ${One Two Three Four five six seven so s:L:Ms??*} != "six seven"
 .  error
 .endif
-# Ensure that a pattern without placeholders only matches itself.
+# A pattern without placeholders only matches itself.
 .if ${a aa aaa b ba baa bab:L:Ma} != "a"
 .  error
 .endif
-# Ensure that a pattern that ends with '*' is properly anchored at the
+# A pattern that ends with '*' is anchored at the
 # beginning.
 .if ${a aa aaa b ba baa bab:L:Ma*} != "a aa aaa"
 .  error
 .endif
-# Ensure that a pattern that starts with '*' is properly anchored at the end.
+# A pattern that starts with '*' is anchored at the end.
 .if ${a aa aaa b ba baa bab:L:M*a} != "a aa aaa ba baa"
 .  error
 .endif
 # Test the fast code path for '*' followed by a regular character.
 .if ${:U file.c file.*c file.h file\.c :M*.c} != "file.c file\\.c"
 .  error
 .endif
 # Ensure that the fast code path correctly handles the backslash.
 .if ${:U file.c file.*c file.h file\.c :M*\.c} != "file.c file\\.c"
 .  error
 .endif
 # Ensure that the fast code path correctly handles '\*'.
 .if ${:U file.c file.*c file.h file\.c :M*\*c} != "file.*c"
 .  error
 .endif
 # Ensure that the partial match '.c' doesn't confuse the fast code path.
 .if ${:U file.c.cc file.cc.cc file.cc.c :M*.cc} != "file.c.cc file.cc.cc"
 .  error
 .endif
 # Ensure that the substring '.cc' doesn't confuse the fast code path for '.c'.
 .if ${:U file.c.cc file.cc.cc file.cc.c :M*.c} != "file.cc.c"
 .  error
 .endif
 # 2. Character lists and character ranges
+#
 #	[...]	matches 1 character from the listed characters
 #	[^...]	matches 1 character from the unlisted characters
 #	[a-z]	matches 1 character from the range 'a' to 'z'
 #	[z-a]	matches 1 character from the range 'a' to 'z'
 # Only keep words that start with an uppercase letter.
 .if ${One Two Three Four five six seven:L:M[A-Z]*} != "One Two Three Four"
 .  error
 .endif
 # Only keep words that start with a character other than an uppercase letter.
 .if ${One Two Three Four five six seven:L:M[^A-Z]*} != "five six seven"
 .  error
 .endif
 #	[]	matches never
 .if ${ ab a[]b a[b a b :L:M[]} != ""
 .  error
 .endif
 #	a[]b	matches never
 .if ${ ab a[]b a[b a b [ ] :L:Ma[]b} != ""
 .  error
 .endif
 #	[^]	matches exactly 1 arbitrary character
 .if ${ ab a[]b a[b a b [ ] :L:M[^]} != "a b [ ]"
 .  error
 .endif
 #	a[^]b	matches 'a', then exactly 1 arbitrary character, then 'b'
 .if ${ ab a[]b a[b a b :L:Ma[^]b} != "a[b"
 .  error
 .endif
 #	[Nn0]	matches exactly 1 character from the set 'N', 'n', '0'
 .if ${ a b N n 0 Nn0 [ ] :L:M[Nn0]} != "N n 0"
 .  error
 .endif
 #	[a-c]	matches exactly 1 character from the range 'a' to 'c'
 .if ${ A B C a b c d [a-c] [a] :L:M[a-c]} != "a b c"
 .  error
 .endif
 #	[c-a]	matches the same as [a-c]
 .if ${ A B C a b c d [a-c] [a] :L:M[c-a]} != "a b c"
 .  error
 .endif
 #	[^a-c67]
 #		matches a single character, except for 'a', 'b', 'c', '6' or
 #		'7'
 .if ${ A B C a b c d 5 6 7 8 [a-c] [a] :L:M[^a-c67]} != "A B C d 5 8"
 .  error
 .endif
 #	[\]	matches a single backslash; no escaping takes place in
 #		character ranges
 # Without the 'b' in the below words, the backslash would end a word and thus
 # influence how the string is split into words.
 WORDS=		a\b a[\]b ab a\\b
 .if ${WORDS:Ma[\]b} != "a\\b"
 .  error
 .endif
 #	[[-]]	May look like it would match a single '[', '\' or ']', but
 #		the inner ']' has two roles: it is the upper bound of the
 #		character range as well as the closing character of the
 #		character list.  The outer ']' is just a regular character.
 WORDS=		[ ] [] \] ]]
 .if ${WORDS:M[[-]]} != "[] \\] ]]"
 .  error
 .endif
 #	[b[-]a]
 #		Same as for '[[-]]': the character list stops at the first
 #		']', and the 'a]' is treated as a literal string.
 WORDS=		[a \a ]a []a \]a ]]a [a] \a] ]a] ba]
 .if ${WORDS:M[b[-]a]} != "[a] \\a] ]a] ba]"
 .  error
 .endif
 #	[-]	Matches a single '-' since the '-' only becomes part of a
 #		character range if it is preceded and followed by another
 #		character.
 WORDS=		- -]
 .if ${WORDS:M[-]} != "-"
 .  error
 .endif
 # Only keep words that don't start with s and at the same time end with
 # either of [ex].
+#
 # This test case ensures that the negation from the first character list
 # '[^s]' does not propagate to the second character list '[ex]'.
 .if ${One Two Three Four five six seven:L:M[^s]*[ex]} != "One Three five"
 .  error
 .endif
 # 3. Parsing and escaping
+#
 #	*	matches 0 or more characters
 #	?	matches 1 character
 #	\	outside a character list, escapes the following character
 #	[	starts a character list for matching 1 character
 #	]	ends a character list for matching 1 character
 #	-	in a character list, forms a character range
 #	^	at the beginning of a character list, negates the list
 #	(	while parsing the pattern, starts a nesting level
 #	)	while parsing the pattern, ends a nesting level
 #	{	while parsing the pattern, starts a nesting level
 #	}	while parsing the pattern, ends a nesting level
 #	:	while parsing the pattern, terminates the pattern
 #	$	while parsing the pattern, starts a nested expression
 #	#	in a line except a shell command, starts a comment
 # The pattern can come from an expression.  For single-letter
 # variables, either the short form or the long form can be used, just as
 # everywhere else.
 PRIMES=	2 3 5 7 11
 n=	2
 .if ${PRIMES:M$n} != "2"
 .  error
 .endif
 .if ${PRIMES:M${n}} != "2"
 .  error
 .endif
 .if ${PRIMES:M${:U2}} != "2"
 .  error
 .endif
 #	:	terminates the pattern
 .if ${ A * :L:M:} != ""
 .  error
 .endif
 #	\:	matches a colon
 .if ${ ${:U\: \:\:} :L:M\:} != ":"
 .  error
 .endif
 #	${:U\:}	matches a colon
 .if ${ ${:U\:} ${:U\:\:} :L:M${:U\:}} != ":"
 .  error
 .endif
 # To match a dollar sign in a word, double it.
+#
 # This is different from the :S and :C modifiers, where a '$' has to be
 # escaped as '\$'.
 .if ${:Ua \$ sign:M*$$*} != "\$"
 .  error
 .endif
 # In the :M modifier, '\$' does not escape a dollar.  Instead it is
 # interpreted as a backslash followed by whatever expression the
 # '$' starts.
+#
 # This differs from the :S, :C and several other modifiers.
 ${:U*}=		asterisk
 .if ${:Ua \$ sign any-asterisk:M*\$*} != "any-asterisk"
 .  error
 .endif
 # TODO: ${VAR:M(((}}}}
 # TODO: ${VAR:M{{{)))}
 # TODO: ${VAR:M${UNBALANCED}}
 # TODO: ${VAR:M${:U(((\}\}\}}}
 # 4. Interaction with other modifiers
 # The modifier ':tW' prevents splitting at whitespace.  Even leading and
 # trailing whitespace is preserved.
 .if ${   plain   string   :L:tW:M*} != "   plain   string   "
 .  error
 .endif
-# Without the modifier ':tW', the string is split into words.  All whitespace
+# Without the modifier ':tW', the string is split into words.  Whitespace
-# around and between the words is normalized to a single space.
+# around the words is discarded, and whitespace between the words is
 # normalized to a single space.
 .if ${   plain    string   :L:M*} != "plain string"
 .  error
 .endif
 # 5. Performance
 # Before 2020-06-13, this expression called Str_Match 601,080,390 times.
 # Since 2020-06-13, this expression calls Str_Match 1 time.
 .if ${:U****************:M****************b}
 .endif
 # Before 2023-06-22, this expression called Str_Match 2,621,112 times.
 # Adding another '*?' to the pattern called Str_Match 20,630,572 times.
 # Adding another '*?' to the pattern called Str_Match 136,405,672 times.
 # Adding another '*?' to the pattern called Str_Match 773,168,722 times.
 # Adding another '*?' to the pattern called Str_Match 3,815,481,072 times.
 # Since 2023-06-22, Str_Match no longer backtracks.
 .if ${:U..................................................b:M*?*?*?*?*?a}
 .endif
 # 6. Error handling
 #	[	Incomplete empty character list, never matches.
 WORDS=		a a[
 # expect+1: while evaluating variable "WORDS": warning: Unfinished character list in pattern 'a[' of modifier ':M'
 .if ${WORDS:Ma[} != ""
 .  error
 .endif
 #	[^	Incomplete negated empty character list, matches any single
 #		character.
 WORDS=		a a[ aX
 # expect+1: while evaluating variable "WORDS": warning: Unfinished character list in pattern 'a[^' of modifier ':M'
 .if ${WORDS:Ma[^} != "a[ aX"
 .  error
 .endif
 #	[-x1-3	Incomplete character list, matches those elements that can be
 #		parsed without lookahead.
 WORDS=		- + x xx 0 1 2 3 4 [x1-3
 # expect+1: while evaluating variable "WORDS": warning: Unfinished character list in pattern '[-x1-3' of modifier ':M'
 .if ${WORDS:M[-x1-3} != "- x 1 2 3"
 .  error
 .endif
 #	*[-x1-3	Incomplete character list after a wildcard, matches those
 #		words that end with one of the characters from the list.
 WORDS=		- + x xx 0 1 2 3 4 00 01 10 11 000 001 010 011 100 101 110 111 [x1-3
 # expect+1: while evaluating variable "WORDS": warning: Unfinished character list in pattern '*[-x1-3' of modifier ':M'
 .if ${WORDS:M*[-x1-3} != "- x xx 1 2 3 01 11 001 011 101 111 [x1-3"
 .  warning ${WORDS:M*[-x1-3}
 .endif
 #	[^-x1-3
 #		Incomplete negated character list, matches any character
 #		except those elements that can be parsed without lookahead.
 WORDS=		- + x xx 0 1 2 3 4 [x1-3
 # expect+1: while evaluating variable "WORDS": warning: Unfinished character list in pattern '[^-x1-3' of modifier ':M'
 .if ${WORDS:M[^-x1-3} != "+ 0 4"
 .  error
 .endif
 #	[\	Incomplete character list containing a single '\'.
+#
 #		A word can only end with a backslash if the preceding
 #		character is a backslash as well; in all other cases the final
 #		backslash would escape the following space, making the space
 #		part of the word.  Only the very last word of a string can be
 #		'\', as there is no following space that could be escaped.
 WORDS=		\\ \a ${:Ux\\}
 PATTERN=	${:U?[\\}
 # expect+1: while evaluating variable "WORDS": warning: Unfinished character list in pattern '?[\' of modifier ':M'
 .if ${WORDS:M${PATTERN}} != "\\\\ x\\"
 .  error
 .endif
 #	[x-	Incomplete character list containing an incomplete character
 #		range, matches only the 'x'.
 WORDS=		[x- x x- y
 # expect+1: while evaluating variable "WORDS": warning: Unfinished character range in pattern '[x-' of modifier ':M'
 .if ${WORDS:M[x-} != "x"
 .  error
 .endif
 #	[^x-	Incomplete negated character list containing an incomplete
 #		character range; matches each word that does not have an 'x'
 #		at the position of the character list.
+#
 #		XXX: Even matches strings that are longer than a single
 #		character.
 WORDS=		[x- x x- y yyyyy
 # expect+1: while evaluating variable "WORDS": warning: Unfinished character range in pattern '[^x-' of modifier ':M'
 .if ${WORDS:M[^x-} != "[x- y yyyyy"
 .  error
 .endif
 #	[:]	matches never since the ':' starts the next modifier
 # expect+3: while evaluating variable " : :: ": warning: Unfinished character list in pattern '[' of modifier ':M'
 # expect+2: while evaluating variable " : :: ": Unknown modifier "]"
 # expect+1: Malformed conditional (${ ${:U\:} ${:U\:\:} :L:M[:]} != ":")
 .if ${ ${:U\:} ${:U\:\:} :L:M[:]} != ":"
 .  error
 .else
 .  error
 .endif
 # 7. Historical bugs
 # Before var.c 1.1031 from 2022-08-24, the following expressions caused an
 # out-of-bounds read beyond the indirect ':M' modifiers.
 .if ${:U:${:UM\\}}		# The ':M' pattern need not be unescaped, the
-.  error			# resulting pattern is '\', it never matches
+# The argument to the inner ':U' is unescaped to 'M\'.
-.endif				# anything.
+# This 'M\' becomes an # indirect modifier ':M' with the pattern '\'.
-.if ${:U:${:UM\\\:\\}}		# The ':M' pattern must be unescaped, the
+# The pattern '\' never matches.
-.  error			# resulting pattern is ':\', it never matches
+.if ${:U:${:UM\\}}
-.endif				# anything.
+.  error
 .endif
 # The argument to the inner ':U' is unescaped to 'M\:\'.
 # This 'M\:\' becomes an indirect modifier ':M' with the pattern ':\'.
 # The pattern ':\' never matches.
 .if ${:U:${:UM\\\:\\}}
 .  error
 .endif