This patch re-implements the register backing stacks as PObjs (so they
can be garbage-collected), honors their COW flags, and adds them to the
interpreter context (where they should be, honest!).

As a healthy side-effect, it encapsulates their behavior nicely into
register.c, when before their guts were splattered all over the source.

Luke

Index: classes/continuation.pmc
===================================================================
RCS file: /cvs/public/parrot/classes/continuation.pmc,v
retrieving revision 1.17
diff -u -r1.17 continuation.pmc
--- classes/continuation.pmc    19 Dec 2003 10:01:36 -0000      1.17
+++ classes/continuation.pmc    8 Jan 2004 03:04:01 -0000
@@ -26,8 +26,7 @@
     void mark () {
         struct Parrot_Sub * cc
             = (struct Parrot_Sub*)PMC_sub(SELF);
-       mark_stack(INTERP, cc->ctx.user_stack);
-       mark_stack(INTERP, cc->ctx.control_stack);
+        mark_context(INTERP, &cc->ctx);
        SUPER();        /* mark pad_stack, warns in closure */
     }

Index: imcc/t/syn/pcc.t
===================================================================
RCS file: /cvs/public/parrot/imcc/t/syn/pcc.t,v
retrieving revision 1.28
diff -u -r1.28 pcc.t
--- imcc/t/syn/pcc.t    16 Dec 2003 08:53:44 -0000      1.28
+++ imcc/t/syn/pcc.t    8 Jan 2004 03:04:01 -0000
@@ -738,7 +738,7 @@
 .pcc_sub _sub1 non_prototyped
     .local pmc res1               # (visitReturn:528)
     find_lex $P2, 'g'             # (callingExpression:325)
-    newsub $P3, .Continuation, ret0 # (callingExpression:331)
+    newsub $P3, .RetContinuation, ret0 # (callingExpression:331)
     .pcc_begin non_prototyped     # (callingExpression:332)
     .pcc_call $P2, $P3            # (callingExpression:335)
 ret0:
Index: include/parrot/interpreter.h
===================================================================
RCS file: /cvs/public/parrot/include/parrot/interpreter.h,v
retrieving revision 1.114
diff -u -r1.114 interpreter.h
--- include/parrot/interpreter.h        2 Jan 2004 14:09:32 -0000       1.114
+++ include/parrot/interpreter.h        8 Jan 2004 03:04:01 -0000
@@ -125,12 +125,10 @@
 struct _imc_info_t;

 typedef struct Parrot_Context {
-    struct IRegChunk *int_reg_top;    /* Current top chunk of int reg stack */
-    struct NRegChunk *num_reg_top;    /* Current top chunk of the float reg
-                                       * stack */
-    struct SRegChunk *string_reg_top; /* Current top chunk of the string
-                                       * stack */
-    struct PRegChunk *pmc_reg_top;    /* Current top chunk of the PMC stack */
+    struct RegStack int_reg_stack;
+    struct RegStack num_reg_stack;
+    struct RegStack string_reg_stack;
+    struct RegStack pmc_reg_stack;

     struct Stack_Chunk *pad_stack;      /* Base of the lex pad stack */
     struct Stack_Chunk *user_stack;     /* Base of the scratch stack */
Index: include/parrot/register.h
===================================================================
RCS file: /cvs/public/parrot/include/parrot/register.h,v
retrieving revision 1.17
diff -u -r1.17 register.h
--- include/parrot/register.h   21 Jul 2003 18:00:42 -0000      1.17
+++ include/parrot/register.h   8 Jan 2004 03:04:01 -0000
@@ -48,38 +48,43 @@
     PMC *registers[NUM_REGISTERS/2];
 };

-struct IRegChunk {
+struct RegStack {
+    struct RegisterChunkBuf* top;
+    size_t chunk_size;
+};
+
+/* Base class for the RegChunk types */
+struct RegisterChunkBuf {
+    Buffer data;
     size_t used;
-    Stack_chunk_flags flags;
-    struct IRegChunk *next;
-    struct IRegChunk *prev;
+    struct RegisterChunkBuf* next;
+};
+
+struct IRegChunkBuf {
     struct IRegFrame IRegFrame[FRAMES_PER_CHUNK];
 };

-struct NRegChunk {
-    size_t used;
-    Stack_chunk_flags flags;
-    struct NRegChunk *next;
-    struct NRegChunk *prev;
+struct NRegChunkBuf {
     struct NRegFrame NRegFrame[FRAMES_PER_CHUNK];
 };

-struct SRegChunk {
-    size_t used;
-    Stack_chunk_flags flags;
-    struct SRegChunk *next;
-    struct SRegChunk *prev;
+struct SRegChunkBuf {
     struct SRegFrame SRegFrame[FRAMES_PER_CHUNK];
 };

-struct PRegChunk {
-    size_t used;
-    Stack_chunk_flags flags;
-    struct PRegChunk *next;
-    struct PRegChunk *prev;
+struct PRegChunkBuf {
     struct PRegFrame PRegFrame[FRAMES_PER_CHUNK];
 };

+void setup_register_stacks(struct Parrot_Interp* interpreter);
+void mark_register_stack_cow(struct Parrot_Interp* interpreter,
+                             struct RegStack* stack);
+void mark_pmc_register_stack(struct Parrot_Interp* interpreter,
+                             struct RegStack* stack);
+void mark_string_register_stack(struct Parrot_Interp* interpreter,
+                                struct RegStack* stack);
+void mark_register_stack(struct Parrot_Interp* interpreter,
+                         struct RegStack* stack);

 #endif /* PARROT_REGISTER_H */

Index: include/parrot/sub.h
===================================================================
RCS file: /cvs/public/parrot/include/parrot/sub.h,v
retrieving revision 1.25
diff -u -r1.25 sub.h
--- include/parrot/sub.h        2 Oct 2003 07:41:55 -0000       1.25
+++ include/parrot/sub.h        8 Jan 2004 03:04:01 -0000
@@ -59,6 +59,7 @@
 void cow_copy_context(struct Parrot_Interp* , struct Parrot_Context *);
 void swap_context(struct Parrot_Interp *, PMC *);
 void restore_context(struct Parrot_Interp *, struct Parrot_Context *);
+void mark_context(struct Parrot_Interp *, struct Parrot_Context *);

 PMC * scratchpad_new(struct Parrot_Interp * interp, PMC * base, INTVAL depth);

Index: src/debug.c
===================================================================
RCS file: /cvs/public/parrot/src/debug.c,v
retrieving revision 1.117
diff -u -r1.117 debug.c
--- src/debug.c 5 Jan 2004 14:44:52 -0000       1.117
+++ src/debug.c 8 Jan 2004 03:04:02 -0000
@@ -1808,9 +1808,10 @@
 PDB_print_stack_int(struct Parrot_Interp *interpreter, const char *command)
 {
     unsigned long depth = 0, i = 0;
-    struct IRegChunk *chunk = interpreter->ctx.int_reg_top;
+    struct RegisterChunkBuf *chunk = interpreter->ctx.int_reg_stack.top;

-    valid_chunk(chunk, command, depth, FRAMES_PER_INT_REG_CHUNK, i);
+    valid_chunk(chunk, command, depth,
+                FRAMES_PER_INT_REG_CHUNK, i);

     if (!chunk) {
         i = depth / FRAMES_PER_INT_REG_CHUNK;
@@ -1822,8 +1823,9 @@
                 i, depth);

     na(command);
-    PDB_print_int_frame(interpreter, &chunk->IRegFrame[depth],
-            atoi(command));
+    PDB_print_int_frame(interpreter,
+                &((struct IRegChunkBuf*)chunk->data.bufstart)->IRegFrame[depth],
+                atoi(command));
 }

 /* PDB_print_stack_num
@@ -1833,9 +1835,10 @@
 PDB_print_stack_num(struct Parrot_Interp *interpreter, const char *command)
 {
     unsigned long depth = 0, i = 0;
-    struct NRegChunk *chunk = interpreter->ctx.num_reg_top;
+    struct RegisterChunkBuf *chunk = interpreter->ctx.num_reg_stack.top;

-    valid_chunk(chunk, command, depth, FRAMES_PER_NUM_REG_CHUNK, i);
+    valid_chunk(chunk, command, depth,
+                FRAMES_PER_NUM_REG_CHUNK, i);

     if (!chunk) {
         i = depth / FRAMES_PER_NUM_REG_CHUNK;
@@ -1846,8 +1849,9 @@
     PIO_eprintf(interpreter, "Float stack, frame %li, depth %li\n", i, depth);

     na(command);
-    PDB_print_num_frame(interpreter, &chunk->NRegFrame[depth],
-            atoi(command));
+    PDB_print_num_frame(interpreter,
+                &((struct NRegChunkBuf*)chunk->data.bufstart)->NRegFrame[depth],
+                atoi(command));
 }

 /* PDB_print_stack_string
@@ -1857,9 +1861,10 @@
 PDB_print_stack_string(struct Parrot_Interp *interpreter, const char *command)
 {
     unsigned long depth = 0, i = 0;
-    struct SRegChunk *chunk = interpreter->ctx.string_reg_top;
+    struct RegisterChunkBuf *chunk = interpreter->ctx.string_reg_stack.top;

-    valid_chunk(chunk, command, depth, FRAMES_PER_STR_REG_CHUNK, i);
+    valid_chunk(chunk, command, depth,
+                FRAMES_PER_STR_REG_CHUNK, i);

     if (!chunk) {
         i = depth / FRAMES_PER_STR_REG_CHUNK;
@@ -1871,8 +1876,9 @@
                 i, depth);

     na(command);
-    PDB_print_string_frame(interpreter, &chunk->SRegFrame[depth],
-            atoi(command));
+    PDB_print_string_frame(interpreter,
+                &((struct SRegChunkBuf*)chunk->data.bufstart)->SRegFrame[depth],
+                atoi(command));
 }

 /* PDB_print_stack_pmc
@@ -1882,9 +1888,10 @@
 PDB_print_stack_pmc(struct Parrot_Interp *interpreter, const char *command)
 {
     unsigned long depth = 0, i = 0;
-    struct PRegChunk *chunk = interpreter->ctx.pmc_reg_top;
+    struct RegisterChunkBuf *chunk = interpreter->ctx.pmc_reg_stack.top;

-    valid_chunk(chunk, command, depth, FRAMES_PER_PMC_REG_CHUNK, i);
+    valid_chunk(chunk, command, depth,
+                FRAMES_PER_PMC_REG_CHUNK, i);

     if (!chunk) {
         i = depth / FRAMES_PER_PMC_REG_CHUNK;
@@ -1895,8 +1902,9 @@
     PIO_eprintf(interpreter, "PMC stack, frame %li, depth %li\n", i, depth);

     na(command);
-    PDB_print_pmc_frame(interpreter, &chunk->PRegFrame[depth],
-            atoi(command), NULL);
+    PDB_print_pmc_frame(interpreter,
+                &((struct PRegChunkBuf*)chunk->data.bufstart)->PRegFrame[depth],
+                atoi(command), NULL);
 }

 static void
Index: src/dod.c
===================================================================
RCS file: /cvs/public/parrot/src/dod.c,v
retrieving revision 1.78
diff -u -r1.78 dod.c
--- src/dod.c   2 Jan 2004 14:09:38 -0000       1.78
+++ src/dod.c   8 Jan 2004 03:04:02 -0000
@@ -130,7 +130,6 @@
      * note: adding locals here did cause increased DOD runs
      */
     unsigned int i = 0, j = 0;
-    struct PRegChunk *cur_chunk = 0;
     struct Stash *stash = 0;

     /* We have to start somewhere, the interpreter globals is a good place */
@@ -162,31 +161,8 @@
     if (interpreter->DOD_registry)
         pobject_lives(interpreter, (PObj *)interpreter->DOD_registry);

-    /* Now walk the pmc stack. Make sure to walk from top down since stack may
-     * have segments above top that we shouldn't walk. */
-    for (cur_chunk = interpreter->ctx.pmc_reg_top; cur_chunk;
-            cur_chunk = cur_chunk->prev) {
-        for (j = 0; j < cur_chunk->used; j++) {
-            for (i = 0; i < NUM_REGISTERS/2; i++) {
-                if (cur_chunk->PRegFrame[j].registers[i]) {
-                    pobject_lives(interpreter,
-                            (PObj *)cur_chunk->PRegFrame[j].registers[i]);
-                }
-            }
-        }
-    }
-
-    /* Walk all stacks: lexical pad, user and control */
-    {
-        Stack_Chunk_t *stacks[3];
-
-        stacks[0] = interpreter->ctx.pad_stack;
-        stacks[1] = interpreter->ctx.user_stack;
-        stacks[2] = interpreter->ctx.control_stack;
-        for (j = 0; j < 3; j++)
-            mark_stack(interpreter, stacks[j]);
-
-    }
+    /* Walk all stacks */
+    mark_context(interpreter, &interpreter->ctx);

     /* Walk the iodata */
     Parrot_IOData_mark(interpreter, interpreter->piodata);
@@ -262,7 +238,6 @@
 trace_active_buffers(struct Parrot_Interp *interpreter)
 {
     UINTVAL i, j;
-    struct SRegChunk *cur_chunk;

     /* First mark the current set. We assume that all pointers in S registers
      * are pointing to valid buffers. This is not a good assumption, but it'll
@@ -279,20 +254,6 @@
         pobject_lives(interpreter, (PObj *)interpreter->current_file);
     if (interpreter->current_package)
         pobject_lives(interpreter, (PObj *)interpreter->current_package);
-
-    /* Now walk the string stack. Make sure to walk from top down since stack
-     * may have segments above top that we shouldn't walk. */
-    for (cur_chunk = interpreter->ctx.string_reg_top;
-            cur_chunk; cur_chunk = cur_chunk->prev) {
-        for (j = 0; j < cur_chunk->used; j++) {
-            for (i = 0; i < NUM_REGISTERS/2; i++) {
-                Buffer *reg = (Buffer *)cur_chunk->SRegFrame[j].registers[i];
-
-                if (reg)
-                    pobject_lives(interpreter, reg);
-            }
-        }
-    }
 }

 #ifdef GC_IS_MALLOC
Index: src/interpreter.c
===================================================================
RCS file: /cvs/public/parrot/src/interpreter.c,v
retrieving revision 1.252
diff -u -r1.252 interpreter.c
--- src/interpreter.c   2 Jan 2004 14:09:38 -0000       1.252
+++ src/interpreter.c   8 Jan 2004 03:04:02 -0000
@@ -995,14 +995,7 @@
     PARROT_WARNINGS_off(interpreter, PARROT_WARNINGS_ALL_FLAG);

     /* Set up the initial register chunks */
-    interpreter->ctx.int_reg_top =
-        mem_sys_allocate_zeroed(sizeof(struct IRegChunk));
-    interpreter->ctx.num_reg_top =
-        mem_sys_allocate_zeroed(sizeof(struct NRegChunk));
-    interpreter->ctx.string_reg_top =
-        mem_sys_allocate_zeroed(sizeof(struct SRegChunk));
-    interpreter->ctx.pmc_reg_top =
-        mem_sys_allocate_zeroed(sizeof(struct PRegChunk));
+    setup_register_stacks(interpreter);

     /* the SET_NULL macros are only for systems where a NULL pointer
      * isn't represented by zeroes, so don't use these for resetting
@@ -1172,24 +1165,6 @@

     /* deinit op_lib */
     (void) PARROT_CORE_OPLIB_INIT(0);
-
-    /* XXX move this to register.c */
-    {
-        struct IRegChunk *stacks[4];
-        struct IRegChunk *top, *next;
-        stacks[0] = interpreter->ctx.int_reg_top;
-        stacks[1] = (struct IRegChunk*) interpreter->ctx.num_reg_top;
-        stacks[2] = (struct IRegChunk*) interpreter->ctx.string_reg_top;
-        stacks[3] = (struct IRegChunk*) interpreter->ctx.pmc_reg_top;
-        for (i = 0; i< 4; i++) {
-            top = stacks[i];
-            for (; top ; ) {
-                next = top->next;
-                mem_sys_free(top);
-                top = next;
-            }
-        }
-    }

     stack_destroy(interpreter->ctx.pad_stack);
     stack_destroy(interpreter->ctx.user_stack);
Index: src/register.c
===================================================================
RCS file: /cvs/public/parrot/src/register.c,v
retrieving revision 1.34
diff -u -r1.34 register.c
--- src/register.c      28 Oct 2003 03:13:06 -0000      1.34
+++ src/register.c      8 Jan 2004 03:04:02 -0000
@@ -12,62 +12,187 @@

 #include "parrot/parrot.h"

-/*=for api register Parrot_push_i
-  pushes a new integer register frame onto the corresponding frame stack
-*/
 void
-Parrot_push_i(struct Parrot_Interp *interpreter, void *where)
+setup_register_stacks(struct Parrot_Interp* interpreter)
+{
+    struct RegisterChunkBuf* buf;
+    make_bufferlike_pool(interpreter, sizeof(struct RegisterChunkBuf));
+
+    Parrot_block_DOD(interpreter);
+
+    buf = new_bufferlike_header(interpreter, sizeof(struct RegisterChunkBuf));
+    Parrot_allocate_zeroed(interpreter, (PObj*)buf, sizeof(struct IRegChunkBuf));
+    interpreter->ctx.int_reg_stack.top = buf;
+    interpreter->ctx.int_reg_stack.chunk_size = sizeof(struct IRegChunkBuf);
+    
+    buf = new_bufferlike_header(interpreter, sizeof(struct RegisterChunkBuf));
+    Parrot_allocate_zeroed(interpreter, (PObj*)buf, sizeof(struct SRegChunkBuf));
+    interpreter->ctx.string_reg_stack.top = buf;
+    interpreter->ctx.string_reg_stack.chunk_size = sizeof(struct SRegChunkBuf);
+    
+    buf = new_bufferlike_header(interpreter, sizeof(struct RegisterChunkBuf));
+    Parrot_allocate_zeroed(interpreter, (PObj*)buf, sizeof(struct NRegChunkBuf));
+    interpreter->ctx.num_reg_stack.top = buf;
+    interpreter->ctx.num_reg_stack.chunk_size = sizeof(struct NRegChunkBuf);
+    
+    buf = new_bufferlike_header(interpreter, sizeof(struct RegisterChunkBuf));
+    Parrot_allocate_zeroed(interpreter, (PObj*)buf, sizeof(struct PRegChunkBuf));
+    interpreter->ctx.pmc_reg_stack.top = buf;
+    interpreter->ctx.pmc_reg_stack.chunk_size = sizeof(struct PRegChunkBuf);
+    
+    Parrot_unblock_DOD(interpreter);
+}
+
+void
+mark_register_stack(struct Parrot_Interp* interpreter, struct RegStack* stack)
+{
+    struct RegisterChunkBuf* chunk;
+    for (chunk = stack->top; chunk; chunk = chunk->next) {
+        pobject_lives(interpreter, (PObj*)chunk);
+    }
+}
+
+void
+mark_pmc_register_stack(struct Parrot_Interp* interpreter, struct RegStack* stack)
+{
+    struct RegisterChunkBuf* chunk;
+    UINTVAL i, j;
+    for (chunk = stack->top; chunk;
+        chunk = chunk->next) {
+        pobject_lives(interpreter, (PObj*)chunk);
+        for (i = 0; i < chunk->used; i++) {
+            for (j = 0; j < NUM_REGISTERS/2; j++) {
+                if (((struct PRegChunkBuf*)chunk->data.bufstart)->PRegFrame[i].registers[j]) {
+                    pobject_lives(interpreter,
+                            (PObj*)((struct PRegChunkBuf*)chunk->data.bufstart)->
+                                PRegFrame[i].registers[j]);
+                }
+            }
+        }
+    }
+}
+
+void
+mark_string_register_stack(struct Parrot_Interp* interpreter, struct RegStack* stack)
+{
+    struct RegisterChunkBuf* chunk;
+    UINTVAL i, j;
+    for (chunk = stack->top; chunk; chunk = chunk->next) {
+        pobject_lives(interpreter, (PObj*)chunk);
+        for (i = 0; i < chunk->used; i++) {
+            for (j = 0; j < NUM_REGISTERS/2; j++) {
+                PObj* reg = (PObj*)((struct SRegChunkBuf*)chunk->data.bufstart)->
+                    SRegFrame[i].registers[j];
+                if (reg)
+                    pobject_lives(interpreter, reg);
+            }
+        }
+    }
+}
+
+void
+mark_register_stack_cow(struct Parrot_Interp* interpreter, struct RegStack* stack)
+{
+    struct RegisterChunkBuf* chunk;
+    for (chunk = stack->top; chunk; chunk = chunk->next) {
+        PObj_COW_SET((PObj*)chunk);
+    }
+}
+
+static struct RegisterChunkBuf*
+regstack_copy_chunk(struct Parrot_Interp* interpreter,
+                    struct RegisterChunkBuf* chunk,
+                    struct RegStack* stack)
+{
+    struct RegisterChunkBuf* buf =
+            new_bufferlike_header(interpreter, sizeof(struct RegisterChunkBuf));
+    *buf = *chunk;
+    
+    Parrot_block_DOD(interpreter);
+    Parrot_allocate_zeroed(interpreter, (PObj*)buf, stack->chunk_size);
+    Parrot_unblock_DOD(interpreter);
+    
+    memcpy(buf->data.bufstart, chunk->data.bufstart, stack->chunk_size);
+    return buf;
+}
+
+static void
+regstack_push_entry(struct Parrot_Interp* interpreter, struct RegStack* stack)
 {
-    /* Do we have any space in the current savestack? If so, memcpy
-     * down */
-    if (interpreter->ctx.int_reg_top->used < FRAMES_PER_CHUNK) {
-        memcpy(&interpreter->ctx.int_reg_top->
-               IRegFrame[interpreter->ctx.int_reg_top->used],
-               where, sizeof(struct IRegFrame));
-        interpreter->ctx.int_reg_top->used++;
+    struct RegisterChunkBuf* top = stack->top;
+    /* Before we change anything, is this a read-only stack? */
+    if (PObj_COW_TEST((PObj*)top))
+        top = stack->top = regstack_copy_chunk(interpreter, top, stack);
+    /* If we can stay in the current frame, we will.  Else make a new chunk */
+    if (top->used < FRAMES_PER_CHUNK) {
+        top->used++;
     }
-    /* Nope, so either move to next stack chunk or grow the stack */
     else {
-        struct IRegChunk *next_chunk;
-        if (interpreter->ctx.int_reg_top->next)
-            next_chunk = interpreter->ctx.int_reg_top->next;
+        struct RegisterChunkBuf* buf = new_bufferlike_header(interpreter,
+                                sizeof(struct RegisterChunkBuf));
+
+        Parrot_block_DOD(interpreter);
+        Parrot_allocate_zeroed(interpreter, (PObj*)buf, stack->chunk_size);
+        Parrot_unblock_DOD(interpreter);
+        
+        buf->used = 1;
+        buf->next = top;
+
+        stack->top = buf;
+    }
+}
+
+static void
+regstack_pop_entry(struct Parrot_Interp* interpreter, struct RegStack* stack)
+{
+    struct RegisterChunkBuf* top = stack->top;
+    if (top->used > 1) {
+        /* Before we change anything, is this a read-only stack? */
+        if (PObj_COW_TEST((PObj*)top))
+            top = stack->top = regstack_copy_chunk(interpreter, stack->top, stack);
+        top->used--;
+    }
+    else {
+        /* XXX: If this isn't marked COW, we should keep it around to
+         * prevent thrashing */
+        if (top->next) {
+            stack->top = top->next;
+        }
         else {
-            next_chunk = mem_sys_allocate(sizeof(struct IRegChunk));
-            next_chunk->next = NULL;
-            next_chunk->prev = interpreter->ctx.int_reg_top;
-            interpreter->ctx.int_reg_top->next = next_chunk;
+            if (PObj_COW_TEST((PObj*)top))
+                top = stack->top = regstack_copy_chunk(interpreter, stack->top, stack);
+            top->used--;
         }
-        next_chunk->used = 1;
-        interpreter->ctx.int_reg_top = next_chunk;
-        memcpy(&next_chunk->IRegFrame[0],
-               where, sizeof(struct IRegFrame));
     }
 }

+/*=for api register Parrot_push_i
+  pushes a new integer register frame onto the corresponding frame stack
+*/
+void
+Parrot_push_i(struct Parrot_Interp *interpreter, void *where)
+{    
+    struct RegisterChunkBuf* top;
+    regstack_push_entry(interpreter, &interpreter->ctx.int_reg_stack);
+    top = interpreter->ctx.int_reg_stack.top;
+    memcpy(&((struct IRegChunkBuf*)top->data.bufstart)->
+                    IRegFrame[top->used-1].registers,
+           where, sizeof(struct IRegFrame));
+}
+
 /*=for api register Parrot_pop_i
   pops an integer register frame from the corresponding frame stack
 */
 void
 Parrot_pop_i(struct Parrot_Interp *interpreter, void *where)
 {
-    struct IRegChunk *top = interpreter->ctx.int_reg_top;
+    struct RegisterChunkBuf* top = interpreter->ctx.int_reg_stack.top;
     /* Do we even have anything? */
     if (top->used > 0) {
-        top->used--;
-        memcpy(where,
-               &top->IRegFrame[top->used], sizeof(struct IRegFrame));
-        /* Empty? */
-        if (!top->used) {
-            /* Yep, drop down a frame. Maybe */
-            if (top->prev) {
-                /* Keep one stack segment spare to avoid thrashing */
-                if (top->next) {
-                    mem_sys_free(top->next);
-                    top->next = NULL;
-                }
-                interpreter->ctx.int_reg_top = top->prev;
-            }
-        }
+        memcpy(where,
+               &((struct IRegChunkBuf*)top->data.bufstart)->IRegFrame[top->used-1],
+               sizeof(struct IRegFrame));
+        regstack_pop_entry(interpreter, &interpreter->ctx.int_reg_stack);
     }
     /* Nope. So pitch a fit */
     else {
@@ -92,31 +217,13 @@
 */
 void
 Parrot_push_s(struct Parrot_Interp *interpreter, void *where)
-{
-    /* Do we have any space in the current savestack? If so, memcpy
-     * down */
-    if (interpreter->ctx.string_reg_top->used < FRAMES_PER_CHUNK) {
-        memcpy(&interpreter->ctx.string_reg_top->
-               SRegFrame[interpreter->ctx.string_reg_top->used],
-               where, sizeof(struct SRegFrame));
-        interpreter->ctx.string_reg_top->used++;
-    }
-    /* Nope, so either move to next stack chunk or grow the stack */
-    else {
-        struct SRegChunk *next_chunk;
-        if (interpreter->ctx.string_reg_top->next)
-            next_chunk = interpreter->ctx.string_reg_top->next;
-        else {
-            next_chunk = mem_sys_allocate(sizeof(struct SRegChunk));
-            next_chunk->next = NULL;
-            next_chunk->prev = interpreter->ctx.string_reg_top;
-            interpreter->ctx.string_reg_top->next = next_chunk;
-        }
-        next_chunk->used = 1;
-        interpreter->ctx.string_reg_top = next_chunk;
-        memcpy(&next_chunk->SRegFrame[0],
-               where, sizeof(struct SRegFrame));
-    }
+{    
+    struct RegisterChunkBuf* top;
+    regstack_push_entry(interpreter, &interpreter->ctx.string_reg_stack);
+    top = interpreter->ctx.string_reg_stack.top;
+    memcpy(&((struct SRegChunkBuf*)top->data.bufstart)->
+                    SRegFrame[top->used-1].registers,
+           where, sizeof(struct SRegFrame));
 }

 /*=for api register Parrot_pop_s
@@ -125,24 +232,15 @@
 void
 Parrot_pop_s(struct Parrot_Interp *interpreter, void *where)
 {
-    struct SRegChunk *top = interpreter->ctx.string_reg_top;
+    struct RegisterChunkBuf* top = interpreter->ctx.string_reg_stack.top;
     /* Do we even have anything? */
     if (top->used > 0) {
-        top->used--;
-        memcpy(where,
-               &top->SRegFrame[top->used], sizeof(struct SRegFrame));
-        /* Empty? */
-        if (!top->used) {
-            /* Yep, drop down a frame. Maybe */
-            if (top->prev) {
-                /* Keep one stack segment spare to avoid thrashing */
-                if (top->next) {
-                    mem_sys_free(top->next);
-                    top->next = NULL;
-                }
-                interpreter->ctx.string_reg_top = top->prev;
-            }
-        }
+        struct SRegFrame* irf = &((struct SRegChunkBuf*)top->data.bufstart)->
+                    SRegFrame[top->used-1];
+        memcpy(where,
+               &irf->registers,
+               sizeof(struct SRegFrame));
+        regstack_pop_entry(interpreter, &interpreter->ctx.string_reg_stack);
     }
     /* Nope. So pitch a fit */
     else {
@@ -167,31 +265,13 @@
 */
 void
 Parrot_push_n(struct Parrot_Interp *interpreter, void *where)
-{
-    /* Do we have any space in the current savestack? If so, memcpy
-     * down */
-    if (interpreter->ctx.num_reg_top->used < FRAMES_PER_CHUNK) {
-        memcpy(&interpreter->ctx.num_reg_top->
-               NRegFrame[interpreter->ctx.num_reg_top->used],
-               where, sizeof(struct NRegFrame));
-        interpreter->ctx.num_reg_top->used++;
-    }
-    /* Nope, so either move to next stack chunk or grow the stack */
-    else {
-        struct NRegChunk *next_chunk;
-        if (interpreter->ctx.num_reg_top->next)
-            next_chunk = interpreter->ctx.num_reg_top->next;
-        else {
-            next_chunk = mem_sys_allocate(sizeof(struct NRegChunk));
-            next_chunk->next = NULL;
-            next_chunk->prev = interpreter->ctx.num_reg_top;
-            interpreter->ctx.num_reg_top->next = next_chunk;
-        }
-        next_chunk->used = 1;
-        interpreter->ctx.num_reg_top = next_chunk;
-        memcpy(&next_chunk->NRegFrame[0],
-               where, sizeof(struct NRegFrame));
-    }
+{    
+    struct RegisterChunkBuf* top;
+    regstack_push_entry(interpreter, &interpreter->ctx.num_reg_stack);
+    top = interpreter->ctx.num_reg_stack.top;
+    memcpy(&((struct NRegChunkBuf*)top->data.bufstart)->
+                    NRegFrame[top->used-1].registers,
+           where, sizeof(struct NRegFrame));
 }

 /*=for api register Parrot_pop_n
@@ -200,24 +280,15 @@
 void
 Parrot_pop_n(struct Parrot_Interp *interpreter, void *where)
 {
-    struct NRegChunk *top = interpreter->ctx.num_reg_top;
+    struct RegisterChunkBuf* top = interpreter->ctx.num_reg_stack.top;
     /* Do we even have anything? */
     if (top->used > 0) {
-        top->used--;
-        memcpy(where,
-               &top->NRegFrame[top->used], sizeof(struct NRegFrame));
-        /* Empty? */
-        if (!top->used) {
-            /* Yep, drop down a frame. Maybe */
-            if (top->prev) {
-                /* Keep one stack segment spare to avoid thrashing */
-                if (top->next) {
-                    mem_sys_free(top->next);
-                    top->next = NULL;
-                }
-                interpreter->ctx.num_reg_top = top->prev;
-            }
-        }
+        struct NRegFrame* irf = &((struct NRegChunkBuf*)top->data.bufstart)->
+                    NRegFrame[top->used-1];
+        memcpy(where,
+               &irf->registers,
+               sizeof(struct NRegFrame));
+        regstack_pop_entry(interpreter, &interpreter->ctx.num_reg_stack);
     }
     /* Nope. So pitch a fit */
     else {
@@ -242,31 +313,13 @@
 */
 void
 Parrot_push_p(struct Parrot_Interp *interpreter, void *where)
-{
-    /* Do we have any space in the current savestack? If so, memcpy
-     * down */
-    if (interpreter->ctx.pmc_reg_top->used < FRAMES_PER_CHUNK) {
-        memcpy(&interpreter->ctx.pmc_reg_top->
-               PRegFrame[interpreter->ctx.pmc_reg_top->used],
-               where, sizeof(struct PRegFrame));
-        interpreter->ctx.pmc_reg_top->used++;
-    }
-    /* Nope, so either move to next stack chunk or grow the stack */
-    else {
-        struct PRegChunk *next_chunk;
-        if (interpreter->ctx.pmc_reg_top->next)
-            next_chunk = interpreter->ctx.pmc_reg_top->next;
-        else {
-            next_chunk = mem_sys_allocate(sizeof(struct PRegChunk));
-            next_chunk->next = NULL;
-            next_chunk->prev = interpreter->ctx.pmc_reg_top;
-            interpreter->ctx.pmc_reg_top->next = next_chunk;
-        }
-        next_chunk->used = 1;
-        interpreter->ctx.pmc_reg_top = next_chunk;
-        memcpy(&next_chunk->PRegFrame[0],
-               where, sizeof(struct PRegFrame));
-    }
+{    
+    struct RegisterChunkBuf* top;
+    regstack_push_entry(interpreter, &interpreter->ctx.pmc_reg_stack);
+    top = interpreter->ctx.pmc_reg_stack.top;
+    memcpy(&((struct PRegChunkBuf*)top->data.bufstart)->
+                    PRegFrame[top->used-1].registers,
+           where, sizeof(struct PRegFrame));
 }

 /*=for api register Parrot_pop_p
@@ -275,24 +328,15 @@
 void
 Parrot_pop_p(struct Parrot_Interp *interpreter, void *where)
 {
-    struct PRegChunk *top = interpreter->ctx.pmc_reg_top;
+    struct RegisterChunkBuf* top = interpreter->ctx.pmc_reg_stack.top;
     /* Do we even have anything? */
     if (top->used > 0) {
-        top->used--;
-        memcpy(where,
-               &top->PRegFrame[top->used], sizeof(struct PRegFrame));
-        /* Empty? */
-        if (!top->used) {
-            /* Yep, drop down a frame. Maybe */
-            if (top->prev) {
-                /* Keep one stack segment spare to avoid thrashing */
-                if (top->next) {
-                    mem_sys_free(top->next);
-                    top->next = NULL;
-                }
-                interpreter->ctx.pmc_reg_top = top->prev;
-            }
-        }
+        struct PRegFrame* irf = &((struct PRegChunkBuf*)top->data.bufstart)->
+                    PRegFrame[top->used-1];
+        memcpy(where,
+               &irf->registers,
+               sizeof(struct PRegFrame));
+        regstack_pop_entry(interpreter, &interpreter->ctx.pmc_reg_stack);
     }
     /* Nope. So pitch a fit */
     else {
Index: src/sub.c
===================================================================
RCS file: /cvs/public/parrot/src/sub.c,v
retrieving revision 1.40
diff -u -r1.40 sub.c
--- src/sub.c   25 Oct 2003 06:13:21 -0000      1.40
+++ src/sub.c   8 Jan 2004 03:04:02 -0000
@@ -12,6 +12,7 @@
  */

 #include "parrot/parrot.h"
+#include "parrot/method_util.h"

 /*
@@ -33,6 +34,10 @@
 cow_copy_context(struct Parrot_Interp *interp, struct Parrot_Context *ctx)
 {
     memcpy(ctx, &interp->ctx, sizeof(*ctx));
+    mark_register_stack_cow(interp, &ctx->int_reg_stack);
+    mark_register_stack_cow(interp, &ctx->num_reg_stack);
+    mark_register_stack_cow(interp, &ctx->string_reg_stack);
+    mark_register_stack_cow(interp, &ctx->pmc_reg_stack);
     stack_mark_cow(ctx->pad_stack);
     stack_mark_cow(ctx->user_stack);
     stack_mark_cow(ctx->control_stack);
@@ -46,6 +51,18 @@
 restore_context(struct Parrot_Interp *interp, struct Parrot_Context *ctx)
 {
     memcpy(&interp->ctx, ctx, sizeof(*ctx));
+}
+
+void
+mark_context(struct Parrot_Interp* interpreter, struct Parrot_Context* ctx)
+{
+    mark_stack(interpreter, ctx->pad_stack);
+    mark_stack(interpreter, ctx->user_stack);
+    mark_stack(interpreter, ctx->control_stack);
+    mark_register_stack(interpreter, &ctx->int_reg_stack);
+    mark_register_stack(interpreter, &ctx->num_reg_stack);
+    mark_string_register_stack(interpreter, &ctx->string_reg_stack);
+    mark_pmc_register_stack(interpreter, &ctx->pmc_reg_stack);
 }

 static void coro_error(Stack_Entry_t *e)
Index: t/pmc/sub.t
===================================================================
RCS file: /cvs/public/parrot/t/pmc/sub.t,v
retrieving revision 1.31
diff -u -r1.31 sub.t
--- t/pmc/sub.t 4 Dec 2003 10:30:38 -0000       1.31
+++ t/pmc/sub.t 8 Jan 2004 03:04:02 -0000
@@ -1,6 +1,6 @@
 #! perl -w

-use Parrot::Test tests => 47;
+use Parrot::Test tests => 49;
 use Test::More;
 use Parrot::Config;

@@ -708,6 +708,40 @@
 CODE
 ok 1
 ok 2
+OUTPUT
+
+output_is(<<'CODE', <<'OUTPUT', "continuation close over register stacks");
+    set S20, "ok\n"
+    savetop
+    newsub P0, .Continuation, next
+    restoretop
+    concat S20, "not ", S20
+    invoke
+    print "bad\n"
+next:
+    restoretop
+    print S20
+    end
+CODE
+ok
+OUTPUT
+
+output_is(<<'CODE', <<'OUTPUT', "DOD marks continuation's register stacks");
+    set S20, "ok\n"
+    savetop
+    newsub P0, .Continuation, next
+    restoretop
+    null S20
+    sweep 1
+    collect
+    invoke
+    print "bad\n"
+next:
+    restoretop
+    print S20
+    end
+CODE
+ok
 OUTPUT

 unlink($temp, 'temp.pbc');