Return errors from constructors and destructors.

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

7 files changed, 129 insertions, 86 deletions

diff --git a/src/utils/buffer.c b/src/utils/buffer.c
index 3c28e16..a7ee7f4 100644
--- a/src/utils/buffer.c
+++ b/src/utils/buffer.c
@@ -14,45 +14,57 @@
 /**
  * Create a memory buffer
  *
- * \param alloc  Memory (de)allocation function
- * \param pw     Pointer to client-specific private data
- * \return Pointer to memory buffer, or NULL on memory exhaustion
+ * \param alloc   Memory (de)allocation function
+ * \param pw      Pointer to client-specific private data
+ * \param buffer  Pointer to location to receive memory buffer
+ * \return PARSERUTILS_OK on success,
+ *         PARSERUTILS_BADPARM on bad parameters,
+ *         PARSERUTILS_NOMEM on memory exhausion
  */
-parserutils_buffer *parserutils_buffer_create(parserutils_alloc alloc, void *pw)
+parserutils_error parserutils_buffer_create(parserutils_alloc alloc, void *pw,
+		parserutils_buffer **buffer)
 {
-	parserutils_buffer *buffer = 
-			alloc(NULL, sizeof(parserutils_buffer), pw);
+	parserutils_buffer *b;
 
-	if (buffer == NULL)
-		return NULL;
+	if (alloc == NULL || buffer == NULL)
+		return PARSERUTILS_BADPARM;
+
+	b = alloc(NULL, sizeof(parserutils_buffer), pw);
+	if (b == NULL)
+		return PARSERUTILS_NOMEM;
 
-	buffer->data = alloc(NULL, DEFAULT_SIZE, pw);
-	if (buffer->data == NULL) {
-		alloc(buffer, 0, pw);
-		return NULL;
+	b->data = alloc(NULL, DEFAULT_SIZE, pw);
+	if (b->data == NULL) {
+		alloc(b, 0, pw);
+		return PARSERUTILS_NOMEM;
 	}
 
-	buffer->length = 0;
-	buffer->allocated = DEFAULT_SIZE;
+	b->length = 0;
+	b->allocated = DEFAULT_SIZE;
+
+	b->alloc = alloc;
+	b->pw = pw;
 
-	buffer->alloc = alloc;
-	buffer->pw = pw;
+	*buffer = b;
 
-	return buffer;
+	return PARSERUTILS_OK;
 }
 
 /**
  * Destroy a memory buffer
  *
  * \param buffer  The buffer to destroy
+ * \return PARSERUTILS_OK on success, appropriate error otherwise
  */
-void parserutils_buffer_destroy(parserutils_buffer *buffer)
+parserutils_error parserutils_buffer_destroy(parserutils_buffer *buffer)
 {
 	if (buffer == NULL)
-		return;
+		return PARSERUTILS_BADPARM;
 
 	buffer->alloc(buffer->data, 0, buffer->pw);
 	buffer->alloc(buffer, 0, buffer->pw);
+
+	return PARSERUTILS_OK;
 }
 
 /**
diff --git a/src/utils/dict.c b/src/utils/dict.c
index 17b94a5..8b519ba 100644
--- a/src/utils/dict.c
+++ b/src/utils/dict.c
@@ -104,10 +104,10 @@ parserutils_error parserutils_dict_insert(parserutils_dict *dict,
 			return PARSERUTILS_OK;
 		}
 	} else {
-		dict->table[index] = parserutils_rbtree_create(dict_cmp, 
-				dict->alloc, dict->pw);
-		if (dict->table[index] == NULL)
-			return PARSERUTILS_NOMEM;
+		error = parserutils_rbtree_create(dict_cmp, 
+				dict->alloc, dict->pw, &dict->table[index]);
+		if (error != PARSERUTILS_OK)
+			return error;
 	}
 
 	entry = dict->alloc(NULL, sizeof(parserutils_dict_entry) + len, 
diff --git a/src/utils/errors.c b/src/utils/errors.c
index 353cda1..93e098d 100644
--- a/src/utils/errors.c
+++ b/src/utils/errors.c
@@ -38,6 +38,9 @@ const char *parserutils_error_to_string(parserutils_error error)
 	case PARSERUTILS_NEEDDATA:
 		result = "Insufficient data";
 		break;
+	case PARSERUTILS_BADENCODING:
+		result = "Unsupported encoding";
+		break;
 	}
 
 	return result;
@@ -64,6 +67,8 @@ parserutils_error parserutils_error_from_string(const char *str, size_t len)
 		return PARSERUTILS_FILENOTFOUND;
 	} else if (strncmp(str, "PARSERUTILS_NEEDDATA", len) == 0) {
 		return PARSERUTILS_NEEDDATA;
+	} else if (strncmp(str, "PARSERUTILS_BADENCODING", len) == 0) {
+		return PARSERUTILS_BADENCODING;
 	}
 
 	return PARSERUTILS_OK;
diff --git a/src/utils/rbtree.c b/src/utils/rbtree.c
index 9bf1087..4f2b64b 100644
--- a/src/utils/rbtree.c
+++ b/src/utils/rbtree.c
@@ -92,26 +92,31 @@ static inline void dump_tree(rbnode *node, parserutils_rbtree_print print,
  * \param cmp    Comparator routine for keys
  * \param alloc  Memory (de)allocation function
  * \param pw     Pointer to client-specific private data
- * \return Pointer to tree instance, or NULL on memory exhaustion
+ * \param tree   Pointer to location to receive tree instance
+ * \return PARSERUTILS_OK on success, 
+ *         PARSERUTILS_BADPARM on bad parameters,
+ *         PARSERUTILS_NOMEM on memory exhaustion
  */
-parserutils_rbtree *parserutils_rbtree_create(parserutils_rbtree_cmp cmp, 
-		parserutils_alloc alloc, void *pw)
+parserutils_error parserutils_rbtree_create(parserutils_rbtree_cmp cmp, 
+		parserutils_alloc alloc, void *pw, parserutils_rbtree **tree)
 {
-	parserutils_rbtree *tree;
+	parserutils_rbtree *t;
 
-	if (cmp == NULL || alloc == NULL)
-		return NULL;
+	if (cmp == NULL || alloc == NULL || tree == NULL)
+		return PARSERUTILS_BADPARM;
 
-	tree = alloc(NULL, sizeof(parserutils_rbtree), pw);
-	if (tree == NULL)
-		return NULL;
+	t = alloc(NULL, sizeof(parserutils_rbtree), pw);
+	if (t == NULL)
+		return PARSERUTILS_NOMEM;
+
+	t->root = NULL;
+	t->cmp = cmp;
+	t->alloc = alloc;
+	t->pw = pw;
 
-	tree->root = NULL;
-	tree->cmp = cmp;
-	tree->alloc = alloc;
-	tree->pw = pw;
+	*tree = t;
 
-	return tree;
+	return PARSERUTILS_OK;
 }
 
 /**
@@ -120,12 +125,13 @@ parserutils_rbtree *parserutils_rbtree_create(parserutils_rbtree_cmp cmp,
  * \param tree        The tree to destroy
  * \param destructor  Routine to be called with key/value pairs to destroy
  * \param pw          Pointer to client-specific private data
+ * \return PARSERUTILS_OK on success, appropriate error otherwise
  */
-void parserutils_rbtree_destroy(parserutils_rbtree *tree,
+parserutils_error parserutils_rbtree_destroy(parserutils_rbtree *tree,
 		parserutils_rbtree_del destructor, void *pw)
 {
 	if (tree == NULL)
-		return;
+		return PARSERUTILS_BADPARM;
 
 	while (tree->root != NULL) {
 #ifndef USE_DELETEMAX
@@ -142,6 +148,8 @@ void parserutils_rbtree_destroy(parserutils_rbtree *tree,
 	}
 
 	tree->alloc(tree, 0, tree->pw);
+
+	return PARSERUTILS_OK;
 }
 
 /**
diff --git a/src/utils/rbtree.h b/src/utils/rbtree.h
index 0225c92..074d390 100644
--- a/src/utils/rbtree.h
+++ b/src/utils/rbtree.h
@@ -19,9 +19,9 @@ typedef void (*parserutils_rbtree_del)(void *key, void *value, void *pw);
 typedef void (*parserutils_rbtree_print)(const void *key, const void *value,
 		int depth);
 
-parserutils_rbtree *parserutils_rbtree_create(parserutils_rbtree_cmp cmp,
-		parserutils_alloc alloc, void *pw);
-void parserutils_rbtree_destroy(parserutils_rbtree *tree,
+parserutils_error parserutils_rbtree_create(parserutils_rbtree_cmp cmp,
+		parserutils_alloc alloc, void *pw, parserutils_rbtree **tree);
+parserutils_error parserutils_rbtree_destroy(parserutils_rbtree *tree,
 		parserutils_rbtree_del destructor, void *pw);
 
 parserutils_error parserutils_rbtree_insert(parserutils_rbtree *tree, 
diff --git a/src/utils/stack.c b/src/utils/stack.c
index 2751ec4..cee43ee 100644
--- a/src/utils/stack.c
+++ b/src/utils/stack.c
@@ -32,49 +32,57 @@ struct parserutils_stack
  * \param chunk_size  Number of stack slots in a chunk
  * \param alloc       Memory (de)allocation function
  * \param pw          Pointer to client-specific private data
- * \return Pointer to stack instance, or NULL on memory exhaustion
+ * \param stack       Pointer to location to receive stack instance
+ * \return PARSERUTILS_OK on success,
+ *         PARSERUTILS_BADPARM on bad parameters
+ *         PARSERUTILS_NOMEM on memory exhaustion
  */
-parserutils_stack *parserutils_stack_create(size_t item_size, size_t chunk_size,
-		parserutils_alloc alloc, void *pw)
+parserutils_error parserutils_stack_create(size_t item_size, size_t chunk_size,
+		parserutils_alloc alloc, void *pw, parserutils_stack **stack)
 {
-	parserutils_stack *stack;
+	parserutils_stack *s;
 
-	if (item_size == 0 || chunk_size == 0 || alloc == NULL)
-		return NULL;
+	if (item_size == 0 || chunk_size == 0 || alloc == NULL || stack == NULL)
+		return PARSERUTILS_BADPARM;
 
-	stack = alloc(NULL, sizeof(parserutils_stack), pw);
-	if (stack == NULL)
-		return NULL;
+	s = alloc(NULL, sizeof(parserutils_stack), pw);
+	if (s == NULL)
+		return PARSERUTILS_NOMEM;
 
-	stack->items = alloc(NULL, item_size * chunk_size, pw);
-	if (stack->items == NULL) {
-		alloc(stack, 0, pw);
-		return NULL;
+	s->items = alloc(NULL, item_size * chunk_size, pw);
+	if (s->items == NULL) {
+		alloc(s, 0, pw);
+		return PARSERUTILS_NOMEM;
 	}
 
-	stack->item_size = item_size;
-	stack->chunk_size = chunk_size;
-	stack->items_allocated = chunk_size;
-	stack->current_item = -1;
+	s->item_size = item_size;
+	s->chunk_size = chunk_size;
+	s->items_allocated = chunk_size;
+	s->current_item = -1;
+
+	s->alloc = alloc;
+	s->pw = pw;
 
-	stack->alloc = alloc;
-	stack->pw = pw;
+	*stack = s;
 
-	return stack;
+	return PARSERUTILS_OK;
 }
 
 /**
  * Destroy a stack instance
  *
  * \param stack  The stack to destroy
+ * \return PARSERUTILS_OK on success, appropriate error otherwise.
  */
-void parserutils_stack_destroy(parserutils_stack *stack)
+parserutils_error parserutils_stack_destroy(parserutils_stack *stack)
 {
 	if (stack == NULL)
-		return;
+		return PARSERUTILS_BADPARM;
 
 	stack->alloc(stack->items, 0, stack->pw);
 	stack->alloc(stack, 0, stack->pw);
+
+	return PARSERUTILS_OK;
 }
 
 /**
diff --git a/src/utils/vector.c b/src/utils/vector.c
index 1ffa8a3..f99b773 100644
--- a/src/utils/vector.c
+++ b/src/utils/vector.c
@@ -32,49 +32,59 @@ struct parserutils_vector
  * \param chunk_size  Number of vector slots in a chunk
  * \param alloc       Memory (de)allocation function
  * \param pw          Pointer to client-specific private data
- * \return Pointer to vector instance, or NULL on memory exhaustion
+ * \param vector      Pointer to location to receive vector instance
+ * \return PARSERUTILS_OK on success,
+ *         PARSERUTILS_BADPARM on bad parameters,
+ *         PARSERUTILS_NOMEM on memory exhaustion
  */
-parserutils_vector *parserutils_vector_create(size_t item_size, 
-		size_t chunk_size, parserutils_alloc alloc, void *pw)
+parserutils_error parserutils_vector_create(size_t item_size, 
+		size_t chunk_size, parserutils_alloc alloc, void *pw,
+		parserutils_vector **vector)
 {
-	parserutils_vector *vector;
+	parserutils_vector *v;
 
-	if (item_size == 0 || chunk_size == 0 || alloc == NULL)
-		return NULL;
+	if (item_size == 0 || chunk_size == 0 || alloc == NULL || 
+			vector == NULL)
+		return PARSERUTILS_BADPARM;
 
-	vector = alloc(NULL, sizeof(parserutils_vector), pw);
-	if (vector == NULL)
-		return NULL;
+	v = alloc(NULL, sizeof(parserutils_vector), pw);
+	if (v == NULL)
+		return PARSERUTILS_NOMEM;
 
-	vector->items = alloc(NULL, item_size * chunk_size, pw);
-	if (vector->items == NULL) {
-		alloc(vector, 0, pw);
-		return NULL;
+	v->items = alloc(NULL, item_size * chunk_size, pw);
+	if (v->items == NULL) {
+		alloc(v, 0, pw);
+		return PARSERUTILS_NOMEM;
 	}
 
-	vector->item_size = item_size;
-	vector->chunk_size = chunk_size;
-	vector->items_allocated = chunk_size;
-	vector->current_item = -1;
+	v->item_size = item_size;
+	v->chunk_size = chunk_size;
+	v->items_allocated = chunk_size;
+	v->current_item = -1;
+
+	v->alloc = alloc;
+	v->pw = pw;
 
-	vector->alloc = alloc;
-	vector->pw = pw;
+	*vector = v;
 
-	return vector;
+	return PARSERUTILS_OK;
 }
 
 /**
  * Destroy a vector instance
  *
  * \param vector  The vector to destroy
+ * \return PARSERUTILS_OK on success, appropriate error otherwise.
  */
-void parserutils_vector_destroy(parserutils_vector *vector)
+parserutils_error parserutils_vector_destroy(parserutils_vector *vector)
 {
 	if (vector == NULL)
-		return;
+		return PARSERUTILS_BADPARM;
 
 	vector->alloc(vector->items, 0, vector->pw);
 	vector->alloc(vector, 0, vector->pw);
+
+	return PARSERUTILS_OK;
 }
 
 /**