1 /* GLIB - Library of useful routines for C programming
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Library General Public
6 * License as published by the Free Software Foundation; either
7 * version 2 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Library General Public License for more details.
14 * You should have received a copy of the GNU Library General Public
15 * License along with this library; if not, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
21 * Modified by the GLib Team and others 1997-1999. See the AUTHORS
22 * file for a list of people on the GLib Team. See the ChangeLog
23 * files for a list of changes. These files are distributed with
24 * GLib at ftp://ftp.gtk.org/pub/gtk/.
35 #define MIN_ARRAY_SIZE 16
37 typedef struct _GRealArray GRealArray;
45 guint zero_terminated : 1;
49 #define g_array_elt_len(array,i) ((array)->elt_size * (i))
50 #define g_array_elt_pos(array,i) ((array)->data + g_array_elt_len((array),(i)))
51 #define g_array_elt_zero(array, pos, len) \
52 (memset (g_array_elt_pos ((array), pos), 0, g_array_elt_len ((array), len)))
53 #define g_array_zero_terminate(array) G_STMT_START{ \
54 if ((array)->zero_terminated) \
55 g_array_elt_zero ((array), (array)->len, 1); \
58 static gint g_nearest_pow (gint num);
59 static void g_array_maybe_expand (GRealArray *array,
62 static GMemChunk *array_mem_chunk = NULL;
63 G_LOCK_DEFINE_STATIC (array_mem_chunk);
66 g_array_new (gboolean zero_terminated,
70 return (GArray*) g_array_sized_new (zero_terminated, clear, elt_size, 0);
73 GArray* g_array_sized_new (gboolean zero_terminated,
80 G_LOCK (array_mem_chunk);
82 array_mem_chunk = g_mem_chunk_new ("array mem chunk",
84 1024, G_ALLOC_AND_FREE);
86 array = g_chunk_new (GRealArray, array_mem_chunk);
87 G_UNLOCK (array_mem_chunk);
92 array->zero_terminated = (zero_terminated ? 1 : 0);
93 array->clear = (clear ? 1 : 0);
94 array->elt_size = elt_size;
96 if (array->zero_terminated || reserved_size != 0)
98 g_array_maybe_expand (array, reserved_size);
99 g_array_zero_terminate(array);
102 return (GArray*) array;
106 g_array_free (GArray *array,
107 gboolean free_segment)
110 g_free (array->data);
112 G_LOCK (array_mem_chunk);
113 g_mem_chunk_free (array_mem_chunk, array);
114 G_UNLOCK (array_mem_chunk);
118 g_array_append_vals (GArray *farray,
122 GRealArray *array = (GRealArray*) farray;
124 g_array_maybe_expand (array, len);
126 memcpy (g_array_elt_pos (array, array->len), data,
127 g_array_elt_len (array, len));
131 g_array_zero_terminate (array);
137 g_array_prepend_vals (GArray *farray,
141 GRealArray *array = (GRealArray*) farray;
143 g_array_maybe_expand (array, len);
145 g_memmove (g_array_elt_pos (array, len), g_array_elt_pos (array, 0),
146 g_array_elt_len (array, array->len));
148 memcpy (g_array_elt_pos (array, 0), data, g_array_elt_len (array, len));
152 g_array_zero_terminate (array);
158 g_array_insert_vals (GArray *farray,
163 GRealArray *array = (GRealArray*) farray;
165 g_array_maybe_expand (array, len);
167 g_memmove (g_array_elt_pos (array, len + index),
168 g_array_elt_pos (array, index),
169 g_array_elt_len (array, array->len - index));
171 memcpy (g_array_elt_pos (array, index), data, g_array_elt_len (array, len));
175 g_array_zero_terminate (array);
181 g_array_set_size (GArray *farray,
184 GRealArray *array = (GRealArray*) farray;
185 if (length > array->len)
187 g_array_maybe_expand (array, length - array->len);
190 g_array_elt_zero (array, array->len, length - array->len);
192 #ifdef ENABLE_GC_FRIENDLY
193 else if (length < array->len)
194 g_array_elt_zero (array, length, array->len - length);
195 #endif /* ENABLE_GC_FRIENDLY */
199 g_array_zero_terminate (array);
205 g_array_remove_index (GArray* farray,
208 GRealArray* array = (GRealArray*) farray;
210 g_return_val_if_fail (array, NULL);
212 g_return_val_if_fail (index >= 0 && index < array->len, NULL);
214 if (index != array->len - 1)
215 g_memmove (g_array_elt_pos (array, index),
216 g_array_elt_pos (array, index + 1),
217 g_array_elt_len (array, array->len - index - 1));
221 #ifdef ENABLE_GC_FRIENDLY
222 g_array_elt_zero (array, array->len, 1);
223 #else /* !ENABLE_GC_FRIENDLY */
224 g_array_zero_terminate (array);
225 #endif /* ENABLE_GC_FRIENDLY */
231 g_array_remove_index_fast (GArray* farray,
234 GRealArray* array = (GRealArray*) farray;
236 g_return_val_if_fail (array, NULL);
238 g_return_val_if_fail (index >= 0 && index < array->len, NULL);
240 if (index != array->len - 1)
241 g_memmove (g_array_elt_pos (array, index),
242 g_array_elt_pos (array, array->len - 1),
243 g_array_elt_len (array, 1));
247 #ifdef ENABLE_GC_FRIENDLY
248 g_array_elt_zero (array, array->len, 1);
249 #else /* !ENABLE_GC_FRIENDLY */
250 g_array_zero_terminate (array);
251 #endif /* ENABLE_GC_FRIENDLY */
257 g_nearest_pow (gint num)
268 g_array_maybe_expand (GRealArray *array,
271 guint want_alloc = g_array_elt_len (array, array->len + len +
272 array->zero_terminated);
274 if (want_alloc > array->alloc)
276 want_alloc = g_nearest_pow (want_alloc);
277 want_alloc = MAX (want_alloc, MIN_ARRAY_SIZE);
279 array->data = g_realloc (array->data, want_alloc);
281 #ifdef ENABLE_GC_FRIENDLY
282 memset (array->data + array->alloc, 0, want_alloc - array->alloc);
283 #endif /* ENABLE_GC_FRIENDLY */
285 array->alloc = want_alloc;
292 typedef struct _GRealPtrArray GRealPtrArray;
294 struct _GRealPtrArray
301 static void g_ptr_array_maybe_expand (GRealPtrArray *array,
304 static GMemChunk *ptr_array_mem_chunk = NULL;
305 G_LOCK_DEFINE_STATIC (ptr_array_mem_chunk);
309 g_ptr_array_new (void)
311 return g_ptr_array_sized_new (0);
315 g_ptr_array_sized_new (guint reserved_size)
317 GRealPtrArray *array;
319 G_LOCK (ptr_array_mem_chunk);
320 if (!ptr_array_mem_chunk)
321 ptr_array_mem_chunk = g_mem_chunk_new ("array mem chunk",
322 sizeof (GRealPtrArray),
323 1024, G_ALLOC_AND_FREE);
325 array = g_chunk_new (GRealPtrArray, ptr_array_mem_chunk);
326 G_UNLOCK (ptr_array_mem_chunk);
332 if (reserved_size != 0)
333 g_ptr_array_maybe_expand (array, reserved_size);
335 return (GPtrArray*) array;
339 g_ptr_array_free (GPtrArray *array,
340 gboolean free_segment)
342 g_return_if_fail (array);
345 g_free (array->pdata);
347 G_LOCK (ptr_array_mem_chunk);
348 g_mem_chunk_free (ptr_array_mem_chunk, array);
349 G_UNLOCK (ptr_array_mem_chunk);
353 g_ptr_array_maybe_expand (GRealPtrArray *array,
356 if ((array->len + len) > array->alloc)
358 #ifdef ENABLE_GC_FRIENDLY
359 guint old_alloc = array->alloc;
360 #endif /* ENABLE_GC_FRIENDLY */
361 array->alloc = g_nearest_pow (array->len + len);
362 array->alloc = MAX (array->alloc, MIN_ARRAY_SIZE);
363 array->pdata = g_realloc (array->pdata, sizeof(gpointer) * array->alloc);
364 #ifdef ENABLE_GC_FRIENDLY
365 for ( ; old_alloc < array->alloc; old_alloc++)
366 array->pdata [old_alloc] = NULL;
367 #endif /* ENABLE_GC_FRIENDLY */
372 g_ptr_array_set_size (GPtrArray *farray,
375 GRealPtrArray* array = (GRealPtrArray*) farray;
377 g_return_if_fail (array);
379 if (length > array->len)
382 g_ptr_array_maybe_expand (array, (length - array->len));
384 * memset (array->pdata + array->len, 0,
385 * sizeof (gpointer) * (length - array->len));
386 * to make it really portable. Remember (void*)NULL needn't be
387 * bitwise zero. It of course is silly not to use memset (..,0,..).
389 for (i = array->len; i < length; i++)
390 array->pdata[i] = NULL;
392 #ifdef ENABLE_GC_FRIENDLY
393 else if (length < array->len)
396 for (i = length; i < array->len; i++)
397 array->pdata[i] = NULL;
399 #endif /* ENABLE_GC_FRIENDLY */
405 g_ptr_array_remove_index (GPtrArray* farray,
408 GRealPtrArray* array = (GRealPtrArray*) farray;
411 g_return_val_if_fail (array, NULL);
413 g_return_val_if_fail (index >= 0 && index < array->len, NULL);
415 result = array->pdata[index];
417 if (index != array->len - 1)
418 g_memmove (array->pdata + index, array->pdata + index + 1,
419 sizeof (gpointer) * (array->len - index - 1));
423 #ifdef ENABLE_GC_FRIENDLY
424 array->pdata[array->len] = NULL;
425 #endif /* ENABLE_GC_FRIENDLY */
431 g_ptr_array_remove_index_fast (GPtrArray* farray,
434 GRealPtrArray* array = (GRealPtrArray*) farray;
437 g_return_val_if_fail (array, NULL);
439 g_return_val_if_fail (index >= 0 && index < array->len, NULL);
441 result = array->pdata[index];
443 if (index != array->len - 1)
444 array->pdata[index] = array->pdata[array->len - 1];
448 #ifdef ENABLE_GC_FRIENDLY
449 array->pdata[array->len] = NULL;
450 #endif /* ENABLE_GC_FRIENDLY */
456 g_ptr_array_remove (GPtrArray* farray,
459 GRealPtrArray* array = (GRealPtrArray*) farray;
462 g_return_val_if_fail (array, FALSE);
464 for (i = 0; i < array->len; i += 1)
466 if (array->pdata[i] == data)
468 g_ptr_array_remove_index (farray, i);
477 g_ptr_array_remove_fast (GPtrArray* farray,
480 GRealPtrArray* array = (GRealPtrArray*) farray;
483 g_return_val_if_fail (array, FALSE);
485 for (i = 0; i < array->len; i += 1)
487 if (array->pdata[i] == data)
489 g_ptr_array_remove_index_fast (farray, i);
498 g_ptr_array_add (GPtrArray* farray,
501 GRealPtrArray* array = (GRealPtrArray*) farray;
503 g_return_if_fail (array);
505 g_ptr_array_maybe_expand (array, 1);
507 array->pdata[array->len++] = data;
513 GByteArray* g_byte_array_new (void)
515 return (GByteArray*) g_array_sized_new (FALSE, FALSE, 1, 0);
518 GByteArray* g_byte_array_sized_new (guint reserved_size)
520 return (GByteArray*) g_array_sized_new (FALSE, FALSE, 1, reserved_size);
523 void g_byte_array_free (GByteArray *array,
524 gboolean free_segment)
526 g_array_free ((GArray*) array, free_segment);
529 GByteArray* g_byte_array_append (GByteArray *array,
533 g_array_append_vals ((GArray*) array, (guint8*)data, len);
538 GByteArray* g_byte_array_prepend (GByteArray *array,
542 g_array_prepend_vals ((GArray*) array, (guint8*)data, len);
547 GByteArray* g_byte_array_set_size (GByteArray *array,
550 g_array_set_size ((GArray*) array, length);
555 GByteArray* g_byte_array_remove_index (GByteArray *array,
558 g_array_remove_index((GArray*) array, index);
563 GByteArray* g_byte_array_remove_index_fast (GByteArray *array,
566 g_array_remove_index_fast((GArray*) array, index);