Initial import of exception handling code

Import exception handling code from WSS, modified to fit into the
fitz world.

With this code we have 'real' fz_try/fz_catch/fz_rethrow functions,
handling a fz_except type. We therefore rename the existing fz_throw/
fz_catch/fz_rethrow to be fz_error_make/fz_error_handle/fz_error_note.

We don't actually use fz_try/fz_catch/fz_rethrow yet...

59 files changed, 763 insertions, 619 deletions

diff --git a/apps/pdfapp.c b/apps/pdfapp.c
index 6292b039..2c9ac4e0 100644
--- a/apps/pdfapp.c
+++ b/apps/pdfapp.c
@@ -112,7 +112,7 @@ static void pdfapp_open_pdf(pdfapp_t *app, char *filename, int fd)
 	file = fz_open_fd(fd);
 	error = pdf_open_xref_with_stream(&app->xref, file, NULL);
 	if (error)
-		pdfapp_error(app, fz_rethrow(error, "cannot open document '%s'", filename));
+		pdfapp_error(app, fz_error_note(error, "cannot open document '%s'", filename));
 	fz_close(file);
 
 	/*
@@ -158,7 +158,7 @@ static void pdfapp_open_pdf(pdfapp_t *app, char *filename, int fd)
 
 	error = pdf_load_page_tree(app->xref);
 	if (error)
-		pdfapp_error(app, fz_rethrow(error, "cannot load page tree"));
+		pdfapp_error(app, fz_error_note(error, "cannot load page tree"));
 
 	app->pagecount = pdf_count_pages(app->xref);
 }
@@ -171,7 +171,7 @@ static void pdfapp_open_xps(pdfapp_t *app, char *filename, int fd)
 	file = fz_open_fd(fd);
 	error = xps_open_stream(&app->xps, file);
 	if (error)
-		pdfapp_error(app, fz_rethrow(error, "cannot open document '%s'", filename));
+		pdfapp_error(app, fz_error_note(error, "cannot open document '%s'", filename));
 	fz_close(file);
 
 	app->doctitle = filename;
@@ -299,7 +299,7 @@ static void pdfapp_loadpage_pdf(pdfapp_t *app)
 	error = pdf_run_page(app->xref, page, mdev, fz_identity);
 	if (error)
 	{
-		error = fz_rethrow(error, "cannot draw page %d in '%s'", app->pageno, app->doctitle);
+		error = fz_error_note(error, "cannot draw page %d in '%s'", app->pageno, app->doctitle);
 		pdfapp_error(app, error);
 	}
 	fz_free_device(mdev);
@@ -317,7 +317,7 @@ static void pdfapp_loadpage_xps(pdfapp_t *app)
 
 	error = xps_load_page(&page, app->xps, app->pageno - 1);
 	if (error)
-		pdfapp_error(app, fz_rethrow(error, "cannot load page %d in file '%s'", app->pageno, app->doctitle));
+		pdfapp_error(app, fz_error_note(error, "cannot load page %d in file '%s'", app->pageno, app->doctitle));
 
 	app->page_bbox.x0 = 0;
 	app->page_bbox.y0 = 0;
diff --git a/apps/pdfclean.c b/apps/pdfclean.c
index dd85b1a4..99a00845 100644
--- a/apps/pdfclean.c
+++ b/apps/pdfclean.c
@@ -27,7 +27,7 @@ static pdf_xref *xref = NULL;
 
 void die(fz_error error)
 {
-	fz_catch(error, "aborting");
+	fz_error_handle(error, "aborting");
 	if (xref)
 		pdf_free_xref(xref);
 	exit(1);
@@ -283,7 +283,7 @@ static void retainpages(int argc, char **argv)
 	/* Load the old page tree */
 	error = pdf_load_page_tree(xref);
 	if (error)
-		die(fz_rethrow(error, "cannot load page tree"));
+		die(fz_error_note(error, "cannot load page tree"));
 
 	/* Keep only pages/type entry to avoid references to unretained pages */
 	oldroot = fz_dict_gets(xref->trailer, "Root");
@@ -712,11 +712,11 @@ int main(int argc, char **argv)
 
 	error = pdf_open_xref(&xref, infile, password);
 	if (error)
-		die(fz_rethrow(error, "cannot open input file '%s'", infile));
+		die(fz_error_note(error, "cannot open input file '%s'", infile));
 
 	out = fopen(outfile, "wb");
 	if (!out)
-		die(fz_throw("cannot open output file '%s'", outfile));
+		die(fz_error_make("cannot open output file '%s'", outfile));
 
 	fprintf(out, "%%PDF-%d.%d\n", xref->version / 10, xref->version % 10);
 	fprintf(out, "%%\316\274\341\277\246\n\n");
@@ -760,7 +760,7 @@ int main(int argc, char **argv)
 	writepdf();
 
 	if (fclose(out))
-		die(fz_throw("cannot close output file '%s'", outfile));
+		die(fz_error_make("cannot close output file '%s'", outfile));
 
 	fz_free(uselist);
 	fz_free(ofslist);
diff --git a/apps/pdfdraw.c b/apps/pdfdraw.c
index a5f6aa1e..7a23acef 100644
--- a/apps/pdfdraw.c
+++ b/apps/pdfdraw.c
@@ -37,7 +37,7 @@ struct {
 
 static void die(fz_error error)
 {
-	fz_catch(error, "aborting");
+	fz_error_handle(error, "aborting");
 	exit(1);
 }
 
@@ -105,7 +105,7 @@ static void drawpage(pdf_xref *xref, int pagenum)
 
 	error = pdf_load_page(&page, xref, pagenum - 1);
 	if (error)
-		die(fz_rethrow(error, "cannot load page %d in file '%s'", pagenum, filename));
+		die(fz_error_note(error, "cannot load page %d in file '%s'", pagenum, filename));
 
 	list = NULL;
 
@@ -115,7 +115,7 @@ static void drawpage(pdf_xref *xref, int pagenum)
 		dev = fz_new_list_device(list);
 		error = pdf_run_page(xref, page, dev, fz_identity);
 		if (error)
-			die(fz_rethrow(error, "cannot draw page %d in file '%s'", pagenum, filename));
+			die(fz_error_note(error, "cannot draw page %d in file '%s'", pagenum, filename));
 		fz_free_device(dev);
 	}
 
@@ -369,11 +369,11 @@ int main(int argc, char **argv)
 
 		error = pdf_open_xref(&xref, filename, password);
 		if (error)
-			die(fz_rethrow(error, "cannot open document: %s", filename));
+			die(fz_error_note(error, "cannot open document: %s", filename));
 
 		error = pdf_load_page_tree(xref);
 		if (error)
-			die(fz_rethrow(error, "cannot load page tree: %s", filename));
+			die(fz_error_note(error, "cannot load page tree: %s", filename));
 
 		if (showxml)
 			printf("<document name=\"%s\">\n", filename);
diff --git a/apps/pdfextract.c b/apps/pdfextract.c
index 7e6e4ace..c84f6ad9 100644
--- a/apps/pdfextract.c
+++ b/apps/pdfextract.c
@@ -10,7 +10,7 @@ static int dorgb = 0;
 
 void die(fz_error error)
 {
-	fz_catch(error, "aborting");
+	fz_error_handle(error, "aborting");
 	if (xref)
 		pdf_free_xref(xref);
 	exit(1);
@@ -115,7 +115,7 @@ static void savefont(fz_obj *dict, int num)
 
 		obj = fz_dict_gets(obj, "Subtype");
 		if (obj && !fz_is_name(obj))
-			die(fz_throw("Invalid font descriptor subtype"));
+			die(fz_error_make("Invalid font descriptor subtype"));
 
 		subtype = fz_to_name(obj);
 		if (!strcmp(subtype, "Type1C"))
@@ -123,7 +123,7 @@ static void savefont(fz_obj *dict, int num)
 		else if (!strcmp(subtype, "CIDFontType0C"))
 			ext = "cid";
 		else
-			die(fz_throw("Unhandled font type '%s'", subtype));
+			die(fz_error_make("Unhandled font type '%s'", subtype));
 	}
 
 	if (!stream)
@@ -143,14 +143,14 @@ static void savefont(fz_obj *dict, int num)
 
 	f = fopen(name, "wb");
 	if (f == NULL)
-		die(fz_throw("Error creating font file"));
+		die(fz_error_make("Error creating font file"));
 
 	n = fwrite(buf->data, 1, buf->len, f);
 	if (n < buf->len)
-		die(fz_throw("Error writing font file"));
+		die(fz_error_make("Error writing font file"));
 
 	if (fclose(f) < 0)
-		die(fz_throw("Error closing font file"));
+		die(fz_error_make("Error closing font file"));
 
 	fz_drop_buffer(buf);
 }
@@ -161,7 +161,7 @@ static void showobject(int num)
 	fz_obj *obj;
 
 	if (!xref)
-		die(fz_throw("no file specified"));
+		die(fz_error_make("no file specified"));
 
 	error = pdf_load_object(&obj, xref, num, 0);
 	if (error)
@@ -198,7 +198,7 @@ int main(int argc, char **argv)
 	infile = argv[fz_optind++];
 	error = pdf_open_xref(&xref, infile, password);
 	if (error)
-		die(fz_rethrow(error, "cannot open input file '%s'", infile));
+		die(fz_error_note(error, "cannot open input file '%s'", infile));
 
 	if (fz_optind == argc)
 	{
diff --git a/apps/pdfinfo.c b/apps/pdfinfo.c
index d8948264..34370869 100644
--- a/apps/pdfinfo.c
+++ b/apps/pdfinfo.c
@@ -13,7 +13,7 @@ void closexref(void);
 
 void die(fz_error error)
 {
-	fz_catch(error, "aborting");
+	fz_error_handle(error, "aborting");
 	closexref();
 	exit(1);
 }
@@ -573,7 +573,7 @@ gatherresourceinfo(int page, fz_obj *rsrc)
 	pageref = xref->page_refs[page-1];
 
 	if (!pageobj)
-		die(fz_throw("cannot retrieve info from page %d", page));
+		die(fz_error_make("cannot retrieve info from page %d", page));
 
 	font = fz_dict_gets(rsrc, "Font");
 	if (font)
@@ -636,7 +636,7 @@ gatherpageinfo(int page)
 	pageref = xref->page_refs[page-1];
 
 	if (!pageobj)
-		die(fz_throw("cannot retrieve info from page %d", page));
+		die(fz_error_make("cannot retrieve info from page %d", page));
 
 	gatherdimensions(page, pageref, pageobj);
 
@@ -983,11 +983,11 @@ int main(int argc, char **argv)
 			printf("%s:\n", filename);
 			error = pdf_open_xref(&xref, filename, password);
 			if (error)
-				die(fz_rethrow(error, "cannot open input file '%s'", filename));
+				die(fz_error_note(error, "cannot open input file '%s'", filename));
 
 			error = pdf_load_page_tree(xref);
 			if (error)
-				die(fz_rethrow(error, "cannot load page tree: %s", filename));
+				die(fz_error_note(error, "cannot load page tree: %s", filename));
 			pagecount = pdf_count_pages(xref);
 
 			showglobalinfo();
diff --git a/apps/pdfshow.c b/apps/pdfshow.c
index 5e74042b..daf31298 100644
--- a/apps/pdfshow.c
+++ b/apps/pdfshow.c
@@ -12,7 +12,7 @@ static int showcolumn;
 
 void die(fz_error error)
 {
-	fz_catch(error, "aborting");
+	fz_error_handle(error, "aborting");
 	if (xref)
 		pdf_free_xref(xref);
 	exit(1);
@@ -30,7 +30,7 @@ static void usage(void)
 static void showtrailer(void)
 {
 	if (!xref)
-		die(fz_throw("no file specified"));
+		die(fz_error_make("no file specified"));
 	printf("trailer\n");
 	fz_debug_obj(xref->trailer);
 	printf("\n");
@@ -39,7 +39,7 @@ static void showtrailer(void)
 static void showxref(void)
 {
 	if (!xref)
-		die(fz_throw("no file specified"));
+		die(fz_error_make("no file specified"));
 	pdf_debug_xref(xref);
 	printf("\n");
 }
@@ -52,13 +52,13 @@ static void showpagetree(void)
 	int i;
 
 	if (!xref)
-		die(fz_throw("no file specified"));
+		die(fz_error_make("no file specified"));
 
 	if (!xref->page_len)
 	{
 		error = pdf_load_page_tree(xref);
 		if (error)
-			die(fz_rethrow(error, "cannot load page tree"));
+			die(fz_error_note(error, "cannot load page tree"));
 	}
 
 	count = pdf_count_pages(xref);
@@ -131,7 +131,7 @@ static void showobject(int num, int gen)
 	fz_obj *obj;
 
 	if (!xref)
-		die(fz_throw("no file specified"));
+		die(fz_error_make("no file specified"));
 
 	error = pdf_load_object(&obj, xref, num, gen);
 	if (error)
@@ -214,7 +214,7 @@ int main(int argc, char **argv)
 	filename = argv[fz_optind++];
 	error = pdf_open_xref(&xref, filename, password);
 	if (error)
-		die(fz_rethrow(error, "cannot open document: %s", filename));
+		die(fz_error_note(error, "cannot open document: %s", filename));
 
 	if (fz_optind == argc)
 		showtrailer();
diff --git a/apps/win_main.c b/apps/win_main.c
index da97b011..92f7f085 100644
--- a/apps/win_main.c
+++ b/apps/win_main.c
@@ -98,7 +98,7 @@ void winerror(pdfapp_t *app, fz_error error)
 	int i;
 
 	/* TODO: redirect stderr to a log file and display here */
-	fz_catch(error, "displaying error message to user");
+	fz_error_handle(error, "displaying error message to user");
 
 	fz_strlcpy(msgbuf, "An error has occurred.\n\n", sizeof msgbuf);
 	for (i = 0; i < fz_get_error_count(); i++)
@@ -122,7 +122,7 @@ void win32error(char *msg)
 		code,
 		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
 		(LPSTR)&buf, 0, NULL);
-	winerror(&gapp, fz_throw("%s:\n%s", msg, buf));
+	winerror(&gapp, fz_error_make("%s:\n%s", msg, buf));
 }
 
 int winfilename(wchar_t *buf, int len)
@@ -617,7 +617,7 @@ void winreloadfile(pdfapp_t *app)
 
 	fd = _wopen(wbuf, O_BINARY | O_RDONLY, 0666);
 	if (fd < 0)
-		winerror(&gapp, fz_throw("cannot reload file '%s'", filename));
+		winerror(&gapp, fz_error_make("cannot reload file '%s'", filename));
 
 	pdfapp_open(app, filename, fd, 1);
 }
@@ -875,7 +875,7 @@ WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShow
 
 	fd = _wopen(wbuf, O_BINARY | O_RDONLY, 0666);
 	if (fd < 0)
-		winerror(&gapp, fz_throw("cannot open file '%s'", filename));
+		winerror(&gapp, fz_error_make("cannot open file '%s'", filename));
 
 	code = WideCharToMultiByte(CP_UTF8, 0, wbuf, -1, filename, sizeof filename, NULL, NULL);
 	if (code == 0)
diff --git a/apps/x11_main.c b/apps/x11_main.c
index c2aef917..d719abda 100644
--- a/apps/x11_main.c
+++ b/apps/x11_main.c
@@ -102,7 +102,7 @@ void winwarn(pdfapp_t *app, char *msg)
 
 void winerror(pdfapp_t *app, fz_error error)
 {
-	fz_catch(error, "aborting");
+	fz_error_handle(error, "aborting");
 	exit(1);
 }
 
@@ -124,7 +124,7 @@ static void winopen(void)
 
 	xdpy = XOpenDisplay(NULL);
 	if (!xdpy)
-		winerror(&gapp, fz_throw("cannot open display"));
+		winerror(&gapp, fz_error_make("cannot open display"));
 
 	XA_TARGETS = XInternAtom(xdpy, "TARGETS", False);
 	XA_TIMESTAMP = XInternAtom(xdpy, "TIMESTAMP", False);
@@ -158,7 +158,7 @@ static void winopen(void)
 		0,
 		NULL);
 	if (xwin == None)
-		winerror(&gapp, fz_throw("cannot create window"));
+		winerror(&gapp, fz_error_make("cannot create window"));
 
 	XSetWindowColormap(xdpy, xwin, ximage_get_colormap());
 	XSelectInput(xdpy, xwin,
@@ -487,7 +487,7 @@ void winreloadfile(pdfapp_t *app)
 
 	fd = open(filename, O_BINARY | O_RDONLY, 0666);
 	if (fd < 0)
-		winerror(app, fz_throw("cannot reload file '%s'", filename));
+		winerror(app, fz_error_make("cannot reload file '%s'", filename));
 
 	pdfapp_open(app, filename, fd, 1);
 }
@@ -593,7 +593,7 @@ int main(int argc, char **argv)
 
 	fd = open(filename, O_BINARY | O_RDONLY, 0666);
 	if (fd < 0)
-		winerror(&gapp, fz_throw("cannot open file '%s'", filename));
+		winerror(&gapp, fz_error_make("cannot open file '%s'", filename));
 
 	pdfapp_open(&gapp, filename, fd, 0);
 
diff --git a/apps/xpsdraw.c b/apps/xpsdraw.c
index 29738e6b..6afe344d 100644
--- a/apps/xpsdraw.c
+++ b/apps/xpsdraw.c
@@ -29,7 +29,7 @@ struct {
 
 static void die(fz_error error)
 {
-	fz_catch(error, "aborting");
+	fz_error_handle(error, "aborting");
 	exit(1);
 }
 
@@ -99,7 +99,7 @@ static void drawpage(xps_context *ctx, int pagenum)
 
 	code = xps_load_page(&page, ctx, pagenum - 1);
 	if (code)
-		die(fz_rethrow(code, "cannot load page %d in file '%s'", pagenum, filename));
+		die(fz_error_note(code, "cannot load page %d in file '%s'", pagenum, filename));
 
 	list = NULL;
 
@@ -336,7 +336,7 @@ int main(int argc, char **argv)
 
 		code = xps_open_file(&ctx, filename);
 		if (code)
-			die(fz_rethrow(code, "cannot open document: %s", filename));
+			die(fz_error_note(code, "cannot open document: %s", filename));
 
 		if (showxml)
 			printf("<document name=\"%s\">\n", filename);
diff --git a/fitz/base_error.c b/fitz/base_error.c
index a0efa290..1610d033 100644
--- a/fitz/base_error.c
+++ b/fitz/base_error.c
@@ -66,7 +66,7 @@ fz_get_error_line(int n)
 }
 
 fz_error
-fz_throw_imp(const char *file, int line, const char *func, char *fmt, ...)
+fz_error_make_imp(const char *file, int line, const char *func, char *fmt, ...)
 {
 	va_list ap;
 	char one[LINE_LEN], two[LINE_LEN];
@@ -84,7 +84,7 @@ fz_throw_imp(const char *file, int line, const char *func, char *fmt, ...)
 }
 
 fz_error
-fz_rethrow_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...)
+fz_error_note_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...)
 {
 	va_list ap;
 	char one[LINE_LEN], two[LINE_LEN];
@@ -100,7 +100,7 @@ fz_rethrow_imp(const char *file, int line, const char *func, fz_error cause, cha
 }
 
 void
-fz_catch_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...)
+fz_error_handle_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...)
 {
 	va_list ap;
 	char one[LINE_LEN], two[LINE_LEN];
@@ -114,7 +114,7 @@ fz_catch_imp(const char *file, int line, const char *func, fz_error cause, char
 }
 
 fz_error
-fz_throw_impx(char *fmt, ...)
+fz_error_make_impx(char *fmt, ...)
 {
 	va_list ap;
 	char buf[LINE_LEN];
@@ -131,7 +131,7 @@ fz_throw_impx(char *fmt, ...)
 }
 
 fz_error
-fz_rethrow_impx(fz_error cause, char *fmt, ...)
+fz_error_note_impx(fz_error cause, char *fmt, ...)
 {
 	va_list ap;
 	char buf[LINE_LEN];
@@ -146,7 +146,7 @@ fz_rethrow_impx(fz_error cause, char *fmt, ...)
 }
 
 void
-fz_catch_impx(fz_error cause, char *fmt, ...)
+fz_error_handle_impx(fz_error cause, char *fmt, ...)
 {
 	va_list ap;
 	char buf[LINE_LEN];
diff --git a/fitz/base_hash.c b/fitz/base_hash.c
index fcfc1f61..b7caf173 100644
--- a/fitz/base_hash.c
+++ b/fitz/base_hash.c
@@ -100,7 +100,7 @@ fz_resize_hash(fz_hash_table *table, int newsize)
 
 	if (newsize < oldload * 8 / 10)
 	{
-		fz_throw("assert: resize hash too small");
+		fz_error_make("assert: resize hash too small");
 		return;
 	}
 
diff --git a/fitz/base_object.c b/fitz/base_object.c
index 5c20767a..4a23e5ab 100644
--- a/fitz/base_object.c
+++ b/fitz/base_object.c
@@ -537,7 +537,7 @@ fz_copy_dict(fz_obj *obj)
 	int i;
 
 	if (fz_is_indirect(obj) || !fz_is_dict(obj))
-		fz_throw("assert: not a dict (%s)", fz_objkindstr(obj));
+		fz_error_make("assert: not a dict (%s)", fz_objkindstr(obj));
 
 	new = fz_new_dict(fz_dict_len(obj));
 	for (i = 0; i < fz_dict_len(obj); i++)
diff --git a/fitz/except.c b/fitz/except.c
new file mode 100644
index 00000000..348b950e
--- /dev/null
+++ b/fitz/except.c
@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+#include "except.h"
+
+static void do_throw(fz_except_context *ex)
+{
+    if(ex->depth >= 0)
+        longjmp(ex->stack[ex->depth].buffer, 1);
+    else {
+        printf("Uncaught exception: %s\n", ex->except.mess);
+        exit(EXIT_FAILURE);           /* Bale through normal channels */
+    }
+}
+
+void fz_throw(fz_context *ctx, char *fmt, ...)
+{
+    va_list args;
+
+    va_start(args, fmt);
+    vsprintf(ctx->except->except.mess, fmt, args);
+    va_end(args);
+    do_throw(ctx->except);
+}
+
+fz_except *fz_caught(fz_context *ctx)
+{
+    return &ctx->except->except;
+}
+
+void fz_rethrow(fz_context *ctx)
+{
+    do_throw(ctx->except);
+}
+
+void fz_except_xxx_push(fz_except_context *ex)
+{
+    if(ex->depth+1 >= MAXDEPTH) {
+        fprintf(stderr, "Exception stack overflow!\n");
+        exit(EXIT_FAILURE);           /* Bale through normal channels */
+    }
+    ex->depth++;
+}
+
+void fz_var_xxx(void *e)
+{
+    /* Do nothing */
+}
diff --git a/fitz/except.h b/fitz/except.h
new file mode 100644
index 00000000..a964b94e
--- /dev/null
+++ b/fitz/except.h
@@ -0,0 +1,46 @@
+#ifndef EXCEPT_H
+#define EXCEPT_H
+
+#include "fitz.h"
+
+typedef struct fz_except {
+  char mess[256];
+} fz_except;
+
+#include "exceptxxx.h"
+/*
+    Macros for fz_try and fz_catch are defined in exceptxxx.h,
+    but their definitions are best ignored.  Just use them as follows:
+
+    fz_var(..);
+    fz_var(..);
+
+    fz_try(ctx)
+    {
+       .
+       .
+       .
+    }
+    fz_catch(ctx)
+    {
+       .
+       .
+       .
+    }
+
+    and don't return from within the try clause.
+*/
+
+void fz_throw(fz_context *, char *, ...);
+
+fz_except *fz_caught(fz_context *);
+
+void fz_rethrow(fz_context *);
+
+#define fz_var(A) fz_var_xxx((void *)&(A))
+
+void fz_var_xxx(void *x);
+
+void fz_except_init(fz_context *);
+
+#endif /* EXCEPT */
diff --git a/fitz/exceptxxx.h b/fitz/exceptxxx.h
new file mode 100644
index 00000000..185f73f6
--- /dev/null
+++ b/fitz/exceptxxx.h
@@ -0,0 +1,36 @@
+#ifndef EXCEPTXXX_H
+#define EXCEPTXXX_H
+
+#include <setjmp.h>
+
+#define fz_try(ctx)                                      \
+if(fz_except_xxx_push(ctx->except),                      \
+   !setjmp(ctx->except.stack[ctx->except.depth].buffer)) \
+{
+
+#define fz_catch(ctx)                               \
+    ctx->except.stack[ctx->except.depth].failed = 0;\
+}\
+else\
+{\
+    ctx->except.stack[ctx->except.depth].failed = 1;\
+}\
+if(ex->stack[ex->depth--].failed)
+
+typedef struct fz_except_xxx_stack
+{
+    int failed;
+    jmp_buf buffer;
+} fz_except_xxx_stack;
+
+#define MAXDEPTH (20)
+
+struct fz_except_context {
+    fz_except_xxx_stack stack[MAXDEPTH];
+    int depth;
+    fz_except except;
+};
+
+void fz_except_xxx_push(fz_except_context *);
+
+#endif /* EXCEPTXXX */
diff --git a/fitz/filt_basic.c b/fitz/filt_basic.c
index feb13076..15c42137 100644
--- a/fitz/filt_basic.c
+++ b/fitz/filt_basic.c
@@ -23,7 +23,7 @@ read_null(fz_stream *stm, unsigned char *buf, int len)
 	int amount = MIN(len, state->remain);
 	int n = fz_read(state->chain, buf, amount);
 	if (n < 0)
-		return fz_rethrow(n, "read error in null filter");
+		return fz_error_note(n, "read error in null filter");
 	state->remain -= n;
 	return n;
 }
@@ -124,7 +124,7 @@ read_ahxd(fz_stream *stm, unsigned char *buf, int len)
 		}
 		else if (!iswhite(c))
 		{
-			return fz_throw("bad data in ahxd: '%c'", c);
+			return fz_error_make("bad data in ahxd: '%c'", c);
 		}
 	}
 
@@ -228,7 +228,7 @@ read_a85d(fz_stream *stm, unsigned char *buf, int len)
 			case 0:
 				break;
 			case 1:
-				return fz_throw("partial final byte in a85d");
+				return fz_error_make("partial final byte in a85d");
 			case 2:
 				word = word * (85 * 85 * 85) + 0xffffff;
 				state->bp[0] = word >> 24;
@@ -256,7 +256,7 @@ read_a85d(fz_stream *stm, unsigned char *buf, int len)
 
 		else if (!iswhite(c))
 		{
-			return fz_throw("bad data in a85d: '%c'", c);
+			return fz_error_make("bad data in a85d: '%c'", c);
 		}
 
 		while (state->rp < state->wp && p < ep)
@@ -322,7 +322,7 @@ read_rld(fz_stream *stm, unsigned char *buf, int len)
 				state->n = 257 - state->run;
 				state->c = fz_read_byte(state->chain);
 				if (state->c < 0)
-					return fz_throw("premature end of data in run length decode");
+					return fz_error_make("premature end of data in run length decode");
 			}
 		}
 
@@ -332,7 +332,7 @@ read_rld(fz_stream *stm, unsigned char *buf, int len)
 			{
 				int c = fz_read_byte(state->chain);
 				if (c < 0)
-					return fz_throw("premature end of data in run length decode");
+					return fz_error_make("premature end of data in run length decode");
 				*p++ = c;
 				state->n--;
 			}
@@ -391,7 +391,7 @@ read_arc4(fz_stream *stm, unsigned char *buf, int len)
 
 	n = fz_read(state->chain, buf, len);
 	if (n < 0)
-		return fz_rethrow(n, "read error in arc4 filter");
+		return fz_error_note(n, "read error in arc4 filter");
 
 	fz_arc4_encrypt(&state->arc4, buf, buf, n);
 
@@ -443,7 +443,7 @@ read_aesd(fz_stream *stm, unsigned char *buf, int len)
 	{
 		int c = fz_read_byte(state->chain);
 		if (c < 0)
-			return fz_throw("premature end in aes filter");
+			return fz_error_make("premature end in aes filter");
 		state->iv[state->ivcount++] = c;
 	}
 
@@ -454,11 +454,11 @@ read_aesd(fz_stream *stm, unsigned char *buf, int len)
 	{
 		int n = fz_read(state->chain, state->bp, 16);
 		if (n < 0)
-			return fz_rethrow(n, "read error in aes filter");
+			return fz_error_note(n, "read error in aes filter");
 		else if (n == 0)
 			return p - buf;
 		else if (n < 16)
-			return fz_throw("partial block in aes filter");
+			return fz_error_make("partial block in aes filter");
 
 		aes_crypt_cbc(&state->aes, AES_DECRYPT, 16, state->iv, state->bp, state->bp);
 		state->rp = state->bp;
@@ -469,7 +469,7 @@ read_aesd(fz_stream *stm, unsigned char *buf, int len)
 		{
 			int pad = state->bp[15];
 			if (pad < 1 || pad > 16)
-				return fz_throw("aes padding out of range: %d", pad);
+				return fz_error_make("aes padding out of range: %d", pad);
 			state->wp -= pad;
 		}
 
diff --git a/fitz/filt_dctd.c b/fitz/filt_dctd.c
index 0e24b794..372efe9e 100644
--- a/fitz/filt_dctd.c
+++ b/fitz/filt_dctd.c
@@ -86,7 +86,7 @@ read_dctd(fz_stream *stm, unsigned char *buf, int len)
 	{
 		if (cinfo->src)
 			state->chain->rp = state->chain->wp - cinfo->src->bytes_in_buffer;
-		return fz_throw("jpeg error: %s", state->msg);
+		return fz_error_make("jpeg error: %s", state->msg);
 	}
 
 	if (!state->init)
diff --git a/fitz/filt_faxd.c b/fitz/filt_faxd.c
index dcf56cf3..d36c8c76 100644
--- a/fitz/filt_faxd.c
+++ b/fitz/filt_faxd.c
@@ -345,13 +345,13 @@ dec1d(fz_faxd *fax)
 		code = get_code(fax, cf_white_decode, cfd_white_initial_bits);
 
 	if (code == UNCOMPRESSED)
-		return fz_throw("uncompressed data in faxd");
+		return fz_error_make("uncompressed data in faxd");
 
 	if (code < 0)
-		return fz_throw("negative code in 1d faxd");
+		return fz_error_make("negative code in 1d faxd");
 
 	if (fax->a + code > fax->columns)
-		return fz_throw("overflow in 1d faxd");
+		return fz_error_make("overflow in 1d faxd");
 
 	if (fax->c)
 		setbits(fax->dst, fax->a, fax->a + code);
@@ -386,13 +386,13 @@ dec2d(fz_faxd *fax)
 			code = get_code(fax, cf_white_decode, cfd_white_initial_bits);
 
 		if (code == UNCOMPRESSED)
-			return fz_throw("uncompressed data in faxd");
+			return fz_error_make("uncompressed data in faxd");
 
 		if (code < 0)
-			return fz_throw("negative code in 2d faxd");
+			return fz_error_make("negative code in 2d faxd");
 
 		if (fax->a + code > fax->columns)
-			return fz_throw("overflow in 2d faxd");
+			return fz_error_make("overflow in 2d faxd");
 
 		if (fax->c)
 			setbits(fax->dst, fax->a, fax->a + code);
@@ -485,13 +485,13 @@ dec2d(fz_faxd *fax)
 		break;
 
 	case UNCOMPRESSED:
-		return fz_throw("uncompressed data in faxd");
+		return fz_error_make("uncompressed data in faxd");
 
 	case ERROR:
-		return fz_throw("invalid code in 2d faxd");
+		return fz_error_make("invalid code in 2d faxd");
 
 	default:
-		return fz_throw("invalid code in 2d faxd (%d)", code);
+		return fz_error_make("invalid code in 2d faxd (%d)", code);
 	}
 
 	return 0;
@@ -560,14 +560,14 @@ loop:
 		fax->eolc = 0;
 		error = dec1d(fax);
 		if (error)
-			return fz_rethrow(error, "cannot decode 1d code");
+			return fz_error_note(error, "cannot decode 1d code");
 	}
 	else if (fax->dim == 2)
 	{
 		fax->eolc = 0;
 		error = dec2d(fax);
 		if (error)
-			return fz_rethrow(error, "cannot decode 2d code");
+			return fz_error_note(error, "cannot decode 2d code");
 	}
 
 	/* no eol check after makeup codes nor in the middle of an H code */
diff --git a/fitz/filt_flate.c b/fitz/filt_flate.c
index e7d4c9f7..4d4caf37 100644
--- a/fitz/filt_flate.c
+++ b/fitz/filt_flate.c
@@ -59,7 +59,7 @@ read_flated(fz_stream *stm, unsigned char *outbuf, int outlen)
 		}
 		else if (code != Z_OK)
 		{
-			return fz_throw("zlib error: %s", zp->msg);
+			return fz_error_make("zlib error: %s", zp->msg);
 		}
 	}
 
diff --git a/fitz/filt_jbig2d.c b/fitz/filt_jbig2d.c
index 4dbe542c..ad335045 100644
--- a/fitz/filt_jbig2d.c
+++ b/fitz/filt_jbig2d.c
@@ -57,7 +57,7 @@ read_jbig2d(fz_stream *stm, unsigned char *buf, int len)
 		{
 			n = fz_read(state->chain, tmp, sizeof tmp);
 			if (n < 0)
-				return fz_rethrow(n, "read error in jbig2 filter");
+				return fz_error_note(n, "read error in jbig2 filter");
 			if (n == 0)
 				break;
 			jbig2_data_in(state->ctx, tmp, n);
@@ -67,7 +67,7 @@ read_jbig2d(fz_stream *stm, unsigned char *buf, int len)
 
 		state->page = jbig2_page_out(state->ctx);
 		if (!state->page)
-			return fz_throw("jbig2_page_out failed");
+			return fz_error_make("jbig2_page_out failed");
 	}
 
 	s = state->page->data;
diff --git a/fitz/filt_jpxd.c b/fitz/filt_jpxd.c
index 765aad29..d646cabc 100644
--- a/fitz/filt_jpxd.c
+++ b/fitz/filt_jpxd.c
@@ -34,7 +34,7 @@ fz_load_jpx_image(fz_pixmap **imgp, unsigned char *data, int size, fz_colorspace
 	int x, y, k, v;
 
 	if (size < 2)
-		return fz_throw("not enough data to determine image format");
+		return fz_error_make("not enough data to determine image format");
 
 	/* Check for SOC marker -- if found we have a bare J2K stream */
 	if (data[0] == 0xFF && data[1] == 0x4F)
@@ -61,16 +61,16 @@ fz_load_jpx_image(fz_pixmap **imgp, unsigned char *data, int size, fz_colorspace
 	opj_destroy_decompress(info);
 
 	if (!jpx)
-		return fz_throw("opj_decode failed");
+		return fz_error_make("opj_decode failed");
 
 	for (k = 1; k < jpx->numcomps; k++)
 	{
 		if (jpx->comps[k].w != jpx->comps[0].w)
-			return fz_throw("image components have different width");
+			return fz_error_make("image components have different width");
 		if (jpx->comps[k].h != jpx->comps[0].h)
-			return fz_throw("image components have different height");
+			return fz_error_make("image components have different height");
 		if (jpx->comps[k].prec != jpx->comps[0].prec)
-			return fz_throw("image components have different precision");
+			return fz_error_make("image components have different precision");
 	}
 
 	n = jpx->numcomps;
@@ -112,7 +112,7 @@ fz_load_jpx_image(fz_pixmap **imgp, unsigned char *data, int size, fz_colorspace
 	if (!img)
 	{
 		opj_image_destroy(jpx);
-		return fz_throw("out of memory");
+		return fz_error_make("out of memory");
 	}
 
 	p = img->samples;
diff --git a/fitz/filt_predict.c b/fitz/filt_predict.c
index 94f2718a..17cfe905 100644
--- a/fitz/filt_predict.c
+++ b/fitz/filt_predict.c
@@ -154,7 +154,7 @@ read_predict(fz_stream *stm, unsigned char *buf, int len)
 	{
 		n = fz_read(state->chain, state->in, state->stride + ispng);
 		if (n < 0)
-			return fz_rethrow(n, "read error in prediction filter");
+			return fz_error_note(n, "read error in prediction filter");
 		if (n == 0)
 			return p - buf;
 
diff --git a/fitz/fitz.h b/fitz/fitz.h
index 30b037e8..afc92436 100644
--- a/fitz/fitz.h
+++ b/fitz/fitz.h
@@ -68,33 +68,33 @@ int gettimeofday(struct timeval *tv, struct timezone *tz);
 
 #if __STDC_VERSION__ == 199901L /* C99 */
 
-#define fz_throw(...) fz_throw_imp(__FILE__, __LINE__, __func__, __VA_ARGS__)
-#define fz_rethrow(cause, ...) fz_rethrow_imp(__FILE__, __LINE__, __func__, cause, __VA_ARGS__)
+#define fz_error_make(...) fz_error_make_imp(__FILE__, __LINE__, __func__, __VA_ARGS__)
+#define fz_error_note(cause, ...) fz_error_note_imp(__FILE__, __LINE__, __func__, cause, __VA_ARGS__)
 #define fz_catch(cause, ...) fz_catch_imp(__FILE__, __LINE__, __func__, cause, __VA_ARGS__)
 
 #elif _MSC_VER >= 1500 /* MSVC 9 or newer */
 
 #define inline __inline
 #define restrict __restrict
-#define fz_throw(...) fz_throw_imp(__FILE__, __LINE__, __FUNCTION__, __VA_ARGS__)
-#define fz_rethrow(cause, ...) fz_rethrow_imp(__FILE__, __LINE__, __FUNCTION__, cause, __VA_ARGS__)
-#define fz_catch(cause, ...) fz_catch_imp(__FILE__, __LINE__, __FUNCTION__, cause, __VA_ARGS__)
+#define fz_error_make(...) fz_error_make_imp(__FILE__, __LINE__, __FUNCTION__, __VA_ARGS__)
+#define fz_error_note(cause, ...) fz_error_note_imp(__FILE__, __LINE__, __FUNCTION__, cause, __VA_ARGS__)
+#define fz_catch(cause, ...) fz_error_handle_imp(__FILE__, __LINE__, __FUNCTION__, cause, __VA_ARGS__)
 
 #elif __GNUC__ >= 3 /* GCC 3 or newer */
 
 #define inline __inline
 #define restrict __restrict
-#define fz_throw(fmt...) fz_throw_imp(__FILE__, __LINE__, __FUNCTION__, fmt)
-#define fz_rethrow(cause, fmt...) fz_rethrow_imp(__FILE__, __LINE__, __FUNCTION__, cause, fmt)
-#define fz_catch(cause, fmt...) fz_catch_imp(__FILE__, __LINE__, __FUNCTION__, cause, fmt)
+#define fz_error_make(fmt...) fz_error_make_imp(__FILE__, __LINE__, __FUNCTION__, fmt)
+#define fz_error_note(cause, fmt...) fz_error_note_imp(__FILE__, __LINE__, __FUNCTION__, cause, fmt)
+#define fz_error_handle(cause, fmt...) fz_error_handle_imp(__FILE__, __LINE__, __FUNCTION__, cause, fmt)
 
 #else /* Unknown or ancient */
 
 #define inline
 #define restrict
-#define fz_throw fz_throw_impx
-#define fz_rethrow fz_rethrow_impx
-#define fz_catch fz_catch_impx
+#define fz_error_make fz_error_make_impx
+#define fz_error_note fz_error_note_impx
+#define fz_error_handle fz_catch_impx
 
 #endif
 
@@ -122,13 +122,13 @@ typedef int fz_error;
 void fz_warn(char *fmt, ...) __printflike(1, 2);
 void fz_flush_warnings(void);
 
-fz_error fz_throw_imp(const char *file, int line, const char *func, char *fmt, ...) __printflike(4, 5);
-fz_error fz_rethrow_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...) __printflike(5, 6);
-void fz_catch_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...) __printflike(5, 6);
+fz_error fz_error_make_imp(const char *file, int line, const char *func, char *fmt, ...) __printflike(4, 5);
+fz_error fz_error_note_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...) __printflike(5, 6);
+void fz_error_handle_imp(const char *file, int line, const char *func, fz_error cause, char *fmt, ...) __printflike(5, 6);
 
-fz_error fz_throw_impx(char *fmt, ...) __printflike(1, 2);
-fz_error fz_rethrow_impx(fz_error cause, char *fmt, ...) __printflike(2, 3);
-void fz_catch_impx(fz_error cause, char *fmt, ...) __printflike(2, 3);
+fz_error fz_error_make_impx(char *fmt, ...) __printflike(1, 2);
+fz_error fz_error_note_impx(fz_error cause, char *fmt, ...) __printflike(2, 3);
+void fz_error_handle_impx(fz_error cause, char *fmt, ...) __printflike(2, 3);
 
 /* extract the last error stack trace */
 int fz_get_error_count(void);
@@ -1119,4 +1119,17 @@ enum
 	FZ_BLEND_KNOCKOUT = 32
 };
 
+/* Fitz context */
+
+typedef struct fz_except_context fz_except_context;
+typedef struct fz_alloc_context fz_alloc_context;
+
+typedef struct fz_context
+{
+    fz_except_context *except;
+    fz_alloc_context *alloc;
+}
+fz_context;
+
+
 #endif
diff --git a/fitz/res_bitmap.c b/fitz/res_bitmap.c
index 0b852af2..a50d0952 100644
--- a/fitz/res_bitmap.c
+++ b/fitz/res_bitmap.c
@@ -55,7 +55,7 @@ fz_write_pbm(fz_bitmap *bitmap, char *filename)
 
 	fp = fopen(filename, "wb");
 	if (!fp)
-		return fz_throw("cannot open file '%s': %s", filename, strerror(errno));
+		return fz_error_make("cannot open file '%s': %s", filename, strerror(errno));
 
 	assert(bitmap->n == 1);
 
diff --git a/fitz/res_font.c b/fitz/res_font.c
index ffee1d46..c78b5995 100644
--- a/fitz/res_font.c
+++ b/fitz/res_font.c
@@ -150,7 +150,7 @@ fz_init_freetype(void)
 
 	fterr = FT_Init_FreeType(&fz_ftlib);
 	if (fterr)
-		return fz_throw("cannot init freetype: %s", ft_error_string(fterr));
+		return fz_error_make("cannot init freetype: %s", ft_error_string(fterr));
 
 	FT_Library_Version(fz_ftlib, &maj, &min, &pat);
 	if (maj == 2 && min == 1 && pat < 7)
@@ -158,7 +158,7 @@ fz_init_freetype(void)
 		fterr = FT_Done_FreeType(fz_ftlib);
 		if (fterr)
 			fz_warn("freetype finalizing: %s", ft_error_string(fterr));
-		return fz_throw("freetype version too old: %d.%d.%d", maj, min, pat);
+		return fz_error_make("freetype version too old: %d.%d.%d", maj, min, pat);
 	}
 
 	fz_ftlib_refs++;
@@ -189,11 +189,11 @@ fz_new_font_from_file(fz_font **fontp, char *path, int index)
 
 	error = fz_init_freetype();
 	if (error)
-		return fz_rethrow(error, "cannot init freetype library");
+		return fz_error_note(error, "cannot init freetype library");
 
 	fterr = FT_New_Face(fz_ftlib, path, index, &face);
 	if (fterr)
-		return fz_throw("freetype: cannot load font: %s", ft_error_string(fterr));
+		return fz_error_make("freetype: cannot load font: %s", ft_error_string(fterr));
 
 	font = fz_new_font(face->family_name);
 	font->ft_face = face;
@@ -216,11 +216,11 @@ fz_new_font_from_memory(fz_font **fontp, unsigned char *data, int len, int index
 
 	error = fz_init_freetype();
 	if (error)
-		return fz_rethrow(error, "cannot init freetype library");
+		return fz_error_note(error, "cannot init freetype library");
 
 	fterr = FT_New_Memory_Face(fz_ftlib, data, len, index, &face);
 	if (fterr)
-		return fz_throw("freetype: cannot load font: %s", ft_error_string(fterr));
+		return fz_error_make("freetype: cannot load font: %s", ft_error_string(fterr));
 
 	font = fz_new_font(face->family_name);
 	font->ft_face = face;
@@ -534,7 +534,7 @@ fz_render_t3_glyph(fz_font *font, int gid, fz_matrix trm, fz_colorspace *model)
 	dev = fz_new_bbox_device(&bbox);
 	error = font->t3run(font->t3xref, font->t3resources, contents, dev, ctm);
 	if (error)
-		fz_catch(error, "cannot draw type3 glyph");
+		fz_error_handle(error, "cannot draw type3 glyph");
 
 	if (dev->flags & FZ_CHARPROC_MASK)
 	{
@@ -567,7 +567,7 @@ fz_render_t3_glyph(fz_font *font, int gid, fz_matrix trm, fz_colorspace *model)
 	dev = fz_new_draw_device_type3(cache, glyph);
 	error = font->t3run(font->t3xref, font->t3resources, contents, dev, ctm);
 	if (error)
-		fz_catch(error, "cannot draw type3 glyph");
+		fz_error_handle(error, "cannot draw type3 glyph");
 	fz_free_device(dev);
 	fz_free_glyph_cache(cache);
 
diff --git a/fitz/res_pixmap.c b/fitz/res_pixmap.c
index 83f46526..dccc62e3 100644
--- a/fitz/res_pixmap.c
+++ b/fitz/res_pixmap.c
@@ -301,11 +301,11 @@ fz_write_pnm(fz_pixmap *pixmap, char *filename)
 	int len;
 
 	if (pixmap->n != 1 && pixmap->n != 2 && pixmap->n != 4)
-		return fz_throw("pixmap must be grayscale or rgb to write as pnm");
+		return fz_error_make("pixmap must be grayscale or rgb to write as pnm");
 
 	fp = fopen(filename, "wb");
 	if (!fp)
-		return fz_throw("cannot open file '%s': %s", filename, strerror(errno));
+		return fz_error_make("cannot open file '%s': %s", filename, strerror(errno));
 
 	if (pixmap->n == 1 || pixmap->n == 2)
 		fprintf(fp, "P5\n");
@@ -361,7 +361,7 @@ fz_write_pam(fz_pixmap *pixmap, char *filename, int savealpha)
 
 	fp = fopen(filename, "wb");
 	if (!fp)
-		return fz_throw("cannot open file '%s': %s", filename, strerror(errno));
+		return fz_error_make("cannot open file '%s': %s", filename, strerror(errno));
 
 	fprintf(fp, "P7\n");
 	fprintf(fp, "WIDTH %d\n", pixmap->w);
@@ -443,7 +443,7 @@ fz_write_png(fz_pixmap *pixmap, char *filename, int savealpha)
 	int err;
 
 	if (pixmap->n != 1 && pixmap->n != 2 && pixmap->n != 4)
-		return fz_throw("pixmap must be grayscale or rgb to write as png");
+		return fz_error_make("pixmap must be grayscale or rgb to write as png");
 
 	sn = pixmap->n;
 	dn = pixmap->n;
@@ -488,7 +488,7 @@ fz_write_png(fz_pixmap *pixmap, char *filename, int savealpha)
 	{
 		fz_free(udata);
 		fz_free(cdata);
-		return fz_throw("cannot compress image data");
+		return fz_error_make("cannot compress image data");
 	}
 
 	fp = fopen(filename, "wb");
@@ -496,7 +496,7 @@ fz_write_png(fz_pixmap *pixmap, char *filename, int savealpha)
 	{
 		fz_free(udata);
 		fz_free(cdata);
-		return fz_throw("cannot open file '%s': %s", filename, strerror(errno));
+		return fz_error_make("cannot open file '%s': %s", filename, strerror(errno));
 	}
 
 	big32(head+0, pixmap->w);
diff --git a/fitz/stm_open.c b/fitz/stm_open.c
index 74346f73..81eb819e 100644
--- a/fitz/stm_open.c
+++ b/fitz/stm_open.c
@@ -55,7 +55,7 @@ static int read_file(fz_stream *stm, unsigned char *buf, int len)
 {
 	int n = read(*(int*)stm->state, buf, len);
 	if (n < 0)
-		return fz_throw("read error: %s", strerror(errno));
+		return fz_error_make("read error: %s", strerror(errno));
 	return n;
 }
 
diff --git a/fitz/stm_read.c b/fitz/stm_read.c
index 59f06433..89811333 100644
--- a/fitz/stm_read.c
+++ b/fitz/stm_read.c
@@ -23,7 +23,7 @@ fz_read(fz_stream *stm, unsigned char *buf, int len)
 		if (n < 0)
 		{
 			stm->error = 1;
-			return fz_rethrow(n, "read error");
+			return fz_error_note(n, "read error");
 		}
 		else if (n == 0)
 		{
@@ -50,7 +50,7 @@ fz_read(fz_stream *stm, unsigned char *buf, int len)
 		if (n < 0)
 		{
 			stm->error = 1;
-			return fz_rethrow(n, "read error");
+			return fz_error_note(n, "read error");
 		}
 		else if (n == 0)
 		{
@@ -80,7 +80,7 @@ fz_fill_buffer(fz_stream *stm)
 	if (n < 0)
 	{
 		stm->error = 1;
-		fz_catch(n, "read error; treating as end of file");
+		fz_error_handle(n, "read error; treating as end of file");
 	}
 	else if (n == 0)
 	{
@@ -113,14 +113,14 @@ fz_read_all(fz_buffer **bufp, fz_stream *stm, int initial)
 		if (buf->len / 200 > initial)
 		{
 			fz_drop_buffer(buf);
-			return fz_throw("compression bomb detected");
+			return fz_error_make("compression bomb detected");
 		}
 
 		n = fz_read(stm, buf->data + buf->len, buf->cap - buf->len);
 		if (n < 0)
 		{
 			fz_drop_buffer(buf);
-			return fz_rethrow(n, "read error");
+			return fz_error_note(n, "read error");
 		}
 		if (n == 0)
 			break;
diff --git a/pdf/pdf_annot.c b/pdf/pdf_annot.c
index 2fc9d7bb..8401d79b 100644
--- a/pdf/pdf_annot.c
+++ b/pdf/pdf_annot.c
@@ -204,7 +204,7 @@ pdf_load_annots(pdf_annot **annotp, pdf_xref *xref, fz_obj *annots)
 				error = pdf_load_xobject(&form, xref, n);
 				if (error)
 				{
-					fz_catch(error, "ignoring broken annotation");
+					fz_error_handle(error, "ignoring broken annotation");
 					continue;
 				}
 
diff --git a/pdf/pdf_cmap_load.c b/pdf/pdf_cmap_load.c
index 12adeb40..7acc60d3 100644
--- a/pdf/pdf_cmap_load.c
+++ b/pdf/pdf_cmap_load.c
@@ -23,14 +23,14 @@ pdf_load_embedded_cmap(pdf_cmap **cmapp, pdf_xref *xref, fz_obj *stmobj)
 	error = pdf_open_stream(&file, xref, fz_to_num(stmobj), fz_to_gen(stmobj));
 	if (error)
 	{
-		error = fz_rethrow(error, "cannot open cmap stream (%d %d R)", fz_to_num(stmobj), fz_to_gen(stmobj));
+		error = fz_error_note(error, "cannot open cmap stream (%d %d R)", fz_to_num(stmobj), fz_to_gen(stmobj));
 		goto cleanup;
 	}
 
 	error = pdf_parse_cmap(&cmap, file);
 	if (error)
 	{
-		error = fz_rethrow(error, "cannot parse cmap stream (%d %d R)", fz_to_num(stmobj), fz_to_gen(stmobj));
+		error = fz_error_note(error, "cannot parse cmap stream (%d %d R)", fz_to_num(stmobj), fz_to_gen(stmobj));
 		goto cleanup;
 	}
 
@@ -46,7 +46,7 @@ pdf_load_embedded_cmap(pdf_cmap **cmapp, pdf_xref *xref, fz_obj *stmobj)
 		error = pdf_load_system_cmap(&usecmap, fz_to_name(obj));
 		if (error)
 		{
-			error = fz_rethrow(error, "cannot load system usecmap '%s'", fz_to_name(obj));
+			error = fz_error_note(error, "cannot load system usecmap '%s'", fz_to_name(obj));
 			goto cleanup;
 		}
 		pdf_set_usecmap(cmap, usecmap);
@@ -57,7 +57,7 @@ pdf_load_embedded_cmap(pdf_cmap **cmapp, pdf_xref *xref, fz_obj *stmobj)
 		error = pdf_load_embedded_cmap(&usecmap, xref, obj);
 		if (error)
 		{
-			error = fz_rethrow(error, "cannot load embedded usecmap (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+			error = fz_error_note(error, "cannot load embedded usecmap (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
 			goto cleanup;
 		}
 		pdf_set_usecmap(cmap, usecmap);
@@ -103,13 +103,13 @@ pdf_load_system_cmap(pdf_cmap **cmapp, char *cmap_name)
 
 	cmap = pdf_find_builtin_cmap(cmap_name);
 	if (!cmap)
-		return fz_throw("no builtin cmap file: %s", cmap_name);
+		return fz_error_make("no builtin cmap file: %s", cmap_name);
 
 	if (cmap->usecmap_name[0] && !cmap->usecmap)
 	{
 		usecmap = pdf_find_builtin_cmap(cmap->usecmap_name);
 		if (!usecmap)
-			return fz_throw("nu builtin cmap file: %s", cmap->usecmap_name);
+			return fz_error_make("nu builtin cmap file: %s", cmap->usecmap_name);
 		pdf_set_usecmap(cmap, usecmap);
 	}
 
diff --git a/pdf/pdf_cmap_parse.c b/pdf/pdf_cmap_parse.c
index edd97de8..06421fbb 100644
--- a/pdf/pdf_cmap_parse.c
+++ b/pdf/pdf_cmap_parse.c
@@ -55,7 +55,7 @@ pdf_lex_cmap(int *tok, fz_stream *file, char *buf, int n, int *sl)
 
 	error = pdf_lex(tok, file, buf, n, sl);
 	if (error)
-		return fz_rethrow(error, "cannot parse cmap token");
+		return fz_error_note(error, "cannot parse cmap token");
 
 	if (*tok == PDF_TOK_KEYWORD)
 		*tok = pdf_cmap_token_from_keyword(buf);
@@ -73,7 +73,7 @@ pdf_parse_cmap_name(pdf_cmap *cmap, fz_stream *file)
 
 	error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 	if (error)
-		return fz_rethrow(error, "syntaxerror in cmap");
+		return fz_error_note(error, "syntaxerror in cmap");
 
 	if (tok == PDF_TOK_NAME)
 		fz_strlcpy(cmap->cmap_name, buf, sizeof(cmap->cmap_name));
@@ -93,7 +93,7 @@ pdf_parse_wmode(pdf_cmap *cmap, fz_stream *file)
 
 	error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 	if (error)
-		return fz_rethrow(error, "syntaxerror in cmap");
+		return fz_error_note(error, "syntaxerror in cmap");
 
 	if (tok == PDF_TOK_INT)
 		pdf_set_wmode(cmap, atoi(buf));
@@ -116,7 +116,7 @@ pdf_parse_codespace_range(pdf_cmap *cmap, fz_stream *file)
 	{
 		error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
+			return fz_error_note(error, "syntaxerror in cmap");
 
 		if (tok == TOK_END_CODESPACE_RANGE)
 			return fz_okay;
@@ -126,7 +126,7 @@ pdf_parse_codespace_range(pdf_cmap *cmap, fz_stream *file)
 			lo = pdf_code_from_string(buf, len);
 			error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 			if (error)
-				return fz_rethrow(error, "syntaxerror in cmap");
+				return fz_error_note(error, "syntaxerror in cmap");
 			if (tok == PDF_TOK_STRING)
 			{
 				hi = pdf_code_from_string(buf, len);
@@ -138,7 +138,7 @@ pdf_parse_codespace_range(pdf_cmap *cmap, fz_stream *file)
 		else break;
 	}
 
-	return fz_throw("expected string or endcodespacerange");
+	return fz_error_make("expected string or endcodespacerange");
 }
 
 static fz_error
@@ -154,29 +154,29 @@ pdf_parse_cid_range(pdf_cmap *cmap, fz_stream *file)
 	{
 		error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
+			return fz_error_note(error, "syntaxerror in cmap");
 
 		if (tok == TOK_END_CID_RANGE)
 			return fz_okay;
 
 		else if (tok != PDF_TOK_STRING)
-			return fz_throw("expected string or endcidrange");
+			return fz_error_make("expected string or endcidrange");
 
 		lo = pdf_code_from_string(buf, len);
 
 		error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
+			return fz_error_note(error, "syntaxerror in cmap");
 		if (tok != PDF_TOK_STRING)
-			return fz_throw("expected string");
+			return fz_error_make("expected string");
 
 		hi = pdf_code_from_string(buf, len);
 
 		error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
+			return fz_error_note(error, "syntaxerror in cmap");
 		if (tok != PDF_TOK_INT)
-			return fz_throw("expected integer");
+			return fz_error_make("expected integer");
 
 		dst = atoi(buf);
 
@@ -197,21 +197,21 @@ pdf_parse_cid_char(pdf_cmap *cmap, fz_stream *file)
 	{
 		error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
+			return fz_error_note(error, "syntaxerror in cmap");
 
 		if (tok == TOK_END_CID_CHAR)
 			return fz_okay;
 
 		else if (tok != PDF_TOK_STRING)
-			return fz_throw("expected string or endcidchar");
+			return fz_error_make("expected string or endcidchar");
 
 		src = pdf_code_from_string(buf, len);
 
 		error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
+			return fz_error_note(error, "syntaxerror in cmap");
 		if (tok != PDF_TOK_INT)
-			return fz_throw("expected integer");
+			return fz_error_make("expected integer");
 
 		dst = atoi(buf);
 
@@ -233,14 +233,14 @@ pdf_parse_bf_range_array(pdf_cmap *cmap, fz_stream *file, int lo, int hi)
 	{
 		error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
+			return fz_error_note(error, "syntaxerror in cmap");
 
 		if (tok == PDF_TOK_CLOSE_ARRAY)
 			return fz_okay;
 
 		/* Note: does not handle [ /Name /Name ... ] */
 		else if (tok != PDF_TOK_STRING)
-			return fz_throw("expected string or ]");
+			return fz_error_make("expected string or ]");
 
 		if (len / 2)
 		{
@@ -267,27 +267,27 @@ pdf_parse_bf_range(pdf_cmap *cmap, fz_stream *file)
 	{
 		error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
+			return fz_error_note(error, "syntaxerror in cmap");
 
 		if (tok == TOK_END_BF_RANGE)
 			return fz_okay;
 
 		else if (tok != PDF_TOK_STRING)
-			return fz_throw("expected string or endbfrange");
+			return fz_error_make("expected string or endbfrange");
 
 		lo = pdf_code_from_string(buf, len);
 
 		error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
+			return fz_error_note(error, "syntaxerror in cmap");
 		if (tok != PDF_TOK_STRING)
-			return fz_throw("expected string");
+			return fz_error_make("expected string");
 
 		hi = pdf_code_from_string(buf, len);
 
 		error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
+			return fz_error_note(error, "syntaxerror in cmap");
 
 		if (tok == PDF_TOK_STRING)
 		{
@@ -320,12 +320,12 @@ pdf_parse_bf_range(pdf_cmap *cmap, fz_stream *file)
 		{
 			error = pdf_parse_bf_range_array(cmap, file, lo, hi);
 			if (error)
-				return fz_rethrow(error, "cannot map bfrange");
+				return fz_error_note(error, "cannot map bfrange");
 		}
 
 		else
 		{
-			return fz_throw("expected string or array or endbfrange");
+			return fz_error_make("expected string or array or endbfrange");
 		}
 	}
 }
@@ -345,22 +345,22 @@ pdf_parse_bf_char(pdf_cmap *cmap, fz_stream *file)
 	{
 		error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
+			return fz_error_note(error, "syntaxerror in cmap");
 
 		if (tok == TOK_END_BF_CHAR)
 			return fz_okay;
 
 		else if (tok != PDF_TOK_STRING)
-			return fz_throw("expected string or endbfchar");
+			return fz_error_make("expected string or endbfchar");
 
 		src = pdf_code_from_string(buf, len);
 
 		error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 		if (error)
-			return fz_rethrow(error, "syntaxerror in cmap");
+			return fz_error_note(error, "syntaxerror in cmap");
 		/* Note: does not handle /dstName */
 		if (tok != PDF_TOK_STRING)
-			return fz_throw("expected string");
+			return fz_error_make("expected string");
 
 		if (len / 2)
 		{
@@ -390,7 +390,7 @@ pdf_parse_cmap(pdf_cmap **cmapp, fz_stream *file)
 		error = pdf_lex_cmap(&tok, file, buf, sizeof buf, &len);
 		if (error)
 		{
-			error = fz_rethrow(error, "syntaxerror in cmap");
+			error = fz_error_note(error, "syntaxerror in cmap");
 			goto cleanup;
 		}
 
@@ -404,7 +404,7 @@ pdf_parse_cmap(pdf_cmap **cmapp, fz_stream *file)
 				error = pdf_parse_cmap_name(cmap, file);
 				if (error)
 				{
-					error = fz_rethrow(error, "syntaxerror in cmap after CMapName");
+					error = fz_error_note(error, "syntaxerror in cmap after CMapName");
 					goto cleanup;
 				}
 			}
@@ -413,7 +413,7 @@ pdf_parse_cmap(pdf_cmap **cmapp, fz_stream *file)
 				error = pdf_parse_wmode(cmap, file);
 				if (error)
 				{
-					error = fz_rethrow(error, "syntaxerror in cmap after WMode");
+					error = fz_error_note(error, "syntaxerror in cmap after WMode");
 					goto cleanup;
 				}
 			}
@@ -431,7 +431,7 @@ pdf_parse_cmap(pdf_cmap **cmapp, fz_stream *file)
 			error = pdf_parse_codespace_range(cmap, file);
 			if (error)
 			{
-				error = fz_rethrow(error, "syntaxerror in cmap codespacerange");
+				error = fz_error_note(error, "syntaxerror in cmap codespacerange");
 				goto cleanup;
 			}
 		}
@@ -441,7 +441,7 @@ pdf_parse_cmap(pdf_cmap **cmapp, fz_stream *file)
 			error = pdf_parse_bf_char(cmap, file);
 			if (error)
 			{
-				error = fz_rethrow(error, "syntaxerror in cmap bfchar");
+				error = fz_error_note(error, "syntaxerror in cmap bfchar");
 				goto cleanup;
 			}
 		}
@@ -451,7 +451,7 @@ pdf_parse_cmap(pdf_cmap **cmapp, fz_stream *file)
 			error = pdf_parse_cid_char(cmap, file);
 			if (error)
 			{
-				error = fz_rethrow(error, "syntaxerror in cmap cidchar");
+				error = fz_error_note(error, "syntaxerror in cmap cidchar");
 				goto cleanup;
 			}
 		}
@@ -461,7 +461,7 @@ pdf_parse_cmap(pdf_cmap **cmapp, fz_stream *file)
 			error = pdf_parse_bf_range(cmap, file);
 			if (error)
 			{
-				error = fz_rethrow(error, "syntaxerror in cmap bfrange");
+				error = fz_error_note(error, "syntaxerror in cmap bfrange");
 				goto cleanup;
 			}
 		}
@@ -471,7 +471,7 @@ pdf_parse_cmap(pdf_cmap **cmapp, fz_stream *file)
 			error = pdf_parse_cid_range(cmap, file);
 			if (error)
 			{
-				error = fz_rethrow(error, "syntaxerror in cmap cidrange");
+				error = fz_error_note(error, "syntaxerror in cmap cidrange");
 				goto cleanup;
 			}
 		}
diff --git a/pdf/pdf_colorspace.c b/pdf/pdf_colorspace.c
index b7ea51a3..2fe5bccd 100644
--- a/pdf/pdf_colorspace.c
+++ b/pdf/pdf_colorspace.c
@@ -17,7 +17,7 @@ load_icc_based(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
 	case 4: *csp = fz_device_cmyk; return fz_okay;
 	}
 
-	return fz_throw("syntaxerror: ICCBased must have 1, 3 or 4 components");
+	return fz_error_make("syntaxerror: ICCBased must have 1, 3 or 4 components");
 }
 
 /* Lab */
@@ -108,17 +108,17 @@ load_separation(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
 		n = 1;
 
 	if (n > FZ_MAX_COLORS)
-		return fz_throw("too many components in colorspace");
+		return fz_error_make("too many components in colorspace");
 
 	error = pdf_load_colorspace(&base, xref, baseobj);
 	if (error)
-		return fz_rethrow(error, "cannot load base colorspace (%d %d R)", fz_to_num(baseobj), fz_to_gen(baseobj));
+		return fz_error_note(error, "cannot load base colorspace (%d %d R)", fz_to_num(baseobj), fz_to_gen(baseobj));
 
 	error = pdf_load_function(&tint, xref, tintobj);
 	if (error)
 	{
 		fz_drop_colorspace(base);
-		return fz_rethrow(error, "cannot load tint function (%d %d R)", fz_to_num(tintobj), fz_to_gen(tintobj));
+		return fz_error_note(error, "cannot load tint function (%d %d R)", fz_to_num(tintobj), fz_to_gen(tintobj));
 	}
 
 	sep = fz_malloc(sizeof(struct separation));
@@ -221,7 +221,7 @@ load_indexed(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
 
 	error = pdf_load_colorspace(&base, xref, baseobj);
 	if (error)
-		return fz_rethrow(error, "cannot load base colorspace (%d %d R)", fz_to_num(baseobj), fz_to_gen(baseobj));
+		return fz_error_note(error, "cannot load base colorspace (%d %d R)", fz_to_num(baseobj), fz_to_gen(baseobj));
 
 	idx = fz_malloc(sizeof(struct indexed));
 	idx->base = base;
@@ -250,14 +250,14 @@ load_indexed(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
 		if (error)
 		{
 			fz_drop_colorspace(cs);
-			return fz_rethrow(error, "cannot open colorspace lookup table (%d 0 R)", fz_to_num(lookup));
+			return fz_error_note(error, "cannot open colorspace lookup table (%d 0 R)", fz_to_num(lookup));
 		}
 
 		i = fz_read(file, idx->lookup, n);
 		if (i < 0)
 		{
 			fz_drop_colorspace(cs);
-			return fz_throw("cannot read colorspace lookup table (%d 0 R)", fz_to_num(lookup));
+			return fz_error_make("cannot read colorspace lookup table (%d 0 R)", fz_to_num(lookup));
 		}
 
 		fz_close(file);
@@ -265,7 +265,7 @@ load_indexed(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
 	else
 	{
 		fz_drop_colorspace(cs);
-		return fz_throw("cannot parse colorspace lookup table");
+		return fz_error_make("cannot parse colorspace lookup table");
 	}
 
 	*csp = cs;
@@ -294,7 +294,7 @@ pdf_load_colorspace_imp(fz_colorspace **csp, pdf_xref *xref, fz_obj *obj)
 		else if (!strcmp(fz_to_name(obj), "DeviceCMYK"))
 			*csp = fz_device_cmyk;
 		else
-			return fz_throw("unknown colorspace: %s", fz_to_name(obj));
+			return fz_error_make("unknown colorspace: %s", fz_to_name(obj));
 		return fz_okay;
 	}
 
@@ -318,7 +318,7 @@ pdf_load_colorspace_imp(fz_colorspace **csp, pdf_xref *xref, fz_obj *obj)
 
 				error = pdf_load_colorspace(csp, xref, obj);
 				if (error)
-					return fz_rethrow(error, "cannot load pattern (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+					return fz_error_note(error, "cannot load pattern (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
 			}
 
 			else if (!strcmp(fz_to_name(name), "G"))
@@ -357,13 +357,13 @@ pdf_load_colorspace_imp(fz_colorspace **csp, pdf_xref *xref, fz_obj *obj)
 				return load_separation(csp, xref, obj);
 
 			else
-				return fz_throw("syntaxerror: unknown colorspace %s", fz_to_name(name));
+				return fz_error_make("syntaxerror: unknown colorspace %s", fz_to_name(name));
 
 			return fz_okay;
 		}
 	}
 
-	return fz_throw("syntaxerror: could not parse color space (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+	return fz_error_make("syntaxerror: could not parse color space (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
 }
 
 fz_error
@@ -379,7 +379,7 @@ pdf_load_colorspace(fz_colorspace **csp, pdf_xref *xref, fz_obj *obj)
 
 	error = pdf_load_colorspace_imp(csp, xref, obj);
 	if (error)
-		return fz_rethrow(error, "cannot load colorspace (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+		return fz_error_note(error, "cannot load colorspace (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
 
 	pdf_store_item(xref->store, fz_keep_colorspace, fz_drop_colorspace, obj, *csp);
 
diff --git a/pdf/pdf_crypt.c b/pdf/pdf_crypt.c
index 4dd4c4e1..0bf52357 100644
--- a/pdf/pdf_crypt.c
+++ b/pdf/pdf_crypt.c
@@ -62,12 +62,12 @@ pdf_new_crypt(pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 	if (!fz_is_name(obj))
 	{
 		pdf_free_crypt(crypt);
-		return fz_throw("unspecified encryption handler");
+		return fz_error_make("unspecified encryption handler");
 	}
 	if (strcmp(fz_to_name(obj), "Standard") != 0)
 	{
 		pdf_free_crypt(crypt);
-		return fz_throw("unknown encryption handler: '%s'", fz_to_name(obj));
+		return fz_error_make("unknown encryption handler: '%s'", fz_to_name(obj));
 	}
 
 	crypt->v = 0;
@@ -77,7 +77,7 @@ pdf_new_crypt(pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 	if (crypt->v != 1 && crypt->v != 2 && crypt->v != 4 && crypt->v != 5)
 	{
 		pdf_free_crypt(crypt);
-		return fz_throw("unknown encryption version");
+		return fz_error_make("unknown encryption version");
 	}
 
 	crypt->length = 40;
@@ -94,12 +94,12 @@ pdf_new_crypt(pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 		if (crypt->length % 8 != 0)
 		{
 			pdf_free_crypt(crypt);
-			return fz_throw("invalid encryption key length");
+			return fz_error_make("invalid encryption key length");
 		}
 		if (crypt->length > 256)
 		{
 			pdf_free_crypt(crypt);
-			return fz_throw("invalid encryption key length");
+			return fz_error_make("invalid encryption key length");
 		}
 	}
 
@@ -140,7 +140,7 @@ pdf_new_crypt(pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 			if (error)
 			{
 				pdf_free_crypt(crypt);
-				return fz_rethrow(error, "cannot parse stream crypt filter (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+				return fz_error_note(error, "cannot parse stream crypt filter (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
 			}
 		}
 
@@ -151,7 +151,7 @@ pdf_new_crypt(pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 			if (error)
 			{
 				pdf_free_crypt(crypt);
-				return fz_rethrow(error, "cannot parse string crypt filter (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+				return fz_error_note(error, "cannot parse string crypt filter (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
 			}
 		}
 
@@ -168,7 +168,7 @@ pdf_new_crypt(pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 	else
 	{
 		pdf_free_crypt(crypt);
-		return fz_throw("encryption dictionary missing revision value");
+		return fz_error_make("encryption dictionary missing revision value");
 	}
 
 	obj = fz_dict_gets(dict, "O");
@@ -180,7 +180,7 @@ pdf_new_crypt(pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 	else
 	{
 		pdf_free_crypt(crypt);
-		return fz_throw("encryption dictionary missing owner password");
+		return fz_error_make("encryption dictionary missing owner password");
 	}
 
 	obj = fz_dict_gets(dict, "U");
@@ -196,7 +196,7 @@ pdf_new_crypt(pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 	else
 	{
 		pdf_free_crypt(crypt);
-		return fz_throw("encryption dictionary missing user password");
+		return fz_error_make("encryption dictionary missing user password");
 	}
 
 	obj = fz_dict_gets(dict, "P");
@@ -205,7 +205,7 @@ pdf_new_crypt(pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 	else
 	{
 		pdf_free_crypt(crypt);
-		return fz_throw("encryption dictionary missing permissions value");
+		return fz_error_make("encryption dictionary missing permissions value");
 	}
 
 	if (crypt->r == 5)
@@ -214,7 +214,7 @@ pdf_new_crypt(pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 		if (!fz_is_string(obj) || fz_to_str_len(obj) != 32)
 		{
 			pdf_free_crypt(crypt);
-			return fz_throw("encryption dictionary missing owner encryption key");
+			return fz_error_make("encryption dictionary missing owner encryption key");
 		}
 		memcpy(crypt->oe, fz_to_str_buf(obj), 32);
 
@@ -222,7 +222,7 @@ pdf_new_crypt(pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
 		if (!fz_is_string(obj) || fz_to_str_len(obj) != 32)
 		{
 			pdf_free_crypt(crypt);
-			return fz_throw("encryption dictionary missing user encryption key");
+			return fz_error_make("encryption dictionary missing user encryption key");
 		}
 		memcpy(crypt->ue, fz_to_str_buf(obj), 32);
 	}
@@ -269,7 +269,7 @@ pdf_parse_crypt_filter(pdf_crypt_filter *cf, fz_obj *cf_obj, char *name, int def
 
 	if (!is_identity && !is_stdcf)
 	{
-		return fz_throw("Crypt Filter not Identity or StdCF (%d %d R)", fz_to_num(cf_obj), fz_to_gen(cf_obj));
+		return fz_error_make("Crypt Filter not Identity or StdCF (%d %d R)", fz_to_num(cf_obj), fz_to_gen(cf_obj));
 	}
 	cf->method = PDF_CRYPT_NONE;
 	cf->length = defaultlength;
@@ -283,7 +283,7 @@ pdf_parse_crypt_filter(pdf_crypt_filter *cf, fz_obj *cf_obj, char *name, int def
 	dict = fz_dict_gets(cf_obj, name);
 	if (!fz_is_dict(dict))
 	{
-		return fz_throw("cannot parse crypt filter (%d %d R)", fz_to_num(cf_obj), fz_to_gen(cf_obj));
+		return fz_error_make("cannot parse crypt filter (%d %d R)", fz_to_num(cf_obj), fz_to_gen(cf_obj));
 	}
 	obj = fz_dict_gets(dict, "CFM");
 	if (fz_is_name(obj))
@@ -297,7 +297,7 @@ pdf_parse_crypt_filter(pdf_crypt_filter *cf, fz_obj *cf_obj, char *name, int def
 		else if (!strcmp(fz_to_name(obj), "AESV3"))
 			cf->method = PDF_CRYPT_AESV3;
 		else
-			fz_throw("unknown encryption method: %s", fz_to_name(obj));
+			fz_error_make("unknown encryption method: %s", fz_to_name(obj));
 	}
 
 	obj = fz_dict_gets(dict, "Length");
@@ -309,7 +309,7 @@ pdf_parse_crypt_filter(pdf_crypt_filter *cf, fz_obj *cf_obj, char *name, int def
 		cf->length = cf->length * 8;
 
 	if ((cf->length % 8) != 0)
-		return fz_throw("invalid key length: %d", cf->length);
+		return fz_error_make("invalid key length: %d", cf->length);
 
 	return fz_okay;
 }
@@ -815,7 +815,7 @@ pdf_open_crypt_with_filter(fz_stream *chain, pdf_crypt *crypt, char *name, int n
 	{
 		error = pdf_parse_crypt_filter(&cf, crypt->cf, name, crypt->length);
 		if (error)
-			fz_catch(error, "cannot parse crypt filter (%d %d R)", num, gen);
+			fz_error_handle(error, "cannot parse crypt filter (%d %d R)", num, gen);
 		else
 			return pdf_open_crypt_imp(chain, crypt, &cf, num, gen);
 	}
diff --git a/pdf/pdf_font.c b/pdf/pdf_font.c
index e7da43c0..0e4b2229 100644
--- a/pdf/pdf_font.c
+++ b/pdf/pdf_font.c
@@ -179,11 +179,11 @@ pdf_load_builtin_font(pdf_font_desc *fontdesc, char *fontname)
 
 	data = pdf_find_builtin_font(fontname, &len);
 	if (!data)
-		return fz_throw("cannot find builtin font: '%s'", fontname);
+		return fz_error_make("cannot find builtin font: '%s'", fontname);
 
 	error = fz_new_font_from_memory(&fontdesc->font, data, len, 0);
 	if (error)
-		return fz_rethrow(error, "cannot load freetype font from memory");
+		return fz_error_note(error, "cannot load freetype font from memory");
 
 	if (!strcmp(fontname, "Symbol") || !strcmp(fontname, "ZapfDingbats"))
 		fontdesc->flags |= PDF_FD_SYMBOLIC;
@@ -200,11 +200,11 @@ pdf_load_substitute_font(pdf_font_desc *fontdesc, int mono, int serif, int bold,
 
 	data = pdf_find_substitute_font(mono, serif, bold, italic, &len);
 	if (!data)
-		return fz_throw("cannot find substitute font");
+		return fz_error_make("cannot find substitute font");
 
 	error = fz_new_font_from_memory(&fontdesc->font, data, len, 0);
 	if (error)
-		return fz_rethrow(error, "cannot load freetype font from memory");
+		return fz_error_note(error, "cannot load freetype font from memory");
 
 	fontdesc->font->ft_substitute = 1;
 	fontdesc->font->ft_bold = bold && !ft_is_bold(fontdesc->font->ft_face);
@@ -221,11 +221,11 @@ pdf_load_substitute_cjk_font(pdf_font_desc *fontdesc, int ros, int serif)
 
 	data = pdf_find_substitute_cjk_font(ros, serif, &len);
 	if (!data)
-		return fz_throw("cannot find builtin CJK font");
+		return fz_error_make("cannot find builtin CJK font");
 
 	error = fz_new_font_from_memory(&fontdesc->font, data, len, 0);
 	if (error)
-		return fz_rethrow(error, "cannot load builtin CJK font");
+		return fz_error_note(error, "cannot load builtin CJK font");
 
 	fontdesc->font->ft_substitute = 1;
 	return fz_okay;
@@ -266,12 +266,12 @@ pdf_load_system_font(pdf_font_desc *fontdesc, char *fontname, char *collection)
 			return pdf_load_substitute_cjk_font(fontdesc, PDF_ROS_JAPAN, serif);
 		else if (!strcmp(collection, "Adobe-Korea1"))
 			return pdf_load_substitute_cjk_font(fontdesc, PDF_ROS_KOREA, serif);
-		return fz_throw("unknown cid collection: %s", collection);
+		return fz_error_make("unknown cid collection: %s", collection);
 	}
 
 	error = pdf_load_substitute_font(fontdesc, mono, serif, bold, italic);
 	if (error)
-		return fz_rethrow(error, "cannot load substitute font");
+		return fz_error_note(error, "cannot load substitute font");
 
 	return fz_okay;
 }
@@ -284,13 +284,13 @@ pdf_load_embedded_font(pdf_font_desc *fontdesc, pdf_xref *xref, fz_obj *stmref)
 
 	error = pdf_load_stream(&buf, xref, fz_to_num(stmref), fz_to_gen(stmref));
 	if (error)
-		return fz_rethrow(error, "cannot load font stream (%d %d R)", fz_to_num(stmref), fz_to_gen(stmref));
+		return fz_error_note(error, "cannot load font stream (%d %d R)", fz_to_num(stmref), fz_to_gen(stmref));
 
 	error = fz_new_font_from_memory(&fontdesc->font, buf->data, buf->len, 0);
 	if (error)
 	{
 		fz_drop_buffer(buf);
-		return fz_rethrow(error, "cannot load embedded font (%d %d R)", fz_to_num(stmref), fz_to_gen(stmref));
+		return fz_error_note(error, "cannot load embedded font (%d %d R)", fz_to_num(stmref), fz_to_gen(stmref));
 	}
 
 	/* save the buffer so we can free it later */
@@ -454,7 +454,7 @@ pdf_load_simple_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict)
 			error |= pdf_load_system_cmap(&fontdesc->to_unicode, "Adobe-GB1-UCS2");
 			error |= pdf_load_system_cmap(&fontdesc->to_ttf_cmap, "Adobe-GB1-UCS2");
 			if (error)
-				return fz_rethrow(error, "cannot load font");
+				return fz_error_note(error, "cannot load font");
 
 			face = fontdesc->font->ft_face;
 			kind = ft_kind(face);
@@ -648,7 +648,7 @@ pdf_load_simple_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict)
 
 	error = pdf_load_to_unicode(fontdesc, xref, estrings, NULL, fz_dict_gets(dict, "ToUnicode"));
 	if (error)
-		fz_catch(error, "cannot load to_unicode");
+		fz_error_handle(error, "cannot load to_unicode");
 
 skip_encoding:
 
@@ -693,7 +693,7 @@ cleanup:
 	if (etable != fontdesc->cid_to_gid)
 		fz_free(etable);
 	pdf_drop_font(fontdesc);
-	return fz_rethrow(error, "cannot load simple font (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+	return fz_error_note(error, "cannot load simple font (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 }
 
 /*
@@ -726,7 +726,7 @@ load_cid_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *e
 
 		cidinfo = fz_dict_gets(dict, "CIDSystemInfo");
 		if (!cidinfo)
-			return fz_throw("cid font is missing info");
+			return fz_error_make("cid font is missing info");
 
 		obj = fz_dict_gets(cidinfo, "Registry");
 		tmplen = MIN(sizeof tmpstr - 1, fz_to_str_len(obj));
@@ -751,7 +751,7 @@ load_cid_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *e
 	if (descriptor)
 		error = pdf_load_font_descriptor(fontdesc, xref, descriptor, collection, basefont);
 	else
-		error = fz_throw("syntaxerror: missing font descriptor");
+		error = fz_error_make("syntaxerror: missing font descriptor");
 	if (error)
 		goto cleanup;
 
@@ -776,7 +776,7 @@ load_cid_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *e
 	}
 	else
 	{
-		error = fz_throw("syntaxerror: font missing encoding");
+		error = fz_error_make("syntaxerror: font missing encoding");
 	}
 	if (error)
 		goto cleanup;
@@ -812,7 +812,7 @@ load_cid_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *e
 			fterr = FT_Select_Charmap(face, ft_encoding_unicode);
 			if (fterr)
 			{
-				error = fz_throw("fonterror: no unicode cmap when emulating CID font: %s", ft_error_string(fterr));
+				error = fz_error_make("fonterror: no unicode cmap when emulating CID font: %s", ft_error_string(fterr));
 				goto cleanup;
 			}
 
@@ -831,7 +831,7 @@ load_cid_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *e
 
 			if (error)
 			{
-				error = fz_rethrow(error, "cannot load system cmap %s", collection);
+				error = fz_error_note(error, "cannot load system cmap %s", collection);
 				goto cleanup;
 			}
 		}
@@ -839,7 +839,7 @@ load_cid_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *e
 
 	error = pdf_load_to_unicode(fontdesc, xref, NULL, collection, to_unicode);
 	if (error)
-		fz_catch(error, "cannot load to_unicode");
+		fz_error_handle(error, "cannot load to_unicode");
 
 	/* Horizontal */
 
@@ -935,7 +935,7 @@ load_cid_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *e
 
 cleanup:
 	pdf_drop_font(fontdesc);
-	return fz_rethrow(error, "cannot load cid font (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+	return fz_error_note(error, "cannot load cid font (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 }
 
 static fz_error
@@ -950,7 +950,7 @@ pdf_load_type0_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict)
 
 	dfonts = fz_dict_gets(dict, "DescendantFonts");
 	if (!dfonts)
-		return fz_throw("cid font is missing descendant fonts");
+		return fz_error_make("cid font is missing descendant fonts");
 
 	dfont = fz_array_get(dfonts, 0);
 
@@ -963,9 +963,9 @@ pdf_load_type0_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *dict)
 	else if (fz_is_name(subtype) && !strcmp(fz_to_name(subtype), "CIDFontType2"))
 		error = load_cid_font(fontdescp, xref, dfont, encoding, to_unicode);
 	else
-		error = fz_throw("syntaxerror: unknown cid font type");
+		error = fz_error_make("syntaxerror: unknown cid font type");
 	if (error)
-		return fz_rethrow(error, "cannot load descendant font (%d %d R)", fz_to_num(dfont), fz_to_gen(dfont));
+		return fz_error_note(error, "cannot load descendant font (%d %d R)", fz_to_num(dfont), fz_to_gen(dfont));
 
 	return fz_okay;
 }
@@ -1007,13 +1007,13 @@ pdf_load_font_descriptor(pdf_font_desc *fontdesc, pdf_xref *xref, fz_obj *dict,
 		error = pdf_load_embedded_font(fontdesc, xref, obj);
 		if (error)
 		{
-			fz_catch(error, "ignored error when loading embedded font, attempting to load system font");
+			fz_error_handle(error, "ignored error when loading embedded font, attempting to load system font");
 			if (origname != fontname)
 				error = pdf_load_builtin_font(fontdesc, fontname);
 			else
 				error = pdf_load_system_font(fontdesc, fontname, collection);
 			if (error)
-				return fz_rethrow(error, "cannot load font descriptor (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+				return fz_error_note(error, "cannot load font descriptor (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 		}
 	}
 	else
@@ -1023,7 +1023,7 @@ pdf_load_font_descriptor(pdf_font_desc *fontdesc, pdf_xref *xref, fz_obj *dict,
 		else
 			error = pdf_load_system_font(fontdesc, fontname, collection);
 		if (error)
-			return fz_rethrow(error, "cannot load font descriptor (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+			return fz_error_note(error, "cannot load font descriptor (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 	}
 
 	fz_strlcpy(fontdesc->font->name, fontname, sizeof fontdesc->font->name);
@@ -1118,7 +1118,7 @@ pdf_load_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *rdb, fz_obj *di
 		error = pdf_load_simple_font(fontdescp, xref, dict);
 	}
 	if (error)
-		return fz_rethrow(error, "cannot load font (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+		return fz_error_note(error, "cannot load font (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 
 	/* Save the widths to stretch non-CJK substitute fonts */
 	if ((*fontdescp)->font->ft_substitute && !(*fontdescp)->to_ttf_cmap)
diff --git a/pdf/pdf_function.c b/pdf/pdf_function.c
index c1132365..7eeb7863 100644
--- a/pdf/pdf_function.c
+++ b/pdf/pdf_function.c
@@ -697,12 +697,12 @@ parse_code(pdf_function *func, fz_stream *stream, int *codeptr)
 	{
 		error = pdf_lex(&tok, stream, buf, sizeof buf, &len);
 		if (error)
-			return fz_rethrow(error, "calculator function lexical error");
+			return fz_error_note(error, "calculator function lexical error");
 
 		switch(tok)
 		{
 		case PDF_TOK_EOF:
-			return fz_throw("truncated calculator function");
+			return fz_error_make("truncated calculator function");
 
 		case PDF_TOK_INT:
 			resize_code(func, *codeptr);
@@ -727,22 +727,22 @@ parse_code(pdf_function *func, fz_stream *stream, int *codeptr)
 			ifptr = *codeptr;
 			error = parse_code(func, stream, codeptr);
 			if (error)
-				return fz_rethrow(error, "error in 'if' branch");
+				return fz_error_note(error, "error in 'if' branch");
 
 			error = pdf_lex(&tok, stream, buf, sizeof buf, &len);
 			if (error)
-				return fz_rethrow(error, "calculator function syntax error");
+				return fz_error_note(error, "calculator function syntax error");
 
 			if (tok == PDF_TOK_OPEN_BRACE)
 			{
 				elseptr = *codeptr;
 				error = parse_code(func, stream, codeptr);
 				if (error)
-					return fz_rethrow(error, "error in 'else' branch");
+					return fz_error_note(error, "error in 'else' branch");
 
 				error = pdf_lex(&tok, stream, buf, sizeof buf, &len);
 				if (error)
-					return fz_rethrow(error, "calculator function syntax error");
+					return fz_error_note(error, "calculator function syntax error");
 			}
 			else
 			{
@@ -754,7 +754,7 @@ parse_code(pdf_function *func, fz_stream *stream, int *codeptr)
 				if (!strcmp(buf, "if"))
 				{
 					if (elseptr >= 0)
-						return fz_throw("too many branches for 'if'");
+						return fz_error_make("too many branches for 'if'");
 					func->u.p.code[opptr].type = PS_OPERATOR;
 					func->u.p.code[opptr].u.op = PS_OP_IF;
 					func->u.p.code[opptr+2].type = PS_BLOCK;
@@ -765,7 +765,7 @@ parse_code(pdf_function *func, fz_stream *stream, int *codeptr)
 				else if (!strcmp(buf, "ifelse"))
 				{
 					if (elseptr < 0)
-						return fz_throw("not enough branches for 'ifelse'");
+						return fz_error_make("not enough branches for 'ifelse'");
 					func->u.p.code[opptr].type = PS_OPERATOR;
 					func->u.p.code[opptr].u.op = PS_OP_IFELSE;
 					func->u.p.code[opptr+1].type = PS_BLOCK;
@@ -777,12 +777,12 @@ parse_code(pdf_function *func, fz_stream *stream, int *codeptr)
 				}
 				else
 				{
-					return fz_throw("unknown keyword in 'if-else' context: '%s'", buf);
+					return fz_error_make("unknown keyword in 'if-else' context: '%s'", buf);
 				}
 			}
 			else
 			{
-				return fz_throw("missing keyword in 'if-else' context");
+				return fz_error_make("missing keyword in 'if-else' context");
 			}
 			break;
 
@@ -809,7 +809,7 @@ parse_code(pdf_function *func, fz_stream *stream, int *codeptr)
 					a = b = mid;
 			}
 			if (cmp != 0)
-				return fz_throw("unknown operator: '%s'", buf);
+				return fz_error_make("unknown operator: '%s'", buf);
 
 			resize_code(func, *codeptr);
 			func->u.p.code[*codeptr].type = PS_OPERATOR;
@@ -818,7 +818,7 @@ parse_code(pdf_function *func, fz_stream *stream, int *codeptr)
 			break;
 
 		default:
-			return fz_throw("calculator function syntax error");
+			return fz_error_make("calculator function syntax error");
 		}
 	}
 }
@@ -835,19 +835,19 @@ load_postscript_func(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num,
 
 	error = pdf_open_stream(&stream, xref, num, gen);
 	if (error)
-		return fz_rethrow(error, "cannot open calculator function stream");
+		return fz_error_note(error, "cannot open calculator function stream");
 
 	error = pdf_lex(&tok, stream, buf, sizeof buf, &len);
 	if (error)
 	{
 		fz_close(stream);
-		return fz_rethrow(error, "stream is not a calculator function");
+		return fz_error_note(error, "stream is not a calculator function");
 	}
 
 	if (tok != PDF_TOK_OPEN_BRACE)
 	{
 		fz_close(stream);
-		return fz_throw("stream is not a calculator function");
+		return fz_error_make("stream is not a calculator function");
 	}
 
 	func->u.p.code = NULL;
@@ -858,7 +858,7 @@ load_postscript_func(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num,
 	if (error)
 	{
 		fz_close(stream);
-		return fz_rethrow(error, "cannot parse calculator function (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot parse calculator function (%d %d R)", num, gen);
 	}
 
 	fz_close(stream);
@@ -907,20 +907,20 @@ load_sample_func(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int
 
 	obj = fz_dict_gets(dict, "Size");
 	if (!fz_is_array(obj) || fz_array_len(obj) != func->m)
-		return fz_throw("malformed /Size");
+		return fz_error_make("malformed /Size");
 	for (i = 0; i < func->m; i++)
 		func->u.sa.size[i] = fz_to_int(fz_array_get(obj, i));
 
 	obj = fz_dict_gets(dict, "BitsPerSample");
 	if (!fz_is_int(obj))
-		return fz_throw("malformed /BitsPerSample");
+		return fz_error_make("malformed /BitsPerSample");
 	func->u.sa.bps = bps = fz_to_int(obj);
 
 	obj = fz_dict_gets(dict, "Encode");
 	if (fz_is_array(obj))
 	{
 		if (fz_array_len(obj) != func->m * 2)
-			return fz_throw("malformed /Encode");
+			return fz_error_make("malformed /Encode");
 		for (i = 0; i < func->m; i++)
 		{
 			func->u.sa.encode[i][0] = fz_to_real(fz_array_get(obj, i*2+0));
@@ -940,7 +940,7 @@ load_sample_func(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int
 	if (fz_is_array(obj))
 	{
 		if (fz_array_len(obj) != func->n * 2)
-			return fz_throw("malformed /Decode");
+			return fz_error_make("malformed /Decode");
 		for (i = 0; i < func->n; i++)
 		{
 			func->u.sa.decode[i][0] = fz_to_real(fz_array_get(obj, i*2+0));
@@ -963,7 +963,7 @@ load_sample_func(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int
 
 	error = pdf_open_stream(&stream, xref, num, gen);
 	if (error)
-		return fz_rethrow(error, "cannot open samples stream (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot open samples stream (%d %d R)", num, gen);
 
 	/* read samples */
 	for (i = 0; i < samplecount; i++)
@@ -974,7 +974,7 @@ load_sample_func(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int
 		if (fz_is_eof_bits(stream))
 		{
 			fz_close(stream);
-			return fz_throw("truncated sample stream");
+			return fz_error_make("truncated sample stream");
 		}
 
 		switch (bps)
@@ -1004,7 +1004,7 @@ load_sample_func(pdf_function *func, pdf_xref *xref, fz_obj *dict, int num, int
 			break;
 		default:
 			fz_close(stream);
-			return fz_throw("sample stream bit depth %d unsupported", bps);
+			return fz_error_make("sample stream bit depth %d unsupported", bps);
 		}
 
 		func->u.sa.samples[i] = s;
@@ -1113,11 +1113,11 @@ load_exponential_func(pdf_function *func, fz_obj *dict)
 	int i;
 
 	if (func->m != 1)
-		return fz_throw("/Domain must be one dimension (%d)", func->m);
+		return fz_error_make("/Domain must be one dimension (%d)", func->m);
 
 	obj = fz_dict_gets(dict, "N");
 	if (!fz_is_int(obj) && !fz_is_real(obj))
-		return fz_throw("malformed /N");
+		return fz_error_make("malformed /N");
 	func->u.e.n = fz_to_real(obj);
 
 	obj = fz_dict_gets(dict, "C0");
@@ -1125,7 +1125,7 @@ load_exponential_func(pdf_function *func, fz_obj *dict)
 	{
 		func->n = fz_array_len(obj);
 		if (func->n >= MAXN)
-			return fz_throw("exponential function result array out of range");
+			return fz_error_make("exponential function result array out of range");
 		for (i = 0; i < func->n; i++)
 			func->u.e.c0[i] = fz_to_real(fz_array_get(obj, i));
 	}
@@ -1139,14 +1139,14 @@ load_exponential_func(pdf_function *func, fz_obj *dict)
 	if (fz_is_array(obj))
 	{
 		if (fz_array_len(obj) != func->n)
-			return fz_throw("/C1 must match /C0 length");
+			return fz_error_make("/C1 must match /C0 length");
 		for (i = 0; i < func->n; i++)
 			func->u.e.c1[i] = fz_to_real(fz_array_get(obj, i));
 	}
 	else
 	{
 		if (func->n != 1)
-			return fz_throw("/C1 must match /C0 length");
+			return fz_error_make("/C1 must match /C0 length");
 		func->u.e.c1[0] = 1;
 	}
 
@@ -1196,11 +1196,11 @@ load_stitching_func(pdf_function *func, pdf_xref *xref, fz_obj *dict)
 	func->u.st.k = 0;
 
 	if (func->m != 1)
-		return fz_throw("/Domain must be one dimension (%d)", func->m);
+		return fz_error_make("/Domain must be one dimension (%d)", func->m);
 
 	obj = fz_dict_gets(dict, "Functions");
 	if (!fz_is_array(obj))
-		return fz_throw("stitching function has no input functions");
+		return fz_error_make("stitching function has no input functions");
 	{
 		k = fz_array_len(obj);
 
@@ -1214,33 +1214,33 @@ load_stitching_func(pdf_function *func, pdf_xref *xref, fz_obj *dict)
 			sub = fz_array_get(obj, i);
 			error = pdf_load_function(&funcs[i], xref, sub);
 			if (error)
-				return fz_rethrow(error, "cannot load sub function %d (%d %d R)", i, fz_to_num(sub), fz_to_gen(sub));
+				return fz_error_note(error, "cannot load sub function %d (%d %d R)", i, fz_to_num(sub), fz_to_gen(sub));
 			if (funcs[i]->m != 1 || funcs[i]->n != funcs[0]->n)
-				return fz_throw("sub function %d /Domain or /Range mismatch", i);
+				return fz_error_make("sub function %d /Domain or /Range mismatch", i);
 			func->u.st.k ++;
 		}
 
 		if (!func->n)
 			func->n = funcs[0]->n;
 		else if (func->n != funcs[0]->n)
-			return fz_throw("sub function /Domain or /Range mismatch");
+			return fz_error_make("sub function /Domain or /Range mismatch");
 	}
 
 	obj = fz_dict_gets(dict, "Bounds");
 	if (!fz_is_array(obj))
-		return fz_throw("stitching function has no bounds");
+		return fz_error_make("stitching function has no bounds");
 	{
 		if (!fz_is_array(obj) || fz_array_len(obj) != k - 1)
-			return fz_throw("malformed /Bounds (not array or wrong length)");
+			return fz_error_make("malformed /Bounds (not array or wrong length)");
 
 		for (i = 0; i < k-1; i++)
 		{
 			num = fz_array_get(obj, i);
 			if (!fz_is_int(num) && !fz_is_real(num))
-				return fz_throw("malformed /Bounds (item not real)");
+				return fz_error_make("malformed /Bounds (item not real)");
 			func->u.st.bounds[i] = fz_to_real(num);
 			if (i && func->u.st.bounds[i-1] > func->u.st.bounds[i])
-				return fz_throw("malformed /Bounds (item not monotonic)");
+				return fz_error_make("malformed /Bounds (item not monotonic)");
 		}
 
 		if (k != 1 && (func->domain[0][0] > func->u.st.bounds[0] ||
@@ -1250,10 +1250,10 @@ load_stitching_func(pdf_function *func, pdf_xref *xref, fz_obj *dict)
 
 	obj = fz_dict_gets(dict, "Encode");
 	if (!fz_is_array(obj))
-		return fz_throw("stitching function is missing encoding");
+		return fz_error_make("stitching function is missing encoding");
 	{
 		if (!fz_is_array(obj) || fz_array_len(obj) != k * 2)
-			return fz_throw("malformed /Encode");
+			return fz_error_make("malformed /Encode");
 		for (i = 0; i < k; i++)
 		{
 			func->u.st.encode[i*2+0] = fz_to_real(fz_array_get(obj, i*2+0));
@@ -1396,7 +1396,7 @@ pdf_load_function(pdf_function **funcp, pdf_xref *xref, fz_obj *dict)
 	if (func->m >= MAXM || func->n >= MAXN)
 	{
 		fz_free(func);
-		return fz_throw("assert: /Domain or /Range too big");
+		return fz_error_make("assert: /Domain or /Range too big");
 	}
 
 	switch(func->type)
@@ -1406,7 +1406,7 @@ pdf_load_function(pdf_function **funcp, pdf_xref *xref, fz_obj *dict)
 		if (error)
 		{
 			pdf_drop_function(func);
-			return fz_rethrow(error, "cannot load sampled function (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+			return fz_error_note(error, "cannot load sampled function (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 		}
 		break;
 
@@ -1415,7 +1415,7 @@ pdf_load_function(pdf_function **funcp, pdf_xref *xref, fz_obj *dict)
 		if (error)
 		{
 			pdf_drop_function(func);
-			return fz_rethrow(error, "cannot load exponential function (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+			return fz_error_note(error, "cannot load exponential function (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 		}
 		break;
 
@@ -1424,7 +1424,7 @@ pdf_load_function(pdf_function **funcp, pdf_xref *xref, fz_obj *dict)
 		if (error)
 		{
 			pdf_drop_function(func);
-			return fz_rethrow(error, "cannot load stitching function (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+			return fz_error_note(error, "cannot load stitching function (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 		}
 		break;
 
@@ -1433,13 +1433,13 @@ pdf_load_function(pdf_function **funcp, pdf_xref *xref, fz_obj *dict)
 		if (error)
 		{
 			pdf_drop_function(func);
-			return fz_rethrow(error, "cannot load calculator function (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+			return fz_error_note(error, "cannot load calculator function (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 		}
 		break;
 
 	default:
 		fz_free(func);
-		return fz_throw("unknown function type (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+		return fz_error_make("unknown function type (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 	}
 
 	pdf_store_item(xref->store, pdf_keep_function, pdf_drop_function, dict, func);
diff --git a/pdf/pdf_image.c b/pdf/pdf_image.c
index e1901100..413efc98 100644
--- a/pdf/pdf_image.c
+++ b/pdf/pdf_image.c
@@ -53,13 +53,13 @@ pdf_load_image_imp(fz_pixmap **imgp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict,
 		tile = NULL;
 		error = pdf_load_jpx_image(&tile, xref, dict);
 		if (error)
-			return fz_rethrow(error, "cannot load jpx image");
+			return fz_error_note(error, "cannot load jpx image");
 		if (forcemask)
 		{
 			if (tile->n != 2)
 			{
 				fz_drop_pixmap(tile);
-				return fz_throw("softmask must be grayscale");
+				return fz_error_make("softmask must be grayscale");
 			}
 			mask = fz_alpha_from_gray(tile, 1);
 			fz_drop_pixmap(tile);
@@ -85,17 +85,17 @@ pdf_load_image_imp(fz_pixmap **imgp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict,
 		bpc = 1;
 
 	if (w == 0)
-		return fz_throw("image width is zero");
+		return fz_error_make("image width is zero");
 	if (h == 0)
-		return fz_throw("image height is zero");
+		return fz_error_make("image height is zero");
 	if (bpc == 0)
-		return fz_throw("image depth is zero");
+		return fz_error_make("image depth is zero");
 	if (bpc > 16)
-		return fz_throw("image depth is too large: %d", bpc);
+		return fz_error_make("image depth is too large: %d", bpc);
 	if (w > (1 << 16))
-		return fz_throw("image is too wide");
+		return fz_error_make("image is too wide");
 	if (h > (1 << 16))
-		return fz_throw("image is too high");
+		return fz_error_make("image is too high");
 
 	obj = fz_dict_getsa(dict, "ColorSpace", "CS");
 	if (obj && !imagemask && !forcemask)
@@ -110,7 +110,7 @@ pdf_load_image_imp(fz_pixmap **imgp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict,
 
 		error = pdf_load_colorspace(&colorspace, xref, obj);
 		if (error)
-			return fz_rethrow(error, "cannot load image colorspace");
+			return fz_error_note(error, "cannot load image colorspace");
 
 		if (!strcmp(colorspace->name, "Indexed"))
 			indexed = 1;
@@ -146,7 +146,7 @@ pdf_load_image_imp(fz_pixmap **imgp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict,
 			{
 				if (colorspace)
 					fz_drop_colorspace(colorspace);
-				return fz_rethrow(error, "cannot load image mask/softmask");
+				return fz_error_note(error, "cannot load image mask/softmask");
 			}
 		}
 	}
@@ -165,7 +165,7 @@ pdf_load_image_imp(fz_pixmap **imgp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict,
 			fz_drop_colorspace(colorspace);
 		if (mask)
 			fz_drop_pixmap(mask);
-		return fz_throw("out of memory");
+		return fz_error_make("out of memory");
 	}
 
 	if (colorspace)
@@ -186,7 +186,7 @@ pdf_load_image_imp(fz_pixmap **imgp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict,
 		if (error)
 		{
 			fz_drop_pixmap(tile);
-			return fz_rethrow(error, "cannot open image data stream (%d 0 R)", fz_to_num(dict));
+			return fz_error_note(error, "cannot open image data stream (%d 0 R)", fz_to_num(dict));
 		}
 	}
 
@@ -198,7 +198,7 @@ pdf_load_image_imp(fz_pixmap **imgp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict,
 		fz_close(stm);
 		fz_free(samples);
 		fz_drop_pixmap(tile);
-		return fz_rethrow(len, "cannot read image data");
+		return fz_error_note(len, "cannot read image data");
 	}
 
 	/* Make sure we read the EOF marker (for inline images only) */
@@ -207,7 +207,7 @@ pdf_load_image_imp(fz_pixmap **imgp, pdf_xref *xref, fz_obj *rdb, fz_obj *dict,
 		unsigned char tbuf[512];
 		int tlen = fz_read(stm, tbuf, sizeof tbuf);
 		if (tlen < 0)
-			fz_catch(tlen, "ignoring error at end of image");
+			fz_error_handle(tlen, "ignoring error at end of image");
 		if (tlen > 0)
 			fz_warn("ignoring garbage at end of image");
 	}
@@ -262,7 +262,7 @@ pdf_load_inline_image(fz_pixmap **pixp, pdf_xref *xref, fz_obj *rdb, fz_obj *dic
 
 	error = pdf_load_image_imp(pixp, xref, rdb, dict, file, 0);
 	if (error)
-		return fz_rethrow(error, "cannot load inline image");
+		return fz_error_note(error, "cannot load inline image");
 
 	return fz_okay;
 }
@@ -295,14 +295,14 @@ pdf_load_jpx_image(fz_pixmap **imgp, pdf_xref *xref, fz_obj *dict)
 
 	error = pdf_load_stream(&buf, xref, fz_to_num(dict), fz_to_gen(dict));
 	if (error)
-		return fz_rethrow(error, "cannot load jpx image data");
+		return fz_error_note(error, "cannot load jpx image data");
 
 	obj = fz_dict_gets(dict, "ColorSpace");
 	if (obj)
 	{
 		error = pdf_load_colorspace(&colorspace, xref, obj);
 		if (error)
-			fz_catch(error, "cannot load image colorspace");
+			fz_error_handle(error, "cannot load image colorspace");
 	}
 
 	error = fz_load_jpx_image(&img, buf->data, buf->len, colorspace);
@@ -311,7 +311,7 @@ pdf_load_jpx_image(fz_pixmap **imgp, pdf_xref *xref, fz_obj *dict)
 		if (colorspace)
 			fz_drop_colorspace(colorspace);
 		fz_drop_buffer(buf);
-		return fz_rethrow(error, "cannot load jpx image");
+		return fz_error_note(error, "cannot load jpx image");
 	}
 
 	if (colorspace)
@@ -325,7 +325,7 @@ pdf_load_jpx_image(fz_pixmap **imgp, pdf_xref *xref, fz_obj *dict)
 		if (error)
 		{
 			fz_drop_pixmap(img);
-			return fz_rethrow(error, "cannot load image mask/softmask");
+			return fz_error_note(error, "cannot load image mask/softmask");
 		}
 	}
 
@@ -346,7 +346,7 @@ pdf_load_image(fz_pixmap **pixp, pdf_xref *xref, fz_obj *dict)
 
 	error = pdf_load_image_imp(pixp, xref, NULL, dict, NULL, 0);
 	if (error)
-		return fz_rethrow(error, "cannot load image (%d 0 R)", fz_to_num(dict));
+		return fz_error_note(error, "cannot load image (%d 0 R)", fz_to_num(dict));
 
 	pdf_store_item(xref->store, fz_keep_pixmap, fz_drop_pixmap, dict, *pixp);
 
diff --git a/pdf/pdf_interpret.c b/pdf/pdf_interpret.c
index b49d9c11..77ff59d8 100644
--- a/pdf/pdf_interpret.c
+++ b/pdf/pdf_interpret.c
@@ -143,7 +143,7 @@ pdf_begin_group(pdf_csi *csi, fz_rect bbox)
 			softmask->colorspace, gstate->softmask_bc);
 		error = pdf_run_xobject(csi, NULL, softmask, fz_identity);
 		if (error)
-			fz_catch(error, "cannot run softmask");
+			fz_error_handle(error, "cannot run softmask");
 		fz_end_mask(csi->dev);
 
 		gstate->softmask = softmask;
@@ -984,7 +984,7 @@ pdf_show_pattern(pdf_csi *csi, pdf_pattern *pat, fz_rect area, int what)
 		pdf_gsave(csi);
 		error = pdf_run_buffer(csi, pat->resources, pat->contents);
 		if (error)
-			fz_catch(error, "cannot render pattern tile");
+			fz_error_handle(error, "cannot render pattern tile");
 		pdf_grestore(csi);
 		while (oldtop < csi->gtop)
 			pdf_grestore(csi);
@@ -1006,7 +1006,7 @@ pdf_show_pattern(pdf_csi *csi, pdf_pattern *pat, fz_rect area, int what)
 					pdf_grestore(csi);
 				if (error)
 				{
-					fz_catch(error, "cannot render pattern tile");
+					fz_error_handle(error, "cannot render pattern tile");
 					goto cleanup;
 				}
 			}
@@ -1053,7 +1053,7 @@ pdf_run_xobject(pdf_csi *csi, fz_obj *resources, pdf_xobject *xobj, fz_matrix tr
 				softmask->colorspace, gstate->softmask_bc);
 			error = pdf_run_xobject(csi, resources, softmask, fz_identity);
 			if (error)
-				return fz_rethrow(error, "cannot run softmask");
+				return fz_error_note(error, "cannot run softmask");
 			fz_end_mask(csi->dev);
 
 			pdf_drop_xobject(softmask);
@@ -1088,7 +1088,7 @@ pdf_run_xobject(pdf_csi *csi, fz_obj *resources, pdf_xobject *xobj, fz_matrix tr
 
 	error = pdf_run_buffer(csi, resources, xobj->contents);
 	if (error)
-		fz_catch(error, "cannot interpret XObject stream");
+		fz_error_note(error, "cannot interpret XObject stream");
 
 	csi->top_ctm = oldtopctm;
 
@@ -1139,13 +1139,13 @@ pdf_run_extgstate(pdf_csi *csi, fz_obj *rdb, fz_obj *extgstate)
 
 				error = pdf_load_font(&gstate->font, csi->xref, rdb, font);
 				if (error)
-					return fz_rethrow(error, "cannot load font (%d %d R)", fz_to_num(font), fz_to_gen(font));
+					return fz_error_note(error, "cannot load font (%d %d R)", fz_to_num(font), fz_to_gen(font));
 				if (!gstate->font)
-					return fz_throw("cannot find font in store");
+					return fz_error_make("cannot find font in store");
 				gstate->size = fz_to_real(fz_array_get(val, 1));
 			}
 			else
-				return fz_throw("malformed /Font dictionary");
+				return fz_error_make("malformed /Font dictionary");
 		}
 
 		else if (!strcmp(s, "LC"))
@@ -1172,7 +1172,7 @@ pdf_run_extgstate(pdf_csi *csi, fz_obj *rdb, fz_obj *extgstate)
 				gstate->stroke_state.dash_phase = fz_to_real(fz_array_get(val, 1));
 			}
 			else
-				return fz_throw("malformed /D");
+				return fz_error_make("malformed /D");
 		}
 
 		else if (!strcmp(s, "CA"))
@@ -1204,10 +1204,10 @@ pdf_run_extgstate(pdf_csi *csi, fz_obj *rdb, fz_obj *extgstate)
 
 				group = fz_dict_gets(val, "G");
 				if (!group)
-					return fz_throw("cannot load softmask xobject (%d %d R)", fz_to_num(val), fz_to_gen(val));
+					return fz_error_make("cannot load softmask xobject (%d %d R)", fz_to_num(val), fz_to_gen(val));
 				error = pdf_load_xobject(&xobj, csi->xref, group);
 				if (error)
-					return fz_rethrow(error, "cannot load xobject (%d %d R)", fz_to_num(val), fz_to_gen(val));
+					return fz_error_note(error, "cannot load xobject (%d %d R)", fz_to_num(val), fz_to_gen(val));
 
 				colorspace = xobj->colorspace;
 				if (!colorspace)
@@ -1270,7 +1270,7 @@ static fz_error pdf_run_BI(pdf_csi *csi, fz_obj *rdb, fz_stream *file)
 
 	error = pdf_parse_dict(&obj, csi->xref, file, buf, buflen);
 	if (error)
-		return fz_rethrow(error, "cannot parse inline image dictionary");
+		return fz_error_note(error, "cannot parse inline image dictionary");
 
 	/* read whitespace after ID keyword */
 	ch = fz_read_byte(file);
@@ -1281,7 +1281,7 @@ static fz_error pdf_run_BI(pdf_csi *csi, fz_obj *rdb, fz_stream *file)
 	error = pdf_load_inline_image(&img, csi->xref, rdb, obj, file);
 	fz_drop_obj(obj);
 	if (error)
-		return fz_rethrow(error, "cannot load inline image");
+		return fz_error_note(error, "cannot load inline image");
 
 	pdf_show_image(csi, img);
 
@@ -1293,7 +1293,7 @@ static fz_error pdf_run_BI(pdf_csi *csi, fz_obj *rdb, fz_stream *file)
 		ch = fz_read_byte(file);
 	ch = fz_read_byte(file);
 	if (ch != 'I')
-		return fz_rethrow(error, "syntax error after inline image");
+		return fz_error_note(error, "syntax error after inline image");
 
 	return fz_okay;
 }
@@ -1346,13 +1346,13 @@ static fz_error pdf_run_cs_imp(pdf_csi *csi, fz_obj *rdb, int what)
 		{
 			dict = fz_dict_gets(rdb, "ColorSpace");
 			if (!dict)
-				return fz_throw("cannot find ColorSpace dictionary");
+				return fz_error_make("cannot find ColorSpace dictionary");
 			obj = fz_dict_gets(dict, csi->name);
 			if (!obj)
-				return fz_throw("cannot find colorspace resource '%s'", csi->name);
+				return fz_error_make("cannot find colorspace resource '%s'", csi->name);
 			error = pdf_load_colorspace(&colorspace, csi->xref, obj);
 			if (error)
-				return fz_rethrow(error, "cannot load colorspace (%d 0 R)", fz_to_num(obj));
+				return fz_error_note(error, "cannot load colorspace (%d 0 R)", fz_to_num(obj));
 		}
 
 		pdf_set_colorspace(csi, what, colorspace);
@@ -1367,7 +1367,7 @@ static void pdf_run_CS(pdf_csi *csi, fz_obj *rdb)
 	fz_error error;
 	error = pdf_run_cs_imp(csi, rdb, PDF_STROKE);
 	if (error)
-		fz_catch(error, "cannot set colorspace");
+		fz_error_handle(error, "cannot set colorspace");
 }
 
 static void pdf_run_cs(pdf_csi *csi, fz_obj *rdb)
@@ -1375,7 +1375,7 @@ static void pdf_run_cs(pdf_csi *csi, fz_obj *rdb)
 	fz_error error;
 	error = pdf_run_cs_imp(csi, rdb, PDF_FILL);
 	if (error)
-		fz_catch(error, "cannot set colorspace");
+		fz_error_handle(error, "cannot set colorspace");
 }
 
 static void pdf_run_DP(pdf_csi *csi)
@@ -1391,15 +1391,15 @@ static fz_error pdf_run_Do(pdf_csi *csi, fz_obj *rdb)
 
 	dict = fz_dict_gets(rdb, "XObject");
 	if (!dict)
-		return fz_throw("cannot find XObject dictionary when looking for: '%s'", csi->name);
+		return fz_error_make("cannot find XObject dictionary when looking for: '%s'", csi->name);
 
 	obj = fz_dict_gets(dict, csi->name);
 	if (!obj)
-		return fz_throw("cannot find xobject resource: '%s'", csi->name);
+		return fz_error_make("cannot find xobject resource: '%s'", csi->name);
 
 	subtype = fz_dict_gets(obj, "Subtype");
 	if (!fz_is_name(subtype))
-		return fz_throw("no XObject subtype specified");
+		return fz_error_make("no XObject subtype specified");
 
 	if (pdf_is_hidden_ocg(obj, csi->target))
 		return fz_okay;
@@ -1413,7 +1413,7 @@ static fz_error pdf_run_Do(pdf_csi *csi, fz_obj *rdb)
 
 		error = pdf_load_xobject(&xobj, csi->xref, obj);
 		if (error)
-			return fz_rethrow(error, "cannot load xobject (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+			return fz_error_note(error, "cannot load xobject (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
 
 		/* Inherit parent resources, in case this one was empty XXX check where it's loaded */
 		if (!xobj->resources)
@@ -1421,7 +1421,7 @@ static fz_error pdf_run_Do(pdf_csi *csi, fz_obj *rdb)
 
 		error = pdf_run_xobject(csi, xobj->resources, xobj, fz_identity);
 		if (error)
-			return fz_rethrow(error, "cannot draw xobject (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+			return fz_error_note(error, "cannot draw xobject (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
 
 		pdf_drop_xobject(xobj);
 	}
@@ -1433,7 +1433,7 @@ static fz_error pdf_run_Do(pdf_csi *csi, fz_obj *rdb)
 			fz_pixmap *img;
 			error = pdf_load_image(&img, csi->xref, obj);
 			if (error)
-				return fz_rethrow(error, "cannot load image (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+				return fz_error_note(error, "cannot load image (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
 			pdf_show_image(csi, img);
 			fz_drop_pixmap(img);
 		}
@@ -1446,7 +1446,7 @@ static fz_error pdf_run_Do(pdf_csi *csi, fz_obj *rdb)
 
 	else
 	{
-		return fz_throw("unknown XObject subtype: '%s'", fz_to_name(subtype));
+		return fz_error_make("unknown XObject subtype: '%s'", fz_to_name(subtype));
 	}
 
 	return fz_okay;
@@ -1534,7 +1534,7 @@ static fz_error pdf_run_SC_imp(pdf_csi *csi, fz_obj *rdb, int what, pdf_material
 	switch (kind)
 	{
 	case PDF_MAT_NONE:
-		return fz_throw("cannot set color in mask objects");
+		return fz_error_make("cannot set color in mask objects");
 
 	case PDF_MAT_COLOR:
 		pdf_set_color(csi, what, csi->stack);
@@ -1543,11 +1543,11 @@ static fz_error pdf_run_SC_imp(pdf_csi *csi, fz_obj *rdb, int what, pdf_material
 	case PDF_MAT_PATTERN:
 		dict = fz_dict_gets(rdb, "Pattern");
 		if (!dict)
-			return fz_throw("cannot find Pattern dictionary");
+			return fz_error_make("cannot find Pattern dictionary");
 
 		obj = fz_dict_gets(dict, csi->name);
 		if (!obj)
-			return fz_throw("cannot find pattern resource '%s'", csi->name);
+			return fz_error_make("cannot find pattern resource '%s'", csi->name);
 
 		patterntype = fz_dict_gets(obj, "PatternType");
 
@@ -1556,7 +1556,7 @@ static fz_error pdf_run_SC_imp(pdf_csi *csi, fz_obj *rdb, int what, pdf_material
 			pdf_pattern *pat;
 			error = pdf_load_pattern(&pat, csi->xref, obj);
 			if (error)
-				return fz_rethrow(error, "cannot load pattern (%d 0 R)", fz_to_num(obj));
+				return fz_error_note(error, "cannot load pattern (%d 0 R)", fz_to_num(obj));
 			pdf_set_pattern(csi, what, pat, csi->top > 0 ? csi->stack : NULL);
 			pdf_drop_pattern(pat);
 		}
@@ -1565,18 +1565,18 @@ static fz_error pdf_run_SC_imp(pdf_csi *csi, fz_obj *rdb, int what, pdf_material
 			fz_shade *shd;
 			error = pdf_load_shading(&shd, csi->xref, obj);
 			if (error)
-				return fz_rethrow(error, "cannot load shading (%d 0 R)", fz_to_num(obj));
+				return fz_error_note(error, "cannot load shading (%d 0 R)", fz_to_num(obj));
 			pdf_set_shade(csi, what, shd);
 			fz_drop_shade(shd);
 		}
 		else
 		{
-			return fz_throw("unknown pattern type: %d", fz_to_int(patterntype));
+			return fz_error_make("unknown pattern type: %d", fz_to_int(patterntype));
 		}
 		break;
 
 	case PDF_MAT_SHADE:
-		return fz_throw("cannot set color in shade objects");
+		return fz_error_make("cannot set color in shade objects");
 	}
 
 	return fz_okay;
@@ -1588,7 +1588,7 @@ static void pdf_run_SC(pdf_csi *csi, fz_obj *rdb)
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
 	error = pdf_run_SC_imp(csi, rdb, PDF_STROKE, &gstate->stroke);
 	if (error)
-		fz_catch(error, "cannot set color and colorspace");
+		fz_error_handle(error, "cannot set color and colorspace");
 }
 
 static void pdf_run_sc(pdf_csi *csi, fz_obj *rdb)
@@ -1597,7 +1597,7 @@ static void pdf_run_sc(pdf_csi *csi, fz_obj *rdb)
 	pdf_gstate *gstate = csi->gstate + csi->gtop;
 	error = pdf_run_SC_imp(csi, rdb, PDF_FILL, &gstate->fill);
 	if (error)
-		fz_catch(error, "cannot set color and colorspace");
+		fz_error_handle(error, "cannot set color and colorspace");
 }
 
 static void pdf_run_Tc(pdf_csi *csi)
@@ -1640,15 +1640,15 @@ static fz_error pdf_run_Tf(pdf_csi *csi, fz_obj *rdb)
 
 	dict = fz_dict_gets(rdb, "Font");
 	if (!dict)
-		return fz_throw("cannot find Font dictionary");
+		return fz_error_make("cannot find Font dictionary");
 
 	obj = fz_dict_gets(dict, csi->name);
 	if (!obj)
-		return fz_throw("cannot find font resource: '%s'", csi->name);
+		return fz_error_make("cannot find font resource: '%s'", csi->name);
 
 	error = pdf_load_font(&gstate->font, csi->xref, rdb, obj);
 	if (error)
-		return fz_rethrow(error, "cannot load font (%d 0 R)", fz_to_num(obj));
+		return fz_error_note(error, "cannot load font (%d 0 R)", fz_to_num(obj));
 
 	return fz_okay;
 }
@@ -1812,15 +1812,15 @@ static fz_error pdf_run_gs(pdf_csi *csi, fz_obj *rdb)
 
 	dict = fz_dict_gets(rdb, "ExtGState");
 	if (!dict)
-		return fz_throw("cannot find ExtGState dictionary");
+		return fz_error_make("cannot find ExtGState dictionary");
 
 	obj = fz_dict_gets(dict, csi->name);
 	if (!obj)
-		return fz_throw("cannot find extgstate resource '%s'", csi->name);
+		return fz_error_make("cannot find extgstate resource '%s'", csi->name);
 
 	error = pdf_run_extgstate(csi, rdb, obj);
 	if (error)
-		return fz_rethrow(error, "cannot set ExtGState (%d 0 R)", fz_to_num(obj));
+		return fz_error_note(error, "cannot set ExtGState (%d 0 R)", fz_to_num(obj));
 	return fz_okay;
 }
 
@@ -1911,17 +1911,17 @@ static fz_error pdf_run_sh(pdf_csi *csi, fz_obj *rdb)
 
 	dict = fz_dict_gets(rdb, "Shading");
 	if (!dict)
-		return fz_throw("cannot find shading dictionary");
+		return fz_error_make("cannot find shading dictionary");
 
 	obj = fz_dict_gets(dict, csi->name);
 	if (!obj)
-		return fz_throw("cannot find shading resource: '%s'", csi->name);
+		return fz_error_make("cannot find shading resource: '%s'", csi->name);
 
 	if ((csi->dev->hints & FZ_IGNORE_SHADE) == 0)
 	{
 		error = pdf_load_shading(&shd, csi->xref, obj);
 		if (error)
-			return fz_rethrow(error, "cannot load shading (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+			return fz_error_note(error, "cannot load shading (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
 		pdf_show_shade(csi, shd);
 		fz_drop_shade(shd);
 	}
@@ -2020,7 +2020,7 @@ pdf_run_keyword(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf)
 	case B('B','I'):
 		error = pdf_run_BI(csi, rdb, file);
 		if (error)
-			return fz_rethrow(error, "cannot draw inline image");
+			return fz_error_note(error, "cannot draw inline image");
 		break;
 	case C('B','M','C'): pdf_run_BMC(csi); break;
 	case B('B','T'): pdf_run_BT(csi); break;
@@ -2030,7 +2030,7 @@ pdf_run_keyword(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf)
 	case B('D','o'):
 		error = pdf_run_Do(csi, rdb);
 		if (error)
-			fz_catch(error, "cannot draw xobject/image");
+			fz_error_handle(error, "cannot draw xobject/image");
 		break;
 	case C('E','M','C'): pdf_run_EMC(csi); break;
 	case B('E','T'): pdf_run_ET(csi); break;
@@ -2055,7 +2055,7 @@ pdf_run_keyword(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf)
 	case B('T','f'):
 		error = pdf_run_Tf(csi, rdb);
 		if (error)
-			fz_catch(error, "cannot set font");
+			fz_error_handle(error, "cannot set font");
 		break;
 	case B('T','j'): pdf_run_Tj(csi); break;
 	case B('T','m'): pdf_run_Tm(csi); break;
@@ -2079,7 +2079,7 @@ pdf_run_keyword(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf)
 	case B('g','s'):
 		error = pdf_run_gs(csi, rdb);
 		if (error)
-			fz_catch(error, "cannot set graphics state");
+			fz_error_handle(error, "cannot set graphics state");
 		break;
 	case A('h'): pdf_run_h(csi); break;
 	case A('i'): pdf_run_i(csi); break;
@@ -2098,7 +2098,7 @@ pdf_run_keyword(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf)
 	case B('s','h'):
 		error = pdf_run_sh(csi, rdb);
 		if (error)
-			fz_catch(error, "cannot draw shading");
+			fz_error_handle(error, "cannot draw shading");
 		break;
 	case A('v'): pdf_run_v(csi); break;
 	case A('w'): pdf_run_w(csi); break;
@@ -2125,11 +2125,11 @@ pdf_run_stream(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf, int buflen
 	while (1)
 	{
 		if (csi->top == nelem(csi->stack) - 1)
-			return fz_throw("stack overflow");
+			return fz_error_make("stack overflow");
 
 		error = pdf_lex(&tok, file, buf, buflen, &len);
 		if (error)
-			return fz_rethrow(error, "lexical error in content stream");
+			return fz_error_note(error, "lexical error in content stream");
 
 		if (in_array)
 		{
@@ -2151,12 +2151,12 @@ pdf_run_stream(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf, int buflen
 				if (!strcmp(buf, "Tw") || !strcmp(buf, "Tc"))
 					fz_warn("ignoring keyword '%s' inside array", buf);
 				else
-					return fz_throw("syntax error in array");
+					return fz_error_make("syntax error in array");
 			}
 			else if (tok == PDF_TOK_EOF)
 				return fz_okay;
 			else
-				return fz_throw("syntax error in array");
+				return fz_error_make("syntax error in array");
 		}
 
 		else switch (tok)
@@ -2170,7 +2170,7 @@ pdf_run_stream(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf, int buflen
 			{
 				error = pdf_parse_array(&csi->obj, csi->xref, file, buf, buflen);
 				if (error)
-					return fz_rethrow(error, "cannot parse array");
+					return fz_error_note(error, "cannot parse array");
 			}
 			else
 			{
@@ -2181,7 +2181,7 @@ pdf_run_stream(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf, int buflen
 		case PDF_TOK_OPEN_DICT:
 			error = pdf_parse_dict(&csi->obj, csi->xref, file, buf, buflen);
 			if (error)
-				return fz_rethrow(error, "cannot parse dictionary");
+				return fz_error_note(error, "cannot parse dictionary");
 			break;
 
 		case PDF_TOK_NAME:
@@ -2213,12 +2213,12 @@ pdf_run_stream(pdf_csi *csi, fz_obj *rdb, fz_stream *file, char *buf, int buflen
 		case PDF_TOK_KEYWORD:
 			error = pdf_run_keyword(csi, rdb, file, buf);
 			if (error)
-				return fz_rethrow(error, "cannot run keyword");
+				return fz_error_note(error, "cannot run keyword");
 			pdf_clear_stack(csi);
 			break;
 
 		default:
-			return fz_throw("syntax error in content stream");
+			return fz_error_make("syntax error in content stream");
 		}
 	}
 }
@@ -2241,7 +2241,7 @@ pdf_run_buffer(pdf_csi *csi, fz_obj *rdb, fz_buffer *contents)
 	fz_close(file);
 	fz_free(buf);
 	if (error)
-		return fz_rethrow(error, "cannot parse content stream");
+		return fz_error_note(error, "cannot parse content stream");
 	return fz_okay;
 }
 
@@ -2260,7 +2260,7 @@ pdf_run_page_with_usage(pdf_xref *xref, pdf_page *page, fz_device *dev, fz_matri
 	error = pdf_run_buffer(csi, page->resources, page->contents);
 	pdf_free_csi(csi);
 	if (error)
-		return fz_rethrow(error, "cannot parse page content stream");
+		return fz_error_note(error, "cannot parse page content stream");
 
 	for (annot = page->annots; annot; annot = annot->next)
 	{
@@ -2281,7 +2281,7 @@ pdf_run_page_with_usage(pdf_xref *xref, pdf_page *page, fz_device *dev, fz_matri
 		error = pdf_run_xobject(csi, page->resources, annot->ap, annot->matrix);
 		pdf_free_csi(csi);
 		if (error)
-			return fz_rethrow(error, "cannot parse annotation appearance stream");
+			return fz_error_note(error, "cannot parse annotation appearance stream");
 	}
 
 	if (page->transparency)
@@ -2303,6 +2303,6 @@ pdf_run_glyph(pdf_xref *xref, fz_obj *resources, fz_buffer *contents, fz_device
 	fz_error error = pdf_run_buffer(csi, resources, contents);
 	pdf_free_csi(csi);
 	if (error)
-		return fz_rethrow(error, "cannot parse glyph content stream");
+		return fz_error_note(error, "cannot parse glyph content stream");
 	return fz_okay;
 }
diff --git a/pdf/pdf_lex.c b/pdf/pdf_lex.c
index 23a5781f..84f584b0 100644
--- a/pdf/pdf_lex.c
+++ b/pdf/pdf_lex.c
@@ -457,5 +457,5 @@ pdf_lex(int *tok, fz_stream *f, char *buf, int n, int *sl)
 
 cleanuperror:
 	*tok = PDF_TOK_ERROR;
-	return fz_throw("lexical error");
+	return fz_error_make("lexical error");
 }
diff --git a/pdf/pdf_page.c b/pdf/pdf_page.c
index 7837c4cf..d7eeb3cd 100644
--- a/pdf/pdf_page.c
+++ b/pdf/pdf_page.c
@@ -103,9 +103,9 @@ pdf_load_page_tree(pdf_xref *xref)
 	fz_obj *count = fz_dict_gets(pages, "Count");
 
 	if (!fz_is_dict(pages))
-		return fz_throw("missing page tree");
+		return fz_error_make("missing page tree");
 	if (!fz_is_int(count))
-		return fz_throw("missing page count");
+		return fz_error_make("missing page count");
 
 	xref->page_cap = fz_to_int(count);
 	xref->page_len = 0;
@@ -218,7 +218,7 @@ pdf_load_page_contents_array(fz_buffer **bigbufp, pdf_xref *xref, fz_obj *list)
 		error = pdf_load_stream(&one, xref, fz_to_num(stm), fz_to_gen(stm));
 		if (error)
 		{
-			fz_catch(error, "cannot load content stream part %d/%d", i + 1, n);
+			fz_error_handle(error, "cannot load content stream part %d/%d", i + 1, n);
 			continue;
 		}
 
@@ -234,7 +234,7 @@ pdf_load_page_contents_array(fz_buffer **bigbufp, pdf_xref *xref, fz_obj *list)
 	if (n > 0 && big->len == 0)
 	{
 		fz_drop_buffer(big);
-		return fz_throw("cannot load content stream");
+		return fz_error_make("cannot load content stream");
 	}
 
 	*bigbufp = big;
@@ -250,13 +250,13 @@ pdf_load_page_contents(fz_buffer **bufp, pdf_xref *xref, fz_obj *obj)
 	{
 		error = pdf_load_page_contents_array(bufp, xref, obj);
 		if (error)
-			return fz_rethrow(error, "cannot load content stream array");
+			return fz_error_note(error, "cannot load content stream array");
 	}
 	else if (pdf_is_stream(xref, fz_to_num(obj), fz_to_gen(obj)))
 	{
 		error = pdf_load_stream(bufp, xref, fz_to_num(obj), fz_to_gen(obj));
 		if (error)
-			return fz_rethrow(error, "cannot load content stream (%d 0 R)", fz_to_num(obj));
+			return fz_error_note(error, "cannot load content stream (%d 0 R)", fz_to_num(obj));
 	}
 	else
 	{
@@ -278,7 +278,7 @@ pdf_load_page(pdf_page **pagep, pdf_xref *xref, int number)
 	fz_bbox bbox;
 
 	if (number < 0 || number >= xref->page_len)
-		return fz_throw("cannot find page %d", number + 1);
+		return fz_error_make("cannot find page %d", number + 1);
 
 	/* Ensure that we have a store for resource objects */
 	if (!xref->store)
@@ -341,7 +341,7 @@ pdf_load_page(pdf_page **pagep, pdf_xref *xref, int number)
 	if (error)
 	{
 		pdf_free_page(page);
-		return fz_rethrow(error, "cannot load page %d contents (%d 0 R)", number + 1, fz_to_num(pageref));
+		return fz_error_note(error, "cannot load page %d contents (%d 0 R)", number + 1, fz_to_num(pageref));
 	}
 
 	if (pdf_resources_use_blending(page->resources))
diff --git a/pdf/pdf_parse.c b/pdf/pdf_parse.c
index 54ed97c1..abbac2c6 100644
--- a/pdf/pdf_parse.c
+++ b/pdf/pdf_parse.c
@@ -188,7 +188,7 @@ pdf_parse_array(fz_obj **op, pdf_xref *xref, fz_stream *file, char *buf, int cap
 		if (error)
 		{
 			fz_drop_obj(ary);
-			return fz_rethrow(error, "cannot parse array");
+			return fz_error_note(error, "cannot parse array");
 		}
 
 		if (tok != PDF_TOK_INT && tok != PDF_TOK_R)
@@ -235,7 +235,7 @@ pdf_parse_array(fz_obj **op, pdf_xref *xref, fz_stream *file, char *buf, int cap
 			if (n != 2)
 			{
 				fz_drop_obj(ary);
-				return fz_throw("cannot parse indirect reference in array");
+				return fz_error_make("cannot parse indirect reference in array");
 			}
 			obj = fz_new_indirect(a, b, xref);
 			fz_array_push(ary, obj);
@@ -248,7 +248,7 @@ pdf_parse_array(fz_obj **op, pdf_xref *xref, fz_stream *file, char *buf, int cap
 			if (error)
 			{
 				fz_drop_obj(ary);
-				return fz_rethrow(error, "cannot parse array");
+				return fz_error_note(error, "cannot parse array");
 			}
 			fz_array_push(ary, obj);
 			fz_drop_obj(obj);
@@ -259,7 +259,7 @@ pdf_parse_array(fz_obj **op, pdf_xref *xref, fz_stream *file, char *buf, int cap
 			if (error)
 			{
 				fz_drop_obj(ary);
-				return fz_rethrow(error, "cannot parse array");
+				return fz_error_note(error, "cannot parse array");
 			}
 			fz_array_push(ary, obj);
 			fz_drop_obj(obj);
@@ -298,7 +298,7 @@ pdf_parse_array(fz_obj **op, pdf_xref *xref, fz_stream *file, char *buf, int cap
 
 		default:
 			fz_drop_obj(ary);
-			return fz_throw("cannot parse token in array");
+			return fz_error_make("cannot parse token in array");
 		}
 	}
 }
@@ -322,7 +322,7 @@ pdf_parse_dict(fz_obj **op, pdf_xref *xref, fz_stream *file, char *buf, int cap)
 		if (error)
 		{
 			fz_drop_obj(dict);
-			return fz_rethrow(error, "cannot parse dict");
+			return fz_error_note(error, "cannot parse dict");
 		}
 
 skip:
@@ -342,7 +342,7 @@ skip:
 		if (tok != PDF_TOK_NAME)
 		{
 			fz_drop_obj(dict);
-			return fz_throw("invalid key in dict");
+			return fz_error_make("invalid key in dict");
 		}
 
 		key = fz_new_name(buf);
@@ -352,7 +352,7 @@ skip:
 		{
 			fz_drop_obj(key);
 			fz_drop_obj(dict);
-			return fz_rethrow(error, "cannot parse dict");
+			return fz_error_note(error, "cannot parse dict");
 		}
 
 		switch (tok)
@@ -363,7 +363,7 @@ skip:
 			{
 				fz_drop_obj(key);
 				fz_drop_obj(dict);
-				return fz_rethrow(error, "cannot parse dict");
+				return fz_error_note(error, "cannot parse dict");
 			}
 			break;
 
@@ -373,7 +373,7 @@ skip:
 			{
 				fz_drop_obj(key);
 				fz_drop_obj(dict);
-				return fz_rethrow(error, "cannot parse dict");
+				return fz_error_note(error, "cannot parse dict");
 			}
 			break;
 
@@ -392,7 +392,7 @@ skip:
 			{
 				fz_drop_obj(key);
 				fz_drop_obj(dict);
-				return fz_rethrow(error, "cannot parse dict");
+				return fz_error_note(error, "cannot parse dict");
 			}
 			if (tok == PDF_TOK_CLOSE_DICT || tok == PDF_TOK_NAME ||
 				(tok == PDF_TOK_KEYWORD && !strcmp(buf, "ID")))
@@ -411,7 +411,7 @@ skip:
 				{
 					fz_drop_obj(key);
 					fz_drop_obj(dict);
-					return fz_rethrow(error, "cannot parse dict");
+					return fz_error_note(error, "cannot parse dict");
 				}
 				if (tok == PDF_TOK_R)
 				{
@@ -421,12 +421,12 @@ skip:
 			}
 			fz_drop_obj(key);
 			fz_drop_obj(dict);
-			return fz_throw("invalid indirect reference in dict");
+			return fz_error_make("invalid indirect reference in dict");
 
 		default:
 			fz_drop_obj(key);
 			fz_drop_obj(dict);
-			return fz_throw("unknown token in dict");
+			return fz_error_make("unknown token in dict");
 		}
 
 		fz_dict_put(dict, key, val);
@@ -444,19 +444,19 @@ pdf_parse_stm_obj(fz_obj **op, pdf_xref *xref, fz_stream *file, char *buf, int c
 
 	error = pdf_lex(&tok, file, buf, cap, &len);
 	if (error)
-		return fz_rethrow(error, "cannot parse token in object stream");
+		return fz_error_note(error, "cannot parse token in object stream");
 
 	switch (tok)
 	{
 	case PDF_TOK_OPEN_ARRAY:
 		error = pdf_parse_array(op, xref, file, buf, cap);
 		if (error)
-			return fz_rethrow(error, "cannot parse object stream");
+			return fz_error_note(error, "cannot parse object stream");
 		break;
 	case PDF_TOK_OPEN_DICT:
 		error = pdf_parse_dict(op, xref, file, buf, cap);
 		if (error)
-			return fz_rethrow(error, "cannot parse object stream");
+			return fz_error_note(error, "cannot parse object stream");
 		break;
 	case PDF_TOK_NAME: *op = fz_new_name(buf); break;
 	case PDF_TOK_REAL: *op = fz_new_real(fz_atof(buf)); break;
@@ -465,7 +465,7 @@ pdf_parse_stm_obj(fz_obj **op, pdf_xref *xref, fz_stream *file, char *buf, int c
 	case PDF_TOK_FALSE: *op = fz_new_bool(0); break;
 	case PDF_TOK_NULL: *op = fz_new_null(); break;
 	case PDF_TOK_INT: *op = fz_new_int(atoi(buf)); break;
-	default: return fz_throw("unknown token in object stream");
+	default: return fz_error_make("unknown token in object stream");
 	}
 
 	return fz_okay;
@@ -485,40 +485,40 @@ pdf_parse_ind_obj(fz_obj **op, pdf_xref *xref,
 
 	error = pdf_lex(&tok, file, buf, cap, &len);
 	if (error)
-		return fz_rethrow(error, "cannot parse indirect object (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot parse indirect object (%d %d R)", num, gen);
 	if (tok != PDF_TOK_INT)
-		return fz_throw("expected object number (%d %d R)", num, gen);
+		return fz_error_make("expected object number (%d %d R)", num, gen);
 	num = atoi(buf);
 
 	error = pdf_lex(&tok, file, buf, cap, &len);
 	if (error)
-		return fz_rethrow(error, "cannot parse indirect object (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot parse indirect object (%d %d R)", num, gen);
 	if (tok != PDF_TOK_INT)
-		return fz_throw("expected generation number (%d %d R)", num, gen);
+		return fz_error_make("expected generation number (%d %d R)", num, gen);
 	gen = atoi(buf);
 
 	error = pdf_lex(&tok, file, buf, cap, &len);
 	if (error)
-		return fz_rethrow(error, "cannot parse indirect object (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot parse indirect object (%d %d R)", num, gen);
 	if (tok != PDF_TOK_OBJ)
-		return fz_throw("expected 'obj' keyword (%d %d R)", num, gen);
+		return fz_error_make("expected 'obj' keyword (%d %d R)", num, gen);
 
 	error = pdf_lex(&tok, file, buf, cap, &len);
 	if (error)
-		return fz_rethrow(error, "cannot parse indirect object (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot parse indirect object (%d %d R)", num, gen);
 
 	switch (tok)
 	{
 	case PDF_TOK_OPEN_ARRAY:
 		error = pdf_parse_array(&obj, xref, file, buf, cap);
 		if (error)
-			return fz_rethrow(error, "cannot parse indirect object (%d %d R)", num, gen);
+			return fz_error_note(error, "cannot parse indirect object (%d %d R)", num, gen);
 		break;
 
 	case PDF_TOK_OPEN_DICT:
 		error = pdf_parse_dict(&obj, xref, file, buf, cap);
 		if (error)
-			return fz_rethrow(error, "cannot parse indirect object (%d %d R)", num, gen);
+			return fz_error_note(error, "cannot parse indirect object (%d %d R)", num, gen);
 		break;
 
 	case PDF_TOK_NAME: obj = fz_new_name(buf); break;
@@ -532,7 +532,7 @@ pdf_parse_ind_obj(fz_obj **op, pdf_xref *xref,
 		a = atoi(buf);
 		error = pdf_lex(&tok, file, buf, cap, &len);
 		if (error)
-			return fz_rethrow(error, "cannot parse indirect object (%d %d R)", num, gen);
+			return fz_error_note(error, "cannot parse indirect object (%d %d R)", num, gen);
 		if (tok == PDF_TOK_STREAM || tok == PDF_TOK_ENDOBJ)
 		{
 			obj = fz_new_int(a);
@@ -543,28 +543,28 @@ pdf_parse_ind_obj(fz_obj **op, pdf_xref *xref,
 			b = atoi(buf);
 			error = pdf_lex(&tok, file, buf, cap, &len);
 			if (error)
-				return fz_rethrow(error, "cannot parse indirect object (%d %d R)", num, gen);
+				return fz_error_note(error, "cannot parse indirect object (%d %d R)", num, gen);
 			if (tok == PDF_TOK_R)
 			{
 				obj = fz_new_indirect(a, b, xref);
 				break;
 			}
 		}
-		return fz_throw("expected 'R' keyword (%d %d R)", num, gen);
+		return fz_error_make("expected 'R' keyword (%d %d R)", num, gen);
 
 	case PDF_TOK_ENDOBJ:
 		obj = fz_new_null();
 		goto skip;
 
 	default:
-		return fz_throw("syntax error in object (%d %d R)", num, gen);
+		return fz_error_make("syntax error in object (%d %d R)", num, gen);
 	}
 
 	error = pdf_lex(&tok, file, buf, cap, &len);
 	if (error)
 	{
 		fz_drop_obj(obj);
-		return fz_rethrow(error, "cannot parse indirect object (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot parse indirect object (%d %d R)", num, gen);
 	}
 
 skip:
diff --git a/pdf/pdf_pattern.c b/pdf/pdf_pattern.c
index 33d84c99..418062d6 100644
--- a/pdf/pdf_pattern.c
+++ b/pdf/pdf_pattern.c
@@ -44,7 +44,7 @@ pdf_load_pattern(pdf_pattern **patp, pdf_xref *xref, fz_obj *dict)
 	{
 		pdf_remove_item(xref->store, pdf_drop_pattern, dict);
 		pdf_drop_pattern(pat);
-		return fz_rethrow(error, "cannot load pattern stream (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+		return fz_error_note(error, "cannot load pattern stream (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 	}
 
 	*patp = pat;
diff --git a/pdf/pdf_repair.c b/pdf/pdf_repair.c
index 067fe2cf..3b7d2a3d 100644
--- a/pdf/pdf_repair.c
+++ b/pdf/pdf_repair.c
@@ -28,7 +28,7 @@ pdf_repair_obj(fz_stream *file, char *buf, int cap, int *stmofsp, int *stmlenp,
 
 	error = pdf_lex(&tok, file, buf, cap, &len);
 	if (error)
-		return fz_rethrow(error, "cannot parse object");
+		return fz_error_note(error, "cannot parse object");
 	if (tok == PDF_TOK_OPEN_DICT)
 	{
 		fz_obj *dict, *obj;
@@ -36,7 +36,7 @@ pdf_repair_obj(fz_stream *file, char *buf, int cap, int *stmofsp, int *stmlenp,
 		/* Send NULL xref so we don't try to resolve references */
 		error = pdf_parse_dict(&dict, NULL, file, buf, cap);
 		if (error)
-			return fz_rethrow(error, "cannot parse object");
+			return fz_error_note(error, "cannot parse object");
 
 		obj = fz_dict_gets(dict, "Type");
 		if (fz_is_name(obj) && !strcmp(fz_to_name(obj), "XRef"))
@@ -72,7 +72,7 @@ pdf_repair_obj(fz_stream *file, char *buf, int cap, int *stmofsp, int *stmlenp,
 	{
 		error = pdf_lex(&tok, file, buf, cap, &len);
 		if (error)
-			return fz_rethrow(error, "cannot scan for endobj or stream token");
+			return fz_error_note(error, "cannot scan for endobj or stream token");
 	}
 
 	if (tok == PDF_TOK_STREAM)
@@ -86,14 +86,14 @@ pdf_repair_obj(fz_stream *file, char *buf, int cap, int *stmofsp, int *stmlenp,
 
 		*stmofsp = fz_tell(file);
 		if (*stmofsp < 0)
-			return fz_throw("cannot seek in file");
+			return fz_error_make("cannot seek in file");
 
 		if (stm_len > 0)
 		{
 			fz_seek(file, *stmofsp + stm_len, 0);
 			error = pdf_lex(&tok, file, buf, cap, &len);
 			if (error)
-				fz_catch(error, "cannot find endstream token, falling back to scanning");
+				fz_error_handle(error, "cannot find endstream token, falling back to scanning");
 			if (tok == PDF_TOK_ENDSTREAM)
 				goto atobjend;
 			fz_seek(file, *stmofsp, 0);
@@ -101,7 +101,7 @@ pdf_repair_obj(fz_stream *file, char *buf, int cap, int *stmofsp, int *stmlenp,
 
 		n = fz_read(file, (unsigned char *) buf, 9);
 		if (n < 0)
-			return fz_rethrow(n, "cannot read from file");
+			return fz_error_note(n, "cannot read from file");
 
 		while (memcmp(buf, "endstream", 9) != 0)
 		{
@@ -117,7 +117,7 @@ pdf_repair_obj(fz_stream *file, char *buf, int cap, int *stmofsp, int *stmlenp,
 atobjend:
 		error = pdf_lex(&tok, file, buf, cap, &len);
 		if (error)
-			return fz_rethrow(error, "cannot scan for endobj token");
+			return fz_error_note(error, "cannot scan for endobj token");
 		if (tok != PDF_TOK_ENDOBJ)
 			fz_warn("object missing 'endobj' token");
 	}
@@ -137,7 +137,7 @@ pdf_repair_obj_stm(pdf_xref *xref, int num, int gen)
 
 	error = pdf_load_object(&obj, xref, num, gen);
 	if (error)
-		return fz_rethrow(error, "cannot load object stream object (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot load object stream object (%d %d R)", num, gen);
 
 	count = fz_to_int(fz_dict_gets(obj, "N"));
 
@@ -145,7 +145,7 @@ pdf_repair_obj_stm(pdf_xref *xref, int num, int gen)
 
 	error = pdf_open_stream(&stm, xref, num, gen);
 	if (error)
-		return fz_rethrow(error, "cannot open object stream object (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot open object stream object (%d %d R)", num, gen);
 
 	for (i = 0; i < count; i++)
 	{
@@ -153,7 +153,7 @@ pdf_repair_obj_stm(pdf_xref *xref, int num, int gen)
 		if (error || tok != PDF_TOK_INT)
 		{
 			fz_close(stm);
-			return fz_rethrow(error, "corrupt object stream (%d %d R)", num, gen);
+			return fz_error_note(error, "corrupt object stream (%d %d R)", num, gen);
 		}
 
 		n = atoi(buf);
@@ -170,7 +170,7 @@ pdf_repair_obj_stm(pdf_xref *xref, int num, int gen)
 		if (error || tok != PDF_TOK_INT)
 		{
 			fz_close(stm);
-			return fz_rethrow(error, "corrupt object stream (%d %d R)", num, gen);
+			return fz_error_note(error, "corrupt object stream (%d %d R)", num, gen);
 		}
 	}
 
@@ -213,7 +213,7 @@ pdf_repair_xref(pdf_xref *xref, char *buf, int bufsize)
 	n = fz_read(xref->file, (unsigned char *)buf, MAX(bufsize, 1024));
 	if (n < 0)
 	{
-		error = fz_rethrow(n, "cannot read from file");
+		error = fz_error_note(n, "cannot read from file");
 		goto cleanup;
 	}
 
@@ -239,14 +239,14 @@ pdf_repair_xref(pdf_xref *xref, char *buf, int bufsize)
 		tmpofs = fz_tell(xref->file);
 		if (tmpofs < 0)
 		{
-			error = fz_throw("cannot tell in file");
+			error = fz_error_make("cannot tell in file");
 			goto cleanup;
 		}
 
 		error = pdf_lex(&tok, xref->file, buf, bufsize, &n);
 		if (error)
 		{
-			fz_catch(error, "ignoring the rest of the file");
+			fz_error_handle(error, "ignoring the rest of the file");
 			break;
 		}
 
@@ -263,7 +263,7 @@ pdf_repair_xref(pdf_xref *xref, char *buf, int bufsize)
 			error = pdf_repair_obj(xref->file, buf, bufsize, &stm_ofs, &stm_len, &encrypt, &id);
 			if (error)
 			{
-				error = fz_rethrow(error, "cannot parse object (%d %d R)", num, gen);
+				error = fz_error_note(error, "cannot parse object (%d %d R)", num, gen);
 				goto cleanup;
 			}
 
@@ -290,7 +290,7 @@ pdf_repair_xref(pdf_xref *xref, char *buf, int bufsize)
 			error = pdf_parse_dict(&dict, xref, xref->file, buf, bufsize);
 			if (error)
 			{
-				error = fz_rethrow(error, "cannot parse object");
+				error = fz_error_note(error, "cannot parse object");
 				goto cleanup;
 			}
 
@@ -354,7 +354,7 @@ pdf_repair_xref(pdf_xref *xref, char *buf, int bufsize)
 			error = pdf_load_object(&dict, xref, list[i].num, list[i].gen);
 			if (error)
 			{
-				error = fz_rethrow(error, "cannot load stream object (%d %d R)", list[i].num, list[i].gen);
+				error = fz_error_note(error, "cannot load stream object (%d %d R)", list[i].num, list[i].gen);
 				goto cleanup;
 			}
 
diff --git a/pdf/pdf_shade.c b/pdf/pdf_shade.c
index 1e0bf5ff..cd3ae0e3 100644
--- a/pdf/pdf_shade.c
+++ b/pdf/pdf_shade.c
@@ -987,13 +987,13 @@ pdf_load_shading_dict(fz_shade **shadep, pdf_xref *xref, fz_obj *dict, fz_matrix
 	if (!obj)
 	{
 		fz_drop_shade(shade);
-		return fz_throw("shading colorspace is missing");
+		return fz_error_make("shading colorspace is missing");
 	}
 	error = pdf_load_colorspace(&shade->colorspace, xref, obj);
 	if (error)
 	{
 		fz_drop_shade(shade);
-		return fz_rethrow(error, "cannot load colorspace (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+		return fz_error_note(error, "cannot load colorspace (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
 	}
 
 	obj = fz_dict_gets(dict, "Background");
@@ -1018,7 +1018,7 @@ pdf_load_shading_dict(fz_shade **shadep, pdf_xref *xref, fz_obj *dict, fz_matrix
 		error = pdf_load_function(&func[0], xref, obj);
 		if (error)
 		{
-			error = fz_rethrow(error, "cannot load shading function (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+			error = fz_error_note(error, "cannot load shading function (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
 			goto cleanup;
 		}
 	}
@@ -1027,7 +1027,7 @@ pdf_load_shading_dict(fz_shade **shadep, pdf_xref *xref, fz_obj *dict, fz_matrix
 		funcs = fz_array_len(obj);
 		if (funcs != 1 && funcs != shade->colorspace->n)
 		{
-			error = fz_throw("incorrect number of shading functions");
+			error = fz_error_make("incorrect number of shading functions");
 			goto cleanup;
 		}
 
@@ -1036,7 +1036,7 @@ pdf_load_shading_dict(fz_shade **shadep, pdf_xref *xref, fz_obj *dict, fz_matrix
 			error = pdf_load_function(&func[i], xref, fz_array_get(obj, i));
 			if (error)
 			{
-				error = fz_rethrow(error, "cannot load shading function (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+				error = fz_error_note(error, "cannot load shading function (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
 				goto cleanup;
 			}
 		}
@@ -1047,7 +1047,7 @@ pdf_load_shading_dict(fz_shade **shadep, pdf_xref *xref, fz_obj *dict, fz_matrix
 		error = pdf_open_stream(&stream, xref, fz_to_num(dict), fz_to_gen(dict));
 		if (error)
 		{
-			error = fz_rethrow(error, "cannot open shading stream (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+			error = fz_error_note(error, "cannot open shading stream (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 			goto cleanup;
 		}
 	}
@@ -1062,7 +1062,7 @@ pdf_load_shading_dict(fz_shade **shadep, pdf_xref *xref, fz_obj *dict, fz_matrix
 	case 6: pdf_load_type6_shade(shade, xref, dict, funcs, func, stream); break;
 	case 7: pdf_load_type7_shade(shade, xref, dict, funcs, func, stream); break;
 	default:
-		error = fz_throw("unknown shading type: %d", type);
+		error = fz_error_make("unknown shading type: %d", type);
 		goto cleanup;
 	}
 
@@ -1083,7 +1083,7 @@ cleanup:
 			pdf_drop_function(func[i]);
 	fz_drop_shade(shade);
 
-	return fz_rethrow(error, "cannot load shading type %d (%d %d R)", type, fz_to_num(dict), fz_to_gen(dict));
+	return fz_error_note(error, "cannot load shading type %d (%d %d R)", type, fz_to_num(dict), fz_to_gen(dict));
 }
 
 fz_error
@@ -1119,11 +1119,11 @@ pdf_load_shading(fz_shade **shadep, pdf_xref *xref, fz_obj *dict)
 
 		obj = fz_dict_gets(dict, "Shading");
 		if (!obj)
-			return fz_throw("syntaxerror: missing shading dictionary");
+			return fz_error_make("syntaxerror: missing shading dictionary");
 
 		error = pdf_load_shading_dict(shadep, xref, obj, mat);
 		if (error)
-			return fz_rethrow(error, "cannot load shading dictionary (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
+			return fz_error_note(error, "cannot load shading dictionary (%d %d R)", fz_to_num(obj), fz_to_gen(obj));
 	}
 
 	/* Naked shading dictionary */
@@ -1131,7 +1131,7 @@ pdf_load_shading(fz_shade **shadep, pdf_xref *xref, fz_obj *dict)
 	{
 		error = pdf_load_shading_dict(shadep, xref, dict, fz_identity);
 		if (error)
-			return fz_rethrow(error, "cannot load shading dictionary (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+			return fz_error_note(error, "cannot load shading dictionary (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 	}
 
 	pdf_store_item(xref->store, fz_keep_shade, fz_drop_shade, dict, *shadep);
diff --git a/pdf/pdf_stream.c b/pdf/pdf_stream.c
index c2dd8578..d0e3bad0 100644
--- a/pdf/pdf_stream.c
+++ b/pdf/pdf_stream.c
@@ -15,7 +15,7 @@ pdf_is_stream(pdf_xref *xref, int num, int gen)
 	error = pdf_cache_object(xref, num, gen);
 	if (error)
 	{
-		fz_catch(error, "cannot load object, ignoring error");
+		fz_error_handle(error, "cannot load object, ignoring error");
 		return 0;
 	}
 
@@ -100,7 +100,7 @@ build_filter(fz_stream *chain, pdf_xref * xref, fz_obj * f, fz_obj * p, int num,
 			fz_buffer *globals;
 			error = pdf_load_stream(&globals, xref, fz_to_num(obj), fz_to_gen(obj));
 			if (error)
-				fz_catch(error, "cannot load jbig2 global segments");
+				fz_error_handle(error, "cannot load jbig2 global segments");
 			chain = fz_open_jbig2d(chain, globals);
 			fz_drop_buffer(globals);
 			return chain;
@@ -236,13 +236,13 @@ pdf_open_raw_stream(fz_stream **stmp, pdf_xref *xref, int num, int gen)
 	fz_error error;
 
 	if (num < 0 || num >= xref->len)
-		return fz_throw("object id out of range (%d %d R)", num, gen);
+		return fz_error_make("object id out of range (%d %d R)", num, gen);
 
 	x = xref->table + num;
 
 	error = pdf_cache_object(xref, num, gen);
 	if (error)
-		return fz_rethrow(error, "cannot load stream object (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot load stream object (%d %d R)", num, gen);
 
 	if (x->stm_ofs)
 	{
@@ -251,7 +251,7 @@ pdf_open_raw_stream(fz_stream **stmp, pdf_xref *xref, int num, int gen)
 		return fz_okay;
 	}
 
-	return fz_throw("object is not a stream");
+	return fz_error_make("object is not a stream");
 }
 
 /*
@@ -266,13 +266,13 @@ pdf_open_stream(fz_stream **stmp, pdf_xref *xref, int num, int gen)
 	fz_error error;
 
 	if (num < 0 || num >= xref->len)
-		return fz_throw("object id out of range (%d %d R)", num, gen);
+		return fz_error_make("object id out of range (%d %d R)", num, gen);
 
 	x = xref->table + num;
 
 	error = pdf_cache_object(xref, num, gen);
 	if (error)
-		return fz_rethrow(error, "cannot load stream object (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot load stream object (%d %d R)", num, gen);
 
 	if (x->stm_ofs)
 	{
@@ -281,7 +281,7 @@ pdf_open_stream(fz_stream **stmp, pdf_xref *xref, int num, int gen)
 		return fz_okay;
 	}
 
-	return fz_throw("object is not a stream");
+	return fz_error_make("object is not a stream");
 }
 
 fz_error
@@ -293,7 +293,7 @@ pdf_open_stream_at(fz_stream **stmp, pdf_xref *xref, int num, int gen, fz_obj *d
 		fz_seek(xref->file, stm_ofs, 0);
 		return fz_okay;
 	}
-	return fz_throw("object is not a stream");
+	return fz_error_make("object is not a stream");
 }
 
 /*
@@ -309,7 +309,7 @@ pdf_load_raw_stream(fz_buffer **bufp, pdf_xref *xref, int num, int gen)
 
 	error = pdf_load_object(&dict, xref, num, gen);
 	if (error)
-		return fz_rethrow(error, "cannot load stream dictionary (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot load stream dictionary (%d %d R)", num, gen);
 
 	len = fz_to_int(fz_dict_gets(dict, "Length"));
 
@@ -317,13 +317,13 @@ pdf_load_raw_stream(fz_buffer **bufp, pdf_xref *xref, int num, int gen)
 
 	error = pdf_open_raw_stream(&stm, xref, num, gen);
 	if (error)
-		return fz_rethrow(error, "cannot open raw stream (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot open raw stream (%d %d R)", num, gen);
 
 	error = fz_read_all(bufp, stm, len);
 	if (error)
 	{
 		fz_close(stm);
-		return fz_rethrow(error, "cannot read raw stream (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot read raw stream (%d %d R)", num, gen);
 	}
 
 	fz_close(stm);
@@ -359,11 +359,11 @@ pdf_load_stream(fz_buffer **bufp, pdf_xref *xref, int num, int gen)
 
 	error = pdf_open_stream(&stm, xref, num, gen);
 	if (error)
-		return fz_rethrow(error, "cannot open stream (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot open stream (%d %d R)", num, gen);
 
 	error = pdf_load_object(&dict, xref, num, gen);
 	if (error)
-		return fz_rethrow(error, "cannot load stream dictionary (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot load stream dictionary (%d %d R)", num, gen);
 
 	len = fz_to_int(fz_dict_gets(dict, "Length"));
 	obj = fz_dict_gets(dict, "Filter");
@@ -377,7 +377,7 @@ pdf_load_stream(fz_buffer **bufp, pdf_xref *xref, int num, int gen)
 	if (error)
 	{
 		fz_close(stm);
-		return fz_rethrow(error, "cannot read raw stream (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot read raw stream (%d %d R)", num, gen);
 	}
 
 	fz_close(stm);
diff --git a/pdf/pdf_type3.c b/pdf/pdf_type3.c
index 1d851ebe..1d814ddd 100644
--- a/pdf/pdf_type3.c
+++ b/pdf/pdf_type3.c
@@ -49,7 +49,7 @@ pdf_load_type3_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *rdb, fz_o
 	encoding = fz_dict_gets(dict, "Encoding");
 	if (!encoding)
 	{
-		error = fz_throw("syntaxerror: Type3 font missing Encoding");
+		error = fz_error_make("syntaxerror: Type3 font missing Encoding");
 		goto cleanup;
 	}
 
@@ -98,7 +98,7 @@ pdf_load_type3_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *rdb, fz_o
 	widths = fz_dict_gets(dict, "Widths");
 	if (!widths)
 	{
-		error = fz_throw("syntaxerror: Type3 font missing Widths");
+		error = fz_error_make("syntaxerror: Type3 font missing Widths");
 		goto cleanup;
 	}
 
@@ -130,7 +130,7 @@ pdf_load_type3_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *rdb, fz_o
 	charprocs = fz_dict_gets(dict, "CharProcs");
 	if (!charprocs)
 	{
-		error = fz_throw("syntaxerror: Type3 font missing CharProcs");
+		error = fz_error_make("syntaxerror: Type3 font missing CharProcs");
 		goto cleanup;
 	}
 
@@ -154,5 +154,5 @@ pdf_load_type3_font(pdf_font_desc **fontdescp, pdf_xref *xref, fz_obj *rdb, fz_o
 cleanup:
 	fz_drop_font(fontdesc->font);
 	fz_free(fontdesc);
-	return fz_rethrow(error, "cannot load type3 font (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+	return fz_error_note(error, "cannot load type3 font (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 }
diff --git a/pdf/pdf_unicode.c b/pdf/pdf_unicode.c
index 2b28b608..3f27eeb7 100644
--- a/pdf/pdf_unicode.c
+++ b/pdf/pdf_unicode.c
@@ -18,7 +18,7 @@ pdf_load_to_unicode(pdf_font_desc *font, pdf_xref *xref,
 	{
 		error = pdf_load_embedded_cmap(&cmap, xref, cmapstm);
 		if (error)
-			return fz_rethrow(error, "cannot load embedded cmap (%d %d R)", fz_to_num(cmapstm), fz_to_gen(cmapstm));
+			return fz_error_note(error, "cannot load embedded cmap (%d %d R)", fz_to_num(cmapstm), fz_to_gen(cmapstm));
 
 		font->to_unicode = pdf_new_cmap();
 
@@ -54,7 +54,7 @@ pdf_load_to_unicode(pdf_font_desc *font, pdf_xref *xref,
 			error = pdf_load_system_cmap(&font->to_unicode, "Adobe-Korea1-UCS2");
 
 		if (error)
-			return fz_rethrow(error, "cannot load ToUnicode system cmap %s-UCS2", collection);
+			return fz_error_note(error, "cannot load ToUnicode system cmap %s-UCS2", collection);
 	}
 
 	if (strings)
diff --git a/pdf/pdf_xobject.c b/pdf/pdf_xobject.c
index 6228377f..630ca1d9 100644
--- a/pdf/pdf_xobject.c
+++ b/pdf/pdf_xobject.c
@@ -53,7 +53,7 @@ pdf_load_xobject(pdf_xobject **formp, pdf_xref *xref, fz_obj *dict)
 		{
 			error = pdf_load_colorspace(&form->colorspace, xref, obj);
 			if (error)
-				fz_catch(error, "cannot load xobject colorspace");
+				fz_error_handle(error, "cannot load xobject colorspace");
 		}
 	}
 
@@ -66,7 +66,7 @@ pdf_load_xobject(pdf_xobject **formp, pdf_xref *xref, fz_obj *dict)
 	{
 		pdf_remove_item(xref->store, pdf_drop_xobject, dict);
 		pdf_drop_xobject(form);
-		return fz_rethrow(error, "cannot load xobject content stream (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
+		return fz_error_note(error, "cannot load xobject content stream (%d %d R)", fz_to_num(dict), fz_to_gen(dict));
 	}
 
 	*formp = form;
diff --git a/pdf/pdf_xref.c b/pdf/pdf_xref.c
index bd25004e..2411ae99 100644
--- a/pdf/pdf_xref.c
+++ b/pdf/pdf_xref.c
@@ -20,7 +20,7 @@ pdf_load_version(pdf_xref *xref)
 	fz_seek(xref->file, 0, 0);
 	fz_read_line(xref->file, buf, sizeof buf);
 	if (memcmp(buf, "%PDF-", 5) != 0)
-		return fz_throw("cannot recognize version marker");
+		return fz_error_make("cannot recognize version marker");
 
 	xref->version = atoi(buf + 5) * 10 + atoi(buf + 7);
 
@@ -43,7 +43,7 @@ pdf_read_start_xref(pdf_xref *xref)
 
 	n = fz_read(xref->file, buf, sizeof buf);
 	if (n < 0)
-		return fz_rethrow(n, "cannot read from file");
+		return fz_error_note(n, "cannot read from file");
 
 	for (i = n - 9; i >= 0; i--)
 	{
@@ -57,7 +57,7 @@ pdf_read_start_xref(pdf_xref *xref)
 		}
 	}
 
-	return fz_throw("cannot find startxref");
+	return fz_error_make("cannot find startxref");
 }
 
 /*
@@ -77,7 +77,7 @@ pdf_read_old_trailer(pdf_xref *xref, char *buf, int cap)
 
 	fz_read_line(xref->file, buf, cap);
 	if (strncmp(buf, "xref", 4) != 0)
-		return fz_throw("cannot find xref marker");
+		return fz_error_make("cannot find xref marker");
 
 	while (1)
 	{
@@ -89,7 +89,7 @@ pdf_read_old_trailer(pdf_xref *xref, char *buf, int cap)
 		s = buf;
 		fz_strsep(&s, " "); /* ignore ofs */
 		if (!s)
-			return fz_throw("invalid range marker in xref");
+			return fz_error_make("invalid range marker in xref");
 		len = atoi(fz_strsep(&s, " "));
 
 		/* broken pdfs where the section is not on a separate line */
@@ -98,26 +98,26 @@ pdf_read_old_trailer(pdf_xref *xref, char *buf, int cap)
 
 		t = fz_tell(xref->file);
 		if (t < 0)
-			return fz_throw("cannot tell in file");
+			return fz_error_make("cannot tell in file");
 
 		fz_seek(xref->file, t + 20 * len, 0);
 	}
 
 	error = pdf_lex(&tok, xref->file, buf, cap, &n);
 	if (error)
-		return fz_rethrow(error, "cannot parse trailer");
+		return fz_error_note(error, "cannot parse trailer");
 	if (tok != PDF_TOK_TRAILER)
-		return fz_throw("expected trailer marker");
+		return fz_error_make("expected trailer marker");
 
 	error = pdf_lex(&tok, xref->file, buf, cap, &n);
 	if (error)
-		return fz_rethrow(error, "cannot parse trailer");
+		return fz_error_note(error, "cannot parse trailer");
 	if (tok != PDF_TOK_OPEN_DICT)
-		return fz_throw("expected trailer dictionary");
+		return fz_error_make("expected trailer dictionary");
 
 	error = pdf_parse_dict(&xref->trailer, xref, xref->file, buf, cap);
 	if (error)
-		return fz_rethrow(error, "cannot parse trailer");
+		return fz_error_note(error, "cannot parse trailer");
 	return fz_okay;
 }
 
@@ -127,7 +127,7 @@ pdf_read_new_trailer(pdf_xref *xref, char *buf, int cap)
 	fz_error error;
 	error = pdf_parse_ind_obj(&xref->trailer, xref, xref->file, buf, cap, NULL, NULL, NULL);
 	if (error)
-		return fz_rethrow(error, "cannot parse trailer (compressed)");
+		return fz_error_note(error, "cannot parse trailer (compressed)");
 	return fz_okay;
 }
 
@@ -147,17 +147,17 @@ pdf_read_trailer(pdf_xref *xref, char *buf, int cap)
 	{
 		error = pdf_read_old_trailer(xref, buf, cap);
 		if (error)
-			return fz_rethrow(error, "cannot read trailer");
+			return fz_error_note(error, "cannot read trailer");
 	}
 	else if (c >= '0' && c <= '9')
 	{
 		error = pdf_read_new_trailer(xref, buf, cap);
 		if (error)
-			return fz_rethrow(error, "cannot read trailer");
+			return fz_error_note(error, "cannot read trailer");
 	}
 	else
 	{
-		return fz_throw("cannot recognize xref format: '%c'", c);
+		return fz_error_make("cannot recognize xref format: '%c'", c);
 	}
 
 	return fz_okay;
@@ -197,7 +197,7 @@ pdf_read_old_xref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 
 	fz_read_line(xref->file, buf, cap);
 	if (strncmp(buf, "xref", 4) != 0)
-		return fz_throw("cannot find xref marker");
+		return fz_error_make("cannot find xref marker");
 
 	while (1)
 	{
@@ -228,7 +228,7 @@ pdf_read_old_xref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 		{
 			n = fz_read(xref->file, (unsigned char *) buf, 20);
 			if (n < 0)
-				return fz_rethrow(n, "cannot read xref table");
+				return fz_error_note(n, "cannot read xref table");
 			if (!xref->table[i].type)
 			{
 				s = buf;
@@ -241,26 +241,26 @@ pdf_read_old_xref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 				xref->table[i].gen = atoi(s + 11);
 				xref->table[i].type = s[17];
 				if (s[17] != 'f' && s[17] != 'n' && s[17] != 'o')
-					return fz_throw("unexpected xref type: %#x (%d %d R)", s[17], i, xref->table[i].gen);
+					return fz_error_make("unexpected xref type: %#x (%d %d R)", s[17], i, xref->table[i].gen);
 			}
 		}
 	}
 
 	error = pdf_lex(&tok, xref->file, buf, cap, &n);
 	if (error)
-		return fz_rethrow(error, "cannot parse trailer");
+		return fz_error_note(error, "cannot parse trailer");
 	if (tok != PDF_TOK_TRAILER)
-		return fz_throw("expected trailer marker");
+		return fz_error_make("expected trailer marker");
 
 	error = pdf_lex(&tok, xref->file, buf, cap, &n);
 	if (error)
-		return fz_rethrow(error, "cannot parse trailer");
+		return fz_error_note(error, "cannot parse trailer");
 	if (tok != PDF_TOK_OPEN_DICT)
-		return fz_throw("expected trailer dictionary");
+		return fz_error_make("expected trailer dictionary");
 
 	error = pdf_parse_dict(trailerp, xref, xref->file, buf, cap);
 	if (error)
-		return fz_rethrow(error, "cannot parse trailer");
+		return fz_error_note(error, "cannot parse trailer");
 	return fz_okay;
 }
 
@@ -270,7 +270,7 @@ pdf_read_new_xref_section(pdf_xref *xref, fz_stream *stm, int i0, int i1, int w0
 	int i, n;
 
 	if (i0 < 0 || i0 + i1 > xref->len)
-		return fz_throw("xref stream has too many entries");
+		return fz_error_make("xref stream has too many entries");
 
 	for (i = i0; i < i0 + i1; i++)
 	{
@@ -279,7 +279,7 @@ pdf_read_new_xref_section(pdf_xref *xref, fz_stream *stm, int i0, int i1, int w0
 		int c = 0;
 
 		if (fz_is_eof(stm))
-			return fz_throw("truncated xref stream");
+			return fz_error_make("truncated xref stream");
 
 		for (n = 0; n < w0; n++)
 			a = (a << 8) + fz_read_byte(stm);
@@ -314,13 +314,13 @@ pdf_read_new_xref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 
 	error = pdf_parse_ind_obj(&trailer, xref, xref->file, buf, cap, &num, &gen, &stm_ofs);
 	if (error)
-		return fz_rethrow(error, "cannot parse compressed xref stream object");
+		return fz_error_note(error, "cannot parse compressed xref stream object");
 
 	obj = fz_dict_gets(trailer, "Size");
 	if (!obj)
 	{
 		fz_drop_obj(trailer);
-		return fz_throw("xref stream missing Size entry (%d %d R)", num, gen);
+		return fz_error_make("xref stream missing Size entry (%d %d R)", num, gen);
 	}
 	size = fz_to_int(obj);
 
@@ -332,13 +332,13 @@ pdf_read_new_xref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 	if (num < 0 || num >= xref->len)
 	{
 		fz_drop_obj(trailer);
-		return fz_throw("object id (%d %d R) out of range (0..%d)", num, gen, xref->len - 1);
+		return fz_error_make("object id (%d %d R) out of range (0..%d)", num, gen, xref->len - 1);
 	}
 
 	obj = fz_dict_gets(trailer, "W");
 	if (!obj) {
 		fz_drop_obj(trailer);
-		return fz_throw("xref stream missing W entry (%d %d R)", num, gen);
+		return fz_error_make("xref stream missing W entry (%d %d R)", num, gen);
 	}
 	w0 = fz_to_int(fz_array_get(obj, 0));
 	w1 = fz_to_int(fz_array_get(obj, 1));
@@ -350,7 +350,7 @@ pdf_read_new_xref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 	if (error)
 	{
 		fz_drop_obj(trailer);
-		return fz_rethrow(error, "cannot open compressed xref stream (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot open compressed xref stream (%d %d R)", num, gen);
 	}
 
 	if (!index)
@@ -360,7 +360,7 @@ pdf_read_new_xref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 		{
 			fz_close(stm);
 			fz_drop_obj(trailer);
-			return fz_rethrow(error, "cannot read xref stream (%d %d R)", num, gen);
+			return fz_error_note(error, "cannot read xref stream (%d %d R)", num, gen);
 		}
 	}
 	else
@@ -374,7 +374,7 @@ pdf_read_new_xref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 			{
 				fz_close(stm);
 				fz_drop_obj(trailer);
-				return fz_rethrow(error, "cannot read xref stream section (%d %d R)", num, gen);
+				return fz_error_note(error, "cannot read xref stream section (%d %d R)", num, gen);
 			}
 		}
 	}
@@ -402,17 +402,17 @@ pdf_read_xref(fz_obj **trailerp, pdf_xref *xref, int ofs, char *buf, int cap)
 	{
 		error = pdf_read_old_xref(trailerp, xref, buf, cap);
 		if (error)
-			return fz_rethrow(error, "cannot read xref (ofs=%d)", ofs);
+			return fz_error_note(error, "cannot read xref (ofs=%d)", ofs);
 	}
 	else if (c >= '0' && c <= '9')
 	{
 		error = pdf_read_new_xref(trailerp, xref, buf, cap);
 		if (error)
-			return fz_rethrow(error, "cannot read xref (ofs=%d)", ofs);
+			return fz_error_note(error, "cannot read xref (ofs=%d)", ofs);
 	}
 	else
 	{
-		return fz_throw("cannot recognize xref format");
+		return fz_error_make("cannot recognize xref format");
 	}
 
 	return fz_okay;
@@ -428,7 +428,7 @@ pdf_read_xref_sections(pdf_xref *xref, int ofs, char *buf, int cap)
 
 	error = pdf_read_xref(&trailer, xref, ofs, buf, cap);
 	if (error)
-		return fz_rethrow(error, "cannot read xref section");
+		return fz_error_note(error, "cannot read xref section");
 
 	/* FIXME: do we overwrite free entries properly? */
 	xrefstm = fz_dict_gets(trailer, "XRefStm");
@@ -438,7 +438,7 @@ pdf_read_xref_sections(pdf_xref *xref, int ofs, char *buf, int cap)
 		if (error)
 		{
 			fz_drop_obj(trailer);
-			return fz_rethrow(error, "cannot read /XRefStm xref section");
+			return fz_error_note(error, "cannot read /XRefStm xref section");
 		}
 	}
 
@@ -449,7 +449,7 @@ pdf_read_xref_sections(pdf_xref *xref, int ofs, char *buf, int cap)
 		if (error)
 		{
 			fz_drop_obj(trailer);
-			return fz_rethrow(error, "cannot read /Prev xref section");
+			return fz_error_note(error, "cannot read /Prev xref section");
 		}
 	}
 
@@ -470,39 +470,39 @@ pdf_load_xref(pdf_xref *xref, char *buf, int bufsize)
 
 	error = pdf_load_version(xref);
 	if (error)
-		return fz_rethrow(error, "cannot read version marker");
+		return fz_error_note(error, "cannot read version marker");
 
 	error = pdf_read_start_xref(xref);
 	if (error)
-		return fz_rethrow(error, "cannot read startxref");
+		return fz_error_note(error, "cannot read startxref");
 
 	error = pdf_read_trailer(xref, buf, bufsize);
 	if (error)
-		return fz_rethrow(error, "cannot read trailer");
+		return fz_error_note(error, "cannot read trailer");
 
 	size = fz_dict_gets(xref->trailer, "Size");
 	if (!size)
-		return fz_throw("trailer missing Size entry");
+		return fz_error_make("trailer missing Size entry");
 
 	pdf_resize_xref(xref, fz_to_int(size));
 
 	error = pdf_read_xref_sections(xref, xref->startxref, buf, bufsize);
 	if (error)
-		return fz_rethrow(error, "cannot read xref");
+		return fz_error_note(error, "cannot read xref");
 
 	/* broken pdfs where first object is not free */
 	if (xref->table[0].type != 'f')
-		return fz_throw("first object in xref is not free");
+		return fz_error_make("first object in xref is not free");
 
 	/* broken pdfs where object offsets are out of range */
 	for (i = 0; i < xref->len; i++)
 	{
 		if (xref->table[i].type == 'n')
 			if (xref->table[i].ofs <= 0 || xref->table[i].ofs >= xref->file_size)
-				return fz_throw("object offset out of range: %d (%d 0 R)", xref->table[i].ofs, i);
+				return fz_error_make("object offset out of range: %d (%d 0 R)", xref->table[i].ofs, i);
 		if (xref->table[i].type == 'o')
 			if (xref->table[i].ofs <= 0 || xref->table[i].ofs >= xref->len || xref->table[xref->table[i].ofs].type != 'n')
-				return fz_throw("invalid reference to an objstm that does not exist: %d (%d 0 R)", xref->table[i].ofs, i);
+				return error_make("invalid reference to an objstm that does not exist: %d (%d 0 R)", xref->table[i].ofs, i);
 	}
 
 	return fz_okay;
@@ -534,7 +534,7 @@ pdf_open_xref_with_stream(pdf_xref **xrefp, fz_stream *file, char *password)
 	error = pdf_load_xref(xref, xref->scratch, sizeof xref->scratch);
 	if (error)
 	{
-		fz_catch(error, "trying to repair");
+		fz_error_handle(error, "trying to repair");
 		if (xref->table)
 		{
 			fz_free(xref->table);
@@ -550,7 +550,7 @@ pdf_open_xref_with_stream(pdf_xref **xrefp, fz_stream *file, char *password)
 		if (error)
 		{
 			pdf_free_xref(xref);
-			return fz_rethrow(error, "cannot repair document");
+			return fz_error_note(error, "cannot repair document");
 		}
 		repaired = 1;
 	}
@@ -563,7 +563,7 @@ pdf_open_xref_with_stream(pdf_xref **xrefp, fz_stream *file, char *password)
 		if (error)
 		{
 			pdf_free_xref(xref);
-			return fz_rethrow(error, "cannot decrypt document");
+			return fz_error_note(error, "cannot decrypt document");
 		}
 	}
 
@@ -576,7 +576,7 @@ pdf_open_xref_with_stream(pdf_xref **xrefp, fz_stream *file, char *password)
 			if (!okay)
 			{
 				pdf_free_xref(xref);
-				return fz_throw("invalid password");
+				return fz_error_make("invalid password");
 			}
 		}
 	}
@@ -589,7 +589,7 @@ pdf_open_xref_with_stream(pdf_xref **xrefp, fz_stream *file, char *password)
 		if (error)
 		{
 			pdf_free_xref(xref);
-			return fz_rethrow(error, "cannot repair document");
+			return fz_error_note(error, "cannot repair document");
 		}
 
 		hasroot = fz_dict_gets(xref->trailer, "Root") != NULL;
@@ -603,7 +603,7 @@ pdf_open_xref_with_stream(pdf_xref **xrefp, fz_stream *file, char *password)
 			error = pdf_load_object(&dict, xref, i, 0);
 			if (error)
 			{
-				fz_catch(error, "ignoring broken object (%d 0 R)", i);
+				fz_error_handle(error, "ignoring broken object (%d 0 R)", i);
 				continue;
 			}
 
@@ -717,7 +717,7 @@ pdf_load_obj_stm(pdf_xref *xref, int num, int gen, char *buf, int cap)
 
 	error = pdf_load_object(&objstm, xref, num, gen);
 	if (error)
-		return fz_rethrow(error, "cannot load object stream object (%d %d R)", num, gen);
+		return fz_error_note(error, "cannot load object stream object (%d %d R)", num, gen);
 
 	count = fz_to_int(fz_dict_gets(objstm, "N"));
 	first = fz_to_int(fz_dict_gets(objstm, "First"));
@@ -728,7 +728,7 @@ pdf_load_obj_stm(pdf_xref *xref, int num, int gen, char *buf, int cap)
 	error = pdf_open_stream(&stm, xref, num, gen);
 	if (error)
 	{
-		error = fz_rethrow(error, "cannot open object stream (%d %d R)", num, gen);
+		error = fz_error_note(error, "cannot open object stream (%d %d R)", num, gen);
 		goto cleanupbuf;
 	}
 
@@ -737,7 +737,7 @@ pdf_load_obj_stm(pdf_xref *xref, int num, int gen, char *buf, int cap)
 		error = pdf_lex(&tok, stm, buf, cap, &n);
 		if (error || tok != PDF_TOK_INT)
 		{
-			error = fz_rethrow(error, "corrupt object stream (%d %d R)", num, gen);
+			error = fz_error_note(error, "corrupt object stream (%d %d R)", num, gen);
 			goto cleanupstm;
 		}
 		numbuf[i] = atoi(buf);
@@ -745,7 +745,7 @@ pdf_load_obj_stm(pdf_xref *xref, int num, int gen, char *buf, int cap)
 		error = pdf_lex(&tok, stm, buf, cap, &n);
 		if (error || tok != PDF_TOK_INT)
 		{
-			error = fz_rethrow(error, "corrupt object stream (%d %d R)", num, gen);
+			error = fz_error_note(error, "corrupt object stream (%d %d R)", num, gen);
 			goto cleanupstm;
 		}
 		ofsbuf[i] = atoi(buf);
@@ -760,14 +760,14 @@ pdf_load_obj_stm(pdf_xref *xref, int num, int gen, char *buf, int cap)
 		error = pdf_parse_stm_obj(&obj, xref, stm, buf, cap);
 		if (error)
 		{
-			error = fz_rethrow(error, "cannot parse object %d in stream (%d %d R)", i, num, gen);
+			error = fz_error_note(error, "cannot parse object %d in stream (%d %d R)", i, num, gen);
 			goto cleanupstm;
 		}
 
 		if (numbuf[i] < 1 || numbuf[i] >= xref->len)
 		{
 			fz_drop_obj(obj);
-			error = fz_throw("object id (%d 0 R) out of range (0..%d)", numbuf[i], xref->len - 1);
+			error = fz_error_make("object id (%d 0 R) out of range (0..%d)", numbuf[i], xref->len - 1);
 			goto cleanupstm;
 		}
 
@@ -810,7 +810,7 @@ pdf_cache_object(pdf_xref *xref, int num, int gen)
 	int rnum, rgen;
 
 	if (num < 0 || num >= xref->len)
-		return fz_throw("object out of range (%d %d R); xref size %d", num, gen, xref->len);
+		return fz_error_make("object out of range (%d %d R); xref size %d", num, gen, xref->len);
 
 	x = &xref->table[num];
 
@@ -829,10 +829,10 @@ pdf_cache_object(pdf_xref *xref, int num, int gen)
 		error = pdf_parse_ind_obj(&x->obj, xref, xref->file, xref->scratch, sizeof xref->scratch,
 			&rnum, &rgen, &x->stm_ofs);
 		if (error)
-			return fz_rethrow(error, "cannot parse object (%d %d R)", num, gen);
+			return fz_error_note(error, "cannot parse object (%d %d R)", num, gen);
 
 		if (rnum != num)
-			return fz_throw("found object (%d %d R) instead of (%d %d R)", rnum, rgen, num, gen);
+			return fz_error_make("found object (%d %d R) instead of (%d %d R)", rnum, rgen, num, gen);
 
 		if (xref->crypt)
 			pdf_crypt_obj(xref->crypt, x->obj, num, gen);
@@ -843,14 +843,14 @@ pdf_cache_object(pdf_xref *xref, int num, int gen)
 		{
 			error = pdf_load_obj_stm(xref, x->ofs, 0, xref->scratch, sizeof xref->scratch);
 			if (error)
-				return fz_rethrow(error, "cannot load object stream containing object (%d %d R)", num, gen);
+				return fz_error_note(error, "cannot load object stream containing object (%d %d R)", num, gen);
 			if (!x->obj)
-				return fz_throw("object (%d %d R) was not found in its object stream", num, gen);
+				return fz_error_make("object (%d %d R) was not found in its object stream", num, gen);
 		}
 	}
 	else
 	{
-		return fz_throw("assert: corrupt xref struct");
+		return fz_error_make("assert: corrupt xref struct");
 	}
 
 	return fz_okay;
@@ -863,7 +863,7 @@ pdf_load_object(fz_obj **objp, pdf_xref *xref, int num, int gen)
 
 	error = pdf_cache_object(xref, num, gen);
 	if (error)
-		return fz_rethrow(error, "cannot load object (%d %d R) into cache", num, gen);
+		return fz_error_note(error, "cannot load object (%d %d R) into cache", num, gen);
 
 	assert(xref->table[num].obj);
 
@@ -885,7 +885,7 @@ pdf_resolve_indirect(fz_obj *ref)
 			fz_error error = pdf_cache_object(xref, num, gen);
 			if (error)
 			{
-				fz_catch(error, "cannot load object (%d %d R) into cache", num, gen);
+				fz_error_handle(error, "cannot load object (%d %d R) into cache", num, gen);
 				return ref;
 			}
 			if (xref->table[num].obj)
@@ -929,11 +929,11 @@ pdf_open_xref(pdf_xref **xrefp, const char *filename, char *password)
 
 	file = fz_open_file(filename);
 	if (!file)
-		return fz_throw("cannot open file '%s': %s", filename, strerror(errno));
+		return fz_error_make("cannot open file '%s': %s", filename, strerror(errno));
 
 	error = pdf_open_xref_with_stream(xrefp, file, password);
 	if (error)
-		return fz_rethrow(error, "cannot load document '%s'", filename);
+		return fz_error_note(error, "cannot load document '%s'", filename);
 
 	fz_close(file);
 	return fz_okay;
diff --git a/scripts/cmapdump.c b/scripts/cmapdump.c
index dfb3faa0..b1e91f9b 100644
--- a/scripts/cmapdump.c
+++ b/scripts/cmapdump.c
@@ -78,12 +78,12 @@ main(int argc, char **argv)
 
 		fi = fz_open_file(argv[i]);
 		if (!fi)
-			fz_throw("cmapdump: could not open input file '%s'\n", argv[i]);
+			fz_error_make("cmapdump: could not open input file '%s'\n", argv[i]);
 
 		error = pdf_parse_cmap(&cmap, fi);
 		if (error)
 		{
-			fz_catch(error, "cmapdump: could not parse input cmap '%s'\n", argv[i]);
+			fz_error_handle(error, "cmapdump: could not parse input cmap '%s'\n", argv[i]);
 			return 1;
 		}
 
diff --git a/xps/xps_doc.c b/xps/xps_doc.c
index 5719e7f8..c704ec40 100644
--- a/xps/xps_doc.c
+++ b/xps/xps_doc.c
@@ -201,7 +201,7 @@ xps_parse_metadata(xps_context *ctx, xps_part *part)
 
 	root = xml_parse_document(part->data, part->size);
 	if (!root)
-		return fz_rethrow(-1, "cannot parse metadata part '%s'", part->name);
+		return fz_error_note(-1, "cannot parse metadata part '%s'", part->name);
 
 	xps_parse_metadata_imp(ctx, root);
 
@@ -221,11 +221,11 @@ xps_read_and_process_metadata_part(xps_context *ctx, char *name)
 
 	part = xps_read_part(ctx, name);
 	if (!part)
-		return fz_rethrow(-1, "cannot read zip part '%s'", name);
+		return fz_error_note(-1, "cannot read zip part '%s'", name);
 
 	code = xps_parse_metadata(ctx, part);
 	if (code)
-		return fz_rethrow(code, "cannot process metadata part '%s'", name);
+		return fz_error_note(code, "cannot process metadata part '%s'", name);
 
 	xps_free_part(ctx, part);
 
@@ -240,20 +240,20 @@ xps_read_page_list(xps_context *ctx)
 
 	code = xps_read_and_process_metadata_part(ctx, "/_rels/.rels");
 	if (code)
-		return fz_rethrow(code, "cannot process root relationship part");
+		return fz_error_note(code, "cannot process root relationship part");
 
 	if (!ctx->start_part)
-		return fz_throw("cannot find fixed document sequence start part");
+		return fz_error_make("cannot find fixed document sequence start part");
 
 	code = xps_read_and_process_metadata_part(ctx, ctx->start_part);
 	if (code)
-		return fz_rethrow(code, "cannot process FixedDocumentSequence part");
+		return fz_error_note(code, "cannot process FixedDocumentSequence part");
 
 	for (doc = ctx->first_fixdoc; doc; doc = doc->next)
 	{
 		code = xps_read_and_process_metadata_part(ctx, doc->name);
 		if (code)
-			return fz_rethrow(code, "cannot process FixedDocument part");
+			return fz_error_note(code, "cannot process FixedDocument part");
 	}
 
 	return fz_okay;
@@ -279,24 +279,24 @@ xps_load_fixed_page(xps_context *ctx, xps_page *page)
 
 	part = xps_read_part(ctx, page->name);
 	if (!part)
-		return fz_rethrow(-1, "cannot read zip part '%s'", page->name);
+		return fz_error_note(-1, "cannot read zip part '%s'", page->name);
 
 	root = xml_parse_document(part->data, part->size);
 	if (!root)
-		return fz_rethrow(-1, "cannot parse xml part '%s'", page->name);
+		return fz_error_note(-1, "cannot parse xml part '%s'", page->name);
 
 	xps_free_part(ctx, part);
 
 	if (strcmp(xml_tag(root), "FixedPage"))
-		return fz_throw("expected FixedPage element (found %s)", xml_tag(root));
+		return fz_error_make("expected FixedPage element (found %s)", xml_tag(root));
 
 	width_att = xml_att(root, "Width");
 	if (!width_att)
-		return fz_throw("FixedPage missing required attribute: Width");
+		return fz_error_make("FixedPage missing required attribute: Width");
 
 	height_att = xml_att(root, "Height");
 	if (!height_att)
-		return fz_throw("FixedPage missing required attribute: Height");
+		return fz_error_make("FixedPage missing required attribute: Height");
 
 	page->width = atoi(width_att);
 	page->height = atoi(height_att);
@@ -320,7 +320,7 @@ xps_load_page(xps_page **pagep, xps_context *ctx, int number)
 			{
 				code = xps_load_fixed_page(ctx, page);
 				if (code)
-					return fz_rethrow(code, "cannot load page %d", number + 1);
+					return fz_error_note(code, "cannot load page %d", number + 1);
 			}
 			*pagep = page;
 			return fz_okay;
@@ -328,7 +328,7 @@ xps_load_page(xps_page **pagep, xps_context *ctx, int number)
 		n ++;
 	}
 
-	return fz_throw("cannot find page %d", number + 1);
+	return fz_error_make("cannot find page %d", number + 1);
 }
 
 void
diff --git a/xps/xps_glyphs.c b/xps/xps_glyphs.c
index 4b7a8ceb..50cde1e3 100644
--- a/xps/xps_glyphs.c
+++ b/xps/xps_glyphs.c
@@ -498,7 +498,7 @@ xps_parse_glyphs(xps_context *ctx, fz_matrix ctm,
 
 		code = fz_new_font_from_memory(&font, part->data, part->size, subfontid);
 		if (code) {
-			fz_catch(code, "cannot load font resource '%s'", partname);
+			fz_error_handle(code, "cannot load font resource '%s'", partname);
 			xps_free_part(ctx, part);
 			return;
 		}
diff --git a/xps/xps_image.c b/xps/xps_image.c
index 4a347435..5a9d7b13 100644
--- a/xps/xps_image.c
+++ b/xps/xps_image.c
@@ -7,32 +7,32 @@ xps_decode_image(fz_pixmap **imagep, byte *buf, int len)
 	int error;
 
 	if (len < 8)
-		return fz_throw("unknown image file format");
+		return fz_error_make("unknown image file format");
 
 	if (buf[0] == 0xff && buf[1] == 0xd8)
 	{
 		error = xps_decode_jpeg(imagep, buf, len);
 		if (error)
-			return fz_rethrow(error, "cannot decode jpeg image");
+			return fz_error_note(error, "cannot decode jpeg image");
 	}
 	else if (memcmp(buf, "\211PNG\r\n\032\n", 8) == 0)
 	{
 		error = xps_decode_png(imagep, buf, len);
 		if (error)
-			return fz_rethrow(error, "cannot decode png image");
+			return fz_error_note(error, "cannot decode png image");
 	}
 	else if (memcmp(buf, "II", 2) == 0 && buf[2] == 0xBC)
 	{
-		return fz_throw("JPEG-XR codec is not available");
+		return fz_error_make("JPEG-XR codec is not available");
 	}
 	else if (memcmp(buf, "MM", 2) == 0 || memcmp(buf, "II", 2) == 0)
 	{
 		error = xps_decode_tiff(imagep, buf, len);
 		if (error)
-			return fz_rethrow(error, "cannot decode TIFF image");
+			return fz_error_note(error, "cannot decode TIFF image");
 	}
 	else
-		return fz_throw("unknown image file format");
+		return fz_error_make("unknown image file format");
 
 	return fz_okay;
 }
@@ -117,7 +117,7 @@ xps_parse_image_brush(xps_context *ctx, fz_matrix ctm, fz_rect area,
 	code = xps_decode_image(&image, part->data, part->size);
 	if (code < 0) {
 		xps_free_part(ctx, part);
-		fz_catch(-1, "cannot decode image resource");
+		fz_error_handle(-1, "cannot decode image resource");
 		return;
 	}
 
diff --git a/xps/xps_jpeg.c b/xps/xps_jpeg.c
index 68bb5eb9..ad5e2569 100644
--- a/xps/xps_jpeg.c
+++ b/xps/xps_jpeg.c
@@ -64,7 +64,7 @@ xps_decode_jpeg(fz_pixmap **imagep, byte *rbuf, int rlen)
 	{
 		if (image)
 			fz_drop_pixmap(image);
-		return fz_throw("jpeg error: %s", err.msg);
+		return fz_error_make("jpeg error: %s", err.msg);
 	}
 
 	cinfo.err = jpeg_std_error(&err.super);
@@ -92,14 +92,14 @@ xps_decode_jpeg(fz_pixmap **imagep, byte *rbuf, int rlen)
 	else if (cinfo.output_components == 4)
 		colorspace = fz_device_cmyk;
 	else
-		return fz_throw("bad number of components in jpeg: %d", cinfo.output_components);
+		return fz_error_make("bad number of components in jpeg: %d", cinfo.output_components);
 
 	image = fz_new_pixmap_with_limit(colorspace, cinfo.output_width, cinfo.output_height);
 	if (!image)
 	{
 		jpeg_finish_decompress(&cinfo);
 		jpeg_destroy_decompress(&cinfo);
-		return fz_throw("out of memory");
+		return fz_error_make("out of memory");
 	}
 
 	if (cinfo.density_unit == 1)
diff --git a/xps/xps_png.c b/xps/xps_png.c
index 245dd285..aec6610a 100644
--- a/xps/xps_png.c
+++ b/xps/xps_png.c
@@ -224,7 +224,7 @@ png_read_ihdr(struct info *info, unsigned char *p, int size)
 	int color, compression, filter;
 
 	if (size != 13)
-		return fz_throw("IHDR chunk is the wrong size");
+		return fz_error_make("IHDR chunk is the wrong size");
 
 	info->width = getint(p + 0);
 	info->height = getint(p + 4);
@@ -236,21 +236,21 @@ png_read_ihdr(struct info *info, unsigned char *p, int size)
 	info->interlace = p[12];
 
 	if (info->width <= 0)
-		return fz_throw("image width must be > 0");
+		return fz_error_make("image width must be > 0");
 	if (info->height <= 0)
-		return fz_throw("image height must be > 0");
+		return fz_error_make("image height must be > 0");
 
 	if (info->depth != 1 && info->depth != 2 && info->depth != 4 &&
 			info->depth != 8 && info->depth != 16)
-		return fz_throw("image bit depth must be one of 1, 2, 4, 8, 16");
+		return fz_error_make("image bit depth must be one of 1, 2, 4, 8, 16");
 	if (color == 2 && info->depth < 8)
-		return fz_throw("illegal bit depth for truecolor");
+		return fz_error_make("illegal bit depth for truecolor");
 	if (color == 3 && info->depth > 8)
-		return fz_throw("illegal bit depth for indexed");
+		return fz_error_make("illegal bit depth for indexed");
 	if (color == 4 && info->depth < 8)
-		return fz_throw("illegal bit depth for grayscale with alpha");
+		return fz_error_make("illegal bit depth for grayscale with alpha");
 	if (color == 6 && info->depth < 8)
-		return fz_throw("illegal bit depth for truecolor with alpha");
+		return fz_error_make("illegal bit depth for truecolor with alpha");
 
 	info->indexed = 0;
 	if (color == 0) /* gray */
@@ -267,14 +267,14 @@ png_read_ihdr(struct info *info, unsigned char *p, int size)
 		info->n = 1;
 	}
 	else
-		return fz_throw("unknown color type");
+		return fz_error_make("unknown color type");
 
 	if (compression != 0)
-		return fz_throw("unknown compression method");
+		return fz_error_make("unknown compression method");
 	if (filter != 0)
-		return fz_throw("unknown filter method");
+		return fz_error_make("unknown filter method");
 	if (info->interlace != 0 && info->interlace != 1)
-		return fz_throw("interlace method not supported");
+		return fz_error_make("interlace method not supported");
 
 	return fz_okay;
 }
@@ -286,7 +286,7 @@ png_read_plte(struct info *info, unsigned char *p, int size)
 	int i;
 
 	if (n > 256 || n > (1 << info->depth))
-		return fz_throw("too many samples in palette");
+		return fz_error_make("too many samples in palette");
 
 	for (i = 0; i < n; i++)
 	{
@@ -308,14 +308,14 @@ png_read_trns(struct info *info, unsigned char *p, int size)
 	if (info->indexed)
 	{
 		if (size > 256 || size > (1 << info->depth))
-			return fz_throw("too many samples in transparency table");
+			return fz_error_make("too many samples in transparency table");
 		for (i = 0; i < size; i++)
 			info->palette[i * 4 + 3] = p[i];
 	}
 	else
 	{
 		if (size != info->n * 2)
-			return fz_throw("tRNS chunk is the wrong size");
+			return fz_error_make("tRNS chunk is the wrong size");
 		for (i = 0; i < info->n; i++)
 			info->trns[i] = (p[i * 2] << 8 | p[i * 2 + 1]) & ((1 << info->depth) - 1);
 	}
@@ -333,12 +333,12 @@ png_read_idat(struct info *info, unsigned char *p, int size, z_stream *stm)
 
 	code = inflate(stm, Z_SYNC_FLUSH);
 	if (code != Z_OK && code != Z_STREAM_END)
-		return fz_throw("zlib error: %s", stm->msg);
+		return fz_error_make("zlib error: %s", stm->msg);
 	if (stm->avail_in != 0)
 	{
 		if (stm->avail_out == 0)
-			return fz_throw("ran out of output before input");
-		return fz_throw("inflate did not consume buffer (%d remaining)", stm->avail_in);
+			return fz_error_make("ran out of output before input");
+		return fz_error_make("inflate did not consume buffer (%d remaining)", stm->avail_in);
 	}
 
 	return fz_okay;
@@ -348,7 +348,7 @@ static int
 png_read_phys(struct info *info, unsigned char *p, int size)
 {
 	if (size != 9)
-		return fz_throw("pHYs chunk is the wrong size");
+		return fz_error_make("pHYs chunk is the wrong size");
 	if (p[8] == 1)
 	{
 		info->xres = getint(p) * 254 / 10000;
@@ -372,7 +372,7 @@ png_read_image(struct info *info, unsigned char *p, int total)
 	/* Read signature */
 
 	if (total < 8 + 12 || memcmp(p, png_signature, 8))
-		return fz_throw("not a png image (wrong signature)");
+		return fz_error_make("not a png image (wrong signature)");
 
 	p += 8;
 	total -= 8;
@@ -382,16 +382,16 @@ png_read_image(struct info *info, unsigned char *p, int total)
 	size = getint(p);
 
 	if (size + 12 > total)
-		return fz_throw("premature end of data in png image");
+		return fz_error_make("premature end of data in png image");
 
 	if (!memcmp(p + 4, "IHDR", 4))
 	{
 		code = png_read_ihdr(info, p + 8, size);
 		if (code)
-			return fz_rethrow(code, "cannot read png header");
+			return fz_error_note(code, "cannot read png header");
 	}
 	else
-		return fz_throw("png file must start with IHDR chunk");
+		return fz_error_make("png file must start with IHDR chunk");
 
 	p += size + 12;
 	total -= size + 12;
@@ -419,7 +419,7 @@ png_read_image(struct info *info, unsigned char *p, int total)
 
 	code = inflateInit(&stm);
 	if (code != Z_OK)
-		return fz_throw("zlib error: %s", stm.msg);
+		return fz_error_make("zlib error: %s", stm.msg);
 
 	/* Read remaining chunks until IEND */
 
@@ -428,34 +428,34 @@ png_read_image(struct info *info, unsigned char *p, int total)
 		size = getint(p);
 
 		if (size + 12 > total)
-			return fz_throw("premature end of data in png image");
+			return fz_error_make("premature end of data in png image");
 
 		if (!memcmp(p + 4, "PLTE", 4))
 		{
 			code = png_read_plte(info, p + 8, size);
 			if (code)
-				return fz_rethrow(code, "cannot read png palette");
+				return fz_error_note(code, "cannot read png palette");
 		}
 
 		if (!memcmp(p + 4, "tRNS", 4))
 		{
 			code = png_read_trns(info, p + 8, size);
 			if (code)
-				return fz_rethrow(code, "cannot read png transparency");
+				return fz_error_note(code, "cannot read png transparency");
 		}
 
 		if (!memcmp(p + 4, "pHYs", 4))
 		{
 			code = png_read_phys(info, p + 8, size);
 			if (code)
-				return fz_rethrow(code, "cannot read png resolution");
+				return fz_error_note(code, "cannot read png resolution");
 		}
 
 		if (!memcmp(p + 4, "IDAT", 4))
 		{
 			code = png_read_idat(info, p + 8, size, &stm);
 			if (code)
-				return fz_rethrow(code, "cannot read png image data");
+				return fz_error_note(code, "cannot read png image data");
 		}
 
 		if (!memcmp(p + 4, "IEND", 4))
@@ -467,7 +467,7 @@ png_read_image(struct info *info, unsigned char *p, int total)
 
 	code = inflateEnd(&stm);
 	if (code != Z_OK)
-		return fz_throw("zlib error: %s", stm.msg);
+		return fz_error_make("zlib error: %s", stm.msg);
 
 	/* Apply prediction filter and deinterlacing */
 
@@ -542,7 +542,7 @@ xps_decode_png(fz_pixmap **imagep, byte *p, int total)
 
 	code = png_read_image(&png, p, total);
 	if (code)
-		return fz_rethrow(code, "cannot read png image");
+		return fz_error_note(code, "cannot read png image");
 
 	if (png.n == 3 || png.n == 4)
 		colorspace = fz_device_rgb;
@@ -555,7 +555,7 @@ xps_decode_png(fz_pixmap **imagep, byte *p, int total)
 	if (!image)
 	{
 		fz_free(png.samples);
-		return fz_throw("out of memory");
+		return fz_error_make("out of memory");
 	}
 
 	image->xres = png.xres;
diff --git a/xps/xps_resource.c b/xps/xps_resource.c
index c96f3619..bd414894 100644
--- a/xps/xps_resource.c
+++ b/xps/xps_resource.c
@@ -68,21 +68,21 @@ xps_parse_remote_resource_dictionary(xps_context *ctx, xps_resource **dictp, cha
 	part = xps_read_part(ctx, part_name);
 	if (!part)
 	{
-		return fz_throw("cannot find remote resource part '%s'", part_name);
+		return fz_error_make("cannot find remote resource part '%s'", part_name);
 	}
 
 	xml = xml_parse_document(part->data, part->size);
 	if (!xml)
 	{
 		xps_free_part(ctx, part);
-		return fz_rethrow(-1, "cannot parse xml");
+		return fz_error_note(-1, "cannot parse xml");
 	}
 
 	if (strcmp(xml_tag(xml), "ResourceDictionary"))
 	{
 		xml_free_element(xml);
 		xps_free_part(ctx, part);
-		return fz_throw("expected ResourceDictionary element (found %s)", xml_tag(xml));
+		return fz_error_make("expected ResourceDictionary element (found %s)", xml_tag(xml));
 	}
 
 	fz_strlcpy(part_uri, part_name, sizeof part_uri);
@@ -95,7 +95,7 @@ xps_parse_remote_resource_dictionary(xps_context *ctx, xps_resource **dictp, cha
 	{
 		xml_free_element(xml);
 		xps_free_part(ctx, part);
-		return fz_rethrow(code, "cannot parse remote resource dictionary: %s", part_uri);
+		return fz_error_note(code, "cannot parse remote resource dictionary: %s", part_uri);
 	}
 
 	dict->base_xml = xml; /* pass on ownership */
@@ -121,7 +121,7 @@ xps_parse_resource_dictionary(xps_context *ctx, xps_resource **dictp, char *base
 	{
 		code = xps_parse_remote_resource_dictionary(ctx, dictp, base_uri, source);
 		if (code)
-			return fz_rethrow(code, "cannot parse remote resource dictionary");
+			return fz_error_note(code, "cannot parse remote resource dictionary");
 		return fz_okay;
 	}
 
diff --git a/xps/xps_tiff.c b/xps/xps_tiff.c
index 8c58b4d1..22137259 100644
--- a/xps/xps_tiff.c
+++ b/xps/xps_tiff.c
@@ -139,7 +139,7 @@ xps_decode_tiff_uncompressed(struct tiff *tiff, fz_stream *stm, byte *wp, int wl
 	int n = fz_read(stm, wp, wlen);
 	fz_close(stm);
 	if (n < 0)
-		return fz_rethrow(n, "cannot read uncompressed strip");
+		return fz_error_note(n, "cannot read uncompressed strip");
 	return fz_okay;
 }
 
@@ -150,7 +150,7 @@ xps_decode_tiff_packbits(struct tiff *tiff, fz_stream *chain, byte *wp, int wlen
 	int n = fz_read(stm, wp, wlen);
 	fz_close(stm);
 	if (n < 0)
-		return fz_rethrow(n, "cannot read packbits strip");
+		return fz_error_note(n, "cannot read packbits strip");
 	return fz_okay;
 }
 
@@ -161,7 +161,7 @@ xps_decode_tiff_lzw(struct tiff *tiff, fz_stream *chain, byte *wp, int wlen)
 	int n = fz_read(stm, wp, wlen);
 	fz_close(stm);
 	if (n < 0)
-		return fz_rethrow(n, "cannot read lzw strip");
+		return fz_error_note(n, "cannot read lzw strip");
 	return fz_okay;
 }
 static int
@@ -171,7 +171,7 @@ xps_decode_tiff_flate(struct tiff *tiff, fz_stream *chain, byte *wp, int wlen)
 	int n = fz_read(stm, wp, wlen);
 	fz_close(stm);
 	if (n < 0)
-		return fz_rethrow(n, "cannot read flate strip");
+		return fz_error_note(n, "cannot read flate strip");
 	return fz_okay;
 }
 
@@ -208,7 +208,7 @@ xps_decode_tiff_fax(struct tiff *tiff, int comp, fz_stream *chain, byte *wp, int
 	fz_drop_obj(params);
 
 	if (n < 0)
-		return fz_rethrow(n, "cannot read fax strip");
+		return fz_error_note(n, "cannot read fax strip");
 	return fz_okay;
 }
 
@@ -219,7 +219,7 @@ xps_decode_tiff_jpeg(struct tiff *tiff, fz_stream *chain, byte *wp, int wlen)
 	int n = fz_read(stm, wp, wlen);
 	fz_close(stm);
 	if (n < 0)
-		return fz_rethrow(n, "cannot read jpeg strip");
+		return fz_error_note(n, "cannot read jpeg strip");
 	return fz_okay;
 }
 
@@ -311,10 +311,10 @@ xps_expand_tiff_colormap(struct tiff *tiff)
 	/* image can be with or without extrasamples: comps is 1 or 2 */
 
 	if (tiff->samplesperpixel != 1 && tiff->samplesperpixel != 2)
-		return fz_throw("invalid number of samples for RGBPal");
+		return fz_error_make("invalid number of samples for RGBPal");
 
 	if (tiff->bitspersample != 4 && tiff->bitspersample != 8)
-		return fz_throw("invalid number of bits for RGBPal");
+		return fz_error_make("invalid number of bits for RGBPal");
 
 	stride = tiff->imagewidth * (tiff->samplesperpixel + 2);
 
@@ -374,10 +374,10 @@ xps_decode_tiff_strips(struct tiff *tiff)
 	unsigned i;
 
 	if (!tiff->rowsperstrip || !tiff->stripoffsets || !tiff->rowsperstrip)
-		return fz_throw("no image data in tiff; maybe it is tiled");
+		return fz_error_make("no image data in tiff; maybe it is tiled");
 
 	if (tiff->planar != 1)
-		return fz_throw("image data is not in chunky format");
+		return fz_error_make("image data is not in chunky format");
 
 	tiff->stride = (tiff->imagewidth * tiff->samplesperpixel * tiff->bitspersample + 7) / 8;
 
@@ -403,7 +403,7 @@ xps_decode_tiff_strips(struct tiff *tiff)
 		tiff->colorspace = fz_device_rgb;
 		break;
 	default:
-		return fz_throw("unknown photometric: %d", tiff->photometric);
+		return fz_error_make("unknown photometric: %d", tiff->photometric);
 	}
 
 	switch (tiff->resolutionunit)
@@ -444,7 +444,7 @@ xps_decode_tiff_strips(struct tiff *tiff)
 			wlen = tiff->samples + tiff->stride * tiff->imagelength - wp;
 
 		if (rp + rlen > tiff->ep)
-			return fz_throw("strip extends beyond the end of the file");
+			return fz_error_make("strip extends beyond the end of the file");
 
 		/* the bits are in un-natural order */
 		if (tiff->fillorder == 2)
@@ -472,7 +472,7 @@ xps_decode_tiff_strips(struct tiff *tiff)
 			error = xps_decode_tiff_lzw(tiff, stm, wp, wlen);
 			break;
 		case 6:
-			error = fz_throw("deprecated JPEG in TIFF compression not supported");
+			error = fz_error_make("deprecated JPEG in TIFF compression not supported");
 			break;
 		case 7:
 			error = xps_decode_tiff_jpeg(tiff, stm, wp, wlen);
@@ -484,11 +484,11 @@ xps_decode_tiff_strips(struct tiff *tiff)
 			error = xps_decode_tiff_packbits(tiff, stm, wp, wlen);
 			break;
 		default:
-			error = fz_throw("unknown TIFF compression: %d", tiff->compression);
+			error = fz_error_make("unknown TIFF compression: %d", tiff->compression);
 		}
 
 		if (error)
-			return fz_rethrow(error, "cannot decode strip %d", row / tiff->rowsperstrip);
+			return fz_error_note(error, "cannot decode strip %d", row / tiff->rowsperstrip);
 
 		/* scramble the bits back into original order */
 		if (tiff->fillorder == 2)
@@ -515,7 +515,7 @@ xps_decode_tiff_strips(struct tiff *tiff)
 	{
 		error = xps_expand_tiff_colormap(tiff);
 		if (error)
-			return fz_rethrow(error, "cannot expand colormap");
+			return fz_error_note(error, "cannot expand colormap");
 	}
 
 	/* WhiteIsZero .. invert */
@@ -705,7 +705,7 @@ xps_read_tiff_tag(struct tiff *tiff, unsigned offset)
 	case TileLength:
 	case TileOffsets:
 	case TileByteCounts:
-		return fz_throw("tiled tiffs not supported");
+		return fz_error_make("tiled tiffs not supported");
 
 	default:
 		/* printf("unknown tag: %d t=%d n=%d\n", tag, type, count); */
@@ -763,12 +763,12 @@ xps_decode_tiff_header(struct tiff *tiff, byte *buf, int len)
 	tiff->order = TII;
 	tiff->order = readshort(tiff);
 	if (tiff->order != TII && tiff->order != TMM)
-		return fz_throw("not a TIFF file, wrong magic marker");
+		return fz_error_make("not a TIFF file, wrong magic marker");
 
 	/* check version */
 	version = readshort(tiff);
 	if (version != 42)
-		return fz_throw("not a TIFF file, wrong version marker");
+		return fz_error_make("not a TIFF file, wrong version marker");
 
 	/* get offset of IFD */
 	offset = readlong(tiff);
@@ -786,7 +786,7 @@ xps_decode_tiff_header(struct tiff *tiff, byte *buf, int len)
 	{
 		error = xps_read_tiff_tag(tiff, offset);
 		if (error)
-			return fz_rethrow(error, "cannot read TIFF header tag");
+			return fz_error_note(error, "cannot read TIFF header tag");
 		offset += 12;
 	}
 
@@ -802,7 +802,7 @@ xps_decode_tiff(fz_pixmap **imagep, byte *buf, int len)
 
 	error = xps_decode_tiff_header(&tiff, buf, len);
 	if (error)
-		return fz_rethrow(error, "cannot decode tiff header");
+		return fz_error_note(error, "cannot decode tiff header");
 
 	/* Decode the image strips */
 
@@ -811,7 +811,7 @@ xps_decode_tiff(fz_pixmap **imagep, byte *buf, int len)
 
 	error = xps_decode_tiff_strips(&tiff);
 	if (error)
-		return fz_rethrow(error, "cannot decode image data");
+		return fz_error_note(error, "cannot decode image data");
 
 	/* Byte swap 16-bit images to big endian if necessary */
 	if (tiff.bitspersample == 16)
@@ -829,7 +829,7 @@ xps_decode_tiff(fz_pixmap **imagep, byte *buf, int len)
 		if (tiff.stripoffsets) fz_free(tiff.stripoffsets);
 		if (tiff.stripbytecounts) fz_free(tiff.stripbytecounts);
 		if (tiff.samples) fz_free(tiff.samples);
-		return fz_throw("out of memory");
+		return fz_error_make("out of memory");
 	}
 
 	image->xres = tiff.xresolution;
diff --git a/xps/xps_tile.c b/xps/xps_tile.c
index d67a9b24..5aa45891 100644
--- a/xps/xps_tile.c
+++ b/xps/xps_tile.c
@@ -274,7 +274,7 @@ xps_parse_canvas(xps_context *ctx, fz_matrix ctm, fz_rect area, char *base_uri,
 		{
 			code = xps_parse_resource_dictionary(ctx, &new_dict, base_uri, xml_down(node));
 			if (code)
-				fz_catch(code, "cannot load Canvas.Resources");
+				fz_error_handle(code, "cannot load Canvas.Resources");
 			else
 			{
 				new_dict->parent = dict;
@@ -352,7 +352,7 @@ xps_parse_fixed_page(xps_context *ctx, fz_matrix ctm, xps_page *page)
 		{
 			code = xps_parse_resource_dictionary(ctx, &dict, base_uri, xml_down(node));
 			if (code)
-				fz_catch(code, "cannot load FixedPage.Resources");
+				fz_error_handle(code, "cannot load FixedPage.Resources");
 		}
 		xps_parse_element(ctx, ctm, area, base_uri, dict, node);
 	}
diff --git a/xps/xps_xml.c b/xps/xps_xml.c
index 8448ecef..5a564fbc 100644
--- a/xps/xps_xml.c
+++ b/xps/xps_xml.c
@@ -376,7 +376,7 @@ xml_parse_document(unsigned char *s, int n)
 
 	error = xml_parse_document_imp(&parser, p);
 	if (error) {
-		fz_throw(error);
+		fz_error_make(error);
 		return NULL;
 	}
 
diff --git a/xps/xps_zip.c b/xps/xps_zip.c
index a0c981bf..0f89fe56 100644
--- a/xps/xps_zip.c
+++ b/xps/xps_zip.c
@@ -94,7 +94,7 @@ xps_read_zip_entry(xps_context *ctx, xps_entry *ent, unsigned char *outbuf)
 
 	sig = getlong(ctx->file);
 	if (sig != ZIP_LOCAL_FILE_SIG)
-		return fz_throw("wrong zip local file signature (0x%x)", sig);
+		return fz_error_make("wrong zip local file signature (0x%x)", sig);
 
 	version = getshort(ctx->file);
 	general = getshort(ctx->file);
@@ -130,22 +130,22 @@ xps_read_zip_entry(xps_context *ctx, xps_entry *ent, unsigned char *outbuf)
 
 		code = inflateInit2(&stream, -15);
 		if (code != Z_OK)
-			return fz_throw("zlib inflateInit2 error: %s", stream.msg);
+			return fz_error_make("zlib inflateInit2 error: %s", stream.msg);
 		code = inflate(&stream, Z_FINISH);
 		if (code != Z_STREAM_END)
 		{
 			inflateEnd(&stream);
-			return fz_throw("zlib inflate error: %s", stream.msg);
+			return fz_error_make("zlib inflate error: %s", stream.msg);
 		}
 		code = inflateEnd(&stream);
 		if (code != Z_OK)
-			return fz_throw("zlib inflateEnd error: %s", stream.msg);
+			return fz_error_make("zlib inflateEnd error: %s", stream.msg);
 
 		fz_free(inbuf);
 	}
 	else
 	{
-		return fz_throw("unknown compression method (%d)", method);
+		return fz_error_make("unknown compression method (%d)", method);
 	}
 
 	return fz_okay;
@@ -167,7 +167,7 @@ xps_read_zip_dir(xps_context *ctx, int start_offset)
 
 	sig = getlong(ctx->file);
 	if (sig != ZIP_END_OF_CENTRAL_DIRECTORY_SIG)
-		return fz_throw("wrong zip end of central directory signature (0x%x)", sig);
+		return fz_error_make("wrong zip end of central directory signature (0x%x)", sig);
 
 	(void) getshort(ctx->file); /* this disk */
 	(void) getshort(ctx->file); /* start disk */
@@ -186,7 +186,7 @@ xps_read_zip_dir(xps_context *ctx, int start_offset)
 	{
 		sig = getlong(ctx->file);
 		if (sig != ZIP_CENTRAL_DIRECTORY_SIG)
-			return fz_throw("wrong zip central directory signature (0x%x)", sig);
+			return fz_error_make("wrong zip central directory signature (0x%x)", sig);
 
 		(void) getshort(ctx->file); /* version made by */
 		(void) getshort(ctx->file); /* version to extract */
@@ -237,7 +237,7 @@ xps_find_and_read_zip_dir(xps_context *ctx)
 
 		n = fz_read(ctx->file, buf, sizeof buf);
 		if (n < 0)
-			return fz_throw("cannot read end of central directory");
+			return fz_error_make("cannot read end of central directory");
 
 		for (i = n - 4; i > 0; i--)
 			if (!memcmp(buf + i, "PK\5\6", 4))
@@ -246,7 +246,7 @@ xps_find_and_read_zip_dir(xps_context *ctx)
 		back += sizeof buf - 4;
 	}
 
-	return fz_throw("cannot find end of central directory");
+	return fz_error_make("cannot find end of central directory");
 }
 
 /*
@@ -405,7 +405,7 @@ xps_open_directory(xps_context **ctxp, char *directory)
 	if (code)
 	{
 		xps_free_context(ctx);
-		return fz_rethrow(code, "cannot read page list");
+		return fz_error_note(code, "cannot read page list");
 	}
 
 	*ctxp = ctx;
@@ -427,14 +427,14 @@ xps_open_stream(xps_context **ctxp, fz_stream *file)
 	if (code < 0)
 	{
 		xps_free_context(ctx);
-		return fz_rethrow(code, "cannot read zip central directory");
+		return fz_error_note(code, "cannot read zip central directory");
 	}
 
 	code = xps_read_page_list(ctx);
 	if (code)
 	{
 		xps_free_context(ctx);
-		return fz_rethrow(code, "cannot read page list");
+		return fz_error_note(code, "cannot read page list");
 	}
 
 	*ctxp = ctx;
@@ -461,12 +461,12 @@ xps_open_file(xps_context **ctxp, char *filename)
 
 	file = fz_open_file(filename);
 	if (!file)
-		return fz_throw("cannot open file '%s': %s", filename, strerror(errno));
+		return fz_error_make("cannot open file '%s': %s", filename, strerror(errno));
 
 	code = xps_open_stream(ctxp, file);
 	fz_close(file);
 	if (code)
-		return fz_rethrow(code, "cannot load document '%s'", filename);
+		return fz_error_note(code, "cannot load document '%s'", filename);
 	return fz_okay;
 }