 @@ -1,14 +1,14 @@
-/*	$NetBSD: buf.c,v 1.47 2020/12/30 10:03:16 rillig Exp $	*/
+/*	$NetBSD: buf.c,v 1.48 2021/01/30 20:53:29 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 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.
 @@ -65,27 +65,27 @@
  * 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.
  */
 /* Automatically-expanding null-terminated character buffers. */
 #include <limits.h>
 #include "make.h"
 /*	"@(#)buf.c	8.1 (Berkeley) 6/6/93"	*/
-MAKE_RCSID("$NetBSD: buf.c,v 1.47 2020/12/30 10:03:16 rillig Exp $");
+MAKE_RCSID("$NetBSD: buf.c,v 1.48 2021/01/30 20:53:29 rillig Exp $");
 /* Make space in the buffer for adding at least 16 more bytes. */
 void
 Buf_Expand(Buffer *buf)
+{
 	buf->cap += buf->cap > 16 ? buf->cap : 16;
 	buf->data = bmake_realloc(buf->data, buf->cap);
+}
 /* Add the bytes to the buffer. */
 void
 Buf_AddBytes(Buffer *buf, const char *bytes, size_t bytes_len)
+{
 @@ -165,57 +165,66 @@ Buf_InitSize(Buffer *buf, size_t cap)
 	buf->cap = cap;
 	buf->len = 0;
 	buf->data = bmake_malloc(cap);
 	buf->data[0] = '\0';
+}
 void
 Buf_Init(Buffer *buf)
+{
 	Buf_InitSize(buf, 256);
+}
 /*
- * Reset the buffer.
+ * Free the data from the buffer.
- * If freeData is TRUE, the data from the buffer is freed as well.
+ * The buffer is left in an indeterminate state.
- * Otherwise it is kept and returned.
+ */
 void
 Buf_Done(Buffer *buf)
+{
 	free(buf->data);
 	buf->cap = 0;
 	buf->len = 0;
 	buf->data = NULL;
+}
 /*
  * Return the data from the buffer.
  * The buffer is left in an indeterminate state.
  */
 char *
-Buf_Destroy(Buffer *buf, Boolean freeData)
+Buf_DoneData(Buffer *buf)
+{
 	char *data = buf->data;
 	if (freeData) {
 		free(data);
 		data = NULL;
 	buf->cap = 0;
 	buf->len = 0;
 	buf->data = NULL;
 	return data;
+}
 #ifndef BUF_COMPACT_LIMIT
 # define BUF_COMPACT_LIMIT 128	/* worthwhile saving */
 #endif
 /*
  * Reset the buffer and return its data.
+ *
  * If the buffer size is much greater than its content,
  * a new buffer will be allocated and the old one freed.
  */
 char *
-Buf_DestroyCompact(Buffer *buf)
+Buf_DoneDataCompact(Buffer *buf)
+{
 #if BUF_COMPACT_LIMIT > 0
 	if (buf->cap - buf->len >= BUF_COMPACT_LIMIT) {
 		/* We trust realloc to be smart */
 		char *data = bmake_realloc(buf->data, buf->len + 1);
 		data[buf->len] = '\0';	/* XXX: unnecessary */
-		Buf_Destroy(buf, FALSE);
+		Buf_DoneData(buf);
 		return data;
+	}
 #endif
-	return Buf_Destroy(buf, FALSE);
+	return Buf_DoneData(buf);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: buf.h,v 1.38 2020/12/28 15:42:53 rillig Exp $	*/
+/*	$NetBSD: buf.h,v 1.39 2021/01/30 20:53:29 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
 @@ -116,17 +116,18 @@ MAKE_INLINE Boolean
 Buf_EndsWith(const Buffer *buf, char ch)
+{
 	return buf->len > 0 && buf->data[buf->len - 1] == ch;
+}
 void Buf_AddBytes(Buffer *, const char *, size_t);
 void Buf_AddBytesBetween(Buffer *, const char *, const char *);
 void Buf_AddStr(Buffer *, const char *);
 void Buf_AddInt(Buffer *, int);
 char *Buf_GetAll(Buffer *, size_t *);
 void Buf_Empty(Buffer *);
 void Buf_Init(Buffer *);
 void Buf_InitSize(Buffer *, size_t);
-char *Buf_Destroy(Buffer *, Boolean);
+void Buf_Done(Buffer *);
-char *Buf_DestroyCompact(Buffer *);
+char *Buf_DoneData(Buffer *);
 char *Buf_DoneDataCompact(Buffer *);
 #endif /* MAKE_BUF_H */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: cond.c,v 1.253 2021/01/22 00:12:01 rillig Exp $	*/
+/*	$NetBSD: cond.c,v 1.254 2021/01/30 20:53:29 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 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.
 @@ -85,27 +85,27 @@
  *	Cond_restore_depth
  *			Save and restore the nesting of the conditions, at
  *			the start and end of including another makefile, to
  *			ensure that in each makefile the conditional
  *			directives are well-balanced.
  */
 #include <errno.h>
 #include "make.h"
 #include "dir.h"
 /*	"@(#)cond.c	8.2 (Berkeley) 1/2/94"	*/
-MAKE_RCSID("$NetBSD: cond.c,v 1.253 2021/01/22 00:12:01 rillig Exp $");
+MAKE_RCSID("$NetBSD: cond.c,v 1.254 2021/01/30 20:53:29 rillig Exp $");
 /*
  * The parsing of conditional expressions is based on this grammar:
  *	Or -> And '||' Or
  *	Or -> And
  *	And -> Term '&&' And
  *	And -> Term
  *	Term -> Function '(' Argument ')'
  *	Term -> Leaf Operator Leaf
  *	Term -> Leaf
  *	Term -> '(' Or ')'
  *	Term -> '!' Term
  *	Leaf -> "string"
 @@ -272,28 +272,28 @@ ParseFuncArg(CondParser *par, const char
 			/* TODO: handle errors */
 			Buf_AddStr(&argBuf, nestedVal.str);
 			FStr_Done(&nestedVal);
 			continue;
+		}
 		if (ch == '(')
 			paren_depth++;
 		else if (ch == ')' && --paren_depth < 0)
 			break;
 		Buf_AddByte(&argBuf, *p);
 		p++;
+	}
-	*out_arg = Buf_GetAll(&argBuf, &argLen);
+	argLen = argBuf.len;
-	Buf_Destroy(&argBuf, FALSE);
+	*out_arg = Buf_DoneData(&argBuf);
 	cpp_skip_hspace(&p);
 	if (func != NULL && *p++ != ')') {
 		Parse_Error(PARSE_FATAL,
 		    "Missing closing parenthesis for %s()", func);
 		par->printedError = TRUE;
 		return 0;
+	}
 	*pp = p;
 	return argLen;
+}
 @@ -529,29 +529,29 @@ CondParser_String(CondParser *par, Boole
 				/*
 				 * The left-hand side must be quoted,
 				 * a variable reference or a number.
 				 */
 				str = FStr_InitRefer(NULL);
 				goto cleanup;
+			}
 			Buf_AddByte(&buf, par->p[0]);
 			par->p++;
 			continue;
+		}
+	}
 got_str:
-	str = FStr_InitOwn(Buf_GetAll(&buf, NULL));
+	str = FStr_InitOwn(buf.data);
 cleanup:
-	Buf_Destroy(&buf, FALSE);
+	Buf_DoneData(&buf);
 	*out_str = str;
+}
 static Boolean
 If_Eval(const CondParser *par, const char *arg, size_t arglen)
+{
 	Boolean res = par->evalBare(arglen, arg);
 	return par->negateEvalBare ? !res : res;
+}
 /*
  * Evaluate a "comparison without operator", such as in ".if ${VAR}" or
  * ".if 0".

 @@ -1,14 +1,14 @@
-/*	$NetBSD: dir.c,v 1.264 2021/01/24 20:11:55 rillig Exp $	*/
+/*	$NetBSD: dir.c,v 1.265 2021/01/30 20:53:29 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 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.
 @@ -128,27 +128,27 @@
  */
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <dirent.h>
 #include <errno.h>
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 /*	"@(#)dir.c	8.2 (Berkeley) 1/2/94"	*/
-MAKE_RCSID("$NetBSD: dir.c,v 1.264 2021/01/24 20:11:55 rillig Exp $");
+MAKE_RCSID("$NetBSD: dir.c,v 1.265 2021/01/30 20:53:29 rillig Exp $");
 /*
  * A search path is a list of CachedDir structures. A CachedDir has in it the
  * name of the directory and the names of all the files in the directory.
  * This is used to cut down on the number of system calls necessary to find
  * implicit dependents and their like. Since these searches are made before
  * any actions are taken, we need not worry about the directory changing due
  * to creation commands. If this hampers the style of some makefiles, they
  * must be changed.
+ *
  * All previously-read directories are kept in openDirs, which is checked
  * first before a directory is opened.
+ *
 @@ -1635,27 +1635,27 @@ SearchPath_ToFlags(SearchPath *path, con
 	SearchPathNode *ln;
 	Buf_Init(&buf);
 	if (path != NULL) {
 		for (ln = path->dirs.first; ln != NULL; ln = ln->next) {
 			CachedDir *dir = ln->datum;
 			Buf_AddStr(&buf, " ");
 			Buf_AddStr(&buf, flag);
 			Buf_AddStr(&buf, dir->name);
+		}
+	}
-	return Buf_Destroy(&buf, FALSE);
+	return Buf_DoneData(&buf);
+}
 /* Free the search path and all directories mentioned in it. */
 void
 SearchPath_Free(SearchPath *path)
+{
 	SearchPathNode *ln;
 	for (ln = path->dirs.first; ln != NULL; ln = ln->next) {
 		CachedDir *dir = ln->datum;
 		CachedDir_Unref(dir);
+	}
 	Lst_Done(&path->dirs);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: for.c,v 1.138 2021/01/25 19:39:34 rillig Exp $	*/
+/*	$NetBSD: for.c,v 1.139 2021/01/30 20:53:29 rillig Exp $	*/
 /*
  * Copyright (c) 1992, The Regents of the University of California.
  * All rights reserved.
+ *
  * 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
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
 @@ -48,27 +48,27 @@
  * body is scanned for variable expressions, and those that match the variable
  * names are replaced with expressions of the form ${:U...} or $(:U...).
  * After that, the body is treated like a file from an .include directive.
+ *
  * Interface:
  *	For_Eval	Evaluate the loop in the passed line.
+ *
  *	For_Run		Run accumulated loop
  */
 #include "make.h"
 /*	"@(#)for.c	8.1 (Berkeley) 6/6/93"	*/
-MAKE_RCSID("$NetBSD: for.c,v 1.138 2021/01/25 19:39:34 rillig Exp $");
+MAKE_RCSID("$NetBSD: for.c,v 1.139 2021/01/30 20:53:29 rillig Exp $");
 /* One of the variables to the left of the "in" in a .for loop. */
 typedef struct ForVar {
 	char *name;
 	size_t nameLen;
 } ForVar;
 typedef struct ForLoop {
 	Buffer body;		/* Unexpanded body of the loop */
 	Vector /* of ForVar */ vars; /* Iteration variables */
 	Words items;		/* Substitution items */
 	Buffer curBody;		/* Expanded body of the current iteration */
 @@ -93,36 +93,36 @@ ForLoop_New(void)
 	Vector_Init(&f->vars, sizeof(ForVar));
 	f->items.words = NULL;
 	f->items.freeIt = NULL;
 	Buf_Init(&f->curBody);
 	f->short_var = FALSE;
 	f->sub_next = 0;
 	return f;
+}
 static void
 ForLoop_Free(ForLoop *f)
+{
-	Buf_Destroy(&f->body, TRUE);
+	Buf_Done(&f->body);
 	while (f->vars.len > 0) {
 		ForVar *var = Vector_Pop(&f->vars);
 		free(var->name);
+	}
 	Vector_Done(&f->vars);
 	Words_Free(f->items);
-	Buf_Destroy(&f->curBody, TRUE);
+	Buf_Done(&f->curBody);
 	free(f);
+}
 static void
 ForLoop_AddVar(ForLoop *f, const char *name, size_t len)
+{
 	ForVar *var = Vector_Push(&f->vars);
 	var->name = bmake_strldup(name, len);
 	var->nameLen = len;
+}
 static Boolean

 @@ -1,14 +1,14 @@
-/*	$NetBSD: main.c,v 1.517 2021/01/24 20:11:55 rillig Exp $	*/
+/*	$NetBSD: main.c,v 1.518 2021/01/30 20:53:29 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.
 @@ -100,27 +100,27 @@
 #include <errno.h>
 #include <signal.h>
 #include <stdarg.h>
 #include <time.h>
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #include "pathnames.h"
 #include "trace.h"
 /*	"@(#)main.c	8.3 (Berkeley) 3/19/94"	*/
-MAKE_RCSID("$NetBSD: main.c,v 1.517 2021/01/24 20:11:55 rillig Exp $");
+MAKE_RCSID("$NetBSD: main.c,v 1.518 2021/01/30 20:53:29 rillig Exp $");
 #if defined(MAKE_NATIVE) && !defined(lint)
 __COPYRIGHT("@(#) Copyright (c) 1988, 1989, 1990, 1993 "
 	    "The Regents of the University of California.  "
 	    "All rights reserved.");
 #endif
 CmdOpts opts;
 time_t now;			/* Time at start of make */
 GNode *defaultNode;		/* .DEFAULT node */
 Boolean allPrecious;		/* .PRECIOUS given on line by itself */
 Boolean deleteOnError;		/* .DELETE_ON_ERROR: set */
 static int maxJobTokens;	/* -j argument */
 @@ -1831,27 +1831,27 @@ Cmd_Exec(const char *cmd, const char **e
 				Buf_AddBytes(&buf, result, (size_t)bytes_read);
 		} while (bytes_read > 0 ||
 			 (bytes_read == -1 && errno == EINTR));
 		if (bytes_read == -1)
 			savederr = errno;
 		(void)close(pipefds[0]); /* Close the input side of the pipe. */
 		/* Wait for the process to exit. */
 		while ((pid = waitpid(cpid, &status, 0)) != cpid && pid >= 0)
 			JobReapChild(pid, status, FALSE);
 		res_len = Buf_Len(&buf);
-		res = Buf_Destroy(&buf, FALSE);
+		res = Buf_DoneData(&buf);
 		if (savederr != 0)
 			*errfmt = "Couldn't read shell's output for \"%s\"";
 		if (WIFSIGNALED(status))
 			*errfmt = "\"%s\" exited on a signal";
 		else if (WEXITSTATUS(status) != 0)
 			*errfmt = "\"%s\" returned non-zero status";
 		/* Convert newlines to spaces.  A final newline is just stripped */
 		if (res_len > 0 && res[res_len - 1] == '\n')
 			res[res_len - 1] = '\0';
 		for (cp = res; *cp != '\0'; cp++)
 @@ -2017,27 +2017,27 @@ execDie(const char *af, const char *av)
 	Buf_Init(&buf);
 	Buf_AddStr(&buf, progname);
 	Buf_AddStr(&buf, ": ");
 	Buf_AddStr(&buf, af);
 	Buf_AddStr(&buf, "(");
 	Buf_AddStr(&buf, av);
 	Buf_AddStr(&buf, ") failed (");
 	Buf_AddStr(&buf, strerror(errno));
 	Buf_AddStr(&buf, ")\n");
 	write_all(STDERR_FILENO, Buf_GetAll(&buf, NULL), Buf_Len(&buf));
-	Buf_Destroy(&buf, TRUE);
+	Buf_Done(&buf);
 	_exit(1);
+}
 /* purge any relative paths */
 static void
 purge_relative_cached_realpaths(void)
+{
 	HashEntry *he, *nhe;
 	HashIter hi;
 	HashIter_Init(&hi, &cached_realpaths);
 	he = HashIter_Next(&hi);
 	while (he != NULL) {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: parse.c,v 1.533 2021/01/27 00:02:38 rillig Exp $	*/
+/*	$NetBSD: parse.c,v 1.534 2021/01/30 20:53:29 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.
 @@ -99,27 +99,27 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <errno.h>
 #include <stdarg.h>
 #include <stdint.h>
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #include "pathnames.h"
 /*	"@(#)parse.c	8.3 (Berkeley) 3/19/94"	*/
-MAKE_RCSID("$NetBSD: parse.c,v 1.533 2021/01/27 00:02:38 rillig Exp $");
+MAKE_RCSID("$NetBSD: parse.c,v 1.534 2021/01/30 20:53:29 rillig Exp $");
 /* types and constants */
 /*
  * Structure for a file being read ("included file")
  */
 typedef struct IFile {
 	char *fname;		/* name of file (relative? absolute?) */
 	Boolean fromForLoop;	/* simulated .include by the .for loop */
 	int lineno;		/* current line number in file */
 	int first_lineno;	/* line number of start of text */
 	unsigned int cond_depth; /* 'if' nesting when file opened */
 	Boolean depending;	/* state of doing_depend on EOF */
 @@ -445,27 +445,27 @@ loadfile(const char *path, int fd)
 		buf.len += (size_t)n;
+	}
 	assert(buf.len <= buf.cap);
 	if (!Buf_EndsWith(&buf, '\n'))
 		Buf_AddByte(&buf, '\n');
 	if (path != NULL)
 		close(fd);
+	{
 		struct loadedfile *lf = loadedfile_create(path,
 		    buf.data, buf.len);
-		Buf_Destroy(&buf, FALSE);
+		Buf_DoneData(&buf);
 		return lf;
+	}
+}
 static void
 PrintStackTrace(void)
+{
 	const IFile *entries;
 	size_t i, n;
 	if (!(DEBUG(PARSE)))
 		return;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: var.c,v 1.783 2021/01/30 15:48:42 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.784 2021/01/30 20:53:29 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.783 2021/01/30 15:48:42 rillig Exp $");
+MAKE_RCSID("$NetBSD: var.c,v 1.784 2021/01/30 20:53:29 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
 @@ -446,27 +446,30 @@ VarFind(const char *name, GNode *ctxt, B
  *	v		the variable
  *	freeValue	true if the variable value should be freed as well
+ *
  * Results:
  *	TRUE if it is an environment variable, FALSE otherwise.
  */
 static Boolean
 VarFreeEnv(Var *v, Boolean freeValue)
+{
 	if (!(v->flags & VAR_FROM_ENV))
 		return FALSE;
 	FStr_Done(&v->name);
-	Buf_Destroy(&v->val, freeValue);
+	if (freeValue)
 		Buf_Done(&v->val);
 	else
 		Buf_DoneData(&v->val);
 	free(v);
 	return TRUE;
+}
 /*
  * Add a new variable of the given name and value to 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, VarSetFlags flags)
+{
 	HashEntry *he = HashTable_CreateEntry(&ctxt->vars, name, NULL);
 	Var *v = VarNew(FStr_InitRefer(/* aliased to */ he->key), val,
 @@ -489,27 +492,27 @@ Var_DeleteVar(const char *varname, GNode
 	if (he == NULL) {
 		DEBUG2(VAR, "%s:delete %s (not found)\n", ctxt->name, varname);
 		return;
+	}
 	DEBUG2(VAR, "%s:delete %s\n", ctxt->name, varname);
 	v = HashEntry_Get(he);
 	if (v->flags & VAR_EXPORTED)
 		unsetenv(v->name.str);
 	if (strcmp(v->name.str, MAKE_EXPORTED) == 0)
 		var_exportedVars = VAR_EXPORTED_NONE;
 	assert(v->name.freeIt == NULL);
 	HashTable_DeleteEntry(&ctxt->vars, he);
-	Buf_Destroy(&v->val, TRUE);
+	Buf_Done(&v->val);
 	free(v);
+}
 /*
  * Remove a variable from a context, freeing all related memory as well.
  * The variable name is expanded once.
  */
 void
 Var_Delete(const char *name, GNode *ctxt)
+{
 	FStr varname = FStr_InitRefer(name);
 	if (strchr(varname.str, '$') != NULL) {
 @@ -1204,29 +1207,29 @@ SepBuf_AddBytes(SepBuf *buf, const char
 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)
+SepBuf_DoneData(SepBuf *buf)
+{
-	return Buf_Destroy(&buf->buf, free_buf);
+	return Buf_DoneData(&buf->buf);
+}
 /*
  * This callback for ModifyWords gets a single word from a variable expression
  * and typically adds a modification of this word to the buffer. It may also
  * do nothing or add several words.
+ *
  * For example, in ${:Ua b c:M*2}, the callback is called 3 times, once for
  * each word of "a b c".
  */
 typedef void (*ModifyWordsCallback)(const char *word, SepBuf *buf, void *data);
 @@ -1676,27 +1679,27 @@ VarSelectWords(char sep, Boolean oneBigW
 	} else {
 		start = first < 1 ? 0 : first - 1;
 		end = last > len ? len : last;
 		step = 1;
+	}
 	for (i = start; (step < 0) == (i >= end); i += step) {
 		SepBuf_AddStr(&buf, words.words[i]);
 		SepBuf_Sep(&buf);
+	}
 	Words_Free(words);
-	return SepBuf_Destroy(&buf, FALSE);
+	return SepBuf_DoneData(&buf);
+}
 /*
  * Callback for ModifyWords to implement the :tA modifier.
  * Replace each word with the result of realpath() if successful.
  */
 /*ARGSUSED*/
 static void
 ModifyWord_Realpath(const char *word, SepBuf *buf, void *data MAKE_ATTR_UNUSED)
+{
 	struct stat st;
 	char rbuf[MAXPATHLEN];
 @@ -1721,67 +1724,67 @@ ModifyWord_Realpath(const char *word, Se
  */
 static char *
 ModifyWords(const char *str,
 	    ModifyWordsCallback modifyWord, void *modifyWord_args,
 	    Boolean oneBigWord, char sep)
+{
 	SepBuf result;
 	Words words;
 	size_t i;
 	if (oneBigWord) {
 		SepBuf_Init(&result, sep);
 		modifyWord(str, &result, modifyWord_args);
-		return SepBuf_Destroy(&result, FALSE);
+		return SepBuf_DoneData(&result);
+	}
 	SepBuf_Init(&result, sep);
 	words = Str_Words(str, FALSE);
 	DEBUG2(VAR, "ModifyWords: split \"%s\" into %u words\n",
 	    str, (unsigned)words.len);
 	for (i = 0; i < words.len; i++) {
 		modifyWord(words.words[i], &result, modifyWord_args);
 		if (Buf_Len(&result.buf) > 0)
 			SepBuf_Sep(&result);
+	}
 	Words_Free(words);
-	return SepBuf_Destroy(&result, FALSE);
+	return SepBuf_DoneData(&result);
+}
 static char *
 Words_JoinFree(Words words)
+{
 	Buffer buf;
 	size_t i;
 	Buf_Init(&buf);
 	for (i = 0; i < words.len; i++) {
 		if (i != 0) {
 			/* XXX: Use st->sep instead of ' ', for consistency. */
 			Buf_AddByte(&buf, ' ');
+		}
 		Buf_AddStr(&buf, words.words[i]);
+	}
 	Words_Free(words);
-	return Buf_Destroy(&buf, FALSE);
+	return Buf_DoneData(&buf);
+}
 /* Remove adjacent duplicate words. */
 static char *
 VarUniq(const char *str)
+{
 	Words words = Str_Words(str, FALSE);
 	if (words.len > 1) {
 		size_t i, j;
 		for (j = 0, i = 1; i < words.len; i++)
 			if (strcmp(words.words[i], words.words[j]) != 0 &&
 			    (++j != i))
 @@ -1808,27 +1811,27 @@ VarQuote(const char *str, Boolean quoteD
 			const char *newline = Shell_GetNewline();
 			if (newline == NULL)
 				newline = "\\\n";
 			Buf_AddStr(&buf, newline);
 			continue;
+		}
 		if (ch_isspace(*str) || is_shell_metachar((unsigned char)*str))
 			Buf_AddByte(&buf, '\\');
 		Buf_AddByte(&buf, *str);
 		if (quoteDollar && *str == '$')
 			Buf_AddStr(&buf, "\\$");
+	}
-	return Buf_Destroy(&buf, FALSE);
+	return Buf_DoneData(&buf);
+}
 /*
  * Compute the 32-bit hash of the given string, using the MurmurHash3
  * algorithm. Output is encoded as 8 hex digits, in Little Endian order.
  */
 static char *
 VarHash(const char *str)
+{
 	static const char hexdigits[16] = "0123456789abcdef";
 	const unsigned char *ustr = (const unsigned char *)str;
 	uint32_t h = 0x971e137bU;
 @@ -2154,27 +2157,27 @@ ParseModifierPartSubst(
 	if (*p != delim) {
 		*pp = p;
 		Error("Unfinished modifier for %s ('%c' missing)",
 		    st->var->name.str, delim);
 		*out_part = NULL;
 		return VPR_ERR;
+	}
 	*pp = ++p;
 	if (out_length != NULL)
 		*out_length = Buf_Len(&buf);
-	*out_part = Buf_Destroy(&buf, FALSE);
+	*out_part = Buf_DoneData(&buf);
 	DEBUG1(VAR, "Modifier part: \"%s\"\n", *out_part);
 	return VPR_OK;
+}
 /*
  * Parse a part of a modifier such as the "from" and "to" in :S/from/to/ or
  * the "var" or "replacement ${var}" in :@var@replacement ${var}@, up to and
  * including the next unescaped delimiter.  The delimiter, as well as the
  * backslash or the dollar, can be escaped with a backslash.
+ *
  * Return the parsed (and possibly expanded) string, or NULL if no delimiter
  * was found.  On successful return, the parsing position pp points right
  * after the delimiter.  The delimiter is not included in the returned
 @@ -2355,30 +2358,30 @@ ApplyModifier_Defined(const char **pp, c
 			FStr_Done(&nested_val);
 			continue;
+		}
 		/* Ordinary text */
 		Buf_AddByte(&buf, *p);
 		p++;
+	}
 	*pp = p;
 	ApplyModifiersState_Define(st);
 	if (eflags & VARE_WANTRES) {
-		st->newVal = FStr_InitOwn(Buf_Destroy(&buf, FALSE));
+		st->newVal = FStr_InitOwn(Buf_DoneData(&buf));
 	} else {
 		st->newVal = FStr_InitRefer(val);
-		Buf_Destroy(&buf, TRUE);
+		Buf_Done(&buf);
+	}
 	return AMR_OK;
+}
 /* :L */
 static ApplyModifierResult
 ApplyModifier_Literal(const char **pp, ApplyModifiersState *st)
+{
 	ApplyModifiersState_Define(st);
 	st->newVal = FStr_InitOwn(bmake_strdup(st->var->name.str));
 	(*pp)++;
 	return AMR_OK;
+}
 @@ -2553,27 +2556,27 @@ ApplyModifier_Range(const char **pp, con
 		Words_Free(words);
+	}
 	Buf_Init(&buf);
 	for (i = 0; i < n; i++) {
 		if (i != 0) {
 			/* XXX: Use st->sep instead of ' ', for consistency. */
 			Buf_AddByte(&buf, ' ');
+		}
 		Buf_AddInt(&buf, 1 + (int)i);
+	}
-	st->newVal = FStr_InitOwn(Buf_Destroy(&buf, FALSE));
+	st->newVal = FStr_InitOwn(Buf_DoneData(&buf));
 	return AMR_OK;
+}
 /* :Mpattern or :Npattern */
 static ApplyModifierResult
 ApplyModifier_Match(const char **pp, const char *val, ApplyModifiersState *st)
+{
 	const char *mod = *pp;
 	Boolean copy = FALSE;	/* pattern should be, or has been, copied */
 	Boolean needSubst = FALSE;
 	const char *endpat;
 	char *pattern;
 	ModifyWordsCallback callback;
 @@ -2978,27 +2981,27 @@ ApplyModifier_Words(const char **pp, con
 	if (estr[0] == '#' && estr[1] == '\0') { /* Found ":[#]" */
 		if (st->oneBigWord) {
 			st->newVal = FStr_InitRefer("1");
 		} else {
 			Buffer buf;
 			Words words = Str_Words(val, FALSE);
 			size_t ac = words.len;
 			Words_Free(words);
 			/* 3 digits + '\0' is usually enough */
 			Buf_InitSize(&buf, 4);
 			Buf_AddInt(&buf, (int)ac);
-			st->newVal = FStr_InitOwn(Buf_Destroy(&buf, FALSE));
+			st->newVal = FStr_InitOwn(Buf_DoneData(&buf));
+		}
 		goto ok;
+	}
 	if (estr[0] == '*' && estr[1] == '\0') {
 		/* Found ":[*]" */
 		st->oneBigWord = TRUE;
 		st->newVal = FStr_InitRefer(val);
 		goto ok;
+	}
 	if (estr[0] == '@' && estr[1] == '\0') {
 		/* Found ":[@]" */
 @@ -3793,27 +3796,27 @@ ParseVarname(const char **pp, char start
 		if (*p == '$') {
 			FStr nested_val;
 			(void)Var_Parse(&p, ctxt, eflags, &nested_val);
 			/* TODO: handle errors */
 			Buf_AddStr(&buf, nested_val.str);
 			FStr_Done(&nested_val);
 		} else {
 			Buf_AddByte(&buf, *p);
 			p++;
+		}
+	}
 	*pp = p;
 	*out_varname_len = Buf_Len(&buf);
-	return Buf_Destroy(&buf, FALSE);
+	return Buf_DoneData(&buf);
+}
 static VarParseResult
 ValidShortVarname(char varname, const char *start)
+{
 	switch (varname) {
 	case '\0':
 	case ')':
 	case '}':
 	case ':':
 	case '$':
 		break;		/* and continue below */
 	default:
 @@ -4060,27 +4063,27 @@ ParseVarnameLong(
 	*out_TRUE_endc = endc;
 	*out_TRUE_p = p;
 	*out_TRUE_v = v;
 	*out_TRUE_haveModifier = haveModifier;
 	*out_TRUE_dynamic = dynamic;
 	return TRUE;
+}
 /* Free the environment variable now since we own it. */
 static void
 FreeEnvVar(void **out_val_freeIt, Var *v, const char *value)
+{
-	char *varValue = Buf_Destroy(&v->val, FALSE);
+	char *varValue = Buf_DoneData(&v->val);
 	if (value == varValue)
 		*out_val_freeIt = varValue;
 	else
 		free(varValue);
 	FStr_Done(&v->name);
 	free(v);
+}
 /*
  * Given the start of a variable expression (such as $v, $(VAR),
  * ${VAR:Mpattern}), extract the variable name and value, and the modifiers,
  * if any.  While doing that, apply the modifiers to the value of the
 @@ -4231,27 +4234,27 @@ Var_Parse(const char **pp, GNode *ctxt,
 			if (dynamic) {
 				value = FStr_InitOwn(bmake_strsedup(start, p));
 			} else {
 				/*
 				 * The expression is still undefined,
 				 * therefore discard the actual value and
 				 * return an error marker instead.
 				 */
 				value = FStr_InitRefer(eflags & VARE_UNDEFERR
 				    ? var_Error : varUndefined);
+			}
+		}
 		if (value.str != Buf_GetAll(&v->val, NULL))
-			Buf_Destroy(&v->val, TRUE);
+			Buf_Done(&v->val);
 		FStr_Done(&v->name);
 		free(v);
+	}
 	*out_val = (FStr){ value.str, value.freeIt };
 	return VPR_OK;		/* XXX: Is not correct in all cases */
+}
 static void
 VarSubstDollarDollar(const char **pp, Buffer *res, VarEvalFlags eflags)
+{
 	/*
 	 * A dollar sign may be escaped with another dollar
 	 * sign.
 @@ -4355,27 +4358,27 @@ Var_Subst(const char *str, GNode *ctxt,
 	Buf_Init(&res);
 	errorReported = FALSE;
 	while (*p != '\0') {
 		if (p[0] == '$' && p[1] == '$')
 			VarSubstDollarDollar(&p, &res, eflags);
 		else if (p[0] == '$')
 			VarSubstExpr(&p, &res, ctxt, eflags, &errorReported);
 		else
 			VarSubstPlain(&p, &res);
+	}
-	*out_res = Buf_DestroyCompact(&res);
+	*out_res = Buf_DoneDataCompact(&res);
 	return VPR_OK;
+}
 /* Initialize the variables module. */
 void
 Var_Init(void)
+{
 	VAR_INTERNAL = GNode_New("Internal");
 	VAR_GLOBAL = GNode_New("Global");
 	VAR_CMDLINE = GNode_New("Command");
+}
 /* Clean up the variables module. */