hash: avoid no-op rehashing
[gnulib.git] / lib / hash.c
index 8438143..f2123b4 100644 (file)
@@ -1,11 +1,14 @@
 /* hash - hashing table processing.
-   Copyright (C) 1998, 1999, 2000 Free Software Foundation, Inc.
+
+   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006, 2007,
+   2009 Free Software Foundation, Inc.
+
    Written by Jim Meyering, 1992.
 
-   This program is free software; you can redistribute it and/or modify
+   This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2, or (at your option)
-   any later version.
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software Foundation,
-   Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* A generic hash table package.  */
 
 /* Define USE_OBSTACK to 1 if you want the allocator to use obstacks instead
    of malloc.  If you change USE_OBSTACK, you have to recompile!  */
 
-#if HAVE_CONFIG_H
-# include <config.h>
-#endif
-#if HAVE_STDLIB_H
-# include <stdlib.h>
-#endif
-#if HAVE_STDBOOL_H
-# include <stdbool.h>
-#else
-typedef enum {false = 0, true = 1} bool;
-#endif
-#include <stdio.h>
-#include <assert.h>
+#include <config.h>
 
-#ifndef HAVE_DECL_FREE
-"this configure-time declaration test was not run"
-#endif
-#if !HAVE_DECL_FREE
-void free ();
-#endif
+#include "hash.h"
+#include "xalloc.h"
 
-#ifndef HAVE_DECL_MALLOC
-"this configure-time declaration test was not run"
-#endif
-#if !HAVE_DECL_MALLOC
-char *malloc ();
-#endif
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
 
 #if USE_OBSTACK
 # include "obstack.h"
@@ -59,10 +42,52 @@ char *malloc ();
 # endif
 #endif
 
-#include "hash.h"
+#ifndef SIZE_MAX
+# define SIZE_MAX ((size_t) -1)
+#endif
+
+struct hash_entry
+  {
+    void *data;
+    struct hash_entry *next;
+  };
+
+struct hash_table
+  {
+    /* The array of buckets starts at BUCKET and extends to BUCKET_LIMIT-1,
+       for a possibility of N_BUCKETS.  Among those, N_BUCKETS_USED buckets
+       are not empty, there are N_ENTRIES active entries in the table.  */
+    struct hash_entry *bucket;
+    struct hash_entry const *bucket_limit;
+    size_t n_buckets;
+    size_t n_buckets_used;
+    size_t n_entries;
+
+    /* Tuning arguments, kept in a physically separate structure.  */
+    const Hash_tuning *tuning;
+
+    /* Three functions are given to `hash_initialize', see the documentation
+       block for this function.  In a word, HASHER randomizes a user entry
+       into a number up from 0 up to some maximum minus 1; COMPARATOR returns
+       true if two user entries compare equally; and DATA_FREER is the cleanup
+       function for a user entry.  */
+    Hash_hasher hasher;
+    Hash_comparator comparator;
+    Hash_data_freer data_freer;
+
+    /* A linked list of freed struct hash_entry structs.  */
+    struct hash_entry *free_entry_list;
+
+#if USE_OBSTACK
+    /* Whenever obstacks are used, it is possible to allocate all overflowed
+       entries into a single stack, so they all can be freed in a single
+       operation.  It is not clear if the speedup is worth the trouble.  */
+    struct obstack entry_stack;
+#endif
+  };
 
 /* A hash table contains many internal entries, each holding a pointer to
-   some user provided data (also called a user entry).  An entry indistinctly
+   some user-provided data (also called a user entry).  An entry indistinctly
    refers to both the internal entry and its associated user entry.  A user
    entry contents may be hashed by a randomization function (the hashing
    function, or just `hasher' for short) into a number (or `slot') between 0
@@ -124,7 +149,7 @@ static const Hash_tuning default_tuning =
    number of buckets (used plus unused), or the maximum number of slots, are
    the same quantity.  */
 
-unsigned
+size_t
 hash_get_n_buckets (const Hash_table *table)
 {
   return table->n_buckets;
@@ -132,7 +157,7 @@ hash_get_n_buckets (const Hash_table *table)
 
 /* Return the number of slots in use (non-empty buckets).  */
 
-unsigned
+size_t
 hash_get_n_buckets_used (const Hash_table *table)
 {
   return table->n_buckets_used;
@@ -140,7 +165,7 @@ hash_get_n_buckets_used (const Hash_table *table)
 
 /* Return the number of active entries.  */
 
-unsigned
+size_t
 hash_get_n_entries (const Hash_table *table)
 {
   return table->n_entries;
@@ -148,18 +173,18 @@ hash_get_n_entries (const Hash_table *table)
 
 /* Return the length of the longest chain (bucket).  */
 
-unsigned
+size_t
 hash_get_max_bucket_length (const Hash_table *table)
 {
-  struct hash_entry *bucket;
-  unsigned max_bucket_length = 0;
+  struct hash_entry const *bucket;
+  size_t max_bucket_length = 0;
 
   for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
     {
       if (bucket->data)
        {
-         struct hash_entry *cursor = bucket;
-         unsigned bucket_length = 1;
+         struct hash_entry const *cursor = bucket;
+         size_t bucket_length = 1;
 
          while (cursor = cursor->next, cursor)
            bucket_length++;
@@ -178,15 +203,15 @@ hash_get_max_bucket_length (const Hash_table *table)
 bool
 hash_table_ok (const Hash_table *table)
 {
-  struct hash_entry *bucket;
-  unsigned n_buckets_used = 0;
-  unsigned n_entries = 0;
+  struct hash_entry const *bucket;
+  size_t n_buckets_used = 0;
+  size_t n_entries = 0;
 
   for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
     {
       if (bucket->data)
        {
-         struct hash_entry *cursor = bucket;
+         struct hash_entry const *cursor = bucket;
 
          /* Count bucket head.  */
          n_buckets_used++;
@@ -207,16 +232,18 @@ hash_table_ok (const Hash_table *table)
 void
 hash_print_statistics (const Hash_table *table, FILE *stream)
 {
-  unsigned n_entries = hash_get_n_entries (table);
-  unsigned n_buckets = hash_get_n_buckets (table);
-  unsigned n_buckets_used = hash_get_n_buckets_used (table);
-  unsigned max_bucket_length = hash_get_max_bucket_length (table);
-
-  fprintf (stream, "# entries:         %u\n", n_entries);
-  fprintf (stream, "# buckets:         %u\n", n_buckets);
-  fprintf (stream, "# buckets used:    %u (%.2f%%)\n", n_buckets_used,
+  size_t n_entries = hash_get_n_entries (table);
+  size_t n_buckets = hash_get_n_buckets (table);
+  size_t n_buckets_used = hash_get_n_buckets_used (table);
+  size_t max_bucket_length = hash_get_max_bucket_length (table);
+
+  fprintf (stream, "# entries:         %lu\n", (unsigned long int) n_entries);
+  fprintf (stream, "# buckets:         %lu\n", (unsigned long int) n_buckets);
+  fprintf (stream, "# buckets used:    %lu (%.2f%%)\n",
+          (unsigned long int) n_buckets_used,
           (100.0 * n_buckets_used) / n_buckets);
-  fprintf (stream, "max bucket length: %u\n", max_bucket_length);
+  fprintf (stream, "max bucket length: %lu\n",
+          (unsigned long int) max_bucket_length);
 }
 
 /* If ENTRY matches an entry already in the hash table, return the
@@ -225,17 +252,18 @@ hash_print_statistics (const Hash_table *table, FILE *stream)
 void *
 hash_lookup (const Hash_table *table, const void *entry)
 {
-  struct hash_entry *bucket
+  struct hash_entry const *bucket
     = table->bucket + table->hasher (entry, table->n_buckets);
-  struct hash_entry *cursor;
+  struct hash_entry const *cursor;
 
-  assert (bucket < table->bucket_limit);
+  if (! (bucket < table->bucket_limit))
+    abort ();
 
   if (bucket->data == NULL)
     return NULL;
 
   for (cursor = bucket; cursor; cursor = cursor->next)
-    if (table->comparator (entry, cursor->data))
+    if (entry == cursor->data || table->comparator (entry, cursor->data))
       return cursor->data;
 
   return NULL;
@@ -246,23 +274,25 @@ hash_lookup (const Hash_table *table, const void *entry)
 /* The functions in this page traverse the hash table and process the
    contained entries.  For the traversal to work properly, the hash table
    should not be resized nor modified while any particular entry is being
-   processed.  In particular, entries should not be added or removed.  */
+   processed.  In particular, entries should not be added, and an entry
+   may be removed only if there is no shrink threshold and the entry being
+   removed has already been passed to hash_get_next.  */
 
 /* Return the first data in the table, or NULL if the table is empty.  */
 
 void *
 hash_get_first (const Hash_table *table)
 {
-  struct hash_entry *bucket;
+  struct hash_entry const *bucket;
 
   if (table->n_entries == 0)
     return NULL;
 
-  for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
-    if (bucket->data)
+  for (bucket = table->bucket; ; bucket++)
+    if (! (bucket < table->bucket_limit))
+      abort ();
+    else if (bucket->data)
       return bucket->data;
-
-  assert (0);
 }
 
 /* Return the user data for the entry following ENTRY, where ENTRY has been
@@ -272,11 +302,12 @@ hash_get_first (const Hash_table *table)
 void *
 hash_get_next (const Hash_table *table, const void *entry)
 {
-  struct hash_entry *bucket
+  struct hash_entry const *bucket
     = table->bucket + table->hasher (entry, table->n_buckets);
-  struct hash_entry *cursor;
+  struct hash_entry const *cursor;
 
-  assert (bucket < table->bucket_limit);
+  if (! (bucket < table->bucket_limit))
+    abort ();
 
   /* Find next entry in the same bucket.  */
   for (cursor = bucket; cursor; cursor = cursor->next)
@@ -296,13 +327,13 @@ hash_get_next (const Hash_table *table, const void *entry)
    return the number of pointers copied.  Do not copy more than BUFFER_SIZE
    pointers.  */
 
-unsigned
+size_t
 hash_get_entries (const Hash_table *table, void **buffer,
-                 unsigned buffer_size)
+                 size_t buffer_size)
 {
-  unsigned counter = 0;
-  struct hash_entry *bucket;
-  struct hash_entry *cursor;
+  size_t counter = 0;
+  struct hash_entry const *bucket;
+  struct hash_entry const *cursor;
 
   for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
     {
@@ -328,13 +359,13 @@ hash_get_entries (const Hash_table *table, void **buffer,
    as received.  The walking continue for as long as the PROCESSOR function
    returns nonzero.  When it returns zero, the walking is interrupted.  */
 
-unsigned
+size_t
 hash_do_for_each (const Hash_table *table, Hash_processor processor,
                  void *processor_data)
 {
-  unsigned counter = 0;
-  struct hash_entry *bucket;
-  struct hash_entry *cursor;
+  size_t counter = 0;
+  struct hash_entry const *bucket;
+  struct hash_entry const *cursor;
 
   for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
     {
@@ -342,7 +373,7 @@ hash_do_for_each (const Hash_table *table, Hash_processor processor,
        {
          for (cursor = bucket; cursor; cursor = cursor->next)
            {
-             if (!(*processor) (cursor->data, processor_data))
+             if (! processor (cursor->data, processor_data))
                return counter;
              counter++;
            }
@@ -365,21 +396,19 @@ hash_do_for_each (const Hash_table *table, Hash_processor processor,
    algorithms tend to be domain-specific, so what's good for [diffutils'] io.c
    may not be good for your application."  */
 
-unsigned
-hash_string (const char *string, unsigned n_buckets)
+size_t
+hash_string (const char *string, size_t n_buckets)
 {
-# ifndef CHAR_BIT
-#  define CHAR_BIT 8
-# endif
 # define ROTATE_LEFT(Value, Shift) \
-  ((Value) << (Shift) | (Value) >> ((sizeof (unsigned) * CHAR_BIT) - (Shift)))
+  ((Value) << (Shift) | (Value) >> ((sizeof (size_t) * CHAR_BIT) - (Shift)))
 # define HASH_ONE_CHAR(Value, Byte) \
   ((Byte) + ROTATE_LEFT (Value, 7))
 
-  unsigned value = 0;
+  size_t value = 0;
+  unsigned char ch;
 
-  for (; *string; string++)
-    value = HASH_ONE_CHAR (value, *(const unsigned char *) string);
+  for (; (ch = *string); string++)
+    value = HASH_ONE_CHAR (value, ch);
   return value % n_buckets;
 
 # undef ROTATE_LEFT
@@ -393,14 +422,14 @@ hash_string (const char *string, unsigned n_buckets)
    very old Cyber `snoop', itself written in typical Greg Mansfield style.
    (By the way, what happened to this excellent man?  Is he still alive?)  */
 
-unsigned
-hash_string (const char *string, unsigned n_buckets)
+size_t
+hash_string (const char *string, size_t n_buckets)
 {
-  unsigned value = 0;
+  size_t value = 0;
+  unsigned char ch;
 
-  while (*string)
-    value = ((value * 31 + (int) *(const unsigned char *) string++)
-            % n_buckets);
+  for (; (ch = *string); string++)
+    value = (value * 31 + ch) % n_buckets;
   return value;
 }
 
@@ -410,10 +439,10 @@ hash_string (const char *string, unsigned n_buckets)
    number at least equal to 11.  */
 
 static bool
-is_prime (unsigned long candidate)
+is_prime (size_t candidate)
 {
-  unsigned long divisor = 3;
-  unsigned long square = divisor * divisor;
+  size_t divisor = 3;
+  size_t square = divisor * divisor;
 
   while (square < candidate && (candidate % divisor))
     {
@@ -422,14 +451,14 @@ is_prime (unsigned long candidate)
       divisor++;
     }
 
-  return candidate % divisor != 0;
+  return (candidate % divisor ? true : false);
 }
 
 /* Round a given CANDIDATE number up to the nearest prime, and return that
    prime.  Primes lower than 10 are merely skipped.  */
 
-static unsigned long
-next_prime (unsigned long candidate)
+static size_t
+next_prime (size_t candidate)
 {
   /* Skip small primes.  */
   if (candidate < 10)
@@ -450,6 +479,28 @@ hash_reset_tuning (Hash_tuning *tuning)
   *tuning = default_tuning;
 }
 
+/* If the user passes a NULL hasher, we hash the raw pointer.  */
+static size_t
+raw_hasher (const void *data, size_t n)
+{
+  /* When hashing unique pointers, it is often the case that they were
+     generated by malloc and thus have the property that the low-order
+     bits are 0.  As this tends to give poorer performance with small
+     tables, we rotate the pointer value before performing division,
+     in an attempt to improve hash quality.  */
+  size_t val = (size_t) data;
+  val = ((val >> 3) | (val << (CHAR_BIT * sizeof val - 3))) & SIZE_MAX;
+  return val % n;
+}
+
+/* If the user passes a NULL comparator, we use pointer comparison.  */
+static bool
+raw_comparator (const void *a, const void *b)
+{
+  return a == b;
+}
+
+
 /* For the given hash TABLE, check the user supplied tuning structure for
    reasonable values, and return true if there is no gross error with it.
    Otherwise, definitively reset the TUNING field to some acceptable default
@@ -460,15 +511,23 @@ static bool
 check_tuning (Hash_table *table)
 {
   const Hash_tuning *tuning = table->tuning;
+  if (tuning == &default_tuning)
+    return true;
 
-  if (tuning->growth_threshold > 0.0
-      && tuning->growth_threshold < 1.0
-      && tuning->growth_factor > 1.0
-      && tuning->shrink_threshold >= 0.0
-      && tuning->shrink_threshold < 1.0
-      && tuning->shrink_factor > tuning->shrink_threshold
-      && tuning->shrink_factor <= 1.0
-      && tuning->shrink_threshold < tuning->growth_threshold)
+  /* Be a bit stricter than mathematics would require, so that
+     rounding errors in size calculations do not cause allocations to
+     fail to grow or shrink as they should.  The smallest allocation
+     is 11 (due to next_prime's algorithm), so an epsilon of 0.1
+     should be good enough.  */
+  float epsilon = 0.1f;
+
+  if (epsilon < tuning->growth_threshold
+      && tuning->growth_threshold < 1 - epsilon
+      && 1 + epsilon < tuning->growth_factor
+      && 0 <= tuning->shrink_threshold
+      && tuning->shrink_threshold + epsilon < tuning->shrink_factor
+      && tuning->shrink_factor <= 1
+      && tuning->shrink_threshold + epsilon < tuning->growth_threshold)
     return true;
 
   table->tuning = &default_tuning;
@@ -486,17 +545,20 @@ check_tuning (Hash_table *table)
 
    TUNING points to a structure of user-supplied values, in case some fine
    tuning is wanted over the default behavior of the hasher.  If TUNING is
-   NULL, the default tuning parameters are used instead.
+   NULL, the default tuning parameters are used instead.  If TUNING is
+   provided but the values requested are out of bounds or might cause
+   rounding errors, return NULL.
 
-   The user-supplied HASHER function should be provided.  It accepts two
+   The user-supplied HASHER function, when not NULL, accepts two
    arguments ENTRY and TABLE_SIZE.  It computes, by hashing ENTRY contents, a
    slot number for that entry which should be in the range 0..TABLE_SIZE-1.
    This slot number is then returned.
 
-   The user-supplied COMPARATOR function should be provided.  It accepts two
+   The user-supplied COMPARATOR function, when not NULL, accepts two
    arguments pointing to user data, it then returns true for a pair of entries
    that compare equal, or false otherwise.  This function is internally called
-   on entries which are already known to hash to the same bucket index.
+   on entries which are already known to hash to the same bucket index,
+   but which are distinct pointers.
 
    The user-supplied DATA_FREER function, when not NULL, may be later called
    with the user data as an argument, just before the entry containing the
@@ -507,17 +569,18 @@ check_tuning (Hash_table *table)
    values.  */
 
 Hash_table *
-hash_initialize (unsigned candidate, const Hash_tuning *tuning,
+hash_initialize (size_t candidate, const Hash_tuning *tuning,
                 Hash_hasher hasher, Hash_comparator comparator,
                 Hash_data_freer data_freer)
 {
   Hash_table *table;
-  struct hash_entry *bucket;
 
-  if (hasher == NULL || comparator == NULL)
-    return NULL;
+  if (hasher == NULL)
+    hasher = raw_hasher;
+  if (comparator == NULL)
+    comparator = raw_comparator;
 
-  table = (Hash_table *) malloc (sizeof (Hash_table));
+  table = malloc (sizeof *table);
   if (table == NULL)
     return NULL;
 
@@ -531,28 +594,27 @@ hash_initialize (unsigned candidate, const Hash_tuning *tuning,
         if the user provides invalid tuning options, we silently revert to
         using the defaults, and ignore further request to change the tuning
         options.  */
-      free (table);
-      return NULL;
+      goto fail;
     }
 
-  table->n_buckets
-    = next_prime (tuning->is_n_buckets ? candidate
-                 : (unsigned) (candidate / tuning->growth_threshold));
-
-  table->bucket = (struct hash_entry *)
-    malloc (table->n_buckets * sizeof (struct hash_entry));
-  if (table->bucket == NULL)
+  if (!tuning->is_n_buckets)
     {
-      free (table);
-      return NULL;
+      float new_candidate = candidate / tuning->growth_threshold;
+      if (SIZE_MAX <= new_candidate)
+       goto fail;
+      candidate = new_candidate;
     }
-  table->bucket_limit = table->bucket + table->n_buckets;
 
-  for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
-    {
-      bucket->data = NULL;
-      bucket->next = NULL;
-    }
+  if (xalloc_oversized (candidate, sizeof *table->bucket))
+    goto fail;
+  table->n_buckets = next_prime (candidate);
+  if (xalloc_oversized (table->n_buckets, sizeof *table->bucket))
+    goto fail;
+
+  table->bucket = calloc (table->n_buckets, sizeof *table->bucket);
+  if (table->bucket == NULL)
+    goto fail;
+  table->bucket_limit = table->bucket + table->n_buckets;
   table->n_buckets_used = 0;
   table->n_entries = 0;
 
@@ -565,6 +627,10 @@ hash_initialize (unsigned candidate, const Hash_tuning *tuning,
   obstack_init (&table->entry_stack);
 #endif
   return table;
+
+ fail:
+  free (table);
+  return NULL;
 }
 
 /* Make all buckets empty, placing any chained entries on the free list.
@@ -575,19 +641,22 @@ void
 hash_clear (Hash_table *table)
 {
   struct hash_entry *bucket;
-  struct hash_entry *cursor;
 
   for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
     {
       if (bucket->data)
        {
+         struct hash_entry *cursor;
+         struct hash_entry *next;
+
          /* Free the bucket overflow.  */
-         for (cursor = bucket->next; cursor; cursor = cursor->next)
+         for (cursor = bucket->next; cursor; cursor = next)
            {
              if (table->data_freer)
-               (*table->data_freer) (cursor->data);
+               table->data_freer (cursor->data);
              cursor->data = NULL;
 
+             next = cursor->next;
              /* Relinking is done one entry at a time, as it is to be expected
                 that overflows are either rare or short.  */
              cursor->next = table->free_entry_list;
@@ -596,7 +665,7 @@ hash_clear (Hash_table *table)
 
          /* Free the bucket head.  */
          if (table->data_freer)
-           (*table->data_freer) (bucket->data);
+           table->data_freer (bucket->data);
          bucket->data = NULL;
          bucket->next = NULL;
        }
@@ -626,9 +695,7 @@ hash_free (Hash_table *table)
          if (bucket->data)
            {
              for (cursor = bucket; cursor; cursor = cursor->next)
-               {
-                 (*table->data_freer) (cursor->data);
-               }
+               table->data_freer (cursor->data);
            }
        }
     }
@@ -665,7 +732,7 @@ hash_free (Hash_table *table)
 
 /* Insertion and deletion.  */
 
-/* Get a new hash entry for a bucket overflow, possibly by reclying a
+/* Get a new hash entry for a bucket overflow, possibly by recycling a
    previously freed one.  If this is not possible, allocate a new one.  */
 
 static struct hash_entry *
@@ -681,10 +748,9 @@ allocate_entry (Hash_table *table)
   else
     {
 #if USE_OBSTACK
-      new = (struct hash_entry *)
-       obstack_alloc (&table->entry_stack, sizeof (struct hash_entry));
+      new = obstack_alloc (&table->entry_stack, sizeof *new);
 #else
-      new = (struct hash_entry *) malloc (sizeof (struct hash_entry));
+      new = malloc (sizeof *new);
 #endif
     }
 
@@ -716,7 +782,9 @@ hash_find_entry (Hash_table *table, const void *entry,
     = table->bucket + table->hasher (entry, table->n_buckets);
   struct hash_entry *cursor;
 
-  assert (bucket < table->bucket_limit);
+  if (! (bucket < table->bucket_limit))
+    abort ();
+
   *bucket_head = bucket;
 
   /* Test for empty bucket.  */
@@ -724,7 +792,7 @@ hash_find_entry (Hash_table *table, const void *entry,
     return NULL;
 
   /* See if the entry is the first in the bucket.  */
-  if ((*table->comparator) (entry, bucket->data))
+  if (entry == bucket->data || table->comparator (entry, bucket->data))
     {
       void *data = bucket->data;
 
@@ -751,7 +819,8 @@ hash_find_entry (Hash_table *table, const void *entry,
   /* Scan the bucket overflow.  */
   for (cursor = bucket; cursor->next; cursor = cursor->next)
     {
-      if ((*table->comparator) (entry, cursor->next->data))
+      if (entry == cursor->next->data
+         || table->comparator (entry, cursor->next->data))
        {
          void *data = cursor->next->data;
 
@@ -779,10 +848,10 @@ hash_find_entry (Hash_table *table, const void *entry,
    the table may receive at least CANDIDATE different user entries, including
    those already in the table, before any other growth of the hash table size
    occurs.  If TUNING->IS_N_BUCKETS is true, then CANDIDATE specifies the
-   exact number of buckets desired.  */
+   exact number of buckets desired.  Return true iff the rehash succeeded.  */
 
 bool
-hash_rehash (Hash_table *table, unsigned candidate)
+hash_rehash (Hash_table *table, size_t candidate)
 {
   Hash_table *new_table;
   struct hash_entry *bucket;
@@ -793,6 +862,8 @@ hash_rehash (Hash_table *table, unsigned candidate)
                               table->comparator, table->data_freer);
   if (new_table == NULL)
     return false;
+  if (new_table->n_buckets == table->n_buckets)
+    return true;
 
   /* Merely reuse the extra old space into the new table.  */
 #if USE_OBSTACK
@@ -810,7 +881,9 @@ hash_rehash (Hash_table *table, unsigned candidate)
            = (new_table->bucket
               + new_table->hasher (data, new_table->n_buckets));
 
-         assert (new_bucket < new_table->bucket_limit);
+         if (! (new_bucket < new_table->bucket_limit))
+           abort ();
+
          next = cursor->next;
 
          if (new_bucket->data)
@@ -866,7 +939,9 @@ hash_rehash (Hash_table *table, unsigned candidate)
 
 /* If ENTRY matches an entry already in the hash table, return the pointer
    to the entry from the table.  Otherwise, insert ENTRY and return ENTRY.
-   Return NULL if the storage required for insertion cannot be allocated.  */
+   Return NULL if the storage required for insertion cannot be allocated.
+   This implementation does not support duplicate entries or insertion of
+   NULL.  */
 
 void *
 hash_insert (Hash_table *table, const void *entry)
@@ -874,12 +949,48 @@ hash_insert (Hash_table *table, const void *entry)
   void *data;
   struct hash_entry *bucket;
 
-  assert (entry);              /* cannot insert a NULL entry */
+  /* The caller cannot insert a NULL entry.  */
+  if (! entry)
+    abort ();
 
   /* If there's a matching entry already in the table, return that.  */
   if ((data = hash_find_entry (table, entry, &bucket, false)) != NULL)
     return data;
 
+  /* If the growth threshold of the buckets in use has been reached, increase
+     the table size and rehash.  There's no point in checking the number of
+     entries:  if the hashing function is ill-conditioned, rehashing is not
+     likely to improve it.  */
+
+  if (table->n_buckets_used
+      > table->tuning->growth_threshold * table->n_buckets)
+    {
+      /* Check more fully, before starting real work.  If tuning arguments
+        became invalid, the second check will rely on proper defaults.  */
+      check_tuning (table);
+      if (table->n_buckets_used
+         > table->tuning->growth_threshold * table->n_buckets)
+       {
+         const Hash_tuning *tuning = table->tuning;
+         float candidate =
+           (tuning->is_n_buckets
+            ? (table->n_buckets * tuning->growth_factor)
+            : (table->n_buckets * tuning->growth_factor
+               * tuning->growth_threshold));
+
+         if (SIZE_MAX <= candidate)
+           return NULL;
+
+         /* If the rehash fails, arrange to return NULL.  */
+         if (!hash_rehash (table, candidate))
+           return NULL;
+
+         /* Update the bucket we are interested in.  */
+         if (hash_find_entry (table, entry, &bucket, false) != NULL)
+           abort ();
+       }
+    }
+
   /* ENTRY is not matched, it should be inserted.  */
 
   if (bucket->data)
@@ -904,33 +1015,6 @@ hash_insert (Hash_table *table, const void *entry)
   table->n_entries++;
   table->n_buckets_used++;
 
-  /* If the growth threshold of the buckets in use has been reached, increase
-     the table size and rehash.  There's no point in checking the number of
-     entries:  if the hashing function is ill-conditioned, rehashing is not
-     likely to improve it.  */
-
-  if (table->n_buckets_used
-      > table->tuning->growth_threshold * table->n_buckets)
-    {
-      /* Check more fully, before starting real work.  If tuning arguments
-        became invalid, the second check will rely on proper defaults.  */
-      check_tuning (table);
-      if (table->n_buckets_used
-         > table->tuning->growth_threshold * table->n_buckets)
-       {
-         const Hash_tuning *tuning = table->tuning;
-         unsigned candidate
-           = (unsigned) (tuning->is_n_buckets
-                         ? (table->n_buckets * tuning->growth_factor)
-                         : (table->n_buckets * tuning->growth_factor
-                            * tuning->growth_threshold));
-
-         /* If the rehash fails, arrange to return NULL.  */
-         if (!hash_rehash (table, candidate))
-           entry = NULL;
-       }
-    }
-
   return (void *) entry;
 }
 
@@ -966,11 +1050,11 @@ hash_delete (Hash_table *table, const void *entry)
              < table->tuning->shrink_threshold * table->n_buckets)
            {
              const Hash_tuning *tuning = table->tuning;
-             unsigned candidate
-               = (unsigned) (tuning->is_n_buckets
-                             ? table->n_buckets * tuning->shrink_factor
-                             : (table->n_buckets * tuning->shrink_factor
-                                * tuning->growth_threshold));
+             size_t candidate =
+               (tuning->is_n_buckets
+                ? table->n_buckets * tuning->shrink_factor
+                : (table->n_buckets * tuning->shrink_factor
+                   * tuning->growth_threshold));
 
              hash_rehash (table, candidate);
            }
@@ -987,20 +1071,21 @@ hash_delete (Hash_table *table, const void *entry)
 void
 hash_print (const Hash_table *table)
 {
-  struct hash_entry *bucket;
+  struct hash_entry const *bucket;
 
   for (bucket = table->bucket; bucket < table->bucket_limit; bucket++)
     {
       struct hash_entry *cursor;
 
       if (bucket)
-       printf ("%d:\n", slot);
+       printf ("%lu:\n", (unsigned long int) (bucket - table->bucket));
 
       for (cursor = bucket; cursor; cursor = cursor->next)
        {
-         char *s = (char *) cursor->data;
+         char const *s = cursor->data;
          /* FIXME */
-         printf ("  %s\n", s);
+         if (s)
+           printf ("  %s\n", s);
        }
     }
 }