Tue Apr 23 22:51:28 2024 UTC (16d)

make: clean up comments, code and tests


(rillig)

diff -r1.362 -r1.363 src/usr.bin/make/cond.c
diff -r1.330 -r1.331 src/usr.bin/make/make.h
diff -r1.720 -r1.721 src/usr.bin/make/parse.c
diff -r1.1104 -r1.1105 src/usr.bin/make/var.c
diff -r1.5 -r1.6 src/usr.bin/make/unit-tests/cmd-errors-jobs.exp
diff -r1.5 -r1.6 src/usr.bin/make/unit-tests/cmd-errors-lint.exp
diff -r1.5 -r1.6 src/usr.bin/make/unit-tests/cmd-errors.mk
diff -r1.3 -r1.4 src/usr.bin/make/unit-tests/cmd-errors-jobs.mk
diff -r1.1 -r1.2 src/usr.bin/make/unit-tests/cmd-errors-lint.mk
diff -r1.8 -r1.9 src/usr.bin/make/unit-tests/cmd-errors.exp
diff -r1.8 -r1.9 src/usr.bin/make/unit-tests/cond-func-defined.exp
diff -r1.4 -r1.5 src/usr.bin/make/unit-tests/cmdline-undefined.mk
diff -r1.4 -r1.5 src/usr.bin/make/unit-tests/cmdline.mk
diff -r1.6 -r1.7 src/usr.bin/make/unit-tests/comment.mk
diff -r1.18 -r1.19 src/usr.bin/make/unit-tests/cond-cmp-string.mk
diff -r1.11 -r1.12 src/usr.bin/make/unit-tests/cond-func-defined.mk
diff -r1.27 -r1.28 src/usr.bin/make/unit-tests/varmod-ifelse.mk
diff -r1.15 -r1.16 src/usr.bin/make/unit-tests/varmod-match.exp
diff -r1.21 -r1.22 src/usr.bin/make/unit-tests/varmod-match.mk

--- src/usr.bin/make/cond.c 2024/02/07 07:21:22	1.362
+++ src/usr.bin/make/cond.c 2024/04/23 22:51:28	1.363

 @@ -1,14 +1,14 @@
-/*	$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.
 @@ -81,27 +81,27 @@
  *			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
 @@ -414,33 +414,32 @@ CondParser_StringExpr(CondParser *par, c
 	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++;
 @@ -482,27 +481,27 @@ CondParser_Leaf(CondParser *par, bool do
 				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';
 @@ -592,47 +591,47 @@ CondParser_ComparisonOp(CondParser *par,
  *	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.

--- src/usr.bin/make/make.h 2024/04/20 10:18:55	1.330
+++ src/usr.bin/make/make.h 2024/04/23 22:51:28	1.331

 @@ -1,14 +1,14 @@
-/*	$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.
 @@ -389,27 +389,27 @@ typedef struct 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;
 @@ -571,28 +571,28 @@ extern bool doing_depend;
 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;
 @@ -668,31 +668,31 @@ void debug_printf(const char *, ...) MAK
 #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.
 	 */

--- src/usr.bin/make/parse.c 2024/04/20 10:18:55	1.720
+++ src/usr.bin/make/parse.c 2024/04/23 22:51:28	1.721

 @@ -1,14 +1,14 @@
-/*	$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.
 @@ -95,27 +95,27 @@
  */
 #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 */
 @@ -1612,56 +1612,56 @@ ParseDependencySources(char *p, GNodeTyp
  * 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);
+}

--- src/usr.bin/make/var.c 2024/04/21 21:59:48	1.1104
+++ src/usr.bin/make/var.c 2024/04/23 22:51:28	1.1105

 @@ -1,14 +1,14 @@
-/*	$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.
 @@ -71,93 +71,88 @@
 /*
  * 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 {
 	/*
 @@ -172,27 +167,27 @@ typedef struct Var {
 	/* 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;
 @@ -475,31 +470,28 @@ VarFindSubstring(Substring name, GNode *
 	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;
 @@ -994,29 +986,30 @@ Var_SetWithFlags(GNode *scope, const cha
 		    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);
 @@ -4706,30 +4699,29 @@ VarSubstPlain(const char **pp, Buffer *r
 	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;

--- src/usr.bin/make/unit-tests/cmd-errors-jobs.exp 2024/04/20 10:18:55	1.5
+++ src/usr.bin/make/unit-tests/cmd-errors-jobs.exp 2024/04/23 22:51:28	1.6

 @@ -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

--- src/usr.bin/make/unit-tests/cmd-errors-lint.exp 2024/04/20 10:18:55	1.5
+++ src/usr.bin/make/unit-tests/cmd-errors-lint.exp 2024/04/23 22:51:28	1.6

 @@ -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

--- src/usr.bin/make/unit-tests/cmd-errors.mk 2022/09/25 12:51:37	1.5
+++ src/usr.bin/make/unit-tests/cmd-errors.mk 2024/04/23 22:51:28	1.6

 @@ -1,27 +1,28 @@
-# $NetBSD: cmd-errors.mk,v 1.5 2022/09/25 12:51:37 rillig Exp $
+# $NetBSD: cmd-errors.mk,v 1.6 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 compat mode.
-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}-eol
 # 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 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}-eol
 end:

--- src/usr.bin/make/unit-tests/cmd-errors-jobs.mk 2024/04/20 10:18:55	1.3
+++ src/usr.bin/make/unit-tests/cmd-errors-jobs.mk 2024/04/23 22:51:28	1.4

 @@ -1,31 +1,32 @@
-# $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

--- src/usr.bin/make/unit-tests/cmd-errors-lint.mk 2020/11/02 20:43:27	1.1
+++ src/usr.bin/make/unit-tests/cmd-errors-lint.mk 2024/04/23 22:51:28	1.2

 @@ -1,30 +1,31 @@
-# $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}

--- src/usr.bin/make/unit-tests/cmd-errors.exp 2024/04/20 10:18:55	1.8
+++ src/usr.bin/make/unit-tests/cmd-errors.exp 2024/04/23 22:51:28	1.9

 @@ -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

--- src/usr.bin/make/unit-tests/cond-func-defined.exp 2023/11/19 21:47:52	1.8
+++ src/usr.bin/make/unit-tests/cond-func-defined.exp 2024/04/23 22:51:28	1.9

 @@ -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

--- src/usr.bin/make/unit-tests/cmdline-undefined.mk 2023/11/19 21:47:52	1.4
+++ src/usr.bin/make/unit-tests/cmdline-undefined.mk 2024/04/23 22:51:28	1.5

 @@ -1,16 +1,16 @@
-# $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

--- src/usr.bin/make/unit-tests/cmdline.mk 2022/06/10 18:58:07	1.4
+++ src/usr.bin/make/unit-tests/cmdline.mk 2024/04/23 22:51:28	1.5

 @@ -1,40 +1,40 @@
-# $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

--- src/usr.bin/make/unit-tests/comment.mk 2023/11/19 21:47:52	1.6
+++ src/usr.bin/make/unit-tests/comment.mk 2024/04/23 22:51:28	1.7

 @@ -1,14 +1,14 @@
-# $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.
 @@ -43,29 +43,29 @@ VAR=	value
 # 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

--- src/usr.bin/make/unit-tests/cond-cmp-string.mk 2023/11/19 21:47:52	1.18
+++ src/usr.bin/make/unit-tests/cond-cmp-string.mk 2024/04/23 22:51:28	1.19

 @@ -1,41 +1,41 @@
-# $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
 @@ -59,53 +59,53 @@
 # 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.
 @@ -135,20 +135,20 @@
 .  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

--- src/usr.bin/make/unit-tests/cond-func-defined.mk 2023/11/19 21:47:52	1.11
+++ src/usr.bin/make/unit-tests/cond-func-defined.mk 2024/04/23 22:51:28	1.12

 @@ -1,14 +1,14 @@
-# $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
 @@ -33,29 +33,26 @@ ${:UA B}=	variable name with spaces
 # 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

--- src/usr.bin/make/unit-tests/varmod-ifelse.mk 2024/04/20 10:18:55	1.27
+++ src/usr.bin/make/unit-tests/varmod-ifelse.mk 2024/04/23 22:51:28	1.28

 @@ -1,14 +1,14 @@
-# $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:
 @@ -284,24 +284,24 @@ DELAYED=	two
 .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

--- src/usr.bin/make/unit-tests/varmod-match.exp 2024/04/20 10:18:55	1.15
+++ src/usr.bin/make/unit-tests/varmod-match.exp 2024/04/23 22:51:28	1.16

 @@ -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

--- src/usr.bin/make/unit-tests/varmod-match.mk 2024/04/20 10:18:55	1.21
+++ src/usr.bin/make/unit-tests/varmod-match.mk 2024/04/23 22:51:28	1.22

 @@ -1,14 +1,14 @@
-# $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
 @@ -23,42 +23,42 @@
 #	?	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 '\*'.
 @@ -247,28 +247,29 @@ ${:U*}=		asterisk
 # 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.
 @@ -362,19 +363,26 @@ WORDS=		[x- x x- y yyyyy
 # 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