[BACK]Return to array.c CVS log [TXT] [DIR] Up to [ELWIX - Embedded LightWeight unIX -] / libaitio / src

Diff for /libaitio/src/Attic/array.c between versions 1.2.4.2 and 1.7

version 1.2.4.2, 2011/05/19 03:01:20 version 1.7, 2012/02/02 21:32:42
Line 69  io_arrayInit(int numItems) Line 69  io_arrayInit(int numItems)
                 free(arr);                  free(arr);
                 return NULL;                  return NULL;
         } else          } else
                memset(arr->arr_data, 0, io_arraySize(arr) * sizeof(void*));                io_arrayZero(arr);
   
         return arr;          return arr;
 }  }
   
 /*  /*
  * io_arrayFrom() - Create and fill array from array with pointers   * io_arrayFrom() - Create and fill array from array with pointers
 * @argv = Array with pointers * @pargv = Array with pointers
  * @argc = Number of Items, if 0 walk through argv and stop when reach NULL item   * @argc = Number of Items, if 0 walk through argv and stop when reach NULL item
 * return: NULL error, != NULL allocated memory for array * return: NULL error, != NULL allocated new array
  */   */
 inline array_t *  inline array_t *
io_arrayFrom(const char **argv, int argc)io_arrayFrom(const char *** __restrict pargv, int argc)
 {  {
         array_t *arr = NULL;          array_t *arr = NULL;
         const char **a = NULL;          const char **a = NULL;
         register int num = 0;          register int num = 0;
   
        assert(argv);        assert(pargv);
        if (!argv || !*argv || argc < 0)        if (!pargv || !*pargv || argc < 0)
                 return NULL;                  return NULL;
   
         if (argc)          if (argc)
                 num = argc;                  num = argc;
         else          else
                for (a = argv; *a; a++, num++);                for (a = *pargv; *a; a++, num++);
   
         arr = malloc(sizeof(array_t));          arr = malloc(sizeof(array_t));
         if (!arr) {          if (!arr) {
Line 109  io_arrayFrom(const char **argv, int argc) Line 109  io_arrayFrom(const char **argv, int argc)
                 free(arr);                  free(arr);
                 return NULL;                  return NULL;
         } else          } else
                memcpy(arr->arr_data, argv, io_arraySize(arr) * sizeof(void*));                memcpy(arr->arr_data, *pargv, io_arraySize(arr) * sizeof(void*));
   
         return arr;          return arr;
 }  }
Line 117  io_arrayFrom(const char **argv, int argc) Line 117  io_arrayFrom(const char **argv, int argc)
 /*  /*
  * io_arrayTo() - Create and fill array with pointers from dynamic array   * io_arrayTo() - Create and fill array with pointers from dynamic array
  * @arr = Array   * @arr = Array
 * return: NULL error, != NULL allocated memory for array * return: NULL error, != NULL allocated memory for array, NULL terminated
  */   */
 inline char **  inline char **
 io_arrayTo(array_t * __restrict arr)  io_arrayTo(array_t * __restrict arr)
Line 128  io_arrayTo(array_t * __restrict arr) Line 128  io_arrayTo(array_t * __restrict arr)
         if (!arr || !io_arraySize(arr))          if (!arr || !io_arraySize(arr))
                 return NULL;                  return NULL;
   
        args = (char **) calloc(io_arraySize(arr), sizeof(char*));        args = (char **) calloc(io_arraySize(arr) + 1, sizeof(char*));
         if (!args) {          if (!args) {
                 LOGERR;                  LOGERR;
                 return NULL;                  return NULL;
         } else          } else
                 memcpy(args, arr->arr_data, io_arraySize(arr) * sizeof(char*));                  memcpy(args, arr->arr_data, io_arraySize(arr) * sizeof(char*));
           args[io_arraySize(arr)] = NULL;
   
         return args;          return args;
 }  }
Line 149  io_arrayFree(array_t * __restrict arr) Line 150  io_arrayFree(array_t * __restrict arr)
 {  {
         register int i;          register int i;
   
         assert(arr);  
         if (!arr)          if (!arr)
                 return;                  return;
   
Line 168  io_arrayFree(array_t * __restrict arr) Line 168  io_arrayFree(array_t * __restrict arr)
 inline void  inline void
 io_arrayDestroy(array_t ** __restrict parr)  io_arrayDestroy(array_t ** __restrict parr)
 {  {
        assert(parr);        if (!parr || !*parr)
        if (!parr) 
                 return;                  return;
   
         if ((*parr)->arr_data)          if ((*parr)->arr_data)
Line 201  io_arrayLen(array_t * __restrict arr) Line 200  io_arrayLen(array_t * __restrict arr)
  * io_arrayGrow() - Grow/Shrink dynamic array, Use with care when it shrink!!!   * io_arrayGrow() - Grow/Shrink dynamic array, Use with care when it shrink!!!
  * @arr = Array   * @arr = Array
  * @newNumItems = Number of Items   * @newNumItems = Number of Items
    * @freeShrink = Free elements before shrink array
  * return: -1 error, 0 ok   * return: -1 error, 0 ok
  */   */
 int  int
io_arrayGrow(array_t * __restrict arr, int newNumItems)io_arrayGrow(array_t * __restrict arr, int newNumItems, int freeShrink)
 {  {
         void **data;          void **data;
         int n = 0;          int n = 0;
/*        register int i; */        register int i;
   
         assert(arr);  
         if (!arr)          if (!arr)
                 return -1;                  return -1;
   
Line 218  io_arrayGrow(array_t * __restrict arr, int newNumItems Line 217  io_arrayGrow(array_t * __restrict arr, int newNumItems
                 return 0;                  return 0;
         if (io_arraySize(arr) < newNumItems) {          if (io_arraySize(arr) < newNumItems) {
                 n = newNumItems - io_arraySize(arr);                  n = newNumItems - io_arraySize(arr);
        } /* else        } else if (freeShrink)
                 for (i = newNumItems; i < arr->arr_num; i++)                  for (i = newNumItems; i < arr->arr_num; i++)
                         if (arr->arr_data[i])                          if (arr->arr_data[i])
                                 free(arr->arr_data[i]);                                  free(arr->arr_data[i]);
                                 */  
   
         arr->arr_num = newNumItems;          arr->arr_num = newNumItems;
        data = realloc(arr->arr_data, io_arraySize(arr) * sizeof(void*));        if (io_arraySize(arr)) {
        if (!data) {                data = realloc(arr->arr_data, io_arraySize(arr) * sizeof(void*));
                LOGERR;                if (!data) {
                return -1;                        LOGERR;
        } else                        return -1;
                arr->arr_data = data;                } else
        memset(arr->arr_data + (io_arraySize(arr) - n), 0, n * sizeof(void*));                        arr->arr_data = data;
   
                   memset(arr->arr_data + (io_arraySize(arr) - n), 0, n * sizeof(void*));
           } else {
                   if (arr->arr_data)
                           free(arr->arr_data);
                   arr->arr_data = NULL;
           }
   
         return 0;          return 0;
 }  }
   
Line 248  io_arrayVacuum(array_t * __restrict arr, int fromWhere Line 253  io_arrayVacuum(array_t * __restrict arr, int fromWhere
         register int i, j, num;          register int i, j, num;
         int cx = 0;          int cx = 0;
   
         assert(arr);  
         if (!arr)          if (!arr)
                 return -1;                  return -1;
         else          else
Line 263  io_arrayVacuum(array_t * __restrict arr, int fromWhere Line 267  io_arrayVacuum(array_t * __restrict arr, int fromWhere
         */          */
         if (fromWhere & VACUUM_LEFT) {          if (fromWhere & VACUUM_LEFT) {
                 for (i = 0; i < num && !arr->arr_data[i]; i++);                  for (i = 0; i < num && !arr->arr_data[i]; i++);
                   if (i) {
                           memmove(arr->arr_data, arr->arr_data + i, (num - i) * sizeof(void*));
                           memset(arr->arr_data + (num - i), 0, i * sizeof(void*));
   
                memmove(arr->arr_data, arr->arr_data + i, (num - i) * sizeof(void*));                        num -= i;
                memset(arr->arr_data + (num - i), 0, i * sizeof(void*));                        cx += i;
                }
                num -= i; 
                cx += i; 
         }          }
         if (fromWhere & VACUUM_BETWEEN) {          if (fromWhere & VACUUM_BETWEEN) {
                 for (i = 0; i < num; i++) {                  for (i = 0; i < num; i++) {
Line 289  io_arrayVacuum(array_t * __restrict arr, int fromWhere Line 294  io_arrayVacuum(array_t * __restrict arr, int fromWhere
 }  }
   
 /*  /*
    * io_arrayElem() - Always GET/PUT element into dynamic array, if not enough elements grow array
    * @arr = Array
    * @n = Position
    * @data = Element, if set NULL GET element at position or !=NULL PUT element at position
    * return: -1 error or !=-1 return element at position
    */
   inline void *
   io_arrayElem(array_t * __restrict arr, int n, void *data)
   {
           void *dat = NULL;
   
           if (!arr)
                   return (void*) -1;
   
           if (n > io_arraySize(arr) && io_arrayGrow(arr, n + 1, 0))
                   return (void*) -1;
   
           dat = io_arrayGet(arr, n);
           if (data)
                   io_arraySet(arr, n, data);
   
           return dat;
   }
   
   /*
  * io_arrayPush() - Push element into dynamic array like stack manner, place at first empty position   * io_arrayPush() - Push element into dynamic array like stack manner, place at first empty position
  * @arr = Array   * @arr = Array
  * @data = Element, if set NULL return only first empty position   * @data = Element, if set NULL return only first empty position
Line 300  io_arrayPush(array_t * __restrict arr, void **data) Line 330  io_arrayPush(array_t * __restrict arr, void **data)
         register int i;          register int i;
         int ret = -1;          int ret = -1;
   
        assert(arr);        if (!arr)
                 return -1;
   
         for (i = 0; i < io_arraySize(arr); i++)          for (i = 0; i < io_arraySize(arr); i++)
                 if (!arr->arr_data[i]) {                  if (!arr->arr_data[i]) {
Line 316  io_arrayPush(array_t * __restrict arr, void **data) Line 347  io_arrayPush(array_t * __restrict arr, void **data)
 /*  /*
  * io_arrayPop() - Pop element from dynamic array like stack manner, last used position   * io_arrayPop() - Pop element from dynamic array like stack manner, last used position
  * @arr = Array   * @arr = Array
 * @data = Element, if set NULL return only first empty position * @data = Element, if set NULL return only last used position
  * @delAfter = Delete after Pop element, !=0 delete element from array after return data   * @delAfter = Delete after Pop element, !=0 delete element from array after return data
  * return: -1 not found used position, array is empty!, >-1 return element position   * return: -1 not found used position, array is empty!, >-1 return element position
  */   */
Line 326  io_arrayPop(array_t * __restrict arr, void ** __restri Line 357  io_arrayPop(array_t * __restrict arr, void ** __restri
         register int i;          register int i;
         int ret = -1;          int ret = -1;
   
        assert(arr);        if (!arr)
                 return -1;
   
         for (i = io_arraySize(arr) - 1; i >= 0; i--)          for (i = io_arraySize(arr) - 1; i >= 0; i--)
                 if (arr->arr_data[i]) {                  if (arr->arr_data[i]) {
Line 358  io_arrayConcat(array_t * __restrict dest, array_t * __ Line 390  io_arrayConcat(array_t * __restrict dest, array_t * __
                 return -1;                  return -1;
   
         n = io_arraySize(dest);          n = io_arraySize(dest);
        if (io_arrayGrow(dest, n + io_arraySize(src)))        if (io_arrayGrow(dest, n + io_arraySize(src), 0))
                 return -1;                  return -1;
         memcpy(dest->arr_data + n, src->arr_data, io_arraySize(src) * sizeof(void*));          memcpy(dest->arr_data + n, src->arr_data, io_arraySize(src) * sizeof(void*));
   
         return io_arraySize(dest);          return io_arraySize(dest);
   }
   
   /*
    * io_arrayCopy() Copy source array to destination array
    * @dest = Destination array, after use free with io_arrayDestroy()
    * @src = Source array
    * return: -1 error; >0 count of destination array
    */
   int
   io_arrayCopy(array_t ** __restrict dest, array_t * __restrict src)
   {
           assert(dest);
           assert(src);
           if (!dest || !src)
                   return -1;
   
           *dest = io_arrayInit(io_arraySize(src));
           if (!*dest)
                   return -1;
   
           memcpy((*dest)->arr_data, src->arr_data, io_arraySize(*dest) * sizeof(void*));
           return io_arraySize(*dest);
 }  }
   
 /*  /*
Removed from v.1.2.4.2  
changed lines
  Added in v.1.7

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>