This page is part of an archival collection and is no longer actively maintained.

It may contain outdated information and may not meet current or future WCAG accessibility standards. We provide this content, its subpages, and associated links for historical reference only. If you need assistance, please contact support@cs.washington.edu

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