From af0dae2fa560b3177691ef11dff009b7b4aa9cc0 Mon Sep 17 00:00:00 2001 From: Edouard DUPIN Date: Thu, 5 Jul 2018 23:37:47 +0200 Subject: [PATCH] [DEV] start rework bad allocator ==> not work --- rabbit/Array.cpp | 5 ++--- rabbit/Class.cpp | 2 +- rabbit/Closure.cpp | 3 +-- rabbit/FuncState.cpp | 2 +- rabbit/Generator.cpp | 2 +- rabbit/NativeClosure.cpp | 3 +-- rabbit/NativeClosure.hpp | 1 - rabbit/Object.hpp | 11 ----------- rabbit/ObjectPtr.hpp | 36 ++++++++++++++++++------------------ rabbit/RefCounted.cpp | 5 ++++- rabbit/SharedState.cpp | 25 ++++++++++++++----------- rabbit/Table.cpp | 2 +- rabbit/VirtualMachine.cpp | 24 +++++++++++++++--------- rabbit/WeakRef.cpp | 2 +- rabbit/sqapi.cpp | 6 +++--- rabbit/sqbaselib.cpp | 4 ++-- rabbit/sqconfig.hpp | 1 + rabbit/squtils.hpp | 3 --- 18 files changed, 66 insertions(+), 71 deletions(-) diff --git a/rabbit/Array.cpp b/rabbit/Array.cpp index b335134..3384d05 100644 --- a/rabbit/Array.cpp +++ b/rabbit/Array.cpp @@ -30,8 +30,7 @@ rabbit::Array::~Array() { // TODO : remove this ETK_ALLOC can do it natively ... rabbit::Array* rabbit::Array::create(rabbit::SharedState* _ss, int64_t _ninitialsize) { - Array *newarray=(Array*)SQ_MALLOC(sizeof(Array)); - new ((char*)newarray) Array(_ss, _ninitialsize); + Array *newarray = ETK_NEW(Array, _ss, _ninitialsize); return newarray; } void rabbit::Array::finalize() { @@ -126,7 +125,7 @@ bool rabbit::Array::remove(int64_t _idx) { return true; } void rabbit::Array::release() { - sq_delete(this, Array); + ETK_DELETE(Array, this); } rabbit::ObjectPtr& rabbit::Array::operator[] (const size_t _pos) { return m_data[_pos]; diff --git a/rabbit/Class.cpp b/rabbit/Class.cpp index 193ef3d..024d1bb 100644 --- a/rabbit/Class.cpp +++ b/rabbit/Class.cpp @@ -87,7 +87,7 @@ void rabbit::Class::release() { if (_hook) { _hook(_typetag,0); } - sq_delete(this, Class); + ETK_DELETE(Class, this); } bool rabbit::Class::newSlot(rabbit::SharedState *ss,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,bool bstatic) { diff --git a/rabbit/Closure.cpp b/rabbit/Closure.cpp index 53ef1a4..ff72315 100644 --- a/rabbit/Closure.cpp +++ b/rabbit/Closure.cpp @@ -156,8 +156,7 @@ rabbit::Closure::Closure(rabbit::SharedState *ss,rabbit::FunctionProto *func){ } rabbit::Closure *rabbit::Closure::create(rabbit::SharedState *ss,rabbit::FunctionProto *func,rabbit::WeakRef *root){ int64_t size = _CALC_CLOSURE_SIZE(func); - rabbit::Closure *nc=(rabbit::Closure*)SQ_MALLOC(size); - new ((char*)nc) rabbit::Closure(ss,func); + rabbit::Closure *nc = ETK_NEW(rabbit::Closure, ss, func); nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1); nc->_defaultparams = &nc->_outervalues[func->_noutervalues]; nc->_root = root; diff --git a/rabbit/FuncState.cpp b/rabbit/FuncState.cpp index 83d953d..1efbdff 100644 --- a/rabbit/FuncState.cpp +++ b/rabbit/FuncState.cpp @@ -668,7 +668,7 @@ rabbit::FuncState *rabbit::FuncState::pushChildState(rabbit::SharedState *ss) void rabbit::FuncState::popChildState() { FuncState *child = _childstates.back(); - sq_delete(child, FuncState); + ETK_DELETE(FuncState, child); _childstates.popBack(); } diff --git a/rabbit/Generator.cpp b/rabbit/Generator.cpp index d8c92f0..ed1a84d 100644 --- a/rabbit/Generator.cpp +++ b/rabbit/Generator.cpp @@ -123,6 +123,6 @@ void rabbit::Generator::kill() { } void rabbit::Generator::release() { - sq_delete(this,Generator); + ETK_DELETE(Generator, this); } diff --git a/rabbit/NativeClosure.cpp b/rabbit/NativeClosure.cpp index 65a77c4..3de8aa7 100644 --- a/rabbit/NativeClosure.cpp +++ b/rabbit/NativeClosure.cpp @@ -17,8 +17,7 @@ rabbit::NativeClosure::NativeClosure(rabbit::SharedState *ss,SQFUNCTION func) { rabbit::NativeClosure* rabbit::NativeClosure::create(rabbit::SharedState *ss,SQFUNCTION func,int64_t nouters) { int64_t size = _CALC_NATVIVECLOSURE_SIZE(nouters); - rabbit::NativeClosure *nc=(rabbit::NativeClosure*)SQ_MALLOC(size); - new ((char*)nc) rabbit::NativeClosure(ss,func); + rabbit::NativeClosure *nc = ETK_NEW(rabbit::NativeClosure, ss, func); nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1); nc->_noutervalues = nouters; _CONSTRUCT_VECTOR(rabbit::ObjectPtr,nc->_noutervalues,nc->_outervalues); diff --git a/rabbit/NativeClosure.hpp b/rabbit/NativeClosure.hpp index 4844e12..7501163 100644 --- a/rabbit/NativeClosure.hpp +++ b/rabbit/NativeClosure.hpp @@ -28,7 +28,6 @@ namespace rabbit { rabbit::NativeClosure *clone(); ~NativeClosure(); void release(); - int64_t _nparamscheck; etk::Vector _typecheck; rabbit::ObjectPtr *_outervalues; diff --git a/rabbit/Object.hpp b/rabbit/Object.hpp index 185e4b2..9f2470b 100644 --- a/rabbit/Object.hpp +++ b/rabbit/Object.hpp @@ -12,7 +12,6 @@ #include namespace rabbit { - class Object { public: rabbit::ObjectType _type; @@ -228,14 +227,4 @@ namespace rabbit { void releaseRef(); void swap(rabbit::Object& _obj); }; - - inline void _Swap(rabbit::Object &a,rabbit::Object &b) - { - rabbit::ObjectType tOldType = a._type; - rabbit::ObjectValue unOldVal = a._unVal; - a._type = b._type; - a._unVal = b._unVal; - b._type = tOldType; - b._unVal = unOldVal; - } } diff --git a/rabbit/ObjectPtr.hpp b/rabbit/ObjectPtr.hpp index 339013f..f7718f7 100644 --- a/rabbit/ObjectPtr.hpp +++ b/rabbit/ObjectPtr.hpp @@ -14,11 +14,11 @@ #include namespace rabbit { - #define RABBIT_OBJ_REF_TYPE_DECLARE(type,_class,sym) \ + #define RABBIT_OBJ_REF_TYPE_DECLARE(type,_class) \ ObjectPtr(_class * x); \ ObjectPtr& operator=(_class *x); - #define RABBIT_SCALAR_TYPE_DECLARE(type,_class,sym) \ + #define RABBIT_SCALAR_TYPE_DECLARE(type,_class) \ ObjectPtr(_class x); \ ObjectPtr& operator=(_class x); @@ -28,23 +28,23 @@ namespace rabbit { ObjectPtr(const ObjectPtr& _obj); ObjectPtr(const Object& _obj); - RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_TABLE, rabbit::Table, pTable) - RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_CLASS, rabbit::Class, pClass) - RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_INSTANCE, rabbit::Instance, pInstance) - RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_ARRAY, rabbit::Array, pArray) - RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_CLOSURE, rabbit::Closure, pClosure) - RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_NATIVECLOSURE, rabbit::NativeClosure, pNativeClosure) - RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_OUTER, rabbit::Outer, pOuter) - RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_GENERATOR, rabbit::Generator, pGenerator) - RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_STRING, rabbit::String, pString) - RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_USERDATA, UserData, pUserData) - RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_WEAKREF, WeakRef, pWeakRef) - RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_THREAD, VirtualMachine, pThread) - RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_FUNCPROTO, rabbit::FunctionProto, pFunctionProto) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_TABLE, rabbit::Table) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_CLASS, rabbit::Class) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_INSTANCE, rabbit::Instance) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_ARRAY, rabbit::Array) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_CLOSURE, rabbit::Closure) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_NATIVECLOSURE, rabbit::NativeClosure) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_OUTER, rabbit::Outer) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_GENERATOR, rabbit::Generator) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_STRING, rabbit::String) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_USERDATA, UserData) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_WEAKREF, WeakRef) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_THREAD, VirtualMachine) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_FUNCPROTO, rabbit::FunctionProto) - RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_INTEGER, int64_t, nInteger) - RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_FLOAT, float_t, fFloat) - RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_USERPOINTER, UserPointer, pUserPointer) + RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_INTEGER, int64_t) + RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_FLOAT, float_t) + RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_USERPOINTER, UserPointer) ObjectPtr(bool _value); ObjectPtr& operator=(bool _value); diff --git a/rabbit/RefCounted.cpp b/rabbit/RefCounted.cpp index fb3a4bc..3be5bf9 100644 --- a/rabbit/RefCounted.cpp +++ b/rabbit/RefCounted.cpp @@ -7,6 +7,9 @@ */ #include + +#include + #include #include #include @@ -14,7 +17,7 @@ rabbit::WeakRef * rabbit::RefCounted::getWeakRef(rabbit::ObjectType type) { if(!_weakref) { - sq_new(_weakref, WeakRef); + _weakref = ETK_NEW(WeakRef); _weakref->_obj._unVal.raw = 0; //clean the whole union _weakref->_obj._type = type; _weakref->_obj._unVal.pRefCounted = this; diff --git a/rabbit/SharedState.cpp b/rabbit/SharedState.cpp index a6e9066..2b74f61 100644 --- a/rabbit/SharedState.cpp +++ b/rabbit/SharedState.cpp @@ -6,6 +6,9 @@ * @license MPL-2 (see license file) */ #include + +#include + #include #include #include @@ -97,11 +100,10 @@ void rabbit::SharedState::init() { _scratchpad=NULL; _scratchpadsize=0; - _stringtable = (rabbit::StringTable*)SQ_MALLOC(sizeof(rabbit::StringTable)); - new ((char*)_stringtable) rabbit::StringTable(this); - sq_new(_metamethods,etk::Vector); - sq_new(_systemstrings,etk::Vector); - sq_new(_types,etk::Vector); + _stringtable = ETK_NEW(rabbit::StringTable, this); + _metamethods = ETK_NEW(etk::Vector); + _systemstrings = ETK_NEW(etk::Vector); + _types = ETK_NEW(etk::Vector); _metamethodsmap = rabbit::Table::create(this,rabbit::MT_LAST-1); //adding type strings to avoid memory trashing //types names @@ -185,12 +187,13 @@ rabbit::SharedState::~SharedState() _instance_default_delegate.Null(); _weakref_default_delegate.Null(); _refs_table.finalize(); - using tmpType = etk::Vector; - sq_delete(_types, tmpType); - sq_delete(_systemstrings, tmpType); - sq_delete(_metamethods, tmpType); - sq_delete(_stringtable, StringTable); - if(_scratchpad)SQ_FREE(_scratchpad,_scratchpadsize); + ETK_DELETE(etk::Vector, _types); + ETK_DELETE(etk::Vector, _systemstrings); + ETK_DELETE(etk::Vector, _metamethods); + ETK_DELETE(rabbit::StringTable, _stringtable); + if(_scratchpad) { + SQ_FREE(_scratchpad,_scratchpadsize); + } } diff --git a/rabbit/Table.cpp b/rabbit/Table.cpp index 79122f2..e5f330a 100644 --- a/rabbit/Table.cpp +++ b/rabbit/Table.cpp @@ -293,5 +293,5 @@ int64_t rabbit::Table::countUsed() const { } void rabbit::Table::release() { - sq_delete(this, Table); + ETK_DELETE(Table, this); } diff --git a/rabbit/VirtualMachine.cpp b/rabbit/VirtualMachine.cpp index 9aab933..f8ac531 100644 --- a/rabbit/VirtualMachine.cpp +++ b/rabbit/VirtualMachine.cpp @@ -68,7 +68,7 @@ bool rabbit::VirtualMachine::BW_OP(uint64_t op,rabbit::ObjectPtr &trg,const rabb } void rabbit::VirtualMachine::release() { - sq_delete(this,VirtualMachine); + ETK_DELETE(VirtualMachine, this); } #define _ARITH_(op,trg,o1,o2) \ @@ -225,7 +225,7 @@ bool rabbit::VirtualMachine::NEG_OP(rabbit::ObjectPtr &trg,const rabbit::ObjectP if(callMetaMethod(closure, MT_UNM, 1, temp_reg) == false) { return false; } - _Swap(trg,temp_reg); + trg.swap(temp_reg); return true; } } @@ -868,17 +868,21 @@ exception_restore: SQ_THROW(); } STK(arg3) = o; - _Swap(TARGET,temp_reg);//TARGET = temp_reg; + TARGET.swap(temp_reg); } continue; case _OP_GETK: - if (!get(STK(arg2), ci->_literals[arg1], temp_reg, 0,arg2)) { SQ_THROW();} - _Swap(TARGET,temp_reg);//TARGET = temp_reg; + if (!get(STK(arg2), ci->_literals[arg1], temp_reg, 0,arg2)) { + SQ_THROW(); + } + TARGET.swap(temp_reg); continue; case _OP_MOVE: TARGET = STK(arg1); continue; case _OP_NEWSLOT: _GUARD(newSlot(STK(arg1), STK(arg2), STK(arg3),false)); - if(arg0 != 0xFF) TARGET = STK(arg3); + if(arg0 != 0xFF) { + TARGET = STK(arg3); + } continue; case _OP_DELETE: _GUARD(deleteSlot(STK(arg1), STK(arg2), TARGET)); continue; case _OP_SET: @@ -887,7 +891,7 @@ exception_restore: continue; case _OP_GET: if (!get(STK(arg1), STK(arg2), temp_reg, 0,arg1)) { SQ_THROW(); } - _Swap(TARGET,temp_reg);//TARGET = temp_reg; + TARGET.swap(temp_reg); continue; case _OP_EQ:{ bool res; @@ -912,7 +916,7 @@ exception_restore: if(Return(arg0, arg1, temp_reg)){ assert(traps==0); //outres = temp_reg; - _Swap(outres,temp_reg); + outres.swap(temp_reg); return true; } continue; @@ -1053,7 +1057,9 @@ exception_restore: if(sarg1 != MAX_FUNC_STACKSIZE) temp_reg = STK(arg1); _GUARD(ci->_generator->yield(this,arg2)); traps -= ci->_etraps; - if(sarg1 != MAX_FUNC_STACKSIZE) _Swap(STK(arg1),temp_reg);//STK(arg1) = temp_reg; + if(sarg1 != MAX_FUNC_STACKSIZE) { + STK(arg1).swap(temp_reg); + } } else { raise_error("trying to yield a '%s',only genenerator can be yielded", getTypeName(ci->_generator)); SQ_THROW();} if(Return(arg0, arg1, temp_reg)){ diff --git a/rabbit/WeakRef.cpp b/rabbit/WeakRef.cpp index 6a61613..c6f104b 100644 --- a/rabbit/WeakRef.cpp +++ b/rabbit/WeakRef.cpp @@ -15,5 +15,5 @@ void rabbit::WeakRef::release() { if(_obj.isRefCounted() == true) { _obj._unVal.pRefCounted->_weakref = null; } - sq_delete(this, WeakRef); + ETK_DELETE(WeakRef, this); } diff --git a/rabbit/sqapi.cpp b/rabbit/sqapi.cpp index ab7c40c..e39df80 100644 --- a/rabbit/sqapi.cpp +++ b/rabbit/sqapi.cpp @@ -9,6 +9,7 @@ #include +#include #include @@ -58,8 +59,7 @@ namespace rabbit { } rabbit::VirtualMachine* rabbit::sq_open(int64_t initialstacksize) { - rabbit::SharedState *ss; - sq_new(ss, rabbit::SharedState); + rabbit::SharedState *ss = ETK_NEW(rabbit::SharedState); ss->init(); char* allocatedData = (char*)SQ_MALLOC(sizeof(rabbit::VirtualMachine)); @@ -140,7 +140,7 @@ void rabbit::sq_close(rabbit::VirtualMachine* v) { rabbit::SharedState *ss = _get_shared_state(v); ss->_root_vm.toVirtualMachine()->finalize(); - sq_delete(ss, SharedState); + ETK_DELETE(SharedState, ss); } int64_t rabbit::sq_getversion() diff --git a/rabbit/sqbaselib.cpp b/rabbit/sqbaselib.cpp index 5664cf4..d732e99 100644 --- a/rabbit/sqbaselib.cpp +++ b/rabbit/sqbaselib.cpp @@ -758,7 +758,7 @@ static bool _hsort_sift_down(rabbit::VirtualMachine* v,rabbit::Array *arr, int64 return false; // We'd be swapping ourselve. The compare function is incorrect } - _Swap((*arr)[root], (*arr)[maxChild]); + (*arr)[root].swap((*arr)[maxChild]); root = maxChild; } else { @@ -779,7 +779,7 @@ static bool _hsort(rabbit::VirtualMachine* v,rabbit::ObjectPtr &arr, int64_t SQ_ for (i = array_size-1; i >= 1; i--) { - _Swap((*a)[0],(*a)[i]); + (*a)[0].swap((*a)[i]); if(!_hsort_sift_down(v,a, 0, i-1,func)) return false; } return true; diff --git a/rabbit/sqconfig.hpp b/rabbit/sqconfig.hpp index cde6685..c75c03b 100644 --- a/rabbit/sqconfig.hpp +++ b/rabbit/sqconfig.hpp @@ -8,6 +8,7 @@ #pragma once #include +#include #include #ifdef SQUSEDOUBLE typedef double float_t; diff --git a/rabbit/squtils.hpp b/rabbit/squtils.hpp index 174038d..2bf8947 100644 --- a/rabbit/squtils.hpp +++ b/rabbit/squtils.hpp @@ -12,9 +12,6 @@ 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 ((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));