Compiling with gcc -O3 added some more warnings, especially about aliasing.
By setting Word_t to size_t we fix some of them, but jmap_@name_firstval
in JMAP_DEFINE_PTRIDX_TYPE we need to use a real size_t rather than lazily
casting our index to a size_t *.
Gcc also spotted taht we used idx[NUM] in test/run-ptridx-type.c; allocate
that and make the usage explicit.
- /* Judy uses Word_t, we use size_t. */
- BUILD_ASSERT(sizeof(size_t) == sizeof(Word_t));
+ /* Judy uses unsigned long for Word_t, we use size_t. */
+ BUILD_ASSERT(sizeof(size_t) == sizeof(unsigned long));
map = malloc(sizeof(*map));
if (map) {
map = malloc(sizeof(*map));
if (map) {
#ifndef CCAN_JMAP_H
#define CCAN_JMAP_H
#ifndef CCAN_JMAP_H
#define CCAN_JMAP_H
+#include <stddef.h>
+#define _WORD_T
+typedef size_t Word_t, *PWord_t;
#include <Judy.h>
#include <stdbool.h>
#include <Judy.h>
#include <stdbool.h>
#include <ccan/compiler/compiler.h>
#include <assert.h>
#ifdef DEBUG
#include <ccan/compiler/compiler.h>
#include <assert.h>
#ifdef DEBUG
map->acc_value = NULL;
#endif
/* Set it to some invalid value. Not NULL, they might rely on that! */
map->acc_value = NULL;
#endif
/* Set it to some invalid value. Not NULL, they might rely on that! */
- assert((*val = (void *)jmap_new) != NULL);
+ assert(memset(val, 0x42, sizeof(*val)));
}
static inline void jmap_debug_access(struct jmap *map)
}
static inline void jmap_debug_access(struct jmap *map)
*/
static inline bool jmap_add(struct jmap *map, size_t index, size_t value)
{
*/
static inline bool jmap_add(struct jmap *map, size_t index, size_t value)
{
- val = (void *)JudyLIns(&map->judy, index, &map->err);
+ val = (size_t *)JudyLIns(&map->judy, index, &map->err);
if (val == PJERR)
return false;
*val = value;
if (val == PJERR)
return false;
*val = value;
*/
static inline bool jmap_set(const struct jmap *map, size_t index, size_t value)
{
*/
static inline bool jmap_set(const struct jmap *map, size_t index, size_t value)
{
- Word_t *val;
- val = (void *)JudyLGet(map->judy, index, (JError_t *)&map->err);
+ size_t *val;
+ val = (size_t *)JudyLGet(map->judy, index, (JError_t *)&map->err);
if (val && val != PJERR) {
*val = value;
return true;
if (val && val != PJERR) {
*val = value;
return true;
static inline size_t jmap_get(const struct jmap *map, size_t index,
size_t invalid)
{
static inline size_t jmap_get(const struct jmap *map, size_t index,
size_t invalid)
{
- Word_t *val;
- val = (void *)JudyLGet(map->judy, index, (JError_t *)&map->err);
+ size_t *val;
+ val = (size_t *)JudyLGet(map->judy, index, (JError_t *)&map->err);
if (!val || val == PJERR)
return invalid;
return *val;
if (!val || val == PJERR)
return invalid;
return *val;
static inline size_t jmap_nth(const struct jmap *map,
size_t n, size_t invalid)
{
static inline size_t jmap_nth(const struct jmap *map,
size_t n, size_t invalid)
{
if (!JudyLByCount(map->judy, n+1, &index, (JError_t *)&map->err))
index = invalid;
return index;
if (!JudyLByCount(map->judy, n+1, &index, (JError_t *)&map->err))
index = invalid;
return index;
*/
static inline size_t jmap_first(const struct jmap *map, size_t invalid)
{
*/
static inline size_t jmap_first(const struct jmap *map, size_t invalid)
{
if (!JudyLFirst(map->judy, &index, (JError_t *)&map->err))
index = invalid;
else
if (!JudyLFirst(map->judy, &index, (JError_t *)&map->err))
index = invalid;
else
static inline size_t jmap_next(const struct jmap *map, size_t prev,
size_t invalid)
{
static inline size_t jmap_next(const struct jmap *map, size_t prev,
size_t invalid)
{
- if (!JudyLNext(map->judy, (Word_t *)&prev, (JError_t *)&map->err))
+ if (!JudyLNext(map->judy, &prev, (JError_t *)&map->err))
prev = invalid;
else
assert(prev != invalid);
prev = invalid;
else
assert(prev != invalid);
*/
static inline size_t jmap_last(const struct jmap *map, size_t invalid)
{
*/
static inline size_t jmap_last(const struct jmap *map, size_t invalid)
{
if (!JudyLLast(map->judy, &index, (JError_t *)&map->err))
index = invalid;
else
if (!JudyLLast(map->judy, &index, (JError_t *)&map->err))
index = invalid;
else
static inline size_t jmap_prev(const struct jmap *map, size_t prev,
size_t invalid)
{
static inline size_t jmap_prev(const struct jmap *map, size_t prev,
size_t invalid)
{
- if (!JudyLPrev(map->judy, (Word_t *)&prev, (JError_t *)&map->err))
+ if (!JudyLPrev(map->judy, &prev, (JError_t *)&map->err))
prev = invalid;
else
assert(prev != invalid);
prev = invalid;
else
assert(prev != invalid);
static inline size_t *jmap_getval(struct jmap *map, size_t index)
{
size_t *val;
static inline size_t *jmap_getval(struct jmap *map, size_t index)
{
size_t *val;
- val = (void *)JudyLGet(map->judy, index, (JError_t *)&map->err);
+ val = (size_t *)JudyLGet(map->judy, index, (JError_t *)&map->err);
jmap_debug_add_access(map, index, val, "jmap_getval");
return val;
}
jmap_debug_add_access(map, index, val, "jmap_getval");
return val;
}
size_t n, size_t *index)
{
size_t *val;
size_t n, size_t *index)
{
size_t *val;
- val = (size_t *)JudyLByCount(map->judy, n+1, (Word_t *)index,
+ val = (size_t *)JudyLByCount(map->judy, n+1, index,
(JError_t *)&map->err);
jmap_debug_add_access(map, *index, val, "jmap_nthval");
return val;
(JError_t *)&map->err);
jmap_debug_add_access(map, *index, val, "jmap_nthval");
return val;
{
size_t *val;
*index = 0;
{
size_t *val;
*index = 0;
- val = (size_t *)JudyLFirst(map->judy, (Word_t *)index,
- (JError_t *)&map->err);
+ val = (size_t *)JudyLFirst(map->judy, index, (JError_t *)&map->err);
jmap_debug_add_access(map, *index, val, "jmap_firstval");
return val;
}
jmap_debug_add_access(map, *index, val, "jmap_firstval");
return val;
}
static inline size_t *jmap_nextval(const struct jmap *map, size_t *index)
{
size_t *val;
static inline size_t *jmap_nextval(const struct jmap *map, size_t *index)
{
size_t *val;
- val = (size_t *)JudyLNext(map->judy, (Word_t *)index,
- (JError_t *)&map->err);
+ val = (size_t *)JudyLNext(map->judy, index, (JError_t *)&map->err);
jmap_debug_add_access(map, *index, val, "jmap_nextval");
return val;
}
jmap_debug_add_access(map, *index, val, "jmap_nextval");
return val;
}
{
size_t *val;
*index = -1;
{
size_t *val;
*index = -1;
- val = (size_t *)JudyLLast(map->judy, (Word_t *)index,
- (JError_t *)&map->err);
+ val = (size_t *)JudyLLast(map->judy, index, (JError_t *)&map->err);
jmap_debug_add_access(map, *index, val, "jmap_lastval");
return val;
}
jmap_debug_add_access(map, *index, val, "jmap_lastval");
return val;
}
static inline size_t *jmap_prevval(const struct jmap *map, size_t *index)
{
size_t *val;
static inline size_t *jmap_prevval(const struct jmap *map, size_t *index)
{
size_t *val;
- val = (size_t *)JudyLPrev(map->judy, (Word_t *)index,
- (JError_t *)&map->err);
+ val = (size_t *)JudyLPrev(map->judy, index, (JError_t *)&map->err);
jmap_debug_add_access(map, *index, val, "jmap_prevval");
return val;
}
jmap_debug_add_access(map, *index, val, "jmap_prevval");
return val;
}
static inline type **jmap_##name##_firstval(const struct jmap_##name *map, \
itype **index) \
{ \
static inline type **jmap_##name##_firstval(const struct jmap_##name *map, \
itype **index) \
{ \
- return (type **)jmap_firstval((const struct jmap *)map, \
- (size_t *)index); \
+ size_t idx; \
+ type **ret; \
+ ret = (type **)jmap_firstval((const struct jmap *)map, &idx); \
+ *index = (void *)idx; \
+ return ret; \
} \
static inline type **jmap_##name##_nextval(const struct jmap_##name *map, \
itype **index) \
} \
static inline type **jmap_##name##_nextval(const struct jmap_##name *map, \
itype **index) \
{
struct jmap_foo *map;
struct foo *foo[NUM], **foop;
{
struct jmap_foo *map;
struct foo *foo[NUM], **foop;
- struct idx *idx[NUM], *index;
+ struct idx *idx[NUM+1], *index;
unsigned int i;
plan_tests(25 + NUM*2 + 6);
unsigned int i;
plan_tests(25 + NUM*2 + 6);
- for (i = 0; i < NUM; i++)
+ for (i = 0; i < NUM+1; i++)
foo[i] = malloc(20);
qsort(foo, NUM, sizeof(foo[0]), cmp_ptr);
/* idx[i] == foo[i] + 1, for easy checking */
foo[i] = malloc(20);
qsort(foo, NUM, sizeof(foo[0]), cmp_ptr);
/* idx[i] == foo[i] + 1, for easy checking */
- for (i = 0; i < NUM; i++)
+ for (i = 0; i < NUM+1; i++)
idx[i] = (void *)((char *)foo[i] + 1);
map = jmap_foo_new();
ok1(jmap_foo_error(map) == NULL);
idx[i] = (void *)((char *)foo[i] + 1);
map = jmap_foo_new();
ok1(jmap_foo_error(map) == NULL);
- ok1(jmap_foo_test(map, idx[i]) == false);
- ok1(jmap_foo_get(map, idx[i]) == (struct foo *)NULL);
+ ok1(jmap_foo_test(map, idx[NUM]) == false);
+ ok1(jmap_foo_get(map, idx[NUM]) == (struct foo *)NULL);
ok1(jmap_foo_count(map) == 0);
ok1(jmap_foo_first(map) == (struct idx *)NULL);
ok1(jmap_foo_del(map, idx[0]) == false);
ok1(jmap_foo_count(map) == 0);
ok1(jmap_foo_first(map) == (struct idx *)NULL);
ok1(jmap_foo_del(map, idx[0]) == false);