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;
110 } ringbuffer_internal_t;
112 void ringbuffer_init(ringbuffer_t*r)
114 ringbuffer_internal_t*i = (ringbuffer_internal_t*)malloc(sizeof(ringbuffer_internal_t));
115 memset(r, 0, sizeof(ringbuffer_t));
116 memset(i, 0, sizeof(ringbuffer_internal_t));
118 i->buffer = (unsigned char*)malloc(1024);
119 i->buffersize = 1024;
121 int ringbuffer_read(ringbuffer_t*r, void*buf, int len)
123 unsigned char* data = (unsigned char*)buf;
124 ringbuffer_internal_t*i = (ringbuffer_internal_t*)r->internal;
125 if(i->available < len)
129 if(i->readpos + len > i->buffersize) {
130 int read1 = i->buffersize-i->readpos;
131 memcpy(data, &i->buffer[i->readpos], read1);
132 memcpy(&data[read1], &i->buffer[0], len - read1);
133 i->readpos = len - read1;
135 memcpy(data, &i->buffer[i->readpos], len);
137 i->readpos %= i->buffersize;
142 void ringbuffer_put(ringbuffer_t*r, void*buf, int len)
144 unsigned char* data = (unsigned char*)buf;
145 ringbuffer_internal_t*i = (ringbuffer_internal_t*)r->internal;
147 /* if( (i->writepos < i->readpos && i->writepos + len >= i->readpos) ||
148 (i->writepos > i->readpos && i->writepos + len >= i->buffersize &&
149 (i->writepos + len) % i->buffersize >= i->readpos)
151 if(i->buffersize - i->available < len)
154 int newbuffersize = i->buffersize;
155 newbuffersize*=3;newbuffersize/=2; /*grow by 50% each time */
157 if(newbuffersize < i->available + len)
158 newbuffersize = i->available + len;
160 buf2 = (unsigned char*)malloc(newbuffersize);
161 ringbuffer_read(r, buf2, i->available);
164 i->buffersize = newbuffersize;
166 i->readpos = i->available;
168 if(i->writepos + len > i->buffersize) {
169 int read1 = i->buffersize-i->writepos;
170 memcpy(&i->buffer[i->writepos], data, read1);
171 memcpy(&i->buffer[0], &data[read1], len - read1);
172 i->writepos = len - read1;
174 memcpy(&i->buffer[i->writepos], data, len);
176 i->writepos %= i->buffersize;
180 void ringbuffer_clear(ringbuffer_t*r)
182 ringbuffer_internal_t*i = (ringbuffer_internal_t*)r->internal;
187 // ------------------------------- string_t -----------------------------------
189 void string_set2(string_t*str, char*text, int len)
194 void string_set(string_t*str, char*text)
196 str->len = strlen(text);
199 void string_dup2(string_t*str, const char*text, int len)
202 str->str = strndup(text, len);
204 void string_dup(string_t*str, const char*text)
206 str->len = strlen(text);
207 str->str = strdup(text);
209 int string_equals(string_t*str, const char*text)
211 int l = strlen(text);
212 if(str->len == l && !strncmp(str->str, text, l))
216 int string_equals2(string_t*str, string_t*str2)
218 if(str->len == str2->len && !strncmp(str->str, str2->str, str->len))
222 char* string_cstr(string_t*str)
224 return strndup(str->str, str->len);
227 // ------------------------------- stringarray_t ------------------------------
229 typedef struct _stringarray_internal_t
234 } stringarray_internal_t;
235 void stringarray_init(stringarray_t*sa)
237 stringarray_internal_t*s;
238 sa->internal = (stringarray_internal_t*)malloc(sizeof(stringarray_internal_t));
239 memset(sa->internal, 0, sizeof(stringarray_internal_t));
240 s = (stringarray_internal_t*)sa->internal;
244 void stringarray_put(stringarray_t*sa, string_t str)
246 stringarray_internal_t*s = (stringarray_internal_t*)sa->internal;
248 pos = mem_putstring(&s->data, str);
249 mem_put(&s->pos, &pos, sizeof(int));
252 char* stringarray_at(stringarray_t*sa, int pos)
254 stringarray_internal_t*s = (stringarray_internal_t*)sa->internal;
256 if(pos<0 || pos>=s->num)
258 p = *(int*)&s->pos.buffer[pos*sizeof(int)];
261 return &s->data.buffer[p];
263 string_t stringarray_at2(stringarray_t*sa, int pos)
266 s.str = stringarray_at(sa, pos);
267 s.len = s.str?strlen(s.str):0;
270 void stringarray_del(stringarray_t*sa, int pos)
272 stringarray_internal_t*s = (stringarray_internal_t*)sa->internal;
273 *(int*)&s->pos.buffer[pos*sizeof(int)] = -1;
275 int stringarray_find(stringarray_t*sa, string_t* str)
277 stringarray_internal_t*s = (stringarray_internal_t*)sa->internal;
279 for(t=0;t<s->num;t++) {
280 string_t s = stringarray_at2(sa, t);
281 if(s.str && string_equals2(&s, str)) {
287 void stringarray_clear(stringarray_t*sa)
289 stringarray_internal_t*s = (stringarray_internal_t*)sa->internal;
294 void stringarray_destroy(stringarray_t*sa)
296 stringarray_clear(sa);
301 // ------------------------------- map_t --------------------------------------
303 typedef struct _map_internal_t
306 stringarray_t values;
310 void map_init(map_t*map)
313 map->internal = (map_internal_t*)malloc(sizeof(map_internal_t));
314 memset(map->internal, 0, sizeof(map_internal_t));
315 m = (map_internal_t*)map->internal;
316 stringarray_init(&m->keys);
317 stringarray_init(&m->values);
319 void map_put(map_t*map, string_t t1, string_t t2)
321 map_internal_t*m = (map_internal_t*)map->internal;
322 stringarray_put(&m->keys, t1);
323 stringarray_put(&m->values, t2);
326 char* map_lookup(map_t*map, const char*name)
329 map_internal_t*m = (map_internal_t*)map->internal;
331 string_set(&str, (char*)name);
332 s = stringarray_find(&m->keys, &str);
334 string_t s2 = stringarray_at2(&m->values, s);
339 void map_dump(map_t*map, FILE*fi, const char*prefix)
342 map_internal_t*m = (map_internal_t*)map->internal;
343 for(t=0;t<m->num;t++) {
344 string_t s1 = stringarray_at2(&m->keys, t);
345 string_t s2 = stringarray_at2(&m->values, t);
346 fprintf(fi, "%s%s=%s\n", prefix, s1.str, s2.str);
349 void map_clear(map_t*map)
351 map_internal_t*m = (map_internal_t*)map->internal;
352 stringarray_clear(&m->keys);
353 stringarray_clear(&m->values);
356 void map_destroy(map_t*map)
362 // ------------------------------- dictionary_t -------------------------------
364 typedef struct _dictionary_internal_t
369 } dictionary_internal_t;
371 void dictionary_init(dictionary_t*dict)
373 dictionary_internal_t*d;
374 dict->internal = (dictionary_internal_t*)malloc(sizeof(dictionary_internal_t));
375 memset(dict->internal, 0, sizeof(dictionary_internal_t));
376 d = (dictionary_internal_t*)dict->internal;
377 stringarray_init(&d->keys);
378 mem_init(&d->values);
380 void dictionary_put(dictionary_t*dict, string_t t1, void* t2)
382 dictionary_internal_t*d = (dictionary_internal_t*)dict->internal;
384 s = stringarray_find(&d->keys, &t1);
387 *(void**)(&d->values.buffer[s*sizeof(void*)]) = t2;
389 stringarray_put(&d->keys, t1);
390 mem_put(&d->values, &t2, sizeof(void*));
394 void dictionary_put2(dictionary_t*dict, const char*t1, void* t2)
397 string_set(&s, (char*)t1);
398 dictionary_put(dict, s, t2);
400 void* dictionary_lookup(dictionary_t*dict, const char*name)
403 dictionary_internal_t*d = (dictionary_internal_t*)dict->internal;
405 string_set(&str, (char*)name);
406 s = stringarray_find(&d->keys, &str);
408 return *(void**)&d->values.buffer[sizeof(void*)*s];
412 void dictionary_dump(dictionary_t*dict, FILE*fi, const char*prefix)
414 dictionary_internal_t*d = (dictionary_internal_t*)dict->internal;
416 for(t=0;t<d->num;t++) {
417 string_t s1 = stringarray_at2(&d->keys, t);
418 fprintf(fi, "%s%s=%08x\n", prefix, s1.str, *(void**)&d->values.buffer[sizeof(void*)*t]);
421 void dictionary_del(dictionary_t*dict, const char* name)
423 dictionary_internal_t*d = (dictionary_internal_t*)dict->internal;
426 string_set(&str, (char*)name);
427 s = stringarray_find(&d->keys, &str);
429 *(void**)(&d->values.buffer[s*sizeof(void*)]) = 0;
430 stringarray_del(&d->keys, s);
433 void dictionary_clear(dictionary_t*dict)
435 dictionary_internal_t*d = (dictionary_internal_t*)dict->internal;
436 stringarray_clear(&d->keys);
437 mem_clear(&d->values);
440 void dictionary_destroy(dictionary_t*dict)
442 dictionary_clear(dict);