int n = m->pos;
m->pos += length + (null?1:0);
if(m->pos > m->len) {
- m->len = (m->pos+63)&~63;
+ int v1 = (m->pos+63)&~63;
+ int v2 = m->len + m->len / 2;
+ m->len = v1>v2?v1:v2;
m->buffer = m->buffer?(char*)rfx_realloc(m->buffer,m->len):(char*)rfx_alloc(m->len);
}
assert(n+length <= m->len);
{
return mem_put_(m, str.str, str.len, 1);
}
+int mem_get(mem_t*m, void*data, int length)
+{
+ if(m->read_pos + length > m->pos) {
+ length = m->pos - m->read_pos;
+ }
+ memcpy(data, m->buffer+m->read_pos, length);
+ m->read_pos += length;
+ return length;
+}
// ------------------------------- ringbuffer_t -------------------------------
return nodes;
}
+// ------------------------------- trie --------------------------------------
+
+void trie_put(trie_t**t, unsigned const char*id)
+{
+ if(!*t) {
+ (*t) = rfx_calloc(sizeof(trie_t));
+ (*t)->rest = (unsigned char*)strdup(id);
+ return;
+ }
+ if((*t)->rest && (*t)->rest[0]) {
+ // shift whatever's currently in here one node down
+ trie_put(&(*t)->row[(*t)->rest[0]], (*t)->rest+1);
+ (*t)->rest = 0;
+ }
+ if(id[0]) {
+ trie_put(&(*t)->row[id[0]], id+1);
+ } else {
+ (*t)->rest = "";
+ }
+}
+
+int trie_lookup(trie_t*t, unsigned const char*id)
+{
+ while(t) {
+ if(t->rest && !strcmp(t->rest, id))
+ return 1;
+ t = t->row[id[0]];
+ if(!*id)
+ return 0;
+ id++;
+ }
+ return 0;
+}
+
// ------------------------------- crc32 --------------------------------------
static unsigned int*crc32 = 0;
static void crc32_init(void)
}
unsigned int ptr_hash(const void*o)
{
- return string_hash3(o, sizeof(o));
+ return string_hash3((const char*)&o, sizeof(o));
}
void* ptr_dup(const void*o)
{
h->num = 0;
h->key_type = &charptr_type;
}
+void dict_init2(dict_t*h, type_t*t, int size)
+{
+ memset(h, 0, sizeof(dict_t));
+ h->hashsize = size;
+ h->slots = h->hashsize?(dictentry_t**)rfx_calloc(sizeof(dictentry_t*)*h->hashsize):0;
+ h->num = 0;
+ h->key_type = t;
+}
dict_t*dict_clone(dict_t*o)
{
memset(e, 0, sizeof(dictentry_t));
rfx_free(e);
if(e == head) {
- h->slots[hash] = 0;
+ h->slots[hash] = next;
} else {
assert(prev);
prev->next = next;
}
}
-void dict_free_all(dict_t*h, void (*freeFunction)(void*))
+void dict_free_all(dict_t*h, char free_keys, void (*free_data_function)(void*))
{
int t;
for(t=0;t<h->hashsize;t++) {
dictentry_t*e = h->slots[t];
while(e) {
dictentry_t*next = e->next;
- h->key_type->free(e->key);
- if(freeFunction) {
- freeFunction(e->data);
+ if(free_keys) {
+ h->key_type->free(e->key);
+ }
+ if(free_data_function) {
+ free_data_function(e->data);
}
memset(e, 0, sizeof(dictentry_t));
rfx_free(e);
memset(h, 0, sizeof(dict_t));
}
+void dict_clear_shallow(dict_t*h)
+{
+ dict_free_all(h, 0, 0);
+}
+
void dict_clear(dict_t*h)
{
- dict_free_all(h, 0);
+ dict_free_all(h, 1, 0);
+}
+
+void dict_destroy_shallow(dict_t*dict)
+{
+ dict_clear_shallow(dict);
+ rfx_free(dict);
}
void dict_destroy(dict_t*dict)
void map_clear(map_t*map)
{
map_internal_t*m = (map_internal_t*)map->internal;
- dict_free_all(&m->d, freestring);
+ dict_free_all(&m->d, 1, freestring);
rfx_free(m);
}
void map_destroy(map_t*map)
void*array_getkey(array_t*array, int nr) {
if(nr > array->num || nr<0) {
printf("error: reference to element %d in array[%d]\n", nr, array->num);
- *(int*)0 = 0xdead;
return 0;
}
return array->d[nr].name;
void*array_getvalue(array_t*array, int nr) {
if(nr > array->num || nr<0) {
printf("error: reference to element %d in array[%d]\n", nr, array->num);
- *(int*)0 = 0xdead;
return 0;
}
return array->d[nr].data;
}
*list = 0;
}
+void list_deep_free_(void*_list)
+{
+ commonlist_t**list = (commonlist_t**)_list;
+ commonlist_t*l = *list;
+ while(l) {
+ commonlist_t*next = l->next;
+ if(l->entry) {
+ free(l->entry);l->entry=0;
+ }
+ free(l);
+ l = next;
+ }
+ *list = 0;
+}
void*list_clone_(void*_list)
{
commonlist_t*l = *(commonlist_t**)_list;