X-Git-Url: https://arthur.barton.de/cgi-bin/gitweb.cgi?p=ngircd-alex.git;a=blobdiff_plain;f=src%2Fngircd%2Farray.c;h=ad4f8dac7cda4a57fd5f57a4901829872900e4ac;hp=8b83c2c4ba767b52034f35bfb6be4d83ba8f15f4;hb=4102e8fdfea33a5d8c398c98db90914c5dc29610;hpb=ebbf92898e749da9341ebe3b7e71b96362161043 diff --git a/src/ngircd/array.c b/src/ngircd/array.c index 8b83c2c4..ad4f8dac 100644 --- a/src/ngircd/array.c +++ b/src/ngircd/array.c @@ -5,117 +5,96 @@ * (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 $"; +#include "array.h" #include - #include #include #include "log.h" -#define array_UNUSABLE(x) ( ! x->mem || (0 == x->allocated) ) +/* Enable more Debug messages in alloc / append / memmove code. */ +/* #define DEBUG_ARRAY */ -#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); - - if (pos_plus1 < pos) - return NULL; + assert(size > 0); - 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); +#ifdef DEBUG_ARRAY + Log(LOG_DEBUG, "array_alloc(): changing size from %u to %u bytes.", + a->allocated, alloc); #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); -#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; } @@ -127,31 +106,23 @@ array_copy(array * dest, const array * const src) 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); - - if (!len || !src) - return true; + assert(dest != NULL); + assert(src != NULL ); - 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); } @@ -166,14 +137,14 @@ array_copys(array * dest, const char *src) /* 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; @@ -192,11 +163,11 @@ array_catb(array * dest, const char *src, unsigned int len) ptr = dest->mem; - assert(ptr); + assert(ptr != NULL); -#ifdef DEBUG +#ifdef 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); @@ -221,6 +192,18 @@ array_cat0(array * a) } +/* 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) @@ -236,33 +219,35 @@ 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); +#ifdef 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); @@ -271,21 +256,19 @@ array_free(array * a) 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; } @@ -293,17 +276,17 @@ array_start(const array * const a) 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) @@ -313,17 +296,14 @@ array_truncate(array * a, unsigned int membersize, unsigned int len) /* 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; } @@ -331,9 +311,9 @@ array_moveleft(array * a, unsigned int membersize, unsigned int pos) if (!bytepos) return; /* nothing to do */ -#ifdef DEBUG +#ifdef 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) {