ctags/main/ptrarray.c

   1 /*
   2 *   Copyright (c) 1999-2002, Darren Hiebert
   3 *
   4 *   This source code is released for free distribution under the terms of the
   5 *   GNU General Public License version 2 or (at your option) any later version.
   6 *
   7 *   This module contains functions managing resizable pointer arrays.
   8 */
   9
  10 /*
  11 *   INCLUDE FILES
  12 */
  13 #include "general.h"  /* must always come first */
  14
  15 #include <string.h>
  16 #include <stdlib.h>
  17
  18 #include "debug.h"
  19 #include "ptrarray.h"
  20 #include "routines.h"
  21
  22 /*
  23 *   DATA DECLARATIONS
  24 */
  25
  26 struct sPtrArray {
  27         unsigned int max;
  28         unsigned int count;
  29         void **array;
  30         ptrArrayDeleteFunc deleteFunc;
  31 };
  32
  33 /*
  34 *   FUNCTION DEFINITIONS
  35 */
  36
  37 extern ptrArray *ptrArrayNew (ptrArrayDeleteFunc deleteFunc)
  38 {
  39         ptrArray* const result = xMalloc (1, ptrArray);
  40         result->max = 8;
  41         result->count = 0;
  42         result->array = xMalloc (result->max, void*);
  43         result->deleteFunc = deleteFunc;
  44         return result;
  45 }
  46
  47 extern void ptrArrayAdd (ptrArray *const current, void *ptr)
  48 {
  49         Assert (current != NULL);
  50         if (current->count == current->max)
  51         {
  52                 current->max *= 2;
  53                 current->array = xRealloc (current->array, current->max, void*);
  54         }
  55         current->array [current->count++] = ptr;
  56 }
  57
  58 extern void ptrArrayRemoveLast (ptrArray *const current)
  59 {
  60         Assert (current != NULL);
  61         Assert (current->count > 0);
  62         --current->count;
  63 }
  64
  65 /* Combine array `from' into `current', deleting `from' */
  66 extern void ptrArrayCombine (ptrArray *const current, ptrArray *const from)
  67 {
  68         unsigned int i;
  69         Assert (current != NULL);
  70         Assert (from != NULL);
  71         for (i = 0  ;  i < from->count  ;  ++i)
  72                 ptrArrayAdd (current, from->array [i]);
  73         from->count = 0;
  74         ptrArrayDelete (from);
  75 }
  76
  77 extern unsigned int ptrArrayCount (const ptrArray *const current)
  78 {
  79         Assert (current != NULL);
  80         return current->count;
  81 }
  82
  83 extern void* ptrArrayItem (const ptrArray *const current, const unsigned int indx)
  84 {
  85         Assert (current != NULL);
  86         return current->array [indx];
  87 }
  88
  89 extern void* ptrArrayLast (const ptrArray *const current)
  90 {
  91         Assert (current != NULL);
  92         Assert (current->count > 0);
  93         return current->array [current->count - 1];
  94 }
  95
  96 extern void ptrArrayClear (ptrArray *const current)
  97 {
  98         Assert (current != NULL);
  99         if (current->deleteFunc)
 100         {
 101                 unsigned int i;
 102                 for (i = 0  ;  i < current->count  ;  ++i)
 103                         current->deleteFunc (current->array [i]);
 104         }
 105         current->count = 0;
 106 }
 107
 108 extern void ptrArrayDelete (ptrArray *const current)
 109 {
 110         if (current != NULL)
 111         {
 112                 ptrArrayClear (current);
 113                 eFree (current->array);
 114                 eFree (current);
 115         }
 116 }
 117
 118 extern bool ptrArrayHasTest (const ptrArray *const current,
 119                                   bool (*test)(const void *ptr, void *userData),
 120                                   void *userData)
 121 {
 122         bool result = false;
 123         unsigned int i;
 124         Assert (current != NULL);
 125         for (i = 0  ;  ! result  &&  i < current->count  ;  ++i)
 126                 result = (*test)(current->array [i], userData);
 127         return result;
 128 }
 129
 130 static bool ptrEq (const void *ptr, void *userData)
 131 {
 132         return (ptr == userData);
 133 }
 134
 135 extern bool ptrArrayHas (const ptrArray *const current, void *ptr)
 136 {
 137         return ptrArrayHasTest (current, ptrEq, ptr);
 138 }
 139
 140 extern void ptrArrayReverse (const ptrArray *const current)
 141 {
 142         unsigned int i, j;
 143         void *tmp;
 144
 145         Assert (current != NULL);
 146         for (i = 0, j = current->count - 1 ; i <  (current->count / 2); ++i, --j)
 147         {
 148                 tmp = current->array[i];
 149                 current->array[i] = current->array[j];
 150                 current->array[j] = tmp;
 151         }
 152 }
 153
 154 extern void ptrArrayDeleteItem (ptrArray* const current, unsigned int indx)
 155 {
 156         void *ptr = current->array[indx];
 157
 158         if (current->deleteFunc)
 159                 current->deleteFunc (ptr);
 160
 161         memmove (current->array + indx, current->array + indx + 1,
 162                         (current->count - indx) * sizeof (*current->array));
 163         --current->count;
 164 }
 165
 166 static int (*ptrArraySortCompareVar)(const void *, const void *);
 167
 168 static int ptrArraySortCompare(const void *a0, const void *b0)
 169 {
 170         void *const *a = (void *const *)a0;
 171         void *const *b = (void *const *)b0;
 172
 173         return ptrArraySortCompareVar (*a, *b);
 174 }
 175
 176 extern void ptrArraySort (ptrArray *const current, int (*compare)(const void *, const void *))
 177 {
 178         ptrArraySortCompareVar = compare;
 179         qsort (current->array, current->count, sizeof (void *), ptrArraySortCompare);
 180 }