improve clarity in some functions

[platform/upstream/glib.git] / glib / ghash.c

diff --git a/glib/ghash.c b/glib/ghash.c
index 420d8c4..7858b19 100644 (file)
--- a/glib/ghash.c
+++ b/glib/ghash.c
@@ -60,15 +60,6 @@ struct _GHashTable
   GDestroyNotify   value_destroy_func;
 };
 
-#define G_HASH_TABLE_RESIZE(hash_table)                                \
-   G_STMT_START {                                              \
-     if ((hash_table->size >= 3 * hash_table->nnodes &&                \
-         hash_table->size > HASH_TABLE_MIN_SIZE) ||            \
-        (3 * hash_table->size <= hash_table->nnodes &&         \
-         hash_table->size < HASH_TABLE_MAX_SIZE))              \
-          g_hash_table_resize (hash_table);                    \
-   } G_STMT_END
-
 static void            g_hash_table_resize       (GHashTable     *hash_table);
 static GHashNode**     g_hash_table_lookup_node  (GHashTable     *hash_table,
                                                    gconstpointer   key,
@@ -83,6 +74,16 @@ static guint g_hash_table_foreach_remove_or_steal (GHashTable     *hash_table,
 static void         g_hash_table_remove_all_nodes (GHashTable *hash_table,
                                                    gboolean        notify);
 
+static inline void
+g_hash_table_maybe_resize (GHashTable *hash_table)
+{
+  gint nnodes = hash_table->nnodes;
+  gint size = hash_table->size;
+
+  if ((size >= 3 * nnodes && size > HASH_TABLE_MIN_SIZE) ||
+      (3 * size <= nnodes && size < HASH_TABLE_MAX_SIZE))
+    g_hash_table_resize (hash_table);
+}
 
 /**
  * g_hash_table_new:
@@ -216,16 +217,16 @@ g_hash_table_destroy (GHashTable *hash_table)
   g_hash_table_unref (hash_table);
 }
 
-static inline GHashNode**
+static inline GHashNode **
 g_hash_table_lookup_node (GHashTable    *hash_table,
                           gconstpointer  key,
                           guint         *hash_return)
 {
-  GHashNode **node;
+  GHashNode **node_ptr, *node;
   guint hash_value;
 
   hash_value = (* hash_table->hash_func) (key);
-  node = &hash_table->nodes[hash_value % hash_table->size];
+  node_ptr = &hash_table->nodes[hash_value % hash_table->size];
 
   if (hash_return)
     *hash_return = hash_value;
@@ -240,14 +241,28 @@ g_hash_table_lookup_node (GHashTable    *hash_table,
    *  key equality function in most cases.
    */
   if (hash_table->key_equal_func)
-    while (*node && (((*node)->key_hash != hash_value) ||
-                     !(*hash_table->key_equal_func) ((*node)->key, key)))
-      node = &(*node)->next;
+    {
+      while ((node = *node_ptr))
+        {
+          if (node->key_hash == hash_value &&
+              hash_table->key_equal_func (node->key, key))
+            break;
+
+          node_ptr = &(*node_ptr)->next;
+        }
+    }
   else
-    while (*node && (*node)->key != key)
-      node = &(*node)->next;
+    {
+      while ((node = *node_ptr))
+        {
+          if (node->key == key)
+            break;
+
+          node_ptr = &(*node_ptr)->next;
+        }
+    }
 
-  return node;
+  return node_ptr;
 }
 
 /**
@@ -301,16 +316,16 @@ g_hash_table_lookup_extended (GHashTable    *hash_table,
 
   node = *g_hash_table_lookup_node (hash_table, lookup_key, NULL);
 
-  if (node)
-    {
-      if (orig_key)
-        *orig_key = node->key;
-      if (value)
-        *value = node->value;
-      return TRUE;
-    }
-  else
+  if (node == NULL)
     return FALSE;
+
+  if (orig_key)
+    *orig_key = node->key;
+
+  if (value)
+    *value = node->value;
+
+  return TRUE;
 }
 
 static void
@@ -319,21 +334,21 @@ g_hash_table_insert_internal (GHashTable *hash_table,
                               gpointer    value,
                               gboolean    keep_new_key)
 {
-  GHashNode **node;
+  GHashNode **node_ptr, *node;
   guint key_hash;
 
   g_return_if_fail (hash_table != NULL);
   g_return_if_fail (hash_table->ref_count > 0);
 
-  node = g_hash_table_lookup_node (hash_table, key, &key_hash);
+  node_ptr = g_hash_table_lookup_node (hash_table, key, &key_hash);
 
-  if (*node)
+  if ((node = *node_ptr))
     {
       if (keep_new_key)
         {
           if (hash_table->key_destroy_func)
-            hash_table->key_destroy_func ((*node)->key);
-          (*node)->key = key;
+            hash_table->key_destroy_func (node->key);
+          node->key = key;
         }
       else
         {
@@ -342,15 +357,22 @@ g_hash_table_insert_internal (GHashTable *hash_table,
         }
 
       if (hash_table->value_destroy_func)
-        hash_table->value_destroy_func ((*node)->value);
+        hash_table->value_destroy_func (node->value);
 
-      (*node)->value = value;
+      node->value = value;
     }
   else
     {
-      *node = g_hash_node_new (key, value, key_hash);
+      node = g_slice_new (GHashNode);
+
+      node->key = key;
+      node->value = value;
+      node->key_hash = key_hash;
+      node->next = NULL;
+
+      *node_ptr = node;
       hash_table->nnodes++;
-      G_HASH_TABLE_RESIZE (hash_table);
+      g_hash_table_maybe_resize (hash_table);
     }
 }
 
@@ -448,7 +470,7 @@ g_hash_table_remove_internal (GHashTable    *hash_table,
     return FALSE;
 
   g_hash_table_remove_node (hash_table, &node_ptr, notify);
-  G_HASH_TABLE_RESIZE (hash_table);
+  g_hash_table_maybe_resize (hash_table);
 
   return TRUE;
 }
@@ -493,7 +515,7 @@ g_hash_table_remove_all (GHashTable *hash_table)
   g_return_if_fail (hash_table != NULL);
 
   g_hash_table_remove_all_nodes (hash_table, TRUE);
-  G_HASH_TABLE_RESIZE (hash_table);
+  g_hash_table_maybe_resize (hash_table);
 }
 
 /**
@@ -528,7 +550,7 @@ g_hash_table_steal_all (GHashTable *hash_table)
   g_return_if_fail (hash_table != NULL);
 
   g_hash_table_remove_all_nodes (hash_table, FALSE);
-  G_HASH_TABLE_RESIZE (hash_table);
+  g_hash_table_maybe_resize (hash_table);
 }
 
 /**
@@ -599,7 +621,7 @@ g_hash_table_foreach_remove_or_steal (GHashTable *hash_table,
       else
         node_ptr = &node->next;
 
-  G_HASH_TABLE_RESIZE (hash_table);
+  g_hash_table_maybe_resize (hash_table);
 
   return deleted;
 }
@@ -789,20 +811,5 @@ g_hash_table_resize (GHashTable *hash_table)
   hash_table->size = new_size;
 }
 
-static GHashNode*
-g_hash_node_new (gpointer key,
-                gpointer value,
-                guint key_hash)
-{
-  GHashNode *hash_node = g_slice_new (GHashNode);
-
-  hash_node->key = key;
-  hash_node->value = value;
-  hash_node->key_hash = key_hash;
-  hash_node->next = NULL;
-
-  return hash_node;
-}
-
 #define __G_HASH_C__
 #include "galiasdef.c"