1.1 --- a/DynArray.c	Sat Oct 30 22:12:32 2010 -0700
     1.2 +++ b/DynArray.c	Tue Feb 07 12:51:29 2012 -0800
     1.3 @@ -1,145 +1,145 @@
     1.4 -/*
     1.5 - * Copyright 2010  OpenSourceCodeStewardshipFoundation
     1.6 - *
     1.7 - * Licensed under BSD
     1.8 - */
     1.9 -
    1.10 -
    1.11 -
    1.12 -#include <stdio.h>
    1.13 -#include <malloc.h>
    1.14 -
    1.15 -#include "DynArray.h"
    1.16 -
    1.17 -
    1.18 -
    1.19 -DynArrayInfo *
    1.20 -makeDynArrayInfoFrom( void ***addrOfPtrToArray, int32 sizeOfArray )
    1.21 - { DynArrayInfo *info;
    1.22 -
    1.23 -   info = malloc( sizeof(DynArrayInfo) );
    1.24 -
    1.25 -   info->addrOfPtrToArray = addrOfPtrToArray;
    1.26 -   info->sizeOfArray      = sizeOfArray;
    1.27 -   info->numInArray       = 0;
    1.28 - }
    1.29 -
    1.30 -DynArrayInfo *
    1.31 -makeDynArrayOfSize( void ***addrOfPtrToArray, int32 sizeOfArray )
    1.32 - { DynArrayInfo *info;
    1.33 -
    1.34 -   info = malloc( sizeof(DynArrayInfo) );
    1.35 -
    1.36 -   info->addrOfPtrToArray = addrOfPtrToArray;
    1.37 -   
    1.38 -   *(addrOfPtrToArray)    = malloc( sizeOfArray * sizeof(void *) );
    1.39 -   info->sizeOfArray      = sizeOfArray;
    1.40 -   info->numInArray       = 0;
    1.41 - }
    1.42 -
    1.43 -
    1.44 -/*A dynamic array is same as any other array, but add a DynArrayInfo next
    1.45 - * to it.  Accesses and updates of array indexes are done normally, it's
    1.46 - * only when add a new element into array that use the extra info.
    1.47 - * An add can cause the pointer to the normal array to change..  so must
    1.48 - * be protected to single VP at a time.
    1.49 - *
    1.50 - *Only need to use this Fn when need a new index, higher than any previous
    1.51 - */
    1.52 -int32
    1.53 -addToDynArray( void *value, DynArrayInfo *info )
    1.54 - { int32 numInArray, sizeOfArray;
    1.55 -   void **array;
    1.56 - 
    1.57 -   numInArray = info->numInArray;
    1.58 -   sizeOfArray    = info->sizeOfArray;
    1.59 -
    1.60 -   if( numInArray >= sizeOfArray )
    1.61 -    {
    1.62 -      increaseSizeOfDynArrayTo( info, sizeOfArray * 2 );
    1.63 -    }
    1.64 -   
    1.65 -   array = *(info->addrOfPtrToArray);
    1.66 -   array[ numInArray ] = value;
    1.67 -   info->numInArray++;
    1.68 -
    1.69 -   return numInArray; //pre-incr value is the index put value into
    1.70 - }
    1.71 -
    1.72 -
    1.73 -/*Use this when know how many things going to add in -- then can do this
    1.74 - * once and use as normal array afterwards.  If later add another chunk,
    1.75 - * do this again.  Note, this makes new size be just big enough to hold
    1.76 - * highest index, so will do a linear number of copies if use only this.
    1.77 - *To cut down on number of copies, can use the increaseSizeTo Fn to
    1.78 - * exponentially increase size..
    1.79 - */
    1.80 -void
    1.81 -makeHighestDynArrayIndexBe( DynArrayInfo *info, int32 highestIndex )
    1.82 - {
    1.83 -   if( info->sizeOfArray <= highestIndex )
    1.84 -    {
    1.85 -      increaseSizeOfDynArrayTo( info, highestIndex + 1 );
    1.86 -    }
    1.87 -   info->numInArray = highestIndex + 1;
    1.88 - }
    1.89 -
    1.90 -
    1.91 -/*Only use this if certain new size is bigger than current size
    1.92 - */
    1.93 -void
    1.94 -increaseSizeOfDynArrayTo( DynArrayInfo *info, int32 newSize )
    1.95 - { int32 oldSizeOfArray, i;
    1.96 -   void **newArray, **oldArray;
    1.97 - 
    1.98 -   oldSizeOfArray   = info->sizeOfArray;
    1.99 -   if( newSize <= oldSizeOfArray ) return;
   1.100 -   
   1.101 -   oldArray         = *(info->addrOfPtrToArray);
   1.102 -   newArray         = malloc( newSize * sizeof(void *) );
   1.103 -
   1.104 -   for( i = 0; i < oldSizeOfArray; i++ )
   1.105 -    {
   1.106 -      newArray[i] = oldArray[i];
   1.107 -    }
   1.108 -   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
   1.109 -   info->sizeOfArray = newSize;
   1.110 -
   1.111 -   free( oldArray );
   1.112 - }
   1.113 -
   1.114 -
   1.115 -/* Frees the array, plus the info
   1.116 - */
   1.117 -void
   1.118 -freeDynArrayDeep( DynArrayInfo *info, FreeFnPtr freeFnPtr )
   1.119 - {
   1.120 -   forAllInDynArrayDo( info, freeFnPtr );
   1.121 -   free( *(info->addrOfPtrToArray) );
   1.122 -   free( info );
   1.123 - }
   1.124 -
   1.125 -/* Only frees the info
   1.126 - */
   1.127 -void
   1.128 -freeDynArrayFlat( DynArrayInfo *info )
   1.129 - {
   1.130 -   free( info );
   1.131 - }
   1.132 -
   1.133 -
   1.134 -/*The function has a fixed prototype: takes a void * returns void
   1.135 - * So, the function has to internally cast void * to whatever data struc..
   1.136 - */
   1.137 -void
   1.138 -forAllInDynArrayDo( DynArrayInfo *info, DynArrayFnPtr fnPtr )
   1.139 - { int32 idx;
   1.140 -   void **array;
   1.141 -
   1.142 -   array = *(info->addrOfPtrToArray);
   1.143 -   for( idx = 0; idx < info->numInArray; idx++ )
   1.144 -    {
   1.145 -      (*fnPtr)(array[idx]);
   1.146 -    }
   1.147 - }
   1.148 -
   1.149 +/*
   1.150 + * Copyright 2010  OpenSourceCodeStewardshipFoundation
   1.151 + *
   1.152 + * Licensed under BSD
   1.153 + */
   1.154 +
   1.155 +
   1.156 +
   1.157 +#include <stdio.h>
   1.158 +#include <malloc.h>
   1.159 +
   1.160 +#include "DynArray.h"
   1.161 +
   1.162 +
   1.163 +
   1.164 +DynArrayInfo *
   1.165 +makeDynArrayInfoFrom( void ***addrOfPtrToArray, int32 sizeOfArray )
   1.166 + { DynArrayInfo *info;
   1.167 +
   1.168 +   info = malloc( sizeof(DynArrayInfo) );
   1.169 +
   1.170 +   info->addrOfPtrToArray = addrOfPtrToArray;
   1.171 +   info->sizeOfArray      = sizeOfArray;
   1.172 +   info->numInArray       = 0;
   1.173 + }
   1.174 +
   1.175 +DynArrayInfo *
   1.176 +makeDynArrayOfSize( void ***addrOfPtrToArray, int32 sizeOfArray )
   1.177 + { DynArrayInfo *info;
   1.178 +
   1.179 +   info = malloc( sizeof(DynArrayInfo) );
   1.180 +
   1.181 +   info->addrOfPtrToArray = addrOfPtrToArray;
   1.182 +   
   1.183 +   *(addrOfPtrToArray)    = malloc( sizeOfArray * sizeof(void *) );
   1.184 +   info->sizeOfArray      = sizeOfArray;
   1.185 +   info->numInArray       = 0;
   1.186 + }
   1.187 +
   1.188 +
   1.189 +/*A dynamic array is same as any other array, but add a DynArrayInfo next
   1.190 + * to it.  Accesses and updates of array indexes are done normally, it's
   1.191 + * only when add a new element into array that use the extra info.
   1.192 + * An add can cause the pointer to the normal array to change..  so must
   1.193 + * be protected to single VP at a time.
   1.194 + *
   1.195 + *Only need to use this Fn when need a new index, higher than any previous
   1.196 + */
   1.197 +int32
   1.198 +addToDynArray( void *value, DynArrayInfo *info )
   1.199 + { int32 numInArray, sizeOfArray;
   1.200 +   void **array;
   1.201 + 
   1.202 +   numInArray = info->numInArray;
   1.203 +   sizeOfArray    = info->sizeOfArray;
   1.204 +
   1.205 +   if( numInArray >= sizeOfArray )
   1.206 +    {
   1.207 +      increaseSizeOfDynArrayTo( info, sizeOfArray * 2 );
   1.208 +    }
   1.209 +   
   1.210 +   array = *(info->addrOfPtrToArray);
   1.211 +   array[ numInArray ] = value;
   1.212 +   info->numInArray++;
   1.213 +
   1.214 +   return numInArray; //pre-incr value is the index put value into
   1.215 + }
   1.216 +
   1.217 +
   1.218 +/*Use this when know how many things going to add in -- then can do this
   1.219 + * once and use as normal array afterwards.  If later add another chunk,
   1.220 + * do this again.  Note, this makes new size be just big enough to hold
   1.221 + * highest index, so will do a linear number of copies if use only this.
   1.222 + *To cut down on number of copies, can use the increaseSizeTo Fn to
   1.223 + * exponentially increase size..
   1.224 + */
   1.225 +void
   1.226 +makeHighestDynArrayIndexBe( DynArrayInfo *info, int32 highestIndex )
   1.227 + {
   1.228 +   if( info->sizeOfArray <= highestIndex )
   1.229 +    {
   1.230 +      increaseSizeOfDynArrayTo( info, highestIndex + 1 );
   1.231 +    }
   1.232 +   info->numInArray = highestIndex + 1;
   1.233 + }
   1.234 +
   1.235 +
   1.236 +/*Only use this if certain new size is bigger than current size
   1.237 + */
   1.238 +void
   1.239 +increaseSizeOfDynArrayTo( DynArrayInfo *info, int32 newSize )
   1.240 + { int32 oldSizeOfArray, i;
   1.241 +   void **newArray, **oldArray;
   1.242 + 
   1.243 +   oldSizeOfArray   = info->sizeOfArray;
   1.244 +   if( newSize <= oldSizeOfArray ) return;
   1.245 +   
   1.246 +   oldArray         = *(info->addrOfPtrToArray);
   1.247 +   newArray         = malloc( newSize * sizeof(void *) );
   1.248 +
   1.249 +   for( i = 0; i < oldSizeOfArray; i++ )
   1.250 +    {
   1.251 +      newArray[i] = oldArray[i];
   1.252 +    }
   1.253 +   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
   1.254 +   info->sizeOfArray = newSize;
   1.255 +
   1.256 +   free( oldArray );
   1.257 + }
   1.258 +
   1.259 +
   1.260 +/* Frees the array, plus the info
   1.261 + */
   1.262 +void
   1.263 +freeDynArrayDeep( DynArrayInfo *info, FreeFnPtr freeFnPtr )
   1.264 + {
   1.265 +   forAllInDynArrayDo( info, freeFnPtr );
   1.266 +   free( *(info->addrOfPtrToArray) );
   1.267 +   free( info );
   1.268 + }
   1.269 +
   1.270 +/* Only frees the info
   1.271 + */
   1.272 +void
   1.273 +freeDynArrayFlat( DynArrayInfo *info )
   1.274 + {
   1.275 +   free( info );
   1.276 + }
   1.277 +
   1.278 +
   1.279 +/*The function has a fixed prototype: takes a void * returns void
   1.280 + * So, the function has to internally cast void * to whatever data struc..
   1.281 + */
   1.282 +void
   1.283 +forAllInDynArrayDo( DynArrayInfo *info, DynArrayFnPtr fnPtr )
   1.284 + { int32 idx;
   1.285 +   void **array;
   1.286 +
   1.287 +   array = *(info->addrOfPtrToArray);
   1.288 +   for( idx = 0; idx < info->numInArray; idx++ )
   1.289 +    {
   1.290 +      (*fnPtr)(array[idx]);
   1.291 +    }
   1.292 + }
   1.293 +