new files to manage user-definable keybindings
This commit is contained in:
Frederic Culot
392
src/htable.h
Normal file
392
src/htable.h
Normal file
@@ -0,0 +1,392 @@
|
||||
/* $Id: htable.h,v 1.1 2008/11/08 19:05:15 culot Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 2008 Frederic Culot <frederic@culot.org>
|
||||
* All rights reserved.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
*
|
||||
* - Redistributions of source code must retain the above
|
||||
* copyright notice, this list of conditions and the
|
||||
* following disclaimer.
|
||||
*
|
||||
* - Redistributions in binary form must reproduce the above
|
||||
* copyright notice, this list of conditions and the
|
||||
* following disclaimer in the documentation and/or other
|
||||
* materials provided with the distribution.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||||
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
#ifndef HTABLE_H
|
||||
#define HTABLE_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
|
||||
/*
|
||||
* This file defines data structures for hash tables.
|
||||
*
|
||||
* Hash tables are ideal for applications with datasets needing lots of adding,
|
||||
* searching or removal, as those are normally constant-time operations.
|
||||
* The primary operation it supports efficiently is a lookup: given a key (e.g.
|
||||
* a person's name), find the corresponding value (e.g. that person's telephone
|
||||
* number). It works by transforming the key using a hash function into a hash,
|
||||
* a number that is used as an index in an array to locate the desired location
|
||||
* ("bucket") where the values should be.
|
||||
*
|
||||
* Hash tables support the efficient insertion of new entries, in expected O(1)
|
||||
* time. The time spent in searching depends on the hash function and the load
|
||||
* of the hash table; both insertion and search approach O(1) time with well
|
||||
* chosen values and hashes.
|
||||
*
|
||||
* The collision resolution technique used here is direct chaining, implemented
|
||||
* using singly linked lists (the worst-case time is O(n)).
|
||||
*
|
||||
* This was chosen because performance degradation is linear as the table
|
||||
* fills, so there is almost no need to resize table
|
||||
* (for example, a chaining hash table containing twice its recommended
|
||||
* capacity of data would only be about twice as slow on average as the same
|
||||
* table at its recommended capacity).
|
||||
*/
|
||||
|
||||
#define HTABLE_HEAD(name, size, type) \
|
||||
struct name { \
|
||||
uint32_t noitems; /* Number of items stored in hash table. */ \
|
||||
uint32_t nosingle; /* Number of items alone in their bucket. */ \
|
||||
uint32_t nofreebkts; /* Number of free buckets. */ \
|
||||
struct type *bkts[size]; /* Pointers to user-defined data structures. */ \
|
||||
}
|
||||
|
||||
#define HTABLE_ENTRY(type) \
|
||||
struct { \
|
||||
struct type *next; /* To build the bucket chain list. */ \
|
||||
}
|
||||
|
||||
#define HTABLE_SIZE(head) \
|
||||
(sizeof (*(head)->bkts) ? sizeof ((head)->bkts) / sizeof (*(head)->bkts) : 0)
|
||||
|
||||
#define HTABLE_COUNT(head) \
|
||||
((head)->noitems ? (head)->noitems : 0)
|
||||
|
||||
#define HTABLE_EMPTY(head) \
|
||||
(HTABLE_COUNT((head)) == 0 ? 1 : 0)
|
||||
|
||||
#define HTABLE_COLLS(head) \
|
||||
((head)->noitems ? 100.0 - 100 * (head)->nosingle / (head)->noitems : 0)
|
||||
|
||||
#define HTABLE_LOAD(head) \
|
||||
(HTABLE_SIZE((head)) ? \
|
||||
100.0 - 100.0 * (head)->nofreebkts / HTABLE_SIZE((head)) : 0)
|
||||
|
||||
#define HTABLE_INITIALIZER(head) \
|
||||
{ 0, /* noitems */ \
|
||||
0, /* nosingle */ \
|
||||
HTABLE_SIZE((head)) /* nofreebkts */ \
|
||||
}
|
||||
|
||||
#define HTABLE_INIT(head) do { \
|
||||
bzero ((head), sizeof (*(head))); \
|
||||
(head)->nofreebkts = HTABLE_SIZE((head)); \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
* Generate prototypes.
|
||||
*/
|
||||
#define HTABLE_PROTOTYPE(name, type) \
|
||||
struct type *name##_HTABLE_INSERT(struct name *, struct type *); \
|
||||
struct type *name##_HTABLE_REMOVE(struct name *, struct type *); \
|
||||
struct type *name##_HTABLE_LOOKUP(struct name *, struct type *);
|
||||
|
||||
/*
|
||||
* Generate function bodies.
|
||||
*/
|
||||
#define HTABLE_GENERATE(name, type, key, cmp) \
|
||||
uint32_t \
|
||||
name##_HTABLE_FIND_BKT(struct name *head, struct type *elm) \
|
||||
{ \
|
||||
uint32_t __bkt; \
|
||||
char *__key; \
|
||||
int __len; \
|
||||
\
|
||||
(key) (elm, &__key, &__len); \
|
||||
HTABLE_HASH(__key, __len, HTABLE_SIZE(head), __bkt); \
|
||||
\
|
||||
return __bkt; \
|
||||
} \
|
||||
\
|
||||
int \
|
||||
name##_HTABLE_CHAIN_LEN(struct name *head, uint32_t bkt) \
|
||||
{ \
|
||||
struct type *__bktp; \
|
||||
int __len; \
|
||||
\
|
||||
__len = 0; \
|
||||
for (__bktp = (head)->bkts[(bkt)]; __bktp != NULL; __bktp = __bktp->next) \
|
||||
__len++; \
|
||||
\
|
||||
return __len; \
|
||||
} \
|
||||
\
|
||||
struct type * \
|
||||
name##_HTABLE_INSERT(struct name *head, struct type *elm) \
|
||||
{ \
|
||||
struct type *__bktp, **__bktpp; \
|
||||
uint32_t __bkt, __pos; \
|
||||
\
|
||||
__pos = 0; \
|
||||
__bkt = name##_HTABLE_FIND_BKT(head, elm); \
|
||||
__bktpp = &head->bkts[__bkt]; \
|
||||
while ((__bktp = *__bktpp)) \
|
||||
{ \
|
||||
if (!(cmp)(elm, __bktp)) \
|
||||
return __bktp; \
|
||||
else \
|
||||
{ \
|
||||
__pos++; \
|
||||
__bktpp = &__bktp->next; \
|
||||
} \
|
||||
} \
|
||||
__bktp = elm; \
|
||||
__bktp->next = NULL; \
|
||||
*__bktpp = __bktp; \
|
||||
head->noitems++; \
|
||||
switch (__pos) \
|
||||
{ \
|
||||
case 0: \
|
||||
head->nosingle++; \
|
||||
head->nofreebkts--; \
|
||||
break; \
|
||||
case 1: \
|
||||
head->nosingle--; \
|
||||
break; \
|
||||
default: \
|
||||
break; \
|
||||
} \
|
||||
\
|
||||
return __bktp; \
|
||||
} \
|
||||
\
|
||||
struct type * \
|
||||
name##_HTABLE_REMOVE(struct name *head, struct type *elm) \
|
||||
{ \
|
||||
struct type *__bktp, **__bktpp; \
|
||||
uint32_t __bkt, __pos; \
|
||||
\
|
||||
__pos = 0; \
|
||||
__bkt = name##_HTABLE_FIND_BKT(head, elm); \
|
||||
__bktpp = &head->bkts[__bkt]; \
|
||||
while ((__bktp = *__bktpp)) \
|
||||
{ \
|
||||
if (!(cmp)(elm, __bktp)) \
|
||||
{ \
|
||||
*__bktpp = __bktp->next; \
|
||||
elm = __bktp; \
|
||||
head->noitems--; \
|
||||
if (__pos <= 1) /* Need to scan list to know if we have */ \
|
||||
{ /* a free bucket or a single item. */ \
|
||||
int __len; \
|
||||
\
|
||||
__len = name##_HTABLE_CHAIN_LEN(head, __bkt); \
|
||||
switch (__len) \
|
||||
{ \
|
||||
case 0: \
|
||||
head->nofreebkts++; \
|
||||
head->nosingle--; \
|
||||
break; \
|
||||
case 1: \
|
||||
head->nosingle++; \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
return elm; \
|
||||
} \
|
||||
__pos++; \
|
||||
__bktpp = &__bktp->next; \
|
||||
} \
|
||||
return NULL; \
|
||||
} \
|
||||
\
|
||||
struct type * \
|
||||
name##_HTABLE_LOOKUP(struct name *head, struct type *elm) \
|
||||
{ \
|
||||
struct type *__bktp, **__bktpp; \
|
||||
uint32_t __bkt; \
|
||||
\
|
||||
__bkt = name##_HTABLE_FIND_BKT(head, elm); \
|
||||
__bktpp = &head->bkts[__bkt]; \
|
||||
while ((__bktp = *__bktpp)) \
|
||||
{ \
|
||||
if (!(cmp)(elm, __bktp)) \
|
||||
return __bktp; \
|
||||
else \
|
||||
__bktpp = &__bktp->next; \
|
||||
} \
|
||||
\
|
||||
return NULL; \
|
||||
} \
|
||||
\
|
||||
struct type * \
|
||||
name##_HTABLE_FIRST_FROM(struct name *head, int bkt) \
|
||||
{ \
|
||||
struct type *__bktp; \
|
||||
\
|
||||
while (bkt < HTABLE_SIZE(head)) \
|
||||
{ \
|
||||
if ((__bktp = head->bkts[bkt])) \
|
||||
return __bktp; \
|
||||
else \
|
||||
bkt++; \
|
||||
} \
|
||||
\
|
||||
return NULL; \
|
||||
} \
|
||||
\
|
||||
struct type * \
|
||||
name##_HTABLE_NEXT(struct name *head, struct type *elm) \
|
||||
{ \
|
||||
struct type *__elmp, *__bktp, **__bktpp; \
|
||||
uint32_t __bkt; \
|
||||
\
|
||||
__elmp = NULL; \
|
||||
__bkt = name##_HTABLE_FIND_BKT(head, elm); \
|
||||
__bktpp = &head->bkts[__bkt]; \
|
||||
while ((__bktp = *__bktpp)) \
|
||||
{ \
|
||||
if (!(cmp)(elm, __bktp)) \
|
||||
{ \
|
||||
__elmp = __bktp; \
|
||||
break; \
|
||||
} \
|
||||
else \
|
||||
__bktpp = &__bktp->next; \
|
||||
} \
|
||||
\
|
||||
if (!__elmp) \
|
||||
return NULL; \
|
||||
else if (__elmp->next) \
|
||||
return __elmp->next; \
|
||||
else \
|
||||
return name##_HTABLE_FIRST_FROM(head, ++__bkt); \
|
||||
}
|
||||
|
||||
#define FIRST_BKT 0
|
||||
|
||||
#define HTABLE_INSERT(name, x, y) name##_HTABLE_INSERT(x, y)
|
||||
#define HTABLE_REMOVE(name, x, y) name##_HTABLE_REMOVE(x, y)
|
||||
#define HTABLE_LOOKUP(name, x, y) name##_HTABLE_LOOKUP(x, y)
|
||||
#define HTABLE_FIRST_FROM(name, x, y) (HTABLE_EMPTY(x) ? NULL \
|
||||
: name##_HTABLE_FIRST_FROM(x, y))
|
||||
#define HTABLE_FIRST(name, x) HTABLE_FIRST_FROM(name, x, FIRST_BKT)
|
||||
#define HTABLE_NEXT(name, x, y) (HTABLE_EMPTY(x) ? NULL \
|
||||
: name##_HTABLE_NEXT(x, y))
|
||||
|
||||
#define HTABLE_FOREACH(x, name, head) \
|
||||
for ((x) = HTABLE_FIRST(name, head); \
|
||||
(x) != NULL; \
|
||||
(x) = HTABLE_NEXT(name, head, x))
|
||||
|
||||
/*
|
||||
* Hash functions.
|
||||
*/
|
||||
#ifdef HASH_FUNCTION
|
||||
#define HTABLE_HASH HASH_FUNCTION
|
||||
#else
|
||||
#define HTABLE_HASH HASH_JEN
|
||||
#endif
|
||||
|
||||
#define HASH_JEN_MIX(a, b, c) do { \
|
||||
a -= b; a -= c; a ^= (c >> 13); \
|
||||
b -= c; b -= a; b ^= (a << 8); \
|
||||
c -= a; c -= b; c ^= (b >> 13); \
|
||||
a -= b; a -= c; a ^= (c >> 12); \
|
||||
b -= c; b -= a; b ^= (a << 16); \
|
||||
c -= a; c -= b; c ^= (b >> 5); \
|
||||
a -= b; a -= c; a ^= (c >> 3); \
|
||||
b -= c; b -= a; b ^= (a << 10); \
|
||||
c -= a; c -= b; c ^= (b >> 15); \
|
||||
} while (0)
|
||||
|
||||
#define HASH_JEN(key, keylen, num_bkts, bkt) do { \
|
||||
register uint32_t i, j, k, hash; \
|
||||
\
|
||||
hash = 0xfeedbeef; \
|
||||
i = j = 0x9e3779b9; \
|
||||
k = keylen; \
|
||||
while (k >= 12) \
|
||||
{ \
|
||||
i += (key[0] + ((unsigned)key[1] << 8) \
|
||||
+ ((unsigned)key[2] << 16) \
|
||||
+ ((unsigned)key[3] << 24)); \
|
||||
j += (key[4] + ((unsigned)key[5] << 8) \
|
||||
+ ((unsigned)key[6] << 16) \
|
||||
+ ((unsigned)key[7] << 24 )); \
|
||||
hash += (key[8] + ((unsigned)key[9] << 8) \
|
||||
+ ((unsigned)key[10] << 16) \
|
||||
+ ((unsigned)key[11] << 24)); \
|
||||
\
|
||||
HASH_JEN_MIX (i, j, hash); \
|
||||
\
|
||||
key += 12; \
|
||||
k -= 12; \
|
||||
} \
|
||||
hash += keylen; \
|
||||
switch (k) \
|
||||
{ \
|
||||
case 11: \
|
||||
hash += ((unsigned)key[10] << 24); \
|
||||
case 10: \
|
||||
hash += ((unsigned)key[9] << 16); \
|
||||
case 9: \
|
||||
hash += ((unsigned)key[8] << 8); \
|
||||
case 8: \
|
||||
j += ((unsigned)key[7] << 24); \
|
||||
case 7: \
|
||||
j += ((unsigned)key[6] << 16); \
|
||||
case 6: \
|
||||
j += ((unsigned)key[5] << 8); \
|
||||
case 5: \
|
||||
j += key[4]; \
|
||||
case 4: \
|
||||
i += ((unsigned)key[3] << 24); \
|
||||
case 3: \
|
||||
i += ((unsigned)key[2] << 16); \
|
||||
case 2: \
|
||||
i += ((unsigned)key[1] << 8); \
|
||||
case 1: \
|
||||
i += key[0]; \
|
||||
} \
|
||||
HASH_JEN_MIX (i, j, hash); \
|
||||
bkt = hash % (num_bkts); \
|
||||
} while (0)
|
||||
|
||||
#define HASH_OAT(key, keylen, num_bkts, bkt) do { \
|
||||
register uint32_t hash; \
|
||||
int i; \
|
||||
\
|
||||
hash = 0; \
|
||||
for (i = 0; i < keylen; i++) \
|
||||
{ \
|
||||
hash += key[i]; \
|
||||
hash += (hash << 10); \
|
||||
hash ^= (hash >> 6); \
|
||||
} \
|
||||
hash += (hash << 3); \
|
||||
hash ^= (hash >> 11); \
|
||||
hash += (hash << 15); \
|
||||
bkt = hash % (num_bkts); \
|
||||
} while (0)
|
||||
|
||||
#endif /* !HTABLE_H */
|
||||
Reference in New Issue
Block a user