3 Part of the swftools package.
5 Copyright (c) 2001 Matthias Kramm <kramm@quiss.org>
7 This file is distributed under the GPL, see file COPYING for details */
14 // ------------------------------- malloc, alloc routines ---------------------
17 char* strndup(const char*str, int size)
19 char*m = (char*)malloc(size+1);
25 void* qmalloc_internal(int len)
27 void*val = malloc(len);
29 printf("memory error! Couldn't reserve %d bytes\n", len);
30 fprintf(stderr, "memory error! Couldn't reserve %d bytes\n", len);
35 void* qrealloc_internal(void*old, int len)
37 void*val = realloc(old, len);
39 printf("memory error! Couldn't reserve %d bytes\n", len);
40 fprintf(stderr, "memory error! Couldn't reserve %d bytes\n", len);
45 void qfree_internal(void*old)
49 char*qstrdup(const char*string)
51 return strdup(string);
53 char*qstrndup(const char*string, int len)
55 return strndup(string, len);
58 // ------------------------------- mem_t --------------------------------------
60 void mem_init(mem_t*mem)
62 memset(mem, 0, sizeof(mem_t));
64 void mem_clear(mem_t*mem)
68 void mem_destroy(mem_t*mem)
73 static int mem_put_(mem_t*m,void*data, int length, int null)
76 m->pos += length + (null?1:0);
79 //m->len += 1024>length?1024:(null?length*2:length);
82 while(m->len < m->pos)
85 m->buffer = m->buffer?(char*)realloc(m->buffer,m->len):(char*)malloc(m->len);
87 memcpy(&m->buffer[n], data, length);
89 m->buffer[n + length] = 0;
92 int mem_put(mem_t*m,void*data, int length)
94 return mem_put_(m, data, length, 0);
96 int mem_putstring(mem_t*m,string_t str)
98 return mem_put_(m, str.str, str.len, 1);
101 // ------------------------------- ringbuffer_t -------------------------------
103 typedef struct _ringbuffer_internal_t
105 unsigned char*buffer;
109 } ringbuffer_internal_t;
111 void ringbuffer_init(ringbuffer_t*r)
113 ringbuffer_internal_t*i = (ringbuffer_internal_t*)malloc(sizeof(ringbuffer_internal_t));
114 memset(r, 0, sizeof(ringbuffer_t));
115 memset(i, 0, sizeof(ringbuffer_internal_t));
117 i->buffer = (unsigned char*)malloc(1024);
118 i->buffersize = 1024;
120 int ringbuffer_read(ringbuffer_t*r, void*buf, int len)
122 unsigned char* data = (unsigned char*)buf;
123 ringbuffer_internal_t*i = (ringbuffer_internal_t*)r->internal;
124 if(r->available < len)
128 if(i->readpos + len > i->buffersize) {
129 int read1 = i->buffersize-i->readpos;
130 memcpy(data, &i->buffer[i->readpos], read1);
131 memcpy(&data[read1], &i->buffer[0], len - read1);
132 i->readpos = len - read1;
134 memcpy(data, &i->buffer[i->readpos], len);
136 i->readpos %= i->buffersize;
141 void ringbuffer_put(ringbuffer_t*r, void*buf, int len)
143 unsigned char* data = (unsigned char*)buf;
144 ringbuffer_internal_t*i = (ringbuffer_internal_t*)r->internal;
146 if(i->buffersize - r->available < len)
149 int newbuffersize = i->buffersize;
150 int oldavailable = r->available;
151 newbuffersize*=3;newbuffersize/=2; /*grow at least by 50% each time */
153 if(newbuffersize < r->available + len)
154 newbuffersize = r->available + len + 1024;
156 buf2 = (unsigned char*)malloc(newbuffersize);
157 ringbuffer_read(r, buf2, r->available);
160 i->buffersize = newbuffersize;
162 i->writepos = oldavailable;
163 r->available = oldavailable;
165 if(i->writepos + len > i->buffersize) {
166 int read1 = i->buffersize-i->writepos;
167 memcpy(&i->buffer[i->writepos], data, read1);
168 memcpy(&i->buffer[0], &data[read1], len - read1);
169 i->writepos = len - read1;
171 memcpy(&i->buffer[i->writepos], data, len);
173 i->writepos %= i->buffersize;
177 void ringbuffer_clear(ringbuffer_t*r)
179 ringbuffer_internal_t*i = (ringbuffer_internal_t*)r->internal;
184 // ------------------------------- string_t -----------------------------------
186 void string_set2(string_t*str, char*text, int len)
191 void string_set(string_t*str, char*text)
193 str->len = strlen(text);
196 void string_dup2(string_t*str, const char*text, int len)
199 str->str = strndup(text, len);
201 void string_dup(string_t*str, const char*text)
203 str->len = strlen(text);
204 str->str = strdup(text);
206 int string_equals(string_t*str, const char*text)
208 int l = strlen(text);
209 if(str->len == l && !strncmp(str->str, text, l))
213 int string_equals2(string_t*str, string_t*str2)
215 if(str->len == str2->len && !strncmp(str->str, str2->str, str->len))
219 char* string_cstr(string_t*str)
221 return strndup(str->str, str->len);
224 // ------------------------------- stringarray_t ------------------------------
226 typedef struct _stringarray_internal_t
231 } stringarray_internal_t;
232 void stringarray_init(stringarray_t*sa)
234 stringarray_internal_t*s;
235 sa->internal = (stringarray_internal_t*)malloc(sizeof(stringarray_internal_t));
236 memset(sa->internal, 0, sizeof(stringarray_internal_t));
237 s = (stringarray_internal_t*)sa->internal;
241 void stringarray_put(stringarray_t*sa, string_t str)
243 stringarray_internal_t*s = (stringarray_internal_t*)sa->internal;
245 pos = mem_putstring(&s->data, str);
246 mem_put(&s->pos, &pos, sizeof(int));
249 char* stringarray_at(stringarray_t*sa, int pos)
251 stringarray_internal_t*s = (stringarray_internal_t*)sa->internal;
253 if(pos<0 || pos>=s->num)
255 p = *(int*)&s->pos.buffer[pos*sizeof(int)];
258 return &s->data.buffer[p];
260 string_t stringarray_at2(stringarray_t*sa, int pos)
263 s.str = stringarray_at(sa, pos);
264 s.len = s.str?strlen(s.str):0;
267 void stringarray_del(stringarray_t*sa, int pos)
269 stringarray_internal_t*s = (stringarray_internal_t*)sa->internal;
270 *(int*)&s->pos.buffer[pos*sizeof(int)] = -1;
272 int stringarray_find(stringarray_t*sa, string_t* str)
274 stringarray_internal_t*s = (stringarray_internal_t*)sa->internal;
276 for(t=0;t<s->num;t++) {
277 string_t s = stringarray_at2(sa, t);
278 if(s.str && string_equals2(&s, str)) {
284 void stringarray_clear(stringarray_t*sa)
286 stringarray_internal_t*s = (stringarray_internal_t*)sa->internal;
291 void stringarray_destroy(stringarray_t*sa)
293 stringarray_clear(sa);
298 // ------------------------------- map_t --------------------------------------
300 typedef struct _map_internal_t
303 stringarray_t values;
307 void map_init(map_t*map)
310 map->internal = (map_internal_t*)malloc(sizeof(map_internal_t));
311 memset(map->internal, 0, sizeof(map_internal_t));
312 m = (map_internal_t*)map->internal;
313 stringarray_init(&m->keys);
314 stringarray_init(&m->values);
316 void map_put(map_t*map, string_t t1, string_t t2)
318 map_internal_t*m = (map_internal_t*)map->internal;
319 stringarray_put(&m->keys, t1);
320 stringarray_put(&m->values, t2);
323 char* map_lookup(map_t*map, const char*name)
326 map_internal_t*m = (map_internal_t*)map->internal;
328 string_set(&str, (char*)name);
329 s = stringarray_find(&m->keys, &str);
331 string_t s2 = stringarray_at2(&m->values, s);
336 void map_dump(map_t*map, FILE*fi, const char*prefix)
339 map_internal_t*m = (map_internal_t*)map->internal;
340 for(t=0;t<m->num;t++) {
341 string_t s1 = stringarray_at2(&m->keys, t);
342 string_t s2 = stringarray_at2(&m->values, t);
343 fprintf(fi, "%s%s=%s\n", prefix, s1.str, s2.str);
346 void map_clear(map_t*map)
348 map_internal_t*m = (map_internal_t*)map->internal;
349 stringarray_clear(&m->keys);
350 stringarray_clear(&m->values);
353 void map_destroy(map_t*map)
359 // ------------------------------- dictionary_t -------------------------------
361 typedef struct _dictionary_internal_t
366 } dictionary_internal_t;
368 void dictionary_init(dictionary_t*dict)
370 dictionary_internal_t*d;
371 dict->internal = (dictionary_internal_t*)malloc(sizeof(dictionary_internal_t));
372 memset(dict->internal, 0, sizeof(dictionary_internal_t));
373 d = (dictionary_internal_t*)dict->internal;
374 stringarray_init(&d->keys);
375 mem_init(&d->values);
377 void dictionary_put(dictionary_t*dict, string_t t1, void* t2)
379 dictionary_internal_t*d = (dictionary_internal_t*)dict->internal;
381 s = stringarray_find(&d->keys, &t1);
384 *(void**)(&d->values.buffer[s*sizeof(void*)]) = t2;
386 stringarray_put(&d->keys, t1);
387 mem_put(&d->values, &t2, sizeof(void*));
391 void dictionary_put2(dictionary_t*dict, const char*t1, void* t2)
394 string_set(&s, (char*)t1);
395 dictionary_put(dict, s, t2);
397 void* dictionary_lookup(dictionary_t*dict, const char*name)
400 dictionary_internal_t*d = (dictionary_internal_t*)dict->internal;
402 string_set(&str, (char*)name);
403 s = stringarray_find(&d->keys, &str);
405 return *(void**)&d->values.buffer[sizeof(void*)*s];
409 void dictionary_dump(dictionary_t*dict, FILE*fi, const char*prefix)
411 dictionary_internal_t*d = (dictionary_internal_t*)dict->internal;
413 for(t=0;t<d->num;t++) {
414 string_t s1 = stringarray_at2(&d->keys, t);
415 fprintf(fi, "%s%s=%08x\n", prefix, s1.str, *(void**)&d->values.buffer[sizeof(void*)*t]);
418 void dictionary_del(dictionary_t*dict, const char* name)
420 dictionary_internal_t*d = (dictionary_internal_t*)dict->internal;
423 string_set(&str, (char*)name);
424 s = stringarray_find(&d->keys, &str);
426 *(void**)(&d->values.buffer[s*sizeof(void*)]) = 0;
427 stringarray_del(&d->keys, s);
430 void dictionary_clear(dictionary_t*dict)
432 dictionary_internal_t*d = (dictionary_internal_t*)dict->internal;
433 stringarray_clear(&d->keys);
434 mem_clear(&d->values);
437 void dictionary_destroy(dictionary_t*dict)
439 dictionary_clear(dict);