Mercurial > code

comparison array.c @ 30:e2c3a0a549d2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Rename SIZE -> OFFSET
author David Demelier <markand@malikania.fr>
date Fri, 23 Sep 2011 08:57:26 +0200
parents 19c0d2e11406
children e532a973f43d
comparison
equal deleted inserted replaced
29:19c0d2e11406 30:e2c3a0a549d2
20 #include <stdlib.h> 20 #include <stdlib.h>
21 #include <string.h> 21 #include <string.h>
22 22
23 #include "array.h" 23 #include "array.h"
24 24
25 #define SIZE(x) (arr->unit * (x)) 25 #define OFFSET(x) (arr->unit * (x))
26 26
27 static int array_grow(struct array *); 27 static int array_grow(struct array *);
28 28
29 struct array * 29 struct array *
30 array_new(const void *data, size_t unit, size_t bsize, int flags) 30 array_new(const void *data, size_t unit, size_t bsize, int flags)
35 return NULL; 35 return NULL;
36 36
37 arr->tmp = NULL; 37 arr->tmp = NULL;
38 arr->length = 0; 38 arr->length = 0;
39 arr->flags = flags; 39 arr->flags = flags;
40 arr->bsize = (bsize == 0) ? ARRAY_DEFAULT_BSIZE : bsize; 40 arr->bsize = (bsize == 0) ? ARRAY_DEFAULT_BOFFSET : bsize;
41 arr->unit = unit; 41 arr->unit = unit;
42 arr->size = SIZE(arr->bsize); 42 arr->size = OFFSET(arr->bsize);
43 43
44 if ((arr->data = malloc(arr->size)) == NULL) { 44 if ((arr->data = malloc(arr->size)) == NULL) {
45 free(arr); 45 free(arr);
46 return NULL; 46 return NULL;
47 } 47 }
62 array_push(struct array *arr, const void *data) 62 array_push(struct array *arr, const void *data)
63 { 63 {
64 if (array_grow(arr) < 0) 64 if (array_grow(arr) < 0)
65 return -1; 65 return -1;
66 66
67 memmove((char *) arr->data + arr->unit, arr->data, SIZE(arr->length++)); 67 memmove((char *) arr->data + arr->unit, arr->data, OFFSET(arr->length++));
68 memcpy((char *) arr->data, data, arr->unit); 68 memcpy((char *) arr->data, data, arr->unit);
69 69
70 return 0; 70 return 0;
71 } 71 }
72 72
79 array_insert(struct array *arr, const void *data, int index) 79 array_insert(struct array *arr, const void *data, int index)
80 { 80 {
81 if (index > arr->length - 1 || index < 0 || array_grow(arr) < 0) 81 if (index > arr->length - 1 || index < 0 || array_grow(arr) < 0)
82 return -1; 82 return -1;
83 83
84 memmove((char *) arr->data + SIZE(index + 1), 84 memmove((char *) arr->data + OFFSET(index + 1),
85 (char *) arr->data + SIZE(index), SIZE(arr->length++ - index)); 85 (char *) arr->data + OFFSET(index), OFFSET(arr->length++ - index));
86 memcpy((char *) arr->data + SIZE(index), data, arr->unit); 86 memcpy((char *) arr->data + OFFSET(index), data, arr->unit);
87 87
88 return 0; 88 return 0;
89 } 89 }
90 90
91 /* 91 /*
96 array_append(struct array *arr, const void *data) 96 array_append(struct array *arr, const void *data)
97 { 97 {
98 if (array_grow(arr) < 0) 98 if (array_grow(arr) < 0)
99 return -1; 99 return -1;
100 100
101 memcpy((char *) arr->data + SIZE(arr->length++), data, arr->unit); 101 memcpy((char *) arr->data + OFFSET(arr->length++), data, arr->unit);
102 102
103 return 0; 103 return 0;
104 } 104 }
105 105
106 /* 106 /*
109 109
110 void 110 void
111 array_pop(struct array *arr) 111 array_pop(struct array *arr)
112 { 112 {
113 if (arr->length > 0) { 113 if (arr->length > 0) {
114 memmove((char *) arr->data, (char *) arr->data + SIZE(1), 114 memmove((char *) arr->data, (char *) arr->data + OFFSET(1),
115 SIZE(--arr->length)); 115 OFFSET(--arr->length));
116 memset((char *) arr->data + SIZE(arr->length), 0, arr->unit); 116 memset((char *) arr->data + OFFSET(arr->length), 0, arr->unit);
117 } 117 }
118 } 118 }
119 119
120 /* 120 /*
121 * Remove the array's tail. 121 * Remove the array's tail.
123 123
124 void 124 void
125 array_unqueue(struct array *arr) 125 array_unqueue(struct array *arr)
126 { 126 {
127 if (arr->length > 0) 127 if (arr->length > 0)
128 memset((char *) arr->data + SIZE(--arr->length), 0, arr->unit); 128 memset((char *) arr->data + OFFSET(--arr->length), 0, arr->unit);
129 } 129 }
130 130
131 /* 131 /*
132 * Remove the data at the specified index. Bounds are checked. 132 * Remove the data at the specified index. Bounds are checked.
133 */ 133 */
134 134
135 void 135 void
136 array_remove(struct array *arr, int index) 136 array_remove(struct array *arr, int index)
137 { 137 {
138 if (arr->length > 0 && index >= 0 && index < arr->length) { 138 if (arr->length > 0 && index >= 0 && index < arr->length) {
139 memmove((char *) arr->data + SIZE(index), 139 memmove((char *) arr->data + OFFSET(index),
140 (char *) arr->data + SIZE(index + 1), 140 (char *) arr->data + OFFSET(index + 1),
141 SIZE(arr->length - index - 1)); 141 OFFSET(arr->length - index - 1));
142 memset((char *) arr->data + SIZE(--arr->length), 0, arr->unit); 142 memset((char *) arr->data + OFFSET(--arr->length), 0, arr->unit);
143 } 143 }
144 } 144 }
145 145
146 /* 146 /*
147 * Swap the two elements referenced by index `i1' and `i2'. This function needs 147 * Swap the two elements referenced by index `i1' and `i2'. This function needs
162 */ 162 */
163 163
164 if (arr->tmp == NULL && (arr->tmp = malloc(arr->unit)) == NULL) 164 if (arr->tmp == NULL && (arr->tmp = malloc(arr->unit)) == NULL)
165 return -1; 165 return -1;
166 166
167 memcpy((char *) arr->tmp, (char *) arr->data + SIZE(i1), arr->unit); 167 memcpy((char *) arr->tmp, (char *) arr->data + OFFSET(i1), arr->unit);
168 memcpy((char *) arr->data + SIZE(i1), (char *) arr->data + SIZE(i2), 168 memcpy((char *) arr->data + OFFSET(i1), (char *) arr->data + OFFSET(i2),
169 arr->unit); 169 arr->unit);
170 memcpy((char *) arr->data + SIZE(i2), (char *) arr->tmp, arr->unit); 170 memcpy((char *) arr->data + OFFSET(i2), (char *) arr->tmp, arr->unit);
171 171
172 return 0; 172 return 0;
173 } 173 }
174 174
175 /* 175 /*
181 array_map(const struct array *arr, void (*fn)(void *, void *), void *udata) 181 array_map(const struct array *arr, void (*fn)(void *, void *), void *udata)
182 { 182 {
183 int i; 183 int i;
184 184
185 for (i = 0; i < arr->length; ++i) 185 for (i = 0; i < arr->length; ++i)
186 fn((char *) arr->data + SIZE(i), udata); 186 fn((char *) arr->data + OFFSET(i), udata);
187 } 187 }
188 188
189 /* 189 /*
190 * Compare each object with the user supplied function. If the `fn' function 190 * Compare each object with the user supplied function. If the `fn' function
191 * returns 1 then the data is returned. Optional idx argument can be set to 191 * returns 1 then the data is returned. Optional idx argument can be set to
198 { 198 {
199 int st, i; 199 int st, i;
200 void *data; 200 void *data;
201 201
202 for (i = st = 0; i < arr->length && st != 1; ++i) 202 for (i = st = 0; i < arr->length && st != 1; ++i)
203 st = fn((char *) arr->data + SIZE(i), u); 203 st = fn((char *) arr->data + OFFSET(i), u);
204 204
205 if (st) { 205 if (st) {
206 data = (char *) arr->data + SIZE(--i); 206 data = (char *) arr->data + OFFSET(--i);
207 if (ix) 207 if (ix)
208 *ix = i; 208 *ix = i;
209 } else 209 } else
210 data = NULL; 210 data = NULL;
211 211
253 if ((arr->size / arr->unit) > (size_t) arr->length) 253 if ((arr->size / arr->unit) > (size_t) arr->length)
254 return 0; 254 return 0;
255 255
256 if (arr->flags & ARRAY_AUTO) { 256 if (arr->flags & ARRAY_AUTO) {
257 if ((arr->data = realloc(arr->data, arr->size + 257 if ((arr->data = realloc(arr->data, arr->size +
258 SIZE(arr->bsize))) == NULL) 258 OFFSET(arr->bsize))) == NULL)
259 return -1; 259 return -1;
260 260
261 arr->size += SIZE(arr->bsize); 261 arr->size += OFFSET(arr->bsize);
262 } else 262 } else
263 return -1; 263 return -1;
264 264
265 return 0; 265 return 0;
266 } 266 }