[DEV] continue rework ==> take big mistake, use basic pointer to all after object other data (typically C style coding)

[DEV] start rework bad allocator ==> not work
2018-07-06 00:08:43 +02:00 · 2018-07-05 23:37:47 +02:00
27 changed files with 110 additions and 146 deletions
--- 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);
--- 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;
 }

--- 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];
--- 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;
 }

@@ -87,7 +86,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) {
--- 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;
@@ -173,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) {
--- a/rabbit/FuncState.cpp
+++ b/rabbit/FuncState.cpp
@@ -658,17 +658,15 @@ 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;
 }

 void rabbit::FuncState::popChildState() {
 	FuncState *child = _childstates.back();
-	sq_delete(child, FuncState);
+	ETK_DELETE(FuncState, child);
 	_childstates.popBack();
 }

--- 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;
 		}
 	}
--- 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;
 }

@@ -123,6 +122,6 @@ void rabbit::Generator::kill() {
 }

 void rabbit::Generator::release() {
-	sq_delete(this,Generator);
+	ETK_DELETE(Generator, this);
 }

--- 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);
 }

--- 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);
@@ -43,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);
 }
--- 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<int64_t> _typecheck;
 			rabbit::ObjectPtr *_outervalues;
--- a/rabbit/Object.hpp
+++ b/rabbit/Object.hpp
@@ -12,7 +12,6 @@
 #include <rabbit/ObjectValue.hpp>

 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;
-	}
 }
--- a/rabbit/ObjectPtr.hpp
+++ b/rabbit/ObjectPtr.hpp
@@ -14,11 +14,11 @@
 #include <rabbit/Object.hpp>

 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);
--- 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);
 }
--- a/rabbit/RefCounted.cpp
+++ b/rabbit/RefCounted.cpp
@@ -7,6 +7,9 @@
 */

 #include <rabbit/RefCounted.hpp>
+
+#include <etk/Allocator.hpp>
+
 #include <rabbit/WeakRef.hpp>
 #include <rabbit/rabbit.hpp>
 #include <rabbit/squtils.hpp>
@@ -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;
--- 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;
--- a/rabbit/SharedState.cpp
+++ b/rabbit/SharedState.cpp
@@ -6,6 +6,9 @@
 * @license MPL-2 (see license file)
 */
 #include <rabbit/SharedState.hpp>
+
+#include <etk/Allocator.hpp>
+
 #include <rabbit/Table.hpp>
 #include <rabbit/String.hpp>
 #include <rabbit/StringTable.hpp>
@@ -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<rabbit::ObjectPtr>);
-	sq_new(_systemstrings,etk::Vector<rabbit::ObjectPtr>);
-	sq_new(_types,etk::Vector<rabbit::ObjectPtr>);
+	_stringtable = ETK_NEW(rabbit::StringTable, this);
+	_metamethods = ETK_NEW(etk::Vector<rabbit::ObjectPtr>);
+	_systemstrings = ETK_NEW(etk::Vector<rabbit::ObjectPtr>);
+	_types = ETK_NEW(etk::Vector<rabbit::ObjectPtr>);
 	_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<rabbit::ObjectPtr>;
-	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<rabbit::ObjectPtr>, _types);
+	ETK_DELETE(etk::Vector<rabbit::ObjectPtr>, _systemstrings);
+	ETK_DELETE(etk::Vector<rabbit::ObjectPtr>, _metamethods);
+	ETK_DELETE(rabbit::StringTable, _stringtable);
+	if(_scratchpad) {
+		SQ_FREE(_scratchpad,_scratchpadsize);
+	}
 }


--- 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)
--- 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;
--- 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);
 }
--- 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 {
--- 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)){
--- 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);
 }
--- a/rabbit/sqapi.cpp
+++ b/rabbit/sqapi.cpp
@@ -9,6 +9,7 @@
 #include <rabbit/VirtualMachine.hpp>


+#include <etk/Allocator.hpp>
 #include <rabbit/Array.hpp>


@@ -58,19 +59,15 @@ 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));
-	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;
 	}
 }
@@ -140,7 +134,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()
@@ -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);
 }
--- 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;
--- a/rabbit/sqconfig.hpp
+++ b/rabbit/sqconfig.hpp
@@ -8,6 +8,7 @@
 #pragma once

 #include <etk/types.hpp>
+#include <etk/Allocator.hpp>
 #include <ctype.h>
 #ifdef SQUSEDOUBLE
 typedef double float_t;
--- 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));
Author	SHA1	Message	Date
Edouard DUPIN	a8ed39d3b4	[DEV] continue rework ==> take big mistake, use basic pointer to all after object other data (typically C style coding)	2018-07-06 00:08:43 +02:00
Edouard DUPIN	af0dae2fa5	[DEV] start rework bad allocator ==> not work	2018-07-05 23:37:47 +02:00