1.1 --- a/DynArray.c	Thu Feb 09 15:47:41 2012 +0100
     1.2 +++ b/DynArray.c	Sat Feb 11 17:46:39 2012 -0800
     1.3 @@ -1,214 +1,213 @@
     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 -
    1.14 -#include "DynArray.h"
    1.15 -#include "../vmalloc.h"
    1.16 -
    1.17 -//== declarations
    1.18 -void
    1.19 -increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize );
    1.20 -//==
    1.21 -
    1.22 -PrivDynArrayInfo *
    1.23 -makePrivDynArrayInfoFrom( void ***addrOfPtrToArray, int32 sizeOfArray )
    1.24 - { PrivDynArrayInfo *info;
    1.25 -
    1.26 -   info = VMS__malloc( sizeof(PrivDynArrayInfo) );
    1.27 -
    1.28 -   info->addrOfPtrToArray = addrOfPtrToArray;
    1.29 -   info->sizeOfArray      = sizeOfArray;
    1.30 -   info->numInArray       = 0;
    1.31 -   return info;
    1.32 - }
    1.33 -
    1.34 -PrivDynArrayInfo *
    1.35 -makePrivDynArrayOfSize( void ***addrOfPtrToArray, int32 sizeOfArray )
    1.36 - { PrivDynArrayInfo *info;
    1.37 -
    1.38 -   info = VMS__malloc( sizeof(PrivDynArrayInfo) );
    1.39 -
    1.40 -   info->addrOfPtrToArray = addrOfPtrToArray;
    1.41 -
    1.42 -   *(addrOfPtrToArray)    = VMS__malloc( sizeOfArray * sizeof(void *) );
    1.43 -   info->sizeOfArray      = sizeOfArray;
    1.44 -   info->numInArray       = 0;
    1.45 -   return info;
    1.46 - }
    1.47 -
    1.48 -PrivDynArrayInfo *
    1.49 -makePrivDynArrayOfSize_Ext( void ***addrOfPtrToArray, int32 sizeOfArray )
    1.50 - { PrivDynArrayInfo *info;
    1.51 -
    1.52 -   info = malloc( sizeof(PrivDynArrayInfo) );
    1.53 -
    1.54 -   info->addrOfPtrToArray = addrOfPtrToArray;
    1.55 -
    1.56 -   *(addrOfPtrToArray)    = malloc( sizeOfArray * sizeof(void *) );
    1.57 -   info->sizeOfArray      = sizeOfArray;
    1.58 -   info->numInArray       = 0;
    1.59 - }
    1.60 -
    1.61 -
    1.62 -/*A dynamic array is same as any other array, but add a DynArrayInfo next
    1.63 - * to it.  Accesses and updates of array indexes are done normally, it's
    1.64 - * only when add a new element into array that use the extra info.
    1.65 - * An add can cause the pointer to the normal array to change..  so must
    1.66 - * be protected to single VP at a time.
    1.67 - *
    1.68 - *Only need to use this Fn when need a new index, higher than any previous
    1.69 - */
    1.70 -int32
    1.71 -addToDynArray( void *value, PrivDynArrayInfo *info )
    1.72 - { int32 numInArray, sizeOfArray;
    1.73 -   void **array;
    1.74 -
    1.75 -   numInArray = info->numInArray;
    1.76 -   sizeOfArray    = info->sizeOfArray;
    1.77 -
    1.78 -   if( numInArray >= sizeOfArray )
    1.79 -    {
    1.80 -      increaseSizeOfDynArrayTo( info, sizeOfArray * 2 );
    1.81 -    }
    1.82 -
    1.83 -   array = *(info->addrOfPtrToArray);
    1.84 -   array[ numInArray ] = value;
    1.85 -   info->numInArray++;
    1.86 -
    1.87 -   return numInArray; //pre-incr value is the index put value into
    1.88 - }
    1.89 -int32
    1.90 -addToDynArray_Ext( void *value, PrivDynArrayInfo *info )
    1.91 - { int32 numInArray, sizeOfArray;
    1.92 -   void **array;
    1.93 -
    1.94 -   numInArray = info->numInArray;
    1.95 -   sizeOfArray    = info->sizeOfArray;
    1.96 -
    1.97 -   if( numInArray >= sizeOfArray )
    1.98 -    {
    1.99 -      increaseSizeOfDynArrayTo_Ext( info, sizeOfArray * 2 );
   1.100 -    }
   1.101 -
   1.102 -   array = *(info->addrOfPtrToArray);
   1.103 -   array[ numInArray ] = value;
   1.104 -   info->numInArray++;
   1.105 -
   1.106 -   return numInArray; //pre-incr value is the index put value into
   1.107 - }
   1.108 -
   1.109 -
   1.110 -/*Use this when know how many things going to add in -- then can do this
   1.111 - * once and use as normal array afterwards.  If later add another chunk,
   1.112 - * do this again.  Note, this makes new size be just big enough to hold
   1.113 - * highest index, so will do a linear number of copies if use only this.
   1.114 - *To cut down on number of copies, can use the increaseSizeTo Fn to
   1.115 - * exponentially increase size..
   1.116 - */
   1.117 -void
   1.118 -makeHighestDynArrayIndexBe( PrivDynArrayInfo *info, int32 highestIndex )
   1.119 - {
   1.120 -   if( info->sizeOfArray <= highestIndex )
   1.121 -    {
   1.122 -      increaseSizeOfDynArrayTo( info, highestIndex + 1 );
   1.123 -    }
   1.124 -   info->numInArray = highestIndex + 1;
   1.125 - }
   1.126 -
   1.127 -void
   1.128 -makeHighestDynArrayIndexBeAtLeast(PrivDynArrayInfo *info, int32 index)
   1.129 - {
   1.130 -   if( index < info->numInArray ) return;
   1.131 -   else makeHighestDynArrayIndexBe( info, index );
   1.132 - }
   1.133 -
   1.134 -
   1.135 -/*Only use this if certain new size is bigger than current size
   1.136 - */
   1.137 -void
   1.138 -increaseSizeOfDynArrayTo( PrivDynArrayInfo *info, int32 newSize )
   1.139 - { int32 oldSizeOfArray, i;
   1.140 -   void **newArray, **oldArray;
   1.141 -
   1.142 -   oldSizeOfArray   = info->sizeOfArray;
   1.143 -   if( newSize <= oldSizeOfArray ) return;
   1.144 -
   1.145 -   oldArray         = *(info->addrOfPtrToArray);
   1.146 -   newArray         = VMS__malloc( newSize * sizeof(void *) );
   1.147 -
   1.148 -   for( i = 0; i < oldSizeOfArray; i++ )
   1.149 -    {
   1.150 -      newArray[i] = oldArray[i];
   1.151 -    }
   1.152 -   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
   1.153 -   info->sizeOfArray = newSize;
   1.154 -
   1.155 -   VMS__free( oldArray );
   1.156 - }
   1.157 -
   1.158 -/*Can't mix VMS__malloc locations with external malloc locations -- so use
   1.159 - * this version inside VMS, which will perform normal malloc in the core
   1.160 - * loop -- hopefully avoiding the annoying system-stack bugs..
   1.161 - */
   1.162 -void
   1.163 -increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize )
   1.164 - { int32 oldSizeOfArray, i;
   1.165 -   void **newArray, **oldArray;
   1.166 -
   1.167 -   oldSizeOfArray   = info->sizeOfArray;
   1.168 -   if( newSize <= oldSizeOfArray ) return;
   1.169 -
   1.170 -   oldArray         = *(info->addrOfPtrToArray);
   1.171 -   newArray         = malloc( newSize * sizeof(void *) );
   1.172 -
   1.173 -   for( i = 0; i < oldSizeOfArray; i++ )
   1.174 -    {
   1.175 -      newArray[i] = oldArray[i];
   1.176 -    }
   1.177 -   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
   1.178 -   info->sizeOfArray = newSize;
   1.179 -
   1.180 -   free( oldArray );
   1.181 - }
   1.182 -
   1.183 -
   1.184 -/* Frees the array, plus the info
   1.185 - */
   1.186 -void
   1.187 -freeDynArrayDeep( PrivDynArrayInfo *info, FreeFnPtr freeFnPtr )
   1.188 - {
   1.189 -   forAllInDynArrayDo( info, freeFnPtr );
   1.190 -   VMS__free( *(info->addrOfPtrToArray) );
   1.191 -   VMS__free( info );
   1.192 - }
   1.193 -
   1.194 -/* Only frees the info
   1.195 - */
   1.196 -void
   1.197 -freeDynArrayFlat( PrivDynArrayInfo *info )
   1.198 - {
   1.199 -   VMS__free( info );
   1.200 - }
   1.201 -
   1.202 -
   1.203 -/*The function has a fixed prototype: takes a void * returns void
   1.204 - * So, the function has to internally cast void * to whatever data struc..
   1.205 - */
   1.206 -void
   1.207 -forAllInDynArrayDo( PrivDynArrayInfo *info, DynArrayFnPtr fnPtr )
   1.208 - { int32 idx;
   1.209 -   void **array;
   1.210 -
   1.211 -   array = *(info->addrOfPtrToArray);
   1.212 -   for( idx = 0; idx < info->numInArray; idx++ )
   1.213 -    {
   1.214 -      (*fnPtr)(array[idx]);
   1.215 -    }
   1.216 - }
   1.217 -
   1.218 +/*
   1.219 + * Copyright 2010  OpenSourceCodeStewardshipFoundation
   1.220 + *
   1.221 + * Licensed under BSD
   1.222 + */
   1.223 +
   1.224 +
   1.225 +
   1.226 +#include <stdio.h>
   1.227 +
   1.228 +#include "DynArray.h"
   1.229 +
   1.230 +//== declarations
   1.231 +void
   1.232 +increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize );
   1.233 +//==
   1.234 +
   1.235 +PrivDynArrayInfo *
   1.236 +makePrivDynArrayInfoFrom( void ***addrOfPtrToArray, int32 sizeOfArray )
   1.237 + { PrivDynArrayInfo *info;
   1.238 +
   1.239 +   info = VMS__malloc( sizeof(PrivDynArrayInfo) );
   1.240 +
   1.241 +   info->addrOfPtrToArray = addrOfPtrToArray;
   1.242 +   info->sizeOfArray      = sizeOfArray;
   1.243 +   info->numInArray       = 0;
   1.244 +   return info;
   1.245 + }
   1.246 +
   1.247 +PrivDynArrayInfo *
   1.248 +makePrivDynArrayOfSize( void ***addrOfPtrToArray, int32 sizeOfArray )
   1.249 + { PrivDynArrayInfo *info;
   1.250 +
   1.251 +   info = VMS__malloc( sizeof(PrivDynArrayInfo) );
   1.252 +
   1.253 +   info->addrOfPtrToArray = addrOfPtrToArray;
   1.254 +
   1.255 +   *(addrOfPtrToArray)    = VMS__malloc( sizeOfArray * sizeof(void *) );
   1.256 +   info->sizeOfArray      = sizeOfArray;
   1.257 +   info->numInArray       = 0;
   1.258 +   return info;
   1.259 + }
   1.260 +
   1.261 +PrivDynArrayInfo *
   1.262 +makePrivDynArrayOfSize_Ext( void ***addrOfPtrToArray, int32 sizeOfArray )
   1.263 + { PrivDynArrayInfo *info;
   1.264 +
   1.265 +   info = malloc( sizeof(PrivDynArrayInfo) );
   1.266 +
   1.267 +   info->addrOfPtrToArray = addrOfPtrToArray;
   1.268 +
   1.269 +   *(addrOfPtrToArray)    = malloc( sizeOfArray * sizeof(void *) );
   1.270 +   info->sizeOfArray      = sizeOfArray;
   1.271 +   info->numInArray       = 0;
   1.272 + }
   1.273 +
   1.274 +
   1.275 +/*A dynamic array is same as any other array, but add a DynArrayInfo next
   1.276 + * to it.  Accesses and updates of array indexes are done normally, it's
   1.277 + * only when add a new element into array that use the extra info.
   1.278 + * An add can cause the pointer to the normal array to change..  so must
   1.279 + * be protected to single VP at a time.
   1.280 + *
   1.281 + *Only need to use this Fn when need a new index, higher than any previous
   1.282 + */
   1.283 +int32
   1.284 +addToDynArray( void *value, PrivDynArrayInfo *info )
   1.285 + { int32 numInArray, sizeOfArray;
   1.286 +   void **array;
   1.287 +
   1.288 +   numInArray = info->numInArray;
   1.289 +   sizeOfArray    = info->sizeOfArray;
   1.290 +
   1.291 +   if( numInArray >= sizeOfArray )
   1.292 +    {
   1.293 +      increaseSizeOfDynArrayTo( info, sizeOfArray * 2 );
   1.294 +    }
   1.295 +
   1.296 +   array = *(info->addrOfPtrToArray);
   1.297 +   array[ numInArray ] = value;
   1.298 +   info->numInArray++;
   1.299 +
   1.300 +   return numInArray; //pre-incr value is the index put value into
   1.301 + }
   1.302 +int32
   1.303 +addToDynArray_Ext( void *value, PrivDynArrayInfo *info )
   1.304 + { int32 numInArray, sizeOfArray;
   1.305 +   void **array;
   1.306 +
   1.307 +   numInArray = info->numInArray;
   1.308 +   sizeOfArray    = info->sizeOfArray;
   1.309 +
   1.310 +   if( numInArray >= sizeOfArray )
   1.311 +    {
   1.312 +      increaseSizeOfDynArrayTo_Ext( info, sizeOfArray * 2 );
   1.313 +    }
   1.314 +
   1.315 +   array = *(info->addrOfPtrToArray);
   1.316 +   array[ numInArray ] = value;
   1.317 +   info->numInArray++;
   1.318 +
   1.319 +   return numInArray; //pre-incr value is the index put value into
   1.320 + }
   1.321 +
   1.322 +
   1.323 +/*Use this when know how many things going to add in -- then can do this
   1.324 + * once and use as normal array afterwards.  If later add another chunk,
   1.325 + * do this again.  Note, this makes new size be just big enough to hold
   1.326 + * highest index, so will do a linear number of copies if use only this.
   1.327 + *To cut down on number of copies, can use the increaseSizeTo Fn to
   1.328 + * exponentially increase size..
   1.329 + */
   1.330 +void
   1.331 +makeHighestDynArrayIndexBe( PrivDynArrayInfo *info, int32 highestIndex )
   1.332 + {
   1.333 +   if( info->sizeOfArray <= highestIndex )
   1.334 +    {
   1.335 +      increaseSizeOfDynArrayTo( info, highestIndex + 1 );
   1.336 +    }
   1.337 +   info->numInArray = highestIndex + 1;
   1.338 + }
   1.339 +
   1.340 +void
   1.341 +makeHighestDynArrayIndexBeAtLeast(PrivDynArrayInfo *info, int32 index)
   1.342 + {
   1.343 +   if( index < info->numInArray ) return;
   1.344 +   else makeHighestDynArrayIndexBe( info, index );
   1.345 + }
   1.346 +
   1.347 +
   1.348 +/*Only use this if certain new size is bigger than current size
   1.349 + */
   1.350 +void
   1.351 +increaseSizeOfDynArrayTo( PrivDynArrayInfo *info, int32 newSize )
   1.352 + { int32 oldSizeOfArray, i;
   1.353 +   void **newArray, **oldArray;
   1.354 +
   1.355 +   oldSizeOfArray   = info->sizeOfArray;
   1.356 +   if( newSize <= oldSizeOfArray ) return;
   1.357 +
   1.358 +   oldArray         = *(info->addrOfPtrToArray);
   1.359 +   newArray         = VMS__malloc( newSize * sizeof(void *) );
   1.360 +
   1.361 +   for( i = 0; i < oldSizeOfArray; i++ )
   1.362 +    {
   1.363 +      newArray[i] = oldArray[i];
   1.364 +    }
   1.365 +   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
   1.366 +   info->sizeOfArray = newSize;
   1.367 +
   1.368 +   VMS__free( oldArray );
   1.369 + }
   1.370 +
   1.371 +/*Can't mix VMS__malloc locations with external malloc locations -- so use
   1.372 + * this version inside VMS, which will perform normal malloc in the core
   1.373 + * loop -- hopefully avoiding the annoying system-stack bugs..
   1.374 + */
   1.375 +void
   1.376 +increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize )
   1.377 + { int32 oldSizeOfArray, i;
   1.378 +   void **newArray, **oldArray;
   1.379 +
   1.380 +   oldSizeOfArray   = info->sizeOfArray;
   1.381 +   if( newSize <= oldSizeOfArray ) return;
   1.382 +
   1.383 +   oldArray         = *(info->addrOfPtrToArray);
   1.384 +   newArray         = malloc( newSize * sizeof(void *) );
   1.385 +
   1.386 +   for( i = 0; i < oldSizeOfArray; i++ )
   1.387 +    {
   1.388 +      newArray[i] = oldArray[i];
   1.389 +    }
   1.390 +   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
   1.391 +   info->sizeOfArray = newSize;
   1.392 +
   1.393 +   free( oldArray );
   1.394 + }
   1.395 +
   1.396 +
   1.397 +/* Frees the array, plus the info
   1.398 + */
   1.399 +void
   1.400 +freeDynArrayDeep( PrivDynArrayInfo *info, FreeFnPtr freeFnPtr )
   1.401 + {
   1.402 +   forAllInDynArrayDo( info, freeFnPtr );
   1.403 +   VMS__free( *(info->addrOfPtrToArray) );
   1.404 +   VMS__free( info );
   1.405 + }
   1.406 +
   1.407 +/* Only frees the info
   1.408 + */
   1.409 +void
   1.410 +freeDynArrayFlat( PrivDynArrayInfo *info )
   1.411 + {
   1.412 +   VMS__free( info );
   1.413 + }
   1.414 +
   1.415 +
   1.416 +/*The function has a fixed prototype: takes a void * returns void
   1.417 + * So, the function has to internally cast void * to whatever data struc..
   1.418 + */
   1.419 +void
   1.420 +forAllInDynArrayDo( PrivDynArrayInfo *info, DynArrayFnPtr fnPtr )
   1.421 + { int32 idx;
   1.422 +   void **array;
   1.423 +
   1.424 +   array = *(info->addrOfPtrToArray);
   1.425 +   for( idx = 0; idx < info->numInArray; idx++ )
   1.426 +    {
   1.427 +      (*fnPtr)(array[idx]);
   1.428 +    }
   1.429 + }
   1.430 +