Malloc cannot return null. Clean up in mupdf resource code.

32 files changed, 164 insertions, 665 deletions

diff --git a/apps/common/pdfapp.c b/apps/common/pdfapp.c
index 935f79f4..96eeae00 100644
--- a/apps/common/pdfapp.c
+++ b/apps/common/pdfapp.c
@@ -77,10 +77,7 @@ void pdfapp_open(pdfapp_t *app, char *filename)
 
 	app->filename = filename;
 
-	error = pdf_newxref(&app->xref);
-	if (error)
-		pdfapp_error(app, error);
-
+	app->xref = pdf_newxref();
 	error = pdf_loadxref(app->xref, filename);
 	if (error)
 	{
diff --git a/apps/common/pdftool.c b/apps/common/pdftool.c
index 772fc9a0..4d846df5 100644
--- a/apps/common/pdftool.c
+++ b/apps/common/pdftool.c
@@ -33,10 +33,7 @@ void openxref(char *filename, char *password, int dieonbadpass)
 	else
 		basename++;
 
-	error = pdf_newxref(&xref);
-	if (error)
-		die(error);
-
+	xref = pdf_newxref();
 	error = pdf_loadxref(xref, filename);
 	if (error)
 	{
diff --git a/fitz/fitz_tree.h b/fitz/fitz_tree.h
index 68cfe6d7..95044a4e 100644
--- a/fitz/fitz_tree.h
+++ b/fitz/fitz_tree.h
@@ -369,7 +369,7 @@ struct fz_glyph_s
 fz_error fz_newfreetypefont(fz_font **fontp, char *name, int substitute);
 fz_error fz_loadfreetypefontfile(fz_font *font, char *path, int index);
 fz_error fz_loadfreetypefontbuffer(fz_font *font, unsigned char *data, int len, int index);
-fz_error fz_newtype3font(fz_font **fontp, char *name, fz_matrix matrix);
+fz_font * fz_newtype3font(char *name, fz_matrix matrix);
 
 fz_error fz_newfontfrombuffer(fz_font **fontp, unsigned char *data, int len, int index);
 fz_error fz_newfontfromfile(fz_font **fontp, char *path, int index);
diff --git a/fitz/obj_array.c b/fitz/obj_array.c
index ac1e1fa8..07916aa2 100644
--- a/fitz/obj_array.c
+++ b/fitz/obj_array.c
@@ -96,11 +96,10 @@ fz_arraypush(fz_obj *obj, fz_obj *item)
 		if (obj->u.a.len + 1 > obj->u.a.cap)
 		{
 			int i;
-			int newcap = obj->u.a.cap * 2;
-			obj->u.a.items = fz_realloc(obj->u.a.items, sizeof (fz_obj*) * newcap);
-			for (i = obj->u.a.cap ; i < newcap; i++)
+			obj->u.a.cap = (obj->u.a.cap * 3) / 2;
+			obj->u.a.items = fz_realloc(obj->u.a.items, sizeof (fz_obj*) * obj->u.a.cap);
+			for (i = obj->u.a.len ; i < obj->u.a.cap; i++)
 				obj->u.a.items[i] = nil;
-			obj->u.a.cap = newcap;
 		}
 		obj->u.a.items[obj->u.a.len] = fz_keepobj(item);
 		obj->u.a.len++;
diff --git a/fitz/obj_dict.c b/fitz/obj_dict.c
index 1742df92..6849b21b 100644
--- a/fitz/obj_dict.c
+++ b/fitz/obj_dict.c
@@ -200,14 +200,13 @@ fz_dictput(fz_obj *obj, fz_obj *key, fz_obj *val)
 
 	if (obj->u.d.len + 1 > obj->u.d.cap)
 	{
-		int newcap = obj->u.d.cap * 2;
-		obj->u.d.items = fz_realloc(obj->u.d.items, sizeof(fz_keyval) * newcap);
-		for (i = obj->u.d.cap; i < newcap; i++)
+		obj->u.d.cap = (obj->u.d.cap * 3) / 2;
+		obj->u.d.items = fz_realloc(obj->u.d.items, sizeof(fz_keyval) * obj->u.d.cap);
+		for (i = obj->u.d.len; i < obj->u.d.cap; i++)
 		{
 			obj->u.d.items[i].k = nil;
 			obj->u.d.items[i].v = nil;
 		}
-		obj->u.d.cap = newcap;
 	}
 
 	/* borked! */
diff --git a/fitz/obj_print.c b/fitz/obj_print.c
index fa582496..ad5bb344 100644
--- a/fitz/obj_print.c
+++ b/fitz/obj_print.c
@@ -325,8 +325,6 @@ fz_fprintobj(FILE *fp, fz_obj *obj, int tight)
 	else
 	{
 		ptr = fz_malloc(n + 1);
-		if (!ptr)
-			return -1;
 		fz_sprintobj(ptr, n + 1, obj, tight);
 		fputs(ptr, fp);
 		fputc('\n', fp);
diff --git a/fitz/res_font.c b/fitz/res_font.c
index a3ac32a5..4cf523f1 100644
--- a/fitz/res_font.c
+++ b/fitz/res_font.c
@@ -13,9 +13,6 @@ fz_newfont(void)
 	fz_font *font;
 
 	font = fz_malloc(sizeof(fz_font));
-	if (!font)
-		return nil;
-
 	font->refs = 1;
 	strcpy(font->name, "<unknown>");
 
@@ -336,42 +333,25 @@ fz_renderftglyph(fz_glyph *glyph, fz_font *font, int gid, fz_matrix trm)
  * Type 3 fonts...
  */
 
-fz_error
-fz_newtype3font(fz_font **fontp, char *name, fz_matrix matrix)
+fz_font *
+fz_newtype3font(char *name, fz_matrix matrix)
 {
 	fz_font *font;
 	int i;
 
 	font = fz_newfont();
-	if (!font)
-		return fz_rethrow(-1, "out of memory: font struct");
-
 	font->t3procs = fz_malloc(sizeof(fz_tree*) * 256);
-	if (!font->t3procs)
-	{
-		fz_free(font);
-		return fz_rethrow(-1, "out of memory: type3 font charproc array");
-	}
-
 	font->t3widths = fz_malloc(sizeof(float) * 256);
-	if (!font->t3widths)
-	{
-		fz_free(font->t3procs);
-		fz_free(font);
-		return fz_rethrow(-1, "out of memory: type3 font widths array");
-	}
 
+	strlcpy(font->name, name, sizeof(font->name));
 	font->t3matrix = matrix;
 	for (i = 0; i < 256; i++)
 	{
 		font->t3procs[i] = nil;
 		font->t3widths[i] = 0;
 	}
-
-	strlcpy(font->name, name, sizeof(font->name));
-
-	*fontp = font;
-	return fz_okay;
+	
+	return font;
 }
 
 /* XXX UGLY HACK XXX */
diff --git a/fitz/stm_buffer.c b/fitz/stm_buffer.c
index 024dbea9..23bbf635 100644
--- a/fitz/stm_buffer.c
+++ b/fitz/stm_buffer.c
@@ -56,8 +56,6 @@ fz_dropbuffer(fz_buffer *buf)
 void
 fz_growbuffer(fz_buffer *buf)
 {
-	unsigned char *newbp;
-
 	int rp = buf->rp - buf->bp;
 	int wp = buf->wp - buf->bp;
 	int ep = buf->ep - buf->bp;
@@ -68,8 +66,7 @@ fz_growbuffer(fz_buffer *buf)
 		return;
 	}
 	
-	newbp = fz_realloc(buf->bp, ep * 2);
-	buf->bp = newbp;
+	buf->bp = fz_realloc(buf->bp, (ep * 3) / 2);
 	buf->rp = buf->bp + rp;
 	buf->wp = buf->bp + wp;
 	buf->ep = buf->bp + ep * 2;
diff --git a/mupdf/mupdf.h b/mupdf/mupdf.h
index 3235e0ec..a26f0de1 100644
--- a/mupdf/mupdf.h
+++ b/mupdf/mupdf.h
@@ -144,7 +144,7 @@ struct pdf_xrefentry_s
 	int type;	/* 0=unset (f)ree i(n)use (o)bjstm */
 };
 
-fz_error pdf_newxref(pdf_xref **);
+pdf_xref * pdf_newxref(void);
 fz_error pdf_repairxref(pdf_xref *, char *filename);
 fz_error pdf_loadxref(pdf_xref *, char *filename);
 fz_error pdf_initxref(pdf_xref *);
@@ -361,7 +361,7 @@ struct pdf_cmap_s
 
 extern pdf_cmap *pdf_cmaptable[]; /* list of builtin system cmaps */
 
-fz_error pdf_newcmap(pdf_cmap **cmapp);
+pdf_cmap *pdf_newcmap(void);
 pdf_cmap *pdf_keepcmap(pdf_cmap *cmap);
 void pdf_dropcmap(pdf_cmap *cmap);
 
@@ -371,19 +371,19 @@ pdf_cmap *pdf_getusecmap(pdf_cmap *cmap);
 void pdf_setwmode(pdf_cmap *cmap, int wmode);
 void pdf_setusecmap(pdf_cmap *cmap, pdf_cmap *usecmap);
 
-fz_error pdf_addcodespace(pdf_cmap *cmap, int low, int high, int n);
-fz_error pdf_maprangetotable(pdf_cmap *cmap, int low, int *map, int len);
-fz_error pdf_maprangetorange(pdf_cmap *cmap, int srclo, int srchi, int dstlo);
-fz_error pdf_maponetomany(pdf_cmap *cmap, int one, int *many, int len);
-fz_error pdf_sortcmap(pdf_cmap *cmap);
+void pdf_addcodespace(pdf_cmap *cmap, int low, int high, int n);
+void pdf_maprangetotable(pdf_cmap *cmap, int low, int *map, int len);
+void pdf_maprangetorange(pdf_cmap *cmap, int srclo, int srchi, int dstlo);
+void pdf_maponetomany(pdf_cmap *cmap, int one, int *many, int len);
+void pdf_sortcmap(pdf_cmap *cmap);
 
 int pdf_lookupcmap(pdf_cmap *cmap, int cpt);
 unsigned char *pdf_decodecmap(pdf_cmap *cmap, unsigned char *s, int *cpt);
 
+pdf_cmap * pdf_newidentitycmap(int wmode, int bytes);
 fz_error pdf_parsecmap(pdf_cmap **cmapp, fz_stream *file);
 fz_error pdf_loadembeddedcmap(pdf_cmap **cmapp, pdf_xref *xref, fz_obj *ref);
 fz_error pdf_loadsystemcmap(pdf_cmap **cmapp, char *name);
-fz_error pdf_newidentitycmap(pdf_cmap **cmapp, int wmode, int bytes);
 
 /*
  * Font
@@ -466,10 +466,10 @@ struct pdf_fontdesc_s
 void pdf_setfontwmode(pdf_fontdesc *font, int wmode);
 void pdf_setdefaulthmtx(pdf_fontdesc *font, int w);
 void pdf_setdefaultvmtx(pdf_fontdesc *font, int y, int w);
-fz_error pdf_addhmtx(pdf_fontdesc *font, int lo, int hi, int w);
-fz_error pdf_addvmtx(pdf_fontdesc *font, int lo, int hi, int x, int y, int w);
-fz_error pdf_endhmtx(pdf_fontdesc *font);
-fz_error pdf_endvmtx(pdf_fontdesc *font);
+void pdf_addhmtx(pdf_fontdesc *font, int lo, int hi, int w);
+void pdf_addvmtx(pdf_fontdesc *font, int lo, int hi, int x, int y, int w);
+void pdf_endhmtx(pdf_fontdesc *font);
+void pdf_endvmtx(pdf_fontdesc *font);
 pdf_hmtx pdf_gethmtx(pdf_fontdesc *font, int cid);
 pdf_vmtx pdf_getvmtx(pdf_fontdesc *font, int cid);
 
@@ -605,7 +605,7 @@ void pdf_droppage(pdf_page *page);
 /* unicode.c */
 fz_error pdf_loadtextfromtree(pdf_textline **linep, fz_tree *tree, fz_matrix ctm);
 void pdf_debugtextline(pdf_textline *line);
-fz_error pdf_newtextline(pdf_textline **linep);
+pdf_textline * pdf_newtextline(void);
 void pdf_droptextline(pdf_textline *line);
 
 /*
diff --git a/mupdf/pdf_annot.c b/mupdf/pdf_annot.c
index eda2b5d7..b22a4c3d 100644
--- a/mupdf/pdf_annot.c
+++ b/mupdf/pdf_annot.c
@@ -4,15 +4,11 @@
 pdf_link *
 pdf_newlink(pdf_linkkind kind, fz_rect bbox, fz_obj *dest)
 {
-	pdf_link *link;
-
-	link = fz_malloc(sizeof(pdf_link));
-
+	pdf_link *link = fz_malloc(sizeof(pdf_link));
 	link->kind = kind;
 	link->rect = bbox;
 	link->dest = fz_keepobj(dest);
 	link->next = nil;
-
 	return link;
 }
 
diff --git a/mupdf/pdf_cmap.c b/mupdf/pdf_cmap.c
index 7ea130d8..9b154f5a 100644
--- a/mupdf/pdf_cmap.c
+++ b/mupdf/pdf_cmap.c
@@ -22,23 +22,18 @@
  * Allocate, destroy and simple parameters.
  */
 
-fz_error
-pdf_newcmap(pdf_cmap **cmapp)
+pdf_cmap *
+pdf_newcmap(void)
 {
     pdf_cmap *cmap;
 
-    cmap = *cmapp = fz_malloc(sizeof(pdf_cmap));
-    if (!cmap)
-	return fz_rethrow(-1, "out of memory: cmap struct");
-
+    cmap = fz_malloc(sizeof(pdf_cmap));
     cmap->refs = 1;
+    
     strcpy(cmap->cmapname, "");
-
     strcpy(cmap->usecmapname, "");
     cmap->usecmap = nil;
-
     cmap->wmode = 0;
-
     cmap->ncspace = 0;
 
     cmap->rlen = 0;
@@ -49,7 +44,7 @@ pdf_newcmap(pdf_cmap **cmapp)
     cmap->tcap = 0;
     cmap->table = nil;
 
-    return fz_okay;
+    return cmap;
 }
 
 pdf_cmap *
@@ -163,146 +158,96 @@ pdf_debugcmap(pdf_cmap *cmap)
  * These ranges are used by pdf_decodecmap to decode
  * multi-byte encoded strings.
  */
-fz_error
+void
 pdf_addcodespace(pdf_cmap *cmap, int low, int high, int n)
 {
     if (cmap->ncspace + 1 == nelem(cmap->cspace))
-	return fz_throw("assert: too many code space ranges");
+    {
+    	fz_warn("assert: too many code space ranges");
+    	return;
+    }
 
     cmap->cspace[cmap->ncspace].n = n;
     cmap->cspace[cmap->ncspace].low = low;
     cmap->cspace[cmap->ncspace].high = high;
-
     cmap->ncspace ++;
-
-    return fz_okay;
 }
 
 /*
  * Add an integer to the table.
  */
-static fz_error
+static void
 addtable(pdf_cmap *cmap, int value)
 {
     if (cmap->tlen + 1 > cmap->tcap)
     {
-	int newcap = cmap->tcap == 0 ? 256 : cmap->tcap * 2;
-	unsigned short *newtable = fz_realloc(cmap->table, newcap * sizeof(unsigned short));
-	if (!newtable)
-	    return fz_rethrow(-1, "out of memory: cmap table");
-	cmap->tcap = newcap;
-	cmap->table = newtable;
+	cmap->tcap = cmap->tcap == 0 ? 256 : (cmap->tcap * 3) / 2;
+	cmap->table = fz_realloc(cmap->table, cmap->tcap * sizeof(unsigned short));
     }
-
     cmap->table[cmap->tlen++] = value;
-
-    return fz_okay;
 }
 
 /*
  * Add a range.
  */
-static fz_error
+static void
 addrange(pdf_cmap *cmap, int low, int high, int flag, int offset)
 {
     if (cmap->rlen + 1 > cmap->rcap)
     {
-	pdf_range *newranges;
-	int newcap = cmap->rcap == 0 ? 256 : cmap->rcap * 2;
-	newranges = fz_realloc(cmap->ranges, newcap * sizeof(pdf_range));
-	if (!newranges)
-	    return fz_rethrow(-1, "out of memory: cmap ranges");
-	cmap->rcap = newcap;
-	cmap->ranges = newranges;
+	cmap->rcap = cmap->rcap == 0 ? 256 : (cmap->rcap * 3) / 2;
+	cmap->ranges = fz_realloc(cmap->ranges, cmap->rcap * sizeof(pdf_range));
     }
-
     cmap->ranges[cmap->rlen].low = low;
     cmap->ranges[cmap->rlen].high = high;
     cmap->ranges[cmap->rlen].flag = flag;
     cmap->ranges[cmap->rlen].offset = offset;
     cmap->rlen ++;
-
-    return fz_okay;
 }
 
 /*
  * Add a range-to-table mapping.
  */
-fz_error
+void
 pdf_maprangetotable(pdf_cmap *cmap, int low, int *table, int len)
 {
-    fz_error error;
-    int offset;
-    int high;
     int i;
-
-    high = low + len;
-    offset = cmap->tlen;
-
+    int high = low + len;
+    int offset = cmap->tlen;
     for (i = 0; i < len; i++)
-    {
-	error = addtable(cmap, table[i]);
-	if (error)
-	    return fz_rethrow(error, "cannot add range-to-table index");
-    }
-
-    error = addrange(cmap, low, high, PDF_CMAP_TABLE, offset);
-    if (error)
-	return fz_rethrow(error, "cannot add range-to-table range");
-
-    return fz_okay;
+	addtable(cmap, table[i]);
+    addrange(cmap, low, high, PDF_CMAP_TABLE, offset);
 }
 
 /*
  * Add a range of contiguous one-to-one mappings (ie 1..5 maps to 21..25)
  */
-fz_error
+void
 pdf_maprangetorange(pdf_cmap *cmap, int low, int high, int offset)
 {
-    fz_error error;
-    error = addrange(cmap, low, high, high - low == 0 ? PDF_CMAP_SINGLE : PDF_CMAP_RANGE, offset);
-    if (error)
-	return fz_rethrow(error, "cannot add range-to-range mapping");
-    return fz_okay;
+    addrange(cmap, low, high, high - low == 0 ? PDF_CMAP_SINGLE : PDF_CMAP_RANGE, offset);
 }
 
 /*
  * Add a single one-to-many mapping.
  */
-fz_error
+void
 pdf_maponetomany(pdf_cmap *cmap, int low, int *values, int len)
 {
-    fz_error error;
-    int offset;
-    int i;
+    int offset, i;
 
     if (len == 1)
     {
-	error = addrange(cmap, low, low, PDF_CMAP_SINGLE, values[0]);
-	if (error)
-	    return fz_rethrow(error, "cannot add one-to-one mapping");
-	return fz_okay;
+	addrange(cmap, low, low, PDF_CMAP_SINGLE, values[0]);
+	return;
     }
 
     offset = cmap->tlen;
-
-    error = addtable(cmap, len);
-    if (error)
-	return fz_rethrow(error, "cannot add one-to-many table length");
-
+    addtable(cmap, len); 
     for (i = 0; i < len; i++)
-    {
-	error = addtable(cmap, values[i]);
-	if (error)
-	    return fz_rethrow(error, "cannot add one-to-many table index");
-    }
-
-    error = addrange(cmap, low, low, PDF_CMAP_MULTI, offset);
-    if (error)
-	return fz_rethrow(error, "cannot add one-to-many mapping");
-
-    return fz_okay;
-}
+ 	addtable(cmap, values[i]);
+     addrange(cmap, low, low, PDF_CMAP_MULTI, offset);
+ }
 
 /*
  * Sort the input ranges.
@@ -315,17 +260,14 @@ static int cmprange(const void *va, const void *vb)
     return ((const pdf_range*)va)->low - ((const pdf_range*)vb)->low;
 }
 
-fz_error
+void
 pdf_sortcmap(pdf_cmap *cmap)
 {
-    fz_error error;
-    pdf_range *newranges;
-    unsigned short *newtable;
     pdf_range *a;			/* last written range on output */
     pdf_range *b;			/* current range examined on input */
 
     if (cmap->rlen == 0)
-	return fz_okay;
+	return;
 
     qsort(cmap->ranges, cmap->rlen, sizeof(pdf_range), cmprange);
 
@@ -357,9 +299,7 @@ pdf_sortcmap(pdf_cmap *cmap)
 		else if (a->flag == PDF_CMAP_TABLE && b->flag == PDF_CMAP_SINGLE)
 		{
 		    a->high = b->high;
-		    error = addtable(cmap, b->offset);
-		    if (error)
-			return fz_rethrow(error, "cannot convert LS -> L");
+		    addtable(cmap, b->offset);
 		}
 
 		/* LR -> LR */
@@ -383,15 +323,8 @@ pdf_sortcmap(pdf_cmap *cmap)
 		{
 		    a->flag = PDF_CMAP_TABLE;
 		    a->high = b->high;
-
-		    error = addtable(cmap, a->offset);
-		    if (error)
-			return fz_rethrow(error, "cannot convert SS -> L");
-
-		    error = addtable(cmap, b->offset);
-		    if (error)
-			return fz_rethrow(error, "cannot convert SS -> L");
-
+		    addtable(cmap, a->offset);
+		    addtable(cmap, b->offset);
 		    a->offset = cmap->tlen - 2;
 		}
 
@@ -399,9 +332,7 @@ pdf_sortcmap(pdf_cmap *cmap)
 		else if (a->flag == PDF_CMAP_TABLE && b->flag == PDF_CMAP_SINGLE)
 		{
 		    a->high = b->high;
-		    error = addtable(cmap, b->offset);
-		    if (error)
-			return fz_rethrow(error, "cannot convert LS -> L");
+		    addtable(cmap, b->offset);
 		}
 
 		/* XX -> XX */
@@ -420,25 +351,6 @@ pdf_sortcmap(pdf_cmap *cmap)
 
 	b ++;
     }
-
-    cmap->rlen = a - cmap->ranges + 1;
-
-    newranges = fz_realloc(cmap->ranges, cmap->rlen * sizeof(pdf_range));
-    if (!newranges)
-	return fz_rethrow(-1, "out of memory: cmap ranges");
-    cmap->rcap = cmap->rlen;
-    cmap->ranges = newranges;
-
-    if (cmap->tlen)
-    {
-	newtable = fz_realloc(cmap->table, cmap->tlen * sizeof(unsigned short));
-	if (!newtable)
-	    return fz_rethrow(-1, "out of memory: cmap table");
-	cmap->tcap = cmap->tlen;
-	cmap->table = newtable;
-    }
-
-    return fz_okay;
 }
 
 /*
diff --git a/mupdf/pdf_cmap_load.c b/mupdf/pdf_cmap_load.c
index 7376abac..97a7cb3c 100644
--- a/mupdf/pdf_cmap_load.c
+++ b/mupdf/pdf_cmap_load.c
@@ -92,40 +92,16 @@ cleanup:
 /*
  * Create an Identity-* CMap (for both 1 and 2-byte encodings)
  */
-fz_error
-pdf_newidentitycmap(pdf_cmap **cmapp, int wmode, int bytes)
+pdf_cmap *
+pdf_newidentitycmap(int wmode, int bytes)
 {
-    fz_error error;
-    pdf_cmap *cmap;
-
-    error = pdf_newcmap(&cmap);
-    if (error)
-	return fz_rethrow(error, "cannot create cmap");
-
+    pdf_cmap *cmap = pdf_newcmap();
     sprintf(cmap->cmapname, "Identity-%c", wmode ? 'V' : 'H');
-
-    error = pdf_addcodespace(cmap, 0x0000, 0xffff, bytes);
-    if (error) {
-	pdf_dropcmap(cmap);
-	return fz_rethrow(error, "cannot add code space");
-    }
-
-    error = pdf_maprangetorange(cmap, 0x0000, 0xffff, 0);
-    if (error) {
-	pdf_dropcmap(cmap);
-	return fz_rethrow(error, "cannot map <0000> to <ffff>");
-    }
-
-    error = pdf_sortcmap(cmap);
-    if (error) {
-	pdf_dropcmap(cmap);
-	return fz_rethrow(error, "cannot sort cmap");
-    }
-
+    pdf_addcodespace(cmap, 0x0000, 0xffff, bytes);
+    pdf_maprangetorange(cmap, 0x0000, 0xffff, 0);
+    pdf_sortcmap(cmap);
     pdf_setwmode(cmap, wmode);
-
-    *cmapp = cmap;
-    return fz_okay;
+    return cmap;
 }
 
 /*
diff --git a/mupdf/pdf_cmap_parse.c b/mupdf/pdf_cmap_parse.c
index 0e5ceec5..b8f11751 100644
--- a/mupdf/pdf_cmap_parse.c
+++ b/mupdf/pdf_cmap_parse.c
@@ -124,9 +124,7 @@ static fz_error parsecodespacerange(pdf_cmap *cmap, fz_stream *file)
 	    if (tok == PDF_TSTRING)
 	    {
 		hi = codefromstring(buf, len);
-		error = pdf_addcodespace(cmap, lo, hi, len);
-		if (error)
-		    return fz_rethrow(error, "cannot add code space");
+		pdf_addcodespace(cmap, lo, hi, len);
 	    }
 	    else break;
 	}
@@ -175,9 +173,7 @@ static fz_error parsecidrange(pdf_cmap *cmap, fz_stream *file)
 
 	dst = atoi(buf);
 
-	error = pdf_maprangetorange(cmap, lo, hi, dst);
-	if (error)
-	    return fz_rethrow(error, "cannot map cidrange");
+	pdf_maprangetorange(cmap, lo, hi, dst);
     }
 }
 
@@ -211,9 +207,7 @@ static fz_error parsecidchar(pdf_cmap *cmap, fz_stream *file)
 
 	dst = atoi(buf);
 
-	error = pdf_maprangetorange(cmap, src, src, dst);
-	if (error)
-	    return fz_rethrow(error, "cannot map cidchar");
+	pdf_maprangetorange(cmap, src, src, dst);
     }
 }
 
@@ -244,9 +238,7 @@ static fz_error parsebfrangearray(pdf_cmap *cmap, fz_stream *file, int lo, int h
 	    for (i = 0; i < len / 2; i++)
 		dst[i] = codefromstring(buf + i * 2, 2);
 
-	    error = pdf_maponetomany(cmap, lo, dst, len / 2);
-	    if (error)
-		return fz_rethrow(error, "cannot map bfrange array");
+	    pdf_maponetomany(cmap, lo, dst, len / 2);
 	}
 
 	lo ++;
@@ -292,9 +284,7 @@ static fz_error parsebfrange(pdf_cmap *cmap, fz_stream *file)
 	    if (len == 2)
 	    {
 		dst = codefromstring(buf, len);
-		error = pdf_maprangetorange(cmap, lo, hi, dst);
-		if (error)
-		    return fz_rethrow(error, "cannot map bfrange");
+		pdf_maprangetorange(cmap, lo, hi, dst);
 	    }
 	    else
 	    {
@@ -309,9 +299,7 @@ static fz_error parsebfrange(pdf_cmap *cmap, fz_stream *file)
 		    while (lo <= hi)
 		    {
 			dststr[i-1] ++;
-			error = pdf_maponetomany(cmap, lo, dststr, i);
-			if (error)
-			    return fz_rethrow(error, "cannot map bfrange");
+			pdf_maponetomany(cmap, lo, dststr, i);
 			lo ++;
 		    }
 		}
@@ -367,10 +355,7 @@ static fz_error parsebfchar(pdf_cmap *cmap, fz_stream *file)
 	{
 	    for (i = 0; i < len / 2; i++)
 		dst[i] = codefromstring(buf + i * 2, 2);
-
-	    error = pdf_maponetomany(cmap, src, dst, i);
-	    if (error)
-		return fz_rethrow(error, "cannot map bfchar");
+	    pdf_maponetomany(cmap, src, dst, i);
 	}
     }
 }
@@ -385,9 +370,7 @@ pdf_parsecmap(pdf_cmap **cmapp, fz_stream *file)
     pdf_token_e tok;
     int len;
 
-    error = pdf_newcmap(&cmap);
-    if (error)
-	return fz_rethrow(error, "cannot create cmap");
+    cmap = pdf_newcmap();
 
     strcpy(key, ".notdef");
 
@@ -485,12 +468,7 @@ pdf_parsecmap(pdf_cmap **cmapp, fz_stream *file)
 	/* ignore everything else */
     }
 
-    error = pdf_sortcmap(cmap);
-    if (error)
-    {
-	error = fz_rethrow(error, "cannot sort cmap");
-	goto cleanup;
-    }
+    pdf_sortcmap(cmap);
 
     *cmapp = cmap;
     return fz_okay;
diff --git a/mupdf/pdf_colorspace1.c b/mupdf/pdf_colorspace1.c
index d798649c..38b645e1 100644
--- a/mupdf/pdf_colorspace1.c
+++ b/mupdf/pdf_colorspace1.c
@@ -222,17 +222,13 @@ fz_colorspace *pdf_devicepattern = &kdevicepattern;
  * Colorspace parsing
  */
 
-#ifdef USECAL
-
-static fz_error
-loadcalgray(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
+static fz_colorspace *
+loadcalgray(pdf_xref *xref, fz_obj *dict)
 {
 	struct calgray *cs;
 	fz_obj *tmp;
 
 	cs = fz_malloc(sizeof(struct calgray));
-	if (!cs)
-		return fz_rethrow(-1, "out of memory: gray colorspace struct");
 
 	pdf_logrsrc("load CalGray\n");
 
@@ -268,20 +264,17 @@ loadcalgray(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
 	if (fz_isreal(tmp))
 		cs->gamma = fz_toreal(tmp);
 
-	*csp = (fz_colorspace*) cs;
-	return fz_okay;
+	return (fz_colorspace*) cs;
 }
 
-static fz_error
-loadcalrgb(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
+static fz_colorspace *
+loadcalrgb(pdf_xref *xref, fz_obj *dict)
 {
 	struct calrgb *cs;
 	fz_obj *tmp;
 	int i;
 
 	cs = fz_malloc(sizeof(struct calrgb));
-	if (!cs)
-		return fz_rethrow(-1, "out of memory: RGB colorspace struct");
 
 	pdf_logrsrc("load CalRGB\n");
 
@@ -336,19 +329,16 @@ loadcalrgb(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
 
 	fz_invert3x3(cs->invmat, cs->matrix);
 
-	*csp = (fz_colorspace*) cs;
-	return fz_okay;
+	return (fz_colorspace*) cs;
 }
 
-static fz_error
-loadlab(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
+static fz_colorspace *
+loadlab(pdf_xref *xref, fz_obj *dict)
 {
 	struct cielab *cs;
 	fz_obj *tmp;
 
 	cs = fz_malloc(sizeof(struct cielab));
-	if (!cs)
-		return fz_rethrow(-1, "out of memory: L*a*b colorspace struct");
 
 	pdf_logrsrc("load Lab\n");
 
@@ -392,12 +382,9 @@ loadlab(fz_colorspace **csp, pdf_xref *xref, fz_obj *dict)
 		cs->range[3] = fz_toreal(fz_arrayget(tmp, 3));
 	}
 
-	*csp = (fz_colorspace*) cs;
-	return fz_okay;
+	return (fz_colorspace*) cs;
 }
 
-#endif
-
 /*
  * ICCBased
  */
@@ -567,11 +554,6 @@ loadindexed(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
 	pdf_logrsrc("base %s\n", base->name);
 
 	cs = fz_malloc(sizeof(pdf_indexed));
-	if (!cs)
-	{
-		fz_dropcolorspace(base);
-		return fz_rethrow(-1, "out of memory: indexed colorspace struct");
-	}
 
 	initcs((fz_colorspace*)cs, "Indexed", 1, nil, nil, dropindexed);
 
@@ -579,13 +561,7 @@ loadindexed(fz_colorspace **csp, pdf_xref *xref, fz_obj *array)
 	cs->high = fz_toint(highobj);
 
 	n = base->n * (cs->high + 1);
-
 	cs->lookup = fz_malloc(n);
-	if (!cs->lookup)
-	{
-		fz_dropcolorspace((fz_colorspace*)cs);
-		return fz_rethrow(-1, "out of memory: indexed colorspace lookup table (%d entries)", n);
-	}
 
 	if (fz_isstring(lookup) && fz_tostrlen(lookup) == n)
 	{
@@ -663,21 +639,12 @@ pdf_loadcolorspaceimp(fz_colorspace **csp, pdf_xref *xref, fz_obj *obj)
 			if (!strcmp(fz_toname(name), "CalCMYK"))
 				*csp = pdf_devicecmyk;
 
-#ifdef USECAL
 			else if (!strcmp(fz_toname(name), "CalGray"))
-				return loadcalgray(csp, xref, fz_arrayget(obj, 1));
+				*csp = loadcalgray(xref, fz_arrayget(obj, 1));
 			else if (!strcmp(fz_toname(name), "CalRGB"))
-				return loadcalrgb(csp, xref, fz_arrayget(obj, 1));
+				*csp = loadcalrgb(xref, fz_arrayget(obj, 1));
 			else if (!strcmp(fz_toname(name), "Lab"))
-				return loadlab(csp, xref, fz_arrayget(obj, 1));
-#else
-			else if (!strcmp(fz_toname(name), "CalGray"))
-				*csp = pdf_devicegray;
-			else if (!strcmp(fz_toname(name), "CalRGB"))
-				*csp = pdf_devicergb;
-			else if (!strcmp(fz_toname(name), "Lab"))
-				*csp = pdf_devicelab;
-#endif
+				*csp = loadlab(xref, fz_arrayget(obj, 1));
 
 			else if (!strcmp(fz_toname(name), "ICCBased"))
 				return loadiccbased(csp, xref, fz_arrayget(obj, 1));
diff --git a/mupdf/pdf_crypt.c b/mupdf/pdf_crypt.c
index 13973326..b1886231 100644
--- a/mupdf/pdf_crypt.c
+++ b/mupdf/pdf_crypt.c
@@ -14,9 +14,6 @@ pdf_newcrypt(pdf_crypt **cryptp, fz_obj *dict, fz_obj *id)
     fz_obj *obj;
 
     crypt = fz_malloc(sizeof(pdf_crypt));
-    if (!crypt)
-	return fz_rethrow(-1, "out of memory: crypt struct");
-
     memset(crypt, 0x00, sizeof(pdf_crypt));
     crypt->cf = nil;
 
diff --git a/mupdf/pdf_font.c b/mupdf/pdf_font.c
index d0d3007f..7ae140fc 100644
--- a/mupdf/pdf_font.c
+++ b/mupdf/pdf_font.c
@@ -183,9 +183,6 @@ pdf_newfontdesc(void)
 	pdf_fontdesc *fontdesc;
 
 	fontdesc = fz_malloc(sizeof (pdf_fontdesc));
-	if (!fontdesc)
-		return nil;
-
 	fontdesc->refs = 1;
 
 	fontdesc->font = nil;
@@ -266,8 +263,6 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict)
 	 */
 
 	fontdesc = pdf_newfontdesc();
-	if (!fontdesc)
-		return fz_rethrow(-1, "out of memory");
 
 	pdf_logfont("load simple font (%d %d R) ptr=%p {\n", fz_tonum(dict), fz_togen(dict), fontdesc);
 	pdf_logfont("basefont0 %s\n", basefont);
@@ -338,9 +333,6 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict)
 		fz_warn("freetype could not find any cmaps");
 
 	etable = fz_malloc(sizeof(unsigned short) * 256);
-	if (!etable)
-		goto cleanup;
-
 	for (i = 0; i < 256; i++)
 	{
 		estrings[i] = nil;
@@ -472,10 +464,7 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict)
 		}
 	}
 
-	error = pdf_newidentitycmap(&fontdesc->encoding, 0, 1);
-	if (error)
-		goto cleanup;
-
+	fontdesc->encoding = pdf_newidentitycmap(0, 1);
 	fontdesc->ncidtogid = 256;
 	fontdesc->cidtogid = etable;
 
@@ -503,9 +492,7 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict)
 		for (i = 0; i < last - first + 1; i++)
 		{
 			int wid = fz_toint(fz_arrayget(widths, i));
-			error = pdf_addhmtx(fontdesc, i + first, i + first, wid);
-			if (error)
-				goto cleanup;
+			pdf_addhmtx(fontdesc, i + first, i + first, wid);
 		}
 	}
 	else
@@ -515,15 +502,11 @@ loadsimplefont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict)
 			fz_warn("freetype set character size: %s", ft_errorstring(fterr));
 		for (i = 0; i < 256; i++)
 		{
-			error = pdf_addhmtx(fontdesc, i, i, ftwidth(fontdesc, i));
-			if (error)
-				goto cleanup;
+			pdf_addhmtx(fontdesc, i, i, ftwidth(fontdesc, i));
 		}
 	}
 
-	error = pdf_endhmtx(fontdesc);
-	if (error)
-		goto cleanup;
+	pdf_endhmtx(fontdesc);
 
 	pdf_logfont("}\n");
 
@@ -625,13 +608,14 @@ loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *enco
 	 * Encoding
 	 */
 
+	error = fz_okay;
 	if (fz_isname(encoding))
 	{
 		pdf_logfont("encoding /%s\n", fz_toname(encoding));
 		if (!strcmp(fz_toname(encoding), "Identity-H"))
-			error = pdf_newidentitycmap(&fontdesc->encoding, 0, 2);
+			fontdesc->encoding = pdf_newidentitycmap(0, 2);
 		else if (!strcmp(fz_toname(encoding), "Identity-V"))
-			error = pdf_newidentitycmap(&fontdesc->encoding, 1, 2);
+			fontdesc->encoding = pdf_newidentitycmap(1, 2);
 		else
 			error = pdf_loadsystemcmap(&fontdesc->encoding, fz_toname(encoding));
 	}
@@ -657,9 +641,7 @@ loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *enco
 		cidtogidmap = fz_dictgets(dict, "CIDToGIDMap");
 		if (fz_isindirect(cidtogidmap))
 		{
-			unsigned short *map;
 			fz_buffer *buf;
-			int len;
 
 			pdf_logfont("cidtogidmap stream\n");
 
@@ -667,20 +649,10 @@ loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *enco
 			if (error)
 				goto cleanup;
 
-			len = (buf->wp - buf->rp) / 2;
-
-			map = fz_malloc(len * sizeof(unsigned short));
-			if (!map) {
-				fz_dropbuffer(buf);
-				error = fz_rethrow(-1, "out of memory: cidtogidmap");
-				goto cleanup;
-			}
-
-			for (i = 0; i < len; i++)
-				map[i] = (buf->rp[i * 2] << 8) + buf->rp[i * 2 + 1];
-
-			fontdesc->ncidtogid = len;
-			fontdesc->cidtogid = map;
+			fontdesc->ncidtogid = (buf->wp - buf->rp) / 2;
+			fontdesc->cidtogid = fz_malloc(fontdesc->ncidtogid * sizeof(unsigned short));
+			for (i = 0; i < fontdesc->ncidtogid; i++)
+				fontdesc->cidtogid[i] = (buf->rp[i * 2] << 8) + buf->rp[i * 2 + 1];
 
 			fz_dropbuffer(buf);
 		}
@@ -745,9 +717,7 @@ loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *enco
 				for (k = 0; k < fz_arraylen(obj); k++)
 				{
 					w = fz_toint(fz_arrayget(obj, k));
-					error = pdf_addhmtx(fontdesc, c0 + k, c0 + k, w);
-					if (error)
-						goto cleanup;
+					pdf_addhmtx(fontdesc, c0 + k, c0 + k, w);
 				}
 				i += 2;
 			}
@@ -755,17 +725,13 @@ loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *enco
 			{
 				c1 = fz_toint(obj);
 				w = fz_toint(fz_arrayget(widths, i + 2));
-				error = pdf_addhmtx(fontdesc, c0, c1, w);
-				if (error)
-					goto cleanup;
+				pdf_addhmtx(fontdesc, c0, c1, w);
 				i += 3;
 			}
 		}
 	}
 
-	error = pdf_endhmtx(fontdesc);
-	if (error)
-		goto cleanup;
+	pdf_endhmtx(fontdesc);
 
 	/*
 	 * Vertical
@@ -802,9 +768,7 @@ loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *enco
 						w = fz_toint(fz_arrayget(obj, k + 0));
 						x = fz_toint(fz_arrayget(obj, k + 1));
 						y = fz_toint(fz_arrayget(obj, k + 2));
-						error = pdf_addvmtx(fontdesc, c0 + k, c0 + k, x, y, w);
-						if (error)
-							goto cleanup;
+						pdf_addvmtx(fontdesc, c0 + k, c0 + k, x, y, w);
 					}
 					i += 2;
 				}
@@ -814,17 +778,13 @@ loadcidfont(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *dict, fz_obj *enco
 					w = fz_toint(fz_arrayget(widths, i + 2));
 					x = fz_toint(fz_arrayget(widths, i + 3));
 					y = fz_toint(fz_arrayget(widths, i + 4));
-					error = pdf_addvmtx(fontdesc, c0, c1, x, y, w);
-					if (error)
-						goto cleanup;
+					pdf_addvmtx(fontdesc, c0, c1, x, y, w);
 					i += 5;
 				}
 			}
 		}
 
-		error = pdf_endvmtx(fontdesc);
-		if (error)
-			goto cleanup;
+		pdf_endvmtx(fontdesc);
 	}
 
 	pdf_logfont("}\n");
diff --git a/mupdf/pdf_fontmtx.c b/mupdf/pdf_fontmtx.c
index 6355461a..9af5352c 100644
--- a/mupdf/pdf_fontmtx.c
+++ b/mupdf/pdf_fontmtx.c
@@ -20,44 +20,28 @@ pdf_setdefaultvmtx(pdf_fontdesc *font, int y, int w)
 	font->dvmtx.w = w;
 }
 
-fz_error
+void
 pdf_addhmtx(pdf_fontdesc *font, int lo, int hi, int w)
 {
-	int newcap;
-	pdf_hmtx *newmtx;
-
 	if (font->nhmtx + 1 >= font->hmtxcap)
 	{
-		newcap = font->hmtxcap + 16;
-		newmtx = fz_realloc(font->hmtx, sizeof(pdf_hmtx) * newcap);
-		if (!newmtx)
-			return fz_rethrow(-1, "out of memory");
-		font->hmtxcap = newcap;
-		font->hmtx = newmtx;
+		font->hmtxcap = font->hmtxcap + 16;
+		font->hmtx = fz_realloc(font->hmtx, sizeof(pdf_hmtx) * font->hmtxcap);
 	}
 
 	font->hmtx[font->nhmtx].lo = lo;
 	font->hmtx[font->nhmtx].hi = hi;
 	font->hmtx[font->nhmtx].w = w;
 	font->nhmtx++;
-
-	return fz_okay;
 }
 
-fz_error
+void
 pdf_addvmtx(pdf_fontdesc *font, int lo, int hi, int x, int y, int w)
 {
-	int newcap;
-	pdf_vmtx *newmtx;
-
 	if (font->nvmtx + 1 >= font->vmtxcap)
 	{
-		newcap = font->vmtxcap + 16;
-		newmtx = fz_realloc(font->vmtx, sizeof(pdf_vmtx) * newcap);
-		if (!newmtx)
-			return fz_rethrow(-1, "out of memory");
-		font->vmtxcap = newcap;
-		font->vmtx = newmtx;
+		font->vmtxcap = font->vmtxcap + 16;
+		font->vmtx = fz_realloc(font->vmtx, sizeof(pdf_vmtx) * font->vmtxcap);
 	}
 
 	font->vmtx[font->nvmtx].lo = lo;
@@ -66,8 +50,6 @@ pdf_addvmtx(pdf_fontdesc *font, int lo, int hi, int x, int y, int w)
 	font->vmtx[font->nvmtx].y = y;
 	font->vmtx[font->nvmtx].w = w;
 	font->nvmtx++;
-
-	return fz_okay;
 }
 
 static int cmph(const void *a0, const void *b0)
@@ -84,42 +66,20 @@ static int cmpv(const void *a0, const void *b0)
 	return a->lo - b->lo;
 }
 
-fz_error
+void
 pdf_endhmtx(pdf_fontdesc *font)
 {
-	pdf_hmtx *newmtx;
-
 	if (!font->hmtx)
-		return fz_okay;
-
+		return;
 	qsort(font->hmtx, font->nhmtx, sizeof(pdf_hmtx), cmph);
-
-	newmtx = fz_realloc(font->hmtx, sizeof(pdf_hmtx) * font->nhmtx);
-	if (!newmtx)
-		return fz_rethrow(-1, "out of memory");
-	font->hmtxcap = font->nhmtx;
-	font->hmtx = newmtx;
-
-	return fz_okay;
 }
 
-fz_error
+void
 pdf_endvmtx(pdf_fontdesc *font)
 {
-	pdf_vmtx *newmtx;
-
 	if (!font->vmtx)
-		return fz_okay;
-
+		return;
 	qsort(font->vmtx, font->nvmtx, sizeof(pdf_vmtx), cmpv);
-
-	newmtx = fz_realloc(font->vmtx, sizeof(pdf_vmtx) * font->nvmtx);
-	if (!newmtx)
-		return fz_rethrow(-1, "out of memory");
-	font->vmtxcap = font->nvmtx;
-	font->vmtx = newmtx;
-
-	return fz_okay;
 }
 
 pdf_hmtx
diff --git a/mupdf/pdf_function.c b/mupdf/pdf_function.c
index 82baf1b6..ec9a0b4c 100644
--- a/mupdf/pdf_function.c
+++ b/mupdf/pdf_function.c
@@ -306,20 +306,14 @@ pspop(psstack *st)
 	return fz_okay;
 }
 
-static fz_error
+static void
 resizecode(pdf_function *func, int newsize)
 {
 	if (newsize >= func->u.p.cap)
 	{
-		int newcodecap = func->u.p.cap + 64;
-		psobj *newcode;
-		newcode = fz_realloc(func->u.p.code, newcodecap * sizeof(psobj));
-		if (!newcode)
-			return fz_rethrow(-1, "out of memory: calculator function code");
-		func->u.p.cap = newcodecap;
-		func->u.p.code = newcode;
+		func->u.p.cap = func->u.p.cap + 64;
+		func->u.p.code = fz_realloc(func->u.p.code, func->u.p.cap * sizeof(psobj));
 	}
-	return fz_okay;
 }
 
 static fz_error
@@ -346,18 +340,14 @@ parsecode(pdf_function *func, fz_stream *stream, int *codeptr)
 			return fz_throw("truncated calculator function");
 
 		case PDF_TINT:
-			error = resizecode(func, *codeptr);
-			if (error)
-				return fz_rethrow(error, "resize calculator function code");
+			resizecode(func, *codeptr);
 			func->u.p.code[*codeptr].type = PSINT;
 			func->u.p.code[*codeptr].u.i = atoi(buf);
 			++*codeptr;
 			break;
 
 		case PDF_TREAL:
-			error = resizecode(func, *codeptr);
-			if (error)
-				return fz_rethrow(error, "resize calculator function code");
+			resizecode(func, *codeptr);
 			func->u.p.code[*codeptr].type = PSREAL;
 			func->u.p.code[*codeptr].u.f = atof(buf);
 			++*codeptr;
@@ -367,9 +357,7 @@ parsecode(pdf_function *func, fz_stream *stream, int *codeptr)
 			opptr = *codeptr;
 			*codeptr += 3;
 
-			error = resizecode(func, opptr + 2);
-			if (error)
-				return fz_rethrow(error, "resize calculator function code");
+			resizecode(func, opptr + 2);
 
 			error = parsecode(func, stream, codeptr);
 			if (error)
@@ -429,9 +417,7 @@ parsecode(pdf_function *func, fz_stream *stream, int *codeptr)
 			break;
 
 		case PDF_TCBRACE:
-			error = resizecode(func, *codeptr);
-			if (error)
-				return fz_rethrow(error, "resize calculator function code");
+			resizecode(func, *codeptr);
 			func->u.p.code[*codeptr].type = PSOPERATOR;
 			func->u.p.code[*codeptr].u.op = PSORETURN;
 			++*codeptr;
@@ -455,10 +441,7 @@ parsecode(pdf_function *func, fz_stream *stream, int *codeptr)
 			if (cmp != 0)
 				return fz_throw("unknown operator: '%s'", buf);
 
-			error = resizecode(func, *codeptr);
-			if (error)
-				return fz_rethrow(error, "resize calculator function code");
-
+			resizecode(func, *codeptr);
 			func->u.p.code[*codeptr].type = PSOPERATOR;
 			func->u.p.code[*codeptr].u.op = a;
 			++*codeptr;
@@ -1009,8 +992,6 @@ loadsamplefunc(pdf_function *func, pdf_xref *xref, fz_obj *dict, int oid, int ge
 	pdf_logrsrc("samplecount %d\n", samplecount);
 
 	func->u.sa.samples = fz_malloc(samplecount * sizeof(int));
-	if (!func->u.sa.samples)
-		return fz_rethrow(-1, "out of memory: samples");
 
 	error = pdf_openstream(&stream, xref, oid, gen);
 	if (error)
@@ -1101,8 +1082,6 @@ evalsamplefunc(pdf_function *func, float *in, float *out)
 	{
 		s0 = fz_malloc((1 << func->m) * 2 * sizeof(float));
 		s1 = s0 + (1 << func->m);
-		if (!s0)
-			return fz_rethrow(-1, "out of memory: scratch buffer");
 	}
 
 	/* FIXME i think this is wrong... test with 2 samples it gets wrong idxs */
@@ -1254,24 +1233,9 @@ loadstitchingfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict)
 		pdf_logrsrc("k %d\n", func->u.st.k);
 
 		func->u.st.funcs = fz_malloc(func->u.st.k * sizeof (pdf_function));
-		if (!func->u.st.funcs)
-			return fz_throw("out of memory");
-		funcs = func->u.st.funcs;
-
 		func->u.st.bounds = fz_malloc((func->u.st.k - 1) * sizeof (float));
-		if (!func->u.st.bounds)
-		{
-			fz_free(func->u.st.funcs);
-			return fz_throw("out of memory");
-		}
-
 		func->u.st.encode = fz_malloc(func->u.st.k * 2 * sizeof (float));
-		if (!func->u.st.encode)
-		{
-			fz_free(func->u.st.funcs);
-			fz_free(func->u.st.bounds);
-			return fz_throw("out of memory");
-		}
+		funcs = func->u.st.funcs;
 
 		for (i = 0; i < k; ++i)
 		{
@@ -1317,7 +1281,6 @@ loadstitchingfunc(pdf_function *func, pdf_xref *xref, fz_obj *dict)
 	{
 		if (!fz_isarray(obj) || fz_arraylen(obj) != k * 2)
 			return fz_throw("malformed /Encode");
-
 		for (i = 0; i < k; ++i)
 		{
 			func->u.st.encode[i*2+0] = fz_toreal(fz_arrayget(obj, i*2+0));
@@ -1434,9 +1397,6 @@ pdf_loadfunction(pdf_function **funcp, pdf_xref *xref, fz_obj *ref)
 	pdf_logrsrc("load function (%d %d R) {\n", fz_tonum(ref), fz_togen(ref));
 
 	func = fz_malloc(sizeof(pdf_function));
-	if (!func)
-		return fz_rethrow(-1, "out of memory: function struct");
-
 	memset(func, 0, sizeof(pdf_function));
 	func->refs = 1;
 
diff --git a/mupdf/pdf_image.c b/mupdf/pdf_image.c
index 21f05180..ca7a6a83 100644
--- a/mupdf/pdf_image.c
+++ b/mupdf/pdf_image.c
@@ -29,8 +29,6 @@ pdf_loadinlineimage(pdf_image **imgp, pdf_xref *xref,
 	int i;
 
 	img = fz_malloc(sizeof(pdf_image));
-	if (!img)
-		return fz_rethrow(-1, "out of memory: image struct");
 
 	pdf_logimage("load inline image %p {\n", img);
 
@@ -235,8 +233,6 @@ pdf_loadimage(pdf_image **imgp, pdf_xref *xref, fz_obj *dict)
 	}
 
 	img = fz_malloc(sizeof(pdf_image));
-	if (!img)
-		return fz_rethrow(-1, "out of memory: image struct");
 
 	pdf_logimage("load image (%d %d R) ptr=%p {\n", fz_tonum(dict), fz_togen(dict), img);
 
diff --git a/mupdf/pdf_interpret.c b/mupdf/pdf_interpret.c
index d2fc49d6..170db8c9 100644
--- a/mupdf/pdf_interpret.c
+++ b/mupdf/pdf_interpret.c
@@ -9,8 +9,6 @@ pdf_newcsi(pdf_csi **csip, int maskonly)
 	fz_node *node;
 
 	csi = fz_malloc(sizeof(pdf_csi));
-	if (!csi)
-		return fz_rethrow(-1, "out of memory: interpreter struct");
 
 	pdf_initgstate(&csi->gstate[0]);
 
diff --git a/mupdf/pdf_open.c b/mupdf/pdf_open.c
index 81af23af..ec33414d 100644
--- a/mupdf/pdf_open.c
+++ b/mupdf/pdf_open.c
@@ -253,8 +253,6 @@ readoldxref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 			fz_warn("broken xref section, proceeding anyway.");
 			xref->cap = ofs + len;
 			xref->table = fz_realloc(xref->table, xref->cap * sizeof(pdf_xrefentry));
-			if (!xref->table)
-				return fz_rethrow(-1, "out of memory: xref table");
 		}
 
 		if ((ofs + len) > xref->len)
@@ -385,11 +383,6 @@ readnewxref(fz_obj **trailerp, pdf_xref *xref, char *buf, int cap)
 	{
 		xref->cap = size + 1; /* for hack to allow broken pdf generators with off-by-one errors */
 		xref->table = fz_realloc(xref->table, xref->cap * sizeof(pdf_xrefentry));
-		if (!xref->table)
-		{
-			fz_dropobj(trailer);
-			return fz_rethrow(-1, "out of memory: xref table");
-		}
 	}
 
 	if (size > xref->len)
@@ -587,24 +580,13 @@ pdf_loadobjstm(pdf_xref *xref, int oid, int gen, char *buf, int cap)
 	pdf_logxref("  count %d\n", count);
 
 	oidbuf = fz_malloc(count * sizeof(int));
-	if (!oidbuf)
-	{
-		error = fz_rethrow(-1, "out of memory: object id buffer");
-		goto cleanupobj;
-	}
-
 	ofsbuf = fz_malloc(count * sizeof(int));
-	if (!ofsbuf)
-	{
-		error = fz_rethrow(-1, "out of memory: offset buffer");
-		goto cleanupoid;
-	}
 
 	error = pdf_openstream(&stm, xref, oid, gen);
 	if (error)
 	{
 		error = fz_rethrow(error, "cannot open object stream");
-		goto cleanupofs;
+		goto cleanupbuf;
 	}
 
 	for (i = 0; i < count; i++)
@@ -664,11 +646,9 @@ pdf_loadobjstm(pdf_xref *xref, int oid, int gen, char *buf, int cap)
 
 cleanupstm:
 	fz_dropstream(stm);
-cleanupofs:
+cleanupbuf:
 	fz_free(ofsbuf);
-cleanupoid:
 	fz_free(oidbuf);
-cleanupobj:
 	fz_dropobj(objstm);
 	return error; /* already rethrown */
 }
@@ -729,12 +709,6 @@ pdf_loadxref(pdf_xref *xref, char *filename)
 	xref->len = fz_toint(size);
 	xref->cap = xref->len + 1; /* for hack to allow broken pdf generators with off-by-one errors */
 	xref->table = fz_malloc(xref->cap * sizeof(pdf_xrefentry));
-	if (!xref->table)
-	{
-		error = fz_rethrow(-1, "out of memory: xref table");
-		goto cleanup;
-	}
-
 	for (i = 0; i < xref->cap; i++)
 	{
 		xref->table[i].ofs = 0;
diff --git a/mupdf/pdf_page.c b/mupdf/pdf_page.c
index 072d663e..5caca8b3 100644
--- a/mupdf/pdf_page.c
+++ b/mupdf/pdf_page.c
@@ -230,13 +230,6 @@ pdf_loadpage(pdf_page **pagep, pdf_xref *xref, fz_obj *dict)
 	 */
 
 	page = fz_malloc(sizeof(pdf_page));
-	if (!page)
-	{
-		fz_droptree(tree);
-		fz_dropobj(rdb);
-		return fz_rethrow(-1, "out of memory: page struct");
-	}
-
 	page->mediabox.x0 = MIN(bbox.x0, bbox.x1);
 	page->mediabox.y0 = MIN(bbox.y0, bbox.y1);
 	page->mediabox.x1 = MAX(bbox.x0, bbox.x1);
diff --git a/mupdf/pdf_pattern.c b/mupdf/pdf_pattern.c
index 9f768151..01aadd59 100644
--- a/mupdf/pdf_pattern.c
+++ b/mupdf/pdf_pattern.c
@@ -38,9 +38,6 @@ pdf_loadpattern(pdf_pattern **patp, pdf_xref *xref, fz_obj *dict)
 	pdf_logrsrc("load pattern (%d %d R) {\n", fz_tonum(dict), fz_togen(dict));
 
 	pat = fz_malloc(sizeof(pdf_pattern));
-	if (!pat)
-		return fz_rethrow(-1, "out of memory: pattern struct");
-
 	pat->refs = 1;
 	pat->tree = nil;
 	pat->ismask = fz_toint(fz_dictgets(dict, "PaintType")) == 2;
diff --git a/mupdf/pdf_repair.c b/mupdf/pdf_repair.c
index 3f004e5b..3be1e98d 100644
--- a/mupdf/pdf_repair.c
+++ b/mupdf/pdf_repair.c
@@ -173,11 +173,6 @@ pdf_repairxref(pdf_xref *xref, char *filename)
 	listlen = 0;
 	listcap = 1024;
 	list = fz_malloc(listcap * sizeof(struct entry));
-	if (!list)
-	{
-		error = fz_rethrow(-1, "out of memory: reparation object list");
-		goto cleanup;
-	}
 
 	while (1)
 	{
@@ -226,14 +221,8 @@ pdf_repairxref(pdf_xref *xref, char *filename)
 
 			if (listlen + 1 == listcap)
 			{
-				struct entry *newlist;
-				listcap = listcap * 2;
-				newlist = fz_realloc(list, listcap * sizeof(struct entry));
-				if (!newlist) {
-					error = fz_rethrow(-1, "out of memory: resize reparation object list");
-					goto cleanup;
-				}
-				list = newlist;
+				listcap = (listcap * 3) / 2;
+				list = fz_realloc(list, listcap * sizeof(struct entry));
 			}
 
                         pdf_logxref("found object: (%d %d R)\n", oid, gen);
@@ -274,11 +263,6 @@ pdf_repairxref(pdf_xref *xref, char *filename)
 	xref->len = maxoid + 1;
 	xref->cap = xref->len;
 	xref->table = fz_malloc(xref->cap * sizeof(pdf_xrefentry));
-	if (!xref->table)
-	{
-		error = fz_rethrow(-1, "out of memory: xref table");
-		goto cleanup;
-	}
 
 	xref->table[0].type = 'f';
 	xref->table[0].ofs = 0;
diff --git a/mupdf/pdf_shade.c b/mupdf/pdf_shade.c
index d67bb6a7..c7e27dc6 100644
--- a/mupdf/pdf_shade.c
+++ b/mupdf/pdf_shade.c
@@ -43,11 +43,6 @@ pdf_loadcomponentshadefunc(fz_shade *shade, pdf_xref *xref, fz_obj *dict, fz_obj
 	}
 
 	func = fz_malloc(fz_arraylen(funcs) * sizeof(pdf_function *));
-	if (!func)
-	{
-		error = fz_rethrow(-1, "out of memory: shading function");
-		goto cleanup;
-	}
 	memset(func, 0x00, fz_arraylen(funcs) * sizeof(pdf_function *));
 
 	for (i = 0; i < fz_arraylen(funcs); i++)
@@ -148,9 +143,6 @@ loadshadedict(fz_shade **shadep, pdf_xref *xref, fz_obj *dict, fz_matrix matrix)
 	pdf_logshade("load shade dict (%d %d R) {\n", fz_tonum(dict), fz_togen(dict));
 
 	shade = fz_malloc(sizeof(fz_shade));
-	if (!shade)
-		return fz_rethrow(-1, "out of memory");
-
 	shade->refs = 1;
 	shade->usebackground = 0;
 	shade->usefunction = 0;
diff --git a/mupdf/pdf_shade1.c b/mupdf/pdf_shade1.c
index 0fc3f082..fb037725 100644
--- a/mupdf/pdf_shade1.c
+++ b/mupdf/pdf_shade1.c
@@ -66,8 +66,6 @@ pdf_loadtype1shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict)
 
 	shade->meshlen = NSEGS * NSEGS * 2;
 	shade->mesh = fz_malloc(sizeof(float) * (2 + ncomp) * 3 * shade->meshlen);
-	if (!shade->mesh)
-		return fz_rethrow(-1, "out of memory");
 
 	n = 0;
 	for (yy = 0; yy < NSEGS; ++yy)
@@ -189,8 +187,6 @@ pdf_loadtype2shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict)
 
 	shade->meshlen = 2 + e0 * 2 + e1 * 2;
 	shade->mesh = fz_malloc(sizeof(float) * 3*3 * shade->meshlen);
-	if (!shade->mesh)
-		return fz_rethrow(-1, "out of memory");
 
 	p1.x = x0 + BIGNUM * cos(theta);
 	p1.y = y0 + BIGNUM * sin(theta);
@@ -411,8 +407,6 @@ pdf_loadtype3shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict)
 		{
 			shade->meshlen = pos;
 			shade->mesh = fz_malloc(sizeof(float) * 9 * shade->meshlen);
-			if (!shade->mesh)
-				return fz_rethrow(-1, "out of memory");
 		}
 	}
 
diff --git a/mupdf/pdf_shade4.c b/mupdf/pdf_shade4.c
index d336d4fa..7b2b73f5 100644
--- a/mupdf/pdf_shade4.c
+++ b/mupdf/pdf_shade4.c
@@ -11,21 +11,11 @@ struct pdf_tensorpatch_s
     float color[4][FZ_MAXCOLORS];
 };
 
-static fz_error
+static void
 growshademesh(fz_shade *shade, int amount)
 {
-	float *newmesh;
-	int newcap;
-
-	newcap = shade->meshcap + amount;
-	newmesh = fz_realloc(shade->mesh, sizeof(float) * newcap);
-	if (!newmesh)
-		return fz_rethrow(-1, "out of memory");
-
-	shade->mesh = newmesh;
-	shade->meshcap = newcap;
-
-	return fz_okay;
+	shade->meshcap = shade->meshcap + amount;
+	shade->mesh = fz_realloc(shade->mesh, sizeof(float) * shade->meshcap);
 }
 
 static fz_error
@@ -322,11 +312,7 @@ pdf_loadtype5shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict)
 			{\
 				int z;\
 				if (shade->meshlen + 2 + ncomp >= shade->meshcap) \
-				{ \
-					error = growshademesh(shade, shade->meshcap + 1024); \
-					if (error) \
-						goto cleanup; \
-				} \
+					growshademesh(shade, shade->meshcap + 1024); \
 				shade->mesh[j++] = x[idx];\
 				shade->mesh[j++] = y[idx];\
 				for (z = 0; z < ncomp; ++z) \
@@ -339,9 +325,7 @@ pdf_loadtype5shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict)
 	shade->meshlen = 0;
 	shade->meshcap = 0;
 	shade->mesh = nil;
-	error = growshademesh(shade, 1024);
-	if (error)
-		goto cleanup;
+	growshademesh(shade, 1024);
 
 	j = 0;
 	for (p = 0; p < vpr-1; ++p)
@@ -371,9 +355,6 @@ pdf_loadtype5shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict)
 	pdf_logshade("}\n");
 
 	return fz_okay;
-
-cleanup:
-	return error;
 }
 
 #define SEGMENTATION_DEPTH 2
@@ -528,8 +509,6 @@ static inline int setvertex(float *mesh, fz_point pt, float *color, int ptr, int
 static int
 triangulatepatch(pdf_tensorpatch p, fz_shade *shade, int ptr, int ncomp)
 {
-	fz_error error;
-
 	ptr = setvertex(shade->mesh, p.pole[0][0], p.color[0], ptr, ncomp);
 	ptr = setvertex(shade->mesh, p.pole[3][0], p.color[1], ptr, ncomp);
 	ptr = setvertex(shade->mesh, p.pole[3][3], p.color[2], ptr, ncomp);
@@ -538,17 +517,9 @@ triangulatepatch(pdf_tensorpatch p, fz_shade *shade, int ptr, int ncomp)
 	ptr = setvertex(shade->mesh, p.pole[0][3], p.color[3], ptr, ncomp);
 
 	if (shade->meshcap - 1024 < ptr)
-	{
-		error = growshademesh(shade, 1024);
-		if (error)
-			goto cleanup;
-	}
+		growshademesh(shade, 1024);
 
 	return ptr;
-
-cleanup:
-	/* error handling */
-	return -1;
 }
 
 static int
@@ -647,9 +618,7 @@ pdf_loadtype6shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict)
 
 	shade->meshcap = 0;
 	shade->mesh = nil;
-	error = growshademesh(shade, 1024);
-	if (error)
-		goto cleanup;
+	growshademesh(shade, 1024);
 
 	n = 2 + ncomp;
 	j = 0;
@@ -705,9 +674,6 @@ pdf_loadtype6shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict)
 	pdf_logshade("}\n");
 
 	return fz_okay;
-
-cleanup:
-	return error;
 }
 
 fz_error
@@ -760,8 +726,7 @@ pdf_loadtype7shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict)
 
 	shade->meshcap = 0;
 	shade->mesh = nil;
-	error = growshademesh(shade, 1024);
-	if (error) goto cleanup;
+	growshademesh(shade, 1024);
 
 	n = 2 + ncomp;
 	j = 0;
@@ -820,8 +785,5 @@ pdf_loadtype7shade(fz_shade *shade, pdf_xref *xref, fz_obj *dict)
 	pdf_logshade("}\n");
 
 	return fz_okay;
-
-cleanup:
-	return error;
 }
 
diff --git a/mupdf/pdf_store.c b/mupdf/pdf_store.c
index cf5b57f0..0fe2df54 100644
--- a/mupdf/pdf_store.c
+++ b/mupdf/pdf_store.c
@@ -93,11 +93,9 @@ pdf_store *
 pdf_newstore(void)
 {
 	pdf_store *store;
-
 	store = fz_malloc(sizeof(pdf_store));
 	store->hash = fz_newhash(4096, sizeof(struct refkey));
 	store->root = nil;
-
 	return store;
 }
 
diff --git a/mupdf/pdf_type3.c b/mupdf/pdf_type3.c
index 1e010ef9..c4616b0a 100644
--- a/mupdf/pdf_type3.c
+++ b/mupdf/pdf_type3.c
@@ -86,12 +86,7 @@ pdf_loadtype3font(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *rdb, fz_obj
 	bbox.x1 = fz_ceil(bbox.x1 * 1000);
 	bbox.y1 = fz_ceil(bbox.y1 * 1000);
 
-	error = fz_newtype3font(&fontdesc->font, buf, matrix);
-	if (error)
-	{
-	    pdf_dropfont(fontdesc);
-	    return fz_rethrow(error, "could not create type3 font");
-	}
+	fontdesc->font = fz_newtype3font(buf, matrix);
 
 	fz_setfontbbox(fontdesc->font, bbox.x0, bbox.y0, bbox.x1, bbox.y1);
 
@@ -138,12 +133,9 @@ pdf_loadtype3font(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *rdb, fz_obj
 		}
 	}
 
-	error = pdf_newidentitycmap(&fontdesc->encoding, 0, 1);
-	if (error)
-		goto cleanup;
+	fontdesc->encoding = pdf_newidentitycmap(0, 1);
 
-	error = pdf_loadtounicode(fontdesc, xref,
-			estrings, nil, fz_dictgets(dict, "ToUnicode"));
+	error = pdf_loadtounicode(fontdesc, xref, estrings, nil, fz_dictgets(dict, "ToUnicode"));
 	if (error)
 		goto cleanup;
 
@@ -168,15 +160,10 @@ pdf_loadtype3font(pdf_fontdesc **fontdescp, pdf_xref *xref, fz_obj *rdb, fz_obj
 		float w = fz_toreal(fz_arrayget(widths, i - first));
 		w = fontdesc->font->t3matrix.a * w * 1000.0;
 		fontdesc->font->t3widths[i] = w * 0.001;
-
-		error = pdf_addhmtx(fontdesc, i, i, w);
-		if (error)
-			goto cleanup;
+		pdf_addhmtx(fontdesc, i, i, w);
 	}
 
-	error = pdf_endhmtx(fontdesc);
-	if (error)
-		goto cleanup;
+	pdf_endhmtx(fontdesc);
 
 	/*
 	 * Resources
diff --git a/mupdf/pdf_unicode.c b/mupdf/pdf_unicode.c
index da518ed0..d08c7e89 100644
--- a/mupdf/pdf_unicode.c
+++ b/mupdf/pdf_unicode.c
@@ -46,12 +46,7 @@ pdf_loadtounicode(pdf_fontdesc *font, pdf_xref *xref,
 		if (error)
 			return fz_rethrow(error, "cannot load embedded cmap");
 
-		error = pdf_newcmap(&font->tounicode);
-		if (error)
-		{
-			pdf_dropcmap(cmap);
-			return fz_rethrow(error, "cannot create tounicode cmap");
-		}
+		font->tounicode = pdf_newcmap();
 
 		for (i = 0; i < (strings ? 256 : 65536); i++)
 		{
@@ -60,23 +55,11 @@ pdf_loadtounicode(pdf_fontdesc *font, pdf_xref *xref,
 			{
 				ucs = pdf_lookupcmap(cmap, i);
 				if (ucs > 0)
-				{
-					error = pdf_maprangetorange(font->tounicode, cid, cid, ucs);
-					if (error)
-					{
-						pdf_dropcmap(cmap);
-						return fz_rethrow(error, "cannot create tounicode mapping");
-					}
-				}
+					pdf_maprangetorange(font->tounicode, cid, cid, ucs);
 			}
 		}
 
-		error = pdf_sortcmap(font->tounicode);
-		if (error)
-		{
-			pdf_dropcmap(cmap);
-			return fz_rethrow(error, "cannot sort tounicode mappings");
-		}
+		pdf_sortcmap(font->tounicode);
 
 		pdf_dropcmap(cmap);
 		return fz_okay;
@@ -111,8 +94,6 @@ pdf_loadtounicode(pdf_fontdesc *font, pdf_xref *xref,
 
 		font->ncidtoucs = 256;
 		font->cidtoucs = fz_malloc(256 * sizeof(unsigned short));
-		if (!font->cidtoucs)
-			return fz_rethrow(-1, "out of memory: tounicode cidtoucs table");
 
 		for (i = 0; i < 256; i++)
 		{
@@ -151,18 +132,16 @@ pdf_loadtounicode(pdf_fontdesc *font, pdf_xref *xref,
  * in the text objects.
  */
 
-fz_error
-pdf_newtextline(pdf_textline **linep)
+pdf_textline *
+pdf_newtextline(void)
 {
 	pdf_textline *line;
-	line = *linep = fz_malloc(sizeof(pdf_textline));
-	if (!line)
-		return fz_rethrow(-1, "out of memory: textline struct");
+	line = fz_malloc(sizeof(pdf_textline));
 	line->len = 0;
 	line->cap = 0;
 	line->text = nil;
 	line->next = nil;
-	return fz_okay;
+	return line;
 }
 
 void
@@ -174,28 +153,19 @@ pdf_droptextline(pdf_textline *line)
 	fz_free(line);
 }
 
-static fz_error
+static void
 addtextchar(pdf_textline *line, int x, int y, int c)
 {
-	pdf_textchar *newtext;
-	int newcap;
-
 	if (line->len + 1 >= line->cap)
 	{
-		newcap = line->cap ? line->cap * 2 : 80;
-		newtext = fz_realloc(line->text, sizeof(pdf_textchar) * newcap);
-		if (!newtext)
-			return fz_rethrow(-1, "out of memory: textline buffer resize");
-		line->cap = newcap;
-		line->text = newtext;
+		line->cap = line->cap ? (line->cap * 3) / 2 : 80;
+		line->text = fz_realloc(line->text, sizeof(pdf_textchar) * line->cap);
 	}
 
 	line->text[line->len].x = x;
 	line->text[line->len].y = y;
 	line->text[line->len].c = c;
 	line->len ++;
-
-	return fz_okay;
 }
 
 static fz_error
@@ -261,23 +231,16 @@ extracttext(pdf_textline **line, fz_node *node, fz_matrix ctm, fz_point *oldpt)
 
 			if (fabs(dy) > 0.2)
 			{
-				pdf_textline *newline;
-				error = pdf_newtextline(&newline);
-				if (error)
-					return fz_rethrow(error, "cannot create new text line");
+				pdf_textline *newline = pdf_newtextline();
 				(*line)->next = newline;
 				*line = newline;
 			}
 			else if (fabs(dx) > 0.2)
 			{
-				error = addtextchar(*line, x, y, ' ');
-				if (error)
-					return fz_rethrow(error, "cannot add character to text line");
+				addtextchar(*line, x, y, ' ');
 			}
 
-			error = addtextchar(*line, x, y, text->els[i].ucs);
-			if (error)
-				return fz_rethrow(error, "cannot add character to text line");
+			addtextchar(*line, x, y, text->els[i].ucs);
 		}
 	}
 
@@ -305,10 +268,7 @@ pdf_loadtextfromtree(pdf_textline **outp, fz_tree *tree, fz_matrix ctm)
 	oldpt.x = -1;
 	oldpt.y = -1;
 
-	error = pdf_newtextline(&root);
-	if (error)
-		return fz_rethrow(error, "cannot create new text line");
-
+	root = pdf_newtextline();
 	line = root;
 
 	error = extracttext(&line, tree->root, ctm, &oldpt);
diff --git a/mupdf/pdf_xobject.c b/mupdf/pdf_xobject.c
index e11424a7..5f3810c1 100644
--- a/mupdf/pdf_xobject.c
+++ b/mupdf/pdf_xobject.c
@@ -15,9 +15,6 @@ pdf_loadxobject(pdf_xobject **formp, pdf_xref *xref, fz_obj *dict)
 	}
 
 	form = fz_malloc(sizeof(pdf_xobject));
-	if (!form)
-		return fz_rethrow(-1, "out of memory: xobject struct");
-
 	form->refs = 1;
 	form->resources = nil;
 	form->contents = nil;
diff --git a/mupdf/pdf_xref.c b/mupdf/pdf_xref.c
index d79ec663..ec6a8d6c 100644
--- a/mupdf/pdf_xref.c
+++ b/mupdf/pdf_xref.c
@@ -6,14 +6,12 @@
  * needs to be initialized by initxref, openxref or repairxref.
  */
 
-fz_error
-pdf_newxref(pdf_xref **xrefp)
+pdf_xref *
+pdf_newxref(void)
 {
 	pdf_xref *xref;
 
 	xref = fz_malloc(sizeof(pdf_xref));
-	if (!xref)
-		return fz_rethrow(-1, "out of memory: xref struct");
 
 	memset(xref, 0, sizeof(pdf_xref));
 
@@ -35,8 +33,7 @@ pdf_newxref(pdf_xref **xrefp)
 
 	xref->store = nil;	/* you need to create this if you want to render */
 
-	*xrefp = xref;
-	return fz_okay;
+	return xref;
 }
 
 void
@@ -73,9 +70,6 @@ fz_error
 pdf_initxref(pdf_xref *xref)
 {
 	xref->table = fz_malloc(sizeof(pdf_xrefentry) * 128);
-	if (!xref->table)
-		return fz_rethrow(-1, "out of memory: xref table");
-
 	xref->cap = 128;
 	xref->len = 1;