 @@ -1,1325 +1,1325 @@
-/*	$NetBSD: dir.c,v 1.129 2020/09/01 20:17:18 rillig Exp $	*/
+/*	$NetBSD: dir.c,v 1.130 2020/09/01 21:11:31 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 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) 1988, 1989 by Adam de Boor
  * 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.
  */
 #ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: dir.c,v 1.129 2020/09/01 20:17:18 rillig Exp $";
+static char rcsid[] = "$NetBSD: dir.c,v 1.130 2020/09/01 21:11:31 rillig Exp $";
 #else
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)dir.c	8.2 (Berkeley) 1/2/94";
 #else
-__RCSID("$NetBSD: dir.c,v 1.129 2020/09/01 20:17:18 rillig Exp $");
+__RCSID("$NetBSD: dir.c,v 1.130 2020/09/01 21:11:31 rillig Exp $");
 #endif
 #endif /* not lint */
 #endif
 /*-
  * dir.c --
  *	Directory searching using wildcards and/or normal names...
  *	Used both for source wildcarding in the Makefile and for finding
  *	implicit sources.
+ *
  * The interface for this module is:
  *	Dir_Init  	    Initialize the module.
+ *
  *	Dir_InitCur	    Set the cur Path.
+ *
  *	Dir_InitDot	    Set the dot Path.
+ *
  *	Dir_End  	    Cleanup the module.
+ *
  *	Dir_SetPATH	    Set ${.PATH} to reflect state of dirSearchPath.
+ *
  *	Dir_HasWildcards    Returns TRUE if the name given it needs to
  *	    	  	    be wildcard-expanded.
+ *
  *	Dir_Expand	    Given a pattern and a path, return a Lst of names
  *	    	  	    which match the pattern on the search path.
+ *
  *	Dir_FindFile	    Searches for a file on a given search path.
  *	    	  	    If it exists, the entire path is returned.
  *	    	  	    Otherwise NULL is returned.
+ *
  *	Dir_FindHereOrAbove Search for a path in the current directory and
  *			    then all the directories above it in turn until
  *			    the path is found or we reach the root ("/").
+ *
  *	Dir_MTime 	    Return the modification time of a node. The file
  *	    	  	    is searched for along the default search path.
  *	    	  	    The path and mtime fields of the node are filled
  *	    	  	    in.
+ *
  *	Dir_AddDir	    Add a directory to a search path.
+ *
  *	Dir_MakeFlags	    Given a search path and a command flag, create
  *	    	  	    a string with each of the directories in the path
  *	    	  	    preceded by the command flag and all of them
  *	    	  	    separated by a space.
+ *
  *	Dir_Destroy	    Destroy an element of a search path. Frees up all
  *	    	  	    things that can be freed for the element as long
  *	    	  	    as the element is no longer referenced by any other
  *	    	  	    search path.
  *	Dir_ClearPath	    Resets a search path to the empty list.
+ *
  * For debugging:
  *	Dir_PrintDirectories	Print stats about the directory cache.
  */
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <dirent.h>
 #include <errno.h>
 #include <stdio.h>
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 #define DIR_DEBUG0(fmt) \
     if (!DEBUG(DIR)) (void) 0; else fprintf(debug_file, fmt)
 #define DIR_DEBUG1(fmt, arg1) \
     if (!DEBUG(DIR)) (void) 0; else fprintf(debug_file, fmt, arg1)
 #define DIR_DEBUG2(fmt, arg1, arg2) \
     if (!DEBUG(DIR)) (void) 0; else fprintf(debug_file, fmt, arg1, arg2)
 /*
  *	A search path consists of a Lst of Path structures. A Path structure
  *	has in it the name of the directory and a hash table of all the files
  *	in the directory. This is used to cut down on the number of system
  *	calls necessary to find implicit dependents and their like. Since
  *	these searches are made before any actions are taken, we need not
  *	worry about the directory changing due to creation commands. If this
  *	hampers the style of some makefiles, they must be changed.
+ *
  *	A list of all previously-read directories is kept in the
  *	openDirectories Lst. This list is checked first before a directory
  *	is opened.
+ *
  *	The need for the caching of whole directories is brought about by
  *	the multi-level transformation code in suff.c, which tends to search
  *	for far more files than regular make does. In the initial
  *	implementation, the amount of time spent performing "stat" calls was
  *	truly astronomical. The problem with hashing at the start is,
  *	of course, that pmake doesn't then detect changes to these directories
  *	during the course of the make. Three possibilities suggest themselves:
+ *
  *	    1) just use stat to test for a file's existence. As mentioned
  *	       above, this is very inefficient due to the number of checks
  *	       engendered by the multi-level transformation code.
  *	    2) use readdir() and company to search the directories, keeping
  *	       them open between checks. I have tried this and while it
  *	       didn't slow down the process too much, it could severely
  *	       affect the amount of parallelism available as each directory
  *	       open would take another file descriptor out of play for
  *	       handling I/O for another job. Given that it is only recently
  *	       that UNIX OS's have taken to allowing more than 20 or 32
  *	       file descriptors for a process, this doesn't seem acceptable
  *	       to me.
  *	    3) record the mtime of the directory in the Path structure and
  *	       verify the directory hasn't changed since the contents were
  *	       hashed. This will catch the creation or deletion of files,
  *	       but not the updating of files. However, since it is the
  *	       creation and deletion that is the problem, this could be
  *	       a good thing to do. Unfortunately, if the directory (say ".")
  *	       were fairly large and changed fairly frequently, the constant
  *	       rehashing could seriously degrade performance. It might be
  *	       good in such cases to keep track of the number of rehashes
  *	       and if the number goes over a (small) limit, resort to using
  *	       stat in its place.
+ *
  *	An additional thing to consider is that pmake is used primarily
  *	to create C programs and until recently pcc-based compilers refused
  *	to allow you to specify where the resulting object file should be
  *	placed. This forced all objects to be created in the current
  *	directory. This isn't meant as a full excuse, just an explanation of
  *	some of the reasons for the caching used here.
+ *
  *	One more note: the location of a target's file is only performed
  *	on the downward traversal of the graph and then only for terminal
  *	nodes in the graph. This could be construed as wrong in some cases,
  *	but prevents inadvertent modification of files when the "installed"
  *	directory for a file is provided in the search path.
+ *
  *	Another data structure maintained by this module is an mtime
  *	cache used when the searching of cached directories fails to find
  *	a file. In the past, Dir_FindFile would simply perform an access()
  *	call in such a case to determine if the file could be found using
  *	just the name given. When this hit, however, all that was gained
  *	was the knowledge that the file existed. Given that an access() is
  *	essentially a stat() without the copyout() call, and that the same
  *	filesystem overhead would have to be incurred in Dir_MTime, it made
  *	sense to replace the access() with a stat() and record the mtime
  *	in a cache for when Dir_MTime was actually called.
  */
 Lst dirSearchPath;		/* main search path */
 static Lst openDirectories;	/* the list of all open directories */
 /*
  * Variables for gathering statistics on the efficiency of the hashing
  * mechanism.
  */
 static int hits;		/* Found in directory cache */
 static int misses;		/* Sad, but not evil misses */
 static int nearmisses;		/* Found under search path */
 static int bigmisses;		/* Sought by itself */
 static Path *dot;		/* contents of current directory */
 static Path *cur;		/* contents of current directory, if not dot */
 static Path *dotLast;		/* a fake path entry indicating we need to
 				 * look for . last */
 /* Results of doing a last-resort stat in Dir_FindFile -- if we have to go to
  * the system to find the file, we might as well have its mtime on record.
+ *
  * XXX: If this is done way early, there's a chance other rules will have
  * already updated the file, in which case we'll update it again. Generally,
  * there won't be two rules to update a single file, so this should be ok,
  * but... */
 static Hash_Table mtimes;
 static Hash_Table lmtimes;	/* same as mtimes but for lstat */
 static void DirExpandCurly(const char *, const char *, Lst, Lst);
 static void DirExpandInt(const char *, Lst, Lst);
 static int DirPrintWord(void *, void *);
 static int DirPrintDir(void *, void *);
 static char *DirLookup(Path *, const char *, const char *, Boolean);
 static char *DirLookupSubdir(Path *, const char *);
 static char *DirFindDot(Boolean, const char *, const char *);
 static char *DirLookupAbs(Path *, const char *, const char *);
 /*
  * We use stat(2) a lot, cache the results.
  * mtime and mode are all we care about.
  */
 struct cache_st {
     time_t lmtime;		/* lstat */
     time_t mtime;		/* stat */
     mode_t mode;
 };
 /* minimize changes below */
 typedef enum {
     CST_LSTAT = 0x01,		/* call lstat(2) instead of stat(2) */
     CST_UPDATE = 0x02		/* ignore existing cached entry */
 } CachedStatsFlags;
 /* Returns 0 and the result of stat(2) or lstat(2) in *st, or -1 on error.
  * Only st->st_mode and st->st_mtime are filled. */
 static int
 cached_stats(Hash_Table *htp, const char *pathname, struct stat *st,
 	     CachedStatsFlags flags)
+{
     Hash_Entry *entry;
     struct cache_st *cst;
     int rc;
     if (!pathname || !pathname[0])
 	return -1;
     entry = Hash_FindEntry(htp, pathname);
     if (entry && !(flags & CST_UPDATE)) {
-	cst = entry->clientPtr;
+	cst = entry->value;
 	memset(st, 0, sizeof(*st));
 	st->st_mode = cst->mode;
 	st->st_mtime = (flags & CST_LSTAT) ? cst->lmtime : cst->mtime;
 	if (st->st_mtime) {
 	    DIR_DEBUG2("Using cached time %s for %s\n",
 		       Targ_FmtTime(st->st_mtime), pathname);
 	    return 0;
+	}
+    }
     rc = (flags & CST_LSTAT) ? lstat(pathname, st) : stat(pathname, st);
     if (rc == -1)
 	return -1;
     if (st->st_mtime == 0)
 	st->st_mtime = 1;	/* avoid confusion with missing file */
     if (!entry)
 	entry = Hash_CreateEntry(htp, pathname, NULL);
-    if (!entry->clientPtr) {
+    if (!entry->value) {
-	entry->clientPtr = bmake_malloc(sizeof(*cst));
+	entry->value = bmake_malloc(sizeof(*cst));
-	memset(entry->clientPtr, 0, sizeof(*cst));
+	memset(entry->value, 0, sizeof(*cst));
+    }
-    cst = entry->clientPtr;
+    cst = entry->value;
     if (flags & CST_LSTAT) {
 	cst->lmtime = st->st_mtime;
     } else {
 	cst->mtime = st->st_mtime;
+    }
     cst->mode = st->st_mode;
     DIR_DEBUG2("   Caching %s for %s\n",
 	       Targ_FmtTime(st->st_mtime), pathname);
     return 0;
+}
 int
 cached_stat(const char *pathname, void *st)
+{
     return cached_stats(&mtimes, pathname, st, 0);
+}
 int
 cached_lstat(const char *pathname, void *st)
+{
     return cached_stats(&lmtimes, pathname, st, CST_LSTAT);
+}
 /* Initialize things for this module. */
 void
 Dir_Init(void)
+{
     dirSearchPath = Lst_Init();
     openDirectories = Lst_Init();
     Hash_InitTable(&mtimes, 0);
     Hash_InitTable(&lmtimes, 0);
+}
 void
 Dir_InitDir(const char *cdname)
+{
     Dir_InitCur(cdname);
     dotLast = bmake_malloc(sizeof(Path));
     dotLast->refCount = 1;
     dotLast->hits = 0;
     dotLast->name = bmake_strdup(".DOTLAST");
     Hash_InitTable(&dotLast->files, -1);
+}
 /*
  * Called by Dir_InitDir and whenever .CURDIR is assigned to.
  */
 void
 Dir_InitCur(const char *cdname)
+{
     Path *p;
     if (cdname != NULL) {
 	/*
 	 * Our build directory is not the same as our source directory.
 	 * Keep this one around too.
 	 */
 	if ((p = Dir_AddDir(NULL, cdname))) {
 	    p->refCount += 1;
 	    if (cur && cur != p) {
 		/*
 		 * We've been here before, cleanup.
 		 */
 		cur->refCount -= 1;
 		Dir_Destroy(cur);
+	    }
 	    cur = p;
+	}
+    }
+}
 /* (Re)initialize "dot" (current/object directory) path hash.
  * Some directories may be opened. */
 void
 Dir_InitDot(void)
+{
     if (dot != NULL) {
 	LstNode ln;
 	/* Remove old entry from openDirectories, but do not destroy. */
 	ln = Lst_FindDatum(openDirectories, dot);
 	Lst_Remove(openDirectories, ln);
+    }
     dot = Dir_AddDir(NULL, ".");
     if (dot == NULL) {
 	Error("Cannot open `.' (%s)", strerror(errno));
 	exit(1);
+    }
     /*
      * We always need to have dot around, so we increment its reference count
      * to make sure it's not destroyed.
      */
     dot->refCount += 1;
     Dir_SetPATH();		/* initialize */
+}
 /* Clean up things for this module. */
 void
 Dir_End(void)
+{
 #ifdef CLEANUP
     if (cur) {
 	cur->refCount -= 1;
 	Dir_Destroy(cur);
+    }
     dot->refCount -= 1;
     dotLast->refCount -= 1;
     Dir_Destroy(dotLast);
     Dir_Destroy(dot);
     Dir_ClearPath(dirSearchPath);
     Lst_Free(dirSearchPath);
     Dir_ClearPath(openDirectories);
     Lst_Free(openDirectories);
     Hash_DeleteTable(&mtimes);
 #endif
+}
 /*
  * We want ${.PATH} to indicate the order in which we will actually
  * search, so we rebuild it after any .PATH: target.
  * This is the simplest way to deal with the effect of .DOTLAST.
  */
 void
 Dir_SetPATH(void)
+{
     LstNode ln;			/* a list element */
     Path *p;
     Boolean hasLastDot = FALSE;	/* true if we should search dot last */
     Var_Delete(".PATH", VAR_GLOBAL);
     Lst_Open(dirSearchPath);
     if ((ln = Lst_First(dirSearchPath)) != NULL) {
 	p = LstNode_Datum(ln);
 	if (p == dotLast) {
 	    hasLastDot = TRUE;
 	    Var_Append(".PATH", dotLast->name, VAR_GLOBAL);
+	}
+    }
     if (!hasLastDot) {
 	if (dot)
 	    Var_Append(".PATH", dot->name, VAR_GLOBAL);
 	if (cur)
 	    Var_Append(".PATH", cur->name, VAR_GLOBAL);
+    }
     while ((ln = Lst_Next(dirSearchPath)) != NULL) {
 	p = LstNode_Datum(ln);
 	if (p == dotLast)
 	    continue;
 	if (p == dot && hasLastDot)
 	    continue;
 	Var_Append(".PATH", p->name, VAR_GLOBAL);
+    }
     if (hasLastDot) {
 	if (dot)
 	    Var_Append(".PATH", dot->name, VAR_GLOBAL);
 	if (cur)
 	    Var_Append(".PATH", cur->name, VAR_GLOBAL);
+    }
     Lst_Close(dirSearchPath);
+}
 /* See if the Path structure describes the same directory as the
  * given one by comparing their names. Called from Dir_AddDir via
  * Lst_Find when searching the list of open directories. */
 static Boolean
 DirFindName(const void *p, const void *desiredName)
+{
     return strcmp(((const Path *)p)->name, desiredName) == 0;
+}
 /* See if the given name has any wildcard characters in it. Be careful not to
  * expand unmatching brackets or braces.
+ *
  * XXX: This code is not 100% correct ([^]] fails etc.). I really don't think
  * that make(1) should be expanding patterns, because then you have to set a
  * mechanism for escaping the expansion!
+ *
  * Input:
  *	name		name to check
+ *
  * Results:
  *	returns TRUE if the word should be expanded, FALSE otherwise
  */
 Boolean
 Dir_HasWildcards(const char *name)
+{
     const char *cp;
     Boolean wild = FALSE;
     int braces = 0, brackets = 0;
     for (cp = name; *cp; cp++) {
 	switch (*cp) {
 	case '{':
 	    braces++;
 	    wild = TRUE;
 	    break;
 	case '}':
 	    braces--;
 	    break;
 	case '[':
 	    brackets++;
 	    wild = TRUE;
 	    break;
 	case ']':
 	    brackets--;
 	    break;
 	case '?':
 	case '*':
 	    wild = TRUE;
 	    break;
 	default:
 	    break;
+	}
+    }
     return wild && brackets == 0 && braces == 0;
+}
 /*-
  *-----------------------------------------------------------------------
  * DirMatchFiles --
  * 	Given a pattern and a Path structure, see if any files
  *	match the pattern and add their names to the 'expansions' list if
  *	any do. This is incomplete -- it doesn't take care of patterns like
  *	src / *src / *.c properly (just *.c on any of the directories), but it
  *	will do for now.
+ *
  * Input:
  *	pattern		Pattern to look for
  *	p		Directory to search
  *	expansion	Place to store the results
+ *
  * Side Effects:
  *	File names are added to the expansions lst. The directory will be
  *	fully hashed when this is done.
  *-----------------------------------------------------------------------
  */
 static void
 DirMatchFiles(const char *pattern, Path *p, Lst expansions)
+{
     Hash_Search search;		/* Index into the directory's table */
     Hash_Entry *entry;		/* Current entry in the table */
     Boolean isDot;		/* TRUE if the directory being searched is . */
     isDot = (*p->name == '.' && p->name[1] == '\0');
     for (entry = Hash_EnumFirst(&p->files, &search);
 	 entry != NULL;
 	 entry = Hash_EnumNext(&search))
+    {
 	/*
 	 * See if the file matches the given pattern. Note we follow the UNIX
 	 * convention that dot files will only be found if the pattern
 	 * begins with a dot (note also that as a side effect of the hashing
 	 * scheme, .* won't match . or .. since they aren't hashed).
 	 */
 	if (Str_Match(entry->name, pattern) &&
 	    ((entry->name[0] != '.') ||
 	     (pattern[0] == '.')))
+	{
 	    Lst_Append(expansions,
 			(isDot ? bmake_strdup(entry->name) :
 			 str_concat3(p->name, "/", entry->name)));
+	}
+    }
+}
 /* Find the next closing brace in the string, taking nested braces into
  * account. */
 static const char *
 closing_brace(const char *p)
+{
     int nest = 0;
     while (*p != '\0') {
 	if (*p == '}' && nest == 0)
 	    break;
 	if (*p == '{')
 	    nest++;
 	if (*p == '}')
 	    nest--;
 	p++;
+    }
     return p;
+}
 /* Find the next closing brace or comma in the string, taking nested braces
  * into account. */
 static const char *
 separator_comma(const char *p)
+{
     int nest = 0;
     while (*p != '\0') {
 	if ((*p == '}' || *p == ',') && nest == 0)
 	    break;
 	if (*p == '{')
 	    nest++;
 	if (*p == '}')
 	    nest--;
 	p++;
+    }
     return p;
+}
 static Boolean
 contains_wildcard(const char *p)
+{
     for (; *p != '\0'; p++) {
 	switch (*p) {
 	case '*':
 	case '?':
 	case '{':
 	case '[':
 	    return TRUE;
+	}
+    }
     return FALSE;
+}
 static char *
 concat3(const char *a, size_t a_len, const char *b, size_t b_len,
 	const char *c, size_t c_len)
+{
     size_t s_len = a_len + b_len + c_len;
     char *s = bmake_malloc(s_len + 1);
     memcpy(s, a, a_len);
     memcpy(s + a_len, b, b_len);
     memcpy(s + a_len + b_len, c, c_len);
     s[s_len] = '\0';
     return s;
+}
 /*-
  *-----------------------------------------------------------------------
  * DirExpandCurly --
  *	Expand curly braces like the C shell. Does this recursively.
  *	Note the special case: if after the piece of the curly brace is
  *	done there are no wildcard characters in the result, the result is
  *	placed on the list WITHOUT CHECKING FOR ITS EXISTENCE.
+ *
  * Input:
  *	word		Entire word to expand
  *	brace		First curly brace in it
  *	path		Search path to use
  *	expansions	Place to store the expansions
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	The given list is filled with the expansions...
+ *
  *-----------------------------------------------------------------------
  */
 static void
 DirExpandCurly(const char *word, const char *brace, Lst path, Lst expansions)
+{
     const char *prefix, *middle, *piece, *middle_end, *suffix;
     size_t prefix_len, suffix_len;
     /* Split the word into prefix '{' middle '}' suffix. */
     middle = brace + 1;
     middle_end = closing_brace(middle);
     if (*middle_end == '\0') {
 	Error("Unterminated {} clause \"%s\"", middle);
 	return;
+    }
     prefix = word;
     prefix_len = (size_t)(brace - prefix);
     suffix = middle_end + 1;
     suffix_len = strlen(suffix);
     /* Split the middle into pieces, separated by commas. */
     piece = middle;
     while (piece < middle_end + 1) {
 	const char *piece_end = separator_comma(piece);
 	size_t piece_len = (size_t)(piece_end - piece);
 	char *file = concat3(prefix, prefix_len, piece, piece_len,
 			     suffix, suffix_len);
 	if (contains_wildcard(file)) {
 	    Dir_Expand(file, path, expansions);
 	    free(file);
 	} else {
 	    Lst_Append(expansions, file);
+	}
 	piece = piece_end + 1;	/* skip over the comma or closing brace */
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * DirExpandInt --
  *	Internal expand routine. Passes through the directories in the
  *	path one by one, calling DirMatchFiles for each. NOTE: This still
  *	doesn't handle patterns in directories...
+ *
  * Input:
  *	word		Word to expand
  *	path		Path on which to look
  *	expansions	Place to store the result
+ *
  * Results:
  *	None.
+ *
  * Side Effects:
  *	Things are added to the expansions list.
+ *
  *-----------------------------------------------------------------------
  */
 static void
 DirExpandInt(const char *word, Lst path, Lst expansions)
+{
     LstNode ln;			/* Current node */
     Lst_Open(path);
     while ((ln = Lst_Next(path)) != NULL) {
 	Path *p = LstNode_Datum(ln);
 	DirMatchFiles(word, p, expansions);
+    }
     Lst_Close(path);
+}
 /* Print a word in the list of expansions.
  * Callback for Dir_Expand when DEBUG(DIR), via Lst_ForEach. */
 static int
 DirPrintWord(void *word, void *dummy MAKE_ATTR_UNUSED)
+{
     fprintf(debug_file, "%s ", (char *)word);
     return 0;
+}
 /*-
  *-----------------------------------------------------------------------
  * Dir_Expand  --
  *	Expand the given word into a list of words by globbing it looking
  *	in the directories on the given search path.
+ *
  * Input:
  *	word		the word to expand
  *	path		the list of directories in which to find the
  *			resulting files
  *	expansions	the list on which to place the results
+ *
  * Results:
  *	A list of words consisting of the files which exist along the search
  *	path matching the given pattern.
+ *
  * Side Effects:
  *	Directories may be opened. Who knows?
  *	Undefined behavior if the word is really in read-only memory.
  *-----------------------------------------------------------------------
  */
 void
 Dir_Expand(const char *word, Lst path, Lst expansions)
+{
     const char *cp;
     assert(path != NULL);
     assert(expansions != NULL);
     DIR_DEBUG1("Expanding \"%s\"... ", word);
     cp = strchr(word, '{');
     if (cp) {
 	DirExpandCurly(word, cp, path, expansions);
     } else {
 	cp = strchr(word, '/');
 	if (cp) {
 	    /*
 	     * The thing has a directory component -- find the first wildcard
 	     * in the string.
 	     */
 	    for (cp = word; *cp; cp++) {
 		if (*cp == '?' || *cp == '[' || *cp == '*' || *cp == '{') {
 		    break;
+		}
+	    }
 	    if (*cp == '{') {
 		/*
 		 * This one will be fun.
 		 */
 		DirExpandCurly(word, cp, path, expansions);
 		return;
 	    } else if (*cp != '\0') {
 		/*
 		 * Back up to the start of the component
 		 */
 		while (cp > word && *cp != '/') {
 		    cp--;
+		}
 		if (cp != word) {
 		    char sc;
 		    char *dirpath;
 		    /*
 		     * If the glob isn't in the first component, try and find
 		     * all the components up to the one with a wildcard.
 		     */
 		    sc = cp[1];
 		    ((char *)UNCONST(cp))[1] = '\0';
 		    dirpath = Dir_FindFile(word, path);
 		    ((char *)UNCONST(cp))[1] = sc;
 		    /*
 		     * dirpath is null if can't find the leading component
 		     * XXX: Dir_FindFile won't find internal components.
 		     * i.e. if the path contains ../Etc/Object and we're
 		     * looking for Etc, it won't be found. Ah well.
 		     * Probably not important.
 		     */
 		    if (dirpath != NULL) {
 			char *dp = &dirpath[strlen(dirpath) - 1];
 			if (*dp == '/')
 			    *dp = '\0';
 			path = Lst_Init();
 			(void)Dir_AddDir(path, dirpath);
 			DirExpandInt(cp + 1, path, expansions);
 			Lst_Free(path);
+		    }
 		} else {
 		    /*
 		     * Start the search from the local directory
 		     */
 		    DirExpandInt(word, path, expansions);
+		}
 	    } else {
 		/*
 		 * Return the file -- this should never happen.
 		 */
 		DirExpandInt(word, path, expansions);
+	    }
 	} else {
 	    /*
 	     * First the files in dot
 	     */
 	    DirMatchFiles(word, dot, expansions);
 	    /*
 	     * Then the files in every other directory on the path.
 	     */
 	    DirExpandInt(word, path, expansions);
+	}
+    }
     if (DEBUG(DIR)) {
 	Lst_ForEach(expansions, DirPrintWord, NULL);
 	fprintf(debug_file, "\n");
+    }
+}
 /*-
  *-----------------------------------------------------------------------
  * DirLookup  --
  *	Find if the file with the given name exists in the given path.
+ *
  * Results:
  *	The path to the file or NULL. This path is guaranteed to be in a
  *	different part of memory than name and so may be safely free'd.
+ *
  * Side Effects:
  *	None.
  *-----------------------------------------------------------------------
  */
 static char *
 DirLookup(Path *p, const char *name MAKE_ATTR_UNUSED, const char *cp,
 	  Boolean hasSlash MAKE_ATTR_UNUSED)
+{
     char *file;			/* the current filename to check */
     DIR_DEBUG1("   %s ...\n", p->name);
     if (Hash_FindEntry(&p->files, cp) == NULL)
 	return NULL;
     file = str_concat3(p->name, "/", cp);
     DIR_DEBUG1("   returning %s\n", file);
     p->hits += 1;
     hits += 1;
     return file;
+}
 /*-
  *-----------------------------------------------------------------------
  * DirLookupSubdir  --
  *	Find if the file with the given name exists in the given path.
+ *
  * Results:
  *	The path to the file or NULL. This path is guaranteed to be in a
  *	different part of memory than name and so may be safely free'd.
+ *
  * Side Effects:
  *	If the file is found, it is added in the modification times hash
  *	table.
  *-----------------------------------------------------------------------
  */
 static char *
 DirLookupSubdir(Path *p, const char *name)
+{
     struct stat stb;		/* Buffer for stat, if necessary */
     char *file;			/* the current filename to check */
     if (p != dot) {
 	file = str_concat3(p->name, "/", name);
     } else {
 	/*
 	 * Checking in dot -- DON'T put a leading ./ on the thing.
 	 */
 	file = bmake_strdup(name);
+    }
     DIR_DEBUG1("checking %s ...\n", file);
     if (cached_stat(file, &stb) == 0) {
 	nearmisses += 1;
 	return file;
+    }
     free(file);
     return NULL;
+}
 /*-
  *-----------------------------------------------------------------------
  * DirLookupAbs  --
  *	Find if the file with the given name exists in the given path.
+ *
  * Results:
  *	The path to the file, the empty string or NULL. If the file is
  *	the empty string, the search should be terminated.
  *	This path is guaranteed to be in a different part of memory
  *	than name and so may be safely free'd.
+ *
  * Side Effects:
  *	None.
  *-----------------------------------------------------------------------
  */
 static char *
 DirLookupAbs(Path *p, const char *name, const char *cp)
+{
     char *p1;			/* pointer into p->name */
     const char *p2;		/* pointer into name */
     DIR_DEBUG1("   %s ...\n", p->name);
     /*
      * If the file has a leading path component and that component
      * exactly matches the entire name of the current search
      * directory, we can attempt another cache lookup. And if we don't
      * have a hit, we can safely assume the file does not exist at all.
      */
     for (p1 = p->name, p2 = name; *p1 && *p1 == *p2; p1++, p2++) {
 	continue;
+    }
     if (*p1 != '\0' || p2 != cp - 1) {
 	return NULL;
+    }
     if (Hash_FindEntry(&p->files, cp) == NULL) {
 	DIR_DEBUG0("   must be here but isn't -- returning\n");
 	/* Return empty string: terminates search */
 	return bmake_strdup("");
+    }
     p->hits += 1;
     hits += 1;
     DIR_DEBUG1("   returning %s\n", name);
     return bmake_strdup(name);
+}
 /*-
  *-----------------------------------------------------------------------
  * DirFindDot  --
  *	Find the file given on "." or curdir
+ *
  * Results:
  *	The path to the file or NULL. This path is guaranteed to be in a
  *	different part of memory than name and so may be safely free'd.
+ *
  * Side Effects:
  *	Hit counts change
  *-----------------------------------------------------------------------
  */
 static char *
 DirFindDot(Boolean hasSlash MAKE_ATTR_UNUSED, const char *name, const char *cp)
+{
     if (Hash_FindEntry(&dot->files, cp) != NULL) {
 	DIR_DEBUG0("   in '.'\n");
 	hits += 1;
 	dot->hits += 1;
 	return bmake_strdup(name);
+    }
     if (cur && Hash_FindEntry(&cur->files, cp) != NULL) {
 	DIR_DEBUG1("   in ${.CURDIR} = %s\n", cur->name);
 	hits += 1;
 	cur->hits += 1;
 	return str_concat3(cur->name, "/", cp);
+    }
     return NULL;
+}
 /*-
  *-----------------------------------------------------------------------
  * Dir_FindFile  --
  *	Find the file with the given name along the given search path.
+ *
  * Input:
  *	name		the file to find
  *	path		the Lst of directories to search
+ *
  * Results:
  *	The path to the file or NULL. This path is guaranteed to be in a
  *	different part of memory than name and so may be safely free'd.
+ *
  * Side Effects:
  *	If the file is found in a directory which is not on the path
  *	already (either 'name' is absolute or it is a relative path
  *	[ dir1/.../dirn/file ] which exists below one of the directories
  *	already on the search path), its directory is added to the end
  *	of the path on the assumption that there will be more files in
  *	that directory later on. Sometimes this is true. Sometimes not.
  *-----------------------------------------------------------------------
  */
 char *
 Dir_FindFile(const char *name, Lst path)
+{
     LstNode ln;			/* a list element */
     char *file;			/* the current filename to check */
     Path *p;			/* current path member */
     const char *cp;		/* Terminal name of file */
     Boolean hasLastDot = FALSE;	/* true we should search dot last */
     Boolean hasSlash;		/* true if 'name' contains a / */
     struct stat stb;		/* Buffer for stat, if necessary */
     const char *trailing_dot = ".";
     /*
      * Find the final component of the name and note whether it has a
      * slash in it (the name, I mean)
      */
     cp = strrchr(name, '/');
     if (cp) {
 	hasSlash = TRUE;
 	cp += 1;
     } else {
 	hasSlash = FALSE;
 	cp = name;
+    }
     DIR_DEBUG1("Searching for %s ...", name);
     if (path == NULL) {
 	DIR_DEBUG0("couldn't open path, file not found\n");
 	misses += 1;
 	return NULL;
+    }
     Lst_Open(path);
     if ((ln = Lst_First(path)) != NULL) {
 	p = LstNode_Datum(ln);
 	if (p == dotLast) {
 	    hasLastDot = TRUE;
 	    DIR_DEBUG0("[dot last]...");
+	}
+    }
     DIR_DEBUG0("\n");
     /*
      * If there's no leading directory components or if the leading
      * directory component is exactly `./', consult the cached contents
      * of each of the directories on the search path.
      */
     if (!hasSlash || (cp - name == 2 && *name == '.')) {
 	/*
 	 * We look through all the directories on the path seeking one which
 	 * contains the final component of the given name.  If such a beast
 	 * is found, we concatenate the directory name and the final
 	 * component and return the resulting string. If we don't find any
 	 * such thing, we go on to phase two...
+	 *
 	 * No matter what, we always look for the file in the current
 	 * directory before anywhere else (unless we found the magic
 	 * DOTLAST path, in which case we search it last) and we *do not*
 	 * add the ./ to it if it exists.
 	 * This is so there are no conflicts between what the user
 	 * specifies (fish.c) and what pmake finds (./fish.c).
 	 */
 	if (!hasLastDot && (file = DirFindDot(hasSlash, name, cp)) != NULL) {
 	    Lst_Close(path);
 	    return file;
+	}
 	while ((ln = Lst_Next(path)) != NULL) {
 	    p = LstNode_Datum(ln);
 	    if (p == dotLast)
 		continue;
 	    if ((file = DirLookup(p, name, cp, hasSlash)) != NULL) {
 		Lst_Close(path);
 		return file;
+	    }
+	}
 	if (hasLastDot && (file = DirFindDot(hasSlash, name, cp)) != NULL) {
 	    Lst_Close(path);
 	    return file;
+	}
+    }
     Lst_Close(path);
     /*
      * We didn't find the file on any directory in the search path.
      * If the name doesn't contain a slash, that means it doesn't exist.
      * If it *does* contain a slash, however, there is still hope: it
      * could be in a subdirectory of one of the members of the search
      * path. (eg. /usr/include and sys/types.h. The above search would
      * fail to turn up types.h in /usr/include, but it *is* in
      * /usr/include/sys/types.h).
      * [ This no longer applies: If we find such a beast, we assume there
      * will be more (what else can we assume?) and add all but the last
      * component of the resulting name onto the search path (at the
      * end).]
      * This phase is only performed if the file is *not* absolute.
      */
     if (!hasSlash) {
 	DIR_DEBUG0("   failed.\n");
 	misses += 1;
 	return NULL;
+    }
     if (*cp == '\0') {
 	/* we were given a trailing "/" */
 	cp = trailing_dot;
+    }
     if (name[0] != '/') {
 	Boolean checkedDot = FALSE;
 	DIR_DEBUG0("   Trying subdirectories...\n");
 	if (!hasLastDot) {
 	    if (dot) {
 		checkedDot = TRUE;
 		if ((file = DirLookupSubdir(dot, name)) != NULL)
 		    return file;
+	    }
 	    if (cur && (file = DirLookupSubdir(cur, name)) != NULL)
 		return file;
+	}
 	Lst_Open(path);
 	while ((ln = Lst_Next(path)) != NULL) {
 	    p = LstNode_Datum(ln);
 	    if (p == dotLast)
 		continue;
 	    if (p == dot) {
 		if (checkedDot)
 		    continue;
 		checkedDot = TRUE;
+	    }
 	    if ((file = DirLookupSubdir(p, name)) != NULL) {
 		Lst_Close(path);
 		return file;
+	    }
+	}
 	Lst_Close(path);
 	if (hasLastDot) {
 	    if (dot && !checkedDot) {
 		checkedDot = TRUE;
 		if ((file = DirLookupSubdir(dot, name)) != NULL)
 		    return file;
+	    }
 	    if (cur && (file = DirLookupSubdir(cur, name)) != NULL)
 		return file;
+	}
 	if (checkedDot) {
 	    /*
 	     * Already checked by the given name, since . was in the path,
 	     * so no point in proceeding...
 	     */
 	    DIR_DEBUG0("   Checked . already, returning NULL\n");
 	    return NULL;
+	}
     } else { /* name[0] == '/' */
 	/*
 	 * For absolute names, compare directory path prefix against the
 	 * the directory path of each member on the search path for an exact
 	 * match. If we have an exact match on any member of the search path,
 	 * use the cached contents of that member to lookup the final file
 	 * component. If that lookup fails we can safely assume that the
 	 * file does not exist at all.  This is signified by DirLookupAbs()
 	 * returning an empty string.
 	 */
 	DIR_DEBUG0("   Trying exact path matches...\n");
 	if (!hasLastDot && cur &&
 	    ((file = DirLookupAbs(cur, name, cp)) != NULL)) {
 	    if (file[0] == '\0') {
 		free(file);
 		return NULL;
+	    }
 	    return file;
+	}
 	Lst_Open(path);
 	while ((ln = Lst_Next(path)) != NULL) {
 	    p = LstNode_Datum(ln);
 	    if (p == dotLast)
 		continue;
 	    if ((file = DirLookupAbs(p, name, cp)) != NULL) {
 		Lst_Close(path);
 		if (file[0] == '\0') {
 		    free(file);
 		    return NULL;
+		}
 		return file;
+	    }
+	}
 	Lst_Close(path);
 	if (hasLastDot && cur &&
 	    ((file = DirLookupAbs(cur, name, cp)) != NULL)) {
 	    if (file[0] == '\0') {
 		free(file);
 		return NULL;
+	    }
 	    return file;
+	}
+    }
     /*
      * Didn't find it that way, either. Sigh. Phase 3. Add its directory
      * onto the search path in any case, just in case, then look for the
      * thing in the hash table. If we find it, grand. We return a new
      * copy of the name. Otherwise we sadly return a NULL pointer. Sigh.
      * Note that if the directory holding the file doesn't exist, this will
      * do an extra search of the final directory on the path. Unless something
      * weird happens, this search won't succeed and life will be groovy.
+     *
      * Sigh. We cannot add the directory onto the search path because
      * of this amusing case:
      * $(INSTALLDIR)/$(FILE): $(FILE)
+     *
      * $(FILE) exists in $(INSTALLDIR) but not in the current one.
      * When searching for $(FILE), we will find it in $(INSTALLDIR)
      * b/c we added it here. This is not good...
      */
 #ifdef notdef
     if (cp == traling_dot) {
 	cp = strrchr(name, '/');
 	cp += 1;
+    }
     cp[-1] = '\0';
     (void)Dir_AddDir(path, name);
     cp[-1] = '/';
     bigmisses += 1;
     ln = Lst_Last(path);
     if (ln == NULL) {
 	return NULL;
     } else {
 	p = LstNode_Datum(ln);
+    }
     if (Hash_FindEntry(&p->files, cp) != NULL) {
 	return bmake_strdup(name);
     } else {
 	return NULL;
+    }
 #else /* !notdef */
     DIR_DEBUG1("   Looking for \"%s\" ...\n", name);
     bigmisses += 1;
     if (cached_stat(name, &stb) == 0) {
 	return bmake_strdup(name);
+    }
     DIR_DEBUG0("   failed. Returning NULL\n");
     return NULL;
 #endif /* notdef */
+}
 /*-

 @@ -1,404 +1,404 @@
-/*	$NetBSD: hash.c,v 1.28 2020/08/28 20:16:19 rillig Exp $	*/
+/*	$NetBSD: hash.c,v 1.29 2020/09/01 21:11:31 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
  * All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 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) 1988, 1989 by Adam de Boor
  * 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.
  */
 #ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: hash.c,v 1.28 2020/08/28 20:16:19 rillig Exp $";
+static char rcsid[] = "$NetBSD: hash.c,v 1.29 2020/09/01 21:11:31 rillig Exp $";
 #else
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)hash.c	8.1 (Berkeley) 6/6/93";
 #else
-__RCSID("$NetBSD: hash.c,v 1.28 2020/08/28 20:16:19 rillig Exp $");
+__RCSID("$NetBSD: hash.c,v 1.29 2020/09/01 21:11:31 rillig Exp $");
 #endif
 #endif /* not lint */
 #endif
 /* hash.c --
+ *
  * 	This module contains routines to manipulate a hash table.
  * 	See hash.h for a definition of the structure of the hash
  * 	table.  Hash tables grow automatically as the amount of
  * 	information increases.
  */
 #include "make.h"
 /*
  * Forward references to local procedures that are used before they're
  * defined:
  */
 static void RebuildTable(Hash_Table *);
 /*
  * The following defines the ratio of # entries to # buckets
  * at which we rebuild the table to make it larger.
  */
 #define rebuildLimit 3
 /* The hash function(s) */
 #ifndef HASH
 /* The default: this one matches Gosling's emacs */
 #define HASH(h, key, p) do { \
 	for (h = 0, p = key; *p;) \
 		h = (h << 5) - h + *p++; \
 	} while (0)
 #endif
 /* Sets up the hash table.
+ *
  * Input:
  *	t		Structure to to hold the table.
  *	numBuckets	How many buckets to create for starters. This
  *			number is rounded up to a power of two.   If
  *			<= 0, a reasonable default is chosen. The
  *			table will grow in size later as needed.
  */
 void
 Hash_InitTable(Hash_Table *t, int numBuckets)
+{
 	int i;
 	struct Hash_Entry **hp;
 	/*
 	 * Round up the size to a power of two.
 	 */
 	if (numBuckets <= 0)
 		i = 16;
 	else {
 		for (i = 2; i < numBuckets; i <<= 1)
 			 continue;
+	}
 	t->numEntries = 0;
 	t->maxchain = 0;
-	t->size = i;
+	t->bucketsSize = i;
-	t->mask = i - 1;
+	t->bucketsMask = i - 1;
-	t->bucketPtr = hp = bmake_malloc(sizeof(*hp) * i);
+	t->buckets = hp = bmake_malloc(sizeof(*hp) * i);
 	while (--i >= 0)
 		*hp++ = NULL;
+}
 /* Removes everything from the hash table and frees up the memory space it
  * occupied (except for the space in the Hash_Table structure). */
 void
 Hash_DeleteTable(Hash_Table *t)
+{
 	struct Hash_Entry **hp, *h, *nexth = NULL;
 	int i;
-	for (hp = t->bucketPtr, i = t->size; --i >= 0;) {
+	for (hp = t->buckets, i = t->bucketsSize; --i >= 0;) {
 		for (h = *hp++; h != NULL; h = nexth) {
 			nexth = h->next;
 			free(h);
+		}
+	}
-	free(t->bucketPtr);
+	free(t->buckets);
 	/*
 	 * Set up the hash table to cause memory faults on any future access
 	 * attempts until re-initialization.
 	 */
-	t->bucketPtr = NULL;
+	t->buckets = NULL;
+}
 /* Searches the hash table for an entry corresponding to the key.
+ *
  * Input:
  *	t		Hash table to search.
  *	key		A hash key.
+ *
  * Results:
  *	Returns a pointer to the entry for key, or NULL if the table contains
  *	no entry for the key.
  */
 Hash_Entry *
 Hash_FindEntry(Hash_Table *t, const char *key)
+{
 	Hash_Entry *e;
 	unsigned h;
 	const char *p;
 	int chainlen;
-	if (t == NULL || t->bucketPtr == NULL) {
+	if (t == NULL || t->buckets == NULL) {
 	    return NULL;
+	}
 	HASH(h, key, p);
 	p = key;
 	chainlen = 0;
 #ifdef DEBUG_HASH_LOOKUP
 	if (DEBUG(HASH))
 		fprintf(debug_file, "%s: %p h=%x key=%s\n", __func__,
 		    t, h, key);
 #endif
-	for (e = t->bucketPtr[h & t->mask]; e != NULL; e = e->next) {
+	for (e = t->buckets[h & t->bucketsMask]; e != NULL; e = e->next) {
 		chainlen++;
 		if (e->namehash == h && strcmp(e->name, p) == 0)
 			break;
+	}
 	if (chainlen > t->maxchain)
 		t->maxchain = chainlen;
 	return e;
+}
 /* Searches the hash table for an entry corresponding to the key.
  * If no entry is found, then one is created.
+ *
  * Input:
  *	t		Hash table to search.
  *	key		A hash key.
  *	newPtr		Filled with TRUE if new entry created,
  *			FALSE otherwise.
  */
 Hash_Entry *
 Hash_CreateEntry(Hash_Table *t, const char *key, Boolean *newPtr)
+{
 	Hash_Entry *e;
 	unsigned h;
 	const char *p;
 	int keylen;
 	int chainlen;
 	struct Hash_Entry **hp;
 	/*
 	 * Hash the key.  As a side effect, save the length (strlen) of the
 	 * key in case we need to create the entry.
 	 */
 	HASH(h, key, p);
 	keylen = p - key;
 	p = key;
 	chainlen = 0;
 #ifdef DEBUG_HASH_LOOKUP
 	if (DEBUG(HASH))
 		fprintf(debug_file, "%s: %p h=%x key=%s\n", __func__,
 		    t, h, key);
 #endif
-	for (e = t->bucketPtr[h & t->mask]; e != NULL; e = e->next) {
+	for (e = t->buckets[h & t->bucketsMask]; e != NULL; e = e->next) {
 		chainlen++;
 		if (e->namehash == h && strcmp(e->name, p) == 0) {
 			if (newPtr != NULL)
 				*newPtr = FALSE;
 			break;
+		}
+	}
 	if (chainlen > t->maxchain)
 		t->maxchain = chainlen;
 	if (e)
 		return e;
 	/*
 	 * The desired entry isn't there.  Before allocating a new entry,
 	 * expand the table if necessary (and this changes the resulting
 	 * bucket chain).
 	 */
-	if (t->numEntries >= rebuildLimit * t->size)
+	if (t->numEntries >= rebuildLimit * t->bucketsSize)
 		RebuildTable(t);
 	e = bmake_malloc(sizeof(*e) + keylen);
-	hp = &t->bucketPtr[h & t->mask];
+	hp = &t->buckets[h & t->bucketsMask];
 	e->next = *hp;
 	*hp = e;
 	Hash_SetValue(e, NULL);
 	e->namehash = h;
 	(void)strcpy(e->name, p);
 	t->numEntries++;
 	if (newPtr != NULL)
 		*newPtr = TRUE;
 	return e;
+}
 /* Delete the given hash table entry and free memory associated with it. */
 void
 Hash_DeleteEntry(Hash_Table *t, Hash_Entry *e)
+{
 	Hash_Entry **hp, *p;
 	if (e == NULL)
 		return;
-	for (hp = &t->bucketPtr[e->namehash & t->mask];
+	for (hp = &t->buckets[e->namehash & t->bucketsMask];
 	     (p = *hp) != NULL; hp = &p->next) {
 		if (p == e) {
 			*hp = p->next;
 			free(p);
 			t->numEntries--;
 			return;
+		}
+	}
 	(void)write(2, "bad call to Hash_DeleteEntry\n", 29);
 	abort();
+}
 /* Sets things up for enumerating all entries in the hash table.
+ *
  * Input:
  *	t		Table to be searched.
  *	searchPtr	Area in which to keep state about search.
+ *
  * Results:
  *	The return value is the address of the first entry in
  *	the hash table, or NULL if the table is empty.
  */
 Hash_Entry *
 Hash_EnumFirst(Hash_Table *t, Hash_Search *searchPtr)
+{
-	searchPtr->tablePtr = t;
+	searchPtr->table = t;
-	searchPtr->nextIndex = 0;
+	searchPtr->nextBucket = 0;
-	searchPtr->hashEntryPtr = NULL;
+	searchPtr->entry = NULL;
 	return Hash_EnumNext(searchPtr);
+}
 /* Returns the next entry in the hash table, or NULL if the end of the table
  * is reached.
+ *
  * Input:
  *	searchPtr	Area used to keep state about search.
  */
 Hash_Entry *
 Hash_EnumNext(Hash_Search *searchPtr)
+{
 	Hash_Entry *e;
-	Hash_Table *t = searchPtr->tablePtr;
+	Hash_Table *t = searchPtr->table;
 	/*
-	 * The hashEntryPtr field points to the most recently returned
+	 * The entry field points to the most recently returned
-	 * entry, or is nil if we are starting up.  If not nil, we have
+	 * entry, or is NULL if we are starting up.  If not NULL, we have
 	 * to start at the next one in the chain.
 	 */
-	e = searchPtr->hashEntryPtr;
+	e = searchPtr->entry;
 	if (e != NULL)
 		e = e->next;
 	/*
 	 * If the chain ran out, or if we are starting up, we need to
 	 * find the next nonempty chain.
 	 */
 	while (e == NULL) {
-		if (searchPtr->nextIndex >= t->size)
+		if (searchPtr->nextBucket >= t->bucketsSize)
 			return NULL;
-		e = t->bucketPtr[searchPtr->nextIndex++];
+		e = t->buckets[searchPtr->nextBucket++];
+	}
-	searchPtr->hashEntryPtr = e;
+	searchPtr->entry = e;
 	return e;
+}
 /* Makes a new hash table that is larger than the old one. The entire hash
  * table is moved, so any bucket numbers from the old table become invalid. */
 static void
 RebuildTable(Hash_Table *t)
+{
 	Hash_Entry *e, *next = NULL, **hp, **xp;
 	int i, mask;
 	Hash_Entry **oldhp;
 	int oldsize;
-	oldhp = t->bucketPtr;
+	oldhp = t->buckets;
-	oldsize = i = t->size;
+	oldsize = i = t->bucketsSize;
 	i <<= 1;
-	t->size = i;
+	t->bucketsSize = i;
-	t->mask = mask = i - 1;
+	t->bucketsMask = mask = i - 1;
-	t->bucketPtr = hp = bmake_malloc(sizeof(*hp) * i);
+	t->buckets = hp = bmake_malloc(sizeof(*hp) * i);
 	while (--i >= 0)
 		*hp++ = NULL;
 	for (hp = oldhp, i = oldsize; --i >= 0;) {
 		for (e = *hp++; e != NULL; e = next) {
 			next = e->next;
-			xp = &t->bucketPtr[e->namehash & mask];
+			xp = &t->buckets[e->namehash & mask];
 			e->next = *xp;
 			*xp = e;
+		}
+	}
 	free(oldhp);
 	if (DEBUG(HASH))
 		fprintf(debug_file, "%s: %p size=%d entries=%d maxchain=%d\n",
-		    __func__, t, t->size, t->numEntries, t->maxchain);
+			__func__, t, t->bucketsSize, t->numEntries, t->maxchain);
 	t->maxchain = 0;
+}
 void
 Hash_ForEach(Hash_Table *t, void (*action)(void *, void *), void *data)
+{
 	Hash_Search search;
 	Hash_Entry *e;
 	for (e = Hash_EnumFirst(t, &search);
 	     e != NULL;
 	     e = Hash_EnumNext(&search))
 		action(Hash_GetValue(e), data);
+}
 void
 Hash_DebugStats(Hash_Table *t, const char *name)
+{
     if (DEBUG(HASH))
 	fprintf(debug_file, "Hash_Table %s: size=%d numEntries=%d maxchain=%d\n",
-		name, t->size, t->numEntries, t->maxchain);
+		name, t->bucketsSize, t->numEntries, t->maxchain);
+}