Index: trunk/src/kmk/dir.c
===================================================================
--- trunk/src/kmk/dir.c	(revision 1912)
+++ trunk/src/kmk/dir.c	(revision 1913)
@@ -291,5 +291,5 @@
   ISTRING_HASH_2 (key->path_key, hash);
 # else  /* CONFIG_WITH_STRCACHE2 */
-  hash = strcache2_get_hash1 (&file_strcache, key->path_key);
+  hash = strcache2_get_hash (&file_strcache, key->path_key);
 # endif /* CONFIG_WITH_STRCACHE2 */
   hash ^= ((unsigned int) key->dev << 4) ^ (unsigned int) ~key->ctime;
Index: trunk/src/kmk/hash.c
===================================================================
--- trunk/src/kmk/hash.c	(revision 1912)
+++ trunk/src/kmk/hash.c	(revision 1913)
@@ -213,5 +213,5 @@
   /* the rest of the loop. */
 
-  hash_2 = strcache2_get_hash1 (ht->ht_strcache, str1) | 1;
+  hash_2 = strcache2_get_hash (ht->ht_strcache, str1) | 1;
   hash_1 += hash_2;
   for (;;)
Index: trunk/src/kmk/incdep.c
===================================================================
--- trunk/src/kmk/incdep.c	(revision 1912)
+++ trunk/src/kmk/incdep.c	(revision 1913)
@@ -769,9 +769,7 @@
 {
   if (!entry->user)
-    entry->user = (void *)strcache2_add_hashed_file (&file_strcache,
-                                                     (const char *)(entry + 1),
-                                                     entry->length,
-                                                     entry->hash1,
-                                                     1);
+    entry->user = (void *) strcache2_add_hashed_file (&file_strcache,
+                                                      (const char *)(entry + 1),
+                                                      entry->length, entry->hash);
   return (const char *)entry->user;
 }
Index: trunk/src/kmk/strcache2.c
===================================================================
--- trunk/src/kmk/strcache2.c	(revision 1912)
+++ trunk/src/kmk/strcache2.c	(revision 1913)
@@ -512,10 +512,10 @@
 MY_INLINE int
 strcache2_is_equal (struct strcache2 *cache, struct strcache2_entry const *entry,
-                    const char *str, unsigned int length, unsigned int hash1)
+                    const char *str, unsigned int length, unsigned int hash)
 {
   assert (!cache->case_insensitive);
 
   /* the simple stuff first. */
-  if (   entry->hash1 != hash1
+  if (   entry->hash != hash
       || entry->length != length)
       return 0;
@@ -532,10 +532,10 @@
 MY_INLINE int
 strcache2_is_iequal (struct strcache2 *cache, struct strcache2_entry const *entry,
-                     const char *str, unsigned int length, unsigned int hash1)
+                     const char *str, unsigned int length, unsigned int hash)
 {
   assert (cache->case_insensitive);
 
   /* the simple stuff first. */
-  if (   entry->hash1 != hash1
+  if (   entry->hash != hash
       || entry->length != length)
       return 0;
@@ -581,5 +581,5 @@
         {
           struct strcache2_entry *next = entry->next;
-          unsigned int dst = STRCACHE2_MOD_IT (cache, entry->hash1);
+          unsigned int dst = STRCACHE2_MOD_IT (cache, entry->hash);
           if ((entry->next = dst_tab[dst]) != 0)
             cache->collision_count++;
@@ -631,5 +631,5 @@
 strcache2_enter_string (struct strcache2 *cache, unsigned int idx,
                         const char *str, unsigned int length,
-                        unsigned int hash1, unsigned hash2)
+                        unsigned int hash)
 {
   struct strcache2_entry *entry;
@@ -662,5 +662,5 @@
   entry->user = NULL;
   entry->length = length;
-  entry->hash1 = hash1;
+  entry->hash = hash;
   str_copy = (char *) memcpy (entry + 1, str, length);
   str_copy[length] = '\0';
@@ -681,6 +681,5 @@
 {
   struct strcache2_entry const *entry;
-  unsigned int hash1 = strcache2_case_sensitive_hash_1 (str, length);
-  unsigned int hash2 = 0;
+  unsigned int hash = strcache2_case_sensitive_hash_1 (str, length);
   unsigned int idx;
 
@@ -691,9 +690,9 @@
   /* Lookup the entry in the hash table, hoping for an
      early match.  If not found, enter the string at IDX. */
-  idx = STRCACHE2_MOD_IT (cache, hash1);
+  idx = STRCACHE2_MOD_IT (cache, hash);
   entry = cache->hash_tab[idx];
   if (!entry)
-    return strcache2_enter_string (cache, idx, str, length, hash1, hash2);
-  if (strcache2_is_equal (cache, entry, str, length, hash1))
+    return strcache2_enter_string (cache, idx, str, length, hash);
+  if (strcache2_is_equal (cache, entry, str, length, hash))
     return (const char *)(entry + 1);
   cache->collision_1st_count++;
@@ -701,16 +700,16 @@
   entry = entry->next;
   if (!entry)
-    return strcache2_enter_string (cache, idx, str, length, hash1, hash2);
-  if (strcache2_is_equal (cache, entry, str, length, hash1))
+    return strcache2_enter_string (cache, idx, str, length, hash);
+  if (strcache2_is_equal (cache, entry, str, length, hash))
     return (const char *)(entry + 1);
   cache->collision_2nd_count++;
 
-  /* (We've established hash2, so we can do a straight loop now.)  */
+  /* Loop the rest.  */
   for (;;)
     {
       entry = entry->next;
       if (!entry)
-        return strcache2_enter_string (cache, idx, str, length, hash1, hash2);
-      if (strcache2_is_equal (cache, entry, str, length, hash1))
+        return strcache2_enter_string (cache, idx, str, length, hash);
+      if (strcache2_is_equal (cache, entry, str, length, hash))
         return (const char *)(entry + 1);
       cache->collision_3rd_count++;
@@ -722,6 +721,6 @@
    Use strcache2_hash_str to calculate the hash of a string. */
 const char *
-strcache2_add_hashed (struct strcache2 *cache, const char *str, unsigned int length,
-                      unsigned int hash1, unsigned int hash2)
+strcache2_add_hashed (struct strcache2 *cache, const char *str,
+                      unsigned int length, unsigned int hash)
 {
   struct strcache2_entry const *entry;
@@ -732,10 +731,5 @@
   assert (!cache->case_insensitive);
   correct_hash = strcache2_case_sensitive_hash_1 (str, length);
-  MY_ASSERT_MSG (hash1 == correct_hash, ("%#x != %#x\n", hash1, correct_hash));
-  if (hash2)
-    {
-      correct_hash = strcache2_case_sensitive_hash_2 (str, length);
-      MY_ASSERT_MSG (hash2 == correct_hash, ("%#x != %#x\n", hash2, correct_hash));
-    }
+  MY_ASSERT_MSG (hash == correct_hash, ("%#x != %#x\n", hash, correct_hash));
 #endif /* NDEBUG */
 
@@ -744,9 +738,9 @@
   /* Lookup the entry in the hash table, hoping for an
      early match.  If not found, enter the string at IDX. */
-  idx = STRCACHE2_MOD_IT (cache, hash1);
+  idx = STRCACHE2_MOD_IT (cache, hash);
   entry = cache->hash_tab[idx];
   if (!entry)
-    return strcache2_enter_string (cache, idx, str, length, hash1, hash2);
-  if (strcache2_is_equal (cache, entry, str, length, hash1))
+    return strcache2_enter_string (cache, idx, str, length, hash);
+  if (strcache2_is_equal (cache, entry, str, length, hash))
     return (const char *)(entry + 1);
   cache->collision_1st_count++;
@@ -754,16 +748,16 @@
   entry = entry->next;
   if (!entry)
-    return strcache2_enter_string (cache, idx, str, length, hash1, hash2);
-  if (strcache2_is_equal (cache, entry, str, length, hash1))
+    return strcache2_enter_string (cache, idx, str, length, hash);
+  if (strcache2_is_equal (cache, entry, str, length, hash))
     return (const char *)(entry + 1);
   cache->collision_2nd_count++;
 
-  /* (We've established hash2, so we can do a straight loop now.)  */
+  /* Loop the rest.  */
   for (;;)
     {
       entry = entry->next;
       if (!entry)
-        return strcache2_enter_string (cache, idx, str, length, hash1, hash2);
-      if (strcache2_is_equal (cache, entry, str, length, hash1))
+        return strcache2_enter_string (cache, idx, str, length, hash);
+      if (strcache2_is_equal (cache, entry, str, length, hash))
         return (const char *)(entry + 1);
       cache->collision_3rd_count++;
@@ -777,5 +771,5 @@
 {
   struct strcache2_entry const *entry;
-  unsigned int hash1 = strcache2_case_sensitive_hash_1 (str, length);
+  unsigned int hash = strcache2_case_sensitive_hash_1 (str, length);
   unsigned int idx;
 
@@ -786,9 +780,9 @@
   /* Lookup the entry in the hash table, hoping for an
      early match. */
-  idx = STRCACHE2_MOD_IT (cache, hash1);
+  idx = STRCACHE2_MOD_IT (cache, hash);
   entry = cache->hash_tab[idx];
   if (!entry)
     return NULL;
-  if (strcache2_is_equal (cache, entry, str, length, hash1))
+  if (strcache2_is_equal (cache, entry, str, length, hash))
     return (const char *)(entry + 1);
   cache->collision_1st_count++;
@@ -797,9 +791,9 @@
   if (!entry)
     return NULL;
-  if (strcache2_is_equal (cache, entry, str, length, hash1))
+  if (strcache2_is_equal (cache, entry, str, length, hash))
     return (const char *)(entry + 1);
   cache->collision_2nd_count++;
 
-  /* (We've established hash2, so we can do a straight loop now.)  */
+  /* Loop the rest. */
   for (;;)
     {
@@ -807,5 +801,5 @@
       if (!entry)
         return NULL;
-      if (strcache2_is_equal (cache, entry, str, length, hash1))
+      if (strcache2_is_equal (cache, entry, str, length, hash))
         return (const char *)(entry + 1);
       cache->collision_3rd_count++;
@@ -821,6 +815,5 @@
 {
   struct strcache2_entry const *entry;
-  unsigned int hash1 = strcache2_case_insensitive_hash_1 (str, length);
-  unsigned int hash2 = 0;
+  unsigned int hash = strcache2_case_insensitive_hash_1 (str, length);
   unsigned int idx;
 
@@ -831,9 +824,9 @@
   /* Lookup the entry in the hash table, hoping for an
      early match.  If not found, enter the string at IDX. */
-  idx = STRCACHE2_MOD_IT (cache, hash1);
+  idx = STRCACHE2_MOD_IT (cache, hash);
   entry = cache->hash_tab[idx];
   if (!entry)
-    return strcache2_enter_string (cache, idx, str, length, hash1, hash2);
-  if (strcache2_is_equal (cache, entry, str, length, hash1))
+    return strcache2_enter_string (cache, idx, str, length, hash);
+  if (strcache2_is_equal (cache, entry, str, length, hash))
     return (const char *)(entry + 1);
   cache->collision_1st_count++;
@@ -841,16 +834,16 @@
   entry = entry->next;
   if (!entry)
-    return strcache2_enter_string (cache, idx, str, length, hash1, hash2);
-  if (strcache2_is_equal (cache, entry, str, length, hash1))
+    return strcache2_enter_string (cache, idx, str, length, hash);
+  if (strcache2_is_equal (cache, entry, str, length, hash))
     return (const char *)(entry + 1);
   cache->collision_2nd_count++;
 
-  /* (We've established hash2, so we can do a straight loop now.)  */
+  /* Loop the rest. */
   for (;;)
     {
       entry = entry->next;
       if (!entry)
-        return strcache2_enter_string (cache, idx, str, length, hash1, hash2);
-      if (strcache2_is_equal (cache, entry, str, length, hash1))
+        return strcache2_enter_string (cache, idx, str, length, hash);
+      if (strcache2_is_equal (cache, entry, str, length, hash))
         return (const char *)(entry + 1);
       cache->collision_3rd_count++;
@@ -862,6 +855,6 @@
    Use strcache2_hash_istr to calculate the hash of a string. */
 const char *
-strcache2_iadd_hashed (struct strcache2 *cache, const char *str, unsigned int length,
-                       unsigned int hash1, unsigned int hash2)
+strcache2_iadd_hashed (struct strcache2 *cache, const char *str,
+                       unsigned int length, unsigned int hash)
 {
   struct strcache2_entry const *entry;
@@ -872,10 +865,5 @@
   assert (!cache->case_insensitive);
   correct_hash = strcache2_case_insensitive_hash_1 (str, length);
-  MY_ASSERT_MSG (hash1 == correct_hash, ("%#x != %#x\n", hash1, correct_hash));
-  if (hash2)
-    {
-      correct_hash = strcache2_case_insensitive_hash_2 (str, length);
-      MY_ASSERT_MSG (hash2 == correct_hash, ("%#x != %#x\n", hash2, correct_hash));
-    }
+  MY_ASSERT_MSG (hash == correct_hash, ("%#x != %#x\n", hash, correct_hash));
 #endif /* NDEBUG */
 
@@ -884,9 +872,9 @@
   /* Lookup the entry in the hash table, hoping for an
      early match.  If not found, enter the string at IDX. */
-  idx = STRCACHE2_MOD_IT (cache, hash1);
+  idx = STRCACHE2_MOD_IT (cache, hash);
   entry = cache->hash_tab[idx];
   if (!entry)
-    return strcache2_enter_string (cache, idx, str, length, hash1, hash2);
-  if (strcache2_is_equal (cache, entry, str, length, hash1))
+    return strcache2_enter_string (cache, idx, str, length, hash);
+  if (strcache2_is_equal (cache, entry, str, length, hash))
     return (const char *)(entry + 1);
   cache->collision_1st_count++;
@@ -894,16 +882,16 @@
   entry = entry->next;
   if (!entry)
-    return strcache2_enter_string (cache, idx, str, length, hash1, hash2);
-  if (strcache2_is_equal (cache, entry, str, length, hash1))
+    return strcache2_enter_string (cache, idx, str, length, hash);
+  if (strcache2_is_equal (cache, entry, str, length, hash))
     return (const char *)(entry + 1);
   cache->collision_2nd_count++;
 
-  /* (We've established hash2, so we can do a straight loop now.)  */
+  /* Loop the rest. */
   for (;;)
     {
       entry = entry->next;
       if (!entry)
-        return strcache2_enter_string (cache, idx, str, length, hash1, hash2);
-      if (strcache2_is_equal (cache, entry, str, length, hash1))
+        return strcache2_enter_string (cache, idx, str, length, hash);
+      if (strcache2_is_equal (cache, entry, str, length, hash))
         return (const char *)(entry + 1);
       cache->collision_3rd_count++;
@@ -917,5 +905,5 @@
 {
   struct strcache2_entry const *entry;
-  unsigned int hash1 = strcache2_case_insensitive_hash_1 (str, length);
+  unsigned int hash = strcache2_case_insensitive_hash_1 (str, length);
   unsigned int idx;
 
@@ -926,9 +914,9 @@
   /* Lookup the entry in the hash table, hoping for an
      early match. */
-  idx = STRCACHE2_MOD_IT (cache, hash1);
+  idx = STRCACHE2_MOD_IT (cache, hash);
   entry = cache->hash_tab[idx];
   if (!entry)
     return NULL;
-  if (strcache2_is_equal (cache, entry, str, length, hash1))
+  if (strcache2_is_equal (cache, entry, str, length, hash))
     return (const char *)(entry + 1);
   cache->collision_1st_count++;
@@ -937,9 +925,9 @@
   if (!entry)
     return NULL;
-  if (strcache2_is_equal (cache, entry, str, length, hash1))
+  if (strcache2_is_equal (cache, entry, str, length, hash))
     return (const char *)(entry + 1);
   cache->collision_2nd_count++;
 
-  /* (We've established hash2, so we can do a straight loop now.)  */
+  /* Loop the rest. */
   for (;;)
     {
@@ -947,5 +935,5 @@
       if (!entry)
         return NULL;
-      if (strcache2_is_equal (cache, entry, str, length, hash1))
+      if (strcache2_is_equal (cache, entry, str, length, hash))
         return (const char *)(entry + 1);
       cache->collision_3rd_count++;
@@ -1004,9 +992,9 @@
     ? strcache2_case_insensitive_hash_1 (str, entry->length)
     : strcache2_case_sensitive_hash_1 (str, entry->length);
-  if (hash != entry->hash1)
+  if (hash != entry->hash)
     {
       fprintf (stderr,
                "strcache2[%s]: corrupt entry %p, hash#1: %x, expected %x;\nstring: %s\n",
-               cache->name, (void *)entry, hash, entry->hash1, str);
+               cache->name, (void *)entry, hash, entry->hash, str);
       return -1;
     }
Index: trunk/src/kmk/strcache2.h
===================================================================
--- trunk/src/kmk/strcache2.h	(revision 1912)
+++ trunk/src/kmk/strcache2.h	(revision 1913)
@@ -49,5 +49,5 @@
     struct strcache2_entry *next;       /* Collision chain. */
     void *user;
-    unsigned int hash1;
+    unsigned int hash;
     unsigned int length;
 };
@@ -102,8 +102,8 @@
 const char *strcache2_add (struct strcache2 *cache, const char *str, unsigned int length);
 const char *strcache2_iadd (struct strcache2 *cache, const char *str, unsigned int length);
-const char *strcache2_add_hashed (struct strcache2 *cache, const char *str, unsigned int length,
-                                  unsigned int hash1, unsigned int hash2);
-const char *strcache2_iadd_hashed (struct strcache2 *cache, const char *str, unsigned int length,
-                                   unsigned int hash1, unsigned int hash2);
+const char *strcache2_add_hashed (struct strcache2 *cache, const char *str,
+                                  unsigned int length, unsigned int hash);
+const char *strcache2_iadd_hashed (struct strcache2 *cache, const char *str,
+                                   unsigned int length, unsigned int hash);
 const char *strcache2_lookup (struct strcache2 *cache, const char *str, unsigned int length);
 const char *strcache2_ilookup (struct strcache2 *cache, const char *str, unsigned int length);
@@ -142,7 +142,7 @@
 /* Get the first hash value for the string. */
 MY_INLINE unsigned int
-strcache2_get_hash1 (struct strcache2 *cache, const char *str)
+strcache2_get_hash (struct strcache2 *cache, const char *str)
 {
-  return strcache2_get_entry (cache, str)->hash1;
+  return strcache2_get_entry (cache, str)->hash;
 }
 
Index: trunk/src/kmk/variable.c
===================================================================
--- trunk/src/kmk/variable.c	(revision 1912)
+++ trunk/src/kmk/variable.c	(revision 1913)
@@ -475,5 +475,5 @@
 
       /* the rest of the loop  */
-      hash_2 = strcache2_get_hash1 (&variable_strcache, name) | 1;
+      hash_2 = strcache2_get_hash (&variable_strcache, name) | 1;
       for (;;)
         {
@@ -491,5 +491,5 @@
     }
   else
-    hash_2 = strcache2_get_hash1 (&variable_strcache, name) | 1;
+    hash_2 = strcache2_get_hash (&variable_strcache, name) | 1;
 
 
