Add linked lists implementation.

As discussed on the mailing lists, the various linked list
implementations we currently use at a dozen of different places in the
calcurse source tree are inconvenient and should be replaced by a single
generic solution.

This is a first approach to introduce such a generic implemetation. It
provides following functions:

* llist_init(): Initialize a list.

* llist_free_inner(): Loop through a list and free all items.

* llist_free(): Free the list itself (but not the individual items).

* llist_first(): Get the first item of a list.

* llist_nth(): Get the nth item of a list.

* llist_next(): Get the successor of a list item.

* llist_find_first(): Find an item using a callback function.

* llist_find_next(): Find the next match using a callback function.

* llist_find_nth(): Find the nth item in a list (using a callback).

* llist_get_data(): Get a pointer to the actual data of a list item.

* llist_add(): Add an item at the end of a list.

* llist_add_sorted(): Add an item to a sorted list (using a comparison
                      callback function).

* llist_remove(): Remove an item from a list.

Linked lists are stored in "llist_t" structures, list items are to be
stored in "llist_item_t" structs.

All of the llist_*() functions either expect a pointer to a llist_t
structure (in case the function operates on the list itself) or a
pointer to a llist_item_t (llist_*_next() and llist_get_data()).

Signed-off-by: Lukas Fleischer <calcurse@cryptocrack.de>

src/llist.c

@@ -0,0 +1,212 @@
+/*
+ * Calcurse - text-based organizer
+ *
+ * Copyright (c) 2004-2011 Frederic Culot <frederic@culot.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the
+ *        following disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the
+ *        following disclaimer in the documentation and/or other
+ *        materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Send your feedback or comments to : misc@calcurse.org
+ * Calcurse home page : http://calcurse.org
+ *
+ */
+
+#include "calcurse.h"                                                           
+
+void
+llist_init (llist_t *l)
+{
+  l->head = NULL;
+}
+
+void
+llist_free (llist_t *l)
+{
+  llist_item_t *i, *t;
+
+  for (i = l->head; i; i = t)
+    { 
+      t = i->next;
+      mem_free (i);
+    }
+}
+
+void
+llist_free_inner (llist_t *l, llist_fn_free_t fn_free)
+{
+  llist_item_t *i;
+
+  for (i = l->head; i; i = i->next)
+    {
+      if (i->data)
+        fn_free(i->data);
+    }
+}
+
+llist_item_t *
+llist_first (llist_t *l)
+{
+  return l->head;
+}
+
+llist_item_t *
+llist_nth (llist_t *l, int n)
+{
+  llist_item_t *i;
+
+  for (i = l->head; i && n > 0; n--)
+    i = i->next;
+
+  return i;
+}
+
+llist_item_t *
+llist_next (llist_item_t *i)
+{
+  return i ? i->next : NULL;
+}
+
+void *
+llist_get_data (llist_item_t *i)
+{
+  return i ? i->data : NULL;
+}
+
+void
+llist_add (llist_t *l, void *data)
+{
+  llist_item_t *o = mem_malloc (sizeof (llist_item_t));
+  llist_item_t *i;
+
+  if (o)
+    {
+      o->data = data;
+      o->next = NULL;
+
+      if (!l->head)
+        l->head = o;
+      else
+        {
+          for (i = l->head; i->next; i = i->next)
+            ;
+          i->next = o;
+        }
+    }
+}
+
+void
+llist_add_sorted (llist_t *l, void *data, llist_fn_cmp_t fn_cmp)
+{
+  llist_item_t *o = mem_malloc (sizeof (llist_item_t));
+  llist_item_t *i;
+
+  if (o)
+    {
+      o->data = data;
+      o->next = NULL;
+
+      if (!l->head)
+        l->head = o;
+      else if (fn_cmp(o->data, l->head->data) <= 0)
+        {
+          o->next = l->head;
+          l->head = o;
+        }
+      else
+        {
+          i = l->head;
+          while (i->next && fn_cmp(o->data, i->next->data) > 0)
+            i = i->next;
+          o->next = i->next;
+          i->next = o;
+        }
+    }
+}
+
+void
+llist_remove (llist_t *l, llist_item_t *i)
+{
+  llist_item_t *j = NULL;
+
+  if (l->head && i == l->head)
+    l->head = i->next;
+  else
+    {
+      for (j = l->head; j && j->next != i; j = j->next)
+        ;
+    }
+
+  if (i)
+    {
+      if (j)
+        j->next = i->next;
+      mem_free (i);
+    }
+}
+
+llist_item_t *
+llist_find_first (llist_t *l, long data, llist_fn_match_t fn_match)
+{
+  llist_item_t *i;
+
+  for (i = l->head; i; i = i->next)
+    {
+      if (fn_match (i->data, data))
+        return i;
+    }
+
+  return NULL;
+}
+
+llist_item_t *
+llist_find_next (llist_item_t *i, long data, llist_fn_match_t fn_match)
+{
+  if (i)
+    {
+      i = i->next;
+      for (; i; i = i->next)
+        {
+          if (fn_match (i->data, data))
+            return i;
+        }
+    }
+
+  return NULL;
+}
+
+llist_item_t *
+llist_find_nth (llist_t *l, int n, long data, llist_fn_match_t fn_match)
+{
+  llist_item_t *i;
+
+  for (i = l->head; i; i = i->next)
+    {
+      if (fn_match (i->data, data) && (n-- == 0))
+        return i;
+    }
+
+  return NULL;
+}