Malloc cannot return null. Clean up streams and filters.

15 files changed, 136 insertions, 259 deletions

diff --git a/fitz/filt_aesd.c b/fitz/filt_aesd.c
index 9b4c0962..122a284d 100644
--- a/fitz/filt_aesd.c
+++ b/fitz/filt_aesd.c
@@ -11,13 +11,13 @@ struct fz_aesd_s
     int ivcount;
 };
 
-fz_error
-fz_newaesdfilter(fz_filter **fp, unsigned char *key, unsigned keylen)
+fz_filter *
+fz_newaesdfilter(unsigned char *key, unsigned keylen)
 {
     FZ_NEWFILTER(fz_aesd, f, aesdfilter);
     aes_setkey_dec(&f->aes, key, keylen * 8);
     f->ivcount = 0;
-    return fz_okay;
+    return (fz_filter *)f;
 }
 
 void
diff --git a/fitz/filt_arc4.c b/fitz/filt_arc4.c
index d3832ec0..f50f8e86 100644
--- a/fitz/filt_arc4.c
+++ b/fitz/filt_arc4.c
@@ -9,12 +9,12 @@ struct fz_arc4c_s
 	fz_arc4 arc4;
 };
 
-fz_error
-fz_newarc4filter(fz_filter **fp, unsigned char *key, unsigned keylen)
+fz_filter *
+fz_newarc4filter(unsigned char *key, unsigned keylen)
 {
 	FZ_NEWFILTER(fz_arc4c, f, arc4filter);
 	fz_arc4init(&f->arc4, key, keylen);
-	return fz_okay;
+	return (fz_filter *)f;
 }
 
 void
diff --git a/fitz/filt_basic.c b/fitz/filt_basic.c
index 12408b5e..4eea42bf 100644
--- a/fitz/filt_basic.c
+++ b/fitz/filt_basic.c
@@ -1,11 +1,11 @@
 #include "fitz_base.h"
 #include "fitz_stream.h"
 
-fz_error
-fz_newcopyfilter(fz_filter **fp)
+fz_filter *
+fz_newcopyfilter(void)
 {
     FZ_NEWFILTER(fz_filter, f, copyfilter);
-    return fz_okay;
+    return f;
 }
 
 void
@@ -49,13 +49,13 @@ struct fz_nullfilter_s
 	int cur;
 };
 
-fz_error
-fz_newnullfilter(fz_filter **fp, int len)
+fz_filter *
+fz_newnullfilter(int len)
 {
 	FZ_NEWFILTER(fz_nullfilter, f, nullfilter);
 	f->len = len;
 	f->cur = 0;
-	return fz_okay;
+	return (fz_filter *)f;
 }
 
 void
@@ -128,13 +128,13 @@ static inline int fromhex(int a)
 	return 0;
 }
 
-fz_error
-fz_newahxd(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newahxd(fz_obj *params)
 {
 	FZ_NEWFILTER(fz_ahxd, f, ahxd);
 	f->odd = 0;
 	f->a = 0;
-	return fz_okay;
+	return (fz_filter *)f;
 }
 
 void
@@ -209,13 +209,13 @@ struct fz_a85d_s
 	int count;
 };
 
-fz_error
-fz_newa85d(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newa85d(fz_obj *params)
 {
 	FZ_NEWFILTER(fz_a85d, f, a85d);
 	f->word = 0;
 	f->count = 0;
-	return fz_okay;
+	return (fz_filter *)f;
 }
 
 void
@@ -315,11 +315,11 @@ o1:				*(out->wp+0) = f->word >> 24;
 	}
 }
 
-fz_error
-fz_newrld(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newrld(fz_obj *params)
 {
 	FZ_NEWFILTER(fz_filter, f, rld);
-	return fz_okay;
+	return f;
 }
 
 void
diff --git a/fitz/filt_dctd.c b/fitz/filt_dctd.c
index 4f7778e8..99c7821a 100644
--- a/fitz/filt_dctd.c
+++ b/fitz/filt_dctd.c
@@ -81,10 +81,9 @@ static void myskipinput(j_decompress_ptr cinfo, long n)
 	src->super.next_input_byte = in->rp;
 }
 
-fz_error
-fz_newdctd(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newdctd(fz_obj *params)
 {
-	fz_error err;
 	fz_obj *obj;
 	int colortransform;
 
@@ -106,11 +105,8 @@ fz_newdctd(fz_filter **fp, fz_obj *params)
 	myiniterr(&d->err);
 	d->cinfo.err = (struct jpeg_error_mgr*) &d->err;
 
-	if (setjmp(d->err.jb)) {
-		err = fz_throw("cannot decode jpeg: %s", d->err.msg);
-		fz_free(d);
-		return err;
-	}
+	if (setjmp(d->err.jb))
+		fz_warn("cannot initialise jpeg: %s", d->err.msg);
 
 	/* create decompression object. this zeroes cinfo except for err. */
 	jpeg_create_decompress(&d->cinfo);
@@ -131,7 +127,7 @@ fz_newdctd(fz_filter **fp, fz_obj *params)
 	d->cinfo.dct_method = JDCT_FASTEST;
 	d->cinfo.do_fancy_upsampling = FALSE;
 
-	return fz_okay;
+	return (fz_filter *)d;
 }
 
 void
diff --git a/fitz/filt_faxd.c b/fitz/filt_faxd.c
index 7a5cb774..7a244dfa 100644
--- a/fitz/filt_faxd.c
+++ b/fitz/filt_faxd.c
@@ -165,8 +165,8 @@ struct fz_faxd_s
 	unsigned char *dst;
 };
 
-fz_error
-fz_newfaxd(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newfaxd(fz_obj *params)
 {
 	fz_obj *obj;
 
@@ -216,24 +216,12 @@ fz_newfaxd(fz_filter **fp, fz_obj *params)
 	fax->eolc = 0;
 
 	fax->ref = fz_malloc(fax->stride);
-	if (!fax->ref)
-	{
-		fz_free(fax);
-		return fz_rethrow(-1, "out of memory: scanline buffer one");
-	}
-
 	fax->dst = fz_malloc(fax->stride);
-	if (!fax->dst)
-	{
-		fz_free(fax->ref);
-		fz_free(fax);
-		return fz_rethrow(-1, "out of memory: scanline buffer two");
-	}
 
 	memset(fax->ref, 0, fax->stride);
 	memset(fax->dst, 0, fax->stride);
 
-	return fz_okay;
+	return (fz_filter*)fz_okay;
 }
 
 void
diff --git a/fitz/filt_flate.c b/fitz/filt_flate.c
index 7bd2a448..65233e6d 100644
--- a/fitz/filt_flate.c
+++ b/fitz/filt_flate.c
@@ -23,10 +23,9 @@ zfree(void *opaque, void *ptr)
 	fz_free(ptr);
 }
 
-fz_error
-fz_newflated(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newflated(fz_obj *params)
 {
-	fz_error eo;
 	fz_obj *obj;
 	int zipfmt;
 	int ei;
@@ -57,12 +56,10 @@ fz_newflated(fz_filter **fp, fz_obj *params)
 
 	if (ei != Z_OK)
 	{
-		eo = fz_throw("zlib error: inflateInit: %s", f->z.msg);
-		fz_free(f);
-		return eo;
+		fz_warn("zlib error: inflateInit: %s", f->z.msg);
 	}
 
-	return fz_okay;
+	return (fz_filter*)f;
 }
 
 void
@@ -73,7 +70,7 @@ fz_dropflated(fz_filter *f)
 
 	err = inflateEnd(zp);
 	if (err != Z_OK)
-		fprintf(stderr, "inflateEnd: %s", zp->msg);
+		fz_warn("inflateEnd: %s", zp->msg);
 }
 
 fz_error
diff --git a/fitz/filt_lzwd.c b/fitz/filt_lzwd.c
index 3fb5a759..d57d399f 100644
--- a/fitz/filt_lzwd.c
+++ b/fitz/filt_lzwd.c
@@ -42,8 +42,8 @@ struct fz_lzwd_s
 	lzw_code table[NUMCODES];
 };
 
-fz_error
-fz_newlzwd(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newlzwd(fz_obj *params)
 {
 	int i;
 
@@ -83,7 +83,7 @@ fz_newlzwd(fz_filter **fp, fz_obj *params)
 	lzw->oldcode = -1;
 	lzw->resume = 0;
 
-	return fz_okay;
+	return (fz_filter *)lzw;
 }
 
 void
diff --git a/fitz/filt_pipeline.c b/fitz/filt_pipeline.c
index eec24803..3340e5b0 100644
--- a/fitz/filt_pipeline.c
+++ b/fitz/filt_pipeline.c
@@ -16,15 +16,15 @@ struct fz_pipeline_s
 	int tailneedsin;
 };
 
-fz_error
-fz_chainpipeline(fz_filter **fp, fz_filter *head, fz_filter *tail, fz_buffer *buf)
+fz_filter *
+fz_chainpipeline(fz_filter *head, fz_filter *tail, fz_buffer *buf)
 {
 	FZ_NEWFILTER(fz_pipeline, p, pipeline);
 	p->head = fz_keepfilter(head);
 	p->tail = fz_keepfilter(tail);
 	p->tailneedsin = 1;
 	p->buffer = fz_keepbuffer(buf);
-	return fz_okay;
+	return (fz_filter*)p;
 }
 
 void
@@ -38,25 +38,17 @@ fz_unchainpipeline(fz_filter *filter, fz_filter **oldfp, fz_buffer **oldbp)
 	fz_dropfilter(filter);
 }
 
-fz_error
-fz_newpipeline(fz_filter **fp, fz_filter *head, fz_filter *tail)
+fz_filter *
+fz_newpipeline(fz_filter *head, fz_filter *tail)
 {
-	fz_error error;
-
 	FZ_NEWFILTER(fz_pipeline, p, pipeline);
 
-	error = fz_newbuffer(&p->buffer, FZ_BUFSIZE);
-	if (error)
-	{
-	    fz_free(p);
-	    return fz_rethrow(error, "cannot create buffer");
-	}
-
+	p->buffer = fz_newbuffer(FZ_BUFSIZE);
 	p->head = fz_keepfilter(head);
 	p->tail = fz_keepfilter(tail);
 	p->tailneedsin = 1;
 
-	return fz_okay;
+	return (fz_filter*)p;
 }
 
 void
@@ -90,13 +82,10 @@ head:
 	{
 		if (p->tailneedsin && !p->head->produced)
 		{
-			fz_error be = fz_okay;
 			if (p->buffer->rp > p->buffer->bp)
-				be = fz_rewindbuffer(p->buffer);
+				fz_rewindbuffer(p->buffer);
 			else
-				be = fz_growbuffer(p->buffer);
-			if (be)
-				return be;
+				fz_growbuffer(p->buffer);
 			goto head;
 		}
 		goto tail;
diff --git a/fitz/filt_predict.c b/fitz/filt_predict.c
index 77e03799..b86b2515 100644
--- a/fitz/filt_predict.c
+++ b/fitz/filt_predict.c
@@ -21,8 +21,8 @@ struct fz_predict_s
 	unsigned char *ref;
 };
 
-fz_error
-fz_newpredictd(fz_filter **fp, fz_obj *params)
+fz_filter *
+fz_newpredictd(fz_obj *params)
 {
 	fz_obj *obj;
 
@@ -42,8 +42,8 @@ fz_newpredictd(fz_filter **fp, fz_obj *params)
 	    p->predictor != 12 && p->predictor != 13 &&
 	    p->predictor != 14 && p->predictor != 15)
 	{
-	    fz_free(p);
-	    return fz_throw("invalid predictor");
+		fz_warn("invalid predictor: %d", p->predictor);
+		p->predictor = 1;
 	}
 
 	obj = fz_dictgets(params, "Columns");
@@ -64,11 +64,6 @@ fz_newpredictd(fz_filter **fp, fz_obj *params)
 	if (p->predictor >= 10)
 	{
 		p->ref = fz_malloc(p->stride);
-		if (!p->ref)
-		{
-			fz_free(p);
-			return fz_rethrow(-1, "out of memory: scanline buffer");
-		}
 		memset(p->ref, 0, p->stride);
 	}
 	else
@@ -76,7 +71,7 @@ fz_newpredictd(fz_filter **fp, fz_obj *params)
 		p->ref = nil;
 	}
 
-	return fz_okay;
+	return (fz_filter*)p;
 }
 
 void
diff --git a/fitz/fitz_base.h b/fitz/fitz_base.h
index e5dce5f9..ecced36e 100644
--- a/fitz/fitz_base.h
+++ b/fitz/fitz_base.h
@@ -159,13 +159,16 @@ extern unsigned fz_cpuflags;
 
 #define STRIDE(n, bcp) (((bpc) * (n) + 7) / 8)
 
-/* plan9 stuff for utf-8 and path munging */
+/* plan9 stuff for utf-8 */
 int chartorune(int *rune, char *str);
 int runetochar(char *str, int *rune);
 int runelen(long c);
 int runenlen(int *r, int nrune);
 int fullrune(char *str, int n);
 
+/*
+ * Error handling.
+ */
 typedef int fz_error;
 
 extern char fz_errorbuf[];
@@ -205,6 +208,10 @@ int fz_hashlen(fz_hashtable *table);
 void *fz_hashgetkey(fz_hashtable *table, int idx);
 void *fz_hashgetval(fz_hashtable *table, int idx);
 
+/*
+ * Math and geometry
+ */
+
 /* multiply 8-bit fixpoint (0..1) so that 0*0==0 and 255*255==255 */
 #define fz_mul255(a,b) (((a) * ((b) + 1)) >> 8)
 #define fz_floor(x) floor(x)
diff --git a/fitz/fitz_stream.h b/fitz/fitz_stream.h
index fc8eb023..7328b6d1 100644
--- a/fitz/fitz_stream.h
+++ b/fitz/fitz_stream.h
@@ -163,11 +163,11 @@ struct fz_buffer_s
 	int eof;
 };
 
-fz_error fz_newbuffer(fz_buffer **bufp, int size);
-fz_error fz_newbufferwithmemory(fz_buffer **bufp, unsigned char *data, int size);
+fz_buffer * fz_newbuffer(int size);
+fz_buffer * fz_newbufferwithmemory(unsigned char *data, int size);
 
-fz_error fz_rewindbuffer(fz_buffer *buf);
-fz_error fz_growbuffer(fz_buffer *buf);
+void fz_rewindbuffer(fz_buffer *buf);
+void fz_growbuffer(fz_buffer *buf);
 
 fz_buffer *fz_keepbuffer(fz_buffer *buf);
 void fz_dropbuffer(fz_buffer *buf);
@@ -182,7 +182,7 @@ void fz_dropbuffer(fz_buffer *buf);
  *    ioneedout -- output buffer exhausted, please provide more space (ep-wp)
  *    iodone -- finished, please never call me again. ever!
  * or...
- *    any other error object -- oops, something blew up.
+ *    any other error code -- oops, something blew up.
  *
  * To make using the filter easier, three variables are updated:
  *    produced -- if we actually produced any new data
@@ -208,20 +208,18 @@ typedef struct fz_filter_s fz_filter;
  * Evil looking macro to create an initialize a filter struct.
  */
 
-#define FZ_NEWFILTER(TYPE,VAR,NAME)                                         \
-	fz_error fz_process ## NAME (fz_filter*,fz_buffer*,fz_buffer*);   \
-	void fz_drop ## NAME (fz_filter*);                                  \
-	TYPE *VAR;                                                          \
-	*fp = fz_malloc(sizeof(TYPE));                                      \
-	if (!*fp) return fz_throw("outofmem: %s filter struct", #NAME);     \
-	(*fp)->refs = 1;                                                    \
-	(*fp)->process = fz_process ## NAME ;                               \
-	(*fp)->drop = fz_drop ## NAME ;                                     \
-	(*fp)->consumed = 0;                                                \
-	(*fp)->produced = 0;                                                \
-	(*fp)->count = 0;                                                   \
-	(*fp)->done = 0;                                                    \
-	VAR = (TYPE*) *fp
+#define FZ_NEWFILTER(TYPE,VAR,NAME) \
+	fz_error fz_process ## NAME (fz_filter*,fz_buffer*,fz_buffer*); \
+	void fz_drop ## NAME (fz_filter*); \
+	TYPE *VAR; \
+	VAR = fz_malloc(sizeof(TYPE));	 \
+	((fz_filter*)VAR)->refs = 1; \
+	((fz_filter*)VAR)->process = fz_process ## NAME ;  \
+	((fz_filter*)VAR)->drop = fz_drop ## NAME ;  \
+	((fz_filter*)VAR)->consumed = 0;  \
+	((fz_filter*)VAR)->produced = 0; \
+	((fz_filter*)VAR)->count = 0; \
+	((fz_filter*)VAR)->done = 0;
 
 struct fz_filter_s
 {
@@ -238,27 +236,27 @@ fz_error fz_process(fz_filter *f, fz_buffer *in, fz_buffer *out);
 fz_filter *fz_keepfilter(fz_filter *f);
 void fz_dropfilter(fz_filter *f);
 
-fz_error fz_newpipeline(fz_filter **fp, fz_filter *head, fz_filter *tail);
-fz_error fz_chainpipeline(fz_filter **fp, fz_filter *head, fz_filter *tail, fz_buffer *buf);
+fz_filter * fz_newpipeline(fz_filter *head, fz_filter *tail);
+fz_filter * fz_chainpipeline(fz_filter *head, fz_filter *tail, fz_buffer *buf);
 void fz_unchainpipeline(fz_filter *pipe, fz_filter **oldfp, fz_buffer **oldbp);
 
 /* stop and reverse! special case needed for postscript only */
 void fz_pushbackahxd(fz_filter *filter, fz_buffer *in, fz_buffer *out, int n);
 
-fz_error fz_newnullfilter(fz_filter **fp, int len);
-fz_error fz_newcopyfilter(fz_filter **fp);
-fz_error fz_newarc4filter(fz_filter **fp, unsigned char *key, unsigned keylen);
-fz_error fz_newaesdfilter(fz_filter **fp, unsigned char *key, unsigned keylen);
-fz_error fz_newa85d(fz_filter **filterp, fz_obj *param);
-fz_error fz_newahxd(fz_filter **filterp, fz_obj *param);
-fz_error fz_newrld(fz_filter **filterp, fz_obj *param);
-fz_error fz_newdctd(fz_filter **filterp, fz_obj *param);
-fz_error fz_newfaxd(fz_filter **filterp, fz_obj *param);
-fz_error fz_newflated(fz_filter **filterp, fz_obj *param);
-fz_error fz_newlzwd(fz_filter **filterp, fz_obj *param);
-fz_error fz_newpredictd(fz_filter **filterp, fz_obj *param);
-fz_error fz_newjbig2d(fz_filter **filterp, fz_obj *param);
-fz_error fz_newjpxd(fz_filter **filterp, fz_obj *param);
+fz_filter * fz_newnullfilter(int len);
+fz_filter * fz_newcopyfilter();
+fz_filter * fz_newarc4filter(unsigned char *key, unsigned keylen);
+fz_filter * fz_newaesdfilter(unsigned char *key, unsigned keylen);
+fz_filter * fz_newa85d(fz_obj *param);
+fz_filter * fz_newahxd(fz_obj *param);
+fz_filter * fz_newrld(fz_obj *param);
+fz_filter * fz_newdctd(fz_obj *param);
+fz_filter * fz_newfaxd(fz_obj *param);
+fz_filter * fz_newflated(fz_obj *param);
+fz_filter * fz_newlzwd(fz_obj *param);
+fz_filter * fz_newpredictd(fz_obj *param);
+fz_filter * fz_newjbig2d(fz_obj *param);
+fz_filter * fz_newjpxd(fz_obj *param);
 
 fz_error fz_setjbig2dglobalstream(fz_filter *filter, unsigned char *buf, int len);
 
@@ -349,13 +347,9 @@ struct fz_stream_s
  */
 
 fz_error fz_openrfile(fz_stream **stmp, char *filename);
-
-/* write to memory buffers! */
-fz_error fz_openrmemory(fz_stream **stmp, unsigned char *mem, int len);
-fz_error fz_openrbuffer(fz_stream **stmp, fz_buffer *buf);
-
-/* almost like fork() exec() pipe() */
-fz_error fz_openrfilter(fz_stream **stmp, fz_filter *flt, fz_stream *chain);
+fz_stream * fz_openrmemory(unsigned char *mem, int len);
+fz_stream * fz_openrbuffer(fz_buffer *buf);
+fz_stream * fz_openrfilter(fz_filter *flt, fz_stream *chain);
 
 /*
  * Functions that are common to both input and output streams.
@@ -376,8 +370,8 @@ fz_error fz_rseek(fz_stream *stm, int offset, int whence);
 
 fz_error fz_readimp(fz_stream *stm);
 fz_error fz_read(int *np, fz_stream *stm, unsigned char *buf, int len);
-fz_error fz_readall(fz_buffer **bufp, fz_stream *stm, int sizehint);
 fz_error fz_readline(fz_stream *stm, char *buf, int max);
+fz_buffer * fz_readall(fz_stream *stm, int sizehint);
 
 /*
  * Error handling when reading with readbyte/peekbyte is non-standard.
diff --git a/fitz/stm_buffer.c b/fitz/stm_buffer.c
index 102d7327..024dbea9 100644
--- a/fitz/stm_buffer.c
+++ b/fitz/stm_buffer.c
@@ -1,51 +1,38 @@
 #include "fitz_base.h"
 #include "fitz_stream.h"
 
-fz_error
-fz_newbuffer(fz_buffer **bp, int size)
+fz_buffer *
+fz_newbuffer(int size)
 {
 	fz_buffer *b;
 
-	b = *bp = fz_malloc(sizeof(fz_buffer));
-	if (!b)
-		return fz_rethrow(-1, "out of memory: buffer struct");
-
+	b = fz_malloc(sizeof(fz_buffer));
 	b->refs = 1;
 	b->ownsdata = 1;
 	b->bp = fz_malloc(size);
-	if (!b->bp)
-	{
-		fz_free(b);
-		return fz_rethrow(-1, "out of memory: buffer memory");
-	}
-
 	b->rp = b->bp;
 	b->wp = b->bp;
 	b->ep = b->bp + size;
 	b->eof = 0;
 
-	return fz_okay;
+	return b;
 }
 
-fz_error
-fz_newbufferwithmemory(fz_buffer **bp, unsigned char *data, int size)
+fz_buffer *
+fz_newbufferwithmemory(unsigned char *data, int size)
 {
 	fz_buffer *b;
 
-	b = *bp = fz_malloc(sizeof(fz_buffer));
-	if (!b)
-		return fz_rethrow(-1, "out of memory: buffer struct");
-
+	b = fz_malloc(sizeof(fz_buffer));
 	b->refs = 1;
 	b->ownsdata = 0;
 	b->bp = data;
-
 	b->rp = b->bp;
 	b->wp = b->bp + size;
 	b->ep = b->bp + size;
 	b->eof = 0;
 
-	return fz_okay;
+	return b;
 }
 
 fz_buffer *
@@ -66,7 +53,7 @@ fz_dropbuffer(fz_buffer *buf)
 	}
 }
 
-fz_error
+void
 fz_growbuffer(fz_buffer *buf)
 {
 	unsigned char *newbp;
@@ -76,30 +63,29 @@ fz_growbuffer(fz_buffer *buf)
 	int ep = buf->ep - buf->bp;
 
 	if (!buf->ownsdata)
-		return fz_throw("assert: grow borrowed memory");
-
+	{
+		 fz_warn("assert: grow borrowed memory");
+		return;
+	}
+	
 	newbp = fz_realloc(buf->bp, ep * 2);
-	if (!newbp)
-		return fz_rethrow(-1, "out of memory: resize buffer memory");
-
 	buf->bp = newbp;
 	buf->rp = buf->bp + rp;
 	buf->wp = buf->bp + wp;
 	buf->ep = buf->bp + ep * 2;
-
-	return fz_okay;
 }
 
-fz_error
+void
 fz_rewindbuffer(fz_buffer *buf)
 {
 	if (!buf->ownsdata)
-		return fz_throw("assert: rewind borrowed memory");
+	{
+		 fz_warn("assert: rewind borrowed memory");
+		return;
+	}
 
 	memmove(buf->bp, buf->rp, buf->wp - buf->rp);
 	buf->wp = buf->bp + (buf->wp - buf->rp);
 	buf->rp = buf->bp;
-
-	return fz_okay;
 }
 
diff --git a/fitz/stm_misc.c b/fitz/stm_misc.c
index 8e3ced42..7f7cf76f 100644
--- a/fitz/stm_misc.c
+++ b/fitz/stm_misc.c
@@ -72,33 +72,21 @@ static inline int fz_fillbuf(fz_stream *stm, fz_buffer *buf)
  * a freshly allocated buffer.
  */
 
-fz_error
-fz_readall(fz_buffer **bufp, fz_stream *stm, int sizehint)
+fz_buffer *
+fz_readall(fz_stream *stm, int sizehint)
 {
-	fz_error error;
 	fz_buffer *buf;
 
 	if (sizehint == 0)
 	    sizehint = 4 * 1024;
 
-	error = fz_newbuffer(&buf, sizehint);
-	if (error)
-	    return fz_rethrow(error, "cannot create scratch buffer");
+	buf = fz_newbuffer(sizehint);
 
 	while (fz_fillbuf(stm, buf) != EOF)
 	{
 		if (buf->wp == buf->ep)
-		{
-		    error = fz_growbuffer(buf);
-		    if (error)
-		    {
-			fz_dropbuffer(buf);
-			return fz_rethrow(error, "cannot resize scratch buffer");
-		    }
-		}
+			fz_growbuffer(buf);
 	}
 
-	*bufp = buf;
-	return fz_okay;
+	return buf;
 }
-
diff --git a/fitz/stm_open.c b/fitz/stm_open.c
index c1f73f48..0f9e94f8 100644
--- a/fitz/stm_open.c
+++ b/fitz/stm_open.c
@@ -11,8 +11,6 @@ newstm(int kind)
 	fz_stream *stm;
 
 	stm = fz_malloc(sizeof(fz_stream));
-	if (!stm)
-		return nil;
 
 	stm->refs = 1;
 	stm->kind = kind;
@@ -66,19 +64,11 @@ fz_dropstream(fz_stream *stm)
 
 fz_error fz_openrfile(fz_stream **stmp, char *path)
 {
-	fz_error error;
 	fz_stream *stm;
 
 	stm = newstm(FZ_SFILE);
-	if (!stm)
-		return fz_rethrow(-1, "out of memory: stream struct");
 
-	error = fz_newbuffer(&stm->buffer, FZ_BUFSIZE);
-	if (error)
-	{
-		fz_free(stm);
-		return fz_rethrow(error, "cannot create buffer");
-	}
+	stm->buffer = fz_newbuffer(FZ_BUFSIZE);
 
 	stm->file = open(path, O_BINARY | O_RDONLY, 0666);
 	if (stm->file < 0)
@@ -92,63 +82,37 @@ fz_error fz_openrfile(fz_stream **stmp, char *path)
 	return fz_okay;
 }
 
-fz_error fz_openrfilter(fz_stream **stmp, fz_filter *flt, fz_stream *src)
+fz_stream * fz_openrfilter(fz_filter *flt, fz_stream *src)
 {
-	fz_error error;
 	fz_stream *stm;
 
 	stm = newstm(FZ_SFILTER);
-	if (!stm)
-		return fz_rethrow(-1, "out of memory: stream struct");
-
-	error = fz_newbuffer(&stm->buffer, FZ_BUFSIZE);
-	if (error)
-	{
-		fz_free(stm);
-		return fz_rethrow(error, "cannot create buffer");
-	}
-
+	stm->buffer = fz_newbuffer(FZ_BUFSIZE);
 	stm->chain = fz_keepstream(src);
 	stm->filter = fz_keepfilter(flt);
 
-	*stmp = stm;
-	return fz_okay;
+	return stm;
 }
 
-fz_error fz_openrbuffer(fz_stream **stmp, fz_buffer *buf)
+fz_stream * fz_openrbuffer(fz_buffer *buf)
 {
 	fz_stream *stm;
 
 	stm = newstm(FZ_SBUFFER);
-	if (!stm)
-		return fz_rethrow(-1, "out of memory: stream struct");
-
 	stm->buffer = fz_keepbuffer(buf);
-
 	stm->buffer->eof = 1;
 
-	*stmp = stm;
-	return fz_okay;
+	return stm;
 }
 
-fz_error fz_openrmemory(fz_stream **stmp, unsigned char *mem, int len)
+fz_stream * fz_openrmemory(unsigned char *mem, int len)
 {
-	fz_error error;
 	fz_buffer *buf;
-
-	error = fz_newbufferwithmemory(&buf, mem, len);
-	if (error)
-		return fz_rethrow(error, "cannot create memory buffer");
-
-	error = fz_openrbuffer(stmp, buf);
-	if (error)
-	{
-		fz_dropbuffer(buf);
-		return fz_rethrow(error, "cannot open memory buffer stream");
-	}
-
+	fz_stream *stm;
+	
+	buf = fz_newbufferwithmemory(mem, len);
+	stm = fz_openrbuffer(buf);
 	fz_dropbuffer(buf);
 
-	return fz_okay;
+	return stm;
 }
-
diff --git a/fitz/stm_read.c b/fitz/stm_read.c
index adb79908..1dfa4648 100644
--- a/fitz/stm_read.c
+++ b/fitz/stm_read.c
@@ -20,22 +20,9 @@ fz_readimp(fz_stream *stm)
 	if (buf->eof)
 		return fz_okay;
 
-	error = fz_rewindbuffer(buf);
-	if (error)
-	{
-		stm->dead = 1;
-		return fz_rethrow(error, "cannot rewind output buffer");
-	}
-
+	fz_rewindbuffer(buf);
 	if (buf->ep - buf->wp == 0)
-	{
-		error = fz_growbuffer(buf);
-		if (error)
-		{
-			stm->dead = 1;
-			return fz_rethrow(error, "cannot grow output buffer");
-		}
-	}
+		fz_growbuffer(buf);
 
 	switch (stm->kind)
 	{
@@ -80,23 +67,9 @@ fz_readimp(fz_stream *stm)
 					return 0;
 
 				if (buf->rp > buf->bp)
-				{
-					error = fz_rewindbuffer(buf);
-					if (error)
-					{
-						stm->dead = 1;
-						return fz_rethrow(error, "cannot rewind buffer");
-					}
-				}
+					fz_rewindbuffer(buf);
 				else
-				{
-					error = fz_growbuffer(buf);
-					if (error)
-					{
-						stm->dead = 1;
-						return fz_rethrow(error, "cannot grow buffer");
-					}
-				}
+					fz_growbuffer(buf);
 			}
 
 			else if (reason == fz_iodone)