Move fz_obj to be pdf_obj.

Currently, we are in the slightly strange position of having
the PDF specific object types as part of fitz. Here we pull
them out into the pdf layer instead. This has been made possible
by the recent changes to make the store no longer be tied to
having fz_obj's as keys.

Most of this work is a simple huge rename; to help customers who
may have code that use such functions we have provided a sed
script to do the renaming; scripts/rename2.sed.

Various other small tweaks are required; the store used to have
some debugging code that still required knowledge of fz_obj
types - we extract that into a nicer 'type' based function
pointer. Also, the type 3 font handling used to have an fz_obj
pointer for type 3 resources, and therefore needed to know how
to free this; this has become a void * with a function to free
it.

32 files changed, 2283 insertions, 2189 deletions

diff --git a/apps/mupdfclean.c b/apps/mupdfclean.c
index 3130e3f0..f47ea2b5 100644
--- a/apps/mupdfclean.c
+++ b/apps/mupdfclean.c
@@ -53,34 +53,34 @@ static void usage(void)
  * Garbage collect objects not reachable from the trailer.
  */
 
-static void sweepref(fz_obj *ref);
+static void sweepref(pdf_obj *ref);
 
-static void sweepobj(fz_obj *obj)
+static void sweepobj(pdf_obj *obj)
 {
 	int i;
 
-	if (fz_is_indirect(obj))
+	if (pdf_is_indirect(obj))
 		sweepref(obj);
 
-	else if (fz_is_dict(obj))
+	else if (pdf_is_dict(obj))
 	{
-		int n = fz_dict_len(obj);
+		int n = pdf_dict_len(obj);
 		for (i = 0; i < n; i++)
-			sweepobj(fz_dict_get_val(obj, i));
+			sweepobj(pdf_dict_get_val(obj, i));
 	}
 
-	else if (fz_is_array(obj))
+	else if (pdf_is_array(obj))
 	{
-		int n = fz_array_len(obj);
+		int n = pdf_array_len(obj);
 		for (i = 0; i < n; i++)
-			sweepobj(fz_array_get(obj, i));
+			sweepobj(pdf_array_get(obj, i));
 	}
 }
 
-static void sweepref(fz_obj *obj)
+static void sweepref(pdf_obj *obj)
 {
-	int num = fz_to_num(obj);
-	int gen = fz_to_gen(obj);
+	int num = pdf_to_num(obj);
+	int gen = pdf_to_gen(obj);
 
 	if (num < 0 || num >= xref->len)
 		return;
@@ -94,12 +94,12 @@ static void sweepref(fz_obj *obj)
 	{
 		if (pdf_is_stream(xref, num, gen))
 		{
-			fz_obj *len = fz_dict_gets(obj, "Length");
-			if (fz_is_indirect(len))
+			pdf_obj *len = pdf_dict_gets(obj, "Length");
+			if (pdf_is_indirect(len))
 			{
-				uselist[fz_to_num(len)] = 0;
-				len = fz_resolve_indirect(len);
-				fz_dict_puts(obj, "Length", len);
+				uselist[pdf_to_num(len)] = 0;
+				len = pdf_resolve_indirect(len);
+				pdf_dict_puts(obj, "Length", len);
 			}
 		}
 	}
@@ -108,7 +108,7 @@ static void sweepref(fz_obj *obj)
 		/* Leave broken */
 	}
 
-	sweepobj(fz_resolve_indirect(obj));
+	sweepobj(pdf_resolve_indirect(obj));
 }
 
 /*
@@ -124,7 +124,7 @@ static void removeduplicateobjs(void)
 		/* Only compare an object to objects preceding it */
 		for (other = 1; other < num; other++)
 		{
-			fz_obj *a, *b;
+			pdf_obj *a, *b;
 
 			if (num == other || !uselist[num] || !uselist[other])
 				continue;
@@ -148,10 +148,10 @@ static void removeduplicateobjs(void)
 			a = xref->table[num].obj;
 			b = xref->table[other].obj;
 
-			a = fz_resolve_indirect(a);
-			b = fz_resolve_indirect(b);
+			a = pdf_resolve_indirect(a);
+			b = pdf_resolve_indirect(b);
 
-			if (fz_objcmp(a, b))
+			if (pdf_objcmp(a, b))
 				continue;
 
 			/* Keep the lowest numbered object */
@@ -195,23 +195,23 @@ static void compactxref(void)
  * removing duplicate objects and compacting the xref.
  */
 
-static void renumberobj(fz_obj *obj)
+static void renumberobj(pdf_obj *obj)
 {
 	int i;
 	fz_context *ctx = xref->ctx;
 
-	if (fz_is_dict(obj))
+	if (pdf_is_dict(obj))
 	{
-		int n = fz_dict_len(obj);
+		int n = pdf_dict_len(obj);
 		for (i = 0; i < n; i++)
 		{
-			fz_obj *key = fz_dict_get_key(obj, i);
-			fz_obj *val = fz_dict_get_val(obj, i);
-			if (fz_is_indirect(val))
+			pdf_obj *key = pdf_dict_get_key(obj, i);
+			pdf_obj *val = pdf_dict_get_val(obj, i);
+			if (pdf_is_indirect(val))
 			{
-				val = fz_new_indirect(ctx, renumbermap[fz_to_num(val)], 0, xref);
+				val = pdf_new_indirect(ctx, renumbermap[pdf_to_num(val)], 0, xref);
 				fz_dict_put(obj, key, val);
-				fz_drop_obj(val);
+				pdf_drop_obj(val);
 			}
 			else
 			{
@@ -220,17 +220,17 @@ static void renumberobj(fz_obj *obj)
 		}
 	}
 
-	else if (fz_is_array(obj))
+	else if (pdf_is_array(obj))
 	{
-		int n = fz_array_len(obj);
+		int n = pdf_array_len(obj);
 		for (i = 0; i < n; i++)
 		{
-			fz_obj *val = fz_array_get(obj, i);
-			if (fz_is_indirect(val))
+			pdf_obj *val = pdf_array_get(obj, i);
+			if (pdf_is_indirect(val))
 			{
-				val = fz_new_indirect(ctx, renumbermap[fz_to_num(val)], 0, xref);
-				fz_array_put(obj, i, val);
-				fz_drop_obj(val);
+				val = pdf_new_indirect(ctx, renumbermap[pdf_to_num(val)], 0, xref);
+				pdf_array_put(obj, i, val);
+				pdf_drop_obj(val);
 			}
 			else
 			{
@@ -250,13 +250,13 @@ static void renumberobjs(void)
 	renumberobj(xref->trailer);
 	for (num = 0; num < xref->len; num++)
 	{
-		fz_obj *obj = xref->table[num].obj;
+		pdf_obj *obj = xref->table[num].obj;
 
-		if (fz_is_indirect(obj))
+		if (pdf_is_indirect(obj))
 		{
-			obj = fz_new_indirect(ctx, renumbermap[fz_to_num(obj)], 0, xref);
+			obj = pdf_new_indirect(ctx, renumbermap[pdf_to_num(obj)], 0, xref);
 			pdf_update_object(xref, num, 0, obj);
-			fz_drop_obj(obj);
+			pdf_drop_obj(obj);
 		}
 		else
 		{
@@ -282,7 +282,7 @@ static void renumberobjs(void)
 		else
 		{
 			if (oldxref[num].obj)
-				fz_drop_obj(oldxref[num].obj);
+				pdf_drop_obj(oldxref[num].obj);
 		}
 	}
 
@@ -302,25 +302,25 @@ static void renumberobjs(void)
 
 static void retainpages(int argc, char **argv)
 {
-	fz_obj *oldroot, *root, *pages, *kids, *countobj, *parent, *olddests;
+	pdf_obj *oldroot, *root, *pages, *kids, *countobj, *parent, *olddests;
 
 	/* Keep only pages/type and (reduced) dest entries to avoid
 	 * references to unretained pages */
-	oldroot = fz_dict_gets(xref->trailer, "Root");
-	pages = fz_dict_gets(oldroot, "Pages");
+	oldroot = pdf_dict_gets(xref->trailer, "Root");
+	pages = pdf_dict_gets(oldroot, "Pages");
 	olddests = pdf_load_name_tree(xref, "Dests");
 
-	root = fz_new_dict(ctx, 2);
-	fz_dict_puts(root, "Type", fz_dict_gets(oldroot, "Type"));
-	fz_dict_puts(root, "Pages", fz_dict_gets(oldroot, "Pages"));
+	root = pdf_new_dict(ctx, 2);
+	pdf_dict_puts(root, "Type", pdf_dict_gets(oldroot, "Type"));
+	pdf_dict_puts(root, "Pages", pdf_dict_gets(oldroot, "Pages"));
 
-	pdf_update_object(xref, fz_to_num(oldroot), fz_to_gen(oldroot), root);
+	pdf_update_object(xref, pdf_to_num(oldroot), pdf_to_gen(oldroot), root);
 
-	fz_drop_obj(root);
+	pdf_drop_obj(root);
 
 	/* Create a new kids array with only the pages we want to keep */
-	parent = fz_new_indirect(ctx, fz_to_num(pages), fz_to_gen(pages), xref);
-	kids = fz_new_array(ctx, 1);
+	parent = pdf_new_indirect(ctx, pdf_to_num(pages), pdf_to_gen(pages), xref);
+	kids = pdf_new_array(ctx, 1);
 
 	/* Retain pages specified */
 	while (argc - fz_optind)
@@ -357,13 +357,13 @@ static void retainpages(int argc, char **argv)
 
 			for (page = spage; page <= epage; page++)
 			{
-				fz_obj *pageobj = xref->page_objs[page-1];
-				fz_obj *pageref = xref->page_refs[page-1];
+				pdf_obj *pageobj = xref->page_objs[page-1];
+				pdf_obj *pageref = xref->page_refs[page-1];
 
-				fz_dict_puts(pageobj, "Parent", parent);
+				pdf_dict_puts(pageobj, "Parent", parent);
 
 				/* Store page object in new kids array */
-				fz_array_push(kids, pageref);
+				pdf_array_push(kids, pageref);
 			}
 
 			spec = fz_strsep(&pagelist, ",");
@@ -372,48 +372,48 @@ static void retainpages(int argc, char **argv)
 		fz_optind++;
 	}
 
-	fz_drop_obj(parent);
+	pdf_drop_obj(parent);
 
 	/* Update page count and kids array */
-	countobj = fz_new_int(ctx, fz_array_len(kids));
-	fz_dict_puts(pages, "Count", countobj);
-	fz_drop_obj(countobj);
-	fz_dict_puts(pages, "Kids", kids);
-	fz_drop_obj(kids);
+	countobj = pdf_new_int(ctx, pdf_array_len(kids));
+	pdf_dict_puts(pages, "Count", countobj);
+	pdf_drop_obj(countobj);
+	pdf_dict_puts(pages, "Kids", kids);
+	pdf_drop_obj(kids);
 
 	/* Also preserve the (partial) Dests name tree */
 	if (olddests)
 	{
 		int i;
-		fz_obj *names = fz_new_dict(ctx, 1);
-		fz_obj *dests = fz_new_dict(ctx, 1);
-		fz_obj *names_list = fz_new_array(ctx, 32);
+		pdf_obj *names = pdf_new_dict(ctx, 1);
+		pdf_obj *dests = pdf_new_dict(ctx, 1);
+		pdf_obj *names_list = pdf_new_array(ctx, 32);
 
-		for (i = 0; i < fz_dict_len(olddests); i++)
+		for (i = 0; i < pdf_dict_len(olddests); i++)
 		{
-			fz_obj *key = fz_dict_get_key(olddests, i);
-			fz_obj *val = fz_dict_get_val(olddests, i);
-			fz_obj *key_str = fz_new_string(ctx, fz_to_name(key), strlen(fz_to_name(key)));
-			fz_obj *dest = fz_dict_gets(val, "D");
+			pdf_obj *key = pdf_dict_get_key(olddests, i);
+			pdf_obj *val = pdf_dict_get_val(olddests, i);
+			pdf_obj *key_str = pdf_new_string(ctx, pdf_to_name(key), strlen(pdf_to_name(key)));
+			pdf_obj *dest = pdf_dict_gets(val, "D");
 
-			dest = fz_array_get(dest ? dest : val, 0);
-			if (fz_array_contains(fz_dict_gets(pages, "Kids"), dest))
+			dest = pdf_array_get(dest ? dest : val, 0);
+			if (pdf_array_contains(pdf_dict_gets(pages, "Kids"), dest))
 			{
-				fz_array_push(names_list, key_str);
-				fz_array_push(names_list, val);
+				pdf_array_push(names_list, key_str);
+				pdf_array_push(names_list, val);
 			}
-			fz_drop_obj(key_str);
+			pdf_drop_obj(key_str);
 		}
 
-		root = fz_dict_gets(xref->trailer, "Root");
-		fz_dict_puts(dests, "Names", names_list);
-		fz_dict_puts(names, "Dests", dests);
-		fz_dict_puts(root, "Names", names);
+		root = pdf_dict_gets(xref->trailer, "Root");
+		pdf_dict_puts(dests, "Names", names_list);
+		pdf_dict_puts(names, "Dests", dests);
+		pdf_dict_puts(root, "Names", names);
 
-		fz_drop_obj(names);
-		fz_drop_obj(dests);
-		fz_drop_obj(names_list);
-		fz_drop_obj(olddests);
+		pdf_drop_obj(names);
+		pdf_drop_obj(dests);
+		pdf_drop_obj(names_list);
+		pdf_drop_obj(olddests);
 	}
 }
 
@@ -423,7 +423,7 @@ static void retainpages(int argc, char **argv)
 
 static void preloadobjstms(void)
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 	int num;
 
 	for (num = 0; num < xref->len; num++)
@@ -431,7 +431,7 @@ static void preloadobjstms(void)
 		if (xref->table[num].type == 'o')
 		{
 			obj = pdf_load_object(xref, num, 0);
-			fz_drop_obj(obj);
+			pdf_drop_obj(obj);
 		}
 	}
 }
@@ -482,57 +482,57 @@ static fz_buffer *hexbuf(unsigned char *p, int n)
 	return buf;
 }
 
-static void addhexfilter(fz_obj *dict)
+static void addhexfilter(pdf_obj *dict)
 {
-	fz_obj *f, *dp, *newf, *newdp;
-	fz_obj *ahx, *nullobj;
+	pdf_obj *f, *dp, *newf, *newdp;
+	pdf_obj *ahx, *nullobj;
 
 	ahx = fz_new_name(ctx, "ASCIIHexDecode");
-	nullobj = fz_new_null(ctx);
+	nullobj = pdf_new_null(ctx);
 	newf = newdp = NULL;
 
-	f = fz_dict_gets(dict, "Filter");
-	dp = fz_dict_gets(dict, "DecodeParms");
+	f = pdf_dict_gets(dict, "Filter");
+	dp = pdf_dict_gets(dict, "DecodeParms");
 
-	if (fz_is_name(f))
+	if (pdf_is_name(f))
 	{
-		newf = fz_new_array(ctx, 2);
-		fz_array_push(newf, ahx);
-		fz_array_push(newf, f);
+		newf = pdf_new_array(ctx, 2);
+		pdf_array_push(newf, ahx);
+		pdf_array_push(newf, f);
 		f = newf;
-		if (fz_is_dict(dp))
+		if (pdf_is_dict(dp))
 		{
-			newdp = fz_new_array(ctx, 2);
-			fz_array_push(newdp, nullobj);
-			fz_array_push(newdp, dp);
+			newdp = pdf_new_array(ctx, 2);
+			pdf_array_push(newdp, nullobj);
+			pdf_array_push(newdp, dp);
 			dp = newdp;
 		}
 	}
-	else if (fz_is_array(f))
+	else if (pdf_is_array(f))
 	{
-		fz_array_insert(f, ahx);
-		if (fz_is_array(dp))
-			fz_array_insert(dp, nullobj);
+		pdf_array_insert(f, ahx);
+		if (pdf_is_array(dp))
+			pdf_array_insert(dp, nullobj);
 	}
 	else
 		f = ahx;
 
-	fz_dict_puts(dict, "Filter", f);
+	pdf_dict_puts(dict, "Filter", f);
 	if (dp)
-		fz_dict_puts(dict, "DecodeParms", dp);
+		pdf_dict_puts(dict, "DecodeParms", dp);
 
-	fz_drop_obj(ahx);
-	fz_drop_obj(nullobj);
+	pdf_drop_obj(ahx);
+	pdf_drop_obj(nullobj);
 	if (newf)
-		fz_drop_obj(newf);
+		pdf_drop_obj(newf);
 	if (newdp)
-		fz_drop_obj(newdp);
+		pdf_drop_obj(newdp);
 }
 
-static void copystream(fz_obj *obj, int num, int gen)
+static void copystream(pdf_obj *obj, int num, int gen)
 {
 	fz_buffer *buf, *tmp;
-	fz_obj *newlen;
+	pdf_obj *newlen;
 
 	buf = pdf_load_raw_stream(xref, num, gen);
 
@@ -544,13 +544,13 @@ static void copystream(fz_obj *obj, int num, int gen)
 
 		addhexfilter(obj);
 
-		newlen = fz_new_int(ctx, buf->len);
-		fz_dict_puts(obj, "Length", newlen);
-		fz_drop_obj(newlen);
+		newlen = pdf_new_int(ctx, buf->len);
+		pdf_dict_puts(obj, "Length", newlen);
+		pdf_drop_obj(newlen);
 	}
 
 	fprintf(out, "%d %d obj\n", num, gen);
-	fz_fprint_obj(out, obj, doexpand == 0);
+	pdf_fprint_obj(out, obj, doexpand == 0);
 	fprintf(out, "stream\n");
 	fwrite(buf->data, 1, buf->len, out);
 	fprintf(out, "endstream\nendobj\n\n");
@@ -558,15 +558,15 @@ static void copystream(fz_obj *obj, int num, int gen)
 	fz_drop_buffer(ctx, buf);
 }
 
-static void expandstream(fz_obj *obj, int num, int gen)
+static void expandstream(pdf_obj *obj, int num, int gen)
 {
 	fz_buffer *buf, *tmp;
-	fz_obj *newlen;
+	pdf_obj *newlen;
 
 	buf = pdf_load_stream(xref, num, gen);
 
-	fz_dict_dels(obj, "Filter");
-	fz_dict_dels(obj, "DecodeParms");
+	pdf_dict_dels(obj, "Filter");
+	pdf_dict_dels(obj, "DecodeParms");
 
 	if (doascii && isbinarystream(buf))
 	{
@@ -577,12 +577,12 @@ static void expandstream(fz_obj *obj, int num, int gen)
 		addhexfilter(obj);
 	}
 
-	newlen = fz_new_int(ctx, buf->len);
-	fz_dict_puts(obj, "Length", newlen);
-	fz_drop_obj(newlen);
+	newlen = pdf_new_int(ctx, buf->len);
+	pdf_dict_puts(obj, "Length", newlen);
+	pdf_drop_obj(newlen);
 
 	fprintf(out, "%d %d obj\n", num, gen);
-	fz_fprint_obj(out, obj, doexpand == 0);
+	pdf_fprint_obj(out, obj, doexpand == 0);
 	fprintf(out, "stream\n");
 	fwrite(buf->data, 1, buf->len, out);
 	fprintf(out, "endstream\nendobj\n\n");
@@ -592,25 +592,25 @@ static void expandstream(fz_obj *obj, int num, int gen)
 
 static void writeobject(int num, int gen)
 {
-	fz_obj *obj;
-	fz_obj *type;
+	pdf_obj *obj;
+	pdf_obj *type;
 
 	obj = pdf_load_object(xref, num, gen);
 
 	/* skip ObjStm and XRef objects */
-	if (fz_is_dict(obj))
+	if (pdf_is_dict(obj))
 	{
-		type = fz_dict_gets(obj, "Type");
-		if (fz_is_name(type) && !strcmp(fz_to_name(type), "ObjStm"))
+		type = pdf_dict_gets(obj, "Type");
+		if (pdf_is_name(type) && !strcmp(pdf_to_name(type), "ObjStm"))
 		{
 			uselist[num] = 0;
-			fz_drop_obj(obj);
+			pdf_drop_obj(obj);
 			return;
 		}
-		if (fz_is_name(type) && !strcmp(fz_to_name(type), "XRef"))
+		if (pdf_is_name(type) && !strcmp(pdf_to_name(type), "XRef"))
 		{
 			uselist[num] = 0;
-			fz_drop_obj(obj);
+			pdf_drop_obj(obj);
 			return;
 		}
 	}
@@ -618,7 +618,7 @@ static void writeobject(int num, int gen)
 	if (!pdf_is_stream(xref, num, gen))
 	{
 		fprintf(out, "%d %d obj\n", num, gen);
-		fz_fprint_obj(out, obj, doexpand == 0);
+		pdf_fprint_obj(out, obj, doexpand == 0);
 		fprintf(out, "endobj\n\n");
 	}
 	else
@@ -626,24 +626,24 @@ static void writeobject(int num, int gen)
 		int dontexpand = 0;
 		if (doexpand != 0 && doexpand != expand_all)
 		{
-			fz_obj *o;
+			pdf_obj *o;
 
-			if ((o = fz_dict_gets(obj, "Type"), !strcmp(fz_to_name(o), "XObject")) &&
-				(o = fz_dict_gets(obj, "Subtype"), !strcmp(fz_to_name(o), "Image")))
+			if ((o = pdf_dict_gets(obj, "Type"), !strcmp(pdf_to_name(o), "XObject")) &&
+				(o = pdf_dict_gets(obj, "Subtype"), !strcmp(pdf_to_name(o), "Image")))
 				dontexpand = !(doexpand & expand_images);
-			if (o = fz_dict_gets(obj, "Type"), !strcmp(fz_to_name(o), "Font"))
+			if (o = pdf_dict_gets(obj, "Type"), !strcmp(pdf_to_name(o), "Font"))
 				dontexpand = !(doexpand & expand_fonts);
-			if (o = fz_dict_gets(obj, "Type"), !strcmp(fz_to_name(o), "FontDescriptor"))
+			if (o = pdf_dict_gets(obj, "Type"), !strcmp(pdf_to_name(o), "FontDescriptor"))
 				dontexpand = !(doexpand & expand_fonts);
-			if ((o = fz_dict_gets(obj, "Length1")) != NULL)
+			if ((o = pdf_dict_gets(obj, "Length1")) != NULL)
 				dontexpand = !(doexpand & expand_fonts);
-			if ((o = fz_dict_gets(obj, "Length2")) != NULL)
+			if ((o = pdf_dict_gets(obj, "Length2")) != NULL)
 				dontexpand = !(doexpand & expand_fonts);
-			if ((o = fz_dict_gets(obj, "Length3")) != NULL)
+			if ((o = pdf_dict_gets(obj, "Length3")) != NULL)
 				dontexpand = !(doexpand & expand_fonts);
-			if (o = fz_dict_gets(obj, "Subtype"), !strcmp(fz_to_name(o), "Type1C"))
+			if (o = pdf_dict_gets(obj, "Subtype"), !strcmp(pdf_to_name(o), "Type1C"))
 				dontexpand = !(doexpand & expand_fonts);
-			if (o = fz_dict_gets(obj, "Subtype"), !strcmp(fz_to_name(o), "CIDFontType0C"))
+			if (o = pdf_dict_gets(obj, "Subtype"), !strcmp(pdf_to_name(o), "CIDFontType0C"))
 				dontexpand = !(doexpand & expand_fonts);
 		}
 		if (doexpand && !dontexpand && !pdf_is_jpx_image(ctx, obj))
@@ -652,13 +652,13 @@ static void writeobject(int num, int gen)
 			copystream(obj, num, gen);
 	}
 
-	fz_drop_obj(obj);
+	pdf_drop_obj(obj);
 }
 
 static void writexref(void)
 {
-	fz_obj *trailer;
-	fz_obj *obj;
+	pdf_obj *trailer;
+	pdf_obj *obj;
 	int startxref;
 	int num;
 
@@ -674,29 +674,29 @@ static void writexref(void)
 	}
 	fprintf(out, "\n");
 
-	trailer = fz_new_dict(ctx, 5);
+	trailer = pdf_new_dict(ctx, 5);
 
-	obj = fz_new_int(ctx, xref->len);
-	fz_dict_puts(trailer, "Size", obj);
-	fz_drop_obj(obj);
+	obj = pdf_new_int(ctx, xref->len);
+	pdf_dict_puts(trailer, "Size", obj);
+	pdf_drop_obj(obj);
 
-	obj = fz_dict_gets(xref->trailer, "Info");
+	obj = pdf_dict_gets(xref->trailer, "Info");
 	if (obj)
-		fz_dict_puts(trailer, "Info", obj);
+		pdf_dict_puts(trailer, "Info", obj);
 
-	obj = fz_dict_gets(xref->trailer, "Root");
+	obj = pdf_dict_gets(xref->trailer, "Root");
 	if (obj)
-		fz_dict_puts(trailer, "Root", obj);
+		pdf_dict_puts(trailer, "Root", obj);
 
-	obj = fz_dict_gets(xref->trailer, "ID");
+	obj = pdf_dict_gets(xref->trailer, "ID");
 	if (obj)
-		fz_dict_puts(trailer, "ID", obj);
+		pdf_dict_puts(trailer, "ID", obj);
 
 	fprintf(out, "trailer\n");
-	fz_fprint_obj(out, trailer, doexpand == 0);
+	pdf_fprint_obj(out, trailer, doexpand == 0);
 	fprintf(out, "\n");
 
-	fz_drop_obj(trailer);
+	pdf_drop_obj(trailer);
 
 	fprintf(out, "startxref\n%d\n%%%%EOF\n", startxref);
 }
diff --git a/apps/mupdfextract.c b/apps/mupdfextract.c
index 239e9ea7..dd3066f5 100644
--- a/apps/mupdfextract.c
+++ b/apps/mupdfextract.c
@@ -17,26 +17,26 @@ static void usage(void)
 	exit(1);
 }
 
-static int isimage(fz_obj *obj)
+static int isimage(pdf_obj *obj)
 {
-	fz_obj *type = fz_dict_gets(obj, "Subtype");
-	return fz_is_name(type) && !strcmp(fz_to_name(type), "Image");
+	pdf_obj *type = pdf_dict_gets(obj, "Subtype");
+	return pdf_is_name(type) && !strcmp(pdf_to_name(type), "Image");
 }
 
-static int isfontdesc(fz_obj *obj)
+static int isfontdesc(pdf_obj *obj)
 {
-	fz_obj *type = fz_dict_gets(obj, "Type");
-	return fz_is_name(type) && !strcmp(fz_to_name(type), "FontDescriptor");
+	pdf_obj *type = pdf_dict_gets(obj, "Type");
+	return pdf_is_name(type) && !strcmp(pdf_to_name(type), "FontDescriptor");
 }
 
 static void saveimage(int num)
 {
 	fz_image *image;
 	fz_pixmap *img;
-	fz_obj *ref;
+	pdf_obj *ref;
 	char name[1024];
 
-	ref = fz_new_indirect(ctx, num, 0, doc);
+	ref = pdf_new_indirect(ctx, num, 0, doc);
 
 	/* TODO: detect DCTD and save as jpeg */
 
@@ -67,49 +67,49 @@ static void saveimage(int num)
 	}
 
 	fz_drop_pixmap(ctx, img);
-	fz_drop_obj(ref);
+	pdf_drop_obj(ref);
 }
 
-static void savefont(fz_obj *dict, int num)
+static void savefont(pdf_obj *dict, int num)
 {
 	char name[1024];
 	char *subtype;
 	fz_buffer *buf;
-	fz_obj *stream = NULL;
-	fz_obj *obj;
+	pdf_obj *stream = NULL;
+	pdf_obj *obj;
 	char *ext = "";
 	FILE *f;
 	char *fontname = "font";
 	int n;
 
-	obj = fz_dict_gets(dict, "FontName");
+	obj = pdf_dict_gets(dict, "FontName");
 	if (obj)
-		fontname = fz_to_name(obj);
+		fontname = pdf_to_name(obj);
 
-	obj = fz_dict_gets(dict, "FontFile");
+	obj = pdf_dict_gets(dict, "FontFile");
 	if (obj)
 	{
 		stream = obj;
 		ext = "pfa";
 	}
 
-	obj = fz_dict_gets(dict, "FontFile2");
+	obj = pdf_dict_gets(dict, "FontFile2");
 	if (obj)
 	{
 		stream = obj;
 		ext = "ttf";
 	}
 
-	obj = fz_dict_gets(dict, "FontFile3");
+	obj = pdf_dict_gets(dict, "FontFile3");
 	if (obj)
 	{
 		stream = obj;
 
-		obj = fz_dict_gets(obj, "Subtype");
-		if (obj && !fz_is_name(obj))
+		obj = pdf_dict_gets(obj, "Subtype");
+		if (obj && !pdf_is_name(obj))
 			fz_throw(ctx, "Invalid font descriptor subtype");
 
-		subtype = fz_to_name(obj);
+		subtype = pdf_to_name(obj);
 		if (!strcmp(subtype, "Type1C"))
 			ext = "cff";
 		else if (!strcmp(subtype, "CIDFontType0C"))
@@ -124,7 +124,7 @@ static void savefont(fz_obj *dict, int num)
 		return;
 	}
 
-	buf = pdf_load_stream(doc, fz_to_num(stream), fz_to_gen(stream));
+	buf = pdf_load_stream(doc, pdf_to_num(stream), pdf_to_gen(stream));
 
 	sprintf(name, "%s-%04d.%s", fontname, num, ext);
 	printf("extracting font %s\n", name);
@@ -145,7 +145,7 @@ static void savefont(fz_obj *dict, int num)
 
 static void showobject(int num)
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 
 	if (!doc)
 		fz_throw(ctx, "no file specified");
@@ -157,7 +157,7 @@ static void showobject(int num)
 	else if (isfontdesc(obj))
 		savefont(obj, num);
 
-	fz_drop_obj(obj);
+	pdf_drop_obj(obj);
 }
 
 #ifdef MUPDF_COMBINED_EXE
diff --git a/apps/mupdfinfo.c b/apps/mupdfinfo.c
index 3c98c772..90316d6f 100644
--- a/apps/mupdfinfo.c
+++ b/apps/mupdfinfo.c
@@ -28,48 +28,48 @@ enum
 struct info
 {
 	int page;
-	fz_obj *pageref;
-	fz_obj *pageobj;
+	pdf_obj *pageref;
+	pdf_obj *pageobj;
 	union {
 		struct {
-			fz_obj *obj;
+			pdf_obj *obj;
 		} info;
 		struct {
-			fz_obj *obj;
+			pdf_obj *obj;
 		} crypt;
 		struct {
-			fz_obj *obj;
+			pdf_obj *obj;
 			fz_rect *bbox;
 		} dim;
 		struct {
-			fz_obj *obj;
-			fz_obj *subtype;
-			fz_obj *name;
+			pdf_obj *obj;
+			pdf_obj *subtype;
+			pdf_obj *name;
 		} font;
 		struct {
-			fz_obj *obj;
-			fz_obj *width;
-			fz_obj *height;
-			fz_obj *bpc;
-			fz_obj *filter;
-			fz_obj *cs;
-			fz_obj *altcs;
+			pdf_obj *obj;
+			pdf_obj *width;
+			pdf_obj *height;
+			pdf_obj *bpc;
+			pdf_obj *filter;
+			pdf_obj *cs;
+			pdf_obj *altcs;
 		} image;
 		struct {
-			fz_obj *obj;
-			fz_obj *type;
+			pdf_obj *obj;
+			pdf_obj *type;
 		} shading;
 		struct {
-			fz_obj *obj;
-			fz_obj *type;
-			fz_obj *paint;
-			fz_obj *tiling;
-			fz_obj *shading;
+			pdf_obj *obj;
+			pdf_obj *type;
+			pdf_obj *paint;
+			pdf_obj *tiling;
+			pdf_obj *shading;
 		} pattern;
 		struct {
-			fz_obj *obj;
-			fz_obj *groupsubtype;
-			fz_obj *reference;
+			pdf_obj *obj;
+			pdf_obj *groupsubtype;
+			pdf_obj *reference;
 		} form;
 	} u;
 };
@@ -168,36 +168,36 @@ infousage(void)
 static void
 showglobalinfo(void)
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 
 	printf("\nPDF-%d.%d\n", xref->version / 10, xref->version % 10);
 
-	obj = fz_dict_gets(xref->trailer, "Info");
+	obj = pdf_dict_gets(xref->trailer, "Info");
 	if (obj)
 	{
-		printf("Info object (%d %d R):\n", fz_to_num(obj), fz_to_gen(obj));
-		fz_debug_obj(fz_resolve_indirect(obj));
+		printf("Info object (%d %d R):\n", pdf_to_num(obj), pdf_to_gen(obj));
+		pdf_debug_obj(pdf_resolve_indirect(obj));
 	}
 
-	obj = fz_dict_gets(xref->trailer, "Encrypt");
+	obj = pdf_dict_gets(xref->trailer, "Encrypt");
 	if (obj)
 	{
-		printf("\nEncryption object (%d %d R):\n", fz_to_num(obj), fz_to_gen(obj));
-		fz_debug_obj(fz_resolve_indirect(obj));
+		printf("\nEncryption object (%d %d R):\n", pdf_to_num(obj), pdf_to_gen(obj));
+		pdf_debug_obj(pdf_resolve_indirect(obj));
 	}
 
 	printf("\nPages: %d\n\n", pagecount);
 }
 
 static void
-gatherdimensions(int page, fz_obj *pageref, fz_obj *pageobj)
+gatherdimensions(int page, pdf_obj *pageref, pdf_obj *pageobj)
 {
 	fz_rect bbox;
-	fz_obj *obj;
+	pdf_obj *obj;
 	int j;
 
-	obj = fz_dict_gets(pageobj, "MediaBox");
-	if (!fz_is_array(obj))
+	obj = pdf_dict_gets(pageobj, "MediaBox");
+	if (!pdf_is_array(obj))
 		return;
 
 	bbox = pdf_to_rect(ctx, obj);
@@ -222,33 +222,33 @@ gatherdimensions(int page, fz_obj *pageref, fz_obj *pageobj)
 }
 
 static void
-gatherfonts(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
+gatherfonts(int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict)
 {
 	int i, n;
 
-	n = fz_dict_len(dict);
+	n = pdf_dict_len(dict);
 	for (i = 0; i < n; i++)
 	{
-		fz_obj *fontdict = NULL;
-		fz_obj *subtype = NULL;
-		fz_obj *basefont = NULL;
-		fz_obj *name = NULL;
+		pdf_obj *fontdict = NULL;
+		pdf_obj *subtype = NULL;
+		pdf_obj *basefont = NULL;
+		pdf_obj *name = NULL;
 		int k;
 
-		fontdict = fz_dict_get_val(dict, i);
-		if (!fz_is_dict(fontdict))
+		fontdict = pdf_dict_get_val(dict, i);
+		if (!pdf_is_dict(fontdict))
 		{
-			fz_warn(ctx, "not a font dict (%d %d R)", fz_to_num(fontdict), fz_to_gen(fontdict));
+			fz_warn(ctx, "not a font dict (%d %d R)", pdf_to_num(fontdict), pdf_to_gen(fontdict));
 			continue;
 		}
 
-		subtype = fz_dict_gets(fontdict, "Subtype");
-		basefont = fz_dict_gets(fontdict, "BaseFont");
-		if (!basefont || fz_is_null(basefont))
-			name = fz_dict_gets(fontdict, "Name");
+		subtype = pdf_dict_gets(fontdict, "Subtype");
+		basefont = pdf_dict_gets(fontdict, "BaseFont");
+		if (!basefont || pdf_is_null(basefont))
+			name = pdf_dict_gets(fontdict, "Name");
 
 		for (k = 0; k < fonts; k++)
-			if (!fz_objcmp(font[k].u.font.obj, fontdict))
+			if (!pdf_objcmp(font[k].u.font.obj, fontdict))
 				break;
 
 		if (k < fonts)
@@ -267,57 +267,57 @@ gatherfonts(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 }
 
 static void
-gatherimages(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
+gatherimages(int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict)
 {
 	int i, n;
 
-	n = fz_dict_len(dict);
+	n = pdf_dict_len(dict);
 	for (i = 0; i < n; i++)
 	{
-		fz_obj *imagedict;
-		fz_obj *type;
-		fz_obj *width;
-		fz_obj *height;
-		fz_obj *bpc = NULL;
-		fz_obj *filter = NULL;
-		fz_obj *cs = NULL;
-		fz_obj *altcs;
+		pdf_obj *imagedict;
+		pdf_obj *type;
+		pdf_obj *width;
+		pdf_obj *height;
+		pdf_obj *bpc = NULL;
+		pdf_obj *filter = NULL;
+		pdf_obj *cs = NULL;
+		pdf_obj *altcs;
 		int k;
 
-		imagedict = fz_dict_get_val(dict, i);
-		if (!fz_is_dict(imagedict))
+		imagedict = pdf_dict_get_val(dict, i);
+		if (!pdf_is_dict(imagedict))
 		{
-			fz_warn(ctx, "not an image dict (%d %d R)", fz_to_num(imagedict), fz_to_gen(imagedict));
+			fz_warn(ctx, "not an image dict (%d %d R)", pdf_to_num(imagedict), pdf_to_gen(imagedict));
 			continue;
 		}
 
-		type = fz_dict_gets(imagedict, "Subtype");
-		if (strcmp(fz_to_name(type), "Image"))
+		type = pdf_dict_gets(imagedict, "Subtype");
+		if (strcmp(pdf_to_name(type), "Image"))
 			continue;
 
-		filter = fz_dict_gets(imagedict, "Filter");
+		filter = pdf_dict_gets(imagedict, "Filter");
 
 		altcs = NULL;
-		cs = fz_dict_gets(imagedict, "ColorSpace");
-		if (fz_is_array(cs))
+		cs = pdf_dict_gets(imagedict, "ColorSpace");
+		if (pdf_is_array(cs))
 		{
-			fz_obj *cses = cs;
+			pdf_obj *cses = cs;
 
-			cs = fz_array_get(cses, 0);
-			if (fz_is_name(cs) && (!strcmp(fz_to_name(cs), "DeviceN") || !strcmp(fz_to_name(cs), "Separation")))
+			cs = pdf_array_get(cses, 0);
+			if (pdf_is_name(cs) && (!strcmp(pdf_to_name(cs), "DeviceN") || !strcmp(pdf_to_name(cs), "Separation")))
 			{
-				altcs = fz_array_get(cses, 2);
-				if (fz_is_array(altcs))
-					altcs = fz_array_get(altcs, 0);
+				altcs = pdf_array_get(cses, 2);
+				if (pdf_is_array(altcs))
+					altcs = pdf_array_get(altcs, 0);
 			}
 		}
 
-		width = fz_dict_gets(imagedict, "Width");
-		height = fz_dict_gets(imagedict, "Height");
-		bpc = fz_dict_gets(imagedict, "BitsPerComponent");
+		width = pdf_dict_gets(imagedict, "Width");
+		height = pdf_dict_gets(imagedict, "Height");
+		bpc = pdf_dict_gets(imagedict, "BitsPerComponent");
 
 		for (k = 0; k < images; k++)
-			if (!fz_objcmp(image[k].u.image.obj, imagedict))
+			if (!pdf_objcmp(image[k].u.image.obj, imagedict))
 				break;
 
 		if (k < images)
@@ -340,42 +340,42 @@ gatherimages(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 }
 
 static void
-gatherforms(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
+gatherforms(int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict)
 {
 	int i, n;
 
-	n = fz_dict_len(dict);
+	n = pdf_dict_len(dict);
 	for (i = 0; i < n; i++)
 	{
-		fz_obj *xobjdict;
-		fz_obj *type;
-		fz_obj *subtype;
-		fz_obj *group;
-		fz_obj *groupsubtype;
-		fz_obj *reference;
+		pdf_obj *xobjdict;
+		pdf_obj *type;
+		pdf_obj *subtype;
+		pdf_obj *group;
+		pdf_obj *groupsubtype;
+		pdf_obj *reference;
 		int k;
 
-		xobjdict = fz_dict_get_val(dict, i);
-		if (!fz_is_dict(xobjdict))
+		xobjdict = pdf_dict_get_val(dict, i);
+		if (!pdf_is_dict(xobjdict))
 		{
-			fz_warn(ctx, "not a xobject dict (%d %d R)", fz_to_num(xobjdict), fz_to_gen(xobjdict));
+			fz_warn(ctx, "not a xobject dict (%d %d R)", pdf_to_num(xobjdict), pdf_to_gen(xobjdict));
 			continue;
 		}
 
-		type = fz_dict_gets(xobjdict, "Subtype");
-		if (strcmp(fz_to_name(type), "Form"))
+		type = pdf_dict_gets(xobjdict, "Subtype");
+		if (strcmp(pdf_to_name(type), "Form"))
 			continue;
 
-		subtype = fz_dict_gets(xobjdict, "Subtype2");
-		if (!strcmp(fz_to_name(subtype), "PS"))
+		subtype = pdf_dict_gets(xobjdict, "Subtype2");
+		if (!strcmp(pdf_to_name(subtype), "PS"))
 			continue;
 
-		group = fz_dict_gets(xobjdict, "Group");
-		groupsubtype = fz_dict_gets(group, "S");
-		reference = fz_dict_gets(xobjdict, "Ref");
+		group = pdf_dict_gets(xobjdict, "Group");
+		groupsubtype = pdf_dict_gets(group, "S");
+		reference = pdf_dict_gets(xobjdict, "Ref");
 
 		for (k = 0; k < forms; k++)
-			if (!fz_objcmp(form[k].u.form.obj, xobjdict))
+			if (!pdf_objcmp(form[k].u.form.obj, xobjdict))
 				break;
 
 		if (k < forms)
@@ -394,33 +394,33 @@ gatherforms(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 }
 
 static void
-gatherpsobjs(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
+gatherpsobjs(int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict)
 {
 	int i, n;
 
-	n = fz_dict_len(dict);
+	n = pdf_dict_len(dict);
 	for (i = 0; i < n; i++)
 	{
-		fz_obj *xobjdict;
-		fz_obj *type;
-		fz_obj *subtype;
+		pdf_obj *xobjdict;
+		pdf_obj *type;
+		pdf_obj *subtype;
 		int k;
 
-		xobjdict = fz_dict_get_val(dict, i);
-		if (!fz_is_dict(xobjdict))
+		xobjdict = pdf_dict_get_val(dict, i);
+		if (!pdf_is_dict(xobjdict))
 		{
-			fz_warn(ctx, "not a xobject dict (%d %d R)", fz_to_num(xobjdict), fz_to_gen(xobjdict));
+			fz_warn(ctx, "not a xobject dict (%d %d R)", pdf_to_num(xobjdict), pdf_to_gen(xobjdict));
 			continue;
 		}
 
-		type = fz_dict_gets(xobjdict, "Subtype");
-		subtype = fz_dict_gets(xobjdict, "Subtype2");
-		if (strcmp(fz_to_name(type), "PS") &&
-			(strcmp(fz_to_name(type), "Form") || strcmp(fz_to_name(subtype), "PS")))
+		type = pdf_dict_gets(xobjdict, "Subtype");
+		subtype = pdf_dict_gets(xobjdict, "Subtype2");
+		if (strcmp(pdf_to_name(type), "PS") &&
+			(strcmp(pdf_to_name(type), "Form") || strcmp(pdf_to_name(subtype), "PS")))
 			continue;
 
 		for (k = 0; k < psobjs; k++)
-			if (!fz_objcmp(psobj[k].u.form.obj, xobjdict))
+			if (!pdf_objcmp(psobj[k].u.form.obj, xobjdict))
 				break;
 
 		if (k < psobjs)
@@ -437,33 +437,33 @@ gatherpsobjs(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 }
 
 static void
-gathershadings(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
+gathershadings(int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict)
 {
 	int i, n;
 
-	n = fz_dict_len(dict);
+	n = pdf_dict_len(dict);
 	for (i = 0; i < n; i++)
 	{
-		fz_obj *shade;
-		fz_obj *type;
+		pdf_obj *shade;
+		pdf_obj *type;
 		int k;
 
-		shade = fz_dict_get_val(dict, i);
-		if (!fz_is_dict(shade))
+		shade = pdf_dict_get_val(dict, i);
+		if (!pdf_is_dict(shade))
 		{
-			fz_warn(ctx, "not a shading dict (%d %d R)", fz_to_num(shade), fz_to_gen(shade));
+			fz_warn(ctx, "not a shading dict (%d %d R)", pdf_to_num(shade), pdf_to_gen(shade));
 			continue;
 		}
 
-		type = fz_dict_gets(shade, "ShadingType");
-		if (!fz_is_int(type) || fz_to_int(type) < 1 || fz_to_int(type) > 7)
+		type = pdf_dict_gets(shade, "ShadingType");
+		if (!pdf_is_int(type) || pdf_to_int(type) < 1 || pdf_to_int(type) > 7)
 		{
-			fz_warn(ctx, "not a shading type (%d %d R)", fz_to_num(shade), fz_to_gen(shade));
+			fz_warn(ctx, "not a shading type (%d %d R)", pdf_to_num(shade), pdf_to_gen(shade));
 			type = NULL;
 		}
 
 		for (k = 0; k < shadings; k++)
-			if (!fz_objcmp(shading[k].u.shading.obj, shade))
+			if (!pdf_objcmp(shading[k].u.shading.obj, shade))
 				break;
 
 		if (k < shadings)
@@ -481,57 +481,57 @@ gathershadings(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 }
 
 static void
-gatherpatterns(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
+gatherpatterns(int page, pdf_obj *pageref, pdf_obj *pageobj, pdf_obj *dict)
 {
 	int i, n;
 
-	n = fz_dict_len(dict);
+	n = pdf_dict_len(dict);
 	for (i = 0; i < n; i++)
 	{
-		fz_obj *patterndict;
-		fz_obj *type;
-		fz_obj *paint = NULL;
-		fz_obj *tiling = NULL;
-		fz_obj *shading = NULL;
+		pdf_obj *patterndict;
+		pdf_obj *type;
+		pdf_obj *paint = NULL;
+		pdf_obj *tiling = NULL;
+		pdf_obj *shading = NULL;
 		int k;
 
-		patterndict = fz_dict_get_val(dict, i);
-		if (!fz_is_dict(patterndict))
+		patterndict = pdf_dict_get_val(dict, i);
+		if (!pdf_is_dict(patterndict))
 		{
-			fz_warn(ctx, "not a pattern dict (%d %d R)", fz_to_num(patterndict), fz_to_gen(patterndict));
+			fz_warn(ctx, "not a pattern dict (%d %d R)", pdf_to_num(patterndict), pdf_to_gen(patterndict));
 			continue;
 		}
 
-		type = fz_dict_gets(patterndict, "PatternType");
-		if (!fz_is_int(type) || fz_to_int(type) < 1 || fz_to_int(type) > 2)
+		type = pdf_dict_gets(patterndict, "PatternType");
+		if (!pdf_is_int(type) || pdf_to_int(type) < 1 || pdf_to_int(type) > 2)
 		{
-			fz_warn(ctx, "not a pattern type (%d %d R)", fz_to_num(patterndict), fz_to_gen(patterndict));
+			fz_warn(ctx, "not a pattern type (%d %d R)", pdf_to_num(patterndict), pdf_to_gen(patterndict));
 			type = NULL;
 		}
 
-		if (fz_to_int(type) == 1)
+		if (pdf_to_int(type) == 1)
 		{
-			paint = fz_dict_gets(patterndict, "PaintType");
-			if (!fz_is_int(paint) || fz_to_int(paint) < 1 || fz_to_int(paint) > 2)
+			paint = pdf_dict_gets(patterndict, "PaintType");
+			if (!pdf_is_int(paint) || pdf_to_int(paint) < 1 || pdf_to_int(paint) > 2)
 			{
-				fz_warn(ctx, "not a pattern paint type (%d %d R)", fz_to_num(patterndict), fz_to_gen(patterndict));
+				fz_warn(ctx, "not a pattern paint type (%d %d R)", pdf_to_num(patterndict), pdf_to_gen(patterndict));
 				paint = NULL;
 			}
 
-			tiling = fz_dict_gets(patterndict, "TilingType");
-			if (!fz_is_int(tiling) || fz_to_int(tiling) < 1 || fz_to_int(tiling) > 3)
+			tiling = pdf_dict_gets(patterndict, "TilingType");
+			if (!pdf_is_int(tiling) || pdf_to_int(tiling) < 1 || pdf_to_int(tiling) > 3)
 			{
-				fz_warn(ctx, "not a pattern tiling type (%d %d R)", fz_to_num(patterndict), fz_to_gen(patterndict));
+				fz_warn(ctx, "not a pattern tiling type (%d %d R)", pdf_to_num(patterndict), pdf_to_gen(patterndict));
 				tiling = NULL;
 			}
 		}
 		else
 		{
-			shading = fz_dict_gets(patterndict, "Shading");
+			shading = pdf_dict_gets(patterndict, "Shading");
 		}
 
 		for (k = 0; k < patterns; k++)
-			if (!fz_objcmp(pattern[k].u.pattern.obj, patterndict))
+			if (!pdf_objcmp(pattern[k].u.pattern.obj, patterndict))
 				break;
 
 		if (k < patterns)
@@ -552,15 +552,15 @@ gatherpatterns(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 }
 
 static void
-gatherresourceinfo(int page, fz_obj *rsrc)
+gatherresourceinfo(int page, pdf_obj *rsrc)
 {
-	fz_obj *pageobj;
-	fz_obj *pageref;
-	fz_obj *font;
-	fz_obj *xobj;
-	fz_obj *shade;
-	fz_obj *pattern;
-	fz_obj *subrsrc;
+	pdf_obj *pageobj;
+	pdf_obj *pageref;
+	pdf_obj *font;
+	pdf_obj *xobj;
+	pdf_obj *shade;
+	pdf_obj *pattern;
+	pdf_obj *subrsrc;
 	int i;
 
 	pageobj = xref->page_objs[page-1];
@@ -569,24 +569,24 @@ gatherresourceinfo(int page, fz_obj *rsrc)
 	if (!pageobj)
 		fz_throw(ctx, "cannot retrieve info from page %d", page);
 
-	font = fz_dict_gets(rsrc, "Font");
+	font = pdf_dict_gets(rsrc, "Font");
 	if (font)
 	{
 		int n;
 
 		gatherfonts(page, pageref, pageobj, font);
-		n = fz_dict_len(font);
+		n = pdf_dict_len(font);
 		for (i = 0; i < n; i++)
 		{
-			fz_obj *obj = fz_dict_get_val(font, i);
+			pdf_obj *obj = pdf_dict_get_val(font, i);
 
-			subrsrc = fz_dict_gets(obj, "Resources");
-			if (subrsrc && fz_objcmp(rsrc, subrsrc))
+			subrsrc = pdf_dict_gets(obj, "Resources");
+			if (subrsrc && pdf_objcmp(rsrc, subrsrc))
 				gatherresourceinfo(page, subrsrc);
 		}
 	}
 
-	xobj = fz_dict_gets(rsrc, "XObject");
+	xobj = pdf_dict_gets(rsrc, "XObject");
 	if (xobj)
 	{
 		int n;
@@ -594,31 +594,31 @@ gatherresourceinfo(int page, fz_obj *rsrc)
 		gatherimages(page, pageref, pageobj, xobj);
 		gatherforms(page, pageref, pageobj, xobj);
 		gatherpsobjs(page, pageref, pageobj, xobj);
-		n = fz_dict_len(xobj);
+		n = pdf_dict_len(xobj);
 		for (i = 0; i < n; i++)
 		{
-			fz_obj *obj = fz_dict_get_val(xobj, i);
-			subrsrc = fz_dict_gets(obj, "Resources");
-			if (subrsrc && fz_objcmp(rsrc, subrsrc))
+			pdf_obj *obj = pdf_dict_get_val(xobj, i);
+			subrsrc = pdf_dict_gets(obj, "Resources");
+			if (subrsrc && pdf_objcmp(rsrc, subrsrc))
 				gatherresourceinfo(page, subrsrc);
 		}
 	}
 
-	shade = fz_dict_gets(rsrc, "Shading");
+	shade = pdf_dict_gets(rsrc, "Shading");
 	if (shade)
 		gathershadings(page, pageref, pageobj, shade);
 
-	pattern = fz_dict_gets(rsrc, "Pattern");
+	pattern = pdf_dict_gets(rsrc, "Pattern");
 	if (pattern)
 	{
 		int n;
 		gatherpatterns(page, pageref, pageobj, pattern);
-		n = fz_dict_len(pattern);
+		n = pdf_dict_len(pattern);
 		for (i = 0; i < n; i++)
 		{
-			fz_obj *obj = fz_dict_get_val(pattern, i);
-			subrsrc = fz_dict_gets(obj, "Resources");
-			if (subrsrc && fz_objcmp(rsrc, subrsrc))
+			pdf_obj *obj = pdf_dict_get_val(pattern, i);
+			subrsrc = pdf_dict_gets(obj, "Resources");
+			if (subrsrc && pdf_objcmp(rsrc, subrsrc))
 				gatherresourceinfo(page, subrsrc);
 		}
 	}
@@ -627,9 +627,9 @@ gatherresourceinfo(int page, fz_obj *rsrc)
 static void
 gatherpageinfo(int page)
 {
-	fz_obj *pageobj;
-	fz_obj *pageref;
-	fz_obj *rsrc;
+	pdf_obj *pageobj;
+	pdf_obj *pageref;
+	pdf_obj *rsrc;
 
 	pageobj = xref->page_objs[page-1];
 	pageref = xref->page_refs[page-1];
@@ -639,7 +639,7 @@ gatherpageinfo(int page)
 
 	gatherdimensions(page, pageref, pageobj);
 
-	rsrc = fz_dict_gets(pageobj, "Resources");
+	rsrc = pdf_dict_gets(pageobj, "Resources");
 	gatherresourceinfo(page, rsrc);
 }
 
@@ -658,7 +658,7 @@ printinfo(char *filename, int show, int page)
 		{
 			printf(PAGE_FMT "[ %g %g %g %g ]\n",
 				dim[i].page,
-				fz_to_num(dim[i].pageref), fz_to_gen(dim[i].pageref),
+				pdf_to_num(dim[i].pageref), pdf_to_gen(dim[i].pageref),
 				dim[i].u.dim.bbox->x0,
 				dim[i].u.dim.bbox->y0,
 				dim[i].u.dim.bbox->x1,
@@ -674,10 +674,10 @@ printinfo(char *filename, int show, int page)
 		{
 			printf(PAGE_FMT "%s '%s' (%d %d R)\n",
 				font[i].page,
-				fz_to_num(font[i].pageref), fz_to_gen(font[i].pageref),
-				fz_to_name(font[i].u.font.subtype),
-				fz_to_name(font[i].u.font.name),
-				fz_to_num(font[i].u.font.obj), fz_to_gen(font[i].u.font.obj));
+				pdf_to_num(font[i].pageref), pdf_to_gen(font[i].pageref),
+				pdf_to_name(font[i].u.font.subtype),
+				pdf_to_name(font[i].u.font.name),
+				pdf_to_num(font[i].u.font.obj), pdf_to_gen(font[i].u.font.obj));
 		}
 		printf("\n");
 	}
@@ -692,29 +692,29 @@ printinfo(char *filename, int show, int page)
 
 			printf(PAGE_FMT "[ ",
 				image[i].page,
-				fz_to_num(image[i].pageref), fz_to_gen(image[i].pageref));
+				pdf_to_num(image[i].pageref), pdf_to_gen(image[i].pageref));
 
-			if (fz_is_array(image[i].u.image.filter))
+			if (pdf_is_array(image[i].u.image.filter))
 			{
-				int n = fz_array_len(image[i].u.image.filter);
+				int n = pdf_array_len(image[i].u.image.filter);
 				for (j = 0; j < n; j++)
 				{
-					fz_obj *obj = fz_array_get(image[i].u.image.filter, j);
-					char *filter = fz_strdup(ctx, fz_to_name(obj));
+					pdf_obj *obj = pdf_array_get(image[i].u.image.filter, j);
+					char *filter = fz_strdup(ctx, pdf_to_name(obj));
 
 					if (strstr(filter, "Decode"))
 						*(strstr(filter, "Decode")) = '\0';
 
 					printf("%s%s",
 							filter,
-							j == fz_array_len(image[i].u.image.filter) - 1 ? "" : " ");
+							j == pdf_array_len(image[i].u.image.filter) - 1 ? "" : " ");
 					fz_free(ctx, filter);
 				}
 			}
 			else if (image[i].u.image.filter)
 			{
-				fz_obj *obj = image[i].u.image.filter;
-				char *filter = fz_strdup(ctx, fz_to_name(obj));
+				pdf_obj *obj = image[i].u.image.filter;
+				char *filter = fz_strdup(ctx, pdf_to_name(obj));
 
 				if (strstr(filter, "Decode"))
 					*(strstr(filter, "Decode")) = '\0';
@@ -727,7 +727,7 @@ printinfo(char *filename, int show, int page)
 
 			if (image[i].u.image.cs)
 			{
-				cs = fz_strdup(ctx, fz_to_name(image[i].u.image.cs));
+				cs = fz_strdup(ctx, pdf_to_name(image[i].u.image.cs));
 
 				if (!strncmp(cs, "Device", 6))
 				{
@@ -746,7 +746,7 @@ printinfo(char *filename, int show, int page)
 			}
 			if (image[i].u.image.altcs)
 			{
-				altcs = fz_strdup(ctx, fz_to_name(image[i].u.image.altcs));
+				altcs = fz_strdup(ctx, pdf_to_name(image[i].u.image.altcs));
 
 				if (!strncmp(altcs, "Device", 6))
 				{
@@ -765,13 +765,13 @@ printinfo(char *filename, int show, int page)
 			}
 
 			printf(" ] %dx%d %dbpc %s%s%s (%d %d R)\n",
-				fz_to_int(image[i].u.image.width),
-				fz_to_int(image[i].u.image.height),
-				image[i].u.image.bpc ? fz_to_int(image[i].u.image.bpc) : 1,
+				pdf_to_int(image[i].u.image.width),
+				pdf_to_int(image[i].u.image.height),
+				image[i].u.image.bpc ? pdf_to_int(image[i].u.image.bpc) : 1,
 				image[i].u.image.cs ? cs : "ImageMask",
 				image[i].u.image.altcs ? " " : "",
 				image[i].u.image.altcs ? altcs : "",
-				fz_to_num(image[i].u.image.obj), fz_to_gen(image[i].u.image.obj));
+				pdf_to_num(image[i].u.image.obj), pdf_to_gen(image[i].u.image.obj));
 
 			fz_free(ctx, cs);
 			fz_free(ctx, altcs);
@@ -798,9 +798,9 @@ printinfo(char *filename, int show, int page)
 
 			printf(PAGE_FMT "%s (%d %d R)\n",
 				shading[i].page,
-				fz_to_num(shading[i].pageref), fz_to_gen(shading[i].pageref),
-				shadingtype[fz_to_int(shading[i].u.shading.type)],
-				fz_to_num(shading[i].u.shading.obj), fz_to_gen(shading[i].u.shading.obj));
+				pdf_to_num(shading[i].pageref), pdf_to_gen(shading[i].pageref),
+				shadingtype[pdf_to_int(shading[i].u.shading.type)],
+				pdf_to_num(shading[i].u.shading.obj), pdf_to_gen(shading[i].u.shading.obj));
 		}
 		printf("\n");
 	}
@@ -810,7 +810,7 @@ printinfo(char *filename, int show, int page)
 		printf("Patterns (%d):\n", patterns);
 		for (i = 0; i < patterns; i++)
 		{
-			if (fz_to_int(pattern[i].u.pattern.type) == 1)
+			if (pdf_to_int(pattern[i].u.pattern.type) == 1)
 			{
 				char *painttype[] =
 				{
@@ -828,18 +828,18 @@ printinfo(char *filename, int show, int page)
 
 				printf(PAGE_FMT "Tiling %s %s (%d %d R)\n",
 						pattern[i].page,
-						fz_to_num(pattern[i].pageref), fz_to_gen(pattern[i].pageref),
-						painttype[fz_to_int(pattern[i].u.pattern.paint)],
-						tilingtype[fz_to_int(pattern[i].u.pattern.tiling)],
-						fz_to_num(pattern[i].u.pattern.obj), fz_to_gen(pattern[i].u.pattern.obj));
+						pdf_to_num(pattern[i].pageref), pdf_to_gen(pattern[i].pageref),
+						painttype[pdf_to_int(pattern[i].u.pattern.paint)],
+						tilingtype[pdf_to_int(pattern[i].u.pattern.tiling)],
+						pdf_to_num(pattern[i].u.pattern.obj), pdf_to_gen(pattern[i].u.pattern.obj));
 			}
 			else
 			{
 				printf(PAGE_FMT "Shading %d %d R (%d %d R)\n",
 						pattern[i].page,
-						fz_to_num(pattern[i].pageref), fz_to_gen(pattern[i].pageref),
-						fz_to_num(pattern[i].u.pattern.shading), fz_to_gen(pattern[i].u.pattern.shading),
-						fz_to_num(pattern[i].u.pattern.obj), fz_to_gen(pattern[i].u.pattern.obj));
+						pdf_to_num(pattern[i].pageref), pdf_to_gen(pattern[i].pageref),
+						pdf_to_num(pattern[i].u.pattern.shading), pdf_to_gen(pattern[i].u.pattern.shading),
+						pdf_to_num(pattern[i].u.pattern.obj), pdf_to_gen(pattern[i].u.pattern.obj));
 			}
 		}
 		printf("\n");
@@ -852,12 +852,12 @@ printinfo(char *filename, int show, int page)
 		{
 			printf(PAGE_FMT "Form%s%s%s%s (%d %d R)\n",
 				form[i].page,
-				fz_to_num(form[i].pageref), fz_to_gen(form[i].pageref),
+				pdf_to_num(form[i].pageref), pdf_to_gen(form[i].pageref),
 				form[i].u.form.groupsubtype ? " " : "",
-				form[i].u.form.groupsubtype ? fz_to_name(form[i].u.form.groupsubtype) : "",
+				form[i].u.form.groupsubtype ? pdf_to_name(form[i].u.form.groupsubtype) : "",
 				form[i].u.form.groupsubtype ? " Group" : "",
 				form[i].u.form.reference ? " Reference" : "",
-				fz_to_num(form[i].u.form.obj), fz_to_gen(form[i].u.form.obj));
+				pdf_to_num(form[i].u.form.obj), pdf_to_gen(form[i].u.form.obj));
 		}
 		printf("\n");
 	}
@@ -869,8 +869,8 @@ printinfo(char *filename, int show, int page)
 		{
 			printf(PAGE_FMT "(%d %d R)\n",
 				psobj[i].page,
-				fz_to_num(psobj[i].pageref), fz_to_gen(psobj[i].pageref),
-				fz_to_num(psobj[i].u.form.obj), fz_to_gen(psobj[i].u.form.obj));
+				pdf_to_num(psobj[i].pageref), pdf_to_gen(psobj[i].pageref),
+				pdf_to_num(psobj[i].u.form.obj), pdf_to_gen(psobj[i].u.form.obj));
 		}
 		printf("\n");
 	}
diff --git a/apps/mupdfshow.c b/apps/mupdfshow.c
index 8dcdd17d..92fcac2d 100644
--- a/apps/mupdfshow.c
+++ b/apps/mupdfshow.c
@@ -25,7 +25,7 @@ static void showtrailer(void)
 	if (!doc)
 		fz_throw(ctx, "no file specified");
 	printf("trailer\n");
-	fz_debug_obj(doc->trailer);
+	pdf_debug_obj(doc->trailer);
 	printf("\n");
 }
 
@@ -39,7 +39,7 @@ static void showxref(void)
 
 static void showpagetree(void)
 {
-	fz_obj *ref;
+	pdf_obj *ref;
 	int count;
 	int i;
 
@@ -50,7 +50,7 @@ static void showpagetree(void)
 	for (i = 0; i < count; i++)
 	{
 		ref = doc->page_refs[i];
-		printf("page %d = %d %d R\n", i + 1, fz_to_num(ref), fz_to_gen(ref));
+		printf("page %d = %d %d R\n", i + 1, pdf_to_num(ref), pdf_to_gen(ref));
 	}
 	printf("\n");
 }
@@ -107,7 +107,7 @@ static void showstream(int num, int gen)
 
 static void showobject(int num, int gen)
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 
 	if (!doc)
 		fz_throw(ctx, "no file specified");
@@ -123,7 +123,7 @@ static void showobject(int num, int gen)
 		else
 		{
 			printf("%d %d obj\n", num, gen);
-			fz_debug_obj(obj);
+			pdf_debug_obj(obj);
 			printf("stream\n");
 			showstream(num, gen);
 			printf("endstream\n");
@@ -133,16 +133,16 @@ static void showobject(int num, int gen)
 	else
 	{
 		printf("%d %d obj\n", num, gen);
-		fz_debug_obj(obj);
+		pdf_debug_obj(obj);
 		printf("endobj\n\n");
 	}
 
-	fz_drop_obj(obj);
+	pdf_drop_obj(obj);
 }
 
 static void showgrep(char *filename)
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 	int i;
 
 	for (i = 0; i < doc->len; i++)
@@ -159,17 +159,17 @@ static void showgrep(char *filename)
 				continue;
 			}
 
-			fz_sort_dict(obj);
+			pdf_sort_dict(obj);
 
 			printf("%s:%d: ", filename, i);
-			fz_fprint_obj(stdout, obj, 1);
+			pdf_fprint_obj(stdout, obj, 1);
 
-			fz_drop_obj(obj);
+			pdf_drop_obj(obj);
 		}
 	}
 
 	printf("%s:trailer: ", filename);
-	fz_fprint_obj(stdout, doc->trailer, 1);
+	pdf_fprint_obj(stdout, doc->trailer, 1);
 }
 
 #ifdef MUPDF_COMBINED_EXE
diff --git a/fitz/base_context.c b/fitz/base_context.c
index fe69ff8e..d1ce63ae 100644
--- a/fitz/base_context.c
+++ b/fitz/base_context.c
@@ -1,13 +1,5 @@
 #include "fitz.h"
 
-static fz_obj *
-fz_resolve_indirect_null(fz_obj *ref)
-{
-	return ref;
-}
-
-fz_obj *(*fz_resolve_indirect)(fz_obj*) = fz_resolve_indirect_null;
-
 void
 fz_free_context(fz_context *ctx)
 {
diff --git a/fitz/fitz.h b/fitz/fitz.h
index cb7cfa4d..e24d3fbb 100644
--- a/fitz/fitz.h
+++ b/fitz/fitz.h
@@ -54,7 +54,6 @@
 int gettimeofday(struct timeval *tv, struct timezone *tz);
 
 #define snprintf _snprintf
-#define strtoll _strtoi64
 
 #else /* Unix or close enough */
 
@@ -909,87 +908,6 @@ void aes_crypt_cbc( fz_aes *ctx, int mode, int length,
 	unsigned char *output );
 
 /*
- * Dynamic objects.
- * The same type of objects as found in PDF and PostScript.
- * Used by the filters and the mupdf parser.
- */
-
-typedef struct fz_obj_s fz_obj;
-
-extern fz_obj *(*fz_resolve_indirect)(fz_obj *obj);
-
-fz_obj *fz_new_null(fz_context *ctx);
-fz_obj *fz_new_bool(fz_context *ctx, int b);
-fz_obj *fz_new_int(fz_context *ctx, int i);
-fz_obj *fz_new_real(fz_context *ctx, float f);
-fz_obj *fz_new_name(fz_context *ctx, char *str);
-fz_obj *fz_new_string(fz_context *ctx, char *str, int len);
-fz_obj *fz_new_indirect(fz_context *ctx, int num, int gen, void *doc);
-
-fz_obj *fz_new_array(fz_context *ctx, int initialcap);
-fz_obj *fz_new_dict(fz_context *ctx, int initialcap);
-fz_obj *fz_copy_array(fz_context *ctx, fz_obj *array);
-fz_obj *fz_copy_dict(fz_context *ctx, fz_obj *dict);
-
-fz_obj *fz_keep_obj(fz_obj *obj);
-void fz_drop_obj(fz_obj *obj);
-
-/* type queries */
-int fz_is_null(fz_obj *obj);
-int fz_is_bool(fz_obj *obj);
-int fz_is_int(fz_obj *obj);
-int fz_is_real(fz_obj *obj);
-int fz_is_name(fz_obj *obj);
-int fz_is_string(fz_obj *obj);
-int fz_is_array(fz_obj *obj);
-int fz_is_dict(fz_obj *obj);
-int fz_is_indirect(fz_obj *obj);
-
-int fz_objcmp(fz_obj *a, fz_obj *b);
-
-/* dict marking and unmarking functions - to avoid infinite recursions */
-int fz_dict_marked(fz_obj *obj);
-int fz_dict_mark(fz_obj *obj);
-void fz_dict_unmark(fz_obj *obj);
-
-/* safe, silent failure, no error reporting on type mismatches */
-int fz_to_bool(fz_obj *obj);
-int fz_to_int(fz_obj *obj);
-float fz_to_real(fz_obj *obj);
-char *fz_to_name(fz_obj *obj);
-char *fz_to_str_buf(fz_obj *obj);
-fz_obj *fz_to_dict(fz_obj *obj);
-int fz_to_str_len(fz_obj *obj);
-int fz_to_num(fz_obj *obj);
-int fz_to_gen(fz_obj *obj);
-
-int fz_array_len(fz_obj *array);
-fz_obj *fz_array_get(fz_obj *array, int i);
-void fz_array_put(fz_obj *array, int i, fz_obj *obj);
-void fz_array_push(fz_obj *array, fz_obj *obj);
-void fz_array_insert(fz_obj *array, fz_obj *obj);
-int fz_array_contains(fz_obj *array, fz_obj *obj);
-
-int fz_dict_len(fz_obj *dict);
-fz_obj *fz_dict_get_key(fz_obj *dict, int idx);
-fz_obj *fz_dict_get_val(fz_obj *dict, int idx);
-fz_obj *fz_dict_get(fz_obj *dict, fz_obj *key);
-fz_obj *fz_dict_gets(fz_obj *dict, char *key);
-fz_obj *fz_dict_getsa(fz_obj *dict, char *key, char *abbrev);
-void fz_dict_put(fz_obj *dict, fz_obj *key, fz_obj *val);
-void fz_dict_puts(fz_obj *dict, char *key, fz_obj *val);
-void fz_dict_del(fz_obj *dict, fz_obj *key);
-void fz_dict_dels(fz_obj *dict, char *key);
-void fz_sort_dict(fz_obj *dict);
-
-int fz_fprint_obj(FILE *fp, fz_obj *obj, int tight);
-void fz_debug_obj(fz_obj *obj);
-void fz_debug_ref(fz_obj *obj);
-
-void fz_set_str_len(fz_obj *obj, int newlen); /* private */
-void *fz_get_indirect_document(fz_obj *obj); /* private */
-
-/*
 	fz_buffer is a XXX
 */
 typedef struct fz_buffer_s fz_buffer;
@@ -1071,6 +989,7 @@ struct fz_store_type_s
 	void *(*keep_key)(fz_context *,void *);
 	void (*drop_key)(fz_context *,void *);
 	int (*cmp_key)(void *, void *);
+	void (*debug)(void *);
 };
 
 void fz_new_store_context(fz_context *ctx, unsigned int max);
@@ -1558,12 +1477,13 @@ struct fz_font_s
 	int ft_size;
 
 	fz_matrix t3matrix;
-	fz_obj *t3resources;
+	void *t3resources;
 	fz_buffer **t3procs; /* has 256 entries if used */
 	float *t3widths; /* has 256 entries if used */
 	char *t3flags; /* has 256 entries if used */
 	void *t3doc; /* a pdf_document for the callback */
-	void (*t3run)(void *doc, fz_obj *resources, fz_buffer *contents, fz_device *dev, fz_matrix ctm, void *gstate);
+	void (*t3run)(void *doc, void *resources, fz_buffer *contents, fz_device *dev, fz_matrix ctm, void *gstate);
+	void (*t3freeres)(void *doc, void *resources);
 
 	fz_rect bbox;	/* font bbox is used only for t3 fonts */
 
diff --git a/fitz/res_font.c b/fitz/res_font.c
index 7a194da6..e44be9b6 100644
--- a/fitz/res_font.c
+++ b/fitz/res_font.c
@@ -93,7 +93,7 @@ fz_drop_font(fz_context *ctx, fz_font *font)
 	if (font->t3procs)
 	{
 		if (font->t3resources)
-			fz_drop_obj(font->t3resources);
+			font->t3freeres(font->t3doc, font->t3resources);
 		for (i = 0; i < 256; i++)
 			if (font->t3procs[i])
 				fz_drop_buffer(ctx, font->t3procs[i]);
diff --git a/fitz/res_store.c b/fitz/res_store.c
index 461ea7c8..8f9c1ad8 100644
--- a/fitz/res_store.c
+++ b/fitz/res_store.c
@@ -459,17 +459,15 @@ fz_debug_store(fz_context *ctx)
 	for (item = store->head; item; item = next)
 	{
 		next = item->next;
-		next->val->refs++;
+		if (next)
+			next->val->refs++;
 		printf("store[*][refs=%d][size=%d] ", item->val->refs, item->size);
 		fz_unlock(ctx, FZ_LOCK_ALLOC);
-		if (fz_is_indirect(item->key))
-		{
-			printf("(%d %d R) ", fz_to_num(item->key), fz_to_gen(item->key));
-		} else
-			fz_debug_obj(item->key);
+		item->type->debug(item->key);
 		printf(" = %p\n", item->val);
 		fz_lock(ctx, FZ_LOCK_ALLOC);
-		next->val->refs--;
+		if (next)
+			next->val->refs--;
 	}
 	fz_unlock(ctx, FZ_LOCK_ALLOC);
 }
diff --git a/fitz/base_object.c b/pdf/base_object.c
index 964c5bb4..94f1acfc 100644
--- a/fitz/base_object.c
+++ b/pdf/base_object.c
@@ -1,28 +1,29 @@
 #include "fitz.h"
+#include "mupdf.h"
 
-typedef enum fz_objkind_e
+typedef enum pdf_objkind_e
 {
-	FZ_NULL,
-	FZ_BOOL,
-	FZ_INT,
-	FZ_REAL,
-	FZ_STRING,
-	FZ_NAME,
-	FZ_ARRAY,
-	FZ_DICT,
-	FZ_INDIRECT
-} fz_objkind;
+	PDF_NULL,
+	PDF_BOOL,
+	PDF_INT,
+	PDF_REAL,
+	PDF_STRING,
+	PDF_NAME,
+	PDF_ARRAY,
+	PDF_DICT,
+	PDF_INDIRECT
+} pdf_objkind;
 
 struct keyval
 {
-	fz_obj *k;
-	fz_obj *v;
+	pdf_obj *k;
+	pdf_obj *v;
 };
 
-struct fz_obj_s
+struct pdf_obj_s
 {
 	int refs;
-	fz_objkind kind;
+	pdf_objkind kind;
 	fz_context *ctx;
 	union
 	{
@@ -37,7 +38,7 @@ struct fz_obj_s
 		struct {
 			int len;
 			int cap;
-			fz_obj **items;
+			pdf_obj **items;
 		} a;
 		struct {
 			char sorted;
@@ -54,259 +55,259 @@ struct fz_obj_s
 	} u;
 };
 
-fz_obj *
-fz_new_null(fz_context *ctx)
+pdf_obj *
+pdf_new_null(fz_context *ctx)
 {
-	fz_obj *obj;
-	obj = Memento_label(fz_malloc(ctx, sizeof(fz_obj)), "fz_obj(null)");
+	pdf_obj *obj;
+	obj = Memento_label(fz_malloc(ctx, sizeof(pdf_obj)), "pdf_obj(null)");
 	obj->ctx = ctx;
 	obj->refs = 1;
-	obj->kind = FZ_NULL;
+	obj->kind = PDF_NULL;
 	return obj;
 }
 
-fz_obj *
-fz_new_bool(fz_context *ctx, int b)
+pdf_obj *
+pdf_new_bool(fz_context *ctx, int b)
 {
-	fz_obj *obj;
-	obj = Memento_label(fz_malloc(ctx, sizeof(fz_obj)), "fz_obj(bool)");
+	pdf_obj *obj;
+	obj = Memento_label(fz_malloc(ctx, sizeof(pdf_obj)), "pdf_obj(bool)");
 	obj->ctx = ctx;
 	obj->refs = 1;
-	obj->kind = FZ_BOOL;
+	obj->kind = PDF_BOOL;
 	obj->u.b = b;
 	return obj;
 }
 
-fz_obj *
-fz_new_int(fz_context *ctx, int i)
+pdf_obj *
+pdf_new_int(fz_context *ctx, int i)
 {
-	fz_obj *obj;
-	obj = Memento_label(fz_malloc(ctx, sizeof(fz_obj)), "fz_obj(int)");
+	pdf_obj *obj;
+	obj = Memento_label(fz_malloc(ctx, sizeof(pdf_obj)), "pdf_obj(int)");
 	obj->ctx = ctx;
 	obj->refs = 1;
-	obj->kind = FZ_INT;
+	obj->kind = PDF_INT;
 	obj->u.i = i;
 	return obj;
 }
 
-fz_obj *
-fz_new_real(fz_context *ctx, float f)
+pdf_obj *
+pdf_new_real(fz_context *ctx, float f)
 {
-	fz_obj *obj;
-	obj = Memento_label(fz_malloc(ctx, sizeof(fz_obj)), "fz_obj(real)");
+	pdf_obj *obj;
+	obj = Memento_label(fz_malloc(ctx, sizeof(pdf_obj)), "pdf_obj(real)");
 	obj->ctx = ctx;
 	obj->refs = 1;
-	obj->kind = FZ_REAL;
+	obj->kind = PDF_REAL;
 	obj->u.f = f;
 	return obj;
 }
 
-fz_obj *
-fz_new_string(fz_context *ctx, char *str, int len)
+pdf_obj *
+pdf_new_string(fz_context *ctx, char *str, int len)
 {
-	fz_obj *obj;
-	obj = Memento_label(fz_malloc(ctx, offsetof(fz_obj, u.s.buf) + len + 1), "fz_obj(string)");
+	pdf_obj *obj;
+	obj = Memento_label(fz_malloc(ctx, offsetof(pdf_obj, u.s.buf) + len + 1), "pdf_obj(string)");
 	obj->ctx = ctx;
 	obj->refs = 1;
-	obj->kind = FZ_STRING;
+	obj->kind = PDF_STRING;
 	obj->u.s.len = len;
 	memcpy(obj->u.s.buf, str, len);
 	obj->u.s.buf[len] = '\0';
 	return obj;
 }
 
-fz_obj *
+pdf_obj *
 fz_new_name(fz_context *ctx, char *str)
 {
-	fz_obj *obj;
-	obj = Memento_label(fz_malloc(ctx, offsetof(fz_obj, u.n) + strlen(str) + 1), "fz_obj(name)");
+	pdf_obj *obj;
+	obj = Memento_label(fz_malloc(ctx, offsetof(pdf_obj, u.n) + strlen(str) + 1), "pdf_obj(name)");
 	obj->ctx = ctx;
 	obj->refs = 1;
-	obj->kind = FZ_NAME;
+	obj->kind = PDF_NAME;
 	strcpy(obj->u.n, str);
 	return obj;
 }
 
-fz_obj *
-fz_new_indirect(fz_context *ctx, int num, int gen, void *xref)
+pdf_obj *
+pdf_new_indirect(fz_context *ctx, int num, int gen, void *xref)
 {
-	fz_obj *obj;
-	obj = Memento_label(fz_malloc(ctx, sizeof(fz_obj)), "fz_obj(indirect)");
+	pdf_obj *obj;
+	obj = Memento_label(fz_malloc(ctx, sizeof(pdf_obj)), "pdf_obj(indirect)");
 	obj->ctx = ctx;
 	obj->refs = 1;
-	obj->kind = FZ_INDIRECT;
+	obj->kind = PDF_INDIRECT;
 	obj->u.r.num = num;
 	obj->u.r.gen = gen;
 	obj->u.r.xref = xref;
 	return obj;
 }
 
-fz_obj *
-fz_keep_obj(fz_obj *obj)
+pdf_obj *
+pdf_keep_obj(pdf_obj *obj)
 {
 	assert(obj);
 	obj->refs ++;
 	return obj;
 }
 
-int fz_is_indirect(fz_obj *obj)
+int pdf_is_indirect(pdf_obj *obj)
 {
-	return obj ? obj->kind == FZ_INDIRECT : 0;
+	return obj ? obj->kind == PDF_INDIRECT : 0;
 }
 
 #define RESOLVE(obj) \
 	do { \
-		if (obj && obj->kind == FZ_INDIRECT) \
+		if (obj && obj->kind == PDF_INDIRECT) \
 		{\
 			fz_assert_lock_not_held(obj->ctx, FZ_LOCK_FILE); \
-			obj = fz_resolve_indirect(obj); \
+			obj = pdf_resolve_indirect(obj); \
 		} \
 	} while (0)
 
-int fz_is_null(fz_obj *obj)
+int pdf_is_null(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	return obj ? obj->kind == FZ_NULL : 0;
+	return obj ? obj->kind == PDF_NULL : 0;
 }
 
-int fz_is_bool(fz_obj *obj)
+int pdf_is_bool(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	return obj ? obj->kind == FZ_BOOL : 0;
+	return obj ? obj->kind == PDF_BOOL : 0;
 }
 
-int fz_is_int(fz_obj *obj)
+int pdf_is_int(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	return obj ? obj->kind == FZ_INT : 0;
+	return obj ? obj->kind == PDF_INT : 0;
 }
 
-int fz_is_real(fz_obj *obj)
+int pdf_is_real(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	return obj ? obj->kind == FZ_REAL : 0;
+	return obj ? obj->kind == PDF_REAL : 0;
 }
 
-int fz_is_string(fz_obj *obj)
+int pdf_is_string(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	return obj ? obj->kind == FZ_STRING : 0;
+	return obj ? obj->kind == PDF_STRING : 0;
 }
 
-int fz_is_name(fz_obj *obj)
+int pdf_is_name(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	return obj ? obj->kind == FZ_NAME : 0;
+	return obj ? obj->kind == PDF_NAME : 0;
 }
 
-int fz_is_array(fz_obj *obj)
+int pdf_is_array(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	return obj ? obj->kind == FZ_ARRAY : 0;
+	return obj ? obj->kind == PDF_ARRAY : 0;
 }
 
-int fz_is_dict(fz_obj *obj)
+int pdf_is_dict(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	return obj ? obj->kind == FZ_DICT : 0;
+	return obj ? obj->kind == PDF_DICT : 0;
 }
 
-int fz_to_bool(fz_obj *obj)
+int pdf_to_bool(pdf_obj *obj)
 {
 	RESOLVE(obj);
 	if (!obj)
 		return 0;
-	return obj->kind == FZ_BOOL ? obj->u.b : 0;
+	return obj->kind == PDF_BOOL ? obj->u.b : 0;
 }
 
-int fz_to_int(fz_obj *obj)
+int pdf_to_int(pdf_obj *obj)
 {
 	RESOLVE(obj);
 	if (!obj)
 		return 0;
-	if (obj->kind == FZ_INT)
+	if (obj->kind == PDF_INT)
 		return obj->u.i;
-	if (obj->kind == FZ_REAL)
+	if (obj->kind == PDF_REAL)
 		return (int)(obj->u.f + 0.5f); /* No roundf in MSVC */
 	return 0;
 }
 
-float fz_to_real(fz_obj *obj)
+float pdf_to_real(pdf_obj *obj)
 {
 	RESOLVE(obj);
 	if (!obj)
 		return 0;
-	if (obj->kind == FZ_REAL)
+	if (obj->kind == PDF_REAL)
 		return obj->u.f;
-	if (obj->kind == FZ_INT)
+	if (obj->kind == PDF_INT)
 		return obj->u.i;
 	return 0;
 }
 
-char *fz_to_name(fz_obj *obj)
+char *pdf_to_name(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_NAME)
+	if (!obj || obj->kind != PDF_NAME)
 		return "";
 	return obj->u.n;
 }
 
-char *fz_to_str_buf(fz_obj *obj)
+char *pdf_to_str_buf(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_STRING)
+	if (!obj || obj->kind != PDF_STRING)
 		return "";
 	return obj->u.s.buf;
 }
 
-int fz_to_str_len(fz_obj *obj)
+int pdf_to_str_len(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_STRING)
+	if (!obj || obj->kind != PDF_STRING)
 		return 0;
 	return obj->u.s.len;
 }
 
 /* for use by pdf_crypt_obj_imp to decrypt AES string in place */
-void fz_set_str_len(fz_obj *obj, int newlen)
+void pdf_set_str_len(pdf_obj *obj, int newlen)
 {
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_STRING)
+	if (!obj || obj->kind != PDF_STRING)
 		return; /* This should never happen */
 	if (newlen > obj->u.s.len)
 		return; /* This should never happen */
 	obj->u.s.len = newlen;
 }
 
-fz_obj *fz_to_dict(fz_obj *obj)
+pdf_obj *pdf_to_dict(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	return (obj && obj->kind == FZ_DICT ? obj : NULL);
+	return (obj && obj->kind == PDF_DICT ? obj : NULL);
 }
 
-int fz_to_num(fz_obj *obj)
+int pdf_to_num(pdf_obj *obj)
 {
-	if (!obj || obj->kind != FZ_INDIRECT)
+	if (!obj || obj->kind != PDF_INDIRECT)
 		return 0;
 	return obj->u.r.num;
 }
 
-int fz_to_gen(fz_obj *obj)
+int pdf_to_gen(pdf_obj *obj)
 {
-	if (!obj || obj->kind != FZ_INDIRECT)
+	if (!obj || obj->kind != PDF_INDIRECT)
 		return 0;
 	return obj->u.r.gen;
 }
 
-void *fz_get_indirect_document(fz_obj *obj)
+void *pdf_get_indirect_document(pdf_obj *obj)
 {
-	if (!obj || obj->kind != FZ_INDIRECT)
+	if (!obj || obj->kind != PDF_INDIRECT)
 		return NULL;
 	return obj->u.r.xref;
 }
 
 int
-fz_objcmp(fz_obj *a, fz_obj *b)
+pdf_objcmp(pdf_obj *a, pdf_obj *b)
 {
 	int i;
 
@@ -321,23 +322,23 @@ fz_objcmp(fz_obj *a, fz_obj *b)
 
 	switch (a->kind)
 	{
-	case FZ_NULL:
+	case PDF_NULL:
 		return 0;
 
-	case FZ_BOOL:
+	case PDF_BOOL:
 		return a->u.b - b->u.b;
 
-	case FZ_INT:
+	case PDF_INT:
 		return a->u.i - b->u.i;
 
-	case FZ_REAL:
+	case PDF_REAL:
 		if (a->u.f < b->u.f)
 			return -1;
 		if (a->u.f > b->u.f)
 			return 1;
 		return 0;
 
-	case FZ_STRING:
+	case PDF_STRING:
 		if (a->u.s.len < b->u.s.len)
 		{
 			if (memcmp(a->u.s.buf, b->u.s.buf, a->u.s.len) <= 0)
@@ -352,30 +353,30 @@ fz_objcmp(fz_obj *a, fz_obj *b)
 		}
 		return memcmp(a->u.s.buf, b->u.s.buf, a->u.s.len);
 
-	case FZ_NAME:
+	case PDF_NAME:
 		return strcmp(a->u.n, b->u.n);
 
-	case FZ_INDIRECT:
+	case PDF_INDIRECT:
 		if (a->u.r.num == b->u.r.num)
 			return a->u.r.gen - b->u.r.gen;
 		return a->u.r.num - b->u.r.num;
 
-	case FZ_ARRAY:
+	case PDF_ARRAY:
 		if (a->u.a.len != b->u.a.len)
 			return a->u.a.len - b->u.a.len;
 		for (i = 0; i < a->u.a.len; i++)
-			if (fz_objcmp(a->u.a.items[i], b->u.a.items[i]))
+			if (pdf_objcmp(a->u.a.items[i], b->u.a.items[i]))
 				return 1;
 		return 0;
 
-	case FZ_DICT:
+	case PDF_DICT:
 		if (a->u.d.len != b->u.d.len)
 			return a->u.d.len - b->u.d.len;
 		for (i = 0; i < a->u.d.len; i++)
 		{
-			if (fz_objcmp(a->u.d.items[i].k, b->u.d.items[i].k))
+			if (pdf_objcmp(a->u.d.items[i].k, b->u.d.items[i].k))
 				return 1;
-			if (fz_objcmp(a->u.d.items[i].v, b->u.d.items[i].v))
+			if (pdf_objcmp(a->u.d.items[i].v, b->u.d.items[i].v))
 				return 1;
 		}
 		return 0;
@@ -385,42 +386,42 @@ fz_objcmp(fz_obj *a, fz_obj *b)
 }
 
 static char *
-fz_objkindstr(fz_obj *obj)
+pdf_objkindstr(pdf_obj *obj)
 {
 	if (!obj)
 		return "<NULL>";
 	switch (obj->kind)
 	{
-	case FZ_NULL: return "null";
-	case FZ_BOOL: return "boolean";
-	case FZ_INT: return "integer";
-	case FZ_REAL: return "real";
-	case FZ_STRING: return "string";
-	case FZ_NAME: return "name";
-	case FZ_ARRAY: return "array";
-	case FZ_DICT: return "dictionary";
-	case FZ_INDIRECT: return "reference";
+	case PDF_NULL: return "null";
+	case PDF_BOOL: return "boolean";
+	case PDF_INT: return "integer";
+	case PDF_REAL: return "real";
+	case PDF_STRING: return "string";
+	case PDF_NAME: return "name";
+	case PDF_ARRAY: return "array";
+	case PDF_DICT: return "dictionary";
+	case PDF_INDIRECT: return "reference";
 	}
 	return "<unknown>";
 }
 
-fz_obj *
-fz_new_array(fz_context *ctx, int initialcap)
+pdf_obj *
+pdf_new_array(fz_context *ctx, int initialcap)
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 	int i;
 
-	obj = Memento_label(fz_malloc(ctx, sizeof(fz_obj)), "fz_obj(array)");
+	obj = Memento_label(fz_malloc(ctx, sizeof(pdf_obj)), "pdf_obj(array)");
 	obj->ctx = ctx;
 	obj->refs = 1;
-	obj->kind = FZ_ARRAY;
+	obj->kind = PDF_ARRAY;
 
 	obj->u.a.len = 0;
 	obj->u.a.cap = initialcap > 1 ? initialcap : 6;
 
 	fz_try(ctx)
 	{
-		obj->u.a.items = Memento_label(fz_malloc_array(ctx, obj->u.a.cap, sizeof(fz_obj*)), "fz_obj(array items)");
+		obj->u.a.items = Memento_label(fz_malloc_array(ctx, obj->u.a.cap, sizeof(pdf_obj*)), "pdf_obj(array items)");
 	}
 	fz_catch(ctx)
 	{
@@ -434,51 +435,51 @@ fz_new_array(fz_context *ctx, int initialcap)
 }
 
 static void
-fz_array_grow(fz_obj *obj)
+pdf_array_grow(pdf_obj *obj)
 {
 	int i;
 
 	obj->u.a.cap = (obj->u.a.cap * 3) / 2;
-	obj->u.a.items = fz_resize_array(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(pdf_obj*));
 
 	for (i = obj->u.a.len ; i < obj->u.a.cap; i++)
 		obj->u.a.items[i] = NULL;
 }
 
-fz_obj *
-fz_copy_array(fz_context *ctx, fz_obj *obj)
+pdf_obj *
+pdf_copy_array(fz_context *ctx, pdf_obj *obj)
 {
-	fz_obj *arr;
+	pdf_obj *arr;
 	int i;
 	int n;
 
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_ARRAY)
-		fz_warn(ctx, "assert: not an array (%s)", fz_objkindstr(obj));
+	if (!obj || obj->kind != PDF_ARRAY)
+		fz_warn(ctx, "assert: not an array (%s)", pdf_objkindstr(obj));
 
-	arr = fz_new_array(ctx, fz_array_len(obj));
-	n = fz_array_len(obj);
+	arr = pdf_new_array(ctx, pdf_array_len(obj));
+	n = pdf_array_len(obj);
 	for (i = 0; i < n; i++)
-		fz_array_push(arr, fz_array_get(obj, i));
+		pdf_array_push(arr, pdf_array_get(obj, i));
 
 	return arr;
 }
 
 int
-fz_array_len(fz_obj *obj)
+pdf_array_len(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_ARRAY)
+	if (!obj || obj->kind != PDF_ARRAY)
 		return 0;
 	return obj->u.a.len;
 }
 
-fz_obj *
-fz_array_get(fz_obj *obj, int i)
+pdf_obj *
+pdf_array_get(pdf_obj *obj, int i)
 {
 	RESOLVE(obj);
 
-	if (!obj || obj->kind != FZ_ARRAY)
+	if (!obj || obj->kind != PDF_ARRAY)
 		return NULL;
 
 	if (i < 0 || i >= obj->u.a.len)
@@ -488,14 +489,14 @@ fz_array_get(fz_obj *obj, int i)
 }
 
 void
-fz_array_put(fz_obj *obj, int i, fz_obj *item)
+pdf_array_put(pdf_obj *obj, int i, pdf_obj *item)
 {
 	RESOLVE(obj);
 
 	if (!obj)
 		return; /* Can't warn :( */
-	if (obj->kind != FZ_ARRAY)
-		fz_warn(obj->ctx, "assert: not an array (%s)", fz_objkindstr(obj));
+	if (obj->kind != PDF_ARRAY)
+		fz_warn(obj->ctx, "assert: not an array (%s)", pdf_objkindstr(obj));
 	else if (i < 0)
 		fz_warn(obj->ctx, "assert: index %d < 0", i);
 	else if (i >= obj->u.a.len)
@@ -503,55 +504,55 @@ fz_array_put(fz_obj *obj, int i, fz_obj *item)
 	else
 	{
 		if (obj->u.a.items[i])
-			fz_drop_obj(obj->u.a.items[i]);
-		obj->u.a.items[i] = fz_keep_obj(item);
+			pdf_drop_obj(obj->u.a.items[i]);
+		obj->u.a.items[i] = pdf_keep_obj(item);
 	}
 }
 
 void
-fz_array_push(fz_obj *obj, fz_obj *item)
+pdf_array_push(pdf_obj *obj, pdf_obj *item)
 {
 	RESOLVE(obj);
 
 	if (!obj)
 		return; /* Can't warn :( */
-	if (obj->kind != FZ_ARRAY)
-		fz_warn(obj->ctx, "assert: not an array (%s)", fz_objkindstr(obj));
+	if (obj->kind != PDF_ARRAY)
+		fz_warn(obj->ctx, "assert: not an array (%s)", pdf_objkindstr(obj));
 	else
 	{
 		if (obj->u.a.len + 1 > obj->u.a.cap)
-			fz_array_grow(obj);
-		obj->u.a.items[obj->u.a.len] = fz_keep_obj(item);
+			pdf_array_grow(obj);
+		obj->u.a.items[obj->u.a.len] = pdf_keep_obj(item);
 		obj->u.a.len++;
 	}
 }
 
 void
-fz_array_insert(fz_obj *obj, fz_obj *item)
+pdf_array_insert(pdf_obj *obj, pdf_obj *item)
 {
 	RESOLVE(obj);
 
 	if (!obj)
 		return; /* Can't warn :( */
-	if (obj->kind != FZ_ARRAY)
-		fz_warn(obj->ctx, "assert: not an array (%s)", fz_objkindstr(obj));
+	if (obj->kind != PDF_ARRAY)
+		fz_warn(obj->ctx, "assert: not an array (%s)", pdf_objkindstr(obj));
 	else
 	{
 		if (obj->u.a.len + 1 > obj->u.a.cap)
-			fz_array_grow(obj);
-		memmove(obj->u.a.items + 1, obj->u.a.items, obj->u.a.len * sizeof(fz_obj*));
-		obj->u.a.items[0] = fz_keep_obj(item);
+			pdf_array_grow(obj);
+		memmove(obj->u.a.items + 1, obj->u.a.items, obj->u.a.len * sizeof(pdf_obj*));
+		obj->u.a.items[0] = pdf_keep_obj(item);
 		obj->u.a.len++;
 	}
 }
 
 int
-fz_array_contains(fz_obj *arr, fz_obj *obj)
+pdf_array_contains(pdf_obj *arr, pdf_obj *obj)
 {
 	int i;
 
-	for (i = 0; i < fz_array_len(arr); i++)
-		if (!fz_objcmp(fz_array_get(arr, i), obj))
+	for (i = 0; i < pdf_array_len(arr); i++)
+		if (!pdf_objcmp(pdf_array_get(arr, i), obj))
 			return 1;
 
 	return 0;
@@ -563,19 +564,19 @@ static int keyvalcmp(const void *ap, const void *bp)
 {
 	const struct keyval *a = ap;
 	const struct keyval *b = bp;
-	return strcmp(fz_to_name(a->k), fz_to_name(b->k));
+	return strcmp(pdf_to_name(a->k), pdf_to_name(b->k));
 }
 
-fz_obj *
-fz_new_dict(fz_context *ctx, int initialcap)
+pdf_obj *
+pdf_new_dict(fz_context *ctx, int initialcap)
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 	int i;
 
-	obj = Memento_label(fz_malloc(ctx, sizeof(fz_obj)), "fz_obj(dict)");
+	obj = Memento_label(fz_malloc(ctx, sizeof(pdf_obj)), "pdf_obj(dict)");
 	obj->ctx = ctx;
 	obj->refs = 1;
-	obj->kind = FZ_DICT;
+	obj->kind = PDF_DICT;
 
 	obj->u.d.sorted = 0;
 	obj->u.d.marked = 0;
@@ -584,7 +585,7 @@ fz_new_dict(fz_context *ctx, int initialcap)
 
 	fz_try(ctx)
 	{
-		obj->u.d.items = Memento_label(fz_malloc_array(ctx, obj->u.d.cap, sizeof(struct keyval)), "fz_obj(dict items)");
+		obj->u.d.items = Memento_label(fz_malloc_array(ctx, obj->u.d.cap, sizeof(struct keyval)), "pdf_obj(dict items)");
 	}
 	fz_catch(ctx)
 	{
@@ -601,7 +602,7 @@ fz_new_dict(fz_context *ctx, int initialcap)
 }
 
 static void
-fz_dict_grow(fz_obj *obj)
+pdf_dict_grow(pdf_obj *obj)
 {
 	int i;
 
@@ -615,38 +616,38 @@ fz_dict_grow(fz_obj *obj)
 	}
 }
 
-fz_obj *
-fz_copy_dict(fz_context *ctx, fz_obj *obj)
+pdf_obj *
+pdf_copy_dict(fz_context *ctx, pdf_obj *obj)
 {
-	fz_obj *dict;
+	pdf_obj *dict;
 	int i, n;
 
 	RESOLVE(obj);
-	if (obj && obj->kind != FZ_DICT)
-		fz_warn(ctx, "assert: not a dict (%s)", fz_objkindstr(obj));
+	if (obj && obj->kind != PDF_DICT)
+		fz_warn(ctx, "assert: not a dict (%s)", pdf_objkindstr(obj));
 
-	n = fz_dict_len(obj);
-	dict = fz_new_dict(ctx, n);
+	n = pdf_dict_len(obj);
+	dict = pdf_new_dict(ctx, n);
 	for (i = 0; i < n; i++)
-		fz_dict_put(dict, fz_dict_get_key(obj, i), fz_dict_get_val(obj, i));
+		fz_dict_put(dict, pdf_dict_get_key(obj, i), pdf_dict_get_val(obj, i));
 
 	return dict;
 }
 
 int
-fz_dict_len(fz_obj *obj)
+pdf_dict_len(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_DICT)
+	if (!obj || obj->kind != PDF_DICT)
 		return 0;
 	return obj->u.d.len;
 }
 
-fz_obj *
-fz_dict_get_key(fz_obj *obj, int i)
+pdf_obj *
+pdf_dict_get_key(pdf_obj *obj, int i)
 {
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_DICT)
+	if (!obj || obj->kind != PDF_DICT)
 		return NULL;
 
 	if (i < 0 || i >= obj->u.d.len)
@@ -655,11 +656,11 @@ fz_dict_get_key(fz_obj *obj, int i)
 	return obj->u.d.items[i].k;
 }
 
-fz_obj *
-fz_dict_get_val(fz_obj *obj, int i)
+pdf_obj *
+pdf_dict_get_val(pdf_obj *obj, int i)
 {
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_DICT)
+	if (!obj || obj->kind != PDF_DICT)
 		return NULL;
 
 	if (i < 0 || i >= obj->u.d.len)
@@ -669,14 +670,14 @@ fz_dict_get_val(fz_obj *obj, int i)
 }
 
 static int
-fz_dict_finds(fz_obj *obj, char *key, int *location)
+pdf_dict_finds(pdf_obj *obj, char *key, int *location)
 {
 	if (obj->u.d.sorted && obj->u.d.len > 0)
 	{
 		int l = 0;
 		int r = obj->u.d.len - 1;
 
-		if (strcmp(fz_to_name(obj->u.d.items[r].k), key) < 0)
+		if (strcmp(pdf_to_name(obj->u.d.items[r].k), key) < 0)
 		{
 			if (location)
 				*location = r + 1;
@@ -686,7 +687,7 @@ fz_dict_finds(fz_obj *obj, char *key, int *location)
 		while (l <= r)
 		{
 			int m = (l + r) >> 1;
-			int c = -strcmp(fz_to_name(obj->u.d.items[m].k), key);
+			int c = -strcmp(pdf_to_name(obj->u.d.items[m].k), key);
 			if (c < 0)
 				r = m - 1;
 			else if (c > 0)
@@ -703,7 +704,7 @@ fz_dict_finds(fz_obj *obj, char *key, int *location)
 	{
 		int i;
 		for (i = 0; i < obj->u.d.len; i++)
-			if (strcmp(fz_to_name(obj->u.d.items[i].k), key) == 0)
+			if (strcmp(pdf_to_name(obj->u.d.items[i].k), key) == 0)
 				return i;
 
 		if (location)
@@ -713,62 +714,62 @@ fz_dict_finds(fz_obj *obj, char *key, int *location)
 	return -1;
 }
 
-fz_obj *
-fz_dict_gets(fz_obj *obj, char *key)
+pdf_obj *
+pdf_dict_gets(pdf_obj *obj, char *key)
 {
 	int i;
 
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_DICT)
+	if (!obj || obj->kind != PDF_DICT)
 		return NULL;
 
-	i = fz_dict_finds(obj, key, NULL);
+	i = pdf_dict_finds(obj, key, NULL);
 	if (i >= 0)
 		return obj->u.d.items[i].v;
 
 	return NULL;
 }
 
-fz_obj *
-fz_dict_get(fz_obj *obj, fz_obj *key)
+pdf_obj *
+pdf_dict_get(pdf_obj *obj, pdf_obj *key)
 {
-	if (!key || key->kind != FZ_NAME)
+	if (!key || key->kind != PDF_NAME)
 		return NULL;
-	return fz_dict_gets(obj, fz_to_name(key));
+	return pdf_dict_gets(obj, pdf_to_name(key));
 }
 
-fz_obj *
-fz_dict_getsa(fz_obj *obj, char *key, char *abbrev)
+pdf_obj *
+pdf_dict_getsa(pdf_obj *obj, char *key, char *abbrev)
 {
-	fz_obj *v;
-	v = fz_dict_gets(obj, key);
+	pdf_obj *v;
+	v = pdf_dict_gets(obj, key);
 	if (v)
 		return v;
-	return fz_dict_gets(obj, abbrev);
+	return pdf_dict_gets(obj, abbrev);
 }
 
 void
-fz_dict_put(fz_obj *obj, fz_obj *key, fz_obj *val)
+fz_dict_put(pdf_obj *obj, pdf_obj *key, pdf_obj *val)
 {
 	int location;
 	char *s;
 	int i;
 
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_DICT)
+	if (!obj || obj->kind != PDF_DICT)
 	{
-		fz_warn(obj->ctx, "assert: not a dict (%s)", fz_objkindstr(obj));
+		fz_warn(obj->ctx, "assert: not a dict (%s)", pdf_objkindstr(obj));
 		return;
 	}
 
 	RESOLVE(key);
-	if (!key || key->kind != FZ_NAME)
+	if (!key || key->kind != PDF_NAME)
 	{
-		fz_warn(obj->ctx, "assert: key is not a name (%s)", fz_objkindstr(obj));
+		fz_warn(obj->ctx, "assert: key is not a name (%s)", pdf_objkindstr(obj));
 		return;
 	}
 	else
-		s = fz_to_name(key);
+		s = pdf_to_name(key);
 
 	if (!val)
 	{
@@ -777,18 +778,18 @@ fz_dict_put(fz_obj *obj, fz_obj *key, fz_obj *val)
 	}
 
 	if (obj->u.d.len > 100 && !obj->u.d.sorted)
-		fz_sort_dict(obj);
+		pdf_sort_dict(obj);
 
-	i = fz_dict_finds(obj, s, &location);
+	i = pdf_dict_finds(obj, s, &location);
 	if (i >= 0 && i < obj->u.d.len)
 	{
-		fz_drop_obj(obj->u.d.items[i].v);
-		obj->u.d.items[i].v = fz_keep_obj(val);
+		pdf_drop_obj(obj->u.d.items[i].v);
+		obj->u.d.items[i].v = pdf_keep_obj(val);
 	}
 	else
 	{
 		if (obj->u.d.len + 1 > obj->u.d.cap)
-			fz_dict_grow(obj);
+			pdf_dict_grow(obj);
 
 		i = location;
 		if (obj->u.d.sorted && obj->u.d.len > 0)
@@ -796,34 +797,34 @@ fz_dict_put(fz_obj *obj, fz_obj *key, fz_obj *val)
 				&obj->u.d.items[i],
 				(obj->u.d.len - i) * sizeof(struct keyval));
 
-		obj->u.d.items[i].k = fz_keep_obj(key);
-		obj->u.d.items[i].v = fz_keep_obj(val);
+		obj->u.d.items[i].k = pdf_keep_obj(key);
+		obj->u.d.items[i].v = pdf_keep_obj(val);
 		obj->u.d.len ++;
 	}
 }
 
 void
-fz_dict_puts(fz_obj *obj, char *key, fz_obj *val)
+pdf_dict_puts(pdf_obj *obj, char *key, pdf_obj *val)
 {
-	fz_obj *keyobj = fz_new_name(obj->ctx, key);
+	pdf_obj *keyobj = fz_new_name(obj->ctx, key);
 	fz_dict_put(obj, keyobj, val);
-	fz_drop_obj(keyobj);
+	pdf_drop_obj(keyobj);
 }
 
 void
-fz_dict_dels(fz_obj *obj, char *key)
+pdf_dict_dels(pdf_obj *obj, char *key)
 {
 	RESOLVE(obj);
 
-	if (!obj || obj->kind != FZ_DICT)
-		fz_warn(obj->ctx, "assert: not a dict (%s)", fz_objkindstr(obj));
+	if (!obj || obj->kind != PDF_DICT)
+		fz_warn(obj->ctx, "assert: not a dict (%s)", pdf_objkindstr(obj));
 	else
 	{
-		int i = fz_dict_finds(obj, key, NULL);
+		int i = pdf_dict_finds(obj, key, NULL);
 		if (i >= 0)
 		{
-			fz_drop_obj(obj->u.d.items[i].k);
-			fz_drop_obj(obj->u.d.items[i].v);
+			pdf_drop_obj(obj->u.d.items[i].k);
+			pdf_drop_obj(obj->u.d.items[i].v);
 			obj->u.d.sorted = 0;
 			obj->u.d.items[i] = obj->u.d.items[obj->u.d.len-1];
 			obj->u.d.len --;
@@ -832,20 +833,20 @@ fz_dict_dels(fz_obj *obj, char *key)
 }
 
 void
-fz_dict_del(fz_obj *obj, fz_obj *key)
+pdf_dict_del(pdf_obj *obj, pdf_obj *key)
 {
 	RESOLVE(key);
-	if (!key || key->kind != FZ_NAME)
-		fz_warn(obj->ctx, "assert: key is not a name (%s)", fz_objkindstr(obj));
+	if (!key || key->kind != PDF_NAME)
+		fz_warn(obj->ctx, "assert: key is not a name (%s)", pdf_objkindstr(obj));
 	else
-		fz_dict_dels(obj, key->u.n);
+		pdf_dict_dels(obj, key->u.n);
 }
 
 void
-fz_sort_dict(fz_obj *obj)
+pdf_sort_dict(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_DICT)
+	if (!obj || obj->kind != PDF_DICT)
 		return;
 	if (!obj->u.d.sorted)
 	{
@@ -855,20 +856,20 @@ fz_sort_dict(fz_obj *obj)
 }
 
 int
-fz_dict_marked(fz_obj *obj)
+pdf_dict_marked(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_DICT)
+	if (!obj || obj->kind != PDF_DICT)
 		return 0;
 	return obj->u.d.marked;
 }
 
 int
-fz_dict_mark(fz_obj *obj)
+pdf_dict_mark(pdf_obj *obj)
 {
 	int marked;
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_DICT)
+	if (!obj || obj->kind != PDF_DICT)
 		return 0;
 	marked = obj->u.d.marked;
 	obj->u.d.marked = 1;
@@ -876,37 +877,37 @@ fz_dict_mark(fz_obj *obj)
 }
 
 void
-fz_dict_unmark(fz_obj *obj)
+pdf_dict_unmark(pdf_obj *obj)
 {
 	RESOLVE(obj);
-	if (!obj || obj->kind != FZ_DICT)
+	if (!obj || obj->kind != PDF_DICT)
 		return;
 	obj->u.d.marked = 0;
 }
 
 static void
-fz_free_array(fz_obj *obj)
+pdf_free_array(pdf_obj *obj)
 {
 	int i;
 
 	for (i = 0; i < obj->u.a.len; i++)
 		if (obj->u.a.items[i])
-			fz_drop_obj(obj->u.a.items[i]);
+			pdf_drop_obj(obj->u.a.items[i]);
 
 	fz_free(obj->ctx, obj->u.a.items);
 	fz_free(obj->ctx, obj);
 }
 
 static void
-fz_free_dict(fz_obj *obj)
+pdf_free_dict(pdf_obj *obj)
 {
 	int i;
 
 	for (i = 0; i < obj->u.d.len; i++) {
 		if (obj->u.d.items[i].k)
-			fz_drop_obj(obj->u.d.items[i].k);
+			pdf_drop_obj(obj->u.d.items[i].k);
 		if (obj->u.d.items[i].v)
-			fz_drop_obj(obj->u.d.items[i].v);
+			pdf_drop_obj(obj->u.d.items[i].v);
 	}
 
 	fz_free(obj->ctx, obj->u.d.items);
@@ -914,16 +915,16 @@ fz_free_dict(fz_obj *obj)
 }
 
 void
-fz_drop_obj(fz_obj *obj)
+pdf_drop_obj(pdf_obj *obj)
 {
 	if (!obj)
 		return;
 	if (--obj->refs)
 		return;
-	if (obj->kind == FZ_ARRAY)
-		fz_free_array(obj);
-	else if (obj->kind == FZ_DICT)
-		fz_free_dict(obj);
+	if (obj->kind == PDF_ARRAY)
+		pdf_free_array(obj);
+	else if (obj->kind == PDF_DICT)
+		pdf_free_dict(obj);
 	else
 		fz_free(obj->ctx, obj);
 }
@@ -942,7 +943,7 @@ struct fmt
 	int last;
 };
 
-static void fmt_obj(struct fmt *fmt, fz_obj *obj);
+static void fmt_obj(struct fmt *fmt, pdf_obj *obj);
 
 static inline int iswhite(int ch)
 {
@@ -1006,10 +1007,10 @@ static inline void fmt_sep(struct fmt *fmt)
 	fmt->sep = 1;
 }
 
-static void fmt_str(struct fmt *fmt, fz_obj *obj)
+static void fmt_str(struct fmt *fmt, pdf_obj *obj)
 {
-	char *s = fz_to_str_buf(obj);
-	int n = fz_to_str_len(obj);
+	char *s = pdf_to_str_buf(obj);
+	int n = pdf_to_str_len(obj);
 	int i, c;
 
 	fmt_putc(fmt, '(');
@@ -1042,10 +1043,10 @@ static void fmt_str(struct fmt *fmt, fz_obj *obj)
 	fmt_putc(fmt, ')');
 }
 
-static void fmt_hex(struct fmt *fmt, fz_obj *obj)
+static void fmt_hex(struct fmt *fmt, pdf_obj *obj)
 {
-	char *s = fz_to_str_buf(obj);
-	int n = fz_to_str_len(obj);
+	char *s = pdf_to_str_buf(obj);
+	int n = pdf_to_str_len(obj);
 	int i, b, c;
 
 	fmt_putc(fmt, '<');
@@ -1059,9 +1060,9 @@ static void fmt_hex(struct fmt *fmt, fz_obj *obj)
 	fmt_putc(fmt, '>');
 }
 
-static void fmt_name(struct fmt *fmt, fz_obj *obj)
+static void fmt_name(struct fmt *fmt, pdf_obj *obj)
 {
-	unsigned char *s = (unsigned char *) fz_to_name(obj);
+	unsigned char *s = (unsigned char *) pdf_to_name(obj);
 	int i, c;
 
 	fmt_putc(fmt, '/');
@@ -1084,15 +1085,15 @@ static void fmt_name(struct fmt *fmt, fz_obj *obj)
 	}
 }
 
-static void fmt_array(struct fmt *fmt, fz_obj *obj)
+static void fmt_array(struct fmt *fmt, pdf_obj *obj)
 {
 	int i, n;
 
-	n = fz_array_len(obj);
+	n = pdf_array_len(obj);
 	if (fmt->tight) {
 		fmt_putc(fmt, '[');
 		for (i = 0; i < n; i++) {
-			fmt_obj(fmt, fz_array_get(obj, i));
+			fmt_obj(fmt, pdf_array_get(obj, i));
 			fmt_sep(fmt);
 		}
 		fmt_putc(fmt, ']');
@@ -1104,7 +1105,7 @@ static void fmt_array(struct fmt *fmt, fz_obj *obj)
 				fmt_putc(fmt, '\n');
 				fmt_indent(fmt);
 			}
-			fmt_obj(fmt, fz_array_get(obj, i));
+			fmt_obj(fmt, pdf_array_get(obj, i));
 			fmt_putc(fmt, ' ');
 		}
 		fmt_putc(fmt, ']');
@@ -1112,18 +1113,18 @@ static void fmt_array(struct fmt *fmt, fz_obj *obj)
 	}
 }
 
-static void fmt_dict(struct fmt *fmt, fz_obj *obj)
+static void fmt_dict(struct fmt *fmt, pdf_obj *obj)
 {
 	int i, n;
-	fz_obj *key, *val;
+	pdf_obj *key, *val;
 
-	n = fz_dict_len(obj);
+	n = pdf_dict_len(obj);
 	if (fmt->tight) {
 		fmt_puts(fmt, "<<");
 		for (i = 0; i < n; i++) {
-			fmt_obj(fmt, fz_dict_get_key(obj, i));
+			fmt_obj(fmt, pdf_dict_get_key(obj, i));
 			fmt_sep(fmt);
-			fmt_obj(fmt, fz_dict_get_val(obj, i));
+			fmt_obj(fmt, pdf_dict_get_val(obj, i));
 			fmt_sep(fmt);
 		}
 		fmt_puts(fmt, ">>");
@@ -1132,16 +1133,16 @@ static void fmt_dict(struct fmt *fmt, fz_obj *obj)
 		fmt_puts(fmt, "<<\n");
 		fmt->indent ++;
 		for (i = 0; i < n; i++) {
-			key = fz_dict_get_key(obj, i);
-			val = fz_dict_get_val(obj, i);
+			key = pdf_dict_get_key(obj, i);
+			val = pdf_dict_get_val(obj, i);
 			fmt_indent(fmt);
 			fmt_obj(fmt, key);
 			fmt_putc(fmt, ' ');
-			if (!fz_is_indirect(val) && fz_is_array(val))
+			if (!pdf_is_indirect(val) && pdf_is_array(val))
 				fmt->indent ++;
 			fmt_obj(fmt, val);
 			fmt_putc(fmt, '\n');
-			if (!fz_is_indirect(val) && fz_is_array(val))
+			if (!pdf_is_indirect(val) && pdf_is_array(val))
 				fmt->indent --;
 		}
 		fmt->indent --;
@@ -1150,37 +1151,37 @@ static void fmt_dict(struct fmt *fmt, fz_obj *obj)
 	}
 }
 
-static void fmt_obj(struct fmt *fmt, fz_obj *obj)
+static void fmt_obj(struct fmt *fmt, pdf_obj *obj)
 {
 	char buf[256];
 
 	if (!obj)
 		fmt_puts(fmt, "<NULL>");
-	else if (fz_is_indirect(obj))
+	else if (pdf_is_indirect(obj))
 	{
-		sprintf(buf, "%d %d R", fz_to_num(obj), fz_to_gen(obj));
+		sprintf(buf, "%d %d R", pdf_to_num(obj), pdf_to_gen(obj));
 		fmt_puts(fmt, buf);
 	}
-	else if (fz_is_null(obj))
+	else if (pdf_is_null(obj))
 		fmt_puts(fmt, "null");
-	else if (fz_is_bool(obj))
-		fmt_puts(fmt, fz_to_bool(obj) ? "true" : "false");
-	else if (fz_is_int(obj))
+	else if (pdf_is_bool(obj))
+		fmt_puts(fmt, pdf_to_bool(obj) ? "true" : "false");
+	else if (pdf_is_int(obj))
 	{
-		sprintf(buf, "%d", fz_to_int(obj));
+		sprintf(buf, "%d", pdf_to_int(obj));
 		fmt_puts(fmt, buf);
 	}
-	else if (fz_is_real(obj))
+	else if (pdf_is_real(obj))
 	{
-		sprintf(buf, "%g", fz_to_real(obj));
+		sprintf(buf, "%g", pdf_to_real(obj));
 		if (strchr(buf, 'e')) /* bad news! */
-			sprintf(buf, fabsf(fz_to_real(obj)) > 1 ? "%1.1f" : "%1.8f", fz_to_real(obj));
+			sprintf(buf, fabsf(pdf_to_real(obj)) > 1 ? "%1.1f" : "%1.8f", pdf_to_real(obj));
 		fmt_puts(fmt, buf);
 	}
-	else if (fz_is_string(obj))
+	else if (pdf_is_string(obj))
 	{
-		char *str = fz_to_str_buf(obj);
-		int len = fz_to_str_len(obj);
+		char *str = pdf_to_str_buf(obj);
+		int len = pdf_to_str_len(obj);
 		int added = 0;
 		int i, c;
 		for (i = 0; i < len; i++) {
@@ -1195,18 +1196,18 @@ static void fmt_obj(struct fmt *fmt, fz_obj *obj)
 		else
 			fmt_hex(fmt, obj);
 	}
-	else if (fz_is_name(obj))
+	else if (pdf_is_name(obj))
 		fmt_name(fmt, obj);
-	else if (fz_is_array(obj))
+	else if (pdf_is_array(obj))
 		fmt_array(fmt, obj);
-	else if (fz_is_dict(obj))
+	else if (pdf_is_dict(obj))
 		fmt_dict(fmt, obj);
 	else
 		fmt_puts(fmt, "<unknown object>");
 }
 
 static int
-fz_sprint_obj(char *s, int n, fz_obj *obj, int tight)
+pdf_sprint_obj(char *s, int n, pdf_obj *obj, int tight)
 {
 	struct fmt fmt;
 
@@ -1228,23 +1229,23 @@ fz_sprint_obj(char *s, int n, fz_obj *obj, int tight)
 }
 
 int
-fz_fprint_obj(FILE *fp, fz_obj *obj, int tight)
+pdf_fprint_obj(FILE *fp, pdf_obj *obj, int tight)
 {
 	char buf[1024];
 	char *ptr;
 	int n;
 
-	n = fz_sprint_obj(NULL, 0, obj, tight);
+	n = pdf_sprint_obj(NULL, 0, obj, tight);
 	if ((n + 1) < sizeof buf)
 	{
-		fz_sprint_obj(buf, sizeof buf, obj, tight);
+		pdf_sprint_obj(buf, sizeof buf, obj, tight);
 		fputs(buf, fp);
 		fputc('\n', fp);
 	}
 	else
 	{
 		ptr = fz_malloc(obj->ctx, n + 1);
-		fz_sprint_obj(ptr, n + 1, obj, tight);
+		pdf_sprint_obj(ptr, n + 1, obj, tight);
 		fputs(ptr, fp);
 		fputc('\n', fp);
 		fz_free(obj->ctx, ptr);
@@ -1253,13 +1254,13 @@ fz_fprint_obj(FILE *fp, fz_obj *obj, int tight)
 }
 
 void
-fz_debug_obj(fz_obj *obj)
+pdf_debug_obj(pdf_obj *obj)
 {
-	fz_fprint_obj(stdout, obj, 0);
+	pdf_fprint_obj(stdout, obj, 0);
 }
 
 void
-fz_debug_ref(fz_obj *ref)
+pdf_debug_ref(pdf_obj *ref)
 {
-	fz_debug_obj(fz_resolve_indirect(ref));
+	pdf_debug_obj(pdf_resolve_indirect(ref));
 }
diff --git a/pdf/mupdf.h b/pdf/mupdf.h
index 93682083..5d775044 100644
--- a/pdf/mupdf.h
+++ b/pdf/mupdf.h
@@ -6,6 +6,85 @@
 #endif
 
 /*
+ * Dynamic objects.
+ * The same type of objects as found in PDF and PostScript.
+ * Used by the filters and the mupdf parser.
+ */
+
+typedef struct pdf_obj_s pdf_obj;
+
+pdf_obj *pdf_new_null(fz_context *ctx);
+pdf_obj *pdf_new_bool(fz_context *ctx, int b);
+pdf_obj *pdf_new_int(fz_context *ctx, int i);
+pdf_obj *pdf_new_real(fz_context *ctx, float f);
+pdf_obj *fz_new_name(fz_context *ctx, char *str);
+pdf_obj *pdf_new_string(fz_context *ctx, char *str, int len);
+pdf_obj *pdf_new_indirect(fz_context *ctx, int num, int gen, void *doc);
+
+pdf_obj *pdf_new_array(fz_context *ctx, int initialcap);
+pdf_obj *pdf_new_dict(fz_context *ctx, int initialcap);
+pdf_obj *pdf_copy_array(fz_context *ctx, pdf_obj *array);
+pdf_obj *pdf_copy_dict(fz_context *ctx, pdf_obj *dict);
+
+pdf_obj *pdf_keep_obj(pdf_obj *obj);
+void pdf_drop_obj(pdf_obj *obj);
+
+/* type queries */
+int pdf_is_null(pdf_obj *obj);
+int pdf_is_bool(pdf_obj *obj);
+int pdf_is_int(pdf_obj *obj);
+int pdf_is_real(pdf_obj *obj);
+int pdf_is_name(pdf_obj *obj);
+int pdf_is_string(pdf_obj *obj);
+int pdf_is_array(pdf_obj *obj);
+int pdf_is_dict(pdf_obj *obj);
+int pdf_is_indirect(pdf_obj *obj);
+
+int pdf_objcmp(pdf_obj *a, pdf_obj *b);
+
+/* dict marking and unmarking functions - to avoid infinite recursions */
+int pdf_dict_marked(pdf_obj *obj);
+int pdf_dict_mark(pdf_obj *obj);
+void pdf_dict_unmark(pdf_obj *obj);
+
+/* safe, silent failure, no error reporting on type mismatches */
+int pdf_to_bool(pdf_obj *obj);
+int pdf_to_int(pdf_obj *obj);
+float pdf_to_real(pdf_obj *obj);
+char *pdf_to_name(pdf_obj *obj);
+char *pdf_to_str_buf(pdf_obj *obj);
+pdf_obj *pdf_to_dict(pdf_obj *obj);
+int pdf_to_str_len(pdf_obj *obj);
+int pdf_to_num(pdf_obj *obj);
+int pdf_to_gen(pdf_obj *obj);
+
+int pdf_array_len(pdf_obj *array);
+pdf_obj *pdf_array_get(pdf_obj *array, int i);
+void pdf_array_put(pdf_obj *array, int i, pdf_obj *obj);
+void pdf_array_push(pdf_obj *array, pdf_obj *obj);
+void pdf_array_insert(pdf_obj *array, pdf_obj *obj);
+int pdf_array_contains(pdf_obj *array, pdf_obj *obj);
+
+int pdf_dict_len(pdf_obj *dict);
+pdf_obj *pdf_dict_get_key(pdf_obj *dict, int idx);
+pdf_obj *pdf_dict_get_val(pdf_obj *dict, int idx);
+pdf_obj *pdf_dict_get(pdf_obj *dict, pdf_obj *key);
+pdf_obj *pdf_dict_gets(pdf_obj *dict, char *key);
+pdf_obj *pdf_dict_getsa(pdf_obj *dict, char *key, char *abbrev);
+void fz_dict_put(pdf_obj *dict, pdf_obj *key, pdf_obj *val);
+void pdf_dict_puts(pdf_obj *dict, char *key, pdf_obj *val);
+void pdf_dict_del(pdf_obj *dict, pdf_obj *key);
+void pdf_dict_dels(pdf_obj *dict, char *key);
+void pdf_sort_dict(pdf_obj *dict);
+
+int pdf_fprint_obj(FILE *fp, pdf_obj *obj, int tight);
+void pdf_debug_obj(pdf_obj *obj);
+void pdf_debug_ref(pdf_obj *obj);
+
+void pdf_set_str_len(pdf_obj *obj, int newlen); /* private */
+void *pdf_get_indirect_document(pdf_obj *obj); /* private */
+
+/*
  * PDF Images
  */
 
@@ -132,16 +211,16 @@ struct pdf_lexbuf_large_s
 
 int pdf_lex(fz_stream *f, pdf_lexbuf *lexbuf);
 
-fz_obj *pdf_parse_array(pdf_document *doc, fz_stream *f, pdf_lexbuf *buf);
-fz_obj *pdf_parse_dict(pdf_document *doc, fz_stream *f, pdf_lexbuf *buf);
-fz_obj *pdf_parse_stm_obj(pdf_document *doc, fz_stream *f, pdf_lexbuf *buf);
-fz_obj *pdf_parse_ind_obj(pdf_document *doc, fz_stream *f, pdf_lexbuf *buf, int *num, int *gen, int *stm_ofs);
+pdf_obj *pdf_parse_array(pdf_document *doc, fz_stream *f, pdf_lexbuf *buf);
+pdf_obj *pdf_parse_dict(pdf_document *doc, fz_stream *f, pdf_lexbuf *buf);
+pdf_obj *pdf_parse_stm_obj(pdf_document *doc, fz_stream *f, pdf_lexbuf *buf);
+pdf_obj *pdf_parse_ind_obj(pdf_document *doc, fz_stream *f, pdf_lexbuf *buf, int *num, int *gen, int *stm_ofs);
 
-fz_rect pdf_to_rect(fz_context *ctx, fz_obj *array);
-fz_matrix pdf_to_matrix(fz_context *ctx, fz_obj *array);
-char *pdf_to_utf8(fz_context *ctx, fz_obj *src);
-unsigned short *pdf_to_ucs2(fz_context *ctx, fz_obj *src);
-fz_obj *pdf_to_utf8_name(fz_context *ctx, fz_obj *src);
+fz_rect pdf_to_rect(fz_context *ctx, pdf_obj *array);
+fz_matrix pdf_to_matrix(fz_context *ctx, pdf_obj *array);
+char *pdf_to_utf8(fz_context *ctx, pdf_obj *src);
+unsigned short *pdf_to_ucs2(fz_context *ctx, pdf_obj *src);
+pdf_obj *pdf_to_utf8_name(fz_context *ctx, pdf_obj *src);
 char *pdf_from_ucs2(fz_context *ctx, unsigned short *str);
 
 /*
@@ -158,7 +237,7 @@ struct pdf_xref_entry_s
 	int ofs;	/* file offset / objstm object number */
 	int gen;	/* generation / objstm index */
 	int stm_ofs;	/* on-disk stream */
-	fz_obj *obj;	/* stored/cached object */
+	pdf_obj *obj;	/* stored/cached object */
 	int type;	/* 0=unset (f)ree i(n)use (o)bjstm */
 };
 
@@ -173,7 +252,7 @@ struct pdf_ocg_descriptor_s
 {
 	int len;
 	pdf_ocg_entry *ocgs;
-	fz_obj *intent;
+	pdf_obj *intent;
 };
 
 struct pdf_document_s
@@ -187,7 +266,7 @@ struct pdf_document_s
 	int startxref;
 	int file_size;
 	pdf_crypt *crypt;
-	fz_obj *trailer;
+	pdf_obj *trailer;
 	pdf_ocg_descriptor *ocg;
 
 	int len;
@@ -195,26 +274,26 @@ struct pdf_document_s
 
 	int page_len;
 	int page_cap;
-	fz_obj **page_objs;
-	fz_obj **page_refs;
+	pdf_obj **page_objs;
+	pdf_obj **page_refs;
 
 	pdf_lexbuf_large lexbuf;
 };
 
-fz_obj *pdf_resolve_indirect(fz_obj *ref);
+pdf_obj *pdf_resolve_indirect(pdf_obj *ref);
 void pdf_cache_object(pdf_document *doc, int num, int gen);
-fz_obj *pdf_load_object(pdf_document *doc, int num, int gen);
-void pdf_update_object(pdf_document *doc, int num, int gen, fz_obj *newobj);
+pdf_obj *pdf_load_object(pdf_document *doc, int num, int gen);
+void pdf_update_object(pdf_document *doc, int num, int gen, pdf_obj *newobj);
 
 int pdf_is_stream(pdf_document *doc, int num, int gen);
-fz_stream *pdf_open_inline_stream(pdf_document *doc, fz_obj *stmobj, int length, fz_stream *chain, pdf_image_params *params);
+fz_stream *pdf_open_inline_stream(pdf_document *doc, pdf_obj *stmobj, int length, fz_stream *chain, pdf_image_params *params);
 fz_buffer *pdf_load_raw_stream(pdf_document *doc, int num, int gen);
 fz_buffer *pdf_load_stream(pdf_document *doc, int num, int gen);
 fz_buffer *pdf_load_image_stream(pdf_document *doc, int num, int gen, pdf_image_params *params);
 fz_stream *pdf_open_raw_stream(pdf_document *doc, int num, int gen);
 fz_stream *pdf_open_image_stream(pdf_document *doc, int num, int gen, pdf_image_params *params);
 fz_stream *pdf_open_stream(pdf_document *doc, int num, int gen);
-fz_stream *pdf_open_stream_with_offset(pdf_document *doc, int num, int gen, fz_obj *dict, int stm_ofs);
+fz_stream *pdf_open_stream_with_offset(pdf_document *doc, int num, int gen, pdf_obj *dict, int stm_ofs);
 fz_stream *pdf_open_image_decomp_stream(fz_context *ctx, fz_buffer *, pdf_image_params *params, int *factor);
 
 /*
@@ -280,10 +359,10 @@ enum
 	PDF_DEFAULT_PERM_FLAGS = 0xfffc
 };
 
-pdf_crypt *pdf_new_crypt(fz_context *ctx, fz_obj *enc, fz_obj *id);
+pdf_crypt *pdf_new_crypt(fz_context *ctx, pdf_obj *enc, pdf_obj *id);
 void pdf_free_crypt(fz_context *ctx, pdf_crypt *crypt);
 
-void pdf_crypt_obj(fz_context *ctx, pdf_crypt *crypt, fz_obj *obj, int num, int gen);
+void pdf_crypt_obj(fz_context *ctx, pdf_crypt *crypt, pdf_obj *obj, int num, int gen);
 fz_stream *pdf_open_crypt(fz_stream *chain, pdf_crypt *crypt, int num, int gen);
 fz_stream *pdf_open_crypt_with_filter(fz_stream *chain, pdf_crypt *crypt, char *name, int num, int gen);
 
@@ -304,20 +383,20 @@ void pdf_debug_crypt(pdf_crypt *crypt);
 
 typedef struct pdf_function_s pdf_function;
 
-pdf_function *pdf_load_function(pdf_document *doc, fz_obj *ref);
+pdf_function *pdf_load_function(pdf_document *doc, pdf_obj *ref);
 void pdf_eval_function(fz_context *ctx, pdf_function *func, float *in, int inlen, float *out, int outlen);
 pdf_function *pdf_keep_function(fz_context *ctx, pdf_function *func);
 void pdf_drop_function(fz_context *ctx, pdf_function *func);
 unsigned int pdf_function_size(pdf_function *func);
 
-fz_colorspace *pdf_load_colorspace(pdf_document *doc, fz_obj *obj);
+fz_colorspace *pdf_load_colorspace(pdf_document *doc, pdf_obj *obj);
 fz_pixmap *pdf_expand_indexed_pixmap(fz_context *ctx, fz_pixmap *src);
 
-fz_shade *pdf_load_shading(pdf_document *doc, fz_obj *obj);
+fz_shade *pdf_load_shading(pdf_document *doc, pdf_obj *obj);
 
-fz_image *pdf_load_inline_image(pdf_document *doc, fz_obj *rdb, fz_obj *dict, fz_stream *file);
-fz_image *pdf_load_image(pdf_document *doc, fz_obj *obj);
-int pdf_is_jpx_image(fz_context *ctx, fz_obj *dict);
+fz_image *pdf_load_inline_image(pdf_document *doc, pdf_obj *rdb, pdf_obj *dict, fz_stream *file);
+fz_image *pdf_load_image(pdf_document *doc, pdf_obj *obj);
+int pdf_is_jpx_image(fz_context *ctx, pdf_obj *dict);
 
 /*
  * Pattern
@@ -333,11 +412,11 @@ struct pdf_pattern_s
 	float ystep;
 	fz_matrix matrix;
 	fz_rect bbox;
-	fz_obj *resources;
+	pdf_obj *resources;
 	fz_buffer *contents;
 };
 
-pdf_pattern *pdf_load_pattern(pdf_document *doc, fz_obj *obj);
+pdf_pattern *pdf_load_pattern(pdf_document *doc, pdf_obj *obj);
 pdf_pattern *pdf_keep_pattern(fz_context *ctx, pdf_pattern *pat);
 void pdf_drop_pattern(fz_context *ctx, pdf_pattern *pat);
 
@@ -356,12 +435,12 @@ struct pdf_xobject_s
 	int knockout;
 	int transparency;
 	fz_colorspace *colorspace;
-	fz_obj *resources;
+	pdf_obj *resources;
 	fz_buffer *contents;
-	fz_obj *me;
+	pdf_obj *me;
 };
 
-pdf_xobject *pdf_load_xobject(pdf_document *doc, fz_obj *obj);
+pdf_xobject *pdf_load_xobject(pdf_document *doc, pdf_obj *obj);
 pdf_xobject *pdf_keep_xobject(fz_context *ctx, pdf_xobject *xobj);
 void pdf_drop_xobject(fz_context *ctx, pdf_xobject *xobj);
 
@@ -434,7 +513,7 @@ pdf_cmap *pdf_new_identity_cmap(fz_context *ctx, int wmode, int bytes);
 pdf_cmap *pdf_load_cmap(fz_context *ctx, fz_stream *file);
 pdf_cmap *pdf_load_system_cmap(fz_context *ctx, char *name);
 pdf_cmap *pdf_load_builtin_cmap(fz_context *ctx, char *name);
-pdf_cmap *pdf_load_embedded_cmap(pdf_document *doc, fz_obj *ref);
+pdf_cmap *pdf_load_embedded_cmap(pdf_document *doc, pdf_obj *ref);
 
 /*
  * Font
@@ -536,7 +615,7 @@ void pdf_end_vmtx(fz_context *ctx, pdf_font_desc *font);
 pdf_hmtx pdf_get_hmtx(fz_context *ctx, pdf_font_desc *font, int cid);
 pdf_vmtx pdf_get_vmtx(fz_context *ctx, pdf_font_desc *font, int cid);
 
-void pdf_load_to_unicode(pdf_document *doc, pdf_font_desc *font, char **strings, char *collection, fz_obj *cmapstm);
+void pdf_load_to_unicode(pdf_document *doc, pdf_font_desc *font, char **strings, char *collection, pdf_obj *cmapstm);
 
 int pdf_font_cid_to_gid(fz_context *ctx, pdf_font_desc *fontdesc, int cid);
 
@@ -544,8 +623,8 @@ unsigned char *pdf_find_builtin_font(char *name, unsigned int *len);
 unsigned char *pdf_find_substitute_font(int mono, int serif, int bold, int italic, unsigned int *len);
 unsigned char *pdf_find_substitute_cjk_font(int ros, int serif, unsigned int *len);
 
-pdf_font_desc *pdf_load_type3_font(pdf_document *doc, fz_obj *rdb, fz_obj *obj);
-pdf_font_desc *pdf_load_font(pdf_document *doc, fz_obj *rdb, fz_obj *obj);
+pdf_font_desc *pdf_load_type3_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *obj);
+pdf_font_desc *pdf_load_font(pdf_document *doc, pdf_obj *rdb, pdf_obj *obj);
 
 pdf_font_desc *pdf_new_font_desc(fz_context *ctx);
 pdf_font_desc *pdf_keep_font(fz_context *ctx, pdf_font_desc *fontdesc);
@@ -561,24 +640,24 @@ typedef struct pdf_annot_s pdf_annot;
 
 struct pdf_annot_s
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 	fz_rect rect;
 	pdf_xobject *ap;
 	fz_matrix matrix;
 	pdf_annot *next;
 };
 
-fz_link_dest pdf_parse_link_dest(pdf_document *doc, fz_obj *dest);
-fz_link_dest pdf_parse_action(pdf_document *doc, fz_obj *action);
-fz_obj *pdf_lookup_dest(pdf_document *doc, fz_obj *needle);
-fz_obj *pdf_lookup_name(pdf_document *doc, char *which, fz_obj *needle);
-fz_obj *pdf_load_name_tree(pdf_document *doc, char *which);
+fz_link_dest pdf_parse_link_dest(pdf_document *doc, pdf_obj *dest);
+fz_link_dest pdf_parse_action(pdf_document *doc, pdf_obj *action);
+pdf_obj *pdf_lookup_dest(pdf_document *doc, pdf_obj *needle);
+pdf_obj *pdf_lookup_name(pdf_document *doc, char *which, pdf_obj *needle);
+pdf_obj *pdf_load_name_tree(pdf_document *doc, char *which);
 
 fz_outline *pdf_load_outline(pdf_document *doc);
 
-fz_link *pdf_load_link_annots(pdf_document *, fz_obj *annots, fz_matrix page_ctm);
+fz_link *pdf_load_link_annots(pdf_document *, pdf_obj *annots, fz_matrix page_ctm);
 
-pdf_annot *pdf_load_annots(pdf_document *, fz_obj *annots);
+pdf_annot *pdf_load_annots(pdf_document *, pdf_obj *annots);
 void pdf_free_annot(fz_context *ctx, pdf_annot *link);
 
 /*
@@ -593,13 +672,13 @@ struct pdf_page_s
 	fz_rect mediabox;
 	int rotate;
 	int transparency;
-	fz_obj *resources;
+	pdf_obj *resources;
 	fz_buffer *contents;
 	fz_link *links;
 	pdf_annot *annots;
 };
 
-int pdf_find_page_number(pdf_document *doc, fz_obj *pageobj);
+int pdf_find_page_number(pdf_document *doc, pdf_obj *pageobj);
 int pdf_count_pages(pdf_document *doc);
 
 /*
@@ -652,14 +731,14 @@ void pdf_free_page(pdf_document *doc, pdf_page *page);
 void pdf_run_page(pdf_document *doc, pdf_page *page, fz_device *dev, fz_matrix ctm, fz_cookie *cookie);
 
 void pdf_run_page_with_usage(pdf_document *doc, pdf_page *page, fz_device *dev, fz_matrix ctm, char *event, fz_cookie *cookie);
-void pdf_run_glyph(pdf_document *doc, fz_obj *resources, fz_buffer *contents, fz_device *dev, fz_matrix ctm, void *gstate);
+void pdf_run_glyph(pdf_document *doc, pdf_obj *resources, fz_buffer *contents, fz_device *dev, fz_matrix ctm, void *gstate);
 
 /*
  * PDF interface to store
  */
 
-void pdf_store_item(fz_context *ctx, fz_obj *key, void *val, unsigned int itemsize);
-void *pdf_find_item(fz_context *ctx, fz_store_free_fn *free, fz_obj *key);
-void pdf_remove_item(fz_context *ctx, fz_store_free_fn *free, fz_obj *key);
+void pdf_store_item(fz_context *ctx, pdf_obj *key, void *val, unsigned int itemsize);
+void *pdf_find_item(fz_context *ctx, fz_store_free_fn *free, pdf_obj *key);
+void pdf_remove_item(fz_context *ctx, fz_store_free_fn *free, pdf_obj *key);
 
 #endif
diff --git a/pdf/pdf_annot.c b/pdf/pdf_annot.c
index ae03f2b6..81e5d887 100644
--- a/pdf/pdf_annot.c
+++ b/pdf/pdf_annot.c
@@ -1,46 +1,46 @@
 #include "fitz.h"
 #include "mupdf.h"
 
-static fz_obj *
-resolve_dest_rec(pdf_document *xref, fz_obj *dest, int depth)
+static pdf_obj *
+resolve_dest_rec(pdf_document *xref, pdf_obj *dest, int depth)
 {
 	if (depth > 10) /* Arbitrary to avoid infinite recursion */
 		return NULL;
 
-	if (fz_is_name(dest) || fz_is_string(dest))
+	if (pdf_is_name(dest) || pdf_is_string(dest))
 	{
 		dest = pdf_lookup_dest(xref, dest);
 		return resolve_dest_rec(xref, dest, depth+1);
 	}
 
-	else if (fz_is_array(dest))
+	else if (pdf_is_array(dest))
 	{
 		return dest;
 	}
 
-	else if (fz_is_dict(dest))
+	else if (pdf_is_dict(dest))
 	{
-		dest = fz_dict_gets(dest, "D");
+		dest = pdf_dict_gets(dest, "D");
 		return resolve_dest_rec(xref, dest, depth+1);
 	}
 
-	else if (fz_is_indirect(dest))
+	else if (pdf_is_indirect(dest))
 		return dest;
 
 	return NULL;
 }
 
-static fz_obj *
-resolve_dest(pdf_document *xref, fz_obj *dest)
+static pdf_obj *
+resolve_dest(pdf_document *xref, pdf_obj *dest)
 {
 	return resolve_dest_rec(xref, dest, 0);
 }
 
 fz_link_dest
-pdf_parse_link_dest(pdf_document *xref, fz_obj *dest)
+pdf_parse_link_dest(pdf_document *xref, pdf_obj *dest)
 {
 	fz_link_dest ld;
-	fz_obj *obj;
+	pdf_obj *obj;
 
 	int l_from_2 = 0;
 	int b_from_3 = 0;
@@ -51,14 +51,14 @@ pdf_parse_link_dest(pdf_document *xref, fz_obj *dest)
 	int z_from_4 = 0;
 
 	dest = resolve_dest(xref, dest);
-	if (dest == NULL || !fz_is_array(dest))
+	if (dest == NULL || !pdf_is_array(dest))
 	{
 		ld.kind = FZ_LINK_NONE;
 		return ld;
 	}
-	obj = fz_array_get(dest, 0);
-	if (fz_is_int(obj))
-		ld.ld.gotor.page = fz_to_int(obj);
+	obj = pdf_array_get(dest, 0);
+	if (pdf_is_int(obj))
+		ld.ld.gotor.page = pdf_to_int(obj);
 	else
 		ld.ld.gotor.page = pdf_find_page_number(xref, obj);
 
@@ -71,31 +71,31 @@ pdf_parse_link_dest(pdf_document *xref, fz_obj *dest)
 	ld.ld.gotor.file_spec = NULL;
 	ld.ld.gotor.new_window = 0;
 
-	obj = fz_array_get(dest, 1);
-	if (!fz_is_name(obj))
+	obj = pdf_array_get(dest, 1);
+	if (!pdf_is_name(obj))
 		return ld;
 
-	if (!strcmp("XYZ", fz_to_name(obj)))
+	if (!strcmp("XYZ", pdf_to_name(obj)))
 	{
 		l_from_2 = t_from_3 = z_from_4 = 1;
 		ld.ld.gotor.flags |= fz_link_flag_r_is_zoom;
 	}
-	else if ((!strcmp("Fit", fz_to_name(obj))) || (!strcmp("FitB", fz_to_name(obj))))
+	else if ((!strcmp("Fit", pdf_to_name(obj))) || (!strcmp("FitB", pdf_to_name(obj))))
 	{
 		ld.ld.gotor.flags |= fz_link_flag_fit_h;
 		ld.ld.gotor.flags |= fz_link_flag_fit_v;
 	}
-	else if ((!strcmp("FitH", fz_to_name(obj))) || (!strcmp("FitBH", fz_to_name(obj))))
+	else if ((!strcmp("FitH", pdf_to_name(obj))) || (!strcmp("FitBH", pdf_to_name(obj))))
 	{
 		t_from_2 = 1;
 		ld.ld.gotor.flags |= fz_link_flag_fit_h;
 	}
-	else if ((!strcmp("FitV", fz_to_name(obj))) || (!strcmp("FitBV", fz_to_name(obj))))
+	else if ((!strcmp("FitV", pdf_to_name(obj))) || (!strcmp("FitBV", pdf_to_name(obj))))
 	{
 		l_from_2 = 1;
 		ld.ld.gotor.flags |= fz_link_flag_fit_v;
 	}
-	else if (!strcmp("FitR", fz_to_name(obj)))
+	else if (!strcmp("FitR", pdf_to_name(obj)))
 	{
 		l_from_2 = b_from_3 = r_from_4 = t_from_5 = 1;
 		ld.ld.gotor.flags |= fz_link_flag_fit_h;
@@ -104,77 +104,77 @@ pdf_parse_link_dest(pdf_document *xref, fz_obj *dest)
 
 	if (l_from_2)
 	{
-		obj = fz_array_get(dest, 2);
-		if (fz_is_int(obj))
+		obj = pdf_array_get(dest, 2);
+		if (pdf_is_int(obj))
 		{
 			ld.ld.gotor.flags |= fz_link_flag_l_valid;
-			ld.ld.gotor.lt.x = fz_to_int(obj);
+			ld.ld.gotor.lt.x = pdf_to_int(obj);
 		}
-		else if (fz_is_real(obj))
+		else if (pdf_is_real(obj))
 		{
 			ld.ld.gotor.flags |= fz_link_flag_l_valid;
-			ld.ld.gotor.lt.x = fz_to_real(obj);
+			ld.ld.gotor.lt.x = pdf_to_real(obj);
 		}
 	}
 	if (b_from_3)
 	{
-		obj = fz_array_get(dest, 3);
-		if (fz_is_int(obj))
+		obj = pdf_array_get(dest, 3);
+		if (pdf_is_int(obj))
 		{
 			ld.ld.gotor.flags |= fz_link_flag_b_valid;
-			ld.ld.gotor.rb.y = fz_to_int(obj);
+			ld.ld.gotor.rb.y = pdf_to_int(obj);
 		}
-		else if (fz_is_real(obj))
+		else if (pdf_is_real(obj))
 		{
 			ld.ld.gotor.flags |= fz_link_flag_b_valid;
-			ld.ld.gotor.rb.y = fz_to_real(obj);
+			ld.ld.gotor.rb.y = pdf_to_real(obj);
 		}
 	}
 	if (r_from_4)
 	{
-		obj = fz_array_get(dest, 4);
-		if (fz_is_int(obj))
+		obj = pdf_array_get(dest, 4);
+		if (pdf_is_int(obj))
 		{
 			ld.ld.gotor.flags |= fz_link_flag_r_valid;
-			ld.ld.gotor.rb.x = fz_to_int(obj);
+			ld.ld.gotor.rb.x = pdf_to_int(obj);
 		}
-		else if (fz_is_real(obj))
+		else if (pdf_is_real(obj))
 		{
 			ld.ld.gotor.flags |= fz_link_flag_r_valid;
-			ld.ld.gotor.rb.x = fz_to_real(obj);
+			ld.ld.gotor.rb.x = pdf_to_real(obj);
 		}
 	}
 	if (t_from_5 || t_from_3 || t_from_2)
 	{
 		if (t_from_5)
-			obj = fz_array_get(dest, 5);
+			obj = pdf_array_get(dest, 5);
 		else if (t_from_3)
-			obj = fz_array_get(dest, 3);
+			obj = pdf_array_get(dest, 3);
 		else
-			obj = fz_array_get(dest, 2);
-		if (fz_is_int(obj))
+			obj = pdf_array_get(dest, 2);
+		if (pdf_is_int(obj))
 		{
 			ld.ld.gotor.flags |= fz_link_flag_t_valid;
-			ld.ld.gotor.lt.y = fz_to_int(obj);
+			ld.ld.gotor.lt.y = pdf_to_int(obj);
 		}
-		else if (fz_is_real(obj))
+		else if (pdf_is_real(obj))
 		{
 			ld.ld.gotor.flags |= fz_link_flag_t_valid;
-			ld.ld.gotor.lt.y = fz_to_real(obj);
+			ld.ld.gotor.lt.y = pdf_to_real(obj);
 		}
 	}
 	if (z_from_4)
 	{
-		obj = fz_array_get(dest, 4);
-		if (fz_is_int(obj))
+		obj = pdf_array_get(dest, 4);
+		if (pdf_is_int(obj))
 		{
 			ld.ld.gotor.flags |= fz_link_flag_r_valid;
-			ld.ld.gotor.rb.x = fz_to_int(obj);
+			ld.ld.gotor.rb.x = pdf_to_int(obj);
 		}
-		else if (fz_is_real(obj))
+		else if (pdf_is_real(obj))
 		{
 			ld.ld.gotor.flags |= fz_link_flag_r_valid;
-			ld.ld.gotor.rb.x = fz_to_real(obj);
+			ld.ld.gotor.rb.x = pdf_to_real(obj);
 		}
 	}
 
@@ -192,10 +192,10 @@ pdf_parse_link_dest(pdf_document *xref, fz_obj *dest)
 }
 
 fz_link_dest
-pdf_parse_action(pdf_document *xref, fz_obj *action)
+pdf_parse_action(pdf_document *xref, pdf_obj *action)
 {
 	fz_link_dest ld;
-	fz_obj *obj, *dest;
+	pdf_obj *obj, *dest;
 	fz_context *ctx = xref->ctx;
 
 	ld.kind = FZ_LINK_NONE;
@@ -203,53 +203,53 @@ pdf_parse_action(pdf_document *xref, fz_obj *action)
 	if (!action)
 		return ld;
 
-	obj = fz_dict_gets(action, "S");
-	if (!strcmp(fz_to_name(obj), "GoTo"))
+	obj = pdf_dict_gets(action, "S");
+	if (!strcmp(pdf_to_name(obj), "GoTo"))
 	{
-		dest = fz_dict_gets(action, "D");
+		dest = pdf_dict_gets(action, "D");
 		ld = pdf_parse_link_dest(xref, dest);
 	}
-	else if (!strcmp(fz_to_name(obj), "URI"))
+	else if (!strcmp(pdf_to_name(obj), "URI"))
 	{
 		ld.kind = FZ_LINK_URI;
-		ld.ld.uri.is_map = fz_to_bool(fz_dict_gets(action, "IsMap"));
-		ld.ld.uri.uri = pdf_to_utf8(ctx, fz_dict_gets(action, "URI"));
+		ld.ld.uri.is_map = pdf_to_bool(pdf_dict_gets(action, "IsMap"));
+		ld.ld.uri.uri = pdf_to_utf8(ctx, pdf_dict_gets(action, "URI"));
 	}
-	else if (!strcmp(fz_to_name(obj), "Launch"))
+	else if (!strcmp(pdf_to_name(obj), "Launch"))
 	{
 		ld.kind = FZ_LINK_LAUNCH;
-		ld.ld.launch.file_spec = pdf_to_utf8(ctx, fz_dict_gets(action, "F"));
-		ld.ld.launch.new_window = fz_to_int(fz_dict_gets(action, "NewWindow"));
+		ld.ld.launch.file_spec = pdf_to_utf8(ctx, pdf_dict_gets(action, "F"));
+		ld.ld.launch.new_window = pdf_to_int(pdf_dict_gets(action, "NewWindow"));
 	}
-	else if (!strcmp(fz_to_name(obj), "Named"))
+	else if (!strcmp(pdf_to_name(obj), "Named"))
 	{
 		ld.kind = FZ_LINK_NAMED;
-		ld.ld.named.named = pdf_to_utf8(ctx, fz_dict_gets(action, "N"));
+		ld.ld.named.named = pdf_to_utf8(ctx, pdf_dict_gets(action, "N"));
 	}
-	else if (!strcmp(fz_to_name(obj), "GoToR"))
+	else if (!strcmp(pdf_to_name(obj), "GoToR"))
 	{
-		dest = fz_dict_gets(action, "D");
+		dest = pdf_dict_gets(action, "D");
 		ld = pdf_parse_link_dest(xref, dest);
 		ld.kind = FZ_LINK_GOTOR;
-		ld.ld.gotor.file_spec = pdf_to_utf8(ctx, fz_dict_gets(action, "F"));
-		ld.ld.gotor.new_window = fz_to_int(fz_dict_gets(action, "NewWindow"));
+		ld.ld.gotor.file_spec = pdf_to_utf8(ctx, pdf_dict_gets(action, "F"));
+		ld.ld.gotor.new_window = pdf_to_int(pdf_dict_gets(action, "NewWindow"));
 	}
 	return ld;
 }
 
 static fz_link *
-pdf_load_link(pdf_document *xref, fz_obj *dict, fz_matrix page_ctm)
+pdf_load_link(pdf_document *xref, pdf_obj *dict, fz_matrix page_ctm)
 {
-	fz_obj *dest = NULL;
-	fz_obj *action;
-	fz_obj *obj;
+	pdf_obj *dest = NULL;
+	pdf_obj *action;
+	pdf_obj *obj;
 	fz_rect bbox;
 	fz_context *ctx = xref->ctx;
 	fz_link_dest ld;
 
 	dest = NULL;
 
-	obj = fz_dict_gets(dict, "Rect");
+	obj = pdf_dict_gets(dict, "Rect");
 	if (obj)
 		bbox = pdf_to_rect(ctx, obj);
 	else
@@ -257,7 +257,7 @@ pdf_load_link(pdf_document *xref, fz_obj *dict, fz_matrix page_ctm)
 
 	bbox = fz_transform_rect(page_ctm, bbox);
 
-	obj = fz_dict_gets(dict, "Dest");
+	obj = pdf_dict_gets(dict, "Dest");
 	if (obj)
 	{
 		dest = resolve_dest(xref, obj);
@@ -265,10 +265,10 @@ pdf_load_link(pdf_document *xref, fz_obj *dict, fz_matrix page_ctm)
 	}
 	else
 	{
-		action = fz_dict_gets(dict, "A");
+		action = pdf_dict_gets(dict, "A");
 		/* fall back to additional action button's down/up action */
 		if (!action)
-			action = fz_dict_getsa(fz_dict_gets(dict, "AA"), "U", "D");
+			action = pdf_dict_getsa(pdf_dict_gets(dict, "AA"), "U", "D");
 
 		ld = pdf_parse_action(xref, action);
 	}
@@ -278,19 +278,19 @@ pdf_load_link(pdf_document *xref, fz_obj *dict, fz_matrix page_ctm)
 }
 
 fz_link *
-pdf_load_link_annots(pdf_document *xref, fz_obj *annots, fz_matrix page_ctm)
+pdf_load_link_annots(pdf_document *xref, pdf_obj *annots, fz_matrix page_ctm)
 {
 	fz_link *link, *head, *tail;
-	fz_obj *obj;
+	pdf_obj *obj;
 	int i, n;
 
 	head = tail = NULL;
 	link = NULL;
 
-	n = fz_array_len(annots);
+	n = pdf_array_len(annots);
 	for (i = 0; i < n; i++)
 	{
-		obj = fz_array_get(annots, i);
+		obj = pdf_array_get(annots, i);
 		link = pdf_load_link(xref, obj, page_ctm);
 		if (link)
 		{
@@ -318,7 +318,7 @@ pdf_free_annot(fz_context *ctx, pdf_annot *annot)
 		if (annot->ap)
 			pdf_drop_xobject(ctx, annot->ap);
 		if (annot->obj)
-			fz_drop_obj(annot->obj);
+			pdf_drop_obj(annot->obj);
 		fz_free(ctx, annot);
 		annot = next;
 	}
@@ -349,10 +349,10 @@ pdf_transform_annot(pdf_annot *annot)
 }
 
 pdf_annot *
-pdf_load_annots(pdf_document *xref, fz_obj *annots)
+pdf_load_annots(pdf_document *xref, pdf_obj *annots)
 {
 	pdf_annot *annot, *head, *tail;
-	fz_obj *obj, *ap, *as, *n, *rect;
+	pdf_obj *obj, *ap, *as, *n, *rect;
 	pdf_xobject *form;
 	int i, len;
 	fz_context *ctx = xref->ctx;
@@ -360,23 +360,23 @@ pdf_load_annots(pdf_document *xref, fz_obj *annots)
 	head = tail = NULL;
 	annot = NULL;
 
-	len = fz_array_len(annots);
+	len = pdf_array_len(annots);
 	for (i = 0; i < len; i++)
 	{
-		obj = fz_array_get(annots, i);
+		obj = pdf_array_get(annots, i);
 
-		rect = fz_dict_gets(obj, "Rect");
-		ap = fz_dict_gets(obj, "AP");
-		as = fz_dict_gets(obj, "AS");
-		if (fz_is_dict(ap))
+		rect = pdf_dict_gets(obj, "Rect");
+		ap = pdf_dict_gets(obj, "AP");
+		as = pdf_dict_gets(obj, "AS");
+		if (pdf_is_dict(ap))
 		{
-			n = fz_dict_gets(ap, "N"); /* normal state */
+			n = pdf_dict_gets(ap, "N"); /* normal state */
 
 			/* lookup current state in sub-dictionary */
-			if (!pdf_is_stream(xref, fz_to_num(n), fz_to_gen(n)))
-				n = fz_dict_get(n, as);
+			if (!pdf_is_stream(xref, pdf_to_num(n), pdf_to_gen(n)))
+				n = pdf_dict_get(n, as);
 
-			if (pdf_is_stream(xref, fz_to_num(n), fz_to_gen(n)))
+			if (pdf_is_stream(xref, pdf_to_num(n), pdf_to_gen(n)))
 			{
 				fz_try(ctx)
 				{
@@ -389,7 +389,7 @@ pdf_load_annots(pdf_document *xref, fz_obj *annots)
 				}
 
 				annot = fz_malloc_struct(ctx, pdf_annot);
-				annot->obj = fz_keep_obj(obj);
+				annot->obj = pdf_keep_obj(obj);
 				annot->rect = pdf_to_rect(ctx, rect);
 				annot->ap = form;
 				annot->next = NULL;
diff --git a/pdf/pdf_cmap_load.c b/pdf/pdf_cmap_load.c
index 9e6b13ce..d4e161c8 100644
--- a/pdf/pdf_cmap_load.c
+++ b/pdf/pdf_cmap_load.c
@@ -16,13 +16,13 @@ pdf_cmap_size(fz_context *ctx, pdf_cmap *cmap)
  * Load CMap stream in PDF file
  */
 pdf_cmap *
-pdf_load_embedded_cmap(pdf_document *xref, fz_obj *stmobj)
+pdf_load_embedded_cmap(pdf_document *xref, pdf_obj *stmobj)
 {
 	fz_stream *file = NULL;
 	pdf_cmap *cmap = NULL;
 	pdf_cmap *usecmap;
-	fz_obj *wmode;
-	fz_obj *obj = NULL;
+	pdf_obj *wmode;
+	pdf_obj *obj = NULL;
 	fz_context *ctx = xref->ctx;
 	int phase = 0;
 
@@ -38,24 +38,24 @@ pdf_load_embedded_cmap(pdf_document *xref, fz_obj *stmobj)
 
 	fz_try(ctx)
 	{
-		file = pdf_open_stream(xref, fz_to_num(stmobj), fz_to_gen(stmobj));
+		file = pdf_open_stream(xref, pdf_to_num(stmobj), pdf_to_gen(stmobj));
 		phase = 1;
 		cmap = pdf_load_cmap(ctx, file);
 		phase = 2;
 		fz_close(file);
 		file = NULL;
 
-		wmode = fz_dict_gets(stmobj, "WMode");
-		if (fz_is_int(wmode))
-			pdf_set_wmode(ctx, cmap, fz_to_int(wmode));
-		obj = fz_dict_gets(stmobj, "UseCMap");
-		if (fz_is_name(obj))
+		wmode = pdf_dict_gets(stmobj, "WMode");
+		if (pdf_is_int(wmode))
+			pdf_set_wmode(ctx, cmap, pdf_to_int(wmode));
+		obj = pdf_dict_gets(stmobj, "UseCMap");
+		if (pdf_is_name(obj))
 		{
-			usecmap = pdf_load_system_cmap(ctx, fz_to_name(obj));
+			usecmap = pdf_load_system_cmap(ctx, pdf_to_name(obj));
 			pdf_set_usecmap(ctx, cmap, usecmap);
 			pdf_drop_cmap(ctx, usecmap);
 		}
-		else if (fz_is_indirect(obj))
+		else if (pdf_is_indirect(obj))
 		{
 			phase = 3;
 			usecmap = pdf_load_embedded_cmap(xref, obj);
@@ -72,13 +72,13 @@ pdf_load_embedded_cmap(pdf_document *xref, fz_obj *stmobj)
 		if (cmap)
 			pdf_drop_cmap(ctx, cmap);
 		if (phase < 1)
-			fz_throw(ctx, "cannot open cmap stream (%d %d R)", fz_to_num(stmobj), fz_to_gen(stmobj));
+			fz_throw(ctx, "cannot open cmap stream (%d %d R)", pdf_to_num(stmobj), pdf_to_gen(stmobj));
 		else if (phase < 2)
-			fz_throw(ctx, "cannot parse cmap stream (%d %d R)", fz_to_num(stmobj), fz_to_gen(stmobj));
+			fz_throw(ctx, "cannot parse cmap stream (%d %d R)", pdf_to_num(stmobj), pdf_to_gen(stmobj));
 		else if (phase < 3)
-			fz_throw(ctx, "cannot load system usecmap '%s'", fz_to_name(obj));
+			fz_throw(ctx, "cannot load system usecmap '%s'", pdf_to_name(obj));
 		else
-			fz_throw(ctx, "cannot load embedded usecmap (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+			fz_throw(ctx, "cannot load embedded usecmap (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj));
 	}
 
 	return cmap;
diff --git a/pdf/pdf_colorspace.c b/pdf/pdf_colorspace.c
index a6515d42..0e9423b4 100644
--- a/pdf/pdf_colorspace.c
+++ b/pdf/pdf_colorspace.c
@@ -4,11 +4,11 @@
 /* ICCBased */
 
 static fz_colorspace *
-load_icc_based(pdf_document *xref, fz_obj *dict)
+load_icc_based(pdf_document *xref, pdf_obj *dict)
 {
 	int n;
 
-	n = fz_to_int(fz_dict_gets(dict, "N"));
+	n = pdf_to_int(pdf_dict_gets(dict, "N"));
 
 	switch (n)
 	{
@@ -91,14 +91,14 @@ free_separation(fz_context *ctx, fz_colorspace *cs)
 }
 
 static fz_colorspace *
-load_separation(pdf_document *xref, fz_obj *array)
+load_separation(pdf_document *xref, pdf_obj *array)
 {
 	fz_colorspace *cs;
 	struct separation *sep = NULL;
 	fz_context *ctx = xref->ctx;
-	fz_obj *nameobj = fz_array_get(array, 1);
-	fz_obj *baseobj = fz_array_get(array, 2);
-	fz_obj *tintobj = fz_array_get(array, 3);
+	pdf_obj *nameobj = pdf_array_get(array, 1);
+	pdf_obj *baseobj = pdf_array_get(array, 2);
+	pdf_obj *tintobj = pdf_array_get(array, 3);
 	fz_colorspace *base;
 	pdf_function *tint = NULL;
 	int n;
@@ -106,8 +106,8 @@ load_separation(pdf_document *xref, fz_obj *array)
 	fz_var(tint);
 	fz_var(sep);
 
-	if (fz_is_array(nameobj))
-		n = fz_array_len(nameobj);
+	if (pdf_is_array(nameobj))
+		n = pdf_array_len(nameobj);
 	else
 		n = 1;
 
@@ -115,13 +115,13 @@ load_separation(pdf_document *xref, fz_obj *array)
 		fz_throw(ctx, "too many components in colorspace");
 
 	base = pdf_load_colorspace(xref, baseobj);
-	/* RJW: "cannot load base colorspace (%d %d R)", fz_to_num(baseobj), fz_to_gen(baseobj) */
+	/* RJW: "cannot load base colorspace (%d %d R)", pdf_to_num(baseobj), pdf_to_gen(baseobj) */
 
 	fz_try(ctx)
 	{
 		tint = pdf_load_function(xref, tintobj);
 		/* RJW: fz_drop_colorspace(ctx, base);
-		 * "cannot load tint function (%d %d R)", fz_to_num(tintobj), fz_to_gen(tintobj) */
+		 * "cannot load tint function (%d %d R)", pdf_to_num(tintobj), pdf_to_gen(tintobj) */
 
 		sep = fz_malloc_struct(ctx, struct separation);
 		sep->base = base;
@@ -218,13 +218,13 @@ pdf_expand_indexed_pixmap(fz_context *ctx, fz_pixmap *src)
 }
 
 static fz_colorspace *
-load_indexed(pdf_document *xref, fz_obj *array)
+load_indexed(pdf_document *xref, pdf_obj *array)
 {
 	struct indexed *idx = NULL;
 	fz_context *ctx = xref->ctx;
-	fz_obj *baseobj = fz_array_get(array, 1);
-	fz_obj *highobj = fz_array_get(array, 2);
-	fz_obj *lookup = fz_array_get(array, 3);
+	pdf_obj *baseobj = pdf_array_get(array, 1);
+	pdf_obj *highobj = pdf_array_get(array, 2);
+	pdf_obj *lookup = pdf_array_get(array, 3);
 	fz_colorspace *base = NULL;
 	fz_colorspace *cs = NULL;
 	int i, n;
@@ -236,12 +236,12 @@ load_indexed(pdf_document *xref, fz_obj *array)
 	fz_try(ctx)
 	{
 		base = pdf_load_colorspace(xref, baseobj);
-		/* "cannot load base colorspace (%d %d R)", fz_to_num(baseobj), fz_to_gen(baseobj) */
+		/* "cannot load base colorspace (%d %d R)", pdf_to_num(baseobj), pdf_to_gen(baseobj) */
 
 		idx = fz_malloc_struct(ctx, struct indexed);
 		idx->lookup = NULL;
 		idx->base = base;
-		idx->high = fz_to_int(highobj);
+		idx->high = pdf_to_int(highobj);
 		idx->high = CLAMP(idx->high, 0, 255);
 		n = base->n * (idx->high + 1);
 		idx->lookup = fz_malloc_array(ctx, 1, n);
@@ -252,30 +252,30 @@ load_indexed(pdf_document *xref, fz_obj *array)
 		cs->data = idx;
 		cs->size += sizeof(*idx) + n + (base ? base->size : 0);
 
-		if (fz_is_string(lookup) && fz_to_str_len(lookup) == n)
+		if (pdf_is_string(lookup) && pdf_to_str_len(lookup) == n)
 		{
-			unsigned char *buf = (unsigned char *) fz_to_str_buf(lookup);
+			unsigned char *buf = (unsigned char *) pdf_to_str_buf(lookup);
 			for (i = 0; i < n; i++)
 				idx->lookup[i] = buf[i];
 		}
-		else if (fz_is_indirect(lookup))
+		else if (pdf_is_indirect(lookup))
 		{
 			fz_stream *file = NULL;
 
 			fz_try(ctx)
 			{
-				file = pdf_open_stream(xref, fz_to_num(lookup), fz_to_gen(lookup));
+				file = pdf_open_stream(xref, pdf_to_num(lookup), pdf_to_gen(lookup));
 			}
 			fz_catch(ctx)
 			{
-				fz_throw(ctx, "cannot open colorspace lookup table (%d 0 R)", fz_to_num(lookup));
+				fz_throw(ctx, "cannot open colorspace lookup table (%d 0 R)", pdf_to_num(lookup));
 			}
 
 			i = fz_read(file, idx->lookup, n);
 			if (i < 0)
 			{
 				fz_close(file);
-				fz_throw(ctx, "cannot read colorspace lookup table (%d 0 R)", fz_to_num(lookup));
+				fz_throw(ctx, "cannot read colorspace lookup table (%d 0 R)", pdf_to_num(lookup));
 			}
 
 			fz_close(file);
@@ -304,93 +304,93 @@ load_indexed(pdf_document *xref, fz_obj *array)
 /* Parse and create colorspace from PDF object */
 
 static fz_colorspace *
-pdf_load_colorspace_imp(pdf_document *xref, fz_obj *obj)
+pdf_load_colorspace_imp(pdf_document *xref, pdf_obj *obj)
 {
-	if (fz_is_name(obj))
+	if (pdf_is_name(obj))
 	{
-		if (!strcmp(fz_to_name(obj), "Pattern"))
+		if (!strcmp(pdf_to_name(obj), "Pattern"))
 			return fz_device_gray;
-		else if (!strcmp(fz_to_name(obj), "G"))
+		else if (!strcmp(pdf_to_name(obj), "G"))
 			return fz_device_gray;
-		else if (!strcmp(fz_to_name(obj), "RGB"))
+		else if (!strcmp(pdf_to_name(obj), "RGB"))
 			return fz_device_rgb;
-		else if (!strcmp(fz_to_name(obj), "CMYK"))
+		else if (!strcmp(pdf_to_name(obj), "CMYK"))
 			return fz_device_cmyk;
-		else if (!strcmp(fz_to_name(obj), "DeviceGray"))
+		else if (!strcmp(pdf_to_name(obj), "DeviceGray"))
 			return fz_device_gray;
-		else if (!strcmp(fz_to_name(obj), "DeviceRGB"))
+		else if (!strcmp(pdf_to_name(obj), "DeviceRGB"))
 			return fz_device_rgb;
-		else if (!strcmp(fz_to_name(obj), "DeviceCMYK"))
+		else if (!strcmp(pdf_to_name(obj), "DeviceCMYK"))
 			return fz_device_cmyk;
 		else
-			fz_throw(xref->ctx, "unknown colorspace: %s", fz_to_name(obj));
+			fz_throw(xref->ctx, "unknown colorspace: %s", pdf_to_name(obj));
 	}
 
-	else if (fz_is_array(obj))
+	else if (pdf_is_array(obj))
 	{
-		fz_obj *name = fz_array_get(obj, 0);
+		pdf_obj *name = pdf_array_get(obj, 0);
 
-		if (fz_is_name(name))
+		if (pdf_is_name(name))
 		{
 			/* load base colorspace instead */
-			if (!strcmp(fz_to_name(name), "Pattern"))
+			if (!strcmp(pdf_to_name(name), "Pattern"))
 			{
-				obj = fz_array_get(obj, 1);
+				obj = pdf_array_get(obj, 1);
 				if (!obj)
 				{
 					return fz_device_gray;
 				}
 
 				return pdf_load_colorspace(xref, obj);
-				/* RJW: "cannot load pattern (%d %d R)", fz_to_num(obj), fz_to_gen(obj) */
+				/* RJW: "cannot load pattern (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj) */
 			}
 
-			else if (!strcmp(fz_to_name(name), "G"))
+			else if (!strcmp(pdf_to_name(name), "G"))
 				return fz_device_gray;
-			else if (!strcmp(fz_to_name(name), "RGB"))
+			else if (!strcmp(pdf_to_name(name), "RGB"))
 				return fz_device_rgb;
-			else if (!strcmp(fz_to_name(name), "CMYK"))
+			else if (!strcmp(pdf_to_name(name), "CMYK"))
 				return fz_device_cmyk;
-			else if (!strcmp(fz_to_name(name), "DeviceGray"))
+			else if (!strcmp(pdf_to_name(name), "DeviceGray"))
 				return fz_device_gray;
-			else if (!strcmp(fz_to_name(name), "DeviceRGB"))
+			else if (!strcmp(pdf_to_name(name), "DeviceRGB"))
 				return fz_device_rgb;
-			else if (!strcmp(fz_to_name(name), "DeviceCMYK"))
+			else if (!strcmp(pdf_to_name(name), "DeviceCMYK"))
 				return fz_device_cmyk;
-			else if (!strcmp(fz_to_name(name), "CalGray"))
+			else if (!strcmp(pdf_to_name(name), "CalGray"))
 				return fz_device_gray;
-			else if (!strcmp(fz_to_name(name), "CalRGB"))
+			else if (!strcmp(pdf_to_name(name), "CalRGB"))
 				return fz_device_rgb;
-			else if (!strcmp(fz_to_name(name), "CalCMYK"))
+			else if (!strcmp(pdf_to_name(name), "CalCMYK"))
 				return fz_device_cmyk;
-			else if (!strcmp(fz_to_name(name), "Lab"))
+			else if (!strcmp(pdf_to_name(name), "Lab"))
 				return fz_device_lab;
 
-			else if (!strcmp(fz_to_name(name), "ICCBased"))
-				return load_icc_based(xref, fz_array_get(obj, 1));
+			else if (!strcmp(pdf_to_name(name), "ICCBased"))
+				return load_icc_based(xref, pdf_array_get(obj, 1));
 
-			else if (!strcmp(fz_to_name(name), "Indexed"))
+			else if (!strcmp(pdf_to_name(name), "Indexed"))
 				return load_indexed(xref, obj);
-			else if (!strcmp(fz_to_name(name), "I"))
+			else if (!strcmp(pdf_to_name(name), "I"))
 				return load_indexed(xref, obj);
 
-			else if (!strcmp(fz_to_name(name), "Separation"))
+			else if (!strcmp(pdf_to_name(name), "Separation"))
 				return load_separation(xref, obj);
 
-			else if (!strcmp(fz_to_name(name), "DeviceN"))
+			else if (!strcmp(pdf_to_name(name), "DeviceN"))
 				return load_separation(xref, obj);
 
 			else
-				fz_throw(xref->ctx, "syntaxerror: unknown colorspace %s", fz_to_name(name));
+				fz_throw(xref->ctx, "syntaxerror: unknown colorspace %s", pdf_to_name(name));
 		}
 	}
 
-	fz_throw(xref->ctx, "syntaxerror: could not parse color space (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+	fz_throw(xref->ctx, "syntaxerror: could not parse color space (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj));
 	return NULL; /* Stupid MSVC */
 }
 
 fz_colorspace *
-pdf_load_colorspace(pdf_document *xref, fz_obj *obj)
+pdf_load_colorspace(pdf_document *xref, pdf_obj *obj)
 {
 	fz_context *ctx = xref->ctx;
 	fz_colorspace *cs;
@@ -401,7 +401,7 @@ pdf_load_colorspace(pdf_document *xref, fz_obj *obj)
 	}
 
 	cs = pdf_load_colorspace_imp(xref, obj);
-	/* RJW: "cannot load colorspace (%d %d R)", fz_to_num(obj), fz_to_gen(obj) */
+	/* RJW: "cannot load colorspace (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj) */
 
 	pdf_store_item(ctx, obj, cs, cs->size);
 
diff --git a/pdf/pdf_crypt.c b/pdf/pdf_crypt.c
index 59423a38..c99e696c 100644
--- a/pdf/pdf_crypt.c
+++ b/pdf/pdf_crypt.c
@@ -20,11 +20,11 @@ struct pdf_crypt_filter_s
 
 struct pdf_crypt_s
 {
-	fz_obj *id;
+	pdf_obj *id;
 
 	int v;
 	int length;
-	fz_obj *cf;
+	pdf_obj *cf;
 	pdf_crypt_filter stmf;
 	pdf_crypt_filter strf;
 
@@ -40,7 +40,7 @@ struct pdf_crypt_s
 	fz_context *ctx;
 };
 
-static void pdf_parse_crypt_filter(fz_context *ctx, pdf_crypt_filter *cf, fz_obj *dict, char *name, int defaultlength);
+static void pdf_parse_crypt_filter(fz_context *ctx, pdf_crypt_filter *cf, pdf_obj *dict, char *name, int defaultlength);
 
 /*
  * Create crypt object for decrypting strings and streams
@@ -48,31 +48,31 @@ static void pdf_parse_crypt_filter(fz_context *ctx, pdf_crypt_filter *cf, fz_obj
  */
 
 pdf_crypt *
-pdf_new_crypt(fz_context *ctx, fz_obj *dict, fz_obj *id)
+pdf_new_crypt(fz_context *ctx, pdf_obj *dict, pdf_obj *id)
 {
 	pdf_crypt *crypt;
-	fz_obj *obj;
+	pdf_obj *obj;
 
 	crypt = fz_malloc_struct(ctx, pdf_crypt);
 
 	/* Common to all security handlers (PDF 1.7 table 3.18) */
 
-	obj = fz_dict_gets(dict, "Filter");
-	if (!fz_is_name(obj))
+	obj = pdf_dict_gets(dict, "Filter");
+	if (!pdf_is_name(obj))
 	{
 		pdf_free_crypt(ctx, crypt);
 		fz_throw(ctx, "unspecified encryption handler");
 	}
-	if (strcmp(fz_to_name(obj), "Standard") != 0)
+	if (strcmp(pdf_to_name(obj), "Standard") != 0)
 	{
 		pdf_free_crypt(ctx, crypt);
-		fz_throw(ctx, "unknown encryption handler: '%s'", fz_to_name(obj));
+		fz_throw(ctx, "unknown encryption handler: '%s'", pdf_to_name(obj));
 	}
 
 	crypt->v = 0;
-	obj = fz_dict_gets(dict, "V");
-	if (fz_is_int(obj))
-		crypt->v = fz_to_int(obj);
+	obj = pdf_dict_gets(dict, "V");
+	if (pdf_is_int(obj))
+		crypt->v = pdf_to_int(obj);
 	if (crypt->v != 1 && crypt->v != 2 && crypt->v != 4 && crypt->v != 5)
 	{
 		pdf_free_crypt(ctx, crypt);
@@ -82,9 +82,9 @@ pdf_new_crypt(fz_context *ctx, fz_obj *dict, fz_obj *id)
 	crypt->length = 40;
 	if (crypt->v == 2 || crypt->v == 4)
 	{
-		obj = fz_dict_gets(dict, "Length");
-		if (fz_is_int(obj))
-			crypt->length = fz_to_int(obj);
+		obj = pdf_dict_gets(dict, "Length");
+		if (pdf_is_int(obj))
+			crypt->length = pdf_to_int(obj);
 
 		/* work-around for pdf generators that assume length is in bytes */
 		if (crypt->length < 40)
@@ -122,10 +122,10 @@ pdf_new_crypt(fz_context *ctx, fz_obj *dict, fz_obj *id)
 		crypt->strf.method = PDF_CRYPT_NONE;
 		crypt->strf.length = crypt->length;
 
-		obj = fz_dict_gets(dict, "CF");
-		if (fz_is_dict(obj))
+		obj = pdf_dict_gets(dict, "CF");
+		if (pdf_is_dict(obj))
 		{
-			crypt->cf = fz_keep_obj(obj);
+			crypt->cf = pdf_keep_obj(obj);
 		}
 		else
 		{
@@ -134,18 +134,18 @@ pdf_new_crypt(fz_context *ctx, fz_obj *dict, fz_obj *id)
 
 		fz_try(ctx)
 		{
-			obj = fz_dict_gets(dict, "StmF");
-			if (fz_is_name(obj))
-				pdf_parse_crypt_filter(ctx, &crypt->stmf, crypt->cf, fz_to_name(obj), crypt->length);
+			obj = pdf_dict_gets(dict, "StmF");
+			if (pdf_is_name(obj))
+				pdf_parse_crypt_filter(ctx, &crypt->stmf, crypt->cf, pdf_to_name(obj), crypt->length);
 
-			obj = fz_dict_gets(dict, "StrF");
-			if (fz_is_name(obj))
-				pdf_parse_crypt_filter(ctx, &crypt->strf, crypt->cf, fz_to_name(obj), crypt->length);
+			obj = pdf_dict_gets(dict, "StrF");
+			if (pdf_is_name(obj))
+				pdf_parse_crypt_filter(ctx, &crypt->strf, crypt->cf, pdf_to_name(obj), crypt->length);
 		}
 		fz_catch(ctx)
 		{
 			pdf_free_crypt(ctx, crypt);
-			fz_throw(ctx, "cannot parse string crypt filter (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+			fz_throw(ctx, "cannot parse string crypt filter (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj));
 		}
 
 		/* in crypt revision 4, the crypt filter determines the key length */
@@ -155,36 +155,36 @@ pdf_new_crypt(fz_context *ctx, fz_obj *dict, fz_obj *id)
 
 	/* Standard security handler (PDF 1.7 table 3.19) */
 
-	obj = fz_dict_gets(dict, "R");
-	if (fz_is_int(obj))
-		crypt->r = fz_to_int(obj);
+	obj = pdf_dict_gets(dict, "R");
+	if (pdf_is_int(obj))
+		crypt->r = pdf_to_int(obj);
 	else
 	{
 		pdf_free_crypt(ctx, crypt);
 		fz_throw(ctx, "encryption dictionary missing revision value");
 	}
 
-	obj = fz_dict_gets(dict, "O");
-	if (fz_is_string(obj) && fz_to_str_len(obj) == 32)
-		memcpy(crypt->o, fz_to_str_buf(obj), 32);
+	obj = pdf_dict_gets(dict, "O");
+	if (pdf_is_string(obj) && pdf_to_str_len(obj) == 32)
+		memcpy(crypt->o, pdf_to_str_buf(obj), 32);
 	/* /O and /U are supposed to be 48 bytes long for revision 5, they're often longer, though */
-	else if (crypt->r == 5 && fz_is_string(obj) && fz_to_str_len(obj) >= 48)
-		memcpy(crypt->o, fz_to_str_buf(obj), 48);
+	else if (crypt->r == 5 && pdf_is_string(obj) && pdf_to_str_len(obj) >= 48)
+		memcpy(crypt->o, pdf_to_str_buf(obj), 48);
 	else
 	{
 		pdf_free_crypt(ctx, crypt);
 		fz_throw(ctx, "encryption dictionary missing owner password");
 	}
 
-	obj = fz_dict_gets(dict, "U");
-	if (fz_is_string(obj) && fz_to_str_len(obj) == 32)
-		memcpy(crypt->u, fz_to_str_buf(obj), 32);
-	else if (fz_is_string(obj) && fz_to_str_len(obj) >= 48 && crypt->r == 5)
-		memcpy(crypt->u, fz_to_str_buf(obj), 48);
-	else if (fz_is_string(obj) && fz_to_str_len(obj) < 32)
+	obj = pdf_dict_gets(dict, "U");
+	if (pdf_is_string(obj) && pdf_to_str_len(obj) == 32)
+		memcpy(crypt->u, pdf_to_str_buf(obj), 32);
+	else if (pdf_is_string(obj) && pdf_to_str_len(obj) >= 48 && crypt->r == 5)
+		memcpy(crypt->u, pdf_to_str_buf(obj), 48);
+	else if (pdf_is_string(obj) && pdf_to_str_len(obj) < 32)
 	{
-		fz_warn(ctx, "encryption password key too short (%d)", fz_to_str_len(obj));
-		memcpy(crypt->u, fz_to_str_buf(obj), fz_to_str_len(obj));
+		fz_warn(ctx, "encryption password key too short (%d)", pdf_to_str_len(obj));
+		memcpy(crypt->u, pdf_to_str_buf(obj), pdf_to_str_len(obj));
 	}
 	else
 	{
@@ -192,9 +192,9 @@ pdf_new_crypt(fz_context *ctx, fz_obj *dict, fz_obj *id)
 		fz_throw(ctx, "encryption dictionary missing user password");
 	}
 
-	obj = fz_dict_gets(dict, "P");
-	if (fz_is_int(obj))
-		crypt->p = fz_to_int(obj);
+	obj = pdf_dict_gets(dict, "P");
+	if (pdf_is_int(obj))
+		crypt->p = pdf_to_int(obj);
 	else
 	{
 		pdf_free_crypt(ctx, crypt);
@@ -203,35 +203,35 @@ pdf_new_crypt(fz_context *ctx, fz_obj *dict, fz_obj *id)
 
 	if (crypt->r == 5)
 	{
-		obj = fz_dict_gets(dict, "OE");
-		if (!fz_is_string(obj) || fz_to_str_len(obj) != 32)
+		obj = pdf_dict_gets(dict, "OE");
+		if (!pdf_is_string(obj) || pdf_to_str_len(obj) != 32)
 		{
 			pdf_free_crypt(ctx, crypt);
 			fz_throw(ctx, "encryption dictionary missing owner encryption key");
 		}
-		memcpy(crypt->oe, fz_to_str_buf(obj), 32);
+		memcpy(crypt->oe, pdf_to_str_buf(obj), 32);
 
-		obj = fz_dict_gets(dict, "UE");
-		if (!fz_is_string(obj) || fz_to_str_len(obj) != 32)
+		obj = pdf_dict_gets(dict, "UE");
+		if (!pdf_is_string(obj) || pdf_to_str_len(obj) != 32)
 		{
 			pdf_free_crypt(ctx, crypt);
 			fz_throw(ctx, "encryption dictionary missing user encryption key");
 		}
-		memcpy(crypt->ue, fz_to_str_buf(obj), 32);
+		memcpy(crypt->ue, pdf_to_str_buf(obj), 32);
 	}
 
 	crypt->encrypt_metadata = 1;
-	obj = fz_dict_gets(dict, "EncryptMetadata");
-	if (fz_is_bool(obj))
-		crypt->encrypt_metadata = fz_to_bool(obj);
+	obj = pdf_dict_gets(dict, "EncryptMetadata");
+	if (pdf_is_bool(obj))
+		crypt->encrypt_metadata = pdf_to_bool(obj);
 
 	/* Extract file identifier string */
 
-	if (fz_is_array(id) && fz_array_len(id) == 2)
+	if (pdf_is_array(id) && pdf_array_len(id) == 2)
 	{
-		obj = fz_array_get(id, 0);
-		if (fz_is_string(obj))
-			crypt->id = fz_keep_obj(obj);
+		obj = pdf_array_get(id, 0);
+		if (pdf_is_string(obj))
+			crypt->id = pdf_keep_obj(obj);
 	}
 	else
 		fz_warn(ctx, "missing file identifier, may not be able to do decryption");
@@ -242,8 +242,8 @@ pdf_new_crypt(fz_context *ctx, fz_obj *dict, fz_obj *id)
 void
 pdf_free_crypt(fz_context *ctx, pdf_crypt *crypt)
 {
-	if (crypt->id) fz_drop_obj(crypt->id);
-	if (crypt->cf) fz_drop_obj(crypt->cf);
+	if (crypt->id) pdf_drop_obj(crypt->id);
+	if (crypt->cf) pdf_drop_obj(crypt->cf);
 	fz_free(ctx, crypt);
 }
 
@@ -252,15 +252,15 @@ pdf_free_crypt(fz_context *ctx, pdf_crypt *crypt)
  */
 
 static void
-pdf_parse_crypt_filter(fz_context *ctx, pdf_crypt_filter *cf, fz_obj *cf_obj, char *name, int defaultlength)
+pdf_parse_crypt_filter(fz_context *ctx, pdf_crypt_filter *cf, pdf_obj *cf_obj, char *name, int defaultlength)
 {
-	fz_obj *obj;
-	fz_obj *dict;
+	pdf_obj *obj;
+	pdf_obj *dict;
 	int is_identity = (strcmp(name, "Identity") == 0);
 	int is_stdcf = (!is_identity && (strcmp(name, "StdCF") == 0));
 
 	if (!is_identity && !is_stdcf)
-		fz_throw(ctx, "Crypt Filter not Identity or StdCF (%d %d R)", fz_to_num(cf_obj), fz_to_gen(cf_obj));
+		fz_throw(ctx, "Crypt Filter not Identity or StdCF (%d %d R)", pdf_to_num(cf_obj), pdf_to_gen(cf_obj));
 
 	cf->method = PDF_CRYPT_NONE;
 	cf->length = defaultlength;
@@ -271,28 +271,28 @@ pdf_parse_crypt_filter(fz_context *ctx, pdf_crypt_filter *cf, fz_obj *cf_obj, ch
 		return;
 	}
 
-	dict = fz_dict_gets(cf_obj, name);
-	if (!fz_is_dict(dict))
-		fz_throw(ctx, "cannot parse crypt filter (%d %d R)", fz_to_num(cf_obj), fz_to_gen(cf_obj));
+	dict = pdf_dict_gets(cf_obj, name);
+	if (!pdf_is_dict(dict))
+		fz_throw(ctx, "cannot parse crypt filter (%d %d R)", pdf_to_num(cf_obj), pdf_to_gen(cf_obj));
 
-	obj = fz_dict_gets(dict, "CFM");
-	if (fz_is_name(obj))
+	obj = pdf_dict_gets(dict, "CFM");
+	if (pdf_is_name(obj))
 	{
-		if (!strcmp(fz_to_name(obj), "None"))
+		if (!strcmp(pdf_to_name(obj), "None"))
 			cf->method = PDF_CRYPT_NONE;
-		else if (!strcmp(fz_to_name(obj), "V2"))
+		else if (!strcmp(pdf_to_name(obj), "V2"))
 			cf->method = PDF_CRYPT_RC4;
-		else if (!strcmp(fz_to_name(obj), "AESV2"))
+		else if (!strcmp(pdf_to_name(obj), "AESV2"))
 			cf->method = PDF_CRYPT_AESV2;
-		else if (!strcmp(fz_to_name(obj), "AESV3"))
+		else if (!strcmp(pdf_to_name(obj), "AESV3"))
 			cf->method = PDF_CRYPT_AESV3;
 		else
-			fz_warn(ctx, "unknown encryption method: %s", fz_to_name(obj));
+			fz_warn(ctx, "unknown encryption method: %s", pdf_to_name(obj));
 	}
 
-	obj = fz_dict_gets(dict, "Length");
-	if (fz_is_int(obj))
-		cf->length = fz_to_int(obj);
+	obj = pdf_dict_gets(dict, "Length");
+	if (pdf_is_int(obj))
+		cf->length = pdf_to_int(obj);
 
 	/* the length for crypt filters is supposed to be in bytes not bits */
 	if (cf->length < 40)
@@ -346,7 +346,7 @@ pdf_compute_encryption_key(pdf_crypt *crypt, unsigned char *password, int pwlen,
 	fz_md5_update(&md5, buf, 4);
 
 	/* Step 5 - pass first element of ID array */
-	fz_md5_update(&md5, (unsigned char *)fz_to_str_buf(crypt->id), fz_to_str_len(crypt->id));
+	fz_md5_update(&md5, (unsigned char *)pdf_to_str_buf(crypt->id), pdf_to_str_len(crypt->id));
 
 	/* Step 6 (revision 4 or greater) - if metadata is not encrypted pass 0xFFFFFFFF */
 	if (crypt->r >= 4)
@@ -455,7 +455,7 @@ pdf_compute_user_password(pdf_crypt *crypt, unsigned char *password, int pwlen,
 
 		fz_md5_init(&md5);
 		fz_md5_update(&md5, padding, 32);
-		fz_md5_update(&md5, (unsigned char*)fz_to_str_buf(crypt->id), fz_to_str_len(crypt->id));
+		fz_md5_update(&md5, (unsigned char*)pdf_to_str_buf(crypt->id), pdf_to_str_len(crypt->id));
 		fz_md5_final(&md5, digest);
 
 		fz_arc4_init(&arc4, crypt->key, n);
@@ -697,18 +697,18 @@ pdf_compute_object_key(pdf_crypt *crypt, pdf_crypt_filter *cf, int num, int gen,
  */
 
 static void
-pdf_crypt_obj_imp(fz_context *ctx, pdf_crypt *crypt, fz_obj *obj, unsigned char *key, int keylen)
+pdf_crypt_obj_imp(fz_context *ctx, pdf_crypt *crypt, pdf_obj *obj, unsigned char *key, int keylen)
 {
 	unsigned char *s;
 	int i, n;
 
-	if (fz_is_indirect(obj))
+	if (pdf_is_indirect(obj))
 		return;
 
-	if (fz_is_string(obj))
+	if (pdf_is_string(obj))
 	{
-		s = (unsigned char *)fz_to_str_buf(obj);
-		n = fz_to_str_len(obj);
+		s = (unsigned char *)pdf_to_str_buf(obj);
+		n = pdf_to_str_len(obj);
 
 		if (crypt->strf.method == PDF_CRYPT_RC4)
 		{
@@ -736,32 +736,32 @@ pdf_crypt_obj_imp(fz_context *ctx, pdf_crypt *crypt, fz_obj *obj, unsigned char
 				if (s[n - 17] < 1 || s[n - 17] > 16)
 					fz_warn(ctx, "aes padding out of range");
 				else
-					fz_set_str_len(obj, n - 16 - s[n - 17]);
+					pdf_set_str_len(obj, n - 16 - s[n - 17]);
 			}
 		}
 	}
 
-	else if (fz_is_array(obj))
+	else if (pdf_is_array(obj))
 	{
-		n = fz_array_len(obj);
+		n = pdf_array_len(obj);
 		for (i = 0; i < n; i++)
 		{
-			pdf_crypt_obj_imp(ctx, crypt, fz_array_get(obj, i), key, keylen);
+			pdf_crypt_obj_imp(ctx, crypt, pdf_array_get(obj, i), key, keylen);
 		}
 	}
 
-	else if (fz_is_dict(obj))
+	else if (pdf_is_dict(obj))
 	{
-		n = fz_dict_len(obj);
+		n = pdf_dict_len(obj);
 		for (i = 0; i < n; i++)
 		{
-			pdf_crypt_obj_imp(ctx, crypt, fz_dict_get_val(obj, i), key, keylen);
+			pdf_crypt_obj_imp(ctx, crypt, pdf_dict_get_val(obj, i), key, keylen);
 		}
 	}
 }
 
 void
-pdf_crypt_obj(fz_context *ctx, pdf_crypt *crypt, fz_obj *obj, int num, int gen)
+pdf_crypt_obj(fz_context *ctx, pdf_crypt *crypt, pdf_obj *obj, int num, int gen)
 {
 	unsigned char key[32];
 	int len;
diff --git a/pdf/pdf_font.c b/pdf/pdf_font.c
index fd2afab2..5e54e0bb 100644
--- a/pdf/pdf_font.c
+++ b/pdf/pdf_font.c
@@ -5,7 +5,7 @@
 #include FT_FREETYPE_H
 #include FT_XFREE86_H
 
-static void pdf_load_font_descriptor(pdf_font_desc *fontdesc, pdf_document *xref, fz_obj *dict, char *collection, char *basefont);
+static void pdf_load_font_descriptor(pdf_font_desc *fontdesc, pdf_document *xref, pdf_obj *dict, char *collection, char *basefont);
 
 static char *base_font_names[14][7] =
 {
@@ -268,18 +268,18 @@ pdf_load_system_font(fz_context *ctx, pdf_font_desc *fontdesc, char *fontname, c
 }
 
 static void
-pdf_load_embedded_font(pdf_font_desc *fontdesc, pdf_document *xref, fz_obj *stmref)
+pdf_load_embedded_font(pdf_font_desc *fontdesc, pdf_document *xref, pdf_obj *stmref)
 {
 	fz_buffer *buf;
 	fz_context *ctx = xref->ctx;
 
 	fz_try(ctx)
 	{
-		buf = pdf_load_stream(xref, fz_to_num(stmref), fz_to_gen(stmref));
+		buf = pdf_load_stream(xref, pdf_to_num(stmref), pdf_to_gen(stmref));
 	}
 	fz_catch(ctx)
 	{
-		fz_throw(ctx, "cannot load font stream (%d %d R)", fz_to_num(stmref), fz_to_gen(stmref));
+		fz_throw(ctx, "cannot load font stream (%d %d R)", pdf_to_num(stmref), pdf_to_gen(stmref));
 	}
 
 	fz_try(ctx)
@@ -289,7 +289,7 @@ pdf_load_embedded_font(pdf_font_desc *fontdesc, pdf_document *xref, fz_obj *stmr
 	fz_catch(ctx)
 	{
 		fz_drop_buffer(ctx, buf);
-		fz_throw(ctx, "cannot load embedded font (%d %d R)", fz_to_num(stmref), fz_to_gen(stmref));
+		fz_throw(ctx, "cannot load embedded font (%d %d R)", pdf_to_num(stmref), pdf_to_gen(stmref));
 	}
 	fontdesc->size += buf->len;
 
@@ -394,11 +394,11 @@ pdf_new_font_desc(fz_context *ctx)
  */
 
 static pdf_font_desc *
-pdf_load_simple_font(pdf_document *xref, fz_obj *dict)
+pdf_load_simple_font(pdf_document *xref, pdf_obj *dict)
 {
-	fz_obj *descriptor;
-	fz_obj *encoding;
-	fz_obj *widths;
+	pdf_obj *descriptor;
+	pdf_obj *encoding;
+	pdf_obj *widths;
 	unsigned short *etable = NULL;
 	pdf_font_desc *fontdesc = NULL;
 	FT_Face face;
@@ -417,7 +417,7 @@ pdf_load_simple_font(pdf_document *xref, fz_obj *dict)
 	fz_var(fontdesc);
 	fz_var(etable);
 
-	basefont = fz_to_name(fz_dict_gets(dict, "BaseFont"));
+	basefont = pdf_to_name(pdf_dict_gets(dict, "BaseFont"));
 	fontname = clean_font_name(basefont);
 
 	/* Load font file */
@@ -425,7 +425,7 @@ pdf_load_simple_font(pdf_document *xref, fz_obj *dict)
 	{
 		fontdesc = pdf_new_font_desc(ctx);
 
-		descriptor = fz_dict_gets(dict, "FontDescriptor");
+		descriptor = pdf_dict_gets(dict, "FontDescriptor");
 		if (descriptor)
 			pdf_load_font_descriptor(fontdesc, xref, descriptor, NULL, basefont);
 		else
@@ -433,9 +433,9 @@ pdf_load_simple_font(pdf_document *xref, fz_obj *dict)
 
 		/* Some chinese documents mistakenly consider WinAnsiEncoding to be codepage 936 */
 		if (!*fontdesc->font->name &&
-			!fz_dict_gets(dict, "ToUnicode") &&
-			!strcmp(fz_to_name(fz_dict_gets(dict, "Encoding")), "WinAnsiEncoding") &&
-			fz_to_int(fz_dict_gets(descriptor, "Flags")) == 4)
+			!pdf_dict_gets(dict, "ToUnicode") &&
+			!strcmp(pdf_to_name(pdf_dict_gets(dict, "Encoding")), "WinAnsiEncoding") &&
+			pdf_to_int(pdf_dict_gets(descriptor, "Flags")) == 4)
 		{
 			/* note: without the comma, pdf_load_font_descriptor would prefer /FontName over /BaseFont */
 			char *cp936fonts[] = {
@@ -514,34 +514,34 @@ pdf_load_simple_font(pdf_document *xref, fz_obj *dict)
 			etable[i] = 0;
 		}
 
-		encoding = fz_dict_gets(dict, "Encoding");
+		encoding = pdf_dict_gets(dict, "Encoding");
 		if (encoding)
 		{
-			if (fz_is_name(encoding))
-				pdf_load_encoding(estrings, fz_to_name(encoding));
+			if (pdf_is_name(encoding))
+				pdf_load_encoding(estrings, pdf_to_name(encoding));
 
-			if (fz_is_dict(encoding))
+			if (pdf_is_dict(encoding))
 			{
-				fz_obj *base, *diff, *item;
+				pdf_obj *base, *diff, *item;
 
-				base = fz_dict_gets(encoding, "BaseEncoding");
-				if (fz_is_name(base))
-					pdf_load_encoding(estrings, fz_to_name(base));
+				base = pdf_dict_gets(encoding, "BaseEncoding");
+				if (pdf_is_name(base))
+					pdf_load_encoding(estrings, pdf_to_name(base));
 				else if (!fontdesc->is_embedded && !symbolic)
 					pdf_load_encoding(estrings, "StandardEncoding");
 
-				diff = fz_dict_gets(encoding, "Differences");
-				if (fz_is_array(diff))
+				diff = pdf_dict_gets(encoding, "Differences");
+				if (pdf_is_array(diff))
 				{
-					n = fz_array_len(diff);
+					n = pdf_array_len(diff);
 					k = 0;
 					for (i = 0; i < n; i++)
 					{
-						item = fz_array_get(diff, i);
-						if (fz_is_int(item))
-							k = fz_to_int(item);
-						if (fz_is_name(item))
-							estrings[k++] = fz_to_name(item);
+						item = pdf_array_get(diff, i);
+						if (pdf_is_int(item))
+							k = pdf_to_int(item);
+						if (pdf_is_name(item))
+							estrings[k++] = pdf_to_name(item);
 						if (k < 0) k = 0;
 						if (k > 255) k = 255;
 					}
@@ -654,7 +654,7 @@ pdf_load_simple_font(pdf_document *xref, fz_obj *dict)
 		fontdesc->cid_to_gid_len = 256;
 		fontdesc->cid_to_gid = etable;
 
-		pdf_load_to_unicode(xref, fontdesc, estrings, NULL, fz_dict_gets(dict, "ToUnicode"));
+		pdf_load_to_unicode(xref, fontdesc, estrings, NULL, pdf_dict_gets(dict, "ToUnicode"));
 		/* RJW: "cannot load to_unicode" */
 
 	skip_encoding:
@@ -663,20 +663,20 @@ pdf_load_simple_font(pdf_document *xref, fz_obj *dict)
 
 		pdf_set_default_hmtx(ctx, fontdesc, fontdesc->missing_width);
 
-		widths = fz_dict_gets(dict, "Widths");
+		widths = pdf_dict_gets(dict, "Widths");
 		if (widths)
 		{
 			int first, last;
 
-			first = fz_to_int(fz_dict_gets(dict, "FirstChar"));
-			last = fz_to_int(fz_dict_gets(dict, "LastChar"));
+			first = pdf_to_int(pdf_dict_gets(dict, "FirstChar"));
+			last = pdf_to_int(pdf_dict_gets(dict, "LastChar"));
 
 			if (first < 0 || last > 255 || first > last)
 				first = last = 0;
 
 			for (i = 0; i < last - first + 1; i++)
 			{
-				int wid = fz_to_int(fz_array_get(widths, i));
+				int wid = pdf_to_int(pdf_array_get(widths, i));
 				pdf_add_hmtx(ctx, fontdesc, i + first, i + first, wid);
 			}
 		}
@@ -700,7 +700,7 @@ pdf_load_simple_font(pdf_document *xref, fz_obj *dict)
 		if (fontdesc && etable != fontdesc->cid_to_gid)
 			fz_free(ctx, etable);
 		pdf_drop_font(ctx, fontdesc);
-		fz_throw(ctx, "cannot load simple font (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+		fz_throw(ctx, "cannot load simple font (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict));
 	}
 	return fontdesc;
 }
@@ -710,17 +710,17 @@ pdf_load_simple_font(pdf_document *xref, fz_obj *dict)
  */
 
 static pdf_font_desc *
-load_cid_font(pdf_document *xref, fz_obj *dict, fz_obj *encoding, fz_obj *to_unicode)
+load_cid_font(pdf_document *xref, pdf_obj *dict, pdf_obj *encoding, pdf_obj *to_unicode)
 {
-	fz_obj *widths;
-	fz_obj *descriptor;
+	pdf_obj *widths;
+	pdf_obj *descriptor;
 	pdf_font_desc *fontdesc;
 	FT_Face face;
 	int kind;
 	char collection[256];
 	char *basefont;
 	int i, k, fterr;
-	fz_obj *obj;
+	pdf_obj *obj;
 	int dw;
 	fz_context *ctx = xref->ctx;
 
@@ -730,28 +730,28 @@ load_cid_font(pdf_document *xref, fz_obj *dict, fz_obj *encoding, fz_obj *to_uni
 	{
 		/* Get font name and CID collection */
 
-		basefont = fz_to_name(fz_dict_gets(dict, "BaseFont"));
+		basefont = pdf_to_name(pdf_dict_gets(dict, "BaseFont"));
 
 		{
-			fz_obj *cidinfo;
+			pdf_obj *cidinfo;
 			char tmpstr[64];
 			int tmplen;
 
-			cidinfo = fz_dict_gets(dict, "CIDSystemInfo");
+			cidinfo = pdf_dict_gets(dict, "CIDSystemInfo");
 			if (!cidinfo)
 				fz_throw(ctx, "cid font is missing info");
 
-			obj = fz_dict_gets(cidinfo, "Registry");
-			tmplen = MIN(sizeof tmpstr - 1, fz_to_str_len(obj));
-			memcpy(tmpstr, fz_to_str_buf(obj), tmplen);
+			obj = pdf_dict_gets(cidinfo, "Registry");
+			tmplen = MIN(sizeof tmpstr - 1, pdf_to_str_len(obj));
+			memcpy(tmpstr, pdf_to_str_buf(obj), tmplen);
 			tmpstr[tmplen] = '\0';
 			fz_strlcpy(collection, tmpstr, sizeof collection);
 
 			fz_strlcat(collection, "-", sizeof collection);
 
-			obj = fz_dict_gets(cidinfo, "Ordering");
-			tmplen = MIN(sizeof tmpstr - 1, fz_to_str_len(obj));
-			memcpy(tmpstr, fz_to_str_buf(obj), tmplen);
+			obj = pdf_dict_gets(cidinfo, "Ordering");
+			tmplen = MIN(sizeof tmpstr - 1, pdf_to_str_len(obj));
+			memcpy(tmpstr, pdf_to_str_buf(obj), tmplen);
 			tmpstr[tmplen] = '\0';
 			fz_strlcat(collection, tmpstr, sizeof collection);
 		}
@@ -760,7 +760,7 @@ load_cid_font(pdf_document *xref, fz_obj *dict, fz_obj *encoding, fz_obj *to_uni
 
 		fontdesc = pdf_new_font_desc(ctx);
 
-		descriptor = fz_dict_gets(dict, "FontDescriptor");
+		descriptor = pdf_dict_gets(dict, "FontDescriptor");
 		if (!descriptor)
 			fz_throw(ctx, "syntaxerror: missing font descriptor");
 		pdf_load_font_descriptor(fontdesc, xref, descriptor, collection, basefont);
@@ -770,16 +770,16 @@ load_cid_font(pdf_document *xref, fz_obj *dict, fz_obj *encoding, fz_obj *to_uni
 
 		/* Encoding */
 
-		if (fz_is_name(encoding))
+		if (pdf_is_name(encoding))
 		{
-			if (!strcmp(fz_to_name(encoding), "Identity-H"))
+			if (!strcmp(pdf_to_name(encoding), "Identity-H"))
 				fontdesc->encoding = pdf_new_identity_cmap(ctx, 0, 2);
-			else if (!strcmp(fz_to_name(encoding), "Identity-V"))
+			else if (!strcmp(pdf_to_name(encoding), "Identity-V"))
 				fontdesc->encoding = pdf_new_identity_cmap(ctx, 1, 2);
 			else
-				fontdesc->encoding = pdf_load_system_cmap(ctx, fz_to_name(encoding));
+				fontdesc->encoding = pdf_load_system_cmap(ctx, pdf_to_name(encoding));
 		}
-		else if (fz_is_indirect(encoding))
+		else if (pdf_is_indirect(encoding))
 		{
 			fontdesc->encoding = pdf_load_embedded_cmap(xref, encoding);
 		}
@@ -793,14 +793,14 @@ load_cid_font(pdf_document *xref, fz_obj *dict, fz_obj *encoding, fz_obj *to_uni
 
 		if (kind == TRUETYPE)
 		{
-			fz_obj *cidtogidmap;
+			pdf_obj *cidtogidmap;
 
-			cidtogidmap = fz_dict_gets(dict, "CIDToGIDMap");
-			if (fz_is_indirect(cidtogidmap))
+			cidtogidmap = pdf_dict_gets(dict, "CIDToGIDMap");
+			if (pdf_is_indirect(cidtogidmap))
 			{
 				fz_buffer *buf;
 
-				buf = pdf_load_stream(xref, fz_to_num(cidtogidmap), fz_to_gen(cidtogidmap));
+				buf = pdf_load_stream(xref, pdf_to_num(cidtogidmap), pdf_to_gen(cidtogidmap));
 
 				fontdesc->cid_to_gid_len = (buf->len) / 2;
 				fontdesc->cid_to_gid = fz_malloc_array(ctx, fontdesc->cid_to_gid_len, sizeof(unsigned short));
@@ -842,35 +842,35 @@ load_cid_font(pdf_document *xref, fz_obj *dict, fz_obj *encoding, fz_obj *to_uni
 		/* Horizontal */
 
 		dw = 1000;
-		obj = fz_dict_gets(dict, "DW");
+		obj = pdf_dict_gets(dict, "DW");
 		if (obj)
-			dw = fz_to_int(obj);
+			dw = pdf_to_int(obj);
 		pdf_set_default_hmtx(ctx, fontdesc, dw);
 
-		widths = fz_dict_gets(dict, "W");
+		widths = pdf_dict_gets(dict, "W");
 		if (widths)
 		{
 			int c0, c1, w, n, m;
 
-			n = fz_array_len(widths);
+			n = pdf_array_len(widths);
 			for (i = 0; i < n; )
 			{
-				c0 = fz_to_int(fz_array_get(widths, i));
-				obj = fz_array_get(widths, i + 1);
-				if (fz_is_array(obj))
+				c0 = pdf_to_int(pdf_array_get(widths, i));
+				obj = pdf_array_get(widths, i + 1);
+				if (pdf_is_array(obj))
 				{
-					m = fz_array_len(obj);
+					m = pdf_array_len(obj);
 					for (k = 0; k < m; k++)
 					{
-						w = fz_to_int(fz_array_get(obj, k));
+						w = pdf_to_int(pdf_array_get(obj, k));
 						pdf_add_hmtx(ctx, fontdesc, c0 + k, c0 + k, w);
 					}
 					i += 2;
 				}
 				else
 				{
-					c1 = fz_to_int(obj);
-					w = fz_to_int(fz_array_get(widths, i + 2));
+					c1 = pdf_to_int(obj);
+					w = pdf_to_int(pdf_array_get(widths, i + 2));
 					pdf_add_hmtx(ctx, fontdesc, c0, c1, w);
 					i += 3;
 				}
@@ -886,43 +886,43 @@ load_cid_font(pdf_document *xref, fz_obj *dict, fz_obj *encoding, fz_obj *to_uni
 			int dw2y = 880;
 			int dw2w = -1000;
 
-			obj = fz_dict_gets(dict, "DW2");
+			obj = pdf_dict_gets(dict, "DW2");
 			if (obj)
 			{
-				dw2y = fz_to_int(fz_array_get(obj, 0));
-				dw2w = fz_to_int(fz_array_get(obj, 1));
+				dw2y = pdf_to_int(pdf_array_get(obj, 0));
+				dw2w = pdf_to_int(pdf_array_get(obj, 1));
 			}
 
 			pdf_set_default_vmtx(ctx, fontdesc, dw2y, dw2w);
 
-			widths = fz_dict_gets(dict, "W2");
+			widths = pdf_dict_gets(dict, "W2");
 			if (widths)
 			{
 				int c0, c1, w, x, y, n;
 
-				n = fz_array_len(widths);
+				n = pdf_array_len(widths);
 				for (i = 0; i < n; )
 				{
-					c0 = fz_to_int(fz_array_get(widths, i));
-					obj = fz_array_get(widths, i + 1);
-					if (fz_is_array(obj))
+					c0 = pdf_to_int(pdf_array_get(widths, i));
+					obj = pdf_array_get(widths, i + 1);
+					if (pdf_is_array(obj))
 					{
-						int m = fz_array_len(obj);
+						int m = pdf_array_len(obj);
 						for (k = 0; k * 3 < m; k ++)
 						{
-							w = fz_to_int(fz_array_get(obj, k * 3 + 0));
-							x = fz_to_int(fz_array_get(obj, k * 3 + 1));
-							y = fz_to_int(fz_array_get(obj, k * 3 + 2));
+							w = pdf_to_int(pdf_array_get(obj, k * 3 + 0));
+							x = pdf_to_int(pdf_array_get(obj, k * 3 + 1));
+							y = pdf_to_int(pdf_array_get(obj, k * 3 + 2));
 							pdf_add_vmtx(ctx, fontdesc, c0 + k, c0 + k, x, y, w);
 						}
 						i += 2;
 					}
 					else
 					{
-						c1 = fz_to_int(obj);
-						w = fz_to_int(fz_array_get(widths, i + 2));
-						x = fz_to_int(fz_array_get(widths, i + 3));
-						y = fz_to_int(fz_array_get(widths, i + 4));
+						c1 = pdf_to_int(obj);
+						w = pdf_to_int(pdf_array_get(widths, i + 2));
+						x = pdf_to_int(pdf_array_get(widths, i + 3));
+						y = pdf_to_int(pdf_array_get(widths, i + 4));
 						pdf_add_vmtx(ctx, fontdesc, c0, c1, x, y, w);
 						i += 5;
 					}
@@ -935,38 +935,38 @@ load_cid_font(pdf_document *xref, fz_obj *dict, fz_obj *encoding, fz_obj *to_uni
 	fz_catch(ctx)
 	{
 		pdf_drop_font(ctx, fontdesc);
-		fz_throw(ctx, "cannot load cid font (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+		fz_throw(ctx, "cannot load cid font (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict));
 	}
 
 	return fontdesc;
 }
 
 static pdf_font_desc *
-pdf_load_type0_font(pdf_document *xref, fz_obj *dict)
+pdf_load_type0_font(pdf_document *xref, pdf_obj *dict)
 {
-	fz_obj *dfonts;
-	fz_obj *dfont;
-	fz_obj *subtype;
-	fz_obj *encoding;
-	fz_obj *to_unicode;
+	pdf_obj *dfonts;
+	pdf_obj *dfont;
+	pdf_obj *subtype;
+	pdf_obj *encoding;
+	pdf_obj *to_unicode;
 
-	dfonts = fz_dict_gets(dict, "DescendantFonts");
+	dfonts = pdf_dict_gets(dict, "DescendantFonts");
 	if (!dfonts)
 		fz_throw(xref->ctx, "cid font is missing descendant fonts");
 
-	dfont = fz_array_get(dfonts, 0);
+	dfont = pdf_array_get(dfonts, 0);
 
-	subtype = fz_dict_gets(dfont, "Subtype");
-	encoding = fz_dict_gets(dict, "Encoding");
-	to_unicode = fz_dict_gets(dict, "ToUnicode");
+	subtype = pdf_dict_gets(dfont, "Subtype");
+	encoding = pdf_dict_gets(dict, "Encoding");
+	to_unicode = pdf_dict_gets(dict, "ToUnicode");
 
-	if (fz_is_name(subtype) && !strcmp(fz_to_name(subtype), "CIDFontType0"))
+	if (pdf_is_name(subtype) && !strcmp(pdf_to_name(subtype), "CIDFontType0"))
 		return load_cid_font(xref, dfont, encoding, to_unicode);
-	else if (fz_is_name(subtype) && !strcmp(fz_to_name(subtype), "CIDFontType2"))
+	else if (pdf_is_name(subtype) && !strcmp(pdf_to_name(subtype), "CIDFontType2"))
 		return load_cid_font(xref, dfont, encoding, to_unicode);
 	else
 		fz_throw(xref->ctx, "syntaxerror: unknown cid font type");
-	/* RJW: "cannot load descendant font (%d %d R)", fz_to_num(dfont), fz_to_gen(dfont) */
+	/* RJW: "cannot load descendant font (%d %d R)", pdf_to_num(dfont), pdf_to_gen(dfont) */
 	return NULL; /* Stupid MSVC */
 }
 
@@ -975,34 +975,34 @@ pdf_load_type0_font(pdf_document *xref, fz_obj *dict)
  */
 
 static void
-pdf_load_font_descriptor(pdf_font_desc *fontdesc, pdf_document *xref, fz_obj *dict, char *collection, char *basefont)
+pdf_load_font_descriptor(pdf_font_desc *fontdesc, pdf_document *xref, pdf_obj *dict, char *collection, char *basefont)
 {
-	fz_obj *obj1, *obj2, *obj3, *obj;
+	pdf_obj *obj1, *obj2, *obj3, *obj;
 	char *fontname;
 	char *origname;
 	FT_Face face;
 	fz_context *ctx = xref->ctx;
 
 	if (!strchr(basefont, ',') || strchr(basefont, '+'))
-		origname = fz_to_name(fz_dict_gets(dict, "FontName"));
+		origname = pdf_to_name(pdf_dict_gets(dict, "FontName"));
 	else
 		origname = basefont;
 	fontname = clean_font_name(origname);
 
-	fontdesc->flags = fz_to_int(fz_dict_gets(dict, "Flags"));
-	fontdesc->italic_angle = fz_to_real(fz_dict_gets(dict, "ItalicAngle"));
-	fontdesc->ascent = fz_to_real(fz_dict_gets(dict, "Ascent"));
-	fontdesc->descent = fz_to_real(fz_dict_gets(dict, "Descent"));
-	fontdesc->cap_height = fz_to_real(fz_dict_gets(dict, "CapHeight"));
-	fontdesc->x_height = fz_to_real(fz_dict_gets(dict, "XHeight"));
-	fontdesc->missing_width = fz_to_real(fz_dict_gets(dict, "MissingWidth"));
-
-	obj1 = fz_dict_gets(dict, "FontFile");
-	obj2 = fz_dict_gets(dict, "FontFile2");
-	obj3 = fz_dict_gets(dict, "FontFile3");
+	fontdesc->flags = pdf_to_int(pdf_dict_gets(dict, "Flags"));
+	fontdesc->italic_angle = pdf_to_real(pdf_dict_gets(dict, "ItalicAngle"));
+	fontdesc->ascent = pdf_to_real(pdf_dict_gets(dict, "Ascent"));
+	fontdesc->descent = pdf_to_real(pdf_dict_gets(dict, "Descent"));
+	fontdesc->cap_height = pdf_to_real(pdf_dict_gets(dict, "CapHeight"));
+	fontdesc->x_height = pdf_to_real(pdf_dict_gets(dict, "XHeight"));
+	fontdesc->missing_width = pdf_to_real(pdf_dict_gets(dict, "MissingWidth"));
+
+	obj1 = pdf_dict_gets(dict, "FontFile");
+	obj2 = pdf_dict_gets(dict, "FontFile2");
+	obj3 = pdf_dict_gets(dict, "FontFile3");
 	obj = obj1 ? obj1 : obj2 ? obj2 : obj3;
 
-	if (fz_is_indirect(obj))
+	if (pdf_is_indirect(obj))
 	{
 		fz_try(ctx)
 		{
@@ -1015,7 +1015,7 @@ pdf_load_font_descriptor(pdf_font_desc *fontdesc, pdf_document *xref, fz_obj *di
 				pdf_load_builtin_font(ctx, fontdesc, fontname);
 			else
 				pdf_load_system_font(ctx, fontdesc, fontname, collection);
-			/* RJW: "cannot load font descriptor (%d %d R)", fz_to_num(dict), fz_to_gen(dict) */
+			/* RJW: "cannot load font descriptor (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict) */
 		}
 	}
 	else
@@ -1024,7 +1024,7 @@ pdf_load_font_descriptor(pdf_font_desc *fontdesc, pdf_document *xref, fz_obj *di
 			pdf_load_builtin_font(ctx, fontdesc, fontname);
 		else
 			pdf_load_system_font(ctx, fontdesc, fontname, collection);
-		/* RJW: "cannot load font descriptor (%d %d R)", fz_to_num(dict), fz_to_gen(dict) */
+		/* RJW: "cannot load font descriptor (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict) */
 	}
 
 	fz_strlcpy(fontdesc->font->name, fontname, sizeof fontdesc->font->name);
@@ -1073,11 +1073,11 @@ pdf_make_width_table(fz_context *ctx, pdf_font_desc *fontdesc)
 }
 
 pdf_font_desc *
-pdf_load_font(pdf_document *xref, fz_obj *rdb, fz_obj *dict)
+pdf_load_font(pdf_document *xref, pdf_obj *rdb, pdf_obj *dict)
 {
 	char *subtype;
-	fz_obj *dfonts;
-	fz_obj *charprocs;
+	pdf_obj *dfonts;
+	pdf_obj *charprocs;
 	fz_context *ctx = xref->ctx;
 	pdf_font_desc *fontdesc;
 
@@ -1086,9 +1086,9 @@ pdf_load_font(pdf_document *xref, fz_obj *rdb, fz_obj *dict)
 		return fontdesc;
 	}
 
-	subtype = fz_to_name(fz_dict_gets(dict, "Subtype"));
-	dfonts = fz_dict_gets(dict, "DescendantFonts");
-	charprocs = fz_dict_gets(dict, "CharProcs");
+	subtype = pdf_to_name(pdf_dict_gets(dict, "Subtype"));
+	dfonts = pdf_dict_gets(dict, "DescendantFonts");
+	charprocs = pdf_dict_gets(dict, "CharProcs");
 
 	if (subtype && !strcmp(subtype, "Type0"))
 		fontdesc = pdf_load_type0_font(xref, dict);
@@ -1115,7 +1115,7 @@ pdf_load_font(pdf_document *xref, fz_obj *rdb, fz_obj *dict)
 		fz_warn(ctx, "unknown font format, guessing type1 or truetype.");
 		fontdesc = pdf_load_simple_font(xref, dict);
 	}
-	/* RJW: "cannot load font (%d %d R)", fz_to_num(dict), fz_to_gen(dict) */
+	/* RJW: "cannot load font (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict) */
 
 	/* Save the widths to stretch non-CJK substitute fonts */
 	if (fontdesc->font->ft_substitute && !fontdesc->to_ttf_cmap)
diff --git a/pdf/pdf_function.c b/pdf/pdf_function.c
index 17373f42..4273bbc6 100644
--- a/pdf/pdf_function.c
+++ b/pdf/pdf_function.c
@@ -828,7 +828,7 @@ parse_code(pdf_function *func, fz_stream *stream, int *codeptr)
 }
 
 static void
-load_postscript_func(pdf_function *func, pdf_document *xref, fz_obj *dict, int num, int gen)
+load_postscript_func(pdf_function *func, pdf_document *xref, pdf_obj *dict, int num, int gen)
 {
 	fz_stream *stream = NULL;
 	int codeptr;
@@ -900,37 +900,37 @@ eval_postscript_func(fz_context *ctx, pdf_function *func, float *in, float *out)
  */
 
 static void
-load_sample_func(pdf_function *func, pdf_document *xref, fz_obj *dict, int num, int gen)
+load_sample_func(pdf_function *func, pdf_document *xref, pdf_obj *dict, int num, int gen)
 {
 	fz_context *ctx = xref->ctx;
 	fz_stream *stream;
-	fz_obj *obj;
+	pdf_obj *obj;
 	int samplecount;
 	int bps;
 	int i;
 
 	func->u.sa.samples = NULL;
 
-	obj = fz_dict_gets(dict, "Size");
-	if (!fz_is_array(obj) || fz_array_len(obj) != func->m)
+	obj = pdf_dict_gets(dict, "Size");
+	if (!pdf_is_array(obj) || pdf_array_len(obj) != func->m)
 		fz_throw(ctx, "malformed /Size");
 	for (i = 0; i < func->m; i++)
-		func->u.sa.size[i] = fz_to_int(fz_array_get(obj, i));
+		func->u.sa.size[i] = pdf_to_int(pdf_array_get(obj, i));
 
-	obj = fz_dict_gets(dict, "BitsPerSample");
-	if (!fz_is_int(obj))
+	obj = pdf_dict_gets(dict, "BitsPerSample");
+	if (!pdf_is_int(obj))
 		fz_throw(ctx, "malformed /BitsPerSample");
-	func->u.sa.bps = bps = fz_to_int(obj);
+	func->u.sa.bps = bps = pdf_to_int(obj);
 
-	obj = fz_dict_gets(dict, "Encode");
-	if (fz_is_array(obj))
+	obj = pdf_dict_gets(dict, "Encode");
+	if (pdf_is_array(obj))
 	{
-		if (fz_array_len(obj) != func->m * 2)
+		if (pdf_array_len(obj) != func->m * 2)
 			fz_throw(ctx, "malformed /Encode");
 		for (i = 0; i < func->m; i++)
 		{
-			func->u.sa.encode[i][0] = fz_to_real(fz_array_get(obj, i*2+0));
-			func->u.sa.encode[i][1] = fz_to_real(fz_array_get(obj, i*2+1));
+			func->u.sa.encode[i][0] = pdf_to_real(pdf_array_get(obj, i*2+0));
+			func->u.sa.encode[i][1] = pdf_to_real(pdf_array_get(obj, i*2+1));
 		}
 	}
 	else
@@ -942,15 +942,15 @@ load_sample_func(pdf_function *func, pdf_document *xref, fz_obj *dict, int num,
 		}
 	}
 
-	obj = fz_dict_gets(dict, "Decode");
-	if (fz_is_array(obj))
+	obj = pdf_dict_gets(dict, "Decode");
+	if (pdf_is_array(obj))
 	{
-		if (fz_array_len(obj) != func->n * 2)
+		if (pdf_array_len(obj) != func->n * 2)
 			fz_throw(ctx, "malformed /Decode");
 		for (i = 0; i < func->n; i++)
 		{
-			func->u.sa.decode[i][0] = fz_to_real(fz_array_get(obj, i*2+0));
-			func->u.sa.decode[i][1] = fz_to_real(fz_array_get(obj, i*2+1));
+			func->u.sa.decode[i][0] = pdf_to_real(pdf_array_get(obj, i*2+0));
+			func->u.sa.decode[i][1] = pdf_to_real(pdf_array_get(obj, i*2+1));
 		}
 	}
 	else
@@ -1111,27 +1111,27 @@ eval_sample_func(fz_context *ctx, pdf_function *func, float *in, float *out)
  */
 
 static void
-load_exponential_func(fz_context *ctx, pdf_function *func, fz_obj *dict)
+load_exponential_func(fz_context *ctx, pdf_function *func, pdf_obj *dict)
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 	int i;
 
 	if (func->m != 1)
 		fz_throw(ctx, "/Domain must be one dimension (%d)", func->m);
 
-	obj = fz_dict_gets(dict, "N");
-	if (!fz_is_int(obj) && !fz_is_real(obj))
+	obj = pdf_dict_gets(dict, "N");
+	if (!pdf_is_int(obj) && !pdf_is_real(obj))
 		fz_throw(ctx, "malformed /N");
-	func->u.e.n = fz_to_real(obj);
+	func->u.e.n = pdf_to_real(obj);
 
-	obj = fz_dict_gets(dict, "C0");
-	if (fz_is_array(obj))
+	obj = pdf_dict_gets(dict, "C0");
+	if (pdf_is_array(obj))
 	{
-		func->n = fz_array_len(obj);
+		func->n = pdf_array_len(obj);
 		if (func->n >= MAXN)
 			fz_throw(ctx, "exponential function result array out of range");
 		for (i = 0; i < func->n; i++)
-			func->u.e.c0[i] = fz_to_real(fz_array_get(obj, i));
+			func->u.e.c0[i] = pdf_to_real(pdf_array_get(obj, i));
 	}
 	else
 	{
@@ -1139,13 +1139,13 @@ load_exponential_func(fz_context *ctx, pdf_function *func, fz_obj *dict)
 		func->u.e.c0[0] = 0;
 	}
 
-	obj = fz_dict_gets(dict, "C1");
-	if (fz_is_array(obj))
+	obj = pdf_dict_gets(dict, "C1");
+	if (pdf_is_array(obj))
 	{
-		if (fz_array_len(obj) != func->n)
+		if (pdf_array_len(obj) != func->n)
 			fz_throw(ctx, "/C1 must match /C0 length");
 		for (i = 0; i < func->n; i++)
-			func->u.e.c1[i] = fz_to_real(fz_array_get(obj, i));
+			func->u.e.c1[i] = pdf_to_real(pdf_array_get(obj, i));
 	}
 	else
 	{
@@ -1185,13 +1185,13 @@ eval_exponential_func(fz_context *ctx, pdf_function *func, float in, float *out)
  */
 
 static void
-load_stitching_func(pdf_function *func, pdf_document *xref, fz_obj *dict)
+load_stitching_func(pdf_function *func, pdf_document *xref, pdf_obj *dict)
 {
 	fz_context *ctx = xref->ctx;
 	pdf_function **funcs;
-	fz_obj *obj;
-	fz_obj *sub;
-	fz_obj *num;
+	pdf_obj *obj;
+	pdf_obj *sub;
+	pdf_obj *num;
 	int k;
 	int i;
 
@@ -1200,11 +1200,11 @@ load_stitching_func(pdf_function *func, pdf_document *xref, fz_obj *dict)
 	if (func->m != 1)
 		fz_throw(ctx, "/Domain must be one dimension (%d)", func->m);
 
-	obj = fz_dict_gets(dict, "Functions");
-	if (!fz_is_array(obj))
+	obj = pdf_dict_gets(dict, "Functions");
+	if (!pdf_is_array(obj))
 		fz_throw(ctx, "stitching function has no input functions");
 	{
-		k = fz_array_len(obj);
+		k = pdf_array_len(obj);
 
 		func->u.st.funcs = fz_malloc_array(ctx, k, sizeof(pdf_function*));
 		func->u.st.bounds = fz_malloc_array(ctx, k - 1, sizeof(float));
@@ -1213,9 +1213,9 @@ load_stitching_func(pdf_function *func, pdf_document *xref, fz_obj *dict)
 
 		for (i = 0; i < k; i++)
 		{
-			sub = fz_array_get(obj, i);
+			sub = pdf_array_get(obj, i);
 			funcs[i] = pdf_load_function(xref, sub);
-			/* RJW: "cannot load sub function %d (%d %d R)", i, fz_to_num(sub), fz_to_gen(sub) */
+			/* RJW: "cannot load sub function %d (%d %d R)", i, pdf_to_num(sub), pdf_to_gen(sub) */
 			if (funcs[i]->m != 1 || funcs[i]->n != funcs[0]->n)
 				fz_throw(ctx, "sub function %d /Domain or /Range mismatch", i);
 			func->size += pdf_function_size(funcs[i]);
@@ -1228,19 +1228,19 @@ load_stitching_func(pdf_function *func, pdf_document *xref, fz_obj *dict)
 			fz_throw(ctx, "sub function /Domain or /Range mismatch");
 	}
 
-	obj = fz_dict_gets(dict, "Bounds");
-	if (!fz_is_array(obj))
+	obj = pdf_dict_gets(dict, "Bounds");
+	if (!pdf_is_array(obj))
 		fz_throw(ctx, "stitching function has no bounds");
 	{
-		if (fz_array_len(obj) != k - 1)
+		if (pdf_array_len(obj) != k - 1)
 			fz_throw(ctx, "malformed /Bounds (wrong length)");
 
 		for (i = 0; i < k-1; i++)
 		{
-			num = fz_array_get(obj, i);
-			if (!fz_is_int(num) && !fz_is_real(num))
+			num = pdf_array_get(obj, i);
+			if (!pdf_is_int(num) && !pdf_is_real(num))
 				fz_throw(ctx, "malformed /Bounds (item not real)");
-			func->u.st.bounds[i] = fz_to_real(num);
+			func->u.st.bounds[i] = pdf_to_real(num);
 			if (i && func->u.st.bounds[i-1] > func->u.st.bounds[i])
 				fz_throw(ctx, "malformed /Bounds (item not monotonic)");
 		}
@@ -1250,16 +1250,16 @@ load_stitching_func(pdf_function *func, pdf_document *xref, fz_obj *dict)
 			fz_warn(ctx, "malformed shading function bounds (domain mismatch), proceeding anyway.");
 	}
 
-	obj = fz_dict_gets(dict, "Encode");
-	if (!fz_is_array(obj))
+	obj = pdf_dict_gets(dict, "Encode");
+	if (!pdf_is_array(obj))
 		fz_throw(ctx, "stitching function is missing encoding");
 	{
-		if (fz_array_len(obj) != k * 2)
+		if (pdf_array_len(obj) != k * 2)
 			fz_throw(ctx, "malformed /Encode");
 		for (i = 0; i < k; i++)
 		{
-			func->u.st.encode[i*2+0] = fz_to_real(fz_array_get(obj, i*2+0));
-			func->u.st.encode[i*2+1] = fz_to_real(fz_array_get(obj, i*2+1));
+			func->u.st.encode[i*2+0] = pdf_to_real(pdf_array_get(obj, i*2+0));
+			func->u.st.encode[i*2+1] = pdf_to_real(pdf_array_get(obj, i*2+1));
 		}
 	}
 }
@@ -1356,11 +1356,11 @@ pdf_function_size(pdf_function *func)
 }
 
 pdf_function *
-pdf_load_function(pdf_document *xref, fz_obj *dict)
+pdf_load_function(pdf_document *xref, pdf_obj *dict)
 {
 	fz_context *ctx = xref->ctx;
 	pdf_function *func;
-	fz_obj *obj;
+	pdf_obj *obj;
 	int i;
 
 	if ((func = pdf_find_item(ctx, pdf_free_function_imp, dict)))
@@ -1372,28 +1372,28 @@ pdf_load_function(pdf_document *xref, fz_obj *dict)
 	FZ_INIT_STORABLE(func, 1, pdf_free_function_imp);
 	func->size = sizeof(*func);
 
-	obj = fz_dict_gets(dict, "FunctionType");
-	func->type = fz_to_int(obj);
+	obj = pdf_dict_gets(dict, "FunctionType");
+	func->type = pdf_to_int(obj);
 
 	/* required for all */
-	obj = fz_dict_gets(dict, "Domain");
-	func->m = fz_array_len(obj) / 2;
+	obj = pdf_dict_gets(dict, "Domain");
+	func->m = pdf_array_len(obj) / 2;
 	for (i = 0; i < func->m; i++)
 	{
-		func->domain[i][0] = fz_to_real(fz_array_get(obj, i * 2 + 0));
-		func->domain[i][1] = fz_to_real(fz_array_get(obj, i * 2 + 1));
+		func->domain[i][0] = pdf_to_real(pdf_array_get(obj, i * 2 + 0));
+		func->domain[i][1] = pdf_to_real(pdf_array_get(obj, i * 2 + 1));
 	}
 
 	/* required for type0 and type4, optional otherwise */
-	obj = fz_dict_gets(dict, "Range");
-	if (fz_is_array(obj))
+	obj = pdf_dict_gets(dict, "Range");
+	if (pdf_is_array(obj))
 	{
 		func->has_range = 1;
-		func->n = fz_array_len(obj) / 2;
+		func->n = pdf_array_len(obj) / 2;
 		for (i = 0; i < func->n; i++)
 		{
-			func->range[i][0] = fz_to_real(fz_array_get(obj, i * 2 + 0));
-			func->range[i][1] = fz_to_real(fz_array_get(obj, i * 2 + 1));
+			func->range[i][0] = pdf_to_real(pdf_array_get(obj, i * 2 + 0));
+			func->range[i][1] = pdf_to_real(pdf_array_get(obj, i * 2 + 1));
 		}
 	}
 	else
@@ -1413,7 +1413,7 @@ pdf_load_function(pdf_document *xref, fz_obj *dict)
 		switch(func->type)
 		{
 		case SAMPLE:
-			load_sample_func(func, xref, dict, fz_to_num(dict), fz_to_gen(dict));
+			load_sample_func(func, xref, dict, pdf_to_num(dict), pdf_to_gen(dict));
 			break;
 
 		case EXPONENTIAL:
@@ -1425,12 +1425,12 @@ pdf_load_function(pdf_document *xref, fz_obj *dict)
 			break;
 
 		case POSTSCRIPT:
-			load_postscript_func(func, xref, dict, fz_to_num(dict), fz_to_gen(dict));
+			load_postscript_func(func, xref, dict, pdf_to_num(dict), pdf_to_gen(dict));
 			break;
 
 		default:
 			fz_free(ctx, func);
-			fz_throw(ctx, "unknown function type (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+			fz_throw(ctx, "unknown function type (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict));
 		}
 
 		pdf_store_item(ctx, dict, func, func->size);
@@ -1445,7 +1445,7 @@ pdf_load_function(pdf_document *xref, fz_obj *dict)
 				type == STITCHING ? "stitching" :
 				type == POSTSCRIPT ? "calculator" :
 				"unknown",
-				fz_to_num(dict), fz_to_gen(dict));
+				pdf_to_num(dict), pdf_to_gen(dict));
 	}
 
 	return func;
diff --git a/pdf/pdf_image.c b/pdf/pdf_image.c
index 22cca81d..cd2726a5 100644
--- a/pdf/pdf_image.c
+++ b/pdf/pdf_image.c
@@ -9,7 +9,7 @@ struct pdf_image_key_s {
 	int factor;
 };
 
-static void pdf_load_jpx(pdf_document *xref, fz_obj *dict, pdf_image *image);
+static void pdf_load_jpx(pdf_document *xref, pdf_obj *dict, pdf_image *image);
 
 static void
 pdf_mask_color_key(fz_pixmap *pix, int n, int *colorkey)
@@ -77,12 +77,21 @@ pdf_cmp_image_key(void *k0_, void *k1_)
 	return k0->image == k1->image && k0->factor == k1->factor;
 }
 
+static void
+pdf_debug_image(void *key_)
+{
+	pdf_image_key *key = (pdf_image_key *)key_;
+
+	printf("(image %d x %d sf=%d) ", key->image->w, key->image->h, key->factor);
+}
+
 static fz_store_type pdf_image_store_type =
 {
 	pdf_make_hash_image_key,
 	pdf_keep_image_key,
 	pdf_drop_image_key,
-	pdf_cmp_image_key
+	pdf_cmp_image_key,
+	pdf_debug_image
 };
 
 static fz_pixmap *
@@ -281,11 +290,11 @@ pdf_image_get_pixmap(fz_context *ctx, fz_image *image_, int w, int h)
 }
 
 static pdf_image *
-pdf_load_image_imp(pdf_document *xref, fz_obj *rdb, fz_obj *dict, fz_stream *cstm, int forcemask)
+pdf_load_image_imp(pdf_document *xref, pdf_obj *rdb, pdf_obj *dict, fz_stream *cstm, int forcemask)
 {
 	fz_stream *stm = NULL;
 	pdf_image *image = NULL;
-	fz_obj *obj, *res;
+	pdf_obj *obj, *res;
 
 	int w, h, bpc, n;
 	int imagemask;
@@ -321,11 +330,11 @@ pdf_load_image_imp(pdf_document *xref, fz_obj *rdb, fz_obj *dict, fz_stream *cst
 			break; /* Out of fz_try */
 		}
 
-		w = fz_to_int(fz_dict_getsa(dict, "Width", "W"));
-		h = fz_to_int(fz_dict_getsa(dict, "Height", "H"));
-		bpc = fz_to_int(fz_dict_getsa(dict, "BitsPerComponent", "BPC"));
-		imagemask = fz_to_bool(fz_dict_getsa(dict, "ImageMask", "IM"));
-		interpolate = fz_to_bool(fz_dict_getsa(dict, "Interpolate", "I"));
+		w = pdf_to_int(pdf_dict_getsa(dict, "Width", "W"));
+		h = pdf_to_int(pdf_dict_getsa(dict, "Height", "H"));
+		bpc = pdf_to_int(pdf_dict_getsa(dict, "BitsPerComponent", "BPC"));
+		imagemask = pdf_to_bool(pdf_dict_getsa(dict, "ImageMask", "IM"));
+		interpolate = pdf_to_bool(pdf_dict_getsa(dict, "Interpolate", "I"));
 
 		indexed = 0;
 		usecolorkey = 0;
@@ -347,13 +356,13 @@ pdf_load_image_imp(pdf_document *xref, fz_obj *rdb, fz_obj *dict, fz_stream *cst
 		if (h > (1 << 16))
 			fz_throw(ctx, "image is too high");
 
-		obj = fz_dict_getsa(dict, "ColorSpace", "CS");
+		obj = pdf_dict_getsa(dict, "ColorSpace", "CS");
 		if (obj && !imagemask && !forcemask)
 		{
 			/* colorspace resource lookup is only done for inline images */
-			if (fz_is_name(obj))
+			if (pdf_is_name(obj))
 			{
-				res = fz_dict_get(fz_dict_gets(rdb, "ColorSpace"), obj);
+				res = pdf_dict_get(pdf_dict_gets(rdb, "ColorSpace"), obj);
 				if (res)
 					obj = res;
 			}
@@ -371,11 +380,11 @@ pdf_load_image_imp(pdf_document *xref, fz_obj *rdb, fz_obj *dict, fz_stream *cst
 			n = 1;
 		}
 
-		obj = fz_dict_getsa(dict, "Decode", "D");
+		obj = pdf_dict_getsa(dict, "Decode", "D");
 		if (obj)
 		{
 			for (i = 0; i < n * 2; i++)
-				image->decode[i] = fz_to_real(fz_array_get(obj, i));
+				image->decode[i] = pdf_to_real(pdf_array_get(obj, i));
 		}
 		else
 		{
@@ -384,8 +393,8 @@ pdf_load_image_imp(pdf_document *xref, fz_obj *rdb, fz_obj *dict, fz_stream *cst
 				image->decode[i] = i & 1 ? maxval : 0;
 		}
 
-		obj = fz_dict_getsa(dict, "SMask", "Mask");
-		if (fz_is_dict(obj))
+		obj = pdf_dict_getsa(dict, "SMask", "Mask");
+		if (pdf_is_dict(obj))
 		{
 			/* Not allowed for inline images */
 			if (!cstm)
@@ -394,17 +403,17 @@ pdf_load_image_imp(pdf_document *xref, fz_obj *rdb, fz_obj *dict, fz_stream *cst
 				/* RJW: "cannot load image mask/softmask" */
 			}
 		}
-		else if (fz_is_array(obj))
+		else if (pdf_is_array(obj))
 		{
 			usecolorkey = 1;
 			for (i = 0; i < n * 2; i++)
 			{
-				if (!fz_is_int(fz_array_get(obj, i)))
+				if (!pdf_is_int(pdf_array_get(obj, i)))
 				{
 					fz_warn(ctx, "invalid value in color key mask");
 					usecolorkey = 0;
 				}
-				image->colorkey[i] = fz_to_int(fz_array_get(obj, i));
+				image->colorkey[i] = pdf_to_int(pdf_array_get(obj, i));
 			}
 		}
 
@@ -425,7 +434,7 @@ pdf_load_image_imp(pdf_document *xref, fz_obj *rdb, fz_obj *dict, fz_stream *cst
 		{
 			/* Just load the compressed image data now and we can
 			 * decode it on demand. */
-			image->buffer = pdf_load_image_stream(xref, fz_to_num(dict), fz_to_gen(dict), &image->params);
+			image->buffer = pdf_load_image_stream(xref, pdf_to_num(dict), pdf_to_gen(dict), &image->params);
 			break; /* Out of fz_try */
 		}
 
@@ -437,8 +446,8 @@ pdf_load_image_imp(pdf_document *xref, fz_obj *rdb, fz_obj *dict, fz_stream *cst
 		}
 		else
 		{
-			stm = pdf_open_stream(xref, fz_to_num(dict), fz_to_gen(dict));
-			/* RJW: "cannot open image data stream (%d 0 R)", fz_to_num(dict) */
+			stm = pdf_open_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
+			/* RJW: "cannot open image data stream (%d 0 R)", pdf_to_num(dict) */
 		}
 
 		image->tile = decomp_image_from_stream(ctx, stm, image, cstm != NULL, indexed, 1);
@@ -452,35 +461,35 @@ pdf_load_image_imp(pdf_document *xref, fz_obj *rdb, fz_obj *dict, fz_stream *cst
 }
 
 fz_image *
-pdf_load_inline_image(pdf_document *xref, fz_obj *rdb, fz_obj *dict, fz_stream *file)
+pdf_load_inline_image(pdf_document *xref, pdf_obj *rdb, pdf_obj *dict, fz_stream *file)
 {
 	return (fz_image *)pdf_load_image_imp(xref, rdb, dict, file, 0);
 	/* RJW: "cannot load inline image" */
 }
 
 int
-pdf_is_jpx_image(fz_context *ctx, fz_obj *dict)
+pdf_is_jpx_image(fz_context *ctx, pdf_obj *dict)
 {
-	fz_obj *filter;
+	pdf_obj *filter;
 	int i, n;
 
-	filter = fz_dict_gets(dict, "Filter");
-	if (!strcmp(fz_to_name(filter), "JPXDecode"))
+	filter = pdf_dict_gets(dict, "Filter");
+	if (!strcmp(pdf_to_name(filter), "JPXDecode"))
 		return 1;
-	n = fz_array_len(filter);
+	n = pdf_array_len(filter);
 	for (i = 0; i < n; i++)
-		if (!strcmp(fz_to_name(fz_array_get(filter, i)), "JPXDecode"))
+		if (!strcmp(pdf_to_name(pdf_array_get(filter, i)), "JPXDecode"))
 			return 1;
 	return 0;
 }
 
 static void
-pdf_load_jpx(pdf_document *xref, fz_obj *dict, pdf_image *image)
+pdf_load_jpx(pdf_document *xref, pdf_obj *dict, pdf_image *image)
 {
 	fz_buffer *buf = NULL;
 	fz_colorspace *colorspace = NULL;
 	fz_pixmap *img = NULL;
-	fz_obj *obj;
+	pdf_obj *obj;
 	fz_context *ctx = xref->ctx;
 	int indexed = 0;
 
@@ -488,13 +497,13 @@ pdf_load_jpx(pdf_document *xref, fz_obj *dict, pdf_image *image)
 	fz_var(buf);
 	fz_var(colorspace);
 
-	buf = pdf_load_stream(xref, fz_to_num(dict), fz_to_gen(dict));
+	buf = pdf_load_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
 	/* RJW: "cannot load jpx image data" */
 
 	/* FIXME: We can't handle decode arrays for indexed images currently */
 	fz_try(ctx)
 	{
-		obj = fz_dict_gets(dict, "ColorSpace");
+		obj = pdf_dict_gets(dict, "ColorSpace");
 		if (obj)
 		{
 			colorspace = pdf_load_colorspace(xref, obj);
@@ -511,21 +520,21 @@ pdf_load_jpx(pdf_document *xref, fz_obj *dict, pdf_image *image)
 		fz_drop_buffer(ctx, buf);
 		buf = NULL;
 
-		obj = fz_dict_getsa(dict, "SMask", "Mask");
-		if (fz_is_dict(obj))
+		obj = pdf_dict_getsa(dict, "SMask", "Mask");
+		if (pdf_is_dict(obj))
 		{
 			image->base.mask = (fz_image *)pdf_load_image_imp(xref, NULL, obj, NULL, 1);
 			/* RJW: "cannot load image mask/softmask" */
 		}
 
-		obj = fz_dict_getsa(dict, "Decode", "D");
+		obj = pdf_dict_getsa(dict, "Decode", "D");
 		if (obj && !indexed)
 		{
 			float decode[FZ_MAX_COLORS * 2];
 			int i;
 
 			for (i = 0; i < img->n * 2; i++)
-				decode[i] = fz_to_real(fz_array_get(obj, i));
+				decode[i] = pdf_to_real(pdf_array_get(obj, i));
 
 			fz_decode_tile(img, decode);
 		}
@@ -562,7 +571,7 @@ pdf_image_size(fz_context *ctx, pdf_image *im)
 }
 
 fz_image *
-pdf_load_image(pdf_document *xref, fz_obj *dict)
+pdf_load_image(pdf_document *xref, pdf_obj *dict)
 {
 	fz_context *ctx = xref->ctx;
 	pdf_image *image;
@@ -573,7 +582,7 @@ pdf_load_image(pdf_document *xref, fz_obj *dict)
 	}
 
 	image = pdf_load_image_imp(xref, NULL, dict, NULL, 0);
-	/* RJW: "cannot load image (%d 0 R)", fz_to_num(dict) */
+	/* RJW: "cannot load image (%d 0 R)", pdf_to_num(dict) */
 
 	pdf_store_item(ctx, dict, image, pdf_image_size(ctx, image));
 
diff --git a/pdf/pdf_interpret.c b/pdf/pdf_interpret.c
index 1cfe6a96..d2270eaa 100644
--- a/pdf/pdf_interpret.c
+++ b/pdf/pdf_interpret.c
@@ -70,7 +70,7 @@ struct pdf_csi_s
 	char *event; /* "View", "Print", "Export" */
 
 	/* interpreter stack */
-	fz_obj *obj;
+	pdf_obj *obj;
 	char name[256];
 	unsigned char string[256];
 	int string_len;
@@ -104,8 +104,8 @@ struct pdf_csi_s
 	fz_cookie *cookie;
 };
 
-static void pdf_run_buffer(pdf_csi *csi, fz_obj *rdb, fz_buffer *contents);
-static void pdf_run_xobject(pdf_csi *csi, fz_obj *resources, pdf_xobject *xobj, fz_matrix transform);
+static void pdf_run_buffer(pdf_csi *csi, pdf_obj *rdb, fz_buffer *contents);
+static void pdf_run_xobject(pdf_csi *csi, pdf_obj *resources, pdf_xobject *xobj, fz_matrix transform);
 static void pdf_show_pattern(pdf_csi *csi, pdf_pattern *pat, fz_rect area, int what);
 
 static int
@@ -120,20 +120,20 @@ ocg_intents_include(pdf_ocg_descriptor *desc, char *name)
 	if (!desc->intent)
 		return (strcmp(name, "View") == 0);
 
-	if (fz_is_name(desc->intent))
+	if (pdf_is_name(desc->intent))
 	{
-		char *intent = fz_to_name(desc->intent);
+		char *intent = pdf_to_name(desc->intent);
 		if (strcmp(intent, "All") == 0)
 			return 1;
 		return (strcmp(intent, name) == 0);
 	}
-	if (!fz_is_array(desc->intent))
+	if (!pdf_is_array(desc->intent))
 		return 0;
 
-	len = fz_array_len(desc->intent);
+	len = pdf_array_len(desc->intent);
 	for (i=0; i < len; i++)
 	{
-		char *intent = fz_to_name(fz_array_get(desc->intent, i));
+		char *intent = pdf_to_name(pdf_array_get(desc->intent, i));
 		if (strcmp(intent, "All") == 0)
 			return 1;
 		if (strcmp(intent, name) == 0)
@@ -143,10 +143,10 @@ ocg_intents_include(pdf_ocg_descriptor *desc, char *name)
 }
 
 static int
-pdf_is_hidden_ocg(fz_obj *ocg, pdf_csi *csi, fz_obj *rdb)
+pdf_is_hidden_ocg(pdf_obj *ocg, pdf_csi *csi, pdf_obj *rdb)
 {
 	char event_state[16];
-	fz_obj *obj, *obj2;
+	pdf_obj *obj, *obj2;
 	char *type;
 	pdf_ocg_descriptor *desc = csi->xref->ocg;
 
@@ -155,9 +155,9 @@ pdf_is_hidden_ocg(fz_obj *ocg, pdf_csi *csi, fz_obj *rdb)
 		return 0;
 
 	/* If we've been handed a name, look it up in the properties. */
-	if (fz_is_name(ocg))
+	if (pdf_is_name(ocg))
 	{
-		ocg = fz_dict_gets(fz_dict_gets(rdb, "Properties"), fz_to_name(ocg));
+		ocg = pdf_dict_gets(pdf_dict_gets(rdb, "Properties"), pdf_to_name(ocg));
 	}
 	/* If we haven't been given an ocg at all, then we're visible */
 	if (!ocg)
@@ -166,13 +166,13 @@ pdf_is_hidden_ocg(fz_obj *ocg, pdf_csi *csi, fz_obj *rdb)
 	fz_strlcpy(event_state, csi->event, sizeof event_state);
 	fz_strlcat(event_state, "State", sizeof event_state);
 
-	type = fz_to_name(fz_dict_gets(ocg, "Type"));
+	type = pdf_to_name(pdf_dict_gets(ocg, "Type"));
 
 	if (strcmp(type, "OCG") == 0)
 	{
 		/* An Optional Content Group */
-		int num = fz_to_num(ocg);
-		int gen = fz_to_gen(ocg);
+		int num = pdf_to_num(ocg);
+		int gen = pdf_to_gen(ocg);
 		int len = desc->len;
 		int i;
 
@@ -188,19 +188,19 @@ pdf_is_hidden_ocg(fz_obj *ocg, pdf_csi *csi, fz_obj *rdb)
 
 		/* Check Intents; if our intent is not part of the set given
 		 * by the current config, we should ignore it. */
-		obj = fz_dict_gets(ocg, "Intent");
-		if (fz_is_name(obj))
+		obj = pdf_dict_gets(ocg, "Intent");
+		if (pdf_is_name(obj))
 		{
 			/* If it doesn't match, it's hidden */
-			if (ocg_intents_include(desc, fz_to_name(obj)) == 0)
+			if (ocg_intents_include(desc, pdf_to_name(obj)) == 0)
 				return 1;
 		}
-		else if (fz_is_array(obj))
+		else if (pdf_is_array(obj))
 		{
 			int match = 0;
-			len = fz_array_len(obj);
+			len = pdf_array_len(obj);
 			for (i=0; i<len; i++) {
-				match |= ocg_intents_include(desc, fz_to_name(fz_array_get(obj, i)));
+				match |= ocg_intents_include(desc, pdf_to_name(pdf_array_get(obj, i)));
 				if (match)
 					break;
 			}
@@ -224,15 +224,15 @@ pdf_is_hidden_ocg(fz_obj *ocg, pdf_csi *csi, fz_obj *rdb)
 		 * correspond to entries in the AS list in the OCG config.
 		 * Given that we don't handle Zoom or User, or Language
 		 * dicts, this is not really a problem. */
-		obj = fz_dict_gets(ocg, "Usage");
-		if (!fz_is_dict(obj))
+		obj = pdf_dict_gets(ocg, "Usage");
+		if (!pdf_is_dict(obj))
 			return 0;
 		/* FIXME: Should look at Zoom (and return hidden if out of
 		 * max/min range) */
 		/* FIXME: Could provide hooks to the caller to check if
 		 * User is appropriate - if not return hidden. */
-		obj2 = fz_dict_gets(obj, csi->event);
-		if (strcmp(fz_to_name(fz_dict_gets(obj2, event_state)), "OFF") == 0)
+		obj2 = pdf_dict_gets(obj, csi->event);
+		if (strcmp(pdf_to_name(pdf_dict_gets(obj2, event_state)), "OFF") == 0)
 		{
 			return 1;
 		}
@@ -244,12 +244,12 @@ pdf_is_hidden_ocg(fz_obj *ocg, pdf_csi *csi, fz_obj *rdb)
 		char *name;
 		int combine, on;
 
-		obj = fz_dict_gets(ocg, "VE");
-		if (fz_is_array(obj)) {
+		obj = pdf_dict_gets(ocg, "VE");
+		if (pdf_is_array(obj)) {
 			/* FIXME: Calculate visibility from array */
 			return 0;
 		}
-		name = fz_to_name(fz_dict_gets(ocg, "P"));
+		name = pdf_to_name(pdf_dict_gets(ocg, "P"));
 		/* Set combine; Bit 0 set => AND, Bit 1 set => true means
 		 * Off, otherwise true means On */
 		if (strcmp(name, "AllOn") == 0)
@@ -269,15 +269,15 @@ pdf_is_hidden_ocg(fz_obj *ocg, pdf_csi *csi, fz_obj *rdb)
 			combine = 0;
 		}
 
-		obj = fz_dict_gets(ocg, "OCGs");
+		obj = pdf_dict_gets(ocg, "OCGs");
 		on = combine & 1;
-		if (fz_is_array(obj)) {
+		if (pdf_is_array(obj)) {
 			int i, len;
-			len = fz_array_len(obj);
+			len = pdf_array_len(obj);
 			for (i = 0; i < len; i++)
 			{
 				int hidden;
-				hidden = pdf_is_hidden_ocg(fz_array_get(obj, i), csi, rdb);
+				hidden = pdf_is_hidden_ocg(pdf_array_get(obj, i), csi, rdb);
 				if ((combine & 1) == 0)
 					hidden = !hidden;
 				if (combine & 2)
@@ -831,26 +831,26 @@ pdf_show_string(pdf_csi *csi, unsigned char *buf, int len)
 }
 
 static void
-pdf_show_text(pdf_csi *csi, fz_obj *text)
+pdf_show_text(pdf_csi *csi, pdf_obj *text)
 {
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
 	int i;
 
-	if (fz_is_array(text))
+	if (pdf_is_array(text))
 	{
-		int n = fz_array_len(text);
+		int n = pdf_array_len(text);
 		for (i = 0; i < n; i++)
 		{
-			fz_obj *item = fz_array_get(text, i);
-			if (fz_is_string(item))
-				pdf_show_string(csi, (unsigned char *)fz_to_str_buf(item), fz_to_str_len(item));
+			pdf_obj *item = pdf_array_get(text, i);
+			if (pdf_is_string(item))
+				pdf_show_string(csi, (unsigned char *)pdf_to_str_buf(item), pdf_to_str_len(item));
 			else
-				pdf_show_space(csi, - fz_to_real(item) * gstate->size * 0.001f);
+				pdf_show_space(csi, - pdf_to_real(item) * gstate->size * 0.001f);
 		}
 	}
-	else if (fz_is_string(text))
+	else if (pdf_is_string(text))
 	{
-		pdf_show_string(csi, (unsigned char *)fz_to_str_buf(text), fz_to_str_len(text));
+		pdf_show_string(csi, (unsigned char *)pdf_to_str_buf(text), pdf_to_str_len(text));
 	}
 }
 
@@ -1004,7 +1004,7 @@ pdf_clear_stack(pdf_csi *csi)
 	int i;
 
 	if (csi->obj)
-		fz_drop_obj(csi->obj);
+		pdf_drop_obj(csi->obj);
 	csi->obj = NULL;
 
 	csi->name[0] = 0;
@@ -1335,7 +1335,7 @@ pdf_show_pattern(pdf_csi *csi, pdf_pattern *pat, fz_rect area, int what)
 }
 
 static void
-pdf_run_xobject(pdf_csi *csi, fz_obj *resources, pdf_xobject *xobj, fz_matrix transform)
+pdf_run_xobject(pdf_csi *csi, pdf_obj *resources, pdf_xobject *xobj, fz_matrix transform)
 {
 	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gstate = NULL;
@@ -1344,7 +1344,7 @@ pdf_run_xobject(pdf_csi *csi, fz_obj *resources, pdf_xobject *xobj, fz_matrix tr
 	int popmask;
 
 	/* Avoid infinite recursion */
-	if (xobj == NULL || fz_dict_mark(xobj->me))
+	if (xobj == NULL || pdf_dict_mark(xobj->me))
 		return;
 
 	fz_var(gstate);
@@ -1425,7 +1425,7 @@ pdf_run_xobject(pdf_csi *csi, fz_obj *resources, pdf_xobject *xobj, fz_matrix tr
 			pdf_grestore(csi);
 		}
 
-		fz_dict_unmark(xobj->me);
+		pdf_dict_unmark(xobj->me);
 	}
 	fz_catch(ctx)
 	{
@@ -1442,7 +1442,7 @@ pdf_run_xobject(pdf_csi *csi, fz_obj *resources, pdf_xobject *xobj, fz_matrix tr
 }
 
 static void
-pdf_run_extgstate(pdf_csi *csi, fz_obj *rdb, fz_obj *extgstate)
+pdf_run_extgstate(pdf_csi *csi, pdf_obj *rdb, pdf_obj *extgstate)
 {
 	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
@@ -1451,18 +1451,18 @@ pdf_run_extgstate(pdf_csi *csi, fz_obj *rdb, fz_obj *extgstate)
 
 	pdf_flush_text(csi);
 
-	n = fz_dict_len(extgstate);
+	n = pdf_dict_len(extgstate);
 	for (i = 0; i < n; i++)
 	{
-		fz_obj *key = fz_dict_get_key(extgstate, i);
-		fz_obj *val = fz_dict_get_val(extgstate, i);
-		char *s = fz_to_name(key);
+		pdf_obj *key = pdf_dict_get_key(extgstate, i);
+		pdf_obj *val = pdf_dict_get_val(extgstate, i);
+		char *s = pdf_to_name(key);
 
 		if (!strcmp(s, "Font"))
 		{
-			if (fz_is_array(val) && fz_array_len(val) == 2)
+			if (pdf_is_array(val) && pdf_array_len(val) == 2)
 			{
-				fz_obj *font = fz_array_get(val, 0);
+				pdf_obj *font = pdf_array_get(val, 0);
 
 				if (gstate->font)
 				{
@@ -1471,10 +1471,10 @@ pdf_run_extgstate(pdf_csi *csi, fz_obj *rdb, fz_obj *extgstate)
 				}
 
 				gstate->font = pdf_load_font(csi->xref, rdb, font);
-				/* RJW: "cannot load font (%d %d R)", fz_to_num(font), fz_to_gen(font) */
+				/* RJW: "cannot load font (%d %d R)", pdf_to_num(font), pdf_to_gen(font) */
 				if (!gstate->font)
 					fz_throw(ctx, "cannot find font in store");
-				gstate->size = fz_to_real(fz_array_get(val, 1));
+				gstate->size = pdf_to_real(pdf_array_get(val, 1));
 			}
 			else
 				fz_throw(ctx, "malformed /Font dictionary");
@@ -1483,59 +1483,59 @@ pdf_run_extgstate(pdf_csi *csi, fz_obj *rdb, fz_obj *extgstate)
 		else if (!strcmp(s, "LC"))
 		{
 			csi->dev->flags &= ~(FZ_DEVFLAG_STARTCAP_UNDEFINED | FZ_DEVFLAG_DASHCAP_UNDEFINED | FZ_DEVFLAG_ENDCAP_UNDEFINED);
-			gstate->stroke_state.start_cap = fz_to_int(val);
-			gstate->stroke_state.dash_cap = fz_to_int(val);
-			gstate->stroke_state.end_cap = fz_to_int(val);
+			gstate->stroke_state.start_cap = pdf_to_int(val);
+			gstate->stroke_state.dash_cap = pdf_to_int(val);
+			gstate->stroke_state.end_cap = pdf_to_int(val);
 		}
 		else if (!strcmp(s, "LW"))
 		{
 			csi->dev->flags &= ~FZ_DEVFLAG_LINEWIDTH_UNDEFINED;
-			gstate->stroke_state.linewidth = fz_to_real(val);
+			gstate->stroke_state.linewidth = pdf_to_real(val);
 		}
 		else if (!strcmp(s, "LJ"))
 		{
 			csi->dev->flags &= ~FZ_DEVFLAG_LINEJOIN_UNDEFINED;
-			gstate->stroke_state.linejoin = fz_to_int(val);
+			gstate->stroke_state.linejoin = pdf_to_int(val);
 		}
 		else if (!strcmp(s, "ML"))
 		{
 			csi->dev->flags &= ~FZ_DEVFLAG_MITERLIMIT_UNDEFINED;
-			gstate->stroke_state.miterlimit = fz_to_real(val);
+			gstate->stroke_state.miterlimit = pdf_to_real(val);
 		}
 
 		else if (!strcmp(s, "D"))
 		{
-			if (fz_is_array(val) && fz_array_len(val) == 2)
+			if (pdf_is_array(val) && pdf_array_len(val) == 2)
 			{
-				fz_obj *dashes = fz_array_get(val, 0);
-				gstate->stroke_state.dash_len = MAX(fz_array_len(dashes), 32);
+				pdf_obj *dashes = pdf_array_get(val, 0);
+				gstate->stroke_state.dash_len = MAX(pdf_array_len(dashes), 32);
 				for (k = 0; k < gstate->stroke_state.dash_len; k++)
-					gstate->stroke_state.dash_list[k] = fz_to_real(fz_array_get(dashes, k));
-				gstate->stroke_state.dash_phase = fz_to_real(fz_array_get(val, 1));
+					gstate->stroke_state.dash_list[k] = pdf_to_real(pdf_array_get(dashes, k));
+				gstate->stroke_state.dash_phase = pdf_to_real(pdf_array_get(val, 1));
 			}
 			else
 				fz_throw(ctx, "malformed /D");
 		}
 
 		else if (!strcmp(s, "CA"))
-			gstate->stroke.alpha = fz_to_real(val);
+			gstate->stroke.alpha = pdf_to_real(val);
 
 		else if (!strcmp(s, "ca"))
-			gstate->fill.alpha = fz_to_real(val);
+			gstate->fill.alpha = pdf_to_real(val);
 
 		else if (!strcmp(s, "BM"))
 		{
-			if (fz_is_array(val))
-				val = fz_array_get(val, 0);
-			gstate->blendmode = fz_find_blendmode(fz_to_name(val));
+			if (pdf_is_array(val))
+				val = pdf_array_get(val, 0);
+			gstate->blendmode = fz_find_blendmode(pdf_to_name(val));
 		}
 
 		else if (!strcmp(s, "SMask"))
 		{
-			if (fz_is_dict(val))
+			if (pdf_is_dict(val))
 			{
 				pdf_xobject *xobj;
-				fz_obj *group, *luminosity, *bc;
+				pdf_obj *group, *luminosity, *bc;
 
 				if (gstate->softmask)
 				{
@@ -1543,11 +1543,11 @@ pdf_run_extgstate(pdf_csi *csi, fz_obj *rdb, fz_obj *extgstate)
 					gstate->softmask = NULL;
 				}
 
-				group = fz_dict_gets(val, "G");
+				group = pdf_dict_gets(val, "G");
 				if (!group)
-					fz_throw(ctx, "cannot load softmask xobject (%d %d R)", fz_to_num(val), fz_to_gen(val));
+					fz_throw(ctx, "cannot load softmask xobject (%d %d R)", pdf_to_num(val), pdf_to_gen(val));
 				xobj = pdf_load_xobject(csi->xref, group);
-				/* RJW: "cannot load xobject (%d %d R)", fz_to_num(val), fz_to_gen(val) */
+				/* RJW: "cannot load xobject (%d %d R)", pdf_to_num(val), pdf_to_gen(val) */
 
 				colorspace = xobj->colorspace;
 				if (!colorspace)
@@ -1558,20 +1558,20 @@ pdf_run_extgstate(pdf_csi *csi, fz_obj *rdb, fz_obj *extgstate)
 				for (k = 0; k < colorspace->n; k++)
 					gstate->softmask_bc[k] = 0;
 
-				bc = fz_dict_gets(val, "BC");
-				if (fz_is_array(bc))
+				bc = pdf_dict_gets(val, "BC");
+				if (pdf_is_array(bc))
 				{
 					for (k = 0; k < colorspace->n; k++)
-						gstate->softmask_bc[k] = fz_to_real(fz_array_get(bc, k));
+						gstate->softmask_bc[k] = pdf_to_real(pdf_array_get(bc, k));
 				}
 
-				luminosity = fz_dict_gets(val, "S");
-				if (fz_is_name(luminosity) && !strcmp(fz_to_name(luminosity), "Luminosity"))
+				luminosity = pdf_dict_gets(val, "S");
+				if (pdf_is_name(luminosity) && !strcmp(pdf_to_name(luminosity), "Luminosity"))
 					gstate->luminosity = 1;
 				else
 					gstate->luminosity = 0;
 			}
-			else if (fz_is_name(val) && !strcmp(fz_to_name(val), "None"))
+			else if (pdf_is_name(val) && !strcmp(pdf_to_name(val), "None"))
 			{
 				if (gstate->softmask)
 				{
@@ -1583,7 +1583,7 @@ pdf_run_extgstate(pdf_csi *csi, fz_obj *rdb, fz_obj *extgstate)
 
 		else if (!strcmp(s, "TR"))
 		{
-			if (!fz_is_name(val) || strcmp(fz_to_name(val), "Identity"))
+			if (!pdf_is_name(val) || strcmp(pdf_to_name(val), "Identity"))
 				fz_warn(ctx, "ignoring transfer function");
 		}
 	}
@@ -1593,9 +1593,9 @@ pdf_run_extgstate(pdf_csi *csi, fz_obj *rdb, fz_obj *extgstate)
  * Operators
  */
 
-static void pdf_run_BDC(pdf_csi *csi, fz_obj *rdb)
+static void pdf_run_BDC(pdf_csi *csi, pdf_obj *rdb)
 {
-	fz_obj *ocg;
+	pdf_obj *ocg;
 
 	/* If we are already in a hidden OCG, then we'll still be hidden -
 	 * just increment the depth so we pop back to visibility when we've
@@ -1606,14 +1606,14 @@ static void pdf_run_BDC(pdf_csi *csi, fz_obj *rdb)
 		return;
 	}
 
-	ocg = fz_dict_gets(fz_dict_gets(rdb, "Properties"), csi->name);
+	ocg = pdf_dict_gets(pdf_dict_gets(rdb, "Properties"), csi->name);
 	if (!ocg)
 	{
 		/* No Properties array, or name not found in the properties
 		 * means visible. */
 		return;
 	}
-	if (strcmp(fz_to_name(fz_dict_gets(ocg, "Type")), "OCG") != 0)
+	if (strcmp(pdf_to_name(pdf_dict_gets(ocg, "Type")), "OCG") != 0)
 	{
 		/* Wrong type of property */
 		return;
@@ -1622,12 +1622,12 @@ static void pdf_run_BDC(pdf_csi *csi, fz_obj *rdb)
 		csi->in_hidden_ocg++;
 }
 
-static void pdf_run_BI(pdf_csi *csi, fz_obj *rdb, fz_stream *file)
+static void pdf_run_BI(pdf_csi *csi, pdf_obj *rdb, fz_stream *file)
 {
 	fz_context *ctx = csi->dev->ctx;
 	int ch;
 	fz_image *img;
-	fz_obj *obj;
+	pdf_obj *obj;
 
 	obj = pdf_parse_dict(csi->xref, file, &csi->xref->lexbuf.base);
 	/* RJW: "cannot parse inline image dictionary" */
@@ -1639,7 +1639,7 @@ static void pdf_run_BI(pdf_csi *csi, fz_obj *rdb, fz_stream *file)
 			fz_read_byte(file);
 
 	img = pdf_load_inline_image(csi->xref, rdb, obj, file);
-	fz_drop_obj(obj);
+	pdf_drop_obj(obj);
 	/* RJW: "cannot load inline image" */
 
 	pdf_show_image(csi, img);
@@ -1688,11 +1688,11 @@ static void pdf_run_Bstar(pdf_csi *csi)
 	pdf_show_path(csi, 0, 1, 1, 1);
 }
 
-static void pdf_run_cs_imp(pdf_csi *csi, fz_obj *rdb, int what)
+static void pdf_run_cs_imp(pdf_csi *csi, pdf_obj *rdb, int what)
 {
 	fz_context *ctx = csi->dev->ctx;
 	fz_colorspace *colorspace;
-	fz_obj *obj, *dict;
+	pdf_obj *obj, *dict;
 
 	if (!strcmp(csi->name, "Pattern"))
 	{
@@ -1708,14 +1708,14 @@ static void pdf_run_cs_imp(pdf_csi *csi, fz_obj *rdb, int what)
 			colorspace = fz_device_cmyk; /* No fz_keep_colorspace as static */
 		else
 		{
-			dict = fz_dict_gets(rdb, "ColorSpace");
+			dict = pdf_dict_gets(rdb, "ColorSpace");
 			if (!dict)
 				fz_throw(ctx, "cannot find ColorSpace dictionary");
-			obj = fz_dict_gets(dict, csi->name);
+			obj = pdf_dict_gets(dict, csi->name);
 			if (!obj)
 				fz_throw(ctx, "cannot find colorspace resource '%s'", csi->name);
 			colorspace = pdf_load_colorspace(csi->xref, obj);
-			/* RJW: "cannot load colorspace (%d 0 R)", fz_to_num(obj) */
+			/* RJW: "cannot load colorspace (%d 0 R)", pdf_to_num(obj) */
 		}
 
 		pdf_set_colorspace(csi, what, colorspace);
@@ -1724,7 +1724,7 @@ static void pdf_run_cs_imp(pdf_csi *csi, fz_obj *rdb, int what)
 	}
 }
 
-static void pdf_run_CS(pdf_csi *csi, fz_obj *rdb)
+static void pdf_run_CS(pdf_csi *csi, pdf_obj *rdb)
 {
 	csi->dev->flags &= ~FZ_DEVFLAG_STROKECOLOR_UNDEFINED;
 
@@ -1732,7 +1732,7 @@ static void pdf_run_CS(pdf_csi *csi, fz_obj *rdb)
 	/* RJW: "cannot set colorspace" */
 }
 
-static void pdf_run_cs(pdf_csi *csi, fz_obj *rdb)
+static void pdf_run_cs(pdf_csi *csi, pdf_obj *rdb)
 {
 	csi->dev->flags &= ~FZ_DEVFLAG_FILLCOLOR_UNDEFINED;
 
@@ -1744,41 +1744,41 @@ static void pdf_run_DP(pdf_csi *csi)
 {
 }
 
-static void pdf_run_Do(pdf_csi *csi, fz_obj *rdb)
+static void pdf_run_Do(pdf_csi *csi, pdf_obj *rdb)
 {
 	fz_context *ctx = csi->dev->ctx;
-	fz_obj *dict;
-	fz_obj *obj;
-	fz_obj *subtype;
+	pdf_obj *dict;
+	pdf_obj *obj;
+	pdf_obj *subtype;
 
-	dict = fz_dict_gets(rdb, "XObject");
+	dict = pdf_dict_gets(rdb, "XObject");
 	if (!dict)
 		fz_throw(ctx, "cannot find XObject dictionary when looking for: '%s'", csi->name);
 
-	obj = fz_dict_gets(dict, csi->name);
+	obj = pdf_dict_gets(dict, csi->name);
 	if (!obj)
 		fz_throw(ctx, "cannot find xobject resource: '%s'", csi->name);
 
-	subtype = fz_dict_gets(obj, "Subtype");
-	if (!fz_is_name(subtype))
+	subtype = pdf_dict_gets(obj, "Subtype");
+	if (!pdf_is_name(subtype))
 		fz_throw(ctx, "no XObject subtype specified");
 
-	if (pdf_is_hidden_ocg(fz_dict_gets(obj, "OC"), csi, rdb))
+	if (pdf_is_hidden_ocg(pdf_dict_gets(obj, "OC"), csi, rdb))
 		return;
 
-	if (!strcmp(fz_to_name(subtype), "Form") && fz_dict_gets(obj, "Subtype2"))
-		subtype = fz_dict_gets(obj, "Subtype2");
+	if (!strcmp(pdf_to_name(subtype), "Form") && pdf_dict_gets(obj, "Subtype2"))
+		subtype = pdf_dict_gets(obj, "Subtype2");
 
-	if (!strcmp(fz_to_name(subtype), "Form"))
+	if (!strcmp(pdf_to_name(subtype), "Form"))
 	{
 		pdf_xobject *xobj;
 
 		xobj = pdf_load_xobject(csi->xref, obj);
-		/* RJW: "cannot load xobject (%d %d R)", fz_to_num(obj), fz_to_gen(obj) */
+		/* RJW: "cannot load xobject (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj) */
 
 		/* Inherit parent resources, in case this one was empty XXX check where it's loaded */
 		if (!xobj->resources)
-			xobj->resources = fz_keep_obj(rdb);
+			xobj->resources = pdf_keep_obj(rdb);
 
 		fz_try(ctx)
 		{
@@ -1787,18 +1787,18 @@ static void pdf_run_Do(pdf_csi *csi, fz_obj *rdb)
 		fz_catch(ctx)
 		{
 			pdf_drop_xobject(ctx, xobj);
-			fz_throw(ctx, "cannot draw xobject (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+			fz_throw(ctx, "cannot draw xobject (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj));
 		}
 
 		pdf_drop_xobject(ctx, xobj);
 	}
 
-	else if (!strcmp(fz_to_name(subtype), "Image"))
+	else if (!strcmp(pdf_to_name(subtype), "Image"))
 	{
 		if ((csi->dev->hints & FZ_IGNORE_IMAGE) == 0)
 		{
 			fz_image *img = pdf_load_image(csi->xref, obj);
-			/* RJW: "cannot load image (%d %d R)", fz_to_num(obj), fz_to_gen(obj) */
+			/* RJW: "cannot load image (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj) */
 			fz_try(ctx)
 			{
 				pdf_show_image(csi, img);
@@ -1814,14 +1814,14 @@ static void pdf_run_Do(pdf_csi *csi, fz_obj *rdb)
 		}
 	}
 
-	else if (!strcmp(fz_to_name(subtype), "PS"))
+	else if (!strcmp(pdf_to_name(subtype), "PS"))
 	{
 		fz_warn(ctx, "ignoring XObject with subtype PS");
 	}
 
 	else
 	{
-		fz_throw(ctx, "unknown XObject subtype: '%s'", fz_to_name(subtype));
+		fz_throw(ctx, "unknown XObject subtype: '%s'", pdf_to_name(subtype));
 	}
 }
 
@@ -1899,12 +1899,12 @@ static void pdf_run_S(pdf_csi *csi)
 	pdf_show_path(csi, 0, 0, 1, 0);
 }
 
-static void pdf_run_SC_imp(pdf_csi *csi, fz_obj *rdb, int what, pdf_material *mat)
+static void pdf_run_SC_imp(pdf_csi *csi, pdf_obj *rdb, int what, pdf_material *mat)
 {
 	fz_context *ctx = csi->dev->ctx;
-	fz_obj *patterntype;
-	fz_obj *dict;
-	fz_obj *obj;
+	pdf_obj *patterntype;
+	pdf_obj *dict;
+	pdf_obj *obj;
 	int kind;
 
 	kind = mat->kind;
@@ -1921,35 +1921,35 @@ static void pdf_run_SC_imp(pdf_csi *csi, fz_obj *rdb, int what, pdf_material *ma
 		break;
 
 	case PDF_MAT_PATTERN:
-		dict = fz_dict_gets(rdb, "Pattern");
+		dict = pdf_dict_gets(rdb, "Pattern");
 		if (!dict)
 			fz_throw(ctx, "cannot find Pattern dictionary");
 
-		obj = fz_dict_gets(dict, csi->name);
+		obj = pdf_dict_gets(dict, csi->name);
 		if (!obj)
 			fz_throw(ctx, "cannot find pattern resource '%s'", csi->name);
 
-		patterntype = fz_dict_gets(obj, "PatternType");
+		patterntype = pdf_dict_gets(obj, "PatternType");
 
-		if (fz_to_int(patterntype) == 1)
+		if (pdf_to_int(patterntype) == 1)
 		{
 			pdf_pattern *pat;
 			pat = pdf_load_pattern(csi->xref, obj);
-			/* RJW: "cannot load pattern (%d 0 R)", fz_to_num(obj) */
+			/* RJW: "cannot load pattern (%d 0 R)", pdf_to_num(obj) */
 			pdf_set_pattern(csi, what, pat, csi->top > 0 ? csi->stack : NULL);
 			pdf_drop_pattern(ctx, pat);
 		}
-		else if (fz_to_int(patterntype) == 2)
+		else if (pdf_to_int(patterntype) == 2)
 		{
 			fz_shade *shd;
 			shd = pdf_load_shading(csi->xref, obj);
-			/* RJW: "cannot load shading (%d 0 R)", fz_to_num(obj) */
+			/* RJW: "cannot load shading (%d 0 R)", pdf_to_num(obj) */
 			pdf_set_shade(csi, what, shd);
 			fz_drop_shade(ctx, shd);
 		}
 		else
 		{
-			fz_throw(ctx, "unknown pattern type: %d", fz_to_int(patterntype));
+			fz_throw(ctx, "unknown pattern type: %d", pdf_to_int(patterntype));
 		}
 		break;
 
@@ -1958,7 +1958,7 @@ static void pdf_run_SC_imp(pdf_csi *csi, fz_obj *rdb, int what, pdf_material *ma
 	}
 }
 
-static void pdf_run_SC(pdf_csi *csi, fz_obj *rdb)
+static void pdf_run_SC(pdf_csi *csi, pdf_obj *rdb)
 {
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
 	csi->dev->flags &= ~FZ_DEVFLAG_STROKECOLOR_UNDEFINED;
@@ -1966,7 +1966,7 @@ static void pdf_run_SC(pdf_csi *csi, fz_obj *rdb)
 	/* RJW: "cannot set color and colorspace" */
 }
 
-static void pdf_run_sc(pdf_csi *csi, fz_obj *rdb)
+static void pdf_run_sc(pdf_csi *csi, pdf_obj *rdb)
 {
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
 	csi->dev->flags &= ~FZ_DEVFLAG_FILLCOLOR_UNDEFINED;
@@ -2000,28 +2000,28 @@ static void pdf_run_TL(pdf_csi *csi)
 	gstate->leading = csi->stack[0];
 }
 
-static void pdf_run_Tf(pdf_csi *csi, fz_obj *rdb)
+static void pdf_run_Tf(pdf_csi *csi, pdf_obj *rdb)
 {
 	fz_context *ctx = csi->dev->ctx;
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
-	fz_obj *dict;
-	fz_obj *obj;
+	pdf_obj *dict;
+	pdf_obj *obj;
 
 	gstate->size = csi->stack[0];
 	if (gstate->font)
 		pdf_drop_font(ctx, gstate->font);
 	gstate->font = NULL;
 
-	dict = fz_dict_gets(rdb, "Font");
+	dict = pdf_dict_gets(rdb, "Font");
 	if (!dict)
 		fz_throw(ctx, "cannot find Font dictionary");
 
-	obj = fz_dict_gets(dict, csi->name);
+	obj = pdf_dict_gets(dict, csi->name);
 	if (!obj)
 		fz_throw(ctx, "cannot find font resource: '%s'", csi->name);
 
 	gstate->font = pdf_load_font(csi->xref, rdb, obj);
-	/* RJW: "cannot load font (%d 0 R)", fz_to_num(obj) */
+	/* RJW: "cannot load font (%d 0 R)", pdf_to_num(obj) */
 }
 
 static void pdf_run_Tr(pdf_csi *csi)
@@ -2141,13 +2141,13 @@ static void pdf_run_cm(pdf_csi *csi)
 static void pdf_run_d(pdf_csi *csi)
 {
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
-	fz_obj *array;
+	pdf_obj *array;
 	int i;
 
 	array = csi->obj;
-	gstate->stroke_state.dash_len = MIN(fz_array_len(array), nelem(gstate->stroke_state.dash_list));
+	gstate->stroke_state.dash_len = MIN(pdf_array_len(array), nelem(gstate->stroke_state.dash_list));
 	for (i = 0; i < gstate->stroke_state.dash_len; i++)
-		gstate->stroke_state.dash_list[i] = fz_to_real(fz_array_get(array, i));
+		gstate->stroke_state.dash_list[i] = pdf_to_real(pdf_array_get(array, i));
 	gstate->stroke_state.dash_phase = csi->stack[0];
 }
 
@@ -2186,22 +2186,22 @@ static void pdf_run_g(pdf_csi *csi)
 	pdf_set_color(csi, PDF_FILL, csi->stack);
 }
 
-static void pdf_run_gs(pdf_csi *csi, fz_obj *rdb)
+static void pdf_run_gs(pdf_csi *csi, pdf_obj *rdb)
 {
-	fz_obj *dict;
-	fz_obj *obj;
+	pdf_obj *dict;
+	pdf_obj *obj;
 	fz_context *ctx = csi->dev->ctx;
 
-	dict = fz_dict_gets(rdb, "ExtGState");
+	dict = pdf_dict_gets(rdb, "ExtGState");
 	if (!dict)
 		fz_throw(ctx, "cannot find ExtGState dictionary");
 
-	obj = fz_dict_gets(dict, csi->name);
+	obj = pdf_dict_gets(dict, csi->name);
 	if (!obj)
 		fz_throw(ctx, "cannot find extgstate resource '%s'", csi->name);
 
 	pdf_run_extgstate(csi, rdb, obj);
-	/* RJW: "cannot set ExtGState (%d 0 R)", fz_to_num(obj) */
+	/* RJW: "cannot set ExtGState (%d 0 R)", pdf_to_num(obj) */
 }
 
 static void pdf_run_h(pdf_csi *csi)
@@ -2286,25 +2286,25 @@ static void pdf_run(pdf_csi *csi)
 	pdf_show_path(csi, 1, 0, 1, 0);
 }
 
-static void pdf_run_sh(pdf_csi *csi, fz_obj *rdb)
+static void pdf_run_sh(pdf_csi *csi, pdf_obj *rdb)
 {
 	fz_context *ctx = csi->dev->ctx;
-	fz_obj *dict;
-	fz_obj *obj;
+	pdf_obj *dict;
+	pdf_obj *obj;
 	fz_shade *shd;
 
-	dict = fz_dict_gets(rdb, "Shading");
+	dict = pdf_dict_gets(rdb, "Shading");
 	if (!dict)
 		fz_throw(ctx, "cannot find shading dictionary");
 
-	obj = fz_dict_gets(dict, csi->name);
+	obj = pdf_dict_gets(dict, csi->name);
 	if (!obj)
 		fz_throw(ctx, "cannot find shading resource: '%s'", csi->name);
 
 	if ((csi->dev->hints & FZ_IGNORE_SHADE) == 0)
 	{
 		shd = pdf_load_shading(csi->xref, obj);
-		/* RJW: "cannot load shading (%d %d R)", fz_to_num(obj), fz_to_gen(obj) */
+		/* RJW: "cannot load shading (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj) */
 		fz_try(ctx)
 		{
 			pdf_show_shade(csi, shd);
@@ -2384,7 +2384,7 @@ static void pdf_run_dquote(pdf_csi *csi)
 #define C(a,b,c) (a | b << 8 | c << 16)
 
 static void
-pdf_run_keyword(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf)
+pdf_run_keyword(pdf_csi *csi, pdf_obj *rdb, fz_stream *file, char *buf)
 {
 	fz_context *ctx = csi->dev->ctx;
 	int key;
@@ -2522,7 +2522,7 @@ pdf_run_keyword(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf)
 }
 
 static void
-pdf_run_stream(pdf_csi *csi, fz_obj *rdb, fz_stream *file, pdf_lexbuf *buf)
+pdf_run_stream(pdf_csi *csi, pdf_obj *rdb, fz_stream *file, pdf_lexbuf *buf)
 {
 	fz_context *ctx = csi->dev->ctx;
 	int tok, in_array;
@@ -2631,7 +2631,7 @@ pdf_run_stream(pdf_csi *csi, fz_obj *rdb, fz_stream *file, pdf_lexbuf *buf)
 			}
 			else
 			{
-				csi->obj = fz_new_string(ctx, buf->scratch, buf->len);
+				csi->obj = pdf_new_string(ctx, buf->scratch, buf->len);
 			}
 			break;
 
@@ -2652,7 +2652,7 @@ pdf_run_stream(pdf_csi *csi, fz_obj *rdb, fz_stream *file, pdf_lexbuf *buf)
  */
 
 static void
-pdf_run_buffer(pdf_csi *csi, fz_obj *rdb, fz_buffer *contents)
+pdf_run_buffer(pdf_csi *csi, pdf_obj *rdb, fz_buffer *contents)
 {
 	fz_context *ctx = csi->dev->ctx;
 	pdf_lexbuf_large *buf;
@@ -2736,7 +2736,7 @@ pdf_run_page_with_usage(pdf_document *xref, pdf_page *page, fz_device *dev, fz_m
 			cookie->progress++;
 		}
 
-		flags = fz_to_int(fz_dict_gets(annot->obj, "F"));
+		flags = pdf_to_int(pdf_dict_gets(annot->obj, "F"));
 
 		/* TODO: NoZoom and NoRotate */
 		if (flags & (1 << 0)) /* Invisible */
@@ -2749,7 +2749,7 @@ pdf_run_page_with_usage(pdf_document *xref, pdf_page *page, fz_device *dev, fz_m
 			continue;
 
 		csi = pdf_new_csi(xref, dev, ctm, event, cookie, NULL);
-		if (!pdf_is_hidden_ocg(fz_dict_gets(annot->obj, "OC"), csi, page->resources))
+		if (!pdf_is_hidden_ocg(pdf_dict_gets(annot->obj, "OC"), csi, page->resources))
 		{
 			fz_try(ctx)
 			{
@@ -2775,7 +2775,7 @@ pdf_run_page(pdf_document *xref, pdf_page *page, fz_device *dev, fz_matrix ctm,
 }
 
 void
-pdf_run_glyph(pdf_document *xref, fz_obj *resources, fz_buffer *contents, fz_device *dev, fz_matrix ctm, void *gstate)
+pdf_run_glyph(pdf_document *xref, pdf_obj *resources, fz_buffer *contents, fz_device *dev, fz_matrix ctm, void *gstate)
 {
 	pdf_csi *csi = pdf_new_csi(xref, dev, ctm, "View", NULL, gstate);
 	fz_context *ctx = xref->ctx;
diff --git a/pdf/pdf_nametree.c b/pdf/pdf_nametree.c
index c78e238d..98a10241 100644
--- a/pdf/pdf_nametree.c
+++ b/pdf/pdf_nametree.c
@@ -1,55 +1,55 @@
 #include "fitz.h"
 #include "mupdf.h"
 
-static fz_obj *
-pdf_lookup_name_imp(fz_context *ctx, fz_obj *node, fz_obj *needle)
+static pdf_obj *
+pdf_lookup_name_imp(fz_context *ctx, pdf_obj *node, pdf_obj *needle)
 {
-	fz_obj *kids = fz_dict_gets(node, "Kids");
-	fz_obj *names = fz_dict_gets(node, "Names");
+	pdf_obj *kids = pdf_dict_gets(node, "Kids");
+	pdf_obj *names = pdf_dict_gets(node, "Names");
 
-	if (fz_is_array(kids))
+	if (pdf_is_array(kids))
 	{
 		int l = 0;
-		int r = fz_array_len(kids) - 1;
+		int r = pdf_array_len(kids) - 1;
 
 		while (l <= r)
 		{
 			int m = (l + r) >> 1;
-			fz_obj *kid = fz_array_get(kids, m);
-			fz_obj *limits = fz_dict_gets(kid, "Limits");
-			fz_obj *first = fz_array_get(limits, 0);
-			fz_obj *last = fz_array_get(limits, 1);
+			pdf_obj *kid = pdf_array_get(kids, m);
+			pdf_obj *limits = pdf_dict_gets(kid, "Limits");
+			pdf_obj *first = pdf_array_get(limits, 0);
+			pdf_obj *last = pdf_array_get(limits, 1);
 
-			if (fz_objcmp(needle, first) < 0)
+			if (pdf_objcmp(needle, first) < 0)
 				r = m - 1;
-			else if (fz_objcmp(needle, last) > 0)
+			else if (pdf_objcmp(needle, last) > 0)
 				l = m + 1;
 			else
 			{
-				fz_obj *obj;
+				pdf_obj *obj;
 
-				if (fz_dict_mark(node))
+				if (pdf_dict_mark(node))
 					break;
 				obj = pdf_lookup_name_imp(ctx, kid, needle);
-				fz_dict_unmark(node);
+				pdf_dict_unmark(node);
 				return obj;
 			}
 		}
 	}
 
-	if (fz_is_array(names))
+	if (pdf_is_array(names))
 	{
 		int l = 0;
-		int r = (fz_array_len(names) / 2) - 1;
+		int r = (pdf_array_len(names) / 2) - 1;
 
 		while (l <= r)
 		{
 			int m = (l + r) >> 1;
 			int c;
-			fz_obj *key = fz_array_get(names, m * 2);
-			fz_obj *val = fz_array_get(names, m * 2 + 1);
+			pdf_obj *key = pdf_array_get(names, m * 2);
+			pdf_obj *val = pdf_array_get(names, m * 2 + 1);
 
-			c = fz_objcmp(needle, key);
+			c = pdf_objcmp(needle, key);
 			if (c < 0)
 				r = m - 1;
 			else if (c > 0)
@@ -61,49 +61,49 @@ pdf_lookup_name_imp(fz_context *ctx, fz_obj *node, fz_obj *needle)
 		/* Spec says names should be sorted (hence the binary search,
 		 * above), but Acrobat copes with non-sorted. Drop back to a
 		 * simple search if the binary search fails. */
-		r = fz_array_len(names)/2;
+		r = pdf_array_len(names)/2;
 		for (l = 0; l < r; l++)
-			if (!fz_objcmp(needle, fz_array_get(names, l * 2)))
-				return fz_array_get(names, l * 2 + 1);
+			if (!pdf_objcmp(needle, pdf_array_get(names, l * 2)))
+				return pdf_array_get(names, l * 2 + 1);
 	}
 
 	return NULL;
 }
 
-fz_obj *
-pdf_lookup_name(pdf_document *xref, char *which, fz_obj *needle)
+pdf_obj *
+pdf_lookup_name(pdf_document *xref, char *which, pdf_obj *needle)
 {
 	fz_context *ctx = xref->ctx;
 
-	fz_obj *root = fz_dict_gets(xref->trailer, "Root");
-	fz_obj *names = fz_dict_gets(root, "Names");
-	fz_obj *tree = fz_dict_gets(names, which);
+	pdf_obj *root = pdf_dict_gets(xref->trailer, "Root");
+	pdf_obj *names = pdf_dict_gets(root, "Names");
+	pdf_obj *tree = pdf_dict_gets(names, which);
 	return pdf_lookup_name_imp(ctx, tree, needle);
 }
 
-fz_obj *
-pdf_lookup_dest(pdf_document *xref, fz_obj *needle)
+pdf_obj *
+pdf_lookup_dest(pdf_document *xref, pdf_obj *needle)
 {
 	fz_context *ctx = xref->ctx;
 
-	fz_obj *root = fz_dict_gets(xref->trailer, "Root");
-	fz_obj *dests = fz_dict_gets(root, "Dests");
-	fz_obj *names = fz_dict_gets(root, "Names");
-	fz_obj *dest = NULL;
+	pdf_obj *root = pdf_dict_gets(xref->trailer, "Root");
+	pdf_obj *dests = pdf_dict_gets(root, "Dests");
+	pdf_obj *names = pdf_dict_gets(root, "Names");
+	pdf_obj *dest = NULL;
 
 	/* PDF 1.1 has destinations in a dictionary */
 	if (dests)
 	{
-		if (fz_is_name(needle))
-			return fz_dict_get(dests, needle);
+		if (pdf_is_name(needle))
+			return pdf_dict_get(dests, needle);
 		else
-			return fz_dict_gets(dests, fz_to_str_buf(needle));
+			return pdf_dict_gets(dests, pdf_to_str_buf(needle));
 	}
 
 	/* PDF 1.2 has destinations in a name tree */
 	if (names && !dest)
 	{
-		fz_obj *tree = fz_dict_gets(names, "Dests");
+		pdf_obj *tree = pdf_dict_gets(names, "Dests");
 		return pdf_lookup_name_imp(ctx, tree, needle);
 	}
 
@@ -111,33 +111,33 @@ pdf_lookup_dest(pdf_document *xref, fz_obj *needle)
 }
 
 static void
-pdf_load_name_tree_imp(fz_obj *dict, pdf_document *xref, fz_obj *node)
+pdf_load_name_tree_imp(pdf_obj *dict, pdf_document *xref, pdf_obj *node)
 {
 	fz_context *ctx = xref->ctx;
-	fz_obj *kids = fz_dict_gets(node, "Kids");
-	fz_obj *names = fz_dict_gets(node, "Names");
+	pdf_obj *kids = pdf_dict_gets(node, "Kids");
+	pdf_obj *names = pdf_dict_gets(node, "Names");
 	int i;
 
-	if (kids && !fz_dict_mark(node))
+	if (kids && !pdf_dict_mark(node))
 	{
-		for (i = 0; i < fz_array_len(kids); i++)
-			pdf_load_name_tree_imp(dict, xref, fz_array_get(kids, i));
-		fz_dict_unmark(node);
+		for (i = 0; i < pdf_array_len(kids); i++)
+			pdf_load_name_tree_imp(dict, xref, pdf_array_get(kids, i));
+		pdf_dict_unmark(node);
 	}
 
 	if (names)
 	{
-		for (i = 0; i + 1 < fz_array_len(names); i += 2)
+		for (i = 0; i + 1 < pdf_array_len(names); i += 2)
 		{
-			fz_obj *key = fz_array_get(names, i);
-			fz_obj *val = fz_array_get(names, i + 1);
-			if (fz_is_string(key))
+			pdf_obj *key = pdf_array_get(names, i);
+			pdf_obj *val = pdf_array_get(names, i + 1);
+			if (pdf_is_string(key))
 			{
 				key = pdf_to_utf8_name(ctx, key);
 				fz_dict_put(dict, key, val);
-				fz_drop_obj(key);
+				pdf_drop_obj(key);
 			}
-			else if (fz_is_name(key))
+			else if (pdf_is_name(key))
 			{
 				fz_dict_put(dict, key, val);
 			}
@@ -145,17 +145,17 @@ pdf_load_name_tree_imp(fz_obj *dict, pdf_document *xref, fz_obj *node)
 	}
 }
 
-fz_obj *
+pdf_obj *
 pdf_load_name_tree(pdf_document *xref, char *which)
 {
 	fz_context *ctx = xref->ctx;
 
-	fz_obj *root = fz_dict_gets(xref->trailer, "Root");
-	fz_obj *names = fz_dict_gets(root, "Names");
-	fz_obj *tree = fz_dict_gets(names, which);
-	if (fz_is_dict(tree))
+	pdf_obj *root = pdf_dict_gets(xref->trailer, "Root");
+	pdf_obj *names = pdf_dict_gets(root, "Names");
+	pdf_obj *tree = pdf_dict_gets(names, which);
+	if (pdf_is_dict(tree))
 	{
-		fz_obj *dict = fz_new_dict(ctx, 100);
+		pdf_obj *dict = pdf_new_dict(ctx, 100);
 		pdf_load_name_tree_imp(dict, xref, tree);
 		return dict;
 	}
diff --git a/pdf/pdf_outline.c b/pdf/pdf_outline.c
index e5c87f8c..793b5f77 100644
--- a/pdf/pdf_outline.c
+++ b/pdf/pdf_outline.c
@@ -2,12 +2,12 @@
 #include "mupdf.h"
 
 static fz_outline *
-pdf_load_outline_imp(pdf_document *xref, fz_obj *dict)
+pdf_load_outline_imp(pdf_document *xref, pdf_obj *dict)
 {
 	fz_context *ctx = xref->ctx;
 	fz_outline *node, **prev, *first;
-	fz_obj *obj;
-	fz_obj *odict = dict;
+	pdf_obj *obj;
+	pdf_obj *odict = dict;
 
 	fz_var(dict);
 
@@ -15,9 +15,9 @@ pdf_load_outline_imp(pdf_document *xref, fz_obj *dict)
 	{
 		first = NULL;
 		prev = &first;
-		while (dict && fz_is_dict(dict))
+		while (dict && pdf_is_dict(dict))
 		{
-			if (fz_dict_mark(dict))
+			if (pdf_dict_mark(dict))
 				break;
 			node = fz_malloc_struct(ctx, fz_outline);
 			node->title = NULL;
@@ -27,31 +27,31 @@ pdf_load_outline_imp(pdf_document *xref, fz_obj *dict)
 			*prev = node;
 			prev = &node->next;
 
-			obj = fz_dict_gets(dict, "Title");
+			obj = pdf_dict_gets(dict, "Title");
 			if (obj)
 				node->title = pdf_to_utf8(ctx, obj);
 
-			if ((obj = fz_dict_gets(dict, "Dest")))
+			if ((obj = pdf_dict_gets(dict, "Dest")))
 				node->dest = pdf_parse_link_dest(xref, obj);
-			else if ((obj = fz_dict_gets(dict, "A")))
+			else if ((obj = pdf_dict_gets(dict, "A")))
 				node->dest = pdf_parse_action(xref, obj);
 
-			obj = fz_dict_gets(dict, "First");
+			obj = pdf_dict_gets(dict, "First");
 			if (obj)
 				node->down = pdf_load_outline_imp(xref, obj);
 
-			dict = fz_dict_gets(dict, "Next");
+			dict = pdf_dict_gets(dict, "Next");
 		}
 	}
 	fz_catch(ctx)
 	{
-		for (dict = odict; dict && fz_dict_marked(dict); dict = fz_dict_gets(dict, "Next"))
-			fz_dict_unmark(dict);
+		for (dict = odict; dict && pdf_dict_marked(dict); dict = pdf_dict_gets(dict, "Next"))
+			pdf_dict_unmark(dict);
 		fz_rethrow(ctx);
 	}
 
-	for (dict = odict; dict && fz_dict_marked(dict); dict = fz_dict_gets(dict, "Next"))
-		fz_dict_unmark(dict);
+	for (dict = odict; dict && pdf_dict_marked(dict); dict = pdf_dict_gets(dict, "Next"))
+		pdf_dict_unmark(dict);
 
 	return first;
 }
@@ -59,11 +59,11 @@ pdf_load_outline_imp(pdf_document *xref, fz_obj *dict)
 fz_outline *
 pdf_load_outline(pdf_document *xref)
 {
-	fz_obj *root, *obj, *first;
+	pdf_obj *root, *obj, *first;
 
-	root = fz_dict_gets(xref->trailer, "Root");
-	obj = fz_dict_gets(root, "Outlines");
-	first = fz_dict_gets(obj, "First");
+	root = pdf_dict_gets(xref->trailer, "Root");
+	obj = pdf_dict_gets(root, "Outlines");
+	first = pdf_dict_gets(obj, "First");
 	if (first)
 		return pdf_load_outline_imp(xref, first);
 
diff --git a/pdf/pdf_page.c b/pdf/pdf_page.c
index de8e7051..ca38aacf 100644
--- a/pdf/pdf_page.c
+++ b/pdf/pdf_page.c
@@ -3,126 +3,126 @@
 
 struct info
 {
-	fz_obj *resources;
-	fz_obj *mediabox;
-	fz_obj *cropbox;
-	fz_obj *rotate;
+	pdf_obj *resources;
+	pdf_obj *mediabox;
+	pdf_obj *cropbox;
+	pdf_obj *rotate;
 };
 
 static void
-put_marker_bool(fz_context *ctx, fz_obj *rdb, char *marker, int val)
+put_marker_bool(fz_context *ctx, pdf_obj *rdb, char *marker, int val)
 {
-	fz_obj *tmp;
+	pdf_obj *tmp;
 
-	tmp = fz_new_bool(ctx, val);
+	tmp = pdf_new_bool(ctx, val);
 	fz_try(ctx)
 	{
-		fz_dict_puts(rdb, marker, tmp);
+		pdf_dict_puts(rdb, marker, tmp);
 	}
 	fz_catch(ctx)
 	{
-		fz_drop_obj(tmp);
+		pdf_drop_obj(tmp);
 		fz_rethrow(ctx);
 	}
-	fz_drop_obj(tmp);
+	pdf_drop_obj(tmp);
 }
 
 static void
-pdf_load_page_tree_node(pdf_document *xref, fz_obj *node, struct info info)
+pdf_load_page_tree_node(pdf_document *xref, pdf_obj *node, struct info info)
 {
-	fz_obj *dict, *kids, *count;
-	fz_obj *obj;
+	pdf_obj *dict, *kids, *count;
+	pdf_obj *obj;
 	int i, n;
 	fz_context *ctx = xref->ctx;
 
 	/* prevent infinite recursion */
-	if (!node || fz_dict_mark(node))
+	if (!node || pdf_dict_mark(node))
 		return;
 
 	fz_try(ctx)
 	{
-		kids = fz_dict_gets(node, "Kids");
-		count = fz_dict_gets(node, "Count");
+		kids = pdf_dict_gets(node, "Kids");
+		count = pdf_dict_gets(node, "Count");
 
-		if (fz_is_array(kids) && fz_is_int(count))
+		if (pdf_is_array(kids) && pdf_is_int(count))
 		{
-			obj = fz_dict_gets(node, "Resources");
+			obj = pdf_dict_gets(node, "Resources");
 			if (obj)
 				info.resources = obj;
-			obj = fz_dict_gets(node, "MediaBox");
+			obj = pdf_dict_gets(node, "MediaBox");
 			if (obj)
 				info.mediabox = obj;
-			obj = fz_dict_gets(node, "CropBox");
+			obj = pdf_dict_gets(node, "CropBox");
 			if (obj)
 				info.cropbox = obj;
-			obj = fz_dict_gets(node, "Rotate");
+			obj = pdf_dict_gets(node, "Rotate");
 			if (obj)
 				info.rotate = obj;
 
-			n = fz_array_len(kids);
+			n = pdf_array_len(kids);
 			for (i = 0; i < n; i++)
 			{
-				obj = fz_array_get(kids, i);
+				obj = pdf_array_get(kids, i);
 				pdf_load_page_tree_node(xref, obj, info);
 			}
 		}
-		else if ((dict = fz_to_dict(node)) != NULL)
+		else if ((dict = pdf_to_dict(node)) != NULL)
 		{
-			if (info.resources && !fz_dict_gets(dict, "Resources"))
-				fz_dict_puts(dict, "Resources", info.resources);
-			if (info.mediabox && !fz_dict_gets(dict, "MediaBox"))
-				fz_dict_puts(dict, "MediaBox", info.mediabox);
-			if (info.cropbox && !fz_dict_gets(dict, "CropBox"))
-				fz_dict_puts(dict, "CropBox", info.cropbox);
-			if (info.rotate && !fz_dict_gets(dict, "Rotate"))
-				fz_dict_puts(dict, "Rotate", info.rotate);
+			if (info.resources && !pdf_dict_gets(dict, "Resources"))
+				pdf_dict_puts(dict, "Resources", info.resources);
+			if (info.mediabox && !pdf_dict_gets(dict, "MediaBox"))
+				pdf_dict_puts(dict, "MediaBox", info.mediabox);
+			if (info.cropbox && !pdf_dict_gets(dict, "CropBox"))
+				pdf_dict_puts(dict, "CropBox", info.cropbox);
+			if (info.rotate && !pdf_dict_gets(dict, "Rotate"))
+				pdf_dict_puts(dict, "Rotate", info.rotate);
 
 			if (xref->page_len == xref->page_cap)
 			{
 				fz_warn(ctx, "found more pages than expected");
 				xref->page_cap ++;
-				xref->page_refs = fz_resize_array(ctx, xref->page_refs, xref->page_cap, sizeof(fz_obj*));
-				xref->page_objs = fz_resize_array(ctx, xref->page_objs, xref->page_cap, sizeof(fz_obj*));
+				xref->page_refs = fz_resize_array(ctx, xref->page_refs, xref->page_cap, sizeof(pdf_obj*));
+				xref->page_objs = fz_resize_array(ctx, xref->page_objs, xref->page_cap, sizeof(pdf_obj*));
 			}
 
-			xref->page_refs[xref->page_len] = fz_keep_obj(node);
-			xref->page_objs[xref->page_len] = fz_keep_obj(dict);
+			xref->page_refs[xref->page_len] = pdf_keep_obj(node);
+			xref->page_objs[xref->page_len] = pdf_keep_obj(dict);
 			xref->page_len ++;
 		}
 	}
 	fz_catch(ctx)
 	{
-		fz_dict_unmark(node);
+		pdf_dict_unmark(node);
 		fz_rethrow(ctx);
 	}
-	fz_dict_unmark(node);
+	pdf_dict_unmark(node);
 }
 
 static void
 pdf_load_page_tree(pdf_document *xref)
 {
 	fz_context *ctx = xref->ctx;
-	fz_obj *catalog;
-	fz_obj *pages;
-	fz_obj *count;
+	pdf_obj *catalog;
+	pdf_obj *pages;
+	pdf_obj *count;
 	struct info info;
 
 	if (xref->page_len)
 		return;
 
-	catalog = fz_dict_gets(xref->trailer, "Root");
-	pages = fz_dict_gets(catalog, "Pages");
-	count = fz_dict_gets(pages, "Count");
+	catalog = pdf_dict_gets(xref->trailer, "Root");
+	pages = pdf_dict_gets(catalog, "Pages");
+	count = pdf_dict_gets(pages, "Count");
 
-	if (!fz_is_dict(pages))
+	if (!pdf_is_dict(pages))
 		fz_throw(ctx, "missing page tree");
-	if (!fz_is_int(count))
+	if (!pdf_is_int(count))
 		fz_throw(ctx, "missing page count");
 
-	xref->page_cap = fz_to_int(count);
+	xref->page_cap = pdf_to_int(count);
 	xref->page_len = 0;
-	xref->page_refs = fz_malloc_array(ctx, xref->page_cap, sizeof(fz_obj*));
-	xref->page_objs = fz_malloc_array(ctx, xref->page_cap, sizeof(fz_obj*));
+	xref->page_refs = fz_malloc_array(ctx, xref->page_cap, sizeof(pdf_obj*));
+	xref->page_objs = fz_malloc_array(ctx, xref->page_cap, sizeof(pdf_obj*));
 
 	info.resources = NULL;
 	info.mediabox = NULL;
@@ -140,84 +140,84 @@ pdf_count_pages(pdf_document *xref)
 }
 
 int
-pdf_find_page_number(pdf_document *xref, fz_obj *page)
+pdf_find_page_number(pdf_document *xref, pdf_obj *page)
 {
-	int i, num = fz_to_num(page);
+	int i, num = pdf_to_num(page);
 
 	pdf_load_page_tree(xref);
 	for (i = 0; i < xref->page_len; i++)
-		if (num == fz_to_num(xref->page_refs[i]))
+		if (num == pdf_to_num(xref->page_refs[i]))
 			return i;
 	return -1;
 }
 
 /* We need to know whether to install a page-level transparency group */
 
-static int pdf_resources_use_blending(fz_context *ctx, fz_obj *rdb);
+static int pdf_resources_use_blending(fz_context *ctx, pdf_obj *rdb);
 
 static int
-pdf_extgstate_uses_blending(fz_context *ctx, fz_obj *dict)
+pdf_extgstate_uses_blending(fz_context *ctx, pdf_obj *dict)
 {
-	fz_obj *obj = fz_dict_gets(dict, "BM");
-	if (fz_is_name(obj) && strcmp(fz_to_name(obj), "Normal"))
+	pdf_obj *obj = pdf_dict_gets(dict, "BM");
+	if (pdf_is_name(obj) && strcmp(pdf_to_name(obj), "Normal"))
 		return 1;
 	return 0;
 }
 
 static int
-pdf_pattern_uses_blending(fz_context *ctx, fz_obj *dict)
+pdf_pattern_uses_blending(fz_context *ctx, pdf_obj *dict)
 {
-	fz_obj *obj;
-	obj = fz_dict_gets(dict, "Resources");
+	pdf_obj *obj;
+	obj = pdf_dict_gets(dict, "Resources");
 	if (pdf_resources_use_blending(ctx, obj))
 		return 1;
-	obj = fz_dict_gets(dict, "ExtGState");
+	obj = pdf_dict_gets(dict, "ExtGState");
 	return pdf_extgstate_uses_blending(ctx, obj);
 }
 
 static int
-pdf_xobject_uses_blending(fz_context *ctx, fz_obj *dict)
+pdf_xobject_uses_blending(fz_context *ctx, pdf_obj *dict)
 {
-	fz_obj *obj = fz_dict_gets(dict, "Resources");
+	pdf_obj *obj = pdf_dict_gets(dict, "Resources");
 	return pdf_resources_use_blending(ctx, obj);
 }
 
 static int
-pdf_resources_use_blending(fz_context *ctx, fz_obj *rdb)
+pdf_resources_use_blending(fz_context *ctx, pdf_obj *rdb)
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 	int i, n, useBM = 0;
 
 	if (!rdb)
 		return 0;
 
 	/* Have we been here before and stashed an answer? */
-	obj = fz_dict_gets(rdb, ".useBM");
+	obj = pdf_dict_gets(rdb, ".useBM");
 	if (obj)
-		return fz_to_bool(obj);
+		return pdf_to_bool(obj);
 
 	/* stop on cyclic resource dependencies */
-	if (fz_dict_mark(rdb))
+	if (pdf_dict_mark(rdb))
 		return 0;
 
 	fz_try(ctx)
 	{
-		obj = fz_dict_gets(rdb, "ExtGState");
-		n = fz_dict_len(obj);
+		obj = pdf_dict_gets(rdb, "ExtGState");
+		n = pdf_dict_len(obj);
 		for (i = 0; i < n; i++)
-			if (pdf_extgstate_uses_blending(ctx, fz_dict_get_val(obj, i)))
+			if (pdf_extgstate_uses_blending(ctx, pdf_dict_get_val(obj, i)))
 				goto found;
 
-		obj = fz_dict_gets(rdb, "Pattern");
-		n = fz_dict_len(obj);
+		obj = pdf_dict_gets(rdb, "Pattern");
+		n = pdf_dict_len(obj);
 		for (i = 0; i < n; i++)
-			if (pdf_pattern_uses_blending(ctx, fz_dict_get_val(obj, i)))
+			if (pdf_pattern_uses_blending(ctx, pdf_dict_get_val(obj, i)))
 				goto found;
 
-		obj = fz_dict_gets(rdb, "XObject");
-		n = fz_dict_len(obj);
+		obj = pdf_dict_gets(rdb, "XObject");
+		n = pdf_dict_len(obj);
 		for (i = 0; i < n; i++)
-			if (pdf_xobject_uses_blending(ctx, fz_dict_get_val(obj, i)))
+			if (pdf_xobject_uses_blending(ctx, pdf_dict_get_val(obj, i)))
 				goto found;
 		if (0)
 		{
@@ -227,10 +227,10 @@ found:
 	}
 	fz_catch(ctx)
 	{
-		fz_dict_unmark(rdb);
+		pdf_dict_unmark(rdb);
 		fz_rethrow(ctx);
 	}
-	fz_dict_unmark(rdb);
+	pdf_dict_unmark(rdb);
 
 	put_marker_bool(ctx, rdb, ".useBM", useBM);
 	return useBM;
@@ -239,7 +239,7 @@ found:
 /* we need to combine all sub-streams into one for the content stream interpreter */
 
 static fz_buffer *
-pdf_load_page_contents_array(pdf_document *xref, fz_obj *list)
+pdf_load_page_contents_array(pdf_document *xref, pdf_obj *list)
 {
 	fz_buffer *big;
 	fz_buffer *one;
@@ -248,14 +248,14 @@ pdf_load_page_contents_array(pdf_document *xref, fz_obj *list)
 
 	big = fz_new_buffer(ctx, 32 * 1024);
 
-	n = fz_array_len(list);
+	n = pdf_array_len(list);
 	fz_var(i); /* Workaround Mac compiler bug */
 	for (i = 0; i < n; i++)
 	{
-		fz_obj *stm = fz_array_get(list, i);
+		pdf_obj *stm = pdf_array_get(list, i);
 		fz_try(ctx)
 		{
-			one = pdf_load_stream(xref, fz_to_num(stm), fz_to_gen(stm));
+			one = pdf_load_stream(xref, pdf_to_num(stm), pdf_to_gen(stm));
 		}
 		fz_catch(ctx)
 		{
@@ -283,19 +283,19 @@ pdf_load_page_contents_array(pdf_document *xref, fz_obj *list)
 }
 
 static fz_buffer *
-pdf_load_page_contents(pdf_document *xref, fz_obj *obj)
+pdf_load_page_contents(pdf_document *xref, pdf_obj *obj)
 {
 	fz_context *ctx = xref->ctx;
 
-	if (fz_is_array(obj))
+	if (pdf_is_array(obj))
 	{
 		return pdf_load_page_contents_array(xref, obj);
 		/* RJW: "cannot load content stream array" */
 	}
-	else if (pdf_is_stream(xref, fz_to_num(obj), fz_to_gen(obj)))
+	else if (pdf_is_stream(xref, pdf_to_num(obj), pdf_to_gen(obj)))
 	{
-		return pdf_load_stream(xref, fz_to_num(obj), fz_to_gen(obj));
-		/* RJW: "cannot load content stream (%d 0 R)", fz_to_num(obj) */
+		return pdf_load_stream(xref, pdf_to_num(obj), pdf_to_gen(obj));
+		/* RJW: "cannot load content stream (%d 0 R)", pdf_to_num(obj) */
 	}
 
 	fz_warn(ctx, "page contents missing, leaving page blank");
@@ -308,7 +308,7 @@ pdf_load_page(pdf_document *xref, int number)
 	fz_context *ctx = xref->ctx;
 	pdf_page *page;
 	pdf_annot *annot;
-	fz_obj *pageobj, *pageref, *obj;
+	pdf_obj *pageobj, *pageref, *obj;
 	fz_rect mediabox, cropbox, realbox;
 	fz_matrix ctm;
 
@@ -326,7 +326,7 @@ pdf_load_page(pdf_document *xref, int number)
 	page->links = NULL;
 	page->annots = NULL;
 
-	mediabox = pdf_to_rect(ctx, fz_dict_gets(pageobj, "MediaBox"));
+	mediabox = pdf_to_rect(ctx, pdf_dict_gets(pageobj, "MediaBox"));
 	if (fz_is_empty_rect(mediabox))
 	{
 		fz_warn(ctx, "cannot find page size for page %d", number + 1);
@@ -336,7 +336,7 @@ pdf_load_page(pdf_document *xref, int number)
 		mediabox.y1 = 792;
 	}
 
-	cropbox = pdf_to_rect(ctx, fz_dict_gets(pageobj, "CropBox"));
+	cropbox = pdf_to_rect(ctx, pdf_dict_gets(pageobj, "CropBox"));
 	if (!fz_is_empty_rect(cropbox))
 		mediabox = fz_intersect_rect(mediabox, cropbox);
 
@@ -351,24 +351,24 @@ pdf_load_page(pdf_document *xref, int number)
 		page->mediabox = fz_unit_rect;
 	}
 
-	page->rotate = fz_to_int(fz_dict_gets(pageobj, "Rotate"));
+	page->rotate = pdf_to_int(pdf_dict_gets(pageobj, "Rotate"));
 
 	ctm = fz_concat(fz_rotate(-page->rotate), fz_scale(1, -1));
 	realbox = fz_transform_rect(ctm, page->mediabox);
 	page->ctm = fz_concat(ctm, fz_translate(-realbox.x0, -realbox.y0));
 
-	obj = fz_dict_gets(pageobj, "Annots");
+	obj = pdf_dict_gets(pageobj, "Annots");
 	if (obj)
 	{
 		page->links = pdf_load_link_annots(xref, obj, page->ctm);
 		page->annots = pdf_load_annots(xref, obj);
 	}
 
-	page->resources = fz_dict_gets(pageobj, "Resources");
+	page->resources = pdf_dict_gets(pageobj, "Resources");
 	if (page->resources)
-		fz_keep_obj(page->resources);
+		pdf_keep_obj(page->resources);
 
-	obj = fz_dict_gets(pageobj, "Contents");
+	obj = pdf_dict_gets(pageobj, "Contents");
 	fz_try(ctx)
 	{
 		page->contents = pdf_load_page_contents(xref, obj);
@@ -383,7 +383,7 @@ pdf_load_page(pdf_document *xref, int number)
 	fz_catch(ctx)
 	{
 		pdf_free_page(xref, page);
-		fz_throw(ctx, "cannot load page %d contents (%d 0 R)", number + 1, fz_to_num(pageref));
+		fz_throw(ctx, "cannot load page %d contents (%d 0 R)", number + 1, pdf_to_num(pageref));
 	}
 
 	return page;
@@ -409,7 +409,7 @@ void
 pdf_free_page(pdf_document *xref, pdf_page *page)
 {
 	if (page->resources)
-		fz_drop_obj(page->resources);
+		pdf_drop_obj(page->resources);
 	if (page->contents)
 		fz_drop_buffer(xref->ctx, page->contents);
 	if (page->links)
diff --git a/pdf/pdf_parse.c b/pdf/pdf_parse.c
index fb6cb7ef..e171e698 100644
--- a/pdf/pdf_parse.c
+++ b/pdf/pdf_parse.c
@@ -2,13 +2,13 @@
 #include "mupdf.h"
 
 fz_rect
-pdf_to_rect(fz_context *ctx, fz_obj *array)
+pdf_to_rect(fz_context *ctx, pdf_obj *array)
 {
 	fz_rect r;
-	float a = fz_to_real(fz_array_get(array, 0));
-	float b = fz_to_real(fz_array_get(array, 1));
-	float c = fz_to_real(fz_array_get(array, 2));
-	float d = fz_to_real(fz_array_get(array, 3));
+	float a = pdf_to_real(pdf_array_get(array, 0));
+	float b = pdf_to_real(pdf_array_get(array, 1));
+	float c = pdf_to_real(pdf_array_get(array, 2));
+	float d = pdf_to_real(pdf_array_get(array, 3));
 	r.x0 = MIN(a, c);
 	r.y0 = MIN(b, d);
 	r.x1 = MAX(a, c);
@@ -17,25 +17,25 @@ pdf_to_rect(fz_context *ctx, fz_obj *array)
 }
 
 fz_matrix
-pdf_to_matrix(fz_context *ctx, fz_obj *array)
+pdf_to_matrix(fz_context *ctx, pdf_obj *array)
 {
 	fz_matrix m;
-	m.a = fz_to_real(fz_array_get(array, 0));
-	m.b = fz_to_real(fz_array_get(array, 1));
-	m.c = fz_to_real(fz_array_get(array, 2));
-	m.d = fz_to_real(fz_array_get(array, 3));
-	m.e = fz_to_real(fz_array_get(array, 4));
-	m.f = fz_to_real(fz_array_get(array, 5));
+	m.a = pdf_to_real(pdf_array_get(array, 0));
+	m.b = pdf_to_real(pdf_array_get(array, 1));
+	m.c = pdf_to_real(pdf_array_get(array, 2));
+	m.d = pdf_to_real(pdf_array_get(array, 3));
+	m.e = pdf_to_real(pdf_array_get(array, 4));
+	m.f = pdf_to_real(pdf_array_get(array, 5));
 	return m;
 }
 
 /* Convert Unicode/PdfDocEncoding string into utf-8 */
 char *
-pdf_to_utf8(fz_context *ctx, fz_obj *src)
+pdf_to_utf8(fz_context *ctx, pdf_obj *src)
 {
-	unsigned char *srcptr = (unsigned char *) fz_to_str_buf(src);
+	unsigned char *srcptr = (unsigned char *) pdf_to_str_buf(src);
 	char *dstptr, *dst;
-	int srclen = fz_to_str_len(src);
+	int srclen = pdf_to_str_len(src);
 	int dstlen = 0;
 	int ucs;
 	int i;
@@ -92,11 +92,11 @@ pdf_to_utf8(fz_context *ctx, fz_obj *src)
 
 /* Convert Unicode/PdfDocEncoding string into ucs-2 */
 unsigned short *
-pdf_to_ucs2(fz_context *ctx, fz_obj *src)
+pdf_to_ucs2(fz_context *ctx, pdf_obj *src)
 {
-	unsigned char *srcptr = (unsigned char *) fz_to_str_buf(src);
+	unsigned char *srcptr = (unsigned char *) pdf_to_str_buf(src);
 	unsigned short *dstptr, *dst;
-	int srclen = fz_to_str_len(src);
+	int srclen = pdf_to_str_len(src);
 	int i;
 
 	if (srclen >= 2 && srcptr[0] == 254 && srcptr[1] == 255)
@@ -161,28 +161,28 @@ pdf_from_ucs2(fz_context *ctx, unsigned short *src)
 	return docstr;
 }
 
-fz_obj *
-pdf_to_utf8_name(fz_context *ctx, fz_obj *src)
+pdf_obj *
+pdf_to_utf8_name(fz_context *ctx, pdf_obj *src)
 {
 	char *buf = pdf_to_utf8(ctx, src);
-	fz_obj *dst = fz_new_name(ctx, buf);
+	pdf_obj *dst = fz_new_name(ctx, buf);
 	fz_free(ctx, buf);
 	return dst;
 }
 
-fz_obj *
+pdf_obj *
 pdf_parse_array(pdf_document *xref, fz_stream *file, pdf_lexbuf *buf)
 {
-	fz_obj *ary = NULL;
-	fz_obj *obj = NULL;
+	pdf_obj *ary = NULL;
+	pdf_obj *obj = NULL;
 	int a = 0, b = 0, n = 0;
 	int tok;
 	fz_context *ctx = file->ctx;
-	fz_obj *op;
+	pdf_obj *op;
 
 	fz_var(obj);
 
-	ary = fz_new_array(ctx, 4);
+	ary = pdf_new_array(ctx, 4);
 
 	fz_try(ctx)
 	{
@@ -194,16 +194,16 @@ pdf_parse_array(pdf_document *xref, fz_stream *file, pdf_lexbuf *buf)
 			{
 				if (n > 0)
 				{
-					obj = fz_new_int(ctx, a);
-					fz_array_push(ary, obj);
-					fz_drop_obj(obj);
+					obj = pdf_new_int(ctx, a);
+					pdf_array_push(ary, obj);
+					pdf_drop_obj(obj);
 					obj = NULL;
 				}
 				if (n > 1)
 				{
-					obj = fz_new_int(ctx, b);
-					fz_array_push(ary, obj);
-					fz_drop_obj(obj);
+					obj = pdf_new_int(ctx, b);
+					pdf_array_push(ary, obj);
+					pdf_drop_obj(obj);
 					obj = NULL;
 				}
 				n = 0;
@@ -211,9 +211,9 @@ pdf_parse_array(pdf_document *xref, fz_stream *file, pdf_lexbuf *buf)
 
 			if (tok == PDF_TOK_INT && n == 2)
 			{
-				obj = fz_new_int(ctx, a);
-				fz_array_push(ary, obj);
-				fz_drop_obj(obj);
+				obj = pdf_new_int(ctx, a);
+				pdf_array_push(ary, obj);
+				pdf_drop_obj(obj);
 				obj = NULL;
 				a = b;
 				n --;
@@ -236,61 +236,61 @@ pdf_parse_array(pdf_document *xref, fz_stream *file, pdf_lexbuf *buf)
 			case PDF_TOK_R:
 				if (n != 2)
 					fz_throw(ctx, "cannot parse indirect reference in array");
-				obj = fz_new_indirect(ctx, a, b, xref);
-				fz_array_push(ary, obj);
-				fz_drop_obj(obj);
+				obj = pdf_new_indirect(ctx, a, b, xref);
+				pdf_array_push(ary, obj);
+				pdf_drop_obj(obj);
 				obj = NULL;
 				n = 0;
 				break;
 
 			case PDF_TOK_OPEN_ARRAY:
 				obj = pdf_parse_array(xref, file, buf);
-				fz_array_push(ary, obj);
-				fz_drop_obj(obj);
+				pdf_array_push(ary, obj);
+				pdf_drop_obj(obj);
 				obj = NULL;
 				break;
 
 			case PDF_TOK_OPEN_DICT:
 				obj = pdf_parse_dict(xref, file, buf);
-				fz_array_push(ary, obj);
-				fz_drop_obj(obj);
+				pdf_array_push(ary, obj);
+				pdf_drop_obj(obj);
 				obj = NULL;
 				break;
 
 			case PDF_TOK_NAME:
 				obj = fz_new_name(ctx, buf->scratch);
-				fz_array_push(ary, obj);
-				fz_drop_obj(obj);
+				pdf_array_push(ary, obj);
+				pdf_drop_obj(obj);
 				obj = NULL;
 				break;
 			case PDF_TOK_REAL:
-				obj = fz_new_real(ctx, buf->f);
-				fz_array_push(ary, obj);
-				fz_drop_obj(obj);
+				obj = pdf_new_real(ctx, buf->f);
+				pdf_array_push(ary, obj);
+				pdf_drop_obj(obj);
 				obj = NULL;
 				break;
 			case PDF_TOK_STRING:
-				obj = fz_new_string(ctx, buf->scratch, buf->len);
-				fz_array_push(ary, obj);
-				fz_drop_obj(obj);
+				obj = pdf_new_string(ctx, buf->scratch, buf->len);
+				pdf_array_push(ary, obj);
+				pdf_drop_obj(obj);
 				obj = NULL;
 				break;
 			case PDF_TOK_TRUE:
-				obj = fz_new_bool(ctx, 1);
-				fz_array_push(ary, obj);
-				fz_drop_obj(obj);
+				obj = pdf_new_bool(ctx, 1);
+				pdf_array_push(ary, obj);
+				pdf_drop_obj(obj);
 				obj = NULL;
 				break;
 			case PDF_TOK_FALSE:
-				obj = fz_new_bool(ctx, 0);
-				fz_array_push(ary, obj);
-				fz_drop_obj(obj);
+				obj = pdf_new_bool(ctx, 0);
+				pdf_array_push(ary, obj);
+				pdf_drop_obj(obj);
 				obj = NULL;
 				break;
 			case PDF_TOK_NULL:
-				obj = fz_new_null(ctx);
-				fz_array_push(ary, obj);
-				fz_drop_obj(obj);
+				obj = pdf_new_null(ctx);
+				pdf_array_push(ary, obj);
+				pdf_drop_obj(obj);
 				obj = NULL;
 				break;
 
@@ -303,19 +303,19 @@ end:
 	}
 	fz_catch(ctx)
 	{
-		fz_drop_obj(obj);
-		fz_drop_obj(ary);
+		pdf_drop_obj(obj);
+		pdf_drop_obj(ary);
 		fz_throw(ctx, "cannot parse array");
 	}
 	return op;
 }
 
-fz_obj *
+pdf_obj *
 pdf_parse_dict(pdf_document *xref, fz_stream *file, pdf_lexbuf *buf)
 {
-	fz_obj *dict = NULL;
-	fz_obj *key = NULL;
-	fz_obj *val = NULL;
+	pdf_obj *dict = NULL;
+	pdf_obj *key = NULL;
+	pdf_obj *val = NULL;
 	int tok;
 	int a, b;
 	fz_context *ctx = file->ctx;
@@ -324,7 +324,7 @@ pdf_parse_dict(pdf_document *xref, fz_stream *file, pdf_lexbuf *buf)
 	fz_var(key);
 	fz_var(val);
 
-	dict = fz_new_dict(ctx, 8);
+	dict = pdf_new_dict(ctx, 8);
 
 	fz_try(ctx)
 	{
@@ -357,11 +357,11 @@ pdf_parse_dict(pdf_document *xref, fz_stream *file, pdf_lexbuf *buf)
 				break;
 
 			case PDF_TOK_NAME: val = fz_new_name(ctx, buf->scratch); break;
-			case PDF_TOK_REAL: val = fz_new_real(ctx, buf->f); break;
-			case PDF_TOK_STRING: val = fz_new_string(ctx, buf->scratch, buf->len); break;
-			case PDF_TOK_TRUE: val = fz_new_bool(ctx, 1); break;
-			case PDF_TOK_FALSE: val = fz_new_bool(ctx, 0); break;
-			case PDF_TOK_NULL: val = fz_new_null(ctx); break;
+			case PDF_TOK_REAL: val = pdf_new_real(ctx, buf->f); break;
+			case PDF_TOK_STRING: val = pdf_new_string(ctx, buf->scratch, buf->len); break;
+			case PDF_TOK_TRUE: val = pdf_new_bool(ctx, 1); break;
+			case PDF_TOK_FALSE: val = pdf_new_bool(ctx, 0); break;
+			case PDF_TOK_NULL: val = pdf_new_null(ctx); break;
 
 			case PDF_TOK_INT:
 				/* 64-bit to allow for numbers > INT_MAX and overflow */
@@ -370,11 +370,11 @@ pdf_parse_dict(pdf_document *xref, fz_stream *file, pdf_lexbuf *buf)
 				if (tok == PDF_TOK_CLOSE_DICT || tok == PDF_TOK_NAME ||
 					(tok == PDF_TOK_KEYWORD && !strcmp(buf->scratch, "ID")))
 				{
-					val = fz_new_int(ctx, a);
+					val = pdf_new_int(ctx, a);
 					fz_dict_put(dict, key, val);
-					fz_drop_obj(val);
+					pdf_drop_obj(val);
 					val = NULL;
-					fz_drop_obj(key);
+					pdf_drop_obj(key);
 					key = NULL;
 					goto skip;
 				}
@@ -384,7 +384,7 @@ pdf_parse_dict(pdf_document *xref, fz_stream *file, pdf_lexbuf *buf)
 					tok = pdf_lex(file, buf);
 					if (tok == PDF_TOK_R)
 					{
-						val = fz_new_indirect(ctx, a, b, xref);
+						val = pdf_new_indirect(ctx, a, b, xref);
 						break;
 					}
 				}
@@ -395,23 +395,23 @@ pdf_parse_dict(pdf_document *xref, fz_stream *file, pdf_lexbuf *buf)
 			}
 
 			fz_dict_put(dict, key, val);
-			fz_drop_obj(val);
+			pdf_drop_obj(val);
 			val = NULL;
-			fz_drop_obj(key);
+			pdf_drop_obj(key);
 			key = NULL;
 		}
 	}
 	fz_catch(ctx)
 	{
-		fz_drop_obj(dict);
-		fz_drop_obj(key);
-		fz_drop_obj(val);
+		pdf_drop_obj(dict);
+		pdf_drop_obj(key);
+		pdf_drop_obj(val);
 		fz_throw(ctx, "cannot parse dict");
 	}
 	return dict;
 }
 
-fz_obj *
+pdf_obj *
 pdf_parse_stm_obj(pdf_document *xref, fz_stream *file, pdf_lexbuf *buf)
 {
 	int tok;
@@ -429,23 +429,23 @@ pdf_parse_stm_obj(pdf_document *xref, fz_stream *file, pdf_lexbuf *buf)
 		return pdf_parse_dict(xref, file, buf);
 		/* RJW: "cannot parse object stream" */
 	case PDF_TOK_NAME: return fz_new_name(ctx, buf->scratch); break;
-	case PDF_TOK_REAL: return fz_new_real(ctx, buf->f); break;
-	case PDF_TOK_STRING: return fz_new_string(ctx, buf->scratch, buf->len); break;
-	case PDF_TOK_TRUE: return fz_new_bool(ctx, 1); break;
-	case PDF_TOK_FALSE: return fz_new_bool(ctx, 0); break;
-	case PDF_TOK_NULL: return fz_new_null(ctx); break;
-	case PDF_TOK_INT: return fz_new_int(ctx, buf->i); break;
+	case PDF_TOK_REAL: return pdf_new_real(ctx, buf->f); break;
+	case PDF_TOK_STRING: return pdf_new_string(ctx, buf->scratch, buf->len); break;
+	case PDF_TOK_TRUE: return pdf_new_bool(ctx, 1); break;
+	case PDF_TOK_FALSE: return pdf_new_bool(ctx, 0); break;
+	case PDF_TOK_NULL: return pdf_new_null(ctx); break;
+	case PDF_TOK_INT: return pdf_new_int(ctx, buf->i); break;
 	default: fz_throw(ctx, "unknown token in object stream");
 	}
 	return NULL; /* Stupid MSVC */
 }
 
-fz_obj *
+pdf_obj *
 pdf_parse_ind_obj(pdf_document *xref,
 	fz_stream *file, pdf_lexbuf *buf,
 	int *onum, int *ogen, int *ostmofs)
 {
-	fz_obj *obj = NULL;
+	pdf_obj *obj = NULL;
 	int num = 0, gen = 0, stm_ofs;
 	int tok;
 	int a, b;
@@ -486,11 +486,11 @@ pdf_parse_ind_obj(pdf_document *xref,
 		break;
 
 	case PDF_TOK_NAME: obj = fz_new_name(ctx, buf->scratch); break;
-	case PDF_TOK_REAL: obj = fz_new_real(ctx, buf->f); break;
-	case PDF_TOK_STRING: obj = fz_new_string(ctx, buf->scratch, buf->len); break;
-	case PDF_TOK_TRUE: obj = fz_new_bool(ctx, 1); break;
-	case PDF_TOK_FALSE: obj = fz_new_bool(ctx, 0); break;
-	case PDF_TOK_NULL: obj = fz_new_null(ctx); break;
+	case PDF_TOK_REAL: obj = pdf_new_real(ctx, buf->f); break;
+	case PDF_TOK_STRING: obj = pdf_new_string(ctx, buf->scratch, buf->len); break;
+	case PDF_TOK_TRUE: obj = pdf_new_bool(ctx, 1); break;
+	case PDF_TOK_FALSE: obj = pdf_new_bool(ctx, 0); break;
+	case PDF_TOK_NULL: obj = pdf_new_null(ctx); break;
 
 	case PDF_TOK_INT:
 		a = buf->i;
@@ -498,7 +498,7 @@ pdf_parse_ind_obj(pdf_document *xref,
 		/* "cannot parse indirect object (%d %d R)", num, gen */
 		if (tok == PDF_TOK_STREAM || tok == PDF_TOK_ENDOBJ)
 		{
-			obj = fz_new_int(ctx, a);
+			obj = pdf_new_int(ctx, a);
 			goto skip;
 		}
 		if (tok == PDF_TOK_INT)
@@ -508,14 +508,14 @@ pdf_parse_ind_obj(pdf_document *xref,
 			/* RJW: "cannot parse indirect object (%d %d R)", num, gen); */
 			if (tok == PDF_TOK_R)
 			{
-				obj = fz_new_indirect(ctx, a, b, xref);
+				obj = pdf_new_indirect(ctx, a, b, xref);
 				break;
 			}
 		}
 		fz_throw(ctx, "expected 'R' keyword (%d %d R)", num, gen);
 
 	case PDF_TOK_ENDOBJ:
-		obj = fz_new_null(ctx);
+		obj = pdf_new_null(ctx);
 		goto skip;
 
 	default:
@@ -528,7 +528,7 @@ pdf_parse_ind_obj(pdf_document *xref,
 	}
 	fz_catch(ctx)
 	{
-		fz_drop_obj(obj);
+		pdf_drop_obj(obj);
 		fz_throw(ctx, "cannot parse indirect object (%d %d R)", num, gen);
 	}
 
diff --git a/pdf/pdf_pattern.c b/pdf/pdf_pattern.c
index c1869474..00e4b8fb 100644
--- a/pdf/pdf_pattern.c
+++ b/pdf/pdf_pattern.c
@@ -19,7 +19,7 @@ pdf_free_pattern_imp(fz_context *ctx, fz_storable *pat_)
 	pdf_pattern *pat = (pdf_pattern *)pat_;
 
 	if (pat->resources)
-		fz_drop_obj(pat->resources);
+		pdf_drop_obj(pat->resources);
 	if (pat->contents)
 		fz_drop_buffer(ctx, pat->contents);
 	fz_free(ctx, pat);
@@ -34,10 +34,10 @@ pdf_pattern_size(pdf_pattern *pat)
 }
 
 pdf_pattern *
-pdf_load_pattern(pdf_document *xref, fz_obj *dict)
+pdf_load_pattern(pdf_document *xref, pdf_obj *dict)
 {
 	pdf_pattern *pat;
-	fz_obj *obj;
+	pdf_obj *obj;
 	fz_context *ctx = xref->ctx;
 
 	if ((pat = pdf_find_item(ctx, pdf_free_pattern_imp, dict)))
@@ -53,32 +53,32 @@ pdf_load_pattern(pdf_document *xref, fz_obj *dict)
 	/* Store pattern now, to avoid possible recursion if objects refer back to this one */
 	pdf_store_item(ctx, dict, pat, pdf_pattern_size(pat));
 
-	pat->ismask = fz_to_int(fz_dict_gets(dict, "PaintType")) == 2;
-	pat->xstep = fz_to_real(fz_dict_gets(dict, "XStep"));
-	pat->ystep = fz_to_real(fz_dict_gets(dict, "YStep"));
+	pat->ismask = pdf_to_int(pdf_dict_gets(dict, "PaintType")) == 2;
+	pat->xstep = pdf_to_real(pdf_dict_gets(dict, "XStep"));
+	pat->ystep = pdf_to_real(pdf_dict_gets(dict, "YStep"));
 
-	obj = fz_dict_gets(dict, "BBox");
+	obj = pdf_dict_gets(dict, "BBox");
 	pat->bbox = pdf_to_rect(ctx, obj);
 
-	obj = fz_dict_gets(dict, "Matrix");
+	obj = pdf_dict_gets(dict, "Matrix");
 	if (obj)
 		pat->matrix = pdf_to_matrix(ctx, obj);
 	else
 		pat->matrix = fz_identity;
 
-	pat->resources = fz_dict_gets(dict, "Resources");
+	pat->resources = pdf_dict_gets(dict, "Resources");
 	if (pat->resources)
-		fz_keep_obj(pat->resources);
+		pdf_keep_obj(pat->resources);
 
 	fz_try(ctx)
 	{
-		pat->contents = pdf_load_stream(xref, fz_to_num(dict), fz_to_gen(dict));
+		pat->contents = pdf_load_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
 	}
 	fz_catch(ctx)
 	{
 		pdf_remove_item(ctx, pdf_free_pattern_imp, dict);
 		pdf_drop_pattern(ctx, pat);
-		fz_throw(ctx, "cannot load pattern stream (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+		fz_throw(ctx, "cannot load pattern stream (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict));
 	}
 	return pat;
 }
diff --git a/pdf/pdf_repair.c b/pdf/pdf_repair.c
index c70df3e2..f42198eb 100644
--- a/pdf/pdf_repair.c
+++ b/pdf/pdf_repair.c
@@ -13,7 +13,7 @@ struct entry
 };
 
 static void
-pdf_repair_obj(fz_stream *file, pdf_lexbuf *buf, int *stmofsp, int *stmlenp, fz_obj **encrypt, fz_obj **id)
+pdf_repair_obj(fz_stream *file, pdf_lexbuf *buf, int *stmofsp, int *stmlenp, pdf_obj **encrypt, pdf_obj **id)
 {
 	int tok;
 	int stm_len;
@@ -29,7 +29,7 @@ pdf_repair_obj(fz_stream *file, pdf_lexbuf *buf, int *stmofsp, int *stmlenp, fz_
 	/* RJW: "cannot parse object" */
 	if (tok == PDF_TOK_OPEN_DICT)
 	{
-		fz_obj *dict, *obj;
+		pdf_obj *dict, *obj;
 
 		/* Send NULL xref so we don't try to resolve references */
 		fz_try(ctx)
@@ -42,34 +42,34 @@ pdf_repair_obj(fz_stream *file, pdf_lexbuf *buf, int *stmofsp, int *stmlenp, fz_
 			if (file->eof)
 				fz_throw(ctx, "broken object at EOF ignored");
 			/* Silently swallow the error */
-			dict = fz_new_dict(ctx, 2);
+			dict = pdf_new_dict(ctx, 2);
 		}
 
-		obj = fz_dict_gets(dict, "Type");
-		if (fz_is_name(obj) && !strcmp(fz_to_name(obj), "XRef"))
+		obj = pdf_dict_gets(dict, "Type");
+		if (pdf_is_name(obj) && !strcmp(pdf_to_name(obj), "XRef"))
 		{
-			obj = fz_dict_gets(dict, "Encrypt");
+			obj = pdf_dict_gets(dict, "Encrypt");
 			if (obj)
 			{
 				if (*encrypt)
-					fz_drop_obj(*encrypt);
-				*encrypt = fz_keep_obj(obj);
+					pdf_drop_obj(*encrypt);
+				*encrypt = pdf_keep_obj(obj);
 			}
 
-			obj = fz_dict_gets(dict, "ID");
+			obj = pdf_dict_gets(dict, "ID");
 			if (obj)
 			{
 				if (*id)
-					fz_drop_obj(*id);
-				*id = fz_keep_obj(obj);
+					pdf_drop_obj(*id);
+				*id = pdf_keep_obj(obj);
 			}
 		}
 
-		obj = fz_dict_gets(dict, "Length");
-		if (!fz_is_indirect(obj) && fz_is_int(obj))
-			stm_len = fz_to_int(obj);
+		obj = pdf_dict_gets(dict, "Length");
+		if (!pdf_is_indirect(obj) && pdf_is_int(obj))
+			stm_len = pdf_to_int(obj);
 
-		fz_drop_obj(dict);
+		pdf_drop_obj(dict);
 	}
 
 	while ( tok != PDF_TOK_STREAM &&
@@ -142,7 +142,7 @@ atobjend:
 static void
 pdf_repair_obj_stm(pdf_document *xref, int num, int gen)
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 	fz_stream *stm = NULL;
 	int tok;
 	int i, n, count;
@@ -157,9 +157,9 @@ pdf_repair_obj_stm(pdf_document *xref, int num, int gen)
 	{
 		obj = pdf_load_object(xref, num, gen);
 
-		count = fz_to_int(fz_dict_gets(obj, "N"));
+		count = pdf_to_int(pdf_dict_gets(obj, "N"));
 
-		fz_drop_obj(obj);
+		pdf_drop_obj(obj);
 
 		stm = pdf_open_stream(xref, num, gen);
 
@@ -176,7 +176,7 @@ pdf_repair_obj_stm(pdf_document *xref, int num, int gen)
 			xref->table[n].ofs = num;
 			xref->table[n].gen = i;
 			xref->table[n].stm_ofs = 0;
-			fz_drop_obj(xref->table[n].obj);
+			pdf_drop_obj(xref->table[n].obj);
 			xref->table[n].obj = NULL;
 			xref->table[n].type = 'o';
 
@@ -198,13 +198,13 @@ pdf_repair_obj_stm(pdf_document *xref, int num, int gen)
 void
 pdf_repair_xref(pdf_document *xref, pdf_lexbuf *buf)
 {
-	fz_obj *dict, *obj;
-	fz_obj *length;
+	pdf_obj *dict, *obj;
+	pdf_obj *length;
 
-	fz_obj *encrypt = NULL;
-	fz_obj *id = NULL;
-	fz_obj *root = NULL;
-	fz_obj *info = NULL;
+	pdf_obj *encrypt = NULL;
+	pdf_obj *id = NULL;
+	pdf_obj *root = NULL;
+	pdf_obj *info = NULL;
 
 	struct entry *list = NULL;
 	int listlen;
@@ -332,39 +332,39 @@ pdf_repair_xref(pdf_document *xref, pdf_lexbuf *buf)
 					break;
 				}
 
-				obj = fz_dict_gets(dict, "Encrypt");
+				obj = pdf_dict_gets(dict, "Encrypt");
 				if (obj)
 				{
 					if (encrypt)
-						fz_drop_obj(encrypt);
-					encrypt = fz_keep_obj(obj);
+						pdf_drop_obj(encrypt);
+					encrypt = pdf_keep_obj(obj);
 				}
 
-				obj = fz_dict_gets(dict, "ID");
+				obj = pdf_dict_gets(dict, "ID");
 				if (obj)
 				{
 					if (id)
-						fz_drop_obj(id);
-					id = fz_keep_obj(obj);
+						pdf_drop_obj(id);
+					id = pdf_keep_obj(obj);
 				}
 
-				obj = fz_dict_gets(dict, "Root");
+				obj = pdf_dict_gets(dict, "Root");
 				if (obj)
 				{
 					if (root)
-						fz_drop_obj(root);
-					root = fz_keep_obj(obj);
+						pdf_drop_obj(root);
+					root = pdf_keep_obj(obj);
 				}
 
-				obj = fz_dict_gets(dict, "Info");
+				obj = pdf_dict_gets(dict, "Info");
 				if (obj)
 				{
 					if (info)
-						fz_drop_obj(info);
-					info = fz_keep_obj(obj);
+						pdf_drop_obj(info);
+					info = pdf_keep_obj(obj);
 				}
 
-				fz_drop_obj(dict);
+				pdf_drop_obj(dict);
 			}
 
 			else if (tok == PDF_TOK_ERROR)
@@ -394,11 +394,11 @@ pdf_repair_xref(pdf_document *xref, pdf_lexbuf *buf)
 				fz_lock(ctx, FZ_LOCK_FILE);
 				/* RJW: "cannot load stream object (%d %d R)", list[i].num, list[i].gen */
 
-				length = fz_new_int(ctx, list[i].stm_len);
-				fz_dict_puts(dict, "Length", length);
-				fz_drop_obj(length);
+				length = pdf_new_int(ctx, list[i].stm_len);
+				pdf_dict_puts(dict, "Length", length);
+				pdf_drop_obj(length);
 
-				fz_drop_obj(dict);
+				pdf_drop_obj(dict);
 			}
 
 		}
@@ -423,57 +423,57 @@ pdf_repair_xref(pdf_document *xref, pdf_lexbuf *buf)
 
 		/* create a repaired trailer, Root will be added later */
 
-		xref->trailer = fz_new_dict(ctx, 5);
+		xref->trailer = pdf_new_dict(ctx, 5);
 
-		obj = fz_new_int(ctx, maxnum + 1);
-		fz_dict_puts(xref->trailer, "Size", obj);
-		fz_drop_obj(obj);
+		obj = pdf_new_int(ctx, maxnum + 1);
+		pdf_dict_puts(xref->trailer, "Size", obj);
+		pdf_drop_obj(obj);
 
 		if (root)
 		{
-			fz_dict_puts(xref->trailer, "Root", root);
-			fz_drop_obj(root);
+			pdf_dict_puts(xref->trailer, "Root", root);
+			pdf_drop_obj(root);
 		}
 		if (info)
 		{
-			fz_dict_puts(xref->trailer, "Info", info);
-			fz_drop_obj(info);
+			pdf_dict_puts(xref->trailer, "Info", info);
+			pdf_drop_obj(info);
 		}
 
 		if (encrypt)
 		{
-			if (fz_is_indirect(encrypt))
+			if (pdf_is_indirect(encrypt))
 			{
 				/* create new reference with non-NULL xref pointer */
-				obj = fz_new_indirect(ctx, fz_to_num(encrypt), fz_to_gen(encrypt), xref);
-				fz_drop_obj(encrypt);
+				obj = pdf_new_indirect(ctx, pdf_to_num(encrypt), pdf_to_gen(encrypt), xref);
+				pdf_drop_obj(encrypt);
 				encrypt = obj;
 			}
-			fz_dict_puts(xref->trailer, "Encrypt", encrypt);
-			fz_drop_obj(encrypt);
+			pdf_dict_puts(xref->trailer, "Encrypt", encrypt);
+			pdf_drop_obj(encrypt);
 		}
 
 		if (id)
 		{
-			if (fz_is_indirect(id))
+			if (pdf_is_indirect(id))
 			{
 				/* create new reference with non-NULL xref pointer */
-				obj = fz_new_indirect(ctx, fz_to_num(id), fz_to_gen(id), xref);
-				fz_drop_obj(id);
+				obj = pdf_new_indirect(ctx, pdf_to_num(id), pdf_to_gen(id), xref);
+				pdf_drop_obj(id);
 				id = obj;
 			}
-			fz_dict_puts(xref->trailer, "ID", id);
-			fz_drop_obj(id);
+			pdf_dict_puts(xref->trailer, "ID", id);
+			pdf_drop_obj(id);
 		}
 
 		fz_free(ctx, list);
 	}
 	fz_catch(ctx)
 	{
-		if (encrypt) fz_drop_obj(encrypt);
-		if (id) fz_drop_obj(id);
-		if (root) fz_drop_obj(root);
-		if (info) fz_drop_obj(info);
+		if (encrypt) pdf_drop_obj(encrypt);
+		if (id) pdf_drop_obj(id);
+		if (root) pdf_drop_obj(root);
+		if (info) pdf_drop_obj(info);
 		fz_free(ctx, list);
 		fz_rethrow(ctx);
 	}
@@ -482,7 +482,7 @@ pdf_repair_xref(pdf_document *xref, pdf_lexbuf *buf)
 void
 pdf_repair_obj_stms(pdf_document *xref)
 {
-	fz_obj *dict;
+	pdf_obj *dict;
 	int i;
 
 	for (i = 0; i < xref->len; i++)
@@ -490,9 +490,9 @@ pdf_repair_obj_stms(pdf_document *xref)
 		if (xref->table[i].stm_ofs)
 		{
 			dict = pdf_load_object(xref, i, 0);
-			if (!strcmp(fz_to_name(fz_dict_gets(dict, "Type")), "ObjStm"))
+			if (!strcmp(pdf_to_name(pdf_dict_gets(dict, "Type")), "ObjStm"))
 				pdf_repair_obj_stm(xref, i, 0);
-			fz_drop_obj(dict);
+			pdf_drop_obj(dict);
 		}
 	}
 
diff --git a/pdf/pdf_shade.c b/pdf/pdf_shade.c
index 1be2bb15..c3bddcbc 100644
--- a/pdf/pdf_shade.c
+++ b/pdf/pdf_shade.c
@@ -363,9 +363,9 @@ pdf_sample_shade_function(fz_context *ctx, fz_shade *shade, int funcs, pdf_funct
 /* Type 1-3 -- Function-based, axial and radial shadings */
 
 static void
-pdf_load_function_based_shading(fz_shade *shade, pdf_document *xref, fz_obj *dict, pdf_function *func)
+pdf_load_function_based_shading(fz_shade *shade, pdf_document *xref, pdf_obj *dict, pdf_function *func)
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 	float x0, y0, x1, y1;
 	fz_matrix matrix;
 	struct vertex v[4];
@@ -377,18 +377,18 @@ pdf_load_function_based_shading(fz_shade *shade, pdf_document *xref, fz_obj *dic
 
 	x0 = y0 = 0;
 	x1 = y1 = 1;
-	obj = fz_dict_gets(dict, "Domain");
-	if (fz_array_len(obj) == 4)
+	obj = pdf_dict_gets(dict, "Domain");
+	if (pdf_array_len(obj) == 4)
 	{
-		x0 = fz_to_real(fz_array_get(obj, 0));
-		x1 = fz_to_real(fz_array_get(obj, 1));
-		y0 = fz_to_real(fz_array_get(obj, 2));
-		y1 = fz_to_real(fz_array_get(obj, 3));
+		x0 = pdf_to_real(pdf_array_get(obj, 0));
+		x1 = pdf_to_real(pdf_array_get(obj, 1));
+		y0 = pdf_to_real(pdf_array_get(obj, 2));
+		y1 = pdf_to_real(pdf_array_get(obj, 3));
 	}
 
 	matrix = fz_identity;
-	obj = fz_dict_gets(dict, "Matrix");
-	if (fz_array_len(obj) == 6)
+	obj = pdf_dict_gets(dict, "Matrix");
+	if (pdf_array_len(obj) == 6)
 		matrix = pdf_to_matrix(ctx, obj);
 
 	for (yy = 0; yy < FUNSEGS; yy++)
@@ -428,36 +428,36 @@ pdf_load_function_based_shading(fz_shade *shade, pdf_document *xref, fz_obj *dic
 }
 
 static void
-pdf_load_axial_shading(fz_shade *shade, pdf_document *xref, fz_obj *dict, int funcs, pdf_function **func)
+pdf_load_axial_shading(fz_shade *shade, pdf_document *xref, pdf_obj *dict, int funcs, pdf_function **func)
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 	float d0, d1;
 	int e0, e1;
 	float x0, y0, x1, y1;
 	struct vertex p1, p2;
 	fz_context *ctx = xref->ctx;
 
-	obj = fz_dict_gets(dict, "Coords");
-	x0 = fz_to_real(fz_array_get(obj, 0));
-	y0 = fz_to_real(fz_array_get(obj, 1));
-	x1 = fz_to_real(fz_array_get(obj, 2));
-	y1 = fz_to_real(fz_array_get(obj, 3));
+	obj = pdf_dict_gets(dict, "Coords");
+	x0 = pdf_to_real(pdf_array_get(obj, 0));
+	y0 = pdf_to_real(pdf_array_get(obj, 1));
+	x1 = pdf_to_real(pdf_array_get(obj, 2));
+	y1 = pdf_to_real(pdf_array_get(obj, 3));
 
 	d0 = 0;
 	d1 = 1;
-	obj = fz_dict_gets(dict, "Domain");
-	if (fz_array_len(obj) == 2)
+	obj = pdf_dict_gets(dict, "Domain");
+	if (pdf_array_len(obj) == 2)
 	{
-		d0 = fz_to_real(fz_array_get(obj, 0));
-		d1 = fz_to_real(fz_array_get(obj, 1));
+		d0 = pdf_to_real(pdf_array_get(obj, 0));
+		d1 = pdf_to_real(pdf_array_get(obj, 1));
 	}
 
 	e0 = e1 = 0;
-	obj = fz_dict_gets(dict, "Extend");
-	if (fz_array_len(obj) == 2)
+	obj = pdf_dict_gets(dict, "Extend");
+	if (pdf_array_len(obj) == 2)
 	{
-		e0 = fz_to_bool(fz_array_get(obj, 0));
-		e1 = fz_to_bool(fz_array_get(obj, 1));
+		e0 = pdf_to_bool(pdf_array_get(obj, 0));
+		e1 = pdf_to_bool(pdf_array_get(obj, 1));
 	}
 
 	pdf_sample_shade_function(ctx, shade, funcs, func, d0, d1);
@@ -479,38 +479,38 @@ pdf_load_axial_shading(fz_shade *shade, pdf_document *xref, fz_obj *dict, int fu
 }
 
 static void
-pdf_load_radial_shading(fz_shade *shade, pdf_document *xref, fz_obj *dict, int funcs, pdf_function **func)
+pdf_load_radial_shading(fz_shade *shade, pdf_document *xref, pdf_obj *dict, int funcs, pdf_function **func)
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 	float d0, d1;
 	int e0, e1;
 	float x0, y0, r0, x1, y1, r1;
 	struct vertex p1, p2;
 	fz_context *ctx = xref->ctx;
 
-	obj = fz_dict_gets(dict, "Coords");
-	x0 = fz_to_real(fz_array_get(obj, 0));
-	y0 = fz_to_real(fz_array_get(obj, 1));
-	r0 = fz_to_real(fz_array_get(obj, 2));
-	x1 = fz_to_real(fz_array_get(obj, 3));
-	y1 = fz_to_real(fz_array_get(obj, 4));
-	r1 = fz_to_real(fz_array_get(obj, 5));
+	obj = pdf_dict_gets(dict, "Coords");
+	x0 = pdf_to_real(pdf_array_get(obj, 0));
+	y0 = pdf_to_real(pdf_array_get(obj, 1));
+	r0 = pdf_to_real(pdf_array_get(obj, 2));
+	x1 = pdf_to_real(pdf_array_get(obj, 3));
+	y1 = pdf_to_real(pdf_array_get(obj, 4));
+	r1 = pdf_to_real(pdf_array_get(obj, 5));
 
 	d0 = 0;
 	d1 = 1;
-	obj = fz_dict_gets(dict, "Domain");
-	if (fz_array_len(obj) == 2)
+	obj = pdf_dict_gets(dict, "Domain");
+	if (pdf_array_len(obj) == 2)
 	{
-		d0 = fz_to_real(fz_array_get(obj, 0));
-		d1 = fz_to_real(fz_array_get(obj, 1));
+		d0 = pdf_to_real(pdf_array_get(obj, 0));
+		d1 = pdf_to_real(pdf_array_get(obj, 1));
 	}
 
 	e0 = e1 = 0;
-	obj = fz_dict_gets(dict, "Extend");
-	if (fz_array_len(obj) == 2)
+	obj = pdf_dict_gets(dict, "Extend");
+	if (pdf_array_len(obj) == 2)
 	{
-		e0 = fz_to_bool(fz_array_get(obj, 0));
-		e1 = fz_to_bool(fz_array_get(obj, 1));
+		e0 = pdf_to_bool(pdf_array_get(obj, 0));
+		e1 = pdf_to_bool(pdf_array_get(obj, 1));
 	}
 
 	pdf_sample_shade_function(ctx, shade, funcs, func, d0, d1);
@@ -553,9 +553,9 @@ struct mesh_params
 };
 
 static void
-pdf_load_mesh_params(pdf_document *xref, fz_obj *dict, struct mesh_params *p)
+pdf_load_mesh_params(pdf_document *xref, pdf_obj *dict, struct mesh_params *p)
 {
-	fz_obj *obj;
+	pdf_obj *obj;
 	int i, n;
 
 	p->x0 = p->y0 = 0;
@@ -566,23 +566,23 @@ pdf_load_mesh_params(pdf_document *xref, fz_obj *dict, struct mesh_params *p)
 		p->c1[i] = 1;
 	}
 
-	p->vprow = fz_to_int(fz_dict_gets(dict, "VerticesPerRow"));
-	p->bpflag = fz_to_int(fz_dict_gets(dict, "BitsPerFlag"));
-	p->bpcoord = fz_to_int(fz_dict_gets(dict, "BitsPerCoordinate"));
-	p->bpcomp = fz_to_int(fz_dict_gets(dict, "BitsPerComponent"));
+	p->vprow = pdf_to_int(pdf_dict_gets(dict, "VerticesPerRow"));
+	p->bpflag = pdf_to_int(pdf_dict_gets(dict, "BitsPerFlag"));
+	p->bpcoord = pdf_to_int(pdf_dict_gets(dict, "BitsPerCoordinate"));
+	p->bpcomp = pdf_to_int(pdf_dict_gets(dict, "BitsPerComponent"));
 
-	obj = fz_dict_gets(dict, "Decode");
-	if (fz_array_len(obj) >= 6)
+	obj = pdf_dict_gets(dict, "Decode");
+	if (pdf_array_len(obj) >= 6)
 	{
-		n = (fz_array_len(obj) - 4) / 2;
-		p->x0 = fz_to_real(fz_array_get(obj, 0));
-		p->x1 = fz_to_real(fz_array_get(obj, 1));
-		p->y0 = fz_to_real(fz_array_get(obj, 2));
-		p->y1 = fz_to_real(fz_array_get(obj, 3));
+		n = (pdf_array_len(obj) - 4) / 2;
+		p->x0 = pdf_to_real(pdf_array_get(obj, 0));
+		p->x1 = pdf_to_real(pdf_array_get(obj, 1));
+		p->y0 = pdf_to_real(pdf_array_get(obj, 2));
+		p->y1 = pdf_to_real(pdf_array_get(obj, 3));
 		for (i = 0; i < n; i++)
 		{
-			p->c0[i] = fz_to_real(fz_array_get(obj, 4 + i * 2));
-			p->c1[i] = fz_to_real(fz_array_get(obj, 5 + i * 2));
+			p->c0[i] = pdf_to_real(pdf_array_get(obj, 4 + i * 2));
+			p->c1[i] = pdf_to_real(pdf_array_get(obj, 5 + i * 2));
 		}
 	}
 
@@ -603,7 +603,7 @@ pdf_load_mesh_params(pdf_document *xref, fz_obj *dict, struct mesh_params *p)
 }
 
 static void
-pdf_load_type4_shade(fz_shade *shade, pdf_document *xref, fz_obj *dict,
+pdf_load_type4_shade(fz_shade *shade, pdf_document *xref, pdf_obj *dict,
 	int funcs, pdf_function **func)
 {
 	fz_context *ctx = xref->ctx;
@@ -624,7 +624,7 @@ pdf_load_type4_shade(fz_shade *shade, pdf_document *xref, fz_obj *dict,
 	else
 		ncomp = shade->colorspace->n;
 
-	stream = pdf_open_stream(xref, fz_to_num(dict), fz_to_gen(dict));
+	stream = pdf_open_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
 
 	while (!fz_is_eof_bits(stream))
 	{
@@ -672,7 +672,7 @@ pdf_load_type4_shade(fz_shade *shade, pdf_document *xref, fz_obj *dict,
 }
 
 static void
-pdf_load_type5_shade(fz_shade *shade, pdf_document *xref, fz_obj *dict,
+pdf_load_type5_shade(fz_shade *shade, pdf_document *xref, pdf_obj *dict,
 	int funcs, pdf_function **func)
 {
 	fz_context *ctx = xref->ctx;
@@ -697,7 +697,7 @@ pdf_load_type5_shade(fz_shade *shade, pdf_document *xref, fz_obj *dict,
 	buf = fz_malloc_array(ctx, p.vprow, sizeof(struct vertex));
 	first = 1;
 
-	stream = pdf_open_stream(xref, fz_to_num(dict), fz_to_gen(dict));
+	stream = pdf_open_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
 
 	while (!fz_is_eof_bits(stream))
 	{
@@ -726,7 +726,7 @@ pdf_load_type5_shade(fz_shade *shade, pdf_document *xref, fz_obj *dict,
 /* Type 6 & 7 -- Patch mesh shadings */
 
 static void
-pdf_load_type6_shade(fz_shade *shade, pdf_document *xref, fz_obj *dict,
+pdf_load_type6_shade(fz_shade *shade, pdf_document *xref, pdf_obj *dict,
 	int funcs, pdf_function **func)
 {
 	fz_context *ctx = xref->ctx;
@@ -750,7 +750,7 @@ pdf_load_type6_shade(fz_shade *shade, pdf_document *xref, fz_obj *dict,
 
 	hasprevpatch = 0;
 
-	stream = pdf_open_stream(xref, fz_to_num(dict), fz_to_gen(dict));
+	stream = pdf_open_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
 
 	while (!fz_is_eof_bits(stream))
 	{
@@ -849,7 +849,7 @@ pdf_load_type6_shade(fz_shade *shade, pdf_document *xref, fz_obj *dict,
 }
 
 static void
-pdf_load_type7_shade(fz_shade *shade, pdf_document *xref, fz_obj *dict,
+pdf_load_type7_shade(fz_shade *shade, pdf_document *xref, pdf_obj *dict,
 	int funcs, pdf_function **func)
 {
 	fz_context *ctx = xref->ctx;
@@ -873,7 +873,7 @@ pdf_load_type7_shade(fz_shade *shade, pdf_document *xref, fz_obj *dict,
 
 	hasprevpatch = 0;
 
-	stream = pdf_open_stream(xref, fz_to_num(dict), fz_to_gen(dict));
+	stream = pdf_open_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
 
 	while (!fz_is_eof_bits(stream))
 	{
@@ -974,11 +974,11 @@ pdf_load_type7_shade(fz_shade *shade, pdf_document *xref, fz_obj *dict,
 /* Load all of the shading dictionary parameters, then switch on the shading type. */
 
 static fz_shade *
-pdf_load_shading_dict(pdf_document *xref, fz_obj *dict, fz_matrix transform)
+pdf_load_shading_dict(pdf_document *xref, pdf_obj *dict, fz_matrix transform)
 {
 	fz_shade *shade = NULL;
 	pdf_function *func[FZ_MAX_COLORS] = { NULL };
-	fz_obj *obj;
+	pdf_obj *obj;
 	int funcs = 0;
 	int type = 0;
 	int i;
@@ -1009,49 +1009,49 @@ pdf_load_shading_dict(pdf_document *xref, fz_obj *dict, fz_matrix transform)
 
 		funcs = 0;
 
-		obj = fz_dict_gets(dict, "ShadingType");
-		type = fz_to_int(obj);
+		obj = pdf_dict_gets(dict, "ShadingType");
+		type = pdf_to_int(obj);
 
-		obj = fz_dict_gets(dict, "ColorSpace");
+		obj = pdf_dict_gets(dict, "ColorSpace");
 		if (!obj)
 			fz_throw(ctx, "shading colorspace is missing");
 		shade->colorspace = pdf_load_colorspace(xref, obj);
-		/* RJW: "cannot load colorspace (%d %d R)", fz_to_num(obj), fz_to_gen(obj) */
+		/* RJW: "cannot load colorspace (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj) */
 
-		obj = fz_dict_gets(dict, "Background");
+		obj = pdf_dict_gets(dict, "Background");
 		if (obj)
 		{
 			shade->use_background = 1;
 			for (i = 0; i < shade->colorspace->n; i++)
-				shade->background[i] = fz_to_real(fz_array_get(obj, i));
+				shade->background[i] = pdf_to_real(pdf_array_get(obj, i));
 		}
 
-		obj = fz_dict_gets(dict, "BBox");
-		if (fz_is_array(obj))
+		obj = pdf_dict_gets(dict, "BBox");
+		if (pdf_is_array(obj))
 		{
 			shade->bbox = pdf_to_rect(ctx, obj);
 		}
 
-		obj = fz_dict_gets(dict, "Function");
-		if (fz_is_dict(obj))
+		obj = pdf_dict_gets(dict, "Function");
+		if (pdf_is_dict(obj))
 		{
 			funcs = 1;
 
 			func[0] = pdf_load_function(xref, obj);
 			if (!func[0])
-				fz_throw(ctx, "cannot load shading function (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+				fz_throw(ctx, "cannot load shading function (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj));
 		}
-		else if (fz_is_array(obj))
+		else if (pdf_is_array(obj))
 		{
-			funcs = fz_array_len(obj);
+			funcs = pdf_array_len(obj);
 			if (funcs != 1 && funcs != shade->colorspace->n)
 				fz_throw(ctx, "incorrect number of shading functions");
 
 			for (i = 0; i < funcs; i++)
 			{
-				func[i] = pdf_load_function(xref, fz_array_get(obj, i));
+				func[i] = pdf_load_function(xref, pdf_array_get(obj, i));
 				if (!func[i])
-					fz_throw(ctx, "cannot load shading function (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+					fz_throw(ctx, "cannot load shading function (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj));
 			}
 		}
 
@@ -1079,7 +1079,7 @@ pdf_load_shading_dict(pdf_document *xref, fz_obj *dict, fz_matrix transform)
 				pdf_drop_function(ctx, func[i]);
 		fz_drop_shade(ctx, shade);
 
-		fz_throw(ctx, "cannot load shading type %d (%d %d R)", type, fz_to_num(dict), fz_to_gen(dict));
+		fz_throw(ctx, "cannot load shading type %d (%d %d R)", type, pdf_to_num(dict), pdf_to_gen(dict));
 	}
 	return shade;
 }
@@ -1093,10 +1093,10 @@ fz_shade_size(fz_shade *s)
 }
 
 fz_shade *
-pdf_load_shading(pdf_document *xref, fz_obj *dict)
+pdf_load_shading(pdf_document *xref, pdf_obj *dict)
 {
 	fz_matrix mat;
-	fz_obj *obj;
+	pdf_obj *obj;
 	fz_context *ctx = xref->ctx;
 	fz_shade *shade;
 
@@ -1106,36 +1106,36 @@ pdf_load_shading(pdf_document *xref, fz_obj *dict)
 	}
 
 	/* Type 2 pattern dictionary */
-	if (fz_dict_gets(dict, "PatternType"))
+	if (pdf_dict_gets(dict, "PatternType"))
 	{
-		obj = fz_dict_gets(dict, "Matrix");
+		obj = pdf_dict_gets(dict, "Matrix");
 		if (obj)
 			mat = pdf_to_matrix(ctx, obj);
 		else
 			mat = fz_identity;
 
-		obj = fz_dict_gets(dict, "ExtGState");
+		obj = pdf_dict_gets(dict, "ExtGState");
 		if (obj)
 		{
-			if (fz_dict_gets(obj, "CA") || fz_dict_gets(obj, "ca"))
+			if (pdf_dict_gets(obj, "CA") || pdf_dict_gets(obj, "ca"))
 			{
 				fz_warn(ctx, "shading with alpha not supported");
 			}
 		}
 
-		obj = fz_dict_gets(dict, "Shading");
+		obj = pdf_dict_gets(dict, "Shading");
 		if (!obj)
 			fz_throw(ctx, "syntaxerror: missing shading dictionary");
 
 		shade = pdf_load_shading_dict(xref, obj, mat);
-		/* RJW: "cannot load shading dictionary (%d %d R)", fz_to_num(obj), fz_to_gen(obj) */
+		/* RJW: "cannot load shading dictionary (%d %d R)", pdf_to_num(obj), pdf_to_gen(obj) */
 	}
 
 	/* Naked shading dictionary */
 	else
 	{
 		shade = pdf_load_shading_dict(xref, dict, fz_identity);
-		/* RJW: "cannot load shading dictionary (%d %d R)", fz_to_num(dict), fz_to_gen(dict) */
+		/* RJW: "cannot load shading dictionary (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict) */
 	}
 
 	pdf_store_item(ctx, dict, shade, fz_shade_size(shade));
diff --git a/pdf/pdf_store.c b/pdf/pdf_store.c
index 4f51526d..faa81b80 100644
--- a/pdf/pdf_store.c
+++ b/pdf/pdf_store.c
@@ -4,31 +4,43 @@
 static int
 pdf_make_hash_key(fz_store_hash *hash, void *key_)
 {
-	fz_obj *key = (fz_obj *)key_;
+	pdf_obj *key = (pdf_obj *)key_;
 
-	if (!fz_is_indirect(key))
+	if (!pdf_is_indirect(key))
 		return 0;
-	hash->u.i.i0 = fz_to_num(key);
-	hash->u.i.i1 = fz_to_gen(key);
+	hash->u.i.i0 = pdf_to_num(key);
+	hash->u.i.i1 = pdf_to_gen(key);
 	return 1;
 }
 
 static void *
 pdf_keep_key(fz_context *ctx, void *key)
 {
-	return (void *)fz_keep_obj((fz_obj *)key);
+	return (void *)pdf_keep_obj((pdf_obj *)key);
 }
 
 static void
 pdf_drop_key(fz_context *ctx, void *key)
 {
-	fz_drop_obj((fz_obj *)key);
+	pdf_drop_obj((pdf_obj *)key);
 }
 
 static int
 pdf_cmp_key(void *k0, void *k1)
 {
-	return fz_objcmp((fz_obj *)k0, (fz_obj *)k1);
+	return pdf_objcmp((pdf_obj *)k0, (pdf_obj *)k1);
+}
+
+static void
+pdf_debug_key(void *key_)
+{
+	pdf_obj *key = (pdf_obj *)key_;
+
+	if (pdf_is_indirect(key))
+	{
+		printf("(%d %d R) ", pdf_to_num(key), pdf_to_gen(key));
+	} else
+		pdf_debug_obj(key);
 }
 
 static fz_store_type pdf_obj_store_type =
@@ -36,23 +48,24 @@ static fz_store_type pdf_obj_store_type =
 	pdf_make_hash_key,
 	pdf_keep_key,
 	pdf_drop_key,
-	pdf_cmp_key
+	pdf_cmp_key,
+	pdf_debug_key
 };
 
 void
-pdf_store_item(fz_context *ctx, fz_obj *key, void *val, unsigned int itemsize)
+pdf_store_item(fz_context *ctx, pdf_obj *key, void *val, unsigned int itemsize)
 {
 	fz_store_item(ctx, key, val, itemsize, &pdf_obj_store_type);
 }
 
 void *
-pdf_find_item(fz_context *ctx, fz_store_free_fn *free, fz_obj *key)
+pdf_find_item(fz_context *ctx, fz_store_free_fn *free, pdf_obj *key)
 {
 	return fz_find_item(ctx, free, key, &pdf_obj_store_type);
 }
 
 void
-pdf_remove_item(fz_context *ctx, fz_store_free_fn *free, fz_obj *key)
+pdf_remove_item(fz_context *ctx, fz_store_free_fn *free, pdf_obj *key)
 {
 	fz_remove_item(ctx, free, key, &pdf_obj_store_type);
 }
diff --git a/pdf/pdf_stream.c b/pdf/pdf_stream.c
index 28fc616f..6afb2cdb 100644
--- a/pdf/pdf_stream.c
+++ b/pdf/pdf_stream.c
@@ -20,24 +20,24 @@ pdf_is_stream(pdf_document *xref, int num, int gen)
  * Scan stream dictionary for an explicit /Crypt filter
  */
 static int
-pdf_stream_has_crypt(fz_context *ctx, fz_obj *stm)
+pdf_stream_has_crypt(fz_context *ctx, pdf_obj *stm)
 {
-	fz_obj *filters;
-	fz_obj *obj;
+	pdf_obj *filters;
+	pdf_obj *obj;
 	int i;
 
-	filters = fz_dict_getsa(stm, "Filter", "F");
+	filters = pdf_dict_getsa(stm, "Filter", "F");
 	if (filters)
 	{
-		if (!strcmp(fz_to_name(filters), "Crypt"))
+		if (!strcmp(pdf_to_name(filters), "Crypt"))
 			return 1;
-		if (fz_is_array(filters))
+		if (pdf_is_array(filters))
 		{
-			int n = fz_array_len(filters);
+			int n = pdf_array_len(filters);
 			for (i = 0; i < n; i++)
 			{
-				obj = fz_array_get(filters, i);
-				if (!strcmp(fz_to_name(obj), "Crypt"))
+				obj = pdf_array_get(filters, i);
+				if (!strcmp(pdf_to_name(obj), "Crypt"))
 					return 1;
 			}
 		}
@@ -49,15 +49,15 @@ pdf_stream_has_crypt(fz_context *ctx, fz_obj *stm)
  * Create a filter given a name and param dictionary.
  */
 static fz_stream *
-build_filter(fz_stream *chain, pdf_document * xref, fz_obj * f, fz_obj * p, int num, int gen, pdf_image_params *params)
+build_filter(fz_stream *chain, pdf_document * xref, pdf_obj * f, pdf_obj * p, int num, int gen, pdf_image_params *params)
 {
 	fz_context *ctx = chain->ctx;
-	char *s = fz_to_name(f);
+	char *s = pdf_to_name(f);
 
-	int predictor = fz_to_int(fz_dict_gets(p, "Predictor"));
-	int columns = fz_to_int(fz_dict_gets(p, "Columns"));
-	int colors = fz_to_int(fz_dict_gets(p, "Colors"));
-	int bpc = fz_to_int(fz_dict_gets(p, "BitsPerComponent"));
+	int predictor = pdf_to_int(pdf_dict_gets(p, "Predictor"));
+	int columns = pdf_to_int(pdf_dict_gets(p, "Columns"));
+	int colors = pdf_to_int(pdf_dict_gets(p, "Colors"));
+	int bpc = pdf_to_int(pdf_dict_gets(p, "BitsPerComponent"));
 
 	if (predictor == 0) predictor = 1;
 	if (columns == 0) columns = 1;
@@ -72,47 +72,47 @@ build_filter(fz_stream *chain, pdf_document * xref, fz_obj * f, fz_obj * p, int
 
 	else if (!strcmp(s, "CCITTFaxDecode") || !strcmp(s, "CCF"))
 	{
-		fz_obj *k = fz_dict_gets(p, "K");
-		fz_obj *eol = fz_dict_gets(p, "EndOfLine");
-		fz_obj *eba = fz_dict_gets(p, "EncodedByteAlign");
-		fz_obj *columns = fz_dict_gets(p, "Columns");
-		fz_obj *rows = fz_dict_gets(p, "Rows");
-		fz_obj *eob = fz_dict_gets(p, "EndOfBlock");
-		fz_obj *bi1 = fz_dict_gets(p, "BlackIs1");
+		pdf_obj *k = pdf_dict_gets(p, "K");
+		pdf_obj *eol = pdf_dict_gets(p, "EndOfLine");
+		pdf_obj *eba = pdf_dict_gets(p, "EncodedByteAlign");
+		pdf_obj *columns = pdf_dict_gets(p, "Columns");
+		pdf_obj *rows = pdf_dict_gets(p, "Rows");
+		pdf_obj *eob = pdf_dict_gets(p, "EndOfBlock");
+		pdf_obj *bi1 = pdf_dict_gets(p, "BlackIs1");
 		if (params)
 		{
 			/* We will shortstop here */
 			params->type = PDF_IMAGE_FAX;
-			params->u.fax.k = (k ? fz_to_int(k) : 0);
-			params->u.fax.eol = (eol ? fz_to_bool(eol) : 0);
-			params->u.fax.eba = (eba ? fz_to_bool(eba) : 0);
-			params->u.fax.columns = (columns ? fz_to_int(columns) : 1728);
-			params->u.fax.rows = (rows ? fz_to_int(rows) : 0);
-			params->u.fax.eob = (eob ? fz_to_bool(eob) : 1);
-			params->u.fax.bi1 = (bi1 ? fz_to_bool(bi1) : 0);
+			params->u.fax.k = (k ? pdf_to_int(k) : 0);
+			params->u.fax.eol = (eol ? pdf_to_bool(eol) : 0);
+			params->u.fax.eba = (eba ? pdf_to_bool(eba) : 0);
+			params->u.fax.columns = (columns ? pdf_to_int(columns) : 1728);
+			params->u.fax.rows = (rows ? pdf_to_int(rows) : 0);
+			params->u.fax.eob = (eob ? pdf_to_bool(eob) : 1);
+			params->u.fax.bi1 = (bi1 ? pdf_to_bool(bi1) : 0);
 			return chain;
 		}
 		return fz_open_faxd(chain,
-				k ? fz_to_int(k) : 0,
-				eol ? fz_to_bool(eol) : 0,
-				eba ? fz_to_bool(eba) : 0,
-				columns ? fz_to_int(columns) : 1728,
-				rows ? fz_to_int(rows) : 0,
-				eob ? fz_to_bool(eob) : 1,
-				bi1 ? fz_to_bool(bi1) : 0);
+				k ? pdf_to_int(k) : 0,
+				eol ? pdf_to_bool(eol) : 0,
+				eba ? pdf_to_bool(eba) : 0,
+				columns ? pdf_to_int(columns) : 1728,
+				rows ? pdf_to_int(rows) : 0,
+				eob ? pdf_to_bool(eob) : 1,
+				bi1 ? pdf_to_bool(bi1) : 0);
 	}
 
 	else if (!strcmp(s, "DCTDecode") || !strcmp(s, "DCT"))
 	{
-		fz_obj *ct = fz_dict_gets(p, "ColorTransform");
+		pdf_obj *ct = pdf_dict_gets(p, "ColorTransform");
 		if (params)
 		{
 			/* We will shortstop here */
 			params->type = PDF_IMAGE_JPEG;
-			params->u.jpeg.ct = (ct ? fz_to_int(ct) : -1);
+			params->u.jpeg.ct = (ct ? pdf_to_int(ct) : -1);
 			return chain;
 		}
-		return fz_open_dctd(chain, ct ? fz_to_int(ct) : -1);
+		return fz_open_dctd(chain, ct ? pdf_to_int(ct) : -1);
 	}
 
 	else if (!strcmp(s, "RunLengthDecode") || !strcmp(s, "RL"))
@@ -145,7 +145,7 @@ build_filter(fz_stream *chain, pdf_document * xref, fz_obj * f, fz_obj * p, int
 
 	else if (!strcmp(s, "LZWDecode") || !strcmp(s, "LZW"))
 	{
-		fz_obj *ec = fz_dict_gets(p, "EarlyChange");
+		pdf_obj *ec = pdf_dict_gets(p, "EarlyChange");
 		if (params)
 		{
 			/* We will shortstop here */
@@ -154,10 +154,10 @@ build_filter(fz_stream *chain, pdf_document * xref, fz_obj * f, fz_obj * p, int
 			params->u.lzw.columns = columns;
 			params->u.lzw.colors = colors;
 			params->u.lzw.bpc = bpc;
-			params->u.lzw.ec = (ec ? fz_to_int(ec) : 1);
+			params->u.lzw.ec = (ec ? pdf_to_int(ec) : 1);
 			return chain;
 		}
-		chain = fz_open_lzwd(chain, ec ? fz_to_int(ec) : 1);
+		chain = fz_open_lzwd(chain, ec ? pdf_to_int(ec) : 1);
 		if (predictor > 1)
 			chain = fz_open_predict(chain, predictor, columns, colors, bpc);
 		return chain;
@@ -166,9 +166,9 @@ build_filter(fz_stream *chain, pdf_document * xref, fz_obj * f, fz_obj * p, int
 	else if (!strcmp(s, "JBIG2Decode"))
 	{
 		fz_buffer *globals = NULL;
-		fz_obj *obj = fz_dict_gets(p, "JBIG2Globals");
+		pdf_obj *obj = pdf_dict_gets(p, "JBIG2Globals");
 		if (obj)
-			globals = pdf_load_stream(xref, fz_to_num(obj), fz_to_gen(obj));
+			globals = pdf_load_stream(xref, pdf_to_num(obj), pdf_to_gen(obj));
 		/* fz_open_jbig2d takes possession of globals */
 		return fz_open_jbig2d(chain, globals);
 	}
@@ -178,7 +178,7 @@ build_filter(fz_stream *chain, pdf_document * xref, fz_obj * f, fz_obj * p, int
 
 	else if (!strcmp(s, "Crypt"))
 	{
-		fz_obj *name;
+		pdf_obj *name;
 
 		if (!xref->crypt)
 		{
@@ -186,9 +186,9 @@ build_filter(fz_stream *chain, pdf_document * xref, fz_obj * f, fz_obj * p, int
 			return chain;
 		}
 
-		name = fz_dict_gets(p, "Name");
-		if (fz_is_name(name))
-			return pdf_open_crypt_with_filter(chain, xref->crypt, fz_to_name(name), num, gen);
+		name = pdf_dict_gets(p, "Name");
+		if (pdf_is_name(name))
+			return pdf_open_crypt_with_filter(chain, xref->crypt, pdf_to_name(name), num, gen);
 
 		return chain;
 	}
@@ -203,17 +203,17 @@ build_filter(fz_stream *chain, pdf_document * xref, fz_obj * f, fz_obj * p, int
  * Assume ownership of head.
  */
 static fz_stream *
-build_filter_chain(fz_stream *chain, pdf_document *xref, fz_obj *fs, fz_obj *ps, int num, int gen, pdf_image_params *params)
+build_filter_chain(fz_stream *chain, pdf_document *xref, pdf_obj *fs, pdf_obj *ps, int num, int gen, pdf_image_params *params)
 {
-	fz_obj *f;
-	fz_obj *p;
+	pdf_obj *f;
+	pdf_obj *p;
 	int i, n;
 
-	n = fz_array_len(fs);
+	n = pdf_array_len(fs);
 	for (i = 0; i < n; i++)
 	{
-		f = fz_array_get(fs, i);
-		p = fz_array_get(ps, i);
+		f = pdf_array_get(fs, i);
+		p = pdf_array_get(ps, i);
 		chain = build_filter(chain, xref, f, p, num, gen, (i == n-1 ? params : NULL));
 	}
 
@@ -226,7 +226,7 @@ build_filter_chain(fz_stream *chain, pdf_document *xref, fz_obj *fs, fz_obj *ps,
  * stream length, followed by a decryption filter.
  */
 static fz_stream *
-pdf_open_raw_filter(fz_stream *chain, pdf_document *xref, fz_obj *stmobj, int num, int gen)
+pdf_open_raw_filter(fz_stream *chain, pdf_document *xref, pdf_obj *stmobj, int num, int gen)
 {
 	int hascrypt;
 	int len;
@@ -235,7 +235,7 @@ pdf_open_raw_filter(fz_stream *chain, pdf_document *xref, fz_obj *stmobj, int nu
 	/* don't close chain when we close this filter */
 	fz_keep_stream(chain);
 
-	len = fz_to_int(fz_dict_gets(stmobj, "Length"));
+	len = pdf_to_int(pdf_dict_gets(stmobj, "Length"));
 	chain = fz_open_null(chain, len);
 
 	fz_try(ctx)
@@ -258,19 +258,19 @@ pdf_open_raw_filter(fz_stream *chain, pdf_document *xref, fz_obj *stmobj, int nu
  * to stream length and decrypting.
  */
 static fz_stream *
-pdf_open_filter(fz_stream *chain, pdf_document *xref, fz_obj *stmobj, int num, int gen, pdf_image_params *imparams)
+pdf_open_filter(fz_stream *chain, pdf_document *xref, pdf_obj *stmobj, int num, int gen, pdf_image_params *imparams)
 {
-	fz_obj *filters;
-	fz_obj *params;
+	pdf_obj *filters;
+	pdf_obj *params;
 
-	filters = fz_dict_getsa(stmobj, "Filter", "F");
-	params = fz_dict_getsa(stmobj, "DecodeParms", "DP");
+	filters = pdf_dict_getsa(stmobj, "Filter", "F");
+	params = pdf_dict_getsa(stmobj, "DecodeParms", "DP");
 
 	chain = pdf_open_raw_filter(chain, xref, stmobj, num, gen);
 
-	if (fz_is_name(filters))
+	if (pdf_is_name(filters))
 		chain = build_filter(chain, xref, filters, params, num, gen, imparams);
-	else if (fz_array_len(filters) > 0)
+	else if (pdf_array_len(filters) > 0)
 		chain = build_filter_chain(chain, xref, filters, params, num, gen, imparams);
 
 	fz_lock_stream(chain);
@@ -282,20 +282,20 @@ pdf_open_filter(fz_stream *chain, pdf_document *xref, fz_obj *stmobj, int num, i
  * constraining to stream length, and without decryption.
  */
 fz_stream *
-pdf_open_inline_stream(pdf_document *xref, fz_obj *stmobj, int length, fz_stream *chain, pdf_image_params *imparams)
+pdf_open_inline_stream(pdf_document *xref, pdf_obj *stmobj, int length, fz_stream *chain, pdf_image_params *imparams)
 {
-	fz_obj *filters;
-	fz_obj *params;
+	pdf_obj *filters;
+	pdf_obj *params;
 
-	filters = fz_dict_getsa(stmobj, "Filter", "F");
-	params = fz_dict_getsa(stmobj, "DecodeParms", "DP");
+	filters = pdf_dict_getsa(stmobj, "Filter", "F");
+	params = pdf_dict_getsa(stmobj, "DecodeParms", "DP");
 
 	/* don't close chain when we close this filter */
 	fz_keep_stream(chain);
 
-	if (fz_is_name(filters))
+	if (pdf_is_name(filters))
 		return build_filter(chain, xref, filters, params, 0, 0, imparams);
-	if (fz_array_len(filters) > 0)
+	if (pdf_array_len(filters) > 0)
 		return build_filter_chain(chain, xref, filters, params, 0, 0, imparams);
 
 	return fz_open_null(chain, length);
@@ -408,7 +408,7 @@ pdf_open_image_decomp_stream(fz_context *ctx, fz_buffer *buffer, pdf_image_param
 }
 
 fz_stream *
-pdf_open_stream_with_offset(pdf_document *xref, int num, int gen, fz_obj *dict, int stm_ofs)
+pdf_open_stream_with_offset(pdf_document *xref, int num, int gen, pdf_obj *dict, int stm_ofs)
 {
 	fz_stream *stm;
 
@@ -427,16 +427,16 @@ fz_buffer *
 pdf_load_raw_stream(pdf_document *xref, int num, int gen)
 {
 	fz_stream *stm;
-	fz_obj *dict;
+	pdf_obj *dict;
 	int len;
 	fz_buffer *buf;
 
 	dict = pdf_load_object(xref, num, gen);
 	/* RJW: "cannot load stream dictionary (%d %d R)", num, gen */
 
-	len = fz_to_int(fz_dict_gets(dict, "Length"));
+	len = pdf_to_int(pdf_dict_gets(dict, "Length"));
 
-	fz_drop_obj(dict);
+	pdf_drop_obj(dict);
 
 	stm = pdf_open_raw_stream(xref, num, gen);
 	/* RJW: "cannot open raw stream (%d %d R)", num, gen */
@@ -478,7 +478,7 @@ pdf_load_image_stream(pdf_document *xref, int num, int gen, pdf_image_params *pa
 {
 	fz_context *ctx = xref->ctx;
 	fz_stream *stm = NULL;
-	fz_obj *dict, *obj;
+	pdf_obj *dict, *obj;
 	int i, len, n;
 	fz_buffer *buf;
 
@@ -487,14 +487,14 @@ pdf_load_image_stream(pdf_document *xref, int num, int gen, pdf_image_params *pa
 	dict = pdf_load_object(xref, num, gen);
 	/* RJW: "cannot load stream dictionary (%d %d R)", num, gen */
 
-	len = fz_to_int(fz_dict_gets(dict, "Length"));
-	obj = fz_dict_gets(dict, "Filter");
-	len = pdf_guess_filter_length(len, fz_to_name(obj));
-	n = fz_array_len(obj);
+	len = pdf_to_int(pdf_dict_gets(dict, "Length"));
+	obj = pdf_dict_gets(dict, "Filter");
+	len = pdf_guess_filter_length(len, pdf_to_name(obj));
+	n = pdf_array_len(obj);
 	for (i = 0; i < n; i++)
-		len = pdf_guess_filter_length(len, fz_to_name(fz_array_get(obj, i)));
+		len = pdf_guess_filter_length(len, pdf_to_name(pdf_array_get(obj, i)));
 
-	fz_drop_obj(dict);
+	pdf_drop_obj(dict);
 
 	stm = pdf_open_image_stream(xref, num, gen, params);
 	/* RJW: "cannot open stream (%d %d R)", num, gen */
diff --git a/pdf/pdf_type3.c b/pdf/pdf_type3.c
index 777ff756..7a3b985f 100644
--- a/pdf/pdf_type3.c
+++ b/pdf/pdf_type3.c
@@ -2,21 +2,30 @@
 #include "mupdf.h"
 
 static void
-pdf_run_glyph_func(void *doc, fz_obj *rdb, fz_buffer *contents, fz_device *dev, fz_matrix ctm, void *gstate)
+pdf_run_glyph_func(void *doc, void *rdb_, fz_buffer *contents, fz_device *dev, fz_matrix ctm, void *gstate)
 {
+	pdf_obj *rdb = (pdf_obj *)rdb_;
 	pdf_run_glyph(doc, rdb, contents, dev, ctm, gstate);
 }
 
+static void
+pdf_t3_free_resources(void *doc, void *rdb_)
+{
+	pdf_obj *rdb = (pdf_obj *)rdb;
+	pdf_drop_obj(rdb);
+}
+
+
 pdf_font_desc *
-pdf_load_type3_font(pdf_document *xref, fz_obj *rdb, fz_obj *dict)
+pdf_load_type3_font(pdf_document *xref, pdf_obj *rdb, pdf_obj *dict)
 {
 	char buf[256];
 	char *estrings[256];
 	pdf_font_desc *fontdesc = NULL;
-	fz_obj *encoding;
-	fz_obj *widths;
-	fz_obj *charprocs;
-	fz_obj *obj;
+	pdf_obj *encoding;
+	pdf_obj *widths;
+	pdf_obj *charprocs;
+	pdf_obj *obj;
 	int first, last;
 	int i, k, n;
 	fz_rect bbox;
@@ -27,18 +36,18 @@ pdf_load_type3_font(pdf_document *xref, fz_obj *rdb, fz_obj *dict)
 
 	fz_try(ctx)
 	{
-		obj = fz_dict_gets(dict, "Name");
-		if (fz_is_name(obj))
-			fz_strlcpy(buf, fz_to_name(obj), sizeof buf);
+		obj = pdf_dict_gets(dict, "Name");
+		if (pdf_is_name(obj))
+			fz_strlcpy(buf, pdf_to_name(obj), sizeof buf);
 		else
 			sprintf(buf, "Unnamed-T3");
 
 		fontdesc = pdf_new_font_desc(ctx);
 
-		obj = fz_dict_gets(dict, "FontMatrix");
+		obj = pdf_dict_gets(dict, "FontMatrix");
 		matrix = pdf_to_matrix(ctx, obj);
 
-		obj = fz_dict_gets(dict, "FontBBox");
+		obj = pdf_dict_gets(dict, "FontBBox");
 		bbox = pdf_to_rect(ctx, obj);
 		bbox = fz_transform_rect(matrix, bbox);
 
@@ -52,35 +61,35 @@ pdf_load_type3_font(pdf_document *xref, fz_obj *rdb, fz_obj *dict)
 		for (i = 0; i < 256; i++)
 			estrings[i] = NULL;
 
-		encoding = fz_dict_gets(dict, "Encoding");
+		encoding = pdf_dict_gets(dict, "Encoding");
 		if (!encoding)
 		{
 			fz_throw(ctx, "syntaxerror: Type3 font missing Encoding");
 		}
 
-		if (fz_is_name(encoding))
-			pdf_load_encoding(estrings, fz_to_name(encoding));
+		if (pdf_is_name(encoding))
+			pdf_load_encoding(estrings, pdf_to_name(encoding));
 
-		if (fz_is_dict(encoding))
+		if (pdf_is_dict(encoding))
 		{
-			fz_obj *base, *diff, *item;
+			pdf_obj *base, *diff, *item;
 
-			base = fz_dict_gets(encoding, "BaseEncoding");
-			if (fz_is_name(base))
-				pdf_load_encoding(estrings, fz_to_name(base));
+			base = pdf_dict_gets(encoding, "BaseEncoding");
+			if (pdf_is_name(base))
+				pdf_load_encoding(estrings, pdf_to_name(base));
 
-			diff = fz_dict_gets(encoding, "Differences");
-			if (fz_is_array(diff))
+			diff = pdf_dict_gets(encoding, "Differences");
+			if (pdf_is_array(diff))
 			{
-				n = fz_array_len(diff);
+				n = pdf_array_len(diff);
 				k = 0;
 				for (i = 0; i < n; i++)
 				{
-					item = fz_array_get(diff, i);
-					if (fz_is_int(item))
-						k = fz_to_int(item);
-					if (fz_is_name(item))
-						estrings[k++] = fz_to_name(item);
+					item = pdf_array_get(diff, i);
+					if (pdf_is_int(item))
+						k = pdf_to_int(item);
+					if (pdf_is_name(item))
+						estrings[k++] = pdf_to_name(item);
 					if (k < 0) k = 0;
 					if (k > 255) k = 255;
 				}
@@ -90,16 +99,16 @@ pdf_load_type3_font(pdf_document *xref, fz_obj *rdb, fz_obj *dict)
 		fontdesc->encoding = pdf_new_identity_cmap(ctx, 0, 1);
 		fontdesc->size += pdf_cmap_size(ctx, fontdesc->encoding);
 
-		pdf_load_to_unicode(xref, fontdesc, estrings, NULL, fz_dict_gets(dict, "ToUnicode"));
+		pdf_load_to_unicode(xref, fontdesc, estrings, NULL, pdf_dict_gets(dict, "ToUnicode"));
 
 		/* Widths */
 
 		pdf_set_default_hmtx(ctx, fontdesc, 0);
 
-		first = fz_to_int(fz_dict_gets(dict, "FirstChar"));
-		last = fz_to_int(fz_dict_gets(dict, "LastChar"));
+		first = pdf_to_int(pdf_dict_gets(dict, "FirstChar"));
+		last = pdf_to_int(pdf_dict_gets(dict, "LastChar"));
 
-		widths = fz_dict_gets(dict, "Widths");
+		widths = pdf_dict_gets(dict, "Widths");
 		if (!widths)
 		{
 			fz_throw(ctx, "syntaxerror: Type3 font missing Widths");
@@ -107,7 +116,7 @@ pdf_load_type3_font(pdf_document *xref, fz_obj *rdb, fz_obj *dict)
 
 		for (i = first; i <= last; i++)
 		{
-			float w = fz_to_real(fz_array_get(widths, i - first));
+			float w = pdf_to_real(pdf_array_get(widths, i - first));
 			w = fontdesc->font->t3matrix.a * w * 1000;
 			fontdesc->font->t3widths[i] = w * 0.001f;
 			pdf_add_hmtx(ctx, fontdesc, i, i, w);
@@ -117,11 +126,12 @@ pdf_load_type3_font(pdf_document *xref, fz_obj *rdb, fz_obj *dict)
 
 		/* Resources -- inherit page resources if the font doesn't have its own */
 
-		fontdesc->font->t3resources = fz_dict_gets(dict, "Resources");
+		fontdesc->font->t3freeres = pdf_t3_free_resources;
+		fontdesc->font->t3resources = pdf_dict_gets(dict, "Resources");
 		if (!fontdesc->font->t3resources)
 			fontdesc->font->t3resources = rdb;
 		if (fontdesc->font->t3resources)
-			fz_keep_obj(fontdesc->font->t3resources);
+			pdf_keep_obj(fontdesc->font->t3resources);
 		if (!fontdesc->font->t3resources)
 			fz_warn(ctx, "no resource dictionary for type 3 font!");
 
@@ -130,7 +140,7 @@ pdf_load_type3_font(pdf_document *xref, fz_obj *rdb, fz_obj *dict)
 
 		/* CharProcs */
 
-		charprocs = fz_dict_gets(dict, "CharProcs");
+		charprocs = pdf_dict_gets(dict, "CharProcs");
 		if (!charprocs)
 		{
 			fz_throw(ctx, "syntaxerror: Type3 font missing CharProcs");
@@ -140,10 +150,10 @@ pdf_load_type3_font(pdf_document *xref, fz_obj *rdb, fz_obj *dict)
 		{
 			if (estrings[i])
 			{
-				obj = fz_dict_gets(charprocs, estrings[i]);
-				if (pdf_is_stream(xref, fz_to_num(obj), fz_to_gen(obj)))
+				obj = pdf_dict_gets(charprocs, estrings[i]);
+				if (pdf_is_stream(xref, pdf_to_num(obj), pdf_to_gen(obj)))
 				{
-					fontdesc->font->t3procs[i] = pdf_load_stream(xref, fz_to_num(obj), fz_to_gen(obj));
+					fontdesc->font->t3procs[i] = pdf_load_stream(xref, pdf_to_num(obj), pdf_to_gen(obj));
 					fontdesc->size += fontdesc->font->t3procs[i]->cap;
 				}
 			}
@@ -154,7 +164,7 @@ pdf_load_type3_font(pdf_document *xref, fz_obj *rdb, fz_obj *dict)
 		if (fontdesc)
 			fz_drop_font(ctx, fontdesc->font);
 		fz_free(ctx, fontdesc);
-		fz_throw(ctx, "cannot load type3 font (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+		fz_throw(ctx, "cannot load type3 font (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict));
 	}
 	return fontdesc;
 }
diff --git a/pdf/pdf_unicode.c b/pdf/pdf_unicode.c
index d2534612..edfda708 100644
--- a/pdf/pdf_unicode.c
+++ b/pdf/pdf_unicode.c
@@ -5,7 +5,7 @@
 
 void
 pdf_load_to_unicode(pdf_document *xref, pdf_font_desc *font,
-	char **strings, char *collection, fz_obj *cmapstm)
+	char **strings, char *collection, pdf_obj *cmapstm)
 {
 	pdf_cmap *cmap;
 	int cid;
@@ -14,10 +14,10 @@ pdf_load_to_unicode(pdf_document *xref, pdf_font_desc *font,
 	int i;
 	fz_context *ctx = xref->ctx;
 
-	if (pdf_is_stream(xref, fz_to_num(cmapstm), fz_to_gen(cmapstm)))
+	if (pdf_is_stream(xref, pdf_to_num(cmapstm), pdf_to_gen(cmapstm)))
 	{
 		cmap = pdf_load_embedded_cmap(xref, cmapstm);
-		/* RJW: "cannot load embedded cmap (%d %d R)", fz_to_num(cmapstm), fz_to_gen(cmapstm) */
+		/* RJW: "cannot load embedded cmap (%d %d R)", pdf_to_num(cmapstm), pdf_to_gen(cmapstm) */
 
 		font->to_unicode = pdf_new_cmap(ctx);
 
diff --git a/pdf/pdf_xobject.c b/pdf/pdf_xobject.c
index 9f6d10ce..36c5c483 100644
--- a/pdf/pdf_xobject.c
+++ b/pdf/pdf_xobject.c
@@ -21,10 +21,10 @@ pdf_free_xobject_imp(fz_context *ctx, fz_storable *xobj_)
 	if (xobj->colorspace)
 		fz_drop_colorspace(ctx, xobj->colorspace);
 	if (xobj->resources)
-		fz_drop_obj(xobj->resources);
+		pdf_drop_obj(xobj->resources);
 	if (xobj->contents)
 		fz_drop_buffer(ctx, xobj->contents);
-	fz_drop_obj(xobj->me);
+	pdf_drop_obj(xobj->me);
 	fz_free(ctx, xobj);
 }
 
@@ -37,10 +37,10 @@ pdf_xobject_size(pdf_xobject *xobj)
 }
 
 pdf_xobject *
-pdf_load_xobject(pdf_document *xref, fz_obj *dict)
+pdf_load_xobject(pdf_document *xref, pdf_obj *dict)
 {
 	pdf_xobject *form;
-	fz_obj *obj;
+	pdf_obj *obj;
 	fz_context *ctx = xref->ctx;
 
 	if ((form = pdf_find_item(ctx, pdf_free_xobject_imp, dict)))
@@ -58,10 +58,10 @@ pdf_load_xobject(pdf_document *xref, fz_obj *dict)
 	/* Store item immediately, to avoid possible recursion if objects refer back to this one */
 	pdf_store_item(ctx, dict, form, pdf_xobject_size(form));
 
-	obj = fz_dict_gets(dict, "BBox");
+	obj = pdf_dict_gets(dict, "BBox");
 	form->bbox = pdf_to_rect(ctx, obj);
 
-	obj = fz_dict_gets(dict, "Matrix");
+	obj = pdf_dict_gets(dict, "Matrix");
 	if (obj)
 		form->matrix = pdf_to_matrix(ctx, obj);
 	else
@@ -71,19 +71,19 @@ pdf_load_xobject(pdf_document *xref, fz_obj *dict)
 	form->knockout = 0;
 	form->transparency = 0;
 
-	obj = fz_dict_gets(dict, "Group");
+	obj = pdf_dict_gets(dict, "Group");
 	if (obj)
 	{
-		fz_obj *attrs = obj;
+		pdf_obj *attrs = obj;
 
-		form->isolated = fz_to_bool(fz_dict_gets(attrs, "I"));
-		form->knockout = fz_to_bool(fz_dict_gets(attrs, "K"));
+		form->isolated = pdf_to_bool(pdf_dict_gets(attrs, "I"));
+		form->knockout = pdf_to_bool(pdf_dict_gets(attrs, "K"));
 
-		obj = fz_dict_gets(attrs, "S");
-		if (fz_is_name(obj) && !strcmp(fz_to_name(obj), "Transparency"))
+		obj = pdf_dict_gets(attrs, "S");
+		if (pdf_is_name(obj) && !strcmp(pdf_to_name(obj), "Transparency"))
 			form->transparency = 1;
 
-		obj = fz_dict_gets(attrs, "CS");
+		obj = pdf_dict_gets(attrs, "CS");
 		if (obj)
 		{
 			form->colorspace = pdf_load_colorspace(xref, obj);
@@ -92,21 +92,21 @@ pdf_load_xobject(pdf_document *xref, fz_obj *dict)
 		}
 	}
 
-	form->resources = fz_dict_gets(dict, "Resources");
+	form->resources = pdf_dict_gets(dict, "Resources");
 	if (form->resources)
-		fz_keep_obj(form->resources);
+		pdf_keep_obj(form->resources);
 
 	fz_try(ctx)
 	{
-		form->contents = pdf_load_stream(xref, fz_to_num(dict), fz_to_gen(dict));
+		form->contents = pdf_load_stream(xref, pdf_to_num(dict), pdf_to_gen(dict));
 	}
 	fz_catch(ctx)
 	{
 		pdf_remove_item(ctx, pdf_free_xobject_imp, dict);
 		pdf_drop_xobject(ctx, form);
-		fz_throw(ctx, "cannot load xobject content stream (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+		fz_throw(ctx, "cannot load xobject content stream (%d %d R)", pdf_to_num(dict), pdf_to_gen(dict));
 	}
-	form->me = fz_keep_obj(dict);
+	form->me = pdf_keep_obj(dict);
 
 	return form;
 }
diff --git a/pdf/pdf_xref.c b/pdf/pdf_xref.c
index 383747a7..3fec0ab6 100644
--- a/pdf/pdf_xref.c
+++ b/pdf/pdf_xref.c
@@ -178,7 +178,7 @@ pdf_resize_xref(pdf_document *xref, int newlen)
 	xref->len = newlen;
 }
 
-static fz_obj *
+static pdf_obj *
 pdf_read_old_xref(pdf_document *xref, pdf_lexbuf *buf)
 {
 	int ofs, len;
@@ -187,7 +187,7 @@ pdf_read_old_xref(pdf_document *xref, pdf_lexbuf *buf)
 	int tok;
 	int i;
 	int c;
-	fz_obj *trailer;
+	pdf_obj *trailer;
 
 	fz_read_line(xref->file, buf->scratch, buf->size);
 	if (strncmp(buf->scratch, "xref", 4) != 0)
@@ -295,13 +295,13 @@ pdf_read_new_xref_section(pdf_document *xref, fz_stream *stm, int i0, int i1, in
 
 /* Entered with file locked. Drops the lock in the middle, but then picks
  * it up again before exiting. */
-static fz_obj *
+static pdf_obj *
 pdf_read_new_xref(pdf_document *xref, pdf_lexbuf *buf)
 {
 	fz_stream *stm = NULL;
-	fz_obj *trailer = NULL;
-	fz_obj *index = NULL;
-	fz_obj *obj = NULL;
+	pdf_obj *trailer = NULL;
+	pdf_obj *index = NULL;
+	pdf_obj *obj = NULL;
 	int num, gen, stm_ofs;
 	int size, w0, w1, w2;
 	int t;
@@ -322,25 +322,25 @@ pdf_read_new_xref(pdf_document *xref, pdf_lexbuf *buf)
 	fz_try(ctx)
 	{
 		fz_unlock(ctx, FZ_LOCK_FILE);
-		obj = fz_dict_gets(trailer, "Size");
+		obj = pdf_dict_gets(trailer, "Size");
 		if (!obj)
 			fz_throw(ctx, "xref stream missing Size entry (%d %d R)", num, gen);
 
-		size = fz_to_int(obj);
+		size = pdf_to_int(obj);
 		if (size > xref->len)
 			pdf_resize_xref(xref, size);
 
 		if (num < 0 || num >= xref->len)
 			fz_throw(ctx, "object id (%d %d R) out of range (0..%d)", num, gen, xref->len - 1);
 
-		obj = fz_dict_gets(trailer, "W");
+		obj = pdf_dict_gets(trailer, "W");
 		if (!obj)
 			fz_throw(ctx, "xref stream missing W entry (%d %d R)", num, gen);
-		w0 = fz_to_int(fz_array_get(obj, 0));
-		w1 = fz_to_int(fz_array_get(obj, 1));
-		w2 = fz_to_int(fz_array_get(obj, 2));
+		w0 = pdf_to_int(pdf_array_get(obj, 0));
+		w1 = pdf_to_int(pdf_array_get(obj, 1));
+		w2 = pdf_to_int(pdf_array_get(obj, 2));
 
-		index = fz_dict_gets(trailer, "Index");
+		index = pdf_dict_gets(trailer, "Index");
 
 		stm = pdf_open_stream_with_offset(xref, num, gen, trailer, stm_ofs);
 		/* RJW: Ensure pdf_open_stream does fz_throw(ctx, "cannot open compressed xref stream (%d %d R)", num, gen); */
@@ -352,11 +352,11 @@ pdf_read_new_xref(pdf_document *xref, pdf_lexbuf *buf)
 		}
 		else
 		{
-			int n = fz_array_len(index);
+			int n = pdf_array_len(index);
 			for (t = 0; t < n; t += 2)
 			{
-				int i0 = fz_to_int(fz_array_get(index, t + 0));
-				int i1 = fz_to_int(fz_array_get(index, t + 1));
+				int i0 = pdf_to_int(pdf_array_get(index, t + 0));
+				int i1 = pdf_to_int(pdf_array_get(index, t + 1));
 				pdf_read_new_xref_section(xref, stm, i0, i1, w0, w1, w2);
 			}
 		}
@@ -367,8 +367,8 @@ pdf_read_new_xref(pdf_document *xref, pdf_lexbuf *buf)
 	}
 	fz_catch(ctx)
 	{
-		fz_drop_obj(trailer);
-		fz_drop_obj(index);
+		pdf_drop_obj(trailer);
+		pdf_drop_obj(index);
 		fz_rethrow(ctx);
 	}
 	fz_lock(ctx, FZ_LOCK_FILE);
@@ -377,12 +377,12 @@ pdf_read_new_xref(pdf_document *xref, pdf_lexbuf *buf)
 }
 
 /* File is locked on entry, and exit (but may be dropped in the middle) */
-static fz_obj *
+static pdf_obj *
 pdf_read_xref(pdf_document *xref, int ofs, pdf_lexbuf *buf)
 {
 	int c;
 	fz_context *ctx = xref->ctx;
-	fz_obj *trailer;
+	pdf_obj *trailer;
 
 	fz_seek(xref->file, ofs, 0);
 
@@ -409,9 +409,9 @@ pdf_read_xref(pdf_document *xref, int ofs, pdf_lexbuf *buf)
 static void
 pdf_read_xref_sections(pdf_document *xref, int ofs, pdf_lexbuf *buf)
 {
-	fz_obj *trailer = NULL;
-	fz_obj *xrefstm = NULL;
-	fz_obj *prev = NULL;
+	pdf_obj *trailer = NULL;
+	pdf_obj *xrefstm = NULL;
+	pdf_obj *prev = NULL;
 	fz_context *ctx = xref->ctx;
 
 	fz_try(ctx)
@@ -419,21 +419,21 @@ pdf_read_xref_sections(pdf_document *xref, int ofs, pdf_lexbuf *buf)
 		trailer = pdf_read_xref(xref, ofs, buf);
 
 		/* FIXME: do we overwrite free entries properly? */
-		xrefstm = fz_dict_gets(trailer, "XRefStm");
+		xrefstm = pdf_dict_gets(trailer, "XRefStm");
 		if (xrefstm)
-			pdf_read_xref_sections(xref, fz_to_int(xrefstm), buf);
+			pdf_read_xref_sections(xref, pdf_to_int(xrefstm), buf);
 
-		prev = fz_dict_gets(trailer, "Prev");
+		prev = pdf_dict_gets(trailer, "Prev");
 		if (prev)
-			pdf_read_xref_sections(xref, fz_to_int(prev), buf);
+			pdf_read_xref_sections(xref, pdf_to_int(prev), buf);
 	}
 	fz_catch(ctx)
 	{
-		fz_drop_obj(trailer);
+		pdf_drop_obj(trailer);
 		fz_throw(ctx, "cannot read xref at offset %d", ofs);
 	}
 
-	fz_drop_obj(trailer);
+	pdf_drop_obj(trailer);
 }
 
 /*
@@ -443,7 +443,7 @@ pdf_read_xref_sections(pdf_document *xref, int ofs, pdf_lexbuf *buf)
 static void
 pdf_load_xref(pdf_document *xref, pdf_lexbuf *buf)
 {
-	fz_obj *size;
+	pdf_obj *size;
 	int i;
 	fz_context *ctx = xref->ctx;
 
@@ -453,11 +453,11 @@ pdf_load_xref(pdf_document *xref, pdf_lexbuf *buf)
 
 	pdf_read_trailer(xref, buf);
 
-	size = fz_dict_gets(xref->trailer, "Size");
+	size = pdf_dict_gets(xref->trailer, "Size");
 	if (!size)
 		fz_throw(ctx, "trailer missing Size entry");
 
-	pdf_resize_xref(xref, fz_to_int(size));
+	pdf_resize_xref(xref, pdf_to_int(size));
 
 	pdf_read_xref_sections(xref, xref->startxref, buf);
 
@@ -488,10 +488,10 @@ pdf_ocg_set_config(pdf_document *xref, int config)
 {
 	int i, j, len, len2;
 	pdf_ocg_descriptor *desc = xref->ocg;
-	fz_obj *obj, *cobj;
+	pdf_obj *obj, *cobj;
 	char *name;
 
-	obj = fz_dict_gets(fz_dict_gets(xref->trailer, "Root"), "OCProperties");
+	obj = pdf_dict_gets(pdf_dict_gets(xref->trailer, "Root"), "OCProperties");
 	if (!obj)
 	{
 		if (config == 0)
@@ -501,25 +501,25 @@ pdf_ocg_set_config(pdf_document *xref, int config)
 	}
 	if (config == 0)
 	{
-		cobj = fz_dict_gets(obj, "D");
+		cobj = pdf_dict_gets(obj, "D");
 		if (!cobj)
 			fz_throw(xref->ctx, "No default OCG config");
 	}
 	else
 	{
-		cobj = fz_array_get(fz_dict_gets(obj, "Configs"), config);
+		cobj = pdf_array_get(pdf_dict_gets(obj, "Configs"), config);
 		if (!cobj)
 			fz_throw(xref->ctx, "Illegal OCG config");
 	}
 
 	if (desc->intent)
-		fz_drop_obj(desc->intent);
-	desc->intent = fz_dict_gets(cobj, "Intent");
+		pdf_drop_obj(desc->intent);
+	desc->intent = pdf_dict_gets(cobj, "Intent");
 	if (desc->intent)
-		fz_keep_obj(desc->intent);
+		pdf_keep_obj(desc->intent);
 
 	len = desc->len;
-	name = fz_to_name(fz_dict_gets(cobj, "BaseState"));
+	name = pdf_to_name(pdf_dict_gets(cobj, "BaseState"));
 	if (strcmp(name, "Unchanged") == 0)
 	{
 		/* Do nothing */
@@ -539,13 +539,13 @@ pdf_ocg_set_config(pdf_document *xref, int config)
 		}
 	}
 
-	obj = fz_dict_gets(cobj, "ON");
-	len2 = fz_array_len(obj);
+	obj = pdf_dict_gets(cobj, "ON");
+	len2 = pdf_array_len(obj);
 	for (i = 0; i < len2; i++)
 	{
-		fz_obj *o = fz_array_get(obj, i);
-		int n = fz_to_num(o);
-		int g = fz_to_gen(o);
+		pdf_obj *o = pdf_array_get(obj, i);
+		int n = pdf_to_num(o);
+		int g = pdf_to_gen(o);
 		for (j=0; j < len; j++)
 		{
 			if (desc->ocgs[j].num == n && desc->ocgs[j].gen == g)
@@ -556,13 +556,13 @@ pdf_ocg_set_config(pdf_document *xref, int config)
 		}
 	}
 
-	obj = fz_dict_gets(cobj, "OFF");
-	len2 = fz_array_len(obj);
+	obj = pdf_dict_gets(cobj, "OFF");
+	len2 = pdf_array_len(obj);
 	for (i = 0; i < len2; i++)
 	{
-		fz_obj *o = fz_array_get(obj, i);
-		int n = fz_to_num(o);
-		int g = fz_to_gen(o);
+		pdf_obj *o = pdf_array_get(obj, i);
+		int n = pdf_to_num(o);
+		int g = pdf_to_gen(o);
 		for (j=0; j < len; j++)
 		{
 			if (desc->ocgs[j].num == n && desc->ocgs[j].gen == g)
@@ -591,21 +591,21 @@ pdf_ocg_set_config(pdf_document *xref, int config)
 static void
 pdf_read_ocg(pdf_document *xref)
 {
-	fz_obj *obj, *ocg;
+	pdf_obj *obj, *ocg;
 	int len, i;
 	pdf_ocg_descriptor *desc;
 	fz_context *ctx = xref->ctx;
 
 	fz_var(desc);
 
-	obj = fz_dict_gets(fz_dict_gets(xref->trailer, "Root"), "OCProperties");
+	obj = pdf_dict_gets(pdf_dict_gets(xref->trailer, "Root"), "OCProperties");
 	if (!obj)
 		return;
-	ocg = fz_dict_gets(obj, "OCGs");
-	if (!ocg || !fz_is_array(ocg))
+	ocg = pdf_dict_gets(obj, "OCGs");
+	if (!ocg || !pdf_is_array(ocg))
 		/* Not ever supposed to happen, but live with it. */
 		return;
-	len = fz_array_len(ocg);
+	len = pdf_array_len(ocg);
 	fz_try(ctx)
 	{
 		desc = fz_calloc(ctx, 1, sizeof(*desc));
@@ -614,9 +614,9 @@ pdf_read_ocg(pdf_document *xref)
 		desc->intent = NULL;
 		for (i=0; i < len; i++)
 		{
-			fz_obj *o = fz_array_get(ocg, i);
-			desc->ocgs[i].num = fz_to_num(o);
-			desc->ocgs[i].gen = fz_to_gen(o);
+			pdf_obj *o = pdf_array_get(ocg, i);
+			desc->ocgs[i].num = pdf_to_num(o);
+			desc->ocgs[i].gen = pdf_to_gen(o);
 			desc->ocgs[i].state = 0;
 		}
 		xref->ocg = desc;
@@ -639,7 +639,7 @@ pdf_free_ocg(fz_context *ctx, pdf_ocg_descriptor *desc)
 		return;
 
 	if (desc->intent)
-		fz_drop_obj(desc->intent);
+		pdf_drop_obj(desc->intent);
 	fz_free(ctx, desc->ocgs);
 	fz_free(ctx, desc);
 }
@@ -655,10 +655,10 @@ pdf_document *
 pdf_open_document_with_stream(fz_stream *file)
 {
 	pdf_document *xref;
-	fz_obj *encrypt, *id;
-	fz_obj *dict = NULL;
-	fz_obj *obj;
-	fz_obj *nobj = NULL;
+	pdf_obj *encrypt, *id;
+	pdf_obj *dict = NULL;
+	pdf_obj *obj;
+	pdf_obj *nobj = NULL;
 	int i, repaired = 0;
 	int locked;
 	fz_context *ctx = file->ctx;
@@ -667,12 +667,9 @@ pdf_open_document_with_stream(fz_stream *file)
 	fz_var(nobj);
 	fz_var(locked);
 
-	/* install pdf specific callback */
-	fz_resolve_indirect = pdf_resolve_indirect;
-
 	xref = fz_malloc_struct(ctx, pdf_document);
 	pdf_init_document(xref);
-        xref->lexbuf.base.size = PDF_LEXBUF_LARGE;
+	xref->lexbuf.base.size = PDF_LEXBUF_LARGE;
 
 	xref->file = fz_keep_stream(file);
 	xref->ctx = ctx;
@@ -694,7 +691,7 @@ pdf_open_document_with_stream(fz_stream *file)
 		}
 		if (xref->trailer)
 		{
-			fz_drop_obj(xref->trailer);
+			pdf_drop_obj(xref->trailer);
 			xref->trailer = NULL;
 		}
 		fz_warn(xref->ctx, "trying to repair broken xref");
@@ -711,9 +708,9 @@ pdf_open_document_with_stream(fz_stream *file)
 		fz_unlock(ctx, FZ_LOCK_FILE);
 		locked = 0;
 
-		encrypt = fz_dict_gets(xref->trailer, "Encrypt");
-		id = fz_dict_gets(xref->trailer, "ID");
-		if (fz_is_dict(encrypt))
+		encrypt = pdf_dict_gets(xref->trailer, "Encrypt");
+		id = pdf_dict_gets(xref->trailer, "ID");
+		if (pdf_is_dict(encrypt))
 			xref->crypt = pdf_new_crypt(ctx, encrypt, id);
 
 		/* Allow lazy clients to read encrypted files with a blank password */
@@ -723,8 +720,8 @@ pdf_open_document_with_stream(fz_stream *file)
 		{
 			pdf_repair_obj_stms(xref);
 
-			hasroot = (fz_dict_gets(xref->trailer, "Root") != NULL);
-			hasinfo = (fz_dict_gets(xref->trailer, "Info") != NULL);
+			hasroot = (pdf_dict_gets(xref->trailer, "Root") != NULL);
+			hasinfo = (pdf_dict_gets(xref->trailer, "Info") != NULL);
 
 			for (i = 1; i < xref->len; i++)
 			{
@@ -743,28 +740,28 @@ pdf_open_document_with_stream(fz_stream *file)
 
 				if (!hasroot)
 				{
-					obj = fz_dict_gets(dict, "Type");
-					if (fz_is_name(obj) && !strcmp(fz_to_name(obj), "Catalog"))
+					obj = pdf_dict_gets(dict, "Type");
+					if (pdf_is_name(obj) && !strcmp(pdf_to_name(obj), "Catalog"))
 					{
-						nobj = fz_new_indirect(ctx, i, 0, xref);
-						fz_dict_puts(xref->trailer, "Root", nobj);
-						fz_drop_obj(nobj);
+						nobj = pdf_new_indirect(ctx, i, 0, xref);
+						pdf_dict_puts(xref->trailer, "Root", nobj);
+						pdf_drop_obj(nobj);
 						nobj = NULL;
 					}
 				}
 
 				if (!hasinfo)
 				{
-					if (fz_dict_gets(dict, "Creator") || fz_dict_gets(dict, "Producer"))
+					if (pdf_dict_gets(dict, "Creator") || pdf_dict_gets(dict, "Producer"))
 					{
-						nobj = fz_new_indirect(ctx, i, 0, xref);
-						fz_dict_puts(xref->trailer, "Info", nobj);
-						fz_drop_obj(nobj);
+						nobj = pdf_new_indirect(ctx, i, 0, xref);
+						pdf_dict_puts(xref->trailer, "Info", nobj);
+						pdf_drop_obj(nobj);
 						nobj = NULL;
 					}
 				}
 
-				fz_drop_obj(dict);
+				pdf_drop_obj(dict);
 				dict = NULL;
 			}
 		}
@@ -776,8 +773,8 @@ pdf_open_document_with_stream(fz_stream *file)
 	}
 	fz_catch(ctx)
 	{
-		fz_drop_obj(dict);
-		fz_drop_obj(nobj);
+		pdf_drop_obj(dict);
+		pdf_drop_obj(nobj);
 		pdf_close_document(xref);
 		fz_throw(ctx, "cannot open document");
 	}
@@ -810,7 +807,7 @@ pdf_close_document(pdf_document *xref)
 		{
 			if (xref->table[i].obj)
 			{
-				fz_drop_obj(xref->table[i].obj);
+				pdf_drop_obj(xref->table[i].obj);
 				xref->table[i].obj = NULL;
 			}
 		}
@@ -820,21 +817,21 @@ pdf_close_document(pdf_document *xref)
 	if (xref->page_objs)
 	{
 		for (i = 0; i < xref->page_len; i++)
-			fz_drop_obj(xref->page_objs[i]);
+			pdf_drop_obj(xref->page_objs[i]);
 		fz_free(ctx, xref->page_objs);
 	}
 
 	if (xref->page_refs)
 	{
 		for (i = 0; i < xref->page_len; i++)
-			fz_drop_obj(xref->page_refs[i]);
+			pdf_drop_obj(xref->page_refs[i]);
 		fz_free(ctx, xref->page_refs);
 	}
 
 	if (xref->file)
 		fz_close(xref->file);
 	if (xref->trailer)
-		fz_drop_obj(xref->trailer);
+		pdf_drop_obj(xref->trailer);
 	if (xref->crypt)
 		pdf_free_crypt(ctx, xref->crypt);
 
@@ -868,11 +865,11 @@ static void
 pdf_load_obj_stm(pdf_document *xref, int num, int gen, pdf_lexbuf *buf)
 {
 	fz_stream *stm = NULL;
-	fz_obj *objstm = NULL;
+	pdf_obj *objstm = NULL;
 	int *numbuf = NULL;
 	int *ofsbuf = NULL;
 
-	fz_obj *obj;
+	pdf_obj *obj;
 	int first;
 	int count;
 	int i;
@@ -888,8 +885,8 @@ pdf_load_obj_stm(pdf_document *xref, int num, int gen, pdf_lexbuf *buf)
 	{
 		objstm = pdf_load_object(xref, num, gen);
 
-		count = fz_to_int(fz_dict_gets(objstm, "N"));
-		first = fz_to_int(fz_dict_gets(objstm, "First"));
+		count = pdf_to_int(pdf_dict_gets(objstm, "N"));
+		first = pdf_to_int(pdf_dict_gets(objstm, "First"));
 
 		numbuf = fz_calloc(ctx, count, sizeof(int));
 		ofsbuf = fz_calloc(ctx, count, sizeof(int));
@@ -919,19 +916,19 @@ pdf_load_obj_stm(pdf_document *xref, int num, int gen, pdf_lexbuf *buf)
 
 			if (numbuf[i] < 1 || numbuf[i] >= xref->len)
 			{
-				fz_drop_obj(obj);
+				pdf_drop_obj(obj);
 				fz_throw(ctx, "object id (%d 0 R) out of range (0..%d)", numbuf[i], xref->len - 1);
 			}
 
 			if (xref->table[numbuf[i]].type == 'o' && xref->table[numbuf[i]].ofs == num)
 			{
 				if (xref->table[numbuf[i]].obj)
-					fz_drop_obj(xref->table[numbuf[i]].obj);
+					pdf_drop_obj(xref->table[numbuf[i]].obj);
 				xref->table[numbuf[i]].obj = obj;
 			}
 			else
 			{
-				fz_drop_obj(obj);
+				pdf_drop_obj(obj);
 			}
 		}
 	}
@@ -940,7 +937,7 @@ pdf_load_obj_stm(pdf_document *xref, int num, int gen, pdf_lexbuf *buf)
 		fz_close(stm);
 		fz_free(xref->ctx, ofsbuf);
 		fz_free(xref->ctx, numbuf);
-		fz_drop_obj(objstm);
+		pdf_drop_obj(objstm);
 	}
 	fz_catch(ctx)
 	{
@@ -969,7 +966,7 @@ pdf_cache_object(pdf_document *xref, int num, int gen)
 
 	if (x->type == 'f')
 	{
-		x->obj = fz_new_null(ctx);
+		x->obj = pdf_new_null(ctx);
 		return;
 	}
 	else if (x->type == 'n')
@@ -990,7 +987,7 @@ pdf_cache_object(pdf_document *xref, int num, int gen)
 
 		if (rnum != num)
 		{
-			fz_drop_obj(x->obj);
+			pdf_drop_obj(x->obj);
 			x->obj = NULL;
 			fz_unlock(ctx, FZ_LOCK_FILE);
 			fz_throw(ctx, "found object (%d %d R) instead of (%d %d R)", rnum, rgen, num, gen);
@@ -1022,7 +1019,7 @@ pdf_cache_object(pdf_document *xref, int num, int gen)
 	}
 }
 
-fz_obj *
+pdf_obj *
 pdf_load_object(pdf_document *xref, int num, int gen)
 {
 	fz_context *ctx = xref->ctx;
@@ -1038,11 +1035,11 @@ pdf_load_object(pdf_document *xref, int num, int gen)
 
 	assert(xref->table[num].obj);
 
-	return fz_keep_obj(xref->table[num].obj);
+	return pdf_keep_obj(xref->table[num].obj);
 }
 
-fz_obj *
-pdf_resolve_indirect(fz_obj *ref)
+pdf_obj *
+pdf_resolve_indirect(pdf_obj *ref)
 {
 	int sanity = 10;
 	int num;
@@ -1050,16 +1047,16 @@ pdf_resolve_indirect(fz_obj *ref)
 	fz_context *ctx = NULL; /* Avoid warning for stupid compilers */
 	pdf_document *xref;
 
-	while (fz_is_indirect(ref))
+	while (pdf_is_indirect(ref))
 	{
 		if (--sanity == 0)
 			fz_throw(ctx, "Too many indirections (possible indirection cycle involving %d %d R)", num, gen);
-		xref = fz_get_indirect_document(ref);
+		xref = pdf_get_indirect_document(ref);
 		if (!xref)
 			return NULL;
 		ctx = xref->ctx;
-		num = fz_to_num(ref);
-		gen = fz_to_gen(ref);
+		num = pdf_to_num(ref);
+		gen = pdf_to_gen(ref);
 		fz_try(ctx)
 		{
 			pdf_cache_object(xref, num, gen);
@@ -1079,7 +1076,7 @@ pdf_resolve_indirect(fz_obj *ref)
 
 /* Replace numbered object -- for use by pdfclean and similar tools */
 void
-pdf_update_object(pdf_document *xref, int num, int gen, fz_obj *newobj)
+pdf_update_object(pdf_document *xref, int num, int gen, pdf_obj *newobj)
 {
 	pdf_xref_entry *x;
 
@@ -1092,9 +1089,9 @@ pdf_update_object(pdf_document *xref, int num, int gen, fz_obj *newobj)
 	x = &xref->table[num];
 
 	if (x->obj)
-		fz_drop_obj(x->obj);
+		pdf_drop_obj(x->obj);
 
-	x->obj = fz_keep_obj(newobj);
+	x->obj = pdf_keep_obj(newobj);
 	x->type = 'n';
 	x->ofs = 0;
 }
diff --git a/scripts/rename2.sed b/scripts/rename2.sed
new file mode 100644
index 00000000..152d9613
--- /dev/null
+++ b/scripts/rename2.sed
@@ -0,0 +1,75 @@
+s/fz_obj/pdf_obj/g
+s/pdf_resolve_indirect/pdf_resolve_indirect_imp/g
+s/fz_resolve_indirect/pdf_resolve_indirect/g
+s/fz_new_null/pdf_new_null/g
+s/fz_new_bool/pdf_new_bool/g
+s/fz_new_int/pdf_new_int/g
+s/fz_new_real/pdf_new_real/g
+s/fz_new_string/pdf_new_string/g
+s/fz_new_indirect/pdf_new_indirect/g
+s/fz_new_array/pdf_new_array/g
+s/fz_new_dict/pdf_new_dict/g
+s/fz_copy_array/pdf_copy_array/g
+s/fz_copy_dict/pdf_copy_dict/g
+s/fz_keep_obj/pdf_keep_obj/g
+s/fz_drop_obj/pdf_drop_obj/g
+s/fz_is_null/pdf_is_null/g
+s/fz_is_bool/pdf_is_bool/g
+s/fz_is_int/pdf_is_int/g
+s/fz_is_real/pdf_is_real/g
+s/fz_is_name/pdf_is_name/g
+s/fz_is_string/pdf_is_string/g
+s/fz_is_array/pdf_is_array/g
+s/fz_is_dict/pdf_is_dict/g
+s/fz_is_indirect/pdf_is_indirect/g
+s/fz_objcmp/pdf_objcmp/g
+s/fz_dict_marked/pdf_dict_marked/g
+s/fz_dict_mark/pdf_dict_mark/g
+s/fz_dict_unmark/pdf_dict_unmark/g
+s/fz_to_bool/pdf_to_bool/g
+s/fz_to_int/pdf_to_int/g
+s/fz_to_real/pdf_to_real/g
+s/fz_to_name/pdf_to_name/g
+s/fz_to_str_buf/pdf_to_str_buf/g
+s/fz_to_dict/pdf_to_dict/g
+s/fz_to_str_len/pdf_to_str_len/g
+s/fz_to_num/pdf_to_num/g
+s/fz_to_gen/pdf_to_gen/g
+s/fz_array_len/pdf_array_len/g
+s/fz_array_get/pdf_array_get/g
+s/fz_array_put/pdf_array_put/g
+s/fz_array_push/pdf_array_push/g
+s/fz_array_insert/pdf_array_insert/g
+s/fz_array_contains/pdf_array_contains/g
+s/fz_dict_len/pdf_dict_len/g
+s/fz_dict_get_val/pdf_dict_get_val/g
+s/fz_dict_get_key/pdf_dict_get_key/g
+s/fz_dict_get/pdf_dict_get/g
+s/fz_dict_gets/pdf_dict_gets/g
+s/fz_dict_getsa/pdf_dict_getsa/g
+s/fz_dict_put/fz_dict_put/g
+s/fz_dict_puts/pdf_dict_puts/g
+s/fz_dict_del/pdf_dict_del/g
+s/fz_dict_dels/pdf_dict_dels/g
+s/fz_sort_dict/pdf_sort_dict/g
+s/fz_fprint_obj/pdf_fprint_obj/g
+s/fz_debug_obj/pdf_debug_obj/g
+s/fz_debug_ref/pdf_debug_ref/g
+s/fz_set_str_len/pdf_set_str_len/g
+s/fz_get_indirect_document/pdf_get_indirect_document/g
+s/FZ_NULL/PDF_NULL/g
+s/FZ_BOOL/PDF_BOOL/g
+s/FZ_INT/PDF_INT/g
+s/FZ_REAL/PDF_REAL/g
+s/FZ_STRING/PDF_STRING/g
+s/FZ_NAME/PDF_NAME/g
+s/FZ_ARRAY/PDF_ARRAY/g
+s/FZ_DICT/PDF_DICT/g
+s/FZ_INDIRECT/PDF_INDIRECT/g
+s/fz_objkindstr/pdf_objkindstr/g
+s/fz_array_grow/pdf_array_grow/g
+s/fz_dict_grow/pdf_dict_grow/g
+s/fz_dict_finds/pdf_dict_finds/g
+s/fz_free_array/pdf_free_array/g
+s/fz_free_dict/pdf_free_dict/g
+s/fz_sprint_obj/pdf_sprint_obj/g