Changeset e1da7ec in mainline

Timestamp:

2010-04-17T01:24:17Z (15 years ago)

Author:

Martin Decky <martin@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

ab108be4

Parents:

3292623

Message:

coding style changes (no change in functionality)

File:

• uspace/lib/c/generic/adt/hash_table.c (modified) (11 diffs)

uspace/lib/c/generic/adt/hash_table.c

@@ -42 +42 @@
 #include <malloc.h>
 #include <assert.h>
-#include <stdio.h>
 #include <str.h>
 
 /** Create chained hash table.
  *
- * @param h             Hash table structure. Will be initialized by this call.
- * @param m             Number of hash table buckets.
- * @param max_keys      Maximal number of keys needed to identify an item.
- * @param op            Hash table operations structure.
- * @return              True on success
+ * @param h        Hash table structure. Will be initialized by this call.
+ * @param m        Number of hash table buckets.
+ * @param max_keys Maximal number of keys needed to identify an item.
+ * @param op       Hash table operations structure.
+ *
+ * @return True on success
+ *
  */
 int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
     hash_table_operations_t *op)
 {
-        hash_count_t i;
-
         assert(h);
         assert(op && op->hash && op->compare);
@@ -63 +62 @@
         
         h->entry = malloc(m * sizeof(link_t));
-        if (!h->entry) {
-                printf("cannot allocate memory for hash table\n");
+        if (!h->entry)
                 return false;
-        }
+        
         memset((void *) h->entry, 0,  m * sizeof(link_t));
         
+        hash_count_t i;
         for (i = 0; i < m; i++)
                 list_initialize(&h->entry[i]);
@@ -75 +74 @@
         h->max_keys = max_keys;
         h->op = op;
+        
         return true;
 }
@@ -80 +80 @@
 /** Destroy a hash table instance.
  *
- * @param h             Hash table to be destroyed.
+ * @param h Hash table to be destroyed.
+ *
  */
 void hash_table_destroy(hash_table_t *h)
@@ -86 +87 @@
         assert(h);
         assert(h->entry);
+        
         free(h->entry);
 }
@@ -91 +93 @@
 /** Insert item into a hash table.
  *
- * @param h             Hash table.
- * @param key           Array of all keys necessary to compute hash index.
- * @param item          Item to be inserted into the hash table.
+ * @param h    Hash table.
+ * @param key  Array of all keys necessary to compute hash index.
+ * @param item Item to be inserted into the hash table.
  */
 void hash_table_insert(hash_table_t *h, unsigned long key[], link_t *item)
 {
-        hash_index_t chain;
-
         assert(item);
         assert(h && h->op && h->op->hash && h->op->compare);
-
-        chain = h->op->hash(key);
+        
+        hash_index_t chain = h->op->hash(key);
         assert(chain < h->entries);
         
@@ -110 +110 @@
 /** Search hash table for an item matching keys.
  *
- * @param h             Hash table.
- * @param key           Array of all keys needed to compute hash index.
- *
- * @return              Matching item on success, NULL if there is no such item.
+ * @param h   Hash table.
+ * @param key Array of all keys needed to compute hash index.
+ *
+ * @return Matching item on success, NULL if there is no such item.
+ *
  */
 link_t *hash_table_find(hash_table_t *h, unsigned long key[])
 {
+        assert(h && h->op && h->op->hash && h->op->compare);
+        
+        hash_index_t chain = h->op->hash(key);
+        assert(chain < h->entries);
+        
         link_t *cur;
-        hash_index_t chain;
-
-        assert(h && h->op && h->op->hash && h->op->compare);
-
-        chain = h->op->hash(key);
-        assert(chain < h->entries);
-        
         for (cur = h->entry[chain].next; cur != &h->entry[chain];
             cur = cur->next) {
@@ -142 +141 @@
  * For each removed item, h->remove_callback() is called.
  *
- * @param h             Hash table.
- * @param key           Array of keys that will be compared against items of
- *                      the hash table.
- * @param keys          Number of keys in the 'key' array.
+ * @param h    Hash table.
+ * @param key  Array of keys that will be compared against items of
+ *             the hash table.
+ * @param keys Number of keys in the 'key' array.
+ *
  */
 void hash_table_remove(hash_table_t *h, unsigned long key[], hash_count_t keys)
 {
-        hash_index_t chain;
-        link_t *cur;
-
         assert(h && h->op && h->op->hash && h->op->compare &&
             h->op->remove_callback);
         assert(keys <= h->max_keys);
         
+        link_t *cur;
+        
         if (keys == h->max_keys) {
-
                 /*
                  * All keys are known, hash_table_find() can be used to find the
                  * entry.
                  */
-        
+                
                 cur = hash_table_find(h, key);
                 if (cur) {
@@ -168 +166 @@
                         h->op->remove_callback(cur);
                 }
+                
                 return;
         }
@@ -175 +174 @@
          * Any partially matching entries are to be removed.
          */
+        hash_index_t chain;
         for (chain = 0; chain < h->entries; chain++) {
                 for (cur = h->entry[chain].next; cur != &h->entry[chain];
@@ -195 +195 @@
 /** Apply fucntion to all items in hash table.
  *
- * @param h             Hash table.
- * @param f             Function to be applied.
- * @param arg           Argument to be passed to the function.
- */
-void
-hash_table_apply(hash_table_t *h, void (*f)(link_t *, void *), void *arg)
+ * @param h   Hash table.
+ * @param f   Function to be applied.
+ * @param arg Argument to be passed to the function.
+ *
+ */
+void hash_table_apply(hash_table_t *h, void (*f)(link_t *, void *), void *arg)
 {
         hash_index_t bucket;
         link_t *cur;
-
+        
         for (bucket = 0; bucket < h->entries; bucket++) {
                 for (cur = h->entry[bucket].next; cur != &h->entry[bucket];