 @@ -1,14 +1,14 @@
-/*	$NetBSD: dir.c,v 1.210 2020/11/14 21:29:44 rillig Exp $	*/
+/*	$NetBSD: dir.c,v 1.211 2020/11/23 18:24:05 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.
 @@ -124,27 +124,27 @@
  */
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <dirent.h>
 #include <errno.h>
 #include "make.h"
 #include "dir.h"
 #include "job.h"
 /*	"@(#)dir.c	8.2 (Berkeley) 1/2/94"	*/
-MAKE_RCSID("$NetBSD: dir.c,v 1.210 2020/11/14 21:29:44 rillig Exp $");
+MAKE_RCSID("$NetBSD: dir.c,v 1.211 2020/11/23 18:24:05 rillig Exp $");
 #define DIR_DEBUG0(text) DEBUG0(DIR, text)
 #define DIR_DEBUG1(fmt, arg1) DEBUG1(DIR, fmt, arg1)
 #define DIR_DEBUG2(fmt, arg1, arg2) DEBUG2(DIR, fmt, arg1, arg2)
 /* A search path is a list of CachedDir structures. A CachedDir has in it the
  * name of the directory and the names of all the files in the directory.
  * This is used to cut down on the number of system calls necessary to find
  * implicit dependents and their like. Since these searches are made before
  * any actions are taken, we need not worry about the directory changing due
  * to creation commands. If this hampers the style of some makefiles, they
  * must be changed.
+ *
 @@ -369,27 +369,27 @@ Dir_Init(void)
     HashTable_Init(&mtimes);
     HashTable_Init(&lmtimes);
+}
 void
 Dir_InitDir(const char *cdname)
+{
     Dir_InitCur(cdname);
     dotLast = bmake_malloc(sizeof *dotLast);
     dotLast->refCount = 1;
     dotLast->hits = 0;
     dotLast->name = bmake_strdup(".DOTLAST");
-    HashTable_Init(&dotLast->files);
+    HashSet_Init(&dotLast->files);
+}
 /*
  * Called by Dir_InitDir and whenever .CURDIR is assigned to.
  */
 void
 Dir_InitCur(const char *cdname)
+{
     CachedDir *dir;
     if (cdname == NULL)
 	return;
 @@ -563,27 +563,27 @@ Dir_HasWildcards(const char *name)
  *	dir		Directory to search
  *	expansion	Place to store the results
  */
 static void
 DirMatchFiles(const char *pattern, CachedDir *dir, StringList *expansions)
+{
     const char *dirName = dir->name;
     Boolean isDot = dirName[0] == '.' && dirName[1] == '\0';
     HashIter hi;
     /* XXX: Iterating over all hash entries is inefficient.  If the pattern
      * is a plain string without any wildcards, a direct lookup is faster. */
-    HashIter_Init(&hi, &dir->files);
+    HashIter_InitSet(&hi, &dir->files);
     while (HashIter_Next(&hi) != NULL) {
 	const char *base = hi.entry->key;
 	if (!Str_Match(base, pattern))
 	    continue;
 	/*
 	 * Follow the UNIX convention that dot files are only found if the
 	 * pattern begins with a dot. The pattern '.*' does not match '.' or
 	 * '..' since these are not included in the directory cache.
+	 *
 	 * This means that the pattern '[a-z.]*' does not find '.file', which
 	 * is consistent with bash, NetBSD sh and csh.
 @@ -838,27 +838,27 @@ Dir_Expand(const char *word, SearchPath
     if (DEBUG(DIR))
 	PrintExpansions(expansions);
+}
 /* Find if the file with the given name exists in the given path.
  * Return the freshly allocated path to the file, or NULL. */
 static char *
 DirLookup(CachedDir *dir, const char *base)
+{
     char *file;			/* the current filename to check */
     DIR_DEBUG1("   %s ...\n", dir->name);
-    if (HashTable_FindEntry(&dir->files, base) == NULL)
+    if (!HashSet_Contains(&dir->files, base))
 	return NULL;
     file = str_concat3(dir->name, "/", base);
     DIR_DEBUG1("   returning %s\n", file);
     dir->hits++;
     hits++;
     return file;
+}
 /* Find if the file with the given name exists in the given directory.
  * Return the freshly allocated path to the file, or NULL. */
 static char *
 @@ -891,51 +891,51 @@ DirLookupAbs(CachedDir *dir, const char
     DIR_DEBUG1("   %s ...\n", dir->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 (dnp = dir->name, np = name; *dnp != '\0' && *dnp == *np; dnp++, np++)
 	continue;
     if (*dnp != '\0' || np != cp - 1)
 	return NULL;
-    if (HashTable_FindEntry(&dir->files, cp) == NULL) {
+    if (!HashSet_Contains(&dir->files, cp)) {
 	DIR_DEBUG0("   must be here but isn't -- returning\n");
 	return bmake_strdup("");	/* to terminate the search */
+    }
     dir->hits++;
     hits++;
     DIR_DEBUG1("   returning %s\n", name);
     return bmake_strdup(name);
+}
 /* Find the file given on "." or curdir.
  * Return the freshly allocated path to the file, or NULL. */
 static char *
 DirFindDot(const char *name, const char *base)
+{
-    if (HashTable_FindEntry(&dot->files, base) != NULL) {
+    if (HashSet_Contains(&dot->files, base)) {
 	DIR_DEBUG0("   in '.'\n");
 	hits++;
 	dot->hits++;
 	return bmake_strdup(name);
+    }
-    if (cur != NULL && HashTable_FindEntry(&cur->files, base) != NULL) {
+    if (cur != NULL && HashSet_Contains(&cur->files, base)) {
 	DIR_DEBUG1("   in ${.CURDIR} = %s\n", cur->name);
 	hits++;
 	cur->hits++;
 	return str_concat3(cur->name, "/", base);
+    }
     return NULL;
+}
 /* Find the file with the given name along the given search path.
+ *
  * If the file is found in a directory that is not on the path
  * already (either 'name' is absolute or it is a relative path
 @@ -1380,40 +1380,40 @@ Dir_AddDir(SearchPath *path, const char
 	    dir->refCount++;
 	    Lst_Append(path, dir);
+	}
 	return dir;
+    }
     DIR_DEBUG1("Caching %s ...", name);
     if ((d = opendir(name)) != NULL) {
 	dir = bmake_malloc(sizeof *dir);
 	dir->name = bmake_strdup(name);
 	dir->hits = 0;
 	dir->refCount = 1;
-	HashTable_Init(&dir->files);
+	HashSet_Init(&dir->files);
 	while ((dp = readdir(d)) != NULL) {
 #if defined(sun) && defined(d_ino) /* d_ino is a sunos4 #define for d_fileno */
 	    /*
 	     * The sun directory library doesn't check for a 0 inode
 	     * (0-inode slots just take up space), so we have to do
 	     * it ourselves.
 	     */
 	    if (dp->d_fileno == 0) {
 		continue;
+	    }
 #endif /* sun && d_ino */
-	    (void)HashTable_CreateEntry(&dir->files, dp->d_name, NULL);
+	    (void)HashSet_Add(&dir->files, dp->d_name);
+	}
 	(void)closedir(d);
 	OpenDirs_Add(&openDirs, dir);
 	if (path != NULL)
 	    Lst_Append(path, dir);
+    }
     DIR_DEBUG0("done\n");
     return dir;
+}
 /* Return a copy of dirSearchPath, incrementing the reference counts for
  * the contained directories. */
 SearchPath *
 @@ -1475,27 +1475,27 @@ Dir_MakeFlags(const char *flag, SearchPa
+ *
  * Input:
  *	dirp		The directory descriptor to nuke
  */
 void
 Dir_Destroy(void *dirp)
+{
     CachedDir *dir = dirp;
     dir->refCount--;
     if (dir->refCount == 0) {
 	OpenDirs_Remove(&openDirs, dir->name);
-	HashTable_Done(&dir->files);
+	HashSet_Done(&dir->files);
 	free(dir->name);
 	free(dir);
+    }
+}
 /* Clear out all elements from the given search path.
  * The path is set to the empty list but is not destroyed. */
 void
 Dir_ClearPath(SearchPath *path)
+{
     while (!Lst_IsEmpty(path)) {
 	CachedDir *dir = Lst_Dequeue(path);
 	Dir_Destroy(dir);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: dir.h,v 1.34 2020/11/14 19:24:24 rillig Exp $	*/
+/*	$NetBSD: dir.h,v 1.35 2020/11/23 18:24:05 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
 @@ -77,28 +77,27 @@
 /* A cache for the filenames in a directory. */
 typedef struct CachedDir {
     char *name;			/* Name of directory, either absolute or
 				 * relative to the current directory.
 				 * The name is not normalized in any way,
 				 * that is, "." and "./." are different.
+				 *
 				 * Not sure what happens when .CURDIR is
 				 * assigned a new value; see Parse_DoVar. */
     int refCount;		/* Number of SearchPaths with this directory */
     int hits;			/* The number of times a file in this
 				 * directory has been found */
-    HashTable files;		/* Hash set of files in directory;
+    HashSet files;		/* The files in the directory. */
 				 * all values are NULL. */
 } CachedDir;
 void Dir_Init(void);
 void Dir_InitDir(const char *);
 void Dir_InitCur(const char *);
 void Dir_InitDot(void);
 void Dir_End(void);
 void Dir_SetPATH(void);
 Boolean Dir_HasWildcards(const char *);
 void Dir_Expand(const char *, SearchPath *, StringList *);
 char *Dir_FindFile(const char *, SearchPath *);
 char *Dir_FindHereOrAbove(const char *, const char *);
 void Dir_UpdateMTime(GNode *, Boolean);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: hash.h,v 1.35 2020/11/23 18:07:10 rillig Exp $	*/
+/*	$NetBSD: hash.h,v 1.36 2020/11/23 18:24:05 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
 @@ -151,14 +151,20 @@ HashSet_Add(HashSet *set, const char *ke
+{
 	Boolean isNew;
 	(void)HashTable_CreateEntry(&set->tbl, key, &isNew);
 	return isNew;
+}
 MAKE_INLINE Boolean
 HashSet_Contains(HashSet *set, const char *key)
+{
 	return HashTable_FindEntry(&set->tbl, key) != NULL;
+}
 MAKE_INLINE void
 HashIter_InitSet(HashIter *hi, HashSet *set)
+{
     HashIter_Init(hi, &set->tbl);
+}
 #endif /* MAKE_HASH_H */