Improve Hashtable buffer grow and shrink conditions

* Move assertions about hash table sizes to Hashtable_isConsistent() so
  they can be checked in all Hashtable methods.
* Slightly improve conditionals of growing and shrinking the "buckets"
  buffer. Specifically the calculations are now less prone to
  arithmetic overflow and can work with Hashtable.size value up to
  (SIZE_MAX / 7). (Original limit was (SIZE_MAX / 10)).
* If `Hashtable.size > SIZE_MAX / sizeof(HashtableItem)`, allow the
  compiler to optimize out one conditional of checking overflow.
  (The buffer allocation would still fail at xCalloc() in that case.)
* Hashtable_setSize() is now a private method.

Signed-off-by: Kang-Che Sung <explorer09@gmail.com>

Author: Explorer09

Hashtable.c

@@ -74,6 +74,11 @@ static bool Hashtable_isConsistent(const Hashtable* this) {
    bool res = items == this->items;
    if (!res)
       Hashtable_dump(this);
+
+   assert(this->size > 0);
+   assert(this->size <= SIZE_MAX / sizeof(HashtableItem));
+   assert(this->size >= this->items);
+
    return res;
 }
 
@@ -187,21 +192,18 @@ static void insert(Hashtable* this, ht_key_t key, void* value) {
    }
 }
 
-void Hashtable_setSize(Hashtable* this, size_t size) {
-
+static void Hashtable_setSize(Hashtable* this, size_t size) {
    assert(Hashtable_isConsistent(this));
+   assert(size >= this->items);
 
-   if (size <= this->items)
-      return;
-
-   size_t newSize = nextPrime(size);
-   if (newSize == this->size)
+   size = nextPrime(size);
+   if (size == this->size)
       return;
 
    HashtableItem* oldBuckets = this->buckets;
    size_t oldSize = this->size;
 
-   this->size = newSize;
+   this->size = size;
    this->buckets = (HashtableItem*) xCalloc(this->size, sizeof(HashtableItem));
    this->items = 0;
 
@@ -219,24 +221,20 @@ void Hashtable_setSize(Hashtable* this, size_t size) {
 }
 
 void Hashtable_put(Hashtable* this, ht_key_t key, void* value) {
-
    assert(Hashtable_isConsistent(this));
-   assert(this->size > 0);
    assert(value);
 
    /* grow on load-factor > 0.7 */
-   if (10 * this->items > 7 * this->size) {
-      if (SIZE_MAX / 2 < this->size)
-         CRT_fatalError("Hashtable: size overflow");
+   if (sizeof(HashtableItem) < 7 && SIZE_MAX / 7 < this->size)
+      CRT_fatalError("Hashtable: size overflow");
 
-      Hashtable_setSize(this, 2 * this->size);
-   }
+   if (this->items >= this->size * 7 / 10)
+      Hashtable_setSize(this, this->size + 1);
 
    insert(this, key, value);
 
    assert(Hashtable_isConsistent(this));
    assert(Hashtable_get(this, key) != NULL);
-   assert(this->size > this->items);
 }
 
 void* Hashtable_remove(Hashtable* this, ht_key_t key) {
@@ -288,8 +286,12 @@ void* Hashtable_remove(Hashtable* this, ht_key_t key) {
    assert(Hashtable_get(this, key) == NULL);
 
    /* shrink on load-factor < 0.125 */
-   if (8 * this->items < this->size)
-      Hashtable_setSize(this, this->size / 3); /* account for nextPrime rounding up */
+   if (sizeof(HashtableItem) < 3 && SIZE_MAX / 3 < this->size)
+      CRT_fatalError("Hashtable: size overflow");
+
+   if (this->items < this->size / 8) {
+      Hashtable_setSize(this, this->size * 3 / 8); /* account for nextPrime rounding up */
+   }
 
    return res;
 }

Hashtable.h

@@ -29,8 +29,6 @@ void Hashtable_delete(Hashtable* this);
 
 void Hashtable_clear(Hashtable* this);
 
-void Hashtable_setSize(Hashtable* this, size_t size);
-
 void Hashtable_put(Hashtable* this, ht_key_t key, void* value);
 
 void* Hashtable_remove(Hashtable* this, ht_key_t key);