1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/DynArray.c	Mon Feb 13 10:29:40 2012 -0800
     1.3 @@ -0,0 +1,214 @@
     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 = 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 = malloc( sizeof(PrivDynArrayInfo) );
    1.39 +
    1.40 +   info->addrOfPtrToArray = addrOfPtrToArray;
    1.41 +
    1.42 +   *(addrOfPtrToArray)    = 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         = 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 +   free( oldArray );
   1.156 + }
   1.157 +
   1.158 +/*Can't mix 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 +   free( *(info->addrOfPtrToArray) );
   1.191 +   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 +   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 +