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,
72 G_LOCK (array_mem_chunk);
74 array_mem_chunk = g_mem_chunk_new ("array mem chunk",
76 1024, G_ALLOC_AND_FREE);
78 array = g_chunk_new (GRealArray, array_mem_chunk);
79 G_UNLOCK (array_mem_chunk);
84 array->zero_terminated = (zero_terminated ? 1 : 0);
85 array->clear = (clear ? 1 : 0);
86 array->elt_size = elt_size;
88 if (array->zero_terminated)
90 g_array_maybe_expand (array, 0);
91 g_array_elt_zero (array, 0, 1);
94 return (GArray*) array;
98 g_array_free (GArray *array,
99 gboolean free_segment)
102 g_free (array->data);
104 G_LOCK (array_mem_chunk);
105 g_mem_chunk_free (array_mem_chunk, array);
106 G_UNLOCK (array_mem_chunk);
110 g_array_append_vals (GArray *farray,
114 GRealArray *array = (GRealArray*) farray;
116 g_array_maybe_expand (array, len);
118 memcpy (g_array_elt_pos (array, array->len), data,
119 g_array_elt_len (array, len));
123 g_array_zero_terminate (array);
129 g_array_prepend_vals (GArray *farray,
133 GRealArray *array = (GRealArray*) farray;
135 g_array_maybe_expand (array, len);
137 g_memmove (g_array_elt_pos (array, len), g_array_elt_pos (array, 0),
138 g_array_elt_len (array, array->len));
140 memcpy (g_array_elt_pos (array, 0), data, g_array_elt_len (array, len));
144 g_array_zero_terminate (array);
150 g_array_insert_vals (GArray *farray,
155 GRealArray *array = (GRealArray*) farray;
157 g_array_maybe_expand (array, len);
159 g_memmove (g_array_elt_pos (array, len + index),
160 g_array_elt_pos (array, index),
161 g_array_elt_len (array, array->len - index));
163 memcpy (g_array_elt_pos (array, index), data, g_array_elt_len (array, len));
167 g_array_zero_terminate (array);
173 g_array_set_size (GArray *farray,
176 GRealArray *array = (GRealArray*) farray;
178 if (array->len < length)
180 g_array_maybe_expand (array, length - array->len);
183 g_array_elt_zero (array, array->len, length - array->len);
188 g_array_zero_terminate (array);
194 g_array_remove_index (GArray* farray,
197 GRealArray* array = (GRealArray*) farray;
199 g_return_val_if_fail (array, NULL);
201 g_return_val_if_fail (index >= 0 && index < array->len, NULL);
203 if (index != array->len - 1)
204 g_memmove (g_array_elt_pos (array, index),
205 g_array_elt_pos (array, index + 1),
206 g_array_elt_len (array, array->len - index - 1));
210 g_array_zero_terminate (array);
216 g_array_remove_index_fast (GArray* farray,
219 GRealArray* array = (GRealArray*) farray;
221 g_return_val_if_fail (array, NULL);
223 g_return_val_if_fail (index >= 0 && index < array->len, NULL);
225 if (index != array->len - 1)
226 g_memmove (g_array_elt_pos (array, index),
227 g_array_elt_pos (array, array->len - 1),
228 g_array_elt_len (array, 1));
232 g_array_zero_terminate (array);
238 g_nearest_pow (gint num)
249 g_array_maybe_expand (GRealArray *array,
252 guint want_alloc = g_array_elt_len (array, array->len + len +
253 array->zero_terminated);
255 if (want_alloc > array->alloc)
257 array->alloc = g_nearest_pow (want_alloc);
258 array->alloc = MAX (array->alloc, MIN_ARRAY_SIZE);
260 array->data = g_realloc (array->data, array->alloc);
267 typedef struct _GRealPtrArray GRealPtrArray;
269 struct _GRealPtrArray
276 static void g_ptr_array_maybe_expand (GRealPtrArray *array,
279 static GMemChunk *ptr_array_mem_chunk = NULL;
280 G_LOCK_DEFINE_STATIC (ptr_array_mem_chunk);
284 g_ptr_array_new (void)
286 GRealPtrArray *array;
288 G_LOCK (ptr_array_mem_chunk);
289 if (!ptr_array_mem_chunk)
290 ptr_array_mem_chunk = g_mem_chunk_new ("array mem chunk",
291 sizeof (GRealPtrArray),
292 1024, G_ALLOC_AND_FREE);
294 array = g_chunk_new (GRealPtrArray, ptr_array_mem_chunk);
295 G_UNLOCK (ptr_array_mem_chunk);
301 return (GPtrArray*) array;
305 g_ptr_array_free (GPtrArray *array,
306 gboolean free_segment)
308 g_return_if_fail (array);
311 g_free (array->pdata);
313 G_LOCK (ptr_array_mem_chunk);
314 g_mem_chunk_free (ptr_array_mem_chunk, array);
315 G_UNLOCK (ptr_array_mem_chunk);
319 g_ptr_array_maybe_expand (GRealPtrArray *array,
322 if ((array->len + len) > array->alloc)
324 array->alloc = g_nearest_pow (array->len + len);
325 array->alloc = MAX (array->alloc, MIN_ARRAY_SIZE);
326 array->pdata = g_realloc (array->pdata, sizeof(gpointer) * array->alloc);
331 g_ptr_array_set_size (GPtrArray *farray,
334 GRealPtrArray* array = (GRealPtrArray*) farray;
336 g_return_if_fail (array);
338 if (length > array->len)
341 g_ptr_array_maybe_expand (array, (length - array->len));
343 * memset (array->pdata + array->len, 0,
344 * sizeof (gpointer) * (length - array->len));
345 * to make it really portable. Remember (void*)NULL needn't be
346 * bitwise zero. It of course is silly not to use memset (..,0,..).
348 for (i = array->len; i < length; i++)
349 array->pdata[i] = NULL;
356 g_ptr_array_remove_index (GPtrArray* farray,
359 GRealPtrArray* array = (GRealPtrArray*) farray;
362 g_return_val_if_fail (array, NULL);
364 g_return_val_if_fail (index >= 0 && index < array->len, NULL);
366 result = array->pdata[index];
368 if (index != array->len - 1)
369 g_memmove (array->pdata + index, array->pdata + index + 1,
370 sizeof (gpointer) * (array->len - index - 1));
378 g_ptr_array_remove_index_fast (GPtrArray* farray,
381 GRealPtrArray* array = (GRealPtrArray*) farray;
384 g_return_val_if_fail (array, NULL);
386 g_return_val_if_fail (index >= 0 && index < array->len, NULL);
388 result = array->pdata[index];
390 if (index != array->len - 1)
391 array->pdata[index] = array->pdata[array->len - 1];
399 g_ptr_array_remove (GPtrArray* farray,
402 GRealPtrArray* array = (GRealPtrArray*) farray;
405 g_return_val_if_fail (array, FALSE);
407 for (i = 0; i < array->len; i += 1)
409 if (array->pdata[i] == data)
411 g_ptr_array_remove_index (farray, i);
420 g_ptr_array_remove_fast (GPtrArray* farray,
423 GRealPtrArray* array = (GRealPtrArray*) farray;
426 g_return_val_if_fail (array, FALSE);
428 for (i = 0; i < array->len; i += 1)
430 if (array->pdata[i] == data)
432 g_ptr_array_remove_index_fast (farray, i);
441 g_ptr_array_add (GPtrArray* farray,
444 GRealPtrArray* array = (GRealPtrArray*) farray;
446 g_return_if_fail (array);
448 g_ptr_array_maybe_expand (array, 1);
450 array->pdata[array->len++] = data;
456 GByteArray* g_byte_array_new (void)
458 return (GByteArray*) g_array_new (FALSE, FALSE, 1);
461 void g_byte_array_free (GByteArray *array,
462 gboolean free_segment)
464 g_array_free ((GArray*) array, free_segment);
467 GByteArray* g_byte_array_append (GByteArray *array,
471 g_array_append_vals ((GArray*) array, (guint8*)data, len);
476 GByteArray* g_byte_array_prepend (GByteArray *array,
480 g_array_prepend_vals ((GArray*) array, (guint8*)data, len);
485 GByteArray* g_byte_array_set_size (GByteArray *array,
488 g_array_set_size ((GArray*) array, length);
493 GByteArray* g_byte_array_remove_index (GByteArray *array,
496 g_array_remove_index((GArray*) array, index);
501 GByteArray* g_byte_array_remove_index_fast (GByteArray *array,
504 g_array_remove_index_fast((GArray*) array, index);