 @@ -1,1175 +1,1175 @@
-/*	$NetBSD: cond.c,v 1.345 2023/06/01 07:44:10 rillig Exp $	*/
+/*	$NetBSD: cond.c,v 1.346 2023/06/16 07:12:46 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.345 2023/06/01 07:44:10 rillig Exp $");
+MAKE_RCSID("$NetBSD: cond.c,v 1.346 2023/06/16 07:12:46 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 a variable expression or a plain word.
+	 *
 	 * In conditional directives like '.if', the left-hand side must
 	 * either be a variable 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. The first available error message is usually the most
 	 * specific one, therefore it makes sense to suppress the standard
 	 * "Malformed conditional" message.
 	 */
 	bool printedError;
 } CondParser;
-static CondResult CondParser_Or(CondParser *par, bool);
+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 paren_depth;
 	Buf_InitSize(&word, 16);
 	paren_depth = 0;
 	for (;;) {
 		char ch = *p;
 		if (ch == '\0' || ch == ' ' || ch == '\t')
 			break;
 		if ((ch == '&' || ch == '|') && paren_depth == 0)
 			break;
 		if (ch == '$') {
 			/*
 			 * Parse the variable expression and install it as
 			 * part of the argument if it's valid. We tell
 			 * Var_Parse to complain on an undefined variable,
 			 * (XXX: but Var_Parse ignores that request)
 			 * so we don't need to do it. Nor do we return an
 			 * error, though perhaps we should.
 			 */
 			VarEvalMode emode = doEval
 			    ? VARE_UNDEFERR
 			    : VARE_PARSE_ONLY;
 			FStr nestedVal = Var_Parse(&p, SCOPE_CMDLINE, emode);
 			/* TODO: handle errors */
 			Buf_AddStr(&word, nestedVal.str);
 			FStr_Done(&nestedVal);
 			continue;
+		}
 		if (ch == '(')
 			paren_depth++;
 		else if (ch == ')' && --paren_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 opening '(' - verified by caller */
 	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;
 	for (ln = opts.create.first; ln != NULL; ln = ln->next)
 		if (Str_Match(ln->datum, targetPattern))
 			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 a variable
  * 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;
 	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 the '$' started the string literal (which means no quotes), and
 	 * the expression is followed by a space, a comparison operator or
 	 * the end of the expression, we are done.
 	 */
 	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 a variable expression or an optionally quoted string,
  * on the left-hand and right-hand sides of comparisons.
+ *
  * Results:
  *	Returns the string without any enclosing quotes, or NULL on error.
  *	Sets out_quoted if the leaf was a quoted string literal.
  */
 static void
 CondParser_Leaf(CondParser *par, bool doEval, bool unquotedOK,
 		  FStr *out_str, 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)) {
 				/*
 				 * The left-hand side must be quoted,
 				 * a variable expression or a number.
 				 */
 				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;
+}
 /*
  * 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;
 	/* For .ifxxx "...", check for non-empty string. */
 	if (quoted)
 		return value[0] != '\0';
 	/* For .ifxxx <number>, compare against zero */
 	if (TryParseNumber(value, &num))
 		return num != 0.0;
 	/*
 	 * For .if ${...}, check for non-empty string.  This is different
 	 * from the evaluation function from that .if variant, which would
 	 * test whether a variable of the given name were defined.
 	 */
 	/*
 	 * XXX: Whitespace should count as empty, just as in
 	 * CondParser_FuncCallEmpty.
 	 */
 	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);
 	if (lhs.str == NULL)
 		goto done_lhs;
 	CondParser_SkipWhitespace(par);
 	if (!CondParser_ComparisonOp(par, &op)) {
 		/* Unknown operator, compare against an empty string or 0. */
 		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);
 	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 *cp = par->p;
 	Token tok;
 	FStr val;
 	if (!skip_string(&cp, "empty"))
 		return false;
 	cpp_skip_whitespace(&cp);
 	if (*cp != '(')
 		return false;
 	cp--;			/* Make cp[1] point to the '('. */
 	val = Var_Parse(&cp, 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 = cp;
 	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, a variable 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 *cp;
 	/* Push anything numeric through the compare expression */
 	cp = par->p;
 	if (ch_isdigit(cp[0]) || cp[0] == '-' || cp[0] == '+')
 		return CondParser_Comparison(par, doEval);
 	/*
 	 * Most likely we have a naked token 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, a variable expression may be evaluated twice,
 	 *  see cond-token-plain.mk, keyword 'twice'.
 	 */
 	arg = ParseWord(&cp, doEval);
 	assert(arg[0] != '\0');
 	if (*cp == '=' || *cp == '!' || *cp == '<' || *cp == '>')
 		return CondParser_Comparison(par, doEval);
 	par->p = cp;
 	/*
 	 * 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 a variable expansion.
 	 */
 	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;
 	t = CondParser_Token(par, doEval);
 	if (t == TOK_TRUE)
 		return CR_TRUE;
 	if (t == TOK_FALSE)
 		return 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 res;
+	}
 	if (t == TOK_NOT) {
 		res = CondParser_Term(par, doEval);
 		if (res == CR_TRUE)
 			res = CR_FALSE;
 		else if (res == CR_FALSE)
 			res = CR_TRUE;
 		return res;
+	}
 	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;
+}
 static CondResult
 CondParser_Eval(CondParser *par)
+{
 	CondResult res;
 	DEBUG1(COND, "CondParser_Eval: %s\n", par->p);
 	res = CondParser_Or(par, true);
 	if (res != CR_ERROR && CondParser_Token(par, false) != TOK_EOF)
 		return CR_ERROR;
 	return res;
+}
 /*
  * Evaluate the condition, including any side effects from the variable
  * 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;
 	rval = CondParser_Eval(&par);
 	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:
 	/*
 	 * TODO: Add error message about unknown directive, since there is no
 	 * other known directive that starts with 'el' or 'if'.
+	 *
 	 * Example: .elifx 123
 	 */
 	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 has already been 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)) {	/* It is an '.endif'. */
 		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--;
 		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') {
 			/*
 			 * Unknown directive.  It might still be a
 			 * transformation rule like '.err.txt',
 			 * therefore no error message here.
 			 */
 			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;
+			}
 			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') {
 		/*
 		 * Unknown directive.  It might still be a transformation rule
 		 * like '.elisp.scm', therefore no error message here.

 @@ -1,1199 +1,1199 @@
-/*	$NetBSD: make.h,v 1.320 2023/06/01 07:44:10 rillig Exp $	*/
+/*	$NetBSD: make.h,v 1.321 2023/06/16 07:12:46 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.
  */
 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;
 } 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;
 /* 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
  * points to an 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 */
 	bool compatMake;
 	/*
 	 * -d: debug control: There is one bit per module.  It is up to the
 	 * module what debug information to print.
 	 */
 	DebugFlags debug;
 	/* -df: debug output is written here - default stderr */
 	FILE *debug_file;
 	/*
 	 * -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 *gn);
+void Arch_UpdateMTime(GNode *);
-void Arch_UpdateMemberMTime(GNode *gn);
+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;
 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_AddIncludeDir(const char *);
 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;
 /* 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(void);
 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 *);
 /* 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;
 int str2Lst_Append(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)
 extern void do_not_define_rcsid(void); /* for lint */
 # define MAKE_RCSID(id) extern 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) extern void do_not_define_rcsid(void)
 #else
 # define MAKE_RCSID(id) static volatile char rcsid[] = id
 #endif
 #endif