Add context to mupdf.

Huge pervasive change to lots of files, adding a context for exception
handling and allocation.

In time we'll move more statics into there.

Also fix some for(i = 0; i < function(...); i++) calls.

1 files changed, 92 insertions, 92 deletions

diff --git a/fitz/dev_list.c b/fitz/dev_list.c
index 955824f9..63e9eee0 100644
--- a/fitz/dev_list.c
+++ b/fitz/dev_list.c
@@ -64,13 +64,13 @@ struct fz_display_list_s
 enum { ISOLATED = 1, KNOCKOUT = 2 };
 
 static fz_display_node *
-fz_new_display_node(fz_display_command cmd, fz_matrix ctm,
+fz_new_display_node(fz_context *ctx, fz_display_command cmd, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_display_node *node;
 	int i;
 
-	node = fz_malloc(sizeof(fz_display_node));
+	node = fz_malloc(ctx, sizeof(fz_display_node));
 	node->cmd = cmd;
 	node->next = NULL;
 	node->rect = fz_empty_rect;
@@ -97,9 +97,9 @@ fz_new_display_node(fz_display_command cmd, fz_matrix ctm,
 }
 
 static fz_stroke_state *
-fz_clone_stroke_state(fz_stroke_state *stroke)
+fz_clone_stroke_state(fz_context *ctx, fz_stroke_state *stroke)
 {
-	fz_stroke_state *newstroke = fz_malloc(sizeof(fz_stroke_state));
+	fz_stroke_state *newstroke = fz_malloc(ctx, sizeof(fz_stroke_state));
 	*newstroke = *stroke;
 	return newstroke;
 }
@@ -184,7 +184,7 @@ fz_append_display_node(fz_display_list *list, fz_display_node *node)
 }
 
 static void
-fz_free_display_node(fz_display_node *node)
+fz_free_display_node(fz_context *ctx, fz_display_node *node)
 {
 	switch (node->cmd)
 	{
@@ -192,22 +192,22 @@ fz_free_display_node(fz_display_node *node)
 	case FZ_CMD_STROKE_PATH:
 	case FZ_CMD_CLIP_PATH:
 	case FZ_CMD_CLIP_STROKE_PATH:
-		fz_free_path(node->item.path);
+		fz_free_path(ctx, node->item.path);
 		break;
 	case FZ_CMD_FILL_TEXT:
 	case FZ_CMD_STROKE_TEXT:
 	case FZ_CMD_CLIP_TEXT:
 	case FZ_CMD_CLIP_STROKE_TEXT:
 	case FZ_CMD_IGNORE_TEXT:
-		fz_free_text(node->item.text);
+		fz_free_text(ctx, node->item.text);
 		break;
 	case FZ_CMD_FILL_SHADE:
-		fz_drop_shade(node->item.shade);
+		fz_drop_shade(ctx, node->item.shade);
 		break;
 	case FZ_CMD_FILL_IMAGE:
 	case FZ_CMD_FILL_IMAGE_MASK:
 	case FZ_CMD_CLIP_IMAGE_MASK:
-		fz_drop_pixmap(node->item.image);
+		fz_drop_pixmap(ctx, node->item.image);
 		break;
 	case FZ_CMD_POP_CLIP:
 	case FZ_CMD_BEGIN_MASK:
@@ -219,214 +219,214 @@ fz_free_display_node(fz_display_node *node)
 		break;
 	}
 	if (node->stroke)
-		fz_free(node->stroke);
+		fz_free(ctx, node->stroke);
 	if (node->colorspace)
-		fz_drop_colorspace(node->colorspace);
-	fz_free(node);
+		fz_drop_colorspace(ctx, node->colorspace);
+	fz_free(ctx, node);
 }
 
 static void
-fz_list_fill_path(void *user, fz_path *path, int even_odd, fz_matrix ctm,
+fz_list_fill_path(fz_device *dev, fz_path *path, int even_odd, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_FILL_PATH, ctm, colorspace, color, alpha);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_FILL_PATH, ctm, colorspace, color, alpha);
 	node->rect = fz_bound_path(path, NULL, ctm);
-	node->item.path = fz_clone_path(path);
+	node->item.path = fz_clone_path(dev->ctx, path);
 	node->flag = even_odd;
-	fz_append_display_node(user, node);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_stroke_path(void *user, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
+fz_list_stroke_path(fz_device *dev, fz_path *path, fz_stroke_state *stroke, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_STROKE_PATH, ctm, colorspace, color, alpha);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_STROKE_PATH, ctm, colorspace, color, alpha);
 	node->rect = fz_bound_path(path, stroke, ctm);
-	node->item.path = fz_clone_path(path);
-	node->stroke = fz_clone_stroke_state(stroke);
-	fz_append_display_node(user, node);
+	node->item.path = fz_clone_path(dev->ctx, path);
+	node->stroke = fz_clone_stroke_state(dev->ctx, stroke);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_clip_path(void *user, fz_path *path, fz_rect *rect, int even_odd, fz_matrix ctm)
+fz_list_clip_path(fz_device *dev, fz_path *path, fz_rect *rect, int even_odd, fz_matrix ctm)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_CLIP_PATH, ctm, NULL, NULL, 0);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_CLIP_PATH, ctm, NULL, NULL, 0);
 	node->rect = fz_bound_path(path, NULL, ctm);
 	if (rect != NULL)
 		node->rect = fz_intersect_rect(node->rect, *rect);
-	node->item.path = fz_clone_path(path);
+	node->item.path = fz_clone_path(dev->ctx, path);
 	node->flag = even_odd;
-	fz_append_display_node(user, node);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_clip_stroke_path(void *user, fz_path *path, fz_rect *rect, fz_stroke_state *stroke, fz_matrix ctm)
+fz_list_clip_stroke_path(fz_device *dev, fz_path *path, fz_rect *rect, fz_stroke_state *stroke, fz_matrix ctm)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_CLIP_STROKE_PATH, ctm, NULL, NULL, 0);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_CLIP_STROKE_PATH, ctm, NULL, NULL, 0);
 	node->rect = fz_bound_path(path, stroke, ctm);
 	if (rect != NULL)
 		node->rect = fz_intersect_rect(node->rect, *rect);
-	node->item.path = fz_clone_path(path);
-	node->stroke = fz_clone_stroke_state(stroke);
-	fz_append_display_node(user, node);
+	node->item.path = fz_clone_path(dev->ctx, path);
+	node->stroke = fz_clone_stroke_state(dev->ctx, stroke);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_fill_text(void *user, fz_text *text, fz_matrix ctm,
+fz_list_fill_text(fz_device *dev, fz_text *text, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_FILL_TEXT, ctm, colorspace, color, alpha);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_FILL_TEXT, ctm, colorspace, color, alpha);
 	node->rect = fz_bound_text(text, ctm);
-	node->item.text = fz_clone_text(text);
-	fz_append_display_node(user, node);
+	node->item.text = fz_clone_text(dev->ctx, text);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
+fz_list_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_STROKE_TEXT, ctm, colorspace, color, alpha);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_STROKE_TEXT, ctm, colorspace, color, alpha);
 	node->rect = fz_bound_text(text, ctm);
-	node->item.text = fz_clone_text(text);
-	node->stroke = fz_clone_stroke_state(stroke);
-	fz_append_display_node(user, node);
+	node->item.text = fz_clone_text(dev->ctx, text);
+	node->stroke = fz_clone_stroke_state(dev->ctx, stroke);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_clip_text(void *user, fz_text *text, fz_matrix ctm, int accumulate)
+fz_list_clip_text(fz_device *dev, fz_text *text, fz_matrix ctm, int accumulate)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_CLIP_TEXT, ctm, NULL, NULL, 0);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_CLIP_TEXT, ctm, NULL, NULL, 0);
 	node->rect = fz_bound_text(text, ctm);
-	node->item.text = fz_clone_text(text);
+	node->item.text = fz_clone_text(dev->ctx, text);
 	node->flag = accumulate;
 	/* when accumulating, be conservative about culling */
 	if (accumulate)
 		node->rect = fz_infinite_rect;
-	fz_append_display_node(user, node);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_clip_stroke_text(void *user, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
+fz_list_clip_stroke_text(fz_device *dev, fz_text *text, fz_stroke_state *stroke, fz_matrix ctm)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_CLIP_STROKE_TEXT, ctm, NULL, NULL, 0);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_CLIP_STROKE_TEXT, ctm, NULL, NULL, 0);
 	node->rect = fz_bound_text(text, ctm);
-	node->item.text = fz_clone_text(text);
-	node->stroke = fz_clone_stroke_state(stroke);
-	fz_append_display_node(user, node);
+	node->item.text = fz_clone_text(dev->ctx, text);
+	node->stroke = fz_clone_stroke_state(dev->ctx, stroke);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_ignore_text(void *user, fz_text *text, fz_matrix ctm)
+fz_list_ignore_text(fz_device *dev, fz_text *text, fz_matrix ctm)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_IGNORE_TEXT, ctm, NULL, NULL, 0);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_IGNORE_TEXT, ctm, NULL, NULL, 0);
 	node->rect = fz_bound_text(text, ctm);
-	node->item.text = fz_clone_text(text);
-	fz_append_display_node(user, node);
+	node->item.text = fz_clone_text(dev->ctx, text);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_pop_clip(void *user)
+fz_list_pop_clip(fz_device *dev)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_POP_CLIP, fz_identity, NULL, NULL, 0);
-	fz_append_display_node(user, node);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_POP_CLIP, fz_identity, NULL, NULL, 0);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_fill_shade(void *user, fz_shade *shade, fz_matrix ctm, float alpha)
+fz_list_fill_shade(fz_device *dev, fz_shade *shade, fz_matrix ctm, float alpha)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_FILL_SHADE, ctm, NULL, NULL, alpha);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_FILL_SHADE, ctm, NULL, NULL, alpha);
 	node->rect = fz_bound_shade(shade, ctm);
 	node->item.shade = fz_keep_shade(shade);
-	fz_append_display_node(user, node);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_fill_image(void *user, fz_pixmap *image, fz_matrix ctm, float alpha)
+fz_list_fill_image(fz_device *dev, fz_pixmap *image, fz_matrix ctm, float alpha)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_FILL_IMAGE, ctm, NULL, NULL, alpha);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_FILL_IMAGE, ctm, NULL, NULL, alpha);
 	node->rect = fz_transform_rect(ctm, fz_unit_rect);
 	node->item.image = fz_keep_pixmap(image);
-	fz_append_display_node(user, node);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_fill_image_mask(void *user, fz_pixmap *image, fz_matrix ctm,
+fz_list_fill_image_mask(fz_device *dev, fz_pixmap *image, fz_matrix ctm,
 	fz_colorspace *colorspace, float *color, float alpha)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_FILL_IMAGE_MASK, ctm, colorspace, color, alpha);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_FILL_IMAGE_MASK, ctm, colorspace, color, alpha);
 	node->rect = fz_transform_rect(ctm, fz_unit_rect);
 	node->item.image = fz_keep_pixmap(image);
-	fz_append_display_node(user, node);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_clip_image_mask(void *user, fz_pixmap *image, fz_rect *rect, fz_matrix ctm)
+fz_list_clip_image_mask(fz_device *dev, fz_pixmap *image, fz_rect *rect, fz_matrix ctm)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_CLIP_IMAGE_MASK, ctm, NULL, NULL, 0);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_CLIP_IMAGE_MASK, ctm, NULL, NULL, 0);
 	node->rect = fz_transform_rect(ctm, fz_unit_rect);
 	if (rect != NULL)
 		node->rect = fz_intersect_rect(node->rect, *rect);
 	node->item.image = fz_keep_pixmap(image);
-	fz_append_display_node(user, node);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_begin_mask(void *user, fz_rect rect, int luminosity, fz_colorspace *colorspace, float *color)
+fz_list_begin_mask(fz_device *dev, fz_rect rect, int luminosity, fz_colorspace *colorspace, float *color)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_BEGIN_MASK, fz_identity, colorspace, color, 0);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_BEGIN_MASK, fz_identity, colorspace, color, 0);
 	node->rect = rect;
 	node->flag = luminosity;
-	fz_append_display_node(user, node);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_end_mask(void *user)
+fz_list_end_mask(fz_device *dev)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_END_MASK, fz_identity, NULL, NULL, 0);
-	fz_append_display_node(user, node);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_END_MASK, fz_identity, NULL, NULL, 0);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_begin_group(void *user, fz_rect rect, int isolated, int knockout, int blendmode, float alpha)
+fz_list_begin_group(fz_device *dev, fz_rect rect, int isolated, int knockout, int blendmode, float alpha)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_BEGIN_GROUP, fz_identity, NULL, NULL, alpha);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_BEGIN_GROUP, fz_identity, NULL, NULL, alpha);
 	node->rect = rect;
 	node->item.blendmode = blendmode;
 	node->flag |= isolated ? ISOLATED : 0;
 	node->flag |= knockout ? KNOCKOUT : 0;
-	fz_append_display_node(user, node);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_end_group(void *user)
+fz_list_end_group(fz_device *dev)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_END_GROUP, fz_identity, NULL, NULL, 0);
-	fz_append_display_node(user, node);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_END_GROUP, fz_identity, NULL, NULL, 0);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_begin_tile(void *user, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
+fz_list_begin_tile(fz_device *dev, fz_rect area, fz_rect view, float xstep, float ystep, fz_matrix ctm)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_BEGIN_TILE, ctm, NULL, NULL, 0);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_BEGIN_TILE, ctm, NULL, NULL, 0);
 	node->rect = area;
 	node->color[0] = xstep;
 	node->color[1] = ystep;
@@ -434,21 +434,21 @@ fz_list_begin_tile(void *user, fz_rect area, fz_rect view, float xstep, float ys
 	node->color[3] = view.y0;
 	node->color[4] = view.x1;
 	node->color[5] = view.y1;
-	fz_append_display_node(user, node);
+	fz_append_display_node(dev->user, node);
 }
 
 static void
-fz_list_end_tile(void *user)
+fz_list_end_tile(fz_device *dev)
 {
 	fz_display_node *node;
-	node = fz_new_display_node(FZ_CMD_END_TILE, fz_identity, NULL, NULL, 0);
-	fz_append_display_node(user, node);
+	node = fz_new_display_node(dev->ctx, FZ_CMD_END_TILE, fz_identity, NULL, NULL, 0);
+	fz_append_display_node(dev->user, node);
 }
 
 fz_device *
-fz_new_list_device(fz_display_list *list)
+fz_new_list_device(fz_context *ctx, fz_display_list *list)
 {
-	fz_device *dev = fz_new_device(list);
+	fz_device *dev = fz_new_device(ctx, list);
 
 	dev->fill_path = fz_list_fill_path;
 	dev->stroke_path = fz_list_stroke_path;
@@ -480,9 +480,9 @@ fz_new_list_device(fz_display_list *list)
 }
 
 fz_display_list *
-fz_new_display_list(void)
+fz_new_display_list(fz_context *ctx)
 {
-	fz_display_list *list = fz_malloc(sizeof(fz_display_list));
+	fz_display_list *list = fz_malloc(ctx, sizeof(fz_display_list));
 	list->first = NULL;
 	list->last = NULL;
 	list->top = 0;
@@ -491,16 +491,16 @@ fz_new_display_list(void)
 }
 
 void
-fz_free_display_list(fz_display_list *list)
+fz_free_display_list(fz_context *ctx, fz_display_list *list)
 {
 	fz_display_node *node = list->first;
 	while (node)
 	{
 		fz_display_node *next = node->next;
-		fz_free_display_node(node);
+		fz_free_display_node(ctx, node);
 		node = next;
 	}
-	fz_free(list);
+	fz_free(ctx, list);
 }
 
 void