xemacs-beta: src/dynarr.c comparison

comparison src/dynarr.c @ 5125:b5df3737028a ben-lisp-object

merge

author	Ben Wing <ben@xemacs.org>
date	Wed, 24 Feb 2010 01:58:04 -0600
parents	d1247f3cc363 838630c0734f
children	2a462149bd6a

comparison

equal deleted inserted replaced

-:623d57b7fbe8
+:b5df3737028a
 /* Support for dynamic arrays.
 Copyright (C) 1993 Sun Microsystems, Inc.
-Copyright (C) 2002, 2003, 2004 Ben Wing.
+Copyright (C) 2002, 2003, 2004, 2005, 2010 Ben Wing.
 This file is part of XEmacs.
 XEmacs is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 int Dynarr_length(d)
 [MACRO] Return the number of elements currently in a dynamic array.
 int Dynarr_largest(d)
 [MACRO] Return the maximum value that Dynarr_length(d) would
-ever have returned.
+ever have returned.  This is used esp. in the redisplay code,
+which reuses dynarrs for performance reasons.
 type Dynarr_at(d, i)
 [MACRO] Return the element at the specified index (no bounds checking
 done on the index).  The element itself is returned, not a pointer
 to it.
 */
 #include <config.h>
 #include "lisp.h"
+static const struct memory_description const_Ascbyte_ptr_description_1[] = {
+{ XD_ASCII_STRING, 0 },
+{ XD_END }
+};
+const struct sized_memory_description const_Ascbyte_ptr_description = {
+sizeof (const Ascbyte *),
+const_Ascbyte_ptr_description_1
+};
+static const struct memory_description const_Ascbyte_ptr_dynarr_description_1[] = {
+XD_DYNARR_DESC (const_Ascbyte_ptr_dynarr, &const_Ascbyte_ptr_description),
+{ XD_END }
+};
+const struct sized_memory_description const_Ascbyte_ptr_dynarr_description = {
+sizeof (const_Ascbyte_ptr_dynarr),
+const_Ascbyte_ptr_dynarr_description_1
+};
 static int Dynarr_min_size = 8;
 static void
 Dynarr_realloc (Dynarr *dy, int new_size)
 {
 if (DUMPEDP (dy->base))
 {
 void *new_base = malloc (new_size * dy->elsize);
 memcpy (new_base, dy->base,
-	      (dy->max < new_size ? dy->max : new_size) * dy->elsize);
+	      (Dynarr_max (dy) < new_size ? Dynarr_max (dy) : new_size) *
+	      dy->elsize);
 dy->base = new_base;
 }
 else
 dy->base = xrealloc (dy->base, new_size * dy->elsize);
 }
 {
 void *new_base =
 XPNTR (alloc_sized_lrecord_array (dy->elsize, new_size, dy->lisp_imp));
 if (dy->base)
 memcpy (new_base, dy->base,
-	    (dy->max < new_size ? dy->max : new_size) * dy->elsize);
+	    (Dynarr_max (dy) < new_size ? Dynarr_max (dy) : new_size) *
+	    dy->elsize);
 dy->base = new_base;
 }
 void *
 Dynarr_lisp_newf (Bytecount elsize,
 {
 int newsize;
 double multiplier;
 Dynarr *dy = (Dynarr *) Dynarr_verify (d);
-if (dy->max <= 8)
+if (Dynarr_max (dy) <= 8)
 multiplier = 2;
 else
 multiplier = 1.5;
-for (newsize = dy->max; newsize < size;)
+for (newsize = Dynarr_max (dy); newsize < size;)
 newsize = max (Dynarr_min_size, (int) (multiplier * newsize));
 /* Don't do anything if the array is already big enough. */
-if (newsize > dy->max)
+if (newsize > Dynarr_max (dy))
 {
 #ifdef NEW_GC
 if (dy->lisp_imp)
 	Dynarr_lisp_realloc (dy, newsize);
 else
 	Dynarr_realloc (dy, newsize);
 #else /* not NEW_GC */
 Dynarr_realloc (dy, newsize);
 #endif /* not NEW_GC */
-dy->max = newsize;
+dy->max_ = newsize;
 }
 }
 /* Add a number of contiguous elements to the array starting at START. */
 void
 Dynarr_insert_many (void *d, const void *el, int len, int start)
 {
-Dynarr *dy = (Dynarr *) Dynarr_verify (d);
+Dynarr *dy = Dynarr_verify_mod (d);
-Dynarr_resize (dy, dy->cur+len);
+Dynarr_resize_if (dy, len);
-#if 0
-/* WTF? We should be catching these problems. */
+/* #### This could conceivably be wrong, if code wants to access stuff
-/* Silently adjust start to be valid. */
+between len and largest. */
-if (start > dy->cur)
+dynarr_checking_assert (start >= 0 && start <= Dynarr_length (dy));
-start = dy->cur;
-else if (start < 0)
+if (start != Dynarr_length (dy))
-start = 0;
-#else
-assert (start >= 0 && start <= dy->cur);
-#endif
-if (start != dy->cur)
 {
 memmove ((char *) dy->base + (start + len)*dy->elsize,
 	       (char *) dy->base + start*dy->elsize,
-	       (dy->cur - start)*dy->elsize);
+	       (Dynarr_length (dy) - start)*dy->elsize);
 }
+/* Some functions call us with a value of 0 to mean "reserve space but
+don't write into it" */
 if (el)
 memcpy ((char *) dy->base + start*dy->elsize, el, len*dy->elsize);
-dy->cur += len;
+Dynarr_set_length_1 (dy, Dynarr_length (dy) + len);
-if (dy->cur > dy->largest)
+(void) Dynarr_verify_mod (dy);
-dy->largest = dy->cur;
 }
 void
 Dynarr_delete_many (void *d, int start, int len)
 {
-Dynarr *dy = (Dynarr *) Dynarr_verify (d);
+Dynarr *dy = Dynarr_verify_mod (d);
-assert (start >= 0 && len >= 0 && start + len <= dy->cur);
+dynarr_checking_assert (start >= 0 && len >= 0 &&
+			  start + len <= Dynarr_length (dy));
 memmove ((char *) dy->base + start*dy->elsize,
 	   (char *) dy->base + (start + len)*dy->elsize,
-	   (dy->cur - start - len)*dy->elsize);
+	   (Dynarr_length (dy) - start - len)*dy->elsize);
-dy->cur -= len;
+Dynarr_set_length_1 (dy, Dynarr_length (dy) - len);
+(void) Dynarr_verify_mod (dy);
 }
 void
 Dynarr_free (void *d)
 {
 #ifdef NEW_GC
 if (dy->base && !DUMPEDP (dy->base))
 {
 if (!dy->lisp_imp)
-	xfree (dy->base, void *);
+	xfree (dy->base);
 }
 if(!DUMPEDP (dy))
 {
 if (!dy->lisp_imp)
-	xfree (dy, Dynarr *);
+	xfree (dy);
 }
 #else /* not NEW_GC */
 if (dy->base && !DUMPEDP (dy->base))
-xfree (dy->base, void *);
+xfree (dy->base);
 if(!DUMPEDP (dy))
-xfree (dy, Dynarr *);
+xfree (dy);
 #endif /* not NEW_GC */
 }
 #ifdef MEMORY_USAGE_STATS
 memory that malloc() will claim as "requested" was actually
 requested. */
 if (dy->base)
 {
-Bytecount malloc_used = malloced_storage_size (dy->base,
+Bytecount malloc_used =
-						     dy->elsize * dy->max, 0);
+	malloced_storage_size (dy->base, dy->elsize * Dynarr_max (dy), 0);
 /* #### This may or may not be correct.  Some Dynarrs would
-	 prefer that we use dy->cur instead of dy->largest here. */
+	 prefer that we use dy->len instead of dy->largest here. */
-Bytecount was_requested = dy->elsize * dy->largest;
+Bytecount was_requested = dy->elsize * Dynarr_largest (dy);
-Bytecount dynarr_overhead = dy->elsize * (dy->max - dy->largest);
+Bytecount dynarr_overhead =
+	dy->elsize * (Dynarr_max (dy) - Dynarr_largest (dy));
 total += malloc_used;
 stats->was_requested += was_requested;
 stats->dynarr_overhead += dynarr_overhead;
 /* And the remainder must be malloc overhead. */
 if (Dynarr_length (stack_like_free_list) > 0)
 this_one = Dynarr_pop (stack_like_free_list);
 else
 this_one = Dynarr_new (char);
 Dynarr_add (stack_like_in_use_list, this_one);
-Dynarr_resize (this_one, size);
+Dynarr_reset (this_one);
-return Dynarr_atp (this_one, 0);
+Dynarr_add_many (this_one, 0, size);
+return Dynarr_begin (this_one);
 }
 void
 stack_like_free (void *val)
 {
 assert (len > 0);
 /* The vast majority of times, we will be called in a last-in first-out
 order, and the item at the end of the list will be the one we're
 looking for, so just check for this first and avoid any function
 calls. */
-if (Dynarr_atp (Dynarr_at (stack_like_in_use_list, len - 1), 0) == val)
+if (Dynarr_begin (Dynarr_at (stack_like_in_use_list, len - 1)) == val)
 {
 char_dynarr *this_one = Dynarr_pop (stack_like_in_use_list);
 Dynarr_add (stack_like_free_list, this_one);
 }
 else
 {
 /* Find the item and delete it. */
 int i;
 assert (len >= 2);
 for (i = len - 2; i >= 0; i--)
-	if (Dynarr_atp (Dynarr_at (stack_like_in_use_list, i), 0) ==
+	if (Dynarr_begin (Dynarr_at (stack_like_in_use_list, i)) ==
 	    val)
 	  {
 	    char_dynarr *this_one = Dynarr_at (stack_like_in_use_list, i);
 	    Dynarr_add (stack_like_free_list, this_one);
 	    Dynarr_delete (stack_like_in_use_list, i);

Mercurial > hg > xemacs-beta

comparison src/dynarr.c @ 5125:b5df3737028a ben-lisp-object