Update from the Windows port and general cleanup/restructure

1 files changed, 39 insertions, 63 deletions

diff --git a/generic/List.c b/generic/List.c
index 8695df0..3d0e9db 100644
--- a/generic/List.c
+++ b/generic/List.c
@@ -66,7 +66,6 @@
 
 #include "Types.h"
 #include "List.h"
-#include "config.h"
 
 #include <stddef.h>
 #include <memory.h>
@@ -98,10 +97,10 @@ static const char compile_id[]="$Compile: " __FILE__ " " __DATE__ " " __TIME__ "
  */
 
 typedef struct {
-  char	*list;
-  long	elem_size;
-  long	alloc_size;
-  long	used_size;
+  char		*list;
+  unsigned long	elem_size;
+  unsigned long	alloc_size;
+  unsigned long	used_size;
 } _ZnList;
 
 
@@ -116,8 +115,8 @@ typedef struct {
  */
 
 static void
-GrowIfNeeded(_ZnList	*list,
-	     int	min_size)
+GrowIfNeeded(_ZnList	  *list,
+	     unsigned int min_size)
 {
   if (list->used_size+min_size <= list->alloc_size) {
     return;
@@ -127,7 +126,7 @@ GrowIfNeeded(_ZnList	*list,
     if (list->list == NULL) {
       /* Normal case if we have created a zero sized list */
       list->alloc_size = min_size;
-      list->list = (char *) ZnMalloc(list->alloc_size*list->elem_size);
+      list->list = ZnMalloc(list->alloc_size*list->elem_size);
     }
     else {
       /* Case of a list made by ZnListFromArray. If we try to make
@@ -135,7 +134,7 @@ GrowIfNeeded(_ZnList	*list,
       char	*new_list;
 
       list->alloc_size = list->used_size+min_size;
-      new_list = (char *) ZnMalloc(list->alloc_size*list->elem_size);
+      new_list = ZnMalloc(list->alloc_size*list->elem_size);
       memcpy(new_list,
 	     list->list,
 	     list->used_size*list->elem_size);
@@ -146,8 +145,8 @@ GrowIfNeeded(_ZnList	*list,
     list->alloc_size = MAX(MIN(list->alloc_size*2, MAX_CHUNCK_SIZE),
 			   list->alloc_size+min_size);
     
-    list->list = (char *) ZnRealloc(list->list,
-				    list->alloc_size*list->elem_size);
+    list->list = ZnRealloc(list->list,
+			   list->alloc_size*list->elem_size);
   }
   
   memset(list->list+(list->used_size*list->elem_size),
@@ -166,27 +165,23 @@ GrowIfNeeded(_ZnList	*list,
  */
 
 ZnList
-ZnListNew(int	initial_size,
-	  int	element_size)
+ZnListNew(unsigned int	initial_size,
+	  unsigned int	element_size)
 {
   _ZnList	*new_list;
 
-  if (initial_size < 0) {
-    initial_size = 0;
-  }
-
-  if (element_size <= 0) {
+  if (element_size == 0) {
     element_size = 1;
   }
 
-  new_list = (_ZnList *) ZnMalloc(sizeof(_ZnList));
+  new_list = ZnMalloc(sizeof(_ZnList));
 
   new_list->alloc_size = initial_size;
   new_list->used_size = 0;
   new_list->elem_size = element_size;
 
   if (initial_size) {
-    long	size = new_list->alloc_size*new_list->elem_size;
+    unsigned long size = new_list->alloc_size*new_list->elem_size;
 
     new_list->list = ZnMalloc(size);
     memset(new_list->list, 0, size);
@@ -214,7 +209,7 @@ ZnListDuplicate(ZnList	list)
   _ZnList	*cur_list = (_ZnList *) list;
   _ZnList	*new_list;
 
-  new_list = (_ZnList *) ZnMalloc(sizeof(_ZnList));
+  new_list = ZnMalloc(sizeof(_ZnList));
 
   new_list->alloc_size = cur_list->alloc_size == 0 ? cur_list->used_size :
                                                      cur_list->alloc_size;
@@ -222,8 +217,8 @@ ZnListDuplicate(ZnList	list)
   new_list->elem_size = cur_list->elem_size;
 
   if (new_list->alloc_size) {
-    long	used_size = new_list->used_size*new_list->elem_size;
-    long	size = new_list->alloc_size*new_list->elem_size;
+    unsigned long used_size = new_list->used_size*new_list->elem_size;
+    unsigned long size = new_list->alloc_size*new_list->elem_size;
 
     new_list->list = ZnMalloc(size);
 
@@ -269,9 +264,9 @@ ZnListEmpty(ZnList	list)
  */
 
 ZnList
-ZnListFromArray(void	*array,
-		int	array_size,
-		int	element_size)
+ZnListFromArray(void		*array,
+		unsigned int	array_size,
+		unsigned int	element_size)
 {
   _ZnList	*new_list;
 
@@ -333,7 +328,7 @@ ZnListFree(ZnList	list)
  **********************************************************************************
  */
 
-int
+unsigned int
 ZnListSize(ZnList	list)
 {
   return ((_ZnList *)list)->used_size;
@@ -350,8 +345,8 @@ ZnListSize(ZnList	list)
  */
 
 void
-ZnListAssertSize(ZnList	list,
-		 int	size)
+ZnListAssertSize(ZnList		list,
+		 unsigned int	size)
 {
   _ZnList	*cur_list = (_ZnList *) list;
 
@@ -437,19 +432,15 @@ ZnListAppend(ZnList	to,
 void
 ZnListAdd(ZnList	list,
 	  void		*value,
-	  int		index)
+	  unsigned int	index)
 {
-  _ZnList	*cur_list = (_ZnList *) list;
-  int		i;
+  _ZnList *cur_list = (_ZnList *) list;
+  int	  i;
 
   GrowIfNeeded(cur_list, 1);
 
-  if (index < 0) {
-    index = 0;
-  }
-
   if (index < cur_list->used_size) {
-    for (i = cur_list->used_size-1; i >= index; i--) {
+    for (i = cur_list->used_size-1; i >= (int) index; i--) {
       memcpy(cur_list->list+((i+1)*cur_list->elem_size),
 	     cur_list->list+(i*cur_list->elem_size),
 	     cur_list->elem_size);
@@ -479,8 +470,8 @@ ZnListAdd(ZnList	list,
  */
 
 void *
-ZnListAt(ZnList	list,
-	 int	index)
+ZnListAt(ZnList		list,
+	 unsigned int	index)
 {
   if (!((_ZnList *) list)->used_size) {
     return NULL;
@@ -488,11 +479,8 @@ ZnListAt(ZnList	list,
   if (index >= ((_ZnList *) list)->used_size) {
     index = ((_ZnList *) list)->used_size - 1;
   }
-  if (index < 0) {
-    index = 0;
-  }
   
-  return (void *) ((_ZnList *) list)->list+(index*((_ZnList *) list)->elem_size);
+  return (void *) (((_ZnList *) list)->list+(index*((_ZnList *) list)->elem_size));
 }
 
 
@@ -508,9 +496,9 @@ ZnListAt(ZnList	list,
  */
 
 void
-ZnListAtPut(ZnList	list,
-	    void	*value,
-	    int		index)
+ZnListAtPut(ZnList	 list,
+	    void	 *value,
+	    unsigned int index)
 {
   if (!((_ZnList *) list)->used_size) {
     return;
@@ -518,9 +506,6 @@ ZnListAtPut(ZnList	list,
   if (index >= ((_ZnList *) list)->used_size) {
     index = ((_ZnList *) list)->used_size - 1;
   }
-  if (index < 0) {
-    index = 0;
-  }
   
   memcpy(((_ZnList *) list)->list+(index*((_ZnList *) list)->elem_size),
 	 (char *) value,
@@ -539,11 +524,11 @@ ZnListAtPut(ZnList	list,
  */
 
 void
-ZnListDelete(ZnList	list,
-	     int	index)
+ZnListDelete(ZnList		list,
+	     unsigned int	index)
 {
   _ZnList	*cur_list = (_ZnList *) list;
-  int		i;
+  unsigned int	i;
 
   if (!((_ZnList *) list)->used_size) {
     return;
@@ -551,9 +536,6 @@ ZnListDelete(ZnList	list,
   if (index >= ((_ZnList *) list)->used_size) {
     index = ((_ZnList *) list)->used_size - 1;
   }
-  if (index < 0) {
-    index = 0;
-  }
 
   for (i = index; i < cur_list->used_size-1; i++) {
     memcpy(cur_list->list+(i*cur_list->elem_size),
@@ -573,20 +555,14 @@ ZnListDelete(ZnList	list,
  */
 
 void
-ZnListTruncate(ZnList	list,
-	       int	index)
+ZnListTruncate(ZnList		list,
+	       unsigned int	index)
 {
   _ZnList	*cur_list = (_ZnList *) list;
 
-  if (!((_ZnList *) list)->used_size) {
-    return;
-  }
   if (index >= ((_ZnList *) list)->used_size) {
     return;
   }
-  if (index < 0) {
-    index = 0;
-  }
 
   cur_list->used_size = index;
 }