C++ fixes.

[bertos.git] / mware / hashtable.c

diff --git a/mware/hashtable.c b/mware/hashtable.c
index 68676ee9eacd4bb0468e36adee3530023587e1ad..bfc8bc0ec6a0b1510be0fb5aba68bbe8a583ee34 100755 (executable)
--- a/mware/hashtable.c
+++ b/mware/hashtable.c
@@ -1,8 +1,8 @@
 /*!
  * \file
  * <!--
- * Copyright (C) 2004 Giovanni Bajo
- * Copyright (C) 2004 Develer S.r.l. (http://www.develer.com/)
+ * Copyright 2004 Develer S.r.l. (http://www.develer.com/)
+ * Copyright 2004 Giovanni Bajo
  * All Rights Reserved.
  * -->
  *
@@ -61,16 +61,14 @@
 
 /*#*
  *#* $Log$
- *#* Revision 1.2  2004/08/25 14:12:09  rasky
- *#* Aggiornato il comment block dei log RCS
+ *#* Revision 1.5  2005/04/11 19:10:28  bernie
+ *#* Include top-level headers from cfg/ subdir.
  *#*
- *#* Revision 1.1  2004/07/14 14:08:16  rasky
- *#* Implementazione di una tabella hash
+ *#* Revision 1.4  2004/12/08 09:42:30  bernie
+ *#* Suppress warning.
  *#*
- *#* Revision 1.13  2004/07/12 16:33:36  rasky
- *#* Aggiunta nuova ASSERT2, con stringa di descrizione del problema (disabilitabile tramite una macro di configurazione)
- *#* Modificato il codice del firmware per utilizzare ASSERT2
- *#* Modificato il progetto in modo da disabilitare le stringhe di errore nel target xROM-xRAM
+ *#* Revision 1.3  2004/10/03 20:43:22  bernie
+ *#* Import changes from sc/firmware.
  *#*
  *#* Revision 1.12  2004/06/14 15:15:24  rasky
  *#* Cambiato key_data in un union invece di castare
@@ -98,9 +96,11 @@
  *#* Sistemata la documentazione, rimossa keycmp in favore della memcmp
  *#*
  *#*/
+
 #include "hashtable.h"
-#include <drv/kdebug.h>
-#include <compiler.h>
+#include <cfg/debug.h>
+#include <cfg/compiler.h>
+
 #include <string.h>
 
 
@@ -140,6 +140,7 @@ INLINE void node_get_key(struct HashTable* ht, HashNodePtr node, const void** ke
                *key = ht->key_data.hook(*node, key_length);
 }
 
+
 INLINE bool node_key_match(struct HashTable* ht, HashNodePtr node, const void* key, uint8_t key_length)
 {
        const void* key2;
@@ -150,6 +151,7 @@ INLINE bool node_key_match(struct HashTable* ht, HashNodePtr node, const void* k
        return (key_length == key2_length && memcmp(key, key2, key_length) == 0);
 }
 
+
 static uint16_t calc_hash(const void* _key, uint8_t key_length)
 {
        const char* key = (const char*)_key;
@@ -163,6 +165,7 @@ static uint16_t calc_hash(const void* _key, uint8_t key_length)
        return hash ^ (hash >> 6) ^ (hash >> 13);
 }
 
+
 static HashNodePtr perform_lookup(struct HashTable* ht,
                                   const void* key, uint8_t key_length)
 {
@@ -184,9 +187,9 @@ static HashNodePtr perform_lookup(struct HashTable* ht,
        // Increment while going through the hash table in case of collision.
        //  This implements the double-hash technique: we use the higher part
        //  of the hash as a step increment instead of just going to the next
-       //  element, to minimize the collisions. 
+       //  element, to minimize the collisions.
        // Notice that the number must be odd to be sure that the whole table
-       //  is traversed. Actually MCD(table_size, step) must be 1, but 
+       //  is traversed. Actually MCD(table_size, step) must be 1, but
        //  table_size is always a power of 2, so we just ensure that step is
        //  never a multiple of 2.
        step = (ROTATE_RIGHT_16(hash, ht->max_elts_log2) & mask) | 1;
@@ -212,11 +215,13 @@ static HashNodePtr perform_lookup(struct HashTable* ht,
        return NULL;
 }
 
+
 void ht_init(struct HashTable* ht)
 {
        memset(ht->mem, 0, sizeof(ht->mem[0]) * (1 << ht->max_elts_log2));
 }
 
+
 static bool insert(struct HashTable* ht, const void* key, uint8_t key_length, const void* data)
 {
        HashNodePtr node;
@@ -225,7 +230,7 @@ static bool insert(struct HashTable* ht, const void* key, uint8_t key_length, co
                return false;
 
        if (HT_HAS_INTERNAL_KEY(ht))
-               key_length = MIN(key_length, INTERNAL_KEY_MAX_LENGTH);
+               key_length = MIN(key_length, (uint8_t)INTERNAL_KEY_MAX_LENGTH);
 
        node = perform_lookup(ht, key, key_length);
        if (!node)
@@ -242,6 +247,7 @@ static bool insert(struct HashTable* ht, const void* key, uint8_t key_length, co
        return true;
 }
 
+
 bool ht_insert_with_key(struct HashTable* ht, const void* key, uint8_t key_length, const void* data)
 {
 #ifdef _DEBUG
@@ -260,6 +266,7 @@ bool ht_insert_with_key(struct HashTable* ht, const void* key, uint8_t key_lengt
        return insert(ht, key, key_length, data);
 }
 
+
 bool ht_insert(struct HashTable* ht, const void* data)
 {
        const void* key;
@@ -279,12 +286,13 @@ bool ht_insert(struct HashTable* ht, const void* data)
        return insert(ht, key, key_length, data);
 }
 
+
 const void* ht_find(struct HashTable* ht, const void* key, uint8_t key_length)
 {
        HashNodePtr node;
-       
+
        if (HT_HAS_INTERNAL_KEY(ht))
-               key_length = MIN(key_length, INTERNAL_KEY_MAX_LENGTH);
+               key_length = MIN(key_length, (uint8_t)INTERNAL_KEY_MAX_LENGTH);
 
        node = perform_lookup(ht, key, key_length);
 
@@ -326,8 +334,8 @@ static bool single_test(void)
        {
                int k;
                int klen;
-               
-               do 
+
+               do
                {
                        klen = (rand() % 8) + 1;
                        for (k=0;k<klen;k++)
@@ -342,7 +350,7 @@ static bool single_test(void)
        for (i=0;i<NUM_ELEMENTS;i++)
        {
                char *found1, *found2;
-               
+
                found1 = (char*)ht_find_str(&test1, data[i]);
                if (strcmp(found1, data[i]) != 0)
                {