ESAPI-C 1.0
The OWASP Enterprise Security API for C

uthash.h File Reference

A hashing container implementation using macros. More...

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

Go to the source code of this file.

Data Structures

struct  UT_hash_bucket
struct  UT_hash_table
struct  UT_hash_handle

Defines

#define DECLTYPE(x)   (__typeof(x))
#define DECLTYPE_ASSIGN(dst, src)
#define UTHASH_VERSION   1.9.3
#define uthash_fatal(msg)   exit(-1)
#define uthash_malloc(sz)   malloc(sz)
#define uthash_free(ptr, sz)   free(ptr)
#define uthash_noexpand_fyi(tbl)
#define uthash_expand_fyi(tbl)
#define HASH_INITIAL_NUM_BUCKETS   32
#define HASH_INITIAL_NUM_BUCKETS_LOG2   5
#define HASH_BKT_CAPACITY_THRESH   10
#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_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_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_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_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_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_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

Typedefs

typedef struct UT_hash_bucket UT_hash_bucket
typedef struct UT_hash_table UT_hash_table
typedef struct UT_hash_handle UT_hash_handle

Detailed Description

A hashing container implementation using macros.

See also:
http://uthash.sourceforge.net/uthash

Definition in file uthash.h.


Define Documentation

#define DECLTYPE (   x)    (__typeof(x))

LICENSE

Copyright (c) 2003-2010, Troy D. Hanson http://uthash.sourceforge.net 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.

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.

Definition at line 50 of file uthash.h.

#define DECLTYPE_ASSIGN (   dst,
  src 
)
Value:
do {                                                                             \
  (dst) = DECLTYPE(dst)(src);                                                    \
} while(0)

Definition at line 60 of file uthash.h.

#define get16bits (   d)
Value:
((((uint32_t)(((const uint8_t *)(d))[1])) << 8)             \
                       +(uint32_t)(((const uint8_t *)(d))[0]) )

Definition at line 444 of file uthash.h.

#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 = 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)

Definition at line 158 of file uthash.h.

#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)

Definition at line 658 of file uthash.h.

#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)

Definition at line 334 of file uthash.h.

#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));      \
    uthash_free((head)->hh.tbl, sizeof(UT_hash_table));                          \
    (head)=NULL;                                                                 \
  }                                                                              \
} while(0)

Definition at line 888 of file uthash.h.

#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;                              \
    }

Definition at line 672 of file uthash.h.

#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)

Definition at line 90 of file uthash.h.

#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)

Definition at line 644 of file uthash.h.

#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);

Definition at line 356 of file uthash.h.

#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))

Definition at line 903 of file uthash.h.

#define HASH_JEN_MIX (   a,
  b,
 
)
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)

Definition at line 382 of file uthash.h.

#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)

Definition at line 136 of file uthash.h.

#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)

Definition at line 366 of file uthash.h.

#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)

Definition at line 346 of file uthash.h.

#define HASH_TO_BKT (   hashv,
  num_bkts,
  bkt 
)
Value:
do {                                                                             \
  bkt = ((hashv) & ((num_bkts) - 1));                                            \
} while(0)

Definition at line 183 of file uthash.h.

 All Data Structures Files Functions Variables Typedefs Defines