#ifndef lint
static char *rcsid = "$Id: strhash.c,v 1.1 2003/06/04 00:26:13 marka Exp $";
#endif
#include <config.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <idn/assert.h>
#include <idn/logmacro.h>
#include <idn/result.h>
#include <idn/strhash.h>
#define INITIAL_HASH_SIZE 67
#define FACTOR 7
#define THRESHOLD 5
#define HASH_MULT 31
typedef struct strhash_entry {
struct strhash_entry *next;
unsigned long hash_value;
char *key;
void *value;
} strhash_entry_t;
struct idn__strhash {
int nbins;
int nelements;
strhash_entry_t **bins;
};
static unsigned long hash_value(const char *key);
static strhash_entry_t *find_entry(strhash_entry_t *entry, const char *key,
unsigned long hash);
static strhash_entry_t *new_entry(const char *key, void *value);
static idn_result_t expand_bins(idn__strhash_t hash, int new_size);
idn_result_t
idn__strhash_create(idn__strhash_t *hashp) {
idn__strhash_t hash;
idn_result_t r;
TRACE(("idn__strhash_create()\n"));
assert(hashp != NULL);
*hashp = NULL;
if ((hash = malloc(sizeof(struct idn__strhash))) == NULL) {
WARNING(("idn__strhash_create: malloc failed (hash)\n"));
return (idn_nomemory);
}
hash->nbins = 0;
hash->nelements = 0;
hash->bins = NULL;
if ((r = expand_bins(hash, INITIAL_HASH_SIZE)) != idn_success) {
WARNING(("idn__strhash_create: malloc failed (bins)\n"));
free(hash);
return (r);
}
*hashp = hash;
return (idn_success);
}
void
idn__strhash_destroy(idn__strhash_t hash, idn__strhash_freeproc_t proc) {
int i;
assert(hash != NULL && hash->bins != NULL);
for (i = 0; i < hash->nbins; i++) {
strhash_entry_t *bin = hash->bins[i];
strhash_entry_t *next;
while (bin != NULL) {
next = bin->next;
if (proc != NULL)
(*proc)(bin->value);
free(bin);
bin = next;
}
}
free(hash->bins);
free(hash);
}
idn_result_t
idn__strhash_put(idn__strhash_t hash, const char *key, void *value) {
unsigned long h, h_index;
strhash_entry_t *entry;
assert(hash != NULL && key != NULL);
h = hash_value(key);
h_index = h % hash->nbins;
if ((entry = find_entry(hash->bins[h_index], key, h)) != NULL) {
entry->value = value;
} else {
if ((entry = new_entry(key, value)) == NULL) {
return (idn_nomemory);
}
entry->next = hash->bins[h_index];
hash->bins[h_index] = entry;
hash->nelements++;
if (hash->nelements > hash->nbins * THRESHOLD) {
idn_result_t r;
r = expand_bins(hash, hash->nbins * FACTOR);
if (r != idn_success) {
TRACE(("idn__strhash_put: hash table "
"expansion failed\n"));
}
}
}
return (idn_success);
}
idn_result_t
idn__strhash_get(idn__strhash_t hash, const char *key, void **valuep) {
unsigned long h;
strhash_entry_t *entry;
assert(hash != NULL && key != NULL && valuep != NULL);
h = hash_value(key);
entry = find_entry(hash->bins[h % hash->nbins], key, h);
if (entry == NULL)
return (idn_noentry);
*valuep = entry->value;
return (idn_success);
}
int
idn__strhash_exists(idn__strhash_t hash, const char *key) {
unsigned long h;
assert(hash != NULL && key != NULL);
h = hash_value(key);
return (find_entry(hash->bins[h % hash->nbins], key, h) != NULL);
}
static unsigned long
hash_value(const char *key) {
unsigned long h = 0;
unsigned char *p = (unsigned char *)key;
int c;
while ((c = *p++) != '\0') {
h = h * HASH_MULT + c;
}
return (h);
}
static strhash_entry_t *
find_entry(strhash_entry_t *entry, const char *key, unsigned long hash) {
assert(key != NULL);
while (entry != NULL) {
if (entry->hash_value == hash && strcmp(key, entry->key) == 0)
return (entry);
entry = entry->next;
}
return (NULL);
}
static strhash_entry_t *
new_entry(const char *key, void *value) {
strhash_entry_t *entry;
int len;
assert(key != NULL);
len = strlen(key) + 1;
if ((entry = malloc(sizeof(strhash_entry_t) + len)) == NULL) {
return (NULL);
}
entry->next = NULL;
entry->hash_value = hash_value(key);
entry->key = (char *)(entry + 1);
(void)strcpy(entry->key, key);
entry->value = value;
return (entry);
}
static idn_result_t
expand_bins(idn__strhash_t hash, int new_size) {
strhash_entry_t **old_bins, **new_bins;
int old_size;
int old_index, new_index;
new_bins = malloc(sizeof(strhash_entry_t *) * new_size);
if (new_bins == NULL)
return (idn_nomemory);
memset(new_bins, 0, sizeof(strhash_entry_t *) * new_size);
old_bins = hash->bins;
old_size = hash->nbins;
for (old_index = 0; old_index < old_size; old_index++) {
strhash_entry_t *entries = old_bins[old_index];
while (entries != NULL) {
strhash_entry_t *e = entries;
entries = entries->next;
new_index = e->hash_value % new_size;
e->next = new_bins[new_index];
new_bins[new_index] = e;
}
}
hash->nbins = new_size;
hash->bins = new_bins;
if (old_bins != NULL)
free(old_bins);
return (idn_success);
}