source: vis_dev/glu-2.3/src/array/array.c @ 64

/*
 * $Id: array.c,v 1.6 2002/08/27 06:26:29 fabio Exp $
 *
 */
/* LINTLIBRARY */

#include <stdio.h>
#include "util.h"
#include "array.h"

#define INIT_SIZE       3

int unsigned array_global_index;
int array_global_insert;

array_t *
array_do_alloc(int size, int number)
{
    array_t *array;

    array = ALLOC(array_t, 1);
    if (array == NIL(array_t)) {
        return NIL(array_t);
    }
    array->num = 0;
    array->n_size = MAX(number, INIT_SIZE);
    array->obj_size = size;
    array->index = -size;
    array->space = ALLOC(char, array->n_size * array->obj_size);
    if (array->space == NIL(char)) {
        return NIL(array_t);
    }
    (void) memset(array->space, 0, array->n_size * array->obj_size);
    return array;
}


void
array_free(array_t *array)
{
    if (array == NIL(array_t)) return;
    if (array->index >= 0) array_abort(array,4);
    FREE(array->space);
    FREE(array);
}


array_t *
array_dup(array_t *old)
{
    array_t *newa;

    newa = ALLOC(array_t, 1);
    if (newa == NIL(array_t)) {
        return NIL(array_t);
    }
    newa->num = old->num;
    newa->n_size = old->num;
    newa->obj_size = old->obj_size;
    newa->index = -newa->obj_size;
    newa->space = ALLOC(char, newa->n_size * newa->obj_size);
    if (newa->space == NIL(char)) {
        FREE(newa);
        return NIL(array_t);
    }
    (void) memcpy(newa->space, old->space, old->num * old->obj_size);
    return newa;
}

array_t *
array_partial_dup(array_t *old, int i)
{
    array_t *newa;

    newa = ALLOC(array_t, 1);
    if (newa == NIL(array_t)) {
        return NIL(array_t);
    }
    newa->num = old->num - 1;
    newa->n_size = old->num - 1;
    newa->obj_size = old->obj_size;
    newa->index = -newa->obj_size;
    newa->space = ALLOC(char, newa->n_size * newa->obj_size);
    if (newa->space == NIL(char)) {
        FREE(newa);
        return NIL(array_t);
    }
    if (i > 0)
      (void) memcpy(newa->space, old->space, i * old->obj_size);
    if (i < old->num - 1)
      (void) memcpy(newa->space + ((i) * old->obj_size), 
                    old->space + ((i+1) * old->obj_size), (old->num - (i + 1)) * old->obj_size);
    return newa;
}


/* append the elements of array2 to the end of array1 */
int
array_append(array_t *array1, array_t *array2)
{
    char *pos;

    if (array1->index >= 0) array_abort(array1,4);
    if (array1->obj_size != array2->obj_size) {
        array_abort(array1,2);
        /* NOTREACHED */
    }

    /* make sure array1 has enough room */
    if (array1->n_size < array1->num + array2->num) {
        if (array_resize(array1, array1->num + array2->num) == ARRAY_OUT_OF_MEM) {
            return ARRAY_OUT_OF_MEM;
        }
    }
    pos = array1->space + array1->num * array1->obj_size;
    (void) memcpy(pos, array2->space, array2->num * array2->obj_size);
    array1->num += array2->num;

    return 1;
}


/* join array1 and array2, returning a new array */
array_t *
array_join(array_t *array1, array_t *array2)
{
    array_t *array;
    char *pos;

    if (array1->obj_size != array2->obj_size) {
        array_abort(array1,3);
        fail("array: join not defined for arrays of different sizes\n");
        /* NOTREACHED */
    }
    array = ALLOC(array_t, 1);
    if (array == NIL(array_t)) {
        return NIL(array_t);
    }
    array->num = array1->num + array2->num;
    array->n_size = array->num;
    array->obj_size = array1->obj_size;
    array->index = -array->obj_size;
    array->space = ALLOC(char, array->n_size * array->obj_size);
    if (array->space == NIL(char)) {
        FREE(array);
        return NIL(array_t);
    }
    (void) memcpy(array->space, array1->space, array1->num * array1->obj_size);
    pos = array->space + array1->num * array1->obj_size;
    (void) memcpy(pos, array2->space, array2->num * array2->obj_size);
    return array;
}

char *
array_do_data(array_t *array)
{
    char *data;

    data = ALLOC(char, array->num * array->obj_size);
    if (data == NIL(char)) {
        return NIL(char);
    }
    (void) memcpy(data, array->space, array->num * array->obj_size);
    return data;
}


int                     /* would like to be void, except for macro's */
array_resize(array_t *array, int new_size)
{
    int old_size;
    char *pos, *newspace;

    /* Note that this is not an exported function, and does not check if
       the array is locked since that is already done by the caller. */
    old_size = array->n_size;
    array->n_size = MAX(array->n_size * 2, new_size);
    newspace = REALLOC(char, array->space, array->n_size * array->obj_size);
    if (newspace == NIL(char)) {
        array->n_size = old_size;
        return ARRAY_OUT_OF_MEM;
    } else {
        array->space = newspace;
    }
    pos = array->space + old_size * array->obj_size;
    (void) memset(pos, 0, (array->n_size - old_size)*array->obj_size);
    return 1;
}

void
array_sort(array_t *array, int (*compare)(const void *, const void *))
{
    qsort((void *)array->space, array->num, array->obj_size, compare);
}


void
array_uniq(array_t *array, int (*compare)(char **, char **), void (*free_func)(char *))
{
    int i, last;
    char *dest, *obj1, *obj2;

    dest = array->space;
    obj1 = array->space;
    obj2 = array->space + array->obj_size;
    last = array->num;

    for(i = 1; i < last; i++) {
        if ((*compare)((char **) obj1, (char **) obj2) != 0) {
            if (dest != obj1) {
                (void) memcpy(dest, obj1, array->obj_size);
            }
            dest += array->obj_size;
        } else {
            if (free_func != 0) (*free_func)(obj1);
            array->num--;
        }
        obj1 += array->obj_size;
        obj2 += array->obj_size;
    }
    if (dest != obj1) {
        (void) memcpy(dest, obj1, array->obj_size);
    }
}

int                     /* would like to be void, except for macro's */
array_abort(array_t *a, int i)
{
    fputs("array: ",stderr);

    switch (i) {

      case 0:           /* index error on insert */
        fprintf(stderr,"insert of %d\n",a->index);
        break;

      case 1:           /* index error on fetch */
        fprintf(stderr,"fetch index %d not in [0,%d]\n",
                array_global_index,a->num-1);
        break;

      case 2:           /* append with different element sizes */
        fprintf(stderr,"append undefined for arrays of different sizes\n");
        break;

      case 3:           /* join with different element sizes */
        fprintf(stderr,"join not defined for arrays of different sizes\n");
        break;

      case 4:           /* size error or locked error */
        if (a->index >= 0) {
            /* Since array_insert is a macro, it is not allowed to nest a
               call to any routine which might move the array space through
               a realloc or free inside an array_insert call. */
            fprintf(stderr,"nested insert, append, remove, or free operations\n");
        } else {
            fprintf(stderr,"object size mismatch\n");
        }
        break;
    case 5: /* attempt to remove last item from empty array */
      fprintf(stderr, "attempt to remove from empty array");
      break;
    default:
        fputs("unknown error\n", stderr);
        break;
    }

    fail("array package error");
    return 0;  /* never reached */
}