tools/toollib/hash.c

   1 /*
   2     Copyright © 1995-2001, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <string.h>
   7 #include <stdlib.h>
   8 #include <ctype.h>
   9 #include <toollib/hash.h>
  10
  11 typedef struct _HashNode HashNode;
  12
  13 struct _HashNode
  14 {
  15     HashNode   * Next;
  16     const char * key;
  17     const void * data;
  18 };
  19
  20 struct _Hash
  21 {
  22     HashNode * Nodes[256];
  23 };
  24
  25 static int calchash (const char * key)
  26 {
  27     int code = 0;
  28
  29     while (*key)
  30         code = (code + *key++) & 0xFF;
  31
  32     return code;
  33 }
  34
  35 static int calchashNC (const char * key)
  36 {
  37     int code = 0;
  38
  39     while (*key)
  40     {
  41         code = (code + toupper(*key)) & 0xFF;
  42         key ++;
  43     }
  44
  45     return code;
  46 }
  47
  48 Hash * Hash_New (void)
  49 {
  50     Hash * hash = xmalloc (sizeof (Hash));
  51     memset (hash, 0, sizeof(Hash));
  52     return hash;
  53 }
  54
  55 void Hash_Store (Hash * hash, const char * key, const void * data)
  56 {
  57     int code = calchash (key);
  58     HashNode * node, * newNode;
  59
  60     for (node=hash->Nodes[code]; node; node=node->Next)
  61     {
  62         if (node->key[0] == *key && !strcmp (node->key, key))
  63         {
  64             node->data = data;
  65             return;
  66         }
  67     }
  68
  69     newNode = xmalloc (sizeof (HashNode));
  70
  71     newNode->Next = hash->Nodes[code];
  72     newNode->key  = key;
  73     newNode->data = data;
  74
  75     hash->Nodes[code] = newNode;
  76 }
  77
  78 void Hash_StoreNC (Hash * hash, const char * key, const void * data)
  79 {
  80     int code = calchashNC (key);
  81     HashNode * node, * newNode;
  82
  83     for (node=hash->Nodes[code]; node; node=node->Next)
  84     {
  85         if (node->key[0] == *key && !strcmp (node->key, key))
  86         {
  87             node->data = data;
  88             return;
  89         }
  90     }
  91
  92     newNode = xmalloc (sizeof (HashNode));
  93
  94     newNode->Next = hash->Nodes[code];
  95     newNode->key  = key;
  96     newNode->data = data;
  97
  98     hash->Nodes[code] = newNode;
  99 }
 100
 101 void * Hash_Find (Hash * hash, const char * key)
 102 {
 103     int code = calchash (key);
 104     HashNode * node;
 105
 106     for (node=hash->Nodes[code]; node; node=node->Next)
 107     {
 108         if (node->key[0] == *key && !strcmp (node->key, key))
 109         {
 110             return ((void *)node->data);
 111         }
 112     }
 113
 114     return NULL;
 115 }
 116
 117 void * Hash_FindNC (Hash * hash, const char * key)
 118 {
 119     int code = calchashNC (key);
 120     HashNode * node;
 121
 122     for (node=hash->Nodes[code]; node; node=node->Next)
 123     {
 124         if (node->key[0] == *key && !strcmp (node->key, key))
 125         {
 126             return ((void *)node->data);
 127         }
 128     }
 129
 130     return NULL;
 131 }
 132
 133 void Hash_Traverse (Hash * hash, CB tp, CBD userdata)
 134 {
 135     int t;
 136     HashNode * node;
 137
 138     for (t=0; t<256; t++)
 139     {
 140         for (node=hash->Nodes[t]; node; node=node->Next)
 141         {
 142             CallCB (tp, (void *)node->key, node->data, userdata);
 143         }
 144     }
 145
 146     xfree (hash);
 147 }
 148
 149 void Hash_Delete (Hash * hash, CB dnp, CBD userdata)
 150 {
 151     int t;
 152     HashNode * node, * next;
 153
 154     for (t=0; t<256; t++)
 155     {
 156         for (next=hash->Nodes[t]; (node=next); )
 157         {
 158             next=next->Next;
 159
 160             if (dnp)
 161                 CallCB (dnp, (void *)node->key, node->data, userdata);
 162
 163             xfree (node);
 164         }
 165     }
 166
 167     xfree (hash);
 168 }