123 lines
3.3 KiB
C
123 lines
3.3 KiB
C
|
|
|
|
#define HASH(type) struct { type **data; uint count, order; }
|
|
#define HASH_TYPE(v) typeof(** (v).data)
|
|
#define HASH_SIZE(v) (1 << (v).order)
|
|
#define HASH_MASK(v) ((1 << (v).order)-1)
|
|
|
|
|
|
#define HASH_INIT(v,pool,init_order) \
|
|
({ \
|
|
(v).count = 0; \
|
|
(v).order = (init_order); \
|
|
(v).data = mb_allocz(pool, HASH_SIZE(v) * sizeof(* (v).data)); \
|
|
})
|
|
|
|
#define HASH_FIND(v,id,key...) \
|
|
({ \
|
|
uint _h = id##_FN((key)) & HASH_MASK(v); \
|
|
HASH_TYPE(v) *_n = (v).data[_h]; \
|
|
while (_n && !id##_EQ(id##_KEY(_n), (key))) \
|
|
_n = id##_NEXT(_n); \
|
|
_n; \
|
|
})
|
|
|
|
#define HASH_INSERT(v,id,node) \
|
|
({ \
|
|
uint _h = id##_FN(id##_KEY((node))) & HASH_MASK(v); \
|
|
HASH_TYPE(v) **_nn = (v).data + _h; \
|
|
id##_NEXT(node) = *_nn; \
|
|
*_nn = node; \
|
|
(v).count++; \
|
|
})
|
|
|
|
#define HASH_DO_REMOVE(v,id,_nn) \
|
|
({ \
|
|
HASH_TYPE(v) *_n = *_nn; \
|
|
if (_n) \
|
|
{ \
|
|
*_nn = id##_NEXT(_n); \
|
|
(v).count--; \
|
|
} \
|
|
_n; \
|
|
})
|
|
|
|
#define HASH_DELETE(v,id,key...) \
|
|
({ \
|
|
uint _h = id##_FN((key)) & HASH_MASK(v); \
|
|
HASH_TYPE(v) **_nn = (v).data + _h; \
|
|
\
|
|
while ((*_nn) && !id##_EQ(id##_KEY((*_nn)), (key))) \
|
|
_nn = &(id##_NEXT((*_nn))); \
|
|
\
|
|
HASH_DO_REMOVE(v,id,_nn); \
|
|
})
|
|
|
|
#define HASH_REMOVE(v,id,node) \
|
|
({ \
|
|
uint _h = id##_FN(id##_KEY((node))) & HASH_MASK(v); \
|
|
HASH_TYPE(v) **_nn = (v).data + _h; \
|
|
\
|
|
while ((*_nn) && (*_nn != (node))) \
|
|
_nn = &(id##_NEXT((*_nn))); \
|
|
\
|
|
HASH_DO_REMOVE(v,id,_nn); \
|
|
})
|
|
|
|
|
|
#define HASH_REHASH(v,id,pool,step) \
|
|
({ \
|
|
HASH_TYPE(v) *_n, *_n2, **_od; \
|
|
uint _i, _s; \
|
|
\
|
|
_s = HASH_SIZE(v); \
|
|
_od = (v).data; \
|
|
(v).count = 0; \
|
|
(v).order += (step); \
|
|
(v).data = mb_allocz(pool, HASH_SIZE(v) * sizeof(* (v).data)); \
|
|
\
|
|
for (_i = 0; _i < _s; _i++) \
|
|
for (_n = _od[_i]; _n && (_n2 = id##_NEXT(_n), 1); _n = _n2) \
|
|
HASH_INSERT(v, id, _n); \
|
|
\
|
|
mb_free(_od); \
|
|
})
|
|
|
|
#define HASH_DEFINE_REHASH_FN(id, type) \
|
|
static void id##_REHASH_FN(void *v, pool *p, int step) \
|
|
{ HASH_REHASH(* (HASH(type) *) v, id, p, step); }
|
|
|
|
#define HASH_TRY_REHASH_UP(v,id,pool) \
|
|
({ \
|
|
if (((v).order < id##_REHASH_MAX) && ((v).count > HASH_SIZE(v))) \
|
|
id##_REHASH_FN(&v, pool, 1); \
|
|
})
|
|
|
|
#define HASH_TRY_REHASH_DOWN(v,id,pool) \
|
|
({ \
|
|
if (((v).order > id##_REHASH_MIN) && ((v).count < HASH_SIZE(v)/2)) \
|
|
id##_REHASH_FN(&v, pool, -1); \
|
|
})
|
|
|
|
#define HASH_WALK(v,next,n) \
|
|
do { \
|
|
HASH_TYPE(v) *n; \
|
|
uint _i; \
|
|
uint _s = HASH_SIZE(v); \
|
|
for (_i = 0; _i < _s; _i++) \
|
|
for (n = (v).data[_i]; n; n = n->next)
|
|
|
|
#define HASH_WALK_END } while (0)
|
|
|
|
|
|
#define HASH_WALK_DELSAFE(v,next,n) \
|
|
do { \
|
|
HASH_TYPE(v) *n, *_next; \
|
|
uint _i; \
|
|
uint _s = HASH_SIZE(v); \
|
|
for (_i = 0; _i < _s; _i++) \
|
|
for (n = (v).data[_i]; n && (_next = n->next, 1); n = _next)
|
|
|
|
#define HASH_WALK_DELSAFE_END } while (0)
|
|
|
|
|