1 files changed, 1093 insertions, 0 deletions

diff --git a/libraries/eina/src/tests/evas_list.c b/libraries/eina/src/tests/evas_list.c
new file mode 100644
index 0000000..55e301f
--- /dev/null
+++ b/libraries/eina/src/tests/evas_list.c
@@ -0,0 +1,1093 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdlib.h>
+
+#include "Evas_Data.h"
+#include <evas_mempool.h>
+
+typedef struct _Evas_List_Accounting Evas_List_Accounting;
+
+struct _Evas_List_Accounting
+{
+   Evas_List *last;
+   int count;
+};
+
+static int _evas_list_alloc_error = 0;
+
+static Evas_Mempool _evas_list_mempool =
+{
+   sizeof(Evas_List),
+   320,
+   0, NULL, NULL
+};
+static Evas_Mempool _evas_list_accounting_mempool =
+{
+   sizeof(Evas_List_Accounting),
+   80,
+   0, NULL, NULL
+};
+
+/**
+ * @defgroup Evas_List_Data_Group Linked List Creation Functions
+ *
+ * Functions that add data to an Evas_List.
+ */
+
+/**
+ * Appends the given data to the given linked list.
+ *
+ * The following example code demonstrates how to ensure that the
+ * given data has been successfully appended.
+ *
+ * @code
+ * Evas_List *list = NULL;
+ * extern void *my_data;
+ *
+ * list = evas_list_append(list, my_data);
+ * if (evas_list_alloc_error())
+ *   {
+ *     fprintf(stderr, "ERROR: Memory is low. List allocation failed.\n");
+ *     exit(-1);
+ *   }
+ * @endcode
+ *
+ * @param   list The given list.  If @c NULL is given, then a new list
+ *               is created.
+ * @param   data The data to append.
+ * @return  A new list pointer that should be used in place of the one
+ *          given to this function if successful.  Otherwise, the old
+ *          pointer is returned.
+ * @ingroup Evas_List_Data_Group
+ */
+EAPI Evas_List *
+evas_list_append(Evas_List *list, const void *data)
+{
+   Evas_List *l, *new_l;
+
+   _evas_list_alloc_error = 0;
+   new_l = evas_mempool_malloc(&_evas_list_mempool, sizeof(Evas_List));
+   if (!new_l)
+     {
+        _evas_list_alloc_error = 1;
+        return list;
+     }
+
+   new_l->next = NULL;
+   new_l->data = (void *)data;
+   if (!list)
+     {
+        new_l->prev = NULL;
+        new_l->accounting = evas_mempool_malloc(&_evas_list_accounting_mempool,
+                                                sizeof(Evas_List_Accounting));
+        if (!new_l->accounting)
+          {
+             _evas_list_alloc_error = 1;
+             evas_mempool_free(&_evas_list_mempool, new_l);
+             return list;
+          }
+
+        new_l->accounting->last = new_l;
+        new_l->accounting->count = 1;
+        return new_l;
+     }
+
+   l = list->accounting->last;
+   l->next = new_l;
+   new_l->prev = l;
+   new_l->accounting = list->accounting;
+   list->accounting->last = new_l;
+   list->accounting->count++;
+   return list;
+}
+
+/**
+ * Prepends the given data to the given linked list.
+ *
+ * The following example code demonstrates how to ensure that the
+ * given data has been successfully prepended.
+ *
+ * Example:
+ * @code
+ * Evas_List *list = NULL;
+ * extern void *my_data;
+ *
+ * list = evas_list_prepend(list, my_data);
+ * if (evas_list_alloc_error())
+ *   {
+ *     fprintf(stderr, "ERROR: Memory is low. List allocation failed.\n");
+ *     exit(-1);
+ *   }
+ * @endcode
+ *
+ * @param   list The given list.
+ * @param   data The given data.
+ * @return  A new list pointer that should be used in place of the one
+ *          given to this function, if successful.  Otherwise, the old
+ *          pointer is returned.
+ * @ingroup Evas_List_Data_Group
+ */
+EAPI Evas_List *
+evas_list_prepend(Evas_List *list, const void *data)
+{
+   Evas_List *new_l;
+
+   _evas_list_alloc_error = 0;
+   new_l = evas_mempool_malloc(&_evas_list_mempool, sizeof(Evas_List));
+   if (!new_l)
+     {
+        _evas_list_alloc_error = 1;
+        return list;
+     }
+
+   new_l->prev = NULL;
+   new_l->data = (void *)data;
+   if (!list)
+     {
+        new_l->next = NULL;
+        new_l->accounting = evas_mempool_malloc(&_evas_list_accounting_mempool,
+                                                sizeof(Evas_List_Accounting));
+        if (!new_l->accounting)
+          {
+             _evas_list_alloc_error = 1;
+             evas_mempool_free(&_evas_list_mempool, new_l);
+             return list;
+          }
+
+        new_l->accounting->last = new_l;
+        new_l->accounting->count = 1;
+        return new_l;
+     }
+
+   new_l->next = list;
+   list->prev = new_l;
+   new_l->accounting = list->accounting;
+   list->accounting->count++;
+   return new_l;
+}
+
+/**
+ * Inserts the given data into the given linked list after the specified data.
+ *
+ * If @p relative is not in the list, @p data is appended to the end of the
+ * list.  If there are multiple instances of @p relative in the list,
+ * @p data is inserted after the first instance.
+ *
+ * The following example code demonstrates how to ensure that the
+ * given data has been successfully inserted.
+ *
+ * @code
+ * Evas_List *list = NULL;
+ * extern void *my_data;
+ * extern void *relative_member;
+ *
+ * list = evas_list_append(list, relative_member);
+ * if (evas_list_alloc_error())
+ *   {
+ *     fprintf(stderr, "ERROR: Memory is low. List allocation failed.\n");
+ *     exit(-1);
+ *   }
+ * list = evas_list_append_relative(list, my_data, relative_member);
+ * if (evas_list_alloc_error())
+ *   {
+ *     fprintf(stderr, "ERROR: Memory is low. List allocation failed.\n");
+ *     exit(-1);
+ *   }
+ * @endcode
+ *
+ * @param   list The given linked list.
+ * @param   data The given data.
+ * @param   relative The data to insert after.
+ * @return  A new list pointer that should be used in place of the one
+ *          given to this function if successful.  Otherwise, the old pointer
+ *          is returned.
+ * @ingroup Evas_List_Data_Group
+ */
+EAPI Evas_List *
+evas_list_append_relative(Evas_List *list,
+                          const void *data,
+                          const void *relative)
+{
+   Evas_List *l;
+
+   for (l = list; l; l = l->next)
+     {
+        if (l->data == relative)
+           return evas_list_append_relative_list(list, data, l);
+     }
+   return evas_list_append(list, data);
+}
+
+EAPI Evas_List *
+evas_list_append_relative_list(Evas_List *list,
+                               const void *data,
+                               Evas_List *relative)
+{
+   Evas_List *new_l;
+
+   if ((!list) || (!relative))
+      return evas_list_append(list, data);
+
+   _evas_list_alloc_error = 0;
+   new_l = evas_mempool_malloc(&_evas_list_mempool, sizeof(Evas_List));
+   if (!new_l)
+     {
+        _evas_list_alloc_error = 1;
+        return list;
+     }
+
+   new_l->data = (void *)data;
+   if (relative->next)
+     {
+        new_l->next = relative->next;
+        relative->next->prev = new_l;
+     }
+   else
+      new_l->next = NULL;
+
+   relative->next = new_l;
+   new_l->prev = relative;
+   new_l->accounting = list->accounting;
+   list->accounting->count++;
+   if (!new_l->next)
+      new_l->accounting->last = new_l;
+
+   return list;
+}
+
+/**
+ * Prepend a data pointer to a linked list before the member specified
+ * @param list The list handle to prepend @p data too
+ * @param data The data pointer to prepend to list @p list before @p relative
+ * @param relative The data pointer before which to insert @p data
+ * @return A new list handle to replace the old one
+
+ * Inserts the given data into the given linked list before the member
+ * specified.
+ *
+ * If @p relative is not in the list, @p data is prepended to the
+ * start of the list.  If there are multiple instances of @p relative
+ * in the list, @p data is inserted before the first instance.
+ *
+ * The following code example demonstrates how to ensure that the
+ * given data has been successfully inserted.
+ *
+ * @code
+ * Evas_List *list = NULL;
+ * extern void *my_data;
+ * extern void *relative_member;
+ *
+ * list = evas_list_append(list, relative_member);
+ * if (evas_list_alloc_error())
+ *   {
+ *     fprintf(stderr, "ERROR: Memory is low. List allocation failed.\n");
+ *     exit(-1);
+ *   }
+ * list = evas_list_prepend_relative(list, my_data, relative_member);
+ * if (evas_list_alloc_error())
+ *   {
+ *     fprintf(stderr, "ERROR: Memory is low. List allocation failed.\n");
+ *     exit(-1);
+ *   }
+ * @endcode
+ *
+ * @param   list The given linked list.
+ * @param   data The given data.
+ * @param   relative The data to insert before.
+ * @return  A new list pointer that should be used in place of the one
+ *          given to this function if successful.  Otherwise the old pointer
+ *          is returned.
+ * @ingroup Evas_List_Data_Group
+ */
+EAPI Evas_List *
+evas_list_prepend_relative(Evas_List *list,
+                           const void *data,
+                           const void *relative)
+{
+   Evas_List *l;
+
+   _evas_list_alloc_error = 0;
+   for (l = list; l; l = l->next)
+     {
+        if (l->data == relative)
+           return evas_list_prepend_relative_list(list, data, l);
+     }
+   return evas_list_prepend(list, data);
+}
+
+EAPI Evas_List *
+evas_list_prepend_relative_list(Evas_List *list,
+                                const void *data,
+                                Evas_List *relative)
+{
+   Evas_List *new_l;
+
+   if ((!list) || (!relative))
+      return evas_list_prepend(list, data);
+
+   _evas_list_alloc_error = 0;
+   new_l = evas_mempool_malloc(&_evas_list_mempool, sizeof(Evas_List));
+   if (!new_l)
+     {
+        _evas_list_alloc_error = 1;
+        return list;
+     }
+
+   new_l->data = (void *)data;
+   new_l->prev = relative->prev;
+   new_l->next = relative;
+   if (relative->prev)
+      relative->prev->next = new_l;
+
+   relative->prev = new_l;
+   new_l->accounting = list->accounting;
+   list->accounting->count++;
+   if (new_l->prev)
+      return list;
+
+   return new_l;
+}
+
+/**
+ * @defgroup Evas_List_Remove_Group Linked List Remove Functions
+ *
+ * Functions that remove data from linked lists.
+ */
+
+/**
+ * Removes the first instance of the specified data from the given list.
+ *
+ * If the specified data is not in the given list, nothing is done.
+ *
+ * @param   list The given list.
+ * @param   data The specified data.
+ * @return  A new list pointer that should be used in place of the one
+ *          passed to this functions.
+ * @ingroup Evas_List_Remove_Group
+ */
+EAPI Evas_List *
+evas_list_remove(Evas_List *list, const void *data)
+{
+   Evas_List *l;
+
+   for (l = list; l; l = l->next)
+     {
+        if (l->data == data)
+           return evas_list_remove_list(list, l);
+     }
+   return list;
+}
+
+/**
+ * Removes the specified data
+ *
+ * Remove a specified member from a list
+ * @param list The list handle to remove @p remove_list from
+ * @param remove_list The list node which is to be removed
+ * @return A new list handle to replace the old one
+ *
+ * Calling this function takes the list node @p remove_list and removes it
+ * from the list @p list, freeing the list node structure @p remove_list.
+ *
+ * Example:
+ * @code
+ * extern Evas_List *list;
+ * Evas_List *l;
+ * extern void *my_data;
+ *
+ * for (l = list; l; l= l->next)
+ *   {
+ *     if (l->data == my_data)
+ *       {
+ *         list = evas_list_remove_list(list, l);
+ *         break;
+ *       }
+ *   }
+ * @endcode
+ * @ingroup Evas_List_Remove_Group
+ */
+EAPI Evas_List *
+evas_list_remove_list(Evas_List *list, Evas_List *remove_list)
+{
+   Evas_List *return_l;
+
+   if (!list)
+      return NULL;
+
+   if (!remove_list)
+      return list;
+
+   if (remove_list->next)
+      remove_list->next->prev = remove_list->prev;
+
+   if (remove_list->prev)
+     {
+        remove_list->prev->next = remove_list->next;
+        return_l = list;
+     }
+   else
+      return_l = remove_list->next;
+
+   if (remove_list == list->accounting->last)
+      list->accounting->last = remove_list->prev;
+
+   list->accounting->count--;
+   if (list->accounting->count == 0)
+             evas_mempool_free(&_evas_list_accounting_mempool, list->accounting);
+
+             evas_mempool_free(&_evas_list_mempool,            remove_list);
+   return return_l;
+}
+
+/**
+ * Moves the specified data to the head of the list
+ *
+ * Move a specified member to the head of the list
+ * @param list The list handle to move @p inside
+ * @param move_list The list node which is to be moved
+ * @return A new list handle to replace the old one
+ *
+ * Calling this function takes the list node @p move_list and moves it
+ * to the front of the @p list.
+ *
+ * Example:
+ * @code
+ * extern Evas_List *list;
+ * Evas_List *l;
+ * extern void *my_data;
+ *
+ * for (l = list; l; l= l->next)
+ *   {
+ *     if (l->data == my_data)
+ *       {
+ *         list = evas_list_promote_list(list, l);
+ *         break;
+ *       }
+ *   }
+ * @endcode
+ * @ingroup Evas_List_Promote_Group
+ */
+EAPI Evas_List *
+evas_list_promote_list(Evas_List *list, Evas_List *move_list)
+{
+   Evas_List *return_l;
+
+   if (!list)
+      return NULL;
+
+   if (!move_list)
+      return list;
+
+   if (move_list == list)
+      return list;
+
+   if (move_list->next)
+      move_list->next->prev = move_list->prev;
+
+   if (move_list->prev)
+     {
+        move_list->prev->next = move_list->next;
+        return_l = list;
+     }
+   else
+      return_l = move_list->next;
+
+   if (move_list == list->accounting->last)
+      list->accounting->last = move_list->prev;
+
+   move_list->prev = return_l->prev;
+   if (return_l->prev)
+      return_l->prev->next = move_list;
+
+   return_l->prev = move_list;
+   move_list->next = return_l;
+   return move_list;
+}
+
+
+
+/**
+ * @defgroup Evas_List_Find_Group Linked List Find Functions
+ *
+ * Functions that find specified data in a linked list.
+ */
+
+/**
+ * Find a member of a list and return the member
+ * @param list The list handle to search for @p data
+ * @param data The data pointer to find in the list @p list
+ * @return The found member data pointer
+ *
+ * A call to this function will search the list @p list from beginning to end
+ * for the first member whose data pointer is @p data. If it is found, @p data
+ * will be returned, otherwise NULL will be returned.
+ *
+ * Example:
+ * @code
+ * extern Evas_List *list;
+ * extern void *my_data;
+ *
+ * if (evas_list_find(list, my_data) == my_data)
+ *   {
+ *     printf("Found member %p\n", my_data);
+ *   }
+ * @endcode
+ * @ingroup Evas_List_Find_Group
+ */
+EAPI void *
+evas_list_find(const Evas_List *list, const void *data)
+{
+   const Evas_List *l;
+
+   for (l = list; l; l = l->next)
+     {
+        if (l->data == data)
+           return (void *)data;
+     }
+   return NULL;
+}
+
+/**
+ * Find a member of a list and return the list node containing that member
+ * @param list The list handle to search for @p data
+ * @param data The data pointer to find in the list @p list
+ * @return The found members list node
+ *
+ * A call to this function will search the list @p list from beginning to end
+ * for the first member whose data pointer is @p data. If it is found, the
+ * list node containing the specified member will be returned, otherwise NULL
+ * will be returned.
+ *
+ * Example:
+ * @code
+ * extern Evas_List *list;
+ * extern void *my_data;
+ * Evas_List *found_node;
+ *
+ * found_node = evas_list_find_list(list, my_data);
+ * if (found_node)
+ *   {
+ *     printf("Found member %p\n", found_node->data);
+ *   }
+ * @endcode
+ * @ingroup Evas_List_Find_Group
+ */
+EAPI Evas_List *
+evas_list_find_list(const Evas_List *list, const void *data)
+{
+   const Evas_List *l;
+
+   for (l = list; l; l = l->next)
+     {
+        if (l->data == data)
+           return (Evas_List *)l;
+     }
+   return NULL;
+}
+
+/**
+ * Free an entire list and all the nodes, ignoring the data contained
+ * @param list The list to free
+ * @return A NULL pointer
+ *
+ * This function will free all the list nodes in list specified by @p list.
+ *
+ * Example:
+ * @code
+ * extern Evas_List *list;
+ *
+ * list = evas_list_free(list);
+ * @endcode
+ * @ingroup Evas_List_Remove_Group
+ */
+EAPI Evas_List *
+evas_list_free(Evas_List *list)
+{
+   Evas_List *l, *free_l;
+
+   if (!list)
+      return NULL;
+
+             evas_mempool_free(&_evas_list_accounting_mempool, list->accounting);
+   for (l = list; l; )
+     {
+        free_l = l;
+        l = l->next;
+             evas_mempool_free(&_evas_list_mempool, free_l);
+     }
+   return NULL;
+}
+
+/**
+ * @defgroup Evas_List_Traverse_Group Linked List Traverse Functions
+ *
+ * Functions that you can use to traverse a linked list.
+ */
+
+/**
+ * Get the last list node in the list
+ * @param list The list to get the last list node from
+ * @return The last list node in the list @p list
+ *
+ * This function will return the last list node in the list (or NULL if the
+ * list is empty).
+ *
+ * NB: This is a order-1 operation (it takes the same short time regardless of
+ * the length of the list).
+ *
+ * Example:
+ * @code
+ * extern Evas_List *list;
+ * Evas_List *last, *l;
+ *
+ * last = evas_list_last(list);
+ * printf("The list in reverse:\n");
+ * for (l = last; l; l = l->prev)
+ *   {
+ *     printf("%p\n", l->data);
+ *   }
+ * @endcode
+ * @ingroup Evas_List_Traverse_Group
+ */
+EAPI Evas_List *
+evas_list_last(const Evas_List *list)
+{
+   if (!list)
+      return NULL;
+
+   return list->accounting->last;
+}
+
+/**
+ * Get the next list node after the specified list node
+ * @param list The list node to get the next list node from
+ * @return The next list node, or NULL if no next list node exists
+ *
+ * This function returns the next list node after the current one. It is
+ * equivalent to list->next.
+ *
+ * Example:
+ * @code
+ * extern Evas_List *list;
+ * Evas_List *l;
+ *
+ * printf("The list:\n");
+ * for (l = list; l; l = evas_list_next(l))
+ *   {
+ *     printf("%p\n", l->data);
+ *   }
+ * @endcode
+ * @ingroup Evas_List_Traverse_Group
+ */
+EAPI Evas_List *
+evas_list_next(const Evas_List *list)
+{
+   if (!list)
+      return NULL;
+
+   return list->next;
+}
+
+/**
+ * Get the previous list node before the specified list node
+ * @param list The list node to get the previous list node from
+ * @return The previous list node, or NULL if no previous list node exists
+ *
+ * This function returns the previous list node before the current one. It is
+ * equivalent to list->prev.
+ *
+ * Example:
+ * @code
+ * extern Evas_List *list;
+ * Evas_List *last, *l;
+ *
+ * last = evas_list_last(list);
+ * printf("The list in reverse:\n");
+ * for (l = last; l; l = evas_list_prev(l))
+ *   {
+ *     printf("%p\n", l->data);
+ *   }
+ * @endcode
+ * @ingroup Evas_List_Traverse_Group
+ */
+EAPI Evas_List *
+evas_list_prev(const Evas_List *list)
+{
+   if (!list)
+      return NULL;
+
+   return list->prev;
+}
+
+/**
+ * @defgroup Evas_List_General_Group Linked List General Functions
+ *
+ * Miscellaneous functions that work on linked lists.
+ */
+
+/**
+ * Get the list node data member
+ * @param list The list node to get the data member of
+ * @return The data member from the list node @p list
+ *
+ * This function returns the data member of the specified list node @p list.
+ * It is equivalent to list->data.
+ *
+ * Example:
+ * @code
+ * extern Evas_List *list;
+ * Evas_List *l;
+ *
+ * printf("The list:\n");
+ * for (l = list; l; l = evas_list_next(l))
+ *   {
+ *     printf("%p\n", evas_list_data(l));
+ *   }
+ * @endcode
+ * @ingroup Evas_List_General_Group
+ */
+EAPI void *
+evas_list_data(const Evas_List *list)
+{
+   if (!list)
+      return NULL;
+
+   return list->data;
+}
+
+/**
+ * Get the count of the number of items in a list
+ * @param list The list whose count to return
+ * @return The number of members in the list @p list
+ *
+ * This function returns how many members in the specified list: @p list. If
+ * the list is empty (NULL), 0 is returned.
+ *
+ * NB: This is an order-1 operation and takes the same time regardless of the
+ * length of the list.
+ *
+ * Example:
+ * @code
+ * extern Evas_List *list;
+ *
+ * printf("The list has %i members\n", evas_list_count(list));
+ * @endcode
+ * @ingroup Evas_List_General_Group
+ */
+EAPI int
+evas_list_count(const Evas_List *list)
+{
+   if (!list)
+      return 0;
+
+   return list->accounting->count;
+}
+
+/**
+ * Get the nth member's data pointer in a list
+ * @param list The list to get member number @p n from
+ * @param n The number of the element (0 being the first)
+ * @return The data pointer stored in the specified element
+ *
+ * This function returns the data pointer of element number @p n, in the list
+ * @p list. The first element in the array is element number 0. If the element
+ * number @p n does not exist, NULL will be returned.
+ *
+ * Example:
+ * @code
+ * extern Evas_List *list;
+ * extern int number;
+ * void *data;
+ *
+ * data = evas_list_nth(list, number);
+ * if (data)
+ *   printf("Element number %i has data %p\n", number, data);
+ * @endcode
+ * @ingroup Evas_List_Find_Group
+ */
+EAPI void *
+evas_list_nth(const Evas_List *list, int n)
+{
+   Evas_List *l;
+
+   l = evas_list_nth_list(list, n);
+   return l ? l->data : NULL;
+}
+
+/**
+ * Get the nth member's list node in a list
+ * @param list The list to get member number @p n from
+ * @param n The number of the element (0 being the first)
+ * @return The list node stored in the numbered element
+ *
+ * This function returns the list node of element number @p n, in the list
+ * @p list. The first element in the array is element number 0. If the element
+ * number @p n does not exist, NULL will be returned.
+ *
+ * Example:
+ * @code
+ * extern Evas_List *list;
+ * extern int number;
+ * Evas_List *nth_list;
+ *
+ * nth_list = evas_list_nth_list(list, number);
+ * if (nth_list)
+ *   printf("Element number %i has data %p\n", number, nth_list->data);
+ * @endcode
+ * @ingroup Evas_List_Find_Group
+ */
+EAPI Evas_List *
+evas_list_nth_list(const Evas_List *list, int n)
+{
+   int i;
+   const Evas_List *l;
+
+   /* check for non-existing nodes */
+   if ((!list) || (n < 0) ||
+       (n > (list->accounting->count - 1)))
+      return NULL;
+
+   /* if the node is in the 2nd half of the list, search from the end
+    * else, search from the beginning.
+    */
+   if (n > (list->accounting->count / 2))
+      for (i = list->accounting->count - 1,
+           l = list->accounting->last;
+           l;
+           l = l->prev, i--)
+        {
+           if (i == n)
+              return (Evas_List *)l;
+        }
+   else
+      for (i = 0, l = list; l; l = l->next, i++)
+        {
+           if (i == n)
+              return (Evas_List *)l;
+        }
+
+   return NULL;
+}
+
+/**
+ * @defgroup Evas_List_Ordering_Group Linked List Ordering Functions
+ *
+ * Functions that change the ordering of data in a linked list.
+ */
+
+/**
+ * Reverse all the elements in the list
+ * @param list The list to reverse
+ * @return The list after it has been reversed
+ *
+ * This takes a list @p list, and reverses the order of all elements in the
+ * list, so the last member is now first, and so on.
+ *
+ * Example:
+ * @code
+ * extern Evas_List *list;
+ *
+ * list = evas_list_reverse(list);
+ * @endcode
+ * @ingroup Evas_List_Ordering_Group
+ */
+EAPI Evas_List *
+evas_list_reverse(Evas_List *list)
+{
+   Evas_List *l1, *l2;
+
+   if (!list)
+      return NULL;
+
+   l1 = list;
+   l2 = list->accounting->last;
+   while (l1 != l2)
+     {
+        void *data;
+
+        data = l1->data;
+        l1->data = l2->data;
+        l2->data = data;
+        l1 = l1->next;
+        if (l1 == l2)
+           break;
+
+        l2 = l2->prev;
+     }
+
+   return list;
+}
+
+/**
+ * Sort a list according to the ordering func will return
+ * @param list The list handle to sort
+ * @param size The length of the list to sort
+ * @param func A function pointer that can handle comparing the list data
+ * nodes
+ * @return A new sorted list
+ *
+ * This function sorts your list.  The data in your nodes can be arbitrary,
+ * you just have to be smart enough to know what kind of data is in your
+ * lists
+ *
+ * Example:
+ * @code
+ * int
+ * sort_cb(void *d1, void *d2)
+ * {
+ *   const char *txt = NULL;
+ *    const char *txt2 = NULL;
+ *
+ *    if(!d1) return(1);
+ *    if(!d2) return(-1);
+ *
+ *    return(strcmp((const char*)d1, (const char*)d2));
+ * }
+ * extern Evas_List *list;
+ *
+ * list = evas_list_sort(list, evas_list_count(list), sort_cb);
+ * if (evas_list_alloc_error())
+ *   {
+ *     fprintf(stderr, "ERROR: Memory is low. List Sorting failed.\n");
+ *     exit(-1);
+ *   }
+ * @endcode
+ * @ingroup Evas_List_Ordering_Group
+ */
+EAPI Evas_List *
+evas_list_sort(Evas_List *list, int size, int (*func)(void *, void *))
+{
+   Evas_List *last;
+   unsigned int list_number;
+   unsigned int middle;
+   int list_size;
+
+   if (!list || !func)
+      return NULL;
+
+   /* if the caller specified an invalid size, sort the whole list */
+   if ((size <= 0) ||
+       (size > list->accounting->count))
+      size = list->accounting->count;
+
+   last = list->accounting->last;
+   middle = size - size / 2;
+
+   for (list_number = middle, list_size = 1;
+        list_size < middle * 2;
+        list_number >>= 1, list_size <<= 1)
+     {
+        Evas_List *head1 = list;
+        unsigned int limit = size;
+        unsigned int process_list;
+        unsigned int pass_number;
+        unsigned int split_size = list_size;
+
+        for (process_list = 0; process_list < list_number + 1; ++process_list)
+          {
+             Evas_List *head2;
+             unsigned int size_sum;
+             int size1, size2;
+             int i;
+
+             size1 = limit < split_size ? limit : split_size;
+             limit -= size1;
+
+             size2 = limit < split_size ? limit : split_size;
+             limit -= size2;
+
+             size_sum = size1 + size2;
+
+             for (head2 = head1, i = 0; i < size1; ++i)
+                head2 = evas_list_next (head2);
+
+             for (pass_number = 0; pass_number < size_sum; ++pass_number)
+               {
+                  Evas_List *next;
+                  Evas_List *prev1;
+                  Evas_List *prev2;
+
+                  if (size1 == 0 || !head1) /* List1 is empty, head1 is already at the end of the list. So only need to update head2 */
+                    {
+                       for (; pass_number < size_sum; ++pass_number)
+                          head2 = evas_list_next (head2);
+                       break;
+                    }
+                  else
+                  if (size2 == 0 || !head2) /* List2 is empty, just leave */
+                     break;
+                  else
+                  if (func (head1->data, head2->data) < 0)
+                    {
+                       head1 = evas_list_next (head1);
+                       --size1;
+                    }
+                  else
+                    {
+                       next = evas_list_next (head2);
+                       prev1 = evas_list_prev (head1);
+                       prev2 = evas_list_prev (head2);
+
+                       if (next)
+                          next->prev = prev2;
+
+                       if (prev1)
+                          prev1->next = head2;
+
+                       if (prev2)
+                          prev2->next = next;
+
+                       head2->prev = prev1;
+                       head2->next = head1;
+                       head1->prev = head2;
+
+                       --size2;
+
+                       if (head1 == list)
+                          list = head2;
+
+                       if (head2 == last)
+                          last = prev2;
+
+                       head2 = next;
+                    }
+               }
+             head1 = head2;
+          }
+     }
+
+   list->accounting->last = last;
+   return list;
+}
+/**
+ * Return the memory allocation failure flag after any operation needin allocation
+ * @return The state of the allocation flag
+ *
+ * This function returns the state of the memory allocation flag. This flag is
+ * set if memory allocations during evas_list_append(), evas_list_prepend(),
+ * evas_list_append_relative(), or evas_list_prepend_relative() fail. If they
+ * do fail, 1 will be returned, otherwise 0 will be returned. The flag will
+ * remain in its current state until the next call that requires allocation
+ * is called, and is then reset.
+ *
+ * Example:
+ * @code
+ * Evas_List *list = NULL;
+ * extern void *my_data;
+ *
+ * list = evas_list_append(list, my_data);
+ * if (evas_list_alloc_error())
+ *   {
+ *     fprintf(stderr, "ERROR: Memory is low. List allocation failed.\n");
+ *     exit(-1);
+ *   }
+ * @endcode
+ * @ingroup Evas_List_General_Group
+ */
+EAPI int
+evas_list_alloc_error(void)
+{
+   return _evas_list_alloc_error;
+}