1.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
     1.2 +++ b/DynArray3.c	Fri Jul 19 12:27:43 2013 -0700
     1.3 @@ -0,0 +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 +
    1.16 +//== declarations
    1.17 +void
    1.18 +increaseSizeOfDynArrayTo_Ext( PtrToPrivDynArray *info, int32 newSize );
    1.19 +//==
    1.20 +
    1.21 +PtrToPrivDynArray *
    1.22 +makePrivDynArrayInfoFrom( void ***addrOfPtrToArray, int32 sizeOfArray )
    1.23 + { PtrToPrivDynArray *info;
    1.24 +
    1.25 +   info = PR_int__malloc( sizeof(PtrToPrivDynArray) );
    1.26 +
    1.27 +   info->addrOfPtrToArray = addrOfPtrToArray;
    1.28 +   info->sizeOfArray      = sizeOfArray;
    1.29 +   info->numInArray       = 0;
    1.30 +   return info;
    1.31 + }
    1.32 +
    1.33 +PtrToPrivDynArray *
    1.34 +makePrivDynArrayOfSize( void ***addrOfPtrToArray, int32 sizeOfArray )
    1.35 + { PtrToPrivDynArray *info;
    1.36 +
    1.37 +   info = PR_int__malloc( sizeof(PtrToPrivDynArray) );
    1.38 +
    1.39 +   info->addrOfPtrToArray = addrOfPtrToArray;
    1.40 +
    1.41 +   *(addrOfPtrToArray)    = PR_int__malloc( sizeOfArray * sizeof(void *) );
    1.42 +   info->sizeOfArray      = sizeOfArray;
    1.43 +   info->numInArray       = 0;
    1.44 +   return info;
    1.45 + }
    1.46 +
    1.47 +PtrToPrivDynArray *
    1.48 +makePrivDynArrayOfSize_Ext( void ***addrOfPtrToArray, int32 sizeOfArray )
    1.49 + { PtrToPrivDynArray *info;
    1.50 +
    1.51 +   info = malloc( sizeof(PtrToPrivDynArray) );
    1.52 +
    1.53 +   info->addrOfPtrToArray = addrOfPtrToArray;
    1.54 +
    1.55 +   *(addrOfPtrToArray)    = malloc( sizeOfArray * sizeof(void *) );
    1.56 +   info->sizeOfArray      = sizeOfArray;
    1.57 +   info->numInArray       = 0;
    1.58 + }
    1.59 +
    1.60 +
    1.61 +/*A dynamic array is same as any other array, but add a DynArrayInfo next
    1.62 + * to it.  Accesses and updates of array indexes are done normally, it's
    1.63 + * only when add a new element into array that use the extra info.
    1.64 + * An add can cause the pointer to the normal array to change..  so must
    1.65 + * be protected to single VP at a time.
    1.66 + *
    1.67 + *Only need to use this Fn when need a new index, higher than any previous
    1.68 + */
    1.69 +int32
    1.70 +addToDynArray( void *value, PtrToPrivDynArray *info )
    1.71 + { int32 numInArray, sizeOfArray;
    1.72 +   void **array;
    1.73 +
    1.74 +   numInArray = info->numInArray;
    1.75 +   sizeOfArray    = info->sizeOfArray;
    1.76 +
    1.77 +   if( numInArray >= sizeOfArray )
    1.78 +    {
    1.79 +      increaseSizeOfDynArrayTo( info, sizeOfArray * 2 );
    1.80 +    }
    1.81 +
    1.82 +   array = *(info->addrOfPtrToArray);
    1.83 +   array[ numInArray ] = value;
    1.84 +   info->numInArray++;
    1.85 +
    1.86 +   return numInArray; //pre-incr value is the index put value into
    1.87 + }
    1.88 +int32
    1.89 +addToDynArray_Ext( void *value, PtrToPrivDynArray *ptrToArray )
    1.90 + { int32 numInArray, sizeOfArray;
    1.91 +   void **array;
    1.92 +
    1.93 +   numInArray = ptrToArray->numInArray;
    1.94 +   sizeOfArray    = ptrToArray->sizeOfArray;
    1.95 +
    1.96 +   if( numInArray >= sizeOfArray )
    1.97 +    {
    1.98 +      increaseSizeOfDynArrayTo_Ext( ptrToArray, sizeOfArray * 2 );
    1.99 +    }
   1.100 +
   1.101 +   array = *(ptrToArray->addrOfPtrToArray);
   1.102 +   array[ numInArray ] = value;
   1.103 +   ptrToArray->numInArray++;
   1.104 +
   1.105 +   return numInArray; //pre-incr value is the index put value into
   1.106 + }
   1.107 +
   1.108 +
   1.109 +/*Use this when know how many things going to add in -- then can do this
   1.110 + * once and use as normal array afterwards.  If later add another chunk,
   1.111 + * do this again.  Note, this makes new size be just big enough to hold
   1.112 + * highest index, so will do a linear number of copies if use only this.
   1.113 + *To cut down on number of copies, can use the increaseSizeTo Fn to
   1.114 + * exponentially increase size..
   1.115 + */
   1.116 +void
   1.117 +makeHighestDynArrayIndexBe( PtrToPrivDynArray *info, int32 highestIndex )
   1.118 + {
   1.119 +   if( info->sizeOfArray <= highestIndex )
   1.120 +    {
   1.121 +      increaseSizeOfDynArrayTo( info, highestIndex + 1 );
   1.122 +    }
   1.123 +   info->numInArray = highestIndex + 1;
   1.124 + }
   1.125 +
   1.126 +void
   1.127 +makeHighestDynArrayIndexBeAtLeast(PtrToPrivDynArray *info, int32 index)
   1.128 + {
   1.129 +   if( index < info->numInArray ) return;
   1.130 +   else makeHighestDynArrayIndexBe( info, index );
   1.131 + }
   1.132 +
   1.133 +
   1.134 +/*Only use this if certain new size is bigger than current size
   1.135 + */
   1.136 +void
   1.137 +increaseSizeOfDynArrayTo( PtrToPrivDynArray *info, int32 newSize )
   1.138 + { int32 oldSizeOfArray, i;
   1.139 +   void **newArray, **oldArray;
   1.140 +
   1.141 +   oldSizeOfArray   = info->sizeOfArray;
   1.142 +   if( newSize <= oldSizeOfArray ) return;
   1.143 +
   1.144 +   oldArray         = *(info->addrOfPtrToArray);
   1.145 +   newArray         = PR_int__malloc( newSize * sizeof(void *) );
   1.146 +
   1.147 +   for( i = 0; i < oldSizeOfArray; i++ )
   1.148 +    {
   1.149 +      newArray[i] = oldArray[i];
   1.150 +    }
   1.151 +   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
   1.152 +   info->sizeOfArray = newSize;
   1.153 +
   1.154 +   PR_int__free( oldArray );
   1.155 + }
   1.156 +
   1.157 +/*Can't mix PR_int__malloc locations with external malloc locations -- so use
   1.158 + * this version inside PR, which will perform normal malloc in the core
   1.159 + * loop -- hopefully avoiding the annoying system-stack bugs..
   1.160 + */
   1.161 +void
   1.162 +increaseSizeOfDynArrayTo_Ext( PtrToPrivDynArray *info, int32 newSize )
   1.163 + { int32 oldSizeOfArray, i;
   1.164 +   void **newArray, **oldArray;
   1.165 +
   1.166 +   oldSizeOfArray   = info->sizeOfArray;
   1.167 +   if( newSize <= oldSizeOfArray ) return;
   1.168 +
   1.169 +   oldArray         = *(info->addrOfPtrToArray);
   1.170 +   newArray         = malloc( newSize * sizeof(void *) );
   1.171 +
   1.172 +   for( i = 0; i < oldSizeOfArray; i++ )
   1.173 +    {
   1.174 +      newArray[i] = oldArray[i];
   1.175 +    }
   1.176 +   *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
   1.177 +   info->sizeOfArray = newSize;
   1.178 +
   1.179 +   free( oldArray );
   1.180 + }
   1.181 +
   1.182 +
   1.183 +/* Frees the array, plus the info
   1.184 + */
   1.185 +void
   1.186 +freeDynArrayDeep( PtrToPrivDynArray *info, FreeFnPtr freeFnPtr )
   1.187 + {
   1.188 +   forAllInDynArrayDo( info, freeFnPtr );
   1.189 +   PR_int__free( *(info->addrOfPtrToArray) );
   1.190 +   PR_int__free( info );
   1.191 + }
   1.192 +
   1.193 +/* Only frees the info
   1.194 + */
   1.195 +void
   1.196 +freeDynArrayFlat( PtrToPrivDynArray *info )
   1.197 + {
   1.198 +   PR_int__free( info );
   1.199 + }
   1.200 +
   1.201 +
   1.202 +/*The function has a fixed prototype: takes a void * returns void
   1.203 + * So, the function has to internally cast void * to whatever data struc..
   1.204 + */
   1.205 +void
   1.206 +forAllInDynArrayDo( PtrToPrivDynArray *info, DynArrayFnPtr fnPtr )
   1.207 + { int32 idx;
   1.208 +   void **array;
   1.209 +
   1.210 +   array = *(info->addrOfPtrToArray);
   1.211 +   for( idx = 0; idx < info->numInArray; idx++ )
   1.212 +    {
   1.213 +      (*fnPtr)(array[idx]);
   1.214 +    }
   1.215 + }
   1.216 +