 @@ -1,14 +1,14 @@
-/*	$NetBSD: arch.c,v 1.121 2020/09/25 14:49:51 rillig Exp $	*/
+/*	$NetBSD: arch.c,v 1.122 2020/09/26 14:48:31 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.
 @@ -123,27 +123,27 @@
 #include    <ar.h>
 #include    <ctype.h>
 #include    <stdio.h>
 #include    <stdlib.h>
 #include    <utime.h>
 #include    "make.h"
 #include    "hash.h"
 #include    "dir.h"
 #include    "config.h"
 /*	"@(#)arch.c	8.2 (Berkeley) 1/2/94"	*/
-MAKE_RCSID("$NetBSD: arch.c,v 1.121 2020/09/25 14:49:51 rillig Exp $");
+MAKE_RCSID("$NetBSD: arch.c,v 1.122 2020/09/26 14:48:31 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;
 @@ -456,67 +456,66 @@ Arch_ParseArchive(char **linePtr, GNodeL
  *	The archive will remain constant after we read all the headers, so
  *	there's not much point in remembering the position...
  *-----------------------------------------------------------------------
  */
 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 */
     Hash_Entry	  *he;	      /* Entry containing member's description */
     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 final path components, not the entire thing, so we need
      * to point 'member' to the final component, if there is one, to make
      * the comparisons easier...
      */
     const char *base = strrchr(member, '/');
     if (base != NULL) {
 	member = base + 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) {
-	ar = LstNode_Datum(ln);
+	struct ar_hdr *hdr;
-	he = Hash_FindEntry(&ar->members, member);
+	ar = LstNode_Datum(ln);
 	hdr = Hash_FindValue(&ar->members, member);
 	if (hdr != NULL)
 	    return hdr;
 	if (he != NULL) {
 	    return (struct ar_hdr *)Hash_GetValue(he);
 	} else {
 	    /* 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);
+	    }
-	    if ((he = Hash_FindEntry(&ar->members, copy)) != NULL)
+	    hdr = Hash_FindValue(&ar->members, copy);
-		return (struct ar_hdr *)Hash_GetValue(he);
+	    return hdr;
 	    return NULL;
+	}
+    }
     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;
 @@ -618,49 +617,46 @@ ArchStatMember(const char *archive, cons
 		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)) {
 		    fprintf(debug_file, "ArchStat: Extended format entry for %s\n", memName);
+		}
+	    }
 #endif
 	    he = Hash_CreateEntry(&ar->members, memName, NULL);
-	    Hash_SetValue(he, bmake_malloc(sizeof(struct ar_hdr)));
+	        Hash_Entry *he;
-	    memcpy(Hash_GetValue(he), &arh, sizeof(struct ar_hdr));
+		he = Hash_CreateEntry(&ar->members, memName, NULL);
 		Hash_SetValue(he, bmake_malloc(sizeof(struct ar_hdr)));
 		memcpy(Hash_GetValue(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.
      */
-    he = Hash_FindEntry(&ar->members, member);
+    return Hash_FindValue(&ar->members, member);
     if (he != NULL) {
 	return (struct ar_hdr *)Hash_GetValue(he);
     } else {
 	return NULL;
 badarch:
     fclose(arch);
     Hash_DeleteTable(&ar->members);
     free(ar->fnametab);
     free(ar);
     return NULL;
+}
 #ifdef SVR4ARCHIVES
 /*-
  *-----------------------------------------------------------------------
  * ArchSVR4Entry --

 @@ -1,14 +1,14 @@
-/*	$NetBSD: hash.c,v 1.32 2020/09/13 15:15:51 rillig Exp $	*/
+/*	$NetBSD: hash.c,v 1.33 2020/09/26 14:48: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.
 @@ -69,27 +69,27 @@
  * SUCH DAMAGE.
  */
 /* 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"
 /*	"@(#)hash.c	8.1 (Berkeley) 6/6/93"	*/
-MAKE_RCSID("$NetBSD: hash.c,v 1.32 2020/09/13 15:15:51 rillig Exp $");
+MAKE_RCSID("$NetBSD: hash.c,v 1.33 2020/09/26 14:48:31 rillig Exp $");
 /*
  * 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.
  */
 @@ -178,26 +178,33 @@ Hash_FindEntry(Hash_Table *t, const char
 		fprintf(debug_file, "%s: %p h=%x key=%s\n", __func__,
 		    t, h, key);
 #endif
 	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;
+}
 void *
 Hash_FindValue(Hash_Table *t, const char *key)
+{
     Hash_Entry *he = Hash_FindEntry(t, key);
     return he != NULL ? he->value : NULL;
+}
 /* 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;

 @@ -1,14 +1,14 @@
-/*	$NetBSD: hash.h,v 1.23 2020/09/13 15:27:25 rillig Exp $	*/
+/*	$NetBSD: hash.h,v 1.24 2020/09/26 14:48: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
 @@ -111,21 +111,22 @@ Hash_GetValue(Hash_Entry *h)
+{
     return h->value;
+}
 static inline MAKE_ATTR_UNUSED void
 Hash_SetValue(Hash_Entry *h, void *datum)
+{
     h->value = datum;
+}
 void Hash_InitTable(Hash_Table *);
 void Hash_DeleteTable(Hash_Table *);
 Hash_Entry *Hash_FindEntry(Hash_Table *, const char *);
 void *Hash_FindValue(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 */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: var.c,v 1.541 2020/09/25 15:54:51 rillig Exp $	*/
+/*	$NetBSD: var.c,v 1.542 2020/09/26 14:48:31 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.
 @@ -111,27 +111,27 @@
 #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.541 2020/09/25 15:54:51 rillig Exp $");
+MAKE_RCSID("$NetBSD: var.c,v 1.542 2020/09/26 14:48:31 rillig Exp $");
 #define VAR_DEBUG_IF(cond, fmt, ...)	\
     if (!(DEBUG(VAR) && (cond)))	\
 	(void) 0;			\
     else				\
 	fprintf(debug_file, fmt, __VA_ARGS__)
 #define VAR_DEBUG(fmt, ...) VAR_DEBUG_IF(TRUE, fmt, __VA_ARGS__)
 ENUM_FLAGS_RTTI_3(VarEvalFlags,
 		  VARE_UNDEFERR, VARE_WANTRES, VARE_ASSIGN);
 /*
 @@ -267,27 +267,27 @@ typedef enum {
  *	ctxt		context in which to find it
  *	flags		FIND_GLOBAL	look in VAR_GLOBAL as well
  *			FIND_CMD	look in VAR_CMD as well
  *			FIND_ENV	look in the environment 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, VarFindFlags flags)
+{
-    Hash_Entry *var;
+    Var *var;
     /*
      * 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.
      */
     if (*name == '.' && ch_isupper(name[1])) {
 	switch (name[1]) {
 	case 'A':
 	    if (strcmp(name, ".ALLSRC") == 0)
 		name = ALLSRC;
 	    if (strcmp(name, ".ARCHIVE") == 0)
 @@ -312,85 +312,79 @@ VarFind(const char *name, GNode *ctxt, V
 	case 'S':
 	    if (strcmp(name, ".SHELL") == 0 ) {
 		if (!shellPath)
 		    Shell_Init();
+	    }
 	    break;
 	case 'T':
 	    if (strcmp(name, ".TARGET") == 0)
 		name = TARGET;
 	    break;
+	}
+    }
-#ifdef notyet
+#if 0
     /* for compatibility with gmake */
     if (name[0] == '^' && name[1] == '\0')
 	name = ALLSRC;
 #endif
     /*
      * First look for the variable in the given context. If it's not there,
      * look for it in VAR_CMD, VAR_GLOBAL and the environment, in that order,
      * depending on the FIND_* flags in 'flags'
      */
-    var = Hash_FindEntry(&ctxt->context, name);
+    var = Hash_FindValue(&ctxt->context, name);
     if (var == NULL && (flags & FIND_CMD) && ctxt != VAR_CMD)
-	var = Hash_FindEntry(&VAR_CMD->context, name);
+	var = Hash_FindValue(&VAR_CMD->context, name);
     if (!checkEnvFirst && var == NULL && (flags & FIND_GLOBAL) &&
 	ctxt != VAR_GLOBAL)
+    {
-	var = Hash_FindEntry(&VAR_GLOBAL->context, name);
+	var = Hash_FindValue(&VAR_GLOBAL->context, name);
 	if (var == NULL && ctxt != VAR_INTERNAL) {
 	    /* VAR_INTERNAL is subordinate to VAR_GLOBAL */
-	    var = Hash_FindEntry(&VAR_INTERNAL->context, name);
+	    var = Hash_FindValue(&VAR_INTERNAL->context, name);
+	}
+    }
     if (var == NULL && (flags & FIND_ENV)) {
 	char *env;
 	if ((env = getenv(name)) != NULL) {
 	    Var *v = bmake_malloc(sizeof(Var));
 	    size_t len;
 	    v->name = bmake_strdup(name);
 	    len = strlen(env);
 	    Buf_Init(&v->val, len + 1);
 	    Buf_AddBytes(&v->val, env, len);
 	    v->flags = VAR_FROM_ENV;
 	    return v;
+	}
 	if (checkEnvFirst && (flags & FIND_GLOBAL) && ctxt != VAR_GLOBAL) {
-	    var = Hash_FindEntry(&VAR_GLOBAL->context, name);
+	    var = Hash_FindValue(&VAR_GLOBAL->context, name);
 	    if (var == NULL && ctxt != VAR_INTERNAL)
-		var = Hash_FindEntry(&VAR_INTERNAL->context, name);
+		var = Hash_FindValue(&VAR_INTERNAL->context, name);
-	    if (var == NULL)
+	    return var;
 		return NULL;
 	    else
 		return (Var *)Hash_GetValue(var);
+	}
 	return NULL;
+    }
-    if (var == NULL)
+    return var;
 	return NULL;
     else
 	return (Var *)Hash_GetValue(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.