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

annotate DynArray.c @ 10:20f0996a8400

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