Remove fz_outofmem constant.

77 files changed, 486 insertions, 486 deletions

diff --git a/apps/pdfclean.c b/apps/pdfclean.c
index 208d2786..5c8bd981 100644
--- a/apps/pdfclean.c
+++ b/apps/pdfclean.c
@@ -24,9 +24,9 @@ int doencrypt = 0;
 int dogarbage = 0;
 int doexpand = 0;
 
-void die(fz_error eo)
+void die(fz_error error)
 {
-    fz_catch(eo, "aborting");
+    fz_catch(error, "aborting");
     exit(1);
 }
 
diff --git a/apps/pdfinfo.c b/apps/pdfinfo.c
index 46bf11f0..1680f1b1 100644
--- a/apps/pdfinfo.c
+++ b/apps/pdfinfo.c
@@ -230,7 +230,7 @@ gatherglobalinfo()
 	info->u.info.obj = src->info;
 }
 
-fz_error 
+fz_error
 gatherdimensions(int page, fz_obj *pageref, fz_obj *pageobj)
 {
 	fz_error error;
@@ -280,7 +280,7 @@ gatherdimensions(int page, fz_obj *pageref, fz_obj *pageobj)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 gatherfonts(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 {
 	fz_error error;
@@ -365,7 +365,7 @@ gatherfonts(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 gatherimages(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 {
 	fz_error error;
@@ -557,7 +557,7 @@ gatherimages(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 gatherforms(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 {
 	fz_error error;
@@ -655,7 +655,7 @@ gatherforms(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 gatherpsobjs(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 {
 	fz_error error;
@@ -730,7 +730,7 @@ gatherpsobjs(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 gathershadings(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 {
 	fz_error error;
@@ -790,7 +790,7 @@ gathershadings(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 gatherpatterns(int page, fz_obj *pageref, fz_obj *pageobj, fz_obj *dict)
 {
 	fz_error error;
diff --git a/fitz/base_hash.c b/fitz/base_hash.c
index 894d33e0..1b817209 100644
--- a/fitz/base_hash.c
+++ b/fitz/base_hash.c
@@ -45,7 +45,7 @@ static unsigned hash(unsigned char *s, int len)
 	return hash;
 }
 
-fz_error 
+fz_error
 fz_newhash(fz_hashtable **tablep, int initialsize, int keylen)
 {
 	fz_hashtable *table;
@@ -54,7 +54,7 @@ fz_newhash(fz_hashtable **tablep, int initialsize, int keylen)
 
 	table = *tablep = fz_malloc(sizeof(fz_hashtable));
 	if (!table)
-		return fz_throw("outofmem: hash table struct");
+		return fz_rethrow(-1, "out of memory: hash table struct");
 
 	table->keylen = keylen;
 	table->size = initialsize;
@@ -65,7 +65,7 @@ fz_newhash(fz_hashtable **tablep, int initialsize, int keylen)
 	{
 		fz_free(table);
 		*tablep = nil;
-		return fz_throw("outofmem: hash table entries (size=%d)", initialsize);
+		return fz_rethrow(-1, "out of memory: hash table entries (size=%d)", initialsize);
 	}
 
 	memset(table->ents, 0, sizeof(fz_hashentry) * table->size);
@@ -105,7 +105,7 @@ fz_drophash(fz_hashtable *table)
 	fz_free(table);
 }
 
-fz_error 
+fz_error
 fz_resizehash(fz_hashtable *table, int newsize)
 {
 	fz_error error;
@@ -124,7 +124,7 @@ fz_resizehash(fz_hashtable *table, int newsize)
 
 	newents = fz_malloc(sizeof(fz_hashentry) * newsize);
 	if (!newents)
-		return fz_throw("outofmem: hash table (size=%d)", newsize);
+		return fz_rethrow(-1, "out of memory: hash table (size=%d)", newsize);
 
 	table->size = newsize;
 	table->load = 0;
@@ -171,7 +171,7 @@ fz_hashfind(fz_hashtable *table, void *key)
 	}
 }
 
-fz_error 
+fz_error
 fz_hashinsert(fz_hashtable *table, void *key, void *val)
 {
 	fz_error error;
@@ -209,7 +209,7 @@ fz_hashinsert(fz_hashtable *table, void *key, void *val)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_hashremove(fz_hashtable *table, void *key)
 {
 	fz_hashentry *ents = table->ents;
diff --git a/fitz/filt_a85d.c b/fitz/filt_a85d.c
index f064091c..8d485a3c 100644
--- a/fitz/filt_a85d.c
+++ b/fitz/filt_a85d.c
@@ -20,7 +20,7 @@ static inline int iswhite(int a)
 	return 0;
 }
 
-fz_error 
+fz_error
 fz_newa85d(fz_filter **fp, fz_obj *params)
 {
 	FZ_NEWFILTER(fz_a85d, f, a85d);
@@ -34,7 +34,7 @@ fz_dropa85d(fz_filter *f)
 {
 }
 
-fz_error 
+fz_error
 fz_processa85d(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_a85d *f = (fz_a85d*)filter;
diff --git a/fitz/filt_a85e.c b/fitz/filt_a85e.c
index 6b06cd77..e2450bb5 100644
--- a/fitz/filt_a85e.c
+++ b/fitz/filt_a85e.c
@@ -9,7 +9,7 @@ struct fz_a85e_s
 	int c;
 };
 
-fz_error 
+fz_error
 fz_newa85e(fz_filter **fp, fz_obj *params)
 {
 	FZ_NEWFILTER(fz_a85e, f, a85e);
@@ -22,7 +22,7 @@ fz_dropa85e(fz_filter *f)
 {
 }
 
-fz_error 
+fz_error
 fz_processa85e(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_a85e *f = (fz_a85e*)filter;
diff --git a/fitz/filt_ahxd.c b/fitz/filt_ahxd.c
index 56bc2aad..5e1fe17c 100644
--- a/fitz/filt_ahxd.c
+++ b/fitz/filt_ahxd.c
@@ -38,7 +38,7 @@ static inline int fromhex(int a)
 	return 0;
 }
 
-fz_error 
+fz_error
 fz_newahxd(fz_filter **fp, fz_obj *params)
 {
 	FZ_NEWFILTER(fz_ahxd, f, ahxd);
@@ -52,7 +52,7 @@ fz_dropahxd(fz_filter *f)
 {
 }
 
-fz_error 
+fz_error
 fz_processahxd(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_ahxd *f = (fz_ahxd*)filter;
diff --git a/fitz/filt_ahxe.c b/fitz/filt_ahxe.c
index 8ca5345b..ffa66b69 100644
--- a/fitz/filt_ahxe.c
+++ b/fitz/filt_ahxe.c
@@ -11,7 +11,7 @@ struct fz_ahxe_s
 
 static const char tohex[16] = "0123456789ABCDEF";
 
-fz_error 
+fz_error
 fz_newahxe(fz_filter **fp, fz_obj *params)
 {
 	FZ_NEWFILTER(fz_ahxe, f, ahxe);
@@ -24,7 +24,7 @@ fz_dropahxe(fz_filter *f)
 {
 }
 
-fz_error 
+fz_error
 fz_processahxe(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_ahxe *f = (fz_ahxe*)filter;
diff --git a/fitz/filt_arc4.c b/fitz/filt_arc4.c
index a5aa4fcc..d3832ec0 100644
--- a/fitz/filt_arc4.c
+++ b/fitz/filt_arc4.c
@@ -9,7 +9,7 @@ struct fz_arc4c_s
 	fz_arc4 arc4;
 };
 
-fz_error 
+fz_error
 fz_newarc4filter(fz_filter **fp, unsigned char *key, unsigned keylen)
 {
 	FZ_NEWFILTER(fz_arc4c, f, arc4filter);
@@ -22,7 +22,7 @@ fz_droparc4filter(fz_filter *f)
 {
 }
 
-fz_error 
+fz_error
 fz_processarc4filter(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_arc4c *f = (fz_arc4c*)filter;
diff --git a/fitz/filt_dctd.c b/fitz/filt_dctd.c
index 5814c6ab..39e97a0d 100644
--- a/fitz/filt_dctd.c
+++ b/fitz/filt_dctd.c
@@ -48,7 +48,7 @@ static void myskipinput(j_decompress_ptr cinfo, long n)
 	src->super.next_input_byte = in->rp;
 }
 
-fz_error 
+fz_error
 fz_newdctd(fz_filter **fp, fz_obj *params)
 {
 	fz_error err;
@@ -112,7 +112,7 @@ fz_dropdctd(fz_filter *filter)
 	jpeg_destroy_decompress(&d->cinfo);
 }
 
-fz_error 
+fz_error
 fz_processdctd(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_dctd *d = (fz_dctd*)filter;
diff --git a/fitz/filt_dcte.c b/fitz/filt_dcte.c
index 72422cbf..0949d9a9 100644
--- a/fitz/filt_dcte.c
+++ b/fitz/filt_dcte.c
@@ -29,7 +29,7 @@ static void myinitdest(j_compress_ptr cinfo) { /* empty */ }
 static boolean myemptybuf(j_compress_ptr cinfo) { return FALSE; }
 static void mytermdest(j_compress_ptr cinfo) { /* empty */ }
 
-fz_error 
+fz_error
 fz_newdcte(fz_filter **fp, fz_obj *params)
 {
 	fz_error err;
@@ -155,7 +155,7 @@ static const unsigned char unzigzagorder[] =
 #define unzigzag(x) (x)
 #endif
 
-fz_error 
+fz_error
 fz_setquanttables(fz_dcte *e, unsigned int **qtables, int qfactor)
 {
 	int i, j;
@@ -178,7 +178,7 @@ fz_setquanttables(fz_dcte *e, unsigned int **qtables, int qfactor)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_processdcte(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_dcte *e = (fz_dcte*)filter;
diff --git a/fitz/filt_faxd.c b/fitz/filt_faxd.c
index e0f35654..cc083138 100644
--- a/fitz/filt_faxd.c
+++ b/fitz/filt_faxd.c
@@ -41,7 +41,7 @@ struct fz_faxd_s
 	unsigned char *dst;
 };
 
-fz_error 
+fz_error
 fz_newfaxd(fz_filter **fp, fz_obj *params)
 {
 	fz_obj *obj;
@@ -95,7 +95,7 @@ fz_newfaxd(fz_filter **fp, fz_obj *params)
 	if (!fax->ref)
 	{
 		fz_free(fax);
-		return fz_throw("outofmem: scanline buffer one");
+		return fz_rethrow(-1, "out of memory: scanline buffer one");
 	}
 
 	fax->dst = fz_malloc(fax->stride);
@@ -103,7 +103,7 @@ fz_newfaxd(fz_filter **fp, fz_obj *params)
 	{
 		fz_free(fax);
 		fz_free(fax->ref);
-		return fz_throw("outofmem: scanline buffer two");
+		return fz_rethrow(-1, "out of memory: scanline buffer two");
 	}
 
 	memset(fax->ref, 0, fax->stride);
@@ -161,7 +161,7 @@ getcode(fz_faxd *fax, const cfd_node *table, int initialbits)
 }
 
 /* decode one 1d code */
-static fz_error 
+static fz_error
 dec1d(fz_faxd *fax)
 {
 	int code;
@@ -200,7 +200,7 @@ dec1d(fz_faxd *fax)
 }
 
 /* decode one 2d code */
-static fz_error 
+static fz_error
 dec2d(fz_faxd *fax)
 {
 	int code, b1, b2;
@@ -318,7 +318,7 @@ dec2d(fz_faxd *fax)
 	return 0;
 }
 
-fz_error 
+fz_error
 fz_processfaxd(fz_filter *f, fz_buffer *in, fz_buffer *out)
 {
 	fz_faxd *fax = (fz_faxd*)f;
diff --git a/fitz/filt_faxe.c b/fitz/filt_faxe.c
index 3aa4f09a..db152ae5 100644
--- a/fitz/filt_faxe.c
+++ b/fitz/filt_faxe.c
@@ -31,7 +31,7 @@ struct fz_faxe_s
 	unsigned char *src;
 };
 
-fz_error 
+fz_error
 fz_newfaxe(fz_filter **fp, fz_obj *params)
 {
 	fz_obj *obj;
@@ -78,7 +78,7 @@ fz_newfaxe(fz_filter **fp, fz_obj *params)
 	if (!fax->ref)
 	{
 	    fz_free(fax);
-	    return fz_throw("outofmemory: scanline buffer one");
+	    return fz_rethrow(-1, "out of memoryory: scanline buffer one");
 	}
 
 	fax->src = fz_malloc(fax->stride);
@@ -86,7 +86,7 @@ fz_newfaxe(fz_filter **fp, fz_obj *params)
 	{
 	    fz_free(fax);
 	    fz_free(fax->ref);
-	    return fz_throw("outofmemory: scanline buffer two");
+	    return fz_rethrow(-1, "out of memoryory: scanline buffer two");
 	}
 
 	memset(fax->ref, 0, fax->stride);
@@ -176,7 +176,7 @@ putrun(fz_faxe *fax, fz_buffer *out, int run, int c)
 	}
 }
 
-static fz_error 
+static fz_error
 enc1d(fz_faxe *fax, unsigned char *line, fz_buffer *out)
 {
 	int run;
@@ -200,7 +200,7 @@ enc1d(fz_faxe *fax, unsigned char *line, fz_buffer *out)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 enc2d(fz_faxe *fax, unsigned char *ref, unsigned char *src, fz_buffer *out)
 {
 	int a1, a2, b1, b2;
@@ -257,7 +257,7 @@ enc2d(fz_faxe *fax, unsigned char *ref, unsigned char *src, fz_buffer *out)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 process(fz_faxe *fax, fz_buffer *in, fz_buffer *out)
 {
 	fz_error error;
@@ -388,7 +388,7 @@ rtc:
 	return fz_iodone;
 }
 
-fz_error 
+fz_error
 fz_processfaxe(fz_filter *p, fz_buffer *in, fz_buffer *out)
 {
 	fz_faxe *fax = (fz_faxe*) p;
diff --git a/fitz/filt_flate.c b/fitz/filt_flate.c
index 65a84711..67158d5e 100644
--- a/fitz/filt_flate.c
+++ b/fitz/filt_flate.c
@@ -23,7 +23,7 @@ zfree(void *opaque, void *ptr)
 	fz_free(ptr);
 }
 
-fz_error 
+fz_error
 fz_newflated(fz_filter **fp, fz_obj *params)
 {
 	fz_error eo;
@@ -76,7 +76,7 @@ fz_dropflated(fz_filter *f)
 		fprintf(stderr, "inflateEnd: %s", zp->msg);
 }
 
-fz_error 
+fz_error
 fz_processflated(fz_filter *f, fz_buffer *in, fz_buffer *out)
 {
 	z_streamp zp = &((fz_flate*)f)->z;
@@ -116,7 +116,7 @@ fz_processflated(fz_filter *f, fz_buffer *in, fz_buffer *out)
 	}
 }
 
-fz_error 
+fz_error
 fz_newflatee(fz_filter **fp, fz_obj *params)
 {
 	fz_obj *obj;
@@ -172,7 +172,7 @@ fz_dropflatee(fz_filter *f)
 	fz_free(f);
 }
 
-fz_error 
+fz_error
 fz_processflatee(fz_filter *f, fz_buffer *in, fz_buffer *out)
 {
 	z_streamp zp = &((fz_flate*)f)->z;
diff --git a/fitz/filt_jbig2d.c b/fitz/filt_jbig2d.c
index 9dfeda61..0eece1fe 100644
--- a/fitz/filt_jbig2d.c
+++ b/fitz/filt_jbig2d.c
@@ -41,7 +41,7 @@ struct fz_jbig2d_s
 	int idx;
 };
 
-fz_error 
+fz_error
 fz_newjbig2d(fz_filter **fp, fz_obj *params)
 {
 	FZ_NEWFILTER(fz_jbig2d, d, jbig2d);
@@ -58,7 +58,7 @@ fz_dropjbig2d(fz_filter *filter)
 	jbig2_ctx_free(d->ctx);
 }
 
-fz_error 
+fz_error
 fz_setjbig2dglobalstream(fz_filter *filter, unsigned char *buf, int len)
 {
 	fz_jbig2d *d = (fz_jbig2d*)filter;
@@ -68,7 +68,7 @@ fz_setjbig2dglobalstream(fz_filter *filter, unsigned char *buf, int len)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_processjbig2d(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_jbig2d *d = (fz_jbig2d*)filter;
diff --git a/fitz/filt_jpxd.c b/fitz/filt_jpxd.c
index eb940c93..c07f396c 100644
--- a/fitz/filt_jpxd.c
+++ b/fitz/filt_jpxd.c
@@ -34,7 +34,7 @@ struct fz_jpxd_s
 	int stage;
 };
 
-fz_error 
+fz_error
 fz_newjpxd(fz_filter **fp, fz_obj *params)
 {
 	int err;
@@ -70,7 +70,7 @@ fz_dropjpxd(fz_filter *filter)
 	if (d->image) jas_image_destroy(d->image);
 }
 
-fz_error 
+fz_error
 fz_processjpxd(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_jpxd *d = (fz_jpxd*)filter;
diff --git a/fitz/filt_lzwd.c b/fitz/filt_lzwd.c
index 07bdddc8..9edffa71 100644
--- a/fitz/filt_lzwd.c
+++ b/fitz/filt_lzwd.c
@@ -42,7 +42,7 @@ struct fz_lzwd_s
 	lzw_code table[NUMCODES];
 };
 
-fz_error 
+fz_error
 fz_newlzwd(fz_filter **fp, fz_obj *params)
 {
 	int i;
@@ -117,7 +117,7 @@ static inline void unstuff(fz_lzwd *lzw, fz_buffer *in)
 		in->rp --;
 }
 
-fz_error 
+fz_error
 fz_processlzwd(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_lzwd *lzw = (fz_lzwd*)filter;
diff --git a/fitz/filt_lzwe.c b/fitz/filt_lzwe.c
index a20043c0..6b271dfa 100644
--- a/fitz/filt_lzwe.c
+++ b/fitz/filt_lzwe.c
@@ -55,7 +55,7 @@ clearhash(fz_lzwe *lzw)
 		lzw->table[i].hash = -1;
 }
 
-fz_error 
+fz_error
 fz_newlzwe(fz_filter **fp, fz_obj *params)
 {
 	FZ_NEWFILTER(fz_lzwe, lzw, lzwe);
@@ -128,7 +128,7 @@ putcode(fz_lzwe *lzw, fz_buffer *out, int code)
 }
 
 
-static fz_error 
+static fz_error
 compress(fz_lzwe *lzw, fz_buffer *in, fz_buffer *out)
 {
 	if (lzw->resume)
@@ -242,7 +242,7 @@ eof:
 	return fz_iodone;
 }
 
-fz_error 
+fz_error
 fz_processlzwe(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_lzwe *lzw = (fz_lzwe*)filter;
diff --git a/fitz/filt_null.c b/fitz/filt_null.c
index 955354b1..ff19f64e 100644
--- a/fitz/filt_null.c
+++ b/fitz/filt_null.c
@@ -10,7 +10,7 @@ struct fz_nullfilter_s
 	int cur;
 };
 
-fz_error 
+fz_error
 fz_newnullfilter(fz_filter **fp, int len)
 {
 	FZ_NEWFILTER(fz_nullfilter, f, nullfilter);
@@ -24,7 +24,7 @@ fz_dropnullfilter(fz_filter *f)
 {
 }
 
-fz_error 
+fz_error
 fz_processnullfilter(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_nullfilter *f = (fz_nullfilter*)filter;
diff --git a/fitz/filt_pipeline.c b/fitz/filt_pipeline.c
index 33609a4a..fc4ccd22 100644
--- a/fitz/filt_pipeline.c
+++ b/fitz/filt_pipeline.c
@@ -16,7 +16,7 @@ struct fz_pipeline_s
 	int tailneedsin;
 };
 
-fz_error 
+fz_error
 fz_chainpipeline(fz_filter **fp, fz_filter *head, fz_filter *tail, fz_buffer *buf)
 {
 	FZ_NEWFILTER(fz_pipeline, p, pipeline);
@@ -38,7 +38,7 @@ fz_unchainpipeline(fz_filter *filter, fz_filter **oldfp, fz_buffer **oldbp)
 	fz_dropfilter(filter);
 }
 
-fz_error 
+fz_error
 fz_newpipeline(fz_filter **fp, fz_filter *head, fz_filter *tail)
 {
 	fz_error error;
@@ -67,7 +67,7 @@ fz_droppipeline(fz_filter *filter)
 	fz_dropbuffer(p->buffer);
 }
 
-fz_error 
+fz_error
 fz_processpipeline(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_pipeline *p = (fz_pipeline*)filter;
diff --git a/fitz/filt_predict.c b/fitz/filt_predict.c
index fc1bf1ea..1286ec08 100644
--- a/fitz/filt_predict.c
+++ b/fitz/filt_predict.c
@@ -23,7 +23,7 @@ struct fz_predict_s
 	int encode;
 };
 
-fz_error 
+fz_error
 fz_newpredict(fz_filter **fp, fz_obj *params, int encode)
 {
 	fz_obj *obj;
@@ -58,7 +58,7 @@ fz_newpredict(fz_filter **fp, fz_obj *params, int encode)
 		if (!p->ref)
 		{
 			fz_free(p);
-			return fz_throw("outofmem: scanline buffer");
+			return fz_rethrow(-1, "out of memory: scanline buffer");
 		}
 		memset(p->ref, 0, p->stride);
 	}
@@ -187,7 +187,7 @@ png(fz_predict *p, unsigned char *in, unsigned char *out, int predictor)
 	}
 }
 
-fz_error 
+fz_error
 fz_processpredict(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_predict *dec = (fz_predict*)filter;
@@ -240,13 +240,13 @@ fz_processpredict(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 	}
 }
 
-fz_error 
+fz_error
 fz_newpredictd(fz_filter **fp, fz_obj *params)
 {
 	return fz_newpredict(fp, params, 0);
 }
 
-fz_error 
+fz_error
 fz_newpredicte(fz_filter **fp, fz_obj *params)
 {
 	return fz_newpredict(fp, params, 1);
diff --git a/fitz/filt_rld.c b/fitz/filt_rld.c
index 734c7005..8f3b842f 100644
--- a/fitz/filt_rld.c
+++ b/fitz/filt_rld.c
@@ -1,7 +1,7 @@
 #include "fitz_base.h"
 #include "fitz_stream.h"
 
-fz_error 
+fz_error
 fz_newrld(fz_filter **fp, fz_obj *params)
 {
 	FZ_NEWFILTER(fz_filter, f, rld);
@@ -13,7 +13,7 @@ fz_droprld(fz_filter *rld)
 {
 }
 
-fz_error 
+fz_error
 fz_processrld(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	int run, i;
diff --git a/fitz/filt_rle.c b/fitz/filt_rle.c
index 2dfdb91d..65c6c0e8 100644
--- a/fitz/filt_rle.c
+++ b/fitz/filt_rle.c
@@ -28,7 +28,7 @@ enum {
 	END
 };
 
-fz_error 
+fz_error
 fz_newrle(fz_filter **fp, fz_obj *params)
 {
 	FZ_NEWFILTER(fz_rle, enc, rle);
@@ -50,7 +50,7 @@ fz_droprle(fz_filter *enc)
 {
 }
 
-static fz_error 
+static fz_error
 putone(fz_rle *enc, fz_buffer *in, fz_buffer *out)
 {
 	if (out->wp + 2 >= out->ep)
@@ -66,7 +66,7 @@ fprintf(stderr, "one '%c'\n", enc->buf[0]);
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 putsame(fz_rle *enc, fz_buffer *in, fz_buffer *out)
 {
 	if (out->wp + enc->run >= out->ep)
@@ -81,7 +81,7 @@ fprintf(stderr, "same %d x '%c'\n", enc->run, enc->buf[0]);
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 putdiff(fz_rle *enc, fz_buffer *in, fz_buffer *out)
 {
 	int i;
@@ -98,7 +98,7 @@ fprintf(stderr, "diff %d\n", enc->run);
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 puteod(fz_rle *enc, fz_buffer *in, fz_buffer *out)
 {
 	if (out->wp + 1 >= out->ep)
@@ -112,7 +112,7 @@ fprintf(stderr, "eod\n");
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 savebuf(fz_rle *enc, fz_buffer *in, fz_buffer *out)
 {
 	switch (enc->state)
@@ -126,7 +126,7 @@ savebuf(fz_rle *enc, fz_buffer *in, fz_buffer *out)
 	}
 }
 
-fz_error 
+fz_error
 fz_processrle(fz_filter *filter, fz_buffer *in, fz_buffer *out)
 {
 	fz_rle *enc = (fz_rle*)filter;
diff --git a/fitz/node_misc2.c b/fitz/node_misc2.c
index 17ab63c3..c26fc908 100644
--- a/fitz/node_misc2.c
+++ b/fitz/node_misc2.c
@@ -5,14 +5,14 @@
  * Over
  */
 
-fz_error 
+fz_error
 fz_newovernode(fz_node **nodep)
 {
 	fz_node *node;
 
 	node = *nodep = fz_malloc(sizeof (fz_overnode));
 	if (!node)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	fz_initnode(node, FZ_NOVER);
 
@@ -47,14 +47,14 @@ fz_boundovernode(fz_overnode *node, fz_matrix ctm)
  * Mask
  */
 
-fz_error 
+fz_error
 fz_newmasknode(fz_node **nodep)
 {
 	fz_node *node;
 
 	node = *nodep = fz_malloc(sizeof (fz_masknode));
 	if (!node)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	fz_initnode(node, FZ_NMASK);
 
@@ -80,14 +80,14 @@ fz_boundmasknode(fz_masknode *node, fz_matrix ctm)
  * Blend
  */
 
-fz_error 
+fz_error
 fz_newblendnode(fz_node **nodep, fz_blendkind b, int k, int i)
 {
 	fz_blendnode *node;
 
 	node = fz_malloc(sizeof (fz_blendnode));
 	if (!node)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	*nodep = (fz_node*)node;
 
 	fz_initnode((fz_node*)node, FZ_NBLEND);
@@ -132,14 +132,14 @@ fz_dropblendnode(fz_blendnode *node)
  * Transform
  */
 
-fz_error 
+fz_error
 fz_newtransformnode(fz_node **nodep, fz_matrix m)
 {
 	fz_transformnode *node;
 
 	node = fz_malloc(sizeof (fz_transformnode));
 	if (!node)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	*nodep = (fz_node*)node;
 
 	fz_initnode((fz_node*)node, FZ_NTRANSFORM);
@@ -160,14 +160,14 @@ fz_boundtransformnode(fz_transformnode *node, fz_matrix ctm)
  * Link to tree
  */
 
-fz_error 
+fz_error
 fz_newlinknode(fz_node **nodep, fz_tree *subtree)
 {
 	fz_linknode *node;
 
 	node = fz_malloc(sizeof (fz_linknode));
 	if (!node)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	*nodep = (fz_node*)node;
 
 	fz_initnode((fz_node*)node, FZ_NLINK);
@@ -192,7 +192,7 @@ fz_boundlinknode(fz_linknode *node, fz_matrix ctm)
  * Solid color
  */
 
-fz_error 
+fz_error
 fz_newsolidnode(fz_node **nodep, float a, fz_colorspace *cs, int n, float *v)
 {
 	fz_solidnode *node;
@@ -200,7 +200,7 @@ fz_newsolidnode(fz_node **nodep, float a, fz_colorspace *cs, int n, float *v)
 
 	node = fz_malloc(sizeof(fz_solidnode) + sizeof(float) * n);
 	if (!node)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	*nodep = (fz_node*)node;
 
 	fz_initnode((fz_node*)node, FZ_NCOLOR);
@@ -229,14 +229,14 @@ fz_dropsolidnode(fz_solidnode *node)
  * Image node
  */
 
-fz_error 
+fz_error
 fz_newimagenode(fz_node **nodep, fz_image *image)
 {
 	fz_imagenode *node;
 
 	node = fz_malloc(sizeof (fz_imagenode));
 	if (!node)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	*nodep = (fz_node*)node;
 
 	fz_initnode((fz_node*)node, FZ_NIMAGE);
@@ -266,14 +266,14 @@ fz_boundimagenode(fz_imagenode *node, fz_matrix ctm)
  * Shade node
  */
 
-fz_error 
+fz_error
 fz_newshadenode(fz_node **nodep, fz_shade *shade)
 {
 	fz_shadenode *node;
 
 	node = fz_malloc(sizeof (fz_shadenode));
 	if (!node)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	*nodep = (fz_node*)node;
 
 	fz_initnode((fz_node*)node, FZ_NSHADE);
diff --git a/fitz/node_optimize.c b/fitz/node_optimize.c
index 0d173efe..056fc782 100644
--- a/fitz/node_optimize.c
+++ b/fitz/node_optimize.c
@@ -222,7 +222,7 @@ retry:
  *
  */
 
-fz_error 
+fz_error
 fz_optimizetree(fz_tree *tree)
 {
 	if (getenv("DONTOPT"))
diff --git a/fitz/node_path.c b/fitz/node_path.c
index 8cd54300..a72b373d 100644
--- a/fitz/node_path.c
+++ b/fitz/node_path.c
@@ -1,14 +1,14 @@
 #include "fitz_base.h"
 #include "fitz_tree.h"
 
-fz_error 
+fz_error
 fz_newpathnode(fz_pathnode **pathp)
 {
 	fz_pathnode *path;
 
 	path = *pathp = fz_malloc(sizeof(fz_pathnode));
 	if (!path)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	fz_initnode((fz_node*)path, FZ_NPATH);
 
@@ -25,14 +25,14 @@ fz_newpathnode(fz_pathnode **pathp)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_clonepathnode(fz_pathnode **pathp, fz_pathnode *oldpath)
 {
 	fz_pathnode *path;
 
 	path = *pathp = fz_malloc(sizeof(fz_pathnode));
 	if (!path)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	fz_initnode((fz_node*)path, FZ_NPATH);
 
@@ -48,7 +48,7 @@ fz_clonepathnode(fz_pathnode **pathp, fz_pathnode *oldpath)
 	path->els = fz_malloc(sizeof (fz_pathel) * path->len);
 	if (!path->els) {
 		fz_free(path);
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	}
 	memcpy(path->els, oldpath->els, sizeof(fz_pathel) * path->len);
 
@@ -62,7 +62,7 @@ fz_droppathnode(fz_pathnode *node)
 	fz_free(node->els);
 }
 
-static fz_error 
+static fz_error
 growpath(fz_pathnode *path, int n)
 {
 	int newcap;
@@ -73,7 +73,7 @@ growpath(fz_pathnode *path, int n)
 		newcap = path->cap + 36;
 		newels = fz_realloc(path->els, sizeof (fz_pathel) * newcap);
 		if (!newels)
-			return fz_outofmem;
+			return fz_rethrow(-1, "out of memory");
 		path->cap = newcap;
 		path->els = newels;
 	}
@@ -81,36 +81,36 @@ growpath(fz_pathnode *path, int n)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_moveto(fz_pathnode *path, float x, float y)
 {
 	if (growpath(path, 3) != nil)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	path->els[path->len++].k = FZ_MOVETO;
 	path->els[path->len++].v = x;
 	path->els[path->len++].v = y;
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_lineto(fz_pathnode *path, float x, float y)
 {
 	if (growpath(path, 3) != nil)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	path->els[path->len++].k = FZ_LINETO;
 	path->els[path->len++].v = x;
 	path->els[path->len++].v = y;
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_curveto(fz_pathnode *path,
 		float x1, float y1,
 		float x2, float y2,
 		float x3, float y3)
 {
 	if (growpath(path, 7) != nil)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	path->els[path->len++].k = FZ_CURVETO;
 	path->els[path->len++].v = x1;
 	path->els[path->len++].v = y1;
@@ -121,7 +121,7 @@ fz_curveto(fz_pathnode *path,
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_curvetov(fz_pathnode *path, float x2, float y2, float x3, float y3)
 {
 	float x1 = path->els[path->len-2].v;
@@ -129,22 +129,22 @@ fz_curvetov(fz_pathnode *path, float x2, float y2, float x3, float y3)
 	return fz_curveto(path, x1, y1, x2, y2, x3, y3);
 }
 
-fz_error 
+fz_error
 fz_curvetoy(fz_pathnode *path, float x1, float y1, float x3, float y3)
 {
 	return fz_curveto(path, x1, y1, x3, y3, x3, y3);
 }
 
-fz_error 
+fz_error
 fz_closepath(fz_pathnode *path)
 {
 	if (growpath(path, 1) != nil)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	path->els[path->len++].k = FZ_CLOSEPATH;
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_endpath(fz_pathnode *path, fz_pathkind paint, fz_stroke *stroke, fz_dash *dash)
 {
 	if (path->len == 0)
@@ -321,7 +321,7 @@ fz_debugpathnode(fz_pathnode *path, int indent)
 	}
 }
 
-fz_error 
+fz_error
 fz_newdash(fz_dash **dashp, float phase, int len, float *array)
 {
 	fz_dash *dash;
@@ -329,7 +329,7 @@ fz_newdash(fz_dash **dashp, float phase, int len, float *array)
 
 	dash = *dashp = fz_malloc(sizeof(fz_dash) + sizeof(float) * len);
 	if (!dash)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	dash->len = len;
 	dash->phase = phase;
diff --git a/fitz/node_text.c b/fitz/node_text.c
index 5abca20a..fda8d577 100644
--- a/fitz/node_text.c
+++ b/fitz/node_text.c
@@ -1,14 +1,14 @@
 #include "fitz_base.h"
 #include "fitz_tree.h"
 
-fz_error 
+fz_error
 fz_newtextnode(fz_textnode **textp, fz_font *font)
 {
 	fz_textnode *text;
 
 	text = fz_malloc(sizeof(fz_textnode));
 	if (!text)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	fz_initnode((fz_node*)text, FZ_NTEXT);
 
@@ -22,14 +22,14 @@ fz_newtextnode(fz_textnode **textp, fz_font *font)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_clonetextnode(fz_textnode **textp, fz_textnode *oldtext)
 {
 	fz_textnode *text;
 
 	text = *textp = fz_malloc(sizeof(fz_textnode));
 	if (!text)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	fz_initnode((fz_node*)text, FZ_NTEXT);
 
@@ -44,7 +44,7 @@ fz_clonetextnode(fz_textnode **textp, fz_textnode *oldtext)
 	{
 		fz_dropfont(text->font);
 		fz_free(text);
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	}
 
 	memcpy(text->els, oldtext->els, sizeof(fz_textel) * text->len);
@@ -109,7 +109,7 @@ fz_boundtextnode(fz_textnode *text, fz_matrix ctm)
 	return bbox;
 }
 
-static fz_error 
+static fz_error
 growtext(fz_textnode *text, int n)
 {
 	int newcap;
@@ -120,7 +120,7 @@ growtext(fz_textnode *text, int n)
 		newcap = text->cap + 36;
 		newels = fz_realloc(text->els, sizeof (fz_textel) * newcap);
 		if (!newels)
-			return fz_outofmem;
+			return fz_rethrow(-1, "out of memory");
 		text->cap = newcap;
 		text->els = newels;
 	}
@@ -128,11 +128,11 @@ growtext(fz_textnode *text, int n)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_addtext(fz_textnode *text, int gid, int ucs, float x, float y)
 {
 	if (growtext(text, 1) != nil)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	text->els[text->len].ucs = ucs;
 	text->els[text->len].gid = gid;
 	text->els[text->len].x = x;
diff --git a/fitz/node_tree.c b/fitz/node_tree.c
index 9e75b8aa..6dc035e1 100644
--- a/fitz/node_tree.c
+++ b/fitz/node_tree.c
@@ -1,14 +1,14 @@
 #include "fitz_base.h"
 #include "fitz_tree.h"
 
-fz_error 
+fz_error
 fz_newtree(fz_tree **treep)
 {
 	fz_tree *tree;
 
 	tree = *treep = fz_malloc(sizeof (fz_tree));
 	if (!tree)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	tree->refs = 1;
 	tree->root = nil;
diff --git a/fitz/obj_array.c b/fitz/obj_array.c
index ce0309eb..fcd0edc7 100644
--- a/fitz/obj_array.c
+++ b/fitz/obj_array.c
@@ -3,7 +3,7 @@
 
 void fz_droparray(fz_obj *obj);
 
-fz_error 
+fz_error
 fz_newarray(fz_obj **op, int initialcap)
 {
 	fz_obj *obj;
@@ -11,7 +11,7 @@ fz_newarray(fz_obj **op, int initialcap)
 
 	obj = *op = fz_malloc(sizeof (fz_obj));
 	if (!obj)
-	    return fz_throw("outofmem: array struct");
+	    return fz_rethrow(-1, "out of memory: array struct");
 
 	obj->refs = 1;
 	obj->kind = FZ_ARRAY;
@@ -23,7 +23,7 @@ fz_newarray(fz_obj **op, int initialcap)
 	if (!obj->u.a.items)
 	{
 	    fz_free(obj);
-	    return fz_throw("outofmem: array item buffer");
+	    return fz_rethrow(-1, "out of memory: array item buffer");
 	}
 
 	for (i = 0; i < obj->u.a.cap; i++)
@@ -32,7 +32,7 @@ fz_newarray(fz_obj **op, int initialcap)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_copyarray(fz_obj **op, fz_obj *obj)
 {
 	fz_error error;
@@ -61,7 +61,7 @@ fz_copyarray(fz_obj **op, fz_obj *obj)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_deepcopyarray(fz_obj **op, fz_obj *obj)
 {
 	fz_error error;
@@ -155,7 +155,7 @@ fz_arrayget(fz_obj *obj, int i)
 	return obj->u.a.items[i];
 }
 
-fz_error 
+fz_error
 fz_arrayput(fz_obj *obj, int i, fz_obj *item)
 {
 	if (!fz_isarray(obj))
@@ -172,7 +172,7 @@ fz_arrayput(fz_obj *obj, int i, fz_obj *item)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 growarray(fz_obj *obj)
 {
 	fz_obj **newitems;
@@ -182,7 +182,7 @@ growarray(fz_obj *obj)
 	newcap = obj->u.a.cap * 2;
 	newitems = fz_realloc(obj->u.a.items, sizeof (fz_obj*) * newcap);
 	if (!newitems)
-	    return fz_throw("outofmem: resize item buffer");
+	    return fz_rethrow(-1, "out of memory: resize item buffer");
 
 	obj->u.a.items = newitems;
 	for (i = obj->u.a.cap ; i < newcap; i++)
@@ -192,7 +192,7 @@ growarray(fz_obj *obj)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_arraypush(fz_obj *obj, fz_obj *item)
 {
 	fz_error error;
diff --git a/fitz/obj_dict.c b/fitz/obj_dict.c
index 6493baf3..c956fa4d 100644
--- a/fitz/obj_dict.c
+++ b/fitz/obj_dict.c
@@ -23,7 +23,7 @@ static inline int keystrcmp(fz_obj *key, char *s)
 	return -1;
 }
 
-fz_error 
+fz_error
 fz_newdict(fz_obj **op, int initialcap)
 {
 	fz_obj *obj;
@@ -31,7 +31,7 @@ fz_newdict(fz_obj **op, int initialcap)
 
 	obj = *op = fz_malloc(sizeof (fz_obj));
 	if (!obj)
-	    return fz_throw("outofmem: dict struct");
+	    return fz_rethrow(-1, "out of memory: dict struct");
 
 	obj->refs = 1;
 	obj->kind = FZ_DICT;
@@ -44,7 +44,7 @@ fz_newdict(fz_obj **op, int initialcap)
 	if (!obj->u.d.items)
 	{
 	    fz_free(obj);
-	    return fz_throw("outofmem: dict item buffer");
+	    return fz_rethrow(-1, "out of memory: dict item buffer");
 	}
 
 	for (i = 0; i < obj->u.d.cap; i++)
@@ -56,7 +56,7 @@ fz_newdict(fz_obj **op, int initialcap)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_copydict(fz_obj **op, fz_obj *obj)
 {
 	fz_error error;
@@ -84,7 +84,7 @@ fz_copydict(fz_obj **op, fz_obj *obj)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_deepcopydict(fz_obj **op, fz_obj *obj)
 {
 	fz_error error;
@@ -154,7 +154,7 @@ fz_deepcopydict(fz_obj **op, fz_obj *obj)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 growdict(fz_obj *obj)
 {
 	fz_keyval *newitems;
@@ -165,7 +165,7 @@ growdict(fz_obj *obj)
 
 	newitems = fz_realloc(obj->u.d.items, sizeof(fz_keyval) * newcap);
 	if (!newitems)
-	    return fz_throw("outofmem: resize item buffer");
+	    return fz_rethrow(-1, "out of memory: resize item buffer");
 
 	obj->u.d.items = newitems;
 	for (i = obj->u.d.cap; i < newcap; i++)
@@ -275,7 +275,7 @@ fz_dictgetsa(fz_obj *obj, char *key, char *abbrev)
 	return fz_dictgets(obj, abbrev);
 }
 
-fz_error 
+fz_error
 fz_dictput(fz_obj *obj, fz_obj *key, fz_obj *val)
 {
 	fz_error error;
@@ -319,7 +319,7 @@ fz_dictput(fz_obj *obj, fz_obj *key, fz_obj *val)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_dictputs(fz_obj *obj, char *key, fz_obj *val)
 {
 	fz_error error;
@@ -334,7 +334,7 @@ fz_dictputs(fz_obj *obj, char *key, fz_obj *val)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_dictdels(fz_obj *obj, char *key)
 {
 	int i;
@@ -355,7 +355,7 @@ fz_dictdels(fz_obj *obj, char *key)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_dictdel(fz_obj *obj, fz_obj *key)
 {
 	if (fz_isname(key))
diff --git a/fitz/obj_parse.c b/fitz/obj_parse.c
index 1a063223..ba60f5eb 100644
--- a/fitz/obj_parse.c
+++ b/fitz/obj_parse.c
@@ -465,7 +465,7 @@ static fz_error parseobj(fz_obj **obj, char **sp, struct vap *v)
 	return error; /* already rethrown */
 }
 
-fz_error 
+fz_error
 fz_packobj(fz_obj **op, char *fmt, ...)
 {
 	fz_error error;
@@ -484,7 +484,7 @@ fz_packobj(fz_obj **op, char *fmt, ...)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_parseobj(fz_obj **op, char *str)
 {
 	return parseobj(op, &str, nil);
diff --git a/fitz/obj_simple.c b/fitz/obj_simple.c
index 2e664625..320d085d 100644
--- a/fitz/obj_simple.c
+++ b/fitz/obj_simple.c
@@ -7,18 +7,18 @@ extern void fz_dropdict(fz_obj *dict);
 #define NEWOBJ(KIND,SIZE) \
 	fz_obj *o; \
 	o = *op = fz_malloc(SIZE); \
-	if (!o) return fz_throw("outofmem: dynamic object"); \
+	if (!o) return fz_rethrow(-1, "out of memory: dynamic object"); \
 	o->refs = 1; \
 	o->kind = KIND;
 
-fz_error 
+fz_error
 fz_newnull(fz_obj **op)
 {
 	NEWOBJ(FZ_NULL, sizeof (fz_obj));
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_newbool(fz_obj **op, int b)
 {
 	NEWOBJ(FZ_BOOL, sizeof (fz_obj));
@@ -26,7 +26,7 @@ fz_newbool(fz_obj **op, int b)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_newint(fz_obj **op, int i)
 {
 	NEWOBJ(FZ_INT, sizeof (fz_obj));
@@ -34,7 +34,7 @@ fz_newint(fz_obj **op, int i)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_newreal(fz_obj **op, float f)
 {
 	NEWOBJ(FZ_REAL, sizeof (fz_obj));
@@ -42,7 +42,7 @@ fz_newreal(fz_obj **op, float f)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_newstring(fz_obj **op, char *str, int len)
 {
 	NEWOBJ(FZ_STRING, offsetof(fz_obj, u.s.buf) + len + 1);
@@ -52,7 +52,7 @@ fz_newstring(fz_obj **op, char *str, int len)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_newname(fz_obj **op, char *str)
 {
 	NEWOBJ(FZ_NAME, offsetof(fz_obj, u.n) + strlen(str) + 1);
@@ -60,7 +60,7 @@ fz_newname(fz_obj **op, char *str)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_newindirect(fz_obj **op, int objid, int genid)
 {
 	NEWOBJ(FZ_INDIRECT, sizeof (fz_obj));
@@ -69,7 +69,7 @@ fz_newindirect(fz_obj **op, int objid, int genid)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_newpointer(fz_obj **op, void *p)
 {
 	NEWOBJ(FZ_POINTER, sizeof (fz_obj));
@@ -236,7 +236,7 @@ fz_topointer(fz_obj *obj)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_newnamefromstring(fz_obj **op, fz_obj *str)
 {
 	NEWOBJ(FZ_NAME, offsetof(fz_obj, u.n) + fz_tostrlen(str) + 1);
diff --git a/fitz/res_font.c b/fitz/res_font.c
index 1261f2c4..00bb10d4 100644
--- a/fitz/res_font.c
+++ b/fitz/res_font.c
@@ -105,7 +105,7 @@ char *ft_errorstring(int err)
 	return "Unknown error";
 }
 
-static fz_error 
+static fz_error
 fz_initfreetype(void)
 {
 	int code;
@@ -125,7 +125,7 @@ fz_initfreetype(void)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_newfontfromfile(fz_font **fontp, char *path, int index)
 {
 	fz_error error;
@@ -138,7 +138,7 @@ fz_newfontfromfile(fz_font **fontp, char *path, int index)
 
 	font = fz_newfont();
 	if (!font)
-		return fz_throw("outofmem: font struct");
+		return fz_rethrow(-1, "out of memory: font struct");
 
 	code = FT_New_Face(fz_ftlib, path, index, (FT_Face*)&font->ftface);
 	if (code)
@@ -151,7 +151,7 @@ fz_newfontfromfile(fz_font **fontp, char *path, int index)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_newfontfrombuffer(fz_font **fontp, unsigned char *data, int len, int index)
 {
 	fz_error error;
@@ -164,7 +164,7 @@ fz_newfontfrombuffer(fz_font **fontp, unsigned char *data, int len, int index)
 
 	font = fz_newfont();
 	if (!font)
-		return fz_throw("outofmem: font struct");
+		return fz_rethrow(-1, "out of memory: font struct");
 
 	code = FT_New_Memory_Face(fz_ftlib, data, len, index, (FT_Face*)&font->ftface);
 	if (code)
@@ -177,7 +177,7 @@ fz_newfontfrombuffer(fz_font **fontp, unsigned char *data, int len, int index)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_renderftglyph(fz_glyph *glyph, fz_font *font, int gid, fz_matrix trm)
 {
 	FT_Face face = font->ftface;
@@ -299,7 +299,7 @@ fz_renderftglyph(fz_glyph *glyph, fz_font *font, int gid, fz_matrix trm)
  * Type 3 fonts...
  */
 
-fz_error 
+fz_error
 fz_newtype3font(fz_font **fontp, char *name, fz_matrix matrix)
 {
 	fz_font *font;
@@ -307,13 +307,13 @@ fz_newtype3font(fz_font **fontp, char *name, fz_matrix matrix)
 
 	font = fz_newfont();
 	if (!font)
-		return fz_throw("outofmem: font struct");
+		return fz_rethrow(-1, "out of memory: font struct");
 
 	font->t3procs = fz_malloc(sizeof(fz_tree*) * 256);
 	if (!font->t3procs)
 	{
 		fz_free(font);
-		return fz_throw("outofmem: type3 font charproc array");
+		return fz_rethrow(-1, "out of memory: type3 font charproc array");
 	}
 
 	font->t3matrix = matrix;
@@ -326,7 +326,7 @@ fz_newtype3font(fz_font **fontp, char *name, fz_matrix matrix)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_rendert3glyph(fz_glyph *glyph, fz_font *font, int gid, fz_matrix trm)
 {
     fz_error error;
diff --git a/fitz/stm_buffer.c b/fitz/stm_buffer.c
index 128d6e8e..102d7327 100644
--- a/fitz/stm_buffer.c
+++ b/fitz/stm_buffer.c
@@ -1,14 +1,14 @@
 #include "fitz_base.h"
 #include "fitz_stream.h"
 
-fz_error 
+fz_error
 fz_newbuffer(fz_buffer **bp, int size)
 {
 	fz_buffer *b;
 
 	b = *bp = fz_malloc(sizeof(fz_buffer));
 	if (!b)
-		return fz_throw("outofmem: buffer struct");
+		return fz_rethrow(-1, "out of memory: buffer struct");
 
 	b->refs = 1;
 	b->ownsdata = 1;
@@ -16,7 +16,7 @@ fz_newbuffer(fz_buffer **bp, int size)
 	if (!b->bp)
 	{
 		fz_free(b);
-		return fz_throw("outofmem: buffer memory");
+		return fz_rethrow(-1, "out of memory: buffer memory");
 	}
 
 	b->rp = b->bp;
@@ -27,14 +27,14 @@ fz_newbuffer(fz_buffer **bp, int size)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_newbufferwithmemory(fz_buffer **bp, unsigned char *data, int size)
 {
 	fz_buffer *b;
 
 	b = *bp = fz_malloc(sizeof(fz_buffer));
 	if (!b)
-		return fz_throw("outofmem: buffer struct");
+		return fz_rethrow(-1, "out of memory: buffer struct");
 
 	b->refs = 1;
 	b->ownsdata = 0;
@@ -66,7 +66,7 @@ fz_dropbuffer(fz_buffer *buf)
 	}
 }
 
-fz_error 
+fz_error
 fz_growbuffer(fz_buffer *buf)
 {
 	unsigned char *newbp;
@@ -80,7 +80,7 @@ fz_growbuffer(fz_buffer *buf)
 
 	newbp = fz_realloc(buf->bp, ep * 2);
 	if (!newbp)
-		return fz_throw("outofmem: resize buffer memory");
+		return fz_rethrow(-1, "out of memory: resize buffer memory");
 
 	buf->bp = newbp;
 	buf->rp = buf->bp + rp;
@@ -90,7 +90,7 @@ fz_growbuffer(fz_buffer *buf)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_rewindbuffer(fz_buffer *buf)
 {
 	if (!buf->ownsdata)
diff --git a/fitz/stm_filter.c b/fitz/stm_filter.c
index 159740e8..f41c4112 100644
--- a/fitz/stm_filter.c
+++ b/fitz/stm_filter.c
@@ -1,7 +1,7 @@
 #include "fitz_base.h"
 #include "fitz_stream.h"
 
-fz_error 
+fz_error
 fz_process(fz_filter *f, fz_buffer *in, fz_buffer *out)
 {
 	fz_error reason;
diff --git a/fitz/stm_misc.c b/fitz/stm_misc.c
index c051d112..7dedb50b 100644
--- a/fitz/stm_misc.c
+++ b/fitz/stm_misc.c
@@ -9,7 +9,7 @@
  * Read a line terminated by LF or CR or CRLF.
  */
 
-fz_error 
+fz_error
 fz_readline(fz_stream *stm, char *mem, int n)
 {
 	fz_error error;
@@ -46,7 +46,7 @@ fz_readline(fz_stream *stm, char *mem, int n)
  * a freshly allocated buffer.
  */
 
-fz_error 
+fz_error
 fz_readall(fz_buffer **bufp, fz_stream *stm, int sizehint)
 {
 	fz_error error;
diff --git a/fitz/stm_open.c b/fitz/stm_open.c
index c10809a0..c1f73f48 100644
--- a/fitz/stm_open.c
+++ b/fitz/stm_open.c
@@ -71,7 +71,7 @@ fz_error fz_openrfile(fz_stream **stmp, char *path)
 
 	stm = newstm(FZ_SFILE);
 	if (!stm)
-		return fz_throw("outofmem: stream struct");
+		return fz_rethrow(-1, "out of memory: stream struct");
 
 	error = fz_newbuffer(&stm->buffer, FZ_BUFSIZE);
 	if (error)
@@ -99,7 +99,7 @@ fz_error fz_openrfilter(fz_stream **stmp, fz_filter *flt, fz_stream *src)
 
 	stm = newstm(FZ_SFILTER);
 	if (!stm)
-		return fz_throw("outofmem: stream struct");
+		return fz_rethrow(-1, "out of memory: stream struct");
 
 	error = fz_newbuffer(&stm->buffer, FZ_BUFSIZE);
 	if (error)
@@ -121,7 +121,7 @@ fz_error fz_openrbuffer(fz_stream **stmp, fz_buffer *buf)
 
 	stm = newstm(FZ_SBUFFER);
 	if (!stm)
-		return fz_throw("outofmem: stream struct");
+		return fz_rethrow(-1, "out of memory: stream struct");
 
 	stm->buffer = fz_keepbuffer(buf);
 
diff --git a/fitz/stm_read.c b/fitz/stm_read.c
index 330d4ce7..adb79908 100644
--- a/fitz/stm_read.c
+++ b/fitz/stm_read.c
@@ -5,7 +5,7 @@
 #include "fitz_base.h"
 #include "fitz_stream.h"
 
-fz_error 
+fz_error
 fz_readimp(fz_stream *stm)
 {
 	fz_buffer *buf = stm->buffer;
@@ -93,7 +93,7 @@ fz_readimp(fz_stream *stm)
 					error = fz_growbuffer(buf);
 					if (error)
 					{
-						stm->dead = 1; 
+						stm->dead = 1;
 						return fz_rethrow(error, "cannot grow buffer");
 					}
 				}
@@ -151,7 +151,7 @@ fz_tell(fz_stream *stm)
 	}
 }
 
-fz_error 
+fz_error
 fz_seek(fz_stream *stm, int offset, int whence)
 {
 	fz_error error;
@@ -224,7 +224,7 @@ fz_seek(fz_stream *stm, int offset, int whence)
 	}
 }
 
-fz_error 
+fz_error
 fz_read(int *np, fz_stream *stm, unsigned char *mem, int n)
 {
 	fz_error error;
@@ -254,7 +254,7 @@ fz_read(int *np, fz_stream *stm, unsigned char *mem, int n)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_readerror(fz_stream *stm)
 {
 	fz_error error;
diff --git a/fitzdraw/glyphcache.c b/fitzdraw/glyphcache.c
index cc39f437..f3f6d38d 100644
--- a/fitzdraw/glyphcache.c
+++ b/fitzdraw/glyphcache.c
@@ -57,14 +57,14 @@ static unsigned int hashkey(fz_key *key)
 	return hash;
 }
 
-fz_error 
+fz_error
 fz_newglyphcache(fz_glyphcache **arenap, int slots, int size)
 {
 	fz_glyphcache *arena;
 
 	arena = *arenap = fz_malloc(sizeof(fz_glyphcache));
 	if (!arena)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	arena->slots = slots;
 	arena->size = size;
@@ -98,7 +98,7 @@ cleanup:
 	fz_free(arena->lru);
 	fz_free(arena->buffer);
 	fz_free(arena);
-	return fz_outofmem;
+	return fz_rethrow(-1, "out of memory");
 }
 
 void
@@ -313,7 +313,7 @@ evictall(fz_glyphcache *arena)
 	arena->used = 0;
 }
 
-fz_error 
+fz_error
 fz_renderglyph(fz_glyphcache *arena, fz_glyph *glyph, fz_font *font, int cid, fz_matrix ctm)
 {
 	fz_error error;
diff --git a/fitzdraw/imagescale.c b/fitzdraw/imagescale.c
index 065a250e..5d9af3ac 100644
--- a/fitzdraw/imagescale.c
+++ b/fitzdraw/imagescale.c
@@ -179,7 +179,7 @@ void (*fz_scol2)(byte *src, byte *dst, int w, int denom) = scol2;
 void (*fz_scol4)(byte *src, byte *dst, int w, int denom) = scol4;
 void (*fz_scol5)(byte *src, byte *dst, int w, int denom) = scol5;
 
-fz_error 
+fz_error
 fz_newscaledpixmap(fz_pixmap **dstp, int w, int h, int n, int xdenom, int ydenom)
 {
 	int ow = (w + xdenom - 1) / xdenom;
@@ -188,7 +188,7 @@ fz_newscaledpixmap(fz_pixmap **dstp, int w, int h, int n, int xdenom, int ydenom
 }
 
 /* TODO: refactor */
-fz_error 
+fz_error
 fz_scalepixmaptile(fz_pixmap *dst, int xoffs, int yoffs, fz_pixmap *src, int xdenom, int ydenom)
 {
 	unsigned char *buf;
@@ -212,7 +212,7 @@ fz_scalepixmaptile(fz_pixmap *dst, int xoffs, int yoffs, fz_pixmap *src, int xde
 
 	buf = fz_malloc(ow * n * ydenom);
 	if (!buf)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	switch (n)
 	{
@@ -271,7 +271,7 @@ fz_scalepixmaptile(fz_pixmap *dst, int xoffs, int yoffs, fz_pixmap *src, int xde
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_scalepixmap(fz_pixmap **dstp, fz_pixmap *src, int xdenom, int ydenom)
 {
 	fz_error error;
@@ -290,7 +290,7 @@ fz_scalepixmap(fz_pixmap **dstp, fz_pixmap *src, int xdenom, int ydenom)
 
 	buf = fz_malloc(ow * n * ydenom);
 	if (!buf)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	error = fz_newpixmap(&dst, 0, 0, ow, oh, src->n);
 	if (error)
diff --git a/fitzdraw/meshdraw.c b/fitzdraw/meshdraw.c
index 2eedcbc2..ebaaaeaa 100644
--- a/fitzdraw/meshdraw.c
+++ b/fitzdraw/meshdraw.c
@@ -312,7 +312,7 @@ fz_drawtriangle(fz_pixmap *pix, float *av, float *bv, float *cv, int n)
  * mesh drawing
  */
 
-fz_error 
+fz_error
 fz_rendershade(fz_shade *shade, fz_matrix ctm, fz_colorspace *destcs, fz_pixmap *dest)
 {
 	unsigned char clut[256][3];
diff --git a/fitzdraw/pathfill.c b/fitzdraw/pathfill.c
index 92aff3b4..e74fd879 100644
--- a/fitzdraw/pathfill.c
+++ b/fitzdraw/pathfill.c
@@ -2,7 +2,7 @@
 #include "fitz_tree.h"
 #include "fitz_draw.h"
 
-static fz_error 
+static fz_error
 line(fz_gel *gel, fz_matrix *ctm, float x0, float y0, float x1, float y1)
 {
 	float tx0 = ctm->a * x0 + ctm->c * y0 + ctm->e;
@@ -12,7 +12,7 @@ line(fz_gel *gel, fz_matrix *ctm, float x0, float y0, float x1, float y1)
 	return fz_insertgel(gel, tx0, ty0, tx1, ty1);
 }
 
-static fz_error 
+static fz_error
 bezier(fz_gel *gel, fz_matrix *ctm, float flatness,
 	float xa, float ya,
 	float xb, float yb,
@@ -66,7 +66,7 @@ bezier(fz_gel *gel, fz_matrix *ctm, float flatness,
 	return bezier(gel, ctm, flatness, xabcd, yabcd, xbcd, ybcd, xcd, ycd, xd, yd);
 }
 
-fz_error 
+fz_error
 fz_fillpath(fz_gel *gel, fz_pathnode *path, fz_matrix ctm, float flatness)
 {
 	fz_error error;
diff --git a/fitzdraw/pathscan.c b/fitzdraw/pathscan.c
index 2ab7d5b6..64397563 100644
--- a/fitzdraw/pathscan.c
+++ b/fitzdraw/pathscan.c
@@ -18,14 +18,14 @@ enum { HSCALE = 17, VSCALE = 15, SF = 1 };
  * See Mike Abrash -- Graphics Programming Black Book (notably chapter 40)
  */
 
-fz_error 
+fz_error
 fz_newgel(fz_gel **gelp)
 {
 	fz_gel *gel;
 
 	gel = *gelp = fz_malloc(sizeof(fz_gel));
 	if (!gel)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	gel->edges = nil;
 
@@ -34,7 +34,7 @@ fz_newgel(fz_gel **gelp)
 	gel->edges = fz_malloc(sizeof(fz_edge) * gel->cap);
 	if (!gel->edges) {
 		fz_free(gel);
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	}
 
 	gel->clip.x0 = gel->clip.y0 = INT_MAX;
@@ -114,7 +114,7 @@ cliplerpx(int val, int m, int x0, int y0, int x1, int y1, int *out)
 	}
 }
 
-fz_error 
+fz_error
 fz_insertgel(fz_gel *gel, float fx0, float fy0, float fx1, float fy1)
 {
 	fz_edge *edge;
@@ -163,7 +163,7 @@ fz_insertgel(fz_gel *gel, float fx0, float fy0, float fx1, float fy1)
 		int newcap = gel->cap + 512;
 		fz_edge *newedges = fz_realloc(gel->edges, sizeof(fz_edge) * newcap);
 		if (!newedges)
-			return fz_outofmem;
+			return fz_rethrow(-1, "out of memory");
 		gel->cap = newcap;
 		gel->edges = newedges;
 	}
@@ -243,21 +243,21 @@ fz_sortgel(fz_gel *gel)
  * Active Edge List -- keep track of active edges while sweeping
  */
 
-fz_error 
+fz_error
 fz_newael(fz_ael **aelp)
 {
 	fz_ael *ael;
 
 	ael = *aelp = fz_malloc(sizeof(fz_ael));
 	if (!ael)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	ael->cap = 64;
 	ael->len = 0;
 	ael->edges = fz_malloc(sizeof(fz_edge*) * ael->cap);
 	if (!ael->edges) {
 		fz_free(ael);
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	}
 
 	return fz_okay;
@@ -303,7 +303,7 @@ sortael(fz_edge **a, int n)
 	}
 }
 
-static fz_error 
+static fz_error
 insertael(fz_ael *ael, fz_gel *gel, int y, int *e)
 {
 	/* insert edges that start here */
@@ -312,7 +312,7 @@ insertael(fz_ael *ael, fz_gel *gel, int y, int *e)
 			int newcap = ael->cap + 64;
 			fz_edge **newedges = fz_realloc(ael->edges, sizeof(fz_edge*) * newcap);
 			if (!newedges)
-				return fz_outofmem;
+				return fz_rethrow(-1, "out of memory");
 			ael->edges = newedges;
 			ael->cap = newcap;
 		}
@@ -458,7 +458,7 @@ static inline void blit(fz_pixmap *pix, int x, int y,
 		fz_path_1c1(list, cov, len, dst);
 }
 
-fz_error 
+fz_error
 fz_scanconvert(fz_gel *gel, fz_ael *ael, int eofill, fz_irect clip,
 	fz_pixmap *pix, unsigned char *argb, int over)
 {
@@ -483,7 +483,7 @@ fz_scanconvert(fz_gel *gel, fz_ael *ael, int eofill, fz_irect clip,
 
 	deltas = fz_malloc(xmax - xmin + 1);
 	if (!deltas)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	memset(deltas, 0, xmax - xmin + 1);
 
diff --git a/fitzdraw/pathstroke.c b/fitzdraw/pathstroke.c
index 7b560313..b597a425 100644
--- a/fitzdraw/pathstroke.c
+++ b/fitzdraw/pathstroke.c
@@ -26,7 +26,7 @@ struct sctx
 	fz_point cur;
 };
 
-static fz_error 
+static fz_error
 line(struct sctx *s, float x0, float y0, float x1, float y1)
 {
 	float tx0 = s->ctm->a * x0 + s->ctm->c * y0 + s->ctm->e;
@@ -36,7 +36,7 @@ line(struct sctx *s, float x0, float y0, float x1, float y1)
 	return fz_insertgel(s->gel, tx0, ty0, tx1, ty1);
 }
 
-static fz_error 
+static fz_error
 arc(struct sctx *s,
 		float xc, float yc,
 		float x0, float y0,
@@ -85,7 +85,7 @@ arc(struct sctx *s,
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 linestroke(struct sctx *s, fz_point a, fz_point b)
 {
 	fz_error error;
@@ -105,7 +105,7 @@ linestroke(struct sctx *s, fz_point a, fz_point b)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 linejoin(struct sctx *s, fz_point a, fz_point b, fz_point c)
 {
 	fz_error error;
@@ -208,7 +208,7 @@ linejoin(struct sctx *s, fz_point a, fz_point b, fz_point c)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 linecap(struct sctx *s, fz_point a, fz_point b)
 {
 	fz_error error;
@@ -268,7 +268,7 @@ linecap(struct sctx *s, fz_point a, fz_point b)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 linedot(struct sctx *s, fz_point a)
 {
 	fz_error error;
@@ -295,7 +295,7 @@ linedot(struct sctx *s, fz_point a)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 strokeflush(struct sctx *s)
 {
 	fz_error error;
@@ -318,7 +318,7 @@ strokeflush(struct sctx *s)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 strokemoveto(struct sctx *s, fz_point cur)
 {
 	fz_error error;
@@ -334,7 +334,7 @@ strokemoveto(struct sctx *s, fz_point cur)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 strokelineto(struct sctx *s, fz_point cur)
 {
 	fz_error error;
@@ -368,7 +368,7 @@ strokelineto(struct sctx *s, fz_point cur)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 strokeclosepath(struct sctx *s)
 {
 	fz_error error;
@@ -398,7 +398,7 @@ strokeclosepath(struct sctx *s)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 strokebezier(struct sctx *s,
 	float xa, float ya,
 	float xb, float yb,
@@ -457,7 +457,7 @@ strokebezier(struct sctx *s,
 	return strokebezier(s, xabcd, yabcd, xbcd, ybcd, xcd, ycd, xd, yd);
 }
 
-fz_error 
+fz_error
 fz_strokepath(fz_gel *gel, fz_pathnode *path, fz_matrix ctm, float flatness, float linewidth)
 {
 	fz_error error;
@@ -530,7 +530,7 @@ fz_strokepath(fz_gel *gel, fz_pathnode *path, fz_matrix ctm, float flatness, flo
 	return strokeflush(&s);
 }
 
-static fz_error 
+static fz_error
 dashmoveto(struct sctx *s, fz_point a)
 {
 	s->toggle = 1;
@@ -554,7 +554,7 @@ dashmoveto(struct sctx *s, fz_point a)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 dashlineto(struct sctx *s, fz_point b)
 {
 	fz_error error;
@@ -600,7 +600,7 @@ dashlineto(struct sctx *s, fz_point b)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 dashbezier(struct sctx *s,
 	float xa, float ya,
 	float xb, float yb,
@@ -657,7 +657,7 @@ dashbezier(struct sctx *s,
 	return dashbezier(s, xabcd, yabcd, xbcd, ybcd, xcd, ycd, xd, yd);
 }
 
-fz_error 
+fz_error
 fz_dashpath(fz_gel *gel, fz_pathnode *path, fz_matrix ctm, float flatness, float linewidth)
 {
 	fz_error error;
diff --git a/fitzdraw/pixmap.c b/fitzdraw/pixmap.c
index 2103f59b..e3d9a285 100644
--- a/fitzdraw/pixmap.c
+++ b/fitzdraw/pixmap.c
@@ -2,14 +2,14 @@
 #include "fitz_tree.h"
 #include "fitz_draw.h"
 
-fz_error 
+fz_error
 fz_newpixmap(fz_pixmap **pixp, int x, int y, int w, int h, int n)
 {
 	fz_pixmap *pix;
 
 	pix = *pixp = fz_malloc(sizeof(fz_pixmap));
 	if (!pix)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	pix->x = x;
 	pix->y = y;
@@ -20,13 +20,13 @@ fz_newpixmap(fz_pixmap **pixp, int x, int y, int w, int h, int n)
 	pix->samples = fz_malloc(pix->w * pix->h * pix->n * sizeof(fz_sample));
 	if (!pix->samples) {
 		fz_free(pix);
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	}
 
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_newpixmapwithrect(fz_pixmap **pixp, fz_irect r, int n)
 {
 	return fz_newpixmap(pixp,
@@ -35,7 +35,7 @@ fz_newpixmapwithrect(fz_pixmap **pixp, fz_irect r, int n)
 				r.y1 - r.y0, n);
 }
 
-fz_error 
+fz_error
 fz_newpixmapcopy(fz_pixmap **pixp, fz_pixmap *old)
 {
 	fz_error error;
diff --git a/fitzdraw/render.c b/fitzdraw/render.c
index 133c5ed0..48c5fd05 100644
--- a/fitzdraw/render.c
+++ b/fitzdraw/render.c
@@ -23,7 +23,7 @@
 
 static fz_error rendernode(fz_renderer *gc, fz_node *node, fz_matrix ctm);
 
-fz_error 
+fz_error
 fz_newrenderer(fz_renderer **gcp, fz_colorspace *pcm, int maskonly, int gcmem)
 {
 	fz_error error;
@@ -31,7 +31,7 @@ fz_newrenderer(fz_renderer **gcp, fz_colorspace *pcm, int maskonly, int gcmem)
 
 	gc = fz_malloc(sizeof(fz_renderer));
 	if (!gc)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	gc->maskonly = maskonly;
 	gc->model = pcm;
@@ -91,7 +91,7 @@ fz_droprenderer(fz_renderer *gc)
  * Transform
  */
 
-static fz_error 
+static fz_error
 rendertransform(fz_renderer *gc, fz_transformnode *transform, fz_matrix ctm)
 {
 	fz_error error;
@@ -110,7 +110,7 @@ DEBUG("}\n");
  * Color
  */
 
-static fz_error 
+static fz_error
 rendersolid(fz_renderer *gc, fz_solidnode *solid, fz_matrix ctm)
 {
 	fz_error error;
@@ -184,7 +184,7 @@ DEBUG("solid %s [%d %d %d %d];\n", solid->cs->name, gc->argb[0], gc->argb[1], gc
  * Path
  */
 
-static fz_error 
+static fz_error
 renderpath(fz_renderer *gc, fz_pathnode *path, fz_matrix ctm)
 {
 	fz_error error;
@@ -307,7 +307,7 @@ static void drawglyph(fz_renderer *gc, fz_pixmap *dst, fz_glyph *src, int xorig,
 	}
 }
 
-static fz_error 
+static fz_error
 rendertext(fz_renderer *gc, fz_textnode *text, fz_matrix ctm)
 {
 	fz_error error;
@@ -385,7 +385,7 @@ calcimagescale(fz_matrix ctm, int w, int h, int *odx, int *ody)
 	*ody = dy;
 }
 
-static fz_error 
+static fz_error
 renderimage(fz_renderer *gc, fz_imagenode *node, fz_matrix ctm)
 {
 	fz_error error;
@@ -565,7 +565,7 @@ cleanup:
  * Shade
  */
 
-static fz_error 
+static fz_error
 rendershade(fz_renderer *gc, fz_shadenode *node, fz_matrix ctm)
 {
 	fz_error error;
@@ -682,7 +682,7 @@ blendmask(fz_renderer *gc, fz_pixmap *src, fz_pixmap *msk, fz_pixmap *dst, int o
 	}
 }
 
-static fz_error 
+static fz_error
 renderover(fz_renderer *gc, fz_overnode *over, fz_matrix ctm)
 {
 	fz_error error;
@@ -727,7 +727,7 @@ DEBUG("}\n");
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 rendermask(fz_renderer *gc, fz_masknode *mask, fz_matrix ctm)
 {
 	fz_error error;
@@ -851,7 +851,7 @@ cleanup:
  * Dispatch
  */
 
-static fz_error 
+static fz_error
 rendernode(fz_renderer *gc, fz_node *node, fz_matrix ctm)
 {
 	if (!node)
@@ -888,7 +888,7 @@ rendernode(fz_renderer *gc, fz_node *node, fz_matrix ctm)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_rendertree(fz_pixmap **outp,
 	fz_renderer *gc, fz_tree *tree, fz_matrix ctm,
 	fz_irect bbox, int white)
@@ -933,7 +933,7 @@ DEBUG("}\n");
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 fz_rendertreeover(fz_renderer *gc, fz_pixmap *dest, fz_tree *tree, fz_matrix ctm)
 {
 	fz_error error;
diff --git a/mupdf/pdf_annot.c b/mupdf/pdf_annot.c
index 6e634ba3..ac2c4690 100644
--- a/mupdf/pdf_annot.c
+++ b/mupdf/pdf_annot.c
@@ -1,20 +1,20 @@
 #include "fitz.h"
 #include "mupdf.h"
 
-static fz_error 
+static fz_error
 loadcomment(pdf_comment **commentp, pdf_xref *xref, fz_obj *dict)
 {
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_newlink(pdf_link **linkp, fz_rect bbox, fz_obj *dest)
 {
 	pdf_link *link;
 
 	link = fz_malloc(sizeof(pdf_link));
 	if (!link)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	link->rect = bbox;
 	link->dest = fz_keepobj(dest);
@@ -70,7 +70,7 @@ resolvedest(pdf_xref *xref, fz_obj *dest)
 	return nil;
 }
 
-fz_error 
+fz_error
 pdf_loadlink(pdf_link **linkp, pdf_xref *xref, fz_obj *dict)
 {
 	fz_error error;
@@ -144,7 +144,7 @@ pdf_loadlink(pdf_link **linkp, pdf_xref *xref, fz_obj *dict)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_loadannots(pdf_comment **cp, pdf_link **lp, pdf_xref *xref, fz_obj *annots)
 {
 	fz_error error;
diff --git a/mupdf/pdf_build.c b/mupdf/pdf_build.c
index a1553957..52e8f193 100644
--- a/mupdf/pdf_build.c
+++ b/mupdf/pdf_build.c
@@ -42,7 +42,7 @@ pdf_initgstate(pdf_gstate *gs)
 	gs->head = nil;
 }
 
-fz_error 
+fz_error
 pdf_newovernode(fz_node **nodep, pdf_gstate *gs)
 {
     if (gs->blendmode == FZ_BNORMAL)
@@ -51,7 +51,7 @@ pdf_newovernode(fz_node **nodep, pdf_gstate *gs)
 	return fz_newblendnode(nodep, gs->blendmode, 0, 0);
 }
 
-fz_error 
+fz_error
 pdf_setcolorspace(pdf_csi *csi, int what, fz_colorspace *cs)
 {
 	pdf_gstate *gs = csi->gstate + csi->gtop;
@@ -87,7 +87,7 @@ pdf_setcolorspace(pdf_csi *csi, int what, fz_colorspace *cs)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_setcolor(pdf_csi *csi, int what, float *v)
 {
 	pdf_gstate *gs = csi->gstate + csi->gtop;
@@ -138,7 +138,7 @@ Lindexed:
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_setpattern(pdf_csi *csi, int what, pdf_pattern *pat, float *v)
 {
 	pdf_gstate *gs = csi->gstate + csi->gtop;
@@ -170,7 +170,7 @@ pdf_setpattern(pdf_csi *csi, int what, pdf_pattern *pat, float *v)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_setshade(pdf_csi *csi, int what, fz_shade *shade)
 {
 	pdf_gstate *gs = csi->gstate + csi->gtop;
@@ -192,7 +192,7 @@ pdf_setshade(pdf_csi *csi, int what, fz_shade *shade)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_buildstrokepath(pdf_gstate *gs, fz_pathnode *path)
 {
 	fz_error error;
@@ -223,7 +223,7 @@ pdf_buildstrokepath(pdf_gstate *gs, fz_pathnode *path)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_buildfillpath(pdf_gstate *gs, fz_pathnode *path, int eofill)
 {
 	fz_error error;
@@ -233,7 +233,7 @@ pdf_buildfillpath(pdf_gstate *gs, fz_pathnode *path, int eofill)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 addcolorshape(pdf_gstate *gs, fz_node *shape, float alpha, fz_colorspace *cs, float *v)
 {
 	fz_error error;
@@ -258,7 +258,7 @@ addcolorshape(pdf_gstate *gs, fz_node *shape, float alpha, fz_colorspace *cs, fl
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 addinvisibleshape(pdf_gstate *gs, fz_node *shape)
 {
 	fz_error error;
@@ -305,7 +305,7 @@ static fz_matrix getmatrix(fz_node *node)
 	return fz_identity();
 }
 
-static fz_error 
+static fz_error
 addpatternshape(pdf_gstate *gs, fz_node *shape,
 		pdf_pattern *pat, fz_colorspace *cs, float *v)
 {
@@ -397,7 +397,7 @@ addpatternshape(pdf_gstate *gs, fz_node *shape,
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_addshade(pdf_gstate *gs, fz_shade *shade)
 {
 	fz_error error;
@@ -412,7 +412,7 @@ pdf_addshade(pdf_gstate *gs, fz_shade *shade)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 addshadeshape(pdf_gstate *gs, fz_node *shape, fz_shade *shade)
 {
 	fz_error error;
@@ -464,7 +464,7 @@ addshadeshape(pdf_gstate *gs, fz_node *shape, fz_shade *shade)
 			fz_dropnode(color);
 			fz_dropnode(mask);
 			fz_dropnode(xform);
-			return fz_rethrow(error, "cannot create solid node for background color");;
+			return fz_rethrow(error, "cannot create solid node for background color");
 		}
 
 		fz_insertnodelast(mask, shape);
@@ -485,7 +485,7 @@ addshadeshape(pdf_gstate *gs, fz_node *shape, fz_shade *shade)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_addfillshape(pdf_gstate *gs, fz_node *shape)
 {
 	fz_error error;
@@ -523,7 +523,7 @@ pdf_addfillshape(pdf_gstate *gs, fz_node *shape)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_addstrokeshape(pdf_gstate *gs, fz_node *shape)
 {
 	fz_error error;
@@ -561,7 +561,7 @@ pdf_addstrokeshape(pdf_gstate *gs, fz_node *shape)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_addclipmask(pdf_gstate *gs, fz_node *shape)
 {
 	fz_error error;
@@ -587,7 +587,7 @@ pdf_addclipmask(pdf_gstate *gs, fz_node *shape)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_addtransform(pdf_gstate *gs, fz_node *transform)
 {
 	fz_error error;
@@ -604,7 +604,7 @@ pdf_addtransform(pdf_gstate *gs, fz_node *transform)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_showimage(pdf_csi *csi, pdf_image *img)
 {
 	fz_error error;
@@ -656,7 +656,7 @@ pdf_showimage(pdf_csi *csi, pdf_image *img)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_showpath(pdf_csi *csi,
 		int doclose, int dofill, int dostroke, int evenodd)
 {
@@ -768,7 +768,7 @@ pdf_showpath(pdf_csi *csi,
 
 	error = fz_newpathnode(&csi->path);
 	if (error)
-		return fz_rethrow(error, "cannot create path node");;
+		return fz_rethrow(error, "cannot create path node");
 
 	return fz_okay;
 
@@ -785,7 +785,7 @@ cleanupclip:
  * Text
  */
 
-fz_error 
+fz_error
 pdf_flushtext(pdf_csi *csi)
 {
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
@@ -847,7 +847,7 @@ pdf_flushtext(pdf_csi *csi)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 showglyph(pdf_csi *csi, int cid)
 {
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
@@ -941,7 +941,7 @@ showspace(pdf_csi *csi, float tadj)
 		csi->tm = fz_concat(fz_translate(0, tadj), csi->tm);
 }
 
-fz_error 
+fz_error
 pdf_showtext(pdf_csi *csi, fz_obj *text)
 {
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
diff --git a/mupdf/pdf_cmap.c b/mupdf/pdf_cmap.c
index ed383af4..241d8591 100644
--- a/mupdf/pdf_cmap.c
+++ b/mupdf/pdf_cmap.c
@@ -22,14 +22,14 @@
  * Allocate, destroy and simple parameters.
  */
 
-fz_error 
+fz_error
 pdf_newcmap(pdf_cmap **cmapp)
 {
     pdf_cmap *cmap;
 
     cmap = *cmapp = fz_malloc(sizeof(pdf_cmap));
     if (!cmap)
-	return fz_throw("outofmem: cmap struct");
+	return fz_rethrow(-1, "out of memory: cmap struct");
 
     cmap->refs = 1;
     strcpy(cmap->cmapname, "");
@@ -163,7 +163,7 @@ pdf_debugcmap(pdf_cmap *cmap)
  * These ranges are used by pdf_decodecmap to decode
  * multi-byte encoded strings.
  */
-fz_error 
+fz_error
 pdf_addcodespace(pdf_cmap *cmap, int low, int high, int n)
 {
     if (cmap->ncspace + 1 == nelem(cmap->cspace))
@@ -181,7 +181,7 @@ pdf_addcodespace(pdf_cmap *cmap, int low, int high, int n)
 /*
  * Add an integer to the table.
  */
-static fz_error 
+static fz_error
 addtable(pdf_cmap *cmap, int value)
 {
     if (cmap->tlen + 1 > cmap->tcap)
@@ -189,7 +189,7 @@ addtable(pdf_cmap *cmap, int value)
 	int newcap = cmap->tcap == 0 ? 256 : cmap->tcap * 2;
 	unsigned short *newtable = fz_realloc(cmap->table, newcap * sizeof(unsigned short));
 	if (!newtable)
-	    return fz_throw("outofmem: cmap table");
+	    return fz_rethrow(-1, "out of memory: cmap table");
 	cmap->tcap = newcap;
 	cmap->table = newtable;
     }
@@ -202,7 +202,7 @@ addtable(pdf_cmap *cmap, int value)
 /*
  * Add a range.
  */
-static fz_error 
+static fz_error
 addrange(pdf_cmap *cmap, int low, int high, int flag, int offset)
 {
     if (cmap->rlen + 1 > cmap->rcap)
@@ -211,7 +211,7 @@ addrange(pdf_cmap *cmap, int low, int high, int flag, int offset)
 	int newcap = cmap->rcap == 0 ? 256 : cmap->rcap * 2;
 	newranges = fz_realloc(cmap->ranges, newcap * sizeof(pdf_range));
 	if (!newranges)
-	    return fz_throw("outofmem: cmap ranges");
+	    return fz_rethrow(-1, "out of memory: cmap ranges");
 	cmap->rcap = newcap;
 	cmap->ranges = newranges;
     }
@@ -228,7 +228,7 @@ addrange(pdf_cmap *cmap, int low, int high, int flag, int offset)
 /*
  * Add a range-to-table mapping.
  */
-fz_error 
+fz_error
 pdf_maprangetotable(pdf_cmap *cmap, int low, int *table, int len)
 {
     fz_error error;
@@ -256,7 +256,7 @@ pdf_maprangetotable(pdf_cmap *cmap, int low, int *table, int len)
 /*
  * Add a range of contiguous one-to-one mappings (ie 1..5 maps to 21..25)
  */
-fz_error 
+fz_error
 pdf_maprangetorange(pdf_cmap *cmap, int low, int high, int offset)
 {
     fz_error error;
@@ -269,7 +269,7 @@ pdf_maprangetorange(pdf_cmap *cmap, int low, int high, int offset)
 /*
  * Add a single one-to-many mapping.
  */
-fz_error 
+fz_error
 pdf_maponetomany(pdf_cmap *cmap, int low, int *values, int len)
 {
     fz_error error;
@@ -315,7 +315,7 @@ static int cmprange(const void *va, const void *vb)
     return ((const pdf_range*)va)->low - ((const pdf_range*)vb)->low;
 }
 
-fz_error 
+fz_error
 pdf_sortcmap(pdf_cmap *cmap)
 {
     fz_error error;
@@ -425,7 +425,7 @@ pdf_sortcmap(pdf_cmap *cmap)
 
     newranges = fz_realloc(cmap->ranges, cmap->rlen * sizeof(pdf_range));
     if (!newranges)
-	return fz_throw("outofmem: cmap ranges");
+	return fz_rethrow(-1, "out of memory: cmap ranges");
     cmap->rcap = cmap->rlen;
     if (cmap->refs >= 0)
 	cmap->ranges = newranges;
@@ -434,7 +434,7 @@ pdf_sortcmap(pdf_cmap *cmap)
     {
 	newtable = fz_realloc(cmap->table, cmap->tlen * sizeof(unsigned short));
 	if (!newtable)
-	    return fz_throw("outofmem: cmap table");
+	    return fz_rethrow(-1, "out of memory: cmap table");
 	cmap->tcap = cmap->tlen;
 	cmap->table = newtable;
     }
diff --git a/mupdf/pdf_cmap_load.c b/mupdf/pdf_cmap_load.c
index c8a0e18c..f1553e33 100644
--- a/mupdf/pdf_cmap_load.c
+++ b/mupdf/pdf_cmap_load.c
@@ -4,7 +4,7 @@
 /*
  * Load CMap stream in PDF file
  */
-fz_error 
+fz_error
 pdf_loadembeddedcmap(pdf_cmap **cmapp, pdf_xref *xref, fz_obj *stmref)
 {
     fz_error error = fz_okay;
@@ -100,7 +100,7 @@ cleanup:
 /*
  * Create an Identity-* CMap (for both 1 and 2-byte encodings)
  */
-fz_error 
+fz_error
 pdf_newidentitycmap(pdf_cmap **cmapp, int wmode, int bytes)
 {
     fz_error error;
@@ -139,7 +139,7 @@ pdf_newidentitycmap(pdf_cmap **cmapp, int wmode, int bytes)
 /*
  * Load predefined CMap from system.
  */
-fz_error 
+fz_error
 pdf_loadsystemcmap(pdf_cmap **cmapp, char *cmapname)
 {
     fz_error error;
diff --git a/mupdf/pdf_cmap_parse.c b/mupdf/pdf_cmap_parse.c
index cf7dec77..0e5ceec5 100644
--- a/mupdf/pdf_cmap_parse.c
+++ b/mupdf/pdf_cmap_parse.c
@@ -375,7 +375,7 @@ static fz_error parsebfchar(pdf_cmap *cmap, fz_stream *file)
     }
 }
 
-fz_error 
+fz_error
 pdf_parsecmap(pdf_cmap **cmapp, fz_stream *file)
 {
     fz_error error;
diff --git a/mupdf/pdf_colorspace1.c b/mupdf/pdf_colorspace1.c
index 65fd5c2c..0e6444a4 100644
--- a/mupdf/pdf_colorspace1.c
+++ b/mupdf/pdf_colorspace1.c
@@ -224,7 +224,7 @@ fz_colorspace *pdf_devicepattern = &kdevicepattern;
 
 #ifdef USECAL
 
-static fz_error 
+static fz_error
 loadcalgray(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
 {
 	fz_error error;
@@ -237,7 +237,7 @@ loadcalgray(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
 
 	cs = fz_malloc(sizeof(struct calgray));
 	if (!cs)
-		return fz_throw("outofmem: gray colorspace struct");
+		return fz_rethrow(-1, "out of memory: gray colorspace struct");
 
 	pdf_logrsrc("load CalGray\n");
 
@@ -279,7 +279,7 @@ loadcalgray(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 loadcalrgb(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
 {
 	fz_error error;
@@ -293,7 +293,7 @@ loadcalrgb(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
 
 	cs = fz_malloc(sizeof(struct calrgb));
 	if (!cs)
-		return fz_throw("outofmem: RGB colorspace struct");
+		return fz_rethrow(-1, "out of memory: RGB colorspace struct");
 
 	pdf_logrsrc("load CalRGB\n");
 
@@ -354,7 +354,7 @@ loadcalrgb(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 loadlab(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
 {
 	fz_error error;
@@ -367,7 +367,7 @@ loadlab(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
 
 	cs = fz_malloc(sizeof(struct cielab));
 	if (!cs)
-		return fz_throw("outofmem: L*a*b colorspace struct");
+		return fz_rethrow(-1, "out of memory: L*a*b colorspace struct");
 
 	pdf_logrsrc("load Lab\n");
 
@@ -423,7 +423,7 @@ loadlab(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
  * ICCBased
  */
 
-static fz_error 
+static fz_error
 loadiccbased(fz_colorspace **csp, pdf_xref *xref, fz_obj *ref)
 {
 	fz_error error;
@@ -488,7 +488,7 @@ dropseparation(fz_colorspace *fzcs)
 	pdf_dropfunction(cs->tint);
 }
 
-static fz_error 
+static fz_error
 loadseparation(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
 {
 	fz_error error;
@@ -531,7 +531,7 @@ loadseparation(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
 	{
 		pdf_dropfunction(tint);
 		fz_dropcolorspace(base);
-		return fz_throw("outofmem: separation colorspace struct");
+		return fz_rethrow(-1, "out of memory: separation colorspace struct");
 	}
 
 	initcs((fz_colorspace*)cs,
@@ -574,7 +574,7 @@ dropindexed(fz_colorspace *fzcs)
 	if (cs->lookup) fz_free(cs->lookup);
 }
 
-static fz_error 
+static fz_error
 loadindexed(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
 {
 	fz_error error;
@@ -603,7 +603,7 @@ loadindexed(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
 	if (!cs)
 	{
 		fz_dropcolorspace(base);
-		return fz_throw("outofmem: indexed colorspace struct");
+		return fz_rethrow(-1, "out of memory: indexed colorspace struct");
 	}
 
 	initcs((fz_colorspace*)cs, "Indexed", 1, nil, nil, dropindexed);
@@ -617,7 +617,7 @@ loadindexed(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
 	if (!cs->lookup)
 	{
 		fz_dropcolorspace((fz_colorspace*)cs);
-		return fz_throw("outofmem: indexed colorspace lookup table (%d entries)", n);
+		return fz_rethrow(-1, "out of memory: indexed colorspace lookup table (%d entries)", n);
 	}
 
 	if (fz_isstring(lookup) && fz_tostrlen(lookup) == n)
@@ -662,7 +662,7 @@ loadindexed(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
  * Parse and create colorspace from PDF object.
  */
 
-fz_error 
+fz_error
 pdf_loadcolorspace(fz_colorspace **csp, pdf_xref *xref, fz_obj *obj)
 {
 	if (fz_isname(obj))
diff --git a/mupdf/pdf_crypt.c b/mupdf/pdf_crypt.c
index 176de260..e2f844c4 100644
--- a/mupdf/pdf_crypt.c
+++ b/mupdf/pdf_crypt.c
@@ -45,7 +45,7 @@ static void padpassword(unsigned char *buf, unsigned char *pw, int pwlen)
 	memcpy(buf + pwlen, padding, 32 - pwlen);
 }
 
-static fz_error 
+static fz_error
 pdf_parsecryptfilt(fz_obj *filters, char *filter, char **method, int *length)
 {
 	fz_obj *cryptfilt;
@@ -77,7 +77,7 @@ cleanup:
 	return fz_throw("corrupt encryption filter dictionary");
 }
 
-static fz_error 
+static fz_error
 pdf_parseencdict(pdf_crypt *crypt, fz_obj *enc)
 {
 	fz_obj *obj;
@@ -173,7 +173,7 @@ cleanup:
  * Create crypt object for decrypting given the
  * Encoding dictionary and file ID
  */
-fz_error 
+fz_error
 pdf_newdecrypt(pdf_crypt **cp, fz_obj *enc, fz_obj *id)
 {
 	pdf_crypt *crypt;
@@ -182,7 +182,7 @@ pdf_newdecrypt(pdf_crypt **cp, fz_obj *enc, fz_obj *id)
 
 	crypt = fz_malloc(sizeof(pdf_crypt));
 	if (!crypt)
-		return fz_throw("outofmem: crypt struct");
+		return fz_rethrow(-1, "out of memory: crypt struct");
 
 	memset(crypt->o, 0x00, sizeof(crypt->o));
 	memset(crypt->u, 0x00, sizeof(crypt->u));
@@ -449,7 +449,7 @@ createuser(pdf_crypt *crypt, unsigned char *userpw, int pwlen)
  * Create crypt object for encrypting, given passwords,
  * permissions, and file ID
  */
-fz_error 
+fz_error
 pdf_newencrypt(pdf_crypt **cp, char *userpw, char *ownerpw, int p, int n, fz_obj *id)
 {
 	fz_error error;
@@ -457,7 +457,7 @@ pdf_newencrypt(pdf_crypt **cp, char *userpw, char *ownerpw, int p, int n, fz_obj
 
 	crypt = fz_malloc(sizeof(pdf_crypt));
 	if (!crypt)
-		return fz_throw("outofmem: crypt struct");
+		return fz_rethrow(-1, "out of memory: crypt struct");
 
 	crypt->encrypt = nil;
 	crypt->id = fz_keepobj(fz_arrayget(id, 0));
@@ -647,7 +647,7 @@ pdf_cryptbuffer(pdf_crypt *crypt, fz_buffer *buf, int oid, int gen)
 /*
  * Create filter suitable for de/encrypting a stream
  */
-fz_error 
+fz_error
 pdf_cryptstream(fz_filter **fp, pdf_crypt *crypt, int oid, int gen)
 {
 	fz_error error;
diff --git a/mupdf/pdf_font.c b/mupdf/pdf_font.c
index c830aed0..649dc591 100644
--- a/mupdf/pdf_font.c
+++ b/mupdf/pdf_font.c
@@ -209,7 +209,7 @@ pdf_newfontdesc(void)
  * Simple fonts (Type1 and TrueType)
  */
 
-static fz_error 
+static fz_error
 loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 {
 	fz_error error;
@@ -240,7 +240,7 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *r
 
 	fontdesc = pdf_newfontdesc();
 	if (!fontdesc)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	pdf_logfont("load simple font (%d %d R) ptr=%p {\n", fz_tonum(ref), fz_togen(ref), fontdesc);
 	pdf_logfont("basefont0 %s\n", basefont);
@@ -511,7 +511,7 @@ cleanup:
  * CID Fonts
  */
 
-static fz_error 
+static fz_error
 loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *ref, fz_obj *encoding, fz_obj *tounicode)
 {
 	fz_error error;
@@ -566,7 +566,7 @@ loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *ref,
 
 	fontdesc = pdf_newfontdesc();
 	if (!fontdesc)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	pdf_logfont("load cid font (%d %d R) ptr=%p {\n", fz_tonum(ref), fz_togen(ref), fontdesc);
 	pdf_logfont("basefont %s\n", basefont);
@@ -646,7 +646,7 @@ loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *ref,
 			map = fz_malloc(len * sizeof(unsigned short));
 			if (!map) {
 				fz_dropbuffer(buf);
-				error = fz_outofmem;
+				error = fz_rethrow(-1, "out of memory: cidtogidmap");
 				goto cleanup;
 			}
 
@@ -826,7 +826,7 @@ cleanup:
 	return fz_rethrow(error, "cannot load cid font");
 }
 
-static fz_error 
+static fz_error
 loadtype0(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 {
 	fz_error error;
@@ -873,7 +873,7 @@ loadtype0(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
  * FontDescriptor
  */
 
-fz_error 
+fz_error
 pdf_loadfontdescriptor(pdf_fontdesc *fontdesc, pdf_xref *xref, fz_obj *dict, char *collection)
 {
 	fz_error error;
@@ -943,7 +943,7 @@ cleanup:
 	return fz_rethrow(error, "cannot load font descriptor");
 }
 
-fz_error 
+fz_error
 pdf_loadfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 {
 	fz_error error;
diff --git a/mupdf/pdf_fontfile.c b/mupdf/pdf_fontfile.c
index cd525be3..0d6889d4 100644
--- a/mupdf/pdf_fontfile.c
+++ b/mupdf/pdf_fontfile.c
@@ -107,7 +107,7 @@ static const struct
     { 0, 0, 0 }
 };
 
-fz_error 
+fz_error
 pdf_loadbuiltinfont(pdf_fontdesc *font, char *fontname)
 {
 	fz_error error;
@@ -134,7 +134,7 @@ found:
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 loadsystemcidfont(pdf_fontdesc *font, int csi, int kind)
 {
 #ifndef NOCJK
@@ -155,7 +155,7 @@ loadsystemcidfont(pdf_fontdesc *font, int csi, int kind)
 #endif
 }
 
-fz_error 
+fz_error
 pdf_loadsystemfont(pdf_fontdesc *font, char *fontname, char *collection)
 {
 	fz_error error;
@@ -260,7 +260,7 @@ pdf_loadsystemfont(pdf_fontdesc *font, char *fontname, char *collection)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_loadembeddedfont(pdf_fontdesc *font, pdf_xref *xref, fz_obj *stmref)
 {
 	fz_error error;
diff --git a/mupdf/pdf_fontmtx.c b/mupdf/pdf_fontmtx.c
index 9b56a4e1..6355461a 100644
--- a/mupdf/pdf_fontmtx.c
+++ b/mupdf/pdf_fontmtx.c
@@ -20,7 +20,7 @@ pdf_setdefaultvmtx(pdf_fontdesc *font, int y, int w)
 	font->dvmtx.w = w;
 }
 
-fz_error 
+fz_error
 pdf_addhmtx(pdf_fontdesc *font, int lo, int hi, int w)
 {
 	int newcap;
@@ -31,7 +31,7 @@ pdf_addhmtx(pdf_fontdesc *font, int lo, int hi, int w)
 		newcap = font->hmtxcap + 16;
 		newmtx = fz_realloc(font->hmtx, sizeof(pdf_hmtx) * newcap);
 		if (!newmtx)
-			return fz_outofmem;
+			return fz_rethrow(-1, "out of memory");
 		font->hmtxcap = newcap;
 		font->hmtx = newmtx;
 	}
@@ -44,7 +44,7 @@ pdf_addhmtx(pdf_fontdesc *font, int lo, int hi, int w)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_addvmtx(pdf_fontdesc *font, int lo, int hi, int x, int y, int w)
 {
 	int newcap;
@@ -55,7 +55,7 @@ pdf_addvmtx(pdf_fontdesc *font, int lo, int hi, int x, int y, int w)
 		newcap = font->vmtxcap + 16;
 		newmtx = fz_realloc(font->vmtx, sizeof(pdf_vmtx) * newcap);
 		if (!newmtx)
-			return fz_outofmem;
+			return fz_rethrow(-1, "out of memory");
 		font->vmtxcap = newcap;
 		font->vmtx = newmtx;
 	}
@@ -84,7 +84,7 @@ static int cmpv(const void *a0, const void *b0)
 	return a->lo - b->lo;
 }
 
-fz_error 
+fz_error
 pdf_endhmtx(pdf_fontdesc *font)
 {
 	pdf_hmtx *newmtx;
@@ -96,14 +96,14 @@ pdf_endhmtx(pdf_fontdesc *font)
 
 	newmtx = fz_realloc(font->hmtx, sizeof(pdf_hmtx) * font->nhmtx);
 	if (!newmtx)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	font->hmtxcap = font->nhmtx;
 	font->hmtx = newmtx;
 
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_endvmtx(pdf_fontdesc *font)
 {
 	pdf_vmtx *newmtx;
@@ -115,7 +115,7 @@ pdf_endvmtx(pdf_fontdesc *font)
 
 	newmtx = fz_realloc(font->vmtx, sizeof(pdf_vmtx) * font->nvmtx);
 	if (!newmtx)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 	font->vmtxcap = font->nvmtx;
 	font->vmtx = newmtx;
 
diff --git a/mupdf/pdf_function.c b/mupdf/pdf_function.c
index dafd5b2d..5ec84275 100644
--- a/mupdf/pdf_function.c
+++ b/mupdf/pdf_function.c
@@ -144,7 +144,7 @@ pschecktype(psstack *st, unsigned short type)
 	return st->stack[st->sp].type == type;
 }
 
-static fz_error 
+static fz_error
 pspushbool(psstack *st, int booln)
 {
 	if (!pscheckoverflow(st, 1))
@@ -154,7 +154,7 @@ pspushbool(psstack *st, int booln)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 pspushint(psstack *st, int intg)
 {
 	if (!pscheckoverflow(st, 1))
@@ -164,7 +164,7 @@ pspushint(psstack *st, int intg)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 pspushreal(psstack *st, float real)
 {
 	if (!pscheckoverflow(st, 1))
@@ -174,7 +174,7 @@ pspushreal(psstack *st, float real)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 pspopbool(psstack *st, int *booln)
 {
 	if (!pscheckunderflow(st))
@@ -185,7 +185,7 @@ pspopbool(psstack *st, int *booln)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 pspopint(psstack *st, int *intg)
 {
 	if (!pscheckunderflow(st))
@@ -196,7 +196,7 @@ pspopint(psstack *st, int *intg)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 pspopnum(psstack *st, float *real)
 {
 	if (!pscheckunderflow(st))
@@ -237,7 +237,7 @@ pstoptwoarenums(psstack *st)
 		(st->stack[st->sp + 1].type == PSINT || st->stack[st->sp + 1].type == PSREAL);
 }
 
-static fz_error 
+static fz_error
 pscopy(psstack *st, int n)
 {
 	int i;
@@ -288,7 +288,7 @@ psroll(psstack *st, int n, int j)
 	}
 }
 
-static fz_error 
+static fz_error
 psindex(psstack *st, int i)
 {
 	if (!pscheckoverflow(st, 1))
@@ -298,7 +298,7 @@ psindex(psstack *st, int i)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 pspop(psstack *st)
 {
 	if (!pscheckoverflow(st, 1))
@@ -307,7 +307,7 @@ pspop(psstack *st)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 resizecode(pdf_function *func, int newsize)
 {
 	if (newsize >= func->u.p.cap)
@@ -316,14 +316,14 @@ resizecode(pdf_function *func, int newsize)
 		psobj *newcode;
 		newcode = fz_realloc(func->u.p.code, newcodecap * sizeof(psobj));
 		if (!newcode)
-			return fz_throw("outofmem: calculator function code");
+			return fz_rethrow(-1, "out of memory: calculator function code");
 		func->u.p.cap = newcodecap;
 		func->u.p.code = newcode;
 	}
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 parsecode(pdf_function *func, fz_stream *stream, int *codeptr)
 {
 	fz_error error;
@@ -391,7 +391,7 @@ parsecode(pdf_function *func, fz_stream *stream, int *codeptr)
 				if (error)
 					return fz_rethrow(error, "calculator function syntax error");
 			}
-			else 
+			else
 			{
 				elseptr = -1;
 			}
@@ -471,7 +471,7 @@ parsecode(pdf_function *func, fz_stream *stream, int *codeptr)
 	}
 }
 
-static fz_error 
+static fz_error
 loadpostscriptfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int oid, int gen)
 {
 	fz_error error;
@@ -516,7 +516,7 @@ loadpostscriptfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int oid, in
 #define SAFE_INDEX(st, i)	{ error = psindex(st, i); SAFE_RETHROW; }
 #define SAFE_COPY(st, n)	{ error = pscopy(st, n); SAFE_RETHROW; }
 
-static fz_error 
+static fz_error
 evalpostscriptfunc(pdf_function *func, psstack *st, int codeptr)
 {
 	fz_error error;
@@ -931,7 +931,7 @@ evalpostscriptfunc(pdf_function *func, psstack *st, int codeptr)
 
 static int bps_supported[] = { 1, 2, 4, 8, 12, 16, 24, 32 };
 
-static fz_error 
+static fz_error
 loadsamplefunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int oid, int gen)
 {
 	fz_error error;
@@ -1011,7 +1011,7 @@ loadsamplefunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int oid, int ge
 
 	func->u.sa.samples = fz_malloc(samplecount * sizeof(int));
 	if (!func->u.sa.samples)
-		return fz_throw("outofmem: samples");
+		return fz_rethrow(-1, "out of memory: samples");
 
 	error = pdf_openstream(&stream, xref, oid, gen);
 	if (error)
@@ -1073,7 +1073,7 @@ loadsamplefunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int oid, int ge
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 evalsamplefunc(pdf_function *func, float *in, float *out)
 {
 	float x;
@@ -1103,7 +1103,7 @@ evalsamplefunc(pdf_function *func, float *in, float *out)
 		s0 = fz_malloc((1 << func->m) * 2 * sizeof(float));
 		s1 = s0 + (1 << func->m);
 		if (!s0)
-			return fz_throw("outofmem: scratch buffer");
+			return fz_rethrow(-1, "out of memory: scratch buffer");
 	}
 
 	/* FIXME i think this is wrong... test with 2 samples it gets wrong idxs */
@@ -1143,7 +1143,7 @@ evalsamplefunc(pdf_function *func, float *in, float *out)
  * Exponential function
  */
 
-static fz_error 
+static fz_error
 loadexponentialfunc(pdf_function *func, fz_obj *dict)
 {
 	fz_obj *obj;
@@ -1195,7 +1195,7 @@ loadexponentialfunc(pdf_function *func, fz_obj *dict)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 evalexponentialfunc(pdf_function *func, float in, float *out)
 {
 	float x = in;
@@ -1225,7 +1225,7 @@ evalexponentialfunc(pdf_function *func, float in, float *out)
  * Stitching function
  */
 
-static fz_error 
+static fz_error
 loadstitchingfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict)
 {
 	pdf_function **funcs = func->u.st.funcs;
@@ -1434,7 +1434,7 @@ pdf_dropfunction(pdf_function *func)
 	}
 }
 
-fz_error 
+fz_error
 pdf_loadfunction(pdf_function **funcp, pdf_xref *xref, fz_obj *ref)
 {
 	fz_error error;
@@ -1453,7 +1453,7 @@ pdf_loadfunction(pdf_function **funcp, pdf_xref *xref, fz_obj *ref)
 
 	func = fz_malloc(sizeof(pdf_function));
 	if (!func)
-		return fz_throw("outofmem: function struct");
+		return fz_rethrow(-1, "out of memory: function struct");
 
 	memset(func, 0, sizeof(pdf_function));
 	func->refs = 1;
@@ -1571,7 +1571,7 @@ pdf_loadfunction(pdf_function **funcp, pdf_xref *xref, fz_obj *ref)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_evalfunction(pdf_function *func, float *in, int inlen, float *out, int outlen)
 {
 	fz_error error;
diff --git a/mupdf/pdf_image.c b/mupdf/pdf_image.c
index ad43167c..71f14e39 100644
--- a/mupdf/pdf_image.c
+++ b/mupdf/pdf_image.c
@@ -13,7 +13,7 @@ void pdf_dropimage(fz_image *fzimg)
 		fz_dropimage(img->mask);
 }
 
-fz_error 
+fz_error
 pdf_loadinlineimage(pdf_image **imgp, pdf_xref *xref,
 		fz_obj *rdb, fz_obj *dict, fz_stream *file)
 {
@@ -28,7 +28,7 @@ pdf_loadinlineimage(pdf_image **imgp, pdf_xref *xref,
 
 	img = fz_malloc(sizeof(pdf_image));
 	if (!img)
-		return fz_throw("outofmem: image struct");
+		return fz_rethrow(-1, "out of memory: image struct");
 
 	pdf_logimage("load inline image %p {\n", img);
 
@@ -202,7 +202,7 @@ loadcolorkey(int *colorkey, int bpc, int indexed, fz_obj *obj)
 }
 
 /* TODO error cleanup */
-fz_error 
+fz_error
 pdf_loadimage(pdf_image **imgp, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 {
 	fz_error error;
@@ -230,7 +230,7 @@ pdf_loadimage(pdf_image **imgp, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 
 	img = fz_malloc(sizeof(pdf_image));
 	if (!img)
-		return fz_throw("outofmem: image struct");
+		return fz_rethrow(-1, "out of memory: image struct");
 
 	pdf_logimage("load image (%d %d R) ptr=%p {\n", fz_tonum(ref), fz_togen(ref), img);
 
@@ -512,7 +512,7 @@ maskcolorkeyindexed(fz_pixmap *ind, fz_pixmap *pix, int *colorkey)
 	}
 }
 
-fz_error 
+fz_error
 pdf_loadtile(fz_image *img, fz_pixmap *tile)
 {
 	pdf_image *src = (pdf_image*)img;
diff --git a/mupdf/pdf_interpret.c b/mupdf/pdf_interpret.c
index eb573a1f..1324c2f5 100644
--- a/mupdf/pdf_interpret.c
+++ b/mupdf/pdf_interpret.c
@@ -1,7 +1,7 @@
 #include "fitz.h"
 #include "mupdf.h"
 
-fz_error 
+fz_error
 pdf_newcsi(pdf_csi **csip, int maskonly)
 {
 	fz_error error;
@@ -10,7 +10,7 @@ pdf_newcsi(pdf_csi **csip, int maskonly)
 
 	csi = fz_malloc(sizeof(pdf_csi));
 	if (!csi)
-		return fz_throw("outofmem: interpreter struct");
+		return fz_rethrow(-1, "out of memory: interpreter struct");
 
 	pdf_initgstate(&csi->gstate[0]);
 
@@ -94,7 +94,7 @@ pdf_dropmaterial(pdf_material *mat)
 	return mat;
 }
 
-static fz_error 
+static fz_error
 gsave(pdf_csi *csi)
 {
 	pdf_gstate *gs = csi->gstate + csi->gtop;
@@ -112,7 +112,7 @@ gsave(pdf_csi *csi)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 grestore(pdf_csi *csi)
 {
 	pdf_gstate *gs = csi->gstate + csi->gtop;
@@ -154,7 +154,7 @@ pdf_dropcsi(pdf_csi *csi)
  * Push gstate, set transform, clip, run, pop gstate.
  */
 
-static fz_error 
+static fz_error
 runxobject(pdf_csi *csi, pdf_xref *xref, pdf_xobject *xobj, int istransparency)
 {
 	fz_error error;
@@ -225,7 +225,7 @@ runxobject(pdf_csi *csi, pdf_xref *xref, pdf_xobject *xobj, int istransparency)
  * Decode inline image and insert into page.
  */
 
-static fz_error 
+static fz_error
 runinlineimage(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, fz_stream *file, fz_obj *dict)
 {
 	fz_error error;
@@ -266,7 +266,7 @@ runinlineimage(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, fz_stream *file, fz_ob
  * Set gstate params from an ExtGState dictionary.
  */
 
-static fz_error 
+static fz_error
 runextgstate(pdf_gstate *gstate, pdf_xref *xref, fz_obj *extgstate)
 {
 	int i, k;
@@ -386,7 +386,7 @@ runextgstate(pdf_gstate *gstate, pdf_xref *xref, fz_obj *extgstate)
  * The meat of the interpreter...
  */
 
-static fz_error 
+static fz_error
 runkeyword(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, char *buf)
 {
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
@@ -574,7 +574,7 @@ Lsetcolorspace:
 				if (error) return fz_rethrow(error, "cannot set pattern");
 			}
 
-			else 
+			else
 			{
 				if (!strcmp(fz_toname(obj), "DeviceGray"))
 					cs = pdf_devicegray;
@@ -1245,7 +1245,7 @@ syntaxerror:
 	return fz_throw("syntaxerror near '%s'", buf);
 }
 
-fz_error 
+fz_error
 pdf_runcsi(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, fz_stream *file)
 {
 	fz_error error;
diff --git a/mupdf/pdf_lex.c b/mupdf/pdf_lex.c
index 530de913..e0425685 100644
--- a/mupdf/pdf_lex.c
+++ b/mupdf/pdf_lex.c
@@ -252,7 +252,7 @@ pdf_tokenfromkeyword(char *key)
 	return PDF_TKEYWORD;
 }
 
-fz_error 
+fz_error
 pdf_lex(pdf_token_e *tok, fz_stream *f, char *buf, int n, int *sl)
 {
 	fz_error error;
diff --git a/mupdf/pdf_nametree.c b/mupdf/pdf_nametree.c
index b90421de..85a85b09 100644
--- a/mupdf/pdf_nametree.c
+++ b/mupdf/pdf_nametree.c
@@ -1,7 +1,7 @@
 #include "fitz.h"
 #include "mupdf.h"
 
-static fz_error 
+static fz_error
 loadnametreenode(fz_obj *tree, pdf_xref *xref, fz_obj *node)
 {
 	fz_error error;
@@ -72,7 +72,7 @@ loadnametreenode(fz_obj *tree, pdf_xref *xref, fz_obj *node)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_loadnametree(fz_obj **dictp, pdf_xref *xref, fz_obj *root)
 {
 	fz_error error;
@@ -95,7 +95,7 @@ pdf_loadnametree(fz_obj **dictp, pdf_xref *xref, fz_obj *root)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_loadnametrees(pdf_xref *xref)
 {
 	fz_error error;
diff --git a/mupdf/pdf_open.c b/mupdf/pdf_open.c
index 9623f6cc..6546c6d4 100644
--- a/mupdf/pdf_open.c
+++ b/mupdf/pdf_open.c
@@ -12,7 +12,7 @@ static inline int iswhite(int ch)
  * magic version tag and startxref
  */
 
-static fz_error 
+static fz_error
 loadversion(pdf_xref *xref)
 {
 	fz_error error;
@@ -35,7 +35,7 @@ loadversion(pdf_xref *xref)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 readstartxref(pdf_xref *xref)
 {
 	fz_error error;
@@ -75,7 +75,7 @@ readstartxref(pdf_xref *xref)
  * trailer dictionary
  */
 
-static fz_error 
+static fz_error
 readoldtrailer(pdf_xref *xref, char *buf, int cap)
 {
 	fz_error error;
@@ -147,7 +147,7 @@ readoldtrailer(pdf_xref *xref, char *buf, int cap)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 readnewtrailer(pdf_xref *xref, char *buf, int cap)
 {
 	fz_error error;
@@ -160,7 +160,7 @@ readnewtrailer(pdf_xref *xref, char *buf, int cap)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 readtrailer(pdf_xref *xref, char *buf, int cap)
 {
 	fz_error error;
@@ -199,7 +199,7 @@ readtrailer(pdf_xref *xref, char *buf, int cap)
  * xref tables
  */
 
-static fz_error 
+static fz_error
 readoldxref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 {
 	fz_error error;
@@ -249,7 +249,7 @@ readoldxref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 			xref->cap = ofs + len;
 			xref->table = fz_realloc(xref->table, xref->cap * sizeof(pdf_xrefentry));
 			if (!xref->table)
-				return fz_throw("outofmem: xref table");
+				return fz_rethrow(-1, "out of memory: xref table");
 		}
 
 		if ((ofs + len) > xref->len)
@@ -298,7 +298,7 @@ readoldxref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 readnewxrefsection(pdf_xref *xref, fz_stream *stm, int i0, int i1, int w0, int w1, int w2)
 {
 	fz_error error;
@@ -344,7 +344,7 @@ readnewxrefsection(pdf_xref *xref, fz_stream *stm, int i0, int i1, int w0, int w
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 readnewxref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 {
 	fz_error error;
@@ -441,7 +441,7 @@ readnewxref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 readxref(fz_obj **trailerp, pdf_xref *xref, int ofs, char *buf, int cap)
 {
 	fz_error error;
@@ -476,7 +476,7 @@ readxref(fz_obj **trailerp, pdf_xref *xref, int ofs, char *buf, int cap)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 readxrefsections(pdf_xref *xref, int ofs, char *buf, int cap)
 {
 	fz_error error;
@@ -521,7 +521,7 @@ readxrefsections(pdf_xref *xref, int ofs, char *buf, int cap)
  * compressed object streams
  */
 
-fz_error 
+fz_error
 pdf_loadobjstm(pdf_xref *xref, int oid, int gen, char *buf, int cap)
 {
 	fz_error error;
@@ -550,14 +550,14 @@ pdf_loadobjstm(pdf_xref *xref, int oid, int gen, char *buf, int cap)
 	oidbuf = fz_malloc(count * sizeof(int));
 	if (!oidbuf)
 	{
-		error = fz_throw("outofmem: object id buffer");
+		error = fz_rethrow(-1, "out of memory: object id buffer");
 		goto cleanupobj;
 	}
 
 	ofsbuf = fz_malloc(count * sizeof(int));
 	if (!ofsbuf)
 	{
-		error = fz_throw("outofmem: offset buffer");
+		error = fz_rethrow(-1, "out of memory: offset buffer");
 		goto cleanupoid;
 	}
 
@@ -637,7 +637,7 @@ cleanupobj:
  * open and load xref tables from pdf
  */
 
-fz_error 
+fz_error
 pdf_loadxref(pdf_xref *xref, char *filename)
 {
 	fz_error error;
@@ -691,7 +691,7 @@ pdf_loadxref(pdf_xref *xref, char *filename)
 	xref->table = fz_malloc(xref->cap * sizeof(pdf_xrefentry));
 	if (!xref->table)
 	{
-		error = fz_throw("outofmem: xref table");
+		error = fz_rethrow(-1, "out of memory: xref table");
 		goto cleanup;
 	}
 
diff --git a/mupdf/pdf_outline.c b/mupdf/pdf_outline.c
index bcd98038..7b24906c 100644
--- a/mupdf/pdf_outline.c
+++ b/mupdf/pdf_outline.c
@@ -1,7 +1,7 @@
 #include "fitz.h"
 #include "mupdf.h"
 
-static fz_error 
+static fz_error
 loadoutline(pdf_outline **nodep, pdf_xref *xref, fz_obj *dict)
 {
 	fz_error error;
@@ -65,7 +65,7 @@ loadoutline(pdf_outline **nodep, pdf_xref *xref, fz_obj *dict)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_loadoutline(pdf_outline **nodep, pdf_xref *xref)
 {
 	fz_error error;
diff --git a/mupdf/pdf_page.c b/mupdf/pdf_page.c
index b308a76d..b22b4255 100644
--- a/mupdf/pdf_page.c
+++ b/mupdf/pdf_page.c
@@ -1,7 +1,7 @@
 #include "fitz.h"
 #include "mupdf.h"
 
-static fz_error 
+static fz_error
 runone(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, fz_obj *stmref)
 {
 	fz_error error;
@@ -26,7 +26,7 @@ runone(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, fz_obj *stmref)
 /* we need to combine all sub-streams into one for pdf_runcsi
  * to deal with split dictionaries etc.
  */
-static fz_error 
+static fz_error
 runmany(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, fz_obj *list)
 {
     fz_error error;
@@ -92,7 +92,7 @@ runmany(pdf_csi *csi, pdf_xref *xref, fz_obj *rdb, fz_obj *list)
     return fz_okay;
 }
 
-static fz_error 
+static fz_error
 loadpagecontents(fz_tree **treep, pdf_xref *xref, fz_obj *rdb, fz_obj *ref)
 {
 	fz_error error;
@@ -150,7 +150,7 @@ loadpagecontents(fz_tree **treep, pdf_xref *xref, fz_obj *rdb, fz_obj *ref)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_loadpage(pdf_page **pagep, pdf_xref *xref, fz_obj *dict)
 {
 	fz_error error;
@@ -256,7 +256,7 @@ pdf_loadpage(pdf_page **pagep, pdf_xref *xref, fz_obj *dict)
 	{
 		fz_droptree(tree);
 		fz_dropobj(rdb);
-		return fz_throw("outofmem: page struct");
+		return fz_rethrow(-1, "out of memory: page struct");
 	}
 
 	page->mediabox.x0 = MIN(bbox.x0, bbox.x1);
diff --git a/mupdf/pdf_pagetree.c b/mupdf/pdf_pagetree.c
index 4f75b77f..ac06a370 100644
--- a/mupdf/pdf_pagetree.c
+++ b/mupdf/pdf_pagetree.c
@@ -9,7 +9,7 @@ struct stuff
 	fz_obj *rotate;
 };
 
-static fz_error 
+static fz_error
 loadpagetree(pdf_xref *xref, pdf_pagetree *pages,
 		struct stuff inherit, fz_obj *obj, fz_obj *ref, int *pagenum)
 {
@@ -144,7 +144,7 @@ pdf_debugpagetree(pdf_pagetree *pages)
 	printf("  ]\n>>\n");
 }
 
-fz_error 
+fz_error
 pdf_loadpagetree(pdf_pagetree **pp, pdf_xref *xref)
 {
 	fz_error error;
@@ -177,7 +177,7 @@ pdf_loadpagetree(pdf_pagetree **pp, pdf_xref *xref)
 	count = fz_toint(ref);
 
 	p = fz_malloc(sizeof(pdf_pagetree));
-	if (!p) { error = fz_throw("outofmem: page tree struct"); goto cleanup; }
+	if (!p) { error = fz_rethrow(-1, "out of memory: page tree struct"); goto cleanup; }
 
 	pdf_logpage("load pagetree %d pages (%d %d R) ptr=%p {\n", count, treeref->u.r.oid, treeref->u.r.gid, p);
 
@@ -187,10 +187,10 @@ pdf_loadpagetree(pdf_pagetree **pp, pdf_xref *xref)
 	p->cursor = 0;
 
 	p->pref = fz_malloc(sizeof(fz_obj*) * count);
-	if (!p->pref) { error = fz_throw("outofmem: page tree reference array"); goto cleanup; }
+	if (!p->pref) { error = fz_rethrow(-1, "out of memory: page tree reference array"); goto cleanup; }
 
 	p->pobj = fz_malloc(sizeof(fz_obj*) * count);
-	if (!p->pobj) { error = fz_throw("outofmem: page tree object array"); goto cleanup; }
+	if (!p->pobj) { error = fz_rethrow(-1, "out of memory: page tree object array"); goto cleanup; }
 
 	error = loadpagetree(xref, p, inherit, pages, treeref, &pagenum);
 	if (error) { error = fz_rethrow(error, "cannot load pagetree (%d %d R)", fz_tonum(treeref), fz_togen(treeref)); goto cleanup; }
diff --git a/mupdf/pdf_parse.c b/mupdf/pdf_parse.c
index c6589be4..3f9ed545 100644
--- a/mupdf/pdf_parse.c
+++ b/mupdf/pdf_parse.c
@@ -27,7 +27,7 @@ fz_matrix pdf_tomatrix(fz_obj *array)
 	return m;
 }
 
-fz_error 
+fz_error
 pdf_toutf8(char **dstp, fz_obj *src)
 {
 	unsigned char *srcptr = (unsigned char *) fz_tostrbuf(src);
@@ -47,7 +47,7 @@ pdf_toutf8(char **dstp, fz_obj *src)
 
 		dstptr = *dstp = fz_malloc(dstlen + 1);
 		if (!dstptr)
-			return fz_throw("outofmem: utf-8 string");
+			return fz_rethrow(-1, "out of memory: utf-8 string");
 
 		for (i = 2; i < srclen; i += 2)
 		{
@@ -63,7 +63,7 @@ pdf_toutf8(char **dstp, fz_obj *src)
 
 		dstptr = *dstp = fz_malloc(dstlen + 1);
 		if (!dstptr)
-			return fz_throw("outofmem: utf-8 string");
+			return fz_rethrow(-1, "out of memory: utf-8 string");
 
 		for (i = 0; i < srclen; i++)
 		{
@@ -76,7 +76,7 @@ pdf_toutf8(char **dstp, fz_obj *src)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_toucs2(unsigned short **dstp, fz_obj *src)
 {
 	unsigned char *srcptr = (unsigned char *) fz_tostrbuf(src);
@@ -88,7 +88,7 @@ pdf_toucs2(unsigned short **dstp, fz_obj *src)
 	{
 		dstptr = *dstp = fz_malloc(((srclen - 2) / 2 + 1) * sizeof(short));
 		if (!dstptr)
-			return fz_throw("outofmem: ucs-2 string");
+			return fz_rethrow(-1, "out of memory: ucs-2 string");
 		for (i = 2; i < srclen; i += 2)
 			*dstptr++ = (srcptr[i] << 8) | srcptr[i+1];
 	}
@@ -97,7 +97,7 @@ pdf_toucs2(unsigned short **dstp, fz_obj *src)
 	{
 		dstptr = *dstp = fz_malloc((srclen + 1) * sizeof(short));
 		if (!dstptr)
-			return fz_throw("outofmem: ucs-2 string");
+			return fz_rethrow(-1, "out of memory: ucs-2 string");
 		for (i = 0; i < srclen; i++)
 			*dstptr++ = pdf_docencoding[srcptr[i]];
 	}
@@ -106,7 +106,7 @@ pdf_toucs2(unsigned short **dstp, fz_obj *src)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_parsearray(fz_obj **op, fz_stream *file, char *buf, int cap)
 {
 	fz_error error = fz_okay;
@@ -217,7 +217,7 @@ cleanup:
 	return fz_rethrow(error, "cannot parse array");
 }
 
-fz_error 
+fz_error
 pdf_parsedict(fz_obj **op, fz_stream *file, char *buf, int cap)
 {
 	fz_error error = fz_okay;
@@ -325,7 +325,7 @@ cleanup:
 	return fz_rethrow(error, "cannot parse dict");
 }
 
-fz_error 
+fz_error
 pdf_parsestmobj(fz_obj **op, fz_stream *file, char *buf, int cap)
 {
 	fz_error error;
@@ -355,7 +355,7 @@ pdf_parsestmobj(fz_obj **op, fz_stream *file, char *buf, int cap)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_parseindobj(fz_obj **op, fz_stream *file, char *buf, int cap,
 		int *ooid, int *ogid, int *ostmofs)
 {
diff --git a/mupdf/pdf_pattern.c b/mupdf/pdf_pattern.c
index 5eea4140..b105144c 100644
--- a/mupdf/pdf_pattern.c
+++ b/mupdf/pdf_pattern.c
@@ -19,7 +19,7 @@ pdf_droppattern(pdf_pattern *pat)
 	}
 }
 
-fz_error 
+fz_error
 pdf_loadpattern(pdf_pattern **patp, pdf_xref *xref, fz_obj *dict, fz_obj *stmref)
 {
 	fz_error error;
@@ -39,7 +39,7 @@ pdf_loadpattern(pdf_pattern **patp, pdf_xref *xref, fz_obj *dict, fz_obj *stmref
 
 	pat = fz_malloc(sizeof(pdf_pattern));
 	if (!pat)
-		return fz_throw("outofmem: pattern struct");
+		return fz_rethrow(-1, "out of memory: pattern struct");
 
 	pat->refs = 1;
 	pat->tree = nil;
@@ -69,7 +69,7 @@ pdf_loadpattern(pdf_pattern **patp, pdf_xref *xref, fz_obj *dict, fz_obj *stmref
 			pat->matrix.c, pat->matrix.d,
 			pat->matrix.e, pat->matrix.f);
 
-	/* Store pattern now, to avoid possible recursion if objects refer back to this one */ 
+	/* Store pattern now, to avoid possible recursion if objects refer back to this one */
 	error = pdf_storeitem(xref->store, PDF_KPATTERN, stmref, pat);
 	if (error)
 	{
diff --git a/mupdf/pdf_repair.c b/mupdf/pdf_repair.c
index 04620a5f..e9740c4e 100644
--- a/mupdf/pdf_repair.c
+++ b/mupdf/pdf_repair.c
@@ -14,7 +14,7 @@ struct entry
 	int stmlen;
 };
 
-static fz_error 
+static fz_error
 parseobj(fz_stream *file, char *buf, int cap, int *stmofs, int *stmlen,
 		int *isroot, int *isinfo)
 {
@@ -134,7 +134,7 @@ atobjend:
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_repairxref(pdf_xref *xref, char *filename)
 {
 	fz_error error;
@@ -173,7 +173,7 @@ pdf_repairxref(pdf_xref *xref, char *filename)
 	list = fz_malloc(listcap * sizeof(struct entry));
 	if (!list)
 	{
-		error = fz_throw("outofmem: reparation object list");
+		error = fz_rethrow(-1, "out of memory: reparation object list");
 		goto cleanup;
 	}
 
@@ -228,7 +228,7 @@ pdf_repairxref(pdf_xref *xref, char *filename)
 				listcap = listcap * 2;
 				newlist = fz_realloc(list, listcap * sizeof(struct entry));
 				if (!newlist) {
-					error = fz_throw("outofmem: resize reparation object list");
+					error = fz_rethrow(-1, "out of memory: resize reparation object list");
 					goto cleanup;
 				}
 				list = newlist;
@@ -274,7 +274,7 @@ pdf_repairxref(pdf_xref *xref, char *filename)
 	xref->table = fz_malloc(xref->cap * sizeof(pdf_xrefentry));
 	if (!xref->table)
 	{
-		error = fz_throw("outofmem: xref table");
+		error = fz_rethrow(-1, "out of memory: xref table");
 		goto cleanup;
 	}
 
diff --git a/mupdf/pdf_resources.c b/mupdf/pdf_resources.c
index 1a1d5d92..af3a0efd 100644
--- a/mupdf/pdf_resources.c
+++ b/mupdf/pdf_resources.c
@@ -45,7 +45,7 @@ while in the middle of parsing a content stream.
 
 */
 
-static fz_error 
+static fz_error
 preloadcolorspace(pdf_xref *xref, fz_obj *ref)
 {
 	fz_error error;
@@ -73,7 +73,7 @@ preloadcolorspace(pdf_xref *xref, fz_obj *ref)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 preloadpattern(pdf_xref *xref, fz_obj *ref)
 {
 	fz_error error;
@@ -115,7 +115,7 @@ preloadpattern(pdf_xref *xref, fz_obj *ref)
 	}
 }
 
-static fz_error 
+static fz_error
 preloadshading(pdf_xref *xref, fz_obj *ref)
 {
 	fz_error error;
@@ -134,7 +134,7 @@ preloadshading(pdf_xref *xref, fz_obj *ref)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 preloadxobject(pdf_xref *xref, fz_obj *ref)
 {
 	fz_error error;
@@ -176,7 +176,7 @@ preloadxobject(pdf_xref *xref, fz_obj *ref)
 	}
 }
 
-static fz_error 
+static fz_error
 preloadfont(pdf_xref *xref, fz_obj *ref)
 {
 	fz_error error;
@@ -192,7 +192,7 @@ preloadfont(pdf_xref *xref, fz_obj *ref)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 preloadmask(pdf_xref *xref, fz_obj *ref)
 {
 	fz_error error;
@@ -216,7 +216,7 @@ preloadmask(pdf_xref *xref, fz_obj *ref)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 scanfontsandmasks(pdf_xref *xref, fz_obj *rdb)
 {
 	fz_error error;
@@ -266,7 +266,7 @@ scanfontsandmasks(pdf_xref *xref, fz_obj *rdb)
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 copyresolved(fz_obj **outp, pdf_xref *xref, fz_obj *dict)
 {
 	fz_error error;
@@ -314,7 +314,7 @@ copyresolved(fz_obj **outp, pdf_xref *xref, fz_obj *dict)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_loadresources(fz_obj **rdbp, pdf_xref *xref, fz_obj *orig)
 {
 	fz_error error;
diff --git a/mupdf/pdf_shade.c b/mupdf/pdf_shade.c
index 0ea648df..029c06e7 100644
--- a/mupdf/pdf_shade.c
+++ b/mupdf/pdf_shade.c
@@ -1,7 +1,7 @@
 #include "fitz.h"
 #include "mupdf.h"
 
-static fz_error 
+static fz_error
 pdf_loadcompositeshadefunc(fz_shade *shade, pdf_xref *xref, fz_obj *shading, fz_obj *funcref, float t0, float t1)
 {
 	fz_error error;
@@ -26,7 +26,7 @@ pdf_loadcompositeshadefunc(fz_shade *shade, pdf_xref *xref, fz_obj *shading, fz_
 	return fz_okay;
 }
 
-static fz_error 
+static fz_error
 pdf_loadcomponentshadefunc(fz_shade *shade, pdf_xref *xref, fz_obj *shading, fz_obj *funcs, float t0, float t1)
 {
 	fz_error error;
@@ -42,7 +42,7 @@ pdf_loadcomponentshadefunc(fz_shade *shade, pdf_xref *xref, fz_obj *shading, fz_
 	func = fz_malloc(fz_arraylen(funcs) * sizeof(pdf_function *));
 	if (!func)
 	{
-		error = fz_throw("outofmem: shading function"); 
+		error = fz_rethrow(-1, "out of memory: shading function");
 		goto cleanup;
 	}
 	memset(func, 0x00, fz_arraylen(funcs) * sizeof(pdf_function *));
@@ -100,7 +100,7 @@ cleanup:
 	return error;
 }
 
-fz_error 
+fz_error
 pdf_loadshadefunction(fz_shade *shade, pdf_xref *xref, fz_obj *shading, float t0, float t1)
 {
 	fz_error error;
@@ -144,7 +144,7 @@ pdf_setmeshvalue(float *mesh, int i, float x, float y, float t)
 	mesh[i*3+2] = t;
 }
 
-static fz_error 
+static fz_error
 loadshadedict(fz_shade **shadep, pdf_xref *xref, fz_obj *dict, fz_obj *ref, fz_matrix matrix)
 {
 	fz_error error;
@@ -157,7 +157,7 @@ loadshadedict(fz_shade **shadep, pdf_xref *xref, fz_obj *dict, fz_obj *ref, fz_m
 
 	shade = fz_malloc(sizeof(fz_shade));
 	if (!shade)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	shade->refs = 1;
 	shade->usebackground = 0;
@@ -256,7 +256,7 @@ cleanup:
 	return fz_rethrow(error, "could not load shading");
 }
 
-fz_error 
+fz_error
 pdf_loadshade(fz_shade **shadep, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 {
 	fz_error error;
diff --git a/mupdf/pdf_shade1.c b/mupdf/pdf_shade1.c
index ffa1768a..a2702e8d 100644
--- a/mupdf/pdf_shade1.c
+++ b/mupdf/pdf_shade1.c
@@ -8,7 +8,7 @@
 #define NSEGS 32
 #define MAX_RAD_SEGS 36
 
-fz_error 
+fz_error
 pdf_loadtype1shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 {
 	fz_error error;
@@ -60,7 +60,7 @@ pdf_loadtype1shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 	shade->meshlen = NSEGS * NSEGS * 2;
 	shade->mesh = fz_malloc(sizeof(float) * (2 + shade->cs->n) * 3 * shade->meshlen);
 	if (!shade->mesh)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	n = 0;
 	for (yy = 0; yy < NSEGS; ++yy)
@@ -109,7 +109,7 @@ pdf_loadtype1shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_loadtype2shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 {
 	fz_point p1, p2, p3, p4;
@@ -176,7 +176,7 @@ pdf_loadtype2shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 	shade->meshlen = 2 + e0 * 2 + e1 * 2;
 	shade->mesh = fz_malloc(sizeof(float) * 3*3 * shade->meshlen);
 	if (!shade->mesh)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	p1.x = x0 + BIGNUM * cos(theta);
 	p1.y = y0 + BIGNUM * sin(theta);
@@ -306,7 +306,7 @@ buildannulusmesh(float* mesh, int pos,
 	return pos;
 }
 
-fz_error 
+fz_error
 pdf_loadtype3shade(fz_shade *shade, pdf_xref *xref, fz_obj *shading, fz_obj *ref)
 {
 	fz_obj *obj;
@@ -388,7 +388,7 @@ pdf_loadtype3shade(fz_shade *shade, pdf_xref *xref, fz_obj *shading, fz_obj *ref
 			shade->meshlen = pos;
 			shade->mesh = fz_malloc(sizeof(float) * 9 * shade->meshlen);
 			if (!shade->mesh)
-				return fz_outofmem;
+				return fz_rethrow(-1, "out of memory");
 		}
 	}
 
diff --git a/mupdf/pdf_shade4.c b/mupdf/pdf_shade4.c
index 4f02f50a..5114c553 100644
--- a/mupdf/pdf_shade4.c
+++ b/mupdf/pdf_shade4.c
@@ -9,7 +9,7 @@ struct pdf_tensorpatch_s {
     float color[4][FZ_MAXCOLORS];
 };
 
-static fz_error 
+static fz_error
 growshademesh(fz_shade *shade, int amount)
 {
 	float *newmesh;
@@ -18,7 +18,7 @@ growshademesh(fz_shade *shade, int amount)
 	newcap = shade->meshcap + amount;
 	newmesh = fz_realloc(shade->mesh, sizeof(float) * newcap);
 	if (!newmesh)
-		return fz_outofmem;
+		return fz_rethrow(-1, "out of memory");
 
 	shade->mesh = newmesh;
 	shade->meshcap = newcap;
@@ -26,7 +26,7 @@ growshademesh(fz_shade *shade, int amount)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_loadtype4shade(fz_shade *shade, pdf_xref *xref, fz_obj *shading, fz_obj *ref)
 {
 	fz_error error;
@@ -205,7 +205,7 @@ getdata(fz_stream *stream, int bps)
 	return s;
 }
 
-fz_error 
+fz_error
 pdf_loadtype5shade(fz_shade *shade, pdf_xref *xref, fz_obj *shading, fz_obj *ref)
 {
 	fz_error error;
@@ -573,7 +573,7 @@ drawpatch(pdf_tensorpatch patch, fz_shade *shade, int ptr, int ncomp, int depth)
 	return ptr;
 }
 
-fz_error 
+fz_error
 pdf_loadtype6shade(fz_shade *shade, pdf_xref *xref, fz_obj *shading, fz_obj *ref)
 {
 	fz_error error;
@@ -694,7 +694,7 @@ cleanup:
 	return error;
 }
 
-fz_error 
+fz_error
 pdf_loadtype7shade(fz_shade *shade, pdf_xref *xref, fz_obj *shading, fz_obj *ref)
 {
 	fz_error error;
diff --git a/mupdf/pdf_store.c b/mupdf/pdf_store.c
index 16311f31..b7e130b6 100644
--- a/mupdf/pdf_store.c
+++ b/mupdf/pdf_store.c
@@ -24,7 +24,7 @@ struct pdf_store_s
 	pdf_item *root;		/* linked list for everything else */
 };
 
-fz_error 
+fz_error
 pdf_newstore(pdf_store **storep)
 {
 	fz_error error;
@@ -32,7 +32,7 @@ pdf_newstore(pdf_store **storep)
 
 	store = fz_malloc(sizeof(pdf_store));
 	if (!store)
-		return fz_throw("outofmem: store struct");;
+		return fz_rethrow(-1, "out of memory: store struct");
 
 	error = fz_newhash(&store->hash, 4096, sizeof(struct refkey));
 	if (error)
@@ -100,7 +100,7 @@ pdf_dropstore(pdf_store *store)
 	fz_free(store);
 }
 
-fz_error 
+fz_error
 pdf_storeitem(pdf_store *store, pdf_itemkind kind, fz_obj *key, void *val)
 {
 	fz_error error;
@@ -126,7 +126,7 @@ pdf_storeitem(pdf_store *store, pdf_itemkind kind, fz_obj *key, void *val)
 
 		item = fz_malloc(sizeof(pdf_item));
 		if (!item)
-			return fz_throw("outofmem: store list node");
+			return fz_rethrow(-1, "out of memory: store list node");
 
 		pdf_logrsrc("store item %d: ... = %p\n", kind, val);
 
@@ -180,7 +180,7 @@ pdf_finditem(pdf_store *store, pdf_itemkind kind, fz_obj *key)
 	return nil;
 }
 
-fz_error 
+fz_error
 pdf_removeitem(pdf_store *store, pdf_itemkind kind, fz_obj *key)
 {
 	fz_error error;
diff --git a/mupdf/pdf_stream.c b/mupdf/pdf_stream.c
index 4690492d..523145da 100644
--- a/mupdf/pdf_stream.c
+++ b/mupdf/pdf_stream.c
@@ -25,7 +25,7 @@ pdf_isstream(pdf_xref *xref, int oid, int gen)
 /*
  * Create a filter given a name and param dictionary.
  */
-static fz_error 
+static fz_error
 buildonefilter(fz_filter **fp, fz_obj *f, fz_obj *p)
 {
 	fz_filter *decompress;
@@ -136,7 +136,7 @@ buildonefilter(fz_filter **fp, fz_obj *f, fz_obj *p)
  * If head is given, start filter chain with it.
  * Assume ownership of head.
  */
-static fz_error 
+static fz_error
 buildfilterchain(fz_filter **filterp, fz_filter *head, fz_obj *fs, fz_obj *ps)
 {
 	fz_error error;
@@ -183,7 +183,7 @@ buildfilterchain(fz_filter **filterp, fz_filter *head, fz_obj *fs, fz_obj *ps)
  * This is a null filter to constrain reading to the
  * stream length, followed by a decryption filter.
  */
-static fz_error 
+static fz_error
 buildrawfilter(fz_filter **filterp, pdf_xref *xref, fz_obj *stmobj, int oid, int gen)
 {
 	fz_error error;
@@ -234,7 +234,7 @@ buildrawfilter(fz_filter **filterp, pdf_xref *xref, fz_obj *stmobj, int oid, int
  * Construct a filter to decode a stream, without
  * constraining to stream length, and without decryption.
  */
-fz_error 
+fz_error
 pdf_buildinlinefilter(fz_filter **filterp, fz_obj *stmobj)
 {
 	fz_error error;
@@ -263,7 +263,7 @@ pdf_buildinlinefilter(fz_filter **filterp, fz_obj *stmobj)
  * Construct a filter to decode a stream, constraining
  * to stream length and decrypting.
  */
-static fz_error 
+static fz_error
 pdf_buildfilter(fz_filter **filterp, pdf_xref *xref, fz_obj *stmobj, int oid, int gen)
 {
 	fz_error error;
@@ -350,10 +350,10 @@ cleanup0:
 }
 
 /*
- * Open a stream for reading the raw (compressed but decrypted) data. 
+ * Open a stream for reading the raw (compressed but decrypted) data.
  * Using xref->file while this is open is a bad idea.
  */
-fz_error 
+fz_error
 pdf_openrawstream(fz_stream **stmp, pdf_xref *xref, int oid, int gen)
 {
 	pdf_xrefentry *x;
@@ -396,11 +396,11 @@ pdf_openrawstream(fz_stream **stmp, pdf_xref *xref, int oid, int gen)
 }
 
 /*
- * Open a stream for reading uncompressed data. 
+ * Open a stream for reading uncompressed data.
  * Put the opened file in xref->stream.
  * Using xref->file while a stream is open is a Bad idea.
  */
-fz_error 
+fz_error
 pdf_openstream(fz_stream **stmp, pdf_xref *xref, int oid, int gen)
 {
 	pdf_xrefentry *x;
@@ -443,7 +443,7 @@ pdf_openstream(fz_stream **stmp, pdf_xref *xref, int oid, int gen)
 /*
  * Load raw (compressed but decrypted) contents of a stream into buf.
  */
-fz_error 
+fz_error
 pdf_loadrawstream(fz_buffer **bufp, pdf_xref *xref, int oid, int gen)
 {
 	fz_error error;
@@ -463,7 +463,7 @@ pdf_loadrawstream(fz_buffer **bufp, pdf_xref *xref, int oid, int gen)
 /*
  * Load uncompressed contents of a stream into buf.
  */
-fz_error 
+fz_error
 pdf_loadstream(fz_buffer **bufp, pdf_xref *xref, int oid, int gen)
 {
 	fz_error error;
diff --git a/mupdf/pdf_type3.c b/mupdf/pdf_type3.c
index 60cd2460..79d2839e 100644
--- a/mupdf/pdf_type3.c
+++ b/mupdf/pdf_type3.c
@@ -1,7 +1,7 @@
 #include "fitz.h"
 #include "mupdf.h"
 
-static fz_error 
+static fz_error
 loadcharproc(fz_tree **treep, pdf_xref *xref, fz_obj *rdb, fz_obj *stmref)
 {
 	fz_error error;
@@ -35,7 +35,7 @@ loadcharproc(fz_tree **treep, pdf_xref *xref, fz_obj *rdb, fz_obj *stmref)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_loadtype3font(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 {
 	fz_error error;
@@ -60,7 +60,7 @@ pdf_loadtype3font(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj
 
 	fontdesc = pdf_newfontdesc();
 	if (!fontdesc)
-		return fz_throw("outofmem: font struct");
+		return fz_rethrow(-1, "out of memory: font struct");
 
 	pdf_logfont("load type3 font (%d %d R) ptr=%p {\n", fz_tonum(ref), fz_togen(ref), fontdesc);
 	pdf_logfont("name %s\n", buf);
diff --git a/mupdf/pdf_unicode.c b/mupdf/pdf_unicode.c
index 418e318c..e47cd4e9 100644
--- a/mupdf/pdf_unicode.c
+++ b/mupdf/pdf_unicode.c
@@ -5,7 +5,7 @@
  * ToUnicode map for fonts
  */
 
-fz_error 
+fz_error
 pdf_loadtounicode(pdf_fontdesc *font, pdf_xref *xref,
 	char **strings, char *collection, fz_obj *cmapstm)
 {
@@ -89,7 +89,7 @@ pdf_loadtounicode(pdf_fontdesc *font, pdf_xref *xref,
 		font->ncidtoucs = 256;
 		font->cidtoucs = fz_malloc(256 * sizeof(unsigned short));
 		if (!font->cidtoucs)
-			return fz_throw("outofmem: tounicode cidtoucs table");
+			return fz_rethrow(-1, "out of memory: tounicode cidtoucs table");
 
 		for (i = 0; i < 256; i++)
 		{
@@ -130,13 +130,13 @@ pdf_loadtounicode(pdf_fontdesc *font, pdf_xref *xref,
 
 #if 0
 
-fz_error 
+fz_error
 pdf_newtextline(pdf_textline **linep)
 {
 	pdf_textline *line;
 	line = *linep = fz_malloc(sizeof(pdf_textline));
 	if (!line)
-		return fz_throw("outofmem: textline struct");
+		return fz_rethrow(-1, "out of memory: textline struct");
 	line->len = 0;
 	line->cap = 0;
 	line->text = nil;
@@ -153,7 +153,7 @@ pdf_droptextline(pdf_textline *line)
 	fz_free(line);
 }
 
-static fz_error 
+static fz_error
 addtextchar(pdf_textline *line, fz_irect bbox, int c)
 {
 	pdf_textchar *newtext;
@@ -164,7 +164,7 @@ addtextchar(pdf_textline *line, fz_irect bbox, int c)
 		newcap = line->cap ? line->cap * 2 : 80;
 		newtext = fz_realloc(line->text, sizeof(pdf_textchar) * newcap);
 		if (!newtext)
-			return fz_throw("outofmem: textline buffer resize");
+			return fz_rethrow(-1, "out of memory: textline buffer resize");
 		line->cap = newcap;
 		line->text = newtext;
 	}
@@ -179,7 +179,7 @@ addtextchar(pdf_textline *line, fz_irect bbox, int c)
 /* XXX global! not reentrant! */
 static fz_point oldpt = { 0, 0 };
 
-static fz_error 
+static fz_error
 extracttext(pdf_textline **line, fz_node *node, fz_matrix ctm)
 {
 	fz_error error;
@@ -290,7 +290,7 @@ extracttext(pdf_textline **line, fz_node *node, fz_matrix ctm)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_loadtextfromtree(pdf_textline **outp, fz_tree *tree, fz_matrix ctm)
 {
 	pdf_textline *root;
diff --git a/mupdf/pdf_xobject.c b/mupdf/pdf_xobject.c
index 696aae01..8bb802a5 100644
--- a/mupdf/pdf_xobject.c
+++ b/mupdf/pdf_xobject.c
@@ -1,7 +1,7 @@
 #include "fitz.h"
 #include "mupdf.h"
 
-fz_error 
+fz_error
 pdf_loadxobject(pdf_xobject **formp, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 {
 	fz_error error;
@@ -16,7 +16,7 @@ pdf_loadxobject(pdf_xobject **formp, pdf_xref *xref, fz_obj *dict, fz_obj *ref)
 
 	form = fz_malloc(sizeof(pdf_xobject));
 	if (!form)
-		return fz_throw("outofmem: xobject struct");
+		return fz_rethrow(-1, "out of memory: xobject struct");
 
 	form->refs = 1;
 	form->resources = nil;
diff --git a/mupdf/pdf_xref.c b/mupdf/pdf_xref.c
index 30288de0..d27ccfea 100644
--- a/mupdf/pdf_xref.c
+++ b/mupdf/pdf_xref.c
@@ -6,14 +6,14 @@
  * needs to be initialized by initxref, openxref or repairxref.
  */
 
-fz_error 
+fz_error
 pdf_newxref(pdf_xref **xrefp)
 {
 	pdf_xref *xref;
 
 	xref = fz_malloc(sizeof(pdf_xref));
 	if (!xref)
-		return fz_throw("outofmem: xref struct");
+		return fz_rethrow(-1, "out of memory: xref struct");
 
 	memset(xref, 0, sizeof(pdf_xref));
 
@@ -72,12 +72,12 @@ pdf_closexref(pdf_xref *xref)
 	fz_free(xref);
 }
 
-fz_error 
+fz_error
 pdf_initxref(pdf_xref *xref)
 {
 	xref->table = fz_malloc(sizeof(pdf_xrefentry) * 128);
 	if (!xref->table)
-		return fz_throw("outofmem: xref table");
+		return fz_rethrow(-1, "out of memory: xref table");
 
 	xref->cap = 128;
 	xref->len = 1;
@@ -138,7 +138,7 @@ pdf_debugxref(pdf_xref *xref)
 }
 
 /* ICKY! */
-fz_error 
+fz_error
 pdf_decryptxref(pdf_xref *xref)
 {
 	fz_error error;
@@ -181,7 +181,7 @@ pdf_decryptxref(pdf_xref *xref)
  * object loading
  */
 
-fz_error 
+fz_error
 pdf_cacheobject(pdf_xref *xref, int oid, int gen)
 {
 	char buf[65536];	/* yeowch! */
@@ -236,7 +236,7 @@ pdf_cacheobject(pdf_xref *xref, int oid, int gen)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_loadobject(fz_obj **objp, pdf_xref *xref, int oid, int gen)
 {
 	fz_error error;
@@ -250,7 +250,7 @@ pdf_loadobject(fz_obj **objp, pdf_xref *xref, int oid, int gen)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_loadindirect(fz_obj **objp, pdf_xref *xref, fz_obj *ref)
 {
 	fz_error error;
@@ -265,7 +265,7 @@ pdf_loadindirect(fz_obj **objp, pdf_xref *xref, fz_obj *ref)
 	return fz_okay;
 }
 
-fz_error 
+fz_error
 pdf_resolve(fz_obj **objp, pdf_xref *xref)
 {
 	fz_error error;