From 89ae81f651bfa112b8e07317eb6983beaf7cb212 Mon Sep 17 00:00:00 2001 From: Robin Watts Date: Sun, 11 Sep 2011 19:29:42 -0500 Subject: 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... --- apps/pdfapp.c | 10 ++-- apps/pdfclean.c | 10 ++-- apps/pdfdraw.c | 10 ++-- apps/pdfextract.c | 16 +++--- apps/pdfinfo.c | 10 ++-- apps/pdfshow.c | 14 +++--- apps/win_main.c | 8 +-- apps/x11_main.c | 10 ++-- apps/xpsdraw.c | 6 +-- fitz/base_error.c | 12 ++--- fitz/base_hash.c | 2 +- fitz/base_object.c | 2 +- fitz/except.c | 49 +++++++++++++++++++ fitz/except.h | 46 +++++++++++++++++ fitz/exceptxxx.h | 36 ++++++++++++++ fitz/filt_basic.c | 22 ++++----- fitz/filt_dctd.c | 2 +- fitz/filt_faxd.c | 22 ++++----- fitz/filt_flate.c | 2 +- fitz/filt_jbig2d.c | 4 +- fitz/filt_jpxd.c | 12 ++--- fitz/filt_predict.c | 2 +- fitz/fitz.h | 47 +++++++++++------- fitz/res_bitmap.c | 2 +- fitz/res_font.c | 16 +++--- fitz/res_pixmap.c | 12 ++--- fitz/stm_open.c | 2 +- fitz/stm_read.c | 10 ++-- pdf/pdf_annot.c | 2 +- pdf/pdf_cmap_load.c | 12 ++--- pdf/pdf_cmap_parse.c | 74 ++++++++++++++-------------- pdf/pdf_colorspace.c | 26 +++++----- pdf/pdf_crypt.c | 36 +++++++------- pdf/pdf_font.c | 54 ++++++++++---------- pdf/pdf_function.c | 90 +++++++++++++++++----------------- pdf/pdf_image.c | 40 +++++++-------- pdf/pdf_interpret.c | 122 ++++++++++++++++++++++----------------------- pdf/pdf_lex.c | 2 +- pdf/pdf_page.c | 16 +++--- pdf/pdf_parse.c | 64 ++++++++++++------------ pdf/pdf_pattern.c | 2 +- pdf/pdf_repair.c | 34 ++++++------- pdf/pdf_shade.c | 22 ++++----- pdf/pdf_stream.c | 30 ++++++------ pdf/pdf_type3.c | 8 +-- pdf/pdf_unicode.c | 4 +- pdf/pdf_xobject.c | 4 +- pdf/pdf_xref.c | 136 +++++++++++++++++++++++++-------------------------- scripts/cmapdump.c | 4 +- xps/xps_doc.c | 28 +++++------ xps/xps_glyphs.c | 2 +- xps/xps_image.c | 14 +++--- xps/xps_jpeg.c | 6 +-- xps/xps_png.c | 64 ++++++++++++------------ xps/xps_resource.c | 10 ++-- xps/xps_tiff.c | 46 ++++++++--------- xps/xps_tile.c | 4 +- xps/xps_xml.c | 2 +- xps/xps_zip.c | 28 +++++------ 59 files changed, 763 insertions(+), 619 deletions(-) create mode 100644 fitz/except.c create mode 100644 fitz/except.h create mode 100644 fitz/exceptxxx.h 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("\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("\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 +#include +#include +#include +#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 + +#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; } -- cgit v1.2.3