 @@ -1,14 +1,14 @@
-/*	$NetBSD: var.c,v 1.312 2020/07/26 13:39:30 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.313 2020/07/26 15:09:10 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.312 2020/07/26 13:39:30 rillig Exp $";
+static char rcsid[] = "$NetBSD: var.c,v 1.313 2020/07/26 15:09:10 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.312 2020/07/26 13:39:30 rillig Exp $");
+__RCSID("$NetBSD: var.c,v 1.313 2020/07/26 15:09:10 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.
+ *
 @@ -269,29 +269,26 @@ typedef enum {
  *			FIND_ENV	look in the environment as well
+ *
  * Results:
  *	A pointer to the structure describing the desired variable or
  *	NULL if the variable does not exist.
+ *
  * Side Effects:
  *	None
  *-----------------------------------------------------------------------
  */
 static Var *
 VarFind(const char *name, GNode *ctxt, VarFindFlags flags)
+{
     Hash_Entry         	*var;
     Var			*v;
     /*
      * If the variable name begins with a '.', it could very well be one of
      * the local ones.  We check the name against all the local variables
      * and substitute the short version in for 'name' if it matches one of
      * them.
      */
     if (*name == '.' && isupper((unsigned char) name[1])) {
 	switch (name[1]) {
 	case 'A':
 	    if (strcmp(name, ".ALLSRC") == 0)
 		name = ALLSRC;
 	    if (strcmp(name, ".ARCHIVE") == 0)
 		name = ARCHIVE;
 @@ -320,51 +317,48 @@ VarFind(const char *name, GNode *ctxt, V
+    }
 #ifdef notyet
     /* for compatibility with gmake */
     if (name[0] == '^' && name[1] == '\0')
 	name = ALLSRC;
 #endif
     /*
      * First look for the variable in the given context. If it's not there,
      * look for it in VAR_CMD, VAR_GLOBAL and the environment, in that order,
      * depending on the FIND_* flags in 'flags'
      */
-    var = Hash_FindEntry(&ctxt->context, name);
+    Hash_Entry *var = Hash_FindEntry(&ctxt->context, name);
     if (var == NULL && (flags & FIND_CMD) && ctxt != VAR_CMD) {
 	var = Hash_FindEntry(&VAR_CMD->context, name);
+    }
     if (!checkEnvFirst && var == NULL && (flags & FIND_GLOBAL) &&
 	ctxt != VAR_GLOBAL)
+    {
 	var = Hash_FindEntry(&VAR_GLOBAL->context, name);
 	if (var == NULL && ctxt != VAR_INTERNAL) {
 	    /* VAR_INTERNAL is subordinate to VAR_GLOBAL */
 	    var = Hash_FindEntry(&VAR_INTERNAL->context, name);
+	}
+    }
     if (var == NULL && (flags & FIND_ENV)) {
 	char *env;
 	if ((env = getenv(name)) != NULL) {
-	    int len;
+	    Var *v = bmake_malloc(sizeof(Var));
 	    v = bmake_malloc(sizeof(Var));
 	    v->name = bmake_strdup(name);
-	    len = strlen(env);
+	    int len = (int)strlen(env);
 	    Buf_Init(&v->val, len + 1);
 	    Buf_AddBytes(&v->val, len, env);
 	    v->flags = VAR_FROM_ENV;
 	    return v;
 	} else if (checkEnvFirst && (flags & FIND_GLOBAL) &&
 		   ctxt != VAR_GLOBAL)
+	{
 	    var = Hash_FindEntry(&VAR_GLOBAL->context, name);
 	    if (var == NULL && ctxt != VAR_INTERNAL) {
 		var = Hash_FindEntry(&VAR_INTERNAL->context, name);
+	    }
 	    if (var == NULL) {
 @@ -418,39 +412,35 @@ VarFreeEnv(Var *v, Boolean destroy)
  *	name		name of variable to add
  *	val		value to set it to
  *	ctxt		context in which to set it
+ *
  * Side Effects:
  *	The new variable is placed at the front of the given context
  *	The name and val arguments are duplicated so they may
  *	safely be freed.
  *-----------------------------------------------------------------------
  */
 static void
 VarAdd(const char *name, const char *val, GNode *ctxt)
+{
-    Var   	  *v;
+    Var *v = bmake_malloc(sizeof(Var));
     int		  len;
     Hash_Entry    *h;
     v = bmake_malloc(sizeof(Var));
-    len = val != NULL ? strlen(val) : 0;
+    int len = val != NULL ? (int)strlen(val) : 0;
     Buf_Init(&v->val, len + 1);
     Buf_AddBytes(&v->val, len, val);
     v->flags = 0;
-    h = Hash_CreateEntry(&ctxt->context, name, NULL);
+    Hash_Entry *h = Hash_CreateEntry(&ctxt->context, name, NULL);
     Hash_SetValue(h, v);
     v->name = h->name;
     if (DEBUG(VAR) && !(ctxt->flags & INTERNAL)) {
 	fprintf(debug_file, "%s:%s = %s\n", ctxt->name, name, val);
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * Var_Delete --
  *	Remove a variable from a context.
+ *
  * Side Effects:
 @@ -828,27 +818,27 @@ Var_Set_with_flags(const char *name, con
     if (v == NULL) {
 	if (ctxt == VAR_CMD && (flags & VAR_NO_EXPORT) == 0) {
 	    /*
 	     * This var would normally prevent the same name being added
 	     * to VAR_GLOBAL, so delete it from there if needed.
 	     * Otherwise -V name may show the wrong value.
 	     */
 	    Var_Delete(name, VAR_GLOBAL);
+	}
 	VarAdd(name, val, ctxt);
     } else {
 	Buf_Empty(&v->val);
 	if (val)
-	    Buf_AddBytes(&v->val, strlen(val), val);
+	    Buf_AddStr(&v->val, val);
 	if (DEBUG(VAR)) {
 	    fprintf(debug_file, "%s:%s = %s\n", ctxt->name, name, val);
+	}
 	if ((v->flags & VAR_EXPORTED)) {
 	    Var_Export1(name, VAR_EXPORT_PARENT);
+	}
+    }
     /*
      * Any variables given on the command line are automatically exported
      * to the environment (as per POSIX standard)
      */
     if (ctxt == VAR_CMD && (flags & VAR_NO_EXPORT) == 0) {
 @@ -950,27 +940,27 @@ Var_Append(const char *name, const char
+	    }
 	    free(expanded_name);
 	    return;
+	}
 	name = expanded_name;
+    }
     v = VarFind(name, ctxt, ctxt == VAR_GLOBAL ? (FIND_CMD | FIND_ENV) : 0);
     if (v == NULL) {
 	Var_Set(name, val, ctxt);
     } else if (ctxt == VAR_CMD || !(v->flags & VAR_FROM_CMD)) {
 	Buf_AddByte(&v->val, ' ');
-	Buf_AddBytes(&v->val, strlen(val), val);
+	Buf_AddStr(&v->val, val);
 	if (DEBUG(VAR)) {
 	    fprintf(debug_file, "%s:%s = %s\n", ctxt->name, name,
 		    Buf_GetAll(&v->val, NULL));
+	}
 	if (v->flags & VAR_FROM_ENV) {
 	    /*
 	     * If the original variable came from the environment, we
 	     * have to install it in the global context (we could place
 	     * it in the environment, but then we should provide a way to
 	     * export other variables...)
 	     */
 @@ -1690,27 +1680,27 @@ VarOrder(const char *str, const char oty
 		 * 0 with probability 1).
 		 */
 		for (i = ac - 1; i > 0; i--) {
 		    int rndidx = random() % (i + 1);
 		    char *t = av[i];
 		    av[i] = av[rndidx];
 		    av[rndidx] = t;
+		}
+	    }
+	}
+    }
     for (i = 0; i < ac; i++) {
-	Buf_AddBytes(&buf, strlen(av[i]), av[i]);
+	Buf_AddStr(&buf, av[i]);
 	if (i != ac - 1)
 	    Buf_AddByte(&buf, ' ');
+    }
     free(as);
     free(av);
     return Buf_Destroy(&buf, FALSE);
+}
 /*-
  *-----------------------------------------------------------------------
 @@ -1737,27 +1727,27 @@ VarUniq(const char *str)
     int 	  ac, i, j;
     Buf_Init(&buf, 0);
     av = brk_string(str, &ac, FALSE, &as);
     if (ac > 1) {
 	for (j = 0, i = 1; i < ac; i++)
 	    if (strcmp(av[i], av[j]) != 0 && (++j != i))
 		av[j] = av[i];
 	ac = j + 1;
+    }
     for (i = 0; i < ac; i++) {
-	Buf_AddBytes(&buf, strlen(av[i]), av[i]);
+	Buf_AddStr(&buf, av[i]);
 	if (i != ac - 1)
 	    Buf_AddByte(&buf, ' ');
+    }
     free(as);
     free(av);
     return Buf_Destroy(&buf, FALSE);
+}
 /*-
  *-----------------------------------------------------------------------
  * VarRange --
 @@ -1852,51 +1842,51 @@ ParseModifierPart(GNode *ctxt, const cha
 	    } else {
 		if (!(eflags & VARE_NOSUBST)) {
 		    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 | (eflags & VARE_WANTRES),
 				    &len, &freeIt);
-		    Buf_AddBytes(&buf, strlen(cp2), cp2);
+		    Buf_AddStr(&buf, 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;
 			int want = (*cp2 == PROPEN) ? PRCLOSE : BRCLOSE;
 			int depth = 1;
 			for (++cp2; *cp2 != '\0' && depth > 0; ++cp2) {
 			    if (cp2[-1] != '\\') {
 				if (*cp2 == have)
 				    ++depth;
 				if (*cp2 == want)
 				    --depth;
+			    }
+			}
-			Buf_AddBytes(&buf, cp2 - cp, cp);
+			Buf_AddBytesBetween(&buf, cp, cp2);
 			cp = --cp2;
 		    } else
 			Buf_AddByte(&buf, *cp);
+		}
+	    }
 	} else if (subst != NULL && *cp == '&')
 	    Buf_AddBytes(&buf, subst->lhsLen, subst->lhs);
 	else
 	    Buf_AddByte(&buf, *cp);
+    }
     if (*cp != delim) {
 	*tstr = cp;
 @@ -1927,34 +1917,34 @@ ParseModifierPart(GNode *ctxt, const cha
  *-----------------------------------------------------------------------
  */
 static char *
 VarQuote(char *str, Boolean quoteDollar)
+{
     Buffer buf;
     Buf_Init(&buf, 0);
     for (; *str != '\0'; str++) {
 	if (*str == '\n') {
 	    const char *newline = Shell_GetNewline();
 	    if (newline == NULL)
 		newline = "\\\n";
-	    Buf_AddBytes(&buf, strlen(newline), newline);
+	    Buf_AddStr(&buf, newline);
 	    continue;
+	}
 	if (isspace((unsigned char)*str) || ismeta((unsigned char)*str))
 	    Buf_AddByte(&buf, '\\');
 	Buf_AddByte(&buf, *str);
 	if (quoteDollar && *str == '$')
-	    Buf_AddBytes(&buf, 2, "\\$");
+	    Buf_AddStr(&buf, "\\$");
+    }
     str = Buf_Destroy(&buf, FALSE);
     if (DEBUG(VAR))
 	fprintf(debug_file, "QuoteMeta: [%s]\n", str);
     return str;
+}
 /*-
  *-----------------------------------------------------------------------
  * VarHash --
  *      Hash the string using the MurmurHash3 algorithm.
  *      Output is computed using 32bit Little Endian arithmetic.
 @@ -2155,27 +2145,27 @@ ApplyModifier_Defined(const char *mod, A
 	     st->cp[1] == '\\')) {
 	    Buf_AddByte(&buf, st->cp[1]);
 	    st->cp++;
 	} else if (*st->cp == '$') {
 	    /*
 	     * If unescaped dollar sign, assume it's a
 	     * variable substitution and recurse.
 	     */
 	    char    *cp2;
 	    int	    len;
 	    void    *freeIt;
 	    cp2 = Var_Parse(st->cp, st->ctxt, neflags, &len, &freeIt);
-	    Buf_AddBytes(&buf, strlen(cp2), cp2);
+	    Buf_AddStr(&buf, cp2);
 	    free(freeIt);
 	    st->cp += len - 1;
 	} else {
 	    Buf_AddByte(&buf, *st->cp);
+	}
+    }
     st->termc = *st->cp;
     if (st->v->flags & VAR_JUNK)
 	st->v->flags |= VAR_KEEP;
     if (neflags & VARE_WANTRES) {
 	st->newStr = Buf_Destroy(&buf, FALSE);
 @@ -3487,27 +3477,27 @@ Var_Parse(const char *str, GNode *ctxt,
 		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;
 		char *rval = Var_Parse(tstr, ctxt, flags, &rlen, &freeIt);
 		if (rval != NULL)
-		    Buf_AddBytes(&buf, strlen(rval), rval);
+		    Buf_AddStr(&buf, rval);
 		free(freeIt);
 		tstr += rlen - 1;
 	    } else
 		Buf_AddByte(&buf, *tstr);
+	}
 	if (*tstr == ':') {
 	    haveModifier = TRUE;
 	} else if (*tstr == endc) {
 	    haveModifier = FALSE;
 	} else {
 	    /*
 	     * If we never did find the end character, return NULL
 	     * right now, setting the length to be the distance to
 @@ -3757,27 +3747,27 @@ Var_Subst(const char *var, const char *s
 		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;
 	    for (cp = str++; *str != '$' && *str != '\0'; str++)
 		continue;
-	    Buf_AddBytes(&buf, str - cp, cp);
+	    Buf_AddBytesBetween(&buf, cp, str);
 	} 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;
 		    } else if (str[1] != PROPEN && str[1] != BROPEN) {
 			if (str[1] != *var || strlen(var) > 1) {
 			    Buf_AddBytes(&buf, 2, str);
 			    str += 2;
 @@ -3789,40 +3779,40 @@ Var_Subst(const char *var, const char *s
 			const char *p;
 			/* Scan up to the end of the variable name. */
 			for (p = &str[2]; *p &&
 			     *p != ':' && *p != PRCLOSE && *p != BRCLOSE; p++)
 			    if (*p == '$')
 				break;
 			/*
 			 * A variable inside the variable. We cannot expand
 			 * the external variable yet, so we try again with
 			 * the nested one
 			 */
 			if (*p == '$') {
-			    Buf_AddBytes(&buf, p - str, str);
+			    Buf_AddBytesBetween(&buf, str, p);
 			    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++)
 				continue;
-			    Buf_AddBytes(&buf, p - str, str);
+			    Buf_AddBytesBetween(&buf, str, p);
 			    str = p;
 			    expand = FALSE;
 			} else
 			    expand = TRUE;
 			break;
+		    }
+		}
 		if (!expand)
 		    continue;
+	    }
 	    val = Var_Parse(str, ctxt, flags, &length, &freeIt);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: buf.h,v 1.20 2020/07/26 13:39:30 rillig Exp $	*/
+/*	$NetBSD: buf.h,v 1.21 2020/07/26 15:09:10 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -100,21 +100,23 @@ typedef struct Buffer {
 	if (__predict_false(_count >= (bp)->size)) \
 		Buf_Expand_1(bp); \
 	_ptr = (bp)->buffer + _count; \
 	_ptr[-1] = (byte); \
 	_ptr[0] = 0; \
     } while (0)
 #define BUF_ERROR 256
 #define Buf_Size(bp) ((bp)->count)
 void Buf_Expand_1(Buffer *);
 void Buf_AddBytes(Buffer *, int, const Byte *);
 void Buf_AddBytesBetween(Buffer *, const Byte *, const Byte *);
 void Buf_AddStr(Buffer *, const char *);
 void Buf_AddInt(Buffer *, int);
 Byte *Buf_GetAll(Buffer *, int *);
 void Buf_Empty(Buffer *);
 void Buf_Init(Buffer *, int);
 Byte *Buf_Destroy(Buffer *, Boolean);
 Byte *Buf_DestroyCompact(Buffer *);
 #endif /* MAKE_BUF_H */