hphp/neo/ulist.c

   1 /*
   2  * Copyright 2001-2004 Brandon Long
   3  * All Rights Reserved.
   4  *
   5  * ClearSilver Templating System
   6  *
   7  * This code is made available under the terms of the ClearSilver License.
   8  * http://www.clearsilver.net/license.hdf
   9  *
  10  */
  11
  12 #include "cs_config.h"
  13
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <errno.h>
  17
  18 #include "neo_misc.h"
  19 #include "neo_err.h"
  20 #include "ulist.h"
  21
  22 #define ULIST_DEFAULT_SIZE 10
  23
  24 static NEOERR *check_resize (ULIST *ul, int size)
  25 {
  26   if (size > ul->max)
  27   {
  28     void **new_items;
  29     int new_size = 0;
  30
  31     new_size = ul->max*2;
  32     if (size > new_size)
  33     {
  34       new_size = size + ul->max;
  35     }
  36
  37     new_items = (void **) realloc ((void *)(ul->items), new_size * sizeof(void *));
  38     if (new_items == NULL)
  39     {
  40       return nerr_raise(NERR_NOMEM,
  41           "Unable to resize ULIST to %d: Out of memory", new_size);
  42     }
  43     ul->items = new_items;
  44     ul->max = new_size;
  45   }
  46
  47   return STATUS_OK;
  48 }
  49
  50
  51 NEOERR *uListInit(ULIST **ul, int size, int flags)
  52 {
  53   ULIST *r_ul;
  54
  55   *ul = NULL;
  56   if (size == 0)
  57   {
  58     size = ULIST_DEFAULT_SIZE;
  59   }
  60
  61   r_ul = (ULIST *) calloc (1, sizeof (ULIST));
  62   if (r_ul == NULL)
  63   {
  64     return nerr_raise(NERR_NOMEM, "Unable to create ULIST: Out of memory");
  65   }
  66   r_ul->items = (void **) calloc (size, sizeof(void *));
  67   if (r_ul->items == NULL)
  68   {
  69     free (r_ul);
  70     return nerr_raise(NERR_NOMEM, "Unable to create ULIST: Out of memory");
  71   }
  72
  73   r_ul->num = 0;
  74   r_ul->max = size;
  75   r_ul->flags = flags;
  76   *ul = r_ul;
  77
  78   return STATUS_OK;
  79 }
  80
  81 NEOERR *uListAppend (ULIST *ul, void *data)
  82 {
  83   NEOERR *r;
  84
  85   r = check_resize (ul, ul->num + 1);
  86   if (r != STATUS_OK)
  87     return r;
  88
  89   ul->items[ul->num] = data;
  90   ul->num++;
  91
  92   return STATUS_OK;
  93 }
  94
  95 NEOERR *uListGet (ULIST *ul, int x, void **data)
  96 {
  97   if (x < 0)
  98     x = ul->num + x;
  99
 100   if (x >= ul->num)
 101     return nerr_raise(NERR_OUTOFRANGE, "uListGet: past end (%d > %d)",
 102         x, ul->num);
 103
 104   if (x < 0)
 105     return nerr_raise(NERR_OUTOFRANGE, "uListGet: past beginning (%d < 0)", x);
 106
 107   *data = ul->items[x];
 108
 109   return STATUS_OK;
 110 }
 111
 112 NEOERR *uListSort (ULIST *ul, int (*compareFunc)(const void *, const void*)) {
 113   qsort(ul->items, ul->num, sizeof(void *), compareFunc);
 114   return STATUS_OK;
 115 }
 116
 117 NEOERR *uListDestroy (ULIST **ul, int flags)
 118 {
 119   if (flags & ULIST_FREE)
 120   {
 121     return uListDestroyFunc(ul, free);
 122   }
 123   else
 124   {
 125     return uListDestroyFunc(ul, NULL);
 126   }
 127 }
 128
 129 NEOERR *uListDestroyFunc (ULIST **ul, void (*destroyFunc)(void *))
 130 {
 131   ULIST *r_ul;
 132
 133   r_ul = *ul;
 134
 135   if (r_ul == NULL)
 136     return STATUS_OK;
 137
 138   if (destroyFunc != NULL)
 139   {
 140     int x;
 141     for (x = 0; x < r_ul->num; x++)
 142     {
 143       (*destroyFunc)(r_ul->items[x]);
 144     }
 145   }
 146   free (r_ul->items);
 147   free (r_ul);
 148   *ul = NULL;
 149
 150   return STATUS_OK;
 151 }
 152
 153 int uListLength (ULIST *ul)
 154 {
 155   if (ul == NULL) return 0;
 156   return ul->num;
 157 }