Rename malloc functions for arrays (fz_calloc and fz_realloc).

14 files changed, 68 insertions, 150 deletions

diff --git a/fitz/base_context.c b/fitz/base_context.c
index db702e8e..bce0cba1 100644
--- a/fitz/base_context.c
+++ b/fitz/base_context.c
@@ -18,27 +18,23 @@ fz_free_context(fz_context *ctx)
 	if (ctx->error)
 	{
 		assert(ctx->error->top == -1);
-		ctx->alloc->free(ctx->alloc->opaque, ctx->error);
+		free(ctx->error);
 	}
 
 	/* Free the context itself */
-	ctx->alloc->free(ctx->alloc->opaque, ctx);
-
-	/* We do NOT free the allocator! */
+	free(ctx);
 }
 
 fz_context *
-fz_new_context(fz_alloc_context *alloc)
+fz_new_context(void)
 {
 	fz_context *ctx;
 
-	assert(alloc != NULL);
-	ctx = alloc->malloc(alloc->opaque, sizeof(fz_context));
-	if (ctx == NULL)
+	ctx = malloc(sizeof(fz_context));
+	if (!ctx)
 		return NULL;
-	ctx->alloc = alloc;
 
-	ctx->error = alloc->malloc(alloc->opaque, sizeof(fz_error_context));
+	ctx->error = malloc(sizeof(fz_error_context));
 	if (!ctx->error)
 		goto cleanup;
 	ctx->error->top = -1;
@@ -57,5 +53,5 @@ cleanup:
 fz_context *
 fz_clone_context(fz_context *ctx)
 {
-	return fz_new_context(ctx->alloc);
+	return fz_new_context();
 }
diff --git a/fitz/base_hash.c b/fitz/base_hash.c
index f754644d..43bdf2d1 100644
--- a/fitz/base_hash.c
+++ b/fitz/base_hash.c
@@ -52,7 +52,7 @@ fz_new_hash_table(fz_context *ctx, int initialsize, int keylen)
 	table->keylen = keylen;
 	table->size = initialsize;
 	table->load = 0;
-	table->ents = fz_calloc(ctx, table->size, sizeof(fz_hash_entry));
+	table->ents = fz_malloc_array(ctx, table->size, sizeof(fz_hash_entry));
 
 	return table;
 }
@@ -103,7 +103,7 @@ fz_resize_hash(fz_context *ctx, fz_hash_table *table, int newsize)
 		return;
 	}
 
-	table->ents = fz_calloc(ctx, newsize, sizeof(fz_hash_entry));
+	table->ents = fz_malloc_array(ctx, newsize, sizeof(fz_hash_entry));
 	memset(table->ents, 0, sizeof(fz_hash_entry) * newsize);
 	table->size = newsize;
 	table->load = 0;
diff --git a/fitz/base_memory.c b/fitz/base_memory.c
index 643c85b6..27474cc3 100644
--- a/fitz/base_memory.c
+++ b/fitz/base_memory.c
@@ -1,130 +1,72 @@
 #include "fitz.h"
 
 void *
-fz_malloc(fz_context *ctx, size_t size)
+fz_malloc(fz_context *ctx, unsigned int size)
 {
-	void *p;
-	fz_alloc_context *alloc;
-
-	assert(ctx != NULL);
-	alloc = ctx->alloc;
-	assert(alloc != NULL);
-	p = alloc->malloc(alloc->opaque, size);
+	void *p = malloc(size);
 	if (!p)
 	{
-		fz_throw(ctx, "malloc failed (%d bytes)", size);
+		fprintf(stderr, "fatal error: out of memory\n");
+		abort();
 	}
 	return p;
 }
 
-void *fz_calloc(fz_context *ctx, size_t count, size_t size)
+void *
+fz_malloc_array(fz_context *ctx, unsigned int count, unsigned int size)
 {
 	void *p;
-	fz_alloc_context *alloc;
 
-	assert(ctx != NULL);
-	alloc = ctx->alloc;
-	assert(alloc != NULL);
-	p = alloc->calloc(alloc->opaque, count, size);
-	if (!p)
+	if (count == 0 || size == 0)
+		return 0;
+
+	if (count > UINT_MAX / size)
 	{
-		fz_throw(ctx, "calloc failed (%d x %d bytes)", count, size);
+		fprintf(stderr, "fatal error: out of memory (integer overflow)\n");
+		abort();
 	}
-	return p;
-}
 
-void *
-fz_realloc(fz_context *ctx, void *p, size_t size)
-{
-	fz_alloc_context *alloc;
-
-	assert(ctx != NULL);
-	alloc = ctx->alloc;
-	assert(alloc != NULL);
-	p = alloc->realloc(alloc->opaque, p, size);
+	p = malloc(count * size);
 	if (!p)
 	{
-		fz_throw(ctx, "realloc failed (%d bytes)", size);
+		fprintf(stderr, "fatal error: out of memory\n");
+		abort();
 	}
 	return p;
 }
 
-void
-fz_free(fz_context *ctx, void *p)
-{
-	fz_alloc_context *alloc;
-
-	assert(ctx != NULL);
-	alloc = ctx->alloc;
-	assert(alloc != NULL);
-	alloc->free(alloc->opaque, p);
-}
-
-void *
-fz_malloc_nothrow(fz_context *ctx, size_t size)
-{
-	fz_alloc_context *alloc;
-
-	assert(ctx != NULL);
-	alloc = ctx->alloc;
-	assert(alloc != NULL);
-	return alloc->malloc(alloc->opaque, size);
-}
-
-void *fz_calloc_nothrow(fz_context *ctx, size_t count, size_t size)
-{
-	fz_alloc_context *alloc;
-
-	assert(ctx != NULL);
-	alloc = ctx->alloc;
-	assert(alloc != NULL);
-	return alloc->calloc(alloc->opaque, count, size);
-}
-
 void *
-fz_realloc_nothrow(fz_context *ctx, void *p, size_t size)
+fz_resize_array(fz_context *ctx, void *p, unsigned int count, unsigned int size)
 {
-	fz_alloc_context *alloc;
+	void *np;
 
-	assert(ctx != NULL);
-	alloc = ctx->alloc;
-	assert(alloc != NULL);
-	return alloc->realloc(alloc->opaque, p, size);
-}
-
-void *
-fz_malloc_default(void *opaque, size_t size)
-{
-	return malloc(size);
-}
+	if (count == 0 || size == 0)
+	{
+		fz_free(ctx, p);
+		return 0;
+	}
 
-void *
-fz_calloc_default(void *opaque, size_t count, size_t size)
-{
-	return calloc(count, size);
-}
+	if (count > UINT_MAX / size)
+	{
+		fprintf(stderr, "fatal error: out of memory (integer overflow)\n");
+		abort();
+	}
 
-void *
-fz_realloc_default(void *opaque, void *p, size_t size)
-{
-	return realloc(p, size);
+	np = realloc(p, count * size);
+	if (np == NULL)
+	{
+		fprintf(stderr, "fatal error: out of memory\n");
+		abort();
+	}
+	return np;
 }
 
 void
-fz_free_default(void *opaque, void *p)
+fz_free(fz_context *ctx, void *p)
 {
 	free(p);
 }
 
-fz_alloc_context fz_alloc_default =
-{
-	(void *)-1,
-	fz_malloc_default,
-	fz_realloc_default,
-	fz_free_default,
-	fz_calloc_default
-};
-
 char *
 fz_strdup(fz_context *ctx, char *s)
 {
diff --git a/fitz/base_object.c b/fitz/base_object.c
index c515b70d..fd8339a4 100644
--- a/fitz/base_object.c
+++ b/fitz/base_object.c
@@ -389,7 +389,7 @@ fz_new_array(fz_context *ctx, int initialcap)
 	obj->u.a.len = 0;
 	obj->u.a.cap = initialcap > 1 ? initialcap : 6;
 
-	obj->u.a.items = fz_calloc(ctx, obj->u.a.cap, sizeof(fz_obj*));
+	obj->u.a.items = fz_malloc_array(ctx, obj->u.a.cap, sizeof(fz_obj*));
 	for (i = 0; i < obj->u.a.cap; i++)
 		obj->u.a.items[i] = NULL;
 
@@ -469,7 +469,7 @@ fz_array_push(fz_obj *obj, fz_obj *item)
 		{
 			int i;
 			obj->u.a.cap = (obj->u.a.cap * 3) / 2;
-			obj->u.a.items = fz_realloc(obj->ctx, obj->u.a.items, obj->u.a.cap * sizeof(fz_obj*));
+			obj->u.a.items = fz_resize_array(obj->ctx, obj->u.a.items, obj->u.a.cap, sizeof(fz_obj*));
 			for (i = obj->u.a.len ; i < obj->u.a.cap; i++)
 				obj->u.a.items[i] = NULL;
 		}
@@ -491,7 +491,7 @@ fz_array_insert(fz_obj *obj, fz_obj *item)
 		{
 			int i;
 			obj->u.a.cap = (obj->u.a.cap * 3) / 2;
-			obj->u.a.items = fz_realloc(obj->ctx, obj->u.a.items, obj->u.a.cap * sizeof(fz_obj*));
+			obj->u.a.items = fz_resize_array(obj->ctx, obj->u.a.items, obj->u.a.cap, sizeof(fz_obj*));
 			for (i = obj->u.a.len ; i < obj->u.a.cap; i++)
 				obj->u.a.items[i] = NULL;
 		}
@@ -525,7 +525,7 @@ fz_new_dict(fz_context *ctx, int initialcap)
 	obj->u.d.len = 0;
 	obj->u.d.cap = initialcap > 1 ? initialcap : 10;
 
-	obj->u.d.items = fz_calloc(ctx, obj->u.d.cap, sizeof(struct keyval));
+	obj->u.d.items = fz_malloc_array(ctx, obj->u.d.cap, sizeof(struct keyval));
 	for (i = 0; i < obj->u.d.cap; i++)
 	{
 		obj->u.d.items[i].k = NULL;
@@ -694,7 +694,7 @@ fz_dict_put(fz_obj *obj, fz_obj *key, fz_obj *val)
 	if (obj->u.d.len + 1 > obj->u.d.cap)
 	{
 		obj->u.d.cap = (obj->u.d.cap * 3) / 2;
-		obj->u.d.items = fz_realloc(obj->ctx, obj->u.d.items, obj->u.d.cap * sizeof(struct keyval));
+		obj->u.d.items = fz_resize_array(obj->ctx, obj->u.d.items, obj->u.d.cap, sizeof(struct keyval));
 		for (i = obj->u.d.len; i < obj->u.d.cap; i++)
 		{
 			obj->u.d.items[i].k = NULL;
diff --git a/fitz/dev_text.c b/fitz/dev_text.c
index cebfbceb..bbc8efcb 100644
--- a/fitz/dev_text.c
+++ b/fitz/dev_text.c
@@ -55,7 +55,7 @@ fz_add_text_char_imp(fz_context *ctx, fz_text_span *span, int c, fz_bbox bbox)
 	if (span->len + 1 >= span->cap)
 	{
 		span->cap = span->cap > 1 ? (span->cap * 3) / 2 : 80;
-		span->text = fz_realloc(ctx, span->text, span->cap * sizeof(fz_text_char));
+		span->text = fz_resize_array(ctx, span->text, span->cap, sizeof(fz_text_char));
 	}
 	span->text[span->len].c = c;
 	span->text[span->len].bbox = bbox;
diff --git a/fitz/filt_faxd.c b/fitz/filt_faxd.c
index bd64939d..14a71a87 100644
--- a/fitz/filt_faxd.c
+++ b/fitz/filt_faxd.c
@@ -672,12 +672,12 @@ fz_open_faxd(fz_stream *chain, fz_obj *params)
 {
 	fz_faxd *fax;
 	fz_obj *obj;
-        fz_context *ctx;
+	fz_context *ctx;
 
 	assert(chain != NULL);
-        ctx = chain->ctx;
-        fax = fz_malloc(ctx, sizeof(fz_faxd));
-        fax->chain = chain;
+	ctx = chain->ctx;
+	fax = fz_malloc(ctx, sizeof(fz_faxd));
+	fax->chain = chain;
 
 	fax->ref = NULL;
 	fax->dst = NULL;
diff --git a/fitz/filt_flate.c b/fitz/filt_flate.c
index b7ef163d..d9ac44e6 100644
--- a/fitz/filt_flate.c
+++ b/fitz/filt_flate.c
@@ -12,7 +12,7 @@ struct fz_flate_s
 
 static void *zalloc(void *opaque, unsigned int items, unsigned int size)
 {
-	return fz_calloc(opaque, items, size);
+	return fz_malloc_array(opaque, items, size);
 }
 
 static void zfree(void *opaque, void *ptr)
diff --git a/fitz/fitz.h b/fitz/fitz.h
index 0f0d3b5c..a15304b7 100644
--- a/fitz/fitz.h
+++ b/fitz/fitz.h
@@ -139,22 +139,8 @@ char *fz_get_error_line(int n);
 /* Context types */
 
 typedef struct fz_error_context_s fz_error_context;
-typedef struct fz_alloc_context_s fz_alloc_context;
 typedef struct fz_context_s fz_context;
 
-/* Memory allocator context */
-
-struct fz_alloc_context_s
-{
-	void *opaque;
-	void *(*malloc)(void *, size_t);
-	void *(*realloc)(void *, void *, size_t);
-	void (*free)(void *, void *);
-	void *(*calloc)(void *, size_t, size_t);
-};
-
-extern fz_alloc_context fz_alloc_default;
-
 /* Exception context */
 
 struct fz_error_context_s
@@ -187,11 +173,10 @@ void fz_rethrow(fz_context *);
 
 struct fz_context_s
 {
-	fz_alloc_context *alloc;
 	fz_error_context *error;
 };
 
-fz_context *fz_new_context(fz_alloc_context *alloc);
+fz_context *fz_new_context(void);
 fz_context *fz_clone_context(fz_context *ctx);
 void fz_free_context(fz_context *ctx);
 
@@ -202,18 +187,13 @@ void fz_free_context(fz_context *ctx);
 /* memory allocation */
 
 /* The following throw exceptions on failure to allocate */
-void *fz_malloc(fz_context *ctx, size_t size);
-void *fz_calloc(fz_context *ctx, size_t count, size_t size);
-void *fz_realloc(fz_context *ctx, void *p, size_t size);
+void *fz_malloc(fz_context *ctx, unsigned int  size);
+void *fz_malloc_array(fz_context *ctx, unsigned int  count, unsigned int  size);
+void *fz_resize_array(fz_context *ctx, void *p, unsigned int  count, unsigned int  size);
 char *fz_strdup(fz_context *ctx, char *s);
 
 void fz_free(fz_context *ctx, void *p);
 
-/* The following returns NULL on failure to allocate */
-void *fz_malloc_nothrow(fz_context *ctx, size_t size);
-void *fz_calloc_nothrow(fz_context *ctx, size_t count, size_t size);
-void *fz_realloc_nothrow(fz_context *ctx, void *p, size_t size);
-
 /* runtime (hah!) test for endian-ness */
 int fz_is_big_endian(void);
 
diff --git a/fitz/res_bitmap.c b/fitz/res_bitmap.c
index 2ca66efe..3b13883b 100644
--- a/fitz/res_bitmap.c
+++ b/fitz/res_bitmap.c
@@ -14,7 +14,7 @@ fz_new_bitmap(fz_context *ctx, int w, int h, int n)
 	 * use SSE2 etc. */
 	bit->stride = ((n * w + 31) & ~31) >> 3;
 
-	bit->samples = fz_calloc(ctx, h, bit->stride);
+	bit->samples = fz_malloc_array(ctx, h, bit->stride);
 
 	return bit;
 }
diff --git a/fitz/res_font.c b/fitz/res_font.c
index b32f6a61..0ef7bf20 100644
--- a/fitz/res_font.c
+++ b/fitz/res_font.c
@@ -498,8 +498,8 @@ fz_new_type3_font(fz_context *ctx, char *name, fz_matrix matrix)
 	int i;
 
 	font = fz_new_font(ctx, name);
-	font->t3procs = fz_calloc(ctx, 256, sizeof(fz_buffer*));
-	font->t3widths = fz_calloc(ctx, 256, sizeof(float));
+	font->t3procs = fz_malloc_array(ctx, 256, sizeof(fz_buffer*));
+	font->t3widths = fz_malloc_array(ctx, 256, sizeof(float));
 
 	font->t3matrix = matrix;
 	for (i = 0; i < 256; i++)
diff --git a/fitz/res_path.c b/fitz/res_path.c
index 1cc92937..af5d9f43 100644
--- a/fitz/res_path.c
+++ b/fitz/res_path.c
@@ -23,7 +23,7 @@ fz_clone_path(fz_context *ctx, fz_path *old)
 	path = fz_malloc(ctx, sizeof(fz_path));
 	path->len = old->len;
 	path->cap = old->len;
-	path->items = fz_calloc(ctx, path->cap, sizeof(fz_path_item));
+	path->items = fz_malloc_array(ctx, path->cap, sizeof(fz_path_item));
 	memcpy(path->items, old->items, sizeof(fz_path_item) * path->len);
 
 	return path;
@@ -43,7 +43,7 @@ grow_path(fz_context *ctx, fz_path *path, int n)
 		return;
 	while (path->len + n > path->cap)
 		path->cap = path->cap + 36;
-	path->items = fz_realloc(ctx, path->items, path->cap * sizeof(fz_path_item));
+	path->items = fz_resize_array(ctx, path->items, path->cap, sizeof(fz_path_item));
 }
 
 void
diff --git a/fitz/res_pixmap.c b/fitz/res_pixmap.c
index 3706d495..040ec386 100644
--- a/fitz/res_pixmap.c
+++ b/fitz/res_pixmap.c
@@ -35,7 +35,7 @@ fz_new_pixmap_with_data(fz_context *ctx, fz_colorspace *colorspace, int w, int h
 	else
 	{
 		fz_memory_used += pix->w * pix->h * pix->n;
-		pix->samples = fz_calloc(ctx, pix->h, pix->w * pix->n);
+		pix->samples = fz_malloc_array(ctx, pix->h, pix->w * pix->n);
 		pix->free_samples = 1;
 	}
 
diff --git a/fitz/res_text.c b/fitz/res_text.c
index 1c5bbad0..5eaf12b0 100644
--- a/fitz/res_text.c
+++ b/fitz/res_text.c
@@ -35,7 +35,7 @@ fz_clone_text(fz_context *ctx, fz_text *old)
 	text->wmode = old->wmode;
 	text->len = old->len;
 	text->cap = text->len;
-	text->items = fz_calloc(ctx, text->len, sizeof(fz_text_item));
+	text->items = fz_malloc_array(ctx, text->len, sizeof(fz_text_item));
 	memcpy(text->items, old->items, text->len * sizeof(fz_text_item));
 
 	return text;
@@ -97,7 +97,7 @@ fz_grow_text(fz_context *ctx, fz_text *text, int n)
 		return;
 	while (text->len + n > text->cap)
 		text->cap = text->cap + 36;
-	text->items = fz_realloc(ctx, text->items, text->cap * sizeof(fz_text_item));
+	text->items = fz_resize_array(ctx, text->items, text->cap, sizeof(fz_text_item));
 }
 
 void
diff --git a/fitz/stm_buffer.c b/fitz/stm_buffer.c
index edd5c9c9..eb96cd2f 100644
--- a/fitz/stm_buffer.c
+++ b/fitz/stm_buffer.c
@@ -36,7 +36,7 @@ fz_drop_buffer(fz_context *ctx, fz_buffer *buf)
 void
 fz_resize_buffer(fz_context *ctx, fz_buffer *buf, int size)
 {
-	buf->data = fz_realloc(ctx, buf->data, size);
+	buf->data = fz_resize_array(ctx, buf->data, size, 1);
 	buf->cap = size;
 	if (buf->len > buf->cap)
 		buf->len = buf->cap;