1998-06-11 01:21:14 +02:00
|
|
|
/* GLIB - Library of useful routines for C programming
|
|
|
|
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
|
|
|
*
|
|
|
|
* This library is free software; you can redistribute it and/or
|
2000-07-26 13:02:02 +02:00
|
|
|
* modify it under the terms of the GNU Lesser General Public
|
1998-06-11 01:21:14 +02:00
|
|
|
* 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
|
2000-07-26 13:02:02 +02:00
|
|
|
* Lesser General Public License for more details.
|
1998-06-11 01:21:14 +02:00
|
|
|
*
|
2000-07-26 13:02:02 +02:00
|
|
|
* You should have received a copy of the GNU Lesser General Public
|
1998-06-11 01:21:14 +02:00
|
|
|
* License along with this library; if not, write to the
|
|
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
* Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
1998-12-15 06:28:02 +01:00
|
|
|
|
1999-02-24 07:14:27 +01:00
|
|
|
/*
|
2000-07-26 13:02:02 +02:00
|
|
|
* Modified by the GLib Team and others 1997-2000. See the AUTHORS
|
1999-02-24 07:14:27 +01:00
|
|
|
* 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/.
|
|
|
|
*/
|
|
|
|
|
1998-12-15 06:28:02 +01:00
|
|
|
/*
|
|
|
|
* MT safe
|
|
|
|
*/
|
|
|
|
|
2000-12-19 10:35:44 +01:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include <config.h>
|
|
|
|
#endif
|
|
|
|
|
1998-06-11 01:21:14 +02:00
|
|
|
#include "glib.h"
|
|
|
|
|
|
|
|
|
2000-12-19 10:35:44 +01:00
|
|
|
#ifndef DISABLE_MEM_POOLS
|
1998-11-24 13:18:22 +01:00
|
|
|
struct _GAllocator /* from gmem.c */
|
1998-06-11 01:21:14 +02:00
|
|
|
{
|
1998-11-24 13:18:22 +01:00
|
|
|
gchar *name;
|
|
|
|
guint16 n_preallocs;
|
|
|
|
guint is_unused : 1;
|
|
|
|
guint type : 4;
|
|
|
|
GAllocator *last;
|
|
|
|
GMemChunk *mem_chunk;
|
|
|
|
GList *free_lists; /* implementation specific */
|
1998-06-11 01:21:14 +02:00
|
|
|
};
|
|
|
|
|
1998-11-24 13:18:22 +01:00
|
|
|
static GAllocator *current_allocator = NULL;
|
1999-02-10 10:40:46 +01:00
|
|
|
G_LOCK_DEFINE_STATIC (current_allocator);
|
1998-06-11 01:21:14 +02:00
|
|
|
|
1998-12-15 06:28:02 +01:00
|
|
|
/* HOLDS: current_allocator_lock */
|
|
|
|
static void
|
|
|
|
g_list_validate_allocator (GAllocator *allocator)
|
1998-11-24 13:18:22 +01:00
|
|
|
{
|
|
|
|
g_return_if_fail (allocator != NULL);
|
|
|
|
g_return_if_fail (allocator->is_unused == TRUE);
|
1998-06-11 01:21:14 +02:00
|
|
|
|
1998-11-24 13:18:22 +01:00
|
|
|
if (allocator->type != G_ALLOCATOR_LIST)
|
|
|
|
{
|
|
|
|
allocator->type = G_ALLOCATOR_LIST;
|
|
|
|
if (allocator->mem_chunk)
|
|
|
|
{
|
|
|
|
g_mem_chunk_destroy (allocator->mem_chunk);
|
|
|
|
allocator->mem_chunk = NULL;
|
|
|
|
}
|
|
|
|
}
|
1998-06-11 01:21:14 +02:00
|
|
|
|
1998-11-24 13:18:22 +01:00
|
|
|
if (!allocator->mem_chunk)
|
|
|
|
{
|
|
|
|
allocator->mem_chunk = g_mem_chunk_new (allocator->name,
|
|
|
|
sizeof (GList),
|
|
|
|
sizeof (GList) * allocator->n_preallocs,
|
|
|
|
G_ALLOC_ONLY);
|
|
|
|
allocator->free_lists = NULL;
|
|
|
|
}
|
1998-06-11 01:21:14 +02:00
|
|
|
|
1998-11-24 13:18:22 +01:00
|
|
|
allocator->is_unused = FALSE;
|
1998-12-15 06:28:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
g_list_push_allocator(GAllocator *allocator)
|
|
|
|
{
|
1998-12-16 06:38:35 +01:00
|
|
|
G_LOCK (current_allocator);
|
Add configure test for garbage collector friendliness for GLib. If
2000-04-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in, acconfig.h: Add configure test for garbage
collector friendliness for GLib. If enabled, ENABLE_GC_FRIENDLY
will be defined.
* garray.c, ghash.c, glist.c, gmain.c, gmem.c, gnode.c, gqueue.c,
gslist.c, gtree.c: If ENABLE_GC_FRIENDLY is defined, NULLify all
memory released by the user, but cached by GLib. This lets a
garbage collector have a more correct view of the actually used
memory.
2000-04-17 15:23:27 +02:00
|
|
|
g_list_validate_allocator (allocator);
|
1998-11-24 13:18:22 +01:00
|
|
|
allocator->last = current_allocator;
|
|
|
|
current_allocator = allocator;
|
1998-12-16 06:38:35 +01:00
|
|
|
G_UNLOCK (current_allocator);
|
1998-06-11 01:21:14 +02:00
|
|
|
}
|
|
|
|
|
1998-11-24 13:18:22 +01:00
|
|
|
void
|
|
|
|
g_list_pop_allocator (void)
|
1998-06-11 01:21:14 +02:00
|
|
|
{
|
1998-12-16 06:38:35 +01:00
|
|
|
G_LOCK (current_allocator);
|
1998-11-24 13:18:22 +01:00
|
|
|
if (current_allocator)
|
1998-06-11 01:21:14 +02:00
|
|
|
{
|
1998-11-24 13:18:22 +01:00
|
|
|
GAllocator *allocator;
|
|
|
|
|
|
|
|
allocator = current_allocator;
|
|
|
|
current_allocator = allocator->last;
|
|
|
|
allocator->last = NULL;
|
|
|
|
allocator->is_unused = TRUE;
|
1998-06-11 01:21:14 +02:00
|
|
|
}
|
1998-12-16 06:38:35 +01:00
|
|
|
G_UNLOCK (current_allocator);
|
1998-06-11 01:21:14 +02:00
|
|
|
}
|
|
|
|
|
1999-08-17 19:41:01 +02:00
|
|
|
static inline GList*
|
|
|
|
_g_list_alloc (void)
|
1998-06-11 01:21:14 +02:00
|
|
|
{
|
1998-11-24 13:18:22 +01:00
|
|
|
GList *list;
|
|
|
|
|
1998-12-16 06:38:35 +01:00
|
|
|
G_LOCK (current_allocator);
|
1998-11-24 13:18:22 +01:00
|
|
|
if (!current_allocator)
|
1998-12-15 06:28:02 +01:00
|
|
|
{
|
|
|
|
GAllocator *allocator = g_allocator_new ("GLib default GList allocator",
|
1999-02-09 20:25:38 +01:00
|
|
|
128);
|
1998-12-15 06:28:02 +01:00
|
|
|
g_list_validate_allocator (allocator);
|
|
|
|
allocator->last = NULL;
|
|
|
|
current_allocator = allocator;
|
|
|
|
}
|
1998-11-24 13:18:22 +01:00
|
|
|
if (!current_allocator->free_lists)
|
1998-06-11 01:21:14 +02:00
|
|
|
{
|
1998-11-24 13:18:22 +01:00
|
|
|
list = g_chunk_new (GList, current_allocator->mem_chunk);
|
|
|
|
list->data = NULL;
|
1998-06-11 01:21:14 +02:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
1998-11-24 13:18:22 +01:00
|
|
|
if (current_allocator->free_lists->data)
|
|
|
|
{
|
|
|
|
list = current_allocator->free_lists->data;
|
|
|
|
current_allocator->free_lists->data = list->next;
|
|
|
|
list->data = NULL;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
list = current_allocator->free_lists;
|
|
|
|
current_allocator->free_lists = list->next;
|
|
|
|
}
|
1998-06-11 01:21:14 +02:00
|
|
|
}
|
1998-12-16 06:38:35 +01:00
|
|
|
G_UNLOCK (current_allocator);
|
1998-11-24 13:18:22 +01:00
|
|
|
list->next = NULL;
|
|
|
|
list->prev = NULL;
|
1998-06-11 01:21:14 +02:00
|
|
|
|
1998-11-24 13:18:22 +01:00
|
|
|
return list;
|
1998-06-11 01:21:14 +02:00
|
|
|
}
|
|
|
|
|
1999-08-17 19:41:01 +02:00
|
|
|
GList*
|
|
|
|
g_list_alloc (void)
|
|
|
|
{
|
|
|
|
return _g_list_alloc ();
|
|
|
|
}
|
|
|
|
|
1998-06-11 01:21:14 +02:00
|
|
|
void
|
|
|
|
g_list_free (GList *list)
|
|
|
|
{
|
|
|
|
if (list)
|
|
|
|
{
|
Add configure test for garbage collector friendliness for GLib. If
2000-04-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in, acconfig.h: Add configure test for garbage
collector friendliness for GLib. If enabled, ENABLE_GC_FRIENDLY
will be defined.
* garray.c, ghash.c, glist.c, gmain.c, gmem.c, gnode.c, gqueue.c,
gslist.c, gtree.c: If ENABLE_GC_FRIENDLY is defined, NULLify all
memory released by the user, but cached by GLib. This lets a
garbage collector have a more correct view of the actually used
memory.
2000-04-17 15:23:27 +02:00
|
|
|
GList *last_node = list;
|
|
|
|
|
|
|
|
#ifdef ENABLE_GC_FRIENDLY
|
|
|
|
while (last_node->next)
|
|
|
|
{
|
|
|
|
last_node->data = NULL;
|
|
|
|
last_node->prev = NULL;
|
|
|
|
last_node = last_node->next;
|
|
|
|
}
|
Ok, I'm a moron. When I originally implemented ENABLE_GC_FRIENDLY, I
2000-12-19 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* gslist.c, glist.c: Ok, I'm a moron. When I originally
implemented ENABLE_GC_FRIENDLY, I forgot to include config.h into
the affected files. Now that Alex did that for those two,
inevitable typos surfaced, which are now fixed.
* garray.c, ghash.c, gqueue.c, gtree.c: Include config.h as well,
as ENABLE_GC_FRIENDLY should be known.
2000-12-19 16:40:30 +01:00
|
|
|
last_node->data = NULL;
|
|
|
|
last_node->prev = NULL;
|
Add configure test for garbage collector friendliness for GLib. If
2000-04-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in, acconfig.h: Add configure test for garbage
collector friendliness for GLib. If enabled, ENABLE_GC_FRIENDLY
will be defined.
* garray.c, ghash.c, glist.c, gmain.c, gmem.c, gnode.c, gqueue.c,
gslist.c, gtree.c: If ENABLE_GC_FRIENDLY is defined, NULLify all
memory released by the user, but cached by GLib. This lets a
garbage collector have a more correct view of the actually used
memory.
2000-04-17 15:23:27 +02:00
|
|
|
#else /* !ENABLE_GC_FRIENDLY */
|
1998-12-15 06:28:02 +01:00
|
|
|
list->data = list->next;
|
Add configure test for garbage collector friendliness for GLib. If
2000-04-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in, acconfig.h: Add configure test for garbage
collector friendliness for GLib. If enabled, ENABLE_GC_FRIENDLY
will be defined.
* garray.c, ghash.c, glist.c, gmain.c, gmem.c, gnode.c, gqueue.c,
gslist.c, gtree.c: If ENABLE_GC_FRIENDLY is defined, NULLify all
memory released by the user, but cached by GLib. This lets a
garbage collector have a more correct view of the actually used
memory.
2000-04-17 15:23:27 +02:00
|
|
|
#endif /* ENABLE_GC_FRIENDLY */
|
|
|
|
|
1998-12-16 06:38:35 +01:00
|
|
|
G_LOCK (current_allocator);
|
Add configure test for garbage collector friendliness for GLib. If
2000-04-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in, acconfig.h: Add configure test for garbage
collector friendliness for GLib. If enabled, ENABLE_GC_FRIENDLY
will be defined.
* garray.c, ghash.c, glist.c, gmain.c, gmem.c, gnode.c, gqueue.c,
gslist.c, gtree.c: If ENABLE_GC_FRIENDLY is defined, NULLify all
memory released by the user, but cached by GLib. This lets a
garbage collector have a more correct view of the actually used
memory.
2000-04-17 15:23:27 +02:00
|
|
|
last_node->next = current_allocator->free_lists;
|
1998-11-24 13:18:22 +01:00
|
|
|
current_allocator->free_lists = list;
|
1998-12-16 06:38:35 +01:00
|
|
|
G_UNLOCK (current_allocator);
|
1998-06-11 01:21:14 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-08-17 19:41:01 +02:00
|
|
|
static inline void
|
|
|
|
_g_list_free_1 (GList *list)
|
1998-06-11 01:21:14 +02:00
|
|
|
{
|
|
|
|
if (list)
|
|
|
|
{
|
1998-12-15 06:28:02 +01:00
|
|
|
list->data = NULL;
|
Add configure test for garbage collector friendliness for GLib. If
2000-04-17 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* configure.in, acconfig.h: Add configure test for garbage
collector friendliness for GLib. If enabled, ENABLE_GC_FRIENDLY
will be defined.
* garray.c, ghash.c, glist.c, gmain.c, gmem.c, gnode.c, gqueue.c,
gslist.c, gtree.c: If ENABLE_GC_FRIENDLY is defined, NULLify all
memory released by the user, but cached by GLib. This lets a
garbage collector have a more correct view of the actually used
memory.
2000-04-17 15:23:27 +02:00
|
|
|
|
|
|
|
#ifdef ENABLE_GC_FRIENDLY
|
|
|
|
list->prev = NULL;
|
|
|
|
#endif /* ENABLE_GC_FRIENDLY */
|
|
|
|
|
1998-12-16 06:38:35 +01:00
|
|
|
G_LOCK (current_allocator);
|
1998-11-24 13:18:22 +01:00
|
|
|
list->next = current_allocator->free_lists;
|
|
|
|
current_allocator->free_lists = list;
|
1998-12-16 06:38:35 +01:00
|
|
|
G_UNLOCK (current_allocator);
|
1998-06-11 01:21:14 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1999-08-17 19:41:01 +02:00
|
|
|
void
|
|
|
|
g_list_free_1 (GList *list)
|
|
|
|
{
|
|
|
|
_g_list_free_1 (list);
|
|
|
|
}
|
|
|
|
|
2000-12-19 10:35:44 +01:00
|
|
|
#else /* DISABLE_MEM_POOLS */
|
|
|
|
|
|
|
|
#define _g_list_alloc g_list_alloc
|
|
|
|
GList*
|
|
|
|
g_list_alloc (void)
|
|
|
|
{
|
|
|
|
GList *list;
|
|
|
|
|
|
|
|
list = g_new0 (GList, 1);
|
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
g_list_free (GList *list)
|
|
|
|
{
|
|
|
|
GList *last;
|
|
|
|
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
last = list;
|
|
|
|
list = list->next;
|
|
|
|
g_free (last);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#define _g_list_free_1 g_list_free_1
|
|
|
|
void
|
|
|
|
g_list_free_1 (GList *list)
|
|
|
|
{
|
|
|
|
g_free (list);
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
1998-06-11 01:21:14 +02:00
|
|
|
GList*
|
|
|
|
g_list_append (GList *list,
|
|
|
|
gpointer data)
|
|
|
|
{
|
|
|
|
GList *new_list;
|
|
|
|
GList *last;
|
|
|
|
|
1999-08-17 19:41:01 +02:00
|
|
|
new_list = _g_list_alloc ();
|
1998-06-11 01:21:14 +02:00
|
|
|
new_list->data = data;
|
|
|
|
|
|
|
|
if (list)
|
|
|
|
{
|
|
|
|
last = g_list_last (list);
|
|
|
|
/* g_assert (last != NULL); */
|
|
|
|
last->next = new_list;
|
|
|
|
new_list->prev = last;
|
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return new_list;
|
|
|
|
}
|
|
|
|
|
|
|
|
GList*
|
|
|
|
g_list_prepend (GList *list,
|
|
|
|
gpointer data)
|
|
|
|
{
|
|
|
|
GList *new_list;
|
|
|
|
|
1999-08-17 19:41:01 +02:00
|
|
|
new_list = _g_list_alloc ();
|
1998-06-11 01:21:14 +02:00
|
|
|
new_list->data = data;
|
|
|
|
|
|
|
|
if (list)
|
|
|
|
{
|
|
|
|
if (list->prev)
|
|
|
|
{
|
|
|
|
list->prev->next = new_list;
|
|
|
|
new_list->prev = list->prev;
|
|
|
|
}
|
|
|
|
list->prev = new_list;
|
|
|
|
new_list->next = list;
|
|
|
|
}
|
|
|
|
|
|
|
|
return new_list;
|
|
|
|
}
|
|
|
|
|
|
|
|
GList*
|
|
|
|
g_list_insert (GList *list,
|
|
|
|
gpointer data,
|
|
|
|
gint position)
|
|
|
|
{
|
|
|
|
GList *new_list;
|
|
|
|
GList *tmp_list;
|
|
|
|
|
|
|
|
if (position < 0)
|
|
|
|
return g_list_append (list, data);
|
|
|
|
else if (position == 0)
|
|
|
|
return g_list_prepend (list, data);
|
|
|
|
|
|
|
|
tmp_list = g_list_nth (list, position);
|
|
|
|
if (!tmp_list)
|
|
|
|
return g_list_append (list, data);
|
|
|
|
|
1999-08-17 19:41:01 +02:00
|
|
|
new_list = _g_list_alloc ();
|
1998-06-11 01:21:14 +02:00
|
|
|
new_list->data = data;
|
|
|
|
|
|
|
|
if (tmp_list->prev)
|
|
|
|
{
|
|
|
|
tmp_list->prev->next = new_list;
|
|
|
|
new_list->prev = tmp_list->prev;
|
|
|
|
}
|
|
|
|
new_list->next = tmp_list;
|
|
|
|
tmp_list->prev = new_list;
|
|
|
|
|
|
|
|
if (tmp_list == list)
|
|
|
|
return new_list;
|
|
|
|
else
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
|
|
|
GList *
|
|
|
|
g_list_concat (GList *list1, GList *list2)
|
|
|
|
{
|
|
|
|
GList *tmp_list;
|
|
|
|
|
|
|
|
if (list2)
|
|
|
|
{
|
|
|
|
tmp_list = g_list_last (list1);
|
|
|
|
if (tmp_list)
|
|
|
|
tmp_list->next = list2;
|
|
|
|
else
|
|
|
|
list1 = list2;
|
|
|
|
list2->prev = tmp_list;
|
|
|
|
}
|
|
|
|
|
|
|
|
return list1;
|
|
|
|
}
|
|
|
|
|
|
|
|
GList*
|
2000-04-18 16:01:33 +02:00
|
|
|
g_list_remove (GList *list,
|
|
|
|
gconstpointer data)
|
1998-06-11 01:21:14 +02:00
|
|
|
{
|
|
|
|
GList *tmp;
|
|
|
|
|
|
|
|
tmp = list;
|
|
|
|
while (tmp)
|
|
|
|
{
|
|
|
|
if (tmp->data != data)
|
|
|
|
tmp = tmp->next;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if (tmp->prev)
|
|
|
|
tmp->prev->next = tmp->next;
|
|
|
|
if (tmp->next)
|
|
|
|
tmp->next->prev = tmp->prev;
|
|
|
|
|
|
|
|
if (list == tmp)
|
|
|
|
list = list->next;
|
|
|
|
|
1999-08-17 19:41:01 +02:00
|
|
|
_g_list_free_1 (tmp);
|
1998-06-11 01:21:14 +02:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
2001-03-18 05:44:38 +01:00
|
|
|
GList*
|
|
|
|
g_list_remove_all (GList *list,
|
|
|
|
gconstpointer data)
|
|
|
|
{
|
|
|
|
GList *tmp = list;
|
|
|
|
|
|
|
|
while (tmp)
|
|
|
|
{
|
|
|
|
if (tmp->data != data)
|
|
|
|
tmp = tmp->next;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
GList *next = tmp->next;
|
|
|
|
|
|
|
|
if (tmp->prev)
|
|
|
|
tmp->prev->next = next;
|
|
|
|
else
|
|
|
|
list = next;
|
|
|
|
if (next)
|
|
|
|
next->prev = tmp->prev;
|
|
|
|
|
|
|
|
_g_list_free_1 (tmp);
|
|
|
|
tmp = next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
1999-08-17 19:41:01 +02:00
|
|
|
static inline GList*
|
|
|
|
_g_list_remove_link (GList *list,
|
|
|
|
GList *link)
|
1998-06-11 01:21:14 +02:00
|
|
|
{
|
|
|
|
if (link)
|
|
|
|
{
|
|
|
|
if (link->prev)
|
|
|
|
link->prev->next = link->next;
|
|
|
|
if (link->next)
|
|
|
|
link->next->prev = link->prev;
|
|
|
|
|
|
|
|
if (link == list)
|
|
|
|
list = list->next;
|
|
|
|
|
|
|
|
link->next = NULL;
|
|
|
|
link->prev = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
1999-08-17 19:41:01 +02:00
|
|
|
GList*
|
|
|
|
g_list_remove_link (GList *list,
|
|
|
|
GList *link)
|
|
|
|
{
|
|
|
|
return _g_list_remove_link (list, link);
|
|
|
|
}
|
|
|
|
|
1999-03-09 20:41:19 +01:00
|
|
|
GList*
|
1999-07-24 20:50:58 +02:00
|
|
|
g_list_delete_link (GList *list,
|
|
|
|
GList *link)
|
1999-03-09 20:41:19 +01:00
|
|
|
{
|
1999-08-17 19:41:01 +02:00
|
|
|
list = _g_list_remove_link (list, link);
|
|
|
|
_g_list_free_1 (link);
|
1999-03-09 20:41:19 +01:00
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
1998-11-23 02:52:07 +01:00
|
|
|
GList*
|
|
|
|
g_list_copy (GList *list)
|
|
|
|
{
|
|
|
|
GList *new_list = NULL;
|
|
|
|
|
|
|
|
if (list)
|
|
|
|
{
|
|
|
|
GList *last;
|
|
|
|
|
1999-08-17 19:41:01 +02:00
|
|
|
new_list = _g_list_alloc ();
|
1998-11-23 02:52:07 +01:00
|
|
|
new_list->data = list->data;
|
|
|
|
last = new_list;
|
|
|
|
list = list->next;
|
|
|
|
while (list)
|
|
|
|
{
|
1999-08-17 19:41:01 +02:00
|
|
|
last->next = _g_list_alloc ();
|
1998-11-23 02:52:07 +01:00
|
|
|
last->next->prev = last;
|
|
|
|
last = last->next;
|
|
|
|
last->data = list->data;
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return new_list;
|
|
|
|
}
|
|
|
|
|
1998-06-11 01:21:14 +02:00
|
|
|
GList*
|
|
|
|
g_list_reverse (GList *list)
|
|
|
|
{
|
|
|
|
GList *last;
|
|
|
|
|
|
|
|
last = NULL;
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
last = list;
|
|
|
|
list = last->next;
|
|
|
|
last->next = last->prev;
|
|
|
|
last->prev = list;
|
|
|
|
}
|
|
|
|
|
|
|
|
return last;
|
|
|
|
}
|
|
|
|
|
|
|
|
GList*
|
|
|
|
g_list_nth (GList *list,
|
|
|
|
guint n)
|
|
|
|
{
|
|
|
|
while ((n-- > 0) && list)
|
|
|
|
list = list->next;
|
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
2001-04-03 15:15:41 +02:00
|
|
|
GList*
|
|
|
|
g_list_nth_prev (GList *list,
|
|
|
|
guint n)
|
|
|
|
{
|
|
|
|
while ((n-- > 0) && list)
|
|
|
|
list = list->prev;
|
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
1998-06-11 01:21:14 +02:00
|
|
|
gpointer
|
|
|
|
g_list_nth_data (GList *list,
|
|
|
|
guint n)
|
|
|
|
{
|
|
|
|
while ((n-- > 0) && list)
|
|
|
|
list = list->next;
|
|
|
|
|
|
|
|
return list ? list->data : NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
GList*
|
2000-04-18 16:01:33 +02:00
|
|
|
g_list_find (GList *list,
|
|
|
|
gconstpointer data)
|
1998-06-11 01:21:14 +02:00
|
|
|
{
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
if (list->data == data)
|
|
|
|
break;
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
|
|
|
GList*
|
2000-04-18 16:01:33 +02:00
|
|
|
g_list_find_custom (GList *list,
|
|
|
|
gconstpointer data,
|
|
|
|
GCompareFunc func)
|
1998-06-11 01:21:14 +02:00
|
|
|
{
|
|
|
|
g_return_val_if_fail (func != NULL, list);
|
|
|
|
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
if (! func (list->data, data))
|
|
|
|
return list;
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
gint
|
|
|
|
g_list_position (GList *list,
|
|
|
|
GList *link)
|
|
|
|
{
|
|
|
|
gint i;
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
if (list == link)
|
|
|
|
return i;
|
|
|
|
i++;
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
gint
|
2000-04-18 16:01:33 +02:00
|
|
|
g_list_index (GList *list,
|
|
|
|
gconstpointer data)
|
1998-06-11 01:21:14 +02:00
|
|
|
{
|
|
|
|
gint i;
|
|
|
|
|
|
|
|
i = 0;
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
if (list->data == data)
|
|
|
|
return i;
|
|
|
|
i++;
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
GList*
|
|
|
|
g_list_last (GList *list)
|
|
|
|
{
|
|
|
|
if (list)
|
|
|
|
{
|
|
|
|
while (list->next)
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
|
|
|
GList*
|
|
|
|
g_list_first (GList *list)
|
|
|
|
{
|
|
|
|
if (list)
|
|
|
|
{
|
|
|
|
while (list->prev)
|
|
|
|
list = list->prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
|
|
|
guint
|
|
|
|
g_list_length (GList *list)
|
|
|
|
{
|
|
|
|
guint length;
|
|
|
|
|
|
|
|
length = 0;
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
length++;
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
return length;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
g_list_foreach (GList *list,
|
|
|
|
GFunc func,
|
|
|
|
gpointer user_data)
|
|
|
|
{
|
|
|
|
while (list)
|
|
|
|
{
|
|
|
|
(*func) (list->data, user_data);
|
|
|
|
list = list->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
GList*
|
|
|
|
g_list_insert_sorted (GList *list,
|
|
|
|
gpointer data,
|
|
|
|
GCompareFunc func)
|
|
|
|
{
|
|
|
|
GList *tmp_list = list;
|
|
|
|
GList *new_list;
|
|
|
|
gint cmp;
|
|
|
|
|
|
|
|
g_return_val_if_fail (func != NULL, list);
|
|
|
|
|
|
|
|
if (!list)
|
|
|
|
{
|
1999-08-17 19:41:01 +02:00
|
|
|
new_list = _g_list_alloc ();
|
1998-06-11 01:21:14 +02:00
|
|
|
new_list->data = data;
|
|
|
|
return new_list;
|
|
|
|
}
|
|
|
|
|
|
|
|
cmp = (*func) (data, tmp_list->data);
|
|
|
|
|
|
|
|
while ((tmp_list->next) && (cmp > 0))
|
|
|
|
{
|
|
|
|
tmp_list = tmp_list->next;
|
|
|
|
cmp = (*func) (data, tmp_list->data);
|
|
|
|
}
|
|
|
|
|
1999-08-17 19:41:01 +02:00
|
|
|
new_list = _g_list_alloc ();
|
1998-06-11 01:21:14 +02:00
|
|
|
new_list->data = data;
|
|
|
|
|
|
|
|
if ((!tmp_list->next) && (cmp > 0))
|
|
|
|
{
|
|
|
|
tmp_list->next = new_list;
|
|
|
|
new_list->prev = tmp_list;
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (tmp_list->prev)
|
|
|
|
{
|
|
|
|
tmp_list->prev->next = new_list;
|
|
|
|
new_list->prev = tmp_list->prev;
|
|
|
|
}
|
|
|
|
new_list->next = tmp_list;
|
|
|
|
tmp_list->prev = new_list;
|
|
|
|
|
|
|
|
if (tmp_list == list)
|
|
|
|
return new_list;
|
|
|
|
else
|
|
|
|
return list;
|
|
|
|
}
|
1998-11-13 21:50:41 +01:00
|
|
|
|
|
|
|
static GList *
|
2000-11-21 00:59:32 +01:00
|
|
|
g_list_sort_merge (GList *l1,
|
|
|
|
GList *l2,
|
|
|
|
GFunc compare_func,
|
|
|
|
gboolean use_data,
|
|
|
|
gpointer user_data)
|
1998-11-13 21:50:41 +01:00
|
|
|
{
|
|
|
|
GList list, *l, *lprev;
|
2000-11-21 00:59:32 +01:00
|
|
|
gint cmp;
|
1998-11-13 21:50:41 +01:00
|
|
|
|
|
|
|
l = &list;
|
|
|
|
lprev = NULL;
|
|
|
|
|
|
|
|
while (l1 && l2)
|
|
|
|
{
|
2000-11-21 00:59:32 +01:00
|
|
|
if (use_data)
|
changed prototype of g_boxed_type_register_static() to contain an optional
Wed Mar 7 09:36:33 2001 Tim Janik <timj@gtk.org>
* gboxed.[hc]: changed prototype of g_boxed_type_register_static()
to contain an optional init function and a hint at whether the
boxed structure uses ref counting internally.
added g_value_set_boxed_take_ownership().
made G_TYPE_BOXED an abstract value type.
* genums.[hc]: made G_TYPE_ENUM and G_TYPE_FLAGS abstract value
types.
* glib-genmarshal.c: argument type changes, preparation for third-party
arg specification.
* gobject.[hc]: cleaned up get/set property code.
added g_strdup_value_contents() to improve warnings.
* gparam.[hc]: added g_param_value_convert(), taking over responsibility
of the old g_value_convert(). added G_PARAM_LAX_VALIDATION flag so
validation alterations may be valid a part of the property setting
process.
* gparamspecs.[hc]: made value comparisons stable (for sort applications).
added GParamSpecValueArray, a param spec for value arrays and
GParamSpecClosure. nuked the value exchange functions and
GParamSpecCCallback.
* gtype.[hc]: catch unintialized usages of the type system with
g_return_val_if_uninitialized(). introduced G_TYPE_FLAG_VALUE_ABSTRACT
to flag types that introduce a value table, but can't be used for
g_value_init(). cleaned up reserved type ids.
* gvalue.[hc]: code cleanups and saner checking.
nuked the value exchange API. implemented value transformations, we
can't really "convert" values, rather transforms are an anylogy to
C casts, real conversions need a param spec for validation, which is
why g_param_value_convert() does real conversions now.
* gvaluearray.[hc]: new files that implement a GValueArray, a struct
that can hold inhomogeneous arrays of value (to that extend that it
also allowes undefined values, i.e. G_VALUE_TYPE(value)==0).
this is exposed to the type system as a boxed type.
* gvaluetransform.c: new file implementing most of the former value
exchange functions as single-sided transformations.
* gvaluetypes.[hc]: nuked G_TYPE_CCALLBACK, added
g_value_set_string_take_ownership().
* *.h: s/G_IS_VALUE_/G_VALUE_HOLDS_/.
* *.[hc]: many fixes and cleanups.
* many warning improvements.
Tue Feb 27 18:35:15 2001 Tim Janik <timj@gtk.org>
* gobject.c (g_object_get_valist): urg, pass G_VALUE_NOCOPY_CONTENTS
into G_VALUE_LCOPY(), this needs proper documenting.
* gparam.c: fixed G_PARAM_USER_MASK.
* gtype.c (type_data_make_W):
(type_data_last_unref_Wm): fixed invalid memory freeing.
* gobject.c (g_object_last_unref): destroy signal handlers associated
with object, right before finalization.
* gsignal.c (g_signal_parse_name): catch destroyed nodes or signals
that don't actually support details.
* gobject.[hc]: got rid of property trailers. nuked GObject
properties "data" and the "signal" variants.
(g_object_connect): new convenience function to do multiple
signal connections at once.
(g_object_disconnect): likewise, for disconnections.
* gparam.[hc] (g_param_spec_pool_lookup): took out trailer support.
* gvalue.[hc]: marked g_value_fits_pointer() and g_value_peek_pointer()
as private (the latter got renamed from g_value_get_as_pointer()).
Wed Mar 7 09:32:06 2001 Tim Janik <timj@gtk.org>
* glib-object.h: add gvaluearray.h.
* gstring.[hc]: fixup naming of g_string_sprint*.
* gtypes.h: fixed GCompareDataFunc naming.
Wed Mar 7 09:33:27 2001 Tim Janik <timj@gtk.org>
* gobject/Makefile.am: shuffled rules to avoid excessive
rebuilds.
* gobject/gobject-sections.txt: updates.
* gobject/tmpl/*: bunch of updates, added another patch
from Eric Lemings <eric.b.lemings@lmco.com>.
2001-03-07 15:46:45 +01:00
|
|
|
cmp = ((GCompareDataFunc) compare_func) (l1->data, l2->data, user_data);
|
2000-11-21 00:59:32 +01:00
|
|
|
else
|
|
|
|
cmp = ((GCompareFunc) compare_func) (l1->data, l2->data);
|
|
|
|
|
|
|
|
if (cmp <= 0)
|
1998-11-13 21:50:41 +01:00
|
|
|
{
|
|
|
|
l->next = l1;
|
|
|
|
l = l->next;
|
|
|
|
l->prev = lprev;
|
|
|
|
lprev = l;
|
|
|
|
l1 = l1->next;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
l->next = l2;
|
|
|
|
l = l->next;
|
|
|
|
l->prev = lprev;
|
|
|
|
lprev = l;
|
|
|
|
l2 = l2->next;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
l->next = l1 ? l1 : l2;
|
|
|
|
l->next->prev = l;
|
|
|
|
|
|
|
|
return list.next;
|
|
|
|
}
|
|
|
|
|
|
|
|
GList*
|
2000-11-21 00:59:32 +01:00
|
|
|
g_list_sort_real (GList *list,
|
|
|
|
GFunc compare_func,
|
|
|
|
gboolean use_data,
|
|
|
|
gpointer user_data)
|
1998-11-13 21:50:41 +01:00
|
|
|
{
|
|
|
|
GList *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;
|
|
|
|
|
2000-11-21 00:59:32 +01:00
|
|
|
return g_list_sort_merge (g_list_sort_real (list, compare_func, use_data, user_data),
|
|
|
|
g_list_sort_real (l2, compare_func, use_data, user_data),
|
|
|
|
compare_func,
|
|
|
|
use_data,
|
|
|
|
user_data);
|
|
|
|
}
|
|
|
|
|
|
|
|
GList *
|
|
|
|
g_list_sort (GList *list,
|
|
|
|
GCompareFunc compare_func)
|
|
|
|
{
|
|
|
|
return g_list_sort_real (list, (GFunc) compare_func, FALSE, NULL);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
GList *
|
|
|
|
g_list_sort_with_data (GList *list,
|
changed prototype of g_boxed_type_register_static() to contain an optional
Wed Mar 7 09:36:33 2001 Tim Janik <timj@gtk.org>
* gboxed.[hc]: changed prototype of g_boxed_type_register_static()
to contain an optional init function and a hint at whether the
boxed structure uses ref counting internally.
added g_value_set_boxed_take_ownership().
made G_TYPE_BOXED an abstract value type.
* genums.[hc]: made G_TYPE_ENUM and G_TYPE_FLAGS abstract value
types.
* glib-genmarshal.c: argument type changes, preparation for third-party
arg specification.
* gobject.[hc]: cleaned up get/set property code.
added g_strdup_value_contents() to improve warnings.
* gparam.[hc]: added g_param_value_convert(), taking over responsibility
of the old g_value_convert(). added G_PARAM_LAX_VALIDATION flag so
validation alterations may be valid a part of the property setting
process.
* gparamspecs.[hc]: made value comparisons stable (for sort applications).
added GParamSpecValueArray, a param spec for value arrays and
GParamSpecClosure. nuked the value exchange functions and
GParamSpecCCallback.
* gtype.[hc]: catch unintialized usages of the type system with
g_return_val_if_uninitialized(). introduced G_TYPE_FLAG_VALUE_ABSTRACT
to flag types that introduce a value table, but can't be used for
g_value_init(). cleaned up reserved type ids.
* gvalue.[hc]: code cleanups and saner checking.
nuked the value exchange API. implemented value transformations, we
can't really "convert" values, rather transforms are an anylogy to
C casts, real conversions need a param spec for validation, which is
why g_param_value_convert() does real conversions now.
* gvaluearray.[hc]: new files that implement a GValueArray, a struct
that can hold inhomogeneous arrays of value (to that extend that it
also allowes undefined values, i.e. G_VALUE_TYPE(value)==0).
this is exposed to the type system as a boxed type.
* gvaluetransform.c: new file implementing most of the former value
exchange functions as single-sided transformations.
* gvaluetypes.[hc]: nuked G_TYPE_CCALLBACK, added
g_value_set_string_take_ownership().
* *.h: s/G_IS_VALUE_/G_VALUE_HOLDS_/.
* *.[hc]: many fixes and cleanups.
* many warning improvements.
Tue Feb 27 18:35:15 2001 Tim Janik <timj@gtk.org>
* gobject.c (g_object_get_valist): urg, pass G_VALUE_NOCOPY_CONTENTS
into G_VALUE_LCOPY(), this needs proper documenting.
* gparam.c: fixed G_PARAM_USER_MASK.
* gtype.c (type_data_make_W):
(type_data_last_unref_Wm): fixed invalid memory freeing.
* gobject.c (g_object_last_unref): destroy signal handlers associated
with object, right before finalization.
* gsignal.c (g_signal_parse_name): catch destroyed nodes or signals
that don't actually support details.
* gobject.[hc]: got rid of property trailers. nuked GObject
properties "data" and the "signal" variants.
(g_object_connect): new convenience function to do multiple
signal connections at once.
(g_object_disconnect): likewise, for disconnections.
* gparam.[hc] (g_param_spec_pool_lookup): took out trailer support.
* gvalue.[hc]: marked g_value_fits_pointer() and g_value_peek_pointer()
as private (the latter got renamed from g_value_get_as_pointer()).
Wed Mar 7 09:32:06 2001 Tim Janik <timj@gtk.org>
* glib-object.h: add gvaluearray.h.
* gstring.[hc]: fixup naming of g_string_sprint*.
* gtypes.h: fixed GCompareDataFunc naming.
Wed Mar 7 09:33:27 2001 Tim Janik <timj@gtk.org>
* gobject/Makefile.am: shuffled rules to avoid excessive
rebuilds.
* gobject/gobject-sections.txt: updates.
* gobject/tmpl/*: bunch of updates, added another patch
from Eric Lemings <eric.b.lemings@lmco.com>.
2001-03-07 15:46:45 +01:00
|
|
|
GCompareDataFunc compare_func,
|
2000-11-21 00:59:32 +01:00
|
|
|
gpointer user_data)
|
|
|
|
{
|
|
|
|
return g_list_sort_real (list, (GFunc) compare_func, TRUE, user_data);
|
1998-11-13 21:50:41 +01:00
|
|
|
}
|
1998-12-02 15:55:27 +01:00
|
|
|
|
|
|
|
GList*
|
|
|
|
g_list_sort2 (GList *list,
|
|
|
|
GCompareFunc compare_func)
|
|
|
|
{
|
|
|
|
GSList *runs = NULL;
|
|
|
|
GList *tmp;
|
|
|
|
|
|
|
|
/* Degenerate case. */
|
|
|
|
if (!list) return NULL;
|
|
|
|
|
|
|
|
/* Assume: list = [12,2,4,11,2,4,6,1,1,12]. */
|
|
|
|
for (tmp = list; tmp; )
|
|
|
|
{
|
|
|
|
GList *tmp2;
|
|
|
|
for (tmp2 = tmp;
|
|
|
|
tmp2->next && compare_func (tmp2->data, tmp2->next->data) <= 0;
|
|
|
|
tmp2 = tmp2->next)
|
|
|
|
/* Nothing */;
|
|
|
|
runs = g_slist_append (runs, tmp);
|
|
|
|
tmp = tmp2->next;
|
|
|
|
tmp2->next = NULL;
|
|
|
|
}
|
|
|
|
/* Now: runs = [[12],[2,4,11],[2,4,6],[1,1,12]]. */
|
|
|
|
|
|
|
|
while (runs->next)
|
|
|
|
{
|
|
|
|
/* We have more than one run. Merge pairwise. */
|
|
|
|
GSList *dst, *src, *dstprev = NULL;
|
|
|
|
dst = src = runs;
|
|
|
|
while (src && src->next)
|
|
|
|
{
|
|
|
|
dst->data = g_list_sort_merge (src->data,
|
|
|
|
src->next->data,
|
2000-11-21 00:59:32 +01:00
|
|
|
(GFunc) compare_func,
|
|
|
|
FALSE, NULL);
|
1998-12-02 15:55:27 +01:00
|
|
|
dstprev = dst;
|
|
|
|
dst = dst->next;
|
|
|
|
src = src->next->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If number of runs was odd, just keep the last. */
|
|
|
|
if (src)
|
|
|
|
{
|
|
|
|
dst->data = src->data;
|
|
|
|
dstprev = dst;
|
|
|
|
dst = dst->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
dstprev->next = NULL;
|
|
|
|
g_slist_free (dst);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* After 1st loop: runs = [[2,4,11,12],[1,1,2,4,6,12]]. */
|
|
|
|
/* After 2nd loop: runs = [[1,1,2,2,4,4,6,11,12,12]]. */
|
|
|
|
|
|
|
|
list = runs->data;
|
|
|
|
g_slist_free (runs);
|
|
|
|
return list;
|
|
|
|
}
|