lists.h

Go to the documentation of this file.

#ifndef LISTSH
#define LISTSH


/* Generic list code.  VoidList is for when you want a list of pointers to
   things and IntList is for when you just want to store a bunch of integers
    in a list.

    IntList is so you don't always have to create a bunch of pointers to ints
    to store them.

   By Geoff Hulten
   Revised 2/5/98
*/

/* HERE add some asserts to this code */

//#define LINKEDLISTS

#ifdef LINKEDLISTS
   #define VoidList     VoidLList
   #define VoidListPtr  VoidLListPtr
   #define VoidListHandle       VoidLListHandle

   #define VLNew                VLLNew
   #define VLAppend             VLLAppend
   #define VLPush               VLLPush
   #define VLLength             VLLLength
   #define VLIndex              VLLIndex
   #define VLSort               VLLSort
   #define VLRemove             VLLRemove
   #define VLInsert             VLLInsert
   #define VLSet                VLLSet
   #define VLFree               VLLFree

#else /* ARRAYLISTS */
   #define VoidList     VoidAList
   #define VoidListPtr  VoidAListPtr
   #define VoidListHandle       VoidAListHandle

   #define VLNew                VALNew
   #define VLAppend             VALAppend
   #define VLPush               VALPush
   #define VLLength             VALLength
   #define VLIndex              VALIndex
   #define VLSort               VALSort
   #define VLRemove             VALRemove
   #define VLInsert             VALInsert
   #define VLSet                VALSet
   #define VLFree               VALFree
#endif

typedef struct _VoidLList_ {
   void *element;
   struct _VoidLList_ *next;
} VoidLList, *VoidLListPtr, **VoidLListHandle;

VoidLListPtr VLLNew(void);
/* append the element to the end of the list */
void VLLAppend(VoidLListPtr list, void *element);
/* push element on the head of the list */
void VLLPush(VoidLListPtr list, void *element);
int VLLLength(VoidLListPtr list);

void *VLLIndex(VoidLListPtr list, long index);
void VLLSort(VoidLListPtr list, int (*cmp)(const void *, const void *));
void *VLLRemove(VoidLListPtr list, long index);
void VLLInsert(VoidLListPtr list, void *element, long index);
void VLLSet(VoidLListPtr list, long index, void *newVal);
void VLLFree(VoidLListPtr list);

typedef struct _VoidAList_ {
   int size;
   int allocatedSize;
   void **array;
} VoidAList, *VoidAListPtr, **VoidAListHandle;

VoidAListPtr VALNew(void);
void VALAppend(VoidAListPtr list, void *element);
void VALPush(VoidAListPtr list, void *element);

//int VALLength(VoidAListPtr list);
#define VALLength(list) \
   (((VoidAListPtr)(list))->size)

//void *VALIndex(VoidAListPtr list, long index);
#define VALIndex(list, index) \
    ( (index < ((VoidAListPtr)list)->size) ? (((VoidAListPtr)list)->array[index]) : (0) )

void VALSort(VoidAListPtr list, int (*cmp)(const void *, const void *));

void *VALRemove(VoidAListPtr list, long index);

void VALInsert(VoidAListPtr list, void *element, long index);

void VALSet(VoidAListPtr list, long index, void *newVal);

void VALFree(VoidAListPtr list);

typedef VoidAList    IntList;
typedef VoidAListPtr IntListPtr;

#define ILNew()             VLNew()
#define ILClone(l)          VLClone(l)
#define ILAppend(l, e)      VLAppend(l, (void *)e)
#define ILPush(l, e)        VLPush(l, (void *) e)
#define ILInsert(l, e, i)   VLInsert(l, (void *) e, i)
#define ILLength(l)         VLLength(l)
#define ILIndex(l, i)       (void *)VLIndex(l, i)
#define ILRemove(l, i)      (void *)VLRemove(l, i)
#define ILSet(l, i, e)      VLSet(l, i, (void *)e)
#define ILFree(l)           VLFree(l)
#define ILFind(l, e)        VLFind(l, (void *)e)

//typedef struct _IntList_ {
//   int theInt;
//   struct _IntList_ *next;
//} IntList, *IntListPtr, **IntListHandle;

//IntListPtr ILNew(void);
//IntListPtr ILClone(IntListPtr orig);
/* append the element to the end of the list */
//void ILAppend(IntListPtr list, int element);
/* push element on the head of the list */
//void ILPush(IntListPtr list, int element);
//void ILInsert(IntListPtr list, int element, long index);
//int ILLength(IntListPtr list);
//int ILIndex(IntListPtr list, long index);
//int ILRemove(IntListPtr list, long index);
//void ILSet(IntListPtr list, long index, int newVal);
//void ILFree(IntListPtr list);
//int ILFind(IntListPtr list, int element);


typedef struct _FloatList_ {
   int size;
   int allocatedSize;
   float *array;
} FloatList, *FloatListPtr, **FloatListHandle;

FloatListPtr FLNew(void);
FloatListPtr FLClone(FloatListPtr orig);
/* append the element to the end of the list */
void FLAppend(FloatListPtr list, float element);
/* push element on the head of the list */
void FLPush(FloatListPtr list, float element);
void FLInsert(FloatListPtr list, float element, long index);
int FLLength(FloatListPtr list);

float FLIndex(FloatListPtr list, long index);
float FLRemove(FloatListPtr list, long index);
void FLSet(FloatListPtr list, long index, float newVal);
void FLFree(FloatListPtr list);
int FLFind(FloatListPtr list, float element);

#endif

---

Generated for VFML by hosted by