Annotation of libaitio/src/array.c, revision 1.2.4.2
1.2 misho 1: /*************************************************************************
2: * (C) 2011 AITNET ltd - Sofia/Bulgaria - <misho@aitnet.org>
3: * by Michael Pounov <misho@elwix.org>
4: *
5: * $Author: misho $
1.2.4.2 ! misho 6: * $Id: array.c,v 1.2.4.1 2011/05/19 02:22:46 misho Exp $
1.2 misho 7: *
8: **************************************************************************
9: The ELWIX and AITNET software is distributed under the following
10: terms:
11:
12: All of the documentation and software included in the ELWIX and AITNET
13: Releases is copyrighted by ELWIX - Sofia/Bulgaria <info@elwix.org>
14:
15: Copyright 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
16: by Michael Pounov <misho@elwix.org>. All rights reserved.
17:
18: Redistribution and use in source and binary forms, with or without
19: modification, are permitted provided that the following conditions
20: are met:
21: 1. Redistributions of source code must retain the above copyright
22: notice, this list of conditions and the following disclaimer.
23: 2. Redistributions in binary form must reproduce the above copyright
24: notice, this list of conditions and the following disclaimer in the
25: documentation and/or other materials provided with the distribution.
26: 3. All advertising materials mentioning features or use of this software
27: must display the following acknowledgement:
28: This product includes software developed by Michael Pounov <misho@elwix.org>
29: ELWIX - Embedded LightWeight unIX and its contributors.
30: 4. Neither the name of AITNET nor the names of its contributors
31: may be used to endorse or promote products derived from this software
32: without specific prior written permission.
33:
34: THIS SOFTWARE IS PROVIDED BY AITNET AND CONTRIBUTORS ``AS IS'' AND
35: ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36: IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37: ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38: FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39: DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40: OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41: HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42: LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43: OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44: SUCH DAMAGE.
45: */
46: #include "global.h"
47:
48:
49: /*
50: * io_arrayInit() - Create and initialize dynamic array
51: * @numItems = Number of Items
52: * return: NULL error, != NULL allocated memory for array
53: */
54: inline array_t *
55: io_arrayInit(int numItems)
56: {
57: array_t *arr = NULL;
58:
59: arr = malloc(sizeof(array_t));
60: if (!arr) {
61: LOGERR;
62: return NULL;
63: }
64:
65: arr->arr_num = numItems;
1.2.4.2 ! misho 66: arr->arr_data = calloc(io_arraySize(arr), sizeof(void*));
1.2 misho 67: if (!arr->arr_data) {
68: LOGERR;
69: free(arr);
70: return NULL;
71: } else
1.2.4.2 ! misho 72: memset(arr->arr_data, 0, io_arraySize(arr) * sizeof(void*));
1.2 misho 73:
74: return arr;
75: }
76:
77: /*
1.2.4.2 ! misho 78: * io_arrayFrom() - Create and fill array from array with pointers
! 79: * @argv = Array with pointers
! 80: * @argc = Number of Items, if 0 walk through argv and stop when reach NULL item
! 81: * return: NULL error, != NULL allocated memory for array
! 82: */
! 83: inline array_t *
! 84: io_arrayFrom(const char **argv, int argc)
! 85: {
! 86: array_t *arr = NULL;
! 87: const char **a = NULL;
! 88: register int num = 0;
! 89:
! 90: assert(argv);
! 91: if (!argv || !*argv || argc < 0)
! 92: return NULL;
! 93:
! 94: if (argc)
! 95: num = argc;
! 96: else
! 97: for (a = argv; *a; a++, num++);
! 98:
! 99: arr = malloc(sizeof(array_t));
! 100: if (!arr) {
! 101: LOGERR;
! 102: return NULL;
! 103: }
! 104:
! 105: arr->arr_num = num;
! 106: arr->arr_data = calloc(io_arraySize(arr), sizeof(void*));
! 107: if (!arr->arr_data) {
! 108: LOGERR;
! 109: free(arr);
! 110: return NULL;
! 111: } else
! 112: memcpy(arr->arr_data, argv, io_arraySize(arr) * sizeof(void*));
! 113:
! 114: return arr;
! 115: }
! 116:
! 117: /*
! 118: * io_arrayTo() - Create and fill array with pointers from dynamic array
! 119: * @arr = Array
! 120: * return: NULL error, != NULL allocated memory for array
! 121: */
! 122: inline char **
! 123: io_arrayTo(array_t * __restrict arr)
! 124: {
! 125: char **args = NULL;
! 126:
! 127: assert(arr);
! 128: if (!arr || !io_arraySize(arr))
! 129: return NULL;
! 130:
! 131: args = (char **) calloc(io_arraySize(arr), sizeof(char*));
! 132: if (!args) {
! 133: LOGERR;
! 134: return NULL;
! 135: } else
! 136: memcpy(args, arr->arr_data, io_arraySize(arr) * sizeof(char*));
! 137:
! 138: return args;
! 139: }
! 140:
! 141: /*
1.2.4.1 misho 142: * io_arrayFree() - Free all data in dynamic array items
1.2 misho 143: * (WARNING! If assign static array dont use this!!!)
144: * @arr = Array
145: * return: none
146: */
147: inline void
148: io_arrayFree(array_t * __restrict arr)
149: {
150: register int i;
151:
152: assert(arr);
153: if (!arr)
154: return;
155:
1.2.4.2 ! misho 156: for (i = 0; i < io_arraySize(arr); i++)
1.2 misho 157: if (arr->arr_data[i]) {
158: free(arr->arr_data[i]);
159: arr->arr_data[i] = NULL;
160: }
161: }
162:
163: /*
1.2.4.1 misho 164: * io_arrayDestroy() - Free and destroy dynamic array
1.2 misho 165: * @parr = Array
166: * return: none
167: */
168: inline void
169: io_arrayDestroy(array_t ** __restrict parr)
170: {
171: assert(parr);
172: if (!parr)
173: return;
174:
175: if ((*parr)->arr_data)
176: free((*parr)->arr_data);
177: free(*parr);
178: *parr = NULL;
179: }
180:
181: /*
182: * io_arrayLen() - Get last used element in dynamic array (array Length)
183: * @arr = Array
184: * return: -1 error, 0 empty or >0 position of last used element
185: */
186: inline int
187: io_arrayLen(array_t * __restrict arr)
188: {
189: register int i;
190:
191: assert(arr);
192: if (!arr)
193: return -1;
194:
1.2.4.2 ! misho 195: for (i = io_arraySize(arr); i && !arr->arr_data[i - 1]; i--);
1.2 misho 196:
197: return i;
198: }
199:
200: /*
201: * io_arrayGrow() - Grow/Shrink dynamic array, Use with care when it shrink!!!
202: * @arr = Array
203: * @newNumItems = Number of Items
204: * return: -1 error, 0 ok
205: */
206: int
207: io_arrayGrow(array_t * __restrict arr, int newNumItems)
208: {
209: void **data;
210: int n = 0;
211: /* register int i; */
212:
213: assert(arr);
214: if (!arr)
215: return -1;
216:
217: if (arr->arr_num == newNumItems)
218: return 0;
1.2.4.2 ! misho 219: if (io_arraySize(arr) < newNumItems) {
! 220: n = newNumItems - io_arraySize(arr);
1.2 misho 221: } /* else
222: for (i = newNumItems; i < arr->arr_num; i++)
223: if (arr->arr_data[i])
224: free(arr->arr_data[i]);
225: */
226:
227: arr->arr_num = newNumItems;
1.2.4.2 ! misho 228: data = realloc(arr->arr_data, io_arraySize(arr) * sizeof(void*));
1.2 misho 229: if (!data) {
230: LOGERR;
231: return -1;
232: } else
233: arr->arr_data = data;
1.2.4.2 ! misho 234: memset(arr->arr_data + (io_arraySize(arr) - n), 0, n * sizeof(void*));
1.2 misho 235:
236: return 0;
237: }
238:
239: /*
240: * io_arrayVacuum() - Vacuum dynamic array, empty elements will be deleted
241: * @arr = Array
242: * @fromWhere = 1 begin, 2 ALL empty elements
243: * return: -1 error, 0 ok
244: */
245: int
246: io_arrayVacuum(array_t * __restrict arr, int fromWhere)
247: {
248: register int i, j, num;
249: int cx = 0;
250:
251: assert(arr);
252: if (!arr)
253: return -1;
254: else
255: fromWhere &= 0x7;
256:
1.2.4.2 ! misho 257: num = io_arraySize(arr);
1.2 misho 258: /*
259: if (fromWhere & VACUUM_RIGHT) {
260: for (cx = 0, i = num - 1; i && !arr->arr_data[i]; i--, cx++);
261: num -= cx;
262: }
263: */
264: if (fromWhere & VACUUM_LEFT) {
265: for (i = 0; i < num && !arr->arr_data[i]; i++);
266:
267: memmove(arr->arr_data, arr->arr_data + i, (num - i) * sizeof(void*));
268: memset(arr->arr_data + (num - i), 0, i * sizeof(void*));
269:
270: num -= i;
271: cx += i;
272: }
273: if (fromWhere & VACUUM_BETWEEN) {
274: for (i = 0; i < num; i++) {
275: if (arr->arr_data[i])
276: continue;
277:
278: for (j = i; j < num && !arr->arr_data[j]; j++);
279:
280: memmove(arr->arr_data + i, arr->arr_data + j, (num - j) * sizeof(void*));
281: memset(arr->arr_data + i + (num - j), 0, (j - i) * sizeof(void*));
282:
283: num -= j - i;
284: cx += j - i;
285: }
286: }
287:
288: return cx;
289: }
290:
291: /*
292: * io_arrayPush() - Push element into dynamic array like stack manner, place at first empty position
293: * @arr = Array
294: * @data = Element, if set NULL return only first empty position
295: * return: -1 not found empty position, array is full!, >-1 return position of stored element into array
296: */
297: inline int
298: io_arrayPush(array_t * __restrict arr, void **data)
299: {
300: register int i;
301: int ret = -1;
302:
303: assert(arr);
304:
1.2.4.2 ! misho 305: for (i = 0; i < io_arraySize(arr); i++)
1.2 misho 306: if (!arr->arr_data[i]) {
307: if (data)
308: arr->arr_data[i] = *data;
309: ret = i;
310: break;
311: }
312:
313: return ret;
314: }
315:
316: /*
317: * io_arrayPop() - Pop element from dynamic array like stack manner, last used position
318: * @arr = Array
319: * @data = Element, if set NULL return only first empty position
320: * @delAfter = Delete after Pop element, !=0 delete element from array after return data
321: * return: -1 not found used position, array is empty!, >-1 return element position
322: */
323: inline int
324: io_arrayPop(array_t * __restrict arr, void ** __restrict data, int delAfter)
325: {
326: register int i;
327: int ret = -1;
328:
329: assert(arr);
330:
1.2.4.2 ! misho 331: for (i = io_arraySize(arr) - 1; i >= 0; i--)
1.2 misho 332: if (arr->arr_data[i]) {
333: if (data)
334: *data = arr->arr_data[i];
335: if (delAfter)
336: arr->arr_data[i] = NULL;
337: ret = i;
338: break;
339: }
340:
341: return ret;
342: }
343:
344: /*
1.2.4.1 misho 345: * io_arrayConcat() Concat source array to destination array
346: * @dest = Destination array
347: * @src = Source array
348: * return: -1 error; >0 new count of destination array
349: */
350: int
351: io_arrayConcat(array_t * __restrict dest, array_t * __restrict src)
352: {
353: int n;
354:
355: assert(dest);
356: assert(src);
357: if (!dest || !src)
358: return -1;
359:
1.2.4.2 ! misho 360: n = io_arraySize(dest);
! 361: if (io_arrayGrow(dest, n + io_arraySize(src)))
1.2.4.1 misho 362: return -1;
1.2.4.2 ! misho 363: memcpy(dest->arr_data + n, src->arr_data, io_arraySize(src) * sizeof(void*));
1.2.4.1 misho 364:
365: return io_arraySize(dest);
366: }
367:
368: /*
1.2 misho 369: * io_argsNum() Parse and calculate number of arguments
370: * @csArgs = Input arguments line
371: * @csDelim = Delimiter(s) for separate
372: * return: 0 error format; -1 error:: can`t read; >0 ok, number of items
373: */
374: inline int
375: io_argsNum(const char *csArgs, const char *csDelim)
376: {
377: register int res;
378: char *pos;
379:
380: assert(csArgs);
381: assert(csDelim);
382: if (!csArgs || !csDelim)
383: return -1;
384:
385: for (res = 1, pos = (char*) csArgs; (pos = strpbrk(pos, csDelim)); res++, pos++);
386: return res;
387: }
388:
389: /*
390: * io_arrayMake() Parse and make array from arguments ... (input string will be modified!!!
391: * and output array must be free with io_arrayDestroy() after use!)
392: * @psArgs = Input arguments line, after execute string is modified!!!
393: * @nargs = Maximum requested count of arguments from input string psArgs, if 0 all psArgs
394: * @csDelim = Delimiter(s) for separate
395: * @parr = Output array of arguments ... (must be free with io_arrayDestroy() after use!)
396: * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
397: */
398: int
399: io_arrayMake(char * __restrict psArgs, int nargs, const char *csDelim, array_t ** __restrict parr)
400: {
401: char **app;
402: register int i;
403:
404: assert(psArgs);
405: assert(csDelim);
406: assert(parr);
407: if (!psArgs || !csDelim || !parr)
408: return -1;
409:
410: if (nargs)
411: i = nargs;
412: else
413: i = io_argsNum(psArgs, csDelim);
414: *parr = io_arrayInit(i);
415: if (!*parr)
416: return -1;
417:
418: for (i = 0, app = (char**) (*parr)->arr_data;
419: app < (char**) (*parr)->arr_data + (*parr)->arr_num &&
420: (*app = strsep((char **) &psArgs, csDelim));
421: **app ? i++ : i, **app ? app++ : app);
422: return i;
423: }
424:
425: /*
426: * io_MakeAV() Parse and make attribute/value pair
427: * @csArgs = Input argument line
428: * @csDelim = Delimiter for separate
429: * @psAttr = Output Attribute
430: * @attrLen = Size of attribute array
431: * @psValue = Output Value, if ==NULL this element not present value or not wanted for return
432: * @valLen = Size of value array
433: * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
434: */
435: int
436: io_MakeAV(const char * __restrict csArgs, const char *csDelim,
437: char * __restrict psAttr, int attrLen, char * __restrict psValue, int valLen)
438: {
439: register int ret = 0;
440: char *pos, *psBuf;
441:
442: if (!csArgs || !csDelim || !psAttr || !attrLen)
443: return -1;
444: if (psValue && !valLen)
445: return -1;
446: else
447: memset(psValue, 0, valLen);
448: psBuf = strdup(csArgs);
449: if (!psBuf) {
450: LOGERR;
451: return -1;
452: }
453:
454: pos = strpbrk(psBuf, csDelim);
455: if (pos)
456: *pos++ = 0;
457: ret++;
458: strlcpy(psAttr, psBuf, attrLen);
459:
460: if (pos && *pos) {
461: ret++;
462: if (psValue)
463: strlcpy(psValue, pos, valLen);
464: }
465:
466: free(psBuf);
467: return ret;
468: }
469:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to array.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / libaitio / src