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_(1);
  19 SQObjectPtr _minusone_(-1);
  20
  21 SQSharedState::SQSharedState()
  22 {
  23         _compilererrorhandler = NULL;
  24         _printfunc = NULL;
  25         _debuginfo = false;
  26 }
  27
  28 #define newsysstring(s) {       \
  29         _systemstrings->push_back(SQString::Create(this,s));    \
  30         }
  31
  32 #define newmetamethod(s) {      \
  33         _metamethods->push_back(SQString::Create(this,s));      \
  34         _table(_metamethodsmap)->NewSlot(_metamethods->back(),(SQInteger)(_metamethods->size()-1)); \
  35         }
  36
  37 bool CompileTypemask(SQIntVec &res,const SQChar *typemask)
  38 {
  39         int i = 0;
  40
  41         int mask = 0;
  42         while(typemask[i] != 0) {
  43
  44                 switch(typemask[i]){
  45                                 case 'i': mask |= _RT_INTEGER; break;
  46                                 case 'f': mask |= _RT_FLOAT; break;
  47                                 case 'n': mask |= (_RT_FLOAT | _RT_INTEGER); break;
  48                                 case 's': mask |= _RT_STRING; break;
  49                                 case 't': mask |= _RT_TABLE; break;
  50                                 case 'a': mask |= _RT_ARRAY; break;
  51                                 case 'u': mask |= _RT_USERDATA; break;
  52                                 case 'c': mask |= (_RT_CLOSURE | _RT_NATIVECLOSURE); break;
  53                                 case 'b': mask |= _RT_BOOL; break;
  54                                 case 'g': mask |= _RT_GENERATOR; break;
  55                                 case 'p': mask |= _RT_USERPOINTER; break;
  56                                 case 'v': mask |= _RT_THREAD; break;
  57                                 case 'x': mask |= _RT_INSTANCE; break;
  58                                 case 'y': mask |= _RT_CLASS; break;
  59                                 case '.': mask = -1; res.push_back(mask); i++; mask = 0; continue;
  60                                 case ' ': i++; continue; //ignores spaces
  61                                 default:
  62                                         return false;
  63                 }
  64                 i++;
  65                 if(typemask[i] == '|') {
  66                         i++;
  67                         if(typemask[i] == 0)
  68                                 return false;
  69                         continue;
  70                 }
  71                 res.push_back(mask);
  72                 mask = 0;
  73
  74         }
  75         return true;
  76 }
  77
  78 SQTable *CreateDefaultDelegate(SQSharedState *ss,SQRegFunction *funcz)
  79 {
  80         int i=0;
  81         SQTable *t=SQTable::Create(ss,0);
  82         while(funcz[i].name!=0){
  83                 SQNativeClosure *nc = SQNativeClosure::Create(ss,funcz[i].f);
  84                 nc->_nparamscheck = funcz[i].nparamscheck;
  85                 nc->_name = SQString::Create(ss,funcz[i].name);
  86                 if(funcz[i].typemask && !CompileTypemask(nc->_typecheck,funcz[i].typemask))
  87                         return NULL;
  88                 t->NewSlot(SQString::Create(ss,funcz[i].name),nc);
  89                 i++;
  90         }
  91         return t;
  92 }
  93
  94 void SQSharedState::Init()
  95 {
  96         _scratchpad=NULL;
  97         _scratchpadsize=0;
  98 #ifndef NO_GARBAGE_COLLECTOR
  99         _gc_chain=NULL;
 100 #endif
 101         sq_new(_stringtable,StringTable);
 102         sq_new(_metamethods,SQObjectPtrVec);
 103         sq_new(_systemstrings,SQObjectPtrVec);
 104         sq_new(_types,SQObjectPtrVec);
 105         _metamethodsmap = SQTable::Create(this,MT_LAST-1);
 106         //adding type strings to avoid memory trashing
 107         //types names
 108         newsysstring(_SC("null"));
 109         newsysstring(_SC("table"));
 110         newsysstring(_SC("array"));
 111         newsysstring(_SC("closure"));
 112         newsysstring(_SC("string"));
 113         newsysstring(_SC("userdata"));
 114         newsysstring(_SC("integer"));
 115         newsysstring(_SC("float"));
 116         newsysstring(_SC("userpointer"));
 117         newsysstring(_SC("function"));
 118         newsysstring(_SC("generator"));
 119         newsysstring(_SC("thread"));
 120         newsysstring(_SC("class"));
 121         newsysstring(_SC("instance"));
 122         newsysstring(_SC("bool"));
 123         //meta methods
 124         newmetamethod(MM_ADD);
 125         newmetamethod(MM_SUB);
 126         newmetamethod(MM_MUL);
 127         newmetamethod(MM_DIV);
 128         newmetamethod(MM_UNM);
 129         newmetamethod(MM_MODULO);
 130         newmetamethod(MM_SET);
 131         newmetamethod(MM_GET);
 132         newmetamethod(MM_TYPEOF);
 133         newmetamethod(MM_NEXTI);
 134         newmetamethod(MM_CMP);
 135         newmetamethod(MM_CALL);
 136         newmetamethod(MM_CLONED);
 137         newmetamethod(MM_NEWSLOT);
 138         newmetamethod(MM_DELSLOT);
 139
 140         _constructoridx = SQString::Create(this,_SC("constructor"));
 141         _refs_table = SQTable::Create(this,0);
 142         _registry = SQTable::Create(this,0);
 143         _table_default_delegate=CreateDefaultDelegate(this,_table_default_delegate_funcz);
 144         _array_default_delegate=CreateDefaultDelegate(this,_array_default_delegate_funcz);
 145         _string_default_delegate=CreateDefaultDelegate(this,_string_default_delegate_funcz);
 146         _number_default_delegate=CreateDefaultDelegate(this,_number_default_delegate_funcz);
 147         _closure_default_delegate=CreateDefaultDelegate(this,_closure_default_delegate_funcz);
 148         _generator_default_delegate=CreateDefaultDelegate(this,_generator_default_delegate_funcz);
 149         _thread_default_delegate=CreateDefaultDelegate(this,_thread_default_delegate_funcz);
 150         _class_default_delegate=CreateDefaultDelegate(this,_class_default_delegate_funcz);
 151         _instance_default_delegate=CreateDefaultDelegate(this,_instance_default_delegate_funcz);
 152
 153 }
 154
 155 SQSharedState::~SQSharedState()
 156 {
 157         _constructoridx = _null_;
 158         _table(_refs_table)->Finalize();
 159         _table(_registry)->Finalize();
 160         _table(_metamethodsmap)->Finalize();
 161         _refs_table = _null_;
 162         _registry = _null_;
 163         _metamethodsmap = _null_;
 164         while(!_systemstrings->empty()){
 165                 _systemstrings->back()=_null_;
 166                 _systemstrings->pop_back();
 167         }
 168         _thread(_root_vm)->Finalize();
 169         _root_vm = _null_;
 170         _table_default_delegate=_null_;
 171         _array_default_delegate=_null_;
 172         _string_default_delegate=_null_;
 173         _number_default_delegate=_null_;
 174         _closure_default_delegate=_null_;
 175         _generator_default_delegate=_null_;
 176         _thread_default_delegate=_null_;
 177         _class_default_delegate=_null_;
 178         _instance_default_delegate=_null_;
 179
 180 #ifndef NO_GARBAGE_COLLECTOR
 181
 182
 183         SQCollectable *t=_gc_chain;
 184         SQCollectable *nx=NULL;
 185         while(t){
 186                 t->_uiRef++;
 187                 t->Finalize();
 188                 nx=t->_next;
 189                 if(--t->_uiRef==0)
 190                         t->Release();
 191                 t=nx;
 192         }
 193         assert(_gc_chain==NULL); //just to proove a theory
 194         while(_gc_chain){
 195                 _gc_chain->_uiRef++;
 196                 _gc_chain->Release();
 197         }
 198 #endif
 199         sq_delete(_types,SQObjectPtrVec);
 200         sq_delete(_systemstrings,SQObjectPtrVec);
 201         sq_delete(_metamethods,SQObjectPtrVec);
 202         sq_delete(_stringtable,StringTable);
 203         if(_scratchpad)SQ_FREE(_scratchpad,_scratchpadsize);
 204 }
 205
 206
 207 SQInteger SQSharedState::GetMetaMethodIdxByName(const SQObjectPtr &name)
 208 {
 209         if(type(name) != OT_STRING)
 210                 return -1;
 211         SQObjectPtr ret;
 212         if(_table(_metamethodsmap)->Get(name,ret)) {
 213                 return _integer(ret);
 214         }
 215         return -1;
 216 }
 217
 218 #ifndef NO_GARBAGE_COLLECTOR
 219
 220 void SQSharedState::MarkObject(SQObjectPtr &o,SQCollectable **chain)
 221 {
 222         switch(type(o)){
 223         case OT_TABLE:_table(o)->Mark(chain);break;
 224         case OT_ARRAY:_array(o)->Mark(chain);break;
 225         case OT_USERDATA:_userdata(o)->Mark(chain);break;
 226         case OT_CLOSURE:_closure(o)->Mark(chain);break;
 227         case OT_NATIVECLOSURE:_nativeclosure(o)->Mark(chain);break;
 228         case OT_GENERATOR:_generator(o)->Mark(chain);break;
 229         case OT_THREAD:_thread(o)->Mark(chain);break;
 230         case OT_CLASS:_class(o)->Mark(chain);break;
 231         case OT_INSTANCE:_instance(o)->Mark(chain);break;
 232         default: break;
 233         }
 234 }
 235
 236
 237 int SQSharedState::CollectGarbage(SQVM *vm)
 238 {
 239         (void) vm;
 240         int n=0;
 241         SQCollectable *tchain=NULL;
 242         SQVM *vms=_thread(_root_vm);
 243
 244         vms->Mark(&tchain);
 245         int x = _table(_thread(_root_vm)->_roottable)->CountUsed();
 246         MarkObject(_refs_table,&tchain);
 247         MarkObject(_registry,&tchain);
 248         MarkObject(_metamethodsmap,&tchain);
 249         MarkObject(_table_default_delegate,&tchain);
 250         MarkObject(_array_default_delegate,&tchain);
 251         MarkObject(_string_default_delegate,&tchain);
 252         MarkObject(_number_default_delegate,&tchain);
 253         MarkObject(_generator_default_delegate,&tchain);
 254         MarkObject(_thread_default_delegate,&tchain);
 255         MarkObject(_closure_default_delegate,&tchain);
 256         MarkObject(_class_default_delegate,&tchain);
 257         MarkObject(_instance_default_delegate,&tchain);
 258
 259         SQCollectable *t=_gc_chain;
 260         SQCollectable *nx=NULL;
 261         while(t){
 262                 t->_uiRef++;
 263                 t->Finalize();
 264                 nx=t->_next;
 265                 if(--t->_uiRef==0)
 266                         t->Release();
 267                 t=nx;
 268                 n++;
 269         }
 270
 271         t=tchain;
 272         while(t){
 273                 t->UnMark();
 274                 t=t->_next;
 275         }
 276         _gc_chain=tchain;
 277         int z = _table(_thread(_root_vm)->_roottable)->CountUsed();
 278         assert(z == x);
 279         return n;
 280 }
 281 #endif
 282
 283 #ifndef NO_GARBAGE_COLLECTOR
 284 void SQCollectable::AddToChain(SQCollectable **chain,SQCollectable *c)
 285 {
 286     c->_prev=NULL;
 287         c->_next=*chain;
 288         if(*chain) (*chain)->_prev=c;
 289         *chain=c;
 290 }
 291
 292 void SQCollectable::RemoveFromChain(SQCollectable **chain,SQCollectable *c)
 293 {
 294         if(c->_prev) c->_prev->_next=c->_next;
 295         else *chain=c->_next;
 296         if(c->_next)
 297                 c->_next->_prev=c->_prev;
 298         c->_next=NULL;
 299         c->_prev=NULL;
 300 }
 301 #endif
 302
 303 SQChar* SQSharedState::GetScratchPad(int size)
 304 {
 305         int newsize;
 306         if(size>0){
 307                 if(_scratchpadsize<size){
 308                         newsize=size+(size>>1);
 309                         _scratchpad=(SQChar *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
 310                         _scratchpadsize=newsize;
 311
 312                 }else if(_scratchpadsize>=(size<<5)){
 313                         newsize=_scratchpadsize>>1;
 314                         _scratchpad=(SQChar *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
 315                         _scratchpadsize=newsize;
 316                 }
 317         }
 318         return _scratchpad;
 319 }
 320
 321 //////////////////////////////////////////////////////////////////////////
 322 //StringTable
 323 /*
 324 * The following code is based on Lua 4.0 (Copyright 1994-2002 Tecgraf, PUC-Rio.)
 325 * http://www.lua.org/copyright.html#4
 326 * http://www.lua.org/source/4.0.1/src_lstring.c.html
 327 */
 328
 329 int SQString::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval)
 330 {
 331         int idx = (int)TranslateIndex(refpos);
 332         while(idx < _len){
 333                 outkey = (SQInteger)idx;
 334                 outval = SQInteger(_val[idx]);
 335                 //return idx for the next iteration
 336                 return ++idx;
 337         }
 338         //nothing to iterate anymore
 339         return -1;
 340 }
 341
 342 StringTable::StringTable()
 343 {
 344         AllocNodes(4);
 345         _slotused = 0;
 346 }
 347
 348 StringTable::~StringTable()
 349 {
 350         SQ_FREE(_strings,sizeof(SQString*)*_numofslots);
 351         _strings=NULL;
 352 }
 353
 354 void StringTable::AllocNodes(int size)
 355 {
 356         _numofslots=size;
 357         //_slotused=0;
 358         _strings=(SQString**)SQ_MALLOC(sizeof(SQString*)*_numofslots);
 359         memset(_strings,0,sizeof(SQString*)*_numofslots);
 360 }
 361
 362 SQString *StringTable::Add(const SQChar *news,int len)
 363 {
 364         if(len<0)
 365                 len=scstrlen(news);
 366         unsigned int h=::_hashstr(news,len)&(_numofslots-1);
 367         SQString *s;
 368         for (s = _strings[h]; s; s = s->_next){
 369                 if(s->_len == len && (!memcmp(news,s->_val,rsl(len))))
 370                         return s; //found
 371         }
 372
 373         SQString *t=(SQString *)SQ_MALLOC(rsl(len)+sizeof(SQString));
 374         new (t) SQString;
 375         memcpy(t->_val,news,rsl(len));
 376         t->_val[len]=_SC('\0');
 377         t->_len=len;
 378         t->_hash=::_hashstr(news,len);
 379         t->_next=_strings[h];
 380         t->_uiRef=0;
 381         _strings[h]=t;
 382         _slotused++;
 383         if (_slotused > _numofslots)  /* too crowded? */
 384                 Resize(_numofslots*2);
 385         return t;
 386 }
 387
 388 void StringTable::Resize(int size)
 389 {
 390         int oldsize=_numofslots;
 391         SQString **oldtable=_strings;
 392         AllocNodes(size);
 393         for (int i=0; i<oldsize; i++){
 394                 SQString *p = oldtable[i];
 395                 while(p){
 396                         SQString *next = p->_next;
 397                         unsigned int h=p->_hash&(_numofslots-1);
 398                         p->_next=_strings[h];
 399                         _strings[h] = p;
 400                         p=next;
 401                 }
 402         }
 403         SQ_FREE(oldtable,oldsize*sizeof(SQString*));
 404 }
 405
 406 void StringTable::Remove(SQString *bs)
 407 {
 408         SQString *s;
 409         SQString *prev=NULL;
 410         unsigned int h=bs->_hash&(_numofslots-1);
 411
 412         for (s = _strings[h]; s; ){
 413                 if(s == bs){
 414                         if(prev)
 415                                 prev->_next = s->_next;
 416                         else
 417                                 _strings[h] = s->_next;
 418                         _slotused--;
 419                         int slen=s->_len;
 420                         s->~SQString();
 421                         SQ_FREE(s,sizeof(SQString)+rsl(slen));
 422                         return;
 423                 }
 424                 prev = s;
 425                 s = s->_next;
 426         }
 427         assert(0);//if this fail something is wrong
 428 }