modbusd
modbus master daemon
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros
uthash.h
Go to the documentation of this file.
1 /*
2 Copyright (c) 2003-2016, Troy D. Hanson http://troydhanson.github.com/uthash/
3 All rights reserved.
4 
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions are met:
7 
8  * Redistributions of source code must retain the above copyright
9  notice, this list of conditions and the following disclaimer.
10 
11 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
12 IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
13 TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
14 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
15 OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
16 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
17 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
18 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
19 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
20 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
21 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22 */
23 
24 #ifndef UTHASH_H
25 #define UTHASH_H
26 
27 #define UTHASH_VERSION 2.0.1
28 
29 #include <string.h> /* memcmp,strlen */
30 #include <stddef.h> /* ptrdiff_t */
31 #include <stdlib.h> /* exit() */
32 
33 /* These macros use decltype or the earlier __typeof GNU extension.
34  As decltype is only available in newer compilers (VS2010 or gcc 4.3+
35  when compiling c++ source) this code uses whatever method is needed
36  or, for VS2008 where neither is available, uses casting workarounds. */
37 #if defined(_MSC_VER) /* MS compiler */
38 #if _MSC_VER >= 1600 && defined(__cplusplus) /* VS2010 or newer in C++ mode */
39 #define DECLTYPE(x) (decltype(x))
40 #else /* VS2008 or older (or VS2010 in C mode) */
41 #define NO_DECLTYPE
42 #define DECLTYPE(x)
43 #endif
44 #elif defined(__BORLANDC__) || defined(__LCC__) || defined(__WATCOMC__)
45 #define NO_DECLTYPE
46 #define DECLTYPE(x)
47 #else /* GNU, Sun and other compilers */
48 #define DECLTYPE(x) (__typeof(x))
49 #endif
50 
51 #ifdef NO_DECLTYPE
52 #define DECLTYPE_ASSIGN(dst,src) \
53 do { \
54  char **_da_dst = (char**)(&(dst)); \
55  *_da_dst = (char*)(src); \
56 } while (0)
57 #else
58 #define DECLTYPE_ASSIGN(dst,src) \
59 do { \
60  (dst) = DECLTYPE(dst)(src); \
61 } while (0)
62 #endif
63 
64 /* a number of the hash function use uint32_t which isn't defined on Pre VS2010 */
65 #if defined(_WIN32)
66 #if defined(_MSC_VER) && _MSC_VER >= 1600
67 #include <stdint.h>
68 #elif defined(__WATCOMC__) || defined(__MINGW32__) || defined(__CYGWIN__)
69 #include <stdint.h>
70 #else
71 typedef unsigned int uint32_t;
72 typedef unsigned char uint8_t;
73 #endif
74 #elif defined(__GNUC__) && !defined(__VXWORKS__)
75 #include <stdint.h>
76 #else
77 typedef unsigned int uint32_t;
78 typedef unsigned char uint8_t;
79 #endif
80 
81 #ifndef uthash_fatal
82 #define uthash_fatal(msg) exit(-1) /* fatal error (out of memory,etc) */
83 #endif
84 #ifndef uthash_malloc
85 #define uthash_malloc(sz) malloc(sz) /* malloc fcn */
86 #endif
87 #ifndef uthash_free
88 #define uthash_free(ptr,sz) free(ptr) /* free fcn */
89 #endif
90 #ifndef uthash_strlen
91 #define uthash_strlen(s) strlen(s)
92 #endif
93 #ifndef uthash_memcmp
94 #define uthash_memcmp(a,b,n) memcmp(a,b,n)
95 #endif
96 
97 #ifndef uthash_noexpand_fyi
98 #define uthash_noexpand_fyi(tbl) /* can be defined to log noexpand */
99 #endif
100 #ifndef uthash_expand_fyi
101 #define uthash_expand_fyi(tbl) /* can be defined to log expands */
102 #endif
103 
104 /* initial number of buckets */
105 #define HASH_INITIAL_NUM_BUCKETS 32U /* initial number of buckets */
106 #define HASH_INITIAL_NUM_BUCKETS_LOG2 5U /* lg2 of initial number of buckets */
107 #define HASH_BKT_CAPACITY_THRESH 10U /* expand when bucket count reaches */
108 
109 /* calculate the element whose hash handle address is hhp */
110 #define ELMT_FROM_HH(tbl,hhp) ((void*)(((char*)(hhp)) - ((tbl)->hho)))
111 /* calculate the hash handle from element address elp */
112 #define HH_FROM_ELMT(tbl,elp) ((UT_hash_handle *)(((char*)(elp)) + ((tbl)->hho)))
113 
114 #define HASH_VALUE(keyptr,keylen,hashv) \
115 do { \
116  HASH_FCN(keyptr, keylen, hashv); \
117 } while (0)
118 
119 #define HASH_FIND_BYHASHVALUE(hh,head,keyptr,keylen,hashval,out) \
120 do { \
121  (out) = NULL; \
122  if (head) { \
123  unsigned _hf_bkt; \
124  HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _hf_bkt); \
125  if (HASH_BLOOM_TEST((head)->hh.tbl, hashval) != 0) { \
126  HASH_FIND_IN_BKT((head)->hh.tbl, hh, (head)->hh.tbl->buckets[ _hf_bkt ], keyptr, keylen, hashval, out); \
127  } \
128  } \
129 } while (0)
130 
131 #define HASH_FIND(hh,head,keyptr,keylen,out) \
132 do { \
133  unsigned _hf_hashv; \
134  HASH_VALUE(keyptr, keylen, _hf_hashv); \
135  HASH_FIND_BYHASHVALUE(hh, head, keyptr, keylen, _hf_hashv, out); \
136 } while (0)
137 
138 #ifdef HASH_BLOOM
139 #define HASH_BLOOM_BITLEN (1UL << HASH_BLOOM)
140 #define HASH_BLOOM_BYTELEN (HASH_BLOOM_BITLEN/8UL) + (((HASH_BLOOM_BITLEN%8UL)!=0UL) ? 1UL : 0UL)
141 #define HASH_BLOOM_MAKE(tbl) \
142 do { \
143  (tbl)->bloom_nbits = HASH_BLOOM; \
144  (tbl)->bloom_bv = (uint8_t*)uthash_malloc(HASH_BLOOM_BYTELEN); \
145  if (!((tbl)->bloom_bv)) { uthash_fatal( "out of memory"); } \
146  memset((tbl)->bloom_bv, 0, HASH_BLOOM_BYTELEN); \
147  (tbl)->bloom_sig = HASH_BLOOM_SIGNATURE; \
148 } while (0)
149 
150 #define HASH_BLOOM_FREE(tbl) \
151 do { \
152  uthash_free((tbl)->bloom_bv, HASH_BLOOM_BYTELEN); \
153 } while (0)
154 
155 #define HASH_BLOOM_BITSET(bv,idx) (bv[(idx)/8U] |= (1U << ((idx)%8U)))
156 #define HASH_BLOOM_BITTEST(bv,idx) (bv[(idx)/8U] & (1U << ((idx)%8U)))
157 
158 #define HASH_BLOOM_ADD(tbl,hashv) \
159  HASH_BLOOM_BITSET((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1U)))
160 
161 #define HASH_BLOOM_TEST(tbl,hashv) \
162  HASH_BLOOM_BITTEST((tbl)->bloom_bv, (hashv & (uint32_t)((1ULL << (tbl)->bloom_nbits) - 1U)))
163 
164 #else
165 #define HASH_BLOOM_MAKE(tbl)
166 #define HASH_BLOOM_FREE(tbl)
167 #define HASH_BLOOM_ADD(tbl,hashv)
168 #define HASH_BLOOM_TEST(tbl,hashv) (1)
169 #define HASH_BLOOM_BYTELEN 0U
170 #endif
171 
172 #define HASH_MAKE_TABLE(hh,head) \
173 do { \
174  (head)->hh.tbl = (UT_hash_table*)uthash_malloc( \
175  sizeof(UT_hash_table)); \
176  if (!((head)->hh.tbl)) { uthash_fatal( "out of memory"); } \
177  memset((head)->hh.tbl, 0, sizeof(UT_hash_table)); \
178  (head)->hh.tbl->tail = &((head)->hh); \
179  (head)->hh.tbl->num_buckets = HASH_INITIAL_NUM_BUCKETS; \
180  (head)->hh.tbl->log2_num_buckets = HASH_INITIAL_NUM_BUCKETS_LOG2; \
181  (head)->hh.tbl->hho = (char*)(&(head)->hh) - (char*)(head); \
182  (head)->hh.tbl->buckets = (UT_hash_bucket*)uthash_malloc( \
183  HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket)); \
184  if (! (head)->hh.tbl->buckets) { uthash_fatal( "out of memory"); } \
185  memset((head)->hh.tbl->buckets, 0, \
186  HASH_INITIAL_NUM_BUCKETS*sizeof(struct UT_hash_bucket)); \
187  HASH_BLOOM_MAKE((head)->hh.tbl); \
188  (head)->hh.tbl->signature = HASH_SIGNATURE; \
189 } while (0)
190 
191 #define HASH_REPLACE_BYHASHVALUE_INORDER(hh,head,fieldname,keylen_in,hashval,add,replaced,cmpfcn) \
192 do { \
193  (replaced) = NULL; \
194  HASH_FIND_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, replaced); \
195  if (replaced) { \
196  HASH_DELETE(hh, head, replaced); \
197  } \
198  HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, &((add)->fieldname), keylen_in, hashval, add, cmpfcn); \
199 } while (0)
200 
201 #define HASH_REPLACE_BYHASHVALUE(hh,head,fieldname,keylen_in,hashval,add,replaced) \
202 do { \
203  (replaced) = NULL; \
204  HASH_FIND_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, replaced); \
205  if (replaced) { \
206  HASH_DELETE(hh, head, replaced); \
207  } \
208  HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, add); \
209 } while (0)
210 
211 #define HASH_REPLACE(hh,head,fieldname,keylen_in,add,replaced) \
212 do { \
213  unsigned _hr_hashv; \
214  HASH_VALUE(&((add)->fieldname), keylen_in, _hr_hashv); \
215  HASH_REPLACE_BYHASHVALUE(hh, head, fieldname, keylen_in, _hr_hashv, add, replaced); \
216 } while (0)
217 
218 #define HASH_REPLACE_INORDER(hh,head,fieldname,keylen_in,add,replaced,cmpfcn) \
219 do { \
220  unsigned _hr_hashv; \
221  HASH_VALUE(&((add)->fieldname), keylen_in, _hr_hashv); \
222  HASH_REPLACE_BYHASHVALUE_INORDER(hh, head, fieldname, keylen_in, _hr_hashv, add, replaced, cmpfcn); \
223 } while (0)
224 
225 #define HASH_APPEND_LIST(hh, head, add) \
226 do { \
227  (add)->hh.next = NULL; \
228  (add)->hh.prev = ELMT_FROM_HH((head)->hh.tbl, (head)->hh.tbl->tail); \
229  (head)->hh.tbl->tail->next = (add); \
230  (head)->hh.tbl->tail = &((add)->hh); \
231 } while (0)
232 
233 #define HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh,head,keyptr,keylen_in,hashval,add,cmpfcn) \
234 do { \
235  unsigned _ha_bkt; \
236  (add)->hh.hashv = (hashval); \
237  (add)->hh.key = (char*) (keyptr); \
238  (add)->hh.keylen = (unsigned) (keylen_in); \
239  if (!(head)) { \
240  (add)->hh.next = NULL; \
241  (add)->hh.prev = NULL; \
242  (head) = (add); \
243  HASH_MAKE_TABLE(hh, head); \
244  } else { \
245  struct UT_hash_handle *_hs_iter = &(head)->hh; \
246  (add)->hh.tbl = (head)->hh.tbl; \
247  do { \
248  if (cmpfcn(DECLTYPE(head) ELMT_FROM_HH((head)->hh.tbl, _hs_iter), add) > 0) \
249  break; \
250  } while ((_hs_iter = _hs_iter->next)); \
251  if (_hs_iter) { \
252  (add)->hh.next = _hs_iter; \
253  if (((add)->hh.prev = _hs_iter->prev)) { \
254  HH_FROM_ELMT((head)->hh.tbl, _hs_iter->prev)->next = (add); \
255  } else { \
256  (head) = (add); \
257  } \
258  _hs_iter->prev = (add); \
259  } else { \
260  HASH_APPEND_LIST(hh, head, add); \
261  } \
262  } \
263  (head)->hh.tbl->num_items++; \
264  HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _ha_bkt); \
265  HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt], &(add)->hh); \
266  HASH_BLOOM_ADD((head)->hh.tbl, hashval); \
267  HASH_EMIT_KEY(hh, head, keyptr, keylen_in); \
268  HASH_FSCK(hh, head); \
269 } while (0)
270 
271 #define HASH_ADD_KEYPTR_INORDER(hh,head,keyptr,keylen_in,add,cmpfcn) \
272 do { \
273  unsigned _hs_hashv; \
274  HASH_VALUE(keyptr, keylen_in, _hs_hashv); \
275  HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, keyptr, keylen_in, _hs_hashv, add, cmpfcn); \
276 } while (0)
277 
278 #define HASH_ADD_BYHASHVALUE_INORDER(hh,head,fieldname,keylen_in,hashval,add,cmpfcn) \
279  HASH_ADD_KEYPTR_BYHASHVALUE_INORDER(hh, head, &((add)->fieldname), keylen_in, hashval, add, cmpfcn)
280 
281 #define HASH_ADD_INORDER(hh,head,fieldname,keylen_in,add,cmpfcn) \
282  HASH_ADD_KEYPTR_INORDER(hh, head, &((add)->fieldname), keylen_in, add, cmpfcn)
283 
284 #define HASH_ADD_KEYPTR_BYHASHVALUE(hh,head,keyptr,keylen_in,hashval,add) \
285 do { \
286  unsigned _ha_bkt; \
287  (add)->hh.hashv = (hashval); \
288  (add)->hh.key = (char*) (keyptr); \
289  (add)->hh.keylen = (unsigned) (keylen_in); \
290  if (!(head)) { \
291  (add)->hh.next = NULL; \
292  (add)->hh.prev = NULL; \
293  (head) = (add); \
294  HASH_MAKE_TABLE(hh, head); \
295  } else { \
296  (add)->hh.tbl = (head)->hh.tbl; \
297  HASH_APPEND_LIST(hh, head, add); \
298  } \
299  (head)->hh.tbl->num_items++; \
300  HASH_TO_BKT(hashval, (head)->hh.tbl->num_buckets, _ha_bkt); \
301  HASH_ADD_TO_BKT((head)->hh.tbl->buckets[_ha_bkt], &(add)->hh); \
302  HASH_BLOOM_ADD((head)->hh.tbl, hashval); \
303  HASH_EMIT_KEY(hh, head, keyptr, keylen_in); \
304  HASH_FSCK(hh, head); \
305 } while (0)
306 
307 #define HASH_ADD_KEYPTR(hh,head,keyptr,keylen_in,add) \
308 do { \
309  unsigned _ha_hashv; \
310  HASH_VALUE(keyptr, keylen_in, _ha_hashv); \
311  HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, keyptr, keylen_in, _ha_hashv, add); \
312 } while (0)
313 
314 #define HASH_ADD_BYHASHVALUE(hh,head,fieldname,keylen_in,hashval,add) \
315  HASH_ADD_KEYPTR_BYHASHVALUE(hh, head, &((add)->fieldname), keylen_in, hashval, add)
316 
317 #define HASH_ADD(hh,head,fieldname,keylen_in,add) \
318  HASH_ADD_KEYPTR(hh, head, &((add)->fieldname), keylen_in, add)
319 
320 #define HASH_TO_BKT(hashv,num_bkts,bkt) \
321 do { \
322  bkt = ((hashv) & ((num_bkts) - 1U)); \
323 } while (0)
324 
325 /* delete "delptr" from the hash table.
326  * "the usual" patch-up process for the app-order doubly-linked-list.
327  * The use of _hd_hh_del below deserves special explanation.
328  * These used to be expressed using (delptr) but that led to a bug
329  * if someone used the same symbol for the head and deletee, like
330  * HASH_DELETE(hh,users,users);
331  * We want that to work, but by changing the head (users) below
332  * we were forfeiting our ability to further refer to the deletee (users)
333  * in the patch-up process. Solution: use scratch space to
334  * copy the deletee pointer, then the latter references are via that
335  * scratch pointer rather than through the repointed (users) symbol.
336  */
337 #define HASH_DELETE(hh,head,delptr) \
338 do { \
339  struct UT_hash_handle *_hd_hh_del; \
340  if ( ((delptr)->hh.prev == NULL) && ((delptr)->hh.next == NULL) ) { \
341  uthash_free((head)->hh.tbl->buckets, \
342  (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket) ); \
343  HASH_BLOOM_FREE((head)->hh.tbl); \
344  uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); \
345  head = NULL; \
346  } else { \
347  unsigned _hd_bkt; \
348  _hd_hh_del = &((delptr)->hh); \
349  if ((delptr) == ELMT_FROM_HH((head)->hh.tbl,(head)->hh.tbl->tail)) { \
350  (head)->hh.tbl->tail = \
351  (UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) + \
352  (head)->hh.tbl->hho); \
353  } \
354  if ((delptr)->hh.prev != NULL) { \
355  ((UT_hash_handle*)((ptrdiff_t)((delptr)->hh.prev) + \
356  (head)->hh.tbl->hho))->next = (delptr)->hh.next; \
357  } else { \
358  DECLTYPE_ASSIGN(head,(delptr)->hh.next); \
359  } \
360  if (_hd_hh_del->next != NULL) { \
361  ((UT_hash_handle*)((ptrdiff_t)_hd_hh_del->next + \
362  (head)->hh.tbl->hho))->prev = \
363  _hd_hh_del->prev; \
364  } \
365  HASH_TO_BKT( _hd_hh_del->hashv, (head)->hh.tbl->num_buckets, _hd_bkt); \
366  HASH_DEL_IN_BKT(hh,(head)->hh.tbl->buckets[_hd_bkt], _hd_hh_del); \
367  (head)->hh.tbl->num_items--; \
368  } \
369  HASH_FSCK(hh,head); \
370 } while (0)
371 
372 
373 /* convenience forms of HASH_FIND/HASH_ADD/HASH_DEL */
374 #define HASH_FIND_STR(head,findstr,out) \
375  HASH_FIND(hh,head,findstr,(unsigned)uthash_strlen(findstr),out)
376 #define HASH_ADD_STR(head,strfield,add) \
377  HASH_ADD(hh,head,strfield[0],(unsigned)uthash_strlen(add->strfield),add)
378 #define HASH_REPLACE_STR(head,strfield,add,replaced) \
379  HASH_REPLACE(hh,head,strfield[0],(unsigned)uthash_strlen(add->strfield),add,replaced)
380 #define HASH_FIND_INT(head,findint,out) \
381  HASH_FIND(hh,head,findint,sizeof(int),out)
382 #define HASH_ADD_INT(head,intfield,add) \
383  HASH_ADD(hh,head,intfield,sizeof(int),add)
384 #define HASH_REPLACE_INT(head,intfield,add,replaced) \
385  HASH_REPLACE(hh,head,intfield,sizeof(int),add,replaced)
386 #define HASH_FIND_PTR(head,findptr,out) \
387  HASH_FIND(hh,head,findptr,sizeof(void *),out)
388 #define HASH_ADD_PTR(head,ptrfield,add) \
389  HASH_ADD(hh,head,ptrfield,sizeof(void *),add)
390 #define HASH_REPLACE_PTR(head,ptrfield,add,replaced) \
391  HASH_REPLACE(hh,head,ptrfield,sizeof(void *),add,replaced)
392 #define HASH_DEL(head,delptr) \
393  HASH_DELETE(hh,head,delptr)
394 
395 /* HASH_FSCK checks hash integrity on every add/delete when HASH_DEBUG is defined.
396  * This is for uthash developer only; it compiles away if HASH_DEBUG isn't defined.
397  */
398 #ifdef HASH_DEBUG
399 #define HASH_OOPS(...) do { fprintf(stderr,__VA_ARGS__); exit(-1); } while (0)
400 #define HASH_FSCK(hh,head) \
401 do { \
402  struct UT_hash_handle *_thh; \
403  if (head) { \
404  unsigned _bkt_i; \
405  unsigned _count; \
406  char *_prev; \
407  _count = 0; \
408  for( _bkt_i = 0; _bkt_i < (head)->hh.tbl->num_buckets; _bkt_i++) { \
409  unsigned _bkt_count = 0; \
410  _thh = (head)->hh.tbl->buckets[_bkt_i].hh_head; \
411  _prev = NULL; \
412  while (_thh) { \
413  if (_prev != (char*)(_thh->hh_prev)) { \
414  HASH_OOPS("invalid hh_prev %p, actual %p\n", \
415  _thh->hh_prev, _prev ); \
416  } \
417  _bkt_count++; \
418  _prev = (char*)(_thh); \
419  _thh = _thh->hh_next; \
420  } \
421  _count += _bkt_count; \
422  if ((head)->hh.tbl->buckets[_bkt_i].count != _bkt_count) { \
423  HASH_OOPS("invalid bucket count %u, actual %u\n", \
424  (head)->hh.tbl->buckets[_bkt_i].count, _bkt_count); \
425  } \
426  } \
427  if (_count != (head)->hh.tbl->num_items) { \
428  HASH_OOPS("invalid hh item count %u, actual %u\n", \
429  (head)->hh.tbl->num_items, _count ); \
430  } \
431  /* traverse hh in app order; check next/prev integrity, count */ \
432  _count = 0; \
433  _prev = NULL; \
434  _thh = &(head)->hh; \
435  while (_thh) { \
436  _count++; \
437  if (_prev !=(char*)(_thh->prev)) { \
438  HASH_OOPS("invalid prev %p, actual %p\n", \
439  _thh->prev, _prev ); \
440  } \
441  _prev = (char*)ELMT_FROM_HH((head)->hh.tbl, _thh); \
442  _thh = ( _thh->next ? (UT_hash_handle*)((char*)(_thh->next) + \
443  (head)->hh.tbl->hho) : NULL ); \
444  } \
445  if (_count != (head)->hh.tbl->num_items) { \
446  HASH_OOPS("invalid app item count %u, actual %u\n", \
447  (head)->hh.tbl->num_items, _count ); \
448  } \
449  } \
450 } while (0)
451 #else
452 #define HASH_FSCK(hh,head)
453 #endif
454 
455 /* When compiled with -DHASH_EMIT_KEYS, length-prefixed keys are emitted to
456  * the descriptor to which this macro is defined for tuning the hash function.
457  * The app can #include <unistd.h> to get the prototype for write(2). */
458 #ifdef HASH_EMIT_KEYS
459 #define HASH_EMIT_KEY(hh,head,keyptr,fieldlen) \
460 do { \
461  unsigned _klen = fieldlen; \
462  write(HASH_EMIT_KEYS, &_klen, sizeof(_klen)); \
463  write(HASH_EMIT_KEYS, keyptr, (unsigned long)fieldlen); \
464 } while (0)
465 #else
466 #define HASH_EMIT_KEY(hh,head,keyptr,fieldlen)
467 #endif
468 
469 /* default to Jenkin's hash unless overridden e.g. DHASH_FUNCTION=HASH_SAX */
470 #ifdef HASH_FUNCTION
471 #define HASH_FCN HASH_FUNCTION
472 #else
473 #define HASH_FCN HASH_JEN
474 #endif
475 
476 /* The Bernstein hash function, used in Perl prior to v5.6. Note (x<<5+x)=x*33. */
477 #define HASH_BER(key,keylen,hashv) \
478 do { \
479  unsigned _hb_keylen=(unsigned)keylen; \
480  const unsigned char *_hb_key=(const unsigned char*)(key); \
481  (hashv) = 0; \
482  while (_hb_keylen-- != 0U) { \
483  (hashv) = (((hashv) << 5) + (hashv)) + *_hb_key++; \
484  } \
485 } while (0)
486 
487 
488 /* SAX/FNV/OAT/JEN hash functions are macro variants of those listed at
489  * http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx */
490 #define HASH_SAX(key,keylen,hashv) \
491 do { \
492  unsigned _sx_i; \
493  const unsigned char *_hs_key=(const unsigned char*)(key); \
494  hashv = 0; \
495  for(_sx_i=0; _sx_i < keylen; _sx_i++) { \
496  hashv ^= (hashv << 5) + (hashv >> 2) + _hs_key[_sx_i]; \
497  } \
498 } while (0)
499 /* FNV-1a variation */
500 #define HASH_FNV(key,keylen,hashv) \
501 do { \
502  unsigned _fn_i; \
503  const unsigned char *_hf_key=(const unsigned char*)(key); \
504  hashv = 2166136261U; \
505  for(_fn_i=0; _fn_i < keylen; _fn_i++) { \
506  hashv = hashv ^ _hf_key[_fn_i]; \
507  hashv = hashv * 16777619U; \
508  } \
509 } while (0)
510 
511 #define HASH_OAT(key,keylen,hashv) \
512 do { \
513  unsigned _ho_i; \
514  const unsigned char *_ho_key=(const unsigned char*)(key); \
515  hashv = 0; \
516  for(_ho_i=0; _ho_i < keylen; _ho_i++) { \
517  hashv += _ho_key[_ho_i]; \
518  hashv += (hashv << 10); \
519  hashv ^= (hashv >> 6); \
520  } \
521  hashv += (hashv << 3); \
522  hashv ^= (hashv >> 11); \
523  hashv += (hashv << 15); \
524 } while (0)
525 
526 #define HASH_JEN_MIX(a,b,c) \
527 do { \
528  a -= b; a -= c; a ^= ( c >> 13 ); \
529  b -= c; b -= a; b ^= ( a << 8 ); \
530  c -= a; c -= b; c ^= ( b >> 13 ); \
531  a -= b; a -= c; a ^= ( c >> 12 ); \
532  b -= c; b -= a; b ^= ( a << 16 ); \
533  c -= a; c -= b; c ^= ( b >> 5 ); \
534  a -= b; a -= c; a ^= ( c >> 3 ); \
535  b -= c; b -= a; b ^= ( a << 10 ); \
536  c -= a; c -= b; c ^= ( b >> 15 ); \
537 } while (0)
538 
539 #define HASH_JEN(key,keylen,hashv) \
540 do { \
541  unsigned _hj_i,_hj_j,_hj_k; \
542  unsigned const char *_hj_key=(unsigned const char*)(key); \
543  hashv = 0xfeedbeefu; \
544  _hj_i = _hj_j = 0x9e3779b9u; \
545  _hj_k = (unsigned)(keylen); \
546  while (_hj_k >= 12U) { \
547  _hj_i += (_hj_key[0] + ( (unsigned)_hj_key[1] << 8 ) \
548  + ( (unsigned)_hj_key[2] << 16 ) \
549  + ( (unsigned)_hj_key[3] << 24 ) ); \
550  _hj_j += (_hj_key[4] + ( (unsigned)_hj_key[5] << 8 ) \
551  + ( (unsigned)_hj_key[6] << 16 ) \
552  + ( (unsigned)_hj_key[7] << 24 ) ); \
553  hashv += (_hj_key[8] + ( (unsigned)_hj_key[9] << 8 ) \
554  + ( (unsigned)_hj_key[10] << 16 ) \
555  + ( (unsigned)_hj_key[11] << 24 ) ); \
556  \
557  HASH_JEN_MIX(_hj_i, _hj_j, hashv); \
558  \
559  _hj_key += 12; \
560  _hj_k -= 12U; \
561  } \
562  hashv += (unsigned)(keylen); \
563  switch ( _hj_k ) { \
564  case 11: hashv += ( (unsigned)_hj_key[10] << 24 ); /* FALLTHROUGH */ \
565  case 10: hashv += ( (unsigned)_hj_key[9] << 16 ); /* FALLTHROUGH */ \
566  case 9: hashv += ( (unsigned)_hj_key[8] << 8 ); /* FALLTHROUGH */ \
567  case 8: _hj_j += ( (unsigned)_hj_key[7] << 24 ); /* FALLTHROUGH */ \
568  case 7: _hj_j += ( (unsigned)_hj_key[6] << 16 ); /* FALLTHROUGH */ \
569  case 6: _hj_j += ( (unsigned)_hj_key[5] << 8 ); /* FALLTHROUGH */ \
570  case 5: _hj_j += _hj_key[4]; /* FALLTHROUGH */ \
571  case 4: _hj_i += ( (unsigned)_hj_key[3] << 24 ); /* FALLTHROUGH */ \
572  case 3: _hj_i += ( (unsigned)_hj_key[2] << 16 ); /* FALLTHROUGH */ \
573  case 2: _hj_i += ( (unsigned)_hj_key[1] << 8 ); /* FALLTHROUGH */ \
574  case 1: _hj_i += _hj_key[0]; \
575  } \
576  HASH_JEN_MIX(_hj_i, _hj_j, hashv); \
577 } while (0)
578 
579 /* The Paul Hsieh hash function */
580 #undef get16bits
581 #if (defined(__GNUC__) && defined(__i386__)) || defined(__WATCOMC__) \
582  || defined(_MSC_VER) || defined (__BORLANDC__) || defined (__TURBOC__)
583 #define get16bits(d) (*((const uint16_t *) (d)))
584 #endif
585 
586 #if !defined (get16bits)
587 #define get16bits(d) ((((uint32_t)(((const uint8_t *)(d))[1])) << 8) \
588  +(uint32_t)(((const uint8_t *)(d))[0]) )
589 #endif
590 #define HASH_SFH(key,keylen,hashv) \
591 do { \
592  unsigned const char *_sfh_key=(unsigned const char*)(key); \
593  uint32_t _sfh_tmp, _sfh_len = (uint32_t)keylen; \
594  \
595  unsigned _sfh_rem = _sfh_len & 3U; \
596  _sfh_len >>= 2; \
597  hashv = 0xcafebabeu; \
598  \
599  /* Main loop */ \
600  for (;_sfh_len > 0U; _sfh_len--) { \
601  hashv += get16bits (_sfh_key); \
602  _sfh_tmp = ((uint32_t)(get16bits (_sfh_key+2)) << 11) ^ hashv; \
603  hashv = (hashv << 16) ^ _sfh_tmp; \
604  _sfh_key += 2U*sizeof (uint16_t); \
605  hashv += hashv >> 11; \
606  } \
607  \
608  /* Handle end cases */ \
609  switch (_sfh_rem) { \
610  case 3: hashv += get16bits (_sfh_key); \
611  hashv ^= hashv << 16; \
612  hashv ^= (uint32_t)(_sfh_key[sizeof (uint16_t)]) << 18; \
613  hashv += hashv >> 11; \
614  break; \
615  case 2: hashv += get16bits (_sfh_key); \
616  hashv ^= hashv << 11; \
617  hashv += hashv >> 17; \
618  break; \
619  case 1: hashv += *_sfh_key; \
620  hashv ^= hashv << 10; \
621  hashv += hashv >> 1; \
622  } \
623  \
624  /* Force "avalanching" of final 127 bits */ \
625  hashv ^= hashv << 3; \
626  hashv += hashv >> 5; \
627  hashv ^= hashv << 4; \
628  hashv += hashv >> 17; \
629  hashv ^= hashv << 25; \
630  hashv += hashv >> 6; \
631 } while (0)
632 
633 #ifdef HASH_USING_NO_STRICT_ALIASING
634 /* The MurmurHash exploits some CPU's (x86,x86_64) tolerance for unaligned reads.
635  * For other types of CPU's (e.g. Sparc) an unaligned read causes a bus error.
636  * MurmurHash uses the faster approach only on CPU's where we know it's safe.
637  *
638  * Note the preprocessor built-in defines can be emitted using:
639  *
640  * gcc -m64 -dM -E - < /dev/null (on gcc)
641  * cc -## a.c (where a.c is a simple test file) (Sun Studio)
642  */
643 #if (defined(__i386__) || defined(__x86_64__) || defined(_M_IX86))
644 #define MUR_GETBLOCK(p,i) p[i]
645 #else /* non intel */
646 #define MUR_PLUS0_ALIGNED(p) (((unsigned long)p & 3UL) == 0UL)
647 #define MUR_PLUS1_ALIGNED(p) (((unsigned long)p & 3UL) == 1UL)
648 #define MUR_PLUS2_ALIGNED(p) (((unsigned long)p & 3UL) == 2UL)
649 #define MUR_PLUS3_ALIGNED(p) (((unsigned long)p & 3UL) == 3UL)
650 #define WP(p) ((uint32_t*)((unsigned long)(p) & ~3UL))
651 #if (defined(__BIG_ENDIAN__) || defined(SPARC) || defined(__ppc__) || defined(__ppc64__))
652 #define MUR_THREE_ONE(p) ((((*WP(p))&0x00ffffff) << 8) | (((*(WP(p)+1))&0xff000000) >> 24))
653 #define MUR_TWO_TWO(p) ((((*WP(p))&0x0000ffff) <<16) | (((*(WP(p)+1))&0xffff0000) >> 16))
654 #define MUR_ONE_THREE(p) ((((*WP(p))&0x000000ff) <<24) | (((*(WP(p)+1))&0xffffff00) >> 8))
655 #else /* assume little endian non-intel */
656 #define MUR_THREE_ONE(p) ((((*WP(p))&0xffffff00) >> 8) | (((*(WP(p)+1))&0x000000ff) << 24))
657 #define MUR_TWO_TWO(p) ((((*WP(p))&0xffff0000) >>16) | (((*(WP(p)+1))&0x0000ffff) << 16))
658 #define MUR_ONE_THREE(p) ((((*WP(p))&0xff000000) >>24) | (((*(WP(p)+1))&0x00ffffff) << 8))
659 #endif
660 #define MUR_GETBLOCK(p,i) (MUR_PLUS0_ALIGNED(p) ? ((p)[i]) : \
661  (MUR_PLUS1_ALIGNED(p) ? MUR_THREE_ONE(p) : \
662  (MUR_PLUS2_ALIGNED(p) ? MUR_TWO_TWO(p) : \
663  MUR_ONE_THREE(p))))
664 #endif
665 #define MUR_ROTL32(x,r) (((x) << (r)) | ((x) >> (32 - (r))))
666 #define MUR_FMIX(_h) \
667 do { \
668  _h ^= _h >> 16; \
669  _h *= 0x85ebca6bu; \
670  _h ^= _h >> 13; \
671  _h *= 0xc2b2ae35u; \
672  _h ^= _h >> 16; \
673 } while (0)
674 
675 #define HASH_MUR(key,keylen,hashv) \
676 do { \
677  const uint8_t *_mur_data = (const uint8_t*)(key); \
678  const int _mur_nblocks = (int)(keylen) / 4; \
679  uint32_t _mur_h1 = 0xf88D5353u; \
680  uint32_t _mur_c1 = 0xcc9e2d51u; \
681  uint32_t _mur_c2 = 0x1b873593u; \
682  uint32_t _mur_k1 = 0; \
683  const uint8_t *_mur_tail; \
684  const uint32_t *_mur_blocks = (const uint32_t*)(_mur_data+(_mur_nblocks*4)); \
685  int _mur_i; \
686  for(_mur_i = -_mur_nblocks; _mur_i!=0; _mur_i++) { \
687  _mur_k1 = MUR_GETBLOCK(_mur_blocks,_mur_i); \
688  _mur_k1 *= _mur_c1; \
689  _mur_k1 = MUR_ROTL32(_mur_k1,15); \
690  _mur_k1 *= _mur_c2; \
691  \
692  _mur_h1 ^= _mur_k1; \
693  _mur_h1 = MUR_ROTL32(_mur_h1,13); \
694  _mur_h1 = (_mur_h1*5U) + 0xe6546b64u; \
695  } \
696  _mur_tail = (const uint8_t*)(_mur_data + (_mur_nblocks*4)); \
697  _mur_k1=0; \
698  switch((keylen) & 3U) { \
699  case 3: _mur_k1 ^= (uint32_t)_mur_tail[2] << 16; /* FALLTHROUGH */ \
700  case 2: _mur_k1 ^= (uint32_t)_mur_tail[1] << 8; /* FALLTHROUGH */ \
701  case 1: _mur_k1 ^= (uint32_t)_mur_tail[0]; \
702  _mur_k1 *= _mur_c1; \
703  _mur_k1 = MUR_ROTL32(_mur_k1,15); \
704  _mur_k1 *= _mur_c2; \
705  _mur_h1 ^= _mur_k1; \
706  } \
707  _mur_h1 ^= (uint32_t)(keylen); \
708  MUR_FMIX(_mur_h1); \
709  hashv = _mur_h1; \
710 } while (0)
711 #endif /* HASH_USING_NO_STRICT_ALIASING */
712 
713 /* iterate over items in a known bucket to find desired item */
714 #define HASH_FIND_IN_BKT(tbl,hh,head,keyptr,keylen_in,hashval,out) \
715 do { \
716  if ((head).hh_head != NULL) { \
717  DECLTYPE_ASSIGN(out, ELMT_FROM_HH(tbl, (head).hh_head)); \
718  } else { \
719  (out) = NULL; \
720  } \
721  while ((out) != NULL) { \
722  if ((out)->hh.hashv == (hashval) && (out)->hh.keylen == (keylen_in)) { \
723  if (uthash_memcmp((out)->hh.key, keyptr, keylen_in) == 0) { \
724  break; \
725  } \
726  } \
727  if ((out)->hh.hh_next != NULL) { \
728  DECLTYPE_ASSIGN(out, ELMT_FROM_HH(tbl, (out)->hh.hh_next)); \
729  } else { \
730  (out) = NULL; \
731  } \
732  } \
733 } while (0)
734 
735 /* add an item to a bucket */
736 #define HASH_ADD_TO_BKT(head,addhh) \
737 do { \
738  head.count++; \
739  (addhh)->hh_next = head.hh_head; \
740  (addhh)->hh_prev = NULL; \
741  if (head.hh_head != NULL) { (head).hh_head->hh_prev = (addhh); } \
742  (head).hh_head=addhh; \
743  if ((head.count >= ((head.expand_mult+1U) * HASH_BKT_CAPACITY_THRESH)) \
744  && ((addhh)->tbl->noexpand != 1U)) { \
745  HASH_EXPAND_BUCKETS((addhh)->tbl); \
746  } \
747 } while (0)
748 
749 /* remove an item from a given bucket */
750 #define HASH_DEL_IN_BKT(hh,head,hh_del) \
751  (head).count--; \
752  if ((head).hh_head == hh_del) { \
753  (head).hh_head = hh_del->hh_next; \
754  } \
755  if (hh_del->hh_prev) { \
756  hh_del->hh_prev->hh_next = hh_del->hh_next; \
757  } \
758  if (hh_del->hh_next) { \
759  hh_del->hh_next->hh_prev = hh_del->hh_prev; \
760  }
761 
762 /* Bucket expansion has the effect of doubling the number of buckets
763  * and redistributing the items into the new buckets. Ideally the
764  * items will distribute more or less evenly into the new buckets
765  * (the extent to which this is true is a measure of the quality of
766  * the hash function as it applies to the key domain).
767  *
768  * With the items distributed into more buckets, the chain length
769  * (item count) in each bucket is reduced. Thus by expanding buckets
770  * the hash keeps a bound on the chain length. This bounded chain
771  * length is the essence of how a hash provides constant time lookup.
772  *
773  * The calculation of tbl->ideal_chain_maxlen below deserves some
774  * explanation. First, keep in mind that we're calculating the ideal
775  * maximum chain length based on the *new* (doubled) bucket count.
776  * In fractions this is just n/b (n=number of items,b=new num buckets).
777  * Since the ideal chain length is an integer, we want to calculate
778  * ceil(n/b). We don't depend on floating point arithmetic in this
779  * hash, so to calculate ceil(n/b) with integers we could write
780  *
781  * ceil(n/b) = (n/b) + ((n%b)?1:0)
782  *
783  * and in fact a previous version of this hash did just that.
784  * But now we have improved things a bit by recognizing that b is
785  * always a power of two. We keep its base 2 log handy (call it lb),
786  * so now we can write this with a bit shift and logical AND:
787  *
788  * ceil(n/b) = (n>>lb) + ( (n & (b-1)) ? 1:0)
789  *
790  */
791 #define HASH_EXPAND_BUCKETS(tbl) \
792 do { \
793  unsigned _he_bkt; \
794  unsigned _he_bkt_i; \
795  struct UT_hash_handle *_he_thh, *_he_hh_nxt; \
796  UT_hash_bucket *_he_new_buckets, *_he_newbkt; \
797  _he_new_buckets = (UT_hash_bucket*)uthash_malloc( \
798  2UL * tbl->num_buckets * sizeof(struct UT_hash_bucket)); \
799  if (!_he_new_buckets) { uthash_fatal( "out of memory"); } \
800  memset(_he_new_buckets, 0, \
801  2UL * tbl->num_buckets * sizeof(struct UT_hash_bucket)); \
802  tbl->ideal_chain_maxlen = \
803  (tbl->num_items >> (tbl->log2_num_buckets+1U)) + \
804  (((tbl->num_items & ((tbl->num_buckets*2U)-1U)) != 0U) ? 1U : 0U); \
805  tbl->nonideal_items = 0; \
806  for(_he_bkt_i = 0; _he_bkt_i < tbl->num_buckets; _he_bkt_i++) \
807  { \
808  _he_thh = tbl->buckets[ _he_bkt_i ].hh_head; \
809  while (_he_thh != NULL) { \
810  _he_hh_nxt = _he_thh->hh_next; \
811  HASH_TO_BKT( _he_thh->hashv, tbl->num_buckets*2U, _he_bkt); \
812  _he_newbkt = &(_he_new_buckets[ _he_bkt ]); \
813  if (++(_he_newbkt->count) > tbl->ideal_chain_maxlen) { \
814  tbl->nonideal_items++; \
815  _he_newbkt->expand_mult = _he_newbkt->count / \
816  tbl->ideal_chain_maxlen; \
817  } \
818  _he_thh->hh_prev = NULL; \
819  _he_thh->hh_next = _he_newbkt->hh_head; \
820  if (_he_newbkt->hh_head != NULL) { _he_newbkt->hh_head->hh_prev = \
821  _he_thh; } \
822  _he_newbkt->hh_head = _he_thh; \
823  _he_thh = _he_hh_nxt; \
824  } \
825  } \
826  uthash_free( tbl->buckets, tbl->num_buckets*sizeof(struct UT_hash_bucket) ); \
827  tbl->num_buckets *= 2U; \
828  tbl->log2_num_buckets++; \
829  tbl->buckets = _he_new_buckets; \
830  tbl->ineff_expands = (tbl->nonideal_items > (tbl->num_items >> 1)) ? \
831  (tbl->ineff_expands+1U) : 0U; \
832  if (tbl->ineff_expands > 1U) { \
833  tbl->noexpand=1; \
834  uthash_noexpand_fyi(tbl); \
835  } \
836  uthash_expand_fyi(tbl); \
837 } while (0)
838 
839 
840 /* This is an adaptation of Simon Tatham's O(n log(n)) mergesort */
841 /* Note that HASH_SORT assumes the hash handle name to be hh.
842  * HASH_SRT was added to allow the hash handle name to be passed in. */
843 #define HASH_SORT(head,cmpfcn) HASH_SRT(hh,head,cmpfcn)
844 #define HASH_SRT(hh,head,cmpfcn) \
845 do { \
846  unsigned _hs_i; \
847  unsigned _hs_looping,_hs_nmerges,_hs_insize,_hs_psize,_hs_qsize; \
848  struct UT_hash_handle *_hs_p, *_hs_q, *_hs_e, *_hs_list, *_hs_tail; \
849  if (head != NULL) { \
850  _hs_insize = 1; \
851  _hs_looping = 1; \
852  _hs_list = &((head)->hh); \
853  while (_hs_looping != 0U) { \
854  _hs_p = _hs_list; \
855  _hs_list = NULL; \
856  _hs_tail = NULL; \
857  _hs_nmerges = 0; \
858  while (_hs_p != NULL) { \
859  _hs_nmerges++; \
860  _hs_q = _hs_p; \
861  _hs_psize = 0; \
862  for ( _hs_i = 0; _hs_i < _hs_insize; _hs_i++ ) { \
863  _hs_psize++; \
864  _hs_q = (UT_hash_handle*)((_hs_q->next != NULL) ? \
865  ((void*)((char*)(_hs_q->next) + \
866  (head)->hh.tbl->hho)) : NULL); \
867  if (! (_hs_q) ) { break; } \
868  } \
869  _hs_qsize = _hs_insize; \
870  while ((_hs_psize > 0U) || ((_hs_qsize > 0U) && (_hs_q != NULL))) {\
871  if (_hs_psize == 0U) { \
872  _hs_e = _hs_q; \
873  _hs_q = (UT_hash_handle*)((_hs_q->next != NULL) ? \
874  ((void*)((char*)(_hs_q->next) + \
875  (head)->hh.tbl->hho)) : NULL); \
876  _hs_qsize--; \
877  } else if ( (_hs_qsize == 0U) || (_hs_q == NULL) ) { \
878  _hs_e = _hs_p; \
879  if (_hs_p != NULL){ \
880  _hs_p = (UT_hash_handle*)((_hs_p->next != NULL) ? \
881  ((void*)((char*)(_hs_p->next) + \
882  (head)->hh.tbl->hho)) : NULL); \
883  } \
884  _hs_psize--; \
885  } else if (( \
886  cmpfcn(DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_p)), \
887  DECLTYPE(head)(ELMT_FROM_HH((head)->hh.tbl,_hs_q))) \
888  ) <= 0) { \
889  _hs_e = _hs_p; \
890  if (_hs_p != NULL){ \
891  _hs_p = (UT_hash_handle*)((_hs_p->next != NULL) ? \
892  ((void*)((char*)(_hs_p->next) + \
893  (head)->hh.tbl->hho)) : NULL); \
894  } \
895  _hs_psize--; \
896  } else { \
897  _hs_e = _hs_q; \
898  _hs_q = (UT_hash_handle*)((_hs_q->next != NULL) ? \
899  ((void*)((char*)(_hs_q->next) + \
900  (head)->hh.tbl->hho)) : NULL); \
901  _hs_qsize--; \
902  } \
903  if ( _hs_tail != NULL ) { \
904  _hs_tail->next = ((_hs_e != NULL) ? \
905  ELMT_FROM_HH((head)->hh.tbl,_hs_e) : NULL); \
906  } else { \
907  _hs_list = _hs_e; \
908  } \
909  if (_hs_e != NULL) { \
910  _hs_e->prev = ((_hs_tail != NULL) ? \
911  ELMT_FROM_HH((head)->hh.tbl,_hs_tail) : NULL); \
912  } \
913  _hs_tail = _hs_e; \
914  } \
915  _hs_p = _hs_q; \
916  } \
917  if (_hs_tail != NULL){ \
918  _hs_tail->next = NULL; \
919  } \
920  if ( _hs_nmerges <= 1U ) { \
921  _hs_looping=0; \
922  (head)->hh.tbl->tail = _hs_tail; \
923  DECLTYPE_ASSIGN(head,ELMT_FROM_HH((head)->hh.tbl, _hs_list)); \
924  } \
925  _hs_insize *= 2U; \
926  } \
927  HASH_FSCK(hh,head); \
928  } \
929 } while (0)
930 
931 /* This function selects items from one hash into another hash.
932  * The end result is that the selected items have dual presence
933  * in both hashes. There is no copy of the items made; rather
934  * they are added into the new hash through a secondary hash
935  * hash handle that must be present in the structure. */
936 #define HASH_SELECT(hh_dst, dst, hh_src, src, cond) \
937 do { \
938  unsigned _src_bkt, _dst_bkt; \
939  void *_last_elt=NULL, *_elt; \
940  UT_hash_handle *_src_hh, *_dst_hh, *_last_elt_hh=NULL; \
941  ptrdiff_t _dst_hho = ((char*)(&(dst)->hh_dst) - (char*)(dst)); \
942  if (src != NULL) { \
943  for(_src_bkt=0; _src_bkt < (src)->hh_src.tbl->num_buckets; _src_bkt++) { \
944  for(_src_hh = (src)->hh_src.tbl->buckets[_src_bkt].hh_head; \
945  _src_hh != NULL; \
946  _src_hh = _src_hh->hh_next) { \
947  _elt = ELMT_FROM_HH((src)->hh_src.tbl, _src_hh); \
948  if (cond(_elt)) { \
949  _dst_hh = (UT_hash_handle*)(((char*)_elt) + _dst_hho); \
950  _dst_hh->key = _src_hh->key; \
951  _dst_hh->keylen = _src_hh->keylen; \
952  _dst_hh->hashv = _src_hh->hashv; \
953  _dst_hh->prev = _last_elt; \
954  _dst_hh->next = NULL; \
955  if (_last_elt_hh != NULL) { _last_elt_hh->next = _elt; } \
956  if (dst == NULL) { \
957  DECLTYPE_ASSIGN(dst,_elt); \
958  HASH_MAKE_TABLE(hh_dst,dst); \
959  } else { \
960  _dst_hh->tbl = (dst)->hh_dst.tbl; \
961  } \
962  HASH_TO_BKT(_dst_hh->hashv, _dst_hh->tbl->num_buckets, _dst_bkt); \
963  HASH_ADD_TO_BKT(_dst_hh->tbl->buckets[_dst_bkt],_dst_hh); \
964  (dst)->hh_dst.tbl->num_items++; \
965  _last_elt = _elt; \
966  _last_elt_hh = _dst_hh; \
967  } \
968  } \
969  } \
970  } \
971  HASH_FSCK(hh_dst,dst); \
972 } while (0)
973 
974 #define HASH_CLEAR(hh,head) \
975 do { \
976  if (head != NULL) { \
977  uthash_free((head)->hh.tbl->buckets, \
978  (head)->hh.tbl->num_buckets*sizeof(struct UT_hash_bucket)); \
979  HASH_BLOOM_FREE((head)->hh.tbl); \
980  uthash_free((head)->hh.tbl, sizeof(UT_hash_table)); \
981  (head)=NULL; \
982  } \
983 } while (0)
984 
985 #define HASH_OVERHEAD(hh,head) \
986  ((head != NULL) ? ( \
987  (size_t)(((head)->hh.tbl->num_items * sizeof(UT_hash_handle)) + \
988  ((head)->hh.tbl->num_buckets * sizeof(UT_hash_bucket)) + \
989  sizeof(UT_hash_table) + \
990  (HASH_BLOOM_BYTELEN))) : 0U)
991 
992 #ifdef NO_DECLTYPE
993 #define HASH_ITER(hh,head,el,tmp) \
994 for(((el)=(head)), ((*(char**)(&(tmp)))=(char*)((head!=NULL)?(head)->hh.next:NULL)); \
995  (el) != NULL; ((el)=(tmp)), ((*(char**)(&(tmp)))=(char*)((tmp!=NULL)?(tmp)->hh.next:NULL)))
996 #else
997 #define HASH_ITER(hh,head,el,tmp) \
998 for(((el)=(head)), ((tmp)=DECLTYPE(el)((head!=NULL)?(head)->hh.next:NULL)); \
999  (el) != NULL; ((el)=(tmp)), ((tmp)=DECLTYPE(el)((tmp!=NULL)?(tmp)->hh.next:NULL)))
1000 #endif
1001 
1002 /* obtain a count of items in the hash */
1003 #define HASH_COUNT(head) HASH_CNT(hh,head)
1004 #define HASH_CNT(hh,head) ((head != NULL)?((head)->hh.tbl->num_items):0U)
1005 
1006 typedef struct UT_hash_bucket {
1007  struct UT_hash_handle *hh_head;
1008  unsigned count;
1009 
1010  /* expand_mult is normally set to 0. In this situation, the max chain length
1011  * threshold is enforced at its default value, HASH_BKT_CAPACITY_THRESH. (If
1012  * the bucket's chain exceeds this length, bucket expansion is triggered).
1013  * However, setting expand_mult to a non-zero value delays bucket expansion
1014  * (that would be triggered by additions to this particular bucket)
1015  * until its chain length reaches a *multiple* of HASH_BKT_CAPACITY_THRESH.
1016  * (The multiplier is simply expand_mult+1). The whole idea of this
1017  * multiplier is to reduce bucket expansions, since they are expensive, in
1018  * situations where we know that a particular bucket tends to be overused.
1019  * It is better to let its chain length grow to a longer yet-still-bounded
1020  * value, than to do an O(n) bucket expansion too often.
1021  */
1022  unsigned expand_mult;
1023 
1024 } UT_hash_bucket;
1025 
1026 /* random signature used only to find hash tables in external analysis */
1027 #define HASH_SIGNATURE 0xa0111fe1u
1028 #define HASH_BLOOM_SIGNATURE 0xb12220f2u
1029 
1030 typedef struct UT_hash_table {
1031  UT_hash_bucket *buckets;
1032  unsigned num_buckets, log2_num_buckets;
1033  unsigned num_items;
1034  struct UT_hash_handle *tail; /* tail hh in app order, for fast append */
1035  ptrdiff_t hho; /* hash handle offset (byte pos of hash handle in element */
1036 
1037  /* in an ideal situation (all buckets used equally), no bucket would have
1038  * more than ceil(#items/#buckets) items. that's the ideal chain length. */
1039  unsigned ideal_chain_maxlen;
1040 
1041  /* nonideal_items is the number of items in the hash whose chain position
1042  * exceeds the ideal chain maxlen. these items pay the penalty for an uneven
1043  * hash distribution; reaching them in a chain traversal takes >ideal steps */
1044  unsigned nonideal_items;
1045 
1046  /* ineffective expands occur when a bucket doubling was performed, but
1047  * afterward, more than half the items in the hash had nonideal chain
1048  * positions. If this happens on two consecutive expansions we inhibit any
1049  * further expansion, as it's not helping; this happens when the hash
1050  * function isn't a good fit for the key domain. When expansion is inhibited
1051  * the hash will still work, albeit no longer in constant time. */
1052  unsigned ineff_expands, noexpand;
1053 
1054  uint32_t signature; /* used only to find hash tables in external analysis */
1055 #ifdef HASH_BLOOM
1056  uint32_t bloom_sig; /* used only to test bloom exists in external analysis */
1057  uint8_t *bloom_bv;
1058  uint8_t bloom_nbits;
1059 #endif
1060 
1061 } UT_hash_table;
1062 
1063 typedef struct UT_hash_handle {
1064  struct UT_hash_table *tbl;
1065  void *prev; /* prev element in app order */
1066  void *next; /* next element in app order */
1067  struct UT_hash_handle *hh_prev; /* previous hh in bucket order */
1068  struct UT_hash_handle *hh_next; /* next hh in bucket order */
1069  void *key; /* ptr to enclosing struct's key */
1070  unsigned keylen; /* enclosing struct's key len */
1071  unsigned hashv; /* result of hash-fcn(key) */
1072 } UT_hash_handle;
1073 
1074 #endif /* UTHASH_H */
UT_hash_handle::hh_next
struct UT_hash_handle * hh_next
Definition: uthash.h:1068
UT_hash_table::buckets
UT_hash_bucket * buckets
Definition: uthash.h:1031
UT_hash_handle::key
void * key
Definition: uthash.h:1069
UT_hash_handle::keylen
unsigned keylen
Definition: uthash.h:1070
UT_hash_handle::tbl
struct UT_hash_table * tbl
Definition: uthash.h:1064
UT_hash_table::ineff_expands
unsigned ineff_expands
Definition: uthash.h:1052
UT_hash_handle::hh_prev
struct UT_hash_handle * hh_prev
Definition: uthash.h:1067
UT_hash_handle::hashv
unsigned hashv
Definition: uthash.h:1071
UT_hash_bucket::expand_mult
unsigned expand_mult
Definition: uthash.h:1022
UT_hash_bucket::count
unsigned count
Definition: uthash.h:1008
UT_hash_table::signature
uint32_t signature
Definition: uthash.h:1054
UT_hash_table::num_items
unsigned num_items
Definition: uthash.h:1033
UT_hash_handle::prev
void * prev
Definition: uthash.h:1065
UT_hash_table::num_buckets
unsigned num_buckets
Definition: uthash.h:1032
UT_hash_table::noexpand
unsigned noexpand
Definition: uthash.h:1052
UT_hash_table::tail
struct UT_hash_handle * tail
Definition: uthash.h:1034
UT_hash_bucket
struct UT_hash_bucket UT_hash_bucket
uint32_t
unsigned int uint32_t
Definition: uthash.h:77
UT_hash_table
Definition: uthash.h:1030
UT_hash_table::hho
ptrdiff_t hho
Definition: uthash.h:1035
UT_hash_table
struct UT_hash_table UT_hash_table
UT_hash_table::ideal_chain_maxlen
unsigned ideal_chain_maxlen
Definition: uthash.h:1039
UT_hash_handle
struct UT_hash_handle UT_hash_handle
UT_hash_bucket
Definition: uthash.h:1006
UT_hash_handle::next
void * next
Definition: uthash.h:1066
UT_hash_bucket::hh_head
struct UT_hash_handle * hh_head
Definition: uthash.h:1007
uint8_t
unsigned char uint8_t
Definition: uthash.h:78
UT_hash_table::log2_num_buckets
unsigned log2_num_buckets
Definition: uthash.h:1032
UT_hash_handle
Definition: uthash.h:1063
UT_hash_table::nonideal_items
unsigned nonideal_items
Definition: uthash.h:1044