[DEV] continue rework: buid and work again

cmdLine/rabbit.cpp

@@ -163,7 +163,7 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
 			//sq_createslot(v,-3);
 			//sq_pop(v,1);
 			if(compiles_only) {
-				if(SQ_SUCCEEDED(sqstd_loadfile(v,filename,SQTrue))){
+				if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,SQTrue))){
 					const rabbit::Char *outfile = _SC("out.karrot");
 					if(output) {
 #ifdef SQUNICODE
@@ -174,15 +174,15 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
 						outfile = output;
 #endif
 					}
-					if(SQ_SUCCEEDED(sqstd_writeclosuretofile(v,outfile)))
+					if(SQ_SUCCEEDED(rabbit::std::writeclosuretofile(v,outfile)))
 						return _DONE;
 				}
 			}
 			else {
-				//if(SQ_SUCCEEDED(sqstd_dofile(v,filename,SQFalse,SQTrue))) {
+				//if(SQ_SUCCEEDED(rabbit::std::dofile(v,filename,SQFalse,SQTrue))) {
 					//return _DONE;
 				//}
-				if(SQ_SUCCEEDED(sqstd_loadfile(v,filename,SQTrue))) {
+				if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,SQTrue))) {
 					int callargs = 1;
 					sq_pushroottable(v);
 					for(i=arg;i<argc;i++)
@@ -321,20 +321,20 @@ int main(int argc, char* argv[])
 	_CrtsetAllocHook(MemAllocHook);
 #endif
 
-	v=sq_open(1024);
+	v=rabbit::sq_open(1024);
 	sq_setprintfunc(v,printfunc,errorfunc);
 
 	sq_pushroottable(v);
 
-	sqstd_register_bloblib(v);
+	rabbit::std::register_bloblib(v);
-	sqstd_register_iolib(v);
+	rabbit::std::register_iolib(v);
-	sqstd_register_systemlib(v);
+	rabbit::std::register_systemlib(v);
-	sqstd_register_mathlib(v);
+	rabbit::std::register_mathlib(v);
-	sqstd_register_stringlib(v);
+	rabbit::std::register_stringlib(v);
 
 	//aux library
 	//sets error handlers
-	sqstd_seterrorhandlers(v);
+	rabbit::std::seterrorhandlers(v);
 
 	//gets arguments
 	switch(getargs(v,argc,argv,&retval))

etc/minimal.cpp

@@ -56,17 +56,17 @@ int main(int argc, char* argv[])
 
 	//REGISTRATION OF STDLIB
 	//sq_pushroottable(v); //push the root table where the std function will be registered
-	//sqstd_register_iolib(v);  //registers a library
+	//rabbit::std::register_iolib(v);  //registers a library
 	// ... call here other stdlibs string,math etc...
 	//sq_pop(v,1); //pops the root table
 	//END REGISTRATION OF STDLIB
 
-	sqstd_seterrorhandlers(v); //registers the default error handlers
+	rabbit::std::seterrorhandlers(v); //registers the default error handlers
 
 	sq_setprintfunc(v, printfunc,errorfunc); //sets the print function
 
 	sq_pushroottable(v); //push the root table(were the globals of the script will be stored)
-	if(SQ_SUCCEEDED(sqstd_dofile(v, _SC("test.nut"), SQFalse, SQTrue))) // also prints syntax errors if any
+	if(SQ_SUCCEEDED(rabbit::std::dofile(v, _SC("test.nut"), SQFalse, SQTrue))) // also prints syntax errors if any
 	{
 		call_foo(v,1,2.5,_SC("teststring"));
 	}

lutin_rabbit-core.py

@@ -62,6 +62,7 @@ def configure(target, my_module):
 	    'rabbit/String.cpp',
 	    'rabbit/StringTable.cpp',
 	    'rabbit/Table.cpp',
+	    'rabbit/UserData.cpp',
 	    'rabbit/VirtualMachine.cpp',
 	    'rabbit/WeakRef.cpp',
 	    'rabbit/sqapi.cpp',

rabbit-std/sqstdaux.cpp

@@ -11,7 +11,7 @@
 #include <assert.h>
 #include <rabbit/StackInfos.hpp>
 
-void sqstd_printcallstack(rabbit::VirtualMachine* v)
+void rabbit::std::printcallstack(rabbit::VirtualMachine* v)
 {
 	SQPRINTFUNCTION pf = sq_geterrorfunc(v);
 	if(pf) {
@@ -90,11 +90,12 @@ void sqstd_printcallstack(rabbit::VirtualMachine* v)
 				case rabbit::OT_WEAKREF:
 					pf(v,_SC("[%s] WEAKREF\n"),name);
 					break;
-				case rabbit::OT_BOOL:{
+				case rabbit::OT_BOOL:
-					rabbit::Bool bval;
+					{
-					sq_getbool(v,-1,&bval);
+						rabbit::Bool bval;
-					pf(v,_SC("[%s] %s\n"),name,bval == SQTrue ? _SC("true"):_SC("false"));
+						sq_getbool(v,-1,&bval);
-							 }
+						pf(v,_SC("[%s] %s\n"),name,bval == SQTrue ? _SC("true"):_SC("false"));
+					}
 					break;
 				default: assert(0); break;
 				}
@@ -104,35 +105,38 @@ void sqstd_printcallstack(rabbit::VirtualMachine* v)
 	}
 }
 
-static int64_t _sqstd_aux_printerror(rabbit::VirtualMachine* v)
+namespace rabbit {
-{
+	namespace std {
-	SQPRINTFUNCTION pf = sq_geterrorfunc(v);
+		static int64_t aux_printerror(rabbit::VirtualMachine* v) {
-	if(pf) {
+			SQPRINTFUNCTION pf = sq_geterrorfunc(v);
-		const rabbit::Char *sErr = 0;
+			if(pf) {
-		if(sq_gettop(v)>=1) {
+				const rabbit::Char *sErr = 0;
-			if(SQ_SUCCEEDED(sq_getstring(v,2,&sErr)))   {
+				if(sq_gettop(v)>=1) {
-				pf(v,_SC("\nAN ERROR HAS OCCURRED [%s]\n"),sErr);
+					if(SQ_SUCCEEDED(sq_getstring(v,2,&sErr)))   {
+						pf(v,_SC("\nAN ERROR HAS OCCURRED [%s]\n"),sErr);
+					}
+					else{
+						pf(v,_SC("\nAN ERROR HAS OCCURRED [unknown]\n"));
+					}
+					rabbit::std::printcallstack(v);
+				}
 			}
-			else{
+			return 0;
-				pf(v,_SC("\nAN ERROR HAS OCCURRED [unknown]\n"));
+		}
+		
+		void compiler_error(rabbit::VirtualMachine* v,const rabbit::Char *sErr,const rabbit::Char *sSource,int64_t line,int64_t column) {
+			SQPRINTFUNCTION pf = sq_geterrorfunc(v);
+			if(pf) {
+				pf(v,_SC("%s line = (%d) column = (%d) : error %s\n"),sSource,line,column,sErr);
 			}
-			sqstd_printcallstack(v);
 		}
 	}
-	return 0;
 }
 
-void _sqstd_compiler_error(rabbit::VirtualMachine* v,const rabbit::Char *sErr,const rabbit::Char *sSource,int64_t line,int64_t column)
-{
-	SQPRINTFUNCTION pf = sq_geterrorfunc(v);
-	if(pf) {
-		pf(v,_SC("%s line = (%d) column = (%d) : error %s\n"),sSource,line,column,sErr);
-	}
-}
 
-void sqstd_seterrorhandlers(rabbit::VirtualMachine* v)
+void rabbit::std::seterrorhandlers(rabbit::VirtualMachine* v)
 {
-	sq_setcompilererrorhandler(v,_sqstd_compiler_error);
+	sq_setcompilererrorhandler(v,rabbit::std::compiler_error);
-	sq_newclosure(v,_sqstd_aux_printerror,0);
+	sq_newclosure(v,rabbit::std::aux_printerror,0);
 	sq_seterrorhandler(v);
 }

rabbit-std/sqstdaux.hpp

@@ -7,5 +7,10 @@
  */
 #pragma once
 
-RABBIT_API void sqstd_seterrorhandlers(rabbit::VirtualMachine* v);
+namespace rabbit {
-RABBIT_API void sqstd_printcallstack(rabbit::VirtualMachine* v);
+	namespace std {
+		void seterrorhandlers(rabbit::VirtualMachine* v);
+		void printcallstack(rabbit::VirtualMachine* v);
+	}
+}
+

rabbit-std/sqstdblob.cpp

@@ -13,20 +13,20 @@
 
 
 #define SETUP_BLOB(v) \
-	SQBlob *self = NULL; \
+	rabbit::std::Blob *self = NULL; \
-	{ if(SQ_FAILED(sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) \
+	{ if(SQ_FAILED(rabbit::sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) \
-		return sq_throwerror(v,_SC("invalid type tag"));  } \
+		return rabbit::sq_throwerror(v,_SC("invalid type tag"));  } \
 	if(!self || !self->IsValid())  \
-		return sq_throwerror(v,_SC("the blob is invalid"));
+		return rabbit::sq_throwerror(v,_SC("the blob is invalid"));
 
 
 static int64_t _blob_resize(rabbit::VirtualMachine* v)
 {
 	SETUP_BLOB(v);
 	int64_t size;
-	sq_getinteger(v,2,&size);
+	rabbit::sq_getinteger(v,2,&size);
 	if(!self->resize(size))
-		return sq_throwerror(v,_SC("resize failed"));
+		return rabbit::sq_throwerror(v,_SC("resize failed"));
 	return 0;
 }
 
@@ -69,12 +69,12 @@ static int64_t _blob__set(rabbit::VirtualMachine* v)
 {
 	SETUP_BLOB(v);
 	int64_t idx,val;
-	sq_getinteger(v,2,&idx);
+	rabbit::sq_getinteger(v,2,&idx);
-	sq_getinteger(v,3,&val);
+	rabbit::sq_getinteger(v,3,&val);
 	if(idx < 0 || idx >= self->Len())
-		return sq_throwerror(v,_SC("index out of range"));
+		return rabbit::sq_throwerror(v,_SC("index out of range"));
 	((unsigned char *)self->getBuf())[idx] = (unsigned char) val;
-	sq_push(v,3);
+	rabbit::sq_push(v,3);
 	return 1;
 }
 
@@ -83,87 +83,87 @@ static int64_t _blob__get(rabbit::VirtualMachine* v)
 	SETUP_BLOB(v);
 	int64_t idx;
 	
-	if ((sq_gettype(v, 2) & SQOBJECT_NUMERIC) == 0)
+	if ((rabbit::sq_gettype(v, 2) & SQOBJECT_NUMERIC) == 0)
 	{
-		sq_pushnull(v);
+		rabbit::sq_pushnull(v);
-		return sq_throwobject(v);
+		return rabbit::sq_throwobject(v);
 	}
-	sq_getinteger(v,2,&idx);
+	rabbit::sq_getinteger(v,2,&idx);
 	if(idx < 0 || idx >= self->Len())
-		return sq_throwerror(v,_SC("index out of range"));
+		return rabbit::sq_throwerror(v,_SC("index out of range"));
-	sq_pushinteger(v,((unsigned char *)self->getBuf())[idx]);
+	rabbit::sq_pushinteger(v,((unsigned char *)self->getBuf())[idx]);
 	return 1;
 }
 
 static int64_t _blob__nexti(rabbit::VirtualMachine* v)
 {
 	SETUP_BLOB(v);
-	if(sq_gettype(v,2) == rabbit::OT_NULL) {
+	if(rabbit::sq_gettype(v,2) == rabbit::OT_NULL) {
-		sq_pushinteger(v, 0);
+		rabbit::sq_pushinteger(v, 0);
 		return 1;
 	}
 	int64_t idx;
-	if(SQ_SUCCEEDED(sq_getinteger(v, 2, &idx))) {
+	if(SQ_SUCCEEDED(rabbit::sq_getinteger(v, 2, &idx))) {
 		if(idx+1 < self->Len()) {
-			sq_pushinteger(v, idx+1);
+			rabbit::sq_pushinteger(v, idx+1);
 			return 1;
 		}
-		sq_pushnull(v);
+		rabbit::sq_pushnull(v);
 		return 1;
 	}
-	return sq_throwerror(v,_SC("internal error (_nexti) wrong argument type"));
+	return rabbit::sq_throwerror(v,_SC("internal error (_nexti) wrong argument type"));
 }
 
 static int64_t _blob__typeof(rabbit::VirtualMachine* v)
 {
-	sq_pushstring(v,_SC("blob"),-1);
+	rabbit::sq_pushstring(v,_SC("blob"),-1);
 	return 1;
 }
 
 static int64_t _blob_releasehook(rabbit::UserPointer p, int64_t SQ_UNUSED_ARG(size))
 {
-	SQBlob *self = (SQBlob*)p;
+	rabbit::std::Blob *self = (rabbit::std::Blob*)p;
-	self->~SQBlob();
+	self->~Blob();
-	sq_free(self,sizeof(SQBlob));
+	rabbit::sq_free(self,sizeof(rabbit::std::Blob));
 	return 1;
 }
 
 static int64_t _blob_constructor(rabbit::VirtualMachine* v)
 {
-	int64_t nparam = sq_gettop(v);
+	int64_t nparam = rabbit::sq_gettop(v);
 	int64_t size = 0;
 	if(nparam == 2) {
-		sq_getinteger(v, 2, &size);
+		rabbit::sq_getinteger(v, 2, &size);
 	}
-	if(size < 0) return sq_throwerror(v, _SC("cannot create blob with negative size"));
+	if(size < 0) return rabbit::sq_throwerror(v, _SC("cannot create blob with negative size"));
-	//SQBlob *b = new SQBlob(size);
+	//rabbit::std::Blob *b = new rabbit::std::Blob(size);
 
-	SQBlob *b = new (sq_malloc(sizeof(SQBlob)))SQBlob(size);
+	rabbit::std::Blob *b = new (rabbit::sq_malloc(sizeof(rabbit::std::Blob)))rabbit::std::Blob(size);
-	if(SQ_FAILED(sq_setinstanceup(v,1,b))) {
+	if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,b))) {
-		b->~SQBlob();
+		b->~Blob();
-		sq_free(b,sizeof(SQBlob));
+		rabbit::sq_free(b,sizeof(rabbit::std::Blob));
-		return sq_throwerror(v, _SC("cannot create blob"));
+		return rabbit::sq_throwerror(v, _SC("cannot create blob"));
 	}
-	sq_setreleasehook(v,1,_blob_releasehook);
+	rabbit::sq_setreleasehook(v,1,_blob_releasehook);
 	return 0;
 }
 
 static int64_t _blob__cloned(rabbit::VirtualMachine* v)
 {
-	SQBlob *other = NULL;
+	rabbit::std::Blob *other = NULL;
 	{
-		if(SQ_FAILED(sq_getinstanceup(v,2,(rabbit::UserPointer*)&other,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG)))
+		if(SQ_FAILED(rabbit::sq_getinstanceup(v,2,(rabbit::UserPointer*)&other,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG)))
 			return SQ_ERROR;
 	}
-	//SQBlob *thisone = new SQBlob(other->Len());
+	//rabbit::std::Blob *thisone = new rabbit::std::Blob(other->Len());
-	SQBlob *thisone = new (sq_malloc(sizeof(SQBlob)))SQBlob(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(sq_setinstanceup(v,1,thisone))) {
+	if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,thisone))) {
-		thisone->~SQBlob();
+		thisone->~Blob();
-		sq_free(thisone,sizeof(SQBlob));
+		rabbit::sq_free(thisone,sizeof(rabbit::std::Blob));
-		return sq_throwerror(v, _SC("cannot clone blob"));
+		return rabbit::sq_throwerror(v, _SC("cannot clone blob"));
 	}
-	sq_setreleasehook(v,1,_blob_releasehook);
+	rabbit::sq_setreleasehook(v,1,_blob_releasehook);
 	return 0;
 }
 
@@ -188,44 +188,44 @@ static const rabbit::RegFunction _blob_methods[] = {
 static int64_t _g_blob_casti2f(rabbit::VirtualMachine* v)
 {
 	int64_t i;
-	sq_getinteger(v,2,&i);
+	rabbit::sq_getinteger(v,2,&i);
-	sq_pushfloat(v,*((const float_t *)&i));
+	rabbit::sq_pushfloat(v,*((const float_t *)&i));
 	return 1;
 }
 
 static int64_t _g_blob_castf2i(rabbit::VirtualMachine* v)
 {
 	float_t f;
-	sq_getfloat(v,2,&f);
+	rabbit::sq_getfloat(v,2,&f);
-	sq_pushinteger(v,*((const int64_t *)&f));
+	rabbit::sq_pushinteger(v,*((const int64_t *)&f));
 	return 1;
 }
 
 static int64_t _g_blob_swap2(rabbit::VirtualMachine* v)
 {
 	int64_t i;
-	sq_getinteger(v,2,&i);
+	rabbit::sq_getinteger(v,2,&i);
 	short s=(short)i;
-	sq_pushinteger(v,(s<<8)|((s>>8)&0x00FF));
+	rabbit::sq_pushinteger(v,(s<<8)|((s>>8)&0x00FF));
 	return 1;
 }
 
 static int64_t _g_blob_swap4(rabbit::VirtualMachine* v)
 {
 	int64_t i;
-	sq_getinteger(v,2,&i);
+	rabbit::sq_getinteger(v,2,&i);
 	unsigned int t4 = (unsigned int)i;
 	__swap_dword(&t4);
-	sq_pushinteger(v,(int64_t)t4);
+	rabbit::sq_pushinteger(v,(int64_t)t4);
 	return 1;
 }
 
 static int64_t _g_blob_swapfloat(rabbit::VirtualMachine* v)
 {
 	float_t f;
-	sq_getfloat(v,2,&f);
+	rabbit::sq_getfloat(v,2,&f);
 	__swap_dword((unsigned int *)&f);
-	sq_pushfloat(v,f);
+	rabbit::sq_pushfloat(v,f);
 	return 1;
 }
 
@@ -239,44 +239,44 @@ static const rabbit::RegFunction bloblib_funcs[]={
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
-rabbit::Result sqstd_getblob(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *ptr)
+rabbit::Result rabbit::std::getblob(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *ptr)
 {
-	SQBlob *blob;
+	rabbit::std::Blob *blob;
-	if(SQ_FAILED(sq_getinstanceup(v,idx,(rabbit::UserPointer *)&blob,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG)))
+	if(SQ_FAILED(rabbit::sq_getinstanceup(v,idx,(rabbit::UserPointer *)&blob,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG)))
 		return -1;
 	*ptr = blob->getBuf();
 	return SQ_OK;
 }
 
-int64_t sqstd_getblobsize(rabbit::VirtualMachine* v,int64_t idx)
+int64_t rabbit::std::getblobsize(rabbit::VirtualMachine* v,int64_t idx)
 {
-	SQBlob *blob;
+	rabbit::std::Blob *blob;
-	if(SQ_FAILED(sq_getinstanceup(v,idx,(rabbit::UserPointer *)&blob,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG)))
+	if(SQ_FAILED(rabbit::sq_getinstanceup(v,idx,(rabbit::UserPointer *)&blob,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG)))
 		return -1;
 	return blob->Len();
 }
 
-rabbit::UserPointer sqstd_createblob(rabbit::VirtualMachine* v, int64_t size)
+rabbit::UserPointer rabbit::std::createblob(rabbit::VirtualMachine* v, int64_t size)
 {
-	int64_t top = sq_gettop(v);
+	int64_t top = rabbit::sq_gettop(v);
-	sq_pushregistrytable(v);
+	rabbit::sq_pushregistrytable(v);
-	sq_pushstring(v,_SC("std_blob"),-1);
+	rabbit::sq_pushstring(v,_SC("std_blob"),-1);
-	if(SQ_SUCCEEDED(sq_get(v,-2))) {
+	if(SQ_SUCCEEDED(rabbit::sq_get(v,-2))) {
-		sq_remove(v,-2); //removes the registry
+		rabbit::sq_remove(v,-2); //removes the registry
-		sq_push(v,1); // push the this
+		rabbit::sq_push(v,1); // push the this
-		sq_pushinteger(v,size); //size
+		rabbit::sq_pushinteger(v,size); //size
-		SQBlob *blob = NULL;
+		rabbit::std::Blob *blob = NULL;
-		if(SQ_SUCCEEDED(sq_call(v,2,SQTrue,SQFalse))
+		if(SQ_SUCCEEDED(rabbit::sq_call(v,2,SQTrue,SQFalse))
-			&& SQ_SUCCEEDED(sq_getinstanceup(v,-1,(rabbit::UserPointer *)&blob,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) {
+			&& SQ_SUCCEEDED(rabbit::sq_getinstanceup(v,-1,(rabbit::UserPointer *)&blob,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) {
-			sq_remove(v,-2);
+			rabbit::sq_remove(v,-2);
 			return blob->getBuf();
 		}
 	}
-	sq_settop(v,top);
+	rabbit::sq_settop(v,top);
 	return NULL;
 }
 
-rabbit::Result sqstd_register_bloblib(rabbit::VirtualMachine* v)
+rabbit::Result rabbit::std::register_bloblib(rabbit::VirtualMachine* v)
 {
 	return declare_stream(v,_SC("blob"),(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG,_SC("std_blob"),_blob_methods,bloblib_funcs);
 }

rabbit-std/sqstdblob.hpp

@@ -7,9 +7,13 @@
  */
 #pragma once
 
-RABBIT_API rabbit::UserPointer sqstd_createblob(rabbit::VirtualMachine* v, int64_t size);
+namespace rabbit {
-RABBIT_API rabbit::Result sqstd_getblob(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *ptr);
+	namespace std {
-RABBIT_API int64_t sqstd_getblobsize(rabbit::VirtualMachine* v,int64_t idx);
+		rabbit::UserPointer createblob(rabbit::VirtualMachine* v, int64_t size);
+		rabbit::Result getblob(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *ptr);
+		int64_t getblobsize(rabbit::VirtualMachine* v,int64_t idx);
 		
-RABBIT_API rabbit::Result sqstd_register_bloblib(rabbit::VirtualMachine* v);
+		rabbit::Result register_bloblib(rabbit::VirtualMachine* v);
 
+	}
+}

rabbit-std/sqstdblobimpl.hpp

@@ -7,9 +7,11 @@
  */
 #pragma once
 
-struct SQBlob : public SQStream
+namespace rabbit {
+	namespace std {
+struct Blob : public SQStream
 {
-	SQBlob(int64_t size) {
+	Blob(int64_t size) {
 		_size = size;
 		_allocated = size;
 		_buf = (unsigned char *)sq_malloc(size);
@@ -17,7 +19,7 @@ struct SQBlob : public SQStream
 		_ptr = 0;
 		_owns = true;
 	}
-	virtual ~SQBlob() {
+	virtual ~Blob() {
 		sq_free(_buf, _allocated);
 	}
 	int64_t Write(void *buffer, int64_t size) {
@@ -110,3 +112,5 @@ private:
 	bool _owns;
 };
 
+	}
+}

rabbit-std/sqstdio.cpp

@@ -14,27 +14,27 @@
 
 #define SQSTD_FILE_TYPE_TAG ((uint64_t)(SQSTD_STREAM_TYPE_TAG | 0x00000001))
 //basic API
-SQFILE sqstd_fopen(const rabbit::Char *filename ,const rabbit::Char *mode)
+rabbit::std::SQFILE rabbit::std::fopen(const rabbit::Char *filename ,const rabbit::Char *mode)
 {
 #ifndef SQUNICODE
-	return (SQFILE)fopen(filename,mode);
+	return (SQFILE)::fopen(filename,mode);
 #else
-	return (SQFILE)_wfopen(filename,mode);
+	return (SQFILE)::_wfopen(filename,mode);
 #endif
 }
 
-int64_t sqstd_fread(void* buffer, int64_t size, int64_t count, SQFILE file)
+int64_t rabbit::std::fread(void* buffer, int64_t size, int64_t count, SQFILE file)
 {
-	int64_t ret = (int64_t)fread(buffer,size,count,(FILE *)file);
+	int64_t ret = (int64_t)::fread(buffer,size,count,(FILE *)file);
 	return ret;
 }
 
-int64_t sqstd_fwrite(const rabbit::UserPointer buffer, int64_t size, int64_t count, SQFILE file)
+int64_t rabbit::std::fwrite(const rabbit::UserPointer buffer, int64_t size, int64_t count, SQFILE file)
 {
-	return (int64_t)fwrite(buffer,size,count,(FILE *)file);
+	return (int64_t)::fwrite(buffer,size,count,(FILE *)file);
 }
 
-int64_t sqstd_fseek(SQFILE file, int64_t offset, int64_t origin)
+int64_t rabbit::std::fseek(SQFILE file, int64_t offset, int64_t origin)
 {
 	int64_t realorigin;
 	switch(origin) {
@@ -43,79 +43,82 @@ int64_t sqstd_fseek(SQFILE file, int64_t offset, int64_t origin)
 		case SQ_SEEK_SET: realorigin = SEEK_SET; break;
 		default: return -1; //failed
 	}
-	return fseek((FILE *)file,(long)offset,(int)realorigin);
+	return ::fseek((FILE *)file,(long)offset,(int)realorigin);
 }
 
-int64_t sqstd_ftell(SQFILE file)
+int64_t rabbit::std::ftell(SQFILE file)
 {
-	return ftell((FILE *)file);
+	return ::ftell((FILE *)file);
 }
 
-int64_t sqstd_fflush(SQFILE file)
+int64_t rabbit::std::fflush(SQFILE file)
 {
-	return fflush((FILE *)file);
+	return ::fflush((FILE *)file);
 }
 
-int64_t sqstd_fclose(SQFILE file)
+int64_t rabbit::std::fclose(SQFILE file)
 {
-	return fclose((FILE *)file);
+	return ::fclose((FILE *)file);
 }
 
-int64_t sqstd_feof(SQFILE file)
+int64_t rabbit::std::feof(SQFILE file)
 {
-	return feof((FILE *)file);
+	return ::feof((FILE *)file);
 }
+namespace rabbit {
 
-//File
+	namespace std {
-struct SQFile : public SQStream {
+		//File
-	SQFile() { _handle = NULL; _owns = false;}
+		struct File : public rabbit::std::SQStream {
-	SQFile(SQFILE file, bool owns) { _handle = file; _owns = owns;}
+			File() { _handle = NULL; _owns = false;}
-	virtual ~SQFile() { close(); }
+			File(SQFILE file, bool owns) { _handle = file; _owns = owns;}
-	bool Open(const rabbit::Char *filename ,const rabbit::Char *mode) {
+			virtual ~File() { close(); }
-		close();
+			bool Open(const rabbit::Char *filename ,const rabbit::Char *mode) {
-		if( (_handle = sqstd_fopen(filename,mode)) ) {
+				close();
-			_owns = true;
+				if( (_handle = rabbit::std::fopen(filename,mode)) ) {
-			return true;
+					_owns = true;
-		}
+					return true;
-		return false;
+				}
+				return false;
+			}
+			void close() {
+				if(_handle && _owns) {
+					rabbit::std::fclose(_handle);
+					_handle = NULL;
+					_owns = false;
+				}
+			}
+			int64_t Read(void *buffer,int64_t size) {
+				return rabbit::std::fread(buffer,1,size,_handle);
+			}
+			int64_t Write(void *buffer,int64_t size) {
+				return rabbit::std::fwrite(buffer,1,size,_handle);
+			}
+			int64_t Flush() {
+				return rabbit::std::fflush(_handle);
+			}
+			int64_t Tell() {
+				return rabbit::std::ftell(_handle);
+			}
+			int64_t Len() {
+				int64_t prevpos=Tell();
+				Seek(0,SQ_SEEK_END);
+				int64_t size=Tell();
+				Seek(prevpos,SQ_SEEK_SET);
+				return size;
+			}
+			int64_t Seek(int64_t offset, int64_t origin)  {
+				return rabbit::std::fseek(_handle,offset,origin);
+			}
+			bool IsValid() { return _handle?true:false; }
+			bool EOS() { return Tell()==Len()?true:false;}
+			SQFILE getHandle() {return _handle;}
+		private:
+			SQFILE _handle;
+			bool _owns;
+		};
 	}
-	void close() {
+}
-		if(_handle && _owns) {
-			sqstd_fclose(_handle);
-			_handle = NULL;
-			_owns = false;
-		}
-	}
-	int64_t Read(void *buffer,int64_t size) {
-		return sqstd_fread(buffer,1,size,_handle);
-	}
-	int64_t Write(void *buffer,int64_t size) {
-		return sqstd_fwrite(buffer,1,size,_handle);
-	}
-	int64_t Flush() {
-		return sqstd_fflush(_handle);
-	}
-	int64_t Tell() {
-		return sqstd_ftell(_handle);
-	}
-	int64_t Len() {
-		int64_t prevpos=Tell();
-		Seek(0,SQ_SEEK_END);
-		int64_t size=Tell();
-		Seek(prevpos,SQ_SEEK_SET);
-		return size;
-	}
-	int64_t Seek(int64_t offset, int64_t origin)  {
-		return sqstd_fseek(_handle,offset,origin);
-	}
-	bool IsValid() { return _handle?true:false; }
-	bool EOS() { return Tell()==Len()?true:false;}
-	SQFILE getHandle() {return _handle;}
-private:
-	SQFILE _handle;
-	bool _owns;
-};
-
 static int64_t _file__typeof(rabbit::VirtualMachine* v)
 {
 	sq_pushstring(v,_SC("file"),-1);
@@ -124,9 +127,9 @@ static int64_t _file__typeof(rabbit::VirtualMachine* v)
 
 static int64_t _file_releasehook(rabbit::UserPointer p, int64_t SQ_UNUSED_ARG(size))
 {
-	SQFile *self = (SQFile*)p;
+	rabbit::std::File *self = (rabbit::std::File*)p;
-	self->~SQFile();
+	self->~File();
-	sq_free(self,sizeof(SQFile));
+	rabbit::sq_free(self,sizeof(rabbit::std::File));
 	return 1;
 }
 
@@ -134,34 +137,34 @@ static int64_t _file_constructor(rabbit::VirtualMachine* v)
 {
 	const rabbit::Char *filename,*mode;
 	bool owns = true;
-	SQFile *f;
+	rabbit::std::File *f;
-	SQFILE newf;
+	rabbit::std::SQFILE newf;
-	if(sq_gettype(v,2) == rabbit::OT_STRING && sq_gettype(v,3) == rabbit::OT_STRING) {
+	if(rabbit::sq_gettype(v,2) == rabbit::OT_STRING && sq_gettype(v,3) == rabbit::OT_STRING) {
-		sq_getstring(v, 2, &filename);
+		rabbit::sq_getstring(v, 2, &filename);
-		sq_getstring(v, 3, &mode);
+		rabbit::sq_getstring(v, 3, &mode);
-		newf = sqstd_fopen(filename, mode);
+		newf = rabbit::std::fopen(filename, mode);
-		if(!newf) return sq_throwerror(v, _SC("cannot open file"));
+		if(!newf) return rabbit::sq_throwerror(v, _SC("cannot open file"));
-	} else if(sq_gettype(v,2) == rabbit::OT_USERPOINTER) {
+	} else if(rabbit::sq_gettype(v,2) == rabbit::OT_USERPOINTER) {
-		owns = !(sq_gettype(v,3) == rabbit::OT_NULL);
+		owns = !(rabbit::sq_gettype(v,3) == rabbit::OT_NULL);
-		sq_getuserpointer(v,2,&newf);
+		rabbit::sq_getuserpointer(v,2,&newf);
 	} else {
-		return sq_throwerror(v,_SC("wrong parameter"));
+		return rabbit::sq_throwerror(v,_SC("wrong parameter"));
 	}
 
-	f = new (sq_malloc(sizeof(SQFile)))SQFile(newf,owns);
+	f = new (rabbit::sq_malloc(sizeof(rabbit::std::File)))rabbit::std::File(newf,owns);
-	if(SQ_FAILED(sq_setinstanceup(v,1,f))) {
+	if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,f))) {
-		f->~SQFile();
+		f->~File();
-		sq_free(f,sizeof(SQFile));
+		rabbit::sq_free(f,sizeof(rabbit::std::File));
-		return sq_throwerror(v, _SC("cannot create blob with negative size"));
+		return rabbit::sq_throwerror(v, _SC("cannot create blob with negative size"));
 	}
-	sq_setreleasehook(v,1,_file_releasehook);
+	rabbit::sq_setreleasehook(v,1,_file_releasehook);
 	return 0;
 }
 
 static int64_t _file_close(rabbit::VirtualMachine* v)
 {
-	SQFile *self = NULL;
+	rabbit::std::File *self = NULL;
-	if(SQ_SUCCEEDED(sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)SQSTD_FILE_TYPE_TAG))
+	if(SQ_SUCCEEDED(rabbit::sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)SQSTD_FILE_TYPE_TAG))
 		&& self != NULL)
 	{
 		self->close();
@@ -180,7 +183,7 @@ static const rabbit::RegFunction _file_methods[] = {
 
 
 
-rabbit::Result sqstd_createfile(rabbit::VirtualMachine* v, SQFILE file,rabbit::Bool own)
+rabbit::Result rabbit::std::createfile(rabbit::VirtualMachine* v, SQFILE file,rabbit::Bool own)
 {
 	int64_t top = sq_gettop(v);
 	sq_pushregistrytable(v);
@@ -204,9 +207,9 @@ rabbit::Result sqstd_createfile(rabbit::VirtualMachine* v, SQFILE file,rabbit::B
 	return SQ_ERROR;
 }
 
-rabbit::Result sqstd_getfile(rabbit::VirtualMachine* v, int64_t idx, SQFILE *file)
+rabbit::Result rabbit::std::getfile(rabbit::VirtualMachine* v, int64_t idx, SQFILE *file)
 {
-	SQFile *fileobj = NULL;
+	rabbit::std::File *fileobj = NULL;
 	if(SQ_SUCCEEDED(sq_getinstanceup(v,idx,(rabbit::UserPointer*)&fileobj,(rabbit::UserPointer)SQSTD_FILE_TYPE_TAG))) {
 		*file = fileobj->getHandle();
 		return SQ_OK;
@@ -221,7 +224,7 @@ struct IOBuffer {
 	unsigned char buffer[IO_BUFFER_SIZE];
 	int64_t size;
 	int64_t ptr;
-	SQFILE file;
+	rabbit::std::SQFILE file;
 };
 
 int64_t _read_byte(IOBuffer *iobuffer)
@@ -233,7 +236,7 @@ int64_t _read_byte(IOBuffer *iobuffer)
 		return ret;
 	}
 	else {
-		if( (iobuffer->size = sqstd_fread(iobuffer->buffer,1,IO_BUFFER_SIZE,iobuffer->file )) > 0 )
+		if( (iobuffer->size = rabbit::std::fread(iobuffer->buffer,1,IO_BUFFER_SIZE,iobuffer->file )) > 0 )
 		{
 			int64_t ret = iobuffer->buffer[0];
 			iobuffer->ptr = 1;
@@ -253,7 +256,7 @@ int64_t _read_two_bytes(IOBuffer *iobuffer)
 		return ret;
 	}
 	else {
-		if( (iobuffer->size = sqstd_fread(iobuffer->buffer,1,IO_BUFFER_SIZE,iobuffer->file )) > 0 )
+		if( (iobuffer->size = rabbit::std::fread(iobuffer->buffer,1,IO_BUFFER_SIZE,iobuffer->file )) > 0 )
 		{
 			if(iobuffer->size < 2) return 0;
 			int64_t ret = *((const wchar_t*)&iobuffer->buffer[0]);
@@ -335,33 +338,33 @@ static int64_t _io_file_lexfeed_UCS2_BE(rabbit::UserPointer iobuf)
 int64_t file_read(rabbit::UserPointer file,rabbit::UserPointer buf,int64_t size)
 {
 	int64_t ret;
-	if( ( ret = sqstd_fread(buf,1,size,(SQFILE)file ))!=0 )return ret;
+	if( ( ret = rabbit::std::fread(buf,1,size,(rabbit::std::SQFILE)file ))!=0 )return ret;
 	return -1;
 }
 
 int64_t file_write(rabbit::UserPointer file,rabbit::UserPointer p,int64_t size)
 {
-	return sqstd_fwrite(p,1,size,(SQFILE)file);
+	return rabbit::std::fwrite(p,1,size,(rabbit::std::SQFILE)file);
 }
 
-rabbit::Result sqstd_loadfile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool printerror)
+rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool printerror)
 {
-	SQFILE file = sqstd_fopen(filename,_SC("rb"));
+	SQFILE file = rabbit::std::fopen(filename,_SC("rb"));
 
 	int64_t ret;
 	unsigned short us;
 	unsigned char uc;
 	SQLEXREADFUNC func = _io_file_lexfeed_PLAIN;
 	if(file){
-		ret = sqstd_fread(&us,1,2,file);
+		ret = rabbit::std::fread(&us,1,2,file);
 		if(ret != 2) {
 			//probably an empty file
 			us = 0;
 		}
 		if(us == SQ_BYTECODE_STREAM_TAG) { //BYTECODE
-			sqstd_fseek(file,0,SQ_SEEK_SET);
+			rabbit::std::fseek(file,0,SQ_SEEK_SET);
 			if(SQ_SUCCEEDED(sq_readclosure(v,file_read,file))) {
-				sqstd_fclose(file);
+				rabbit::std::fclose(file);
 				return SQ_OK;
 			}
 		}
@@ -373,12 +376,12 @@ rabbit::Result sqstd_loadfile(rabbit::VirtualMachine* v,const rabbit::Char *file
 				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(sqstd_fread(&uc,1,sizeof(uc),file) == 0) {
+					if(rabbit::std::fread(&uc,1,sizeof(uc),file) == 0) {
-						sqstd_fclose(file);
+						rabbit::std::fclose(file);
 						return sq_throwerror(v,_SC("io error"));
 					}
 					if(uc != 0xBF) {
-						sqstd_fclose(file);
+						rabbit::std::fclose(file);
 						return sq_throwerror(v,_SC("Unrecognized encoding"));
 					}
 #ifdef SQUNICODE
@@ -387,30 +390,30 @@ rabbit::Result sqstd_loadfile(rabbit::VirtualMachine* v,const rabbit::Char *file
 					func = _io_file_lexfeed_PLAIN;
 #endif
 					break;//UTF-8 ;
-				default: sqstd_fseek(file,0,SQ_SEEK_SET); break; // ascii
+				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))){
-				sqstd_fclose(file);
+				rabbit::std::fclose(file);
 				return SQ_OK;
 			}
 		}
-		sqstd_fclose(file);
+		rabbit::std::fclose(file);
 		return SQ_ERROR;
 	}
 	return sq_throwerror(v,_SC("cannot open the file"));
 }
 
-rabbit::Result sqstd_dofile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool retval,rabbit::Bool printerror)
+rabbit::Result rabbit::std::dofile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool retval,rabbit::Bool printerror)
 {
 	//at least one entry must exist in order for us to push it as the environment
 	if(sq_gettop(v) == 0)
 		return sq_throwerror(v,_SC("environment table expected"));
 
-	if(SQ_SUCCEEDED(sqstd_loadfile(v,filename,printerror))) {
+	if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,printerror))) {
 		sq_push(v,-2);
 		if(SQ_SUCCEEDED(sq_call(v,1,retval,SQTrue))) {
 			sq_remove(v,retval?-2:-1); //removes the closure
@@ -421,15 +424,15 @@ rabbit::Result sqstd_dofile(rabbit::VirtualMachine* v,const rabbit::Char *filena
 	return SQ_ERROR;
 }
 
-rabbit::Result sqstd_writeclosuretofile(rabbit::VirtualMachine* v,const rabbit::Char *filename)
+rabbit::Result rabbit::std::writeclosuretofile(rabbit::VirtualMachine* v,const rabbit::Char *filename)
 {
-	SQFILE file = sqstd_fopen(filename,_SC("wb+"));
+	SQFILE file = rabbit::std::fopen(filename,_SC("wb+"));
 	if(!file) return sq_throwerror(v,_SC("cannot open the file"));
 	if(SQ_SUCCEEDED(sq_writeclosure(v,file_write,file))) {
-		sqstd_fclose(file);
+		rabbit::std::fclose(file);
 		return SQ_OK;
 	}
-	sqstd_fclose(file);
+	rabbit::std::fclose(file);
 	return SQ_ERROR; //forward the error
 }
 
@@ -441,7 +444,7 @@ int64_t _g_io_loadfile(rabbit::VirtualMachine* v)
 	if(sq_gettop(v) >= 3) {
 		sq_getbool(v,3,&printerror);
 	}
-	if(SQ_SUCCEEDED(sqstd_loadfile(v,filename,printerror)))
+	if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,printerror)))
 		return 1;
 	return SQ_ERROR; //propagates the error
 }
@@ -450,7 +453,7 @@ int64_t _g_io_writeclosuretofile(rabbit::VirtualMachine* v)
 {
 	const rabbit::Char *filename;
 	sq_getstring(v,2,&filename);
-	if(SQ_SUCCEEDED(sqstd_writeclosuretofile(v,filename)))
+	if(SQ_SUCCEEDED(rabbit::std::writeclosuretofile(v,filename)))
 		return 1;
 	return SQ_ERROR; //propagates the error
 }
@@ -464,7 +467,7 @@ int64_t _g_io_dofile(rabbit::VirtualMachine* v)
 		sq_getbool(v,3,&printerror);
 	}
 	sq_push(v,1); //repush the this
-	if(SQ_SUCCEEDED(sqstd_dofile(v,filename,SQTrue,printerror)))
+	if(SQ_SUCCEEDED(rabbit::std::dofile(v,filename,SQTrue,printerror)))
 		return 1;
 	return SQ_ERROR; //propagates the error
 }
@@ -477,19 +480,19 @@ static const rabbit::RegFunction iolib_funcs[]={
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
-rabbit::Result sqstd_register_iolib(rabbit::VirtualMachine* v)
+rabbit::Result rabbit::std::register_iolib(rabbit::VirtualMachine* v)
 {
 	int64_t top = sq_gettop(v);
 	//create delegate
 	declare_stream(v,_SC("file"),(rabbit::UserPointer)SQSTD_FILE_TYPE_TAG,_SC("std_file"),_file_methods,iolib_funcs);
 	sq_pushstring(v,_SC("stdout"),-1);
-	sqstd_createfile(v,stdout,SQFalse);
+	rabbit::std::createfile(v,stdout,SQFalse);
 	sq_newslot(v,-3,SQFalse);
 	sq_pushstring(v,_SC("stdin"),-1);
-	sqstd_createfile(v,stdin,SQFalse);
+	rabbit::std::createfile(v,stdin,SQFalse);
 	sq_newslot(v,-3,SQFalse);
 	sq_pushstring(v,_SC("stderr"),-1);
-	sqstd_createfile(v,stderr,SQFalse);
+	rabbit::std::createfile(v,stderr,SQFalse);
 	sq_newslot(v,-3,SQFalse);
 	sq_settop(v,top);
 	return SQ_OK;

rabbit-std/sqstdio.hpp

@@ -7,6 +7,8 @@
  */
 #pragma once
 
+namespace rabbit {
+	namespace std {
 #define SQSTD_STREAM_TYPE_TAG 0x80000000
 
 struct SQStream {
@@ -25,24 +27,26 @@ struct SQStream {
 #define SQ_SEEK_END 1
 #define SQ_SEEK_SET 2
 
-typedef void* SQFILE;
+using SQFILE = void*;
 
-RABBIT_API SQFILE sqstd_fopen(const rabbit::Char *,const rabbit::Char *);
+SQFILE fopen(const rabbit::Char *,const rabbit::Char *);
-RABBIT_API int64_t sqstd_fread(rabbit::UserPointer, int64_t, int64_t, SQFILE);
+int64_t fread(rabbit::UserPointer, int64_t, int64_t, SQFILE);
-RABBIT_API int64_t sqstd_fwrite(const rabbit::UserPointer, int64_t, int64_t, SQFILE);
+int64_t fwrite(const rabbit::UserPointer, int64_t, int64_t, SQFILE);
-RABBIT_API int64_t sqstd_fseek(SQFILE , int64_t , int64_t);
+int64_t fseek(SQFILE , int64_t , int64_t);
-RABBIT_API int64_t sqstd_ftell(SQFILE);
+int64_t ftell(SQFILE);
-RABBIT_API int64_t sqstd_fflush(SQFILE);
+int64_t fflush(SQFILE);
-RABBIT_API int64_t sqstd_fclose(SQFILE);
+int64_t fclose(SQFILE);
-RABBIT_API int64_t sqstd_feof(SQFILE);
+int64_t feof(SQFILE);
 
-RABBIT_API rabbit::Result sqstd_createfile(rabbit::VirtualMachine* v, SQFILE file,rabbit::Bool own);
+rabbit::Result createfile(rabbit::VirtualMachine* v, SQFILE file,rabbit::Bool own);
-RABBIT_API rabbit::Result sqstd_getfile(rabbit::VirtualMachine* v, int64_t idx, SQFILE *file);
+rabbit::Result getfile(rabbit::VirtualMachine* v, int64_t idx, SQFILE *file);
 
 //compiler helpers
-RABBIT_API rabbit::Result sqstd_loadfile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool printerror);
+rabbit::Result loadfile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool printerror);
-RABBIT_API rabbit::Result sqstd_dofile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool retval,rabbit::Bool printerror);
+rabbit::Result dofile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool retval,rabbit::Bool printerror);
-RABBIT_API rabbit::Result sqstd_writeclosuretofile(rabbit::VirtualMachine* v,const rabbit::Char *filename);
+rabbit::Result writeclosuretofile(rabbit::VirtualMachine* v,const rabbit::Char *filename);
 
-RABBIT_API rabbit::Result sqstd_register_iolib(rabbit::VirtualMachine* v);
+rabbit::Result register_iolib(rabbit::VirtualMachine* v);
 
+	}
+}

rabbit-std/sqstdmath.cpp

@@ -93,7 +93,7 @@ static const rabbit::RegFunction mathlib_funcs[] = {
 #define M_PI (3.14159265358979323846)
 #endif
 
-rabbit::Result sqstd_register_mathlib(rabbit::VirtualMachine* v)
+rabbit::Result rabbit::std::register_mathlib(rabbit::VirtualMachine* v)
 {
 	int64_t i=0;
 	while(mathlib_funcs[i].name!=0) {

rabbit-std/sqstdmath.hpp

@@ -10,5 +10,8 @@
 #include <rabbit/rabbit.hpp>
 #include <rabbit/RegFunction.hpp>
 
-RABBIT_API rabbit::Result sqstd_register_mathlib(rabbit::VirtualMachine* v);
+namespace rabbit {
-
+	namespace std {
+		rabbit::Result register_mathlib(rabbit::VirtualMachine* v);
+	}
+}

rabbit-std/sqstdstream.cpp

@@ -17,11 +17,11 @@
 #include <rabbit-std/sqstdblobimpl.hpp>
 
 #define SETUP_STREAM(v) \
-	SQStream *self = NULL; \
+	rabbit::std::SQStream *self = NULL; \
 	if(SQ_FAILED(sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)((uint64_t)SQSTD_STREAM_TYPE_TAG)))) \
-		return sq_throwerror(v,_SC("invalid type tag")); \
+		return rabbit::sq_throwerror(v,_SC("invalid type tag")); \
 	if(!self || !self->IsValid())  \
-		return sq_throwerror(v,_SC("the stream is invalid"));
+		return rabbit::sq_throwerror(v,_SC("the stream is invalid"));
 
 int64_t _stream_readblob(rabbit::VirtualMachine* v)
 {
@@ -36,7 +36,7 @@ int64_t _stream_readblob(rabbit::VirtualMachine* v)
 	res = self->Read(data,size);
 	if(res <= 0)
 		return sq_throwerror(v,_SC("no data left to read"));
-	blobp = sqstd_createblob(v,res);
+	blobp = rabbit::std::createblob(v,res);
 	memcpy(blobp,data,res);
 	return 1;
 }
@@ -109,9 +109,9 @@ int64_t _stream_writeblob(rabbit::VirtualMachine* v)
 	rabbit::UserPointer data;
 	int64_t size;
 	SETUP_STREAM(v);
-	if(SQ_FAILED(sqstd_getblob(v,2,&data)))
+	if(SQ_FAILED(rabbit::std::getblob(v,2,&data)))
 		return sq_throwerror(v,_SC("invalid parameter"));
-	size = sqstd_getblobsize(v,2);
+	size = rabbit::std::getblobsize(v,2);
 	if(self->Write(data,size) != size)
 		return sq_throwerror(v,_SC("io error"));
 	sq_pushinteger(v,size);
@@ -290,7 +290,7 @@ void init_streamclass(rabbit::VirtualMachine* v)
 	sq_pop(v,1);
 }
 
-rabbit::Result declare_stream(rabbit::VirtualMachine* v,const rabbit::Char* name,rabbit::UserPointer typetag,const rabbit::Char* reg_name,const rabbit::RegFunction *methods,const rabbit::RegFunction *globals)
+rabbit::Result rabbit::std::declare_stream(rabbit::VirtualMachine* v,const rabbit::Char* name,rabbit::UserPointer typetag,const rabbit::Char* reg_name,const rabbit::RegFunction *methods,const rabbit::RegFunction *globals)
 {
 	if(sq_gettype(v,-1) != rabbit::OT_TABLE)
 		return sq_throwerror(v,_SC("table expected"));

rabbit-std/sqstdstream.hpp

@@ -9,16 +9,20 @@
 
 #include <rabbit/RegFunction.hpp>
 
-int64_t _stream_readblob(rabbit::VirtualMachine* v);
+namespace rabbit {
-int64_t _stream_readline(rabbit::VirtualMachine* v);
+	namespace std {
-int64_t _stream_readn(rabbit::VirtualMachine* v);
+		int64_t _stream_readblob(rabbit::VirtualMachine* v);
-int64_t _stream_writeblob(rabbit::VirtualMachine* v);
+		int64_t _stream_readline(rabbit::VirtualMachine* v);
-int64_t _stream_writen(rabbit::VirtualMachine* v);
+		int64_t _stream_readn(rabbit::VirtualMachine* v);
-int64_t _stream_seek(rabbit::VirtualMachine* v);
+		int64_t _stream_writeblob(rabbit::VirtualMachine* v);
-int64_t _stream_tell(rabbit::VirtualMachine* v);
+		int64_t _stream_writen(rabbit::VirtualMachine* v);
-int64_t _stream_len(rabbit::VirtualMachine* v);
+		int64_t _stream_seek(rabbit::VirtualMachine* v);
-int64_t _stream_eos(rabbit::VirtualMachine* v);
+		int64_t _stream_tell(rabbit::VirtualMachine* v);
-int64_t _stream_flush(rabbit::VirtualMachine* v);
+		int64_t _stream_len(rabbit::VirtualMachine* v);
+		int64_t _stream_eos(rabbit::VirtualMachine* v);
+		int64_t _stream_flush(rabbit::VirtualMachine* v);
 		
-#define _DECL_STREAM_FUNC(name,nparams,typecheck) {_SC(#name),_stream_##name,nparams,typecheck}
+		#define _DECL_STREAM_FUNC(name,nparams,typecheck) {_SC(#name),_stream_##name,nparams,typecheck}
-rabbit::Result declare_stream(rabbit::VirtualMachine* v,const rabbit::Char* name,rabbit::UserPointer typetag,const rabbit::Char* reg_name,const rabbit::RegFunction *methods,const rabbit::RegFunction *globals);
+		rabbit::Result declare_stream(rabbit::VirtualMachine* v,const rabbit::Char* name,rabbit::UserPointer typetag,const rabbit::Char* reg_name,const rabbit::RegFunction *methods,const rabbit::RegFunction *globals);
+	}
+}

rabbit-std/sqstdstring.cpp

@@ -21,7 +21,12 @@
 static rabbit::Bool isfmtchr(rabbit::Char ch)
 {
 	switch(ch) {
-	case '-': case '+': case ' ': case '#': case '0': return SQTrue;
+		case '-':
+		case '+':
+		case ' ':
+		case '#':
+		case '0':
+			return SQTrue;
 	}
 	return SQFalse;
 }
@@ -71,7 +76,7 @@ static int64_t validate_format(rabbit::VirtualMachine* v, rabbit::Char *fmt, con
 	return n;
 }
 
-rabbit::Result sqstd_format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t *outlen,rabbit::Char **output)
+rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t *outlen,rabbit::Char **output)
 {
 	const rabbit::Char *format;
 	rabbit::Char *dest;
@@ -164,7 +169,7 @@ static int64_t _string_printf(rabbit::VirtualMachine* v)
 {
 	rabbit::Char *dest = NULL;
 	int64_t length = 0;
-	if(SQ_FAILED(sqstd_format(v,2,&length,&dest)))
+	if(SQ_FAILED(rabbit::std::format(v,2,&length,&dest)))
 		return -1;
 
 	SQPRINTFUNCTION printfunc = sq_getprintfunc(v);
@@ -177,7 +182,7 @@ static int64_t _string_format(rabbit::VirtualMachine* v)
 {
 	rabbit::Char *dest = NULL;
 	int64_t length = 0;
-	if(SQ_FAILED(sqstd_format(v,2,&length,&dest)))
+	if(SQ_FAILED(rabbit::std::format(v,2,&length,&dest)))
 		return -1;
 	sq_pushstring(v,dest,length);
 	return 1;
@@ -370,13 +375,13 @@ static int64_t _string_endswith(rabbit::VirtualMachine* v)
 }
 
 #define SETUP_REX(v) \
-	SQRex *self = NULL; \
+	rabbit::std::SQRex *self = NULL; \
-	sq_getinstanceup(v,1,(rabbit::UserPointer *)&self,0);
+	rabbit::sq_getinstanceup(v,1,(rabbit::UserPointer *)&self,0);
 
 static int64_t _rexobj_releasehook(rabbit::UserPointer p, int64_t SQ_UNUSED_ARG(size))
 {
-	SQRex *self = ((SQRex *)p);
+	rabbit::std::SQRex *self = ((rabbit::std::SQRex *)p);
-	sqstd_rex_free(self);
+	rabbit::std::rex_free(self);
 	return 1;
 }
 
@@ -385,7 +390,7 @@ static int64_t _regexp_match(rabbit::VirtualMachine* v)
 	SETUP_REX(v);
 	const rabbit::Char *str;
 	sq_getstring(v,2,&str);
-	if(sqstd_rex_match(self,str) == SQTrue)
+	if(rabbit::std::rex_match(self,str) == SQTrue)
 	{
 		sq_pushbool(v,SQTrue);
 		return 1;
@@ -412,7 +417,7 @@ static int64_t _regexp_search(rabbit::VirtualMachine* v)
 	int64_t start = 0;
 	sq_getstring(v,2,&str);
 	if(sq_gettop(v) > 2) sq_getinteger(v,3,&start);
-	if(sqstd_rex_search(self,str+start,&begin,&end) == SQTrue) {
+	if(rabbit::std::rex_search(self,str+start,&begin,&end) == SQTrue) {
 		_addrexmatch(v,str,begin,end);
 		return 1;
 	}
@@ -426,12 +431,12 @@ static int64_t _regexp_capture(rabbit::VirtualMachine* v)
 	int64_t start = 0;
 	sq_getstring(v,2,&str);
 	if(sq_gettop(v) > 2) sq_getinteger(v,3,&start);
-	if(sqstd_rex_search(self,str+start,&begin,&end) == SQTrue) {
+	if(rabbit::std::rex_search(self,str+start,&begin,&end) == SQTrue) {
-		int64_t n = sqstd_rex_getsubexpcount(self);
+		int64_t n = rabbit::std::rex_getsubexpcount(self);
-		SQRexMatch match;
+		rabbit::std::SQRexMatch match;
 		sq_newarray(v,0);
 		for(int64_t i = 0;i < n; i++) {
-			sqstd_rex_getsubexp(self,i,&match);
+			rabbit::std::rex_getsubexp(self,i,&match);
 			if(match.len > 0)
 				_addrexmatch(v,str,match.begin,match.begin+match.len);
 			else
@@ -446,7 +451,7 @@ static int64_t _regexp_capture(rabbit::VirtualMachine* v)
 static int64_t _regexp_subexpcount(rabbit::VirtualMachine* v)
 {
 	SETUP_REX(v);
-	sq_pushinteger(v,sqstd_rex_getsubexpcount(self));
+	sq_pushinteger(v,rabbit::std::rex_getsubexpcount(self));
 	return 1;
 }
 
@@ -454,7 +459,7 @@ static int64_t _regexp_constructor(rabbit::VirtualMachine* v)
 {
 	const rabbit::Char *error,*pattern;
 	sq_getstring(v,2,&pattern);
-	SQRex *rex = sqstd_rex_compile(pattern,&error);
+	rabbit::std::SQRex *rex = rabbit::std::rex_compile(pattern,&error);
 	if(!rex) return sq_throwerror(v,error);
 	sq_setinstanceup(v,1,rex);
 	sq_setreleasehook(v,1,_rexobj_releasehook);
@@ -495,7 +500,7 @@ static const rabbit::RegFunction stringlib_funcs[]={
 #undef _DECL_FUNC
 
 
-int64_t sqstd_register_stringlib(rabbit::VirtualMachine* v)
+int64_t rabbit::std::register_stringlib(rabbit::VirtualMachine* v)
 {
 	sq_pushstring(v,_SC("regexp"),-1);
 	sq_newclass(v,SQFalse);

rabbit-std/sqstdstring.hpp

@@ -9,23 +9,27 @@
 
 #include <rabbit/RegFunction.hpp>
 
-typedef unsigned int SQRexBool;
+namespace rabbit {
-typedef struct SQRex SQRex;
+	namespace std {
+		using SQRexBool = unsigned int;
+		using SQRex = struct SQRex;
 		
-typedef struct {
+		typedef struct {
-	const rabbit::Char *begin;
+			const rabbit::Char *begin;
-	int64_t len;
+			int64_t len;
-} SQRexMatch;
+		} SQRexMatch;
 		
-RABBIT_API SQRex *sqstd_rex_compile(const rabbit::Char *pattern,const rabbit::Char **error);
+		SQRex *rex_compile(const rabbit::Char *pattern,const rabbit::Char **error);
-RABBIT_API void sqstd_rex_free(SQRex *exp);
+		void rex_free(SQRex *exp);
-RABBIT_API rabbit::Bool sqstd_rex_match(SQRex* exp,const rabbit::Char* text);
+		rabbit::Bool rex_match(SQRex* exp,const rabbit::Char* text);
-RABBIT_API rabbit::Bool sqstd_rex_search(SQRex* exp,const rabbit::Char* text, const rabbit::Char** out_begin, const rabbit::Char** out_end);
+		rabbit::Bool rex_search(SQRex* exp,const rabbit::Char* text, const rabbit::Char** out_begin, const rabbit::Char** out_end);
-RABBIT_API rabbit::Bool sqstd_rex_searchrange(SQRex* exp,const rabbit::Char* text_begin,const rabbit::Char* text_end,const rabbit::Char** out_begin, const rabbit::Char** out_end);
+		rabbit::Bool rex_searchrange(SQRex* exp,const rabbit::Char* text_begin,const rabbit::Char* text_end,const rabbit::Char** out_begin, const rabbit::Char** out_end);
-RABBIT_API int64_t sqstd_rex_getsubexpcount(SQRex* exp);
+		int64_t rex_getsubexpcount(SQRex* exp);
-RABBIT_API rabbit::Bool sqstd_rex_getsubexp(SQRex* exp, int64_t n, SQRexMatch *subexp);
+		rabbit::Bool rex_getsubexp(SQRex* exp, int64_t n, SQRexMatch *subexp);
 		
-RABBIT_API rabbit::Result sqstd_format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t *outlen,rabbit::Char **output);
+		rabbit::Result format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t *outlen,rabbit::Char **output);
 		
-RABBIT_API rabbit::Result sqstd_register_stringlib(rabbit::VirtualMachine* v);
+		rabbit::Result register_stringlib(rabbit::VirtualMachine* v);
 
+	}
+}

rabbit-std/sqstdsystem.cpp

@@ -139,7 +139,7 @@ static const rabbit::RegFunction systemlib_funcs[]={
 };
 #undef _DECL_FUNC
 
-int64_t sqstd_register_systemlib(rabbit::VirtualMachine* v)
+int64_t rabbit::std::register_systemlib(rabbit::VirtualMachine* v)
 {
 	int64_t i=0;
 	while(systemlib_funcs[i].name!=0)

rabbit-std/sqstdsystem.hpp

@@ -7,4 +7,8 @@
  */
 #pragma once
 
-RABBIT_API int64_t sqstd_register_systemlib(rabbit::VirtualMachine* v);
+namespace rabbit {
+	namespace std {
+int64_t register_systemlib(rabbit::VirtualMachine* v);
+	}
+}

rabbit/Array.cpp

@@ -6,6 +6,8 @@
  * @license MPL-2 (see license file)
  */
 #include <rabbit/Array.hpp>
+#include <rabbit/squtils.hpp>
+#include <rabbit/WeakRef.hpp>
 
 
 
@@ -18,3 +20,119 @@ void rabbit::Array::extend(const rabbit::Array *a){
 		}
 	}
 }
+
+rabbit::Array::Array(rabbit::SharedState* _ss,
+      int64_t _nsize) {
+	m_data.resize(_nsize);
+}
+rabbit::Array::~Array() {
+	// TODO: Clean DATA ...
+}
+// 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);
+	return newarray;
+}
+void rabbit::Array::finalize() {
+	m_data.resize(0);
+}
+bool rabbit::Array::get(const int64_t _nidx,
+         rabbit::ObjectPtr& _val) {
+	if(    _nidx >= 0
+	    && _nidx < (int64_t)m_data.size()){
+		rabbit::ObjectPtr &o = m_data[_nidx];
+		_val = _realval(o);
+		return true;
+	}
+	return false;
+}
+bool rabbit::Array::set(const int64_t _nidx,const rabbit::ObjectPtr& _val) {
+	if(_nidx>=0 && _nidx<(int64_t)m_data.size()){
+		m_data[_nidx] = _val;
+		return true;
+	}
+	return false;
+}
+int64_t rabbit::Array::next(const rabbit::ObjectPtr& _refpos,
+             rabbit::ObjectPtr& _outkey,
+             rabbit::ObjectPtr& _outval) {
+	uint64_t idx=translateIndex(_refpos);
+	while(idx<m_data.size()){
+		//first found
+		_outkey=(int64_t)idx;
+		rabbit::ObjectPtr& o = m_data[idx];
+		_outval = _realval(o);
+		//return idx for the next iteration
+		return ++idx;
+	}
+	//nothing to iterate anymore
+	return -1;
+}
+rabbit::Array* rabbit::Array::clone() {
+	Array *anew = create(NULL,0);
+	anew->m_data = m_data;
+	return anew;
+}
+int64_t rabbit::Array::size() const {
+	return m_data.size();
+}
+void rabbit::Array::resize(int64_t _size) {
+	rabbit::ObjectPtr empty;
+	resize(_size, empty);
+}
+void rabbit::Array::resize(int64_t _size,
+            rabbit::ObjectPtr& _fill) {
+	m_data.resize(_size, _fill);
+	shrinkIfNeeded();
+}
+void rabbit::Array::reserve(int64_t _size) {
+	m_data.reserve(_size);
+}
+void rabbit::Array::append(const rabbit::Object& _o) {
+	m_data.pushBack(_o);
+}
+
+rabbit::ObjectPtr& rabbit::Array::top(){
+	return m_data.back();
+}
+void rabbit::Array::pop() {
+	m_data.popBack();
+	shrinkIfNeeded();
+}
+bool rabbit::Array::insert(int64_t _idx,const rabbit::Object& _val) {
+	if(    _idx < 0
+	    || _idx > (int64_t)m_data.size()) {
+		return false;
+	}
+	m_data.insert(_idx, _val);
+	return true;
+}
+void rabbit::Array::shrinkIfNeeded() {
+	// TODO: Check this. No real need with etk ==> automatic ...
+	/*
+	if(m_data.size() <= m_data.capacity()>>2) {
+		//shrink the array
+		m_data.shrinktofit();
+	}
+	*/
+}
+bool rabbit::Array::remove(int64_t _idx) {
+	if(    _idx < 0
+	    || _idx >= (int64_t)m_data.size()) {
+		return false;
+	}
+	m_data.remove(_idx);
+	shrinkIfNeeded();
+	return true;
+}
+void rabbit::Array::release() {
+	sq_delete(this, Array);
+}
+rabbit::ObjectPtr& rabbit::Array::operator[] (const size_t _pos) {
+	return m_data[_pos];
+}
+const rabbit::ObjectPtr& rabbit::Array::operator[] (const size_t _pos) const {
+	return m_data[_pos];
+}

rabbit/Array.hpp

@@ -9,128 +9,42 @@
 
 #include <rabbit/RefCounted.hpp>
 #include <rabbit/ObjectPtr.hpp>
+#include <etk/Vector.hpp>
 
 namespace rabbit {
 	class SharedState;
-	class Array : public rabbit::RefCounted
+	class Array : public rabbit::RefCounted {
-	{
 		private:
 			Array(rabbit::SharedState* _ss,
-			      int64_t _nsize) {
+			      int64_t _nsize);
-				m_data.resize(_nsize);
+			~Array();
-			}
-			~Array() {
-				// TODO: Clean DATA ...
-			}
 		public:
 			// TODO : remove this ETK_ALLOC can do it natively ...
 			static Array* create(rabbit::SharedState* _ss,
-			                     int64_t _ninitialsize) {
+			                     int64_t _ninitialsize);
-				Array *newarray=(Array*)SQ_MALLOC(sizeof(Array));
+			void finalize();
-				new (newarray) Array(_ss, _ninitialsize);
-				return newarray;
-			}
-			void finalize() {
-				m_data.resize(0);
-			}
 			bool get(const int64_t _nidx,
-			         rabbit::ObjectPtr& _val) {
+			         rabbit::ObjectPtr& _val);
-				if(    _nidx >= 0
+			bool set(const int64_t _nidx,const rabbit::ObjectPtr& _val);
-				    && _nidx < (int64_t)m_data.size()){
-					rabbit::ObjectPtr &o = m_data[_nidx];
-					_val = _realval(o);
-					return true;
-				}
-				return false;
-			}
-			bool set(const int64_t _nidx,const rabbit::ObjectPtr& _val) {
-				if(_nidx>=0 && _nidx<(int64_t)m_data.size()){
-					m_data[_nidx] = _val;
-					return true;
-				}
-				return false;
-			}
 			int64_t next(const rabbit::ObjectPtr& _refpos,
 			             rabbit::ObjectPtr& _outkey,
-			             rabbit::ObjectPtr& _outval) {
+			             rabbit::ObjectPtr& _outval);
-				uint64_t idx=translateIndex(_refpos);
+			Array* clone();
-				while(idx<m_data.size()){
+			int64_t size() const;
-					//first found
+			void resize(int64_t _size);
-					_outkey=(int64_t)idx;
-					rabbit::ObjectPtr& o = m_data[idx];
-					_outval = _realval(o);
-					//return idx for the next iteration
-					return ++idx;
-				}
-				//nothing to iterate anymore
-				return -1;
-			}
-			Array* clone() {
-				Array *anew = create(NULL,0);
-				anew->m_data = m_data;
-				return anew;
-			}
-			int64_t size() const {
-				return m_data.size();
-			}
-			void resize(int64_t _size) {
-				rabbit::ObjectPtr empty;
-				resize(_size, empty);
-			}
 			void resize(int64_t _size,
-			            rabbit::ObjectPtr& _fill) {
+			            rabbit::ObjectPtr& _fill);
-				m_data.resize(_size, _fill);
+			void reserve(int64_t _size);
-				shrinkIfNeeded();
+			void append(const rabbit::Object& _o);
-			}
-			void reserve(int64_t _size) {
-				m_data.reserve(_size);
-			}
-			void append(const rabbit::Object& _o) {
-				m_data.pushBack(_o);
-			}
 			void extend(const Array* _a);
-			rabbit::ObjectPtr &top(){
+			rabbit::ObjectPtr &top();
-				return m_data.back();
+			void pop();
-			}
+			bool insert(int64_t _idx,const rabbit::Object& _val);
-			void pop() {
+			void shrinkIfNeeded();
-				m_data.popBack();
+			bool remove(int64_t _idx);
-				shrinkIfNeeded();
+			void release();
-			}
+			rabbit::ObjectPtr& operator[] (const size_t _pos);
-			bool insert(int64_t _idx,const rabbit::Object& _val) {
+			const rabbit::ObjectPtr& operator[] (const size_t _pos) const;
-				if(    _idx < 0
-				    || _idx > (int64_t)m_data.size()) {
-					return false;
-				}
-				m_data.insert(_idx, _val);
-				return true;
-			}
-			void shrinkIfNeeded() {
-				// TODO: Check this. No real need with etk ==> automatic ...
-				/*
-				if(m_data.size() <= m_data.capacity()>>2) {
-					//shrink the array
-					m_data.shrinktofit();
-				}
-				*/
-			}
-			bool remove(int64_t _idx) {
-				if(    _idx < 0
-				    || _idx >= (int64_t)m_data.size()) {
-					return false;
-				}
-				m_data.remove(_idx);
-				shrinkIfNeeded();
-				return true;
-			}
-			void release() {
-				sq_delete(this, Array);
-			}
-			rabbit::ObjectPtr& operator[] (const size_t _pos) {
-				return m_data[_pos];
-			}
-			const rabbit::ObjectPtr& operator[] (const size_t _pos) const {
-				return m_data[_pos];
-			}
 		private:
 			etk::Vector<rabbit::ObjectPtr> m_data;
 	};

rabbit/Class.cpp

@@ -9,7 +9,11 @@
 #include <rabbit/Instance.hpp>
 #include <rabbit/Table.hpp>
 #include <rabbit/SharedState.hpp>
+#include <rabbit/squtils.hpp>
 
+#include <rabbit/VirtualMachine.hpp>
+#include <rabbit/WeakRef.hpp>
+#include <rabbit/Closure.hpp>
 
 rabbit::Class::Class(rabbit::SharedState *ss, rabbit::Class *base) {
 	_base = base;
@@ -47,7 +51,7 @@ rabbit::Class::~Class() {
 
 rabbit::Class* rabbit::Class::create(rabbit::SharedState *ss, Class *base) {
 	rabbit::Class *newclass = (Class *)SQ_MALLOC(sizeof(Class));
-	new (newclass) Class(ss, base);
+	new ((char*)newclass) Class(ss, base);
 	return newclass;
 }
 

rabbit/Class.hpp

@@ -11,8 +11,8 @@
 
 #include <rabbit/VirtualMachine.hpp>
 
-#include <rabbit/sqfuncproto.hpp>
+
-#include <rabbit/sqclosure.hpp>
+
 #include <rabbit/ClassMember.hpp>
 
 namespace rabbit {

rabbit/Closure.cpp

@@ -6,11 +6,26 @@
  * @license MPL-2 (see license file)
  */
 #include <rabbit/Closure.hpp>
+#include <rabbit/VirtualMachine.hpp>
+#include <rabbit/rabbit.hpp>
+
+#include <rabbit/ObjectPtr.hpp>
+#include <rabbit/WeakRef.hpp>
+#include <rabbit/FunctionProto.hpp>
+
+#include <rabbit/LocalVarInfo.hpp>
+#include <rabbit/LineInfo.hpp>
+#include <rabbit/OuterVar.hpp>
+#include <rabbit/String.hpp>
+#include <rabbit/SharedState.hpp>
+#include <rabbit/Table.hpp>
+#include <rabbit/Class.hpp>
+#include <rabbit/RefCounted.hpp>
+#include <rabbit/squtils.hpp>
 
 
 
-#define _CHECK_IO(exp)  { if(!exp)return false; }
+bool rabbit::SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size)
-bool SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size)
 {
 	if(write(up,dest,size) != size) {
 		v->raise_error(_SC("io error (write function failure)"));
@@ -19,7 +34,7 @@ bool SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer u
 	return true;
 }
 
-bool SafeRead(rabbit::VirtualMachine* v,SQWRITEFUNC read,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size)
+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(_SC("io error, read function failure, the origin stream could be corrupted/trucated"));
@@ -28,12 +43,12 @@ bool SafeRead(rabbit::VirtualMachine* v,SQWRITEFUNC read,rabbit::UserPointer up,
 	return true;
 }
 
-bool WriteTag(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer up,uint32_t tag)
+bool rabbit::WriteTag(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer up,uint32_t tag)
 {
 	return SafeWrite(v,write,up,&tag,sizeof(tag));
 }
 
-bool CheckTag(rabbit::VirtualMachine* v,SQWRITEFUNC read,rabbit::UserPointer up,uint32_t 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)));
@@ -44,7 +59,7 @@ bool CheckTag(rabbit::VirtualMachine* v,SQWRITEFUNC read,rabbit::UserPointer up,
 	return true;
 }
 
-bool WriteObject(rabbit::VirtualMachine* v,rabbit::UserPointer up,SQWRITEFUNC write,rabbit::ObjectPtr &o)
+bool rabbit::WriteObject(rabbit::VirtualMachine* v,rabbit::UserPointer up,SQWRITEFUNC write,rabbit::ObjectPtr &o)
 {
 	uint32_t _type = (uint32_t)sq_type(o);
 	_CHECK_IO(SafeWrite(v,write,up,&_type,sizeof(_type)));
@@ -67,7 +82,7 @@ bool WriteObject(rabbit::VirtualMachine* v,rabbit::UserPointer up,SQWRITEFUNC wr
 	return true;
 }
 
-bool ReadObject(rabbit::VirtualMachine* v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &o)
+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)));
@@ -142,7 +157,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 (nc) rabbit::Closure(ss,func);
+	new ((char*)nc) rabbit::Closure(ss,func);
 	nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1);
 	nc->_defaultparams = &nc->_outervalues[func->_noutervalues];
 	nc->_root = root;
@@ -168,7 +183,7 @@ void rabbit::Closure::setRoot(rabbit::WeakRef *r) {
 	__ObjaddRef(_root);
 }
 
-Closure* rabbit::Closure::clone() {
+rabbit::Closure* rabbit::Closure::clone() {
 	rabbit::FunctionProto *f = _function;
 	rabbit::Closure * ret = rabbit::Closure::create(NULL,f,_root);
 	ret->_env = _env;

rabbit/Closure.hpp

@@ -10,6 +10,7 @@
 #include <rabbit/RefCounted.hpp>
 #include <rabbit/sqconfig.hpp>
 #include <rabbit/rabbit.hpp>
+#include <rabbit/squtils.hpp>
 
 namespace rabbit {
 	class SharedState;
@@ -41,9 +42,15 @@ 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; }
 #define SQ_CLOSURESTREAM_HEAD (('S'<<24)|('Q'<<16)|('I'<<8)|('R'))
 #define SQ_CLOSURESTREAM_PART (('P'<<24)|('A'<<16)|('R'<<8)|('T'))
 #define SQ_CLOSURESTREAM_TAIL (('T'<<24)|('A'<<16)|('I'<<8)|('L'))

rabbit/Compiler.cpp

@@ -11,14 +11,23 @@
 #ifndef NO_COMPILER
 #include <stdarg.h>
 #include <setjmp.h>
+#include <etk/types.hpp>
 #include <rabbit/sqopcodes.hpp>
+#include <rabbit/Lexer.hpp>
+
 
-#include <rabbit/sqfuncproto.hpp>
-#include <rabbit/sqcompiler.hpp>
-#include <rabbit/sqfuncstate.hpp>
-#include <rabbit/sqlexer.hpp>
 #include <rabbit/VirtualMachine.hpp>
+#include <rabbit/rabbit.hpp>
+#include <rabbit/sqconfig.hpp>
+#include <rabbit/FuncState.hpp>
+#include <rabbit/LocalVarInfo.hpp>
+#include <rabbit/OuterVar.hpp>
+#include <rabbit/String.hpp>
+#include <rabbit/SharedState.hpp>
+#include <rabbit/Table.hpp>
+#include <rabbit/Instruction.hpp>
 
+namespace rabbit {
 
 #define EXPR   1
 #define OBJECT 2
@@ -75,10 +84,10 @@ struct SQScope {
 					if(__nbreaks__>0)ResolveBreaks(_fs,__nbreaks__); \
 					_fs->_breaktargets.popBack();_fs->_continuetargets.popBack();}
 
-class rabbit::Compiler
+class Compiler
 {
 public:
-	rabbit::Compiler(rabbit::VirtualMachine *v, SQLEXREADFUNC rg, rabbit::UserPointer up, const rabbit::Char* sourcename, bool raiseerror, bool lineinfo)
+	Compiler(rabbit::VirtualMachine *v, SQLEXREADFUNC rg, rabbit::UserPointer up, const rabbit::Char* sourcename, bool raiseerror, bool lineinfo)
 	{
 		_vm=v;
 		_lex.init(_get_shared_state(v), rg, up,Throwerror,this);
@@ -886,7 +895,7 @@ public:
 		if(target < 0) {
 			target = _fs->pushTarget();
 		}
-		if(value <= INT_MAX && value > INT_MIN) { //does it fit in 32 bits?
+		if(value <= INT64_MAX && value > INT64_MIN) { //does it fit in 32 bits?
 			_fs->addInstruction(_OP_LOADINT, target,value);
 		}
 		else {
@@ -1583,8 +1592,9 @@ private:
 	jmp_buf _errorjmp;
 	rabbit::VirtualMachine *_vm;
 };
+}
 
-bool compile(rabbit::VirtualMachine *vm,SQLEXREADFUNC rg, rabbit::UserPointer up, const rabbit::Char *sourcename, rabbit::ObjectPtr &out, bool raiseerror, bool lineinfo)
+bool rabbit::compile(rabbit::VirtualMachine *vm,SQLEXREADFUNC rg, rabbit::UserPointer up, const rabbit::Char *sourcename, rabbit::ObjectPtr &out, bool raiseerror, bool lineinfo)
 {
 	rabbit::Compiler p(vm, rg, up, sourcename, raiseerror, lineinfo);
 	return p.compile(out);

rabbit/Compiler.hpp

@@ -7,6 +7,10 @@
  */
 #pragma once
 
+#include <rabbit/sqconfig.hpp>
+#include <rabbit/rabbit.hpp>
+#include <rabbit/ObjectPtr.hpp>
+
 namespace rabbit {
 	#define TK_IDENTIFIER   258
 	#define TK_STRING_LITERAL   259

rabbit/FuncState.cpp

@@ -5,15 +5,23 @@
  * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved
  * @license MPL-2 (see license file)
  */
+#include <rabbit/Compiler.hpp>
 #include <rabbit/FuncState.hpp>
 
 #ifndef NO_COMPILER
 #include <rabbit/Compiler.hpp>
 
-#include <rabbit/FuncProto.hpp>
+#include <rabbit/FunctionProto.hpp>
+#include <rabbit/Instruction.hpp>
+#include <rabbit/String.hpp>
+#include <rabbit/Class.hpp>
+#include <rabbit/Table.hpp>
+#include <rabbit/SharedState.hpp>
+
+
 
 #include <rabbit/sqopcodes.hpp>
-#include <rabbit/sqfuncstate.hpp>
+#include <rabbit/squtils.hpp>
 
 #ifdef _DEBUG_DUMP
 rabbit::InstructionDesc g_InstrDesc[]={
@@ -80,8 +88,14 @@ rabbit::InstructionDesc g_InstrDesc[]={
 	{_SC("_OP_CLOSE")},
 };
 #endif
-void dumpLiteral(rabbit::ObjectPtr &o)
+
-{
+
+void rabbit::FuncState::addInstruction(SQOpcode _op,int64_t arg0,int64_t arg1,int64_t arg2,int64_t arg3){
+	rabbit::Instruction i(_op,arg0,arg1,arg2,arg3);
+	addInstruction(i);
+}
+
+static void dumpLiteral(rabbit::ObjectPtr &o) {
 	switch(sq_type(o)){
 		case rabbit::OT_STRING: scprintf(_SC("\"%s\""),_stringval(o));break;
 		case rabbit::OT_FLOAT: scprintf(_SC("{%f}"),_float(o));break;
@@ -91,7 +105,7 @@ void dumpLiteral(rabbit::ObjectPtr &o)
 	}
 }
 
-FuncState::rabbit::FuncState(rabbit::SharedState *ss,rabbit::FuncState *parent,compilererrorFunc efunc,void *ed)
+rabbit::FuncState::FuncState(rabbit::SharedState *ss,rabbit::FuncState *parent,compilererrorFunc efunc,void *ed)
 {
 		_nliterals = 0;
 		_literals = rabbit::Table::create(ss,0);
@@ -112,13 +126,13 @@ FuncState::rabbit::FuncState(rabbit::SharedState *ss,rabbit::FuncState *parent,c
 
 }
 
-void FuncState::error(const rabbit::Char *err)
+void rabbit::FuncState::error(const rabbit::Char *err)
 {
 	_errfunc(_errtarget,err);
 }
 
 #ifdef _DEBUG_DUMP
-void FuncState::dump(rabbit::FunctionProto *func)
+void rabbit::FuncState::dump(rabbit::FunctionProto *func)
 {
 	uint64_t n=0,i;
 	int64_t si;
@@ -217,17 +231,17 @@ void FuncState::dump(rabbit::FunctionProto *func)
 }
 #endif
 
-int64_t FuncState::getNumericConstant(const int64_t cons)
+int64_t rabbit::FuncState::getNumericConstant(const int64_t cons)
 {
 	return getConstant(rabbit::ObjectPtr(cons));
 }
 
-int64_t FuncState::getNumericConstant(const float_t cons)
+int64_t rabbit::FuncState::getNumericConstant(const float_t cons)
 {
 	return getConstant(rabbit::ObjectPtr(cons));
 }
 
-int64_t FuncState::getConstant(const rabbit::Object &cons)
+int64_t rabbit::FuncState::getConstant(const rabbit::Object &cons)
 {
 	rabbit::ObjectPtr val;
 	if(!_table(_literals)->get(cons,val))
@@ -243,7 +257,7 @@ int64_t FuncState::getConstant(const rabbit::Object &cons)
 	return _integer(val);
 }
 
-void FuncState::setIntructionParams(int64_t pos,int64_t arg0,int64_t arg1,int64_t arg2,int64_t arg3)
+void rabbit::FuncState::setIntructionParams(int64_t pos,int64_t arg0,int64_t arg1,int64_t arg2,int64_t arg3)
 {
 	_instructions[pos]._arg0=(unsigned char)*((uint64_t *)&arg0);
 	_instructions[pos]._arg1=(int32_t)*((uint64_t *)&arg1);
@@ -251,7 +265,7 @@ void FuncState::setIntructionParams(int64_t pos,int64_t arg0,int64_t arg1,int64_
 	_instructions[pos]._arg3=(unsigned char)*((uint64_t *)&arg3);
 }
 
-void FuncState::setIntructionParam(int64_t pos,int64_t arg,int64_t val)
+void rabbit::FuncState::setIntructionParam(int64_t pos,int64_t arg,int64_t val)
 {
 	switch(arg){
 		case 0:_instructions[pos]._arg0=(unsigned char)*((uint64_t *)&val);break;
@@ -261,7 +275,7 @@ void FuncState::setIntructionParam(int64_t pos,int64_t arg,int64_t val)
 	};
 }
 
-int64_t FuncState::allocStackPos()
+int64_t rabbit::FuncState::allocStackPos()
 {
 	int64_t npos=_vlocals.size();
 	_vlocals.pushBack(rabbit::LocalVarInfo());
@@ -272,7 +286,7 @@ int64_t FuncState::allocStackPos()
 	return npos;
 }
 
-int64_t FuncState::pushTarget(int64_t n)
+int64_t rabbit::FuncState::pushTarget(int64_t n)
 {
 	if(n!=-1){
 		_targetstack.pushBack(n);
@@ -283,14 +297,14 @@ int64_t FuncState::pushTarget(int64_t n)
 	return n;
 }
 
-int64_t FuncState::getUpTarget(int64_t n){
+int64_t rabbit::FuncState::getUpTarget(int64_t n){
 	return _targetstack[((_targetstack.size()-1)-n)];
 }
 
-int64_t FuncState::topTarget(){
+int64_t rabbit::FuncState::topTarget(){
 	return _targetstack.back();
 }
-int64_t FuncState::popTarget()
+int64_t rabbit::FuncState::popTarget()
 {
 	uint64_t npos=_targetstack.back();
 	assert(npos < _vlocals.size());
@@ -302,12 +316,12 @@ int64_t FuncState::popTarget()
 	return npos;
 }
 
-int64_t FuncState::getStacksize()
+int64_t rabbit::FuncState::getStacksize()
 {
 	return _vlocals.size();
 }
 
-int64_t FuncState::CountOuters(int64_t stacksize)
+int64_t rabbit::FuncState::CountOuters(int64_t stacksize)
 {
 	int64_t outers = 0;
 	int64_t k = _vlocals.size() - 1;
@@ -321,7 +335,7 @@ int64_t FuncState::CountOuters(int64_t stacksize)
 	return outers;
 }
 
-void FuncState::setStacksize(int64_t n)
+void rabbit::FuncState::setStacksize(int64_t n)
 {
 	int64_t size=_vlocals.size();
 	while(size>n){
@@ -338,7 +352,7 @@ void FuncState::setStacksize(int64_t n)
 	}
 }
 
-bool FuncState::isConstant(const rabbit::Object &name,rabbit::Object &e)
+bool rabbit::FuncState::isConstant(const rabbit::Object &name,rabbit::Object &e)
 {
 	rabbit::ObjectPtr val;
 	if(_table(_sharedstate->_consts)->get(name,val)) {
@@ -348,14 +362,14 @@ bool FuncState::isConstant(const rabbit::Object &name,rabbit::Object &e)
 	return false;
 }
 
-bool FuncState::isLocal(uint64_t stkpos)
+bool rabbit::FuncState::isLocal(uint64_t stkpos)
 {
 	if(stkpos>=_vlocals.size())return false;
 	else if(sq_type(_vlocals[stkpos]._name)!=rabbit::OT_NULL)return true;
 	return false;
 }
 
-int64_t FuncState::pushLocalVariable(const rabbit::Object &name)
+int64_t rabbit::FuncState::pushLocalVariable(const rabbit::Object &name)
 {
 	int64_t pos=_vlocals.size();
 	rabbit::LocalVarInfo lvi;
@@ -369,7 +383,7 @@ int64_t FuncState::pushLocalVariable(const rabbit::Object &name)
 
 
 
-int64_t FuncState::getLocalVariable(const rabbit::Object &name)
+int64_t rabbit::FuncState::getLocalVariable(const rabbit::Object &name)
 {
 	int64_t locals=_vlocals.size();
 	while(locals>=1){
@@ -382,14 +396,14 @@ int64_t FuncState::getLocalVariable(const rabbit::Object &name)
 	return -1;
 }
 
-void FuncState::markLocalAsOuter(int64_t pos)
+void rabbit::FuncState::markLocalAsOuter(int64_t pos)
 {
 	rabbit::LocalVarInfo &lvi = _vlocals[pos];
 	lvi._end_op = UINT_MINUS_ONE;
 	_outers++;
 }
 
-int64_t FuncState::getOuterVariable(const rabbit::Object &name)
+int64_t rabbit::FuncState::getOuterVariable(const rabbit::Object &name)
 {
 	int64_t outers = _outervalues.size();
 	for(int64_t i = 0; i<outers; i++) {
@@ -405,25 +419,22 @@ int64_t FuncState::getOuterVariable(const rabbit::Object &name)
 				_outervalues.pushBack(rabbit::OuterVar(name,rabbit::ObjectPtr(int64_t(pos)),otOUTER)); //local
 				return _outervalues.size() - 1;
 			}
-		}
+		} else {
-		else {
 			_parent->markLocalAsOuter(pos);
 			_outervalues.pushBack(rabbit::OuterVar(name,rabbit::ObjectPtr(int64_t(pos)),otLOCAL)); //local
 			return _outervalues.size() - 1;
-
-
 		}
 	}
 	return -1;
 }
 
-void FuncState::addParameter(const rabbit::Object &name)
+void rabbit::FuncState::addParameter(const rabbit::Object &name)
 {
 	pushLocalVariable(name);
 	_parameters.pushBack(name);
 }
 
-void FuncState::addLineInfos(int64_t line,bool lineop,bool force)
+void rabbit::FuncState::addLineInfos(int64_t line,bool lineop,bool force)
 {
 	if(_lastline!=line || force){
 		rabbit::LineInfo li;
@@ -436,7 +447,7 @@ void FuncState::addLineInfos(int64_t line,bool lineop,bool force)
 	}
 }
 
-void FuncState::discardTarget()
+void rabbit::FuncState::discardTarget()
 {
 	int64_t discardedtarget = popTarget();
 	int64_t size = _instructions.size();
@@ -451,7 +462,7 @@ void FuncState::discardTarget()
 	}
 }
 
-void FuncState::addInstruction(rabbit::Instruction &i)
+void rabbit::FuncState::addInstruction(rabbit::Instruction &i)
 {
 	int64_t size = _instructions.size();
 	if(size > 0 && _optimization){ //simple optimizer
@@ -584,23 +595,21 @@ void FuncState::addInstruction(rabbit::Instruction &i)
 	_instructions.pushBack(i);
 }
 
-rabbit::Object FuncState::createString(const rabbit::Char *s,int64_t len)
+rabbit::Object rabbit::FuncState::createString(const rabbit::Char *s,int64_t len)
 {
 	rabbit::ObjectPtr ns(rabbit::String::create(_sharedstate,s,len));
 	_table(_strings)->newSlot(ns,(int64_t)1);
 	return ns;
 }
 
-rabbit::Object FuncState::createTable()
+rabbit::Object rabbit::FuncState::createTable()
 {
 	rabbit::ObjectPtr nt(rabbit::Table::create(_sharedstate,0));
 	_table(_strings)->newSlot(nt,(int64_t)1);
 	return nt;
 }
 
-rabbit::FunctionProto *FuncState::buildProto()
+rabbit::FunctionProto* rabbit::FuncState::buildProto() {
-{
-
 	rabbit::FunctionProto *f=rabbit::FunctionProto::create(_ss,_instructions.size(),
 		_nliterals,_parameters.size(),_functions.size(),_outervalues.size(),
 		_lineinfos.size(),_localvarinfos.size(),_defaultparams.size());
@@ -632,25 +641,22 @@ rabbit::FunctionProto *FuncState::buildProto()
 	return f;
 }
 
-FuncState *rabbit::FuncState::pushChildState(rabbit::SharedState *ss)
+rabbit::FuncState *rabbit::FuncState::pushChildState(rabbit::SharedState *ss)
 {
 	FuncState *child = (rabbit::FuncState *)sq_malloc(sizeof(rabbit::FuncState));
-	new (child) FuncState(ss,this,_errfunc,_errtarget);
+	new ((char*)child) FuncState(ss,this,_errfunc,_errtarget);
 	_childstates.pushBack(child);
 	return child;
 }
 
-void FuncState::popChildState()
+void rabbit::FuncState::popChildState() {
-{
 	FuncState *child = _childstates.back();
-	sq_delete(child,FuncState);
+	sq_delete(child, FuncState);
 	_childstates.popBack();
 }
 
-FuncState::~FuncState()
+rabbit::FuncState::~FuncState() {
-{
+	while(_childstates.size() > 0) {
-	while(_childstates.size() > 0)
-	{
 		popChildState();
 	}
 }

rabbit/FuncState.hpp

@@ -7,6 +7,12 @@
  */
 #pragma once
 
+#include <etk/Vector.hpp>
+#include <rabbit/LocalVarInfo.hpp>
+#include <rabbit/OuterVar.hpp>
+#include <rabbit/LineInfo.hpp>
+#include <rabbit/Instruction.hpp>
+
 namespace rabbit {
 	class FuncState {
 		public:
@@ -18,7 +24,7 @@ namespace rabbit {
 			void error(const rabbit::Char *err);
 			FuncState *pushChildState(rabbit::SharedState *ss);
 			void popChildState();
-			void addInstruction(SQOpcode _op,int64_t arg0=0,int64_t arg1=0,int64_t arg2=0,int64_t arg3=0){rabbit::Instruction i(_op,arg0,arg1,arg2,arg3);addInstruction(i);}
+			void addInstruction(SQOpcode _op,int64_t arg0=0,int64_t arg1=0,int64_t arg2=0,int64_t arg3=0);
 			void addInstruction(rabbit::Instruction &i);
 			void setIntructionParams(int64_t pos,int64_t arg0,int64_t arg1,int64_t arg2=0,int64_t arg3=0);
 			void setIntructionParam(int64_t pos,int64_t arg,int64_t val);

rabbit/FunctionProto.cpp

@@ -6,7 +6,64 @@
  * @license MPL-2 (see license file)
  */
 #include <rabbit/FunctionProto.hpp>
+#include <rabbit/squtils.hpp>
+#include <etk/types.hpp>
+#include <etk/Allocator.hpp>
+#include <rabbit/rabbit.hpp>
+#include <rabbit/squtils.hpp>
+#include <rabbit/Closure.hpp>
 
+#include <rabbit/String.hpp>
+#include <rabbit/VirtualMachine.hpp>
+
+
+
+
+
+rabbit::FunctionProto* rabbit::FunctionProto::create(rabbit::SharedState *ss,int64_t ninstructions,
+	int64_t nliterals,int64_t nparameters,
+	int64_t nfunctions,int64_t noutervalues,
+	int64_t nlineinfos,int64_t nlocalvarinfos,int64_t ndefaultparams)
+{
+	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->_ninstructions = ninstructions;
+	f->_literals = (rabbit::ObjectPtr*)&f->_instructions[ninstructions];
+	f->_nliterals = nliterals;
+	f->_parameters = (rabbit::ObjectPtr*)&f->_literals[nliterals];
+	f->_nparameters = nparameters;
+	f->_functions = (rabbit::ObjectPtr*)&f->_parameters[nparameters];
+	f->_nfunctions = nfunctions;
+	f->_outervalues = (rabbit::OuterVar*)&f->_functions[nfunctions];
+	f->_noutervalues = noutervalues;
+	f->_lineinfos = (rabbit::LineInfo *)&f->_outervalues[noutervalues];
+	f->_nlineinfos = nlineinfos;
+	f->_localvarinfos = (rabbit::LocalVarInfo *)&f->_lineinfos[nlineinfos];
+	f->_nlocalvarinfos = nlocalvarinfos;
+	f->_defaultparams = (int64_t *)&f->_localvarinfos[nlocalvarinfos];
+	f->_ndefaultparams = ndefaultparams;
+
+	_CONSTRUCT_VECTOR(ObjectPtr, f->_nliterals, f->_literals);
+	_CONSTRUCT_VECTOR(ObjectPtr, f->_nparameters, f->_parameters);
+	_CONSTRUCT_VECTOR(ObjectPtr, f->_nfunctions, f->_functions);
+	_CONSTRUCT_VECTOR(OuterVar, f->_noutervalues, f->_outervalues);
+	//_CONSTRUCT_VECTOR(LineInfo, f->_nlineinfos,f->_lineinfos); //not required are 2 integers
+	_CONSTRUCT_VECTOR(LocalVarInfo, f->_nlocalvarinfos, f->_localvarinfos);
+	return f;
+}
+void rabbit::FunctionProto::release(){
+	_DESTRUCT_VECTOR(ObjectPtr,_nliterals,_literals);
+	_DESTRUCT_VECTOR(ObjectPtr,_nparameters,_parameters);
+	_DESTRUCT_VECTOR(ObjectPtr,_nfunctions,_functions);
+	_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);
+}
 
 const rabbit::Char* rabbit::FunctionProto::getLocal(rabbit::VirtualMachine *vm,uint64_t stackbase,uint64_t nseq,uint64_t nop)
 {

rabbit/FunctionProto.hpp

@@ -6,6 +6,13 @@
  * @license MPL-2 (see license file)
  */
 #pragma once
+#include <rabbit/LocalVarInfo.hpp>
+#include <rabbit/LineInfo.hpp>
+#include <rabbit/OuterVar.hpp>
+#include <rabbit/Instruction.hpp>
+#include <rabbit/RefCounted.hpp>
+#include <rabbit/rabbit.hpp>
+
 
 namespace rabbit {
 	
@@ -22,50 +29,11 @@ namespace rabbit {
 			~FunctionProto();
 		
 		public:
-			FunctionProto *create(rabbit::SharedState *ss,int64_t ninstructions,
+			static FunctionProto *create(rabbit::SharedState *ss,int64_t ninstructions,
 				int64_t nliterals,int64_t nparameters,
 				int64_t nfunctions,int64_t noutervalues,
-				int64_t nlineinfos,int64_t nlocalvarinfos,int64_t ndefaultparams)
+				int64_t nlineinfos,int64_t nlocalvarinfos,int64_t ndefaultparams);
-			{
+			void release();
-				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->_ninstructions = ninstructions;
-				f->_literals = (rabbit::ObjectPtr*)&f->_instructions[ninstructions];
-				f->_nliterals = nliterals;
-				f->_parameters = (rabbit::ObjectPtr*)&f->_literals[nliterals];
-				f->_nparameters = nparameters;
-				f->_functions = (rabbit::ObjectPtr*)&f->_parameters[nparameters];
-				f->_nfunctions = nfunctions;
-				f->_outervalues = (rabbit::OuterVar*)&f->_functions[nfunctions];
-				f->_noutervalues = noutervalues;
-				f->_lineinfos = (rabbit::LineInfo *)&f->_outervalues[noutervalues];
-				f->_nlineinfos = nlineinfos;
-				f->_localvarinfos = (rabbit::LocalVarInfo *)&f->_lineinfos[nlineinfos];
-				f->_nlocalvarinfos = nlocalvarinfos;
-				f->_defaultparams = (int64_t *)&f->_localvarinfos[nlocalvarinfos];
-				f->_ndefaultparams = ndefaultparams;
-		
-				_CONSTRUCT_VECTOR(rabbit::ObjectPtr,f->_nliterals,f->_literals);
-				_CONSTRUCT_VECTOR(rabbit::ObjectPtr,f->_nparameters,f->_parameters);
-				_CONSTRUCT_VECTOR(rabbit::ObjectPtr,f->_nfunctions,f->_functions);
-				_CONSTRUCT_VECTOR(rabbit::OuterVar,f->_noutervalues,f->_outervalues);
-				//_CONSTRUCT_VECTOR(rabbit::LineInfo,f->_nlineinfos,f->_lineinfos); //not required are 2 integers
-				_CONSTRUCT_VECTOR(rabbit::LocalVarInfo,f->_nlocalvarinfos,f->_localvarinfos);
-				return f;
-			}
-			void release(){
-				_DESTRUCT_VECTOR(ObjectPtr,_nliterals,_literals);
-				_DESTRUCT_VECTOR(ObjectPtr,_nparameters,_parameters);
-				_DESTRUCT_VECTOR(ObjectPtr,_nfunctions,_functions);
-				_DESTRUCT_VECTOR(rabbit::OuterVar,_noutervalues,_outervalues);
-				//_DESTRUCT_VECTOR(rabbit::LineInfo,_nlineinfos,_lineinfos); //not required are 2 integers
-				_DESTRUCT_VECTOR(rabbit::LocalVarInfo,_nlocalvarinfos,_localvarinfos);
-				int64_t size = _FUNC_SIZE(_ninstructions,_nliterals,_nparameters,_nfunctions,_noutervalues,_nlineinfos,_nlocalvarinfos,_ndefaultparams);
-				this->~FunctionProto();
-				sq_vm_free(this,size);
-			}
 		
 			const rabbit::Char* getLocal(rabbit::VirtualMachine *v,uint64_t stackbase,uint64_t nseq,uint64_t nop);
 			int64_t getLine(rabbit::Instruction *curr);

rabbit/Generator.cpp

@@ -6,6 +6,8 @@
  * @license MPL-2 (see license file)
  */
 #include <rabbit/Generator.hpp>
+#include <rabbit/WeakRef.hpp>
+#include <rabbit/squtils.hpp>
 
 
 
@@ -85,3 +87,30 @@ bool rabbit::Generator::resume(rabbit::VirtualMachine *v,rabbit::ObjectPtr &dest
 
 	return true;
 }
+
+rabbit::Generator::Generator(rabbit::SharedState *ss,rabbit::Closure *closure) {
+	_closure = closure;
+	_state = eRunning;
+	_ci._generator = NULL;
+}
+
+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);
+	return nc;
+}
+
+rabbit::Generator::~Generator() {
+	
+}
+
+void rabbit::Generator::kill() {
+	_state=eDead;
+	_stack.resize(0);
+	_closure.Null();
+}
+
+void rabbit::Generator::release() {
+	sq_delete(this,Generator);
+}
+

rabbit/Generator.hpp

@@ -7,33 +7,26 @@
  */
 #pragma once
 
+#include <rabbit/LocalVarInfo.hpp>
+#include <rabbit/LineInfo.hpp>
+#include <rabbit/OuterVar.hpp>
+#include <rabbit/Instruction.hpp>
+#include <rabbit/RefCounted.hpp>
+#include <rabbit/rabbit.hpp>
+#include <etk/Vector.hpp>
+#include <rabbit/VirtualMachine.hpp>
+
 namespace rabbit {
 	class Generator : public rabbit::RefCounted {
 		public:
-			enum rabbit::GeneratorState{eRunning,eSuspended,eDead};
+			enum GeneratorState{eRunning,eSuspended,eDead};
 		private:
-			Generator(rabbit::SharedState *ss,rabbit::Closure *closure){
+			Generator(rabbit::SharedState *ss,rabbit::Closure *closure);
-				_closure = closure;
-				_state = eRunning;
-				_ci._generator = NULL;
-			}
 		public:
-			static Generator *create(rabbit::SharedState *ss,rabbit::Closure *closure){
+			static Generator *create(rabbit::SharedState *ss,rabbit::Closure *closure);
-				rabbit::Generator *nc=(rabbit::Generator*)SQ_MALLOC(sizeof(rabbit::Generator));
+			~Generator();
-				new ((char*)nc) rabbit::Generator(ss,closure);
+			void kill();
-				return nc;
+			void release();
-			}
-			~Generator()
-			{
-				
-			}
-			void kill(){
-				_state=eDead;
-				_stack.resize(0);
-				_closure.Null();}
-			void release(){
-				sq_delete(this,rabbit::Generator);
-			}
 		
 			bool yield(rabbit::VirtualMachine *v,int64_t target);
 			bool resume(rabbit::VirtualMachine *v,rabbit::ObjectPtr &dest);
@@ -41,7 +34,7 @@ namespace rabbit {
 			etk::Vector<rabbit::ObjectPtr> _stack;
 			rabbit::VirtualMachine::callInfo _ci;
 			etk::Vector<rabbit::ExceptionTrap> _etraps;
-			rabbit::GeneratorState _state;
+			GeneratorState _state;
 	};
 
 }

rabbit/Hash.cpp

@@ -5,8 +5,6 @@
  * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved
  * @license MPL-2 (see license file)
  */
-#pragma once
-
 #include <rabbit/Hash.hpp>
 
 

rabbit/Instance.cpp

@@ -8,6 +8,17 @@
 #include <rabbit/Instance.hpp>
 #include <rabbit/Table.hpp>
 #include <rabbit/SharedState.hpp>
+#include <rabbit/squtils.hpp>
+#include <etk/types.hpp>
+#include <etk/Allocator.hpp>
+#include <rabbit/rabbit.hpp>
+#include <rabbit/squtils.hpp>
+#include <rabbit/Closure.hpp>
+
+#include <rabbit/String.hpp>
+#include <rabbit/Class.hpp>
+#include <rabbit/VirtualMachine.hpp>
+#include <rabbit/WeakRef.hpp>
 
 void rabbit::Instance::init(rabbit::SharedState *ss) {
 	_userpointer = NULL;
@@ -21,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 (&_values[n]) rabbit::ObjectPtr(_class->_defaultvalues[n].val);
+		new ((char*)&_values[n]) rabbit::ObjectPtr(_class->_defaultvalues[n].val);
 	}
 	init(ss);
 }
@@ -31,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 (&_values[n]) rabbit::ObjectPtr(i->_values[n]);
+		new ((char*)&_values[n]) rabbit::ObjectPtr(i->_values[n]);
 	}
 	init(ss);
 }
@@ -70,7 +81,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 (newinst) Instance(ss, theclass,size);
+	new ((char*)newinst) Instance(ss, theclass,size);
 	if(theclass->_udsize) {
 		newinst->_userpointer = ((unsigned char *)newinst) + (size - theclass->_udsize);
 	}
@@ -80,7 +91,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 (newinst) Instance(ss, this,size);
+	new ((char*)newinst) Instance(ss, this,size);
 	if(_class->_udsize) {
 		newinst->_userpointer = ((unsigned char *)newinst) + (size - _class->_udsize);
 	}

rabbit/Instance.hpp

@@ -10,10 +10,13 @@
 #include <etk/types.hpp>
 
 #include <rabbit/VirtualMachine.hpp>
+#include <rabbit/squtils.hpp>
+#include <rabbit/rabbit.hpp>
+#include <rabbit/sqconfig.hpp>
+
+
 
 
-#include <rabbit/sqfuncproto.hpp>
-#include <rabbit/sqclosure.hpp>
 #include <rabbit/MetaMethod.hpp>
 #include <rabbit/Delegable.hpp>
 

rabbit/Instruction.hpp

@@ -6,6 +6,10 @@
  * @license MPL-2 (see license file)
  */
 #pragma once
+#include <rabbit/sqopcodes.hpp>
+#include <rabbit/squtils.hpp>
+#include <rabbit/rabbit.hpp>
+#include <rabbit/sqconfig.hpp>
 
 namespace rabbit {
 	
@@ -15,18 +19,21 @@ namespace rabbit {
 	};
 
 	class Instruction {
-		Instruction(){};
+		public:
-		Instruction(SQOpcode _op,int64_t a0=0,int64_t a1=0,int64_t a2=0,int64_t a3=0) {
+			Instruction(){};
-			op = (unsigned char)_op;
+			Instruction(SQOpcode _op,int64_t a0=0,int64_t a1=0,int64_t a2=0,int64_t a3=0) {
-			_arg0 = (unsigned char)a0;_arg1 = (int32_t)a1;
+				op = (unsigned char)_op;
-			_arg2 = (unsigned char)a2;_arg3 = (unsigned char)a3;
+				_arg0 = (unsigned char)a0;
-		}
+				_arg1 = (int32_t)a1;
+				_arg2 = (unsigned char)a2;
+				_arg3 = (unsigned char)a3;
+			}
 		
-		int32_t _arg1;
+			int32_t _arg1;
-		unsigned char op;
+			unsigned char op;
-		unsigned char _arg0;
+			unsigned char _arg0;
-		unsigned char _arg2;
+			unsigned char _arg2;
-		unsigned char _arg3;
+			unsigned char _arg3;
 	};
 
 }

rabbit/Lexer.cpp

@@ -6,11 +6,11 @@
  * @license MPL-2 (see license file)
  */
 #include <rabbit/Lexer.hpp>
+#include <rabbit/Table.hpp>
+#include <rabbit/String.hpp>
+#include <rabbit/sqconfig.hpp>
 
 
-#include <rabbit/sqcompiler.hpp>
-#include <rabbit/sqlexer.hpp>
-
 #define CUR_CHAR (_currdata)
 #define RETURN_TOKEN(t) { _prevtoken = _curtoken; _curtoken = t; return t;}
 #define IS_EOB() (CUR_CHAR <= RABBIT_EOB)

rabbit/Lexer.hpp

@@ -7,6 +7,12 @@
  */
 #pragma once
 
+#include <etk/Vector.hpp>
+#include <rabbit/squtils.hpp>
+#include <rabbit/rabbit.hpp>
+#include <rabbit/sqconfig.hpp>
+#include <rabbit/Compiler.hpp>
+
 namespace rabbit {
 	
 	#ifdef SQUNICODE

rabbit/LineInfo.hpp

@@ -7,6 +7,8 @@
  */
 #pragma once
 
+#include <etk/types.hpp>
+
 namespace rabbit {
 	class LineInfo {
 		public:

rabbit/LocalVarInfo.hpp

@@ -7,6 +7,12 @@
  */
 #pragma once
 
+#include <etk/types.hpp>
+#include <rabbit/ObjectPtr.hpp>
+#include <rabbit/squtils.hpp>
+#include <rabbit/rabbit.hpp>
+#include <rabbit/sqconfig.hpp>
+
 namespace rabbit {
 	
 	class LocalVarInfo {

rabbit/MemberHandle.hpp

@@ -8,6 +8,8 @@
 #pragma once
 
 #include <etk/types.hpp>
+#include <rabbit/squtils.hpp>
+#include <rabbit/rabbit.hpp>
 #include <rabbit/sqconfig.hpp>
 
 namespace rabbit {

rabbit/MetaMethod.hpp

@@ -8,6 +8,9 @@
 #pragma once
 
 #include <etk/types.hpp>
+#include <rabbit/squtils.hpp>
+#include <rabbit/rabbit.hpp>
+#include <rabbit/sqconfig.hpp>
 
 namespace rabbit {
 	enum MetaMethod {

rabbit/NativeClosure.cpp

@@ -6,4 +6,43 @@
  * @license MPL-2 (see license file)
  */
 #include <rabbit/NativeClosure.hpp>
+#include <etk/Allocator.hpp>
 
+#include <rabbit/WeakRef.hpp>
+
+rabbit::NativeClosure::NativeClosure(rabbit::SharedState *ss,SQFUNCTION func) {
+	_function=func;
+	_env = NULL;
+}
+
+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);
+	nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1);
+	nc->_noutervalues = nouters;
+	_CONSTRUCT_VECTOR(rabbit::ObjectPtr,nc->_noutervalues,nc->_outervalues);
+	return nc;
+}
+
+rabbit::NativeClosure* rabbit::NativeClosure::clone() {
+	rabbit::NativeClosure * ret = rabbit::NativeClosure::create(NULL,_function,_noutervalues);
+	ret->_env = _env;
+	if(ret->_env) __ObjaddRef(ret->_env);
+	ret->_name = _name;
+	_COPY_VECTOR(ret->_outervalues,_outervalues,_noutervalues);
+	ret->_typecheck = _typecheck;
+	ret->_nparamscheck = _nparamscheck;
+	return ret;
+}
+
+rabbit::NativeClosure::~NativeClosure() {
+	__Objrelease(_env);
+}
+
+void rabbit::NativeClosure::release(){
+	int64_t size = _CALC_NATVIVECLOSURE_SIZE(_noutervalues);
+	_DESTRUCT_VECTOR(ObjectPtr,_noutervalues,_outervalues);
+	this->~NativeClosure();
+	sq_free(this,size);
+}

rabbit/NativeClosure.hpp

@@ -8,47 +8,26 @@
 #pragma once
 
 #include <etk/types.hpp>
+#include <etk/Vector.hpp>
+#include <rabbit/RefCounted.hpp>
+#include <rabbit/ObjectPtr.hpp>
+#include <rabbit/squtils.hpp>
+#include <rabbit/rabbit.hpp>
+#include <rabbit/sqconfig.hpp>
 
 namespace rabbit {
+	class ObjectPtr;
+	class SharedState;
+	class WeakRef;
 	#define _CALC_NATVIVECLOSURE_SIZE(noutervalues) (sizeof(rabbit::NativeClosure) + (noutervalues*sizeof(rabbit::ObjectPtr)))
 	class NativeClosure : public rabbit::RefCounted {
 		private:
-			rabbit::NativeClosure(rabbit::SharedState *ss,SQFUNCTION func){
+			NativeClosure(rabbit::SharedState *ss,SQFUNCTION func);
-				_function=func;
-				_env = NULL;
-			}
 		public:
-			static rabbit::NativeClosure *create(rabbit::SharedState *ss,SQFUNCTION func,int64_t nouters)
+			static rabbit::NativeClosure *create(rabbit::SharedState *ss,SQFUNCTION func,int64_t nouters);
-			{
+			rabbit::NativeClosure *clone();
-				int64_t size = _CALC_NATVIVECLOSURE_SIZE(nouters);
+			~NativeClosure();
-				rabbit::NativeClosure *nc=(rabbit::NativeClosure*)SQ_MALLOC(size);
+			void release();
-				new (nc) rabbit::NativeClosure(ss,func);
-				nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1);
-				nc->_noutervalues = nouters;
-				_CONSTRUCT_VECTOR(rabbit::ObjectPtr,nc->_noutervalues,nc->_outervalues);
-				return nc;
-			}
-			rabbit::NativeClosure *clone()
-			{
-				rabbit::NativeClosure * ret = rabbit::NativeClosure::create(NULL,_function,_noutervalues);
-				ret->_env = _env;
-				if(ret->_env) __ObjaddRef(ret->_env);
-				ret->_name = _name;
-				_COPY_VECTOR(ret->_outervalues,_outervalues,_noutervalues);
-				ret->_typecheck = _typecheck;
-				ret->_nparamscheck = _nparamscheck;
-				return ret;
-			}
-			~NativeClosure()
-			{
-				__Objrelease(_env);
-			}
-			void release(){
-				int64_t size = _CALC_NATVIVECLOSURE_SIZE(_noutervalues);
-				_DESTRUCT_VECTOR(ObjectPtr,_noutervalues,_outervalues);
-				this->~NativeClosure();
-				sq_free(this,size);
-			}
 		
 			int64_t _nparamscheck;
 			etk::Vector<int64_t> _typecheck;

rabbit/Outer.cpp

@@ -6,4 +6,26 @@
  * @license MPL-2 (see license file)
  */
 #include <rabbit/Outer.hpp>
+#include <etk/Allocator.hpp>
+#include <rabbit/squtils.hpp>
 
+
+rabbit::Outer::Outer(rabbit::SharedState *ss, rabbit::ObjectPtr *outer){
+	_valptr = outer;
+	_next = NULL;
+}
+
+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);
+	return nc;
+}
+
+rabbit::Outer::~Outer() {
+	
+}
+
+void rabbit::Outer::release() {
+	this->~Outer();
+	sq_vm_free(this,sizeof(rabbit::Outer));
+}

rabbit/Outer.hpp

@@ -7,31 +7,24 @@
  */
 #pragma once
 
+#include <etk/types.hpp>
+#include <rabbit/RefCounted.hpp>
+#include <rabbit/ObjectPtr.hpp>
+
+
 namespace rabbit {
+	class SharedState;
 	class Outer : public rabbit::RefCounted {
 		private:
-			rabbit::Outer(rabbit::SharedState *ss, rabbit::ObjectPtr *outer){
+			Outer(rabbit::SharedState *ss, rabbit::ObjectPtr *outer);
-				_valptr = outer;
-				_next = NULL;
-			}
 		public:
-			static rabbit::Outer *create(rabbit::SharedState *ss, rabbit::ObjectPtr *outer) {
+			static rabbit::Outer *create(rabbit::SharedState *ss, rabbit::ObjectPtr *outer);
-				rabbit::Outer *nc  = (rabbit::Outer*)SQ_MALLOC(sizeof(rabbit::Outer));
+			~Outer();
-				new (nc) rabbit::Outer(ss, outer);
+			void release();
-				return nc;
+			rabbit::ObjectPtr *_valptr; /* pointer to value on stack, or _value below */
-			}
+			int64_t	_idx; /* idx in stack array, for relocation */
-			~Outer() {
+			rabbit::ObjectPtr _value; /* value of outer after stack frame is closed */
-				
+			rabbit::Outer *_next; /* pointer to next outer when frame is open */
-			}
-			void release()
-			{
-				this->~Outer();
-				sq_vm_free(this,sizeof(rabbit::Outer));
-			}
-			rabbit::ObjectPtr *_valptr;  /* pointer to value on stack, or _value below */
-			int64_t	_idx;	 /* idx in stack array, for relocation */
-			rabbit::ObjectPtr  _value;   /* value of outer after stack frame is closed */
-			rabbit::Outer	 *_next;	/* pointer to next outer when frame is open   */
 	};
 
 }

rabbit/OuterVar.hpp

@@ -7,6 +7,10 @@
  */
 #pragma once
 
+#include <etk/types.hpp>
+#include <rabbit/RefCounted.hpp>
+#include <rabbit/ObjectPtr.hpp>
+
 namespace rabbit {
 	enum OuterType {
 		otLOCAL = 0,

rabbit/RefTable.cpp

@@ -9,6 +9,7 @@
 #include <rabbit/Table.hpp>
 
 #include <rabbit/squtils.hpp>
+#include <etk/Allocator.hpp>
 
 rabbit::RefTable::RefTable()
 {

rabbit/SharedState.cpp

@@ -8,7 +8,10 @@
 #include <rabbit/SharedState.hpp>
 #include <rabbit/Table.hpp>
 #include <rabbit/String.hpp>
+#include <rabbit/StringTable.hpp>
 #include <rabbit/RegFunction.hpp>
+#include <rabbit/NativeClosure.hpp>
+#include <rabbit/VirtualMachine.hpp>
 
 static rabbit::Table *createDefaultDelegate(rabbit::SharedState *ss,const rabbit::RegFunction *funcz)
 {
@@ -18,7 +21,7 @@ static rabbit::Table *createDefaultDelegate(rabbit::SharedState *ss,const rabbit
 		rabbit::NativeClosure *nc = rabbit::NativeClosure::create(ss,funcz[i].f,0);
 		nc->_nparamscheck = funcz[i].nparamscheck;
 		nc->_name = rabbit::String::create(ss,funcz[i].name);
-		if(funcz[i].typemask && !compileTypemask(nc->_typecheck,funcz[i].typemask))
+		if(funcz[i].typemask && !rabbit::compileTypemask(nc->_typecheck,funcz[i].typemask))
 			return NULL;
 		t->newSlot(rabbit::String::create(ss,funcz[i].name),nc);
 		i++;
@@ -95,7 +98,7 @@ void rabbit::SharedState::init()
 	_scratchpad=NULL;
 	_scratchpadsize=0;
 	_stringtable = (rabbit::StringTable*)SQ_MALLOC(sizeof(rabbit::StringTable));
-	new (_stringtable) rabbit::StringTable(this);
+	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>);
@@ -186,7 +189,7 @@ rabbit::SharedState::~SharedState()
 	sq_delete(_types, tmpType);
 	sq_delete(_systemstrings, tmpType);
 	sq_delete(_metamethods, tmpType);
-	sq_delete(_stringtable, rabbit::StringTable);
+	sq_delete(_stringtable, StringTable);
 	if(_scratchpad)SQ_FREE(_scratchpad,_scratchpadsize);
 }
 

rabbit/String.cpp

@@ -5,12 +5,13 @@
  * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved
  * @license MPL-2 (see license file)
  */
-#pragma once
-
 #include <rabbit/String.hpp>
+#include <rabbit/SharedState.hpp>
+#include <rabbit/ObjectPtr.hpp>
+#include <rabbit/StringTable.hpp>
 
 
-rabbit::Hash rabbit::_hashstr(const rabbit::Char *s, size_t l); {
+rabbit::Hash rabbit::_hashstr(const rabbit::Char *s, size_t l) {
 	rabbit::Hash h = (rabbit::Hash)l;  /* seed */
 	size_t step = (l>>5)|1;  /* if string is too long, don't hash all its chars */
 	for (; l>=step; l-=step)

rabbit/String.hpp

@@ -8,22 +8,29 @@
 #pragma once
 
 #include <etk/types.hpp>
+#include <rabbit/Hash.hpp>
+#include <rabbit/RefCounted.hpp>
+#include <rabbit/sqconfig.hpp>
 
 namespace rabbit {
+	class SharedState;
+	class ObjectPtr;
 	
 	rabbit::Hash _hashstr (const rabbit::Char *s, size_t l);
+	
 	class String : public rabbit::RefCounted {
-		String(){}
+		public:
-		~String(){}
+			String(){}
-	public:
+			~String(){}
-		static rabbit::String *create(rabbit::SharedState *ss, const rabbit::Char *, int64_t len = -1 );
+		public:
-		int64_t next(const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval);
+			static rabbit::String *create(rabbit::SharedState *ss, const rabbit::Char *, int64_t len = -1 );
-		void release();
+			int64_t next(const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval);
-		rabbit::SharedState *_sharedstate;
+			void release();
-		rabbit::String *_next; //chain for the string table
+			rabbit::SharedState *_sharedstate;
-		int64_t _len;
+			rabbit::String *_next; //chain for the string table
-		rabbit::Hash _hash;
+			int64_t _len;
-		rabbit::Char _val[1];
+			rabbit::Hash _hash;
+			rabbit::Char _val[1];
 	};
 
 

rabbit/StringTable.cpp

@@ -5,9 +5,11 @@
  * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved
  * @license MPL-2 (see license file)
  */
-#pragma once
-
 #include <rabbit/StringTable.hpp>
+#include <rabbit/SharedState.hpp>
+#include <rabbit/ObjectPtr.hpp>
+#include <rabbit/StringTable.hpp>
+#include <rabbit/squtils.hpp>
 
 
 
@@ -36,7 +38,7 @@ rabbit::String *rabbit::StringTable::add(const rabbit::Char *news,int64_t len)
 {
 	if(len<0)
 		len = (int64_t)scstrlen(news);
-	rabbit::Hash newhash = ::_hashstr(news,len);
+	rabbit::Hash newhash = _hashstr(news,len);
 	rabbit::Hash h = newhash&(_numofslots-1);
 	rabbit::String *s;
 	for (s = _strings[h]; s; s = s->_next){
@@ -45,7 +47,7 @@ rabbit::String *rabbit::StringTable::add(const rabbit::Char *news,int64_t len)
 	}
 
 	rabbit::String *t = (rabbit::String *)SQ_MALLOC(sq_rsl(len)+sizeof(rabbit::String));
-	new (t) rabbit::String;
+	new ((char*)t) rabbit::String;
 	t->_sharedstate = _sharedstate;
 	memcpy(t->_val,news,sq_rsl(len));
 	t->_val[len] = _SC('\0');

rabbit/StringTable.hpp

@@ -8,6 +8,7 @@
 #pragma once
 
 #include <etk/types.hpp>
+#include <rabbit/String.hpp>
 
 namespace rabbit {
 	

rabbit/Table.cpp

@@ -5,11 +5,12 @@
  * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved
  * @license MPL-2 (see license file)
  */
-#pragma once
-
 #include <rabbit/Table.hpp>
+#include <rabbit/String.hpp>
+#include <rabbit/WeakRef.hpp>
+#include <etk/Allocator.hpp>
 
-rabbit::Hash rabbit::HashObj(const rabbit::ObjectPtr &key); {
+rabbit::Hash rabbit::HashObj(const rabbit::ObjectPtr &key) {
 	switch(sq_type(key)) {
 		case rabbit::OT_STRING:
 			return _string(key)->_hash;
@@ -26,7 +27,7 @@ rabbit::Hash rabbit::HashObj(const rabbit::ObjectPtr &key); {
 
 #define MINPOWER2 4
 
-rabbit::Table::rabbit::Table(rabbit::SharedState *ss,int64_t ninitialsize) {
+rabbit::Table::Table(rabbit::SharedState *ss,int64_t ninitialsize) {
 	int64_t pow2size=MINPOWER2;
 	while(ninitialsize>pow2size)pow2size=pow2size<<1;
 	allocNodes(pow2size);
@@ -49,7 +50,7 @@ void rabbit::Table::allocNodes(int64_t nsize)
 	_HashNode *nodes=(_HashNode *)SQ_MALLOC(sizeof(_HashNode)*nsize);
 	for(int64_t i=0;i<nsize;i++){
 		_HashNode &n = nodes[i];
-		new (&n) _HashNode;
+		new ((char*)&n) _HashNode;
 		n.next=NULL;
 	}
 	_numofnodes=nsize;
@@ -249,7 +250,7 @@ rabbit::Table::~Table() {
 	SQ_FREE(_nodes, _numofnodes * sizeof(_HashNode));
 }
 
-_HashNode* rabbit::Table::_get(const rabbit::ObjectPtr &key,rabbit::Hash hash) {
+rabbit::Table::_HashNode* rabbit::Table::_get(const rabbit::ObjectPtr &key,rabbit::Hash hash) {
 	_HashNode *n = &_nodes[hash];
 	do {
 		if(    _rawval(n->key) == _rawval(key)
@@ -283,5 +284,5 @@ int64_t rabbit::Table::countUsed() {
 }
 
 void rabbit::Table::release() {
-	sq_delete(this, rabbit::Table);
+	sq_delete(this, Table);
 }

rabbit/UserData.cpp

@@ -0,0 +1,54 @@
+/**
+ * @author Alberto DEMICHELIS
+ * @author Edouard DUPIN
+ * @copyright 2018, Edouard DUPIN, all right reserved
+ * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved
+ * @license MPL-2 (see license file)
+ */
+#include <rabbit/UserData.hpp>
+#include <etk/Allocator.hpp>
+
+rabbit::UserData::UserData(rabbit::SharedState *ss) {
+	_delegate = 0;
+	m_hook = NULL;
+}
+rabbit::UserData::~UserData() {
+	setDelegate(NULL);
+}
+
+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);
+	ud->m_size = size;
+	ud->m_typetag = 0;
+	return ud;
+}
+
+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);
+}
+
+const int64_t& rabbit::UserData::getsize() const {
+	return m_size;
+}
+
+const rabbit::UserPointer& rabbit::UserData::getTypeTag() const {
+	return m_typetag;
+}
+
+void rabbit::UserData::setTypeTag(const rabbit::UserPointer& _value) {
+	m_typetag = _value;
+}
+
+const SQRELEASEHOOK& rabbit::UserData::getHook() const {
+	return m_hook;
+}
+
+void rabbit::UserData::setHook(const SQRELEASEHOOK& _value) {
+	m_hook = _value;
+}

rabbit/UserData.hpp

@@ -6,47 +6,21 @@
  * @license MPL-2 (see license file)
  */
 #pragma once
+#include <etk/types.hpp>
+#include <rabbit/Delegable.hpp>
 
 namespace rabbit {
 	class UserData : public rabbit::Delegable {
 		public:
-			UserData(rabbit::SharedState *ss) {
+			UserData(rabbit::SharedState *ss);
-				_delegate = 0;
+			~UserData();
-				m_hook = NULL;
+			static UserData* create(rabbit::SharedState *ss, int64_t size);
-			}
+			void release();
-			~UserData() {
+			const int64_t& getsize() const;
-				setDelegate(NULL);
+			const rabbit::UserPointer& getTypeTag() const;
-			}
+			void setTypeTag(const rabbit::UserPointer& _value);
-			static UserData* create(rabbit::SharedState *ss, int64_t size) {
+			const SQRELEASEHOOK& getHook() const;
-				UserData* ud = (UserData*)SQ_MALLOC(sq_aligning(sizeof(UserData))+size);
+			void setHook(const SQRELEASEHOOK& _value);
-				new (ud) UserData(ss);
-				ud->m_size = size;
-				ud->m_typetag = 0;
-				return ud;
-			}
-			void 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);
-			}
-			const int64_t& getsize() const {
-				return m_size;
-			}
-			const rabbit::UserPointer& getTypeTag() const {
-				return m_typetag;
-			}
-			void setTypeTag(const rabbit::UserPointer& _value) {
-				m_typetag = _value;
-			}
-			const SQRELEASEHOOK& getHook() const {
-				return m_hook;
-			}
-			void setHook(const SQRELEASEHOOK& _value) {
-				m_hook = _value;
-			}
 		protected:
 			int64_t m_size;
 			SQRELEASEHOOK m_hook;

rabbit/VirtualMachine.cpp

@@ -10,13 +10,24 @@
 #include <stdlib.h>
 #include <rabbit/sqopcodes.hpp>
 #include <rabbit/VirtualMachine.hpp>
-#include <rabbit/sqfuncproto.hpp>
+
-#include <rabbit/sqclosure.hpp>
+
+#include <rabbit/squtils.hpp>
 
 
 #include <rabbit/UserData.hpp>
 #include <rabbit/Array.hpp>
 #include <rabbit/Instance.hpp>
+#include <rabbit/Closure.hpp>
+#include <rabbit/String.hpp>
+#include <rabbit/Table.hpp>
+#include <rabbit/Generator.hpp>
+#include <rabbit/Class.hpp>
+#include <rabbit/FunctionProto.hpp>
+#include <rabbit/NativeClosure.hpp>
+#include <rabbit/WeakRef.hpp>
+#include <rabbit/SharedState.hpp>
+#include <rabbit/Outer.hpp>
 
 
 #define TOP() (_stack[_top-1])
@@ -44,6 +55,10 @@ bool rabbit::VirtualMachine::BW_OP(uint64_t op,rabbit::ObjectPtr &trg,const rabb
 	return true;
 }
 
+void rabbit::VirtualMachine::release() {
+	sq_delete(this,VirtualMachine);
+}
+
 #define _ARITH_(op,trg,o1,o2) \
 { \
 	int64_t tmask = sq_type(o1)|sq_type(o2); \
@@ -76,12 +91,12 @@ bool rabbit::VirtualMachine::ARITH_OP(uint64_t op,rabbit::ObjectPtr &trg,const r
 			case '+': res = i1 + i2; break;
 			case '-': res = i1 - i2; break;
 			case '/': if (i2 == 0) { raise_error(_SC("division by zero")); return false; }
-					else if (i2 == -1 && i1 == INT_MIN) { raise_error(_SC("integer overflow")); return false; }
+					else if (i2 == -1 && i1 == INT64_MIN) { raise_error(_SC("integer overflow")); return false; }
 					res = i1 / i2;
 					break;
 			case '*': res = i1 * i2; break;
 			case '%': if (i2 == 0) { raise_error(_SC("modulo by zero")); return false; }
-					else if (i2 == -1 && i1 == INT_MIN) { res = 0; break; }
+					else if (i2 == -1 && i1 == INT64_MAX) { res = 0; break; }
 					res = i1 % i2;
 					break;
 			default: res = 0xDEADBEEF;

rabbit/VirtualMachine.hpp

@@ -36,8 +36,7 @@ void sq_base_register(rabbit::VirtualMachine* v);
 #define _INLINE
 
 namespace rabbit {
-	class VirtualMachine : public rabbit::RefCounted
+	class VirtualMachine : public rabbit::RefCounted {
-	{
 		public:
 			struct callInfo{
 				rabbit::Instruction *_ip;
@@ -51,7 +50,6 @@ namespace rabbit {
 				int32_t _ncalls;
 				rabbit::Bool _root;
 			};
-	
 		public:
 			void DebugHookProxy(int64_t type, const rabbit::Char * sourcename, int64_t line, const rabbit::Char * funcname);
 			static void _DebugHookProxy(rabbit::VirtualMachine* v, int64_t type, const rabbit::Char * sourcename, int64_t line, const rabbit::Char * funcname);
@@ -132,10 +130,7 @@ namespace rabbit {
 			}
 			bool enterFrame(int64_t newbase, int64_t newtop, bool tailcall);
 			void leaveFrame();
-			void release() {
+			void release();
-				sq_delete(this,VirtualMachine);
-			}
-		////////////////////////////////////////////////////////////////////////////
 			//stack functions for the api
 			void remove(int64_t n);
 		

rabbit/rabbit.hpp

@@ -11,10 +11,6 @@
 #include _SQ_CONFIG_INCLUDE
 #endif
 
-#ifndef RABBIT_API
-#define RABBIT_API extern
-#endif
-
 #if (defined(_WIN64) || defined(_LP64))
 #ifndef _SQ64
 #define _SQ64
@@ -56,175 +52,178 @@ typedef int64_t (*SQREADFUNC)(rabbit::UserPointer,rabbit::UserPointer,int64_t);
 
 typedef int64_t (*SQLEXREADFUNC)(rabbit::UserPointer);
 
+namespace rabbit {
 /*vm*/
-RABBIT_API rabbit::VirtualMachine* sq_open(int64_t initialstacksize);
+rabbit::VirtualMachine* sq_open(int64_t initialstacksize);
-RABBIT_API rabbit::VirtualMachine* sq_newthread(rabbit::VirtualMachine* friendvm, int64_t initialstacksize);
+rabbit::VirtualMachine* sq_newthread(rabbit::VirtualMachine* friendvm, int64_t initialstacksize);
-RABBIT_API void sq_seterrorhandler(rabbit::VirtualMachine* v);
+void sq_seterrorhandler(rabbit::VirtualMachine* v);
-RABBIT_API void sq_close(rabbit::VirtualMachine* v);
+void sq_close(rabbit::VirtualMachine* v);
-RABBIT_API void sq_setforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p);
+void sq_setforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p);
-RABBIT_API rabbit::UserPointer sq_getforeignptr(rabbit::VirtualMachine* v);
+rabbit::UserPointer sq_getforeignptr(rabbit::VirtualMachine* v);
-RABBIT_API void sq_setsharedforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p);
+void sq_setsharedforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p);
-RABBIT_API rabbit::UserPointer sq_getsharedforeignptr(rabbit::VirtualMachine* v);
+rabbit::UserPointer sq_getsharedforeignptr(rabbit::VirtualMachine* v);
-RABBIT_API void sq_setvmreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook);
+void sq_setvmreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook);
-RABBIT_API SQRELEASEHOOK sq_getvmreleasehook(rabbit::VirtualMachine* v);
+SQRELEASEHOOK sq_getvmreleasehook(rabbit::VirtualMachine* v);
-RABBIT_API void sq_setsharedreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook);
+void sq_setsharedreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook);
-RABBIT_API SQRELEASEHOOK sq_getsharedreleasehook(rabbit::VirtualMachine* v);
+SQRELEASEHOOK sq_getsharedreleasehook(rabbit::VirtualMachine* v);
-RABBIT_API void sq_setprintfunc(rabbit::VirtualMachine* v, SQPRINTFUNCTION printfunc,SQPRINTFUNCTION errfunc);
+void sq_setprintfunc(rabbit::VirtualMachine* v, SQPRINTFUNCTION printfunc,SQPRINTFUNCTION errfunc);
-RABBIT_API SQPRINTFUNCTION sq_getprintfunc(rabbit::VirtualMachine* v);
+SQPRINTFUNCTION sq_getprintfunc(rabbit::VirtualMachine* v);
-RABBIT_API SQPRINTFUNCTION sq_geterrorfunc(rabbit::VirtualMachine* v);
+SQPRINTFUNCTION sq_geterrorfunc(rabbit::VirtualMachine* v);
-RABBIT_API rabbit::Result sq_suspendvm(rabbit::VirtualMachine* v);
+rabbit::Result sq_suspendvm(rabbit::VirtualMachine* v);
-RABBIT_API rabbit::Result sq_wakeupvm(rabbit::VirtualMachine* v,rabbit::Bool resumedret,rabbit::Bool retval,rabbit::Bool raiseerror,rabbit::Bool throwerror);
+rabbit::Result sq_wakeupvm(rabbit::VirtualMachine* v,rabbit::Bool resumedret,rabbit::Bool retval,rabbit::Bool raiseerror,rabbit::Bool throwerror);
-RABBIT_API int64_t sq_getvmstate(rabbit::VirtualMachine* v);
+int64_t sq_getvmstate(rabbit::VirtualMachine* v);
-RABBIT_API int64_t sq_getversion();
+int64_t sq_getversion();
 
 /*compiler*/
-RABBIT_API rabbit::Result sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::UserPointer p,const rabbit::Char *sourcename,rabbit::Bool raiseerror);
+rabbit::Result sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::UserPointer p,const rabbit::Char *sourcename,rabbit::Bool raiseerror);
-RABBIT_API rabbit::Result sq_compilebuffer(rabbit::VirtualMachine* v,const rabbit::Char *s,int64_t size,const rabbit::Char *sourcename,rabbit::Bool raiseerror);
+rabbit::Result sq_compilebuffer(rabbit::VirtualMachine* v,const rabbit::Char *s,int64_t size,const rabbit::Char *sourcename,rabbit::Bool raiseerror);
-RABBIT_API void sq_enabledebuginfo(rabbit::VirtualMachine* v, rabbit::Bool enable);
+void sq_enabledebuginfo(rabbit::VirtualMachine* v, rabbit::Bool enable);
-RABBIT_API void sq_notifyallexceptions(rabbit::VirtualMachine* v, rabbit::Bool enable);
+void sq_notifyallexceptions(rabbit::VirtualMachine* v, rabbit::Bool enable);
-RABBIT_API void sq_setcompilererrorhandler(rabbit::VirtualMachine* v,SQCOMPILERERROR f);
+void sq_setcompilererrorhandler(rabbit::VirtualMachine* v,SQCOMPILERERROR f);
 
 /*stack operations*/
-RABBIT_API void sq_push(rabbit::VirtualMachine* v,int64_t idx);
+void sq_push(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API void sq_pop(rabbit::VirtualMachine* v,int64_t nelemstopop);
+void sq_pop(rabbit::VirtualMachine* v,int64_t nelemstopop);
-RABBIT_API void sq_poptop(rabbit::VirtualMachine* v);
+void sq_poptop(rabbit::VirtualMachine* v);
-RABBIT_API void sq_remove(rabbit::VirtualMachine* v,int64_t idx);
+void sq_remove(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API int64_t sq_gettop(rabbit::VirtualMachine* v);
+int64_t sq_gettop(rabbit::VirtualMachine* v);
-RABBIT_API void sq_settop(rabbit::VirtualMachine* v,int64_t newtop);
+void sq_settop(rabbit::VirtualMachine* v,int64_t newtop);
-RABBIT_API rabbit::Result sq_reservestack(rabbit::VirtualMachine* v,int64_t nsize);
+rabbit::Result sq_reservestack(rabbit::VirtualMachine* v,int64_t nsize);
-RABBIT_API int64_t sq_cmp(rabbit::VirtualMachine* v);
+int64_t sq_cmp(rabbit::VirtualMachine* v);
-RABBIT_API void sq_move(rabbit::VirtualMachine* dest,rabbit::VirtualMachine* src,int64_t idx);
+void sq_move(rabbit::VirtualMachine* dest,rabbit::VirtualMachine* src,int64_t idx);
 
 /*object creation handling*/
-RABBIT_API rabbit::UserPointer sq_newuserdata(rabbit::VirtualMachine* v,uint64_t size);
+rabbit::UserPointer sq_newuserdata(rabbit::VirtualMachine* v,uint64_t size);
-RABBIT_API void sq_newtable(rabbit::VirtualMachine* v);
+void sq_newtable(rabbit::VirtualMachine* v);
-RABBIT_API void sq_newtableex(rabbit::VirtualMachine* v,int64_t initialcapacity);
+void sq_newtableex(rabbit::VirtualMachine* v,int64_t initialcapacity);
-RABBIT_API void sq_newarray(rabbit::VirtualMachine* v,int64_t size);
+void sq_newarray(rabbit::VirtualMachine* v,int64_t size);
-RABBIT_API void sq_newclosure(rabbit::VirtualMachine* v,SQFUNCTION func,uint64_t nfreevars);
+void sq_newclosure(rabbit::VirtualMachine* v,SQFUNCTION func,uint64_t nfreevars);
-RABBIT_API rabbit::Result sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const rabbit::Char *typemask);
+rabbit::Result sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const rabbit::Char *typemask);
-RABBIT_API rabbit::Result sq_bindenv(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_bindenv(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_getclosureroot(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_getclosureroot(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API void sq_pushstring(rabbit::VirtualMachine* v,const rabbit::Char *s,int64_t len);
+void sq_pushstring(rabbit::VirtualMachine* v,const rabbit::Char *s,int64_t len);
-RABBIT_API void sq_pushfloat(rabbit::VirtualMachine* v,float_t f);
+void sq_pushfloat(rabbit::VirtualMachine* v,float_t f);
-RABBIT_API void sq_pushinteger(rabbit::VirtualMachine* v,int64_t n);
+void sq_pushinteger(rabbit::VirtualMachine* v,int64_t n);
-RABBIT_API void sq_pushbool(rabbit::VirtualMachine* v,rabbit::Bool b);
+void sq_pushbool(rabbit::VirtualMachine* v,rabbit::Bool b);
-RABBIT_API void sq_pushuserpointer(rabbit::VirtualMachine* v,rabbit::UserPointer p);
+void sq_pushuserpointer(rabbit::VirtualMachine* v,rabbit::UserPointer p);
-RABBIT_API void sq_pushnull(rabbit::VirtualMachine* v);
+void sq_pushnull(rabbit::VirtualMachine* v);
-RABBIT_API void sq_pushthread(rabbit::VirtualMachine* v, rabbit::VirtualMachine* thread);
+void sq_pushthread(rabbit::VirtualMachine* v, rabbit::VirtualMachine* thread);
-RABBIT_API rabbit::ObjectType sq_gettype(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::ObjectType sq_gettype(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_typeof(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_typeof(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API int64_t sq_getsize(rabbit::VirtualMachine* v,int64_t idx);
+int64_t sq_getsize(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Hash sq_gethash(rabbit::VirtualMachine* v, int64_t idx);
+rabbit::Hash sq_gethash(rabbit::VirtualMachine* v, int64_t idx);
-RABBIT_API rabbit::Result sq_getbase(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_getbase(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Bool sq_instanceof(rabbit::VirtualMachine* v);
+rabbit::Bool sq_instanceof(rabbit::VirtualMachine* v);
-RABBIT_API rabbit::Result sq_tostring(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_tostring(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API void sq_tobool(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool *b);
+void sq_tobool(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool *b);
-RABBIT_API rabbit::Result sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c,int64_t *size);
+rabbit::Result sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c,int64_t *size);
-RABBIT_API rabbit::Result sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c);
+rabbit::Result sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c);
-RABBIT_API rabbit::Result sq_getinteger(rabbit::VirtualMachine* v,int64_t idx,int64_t *i);
+rabbit::Result sq_getinteger(rabbit::VirtualMachine* v,int64_t idx,int64_t *i);
-RABBIT_API rabbit::Result sq_getfloat(rabbit::VirtualMachine* v,int64_t idx,float_t *f);
+rabbit::Result sq_getfloat(rabbit::VirtualMachine* v,int64_t idx,float_t *f);
-RABBIT_API rabbit::Result sq_getbool(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool *b);
+rabbit::Result sq_getbool(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool *b);
-RABBIT_API rabbit::Result sq_getthread(rabbit::VirtualMachine* v,int64_t idx,rabbit::VirtualMachine* *thread);
+rabbit::Result sq_getthread(rabbit::VirtualMachine* v,int64_t idx,rabbit::VirtualMachine* *thread);
-RABBIT_API rabbit::Result sq_getuserpointer(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *p);
+rabbit::Result sq_getuserpointer(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *p);
-RABBIT_API rabbit::Result sq_getuserdata(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *p,rabbit::UserPointer *typetag);
+rabbit::Result sq_getuserdata(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *p,rabbit::UserPointer *typetag);
-RABBIT_API rabbit::Result sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer typetag);
+rabbit::Result sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer typetag);
-RABBIT_API rabbit::Result sq_gettypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *typetag);
+rabbit::Result sq_gettypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *typetag);
-RABBIT_API void sq_setreleasehook(rabbit::VirtualMachine* v,int64_t idx,SQRELEASEHOOK hook);
+void sq_setreleasehook(rabbit::VirtualMachine* v,int64_t idx,SQRELEASEHOOK hook);
-RABBIT_API SQRELEASEHOOK sq_getreleasehook(rabbit::VirtualMachine* v,int64_t idx);
+SQRELEASEHOOK sq_getreleasehook(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Char *sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize);
+rabbit::Char *sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize);
-RABBIT_API rabbit::Result sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,rabbit::FunctionInfo *fi);
+rabbit::Result sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,rabbit::FunctionInfo *fi);
-RABBIT_API rabbit::Result sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,uint64_t *nparams,uint64_t *nfreevars);
+rabbit::Result sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,uint64_t *nparams,uint64_t *nfreevars);
-RABBIT_API rabbit::Result sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char *name);
+rabbit::Result sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char *name);
-RABBIT_API rabbit::Result sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer p);
+rabbit::Result sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer p);
-RABBIT_API rabbit::Result sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p,rabbit::UserPointer typetag);
+rabbit::Result sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p,rabbit::UserPointer typetag);
-RABBIT_API rabbit::Result sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize);
+rabbit::Result sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize);
-RABBIT_API rabbit::Result sq_newclass(rabbit::VirtualMachine* v,rabbit::Bool hasbase);
+rabbit::Result sq_newclass(rabbit::VirtualMachine* v,rabbit::Bool hasbase);
-RABBIT_API rabbit::Result sq_createinstance(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_createinstance(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_setattributes(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_setattributes(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_getattributes(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_getattributes(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_getclass(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_getclass(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API void sq_weakref(rabbit::VirtualMachine* v,int64_t idx);
+void sq_weakref(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_getdefaultdelegate(rabbit::VirtualMachine* v,rabbit::ObjectType t);
+rabbit::Result sq_getdefaultdelegate(rabbit::VirtualMachine* v,rabbit::ObjectType t);
-RABBIT_API rabbit::Result sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,rabbit::MemberHandle *handle);
+rabbit::Result sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,rabbit::MemberHandle *handle);
-RABBIT_API rabbit::Result sq_getbyhandle(rabbit::VirtualMachine* v,int64_t idx,const rabbit::MemberHandle *handle);
+rabbit::Result sq_getbyhandle(rabbit::VirtualMachine* v,int64_t idx,const rabbit::MemberHandle *handle);
-RABBIT_API rabbit::Result sq_setbyhandle(rabbit::VirtualMachine* v,int64_t idx,const rabbit::MemberHandle *handle);
+rabbit::Result sq_setbyhandle(rabbit::VirtualMachine* v,int64_t idx,const rabbit::MemberHandle *handle);
 
 /*object manipulation*/
-RABBIT_API void sq_pushroottable(rabbit::VirtualMachine* v);
+void sq_pushroottable(rabbit::VirtualMachine* v);
-RABBIT_API void sq_pushregistrytable(rabbit::VirtualMachine* v);
+void sq_pushregistrytable(rabbit::VirtualMachine* v);
-RABBIT_API void sq_pushconsttable(rabbit::VirtualMachine* v);
+void sq_pushconsttable(rabbit::VirtualMachine* v);
-RABBIT_API rabbit::Result sq_setroottable(rabbit::VirtualMachine* v);
+rabbit::Result sq_setroottable(rabbit::VirtualMachine* v);
-RABBIT_API rabbit::Result sq_setconsttable(rabbit::VirtualMachine* v);
+rabbit::Result sq_setconsttable(rabbit::VirtualMachine* v);
-RABBIT_API rabbit::Result sq_newslot(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool bstatic);
+rabbit::Result sq_newslot(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool bstatic);
-RABBIT_API rabbit::Result sq_deleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval);
+rabbit::Result sq_deleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval);
-RABBIT_API rabbit::Result sq_set(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_set(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_get(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_get(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_rawget(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_rawget(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_rawset(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_rawset(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_rawdeleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval);
+rabbit::Result sq_rawdeleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval);
-RABBIT_API rabbit::Result sq_newmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic);
+rabbit::Result sq_newmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic);
-RABBIT_API rabbit::Result sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic);
+rabbit::Result sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic);
-RABBIT_API rabbit::Result sq_arrayappend(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_arrayappend(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval);
+rabbit::Result sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval);
-RABBIT_API rabbit::Result sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t newsize);
+rabbit::Result sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t newsize);
-RABBIT_API rabbit::Result sq_arrayreverse(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_arrayreverse(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_arrayremove(rabbit::VirtualMachine* v,int64_t idx,int64_t itemidx);
+rabbit::Result sq_arrayremove(rabbit::VirtualMachine* v,int64_t idx,int64_t itemidx);
-RABBIT_API rabbit::Result sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int64_t destpos);
+rabbit::Result sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int64_t destpos);
-RABBIT_API rabbit::Result sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_clone(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_clone(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval);
+rabbit::Result sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval);
-RABBIT_API rabbit::Result sq_next(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_next(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_getweakrefval(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_getweakrefval(rabbit::VirtualMachine* v,int64_t idx);
-RABBIT_API rabbit::Result sq_clear(rabbit::VirtualMachine* v,int64_t idx);
+rabbit::Result sq_clear(rabbit::VirtualMachine* v,int64_t idx);
 
 /*calls*/
-RABBIT_API rabbit::Result sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::Bool retval,rabbit::Bool raiseerror);
+rabbit::Result sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::Bool retval,rabbit::Bool raiseerror);
-RABBIT_API rabbit::Result sq_resume(rabbit::VirtualMachine* v,rabbit::Bool retval,rabbit::Bool raiseerror);
+rabbit::Result sq_resume(rabbit::VirtualMachine* v,rabbit::Bool retval,rabbit::Bool raiseerror);
-RABBIT_API const rabbit::Char *sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx);
+const rabbit::Char *sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx);
-RABBIT_API rabbit::Result sq_getcallee(rabbit::VirtualMachine* v);
+rabbit::Result sq_getcallee(rabbit::VirtualMachine* v);
-RABBIT_API const rabbit::Char *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval);
+const rabbit::Char *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval);
-RABBIT_API rabbit::Result sq_throwerror(rabbit::VirtualMachine* v,const rabbit::Char *err);
+rabbit::Result sq_throwerror(rabbit::VirtualMachine* v,const rabbit::Char *err);
-RABBIT_API rabbit::Result sq_throwobject(rabbit::VirtualMachine* v);
+rabbit::Result sq_throwobject(rabbit::VirtualMachine* v);
-RABBIT_API void sq_reseterror(rabbit::VirtualMachine* v);
+void sq_reseterror(rabbit::VirtualMachine* v);
-RABBIT_API void sq_getlasterror(rabbit::VirtualMachine* v);
+void sq_getlasterror(rabbit::VirtualMachine* v);
-RABBIT_API rabbit::Result sq_tailcall(rabbit::VirtualMachine* v, int64_t nparams);
+rabbit::Result sq_tailcall(rabbit::VirtualMachine* v, int64_t nparams);
 
 /*raw object handling*/
-RABBIT_API rabbit::Result sq_getstackobj(rabbit::VirtualMachine* v,int64_t idx,rabbit::Object *po);
+rabbit::Result sq_getstackobj(rabbit::VirtualMachine* v,int64_t idx,rabbit::Object *po);
-RABBIT_API void sq_pushobject(rabbit::VirtualMachine* v,rabbit::Object obj);
+void sq_pushobject(rabbit::VirtualMachine* v,rabbit::Object obj);
-RABBIT_API void sq_addref(rabbit::VirtualMachine* v,rabbit::Object *po);
+void sq_addref(rabbit::VirtualMachine* v,rabbit::Object *po);
-RABBIT_API rabbit::Bool sq_release(rabbit::VirtualMachine* v,rabbit::Object *po);
+rabbit::Bool sq_release(rabbit::VirtualMachine* v,rabbit::Object *po);
-RABBIT_API uint64_t sq_getrefcount(rabbit::VirtualMachine* v,rabbit::Object *po);
+uint64_t sq_getrefcount(rabbit::VirtualMachine* v,rabbit::Object *po);
-RABBIT_API void sq_resetobject(rabbit::Object *po);
+void sq_resetobject(rabbit::Object *po);
-RABBIT_API const rabbit::Char *sq_objtostring(const rabbit::Object *o);
+const rabbit::Char *sq_objtostring(const rabbit::Object *o);
-RABBIT_API rabbit::Bool sq_objtobool(const rabbit::Object *o);
+rabbit::Bool sq_objtobool(const rabbit::Object *o);
-RABBIT_API int64_t sq_objtointeger(const rabbit::Object *o);
+int64_t sq_objtointeger(const rabbit::Object *o);
-RABBIT_API float_t sq_objtofloat(const rabbit::Object *o);
+float_t sq_objtofloat(const rabbit::Object *o);
-RABBIT_API rabbit::UserPointer sq_objtouserpointer(const rabbit::Object *o);
+rabbit::UserPointer sq_objtouserpointer(const rabbit::Object *o);
-RABBIT_API rabbit::Result sq_getobjtypetag(const rabbit::Object *o,rabbit::UserPointer * typetag);
+rabbit::Result sq_getobjtypetag(const rabbit::Object *o,rabbit::UserPointer * typetag);
-RABBIT_API uint64_t sq_getvmrefcount(rabbit::VirtualMachine* v, const rabbit::Object *po);
+uint64_t sq_getvmrefcount(rabbit::VirtualMachine* v, const rabbit::Object *po);
 
 
 /*GC*/
-RABBIT_API int64_t sq_collectgarbage(rabbit::VirtualMachine* v);
+int64_t sq_collectgarbage(rabbit::VirtualMachine* v);
-RABBIT_API rabbit::Result sq_resurrectunreachable(rabbit::VirtualMachine* v);
+rabbit::Result sq_resurrectunreachable(rabbit::VirtualMachine* v);
 
 /*serialization*/
-RABBIT_API rabbit::Result sq_writeclosure(rabbit::VirtualMachine* vm,SQWRITEFUNC writef,rabbit::UserPointer up);
+rabbit::Result sq_writeclosure(rabbit::VirtualMachine* vm,SQWRITEFUNC writef,rabbit::UserPointer up);
-RABBIT_API rabbit::Result sq_readclosure(rabbit::VirtualMachine* vm,SQREADFUNC readf,rabbit::UserPointer up);
+rabbit::Result sq_readclosure(rabbit::VirtualMachine* vm,SQREADFUNC readf,rabbit::UserPointer up);
 
 /*mem allocation*/
-RABBIT_API void *sq_malloc(uint64_t size);
+void *sq_malloc(uint64_t size);
-RABBIT_API void *sq_realloc(void* p,uint64_t oldsize,uint64_t newsize);
+void *sq_realloc(void* p,uint64_t oldsize,uint64_t newsize);
-RABBIT_API void sq_free(void *p,uint64_t size);
+void sq_free(void *p,uint64_t size);
 
 /*debug*/
-RABBIT_API rabbit::Result sq_stackinfos(rabbit::VirtualMachine* v,int64_t level,rabbit::StackInfos *si);
+rabbit::Result sq_stackinfos(rabbit::VirtualMachine* v,int64_t level,rabbit::StackInfos *si);
-RABBIT_API void sq_setdebughook(rabbit::VirtualMachine* v);
+void sq_setdebughook(rabbit::VirtualMachine* v);
-RABBIT_API void sq_setnativedebughook(rabbit::VirtualMachine* v,SQDEBUGHOOK hook);
+void sq_setnativedebughook(rabbit::VirtualMachine* v,SQDEBUGHOOK hook);
+
+}
 
 /* deprecated */
 #define sq_createslot(v,n) sq_newslot(v,n,SQFalse)

rabbit/sqbaselib.cpp

@@ -10,8 +10,16 @@
 
 
 #include <rabbit/Array.hpp>
-#include <rabbit/sqfuncproto.hpp>
+#include <rabbit/SharedState.hpp>
-#include <rabbit/sqclosure.hpp>
+
+#include <rabbit/String.hpp>
+#include <rabbit/Table.hpp>
+#include <rabbit/Closure.hpp>
+#include <rabbit/RegFunction.hpp>
+#include <rabbit/NativeClosure.hpp>
+#include <rabbit/FunctionProto.hpp>
+#include <rabbit/Generator.hpp>
+
 
 #include <stdlib.h>
 #include <stdarg.h>

rabbit/sqconfig.hpp

@@ -8,7 +8,7 @@
 #pragma once
 
 #include <etk/types.hpp>
-
+#include <ctype.h>
 #ifdef SQUSEDOUBLE
 typedef double float_t;
 #else

rabbit/sqdebug.cpp

@@ -9,13 +9,20 @@
 
 #include <stdarg.h>
 #include <rabbit/VirtualMachine.hpp>
-#include <rabbit/sqfuncproto.hpp>
-#include <rabbit/sqclosure.hpp>
 
+
+#include <rabbit/String.hpp>
+#include <rabbit/Table.hpp>
+#include <rabbit/Closure.hpp>
+#include <rabbit/RegFunction.hpp>
+#include <rabbit/NativeClosure.hpp>
+#include <rabbit/FunctionProto.hpp>
+#include <rabbit/Generator.hpp>
+#include <rabbit/SharedState.hpp>
 #include <rabbit/FunctionInfo.hpp>
 #include <rabbit/StackInfos.hpp>
 
-rabbit::Result sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,rabbit::FunctionInfo *fi)
+rabbit::Result rabbit::sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,rabbit::FunctionInfo *fi)
 {
 	int64_t cssize = v->_callsstacksize;
 	if (cssize > level) {
@@ -33,7 +40,7 @@ rabbit::Result sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,rabbit
 	return sq_throwerror(v,_SC("the object is not a closure"));
 }
 
-rabbit::Result sq_stackinfos(rabbit::VirtualMachine* v, int64_t level, rabbit::StackInfos *si)
+rabbit::Result rabbit::sq_stackinfos(rabbit::VirtualMachine* v, int64_t level, rabbit::StackInfos *si)
 {
 	int64_t cssize = v->_callsstacksize;
 	if (cssize > level) {

rabbit/sqmem.cpp

@@ -6,12 +6,13 @@
  * @license MPL-2 (see license file)
  */
 
+#include <etk/types.hpp>
 
 
 #ifndef SQ_EXCLUDE_DEFAULT_MEMFUNCTIONS
 void *sq_vm_malloc(uint64_t size){ return malloc(size); }
 
-void *sq_vm_realloc(void *p, uint64_t SQ_UNUSED_ARG(oldsize), uint64_t size){ return realloc(p, size); }
+void *sq_vm_realloc(void *p, uint64_t oldsize, uint64_t size){ return realloc(p, size); }
 
-void sq_vm_free(void *p, uint64_t SQ_UNUSED_ARG(size)){ free(p); }
+void sq_vm_free(void *p, uint64_t size){ free(p); }
 #endif

rabbit/squtils.hpp

@@ -6,6 +6,7 @@
  * @license MPL-2 (see license file)
  */
 #pragma once
+#include <etk/types.hpp>
 
 void *sq_vm_malloc(uint64_t size);
 void *sq_vm_realloc(void *p,uint64_t oldsize,uint64_t size);
@@ -24,7 +25,7 @@ void sq_vm_free(void *p,uint64_t size);
 
 #define _CONSTRUCT_VECTOR(type, size, ptr) { \
 	for(int64_t n = 0; n < ((int64_t)size); n++) { \
-			new (&ptr[n]) type(); \
+			new ((char*)&ptr[n]) type(); \
 		} \
 }