Keep the command line on the heap to avoid stack overflow.
[make.git] / hash.h
blob6624fe6e2c0373415e7fd1b33de6bf6c07c060c8
1 /* hash.h -- decls for hash table
2 Copyright (C) 1995, 1999, 2002, 2010 Free Software Foundation, Inc.
3 Written by Greg McGary <gkm@gnu.org> <greg@mcgary.org>
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.
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.
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/>. */
17 #ifndef _hash_h_
18 #define _hash_h_
20 #include <stdio.h>
21 #include <ctype.h>
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. */
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));
41 struct hash_table
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 */
56 typedef int (*qsort_cmp_t) __P((void const *, void const *));
58 void hash_init __P((struct hash_table *ht, unsigned long size,
59 hash_func_t hash_1, hash_func_t hash_2, hash_cmp_func_t hash_cmp));
60 void hash_load __P((struct hash_table *ht, void *item_table,
61 unsigned long cardinality, unsigned long size));
62 void **hash_find_slot __P((struct hash_table *ht, void const *key));
63 void *hash_find_item __P((struct hash_table *ht, void const *key));
64 void *hash_insert __P((struct hash_table *ht, const void *item));
65 void *hash_insert_at __P((struct hash_table *ht, const void *item, void const *slot));
66 void *hash_delete __P((struct hash_table *ht, void const *item));
67 void *hash_delete_at __P((struct hash_table *ht, void const *slot));
68 void hash_delete_items __P((struct hash_table *ht));
69 void hash_free_items __P((struct hash_table *ht));
70 void hash_free __P((struct hash_table *ht, int free_items));
71 void hash_map __P((struct hash_table *ht, hash_map_func_t map));
72 void hash_map_arg __P((struct hash_table *ht, hash_map_arg_func_t map, void *arg));
73 void hash_print_stats __P((struct hash_table *ht, FILE *out_FILE));
74 void **hash_dump __P((struct hash_table *ht, void **vector_0, qsort_cmp_t compare));
76 extern void *hash_deleted_item;
77 #define HASH_VACANT(item) ((item) == 0 || (void *) (item) == hash_deleted_item)
80 /* hash and comparison macros for case-sensitive string keys. */
82 /* Due to the strcache, it's not uncommon for the string pointers to
83 be identical. Take advantage of that to short-circuit string compares. */
85 #define STRING_HASH_1(KEY, RESULT) do { \
86 unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
87 while (*++_key_) \
88 (RESULT) += (*_key_ << (_key_[1] & 0xf)); \
89 } while (0)
90 #define return_STRING_HASH_1(KEY) do { \
91 unsigned long _result_ = 0; \
92 STRING_HASH_1 ((KEY), _result_); \
93 return _result_; \
94 } while (0)
96 #define STRING_HASH_2(KEY, RESULT) do { \
97 unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
98 while (*++_key_) \
99 (RESULT) += (*_key_ << (_key_[1] & 0x7)); \
100 } while (0)
101 #define return_STRING_HASH_2(KEY) do { \
102 unsigned long _result_ = 0; \
103 STRING_HASH_2 ((KEY), _result_); \
104 return _result_; \
105 } while (0)
107 #define STRING_COMPARE(X, Y, RESULT) do { \
108 RESULT = (X) == (Y) ? 0 : strcmp ((X), (Y)); \
109 } while (0)
110 #define return_STRING_COMPARE(X, Y) do { \
111 return (X) == (Y) ? 0 : strcmp ((X), (Y)); \
112 } while (0)
115 #define STRING_N_HASH_1(KEY, N, RESULT) do { \
116 unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
117 int _n_ = (N); \
118 if (_n_) \
119 while (--_n_ && *++_key_) \
120 (RESULT) += (*_key_ << (_key_[1] & 0xf)); \
121 (RESULT) += *++_key_; \
122 } while (0)
123 #define return_STRING_N_HASH_1(KEY, N) do { \
124 unsigned long _result_ = 0; \
125 STRING_N_HASH_1 ((KEY), (N), _result_); \
126 return _result_; \
127 } while (0)
129 #define STRING_N_HASH_2(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] & 0x7)); \
135 (RESULT) += *++_key_; \
136 } while (0)
137 #define return_STRING_N_HASH_2(KEY, N) do { \
138 unsigned long _result_ = 0; \
139 STRING_N_HASH_2 ((KEY), (N), _result_); \
140 return _result_; \
141 } while (0)
143 #define STRING_N_COMPARE(X, Y, N, RESULT) do { \
144 RESULT = (X) == (Y) ? 0 : strncmp ((X), (Y), (N)); \
145 } while (0)
146 #define return_STRING_N_COMPARE(X, Y, N) do { \
147 return (X) == (Y) ? 0 : strncmp ((X), (Y), (N)); \
148 } while (0)
150 #ifdef HAVE_CASE_INSENSITIVE_FS
152 /* hash and comparison macros for case-insensitive string _key_s. */
154 #define ISTRING_HASH_1(KEY, RESULT) do { \
155 unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
156 while (*++_key_) \
157 (RESULT) += ((isupper (*_key_) ? tolower (*_key_) : *_key_) << (_key_[1] & 0xf)); \
158 } while (0)
159 #define return_ISTRING_HASH_1(KEY) do { \
160 unsigned long _result_ = 0; \
161 ISTRING_HASH_1 ((KEY), _result_); \
162 return _result_; \
163 } while (0)
165 #define ISTRING_HASH_2(KEY, RESULT) do { \
166 unsigned char const *_key_ = (unsigned char const *) (KEY) - 1; \
167 while (*++_key_) \
168 (RESULT) += ((isupper (*_key_) ? tolower (*_key_) : *_key_) << (_key_[1] & 0x7)); \
169 } while (0)
170 #define return_ISTRING_HASH_2(KEY) do { \
171 unsigned long _result_ = 0; \
172 ISTRING_HASH_2 ((KEY), _result_); \
173 return _result_; \
174 } while (0)
176 #define ISTRING_COMPARE(X, Y, RESULT) do { \
177 RESULT = (X) == (Y) ? 0 : strcasecmp ((X), (Y)); \
178 } while (0)
179 #define return_ISTRING_COMPARE(X, Y) do { \
180 return (X) == (Y) ? 0 : strcasecmp ((X), (Y)); \
181 } while (0)
183 #else
185 #define ISTRING_HASH_1(KEY, RESULT) STRING_HASH_1 ((KEY), (RESULT))
186 #define return_ISTRING_HASH_1(KEY) return_STRING_HASH_1 (KEY)
188 #define ISTRING_HASH_2(KEY, RESULT) STRING_HASH_2 ((KEY), (RESULT))
189 #define return_ISTRING_HASH_2(KEY) return_STRING_HASH_2 (KEY)
191 #define ISTRING_COMPARE(X, Y, RESULT) STRING_COMPARE ((X), (Y), (RESULT))
192 #define return_ISTRING_COMPARE(X, Y) return_STRING_COMPARE ((X), (Y))
194 #endif
196 /* hash and comparison macros for integer _key_s. */
198 #define INTEGER_HASH_1(KEY, RESULT) do { \
199 (RESULT) += ((unsigned long)(KEY)); \
200 } while (0)
201 #define return_INTEGER_HASH_1(KEY) do { \
202 unsigned long _result_ = 0; \
203 INTEGER_HASH_1 ((KEY), _result_); \
204 return _result_; \
205 } while (0)
207 #define INTEGER_HASH_2(KEY, RESULT) do { \
208 (RESULT) += ~((unsigned long)(KEY)); \
209 } while (0)
210 #define return_INTEGER_HASH_2(KEY) do { \
211 unsigned long _result_ = 0; \
212 INTEGER_HASH_2 ((KEY), _result_); \
213 return _result_; \
214 } while (0)
216 #define INTEGER_COMPARE(X, Y, RESULT) do { \
217 (RESULT) = X - Y; \
218 } while (0)
219 #define return_INTEGER_COMPARE(X, Y) do { \
220 int _result_; \
221 INTEGER_COMPARE (X, Y, _result_); \
222 return _result_; \
223 } while (0)
225 /* hash and comparison macros for address keys. */
227 #define ADDRESS_HASH_1(KEY, RESULT) INTEGER_HASH_1 (((unsigned long)(KEY)) >> 3, (RESULT))
228 #define ADDRESS_HASH_2(KEY, RESULT) INTEGER_HASH_2 (((unsigned long)(KEY)) >> 3, (RESULT))
229 #define ADDRESS_COMPARE(X, Y, RESULT) INTEGER_COMPARE ((X), (Y), (RESULT))
230 #define return_ADDRESS_HASH_1(KEY) return_INTEGER_HASH_1 (((unsigned long)(KEY)) >> 3)
231 #define return_ADDRESS_HASH_2(KEY) return_INTEGER_HASH_2 (((unsigned long)(KEY)) >> 3)
232 #define return_ADDRESS_COMPARE(X, Y) return_INTEGER_COMPARE ((X), (Y))
234 #endif /* not _hash_h_ */