* (at your option) any later version.
* Please read the file COPYING, README and AUTHORS for more information.
*
- * functions to dynamically allocate arrays.
+ * libarray - dynamically allocate arrays.
* Copyright (c) 2005 Florian Westphal (westphal@foo.fh-furtwangen.de)
- *
*/
-#include "array.h"
+/**
+ * @file
+ * Functions to dynamically allocate arrays.
+ */
-static char UNUSED id[] = "$Id: array.c,v 1.1 2005/07/07 18:38:14 fw Exp $";
+/* Additionan debug messages related to array handling: 0=off / 1=on */
+#define DEBUG_ARRAY 0
-#include <assert.h>
+#include "array.h"
+#include <assert.h>
#include <stdlib.h>
#include <string.h>
+#include <unistd.h>
-#include "log.h"
-
-#define array_UNUSABLE(x) ( ! x->mem || (0 == x->allocated) )
+#if DEBUG_ARRAY
+# include "log.h"
+#endif
-#define ALIGN_32U(x) ((x | 0x1fU) +1)
-#define ALIGN_1024U(x) ((x | 0x3ffU) +1)
-#define ALIGN_4096U(x) ((x | 0xfffU) +1)
+#define array_UNUSABLE(x) ( !(x)->mem )
-static int
-safemult_uint(unsigned int a, unsigned int b, unsigned int *res)
+static bool
+safemult_sizet(size_t a, size_t b, size_t *res)
{
- unsigned int tmp;
+ size_t tmp = a * b;
- if (!a || !b) {
- *res = 0;
- return 1;
- }
+ if (b && (tmp / b != a))
+ return false;
- tmp = a * b;
+ *res = tmp;
+ return true;
+}
- if (tmp / b != a)
- return 0;
- *res = tmp;
- return 1;
+void
+array_init(array *a)
+{
+ assert(a != NULL);
+ a->mem = NULL;
+ a->allocated = 0;
+ a->used = 0;
}
/* if realloc() fails, array_alloc return NULL. otherwise return pointer to elem pos in array */
void *
-array_alloc(array * a, unsigned int size, unsigned int pos)
+array_alloc(array * a, size_t size, size_t pos)
{
- unsigned int alloc, pos_plus1 = pos + 1;
- unsigned int aligned = 0;
+ size_t alloc, pos_plus1 = pos + 1;
char *tmp;
- assert(size);
+ assert(size > 0);
- if (pos_plus1 < pos)
- return NULL;
-
- if (!safemult_uint(size, pos_plus1, &alloc))
+ if (pos_plus1 == 0 || !safemult_sizet(size, pos_plus1, &alloc))
return NULL;
if (a->allocated < alloc) {
- if (alloc < 128) {
- aligned = ALIGN_32U(alloc);
- } else {
- if (alloc < 4096) {
- aligned = ALIGN_1024U(alloc);
- } else {
- aligned = ALIGN_4096U(alloc);
- }
- }
-#ifdef DEBUG
- Log(LOG_DEBUG, "Rounded %u to %u byte.", alloc, aligned);
-#endif
-
- assert(aligned >= alloc);
-
- if (aligned < alloc) /* rounding overflow */
- return NULL;
-
- alloc = aligned;
-#ifdef DEBUG
- Log(LOG_DEBUG, "array_alloc: changing size from %u to %u byte",
- a->allocated, aligned);
+#if DEBUG_ARRAY
+ Log(LOG_DEBUG, "array_alloc(): changing size from %u to %u bytes.",
+ a->allocated, alloc);
#endif
-
tmp = realloc(a->mem, alloc);
if (!tmp)
return NULL;
a->mem = tmp;
a->allocated = alloc;
-
- assert(a->allocated > a->used);
-
memset(a->mem + a->used, 0, a->allocated - a->used);
-
a->used = alloc;
}
+
+ assert(a->allocated >= a->used);
+
return a->mem + (pos * size);
}
/*return number of initialized ELEMS in a. */
-unsigned int
-array_length(const array * const a, unsigned int membersize)
+size_t
+array_length(const array * const a, size_t membersize)
{
- assert(a);
- assert(membersize);
+ assert(a != NULL);
+ assert(membersize > 0);
if (array_UNUSABLE(a))
return 0;
+ assert(a->allocated);
return membersize ? a->used / membersize : 0;
}
if (array_UNUSABLE(src))
return false;
+ assert(src->allocated);
return array_copyb(dest, src->mem, src->used);
}
-/* return false if we could not append src (realloc failure, invalid src/dest array) */
+/* return false on failure (realloc failure, invalid src/dest array) */
bool
-array_copyb(array * dest, const char *src, unsigned int len)
+array_copyb(array * dest, const char *src, size_t len)
{
- assert(dest);
- assert(src);
+ assert(dest != NULL);
+ assert(src != NULL );
- if (!len || !src)
- return true;
-
- if (!array_alloc(dest, 1, len))
+ if (!src || !dest)
return false;
- dest->used = len;
- memcpy(dest->mem, src, len);
-#ifdef DEBUG
- Log(LOG_DEBUG,
- "array_copyb: copied %u bytes to array (%u total bytes allocated)",
- len, dest->allocated);
-#endif
- return true;
+ array_trunc(dest);
+ return array_catb(dest, src, len);
}
/* append len bytes from src to the array dest.
return false if we could not append all bytes (realloc failure, invalid src/dest array) */
bool
-array_catb(array * dest, const char *src, unsigned int len)
+array_catb(array * dest, const char *src, size_t len)
{
- unsigned int tmp;
- unsigned int used;
+ size_t tmp;
+ size_t used;
char *ptr;
- assert(dest);
- assert(src);
+ assert(dest != NULL);
+ assert(src != NULL);
if (!len)
return true;
ptr = dest->mem;
- assert(ptr);
+ assert(ptr != NULL);
-#ifdef DEBUG
+#if DEBUG_ARRAY
Log(LOG_DEBUG,
- "array_catb: appending %u bytes to array (now %u total bytes in array)",
+ "array_catb(): appending %u bytes to array (now %u bytes in array).",
len, tmp);
#endif
memcpy(ptr + used, src, len);
}
+/* append trailing NUL byte to array, but do not count it. */
+bool
+array_cat0_temporary(array * a)
+{
+ char *endpos = array_alloc(a, 1, array_bytes(a));
+ if (!endpos)
+ return false;
+
+ *endpos = '\0';
+ return true;
+}
+
/* add contents of array src to array dest. */
bool
array_cat(array * dest, const array * const src)
return NULL if the array is unallocated, or if pos is larger than
the number of elements stored int the array. */
void *
-array_get(array * a, unsigned int membersize, unsigned int pos)
+array_get(array * a, size_t membersize, size_t pos)
{
- unsigned int totalsize;
+ size_t totalsize;
+ size_t posplus1 = pos + 1;
- assert(membersize);
- assert(a);
+ assert(membersize > 0);
+ assert(a != NULL);
- if (array_UNUSABLE(a))
+ if (!posplus1 || array_UNUSABLE(a))
return NULL;
- if (!safemult_uint(pos, membersize, &totalsize))
+ if (!safemult_sizet(posplus1, membersize, &totalsize))
return NULL;
if (a->allocated < totalsize)
return NULL;
- return a->mem + pos * membersize;
+ totalsize = pos * membersize;
+ return a->mem + totalsize;
}
void
array_free(array * a)
{
- assert(a);
-#ifdef DEBUG
+ assert(a != NULL);
+#if DEBUG_ARRAY
Log(LOG_DEBUG,
- "array_free: %u bytes free'd (%u bytes still used at time of free())",
+ "array_free(): %u bytes free'd (%u bytes still used at time of free()).",
a->allocated, a->used);
#endif
free(a->mem);
a->used = 0;
}
-
void
-array_free_wipe(array * a)
+array_free_wipe(array *a)
{
- if (!array_UNUSABLE(a))
- memset(a->mem, 0, a->allocated);
-
+ size_t bytes = a->allocated;
+ if (bytes)
+ memset(a->mem, 0, bytes);
array_free(a);
}
-
void *
array_start(const array * const a)
{
- assert(a);
+ assert(a != NULL);
return a->mem;
}
void
array_trunc(array * a)
{
- assert(a);
+ assert(a != NULL);
a->used = 0;
}
void
-array_truncate(array * a, unsigned int membersize, unsigned int len)
+array_truncate(array * a, size_t membersize, size_t len)
{
- unsigned int newlen;
- assert(a);
- if (!safemult_uint(membersize, len, &newlen))
+ size_t newlen;
+ assert(a != NULL);
+ if (!safemult_sizet(membersize, len, &newlen))
return;
if (newlen <= a->allocated)
/* move elements starting at pos to beginning of array */
void
-array_moveleft(array * a, unsigned int membersize, unsigned int pos)
+array_moveleft(array * a, size_t membersize, size_t pos)
{
- unsigned int bytepos;
-
- assert(a);
- assert(membersize);
+ size_t bytepos;
- if (!pos)
- return;
+ assert(a != NULL);
+ assert(membersize > 0);
- if (!safemult_uint(membersize, pos, &bytepos)) {
+ if (!safemult_sizet(membersize, pos, &bytepos)) {
a->used = 0;
return;
}
if (!bytepos)
return; /* nothing to do */
-#ifdef DEBUG
+#if DEBUG_ARRAY
Log(LOG_DEBUG,
- "array_moveleft: %u used bytes in array, move to beginning, starting at pos %u",
+ "array_moveleft(): %u bytes used in array, starting at position %u.",
a->used, bytepos);
#endif
if (a->used <= bytepos) {
projects / ngircd-alex.git / blobdiff