| 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 #include <malloc.h>
|
|
Me@3
|
11
|
|
Me@4
|
12 #include "DynArray.h"
|
|
Me@3
|
13
|
|
Me@3
|
14
|
|
Me@3
|
15
|
|
Me@4
|
16 DynArrayInfo *
|
|
Me@4
|
17 makeDynArrayInfoFrom( void ***addrOfPtrToArray, int32 sizeOfArray )
|
|
Me@4
|
18 { DynArrayInfo *info;
|
|
Me@3
|
19
|
|
Me@4
|
20 info = malloc( sizeof(DynArrayInfo) );
|
|
Me@3
|
21
|
|
Me@4
|
22 info->addrOfPtrToArray = addrOfPtrToArray;
|
|
Me@4
|
23 info->sizeOfArray = sizeOfArray;
|
|
Me@4
|
24 info->numInArray = 0;
|
|
Me@3
|
25 }
|
|
Me@3
|
26
|
|
Me@4
|
27 DynArrayInfo *
|
|
Me@4
|
28 makeDynArrayOfSize( void ***addrOfPtrToArray, int32 sizeOfArray )
|
|
Me@4
|
29 { DynArrayInfo *info;
|
|
Me@4
|
30
|
|
Me@4
|
31 info = malloc( sizeof(DynArrayInfo) );
|
|
Me@4
|
32
|
|
Me@4
|
33 info->addrOfPtrToArray = addrOfPtrToArray;
|
|
Me@4
|
34
|
|
Me@4
|
35 *(addrOfPtrToArray) = malloc( sizeOfArray * sizeof(void *) );
|
|
Me@4
|
36 info->sizeOfArray = sizeOfArray;
|
|
Me@4
|
37 info->numInArray = 0;
|
|
Me@4
|
38 }
|
|
Me@4
|
39
|
|
Me@4
|
40
|
|
Me@4
|
41 /*A dynamic array is same as any other array, but add a DynArrayInfo next
|
|
Me@4
|
42 * to it. Accesses and updates of array indexes are done normally, it's
|
|
Me@4
|
43 * only when add a new element into array that use the extra info.
|
|
Me@4
|
44 * An add can cause the pointer to the normal array to change.. so must
|
|
Me@4
|
45 * be protected to single VP at a time.
|
|
Me@4
|
46 *
|
|
Me@4
|
47 *Only need to use this Fn when need a new index, higher than any previous
|
|
Me@4
|
48 */
|
|
Me@4
|
49 int32
|
|
Me@4
|
50 addToDynArray( void *value, DynArrayInfo *info )
|
|
Me@4
|
51 { int32 numInArray, sizeOfArray;
|
|
Me@4
|
52 void **array;
|
|
Me@4
|
53
|
|
Me@4
|
54 numInArray = info->numInArray;
|
|
Me@4
|
55 sizeOfArray = info->sizeOfArray;
|
|
Me@4
|
56
|
|
Me@4
|
57 if( numInArray >= sizeOfArray )
|
|
Me@4
|
58 {
|
|
Me@4
|
59 increaseSizeOfDynArrayTo( info, sizeOfArray * 2 );
|
|
Me@4
|
60 }
|
|
Me@4
|
61
|
|
Me@4
|
62 array = *(info->addrOfPtrToArray);
|
|
Me@4
|
63 array[ numInArray ] = value;
|
|
Me@4
|
64 info->numInArray++;
|
|
Me@4
|
65
|
|
Me@4
|
66 return numInArray; //pre-incr value is the index put value into
|
|
Me@4
|
67 }
|
|
Me@4
|
68
|
|
Me@4
|
69
|
|
Me@4
|
70 /*Use this when know how many things going to add in -- then can do this
|
|
Me@4
|
71 * once and use as normal array afterwards. If later add another chunk,
|
|
Me@4
|
72 * do this again. Note, this makes new size be just big enough to hold
|
|
Me@4
|
73 * highest index, so will do a linear number of copies if use only this.
|
|
Me@4
|
74 *To cut down on number of copies, can use the increaseSizeTo Fn to
|
|
Me@4
|
75 * exponentially increase size..
|
|
Me@4
|
76 */
|
|
Me@4
|
77 void
|
|
Me@4
|
78 makeHighestDynArrayIndexBe( DynArrayInfo *info, int32 highestIndex )
|
|
Me@4
|
79 {
|
|
Me@4
|
80 if( info->sizeOfArray <= highestIndex )
|
|
Me@4
|
81 {
|
|
Me@4
|
82 increaseSizeOfDynArrayTo( info, highestIndex + 1 );
|
|
Me@4
|
83 }
|
|
Me@4
|
84 info->numInArray = highestIndex + 1;
|
|
Me@4
|
85 }
|
|
Me@4
|
86
|
|
Me@4
|
87
|
|
Me@4
|
88 /*Only use this if certain new size is bigger than current size
|
|
Me@4
|
89 */
|
|
Me@4
|
90 void
|
|
Me@4
|
91 increaseSizeOfDynArrayTo( DynArrayInfo *info, int32 newSize )
|
|
Me@4
|
92 { int32 oldSizeOfArray, i;
|
|
Me@3
|
93 void **newArray, **oldArray;
|
|
Me@3
|
94
|
|
Me@4
|
95 oldSizeOfArray = info->sizeOfArray;
|
|
Me@4
|
96 if( newSize <= oldSizeOfArray ) return;
|
|
Me@4
|
97
|
|
Me@4
|
98 oldArray = *(info->addrOfPtrToArray);
|
|
Me@4
|
99 newArray = malloc( newSize * sizeof(void *) );
|
|
Me@4
|
100
|
|
Me@3
|
101 for( i = 0; i < oldSizeOfArray; i++ )
|
|
Me@3
|
102 {
|
|
Me@3
|
103 newArray[i] = oldArray[i];
|
|
Me@3
|
104 }
|
|
Me@4
|
105 *(info->addrOfPtrToArray) = newArray; //change location of array-ptr
|
|
Me@4
|
106 info->sizeOfArray = newSize;
|
|
Me@3
|
107
|
|
Me@4
|
108 free( oldArray );
|
|
Me@3
|
109 }
|
|
Me@3
|
110
|
|
Me@4
|
111
|
|
Me@4
|
112 /* Frees the array, plus the info
|
|
Me@4
|
113 */
|
|
Me@4
|
114 void
|
|
Me@4
|
115 freeDynArrayDeep( DynArrayInfo *info, FreeFnPtr freeFnPtr )
|
|
Me@3
|
116 {
|
|
Me@4
|
117 forAllInDynArrayDo( info, freeFnPtr );
|
|
Me@4
|
118 free( *(info->addrOfPtrToArray) );
|
|
Me@4
|
119 free( info );
|
|
Me@3
|
120 }
|
|
Me@4
|
121
|
|
Me@4
|
122 /* Only frees the info
|
|
Me@4
|
123 */
|
|
Me@4
|
124 void
|
|
Me@4
|
125 freeDynArrayFlat( DynArrayInfo *info )
|
|
Me@4
|
126 {
|
|
Me@4
|
127 free( info );
|
|
Me@4
|
128 }
|
|
Me@4
|
129
|
|
Me@4
|
130
|
|
Me@4
|
131 /*The function has a fixed prototype: takes a void * returns void
|
|
Me@4
|
132 * So, the function has to internally cast void * to whatever data struc..
|
|
Me@4
|
133 */
|
|
Me@4
|
134 void
|
|
Me@4
|
135 forAllInDynArrayDo( DynArrayInfo *info, DynArrayFnPtr fnPtr )
|
|
Me@4
|
136 { int32 idx;
|
|
Me@4
|
137 void **array;
|
|
Me@4
|
138
|
|
Me@4
|
139 array = *(info->addrOfPtrToArray);
|
|
Me@4
|
140 for( idx = 0; idx < info->numInArray; idx++ )
|
|
Me@4
|
141 {
|
|
Me@4
|
142 (*fnPtr)(array[idx]);
|
|
Me@4
|
143 }
|
|
Me@4
|
144 }
|
|
Me@4
|
145
|
