zeda_array.h

Go to the documentation of this file.

/* ZEDA - Elementary Data and Algorithms
 * Copyright (C) 1998 Tomomichi Sugihara (Zhidao)
 */
#ifndef __ZEDA_ARRAY_H__
#define __ZEDA_ARRAY_H__

#include <zeda/zeda_misc.h>
#include <zeda/zeda_name.h>

__BEGIN_DECLS

/* ********************************************************** *//* ************************************************** */

#ifdef __cplusplus
#define zArrayClass(array_t,cell_t) \
struct array_t{\
  uint size;\
  cell_t *buf;\
}
#else
#define zArrayClass(array_t,cell_t) \
typedef struct{\
  uint size;\
  cell_t *buf;\
} array_t
#endif /* __cplusplus */

#define zArraySize(a)          (a)->size
#define zArrayBuf(a)           (a)->buf

#define zArrayPosIsValid(a,p)  ( (p) < zArraySize(a) && (p) >= 0 )

/* NOTE: do not use the following macro before allocating buffer */
#define zArrayElemSize(a)      sizeof(*zArrayBuf(a))

#define zArrayElemNC(a,i)      ( &zArrayBuf(a)[i] )
#define zArrayElem(a,i)        ( zArrayPosIsValid(a,i) ? zArrayElemNC(a,i) : NULL )
#define zArraySetElemNC(a,i,d) memcpy( zArrayElemNC(a,i), (d), zArrayElemSize(a) )
#define zArraySetElem(a,i,d)   ( zArrayPosIsValid(a,i) ? zArraySetElemNC(a,i,d) : NULL )

#define zArrayHead(a)          zArrayElemNC( a, zArraySize(a)-1 )
#define zArrayNeck(a)          zArrayElemNC( a, zArraySize(a)-2 )
#define zArrayTail(a)          zArrayElemNC( a, 0 )

#define zArrayInit(arr) do{\
  zArraySize(arr) = 0;\
  zArrayBuf(arr) = NULL;\
} while(0)

#define zArrayAlloc(arr,type,n) do{\
  if( (n) <= 0 ) zArrayInit( arr );\
  else{\
    if( !( zArrayBuf(arr) = zAlloc( type, n ) ) ){\
      ZALLOCERROR();\
      zArraySize(arr) = 0;\
    } else\
      zArraySize(arr) = (n);\
  }\
} while(0)

#define zArrayFree(arr) do{\
  free( zArrayBuf(arr) );\
  zArrayInit( arr );\
} while(0)

#define zArrayFindName(arr,name,ptr) \
  zNameFind( zArrayBuf(arr), zArraySize(arr), name, ptr )

#ifndef __KERNEL__
/* since realloc() is not implemented in kernel space,
 * the following methods are only available in user space.
 */

#define zArrayAdd(arr,type,dat) do{\
  type *__zarray_ap;\
  __zarray_ap = zRealloc( zArrayBuf(arr), type, zArraySize(arr)+1 );\
  if( __zarray_ap == NULL )\
    ZALLOCERROR();\
  else{\
    zArraySize(arr)++;\
    zArrayBuf(arr) = __zarray_ap;\
    zArraySetElemNC( arr, zArraySize(arr)-1, dat );\
  }\
} while(0)

#define zArrayInsert(arr,type,pos,dat) do{\
  type *__zarray_ap;\
  if( (pos) == zArraySize(arr) ){\
    zArrayAdd( arr, type, dat );\
  } else if( zArrayPosIsValid(arr,pos) ){\
    __zarray_ap = zRealloc( zArrayBuf(arr), type, zArraySize(arr)+1 );\
    if( __zarray_ap == NULL )\
      ZALLOCERROR();\
    else{\
      zArrayBuf(arr) = __zarray_ap;\
      memmove( zArrayElemNC(arr,(pos)+1), zArrayElemNC(arr,pos), sizeof(type)*(zArraySize(arr)-(pos)) );\
      zArraySetElemNC( arr, pos, dat );\
      zArraySize(arr)++;\
    }\
  } else{\
    ZRUNWARN( "invalid position %d/%d in array specified", pos, zArraySize(arr)-1 );\
  }\
} while(0)

#define zArrayDelete(arr,type,pos) do{\
  type *__zarray_ap;\
  if( zArrayPosIsValid(arr,pos) ){\
    if( (pos) < zArraySize(arr)-1 )\
      memmove( zArrayElemNC(arr,pos), zArrayElemNC(arr,(pos)+1), sizeof(type)*(zArraySize(arr)-(pos)-1) );\
    if( zArraySize(arr) > 1 ){\
      __zarray_ap = zRealloc( zArrayBuf(arr), type, zArraySize(arr)-1 );\
      if( __zarray_ap == NULL )\
        ZALLOCERROR();\
      else{\
        zArraySize(arr)--;\
        zArrayBuf(arr) = __zarray_ap;\
      }\
    } else{\
      zArrayFree( arr );\
    }\
  } else{\
    ZRUNWARN( "invalid position %d/%d in array specified", pos, zArraySize(arr)-1 );\
  }\
} while(0)

#define zArrayAppend(arr,subarr,type) do{\
  type *__zarray_ap;\
  __zarray_ap = zRealloc( zArrayBuf(arr), type, zArraySize(arr)+zArraySize(subarr) );\
  if( __zarray_ap == NULL )\
    ZALLOCERROR();\
  else{\
    zArrayBuf(arr) = __zarray_ap;\
    memcpy( zArrayElemNC(arr,zArraySize(arr)), zArrayBuf(subarr), zArraySize(subarr)*sizeof(type) );\
    zArraySize(arr) += zArraySize(subarr);\
  }\
} while(0)

#endif /* __KERNEL__ */

__EXPORT void zQuickSort(void *array, size_t nmemb, size_t size, int (*cmp)(void*,void*,void*), void *priv);

#define zArrayQuickSort(arr,cmp,priv) zQuickSort( (void*)zArrayBuf(arr), zArraySize(arr), zArrayElemSize(arr), cmp, priv )

/* ********************************************************** *//* ************************************************** */

#ifdef __cplusplus
#define zArray2Class(array_t,cell_t) \
struct array_t{\
  uint size[2];\
  cell_t *buf;\
}
#else
#define zArray2Class(array_t,cell_t) \
typedef struct{\
  uint size[2];\
  cell_t *buf;\
} array_t
#endif /* __cplusplus */

#define zArray2Size(a,i)  (a)->size[i]
#define zArray2RowSize(a) (a)->size[0]
#define zArray2ColSize(a) (a)->size[1]
#define zArray2Buf(a)     ( (a)->buf )

#define zArray2PosIsValid(a,r,c) ( (r) < zArray2RowSize(a) && (r) >= 0 && (c) < zArray2ColSize(a) && (c) >= 0 )

/* NOTE: do not use the following macro before allocating buffer */
#define zArray2ElemSize(a)       sizeof(*zArray2Buf(a))

#define zArray2ElemNC(a,i,j)      ( &zArray2Buf(a)[(i)*zArray2ColSize(a) + (j)] )
#define zArray2Elem(a,i,j)        ( zArray2PosIsValid(a,i,j) ? zArray2ElemNC(a,i,j) : NULL )
#define zArray2SetElemNC(a,i,j,d) memcpy( zArray2ElemNC(a,i,j), (d), zArray2ElemSize(a) )
#define zArray2SetElem(a,i,j,d)   ( zArray2PosIsValid(a,i,j) ? zArray2SetElemNC(a,i,j,d) : NULL )

#define zArray2Init(arr) do{\
  zArray2RowSize(arr) = zArray2ColSize(arr) = 0;\
  zArray2Buf(arr) = NULL;\
} while(0)

#define zArray2Alloc(arr,type,r,c) do{\
  zArray2Init( arr );\
  if( (r) > 0 && (c) > 0 && !( zArray2Buf(arr) = zAlloc(type,(r)*(c)) ) ){\
    ZALLOCERROR();\
    zArray2RowSize(arr) = 0;\
    zArray2ColSize(arr) = 0;\
  } else{\
    zArray2RowSize(arr) = (r);\
    zArray2ColSize(arr) = (c);\
  }\
} while(0)

#define zArray2Free(arr) do{\
  free( zArray2Buf(arr) );\
  zArray2Init( arr );\
} while(0)

__END_DECLS

#endif /* __ZEDA_ARRAY_H__ */