 @@ -1,14 +1,14 @@
-/*	$NetBSD: var.c,v 1.792 2021/02/03 08:08:18 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.793 2021/02/03 08:40:47 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.
 @@ -121,27 +121,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.792 2021/02/03 08:08:18 rillig Exp $");
+MAKE_RCSID("$NetBSD: var.c,v 1.793 2021/02/03 08:40:47 rillig Exp $");
 typedef enum VarFlags {
 	VAR_NONE	= 0,
 	/*
 	 * The variable's value is currently being used by Var_Parse or
 	 * Var_Subst.  This marker is used to avoid endless recursion.
 	 */
 	VAR_IN_USE = 0x01,
 	/*
 	 * The variable comes from the environment.
 	 * These variables are not registered in any GNode, therefore they
 @@ -906,26 +906,32 @@ Var_UnExport(Boolean isEnv, const char *
 	FStr varnames;
 	GetVarnamesToUnexport(isEnv, arg, &varnames, &what);
 	UnexportVars(&varnames, what);
 	FStr_Done(&varnames);
+}
 /* Set the variable to the value; the name is not expanded. */
 static void
 SetVar(const char *name, const char *val, GNode *ctxt, VarSetFlags flags)
+{
 	Var *v;
 	assert(val != NULL);
 	if (name[0] == '\0') {
 		DEBUG0(VAR, "SetVar: variable name is empty - ignored\n");
 		return;
+	}
 	if (ctxt == VAR_GLOBAL) {
 		v = VarFind(name, VAR_CMDLINE, FALSE);
 		if (v != NULL) {
 			if (v->flags & VAR_FROM_CMD) {
 				DEBUG3(VAR, "%s:%s = %s ignored!\n",
 				    ctxt->name, name, val);
 				return;
+			}
 			VarFreeEnv(v, TRUE);
+		}
+	}
 	/*
 @@ -1024,32 +1030,27 @@ Var_SetWithFlags(const char *name, const
  *	name		name of the variable to set, is expanded once
  *	val		value to give to the variable
  *	ctxt		context in which to set it
  */
 void
 Var_Set(const char *name, const char *val, GNode *ctxt)
+{
 	Var_SetWithFlags(name, val, ctxt, VAR_SET_NONE);
+}
 void
 Global_Set(const char *name, const char *value)
+{
-	assert(value != NULL);
+	SetVar(name, value, VAR_GLOBAL, VAR_SET_NONE);
 	if (name[0] == '\0')
 		DEBUG0(VAR, "Variable name empty - ignored\n");
 	else
 		SetVar(name, value, VAR_GLOBAL, VAR_SET_NONE);
+}
 void
 Global_SetExpand(const char *name, const char *value)
+{
 	Var_Set(name, value, VAR_GLOBAL);
+}
 /*
  * The variable of the given name has the given value appended to it in the
  * given context.
+ *
  * If the variable doesn't exist, it is created. Otherwise the strings are
 @@ -1083,28 +1084,27 @@ Var_Append(const char *name, const char
 		name = name_freeIt;
 		if (name[0] == '\0') {
 			DEBUG2(VAR, "Var_Append(\"%s\", \"%s\", ...) "
 				    "name expands to empty string - ignored\n",
 			    unexpanded_name, val);
 			free(name_freeIt);
 			return;
+		}
+	}
 	v = VarFind(name, ctxt, ctxt == VAR_GLOBAL);
 	if (v == NULL) {
-		/* XXX: name is expanded for the second time */
+		SetVar(name, val, ctxt, VAR_SET_NONE);
 		Var_Set(name, val, ctxt);
 	} else if (v->flags & VAR_READONLY) {
 		DEBUG1(VAR, "Ignoring append to %s since it is read-only\n",
 		    name);
 	} else if (ctxt == VAR_CMDLINE || !(v->flags & VAR_FROM_CMD)) {
 		Buf_AddByte(&v->val, ' ');
 		Buf_AddStr(&v->val, val);
 		DEBUG3(VAR, "%s:%s = %s\n", ctxt->name, name, v->val.data);
 		if (v->flags & VAR_FROM_ENV) {
 			/*
 			 * If the original variable came from the environment,
 			 * we have to install it in the global context (we

 @@ -1,14 +1,14 @@
-# $NetBSD: var-op-append.mk,v 1.7 2020/10/30 20:36:33 rillig Exp $
+# $NetBSD: var-op-append.mk,v 1.8 2021/02/03 08:40:47 rillig Exp $
+#
 # Tests for the += variable assignment operator, which appends to a variable,
 # creating it if necessary.
 # Appending to an undefined variable is possible.
 # The variable is created, and no extra space is added before the value.
 VAR+=	one
 .if ${VAR} != "one"
 .  error
 .endif
 # Appending to an existing variable adds a single space and the value.
 VAR+=	two
 @@ -22,27 +22,25 @@ VAR+=	# empty
 .  error
 .endif
 # Variable names may contain '+', and this character is also part of the
 # '+=' assignment operator.  As far as possible, the '+' is interpreted as
 # part of the assignment operator.
+#
 # See Parse_DoVar
 C++=	value
 .if ${C+} != "value" || defined(C++)
 .  error
 .endif
-# Try out how often the variable name is expanded when appending to a
+# Before var.c 1.793 from 2021-02-03, the variable name of a newly created
-# nonexistent variable.
+# variable was expanded two times in a row, which was unexpected but
-# As of 2020-10-30, that's two times.
+# irrelevant in practice since variable names containing dollars lead to
-# XXX: That's one time too often.
+# strange side effects in several other places as well.
 # See Var_Append, the call to Var_Set.
 .MAKEFLAGS: -dv
 VAR.${:U\$\$\$\$\$\$\$\$}+=	dollars
 .MAKEFLAGS: -d0
-.if ${VAR.${:U\$\$\$\$}} != "dollars"
+.if ${VAR.${:U\$\$\$\$\$\$\$\$}} != "dollars"
 .  error
 .endif
 all:
 	@:;

 @@ -10,27 +10,27 @@ Result of ${MAKE_OBJDIR_CHECK_WRITABLE:U
 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:.PARSEDIR = <curdir>
 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
-Var_Set("", "appended", ...) 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
 Applying ${:U...} to "" (VARE_UNDEFERR|VARE_WANTRES, none, VES_UNDEF)
 Result of ${:Ufallback} is "fallback" (VARE_UNDEFERR|VARE_WANTRES, none, VES_DEF)
 Var_Parse: ${:U} with VARE_WANTRES
 Applying ${:U} to "" (VARE_WANTRES, none, VES_UNDEF)
 Result of ${:U} is "" (VARE_WANTRES, none, VES_DEF)
 Var_Set("${:U}", "assigned indirectly", ...) name expands to empty string - ignored
 Var_Parse: ${:Ufallback} != "fallback" with VARE_UNDEFERR|VARE_WANTRES
 Applying ${:U...} to "" (VARE_UNDEFERR|VARE_WANTRES, none, VES_UNDEF)
 Result of ${:Ufallback} is "fallback" (VARE_UNDEFERR|VARE_WANTRES, none, VES_DEF)

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