size_t n_slots; /* n_slots = 2^log_slots */
size_t n_elements;
- void **slots;
+ const void **slots;
};
/* Use the multiplicative method, as described in Knuth 6.4, to obtain
result->log_slots = 8;
result->n_slots = (size_t) 1 << result->log_slots;
- result->slots = XCNEWVEC (void *, result->n_slots);
+ result->slots = XCNEWVEC (const void *, result->n_slots);
return result;
}
Collisions are resolved by linear probing. */
int
-pointer_set_contains (struct pointer_set_t *pset, void *p)
+pointer_set_contains (const struct pointer_set_t *pset, const void *p)
{
size_t n = hash1 (p, pset->n_slots, pset->log_slots);
/* Subroutine of pointer_set_insert. Return the insertion slot for P into
an empty element of SLOTS, an array of length N_SLOTS. */
static inline size_t
-insert_aux (void *p, void **slots, size_t n_slots, size_t log_slots)
+insert_aux (const void *p, const void **slots, size_t n_slots, size_t log_slots)
{
size_t n = hash1 (p, n_slots, log_slots);
while (true)
/* Inserts P into PSET if it wasn't already there. Returns nonzero
if it was already there. P must be nonnull. */
int
-pointer_set_insert (struct pointer_set_t *pset, void *p)
+pointer_set_insert (struct pointer_set_t *pset, const void *p)
{
size_t n;
{
size_t new_log_slots = pset->log_slots + 1;
size_t new_n_slots = pset->n_slots * 2;
- void **new_slots = XCNEWVEC (void *, new_n_slots);
+ const void **new_slots = XCNEWVEC (const void *, new_n_slots);
size_t i;
for (i = 0; i < pset->n_slots; ++i)
{
- void *value = pset->slots[i];
+ const void *value = pset->slots[i];
n = insert_aux (value, new_slots, new_n_slots, new_log_slots);
new_slots[n] = value;
}
/* Pass each pointer in PSET to the function in FN, together with the fixed
parameter DATA. If FN returns false, the iteration stops. */
-void pointer_set_traverse (struct pointer_set_t *pset,
- bool (*fn) (void *, void *), void *data)
+void pointer_set_traverse (const struct pointer_set_t *pset,
+ bool (*fn) (const void *, void *), void *data)
{
size_t i;
for (i = 0; i < pset->n_slots; ++i)
size_t n_slots; /* n_slots = 2^log_slots */
size_t n_elements;
- void **keys;
+ const void **keys;
void **values;
};
result->log_slots = 8;
result->n_slots = (size_t) 1 << result->log_slots;
- result->keys = XCNEWVEC (void *, result->n_slots);
+ result->keys = XCNEWVEC (const void *, result->n_slots);
result->values = XCNEWVEC (void *, result->n_slots);
return result;
}
Collisions are resolved by linear probing. */
void **
-pointer_map_contains (struct pointer_map_t *pmap, void *p)
+pointer_map_contains (const struct pointer_map_t *pmap, const void *p)
{
size_t n = hash1 (p, pmap->n_slots, pmap->log_slots);
/* Inserts P into PMAP if it wasn't already there. Returns a pointer
to the value. P must be nonnull. */
void **
-pointer_map_insert (struct pointer_map_t *pmap, void *p)
+pointer_map_insert (struct pointer_map_t *pmap, const void *p)
{
size_t n;
{
size_t new_log_slots = pmap->log_slots + 1;
size_t new_n_slots = pmap->n_slots * 2;
- void **new_keys = XCNEWVEC (void *, new_n_slots);
+ const void **new_keys = XCNEWVEC (const void *, new_n_slots);
void **new_values = XCNEWVEC (void *, new_n_slots);
size_t i;
for (i = 0; i < pmap->n_slots; ++i)
if (pmap->keys[i])
{
- void *key = pmap->keys[i];
+ const void *key = pmap->keys[i];
n = insert_aux (key, new_keys, new_n_slots, new_log_slots);
new_keys[n] = key;
new_values[n] = pmap->values[i];
to the value and the fixed parameter DATA. If FN returns false, the
iteration stops. */
-void pointer_map_traverse (struct pointer_map_t *pmap,
- bool (*fn) (void *, void **, void *), void *data)
+void pointer_map_traverse (const struct pointer_map_t *pmap,
+ bool (*fn) (const void *, void **, void *), void *data)
{
size_t i;
for (i = 0; i < pmap->n_slots; ++i)