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

comparison DynArray.c @ 14:9de0a9369134

find changesets by author, revision, files, or words in the commit message
added eol handling and .brch__default to indicate brch (and reason for it)
author Me@portablequad
date Sat, 11 Feb 2012 17:43:20 -0800
parents 601709e9f2a4
children 62b3a4793b6e
comparison
equal deleted inserted replaced
9:ec81049b58b1 10:23429072f207
5 */ 5 */
6 6
7 7
8 8
9 #include <stdio.h> 9 #include <stdio.h>
10 #include <malloc.h>
11 10
12 #include "DynArray.h" 11 #include "DynArray.h"
13 12 #include "../vmalloc.h"
14 13
15 14 //== declarations
16 DynArrayInfo * 15 void
17 makeDynArrayInfoFrom( void ***addrOfPtrToArray, int32 sizeOfArray ) 16 increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize );
18 { DynArrayInfo *info; 17 //==
19 18
20 info = malloc( sizeof(DynArrayInfo) ); 19 PrivDynArrayInfo *
20 makePrivDynArrayInfoFrom( void ***addrOfPtrToArray, int32 sizeOfArray )
21 { PrivDynArrayInfo *info;
22
23 info = malloc( sizeof(PrivDynArrayInfo) );
21 24
22 info->addrOfPtrToArray = addrOfPtrToArray; 25 info->addrOfPtrToArray = addrOfPtrToArray;
23 info->sizeOfArray = sizeOfArray; 26 info->sizeOfArray = sizeOfArray;
24 info->numInArray = 0; 27 info->numInArray = 0;
25 } 28 return info;
26 29 }
27 DynArrayInfo * 30
28 makeDynArrayOfSize( void ***addrOfPtrToArray, int32 sizeOfArray ) 31 PrivDynArrayInfo *
29 { DynArrayInfo *info; 32 makePrivDynArrayOfSize( void ***addrOfPtrToArray, int32 sizeOfArray )
30 33 { PrivDynArrayInfo *info;
31 info = malloc( sizeof(DynArrayInfo) ); 34
35 info = malloc( sizeof(PrivDynArrayInfo) );
32 36
33 info->addrOfPtrToArray = addrOfPtrToArray; 37 info->addrOfPtrToArray = addrOfPtrToArray;
34 38
39 *(addrOfPtrToArray) = malloc( sizeOfArray * sizeof(void *) );
40 info->sizeOfArray = sizeOfArray;
41 info->numInArray = 0;
42 return info;
43 }
44
45 PrivDynArrayInfo *
46 makePrivDynArrayOfSize_Ext( void ***addrOfPtrToArray, int32 sizeOfArray )
47 { PrivDynArrayInfo *info;
48
49 info = malloc( sizeof(PrivDynArrayInfo) );
50
51 info->addrOfPtrToArray = addrOfPtrToArray;
52
35 *(addrOfPtrToArray) = malloc( sizeOfArray * sizeof(void *) ); 53 *(addrOfPtrToArray) = malloc( sizeOfArray * sizeof(void *) );
36 info->sizeOfArray = sizeOfArray; 54 info->sizeOfArray = sizeOfArray;
37 info->numInArray = 0; 55 info->numInArray = 0;
38 } 56 }
39 57
45 * be protected to single VP at a time. 63 * be protected to single VP at a time.
46 * 64 *
47 *Only need to use this Fn when need a new index, higher than any previous 65 *Only need to use this Fn when need a new index, higher than any previous
48 */ 66 */
49 int32 67 int32
50 addToDynArray( void *value, DynArrayInfo *info ) 68 addToDynArray( void *value, PrivDynArrayInfo *info )
51 { int32 numInArray, sizeOfArray; 69 { int32 numInArray, sizeOfArray;
52 void **array; 70 void **array;
53 71
54 numInArray = info->numInArray; 72 numInArray = info->numInArray;
55 sizeOfArray = info->sizeOfArray; 73 sizeOfArray = info->sizeOfArray;
56 74
57 if( numInArray >= sizeOfArray ) 75 if( numInArray >= sizeOfArray )
58 { 76 {
59 increaseSizeOfDynArrayTo( info, sizeOfArray * 2 ); 77 increaseSizeOfDynArrayTo( info, sizeOfArray * 2 );
60 } 78 }
61 79
80 array = *(info->addrOfPtrToArray);
81 array[ numInArray ] = value;
82 info->numInArray++;
83
84 return numInArray; //pre-incr value is the index put value into
85 }
86 int32
87 addToDynArray_Ext( void *value, PrivDynArrayInfo *info )
88 { int32 numInArray, sizeOfArray;
89 void **array;
90
91 numInArray = info->numInArray;
92 sizeOfArray = info->sizeOfArray;
93
94 if( numInArray >= sizeOfArray )
95 {
96 increaseSizeOfDynArrayTo_Ext( info, sizeOfArray * 2 );
97 }
98
62 array = *(info->addrOfPtrToArray); 99 array = *(info->addrOfPtrToArray);
63 array[ numInArray ] = value; 100 array[ numInArray ] = value;
64 info->numInArray++; 101 info->numInArray++;
65 102
66 return numInArray; //pre-incr value is the index put value into 103 return numInArray; //pre-incr value is the index put value into
73 * highest index, so will do a linear number of copies if use only this. 110 * highest index, so will do a linear number of copies if use only this.
74 *To cut down on number of copies, can use the increaseSizeTo Fn to 111 *To cut down on number of copies, can use the increaseSizeTo Fn to
75 * exponentially increase size.. 112 * exponentially increase size..
76 */ 113 */
77 void 114 void
78 makeHighestDynArrayIndexBe( DynArrayInfo *info, int32 highestIndex ) 115 makeHighestDynArrayIndexBe( PrivDynArrayInfo *info, int32 highestIndex )
79 { 116 {
80 if( info->sizeOfArray <= highestIndex ) 117 if( info->sizeOfArray <= highestIndex )
81 { 118 {
82 increaseSizeOfDynArrayTo( info, highestIndex + 1 ); 119 increaseSizeOfDynArrayTo( info, highestIndex + 1 );
83 } 120 }
84 info->numInArray = highestIndex + 1; 121 info->numInArray = highestIndex + 1;
85 } 122 }
86 123
124 void
125 makeHighestDynArrayIndexBeAtLeast(PrivDynArrayInfo *info, int32 index)
126 {
127 if( index < info->numInArray ) return;
128 else makeHighestDynArrayIndexBe( info, index );
129 }
130
87 131
88 /*Only use this if certain new size is bigger than current size 132 /*Only use this if certain new size is bigger than current size
89 */ 133 */
90 void 134 void
91 increaseSizeOfDynArrayTo( DynArrayInfo *info, int32 newSize ) 135 increaseSizeOfDynArrayTo( PrivDynArrayInfo *info, int32 newSize )
92 { int32 oldSizeOfArray, i; 136 { int32 oldSizeOfArray, i;
93 void **newArray, **oldArray; 137 void **newArray, **oldArray;
94 138
95 oldSizeOfArray = info->sizeOfArray; 139 oldSizeOfArray = info->sizeOfArray;
96 if( newSize <= oldSizeOfArray ) return; 140 if( newSize <= oldSizeOfArray ) return;
97 141
98 oldArray = *(info->addrOfPtrToArray); 142 oldArray = *(info->addrOfPtrToArray);
99 newArray = malloc( newSize * sizeof(void *) ); 143 newArray = malloc( newSize * sizeof(void *) );
100 144
101 for( i = 0; i < oldSizeOfArray; i++ ) 145 for( i = 0; i < oldSizeOfArray; i++ )
102 { 146 {
106 info->sizeOfArray = newSize; 150 info->sizeOfArray = newSize;
107 151
108 free( oldArray ); 152 free( oldArray );
109 } 153 }
110 154
155 /*Can't mix malloc locations with external malloc locations -- so use
156 * this version inside VMS, which will perform normal malloc in the core
157 * loop -- hopefully avoiding the annoying system-stack bugs..
158 */
159 void
160 increaseSizeOfDynArrayTo_Ext( PrivDynArrayInfo *info, int32 newSize )
161 { int32 oldSizeOfArray, i;
162 void **newArray, **oldArray;
163
164 oldSizeOfArray = info->sizeOfArray;
165 if( newSize <= oldSizeOfArray ) return;
166
167 oldArray = *(info->addrOfPtrToArray);
168 newArray = malloc( newSize * sizeof(void *) );
169
170 for( i = 0; i < oldSizeOfArray; i++ )
171 {
172 newArray[i] = oldArray[i];
173 }
174 *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
175 info->sizeOfArray = newSize;
176
177 free( oldArray );
178 }
179
111 180
112 /* Frees the array, plus the info 181 /* Frees the array, plus the info
113 */ 182 */
114 void 183 void
115 freeDynArrayDeep( DynArrayInfo *info, FreeFnPtr freeFnPtr ) 184 freeDynArrayDeep( PrivDynArrayInfo *info, FreeFnPtr freeFnPtr )
116 { 185 {
117 forAllInDynArrayDo( info, freeFnPtr ); 186 forAllInDynArrayDo( info, freeFnPtr );
118 free( *(info->addrOfPtrToArray) ); 187 free( *(info->addrOfPtrToArray) );
119 free( info ); 188 free( info );
120 } 189 }
121 190
122 /* Only frees the info 191 /* Only frees the info
123 */ 192 */
124 void 193 void
125 freeDynArrayFlat( DynArrayInfo *info ) 194 freeDynArrayFlat( PrivDynArrayInfo *info )
126 { 195 {
127 free( info ); 196 free( info );
128 } 197 }
129 198
130 199
131 /*The function has a fixed prototype: takes a void * returns void 200 /*The function has a fixed prototype: takes a void * returns void
132 * So, the function has to internally cast void * to whatever data struc.. 201 * So, the function has to internally cast void * to whatever data struc..
133 */ 202 */
134 void 203 void
135 forAllInDynArrayDo( DynArrayInfo *info, DynArrayFnPtr fnPtr ) 204 forAllInDynArrayDo( PrivDynArrayInfo *info, DynArrayFnPtr fnPtr )
136 { int32 idx; 205 { int32 idx;
137 void **array; 206 void **array;
138 207
139 array = *(info->addrOfPtrToArray); 208 array = *(info->addrOfPtrToArray);
140 for( idx = 0; idx < info->numInArray; idx++ ) 209 for( idx = 0; idx < info->numInArray; idx++ )