2 see copyright notice in squirrel.h
4 #include "sqpcheader.h"
7 #include "sqfuncproto.h"
12 #include "squserdata.h"
16 SQObjectPtr _true_(true);
17 SQObjectPtr _false_(false);
19 SQObjectPtr _minusone_(-1);
21 SQSharedState::SQSharedState()
23 _compilererrorhandler = NULL;
28 #define newsysstring(s) { \
29 _systemstrings->push_back(SQString::Create(this,s)); \
32 #define newmetamethod(s) { \
33 _metamethods->push_back(SQString::Create(this,s)); \
34 _table(_metamethodsmap)->NewSlot(_metamethods->back(),(SQInteger)(_metamethods->size()-1)); \
37 bool CompileTypemask(SQIntVec &res,const SQChar *typemask)
42 while(typemask[i] != 0) {
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
65 if(typemask[i] == '|') {
78 SQTable *CreateDefaultDelegate(SQSharedState *ss,SQRegFunction *funcz)
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))
88 t->NewSlot(SQString::Create(ss,funcz[i].name),nc);
94 void SQSharedState::Init()
98 #ifndef NO_GARBAGE_COLLECTOR
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
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"));
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);
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);
155 SQSharedState::~SQSharedState()
157 _constructoridx = _null_;
158 _table(_refs_table)->Finalize();
159 _table(_registry)->Finalize();
160 _table(_metamethodsmap)->Finalize();
161 _refs_table = _null_;
163 _metamethodsmap = _null_;
164 while(!_systemstrings->empty()){
165 _systemstrings->back()=_null_;
166 _systemstrings->pop_back();
168 _thread(_root_vm)->Finalize();
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_;
180 #ifndef NO_GARBAGE_COLLECTOR
183 SQCollectable *t=_gc_chain;
184 SQCollectable *nx=NULL;
193 assert(_gc_chain==NULL); //just to proove a theory
196 _gc_chain->Release();
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);
207 SQInteger SQSharedState::GetMetaMethodIdxByName(const SQObjectPtr &name)
209 if(type(name) != OT_STRING)
212 if(_table(_metamethodsmap)->Get(name,ret)) {
213 return _integer(ret);
218 #ifndef NO_GARBAGE_COLLECTOR
220 void SQSharedState::MarkObject(SQObjectPtr &o,SQCollectable **chain)
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;
237 int SQSharedState::CollectGarbage(SQVM *vm)
241 SQCollectable *tchain=NULL;
242 SQVM *vms=_thread(_root_vm);
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);
259 SQCollectable *t=_gc_chain;
260 SQCollectable *nx=NULL;
277 int z = _table(_thread(_root_vm)->_roottable)->CountUsed();
283 #ifndef NO_GARBAGE_COLLECTOR
284 void SQCollectable::AddToChain(SQCollectable **chain,SQCollectable *c)
288 if(*chain) (*chain)->_prev=c;
292 void SQCollectable::RemoveFromChain(SQCollectable **chain,SQCollectable *c)
294 if(c->_prev) c->_prev->_next=c->_next;
295 else *chain=c->_next;
297 c->_next->_prev=c->_prev;
303 SQChar* SQSharedState::GetScratchPad(int size)
307 if(_scratchpadsize<size){
308 newsize=size+(size>>1);
309 _scratchpad=(SQChar *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
310 _scratchpadsize=newsize;
312 }else if(_scratchpadsize>=(size<<5)){
313 newsize=_scratchpadsize>>1;
314 _scratchpad=(SQChar *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
315 _scratchpadsize=newsize;
321 //////////////////////////////////////////////////////////////////////////
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
329 int SQString::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval)
331 int idx = (int)TranslateIndex(refpos);
333 outkey = (SQInteger)idx;
334 outval = SQInteger(_val[idx]);
335 //return idx for the next iteration
338 //nothing to iterate anymore
342 StringTable::StringTable()
348 StringTable::~StringTable()
350 SQ_FREE(_strings,sizeof(SQString*)*_numofslots);
354 void StringTable::AllocNodes(int size)
358 _strings=(SQString**)SQ_MALLOC(sizeof(SQString*)*_numofslots);
359 memset(_strings,0,sizeof(SQString*)*_numofslots);
362 SQString *StringTable::Add(const SQChar *news,int len)
366 unsigned int h=::_hashstr(news,len)&(_numofslots-1);
368 for (s = _strings[h]; s; s = s->_next){
369 if(s->_len == len && (!memcmp(news,s->_val,rsl(len))))
373 SQString *t=(SQString *)SQ_MALLOC(rsl(len)+sizeof(SQString));
375 memcpy(t->_val,news,rsl(len));
376 t->_val[len]=_SC('\0');
378 t->_hash=::_hashstr(news,len);
379 t->_next=_strings[h];
383 if (_slotused > _numofslots) /* too crowded? */
384 Resize(_numofslots*2);
388 void StringTable::Resize(int size)
390 int oldsize=_numofslots;
391 SQString **oldtable=_strings;
393 for (int i=0; i<oldsize; i++){
394 SQString *p = oldtable[i];
396 SQString *next = p->_next;
397 unsigned int h=p->_hash&(_numofslots-1);
398 p->_next=_strings[h];
403 SQ_FREE(oldtable,oldsize*sizeof(SQString*));
406 void StringTable::Remove(SQString *bs)
410 unsigned int h=bs->_hash&(_numofslots-1);
412 for (s = _strings[h]; s; ){
415 prev->_next = s->_next;
417 _strings[h] = s->_next;
421 SQ_FREE(s,sizeof(SQString)+rsl(slen));
427 assert(0);//if this fail something is wrong