Annotation of libaitio/src/array.c, revision 1.6
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.6 ! misho 6: * $Id: array.c,v 1.5.2.1 2011/12/12 14:45:19 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.3 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.5 misho 72: io_arrayZero(arr);
1.2 misho 73:
74: return arr;
75: }
76:
77: /*
1.3 misho 78: * io_arrayFrom() - Create and fill array from array with pointers
1.4 misho 79: * @pargv = Array with pointers
1.3 misho 80: * @argc = Number of Items, if 0 walk through argv and stop when reach NULL item
1.4 misho 81: * return: NULL error, != NULL allocated new array
1.3 misho 82: */
83: inline array_t *
1.4 misho 84: io_arrayFrom(const char *** __restrict pargv, int argc)
1.3 misho 85: {
86: array_t *arr = NULL;
87: const char **a = NULL;
88: register int num = 0;
89:
1.4 misho 90: assert(pargv);
91: if (!pargv || !*pargv || argc < 0)
1.3 misho 92: return NULL;
93:
94: if (argc)
95: num = argc;
96: else
1.4 misho 97: for (a = *pargv; *a; a++, num++);
1.3 misho 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
1.4 misho 112: memcpy(arr->arr_data, *pargv, io_arraySize(arr) * sizeof(void*));
1.3 misho 113:
114: return arr;
115: }
116:
117: /*
118: * io_arrayTo() - Create and fill array with pointers from dynamic array
119: * @arr = Array
1.4 misho 120: * return: NULL error, != NULL allocated memory for array, NULL terminated
1.3 misho 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) + 1, sizeof(char*));
132: if (!args) {
133: LOGERR;
134: return NULL;
135: } else
136: memcpy(args, arr->arr_data, io_arraySize(arr) * sizeof(char*));
137: args[io_arraySize(arr)] = NULL;
138:
139: return args;
140: }
141:
142: /*
143: * io_arrayFree() - Free all data in dynamic array items
1.2 misho 144: * (WARNING! If assign static array dont use this!!!)
145: * @arr = Array
146: * return: none
147: */
148: inline void
149: io_arrayFree(array_t * __restrict arr)
150: {
151: register int i;
152:
153: if (!arr)
154: return;
155:
1.3 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.3 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: {
1.4 misho 171: if (!parr || !*parr)
1.2 misho 172: return;
173:
174: if ((*parr)->arr_data)
175: free((*parr)->arr_data);
176: free(*parr);
177: *parr = NULL;
178: }
179:
180: /*
181: * io_arrayLen() - Get last used element in dynamic array (array Length)
182: * @arr = Array
183: * return: -1 error, 0 empty or >0 position of last used element
184: */
185: inline int
186: io_arrayLen(array_t * __restrict arr)
187: {
188: register int i;
189:
190: assert(arr);
191: if (!arr)
192: return -1;
193:
1.3 misho 194: for (i = io_arraySize(arr); i && !arr->arr_data[i - 1]; i--);
1.2 misho 195:
196: return i;
197: }
198:
199: /*
200: * io_arrayGrow() - Grow/Shrink dynamic array, Use with care when it shrink!!!
201: * @arr = Array
202: * @newNumItems = Number of Items
1.5 misho 203: * @freeShrink = Free elements before shrink array
1.2 misho 204: * return: -1 error, 0 ok
205: */
206: int
1.5 misho 207: io_arrayGrow(array_t * __restrict arr, int newNumItems, int freeShrink)
1.2 misho 208: {
209: void **data;
210: int n = 0;
1.5 misho 211: register int i;
1.2 misho 212:
213: if (!arr)
214: return -1;
215:
216: if (arr->arr_num == newNumItems)
217: return 0;
1.3 misho 218: if (io_arraySize(arr) < newNumItems) {
219: n = newNumItems - io_arraySize(arr);
1.5 misho 220: } else if (freeShrink)
1.2 misho 221: for (i = newNumItems; i < arr->arr_num; i++)
222: if (arr->arr_data[i])
223: free(arr->arr_data[i]);
224:
225: arr->arr_num = newNumItems;
1.3 misho 226: if (io_arraySize(arr)) {
227: data = realloc(arr->arr_data, io_arraySize(arr) * sizeof(void*));
228: if (!data) {
229: LOGERR;
230: return -1;
231: } else
232: arr->arr_data = data;
233:
234: memset(arr->arr_data + (io_arraySize(arr) - n), 0, n * sizeof(void*));
235: } else {
236: if (arr->arr_data)
237: free(arr->arr_data);
238: arr->arr_data = NULL;
239: }
1.2 misho 240:
241: return 0;
242: }
243:
244: /*
245: * io_arrayVacuum() - Vacuum dynamic array, empty elements will be deleted
246: * @arr = Array
247: * @fromWhere = 1 begin, 2 ALL empty elements
248: * return: -1 error, 0 ok
249: */
250: int
251: io_arrayVacuum(array_t * __restrict arr, int fromWhere)
252: {
253: register int i, j, num;
254: int cx = 0;
255:
256: if (!arr)
257: return -1;
258: else
259: fromWhere &= 0x7;
260:
1.3 misho 261: num = io_arraySize(arr);
1.2 misho 262: /*
263: if (fromWhere & VACUUM_RIGHT) {
264: for (cx = 0, i = num - 1; i && !arr->arr_data[i]; i--, cx++);
265: num -= cx;
266: }
267: */
268: if (fromWhere & VACUUM_LEFT) {
269: for (i = 0; i < num && !arr->arr_data[i]; i++);
1.4 misho 270: if (i) {
271: memmove(arr->arr_data, arr->arr_data + i, (num - i) * sizeof(void*));
272: memset(arr->arr_data + (num - i), 0, i * sizeof(void*));
1.2 misho 273:
1.4 misho 274: num -= i;
275: cx += i;
276: }
1.2 misho 277: }
278: if (fromWhere & VACUUM_BETWEEN) {
279: for (i = 0; i < num; i++) {
280: if (arr->arr_data[i])
281: continue;
282:
283: for (j = i; j < num && !arr->arr_data[j]; j++);
284:
285: memmove(arr->arr_data + i, arr->arr_data + j, (num - j) * sizeof(void*));
286: memset(arr->arr_data + i + (num - j), 0, (j - i) * sizeof(void*));
287:
288: num -= j - i;
289: cx += j - i;
290: }
291: }
292:
293: return cx;
294: }
295:
296: /*
1.6 ! misho 297: * io_arrayElem() - Always GET/PUT element into dynamic array, if not enough elements grow array
! 298: * @arr = Array
! 299: * @n = Position
! 300: * @data = Element, if set NULL GET element at position or !=NULL PUT element at position
! 301: * return: -1 error or !=-1 return element at position
! 302: */
! 303: inline void *
! 304: io_arrayElem(array_t * __restrict arr, int n, void **data)
! 305: {
! 306: void *dat = NULL;
! 307:
! 308: if (!arr)
! 309: return (void*) -1;
! 310:
! 311: if (n > io_arraySize(arr) && io_arrayGrow(arr, n + 1, 0))
! 312: return (void*) -1;
! 313:
! 314: dat = io_arrayGet(arr, n);
! 315: if (data)
! 316: io_arraySet(arr, n, *data);
! 317:
! 318: return dat;
! 319: }
! 320:
! 321: /*
1.2 misho 322: * io_arrayPush() - Push element into dynamic array like stack manner, place at first empty position
323: * @arr = Array
324: * @data = Element, if set NULL return only first empty position
325: * return: -1 not found empty position, array is full!, >-1 return position of stored element into array
326: */
327: inline int
328: io_arrayPush(array_t * __restrict arr, void **data)
329: {
330: register int i;
331: int ret = -1;
332:
1.6 ! misho 333: if (!arr)
! 334: return -1;
! 335:
1.3 misho 336: for (i = 0; i < io_arraySize(arr); i++)
1.2 misho 337: if (!arr->arr_data[i]) {
338: if (data)
339: arr->arr_data[i] = *data;
340: ret = i;
341: break;
342: }
343:
344: return ret;
345: }
346:
347: /*
348: * io_arrayPop() - Pop element from dynamic array like stack manner, last used position
349: * @arr = Array
1.4 misho 350: * @data = Element, if set NULL return only last used position
1.2 misho 351: * @delAfter = Delete after Pop element, !=0 delete element from array after return data
352: * return: -1 not found used position, array is empty!, >-1 return element position
353: */
354: inline int
355: io_arrayPop(array_t * __restrict arr, void ** __restrict data, int delAfter)
356: {
357: register int i;
358: int ret = -1;
359:
1.6 ! misho 360: if (!arr)
! 361: return -1;
! 362:
1.3 misho 363: for (i = io_arraySize(arr) - 1; i >= 0; i--)
1.2 misho 364: if (arr->arr_data[i]) {
365: if (data)
366: *data = arr->arr_data[i];
367: if (delAfter)
368: arr->arr_data[i] = NULL;
369: ret = i;
370: break;
371: }
372:
373: return ret;
374: }
375:
376: /*
1.3 misho 377: * io_arrayConcat() Concat source array to destination array
378: * @dest = Destination array
379: * @src = Source array
380: * return: -1 error; >0 new count of destination array
381: */
382: int
383: io_arrayConcat(array_t * __restrict dest, array_t * __restrict src)
384: {
385: int n;
386:
387: assert(dest);
388: assert(src);
389: if (!dest || !src)
390: return -1;
391:
392: n = io_arraySize(dest);
1.5 misho 393: if (io_arrayGrow(dest, n + io_arraySize(src), 0))
1.3 misho 394: return -1;
395: memcpy(dest->arr_data + n, src->arr_data, io_arraySize(src) * sizeof(void*));
396:
397: return io_arraySize(dest);
398: }
399:
400: /*
1.5 misho 401: * io_arrayCopy() Copy source array to destination array
402: * @dest = Destination array, after use free with io_arrayDestroy()
403: * @src = Source array
404: * return: -1 error; >0 count of destination array
405: */
406: int
407: io_arrayCopy(array_t ** __restrict dest, array_t * __restrict src)
408: {
409: assert(dest);
410: assert(src);
411: if (!dest || !src)
412: return -1;
413:
414: *dest = io_arrayInit(io_arraySize(src));
415: if (!*dest)
416: return -1;
417:
418: memcpy((*dest)->arr_data, src->arr_data, io_arraySize(*dest) * sizeof(void*));
419: return io_arraySize(*dest);
420: }
421:
422: /*
1.2 misho 423: * io_argsNum() Parse and calculate number of arguments
424: * @csArgs = Input arguments line
425: * @csDelim = Delimiter(s) for separate
426: * return: 0 error format; -1 error:: can`t read; >0 ok, number of items
427: */
428: inline int
429: io_argsNum(const char *csArgs, const char *csDelim)
430: {
431: register int res;
432: char *pos;
433:
434: assert(csArgs);
435: assert(csDelim);
436: if (!csArgs || !csDelim)
437: return -1;
438:
439: for (res = 1, pos = (char*) csArgs; (pos = strpbrk(pos, csDelim)); res++, pos++);
440: return res;
441: }
442:
443: /*
444: * io_arrayMake() Parse and make array from arguments ... (input string will be modified!!!
445: * and output array must be free with io_arrayDestroy() after use!)
446: * @psArgs = Input arguments line, after execute string is modified!!!
447: * @nargs = Maximum requested count of arguments from input string psArgs, if 0 all psArgs
448: * @csDelim = Delimiter(s) for separate
449: * @parr = Output array of arguments ... (must be free with io_arrayDestroy() after use!)
450: * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
451: */
452: int
453: io_arrayMake(char * __restrict psArgs, int nargs, const char *csDelim, array_t ** __restrict parr)
454: {
455: char **app;
456: register int i;
457:
458: assert(psArgs);
459: assert(csDelim);
460: assert(parr);
461: if (!psArgs || !csDelim || !parr)
462: return -1;
463:
464: if (nargs)
465: i = nargs;
466: else
467: i = io_argsNum(psArgs, csDelim);
468: *parr = io_arrayInit(i);
469: if (!*parr)
470: return -1;
471:
472: for (i = 0, app = (char**) (*parr)->arr_data;
473: app < (char**) (*parr)->arr_data + (*parr)->arr_num &&
474: (*app = strsep((char **) &psArgs, csDelim));
475: **app ? i++ : i, **app ? app++ : app);
476: return i;
477: }
478:
479: /*
480: * io_MakeAV() Parse and make attribute/value pair
481: * @csArgs = Input argument line
482: * @csDelim = Delimiter for separate
483: * @psAttr = Output Attribute
484: * @attrLen = Size of attribute array
485: * @psValue = Output Value, if ==NULL this element not present value or not wanted for return
486: * @valLen = Size of value array
487: * return: 0 error format; -1 error:: can`t read; >0 ok, number of readed items
488: */
489: int
490: io_MakeAV(const char * __restrict csArgs, const char *csDelim,
491: char * __restrict psAttr, int attrLen, char * __restrict psValue, int valLen)
492: {
493: register int ret = 0;
494: char *pos, *psBuf;
495:
496: if (!csArgs || !csDelim || !psAttr || !attrLen)
497: return -1;
498: if (psValue && !valLen)
499: return -1;
500: else
501: memset(psValue, 0, valLen);
502: psBuf = strdup(csArgs);
503: if (!psBuf) {
504: LOGERR;
505: return -1;
506: }
507:
508: pos = strpbrk(psBuf, csDelim);
509: if (pos)
510: *pos++ = 0;
511: ret++;
512: strlcpy(psAttr, psBuf, attrLen);
513:
514: if (pos && *pos) {
515: ret++;
516: if (psValue)
517: strlcpy(psValue, pos, valLen);
518: }
519:
520: free(psBuf);
521: return ret;
522: }
523:
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