uthash.h File Reference

#include <string.h>
#include <stddef.h>
#include <stdlib.h>
#include <inttypes.h>

Classes
struct	UT_hash_bucket
struct	UT_hash_table
struct	UT_hash_handle

Macros
#define	DECLTYPE(x)   (__typeof(x))
#define	DECLTYPE_ASSIGN(dst, src)
#define	UTHASH_VERSION   1.9.8
#define	uthash_fatal(msg)   exit(-1) /* fatal error (out of memory,etc) */
#define	uthash_malloc(sz)   malloc(sz) /* malloc fcn */
#define	uthash_free(ptr, sz)   free(ptr) /* free fcn */
#define	uthash_noexpand_fyi(tbl)   /* can be defined to log noexpand */
#define	uthash_expand_fyi(tbl)   /* can be defined to log expands */
#define	HASH_INITIAL_NUM_BUCKETS   32 /* initial number of buckets */
#define	HASH_INITIAL_NUM_BUCKETS_LOG2   5 /* lg2 of initial number of buckets */
#define	HASH_BKT_CAPACITY_THRESH   10 /* expand when bucket count reaches */
#define	ELMT_FROM_HH(tbl, hhp)   ((void*)(((char*)(hhp)) - ((tbl)->hho)))
#define	HASH_FIND(hh, head, keyptr, keylen, out)
#define	HASH_BLOOM_MAKE(tbl)
#define	HASH_BLOOM_FREE(tbl)
#define	HASH_BLOOM_ADD(tbl, hashv)
#define	HASH_BLOOM_TEST(tbl, hashv)   (1)
#define	HASH_BLOOM_BYTELEN   0
#define	HASH_MAKE_TABLE(hh, head)
#define	HASH_ADD(hh, head, fieldname, keylen_in, add)   HASH_ADD_KEYPTR(hh,head,&((add)->fieldname),keylen_in,add)
#define	HASH_REPLACE(hh, head, fieldname, keylen_in, add, replaced)
#define	HASH_ADD_KEYPTR(hh, head, keyptr, keylen_in, add)
#define	HASH_TO_BKT(hashv, num_bkts, bkt)
#define	HASH_DELETE(hh, head, delptr)
#define	HASH_FIND_STR(head, findstr, out)   HASH_FIND(hh,head,findstr,strlen(findstr),out)
#define	HASH_ADD_STR(head, strfield, add)   HASH_ADD(hh,head,strfield,strlen(add->strfield),add)
#define	HASH_REPLACE_STR(head, strfield, add, replaced)   HASH_REPLACE(hh,head,strfield,strlen(add->strfield),add,replaced)
#define	HASH_FIND_INT(head, findint, out)   HASH_FIND(hh,head,findint,sizeof(int),out)
#define	HASH_ADD_INT(head, intfield, add)   HASH_ADD(hh,head,intfield,sizeof(int),add)
#define	HASH_REPLACE_INT(head, intfield, add, replaced)   HASH_REPLACE(hh,head,intfield,sizeof(int),add,replaced)
#define	HASH_FIND_PTR(head, findptr, out)   HASH_FIND(hh,head,findptr,sizeof(void *),out)
#define	HASH_ADD_PTR(head, ptrfield, add)   HASH_ADD(hh,head,ptrfield,sizeof(void *),add)
#define	HASH_REPLACE_PTR(head, ptrfield, add)   HASH_REPLACE(hh,head,ptrfield,sizeof(void *),add,replaced)
#define	HASH_DEL(head, delptr)   HASH_DELETE(hh,head,delptr)
#define	HASH_FSCK(hh, head)
#define	HASH_EMIT_KEY(hh, head, keyptr, fieldlen)
#define	HASH_FCN   HASH_JEN
#define	HASH_BER(key, keylen, num_bkts, hashv, bkt)
#define	HASH_SAX(key, keylen, num_bkts, hashv, bkt)
#define	HASH_FNV(key, keylen, num_bkts, hashv, bkt)
#define	HASH_OAT(key, keylen, num_bkts, hashv, bkt)
#define	HASH_JEN_MIX(a, b, c)
#define	HASH_JEN(key, keylen, num_bkts, hashv, bkt)
#define	get16bits(d)
#define	HASH_SFH(key, keylen, num_bkts, hashv, bkt)
#define	HASH_KEYCMP(a, b, len)   memcmp(a,b,len)
#define	HASH_FIND_IN_BKT(tbl, hh, head, keyptr, keylen_in, out)
#define	HASH_ADD_TO_BKT(head, addhh)
#define	HASH_DEL_IN_BKT(hh, head, hh_del)
#define	HASH_EXPAND_BUCKETS(tbl)
#define	HASH_SORT(head, cmpfcn)   HASH_SRT(hh,head,cmpfcn)
#define	HASH_SRT(hh, head, cmpfcn)
#define	HASH_SELECT(hh_dst, dst, hh_src, src, cond)
#define	HASH_CLEAR(hh, head)
#define	HASH_OVERHEAD(hh, head)
#define	HASH_ITER(hh, head, el, tmp)
#define	HASH_COUNT(head)   HASH_CNT(hh,head)
#define	HASH_CNT(hh, head)   ((head)?((head)->hh.tbl->num_items):0)
#define	HASH_SIGNATURE   0xa0111fe1
#define	HASH_BLOOM_SIGNATURE   0xb12220f2

Macro Definition Documentation

#define DECLTYPE

(

x

)

(__typeof(x))

var DECLTYPE

(

var

)

(__typeof(x))

local DECLTYPE

(

local

)

(__typeof(x))

#define DECLTYPE_ASSIGN	(		dst,
			src
	)

Value:

do {                                                                             \
  (dst) = DECLTYPE(dst)(src);                                                    \
} while(0)

var DECLTYPE_ASSIGN	(		var,
			var
	)

Value:

do {                                                                             \
  (dst) = DECLTYPE(dst)(src);                                                    \
} while(0)

local DECLTYPE_ASSIGN	(		local,
			local
	)

Value:

do {                                                                             \
  (dst) = DECLTYPE(dst)(src);                                                    \
} while(0)

#define ELMT_FROM_HH	(		tbl,
			hhp
	)		((void*)(((char*)(hhp)) - ((tbl)->hho)))

var ELMT_FROM_HH	(		var,
			var
	)		((void*)(((char*)(hhp)) - ((tbl)->hho)))

local ELMT_FROM_HH	(		local,
			local
	)		((void*)(((char*)(hhp)) - ((tbl)->hho)))

#define get16bits

(

d

)

Value:

((((uint32_t)(((const uint8_t *)(d))[1])) << 8)             \
                       +(uint32_t)(((const uint8_t *)(d))[0]) )

var get16bits

(

var

)

Value:

((((uint32_t)(((const uint8_t *)(d))[1])) << 8)             \
                       +(uint32_t)(((const uint8_t *)(d))[0]) )

local get16bits

(

local

)

Value:

((((uint32_t)(((const uint8_t *)(d))[1])) << 8)             \
                       +(uint32_t)(((const uint8_t *)(d))[0]) )

#define HASH_ADD	(		hh,
			head,
			fieldname,
			keylen_in,
			add
	)		HASH_ADD_KEYPTR(hh,head,&((add)->fieldname),keylen_in,add)

#define HASH_ADD_INT	(		head,
			intfield,
			add
	)		HASH_ADD(hh,head,intfield,sizeof(int),add)

var HASH_ADD_INT	(		var,
			var,
			var
	)		HASH_ADD(hh,head,intfield,sizeof(int),add)

local HASH_ADD_INT	(		local,
			local,
			local
	)		HASH_ADD(hh,head,intfield,sizeof(int),add)

#define HASH_ADD_KEYPTR	(		hh,
			head,
			keyptr,
			keylen_in,
			add
	)

Value:

do {                                                                             \
 unsigned _ha_bkt;                                                               \
 (add)->hh.next = NULL;                                                          \
 (add)->hh.key = (char*)keyptr;                                                  \
 (add)->hh.keylen = (unsigned)keylen_in;                                                   \
 if (!(head)) {                                                                  \
    head = (add);                                                                \
    (head)->hh.prev = NULL;                                                      \
    HASH_MAKE_TABLE(hh,head);                                                    \
 } else {                                                                        \
    (head)->hh.tbl->tail->next = (add);                                          \
    (add)->hh.prev = ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail);         \
    (head)->hh.tbl->tail = &((add)->hh);                                         \
 }                                                                               \
 (head)->hh.tbl->num_items++;                                                    \
 (add)->hh.tbl = (head)->hh.tbl;                                                 \
 HASH_FCN(keyptr,keylen_in, (head)->hh.tbl->num_buckets,                         \
         (add)->hh.hashv, _ha_bkt);                                              \
 HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt],&(add)->hh);                   \
 HASH_BLOOM_ADD((head)->hh.tbl,(add)->hh.hashv);                                 \
 HASH_EMIT_KEY(hh,head,keyptr,keylen_in);                                        \
 HASH_FSCK(hh,head);                                                             \
} while(0)

#define HASH_ADD_PTR	(		head,
			ptrfield,
			add
	)		HASH_ADD(hh,head,ptrfield,sizeof(void *),add)

var HASH_ADD_PTR	(		var,
			var,
			var
	)		HASH_ADD(hh,head,ptrfield,sizeof(void *),add)

local HASH_ADD_PTR	(		local,
			local,
			local
	)		HASH_ADD(hh,head,ptrfield,sizeof(void *),add)

#define HASH_ADD_STR	(		head,
			strfield,
			add
	)		HASH_ADD(hh,head,strfield,strlen(add->strfield),add)

var HASH_ADD_STR	(		var,
			var,
			var
	)		HASH_ADD(hh,head,strfield,strlen(add->strfield),add)

local HASH_ADD_STR	(		local,
			local,
			local
	)		HASH_ADD(hh,head,strfield,strlen(add->strfield),add)

#define HASH_ADD_TO_BKT	(		head,
			addhh
	)

Value:

do {                                                                             \
 head.count++;                                                                   \
 (addhh)->hh_next = head.hh_head;                                                \
 (addhh)->hh_prev = NULL;                                                        \
 if (head.hh_head) { (head).hh_head->hh_prev = (addhh); }                        \
 (head).hh_head=addhh;                                                           \
 if (head.count >= ((head.expand_mult+1) * HASH_BKT_CAPACITY_THRESH)             \
     && (addhh)->tbl->noexpand != 1) {                                           \
       HASH_EXPAND_BUCKETS((addhh)->tbl);                                        \
 }                                                                               \
} while(0)

var HASH_ADD_TO_BKT	(		var,
			var
	)

Value:

do {                                                                             \
 head.count++;                                                                   \
 (addhh)->hh_next = head.hh_head;                                                \
 (addhh)->hh_prev = NULL;                                                        \
 if (head.hh_head) { (head).hh_head->hh_prev = (addhh); }                        \
 (head).hh_head=addhh;                                                           \
 if (head.count >= ((head.expand_mult+1) * HASH_BKT_CAPACITY_THRESH)             \
     && (addhh)->tbl->noexpand != 1) {                                           \
       HASH_EXPAND_BUCKETS((addhh)->tbl);                                        \
 }                                                                               \
} while(0)

local HASH_ADD_TO_BKT	(		local,
			local
	)

Value:

do {                                                                             \
 head.count++;                                                                   \
 (addhh)->hh_next = head.hh_head;                                                \
 (addhh)->hh_prev = NULL;                                                        \
 if (head.hh_head) { (head).hh_head->hh_prev = (addhh); }                        \
 (head).hh_head=addhh;                                                           \
 if (head.count >= ((head.expand_mult+1) * HASH_BKT_CAPACITY_THRESH)             \
     && (addhh)->tbl->noexpand != 1) {                                           \
       HASH_EXPAND_BUCKETS((addhh)->tbl);                                        \
 }                                                                               \
} while(0)

#define HASH_BER	(		key,
			keylen,
			num_bkts,
			hashv,
			bkt
	)

Value:

do {                                                                             \
  unsigned _hb_keylen=keylen;                                                    \
  char *_hb_key=(char*)(key);                                                    \
  (hashv) = 0;                                                                   \
  while (_hb_keylen--)  { (hashv) = ((hashv) * 33) + *_hb_key++; }               \
  bkt = (hashv) & (num_bkts-1);                                                  \
} while (0)

var HASH_BER	(		var,
			var,
			var,
			var,
			var
	)

Value:

do {                                                                             \
  unsigned _hb_keylen=keylen;                                                    \
  char *_hb_key=(char*)(key);                                                    \
  (hashv) = 0;                                                                   \
  while (_hb_keylen--)  { (hashv) = ((hashv) * 33) + *_hb_key++; }               \
  bkt = (hashv) & (num_bkts-1);                                                  \
} while (0)

local HASH_BER	(		local,
			local,
			local,
			local,
			local
	)

Value:

do {                                                                             \
  unsigned _hb_keylen=keylen;                                                    \
  char *_hb_key=(char*)(key);                                                    \
  (hashv) = 0;                                                                   \
  while (_hb_keylen--)  { (hashv) = ((hashv) * 33) + *_hb_key++; }               \
  bkt = (hashv) & (num_bkts-1);                                                  \
} while (0)

#define HASH_BKT_CAPACITY_THRESH   10 /* expand when bucket count reaches */

var HASH_BKT_CAPACITY_THRESH   10 /* expand when bucket count reaches */

local HASH_BKT_CAPACITY_THRESH   10 /* expand when bucket count reaches */

#define HASH_BLOOM_ADD	(		tbl,
			hashv
	)

var HASH_BLOOM_ADD	(		var,
			var
	)

local HASH_BLOOM_ADD	(		local,
			local
	)

#define HASH_BLOOM_BYTELEN   0

var HASH_BLOOM_BYTELEN   0

local HASH_BLOOM_BYTELEN   0

#define HASH_BLOOM_FREE

(

tbl

)

var HASH_BLOOM_FREE

(

var

)

local HASH_BLOOM_FREE

(

local

)

#define HASH_BLOOM_MAKE

(

tbl

)

#define HASH_BLOOM_SIGNATURE   0xb12220f2

var HASH_BLOOM_SIGNATURE   0xb12220f2

local HASH_BLOOM_SIGNATURE   0xb12220f2

#define HASH_BLOOM_TEST	(		tbl,
			hashv
	)		(1)

var HASH_BLOOM_TEST	(		var,
			var
	)		(1)

local HASH_BLOOM_TEST	(		local,
			local
	)		(1)

#define HASH_CLEAR	(		hh,
			head
	)

Value:

do {                                                                             \
  if (head) {                                                                    \
    uthash_free((head)->hh.tbl->buckets,                                         \
                (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket));      \
    HASH_BLOOM_FREE((head)->hh.tbl);                                             \
    uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                          \
    (head)=NULL;                                                                 \
  }                                                                              \
} while(0)

var HASH_CLEAR	(		var,
			var
	)

Value:

do {                                                                             \
  if (head) {                                                                    \
    uthash_free((head)->hh.tbl->buckets,                                         \
                (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket));      \
    HASH_BLOOM_FREE((head)->hh.tbl);                                             \
    uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                          \
    (head)=NULL;                                                                 \
  }                                                                              \
} while(0)

local HASH_CLEAR	(		local,
			local
	)

Value:

do {                                                                             \
  if (head) {                                                                    \
    uthash_free((head)->hh.tbl->buckets,                                         \
                (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket));      \
    HASH_BLOOM_FREE((head)->hh.tbl);                                             \
    uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                          \
    (head)=NULL;                                                                 \
  }                                                                              \
} while(0)

#define HASH_CNT	(		hh,
			head
	)		((head)?((head)->hh.tbl->num_items):0)

var HASH_CNT	(		var,
			var
	)		((head)?((head)->hh.tbl->num_items):0)

local HASH_CNT	(		local,
			local
	)		((head)?((head)->hh.tbl->num_items):0)

#define HASH_COUNT

(

head

)

HASH_CNT(hh,head)

var HASH_COUNT

(

var

)

HASH_CNT(hh,head)

local HASH_COUNT

(

local

)

HASH_CNT(hh,head)

#define HASH_DEL	(		head,
			delptr
	)		HASH_DELETE(hh,head,delptr)

var HASH_DEL	(		var,
			var
	)		HASH_DELETE(hh,head,delptr)

local HASH_DEL	(		local,
			local
	)		HASH_DELETE(hh,head,delptr)

#define HASH_DEL_IN_BKT	(		hh,
			head,
			hh_del
	)

Value:

(head).count--;                                                              \
    if ((head).hh_head == hh_del) {                                              \
      (head).hh_head = hh_del->hh_next;                                          \
    }                                                                            \
    if (hh_del->hh_prev) {                                                       \
        hh_del->hh_prev->hh_next = hh_del->hh_next;                              \
    }                                                                            \
    if (hh_del->hh_next) {                                                       \
        hh_del->hh_next->hh_prev = hh_del->hh_prev;                              \
    }

#define HASH_DELETE	(		hh,
			head,
			delptr
	)

#define HASH_EMIT_KEY	(		hh,
			head,
			keyptr,
			fieldlen
	)

#define HASH_EXPAND_BUCKETS

(

tbl

)

#define HASH_FCN   HASH_JEN

#define HASH_FIND	(		hh,
			head,
			keyptr,
			keylen,
			out
	)

Value:

do {                                                                             \
  unsigned _hf_bkt,_hf_hashv;                                                    \
  out=NULL;                                                                      \
  if (head) {                                                                    \
     HASH_FCN(keyptr,keylen, (head)->hh.tbl->num_buckets, _hf_hashv, _hf_bkt);   \
     if (HASH_BLOOM_TEST((head)->hh.tbl, _hf_hashv)) {                           \
       HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ],  \
                        keyptr,keylen,out);                                      \
     }                                                                           \
  }                                                                              \
} while (0)

var HASH_FIND	(		var,
			var,
			var,
			var,
			var
	)

Value:

do {                                                                             \
  unsigned _hf_bkt,_hf_hashv;                                                    \
  out=NULL;                                                                      \
  if (head) {                                                                    \
     HASH_FCN(keyptr,keylen, (head)->hh.tbl->num_buckets, _hf_hashv, _hf_bkt);   \
     if (HASH_BLOOM_TEST((head)->hh.tbl, _hf_hashv)) {                           \
       HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ],  \
                        keyptr,keylen,out);                                      \
     }                                                                           \
  }                                                                              \
} while (0)

local HASH_FIND	(		local,
			local,
			local,
			local,
			local
	)

Value:

do {                                                                             \
  unsigned _hf_bkt,_hf_hashv;                                                    \
  out=NULL;                                                                      \
  if (head) {                                                                    \
     HASH_FCN(keyptr,keylen, (head)->hh.tbl->num_buckets, _hf_hashv, _hf_bkt);   \
     if (HASH_BLOOM_TEST((head)->hh.tbl, _hf_hashv)) {                           \
       HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ],  \
                        keyptr,keylen,out);                                      \
     }                                                                           \
  }                                                                              \
} while (0)

#define HASH_FIND_IN_BKT	(		tbl,
			hh,
			head,
			keyptr,
			keylen_in,
			out
	)

Value:

do {                                                                             \
 if (head.hh_head) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,head.hh_head));          \
 else out=NULL;                                                                  \
 while (out) {                                                                   \
    if ((out)->hh.keylen == keylen_in) {                                           \
        if ((HASH_KEYCMP((out)->hh.key,keyptr,keylen_in)) == 0) break;             \
    }                                                                            \
    if ((out)->hh.hh_next) DECLTYPE_ASSIGN(out,ELMT_FROM_HH(tbl,(out)->hh.hh_next)); \
    else out = NULL;                                                             \
 }                                                                               \
} while(0)

#define HASH_FIND_INT	(		head,
			findint,
			out
	)		HASH_FIND(hh,head,findint,sizeof(int),out)

var HASH_FIND_INT	(		var,
			var,
			var
	)		HASH_FIND(hh,head,findint,sizeof(int),out)

local HASH_FIND_INT	(		local,
			local,
			local
	)		HASH_FIND(hh,head,findint,sizeof(int),out)

#define HASH_FIND_PTR	(		head,
			findptr,
			out
	)		HASH_FIND(hh,head,findptr,sizeof(void *),out)

var HASH_FIND_PTR	(		var,
			var,
			var
	)		HASH_FIND(hh,head,findptr,sizeof(void *),out)

local HASH_FIND_PTR	(		local,
			local,
			local
	)		HASH_FIND(hh,head,findptr,sizeof(void *),out)

#define HASH_FIND_STR	(		head,
			findstr,
			out
	)		HASH_FIND(hh,head,findstr,strlen(findstr),out)

#define HASH_FNV	(		key,
			keylen,
			num_bkts,
			hashv,
			bkt
	)

Value:

do {                                                                             \
  unsigned _fn_i;                                                                \
  char *_hf_key=(char*)(key);                                                    \
  hashv = 2166136261UL;                                                          \
  for(_fn_i=0; _fn_i < keylen; _fn_i++)                                          \
      hashv = (hashv * 16777619) ^ _hf_key[_fn_i];                               \
  bkt = hashv & (num_bkts-1);                                                    \
} while(0)

#define HASH_FSCK	(		hh,
			head
	)

var HASH_FSCK	(		var,
			var
	)

local HASH_FSCK	(		local,
			local
	)

#define HASH_INITIAL_NUM_BUCKETS   32 /* initial number of buckets */

var HASH_INITIAL_NUM_BUCKETS   32 /* initial number of buckets */

local HASH_INITIAL_NUM_BUCKETS   32 /* initial number of buckets */

#define HASH_INITIAL_NUM_BUCKETS_LOG2   5 /* lg2 of initial number of buckets */

var HASH_INITIAL_NUM_BUCKETS_LOG2   5 /* lg2 of initial number of buckets */

local HASH_INITIAL_NUM_BUCKETS_LOG2   5 /* lg2 of initial number of buckets */

#define HASH_ITER	(		hh,
			head,
			el,
			tmp
	)

Value:

for((el)=(head),(tmp)=DECLTYPE(el)((head)?(head)->hh.next:NULL);                 \
  el; (el)=(tmp),(tmp)=DECLTYPE(el)((tmp)?(tmp)->hh.next:NULL))

var HASH_ITER	(		var,
			var,
			var,
			var
	)

Value:

for((el)=(head),(tmp)=DECLTYPE(el)((head)?(head)->hh.next:NULL);                 \
  el; (el)=(tmp),(tmp)=DECLTYPE(el)((tmp)?(tmp)->hh.next:NULL))

local HASH_ITER	(		local,
			local,
			local,
			local
	)

Value:

for((el)=(head),(tmp)=DECLTYPE(el)((head)?(head)->hh.next:NULL);                 \
  el; (el)=(tmp),(tmp)=DECLTYPE(el)((tmp)?(tmp)->hh.next:NULL))

#define HASH_JEN	(		key,
			keylen,
			num_bkts,
			hashv,
			bkt
	)

#define HASH_JEN_MIX	(		a,
			b,
			c
	)

Value:

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_KEYCMP	(		a,
			b,
			len
	)		memcmp(a,b,len)

var HASH_KEYCMP	(		var,
			var,
			var
	)		memcmp(a,b,len)

local HASH_KEYCMP	(		local,
			local,
			local
	)		memcmp(a,b,len)

#define HASH_MAKE_TABLE	(		hh,
			head
	)

Value:

do {                                                                             \
  (head)->hh.tbl = (UT_hash_table*)uthash_malloc(                                \
                  sizeof(UT_hash_table));                                        \
  if (!((head)->hh.tbl))  { uthash_fatal( "out of memory"); }                    \
  memset((head)->hh.tbl, 0, sizeof(UT_hash_table));                              \
  (head)->hh.tbl->tail = &((head)->hh);                                          \
  (head)->hh.tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS;                        \
  (head)->hh.tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2;              \
  (head)->hh.tbl->hho = (char*)(&(head)->hh) - (char*)(head);                    \
  (head)->hh.tbl->buckets = (UT_hash_bucket*)uthash_malloc(                      \
          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));               \
  if (! (head)->hh.tbl->buckets) { uthash_fatal( "out of memory"); }             \
  memset((head)->hh.tbl->buckets, 0,                                             \
          HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket));               \
  HASH_BLOOM_MAKE((head)->hh.tbl);                                               \
  (head)->hh.tbl->signature = HASH_SIGNATURE;                                    \
} while(0)

#define HASH_OAT	(		key,
			keylen,
			num_bkts,
			hashv,
			bkt
	)

Value:

do {                                                                             \
  unsigned _ho_i;                                                                \
  char *_ho_key=(char*)(key);                                                    \
  hashv = 0;                                                                     \
  for(_ho_i=0; _ho_i < keylen; _ho_i++) {                                        \
      hashv += _ho_key[_ho_i];                                                   \
      hashv += (hashv << 10);                                                    \
      hashv ^= (hashv >> 6);                                                     \
  }                                                                              \
  hashv += (hashv << 3);                                                         \
  hashv ^= (hashv >> 11);                                                        \
  hashv += (hashv << 15);                                                        \
  bkt = hashv & (num_bkts-1);                                                    \
} while(0)

var HASH_OAT	(		var,
			var,
			var,
			var,
			var
	)

Value:

do {                                                                             \
  unsigned _ho_i;                                                                \
  char *_ho_key=(char*)(key);                                                    \
  hashv = 0;                                                                     \
  for(_ho_i=0; _ho_i < keylen; _ho_i++) {                                        \
      hashv += _ho_key[_ho_i];                                                   \
      hashv += (hashv << 10);                                                    \
      hashv ^= (hashv >> 6);                                                     \
  }                                                                              \
  hashv += (hashv << 3);                                                         \
  hashv ^= (hashv >> 11);                                                        \
  hashv += (hashv << 15);                                                        \
  bkt = hashv & (num_bkts-1);                                                    \
} while(0)

local HASH_OAT	(		local,
			local,
			local,
			local,
			local
	)

Value:

do {                                                                             \
  unsigned _ho_i;                                                                \
  char *_ho_key=(char*)(key);                                                    \
  hashv = 0;                                                                     \
  for(_ho_i=0; _ho_i < keylen; _ho_i++) {                                        \
      hashv += _ho_key[_ho_i];                                                   \
      hashv += (hashv << 10);                                                    \
      hashv ^= (hashv >> 6);                                                     \
  }                                                                              \
  hashv += (hashv << 3);                                                         \
  hashv ^= (hashv >> 11);                                                        \
  hashv += (hashv << 15);                                                        \
  bkt = hashv & (num_bkts-1);                                                    \
} while(0)

#define HASH_OVERHEAD	(		hh,
			head
	)

Value:

(size_t)((((head)->hh.tbl->num_items   * sizeof(UT_hash_handle))   +            \
           ((head)->hh.tbl->num_buckets * sizeof(UT_hash_bucket))   +            \
            (sizeof(UT_hash_table))                                 +            \
            (HASH_BLOOM_BYTELEN)))

var HASH_OVERHEAD	(		var,
			var
	)

Value:

(size_t)((((head)->hh.tbl->num_items   * sizeof(UT_hash_handle))   +            \
           ((head)->hh.tbl->num_buckets * sizeof(UT_hash_bucket))   +            \
            (sizeof(UT_hash_table))                                 +            \
            (HASH_BLOOM_BYTELEN)))

local HASH_OVERHEAD	(		local,
			local
	)

Value:

(size_t)((((head)->hh.tbl->num_items   * sizeof(UT_hash_handle))   +            \
           ((head)->hh.tbl->num_buckets * sizeof(UT_hash_bucket))   +            \
            (sizeof(UT_hash_table))                                 +            \
            (HASH_BLOOM_BYTELEN)))

#define HASH_REPLACE	(		hh,
			head,
			fieldname,
			keylen_in,
			add,
			replaced
	)

Value:

do {                                                                             \
  replaced=NULL;                                                                 \
  HASH_FIND(hh,head,&((add)->fieldname),keylen_in,replaced);                     \
  if (replaced!=NULL) {                                                          \
     HASH_DELETE(hh,head,replaced);                                              \
  };                                                                             \
  HASH_ADD(hh,head,fieldname,keylen_in,add);                                     \
} while(0)

var HASH_REPLACE	(		var,
			var,
			var,
			var,
			var,
			var
	)

Value:

do {                                                                             \
  replaced=NULL;                                                                 \
  HASH_FIND(hh,head,&((add)->fieldname),keylen_in,replaced);                     \
  if (replaced!=NULL) {                                                          \
     HASH_DELETE(hh,head,replaced);                                              \
  };                                                                             \
  HASH_ADD(hh,head,fieldname,keylen_in,add);                                     \
} while(0)

local HASH_REPLACE	(		local,
			local,
			local,
			local,
			local,
			local
	)

Value:

do {                                                                             \
  replaced=NULL;                                                                 \
  HASH_FIND(hh,head,&((add)->fieldname),keylen_in,replaced);                     \
  if (replaced!=NULL) {                                                          \
     HASH_DELETE(hh,head,replaced);                                              \
  };                                                                             \
  HASH_ADD(hh,head,fieldname,keylen_in,add);                                     \
} while(0)

#define HASH_REPLACE_INT	(		head,
			intfield,
			add,
			replaced
	)		HASH_REPLACE(hh,head,intfield,sizeof(int),add,replaced)

var HASH_REPLACE_INT	(		var,
			var,
			var,
			var
	)		HASH_REPLACE(hh,head,intfield,sizeof(int),add,replaced)

local HASH_REPLACE_INT	(		local,
			local,
			local,
			local
	)		HASH_REPLACE(hh,head,intfield,sizeof(int),add,replaced)

#define HASH_REPLACE_PTR	(		head,
			ptrfield,
			add
	)		HASH_REPLACE(hh,head,ptrfield,sizeof(void *),add,replaced)

var HASH_REPLACE_PTR	(		var,
			var,
			var
	)		HASH_REPLACE(hh,head,ptrfield,sizeof(void *),add,replaced)

local HASH_REPLACE_PTR	(		local,
			local,
			local
	)		HASH_REPLACE(hh,head,ptrfield,sizeof(void *),add,replaced)

#define HASH_REPLACE_STR	(		head,
			strfield,
			add,
			replaced
	)		HASH_REPLACE(hh,head,strfield,strlen(add->strfield),add,replaced)

var HASH_REPLACE_STR	(		var,
			var,
			var,
			var
	)		HASH_REPLACE(hh,head,strfield,strlen(add->strfield),add,replaced)

local HASH_REPLACE_STR	(		local,
			local,
			local,
			local
	)		HASH_REPLACE(hh,head,strfield,strlen(add->strfield),add,replaced)

#define HASH_SAX	(		key,
			keylen,
			num_bkts,
			hashv,
			bkt
	)

Value:

do {                                                                             \
  unsigned _sx_i;                                                                \
  char *_hs_key=(char*)(key);                                                    \
  hashv = 0;                                                                     \
  for(_sx_i=0; _sx_i < keylen; _sx_i++)                                          \
      hashv ^= (hashv << 5) + (hashv >> 2) + _hs_key[_sx_i];                     \
  bkt = hashv & (num_bkts-1);                                                    \
} while (0)

#define HASH_SELECT	(		hh_dst,
			dst,
			hh_src,
			src,
			cond
	)

#define HASH_SFH	(		key,
			keylen,
			num_bkts,
			hashv,
			bkt
	)

var HASH_SFH	(		var,
			var,
			var,
			var,
			var
	)

local HASH_SFH	(		local,
			local,
			local,
			local,
			local
	)

#define HASH_SIGNATURE   0xa0111fe1

var HASH_SIGNATURE   0xa0111fe1

local HASH_SIGNATURE   0xa0111fe1

#define HASH_SORT	(		head,
			cmpfcn
	)		HASH_SRT(hh,head,cmpfcn)

var HASH_SORT	(		var,
			var
	)		HASH_SRT(hh,head,cmpfcn)

local HASH_SORT	(		local,
			local
	)		HASH_SRT(hh,head,cmpfcn)

#define HASH_SRT	(		hh,
			head,
			cmpfcn
	)

#define HASH_TO_BKT	(		hashv,
			num_bkts,
			bkt
	)

Value:

do {                                                                             \
  bkt = ((hashv) & ((num_bkts) - 1));                                            \
} while(0)

#define uthash_expand_fyi

(

tbl

)

/* can be defined to log expands */

var uthash_expand_fyi

(

var

)

/* can be defined to log expands */

local uthash_expand_fyi

(

local

)

/* can be defined to log expands */

#define uthash_fatal

(

msg

)

exit(-1) /* fatal error (out of memory,etc) */

var uthash_fatal

(

var

)

exit(-1) /* fatal error (out of memory,etc) */

local uthash_fatal

(

local

)

exit(-1) /* fatal error (out of memory,etc) */

#define uthash_free	(		ptr,
			sz
	)		free(ptr) /* free fcn */

var uthash_free	(		var,
			var
	)		free(ptr) /* free fcn */

local uthash_free	(		local,
			local
	)		free(ptr) /* free fcn */

#define uthash_malloc

(

sz

)

malloc(sz) /* malloc fcn */

var uthash_malloc

(

var

)

malloc(sz) /* malloc fcn */

#define uthash_noexpand_fyi

(

tbl

)

/* can be defined to log noexpand */

var uthash_noexpand_fyi

(

var

)

/* can be defined to log noexpand */

local uthash_noexpand_fyi

(

local

)

/* can be defined to log noexpand */

#define UTHASH_VERSION   1.9.8

var UTHASH_VERSION   1.9.8

local UTHASH_VERSION   1.9.8