Mercurial > cgi-bin > hgwebdir.cgi > VMS > C_Libraries > DynArray

annotate DynArray.c @ 35:59eaf81a9cc7

find changesets by author, revision, files, or words in the commit message
updated headers (fixed circular includes) and PR_int__malloc into PR__malloc
author Sean Halle <seanhalle@yahoo.com>
date Tue, 23 Jul 2013 07:41:03 -0700
parents 958dcb7754ca
children 82b36ebdc648
rev   line source
Me@11 1 /*
Me@11 2 * Copyright 2010 OpenSourceCodeStewardshipFoundation
Me@11 3 *
Me@11 4 * Licensed under BSD
Me@11 5 */
Me@11 6
Me@11 7
Me@11 8
Me@11 9 #include <stdio.h>
seanhalle@32 10 #include <malloc.h>
Me@11 11
Me@11 12 #include "DynArray.h"
seanhalle@35 13 #include "PR__common_includes/Services_offered_by_PR/Memory_Handling/vmalloc__wrapper_library.h"
Me@11 14
Me@14 15 //== declarations
Me@14 16 void
Me@14 17 increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize );
Me@14 18 //==
Me@11 19
Me@14 20 PrivDynArrayInfo *
Me@14 21 makePrivDynArrayInfoFrom( void ***addrOfPtrToArray, int32 sizeOfArray )
Me@14 22 { PrivDynArrayInfo *info;
Me@11 23
seanhalle@35 24 info = PR__malloc( sizeof(PrivDynArrayInfo) );
Me@11 25
Me@11 26 info->addrOfPtrToArray = addrOfPtrToArray;
Me@11 27 info->sizeOfArray = sizeOfArray;
Me@11 28 info->numInArray = 0;
Me@14 29 return info;
Me@11 30 }
Me@11 31
Me@14 32 PrivDynArrayInfo *
Me@14 33 makePrivDynArrayOfSize( void ***addrOfPtrToArray, int32 sizeOfArray )
Me@14 34 { PrivDynArrayInfo *info;
Me@11 35
seanhalle@35 36 info = PR__malloc( sizeof(PrivDynArrayInfo) );
Me@11 37
Me@11 38 info->addrOfPtrToArray = addrOfPtrToArray;
Me@14 39
seanhalle@35 40 *(addrOfPtrToArray) = PR__malloc( sizeOfArray * sizeof(void *) );
Me@14 41 info->sizeOfArray = sizeOfArray;
Me@14 42 info->numInArray = 0;
Me@14 43 return info;
Me@14 44 }
Me@14 45
Me@14 46 PrivDynArrayInfo *
Me@14 47 makePrivDynArrayOfSize_Ext( void ***addrOfPtrToArray, int32 sizeOfArray )
Me@14 48 { PrivDynArrayInfo *info;
Me@14 49
seanhalle@32 50 info = (PrivDynArrayInfo*) malloc( sizeof(PrivDynArrayInfo) );
Me@14 51
Me@14 52 info->addrOfPtrToArray = addrOfPtrToArray;
Me@14 53
Me@11 54 *(addrOfPtrToArray) = malloc( sizeOfArray * sizeof(void *) );
Me@11 55 info->sizeOfArray = sizeOfArray;
Me@11 56 info->numInArray = 0;
Me@11 57 }
Me@11 58
Me@11 59
Me@11 60 /*A dynamic array is same as any other array, but add a DynArrayInfo next
Me@11 61 * to it. Accesses and updates of array indexes are done normally, it's
Me@11 62 * only when add a new element into array that use the extra info.
Me@11 63 * An add can cause the pointer to the normal array to change.. so must
Me@11 64 * be protected to single VP at a time.
Me@11 65 *
Me@11 66 *Only need to use this Fn when need a new index, higher than any previous
Me@11 67 */
Me@11 68 int32
Me@14 69 addToDynArray( void *value, PrivDynArrayInfo *info )
Me@11 70 { int32 numInArray, sizeOfArray;
Me@11 71 void **array;
Me@14 72
Me@11 73 numInArray = info->numInArray;
Me@11 74 sizeOfArray = info->sizeOfArray;
Me@11 75
Me@11 76 if( numInArray >= sizeOfArray )
Me@11 77 {
Me@11 78 increaseSizeOfDynArrayTo( info, sizeOfArray * 2 );
Me@11 79 }
Me@14 80
Me@14 81 array = *(info->addrOfPtrToArray);
Me@14 82 array[ numInArray ] = value;
Me@14 83 info->numInArray++;
Me@14 84
Me@14 85 return numInArray; //pre-incr value is the index put value into
Me@14 86 }
Me@14 87 int32
Me@14 88 addToDynArray_Ext( void *value, PrivDynArrayInfo *info )
Me@14 89 { int32 numInArray, sizeOfArray;
Me@14 90 void **array;
Me@14 91
Me@14 92 numInArray = info->numInArray;
Me@14 93 sizeOfArray = info->sizeOfArray;
Me@14 94
Me@14 95 if( numInArray >= sizeOfArray )
Me@14 96 {
Me@14 97 increaseSizeOfDynArrayTo_Ext( info, sizeOfArray * 2 );
Me@14 98 }
Me@14 99
Me@11 100 array = *(info->addrOfPtrToArray);
Me@11 101 array[ numInArray ] = value;
Me@11 102 info->numInArray++;
Me@11 103
Me@11 104 return numInArray; //pre-incr value is the index put value into
Me@11 105 }
Me@11 106
Me@11 107
Me@11 108 /*Use this when know how many things going to add in -- then can do this
Me@11 109 * once and use as normal array afterwards. If later add another chunk,
Me@11 110 * do this again. Note, this makes new size be just big enough to hold
Me@11 111 * highest index, so will do a linear number of copies if use only this.
Me@11 112 *To cut down on number of copies, can use the increaseSizeTo Fn to
Me@11 113 * exponentially increase size..
Me@11 114 */
Me@11 115 void
Me@14 116 makeHighestDynArrayIndexBe( PrivDynArrayInfo *info, int32 highestIndex )
Me@11 117 {
Me@11 118 if( info->sizeOfArray <= highestIndex )
Me@11 119 {
Me@11 120 increaseSizeOfDynArrayTo( info, highestIndex + 1 );
Me@11 121 }
Me@11 122 info->numInArray = highestIndex + 1;
Me@11 123 }
Me@11 124
Me@14 125 void
Me@14 126 makeHighestDynArrayIndexBeAtLeast(PrivDynArrayInfo *info, int32 index)
Me@14 127 {
Me@14 128 if( index < info->numInArray ) return;
Me@14 129 else makeHighestDynArrayIndexBe( info, index );
Me@14 130 }
Me@14 131
Me@11 132
Me@11 133 /*Only use this if certain new size is bigger than current size
Me@11 134 */
Me@11 135 void
Me@14 136 increaseSizeOfDynArrayTo( PrivDynArrayInfo *info, int32 newSize )
seanhalle@32 137 { int32 oldsizeOfArray, i;
Me@11 138 void **newArray, **oldArray;
Me@14 139
seanhalle@32 140 oldsizeOfArray = info->sizeOfArray;
seanhalle@32 141 if( newSize <= oldsizeOfArray ) return;
Me@14 142
Me@11 143 oldArray = *(info->addrOfPtrToArray);
seanhalle@35 144 newArray = PR__malloc( newSize * sizeof(void *) );
Me@11 145
seanhalle@32 146 for( i = 0; i < oldsizeOfArray; i++ )
Me@11 147 {
Me@11 148 newArray[i] = oldArray[i];
Me@11 149 }
Me@11 150 *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
Me@11 151 info->sizeOfArray = newSize;
Me@11 152
seanhalle@35 153 PR__free( oldArray );
Me@11 154 }
Me@11 155
seanhalle@35 156 /*Can't mix PR__malloc locations with external malloc locations -- so use
seanhalle@30 157 * this version inside PR, which will perform normal malloc in the core
Me@14 158 * loop -- hopefully avoiding the annoying system-stack bugs..
Me@14 159 */
Me@14 160 void
Me@14 161 increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize )
seanhalle@32 162 { int32 oldsizeOfArray, i;
Me@14 163 void **newArray, **oldArray;
Me@14 164
seanhalle@32 165 oldsizeOfArray = info->sizeOfArray;
seanhalle@32 166 if( newSize <= oldsizeOfArray ) return;
Me@14 167
Me@14 168 oldArray = *(info->addrOfPtrToArray);
Me@14 169 newArray = malloc( newSize * sizeof(void *) );
Me@14 170
seanhalle@32 171 for( i = 0; i < oldsizeOfArray; i++ )
Me@14 172 {
Me@14 173 newArray[i] = oldArray[i];
Me@14 174 }
Me@14 175 *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
Me@14 176 info->sizeOfArray = newSize;
Me@14 177
Me@14 178 free( oldArray );
Me@14 179 }
Me@14 180
Me@11 181
Me@11 182 /* Frees the array, plus the info
Me@11 183 */
Me@11 184 void
Me@14 185 freeDynArrayDeep( PrivDynArrayInfo *info, FreeFnPtr freeFnPtr )
Me@11 186 {
Me@11 187 forAllInDynArrayDo( info, freeFnPtr );
seanhalle@35 188 PR__free( *(info->addrOfPtrToArray) );
seanhalle@35 189 PR__free( info );
Me@11 190 }
Me@11 191
Me@11 192 /* Only frees the info
Me@11 193 */
Me@11 194 void
Me@14 195 freeDynArrayFlat( PrivDynArrayInfo *info )
Me@11 196 {
seanhalle@35 197 PR__free( info );
Me@11 198 }
Me@11 199
Me@11 200
Me@11 201 /*The function has a fixed prototype: takes a void * returns void
Me@11 202 * So, the function has to internally cast void * to whatever data struc..
Me@11 203 */
Me@11 204 void
Me@14 205 forAllInDynArrayDo( PrivDynArrayInfo *info, DynArrayFnPtr fnPtr )
Me@11 206 { int32 idx;
Me@11 207 void **array;
Me@11 208
Me@11 209 array = *(info->addrOfPtrToArray);
Me@11 210 for( idx = 0; idx < info->numInArray; idx++ )
Me@11 211 {
Me@11 212 (*fnPtr)(array[idx]);
Me@11 213 }
Me@11 214 }
Me@11 215