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

annotate DynArray.c @ 8:015aab562ace

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