include/lang/PyrDeepCopier.h

   1 /*
   2         SuperCollider real time audio synthesis system
   3     Copyright (c) 2002 James McCartney. All rights reserved.
   4         http://www.audiosynth.com
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  19 */
  20 /*
  21
  22 An object archiving system for SuperCollider.
  23
  24 */
  25
  26
  27 #ifndef _PyrDeepCopier_
  28 #define _PyrDeepCopier_
  29
  30 #include "PyrObject.h"
  31 #include "SC_AllocPool.h"
  32
  33 #include "PyrKernel.h"
  34 #include "PyrPrimitive.h"
  35 #include "VMGlobals.h"
  36 #include "GC.h"
  37
  38 const int32 kDeepCopierObjectArrayInitialCapacity = 32;
  39
  40 class PyrDeepCopier
  41 {
  42 public:
  43         PyrDeepCopier(VMGlobals *inG)
  44                 : g(inG), objectArray(initialObjectArray), numObjects(0),
  45                 objectArrayCapacity( kDeepCopierObjectArrayInitialCapacity )
  46         {}
  47
  48         ~PyrDeepCopier()
  49         {
  50                 if (objectArrayCapacity > kDeepCopierObjectArrayInitialCapacity) {
  51                         g->allocPool->Free(objectArray);
  52                 }
  53         }
  54
  55         long doDeepCopy(PyrSlot *objectSlot)
  56         {
  57                 long err = errNone;
  58
  59                 try {
  60                         if (IsObj(objectSlot)) {
  61                                 constructObjectArray(slotRawObject(objectSlot));
  62                                 for (int i=0; i<numObjects; ++i) {
  63                                         fixSlots(objectArray[i]);
  64                                 }
  65                                 fixObjSlot(objectSlot);
  66                                 for (int i=0; i<numObjects; ++i) {
  67                                         objectArray[i]->ClearMark();
  68                                 }
  69
  70                         }
  71                 } catch (std::exception &ex) {
  72                         error(ex.what());
  73                         err = errFailed;
  74                 }
  75                 return err;
  76         }
  77
  78 private:
  79
  80         void recurse(PyrObject *obj, int n)
  81         {
  82                 //post("->recurse %s %08X\n", obj->classptr->name.us->name, obj);
  83                 PyrSlot *slot = obj->slots;
  84                 for (int i=0; i<n; ++i, ++slot) {
  85                         if (IsObj(slot)) constructObjectArray(slotRawObject(slot));
  86                 }
  87                 //post("<-recurse %s %08X\n", obj->classptr->name.us->name, obj);
  88         }
  89
  90         void growObjectArray()
  91         {
  92                 int32 newObjectArrayCapacity = objectArrayCapacity << 1;
  93
  94                 int32 newSize = newObjectArrayCapacity * sizeof(PyrObject*);
  95                 PyrObject** newArray = (PyrObject**)g->allocPool->Alloc(newSize);
  96                 memcpy(newArray, objectArray, numObjects * sizeof(PyrObject*));
  97                 if (objectArrayCapacity > kDeepCopierObjectArrayInitialCapacity) {
  98                         g->allocPool->Free(objectArray);
  99                 }
 100                 objectArrayCapacity = newObjectArrayCapacity;
 101                 objectArray = newArray;
 102         }
 103
 104         void putSelf(PyrObject *obj)
 105         {
 106                 obj->SetMark();
 107                 obj->scratch1 = numObjects;
 108
 109                 // expand array if needed
 110                 if (numObjects >= objectArrayCapacity) growObjectArray();
 111
 112                 //post("putSelf %d %08X\n", numObjects, obj);
 113                 // add to array
 114                 objectArray[numObjects++] = obj;
 115         }
 116
 117         void putCopy(PyrObject *obj)
 118         {
 119                 obj->SetMark();
 120                 obj->scratch1 = numObjects;
 121
 122                 // expand array if needed
 123                 if (numObjects+2 >= objectArrayCapacity) growObjectArray();
 124
 125                 // add a shallow copy to object array
 126                 PyrObject *copy = copyObject(g->gc, obj, false);
 127                 copy->ClearMark();
 128
 129                 //post("putCopy %d %08X\n", numObjects, copy);
 130
 131                 // add to array
 132                 objectArray[numObjects++] = copy;
 133                 objectArray[numObjects++] = obj;
 134         }
 135
 136         void constructObjectArray(PyrObject *obj)
 137         {
 138                 //post("->constructObjectArray %s %08X\n", obj->classptr->name.us->name, obj);
 139                 if (!obj->IsMarked()) {
 140                         if (isKindOf(obj, class_class)) {
 141                                 putSelf(obj);
 142                         } else if (isKindOf(obj, class_process)) {
 143                                 putSelf(obj);
 144                         } else if (isKindOf(obj, s_interpreter->u.classobj)) {
 145                                 putSelf(obj);
 146                         } else if (isKindOf(obj, class_rawarray)) {
 147                                 putCopy(obj);
 148                         } else if (isKindOf(obj, class_array)) {
 149                                 putCopy(obj);
 150                                 recurse(obj, obj->size);
 151                         } else if (isKindOf(obj, class_func)) {
 152                                 putSelf(obj);
 153                         } else if (isKindOf(obj, class_method)) {
 154                                 putSelf(obj);
 155                         } else if (isKindOf(obj, class_thread)) {
 156                                 putSelf(obj);
 157                         } else if (isKindOf(obj, class_server_shm_interface)) {
 158                                 putSelf(obj);
 159                         } else {
 160                                 putCopy(obj);
 161                                 recurse(obj, obj->size);
 162                         }
 163                 }
 164                 //post("<-constructObjectArray %s %08X\n", obj->classptr->name.us->name, obj);
 165         }
 166
 167         void fixObjSlot(PyrSlot* slot)
 168         {
 169                 //post("fixObjSlot %s %08X %d %08X\n", slotRawObject(slot)->classptr->name.us->name, slotRawObject(slot), slot->uo->scratch1, objectArray[slot->uo->scratch1]);
 170                 SetRaw(slot, objectArray[slotRawObject(slot)->scratch1]);
 171         }
 172
 173         void fixSlots(PyrObject *obj)
 174         {
 175                 //post("fixSlots %s %08X %d\n", obj->classptr->name.us->name, obj, obj->IsMarked());
 176                 if (!obj->IsMarked() && obj->obj_format <= obj_slot) { // it is a copy
 177                         PyrSlot *slot = obj->slots;
 178                         for (int i=0; i<obj->size; ++i, ++slot) {
 179                                 if (IsObj(slot)) fixObjSlot(slot);
 180                         }
 181                 }
 182         }
 183
 184         VMGlobals *g;
 185
 186         PyrObject **objectArray;
 187         int32 numObjects;
 188         int32 objectArrayCapacity;
 189
 190         PyrObject *initialObjectArray[kDeepCopierObjectArrayInitialCapacity];
 191 };
 192
 193 #endif
 194