supertux/src/squirrel/squirrel/sqobject.cpp

   1 /*
   2         see copyright notice in squirrel.h
   3 */
   4 #include "sqpcheader.h"
   5 #include "sqvm.h"
   6 #include "sqstring.h"
   7 #include "sqarray.h"
   8 #include "sqtable.h"
   9 #include "squserdata.h"
  10 #include "sqfuncproto.h"
  11 #include "sqclass.h"
  12 #include "sqclosure.h"
  13
  14 SQString *SQString::Create(SQSharedState *ss,const SQChar *s,SQInteger len)
  15 {
  16         SQString *str=ADD_STRING(ss,s,len);
  17         str->_sharedstate=ss;
  18         return str;
  19 }
  20
  21 void SQString::Release()
  22 {
  23         REMOVE_STRING(_sharedstate,this);
  24 }
  25
  26 SQInteger SQString::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval)
  27 {
  28         SQInteger idx = (SQInteger)TranslateIndex(refpos);
  29         while(idx < _len){
  30                 outkey = (SQInteger)idx;
  31                 outval = SQInteger(_val[idx]);
  32                 //return idx for the next iteration
  33                 return ++idx;
  34         }
  35         //nothing to iterate anymore
  36         return -1;
  37 }
  38
  39 SQUnsignedInteger TranslateIndex(const SQObjectPtr &idx)
  40 {
  41         switch(type(idx)){
  42                 case OT_NULL:
  43                         return 0;
  44                 case OT_INTEGER:
  45                         return (SQUnsignedInteger)_integer(idx);
  46                 default: assert(0); break;
  47         }
  48         return 0;
  49 }
  50
  51 SQWeakRef *SQRefCounted::GetWeakRef(SQObjectType type)
  52 {
  53         if(!_weakref) {
  54                 sq_new(_weakref,SQWeakRef);
  55                 _weakref->_obj._type = type;
  56                 _weakref->_obj._unVal.pRefCounted = this;
  57         }
  58         return _weakref;
  59 }
  60
  61 SQRefCounted::~SQRefCounted()
  62 {
  63         if(_weakref) {
  64                 _weakref->_obj._type = OT_NULL;
  65                 _weakref->_obj._unVal.pRefCounted = NULL;
  66         }
  67 }
  68
  69 void SQWeakRef::Release() {
  70         if(ISREFCOUNTED(_obj._type)) {
  71                 _obj._unVal.pRefCounted->_weakref = NULL;
  72         }
  73         sq_delete(this,SQWeakRef);
  74 }
  75
  76 bool SQDelegable::GetMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res) {
  77         if(_delegate) {
  78                 return _delegate->Get((*_ss(v)->_metamethods)[mm],res);
  79         }
  80         return false;
  81 }
  82
  83 bool SQDelegable::SetDelegate(SQTable *mt)
  84 {
  85         SQTable *temp = mt;
  86         while (temp) {
  87                 if (temp->_delegate == this) return false; //cycle detected
  88                 temp = temp->_delegate;
  89         }
  90         if (mt) __ObjAddRef(mt);
  91         __ObjRelease(_delegate);
  92         _delegate = mt;
  93         return true;
  94 }
  95
  96 bool SQGenerator::Yield(SQVM *v)
  97 {
  98         if(_state==eSuspended) { v->Raise_Error(_SC("internal vm error, yielding dead generator"));  return false;}
  99         if(_state==eDead) { v->Raise_Error(_SC("internal vm error, yielding a dead generator")); return false; }
 100         SQInteger size = v->_top-v->_stackbase;
 101         _ci=*v->ci;
 102         _stack.resize(size);
 103         for(SQInteger n =0; n<size; n++) {
 104                 _stack._vals[n] = v->_stack[v->_stackbase+n];
 105                 v->_stack[v->_stackbase+n] = _null_;
 106         }
 107         SQInteger nvargs = v->ci->_vargs.size;
 108         SQInteger vargsbase = v->ci->_vargs.base;
 109         for(SQInteger j = nvargs - 1; j >= 0; j--) {
 110                 _vargsstack.push_back(v->_vargsstack[vargsbase+j]);
 111         }
 112         _ci._generator=_null_;
 113         for(SQInteger i=0;i<_ci._etraps;i++) {
 114                 _etraps.push_back(v->_etraps.top());
 115                 v->_etraps.pop_back();
 116         }
 117         _state=eSuspended;
 118         return true;
 119 }
 120
 121 bool SQGenerator::Resume(SQVM *v,SQInteger target)
 122 {
 123         SQInteger size=_stack.size();
 124         if(_state==eDead){ v->Raise_Error(_SC("resuming dead generator")); return false; }
 125         if(_state==eRunning){ v->Raise_Error(_SC("resuming active generator")); return false; }
 126         SQInteger prevtop=v->_top-v->_stackbase;
 127         PUSH_CALLINFO(v,_ci);
 128         SQInteger oldstackbase=v->_stackbase;
 129         v->_stackbase = v->_top;
 130         v->ci->_target = (SQInt32)target;
 131         v->ci->_generator = SQObjectPtr(this);
 132         v->ci->_vargs.size = (unsigned short)_vargsstack.size();
 133
 134         for(SQInteger i=0;i<_ci._etraps;i++) {
 135                 v->_etraps.push_back(_etraps.top());
 136                 _etraps.pop_back();
 137         }
 138         for(SQInteger n =0; n<size; n++) {
 139                 v->_stack[v->_stackbase+n] = _stack._vals[n];
 140                 _stack._vals[0] = _null_;
 141         }
 142         while(_vargsstack.size()) {
 143                 v->_vargsstack.push_back(_vargsstack.back());
 144                 _vargsstack.pop_back();
 145         }
 146         v->ci->_vargs.base = (unsigned short)(v->_vargsstack.size() - v->ci->_vargs.size);
 147         v->_top=v->_stackbase+size;
 148         v->ci->_prevtop = (SQInt32)prevtop;
 149         v->ci->_prevstkbase = (SQInt32)(v->_stackbase - oldstackbase);
 150         _state=eRunning;
 151         return true;
 152 }
 153
 154 void SQArray::Extend(const SQArray *a){
 155         SQInteger xlen;
 156         if((xlen=a->Size()))
 157                 for(SQInteger i=0;i<xlen;i++)
 158                         Append(a->_values[i]);
 159 }
 160
 161 const SQChar* SQFunctionProto::GetLocal(SQVM *vm,SQUnsignedInteger stackbase,SQUnsignedInteger nseq,SQUnsignedInteger nop)
 162 {
 163         SQUnsignedInteger nvars=_nlocalvarinfos;
 164         const SQChar *res=NULL;
 165         if(nvars>=nseq){
 166                 for(SQUnsignedInteger i=0;i<nvars;i++){
 167                         if(_localvarinfos[i]._start_op<=nop && _localvarinfos[i]._end_op>=nop)
 168                         {
 169                                 if(nseq==0){
 170                                         vm->Push(vm->_stack[stackbase+_localvarinfos[i]._pos]);
 171                                         res=_stringval(_localvarinfos[i]._name);
 172                                         break;
 173                                 }
 174                                 nseq--;
 175                         }
 176                 }
 177         }
 178         return res;
 179 }
 180
 181 SQInteger SQFunctionProto::GetLine(SQInstruction *curr)
 182 {
 183         SQInteger op = (SQInteger)(curr-_instructions);
 184         SQInteger line=_lineinfos[0]._line;
 185         for(SQInteger i=1;i<_nlineinfos;i++){
 186                 if(_lineinfos[i]._op>=op)
 187                         return line;
 188                 line=_lineinfos[i]._line;
 189         }
 190         return line;
 191 }
 192
 193 #define _CHECK_IO(exp)  { if(!exp)return false; }
 194 bool SafeWrite(HSQUIRRELVM v,SQWRITEFUNC write,SQUserPointer up,SQUserPointer dest,SQInteger size)
 195 {
 196         if(write(up,dest,size) != size) {
 197                 v->Raise_Error(_SC("io error (write function failure)"));
 198                 return false;
 199         }
 200         return true;
 201 }
 202
 203 bool SafeRead(HSQUIRRELVM v,SQWRITEFUNC read,SQUserPointer up,SQUserPointer dest,SQInteger size)
 204 {
 205         if(size && read(up,dest,size) != size) {
 206                 v->Raise_Error(_SC("io error, read function failure, the origin stream could be corrupted/trucated"));
 207                 return false;
 208         }
 209         return true;
 210 }
 211
 212 bool WriteTag(HSQUIRRELVM v,SQWRITEFUNC write,SQUserPointer up,SQInteger tag)
 213 {
 214         return SafeWrite(v,write,up,&tag,sizeof(tag));
 215 }
 216
 217 bool CheckTag(HSQUIRRELVM v,SQWRITEFUNC read,SQUserPointer up,SQInteger tag)
 218 {
 219         SQInteger t;
 220         _CHECK_IO(SafeRead(v,read,up,&t,sizeof(t)));
 221         if(t != tag){
 222                 v->Raise_Error(_SC("invalid or corrupted closure stream"));
 223                 return false;
 224         }
 225         return true;
 226 }
 227
 228 bool WriteObject(HSQUIRRELVM v,SQUserPointer up,SQWRITEFUNC write,SQObjectPtr &o)
 229 {
 230         _CHECK_IO(SafeWrite(v,write,up,&type(o),sizeof(SQObjectType)));
 231         switch(type(o)){
 232         case OT_STRING:
 233                 _CHECK_IO(SafeWrite(v,write,up,&_string(o)->_len,sizeof(SQInteger)));
 234                 _CHECK_IO(SafeWrite(v,write,up,_stringval(o),rsl(_string(o)->_len)));
 235                 break;
 236         case OT_INTEGER:
 237                 _CHECK_IO(SafeWrite(v,write,up,&_integer(o),sizeof(SQInteger)));break;
 238         case OT_FLOAT:
 239                 _CHECK_IO(SafeWrite(v,write,up,&_float(o),sizeof(SQFloat)));break;
 240         case OT_NULL:
 241                 break;
 242         default:
 243                 v->Raise_Error(_SC("cannot serialize a %s"),GetTypeName(o));
 244                 return false;
 245         }
 246         return true;
 247 }
 248
 249 bool ReadObject(HSQUIRRELVM v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &o)
 250 {
 251         SQObjectType t;
 252         _CHECK_IO(SafeRead(v,read,up,&t,sizeof(SQObjectType)));
 253         switch(t){
 254         case OT_STRING:{
 255                 SQInteger len;
 256                 _CHECK_IO(SafeRead(v,read,up,&len,sizeof(SQInteger)));
 257                 _CHECK_IO(SafeRead(v,read,up,_ss(v)->GetScratchPad(rsl(len)),rsl(len)));
 258                 o=SQString::Create(_ss(v),_ss(v)->GetScratchPad(-1),len);
 259                                    }
 260                 break;
 261         case OT_INTEGER:{
 262                 SQInteger i;
 263                 _CHECK_IO(SafeRead(v,read,up,&i,sizeof(SQInteger))); o = i; break;
 264                                         }
 265         case OT_FLOAT:{
 266                 SQFloat f;
 267                 _CHECK_IO(SafeRead(v,read,up,&f,sizeof(SQFloat))); o = f; break;
 268                                   }
 269         case OT_NULL:
 270                 o=_null_;
 271                 break;
 272         default:
 273                 v->Raise_Error(_SC("cannot serialize a %s"),IdType2Name(t));
 274                 return false;
 275         }
 276         return true;
 277 }
 278
 279 bool SQClosure::Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write)
 280 {
 281         _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_HEAD));
 282         _CHECK_IO(WriteTag(v,write,up,sizeof(SQChar)));
 283         _CHECK_IO(_funcproto(_function)->Save(v,up,write));
 284         _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_TAIL));
 285         return true;
 286 }
 287
 288 bool SQClosure::Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret)
 289 {
 290         _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_HEAD));
 291         _CHECK_IO(CheckTag(v,read,up,sizeof(SQChar)));
 292         SQObjectPtr func;
 293         _CHECK_IO(SQFunctionProto::Load(v,up,read,func));
 294         _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_TAIL));
 295         ret = SQClosure::Create(_ss(v),_funcproto(func));
 296         return true;
 297 }
 298
 299 bool SQFunctionProto::Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write)
 300 {
 301         SQInteger i,nliterals = _nliterals,nparameters = _nparameters;
 302         SQInteger noutervalues = _noutervalues,nlocalvarinfos = _nlocalvarinfos;
 303         SQInteger nlineinfos=_nlineinfos,ninstructions = _ninstructions,nfunctions=_nfunctions;
 304         _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
 305         _CHECK_IO(WriteObject(v,up,write,_sourcename));
 306         _CHECK_IO(WriteObject(v,up,write,_name));
 307         _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
 308         _CHECK_IO(SafeWrite(v,write,up,&nliterals,sizeof(nliterals)));
 309         _CHECK_IO(SafeWrite(v,write,up,&nparameters,sizeof(nparameters)));
 310         _CHECK_IO(SafeWrite(v,write,up,&noutervalues,sizeof(noutervalues)));
 311         _CHECK_IO(SafeWrite(v,write,up,&nlocalvarinfos,sizeof(nlocalvarinfos)));
 312         _CHECK_IO(SafeWrite(v,write,up,&nlineinfos,sizeof(nlineinfos)));
 313         _CHECK_IO(SafeWrite(v,write,up,&ninstructions,sizeof(ninstructions)));
 314         _CHECK_IO(SafeWrite(v,write,up,&nfunctions,sizeof(nfunctions)));
 315         _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
 316         for(i=0;i<nliterals;i++){
 317                 _CHECK_IO(WriteObject(v,up,write,_literals[i]));
 318         }
 319
 320         _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
 321         for(i=0;i<nparameters;i++){
 322                 _CHECK_IO(WriteObject(v,up,write,_parameters[i]));
 323         }
 324
 325         _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
 326         for(i=0;i<noutervalues;i++){
 327                 _CHECK_IO(SafeWrite(v,write,up,&_outervalues[i]._type,sizeof(SQUnsignedInteger)));
 328                 _CHECK_IO(WriteObject(v,up,write,_outervalues[i]._src));
 329                 _CHECK_IO(WriteObject(v,up,write,_outervalues[i]._name));
 330         }
 331
 332         _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
 333         for(i=0;i<nlocalvarinfos;i++){
 334                 SQLocalVarInfo &lvi=_localvarinfos[i];
 335                 _CHECK_IO(WriteObject(v,up,write,lvi._name));
 336                 _CHECK_IO(SafeWrite(v,write,up,&lvi._pos,sizeof(SQUnsignedInteger)));
 337                 _CHECK_IO(SafeWrite(v,write,up,&lvi._start_op,sizeof(SQUnsignedInteger)));
 338                 _CHECK_IO(SafeWrite(v,write,up,&lvi._end_op,sizeof(SQUnsignedInteger)));
 339         }
 340
 341         _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
 342         _CHECK_IO(SafeWrite(v,write,up,_lineinfos,sizeof(SQLineInfo)*nlineinfos));
 343
 344         _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
 345         _CHECK_IO(SafeWrite(v,write,up,_instructions,sizeof(SQInstruction)*ninstructions));
 346
 347         _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
 348         for(i=0;i<nfunctions;i++){
 349                 _CHECK_IO(_funcproto(_functions[i])->Save(v,up,write));
 350         }
 351         _CHECK_IO(SafeWrite(v,write,up,&_stacksize,sizeof(_stacksize)));
 352         _CHECK_IO(SafeWrite(v,write,up,&_bgenerator,sizeof(_bgenerator)));
 353         _CHECK_IO(SafeWrite(v,write,up,&_varparams,sizeof(_varparams)));
 354         return true;
 355 }
 356
 357 bool SQFunctionProto::Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret)
 358 {
 359         SQInteger i, nliterals,nparameters;
 360         SQInteger noutervalues ,nlocalvarinfos ;
 361         SQInteger nlineinfos,ninstructions ,nfunctions ;
 362         SQObjectPtr sourcename, name;
 363         SQObjectPtr o;
 364         _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
 365         _CHECK_IO(ReadObject(v, up, read, sourcename));
 366         _CHECK_IO(ReadObject(v, up, read, name));
 367
 368         _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
 369         _CHECK_IO(SafeRead(v,read,up, &nliterals, sizeof(nliterals)));
 370         _CHECK_IO(SafeRead(v,read,up, &nparameters, sizeof(nparameters)));
 371         _CHECK_IO(SafeRead(v,read,up, &noutervalues, sizeof(noutervalues)));
 372         _CHECK_IO(SafeRead(v,read,up, &nlocalvarinfos, sizeof(nlocalvarinfos)));
 373         _CHECK_IO(SafeRead(v,read,up, &nlineinfos, sizeof(nlineinfos)));
 374         _CHECK_IO(SafeRead(v,read,up, &ninstructions, sizeof(ninstructions)));
 375         _CHECK_IO(SafeRead(v,read,up, &nfunctions, sizeof(nfunctions)));
 376
 377         SQFunctionProto *f = SQFunctionProto::Create(ninstructions,nliterals,nparameters,nfunctions,noutervalues,nlineinfos,nlocalvarinfos);
 378         SQObjectPtr proto = f; //gets a ref in case of failure
 379         f->_sourcename = sourcename;
 380         f->_name = name;
 381
 382         _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
 383
 384         for(i = 0;i < nliterals; i++){
 385                 _CHECK_IO(ReadObject(v, up, read, o));
 386                 f->_literals[i] = o;
 387         }
 388         _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
 389
 390         for(i = 0; i < nparameters; i++){
 391                 _CHECK_IO(ReadObject(v, up, read, o));
 392                 f->_parameters[i] = o;
 393         }
 394         _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
 395
 396         for(i = 0; i < noutervalues; i++){
 397                 SQUnsignedInteger type;
 398                 SQObjectPtr name;
 399                 _CHECK_IO(SafeRead(v,read,up, &type, sizeof(SQUnsignedInteger)));
 400                 _CHECK_IO(ReadObject(v, up, read, o));
 401                 _CHECK_IO(ReadObject(v, up, read, name));
 402                 f->_outervalues[i] = SQOuterVar(name,o, (SQOuterType)type);
 403         }
 404         _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
 405
 406         for(i = 0; i < nlocalvarinfos; i++){
 407                 SQLocalVarInfo lvi;
 408                 _CHECK_IO(ReadObject(v, up, read, lvi._name));
 409                 _CHECK_IO(SafeRead(v,read,up, &lvi._pos, sizeof(SQUnsignedInteger)));
 410                 _CHECK_IO(SafeRead(v,read,up, &lvi._start_op, sizeof(SQUnsignedInteger)));
 411                 _CHECK_IO(SafeRead(v,read,up, &lvi._end_op, sizeof(SQUnsignedInteger)));
 412                 f->_localvarinfos[i] = lvi;
 413         }
 414         _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
 415         _CHECK_IO(SafeRead(v,read,up, f->_lineinfos, sizeof(SQLineInfo)*nlineinfos));
 416
 417         _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
 418         _CHECK_IO(SafeRead(v,read,up, f->_instructions, sizeof(SQInstruction)*ninstructions));
 419
 420         _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
 421         for(i = 0; i < nfunctions; i++){
 422                 _CHECK_IO(_funcproto(o)->Load(v, up, read, o));
 423                 f->_functions[i] = o;
 424         }
 425         _CHECK_IO(SafeRead(v,read,up, &f->_stacksize, sizeof(f->_stacksize)));
 426         _CHECK_IO(SafeRead(v,read,up, &f->_bgenerator, sizeof(f->_bgenerator)));
 427         _CHECK_IO(SafeRead(v,read,up, &f->_varparams, sizeof(f->_varparams)));
 428         ret = f;
 429         return true;
 430 }
 431
 432 #ifndef NO_GARBAGE_COLLECTOR
 433
 434 #define START_MARK()    if(!(_uiRef&MARK_FLAG)){ \
 435                 _uiRef|=MARK_FLAG;
 436
 437 #define END_MARK() RemoveFromChain(&_sharedstate->_gc_chain, this); \
 438                 AddToChain(chain, this); }
 439
 440 void SQVM::Mark(SQCollectable **chain)
 441 {
 442         START_MARK()
 443                 SQSharedState::MarkObject(_lasterror,chain);
 444                 SQSharedState::MarkObject(_errorhandler,chain);
 445                 SQSharedState::MarkObject(_debughook,chain);
 446                 SQSharedState::MarkObject(_roottable, chain);
 447                 SQSharedState::MarkObject(temp_reg, chain);
 448                 for(SQUnsignedInteger i = 0; i < _stack.size(); i++) SQSharedState::MarkObject(_stack[i], chain);
 449                 for(SQUnsignedInteger j = 0; j < _vargsstack.size(); j++) SQSharedState::MarkObject(_vargsstack[j], chain);
 450         END_MARK()
 451 }
 452
 453 void SQArray::Mark(SQCollectable **chain)
 454 {
 455         START_MARK()
 456                 SQInteger len = _values.size();
 457                 for(SQInteger i = 0;i < len; i++) SQSharedState::MarkObject(_values[i], chain);
 458         END_MARK()
 459 }
 460 void SQTable::Mark(SQCollectable **chain)
 461 {
 462         START_MARK()
 463                 if(_delegate) _delegate->Mark(chain);
 464                 SQInteger len = _numofnodes;
 465                 for(SQInteger i = 0; i < len; i++){
 466                         SQSharedState::MarkObject(_nodes[i].key, chain);
 467                         SQSharedState::MarkObject(_nodes[i].val, chain);
 468                 }
 469         END_MARK()
 470 }
 471
 472 void SQClass::Mark(SQCollectable **chain)
 473 {
 474         START_MARK()
 475                 _members->Mark(chain);
 476                 if(_base) _base->Mark(chain);
 477                 SQSharedState::MarkObject(_attributes, chain);
 478                 for(SQUnsignedInteger i =0; i< _defaultvalues.size(); i++) {
 479                         SQSharedState::MarkObject(_defaultvalues[i].val, chain);
 480                         SQSharedState::MarkObject(_defaultvalues[i].attrs, chain);
 481                 }
 482                 for(SQUnsignedInteger j =0; j< _methods.size(); j++) {
 483                         SQSharedState::MarkObject(_methods[j].val, chain);
 484                         SQSharedState::MarkObject(_methods[j].attrs, chain);
 485                 }
 486                 for(SQUnsignedInteger k =0; k< _metamethods.size(); k++) {
 487                         SQSharedState::MarkObject(_metamethods[k], chain);
 488                 }
 489         END_MARK()
 490 }
 491
 492 void SQInstance::Mark(SQCollectable **chain)
 493 {
 494         START_MARK()
 495                 _class->Mark(chain);
 496                 SQUnsignedInteger nvalues = _class->_defaultvalues.size();
 497                 for(SQUnsignedInteger i =0; i< nvalues; i++) {
 498                         SQSharedState::MarkObject(_values[i], chain);
 499                 }
 500         END_MARK()
 501 }
 502
 503 void SQGenerator::Mark(SQCollectable **chain)
 504 {
 505         START_MARK()
 506                 for(SQUnsignedInteger i = 0; i < _stack.size(); i++) SQSharedState::MarkObject(_stack[i], chain);
 507                 for(SQUnsignedInteger j = 0; j < _vargsstack.size(); j++) SQSharedState::MarkObject(_vargsstack[j], chain);
 508                 SQSharedState::MarkObject(_closure, chain);
 509         END_MARK()
 510 }
 511
 512 void SQClosure::Mark(SQCollectable **chain)
 513 {
 514         START_MARK()
 515                 for(SQUnsignedInteger i = 0; i < _outervalues.size(); i++) SQSharedState::MarkObject(_outervalues[i], chain);
 516         END_MARK()
 517 }
 518
 519 void SQNativeClosure::Mark(SQCollectable **chain)
 520 {
 521         START_MARK()
 522                 for(SQUnsignedInteger i = 0; i < _outervalues.size(); i++) SQSharedState::MarkObject(_outervalues[i], chain);
 523         END_MARK()
 524 }
 525
 526 void SQUserData::Mark(SQCollectable **chain){
 527         START_MARK()
 528                 if(_delegate) _delegate->Mark(chain);
 529         END_MARK()
 530 }
 531
 532 void SQCollectable::UnMark() { _uiRef&=~MARK_FLAG; }
 533
 534 #endif
 535