diff -r 000000000000 -r e4d67989cc36 glib/libglib/src/gslist.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/glib/libglib/src/gslist.c	Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,624 @@
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
+ * Portions copyright (c) 2006 Nokia Corporation.  All rights reserved.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+/*
+ * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
+ * file for a list of people on the GLib Team.  See the ChangeLog
+ * files for a list of changes.  These files are distributed with
+ * GLib at ftp://ftp.gtk.org/pub/gtk/. 
+ */
+
+/* 
+ * MT safe
+ */
+
+#include "config.h"
+
+#include "glib.h"
+#include "galias.h"
+
+
+EXPORT_C void g_slist_push_allocator (gpointer dummy) { /* present for binary compat only */ }
+EXPORT_C void g_slist_pop_allocator  (void)           { /* present for binary compat only */ }
+
+#define _g_slist_alloc0()       g_slice_new0 (GSList)
+#define _g_slist_alloc()        g_slice_new (GSList)
+#define _g_slist_free1(slist)   g_slice_free (GSList, slist)
+
+EXPORT_C GSList*
+g_slist_alloc (void)
+{
+  return _g_slist_alloc0 ();
+}
+
+EXPORT_C void
+g_slist_free (GSList *slist)
+{
+  g_slice_free_chain (GSList, slist, next);
+}
+
+EXPORT_C void
+g_slist_free_1 (GSList *slist)
+{
+  _g_slist_free1 (slist);
+}
+
+EXPORT_C GSList*
+g_slist_append (GSList   *list,
+		gpointer  data)
+{
+  GSList *new_list;
+  GSList *last;
+
+  new_list = _g_slist_alloc ();
+  new_list->data = data;
+  new_list->next = NULL;
+
+  if (list)
+    {
+      last = g_slist_last (list);
+      /* g_assert (last != NULL); */
+      last->next = new_list;
+
+      return list;
+    }
+  else
+    return new_list;
+}
+
+EXPORT_C GSList*
+g_slist_prepend (GSList   *list,
+		 gpointer  data)
+{
+  GSList *new_list;
+
+  new_list = _g_slist_alloc ();
+  new_list->data = data;
+  new_list->next = list;
+
+  return new_list;
+}
+
+EXPORT_C GSList*
+g_slist_insert (GSList   *list,
+		gpointer  data,
+		gint      position)
+{
+  GSList *prev_list;
+  GSList *tmp_list;
+  GSList *new_list;
+
+  if (position < 0)
+    return g_slist_append (list, data);
+  else if (position == 0)
+    return g_slist_prepend (list, data);
+
+  new_list = _g_slist_alloc ();
+  
+  new_list->data = data;
+
+  if (!list)
+    {
+      new_list->next = NULL;
+      return new_list;
+    }
+
+  prev_list = NULL;
+  tmp_list = list;
+
+  while ((position-- > 0) && tmp_list)
+    {
+      prev_list = tmp_list;
+      tmp_list = tmp_list->next;
+    }
+
+  if (prev_list)
+    {
+      new_list->next = prev_list->next;
+      prev_list->next = new_list;
+    }
+  else
+    {
+      new_list->next = list;
+      list = new_list;
+    }
+
+  return list;
+}
+
+EXPORT_C GSList*
+g_slist_insert_before (GSList  *slist,
+		       GSList  *sibling,
+		       gpointer data)
+{
+  if (!slist)
+    {
+      slist = _g_slist_alloc ();
+      slist->data = data;
+      slist->next = NULL;
+      g_return_val_if_fail (sibling == NULL, slist);
+      return slist;
+    }
+  else
+    {
+      GSList *node, *last = NULL;
+
+      for (node = slist; node; last = node, node = last->next)
+	if (node == sibling)
+	  break;
+      if (!last)
+	{
+	  node = _g_slist_alloc ();
+	  
+	  node->data = data;
+	  node->next = slist;
+
+	  return node;
+	}
+      else
+	{
+	  node = _g_slist_alloc ();
+	  node->data = data;
+	  node->next = last->next;
+	  last->next = node;
+
+	  return slist;
+	}
+    }
+}
+
+EXPORT_C GSList *
+g_slist_concat (GSList *list1, GSList *list2)
+{
+  if (list2)
+    {
+      if (list1)
+	g_slist_last (list1)->next = list2;
+      else
+	list1 = list2;
+    }
+
+  return list1;
+}
+
+EXPORT_C GSList*
+g_slist_remove (GSList        *list,
+		gconstpointer  data)
+{
+  GSList *tmp, *prev = NULL;
+
+  tmp = list;
+  while (tmp)
+    {
+      if (tmp->data == data)
+	{
+	  if (prev)
+	    prev->next = tmp->next;
+	  else
+	    list = tmp->next;
+
+	  g_slist_free_1 (tmp);
+	  break;
+	}
+      prev = tmp;
+      tmp = prev->next;
+    }
+
+  return list;
+}
+
+EXPORT_C GSList*
+g_slist_remove_all (GSList        *list,
+		    gconstpointer  data)
+{
+  GSList *tmp, *prev = NULL;
+
+  tmp = list;
+  while (tmp)
+    {
+      if (tmp->data == data)
+	{
+	  GSList *next = tmp->next;
+
+	  if (prev)
+	    prev->next = next;
+	  else
+	    list = next;
+	  
+	  g_slist_free_1 (tmp);
+	  tmp = next;
+	}
+      else
+	{
+	  prev = tmp;
+	  tmp = prev->next;
+	}
+    }
+
+  return list;
+}
+
+static inline GSList*
+_g_slist_remove_link (GSList *list,
+		      GSList *link)
+{
+  GSList *tmp;
+  GSList *prev;
+
+  prev = NULL;
+  tmp = list;
+
+  while (tmp)
+    {
+      if (tmp == link)
+	{
+	  if (prev)
+	    prev->next = tmp->next;
+	  if (list == tmp)
+	    list = list->next;
+
+	  tmp->next = NULL;
+	  break;
+	}
+
+      prev = tmp;
+      tmp = tmp->next;
+    }
+
+  return list;
+}
+
+EXPORT_C GSList* 
+g_slist_remove_link (GSList *list,
+		     GSList *link)
+{
+  return _g_slist_remove_link (list, link);
+}
+
+EXPORT_C GSList*
+g_slist_delete_link (GSList *list,
+		     GSList *link)
+{
+  list = _g_slist_remove_link (list, link);
+  _g_slist_free1 (link);
+
+  return list;
+}
+
+EXPORT_C GSList*
+g_slist_copy (GSList *list)
+{
+  GSList *new_list = NULL;
+
+  if (list)
+    {
+      GSList *last;
+
+      new_list = _g_slist_alloc ();
+      new_list->data = list->data;
+      last = new_list;
+      list = list->next;
+      while (list)
+	{
+	  last->next = _g_slist_alloc ();
+	  last = last->next;
+	  last->data = list->data;
+	  list = list->next;
+	}
+      last->next = NULL;
+    }
+
+  return new_list;
+}
+
+EXPORT_C GSList*
+g_slist_reverse (GSList *list)
+{
+  GSList *prev = NULL;
+  
+  while (list)
+    {
+      GSList *next = list->next;
+
+      list->next = prev;
+      
+      prev = list;
+      list = next;
+    }
+  
+  return prev;
+}
+
+EXPORT_C GSList*
+g_slist_nth (GSList *list,
+	     guint   n)
+{
+  while (n-- > 0 && list)
+    list = list->next;
+
+  return list;
+}
+
+EXPORT_C gpointer
+g_slist_nth_data (GSList   *list,
+		  guint     n)
+{
+  while (n-- > 0 && list)
+    list = list->next;
+
+  return list ? list->data : NULL;
+}
+
+EXPORT_C GSList*
+g_slist_find (GSList        *list,
+	      gconstpointer  data)
+{
+  while (list)
+    {
+      if (list->data == data)
+	break;
+      list = list->next;
+    }
+
+  return list;
+}
+
+EXPORT_C GSList*
+g_slist_find_custom (GSList        *list,
+		     gconstpointer  data,
+		     GCompareFunc   func)
+{
+  g_return_val_if_fail (func != NULL, list);
+
+  while (list)
+    {
+      if (! func (list->data, data))
+	return list;
+      list = list->next;
+    }
+
+  return NULL;
+}
+
+EXPORT_C gint
+g_slist_position (GSList *list,
+		  GSList *link)
+{
+  gint i;
+
+  i = 0;
+  while (list)
+    {
+      if (list == link)
+	return i;
+      i++;
+      list = list->next;
+    }
+
+  return -1;
+}
+
+EXPORT_C gint
+g_slist_index (GSList        *list,
+	       gconstpointer  data)
+{
+  gint i;
+
+  i = 0;
+  while (list)
+    {
+      if (list->data == data)
+	return i;
+      i++;
+      list = list->next;
+    }
+
+  return -1;
+}
+
+EXPORT_C GSList*
+g_slist_last (GSList *list)
+{
+  if (list)
+    {
+      while (list->next)
+	list = list->next;
+    }
+
+  return list;
+}
+
+EXPORT_C guint
+g_slist_length (GSList *list)
+{
+  guint length;
+
+  length = 0;
+  while (list)
+    {
+      length++;
+      list = list->next;
+    }
+
+  return length;
+}
+
+EXPORT_C void
+g_slist_foreach (GSList   *list,
+		 GFunc     func,
+		 gpointer  user_data)
+{
+  while (list)
+    {
+      GSList *next = list->next;
+      (*func) (list->data, user_data);
+      list = next;
+    }
+}
+
+static GSList*
+g_slist_insert_sorted_real (GSList   *list,
+			    gpointer  data,
+			    GFunc     func,
+			    gpointer  user_data)
+{
+  GSList *tmp_list = list;
+  GSList *prev_list = NULL;
+  GSList *new_list;
+  gint cmp;
+ 
+  g_return_val_if_fail (func != NULL, list);
+
+  if (!list)
+    {
+      new_list = _g_slist_alloc ();
+      new_list->data = data;
+      new_list->next = NULL;
+      return new_list;
+    }
+ 
+  cmp = ((GCompareDataFunc) func) (data, tmp_list->data, user_data);
+ 
+  while ((tmp_list->next) && (cmp > 0))
+    {
+      prev_list = tmp_list;
+      tmp_list = tmp_list->next;
+
+      cmp = ((GCompareDataFunc) func) (data, tmp_list->data, user_data);
+    }
+
+  new_list = _g_slist_alloc ();
+  new_list->data = data;
+
+  if ((!tmp_list->next) && (cmp > 0))
+    {
+      tmp_list->next = new_list;
+      new_list->next = NULL;
+      return list;
+    }
+  
+  if (prev_list)
+    {
+      prev_list->next = new_list;
+      new_list->next = tmp_list;
+      return list;
+    }
+  else
+    {
+      new_list->next = list;
+      return new_list;
+    }
+}
+
+EXPORT_C GSList*
+g_slist_insert_sorted (GSList       *list,
+                       gpointer      data,
+                       GCompareFunc  func)
+{
+  return g_slist_insert_sorted_real (list, data, (GFunc) func, NULL);
+}
+
+EXPORT_C GSList*
+g_slist_insert_sorted_with_data (GSList           *list,
+				 gpointer          data,
+				 GCompareDataFunc  func,
+				 gpointer          user_data)
+{
+  return g_slist_insert_sorted_real (list, data, (GFunc) func, user_data);
+}
+
+static GSList *
+g_slist_sort_merge (GSList   *l1, 
+		    GSList   *l2,
+		    GFunc     compare_func,
+		    gpointer  user_data)
+{
+  GSList list, *l;
+  gint cmp;
+
+  l=&list;
+
+  while (l1 && l2)
+    {
+      cmp = ((GCompareDataFunc) compare_func) (l1->data, l2->data, user_data);
+
+      if (cmp <= 0)
+        {
+	  l=l->next=l1;
+	  l1=l1->next;
+        } 
+      else 
+	{
+	  l=l->next=l2;
+	  l2=l2->next;
+        }
+    }
+  l->next= l1 ? l1 : l2;
+  
+  return list.next;
+}
+
+static GSList *
+g_slist_sort_real (GSList   *list,
+		   GFunc     compare_func,
+		   gpointer  user_data)
+{
+  GSList *l1, *l2;
+
+  if (!list) 
+    return NULL;
+  if (!list->next) 
+    return list;
+
+  l1 = list; 
+  l2 = list->next;
+
+  while ((l2 = l2->next) != NULL)
+    {
+      if ((l2 = l2->next) == NULL) 
+	break;
+      l1=l1->next;
+    }
+  l2 = l1->next; 
+  l1->next = NULL;
+
+  return g_slist_sort_merge (g_slist_sort_real (list, compare_func, user_data),
+			     g_slist_sort_real (l2, compare_func, user_data),
+			     compare_func,
+			     user_data);
+}
+
+EXPORT_C GSList *
+g_slist_sort (GSList       *list,
+	      GCompareFunc  compare_func)
+{
+  return g_slist_sort_real (list, (GFunc) compare_func, NULL);
+}
+
+EXPORT_C GSList *
+g_slist_sort_with_data (GSList           *list,
+			GCompareDataFunc  compare_func,
+			gpointer          user_data)
+{
+  return g_slist_sort_real (list, (GFunc) compare_func, user_data);
+}
+
+#define __G_SLIST_C__
+#include "galiasdef.c"