src/squirrel/squirrel/sqstate.cpp

   1 /*
   2         see copyright notice in squirrel.h
   3 */
   4 #include "sqpcheader.h"
   5 #include "sqopcodes.h"
   6 #include "sqvm.h"
   7 #include "sqfuncproto.h"
   8 #include "sqclosure.h"
   9 #include "sqstring.h"
  10 #include "sqtable.h"
  11 #include "sqarray.h"
  12 #include "squserdata.h"
  13 #include "sqclass.h"
  14
  15 SQObjectPtr _null_;
  16 SQObjectPtr _true_(true);
  17 SQObjectPtr _false_(false);
  18 SQObjectPtr _one_((SQInteger)1);
  19 SQObjectPtr _minusone_((SQInteger)-1);
  20
  21 SQSharedState::SQSharedState()
  22 {
  23         _compilererrorhandler = NULL;
  24         _printfunc = NULL;
  25         _debuginfo = false;
  26         _notifyallexceptions = false;
  27 }
  28
  29 #define newsysstring(s) {       \
  30         _systemstrings->push_back(SQString::Create(this,s));    \
  31         }
  32
  33 #define newmetamethod(s) {      \
  34         _metamethods->push_back(SQString::Create(this,s));      \
  35         _table(_metamethodsmap)->NewSlot(_metamethods->back(),(SQInteger)(_metamethods->size()-1)); \
  36         }
  37
  38 bool CompileTypemask(SQIntVec &res,const SQChar *typemask)
  39 {
  40         SQInteger i = 0;
  41
  42         SQInteger mask = 0;
  43         while(typemask[i] != 0) {
  44
  45                 switch(typemask[i]){
  46                                 case 'o': mask |= _RT_NULL; break;
  47                                 case 'i': mask |= _RT_INTEGER; break;
  48                                 case 'f': mask |= _RT_FLOAT; break;
  49                                 case 'n': mask |= (_RT_FLOAT | _RT_INTEGER); break;
  50                                 case 's': mask |= _RT_STRING; break;
  51                                 case 't': mask |= _RT_TABLE; break;
  52                                 case 'a': mask |= _RT_ARRAY; break;
  53                                 case 'u': mask |= _RT_USERDATA; break;
  54                                 case 'c': mask |= (_RT_CLOSURE | _RT_NATIVECLOSURE); break;
  55                                 case 'b': mask |= _RT_BOOL; break;
  56                                 case 'g': mask |= _RT_GENERATOR; break;
  57                                 case 'p': mask |= _RT_USERPOINTER; break;
  58                                 case 'v': mask |= _RT_THREAD; break;
  59                                 case 'x': mask |= _RT_INSTANCE; break;
  60                                 case 'y': mask |= _RT_CLASS; break;
  61                                 case 'r': mask |= _RT_WEAKREF; break;
  62                                 case '.': mask = -1; res.push_back(mask); i++; mask = 0; continue;
  63                                 case ' ': i++; continue; //ignores spaces
  64                                 default:
  65                                         return false;
  66                 }
  67                 i++;
  68                 if(typemask[i] == '|') {
  69                         i++;
  70                         if(typemask[i] == 0)
  71                                 return false;
  72                         continue;
  73                 }
  74                 res.push_back(mask);
  75                 mask = 0;
  76
  77         }
  78         return true;
  79 }
  80
  81 SQTable *CreateDefaultDelegate(SQSharedState *ss,SQRegFunction *funcz)
  82 {
  83         SQInteger i=0;
  84         SQTable *t=SQTable::Create(ss,0);
  85         while(funcz[i].name!=0){
  86                 SQNativeClosure *nc = SQNativeClosure::Create(ss,funcz[i].f);
  87                 nc->_nparamscheck = funcz[i].nparamscheck;
  88                 nc->_name = SQString::Create(ss,funcz[i].name);
  89                 if(funcz[i].typemask && !CompileTypemask(nc->_typecheck,funcz[i].typemask))
  90                         return NULL;
  91                 t->NewSlot(SQString::Create(ss,funcz[i].name),nc);
  92                 i++;
  93         }
  94         return t;
  95 }
  96
  97 void SQSharedState::Init()
  98 {
  99         _scratchpad=NULL;
 100         _scratchpadsize=0;
 101 #ifndef NO_GARBAGE_COLLECTOR
 102         _gc_chain=NULL;
 103 #endif
 104         sq_new(_stringtable,StringTable);
 105         sq_new(_metamethods,SQObjectPtrVec);
 106         sq_new(_systemstrings,SQObjectPtrVec);
 107         sq_new(_types,SQObjectPtrVec);
 108         _metamethodsmap = SQTable::Create(this,MT_LAST-1);
 109         //adding type strings to avoid memory trashing
 110         //types names
 111         newsysstring(_SC("null"));
 112         newsysstring(_SC("table"));
 113         newsysstring(_SC("array"));
 114         newsysstring(_SC("closure"));
 115         newsysstring(_SC("string"));
 116         newsysstring(_SC("userdata"));
 117         newsysstring(_SC("integer"));
 118         newsysstring(_SC("float"));
 119         newsysstring(_SC("userpointer"));
 120         newsysstring(_SC("function"));
 121         newsysstring(_SC("generator"));
 122         newsysstring(_SC("thread"));
 123         newsysstring(_SC("class"));
 124         newsysstring(_SC("instance"));
 125         newsysstring(_SC("bool"));
 126         //meta methods
 127         newmetamethod(MM_ADD);
 128         newmetamethod(MM_SUB);
 129         newmetamethod(MM_MUL);
 130         newmetamethod(MM_DIV);
 131         newmetamethod(MM_UNM);
 132         newmetamethod(MM_MODULO);
 133         newmetamethod(MM_SET);
 134         newmetamethod(MM_GET);
 135         newmetamethod(MM_TYPEOF);
 136         newmetamethod(MM_NEXTI);
 137         newmetamethod(MM_CMP);
 138         newmetamethod(MM_CALL);
 139         newmetamethod(MM_CLONED);
 140         newmetamethod(MM_NEWSLOT);
 141         newmetamethod(MM_DELSLOT);
 142         newmetamethod(MM_TOSTRING);
 143         newmetamethod(MM_NEWMEMBER);
 144         newmetamethod(MM_INHERITED);
 145
 146         _constructoridx = SQString::Create(this,_SC("constructor"));
 147         _registry = SQTable::Create(this,0);
 148         _table_default_delegate=CreateDefaultDelegate(this,_table_default_delegate_funcz);
 149         _array_default_delegate=CreateDefaultDelegate(this,_array_default_delegate_funcz);
 150         _string_default_delegate=CreateDefaultDelegate(this,_string_default_delegate_funcz);
 151         _number_default_delegate=CreateDefaultDelegate(this,_number_default_delegate_funcz);
 152         _closure_default_delegate=CreateDefaultDelegate(this,_closure_default_delegate_funcz);
 153         _generator_default_delegate=CreateDefaultDelegate(this,_generator_default_delegate_funcz);
 154         _thread_default_delegate=CreateDefaultDelegate(this,_thread_default_delegate_funcz);
 155         _class_default_delegate=CreateDefaultDelegate(this,_class_default_delegate_funcz);
 156         _instance_default_delegate=CreateDefaultDelegate(this,_instance_default_delegate_funcz);
 157         _weakref_default_delegate=CreateDefaultDelegate(this,_weakref_default_delegate_funcz);
 158
 159 }
 160
 161 SQSharedState::~SQSharedState()
 162 {
 163         _constructoridx = _null_;
 164         _refs_table.Finalize();
 165         _table(_registry)->Finalize();
 166         _table(_metamethodsmap)->Finalize();
 167 //      _refs_table = _null_;
 168         _registry = _null_;
 169         _metamethodsmap = _null_;
 170         while(!_systemstrings->empty()){
 171                 _systemstrings->back()=_null_;
 172                 _systemstrings->pop_back();
 173         }
 174         _thread(_root_vm)->Finalize();
 175         _root_vm = _null_;
 176         _table_default_delegate=_null_;
 177         _array_default_delegate=_null_;
 178         _string_default_delegate=_null_;
 179         _number_default_delegate=_null_;
 180         _closure_default_delegate=_null_;
 181         _generator_default_delegate=_null_;
 182         _thread_default_delegate=_null_;
 183         _class_default_delegate=_null_;
 184         _instance_default_delegate=_null_;
 185         _weakref_default_delegate=_null_;
 186
 187 #ifndef NO_GARBAGE_COLLECTOR
 188
 189
 190         SQCollectable *t=_gc_chain;
 191         SQCollectable *nx=NULL;
 192         while(t){
 193                 t->_uiRef++;
 194                 t->Finalize();
 195                 nx=t->_next;
 196                 if(--t->_uiRef==0)
 197                         t->Release();
 198                 t=nx;
 199         }
 200         assert(_gc_chain==NULL); //just to proove a theory
 201         while(_gc_chain){
 202                 _gc_chain->_uiRef++;
 203                 _gc_chain->Release();
 204         }
 205 #endif
 206         sq_delete(_types,SQObjectPtrVec);
 207         sq_delete(_systemstrings,SQObjectPtrVec);
 208         sq_delete(_metamethods,SQObjectPtrVec);
 209         sq_delete(_stringtable,StringTable);
 210         if(_scratchpad)SQ_FREE(_scratchpad,_scratchpadsize);
 211 }
 212
 213
 214 SQInteger SQSharedState::GetMetaMethodIdxByName(const SQObjectPtr &name)
 215 {
 216         if(type(name) != OT_STRING)
 217                 return -1;
 218         SQObjectPtr ret;
 219         if(_table(_metamethodsmap)->Get(name,ret)) {
 220                 return _integer(ret);
 221         }
 222         return -1;
 223 }
 224
 225 #ifndef NO_GARBAGE_COLLECTOR
 226
 227 void SQSharedState::MarkObject(SQObjectPtr &o,SQCollectable **chain)
 228 {
 229         switch(type(o)){
 230         case OT_TABLE:_table(o)->Mark(chain);break;
 231         case OT_ARRAY:_array(o)->Mark(chain);break;
 232         case OT_USERDATA:_userdata(o)->Mark(chain);break;
 233         case OT_CLOSURE:_closure(o)->Mark(chain);break;
 234         case OT_NATIVECLOSURE:_nativeclosure(o)->Mark(chain);break;
 235         case OT_GENERATOR:_generator(o)->Mark(chain);break;
 236         case OT_THREAD:_thread(o)->Mark(chain);break;
 237         case OT_CLASS:_class(o)->Mark(chain);break;
 238         case OT_INSTANCE:_instance(o)->Mark(chain);break;
 239         default: break; //shutup compiler
 240         }
 241 }
 242
 243
 244 SQInteger SQSharedState::CollectGarbage(SQVM *vm)
 245 {
 246         SQInteger n=0;
 247         SQCollectable *tchain=NULL;
 248         SQVM *vms=_thread(_root_vm);
 249
 250         vms->Mark(&tchain);
 251         SQInteger x = _table(_thread(_root_vm)->_roottable)->CountUsed();
 252         _refs_table.Mark(&tchain);
 253         MarkObject(_registry,&tchain);
 254         MarkObject(_metamethodsmap,&tchain);
 255         MarkObject(_table_default_delegate,&tchain);
 256         MarkObject(_array_default_delegate,&tchain);
 257         MarkObject(_string_default_delegate,&tchain);
 258         MarkObject(_number_default_delegate,&tchain);
 259         MarkObject(_generator_default_delegate,&tchain);
 260         MarkObject(_thread_default_delegate,&tchain);
 261         MarkObject(_closure_default_delegate,&tchain);
 262         MarkObject(_class_default_delegate,&tchain);
 263         MarkObject(_instance_default_delegate,&tchain);
 264         MarkObject(_weakref_default_delegate,&tchain);
 265
 266         SQCollectable *t=_gc_chain;
 267         SQCollectable *nx=NULL;
 268         while(t){
 269                 t->_uiRef++;
 270                 t->Finalize();
 271                 nx=t->_next;
 272                 if(--t->_uiRef==0)
 273                         t->Release();
 274                 t=nx;
 275                 n++;
 276         }
 277
 278         t=tchain;
 279         while(t){
 280                 t->UnMark();
 281                 t=t->_next;
 282         }
 283         _gc_chain=tchain;
 284         SQInteger z = _table(_thread(_root_vm)->_roottable)->CountUsed();
 285         assert(z == x);
 286         return n;
 287 }
 288 #endif
 289
 290 #ifndef NO_GARBAGE_COLLECTOR
 291 void SQCollectable::AddToChain(SQCollectable **chain,SQCollectable *c)
 292 {
 293     c->_prev=NULL;
 294         c->_next=*chain;
 295         if(*chain) (*chain)->_prev=c;
 296         *chain=c;
 297 }
 298
 299 void SQCollectable::RemoveFromChain(SQCollectable **chain,SQCollectable *c)
 300 {
 301         if(c->_prev) c->_prev->_next=c->_next;
 302         else *chain=c->_next;
 303         if(c->_next)
 304                 c->_next->_prev=c->_prev;
 305         c->_next=NULL;
 306         c->_prev=NULL;
 307 }
 308 #endif
 309
 310 SQChar* SQSharedState::GetScratchPad(SQInteger size)
 311 {
 312         SQInteger newsize;
 313         if(size>0){
 314                 if(_scratchpadsize<size){
 315                         newsize=size+(size>>1);
 316                         _scratchpad=(SQChar *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
 317                         _scratchpadsize=newsize;
 318
 319                 }else if(_scratchpadsize>=(size<<5)){
 320                         newsize=_scratchpadsize>>1;
 321                         _scratchpad=(SQChar *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
 322                         _scratchpadsize=newsize;
 323                 }
 324         }
 325         return _scratchpad;
 326 }
 327
 328 RefTable::RefTable()
 329 {
 330         AllocNodes(4);
 331 }
 332
 333 void RefTable::Finalize()
 334 {
 335         RefNode *nodes = (RefNode *)&_buckets[_numofslots];
 336         for(SQUnsignedInteger n = 0; n < _numofslots; n++) {
 337                 nodes->obj = _null_;
 338                 nodes++;
 339         }
 340 }
 341
 342 RefTable::~RefTable()
 343 {
 344         SQ_FREE(_buckets,_buffersize);
 345 }
 346 #ifndef NO_GARBAGE_COLLECTOR
 347 void RefTable::Mark(SQCollectable **chain)
 348 {
 349         RefNode *nodes = (RefNode *)&_buckets[_numofslots];
 350         for(SQUnsignedInteger n = 0; n < _numofslots; n++) {
 351                 if(type(nodes->obj) != OT_NULL) {
 352                         SQSharedState::MarkObject(nodes->obj,chain);
 353                 }
 354                 nodes++;
 355         }
 356 }
 357 #endif
 358 void RefTable::AddRef(SQObject &obj)
 359 {
 360         SQHash mainpos;
 361         RefNode *prev;
 362         RefNode *ref = Get(obj,mainpos,&prev,true);
 363         ref->refs++;
 364 }
 365
 366 SQBool RefTable::Release(SQObject &obj)
 367 {
 368         SQHash mainpos;
 369         RefNode *prev;
 370         RefNode *ref = Get(obj,mainpos,&prev,false);
 371         if(ref) {
 372                 if(--ref->refs == 0) {
 373                         ref->obj = _null_;
 374                         if(prev) {
 375                                 prev->next = ref->next;
 376                         }
 377                         else {
 378                                 _buckets[mainpos] = ref->next;
 379                         }
 380                         ref->next = _freelist;
 381                         _freelist = ref;
 382                         _slotused--;
 383                         //<<FIXME>>test for shrink?
 384                         return SQTrue;
 385                 }
 386         }
 387         return SQFalse;
 388 }
 389
 390 void RefTable::Resize(SQUnsignedInteger size)
 391 {
 392         RefNode **oldbuffer = _buckets;
 393         RefNode *oldnodes = (RefNode *)&_buckets[_numofslots];
 394         SQUnsignedInteger oldnumofslots = _numofslots;
 395         SQUnsignedInteger oldbuffersize = _buffersize;
 396         AllocNodes(size);
 397         //rehash
 398         for(SQUnsignedInteger n = 0; n < oldnumofslots; n++) {
 399                 if(type(oldnodes->obj) != OT_NULL) {
 400                         //add back;
 401                         assert(oldnodes->refs != 0);
 402                         RefNode *nn = Add(::HashObj(oldnodes->obj)&(_numofslots-1),oldnodes->obj);
 403                         nn->refs = oldnodes->refs;
 404                         oldnodes->obj = _null_;
 405                 }
 406                 oldnodes++;
 407         }
 408         SQ_FREE(oldbuffer,oldbuffersize);
 409 }
 410
 411 RefTable::RefNode *RefTable::Add(SQHash mainpos,SQObject &obj)
 412 {
 413         RefNode *t = _buckets[mainpos];
 414         RefNode *newnode = _freelist;
 415         newnode->obj = obj;
 416         _buckets[mainpos] = newnode;
 417         _freelist = _freelist->next;
 418         newnode->next = t;
 419         assert(newnode->refs == 0);
 420         _slotused++;
 421         return newnode;
 422 }
 423
 424 RefTable::RefNode *RefTable::Get(SQObject &obj,SQHash &mainpos,RefNode **prev,bool add)
 425 {
 426         RefNode *ref;
 427         mainpos = ::HashObj(obj)&(_numofslots-1);
 428         *prev = NULL;
 429         for (ref = _buckets[mainpos]; ref; ) {
 430                 if(_rawval(ref->obj) == _rawval(obj) && type(ref->obj) == type(obj))
 431                         break;
 432                 *prev = ref;
 433                 ref = ref->next;
 434         }
 435         if(ref == NULL && add) {
 436                 if(_numofslots == _slotused) {
 437                         Resize(_numofslots*2);
 438                 }
 439                 ref = Add(mainpos,obj);
 440         }
 441         return ref;
 442 }
 443
 444 void RefTable::AllocNodes(SQUnsignedInteger size)
 445 {
 446         RefNode **bucks;
 447         RefNode *firstnode;
 448         _buffersize = size * sizeof(RefNode *) + size * sizeof(RefNode);
 449         bucks = (RefNode **)SQ_MALLOC(_buffersize);
 450         firstnode = (RefNode *)&bucks[size];
 451         RefNode *temp = firstnode;
 452         SQUnsignedInteger n;
 453         for(n = 0; n < size - 1; n++) {
 454                 bucks[n] = NULL;
 455                 temp->refs = 0;
 456                 new (&temp->obj) SQObjectPtr;
 457                 temp->next = temp+1;
 458                 temp++;
 459         }
 460         bucks[n] = NULL;
 461         temp->refs = 0;
 462         new (&temp->obj) SQObjectPtr;
 463         temp->next = NULL;
 464         _freelist = firstnode;
 465         _buckets = bucks;
 466         _slotused = 0;
 467         _numofslots = size;
 468 }
 469 //////////////////////////////////////////////////////////////////////////
 470 //StringTable
 471 /*
 472 * The following code is based on Lua 4.0 (Copyright 1994-2002 Tecgraf, PUC-Rio.)
 473 * http://www.lua.org/copyright.html#4
 474 * http://www.lua.org/source/4.0.1/src_lstring.c.html
 475 */
 476
 477 StringTable::StringTable()
 478 {
 479         AllocNodes(4);
 480         _slotused = 0;
 481 }
 482
 483 StringTable::~StringTable()
 484 {
 485         SQ_FREE(_strings,sizeof(SQString*)*_numofslots);
 486         _strings=NULL;
 487 }
 488
 489 void StringTable::AllocNodes(SQInteger size)
 490 {
 491         _numofslots=size;
 492         //_slotused=0;
 493         _strings=(SQString**)SQ_MALLOC(sizeof(SQString*)*_numofslots);
 494         memset(_strings,0,sizeof(SQString*)*_numofslots);
 495 }
 496
 497 SQString *StringTable::Add(const SQChar *news,SQInteger len)
 498 {
 499         if(len<0)
 500                 len = (SQInteger)scstrlen(news);
 501         SQHash h = ::_hashstr(news,len)&(_numofslots-1);
 502         SQString *s;
 503         for (s = _strings[h]; s; s = s->_next){
 504                 if(s->_len == len && (!memcmp(news,s->_val,rsl(len))))
 505                         return s; //found
 506         }
 507
 508         SQString *t=(SQString *)SQ_MALLOC(rsl(len)+sizeof(SQString));
 509         new (t) SQString;
 510         memcpy(t->_val,news,rsl(len));
 511         t->_val[len] = _SC('\0');
 512         t->_len = len;
 513         t->_hash = ::_hashstr(news,len);
 514         t->_next = _strings[h];
 515         _strings[h] = t;
 516         _slotused++;
 517         if (_slotused > _numofslots)  /* too crowded? */
 518                 Resize(_numofslots*2);
 519         return t;
 520 }
 521
 522 void StringTable::Resize(SQInteger size)
 523 {
 524         SQInteger oldsize=_numofslots;
 525         SQString **oldtable=_strings;
 526         AllocNodes(size);
 527         for (SQInteger i=0; i<oldsize; i++){
 528                 SQString *p = oldtable[i];
 529                 while(p){
 530                         SQString *next = p->_next;
 531                         SQHash h = p->_hash&(_numofslots-1);
 532                         p->_next = _strings[h];
 533                         _strings[h] = p;
 534                         p = next;
 535                 }
 536         }
 537         SQ_FREE(oldtable,oldsize*sizeof(SQString*));
 538 }
 539
 540 void StringTable::Remove(SQString *bs)
 541 {
 542         SQString *s;
 543         SQString *prev=NULL;
 544         SQHash h = bs->_hash&(_numofslots - 1);
 545
 546         for (s = _strings[h]; s; ){
 547                 if(s == bs){
 548                         if(prev)
 549                                 prev->_next = s->_next;
 550                         else
 551                                 _strings[h] = s->_next;
 552                         _slotused--;
 553                         SQInteger slen = s->_len;
 554                         s->~SQString();
 555                         SQ_FREE(s,sizeof(SQString) + rsl(slen));
 556                         return;
 557                 }
 558                 prev = s;
 559                 s = s->_next;
 560         }
 561         assert(0);//if this fail something is wrong
 562 }