src/kmk/hash.h

   1 /* hash.h -- decls for hash table
   2 Copyright (C) 1995, 1999, 2002 Free Software Foundation, Inc.
   3 Written by Greg McGary <gkm@gnu.org> <greg@mcgary.org>
   4
   5 GNU Make is free software; you can redistribute it and/or modify it under the
   6 terms of the GNU General Public License as published by the Free Software
   7 Foundation; either version 3 of the License, or (at your option) any later
   8 version.
   9
  10 GNU Make is distributed in the hope that it will be useful, but WITHOUT ANY
  11 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  12 A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License along with
  15 this program.  If not, see <http://www.gnu.org/licenses/>.  */
  16
  17 #ifndef _hash_h_
  18 #define _hash_h_
  19
  20 #include <stdio.h>
  21 #include <ctype.h>
  22
  23 #if defined __cplusplus || (defined __STDC__ && __STDC__) || defined WINDOWS32
  24 # if !defined __GLIBC__ || !defined __P
  25 #  undef        __P
  26 #  define __P(protos)   protos
  27 # endif
  28 #else /* Not C++ or ANSI C.  */
  29 # undef __P
  30 # define __P(protos)    ()
  31 /* We can get away without defining `const' here only because in this file
  32    it is used only inside the prototype for `fnmatch', which is elided in
  33    non-ANSI C where `const' is problematical.  */
  34 #endif /* C++ or ANSI C.  */
  35
  36 typedef unsigned long (*hash_func_t) __P((void const *key));
  37 typedef int (*hash_cmp_func_t) __P((void const *x, void const *y));
  38 typedef void (*hash_map_func_t) __P((void const *item));
  39 typedef void (*hash_map_arg_func_t) __P((void const *item, void *arg));
  40
  41 struct hash_table
  42 {
  43   void **ht_vec;
  44   unsigned long ht_size;        /* total number of slots (power of 2) */
  45   unsigned long ht_capacity;    /* usable slots, limited by loading-factor */
  46   unsigned long ht_fill;        /* items in table */
  47   unsigned long ht_empty_slots; /* empty slots not including deleted slots */
  48   unsigned long ht_collisions;  /* # of failed calls to comparison function */
  49   unsigned long ht_lookups;     /* # of queries */
  50   unsigned int ht_rehashes;     /* # of times we've expanded table */
  51   hash_func_t ht_hash_1;        /* primary hash function */
  52   hash_func_t ht_hash_2;        /* secondary hash function */
  53   hash_cmp_func_t ht_compare;   /* comparison function */
  54 #ifdef CONFIG_WITH_STRCACHE2
  55   struct strcache2 *ht_strcache; /* the string cache pointer. */
  56   unsigned int ht_off_string;  /* offsetof (struct key, string) */
  57 #endif
  58 };
  59
  60 typedef int (*qsort_cmp_t) __P((void const *, void const *));
  61
  62 void hash_init __P((struct hash_table *ht, unsigned long size,
  63                     hash_func_t hash_1, hash_func_t hash_2, hash_cmp_func_t hash_cmp));
  64 void hash_load __P((struct hash_table *ht, void *item_table,
  65                     unsigned long cardinality, unsigned long size));
  66 void **hash_find_slot __P((struct hash_table *ht, void const *key));
  67 void *hash_find_item __P((struct hash_table *ht, void const *key));
  68 void *hash_insert __P((struct hash_table *ht, const void *item));
  69 void *hash_insert_at __P((struct hash_table *ht, const void *item, void const *slot));
  70 void *hash_delete __P((struct hash_table *ht, void const *item));
  71 void *hash_delete_at __P((struct hash_table *ht, void const *slot));
  72 void hash_delete_items __P((struct hash_table *ht));
  73 void hash_free_items __P((struct hash_table *ht));
  74 void hash_free __P((struct hash_table *ht, int free_items));
  75 #ifdef CONFIG_WITH_ALLOC_CACHES
  76 void hash_free_items_cached __P((struct hash_table *ht, struct alloccache *cache));
  77 void hash_free_cached __P((struct hash_table *ht, int free_items, struct alloccache *cache));
  78 #endif
  79 void hash_map __P((struct hash_table *ht, hash_map_func_t map));
  80 void hash_map_arg __P((struct hash_table *ht, hash_map_arg_func_t map, void *arg));
  81 void hash_print_stats __P((struct hash_table *ht, FILE *out_FILE));
  82 void **hash_dump __P((struct hash_table *ht, void **vector_0, qsort_cmp_t compare));
  83
  84 #ifdef CONFIG_WITH_STRCACHE2
  85 void hash_init_strcached __P((struct hash_table *ht, unsigned long size,
  86                               struct strcache2 *strcache, unsigned int off_strptr));
  87 void **hash_find_slot_strcached __P((struct hash_table *ht, const void *key));
  88 void *hash_find_item_strcached __P((struct hash_table *ht, void const *key));
  89 void *hash_insert_strcached __P((struct hash_table *ht, const void *item));
  90 void *hash_delete_strcached __P((struct hash_table *ht, void const *item));
  91 #endif /* CONFIG_WITH_STRCACHE2 */
  92
  93 extern void *hash_deleted_item;
  94 #define HASH_VACANT(item) ((item) == 0 || (void *) (item) == hash_deleted_item)
  95
  96 \f
  97 /* hash and comparison macros for case-sensitive string keys. */
  98
  99 #define STRING_HASH_1(KEY, RESULT) do { \
 100   unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
 101   while (*++_key_) \
 102     (RESULT) += (*_key_ << (_key_[1] & 0xf)); \
 103 } while (0)
 104 #define return_STRING_HASH_1(KEY) do { \
 105   unsigned long _result_ = 0; \
 106   STRING_HASH_1 ((KEY), _result_); \
 107   return _result_; \
 108 } while (0)
 109
 110 #define STRING_HASH_2(KEY, RESULT) do { \
 111   unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
 112   while (*++_key_) \
 113     (RESULT) += (*_key_ << (_key_[1] & 0x7)); \
 114 } while (0)
 115 #define return_STRING_HASH_2(KEY) do { \
 116   unsigned long _result_ = 0; \
 117   STRING_HASH_2 ((KEY), _result_); \
 118   return _result_; \
 119 } while (0)
 120
 121 #define STRING_COMPARE(X, Y, RESULT) do { \
 122   RESULT = strcmp ((X), (Y)); \
 123 } while (0)
 124 #define return_STRING_COMPARE(X, Y) do { \
 125   return strcmp ((X), (Y)); \
 126 } while (0)
 127
 128
 129 #define STRING_N_HASH_1(KEY, N, RESULT) do { \
 130   unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
 131   int _n_ = (N); \
 132   if (_n_) \
 133     while (--_n_ && *++_key_) \
 134       (RESULT) += (*_key_ << (_key_[1] & 0xf)); \
 135   (RESULT) += *++_key_; \
 136 } while (0)
 137 #define return_STRING_N_HASH_1(KEY, N) do { \
 138   unsigned long _result_ = 0; \
 139   STRING_N_HASH_1 ((KEY), (N), _result_); \
 140   return _result_; \
 141 } while (0)
 142
 143 #define STRING_N_HASH_2(KEY, N, RESULT) do { \
 144   unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
 145   int _n_ = (N); \
 146   if (_n_) \
 147     while (--_n_ && *++_key_) \
 148       (RESULT) += (*_key_ << (_key_[1] & 0x7)); \
 149   (RESULT) += *++_key_; \
 150 } while (0)
 151 #define return_STRING_N_HASH_2(KEY, N) do { \
 152   unsigned long _result_ = 0; \
 153   STRING_N_HASH_2 ((KEY), (N), _result_); \
 154   return _result_; \
 155 } while (0)
 156
 157 #define STRING_N_COMPARE(X, Y, N, RESULT) do { \
 158   RESULT = strncmp ((X), (Y), (N)); \
 159 } while (0)
 160 #define return_STRING_N_COMPARE(X, Y, N) do { \
 161   return strncmp ((X), (Y), (N)); \
 162 } while (0)
 163
 164 #ifdef HAVE_CASE_INSENSITIVE_FS
 165
 166 /* hash and comparison macros for case-insensitive string _key_s. */
 167
 168 #define ISTRING_HASH_1(KEY, RESULT) do { \
 169   unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
 170   while (*++_key_) \
 171     (RESULT) += ((isupper (*_key_) ? tolower (*_key_) : *_key_) << (_key_[1] & 0xf)); \
 172 } while (0)
 173 #define return_ISTRING_HASH_1(KEY) do { \
 174   unsigned long _result_ = 0; \
 175   ISTRING_HASH_1 ((KEY), _result_); \
 176   return _result_; \
 177 } while (0)
 178
 179 #define ISTRING_HASH_2(KEY, RESULT) do { \
 180   unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
 181   while (*++_key_) \
 182     (RESULT) += ((isupper (*_key_) ? tolower (*_key_) : *_key_) << (_key_[1] & 0x7)); \
 183 } while (0)
 184 #define return_ISTRING_HASH_2(KEY) do { \
 185   unsigned long _result_ = 0; \
 186   ISTRING_HASH_2 ((KEY), _result_); \
 187   return _result_; \
 188 } while (0)
 189
 190 #define ISTRING_COMPARE(X, Y, RESULT) do { \
 191   RESULT = strcasecmp ((X), (Y)); \
 192 } while (0)
 193 #define return_ISTRING_COMPARE(X, Y) do { \
 194   return strcasecmp ((X), (Y)); \
 195 } while (0)
 196
 197 #else
 198
 199 #define ISTRING_HASH_1(KEY, RESULT) STRING_HASH_1 ((KEY), (RESULT))
 200 #define return_ISTRING_HASH_1(KEY) return_STRING_HASH_1 (KEY)
 201
 202 #define ISTRING_HASH_2(KEY, RESULT) STRING_HASH_2 ((KEY), (RESULT))
 203 #define return_ISTRING_HASH_2(KEY) return_STRING_HASH_2 (KEY)
 204
 205 #define ISTRING_COMPARE(X, Y, RESULT) STRING_COMPARE ((X), (Y), (RESULT))
 206 #define return_ISTRING_COMPARE(X, Y) return_STRING_COMPARE ((X), (Y))
 207
 208 #endif
 209
 210 /* hash and comparison macros for integer _key_s. */
 211
 212 #define INTEGER_HASH_1(KEY, RESULT) do { \
 213   (RESULT) += ((unsigned long)(KEY)); \
 214 } while (0)
 215 #define return_INTEGER_HASH_1(KEY) do { \
 216   unsigned long _result_ = 0; \
 217   INTEGER_HASH_1 ((KEY), _result_); \
 218   return _result_; \
 219 } while (0)
 220
 221 #define INTEGER_HASH_2(KEY, RESULT) do { \
 222   (RESULT) += ~((unsigned long)(KEY)); \
 223 } while (0)
 224 #define return_INTEGER_HASH_2(KEY) do { \
 225   unsigned long _result_ = 0; \
 226   INTEGER_HASH_2 ((KEY), _result_); \
 227   return _result_; \
 228 } while (0)
 229
 230 #define INTEGER_COMPARE(X, Y, RESULT) do { \
 231   (RESULT) = X - Y; \
 232 } while (0)
 233 #define return_INTEGER_COMPARE(X, Y) do { \
 234   int _result_; \
 235   INTEGER_COMPARE (X, Y, _result_); \
 236   return _result_; \
 237 } while (0)
 238
 239 /* hash and comparison macros for address keys. */
 240
 241 #define ADDRESS_HASH_1(KEY, RESULT) INTEGER_HASH_1 (((unsigned long)(KEY)) >> 3, (RESULT))
 242 #define ADDRESS_HASH_2(KEY, RESULT) INTEGER_HASH_2 (((unsigned long)(KEY)) >> 3, (RESULT))
 243 #define ADDRESS_COMPARE(X, Y, RESULT) INTEGER_COMPARE ((X), (Y), (RESULT))
 244 #define return_ADDRESS_HASH_1(KEY) return_INTEGER_HASH_1 (((unsigned long)(KEY)) >> 3)
 245 #define return_ADDRESS_HASH_2(KEY) return_INTEGER_HASH_2 (((unsigned long)(KEY)) >> 3)
 246 #define return_ADDRESS_COMPARE(X, Y) return_INTEGER_COMPARE ((X), (Y))
 247
 248 #endif /* not _hash_h_ */