Changeset 4f34b6a in mainline

Timestamp:

2006-03-14T22:55:01Z (19 years ago)

Author:

Josef Cejka <malyzelenyhnus@…>

Branches:

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

Children:

936351c1

Parents:

ee7736e

Message:

Hash_table conversion done.
Simple assert function converted from kernel.

Files:

• libadt/Makefile (modified) (1 diff)
• libadt/generic/hash_table.c (modified) (6 diffs)
• libadt/include/hash_table.h (modified) (3 diffs)
• libc/include/assert.h (added)

libadt/Makefile

@@ -42 +42 @@
 
 GENERIC_SOURCES = \
-        generic/list.c
+        generic/list.c \
+        generic/hash_table.c
 
 GENERIC_OBJECTS := $(addsuffix .o,$(basename $(GENERIC_SOURCES)))

libadt/generic/hash_table.c

@@ -36 +36 @@
 #include <malloc.h>
 #include <assert.h>
+#include <stdio.h>
+#include <string.h>
 
 /** Create chained hash table.
@@ -43 +45 @@
  * @param max_keys Maximal number of keys needed to identify an item.
  * @param op Hash table operations structure.
+ * @return true on success
  */
-void hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys, hash_table_operations_t *op)
+int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys, hash_table_operations_t *op)
 {
-        int i;
+        hash_count_t i;
 
-        ASSERT(h);
-        ASSERT(op && op->hash && op->compare);
-        ASSERT(max_keys > 0);
+        assert(h);
+        assert(op && op->hash && op->compare);
+        assert(max_keys > 0);
         
-        h->entry = malloc(m * sizeof(link_t *), 0);
+        h->entry = malloc(m * sizeof(link_t *));
         if (!h->entry) {
-                panic("cannot allocate memory for hash table\n");
+                printf("cannot allocate memory for hash table\n");
+                return false;
         }
-        memsetb((__address) h->entry, m * sizeof(link_t *), 0);
+        memset((void *) h->entry, 0,  m * sizeof(link_t *));
         
         for (i = 0; i < m; i++)
@@ -64 +68 @@
         h->max_keys = max_keys;
         h->op = op;
+        return true;
 }
 
@@ -72 +77 @@
  * @param item Item to be inserted into the hash table.
  */
-void hash_table_insert(hash_table_t *h, __native key[], link_t *item)
+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);
+        assert(item);
+        assert(h && h->op && h->op->hash && h->op->compare);
 
         chain = h->op->hash(key);
-        ASSERT(chain < h->entries);
+        assert(chain < h->entries);
         
         list_append(item, &h->entry[chain]);
@@ -92 +97 @@
  * @return Matching item on success, NULL if there is no such item.
  */
-link_t *hash_table_find(hash_table_t *h, __native key[])
+link_t *hash_table_find(hash_table_t *h, unsigned long key[])
 {
         link_t *cur;
         hash_index_t chain;
 
-        ASSERT(h && h->op && h->op->hash && h->op->compare);
+        assert(h && h->op && h->op->hash && h->op->compare);
 
         chain = h->op->hash(key);
-        ASSERT(chain < h->entries);
+        assert(chain < h->entries);
         
         /*
@@ -126 +131 @@
  * @param keys Number of keys in the 'key' array.
  */
-void hash_table_remove(hash_table_t *h, __native key[], hash_count_t keys)
+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);
+        assert(h && h->op && h->op->hash && h->op->compare && h->op->remove_callback);
+        assert(keys <= h->max_keys);
         
         if (keys == h->max_keys) {

libadt/include/hash_table.h

@@ -54 +54 @@
          * @return Index into hash table.
          */
-        hash_index_t (* hash)(int key[]);
+        hash_index_t (* hash)(unsigned long key[]);
         
         /** Hash table item comparison function.
@@ -62 +62 @@
          * @return true if the keys match, false otherwise.
          */
-        int (*compare)(int key[], hash_count_t keys, link_t *item);
+        int (*compare)(unsigned long key[], hash_count_t keys, link_t *item);
 
         /** Hash table item removal callback.
@@ -73 +73 @@
 #define hash_table_get_instance(item, type, member)     list_get_instance((item), type, member)
 
-extern void hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys, hash_table_operations_t *op);
-extern void hash_table_insert(hash_table_t *h, int key[], link_t *item);
-extern link_t *hash_table_find(hash_table_t *h, int key[]);
-extern void hash_table_remove(hash_table_t *h, int key[], hash_count_t keys);
+extern int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys, hash_table_operations_t *op);
+extern void hash_table_insert(hash_table_t *h, unsigned long key[], link_t *item);
+extern link_t *hash_table_find(hash_table_t *h, unsigned long key[]);
+extern void hash_table_remove(hash_table_t *h, unsigned long key[], hash_count_t keys);
 
 #endif