Return errors from constructors and destructors.

svn path=/trunk/libparserutils/; revision=5652

3 files changed, 107 insertions, 86 deletions

diff --git a/src/input/filter.c b/src/input/filter.c
index 337fc78..716fbf6 100644
--- a/src/input/filter.c
+++ b/src/input/filter.c
@@ -54,65 +54,74 @@ static parserutils_error filter_set_encoding(parserutils_filter *input,
  * \param int_enc  Desired encoding of document
  * \param alloc    Function used to (de)allocate data
  * \param pw       Pointer to client-specific private data (may be NULL)
- * \return Pointer to filter instance, or NULL on failure
+ * \param filter   Pointer to location to receive filter instance
+ * \return PARSERUTILS_OK on success,
+ *         PARSERUTILS_BADPARM on bad parameters,
+ *         PARSERUTILS_NOMEM on memory exhausion,
+ *         PARSERUTILS_BADENCODING if the encoding is unsupported
  */
-parserutils_filter *parserutils_filter_create(const char *int_enc,
-		parserutils_alloc alloc, void *pw)
+parserutils_error parserutils_filter_create(const char *int_enc,
+		parserutils_alloc alloc, void *pw, parserutils_filter **filter)
 {
-	parserutils_filter *filter;
+	parserutils_filter *f;
+	parserutils_error error;
 
-	if (int_enc == NULL || alloc == NULL)
-		return NULL;
+	if (int_enc == NULL || alloc == NULL || filter == NULL)
+		return PARSERUTILS_BADPARM;
 
-	filter = alloc(NULL, sizeof(*filter), pw);
-	if (!filter)
-		return NULL;
+	f = alloc(NULL, sizeof(parserutils_filter), pw);
+	if (f == NULL)
+		return PARSERUTILS_NOMEM;
 
 #ifdef WITH_ICONV_FILTER
-	filter->cd = (iconv_t) -1;
-	filter->int_enc = parserutils_charset_mibenum_from_name(
+	f->cd = (iconv_t) -1;
+	f->int_enc = parserutils_charset_mibenum_from_name(
 			int_enc, strlen(int_enc));
-	if (filter->int_enc == 0) {
-		alloc(filter, 0, pw);
-		return NULL;
+	if (f->int_enc == 0) {
+		alloc(f, 0, pw);
+		return PARSERUTILS_BADENCODING;
 	}
 #else
-	filter->leftover = false;
-	filter->pivot_left = NULL;
-	filter->pivot_len = 0;
+	f->leftover = false;
+	f->pivot_left = NULL;
+	f->pivot_len = 0;
 #endif
 
-	filter->alloc = alloc;
-	filter->pw = pw;
+	f->alloc = alloc;
+	f->pw = pw;
 
-	if (filter_set_defaults(filter) != PARSERUTILS_OK) {
-		filter->alloc(filter, 0, pw);
-		return NULL;
+	error = filter_set_defaults(f);
+	if (error != PARSERUTILS_OK) {
+		f->alloc(f, 0, pw);
+		return error;
 	}
 
 #ifndef WITH_ICONV_FILTER
-	filter->write_codec = 
-			parserutils_charset_codec_create(int_enc, alloc, pw);
-	if (filter->write_codec == NULL) {
-		if (filter->read_codec != NULL)
-			parserutils_charset_codec_destroy(filter->read_codec);
-		filter->alloc(filter, 0, pw);
-		return NULL;
+	error = parserutils_charset_codec_create(int_enc, alloc, pw, 
+			&f->write_codec);
+	if (error != PARSERUTILS_OK) {
+		if (f->read_codec != NULL)
+			parserutils_charset_codec_destroy(f->read_codec);
+		f->alloc(f, 0, pw);
+		return error;
 	}
 #endif
 
-	return filter;
+	*filter = f;
+
+	return PARSERUTILS_OK;
 }
 
 /**
  * Destroy an input filter
  *
  * \param input  Pointer to filter instance
+ * \return PARSERUTILS_OK on success, appropriate error otherwise
  */
-void parserutils_filter_destroy(parserutils_filter *input)
+parserutils_error parserutils_filter_destroy(parserutils_filter *input)
 {
 	if (input == NULL)
-		return;
+		return PARSERUTILS_BADPARM;
 
 #ifdef WITH_ICONV_FILTER
 	if (input->cd != (iconv_t) -1)
@@ -127,7 +136,7 @@ void parserutils_filter_destroy(parserutils_filter *input)
 
 	input->alloc(input, 0, input->pw);
 
-	return;
+	return PARSERUTILS_OK;
 }
 
 /**
@@ -354,6 +363,7 @@ parserutils_error filter_set_defaults(parserutils_filter *input)
 parserutils_error filter_set_encoding(parserutils_filter *input,
 		const char *enc)
 {
+	parserutils_error error;
 	const char *old_enc;
 	uint16_t mibenum;
 
@@ -384,10 +394,10 @@ parserutils_error filter_set_encoding(parserutils_filter *input,
 	if (input->read_codec != NULL)
 		parserutils_charset_codec_destroy(input->read_codec);
 
-	input->read_codec = parserutils_charset_codec_create(enc, input->alloc,
-			input->pw);
-	if (input->read_codec == NULL)
-		return PARSERUTILS_NOMEM;
+	error = parserutils_charset_codec_create(enc, input->alloc,
+			input->pw, &input->read_codec);
+	if (error != PARSERUTILS_OK)
+		return error;
 #endif
 
 	input->settings.encoding = mibenum;
diff --git a/src/input/filter.h b/src/input/filter.h
index 96941a6..0d72b92 100644
--- a/src/input/filter.h
+++ b/src/input/filter.h
@@ -35,10 +35,10 @@ typedef union parserutils_filter_optparams {
 
 
 /* Create an input filter */
-parserutils_filter *parserutils_filter_create(const char *int_enc,
-		parserutils_alloc alloc, void *pw);
+parserutils_error parserutils_filter_create(const char *int_enc,
+		parserutils_alloc alloc, void *pw, parserutils_filter **filter);
 /* Destroy an input filter */
-void parserutils_filter_destroy(parserutils_filter *input);
+parserutils_error parserutils_filter_destroy(parserutils_filter *input);
 
 /* Configure an input filter */
 parserutils_error parserutils_filter_setopt(parserutils_filter *input,
diff --git a/src/input/inputstream.c b/src/input/inputstream.c
index 5631331..a4859be 100644
--- a/src/input/inputstream.c
+++ b/src/input/inputstream.c
@@ -51,104 +51,115 @@ static inline parserutils_error parserutils_inputstream_strip_bom(
  * \param csdetect  Charset detection function, or NULL
  * \param alloc     Memory (de)allocation function
  * \param pw        Pointer to client-specific private data (may be NULL)
- * \return Pointer to stream instance, or NULL on failure
+ * \param stream    Pointer to location to receive stream instance
+ * \return PARSERUTILS_OK on success,
+ *         PARSERUTILS_BADPARM on bad parameters,
+ *         PARSERUTILS_NOMEM on memory exhaustion,
+ *         PARSERUTILS_BADENCODING on unsupported encoding
  *
  * The value 0 is defined as being the lowest priority encoding source 
  * (i.e. the default fallback encoding). Beyond this, no further 
  * interpretation is made upon the encoding source.
  */
-parserutils_inputstream *parserutils_inputstream_create(const char *enc,
+parserutils_error parserutils_inputstream_create(const char *enc,
 		uint32_t encsrc, parserutils_charset_detect_func csdetect,
-		parserutils_alloc alloc, void *pw)
+		parserutils_alloc alloc, void *pw,
+		parserutils_inputstream **stream)
 {
-	parserutils_inputstream_private *stream;
+	parserutils_inputstream_private *s;
+	parserutils_error error;
 
-	if (alloc == NULL)
-		return NULL;
+	if (alloc == NULL || stream == NULL)
+		return PARSERUTILS_BADPARM;
 
-	stream = alloc(NULL, sizeof(parserutils_inputstream_private), pw);
-	if (stream == NULL)
-		return NULL;
+	s = alloc(NULL, sizeof(parserutils_inputstream_private), pw);
+	if (s == NULL)
+		return PARSERUTILS_NOMEM;
 
-	stream->raw = parserutils_buffer_create(alloc, pw);
-	if (stream->raw == NULL) {
-		alloc(stream, 0, pw);
-		return NULL;
+	error = parserutils_buffer_create(alloc, pw, &s->raw);
+	if (error != PARSERUTILS_OK) {
+		alloc(s, 0, pw);
+		return error;
 	}
 
-	stream->public.utf8 = parserutils_buffer_create(alloc, pw);
-	if (stream->public.utf8 == NULL) {
-		parserutils_buffer_destroy(stream->raw);
-		alloc(stream, 0, pw);
-		return NULL;
+	error = parserutils_buffer_create(alloc, pw, &s->public.utf8);
+	if (error != PARSERUTILS_OK) {
+		parserutils_buffer_destroy(s->raw);
+		alloc(s, 0, pw);
+		return error;
 	}
 
-	stream->public.cursor = 0;
-	stream->public.had_eof = false;
-	stream->done_first_chunk = false;
-
-	stream->input = parserutils_filter_create("UTF-8", alloc, pw);
-	if (stream->input == NULL) {
-		parserutils_buffer_destroy(stream->public.utf8);
-		parserutils_buffer_destroy(stream->raw);
-		alloc(stream, 0, pw);
-		return NULL;
+	s->public.cursor = 0;
+	s->public.had_eof = false;
+	s->done_first_chunk = false;
+
+	error = parserutils_filter_create("UTF-8", alloc, pw, &s->input);
+	if (error != PARSERUTILS_OK) {
+		parserutils_buffer_destroy(s->public.utf8);
+		parserutils_buffer_destroy(s->raw);
+		alloc(s, 0, pw);
+		return error;
 	}
 
 	if (enc != NULL) {
-		parserutils_error error;
 		parserutils_filter_optparams params;
 
-		stream->mibenum = 
+		s->mibenum = 
 			parserutils_charset_mibenum_from_name(enc, strlen(enc));
 
-		if (stream->mibenum != 0) {
+		if (s->mibenum != 0) {
 			params.encoding.name = enc;
 
-			error = parserutils_filter_setopt(stream->input,
+			error = parserutils_filter_setopt(s->input,
 					PARSERUTILS_FILTER_SET_ENCODING, 
 					&params);
 			if (error != PARSERUTILS_OK && 
 					error != PARSERUTILS_INVALID) {
-				parserutils_filter_destroy(stream->input);
-				parserutils_buffer_destroy(stream->public.utf8);
-				parserutils_buffer_destroy(stream->raw);
-				alloc(stream, 0, pw);
-				return NULL;
+				parserutils_filter_destroy(s->input);
+				parserutils_buffer_destroy(s->public.utf8);
+				parserutils_buffer_destroy(s->raw);
+				alloc(s, 0, pw);
+				return error;
 			}
 
-			stream->encsrc = encsrc;
+			s->encsrc = encsrc;
 		}
 	} else {
-		stream->mibenum = 0;
-		stream->encsrc = 0;
+		s->mibenum = 0;
+		s->encsrc = 0;
 	}
 
-	stream->csdetect = csdetect;
+	s->csdetect = csdetect;
+
+	s->alloc = alloc;
+	s->pw = pw;
 
-	stream->alloc = alloc;
-	stream->pw = pw;
+	*stream = (parserutils_inputstream *) s;
 
-	return (parserutils_inputstream *) stream;
+	return PARSERUTILS_OK;
 }
 
 /**
  * Destroy an input stream
  *
  * \param stream  Input stream to destroy
+ * \return PARSERUTILS_OK on success, appropriate error otherwise
  */
-void parserutils_inputstream_destroy(parserutils_inputstream *stream)
+parserutils_error parserutils_inputstream_destroy(
+		parserutils_inputstream *stream)
 {
 	parserutils_inputstream_private *s = 
 			(parserutils_inputstream_private *) stream;
 
 	if (stream == NULL)
-		return;
+		return PARSERUTILS_BADPARM;
 
 	parserutils_filter_destroy(s->input);
 	parserutils_buffer_destroy(s->public.utf8);
 	parserutils_buffer_destroy(s->raw);
 	s->alloc(s, 0, s->pw);
+
+	return PARSERUTILS_OK;
 }
 
 /**