From 64089dca388f5a9a8235a94b4372763875132219 Mon Sep 17 00:00:00 2001 From: lecoanet Date: Wed, 2 Feb 2000 14:01:15 +0000 Subject: Passage en Zinc --- generic/List.c | 238 ++++++++++++++++++++++++++++----------------------------- 1 file changed, 119 insertions(+), 119 deletions(-) (limited to 'generic/List.c') diff --git a/generic/List.c b/generic/List.c index 573d7b2..2b0ed2f 100644 --- a/generic/List.c +++ b/generic/List.c @@ -31,25 +31,25 @@ ********************************************************************************** * * This modules exports the following functions: - * - RadarListNew - * - RadarListDuplicate - * - RadarListEmpty - * - RadarListFromArray - * - RadarListArray - * - RadarListFree - * - RadarListSize - * - RadarListAssertSize - * - RadarListAdd - * - RadarListAt - * - RadarListAtPut - * - RadarListDelete - * - RadarListTruncate - * - RadarListDetect - * - RadarListDo + * - ZnListNew + * - ZnListDuplicate + * - ZnListEmpty + * - ZnListFromArray + * - ZnListArray + * - ZnListFree + * - ZnListSize + * - ZnListAssertSize + * - ZnListAdd + * - ZnListAt + * - ZnListAtPut + * - ZnListDelete + * - ZnListTruncate + * - ZnListDetect + * - ZnListDo * * To appear soon: - * - RadarListCollect - * - RadarListReject + * - ZnListCollect + * - ZnListReject * * And the following variables: * @@ -102,7 +102,7 @@ typedef struct { long elem_size; long alloc_size; long used_size; -} _RadarList; +} _ZnList; /* @@ -116,7 +116,7 @@ typedef struct { */ static void -GrowIfNeeded(_RadarList *list, +GrowIfNeeded(_ZnList *list, int min_size) { if (list->used_size+min_size <= list->alloc_size) { @@ -127,15 +127,15 @@ GrowIfNeeded(_RadarList *list, if (list->list == NULL) { /* Normal case if we have created a zero sized list */ list->alloc_size = min_size; - list->list = (char *) RadarMalloc(list->alloc_size*list->elem_size); + list->list = (char *) ZnMalloc(list->alloc_size*list->elem_size); } else { - /* Case of a list made by RadarListFromArray. If we try to make + /* Case of a list made by ZnListFromArray. If we try to make it grow we need to reallocate and copy. */ char *new_list; list->alloc_size = list->used_size+min_size; - new_list = (char *) RadarMalloc(list->alloc_size*list->elem_size); + new_list = (char *) ZnMalloc(list->alloc_size*list->elem_size); memcpy(new_list, list->list, list->used_size*list->elem_size); @@ -146,7 +146,7 @@ GrowIfNeeded(_RadarList *list, list->alloc_size = MAX(MIN(list->alloc_size*2, MAX_CHUNCK_SIZE), list->alloc_size+min_size); - list->list = (char *) RadarRealloc(list->list, + list->list = (char *) ZnRealloc(list->list, list->alloc_size*list->elem_size); } @@ -159,17 +159,17 @@ GrowIfNeeded(_RadarList *list, /* ********************************************************************************** * - * RadarListNew -- + * ZnListNew -- * Return a new empty list 'initial_size' large. * ********************************************************************************** */ -RadarList -RadarListNew(int initial_size, - int element_size) +ZnList +ZnListNew(int initial_size, + int element_size) { - _RadarList *new_list; + _ZnList *new_list; if (initial_size < 0) { initial_size = 0; @@ -179,7 +179,7 @@ RadarListNew(int initial_size, element_size = 1; } - new_list = (_RadarList *) RadarMalloc(sizeof(_RadarList)); + new_list = (_ZnList *) ZnMalloc(sizeof(_ZnList)); new_list->alloc_size = initial_size; new_list->used_size = 0; @@ -188,33 +188,33 @@ RadarListNew(int initial_size, if (initial_size) { long size = new_list->alloc_size*new_list->elem_size; - new_list->list = RadarMalloc(size); + new_list->list = ZnMalloc(size); memset(new_list->list, 0, size); } else { new_list->list = NULL; } - return (RadarList) new_list; + return (ZnList) new_list; } /* ********************************************************************************** * - * RadarListDuplicate -- + * ZnListDuplicate -- * Return a copy of the list given as parameter. * ********************************************************************************** */ -RadarList -RadarListDuplicate(RadarList list) +ZnList +ZnListDuplicate(ZnList list) { - _RadarList *cur_list = (_RadarList *) list; - _RadarList *new_list; + _ZnList *cur_list = (_ZnList *) list; + _ZnList *new_list; - new_list = (_RadarList *) RadarMalloc(sizeof(_RadarList)); + new_list = (_ZnList *) ZnMalloc(sizeof(_ZnList)); new_list->alloc_size = cur_list->alloc_size == 0 ? cur_list->used_size : cur_list->alloc_size; @@ -225,7 +225,7 @@ RadarListDuplicate(RadarList list) long used_size = new_list->used_size*new_list->elem_size; long size = new_list->alloc_size*new_list->elem_size; - new_list->list = RadarMalloc(size); + new_list->list = ZnMalloc(size); if (used_size) { memcpy(new_list->list, cur_list->list, used_size); @@ -237,23 +237,23 @@ RadarListDuplicate(RadarList list) new_list->list = NULL; } - return (RadarList) new_list; + return (ZnList) new_list; } /* ********************************************************************************** * - * RadarListEmpty -- + * ZnListEmpty -- * Clear out a list, kkeping its allocated size. * ********************************************************************************** */ void -RadarListEmpty(RadarList list) +ZnListEmpty(ZnList list) { - _RadarList *cur_list = (_RadarList *) list; + _ZnList *cur_list = (_ZnList *) list; cur_list->used_size = 0; } @@ -262,39 +262,39 @@ RadarListEmpty(RadarList list) /* ********************************************************************************** * - * RadarListFromArray -- + * ZnListFromArray -- * Return a list filled from the given array. * ********************************************************************************** */ -RadarList -RadarListFromArray(void *array, - int array_size, - int element_size) +ZnList +ZnListFromArray(void *array, + int array_size, + int element_size) { - _RadarList *new_list; + _ZnList *new_list; - new_list = (_RadarList *) RadarListNew(0, element_size); + new_list = (_ZnList *) ZnListNew(0, element_size); new_list->list = array; new_list->used_size = array_size; - return (RadarList) new_list; + return (ZnList) new_list; } /* ********************************************************************************** * - * RadarListArray -- + * ZnListArray -- * Return a pointer to the array containing the list. * ********************************************************************************** */ void * -RadarListArray(RadarList list) +ZnListArray(ZnList list) { - _RadarList *cur_list = (_RadarList *) list; + _ZnList *cur_list = (_ZnList *) list; return (void *) cur_list->list; } @@ -303,7 +303,7 @@ RadarListArray(RadarList list) /* ********************************************************************************** * - * RadarListFree -- + * ZnListFree -- * Delete a list and free its memory. The entries * still in the list are lost but no further deallocation * is attempted. @@ -312,48 +312,48 @@ RadarListArray(RadarList list) */ void -RadarListFree(RadarList list) +ZnListFree(ZnList list) { - _RadarList *cur_list = (_RadarList *) list; + _ZnList *cur_list = (_ZnList *) list; if (cur_list->list != NULL && cur_list->alloc_size != 0) { - RadarFree(cur_list->list); + ZnFree(cur_list->list); } - RadarFree(cur_list); + ZnFree(cur_list); } /* ********************************************************************************** * - * RadarListSize -- + * ZnListSize -- * Return the current number of entries kept in list. * ********************************************************************************** */ int -RadarListSize(RadarList list) +ZnListSize(ZnList list) { - return ((_RadarList *)list)->used_size; + return ((_ZnList *)list)->used_size; } /* ********************************************************************************** * - * RadarListAssertSize -- + * ZnListAssertSize -- * Set the list length to size. * ********************************************************************************** */ void -RadarListAssertSize(RadarList list, - int size) +ZnListAssertSize(ZnList list, + int size) { - _RadarList *cur_list = (_RadarList *) list; + _ZnList *cur_list = (_ZnList *) list; if (cur_list->used_size < size) { GrowIfNeeded(cur_list, size - cur_list->used_size); @@ -365,20 +365,20 @@ RadarListAssertSize(RadarList list, /* ********************************************************************************** * - * RadarListCopy -- + * ZnListCopy -- * Destructively copy 'from' into 'to' starting at the first - * position. It is the same as saying RadarListEmpty and then - * RadarListAppend. + * position. It is the same as saying ZnListEmpty and then + * ZnListAppend. * ********************************************************************************** */ void -RadarListCopy(RadarList to, - RadarList from) +ZnListCopy(ZnList to, + ZnList from) { - _RadarList *to_list = (_RadarList *) to; - _RadarList *from_list = (_RadarList *) from; + _ZnList *to_list = (_ZnList *) to; + _ZnList *from_list = (_ZnList *) from; if (from_list->elem_size != to_list->elem_size) { return; @@ -396,18 +396,18 @@ RadarListCopy(RadarList to, /* ********************************************************************************** * - * RadarListAppend -- + * ZnListAppend -- * Append 'from' at the end of 'to' which is enlarged as needed. * ********************************************************************************** */ void -RadarListAppend(RadarList to, - RadarList from) +ZnListAppend(ZnList to, + ZnList from) { - _RadarList *to_list = (_RadarList *) to; - _RadarList *from_list = (_RadarList *) from; + _ZnList *to_list = (_ZnList *) to; + _ZnList *from_list = (_ZnList *) from; if (from_list->elem_size != to_list->elem_size) { return; @@ -424,22 +424,22 @@ RadarListAppend(RadarList to, /* ********************************************************************************** * - * RadarListAdd -- + * ZnListAdd -- * Add a new entry 'value' in the list before * 'index'. 'index' can be the position of a - * previous entry or the special values RadarListHead, - * RadarListTail. The entries have positions + * previous entry or the special values ZnListHead, + * ZnListTail. The entries have positions * starting at 0. * ********************************************************************************** */ void -RadarListAdd(RadarList list, - void *value, - int index) +ZnListAdd(ZnList list, + void *value, + int index) { - _RadarList *cur_list = (_RadarList *) list; + _ZnList *cur_list = (_ZnList *) list; int i; GrowIfNeeded(cur_list, 1); @@ -470,7 +470,7 @@ RadarListAdd(RadarList list, /* ********************************************************************************** * - * RadarListAt -- + * ZnListAt -- * Return the entry at 'index'. Indices start at 0. * Indices out of the current range are constrained * to fit in the range. @@ -479,27 +479,27 @@ RadarListAdd(RadarList list, */ void * -RadarListAt(RadarList list, - int index) +ZnListAt(ZnList list, + int index) { - if (!((_RadarList *) list)->used_size) { + if (!((_ZnList *) list)->used_size) { return NULL; } - if (index >= ((_RadarList *) list)->used_size) { - index = ((_RadarList *) list)->used_size - 1; + if (index >= ((_ZnList *) list)->used_size) { + index = ((_ZnList *) list)->used_size - 1; } if (index < 0) { index = 0; } - return (void *) ((_RadarList *) list)->list+(index*((_RadarList *) list)->elem_size); + return (void *) ((_ZnList *) list)->list+(index*((_ZnList *) list)->elem_size); } /* ********************************************************************************** * - * RadarListAtPut -- + * ZnListAtPut -- * Set the entry at 'index' to 'value'. * Indices start at 0. Indices out of the current * range are constrained to fit in the range. @@ -508,30 +508,30 @@ RadarListAt(RadarList list, */ void -RadarListAtPut(RadarList list, - void *value, - int index) +ZnListAtPut(ZnList list, + void *value, + int index) { - if (!((_RadarList *) list)->used_size) { + if (!((_ZnList *) list)->used_size) { return; } - if (index >= ((_RadarList *) list)->used_size) { - index = ((_RadarList *) list)->used_size - 1; + if (index >= ((_ZnList *) list)->used_size) { + index = ((_ZnList *) list)->used_size - 1; } if (index < 0) { index = 0; } - memcpy(((_RadarList *) list)->list+(index*((_RadarList *) list)->elem_size), + memcpy(((_ZnList *) list)->list+(index*((_ZnList *) list)->elem_size), (char *) value, - ((_RadarList *) list)->elem_size); + ((_ZnList *) list)->elem_size); } /* ********************************************************************************** * - * RadarListDelete -- + * ZnListDelete -- * Suppress the entry matching value, searching from position * 'index'. If value is NULL suppress entry at index. * @@ -539,17 +539,17 @@ RadarListAtPut(RadarList list, */ void -RadarListDelete(RadarList list, - int index) +ZnListDelete(ZnList list, + int index) { - _RadarList *cur_list = (_RadarList *) list; + _ZnList *cur_list = (_ZnList *) list; int i; - if (!((_RadarList *) list)->used_size) { + if (!((_ZnList *) list)->used_size) { return; } - if (index >= ((_RadarList *) list)->used_size) { - index = ((_RadarList *) list)->used_size - 1; + if (index >= ((_ZnList *) list)->used_size) { + index = ((_ZnList *) list)->used_size - 1; } if (index < 0) { index = 0; @@ -566,22 +566,22 @@ RadarListDelete(RadarList list, /* ********************************************************************************** * - * RadarListTruncate -- + * ZnListTruncate -- * Suppress the entries from position 'index' inclusive to the end. * ********************************************************************************** */ void -RadarListTruncate(RadarList list, - int index) +ZnListTruncate(ZnList list, + int index) { - _RadarList *cur_list = (_RadarList *) list; + _ZnList *cur_list = (_ZnList *) list; - if (!((_RadarList *) list)->used_size) { + if (!((_ZnList *) list)->used_size) { return; } - if (index >= ((_RadarList *) list)->used_size) { + if (index >= ((_ZnList *) list)->used_size) { return; } if (index < 0) { @@ -595,12 +595,12 @@ RadarListTruncate(RadarList list, /* ********************************************************************************** * - * RadarListDo -- + * ZnListDo -- * Apply the function 'to_do' to each entry in the list. * Stop either at end of list or if 'to_do' returns a * non nul result. 'to_do' is a function with two * parameters. The first is bound in turn to each value of - * the list, the second is the data passed to RadarListDo. + * the list, the second is the data passed to ZnListDo. * If the scan stops at the end of the list, the function * returns -1, else it returns the index at which it has * stopped. @@ -609,11 +609,11 @@ RadarListTruncate(RadarList list, */ int -RadarListDo(RadarList list, - void *data, - int (*to_do)(void *value, void *data)) +ZnListDo(ZnList list, + void *data, + int (*to_do)(void *value, void *data)) { - _RadarList *cur_list = (_RadarList *) list; + _ZnList *cur_list = (_ZnList *) list; int i; for (i = 0; -- cgit v1.1