[DEV] some patch

[DEV] remove store compiled file
[DEV] remove __Swap()
2018-07-06 23:20:24 +02:00 · 2018-07-06 21:09:45 +02:00 · 2018-07-06 00:12:59 +02:00
31 changed files with 209 additions and 543 deletions
--- a/cmdLine/rabbit.cpp
+++ b/cmdLine/rabbit.cpp
@@ -72,9 +72,6 @@ void PrintUsage()
 {
 	fprintf(stderr,"usage: sq <options> <scriptpath [args]>.\n"
 		"Available options are:\n"
-		"   -c			  compiles the file to bytecode(default output 'out.karrot')\n"
-		"   -o			  specifies output file for the -c option\n"
-		"   -c			  compiles only\n"
 		"   -d			  generates debug infos\n"
 		"   -v			  displays version infos\n"
 		"   -h			  prints help\n");
@@ -87,8 +84,6 @@ void PrintUsage()
 int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
 {
 	int i;
-	int compiles_only = 0;
-	char * output = NULL;
 	*retval = 0;
 	if(argc>1)
 	{
@@ -104,14 +99,6 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
 				case 'd':
 					sq_enabledebuginfo(v,1);
 					break;
-				case 'c':
-					compiles_only = 1;
-					break;
-				case 'o':
-					if(arg < argc) {
-						arg++;
-						output = argv[arg];
-					}
 					break;
 				case 'v':
 					PrintVersionInfos();
@@ -140,49 +127,28 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)

 			arg++;

-			//sq_pushstring(v,"ARGS",-1);
-			//sq_newarray(v,0);
-
-			//sq_createslot(v,-3);
-			//sq_pop(v,1);
-			if(compiles_only) {
-				if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,SQTrue))){
-					const char *outfile = "out.karrot";
-					if(output) {
-						outfile = output;
-					}
-					if(SQ_SUCCEEDED(rabbit::std::writeclosuretofile(v,outfile)))
-						return _DONE;
+			if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,SQTrue))) {
+				int callargs = 1;
+				sq_pushroottable(v);
+				for(i=arg;i<argc;i++)
+				{
+					const char *a;
+					a=argv[i];
+					sq_pushstring(v,a,-1);
+					callargs++;
 				}
-			}
-			else {
-				//if(SQ_SUCCEEDED(rabbit::std::dofile(v,filename,SQFalse,SQTrue))) {
-					//return _DONE;
-				//}
-				if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,SQTrue))) {
-					int callargs = 1;
-					sq_pushroottable(v);
-					for(i=arg;i<argc;i++)
-					{
-						const char *a;
-						a=argv[i];
-						sq_pushstring(v,a,-1);
-						callargs++;
-						//sq_arrayappend(v,-2);
+				if(SQ_SUCCEEDED(sq_call(v,callargs,SQTrue,SQTrue))) {
+					rabbit::ObjectType type = sq_gettype(v,-1);
+					if(type == rabbit::OT_INTEGER) {
+						*retval = type;
+						sq_getinteger(v,-1,retval);
 					}
-					if(SQ_SUCCEEDED(sq_call(v,callargs,SQTrue,SQTrue))) {
-						rabbit::ObjectType type = sq_gettype(v,-1);
-						if(type == rabbit::OT_INTEGER) {
-							*retval = type;
-							sq_getinteger(v,-1,retval);
-						}
-						return _DONE;
-					}
-					else{
-						return _ERROR;
-					}
-
+					return _DONE;
 				}
+				else{
+					return _ERROR;
+				}
+
 			}
 			//if this point is reached an error occurred
 			{
@@ -291,7 +257,7 @@ int main(int argc, char* argv[])
 	_CrtsetAllocHook(MemAllocHook);
 #endif

-	v=rabbit::sq_open(1024);
+	v=rabbit::sq_open();
 	sq_setprintfunc(v,printfunc,errorfunc);

 	sq_pushroottable(v);
--- a/rabbit-std/sqstdblob.cpp
+++ b/rabbit-std/sqstdblob.cpp
@@ -138,9 +138,10 @@ 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 = ETK_NEW(rabbit::std::Blob, size);
+	rabbit::std::Blob *b = new (rabbit::sq_malloc(sizeof(rabbit::std::Blob)))rabbit::std::Blob(size);
 	if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,b))) {
-		ETK_FREE(rabbit::std::Blob, b);
+		b->~Blob();
+		rabbit::sq_free(b,sizeof(rabbit::std::Blob));
 		return rabbit::sq_throwerror(v, "cannot create blob");
 	}
 	rabbit::sq_setreleasehook(v,1,_blob_releasehook);
@@ -155,10 +156,11 @@ 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 = ETK_NEW(rabbit::std::Blob, other->Len());
+	rabbit::std::Blob *thisone = new (rabbit::sq_malloc(sizeof(rabbit::std::Blob)))rabbit::std::Blob(other->Len());
 	memcpy(thisone->getBuf(),other->getBuf(),thisone->Len());
 	if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,thisone))) {
-		ETK_FREE(rabbit::std::Blob, thisone);
+		thisone->~Blob();
+		rabbit::sq_free(thisone,sizeof(rabbit::std::Blob));
 		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,12 +147,13 @@ static int64_t _file_constructor(rabbit::VirtualMachine* v)
 		return rabbit::sq_throwerror(v,"wrong parameter");
 	}

-	f = ETK_NEW(rabbit::std::File, newf, owns);
-	if(SQ_FAILED(rabbit::sq_setinstanceup(v, 1, f))) {
-		ETK_DELETE(rabbit::std::File, f);
+	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));
 		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;
 }

@@ -316,41 +317,38 @@ rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const char *filen
 			//probably an empty file
 			us = 0;
 		}
-		if(us == SQ_BYTECODE_STREAM_TAG) { //BYTECODE
-			rabbit::std::fseek(file,0,SQ_SEEK_SET);
-			if(SQ_SUCCEEDED(sq_readclosure(v,file_read,file))) {
-				rabbit::std::fclose(file);
-				return SQ_OK;
-			}
+		switch (us) {
+			//gotta swap the next 2 lines on BIG endian machines
+			case 0xFFFE:
+				func = _io_file_lexfeed_UCS2_BE;
+				break; //UTF-16 little endian;
+			case 0xFEFF:
+				func = _io_file_lexfeed_UCS2_LE;
+				break; //UTF-16 big endian;
+			case 0xBBEF:
+				if(rabbit::std::fread(&uc,1,sizeof(uc),file) == 0) {
+					rabbit::std::fclose(file);
+					return sq_throwerror(v,"io error");
+				}
+				if(uc != 0xBF) {
+					rabbit::std::fclose(file);
+					return sq_throwerror(v,"Unrecognized encoding");
+				}
+				func = _io_file_lexfeed_PLAIN;
+				break;
+				//UTF-8 ;
+			default:
+				rabbit::std::fseek(file,0,SQ_SEEK_SET);
+				break;
+				// ascii
 		}
-		else { //SCRIPT
-
-			switch(us)
-			{
-				//gotta swap the next 2 lines on BIG endian machines
-				case 0xFFFE: func = _io_file_lexfeed_UCS2_BE; break;//UTF-16 little endian;
-				case 0xFEFF: func = _io_file_lexfeed_UCS2_LE; break;//UTF-16 big endian;
-				case 0xBBEF:
-					if(rabbit::std::fread(&uc,1,sizeof(uc),file) == 0) {
-						rabbit::std::fclose(file);
-						return sq_throwerror(v,"io error");
-					}
-					if(uc != 0xBF) {
-						rabbit::std::fclose(file);
-						return sq_throwerror(v,"Unrecognized encoding");
-					}
-					func = _io_file_lexfeed_PLAIN;
-					break;//UTF-8 ;
-				default: rabbit::std::fseek(file,0,SQ_SEEK_SET); break; // ascii
-			}
-			IOBuffer buffer;
-			buffer.ptr = 0;
-			buffer.size = 0;
-			buffer.file = file;
-			if(SQ_SUCCEEDED(sq_compile(v,func,&buffer,filename,printerror))){
-				rabbit::std::fclose(file);
-				return SQ_OK;
-			}
+		IOBuffer buffer;
+		buffer.ptr = 0;
+		buffer.size = 0;
+		buffer.file = file;
+		if(SQ_SUCCEEDED(sq_compile(v,func,&buffer,filename,printerror))){
+			rabbit::std::fclose(file);
+			return SQ_OK;
 		}
 		rabbit::std::fclose(file);
 		return SQ_ERROR;
@@ -375,18 +373,6 @@ rabbit::Result rabbit::std::dofile(rabbit::VirtualMachine* v,const char *filenam
 	return SQ_ERROR;
 }

-rabbit::Result rabbit::std::writeclosuretofile(rabbit::VirtualMachine* v,const char *filename)
-{
-	SQFILE file = rabbit::std::fopen(filename,"wb+");
-	if(!file) return sq_throwerror(v,"cannot open the file");
-	if(SQ_SUCCEEDED(sq_writeclosure(v,file_write,file))) {
-		rabbit::std::fclose(file);
-		return SQ_OK;
-	}
-	rabbit::std::fclose(file);
-	return SQ_ERROR; //forward the error
-}
-
 int64_t _g_io_loadfile(rabbit::VirtualMachine* v)
 {
 	const char *filename;
@@ -400,15 +386,6 @@ int64_t _g_io_loadfile(rabbit::VirtualMachine* v)
 	return SQ_ERROR; //propagates the error
 }

-int64_t _g_io_writeclosuretofile(rabbit::VirtualMachine* v)
-{
-	const char *filename;
-	sq_getstring(v,2,&filename);
-	if(SQ_SUCCEEDED(rabbit::std::writeclosuretofile(v,filename)))
-		return 1;
-	return SQ_ERROR; //propagates the error
-}
-
 int64_t _g_io_dofile(rabbit::VirtualMachine* v)
 {
 	const char *filename;
@@ -427,7 +404,6 @@ int64_t _g_io_dofile(rabbit::VirtualMachine* v)
 static const rabbit::RegFunction iolib_funcs[]={
 	_DECL_GLOBALIO_FUNC(loadfile,-2,".sb"),
 	_DECL_GLOBALIO_FUNC(dofile,-2,".sb"),
-	_DECL_GLOBALIO_FUNC(writeclosuretofile,3,".sc"),
 	{NULL,(SQFUNCTION)0,0,NULL}
 };

--- a/rabbit-std/sqstdio.hpp
+++ b/rabbit-std/sqstdio.hpp
@@ -44,7 +44,6 @@ rabbit::Result getfile(rabbit::VirtualMachine* v, int64_t idx, SQFILE *file);
 //compiler helpers
 rabbit::Result loadfile(rabbit::VirtualMachine* v,const char *filename,rabbit::Bool printerror);
 rabbit::Result dofile(rabbit::VirtualMachine* v,const char *filename,rabbit::Bool retval,rabbit::Bool printerror);
-rabbit::Result writeclosuretofile(rabbit::VirtualMachine* v,const char *filename);

 rabbit::Result register_iolib(rabbit::VirtualMachine* v);

--- a/rabbit/Array.cpp
+++ b/rabbit/Array.cpp
@@ -30,7 +30,8 @@ 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 = ETK_NEW(Array, _ss, _ninitialsize);
+	Array *newarray=(Array*)SQ_MALLOC(sizeof(Array));
+	new ((char*)newarray) Array(_ss, _ninitialsize);
 	return newarray;
 }
 void rabbit::Array::finalize() {
@@ -125,7 +126,7 @@ bool rabbit::Array::remove(int64_t _idx) {
 	return true;
 }
 void rabbit::Array::release() {
-	ETK_DELETE(Array, this);
+	sq_delete(this, Array);
 }
 rabbit::ObjectPtr& rabbit::Array::operator[] (const size_t _pos) {
 	return m_data[_pos];
--- a/rabbit/Class.cpp
+++ b/rabbit/Class.cpp
@@ -50,7 +50,8 @@ rabbit::Class::~Class() {
 }

 rabbit::Class* rabbit::Class::create(rabbit::SharedState *ss, Class *base) {
-	rabbit::Class *newclass = ETK_NEW(Class, ss, base);
+	rabbit::Class *newclass = (Class *)SQ_MALLOC(sizeof(Class));
+	new ((char*)newclass) Class(ss, base);
 	return newclass;
 }

@@ -86,7 +87,7 @@ void rabbit::Class::release() {
 	if (_hook) {
 		_hook(_typetag,0);
 	}
-	ETK_DELETE(Class, this);
+	sq_delete(this, Class);
 }

 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
@@ -23,125 +23,6 @@
 #include <rabbit/RefCounted.hpp>
 #include <rabbit/squtils.hpp>

-
-
-bool rabbit::SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size)
-{
-	if(write(up,dest,size) != size) {
-		v->raise_error("io error (write function failure)");
-		return false;
-	}
-	return true;
-}
-
-bool rabbit::SafeRead(rabbit::VirtualMachine* v,SQWRITEFUNC read,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size)
-{
-	if(size && read(up,dest,size) != size) {
-		v->raise_error("io error, read function failure, the origin stream could be corrupted/trucated");
-		return false;
-	}
-	return true;
-}
-
-bool rabbit::WriteTag(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer up,uint32_t tag)
-{
-	return SafeWrite(v,write,up,&tag,sizeof(tag));
-}
-
-bool rabbit::CheckTag(rabbit::VirtualMachine* v,SQWRITEFUNC read,rabbit::UserPointer up,uint32_t tag)
-{
-	uint32_t t;
-	_CHECK_IO(SafeRead(v,read,up,&t,sizeof(t)));
-	if(t != tag){
-		v->raise_error("invalid or corrupted closure stream");
-		return false;
-	}
-	return true;
-}
-
-bool rabbit::WriteObject(rabbit::VirtualMachine* v,rabbit::UserPointer up,SQWRITEFUNC write,rabbit::ObjectPtr &o)
-{
-	uint32_t _type = (uint32_t)o.getType();
-	_CHECK_IO(SafeWrite(v,write,up,&_type,sizeof(_type)));
-	switch(o.getType()){
-		case rabbit::OT_STRING:
-			_CHECK_IO(SafeWrite(v,write,up,&o.toString()->_len,sizeof(int64_t)));
-			_CHECK_IO(SafeWrite(v,write,up,o.getStringValue(),sq_rsl(o.toString()->_len)));
-			break;
-		case rabbit::OT_BOOL:
-		case rabbit::OT_INTEGER:
-			_CHECK_IO(SafeWrite(v,write,up,&o.toInteger(),sizeof(int64_t)));break;
-		case rabbit::OT_FLOAT:
-			_CHECK_IO(SafeWrite(v,write,up,&o.toFloat(),sizeof(float_t)));break;
-		case rabbit::OT_NULL:
-			break;
-		default:
-			v->raise_error("cannot serialize a %s",getTypeName(o));
-			return false;
-	}
-	return true;
-}
-
-bool rabbit::ReadObject(rabbit::VirtualMachine* v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &o)
-{
-	uint32_t _type;
-	_CHECK_IO(SafeRead(v,read,up,&_type,sizeof(_type)));
-	rabbit::ObjectType t = (rabbit::ObjectType)_type;
-	switch(t){
-	case rabbit::OT_STRING:{
-		int64_t len;
-		_CHECK_IO(SafeRead(v,read,up,&len,sizeof(int64_t)));
-		_CHECK_IO(SafeRead(v,read,up,_get_shared_state(v)->getScratchPad(sq_rsl(len)),sq_rsl(len)));
-		o=rabbit::String::create(_get_shared_state(v),_get_shared_state(v)->getScratchPad(-1),len);
-				   }
-		break;
-	case rabbit::OT_INTEGER:{
-		int64_t i;
-		_CHECK_IO(SafeRead(v,read,up,&i,sizeof(int64_t))); o = i; break;
-					}
-	case rabbit::OT_BOOL:{
-		int64_t i;
-		_CHECK_IO(SafeRead(v,read,up,&i,sizeof(int64_t))); o._type = rabbit::OT_BOOL; o._unVal.nInteger = i; break;
-					}
-	case rabbit::OT_FLOAT:{
-		float_t f;
-		_CHECK_IO(SafeRead(v,read,up,&f,sizeof(float_t))); o = f; break;
-				  }
-	case rabbit::OT_NULL:
-		o.Null();
-		break;
-	default:
-		v->raise_error("cannot serialize a %s",IdType2Name(t));
-		return false;
-	}
-	return true;
-}
-
-bool rabbit::Closure::save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write)
-{
-	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_HEAD));
-	_CHECK_IO(WriteTag(v,write,up,sizeof(char)));
-	_CHECK_IO(WriteTag(v,write,up,sizeof(int64_t)));
-	_CHECK_IO(WriteTag(v,write,up,sizeof(float_t)));
-	_CHECK_IO(_function->save(v,up,write));
-	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_TAIL));
-	return true;
-}
-
-bool rabbit::Closure::load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &ret)
-{
-	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_HEAD));
-	_CHECK_IO(CheckTag(v,read,up,sizeof(char)));
-	_CHECK_IO(CheckTag(v,read,up,sizeof(int64_t)));
-	_CHECK_IO(CheckTag(v,read,up,sizeof(float_t)));
-	rabbit::ObjectPtr func;
-	_CHECK_IO(rabbit::FunctionProto::load(v,up,read,func));
-	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_TAIL));
-	ret = rabbit::Closure::create(_get_shared_state(v),func.toFunctionProto(),v->_roottable.toTable()->getWeakRef(rabbit::OT_TABLE));
-	//FIXME: load an root for this closure
-	return true;
-}
-
 rabbit::Closure::~Closure() {
 	__Objrelease(_root);
 	__Objrelease(_env);
@@ -156,7 +37,8 @@ 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 = ETK_NEW(rabbit::Closure, ss, func);
+	rabbit::Closure *nc=(rabbit::Closure*)SQ_MALLOC(size);
+	new ((char*)nc) rabbit::Closure(ss,func);
 	nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1);
 	nc->_defaultparams = &nc->_outervalues[func->_noutervalues];
 	nc->_root = root;
@@ -172,7 +54,8 @@ void rabbit::Closure::release(){
 	_DESTRUCT_VECTOR(ObjectPtr,f->_noutervalues,_outervalues);
 	_DESTRUCT_VECTOR(ObjectPtr,f->_ndefaultparams,_defaultparams);
 	__Objrelease(_function);
-	ETK_FREE(Closure, this);
+	this->~Closure();
+	sq_vm_free(this,size);
 }

 void rabbit::Closure::setRoot(rabbit::WeakRef *r) {
--- a/rabbit/Closure.hpp
+++ b/rabbit/Closure.hpp
@@ -33,8 +33,6 @@ namespace rabbit {
 			Closure *clone();
 			~Closure();
 		
-			bool save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write);
-			static bool load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &ret);
 			rabbit::WeakRef *_env;
 			rabbit::WeakRef *_root;
 			rabbit::Class *_base;
@@ -42,12 +40,6 @@ namespace rabbit {
 			rabbit::ObjectPtr *_outervalues;
 			rabbit::ObjectPtr *_defaultparams;
 	};
-	bool SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size);
-	bool SafeRead(rabbit::VirtualMachine* v,SQWRITEFUNC read,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size);
-	bool WriteTag(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer up,uint32_t tag);
-	bool CheckTag(rabbit::VirtualMachine* v,SQWRITEFUNC read,rabbit::UserPointer up,uint32_t tag);
-	bool WriteObject(rabbit::VirtualMachine* v,rabbit::UserPointer up,SQWRITEFUNC write,rabbit::ObjectPtr &o);
-	bool ReadObject(rabbit::VirtualMachine* v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &o);

 }
 #define _CHECK_IO(exp)  { if(!exp)return false; }
--- a/rabbit/FuncState.cpp
+++ b/rabbit/FuncState.cpp
@@ -658,15 +658,17 @@ rabbit::FunctionProto* rabbit::FuncState::buildProto() {
 	return f;
 }

-rabbit::FuncState *rabbit::FuncState::pushChildState(rabbit::SharedState *ss) {
-	FuncState *child = ETK_NEW(rabbit::FuncState, ss, this, _errfunc, _errtarget);
+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);
 	_childstates.pushBack(child);
 	return child;
 }

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

--- a/rabbit/FunctionProto.cpp
+++ b/rabbit/FunctionProto.cpp
@@ -27,7 +27,8 @@ 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 = ETK_NEW(rabbit::FunctionProto, ss);
+	f = (rabbit::FunctionProto *)sq_vm_malloc(_FUNC_SIZE(ninstructions,nliterals,nparameters,nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams));
+	new ((char*)f) rabbit::FunctionProto(ss);
 	f->_ninstructions = ninstructions;
 	f->_literals = (rabbit::ObjectPtr*)&f->_instructions[ninstructions];
 	f->_nliterals = nliterals;
@@ -59,8 +60,9 @@ 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);
-	ETK_FREE(FunctionProto, this);
+	int64_t size = _FUNC_SIZE(_ninstructions,_nliterals,_nparameters,_nfunctions,_noutervalues,_nlineinfos,_nlocalvarinfos,_ndefaultparams);
+	this->~FunctionProto();
+	sq_vm_free(this,size);
 }

 const char* rabbit::FunctionProto::getLocal(rabbit::VirtualMachine *vm,uint64_t stackbase,uint64_t nseq,uint64_t nop)
@@ -87,23 +89,26 @@ 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;
 		}
 	}
@@ -126,151 +131,3 @@ rabbit::FunctionProto::FunctionProto(rabbit::SharedState *ss)
 rabbit::FunctionProto::~FunctionProto()
 {
 }
-
-
-
-bool rabbit::FunctionProto::save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write)
-{
-	int64_t i,nliterals = _nliterals,nparameters = _nparameters;
-	int64_t noutervalues = _noutervalues,nlocalvarinfos = _nlocalvarinfos;
-	int64_t nlineinfos=_nlineinfos,ninstructions = _ninstructions,nfunctions=_nfunctions;
-	int64_t ndefaultparams = _ndefaultparams;
-	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
-	_CHECK_IO(WriteObject(v,up,write,_sourcename));
-	_CHECK_IO(WriteObject(v,up,write,_name));
-	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
-	_CHECK_IO(SafeWrite(v,write,up,&nliterals,sizeof(nliterals)));
-	_CHECK_IO(SafeWrite(v,write,up,&nparameters,sizeof(nparameters)));
-	_CHECK_IO(SafeWrite(v,write,up,&noutervalues,sizeof(noutervalues)));
-	_CHECK_IO(SafeWrite(v,write,up,&nlocalvarinfos,sizeof(nlocalvarinfos)));
-	_CHECK_IO(SafeWrite(v,write,up,&nlineinfos,sizeof(nlineinfos)));
-	_CHECK_IO(SafeWrite(v,write,up,&ndefaultparams,sizeof(ndefaultparams)));
-	_CHECK_IO(SafeWrite(v,write,up,&ninstructions,sizeof(ninstructions)));
-	_CHECK_IO(SafeWrite(v,write,up,&nfunctions,sizeof(nfunctions)));
-	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
-	for(i=0;i<nliterals;i++){
-		_CHECK_IO(WriteObject(v,up,write,_literals[i]));
-	}
-
-	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
-	for(i=0;i<nparameters;i++){
-		_CHECK_IO(WriteObject(v,up,write,_parameters[i]));
-	}
-
-	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
-	for(i=0;i<noutervalues;i++){
-		_CHECK_IO(SafeWrite(v,write,up,&_outervalues[i]._type,sizeof(uint64_t)));
-		_CHECK_IO(WriteObject(v,up,write,_outervalues[i]._src));
-		_CHECK_IO(WriteObject(v,up,write,_outervalues[i]._name));
-	}
-
-	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
-	for(i=0;i<nlocalvarinfos;i++){
-		rabbit::LocalVarInfo &lvi=_localvarinfos[i];
-		_CHECK_IO(WriteObject(v,up,write,lvi._name));
-		_CHECK_IO(SafeWrite(v,write,up,&lvi._pos,sizeof(uint64_t)));
-		_CHECK_IO(SafeWrite(v,write,up,&lvi._start_op,sizeof(uint64_t)));
-		_CHECK_IO(SafeWrite(v,write,up,&lvi._end_op,sizeof(uint64_t)));
-	}
-
-	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
-	_CHECK_IO(SafeWrite(v,write,up,_lineinfos,sizeof(rabbit::LineInfo)*nlineinfos));
-
-	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
-	_CHECK_IO(SafeWrite(v,write,up,_defaultparams,sizeof(int64_t)*ndefaultparams));
-
-	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
-	_CHECK_IO(SafeWrite(v,write,up,_instructions,sizeof(rabbit::Instruction)*ninstructions));
-
-	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
-	for(i=0;i<nfunctions;i++){
-		_CHECK_IO(_functions[i].toFunctionProto()->save(v,up,write));
-	}
-	_CHECK_IO(SafeWrite(v,write,up,&_stacksize,sizeof(_stacksize)));
-	_CHECK_IO(SafeWrite(v,write,up,&_bgenerator,sizeof(_bgenerator)));
-	_CHECK_IO(SafeWrite(v,write,up,&_varparams,sizeof(_varparams)));
-	return true;
-}
-
-bool rabbit::FunctionProto::load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &ret)
-{
-	int64_t i, nliterals,nparameters;
-	int64_t noutervalues ,nlocalvarinfos ;
-	int64_t nlineinfos,ninstructions ,nfunctions,ndefaultparams ;
-	rabbit::ObjectPtr sourcename, name;
-	rabbit::ObjectPtr o;
-	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
-	_CHECK_IO(ReadObject(v, up, read, sourcename));
-	_CHECK_IO(ReadObject(v, up, read, name));
-
-	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
-	_CHECK_IO(SafeRead(v,read,up, &nliterals, sizeof(nliterals)));
-	_CHECK_IO(SafeRead(v,read,up, &nparameters, sizeof(nparameters)));
-	_CHECK_IO(SafeRead(v,read,up, &noutervalues, sizeof(noutervalues)));
-	_CHECK_IO(SafeRead(v,read,up, &nlocalvarinfos, sizeof(nlocalvarinfos)));
-	_CHECK_IO(SafeRead(v,read,up, &nlineinfos, sizeof(nlineinfos)));
-	_CHECK_IO(SafeRead(v,read,up, &ndefaultparams, sizeof(ndefaultparams)));
-	_CHECK_IO(SafeRead(v,read,up, &ninstructions, sizeof(ninstructions)));
-	_CHECK_IO(SafeRead(v,read,up, &nfunctions, sizeof(nfunctions)));
-
-
-	rabbit::FunctionProto *f = rabbit::FunctionProto::create(NULL,ninstructions,nliterals,nparameters,
-			nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams);
-	rabbit::ObjectPtr proto = f; //gets a ref in case of failure
-	f->_sourcename = sourcename;
-	f->_name = name;
-
-	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
-
-	for(i = 0;i < nliterals; i++){
-		_CHECK_IO(ReadObject(v, up, read, o));
-		f->_literals[i] = o;
-	}
-	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
-
-	for(i = 0; i < nparameters; i++){
-		_CHECK_IO(ReadObject(v, up, read, o));
-		f->_parameters[i] = o;
-	}
-	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
-
-	for(i = 0; i < noutervalues; i++){
-		uint64_t type;
-		rabbit::ObjectPtr name;
-		_CHECK_IO(SafeRead(v,read,up, &type, sizeof(uint64_t)));
-		_CHECK_IO(ReadObject(v, up, read, o));
-		_CHECK_IO(ReadObject(v, up, read, name));
-		f->_outervalues[i] = rabbit::OuterVar(name,o, (rabbit::OuterType)type);
-	}
-	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
-
-	for(i = 0; i < nlocalvarinfos; i++){
-		rabbit::LocalVarInfo lvi;
-		_CHECK_IO(ReadObject(v, up, read, lvi._name));
-		_CHECK_IO(SafeRead(v,read,up, &lvi._pos, sizeof(uint64_t)));
-		_CHECK_IO(SafeRead(v,read,up, &lvi._start_op, sizeof(uint64_t)));
-		_CHECK_IO(SafeRead(v,read,up, &lvi._end_op, sizeof(uint64_t)));
-		f->_localvarinfos[i] = lvi;
-	}
-	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
-	_CHECK_IO(SafeRead(v,read,up, f->_lineinfos, sizeof(rabbit::LineInfo)*nlineinfos));
-
-	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
-	_CHECK_IO(SafeRead(v,read,up, f->_defaultparams, sizeof(int64_t)*ndefaultparams));
-
-	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
-	_CHECK_IO(SafeRead(v,read,up, f->_instructions, sizeof(rabbit::Instruction)*ninstructions));
-
-	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
-	for(i = 0; i < nfunctions; i++){
-		_CHECK_IO(o.toFunctionProto()->load(v, up, read, o));
-		f->_functions[i] = o;
-	}
-	_CHECK_IO(SafeRead(v,read,up, &f->_stacksize, sizeof(f->_stacksize)));
-	_CHECK_IO(SafeRead(v,read,up, &f->_bgenerator, sizeof(f->_bgenerator)));
-	_CHECK_IO(SafeRead(v,read,up, &f->_varparams, sizeof(f->_varparams)));
-
-	ret = f;
-	return true;
-}
-
--- a/rabbit/FunctionProto.hpp
+++ b/rabbit/FunctionProto.hpp
@@ -37,8 +37,6 @@ namespace rabbit {
 		
 			const char* getLocal(rabbit::VirtualMachine *v,uint64_t stackbase,uint64_t nseq,uint64_t nop);
 			int64_t getLine(rabbit::Instruction *curr);
-			bool save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write);
-			static bool load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &ret);
 			rabbit::ObjectPtr _sourcename;
 			rabbit::ObjectPtr _name;
 			int64_t _stacksize;
--- a/rabbit/Generator.cpp
+++ b/rabbit/Generator.cpp
@@ -107,7 +107,8 @@ rabbit::Generator::Generator(rabbit::SharedState *ss,rabbit::Closure *closure) {
 }

 rabbit::Generator *rabbit::Generator::create(rabbit::SharedState *ss,rabbit::Closure *closure) {
-	rabbit::Generator *nc = ETK_NEW(rabbit::Generator, ss, closure);
+	rabbit::Generator *nc=(rabbit::Generator*)SQ_MALLOC(sizeof(rabbit::Generator));
+	new ((char*)nc) rabbit::Generator(ss,closure);
 	return nc;
 }

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

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

--- 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++) {
-		&_values[n] = ETK_NEW(rabbit::ObjectPtr, _class->_defaultvalues[n].val);
+		new ((char*)&_values[n]) 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++) {
-		&_values[n] = ETK_NEW(rabbit::ObjectPtr, i->_values[n]);
+		new ((char*)&_values[n]) rabbit::ObjectPtr(i->_values[n]);
 	}
 	init(ss);
 }
@@ -80,7 +80,8 @@ 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 = ETK_NEW(Instance, ss, theclass,size);
+	Instance *newinst = (Instance *)SQ_MALLOC(size);
+	new ((char*)newinst) Instance(ss, theclass,size);
 	if(theclass->_udsize) {
 		newinst->_userpointer = ((unsigned char *)newinst) + (size - theclass->_udsize);
 	}
@@ -89,7 +90,8 @@ 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 = ETK_NEW(Instance, ss, this, size);
+	Instance *newinst = (Instance *)SQ_MALLOC(size);
+	new ((char*)newinst) Instance(ss, this,size);
 	if(_class->_udsize) {
 		newinst->_userpointer = ((unsigned char *)newinst) + (size - _class->_udsize);
 	}
@@ -128,6 +130,7 @@ void rabbit::Instance::release() {
 		return;
 	}
 	int64_t size = _memsize;
-	ETK_FREE(Instance, this);
+	this->~Instance();
+	SQ_FREE(this, size);
 }

--- a/rabbit/NativeClosure.cpp
+++ b/rabbit/NativeClosure.cpp
@@ -17,7 +17,8 @@ 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 = ETK_NEW(rabbit::NativeClosure, ss, func);
+	rabbit::NativeClosure *nc=(rabbit::NativeClosure*)SQ_MALLOC(size);
+	new ((char*)nc) rabbit::NativeClosure(ss,func);
 	nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1);
 	nc->_noutervalues = nouters;
 	_CONSTRUCT_VECTOR(rabbit::ObjectPtr,nc->_noutervalues,nc->_outervalues);
@@ -42,5 +43,6 @@ rabbit::NativeClosure::~NativeClosure() {
 void rabbit::NativeClosure::release(){
 	int64_t size = _CALC_NATVIVECLOSURE_SIZE(_noutervalues);
 	_DESTRUCT_VECTOR(ObjectPtr,_noutervalues,_outervalues);
-	ETK_FREE(NativeClosure, this);
+	this->~NativeClosure();
+	sq_free(this,size);
 }
--- a/rabbit/NativeClosure.hpp
+++ b/rabbit/NativeClosure.hpp
@@ -28,6 +28,7 @@ namespace rabbit {
 			rabbit::NativeClosure *clone();
 			~NativeClosure();
 			void release();
+		
 			int64_t _nparamscheck;
 			etk::Vector<int64_t> _typecheck;
 			rabbit::ObjectPtr *_outervalues;
--- a/rabbit/Outer.cpp
+++ b/rabbit/Outer.cpp
@@ -16,7 +16,8 @@ rabbit::Outer::Outer(rabbit::SharedState *ss, rabbit::ObjectPtr *outer){
 }

 rabbit::Outer* rabbit::Outer::create(rabbit::SharedState *ss, rabbit::ObjectPtr *outer) {
-	rabbit::Outer *nc = ETK_NEW(rabbit::Outer, ss, outer);
+	rabbit::Outer *nc  = (rabbit::Outer*)SQ_MALLOC(sizeof(rabbit::Outer));
+	new ((char*)nc) rabbit::Outer(ss, outer);
 	return nc;
 }

@@ -25,5 +26,6 @@ rabbit::Outer::~Outer() {
 }

 void rabbit::Outer::release() {
-	ETK_FREE(rabbit::Outer, this);
+	this->~Outer();
+	sq_vm_free(this,sizeof(rabbit::Outer));
 }
--- a/rabbit/RefCounted.cpp
+++ b/rabbit/RefCounted.cpp
@@ -7,9 +7,6 @@
 */

 #include <rabbit/RefCounted.hpp>
-
-#include <etk/Allocator.hpp>
-
 #include <rabbit/WeakRef.hpp>
 #include <rabbit/rabbit.hpp>
 #include <rabbit/squtils.hpp>
@@ -17,7 +14,7 @@

 rabbit::WeakRef * rabbit::RefCounted::getWeakRef(rabbit::ObjectType type) {
 	if(!_weakref) {
-		_weakref = ETK_NEW(WeakRef);
+		sq_new(_weakref, 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;
-		&temp->obj = ETK_NEW(ObjectPtr);
+		new ((char*)&temp->obj) ObjectPtr;
 		temp->next = temp+1;
 		temp++;
 	}
 	bucks[n] = NULL;
 	temp->refs = 0;
-	&temp->obj = ETK_NEW(ObjectPtr);
+	new ((char*)&temp->obj) ObjectPtr;
 	temp->next = NULL;
 	_freelist = nodes;
 	_nodes = nodes;
--- a/rabbit/SharedState.cpp
+++ b/rabbit/SharedState.cpp
@@ -6,9 +6,6 @@
 * @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>
@@ -100,10 +97,11 @@ void rabbit::SharedState::init()
 {
 	_scratchpad=NULL;
 	_scratchpadsize=0;
-	_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>);
+	_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>);
 	_metamethodsmap = rabbit::Table::create(this,rabbit::MT_LAST-1);
 	//adding type strings to avoid memory trashing
 	//types names
@@ -187,13 +185,12 @@ rabbit::SharedState::~SharedState()
 	_instance_default_delegate.Null();
 	_weakref_default_delegate.Null();
 	_refs_table.finalize();
-	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);
-	}
+	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);
 }


--- 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,7 +46,8 @@ rabbit::String *rabbit::StringTable::add(const char *news,int64_t len)
 			return s; //found
 	}

-	rabbit::String *t = ETK_NEW(rabbit::String);
+	rabbit::String *t = (rabbit::String *)SQ_MALLOC(sq_rsl(len)+sizeof(rabbit::String));
+	new ((char*)t) rabbit::String;
 	t->_sharedstate = _sharedstate;
 	memcpy(t->_val,news,sq_rsl(len));
 	t->_val[len] = '\0';
@@ -91,7 +92,9 @@ void rabbit::StringTable::remove(rabbit::String *bs)
 			else
 				_strings[h] = s->_next;
 			_slotused--;
-			ETK_FREE(String, s);
+			int64_t slen = s->_len;
+			s->~String();
+			SQ_FREE(s,sizeof(rabbit::String) + sq_rsl(slen));
 			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() {
-	ETK_DELETE(Table, this);
+	sq_delete(this, Table);
 }
--- a/rabbit/UserData.cpp
+++ b/rabbit/UserData.cpp
@@ -17,7 +17,8 @@ rabbit::UserData::~UserData() {
 }

 rabbit::UserData* rabbit::UserData::create(rabbit::SharedState *ss, int64_t size) {
-	UserData* ud = ETK_NEW(UserData, ss);
+	UserData* ud = (UserData*)SQ_MALLOC(sq_aligning(sizeof(UserData))+size);
+	new ((char*)ud) UserData(ss);
 	ud->m_size = size;
 	ud->m_typetag = 0;
 	return ud;
@@ -27,7 +28,9 @@ void rabbit::UserData::release() {
 	if (m_hook) {
 		m_hook((rabbit::UserPointer)sq_aligning(this + 1),m_size);
 	}
-	ETK_FREE(UserData, this);
+	int64_t tsize = m_size;
+	this->~UserData();
+	SQ_FREE(this, sq_aligning(sizeof(UserData)) + tsize);
 }

 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() {
-	ETK_DELETE(VirtualMachine, this);
+	sq_delete(this,VirtualMachine);
 }

 #define _ARITH_(op,trg,o1,o2) \
@@ -141,7 +141,8 @@ bool rabbit::VirtualMachine::ARITH_OP(uint64_t op,rabbit::ObjectPtr &trg,const r

 rabbit::VirtualMachine::VirtualMachine(rabbit::SharedState *ss)
 {
-	_sharedstate=ss;
+	_stack.resize(4096);
+	_sharedstate = ss;
 	_suspended = SQFalse;
 	_suspended_target = -1;
 	_suspended_root = SQFalse;
@@ -159,6 +160,27 @@ rabbit::VirtualMachine::VirtualMachine(rabbit::SharedState *ss)
 	_releasehook = NULL;
 }

+bool rabbit::VirtualMachine::init(rabbit::VirtualMachine *friendvm) {
+	_alloccallsstacksize = 4;
+	_callstackdata.resize(_alloccallsstacksize);
+	_callsstacksize = 0;
+	_callsstack = &_callstackdata[0];
+	_stackbase = 0;
+	_top = 0;
+	if(!friendvm) {
+		_roottable = rabbit::Table::create(_get_shared_state(this), 0);
+		sq_base_register(this);
+	}
+	else {
+		_roottable = friendvm->_roottable;
+		_errorhandler = friendvm->_errorhandler;
+		_debughook = friendvm->_debughook;
+		_debughook_native = friendvm->_debughook_native;
+		_debughook_closure = friendvm->_debughook_closure;
+	}
+	return true;
+}
+
 void rabbit::VirtualMachine::finalize()
 {
 	if(_releasehook) { _releasehook(_foreignptr,0); _releasehook = NULL; }
@@ -185,12 +207,25 @@ bool rabbit::VirtualMachine::arithMetaMethod(int64_t op,const rabbit::ObjectPtr
 {
 	rabbit::MetaMethod mm;
 	switch(op){
-		case '+': mm=MT_ADD; break;
-		case '-': mm=MT_SUB; break;
-		case '/': mm=MT_DIV; break;
-		case '*': mm=MT_MUL; break;
-		case '%': mm=MT_MODULO; break;
-		default: mm = MT_ADD; assert(0); break; //shutup compiler
+		case '+':
+			mm=MT_ADD;
+			break;
+		case '-':
+			mm=MT_SUB;
+			break;
+		case '/':
+			mm=MT_DIV;
+			break;
+		case '*':
+			mm=MT_MUL;
+			break;
+		case '%':
+			mm=MT_MODULO;
+			break;
+		default:
+			mm = MT_ADD;
+			assert(0);
+			break; //shutup compiler
 	}
 	if(    o1.isDelegable() == true
 	    && o1.toDelegable()->_delegate) {
@@ -382,31 +417,6 @@ bool rabbit::VirtualMachine::typeOf(const rabbit::ObjectPtr &obj1,rabbit::Object
 	return true;
 }

-bool rabbit::VirtualMachine::init(rabbit::VirtualMachine *friendvm, int64_t stacksize)
-{
-	_stack.resize(stacksize);
-	_alloccallsstacksize = 4;
-	_callstackdata.resize(_alloccallsstacksize);
-	_callsstacksize = 0;
-	_callsstack = &_callstackdata[0];
-	_stackbase = 0;
-	_top = 0;
-	if(!friendvm) {
-		_roottable = rabbit::Table::create(_get_shared_state(this), 0);
-		sq_base_register(this);
-	}
-	else {
-		_roottable = friendvm->_roottable;
-		_errorhandler = friendvm->_errorhandler;
-		_debughook = friendvm->_debughook;
-		_debughook_native = friendvm->_debughook_native;
-		_debughook_closure = friendvm->_debughook_closure;
-	}
-
-
-	return true;
-}
-

 bool rabbit::VirtualMachine::startcall(rabbit::Closure *closure,int64_t target,int64_t args,int64_t stackbase,bool tailcall)
 {
--- a/rabbit/VirtualMachine.hpp
+++ b/rabbit/VirtualMachine.hpp
@@ -61,7 +61,7 @@ namespace rabbit {
 			};
 			VirtualMachine(rabbit::SharedState *ss);
 			~VirtualMachine();
-			bool init(VirtualMachine *friendvm, int64_t stacksize);
+			bool init(VirtualMachine *friendvm);
 			bool execute(rabbit::ObjectPtr &func, int64_t nargs, int64_t stackbase, rabbit::ObjectPtr &outres, rabbit::Bool raiseerror, ExecutionType et = ET_CALL);
 			//starts a native call return when the NATIVE closure returns
 			bool callNative(rabbit::NativeClosure *nclosure, int64_t nargs, int64_t newbase, rabbit::ObjectPtr &retval, int32_t target, bool &suspend,bool &tailcall);
--- 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;
 	}
-	ETK_DELETE(WeakRef, this);
+	sq_delete(this, WeakRef);
 }
--- a/rabbit/rabbit.hpp
+++ b/rabbit/rabbit.hpp
@@ -43,8 +43,8 @@ typedef int64_t (*SQLEXREADFUNC)(rabbit::UserPointer);

 namespace rabbit {
 /*vm*/
-rabbit::VirtualMachine* sq_open(int64_t initialstacksize);
-rabbit::VirtualMachine* sq_newthread(rabbit::VirtualMachine* friendvm, int64_t initialstacksize);
+rabbit::VirtualMachine* sq_open();
+rabbit::VirtualMachine* sq_newthread(rabbit::VirtualMachine* friendvm);
 void sq_seterrorhandler(rabbit::VirtualMachine* v);
 void sq_close(rabbit::VirtualMachine* v);
 void sq_setforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p);
@@ -198,10 +198,6 @@ uint64_t sq_getvmrefcount(rabbit::VirtualMachine* v, const rabbit::Object *po);
 int64_t sq_collectgarbage(rabbit::VirtualMachine* v);
 rabbit::Result sq_resurrectunreachable(rabbit::VirtualMachine* v);

-/*serialization*/
-rabbit::Result sq_writeclosure(rabbit::VirtualMachine* vm,SQWRITEFUNC writef,rabbit::UserPointer up);
-rabbit::Result sq_readclosure(rabbit::VirtualMachine* vm,SQREADFUNC readf,rabbit::UserPointer up);
-
 /*mem allocation*/
 void *sq_malloc(uint64_t size);
 void *sq_realloc(void* p,uint64_t oldsize,uint64_t newsize);
--- a/rabbit/sqapi.cpp
+++ b/rabbit/sqapi.cpp
@@ -9,7 +9,6 @@
 #include <rabbit/VirtualMachine.hpp>


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


@@ -57,34 +56,41 @@ namespace rabbit {
 		return sq_throwerror(v, _get_shared_state(v)->getScratchPad(-1));
 	}
 }
-rabbit::VirtualMachine* rabbit::sq_open(int64_t initialstacksize)
+rabbit::VirtualMachine* rabbit::sq_open()
 {
-	rabbit::SharedState *ss = ETK_NEW(rabbit::SharedState);
+	rabbit::SharedState *ss;
+	sq_new(ss, rabbit::SharedState);
 	ss->init();
-	rabbit::VirtualMachine *v = ETK_NEW(rabbit::VirtualMachine, ss);
+	
+	char* allocatedData = (char*)SQ_MALLOC(sizeof(rabbit::VirtualMachine));
+	rabbit::VirtualMachine *v = new (allocatedData) rabbit::VirtualMachine(ss);
 	ss->_root_vm = v;
 	
-	if(v->init(NULL, initialstacksize)) {
+	if(v->init(NULL)) {
 		return v;
 	} else {
-		ETK_FREE(rabbit::VirtualMachine, v);
+		v->~VirtualMachine();
+		SQ_FREE(allocatedData,sizeof(rabbit::VirtualMachine));
 		return NULL;
 	}
 	return v;
 }

-rabbit::VirtualMachine* rabbit::sq_newthread(rabbit::VirtualMachine* friendvm, int64_t initialstacksize)
+rabbit::VirtualMachine* rabbit::sq_newthread(rabbit::VirtualMachine* friendvm)
 {
 	rabbit::SharedState *ss;
 	ss=_get_shared_state(friendvm);
-	rabbit::VirtualMachine *v = ETK_NEW(rabbit::VirtualMachine, ss);
+	
+	char* allocatedData = (char*)SQ_MALLOC(sizeof(rabbit::VirtualMachine));
+	rabbit::VirtualMachine *v = new (allocatedData) rabbit::VirtualMachine(ss);
 	ss->_root_vm = v;
 	
-	if(v->init(friendvm, initialstacksize)) {
+	if(v->init(friendvm)) {
 		friendvm->push(v);
 		return v;
 	} else {
-		ETK_FREE(rabbit::VirtualMachine, v);
+		v->~VirtualMachine();
+		SQ_FREE(allocatedData,sizeof(rabbit::VirtualMachine));
 		return NULL;
 	}
 }
@@ -134,7 +140,7 @@ void rabbit::sq_close(rabbit::VirtualMachine* v)
 {
 	rabbit::SharedState *ss = _get_shared_state(v);
 	ss->_root_vm.toVirtualMachine()->finalize();
-	ETK_DELETE(SharedState, ss);
+	sq_delete(ss, SharedState);
 }

 int64_t rabbit::sq_getversion()
@@ -145,15 +151,11 @@ int64_t rabbit::sq_getversion()
 rabbit::Result rabbit::sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::UserPointer p,const char *sourcename,rabbit::Bool raiseerror)
 {
 	rabbit::ObjectPtr o;
-#ifndef NO_COMPILER
 	if(compile(v, read, p, sourcename, o, raiseerror?true:false, _get_shared_state(v)->_debuginfo)) {
 		v->push(rabbit::Closure::create(_get_shared_state(v), o.toFunctionProto(), v->_roottable.toTable()->getWeakRef(rabbit::OT_TABLE)));
 		return SQ_OK;
 	}
 	return SQ_ERROR;
-#else
-	return sq_throwerror(v,"this is a no compiler build");
-#endif
 }

 void rabbit::sq_enabledebuginfo(rabbit::VirtualMachine* v, rabbit::Bool enable)
@@ -252,17 +254,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);
 }
@@ -1344,35 +1346,6 @@ void rabbit::sq_setcompilererrorhandler(rabbit::VirtualMachine* v,SQCOMPILERERRO
 	_get_shared_state(v)->_compilererrorhandler = f;
 }

-rabbit::Result rabbit::sq_writeclosure(rabbit::VirtualMachine* v,SQWRITEFUNC w,rabbit::UserPointer up)
-{
-	rabbit::ObjectPtr *o = NULL;
-	_GETSAFE_OBJ(v, -1, rabbit::OT_CLOSURE,o);
-	unsigned short tag = SQ_BYTECODE_STREAM_TAG;
-	if(o->toClosure()->_function->_noutervalues)
-		return sq_throwerror(v,"a closure with free variables bound cannot be serialized");
-	if(w(up,&tag,2) != 2)
-		return sq_throwerror(v,"io error");
-	if(!o->toClosure()->save(v,up,w))
-		return SQ_ERROR;
-	return SQ_OK;
-}
-
-rabbit::Result rabbit::sq_readclosure(rabbit::VirtualMachine* v,SQREADFUNC r,rabbit::UserPointer up)
-{
-	rabbit::ObjectPtr closure;
-
-	unsigned short tag;
-	if(r(up,&tag,2) != 2)
-		return sq_throwerror(v,"io error");
-	if(tag != SQ_BYTECODE_STREAM_TAG)
-		return sq_throwerror(v,"invalid stream");
-	if(!rabbit::Closure::load(v,up,r,closure))
-		return SQ_ERROR;
-	v->push(closure);
-	return SQ_OK;
-}
-
 char * rabbit::sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize)
 {
 	return _get_shared_state(v)->getScratchPad(minsize);
--- a/rabbit/sqbaselib.cpp
+++ b/rabbit/sqbaselib.cpp
@@ -238,9 +238,8 @@ static int64_t base_compilestring(rabbit::VirtualMachine* v)
 static int64_t base_newthread(rabbit::VirtualMachine* v)
 {
 	rabbit::ObjectPtr &func = stack_get(v,2);
-	int64_t stksize = (func.toClosure()->_function->_stacksize << 1) +2;
-	rabbit::VirtualMachine* newv = sq_newthread(v, (stksize < MIN_STACK_OVERHEAD + 2)? MIN_STACK_OVERHEAD + 2 : stksize);
-	sq_move(newv,v,-2);
+	rabbit::VirtualMachine* newv = sq_newthread(v);
+	sq_move(newv, v, -2);
 	return 1;
 }

--- a/rabbit/sqconfig.hpp
+++ b/rabbit/sqconfig.hpp
@@ -8,7 +8,6 @@
 #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,6 +12,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 ((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	685dd2bca8	[DEV] some patch	2018-07-06 23:20:24 +02:00
Edouard DUPIN	0b9cd5c735	[DEV] remove store compiled file	2018-07-06 21:09:45 +02:00
Edouard DUPIN	6ec3f05c5d	[DEV] remove __Swap()	2018-07-06 00:12:59 +02:00