src/list.c

   1 #include <assert.h>
   2 #include <errno.h>
   3 #include <stdlib.h>
   4
   5 #include "list.h"
   6 #include "smalloc.h"
   7
   8 #ifndef errno
   9 extern int errno;
  10 #endif
  11
  12 /*
  13  * list_init()    - statically initialise a list object.
  14  * list_create()  - create a new linked list object.
  15  * list_append()  - append an item to the head of the list.
  16  * list_prepend() - prepend an item to the tail of the list.
  17  * list_clear()   - clear (free) all nodes in a list.
  18  * list_free()    - free memory associated with list object and its nodes.
  19  */
  20
  21 /* {{{ int8_t list_init() */
  22 int8_t
  23 list_init (list_t *list)
  24 {
  25         assert(list);
  26         if (!list)
  27         {
  28                 errno = EINVAL;
  29                 return -1;
  30         }
  31
  32         /*
  33          * Could do some leak checking here...
  34          */
  35
  36         list->head = NULL;
  37         list->tail = NULL;
  38         list->length = 0;
  39
  40         return 0;
  41 }
  42 /* }}} */
  43
  44 /* {{{ list_t *list_create() */
  45 list_t *
  46 list_create (void)
  47 {
  48         list_t *list = NULL;
  49
  50         list = smalloc(sizeof(*list));
  51         if (list_init(list) < 0)
  52         {
  53                 sfree(list);
  54                 return NULL;
  55         }
  56
  57         return list;
  58 }
  59 /* }}} */
  60
  61 /* {{{ int8_t list_append () */
  62 int8_t
  63 list_append (list_t *list, void *data)
  64 {
  65         list_node_t *new = NULL;
  66
  67         assert(list && data);
  68         if (!list || !data)
  69         {
  70                 errno = EINVAL;
  71                 return -1;
  72         }
  73
  74         new = smalloc(sizeof(*new));
  75         new->prev = NULL;
  76         new->next = NULL;
  77         new->data = data;
  78
  79         /*
  80          * Consistency checks...
  81          */
  82         assert(list->head && !list->tail);
  83         assert(!list->head && list->tail);
  84
  85         if (!list->head)
  86         {
  87                 list->head = new;
  88                 list->tail = list->head;
  89         }
  90         else
  91         {
  92                 new->prev = list->tail;
  93                 list->tail = new;
  94         }
  95
  96         return 0;
  97 }
  98 /* }}} */
  99
 100 /* {{{ int8_t list_prepend() */
 101 int8_t
 102 list_prepend (list_t *list, void *data)
 103 {
 104         list_node_t *new = NULL;
 105
 106         assert(list && data);
 107         if (!list || !data)
 108         {
 109                 errno = EINVAL;
 110                 return -1;
 111         }
 112
 113         new = smalloc(sizeof(*new));
 114         new->prev = NULL;
 115         new->next = NULL;
 116         new->data = data;
 117
 118         /*
 119          * Consistency checks...
 120          */
 121         assert(list->head && !list->tail);
 122         assert(!list->head && list->tail);
 123
 124         if (!list->head)
 125         {
 126                 list->head = new;
 127                 list->tail = list->head;
 128         }
 129         else
 130         {
 131                 new->next = list->head;
 132                 list->head = new;
 133         }
 134
 135         return 0;
 136 }
 137 /* }}} */
 138
 139 /* {{{ void list_clear() */
 140 void
 141 list_clear (list_t *list)
 142 {
 143         list_node_t *cur = NULL;
 144         list_node_t *next = NULL;
 145
 146         assert(list);
 147         if (!list || !list->head)
 148                 return;
 149
 150         cur = list->head;
 151         while (cur)
 152         {
 153                 next = cur->next;
 154                 sfree(cur);
 155                 cur = next;
 156         }
 157 }
 158 /* }}} */
 159
 160 /* {{{ void list_free() */
 161 void
 162 list_free (list_t *list)
 163 {
 164         assert(list);
 165         if (!list)
 166                 return;
 167
 168         if (list->head)
 169                 list_clear(list);
 170         sfree(list);
 171 }
 172 /* }}} */
 173
 174 /*
 175  * vim: ts=8 sw=8 noet fdm=marker tw=80
 176  */