 @@ -1,1122 +1,1121 @@
-/*	$NetBSD: arch.c,v 1.147 2020/10/25 19:19:07 rillig Exp $	*/
+/*	$NetBSD: arch.c,v 1.148 2020/10/30 16:48:58 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.
  * 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.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * 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.
  */
 /*
  * Copyright (c) 1989 by Berkeley Softworks
  * 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.
  * 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.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by the University of
  *	California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * 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.
  */
 /*-
  * arch.c --
  *	Functions to manipulate libraries, archives and their members.
+ *
  *	Once again, cacheing/hashing comes into play in the manipulation
  * of archives. The first time an archive is referenced, all of its members'
  * headers are read and hashed and the archive closed again. All hashed
  * archives are kept on a list which is searched each time an archive member
  * is referenced.
+ *
  * The interface to this module is:
  *	Arch_ParseArchive
  *			Given an archive specification, return a list
  *			of GNode's, one for each member in the spec.
  *			FALSE is returned if the specification is
  *			invalid for some reason.
+ *
  *	Arch_Touch	Alter the modification time of the archive
  *			member described by the given node to be
  *			the current time.
+ *
  *	Arch_TouchLib	Update the modification time of the library
  *			described by the given node. This is special
  *			because it also updates the modification time
  *			of the library's table of contents.
+ *
  *	Arch_MTime	Find the modification time of a member of
  *			an archive *in the archive*. The time is also
  *			placed in the member's GNode. Returns the
  *			modification time.
+ *
  *	Arch_MemTime	Find the modification time of a member of
  *			an archive. Called when the member doesn't
  *			already exist. Looks in the archive for the
  *			modification time. Returns the modification
  *			time.
+ *
  *	Arch_FindLib	Search for a library along a path. The
  *			library name in the GNode should be in
  *			-l<name> format.
+ *
  *	Arch_LibOODate	Special function to decide if a library node
  *			is out-of-date.
+ *
  *	Arch_Init	Initialize this module.
+ *
  *	Arch_End	Clean up this module.
  */
 #include    <sys/types.h>
 #include    <sys/stat.h>
 #include    <sys/time.h>
 #include    <sys/param.h>
 #include    <ar.h>
 #include    <utime.h>
 #include    "make.h"
 #include    "dir.h"
 #include    "config.h"
 /*	"@(#)arch.c	8.2 (Berkeley) 1/2/94"	*/
-MAKE_RCSID("$NetBSD: arch.c,v 1.147 2020/10/25 19:19:07 rillig Exp $");
+MAKE_RCSID("$NetBSD: arch.c,v 1.148 2020/10/30 16:48:58 rillig Exp $");
 #ifdef TARGET_MACHINE
 #undef MAKE_MACHINE
 #define MAKE_MACHINE TARGET_MACHINE
 #endif
 #ifdef TARGET_MACHINE_ARCH
 #undef MAKE_MACHINE_ARCH
 #define MAKE_MACHINE_ARCH TARGET_MACHINE_ARCH
 #endif
 typedef struct List ArchList;
 typedef struct ListNode ArchListNode;
 static ArchList *archives;	/* The archives we've already examined */
 typedef struct Arch {
     char *name;			/* Name of archive */
     HashTable members;		/* All the members of the archive described
 				 * by <name, struct ar_hdr *> key/value pairs */
     char *fnametab;		/* Extended name table strings */
     size_t fnamesize;		/* Size of the string table */
 } Arch;
 static FILE *ArchFindMember(const char *, const char *,
 			    struct ar_hdr *, const char *);
 #if defined(__svr4__) || defined(__SVR4) || defined(__ELF__)
 #define SVR4ARCHIVES
 static int ArchSVR4Entry(Arch *, char *, size_t, FILE *);
 #endif
 #ifdef CLEANUP
 static void
 ArchFree(void *ap)
+{
     Arch *a = ap;
     HashIter hi;
     HashEntry *he;
     /* Free memory from hash entries */
     HashIter_Init(&hi, &a->members);
-    while ((he = HashIter_Next(&hi)) != NULL)
+    while (HashIter_Next(&hi) != NULL)
-	free(HashEntry_Get(he));
+	free(hi.entry->value);
     free(a->name);
     free(a->fnametab);
     HashTable_Done(&a->members);
     free(a);
+}
 #endif
 /*-
  *-----------------------------------------------------------------------
  * Arch_ParseArchive --
  *	Parse the archive specification in the given line and find/create
  *	the nodes for the specified archive members, placing their nodes
  *	on the given list.
+ *
  * Input:
  *	linePtr		Pointer to start of specification
  *	nodeLst		Lst on which to place the nodes
  *	ctxt		Context in which to expand variables
+ *
  * Results:
  *	TRUE if it was a valid specification. The linePtr is updated
  *	to point to the first non-space after the archive spec. The
  *	nodes for the members are placed on the given list.
  *-----------------------------------------------------------------------
  */
 Boolean
 Arch_ParseArchive(char **linePtr, GNodeList *nodeLst, GNode *ctxt)
+{
     char *cp;			/* Pointer into line */
     GNode *gn;			/* New node */
     char *libName;		/* Library-part of specification */
     char *memName;		/* Member-part of specification */
     char saveChar;		/* Ending delimiter of member-name */
     Boolean subLibName;		/* TRUE if libName should have/had
 				 * variable substitution performed on it */
     libName = *linePtr;
     subLibName = FALSE;
     for (cp = libName; *cp != '(' && *cp != '\0';) {
 	if (*cp == '$') {
 	    /*
 	     * Variable spec, so call the Var module to parse the puppy
 	     * so we can safely advance beyond it...
 	     */
 	    const char *nested_p = cp;
 	    void *result_freeIt;
 	    const char *result;
 	    Boolean isError;
 	    (void)Var_Parse(&nested_p, ctxt, VARE_UNDEFERR|VARE_WANTRES,
 			    &result, &result_freeIt);
 	    /* TODO: handle errors */
 	    isError = result == var_Error;
 	    free(result_freeIt);
 	    if (isError)
 		return FALSE;
 	    subLibName = TRUE;
 	    cp += nested_p - cp;
 	} else
 	    cp++;
+    }
     *cp++ = '\0';
     if (subLibName) {
 	(void)Var_Subst(libName, ctxt, VARE_UNDEFERR|VARE_WANTRES, &libName);
 	/* TODO: handle errors */
+    }
     for (;;) {
 	/*
 	 * First skip to the start of the member's name, mark that
 	 * place and skip to the end of it (either white-space or
 	 * a close paren).
 	 */
 	Boolean doSubst = FALSE; /* TRUE if need to substitute in memName */
 	pp_skip_whitespace(&cp);
 	memName = cp;
 	while (*cp != '\0' && *cp != ')' && !ch_isspace(*cp)) {
 	    if (*cp == '$') {
 		/*
 		 * Variable spec, so call the Var module to parse the puppy
 		 * so we can safely advance beyond it...
 		 */
 		void *freeIt;
 		const char *result;
 		Boolean isError;
 		const char *nested_p = cp;
 		(void)Var_Parse(&nested_p, ctxt, VARE_UNDEFERR|VARE_WANTRES,
 				&result, &freeIt);
 		/* TODO: handle errors */
 		isError = result == var_Error;
 		free(freeIt);
 		if (isError)
 		    return FALSE;
 		doSubst = TRUE;
 		cp += nested_p - cp;
 	    } else {
 		cp++;
+	    }
+	}
 	/*
 	 * If the specification ends without a closing parenthesis,
 	 * chances are there's something wrong (like a missing backslash),
 	 * so it's better to return failure than allow such things to happen
 	 */
 	if (*cp == '\0') {
 	    printf("No closing parenthesis in archive specification\n");
 	    return FALSE;
+	}
 	/*
 	 * If we didn't move anywhere, we must be done
 	 */
 	if (cp == memName) {
 	    break;
+	}
 	saveChar = *cp;
 	*cp = '\0';
 	/*
 	 * XXX: This should be taken care of intelligently by
 	 * SuffExpandChildren, both for the archive and the member portions.
 	 */
 	/*
 	 * If member contains variables, try and substitute for them.
 	 * This will slow down archive specs with dynamic sources, of course,
 	 * since we'll be (non-)substituting them three times, but them's
 	 * the breaks -- we need to do this since SuffExpandChildren calls
 	 * us, otherwise we could assume the thing would be taken care of
 	 * later.
 	 */
 	if (doSubst) {
 	    char *buf;
 	    char *sacrifice;
 	    char *oldMemName = memName;
 	    (void)Var_Subst(memName, ctxt, VARE_UNDEFERR|VARE_WANTRES,
 			    &memName);
 	    /* TODO: handle errors */
 	    /*
 	     * Now form an archive spec and recurse to deal with nested
 	     * variables and multi-word variable values.... The results
 	     * are just placed at the end of the nodeLst we're returning.
 	     */
 	    buf = sacrifice = str_concat4(libName, "(", memName, ")");
 	    if (strchr(memName, '$') && strcmp(memName, oldMemName) == 0) {
 		/*
 		 * Must contain dynamic sources, so we can't deal with it now.
 		 * Just create an ARCHV node for the thing and let
 		 * SuffExpandChildren handle it...
 		 */
 		gn = Targ_GetNode(buf);
 		gn->type |= OP_ARCHV;
 		Lst_Append(nodeLst, gn);
 	    } else if (!Arch_ParseArchive(&sacrifice, nodeLst, ctxt)) {
 		/* Error in nested call. */
 		free(buf);
 		return FALSE;
+	    }
 	    free(buf);
 	} else if (Dir_HasWildcards(memName)) {
 	    StringList *members = Lst_New();
 	    Dir_Expand(memName, dirSearchPath, members);
 	    while (!Lst_IsEmpty(members)) {
 		char *member = Lst_Dequeue(members);
 		char *fullname = str_concat4(libName, "(", member, ")");
 		free(member);
 		gn = Targ_GetNode(fullname);
 		free(fullname);
 		gn->type |= OP_ARCHV;
 		Lst_Append(nodeLst, gn);
+	    }
 	    Lst_Free(members);
 	} else {
 	    char *fullname = str_concat4(libName, "(", memName, ")");
 	    gn = Targ_GetNode(fullname);
 	    free(fullname);
 	    /*
 	     * We've found the node, but have to make sure the rest of the
 	     * world knows it's an archive member, without having to
 	     * constantly check for parentheses, so we type the thing with
 	     * the OP_ARCHV bit before we place it on the end of the
 	     * provided list.
 	     */
 	    gn->type |= OP_ARCHV;
 	    Lst_Append(nodeLst, gn);
+	}
 	if (doSubst) {
 	    free(memName);
+	}
 	*cp = saveChar;
+    }
     /*
      * If substituted libName, free it now, since we need it no longer.
      */
     if (subLibName) {
 	free(libName);
+    }
     cp++;			/* skip the ')' */
     /* We promised that linePtr would be set up at the next non-space. */
     pp_skip_whitespace(&cp);
     *linePtr = cp;
     return TRUE;
+}
 /* Locate a member of an archive, given the path of the archive and the path
  * of the desired member.
+ *
  * Input:
  *	archive		Path to the archive
  *	member		Name of member; only its basename is used.
  *	hash		TRUE if archive should be hashed if not already so.
+ *
  * Results:
  *	The ar_hdr for the member.
  */
 static struct ar_hdr *
 ArchStatMember(const char *archive, const char *member, Boolean hash)
+{
 #define AR_MAX_NAME_LEN (sizeof(arh.ar_name) - 1)
     FILE *arch;			/* Stream to archive */
     size_t size;		/* Size of archive member */
     char magic[SARMAG];
     ArchListNode *ln;
     Arch *ar;			/* Archive descriptor */
     struct ar_hdr arh;		/* archive-member header for reading archive */
     char memName[MAXPATHLEN + 1];
 				/* Current member name while hashing. */
     /*
      * Because of space constraints and similar things, files are archived
      * using their basename, not the entire path.
      */
     const char *lastSlash = strrchr(member, '/');
     if (lastSlash != NULL)
 	member = lastSlash + 1;
     for (ln = archives->first; ln != NULL; ln = ln->next) {
 	const Arch *archPtr = ln->datum;
 	if (strcmp(archPtr->name, archive) == 0)
 	    break;
+    }
     if (ln != NULL) {
 	struct ar_hdr *hdr;
 	ar = ln->datum;
 	hdr = HashTable_FindValue(&ar->members, member);
 	if (hdr != NULL)
 	    return hdr;
+	{
 	    /* Try truncated name */
 	    char copy[AR_MAX_NAME_LEN + 1];
 	    size_t len = strlen(member);
 	    if (len > AR_MAX_NAME_LEN) {
 		len = AR_MAX_NAME_LEN;
 		snprintf(copy, sizeof copy, "%s", member);
+	    }
 	    hdr = HashTable_FindValue(&ar->members, copy);
 	    return hdr;
+	}
+    }
     if (!hash) {
 	/*
 	 * Caller doesn't want the thing hashed, just use ArchFindMember
 	 * to read the header for the member out and close down the stream
 	 * again. Since the archive is not to be hashed, we assume there's
 	 * no need to allocate extra room for the header we're returning,
 	 * so just declare it static.
 	 */
 	static struct ar_hdr sarh;
 	arch = ArchFindMember(archive, member, &sarh, "r");
 	if (arch == NULL)
 	    return NULL;
 	fclose(arch);
 	return &sarh;
+    }
     /*
      * We don't have this archive on the list yet, so we want to find out
      * everything that's in it and cache it so we can get at it quickly.
      */
     arch = fopen(archive, "r");
     if (arch == NULL)
 	return NULL;
     /*
      * We use the ARMAG string to make sure this is an archive we
      * can handle...
      */
     if ((fread(magic, SARMAG, 1, arch) != 1) ||
 	(strncmp(magic, ARMAG, SARMAG) != 0)) {
 	fclose(arch);
 	return NULL;
+    }
     ar = bmake_malloc(sizeof(Arch));
     ar->name = bmake_strdup(archive);
     ar->fnametab = NULL;
     ar->fnamesize = 0;
     HashTable_Init(&ar->members);
     memName[AR_MAX_NAME_LEN] = '\0';
     while (fread((char *)&arh, sizeof(struct ar_hdr), 1, arch) == 1) {
 	if (strncmp(arh.ar_fmag, ARFMAG, sizeof(arh.ar_fmag)) != 0) {
 	    /*
 	     * The header is bogus, so the archive is bad
 	     * and there's no way we can recover...
 	     */
 	    goto badarch;
 	} else {
 	    char *nameend;
 	    /*
 	     * We need to advance the stream's pointer to the start of the
 	     * next header. Files are padded with newlines to an even-byte
 	     * boundary, so we need to extract the size of the file from the
 	     * 'size' field of the header and round it up during the seek.
 	     */
 	    arh.ar_size[sizeof(arh.ar_size) - 1] = '\0';
 	    size = (size_t)strtol(arh.ar_size, NULL, 10);
 	    memcpy(memName, arh.ar_name, sizeof(arh.ar_name));
 	    nameend = memName + AR_MAX_NAME_LEN;
 	    while (*nameend == ' ') {
 		nameend--;
+	    }
 	    nameend[1] = '\0';
 #ifdef SVR4ARCHIVES
 	    /*
 	     * svr4 names are slash terminated. Also svr4 extended AR format.
 	     */
 	    if (memName[0] == '/') {
 		/*
 		 * svr4 magic mode; handle it
 		 */
 		switch (ArchSVR4Entry(ar, memName, size, arch)) {
 		case -1:	/* Invalid data */
 		    goto badarch;
 		case 0:		/* List of files entry */
 		    continue;
 		default:	/* Got the entry */
 		    break;
+		}
 	    } else {
 		if (nameend[0] == '/')
 		    nameend[0] = '\0';
+	    }
 #endif
 #ifdef AR_EFMT1
 	    /*
 	     * BSD 4.4 extended AR format: #1/<namelen>, with name as the
 	     * first <namelen> bytes of the file
 	     */
 	    if (strncmp(memName, AR_EFMT1, sizeof(AR_EFMT1) - 1) == 0 &&
 		ch_isdigit(memName[sizeof(AR_EFMT1) - 1])) {
 		int elen = atoi(&memName[sizeof(AR_EFMT1) - 1]);
 		if ((unsigned int)elen > MAXPATHLEN)
 		    goto badarch;
 		if (fread(memName, (size_t)elen, 1, arch) != 1)
 		    goto badarch;
 		memName[elen] = '\0';
 		if (fseek(arch, -elen, SEEK_CUR) != 0)
 		    goto badarch;
 		if (DEBUG(ARCH) || DEBUG(MAKE)) {
 		    debug_printf("ArchStat: Extended format entry for %s\n",
 				 memName);
+		}
+	    }
 #endif
+	    {
 		HashEntry *he;
 		he = HashTable_CreateEntry(&ar->members, memName, NULL);
 		HashEntry_Set(he, bmake_malloc(sizeof(struct ar_hdr)));
 		memcpy(HashEntry_Get(he), &arh, sizeof(struct ar_hdr));
+	    }
+	}
 	if (fseek(arch, ((long)size + 1) & ~1, SEEK_CUR) != 0)
 	    goto badarch;
+    }
     fclose(arch);
     Lst_Append(archives, ar);
     /*
      * Now that the archive has been read and cached, we can look into
      * the hash table to find the desired member's header.
      */
     return HashTable_FindValue(&ar->members, member);
 badarch:
     fclose(arch);
     HashTable_Done(&ar->members);
     free(ar->fnametab);
     free(ar);
     return NULL;
+}
 #ifdef SVR4ARCHIVES
 /*-
  *-----------------------------------------------------------------------
  * ArchSVR4Entry --
  *	Parse an SVR4 style entry that begins with a slash.
  *	If it is "//", then load the table of filenames
  *	If it is "/<offset>", then try to substitute the long file name
  *	from offset of a table previously read.
  *	If a table is read, the file pointer is moved to the next archive
  *	member.
+ *
  * Results:
  *	-1: Bad data in archive
  *	 0: A table was loaded from the file
  *	 1: Name was successfully substituted from table
  *	 2: Name was not successfully substituted from table
  *-----------------------------------------------------------------------
  */
 static int
 ArchSVR4Entry(Arch *ar, char *name, size_t size, FILE *arch)
+{
 #define ARLONGNAMES1 "//"
 #define ARLONGNAMES2 "/ARFILENAMES"
     size_t entry;
     char *ptr, *eptr;
     if (strncmp(name, ARLONGNAMES1, sizeof(ARLONGNAMES1) - 1) == 0 ||
 	strncmp(name, ARLONGNAMES2, sizeof(ARLONGNAMES2) - 1) == 0) {
 	if (ar->fnametab != NULL) {
 	    DEBUG0(ARCH, "Attempted to redefine an SVR4 name table\n");
 	    return -1;
+	}
 	/*
 	 * This is a table of archive names, so we build one for
 	 * ourselves
 	 */
 	ar->fnametab = bmake_malloc(size);
 	ar->fnamesize = size;
 	if (fread(ar->fnametab, size, 1, arch) != 1) {
 	    DEBUG0(ARCH, "Reading an SVR4 name table failed\n");
 	    return -1;
+	}
 	eptr = ar->fnametab + size;
 	for (entry = 0, ptr = ar->fnametab; ptr < eptr; ptr++)
 	    if (*ptr == '/') {
 		entry++;
 		*ptr = '\0';
+	    }
 	DEBUG1(ARCH, "Found svr4 archive name table with %lu entries\n",
 	       (unsigned long)entry);
 	return 0;
+    }
     if (name[1] == ' ' || name[1] == '\0')
 	return 2;
     entry = (size_t)strtol(&name[1], &eptr, 0);
     if ((*eptr != ' ' && *eptr != '\0') || eptr == &name[1]) {
 	DEBUG1(ARCH, "Could not parse SVR4 name %s\n", name);
 	return 2;
+    }
     if (entry >= ar->fnamesize) {
 	DEBUG2(ARCH, "SVR4 entry offset %s is greater than %lu\n",
 	       name, (unsigned long)ar->fnamesize);
 	return 2;
+    }
     DEBUG2(ARCH, "Replaced %s with %s\n", name, &ar->fnametab[entry]);
     snprintf(name, MAXPATHLEN + 1, "%s", &ar->fnametab[entry]);
     return 1;
+}
 #endif
 /*-
  *-----------------------------------------------------------------------
  * ArchFindMember --
  *	Locate a member of an archive, given the path of the archive and
  *	the path of the desired member. If the archive is to be modified,
  *	the mode should be "r+", if not, it should be "r".
  *	The passed struct ar_hdr structure is filled in.
+ *
  * Input:
  *	archive		Path to the archive
  *	member		Name of member. If it is a path, only the last
  *			component is used.
  *	arhPtr		Pointer to header structure to be filled in
  *	mode		The mode for opening the stream
+ *
  * Results:
  *	An FILE *, opened for reading and writing, positioned at the
  *	start of the member's struct ar_hdr, or NULL if the member was
  *	nonexistent. The current struct ar_hdr for member.
  *-----------------------------------------------------------------------
  */
 static FILE *
 ArchFindMember(const char *archive, const char *member, struct ar_hdr *arhPtr,
 	       const char *mode)
+{
     FILE *arch;			/* Stream to archive */
     int size;			/* Size of archive member */
     char magic[SARMAG];
     size_t len, tlen;
     const char *lastSlash;
     arch = fopen(archive, mode);
     if (arch == NULL)
 	return NULL;
     /*
      * We use the ARMAG string to make sure this is an archive we
      * can handle...
      */
     if ((fread(magic, SARMAG, 1, arch) != 1) ||
 	(strncmp(magic, ARMAG, SARMAG) != 0)) {
 	fclose(arch);
 	return NULL;
+    }
     /*
      * Because of space constraints and similar things, files are archived
      * using their basename, not the entire path.
      */
     lastSlash = strrchr(member, '/');
     if (lastSlash != NULL)
 	member = lastSlash + 1;
     len = tlen = strlen(member);
     if (len > sizeof(arhPtr->ar_name)) {
 	tlen = sizeof(arhPtr->ar_name);
+    }
     while (fread((char *)arhPtr, sizeof(struct ar_hdr), 1, arch) == 1) {
 	if (strncmp(arhPtr->ar_fmag, ARFMAG, sizeof(arhPtr->ar_fmag)) != 0) {
 	    /*
 	     * The header is bogus, so the archive is bad
 	     * and there's no way we can recover...
 	     */
 	    fclose(arch);
 	    return NULL;
+	}
 	if (strncmp(member, arhPtr->ar_name, tlen) == 0) {
 	    /*
 	     * If the member's name doesn't take up the entire 'name' field,
 	     * we have to be careful of matching prefixes. Names are space-
 	     * padded to the right, so if the character in 'name' at the end
 	     * of the matched string is anything but a space, this isn't the
 	     * member we sought.
 	     */
 	    if (tlen != sizeof arhPtr->ar_name && arhPtr->ar_name[tlen] != ' ')
 		goto skip;
 	    /*
 	     * To make life easier, we reposition the file at the start
 	     * of the header we just read before we return the stream.
 	     * In a more general situation, it might be better to leave
 	     * the file at the actual member, rather than its header, but
 	     * not here...
 	     */
 	    if (fseek(arch, -(long)sizeof(struct ar_hdr), SEEK_CUR) != 0) {
 		fclose(arch);
 		return NULL;
+	    }
 	    return arch;
+	}
 #ifdef AR_EFMT1
 	/*
 	 * BSD 4.4 extended AR format: #1/<namelen>, with name as the
 	 * first <namelen> bytes of the file
 	 */
 	if (strncmp(arhPtr->ar_name, AR_EFMT1, sizeof(AR_EFMT1) - 1) == 0 &&
 	    ch_isdigit(arhPtr->ar_name[sizeof(AR_EFMT1) - 1]))
+	{
 	    int elen = atoi(&arhPtr->ar_name[sizeof(AR_EFMT1) - 1]);
 	    char ename[MAXPATHLEN + 1];
 	    if ((unsigned int)elen > MAXPATHLEN) {
 		fclose(arch);
 		return NULL;
+	    }
 	    if (fread(ename, (size_t)elen, 1, arch) != 1) {
 		fclose(arch);
 		return NULL;
+	    }
 	    ename[elen] = '\0';
 	    if (DEBUG(ARCH) || DEBUG(MAKE)) {
 		debug_printf("ArchFind: Extended format entry for %s\n", ename);
+	    }
 	    if (strncmp(ename, member, len) == 0) {
 		/* Found as extended name */
 		if (fseek(arch, -(long)sizeof(struct ar_hdr) - elen,
 			  SEEK_CUR) != 0) {
 		    fclose(arch);
 		    return NULL;
+		}
 		return arch;
+	    }
 	    if (fseek(arch, -elen, SEEK_CUR) != 0) {
 		fclose(arch);
 		return NULL;
+	    }
+	}
 #endif
 skip:
 	/*
 	 * This isn't the member we're after, so we need to advance the
 	 * stream's pointer to the start of the next header. Files are
 	 * padded with newlines to an even-byte boundary, so we need to
 	 * extract the size of the file from the 'size' field of the
 	 * header and round it up during the seek.
 	 */
 	arhPtr->ar_size[sizeof(arhPtr->ar_size) - 1] = '\0';
 	size = (int)strtol(arhPtr->ar_size, NULL, 10);
 	if (fseek(arch, (size + 1) & ~1, SEEK_CUR) != 0) {
 	    fclose(arch);
 	    return NULL;
+	}
+    }
     /*
      * We've looked everywhere, but the member is not to be found. Close the
      * archive and return NULL -- an error.
      */
     fclose(arch);
     return NULL;
+}
 /*-
  *-----------------------------------------------------------------------
  * Arch_Touch --
  *	Touch a member of an archive.
  *	The modification time of the entire archive is also changed.
  *	For a library, this could necessitate the re-ranlib'ing of the
  *	whole thing.
+ *
  * Input:
  *	gn		Node of member to touch
+ *
  * Results:
  *	The 'time' field of the member's header is updated.
  *-----------------------------------------------------------------------
  */
 void
 Arch_Touch(GNode *gn)
+{
     FILE *arch;		/* Stream open to archive, positioned properly */
     struct ar_hdr arh;	/* Current header describing member */
     char *p1, *p2;
     arch = ArchFindMember(Var_Value(ARCHIVE, gn, &p1),
 			  Var_Value(MEMBER, gn, &p2),
 			  &arh, "r+");
     bmake_free(p1);
     bmake_free(p2);
     snprintf(arh.ar_date, sizeof(arh.ar_date), "%-12ld", (long)now);
     if (arch != NULL) {
 	(void)fwrite((char *)&arh, sizeof(struct ar_hdr), 1, arch);
 	fclose(arch);
+    }
+}
 /* Given a node which represents a library, touch the thing, making sure that
  * the table of contents also is touched.
+ *
  * Both the modification time of the library and of the RANLIBMAG member are
  * set to 'now'.
+ *
  * Input:
  *	gn		The node of the library to touch
  */
 void
 Arch_TouchLib(GNode *gn)
+{
 #ifdef RANLIBMAG
     FILE *	    arch;	/* Stream open to archive */
     struct ar_hdr   arh;	/* Header describing table of contents */
     struct utimbuf  times;	/* Times for utime() call */
     arch = ArchFindMember(gn->path, RANLIBMAG, &arh, "r+");
     snprintf(arh.ar_date, sizeof(arh.ar_date), "%-12ld", (long) now);
     if (arch != NULL) {
 	(void)fwrite((char *)&arh, sizeof(struct ar_hdr), 1, arch);
 	fclose(arch);
 	times.actime = times.modtime = now;
 	utime(gn->path, &times);
+    }
 #else
     (void)gn;
 #endif
+}
 /* Return the modification time of a member of an archive. The mtime field
  * of the given node is filled in with the value returned by the function.
+ *
  * Input:
  *	gn		Node describing archive member
  */
 time_t
 Arch_MTime(GNode *gn)
+{
     struct ar_hdr *arhPtr;	/* Header of desired member */
     time_t modTime;		/* Modification time as an integer */
     char *p1, *p2;
     arhPtr = ArchStatMember(Var_Value(ARCHIVE, gn, &p1),
 			    Var_Value(MEMBER, gn, &p2),
 			    TRUE);
     bmake_free(p1);
     bmake_free(p2);
     if (arhPtr != NULL) {
 	modTime = (time_t)strtol(arhPtr->ar_date, NULL, 10);
     } else {
 	modTime = 0;
+    }
     gn->mtime = modTime;
     return modTime;
+}
 /* Given a non-existent archive member's node, get its modification time from
  * its archived form, if it exists. gn->mtime is filled in as well. */
 time_t
 Arch_MemMTime(GNode *gn)
+{
     GNodeListNode *ln;
     for (ln = gn->parents->first; ln != NULL; ln = ln->next) {
 	GNode *pgn = ln->datum;
 	if (pgn->type & OP_ARCHV) {
 	    /*
 	     * If the parent is an archive specification and is being made
 	     * and its member's name matches the name of the node we were
 	     * given, record the modification time of the parent in the
 	     * child. We keep searching its parents in case some other
 	     * parent requires this child to exist...
 	     */
 	    const char *nameStart = strchr(pgn->name, '(') + 1;
 	    const char *nameEnd = strchr(nameStart, ')');
 	    size_t nameLen = (size_t)(nameEnd - nameStart);
 	    if ((pgn->flags & REMAKE) &&
 		strncmp(nameStart, gn->name, nameLen) == 0) {
 		gn->mtime = Arch_MTime(pgn);
+	    }
 	} else if (pgn->flags & REMAKE) {
 	    /*
 	     * Something which isn't a library depends on the existence of
 	     * this target, so it needs to exist.
 	     */
 	    gn->mtime = 0;
 	    break;
+	}
+    }
     return gn->mtime;
+}
 /* Search for a library along the given search path.
+ *
  * The node's 'path' field is set to the found path (including the
  * actual file name, not -l...). If the system can handle the -L
  * flag when linking (or we cannot find the library), we assume that
  * the user has placed the .LIBS variable in the final linking
  * command (or the linker will know where to find it) and set the
  * TARGET variable for this node to be the node's name. Otherwise,
  * we set the TARGET variable to be the full path of the library,
  * as returned by Dir_FindFile.
+ *
  * Input:
  *	gn		Node of library to find
  */
 void
 Arch_FindLib(GNode *gn, SearchPath *path)
+{
     char *libName = str_concat3("lib", gn->name + 2, ".a");
     gn->path = Dir_FindFile(libName, path);
     free(libName);
 #ifdef LIBRARIES
     Var_Set(TARGET, gn->name, gn);
 #else
     Var_Set(TARGET, gn->path == NULL ? gn->name : gn->path, gn);
 #endif
+}
 /* Decide if a node with the OP_LIB attribute is out-of-date. Called from
  * Make_OODate to make its life easier.
  * The library will be hashed if it hasn't been already.
+ *
  * There are several ways for a library to be out-of-date that are
  * not available to ordinary files. In addition, there are ways
  * that are open to regular files that are not available to
  * libraries. A library that is only used as a source is never
  * considered out-of-date by itself. This does not preclude the
  * library's modification time from making its parent be out-of-date.
  * A library will be considered out-of-date for any of these reasons,
  * given that it is a target on a dependency line somewhere:
+ *
  *	Its modification time is less than that of one of its sources
  *	(gn->mtime < gn->youngestChild->mtime).
+ *
  *	Its modification time is greater than the time at which the make
  *	began (i.e. it's been modified in the course of the make, probably
  *	by archiving).
+ *
  *	The modification time of one of its sources is greater than the one
  *	of its RANLIBMAG member (i.e. its table of contents is out-of-date).
  *	We don't compare of the archive time vs. TOC time because they can be
  *	too close. In my opinion we should not bother with the TOC at all
  *	since this is used by 'ar' rules that affect the data contents of the
  *	archive, not by ranlib rules, which affect the TOC.
+ *
  * Input:
  *	gn		The library's graph node
+ *
  * Results:
  *	TRUE if the library is out-of-date. FALSE otherwise.
  */
 Boolean
 Arch_LibOODate(GNode *gn)
+{
     Boolean oodate;
     if (gn->type & OP_PHONY) {
 	oodate = TRUE;
     } else if (!GNode_IsTarget(gn) && Lst_IsEmpty(gn->children)) {
 	oodate = FALSE;
     } else if ((!Lst_IsEmpty(gn->children) && gn->youngestChild == NULL) ||
 	       (gn->mtime > now) ||
 	       (gn->youngestChild != NULL &&
 		gn->mtime < gn->youngestChild->mtime)) {
 	oodate = TRUE;
     } else {
 #ifdef RANLIBMAG
 	struct ar_hdr *arhPtr;	/* Header for __.SYMDEF */
 	int modTimeTOC;		/* The table-of-contents's mod time */
 	arhPtr = ArchStatMember(gn->path, RANLIBMAG, FALSE);
 	if (arhPtr != NULL) {
 	    modTimeTOC = (int)strtol(arhPtr->ar_date, NULL, 10);
 	    if (DEBUG(ARCH) || DEBUG(MAKE)) {
 		debug_printf("%s modified %s...", RANLIBMAG, Targ_FmtTime(modTimeTOC));
+	    }
 	    oodate = (gn->youngestChild == NULL || gn->youngestChild->mtime > modTimeTOC);
 	} else {
 	    /*
 	     * A library w/o a table of contents is out-of-date
 	     */
 	    if (DEBUG(ARCH) || DEBUG(MAKE)) {
 		debug_printf("No t.o.c....");
+	    }
 	    oodate = TRUE;
+	}
 #else
 	oodate = FALSE;
 #endif
+    }
     return oodate;
+}
 /* Initialize the archives module. */
 void
 Arch_Init(void)
+{
     archives = Lst_New();
+}
 /* Clean up the archives module. */
 void
 Arch_End(void)
+{
 #ifdef CLEANUP
     Lst_Destroy(archives, ArchFree);
 #endif
+}
 Boolean
 Arch_IsLib(GNode *gn)
+{
     static const char armag[] = "!<arch>\n";
     char buf[sizeof armag - 1];
     int fd;
     if ((fd = open(gn->path, O_RDONLY)) == -1)
 	return FALSE;
     if (read(fd, buf, sizeof buf) != sizeof buf) {
 	(void)close(fd);
 	return FALSE;
+    }
     (void)close(fd);
     return memcmp(buf, armag, sizeof buf) == 0;
+}

 @@ -1,1609 +1,1608 @@
-/*	$NetBSD: var.c,v 1.602 2020/10/30 16:45:37 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.603 2020/10/30 16:48:58 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.
  * 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.
  * 3. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * 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.
  */
 /*
  * Copyright (c) 1989 by Berkeley Softworks
  * 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.
  * 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.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *	This product includes software developed by the University of
  *	California, Berkeley and its contributors.
  * 4. Neither the name of the University nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  * 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.
  */
 /*
  * Handling of variables and the expressions formed from them.
+ *
  * Variables are set using lines of the form VAR=value.  Both the variable
  * name and the value can contain references to other variables, by using
  * expressions like ${VAR}, ${VAR:Modifiers}, ${${VARNAME}} or ${VAR:${MODS}}.
+ *
  * Interface:
  *	Var_Init	Initialize this module.
+ *
  *	Var_End		Clean up the module.
+ *
  *	Var_Set		Set the value of the variable, creating it if
  *			necessary.
+ *
  *	Var_Append	Append more characters to the variable, creating it if
  *			necessary. A space is placed between the old value and
  *			the new one.
+ *
  *	Var_Exists	See if a variable exists.
+ *
  *	Var_Value	Return the unexpanded value of a variable, or NULL if
  *			the variable is undefined.
+ *
  *	Var_Subst	Substitute all variable expressions in a string.
+ *
  *	Var_Parse	Parse a variable expression such as ${VAR:Mpattern}.
+ *
  *	Var_Delete	Delete a variable.
+ *
  *	Var_ExportVars	Export some or even all variables to the environment
  *			of this process and its child processes.
+ *
  *	Var_Export	Export the variable to the environment of this process
  *			and its child processes.
+ *
  *	Var_UnExport	Don't export the variable anymore.
+ *
  * Debugging:
  *	Var_Stats	Print out hashing statistics if in -dh mode.
+ *
  *	Var_Dump	Print out all variables defined in the given context.
+ *
  * XXX: There's a lot of duplication in these functions.
  */
 #include    <sys/stat.h>
 #ifndef NO_REGEX
 #include    <sys/types.h>
 #include    <regex.h>
 #endif
 #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.602 2020/10/30 16:45:37 rillig Exp $");
+MAKE_RCSID("$NetBSD: var.c,v 1.603 2020/10/30 16:48:58 rillig Exp $");
 #define VAR_DEBUG1(fmt, arg1) DEBUG1(VAR, fmt, arg1)
 #define VAR_DEBUG2(fmt, arg1, arg2) DEBUG2(VAR, fmt, arg1, arg2)
 #define VAR_DEBUG3(fmt, arg1, arg2, arg3) DEBUG3(VAR, fmt, arg1, arg2, arg3)
 #define VAR_DEBUG4(fmt, arg1, arg2, arg3, arg4) DEBUG4(VAR, fmt, arg1, arg2, arg3, arg4)
 ENUM_FLAGS_RTTI_3(VarEvalFlags,
 		  VARE_UNDEFERR, VARE_WANTRES, VARE_ASSIGN);
 /*
  * This lets us tell if we have replaced the original environ
  * (which we cannot free).
  */
 char **savedEnv = NULL;
 /* Special return value for Var_Parse, indicating a parse error.  It may be
  * caused by an undefined variable, a syntax error in a modifier or
  * something entirely different. */
 char var_Error[] = "";
 /* Special return value for Var_Parse, indicating an undefined variable in
  * a case where VARE_UNDEFERR is not set.  This undefined variable is
  * typically a dynamic variable such as ${.TARGET}, whose expansion needs to
  * be deferred until it is defined in an actual target. */
 static char varUndefined[] = "";
 /* Special return value for Var_Parse, just to avoid allocating empty strings.
  * In contrast to var_Error and varUndefined, this is not an error marker but
  * just an ordinary successful return value. */
 static char emptyString[] = "";
 /*
  * Traditionally this make consumed $$ during := like any other expansion.
  * Other make's do not, and this make follows straight since 2016-01-09.
+ *
  * This knob allows controlling the behavior.
  * FALSE to consume $$ during := assignment.
  * TRUE to preserve $$ during := assignment.
  */
 #define MAKE_SAVE_DOLLARS ".MAKE.SAVE_DOLLARS"
 static Boolean save_dollars = TRUE;
 /*
  * Internally, variables are contained in four different contexts.
  *	1) the environment. They cannot be changed. If an environment
  *	   variable is appended to, the result is placed in the global
  *	   context.
  *	2) the global context. Variables set in the makefiles are located
  *	   here.
  *	3) the command-line context. All variables set on the command line
  *	   are placed in this context.
  *	4) the local context. Each target has associated with it a context
  *	   list. On this list are located the structures describing such
  *	   local variables as $(@) and $(*)
  * The four contexts are searched in the reverse order from which they are
  * listed (but see opts.checkEnvFirst).
  */
 GNode          *VAR_INTERNAL;	/* variables from make itself */
 GNode          *VAR_GLOBAL;	/* variables from the makefile */
 GNode          *VAR_CMDLINE;	/* variables defined on the command-line */
 typedef enum VarFlags {
     /* 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 must
      * be freed as soon as they are not used anymore. */
     VAR_FROM_ENV = 0x02,
     /* The variable is exported to the environment, to be used by child
      * processes. */
     VAR_EXPORTED = 0x10,
     /* At the point where this variable was exported, it contained an
      * unresolved reference to another variable.  Before any child process is
      * started, it needs to be exported again, in the hope that the referenced
      * variable can then be resolved. */
     VAR_REEXPORT = 0x20,
     /* The variable came from the command line. */
     VAR_FROM_CMD = 0x40,
     /* The variable value cannot be changed anymore, and the variable cannot
      * be deleted.  Any attempts to do so are ignored. */
     VAR_READONLY = 0x80
 } VarFlags;
 ENUM_FLAGS_RTTI_6(VarFlags,
 		  VAR_IN_USE, VAR_FROM_ENV,
 		  VAR_EXPORTED, VAR_REEXPORT, VAR_FROM_CMD, VAR_READONLY);
 /* Variables are defined using one of the VAR=value assignments.  Their
  * value can be queried by expressions such as $V, ${VAR}, or with modifiers
  * such as ${VAR:S,from,to,g:Q}.
+ *
  * There are 3 kinds of variables: context variables, environment variables,
  * undefined variables.
+ *
  * Context variables are stored in a GNode.context.  The only way to undefine
  * a context variable is using the .undef directive.  In particular, it must
  * not be possible to undefine a variable during the evaluation of an
  * expression, or Var.name might point nowhere.
+ *
  * Environment variables are temporary.  They are returned by VarFind, and
  * after using them, they must be freed using VarFreeEnv.
+ *
  * Undefined variables occur during evaluation of variable expressions such
  * as ${UNDEF:Ufallback} in Var_Parse and ApplyModifiers.
  */
 typedef struct Var {
     /* The name of the variable, once set, doesn't change anymore.
      * For context variables, it aliases the corresponding HashEntry name.
      * For environment and undefined variables, it is allocated. */
     const char *name;
     void *name_freeIt;
     Buffer	  val;		/* its value */
     VarFlags	  flags;	/* miscellaneous status flags */
 } Var;
 /*
  * Exporting vars is expensive so skip it if we can
  */
 typedef enum VarExportedMode {
     VAR_EXPORTED_NONE,
     VAR_EXPORTED_SOME,
     VAR_EXPORTED_ALL
 } VarExportedMode;
 static VarExportedMode var_exportedVars = VAR_EXPORTED_NONE;
 typedef enum VarExportFlags {
     /*
      * We pass this to Var_Export when doing the initial export
      * or after updating an exported var.
      */
     VAR_EXPORT_PARENT	= 0x01,
     /*
      * We pass this to Var_Export1 to tell it to leave the value alone.
      */
     VAR_EXPORT_LITERAL	= 0x02
 } VarExportFlags;
 /* Flags for pattern matching in the :S and :C modifiers */
 typedef enum VarPatternFlags {
     VARP_SUB_GLOBAL	= 0x01,	/* Apply substitution globally */
     VARP_SUB_ONE	= 0x02,	/* Apply substitution to one word */
     VARP_ANCHOR_START	= 0x04,	/* Match at start of word */
     VARP_ANCHOR_END	= 0x08	/* Match at end of word */
 } VarPatternFlags;
 static Var *
 VarNew(const char *name, void *name_freeIt, const char *value, VarFlags flags)
+{
     size_t value_len = strlen(value);
     Var *var = bmake_malloc(sizeof *var);
     var->name = name;
     var->name_freeIt = name_freeIt;
     Buf_Init(&var->val, value_len + 1);
     Buf_AddBytes(&var->val, value, value_len);
     var->flags = flags;
     return var;
+}
 static const char *
 CanonicalVarname(const char *name)
+{
     if (*name == '.' && ch_isupper(name[1])) {
 	switch (name[1]) {
 	case 'A':
 	    if (strcmp(name, ".ALLSRC") == 0)
 		name = ALLSRC;
 	    if (strcmp(name, ".ARCHIVE") == 0)
 		name = ARCHIVE;
 	    break;
 	case 'I':
 	    if (strcmp(name, ".IMPSRC") == 0)
 		name = IMPSRC;
 	    break;
 	case 'M':
 	    if (strcmp(name, ".MEMBER") == 0)
 		name = MEMBER;
 	    break;
 	case 'O':
 	    if (strcmp(name, ".OODATE") == 0)
 		name = OODATE;
 	    break;
 	case 'P':
 	    if (strcmp(name, ".PREFIX") == 0)
 		name = PREFIX;
 	    break;
 	case 'S':
 	    if (strcmp(name, ".SHELL") == 0) {
 		if (!shellPath)
 		    Shell_Init();
+	    }
 	    break;
 	case 'T':
 	    if (strcmp(name, ".TARGET") == 0)
 		name = TARGET;
 	    break;
+	}
+    }
     /* GNU make has an additional alias $^ == ${.ALLSRC}. */
     return name;
+}
 static Var *
 GNode_FindVar(GNode *ctxt, const char *varname, unsigned int hash)
+{
     return HashTable_FindValueHash(&ctxt->context, varname, hash);
+}
 /*-
  *-----------------------------------------------------------------------
  * VarFind --
  *	Find the given variable in the given context and any other contexts
  *	indicated.
+ *
  * Input:
  *	name		name to find
  *	ctxt		context in which to find it
  *	elsewhere	to look in other contexts as well
+ *
  * Results:
  *	A pointer to the structure describing the desired variable or
  *	NULL if the variable does not exist.
  *-----------------------------------------------------------------------
  */
 static Var *
 VarFind(const char *name, GNode *ctxt, Boolean elsewhere)
+{
     Var *var;
     unsigned int nameHash;
     /*
      * 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.
      */
     name = CanonicalVarname(name);
     nameHash = Hash_Hash(name);
     /*
      * First look for the variable in the given context. If it's not there,
      * look for it in VAR_CMDLINE, VAR_GLOBAL and the environment, in that order,
      * depending on the FIND_* flags in 'flags'
      */
     var = GNode_FindVar(ctxt, name, nameHash);
     if (!elsewhere)
 	return var;
     if (var == NULL && ctxt != VAR_CMDLINE)
 	var = GNode_FindVar(VAR_CMDLINE, name, nameHash);
     if (!opts.checkEnvFirst && var == NULL && ctxt != VAR_GLOBAL) {
 	var = GNode_FindVar(VAR_GLOBAL, name, nameHash);
 	if (var == NULL && ctxt != VAR_INTERNAL) {
 	    /* VAR_INTERNAL is subordinate to VAR_GLOBAL */
 	    var = GNode_FindVar(VAR_INTERNAL, name, nameHash);
+	}
+    }
     if (var == NULL) {
 	char *env;
 	if ((env = getenv(name)) != NULL) {
 	    char *varname = bmake_strdup(name);
 	    return VarNew(varname, varname, env, VAR_FROM_ENV);
+	}
 	if (opts.checkEnvFirst && ctxt != VAR_GLOBAL) {
 	    var = GNode_FindVar(VAR_GLOBAL, name, nameHash);
 	    if (var == NULL && ctxt != VAR_INTERNAL)
 		var = GNode_FindVar(VAR_INTERNAL, name, nameHash);
 	    return var;
+	}
 	return NULL;
+    }
     return var;
+}
 /*-
  *-----------------------------------------------------------------------
  * VarFreeEnv  --
  *	If the variable is an environment variable, free it
+ *
  * Input:
  *	v		the variable
  *	destroy		true if the value buffer should be destroyed.
+ *
  * Results:
  *	TRUE if it is an environment variable, FALSE otherwise.
  *-----------------------------------------------------------------------
  */
 static Boolean
 VarFreeEnv(Var *v, Boolean destroy)
+{
     if (!(v->flags & VAR_FROM_ENV))
 	return FALSE;
     free(v->name_freeIt);
     Buf_Destroy(&v->val, destroy);
     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, VarSet_Flags flags)
+{
     HashEntry *he = HashTable_CreateEntry(&ctxt->context, name, NULL);
     Var *v = VarNew(he->key, NULL, val,
 		    flags & VAR_SET_READONLY ? VAR_READONLY : 0);
     HashEntry_Set(he, v);
     if (!(ctxt->flags & INTERNAL)) {
 	VAR_DEBUG3("%s:%s = %s\n", ctxt->name, name, val);
+    }
+}
 /* Remove a variable from a context, freeing the Var structure as well. */
 void
 Var_Delete(const char *name, GNode *ctxt)
+{
     char *name_freeIt = NULL;
     HashEntry *he;
     if (strchr(name, '$') != NULL) {
 	(void)Var_Subst(name, VAR_GLOBAL, VARE_WANTRES, &name_freeIt);
 	/* TODO: handle errors */
 	name = name_freeIt;
+    }
     he = HashTable_FindEntry(&ctxt->context, name);
     VAR_DEBUG3("%s:delete %s%s\n",
 	       ctxt->name, name, he != NULL ? "" : " (not found)");
     free(name_freeIt);
     if (he != NULL) {
 	Var *v = HashEntry_Get(he);
 	if (v->flags & VAR_EXPORTED)
 	    unsetenv(v->name);
 	if (strcmp(v->name, MAKE_EXPORTED) == 0)
 	    var_exportedVars = VAR_EXPORTED_NONE;
 	assert(v->name_freeIt == NULL);
 	HashTable_DeleteEntry(&ctxt->context, he);
 	Buf_Destroy(&v->val, TRUE);
 	free(v);
+    }
+}
 static Boolean
 MayExport(const char *name)
+{
     if (name[0] == '.')
 	return FALSE;		/* skip internals */
     if (name[0] == '-')
 	return FALSE;		/* skip misnamed variables */
     if (name[1] == '\0') {
 	/*
 	 * A single char.
 	 * If it is one of the vars that should only appear in
 	 * local context, skip it, else we can get Var_Subst
 	 * into a loop.
 	 */
 	switch (name[0]) {
 	case '@':
 	case '%':
 	case '*':
 	case '!':
 	    return FALSE;
+	}
+    }
     return TRUE;
+}
 /*
  * Export a single variable.
  * We ignore make internal variables (those which start with '.').
  * Also we jump through some hoops to avoid calling setenv
  * more than necessary since it can leak.
  * We only manipulate flags of vars if 'parent' is set.
  */
 static Boolean
 Var_Export1(const char *name, VarExportFlags flags)
+{
     VarExportFlags parent = flags & VAR_EXPORT_PARENT;
     Var *v;
     char *val;
     if (!MayExport(name))
 	return FALSE;
     v = VarFind(name, VAR_GLOBAL, 0);
     if (v == NULL)
 	return FALSE;
     if (!parent && (v->flags & VAR_EXPORTED) && !(v->flags & VAR_REEXPORT))
 	return FALSE;		/* nothing to do */
     val = Buf_GetAll(&v->val, NULL);
     if (!(flags & VAR_EXPORT_LITERAL) && strchr(val, '$') != NULL) {
 	char *expr;
 	if (parent) {
 	    /*
 	     * Flag this as something we need to re-export.
 	     * No point actually exporting it now though,
 	     * the child can do it at the last minute.
 	     */
 	    v->flags |= VAR_EXPORTED | VAR_REEXPORT;
 	    return TRUE;
+	}
 	if (v->flags & VAR_IN_USE) {
 	    /*
 	     * We recursed while exporting in a child.
 	     * This isn't going to end well, just skip it.
 	     */
 	    return FALSE;
+	}
 	expr = str_concat3("${", name, "}");
 	(void)Var_Subst(expr, VAR_GLOBAL, VARE_WANTRES, &val);
 	/* TODO: handle errors */
 	setenv(name, val, 1);
 	free(val);
 	free(expr);
     } else {
 	if (parent)
 	    v->flags &= ~(unsigned)VAR_REEXPORT;	/* once will do */
 	if (parent || !(v->flags & VAR_EXPORTED))
 	    setenv(name, val, 1);
+    }
     /*
      * This is so Var_Set knows to call Var_Export again...
      */
     if (parent) {
 	v->flags |= VAR_EXPORTED;
+    }
     return TRUE;
+}
 /*
  * This gets called from our children.
  */
 void
 Var_ExportVars(void)
+{
     char *val;
     /*
      * Several make's support this sort of mechanism for tracking
      * recursion - but each uses a different name.
      * We allow the makefiles to update MAKELEVEL and ensure
      * children see a correctly incremented value.
      */
     char tmp[BUFSIZ];
     snprintf(tmp, sizeof(tmp), "%d", makelevel + 1);
     setenv(MAKE_LEVEL_ENV, tmp, 1);
     if (var_exportedVars == VAR_EXPORTED_NONE)
 	return;
     if (var_exportedVars == VAR_EXPORTED_ALL) {
 	HashIter hi;
 	HashEntry *he;
 	/* Ouch! Exporting all variables at once is crazy... */
 	HashIter_Init(&hi, &VAR_GLOBAL->context);
-	while ((he = HashIter_Next(&hi)) != NULL) {
+	while (HashIter_Next(&hi) != NULL) {
-	    Var *var = HashEntry_Get(he);
+	    Var *var = hi.entry->value;
 	    Var_Export1(var->name, 0);
+	}
 	return;
+    }
     (void)Var_Subst("${" MAKE_EXPORTED ":O:u}", VAR_GLOBAL, VARE_WANTRES, &val);
     /* TODO: handle errors */
     if (*val) {
 	Words words = Str_Words(val, FALSE);
 	size_t i;
 	for (i = 0; i < words.len; i++)
 	    Var_Export1(words.words[i], 0);
 	Words_Free(words);
+    }
     free(val);
+}
 /*
  * This is called when .export is seen or .MAKE.EXPORTED is modified.
+ *
  * It is also called when any exported variable is modified.
  * XXX: Is it really?
+ *
  * str has the format "[-env|-literal] varname...".
  */
 void
 Var_Export(const char *str, Boolean isExport)
+{
     VarExportFlags flags;
     char *val;
     if (isExport && str[0] == '\0') {
 	var_exportedVars = VAR_EXPORTED_ALL; /* use with caution! */
 	return;
+    }
     if (isExport && strncmp(str, "-env", 4) == 0) {
 	str += 4;
 	flags = 0;
     } else if (isExport && strncmp(str, "-literal", 8) == 0) {
 	str += 8;
 	flags = VAR_EXPORT_LITERAL;
     } else {
 	flags = VAR_EXPORT_PARENT;
+    }
     (void)Var_Subst(str, VAR_GLOBAL, VARE_WANTRES, &val);
     /* TODO: handle errors */
     if (val[0] != '\0') {
 	Words words = Str_Words(val, FALSE);
 	size_t i;
 	for (i = 0; i < words.len; i++) {
 	    const char *name = words.words[i];
 	    if (Var_Export1(name, flags)) {
 		if (var_exportedVars == VAR_EXPORTED_NONE)
 		    var_exportedVars = VAR_EXPORTED_SOME;
 		if (isExport && (flags & VAR_EXPORT_PARENT)) {
 		    Var_Append(MAKE_EXPORTED, name, VAR_GLOBAL);
+		}
+	    }
+	}
 	Words_Free(words);
+    }
     free(val);
+}
 extern char **environ;
 /*
  * This is called when .unexport[-env] is seen.
+ *
  * str must have the form "unexport[-env] varname...".
  */
 void
 Var_UnExport(const char *str)
+{
     const char *varnames;
     char *varnames_freeIt;
     Boolean unexport_env;
     varnames = NULL;
     varnames_freeIt = NULL;
     str += strlen("unexport");
     unexport_env = strncmp(str, "-env", 4) == 0;
     if (unexport_env) {
 	const char *cp;
 	char **newenv;
 	cp = getenv(MAKE_LEVEL_ENV);	/* we should preserve this */
 	if (environ == savedEnv) {
 	    /* we have been here before! */
 	    newenv = bmake_realloc(environ, 2 * sizeof(char *));
 	} else {
 	    if (savedEnv) {
 		free(savedEnv);
 		savedEnv = NULL;
+	    }
 	    newenv = bmake_malloc(2 * sizeof(char *));
+	}
 	/* Note: we cannot safely free() the original environ. */
 	environ = savedEnv = newenv;
 	newenv[0] = NULL;
 	newenv[1] = NULL;
 	if (cp && *cp)
 	    setenv(MAKE_LEVEL_ENV, cp, 1);
     } else {
 	cpp_skip_whitespace(&str);
 	if (str[0] != '\0')
 	    varnames = str;
+    }
     if (varnames == NULL) {
 	/* Using .MAKE.EXPORTED */
 	(void)Var_Subst("${" MAKE_EXPORTED ":O:u}", VAR_GLOBAL, VARE_WANTRES,
 			&varnames_freeIt);
 	/* TODO: handle errors */
 	varnames = varnames_freeIt;
+    }
+    {
 	Var *v;
 	size_t i;
 	Words words = Str_Words(varnames, FALSE);
 	for (i = 0; i < words.len; i++) {
 	    const char *varname = words.words[i];
 	    v = VarFind(varname, VAR_GLOBAL, 0);
 	    if (v == NULL) {
 		VAR_DEBUG1("Not unexporting \"%s\" (not found)\n", varname);
 		continue;
+	    }
 	    VAR_DEBUG1("Unexporting \"%s\"\n", varname);
 	    if (!unexport_env && (v->flags & VAR_EXPORTED) &&
 		!(v->flags & VAR_REEXPORT))
 		unsetenv(v->name);
 	    v->flags &= ~(unsigned)(VAR_EXPORTED | VAR_REEXPORT);
 	    /*
 	     * If we are unexporting a list,
 	     * remove each one from .MAKE.EXPORTED.
 	     * If we are removing them all,
 	     * just delete .MAKE.EXPORTED below.
 	     */
 	    if (varnames == str) {
 		char *expr = str_concat3("${" MAKE_EXPORTED ":N", v->name, "}");
 		char *cp;
 		(void)Var_Subst(expr, VAR_GLOBAL, VARE_WANTRES, &cp);
 		/* TODO: handle errors */
 		Var_Set(MAKE_EXPORTED, cp, VAR_GLOBAL);
 		free(cp);
 		free(expr);
+	    }
+	}
 	Words_Free(words);
 	if (varnames != str) {
 	    Var_Delete(MAKE_EXPORTED, VAR_GLOBAL);
 	    free(varnames_freeIt);
+	}
+    }
+}
 /* See Var_Set for documentation. */
 void
 Var_Set_with_flags(const char *name, const char *val, GNode *ctxt,
 		   VarSet_Flags flags)
+{
     const char *unexpanded_name = name;
     char *name_freeIt = NULL;
     Var *v;
     assert(val != NULL);
     if (strchr(name, '$') != NULL) {
 	(void)Var_Subst(name, ctxt, VARE_WANTRES, &name_freeIt);
 	/* TODO: handle errors */
 	name = name_freeIt;
+    }
     if (name[0] == '\0') {
 	VAR_DEBUG2("Var_Set(\"%s\", \"%s\", ...) "
 		   "name expands to empty string - ignored\n",
 		   unexpanded_name, val);
 	free(name_freeIt);
 	return;
+    }
     if (ctxt == VAR_GLOBAL) {
 	v = VarFind(name, VAR_CMDLINE, 0);
 	if (v != NULL) {
 	    if (v->flags & VAR_FROM_CMD) {
 		VAR_DEBUG3("%s:%s = %s ignored!\n", ctxt->name, name, val);
 		goto out;
+	    }
 	    VarFreeEnv(v, TRUE);
+	}
+    }
     /*
      * 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...
      */
     v = VarFind(name, ctxt, 0);
     if (v == NULL) {
 	if (ctxt == VAR_CMDLINE && !(flags & VAR_NO_EXPORT)) {
 	    /*
 	     * 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, flags);
     } else {
 	if ((v->flags & VAR_READONLY) && !(flags & VAR_SET_READONLY)) {
 	    VAR_DEBUG3("%s:%s = %s ignored (read-only)\n",
 		       ctxt->name, name, val);
 	    goto out;
+	}
 	Buf_Empty(&v->val);
 	if (val)
 	    Buf_AddStr(&v->val, val);
 	VAR_DEBUG3("%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)
      * Other than internals.
      */
     if (ctxt == VAR_CMDLINE && !(flags & VAR_NO_EXPORT) && name[0] != '.') {
 	if (v == NULL) {
 	    /* we just added it */
 	    v = VarFind(name, ctxt, 0);
+	}
 	if (v != NULL)
 	    v->flags |= VAR_FROM_CMD;
 	/*
 	 * If requested, don't export these in the environment
 	 * individually.  We still put them in MAKEOVERRIDES so
 	 * that the command-line settings continue to override
 	 * Makefile settings.
 	 */
 	if (!opts.varNoExportEnv)
 	    setenv(name, val ? val : "", 1);
 	Var_Append(MAKEOVERRIDES, name, VAR_GLOBAL);
+    }
     if (name[0] == '.' && strcmp(name, MAKE_SAVE_DOLLARS) == 0)
 	save_dollars = s2Boolean(val, save_dollars);
 out:
     free(name_freeIt);
     if (v != NULL)
 	VarFreeEnv(v, TRUE);
+}
 /*-
  *-----------------------------------------------------------------------
  * Var_Set --
  *	Set the variable name to the value val in the given context.
+ *
  *	If the variable doesn't yet exist, it is created.
  *	Otherwise the new value overwrites and replaces the old value.
+ *
  * Input:
  *	name		name of variable to set
  *	val		value to give to the variable
  *	ctxt		context in which to set it
+ *
  * Notes:
  *	The variable is searched for only in its context before being
  *	created in that context. I.e. if the context is VAR_GLOBAL,
  *	only VAR_GLOBAL->context is searched. Likewise if it is VAR_CMDLINE,
  *	only VAR_CMDLINE->context is searched. This is done to avoid the
  *	literally thousands of unnecessary strcmp's that used to be done to
  *	set, say, $(@) or $(<).
  *	If the context is VAR_GLOBAL though, we check if the variable
  *	was set in VAR_CMDLINE from the command line and skip it if so.
  *-----------------------------------------------------------------------
  */
 void
 Var_Set(const char *name, const char *val, GNode *ctxt)
+{
     Var_Set_with_flags(name, val, ctxt, 0);
+}
 /*-
  *-----------------------------------------------------------------------
  * Var_Append --
  *	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 concatenated, with a space in between.
+ *
  * Input:
  *	name		name of variable to modify
  *	val		string to append to it
  *	ctxt		context in which this should occur
+ *
  * 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)
+{
     char *name_freeIt = NULL;
     Var *v;
     assert(val != NULL);
     if (strchr(name, '$') != NULL) {
 	const char *unexpanded_name = name;
 	(void)Var_Subst(name, ctxt, VARE_WANTRES, &name_freeIt);
 	/* TODO: handle errors */
 	name = name_freeIt;
 	if (name[0] == '\0') {
 	    VAR_DEBUG2("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) {
 	Var_Set(name, val, ctxt);
     } else if (v->flags & VAR_READONLY) {
         VAR_DEBUG1("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);
 	VAR_DEBUG3("%s:%s = %s\n",
 		   ctxt->name, name, Buf_GetAll(&v->val, NULL));
 	if (v->flags & VAR_FROM_ENV) {
 	    HashEntry *h;
 	    /*
 	     * 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...)
 	     */
 	    v->flags &= ~(unsigned)VAR_FROM_ENV;
 	    h = HashTable_CreateEntry(&ctxt->context, name, NULL);
 	    HashEntry_Set(h, v);
+	}
+    }
     free(name_freeIt);
+}
 /* See if the given variable exists, in the given context or in other
  * fallback contexts.
+ *
  * Input:
  *	name		Variable to find
  *	ctxt		Context in which to start search
  */
 Boolean
 Var_Exists(const char *name, GNode *ctxt)
+{
     char *name_freeIt = NULL;
     Var *v;
     if (strchr(name, '$') != NULL) {
 	(void)Var_Subst(name, ctxt, VARE_WANTRES, &name_freeIt);
 	/* TODO: handle errors */
 	name = name_freeIt;
+    }
     v = VarFind(name, ctxt, TRUE);
     free(name_freeIt);
     if (v == NULL)
 	return FALSE;
     (void)VarFreeEnv(v, TRUE);
     return TRUE;
+}
 /*-
  *-----------------------------------------------------------------------
  * Var_Value --
  *	Return the unexpanded value of the given variable in the given
  *	context, or the usual contexts.
+ *
  * Input:
  *	name		name to find
  *	ctxt		context in which to search for it
+ *
  * Results:
  *	The value if the variable exists, NULL if it doesn't.
  *	If the returned value is not NULL, the caller must free *freeIt
  *	as soon as the returned value is no longer needed.
  *-----------------------------------------------------------------------
  */
 const char *
 Var_Value(const char *name, GNode *ctxt, char **freeIt)
+{
     Var *v = VarFind(name, ctxt, TRUE);
     char *p;
     *freeIt = NULL;
     if (v == NULL)
 	return NULL;
     p = Buf_GetAll(&v->val, NULL);
     if (VarFreeEnv(v, FALSE))
 	*freeIt = p;
     return p;
+}
 /* SepBuf is a string being built from "words", interleaved with separators. */
 typedef struct SepBuf {
     Buffer buf;
     Boolean needSep;
     char sep;			/* usually ' ', but see the :ts modifier */
 } SepBuf;
 static void
 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 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, mem_size);
+}
 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_AddBytesBetween(buf, word, slash);
     else
 	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_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_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)
+{
     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;
     VAR_DEBUG2("VarMatch [%s] [%s]\n", word, pattern);
     if (Str_Match(word, pattern))
 	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_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
+ *
  * Results:
  *	Returns the start of the match, or NULL.
  *	*match_len returns the length of the match, if any.
  *	*hasPercent returns whether the pattern contains a percent.
  *-----------------------------------------------------------------------
  */
 static const char *
 Str_SYSVMatch(const char *word, const char *pattern, size_t *match_len,
 	      Boolean *hasPercent)
+{
     const char *p = pattern;
     const char *w = word;
     const char *percent;
     size_t w_len;
     size_t p_len;
     const char *w_tail;
     *hasPercent = FALSE;
     if (*p == '\0') {		/* ${VAR:=suffix} */
 	*match_len = strlen(w);	/* Null pattern is the whole string */
 	return w;
+    }
     percent = strchr(p, '%');
     if (percent != NULL) {	/* ${VAR:...%...=...} */
 	*hasPercent = TRUE;
 	if (*w == '\0')
 	    return NULL;	/* empty word does not match pattern */
 	/* check that the prefix matches */
 	for (; p != percent && *w != '\0' && *w == *p; w++, p++)
 	    continue;
 	if (p != percent)
 	    return NULL;	/* No match */
 	p++;			/* Skip the percent */
 	if (*p == '\0') {
 	    /* No more pattern, return the rest of the string */
 	    *match_len = strlen(w);
 	    return w;
+	}
+    }
     /* Test whether the tail matches */
     w_len = strlen(w);
     p_len = strlen(p);
     if (w_len < p_len)
 	return NULL;
     w_tail = w + w_len - p_len;
     if (memcmp(p, w_tail, p_len) != 0)
 	return NULL;
     *match_len = (size_t)(w_tail - w);
     return w;
+}
 struct ModifyWord_SYSVSubstArgs {
     GNode *ctx;
     const char *lhs;
     const char *rhs;
 };
 /* Callback for ModifyWords to implement the :%.from=%.to modifier. */
 static void
 ModifyWord_SYSVSubst(const char *word, SepBuf *buf, void *data)
+{
     const struct ModifyWord_SYSVSubstArgs *args = data;
     char *rhs_expanded;
     const char *rhs;
     const char *percent;
     size_t match_len;
     Boolean lhsPercent;
     const char *match = Str_SYSVMatch(word, args->lhs, &match_len, &lhsPercent);
     if (match == NULL) {
 	SepBuf_AddStr(buf, word);
 	return;
+    }
     /* Append rhs to the buffer, substituting the first '%' with the
      * match, but only if the lhs had a '%' as well. */
     (void)Var_Subst(args->rhs, args->ctx, VARE_WANTRES, &rhs_expanded);
     /* TODO: handle errors */
     rhs = rhs_expanded;
     percent = strchr(rhs, '%');
     if (percent != NULL && lhsPercent) {
 	/* Copy the prefix of the replacement pattern */
 	SepBuf_AddBytesBetween(buf, rhs, percent);
 	rhs = percent + 1;
+    }
     if (percent != NULL || !lhsPercent)
 	SepBuf_AddBytes(buf, match, match_len);
     /* Append the suffix of the replacement pattern */
     SepBuf_AddStr(buf, rhs);
     free(rhs_expanded);
+}
 #endif
 struct ModifyWord_SubstArgs {
     const char	*lhs;
     size_t	lhsLen;
     const char	*rhs;
     size_t	rhsLen;
     VarPatternFlags pflags;
     Boolean	matched;
 };
 /* Callback for ModifyWords to implement the :S,from,to, modifier.
  * Perform a string substitution on the given word. */
 static void
 ModifyWord_Subst(const char *word, SepBuf *buf, void *data)
+{
     size_t wordLen = strlen(word);
     struct ModifyWord_SubstArgs *args = data;
     const char *match;
     if ((args->pflags & VARP_SUB_ONE) && args->matched)
 	goto nosub;
     if (args->pflags & VARP_ANCHOR_START) {
 	if (wordLen < args->lhsLen ||
 	    memcmp(word, args->lhs, args->lhsLen) != 0)
 	    goto nosub;
 	if (args->pflags & VARP_ANCHOR_END) {
 	    if (wordLen != args->lhsLen)
 		goto nosub;
 	    /* :S,^whole$,replacement, */
 	    SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
 	    args->matched = TRUE;
 	} else {
 	    /* :S,^prefix,replacement, */
 	    SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
 	    SepBuf_AddBytes(buf, word + args->lhsLen, wordLen - args->lhsLen);
 	    args->matched = TRUE;
+	}
 	return;
+    }
     if (args->pflags & VARP_ANCHOR_END) {
 	const char *start;
 	if (wordLen < args->lhsLen)
 	    goto nosub;
 	start = word + (wordLen - args->lhsLen);
 	if (memcmp(start, args->lhs, args->lhsLen) != 0)
 	    goto nosub;
 	/* :S,suffix$,replacement, */
 	SepBuf_AddBytesBetween(buf, word, start);
 	SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
 	args->matched = TRUE;
 	return;
+    }
     if (args->lhs[0] == '\0')
 	goto nosub;
     /* unanchored case, may match more than once */
     while ((match = strstr(word, args->lhs)) != NULL) {
 	SepBuf_AddBytesBetween(buf, word, match);
 	SepBuf_AddBytes(buf, args->rhs, args->rhsLen);
 	args->matched = TRUE;
 	wordLen -= (size_t)(match - word) + args->lhsLen;
 	word += (size_t)(match - word) + args->lhsLen;
 	if (wordLen == 0 || !(args->pflags & VARP_SUB_GLOBAL))
 	    break;
+    }
 nosub:
     SepBuf_AddBytes(buf, word, wordLen);
+}
 #ifndef NO_REGEX
 /* Print the error caused by a regcomp or regexec call. */
 static void
 VarREError(int reerr, regex_t *pat, const char *str)
+{
     size_t errlen = regerror(reerr, pat, 0, 0);
     char *errbuf = bmake_malloc(errlen);
     regerror(reerr, pat, errbuf, errlen);
     Error("%s: %s", str, errbuf);
     free(errbuf);
+}
 struct ModifyWord_SubstRegexArgs {
     regex_t re;
     size_t nsub;
     char *replace;
     VarPatternFlags pflags;
     Boolean matched;
 };
 /* Callback for ModifyWords to implement the :C/from/to/ modifier.
  * Perform a regex substitution on the given word. */
 static void
 ModifyWord_SubstRegex(const char *word, SepBuf *buf, void *data)
+{
     struct ModifyWord_SubstRegexArgs *args = data;
     int xrv;
     const char *wp = word;
     char *rp;
     int flags = 0;
     regmatch_t m[10];
     if ((args->pflags & VARP_SUB_ONE) && args->matched)
 	goto nosub;
 tryagain:
     xrv = regexec(&args->re, wp, args->nsub, m, flags);
     switch (xrv) {
     case 0:
 	args->matched = TRUE;
 	SepBuf_AddBytes(buf, wp, (size_t)m[0].rm_so);
 	for (rp = args->replace; *rp; rp++) {
 	    if (*rp == '\\' && (rp[1] == '&' || rp[1] == '\\')) {
 		SepBuf_AddBytes(buf, rp + 1, 1);
 		rp++;
 		continue;
+	    }
 	    if (*rp == '&') {
 		SepBuf_AddBytesBetween(buf, wp + m[0].rm_so, wp + m[0].rm_eo);
 		continue;
+	    }
 	    if (*rp != '\\' || !ch_isdigit(rp[1])) {
 		SepBuf_AddBytes(buf, rp, 1);
 		continue;
+	    }
 	    {			/* \0 to \9 backreference */
 		size_t n = (size_t)(rp[1] - '0');
 		rp++;
 		if (n >= args->nsub) {
 		    Error("No subexpression \\%zu", n);
 		} else if (m[n].rm_so == -1 && m[n].rm_eo == -1) {
 		    Error("No match for subexpression \\%zu", n);
 		} else {
 		    SepBuf_AddBytesBetween(buf, wp + m[n].rm_so,
 					   wp + m[n].rm_eo);
+		}
+	    }
+	}
 	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_AddStr(buf, wp);
+	}
 	break;
     default:
 	VarREError(xrv, &args->re, "Unexpected regex error");
 	/* FALLTHROUGH */
     case REG_NOMATCH:
     nosub:
 	SepBuf_AddStr(buf, wp);
 	break;
+    }
+}
 #endif
 struct ModifyWord_LoopArgs {
     GNode	*ctx;
     char	*tvar;		/* name of temporary variable */
     char	*str;		/* string to expand */
     VarEvalFlags eflags;
 };
 /* Callback for ModifyWords to implement the :@var@...@ modifier of ODE make. */
 static void
 ModifyWord_Loop(const char *word, SepBuf *buf, void *data)
+{
     const struct ModifyWord_LoopArgs *args;
     char *s;
     if (word[0] == '\0')
 	return;
     args = data;
     Var_Set_with_flags(args->tvar, word, args->ctx, VAR_NO_EXPORT);
     (void)Var_Subst(args->str, args->ctx, args->eflags, &s);
     /* TODO: handle errors */
     VAR_DEBUG4("ModifyWord_Loop: in \"%s\", replace \"%s\" with \"%s\" "
 	       "to \"%s\"\n",
 	       word, args->tvar, args->str, s);
     if (s[0] == '\n' || Buf_EndsWith(&buf->buf, '\n'))
 	buf->needSep = FALSE;
     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(char sep, Boolean oneBigWord, const char *str, int first,
 	       int last)
+{
     Words words;
     int len, start, end, step;
     int i;
     SepBuf buf;
     SepBuf_Init(&buf, sep);
     if (oneBigWord) {
 	/* fake what Str_Words() would do if there were only one word */
 	words.len = 1;
 	words.words = bmake_malloc((words.len + 1) * sizeof(char *));
 	words.freeIt = bmake_strdup(str);
 	words.words[0] = words.freeIt;
 	words.words[1] = NULL;
     } else {
 	words = Str_Words(str, FALSE);
+    }
     /*
      * Now sanitize the given range.
      * If first or last are negative, convert them to the positive equivalents
      * (-1 gets converted to ac, -2 gets converted to (ac - 1), etc.).
      */
     len = (int)words.len;
     if (first < 0)
 	first += len + 1;
     if (last < 0)
 	last += len + 1;
     /*
      * We avoid scanning more of the list than we need to.
      */
     if (first > last) {
 	start = (first > len ? len : first) - 1;
 	end = last < 1 ? 0 : last - 1;
 	step = -1;
     } 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);
+}
 /* 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];
     const char *rp = cached_realpath(word, rbuf);
     if (rp != NULL && *rp == '/' && stat(rp, &st) == 0)
 	word = rp;
     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
  *	modifyWord_args Custom arguments for modifyWord
+ *
  * Results:
  *	A string of all the words modified appropriately.
  *-----------------------------------------------------------------------
  */
 static char *
 ModifyWords(GNode *ctx, char sep, Boolean oneBigWord, const char *str,
 	    ModifyWordsCallback modifyWord, void *modifyWord_args)
+{
     SepBuf result;
     Words words;
     size_t i;
     if (oneBigWord) {
 	SepBuf_Init(&result, sep);
 	modifyWord(str, &result, modifyWord_args);
 	return SepBuf_Destroy(&result, FALSE);
+    }
     SepBuf_Init(&result, sep);
     words = Str_Words(str, FALSE);
     VAR_DEBUG2("ModifyWords: split \"%s\" into %zu words\n", str, 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);
+}
 @@ -2897,1020 +2896,1019 @@ ApplyModifier_Assign(const char **pp, Ap
 	*pp = mod + 2;
 	break;
+    }
     delim = st->startc == '(' ? ')' : '}';
     res = ParseModifierPart(pp, delim, st->eflags, st, &val, NULL, NULL, NULL);
     if (res != VPR_OK)
 	return AMR_CLEANUP;
     (*pp)--;
     if (st->eflags & VARE_WANTRES) {
 	switch (op[0]) {
 	case '+':
 	    Var_Append(st->v->name, val, v_ctxt);
 	    break;
 	case '!': {
 	    const char *errfmt;
 	    char *cmd_output = Cmd_Exec(val, &errfmt);
 	    if (errfmt)
 		Error(errfmt, val);
 	    else
 		Var_Set(st->v->name, cmd_output, v_ctxt);
 	    free(cmd_output);
 	    break;
+	}
 	case '?':
 	    if (!(st->exprFlags & VEF_UNDEF))
 		break;
 	    /* FALLTHROUGH */
 	default:
 	    Var_Set(st->v->name, val, v_ctxt);
 	    break;
+	}
+    }
     free(val);
     st->newVal = emptyString;
     return AMR_OK;
+}
 /* remember current value */
 static ApplyModifierResult
 ApplyModifier_Remember(const char **pp, ApplyModifiersState *st)
+{
     const char *mod = *pp;
     if (!ModMatchEq(mod, "_", st->endc))
 	return AMR_UNKNOWN;
     if (mod[1] == '=') {
 	size_t n = strcspn(mod + 2, ":)}");
 	char *name = bmake_strldup(mod + 2, n);
 	Var_Set(name, st->val, st->ctxt);
 	free(name);
 	*pp = mod + 2 + n;
     } else {
 	Var_Set("_", st->val, st->ctxt);
 	*pp = mod + 1;
+    }
     st->newVal = st->val;
     return AMR_OK;
+}
 /* Apply the given function to each word of the variable value. */
 static ApplyModifierResult
 ApplyModifier_WordFunc(const char **pp, ApplyModifiersState *st,
 		       ModifyWordsCallback modifyWord)
+{
     char delim = (*pp)[1];
     if (delim != st->endc && delim != ':')
 	return AMR_UNKNOWN;
     st->newVal = ModifyWords(st->ctxt, st->sep, st->oneBigWord,
 			     st->val, modifyWord, NULL);
     (*pp)++;
     return AMR_OK;
+}
 static ApplyModifierResult
 ApplyModifier_Unique(const char **pp, ApplyModifiersState *st)
+{
     if ((*pp)[1] == st->endc || (*pp)[1] == ':') {
 	st->newVal = VarUniq(st->val);
 	(*pp)++;
 	return AMR_OK;
     } else
 	return AMR_UNKNOWN;
+}
 #ifdef SYSVVARSUB
 /* :from=to */
 static ApplyModifierResult
 ApplyModifier_SysV(const char **pp, ApplyModifiersState *st)
+{
     char *lhs, *rhs;
     VarParseResult res;
     const char *mod = *pp;
     Boolean eqFound = FALSE;
     /*
      * First we make a pass through the string trying
      * to verify it is a SYSV-make-style translation:
      * it must be: <string1>=<string2>)
      */
     int nest = 1;
     const char *next = mod;
     while (*next != '\0' && nest > 0) {
 	if (*next == '=') {
 	    eqFound = TRUE;
 	    /* continue looking for st->endc */
 	} else if (*next == st->endc)
 	    nest--;
 	else if (*next == st->startc)
 	    nest++;
 	if (nest > 0)
 	    next++;
+    }
     if (*next != st->endc || !eqFound)
 	return AMR_UNKNOWN;
     *pp = mod;
     res = ParseModifierPart(pp, '=', st->eflags, st,
 			    &lhs, NULL, NULL, NULL);
     if (res != VPR_OK)
 	return AMR_CLEANUP;
     res = ParseModifierPart(pp, st->endc, st->eflags, st,
 			    &rhs, NULL, NULL, NULL);
     if (res != VPR_OK)
 	return AMR_CLEANUP;
     /*
      * SYSV modifications happen through the whole
      * string. Note the pattern is anchored at the end.
      */
     (*pp)--;
     if (lhs[0] == '\0' && st->val[0] == '\0') {
 	st->newVal = st->val;	/* special case */
     } else {
 	struct ModifyWord_SYSVSubstArgs args = {st->ctxt, lhs, rhs};
 	st->newVal = ModifyWords(st->ctxt, st->sep, st->oneBigWord, st->val,
 				 ModifyWord_SYSVSubst, &args);
+    }
     free(lhs);
     free(rhs);
     return AMR_OK;
+}
 #endif
 #ifdef SUNSHCMD
 /* :sh */
 static ApplyModifierResult
 ApplyModifier_SunShell(const char **pp, ApplyModifiersState *st)
+{
     const char *p = *pp;
     if (p[1] == 'h' && (p[2] == st->endc || p[2] == ':')) {
 	if (st->eflags & VARE_WANTRES) {
 	    const char *errfmt;
 	    st->newVal = Cmd_Exec(st->val, &errfmt);
 	    if (errfmt)
 		Error(errfmt, st->val);
 	} else
 	    st->newVal = emptyString;
 	*pp = p + 2;
 	return AMR_OK;
     } else
 	return AMR_UNKNOWN;
+}
 #endif
 static void
 LogBeforeApply(const ApplyModifiersState *st, const char *mod, const char endc)
+{
     char eflags_str[VarEvalFlags_ToStringSize];
     char vflags_str[VarFlags_ToStringSize];
     char exprflags_str[VarExprFlags_ToStringSize];
     Boolean is_single_char = mod[0] != '\0' &&
 			     (mod[1] == endc || mod[1] == ':');
     /* At this point, only the first character of the modifier can
      * be used since the end of the modifier is not yet known. */
     debug_printf("Applying ${%s:%c%s} to \"%s\" (%s, %s, %s)\n",
 		 st->v->name, mod[0], is_single_char ? "" : "...", st->val,
 		 Enum_FlagsToString(eflags_str, sizeof eflags_str,
 				    st->eflags, VarEvalFlags_ToStringSpecs),
 		 Enum_FlagsToString(vflags_str, sizeof vflags_str,
 				    st->v->flags, VarFlags_ToStringSpecs),
 		 Enum_FlagsToString(exprflags_str, sizeof exprflags_str,
 				    st->exprFlags,
 				    VarExprFlags_ToStringSpecs));
+}
 static void
 LogAfterApply(ApplyModifiersState *st, const char *p, const char *mod)
+{
     char eflags_str[VarEvalFlags_ToStringSize];
     char vflags_str[VarFlags_ToStringSize];
     char exprflags_str[VarExprFlags_ToStringSize];
     const char *quot = st->newVal == var_Error ? "" : "\"";
     const char *newVal = st->newVal == var_Error ? "error" : st->newVal;
     debug_printf("Result of ${%s:%.*s} is %s%s%s (%s, %s, %s)\n",
 		 st->v->name, (int)(p - mod), mod, quot, newVal, quot,
 		 Enum_FlagsToString(eflags_str, sizeof eflags_str,
 				    st->eflags, VarEvalFlags_ToStringSpecs),
 		 Enum_FlagsToString(vflags_str, sizeof vflags_str,
 				    st->v->flags, VarFlags_ToStringSpecs),
 		 Enum_FlagsToString(exprflags_str, sizeof exprflags_str,
 				    st->exprFlags,
 				    VarExprFlags_ToStringSpecs));
+}
 static ApplyModifierResult
 ApplyModifier(const char **pp, ApplyModifiersState *st)
+{
     switch (**pp) {
     case ':':
 	return ApplyModifier_Assign(pp, st);
     case '@':
 	return ApplyModifier_Loop(pp, st);
     case '_':
 	return ApplyModifier_Remember(pp, st);
     case 'D':
     case 'U':
 	return ApplyModifier_Defined(pp, st);
     case 'L':
 	return ApplyModifier_Literal(pp, st);
     case 'P':
 	return ApplyModifier_Path(pp, st);
     case '!':
 	return ApplyModifier_ShellCommand(pp, st);
     case '[':
 	return ApplyModifier_Words(pp, st);
     case 'g':
 	return ApplyModifier_Gmtime(pp, st);
     case 'h':
 	return ApplyModifier_Hash(pp, st);
     case 'l':
 	return ApplyModifier_Localtime(pp, st);
     case 't':
 	return ApplyModifier_To(pp, st);
     case 'N':
     case 'M':
 	return ApplyModifier_Match(pp, st);
     case 'S':
 	return ApplyModifier_Subst(pp, st);
     case '?':
 	return ApplyModifier_IfElse(pp, st);
 #ifndef NO_REGEX
     case 'C':
 	return ApplyModifier_Regex(pp, st);
 #endif
     case 'q':
     case 'Q':
 	return ApplyModifier_Quote(pp, st);
     case 'T':
 	return ApplyModifier_WordFunc(pp, st, ModifyWord_Tail);
     case 'H':
 	return ApplyModifier_WordFunc(pp, st, ModifyWord_Head);
     case 'E':
 	return ApplyModifier_WordFunc(pp, st, ModifyWord_Suffix);
     case 'R':
 	return ApplyModifier_WordFunc(pp, st, ModifyWord_Root);
     case 'r':
 	return ApplyModifier_Range(pp, st);
     case 'O':
 	return ApplyModifier_Order(pp, st);
     case 'u':
 	return ApplyModifier_Unique(pp, st);
 #ifdef SUNSHCMD
     case 's':
 	return ApplyModifier_SunShell(pp, st);
 #endif
     default:
 	return AMR_UNKNOWN;
+    }
+}
 /* Apply any modifiers (such as :Mpattern or :@var@loop@ or :Q or ::=value). */
 static char *
 ApplyModifiers(
     const char **pp,		/* the parsing position, updated upon return */
     char *val,			/* the current value of the variable */
     char const startc,		/* '(' or '{', or '\0' for indirect modifiers */
     char const endc,		/* ')' or '}', or '\0' for indirect modifiers */
     Var * const v,
     VarExprFlags *exprFlags,
     GNode * const ctxt,		/* for looking up and modifying variables */
     VarEvalFlags const eflags,
     void ** const freePtr	/* free this after using the return value */
 ) {
     ApplyModifiersState st = {
 	startc, endc, v, ctxt, eflags, val,
 	var_Error,		/* .newVal */
 	' ',			/* .sep */
 	FALSE,			/* .oneBigWord */
 	*exprFlags		/* .exprFlags */
     };
     const char *p;
     const char *mod;
     ApplyModifierResult res;
     assert(startc == '(' || startc == '{' || startc == '\0');
     assert(endc == ')' || endc == '}' || endc == '\0');
     assert(val != NULL);
     p = *pp;
     while (*p != '\0' && *p != endc) {
 	if (*p == '$') {
 	    /*
 	     * We may have some complex modifiers in a variable.
 	     */
 	    const char *nested_p = p;
 	    void *freeIt;
 	    const char *rval;
 	    char c;
 	    (void)Var_Parse(&nested_p, st.ctxt, st.eflags, &rval, &freeIt);
 	    /* TODO: handle errors */
 	    /*
 	     * If we have not parsed up to st.endc or ':', we are not
 	     * interested.  This means the expression ${VAR:${M_1}${M_2}}
 	     * is not accepted, but ${VAR:${M_1}:${M_2}} is.
 	     */
 	    if (rval[0] != '\0' &&
 		(c = *nested_p) != '\0' && c != ':' && c != st.endc) {
 		if (DEBUG(LINT))
 		    Parse_Error(PARSE_FATAL,
 				"Missing delimiter ':' after indirect modifier \"%.*s\"",
 				(int)(nested_p - p), p);
 		free(freeIt);
 		/* XXX: apply_mods doesn't sound like "not interested". */
 		/* XXX: Why is the indirect modifier parsed again by
 		 * apply_mods?  If any, p should be advanced to nested_p. */
 		goto apply_mods;
+	    }
 	    VAR_DEBUG3("Indirect modifier \"%s\" from \"%.*s\"\n",
 		       rval, (int)(size_t)(nested_p - p), p);
 	    p = nested_p;
 	    if (rval[0] != '\0') {
 		const char *rval_pp = rval;
 		st.val = ApplyModifiers(&rval_pp, st.val, '\0', '\0', v,
 					&st.exprFlags, ctxt, eflags, freePtr);
 		if (st.val == var_Error
 		    || (st.val == varUndefined && !(st.eflags & VARE_UNDEFERR))
 		    || *rval_pp != '\0') {
 		    free(freeIt);
 		    goto out;	/* error already reported */
+		}
+	    }
 	    free(freeIt);
 	    if (*p == ':')
 		p++;
 	    else if (*p == '\0' && endc != '\0') {
 		Error("Unclosed variable specification after complex "
 		      "modifier (expecting '%c') for %s", st.endc, st.v->name);
 		goto out;
+	    }
 	    continue;
+	}
     apply_mods:
 	st.newVal = var_Error;	/* default value, in case of errors */
 	mod = p;
 	if (DEBUG(VAR))
 	    LogBeforeApply(&st, mod, endc);
 	res = ApplyModifier(&p, &st);
 #ifdef SYSVVARSUB
 	if (res == AMR_UNKNOWN) {
 	    assert(p == mod);
 	    res = ApplyModifier_SysV(&p, &st);
+	}
 #endif
 	if (res == AMR_UNKNOWN) {
 	    Error("Unknown modifier '%c'", *mod);
 	    for (p++; *p != ':' && *p != st.endc && *p != '\0'; p++)
 		continue;
 	    st.newVal = var_Error;
+	}
 	if (res == AMR_CLEANUP)
 	    goto cleanup;
 	if (res == AMR_BAD)
 	    goto bad_modifier;
 	if (DEBUG(VAR))
 	    LogAfterApply(&st, p, mod);
 	if (st.newVal != st.val) {
 	    if (*freePtr) {
 		free(st.val);
 		*freePtr = NULL;
+	    }
 	    st.val = st.newVal;
 	    if (st.val != var_Error && st.val != varUndefined &&
 		st.val != emptyString) {
 		*freePtr = st.val;
+	    }
+	}
 	if (*p == '\0' && st.endc != '\0') {
 	    Error("Unclosed variable specification (expecting '%c') "
 		  "for \"%s\" (value \"%s\") modifier %c",
 		  st.endc, st.v->name, st.val, *mod);
 	} else if (*p == ':') {
 	    p++;
 	} else if (DEBUG(LINT) && *p != '\0' && *p != endc) {
 	    Parse_Error(PARSE_FATAL,
 			"Missing delimiter ':' after modifier \"%.*s\"",
 			(int)(p - mod), mod);
+	}
+    }
 out:
     *pp = p;
     assert(st.val != NULL);	/* Use var_Error or varUndefined instead. */
     *exprFlags = st.exprFlags;
     return st.val;
 bad_modifier:
     Error("Bad modifier `:%.*s' for %s",
 	  (int)strcspn(mod, ":)}"), mod, st.v->name);
 cleanup:
     *pp = p;
     free(*freePtr);
     *freePtr = NULL;
     *exprFlags = st.exprFlags;
     return var_Error;
+}
 static Boolean
 VarIsDynamic(GNode *ctxt, const char *varname, size_t namelen)
+{
     if ((namelen == 1 ||
 	 (namelen == 2 && (varname[1] == 'F' || varname[1] == 'D'))) &&
 	(ctxt == VAR_CMDLINE || ctxt == VAR_GLOBAL))
+    {
 	/*
 	 * If substituting a local variable in a non-local context,
 	 * assume it's for dynamic source stuff. We have to handle
 	 * this specially and return the longhand for the variable
 	 * with the dollar sign escaped so it makes it back to the
 	 * caller. Only four of the local variables are treated
 	 * specially as they are the only four that will be set
 	 * when dynamic sources are expanded.
 	 */
 	switch (varname[0]) {
 	case '@':
 	case '%':
 	case '*':
 	case '!':
 	    return TRUE;
+	}
 	return FALSE;
+    }
     if ((namelen == 7 || namelen == 8) && varname[0] == '.' &&
 	ch_isupper(varname[1]) && (ctxt == VAR_CMDLINE || ctxt == VAR_GLOBAL))
+    {
 	return strcmp(varname, ".TARGET") == 0 ||
 	       strcmp(varname, ".ARCHIVE") == 0 ||
 	       strcmp(varname, ".PREFIX") == 0 ||
 	       strcmp(varname, ".MEMBER") == 0;
+    }
     return FALSE;
+}
 static const char *
 UndefinedShortVarValue(char varname, const GNode *ctxt, VarEvalFlags eflags)
+{
     if (ctxt == VAR_CMDLINE || ctxt == VAR_GLOBAL) {
 	/*
 	 * If substituting a local variable in a non-local context,
 	 * assume it's for dynamic source stuff. We have to handle
 	 * this specially and return the longhand for the variable
 	 * with the dollar sign escaped so it makes it back to the
 	 * caller. Only four of the local variables are treated
 	 * specially as they are the only four that will be set
 	 * when dynamic sources are expanded.
 	 */
 	switch (varname) {
 	case '@':
 	    return "$(.TARGET)";
 	case '%':
 	    return "$(.MEMBER)";
 	case '*':
 	    return "$(.PREFIX)";
 	case '!':
 	    return "$(.ARCHIVE)";
+	}
+    }
     return eflags & VARE_UNDEFERR ? var_Error : varUndefined;
+}
 /* Parse a variable name, until the end character or a colon, whichever
  * comes first. */
 static char *
 ParseVarname(const char **pp, char startc, char endc,
 	     GNode *ctxt, VarEvalFlags eflags,
 	     size_t *out_varname_len)
+{
     Buffer buf;
     const char *p = *pp;
     int depth = 1;
     Buf_Init(&buf, 0);
     while (*p != '\0') {
 	/* Track depth so we can spot parse errors. */
 	if (*p == startc)
 	    depth++;
 	if (*p == endc) {
 	    if (--depth == 0)
 		break;
+	}
 	if (*p == ':' && depth == 1)
 	    break;
 	/* A variable inside a variable, expand. */
 	if (*p == '$') {
 	    void *freeIt;
 	    const char *rval;
 	    (void)Var_Parse(&p, ctxt, eflags, &rval, &freeIt);
 	    /* TODO: handle errors */
 	    Buf_AddStr(&buf, rval);
 	    free(freeIt);
 	} else {
 	    Buf_AddByte(&buf, *p);
 	    p++;
+	}
+    }
     *pp = p;
     *out_varname_len = Buf_Len(&buf);
     return Buf_Destroy(&buf, FALSE);
+}
 static Boolean
 ValidShortVarname(char varname, const char *start)
+{
     switch (varname) {
     case '\0':
     case ')':
     case '}':
     case ':':
     case '$':
 	break;			/* and continue below */
     default:
 	return TRUE;
+    }
     if (!DEBUG(LINT))
 	return FALSE;
     if (varname == '$')
 	Parse_Error(PARSE_FATAL,
 		    "To escape a dollar, use \\$, not $$, at \"%s\"", start);
     else if (varname == '\0')
 	Parse_Error(PARSE_FATAL, "Dollar followed by nothing");
     else
 	Parse_Error(PARSE_FATAL,
 		    "Invalid variable name '%c', at \"%s\"", varname, start);
     return FALSE;
+}
 /*-
  *-----------------------------------------------------------------------
  * Var_Parse --
  *	Given the start of a variable expression (such as $v, $(VAR),
  *	${VAR:Mpattern}), extract the variable name, possibly some
  *	modifiers and find its value by applying the modifiers to the
  *	original value.
+ *
  *	When parsing a condition in ParseEmptyArg, pp may also point to
  *	the "y" of "empty(VARNAME:Modifiers)", which is syntactically
  *	identical.
+ *
  * Input:
  *	str		The string to parse
  *	ctxt		The context for the variable
  *	flags		VARE_UNDEFERR	if undefineds are an error
  *			VARE_WANTRES	if we actually want the result
  *			VARE_ASSIGN	if we are in a := assignment
  *	lengthPtr	OUT: The length of the specification
  *	freePtr		OUT: Non-NULL if caller should free *freePtr
+ *
  * Results:
  *	Returns the value of the variable expression, never NULL.
  *	Returns var_Error if there was a parse error and VARE_UNDEFERR was
  *	set.
  *	Returns varUndefined if there was an undefined variable and
  *	VARE_UNDEFERR was not set.
+ *
  *	Parsing should continue at *pp.
  *	TODO: Document the value of *pp on parse errors.  It might be advanced
  *	by 0, or +1, or the index of the parse error, or the guessed end of the
  *	variable expression.
+ *
  *	If var_Error is returned, a diagnostic may or may not have been
  *	printed. XXX: This is inconsistent.
+ *
  *	If varUndefined is returned, a diagnostic may or may not have been
  *	printed. XXX: This is inconsistent.
+ *
  *	After using the returned value, *freePtr must be freed, preferably
  *	using bmake_free since it is NULL in most cases.
+ *
  * Side Effects:
  *	Any effects from the modifiers, such as :!cmd! or ::=value.
  *-----------------------------------------------------------------------
  */
 /* coverity[+alloc : arg-*4] */
 VarParseResult
 Var_Parse(const char **pp, GNode *ctxt, VarEvalFlags eflags,
 	  const char **out_val, void **freePtr)
+{
     const char *const start = *pp;
     const char *p;
     Boolean haveModifier;	/* TRUE if have modifiers for the variable */
     char startc;		/* Starting character if variable in parens
 				 * or braces */
     char endc;			/* Ending character if variable in parens
 				 * or braces */
     Boolean dynamic;		/* TRUE if the variable is local and we're
 				 * expanding it in a non-local context. This
 				 * is done to support dynamic sources. The
 				 * result is just the expression, unaltered */
     const char *extramodifiers;
     Var *v;
     char *nstr;
     char eflags_str[VarEvalFlags_ToStringSize];
     VarExprFlags exprFlags = 0;
     VAR_DEBUG3("%s: %s with %s\n", __func__, start,
 	       Enum_FlagsToString(eflags_str, sizeof eflags_str, eflags,
 				  VarEvalFlags_ToStringSpecs));
     *freePtr = NULL;
     extramodifiers = NULL;	/* extra modifiers to apply first */
     dynamic = FALSE;
     /* Appease GCC, which thinks that the variable might not be
      * initialized. */
     endc = '\0';
     startc = start[1];
     if (startc != '(' && startc != '{') {
 	char name[2];
 	/*
 	 * If it's not bounded by braces of some sort, life is much simpler.
 	 * We just need to check for the first character and return the
 	 * value if it exists.
 	 */
 	if (!ValidShortVarname(startc, start)) {
 	    (*pp)++;
 	    *out_val = var_Error;
 	    return VPR_PARSE_MSG;
+	}
 	name[0] = startc;
 	name[1] = '\0';
 	v = VarFind(name, ctxt, TRUE);
 	if (v == NULL) {
 	    *pp += 2;
 	    *out_val = UndefinedShortVarValue(startc, ctxt, eflags);
 	    if (DEBUG(LINT) && *out_val == var_Error) {
 		Parse_Error(PARSE_FATAL, "Variable \"%s\" is undefined", name);
 		return VPR_UNDEF_MSG;
+	    }
 	    return eflags & VARE_UNDEFERR ? VPR_UNDEF_SILENT : VPR_OK;
 	} else {
 	    haveModifier = FALSE;
 	    p = start + 1;
+	}
     } else {
 	size_t namelen;
 	char *varname;
 	endc = startc == '(' ? ')' : '}';
 	p = start + 2;
 	varname = ParseVarname(&p, startc, endc, ctxt, eflags, &namelen);
 	if (*p == ':') {
 	    haveModifier = TRUE;
 	} else if (*p == endc) {
 	    haveModifier = FALSE;
 	} else {
 	    Parse_Error(PARSE_FATAL, "Unclosed variable \"%s\"", varname);
 	    *pp = p;
 	    free(varname);
 	    *out_val = var_Error;
 	    return VPR_PARSE_MSG;
+	}
 	v = VarFind(varname, ctxt, TRUE);
 	/* At this point, p points just after the variable name,
 	 * either at ':' or at endc. */
 	/*
 	 * Check also for bogus D and F forms of local variables since we're
 	 * in a local context and the name is the right length.
 	 */
 	if (v == NULL && ctxt != VAR_CMDLINE && ctxt != VAR_GLOBAL &&
 	    namelen == 2 && (varname[1] == 'F' || varname[1] == 'D') &&
 	    strchr("@%?*!<>", varname[0]) != NULL)
+	{
 	    /*
 	     * Well, it's local -- go look for it.
 	     */
 	    char name[] = { varname[0], '\0' };
 	    v = VarFind(name, ctxt, 0);
 	    if (v != NULL) {
 		if (varname[1] == 'D') {
 		    extramodifiers = "H:";
 		} else { /* F */
 		    extramodifiers = "T:";
+		}
+	    }
+	}
 	if (v == NULL) {
 	    dynamic = VarIsDynamic(ctxt, varname, namelen);
 	    if (!haveModifier) {
 		p++;		/* skip endc */
 		*pp = p;
 		if (dynamic) {
 		    char *pstr = bmake_strsedup(start, p);
 		    *freePtr = pstr;
 		    free(varname);
 		    *out_val = pstr;
 		    return VPR_OK;
+		}
 		if ((eflags & VARE_UNDEFERR) && (eflags & VARE_WANTRES) &&
 		    DEBUG(LINT))
+		{
 		    Parse_Error(PARSE_FATAL, "Variable \"%s\" is undefined",
 				varname);
 		    free(varname);
 		    *out_val = var_Error;
 		    return VPR_UNDEF_MSG;
+		}
 		if (eflags & VARE_UNDEFERR) {
 		    free(varname);
 		    *out_val = var_Error;
 		    return VPR_UNDEF_SILENT;
+		}
 		free(varname);
 		*out_val = varUndefined;
 		return VPR_OK;
+	    }
 	    /* The variable expression is based on an undefined variable.
 	     * Nevertheless it needs a Var, for modifiers that access the
 	     * variable name, such as :L or :?.
+	     *
 	     * Most modifiers leave this expression in the "undefined" state
 	     * (VEF_UNDEF), only a few modifiers like :D, :U, :L, :P turn this
 	     * undefined expression into a defined expression (VEF_DEF).
+	     *
 	     * At the end, after applying all modifiers, if the expression
 	     * is still undefined, Var_Parse will return an empty string
 	     * instead of the actually computed value. */
 	    v = VarNew(varname, varname, "", 0);
 	    exprFlags = VEF_UNDEF;
 	} else
 	    free(varname);
+    }
     if (v->flags & VAR_IN_USE) {
 	Fatal("Variable %s is recursive.", v->name);
 	/*NOTREACHED*/
     } else {
 	v->flags |= VAR_IN_USE;
+    }
     /*
      * Before doing any modification, we have to make sure the value
      * has been fully expanded. If it looks like recursion might be
      * necessary (there's a dollar sign somewhere in the variable's value)
      * we just call Var_Subst to do any other substitutions that are
      * necessary. Note that the value returned by Var_Subst will have
      * been dynamically-allocated, so it will need freeing when we
      * return.
      */
     nstr = Buf_GetAll(&v->val, NULL);
     if (strchr(nstr, '$') != NULL && (eflags & VARE_WANTRES)) {
 	VarEvalFlags nested_eflags = eflags;
 	if (DEBUG(LINT))
 	    nested_eflags &= ~(unsigned)VARE_UNDEFERR;
 	(void)Var_Subst(nstr, ctxt, nested_eflags, &nstr);
 	/* TODO: handle errors */
 	*freePtr = nstr;
+    }
     v->flags &= ~(unsigned)VAR_IN_USE;
     if (haveModifier || extramodifiers != NULL) {
 	void *extraFree;
 	extraFree = NULL;
 	if (extramodifiers != NULL) {
 	    const char *em = extramodifiers;
 	    nstr = ApplyModifiers(&em, nstr, '(', ')',
 				  v, &exprFlags, ctxt, eflags, &extraFree);
+	}
 	if (haveModifier) {
 	    /* Skip initial colon. */
 	    p++;
 	    nstr = ApplyModifiers(&p, nstr, startc, endc,
 				  v, &exprFlags, ctxt, eflags, freePtr);
 	    free(extraFree);
 	} else {
 	    *freePtr = extraFree;
+	}
+    }
     if (*p != '\0')		/* Skip past endc if possible. */
 	p++;
     *pp = p;
     if (v->flags & VAR_FROM_ENV) {
 	/* Free the environment variable now since we own it,
 	 * but don't free the variable value if it will be returned. */
 	Boolean keepValue = nstr == Buf_GetAll(&v->val, NULL);
 	if (keepValue)
 	    *freePtr = nstr;
 	(void)VarFreeEnv(v, !keepValue);
     } else if (exprFlags & VEF_UNDEF) {
 	if (!(exprFlags & VEF_DEF)) {
 	    if (*freePtr != NULL) {
 		free(*freePtr);
 		*freePtr = NULL;
+	    }
 	    if (dynamic) {
 		nstr = bmake_strsedup(start, p);
 		*freePtr = nstr;
 	    } else {
 		/* The expression is still undefined, therefore discard the
 		 * actual value and return an error marker instead. */
 		nstr = (eflags & VARE_UNDEFERR) ? var_Error : varUndefined;
+	    }
+	}
 	if (nstr != Buf_GetAll(&v->val, NULL))
 	    Buf_Destroy(&v->val, TRUE);
 	free(v->name_freeIt);
 	free(v);
+    }
     *out_val = nstr;
     return VPR_UNKNOWN;
+}
 /* Substitute for all variables in the given string in the given context.
+ *
  * If eflags & VARE_UNDEFERR, Parse_Error will be called when an undefined
  * variable is encountered.
+ *
  * If eflags & VARE_WANTRES, any effects from the modifiers, such as ::=,
  * :sh or !cmd! take place.
+ *
  * Input:
  *	str		the string which to substitute
  *	ctxt		the context wherein to find variables
  *	eflags		VARE_UNDEFERR	if undefineds are an error
  *			VARE_WANTRES	if we actually want the result
  *			VARE_ASSIGN	if we are in a := assignment
+ *
  * Results:
  *	The resulting string.
  */
 VarParseResult
 Var_Subst(const char *str, GNode *ctxt, VarEvalFlags eflags, char **out_res)
+{
     const char *p = str;
     Buffer buf;			/* Buffer for forming things */
     /* Set true if an error has already been reported,
      * to prevent a plethora of messages when recursing */
     static Boolean errorReported;
     Buf_Init(&buf, 0);
     errorReported = FALSE;
     while (*p != '\0') {
 	if (p[0] == '$' && p[1] == '$') {
 	    /* A dollar sign may be escaped with another dollar sign. */
 	    if (save_dollars && (eflags & VARE_ASSIGN))
 		Buf_AddByte(&buf, '$');
 	    Buf_AddByte(&buf, '$');
 	    p += 2;
 	} else if (*p != '$') {
 	    /*
 	     * Skip as many characters as possible -- either to the end of
 	     * the string or to the next dollar sign (variable expression).
 	     */
 	    const char *plainStart = p;
 	    for (p++; *p != '$' && *p != '\0'; p++)
 		continue;
 	    Buf_AddBytesBetween(&buf, plainStart, p);
 	} else {
 	    const char *nested_p = p;
 	    void *freeIt;
 	    const char *val;
 	    (void)Var_Parse(&nested_p, ctxt, eflags, &val, &freeIt);
 	    /* TODO: handle errors */
 	    if (val == var_Error || val == varUndefined) {
 		/*
 		 * If performing old-time variable substitution, skip over
 		 * the variable and continue with the substitution. Otherwise,
 		 * store the dollar sign and advance str so we continue with
 		 * the string...
 		 */
 		if (oldVars) {
 		    p = nested_p;
 		} else if ((eflags & VARE_UNDEFERR) || val == var_Error) {
 		    /*
 		     * If variable is undefined, complain and skip the
 		     * variable. The complaint will stop us from doing anything
 		     * when the file is parsed.
 		     */
 		    if (!errorReported) {
 			Parse_Error(PARSE_FATAL, "Undefined variable \"%.*s\"",
 				    (int)(size_t)(nested_p - p), p);
+		    }
 		    p = nested_p;
 		    errorReported = TRUE;
 		} else {
 		    /* Copy the initial '$' of the undefined expression,
 		     * thereby deferring expansion of the expression, but
 		     * expand nested expressions if already possible.
 		     * See unit-tests/varparse-undef-partial.mk. */
 		    Buf_AddByte(&buf, *p);
 		    p++;
+		}
 	    } else {
 		p = nested_p;
 		Buf_AddStr(&buf, val);
+	    }
 	    free(freeIt);
 	    freeIt = NULL;
+	}
+    }
     *out_res = Buf_DestroyCompact(&buf);
     return VPR_OK;
+}
 /* Initialize the variables module. */
 void
 Var_Init(void)
+{
     VAR_INTERNAL = Targ_NewGN("Internal");
     VAR_GLOBAL = Targ_NewGN("Global");
     VAR_CMDLINE = Targ_NewGN("Command");
+}
 /* Clean up the variables module. */
 void
 Var_End(void)
+{
     Var_Stats();
+}
 void
 Var_Stats(void)
+{
     HashTable_DebugStats(&VAR_GLOBAL->context, "VAR_GLOBAL");
+}
 /* Print all variables in a context, sorted by name. */
 void
 Var_Dump(GNode *ctxt)
+{
     Vector /* of const char * */ vec;
     HashIter hi;
     HashEntry *he;
     size_t i;
     const char **varnames;
     Vector_Init(&vec, sizeof(const char *));
     HashIter_Init(&hi, &ctxt->context);
-    while ((he = HashIter_Next(&hi)) != NULL)
+    while (HashIter_Next(&hi) != NULL)
-	*(const char **)Vector_Push(&vec) = he->key;
+	*(const char **)Vector_Push(&vec) = hi.entry->key;
     varnames = vec.items;
     qsort(varnames, vec.len, sizeof varnames[0], str_cmp_asc);
     for (i = 0; i < vec.len; i++) {
 	const char *varname = varnames[i];
 	Var *var = HashTable_FindValue(&ctxt->context, varname);
 	debug_printf("%-16s = %s\n", varname, Buf_GetAll(&var->val, NULL));
+    }
     Vector_Done(&vec);
+}