 @@ -1,14 +1,14 @@
-/*	$NetBSD: var.c,v 1.248 2020/07/04 10:19:39 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.249 2020/07/04 10:35:30 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.
 @@ -59,34 +59,34 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: var.c,v 1.248 2020/07/04 10:19:39 rillig Exp $";
+static char rcsid[] = "$NetBSD: var.c,v 1.249 2020/07/04 10:35:30 rillig Exp $";
 #else
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)var.c	8.3 (Berkeley) 3/19/94";
 #else
-__RCSID("$NetBSD: var.c,v 1.248 2020/07/04 10:19:39 rillig Exp $");
+__RCSID("$NetBSD: var.c,v 1.249 2020/07/04 10:35:30 rillig Exp $");
 #endif
 #endif /* not lint */
 #endif
 /*-
  * var.c --
  *	Variable-handling functions
+ *
  * Interface:
  *	Var_Set		    Set the value of a variable in the given
  *			    context. The variable is created if it doesn't
  *			    yet exist. The value and variable name need not
  *			    be preserved.
 @@ -142,34 +142,34 @@ __RCSID("$NetBSD: var.c,v 1.248 2020/07/
 extern int makelevel;
 /*
  * This lets us tell if we have replaced the original environ
  * (which we cannot free).
  */
 char **savedEnv = NULL;
 /*
  * This is a harmless return value for Var_Parse that can be used by Var_Subst
  * to determine if there was an error in parsing -- easier than returning
  * a flag, as things outside this module don't give a hoot.
  */
-char 	var_Error[] = "";
+char var_Error[] = "";
 /*
  * Similar to var_Error, but returned when the 'VARF_UNDEFERR' flag for
  * Var_Parse is not set. Why not just use a constant? Well, gcc likes
  * to condense identical string instances...
  */
-static char	varNoError[] = "";
+static char varNoError[] = "";
 /*
  * Traditionally we consume $$ during := like any other expansion.
  * Other make's do not.
  * This knob allows controlling the behavior.
  * FALSE for old behavior.
  * TRUE for new compatible.
  */
 #define SAVE_DOLLARS ".MAKE.SAVE_DOLLARS"
 static Boolean save_dollars = TRUE;
 /*
  * Internally, variables are contained in four different contexts.
 @@ -289,39 +289,26 @@ typedef struct {
     int		   nsub;
     regmatch_t 	  *matches;
     char 	  *replace;
     int		   flags;
 } VarREPattern;
 #endif
 /* struct passed to VarSelectWords() for ":[start..end]" */
 typedef struct {
     int		start;		/* first word to select */
     int		end;		/* last word to select */
 } VarSelectWords_t;
 static char *VarGetPattern(GNode *, Var_Parse_State *,
 			   VarPattern_Flags, const char **, int,
 			   VarPattern_Flags *, int *, VarPattern *);
 static char *VarQuote(char *, Boolean);
 static char *VarHash(char *);
 static char *VarModify(GNode *, Var_Parse_State *,
     const char *,
     Boolean (*)(GNode *, Var_Parse_State *, char *, Boolean, Buffer *, void *),
     void *);
 static char *VarOrder(const char *, const char);
 static char *VarUniq(const char *);
 static int VarWordCompare(const void *, const void *);
 #define BROPEN	'{'
 #define BRCLOSE	'}'
 #define PROPEN	'('
 #define PRCLOSE	')'
 /*-
  *-----------------------------------------------------------------------
  * VarFind --
  *	Find the given variable in the given context and any other contexts
  *	indicated.
+ *
  * Input:
  *	name		name to find
 @@ -864,27 +851,27 @@ Var_UnExport(char *str)
 	free(as);
 	free(av);
 	if (vlist != str) {
 	    Var_Delete(MAKE_EXPORTED, VAR_GLOBAL);
 	    free(vlist);
+	}
+    }
+}
 static void
 Var_Set_with_flags(const char *name, const char *val, GNode *ctxt,
 		   VarSet_Flags flags)
+{
-    Var   *v;
+    Var *v;
     char *expanded_name = NULL;
     /*
      * We only look for a variable in the given context since anything set
      * here will override anything in a lower context, so there's not much
      * point in searching them all just to save a bit of memory...
      */
     if (strchr(name, '$') != NULL) {
 	expanded_name = Var_Subst(NULL, name, ctxt, VARF_WANTRES);
 	if (expanded_name[0] == 0) {
 	    if (DEBUG(VAR)) {
 		fprintf(debug_file, "Var_Set(\"%s\", \"%s\", ...) "
 			"name expands to empty string - ignored\n",
 @@ -1017,28 +1004,28 @@ Var_Set(const char *name, const char *va
+ *
  * Notes:
  *	Only if the variable is being sought in the global context is the
  *	environment searched.
  *	XXX: Knows its calling circumstances in that if called with ctxt
  *	an actual target, it will only search that context since only
  *	a local variable could be being appended to. This is actually
  *	a big win and must be tolerated.
  *-----------------------------------------------------------------------
  */
 void
 Var_Append(const char *name, const char *val, GNode *ctxt)
+{
-    Var		   *v;
+    Var *v;
-    Hash_Entry	   *h;
+    Hash_Entry *h;
     char *expanded_name = NULL;
     if (strchr(name, '$') != NULL) {
 	expanded_name = Var_Subst(NULL, name, ctxt, VARF_WANTRES);
 	if (expanded_name[0] == 0) {
 	    if (DEBUG(VAR)) {
 		fprintf(debug_file, "Var_Append(\"%s\", \"%s\", ...) "
 			"name expands to empty string - ignored\n",
 			name, val);
+	    }
 	    free(expanded_name);
 	    return;
+	}
 @@ -1320,27 +1307,27 @@ VarSubstitute(GNode *ctx MAKE_ATTR_UNUSE
 		    addSpace = TRUE;
 		    Buf_AddBytes(buf, pattern->rightLen, pattern->rhs);
+		}
 		pattern->flags |= VAR_SUB_MATCHED;
 	    } else if (pattern->flags & VAR_MATCH_END) {
 		/*
 		 * Doesn't match to end -- copy word wholesale
 		 */
 		goto nosub;
 	    } else {
 		/*
 		 * Matches at start but need to copy in trailing characters
 		 */
-		if ((pattern->rightLen + wordLen - pattern->leftLen) != 0){
+		if ((pattern->rightLen + wordLen - pattern->leftLen) != 0) {
 		    if (addSpace && vpstate->varSpace) {
 			Buf_AddByte(buf, vpstate->varSpace);
+		    }
 		    addSpace = TRUE;
+		}
 		Buf_AddBytes(buf, pattern->rightLen, pattern->rhs);
 		Buf_AddBytes(buf, wordLen - pattern->leftLen,
 			     (word + pattern->leftLen));
 		pattern->flags |= VAR_SUB_MATCHED;
+	    }
 	} else if (pattern->flags & VAR_MATCH_START) {
 	    /*
 	     * Had to match at start of word and didn't -- copy whole word.
 @@ -1387,27 +1374,27 @@ VarSubstitute(GNode *ctx MAKE_ATTR_UNUSE
 	     * accordingly through the loop) is copied straight into the
 	     * buffer.
 	     * addSpace is set FALSE as soon as a space is added to the
 	     * buffer.
 	     */
 	    Boolean done;
 	    int origSize;
 	    done = FALSE;
 	    origSize = Buf_Size(buf);
 	    while (!done) {
 		cp = Str_FindSubstring(word, pattern->lhs);
 		if (cp != NULL) {
-		    if (addSpace && (((cp - word) + pattern->rightLen) != 0)){
+		    if (addSpace && (((cp - word) + pattern->rightLen) != 0)) {
 			Buf_AddByte(buf, vpstate->varSpace);
 			addSpace = FALSE;
+		    }
 		    Buf_AddBytes(buf, cp-word, word);
 		    Buf_AddBytes(buf, pattern->rightLen, pattern->rhs);
 		    wordLen -= (cp - word) + pattern->leftLen;
 		    word = cp + pattern->leftLen;
 		    if (wordLen == 0) {
 			done = TRUE;
+		    }
 		    if ((pattern->flags & VAR_SUB_GLOBAL) == 0) {
 			done = TRUE;
+		    }
 @@ -1585,34 +1572,34 @@ VarRESubstitute(GNode *ctx MAKE_ATTR_UNU
  * ODE make. We set the temp variable named in pattern.lhs to word and
  * expand pattern.rhs. */
 static Boolean
 VarLoopExpand(GNode *ctx MAKE_ATTR_UNUSED,
 	      Var_Parse_State *vpstate MAKE_ATTR_UNUSED,
 	      char *word, Boolean addSpace, Buffer *buf,
 	      void *data)
+{
     VarLoop_t *loop = data;
     char *s;
     int slen;
     if (*word) {
-        Var_Set_with_flags(loop->tvar, word, loop->ctxt, VAR_NO_EXPORT);
+	Var_Set_with_flags(loop->tvar, word, loop->ctxt, VAR_NO_EXPORT);
-        s = Var_Subst(NULL, loop->str, loop->ctxt, loop->flags);
+	s = Var_Subst(NULL, loop->str, loop->ctxt, loop->flags);
-        if (s != NULL && *s != '\0') {
+	if (s != NULL && *s != '\0') {
-            if (addSpace && *s != '\n')
+	    if (addSpace && *s != '\n')
-                Buf_AddByte(buf, ' ');
+		Buf_AddByte(buf, ' ');
-            Buf_AddBytes(buf, (slen = strlen(s)), s);
+	    Buf_AddBytes(buf, (slen = strlen(s)), s);
-            addSpace = (slen > 0 && s[slen - 1] != '\n');
+	    addSpace = (slen > 0 && s[slen - 1] != '\n');
+	}
 	free(s);
+    }
     return addSpace;
+}
 /*-
  *-----------------------------------------------------------------------
  * VarSelectWords --
  *	Implements the :[start..end] modifier.
  *	This is a special case of VarModify since we want to be able
  *	to scan the list backwards if start > end.
+ *
 @@ -2008,28 +1995,28 @@ VarGetPattern(GNode *ctxt, Var_Parse_Sta
 		     */
 		    *vflags |= VAR_MATCH_END;
 	    } else {
 		if (vflags == NULL || (*vflags & VAR_NOSUBST) == 0) {
 		    char   *cp2;
 		    int     len;
 		    void   *freeIt;
 		    /*
 		     * If unescaped dollar sign not before the
 		     * delimiter, assume it's a variable
 		     * substitution and recurse.
 		     */
-		    cp2 = Var_Parse(cp, ctxt, errnum |
+		    cp2 = Var_Parse(cp, ctxt, errnum | (flags & VARF_WANTRES),
-				    (flags & VARF_WANTRES), &len, &freeIt);
+				    &len, &freeIt);
 		    Buf_AddBytes(&buf, strlen(cp2), cp2);
 		    free(freeIt);
 		    cp += len - 1;
 		} else {
 		    const char *cp2 = &cp[1];
 		    if (*cp2 == PROPEN || *cp2 == BROPEN) {
 			/*
 			 * Find the end of this variable reference
 			 * and suck it in without further ado.
 			 * It will be interpreted later.
 			 */
 			int have = *cp2;
 @@ -2174,29 +2161,29 @@ VarHash(char *str)
 	h = h * 5 + 0x52dce729U;
 	h ^= k;
+    }
     h ^= len2;
     h *= 0x85ebca6b;
     h ^= h >> 13;
     h *= 0xc2b2ae35;
     h ^= h >> 16;
     Buf_Init(&buf, 0);
     for (len = 0; len < 8; ++len) {
 	Buf_AddByte(&buf, hexdigits[h & 15]);
 	h >>= 4;
+    }
-   return Buf_Destroy(&buf, FALSE);
+    return Buf_Destroy(&buf, FALSE);
+}
 static char *
 VarStrftime(const char *fmt, int zulu, time_t utc)
+{
     char buf[BUFSIZ];
     if (!utc)
 	time(&utc);
     if (!*fmt)
 	fmt = "%c";
     strftime(buf, sizeof(buf), fmt, zulu ? gmtime(&utc) : localtime(&utc));
 @@ -3124,27 +3111,27 @@ ApplyModifier_Assign(ApplyModifiersState
 static Boolean
 ApplyModifier_Remember(ApplyModifiersState *st)
+{
     st->cp = st->tstr + 1;	/* make sure it is set */
     if (!STRMOD_MATCHX(st->tstr, "_", 1))
 	return FALSE;
     if (st->tstr[1] == '=') {
 	char *np;
 	int n;
 	st->cp++;
 	n = strcspn(st->cp, ":)}");
-	np = bmake_strndup(st->cp, n+1);
+	np = bmake_strndup(st->cp, n + 1);
 	np[n] = '\0';
 	st->cp = st->tstr + 2 + n;
 	Var_Set(np, st->nstr, st->ctxt);
 	free(np);
     } else {
 	Var_Set("_", st->nstr, st->ctxt);
+    }
     st->newStr = st->nstr;
     st->termc = *st->cp;
     return TRUE;
+}
 #ifdef SYSVVARSUB
 @@ -3696,28 +3683,27 @@ Var_Parse(const char *str, GNode *ctxt,
 	    tstr = &str[1];
 	    endc = str[1];
+	}
     } else {
 	Buffer buf;		/* Holds the variable name */
 	int depth = 1;
 	endc = startc == PROPEN ? PRCLOSE : BRCLOSE;
 	Buf_Init(&buf, 0);
 	/*
 	 * Skip to the end character or a colon, whichever comes first.
 	 */
-	for (tstr = str + 2; *tstr != '\0'; tstr++)
+	for (tstr = str + 2; *tstr != '\0'; tstr++) {
 	    /* Track depth so we can spot parse errors. */
 	    if (*tstr == startc)
 		depth++;
 	    if (*tstr == endc) {
 		if (--depth == 0)
 		    break;
+	    }
 	    if (depth == 1 && *tstr == ':')
 		break;
 	    /* A variable inside a variable, expand. */
 	    if (*tstr == '$') {
 		int rlen;
 		void *freeIt;
 @@ -3884,27 +3870,27 @@ Var_Parse(const char *str, GNode *ctxt,
 	    tstr++;
 	    nstr = ApplyModifiers(nstr, tstr, startc, endc,
 				  v, ctxt, flags, &used, freePtr);
 	    tstr += used;
 	    free(extraFree);
 	} else {
 	    *freePtr = extraFree;
+	}
+    }
     *lengthPtr = tstr - start + (*tstr ? 1 : 0);
     if (v->flags & VAR_FROM_ENV) {
-	Boolean	  destroy = FALSE;
+	Boolean destroy = FALSE;
 	if (nstr != Buf_GetAll(&v->val, NULL)) {
 	    destroy = TRUE;
 	} else {
 	    /*
 	     * Returning the value unmodified, so tell the caller to free
 	     * the thing.
 	     */
 	    *freePtr = nstr;
+	}
 	VarFreeEnv(v, destroy);
     } else if (v->flags & VAR_JUNK) {
 	/*
 @@ -3979,27 +3965,27 @@ Var_Subst(const char *var, const char *s
 	     * In such a case, we skip over the escape character and store the
 	     * dollar sign into the buffer directly.
 	     */
 	    if (save_dollars && (flags & VARF_ASSIGN))
 		Buf_AddByte(&buf, *str);
 	    str++;
 	    Buf_AddByte(&buf, *str);
 	    str++;
 	} else if (*str != '$') {
 	    /*
 	     * Skip as many characters as possible -- either to the end of
 	     * the string or to the next dollar sign (variable invocation).
 	     */
-	    const char  *cp;
+	    const char *cp;
 	    for (cp = str++; *str != '$' && *str != '\0'; str++)
 		continue;
 	    Buf_AddBytes(&buf, str - cp, cp);
 	} else {
 	    if (var != NULL) {
 		int expand;
 		for (;;) {
 		    if (str[1] == '\0') {
 			/* A trailing $ is kind of a special case */
 			Buf_AddByte(&buf, str[0]);
 			str++;
 			expand = FALSE;
 @@ -4026,27 +4012,27 @@ Var_Subst(const char *var, const char *s
 			 */
 			if (*p == '$') {
 			    Buf_AddBytes(&buf, p - str, str);
 			    str = p;
 			    continue;
+			}
 			if (strncmp(var, str + 2, p - str - 2) != 0 ||
 			    var[p - str - 2] != '\0') {
 			    /*
 			     * Not the variable we want to expand, scan
 			     * until the next variable
 			     */
-			    for (;*p != '$' && *p != '\0'; p++)
+			    for (; *p != '$' && *p != '\0'; p++)
 				continue;
 			    Buf_AddBytes(&buf, p - str, str);
 			    str = p;
 			    expand = FALSE;
 			} else
 			    expand = TRUE;
 			break;
+		    }
+		}
 		if (!expand)
 		    continue;
+	    }