dict_t*dict_new()
{
dict_t*d = rfx_alloc(sizeof(dict_t));
- dict_init(d);
+ dict_init(d, INITIAL_SIZE);
return d;
}
dict_t*dict_new2(type_t*t)
{
dict_t*d = rfx_alloc(sizeof(dict_t));
- dict_init(d);
+ dict_init(d, INITIAL_SIZE);
d->key_type = t;
return d;
}
-void dict_init(dict_t*h)
+void dict_init(dict_t*h, int size)
{
memset(h, 0, sizeof(dict_t));
- h->hashsize = INITIAL_SIZE;
+ h->hashsize = size;
h->slots = h->hashsize?(dictentry_t**)rfx_calloc(sizeof(dictentry_t*)*h->hashsize):0;
h->num = 0;
h->key_type = &charptr_type;
}
+dict_t*dict_clone(dict_t*o)
+{
+ dict_t*h = rfx_alloc(sizeof(dict_t));
+ memcpy(h, o, sizeof(dict_t));
+ h->slots = h->hashsize?(dictentry_t**)rfx_calloc(sizeof(dictentry_t*)*h->hashsize):0;
+ int t;
+ for(t=0;t<o->hashsize;t++) {
+ dictentry_t*e = o->slots[t];
+ while(e) {
+ dictentry_t*n = (dictentry_t*)rfx_alloc(sizeof(dictentry_t));
+ memcpy(n, e, sizeof(dictentry_t));
+ n->key = h->key_type->dup(e->key);
+ n->data = e->data;
+ n->next = h->slots[t];
+ h->slots[t] = n;
+ e = e->next;
+ }
+ }
+ return h;
+}
+
static void dict_expand(dict_t*h, int newlen)
{
assert(h->hashsize < newlen);
for(t=0;t<h->hashsize;t++) {
dictentry_t*e = h->slots[t];
while(e) {
- if(h->key_type==&charptr_type) {
+ if(h->key_type!=&charptr_type) {
fprintf(fi, "%s%08x=%08x\n", prefix, e->key, e->data);
} else {
fprintf(fi, "%s%s=%08x\n", prefix, e->key, e->data);
return 0;
}
-static dictentry_t* dict_get_slot(dict_t*h, const void*key)
+dictentry_t* dict_get_slot(dict_t*h, const void*key)
{
if(!h->num)
return 0;
rfx_free(e);
e = next;
}
+ h->slots[t]=0;
}
rfx_free(h->slots);
memset(h, 0, sizeof(dict_t));
map_internal_t*m;
map->internal = (map_internal_t*)rfx_calloc(sizeof(map_internal_t));
m = (map_internal_t*)map->internal;
- dict_init(&m->d);
+ dict_init(&m->d, INITIAL_SIZE);
}
void map_put(map_t*map, string_t t1, string_t t2)
{
commonlist_t**list = (commonlist_t**)_list;
commonlist_t* n = 0;
if(!*list) {
- n = malloc(sizeof(commonlist_t)+sizeof(listinfo_t));
+ n = (commonlist_t*)malloc(sizeof(commonlist_t)+sizeof(listinfo_t));
*list = n;
(*list)->info[0].size = 0;
} else {
(*list)->info[0].last = n;
(*list)->info[0].size++;
}
+/* notice: prepending uses slighly more space than appending */
+void list_prepend_(void*_list, void*entry)
+{
+ commonlist_t**list = (commonlist_t**)_list;
+ commonlist_t* n = (commonlist_t*)malloc(sizeof(commonlist_t)+sizeof(listinfo_t));
+ int size = 0;
+ commonlist_t* last = 0;
+ if(*list) {
+ last = (*list)->info[0].last;
+ size = (*list)->info[0].size;
+ }
+ n->next = *list;
+ n->entry = entry;
+ *list = n;
+ (*list)->info[0].last = last;
+ (*list)->info[0].size = size+1;
+}
void list_free_(void*_list)
{
commonlist_t**list = (commonlist_t**)_list;