Index: classes/resizablepmcarray.pmc
===================================================================
--- classes/resizablepmcarray.pmc	(revision 8687)
+++ classes/resizablepmcarray.pmc	(working copy)
@@ -506,7 +506,7 @@
 
     PMC* clone () {
         PMC *copy = SUPER();
-
+        /* copy trimmed extra space */
         PMC_int_val2(copy) = PMC_int_val(SELF);
         return copy;
     }
Index: classes/resizableintegerarray.pmc
===================================================================
--- classes/resizableintegerarray.pmc	(revision 8687)
+++ classes/resizableintegerarray.pmc	(working copy)
@@ -21,11 +21,6 @@
 
 #include "parrot/parrot.h"
 
-typedef struct _SizeIntData {
-    INTVAL size;
-    INTVAL data[1];
-} SizeIntData;
-#define NEEDED_SIZE(n) ((n-1)*sizeof(INTVAL) + sizeof(SizeIntData))
 
 pmclass ResizableIntegerArray extends FixedIntegerArray need_ext does array {
 
@@ -40,15 +35,15 @@
 */
 
     INTVAL get_integer_keyed_int (INTVAL key) {
-        SizeIntData *sd;
+        INTVAL *data;
         if (key < 0)
             internal_exception(OUT_OF_BOUNDS,
                 "ResizableIntegerArray: index out of bounds!");
         if(key >= PMC_int_val(SELF))
             DYNSELF.set_integer_native(key+1);
 
-        sd = (SizeIntData *)PMC_data(SELF);
-        return sd->data[key];
+        data = (INTVAL *)PMC_data(SELF);
+        return data[key];
     }
 
 /*
@@ -62,15 +57,15 @@
 */
 
     void set_integer_keyed_int (INTVAL key, INTVAL value) {
-        SizeIntData *sd;
+        INTVAL *data;
         if (key < 0)
             internal_exception(OUT_OF_BOUNDS,
                 "ResizableIntegerArray: index out of bounds!");
         if(key >= PMC_int_val(SELF))
             DYNSELF.set_integer_native(key+1);
 
-        sd = (SizeIntData *)PMC_data(SELF);
-        sd->data[key] = value;
+        data = (INTVAL *)PMC_data(SELF);
+        data[key] = value;
     }
 
 /*
@@ -84,35 +79,50 @@
 */
 
     void set_integer_native (INTVAL size) {
-        SizeIntData *sd;
         if (size < 0)
             internal_exception(OUT_OF_BOUNDS,
-                    "ResizableIntegerArray: Can't resize!");
+                    "ResizableStringArray: Can't resize!");
 
-        sd = PMC_data(SELF);
-        PMC_int_val(SELF) = size;
-        if(sd == NULL) {
-            sd = mem_sys_allocate_zeroed(NEEDED_SIZE(size));
-            sd->size = size;
-        } else if(size >= sd->size) {
-            INTVAL old = sd->size;
-            sd->size =  size < 2*sd->size ? sd->size*2 : size;
-            sd = mem_sys_realloc(sd, NEEDED_SIZE(sd->size));
-            memset(sd->data + old, 0, (sd->size - old) * sizeof(INTVAL));
-        } else {
+        if(!PMC_data(SELF)) {
+            /* empty - used fixed routine */
+            if (size < 8) {
+                SUPER(8);
+                PMC_int_val(SELF) = size;
+                PMC_int_val2(SELF) = 8;
+            }
+            else {
+                SUPER(size);
+                PMC_int_val2(SELF) = size;
+            }
+        }
+        else if (size <= PMC_int_val2(SELF)) {
+            PMC_int_val(SELF) = size;
+            /* we could shrink here if necessary */
             return;
         }
-
-        PMC_data(SELF) = sd;
-        PObj_active_destroy_SET(SELF);
+        else {
+            INTVAL cur, needed;
+            cur = PMC_int_val2(SELF);
+            if (cur < 8192)
+                cur = size < 2 * cur ? 2 * cur : size;
+            else {
+                needed = size - cur;
+                cur += needed + 4096;
+                cur &= ~0xfff;
+            }
+            PMC_data(SELF) = mem_sys_realloc(PMC_data(SELF),
+                    cur * sizeof(INTVAL));
+            PMC_int_val2(SELF) = cur;
+            PMC_int_val(SELF) = size;
+        }
     }
 
 /*
 
 =item C<void push_integer (INTVAL value)>
 
-Extends the array by adding an element of value C<value> to the end of
-the array.
+Extends the array by adding an element of value C<value> to the end
+of the array.
 
 =cut
 
@@ -136,19 +146,14 @@
     INTVAL pop_integer() {
         INTVAL size;
         INTVAL value;
-        SizeIntData *sd;
 
         size = PMC_int_val(SELF);
-        sd = (SizeIntData *)PMC_data(SELF);
-
-        if (sd == NULL || size == 0) {
+        if (size == 0) {
             internal_exception(OUT_OF_BOUNDS,
                     "ResizableIntegerArray: Can't pop from an empty array!");
         }
-
-	value = sd->data[size - 1];
+        value = DYNSELF.get_integer_keyed_int(size-1);
         DYNSELF.set_integer_native(size - 1);
-
         return value;
     }
 
@@ -163,18 +168,10 @@
 */
 
     PMC* clone () {
-        SizeIntData *sd;
-        PMC * dest = pmc_new(INTERP, SELF->vtable->base_type);
-
-        if (!PMC_data(SELF))
-            return dest;
-        PMC_int_val(dest) = PMC_int_val(SELF);
-        sd = PMC_data(SELF);
-
-        PMC_data(dest) = mem_sys_allocate(NEEDED_SIZE(sd->size));
-        mem_sys_memcopy(PMC_data(dest), PMC_data(SELF), NEEDED_SIZE(sd->size));
-        PObj_active_destroy_SET(dest);
-        return dest;
+        PMC *copy = SUPER();
+        /* copy trimmed extra space */
+        PMC_int_val2(copy) = PMC_int_val(SELF);
+        return copy;
     }
 
 }
@@ -192,6 +189,7 @@
 Initial version                  - Matt Fowles 2004-06-11
 Changed allocator to double size - Matt Fowles 2004-06-15
 Added push_integer               - Bernhard Schmalhofer 2004-10-17
+moved available size to int_val2 - Matt Fowles 2005-07-22
 
 =cut
 
Index: classes/resizablefloatarray.pmc
===================================================================
--- classes/resizablefloatarray.pmc	(revision 8687)
+++ classes/resizablefloatarray.pmc	(working copy)
@@ -22,12 +22,6 @@
 
 #include "parrot/parrot.h"
 
-typedef struct _SizeFloatData {
-    INTVAL size;
-    FLOATVAL data[1];
-} SizeFloatData;
-#define NEEDED_SIZE(n) ((n-1)*sizeof(FLOATVAL) + sizeof(SizeFloatData))
-
 pmclass ResizableFloatArray extends FixedFloatArray need_ext does array {
     
 
@@ -42,15 +36,15 @@
 */
 
     FLOATVAL get_number_keyed_int (INTVAL key) {
-        SizeFloatData *sd;
+        FLOATVAL *data;
         if (key < 0)
             internal_exception(OUT_OF_BOUNDS, 
                 "ResizableFloatArray: index out of bounds!");
         if (key >= PMC_int_val(SELF))
             DYNSELF.set_integer_native(key+1);
         
-        sd = (SizeFloatData *)PMC_data(SELF);
-        return sd->data[key];
+        data = (FLOATVAL *)PMC_data(SELF);
+        return data[key];
     }
 
 /*
@@ -65,15 +59,15 @@
 */
 
     void set_number_keyed_int (INTVAL key, FLOATVAL value) {
-        SizeFloatData *sd;
+        FLOATVAL *data;
         if (key < 0)
             internal_exception(OUT_OF_BOUNDS, 
                 "ResizableFloatArray: index out of bounds!");
         if(key >= PMC_int_val(SELF))
             DYNSELF.set_integer_native(key+1);
 
-        sd = (SizeFloatData *)PMC_data(SELF);
-        sd->data[key] = value;
+        data = (FLOATVAL *)PMC_data(SELF);
+        data[key] = value;
     }
 
 /*
@@ -94,28 +88,42 @@
 */
 
     void set_integer_native (INTVAL size) {
-        SizeFloatData *sd;
         if (size < 0)
             internal_exception(OUT_OF_BOUNDS, 
                     "ResizableFloatArray: Can't resize to negative value!");
 
-        sd = PMC_data(SELF);
-        PMC_int_val(SELF) = size;
-        if (sd == NULL) {
-            sd = mem_sys_allocate(NEEDED_SIZE(size));
-            sd->size = size;
-        } else if (size >= sd->size) {
-            sd->size = size < 2 * sd->size ? 2 * sd->size : size;
-            sd = mem_sys_realloc(sd, NEEDED_SIZE(sd->size));
-        } else if (size < sd->size / 2) {
-            sd->size = size * 3 / 2;
-            sd = mem_sys_realloc(sd, NEEDED_SIZE(sd->size));
-        } else {
+        if(!PMC_data(SELF)) {
+            /* empty - used fixed routine */
+            if (size < 8) {
+                SUPER(8);
+                PMC_int_val(SELF) = size;
+                PMC_int_val2(SELF) = 8;
+            }
+            else {
+                SUPER(size);
+                PMC_int_val2(SELF) = size;
+            }
+        }
+        else if (size <= PMC_int_val2(SELF)) {
+            PMC_int_val(SELF) = size;
+            /* we could shrink here if necessary */
             return;
         }
-
-        PMC_data(SELF) = sd;
-        PObj_active_destroy_SET(SELF);
+        else {
+            INTVAL cur, needed;
+            cur = PMC_int_val2(SELF);
+            if (cur < 8192)
+                cur = size < 2 * cur ? 2 * cur : size;
+            else {
+                needed = size - cur;
+                cur += needed + 4096;
+                cur &= ~0xfff;
+            }
+            PMC_data(SELF) = mem_sys_realloc(PMC_data(SELF),
+                    cur * sizeof(FLOATVAL));
+            PMC_int_val2(SELF) = cur;
+            PMC_int_val(SELF) = size;
+        }
     }
 
 /*
@@ -129,18 +137,10 @@
 */
 
     PMC* clone () {
-        SizeFloatData *sd;
-        PMC * dest = pmc_new(INTERP, SELF->vtable->base_type);
-    
-        if (!PMC_data(SELF))
-            return dest;
-        PMC_int_val(dest) = PMC_int_val(SELF);
-        sd = PMC_data(SELF);
-        
-        PMC_data(dest) = mem_sys_allocate(NEEDED_SIZE(sd->size));
-        mem_sys_memcopy(PMC_data(dest), PMC_data(SELF), NEEDED_SIZE(sd->size));
-        PObj_active_destroy_SET(dest);
-        return dest;
+        PMC *copy = SUPER();
+        /* copy trimmed extra space */
+        PMC_int_val2(copy) = PMC_int_val(SELF);
+        return copy;
     }
 
 /*
@@ -154,13 +154,8 @@
 */
 
     void push_float (FLOATVAL value) {
-        INTVAL size;
-        SizeFloatData *sd;
-
-        size = PMC_int_val(SELF);
-        DYNSELF.set_integer_native(size+1);
-        sd = (SizeFloatData *)PMC_data(SELF);
-        sd->data[size] = value;
+        INTVAL nextix = DYNSELF.elements();
+        DYNSELF.set_number_keyed_int(nextix, value);
     }
 
 /*
@@ -176,19 +171,16 @@
     FLOATVAL pop_float() {
         INTVAL size;
         FLOATVAL value;
-        SizeFloatData *sd;
 
         size = PMC_int_val(SELF);
-        sd = (SizeFloatData *)PMC_data(SELF);
 
-        if (sd == NULL || size == 0) {
+        if (size == 0) {
             internal_exception(OUT_OF_BOUNDS, 
                     "ResizableFloatArray: Can't pop from an empty array!");
         }
 
-	value = sd->data[size - 1];
+        value = DYNSELF.get_number_keyed_int(size-1);
         DYNSELF.set_integer_native(size - 1);
-
         return value;
     }
 
@@ -206,6 +198,7 @@
 
 Initial version                  - Matt Fowles 2004-06-11
 Changed allocator to double size - Matt Fowles 2004-06-15
+moved available size to int_val2 - Matt Fowles 2005-07-22
 
 =cut
 
Index: classes/resizablestringarray.pmc
===================================================================
--- classes/resizablestringarray.pmc	(revision 8687)
+++ classes/resizablestringarray.pmc	(working copy)
@@ -24,12 +24,6 @@
 
 #include "parrot/parrot.h"
 
-typedef struct _SizeStringData {
-    INTVAL size;
-    STRING* data[1];
-} SizeStringData;
-#define NEEDED_SIZE(n) ((n-1)*sizeof(STRING*) + sizeof(SizeStringData))
-
 pmclass ResizableStringArray extends FixedStringArray need_ext does array {
 
 /*
@@ -43,15 +37,15 @@
 */
 
     STRING* get_string_keyed_int (INTVAL key) {
-        SizeStringData *sd;
+        STRING **data;
         if (key < 0)
             internal_exception(OUT_OF_BOUNDS,
                 "ResizableStringArray: index out of bounds!");
         if(key >= PMC_int_val(SELF))
             DYNSELF.set_integer_native(key+1);
 
-        sd = (SizeStringData *)PMC_data(SELF);
-        return sd->data[key];
+        data = (STRING**)PMC_data(SELF);
+        return data[key];
     }
 
 /*
@@ -65,16 +59,16 @@
 */
 
     void set_string_keyed_int (INTVAL key, STRING* value) {
-        SizeStringData *sd;
+        STRING **data;
         if (key < 0)
             internal_exception(OUT_OF_BOUNDS,
                 "ResizableStringArray: index out of bounds!");
         if(key >= PMC_int_val(SELF))
             DYNSELF.set_integer_native(key+1);
 
-        sd = (SizeStringData *)PMC_data(SELF);
-        DOD_WRITE_BARRIER(INTERP, SELF, sd->data[key], value);
-        sd->data[key] = value;
+        data = (STRING**)PMC_data(SELF);
+        DOD_WRITE_BARRIER(INTERP, SELF, data[key], value);
+        data[key] = value;
     }
 
 /*
@@ -106,19 +100,14 @@
     STRING* pop_string() {
         INTVAL size;
         STRING* value;
-        SizeStringData *sd;
 
         size = PMC_int_val(SELF);
-        sd = (SizeStringData *)PMC_data(SELF);
-
-        if (sd == NULL || size == 0) {
+        if (size == 0) {
             internal_exception(OUT_OF_BOUNDS,
                     "ResizableStringArray: Can't pop from an empty array!");
         }
-
-	value = sd->data[size - 1];
+        value = DYNSELF.get_string_keyed_int(size-1);
         DYNSELF.set_integer_native(size - 1);
-
         return value;
     }
 
@@ -133,31 +122,44 @@
 */
 
     void set_integer_native (INTVAL size) {
-        SizeStringData *sd;
-
         if (size < 0)
             internal_exception(OUT_OF_BOUNDS,
                     "ResizableStringArray: Can't resize!");
 
-        sd = (SizeStringData *)PMC_data(SELF);
-        PMC_int_val(SELF) = size;
-        if(sd == NULL) {
-            /* The parent class makes the assumption that NULL pointers are all
-               bits zero, so we might as well too.  */
-            sd = mem_sys_allocate_zeroed(NEEDED_SIZE(size));
-            sd->size = size;
-        } else if(size >= sd->size) {
-            int i = sd->size;
-            sd->size =  size < 2*sd->size ? sd->size*2 : size;
-            sd = mem_sys_realloc(sd, NEEDED_SIZE(sd->size));
-            for(; i < sd->size; i++)
-                sd->data[i] = NULL;
-        } else {
+        if(!PMC_data(SELF)) {
+            /* empty - used fixed routine */
+            if (size < 8) {
+                SUPER(8);
+                PMC_int_val(SELF) = size;
+                PMC_int_val2(SELF) = 8;
+            }
+            else {
+                SUPER(size);
+                PMC_int_val2(SELF) = size;
+            }
+        }
+        else if (size <= PMC_int_val2(SELF)) {
+            PMC_int_val(SELF) = size;
+            /* we could shrink here if necessary */
             return;
         }
-
-        PMC_data(SELF) = sd;
-        PObj_custom_mark_destroy_SETALL(SELF);
+        else {
+            INTVAL i, cur, needed;
+            i = cur = PMC_int_val2(SELF);
+            if (cur < 8192)
+                cur = size < 2 * cur ? 2 * cur : size;
+            else {
+                needed = size - cur;
+                cur += needed + 4096;
+                cur &= ~0xfff;
+            }
+            PMC_data(SELF) = mem_sys_realloc(PMC_data(SELF),
+                    cur * sizeof(STRING*));
+            for (; i < cur; i++)
+                ((STRING**)PMC_data(SELF))[i] = NULL;
+            PMC_int_val2(SELF) = cur;
+            PMC_int_val(SELF) = size;
+        }
     }
 
 /*
@@ -171,46 +173,12 @@
 */
 
     PMC* clone () {
-        SizeStringData *sd;
-        PMC * dest = pmc_new(INTERP, SELF->vtable->base_type);
-
-        if (!PMC_data(SELF))
-            return dest;
-        PMC_int_val(dest) = PMC_int_val(SELF);
-        sd = (SizeStringData *)PMC_data(SELF);
-
-        PMC_data(dest) = mem_sys_allocate(NEEDED_SIZE(sd->size));
-        mem_sys_memcopy(PMC_data(dest), PMC_data(SELF), NEEDED_SIZE(sd->size));
-        PObj_custom_mark_destroy_SETALL(SELF);
-        return dest;
+        PMC *copy = SUPER();
+        /* copy trimmed extra space */
+        PMC_int_val2(copy) = PMC_int_val(SELF);
+        return copy;
     }
 
-/*
-
-=item C<void mark()>
-
-Marks the array as live.
-
-=cut
-
-*/
-
-    void mark () {
-        SizeStringData *sd;
-        int i, end;
-        STRING **data;
-        if (!PMC_data(SELF))
-            return;
-        sd = (SizeStringData *)PMC_data(SELF);
-        data = sd->data;
-        end = PMC_int_val(SELF);
-        for(i = 0; i < end; i++) {
-            if(data[i]) {
-                pobject_lives(INTERP, (PObj *) data[i]);
-            }
-        }
-    }
-
 }
 
 /*
@@ -226,6 +194,7 @@
 Initial version                  - Matt Fowles 2004-06-11
 Changed allocator to double size - Matt Fowles 2004-06-15
 Added push_string                - Bernhard Schmalhofer 2004-10-17
+moved available size to int_val2 - Matt Fowles 2005-07-22
 
 =cut
 
Index: classes/resizablebooleanarray.pmc
===================================================================
--- classes/resizablebooleanarray.pmc	(revision 8687)
+++ classes/resizablebooleanarray.pmc	(working copy)
@@ -8,10 +8,10 @@
 
 =head1 DESCRIPTION
 
-The C<ResizableBooleanArray PMC> implements an array of resizable size,
-which stores booleans.
+The C<ResizableBooleanArray PMC> implements an array of resizable
+size, which stores booleans.
 It uses the C<Boolean PMC> for all conversions.
-The C<ResizableBooleanArray PMC> extends the C<FixedBooleanArray PMC>.
+C<ResizableBooleanArray PMC> extends C<FixedBooleanArray PMC>
 
 =head2 Functions
 
@@ -49,7 +49,6 @@
 */
 
     INTVAL get_integer_keyed_int (INTVAL key) {
-        Parrot_UInt1 *sd;
         if (key < 0)
             internal_exception(OUT_OF_BOUNDS,
                 "ResizableBooleanArray: index out of bounds!");
@@ -90,23 +89,35 @@
 */
 
     void set_integer_native (INTVAL size) {
-        Parrot_UInt1 *sd;
         if (size < 0)
             internal_exception(OUT_OF_BOUNDS,
                     "ResizableBooleanArray: Can't resize!");
 
         if ( ! PMC_data(SELF) ) {
             SUPER(size);
-        } else if ( size > PMC_int_val2(SELF) ) {
-            INTVAL old_size = PMC_int_val2(SELF);
-            PMC_int_val2(SELF) = size < 2*old_size ? 2*old_size : (size/BITS_PER_CHAR+1)*BITS_PER_CHAR;
-            sd = PMC_data(SELF);
-            PMC_data(SELF) = mem_sys_realloc(sd, PMC_int_val2(SELF)/BITS_PER_CHAR);
+        }
+        else if (size <= PMC_int_val2(SELF)) {
             PMC_int_val(SELF) = size;
-        } else {
-            PMC_int_val(SELF) = size;
+            /* we could shrink here if necessary */
             return;
         }
+        else {
+            INTVAL cur, needed;
+            cur = PMC_int_val2(SELF);
+            if (cur < 8192) {
+                cur = size < 2 * cur ? 2 * cur
+                    : (size/BITS_PER_CHAR+1)*BITS_PER_CHAR;
+            }
+            else {
+                needed = size - cur;
+                cur += needed + 4096;
+                cur &= ~0xfff;
+            }
+            PMC_data(SELF) = mem_sys_realloc(PMC_data(SELF),
+                    cur/BITS_PER_CHAR);
+            PMC_int_val(SELF) = size;
+            PMC_int_val2(SELF) = cur;
+        }
     }
 
 }
@@ -123,7 +134,6 @@
 
 Initial version                  - Matt Fowles 2004-06-11
 Changed allocator to double size - Matt Fowles 2004-06-15
-Added push_integer               - Bernhard Schmalhofer 2004-10-17
 
 =cut
 
