Mercurial > code
comparison array.c @ 30:e2c3a0a549d2
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 } |