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 Lesser 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 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser 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-2000. 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/.
40 #include "gmessages.h"
46 #define MIN_ARRAY_SIZE 16
48 typedef struct _GRealArray GRealArray;
56 guint zero_terminated : 1;
60 #define g_array_elt_len(array,i) ((array)->elt_size * (i))
61 #define g_array_elt_pos(array,i) ((array)->data + g_array_elt_len((array),(i)))
62 #define g_array_elt_zero(array, pos, len) \
63 (memset (g_array_elt_pos ((array), pos), 0, g_array_elt_len ((array), len)))
64 #define g_array_zero_terminate(array) G_STMT_START{ \
65 if ((array)->zero_terminated) \
66 g_array_elt_zero ((array), (array)->len, 1); \
69 static gint g_nearest_pow (gint num) G_GNUC_CONST;
70 static void g_array_maybe_expand (GRealArray *array,
74 g_array_new (gboolean zero_terminated,
78 return (GArray*) g_array_sized_new (zero_terminated, clear, elt_size, 0);
81 GArray* g_array_sized_new (gboolean zero_terminated,
86 GRealArray *array = g_slice_new (GRealArray);
91 array->zero_terminated = (zero_terminated ? 1 : 0);
92 array->clear = (clear ? 1 : 0);
93 array->elt_size = elt_size;
95 if (array->zero_terminated || reserved_size != 0)
97 g_array_maybe_expand (array, reserved_size);
98 g_array_zero_terminate(array);
101 return (GArray*) array;
105 g_array_free (GArray *array,
106 gboolean free_segment)
110 g_return_val_if_fail (array, NULL);
114 g_free (array->data);
118 segment = array->data;
120 g_slice_free1 (sizeof (GRealArray), array);
126 g_array_append_vals (GArray *farray,
130 GRealArray *array = (GRealArray*) farray;
132 g_array_maybe_expand (array, len);
134 memcpy (g_array_elt_pos (array, array->len), data,
135 g_array_elt_len (array, len));
139 g_array_zero_terminate (array);
145 g_array_prepend_vals (GArray *farray,
149 GRealArray *array = (GRealArray*) farray;
151 g_array_maybe_expand (array, len);
153 g_memmove (g_array_elt_pos (array, len), g_array_elt_pos (array, 0),
154 g_array_elt_len (array, array->len));
156 memcpy (g_array_elt_pos (array, 0), data, g_array_elt_len (array, len));
160 g_array_zero_terminate (array);
166 g_array_insert_vals (GArray *farray,
171 GRealArray *array = (GRealArray*) farray;
173 g_array_maybe_expand (array, len);
175 g_memmove (g_array_elt_pos (array, len + index),
176 g_array_elt_pos (array, index),
177 g_array_elt_len (array, array->len - index));
179 memcpy (g_array_elt_pos (array, index), data, g_array_elt_len (array, len));
183 g_array_zero_terminate (array);
189 g_array_set_size (GArray *farray,
192 GRealArray *array = (GRealArray*) farray;
193 if (length > array->len)
195 g_array_maybe_expand (array, length - array->len);
198 g_array_elt_zero (array, array->len, length - array->len);
200 #ifdef ENABLE_GC_FRIENDLY
201 else if (length < array->len)
202 g_array_elt_zero (array, length, array->len - length);
203 #endif /* ENABLE_GC_FRIENDLY */
207 g_array_zero_terminate (array);
213 g_array_remove_index (GArray* farray,
216 GRealArray* array = (GRealArray*) farray;
218 g_return_val_if_fail (array, NULL);
220 g_return_val_if_fail (index < array->len, NULL);
222 if (index != array->len - 1)
223 g_memmove (g_array_elt_pos (array, index),
224 g_array_elt_pos (array, index + 1),
225 g_array_elt_len (array, array->len - index - 1));
229 #ifdef ENABLE_GC_FRIENDLY
230 g_array_elt_zero (array, array->len, 1);
231 #else /* !ENABLE_GC_FRIENDLY */
232 g_array_zero_terminate (array);
233 #endif /* ENABLE_GC_FRIENDLY */
239 g_array_remove_index_fast (GArray* farray,
242 GRealArray* array = (GRealArray*) farray;
244 g_return_val_if_fail (array, NULL);
246 g_return_val_if_fail (index < array->len, NULL);
248 if (index != array->len - 1)
249 memcpy (g_array_elt_pos (array, index),
250 g_array_elt_pos (array, array->len - 1),
251 g_array_elt_len (array, 1));
255 #ifdef ENABLE_GC_FRIENDLY
256 g_array_elt_zero (array, array->len, 1);
257 #else /* !ENABLE_GC_FRIENDLY */
258 g_array_zero_terminate (array);
259 #endif /* ENABLE_GC_FRIENDLY */
265 g_array_remove_range (GArray *farray,
269 GRealArray *array = (GRealArray*) farray;
271 g_return_val_if_fail (array, NULL);
272 g_return_val_if_fail (index_ < array->len, NULL);
273 g_return_val_if_fail (index_ + length <= array->len, NULL);
275 if (index_ + length != array->len)
276 g_memmove (g_array_elt_pos (array, index_),
277 g_array_elt_pos (array, index_ + length),
278 (array->len - (index_ + length)) * array->elt_size);
280 array->len -= length;
281 #ifdef ENABLE_GC_FRIENDLY
282 g_array_elt_zero (array, array->len, length);
283 #else /* !ENABLE_GC_FRIENDLY */
284 g_array_zero_terminate (array);
285 #endif /* ENABLE_GC_FRIENDLY */
291 g_array_sort (GArray *farray,
292 GCompareFunc compare_func)
294 GRealArray *array = (GRealArray*) farray;
296 g_return_if_fail (array != NULL);
305 g_array_sort_with_data (GArray *farray,
306 GCompareDataFunc compare_func,
309 GRealArray *array = (GRealArray*) farray;
311 g_return_if_fail (array != NULL);
313 g_qsort_with_data (array->data,
322 g_nearest_pow (gint num)
333 g_array_maybe_expand (GRealArray *array,
336 guint want_alloc = g_array_elt_len (array, array->len + len +
337 array->zero_terminated);
339 if (want_alloc > array->alloc)
341 want_alloc = g_nearest_pow (want_alloc);
342 want_alloc = MAX (want_alloc, MIN_ARRAY_SIZE);
344 array->data = g_realloc (array->data, want_alloc);
346 #ifdef ENABLE_GC_FRIENDLY
347 memset (array->data + array->alloc, 0, want_alloc - array->alloc);
348 #endif /* ENABLE_GC_FRIENDLY */
350 array->alloc = want_alloc;
357 typedef struct _GRealPtrArray GRealPtrArray;
359 struct _GRealPtrArray
366 static void g_ptr_array_maybe_expand (GRealPtrArray *array,
370 g_ptr_array_new (void)
372 return g_ptr_array_sized_new (0);
376 g_ptr_array_sized_new (guint reserved_size)
378 GRealPtrArray *array = g_slice_new (GRealPtrArray);
384 if (reserved_size != 0)
385 g_ptr_array_maybe_expand (array, reserved_size);
387 return (GPtrArray*) array;
391 g_ptr_array_free (GPtrArray *array,
392 gboolean free_segment)
396 g_return_val_if_fail (array, NULL);
400 g_free (array->pdata);
404 segment = array->pdata;
406 g_slice_free1 (sizeof (GRealPtrArray), array);
412 g_ptr_array_maybe_expand (GRealPtrArray *array,
415 if ((array->len + len) > array->alloc)
417 #ifdef ENABLE_GC_FRIENDLY
418 guint old_alloc = array->alloc;
419 #endif /* ENABLE_GC_FRIENDLY */
420 array->alloc = g_nearest_pow (array->len + len);
421 array->alloc = MAX (array->alloc, MIN_ARRAY_SIZE);
422 array->pdata = g_realloc (array->pdata, sizeof (gpointer) * array->alloc);
423 #ifdef ENABLE_GC_FRIENDLY
424 for ( ; old_alloc < array->alloc; old_alloc++)
425 array->pdata [old_alloc] = NULL;
426 #endif /* ENABLE_GC_FRIENDLY */
431 g_ptr_array_set_size (GPtrArray *farray,
434 GRealPtrArray* array = (GRealPtrArray*) farray;
436 g_return_if_fail (array);
438 if (length > array->len)
441 g_ptr_array_maybe_expand (array, (length - array->len));
443 * memset (array->pdata + array->len, 0,
444 * sizeof (gpointer) * (length - array->len));
445 * to make it really portable. Remember (void*)NULL needn't be
446 * bitwise zero. It of course is silly not to use memset (..,0,..).
448 for (i = array->len; i < length; i++)
449 array->pdata[i] = NULL;
451 #ifdef ENABLE_GC_FRIENDLY
452 else if (length < array->len)
455 for (i = length; i < array->len; i++)
456 array->pdata[i] = NULL;
458 #endif /* ENABLE_GC_FRIENDLY */
464 g_ptr_array_remove_index (GPtrArray* farray,
467 GRealPtrArray* array = (GRealPtrArray*) farray;
470 g_return_val_if_fail (array, NULL);
472 g_return_val_if_fail (index < array->len, NULL);
474 result = array->pdata[index];
476 if (index != array->len - 1)
477 g_memmove (array->pdata + index, array->pdata + index + 1,
478 sizeof (gpointer) * (array->len - index - 1));
482 #ifdef ENABLE_GC_FRIENDLY
483 array->pdata[array->len] = NULL;
484 #endif /* ENABLE_GC_FRIENDLY */
490 g_ptr_array_remove_index_fast (GPtrArray* farray,
493 GRealPtrArray* array = (GRealPtrArray*) farray;
496 g_return_val_if_fail (array, NULL);
498 g_return_val_if_fail (index < array->len, NULL);
500 result = array->pdata[index];
502 if (index != array->len - 1)
503 array->pdata[index] = array->pdata[array->len - 1];
507 #ifdef ENABLE_GC_FRIENDLY
508 array->pdata[array->len] = NULL;
509 #endif /* ENABLE_GC_FRIENDLY */
515 g_ptr_array_remove_range (GPtrArray* farray,
519 GRealPtrArray* array = (GRealPtrArray*) farray;
521 g_return_if_fail (array);
522 g_return_if_fail (index_ < array->len);
523 g_return_if_fail (index_ + length <= array->len);
525 if (index_ + length != array->len)
526 g_memmove (&array->pdata[index_],
527 &array->pdata[index_ + length],
528 (array->len - (index_ + length)) * sizeof (gpointer));
530 array->len -= length;
531 #ifdef ENABLE_GC_FRIENDLY
534 for (i = 0; i < length; i++)
535 array->pdata[array->len + i] = NULL;
537 #endif /* ENABLE_GC_FRIENDLY */
541 g_ptr_array_remove (GPtrArray* farray,
544 GRealPtrArray* array = (GRealPtrArray*) farray;
547 g_return_val_if_fail (array, FALSE);
549 for (i = 0; i < array->len; i += 1)
551 if (array->pdata[i] == data)
553 g_ptr_array_remove_index (farray, i);
562 g_ptr_array_remove_fast (GPtrArray* farray,
565 GRealPtrArray* array = (GRealPtrArray*) farray;
568 g_return_val_if_fail (array, FALSE);
570 for (i = 0; i < array->len; i += 1)
572 if (array->pdata[i] == data)
574 g_ptr_array_remove_index_fast (farray, i);
583 g_ptr_array_add (GPtrArray* farray,
586 GRealPtrArray* array = (GRealPtrArray*) farray;
588 g_return_if_fail (array);
590 g_ptr_array_maybe_expand (array, 1);
592 array->pdata[array->len++] = data;
596 g_ptr_array_sort (GPtrArray *array,
597 GCompareFunc compare_func)
599 g_return_if_fail (array != NULL);
608 g_ptr_array_sort_with_data (GPtrArray *array,
609 GCompareDataFunc compare_func,
612 g_return_if_fail (array != NULL);
614 g_qsort_with_data (array->pdata,
622 * g_ptr_array_foreach:
623 * @array: a #GPtrArray
624 * @func: the function to call for each array element
625 * @user_data: user data to pass to the function
627 * Calls a function for each element of a #GPtrArray.
632 g_ptr_array_foreach (GPtrArray *array,
638 g_return_if_fail (array);
640 for (i = 0; i < array->len; i++)
641 (*func) (array->pdata[i], user_data);
647 GByteArray* g_byte_array_new (void)
649 return (GByteArray*) g_array_sized_new (FALSE, FALSE, 1, 0);
652 GByteArray* g_byte_array_sized_new (guint reserved_size)
654 return (GByteArray*) g_array_sized_new (FALSE, FALSE, 1, reserved_size);
657 guint8* g_byte_array_free (GByteArray *array,
658 gboolean free_segment)
660 return (guint8*) g_array_free ((GArray*) array, free_segment);
663 GByteArray* g_byte_array_append (GByteArray *array,
667 g_array_append_vals ((GArray*) array, (guint8*)data, len);
672 GByteArray* g_byte_array_prepend (GByteArray *array,
676 g_array_prepend_vals ((GArray*) array, (guint8*)data, len);
681 GByteArray* g_byte_array_set_size (GByteArray *array,
684 g_array_set_size ((GArray*) array, length);
689 GByteArray* g_byte_array_remove_index (GByteArray *array,
692 g_array_remove_index((GArray*) array, index);
697 GByteArray* g_byte_array_remove_index_fast (GByteArray *array,
700 g_array_remove_index_fast((GArray*) array, index);
706 g_byte_array_remove_range (GByteArray *array,
710 g_return_val_if_fail (array, NULL);
711 g_return_val_if_fail (index_ < array->len, NULL);
712 g_return_val_if_fail (index_ + length <= array->len, NULL);
714 return (GByteArray *)g_array_remove_range ((GArray*) array, index_, length);
718 g_byte_array_sort (GByteArray *array,
719 GCompareFunc compare_func)
721 g_array_sort ((GArray *) array, compare_func);
725 g_byte_array_sort_with_data (GByteArray *array,
726 GCompareDataFunc compare_func,
729 g_array_sort_with_data ((GArray *) array, compare_func, user_data);
732 #define __G_ARRAY_C__
733 #include "galiasdef.c"