 @@ -1,14 +1,14 @@
-/*	$NetBSD: nonints.h,v 1.205 2021/03/15 12:15:03 rillig Exp $	*/
+/*	$NetBSD: nonints.h,v 1.206 2021/03/15 15:39:13 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.
 @@ -331,27 +331,27 @@ typedef struct VarEvalFlags {
 	 *	CFLAGS := -I.. $(CFLAGS)
 	 *	# If .INCLUDES (an undocumented special variable, by the
 	 *	# way) is still undefined, the updated CFLAGS becomes
 	 *	# "-I.. $(.INCLUDES)".
 	 */
 	Boolean keepUndef: 1;
 	/*
 	 * Without this padding, GCC 9.3.0 on NetBSD 9.99.80 generates larger
 	 * code than necessary (1.2 kB), masking out the unused bits from the
 	 * int (since that is the default representation of Boolean in make),
 	 * even for initializers consisting entirely of constants.
 	 */
-	Boolean : 1;
+	Boolean : 0;
 } VarEvalFlags;
 #define VARE_PARSE_ONLY	(VarEvalFlags) { FALSE, FALSE, FALSE, FALSE }
 #define VARE_WANTRES	(VarEvalFlags) { TRUE, FALSE, FALSE, FALSE }
 #define VARE_UNDEFERR	(VarEvalFlags) { TRUE, TRUE, FALSE, FALSE }
 #define VARE_KEEP_DOLLAR_UNDEF (VarEvalFlags) { TRUE, FALSE, TRUE, TRUE }
 typedef enum VarSetFlags {
 	VAR_SET_NONE		= 0,
 	/* do not export */
 	VAR_SET_NO_EXPORT	= 1 << 0,

 @@ -1,14 +1,14 @@
-/*	$NetBSD: var.c,v 1.885 2021/03/15 12:15:03 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.886 2021/03/15 15:39:13 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.
 @@ -130,27 +130,27 @@
 #include <regex.h>
 #endif
 #include <errno.h>
 #include <inttypes.h>
 #include <limits.h>
 #include <time.h>
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #include "metachar.h"
 /*	"@(#)var.c	8.3 (Berkeley) 3/19/94" */
-MAKE_RCSID("$NetBSD: var.c,v 1.885 2021/03/15 12:15:03 rillig Exp $");
+MAKE_RCSID("$NetBSD: var.c,v 1.886 2021/03/15 15:39:13 rillig Exp $");
 typedef enum VarFlags {
 	VFL_NONE	= 0,
 	/*
 	 * The variable's value is currently being used by Var_Parse or
 	 * Var_Subst.  This marker is used to avoid endless recursion.
 	 */
 	VFL_IN_USE	= 1 << 0,
 	/*
 	 * The variable comes from the environment.
 	 * These variables are not registered in any GNode, therefore they
 @@ -257,57 +257,45 @@ typedef struct VarPatternFlags {
 	Boolean anchorStart: 1;
 	/* Match at end of word ('$') */
 	Boolean anchorEnd: 1;
 } VarPatternFlags;
 /* SepBuf builds a string from words interleaved with separators. */
 typedef struct SepBuf {
 	Buffer buf;
 	Boolean needSep;
 	/* Usually ' ', but see the ':ts' modifier. */
 	char sep;
 } SepBuf;
 enum {
 	VarEvalFlags_ToStringSize = sizeof
 	    "VARE_UNDEFERR|VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF"
 };
 MAKE_INLINE char *
 str_append(char *dst, const char *src)
 	size_t len = strlen(src);
 	memcpy(dst, src, len);
 	return dst + len;
 static const char *
-VarEvalFlags_ToString(char *buf, VarEvalFlags eflags)
+VarEvalFlags_ToString(VarEvalFlags eflags)
+{
-	char *p = buf;
+	if (!eflags.wantRes) {
 		assert(!eflags.undefErr);
-	/* TODO: WANTRES should be mentioned before UNDEFERR */
+		assert(!eflags.keepDollar && !eflags.keepUndef);
-	if (eflags.undefErr)
+		return "parse-only";
 		p = str_append(p, "VARE_UNDEFERR|");
-	if (eflags.wantRes)
+	if (eflags.undefErr) {
-		p = str_append(p, "VARE_WANTRES|");
+		assert(!eflags.keepDollar && !eflags.keepUndef);
 		return "eval-defined";
+	}
 	if (eflags.keepDollar && eflags.keepUndef)
 		return "eval-keep-dollar-and-undefined";
 	if (eflags.keepDollar)
-		p = str_append(p, "VARE_KEEP_DOLLAR|");
+		return "eval-keep-dollar";
 	if (eflags.keepUndef)
-		p = str_append(p, "VARE_KEEP_UNDEF|");
+		return "eval-keep-undefined";
-	if (p == buf)
+	return "eval";
 		return "none";
 	p[-1] = '\0';
 	return buf;
+}
 /*
  * This lets us tell if we have replaced the original environ
  * (which we cannot free).
  */
 char **savedEnv = NULL;
 /*
  * Special return value for Var_Parse, indicating a parse error.  It may be
  * caused by an undefined variable, a syntax error in a modifier or
  * something entirely different.
  */
 @@ -3608,53 +3596,51 @@ ApplyModifier_SunShell(const char **pp,
 		if (errfmt != NULL)
 			Error(errfmt, expr->value.str);
 		Expr_SetValueOwn(expr, output);
+	}
 	return AMR_OK;
+}
 #endif
 static void
 LogBeforeApply(const ApplyModifiersState *st, const char *mod)
+{
 	const Expr *expr = st->expr;
 	char eflags_str[VarEvalFlags_ToStringSize];
 	char vflags_str[VarFlags_ToStringSize];
 	Boolean is_single_char = mod[0] != '\0' && IsDelimiter(mod[1], st);
 	/* At this point, only the first character of the modifier can
 	 * be used since the end of the modifier is not yet known. */
 	debug_printf("Applying ${%s:%c%s} to \"%s\" (%s, %s, %s)\n",
 	    expr->var->name.str, mod[0], is_single_char ? "" : "...",
 	    expr->value.str,
-	    VarEvalFlags_ToString(eflags_str, expr->eflags),
+	    VarEvalFlags_ToString(expr->eflags),
 	    VarFlags_ToString(vflags_str, expr->var->flags),
 	    ExprDefined_Name[expr->defined]);
+}
 static void
 LogAfterApply(const ApplyModifiersState *st, const char *p, const char *mod)
+{
 	const Expr *expr = st->expr;
 	const char *value = expr->value.str;
 	char eflags_str[VarEvalFlags_ToStringSize];
 	char vflags_str[VarFlags_ToStringSize];
 	const char *quot = value == var_Error ? "" : "\"";
 	debug_printf("Result of ${%s:%.*s} is %s%s%s (%s, %s, %s)\n",
 	    expr->var->name.str, (int)(p - mod), mod,
 	    quot, value == var_Error ? "error" : value, quot,
-	    VarEvalFlags_ToString(eflags_str, expr->eflags),
+	    VarEvalFlags_ToString(expr->eflags),
 	    VarFlags_ToString(vflags_str, expr->var->flags),
 	    ExprDefined_Name[expr->defined]);
+}
 static ApplyModifierResult
 ApplyModifier(const char **pp, ApplyModifiersState *st)
+{
 	switch (**pp) {
 	case '!':
 		return ApplyModifier_ShellCommand(pp, st);
 	case ':':
 		return ApplyModifier_Assign(pp, st);
 	case '?':
 @@ -4328,44 +4314,43 @@ Var_Parse(const char **pp, GNode *scope,
 	/* TRUE if have modifiers for the variable. */
 	Boolean haveModifier;
 	/* Starting character if variable in parens or braces. */
 	char startc;
 	/* Ending character if variable in parens or braces. */
 	char endc;
 	/*
 	 * TRUE if the variable is local and we're expanding it in a
 	 * non-local scope. This is done to support dynamic sources.
 	 * The result is just the expression, unaltered.
 	 */
 	Boolean dynamic;
 	const char *extramodifiers;
 	char eflags_str[VarEvalFlags_ToStringSize];
 	Var *v;
 	Expr expr = {
 		NULL,
 #if defined(lint)
 		/* NetBSD lint cannot fully parse C99 struct initializers. */
 		{ NULL, NULL },
 #else
 		FStr_InitRefer(NULL),
 #endif
 		eflags,
 		scope,
 		DEF_REGULAR
 	};
-	DEBUG2(VAR, "Var_Parse: %s with %s\n", start,
+	DEBUG2(VAR, "Var_Parse: %s (%s)\n", start,
-	    VarEvalFlags_ToString(eflags_str, eflags));
+	    VarEvalFlags_ToString(eflags));
 	*out_val = FStr_InitRefer(NULL);
 	extramodifiers = NULL;	/* extra modifiers to apply first */
 	dynamic = FALSE;
 	/*
 	 * Appease GCC, which thinks that the variable might not be
 	 * initialized.
 	 */
 	endc = '\0';
 	startc = p[1];
 	if (startc != '(' && startc != '{') {

 @@ -1,56 +1,56 @@
 ParseReadLine (21): 'UT_VAR=		<${REF}>'
 Global:UT_VAR = <${REF}>
 ParseReadLine (28): '.export UT_VAR'
 Global:.MAKE.EXPORTED = UT_VAR
 ParseReadLine (32): ': ${UT_VAR:N*}'
-Var_Parse: ${UT_VAR:N*} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${UT_VAR:N*} (eval-defined)
-Var_Parse: ${REF}> with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${REF}> (eval-defined)
-Applying ${UT_VAR:N...} to "<>" (VARE_UNDEFERR|VARE_WANTRES, VFL_EXPORTED|VFL_REEXPORT, regular)
+Applying ${UT_VAR:N...} to "<>" (eval-defined, VFL_EXPORTED|VFL_REEXPORT, regular)
 Pattern[UT_VAR] for [<>] is [*]
 ModifyWords: split "<>" into 1 words
-Result of ${UT_VAR:N*} is "" (VARE_UNDEFERR|VARE_WANTRES, VFL_EXPORTED|VFL_REEXPORT, regular)
+Result of ${UT_VAR:N*} is "" (eval-defined, VFL_EXPORTED|VFL_REEXPORT, regular)
 ParseDoDependency(: )
 CondParser_Eval: ${:!echo "\$UT_VAR"!} != "<>"
-Var_Parse: ${:!echo "\$UT_VAR"!} != "<>" with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${:!echo "\$UT_VAR"!} != "<>" (eval-defined)
-Applying ${:!...} to "" (VARE_UNDEFERR|VARE_WANTRES, none, undefined)
+Applying ${:!...} to "" (eval-defined, none, undefined)
 Modifier part: "echo "$UT_VAR""
-Var_Parse: ${.MAKE.EXPORTED:O:u} with VARE_WANTRES
+Var_Parse: ${.MAKE.EXPORTED:O:u} (eval)
-Applying ${.MAKE.EXPORTED:O} to "UT_VAR" (VARE_WANTRES, none, regular)
+Applying ${.MAKE.EXPORTED:O} to "UT_VAR" (eval, none, regular)
-Result of ${.MAKE.EXPORTED:O} is "UT_VAR" (VARE_WANTRES, none, regular)
+Result of ${.MAKE.EXPORTED:O} is "UT_VAR" (eval, none, regular)
-Applying ${.MAKE.EXPORTED:u} to "UT_VAR" (VARE_WANTRES, none, regular)
+Applying ${.MAKE.EXPORTED:u} to "UT_VAR" (eval, none, regular)
-Result of ${.MAKE.EXPORTED:u} is "UT_VAR" (VARE_WANTRES, none, regular)
+Result of ${.MAKE.EXPORTED:u} is "UT_VAR" (eval, none, regular)
-Var_Parse: ${UT_VAR} with VARE_WANTRES
+Var_Parse: ${UT_VAR} (eval)
-Var_Parse: ${REF}> with VARE_WANTRES
+Var_Parse: ${REF}> (eval)
-Result of ${:!echo "\$UT_VAR"!} is "<>" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:!echo "\$UT_VAR"!} is "<>" (eval-defined, none, defined)
 lhs = "<>", rhs = "<>", op = !=
 ParseReadLine (49): ': ${UT_VAR:N*}'
-Var_Parse: ${UT_VAR:N*} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${UT_VAR:N*} (eval-defined)
-Var_Parse: ${REF}> with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${REF}> (eval-defined)
-Applying ${UT_VAR:N...} to "<>" (VARE_UNDEFERR|VARE_WANTRES, VFL_EXPORTED|VFL_REEXPORT, regular)
+Applying ${UT_VAR:N...} to "<>" (eval-defined, VFL_EXPORTED|VFL_REEXPORT, regular)
 Pattern[UT_VAR] for [<>] is [*]
 ModifyWords: split "<>" into 1 words
-Result of ${UT_VAR:N*} is "" (VARE_UNDEFERR|VARE_WANTRES, VFL_EXPORTED|VFL_REEXPORT, regular)
+Result of ${UT_VAR:N*} is "" (eval-defined, VFL_EXPORTED|VFL_REEXPORT, regular)
 ParseDoDependency(: )
 ParseReadLine (53): 'REF=		defined'
 Global:REF = defined
 CondParser_Eval: ${:!echo "\$UT_VAR"!} != "<defined>"
-Var_Parse: ${:!echo "\$UT_VAR"!} != "<defined>" with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${:!echo "\$UT_VAR"!} != "<defined>" (eval-defined)
-Applying ${:!...} to "" (VARE_UNDEFERR|VARE_WANTRES, none, undefined)
+Applying ${:!...} to "" (eval-defined, none, undefined)
 Modifier part: "echo "$UT_VAR""
-Var_Parse: ${.MAKE.EXPORTED:O:u} with VARE_WANTRES
+Var_Parse: ${.MAKE.EXPORTED:O:u} (eval)
-Applying ${.MAKE.EXPORTED:O} to "UT_VAR" (VARE_WANTRES, none, regular)
+Applying ${.MAKE.EXPORTED:O} to "UT_VAR" (eval, none, regular)
-Result of ${.MAKE.EXPORTED:O} is "UT_VAR" (VARE_WANTRES, none, regular)
+Result of ${.MAKE.EXPORTED:O} is "UT_VAR" (eval, none, regular)
-Applying ${.MAKE.EXPORTED:u} to "UT_VAR" (VARE_WANTRES, none, regular)
+Applying ${.MAKE.EXPORTED:u} to "UT_VAR" (eval, none, regular)
-Result of ${.MAKE.EXPORTED:u} is "UT_VAR" (VARE_WANTRES, none, regular)
+Result of ${.MAKE.EXPORTED:u} is "UT_VAR" (eval, none, regular)
-Var_Parse: ${UT_VAR} with VARE_WANTRES
+Var_Parse: ${UT_VAR} (eval)
-Var_Parse: ${REF}> with VARE_WANTRES
+Var_Parse: ${REF}> (eval)
-Result of ${:!echo "\$UT_VAR"!} is "<defined>" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:!echo "\$UT_VAR"!} is "<defined>" (eval-defined, none, defined)
 lhs = "<defined>", rhs = "<defined>", op = !=
 ParseReadLine (61): 'all:'
 ParseDoDependency(all:)
 Global:.ALLTARGETS =  all
 ParseReadLine (62): '.MAKEFLAGS: -d0'
 ParseDoDependency(.MAKEFLAGS: -d0)
 Global:.MAKEFLAGS =  -r -k -d cpv -d
 Global:.MAKEFLAGS =  -r -k -d cpv -d 0
 exit status 0

 @@ -1,23 +1,23 @@
 Global:8_DOLLARS = $$$$$$$$
 Global:VAR =
-Var_Parse: ${8_DOLLARS} with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${8_DOLLARS} (eval-keep-dollar-and-undefined)
 Global:VAR = $$$$$$$$
-Var_Parse: ${VAR:D${8_DOLLARS}} with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${VAR:D${8_DOLLARS}} (eval-keep-dollar-and-undefined)
-Applying ${VAR:D...} to "$$$$$$$$" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, regular)
+Applying ${VAR:D...} to "$$$$$$$$" (eval-keep-dollar-and-undefined, none, regular)
-Var_Parse: ${8_DOLLARS}} with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${8_DOLLARS}} (eval-keep-dollar-and-undefined)
-Result of ${VAR:D${8_DOLLARS}} is "$$$$$$$$" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, regular)
+Result of ${VAR:D${8_DOLLARS}} is "$$$$$$$$" (eval-keep-dollar-and-undefined, none, regular)
 Global:VAR = $$$$$$$$
-Var_Parse: ${VAR:@var@${8_DOLLARS}@} with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${VAR:@var@${8_DOLLARS}@} (eval-keep-dollar-and-undefined)
-Applying ${VAR:@...} to "$$$$$$$$" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, regular)
+Applying ${VAR:@...} to "$$$$$$$$" (eval-keep-dollar-and-undefined, none, regular)
 Modifier part: "var"
 Modifier part: "${8_DOLLARS}"
 ModifyWords: split "$$$$$$$$" into 1 words
 Global:var = $$$$$$$$
-Var_Parse: ${8_DOLLARS} with VARE_WANTRES|VARE_KEEP_UNDEF
+Var_Parse: ${8_DOLLARS} (eval-keep-undefined)
 ModifyWord_Loop: in "$$$$$$$$", replace "var" with "${8_DOLLARS}" to "$$$$"
 Global:delete var
-Result of ${VAR:@var@${8_DOLLARS}@} is "$$$$" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, regular)
+Result of ${VAR:@var@${8_DOLLARS}@} is "$$$$" (eval-keep-dollar-and-undefined, none, regular)
 Global:VAR = $$$$
 Global:.MAKEFLAGS =  -r -k -d v -d
 Global:.MAKEFLAGS =  -r -k -d v -d 0
 exit status 0

 @@ -1,27 +1,27 @@
 make: "var-eval-short.mk" line 77: Invalid time value: ${FAIL}}
 make: "var-eval-short.mk" line 77: Malformed conditional (0 && ${:Uword:gmtime=${FAIL}})
 make: "var-eval-short.mk" line 91: Invalid time value: ${FAIL}}
 make: "var-eval-short.mk" line 91: Malformed conditional (0 && ${:Uword:localtime=${FAIL}})
 CondParser_Eval: 0 && ${0:?${FAIL}then:${FAIL}else}
-Var_Parse: ${0:?${FAIL}then:${FAIL}else} with none
+Var_Parse: ${0:?${FAIL}then:${FAIL}else} (parse-only)
-Applying ${0:?...} to "" (none, none, undefined)
+Applying ${0:?...} to "" (parse-only, none, undefined)
 Modifier part: "${FAIL}then"
 Modifier part: "${FAIL}else"
-Result of ${0:?${FAIL}then:${FAIL}else} is "" (none, none, defined)
+Result of ${0:?${FAIL}then:${FAIL}else} is "" (parse-only, none, defined)
 ParseReadLine (156): 'DEFINED=	defined'
 Global:DEFINED = defined
 CondParser_Eval: 0 && ${DEFINED:L:?${FAIL}then:${FAIL}else}
-Var_Parse: ${DEFINED:L:?${FAIL}then:${FAIL}else} with none
+Var_Parse: ${DEFINED:L:?${FAIL}then:${FAIL}else} (parse-only)
-Applying ${DEFINED:L} to "defined" (none, none, regular)
+Applying ${DEFINED:L} to "defined" (parse-only, none, regular)
-Result of ${DEFINED:L} is "defined" (none, none, regular)
+Result of ${DEFINED:L} is "defined" (parse-only, none, regular)
-Applying ${DEFINED:?...} to "defined" (none, none, regular)
+Applying ${DEFINED:?...} to "defined" (parse-only, none, regular)
 Modifier part: "${FAIL}then"
 Modifier part: "${FAIL}else"
-Result of ${DEFINED:?${FAIL}then:${FAIL}else} is "defined" (none, none, regular)
+Result of ${DEFINED:?${FAIL}then:${FAIL}else} is "defined" (parse-only, none, regular)
 ParseReadLine (159): '.MAKEFLAGS: -d0'
 ParseDoDependency(.MAKEFLAGS: -d0)
 Global:.MAKEFLAGS =  -r -k -d cpv -d
 Global:.MAKEFLAGS =  -r -k -d cpv -d 0
 make: Fatal errors encountered -- cannot continue
 make: stopped in unit-tests
 exit status 1

 @@ -1,61 +1,61 @@
 Global:SPECIALS = \: : \\ * \*
 CondParser_Eval: ${SPECIALS:M${:U}\:} != ${SPECIALS:M\:${:U}}
-Var_Parse: ${SPECIALS:M${:U}\:} != ${SPECIALS:M\:${:U}} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${SPECIALS:M${:U}\:} != ${SPECIALS:M\:${:U}} (eval-defined)
-Applying ${SPECIALS:M...} to "\: : \\ * \*" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Applying ${SPECIALS:M...} to "\: : \\ * \*" (eval-defined, none, regular)
-Var_Parse: ${:U}\: with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${:U}\: (eval-defined)
-Applying ${:U} to "" (VARE_UNDEFERR|VARE_WANTRES, none, undefined)
+Applying ${:U} to "" (eval-defined, none, undefined)
-Result of ${:U} is "" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:U} is "" (eval-defined, none, defined)
 Pattern[SPECIALS] for [\: : \\ * \*] is [\:]
 ModifyWords: split "\: : \\ * \*" into 5 words
 VarMatch [\:] [\:]
 VarMatch [:] [\:]
 VarMatch [\\] [\:]
 VarMatch [*] [\:]
 VarMatch [\*] [\:]
-Result of ${SPECIALS:M${:U}\:} is ":" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Result of ${SPECIALS:M${:U}\:} is ":" (eval-defined, none, regular)
-Var_Parse: ${SPECIALS:M\:${:U}} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${SPECIALS:M\:${:U}} (eval-defined)
-Applying ${SPECIALS:M...} to "\: : \\ * \*" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Applying ${SPECIALS:M...} to "\: : \\ * \*" (eval-defined, none, regular)
-Var_Parse: ${:U} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${:U} (eval-defined)
-Applying ${:U} to "" (VARE_UNDEFERR|VARE_WANTRES, none, undefined)
+Applying ${:U} to "" (eval-defined, none, undefined)
-Result of ${:U} is "" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:U} is "" (eval-defined, none, defined)
 Pattern[SPECIALS] for [\: : \\ * \*] is [:]
 ModifyWords: split "\: : \\ * \*" into 5 words
 VarMatch [\:] [:]
 VarMatch [:] [:]
 VarMatch [\\] [:]
 VarMatch [*] [:]
 VarMatch [\*] [:]
-Result of ${SPECIALS:M\:${:U}} is ":" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Result of ${SPECIALS:M\:${:U}} is ":" (eval-defined, none, regular)
 lhs = ":", rhs = ":", op = !=
 Global:VALUES = : :: :\:
 CondParser_Eval: ${VALUES:M\:${:U\:}} != ${VALUES:M${:U\:}\:}
-Var_Parse: ${VALUES:M\:${:U\:}} != ${VALUES:M${:U\:}\:} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${VALUES:M\:${:U\:}} != ${VALUES:M${:U\:}\:} (eval-defined)
-Applying ${VALUES:M...} to ": :: :\:" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Applying ${VALUES:M...} to ": :: :\:" (eval-defined, none, regular)
-Var_Parse: ${:U:} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${:U:} (eval-defined)
-Applying ${:U} to "" (VARE_UNDEFERR|VARE_WANTRES, none, undefined)
+Applying ${:U} to "" (eval-defined, none, undefined)
-Result of ${:U} is "" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:U} is "" (eval-defined, none, defined)
 Pattern[VALUES] for [: :: :\:] is [:]
 ModifyWords: split ": :: :\:" into 3 words
 VarMatch [:] [:]
 VarMatch [::] [:]
 VarMatch [:\:] [:]
-Result of ${VALUES:M\:${:U\:}} is ":" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Result of ${VALUES:M\:${:U\:}} is ":" (eval-defined, none, regular)
-Var_Parse: ${VALUES:M${:U\:}\:} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${VALUES:M${:U\:}\:} (eval-defined)
-Applying ${VALUES:M...} to ": :: :\:" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Applying ${VALUES:M...} to ": :: :\:" (eval-defined, none, regular)
-Var_Parse: ${:U\:}\: with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${:U\:}\: (eval-defined)
-Applying ${:U...} to "" (VARE_UNDEFERR|VARE_WANTRES, none, undefined)
+Applying ${:U...} to "" (eval-defined, none, undefined)
-Result of ${:U\:} is ":" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:U\:} is ":" (eval-defined, none, defined)
 Pattern[VALUES] for [: :: :\:] is [:\:]
 ModifyWords: split ": :: :\:" into 3 words
 VarMatch [:] [:\:]
 VarMatch [::] [:\:]
 VarMatch [:\:] [:\:]
-Result of ${VALUES:M${:U\:}\:} is "::" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Result of ${VALUES:M${:U\:}\:} is "::" (eval-defined, none, regular)
 lhs = ":", rhs = "::", op = !=
 make: "varmod-match-escape.mk" line 42: warning: XXX: Oops
 Global:.MAKEFLAGS =  -r -k -d cv -d
 Global:.MAKEFLAGS =  -r -k -d cv -d 0
 make: "varmod-match-escape.mk" line 67: Dollar followed by nothing
 make: Fatal errors encountered -- cannot continue
 make: stopped in unit-tests
 exit status 1

 @@ -1,86 +1,86 @@
 Global:delete FROM_CMDLINE (not found)
 Command:FROM_CMDLINE =
 Global:.MAKEOVERRIDES =  FROM_CMDLINE
 Global:VAR = added
 Global:VAR = overwritten
 Global:delete VAR
 Global:delete VAR (not found)
-Var_Parse: ${:U} with VARE_WANTRES
+Var_Parse: ${:U} (eval)
-Applying ${:U} to "" (VARE_WANTRES, none, undefined)
+Applying ${:U} to "" (eval, none, undefined)
-Result of ${:U} is "" (VARE_WANTRES, none, defined)
+Result of ${:U} is "" (eval, none, defined)
 Var_Set("${:U}", "empty name", ...) name expands to empty string - ignored
-Var_Parse: ${:U} with VARE_WANTRES
+Var_Parse: ${:U} (eval)
-Applying ${:U} to "" (VARE_WANTRES, none, undefined)
+Applying ${:U} to "" (eval, none, undefined)
-Result of ${:U} is "" (VARE_WANTRES, none, defined)
+Result of ${:U} is "" (eval, none, defined)
 Var_Append("${:U}", "empty name", ...) name expands to empty string - ignored
 Global:FROM_CMDLINE = overwritten ignored!
 Global:VAR = 1
 Global:VAR = 1 2
 Global:VAR = 1 2 3
-Var_Parse: ${VAR:M[2]} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${VAR:M[2]} (eval-defined)
-Applying ${VAR:M...} to "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Applying ${VAR:M...} to "1 2 3" (eval-defined, none, regular)
 Pattern[VAR] for [1 2 3] is [[2]]
 ModifyWords: split "1 2 3" into 3 words
 VarMatch [1] [[2]]
 VarMatch [2] [[2]]
 VarMatch [3] [[2]]
-Result of ${VAR:M[2]} is "2" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Result of ${VAR:M[2]} is "2" (eval-defined, none, regular)
-Var_Parse: ${VAR:N[2]} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${VAR:N[2]} (eval-defined)
-Applying ${VAR:N...} to "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Applying ${VAR:N...} to "1 2 3" (eval-defined, none, regular)
 Pattern[VAR] for [1 2 3] is [[2]]
 ModifyWords: split "1 2 3" into 3 words
-Result of ${VAR:N[2]} is "1 3" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Result of ${VAR:N[2]} is "1 3" (eval-defined, none, regular)
-Var_Parse: ${VAR:S,2,two,} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${VAR:S,2,two,} (eval-defined)
-Applying ${VAR:S...} to "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Applying ${VAR:S...} to "1 2 3" (eval-defined, none, regular)
 Modifier part: "2"
 Modifier part: "two"
 ModifyWords: split "1 2 3" into 3 words
-Result of ${VAR:S,2,two,} is "1 two 3" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Result of ${VAR:S,2,two,} is "1 two 3" (eval-defined, none, regular)
-Var_Parse: ${VAR:Q} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${VAR:Q} (eval-defined)
-Applying ${VAR:Q} to "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Applying ${VAR:Q} to "1 2 3" (eval-defined, none, regular)
-Result of ${VAR:Q} is "1\ 2\ 3" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Result of ${VAR:Q} is "1\ 2\ 3" (eval-defined, none, regular)
-Var_Parse: ${VAR:tu:tl:Q} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${VAR:tu:tl:Q} (eval-defined)
-Applying ${VAR:t...} to "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Applying ${VAR:t...} to "1 2 3" (eval-defined, none, regular)
-Result of ${VAR:tu} is "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Result of ${VAR:tu} is "1 2 3" (eval-defined, none, regular)
-Applying ${VAR:t...} to "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Applying ${VAR:t...} to "1 2 3" (eval-defined, none, regular)
-Result of ${VAR:tl} is "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Result of ${VAR:tl} is "1 2 3" (eval-defined, none, regular)
-Applying ${VAR:Q} to "1 2 3" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Applying ${VAR:Q} to "1 2 3" (eval-defined, none, regular)
-Result of ${VAR:Q} is "1\ 2\ 3" (VARE_UNDEFERR|VARE_WANTRES, none, regular)
+Result of ${VAR:Q} is "1\ 2\ 3" (eval-defined, none, regular)
-Var_Parse: ${:Uvalue:${:UM*e}:Mvalu[e]} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${:Uvalue:${:UM*e}:Mvalu[e]} (eval-defined)
-Applying ${:U...} to "" (VARE_UNDEFERR|VARE_WANTRES, none, undefined)
+Applying ${:U...} to "" (eval-defined, none, undefined)
-Result of ${:Uvalue} is "value" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:Uvalue} is "value" (eval-defined, none, defined)
-Var_Parse: ${:UM*e}:Mvalu[e]} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${:UM*e}:Mvalu[e]} (eval-defined)
-Applying ${:U...} to "" (VARE_UNDEFERR|VARE_WANTRES, none, undefined)
+Applying ${:U...} to "" (eval-defined, none, undefined)
-Result of ${:UM*e} is "M*e" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:UM*e} is "M*e" (eval-defined, none, defined)
 Indirect modifier "M*e" from "${:UM*e}"
-Applying ${:M...} to "value" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Applying ${:M...} to "value" (eval-defined, none, defined)
 Pattern[] for [value] is [*e]
 ModifyWords: split "value" into 1 words
 VarMatch [value] [*e]
-Result of ${:M*e} is "value" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:M*e} is "value" (eval-defined, none, defined)
-Applying ${:M...} to "value" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Applying ${:M...} to "value" (eval-defined, none, defined)
 Pattern[] for [value] is [valu[e]]
 ModifyWords: split "value" into 1 words
 VarMatch [value] [valu[e]]
-Result of ${:Mvalu[e]} is "value" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:Mvalu[e]} is "value" (eval-defined, none, defined)
-Var_Parse: ${:UVAR} with VARE_WANTRES
+Var_Parse: ${:UVAR} (eval)
-Applying ${:U...} to "" (VARE_WANTRES, none, undefined)
+Applying ${:U...} to "" (eval, none, undefined)
-Result of ${:UVAR} is "VAR" (VARE_WANTRES, none, defined)
+Result of ${:UVAR} is "VAR" (eval, none, defined)
 Global:delete VAR
-Var_Parse: ${:Uvariable:unknown} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${:Uvariable:unknown} (eval-defined)
-Applying ${:U...} to "" (VARE_UNDEFERR|VARE_WANTRES, none, undefined)
+Applying ${:U...} to "" (eval-defined, none, undefined)
-Result of ${:Uvariable} is "variable" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:Uvariable} is "variable" (eval-defined, none, defined)
-Applying ${:u...} to "variable" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Applying ${:u...} to "variable" (eval-defined, none, defined)
 make: "vardebug.mk" line 44: Unknown modifier "unknown"
-Result of ${:unknown} is error (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:unknown} is error (eval-defined, none, defined)
 make: "vardebug.mk" line 44: Malformed conditional (${:Uvariable:unknown})
-Var_Parse: ${UNDEFINED} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${UNDEFINED} (eval-defined)
 make: "vardebug.mk" line 53: Malformed conditional (${UNDEFINED})
 Global:delete .SHELL (not found)
 Command:.SHELL = </path/to/shell>
 Command:.SHELL = overwritten ignored (read-only)
 Global:.MAKEFLAGS =  -r -k -d v -d
 Global:.MAKEFLAGS =  -r -k -d v -d 0
 make: Fatal errors encountered -- cannot continue
 make: stopped in unit-tests
 exit status 1

 @@ -2,60 +2,60 @@ make: "varmod-indirect.mk" line 19: Unkn
 make: "varmod-indirect.mk" line 52: Unknown modifier "${"
 make: "varmod-indirect.mk" line 55: warning: FIXME: this expression should have resulted in a parse error rather than returning the unparsed portion of the expression.
 make: "varmod-indirect.mk" line 140: before
 make: "varmod-indirect.mk" line 140: after
 make: "varmod-indirect.mk" line 146: before
 make: "varmod-indirect.mk" line 146: after
 make: "varmod-indirect.mk" line 152: before
 make: "varmod-indirect.mk" line 152: after
 make: "varmod-indirect.mk" line 156: Unknown modifier "Z"
 make: "varmod-indirect.mk" line 157: before
 make: "varmod-indirect.mk" line 157: after
 ParseReadLine (166): '_:=	before ${UNDEF} after'
 Global:_ =
-Var_Parse: ${UNDEF} after with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${UNDEF} after (eval-keep-dollar-and-undefined)
 Global:_ = before ${UNDEF} after
 ParseReadLine (169): '_:=	before ${UNDEF:${:US,a,a,}} after'
-Var_Parse: ${UNDEF:${:US,a,a,}} after with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${UNDEF:${:US,a,a,}} after (eval-keep-dollar-and-undefined)
-Var_Parse: ${:US,a,a,}} after with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${:US,a,a,}} after (eval-keep-dollar-and-undefined)
-Applying ${:U...} to "" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, undefined)
+Applying ${:U...} to "" (eval-keep-dollar-and-undefined, none, undefined)
-Result of ${:US,a,a,} is "S,a,a," (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, defined)
+Result of ${:US,a,a,} is "S,a,a," (eval-keep-dollar-and-undefined, none, defined)
 Indirect modifier "S,a,a," from "${:US,a,a,}"
-Applying ${UNDEF:S...} to "" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, undefined)
+Applying ${UNDEF:S...} to "" (eval-keep-dollar-and-undefined, none, undefined)
 Modifier part: "a"
 Modifier part: "a"
 ModifyWords: split "" into 1 words
-Result of ${UNDEF:S,a,a,} is "" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, undefined)
+Result of ${UNDEF:S,a,a,} is "" (eval-keep-dollar-and-undefined, none, undefined)
-Var_Parse: ${:US,a,a,}} after with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${:US,a,a,}} after (eval-keep-dollar-and-undefined)
-Applying ${:U...} to "" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, undefined)
+Applying ${:U...} to "" (eval-keep-dollar-and-undefined, none, undefined)
-Result of ${:US,a,a,} is "S,a,a," (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, defined)
+Result of ${:US,a,a,} is "S,a,a," (eval-keep-dollar-and-undefined, none, defined)
 Global:_ = before ${UNDEF:S,a,a,} after
 ParseReadLine (179): '_:=	before ${UNDEF:${:U}} after'
-Var_Parse: ${UNDEF:${:U}} after with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${UNDEF:${:U}} after (eval-keep-dollar-and-undefined)
-Var_Parse: ${:U}} after with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${:U}} after (eval-keep-dollar-and-undefined)
-Applying ${:U} to "" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, undefined)
+Applying ${:U} to "" (eval-keep-dollar-and-undefined, none, undefined)
-Result of ${:U} is "" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, defined)
+Result of ${:U} is "" (eval-keep-dollar-and-undefined, none, defined)
 Indirect modifier "" from "${:U}"
-Var_Parse: ${:U}} after with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${:U}} after (eval-keep-dollar-and-undefined)
-Applying ${:U} to "" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, undefined)
+Applying ${:U} to "" (eval-keep-dollar-and-undefined, none, undefined)
-Result of ${:U} is "" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, defined)
+Result of ${:U} is "" (eval-keep-dollar-and-undefined, none, defined)
 Global:_ = before ${UNDEF:} after
 ParseReadLine (184): '_:=	before ${UNDEF:${:UZ}} after'
-Var_Parse: ${UNDEF:${:UZ}} after with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${UNDEF:${:UZ}} after (eval-keep-dollar-and-undefined)
-Var_Parse: ${:UZ}} after with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${:UZ}} after (eval-keep-dollar-and-undefined)
-Applying ${:U...} to "" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, undefined)
+Applying ${:U...} to "" (eval-keep-dollar-and-undefined, none, undefined)
-Result of ${:UZ} is "Z" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, defined)
+Result of ${:UZ} is "Z" (eval-keep-dollar-and-undefined, none, defined)
 Indirect modifier "Z" from "${:UZ}"
-Applying ${UNDEF:Z} to "" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, undefined)
+Applying ${UNDEF:Z} to "" (eval-keep-dollar-and-undefined, none, undefined)
 make: "varmod-indirect.mk" line 184: Unknown modifier "Z"
-Result of ${UNDEF:Z} is error (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, undefined)
+Result of ${UNDEF:Z} is error (eval-keep-dollar-and-undefined, none, undefined)
-Var_Parse: ${:UZ}} after with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${:UZ}} after (eval-keep-dollar-and-undefined)
-Applying ${:U...} to "" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, undefined)
+Applying ${:U...} to "" (eval-keep-dollar-and-undefined, none, undefined)
-Result of ${:UZ} is "Z" (VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF, none, defined)
+Result of ${:UZ} is "Z" (eval-keep-dollar-and-undefined, none, defined)
 Global:_ = before ${UNDEF:Z} after
 ParseReadLine (186): '.MAKEFLAGS: -d0'
 ParseDoDependency(.MAKEFLAGS: -d0)
 Global:.MAKEFLAGS =  -r -k -d 0 -d pv -d
 Global:.MAKEFLAGS =  -r -k -d 0 -d pv -d 0
 make: Fatal errors encountered -- cannot continue
 make: stopped in unit-tests
 exit status 1

 @@ -1,24 +1,24 @@
 Global:VAR{{{}}} = 3 braces
-Var_Parse: ${VAR{{{}}}}" != "3 braces" with VARE_WANTRES
+Var_Parse: ${VAR{{{}}}}" != "3 braces" (eval)
 Global:VARNAME = VAR(((
-Var_Parse: ${VARNAME} with VARE_WANTRES
+Var_Parse: ${VARNAME} (eval)
 Global:VAR((( = 3 open parentheses
-Var_Parse: ${VAR(((}}}}" != "3 open parentheses}}}" with VARE_WANTRES
+Var_Parse: ${VAR(((}}}}" != "3 open parentheses}}}" (eval)
-Var_Parse: ${:UVAR(((}=	try1 with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${:UVAR(((}=	try1 (eval-defined)
-Applying ${:U...} to "" (VARE_UNDEFERR|VARE_WANTRES, none, undefined)
+Applying ${:U...} to "" (eval-defined, none, undefined)
-Result of ${:UVAR(((} is "VAR(((" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:UVAR(((} is "VAR(((" (eval-defined, none, defined)
 Global:.ALLTARGETS =  VAR(((=)
 make: "varname.mk" line 30: No closing parenthesis in archive specification
 make: "varname.mk" line 30: Error in archive specification: "VAR"
-Var_Parse: ${:UVAR\(\(\(}=	try2 with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${:UVAR\(\(\(}=	try2 (eval-defined)
-Applying ${:U...} to "" (VARE_UNDEFERR|VARE_WANTRES, none, undefined)
+Applying ${:U...} to "" (eval-defined, none, undefined)
-Result of ${:UVAR\(\(\(} is "VAR\(\(\(" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:UVAR\(\(\(} is "VAR\(\(\(" (eval-defined, none, defined)
 Global:.ALLTARGETS =  VAR(((=) VAR\(\(\(=
 make: "varname.mk" line 35: Invalid line type
-Var_Parse: ${VARNAME} with VARE_WANTRES
+Var_Parse: ${VARNAME} (eval)
 Global:VAR((( = try3
 Global:.MAKEFLAGS =  -r -k -d v -d
 Global:.MAKEFLAGS =  -r -k -d v -d 0
 make: Fatal errors encountered -- cannot continue
 make: stopped in unit-tests
 exit status 1

 @@ -1,32 +1,32 @@
 ParseReadLine (10): 'ORIG_SHELL:=	${.SHELL}'
 Global:ORIG_SHELL =
-Var_Parse: ${.SHELL} with VARE_WANTRES|VARE_KEEP_DOLLAR|VARE_KEEP_UNDEF
+Var_Parse: ${.SHELL} (eval-keep-dollar-and-undefined)
 Global:delete .SHELL (not found)
 Command:.SHELL = (details omitted)
 Global:ORIG_SHELL = (details omitted)
 ParseReadLine (12): '.SHELL=		overwritten'
 Global:.SHELL = overwritten
 CondParser_Eval: ${.SHELL} != ${ORIG_SHELL}
-Var_Parse: ${.SHELL} != ${ORIG_SHELL} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${.SHELL} != ${ORIG_SHELL} (eval-defined)
-Var_Parse: ${ORIG_SHELL} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${ORIG_SHELL} (eval-defined)
 lhs = "(details omitted)", rhs = "(details omitted)", op = !=
 ParseReadLine (19): '.MAKEFLAGS: .SHELL+=appended'
 ParseDoDependency(.MAKEFLAGS: .SHELL+=appended)
 Ignoring append to .SHELL since it is read-only
 CondParser_Eval: ${.SHELL} != ${ORIG_SHELL}
-Var_Parse: ${.SHELL} != ${ORIG_SHELL} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${.SHELL} != ${ORIG_SHELL} (eval-defined)
-Var_Parse: ${ORIG_SHELL} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${ORIG_SHELL} (eval-defined)
 lhs = "(details omitted)", rhs = "(details omitted)", op = !=
 ParseReadLine (27): '.undef .SHELL'
 Global:delete .SHELL
 ParseReadLine (28): '.SHELL=		newly overwritten'
 Global:.SHELL = newly overwritten
 CondParser_Eval: ${.SHELL} != ${ORIG_SHELL}
-Var_Parse: ${.SHELL} != ${ORIG_SHELL} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${.SHELL} != ${ORIG_SHELL} (eval-defined)
-Var_Parse: ${ORIG_SHELL} with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${ORIG_SHELL} (eval-defined)
 lhs = "(details omitted)", rhs = "(details omitted)", op = !=
 ParseReadLine (33): '.MAKEFLAGS: -d0'
 ParseDoDependency(.MAKEFLAGS: -d0)
 Global:.MAKEFLAGS =  -r -k -d cpv -d
 Global:.MAKEFLAGS =  -r -k -d cpv -d 0
 exit status 0

 @@ -1,47 +1,47 @@
-Var_Parse: ${:U} with VARE_WANTRES
+Var_Parse: ${:U} (eval)
-Applying ${:U} to "" (VARE_WANTRES, none, undefined)
+Applying ${:U} to "" (eval, none, undefined)
-Result of ${:U} is "" (VARE_WANTRES, none, defined)
+Result of ${:U} is "" (eval, none, defined)
 Var_Set("${:U}", "cmdline-u", ...) name expands to empty string - ignored
 Var_Set("", "cmdline-plain", ...) name expands to empty string - ignored
 Global:.CURDIR = <curdir>
-Var_Parse: ${MAKE_OBJDIR_CHECK_WRITABLE:U} with VARE_WANTRES
+Var_Parse: ${MAKE_OBJDIR_CHECK_WRITABLE:U} (eval)
-Applying ${MAKE_OBJDIR_CHECK_WRITABLE:U} to "" (VARE_WANTRES, none, undefined)
+Applying ${MAKE_OBJDIR_CHECK_WRITABLE:U} to "" (eval, none, undefined)
-Result of ${MAKE_OBJDIR_CHECK_WRITABLE:U} is "" (VARE_WANTRES, none, defined)
+Result of ${MAKE_OBJDIR_CHECK_WRITABLE:U} is "" (eval, none, defined)
 Global:.OBJDIR = <curdir>
 Global:delete .PATH (not found)
 Global:.PATH = .
 Global:.PATH = . <curdir>
 Global:.TARGETS =
 Internal:MAKEFILE = varname-empty.mk
 Global:.MAKE.MAKEFILES = varname-empty.mk
 Global:.PARSEFILE = varname-empty.mk
 Global:delete .INCLUDEDFROMDIR (not found)
 Global:delete .INCLUDEDFROMFILE (not found)
 Var_Set("", "default", ...) name expands to empty string - ignored
 Var_Set("", "assigned", ...) name expands to empty string - ignored
 SetVar: variable name is empty - ignored
 Var_Set("", "", ...) name expands to empty string - ignored
 Var_Set("", "subst", ...) name expands to empty string - ignored
 Var_Set("", "shell-output", ...) name expands to empty string - ignored
-Var_Parse: ${:Ufallback} != "fallback" with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${:Ufallback} != "fallback" (eval-defined)
-Applying ${:U...} to "" (VARE_UNDEFERR|VARE_WANTRES, none, undefined)
+Applying ${:U...} to "" (eval-defined, none, undefined)
-Result of ${:Ufallback} is "fallback" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:Ufallback} is "fallback" (eval-defined, none, defined)
-Var_Parse: ${:U} with VARE_WANTRES
+Var_Parse: ${:U} (eval)
-Applying ${:U} to "" (VARE_WANTRES, none, undefined)
+Applying ${:U} to "" (eval, none, undefined)
-Result of ${:U} is "" (VARE_WANTRES, none, defined)
+Result of ${:U} is "" (eval, none, defined)
 Var_Set("${:U}", "assigned indirectly", ...) name expands to empty string - ignored
-Var_Parse: ${:Ufallback} != "fallback" with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${:Ufallback} != "fallback" (eval-defined)
-Applying ${:U...} to "" (VARE_UNDEFERR|VARE_WANTRES, none, undefined)
+Applying ${:U...} to "" (eval-defined, none, undefined)
-Result of ${:Ufallback} is "fallback" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:Ufallback} is "fallback" (eval-defined, none, defined)
-Var_Parse: ${:U} with VARE_WANTRES
+Var_Parse: ${:U} (eval)
-Applying ${:U} to "" (VARE_WANTRES, none, undefined)
+Applying ${:U} to "" (eval, none, undefined)
-Result of ${:U} is "" (VARE_WANTRES, none, defined)
+Result of ${:U} is "" (eval, none, defined)
 Var_Append("${:U}", "appended indirectly", ...) name expands to empty string - ignored
-Var_Parse: ${:Ufallback} != "fallback" with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${:Ufallback} != "fallback" (eval-defined)
-Applying ${:U...} to "" (VARE_UNDEFERR|VARE_WANTRES, none, undefined)
+Applying ${:U...} to "" (eval-defined, none, undefined)
-Result of ${:Ufallback} is "fallback" (VARE_UNDEFERR|VARE_WANTRES, none, defined)
+Result of ${:Ufallback} is "fallback" (eval-defined, none, defined)
 Global:.MAKEFLAGS =  -r -d v -d
 Global:.MAKEFLAGS =  -r -d v -d 0
 out: fallback
 out: 1 2 3
 exit status 0

 @@ -1,10 +1,10 @@
 Global:delete DOLLAR (not found)
 Command:DOLLAR = $$$$
 Global:.MAKEOVERRIDES =  VAR DOLLAR
 CondParser_Eval: ${DOLLAR} != "\$\$"
-Var_Parse: ${DOLLAR} != "\$\$" with VARE_UNDEFERR|VARE_WANTRES
+Var_Parse: ${DOLLAR} != "\$\$" (eval-defined)
 lhs = "$$", rhs = "$$", op = !=
 Global:.MAKEFLAGS =  -r -k -D VAR -D VAR -d cv -d
 Global:.MAKEFLAGS =  -r -k -D VAR -D VAR -d cv -d 0
 make: Unterminated quoted string [make VAR=initial UNBALANCED=']
 exit status 0

 @@ -1,18 +1,18 @@
 make: "directive-unexport-env.mk" line 13: Unknown directive "unexport-en"
 make: "directive-unexport-env.mk" line 15: Unknown directive "unexport-environment"
 Global:UT_EXPORTED = value
 Global:UT_UNEXPORTED = value
 Global:.MAKE.EXPORTED = UT_EXPORTED
 make: "directive-unexport-env.mk" line 21: The directive .unexport-env does not take arguments
-Var_Parse: ${.MAKE.EXPORTED:O:u} with VARE_WANTRES
+Var_Parse: ${.MAKE.EXPORTED:O:u} (eval)
-Applying ${.MAKE.EXPORTED:O} to "UT_EXPORTED" (VARE_WANTRES, none, regular)
+Applying ${.MAKE.EXPORTED:O} to "UT_EXPORTED" (eval, none, regular)
-Result of ${.MAKE.EXPORTED:O} is "UT_EXPORTED" (VARE_WANTRES, none, regular)
+Result of ${.MAKE.EXPORTED:O} is "UT_EXPORTED" (eval, none, regular)
-Applying ${.MAKE.EXPORTED:u} to "UT_EXPORTED" (VARE_WANTRES, none, regular)
+Applying ${.MAKE.EXPORTED:u} to "UT_EXPORTED" (eval, none, regular)
-Result of ${.MAKE.EXPORTED:u} is "UT_EXPORTED" (VARE_WANTRES, none, regular)
+Result of ${.MAKE.EXPORTED:u} is "UT_EXPORTED" (eval, none, regular)
 Unexporting "UT_EXPORTED"
 Global:delete .MAKE.EXPORTED
 Global:.MAKEFLAGS =  -r -k -d v -d
 Global:.MAKEFLAGS =  -r -k -d v -d 0
 make: Fatal errors encountered -- cannot continue
 make: stopped in unit-tests
 exit status 1

 @@ -1,7 +1,7 @@
-Var_Parse: ${:U\$\$\$\$\$\$\$\$} with VARE_WANTRES
+Var_Parse: ${:U\$\$\$\$\$\$\$\$} (eval)
-Applying ${:U...} to "" (VARE_WANTRES, none, undefined)
+Applying ${:U...} to "" (eval, none, undefined)
-Result of ${:U\$\$\$\$\$\$\$\$} is "$$$$$$$$" (VARE_WANTRES, none, defined)
+Result of ${:U\$\$\$\$\$\$\$\$} is "$$$$$$$$" (eval, none, defined)
 Global:VAR.$$$$$$$$ = dollars
 Global:.MAKEFLAGS =  -r -k -d v -d
 Global:.MAKEFLAGS =  -r -k -d v -d 0
 exit status 0