 @@ -1,14 +1,14 @@
-/*	$NetBSD: var.c,v 1.313 2020/07/26 15:09:10 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.314 2020/07/26 15:26:27 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.313 2020/07/26 15:09:10 rillig Exp $";
+static char rcsid[] = "$NetBSD: var.c,v 1.314 2020/07/26 15:26:27 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.313 2020/07/26 15:09:10 rillig Exp $");
+__RCSID("$NetBSD: var.c,v 1.314 2020/07/26 15:26:27 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.
+ *
 @@ -1049,112 +1049,124 @@ SepBuf_Init(SepBuf *buf, char sep)
+{
     Buf_Init(&buf->buf, 32 /* bytes */);
     buf->needSep = FALSE;
     buf->sep = sep;
+}
 static void
 SepBuf_Sep(SepBuf *buf)
+{
     buf->needSep = TRUE;
+}
 static void
-SepBuf_AddBytes(SepBuf *buf, const void *mem, size_t mem_size)
+SepBuf_AddBytes(SepBuf *buf, const char *mem, size_t mem_size)
+{
     if (mem_size == 0)
 	return;
     if (buf->needSep && buf->sep != '\0') {
 	Buf_AddByte(&buf->buf, buf->sep);
 	buf->needSep = FALSE;
+    }
     Buf_AddBytes(&buf->buf, mem_size, mem);
+}
 static void
 SepBuf_AddBytesBetween(SepBuf *buf, const char *start, const char *end)
+{
     SepBuf_AddBytes(buf, start, (size_t)(end - start));
+}
 static void
 SepBuf_AddStr(SepBuf *buf, const char *str)
+{
     SepBuf_AddBytes(buf, str, strlen(str));
+}
 static char *
 SepBuf_Destroy(SepBuf *buf, Boolean free_buf)
+{
     return Buf_Destroy(&buf->buf, free_buf);
+}
 /* This callback for ModifyWords gets a single word from an expression and
  * typically adds a modification of this word to the buffer. It may also do
  * nothing or add several words. */
 typedef void (*ModifyWordsCallback)(const char *word, SepBuf *buf, void *data);
 /* Callback for ModifyWords to implement the :H modifier.
  * Add the dirname of the given word to the buffer. */
 static void
 ModifyWord_Head(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
     const char *slash = strrchr(word, '/');
     if (slash != NULL)
-	SepBuf_AddBytes(buf, word, slash - word);
+	SepBuf_AddBytesBetween(buf, word, slash);
     else
-	SepBuf_AddBytes(buf, ".", 1);
+	SepBuf_AddStr(buf, ".");
+}
 /* Callback for ModifyWords to implement the :T modifier.
  * Add the basename of the given word to the buffer. */
 static void
 ModifyWord_Tail(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
     const char *slash = strrchr(word, '/');
     const char *base = slash != NULL ? slash + 1 : word;
-    SepBuf_AddBytes(buf, base, strlen(base));
+    SepBuf_AddStr(buf, base);
+}
 /* Callback for ModifyWords to implement the :E modifier.
  * Add the filename suffix of the given word to the buffer, if it exists. */
 static void
 ModifyWord_Suffix(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
     const char *dot = strrchr(word, '.');
     if (dot != NULL)
-	SepBuf_AddBytes(buf, dot + 1, strlen(dot + 1));
+	SepBuf_AddStr(buf, dot + 1);
+}
 /* Callback for ModifyWords to implement the :R modifier.
  * Add the basename of the given word to the buffer. */
 static void
 ModifyWord_Root(const char *word, SepBuf *buf, void *dummy MAKE_ATTR_UNUSED)
+{
-    char *dot = strrchr(word, '.');
+    const char *dot = strrchr(word, '.');
     size_t len = dot != NULL ? (size_t)(dot - word) : strlen(word);
     SepBuf_AddBytes(buf, word, len);
+}
 /* Callback for ModifyWords to implement the :M modifier.
  * Place the word in the buffer if it matches the given pattern. */
 static void
 ModifyWord_Match(const char *word, SepBuf *buf, void *data)
+{
     const char *pattern = data;
     if (DEBUG(VAR))
 	fprintf(debug_file, "VarMatch [%s] [%s]\n", word, pattern);
     if (Str_Match(word, pattern))
-	SepBuf_AddBytes(buf, word, strlen(word));
+	SepBuf_AddStr(buf, word);
+}
 /* Callback for ModifyWords to implement the :N modifier.
  * Place the word in the buffer if it doesn't match the given pattern. */
 static void
 ModifyWord_NoMatch(const char *word, SepBuf *buf, void *data)
+{
     const char *pattern = data;
     if (!Str_Match(word, pattern))
-	SepBuf_AddBytes(buf, word, strlen(word));
+	SepBuf_AddStr(buf, word);
+}
 #ifdef SYSVVARSUB
 /*-
  *-----------------------------------------------------------------------
  * Str_SYSVMatch --
  *	Check word against pattern for a match (% is wild),
+ *
  * Input:
  *	word		Word to examine
  *	pattern		Pattern to examine against
  *	len		Number of characters to substitute
+ *
 @@ -1221,61 +1233,61 @@ Str_SYSVMatch(const char *word, const ch
+ *
  * Side Effects:
  *	Places result on buf
  *-----------------------------------------------------------------------
  */
 static void
 Str_SYSVSubst(SepBuf *buf, const char *pat, const char *src, size_t len,
 	      Boolean lhsHasPercent)
+{
     const char *m;
     if ((m = strchr(pat, '%')) != NULL && lhsHasPercent) {
 	/* Copy the prefix */
-	SepBuf_AddBytes(buf, pat, m - pat);
+	SepBuf_AddBytesBetween(buf, pat, m);
 	/* skip the % */
 	pat = m + 1;
+    }
     if (m != NULL || !lhsHasPercent) {
 	/* Copy the pattern */
 	SepBuf_AddBytes(buf, src, len);
+    }
     /* append the rest */
-    SepBuf_AddBytes(buf, pat, strlen(pat));
+    SepBuf_AddStr(buf, pat);
+}
 typedef struct {
     GNode *ctx;
     const char *lhs;
     const char *rhs;
 } ModifyWord_SYSVSubstArgs;
 /* Callback for ModifyWords to implement the :%.from=%.to modifier. */
 static void
 ModifyWord_SYSVSubst(const char *word, SepBuf *buf, void *data)
+{
     const ModifyWord_SYSVSubstArgs *args = data;
     size_t len;
     Boolean hasPercent;
     const char *ptr = Str_SYSVMatch(word, args->lhs, &len, &hasPercent);
     if (ptr != NULL) {
 	char *varexp = Var_Subst(NULL, args->rhs, args->ctx, VARE_WANTRES);
 	Str_SYSVSubst(buf, varexp, ptr, len, hasPercent);
 	free(varexp);
     } else {
-	SepBuf_AddBytes(buf, word, strlen(word));
+	SepBuf_AddStr(buf, word);
+    }
+}
 #endif
 typedef struct {
     const char	*lhs;
     size_t	lhsLen;
     const char	*rhs;
     size_t	rhsLen;
     VarPatternFlags pflags;
 } ModifyWord_SubstArgs;
 @@ -1307,36 +1319,36 @@ ModifyWord_Subst(const char *word, SepBu
 	    SepBuf_AddBytes(buf, word + args->lhsLen, wordLen - args->lhsLen);
 	    args->pflags |= VARP_SUB_MATCHED;
+	}
 	return;
+    }
     if (args->pflags & VARP_ANCHOR_END) {
 	if (wordLen < args->lhsLen)
 	    goto nosub;
 	const char *start = word + (wordLen - args->lhsLen);
 	if (memcmp(start, args->lhs, args->lhsLen) != 0)
 	    goto nosub;
-	SepBuf_AddBytes(buf, word, start - word);
+	SepBuf_AddBytesBetween(buf, word, start);
 	SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
 	args->pflags |= VARP_SUB_MATCHED;
 	return;
+    }
     /* unanchored */
     const char *cp;
     while ((cp = Str_FindSubstring(word, args->lhs)) != NULL) {
-	SepBuf_AddBytes(buf, word, cp - word);
+	SepBuf_AddBytesBetween(buf, word, cp);
 	SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
 	args->pflags |= VARP_SUB_MATCHED;
 	wordLen -= (cp - word) + args->lhsLen;
 	word = cp + args->lhsLen;
 	if (wordLen == 0 || !(args->pflags & VARP_SUB_GLOBAL))
 	    break;
+    }
 nosub:
     SepBuf_AddBytes(buf, word, wordLen);
+}
 #ifndef NO_REGEX
 /*-
 @@ -1408,54 +1420,54 @@ tryagain:
 		} else {
 		    n = rp[1] - '0';
 		    errstr[0] = '\\';
 		    errstr[1] = rp[1];
 		    errstr[2] = '\0';
 		    rp++;
+		}
 		if (n >= args->nsub) {
 		    Error("No subexpression %s", errstr);
 		} else if (m[n].rm_so == -1 && m[n].rm_eo == -1) {
 		    Error("No match for subexpression %s", errstr);
 		} else {
-		    SepBuf_AddBytes(buf, wp + m[n].rm_so,
+		    SepBuf_AddBytesBetween(buf, wp + m[n].rm_so,
-				    m[n].rm_eo - m[n].rm_so);
+					   wp + m[n].rm_eo);
+		}
 	    } else {
 		SepBuf_AddBytes(buf, rp, 1);
+	    }
+	}
 	wp += m[0].rm_eo;
 	if (args->pflags & VARP_SUB_GLOBAL) {
 	    flags |= REG_NOTBOL;
 	    if (m[0].rm_so == 0 && m[0].rm_eo == 0) {
 		SepBuf_AddBytes(buf, wp, 1);
 		wp++;
+	    }
 	    if (*wp)
 		goto tryagain;
+	}
 	if (*wp) {
-	    SepBuf_AddBytes(buf, wp, strlen(wp));
+	    SepBuf_AddStr(buf, wp);
+	}
 	break;
     default:
 	VarREError(xrv, &args->re, "Unexpected regex error");
 	/* fall through */
     case REG_NOMATCH:
     nosub:
-	SepBuf_AddBytes(buf, wp, strlen(wp));
+	SepBuf_AddStr(buf, wp);
 	break;
+    }
+}
 #endif
 typedef struct {
     GNode	*ctx;
     char	*tvar;		/* name of temporary variable */
     char	*str;		/* string to expand */
     VarEvalFlags eflags;
 } ModifyWord_LoopArgs;
 @@ -1470,27 +1482,27 @@ ModifyWord_Loop(const char *word, SepBuf
     Var_Set_with_flags(args->tvar, word, args->ctx, VAR_NO_EXPORT);
     char *s = Var_Subst(NULL, args->str, args->ctx, args->eflags);
     if (DEBUG(VAR)) {
 	fprintf(debug_file,
 		"ModifyWord_Loop: in \"%s\", replace \"%s\" with \"%s\" "
 		"to \"%s\"\n",
 		word, args->tvar, args->str, s ? s : "(null)");
+    }
     if (s != NULL && s[0] != '\0') {
 	if (s[0] == '\n' || (buf->buf.count > 0 &&
 	    buf->buf.buffer[buf->buf.count - 1] == '\n'))
 	    buf->needSep = FALSE;
-	SepBuf_AddBytes(buf, s, strlen(s));
+	SepBuf_AddStr(buf, s);
+    }
     free(s);
+}
 /*-
  * Implements the :[first..last] modifier.
  * This is a special case of ModifyWords since we want to be able
  * to scan the list backwards if first > last.
  */
 static char *
 VarSelectWords(Byte sep, Boolean oneBigWord, const char *str, int first,
 	       int last)
 @@ -1529,50 +1541,50 @@ VarSelectWords(Byte sep, Boolean oneBigW
      * We avoid scanning more of the list than we need to.
      */
     if (first > last) {
 	start = MIN(ac, first) - 1;
 	end = MAX(0, last - 1);
 	step = -1;
     } else {
 	start = MAX(0, first - 1);
 	end = MIN(ac, last);
 	step = 1;
+    }
     for (i = start; (step < 0) == (i >= end); i += step) {
-	SepBuf_AddBytes(&buf, av[i], strlen(av[i]));
+	SepBuf_AddStr(&buf, av[i]);
 	SepBuf_Sep(&buf);
+    }
     free(as);
     free(av);
     return SepBuf_Destroy(&buf, FALSE);
+}
 /* Callback for ModifyWords to implement the :tA modifier.
  * Replace each word with the result of realpath() if successful. */
 static void
 ModifyWord_Realpath(const char *word, SepBuf *buf, void *data MAKE_ATTR_UNUSED)
+{
     struct stat st;
     char rbuf[MAXPATHLEN];
-    char *rp = cached_realpath(word, rbuf);
+    const char *rp = cached_realpath(word, rbuf);
     if (rp != NULL && *rp == '/' && stat(rp, &st) == 0)
 	word = rp;
-    SepBuf_AddBytes(buf, word, strlen(word));
+    SepBuf_AddStr(buf, word);
+}
 /*-
  *-----------------------------------------------------------------------
  * Modify each of the words of the passed string using the given function.
+ *
  * Input:
  *	str		String whose words should be modified
  *	modifyWord	Function that modifies a single word
  *	data		Custom data for modifyWord
+ *
  * Results:
  *	A string of all the words modified appropriately.
 @@ -2511,27 +2523,27 @@ ApplyModifier_Regex(const char *mod, App
     if (args.nsub > 10)
 	args.nsub = 10;
     st->newStr = ModifyWords(st->ctxt, st->sep, oneBigWord, st->nstr,
 			     ModifyWord_SubstRegex, &args);
     regfree(&args.re);
     free(args.replace);
     return TRUE;
+}
 #endif
 static void
 ModifyWord_Copy(const char *word, SepBuf *buf, void *data MAKE_ATTR_UNUSED)
+{
-    SepBuf_AddBytes(buf, word, strlen(word));
+    SepBuf_AddStr(buf, word);
+}
 /* :ts<separator> */
 static Boolean
 ApplyModifier_ToSep(const char *sep, ApplyModifiersState *st)
+{
     if (sep[0] != st->endc && (sep[1] == st->endc || sep[1] == ':')) {
 	/* ":ts<unrecognised><endc>" or ":ts<unrecognised>:" */
 	st->sep = sep[0];
 	st->cp = sep + 1;
     } else if (sep[0] == st->endc || sep[0] == ':') {
 	/* ":ts<endc>" or ":ts:" */
 	st->sep = '\0';		/* no separator */