diff --git a/cmdLine/rabbit.cpp b/cmdLine/rabbit.cpp index 2d6d952..fe94aa1 100644 --- a/cmdLine/rabbit.cpp +++ b/cmdLine/rabbit.cpp @@ -318,7 +318,7 @@ int main(int argc, char* argv[]) HRABBITVM v; int64_t retval = 0; #if defined(_MSC_VER) && defined(_DEBUG) - _CrtSetAllocHook(MemAllocHook); + _CrtsetAllocHook(MemAllocHook); #endif v=sq_open(1024); diff --git a/doc/source/conf.py b/doc/source/conf.py index 144f10e..d673b79 100644 --- a/doc/source/conf.py +++ b/doc/source/conf.py @@ -173,7 +173,7 @@ html_static_path = ['_static'] # If true, links to the reST sources are added to the pages. #html_show_sourcelink = True -# If true, "Created using Sphinx" is shown in the HTML footer. Default is True. +# If true, "created using Sphinx" is shown in the HTML footer. Default is True. #html_show_sphinx = True # If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. @@ -285,5 +285,5 @@ texinfo_documents = [ # How to display URL addresses: 'footnote', 'no', or 'inline'. #texinfo_show_urls = 'footnote' -# If true, do not generate a @detailmenu in the "Top" node's menu. +# If true, do not generate a @detailmenu in the "top" node's menu. #texinfo_no_detailmenu = False diff --git a/lutin_rabbit-core.py b/lutin_rabbit-core.py index 06164a1..136277e 100644 --- a/lutin_rabbit-core.py +++ b/lutin_rabbit-core.py @@ -39,6 +39,8 @@ def configure(target, my_module): 'rabbit/sqcompiler.cpp', 'rabbit/sqdebug.cpp', 'rabbit/sqfuncstate.cpp', + 'rabbit/RefCounted.cpp', + 'rabbit/WeakRef.cpp', ]) my_module.compile_version("c++", 2011) my_module.add_depend([ @@ -60,12 +62,14 @@ def configure(target, my_module): 'rabbit/sqfuncproto.hpp', 'rabbit/sqconfig.hpp', 'rabbit/sqcompiler.hpp', - 'rabbit/sqarray.hpp', + 'rabbit/Array.hpp', 'rabbit/sqclosure.hpp', 'rabbit/sqlexer.hpp', 'rabbit/sqfuncstate.hpp', 'rabbit/sqstring.hpp', 'rabbit/sqtable.hpp', + 'rabbit/RefCounted.hpp', + 'rabbit/WeakRef.hpp', ]) return True diff --git a/rabbit-std/sqstdblob.cpp b/rabbit-std/sqstdblob.cpp index c78f305..51c61f0 100644 --- a/rabbit-std/sqstdblob.cpp +++ b/rabbit-std/sqstdblob.cpp @@ -25,7 +25,7 @@ static int64_t _blob_resize(HRABBITVM v) SETUP_BLOB(v); int64_t size; sq_getinteger(v,2,&size); - if(!self->Resize(size)) + if(!self->resize(size)) return sq_throwerror(v,_SC("resize failed")); return 0; } @@ -47,7 +47,7 @@ static int64_t _blob_swap4(HRABBITVM v) { SETUP_BLOB(v); int64_t num=(self->Len()-(self->Len()%4))>>2; - unsigned int *t=(unsigned int *)self->GetBuf(); + unsigned int *t=(unsigned int *)self->getBuf(); for(int64_t i = 0; i < num; i++) { __swap_dword(&t[i]); } @@ -58,7 +58,7 @@ static int64_t _blob_swap2(HRABBITVM v) { SETUP_BLOB(v); int64_t num=(self->Len()-(self->Len()%2))>>1; - unsigned short *t = (unsigned short *)self->GetBuf(); + unsigned short *t = (unsigned short *)self->getBuf(); for(int64_t i = 0; i < num; i++) { __swap_word(&t[i]); } @@ -73,7 +73,7 @@ static int64_t _blob__set(HRABBITVM v) sq_getinteger(v,3,&val); if(idx < 0 || idx >= self->Len()) return sq_throwerror(v,_SC("index out of range")); - ((unsigned char *)self->GetBuf())[idx] = (unsigned char) val; + ((unsigned char *)self->getBuf())[idx] = (unsigned char) val; sq_push(v,3); return 1; } @@ -91,7 +91,7 @@ static int64_t _blob__get(HRABBITVM v) sq_getinteger(v,2,&idx); if(idx < 0 || idx >= self->Len()) return sq_throwerror(v,_SC("index out of range")); - sq_pushinteger(v,((unsigned char *)self->GetBuf())[idx]); + sq_pushinteger(v,((unsigned char *)self->getBuf())[idx]); return 1; } @@ -157,7 +157,7 @@ static int64_t _blob__cloned(HRABBITVM v) } //SQBlob *thisone = new SQBlob(other->Len()); SQBlob *thisone = new (sq_malloc(sizeof(SQBlob)))SQBlob(other->Len()); - memcpy(thisone->GetBuf(),other->GetBuf(),thisone->Len()); + memcpy(thisone->getBuf(),other->getBuf(),thisone->Len()); if(SQ_FAILED(sq_setinstanceup(v,1,thisone))) { thisone->~SQBlob(); sq_free(thisone,sizeof(SQBlob)); @@ -244,7 +244,7 @@ SQRESULT sqstd_getblob(HRABBITVM v,int64_t idx,SQUserPointer *ptr) SQBlob *blob; if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) return -1; - *ptr = blob->GetBuf(); + *ptr = blob->getBuf(); return SQ_OK; } @@ -269,7 +269,7 @@ SQUserPointer sqstd_createblob(HRABBITVM v, int64_t size) if(SQ_SUCCEEDED(sq_call(v,2,SQTrue,SQFalse)) && SQ_SUCCEEDED(sq_getinstanceup(v,-1,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) { sq_remove(v,-2); - return blob->GetBuf(); + return blob->getBuf(); } } sq_settop(v,top); diff --git a/rabbit-std/sqstdblobimpl.hpp b/rabbit-std/sqstdblobimpl.hpp index e82637a..ddacd11 100644 --- a/rabbit-std/sqstdblobimpl.hpp +++ b/rabbit-std/sqstdblobimpl.hpp @@ -39,7 +39,7 @@ struct SQBlob : public SQStream _ptr += n; return n; } - bool Resize(int64_t n) { + bool resize(int64_t n) { if(!_owns) return false; if(n != _allocated) { unsigned char *newbuf = (unsigned char *)sq_malloc(n); @@ -63,9 +63,9 @@ struct SQBlob : public SQStream bool ret = true; if(_size + n > _allocated) { if(_size + n > _size * 2) - ret = Resize(_size + n); + ret = resize(_size + n); else - ret = Resize(_size * 2); + ret = resize(_size * 2); } _size = _size + n; return ret; @@ -101,7 +101,7 @@ struct SQBlob : public SQStream int64_t Flush() { return 0; } int64_t Tell() { return _ptr; } int64_t Len() { return _size; } - SQUserPointer GetBuf(){ return _buf; } + SQUserPointer getBuf(){ return _buf; } private: int64_t _size; int64_t _allocated; diff --git a/rabbit-std/sqstdio.cpp b/rabbit-std/sqstdio.cpp index b2098c4..df032bb 100644 --- a/rabbit-std/sqstdio.cpp +++ b/rabbit-std/sqstdio.cpp @@ -110,7 +110,7 @@ struct SQFile : public SQStream { } bool IsValid() { return _handle?true:false; } bool EOS() { return Tell()==Len()?true:false;} - SQFILE GetHandle() {return _handle;} + SQFILE getHandle() {return _handle;} private: SQFILE _handle; bool _owns; @@ -208,7 +208,7 @@ SQRESULT sqstd_getfile(HRABBITVM v, int64_t idx, SQFILE *file) { SQFile *fileobj = NULL; if(SQ_SUCCEEDED(sq_getinstanceup(v,idx,(SQUserPointer*)&fileobj,(SQUserPointer)SQSTD_FILE_TYPE_TAG))) { - *file = fileobj->GetHandle(); + *file = fileobj->getHandle(); return SQ_OK; } return sq_throwerror(v,_SC("not a file")); diff --git a/rabbit/Array.cpp b/rabbit/Array.cpp new file mode 100644 index 0000000..06f832e --- /dev/null +++ b/rabbit/Array.cpp @@ -0,0 +1,20 @@ +/** + * @author Alberto DEMICHELIS + * @author Edouard DUPIN + * @copyright 2018, Edouard DUPIN, all right reserved + * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved + * @license MPL-2 (see license file) + */ +#include + + + +void rabbit::Array::extend(const rabbit::Array *a){ + int64_t xlen = a->size(); + // TODO: check this condition... + if(xlen) { + for(int64_t iii=0;iii= 0 + && _nidx < (int64_t)m_data.size()){ + SQObjectPtr &o = m_data[_nidx]; + _val = _realval(o); + return true; + } + return false; + } + bool set(const int64_t _nidx,const SQObjectPtr& _val) { + if(_nidx>=0 && _nidx<(int64_t)m_data.size()){ + m_data[_nidx] = _val; + return true; + } + return false; + } + int64_t next(const SQObjectPtr& _refpos, + SQObjectPtr& _outkey, + SQObjectPtr& _outval) { + uint64_t idx=translateIndex(_refpos); + while(idxm_data.copy(m_data); + return anew; + } + int64_t size() const { + return m_data.size(); + } + void resize(int64_t _size) { + SQObjectPtr empty; + resize(_size, empty); + } + void resize(int64_t _size, + SQObjectPtr& _fill) { + m_data.resize(_size, _fill); + shrinkIfNeeded(); + } + void reserve(int64_t _size) { + m_data.reserve(_size); + } + void append(const SQObject& _o) { + m_data.push_back(_o); + } + void extend(const Array* _a); + SQObjectPtr &top(){ + return m_data.top(); + } + void pop() { + m_data.pop_back(); + shrinkIfNeeded(); + } + bool insert(int64_t _idx,const SQObject& _val) { + if( _idx < 0 + || _idx > (int64_t)m_data.size()) { + return false; + } + m_data.insert(_idx, _val); + return true; + } + void shrinkIfNeeded() { + if(m_data.size() <= m_data.capacity()>>2) { + //shrink the array + m_data.shrinktofit(); + } + } + bool remove(int64_t _idx) { + if( _idx < 0 + || _idx >= (int64_t)m_data.size()) { + return false; + } + m_data.remove(_idx); + shrinkIfNeeded(); + return true; + } + void release() { + sq_delete(this, Array); + } + SQObjectPtr& operator[] (const size_t _pos) { + return m_data[_pos]; + } + const SQObjectPtr& operator[] (const size_t _pos) const { + return m_data[_pos]; + } + private: + SQObjectPtrVec m_data; + }; +} + diff --git a/rabbit/RefCounted.cpp b/rabbit/RefCounted.cpp new file mode 100644 index 0000000..4cd05e3 --- /dev/null +++ b/rabbit/RefCounted.cpp @@ -0,0 +1,44 @@ +/** + * @author Alberto DEMICHELIS + * @author Edouard DUPIN + * @copyright 2018, Edouard DUPIN, all right reserved + * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved + * @license MPL-2 (see license file) + */ + +#include +#include +#include +#include +#include + +rabbit::WeakRef * rabbit::RefCounted::getWeakRef(SQObjectType type) { + if(!_weakref) { + sq_new(_weakref, WeakRef); +#if defined(SQUSEDOUBLE) && !defined(_SQ64) + _weakref->_obj._unVal.raw = 0; //clean the whole union on 32 bits with double +#endif + _weakref->_obj._type = type; + _weakref->_obj._unVal.pRefCounted = this; + } + return _weakref; +} + +rabbit::RefCounted::~RefCounted() { + if(_weakref) { + _weakref->_obj._type = OT_NULL; + _weakref->_obj._unVal.pRefCounted = NULL; + } +} + +void rabbit::RefCounted::refCountIncrement() { + _uiRef++; +} + +int64_t rabbit::RefCounted::refCountDecrement() { + return --_uiRef; +} + +int64_t rabbit::RefCounted::refCountget() { + return _uiRef; +} diff --git a/rabbit/RefCounted.hpp b/rabbit/RefCounted.hpp new file mode 100644 index 0000000..1b8550c --- /dev/null +++ b/rabbit/RefCounted.hpp @@ -0,0 +1,30 @@ +/** + * @author Alberto DEMICHELIS + * @author Edouard DUPIN + * @copyright 2018, Edouard DUPIN, all right reserved + * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved + * @license MPL-2 (see license file) + */ +#pragma once + +#include +#include + +namespace rabbit { + class WeakRef; + class RefCounted { + protected: + int64_t _uiRef = 0; + struct WeakRef *_weakref = null; + public: + RefCounted() {} + virtual ~RefCounted(); + WeakRef *getWeakRef(SQObjectType _type); + virtual void release() = 0; + void refCountIncrement(); + int64_t refCountDecrement(); + int64_t refCountget(); + friend WeakRef; + }; +} + diff --git a/rabbit/UserData.hpp b/rabbit/UserData.hpp index 890d43e..7d26e3c 100644 --- a/rabbit/UserData.hpp +++ b/rabbit/UserData.hpp @@ -15,16 +15,16 @@ namespace rabbit { m_hook = NULL; } ~UserData() { - SetDelegate(NULL); + setDelegate(NULL); } - static UserData* Create(SQSharedState *ss, int64_t size) { + static UserData* create(SQSharedState *ss, int64_t size) { UserData* ud = (UserData*)SQ_MALLOC(sq_aligning(sizeof(UserData))+size); new (ud) UserData(ss); ud->m_size = size; ud->m_typetag = 0; return ud; } - void Release() { + void release() { if (m_hook) { m_hook((SQUserPointer)sq_aligning(this + 1),m_size); } @@ -32,7 +32,7 @@ namespace rabbit { this->~UserData(); SQ_FREE(this, sq_aligning(sizeof(UserData)) + tsize); } - const int64_t& getSize() const { + const int64_t& getsize() const { return m_size; } const SQUserPointer& getTypeTag() const { diff --git a/rabbit/WeakRef.cpp b/rabbit/WeakRef.cpp new file mode 100644 index 0000000..c158bb6 --- /dev/null +++ b/rabbit/WeakRef.cpp @@ -0,0 +1,19 @@ +/** + * @author Alberto DEMICHELIS + * @author Edouard DUPIN + * @copyright 2018, Edouard DUPIN, all right reserved + * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved + * @license MPL-2 (see license file) + */ + +#include +#include +#include +#include + +void rabbit::WeakRef::release() { + if(ISREFCOUNTED(_obj._type)) { + _obj._unVal.pRefCounted->_weakref = null; + } + sq_delete(this, WeakRef); +} diff --git a/rabbit/WeakRef.hpp b/rabbit/WeakRef.hpp new file mode 100644 index 0000000..b576f55 --- /dev/null +++ b/rabbit/WeakRef.hpp @@ -0,0 +1,23 @@ +/** + * @author Alberto DEMICHELIS + * @author Edouard DUPIN + * @copyright 2018, Edouard DUPIN, all right reserved + * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved + * @license MPL-2 (see license file) + */ +#pragma once + +#include +#include + +namespace rabbit { + class WeakRef: public RefCounted { + public: + void release(); + public: + SQObject _obj; + protected: + friend RefCounted; + }; +} + diff --git a/rabbit/rabbit.hpp b/rabbit/rabbit.hpp index b264dcc..86e1830 100644 --- a/rabbit/rabbit.hpp +++ b/rabbit/rabbit.hpp @@ -27,19 +27,20 @@ struct SQVM; struct SQTable; -struct SQArray; struct SQString; struct SQClosure; struct SQGenerator; struct SQNativeClosure; struct SQFunctionProto; -struct SQRefCounted; struct SQClass; struct SQInstance; struct SQDelegable; struct SQOuter; namespace rabbit { class UserData; + class Array; + class RefCounted; + class WeakRef; } #ifdef _UNICODE @@ -116,7 +117,7 @@ typedef enum tagSQObjectType{ typedef union tagSQObjectValue { struct SQTable *pTable; - struct SQArray *pArray; + struct rabbit::Array *pArray; struct SQClosure *pClosure; struct SQOuter *pOuter; struct SQGenerator *pGenerator; @@ -127,12 +128,12 @@ typedef union tagSQObjectValue float_t fFloat; SQUserPointer pUserPointer; struct SQFunctionProto *pFunctionProto; - struct SQRefCounted *pRefCounted; + struct rabbit::RefCounted *pRefCounted; struct SQDelegable *pDelegable; struct SQVM *pThread; struct SQClass *pClass; struct SQInstance *pInstance; - struct SQWeakRef *pWeakRef; + struct rabbit::WeakRef *pWeakRef; SQRawObjectVal raw; }SQObjectValue; diff --git a/rabbit/sqapi.cpp b/rabbit/sqapi.cpp index 8b9ee2e..795f6af 100644 --- a/rabbit/sqapi.cpp +++ b/rabbit/sqapi.cpp @@ -9,7 +9,7 @@ #include #include #include -#include +#include #include #include #include @@ -39,8 +39,8 @@ static bool sq_aux_gettypedarg(HRABBITVM v,int64_t idx,SQObjectType type,SQObjec int64_t sq_aux_invalidtype(HRABBITVM v,SQObjectType type) { uint64_t buf_size = 100 *sizeof(SQChar); - scsprintf(_ss(v)->GetScratchPad(buf_size), buf_size, _SC("unexpected type %s"), IdType2Name(type)); - return sq_throwerror(v, _ss(v)->GetScratchPad(-1)); + scsprintf(_ss(v)->getScratchPad(buf_size), buf_size, _SC("unexpected type %s"), IdType2Name(type)); + return sq_throwerror(v, _ss(v)->getScratchPad(-1)); } HRABBITVM sq_open(int64_t initialstacksize) @@ -133,7 +133,7 @@ SQRESULT sq_compile(HRABBITVM v,SQLEXREADFUNC read,SQUserPointer p,const SQChar SQObjectPtr o; #ifndef NO_COMPILER if(Compile(v, read, p, sourcename, o, raiseerror?true:false, _ss(v)->_debuginfo)) { - v->Push(SQClosure::Create(_ss(v), _funcproto(o), _table(v->_roottable)->GetWeakRef(OT_TABLE))); + v->Push(SQClosure::create(_ss(v), _funcproto(o), _table(v->_roottable)->getWeakRef(OT_TABLE))); return SQ_OK; } return SQ_ERROR; @@ -161,21 +161,21 @@ void sq_addref(HRABBITVM v,HSQOBJECT *po) uint64_t sq_getrefcount(HRABBITVM v,HSQOBJECT *po) { if(!ISREFCOUNTED(sq_type(*po))) return 0; - return po->_unVal.pRefCounted->_uiRef; + return po->_unVal.pRefCounted->refCountget(); } SQBool sq_release(HRABBITVM v,HSQOBJECT *po) { if(!ISREFCOUNTED(sq_type(*po))) return SQTrue; - bool ret = (po->_unVal.pRefCounted->_uiRef <= 1) ? SQTrue : SQFalse; - __Release(po->_type,po->_unVal); + bool ret = (po->_unVal.pRefCounted->refCountget() <= 1) ? SQTrue : SQFalse; + __release(po->_type,po->_unVal); return ret; //the ret val doesn't work(and cannot be fixed) } uint64_t sq_getvmrefcount(HRABBITVM SQ_UNUSED_ARG(v), const HSQOBJECT *po) { if (!ISREFCOUNTED(sq_type(*po))) return 0; - return po->_unVal.pRefCounted->_uiRef; + return po->_unVal.pRefCounted->refCountget(); } const SQChar *sq_objtostring(const HSQOBJECT *o) @@ -226,7 +226,7 @@ void sq_pushnull(HRABBITVM v) void sq_pushstring(HRABBITVM v,const SQChar *s,int64_t len) { if(s) - v->Push(SQObjectPtr(SQString::Create(_ss(v), s, len))); + v->Push(SQObjectPtr(SQString::create(_ss(v), s, len))); else v->PushNull(); } @@ -257,24 +257,24 @@ void sq_pushthread(HRABBITVM v, HRABBITVM thread) SQUserPointer sq_newuserdata(HRABBITVM v,uint64_t size) { - rabbit::UserData *ud = rabbit::UserData::Create(_ss(v), size + SQ_ALIGNMENT); + rabbit::UserData *ud = rabbit::UserData::create(_ss(v), size + SQ_ALIGNMENT); v->Push(ud); return (SQUserPointer)sq_aligning(ud + 1); } void sq_newtable(HRABBITVM v) { - v->Push(SQTable::Create(_ss(v), 0)); + v->Push(SQTable::create(_ss(v), 0)); } void sq_newtableex(HRABBITVM v,int64_t initialcapacity) { - v->Push(SQTable::Create(_ss(v), initialcapacity)); + v->Push(SQTable::create(_ss(v), initialcapacity)); } void sq_newarray(HRABBITVM v,int64_t size) { - v->Push(SQArray::Create(_ss(v), size)); + v->Push(rabbit::Array::create(_ss(v), size)); } SQRESULT sq_newclass(HRABBITVM v,SQBool hasbase) @@ -286,7 +286,7 @@ SQRESULT sq_newclass(HRABBITVM v,SQBool hasbase) return sq_throwerror(v,_SC("invalid base type")); baseclass = _class(base); } - SQClass *newclass = SQClass::Create(_ss(v), baseclass); + SQClass *newclass = SQClass::create(_ss(v), baseclass); if(baseclass) v->Pop(); v->Push(newclass); return SQ_OK; @@ -306,7 +306,7 @@ SQRESULT sq_arrayappend(HRABBITVM v,int64_t idx) sq_aux_paramscheck(v,2); SQObjectPtr *arr; _GETSAFE_OBJ(v, idx, OT_ARRAY,arr); - _array(*arr)->Append(v->GetUp(-1)); + _array(*arr)->append(v->getUp(-1)); v->Pop(); return SQ_OK; } @@ -316,9 +316,11 @@ SQRESULT sq_arraypop(HRABBITVM v,int64_t idx,SQBool pushval) sq_aux_paramscheck(v, 1); SQObjectPtr *arr; _GETSAFE_OBJ(v, idx, OT_ARRAY,arr); - if(_array(*arr)->Size() > 0) { - if(pushval != 0){ v->Push(_array(*arr)->Top()); } - _array(*arr)->Pop(); + if(_array(*arr)->size() > 0) { + if(pushval != 0){ + v->Push(_array(*arr)->top()); + } + _array(*arr)->pop(); return SQ_OK; } return sq_throwerror(v, _SC("empty array")); @@ -330,7 +332,7 @@ SQRESULT sq_arrayresize(HRABBITVM v,int64_t idx,int64_t newsize) SQObjectPtr *arr; _GETSAFE_OBJ(v, idx, OT_ARRAY,arr); if(newsize >= 0) { - _array(*arr)->Resize(newsize); + _array(*arr)->resize(newsize); return SQ_OK; } return sq_throwerror(v,_SC("negative size")); @@ -342,15 +344,16 @@ SQRESULT sq_arrayreverse(HRABBITVM v,int64_t idx) sq_aux_paramscheck(v, 1); SQObjectPtr *o; _GETSAFE_OBJ(v, idx, OT_ARRAY,o); - SQArray *arr = _array(*o); - if(arr->Size() > 0) { + rabbit::Array *arr = _array(*o); + if(arr->size() > 0) { SQObjectPtr t; - int64_t size = arr->Size(); + int64_t size = arr->size(); int64_t n = size >> 1; size -= 1; for(int64_t i = 0; i < n; i++) { - t = arr->_values[i]; - arr->_values[i] = arr->_values[size-i]; - arr->_values[size-i] = t; + // TODO: set a swap + t = (*arr)[i]; + (*arr)[i] = (*arr)[size-i]; + (*arr)[size-i] = t; } return SQ_OK; } @@ -362,7 +365,7 @@ SQRESULT sq_arrayremove(HRABBITVM v,int64_t idx,int64_t itemidx) sq_aux_paramscheck(v, 1); SQObjectPtr *arr; _GETSAFE_OBJ(v, idx, OT_ARRAY,arr); - return _array(*arr)->Remove(itemidx) ? SQ_OK : sq_throwerror(v,_SC("index out of range")); + return _array(*arr)->remove(itemidx) ? SQ_OK : sq_throwerror(v,_SC("index out of range")); } SQRESULT sq_arrayinsert(HRABBITVM v,int64_t idx,int64_t destpos) @@ -370,17 +373,17 @@ SQRESULT sq_arrayinsert(HRABBITVM v,int64_t idx,int64_t destpos) sq_aux_paramscheck(v, 1); SQObjectPtr *arr; _GETSAFE_OBJ(v, idx, OT_ARRAY,arr); - SQRESULT ret = _array(*arr)->Insert(destpos, v->GetUp(-1)) ? SQ_OK : sq_throwerror(v,_SC("index out of range")); + SQRESULT ret = _array(*arr)->insert(destpos, v->getUp(-1)) ? SQ_OK : sq_throwerror(v,_SC("index out of range")); v->Pop(); return ret; } void sq_newclosure(HRABBITVM v,SQFUNCTION func,uint64_t nfreevars) { - SQNativeClosure *nc = SQNativeClosure::Create(_ss(v), func,nfreevars); + SQNativeClosure *nc = SQNativeClosure::create(_ss(v), func,nfreevars); nc->_nparamscheck = 0; for(uint64_t i = 0; i < nfreevars; i++) { - nc->_outervalues[i] = v->Top(); + nc->_outervalues[i] = v->top(); v->Pop(); } v->Push(SQObjectPtr(nc)); @@ -411,7 +414,7 @@ SQRESULT sq_setnativeclosurename(HRABBITVM v,int64_t idx,const SQChar *name) SQObject o = stack_get(v, idx); if(sq_isnativeclosure(o)) { SQNativeClosure *nc = _nativeclosure(o); - nc->_name = SQString::Create(_ss(v),name); + nc->_name = SQString::create(_ss(v),name); return SQ_OK; } return sq_throwerror(v,_SC("the object is not a nativeclosure")); @@ -451,11 +454,11 @@ SQRESULT sq_bindenv(HRABBITVM v,int64_t idx) !sq_isclass(env) && !sq_isinstance(env)) return sq_throwerror(v,_SC("invalid environment")); - SQWeakRef *w = _refcounted(env)->GetWeakRef(sq_type(env)); + rabbit::WeakRef *w = _refcounted(env)->getWeakRef(sq_type(env)); SQObjectPtr ret; if(sq_isclosure(o)) { - SQClosure *c = _closure(o)->Clone(); - __ObjRelease(c->_env); + SQClosure *c = _closure(o)->clone(); + __Objrelease(c->_env); c->_env = w; __ObjAddRef(c->_env); if(_closure(o)->_base) { @@ -465,8 +468,8 @@ SQRESULT sq_bindenv(HRABBITVM v,int64_t idx) ret = c; } else { //then must be a native closure - SQNativeClosure *c = _nativeclosure(o)->Clone(); - __ObjRelease(c->_env); + SQNativeClosure *c = _nativeclosure(o)->clone(); + __Objrelease(c->_env); c->_env = w; __ObjAddRef(c->_env); ret = c; @@ -498,7 +501,7 @@ SQRESULT sq_setclosureroot(HRABBITVM v,int64_t idx) SQObject o = stack_get(v, -1); if(!sq_isclosure(c)) return sq_throwerror(v, _SC("closure expected")); if(sq_istable(o)) { - _closure(c)->SetRoot(_table(o)->GetWeakRef(OT_TABLE)); + _closure(c)->setRoot(_table(o)->getWeakRef(OT_TABLE)); v->Pop(); return SQ_OK; } @@ -518,7 +521,7 @@ SQRESULT sq_clear(HRABBITVM v,int64_t idx) SQObject &o=stack_get(v,idx); switch(sq_type(o)) { case OT_TABLE: _table(o)->Clear(); break; - case OT_ARRAY: _array(o)->Resize(0); break; + case OT_ARRAY: _array(o)->resize(0); break; default: return sq_throwerror(v, _SC("clear only works on table and array")); break; @@ -705,7 +708,7 @@ SQRESULT sq_clone(HRABBITVM v,int64_t idx) { SQObjectPtr &o = stack_get(v,idx); v->PushNull(); - if(!v->Clone(o, stack_get(v, -1))){ + if(!v->clone(o, stack_get(v, -1))){ v->Pop(); return SQ_ERROR; } @@ -719,8 +722,8 @@ int64_t sq_getsize(HRABBITVM v, int64_t idx) switch(type) { case OT_STRING: return _string(o)->_len; case OT_TABLE: return _table(o)->CountUsed(); - case OT_ARRAY: return _array(o)->Size(); - case OT_USERDATA: return _userdata(o)->getSize(); + case OT_ARRAY: return _array(o)->size(); + case OT_USERDATA: return _userdata(o)->getsize(); case OT_INSTANCE: return _instance(o)->_class->_udsize; case OT_CLASS: return _class(o)->_udsize; default: @@ -852,7 +855,7 @@ void sq_poptop(HRABBITVM v) void sq_remove(HRABBITVM v, int64_t idx) { - v->Remove(idx); + v->remove(idx); } int64_t sq_cmp(HRABBITVM v) @@ -867,9 +870,9 @@ SQRESULT sq_newslot(HRABBITVM v, int64_t idx, SQBool bstatic) sq_aux_paramscheck(v, 3); SQObjectPtr &self = stack_get(v, idx); if(sq_type(self) == OT_TABLE || sq_type(self) == OT_CLASS) { - SQObjectPtr &key = v->GetUp(-2); + SQObjectPtr &key = v->getUp(-2); if(sq_type(key) == OT_NULL) return sq_throwerror(v, _SC("null is not a valid key")); - v->NewSlot(self, key, v->GetUp(-1),bstatic?true:false); + v->NewSlot(self, key, v->getUp(-1),bstatic?true:false); v->Pop(2); } return SQ_OK; @@ -880,14 +883,14 @@ SQRESULT sq_deleteslot(HRABBITVM v,int64_t idx,SQBool pushval) sq_aux_paramscheck(v, 2); SQObjectPtr *self; _GETSAFE_OBJ(v, idx, OT_TABLE,self); - SQObjectPtr &key = v->GetUp(-1); + SQObjectPtr &key = v->getUp(-1); if(sq_type(key) == OT_NULL) return sq_throwerror(v, _SC("null is not a valid key")); SQObjectPtr res; if(!v->DeleteSlot(*self, key, res)){ v->Pop(); return SQ_ERROR; } - if(pushval) v->GetUp(-1) = res; + if(pushval) v->getUp(-1) = res; else v->Pop(); return SQ_OK; } @@ -895,7 +898,7 @@ SQRESULT sq_deleteslot(HRABBITVM v,int64_t idx,SQBool pushval) SQRESULT sq_set(HRABBITVM v,int64_t idx) { SQObjectPtr &self = stack_get(v, idx); - if(v->Set(self, v->GetUp(-2), v->GetUp(-1),DONT_FALL_BACK)) { + if(v->set(self, v->getUp(-2), v->getUp(-1),DONT_FALL_BACK)) { v->Pop(2); return SQ_OK; } @@ -905,30 +908,30 @@ SQRESULT sq_set(HRABBITVM v,int64_t idx) SQRESULT sq_rawset(HRABBITVM v,int64_t idx) { SQObjectPtr &self = stack_get(v, idx); - SQObjectPtr &key = v->GetUp(-2); + SQObjectPtr &key = v->getUp(-2); if(sq_type(key) == OT_NULL) { v->Pop(2); return sq_throwerror(v, _SC("null key")); } switch(sq_type(self)) { case OT_TABLE: - _table(self)->NewSlot(key, v->GetUp(-1)); + _table(self)->NewSlot(key, v->getUp(-1)); v->Pop(2); return SQ_OK; break; case OT_CLASS: - _class(self)->NewSlot(_ss(v), key, v->GetUp(-1),false); + _class(self)->NewSlot(_ss(v), key, v->getUp(-1),false); v->Pop(2); return SQ_OK; break; case OT_INSTANCE: - if(_instance(self)->Set(key, v->GetUp(-1))) { + if(_instance(self)->set(key, v->getUp(-1))) { v->Pop(2); return SQ_OK; } break; case OT_ARRAY: - if(v->Set(self, key, v->GetUp(-1),false)) { + if(v->set(self, key, v->getUp(-1),false)) { v->Pop(2); return SQ_OK; } @@ -937,16 +940,16 @@ SQRESULT sq_rawset(HRABBITVM v,int64_t idx) v->Pop(2); return sq_throwerror(v, _SC("rawset works only on array/table/class and instance")); } - v->Raise_IdxError(v->GetUp(-2));return SQ_ERROR; + v->Raise_IdxError(v->getUp(-2));return SQ_ERROR; } SQRESULT sq_newmember(HRABBITVM v,int64_t idx,SQBool bstatic) { SQObjectPtr &self = stack_get(v, idx); if(sq_type(self) != OT_CLASS) return sq_throwerror(v, _SC("new member only works with classes")); - SQObjectPtr &key = v->GetUp(-3); + SQObjectPtr &key = v->getUp(-3); if(sq_type(key) == OT_NULL) return sq_throwerror(v, _SC("null key")); - if(!v->NewSlotA(self,key,v->GetUp(-2),v->GetUp(-1),bstatic?true:false,false)) { + if(!v->NewSlotA(self,key,v->getUp(-2),v->getUp(-1),bstatic?true:false,false)) { v->Pop(3); return SQ_ERROR; } @@ -958,9 +961,9 @@ SQRESULT sq_rawnewmember(HRABBITVM v,int64_t idx,SQBool bstatic) { SQObjectPtr &self = stack_get(v, idx); if(sq_type(self) != OT_CLASS) return sq_throwerror(v, _SC("new member only works with classes")); - SQObjectPtr &key = v->GetUp(-3); + SQObjectPtr &key = v->getUp(-3); if(sq_type(key) == OT_NULL) return sq_throwerror(v, _SC("null key")); - if(!v->NewSlotA(self,key,v->GetUp(-2),v->GetUp(-1),bstatic?true:false,true)) { + if(!v->NewSlotA(self,key,v->getUp(-2),v->getUp(-1),bstatic?true:false,true)) { v->Pop(3); return SQ_ERROR; } @@ -971,25 +974,25 @@ SQRESULT sq_rawnewmember(HRABBITVM v,int64_t idx,SQBool bstatic) SQRESULT sq_setdelegate(HRABBITVM v,int64_t idx) { SQObjectPtr &self = stack_get(v, idx); - SQObjectPtr &mt = v->GetUp(-1); + SQObjectPtr &mt = v->getUp(-1); SQObjectType type = sq_type(self); switch(type) { case OT_TABLE: if(sq_type(mt) == OT_TABLE) { - if(!_table(self)->SetDelegate(_table(mt))) { + if(!_table(self)->setDelegate(_table(mt))) { return sq_throwerror(v, _SC("delagate cycle")); } v->Pop(); } else if(sq_type(mt)==OT_NULL) { - _table(self)->SetDelegate(NULL); v->Pop(); } + _table(self)->setDelegate(NULL); v->Pop(); } else return sq_aux_invalidtype(v,type); break; case OT_USERDATA: if(sq_type(mt)==OT_TABLE) { - _userdata(self)->SetDelegate(_table(mt)); v->Pop(); } + _userdata(self)->setDelegate(_table(mt)); v->Pop(); } else if(sq_type(mt)==OT_NULL) { - _userdata(self)->SetDelegate(NULL); v->Pop(); } + _userdata(self)->setDelegate(NULL); v->Pop(); } else return sq_aux_invalidtype(v, type); break; default: @@ -1004,13 +1007,13 @@ SQRESULT sq_rawdeleteslot(HRABBITVM v,int64_t idx,SQBool pushval) sq_aux_paramscheck(v, 2); SQObjectPtr *self; _GETSAFE_OBJ(v, idx, OT_TABLE,self); - SQObjectPtr &key = v->GetUp(-1); + SQObjectPtr &key = v->getUp(-1); SQObjectPtr t; - if(_table(*self)->Get(key,t)) { - _table(*self)->Remove(key); + if(_table(*self)->get(key,t)) { + _table(*self)->remove(key); } if(pushval != 0) - v->GetUp(-1) = t; + v->getUp(-1) = t; else v->Pop(); return SQ_OK; @@ -1037,8 +1040,8 @@ SQRESULT sq_getdelegate(HRABBITVM v,int64_t idx) SQRESULT sq_get(HRABBITVM v,int64_t idx) { SQObjectPtr &self=stack_get(v,idx); - SQObjectPtr &obj = v->GetUp(-1); - if(v->Get(self,obj,obj,false,DONT_FALL_BACK)) + SQObjectPtr &obj = v->getUp(-1); + if(v->get(self,obj,obj,false,DONT_FALL_BACK)) return SQ_OK; v->Pop(); return SQ_ERROR; @@ -1047,23 +1050,23 @@ SQRESULT sq_get(HRABBITVM v,int64_t idx) SQRESULT sq_rawget(HRABBITVM v,int64_t idx) { SQObjectPtr &self=stack_get(v,idx); - SQObjectPtr &obj = v->GetUp(-1); + SQObjectPtr &obj = v->getUp(-1); switch(sq_type(self)) { case OT_TABLE: - if(_table(self)->Get(obj,obj)) + if(_table(self)->get(obj,obj)) return SQ_OK; break; case OT_CLASS: - if(_class(self)->Get(obj,obj)) + if(_class(self)->get(obj,obj)) return SQ_OK; break; case OT_INSTANCE: - if(_instance(self)->Get(obj,obj)) + if(_instance(self)->get(obj,obj)) return SQ_OK; break; case OT_ARRAY:{ if(sq_isnumeric(obj)){ - if(_array(self)->Get(tointeger(obj),obj)) { + if(_array(self)->get(tointeger(obj),obj)) { return SQ_OK; } } @@ -1107,7 +1110,7 @@ const SQChar *sq_getlocal(HRABBITVM v,uint64_t level,uint64_t idx) return _stringval(func->_outervalues[idx]._name); } idx -= func->_noutervalues; - return func->GetLocal(v,stackbase,idx,(int64_t)(ci._ip-func->_instructions)-1); + return func->getLocal(v,stackbase,idx,(int64_t)(ci._ip-func->_instructions)-1); } return NULL; } @@ -1124,13 +1127,13 @@ void sq_resetobject(HSQOBJECT *po) SQRESULT sq_throwerror(HRABBITVM v,const SQChar *err) { - v->_lasterror=SQString::Create(_ss(v),err); + v->_lasterror=SQString::create(_ss(v),err); return SQ_ERROR; } SQRESULT sq_throwobject(HRABBITVM v) { - v->_lasterror = v->GetUp(-1); + v->_lasterror = v->getUp(-1); v->Pop(); return SQ_ERROR; } @@ -1159,10 +1162,10 @@ SQRESULT sq_reservestack(HRABBITVM v,int64_t nsize) SQRESULT sq_resume(HRABBITVM v,SQBool retval,SQBool raiseerror) { - if (sq_type(v->GetUp(-1)) == OT_GENERATOR) + if (sq_type(v->getUp(-1)) == OT_GENERATOR) { v->PushNull(); //retval - if (!v->Execute(v->GetUp(-2), 0, v->_top, v->GetUp(-1), raiseerror, SQVM::ET_RESUME_GENERATOR)) + if (!v->Execute(v->getUp(-2), 0, v->_top, v->getUp(-1), raiseerror, SQVM::ET_RESUME_GENERATOR)) {v->Raise_Error(v->_lasterror); return SQ_ERROR;} if(!retval) v->Pop(); @@ -1174,7 +1177,7 @@ SQRESULT sq_resume(HRABBITVM v,SQBool retval,SQBool raiseerror) SQRESULT sq_call(HRABBITVM v,int64_t params,SQBool retval,SQBool raiseerror) { SQObjectPtr res; - if(v->Call(v->GetUp(-(params+1)),params,v->_top-params,res,raiseerror?true:false)){ + if(v->Call(v->getUp(-(params+1)),params,v->_top-params,res,raiseerror?true:false)){ if(!v->_suspended) { v->Pop(params);//pop args @@ -1195,7 +1198,7 @@ SQRESULT sq_call(HRABBITVM v,int64_t params,SQBool retval,SQBool raiseerror) SQRESULT sq_tailcall(HRABBITVM v, int64_t nparams) { - SQObjectPtr &res = v->GetUp(-(nparams + 1)); + SQObjectPtr &res = v->getUp(-(nparams + 1)); if (sq_type(res) != OT_CLOSURE) { return sq_throwerror(v, _SC("only closure can be tail called")); } @@ -1225,10 +1228,10 @@ SQRESULT sq_wakeupvm(HRABBITVM v,SQBool wakeupret,SQBool retval,SQBool raiseerro int64_t target = v->_suspended_target; if(wakeupret) { if(target != -1) { - v->GetAt(v->_stackbase+v->_suspended_target)=v->GetUp(-1); //retval + v->getAt(v->_stackbase+v->_suspended_target)=v->getUp(-1); //retval } v->Pop(); - } else if(target != -1) { v->GetAt(v->_stackbase+v->_suspended_target).Null(); } + } else if(target != -1) { v->getAt(v->_stackbase+v->_suspended_target).Null(); } SQObjectPtr dummy; if(!v->Execute(dummy,-1,-1,ret,raiseerror,throwerror?SQVM::ET_RESUME_THROW_VM : SQVM::ET_RESUME_VM)) { return SQ_ERROR; @@ -1311,7 +1314,7 @@ SQRESULT sq_readclosure(HRABBITVM v,SQREADFUNC r,SQUserPointer up) SQChar *sq_getscratchpad(HRABBITVM v,int64_t minsize) { - return _ss(v)->GetScratchPad(minsize); + return _ss(v)->getScratchPad(minsize); } SQRESULT sq_resurrectunreachable(HRABBITVM v) @@ -1319,7 +1322,7 @@ SQRESULT sq_resurrectunreachable(HRABBITVM v) return sq_throwerror(v,_SC("sq_resurrectunreachable requires a garbage collector build")); } -// TODO: Remove this... +// TODO: remove this... int64_t sq_collectgarbage(HRABBITVM v) { return -1; @@ -1403,8 +1406,8 @@ SQRESULT sq_setattributes(HRABBITVM v,int64_t idx) v->Pop(2); v->Push(attrs); return SQ_OK; - }else if(_class(*o)->GetAttributes(key,attrs)) { - _class(*o)->SetAttributes(key,val); + }else if(_class(*o)->getAttributes(key,attrs)) { + _class(*o)->setAttributes(key,val); v->Pop(2); v->Push(attrs); return SQ_OK; @@ -1424,7 +1427,7 @@ SQRESULT sq_getattributes(HRABBITVM v,int64_t idx) v->Push(attrs); return SQ_OK; } - else if(_class(*o)->GetAttributes(key,attrs)) { + else if(_class(*o)->getAttributes(key,attrs)) { v->Pop(); v->Push(attrs); return SQ_OK; @@ -1439,7 +1442,7 @@ SQRESULT sq_getmemberhandle(HRABBITVM v,int64_t idx,HSQMEMBERHANDLE *handle) SQObjectPtr &key = stack_get(v,-1); SQTable *m = _class(*o)->_members; SQObjectPtr val; - if(m->Get(key,val)) { + if(m->get(key,val)) { handle->_static = _isfield(val) ? SQFalse : SQTrue; handle->_index = _member_idx(val); v->Pop(); @@ -1526,7 +1529,7 @@ SQRESULT sq_createinstance(HRABBITVM v,int64_t idx) { SQObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, OT_CLASS,o); - v->Push(_class(*o)->CreateInstance()); + v->Push(_class(*o)->createInstance()); return SQ_OK; } @@ -1534,7 +1537,7 @@ void sq_weakref(HRABBITVM v,int64_t idx) { SQObject &o=stack_get(v,idx); if(ISREFCOUNTED(sq_type(o))) { - v->Push(_refcounted(o)->GetWeakRef(sq_type(o))); + v->Push(_refcounted(o)->getWeakRef(sq_type(o))); return; } v->Push(o); diff --git a/rabbit/sqarray.hpp b/rabbit/sqarray.hpp deleted file mode 100644 index 3253d91..0000000 --- a/rabbit/sqarray.hpp +++ /dev/null @@ -1,97 +0,0 @@ -/** - * @author Alberto DEMICHELIS - * @author Edouard DUPIN - * @copyright 2018, Edouard DUPIN, all right reserved - * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved - * @license MPL-2 (see license file) - */ -#pragma once - -struct SQArray : public SQRefCounted -{ -private: - SQArray(SQSharedState *ss,int64_t nsize) { - _values.resize(nsize); - } - ~SQArray() - { - } -public: - static SQArray* Create(SQSharedState *ss,int64_t nInitialSize){ - SQArray *newarray=(SQArray*)SQ_MALLOC(sizeof(SQArray)); - new (newarray) SQArray(ss,nInitialSize); - return newarray; - } - void Finalize(){ - _values.resize(0); - } - bool Get(const int64_t nidx,SQObjectPtr &val) - { - if(nidx>=0 && nidx<(int64_t)_values.size()){ - SQObjectPtr &o = _values[nidx]; - val = _realval(o); - return true; - } - else return false; - } - bool Set(const int64_t nidx,const SQObjectPtr &val) - { - if(nidx>=0 && nidx<(int64_t)_values.size()){ - _values[nidx]=val; - return true; - } - else return false; - } - int64_t Next(const SQObjectPtr &refpos,SQObjectPtr &outkey,SQObjectPtr &outval) - { - uint64_t idx=TranslateIndex(refpos); - while(idx<_values.size()){ - //first found - outkey=(int64_t)idx; - SQObjectPtr &o = _values[idx]; - outval = _realval(o); - //return idx for the next iteration - return ++idx; - } - //nothing to iterate anymore - return -1; - } - SQArray *Clone(){SQArray *anew=Create(NULL,0); anew->_values.copy(_values); return anew; } - int64_t Size() const {return _values.size();} - void Resize(int64_t size) - { - SQObjectPtr _null; - Resize(size,_null); - } - void Resize(int64_t size,SQObjectPtr &fill) { _values.resize(size,fill); ShrinkIfNeeded(); } - void Reserve(int64_t size) { _values.reserve(size); } - void Append(const SQObject &o){_values.push_back(o);} - void Extend(const SQArray *a); - SQObjectPtr &Top(){return _values.top();} - void Pop(){_values.pop_back(); ShrinkIfNeeded(); } - bool Insert(int64_t idx,const SQObject &val){ - if(idx < 0 || idx > (int64_t)_values.size()) - return false; - _values.insert(idx,val); - return true; - } - void ShrinkIfNeeded() { - if(_values.size() <= _values.capacity()>>2) //shrink the array - _values.shrinktofit(); - } - bool Remove(int64_t idx){ - if(idx < 0 || idx >= (int64_t)_values.size()) - return false; - _values.remove(idx); - ShrinkIfNeeded(); - return true; - } - void Release() - { - sq_delete(this,SQArray); - } - - SQObjectPtrVec _values; -}; - - diff --git a/rabbit/sqbaselib.cpp b/rabbit/sqbaselib.cpp index f37d145..9db380f 100644 --- a/rabbit/sqbaselib.cpp +++ b/rabbit/sqbaselib.cpp @@ -9,7 +9,7 @@ #include #include #include -#include +#include #include #include #include @@ -241,14 +241,14 @@ static int64_t base_suspend(HRABBITVM v) static int64_t base_array(HRABBITVM v) { - SQArray *a; + rabbit::Array *a; SQObject &size = stack_get(v,2); if(sq_gettop(v) > 2) { - a = SQArray::Create(_ss(v),0); - a->Resize(tointeger(size),stack_get(v,3)); + a = rabbit::Array::create(_ss(v),0); + a->resize(tointeger(size),stack_get(v,3)); } else { - a = SQArray::Create(_ss(v),tointeger(size)); + a = rabbit::Array::create(_ss(v),tointeger(size)); } v->Push(a); return 1; @@ -257,7 +257,7 @@ static int64_t base_array(HRABBITVM v) static int64_t base_type(HRABBITVM v) { SQObjectPtr &o = stack_get(v,2); - v->Push(SQString::Create(_ss(v),GetTypeName(o),-1)); + v->Push(SQString::create(_ss(v),getTypeName(o),-1)); return 1; } @@ -408,7 +408,7 @@ static int64_t number_delegate_tochar(HRABBITVM v) { SQObject &o=stack_get(v,1); SQChar c = (SQChar)tointeger(o); - v->Push(SQString::Create(_ss(v),(const SQChar *)&c,1)); + v->Push(SQString::create(_ss(v),(const SQChar *)&c,1)); return 1; } @@ -463,11 +463,11 @@ static int64_t table_filter(HRABBITVM v) { SQObject &o = stack_get(v,1); SQTable *tbl = _table(o); - SQObjectPtr ret = SQTable::Create(_ss(v),0); + SQObjectPtr ret = SQTable::create(_ss(v),0); SQObjectPtr itr, key, val; int64_t nitr; - while((nitr = tbl->Next(false, itr, key, val)) != -1) { + while((nitr = tbl->next(false, itr, key, val)) != -1) { itr = (int64_t)nitr; v->Push(o); @@ -476,7 +476,7 @@ static int64_t table_filter(HRABBITVM v) if(SQ_FAILED(sq_call(v,3,SQTrue,SQFalse))) { return SQ_ERROR; } - if(!SQVM::IsFalse(v->GetUp(-1))) { + if(!SQVM::IsFalse(v->getUp(-1))) { _table(ret)->NewSlot(key, val); } v->Pop(); @@ -511,7 +511,7 @@ static int64_t array_append(HRABBITVM v) static int64_t array_extend(HRABBITVM v) { - _array(stack_get(v,1))->Extend(_array(stack_get(v,2))); + _array(stack_get(v,1))->extend(_array(stack_get(v,2))); sq_pop(v,1); return 1; } @@ -529,8 +529,8 @@ static int64_t array_pop(HRABBITVM v) static int64_t array_top(HRABBITVM v) { SQObject &o=stack_get(v,1); - if(_array(o)->Size()>0){ - v->Push(_array(o)->Top()); + if(_array(o)->size()>0){ + v->Push(_array(o)->top()); return 1; } else return sq_throwerror(v,_SC("top() on a empty array")); @@ -541,7 +541,7 @@ static int64_t array_insert(HRABBITVM v) SQObject &o=stack_get(v,1); SQObject &idx=stack_get(v,2); SQObject &val=stack_get(v,3); - if(!_array(o)->Insert(tointeger(idx),val)) + if(!_array(o)->insert(tointeger(idx),val)) return sq_throwerror(v,_SC("index out of range")); sq_pop(v,2); return 1; @@ -553,8 +553,8 @@ static int64_t array_remove(HRABBITVM v) SQObject &idx = stack_get(v, 2); if(!sq_isnumeric(idx)) return sq_throwerror(v, _SC("wrong type")); SQObjectPtr val; - if(_array(o)->Get(tointeger(idx), val)) { - _array(o)->Remove(tointeger(idx)); + if(_array(o)->get(tointeger(idx), val)) { + _array(o)->remove(tointeger(idx)); v->Push(val); return 1; } @@ -573,24 +573,24 @@ static int64_t array_resize(HRABBITVM v) if(sq_gettop(v) > 2) fill = stack_get(v, 3); - _array(o)->Resize(sz,fill); + _array(o)->resize(sz,fill); sq_settop(v, 1); return 1; } return sq_throwerror(v, _SC("size must be a number")); } -static int64_t __map_array(SQArray *dest,SQArray *src,HRABBITVM v) { +static int64_t __map_array(rabbit::Array *dest,rabbit::Array *src,HRABBITVM v) { SQObjectPtr temp; - int64_t size = src->Size(); + int64_t size = src->size(); for(int64_t n = 0; n < size; n++) { - src->Get(n,temp); + src->get(n,temp); v->Push(src); v->Push(temp); if(SQ_FAILED(sq_call(v,2,SQTrue,SQFalse))) { return SQ_ERROR; } - dest->Set(n,v->GetUp(-1)); + dest->set(n,v->getUp(-1)); v->Pop(); } return 0; @@ -599,8 +599,8 @@ static int64_t __map_array(SQArray *dest,SQArray *src,HRABBITVM v) { static int64_t array_map(HRABBITVM v) { SQObject &o = stack_get(v,1); - int64_t size = _array(o)->Size(); - SQObjectPtr ret = SQArray::Create(_ss(v),size); + int64_t size = _array(o)->size(); + SQObjectPtr ret = rabbit::Array::create(_ss(v),size); if(SQ_FAILED(__map_array(_array(ret),_array(o),v))) return SQ_ERROR; v->Push(ret); @@ -619,24 +619,24 @@ static int64_t array_apply(HRABBITVM v) static int64_t array_reduce(HRABBITVM v) { SQObject &o = stack_get(v,1); - SQArray *a = _array(o); - int64_t size = a->Size(); + rabbit::Array *a = _array(o); + int64_t size = a->size(); if(size == 0) { return 0; } SQObjectPtr res; - a->Get(0,res); + a->get(0,res); if(size > 1) { SQObjectPtr other; for(int64_t n = 1; n < size; n++) { - a->Get(n,other); + a->get(n,other); v->Push(o); v->Push(res); v->Push(other); if(SQ_FAILED(sq_call(v,3,SQTrue,SQFalse))) { return SQ_ERROR; } - res = v->GetUp(-1); + res = v->getUp(-1); v->Pop(); } } @@ -647,20 +647,20 @@ static int64_t array_reduce(HRABBITVM v) static int64_t array_filter(HRABBITVM v) { SQObject &o = stack_get(v,1); - SQArray *a = _array(o); - SQObjectPtr ret = SQArray::Create(_ss(v),0); - int64_t size = a->Size(); + rabbit::Array *a = _array(o); + SQObjectPtr ret = rabbit::Array::create(_ss(v),0); + int64_t size = a->size(); SQObjectPtr val; for(int64_t n = 0; n < size; n++) { - a->Get(n,val); + a->get(n,val); v->Push(o); v->Push(n); v->Push(val); if(SQ_FAILED(sq_call(v,3,SQTrue,SQFalse))) { return SQ_ERROR; } - if(!SQVM::IsFalse(v->GetUp(-1))) { - _array(ret)->Append(val); + if(!SQVM::IsFalse(v->getUp(-1))) { + _array(ret)->append(val); } v->Pop(); } @@ -672,12 +672,12 @@ static int64_t array_find(HRABBITVM v) { SQObject &o = stack_get(v,1); SQObjectPtr &val = stack_get(v,2); - SQArray *a = _array(o); - int64_t size = a->Size(); + rabbit::Array *a = _array(o); + int64_t size = a->size(); SQObjectPtr temp; for(int64_t n = 0; n < size; n++) { bool res = false; - a->Get(n,temp); + a->get(n,temp); if(SQVM::IsEqual(temp,val,res) && res) { v->Push(n); return 1; @@ -713,7 +713,7 @@ static bool _sort_compare(HRABBITVM v,SQObjectPtr &a,SQObjectPtr &b,int64_t func return true; } -static bool _hsort_sift_down(HRABBITVM v,SQArray *arr, int64_t root, int64_t bottom, int64_t func) +static bool _hsort_sift_down(HRABBITVM v,rabbit::Array *arr, int64_t root, int64_t bottom, int64_t func) { int64_t maxChild; int64_t done = 0; @@ -725,7 +725,7 @@ static bool _hsort_sift_down(HRABBITVM v,SQArray *arr, int64_t root, int64_t bot maxChild = root2; } else { - if(!_sort_compare(v,arr->_values[root2],arr->_values[root2 + 1],func,ret)) + if(!_sort_compare(v,(*arr)[root2],(*arr)[root2 + 1],func,ret)) return false; if (ret > 0) { maxChild = root2; @@ -735,7 +735,7 @@ static bool _hsort_sift_down(HRABBITVM v,SQArray *arr, int64_t root, int64_t bot } } - if(!_sort_compare(v,arr->_values[root],arr->_values[maxChild],func,ret)) + if(!_sort_compare(v,(*arr)[root],(*arr)[maxChild],func,ret)) return false; if (ret < 0) { if (root == maxChild) { @@ -743,7 +743,7 @@ static bool _hsort_sift_down(HRABBITVM v,SQArray *arr, int64_t root, int64_t bot return false; // We'd be swapping ourselve. The compare function is incorrect } - _Swap(arr->_values[root],arr->_values[maxChild]); + _Swap((*arr)[root], (*arr)[maxChild]); root = maxChild; } else { @@ -755,16 +755,16 @@ static bool _hsort_sift_down(HRABBITVM v,SQArray *arr, int64_t root, int64_t bot static bool _hsort(HRABBITVM v,SQObjectPtr &arr, int64_t SQ_UNUSED_ARG(l), int64_t SQ_UNUSED_ARG(r),int64_t func) { - SQArray *a = _array(arr); + rabbit::Array *a = _array(arr); int64_t i; - int64_t array_size = a->Size(); + int64_t array_size = a->size(); for (i = (array_size / 2); i >= 0; i--) { if(!_hsort_sift_down(v,a, i, array_size - 1,func)) return false; } for (i = array_size-1; i >= 1; i--) { - _Swap(a->_values[0],a->_values[i]); + _Swap((*a)[0],(*a)[i]); if(!_hsort_sift_down(v,a, 0, i-1,func)) return false; } return true; @@ -774,9 +774,9 @@ static int64_t array_sort(HRABBITVM v) { int64_t func = -1; SQObjectPtr &o = stack_get(v,1); - if(_array(o)->Size() > 1) { + if(_array(o)->size() > 1) { if(sq_gettop(v) == 2) func = 2; - if(!_hsort(v, o, 0, _array(o)->Size()-1, func)) + if(!_hsort(v, o, 0, _array(o)->size()-1, func)) return SQ_ERROR; } @@ -789,17 +789,17 @@ static int64_t array_slice(HRABBITVM v) int64_t sidx,eidx; SQObjectPtr o; if(get_slice_params(v,sidx,eidx,o)==-1)return -1; - int64_t alen = _array(o)->Size(); + int64_t alen = _array(o)->size(); if(sidx < 0)sidx = alen + sidx; if(eidx < 0)eidx = alen + eidx; if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes")); if(eidx > alen || sidx < 0)return sq_throwerror(v, _SC("slice out of range")); - SQArray *arr=SQArray::Create(_ss(v),eidx-sidx); + rabbit::Array *arr=rabbit::Array::create(_ss(v),eidx-sidx); SQObjectPtr t; int64_t count=0; for(int64_t i=sidx;iGet(i,t); - arr->Set(count++,t); + _array(o)->get(i,t); + arr->set(count++,t); } v->Push(arr); return 1; @@ -841,7 +841,7 @@ static int64_t string_slice(HRABBITVM v) if(eidx < 0)eidx = slen + eidx; if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes")); if(eidx > slen || sidx < 0) return sq_throwerror(v, _SC("slice out of range")); - v->Push(SQString::Create(_ss(v),&_stringval(o)[sidx],eidx-sidx)); + v->Push(SQString::create(_ss(v),&_stringval(o)[sidx],eidx-sidx)); return 1; } @@ -875,10 +875,10 @@ static int64_t string_find(HRABBITVM v) if(eidx > slen || sidx < 0) return sq_throwerror(v,_SC("slice out of range")); \ int64_t len=_string(str)->_len; \ const SQChar *sthis=_stringval(str); \ - SQChar *snew=(_ss(v)->GetScratchPad(sq_rsl(len))); \ + SQChar *snew=(_ss(v)->getScratchPad(sq_rsl(len))); \ memcpy(snew,sthis,sq_rsl(len));\ for(int64_t i=sidx;iPush(SQString::Create(_ss(v),snew,len)); \ + v->Push(SQString::create(_ss(v),snew,len)); \ return 1; \ } @@ -927,10 +927,10 @@ static int64_t closure_call(HRABBITVM v) static int64_t _closure_acall(HRABBITVM v,SQBool raiseerror) { - SQArray *aparams=_array(stack_get(v,2)); - int64_t nparams=aparams->Size(); + rabbit::Array *aparams=_array(stack_get(v,2)); + int64_t nparams=aparams->size(); v->Push(stack_get(v,1)); - for(int64_t i=0;iPush(aparams->_values[i]); + for(int64_t i=0;iPush((*aparams)[i]); return SQ_SUCCEEDED(sq_call(v,nparams,SQTrue,raiseerror))?1:SQ_ERROR; } @@ -967,42 +967,42 @@ static int64_t closure_setroot(HRABBITVM v) static int64_t closure_getinfos(HRABBITVM v) { SQObject o = stack_get(v,1); - SQTable *res = SQTable::Create(_ss(v),4); + SQTable *res = SQTable::create(_ss(v),4); if(sq_type(o) == OT_CLOSURE) { SQFunctionProto *f = _closure(o)->_function; int64_t nparams = f->_nparameters + (f->_varparams?1:0); - SQObjectPtr params = SQArray::Create(_ss(v),nparams); - SQObjectPtr defparams = SQArray::Create(_ss(v),f->_ndefaultparams); + SQObjectPtr params = rabbit::Array::create(_ss(v),nparams); + SQObjectPtr defparams = rabbit::Array::create(_ss(v),f->_ndefaultparams); for(int64_t n = 0; n_nparameters; n++) { - _array(params)->Set((int64_t)n,f->_parameters[n]); + _array(params)->set((int64_t)n,f->_parameters[n]); } for(int64_t j = 0; j_ndefaultparams; j++) { - _array(defparams)->Set((int64_t)j,_closure(o)->_defaultparams[j]); + _array(defparams)->set((int64_t)j,_closure(o)->_defaultparams[j]); } if(f->_varparams) { - _array(params)->Set(nparams-1,SQString::Create(_ss(v),_SC("..."),-1)); + _array(params)->set(nparams-1,SQString::create(_ss(v),_SC("..."),-1)); } - res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),false); - res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),f->_name); - res->NewSlot(SQString::Create(_ss(v),_SC("src"),-1),f->_sourcename); - res->NewSlot(SQString::Create(_ss(v),_SC("parameters"),-1),params); - res->NewSlot(SQString::Create(_ss(v),_SC("varargs"),-1),f->_varparams); - res->NewSlot(SQString::Create(_ss(v),_SC("defparams"),-1),defparams); + res->NewSlot(SQString::create(_ss(v),_SC("native"),-1),false); + res->NewSlot(SQString::create(_ss(v),_SC("name"),-1),f->_name); + res->NewSlot(SQString::create(_ss(v),_SC("src"),-1),f->_sourcename); + res->NewSlot(SQString::create(_ss(v),_SC("parameters"),-1),params); + res->NewSlot(SQString::create(_ss(v),_SC("varargs"),-1),f->_varparams); + res->NewSlot(SQString::create(_ss(v),_SC("defparams"),-1),defparams); } else { //OT_NATIVECLOSURE SQNativeClosure *nc = _nativeclosure(o); - res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),true); - res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),nc->_name); - res->NewSlot(SQString::Create(_ss(v),_SC("paramscheck"),-1),nc->_nparamscheck); + res->NewSlot(SQString::create(_ss(v),_SC("native"),-1),true); + res->NewSlot(SQString::create(_ss(v),_SC("name"),-1),nc->_name); + res->NewSlot(SQString::create(_ss(v),_SC("paramscheck"),-1),nc->_nparamscheck); SQObjectPtr typecheck; if(nc->_typecheck.size() > 0) { typecheck = - SQArray::Create(_ss(v), nc->_typecheck.size()); + rabbit::Array::create(_ss(v), nc->_typecheck.size()); for(uint64_t n = 0; n_typecheck.size(); n++) { - _array(typecheck)->Set((int64_t)n,nc->_typecheck[n]); + _array(typecheck)->set((int64_t)n,nc->_typecheck[n]); } } - res->NewSlot(SQString::Create(_ss(v),_SC("typecheck"),-1),typecheck); + res->NewSlot(SQString::create(_ss(v),_SC("typecheck"),-1),typecheck); } v->Push(res); return 1; @@ -1029,9 +1029,9 @@ static int64_t generator_getstatus(HRABBITVM v) { SQObject &o=stack_get(v,1); switch(_generator(o)->_state){ - case SQGenerator::eSuspended:v->Push(SQString::Create(_ss(v),_SC("suspended")));break; - case SQGenerator::eRunning:v->Push(SQString::Create(_ss(v),_SC("running")));break; - case SQGenerator::eDead:v->Push(SQString::Create(_ss(v),_SC("dead")));break; + case SQGenerator::eSuspended:v->Push(SQString::create(_ss(v),_SC("suspended")));break; + case SQGenerator::eRunning:v->Push(SQString::create(_ss(v),_SC("running")));break; + case SQGenerator::eDead:v->Push(SQString::create(_ss(v),_SC("dead")));break; } return 1; } diff --git a/rabbit/sqclass.cpp b/rabbit/sqclass.cpp index 33e7948..b113764 100644 --- a/rabbit/sqclass.cpp +++ b/rabbit/sqclass.cpp @@ -30,7 +30,7 @@ SQClass::SQClass(SQSharedState *ss,SQClass *base) _COPY_VECTOR(_metamethods,base->_metamethods,MT_LAST); __ObjAddRef(_base); } - _members = base?base->_members->Clone() : SQTable::Create(ss,0); + _members = base?base->_members->clone() : SQTable::create(ss,0); __ObjAddRef(_members); } @@ -39,9 +39,9 @@ void SQClass::Finalize() { _NULL_SQOBJECT_VECTOR(_defaultvalues,_defaultvalues.size()); _methods.resize(0); _NULL_SQOBJECT_VECTOR(_metamethods,MT_LAST); - __ObjRelease(_members); + __Objrelease(_members); if(_base) { - __ObjRelease(_base); + __Objrelease(_base); } } @@ -56,7 +56,7 @@ bool SQClass::NewSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr bool belongs_to_static_table = sq_type(val) == OT_CLOSURE || sq_type(val) == OT_NATIVECLOSURE || bstatic; if(_locked && !belongs_to_static_table) return false; //the class already has an instance so cannot be modified - if(_members->Get(key,temp) && _isfield(temp)) //overrides the default value + if(_members->get(key,temp) && _isfield(temp)) //overrides the default value { _defaultvalues[_member_idx(temp)].val = val; return true; @@ -64,13 +64,13 @@ bool SQClass::NewSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr if(belongs_to_static_table) { int64_t mmidx; if((sq_type(val) == OT_CLOSURE || sq_type(val) == OT_NATIVECLOSURE) && - (mmidx = ss->GetMetaMethodIdxByName(key)) != -1) { + (mmidx = ss->getMetaMethodIdxByName(key)) != -1) { _metamethods[mmidx] = val; } else { SQObjectPtr theval = val; if(_base && sq_type(val) == OT_CLOSURE) { - theval = _closure(val)->Clone(); + theval = _closure(val)->clone(); _closure(theval)->_base = _base; __ObjAddRef(_base); //ref for the closure } @@ -98,16 +98,16 @@ bool SQClass::NewSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr return true; } -SQInstance *SQClass::CreateInstance() +SQInstance *SQClass::createInstance() { if(!_locked) Lock(); - return SQInstance::Create(NULL,this); + return SQInstance::create(NULL,this); } -int64_t SQClass::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval) +int64_t SQClass::next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval) { SQObjectPtr oval; - int64_t idx = _members->Next(false,refpos,outkey,oval); + int64_t idx = _members->next(false,refpos,outkey,oval); if(idx != -1) { if(_ismethod(oval)) { outval = _methods[_member_idx(oval)].val; @@ -120,10 +120,10 @@ int64_t SQClass::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPt return idx; } -bool SQClass::SetAttributes(const SQObjectPtr &key,const SQObjectPtr &val) +bool SQClass::setAttributes(const SQObjectPtr &key,const SQObjectPtr &val) { SQObjectPtr idx; - if(_members->Get(key,idx)) { + if(_members->get(key,idx)) { if(_isfield(idx)) _defaultvalues[_member_idx(idx)].attrs = val; else @@ -133,10 +133,10 @@ bool SQClass::SetAttributes(const SQObjectPtr &key,const SQObjectPtr &val) return false; } -bool SQClass::GetAttributes(const SQObjectPtr &key,SQObjectPtr &outval) +bool SQClass::getAttributes(const SQObjectPtr &key,SQObjectPtr &outval) { SQObjectPtr idx; - if(_members->Get(key,idx)) { + if(_members->get(key,idx)) { outval = (_isfield(idx)?_defaultvalues[_member_idx(idx)].attrs:_methods[_member_idx(idx)].attrs); return true; } @@ -177,7 +177,7 @@ SQInstance::SQInstance(SQSharedState *ss, SQInstance *i, int64_t memsize) void SQInstance::Finalize() { uint64_t nvalues = _class->_defaultvalues.size(); - __ObjRelease(_class); + __Objrelease(_class); _NULL_SQOBJECT_VECTOR(_values,nvalues); } @@ -186,7 +186,7 @@ SQInstance::~SQInstance() if(_class){ Finalize(); } //if _class is null it was already finalized by the GC } -bool SQInstance::GetMetaMethod(SQVM* SQ_UNUSED_ARG(v),SQMetaMethod mm,SQObjectPtr &res) +bool SQInstance::getMetaMethod(SQVM* SQ_UNUSED_ARG(v),SQMetaMethod mm,SQObjectPtr &res) { if(sq_type(_class->_metamethods[mm]) != OT_NULL) { res = _class->_metamethods[mm]; diff --git a/rabbit/sqclass.hpp b/rabbit/sqclass.hpp index 25a8f9b..8684b6d 100644 --- a/rabbit/sqclass.hpp +++ b/rabbit/sqclass.hpp @@ -30,19 +30,19 @@ typedef sqvector SQClassMemberVec; #define _member_type(o) (_integer(o)&0xFF000000) #define _member_idx(o) (_integer(o)&0x00FFFFFF) -struct SQClass : public SQRefCounted +struct SQClass : public rabbit::RefCounted { SQClass(SQSharedState *ss,SQClass *base); public: - static SQClass* Create(SQSharedState *ss,SQClass *base) { + static SQClass* create(SQSharedState *ss,SQClass *base) { SQClass *newclass = (SQClass *)SQ_MALLOC(sizeof(SQClass)); new (newclass) SQClass(ss, base); return newclass; } ~SQClass(); bool NewSlot(SQSharedState *ss, const SQObjectPtr &key,const SQObjectPtr &val,bool bstatic); - bool Get(const SQObjectPtr &key,SQObjectPtr &val) { - if(_members->Get(key,val)) { + bool get(const SQObjectPtr &key,SQObjectPtr &val) { + if(_members->get(key,val)) { if(_isfield(val)) { SQObjectPtr &o = _defaultvalues[_member_idx(val)].val; val = _realval(o); @@ -54,7 +54,7 @@ public: } return false; } - bool GetConstructor(SQObjectPtr &ctor) + bool getConstructor(SQObjectPtr &ctor) { if(_constructoridx != -1) { ctor = _methods[_constructoridx].val; @@ -62,16 +62,16 @@ public: } return false; } - bool SetAttributes(const SQObjectPtr &key,const SQObjectPtr &val); - bool GetAttributes(const SQObjectPtr &key,SQObjectPtr &outval); + bool setAttributes(const SQObjectPtr &key,const SQObjectPtr &val); + bool getAttributes(const SQObjectPtr &key,SQObjectPtr &outval); void Lock() { _locked = true; if(_base) _base->Lock(); } - void Release() { + void release() { if (_hook) { _hook(_typetag,0);} sq_delete(this, SQClass); } void Finalize(); - int64_t Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); - SQInstance *CreateInstance(); + int64_t next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); + SQInstance *createInstance(); SQTable *_members; SQClass *_base; SQClassMemberVec _defaultvalues; @@ -94,7 +94,7 @@ struct SQInstance : public SQDelegable SQInstance(SQSharedState *ss, SQClass *c, int64_t memsize); SQInstance(SQSharedState *ss, SQInstance *c, int64_t memsize); public: - static SQInstance* Create(SQSharedState *ss,SQClass *theclass) { + static SQInstance* create(SQSharedState *ss,SQClass *theclass) { int64_t size = calcinstancesize(theclass); SQInstance *newinst = (SQInstance *)SQ_MALLOC(size); @@ -104,7 +104,7 @@ public: } return newinst; } - SQInstance *Clone(SQSharedState *ss) + SQInstance *clone(SQSharedState *ss) { int64_t size = calcinstancesize(_class); SQInstance *newinst = (SQInstance *)SQ_MALLOC(size); @@ -115,8 +115,8 @@ public: return newinst; } ~SQInstance(); - bool Get(const SQObjectPtr &key,SQObjectPtr &val) { - if(_class->_members->Get(key,val)) { + bool get(const SQObjectPtr &key,SQObjectPtr &val) { + if(_class->_members->get(key,val)) { if(_isfield(val)) { SQObjectPtr &o = _values[_member_idx(val)]; val = _realval(o); @@ -128,15 +128,15 @@ public: } return false; } - bool Set(const SQObjectPtr &key,const SQObjectPtr &val) { + bool set(const SQObjectPtr &key,const SQObjectPtr &val) { SQObjectPtr idx; - if(_class->_members->Get(key,idx) && _isfield(idx)) { + if(_class->_members->get(key,idx) && _isfield(idx)) { _values[_member_idx(idx)] = val; return true; } return false; } - void Release() { + void release() { _uiRef++; if (_hook) { _hook(_userpointer,0);} _uiRef--; @@ -147,7 +147,7 @@ public: } void Finalize(); bool InstanceOf(SQClass *trg); - bool GetMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res); + bool getMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res); SQClass *_class; SQUserPointer _userpointer; diff --git a/rabbit/sqclosure.hpp b/rabbit/sqclosure.hpp index a452e96..8c55e5b 100644 --- a/rabbit/sqclosure.hpp +++ b/rabbit/sqclosure.hpp @@ -11,7 +11,7 @@ struct SQFunctionProto; struct SQClass; -struct SQClosure : public SQRefCounted +struct SQClosure : public rabbit::RefCounted { private: SQClosure(SQSharedState *ss,SQFunctionProto *func){ @@ -21,7 +21,7 @@ private: _root=NULL; } public: - static SQClosure *Create(SQSharedState *ss,SQFunctionProto *func,SQWeakRef *root){ + static SQClosure *create(SQSharedState *ss,SQFunctionProto *func,rabbit::WeakRef *root){ int64_t size = _CALC_CLOSURE_SIZE(func); SQClosure *nc=(SQClosure*)SQ_MALLOC(size); new (nc) SQClosure(ss,func); @@ -33,25 +33,25 @@ public: _CONSTRUCT_VECTOR(SQObjectPtr,func->_ndefaultparams,nc->_defaultparams); return nc; } - void Release(){ + void release(){ SQFunctionProto *f = _function; int64_t size = _CALC_CLOSURE_SIZE(f); _DESTRUCT_VECTOR(SQObjectPtr,f->_noutervalues,_outervalues); _DESTRUCT_VECTOR(SQObjectPtr,f->_ndefaultparams,_defaultparams); - __ObjRelease(_function); + __Objrelease(_function); this->~SQClosure(); sq_vm_free(this,size); } - void SetRoot(SQWeakRef *r) + void setRoot(rabbit::WeakRef *r) { - __ObjRelease(_root); + __Objrelease(_root); _root = r; __ObjAddRef(_root); } - SQClosure *Clone() + SQClosure *clone() { SQFunctionProto *f = _function; - SQClosure * ret = SQClosure::Create(NULL,f,_root); + SQClosure * ret = SQClosure::create(NULL,f,_root); ret->_env = _env; if(ret->_env) __ObjAddRef(ret->_env); _COPY_VECTOR(ret->_outervalues,_outervalues,f->_noutervalues); @@ -62,8 +62,8 @@ public: bool Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write); static bool Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret); - SQWeakRef *_env; - SQWeakRef *_root; + rabbit::WeakRef *_env; + rabbit::WeakRef *_root; SQClass *_base; SQFunctionProto *_function; SQObjectPtr *_outervalues; @@ -71,7 +71,7 @@ public: }; ////////////////////////////////////////////// -struct SQOuter : public SQRefCounted +struct SQOuter : public rabbit::RefCounted { private: @@ -81,7 +81,7 @@ private: } public: - static SQOuter *Create(SQSharedState *ss, SQObjectPtr *outer) + static SQOuter *create(SQSharedState *ss, SQObjectPtr *outer) { SQOuter *nc = (SQOuter*)SQ_MALLOC(sizeof(SQOuter)); new (nc) SQOuter(ss, outer); @@ -91,7 +91,7 @@ public: } - void Release() + void release() { this->~SQOuter(); sq_vm_free(this,sizeof(SQOuter)); @@ -104,7 +104,7 @@ public: }; ////////////////////////////////////////////// -struct SQGenerator : public SQRefCounted +struct SQGenerator : public rabbit::RefCounted { enum SQGeneratorState{eRunning,eSuspended,eDead}; private: @@ -114,7 +114,7 @@ private: _ci._generator=NULL; } public: - static SQGenerator *Create(SQSharedState *ss,SQClosure *closure){ + static SQGenerator *create(SQSharedState *ss,SQClosure *closure){ SQGenerator *nc=(SQGenerator*)SQ_MALLOC(sizeof(SQGenerator)); new (nc) SQGenerator(ss,closure); return nc; @@ -127,7 +127,7 @@ public: _state=eDead; _stack.resize(0); _closure.Null();} - void Release(){ + void release(){ sq_delete(this,SQGenerator); } @@ -142,7 +142,7 @@ public: #define _CALC_NATVIVECLOSURE_SIZE(noutervalues) (sizeof(SQNativeClosure) + (noutervalues*sizeof(SQObjectPtr))) -struct SQNativeClosure : public SQRefCounted +struct SQNativeClosure : public rabbit::RefCounted { private: SQNativeClosure(SQSharedState *ss,SQFUNCTION func){ @@ -150,7 +150,7 @@ private: _env = NULL; } public: - static SQNativeClosure *Create(SQSharedState *ss,SQFUNCTION func,int64_t nouters) + static SQNativeClosure *create(SQSharedState *ss,SQFUNCTION func,int64_t nouters) { int64_t size = _CALC_NATVIVECLOSURE_SIZE(nouters); SQNativeClosure *nc=(SQNativeClosure*)SQ_MALLOC(size); @@ -160,9 +160,9 @@ public: _CONSTRUCT_VECTOR(SQObjectPtr,nc->_noutervalues,nc->_outervalues); return nc; } - SQNativeClosure *Clone() + SQNativeClosure *clone() { - SQNativeClosure * ret = SQNativeClosure::Create(NULL,_function,_noutervalues); + SQNativeClosure * ret = SQNativeClosure::create(NULL,_function,_noutervalues); ret->_env = _env; if(ret->_env) __ObjAddRef(ret->_env); ret->_name = _name; @@ -173,9 +173,9 @@ public: } ~SQNativeClosure() { - __ObjRelease(_env); + __Objrelease(_env); } - void Release(){ + void release(){ int64_t size = _CALC_NATVIVECLOSURE_SIZE(_noutervalues); _DESTRUCT_VECTOR(SQObjectPtr,_noutervalues,_outervalues); this->~SQNativeClosure(); @@ -186,7 +186,7 @@ public: SQIntVec _typecheck; SQObjectPtr *_outervalues; uint64_t _noutervalues; - SQWeakRef *_env; + rabbit::WeakRef *_env; SQFUNCTION _function; SQObjectPtr _name; }; diff --git a/rabbit/sqcompiler.cpp b/rabbit/sqcompiler.cpp index 39b67bf..c1964af 100644 --- a/rabbit/sqcompiler.cpp +++ b/rabbit/sqcompiler.cpp @@ -39,23 +39,23 @@ struct SQScope { #define BEGIN_SCOPE() SQScope __oldscope__ = _scope; \ _scope.outers = _fs->_outers; \ - _scope.stacksize = _fs->GetStackSize(); + _scope.stacksize = _fs->getStacksize(); -#define RESOLVE_OUTERS() if(_fs->GetStackSize() != _scope.stacksize) { \ +#define RESOLVE_OUTERS() if(_fs->getStacksize() != _scope.stacksize) { \ if(_fs->CountOuters(_scope.stacksize)) { \ _fs->AddInstruction(_OP_CLOSE,0,_scope.stacksize); \ } \ } -#define END_SCOPE_NO_CLOSE() { if(_fs->GetStackSize() != _scope.stacksize) { \ - _fs->SetStackSize(_scope.stacksize); \ +#define END_SCOPE_NO_CLOSE() { if(_fs->getStacksize() != _scope.stacksize) { \ + _fs->setStacksize(_scope.stacksize); \ } \ _scope = __oldscope__; \ } #define END_SCOPE() { int64_t oldouters = _fs->_outers;\ - if(_fs->GetStackSize() != _scope.stacksize) { \ - _fs->SetStackSize(_scope.stacksize); \ + if(_fs->getStacksize() != _scope.stacksize) { \ + _fs->setStacksize(_scope.stacksize); \ if(oldouters != _fs->_outers) { \ _fs->AddInstruction(_OP_CLOSE,0,_scope.stacksize); \ } \ @@ -80,7 +80,7 @@ public: { _vm=v; _lex.Init(_ss(v), rg, up,ThrowError,this); - _sourcename = SQString::Create(_ss(v), sourcename); + _sourcename = SQString::create(_ss(v), sourcename); _lineinfo = lineinfo;_raiseerror = raiseerror; _scope.outers = 0; _scope.stacksize = 0; @@ -135,10 +135,10 @@ public: switch(tok) { case TK_IDENTIFIER: - ret = _fs->CreateString(_lex._svalue); + ret = _fs->createString(_lex._svalue); break; case TK_STRING_LITERAL: - ret = _fs->CreateString(_lex._svalue,_lex._longstr.size()-1); + ret = _fs->createString(_lex._svalue,_lex._longstr.size()-1); break; case TK_INTEGER: ret = SQObjectPtr(_lex._nvalue); @@ -159,7 +159,7 @@ public: } } void MoveIfCurrentTargetIsLocal() { - int64_t trg = _fs->TopTarget(); + int64_t trg = _fs->topTarget(); if(_fs->IsLocal(trg)) { trg = _fs->PopTarget(); //pops the target and moves it _fs->AddInstruction(_OP_MOVE, _fs->PushTarget(), trg); @@ -171,23 +171,23 @@ public: _debugop = 0; SQFuncState funcstate(_ss(_vm), NULL,ThrowError,this); - funcstate._name = SQString::Create(_ss(_vm), _SC("main")); + funcstate._name = SQString::create(_ss(_vm), _SC("main")); _fs = &funcstate; - _fs->AddParameter(_fs->CreateString(_SC("this"))); - _fs->AddParameter(_fs->CreateString(_SC("vargv"))); + _fs->AddParameter(_fs->createString(_SC("this"))); + _fs->AddParameter(_fs->createString(_SC("vargv"))); _fs->_varparams = true; _fs->_sourcename = _sourcename; - int64_t stacksize = _fs->GetStackSize(); + int64_t stacksize = _fs->getStacksize(); if(setjmp(_errorjmp) == 0) { Lex(); while(_token > 0){ Statement(); if(_lex._prevtoken != _SC('}') && _lex._prevtoken != _SC(';')) OptionalSemicolon(); } - _fs->SetStackSize(stacksize); + _fs->setStacksize(stacksize); _fs->AddLineInfos(_lex._currentline, _lineinfo, true); _fs->AddInstruction(_OP_RETURN, 0xFF); - _fs->SetStackSize(0); + _fs->setStacksize(0); o =_fs->BuildProto(); #ifdef _DEBUG_DUMP _fs->Dump(_funcproto(o)); @@ -198,7 +198,7 @@ public: _ss(_vm)->_compilererrorhandler(_vm, _compilererror, sq_type(_sourcename) == OT_STRING?_stringval(_sourcename):_SC("unknown"), _lex._currentline, _lex._currentcolumn); } - _vm->_lasterror = SQString::Create(_ss(_vm), _compilererror, -1); + _vm->_lasterror = SQString::create(_ss(_vm), _compilererror, -1); return false; } return true; @@ -234,18 +234,18 @@ public: } Lex(); if(!IsEndOfStatement()) { - int64_t retexp = _fs->GetCurrentPos()+1; + int64_t retexp = _fs->getCurrentPos()+1; CommaExpr(); if(op == _OP_RETURN && _fs->_traps > 0) _fs->AddInstruction(_OP_POPTRAP, _fs->_traps, 0); _fs->_returnexp = retexp; - _fs->AddInstruction(op, 1, _fs->PopTarget(),_fs->GetStackSize()); + _fs->AddInstruction(op, 1, _fs->PopTarget(),_fs->getStacksize()); } else{ if(op == _OP_RETURN && _fs->_traps > 0) _fs->AddInstruction(_OP_POPTRAP, _fs->_traps ,0); _fs->_returnexp = -1; - _fs->AddInstruction(op, 0xFF,0,_fs->GetStackSize()); + _fs->AddInstruction(op, 0xFF,0,_fs->getStacksize()); } break;} case TK_BREAK: @@ -255,7 +255,7 @@ public: } RESOLVE_OUTERS(); _fs->AddInstruction(_OP_JMP, 0, -1234); - _fs->_unresolvedbreaks.push_back(_fs->GetCurrentPos()); + _fs->_unresolvedbreaks.push_back(_fs->getCurrentPos()); Lex(); break; case TK_CONTINUE: @@ -265,7 +265,7 @@ public: } RESOLVE_OUTERS(); _fs->AddInstruction(_OP_JMP, 0, -1234); - _fs->_unresolvedcontinues.push_back(_fs->GetCurrentPos()); + _fs->_unresolvedcontinues.push_back(_fs->getCurrentPos()); Lex(); break; case TK_FUNCTION: @@ -357,7 +357,7 @@ public: break; case OUTER: { - int64_t val = _fs->TopTarget(); + int64_t val = _fs->topTarget(); int64_t tmp = _fs->PushTarget(); _fs->AddInstruction(_OP_GETOUTER, tmp, pos); _fs->AddInstruction(ChooseArithOpByToken(tok), tmp, val, tmp, 0); @@ -406,7 +406,7 @@ public: case LOCAL: { int64_t src = _fs->PopTarget(); - int64_t dst = _fs->TopTarget(); + int64_t dst = _fs->topTarget(); _fs->AddInstruction(_OP_MOVE, dst, src); } break; @@ -435,20 +435,20 @@ public: case _SC('?'): { Lex(); _fs->AddInstruction(_OP_JZ, _fs->PopTarget()); - int64_t jzpos = _fs->GetCurrentPos(); + int64_t jzpos = _fs->getCurrentPos(); int64_t trg = _fs->PushTarget(); Expression(); int64_t first_exp = _fs->PopTarget(); if(trg != first_exp) _fs->AddInstruction(_OP_MOVE, trg, first_exp); - int64_t endfirstexp = _fs->GetCurrentPos(); + int64_t endfirstexp = _fs->getCurrentPos(); _fs->AddInstruction(_OP_JMP, 0, 0); Expect(_SC(':')); - int64_t jmppos = _fs->GetCurrentPos(); + int64_t jmppos = _fs->getCurrentPos(); Expression(); int64_t second_exp = _fs->PopTarget(); if(trg != second_exp) _fs->AddInstruction(_OP_MOVE, trg, second_exp); - _fs->SetIntructionParam(jmppos, 1, _fs->GetCurrentPos() - jmppos); - _fs->SetIntructionParam(jzpos, 1, endfirstexp - jzpos + 1); + _fs->setIntructionParam(jmppos, 1, _fs->getCurrentPos() - jmppos); + _fs->setIntructionParam(jzpos, 1, endfirstexp - jzpos + 1); _fs->SnoozeOpt(); } break; @@ -479,14 +479,14 @@ public: int64_t first_exp = _fs->PopTarget(); int64_t trg = _fs->PushTarget(); _fs->AddInstruction(_OP_OR, trg, 0, first_exp, 0); - int64_t jpos = _fs->GetCurrentPos(); + int64_t jpos = _fs->getCurrentPos(); if(trg != first_exp) _fs->AddInstruction(_OP_MOVE, trg, first_exp); Lex(); INVOKE_EXP(&SQCompiler::LogicalOrExp); _fs->SnoozeOpt(); int64_t second_exp = _fs->PopTarget(); if(trg != second_exp) _fs->AddInstruction(_OP_MOVE, trg, second_exp); _fs->SnoozeOpt(); - _fs->SetIntructionParam(jpos, 1, (_fs->GetCurrentPos() - jpos)); + _fs->setIntructionParam(jpos, 1, (_fs->getCurrentPos() - jpos)); _es.etype = EXPR; break; }else return; @@ -499,14 +499,14 @@ public: int64_t first_exp = _fs->PopTarget(); int64_t trg = _fs->PushTarget(); _fs->AddInstruction(_OP_AND, trg, 0, first_exp, 0); - int64_t jpos = _fs->GetCurrentPos(); + int64_t jpos = _fs->getCurrentPos(); if(trg != first_exp) _fs->AddInstruction(_OP_MOVE, trg, first_exp); Lex(); INVOKE_EXP(&SQCompiler::LogicalAndExp); _fs->SnoozeOpt(); int64_t second_exp = _fs->PopTarget(); if(trg != second_exp) _fs->AddInstruction(_OP_MOVE, trg, second_exp); _fs->SnoozeOpt(); - _fs->SetIntructionParam(jpos, 1, (_fs->GetCurrentPos() - jpos)); + _fs->setIntructionParam(jpos, 1, (_fs->getCurrentPos() - jpos)); _es.etype = EXPR; break; } @@ -624,15 +624,15 @@ public: pos = -1; Lex(); - _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(Expect(TK_IDENTIFIER))); + _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->getConstant(Expect(TK_IDENTIFIER))); if(_es.etype==BASE) { Emit2ArgsOP(_OP_GET); - pos = _fs->TopTarget(); + pos = _fs->topTarget(); _es.etype = EXPR; _es.epos = pos; } else { - if(NeedGet()) { + if(Needget()) { Emit2ArgsOP(_OP_GET); } _es.etype = OBJECT; @@ -644,12 +644,12 @@ public: pos = -1; if(_es.etype==BASE) { Emit2ArgsOP(_OP_GET); - pos = _fs->TopTarget(); + pos = _fs->topTarget(); _es.etype = EXPR; _es.epos = pos; } else { - if(NeedGet()) { + if(Needget()) { Emit2ArgsOP(_OP_GET); } _es.etype = OBJECT; @@ -721,14 +721,14 @@ public: switch(_token) { case TK_STRING_LITERAL: - _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(_fs->CreateString(_lex._svalue,_lex._longstr.size()-1))); + _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->getConstant(_fs->createString(_lex._svalue,_lex._longstr.size()-1))); Lex(); break; case TK_BASE: Lex(); _fs->AddInstruction(_OP_GETBASE, _fs->PushTarget()); _es.etype = BASE; - _es.epos = _fs->TopTarget(); + _es.epos = _fs->topTarget(); return (_es.epos); break; case TK_IDENTIFIER: @@ -738,23 +738,23 @@ public: SQObject constant; switch(_token) { - case TK_IDENTIFIER: id = _fs->CreateString(_lex._svalue); break; - case TK_THIS: id = _fs->CreateString(_SC("this"),4); break; - case TK_CONSTRUCTOR: id = _fs->CreateString(_SC("constructor"),11); break; + case TK_IDENTIFIER: id = _fs->createString(_lex._svalue); break; + case TK_THIS: id = _fs->createString(_SC("this"),4); break; + case TK_CONSTRUCTOR: id = _fs->createString(_SC("constructor"),11); break; } int64_t pos = -1; Lex(); - if((pos = _fs->GetLocalVariable(id)) != -1) { + if((pos = _fs->getLocalVariable(id)) != -1) { /* Handle a local variable (includes 'this') */ _fs->PushTarget(pos); _es.etype = LOCAL; _es.epos = pos; } - else if((pos = _fs->GetOuterVariable(id)) != -1) { + else if((pos = _fs->getOuterVariable(id)) != -1) { /* Handle a free var */ - if(NeedGet()) { + if(Needget()) { _es.epos = _fs->PushTarget(); _fs->AddInstruction(_OP_GETOUTER, _es.epos, pos); /* _es.etype = EXPR; already default value */ @@ -772,7 +772,7 @@ public: if(sq_type(constant) == OT_TABLE) { Expect('.'); constid = Expect(TK_IDENTIFIER); - if(!_table(constant)->Get(constid, constval)) { + if(!_table(constant)->get(constid, constval)) { constval.Null(); Error(_SC("invalid constant [%s.%s]"), _stringval(id), _stringval(constid)); } @@ -788,7 +788,7 @@ public: case OT_INTEGER: EmitLoadConstInt(_integer(constval),_es.epos); break; case OT_FLOAT: EmitLoadConstFloat(_float(constval),_es.epos); break; case OT_BOOL: _fs->AddInstruction(_OP_LOADBOOL, _es.epos, _integer(constval)); break; - default: _fs->AddInstruction(_OP_LOAD,_es.epos,_fs->GetConstant(constval)); break; + default: _fs->AddInstruction(_OP_LOAD,_es.epos,_fs->getConstant(constval)); break; } _es.etype = EXPR; } @@ -800,8 +800,8 @@ public: * the _OP_GET instruction. */ _fs->PushTarget(0); - _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(id)); - if(NeedGet()) { + _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->getConstant(id)); + if(Needget()) { Emit2ArgsOP(_OP_GET); } _es.etype = OBJECT; @@ -828,17 +828,17 @@ public: break; case _SC('['): { _fs->AddInstruction(_OP_NEWOBJ, _fs->PushTarget(),0,0,NOT_ARRAY); - int64_t apos = _fs->GetCurrentPos(),key = 0; + int64_t apos = _fs->getCurrentPos(),key = 0; Lex(); while(_token != _SC(']')) { Expression(); if(_token == _SC(',')) Lex(); int64_t val = _fs->PopTarget(); - int64_t array = _fs->TopTarget(); + int64_t array = _fs->topTarget(); _fs->AddInstruction(_OP_APPENDARRAY, array, val, AAT_STACK); key++; } - _fs->SetIntructionParam(apos, 1, key); + _fs->setIntructionParam(apos, 1, key); Lex(); } break; @@ -873,7 +873,7 @@ public: case _SC('('): Lex(); CommaExpr(); Expect(_SC(')')); break; case TK___LINE__: EmitLoadConstInt(_lex._currentline,-1); Lex(); break; - case TK___FILE__: _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(_sourcename)); Lex(); break; + case TK___FILE__: _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->getConstant(_sourcename)); Lex(); break; default: Error(_SC("expression expected")); } _es.etype = EXPR; @@ -888,7 +888,7 @@ public: _fs->AddInstruction(_OP_LOADINT, target,value); } else { - _fs->AddInstruction(_OP_LOAD, target, _fs->GetNumericConstant(value)); + _fs->AddInstruction(_OP_LOAD, target, _fs->getNumericConstant(value)); } } void EmitLoadConstFloat(float_t value,int64_t target) @@ -900,7 +900,7 @@ public: _fs->AddInstruction(_OP_LOADFLOAT, target,*((int32_t *)&value)); } else { - _fs->AddInstruction(_OP_LOAD, target, _fs->GetNumericConstant(value)); + _fs->AddInstruction(_OP_LOAD, target, _fs->getNumericConstant(value)); } } void UnaryOP(SQOpcode op) @@ -909,7 +909,7 @@ public: int64_t src = _fs->PopTarget(); _fs->AddInstruction(op, _fs->PushTarget(), src); } - bool NeedGet() + bool Needget() { switch(_token) { case _SC('='): case _SC('('): case TK_NEWSLOT: case TK_MODEQ: case TK_MULEQ: @@ -947,7 +947,7 @@ public: } void ParseTableOrClass(int64_t separator,int64_t terminator) { - int64_t tpos = _fs->GetCurrentPos(),nkeys = 0; + int64_t tpos = _fs->getCurrentPos(),nkeys = 0; while(_token != terminator) { bool hasattrs = false; bool isstatic = false; @@ -968,10 +968,10 @@ public: case TK_CONSTRUCTOR:{ int64_t tk = _token; Lex(); - SQObject id = tk == TK_FUNCTION ? Expect(TK_IDENTIFIER) : _fs->CreateString(_SC("constructor")); + SQObject id = tk == TK_FUNCTION ? Expect(TK_IDENTIFIER) : _fs->createString(_SC("constructor")); Expect(_SC('(')); - _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(id)); - CreateFunction(id); + _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->getConstant(id)); + createFunction(id); _fs->AddInstruction(_OP_CLOSURE, _fs->PushTarget(), _fs->_functions.size() - 1, 0); } break; @@ -981,12 +981,12 @@ public: break; case TK_STRING_LITERAL: //JSON if(separator == ',') { //only works for tables - _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(Expect(TK_STRING_LITERAL))); + _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->getConstant(Expect(TK_STRING_LITERAL))); Expect(_SC(':')); Expression(); break; } default : - _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(Expect(TK_IDENTIFIER))); + _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->getConstant(Expect(TK_IDENTIFIER))); Expect(_SC('=')); Expression(); } if(_token == separator) Lex();//optional comma/semicolon @@ -997,7 +997,7 @@ public: ((void)attrs); assert((hasattrs && (attrs == key-1)) || !hasattrs); unsigned char flags = (hasattrs?NEW_SLOT_ATTRIBUTES_FLAG:0)|(isstatic?NEW_SLOT_STATIC_FLAG:0); - int64_t table = _fs->TopTarget(); //<topTarget(); //<AddInstruction(_OP_NEWSLOT, 0xFF, table, key, val); } @@ -1006,7 +1006,7 @@ public: } } if(separator == _SC(',')) //hack recognizes a table from the separator - _fs->SetIntructionParam(tpos, 1, nkeys); + _fs->setIntructionParam(tpos, 1, nkeys); Lex(); } void LocalDeclStatement() @@ -1017,7 +1017,7 @@ public: Lex(); varname = Expect(TK_IDENTIFIER); Expect(_SC('(')); - CreateFunction(varname,false); + createFunction(varname,false); _fs->AddInstruction(_OP_CLOSURE, _fs->PushTarget(), _fs->_functions.size() - 1, 0); _fs->PopTarget(); _fs->PushLocalVariable(varname); @@ -1068,7 +1068,7 @@ public: bool haselse = false; Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')')); _fs->AddInstruction(_OP_JZ, _fs->PopTarget()); - int64_t jnepos = _fs->GetCurrentPos(); + int64_t jnepos = _fs->getCurrentPos(); @@ -1086,52 +1086,52 @@ public: }*/ - int64_t endifblock = _fs->GetCurrentPos(); + int64_t endifblock = _fs->getCurrentPos(); if(_token == TK_ELSE){ haselse = true; //BEGIN_SCOPE(); _fs->AddInstruction(_OP_JMP); - jmppos = _fs->GetCurrentPos(); + jmppos = _fs->getCurrentPos(); Lex(); //Statement(); if(_lex._prevtoken != _SC('}')) OptionalSemicolon(); IfBlock(); //END_SCOPE(); - _fs->SetIntructionParam(jmppos, 1, _fs->GetCurrentPos() - jmppos); + _fs->setIntructionParam(jmppos, 1, _fs->getCurrentPos() - jmppos); } - _fs->SetIntructionParam(jnepos, 1, endifblock - jnepos + (haselse?1:0)); + _fs->setIntructionParam(jnepos, 1, endifblock - jnepos + (haselse?1:0)); } void WhileStatement() { int64_t jzpos, jmppos; - jmppos = _fs->GetCurrentPos(); + jmppos = _fs->getCurrentPos(); Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')')); BEGIN_BREAKBLE_BLOCK(); _fs->AddInstruction(_OP_JZ, _fs->PopTarget()); - jzpos = _fs->GetCurrentPos(); + jzpos = _fs->getCurrentPos(); BEGIN_SCOPE(); Statement(); END_SCOPE(); - _fs->AddInstruction(_OP_JMP, 0, jmppos - _fs->GetCurrentPos() - 1); - _fs->SetIntructionParam(jzpos, 1, _fs->GetCurrentPos() - jzpos); + _fs->AddInstruction(_OP_JMP, 0, jmppos - _fs->getCurrentPos() - 1); + _fs->setIntructionParam(jzpos, 1, _fs->getCurrentPos() - jzpos); END_BREAKBLE_BLOCK(jmppos); } void DoWhileStatement() { Lex(); - int64_t jmptrg = _fs->GetCurrentPos(); + int64_t jmptrg = _fs->getCurrentPos(); BEGIN_BREAKBLE_BLOCK() BEGIN_SCOPE(); Statement(); END_SCOPE(); Expect(TK_WHILE); - int64_t continuetrg = _fs->GetCurrentPos(); + int64_t continuetrg = _fs->getCurrentPos(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')')); _fs->AddInstruction(_OP_JZ, _fs->PopTarget(), 1); - _fs->AddInstruction(_OP_JMP, 0, jmptrg - _fs->GetCurrentPos() - 1); + _fs->AddInstruction(_OP_JMP, 0, jmptrg - _fs->getCurrentPos() - 1); END_BREAKBLE_BLOCK(continuetrg); } void ForStatement() @@ -1146,35 +1146,35 @@ public: } Expect(_SC(';')); _fs->SnoozeOpt(); - int64_t jmppos = _fs->GetCurrentPos(); + int64_t jmppos = _fs->getCurrentPos(); int64_t jzpos = -1; - if(_token != _SC(';')) { CommaExpr(); _fs->AddInstruction(_OP_JZ, _fs->PopTarget()); jzpos = _fs->GetCurrentPos(); } + if(_token != _SC(';')) { CommaExpr(); _fs->AddInstruction(_OP_JZ, _fs->PopTarget()); jzpos = _fs->getCurrentPos(); } Expect(_SC(';')); _fs->SnoozeOpt(); - int64_t expstart = _fs->GetCurrentPos() + 1; + int64_t expstart = _fs->getCurrentPos() + 1; if(_token != _SC(')')) { CommaExpr(); _fs->PopTarget(); } Expect(_SC(')')); _fs->SnoozeOpt(); - int64_t expend = _fs->GetCurrentPos(); + int64_t expend = _fs->getCurrentPos(); int64_t expsize = (expend - expstart) + 1; SQInstructionVec exp; if(expsize > 0) { for(int64_t i = 0; i < expsize; i++) - exp.push_back(_fs->GetInstruction(expstart + i)); + exp.push_back(_fs->getInstruction(expstart + i)); _fs->PopInstructions(expsize); } BEGIN_BREAKBLE_BLOCK() Statement(); - int64_t continuetrg = _fs->GetCurrentPos(); + int64_t continuetrg = _fs->getCurrentPos(); if(expsize > 0) { for(int64_t i = 0; i < expsize; i++) _fs->AddInstruction(exp[i]); } - _fs->AddInstruction(_OP_JMP, 0, jmppos - _fs->GetCurrentPos() - 1, 0); - if(jzpos> 0) _fs->SetIntructionParam(jzpos, 1, _fs->GetCurrentPos() - jzpos); + _fs->AddInstruction(_OP_JMP, 0, jmppos - _fs->getCurrentPos() - 1, 0); + if(jzpos> 0) _fs->setIntructionParam(jzpos, 1, _fs->getCurrentPos() - jzpos); END_BREAKBLE_BLOCK(continuetrg); @@ -1189,7 +1189,7 @@ public: Lex(); valname = Expect(TK_IDENTIFIER); } else{ - idxname = _fs->CreateString(_SC("@INDEX@")); + idxname = _fs->createString(_SC("@INDEX@")); } Expect(TK_IN); @@ -1197,7 +1197,7 @@ public: BEGIN_SCOPE(); //put the table in the stack(evaluate the table expression) Expression(); Expect(_SC(')')); - int64_t container = _fs->TopTarget(); + int64_t container = _fs->topTarget(); //push the index local var int64_t indexpos = _fs->PushLocalVariable(idxname); _fs->AddInstruction(_OP_LOADNULLS, indexpos,1); @@ -1205,18 +1205,18 @@ public: int64_t valuepos = _fs->PushLocalVariable(valname); _fs->AddInstruction(_OP_LOADNULLS, valuepos,1); //push reference index - int64_t itrpos = _fs->PushLocalVariable(_fs->CreateString(_SC("@ITERATOR@"))); //use invalid id to make it inaccessible + int64_t itrpos = _fs->PushLocalVariable(_fs->createString(_SC("@ITERATOR@"))); //use invalid id to make it inaccessible _fs->AddInstruction(_OP_LOADNULLS, itrpos,1); - int64_t jmppos = _fs->GetCurrentPos(); + int64_t jmppos = _fs->getCurrentPos(); _fs->AddInstruction(_OP_FOREACH, container, 0, indexpos); - int64_t foreachpos = _fs->GetCurrentPos(); + int64_t foreachpos = _fs->getCurrentPos(); _fs->AddInstruction(_OP_POSTFOREACH, container, 0, indexpos); //generate the statement code BEGIN_BREAKBLE_BLOCK() Statement(); - _fs->AddInstruction(_OP_JMP, 0, jmppos - _fs->GetCurrentPos() - 1); - _fs->SetIntructionParam(foreachpos, 1, _fs->GetCurrentPos() - foreachpos); - _fs->SetIntructionParam(foreachpos + 1, 1, _fs->GetCurrentPos() - foreachpos); + _fs->AddInstruction(_OP_JMP, 0, jmppos - _fs->getCurrentPos() - 1); + _fs->setIntructionParam(foreachpos, 1, _fs->getCurrentPos() - foreachpos); + _fs->setIntructionParam(foreachpos + 1, 1, _fs->getCurrentPos() - foreachpos); END_BREAKBLE_BLOCK(foreachpos - 1); //restore the local variable stack(remove index,val and ref idx) _fs->PopTarget(); @@ -1226,7 +1226,7 @@ public: { Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')')); Expect(_SC('{')); - int64_t expr = _fs->TopTarget(); + int64_t expr = _fs->topTarget(); bool bfirst = true; int64_t tonextcondjmp = -1; int64_t skipcondjmp = -1; @@ -1235,8 +1235,8 @@ public: while(_token == TK_CASE) { if(!bfirst) { _fs->AddInstruction(_OP_JMP, 0, 0); - skipcondjmp = _fs->GetCurrentPos(); - _fs->SetIntructionParam(tonextcondjmp, 1, _fs->GetCurrentPos() - tonextcondjmp); + skipcondjmp = _fs->getCurrentPos(); + _fs->setIntructionParam(tonextcondjmp, 1, _fs->getCurrentPos() - tonextcondjmp); } //condition Lex(); Expression(); Expect(_SC(':')); @@ -1254,16 +1254,16 @@ public: //end condition if(skipcondjmp != -1) { - _fs->SetIntructionParam(skipcondjmp, 1, (_fs->GetCurrentPos() - skipcondjmp)); + _fs->setIntructionParam(skipcondjmp, 1, (_fs->getCurrentPos() - skipcondjmp)); } - tonextcondjmp = _fs->GetCurrentPos(); + tonextcondjmp = _fs->getCurrentPos(); BEGIN_SCOPE(); Statements(); END_SCOPE(); bfirst = false; } if(tonextcondjmp != -1) - _fs->SetIntructionParam(tonextcondjmp, 1, _fs->GetCurrentPos() - tonextcondjmp); + _fs->setIntructionParam(tonextcondjmp, 1, _fs->getCurrentPos() - tonextcondjmp); if(_token == TK_DEFAULT) { Lex(); Expect(_SC(':')); BEGIN_SCOPE(); @@ -1281,17 +1281,17 @@ public: SQObject id; Lex(); id = Expect(TK_IDENTIFIER); _fs->PushTarget(0); - _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(id)); + _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->getConstant(id)); if(_token == TK_DOUBLE_COLON) Emit2ArgsOP(_OP_GET); while(_token == TK_DOUBLE_COLON) { Lex(); id = Expect(TK_IDENTIFIER); - _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->GetConstant(id)); + _fs->AddInstruction(_OP_LOAD, _fs->PushTarget(), _fs->getConstant(id)); if(_token == TK_DOUBLE_COLON) Emit2ArgsOP(_OP_GET); } Expect(_SC('(')); - CreateFunction(id); + createFunction(id); _fs->AddInstruction(_OP_CLOSURE, _fs->PushTarget(), _fs->_functions.size() - 1, 0); EmitDerefOp(_OP_NEWSLOT); _fs->PopTarget(); @@ -1330,7 +1330,7 @@ public: val._unVal.fFloat = _lex._fvalue; break; case TK_STRING_LITERAL: - val = _fs->CreateString(_lex._svalue,_lex._longstr.size()-1); + val = _fs->createString(_lex._svalue,_lex._longstr.size()-1); break; case TK_TRUE: case TK_FALSE: @@ -1365,7 +1365,7 @@ public: SQObject id = Expect(TK_IDENTIFIER); Expect(_SC('{')); - SQObject table = _fs->CreateTable(); + SQObject table = _fs->createTable(); int64_t nval = 0; while(_token != _SC('}')) { SQObject key = Expect(TK_IDENTIFIER); @@ -1395,7 +1395,7 @@ public: _fs->_traps++; if(_fs->_breaktargets.size()) _fs->_breaktargets.top()++; if(_fs->_continuetargets.size()) _fs->_continuetargets.top()++; - int64_t trappos = _fs->GetCurrentPos(); + int64_t trappos = _fs->getCurrentPos(); { BEGIN_SCOPE(); Statement(); @@ -1406,15 +1406,15 @@ public: if(_fs->_breaktargets.size()) _fs->_breaktargets.top()--; if(_fs->_continuetargets.size()) _fs->_continuetargets.top()--; _fs->AddInstruction(_OP_JMP, 0, 0); - int64_t jmppos = _fs->GetCurrentPos(); - _fs->SetIntructionParam(trappos, 1, (_fs->GetCurrentPos() - trappos)); + int64_t jmppos = _fs->getCurrentPos(); + _fs->setIntructionParam(trappos, 1, (_fs->getCurrentPos() - trappos)); Expect(TK_CATCH); Expect(_SC('(')); exid = Expect(TK_IDENTIFIER); Expect(_SC(')')); { BEGIN_SCOPE(); int64_t ex_target = _fs->PushLocalVariable(exid); - _fs->SetIntructionParam(trappos, 0, ex_target); + _fs->setIntructionParam(trappos, 0, ex_target); Statement(); - _fs->SetIntructionParams(jmppos, 0, (_fs->GetCurrentPos() - jmppos), 0); + _fs->setIntructionParams(jmppos, 0, (_fs->getCurrentPos() - jmppos), 0); END_SCOPE(); } } @@ -1422,7 +1422,7 @@ public: { Lex(); Expect(_SC('(')); SQObjectPtr dummy; - CreateFunction(dummy,lambda); + createFunction(dummy,lambda); _fs->AddInstruction(_OP_CLOSURE, _fs->PushTarget(), _fs->_functions.size() - 1, ftype == TK_FUNCTION?0:1); } void ClassExp() @@ -1431,13 +1431,13 @@ public: int64_t attrs = -1; if(_token == TK_EXTENDS) { Lex(); Expression(); - base = _fs->TopTarget(); + base = _fs->topTarget(); } if(_token == TK_ATTR_OPEN) { Lex(); _fs->AddInstruction(_OP_NEWOBJ, _fs->PushTarget(),0,NOT_TABLE); ParseTableOrClass(_SC(','),TK_ATTR_CLOSE); - attrs = _fs->TopTarget(); + attrs = _fs->topTarget(); } Expect(_SC('{')); if(attrs != -1) _fs->PopTarget(); @@ -1476,7 +1476,7 @@ public: Emit2ArgsOP(_OP_INC, diff); } else if(_es.etype==LOCAL) { - int64_t src = _fs->TopTarget(); + int64_t src = _fs->topTarget(); _fs->AddInstruction(_OP_INCL, src, src, 0, diff); } @@ -1488,18 +1488,18 @@ public: } _es = es; } - void CreateFunction(SQObject &name,bool lambda = false) + void createFunction(SQObject &name,bool lambda = false) { SQFuncState *funcstate = _fs->PushChildState(_ss(_vm)); funcstate->_name = name; SQObject paramname; - funcstate->AddParameter(_fs->CreateString(_SC("this"))); + funcstate->AddParameter(_fs->createString(_SC("this"))); funcstate->_sourcename = _sourcename; int64_t defparams = 0; while(_token!=_SC(')')) { if(_token == TK_VARPARAMS) { if(defparams > 0) Error(_SC("function with default parameters cannot have variable number of parameters")); - funcstate->AddParameter(_fs->CreateString(_SC("vargv"))); + funcstate->AddParameter(_fs->createString(_SC("vargv"))); funcstate->_varparams = true; Lex(); if(_token != _SC(')')) Error(_SC("expected ')'")); @@ -1511,7 +1511,7 @@ public: if(_token == _SC('=')) { Lex(); Expression(); - funcstate->AddDefaultParam(_fs->TopTarget()); + funcstate->AddDefaultParam(_fs->topTarget()); defparams++; } else { @@ -1536,7 +1536,7 @@ public: } funcstate->AddLineInfos(_lex._prevtoken == _SC('\n')?_lex._lasttokenline:_lex._currentline, _lineinfo, true); funcstate->AddInstruction(_OP_RETURN, -1); - funcstate->SetStackSize(0); + funcstate->setStacksize(0); SQFunctionProto *func = funcstate->BuildProto(); #ifdef _DEBUG_DUMP @@ -1552,7 +1552,7 @@ public: int64_t pos = funcstate->_unresolvedbreaks.back(); funcstate->_unresolvedbreaks.pop_back(); //set the jmp instruction - funcstate->SetIntructionParams(pos, 0, funcstate->GetCurrentPos() - pos, 0); + funcstate->setIntructionParams(pos, 0, funcstate->getCurrentPos() - pos, 0); ntoresolve--; } } @@ -1562,7 +1562,7 @@ public: int64_t pos = funcstate->_unresolvedcontinues.back(); funcstate->_unresolvedcontinues.pop_back(); //set the jmp instruction - funcstate->SetIntructionParams(pos, 0, targetpos - pos, 0); + funcstate->setIntructionParams(pos, 0, targetpos - pos, 0); ntoresolve--; } } diff --git a/rabbit/sqdebug.cpp b/rabbit/sqdebug.cpp index c528379..2eba343 100644 --- a/rabbit/sqdebug.cpp +++ b/rabbit/sqdebug.cpp @@ -44,7 +44,7 @@ SQRESULT sq_stackinfos(HRABBITVM v, int64_t level, SQStackInfos *si) si->funcname = _stringval(func->_name); if (sq_type(func->_sourcename) == OT_STRING) si->source = _stringval(func->_sourcename); - si->line = func->GetLine(ci._ip); + si->line = func->getLine(ci._ip); } break; case OT_NATIVECLOSURE: @@ -68,7 +68,7 @@ void SQVM::Raise_Error(const SQChar *s, ...) int64_t buffersize = (int64_t)scstrlen(s)+(NUMBER_MAX_CHAR*2); scvsprintf(_sp(sq_rsl(buffersize)),buffersize, s, vl); va_end(vl); - _lasterror = SQString::Create(_ss(this),_spval,-1); + _lasterror = SQString::create(_ss(this),_spval,-1); } void SQVM::Raise_Error(const SQObjectPtr &desc) @@ -82,14 +82,14 @@ SQString *SQVM::PrintObjVal(const SQObjectPtr &o) case OT_STRING: return _string(o); case OT_INTEGER: scsprintf(_sp(sq_rsl(NUMBER_MAX_CHAR+1)),sq_rsl(NUMBER_MAX_CHAR), _PRINT_INT_FMT, _integer(o)); - return SQString::Create(_ss(this), _spval); + return SQString::create(_ss(this), _spval); break; case OT_FLOAT: scsprintf(_sp(sq_rsl(NUMBER_MAX_CHAR+1)), sq_rsl(NUMBER_MAX_CHAR), _SC("%.14g"), _float(o)); - return SQString::Create(_ss(this), _spval); + return SQString::create(_ss(this), _spval); break; default: - return SQString::Create(_ss(this), GetTypeName(o)); + return SQString::create(_ss(this), getTypeName(o)); } } @@ -108,15 +108,15 @@ void SQVM::Raise_CompareError(const SQObject &o1, const SQObject &o2) void SQVM::Raise_ParamTypeError(int64_t nparam,int64_t typemask,int64_t type) { - SQObjectPtr exptypes = SQString::Create(_ss(this), _SC(""), -1); + SQObjectPtr exptypes = SQString::create(_ss(this), _SC(""), -1); int64_t found = 0; for(int64_t i=0; i<16; i++) { int64_t mask = ((int64_t)1) << i; if(typemask & (mask)) { - if(found>0) StringCat(exptypes,SQString::Create(_ss(this), _SC("|"), -1), exptypes); + if(found>0) StringCat(exptypes,SQString::create(_ss(this), _SC("|"), -1), exptypes); found ++; - StringCat(exptypes,SQString::Create(_ss(this), IdType2Name((SQObjectType)mask), -1), exptypes); + StringCat(exptypes,SQString::create(_ss(this), IdType2Name((SQObjectType)mask), -1), exptypes); } } Raise_Error(_SC("parameter %d has an invalid type '%s' ; expected: '%s'"), nparam, IdType2Name((SQObjectType)type), _stringval(exptypes)); diff --git a/rabbit/sqfuncproto.hpp b/rabbit/sqfuncproto.hpp index 6051aef..73f631c 100644 --- a/rabbit/sqfuncproto.hpp +++ b/rabbit/sqfuncproto.hpp @@ -64,14 +64,14 @@ typedef sqvector SQLineInfoVec; +(localinf*sizeof(SQLocalVarInfo))+(defparams*sizeof(int64_t))) -struct SQFunctionProto : public SQRefCounted +struct SQFunctionProto : public rabbit::RefCounted { private: SQFunctionProto(SQSharedState *ss); ~SQFunctionProto(); public: - static SQFunctionProto *Create(SQSharedState *ss,int64_t ninstructions, + static SQFunctionProto *create(SQSharedState *ss,int64_t ninstructions, int64_t nliterals,int64_t nparameters, int64_t nfunctions,int64_t noutervalues, int64_t nlineinfos,int64_t nlocalvarinfos,int64_t ndefaultparams) @@ -104,7 +104,7 @@ public: _CONSTRUCT_VECTOR(SQLocalVarInfo,f->_nlocalvarinfos,f->_localvarinfos); return f; } - void Release(){ + void release(){ _DESTRUCT_VECTOR(SQObjectPtr,_nliterals,_literals); _DESTRUCT_VECTOR(SQObjectPtr,_nparameters,_parameters); _DESTRUCT_VECTOR(SQObjectPtr,_nfunctions,_functions); @@ -116,8 +116,8 @@ public: sq_vm_free(this,size); } - const SQChar* GetLocal(SQVM *v,uint64_t stackbase,uint64_t nseq,uint64_t nop); - int64_t GetLine(SQInstruction *curr); + const SQChar* getLocal(SQVM *v,uint64_t stackbase,uint64_t nseq,uint64_t nop); + int64_t getLine(SQInstruction *curr); bool Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write); static bool Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret); SQObjectPtr _sourcename; diff --git a/rabbit/sqfuncstate.cpp b/rabbit/sqfuncstate.cpp index f7161c2..0678a59 100644 --- a/rabbit/sqfuncstate.cpp +++ b/rabbit/sqfuncstate.cpp @@ -87,15 +87,15 @@ void DumpLiteral(SQObjectPtr &o) case OT_FLOAT: scprintf(_SC("{%f}"),_float(o));break; case OT_INTEGER: scprintf(_SC("{") _PRINT_INT_FMT _SC("}"),_integer(o));break; case OT_BOOL: scprintf(_SC("%s"),_integer(o)?_SC("true"):_SC("false"));break; - default: scprintf(_SC("(%s %p)"),GetTypeName(o),(void*)_rawval(o));break; break; //shut up compiler + default: scprintf(_SC("(%s %p)"),getTypeName(o),(void*)_rawval(o));break; break; //shut up compiler } } SQFuncState::SQFuncState(SQSharedState *ss,SQFuncState *parent,CompilerErrorFunc efunc,void *ed) { _nliterals = 0; - _literals = SQTable::Create(ss,0); - _strings = SQTable::Create(ss,0); + _literals = SQTable::create(ss,0); + _strings = SQTable::create(ss,0); _sharedstate = ss; _lastline = 0; _optimization = true; @@ -131,7 +131,7 @@ void SQFuncState::Dump(SQFunctionProto *func) int64_t idx; SQObjectPtrVec templiterals; templiterals.resize(_nliterals); - while((idx=_table(_literals)->Next(false,refidx,key,val))!=-1) { + while((idx=_table(_literals)->next(false,refidx,key,val))!=-1) { refidx=idx; templiterals[_integer(val)]=key; } @@ -176,7 +176,7 @@ void SQFuncState::Dump(SQFunctionProto *func) else { int64_t refidx; SQObjectPtr val,key,refo; - while(((refidx=_table(_literals)->Next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) { + while(((refidx=_table(_literals)->next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) { refo = refidx; } DumpLiteral(key); @@ -192,7 +192,7 @@ void SQFuncState::Dump(SQFunctionProto *func) else { int64_t refidx; SQObjectPtr val,key,refo; - while(((refidx=_table(_literals)->Next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) { + while(((refidx=_table(_literals)->next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) { refo = refidx; } DumpLiteral(key); @@ -217,20 +217,20 @@ void SQFuncState::Dump(SQFunctionProto *func) } #endif -int64_t SQFuncState::GetNumericConstant(const int64_t cons) +int64_t SQFuncState::getNumericConstant(const int64_t cons) { - return GetConstant(SQObjectPtr(cons)); + return getConstant(SQObjectPtr(cons)); } -int64_t SQFuncState::GetNumericConstant(const float_t cons) +int64_t SQFuncState::getNumericConstant(const float_t cons) { - return GetConstant(SQObjectPtr(cons)); + return getConstant(SQObjectPtr(cons)); } -int64_t SQFuncState::GetConstant(const SQObject &cons) +int64_t SQFuncState::getConstant(const SQObject &cons) { SQObjectPtr val; - if(!_table(_literals)->Get(cons,val)) + if(!_table(_literals)->get(cons,val)) { val = _nliterals; _table(_literals)->NewSlot(cons,val); @@ -243,7 +243,7 @@ int64_t SQFuncState::GetConstant(const SQObject &cons) return _integer(val); } -void SQFuncState::SetIntructionParams(int64_t pos,int64_t arg0,int64_t arg1,int64_t arg2,int64_t arg3) +void SQFuncState::setIntructionParams(int64_t pos,int64_t arg0,int64_t arg1,int64_t arg2,int64_t arg3) { _instructions[pos]._arg0=(unsigned char)*((uint64_t *)&arg0); _instructions[pos]._arg1=(int32_t)*((uint64_t *)&arg1); @@ -251,7 +251,7 @@ void SQFuncState::SetIntructionParams(int64_t pos,int64_t arg0,int64_t arg1,int6 _instructions[pos]._arg3=(unsigned char)*((uint64_t *)&arg3); } -void SQFuncState::SetIntructionParam(int64_t pos,int64_t arg,int64_t val) +void SQFuncState::setIntructionParam(int64_t pos,int64_t arg,int64_t val) { switch(arg){ case 0:_instructions[pos]._arg0=(unsigned char)*((uint64_t *)&val);break; @@ -283,11 +283,11 @@ int64_t SQFuncState::PushTarget(int64_t n) return n; } -int64_t SQFuncState::GetUpTarget(int64_t n){ +int64_t SQFuncState::getUpTarget(int64_t n){ return _targetstack[((_targetstack.size()-1)-n)]; } -int64_t SQFuncState::TopTarget(){ +int64_t SQFuncState::topTarget(){ return _targetstack.back(); } int64_t SQFuncState::PopTarget() @@ -302,7 +302,7 @@ int64_t SQFuncState::PopTarget() return npos; } -int64_t SQFuncState::GetStackSize() +int64_t SQFuncState::getStacksize() { return _vlocals.size(); } @@ -321,7 +321,7 @@ int64_t SQFuncState::CountOuters(int64_t stacksize) return outers; } -void SQFuncState::SetStackSize(int64_t n) +void SQFuncState::setStacksize(int64_t n) { int64_t size=_vlocals.size(); while(size>n){ @@ -331,7 +331,7 @@ void SQFuncState::SetStackSize(int64_t n) if(lvi._end_op == UINT_MINUS_ONE) { //this means is an outer _outers--; } - lvi._end_op = GetCurrentPos(); + lvi._end_op = getCurrentPos(); _localvarinfos.push_back(lvi); } _vlocals.pop_back(); @@ -341,7 +341,7 @@ void SQFuncState::SetStackSize(int64_t n) bool SQFuncState::IsConstant(const SQObject &name,SQObject &e) { SQObjectPtr val; - if(_table(_sharedstate->_consts)->Get(name,val)) { + if(_table(_sharedstate->_consts)->get(name,val)) { e = val; return true; } @@ -360,7 +360,7 @@ int64_t SQFuncState::PushLocalVariable(const SQObject &name) int64_t pos=_vlocals.size(); SQLocalVarInfo lvi; lvi._name=name; - lvi._start_op=GetCurrentPos()+1; + lvi._start_op=getCurrentPos()+1; lvi._pos=_vlocals.size(); _vlocals.push_back(lvi); if(_vlocals.size()>((uint64_t)_stacksize))_stacksize=_vlocals.size(); @@ -369,7 +369,7 @@ int64_t SQFuncState::PushLocalVariable(const SQObject &name) -int64_t SQFuncState::GetLocalVariable(const SQObject &name) +int64_t SQFuncState::getLocalVariable(const SQObject &name) { int64_t locals=_vlocals.size(); while(locals>=1){ @@ -389,7 +389,7 @@ void SQFuncState::MarkLocalAsOuter(int64_t pos) _outers++; } -int64_t SQFuncState::GetOuterVariable(const SQObject &name) +int64_t SQFuncState::getOuterVariable(const SQObject &name) { int64_t outers = _outervalues.size(); for(int64_t i = 0; iGetLocalVariable(name); + pos = _parent->getLocalVariable(name); if(pos == -1) { - pos = _parent->GetOuterVariable(name); + pos = _parent->getOuterVariable(name); if(pos != -1) { _outervalues.push_back(SQOuterVar(name,SQObjectPtr(int64_t(pos)),otOUTER)); //local return _outervalues.size() - 1; @@ -427,7 +427,7 @@ void SQFuncState::AddLineInfos(int64_t line,bool lineop,bool force) { if(_lastline!=line || force){ SQLineInfo li; - li._line=line;li._op=(GetCurrentPos()+1); + li._line=line;li._op=(getCurrentPos()+1); if(lineop)AddInstruction(_OP_LINE,0,line); if(_lastline!=line) { _lineinfos.push_back(li); @@ -584,16 +584,16 @@ void SQFuncState::AddInstruction(SQInstruction &i) _instructions.push_back(i); } -SQObject SQFuncState::CreateString(const SQChar *s,int64_t len) +SQObject SQFuncState::createString(const SQChar *s,int64_t len) { - SQObjectPtr ns(SQString::Create(_sharedstate,s,len)); + SQObjectPtr ns(SQString::create(_sharedstate,s,len)); _table(_strings)->NewSlot(ns,(int64_t)1); return ns; } -SQObject SQFuncState::CreateTable() +SQObject SQFuncState::createTable() { - SQObjectPtr nt(SQTable::Create(_sharedstate,0)); + SQObjectPtr nt(SQTable::create(_sharedstate,0)); _table(_strings)->NewSlot(nt,(int64_t)1); return nt; } @@ -601,7 +601,7 @@ SQObject SQFuncState::CreateTable() SQFunctionProto *SQFuncState::BuildProto() { - SQFunctionProto *f=SQFunctionProto::Create(_ss,_instructions.size(), + SQFunctionProto *f=SQFunctionProto::create(_ss,_instructions.size(), _nliterals,_parameters.size(),_functions.size(),_outervalues.size(), _lineinfos.size(),_localvarinfos.size(),_defaultparams.size()); @@ -613,7 +613,7 @@ SQFunctionProto *SQFuncState::BuildProto() f->_bgenerator = _bgenerator; f->_name = _name; - while((idx=_table(_literals)->Next(false,refidx,key,val))!=-1) { + while((idx=_table(_literals)->next(false,refidx,key,val))!=-1) { f->_literals[_integer(val)]=key; refidx=idx; } diff --git a/rabbit/sqfuncstate.hpp b/rabbit/sqfuncstate.hpp index 23226e0..2f39d92 100644 --- a/rabbit/sqfuncstate.hpp +++ b/rabbit/sqfuncstate.hpp @@ -21,38 +21,38 @@ struct SQFuncState void PopChildState(); void AddInstruction(SQOpcode _op,int64_t arg0=0,int64_t arg1=0,int64_t arg2=0,int64_t arg3=0){SQInstruction i(_op,arg0,arg1,arg2,arg3);AddInstruction(i);} void AddInstruction(SQInstruction &i); - void SetIntructionParams(int64_t pos,int64_t arg0,int64_t arg1,int64_t arg2=0,int64_t arg3=0); - void SetIntructionParam(int64_t pos,int64_t arg,int64_t val); - SQInstruction &GetInstruction(int64_t pos){return _instructions[pos];} + void setIntructionParams(int64_t pos,int64_t arg0,int64_t arg1,int64_t arg2=0,int64_t arg3=0); + void setIntructionParam(int64_t pos,int64_t arg,int64_t val); + SQInstruction &getInstruction(int64_t pos){return _instructions[pos];} void PopInstructions(int64_t size){for(int64_t i=0;i _childstates; - int64_t GetConstant(const SQObject &cons); + int64_t getConstant(const SQObject &cons); private: CompilerErrorFunc _errfunc; void *_errtarget; diff --git a/rabbit/sqlexer.cpp b/rabbit/sqlexer.cpp index 487b94b..c6df1b9 100644 --- a/rabbit/sqlexer.cpp +++ b/rabbit/sqlexer.cpp @@ -17,16 +17,16 @@ #define CUR_CHAR (_currdata) #define RETURN_TOKEN(t) { _prevtoken = _curtoken; _curtoken = t; return t;} #define IS_EOB() (CUR_CHAR <= RABBIT_EOB) -#define NEXT() {Next();_currentcolumn++;} +#define NEXT() {next();_currentcolumn++;} #define INIT_TEMP_STRING() { _longstr.resize(0);} #define APPEND_CHAR(c) { _longstr.push_back(c);} #define TERMINATE_BUFFER() {_longstr.push_back(_SC('\0'));} -#define ADD_KEYWORD(key,id) _keywords->NewSlot( SQString::Create(ss, _SC(#key)) ,int64_t(id)) +#define ADD_KEYWORD(key,id) _keywords->NewSlot( SQString::create(ss, _SC(#key)) ,int64_t(id)) SQLexer::SQLexer(){} SQLexer::~SQLexer() { - _keywords->Release(); + _keywords->release(); } void SQLexer::Init(SQSharedState *ss, SQLEXREADFUNC rg, SQUserPointer up,CompilerErrorFunc efunc,void *ed) @@ -34,7 +34,7 @@ void SQLexer::Init(SQSharedState *ss, SQLEXREADFUNC rg, SQUserPointer up,Compile _errfunc = efunc; _errtarget = ed; _sharedstate = ss; - _keywords = SQTable::Create(ss, 37); + _keywords = SQTable::create(ss, 37); ADD_KEYWORD(while, TK_WHILE); ADD_KEYWORD(do, TK_DO); ADD_KEYWORD(if, TK_IF); @@ -81,7 +81,7 @@ void SQLexer::Init(SQSharedState *ss, SQLEXREADFUNC rg, SQUserPointer up,Compile _currentcolumn = 0; _prevtoken = -1; _reached_eof = SQFalse; - Next(); + next(); } void SQLexer::Error(const SQChar *err) @@ -89,7 +89,7 @@ void SQLexer::Error(const SQChar *err) _errfunc(_errtarget,err); } -void SQLexer::Next() +void SQLexer::next() { int64_t t = _readf(_up); if(t > MAX_CHAR) Error(_SC("Invalid character")); @@ -105,7 +105,7 @@ const SQChar *SQLexer::Tok2Str(int64_t tok) { SQObjectPtr itr, key, val; int64_t nitr; - while((nitr = _keywords->Next(false,itr, key, val)) != -1) { + while((nitr = _keywords->next(false,itr, key, val)) != -1) { itr = (int64_t)nitr; if(((int64_t)_integer(val)) == tok) return _stringval(key); @@ -285,10 +285,10 @@ int64_t SQLexer::Lex() return 0; } -int64_t SQLexer::GetIDType(const SQChar *s,int64_t len) +int64_t SQLexer::getIDType(const SQChar *s,int64_t len) { SQObjectPtr t; - if(_keywords->GetStr(s,len, t)) { + if(_keywords->getStr(s,len, t)) { return int64_t(_integer(t)); } return TK_IDENTIFIER; @@ -560,7 +560,7 @@ int64_t SQLexer::ReadID() NEXT(); } while(scisalnum(CUR_CHAR) || CUR_CHAR == _SC('_')); TERMINATE_BUFFER(); - res = GetIDType(&_longstr[0],_longstr.size() - 1); + res = getIDType(&_longstr[0],_longstr.size() - 1); if(res == TK_IDENTIFIER || res == TK_CONSTRUCTOR) { _svalue = &_longstr[0]; } diff --git a/rabbit/sqlexer.hpp b/rabbit/sqlexer.hpp index 5a8a782..41d52a2 100644 --- a/rabbit/sqlexer.hpp +++ b/rabbit/sqlexer.hpp @@ -22,13 +22,13 @@ struct SQLexer int64_t Lex(); const SQChar *Tok2Str(int64_t tok); private: - int64_t GetIDType(const SQChar *s,int64_t len); + int64_t getIDType(const SQChar *s,int64_t len); int64_t ReadString(int64_t ndelim,bool verbatim); int64_t ReadNumber(); void LexBlockComment(); void LexLineComment(); int64_t ReadID(); - void Next(); + void next(); #ifdef SQUNICODE #if WCHAR_SIZE == 2 int64_t AddUTF16(uint64_t ch); diff --git a/rabbit/sqobject.cpp b/rabbit/sqobject.cpp index fb74409..ea65863 100644 --- a/rabbit/sqobject.cpp +++ b/rabbit/sqobject.cpp @@ -8,7 +8,7 @@ #include #include #include -#include +#include #include #include #include @@ -45,25 +45,25 @@ const SQChar *IdType2Name(SQObjectType type) } } -const SQChar *GetTypeName(const SQObjectPtr &obj1) +const SQChar *getTypeName(const SQObjectPtr &obj1) { return IdType2Name(sq_type(obj1)); } -SQString *SQString::Create(SQSharedState *ss,const SQChar *s,int64_t len) +SQString *SQString::create(SQSharedState *ss,const SQChar *s,int64_t len) { SQString *str=ADD_STRING(ss,s,len); return str; } -void SQString::Release() +void SQString::release() { REMOVE_STRING(_sharedstate,this); } -int64_t SQString::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval) +int64_t SQString::next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval) { - int64_t idx = (int64_t)TranslateIndex(refpos); + int64_t idx = (int64_t)translateIndex(refpos); while(idx < _len){ outkey = (int64_t)idx; outval = (int64_t)((uint64_t)_val[idx]); @@ -74,7 +74,7 @@ int64_t SQString::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectP return -1; } -uint64_t TranslateIndex(const SQObjectPtr &idx) +uint64_t translateIndex(const SQObjectPtr &idx) { switch(sq_type(idx)){ case OT_NULL: @@ -86,42 +86,16 @@ uint64_t TranslateIndex(const SQObjectPtr &idx) return 0; } -SQWeakRef *SQRefCounted::GetWeakRef(SQObjectType type) -{ - if(!_weakref) { - sq_new(_weakref,SQWeakRef); -#if defined(SQUSEDOUBLE) && !defined(_SQ64) - _weakref->_obj._unVal.raw = 0; //clean the whole union on 32 bits with double -#endif - _weakref->_obj._type = type; - _weakref->_obj._unVal.pRefCounted = this; - } - return _weakref; -} -SQRefCounted::~SQRefCounted() -{ - if(_weakref) { - _weakref->_obj._type = OT_NULL; - _weakref->_obj._unVal.pRefCounted = NULL; - } -} -void SQWeakRef::Release() { - if(ISREFCOUNTED(_obj._type)) { - _obj._unVal.pRefCounted->_weakref = NULL; - } - sq_delete(this,SQWeakRef); -} - -bool SQDelegable::GetMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res) { +bool SQDelegable::getMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res) { if(_delegate) { - return _delegate->Get((*_ss(v)->_metamethods)[mm],res); + return _delegate->get((*_ss(v)->_metamethods)[mm],res); } return false; } -bool SQDelegable::SetDelegate(SQTable *mt) +bool SQDelegable::setDelegate(SQTable *mt) { SQTable *temp = mt; if(temp == this) return false; @@ -130,7 +104,7 @@ bool SQDelegable::SetDelegate(SQTable *mt) temp = temp->_delegate; } if (mt) __ObjAddRef(mt); - __ObjRelease(_delegate); + __Objrelease(_delegate); _delegate = mt; return true; } @@ -143,7 +117,7 @@ bool SQGenerator::Yield(SQVM *v,int64_t target) _stack.resize(size); SQObject _this = v->_stack[v->_stackbase]; - _stack._vals[0] = ISREFCOUNTED(sq_type(_this)) ? SQObjectPtr(_refcounted(_this)->GetWeakRef(sq_type(_this))) : _this; + _stack._vals[0] = ISREFCOUNTED(sq_type(_this)) ? SQObjectPtr(_refcounted(_this)->getWeakRef(sq_type(_this))) : _this; for(int64_t n =1; n_stack[v->_stackbase+n]; } @@ -209,14 +183,14 @@ bool SQGenerator::Resume(SQVM *v,SQObjectPtr &dest) return true; } -void SQArray::Extend(const SQArray *a){ +void rabbit::Array::extend(const rabbit::Array *a){ int64_t xlen; - if((xlen=a->Size())) + if((xlen=a->size())) for(int64_t i=0;i_values[i]); + append((*a)[i]); } -const SQChar* SQFunctionProto::GetLocal(SQVM *vm,uint64_t stackbase,uint64_t nseq,uint64_t nop) +const SQChar* SQFunctionProto::getLocal(SQVM *vm,uint64_t stackbase,uint64_t nseq,uint64_t nop) { uint64_t nvars=_nlocalvarinfos; const SQChar *res=NULL; @@ -237,7 +211,7 @@ const SQChar* SQFunctionProto::GetLocal(SQVM *vm,uint64_t stackbase,uint64_t nse } -int64_t SQFunctionProto::GetLine(SQInstruction *curr) +int64_t SQFunctionProto::getLine(SQInstruction *curr) { int64_t op = (int64_t)(curr-_instructions); int64_t line=_lineinfos[0]._line; @@ -273,9 +247,9 @@ int64_t SQFunctionProto::GetLine(SQInstruction *curr) SQClosure::~SQClosure() { - __ObjRelease(_root); - __ObjRelease(_env); - __ObjRelease(_base); + __Objrelease(_root); + __Objrelease(_env); + __Objrelease(_base); } #define _CHECK_IO(exp) { if(!exp)return false; } @@ -330,7 +304,7 @@ bool WriteObject(HRABBITVM v,SQUserPointer up,SQWRITEFUNC write,SQObjectPtr &o) case OT_NULL: break; default: - v->Raise_Error(_SC("cannot serialize a %s"),GetTypeName(o)); + v->Raise_Error(_SC("cannot serialize a %s"),getTypeName(o)); return false; } return true; @@ -345,8 +319,8 @@ bool ReadObject(HRABBITVM v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &o) case OT_STRING:{ int64_t len; _CHECK_IO(SafeRead(v,read,up,&len,sizeof(int64_t))); - _CHECK_IO(SafeRead(v,read,up,_ss(v)->GetScratchPad(sq_rsl(len)),sq_rsl(len))); - o=SQString::Create(_ss(v),_ss(v)->GetScratchPad(-1),len); + _CHECK_IO(SafeRead(v,read,up,_ss(v)->getScratchPad(sq_rsl(len)),sq_rsl(len))); + o=SQString::create(_ss(v),_ss(v)->getScratchPad(-1),len); } break; case OT_INTEGER:{ @@ -391,7 +365,7 @@ bool SQClosure::Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret) SQObjectPtr func; _CHECK_IO(SQFunctionProto::Load(v,up,read,func)); _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_TAIL)); - ret = SQClosure::Create(_ss(v),_funcproto(func),_table(v->_roottable)->GetWeakRef(OT_TABLE)); + ret = SQClosure::create(_ss(v),_funcproto(func),_table(v->_roottable)->getWeakRef(OT_TABLE)); //FIXME: load an root for this closure return true; } @@ -491,7 +465,7 @@ bool SQFunctionProto::Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr _CHECK_IO(SafeRead(v,read,up, &nfunctions, sizeof(nfunctions))); - SQFunctionProto *f = SQFunctionProto::Create(NULL,ninstructions,nliterals,nparameters, + SQFunctionProto *f = SQFunctionProto::create(NULL,ninstructions,nliterals,nparameters, nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams); SQObjectPtr proto = f; //gets a ref in case of failure f->_sourcename = sourcename; diff --git a/rabbit/sqobject.hpp b/rabbit/sqobject.hpp index 397d079..6ab20a2 100644 --- a/rabbit/sqobject.hpp +++ b/rabbit/sqobject.hpp @@ -8,6 +8,8 @@ #pragma once #include +#include +#include #ifdef _SQ64 #define UINT_MINUS_ONE (0xFFFFFFFFFFFFFFFF) @@ -89,22 +91,6 @@ enum SQMetaMethod{ #define MINPOWER2 4 -struct SQRefCounted -{ - uint64_t _uiRef; - struct SQWeakRef *_weakref; - SQRefCounted() { _uiRef = 0; _weakref = NULL; } - virtual ~SQRefCounted(); - SQWeakRef *GetWeakRef(SQObjectType type); - virtual void Release()=0; - -}; - -struct SQWeakRef : SQRefCounted -{ - void Release(); - SQObject _obj; -}; #define _realval(o) (sq_type((o)) != OT_WEAKREF?(SQObject)o:_weakref(o)->_obj) @@ -112,25 +98,26 @@ struct SQObjectPtr; #define __AddRef(type,unval) if(ISREFCOUNTED(type)) \ { \ - unval.pRefCounted->_uiRef++; \ + unval.pRefCounted->refCountIncrement(); \ } -#define __Release(type,unval) if(ISREFCOUNTED(type) && ((--unval.pRefCounted->_uiRef)==0)) \ +#define __release(type,unval) if(ISREFCOUNTED(type) && (unval.pRefCounted->refCountDecrement()==0)) \ { \ - unval.pRefCounted->Release(); \ + unval.pRefCounted->release(); \ } -#define __ObjRelease(obj) { \ +#define __Objrelease(obj) { \ if((obj)) { \ - (obj)->_uiRef--; \ - if((obj)->_uiRef == 0) \ - (obj)->Release(); \ + auto val = (obj)->refCountDecrement(); \ + if(val == 0) { \ + (obj)->release(); \ + } \ (obj) = NULL; \ } \ } #define __ObjAddRef(obj) { \ - (obj)->_uiRef++; \ + (obj)->refCountIncrement(); \ } #define is_delegable(t) (sq_type(t)&SQOBJECT_DELEGABLE) @@ -176,7 +163,7 @@ struct SQObjectPtr; _type=type; \ _unVal.sym = x; \ assert(_unVal.pTable); \ - _unVal.pRefCounted->_uiRef++; \ + _unVal.pRefCounted->refCountIncrement(); \ } \ inline SQObjectPtr& operator=(_class *x) \ { \ @@ -187,8 +174,8 @@ struct SQObjectPtr; _type = type; \ SQ_REFOBJECT_INIT() \ _unVal.sym = x; \ - _unVal.pRefCounted->_uiRef++; \ - __Release(tOldType,unOldVal); \ + _unVal.pRefCounted->refCountIncrement(); \ + __release(tOldType,unOldVal); \ return *this; \ } @@ -201,7 +188,7 @@ struct SQObjectPtr; } \ inline SQObjectPtr& operator=(_class x) \ { \ - __Release(_type,_unVal); \ + __release(_type,_unVal); \ _type = type; \ SQ_OBJECT_RAWINIT() \ _unVal.sym = x; \ @@ -230,14 +217,14 @@ struct SQObjectPtr : public SQObject _REF_TYPE_DECL(OT_TABLE,SQTable,pTable) _REF_TYPE_DECL(OT_CLASS,SQClass,pClass) _REF_TYPE_DECL(OT_INSTANCE,SQInstance,pInstance) - _REF_TYPE_DECL(OT_ARRAY,SQArray,pArray) + _REF_TYPE_DECL(OT_ARRAY,rabbit::Array,pArray) _REF_TYPE_DECL(OT_CLOSURE,SQClosure,pClosure) _REF_TYPE_DECL(OT_NATIVECLOSURE,SQNativeClosure,pNativeClosure) _REF_TYPE_DECL(OT_OUTER,SQOuter,pOuter) _REF_TYPE_DECL(OT_GENERATOR,SQGenerator,pGenerator) _REF_TYPE_DECL(OT_STRING,SQString,pString) _REF_TYPE_DECL(OT_USERDATA,rabbit::UserData,pUserData) - _REF_TYPE_DECL(OT_WEAKREF,SQWeakRef,pWeakRef) + _REF_TYPE_DECL(OT_WEAKREF,rabbit::WeakRef,pWeakRef) _REF_TYPE_DECL(OT_THREAD,SQVM,pThread) _REF_TYPE_DECL(OT_FUNCPROTO,SQFunctionProto,pFunctionProto) @@ -253,7 +240,7 @@ struct SQObjectPtr : public SQObject } inline SQObjectPtr& operator=(bool b) { - __Release(_type,_unVal); + __release(_type,_unVal); SQ_OBJECT_RAWINIT() _type = OT_BOOL; _unVal.nInteger = b?1:0; @@ -262,7 +249,7 @@ struct SQObjectPtr : public SQObject ~SQObjectPtr() { - __Release(_type,_unVal); + __release(_type,_unVal); } inline SQObjectPtr& operator=(const SQObjectPtr& obj) @@ -274,7 +261,7 @@ struct SQObjectPtr : public SQObject _unVal = obj._unVal; _type = obj._type; __AddRef(_type,_unVal); - __Release(tOldType,unOldVal); + __release(tOldType,unOldVal); return *this; } inline SQObjectPtr& operator=(const SQObject& obj) @@ -286,7 +273,7 @@ struct SQObjectPtr : public SQObject _unVal = obj._unVal; _type = obj._type; __AddRef(_type,_unVal); - __Release(tOldType,unOldVal); + __release(tOldType,unOldVal); return *this; } inline void Null() @@ -295,7 +282,7 @@ struct SQObjectPtr : public SQObject SQObjectValue unOldVal = _unVal; _type = OT_NULL; _unVal.raw = (SQRawObjectVal)NULL; - __Release(tOldType ,unOldVal); + __release(tOldType ,unOldVal); } private: SQObjectPtr(const SQChar *){} //safety @@ -313,16 +300,16 @@ inline void _Swap(SQObject &a,SQObject &b) } -struct SQDelegable : public SQRefCounted { - bool SetDelegate(SQTable *m); - virtual bool GetMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res); +struct SQDelegable : public rabbit::RefCounted { + bool setDelegate(SQTable *m); + virtual bool getMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res); SQTable *_delegate; }; -uint64_t TranslateIndex(const SQObjectPtr &idx); +uint64_t translateIndex(const SQObjectPtr &idx); typedef sqvector SQObjectPtrVec; typedef sqvector SQIntVec; -const SQChar *GetTypeName(const SQObjectPtr &obj1); +const SQChar *getTypeName(const SQObjectPtr &obj1); const SQChar *IdType2Name(SQObjectType type); diff --git a/rabbit/sqopcodes.hpp b/rabbit/sqopcodes.hpp index 5ec5c52..8c0d732 100644 --- a/rabbit/sqopcodes.hpp +++ b/rabbit/sqopcodes.hpp @@ -33,7 +33,7 @@ enum NewObjectType { NOT_CLASS = 2 }; -enum AppendArrayType { +enum appendArrayType { AAT_STACK = 0, AAT_LITERAL = 1, AAT_INT = 2, diff --git a/rabbit/sqstate.cpp b/rabbit/sqstate.cpp index 2557a4b..06ecef7 100644 --- a/rabbit/sqstate.cpp +++ b/rabbit/sqstate.cpp @@ -12,7 +12,7 @@ #include #include #include -#include +#include #include #include @@ -28,11 +28,11 @@ SQSharedState::SQSharedState() } #define newsysstring(s) { \ - _systemstrings->push_back(SQString::Create(this,s)); \ + _systemstrings->push_back(SQString::create(this,s)); \ } #define newmetamethod(s) { \ - _metamethods->push_back(SQString::Create(this,s)); \ + _metamethods->push_back(SQString::create(this,s)); \ _table(_metamethodsmap)->NewSlot(_metamethods->back(),(int64_t)(_metamethods->size()-1)); \ } @@ -77,17 +77,17 @@ bool CompileTypemask(SQIntVec &res,const SQChar *typemask) return true; } -SQTable *CreateDefaultDelegate(SQSharedState *ss,const SQRegFunction *funcz) +SQTable *createDefaultDelegate(SQSharedState *ss,const SQRegFunction *funcz) { int64_t i=0; - SQTable *t=SQTable::Create(ss,0); + SQTable *t=SQTable::create(ss,0); while(funcz[i].name!=0){ - SQNativeClosure *nc = SQNativeClosure::Create(ss,funcz[i].f,0); + SQNativeClosure *nc = SQNativeClosure::create(ss,funcz[i].f,0); nc->_nparamscheck = funcz[i].nparamscheck; - nc->_name = SQString::Create(ss,funcz[i].name); + nc->_name = SQString::create(ss,funcz[i].name); if(funcz[i].typemask && !CompileTypemask(nc->_typecheck,funcz[i].typemask)) return NULL; - t->NewSlot(SQString::Create(ss,funcz[i].name),nc); + t->NewSlot(SQString::create(ss,funcz[i].name),nc); i++; } return t; @@ -102,7 +102,7 @@ void SQSharedState::Init() sq_new(_metamethods,SQObjectPtrVec); sq_new(_systemstrings,SQObjectPtrVec); sq_new(_types,SQObjectPtrVec); - _metamethodsmap = SQTable::Create(this,MT_LAST-1); + _metamethodsmap = SQTable::create(this,MT_LAST-1); //adding type strings to avoid memory trashing //types names newsysstring(_SC("null")); @@ -140,19 +140,19 @@ void SQSharedState::Init() newmetamethod(MM_NEWMEMBER); newmetamethod(MM_INHERITED); - _constructoridx = SQString::Create(this,_SC("constructor")); - _registry = SQTable::Create(this,0); - _consts = SQTable::Create(this,0); - _table_default_delegate = CreateDefaultDelegate(this,_table_default_delegate_funcz); - _array_default_delegate = CreateDefaultDelegate(this,_array_default_delegate_funcz); - _string_default_delegate = CreateDefaultDelegate(this,_string_default_delegate_funcz); - _number_default_delegate = CreateDefaultDelegate(this,_number_default_delegate_funcz); - _closure_default_delegate = CreateDefaultDelegate(this,_closure_default_delegate_funcz); - _generator_default_delegate = CreateDefaultDelegate(this,_generator_default_delegate_funcz); - _thread_default_delegate = CreateDefaultDelegate(this,_thread_default_delegate_funcz); - _class_default_delegate = CreateDefaultDelegate(this,_class_default_delegate_funcz); - _instance_default_delegate = CreateDefaultDelegate(this,_instance_default_delegate_funcz); - _weakref_default_delegate = CreateDefaultDelegate(this,_weakref_default_delegate_funcz); + _constructoridx = SQString::create(this,_SC("constructor")); + _registry = SQTable::create(this,0); + _consts = SQTable::create(this,0); + _table_default_delegate = createDefaultDelegate(this,_table_default_delegate_funcz); + _array_default_delegate = createDefaultDelegate(this,_array_default_delegate_funcz); + _string_default_delegate = createDefaultDelegate(this,_string_default_delegate_funcz); + _number_default_delegate = createDefaultDelegate(this,_number_default_delegate_funcz); + _closure_default_delegate = createDefaultDelegate(this,_closure_default_delegate_funcz); + _generator_default_delegate = createDefaultDelegate(this,_generator_default_delegate_funcz); + _thread_default_delegate = createDefaultDelegate(this,_thread_default_delegate_funcz); + _class_default_delegate = createDefaultDelegate(this,_class_default_delegate_funcz); + _instance_default_delegate = createDefaultDelegate(this,_instance_default_delegate_funcz); + _weakref_default_delegate = createDefaultDelegate(this,_weakref_default_delegate_funcz); } SQSharedState::~SQSharedState() @@ -191,19 +191,19 @@ SQSharedState::~SQSharedState() } -int64_t SQSharedState::GetMetaMethodIdxByName(const SQObjectPtr &name) +int64_t SQSharedState::getMetaMethodIdxByName(const SQObjectPtr &name) { if(sq_type(name) != OT_STRING) return -1; SQObjectPtr ret; - if(_table(_metamethodsmap)->Get(name,ret)) { + if(_table(_metamethodsmap)->get(name,ret)) { return _integer(ret); } return -1; } -SQChar* SQSharedState::GetScratchPad(int64_t size) +SQChar* SQSharedState::getScratchPad(int64_t size) { int64_t newsize; if(size>0) { @@ -245,24 +245,24 @@ void RefTable::AddRef(SQObject &obj) { SQHash mainpos; RefNode *prev; - RefNode *ref = Get(obj,mainpos,&prev,true); + RefNode *ref = get(obj,mainpos,&prev,true); ref->refs++; } -uint64_t RefTable::GetRefCount(SQObject &obj) +uint64_t RefTable::getRefCount(SQObject &obj) { SQHash mainpos; RefNode *prev; - RefNode *ref = Get(obj,mainpos,&prev,true); + RefNode *ref = get(obj,mainpos,&prev,true); return ref->refs; } -SQBool RefTable::Release(SQObject &obj) +SQBool RefTable::release(SQObject &obj) { SQHash mainpos; RefNode *prev; - RefNode *ref = Get(obj,mainpos,&prev,false); + RefNode *ref = get(obj,mainpos,&prev,false); if(ref) { if(--ref->refs == 0) { SQObjectPtr o = ref->obj; @@ -286,7 +286,7 @@ SQBool RefTable::Release(SQObject &obj) return SQFalse; } -void RefTable::Resize(uint64_t size) +void RefTable::resize(uint64_t size) { RefNode **oldbucks = _buckets; RefNode *t = _nodes; @@ -322,7 +322,7 @@ RefTable::RefNode *RefTable::Add(SQHash mainpos,SQObject &obj) return newnode; } -RefTable::RefNode *RefTable::Get(SQObject &obj,SQHash &mainpos,RefNode **prev,bool add) +RefTable::RefNode *RefTable::get(SQObject &obj,SQHash &mainpos,RefNode **prev,bool add) { RefNode *ref; mainpos = ::HashObj(obj)&(_numofslots-1); @@ -336,7 +336,7 @@ RefTable::RefNode *RefTable::Get(SQObject &obj,SQHash &mainpos,RefNode **prev,bo if(ref == NULL && add) { if(_numofslots == _slotused) { assert(_freelist == 0); - Resize(_numofslots*2); + resize(_numofslots*2); mainpos = ::HashObj(obj)&(_numofslots-1); } ref = Add(mainpos,obj); @@ -420,11 +420,11 @@ SQString *SQStringTable::Add(const SQChar *news,int64_t len) _strings[h] = t; _slotused++; if (_slotused > _numofslots) /* too crowded? */ - Resize(_numofslots*2); + resize(_numofslots*2); return t; } -void SQStringTable::Resize(int64_t size) +void SQStringTable::resize(int64_t size) { int64_t oldsize=_numofslots; SQString **oldtable=_strings; @@ -442,7 +442,7 @@ void SQStringTable::Resize(int64_t size) SQ_FREE(oldtable,oldsize*sizeof(SQString*)); } -void SQStringTable::Remove(SQString *bs) +void SQStringTable::remove(SQString *bs) { SQString *s; SQString *prev=NULL; diff --git a/rabbit/sqstate.hpp b/rabbit/sqstate.hpp index 533c24c..7d7f3f8 100644 --- a/rabbit/sqstate.hpp +++ b/rabbit/sqstate.hpp @@ -19,9 +19,9 @@ struct SQStringTable SQStringTable(SQSharedState*ss); ~SQStringTable(); SQString *Add(const SQChar *,int64_t len); - void Remove(SQString *); + void remove(SQString *); private: - void Resize(int64_t size); + void resize(int64_t size); void AllocNodes(int64_t size); SQString **_strings; uint64_t _numofslots; @@ -38,13 +38,13 @@ struct RefTable { RefTable(); ~RefTable(); void AddRef(SQObject &obj); - SQBool Release(SQObject &obj); - uint64_t GetRefCount(SQObject &obj); + SQBool release(SQObject &obj); + uint64_t getRefCount(SQObject &obj); void Finalize(); private: - RefNode *Get(SQObject &obj,SQHash &mainpos,RefNode **prev,bool add); + RefNode *get(SQObject &obj,SQHash &mainpos,RefNode **prev,bool add); RefNode *Add(SQHash mainpos,SQObject &obj); - void Resize(uint64_t size); + void resize(uint64_t size); void AllocNodes(uint64_t size); uint64_t _numofslots; uint64_t _slotused; @@ -54,7 +54,7 @@ private: }; #define ADD_STRING(ss,str,len) ss->_stringtable->Add(str,len) -#define REMOVE_STRING(ss,bstr) ss->_stringtable->Remove(bstr) +#define REMOVE_STRING(ss,bstr) ss->_stringtable->remove(bstr) struct SQObjectPtr; @@ -64,8 +64,8 @@ struct SQSharedState ~SQSharedState(); void Init(); public: - SQChar* GetScratchPad(int64_t size); - int64_t GetMetaMethodIdxByName(const SQObjectPtr &name); + SQChar* getScratchPad(int64_t size); + int64_t getMetaMethodIdxByName(const SQObjectPtr &name); SQObjectPtrVec *_metamethods; SQObjectPtr _metamethodsmap; SQObjectPtrVec *_systemstrings; @@ -109,8 +109,8 @@ private: int64_t _scratchpadsize; }; -#define _sp(s) (_sharedstate->GetScratchPad(s)) -#define _spval (_sharedstate->GetScratchPad(-1)) +#define _sp(s) (_sharedstate->getScratchPad(s)) +#define _spval (_sharedstate->getScratchPad(-1)) #define _table_ddel _table(_sharedstate->_table_default_delegate) #define _array_ddel _table(_sharedstate->_array_default_delegate) diff --git a/rabbit/sqstring.hpp b/rabbit/sqstring.hpp index 764a2b6..e7a2739 100644 --- a/rabbit/sqstring.hpp +++ b/rabbit/sqstring.hpp @@ -16,14 +16,14 @@ inline SQHash _hashstr (const SQChar *s, size_t l) return h; } -struct SQString : public SQRefCounted +struct SQString : public rabbit::RefCounted { SQString(){} ~SQString(){} public: - static SQString *Create(SQSharedState *ss, const SQChar *, int64_t len = -1 ); - int64_t Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); - void Release(); + static SQString *create(SQSharedState *ss, const SQChar *, int64_t len = -1 ); + int64_t next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); + void release(); SQSharedState *_sharedstate; SQString *_next; //chain for the string table int64_t _len; diff --git a/rabbit/sqtable.cpp b/rabbit/sqtable.cpp index ab77ac7..934d9b5 100644 --- a/rabbit/sqtable.cpp +++ b/rabbit/sqtable.cpp @@ -12,19 +12,19 @@ #include #include -SQTable::SQTable(SQSharedState *ss,int64_t nInitialSize) +SQTable::SQTable(SQSharedState *ss,int64_t nInitialsize) { int64_t pow2size=MINPOWER2; - while(nInitialSize>pow2size)pow2size=pow2size<<1; + while(nInitialsize>pow2size)pow2size=pow2size<<1; AllocNodes(pow2size); _usednodes = 0; _delegate = NULL; } -void SQTable::Remove(const SQObjectPtr &key) +void SQTable::remove(const SQObjectPtr &key) { - _HashNode *n = _Get(key, HashObj(key) & (_numofnodes - 1)); + _HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1)); if (n) { n->val.Null(); n->key.Null(); @@ -33,15 +33,15 @@ void SQTable::Remove(const SQObjectPtr &key) } } -void SQTable::AllocNodes(int64_t nSize) +void SQTable::AllocNodes(int64_t nsize) { - _HashNode *nodes=(_HashNode *)SQ_MALLOC(sizeof(_HashNode)*nSize); - for(int64_t i=0;i_nodes; @@ -100,19 +100,19 @@ SQTable *SQTable::Clone() #else int64_t ridx=0; SQObjectPtr key,val; - while((ridx=Next(true,ridx,key,val))!=-1){ + while((ridx=next(true,ridx,key,val))!=-1){ nt->NewSlot(key,val); } #endif - nt->SetDelegate(_delegate); + nt->setDelegate(_delegate); return nt; } -bool SQTable::Get(const SQObjectPtr &key,SQObjectPtr &val) +bool SQTable::get(const SQObjectPtr &key,SQObjectPtr &val) { if(sq_type(key) == OT_NULL) return false; - _HashNode *n = _Get(key, HashObj(key) & (_numofnodes - 1)); + _HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1)); if (n) { val = _realval(n->val); return true; @@ -123,7 +123,7 @@ bool SQTable::NewSlot(const SQObjectPtr &key,const SQObjectPtr &val) { assert(sq_type(key) != OT_NULL); SQHash h = HashObj(key) & (_numofnodes - 1); - _HashNode *n = _Get(key, h); + _HashNode *n = _get(key, h); if (n) { n->val = val; return false; @@ -176,9 +176,9 @@ bool SQTable::NewSlot(const SQObjectPtr &key,const SQObjectPtr &val) return NewSlot(key, val); } -int64_t SQTable::Next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval) +int64_t SQTable::next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval) { - int64_t idx = (int64_t)TranslateIndex(refpos); + int64_t idx = (int64_t)translateIndex(refpos); while (idx < _numofnodes) { if(sq_type(_nodes[idx].key) != OT_NULL) { //first found @@ -195,9 +195,9 @@ int64_t SQTable::Next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &o } -bool SQTable::Set(const SQObjectPtr &key, const SQObjectPtr &val) +bool SQTable::set(const SQObjectPtr &key, const SQObjectPtr &val) { - _HashNode *n = _Get(key, HashObj(key) & (_numofnodes - 1)); + _HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1)); if (n) { n->val = val; return true; @@ -213,7 +213,7 @@ void SQTable::_ClearNodes() void SQTable::Finalize() { _ClearNodes(); - SetDelegate(NULL); + setDelegate(NULL); } void SQTable::Clear() diff --git a/rabbit/sqtable.hpp b/rabbit/sqtable.hpp index 8fa7d3f..111818e 100644 --- a/rabbit/sqtable.hpp +++ b/rabbit/sqtable.hpp @@ -44,27 +44,27 @@ private: int64_t _usednodes; /////////////////////////// - void AllocNodes(int64_t nSize); + void AllocNodes(int64_t nsize); void Rehash(bool force); - SQTable(SQSharedState *ss, int64_t nInitialSize); + SQTable(SQSharedState *ss, int64_t nInitialsize); void _ClearNodes(); public: - static SQTable* Create(SQSharedState *ss,int64_t nInitialSize) + static SQTable* create(SQSharedState *ss,int64_t nInitialsize) { SQTable *newtable = (SQTable*)SQ_MALLOC(sizeof(SQTable)); - new (newtable) SQTable(ss, nInitialSize); + new (newtable) SQTable(ss, nInitialsize); newtable->_delegate = NULL; return newtable; } void Finalize(); - SQTable *Clone(); + SQTable *clone(); ~SQTable() { - SetDelegate(NULL); + setDelegate(NULL); for (int64_t i = 0; i < _numofnodes; i++) _nodes[i].~_HashNode(); SQ_FREE(_nodes, _numofnodes * sizeof(_HashNode)); } - inline _HashNode *_Get(const SQObjectPtr &key,SQHash hash) + inline _HashNode *_get(const SQObjectPtr &key,SQHash hash) { _HashNode *n = &_nodes[hash]; do{ @@ -75,7 +75,7 @@ public: return NULL; } //for compiler use - inline bool GetStr(const SQChar* key,int64_t keylen,SQObjectPtr &val) + inline bool getStr(const SQChar* key,int64_t keylen,SQObjectPtr &val) { SQHash hash = _hashstr(key,keylen); _HashNode *n = &_nodes[hash & (_numofnodes - 1)]; @@ -92,16 +92,16 @@ public: } return false; } - bool Get(const SQObjectPtr &key,SQObjectPtr &val); - void Remove(const SQObjectPtr &key); - bool Set(const SQObjectPtr &key, const SQObjectPtr &val); + bool get(const SQObjectPtr &key,SQObjectPtr &val); + void remove(const SQObjectPtr &key); + bool set(const SQObjectPtr &key, const SQObjectPtr &val); //returns true if a new slot has been created false if it was already present bool NewSlot(const SQObjectPtr &key,const SQObjectPtr &val); - int64_t Next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); + int64_t next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); int64_t CountUsed(){ return _usednodes;} void Clear(); - void Release() + void release() { sq_delete(this, SQTable); } diff --git a/rabbit/squtils.hpp b/rabbit/squtils.hpp index 67b4826..e779d43 100644 --- a/rabbit/squtils.hpp +++ b/rabbit/squtils.hpp @@ -11,8 +11,9 @@ void *sq_vm_malloc(uint64_t size); void *sq_vm_realloc(void *p,uint64_t oldsize,uint64_t size); void sq_vm_free(void *p,uint64_t size); -#define sq_new(__ptr,__type) {__ptr=(__type *)sq_vm_malloc(sizeof(__type));new (__ptr) __type;} -#define sq_delete(__ptr,__type) {__ptr->~__type();sq_vm_free(__ptr,sizeof(__type));} +#define sq_new(__ptr,__type) {__ptr=(__type *)sq_vm_malloc(sizeof(__type));new ((char*)__ptr) __type;} +#define sq_delete(__ptr,__type) {((__type*)__ptr)->~__type();sq_vm_free(__ptr,sizeof(__type));} + #define SQ_MALLOC(__size) sq_vm_malloc((__size)); #define SQ_FREE(__ptr,__size) sq_vm_free((__ptr),(__size)); #define SQ_REALLOC(__ptr,__oldsize,__size) sq_vm_realloc((__ptr),(__oldsize),(__size)); diff --git a/rabbit/sqvm.cpp b/rabbit/sqvm.cpp index 7ab47b4..73fc62a 100644 --- a/rabbit/sqvm.cpp +++ b/rabbit/sqvm.cpp @@ -15,7 +15,7 @@ #include #include #include -#include +#include #include #define TOP() (_stack._vals[_top-1]) @@ -38,7 +38,7 @@ bool SQVM::BW_OP(uint64_t op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObje default: { Raise_Error(_SC("internal vm error bitwise op failed")); return false; } } } - else { Raise_Error(_SC("bitwise op between '%s' and '%s'"),GetTypeName(o1),GetTypeName(o2)); return false;} + else { Raise_Error(_SC("bitwise op between '%s' and '%s'"),getTypeName(o1),getTypeName(o2)); return false;} trg = res; return true; } @@ -167,12 +167,12 @@ bool SQVM::ArithMetaMethod(int64_t op,const SQObjectPtr &o1,const SQObjectPtr &o if(is_delegable(o1) && _delegable(o1)->_delegate) { SQObjectPtr closure; - if(_delegable(o1)->GetMetaMethod(this, mm, closure)) { + if(_delegable(o1)->getMetaMethod(this, mm, closure)) { Push(o1);Push(o2); return CallMetaMethod(closure,mm,2,dest); } } - Raise_Error(_SC("arith op %c on between '%s' and '%s'"),op,GetTypeName(o1),GetTypeName(o2)); + Raise_Error(_SC("arith op %c on between '%s' and '%s'"),op,getTypeName(o1),getTypeName(o2)); return false; } @@ -191,7 +191,7 @@ bool SQVM::NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o) case OT_INSTANCE: if(_delegable(o)->_delegate) { SQObjectPtr closure; - if(_delegable(o)->GetMetaMethod(this, MT_UNM, closure)) { + if(_delegable(o)->getMetaMethod(this, MT_UNM, closure)) { Push(o); if(!CallMetaMethod(closure, MT_UNM, 1, temp_reg)) return false; _Swap(trg,temp_reg); @@ -201,7 +201,7 @@ bool SQVM::NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o) } default:break; //shutup compiler } - Raise_Error(_SC("attempt to negate a %s"), GetTypeName(o)); + Raise_Error(_SC("attempt to negate a %s"), getTypeName(o)); return false; } @@ -224,7 +224,7 @@ bool SQVM::ObjCmp(const SQObjectPtr &o1,const SQObjectPtr &o2,int64_t &result) case OT_INSTANCE: if(_delegable(o1)->_delegate) { SQObjectPtr closure; - if(_delegable(o1)->GetMetaMethod(this, MT_CMP, closure)) { + if(_delegable(o1)->getMetaMethod(this, MT_CMP, closure)) { Push(o1);Push(o2); if(CallMetaMethod(closure,MT_CMP,2,res)) { if(sq_type(res) != OT_INTEGER) { @@ -303,7 +303,7 @@ bool SQVM::ToString(const SQObjectPtr &o,SQObjectPtr &res) case OT_INSTANCE: if(_delegable(o)->_delegate) { SQObjectPtr closure; - if(_delegable(o)->GetMetaMethod(this, MT_TOSTRING, closure)) { + if(_delegable(o)->getMetaMethod(this, MT_TOSTRING, closure)) { Push(o); if(CallMetaMethod(closure,MT_TOSTRING,1,res)) { if(sq_type(res) == OT_STRING) @@ -315,9 +315,9 @@ bool SQVM::ToString(const SQObjectPtr &o,SQObjectPtr &res) } } default: - scsprintf(_sp(sq_rsl((sizeof(void*)*2)+NUMBER_MAX_CHAR)),sq_rsl((sizeof(void*)*2)+NUMBER_MAX_CHAR),_SC("(%s : 0x%p)"),GetTypeName(o),(void*)_rawval(o)); + scsprintf(_sp(sq_rsl((sizeof(void*)*2)+NUMBER_MAX_CHAR)),sq_rsl((sizeof(void*)*2)+NUMBER_MAX_CHAR),_SC("(%s : 0x%p)"),getTypeName(o),(void*)_rawval(o)); } - res = SQString::Create(_ss(this),_spval); + res = SQString::create(_ss(this),_spval); return true; } @@ -331,7 +331,7 @@ bool SQVM::StringCat(const SQObjectPtr &str,const SQObjectPtr &obj,SQObjectPtr & SQChar *s = _sp(sq_rsl(l + ol + 1)); memcpy(s, _stringval(a), sq_rsl(l)); memcpy(s + l, _stringval(b), sq_rsl(ol)); - dest = SQString::Create(_ss(this), _spval, l + ol); + dest = SQString::create(_ss(this), _spval, l + ol); return true; } @@ -339,12 +339,12 @@ bool SQVM::TypeOf(const SQObjectPtr &obj1,SQObjectPtr &dest) { if(is_delegable(obj1) && _delegable(obj1)->_delegate) { SQObjectPtr closure; - if(_delegable(obj1)->GetMetaMethod(this, MT_TYPEOF, closure)) { + if(_delegable(obj1)->getMetaMethod(this, MT_TYPEOF, closure)) { Push(obj1); return CallMetaMethod(closure,MT_TYPEOF,1,dest); } } - dest = SQString::Create(_ss(this),GetTypeName(obj1)); + dest = SQString::create(_ss(this),getTypeName(obj1)); return true; } @@ -358,7 +358,7 @@ bool SQVM::Init(SQVM *friendvm, int64_t stacksize) _stackbase = 0; _top = 0; if(!friendvm) { - _roottable = SQTable::Create(_ss(this), 0); + _roottable = SQTable::create(_ss(this), 0); sq_base_register(this); } else { @@ -391,10 +391,10 @@ bool SQVM::StartCall(SQClosure *closure,int64_t target,int64_t args,int64_t stac //dumpstack(stackbase); int64_t nvargs = nargs - paramssize; - SQArray *arr = SQArray::Create(_ss(this),nvargs); + rabbit::Array *arr = rabbit::Array::create(_ss(this),nvargs); int64_t pbase = stackbase+paramssize; for(int64_t n = 0; n < nvargs; n++) { - arr->_values[n] = _stack._vals[pbase]; + (*arr)[n] = _stack._vals[pbase]; _stack._vals[pbase].Null(); pbase++; @@ -433,7 +433,7 @@ bool SQVM::StartCall(SQClosure *closure,int64_t target,int64_t args,int64_t stac if (closure->_function->_bgenerator) { SQFunctionProto *f = closure->_function; - SQGenerator *gen = SQGenerator::Create(_ss(this), closure); + SQGenerator *gen = SQGenerator::create(_ss(this), closure); if(!gen->Yield(this,f->_stacksize)) return false; SQObjectPtr temp; @@ -491,9 +491,9 @@ bool SQVM::PLOCAL_INC(int64_t op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPt bool SQVM::DerefInc(int64_t op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix,int64_t selfidx) { SQObjectPtr tmp, tself = self, tkey = key; - if (!Get(tself, tkey, tmp, 0, selfidx)) { return false; } + if (!get(tself, tkey, tmp, 0, selfidx)) { return false; } _RET_ON_FAIL(ARITH_OP( op , target, tmp, incr)) - if (!Set(tself, tkey, target,selfidx)) { return false; } + if (!set(tself, tkey, target,selfidx)) { return false; } if (postfix) target = tmp; return true; } @@ -523,29 +523,29 @@ bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr int64_t nrefidx; switch(sq_type(o1)) { case OT_TABLE: - if((nrefidx = _table(o1)->Next(false,o4, o2, o3)) == -1) _FINISH(exitpos); + if((nrefidx = _table(o1)->next(false,o4, o2, o3)) == -1) _FINISH(exitpos); o4 = (int64_t)nrefidx; _FINISH(1); case OT_ARRAY: - if((nrefidx = _array(o1)->Next(o4, o2, o3)) == -1) _FINISH(exitpos); + if((nrefidx = _array(o1)->next(o4, o2, o3)) == -1) _FINISH(exitpos); o4 = (int64_t) nrefidx; _FINISH(1); case OT_STRING: - if((nrefidx = _string(o1)->Next(o4, o2, o3)) == -1)_FINISH(exitpos); + if((nrefidx = _string(o1)->next(o4, o2, o3)) == -1)_FINISH(exitpos); o4 = (int64_t)nrefidx; _FINISH(1); case OT_CLASS: - if((nrefidx = _class(o1)->Next(o4, o2, o3)) == -1)_FINISH(exitpos); + if((nrefidx = _class(o1)->next(o4, o2, o3)) == -1)_FINISH(exitpos); o4 = (int64_t)nrefidx; _FINISH(1); case OT_USERDATA: case OT_INSTANCE: if(_delegable(o1)->_delegate) { SQObjectPtr itr; SQObjectPtr closure; - if(_delegable(o1)->GetMetaMethod(this, MT_NEXTI, closure)) { + if(_delegable(o1)->getMetaMethod(this, MT_NEXTI, closure)) { Push(o1); Push(o4); if(CallMetaMethod(closure, MT_NEXTI, 2, itr)) { o4 = o2 = itr; if(sq_type(itr) == OT_NULL) _FINISH(exitpos); - if(!Get(o1, itr, o3, 0, DONT_FALL_BACK)) { + if(!get(o1, itr, o3, 0, DONT_FALL_BACK)) { Raise_Error(_SC("_nexti returned an invalid idx")); // cloud be changed return false; } @@ -572,7 +572,7 @@ bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr _FINISH(0); } default: - Raise_Error(_SC("cannot iterate %s"), GetTypeName(o1)); + Raise_Error(_SC("cannot iterate %s"), getTypeName(o1)); } return false; //cannot be hit(just to avoid warnings) } @@ -586,7 +586,7 @@ bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func) { int64_t nouters; - SQClosure *closure = SQClosure::Create(_ss(this), func,_table(_roottable)->GetWeakRef(OT_TABLE)); + SQClosure *closure = SQClosure::create(_ss(this), func,_table(_roottable)->getWeakRef(OT_TABLE)); if((nouters = func->_noutervalues)) { for(int64_t i = 0; i_outervalues[i]; @@ -618,13 +618,13 @@ bool SQVM::CLASS_OP(SQObjectPtr &target,int64_t baseclass,int64_t attributes) SQClass *base = NULL; SQObjectPtr attrs; if(baseclass != -1) { - if(sq_type(_stack._vals[_stackbase+baseclass]) != OT_CLASS) { Raise_Error(_SC("trying to inherit from a %s"),GetTypeName(_stack._vals[_stackbase+baseclass])); return false; } + if(sq_type(_stack._vals[_stackbase+baseclass]) != OT_CLASS) { Raise_Error(_SC("trying to inherit from a %s"),getTypeName(_stack._vals[_stackbase+baseclass])); return false; } base = _class(_stack._vals[_stackbase + baseclass]); } if(attributes != MAX_FUNC_STACKSIZE) { attrs = _stack._vals[_stackbase+attributes]; } - target = SQClass::Create(_ss(this),base); + target = SQClass::create(_ss(this),base); if(sq_type(_class(target)->_metamethods[MT_INHERITED]) != OT_NULL) { int nparams = 2; SQObjectPtr ret; @@ -763,7 +763,7 @@ exception_restore: continue; case OT_CLASS:{ SQObjectPtr inst; - _GUARD(CreateClassInstance(_class(clo),inst,clo)); + _GUARD(createClassInstance(_class(clo),inst,clo)); if(sarg0 != -1) { STK(arg0) = inst; } @@ -788,7 +788,7 @@ exception_restore: case OT_USERDATA: case OT_INSTANCE:{ SQObjectPtr closure; - if(_delegable(clo)->_delegate && _delegable(clo)->GetMetaMethod(this,MT_CALL,closure)) { + if(_delegable(clo)->_delegate && _delegable(clo)->getMetaMethod(this,MT_CALL,closure)) { Push(clo); for (int64_t i = 0; i < arg3; i++) Push(STK(arg2 + i)); if(!CallMetaMethod(closure, MT_CALL, arg3+1, clo)) SQ_THROW(); @@ -798,11 +798,11 @@ exception_restore: break; } - //Raise_Error(_SC("attempt to call '%s'"), GetTypeName(clo)); + //Raise_Error(_SC("attempt to call '%s'"), getTypeName(clo)); //SQ_THROW(); } default: - Raise_Error(_SC("attempt to call '%s'"), GetTypeName(clo)); + Raise_Error(_SC("attempt to call '%s'"), getTypeName(clo)); SQ_THROW(); } } @@ -811,7 +811,7 @@ exception_restore: case _OP_PREPCALLK: { SQObjectPtr &key = _i_.op == _OP_PREPCALLK?(ci->_literals)[arg1]:STK(arg1); SQObjectPtr &o = STK(arg2); - if (!Get(o, key, temp_reg,0,arg2)) { + if (!get(o, key, temp_reg,0,arg2)) { SQ_THROW(); } STK(arg3) = o; @@ -819,7 +819,7 @@ exception_restore: } continue; case _OP_GETK: - if (!Get(STK(arg2), ci->_literals[arg1], temp_reg, 0,arg2)) { SQ_THROW();} + if (!get(STK(arg2), ci->_literals[arg1], temp_reg, 0,arg2)) { SQ_THROW();} _Swap(TARGET,temp_reg);//TARGET = temp_reg; continue; case _OP_MOVE: TARGET = STK(arg1); continue; @@ -829,11 +829,11 @@ exception_restore: continue; case _OP_DELETE: _GUARD(DeleteSlot(STK(arg1), STK(arg2), TARGET)); continue; case _OP_SET: - if (!Set(STK(arg1), STK(arg2), STK(arg3),arg1)) { SQ_THROW(); } + if (!set(STK(arg1), STK(arg2), STK(arg3),arg1)) { SQ_THROW(); } if (arg0 != 0xFF) TARGET = STK(arg3); continue; case _OP_GET: - if (!Get(STK(arg1), STK(arg2), temp_reg, 0,arg1)) { SQ_THROW(); } + if (!get(STK(arg1), STK(arg2), temp_reg, 0,arg1)) { SQ_THROW(); } _Swap(TARGET,temp_reg);//TARGET = temp_reg; continue; case _OP_EQ:{ @@ -865,7 +865,7 @@ exception_restore: continue; case _OP_LOADNULLS:{ for(int32_t n=0; n < arg1; n++) STK(arg0+n).Null(); }continue; case _OP_LOADROOT: { - SQWeakRef *w = _closure(ci->_closure)->_root; + rabbit::WeakRef *w = _closure(ci->_closure)->_root; if(sq_type(w->_obj) != OT_NULL) { TARGET = w->_obj; } else { @@ -899,8 +899,8 @@ exception_restore: continue; case _OP_NEWOBJ: switch(arg3) { - case NOT_TABLE: TARGET = SQTable::Create(_ss(this), arg1); continue; - case NOT_ARRAY: TARGET = SQArray::Create(_ss(this), 0); _array(TARGET)->Reserve(arg1); continue; + case NOT_TABLE: TARGET = SQTable::create(_ss(this), arg1); continue; + case NOT_ARRAY: TARGET = rabbit::Array::create(_ss(this), 0); _array(TARGET)->reserve(arg1); continue; case NOT_CLASS: _GUARD(CLASS_OP(TARGET,arg1,arg2)); continue; default: assert(0); continue; } @@ -932,7 +932,7 @@ exception_restore: default: val._type = OT_INTEGER; assert(0); break; } - _array(STK(arg0))->Append(val); continue; + _array(STK(arg0))->append(val); continue; } case _OP_COMPARITH: { int64_t selfidx = (((uint64_t)arg1&0xFFFF0000)>>16); @@ -963,10 +963,10 @@ exception_restore: } continue; case _OP_CMP: _GUARD(CMP_OP((CmpOP)arg3,STK(arg2),STK(arg1),TARGET)) continue; - case _OP_EXISTS: TARGET = Get(STK(arg1), STK(arg2), temp_reg, GET_FLAG_DO_NOT_RAISE_ERROR | GET_FLAG_RAW, DONT_FALL_BACK) ? true : false; continue; + case _OP_EXISTS: TARGET = get(STK(arg1), STK(arg2), temp_reg, GET_FLAG_DO_NOT_RAISE_ERROR | GET_FLAG_RAW, DONT_FALL_BACK) ? true : false; continue; case _OP_INSTANCEOF: if(sq_type(STK(arg1)) != OT_CLASS) - {Raise_Error(_SC("cannot apply instanceof between a %s and a %s"),GetTypeName(STK(arg1)),GetTypeName(STK(arg2))); SQ_THROW();} + {Raise_Error(_SC("cannot apply instanceof between a %s and a %s"),getTypeName(STK(arg1)),getTypeName(STK(arg2))); SQ_THROW();} TARGET = (sq_type(STK(arg2)) == OT_INSTANCE) ? (_instance(STK(arg2))->InstanceOf(_class(STK(arg1)))?true:false) : false; continue; case _OP_AND: @@ -989,7 +989,7 @@ exception_restore: TARGET = int64_t(~t); continue; } - Raise_Error(_SC("attempt to perform a bitwise op on a %s"), GetTypeName(STK(arg1))); + Raise_Error(_SC("attempt to perform a bitwise op on a %s"), getTypeName(STK(arg1))); SQ_THROW(); case _OP_CLOSURE: { SQClosure *c = ci->_closure._unVal.pClosure; @@ -1004,7 +1004,7 @@ exception_restore: traps -= ci->_etraps; if(sarg1 != MAX_FUNC_STACKSIZE) _Swap(STK(arg1),temp_reg);//STK(arg1) = temp_reg; } - else { Raise_Error(_SC("trying to yield a '%s',only genenerator can be yielded"), GetTypeName(ci->_generator)); SQ_THROW();} + else { Raise_Error(_SC("trying to yield a '%s',only genenerator can be yielded"), getTypeName(ci->_generator)); SQ_THROW();} if(Return(arg0, arg1, temp_reg)){ assert(traps == 0); outres = temp_reg; @@ -1014,7 +1014,7 @@ exception_restore: } continue; case _OP_RESUME: - if(sq_type(STK(arg1)) != OT_GENERATOR){ Raise_Error(_SC("trying to resume a '%s',only genenerator can be resumed"), GetTypeName(STK(arg1))); SQ_THROW();} + if(sq_type(STK(arg1)) != OT_GENERATOR){ Raise_Error(_SC("trying to resume a '%s',only genenerator can be resumed"), getTypeName(STK(arg1))); SQ_THROW();} _GUARD(_generator(STK(arg1))->Resume(this, TARGET)); traps += ci->_etraps; continue; @@ -1027,7 +1027,7 @@ exception_restore: if(_generator(STK(arg0))->_state == SQGenerator::eDead) ci->_ip += (sarg1 - 1); continue; - case _OP_CLONE: _GUARD(Clone(STK(arg1), TARGET)); continue; + case _OP_CLONE: _GUARD(clone(STK(arg1), TARGET)); continue; case _OP_TYPEOF: _GUARD(TypeOf(STK(arg1), TARGET)) continue; case _OP_PUSHTRAP:{ SQInstruction *_iv = _closure(ci->_closure)->_function->_instructions; @@ -1102,10 +1102,10 @@ exception_trap: assert(0); } -bool SQVM::CreateClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor) +bool SQVM::createClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor) { - inst = theclass->CreateInstance(); - if(!theclass->GetConstructor(constructor)) { + inst = theclass->createInstance(); + if(!theclass->getConstructor(constructor)) { constructor.Null(); } return true; @@ -1129,13 +1129,13 @@ void SQVM::CallDebugHook(int64_t type,int64_t forcedline) if(_debughook_native) { const SQChar *src = sq_type(func->_sourcename) == OT_STRING?_stringval(func->_sourcename):NULL; const SQChar *fname = sq_type(func->_name) == OT_STRING?_stringval(func->_name):NULL; - int64_t line = forcedline?forcedline:func->GetLine(ci->_ip); + int64_t line = forcedline?forcedline:func->getLine(ci->_ip); _debughook_native(this,type,src,line,fname); } else { SQObjectPtr temp_reg; int64_t nparams=5; - Push(_roottable); Push(type); Push(func->_sourcename); Push(forcedline?forcedline:func->GetLine(ci->_ip)); Push(func->_name); + Push(_roottable); Push(type); Push(func->_sourcename); Push(forcedline?forcedline:func->getLine(ci->_ip)); Push(func->_name); Call(_debughook_closure,nparams,_top-nparams,temp_reg,SQFalse); Pop(nparams); } @@ -1232,20 +1232,20 @@ bool SQVM::TailCall(SQClosure *closure, int64_t parambase,int64_t nparams) #define FALLBACK_NO_MATCH 1 #define FALLBACK_ERROR 2 -bool SQVM::Get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &dest, uint64_t getflags, int64_t selfidx) +bool SQVM::get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &dest, uint64_t getflags, int64_t selfidx) { switch(sq_type(self)){ case OT_TABLE: - if(_table(self)->Get(key,dest))return true; + if(_table(self)->get(key,dest))return true; break; case OT_ARRAY: - if (sq_isnumeric(key)) { if (_array(self)->Get(tointeger(key), dest)) { return true; } if ((getflags & GET_FLAG_DO_NOT_RAISE_ERROR) == 0) Raise_IdxError(key); return false; } + if (sq_isnumeric(key)) { if (_array(self)->get(tointeger(key), dest)) { return true; } if ((getflags & GET_FLAG_DO_NOT_RAISE_ERROR) == 0) Raise_IdxError(key); return false; } break; case OT_INSTANCE: - if(_instance(self)->Get(key,dest)) return true; + if(_instance(self)->get(key,dest)) return true; break; case OT_CLASS: - if(_class(self)->Get(key,dest)) return true; + if(_class(self)->get(key,dest)) return true; break; case OT_STRING: if(sq_isnumeric(key)){ @@ -1263,7 +1263,7 @@ bool SQVM::Get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &des default:break; //shut up compiler } if ((getflags & GET_FLAG_RAW) == 0) { - switch(FallBackGet(self,key,dest)) { + switch(FallBackget(self,key,dest)) { case FALLBACK_OK: return true; //okie case FALLBACK_NO_MATCH: break; //keep falling back case FALLBACK_ERROR: return false; // the metamethod failed @@ -1274,10 +1274,10 @@ bool SQVM::Get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &des } //#ifdef ROOT_FALLBACK if(selfidx == 0) { - SQWeakRef *w = _closure(ci->_closure)->_root; + rabbit::WeakRef *w = _closure(ci->_closure)->_root; if(sq_type(w->_obj) != OT_NULL) { - if(Get(*((const SQObjectPtr *)&w->_obj),key,dest,0,DONT_FALL_BACK)) return true; + if(get(*((const SQObjectPtr *)&w->_obj),key,dest,0,DONT_FALL_BACK)) return true; } } @@ -1302,18 +1302,18 @@ bool SQVM::InvokeDefaultDelegate(const SQObjectPtr &self,const SQObjectPtr &key, case OT_WEAKREF: ddel = _weakref_ddel; break; default: return false; } - return ddel->Get(key,dest); + return ddel->get(key,dest); } -int64_t SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest) +int64_t SQVM::FallBackget(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest) { switch(sq_type(self)){ case OT_TABLE: case OT_USERDATA: //delegation if(_delegable(self)->_delegate) { - if(Get(SQObjectPtr(_delegable(self)->_delegate),key,dest,0,DONT_FALL_BACK)) return FALLBACK_OK; + if(get(SQObjectPtr(_delegable(self)->_delegate),key,dest,0,DONT_FALL_BACK)) return FALLBACK_OK; } else { return FALLBACK_NO_MATCH; @@ -1321,7 +1321,7 @@ int64_t SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjec //go through case OT_INSTANCE: { SQObjectPtr closure; - if(_delegable(self)->GetMetaMethod(this, MT_GET, closure)) { + if(_delegable(self)->getMetaMethod(this, MT_GET, closure)) { Push(self);Push(key); _nmetamethodscall++; AutoDec ad(&_nmetamethodscall); @@ -1344,54 +1344,54 @@ int64_t SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjec return FALLBACK_NO_MATCH; } -bool SQVM::Set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,int64_t selfidx) +bool SQVM::set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,int64_t selfidx) { switch(sq_type(self)){ case OT_TABLE: - if(_table(self)->Set(key,val)) return true; + if(_table(self)->set(key,val)) return true; break; case OT_INSTANCE: - if(_instance(self)->Set(key,val)) return true; + if(_instance(self)->set(key,val)) return true; break; case OT_ARRAY: - if(!sq_isnumeric(key)) { Raise_Error(_SC("indexing %s with %s"),GetTypeName(self),GetTypeName(key)); return false; } - if(!_array(self)->Set(tointeger(key),val)) { + if(!sq_isnumeric(key)) { Raise_Error(_SC("indexing %s with %s"),getTypeName(self),getTypeName(key)); return false; } + if(!_array(self)->set(tointeger(key),val)) { Raise_IdxError(key); return false; } return true; case OT_USERDATA: break; // must fall back default: - Raise_Error(_SC("trying to set '%s'"),GetTypeName(self)); + Raise_Error(_SC("trying to set '%s'"),getTypeName(self)); return false; } - switch(FallBackSet(self,key,val)) { + switch(FallBackset(self,key,val)) { case FALLBACK_OK: return true; //okie case FALLBACK_NO_MATCH: break; //keep falling back case FALLBACK_ERROR: return false; // the metamethod failed } if(selfidx == 0) { - if(_table(_roottable)->Set(key,val)) + if(_table(_roottable)->set(key,val)) return true; } Raise_IdxError(key); return false; } -int64_t SQVM::FallBackSet(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val) +int64_t SQVM::FallBackset(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val) { switch(sq_type(self)) { case OT_TABLE: if(_table(self)->_delegate) { - if(Set(_table(self)->_delegate,key,val,DONT_FALL_BACK)) return FALLBACK_OK; + if(set(_table(self)->_delegate,key,val,DONT_FALL_BACK)) return FALLBACK_OK; } //keps on going case OT_INSTANCE: case OT_USERDATA:{ SQObjectPtr closure; SQObjectPtr t; - if(_delegable(self)->GetMetaMethod(this, MT_SET, closure)) { + if(_delegable(self)->getMetaMethod(this, MT_SET, closure)) { Push(self);Push(key);Push(val); _nmetamethodscall++; AutoDec ad(&_nmetamethodscall); @@ -1414,19 +1414,19 @@ int64_t SQVM::FallBackSet(const SQObjectPtr &self,const SQObjectPtr &key,const S return FALLBACK_NO_MATCH; } -bool SQVM::Clone(const SQObjectPtr &self,SQObjectPtr &target) +bool SQVM::clone(const SQObjectPtr &self,SQObjectPtr &target) { SQObjectPtr temp_reg; SQObjectPtr newobj; switch(sq_type(self)){ case OT_TABLE: - newobj = _table(self)->Clone(); + newobj = _table(self)->clone(); goto cloned_mt; case OT_INSTANCE: { - newobj = _instance(self)->Clone(_ss(this)); + newobj = _instance(self)->clone(_ss(this)); cloned_mt: SQObjectPtr closure; - if(_delegable(newobj)->_delegate && _delegable(newobj)->GetMetaMethod(this,MT_CLONED,closure)) { + if(_delegable(newobj)->_delegate && _delegable(newobj)->getMetaMethod(this,MT_CLONED,closure)) { Push(newobj); Push(self); if(!CallMetaMethod(closure,MT_CLONED,2,temp_reg)) @@ -1436,10 +1436,10 @@ cloned_mt: target = newobj; return true; case OT_ARRAY: - target = _array(self)->Clone(); + target = _array(self)->clone(); return true; default: - Raise_Error(_SC("cloning a %s"), GetTypeName(self)); + Raise_Error(_SC("cloning a %s"), getTypeName(self)); return false; } } @@ -1463,7 +1463,7 @@ bool SQVM::NewSlotA(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjec if(!NewSlot(self, key, val,bstatic)) return false; if(sq_type(attrs) != OT_NULL) { - c->SetAttributes(key,attrs); + c->setAttributes(key,attrs); } return true; } @@ -1476,9 +1476,9 @@ bool SQVM::NewSlot(const SQObjectPtr &self,const SQObjectPtr &key,const SQObject bool rawcall = true; if(_table(self)->_delegate) { SQObjectPtr res; - if(!_table(self)->Get(key,res)) { + if(!_table(self)->get(key,res)) { SQObjectPtr closure; - if(_delegable(self)->_delegate && _delegable(self)->GetMetaMethod(this,MT_NEWSLOT,closure)) { + if(_delegable(self)->_delegate && _delegable(self)->getMetaMethod(this,MT_NEWSLOT,closure)) { Push(self);Push(key);Push(val); if(!CallMetaMethod(closure,MT_NEWSLOT,3,res)) { return false; @@ -1496,7 +1496,7 @@ bool SQVM::NewSlot(const SQObjectPtr &self,const SQObjectPtr &key,const SQObject case OT_INSTANCE: { SQObjectPtr res; SQObjectPtr closure; - if(_delegable(self)->_delegate && _delegable(self)->GetMetaMethod(this,MT_NEWSLOT,closure)) { + if(_delegable(self)->_delegate && _delegable(self)->getMetaMethod(this,MT_NEWSLOT,closure)) { Push(self);Push(key);Push(val); if(!CallMetaMethod(closure,MT_NEWSLOT,3,res)) { return false; @@ -1520,7 +1520,7 @@ bool SQVM::NewSlot(const SQObjectPtr &self,const SQObjectPtr &key,const SQObject } break; default: - Raise_Error(_SC("indexing %s with %s"),GetTypeName(self),GetTypeName(key)); + Raise_Error(_SC("indexing %s with %s"),getTypeName(self),getTypeName(key)); return false; break; } @@ -1538,14 +1538,14 @@ bool SQVM::DeleteSlot(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr SQObjectPtr t; //bool handled = false; SQObjectPtr closure; - if(_delegable(self)->_delegate && _delegable(self)->GetMetaMethod(this,MT_DELSLOT,closure)) { + if(_delegable(self)->_delegate && _delegable(self)->getMetaMethod(this,MT_DELSLOT,closure)) { Push(self);Push(key); return CallMetaMethod(closure,MT_DELSLOT,2,res); } else { if(sq_type(self) == OT_TABLE) { - if(_table(self)->Get(key,t)) { - _table(self)->Remove(key); + if(_table(self)->get(key,t)) { + _table(self)->remove(key); } else { Raise_IdxError((const SQObject &)key); @@ -1553,7 +1553,7 @@ bool SQVM::DeleteSlot(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr } } else { - Raise_Error(_SC("cannot delete a slot from %s"),GetTypeName(self)); + Raise_Error(_SC("cannot delete a slot from %s"),getTypeName(self)); return false; } } @@ -1561,7 +1561,7 @@ bool SQVM::DeleteSlot(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr } break; default: - Raise_Error(_SC("attempt to delete a slot from a %s"),GetTypeName(self)); + Raise_Error(_SC("attempt to delete a slot from a %s"),getTypeName(self)); return false; } return true; @@ -1585,7 +1585,7 @@ int64_t prevstackbase = _stackbase; case OT_CLASS: { SQObjectPtr constr; SQObjectPtr temp; - CreateClassInstance(_class(closure),outres,constr); + createClassInstance(_class(closure),outres,constr); SQObjectType ctype = sq_type(constr); if (ctype == OT_NATIVECLOSURE || ctype == OT_CLOSURE) { _stack[stackbase] = outres; @@ -1634,7 +1634,7 @@ void SQVM::FindOuter(SQObjectPtr &target, SQObjectPtr *stackindex) } pp = &p->_next; } - otr = SQOuter::Create(_ss(this), stackindex); + otr = SQOuter::create(_ss(this), stackindex); otr->_next = *pp; otr->_idx = (stackindex - _stack._vals); __ObjAddRef(otr); @@ -1705,11 +1705,11 @@ void SQVM::CloseOuters(SQObjectPtr *stackindex) { p->_value = *(p->_valptr); p->_valptr = &p->_value; _openouters = p->_next; - __ObjRelease(p); + __Objrelease(p); } } -void SQVM::Remove(int64_t n) { +void SQVM::remove(int64_t n) { n = (n >= 0)?n + _stackbase - 1:_top + n; for(int64_t i = n; i < _top; i++){ _stack[i] = _stack[i+1]; @@ -1730,10 +1730,10 @@ void SQVM::Pop(int64_t n) { void SQVM::PushNull() { _stack[_top++].Null(); } void SQVM::Push(const SQObjectPtr &o) { _stack[_top++] = o; } -SQObjectPtr &SQVM::Top() { return _stack[_top-1]; } -SQObjectPtr &SQVM::PopGet() { return _stack[--_top]; } -SQObjectPtr &SQVM::GetUp(int64_t n) { return _stack[_top+n]; } -SQObjectPtr &SQVM::GetAt(int64_t n) { return _stack[n]; } +SQObjectPtr &SQVM::top() { return _stack[_top-1]; } +SQObjectPtr &SQVM::Popget() { return _stack[--_top]; } +SQObjectPtr &SQVM::getUp(int64_t n) { return _stack[_top+n]; } +SQObjectPtr &SQVM::getAt(int64_t n) { return _stack[n]; } #ifdef _DEBUG_DUMP void SQVM::dumpstack(int64_t stackbase,bool dumpall) diff --git a/rabbit/sqvm.hpp b/rabbit/sqvm.hpp index 2fca32f..1dd128d 100644 --- a/rabbit/sqvm.hpp +++ b/rabbit/sqvm.hpp @@ -37,7 +37,7 @@ struct SQExceptionTrap{ typedef sqvector ExceptionsTraps; -struct SQVM : public SQRefCounted +struct SQVM : public rabbit::RefCounted { struct CallInfo{ //CallInfo() { _generator = NULL;} @@ -67,22 +67,22 @@ public: bool TailCall(SQClosure *closure, int64_t firstparam, int64_t nparams); //starts a RABBIT call in the same "Execution loop" bool StartCall(SQClosure *closure, int64_t target, int64_t nargs, int64_t stackbase, bool tailcall); - bool CreateClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor); + bool createClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor); //call a generic closure pure RABBIT or NATIVE bool Call(SQObjectPtr &closure, int64_t nparams, int64_t stackbase, SQObjectPtr &outres,SQBool raiseerror); SQRESULT Suspend(); void CallDebugHook(int64_t type,int64_t forcedline=0); void CallErrorHandler(SQObjectPtr &e); - bool Get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &dest, uint64_t getflags, int64_t selfidx); - int64_t FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest); + bool get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &dest, uint64_t getflags, int64_t selfidx); + int64_t FallBackget(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest); bool InvokeDefaultDelegate(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest); - bool Set(const SQObjectPtr &self, const SQObjectPtr &key, const SQObjectPtr &val, int64_t selfidx); - int64_t FallBackSet(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val); + bool set(const SQObjectPtr &self, const SQObjectPtr &key, const SQObjectPtr &val, int64_t selfidx); + int64_t FallBackset(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val); bool NewSlot(const SQObjectPtr &self, const SQObjectPtr &key, const SQObjectPtr &val,bool bstatic); bool NewSlotA(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,const SQObjectPtr &attrs,bool bstatic,bool raw); bool DeleteSlot(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &res); - bool Clone(const SQObjectPtr &self, SQObjectPtr &target); + bool clone(const SQObjectPtr &self, SQObjectPtr &target); bool ObjCmp(const SQObjectPtr &o1, const SQObjectPtr &o2,int64_t &res); bool StringCat(const SQObjectPtr &str, const SQObjectPtr &obj, SQObjectPtr &dest); static bool IsEqual(const SQObjectPtr &o1,const SQObjectPtr &o2,bool &res); @@ -129,10 +129,10 @@ public: } bool EnterFrame(int64_t newbase, int64_t newtop, bool tailcall); void LeaveFrame(); - void Release(){ sq_delete(this,SQVM); } + void release(){ sq_delete(this,SQVM); } //////////////////////////////////////////////////////////////////////////// //stack functions for the api - void Remove(int64_t n); + void remove(int64_t n); static bool IsFalse(SQObjectPtr &o); @@ -140,10 +140,10 @@ public: void Pop(int64_t n); void Push(const SQObjectPtr &o); void PushNull(); - SQObjectPtr &Top(); - SQObjectPtr &PopGet(); - SQObjectPtr &GetUp(int64_t n); - SQObjectPtr &GetAt(int64_t n); + SQObjectPtr &top(); + SQObjectPtr &Popget(); + SQObjectPtr &getUp(int64_t n); + SQObjectPtr &getAt(int64_t n); SQObjectPtrVec _stack; @@ -187,7 +187,7 @@ struct AutoDec{ int64_t *_n; }; -inline SQObjectPtr &stack_get(HRABBITVM v,int64_t idx){return ((idx>=0)?(v->GetAt(idx+v->_stackbase-1)):(v->GetUp(idx)));} +inline SQObjectPtr &stack_get(HRABBITVM v,int64_t idx){return ((idx>=0)?(v->getAt(idx+v->_stackbase-1)):(v->getUp(idx)));} #define _ss(_vm_) (_vm_)->_sharedstate