Passage en Zinc

1 files changed, 119 insertions, 119 deletions

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;