 @@ -1,14 +1,14 @@
-/*	$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.
 @@ -60,34 +60,34 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: 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.
+ *
 @@ -288,52 +288,52 @@ 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

 @@ -1,14 +1,14 @@
-/*	$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.
 @@ -60,34 +60,34 @@
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  */
 #ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: 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"
 @@ -132,86 +132,86 @@ Hash_InitTable(Hash_Table *t, int numBuc
 	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:
 @@ -233,172 +233,172 @@ Hash_CreateEntry(Hash_Table *t, const ch
 	/*
 	 * 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);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: hash.h,v 1.20 2020/09/01 21:00:15 rillig Exp $	*/
+/*	$NetBSD: hash.h,v 1.21 2020/09/01 21:11:31 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
 @@ -62,78 +62,70 @@
  * 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.
+ *
  *	from: @(#)hash.h	8.1 (Berkeley) 6/6/93
  */
-/* hash.h --
+/* Hash tables with strings as keys and arbitrary pointers as values. */
  * 	This file contains definitions used by the hash module,
  * 	which maintains hash tables.
  */
 #ifndef	MAKE_HASH_H
 #define	MAKE_HASH_H
-/*
+/* A single key-value entry in the hash table. */
  * The following defines one entry in the hash table.
  */
 typedef struct Hash_Entry {
-    struct Hash_Entry *next;		/* Used to link together all the
+    struct Hash_Entry *next;	/* Used to link together all the entries
-					 * entries associated with the same
+				 * associated with the same bucket. */
-					 * bucket. */
+    void	      *value;
-    void	      *clientPtr;	/* Arbitrary pointer */
+    unsigned	      namehash;	/* hash value of key */
-    unsigned	      namehash;		/* hash value of key */
+    char	      name[1];	/* key string, variable length */
     char	      name[1];		/* key string, variable length */
 } Hash_Entry;
 /* The hash table containing the entries. */
 typedef struct Hash_Table {
-    struct Hash_Entry **bucketPtr;/* Pointers to Hash_Entry, one
+    Hash_Entry **buckets;	/* Pointers to Hash_Entry, one
 				 * for each bucket in the table. */
-    int 	size;		/* Actual size of array. */
+    int 	bucketsSize;
     int 	numEntries;	/* Number of entries in the table. */
-    int 	mask;		/* Used to select bits for hashing. */
+    int 	bucketsMask;	/* Used to select the bucket for a hash. */
     int 	maxchain;	/* max length of chain detected */
 } Hash_Table;
 /*
  * The following structure is used by the searching routines
  * to record where we are in the search.
  */
 typedef struct Hash_Search {
-    Hash_Table  *tablePtr;	/* Table being searched. */
+    Hash_Table  *table;		/* Table being searched. */
-    int 	nextIndex;	/* Next bucket to check (after current). */
+    int 	nextBucket;	/* Next bucket to check (after current). */
-    Hash_Entry 	*hashEntryPtr;	/* Next entry to check in current bucket. */
+    Hash_Entry 	*entry;		/* Next entry to check in current bucket. */
 } Hash_Search;
 static inline void * MAKE_ATTR_UNUSED
 Hash_GetValue(Hash_Entry *h)
+{
-    return h->clientPtr;
+    return h->value;
+}
 static inline void MAKE_ATTR_UNUSED
 Hash_SetValue(Hash_Entry *h, void *datum)
+{
-    h->clientPtr = datum;
+    h->value = datum;
+}
 void Hash_InitTable(Hash_Table *, int);
 void Hash_DeleteTable(Hash_Table *);
 Hash_Entry *Hash_FindEntry(Hash_Table *, const char *);
 Hash_Entry *Hash_CreateEntry(Hash_Table *, const char *, Boolean *);
 void Hash_DeleteEntry(Hash_Table *, Hash_Entry *);
 Hash_Entry *Hash_EnumFirst(Hash_Table *, Hash_Search *);
 Hash_Entry *Hash_EnumNext(Hash_Search *);
 void Hash_ForEach(Hash_Table *, void (*)(void *, void *), void *);
 void Hash_DebugStats(Hash_Table *, const char *);
 #endif /* MAKE_HASH_H */