-#include "io.h"
+#include "imager.h"
+#include "imageri.h"
#include <stdlib.h>
#ifndef _MSC_VER
#include <unistd.h>
return buf;
}
-
-
-
void
malloc_state(void) {
int i, total = 0;
+ i_clear_error();
mm_log((0,"malloc_state()\n"));
bndcheck_all();
for(i=0; i<MAXMAL; i++) if (malloc_pointers[i].ptr != NULL) {
return buf;
}
-
-
-
-
-
+void *
+(mymalloc)(int size) {
+ return mymalloc_file_line(size, "unknown", 0);
+}
void*
myrealloc_file_line(void *ptr, size_t newsize, char* file, int line) {
return buf;
}
-
-
+void *
+(myrealloc)(void *ptr, size_t newsize) {
+ return myrealloc_file_line(ptr, newsize, "unknown", 0);
+}
static
void
bndcheck(idx);
}
-
-
-
-
void
myfree_file_line(void *p, char *file, int line) {
char *pp = p;
int match = 0;
int i;
+
+ if (p == NULL)
+ return;
for(i=0; i<MAXMAL; i++) if (malloc_pointers[i].ptr == p) {
mm_log((1,"myfree_file_line: pointer %i (%s) freed at %s (%i)\n", i, malloc_pointers[i].comm, file, line));
malloc_pointers[i].ptr = NULL;
match++;
}
+
+ mm_log((1, "myfree_file_line: freeing address %p (real %p)\n", pp, pp-UNDRRNVAL));
if (match != 1) {
mm_log((1, "myfree_file_line: INCONSISTENT REFCOUNT %d at %s (%i)\n", match, file, line));
exit(255);
}
- mm_log((1, "myfree_file_line: freeing address %p (real %p)\n", pp, pp-UNDRRNVAL));
free(pp-UNDRRNVAL);
}
+void
+(myfree)(void *block) {
+ myfree_file_line(block, "unknown", 0);
+}
+
#else
#define malloc_comm(a,b) (mymalloc(a))
void
malloc_state() {
- printf("malloc_state: not in debug mode\n");
}
void*
mymalloc(int size) {
void *buf;
+ if (size < 0) {
+ fprintf(stderr, "Attempt to allocate size %d\n", size);
+ exit(3);
+ }
+
if ( (buf = malloc(size)) == NULL ) {
mm_log((1, "mymalloc: unable to malloc %d\n", size));
fprintf(stderr,"Unable to malloc %d.\n", size); exit(3);
return buf;
}
+void *
+mymalloc_file_line(size_t size, char *file, int line) {
+ return mymalloc(size);
+}
+
void
myfree(void *p) {
mm_log((1, "myfree(p %p)\n", p));
free(p);
}
+void
+myfree_file_line(void *p, char *file, int line) {
+ myfree(p);
+}
+
void *
myrealloc(void *block, size_t size) {
void *result;
return result;
}
+void *
+myrealloc_file_line(void *block, size_t newsize, char *file, int size) {
+ return myrealloc(block, newsize);
+}
+
#endif /* IMAGER_MALLOC_DEBUG */
+/* memory pool implementation */
+
+void
+i_mempool_init(i_mempool *mp) {
+ mp->alloc = 10;
+ mp->used = 0;
+ mp->p = mymalloc(sizeof(void*)*mp->alloc);
+}
+
+void
+i_mempool_extend(i_mempool *mp) {
+ mp->p = myrealloc(mp->p, mp->alloc * 2);
+ mp->alloc *=2;
+}
+
+void *
+i_mempool_alloc(i_mempool *mp, size_t size) {
+ if (mp->used == mp->alloc) i_mempool_extend(mp);
+ mp->p[mp->used] = mymalloc(size);
+ mp->used++;
+ return mp->p[mp->used-1];
+}
+
+
+void
+i_mempool_destroy(i_mempool *mp) {
+ unsigned int i;
+ for(i=0; i<mp->used; i++) myfree(mp->p[i]);
+ myfree(mp->p);
+}
+
/* Should these really be here? */
#undef min
#undef max
-int
-min(int a,int b) {
+i_img_dim
+i_minx(i_img_dim a, i_img_dim b) {
if (a<b) return a; else return b;
}
-int
-max(int a,int b) {
+i_img_dim
+i_maxx(i_img_dim a, i_img_dim b) {
if (a>b) return a; else return b;
}
+
+struct utf8_size {
+ int mask, expect;
+ int size;
+};
+
+struct utf8_size utf8_sizes[] =
+{
+ { 0x80, 0x00, 1 },
+ { 0xE0, 0xC0, 2 },
+ { 0xF0, 0xE0, 3 },
+ { 0xF8, 0xF0, 4 },
+};
+
+/*
+=item i_utf8_advance(char **p, size_t *len)
+
+Retrieve a C<UTF-8> character from the stream.
+
+Modifies *p and *len to indicate the consumed characters.
+
+This doesn't support the extended C<UTF-8> encoding used by later
+versions of Perl.
+
+This doesn't check that the C<UTF-8> character is using the shortest
+possible representation.
+
+=cut
+*/
+
+unsigned long
+i_utf8_advance(char const **p, size_t *len) {
+ unsigned char c;
+ int i, ci, clen = 0;
+ unsigned char codes[3];
+ if (*len == 0)
+ return ~0UL;
+ c = *(*p)++; --*len;
+
+ for (i = 0; i < sizeof(utf8_sizes)/sizeof(*utf8_sizes); ++i) {
+ if ((c & utf8_sizes[i].mask) == utf8_sizes[i].expect) {
+ clen = utf8_sizes[i].size;
+ break;
+ }
+ }
+ if (clen == 0 || *len < clen-1) {
+ --*p; ++*len;
+ return ~0UL;
+ }
+
+ /* check that each character is well formed */
+ i = 1;
+ ci = 0;
+ while (i < clen) {
+ if (((*p)[ci] & 0xC0) != 0x80) {
+ --*p; ++*len;
+ return ~0UL;
+ }
+ codes[ci] = (*p)[ci];
+ ++ci; ++i;
+ }
+ *p += clen-1; *len -= clen-1;
+ if (c & 0x80) {
+ if ((c & 0xE0) == 0xC0) {
+ return ((c & 0x1F) << 6) + (codes[0] & 0x3F);
+ }
+ else if ((c & 0xF0) == 0xE0) {
+ return ((c & 0x0F) << 12) | ((codes[0] & 0x3F) << 6) | (codes[1] & 0x3f);
+ }
+ else if ((c & 0xF8) == 0xF0) {
+ return ((c & 0x07) << 18) | ((codes[0] & 0x3F) << 12)
+ | ((codes[1] & 0x3F) << 6) | (codes[2] & 0x3F);
+ }
+ else {
+ *p -= clen; *len += clen;
+ return ~0UL;
+ }
+ }
+ else {
+ return c;
+ }
+}
+
projects / imager.git / blobdiff