--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/parray.c	Sun Oct 02 09:55:16 2011 +0200
@@ -0,0 +1,273 @@
+/*
+ * parray.c -- manipulate dynamic pointer arrays
+ *
+ * Copyright (c) 2011, David Demelier <markand@malikania.fr>
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "parray.h"
+
+#define LENGTH(x)	((x) * (sizeof (void *)))
+
+static int	parray_grow(struct parray *);
+
+struct parray *
+parray_new(void *data, int bsize, int type)
+{
+	struct parray *arr;
+
+	if ((arr = malloc(sizeof (struct parray))) == NULL)
+		return NULL;
+
+	memset(arr, 0, sizeof (struct parray));
+
+	arr->type	= type;
+	arr->bsize	= (bsize == 0) ? PARRAY_DEFAULT_BSIZE : bsize;
+	arr->size	= LENGTH(arr->bsize);
+
+	if ((arr->datas = calloc(arr->bsize, sizeof (void *))) == NULL) {
+		free(arr);
+		return NULL;
+	}
+
+	if (data)
+		arr->datas[0] = data;
+
+	return arr;
+}
+
+/*
+ * Add to the head of array. NOTE: this may be very slow when adding a lot
+ * of object (about 100000). If you need to add a lot of data please consider
+ * using linked list instead.
+ */
+
+int
+parray_push(struct parray *arr, void *data)
+{
+	if (parray_grow(arr) < 0)
+		return -1;
+
+	memmove(&arr->datas[1], &arr->datas[0], LENGTH(arr->length++));
+	arr->datas[0] = data;
+
+	return 0;
+}
+
+/*
+ * Insert the data at the specified index. The function returns -1 on
+ * allocation failure or when the index is outof bounds otherwise 0 is returned.
+ */
+
+int
+parray_insert(struct parray *arr, void *data, int index)
+{
+	if (index > arr->length - 1 || index < 0 || parray_grow(arr) < 0)
+		return -1;
+
+	memmove(&arr->datas[index + 1], &arr->datas[index],
+		LENGTH(arr->length++ - index));
+	arr->datas[index] = data;
+
+	return 0;
+}
+
+/*
+ * Append the data to the end of array.
+ */
+
+int
+parray_append(struct parray *arr, void *data)
+{
+	if (parray_grow(arr) < 0)
+		return -1;
+
+	arr->datas[arr->length++] = data;
+
+	return 0;
+}
+
+/*
+ * Remove the array's head.
+ */
+
+void
+parray_pop(struct parray *arr)
+{
+	if (arr->length > 0) {
+		memmove(&arr->datas[0], &arr->datas[1], LENGTH(--arr->length));
+		arr->datas[arr->length] = NULL;
+	}
+}
+
+/*
+ * Remove the array's tail.
+ */
+
+void
+parray_unqueue(struct parray *arr)
+{
+	if (arr->length > 0)
+		arr->datas[--arr->length] = NULL;
+}
+
+/*
+ * Remove the data at the specified index. Bounds are checked.
+ */
+
+void
+parray_remove(struct parray *arr, int index)
+{
+	if (arr->length > 0 && index >= 0 && index < arr->length) {
+		memmove(&arr->datas[index], &arr->datas[index + 1],
+		    LENGTH(arr->length - index - 1));
+		arr->datas[--arr->length] = NULL;
+	}
+}
+
+/*
+ * Remove the object referenced by the `data' argument. Useful when you
+ * don't know the index.
+ */
+
+void
+parray_unref(struct parray *arr, const void *data)
+{
+	void *elm;
+	int i;
+
+	for (i = 0; i < arr->length; ++i) {
+		elm = PARRAY_INDEX(arr, i);
+
+		if (elm == data)
+			parray_remove(arr, i);
+	}
+}
+
+/*
+ * Swap the two elements referenced by index `i1' and `i2'. This function needs
+ * to allocate data to swap elements thus if the functions fails it returns -1
+ * otherwise 0 is returned.
+ */
+
+int
+parray_swap(struct parray *arr, int i1, int i2)
+{
+	void *tmp;
+
+	/* Out of bounds */
+	if (i1 >= arr->length || i1 < 0 || i2 >= arr->length || i2 < 0)
+		return -1;
+
+	tmp = arr->datas[i1];
+	arr->datas[i1] = arr->datas[i2];
+	arr->datas[i2] = tmp;
+
+	return 0;
+}
+
+/*
+ * Apply the function `fn' on each object and give the optional `udata'
+ * argument to the function too.
+ */
+
+void
+parray_map(const struct parray *arr, void (*fn)(void *, void *), void *udata)
+{
+	int i;
+
+	for (i = 0; i < arr->length; ++i)
+		fn(arr->datas[i], udata);
+}
+
+/*
+ * Compare each object with the user supplied function. If the `fn' function
+ * returns 1 then the data is returned. Optional idx argument can be set to
+ * indicate the data position. If the data was not found the function returns
+ * NULL.
+ */
+
+void *
+parray_find(const struct parray *arr, int (*fn)(void *, void *), int *ix, void *u)
+{
+	int st, i;
+	void *data;
+
+	for (i = st = 0; i < arr->length && st != 1; ++i)
+		st = fn(arr->datas[i], u);
+
+	if (st)	{
+		data = arr->datas[--i];
+		if (ix)
+			*ix = i;
+	} else
+		data = NULL;
+
+	return data;
+}
+
+/*
+ * Reset the array, if the trash argument is set it will free the object
+ * too, otherwise the array is just truncated to 0 length.
+ */
+
+void
+parray_clear(struct parray *arr)
+{
+	memset(arr->datas, 0, arr->size);
+	arr->length = 0;
+}
+
+/*
+ * Same as parray_clear except it also free the array object.
+ */
+
+void
+parray_free(struct parray *arr)
+{
+	parray_clear(arr);
+
+	if (arr->datas)
+		free(arr->datas);
+
+	free(arr);
+}
+
+/*
+ * Increate the array storage when it is full. If the buffer is fixed size
+ * it returns -1 on full buffer otherwise 0 is returned if allocation
+ * succeeded.
+ */
+
+static int
+parray_grow(struct parray *arr)
+{
+	if ((arr->size / sizeof (void *)) > (size_t) arr->length - 1)
+		return 0;
+
+	if (arr->type == PARRAY_AUTO) {
+		if ((arr->datas = realloc(arr->datas, arr->size +
+		    LENGTH(arr->bsize))) == NULL)
+			return -1;
+
+		arr->size += LENGTH(arr->bsize);
+	} else
+		return -1;
+
+	return 0;
+}