From a8ed39d3b4cbc690187153dc1e1f63ff8580111f Mon Sep 17 00:00:00 2001 From: Edouard DUPIN Date: Fri, 6 Jul 2018 00:08:43 +0200 Subject: [PATCH] [DEV] continue rework ==> take big mistake, use basic pointer to all after object other data (typically C style coding) --- rabbit-std/sqstdblob.cpp | 10 ++++------ rabbit-std/sqstdio.cpp | 9 ++++----- rabbit/Class.cpp | 3 +-- rabbit/Closure.cpp | 3 +-- rabbit/FuncState.cpp | 6 ++---- rabbit/FunctionProto.cpp | 23 +++++++++-------------- rabbit/Generator.cpp | 3 +-- rabbit/Instance.cpp | 13 +++++-------- rabbit/NativeClosure.cpp | 3 +-- rabbit/Outer.cpp | 6 ++---- rabbit/RefTable.cpp | 4 ++-- rabbit/String.cpp | 2 +- rabbit/StringTable.cpp | 7 ++----- rabbit/UserData.cpp | 7 ++----- rabbit/sqapi.cpp | 20 +++++++------------- 15 files changed, 44 insertions(+), 75 deletions(-) diff --git a/rabbit-std/sqstdblob.cpp b/rabbit-std/sqstdblob.cpp index fd6ec94..e5a2baa 100644 --- a/rabbit-std/sqstdblob.cpp +++ b/rabbit-std/sqstdblob.cpp @@ -138,10 +138,9 @@ static int64_t _blob_constructor(rabbit::VirtualMachine* v) if(size < 0) return rabbit::sq_throwerror(v, "cannot create blob with negative size"); //rabbit::std::Blob *b = new rabbit::std::Blob(size); - rabbit::std::Blob *b = new (rabbit::sq_malloc(sizeof(rabbit::std::Blob)))rabbit::std::Blob(size); + rabbit::std::Blob *b = ETK_NEW(rabbit::std::Blob, size); if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,b))) { - b->~Blob(); - rabbit::sq_free(b,sizeof(rabbit::std::Blob)); + ETK_FREE(rabbit::std::Blob, b); return rabbit::sq_throwerror(v, "cannot create blob"); } rabbit::sq_setreleasehook(v,1,_blob_releasehook); @@ -156,11 +155,10 @@ static int64_t _blob__cloned(rabbit::VirtualMachine* v) return SQ_ERROR; } //rabbit::std::Blob *thisone = new rabbit::std::Blob(other->Len()); - rabbit::std::Blob *thisone = new (rabbit::sq_malloc(sizeof(rabbit::std::Blob)))rabbit::std::Blob(other->Len()); + rabbit::std::Blob *thisone = ETK_NEW(rabbit::std::Blob, other->Len()); memcpy(thisone->getBuf(),other->getBuf(),thisone->Len()); if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,thisone))) { - thisone->~Blob(); - rabbit::sq_free(thisone,sizeof(rabbit::std::Blob)); + ETK_FREE(rabbit::std::Blob, thisone); return rabbit::sq_throwerror(v, "cannot clone blob"); } rabbit::sq_setreleasehook(v,1,_blob_releasehook); diff --git a/rabbit-std/sqstdio.cpp b/rabbit-std/sqstdio.cpp index d677e43..b4107b6 100644 --- a/rabbit-std/sqstdio.cpp +++ b/rabbit-std/sqstdio.cpp @@ -147,13 +147,12 @@ static int64_t _file_constructor(rabbit::VirtualMachine* v) return rabbit::sq_throwerror(v,"wrong parameter"); } - f = new (rabbit::sq_malloc(sizeof(rabbit::std::File)))rabbit::std::File(newf,owns); - if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,f))) { - f->~File(); - rabbit::sq_free(f,sizeof(rabbit::std::File)); + f = ETK_NEW(rabbit::std::File, newf, owns); + if(SQ_FAILED(rabbit::sq_setinstanceup(v, 1, f))) { + ETK_DELETE(rabbit::std::File, f); return rabbit::sq_throwerror(v, "cannot create blob with negative size"); } - rabbit::sq_setreleasehook(v,1,_file_releasehook); + rabbit::sq_setreleasehook(v, 1, _file_releasehook); return 0; } diff --git a/rabbit/Class.cpp b/rabbit/Class.cpp index 024d1bb..8a2f333 100644 --- a/rabbit/Class.cpp +++ b/rabbit/Class.cpp @@ -50,8 +50,7 @@ rabbit::Class::~Class() { } rabbit::Class* rabbit::Class::create(rabbit::SharedState *ss, Class *base) { - rabbit::Class *newclass = (Class *)SQ_MALLOC(sizeof(Class)); - new ((char*)newclass) Class(ss, base); + rabbit::Class *newclass = ETK_NEW(Class, ss, base); return newclass; } diff --git a/rabbit/Closure.cpp b/rabbit/Closure.cpp index ff72315..4763f51 100644 --- a/rabbit/Closure.cpp +++ b/rabbit/Closure.cpp @@ -172,8 +172,7 @@ void rabbit::Closure::release(){ _DESTRUCT_VECTOR(ObjectPtr,f->_noutervalues,_outervalues); _DESTRUCT_VECTOR(ObjectPtr,f->_ndefaultparams,_defaultparams); __Objrelease(_function); - this->~Closure(); - sq_vm_free(this,size); + ETK_FREE(Closure, this); } void rabbit::Closure::setRoot(rabbit::WeakRef *r) { diff --git a/rabbit/FuncState.cpp b/rabbit/FuncState.cpp index 1efbdff..44c7e43 100644 --- a/rabbit/FuncState.cpp +++ b/rabbit/FuncState.cpp @@ -658,10 +658,8 @@ rabbit::FunctionProto* rabbit::FuncState::buildProto() { return f; } -rabbit::FuncState *rabbit::FuncState::pushChildState(rabbit::SharedState *ss) -{ - FuncState *child = (rabbit::FuncState *)sq_malloc(sizeof(rabbit::FuncState)); - new ((char*)child) FuncState(ss,this,_errfunc,_errtarget); +rabbit::FuncState *rabbit::FuncState::pushChildState(rabbit::SharedState *ss) { + FuncState *child = ETK_NEW(rabbit::FuncState, ss, this, _errfunc, _errtarget); _childstates.pushBack(child); return child; } diff --git a/rabbit/FunctionProto.cpp b/rabbit/FunctionProto.cpp index 9cfca53..5f52a40 100644 --- a/rabbit/FunctionProto.cpp +++ b/rabbit/FunctionProto.cpp @@ -27,8 +27,7 @@ rabbit::FunctionProto* rabbit::FunctionProto::create(rabbit::SharedState *ss,int { rabbit::FunctionProto *f; //I compact the whole class and members in a single memory allocation - f = (rabbit::FunctionProto *)sq_vm_malloc(_FUNC_SIZE(ninstructions,nliterals,nparameters,nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams)); - new ((char*)f) rabbit::FunctionProto(ss); + f = ETK_NEW(rabbit::FunctionProto, ss); f->_ninstructions = ninstructions; f->_literals = (rabbit::ObjectPtr*)&f->_instructions[ninstructions]; f->_nliterals = nliterals; @@ -60,9 +59,8 @@ void rabbit::FunctionProto::release(){ _DESTRUCT_VECTOR(OuterVar,_noutervalues,_outervalues); //_DESTRUCT_VECTOR(rabbit::LineInfo,_nlineinfos,_lineinfos); //not required are 2 integers _DESTRUCT_VECTOR(LocalVarInfo,_nlocalvarinfos,_localvarinfos); - int64_t size = _FUNC_SIZE(_ninstructions,_nliterals,_nparameters,_nfunctions,_noutervalues,_nlineinfos,_nlocalvarinfos,_ndefaultparams); - this->~FunctionProto(); - sq_vm_free(this,size); + //int64_t size = _FUNC_SIZE(_ninstructions,_nliterals,_nparameters,_nfunctions,_noutervalues,_nlineinfos,_nlocalvarinfos,_ndefaultparams); + ETK_FREE(FunctionProto, this); } const char* rabbit::FunctionProto::getLocal(rabbit::VirtualMachine *vm,uint64_t stackbase,uint64_t nseq,uint64_t nop) @@ -89,26 +87,23 @@ const char* rabbit::FunctionProto::getLocal(rabbit::VirtualMachine *vm,uint64_t int64_t rabbit::FunctionProto::getLine(rabbit::Instruction *curr) { int64_t op = (int64_t)(curr-_instructions); - int64_t line=_lineinfos[0]._line; + int64_t line = _lineinfos[0]._line; int64_t low = 0; int64_t high = _nlineinfos - 1; int64_t mid = 0; - while(low <= high) - { + while(low <= high) { mid = low + ((high - low) >> 1); int64_t curop = _lineinfos[mid]._op; - if(curop > op) - { + if(curop > op) { high = mid - 1; - } - else if(curop < op) { + } else if(curop < op) { if(mid < (_nlineinfos - 1) && _lineinfos[mid + 1]._op >= op) { break; } low = mid + 1; - } - else { //equal + } else { + //equal break; } } diff --git a/rabbit/Generator.cpp b/rabbit/Generator.cpp index ed1a84d..64d4b93 100644 --- a/rabbit/Generator.cpp +++ b/rabbit/Generator.cpp @@ -107,8 +107,7 @@ rabbit::Generator::Generator(rabbit::SharedState *ss,rabbit::Closure *closure) { } rabbit::Generator *rabbit::Generator::create(rabbit::SharedState *ss,rabbit::Closure *closure) { - rabbit::Generator *nc=(rabbit::Generator*)SQ_MALLOC(sizeof(rabbit::Generator)); - new ((char*)nc) rabbit::Generator(ss,closure); + rabbit::Generator *nc = ETK_NEW(rabbit::Generator, ss, closure); return nc; } diff --git a/rabbit/Instance.cpp b/rabbit/Instance.cpp index 8394fc6..3d9ca34 100644 --- a/rabbit/Instance.cpp +++ b/rabbit/Instance.cpp @@ -32,7 +32,7 @@ rabbit::Instance::Instance(rabbit::SharedState *ss, rabbit::Class *c, int64_t me _class = c; uint64_t nvalues = _class->_defaultvalues.size(); for(uint64_t n = 0; n < nvalues; n++) { - new ((char*)&_values[n]) rabbit::ObjectPtr(_class->_defaultvalues[n].val); + &_values[n] = ETK_NEW(rabbit::ObjectPtr, _class->_defaultvalues[n].val); } init(ss); } @@ -42,7 +42,7 @@ rabbit::Instance::Instance(rabbit::SharedState *ss, rabbit::Instance *i, int64_t _class = i->_class; uint64_t nvalues = _class->_defaultvalues.size(); for(uint64_t n = 0; n < nvalues; n++) { - new ((char*)&_values[n]) rabbit::ObjectPtr(i->_values[n]); + &_values[n] = ETK_NEW(rabbit::ObjectPtr, i->_values[n]); } init(ss); } @@ -80,8 +80,7 @@ bool rabbit::Instance::instanceOf(rabbit::Class *trg) { rabbit::Instance* rabbit::Instance::create(rabbit::SharedState *ss,rabbit::Class *theclass) { int64_t size = calcinstancesize(theclass); - Instance *newinst = (Instance *)SQ_MALLOC(size); - new ((char*)newinst) Instance(ss, theclass,size); + Instance *newinst = ETK_NEW(Instance, ss, theclass,size); if(theclass->_udsize) { newinst->_userpointer = ((unsigned char *)newinst) + (size - theclass->_udsize); } @@ -90,8 +89,7 @@ rabbit::Instance* rabbit::Instance::create(rabbit::SharedState *ss,rabbit::Class rabbit::Instance* rabbit::Instance::clone(rabbit::SharedState *ss) { int64_t size = calcinstancesize(_class); - Instance *newinst = (Instance *)SQ_MALLOC(size); - new ((char*)newinst) Instance(ss, this,size); + Instance *newinst = ETK_NEW(Instance, ss, this, size); if(_class->_udsize) { newinst->_userpointer = ((unsigned char *)newinst) + (size - _class->_udsize); } @@ -130,7 +128,6 @@ void rabbit::Instance::release() { return; } int64_t size = _memsize; - this->~Instance(); - SQ_FREE(this, size); + ETK_FREE(Instance, this); } diff --git a/rabbit/NativeClosure.cpp b/rabbit/NativeClosure.cpp index 3de8aa7..4edf94b 100644 --- a/rabbit/NativeClosure.cpp +++ b/rabbit/NativeClosure.cpp @@ -42,6 +42,5 @@ rabbit::NativeClosure::~NativeClosure() { void rabbit::NativeClosure::release(){ int64_t size = _CALC_NATVIVECLOSURE_SIZE(_noutervalues); _DESTRUCT_VECTOR(ObjectPtr,_noutervalues,_outervalues); - this->~NativeClosure(); - sq_free(this,size); + ETK_FREE(NativeClosure, this); } \ No newline at end of file diff --git a/rabbit/Outer.cpp b/rabbit/Outer.cpp index 39e8874..ed5635c 100644 --- a/rabbit/Outer.cpp +++ b/rabbit/Outer.cpp @@ -16,8 +16,7 @@ rabbit::Outer::Outer(rabbit::SharedState *ss, rabbit::ObjectPtr *outer){ } rabbit::Outer* rabbit::Outer::create(rabbit::SharedState *ss, rabbit::ObjectPtr *outer) { - rabbit::Outer *nc = (rabbit::Outer*)SQ_MALLOC(sizeof(rabbit::Outer)); - new ((char*)nc) rabbit::Outer(ss, outer); + rabbit::Outer *nc = ETK_NEW(rabbit::Outer, ss, outer); return nc; } @@ -26,6 +25,5 @@ rabbit::Outer::~Outer() { } void rabbit::Outer::release() { - this->~Outer(); - sq_vm_free(this,sizeof(rabbit::Outer)); + ETK_FREE(rabbit::Outer, this); } \ No newline at end of file diff --git a/rabbit/RefTable.cpp b/rabbit/RefTable.cpp index 0f99fbe..6cae814 100644 --- a/rabbit/RefTable.cpp +++ b/rabbit/RefTable.cpp @@ -146,13 +146,13 @@ void rabbit::RefTable::allocNodes(uint64_t size) for(n = 0; n < size - 1; n++) { bucks[n] = NULL; temp->refs = 0; - new ((char*)&temp->obj) ObjectPtr; + &temp->obj = ETK_NEW(ObjectPtr); temp->next = temp+1; temp++; } bucks[n] = NULL; temp->refs = 0; - new ((char*)&temp->obj) ObjectPtr; + &temp->obj = ETK_NEW(ObjectPtr); temp->next = NULL; _freelist = nodes; _nodes = nodes; diff --git a/rabbit/String.cpp b/rabbit/String.cpp index d43c5be..581e471 100644 --- a/rabbit/String.cpp +++ b/rabbit/String.cpp @@ -28,7 +28,7 @@ rabbit::String *rabbit::String::create(rabbit::SharedState *ss,const char *s,int void rabbit::String::release() { - REMOVE_STRING(_sharedstate,this); + REMOVE_STRING(_sharedstate, this); } int64_t rabbit::String::next(const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval) diff --git a/rabbit/StringTable.cpp b/rabbit/StringTable.cpp index 8aef7b3..2721b88 100644 --- a/rabbit/StringTable.cpp +++ b/rabbit/StringTable.cpp @@ -46,8 +46,7 @@ rabbit::String *rabbit::StringTable::add(const char *news,int64_t len) return s; //found } - rabbit::String *t = (rabbit::String *)SQ_MALLOC(sq_rsl(len)+sizeof(rabbit::String)); - new ((char*)t) rabbit::String; + rabbit::String *t = ETK_NEW(rabbit::String); t->_sharedstate = _sharedstate; memcpy(t->_val,news,sq_rsl(len)); t->_val[len] = '\0'; @@ -92,9 +91,7 @@ void rabbit::StringTable::remove(rabbit::String *bs) else _strings[h] = s->_next; _slotused--; - int64_t slen = s->_len; - s->~String(); - SQ_FREE(s,sizeof(rabbit::String) + sq_rsl(slen)); + ETK_FREE(String, s); return; } prev = s; diff --git a/rabbit/UserData.cpp b/rabbit/UserData.cpp index da3315e..54f156d 100644 --- a/rabbit/UserData.cpp +++ b/rabbit/UserData.cpp @@ -17,8 +17,7 @@ rabbit::UserData::~UserData() { } rabbit::UserData* rabbit::UserData::create(rabbit::SharedState *ss, int64_t size) { - UserData* ud = (UserData*)SQ_MALLOC(sq_aligning(sizeof(UserData))+size); - new ((char*)ud) UserData(ss); + UserData* ud = ETK_NEW(UserData, ss); ud->m_size = size; ud->m_typetag = 0; return ud; @@ -28,9 +27,7 @@ void rabbit::UserData::release() { if (m_hook) { m_hook((rabbit::UserPointer)sq_aligning(this + 1),m_size); } - int64_t tsize = m_size; - this->~UserData(); - SQ_FREE(this, sq_aligning(sizeof(UserData)) + tsize); + ETK_FREE(UserData, this); } const int64_t& rabbit::UserData::getsize() const { diff --git a/rabbit/sqapi.cpp b/rabbit/sqapi.cpp index e39df80..0d62f4a 100644 --- a/rabbit/sqapi.cpp +++ b/rabbit/sqapi.cpp @@ -61,16 +61,13 @@ rabbit::VirtualMachine* rabbit::sq_open(int64_t initialstacksize) { rabbit::SharedState *ss = ETK_NEW(rabbit::SharedState); ss->init(); - - char* allocatedData = (char*)SQ_MALLOC(sizeof(rabbit::VirtualMachine)); - rabbit::VirtualMachine *v = new (allocatedData) rabbit::VirtualMachine(ss); + rabbit::VirtualMachine *v = ETK_NEW(rabbit::VirtualMachine, ss); ss->_root_vm = v; if(v->init(NULL, initialstacksize)) { return v; } else { - v->~VirtualMachine(); - SQ_FREE(allocatedData,sizeof(rabbit::VirtualMachine)); + ETK_FREE(rabbit::VirtualMachine, v); return NULL; } return v; @@ -80,17 +77,14 @@ rabbit::VirtualMachine* rabbit::sq_newthread(rabbit::VirtualMachine* friendvm, i { rabbit::SharedState *ss; ss=_get_shared_state(friendvm); - - char* allocatedData = (char*)SQ_MALLOC(sizeof(rabbit::VirtualMachine)); - rabbit::VirtualMachine *v = new (allocatedData) rabbit::VirtualMachine(ss); + rabbit::VirtualMachine *v = ETK_NEW(rabbit::VirtualMachine, ss); ss->_root_vm = v; if(v->init(friendvm, initialstacksize)) { friendvm->push(v); return v; } else { - v->~VirtualMachine(); - SQ_FREE(allocatedData,sizeof(rabbit::VirtualMachine)); + ETK_FREE(rabbit::VirtualMachine, v); return NULL; } } @@ -258,17 +252,17 @@ void rabbit::sq_pushstring(rabbit::VirtualMachine* v,const char *s,int64_t len) else v->pushNull(); } -void rabbit::sq_pushinteger(rabbit::VirtualMachine* v,int64_t n) +void rabbit::sq_pushinteger(rabbit::VirtualMachine* v, int64_t n) { v->push(n); } -void rabbit::sq_pushbool(rabbit::VirtualMachine* v,rabbit::Bool b) +void rabbit::sq_pushbool(rabbit::VirtualMachine* v, rabbit::Bool b) { v->push(b?true:false); } -void rabbit::sq_pushfloat(rabbit::VirtualMachine* v,float_t n) +void rabbit::sq_pushfloat(rabbit::VirtualMachine* v, float_t n) { v->push(n); }