more atomic ops pointer cast fixes. this time it'll work with atomic op

[platform/upstream/glib.git] / glib / garray.c

diff --git a/glib/garray.c b/glib/garray.c
index c50d643..6aaf0a5 100644 (file)
--- a/glib/garray.c
+++ b/glib/garray.c
@@ -28,13 +28,19 @@
  * MT safe
  */
 
-#ifdef HAVE_CONFIG_H
-#include <config.h>
-#endif
+#include "config.h"
 
 #include <string.h>
 #include <stdlib.h>
-#include "glib.h"
+
+#include "garray.h"
+
+#include "gmem.h"
+#include "gthread.h"
+#include "gmessages.h"
+#include "gqsort.h"
+
+#include "galias.h"
 
 
 #define MIN_ARRAY_SIZE  16
@@ -64,9 +70,6 @@ static gint g_nearest_pow        (gint        num) G_GNUC_CONST;
 static void g_array_maybe_expand (GRealArray *array,
                                  gint        len);
 
-static GMemChunk *array_mem_chunk = NULL;
-G_LOCK_DEFINE_STATIC (array_mem_chunk);
-
 GArray*
 g_array_new (gboolean zero_terminated,
             gboolean clear,
@@ -80,16 +83,7 @@ GArray* g_array_sized_new (gboolean zero_terminated,
                           guint    elt_size,
                           guint    reserved_size)
 {
-  GRealArray *array;
-
-  G_LOCK (array_mem_chunk);
-  if (!array_mem_chunk)
-    array_mem_chunk = g_mem_chunk_new ("array mem chunk",
-                                      sizeof (GRealArray),
-                                      1024, G_ALLOC_AND_FREE);
-
-  array = g_chunk_new (GRealArray, array_mem_chunk);
-  G_UNLOCK (array_mem_chunk);
+  GRealArray *array = g_slice_new (GRealArray);
 
   array->data            = NULL;
   array->len             = 0;
@@ -123,9 +117,7 @@ g_array_free (GArray  *array,
   else
     segment = array->data;
 
-  G_LOCK (array_mem_chunk);
-  g_mem_chunk_free (array_mem_chunk, array);
-  G_UNLOCK (array_mem_chunk);
+  g_slice_free1 (sizeof (GRealArray), array);
 
   return segment;
 }
@@ -205,10 +197,8 @@ g_array_set_size (GArray *farray,
       if (array->clear)
        g_array_elt_zero (array, array->len, length - array->len);
     }
-#ifdef ENABLE_GC_FRIENDLY  
-  else if (length < array->len)
+  else if (G_UNLIKELY (g_mem_gc_friendly) && length < array->len)
     g_array_elt_zero (array, length, array->len - length);
-#endif /* ENABLE_GC_FRIENDLY */  
   
   array->len = length;
   
@@ -234,11 +224,10 @@ g_array_remove_index (GArray* farray,
   
   array->len -= 1;
 
-#ifdef ENABLE_GC_FRIENDLY
-  g_array_elt_zero (array, array->len, 1);
-#else /* !ENABLE_GC_FRIENDLY */
-  g_array_zero_terminate (array);
-#endif /* ENABLE_GC_FRIENDLY */  
+  if (G_UNLIKELY (g_mem_gc_friendly))
+    g_array_elt_zero (array, array->len, 1);
+  else
+    g_array_zero_terminate (array);
 
   return farray;
 }
@@ -254,17 +243,41 @@ g_array_remove_index_fast (GArray* farray,
   g_return_val_if_fail (index < array->len, NULL);
 
   if (index != array->len - 1)
-    g_memmove (g_array_elt_pos (array, index), 
-              g_array_elt_pos (array, array->len - 1),
-              g_array_elt_len (array, 1));
+    memcpy (g_array_elt_pos (array, index), 
+           g_array_elt_pos (array, array->len - 1),
+           g_array_elt_len (array, 1));
   
   array->len -= 1;
 
-#ifdef ENABLE_GC_FRIENDLY
-  g_array_elt_zero (array, array->len, 1);
-#else /* !ENABLE_GC_FRIENDLY */
-  g_array_zero_terminate (array);
-#endif /* ENABLE_GC_FRIENDLY */  
+  if (G_UNLIKELY (g_mem_gc_friendly))
+    g_array_elt_zero (array, array->len, 1);
+  else
+    g_array_zero_terminate (array);
+
+  return farray;
+}
+
+GArray*
+g_array_remove_range (GArray       *farray,
+                      guint         index_,
+                      guint         length)
+{
+  GRealArray *array = (GRealArray*) farray;
+
+  g_return_val_if_fail (array, NULL);
+  g_return_val_if_fail (index_ < array->len, NULL);
+  g_return_val_if_fail (index_ + length <= array->len, NULL);
+
+  if (index_ + length != array->len)
+    g_memmove (g_array_elt_pos (array, index_), 
+               g_array_elt_pos (array, index_ + length), 
+               (array->len - (index_ + length)) * array->elt_size);
+
+  array->len -= length;
+  if (G_UNLIKELY (g_mem_gc_friendly))
+    g_array_elt_zero (array, array->len, length);
+  else
+    g_array_zero_terminate (array);
 
   return farray;
 }
@@ -276,7 +289,6 @@ g_array_sort (GArray       *farray,
   GRealArray *array = (GRealArray*) farray;
 
   g_return_if_fail (array != NULL);
-  g_return_if_fail (array->data != NULL);
 
   qsort (array->data,
         array->len,
@@ -286,13 +298,12 @@ g_array_sort (GArray       *farray,
 
 void
 g_array_sort_with_data (GArray           *farray,
-                       GCompareFuncData  compare_func,
+                       GCompareDataFunc  compare_func,
                        gpointer          user_data)
 {
   GRealArray *array = (GRealArray*) farray;
 
   g_return_if_fail (array != NULL);
-  g_return_if_fail (array->data != NULL);
 
   g_qsort_with_data (array->data,
                     array->len,
@@ -327,9 +338,8 @@ g_array_maybe_expand (GRealArray *array,
 
       array->data = g_realloc (array->data, want_alloc);
 
-#ifdef ENABLE_GC_FRIENDLY
-      memset (array->data + array->alloc, 0, want_alloc - array->alloc);
-#endif /* ENABLE_GC_FRIENDLY */
+      if (G_UNLIKELY (g_mem_gc_friendly))
+        memset (array->data + array->alloc, 0, want_alloc - array->alloc);
 
       array->alloc = want_alloc;
     }
@@ -350,10 +360,6 @@ struct _GRealPtrArray
 static void g_ptr_array_maybe_expand (GRealPtrArray *array,
                                      gint           len);
 
-static GMemChunk *ptr_array_mem_chunk = NULL;
-G_LOCK_DEFINE_STATIC (ptr_array_mem_chunk);
-
-
 GPtrArray*
 g_ptr_array_new (void)
 {
@@ -363,16 +369,7 @@ g_ptr_array_new (void)
 GPtrArray*  
 g_ptr_array_sized_new (guint reserved_size)
 {
-  GRealPtrArray *array;
-
-  G_LOCK (ptr_array_mem_chunk);
-  if (!ptr_array_mem_chunk)
-    ptr_array_mem_chunk = g_mem_chunk_new ("array mem chunk",
-                                          sizeof (GRealPtrArray),
-                                          1024, G_ALLOC_AND_FREE);
-
-  array = g_chunk_new (GRealPtrArray, ptr_array_mem_chunk);
-  G_UNLOCK (ptr_array_mem_chunk);
+  GRealPtrArray *array = g_slice_new (GRealPtrArray);
 
   array->pdata = NULL;
   array->len = 0;
@@ -400,9 +397,7 @@ g_ptr_array_free (GPtrArray   *array,
   else
     segment = array->pdata;
 
-  G_LOCK (ptr_array_mem_chunk);
-  g_mem_chunk_free (ptr_array_mem_chunk, array);
-  G_UNLOCK (ptr_array_mem_chunk);
+  g_slice_free1 (sizeof (GRealPtrArray), array);
 
   return segment;
 }
@@ -413,16 +408,13 @@ g_ptr_array_maybe_expand (GRealPtrArray *array,
 {
   if ((array->len + len) > array->alloc)
     {
-#ifdef ENABLE_GC_FRIENDLY
       guint old_alloc = array->alloc;
-#endif /* ENABLE_GC_FRIENDLY */
       array->alloc = g_nearest_pow (array->len + len);
       array->alloc = MAX (array->alloc, MIN_ARRAY_SIZE);
-      array->pdata = g_realloc (array->pdata, sizeof(gpointer) * array->alloc);
-#ifdef ENABLE_GC_FRIENDLY
-      for ( ; old_alloc < array->alloc; old_alloc++)
-       array->pdata [old_alloc] = NULL;
-#endif /* ENABLE_GC_FRIENDLY */
+      array->pdata = g_realloc (array->pdata, sizeof (gpointer) * array->alloc);
+      if (G_UNLIKELY (g_mem_gc_friendly))
+        for ( ; old_alloc < array->alloc; old_alloc++)
+          array->pdata [old_alloc] = NULL;
     }
 }
 
@@ -447,14 +439,12 @@ g_ptr_array_set_size  (GPtrArray   *farray,
       for (i = array->len; i < length; i++)
        array->pdata[i] = NULL;
     }
-#ifdef ENABLE_GC_FRIENDLY  
-  else if (length < array->len)
+  if (G_UNLIKELY (g_mem_gc_friendly) && length < array->len)
     {
       int i;
       for (i = length; i < array->len; i++)
        array->pdata[i] = NULL;
     }
-#endif /* ENABLE_GC_FRIENDLY */  
 
   array->len = length;
 }
@@ -478,9 +468,8 @@ g_ptr_array_remove_index (GPtrArray* farray,
   
   array->len -= 1;
 
-#ifdef ENABLE_GC_FRIENDLY  
-  array->pdata[array->len] = NULL;
-#endif /* ENABLE_GC_FRIENDLY */  
+  if (G_UNLIKELY (g_mem_gc_friendly))
+    array->pdata[array->len] = NULL;
 
   return result;
 }
@@ -503,19 +492,43 @@ g_ptr_array_remove_index_fast (GPtrArray* farray,
 
   array->len -= 1;
 
-#ifdef ENABLE_GC_FRIENDLY  
-  array->pdata[array->len] = NULL;
-#endif /* ENABLE_GC_FRIENDLY */  
+  if (G_UNLIKELY (g_mem_gc_friendly))
+    array->pdata[array->len] = NULL;
 
   return result;
 }
 
+void
+g_ptr_array_remove_range (GPtrArray* farray,
+                          guint      index_,
+                          guint      length)
+{
+  GRealPtrArray* array = (GRealPtrArray*) farray;
+
+  g_return_if_fail (array);
+  g_return_if_fail (index_ < array->len);
+  g_return_if_fail (index_ + length <= array->len);
+
+  if (index_ + length != array->len)
+    g_memmove (&array->pdata[index_],
+               &array->pdata[index_ + length], 
+               (array->len - (index_ + length)) * sizeof (gpointer));
+
+  array->len -= length;
+  if (G_UNLIKELY (g_mem_gc_friendly))
+    {
+      guint i;
+      for (i = 0; i < length; i++)
+        array->pdata[array->len + i] = NULL;
+    }
+}
+
 gboolean
 g_ptr_array_remove (GPtrArray* farray,
                    gpointer data)
 {
   GRealPtrArray* array = (GRealPtrArray*) farray;
-  int i;
+  guint i;
 
   g_return_val_if_fail (array, FALSE);
 
@@ -536,7 +549,7 @@ g_ptr_array_remove_fast (GPtrArray* farray,
                         gpointer data)
 {
   GRealPtrArray* array = (GRealPtrArray*) farray;
-  int i;
+  guint i;
 
   g_return_val_if_fail (array, FALSE);
 
@@ -570,7 +583,6 @@ g_ptr_array_sort (GPtrArray    *array,
                  GCompareFunc  compare_func)
 {
   g_return_if_fail (array != NULL);
-  g_return_if_fail (array->pdata != NULL);
 
   qsort (array->pdata,
         array->len,
@@ -580,11 +592,10 @@ g_ptr_array_sort (GPtrArray    *array,
 
 void
 g_ptr_array_sort_with_data (GPtrArray        *array,
-                           GCompareFuncData  compare_func,
+                           GCompareDataFunc  compare_func,
                            gpointer          user_data)
 {
   g_return_if_fail (array != NULL);
-  g_return_if_fail (array->pdata != NULL);
 
   g_qsort_with_data (array->pdata,
                     array->len,
@@ -593,6 +604,29 @@ g_ptr_array_sort_with_data (GPtrArray        *array,
                     user_data);
 }
 
+/**
+ * g_ptr_array_foreach:
+ * @array: a #GPtrArray
+ * @func: the function to call for each array element
+ * @user_data: user data to pass to the function
+ * 
+ * Calls a function for each element of a #GPtrArray.
+ *
+ * Since: 2.4
+ **/
+void
+g_ptr_array_foreach (GPtrArray *array,
+                     GFunc      func,
+                     gpointer   user_data)
+{
+  guint i;
+
+  g_return_if_fail (array);
+
+  for (i = 0; i < array->len; i++)
+    (*func) (array->pdata[i], user_data);
+}
+
 /* Byte arrays 
  */
 
@@ -654,6 +688,18 @@ GByteArray* g_byte_array_remove_index_fast (GByteArray *array,
   return array;
 }
 
+GByteArray*
+g_byte_array_remove_range (GByteArray *array,
+                           guint index_,
+                           guint length)
+{
+  g_return_val_if_fail (array, NULL);
+  g_return_val_if_fail (index_ < array->len, NULL);
+  g_return_val_if_fail (index_ + length <= array->len, NULL);
+
+  return (GByteArray *)g_array_remove_range ((GArray*) array, index_, length);
+}
+
 void
 g_byte_array_sort (GByteArray   *array,
                   GCompareFunc  compare_func)
@@ -663,8 +709,11 @@ g_byte_array_sort (GByteArray   *array,
 
 void
 g_byte_array_sort_with_data (GByteArray       *array,
-                            GCompareFuncData  compare_func,
+                            GCompareDataFunc  compare_func,
                             gpointer          user_data)
 {
   g_array_sort_with_data ((GArray *) array, compare_func, user_data);
 }
+
+#define __G_ARRAY_C__
+#include "galiasdef.c"