/* Hash tables.
- Copyright (C) 2000-2005 Free Software Foundation, Inc.
+ Copyright (C) 2000-2006 Free Software Foundation, Inc.
This file is part of GNU Wget.
GNU Wget is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or (at
+the Free Software Foundation; either version 3 of the License, or (at
your option) any later version.
GNU Wget is distributed in the hope that it will be useful,
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with Wget; if not, write to the Free Software Foundation, Inc.,
-51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+along with Wget. If not, see <http://www.gnu.org/licenses/>.
In addition, as a special exception, the Free Software Foundation
gives permission to link the code of its release of Wget with the
# define xnew_array(type, x) xmalloc (sizeof (type) * (x))
# define xmalloc malloc
# define xfree free
-# define countof(x) (sizeof (x) / sizeof ((x)[0]))
-# define TOLOWER(x) ('A' <= (x) && (x) <= 'Z' ? (x) - 32 : (x))
+# ifndef countof
+# define countof(x) (sizeof (x) / sizeof ((x)[0]))
+# endif
+# include <ctype.h>
+# define TOLOWER(x) tolower ((unsigned char) (x))
+# if __STDC_VERSION__ >= 199901L
+# include <stdint.h> /* for uintptr_t */
+# else
+ typedef unsigned long uintptr_t;
+# endif
#endif
#include "hash.h"
hash_table_get_pair -- get key/value pair for key.
hash_table_contains -- test whether the table contains key.
hash_table_remove -- remove key->value mapping for given key.
- hash_table_map -- iterate through table entries.
+ hash_table_for_each -- call function for each table entry.
+ hash_table_iterate -- iterate over entries in hash table.
+ hash_table_iter_next -- return next element during iteration.
hash_table_clear -- clear hash table contents.
hash_table_count -- return the number of entries in the table.
with each resize, which ensures that the amortized time per
operation remains constant.
- By default, tables created by hash_table_new consider the keys to
- be equal if their pointer values are the same. You can use
- make_string_hash_table to create tables whose keys are considered
- equal if their string contents are the same. In the general case,
- the criterion of equality used to compare keys is specified at
- table creation time with two callback functions, "hash" and "test".
- The hash function transforms the key into an arbitrary number that
- must be the same for two equal keys. The test function accepts two
- keys and returns non-zero if they are to be considered equal.
+ If not instructed otherwise, tables created by hash_table_new
+ consider the keys to be equal if their pointer values are the same.
+ You can use make_string_hash_table to create tables whose keys are
+ considered equal if their string contents are the same. In the
+ general case, the criterion of equality used to compare keys is
+ specified at table creation time with two callback functions,
+ "hash" and "test". The hash function transforms the key into an
+ arbitrary number that must be the same for two equal keys. The
+ test function accepts two keys and returns non-zero if they are to
+ be considered equal.
Note that neither keys nor values are copied when inserted into the
hash table, so they must exist for the lifetime of the table. This
means that e.g. the use of static strings is OK, but objects with a
- shorter life-time need to be copied (with strdup() or the like in
- the case of strings) before being inserted. */
+ shorter life-time probably need to be copied (with strdup() or the
+ like in the case of strings) before being inserted. */
/* IMPLEMENTATION:
-1. This is acceptable because it still allows the use of
nonnegative integer keys. */
-#define INVALID_PTR ((void *) ~0UL)
+#define INVALID_PTR ((void *) ~(uintptr_t) 0)
#ifndef UCHAR_MAX
# define UCHAR_MAX 0xff
#endif
ht->count = 0;
}
-/* Map MAPFUN over all entries in HT. MAPFUN is called with three
- arguments: the key, the value, and MAPARG.
+/* Call FN for each entry in HT. FN is called with three arguments:
+ the key, the value, and ARG. When FN returns a non-zero value, the
+ mapping stops.
It is undefined what happens if you add or remove entries in the
- hash table while hash_table_map is running. The exception is the
- entry you're currently mapping over; you may remove or change that
- entry. */
+ hash table while hash_table_for_each is running. The exception is
+ the entry you're currently mapping over; you may call
+ hash_table_put or hash_table_remove on that entry's key. That is
+ also the reason why this function cannot be implemented in terms of
+ hash_table_iterate. */
void
-hash_table_map (struct hash_table *ht,
- int (*mapfun) (void *, void *, void *),
- void *maparg)
+hash_table_for_each (struct hash_table *ht,
+ int (*fn) (void *, void *, void *), void *arg)
{
- struct cell *c = ht->cells;
+ struct cell *c = ht->cells;
struct cell *end = ht->cells + ht->size;
for (; c < end; c++)
void *key;
repeat:
key = c->key;
- if (mapfun (key, c->value, maparg))
+ if (fn (key, c->value, arg))
return;
/* hash_table_remove might have moved the adjacent cells. */
if (c->key != key && CELL_OCCUPIED (c))
}
}
+/* Initiate iteration over HT. Entries are obtained with
+ hash_table_iter_next, a typical iteration loop looking like this:
+
+ hash_table_iterator iter;
+ for (hash_table_iterate (ht, &iter); hash_table_iter_next (&iter); )
+ ... do something with iter.key and iter.value ...
+
+ The iterator does not need to be deallocated after use. The hash
+ table must not be modified while being iterated over. */
+
+void
+hash_table_iterate (struct hash_table *ht, hash_table_iterator *iter)
+{
+ iter->pos = ht->cells;
+ iter->end = ht->cells + ht->size;
+}
+
+/* Get the next hash table entry. ITER is an iterator object
+ initialized using hash_table_iterate. While there are more
+ entries, the key and value pointers are stored to ITER->key and
+ ITER->value respectively and 1 is returned. When there are no more
+ entries, 0 is returned.
+
+ If the hash table is modified between calls to this function, the
+ result is undefined. */
+
+int
+hash_table_iter_next (hash_table_iterator *iter)
+{
+ struct cell *c = iter->pos;
+ struct cell *end = iter->end;
+ for (; c < end; c++)
+ if (CELL_OCCUPIED (c))
+ {
+ iter->key = c->key;
+ iter->value = c->value;
+ iter->pos = c + 1;
+ return 1;
+ }
+ return 0;
+}
+
/* Return the number of elements in the hash table. This is not the
same as the physical size of the hash table, which is always
greater than the number of elements. */
a hash function that returns 0 for any given object is a
perfectly valid (albeit extremely bad) hash function. A hash
function that hashes a string by adding up all its characters is
- another example of a valid (but quite bad) hash function.
+ another example of a valid (but still quite bad) hash function.
It is not hard to make hash and test functions agree about
equality. For example, if the test function compares strings
characters when calculating the hash value. That ensures that
two strings differing only in case will hash the same.
- - If you care about performance, choose a hash function with as
- good "spreading" as possible. A good hash function will use all
- the bits of the input when calculating the hash, and will react
- to even small changes in input with a completely different
- output. Finally, don't make the hash function itself overly
- slow, because you'll be incurring a non-negligible overhead to
- all hash table operations. */
+ - To prevent performance degradation, choose a hash function with
+ as good "spreading" as possible. A good hash function will use
+ all the bits of the input when calculating the hash, and will
+ react to even small changes in input with a completely different
+ output. But don't make the hash function itself overly slow,
+ because you'll be incurring a non-negligible overhead to all hash
+ table operations. */
/*
* Support for hash tables whose keys are strings.
*
*/
-/* 31 bit hash function. Taken from Gnome's glib, modified to use
+/* Base 31 hash function. Taken from Gnome's glib, modified to use
standard C types.
We used to use the popular hash function from the Dragon Book, but
- this one seems to perform much better. */
+ this one seems to perform much better, both by being faster and by
+ generating less collisions. */
static unsigned long
hash_string (const void *key)
/* Hashing of numeric values, such as pointers and integers.
This implementation is the Robert Jenkins' 32 bit Mix Function,
- with a simple adaptation for 64-bit values. It offers excellent
- spreading of values and doesn't need to know the hash table size to
- work (unlike the very popular Knuth's multiplication hash). */
+ with a simple adaptation for 64-bit values. According to Jenkins
+ it should offer excellent spreading of values. Unlike the popular
+ Knuth's multiplication hash, this function doesn't need to know the
+ hash table size to work. */
unsigned long
hash_pointer (const void *ptr)
{
- unsigned long key = (unsigned long)ptr;
+ uintptr_t key = (uintptr_t) ptr;
key += (key << 12);
key ^= (key >> 22);
key += (key << 4);
key ^= (key >> 2);
key += (key << 7);
key ^= (key >> 12);
-#if SIZEOF_LONG > 4
+#if SIZEOF_VOID_P > 4
key += (key << 44);
key ^= (key >> 54);
key += (key << 36);
key += (key << 39);
key ^= (key >> 44);
#endif
- return key;
+ return (unsigned long) key;
}
static int
#include <stdio.h>
#include <string.h>
-int
-print_hash_table_mapper (void *key, void *value, void *count)
-{
- ++*(int *)count;
- printf ("%s: %s\n", (const char *)key, (char *)value);
- return 0;
-}
-
void
print_hash (struct hash_table *sht)
{
- int debug_count = 0;
- hash_table_map (sht, print_hash_table_mapper, &debug_count);
- assert (debug_count == sht->count);
+ hash_table_iterator iter;
+ int count = 0;
+
+ for (hash_table_iterate (sht, &iter); hash_table_iter_next (&iter);
+ ++count)
+ printf ("%s: %s\n", iter.key, iter.value);
+ assert (count == sht->count);
}
int
projects / wget / blobdiff