From ad27afec61dd80f9ee67e1a0c7c46da71d76947a Mon Sep 17 00:00:00 2001 From: Edouard DUPIN Date: Sun, 1 Jul 2018 15:49:34 +0200 Subject: [PATCH] [DEV] continue rework: buid and work again --- cmdLine/rabbit.cpp | 22 +- etc/minimal.cpp | 6 +- lutin_rabbit-core.py | 1 + rabbit-std/sqstdaux.cpp | 60 ++- rabbit-std/sqstdaux.hpp | 9 +- rabbit-std/sqstdblob.cpp | 150 +++--- rabbit-std/sqstdblob.hpp | 14 +- rabbit-std/sqstdblobimpl.hpp | 10 +- rabbit-std/sqstdio.cpp | 243 ++++----- rabbit-std/sqstdio.hpp | 34 +- rabbit-std/sqstdmath.cpp | 2 +- rabbit-std/sqstdmath.hpp | 7 +- rabbit-std/sqstdrex.cpp | 990 ++++++++++++++++++----------------- rabbit-std/sqstdstream.cpp | 14 +- rabbit-std/sqstdstream.hpp | 30 +- rabbit-std/sqstdstring.cpp | 39 +- rabbit-std/sqstdstring.hpp | 42 +- rabbit-std/sqstdsystem.cpp | 2 +- rabbit-std/sqstdsystem.hpp | 6 +- rabbit/Array.cpp | 118 +++++ rabbit/Array.hpp | 132 +---- rabbit/Class.cpp | 6 +- rabbit/Class.hpp | 4 +- rabbit/Closure.cpp | 33 +- rabbit/Closure.hpp | 9 +- rabbit/Compiler.cpp | 26 +- rabbit/Compiler.hpp | 4 + rabbit/FuncState.cpp | 102 ++-- rabbit/FuncState.hpp | 8 +- rabbit/FunctionProto.cpp | 57 ++ rabbit/FunctionProto.hpp | 52 +- rabbit/Generator.cpp | 29 + rabbit/Generator.hpp | 39 +- rabbit/Hash.cpp | 2 - rabbit/Instance.cpp | 19 +- rabbit/Instance.hpp | 7 +- rabbit/Instruction.hpp | 31 +- rabbit/Lexer.cpp | 6 +- rabbit/Lexer.hpp | 6 + rabbit/LineInfo.hpp | 2 + rabbit/LocalVarInfo.hpp | 6 + rabbit/MemberHandle.hpp | 2 + rabbit/MetaMethod.hpp | 3 + rabbit/NativeClosure.cpp | 39 ++ rabbit/NativeClosure.hpp | 49 +- rabbit/Outer.cpp | 22 + rabbit/Outer.hpp | 35 +- rabbit/OuterVar.hpp | 4 + rabbit/RefTable.cpp | 1 + rabbit/SharedState.cpp | 9 +- rabbit/String.cpp | 7 +- rabbit/String.hpp | 29 +- rabbit/StringTable.cpp | 10 +- rabbit/StringTable.hpp | 1 + rabbit/Table.cpp | 15 +- rabbit/UserData.cpp | 54 ++ rabbit/UserData.hpp | 48 +- rabbit/VirtualMachine.cpp | 23 +- rabbit/VirtualMachine.hpp | 9 +- rabbit/rabbit.hpp | 301 ++++++----- rabbit/sqapi.cpp | 352 +++++++------ rabbit/sqbaselib.cpp | 12 +- rabbit/sqconfig.hpp | 2 +- rabbit/sqdebug.cpp | 15 +- rabbit/sqmem.cpp | 5 +- rabbit/squtils.hpp | 3 +- 66 files changed, 1883 insertions(+), 1546 deletions(-) create mode 100644 rabbit/UserData.cpp diff --git a/cmdLine/rabbit.cpp b/cmdLine/rabbit.cpp index 96bf569..6608570 100644 --- a/cmdLine/rabbit.cpp +++ b/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 #include -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:{ - rabbit::Bool bval; - sq_getbool(v,-1,&bval); - pf(v,_SC("[%s] %s\n"),name,bval == SQTrue ? _SC("true"):_SC("false")); - } + case rabbit::OT_BOOL: + { + rabbit::Bool bval; + 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) -{ - SQPRINTFUNCTION pf = sq_geterrorfunc(v); - if(pf) { - const rabbit::Char *sErr = 0; - if(sq_gettop(v)>=1) { - if(SQ_SUCCEEDED(sq_getstring(v,2,&sErr))) { - pf(v,_SC("\nAN ERROR HAS OCCURRED [%s]\n"),sErr); +namespace rabbit { + namespace std { + static int64_t aux_printerror(rabbit::VirtualMachine* v) { + SQPRINTFUNCTION pf = sq_geterrorfunc(v); + if(pf) { + const rabbit::Char *sErr = 0; + if(sq_gettop(v)>=1) { + 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{ - pf(v,_SC("\nAN ERROR HAS OCCURRED [unknown]\n")); + return 0; + } + + 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_newclosure(v,_sqstd_aux_printerror,0); + sq_setcompilererrorhandler(v,rabbit::std::compiler_error); + sq_newclosure(v,rabbit::std::aux_printerror,0); sq_seterrorhandler(v); } diff --git a/rabbit-std/sqstdaux.hpp b/rabbit-std/sqstdaux.hpp index 7fe86bc..55fe1ad 100644 --- a/rabbit-std/sqstdaux.hpp +++ b/rabbit-std/sqstdaux.hpp @@ -7,5 +7,10 @@ */ #pragma once -RABBIT_API void sqstd_seterrorhandlers(rabbit::VirtualMachine* v); -RABBIT_API void sqstd_printcallstack(rabbit::VirtualMachine* v); +namespace rabbit { + namespace std { + void seterrorhandlers(rabbit::VirtualMachine* v); + void printcallstack(rabbit::VirtualMachine* v); + } +} + diff --git a/rabbit-std/sqstdblob.cpp b/rabbit-std/sqstdblob.cpp index 51ce17f..903b16c 100644 --- a/rabbit-std/sqstdblob.cpp +++ b/rabbit-std/sqstdblob.cpp @@ -13,20 +13,20 @@ #define SETUP_BLOB(v) \ - SQBlob *self = NULL; \ - { if(SQ_FAILED(sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) \ - return sq_throwerror(v,_SC("invalid type tag")); } \ + rabbit::std::Blob *self = NULL; \ + { if(SQ_FAILED(rabbit::sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)SQSTD_BLOB_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); - sq_getinteger(v,3,&val); + rabbit::sq_getinteger(v,2,&idx); + 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); - return sq_throwobject(v); + rabbit::sq_pushnull(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")); - sq_pushinteger(v,((unsigned char *)self->getBuf())[idx]); + return rabbit::sq_throwerror(v,_SC("index out of range")); + 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) { - sq_pushinteger(v, 0); + if(rabbit::sq_gettype(v,2) == rabbit::OT_NULL) { + 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; - self->~SQBlob(); - sq_free(self,sizeof(SQBlob)); + rabbit::std::Blob *self = (rabbit::std::Blob*)p; + self->~Blob(); + 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")); - //SQBlob *b = new SQBlob(size); + if(size < 0) return rabbit::sq_throwerror(v, _SC("cannot create blob with negative size")); + //rabbit::std::Blob *b = new rabbit::std::Blob(size); - SQBlob *b = new (sq_malloc(sizeof(SQBlob)))SQBlob(size); - if(SQ_FAILED(sq_setinstanceup(v,1,b))) { - b->~SQBlob(); - sq_free(b,sizeof(SQBlob)); - return sq_throwerror(v, _SC("cannot create blob")); + rabbit::std::Blob *b = new (rabbit::sq_malloc(sizeof(rabbit::std::Blob)))rabbit::std::Blob(size); + if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,b))) { + b->~Blob(); + rabbit::sq_free(b,sizeof(rabbit::std::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()); - SQBlob *thisone = new (sq_malloc(sizeof(SQBlob)))SQBlob(other->Len()); + //rabbit::std::Blob *thisone = new rabbit::std::Blob(other->Len()); + rabbit::std::Blob *thisone = new (rabbit::sq_malloc(sizeof(rabbit::std::Blob)))rabbit::std::Blob(other->Len()); memcpy(thisone->getBuf(),other->getBuf(),thisone->Len()); - if(SQ_FAILED(sq_setinstanceup(v,1,thisone))) { - thisone->~SQBlob(); - sq_free(thisone,sizeof(SQBlob)); - return sq_throwerror(v, _SC("cannot clone blob")); + if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,thisone))) { + thisone->~Blob(); + rabbit::sq_free(thisone,sizeof(rabbit::std::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); - sq_pushfloat(v,*((const float_t *)&i)); + rabbit::sq_getinteger(v,2,&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); - sq_pushinteger(v,*((const int64_t *)&f)); + rabbit::sq_getfloat(v,2,&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; - if(SQ_FAILED(sq_getinstanceup(v,idx,(rabbit::UserPointer *)&blob,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) + rabbit::std::Blob *blob; + 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; - if(SQ_FAILED(sq_getinstanceup(v,idx,(rabbit::UserPointer *)&blob,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) + rabbit::std::Blob *blob; + 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); - sq_pushregistrytable(v); - sq_pushstring(v,_SC("std_blob"),-1); - if(SQ_SUCCEEDED(sq_get(v,-2))) { - sq_remove(v,-2); //removes the registry - sq_push(v,1); // push the this - sq_pushinteger(v,size); //size - SQBlob *blob = NULL; - if(SQ_SUCCEEDED(sq_call(v,2,SQTrue,SQFalse)) - && SQ_SUCCEEDED(sq_getinstanceup(v,-1,(rabbit::UserPointer *)&blob,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) { - sq_remove(v,-2); + int64_t top = rabbit::sq_gettop(v); + rabbit::sq_pushregistrytable(v); + rabbit::sq_pushstring(v,_SC("std_blob"),-1); + if(SQ_SUCCEEDED(rabbit::sq_get(v,-2))) { + rabbit::sq_remove(v,-2); //removes the registry + rabbit::sq_push(v,1); // push the this + rabbit::sq_pushinteger(v,size); //size + rabbit::std::Blob *blob = NULL; + if(SQ_SUCCEEDED(rabbit::sq_call(v,2,SQTrue,SQFalse)) + && SQ_SUCCEEDED(rabbit::sq_getinstanceup(v,-1,(rabbit::UserPointer *)&blob,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) { + 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); } diff --git a/rabbit-std/sqstdblob.hpp b/rabbit-std/sqstdblob.hpp index 7265f5e..2fc3d96 100644 --- a/rabbit-std/sqstdblob.hpp +++ b/rabbit-std/sqstdblob.hpp @@ -7,9 +7,13 @@ */ #pragma once -RABBIT_API rabbit::UserPointer sqstd_createblob(rabbit::VirtualMachine* v, int64_t size); -RABBIT_API rabbit::Result sqstd_getblob(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *ptr); -RABBIT_API int64_t sqstd_getblobsize(rabbit::VirtualMachine* v,int64_t idx); - -RABBIT_API rabbit::Result sqstd_register_bloblib(rabbit::VirtualMachine* v); +namespace rabbit { + namespace std { + 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::Result register_bloblib(rabbit::VirtualMachine* v); + } +} diff --git a/rabbit-std/sqstdblobimpl.hpp b/rabbit-std/sqstdblobimpl.hpp index f3826d9..5025abc 100644 --- a/rabbit-std/sqstdblobimpl.hpp +++ b/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; }; + } +} diff --git a/rabbit-std/sqstdio.cpp b/rabbit-std/sqstdio.cpp index 41f38e6..b52f64f 100644 --- a/rabbit-std/sqstdio.cpp +++ b/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 -struct SQFile : public SQStream { - SQFile() { _handle = NULL; _owns = false;} - SQFile(SQFILE file, bool owns) { _handle = file; _owns = owns;} - virtual ~SQFile() { close(); } - bool Open(const rabbit::Char *filename ,const rabbit::Char *mode) { - close(); - if( (_handle = sqstd_fopen(filename,mode)) ) { - _owns = true; - return true; - } - return false; + namespace std { + //File + struct File : public rabbit::std::SQStream { + File() { _handle = NULL; _owns = false;} + File(SQFILE file, bool owns) { _handle = file; _owns = owns;} + virtual ~File() { close(); } + bool Open(const rabbit::Char *filename ,const rabbit::Char *mode) { + close(); + if( (_handle = rabbit::std::fopen(filename,mode)) ) { + _owns = true; + return true; + } + 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; - self->~SQFile(); - sq_free(self,sizeof(SQFile)); + rabbit::std::File *self = (rabbit::std::File*)p; + self->~File(); + 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; - SQFILE newf; - if(sq_gettype(v,2) == rabbit::OT_STRING && sq_gettype(v,3) == rabbit::OT_STRING) { - sq_getstring(v, 2, &filename); - sq_getstring(v, 3, &mode); - newf = sqstd_fopen(filename, mode); - if(!newf) return sq_throwerror(v, _SC("cannot open file")); - } else if(sq_gettype(v,2) == rabbit::OT_USERPOINTER) { - owns = !(sq_gettype(v,3) == rabbit::OT_NULL); - sq_getuserpointer(v,2,&newf); + rabbit::std::File *f; + rabbit::std::SQFILE newf; + if(rabbit::sq_gettype(v,2) == rabbit::OT_STRING && sq_gettype(v,3) == rabbit::OT_STRING) { + rabbit::sq_getstring(v, 2, &filename); + rabbit::sq_getstring(v, 3, &mode); + newf = rabbit::std::fopen(filename, mode); + if(!newf) return rabbit::sq_throwerror(v, _SC("cannot open file")); + } else if(rabbit::sq_gettype(v,2) == rabbit::OT_USERPOINTER) { + owns = !(rabbit::sq_gettype(v,3) == rabbit::OT_NULL); + 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); - if(SQ_FAILED(sq_setinstanceup(v,1,f))) { - f->~SQFile(); - sq_free(f,sizeof(SQFile)); - return sq_throwerror(v, _SC("cannot create blob with negative size")); + f = new (rabbit::sq_malloc(sizeof(rabbit::std::File)))rabbit::std::File(newf,owns); + if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,f))) { + f->~File(); + rabbit::sq_free(f,sizeof(rabbit::std::File)); + return rabbit::sq_throwerror(v, _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; - if(SQ_SUCCEEDED(sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)SQSTD_FILE_TYPE_TAG)) + rabbit::std::File *self = NULL; + 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) { - sqstd_fclose(file); + if(rabbit::std::fread(&uc,1,sizeof(uc),file) == 0) { + 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; diff --git a/rabbit-std/sqstdio.hpp b/rabbit-std/sqstdio.hpp index 9d5a51c..c4b3ea7 100644 --- a/rabbit-std/sqstdio.hpp +++ b/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 *); -RABBIT_API int64_t sqstd_fread(rabbit::UserPointer, int64_t, int64_t, SQFILE); -RABBIT_API int64_t sqstd_fwrite(const rabbit::UserPointer, int64_t, int64_t, SQFILE); -RABBIT_API int64_t sqstd_fseek(SQFILE , int64_t , int64_t); -RABBIT_API int64_t sqstd_ftell(SQFILE); -RABBIT_API int64_t sqstd_fflush(SQFILE); -RABBIT_API int64_t sqstd_fclose(SQFILE); -RABBIT_API int64_t sqstd_feof(SQFILE); +SQFILE fopen(const rabbit::Char *,const rabbit::Char *); +int64_t fread(rabbit::UserPointer, int64_t, int64_t, SQFILE); +int64_t fwrite(const rabbit::UserPointer, int64_t, int64_t, SQFILE); +int64_t fseek(SQFILE , int64_t , int64_t); +int64_t ftell(SQFILE); +int64_t fflush(SQFILE); +int64_t fclose(SQFILE); +int64_t feof(SQFILE); -RABBIT_API rabbit::Result sqstd_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 createfile(rabbit::VirtualMachine* v, SQFILE file,rabbit::Bool own); +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_API rabbit::Result sqstd_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 loadfile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool printerror); +rabbit::Result dofile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool retval,rabbit::Bool printerror); +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); + } +} diff --git a/rabbit-std/sqstdmath.cpp b/rabbit-std/sqstdmath.cpp index 5225054..0075920 100644 --- a/rabbit-std/sqstdmath.cpp +++ b/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) { diff --git a/rabbit-std/sqstdmath.hpp b/rabbit-std/sqstdmath.hpp index 79cbc2c..372c6d0 100644 --- a/rabbit-std/sqstdmath.hpp +++ b/rabbit-std/sqstdmath.hpp @@ -10,5 +10,8 @@ #include #include -RABBIT_API rabbit::Result sqstd_register_mathlib(rabbit::VirtualMachine* v); - +namespace rabbit { + namespace std { + rabbit::Result register_mathlib(rabbit::VirtualMachine* v); + } +} diff --git a/rabbit-std/sqstdrex.cpp b/rabbit-std/sqstdrex.cpp index 667e76a..d1be2f1 100644 --- a/rabbit-std/sqstdrex.cpp +++ b/rabbit-std/sqstdrex.cpp @@ -49,516 +49,520 @@ static const rabbit::Char *g_nnames[] = #define SQREX_SYMBOL_BEGINNING_OF_STRING ('^') #define SQREX_SYMBOL_ESCAPE_CHAR ('\\') +namespace rabbit { -typedef int SQRexNodeType; +namespace std { -typedef struct tagSQRexNode{ - SQRexNodeType type; - int64_t left; - int64_t right; - int64_t next; -}SQRexNode; - -struct SQRex{ - const rabbit::Char *_eol; - const rabbit::Char *_bol; - const rabbit::Char *_p; - int64_t _first; - int64_t _op; - SQRexNode *_nodes; - int64_t _nallocated; - int64_t _nsize; - int64_t _nsubexpr; - SQRexMatch *_matches; - int64_t _currsubexp; - void *_jmpbuf; - const rabbit::Char **_error; -}; - -static int64_t sqstd_rex_list(SQRex *exp); - -static int64_t sqstd_rex_newnode(SQRex *exp, SQRexNodeType type) -{ - SQRexNode n; - n.type = type; - n.next = n.right = n.left = -1; - if(type == OP_EXPR) - n.right = exp->_nsubexpr++; - if(exp->_nallocated < (exp->_nsize + 1)) { - int64_t oldsize = exp->_nallocated; - exp->_nallocated *= 2; - exp->_nodes = (SQRexNode *)sq_realloc(exp->_nodes, oldsize * sizeof(SQRexNode) ,exp->_nallocated * sizeof(SQRexNode)); - } - exp->_nodes[exp->_nsize++] = n; - int64_t newid = exp->_nsize - 1; - return (int64_t)newid; -} - -static void sqstd_rex_error(SQRex *exp,const rabbit::Char *error) -{ - if(exp->_error) *exp->_error = error; - longjmp(*((jmp_buf*)exp->_jmpbuf),-1); -} - -static void sqstd_rex_expect(SQRex *exp, int64_t n){ - if((*exp->_p) != n) - sqstd_rex_error(exp, _SC("expected paren")); - exp->_p++; -} - -static rabbit::Char sqstd_rex_escapechar(SQRex *exp) -{ - if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR){ - exp->_p++; - switch(*exp->_p) { - case 'v': exp->_p++; return '\v'; - case 'n': exp->_p++; return '\n'; - case 't': exp->_p++; return '\t'; - case 'r': exp->_p++; return '\r'; - case 'f': exp->_p++; return '\f'; - default: return (*exp->_p++); + typedef int SQRexNodeType; + + typedef struct tagSQRexNode{ + SQRexNodeType type; + int64_t left; + int64_t right; + int64_t next; + }SQRexNode; + + struct SQRex{ + const rabbit::Char *_eol; + const rabbit::Char *_bol; + const rabbit::Char *_p; + int64_t _first; + int64_t _op; + SQRexNode *_nodes; + int64_t _nallocated; + int64_t _nsize; + int64_t _nsubexpr; + rabbit::std::SQRexMatch *_matches; + int64_t _currsubexp; + void *_jmpbuf; + const rabbit::Char **_error; + }; + + static int64_t rex_list(SQRex *exp); + + static int64_t rex_newnode(SQRex *exp, SQRexNodeType type) + { + SQRexNode n; + n.type = type; + n.next = n.right = n.left = -1; + if(type == OP_EXPR) + n.right = exp->_nsubexpr++; + if(exp->_nallocated < (exp->_nsize + 1)) { + int64_t oldsize = exp->_nallocated; + exp->_nallocated *= 2; + exp->_nodes = (SQRexNode *)sq_realloc(exp->_nodes, oldsize * sizeof(SQRexNode) ,exp->_nallocated * sizeof(SQRexNode)); + } + exp->_nodes[exp->_nsize++] = n; + int64_t newid = exp->_nsize - 1; + return (int64_t)newid; } - } else if(!scisprint(*exp->_p)) sqstd_rex_error(exp,_SC("letter expected")); - return (*exp->_p++); -} - -static int64_t sqstd_rex_charclass(SQRex *exp,int64_t classid) -{ - int64_t n = sqstd_rex_newnode(exp,OP_CCLASS); - exp->_nodes[n].left = classid; - return n; -} - -static int64_t sqstd_rex_charnode(SQRex *exp,rabbit::Bool isclass) -{ - rabbit::Char t; - if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR) { - exp->_p++; - switch(*exp->_p) { - case 'n': exp->_p++; return sqstd_rex_newnode(exp,'\n'); - case 't': exp->_p++; return sqstd_rex_newnode(exp,'\t'); - case 'r': exp->_p++; return sqstd_rex_newnode(exp,'\r'); - case 'f': exp->_p++; return sqstd_rex_newnode(exp,'\f'); - case 'v': exp->_p++; return sqstd_rex_newnode(exp,'\v'); - case 'a': case 'A': case 'w': case 'W': case 's': case 'S': - case 'd': case 'D': case 'x': case 'X': case 'c': case 'C': - case 'p': case 'P': case 'l': case 'u': - { - t = *exp->_p; exp->_p++; - return sqstd_rex_charclass(exp,t); + + static void rex_error(SQRex *exp,const rabbit::Char *error) + { + if(exp->_error) *exp->_error = error; + longjmp(*((jmp_buf*)exp->_jmpbuf),-1); + } + + static void rex_expect(SQRex *exp, int64_t n){ + if((*exp->_p) != n) + rabbit::std::rex_error(exp, _SC("expected paren")); + exp->_p++; + } + + static rabbit::Char rex_escapechar(SQRex *exp) + { + if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR){ + exp->_p++; + switch(*exp->_p) { + case 'v': exp->_p++; return '\v'; + case 'n': exp->_p++; return '\n'; + case 't': exp->_p++; return '\t'; + case 'r': exp->_p++; return '\r'; + case 'f': exp->_p++; return '\f'; + default: return (*exp->_p++); } - case 'm': - { - rabbit::Char cb, ce; //cb = character begin match ce = character end match - cb = *++exp->_p; //skip 'm' - ce = *++exp->_p; - exp->_p++; //points to the next char to be parsed - if ((!cb) || (!ce)) sqstd_rex_error(exp,_SC("balanced chars expected")); - if ( cb == ce ) sqstd_rex_error(exp,_SC("open/close char can't be the same")); - int64_t node = sqstd_rex_newnode(exp,OP_MB); - exp->_nodes[node].left = cb; - exp->_nodes[node].right = ce; - return node; + } else if(!scisprint(*exp->_p)) rabbit::std::rex_error(exp,_SC("letter expected")); + return (*exp->_p++); + } + + static int64_t rex_charclass(SQRex *exp,int64_t classid) + { + int64_t n = rabbit::std::rex_newnode(exp,OP_CCLASS); + exp->_nodes[n].left = classid; + return n; + } + + static int64_t rex_charnode(SQRex *exp,rabbit::Bool isclass) + { + rabbit::Char t; + if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR) { + exp->_p++; + switch(*exp->_p) { + case 'n': exp->_p++; return rabbit::std::rex_newnode(exp,'\n'); + case 't': exp->_p++; return rabbit::std::rex_newnode(exp,'\t'); + case 'r': exp->_p++; return rabbit::std::rex_newnode(exp,'\r'); + case 'f': exp->_p++; return rabbit::std::rex_newnode(exp,'\f'); + case 'v': exp->_p++; return rabbit::std::rex_newnode(exp,'\v'); + case 'a': case 'A': case 'w': case 'W': case 's': case 'S': + case 'd': case 'D': case 'x': case 'X': case 'c': case 'C': + case 'p': case 'P': case 'l': case 'u': + { + t = *exp->_p; exp->_p++; + return rabbit::std::rex_charclass(exp,t); + } + case 'm': + { + rabbit::Char cb, ce; //cb = character begin match ce = character end match + cb = *++exp->_p; //skip 'm' + ce = *++exp->_p; + exp->_p++; //points to the next char to be parsed + if ((!cb) || (!ce)) rabbit::std::rex_error(exp,_SC("balanced chars expected")); + if ( cb == ce ) rabbit::std::rex_error(exp,_SC("open/close char can't be the same")); + int64_t node = rabbit::std::rex_newnode(exp,OP_MB); + exp->_nodes[node].left = cb; + exp->_nodes[node].right = ce; + return node; + } + case 0: + rabbit::std::rex_error(exp,_SC("letter expected for argument of escape sequence")); + break; + case 'b': + case 'B': + if(!isclass) { + int64_t node = rabbit::std::rex_newnode(exp,OP_WB); + exp->_nodes[node].left = *exp->_p; + exp->_p++; + return node; + } //else default + default: + t = *exp->_p; exp->_p++; + return rabbit::std::rex_newnode(exp,t); } - case 0: - sqstd_rex_error(exp,_SC("letter expected for argument of escape sequence")); - break; - case 'b': - case 'B': - if(!isclass) { - int64_t node = sqstd_rex_newnode(exp,OP_WB); - exp->_nodes[node].left = *exp->_p; - exp->_p++; - return node; - } //else default - default: - t = *exp->_p; exp->_p++; - return sqstd_rex_newnode(exp,t); + } + else if(!scisprint(*exp->_p)) { + + rabbit::std::rex_error(exp,_SC("letter expected")); + } + t = *exp->_p; exp->_p++; + return rabbit::std::rex_newnode(exp,t); } - } - else if(!scisprint(*exp->_p)) { - - sqstd_rex_error(exp,_SC("letter expected")); - } - t = *exp->_p; exp->_p++; - return sqstd_rex_newnode(exp,t); -} -static int64_t sqstd_rex_class(SQRex *exp) -{ - int64_t ret = -1; - int64_t first = -1,chain; - if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING){ - ret = sqstd_rex_newnode(exp,OP_NCLASS); - exp->_p++; - }else ret = sqstd_rex_newnode(exp,OP_CLASS); - - if(*exp->_p == ']') sqstd_rex_error(exp,_SC("empty class")); - chain = ret; - while(*exp->_p != ']' && exp->_p != exp->_eol) { - if(*exp->_p == '-' && first != -1){ - int64_t r; - if(*exp->_p++ == ']') sqstd_rex_error(exp,_SC("unfinished range")); - r = sqstd_rex_newnode(exp,OP_RANGE); - if(exp->_nodes[first].type>*exp->_p) sqstd_rex_error(exp,_SC("invalid range")); - if(exp->_nodes[first].type == OP_CCLASS) sqstd_rex_error(exp,_SC("cannot use character classes in ranges")); - exp->_nodes[r].left = exp->_nodes[first].type; - int64_t t = sqstd_rex_escapechar(exp); - exp->_nodes[r].right = t; - exp->_nodes[chain].next = r; - chain = r; - first = -1; - } - else{ + static int64_t rex_class(SQRex *exp) + { + int64_t ret = -1; + int64_t first = -1,chain; + if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING){ + ret = rabbit::std::rex_newnode(exp,OP_NCLASS); + exp->_p++; + }else ret = rabbit::std::rex_newnode(exp,OP_CLASS); + + if(*exp->_p == ']') rabbit::std::rex_error(exp,_SC("empty class")); + chain = ret; + while(*exp->_p != ']' && exp->_p != exp->_eol) { + if(*exp->_p == '-' && first != -1){ + int64_t r; + if(*exp->_p++ == ']') rabbit::std::rex_error(exp,_SC("unfinished range")); + r = rabbit::std::rex_newnode(exp,OP_RANGE); + if(exp->_nodes[first].type>*exp->_p) rabbit::std::rex_error(exp,_SC("invalid range")); + if(exp->_nodes[first].type == OP_CCLASS) rabbit::std::rex_error(exp,_SC("cannot use character classes in ranges")); + exp->_nodes[r].left = exp->_nodes[first].type; + int64_t t = rabbit::std::rex_escapechar(exp); + exp->_nodes[r].right = t; + exp->_nodes[chain].next = r; + chain = r; + first = -1; + } + else{ + if(first!=-1){ + int64_t c = first; + exp->_nodes[chain].next = c; + chain = c; + first = rabbit::std::rex_charnode(exp,SQTrue); + } + else{ + first = rabbit::std::rex_charnode(exp,SQTrue); + } + } + } if(first!=-1){ int64_t c = first; exp->_nodes[chain].next = c; - chain = c; - first = sqstd_rex_charnode(exp,SQTrue); - } - else{ - first = sqstd_rex_charnode(exp,SQTrue); } + /* hack? */ + exp->_nodes[ret].left = exp->_nodes[ret].next; + exp->_nodes[ret].next = -1; + return ret; } - } - if(first!=-1){ - int64_t c = first; - exp->_nodes[chain].next = c; - } - /* hack? */ - exp->_nodes[ret].left = exp->_nodes[ret].next; - exp->_nodes[ret].next = -1; - return ret; -} - -static int64_t sqstd_rex_parsenumber(SQRex *exp) -{ - int64_t ret = *exp->_p-'0'; - int64_t positions = 10; - exp->_p++; - while(isdigit(*exp->_p)) { - ret = ret*10+(*exp->_p++-'0'); - if(positions==1000000000) sqstd_rex_error(exp,_SC("overflow in numeric constant")); - positions *= 10; - }; - return ret; -} - -static int64_t sqstd_rex_element(SQRex *exp) -{ - int64_t ret = -1; - switch(*exp->_p) - { - case '(': { - int64_t expr; - exp->_p++; - - - if(*exp->_p =='?') { + + static int64_t rex_parsenumber(SQRex *exp) + { + int64_t ret = *exp->_p-'0'; + int64_t positions = 10; exp->_p++; - sqstd_rex_expect(exp,':'); - expr = sqstd_rex_newnode(exp,OP_NOCAPEXPR); + while(isdigit(*exp->_p)) { + ret = ret*10+(*exp->_p++-'0'); + if(positions==1000000000) rabbit::std::rex_error(exp,_SC("overflow in numeric constant")); + positions *= 10; + }; + return ret; } - else - expr = sqstd_rex_newnode(exp,OP_EXPR); - int64_t newn = sqstd_rex_list(exp); - exp->_nodes[expr].left = newn; - ret = expr; - sqstd_rex_expect(exp,')'); - } - break; - case '[': - exp->_p++; - ret = sqstd_rex_class(exp); - sqstd_rex_expect(exp,']'); - break; - case SQREX_SYMBOL_END_OF_STRING: exp->_p++; ret = sqstd_rex_newnode(exp,OP_EOL);break; - case SQREX_SYMBOL_ANY_CHAR: exp->_p++; ret = sqstd_rex_newnode(exp,OP_DOT);break; - default: - ret = sqstd_rex_charnode(exp,SQFalse); - break; - } - - - rabbit::Bool isgreedy = SQFalse; - unsigned short p0 = 0, p1 = 0; - switch(*exp->_p){ - case SQREX_SYMBOL_GREEDY_ZERO_OR_MORE: p0 = 0; p1 = 0xFFFF; exp->_p++; isgreedy = SQTrue; break; - case SQREX_SYMBOL_GREEDY_ONE_OR_MORE: p0 = 1; p1 = 0xFFFF; exp->_p++; isgreedy = SQTrue; break; - case SQREX_SYMBOL_GREEDY_ZERO_OR_ONE: p0 = 0; p1 = 1; exp->_p++; isgreedy = SQTrue; break; - case '{': - exp->_p++; - if(!isdigit(*exp->_p)) sqstd_rex_error(exp,_SC("number expected")); - p0 = (unsigned short)sqstd_rex_parsenumber(exp); - /*******************************/ - switch(*exp->_p) { - case '}': - p1 = p0; exp->_p++; - break; - case ',': - exp->_p++; - p1 = 0xFFFF; - if(isdigit(*exp->_p)){ - p1 = (unsigned short)sqstd_rex_parsenumber(exp); - } - sqstd_rex_expect(exp,'}'); - break; - default: - sqstd_rex_error(exp,_SC(", or } expected")); - } - /*******************************/ - isgreedy = SQTrue; - break; - - } - if(isgreedy) { - int64_t nnode = sqstd_rex_newnode(exp,OP_GREEDY); - exp->_nodes[nnode].left = ret; - exp->_nodes[nnode].right = ((p0)<<16)|p1; - ret = nnode; - } - - if((*exp->_p != SQREX_SYMBOL_BRANCH) && (*exp->_p != ')') && (*exp->_p != SQREX_SYMBOL_GREEDY_ZERO_OR_MORE) && (*exp->_p != SQREX_SYMBOL_GREEDY_ONE_OR_MORE) && (*exp->_p != '\0')) { - int64_t nnode = sqstd_rex_element(exp); - exp->_nodes[ret].next = nnode; - } - - return ret; -} - -static int64_t sqstd_rex_list(SQRex *exp) -{ - int64_t ret=-1,e; - if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING) { - exp->_p++; - ret = sqstd_rex_newnode(exp,OP_BOL); - } - e = sqstd_rex_element(exp); - if(ret != -1) { - exp->_nodes[ret].next = e; - } - else ret = e; - - if(*exp->_p == SQREX_SYMBOL_BRANCH) { - int64_t temp,tright; - exp->_p++; - temp = sqstd_rex_newnode(exp,OP_OR); - exp->_nodes[temp].left = ret; - tright = sqstd_rex_list(exp); - exp->_nodes[temp].right = tright; - ret = temp; - } - return ret; -} - -static rabbit::Bool sqstd_rex_matchcclass(int64_t cclass,rabbit::Char c) -{ - switch(cclass) { - case 'a': return isalpha(c)?SQTrue:SQFalse; - case 'A': return !isalpha(c)?SQTrue:SQFalse; - case 'w': return (isalnum(c) || c == '_')?SQTrue:SQFalse; - case 'W': return (!isalnum(c) && c != '_')?SQTrue:SQFalse; - case 's': return isspace(c)?SQTrue:SQFalse; - case 'S': return !isspace(c)?SQTrue:SQFalse; - case 'd': return isdigit(c)?SQTrue:SQFalse; - case 'D': return !isdigit(c)?SQTrue:SQFalse; - case 'x': return isxdigit(c)?SQTrue:SQFalse; - case 'X': return !isxdigit(c)?SQTrue:SQFalse; - case 'c': return iscntrl(c)?SQTrue:SQFalse; - case 'C': return !iscntrl(c)?SQTrue:SQFalse; - case 'p': return ispunct(c)?SQTrue:SQFalse; - case 'P': return !ispunct(c)?SQTrue:SQFalse; - case 'l': return islower(c)?SQTrue:SQFalse; - case 'u': return isupper(c)?SQTrue:SQFalse; - } - return SQFalse; /*cannot happen*/ -} - -static rabbit::Bool sqstd_rex_matchclass(SQRex* exp,SQRexNode *node,rabbit::Char c) -{ - do { - switch(node->type) { - case OP_RANGE: - if(c >= node->left && c <= node->right) return SQTrue; - break; - case OP_CCLASS: - if(sqstd_rex_matchcclass(node->left,c)) return SQTrue; + + static int64_t rex_element(SQRex *exp) + { + int64_t ret = -1; + switch(*exp->_p) + { + case '(': { + int64_t expr; + exp->_p++; + + + if(*exp->_p =='?') { + exp->_p++; + rabbit::std::rex_expect(exp,':'); + expr = rabbit::std::rex_newnode(exp,OP_NOCAPEXPR); + } + else + expr = rabbit::std::rex_newnode(exp,OP_EXPR); + int64_t newn = rabbit::std::rex_list(exp); + exp->_nodes[expr].left = newn; + ret = expr; + rabbit::std::rex_expect(exp,')'); + } + break; + case '[': + exp->_p++; + ret = rabbit::std::rex_class(exp); + rabbit::std::rex_expect(exp,']'); break; + case SQREX_SYMBOL_END_OF_STRING: exp->_p++; ret = rabbit::std::rex_newnode(exp,OP_EOL);break; + case SQREX_SYMBOL_ANY_CHAR: exp->_p++; ret = rabbit::std::rex_newnode(exp,OP_DOT);break; default: - if(c == node->type)return SQTrue; - } - } while((node->next != -1) && (node = &exp->_nodes[node->next])); - return SQFalse; -} - -static const rabbit::Char *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const rabbit::Char *str,SQRexNode *next) -{ - - SQRexNodeType type = node->type; - switch(type) { - case OP_GREEDY: { - //SQRexNode *greedystop = (node->next != -1) ? &exp->_nodes[node->next] : NULL; - SQRexNode *greedystop = NULL; - int64_t p0 = (node->right >> 16)&0x0000FFFF, p1 = node->right&0x0000FFFF, nmaches = 0; - const rabbit::Char *s=str, *good = str; - - if(node->next != -1) { - greedystop = &exp->_nodes[node->next]; - } - else { - greedystop = next; - } - - while((nmaches == 0xFFFF || nmaches < p1)) { - - const rabbit::Char *stop; - if(!(s = sqstd_rex_matchnode(exp,&exp->_nodes[node->left],s,greedystop))) + ret = rabbit::std::rex_charnode(exp,SQFalse); break; - nmaches++; - good=s; - if(greedystop) { - //checks that 0 matches satisfy the expression(if so skips) - //if not would always stop(for instance if is a '?') - if(greedystop->type != OP_GREEDY || - (greedystop->type == OP_GREEDY && ((greedystop->right >> 16)&0x0000FFFF) != 0)) - { - SQRexNode *gnext = NULL; - if(greedystop->next != -1) { - gnext = &exp->_nodes[greedystop->next]; - }else if(next && next->next != -1){ - gnext = &exp->_nodes[next->next]; - } - stop = sqstd_rex_matchnode(exp,greedystop,s,gnext); - if(stop) { - //if satisfied stop it - if(p0 == p1 && p0 == nmaches) break; - else if(nmaches >= p0 && p1 == 0xFFFF) break; - else if(nmaches >= p0 && nmaches <= p1) break; - } - } } - - if(s >= exp->_eol) - break; + + + rabbit::Bool isgreedy = SQFalse; + unsigned short p0 = 0, p1 = 0; + switch(*exp->_p){ + case SQREX_SYMBOL_GREEDY_ZERO_OR_MORE: p0 = 0; p1 = 0xFFFF; exp->_p++; isgreedy = SQTrue; break; + case SQREX_SYMBOL_GREEDY_ONE_OR_MORE: p0 = 1; p1 = 0xFFFF; exp->_p++; isgreedy = SQTrue; break; + case SQREX_SYMBOL_GREEDY_ZERO_OR_ONE: p0 = 0; p1 = 1; exp->_p++; isgreedy = SQTrue; break; + case '{': + exp->_p++; + if(!isdigit(*exp->_p)) rabbit::std::rex_error(exp,_SC("number expected")); + p0 = (unsigned short)rabbit::std::rex_parsenumber(exp); + /*******************************/ + switch(*exp->_p) { + case '}': + p1 = p0; exp->_p++; + break; + case ',': + exp->_p++; + p1 = 0xFFFF; + if(isdigit(*exp->_p)){ + p1 = (unsigned short)rabbit::std::rex_parsenumber(exp); + } + rabbit::std::rex_expect(exp,'}'); + break; + default: + rabbit::std::rex_error(exp,_SC(", or } expected")); + } + /*******************************/ + isgreedy = SQTrue; + break; + + } + if(isgreedy) { + int64_t nnode = rabbit::std::rex_newnode(exp,OP_GREEDY); + exp->_nodes[nnode].left = ret; + exp->_nodes[nnode].right = ((p0)<<16)|p1; + ret = nnode; + } + + if((*exp->_p != SQREX_SYMBOL_BRANCH) && (*exp->_p != ')') && (*exp->_p != SQREX_SYMBOL_GREEDY_ZERO_OR_MORE) && (*exp->_p != SQREX_SYMBOL_GREEDY_ONE_OR_MORE) && (*exp->_p != '\0')) { + int64_t nnode = rabbit::std::rex_element(exp); + exp->_nodes[ret].next = nnode; + } + + return ret; } - if(p0 == p1 && p0 == nmaches) return good; - else if(nmaches >= p0 && p1 == 0xFFFF) return good; - else if(nmaches >= p0 && nmaches <= p1) return good; - return NULL; - } - case OP_OR: { - const rabbit::Char *asd = str; - SQRexNode *temp=&exp->_nodes[node->left]; - while( (asd = sqstd_rex_matchnode(exp,temp,asd,NULL)) ) { - if(temp->next != -1) - temp = &exp->_nodes[temp->next]; - else - return asd; + + static int64_t rex_list(SQRex *exp) + { + int64_t ret=-1,e; + if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING) { + exp->_p++; + ret = rabbit::std::rex_newnode(exp,OP_BOL); } - asd = str; - temp = &exp->_nodes[node->right]; - while( (asd = sqstd_rex_matchnode(exp,temp,asd,NULL)) ) { - if(temp->next != -1) - temp = &exp->_nodes[temp->next]; - else - return asd; + e = rabbit::std::rex_element(exp); + if(ret != -1) { + exp->_nodes[ret].next = e; } - return NULL; - break; - } - case OP_EXPR: - case OP_NOCAPEXPR:{ - SQRexNode *n = &exp->_nodes[node->left]; - const rabbit::Char *cur = str; - int64_t capture = -1; - if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) { - capture = exp->_currsubexp; - exp->_matches[capture].begin = cur; - exp->_currsubexp++; + else ret = e; + + if(*exp->_p == SQREX_SYMBOL_BRANCH) { + int64_t temp,tright; + exp->_p++; + temp = rabbit::std::rex_newnode(exp,OP_OR); + exp->_nodes[temp].left = ret; + tright = rabbit::std::rex_list(exp); + exp->_nodes[temp].right = tright; + ret = temp; } - int64_t tempcap = exp->_currsubexp; + return ret; + } + + static rabbit::Bool rex_matchcclass(int64_t cclass,rabbit::Char c) + { + switch(cclass) { + case 'a': return isalpha(c)?SQTrue:SQFalse; + case 'A': return !isalpha(c)?SQTrue:SQFalse; + case 'w': return (isalnum(c) || c == '_')?SQTrue:SQFalse; + case 'W': return (!isalnum(c) && c != '_')?SQTrue:SQFalse; + case 's': return isspace(c)?SQTrue:SQFalse; + case 'S': return !isspace(c)?SQTrue:SQFalse; + case 'd': return isdigit(c)?SQTrue:SQFalse; + case 'D': return !isdigit(c)?SQTrue:SQFalse; + case 'x': return isxdigit(c)?SQTrue:SQFalse; + case 'X': return !isxdigit(c)?SQTrue:SQFalse; + case 'c': return iscntrl(c)?SQTrue:SQFalse; + case 'C': return !iscntrl(c)?SQTrue:SQFalse; + case 'p': return ispunct(c)?SQTrue:SQFalse; + case 'P': return !ispunct(c)?SQTrue:SQFalse; + case 'l': return islower(c)?SQTrue:SQFalse; + case 'u': return isupper(c)?SQTrue:SQFalse; + } + return SQFalse; /*cannot happen*/ + } + + static rabbit::Bool rex_matchclass(SQRex* exp,SQRexNode *node,rabbit::Char c) + { do { - SQRexNode *subnext = NULL; - if(n->next != -1) { - subnext = &exp->_nodes[n->next]; - }else { - subnext = next; + switch(node->type) { + case OP_RANGE: + if(c >= node->left && c <= node->right) return SQTrue; + break; + case OP_CCLASS: + if(rabbit::std::rex_matchcclass(node->left,c)) return SQTrue; + break; + default: + if(c == node->type)return SQTrue; } - if(!(cur = sqstd_rex_matchnode(exp,n,cur,subnext))) { - if(capture != -1){ - exp->_matches[capture].begin = 0; - exp->_matches[capture].len = 0; + } while((node->next != -1) && (node = &exp->_nodes[node->next])); + return SQFalse; + } + + static const rabbit::Char * rex_matchnode(SQRex* exp,SQRexNode *node,const rabbit::Char *str,SQRexNode *next) + { + + SQRexNodeType type = node->type; + switch(type) { + case OP_GREEDY: { + //SQRexNode *greedystop = (node->next != -1) ? &exp->_nodes[node->next] : NULL; + SQRexNode *greedystop = NULL; + int64_t p0 = (node->right >> 16)&0x0000FFFF, p1 = node->right&0x0000FFFF, nmaches = 0; + const rabbit::Char *s=str, *good = str; + + if(node->next != -1) { + greedystop = &exp->_nodes[node->next]; + } + else { + greedystop = next; + } + + while((nmaches == 0xFFFF || nmaches < p1)) { + + const rabbit::Char *stop; + if(!(s = rabbit::std::rex_matchnode(exp,&exp->_nodes[node->left],s,greedystop))) + break; + nmaches++; + good=s; + if(greedystop) { + //checks that 0 matches satisfy the expression(if so skips) + //if not would always stop(for instance if is a '?') + if(greedystop->type != OP_GREEDY || + (greedystop->type == OP_GREEDY && ((greedystop->right >> 16)&0x0000FFFF) != 0)) + { + SQRexNode *gnext = NULL; + if(greedystop->next != -1) { + gnext = &exp->_nodes[greedystop->next]; + }else if(next && next->next != -1){ + gnext = &exp->_nodes[next->next]; + } + stop = rabbit::std::rex_matchnode(exp,greedystop,s,gnext); + if(stop) { + //if satisfied stop it + if(p0 == p1 && p0 == nmaches) break; + else if(nmaches >= p0 && p1 == 0xFFFF) break; + else if(nmaches >= p0 && nmaches <= p1) break; + } + } + } + + if(s >= exp->_eol) + break; + } + if(p0 == p1 && p0 == nmaches) return good; + else if(nmaches >= p0 && p1 == 0xFFFF) return good; + else if(nmaches >= p0 && nmaches <= p1) return good; + return NULL; + } + case OP_OR: { + const rabbit::Char *asd = str; + SQRexNode *temp=&exp->_nodes[node->left]; + while( (asd = rabbit::std::rex_matchnode(exp,temp,asd,NULL)) ) { + if(temp->next != -1) + temp = &exp->_nodes[temp->next]; + else + return asd; + } + asd = str; + temp = &exp->_nodes[node->right]; + while( (asd = rabbit::std::rex_matchnode(exp,temp,asd,NULL)) ) { + if(temp->next != -1) + temp = &exp->_nodes[temp->next]; + else + return asd; } return NULL; - } - } while((n->next != -1) && (n = &exp->_nodes[n->next])); - - exp->_currsubexp = tempcap; - if(capture != -1) - exp->_matches[capture].len = cur - exp->_matches[capture].begin; - return cur; - } - case OP_WB: - if((str == exp->_bol && !isspace(*str)) - || (str == exp->_eol && !isspace(*(str-1))) - || (!isspace(*str) && isspace(*(str+1))) - || (isspace(*str) && !isspace(*(str+1))) ) { - return (node->left == 'b')?str:NULL; - } - return (node->left == 'b')?NULL:str; - case OP_BOL: - if(str == exp->_bol) return str; - return NULL; - case OP_EOL: - if(str == exp->_eol) return str; - return NULL; - case OP_DOT:{ - if (str == exp->_eol) return NULL; - str++; - } - return str; - case OP_NCLASS: - case OP_CLASS: - if (str == exp->_eol) return NULL; - if(sqstd_rex_matchclass(exp,&exp->_nodes[node->left],*str)?(type == OP_CLASS?SQTrue:SQFalse):(type == OP_NCLASS?SQTrue:SQFalse)) { - str++; - return str; - } - return NULL; - case OP_CCLASS: - if (str == exp->_eol) return NULL; - if(sqstd_rex_matchcclass(node->left,*str)) { - str++; - return str; - } - return NULL; - case OP_MB: - { - int64_t cb = node->left; //char that opens a balanced expression - if(*str != cb) return NULL; // string doesnt start with open char - int64_t ce = node->right; //char that closes a balanced expression - int64_t cont = 1; - const rabbit::Char *streol = exp->_eol; - while (++str < streol) { - if (*str == ce) { - if (--cont == 0) { - return ++str; - } - } - else if (*str == cb) cont++; + break; } + case OP_EXPR: + case OP_NOCAPEXPR:{ + SQRexNode *n = &exp->_nodes[node->left]; + const rabbit::Char *cur = str; + int64_t capture = -1; + if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) { + capture = exp->_currsubexp; + exp->_matches[capture].begin = cur; + exp->_currsubexp++; + } + int64_t tempcap = exp->_currsubexp; + do { + SQRexNode *subnext = NULL; + if(n->next != -1) { + subnext = &exp->_nodes[n->next]; + }else { + subnext = next; + } + if(!(cur = rabbit::std::rex_matchnode(exp,n,cur,subnext))) { + if(capture != -1){ + exp->_matches[capture].begin = 0; + exp->_matches[capture].len = 0; + } + return NULL; + } + } while((n->next != -1) && (n = &exp->_nodes[n->next])); + + exp->_currsubexp = tempcap; + if(capture != -1) + exp->_matches[capture].len = cur - exp->_matches[capture].begin; + return cur; + } + case OP_WB: + if((str == exp->_bol && !isspace(*str)) + || (str == exp->_eol && !isspace(*(str-1))) + || (!isspace(*str) && isspace(*(str+1))) + || (isspace(*str) && !isspace(*(str+1))) ) { + return (node->left == 'b')?str:NULL; + } + return (node->left == 'b')?NULL:str; + case OP_BOL: + if(str == exp->_bol) return str; + return NULL; + case OP_EOL: + if(str == exp->_eol) return str; + return NULL; + case OP_DOT:{ + if (str == exp->_eol) return NULL; + str++; + } + return str; + case OP_NCLASS: + case OP_CLASS: + if (str == exp->_eol) return NULL; + if(rabbit::std::rex_matchclass(exp,&exp->_nodes[node->left],*str)?(type == OP_CLASS?SQTrue:SQFalse):(type == OP_NCLASS?SQTrue:SQFalse)) { + str++; + return str; + } + return NULL; + case OP_CCLASS: + if (str == exp->_eol) return NULL; + if(rabbit::std::rex_matchcclass(node->left,*str)) { + str++; + return str; + } + return NULL; + case OP_MB: + { + int64_t cb = node->left; //char that opens a balanced expression + if(*str != cb) return NULL; // string doesnt start with open char + int64_t ce = node->right; //char that closes a balanced expression + int64_t cont = 1; + const rabbit::Char *streol = exp->_eol; + while (++str < streol) { + if (*str == ce) { + if (--cont == 0) { + return ++str; + } + } + else if (*str == cb) cont++; + } + } + return NULL; // string ends out of balance + default: /* char */ + if (str == exp->_eol) return NULL; + if(*str != node->type) return NULL; + str++; + return str; + } + return NULL; } - return NULL; // string ends out of balance - default: /* char */ - if (str == exp->_eol) return NULL; - if(*str != node->type) return NULL; - str++; - return str; } - return NULL; } - /* public api */ -SQRex *sqstd_rex_compile(const rabbit::Char *pattern,const rabbit::Char **error) +rabbit::std::SQRex *rabbit::std::rex_compile(const rabbit::Char *pattern,const rabbit::Char **error) { SQRex * volatile exp = (SQRex *)sq_malloc(sizeof(SQRex)); // "volatile" is needed for setjmp() exp->_eol = exp->_bol = NULL; @@ -568,14 +572,14 @@ SQRex *sqstd_rex_compile(const rabbit::Char *pattern,const rabbit::Char **error) exp->_nsize = 0; exp->_matches = 0; exp->_nsubexpr = 0; - exp->_first = sqstd_rex_newnode(exp,OP_EXPR); + exp->_first = rabbit::std::rex_newnode(exp,OP_EXPR); exp->_error = error; exp->_jmpbuf = sq_malloc(sizeof(jmp_buf)); if(setjmp(*((jmp_buf*)exp->_jmpbuf)) == 0) { - int64_t res = sqstd_rex_list(exp); + int64_t res = rabbit::std::rex_list(exp); exp->_nodes[exp->_first].left = res; if(*exp->_p!='\0') - sqstd_rex_error(exp,_SC("unexpected character")); + rabbit::std::rex_error(exp,_SC("unexpected character")); #ifdef _DEBUG { int64_t nsize,i; @@ -597,13 +601,13 @@ SQRex *sqstd_rex_compile(const rabbit::Char *pattern,const rabbit::Char **error) memset(exp->_matches,0,exp->_nsubexpr * sizeof(SQRexMatch)); } else{ - sqstd_rex_free(exp); + rabbit::std::rex_free(exp); return NULL; } return exp; } -void sqstd_rex_free(SQRex *exp) +void rabbit::std::rex_free(SQRex *exp) { if(exp) { if(exp->_nodes) sq_free(exp->_nodes,exp->_nallocated * sizeof(SQRexNode)); @@ -613,19 +617,19 @@ void sqstd_rex_free(SQRex *exp) } } -rabbit::Bool sqstd_rex_match(SQRex* exp,const rabbit::Char* text) +rabbit::Bool rabbit::std::rex_match(SQRex* exp,const rabbit::Char* text) { const rabbit::Char* res = NULL; exp->_bol = text; exp->_eol = text + scstrlen(text); exp->_currsubexp = 0; - res = sqstd_rex_matchnode(exp,exp->_nodes,text,NULL); + res = rabbit::std::rex_matchnode(exp,exp->_nodes,text,NULL); if(res == NULL || res != exp->_eol) return SQFalse; return SQTrue; } -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 rabbit::std::rex_searchrange(SQRex* exp,const rabbit::Char* text_begin,const rabbit::Char* text_end,const rabbit::Char** out_begin, const rabbit::Char** out_end) { const rabbit::Char *cur = NULL; int64_t node = exp->_first; @@ -636,7 +640,7 @@ rabbit::Bool sqstd_rex_searchrange(SQRex* exp,const rabbit::Char* text_begin,con cur = text_begin; while(node != -1) { exp->_currsubexp = 0; - cur = sqstd_rex_matchnode(exp,&exp->_nodes[node],cur,NULL); + cur = rabbit::std::rex_matchnode(exp,&exp->_nodes[node],cur,NULL); if(!cur) break; node = exp->_nodes[node].next; @@ -654,17 +658,17 @@ rabbit::Bool sqstd_rex_searchrange(SQRex* exp,const rabbit::Char* text_begin,con return SQTrue; } -rabbit::Bool sqstd_rex_search(SQRex* exp,const rabbit::Char* text, const rabbit::Char** out_begin, const rabbit::Char** out_end) +rabbit::Bool rabbit::std::rex_search(SQRex* exp,const rabbit::Char* text, const rabbit::Char** out_begin, const rabbit::Char** out_end) { - return sqstd_rex_searchrange(exp,text,text + scstrlen(text),out_begin,out_end); + return rabbit::std::rex_searchrange(exp,text,text + scstrlen(text),out_begin,out_end); } -int64_t sqstd_rex_getsubexpcount(SQRex* exp) +int64_t rabbit::std::rex_getsubexpcount(SQRex* exp) { return exp->_nsubexpr; } -rabbit::Bool sqstd_rex_getsubexp(SQRex* exp, int64_t n, SQRexMatch *subexp) +rabbit::Bool rabbit::std::rex_getsubexp(SQRex* exp, int64_t n, SQRexMatch *subexp) { if( n<0 || n >= exp->_nsubexpr) return SQFalse; *subexp = exp->_matches[n]; diff --git a/rabbit-std/sqstdstream.cpp b/rabbit-std/sqstdstream.cpp index 923666d..0952d24 100644 --- a/rabbit-std/sqstdstream.cpp +++ b/rabbit-std/sqstdstream.cpp @@ -17,11 +17,11 @@ #include #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")); diff --git a/rabbit-std/sqstdstream.hpp b/rabbit-std/sqstdstream.hpp index 9ea479a..65e241e 100644 --- a/rabbit-std/sqstdstream.hpp +++ b/rabbit-std/sqstdstream.hpp @@ -9,16 +9,20 @@ #include -int64_t _stream_readblob(rabbit::VirtualMachine* v); -int64_t _stream_readline(rabbit::VirtualMachine* v); -int64_t _stream_readn(rabbit::VirtualMachine* v); -int64_t _stream_writeblob(rabbit::VirtualMachine* v); -int64_t _stream_writen(rabbit::VirtualMachine* v); -int64_t _stream_seek(rabbit::VirtualMachine* v); -int64_t _stream_tell(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} -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); +namespace rabbit { + namespace std { + int64_t _stream_readblob(rabbit::VirtualMachine* v); + int64_t _stream_readline(rabbit::VirtualMachine* v); + int64_t _stream_readn(rabbit::VirtualMachine* v); + int64_t _stream_writeblob(rabbit::VirtualMachine* v); + int64_t _stream_writen(rabbit::VirtualMachine* v); + int64_t _stream_seek(rabbit::VirtualMachine* v); + int64_t _stream_tell(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} + 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); + } +} diff --git a/rabbit-std/sqstdstring.cpp b/rabbit-std/sqstdstring.cpp index 1557ba4..d24fae4 100644 --- a/rabbit-std/sqstdstring.cpp +++ b/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; \ - sq_getinstanceup(v,1,(rabbit::UserPointer *)&self,0); + rabbit::std::SQRex *self = NULL; \ + 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); - sqstd_rex_free(self); + rabbit::std::SQRex *self = ((rabbit::std::SQRex *)p); + 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) { - int64_t n = sqstd_rex_getsubexpcount(self); - SQRexMatch match; + if(rabbit::std::rex_search(self,str+start,&begin,&end) == SQTrue) { + int64_t n = rabbit::std::rex_getsubexpcount(self); + 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); diff --git a/rabbit-std/sqstdstring.hpp b/rabbit-std/sqstdstring.hpp index a62cb85..b17b6c5 100644 --- a/rabbit-std/sqstdstring.hpp +++ b/rabbit-std/sqstdstring.hpp @@ -9,23 +9,27 @@ #include -typedef unsigned int SQRexBool; -typedef struct SQRex SQRex; - -typedef struct { - const rabbit::Char *begin; - int64_t len; -} SQRexMatch; - -RABBIT_API SQRex *sqstd_rex_compile(const rabbit::Char *pattern,const rabbit::Char **error); -RABBIT_API void sqstd_rex_free(SQRex *exp); -RABBIT_API rabbit::Bool sqstd_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_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_API int64_t sqstd_rex_getsubexpcount(SQRex* exp); -RABBIT_API rabbit::Bool sqstd_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_API rabbit::Result sqstd_register_stringlib(rabbit::VirtualMachine* v); +namespace rabbit { + namespace std { + using SQRexBool = unsigned int; + using SQRex = struct SQRex; + + typedef struct { + const rabbit::Char *begin; + int64_t len; + } SQRexMatch; + + SQRex *rex_compile(const rabbit::Char *pattern,const rabbit::Char **error); + void rex_free(SQRex *exp); + rabbit::Bool rex_match(SQRex* exp,const rabbit::Char* text); + rabbit::Bool rex_search(SQRex* exp,const rabbit::Char* text, 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); + int64_t rex_getsubexpcount(SQRex* exp); + rabbit::Bool rex_getsubexp(SQRex* exp, int64_t n, SQRexMatch *subexp); + + rabbit::Result format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t *outlen,rabbit::Char **output); + + rabbit::Result register_stringlib(rabbit::VirtualMachine* v); + } +} diff --git a/rabbit-std/sqstdsystem.cpp b/rabbit-std/sqstdsystem.cpp index 46b080b..8b675f9 100644 --- a/rabbit-std/sqstdsystem.cpp +++ b/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) diff --git a/rabbit-std/sqstdsystem.hpp b/rabbit-std/sqstdsystem.hpp index 0938e21..5568150 100644 --- a/rabbit-std/sqstdsystem.hpp +++ b/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); + } +} diff --git a/rabbit/Array.cpp b/rabbit/Array.cpp index 06f832e..d752683 100644 --- a/rabbit/Array.cpp +++ b/rabbit/Array.cpp @@ -6,6 +6,8 @@ * @license MPL-2 (see license file) */ #include +#include +#include @@ -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(idxm_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]; +} \ No newline at end of file diff --git a/rabbit/Array.hpp b/rabbit/Array.hpp index 00aa1be..74cef34 100644 --- a/rabbit/Array.hpp +++ b/rabbit/Array.hpp @@ -9,128 +9,42 @@ #include #include +#include namespace rabbit { class SharedState; - class Array : public rabbit::RefCounted - { + class Array : public rabbit::RefCounted { private: Array(rabbit::SharedState* _ss, - int64_t _nsize) { - m_data.resize(_nsize); - } - ~Array() { - // TODO: Clean DATA ... - } + int64_t _nsize); + ~Array(); public: // TODO : remove this ETK_ALLOC can do it natively ... static Array* create(rabbit::SharedState* _ss, - int64_t _ninitialsize) { - Array *newarray=(Array*)SQ_MALLOC(sizeof(Array)); - new (newarray) Array(_ss, _ninitialsize); - return newarray; - } - void finalize() { - m_data.resize(0); - } + int64_t _ninitialsize); + void finalize(); bool 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 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; - } + rabbit::ObjectPtr& _val); + bool set(const int64_t _nidx,const rabbit::ObjectPtr& _val); int64_t next(const rabbit::ObjectPtr& _refpos, rabbit::ObjectPtr& _outkey, - rabbit::ObjectPtr& _outval) { - uint64_t idx=translateIndex(_refpos); - while(idxm_data = m_data; - return anew; - } - int64_t size() const { - return m_data.size(); - } - void resize(int64_t _size) { - rabbit::ObjectPtr empty; - resize(_size, empty); - } + rabbit::ObjectPtr& _outval); + Array* clone(); + int64_t size() const; + void resize(int64_t _size); void resize(int64_t _size, - rabbit::ObjectPtr& _fill) { - m_data.resize(_size, _fill); - shrinkIfNeeded(); - } - void reserve(int64_t _size) { - m_data.reserve(_size); - } - void append(const rabbit::Object& _o) { - m_data.pushBack(_o); - } + rabbit::ObjectPtr& _fill); + void reserve(int64_t _size); + void append(const rabbit::Object& _o); void extend(const Array* _a); - rabbit::ObjectPtr &top(){ - return m_data.back(); - } - void pop() { - m_data.popBack(); - shrinkIfNeeded(); - } - bool 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 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]; - } + rabbit::ObjectPtr &top(); + void pop(); + bool insert(int64_t _idx,const rabbit::Object& _val); + void shrinkIfNeeded(); + bool remove(int64_t _idx); + void release(); + rabbit::ObjectPtr& operator[] (const size_t _pos); + const rabbit::ObjectPtr& operator[] (const size_t _pos) const; private: etk::Vector m_data; }; diff --git a/rabbit/Class.cpp b/rabbit/Class.cpp index 078a997..ce27c20 100644 --- a/rabbit/Class.cpp +++ b/rabbit/Class.cpp @@ -9,7 +9,11 @@ #include #include #include +#include +#include +#include +#include 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; } diff --git a/rabbit/Class.hpp b/rabbit/Class.hpp index 6ba61c1..f60fd8a 100644 --- a/rabbit/Class.hpp +++ b/rabbit/Class.hpp @@ -11,8 +11,8 @@ #include -#include -#include + + #include namespace rabbit { diff --git a/rabbit/Closure.cpp b/rabbit/Closure.cpp index cee8122..6957958 100644 --- a/rabbit/Closure.cpp +++ b/rabbit/Closure.cpp @@ -6,11 +6,26 @@ * @license MPL-2 (see license file) */ #include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include -#define _CHECK_IO(exp) { if(!exp)return false; } -bool SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size) +bool rabbit::SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size) { if(write(up,dest,size) != size) { v->raise_error(_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; diff --git a/rabbit/Closure.hpp b/rabbit/Closure.hpp index d4c6b2c..d12767f 100644 --- a/rabbit/Closure.hpp +++ b/rabbit/Closure.hpp @@ -10,6 +10,7 @@ #include #include #include +#include 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')) diff --git a/rabbit/Compiler.cpp b/rabbit/Compiler.cpp index 6fd1e2b..8096a2e 100644 --- a/rabbit/Compiler.cpp +++ b/rabbit/Compiler.cpp @@ -11,14 +11,23 @@ #ifndef NO_COMPILER #include #include +#include #include +#include + -#include -#include -#include -#include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +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); diff --git a/rabbit/Compiler.hpp b/rabbit/Compiler.hpp index 1c37387..f1be6c6 100644 --- a/rabbit/Compiler.hpp +++ b/rabbit/Compiler.hpp @@ -7,6 +7,10 @@ */ #pragma once +#include +#include +#include + namespace rabbit { #define TK_IDENTIFIER 258 #define TK_STRING_LITERAL 259 diff --git a/rabbit/FuncState.cpp b/rabbit/FuncState.cpp index b55f677..5776522 100644 --- a/rabbit/FuncState.cpp +++ b/rabbit/FuncState.cpp @@ -5,15 +5,23 @@ * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved * @license MPL-2 (see license file) */ +#include #include #ifndef NO_COMPILER #include -#include +#include +#include +#include +#include +#include +#include + + #include -#include +#include #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; imarkLocalAsOuter(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() -{ - while(_childstates.size() > 0) - { +rabbit::FuncState::~FuncState() { + while(_childstates.size() > 0) { popChildState(); } } diff --git a/rabbit/FuncState.hpp b/rabbit/FuncState.hpp index 857085d..636cd68 100644 --- a/rabbit/FuncState.hpp +++ b/rabbit/FuncState.hpp @@ -7,6 +7,12 @@ */ #pragma once +#include +#include +#include +#include +#include + 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); diff --git a/rabbit/FunctionProto.cpp b/rabbit/FunctionProto.cpp index 988d418..ef37c28 100644 --- a/rabbit/FunctionProto.cpp +++ b/rabbit/FunctionProto.cpp @@ -6,7 +6,64 @@ * @license MPL-2 (see license file) */ #include +#include +#include +#include +#include +#include +#include +#include +#include + + + + + +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) { diff --git a/rabbit/FunctionProto.hpp b/rabbit/FunctionProto.hpp index afd2b55..b620031 100644 --- a/rabbit/FunctionProto.hpp +++ b/rabbit/FunctionProto.hpp @@ -6,6 +6,13 @@ * @license MPL-2 (see license file) */ #pragma once +#include +#include +#include +#include +#include +#include + 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) - { - 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); - } + int64_t nlineinfos,int64_t nlocalvarinfos,int64_t ndefaultparams); + void release(); const rabbit::Char* getLocal(rabbit::VirtualMachine *v,uint64_t stackbase,uint64_t nseq,uint64_t nop); int64_t getLine(rabbit::Instruction *curr); diff --git a/rabbit/Generator.cpp b/rabbit/Generator.cpp index c2ccf9b..99a16cf 100644 --- a/rabbit/Generator.cpp +++ b/rabbit/Generator.cpp @@ -6,6 +6,8 @@ * @license MPL-2 (see license file) */ #include +#include +#include @@ -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); +} + diff --git a/rabbit/Generator.hpp b/rabbit/Generator.hpp index d2e204f..5db2dbe 100644 --- a/rabbit/Generator.hpp +++ b/rabbit/Generator.hpp @@ -7,33 +7,26 @@ */ #pragma once +#include +#include +#include +#include +#include +#include +#include +#include + 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){ - _closure = closure; - _state = eRunning; - _ci._generator = NULL; - } + Generator(rabbit::SharedState *ss,rabbit::Closure *closure); public: - static 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; - } - ~Generator() - { - - } - void kill(){ - _state=eDead; - _stack.resize(0); - _closure.Null();} - void release(){ - sq_delete(this,rabbit::Generator); - } + static Generator *create(rabbit::SharedState *ss,rabbit::Closure *closure); + ~Generator(); + void kill(); + void release(); bool yield(rabbit::VirtualMachine *v,int64_t target); bool resume(rabbit::VirtualMachine *v,rabbit::ObjectPtr &dest); @@ -41,7 +34,7 @@ namespace rabbit { etk::Vector _stack; rabbit::VirtualMachine::callInfo _ci; etk::Vector _etraps; - rabbit::GeneratorState _state; + GeneratorState _state; }; } diff --git a/rabbit/Hash.cpp b/rabbit/Hash.cpp index bad450d..656c1c5 100644 --- a/rabbit/Hash.cpp +++ b/rabbit/Hash.cpp @@ -5,8 +5,6 @@ * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved * @license MPL-2 (see license file) */ -#pragma once - #include diff --git a/rabbit/Instance.cpp b/rabbit/Instance.cpp index 6e64522..01823c6 100644 --- a/rabbit/Instance.cpp +++ b/rabbit/Instance.cpp @@ -8,6 +8,17 @@ #include #include #include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include 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); } diff --git a/rabbit/Instance.hpp b/rabbit/Instance.hpp index 80f2ad3..ced01d8 100644 --- a/rabbit/Instance.hpp +++ b/rabbit/Instance.hpp @@ -10,10 +10,13 @@ #include #include +#include +#include +#include + + -#include -#include #include #include diff --git a/rabbit/Instruction.hpp b/rabbit/Instruction.hpp index 7b81059..1aa83f0 100644 --- a/rabbit/Instruction.hpp +++ b/rabbit/Instruction.hpp @@ -6,6 +6,10 @@ * @license MPL-2 (see license file) */ #pragma once +#include +#include +#include +#include namespace rabbit { @@ -15,18 +19,21 @@ namespace rabbit { }; class Instruction { - Instruction(){}; - Instruction(SQOpcode _op,int64_t a0=0,int64_t a1=0,int64_t a2=0,int64_t a3=0) { - op = (unsigned char)_op; - _arg0 = (unsigned char)a0;_arg1 = (int32_t)a1; - _arg2 = (unsigned char)a2;_arg3 = (unsigned char)a3; - } - - int32_t _arg1; - unsigned char op; - unsigned char _arg0; - unsigned char _arg2; - unsigned char _arg3; + public: + Instruction(){}; + Instruction(SQOpcode _op,int64_t a0=0,int64_t a1=0,int64_t a2=0,int64_t a3=0) { + op = (unsigned char)_op; + _arg0 = (unsigned char)a0; + _arg1 = (int32_t)a1; + _arg2 = (unsigned char)a2; + _arg3 = (unsigned char)a3; + } + + int32_t _arg1; + unsigned char op; + unsigned char _arg0; + unsigned char _arg2; + unsigned char _arg3; }; } diff --git a/rabbit/Lexer.cpp b/rabbit/Lexer.cpp index efd3ffc..3fcb90e 100644 --- a/rabbit/Lexer.cpp +++ b/rabbit/Lexer.cpp @@ -6,11 +6,11 @@ * @license MPL-2 (see license file) */ #include +#include +#include +#include -#include -#include - #define CUR_CHAR (_currdata) #define RETURN_TOKEN(t) { _prevtoken = _curtoken; _curtoken = t; return t;} #define IS_EOB() (CUR_CHAR <= RABBIT_EOB) diff --git a/rabbit/Lexer.hpp b/rabbit/Lexer.hpp index 3ca917c..430e59b 100644 --- a/rabbit/Lexer.hpp +++ b/rabbit/Lexer.hpp @@ -7,6 +7,12 @@ */ #pragma once +#include +#include +#include +#include +#include + namespace rabbit { #ifdef SQUNICODE diff --git a/rabbit/LineInfo.hpp b/rabbit/LineInfo.hpp index 95baca4..beedfa4 100644 --- a/rabbit/LineInfo.hpp +++ b/rabbit/LineInfo.hpp @@ -7,6 +7,8 @@ */ #pragma once +#include + namespace rabbit { class LineInfo { public: diff --git a/rabbit/LocalVarInfo.hpp b/rabbit/LocalVarInfo.hpp index 423a045..e0083f3 100644 --- a/rabbit/LocalVarInfo.hpp +++ b/rabbit/LocalVarInfo.hpp @@ -7,6 +7,12 @@ */ #pragma once +#include +#include +#include +#include +#include + namespace rabbit { class LocalVarInfo { diff --git a/rabbit/MemberHandle.hpp b/rabbit/MemberHandle.hpp index e355cc9..0eab48f 100644 --- a/rabbit/MemberHandle.hpp +++ b/rabbit/MemberHandle.hpp @@ -8,6 +8,8 @@ #pragma once #include +#include +#include #include namespace rabbit { diff --git a/rabbit/MetaMethod.hpp b/rabbit/MetaMethod.hpp index 6005f4f..736a051 100644 --- a/rabbit/MetaMethod.hpp +++ b/rabbit/MetaMethod.hpp @@ -8,6 +8,9 @@ #pragma once #include +#include +#include +#include namespace rabbit { enum MetaMethod { diff --git a/rabbit/NativeClosure.cpp b/rabbit/NativeClosure.cpp index 13facd5..65a77c4 100644 --- a/rabbit/NativeClosure.cpp +++ b/rabbit/NativeClosure.cpp @@ -6,4 +6,43 @@ * @license MPL-2 (see license file) */ #include +#include +#include + +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); +} \ No newline at end of file diff --git a/rabbit/NativeClosure.hpp b/rabbit/NativeClosure.hpp index f2aea80..4844e12 100644 --- a/rabbit/NativeClosure.hpp +++ b/rabbit/NativeClosure.hpp @@ -8,47 +8,26 @@ #pragma once #include +#include +#include +#include +#include +#include +#include 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){ - _function=func; - _env = NULL; - } + NativeClosure(rabbit::SharedState *ss,SQFUNCTION func); public: - static 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 (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); - } + static rabbit::NativeClosure *create(rabbit::SharedState *ss,SQFUNCTION func,int64_t nouters); + rabbit::NativeClosure *clone(); + ~NativeClosure(); + void release(); int64_t _nparamscheck; etk::Vector _typecheck; diff --git a/rabbit/Outer.cpp b/rabbit/Outer.cpp index 31ae146..39e8874 100644 --- a/rabbit/Outer.cpp +++ b/rabbit/Outer.cpp @@ -6,4 +6,26 @@ * @license MPL-2 (see license file) */ #include +#include +#include + +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)); +} \ No newline at end of file diff --git a/rabbit/Outer.hpp b/rabbit/Outer.hpp index 7fab5b9..227883c 100644 --- a/rabbit/Outer.hpp +++ b/rabbit/Outer.hpp @@ -7,31 +7,24 @@ */ #pragma once +#include +#include +#include + + namespace rabbit { + class SharedState; class Outer : public rabbit::RefCounted { private: - rabbit::Outer(rabbit::SharedState *ss, rabbit::ObjectPtr *outer){ - _valptr = outer; - _next = NULL; - } + Outer(rabbit::SharedState *ss, rabbit::ObjectPtr *outer); public: - static rabbit::Outer *create(rabbit::SharedState *ss, rabbit::ObjectPtr *outer) { - rabbit::Outer *nc = (rabbit::Outer*)SQ_MALLOC(sizeof(rabbit::Outer)); - new (nc) rabbit::Outer(ss, outer); - return nc; - } - ~Outer() { - - } - 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 */ + static rabbit::Outer *create(rabbit::SharedState *ss, rabbit::ObjectPtr *outer); + ~Outer(); + void release(); + 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 */ }; } diff --git a/rabbit/OuterVar.hpp b/rabbit/OuterVar.hpp index 9e5be55..2ab3711 100644 --- a/rabbit/OuterVar.hpp +++ b/rabbit/OuterVar.hpp @@ -7,6 +7,10 @@ */ #pragma once +#include +#include +#include + namespace rabbit { enum OuterType { otLOCAL = 0, diff --git a/rabbit/RefTable.cpp b/rabbit/RefTable.cpp index 6b7900d..0164d79 100644 --- a/rabbit/RefTable.cpp +++ b/rabbit/RefTable.cpp @@ -9,6 +9,7 @@ #include #include +#include rabbit::RefTable::RefTable() { diff --git a/rabbit/SharedState.cpp b/rabbit/SharedState.cpp index 3cf6e45..402ee39 100644 --- a/rabbit/SharedState.cpp +++ b/rabbit/SharedState.cpp @@ -8,7 +8,10 @@ #include #include #include +#include #include +#include +#include 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); sq_new(_systemstrings,etk::Vector); sq_new(_types,etk::Vector); @@ -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); } diff --git a/rabbit/String.cpp b/rabbit/String.cpp index 908b239..7f37d7c 100644 --- a/rabbit/String.cpp +++ b/rabbit/String.cpp @@ -5,12 +5,13 @@ * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved * @license MPL-2 (see license file) */ -#pragma once - #include +#include +#include +#include -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) diff --git a/rabbit/String.hpp b/rabbit/String.hpp index 6e7fc23..012ceff 100644 --- a/rabbit/String.hpp +++ b/rabbit/String.hpp @@ -8,22 +8,29 @@ #pragma once #include +#include +#include +#include namespace rabbit { + class SharedState; + class ObjectPtr; rabbit::Hash _hashstr (const rabbit::Char *s, size_t l); + class String : public rabbit::RefCounted { - String(){} - ~String(){} - public: - static rabbit::String *create(rabbit::SharedState *ss, const rabbit::Char *, int64_t len = -1 ); - int64_t next(const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval); - void release(); - rabbit::SharedState *_sharedstate; - rabbit::String *_next; //chain for the string table - int64_t _len; - rabbit::Hash _hash; - rabbit::Char _val[1]; + public: + String(){} + ~String(){} + public: + static rabbit::String *create(rabbit::SharedState *ss, const rabbit::Char *, int64_t len = -1 ); + int64_t next(const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval); + void release(); + rabbit::SharedState *_sharedstate; + rabbit::String *_next; //chain for the string table + int64_t _len; + rabbit::Hash _hash; + rabbit::Char _val[1]; }; diff --git a/rabbit/StringTable.cpp b/rabbit/StringTable.cpp index ace8b64..8bd884d 100644 --- a/rabbit/StringTable.cpp +++ b/rabbit/StringTable.cpp @@ -5,9 +5,11 @@ * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved * @license MPL-2 (see license file) */ -#pragma once - #include +#include +#include +#include +#include @@ -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'); diff --git a/rabbit/StringTable.hpp b/rabbit/StringTable.hpp index 1cf536a..0ac5a70 100644 --- a/rabbit/StringTable.hpp +++ b/rabbit/StringTable.hpp @@ -8,6 +8,7 @@ #pragma once #include +#include namespace rabbit { diff --git a/rabbit/Table.cpp b/rabbit/Table.cpp index f3248a8..d7b9ca8 100644 --- a/rabbit/Table.cpp +++ b/rabbit/Table.cpp @@ -5,11 +5,12 @@ * @copyright 2003-2017, Alberto DEMICHELIS, all right reserved * @license MPL-2 (see license file) */ -#pragma once - #include +#include +#include +#include -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;ikey) == _rawval(key) @@ -283,5 +284,5 @@ int64_t rabbit::Table::countUsed() { } void rabbit::Table::release() { - sq_delete(this, rabbit::Table); + sq_delete(this, Table); } diff --git a/rabbit/UserData.cpp b/rabbit/UserData.cpp new file mode 100644 index 0000000..da3315e --- /dev/null +++ b/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 +#include + +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; +} diff --git a/rabbit/UserData.hpp b/rabbit/UserData.hpp index ee74103..c203a0f 100644 --- a/rabbit/UserData.hpp +++ b/rabbit/UserData.hpp @@ -6,47 +6,21 @@ * @license MPL-2 (see license file) */ #pragma once +#include +#include namespace rabbit { class UserData : public rabbit::Delegable { public: - UserData(rabbit::SharedState *ss) { - _delegate = 0; - m_hook = NULL; - } - ~UserData() { - setDelegate(NULL); - } - static UserData* create(rabbit::SharedState *ss, int64_t size) { - UserData* ud = (UserData*)SQ_MALLOC(sq_aligning(sizeof(UserData))+size); - 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; - } + UserData(rabbit::SharedState *ss); + ~UserData(); + static UserData* create(rabbit::SharedState *ss, int64_t size); + void release(); + const int64_t& getsize() const; + const rabbit::UserPointer& getTypeTag() const; + void setTypeTag(const rabbit::UserPointer& _value); + const SQRELEASEHOOK& getHook() const; + void setHook(const SQRELEASEHOOK& _value); protected: int64_t m_size; SQRELEASEHOOK m_hook; diff --git a/rabbit/VirtualMachine.cpp b/rabbit/VirtualMachine.cpp index 0823676..991875f 100644 --- a/rabbit/VirtualMachine.cpp +++ b/rabbit/VirtualMachine.cpp @@ -10,13 +10,24 @@ #include #include #include -#include -#include + + +#include #include #include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #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; diff --git a/rabbit/VirtualMachine.hpp b/rabbit/VirtualMachine.hpp index d586c37..3f981b3 100644 --- a/rabbit/VirtualMachine.hpp +++ b/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() { - sq_delete(this,VirtualMachine); - } - //////////////////////////////////////////////////////////////////////////// + void release(); //stack functions for the api void remove(int64_t n); diff --git a/rabbit/rabbit.hpp b/rabbit/rabbit.hpp index 16ad727..47bfa31 100644 --- a/rabbit/rabbit.hpp +++ b/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_API rabbit::VirtualMachine* sq_newthread(rabbit::VirtualMachine* friendvm, int64_t initialstacksize); -RABBIT_API void sq_seterrorhandler(rabbit::VirtualMachine* v); -RABBIT_API void sq_close(rabbit::VirtualMachine* v); -RABBIT_API void sq_setforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p); -RABBIT_API rabbit::UserPointer sq_getforeignptr(rabbit::VirtualMachine* v); -RABBIT_API void sq_setsharedforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p); -RABBIT_API rabbit::UserPointer sq_getsharedforeignptr(rabbit::VirtualMachine* v); -RABBIT_API void sq_setvmreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook); -RABBIT_API SQRELEASEHOOK sq_getvmreleasehook(rabbit::VirtualMachine* v); -RABBIT_API void sq_setsharedreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook); -RABBIT_API SQRELEASEHOOK sq_getsharedreleasehook(rabbit::VirtualMachine* v); -RABBIT_API void sq_setprintfunc(rabbit::VirtualMachine* v, SQPRINTFUNCTION printfunc,SQPRINTFUNCTION errfunc); -RABBIT_API SQPRINTFUNCTION sq_getprintfunc(rabbit::VirtualMachine* v); -RABBIT_API SQPRINTFUNCTION sq_geterrorfunc(rabbit::VirtualMachine* v); -RABBIT_API 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_API int64_t sq_getvmstate(rabbit::VirtualMachine* v); -RABBIT_API int64_t sq_getversion(); +rabbit::VirtualMachine* sq_open(int64_t initialstacksize); +rabbit::VirtualMachine* sq_newthread(rabbit::VirtualMachine* friendvm, int64_t initialstacksize); +void sq_seterrorhandler(rabbit::VirtualMachine* v); +void sq_close(rabbit::VirtualMachine* v); +void sq_setforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p); +rabbit::UserPointer sq_getforeignptr(rabbit::VirtualMachine* v); +void sq_setsharedforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p); +rabbit::UserPointer sq_getsharedforeignptr(rabbit::VirtualMachine* v); +void sq_setvmreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook); +SQRELEASEHOOK sq_getvmreleasehook(rabbit::VirtualMachine* v); +void sq_setsharedreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook); +SQRELEASEHOOK sq_getsharedreleasehook(rabbit::VirtualMachine* v); +void sq_setprintfunc(rabbit::VirtualMachine* v, SQPRINTFUNCTION printfunc,SQPRINTFUNCTION errfunc); +SQPRINTFUNCTION sq_getprintfunc(rabbit::VirtualMachine* v); +SQPRINTFUNCTION sq_geterrorfunc(rabbit::VirtualMachine* v); +rabbit::Result sq_suspendvm(rabbit::VirtualMachine* v); +rabbit::Result sq_wakeupvm(rabbit::VirtualMachine* v,rabbit::Bool resumedret,rabbit::Bool retval,rabbit::Bool raiseerror,rabbit::Bool throwerror); +int64_t sq_getvmstate(rabbit::VirtualMachine* v); +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_API 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); -RABBIT_API void sq_notifyallexceptions(rabbit::VirtualMachine* v, rabbit::Bool enable); -RABBIT_API void sq_setcompilererrorhandler(rabbit::VirtualMachine* v,SQCOMPILERERROR f); +rabbit::Result sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::UserPointer p,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); +void sq_enabledebuginfo(rabbit::VirtualMachine* v, rabbit::Bool enable); +void sq_notifyallexceptions(rabbit::VirtualMachine* v, rabbit::Bool enable); +void sq_setcompilererrorhandler(rabbit::VirtualMachine* v,SQCOMPILERERROR f); /*stack operations*/ -RABBIT_API void sq_push(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API void sq_pop(rabbit::VirtualMachine* v,int64_t nelemstopop); -RABBIT_API void sq_poptop(rabbit::VirtualMachine* v); -RABBIT_API void sq_remove(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API int64_t sq_gettop(rabbit::VirtualMachine* v); -RABBIT_API void sq_settop(rabbit::VirtualMachine* v,int64_t newtop); -RABBIT_API rabbit::Result sq_reservestack(rabbit::VirtualMachine* v,int64_t nsize); -RABBIT_API int64_t sq_cmp(rabbit::VirtualMachine* v); -RABBIT_API void sq_move(rabbit::VirtualMachine* dest,rabbit::VirtualMachine* src,int64_t idx); +void sq_push(rabbit::VirtualMachine* v,int64_t idx); +void sq_pop(rabbit::VirtualMachine* v,int64_t nelemstopop); +void sq_poptop(rabbit::VirtualMachine* v); +void sq_remove(rabbit::VirtualMachine* v,int64_t idx); +int64_t sq_gettop(rabbit::VirtualMachine* v); +void sq_settop(rabbit::VirtualMachine* v,int64_t newtop); +rabbit::Result sq_reservestack(rabbit::VirtualMachine* v,int64_t nsize); +int64_t sq_cmp(rabbit::VirtualMachine* v); +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_API void sq_newtable(rabbit::VirtualMachine* v); -RABBIT_API void sq_newtableex(rabbit::VirtualMachine* v,int64_t initialcapacity); -RABBIT_API void sq_newarray(rabbit::VirtualMachine* v,int64_t size); -RABBIT_API 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_API rabbit::Result sq_bindenv(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API rabbit::Result sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API 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); -RABBIT_API void sq_pushfloat(rabbit::VirtualMachine* v,float_t f); -RABBIT_API void sq_pushinteger(rabbit::VirtualMachine* v,int64_t n); -RABBIT_API void sq_pushbool(rabbit::VirtualMachine* v,rabbit::Bool b); -RABBIT_API void sq_pushuserpointer(rabbit::VirtualMachine* v,rabbit::UserPointer p); -RABBIT_API void sq_pushnull(rabbit::VirtualMachine* v); -RABBIT_API void sq_pushthread(rabbit::VirtualMachine* v, rabbit::VirtualMachine* thread); -RABBIT_API rabbit::ObjectType sq_gettype(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API rabbit::Result sq_typeof(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API int64_t sq_getsize(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API rabbit::Hash sq_gethash(rabbit::VirtualMachine* v, int64_t idx); -RABBIT_API rabbit::Result sq_getbase(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API rabbit::Bool sq_instanceof(rabbit::VirtualMachine* v); -RABBIT_API rabbit::Result sq_tostring(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API 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_API 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_API 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_API 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_API 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_API 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); -RABBIT_API SQRELEASEHOOK sq_getreleasehook(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API 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_API 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_API 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_API 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_API rabbit::Result sq_newclass(rabbit::VirtualMachine* v,rabbit::Bool hasbase); -RABBIT_API rabbit::Result sq_createinstance(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API rabbit::Result sq_setattributes(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API rabbit::Result sq_getattributes(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API rabbit::Result sq_getclass(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API void sq_weakref(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API 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_API 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::UserPointer sq_newuserdata(rabbit::VirtualMachine* v,uint64_t size); +void sq_newtable(rabbit::VirtualMachine* v); +void sq_newtableex(rabbit::VirtualMachine* v,int64_t initialcapacity); +void sq_newarray(rabbit::VirtualMachine* v,int64_t size); +void sq_newclosure(rabbit::VirtualMachine* v,SQFUNCTION func,uint64_t nfreevars); +rabbit::Result sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const rabbit::Char *typemask); +rabbit::Result sq_bindenv(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_getclosureroot(rabbit::VirtualMachine* v,int64_t idx); +void sq_pushstring(rabbit::VirtualMachine* v,const rabbit::Char *s,int64_t len); +void sq_pushfloat(rabbit::VirtualMachine* v,float_t f); +void sq_pushinteger(rabbit::VirtualMachine* v,int64_t n); +void sq_pushbool(rabbit::VirtualMachine* v,rabbit::Bool b); +void sq_pushuserpointer(rabbit::VirtualMachine* v,rabbit::UserPointer p); +void sq_pushnull(rabbit::VirtualMachine* v); +void sq_pushthread(rabbit::VirtualMachine* v, rabbit::VirtualMachine* thread); +rabbit::ObjectType sq_gettype(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_typeof(rabbit::VirtualMachine* v,int64_t idx); +int64_t sq_getsize(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Hash sq_gethash(rabbit::VirtualMachine* v, int64_t idx); +rabbit::Result sq_getbase(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Bool sq_instanceof(rabbit::VirtualMachine* v); +rabbit::Result sq_tostring(rabbit::VirtualMachine* v,int64_t idx); +void sq_tobool(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool *b); +rabbit::Result sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c,int64_t *size); +rabbit::Result sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c); +rabbit::Result sq_getinteger(rabbit::VirtualMachine* v,int64_t idx,int64_t *i); +rabbit::Result sq_getfloat(rabbit::VirtualMachine* v,int64_t idx,float_t *f); +rabbit::Result sq_getbool(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool *b); +rabbit::Result sq_getthread(rabbit::VirtualMachine* v,int64_t idx,rabbit::VirtualMachine* *thread); +rabbit::Result sq_getuserpointer(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *p); +rabbit::Result sq_getuserdata(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *p,rabbit::UserPointer *typetag); +rabbit::Result sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer typetag); +rabbit::Result sq_gettypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *typetag); +void sq_setreleasehook(rabbit::VirtualMachine* v,int64_t idx,SQRELEASEHOOK hook); +SQRELEASEHOOK sq_getreleasehook(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Char *sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize); +rabbit::Result sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,rabbit::FunctionInfo *fi); +rabbit::Result sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,uint64_t *nparams,uint64_t *nfreevars); +rabbit::Result sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char *name); +rabbit::Result sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer p); +rabbit::Result sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p,rabbit::UserPointer typetag); +rabbit::Result sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize); +rabbit::Result sq_newclass(rabbit::VirtualMachine* v,rabbit::Bool hasbase); +rabbit::Result sq_createinstance(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_setattributes(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_getattributes(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_getclass(rabbit::VirtualMachine* v,int64_t idx); +void sq_weakref(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_getdefaultdelegate(rabbit::VirtualMachine* v,rabbit::ObjectType t); +rabbit::Result sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,rabbit::MemberHandle *handle); +rabbit::Result sq_getbyhandle(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); -RABBIT_API void sq_pushregistrytable(rabbit::VirtualMachine* v); -RABBIT_API void sq_pushconsttable(rabbit::VirtualMachine* v); -RABBIT_API rabbit::Result sq_setroottable(rabbit::VirtualMachine* v); -RABBIT_API rabbit::Result sq_setconsttable(rabbit::VirtualMachine* v); -RABBIT_API 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_API rabbit::Result sq_set(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API rabbit::Result sq_get(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API rabbit::Result sq_rawget(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API 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_API 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_API 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_API 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_API 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_API rabbit::Result sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API rabbit::Result sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API 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_API rabbit::Result sq_next(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API rabbit::Result sq_getweakrefval(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API rabbit::Result sq_clear(rabbit::VirtualMachine* v,int64_t idx); +void sq_pushroottable(rabbit::VirtualMachine* v); +void sq_pushregistrytable(rabbit::VirtualMachine* v); +void sq_pushconsttable(rabbit::VirtualMachine* v); +rabbit::Result sq_setroottable(rabbit::VirtualMachine* v); +rabbit::Result sq_setconsttable(rabbit::VirtualMachine* v); +rabbit::Result sq_newslot(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool bstatic); +rabbit::Result sq_deleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval); +rabbit::Result sq_set(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_get(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_rawget(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_rawset(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_rawdeleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval); +rabbit::Result sq_newmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic); +rabbit::Result sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic); +rabbit::Result sq_arrayappend(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval); +rabbit::Result sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t newsize); +rabbit::Result sq_arrayreverse(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_arrayremove(rabbit::VirtualMachine* v,int64_t idx,int64_t itemidx); +rabbit::Result sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int64_t destpos); +rabbit::Result sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_clone(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval); +rabbit::Result sq_next(rabbit::VirtualMachine* v,int64_t idx); +rabbit::Result sq_getweakrefval(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_API 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); -RABBIT_API rabbit::Result sq_getcallee(rabbit::VirtualMachine* v); -RABBIT_API 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_API rabbit::Result sq_throwobject(rabbit::VirtualMachine* v); -RABBIT_API void sq_reseterror(rabbit::VirtualMachine* v); -RABBIT_API void sq_getlasterror(rabbit::VirtualMachine* v); -RABBIT_API rabbit::Result sq_tailcall(rabbit::VirtualMachine* v, int64_t nparams); +rabbit::Result sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::Bool retval,rabbit::Bool raiseerror); +rabbit::Result sq_resume(rabbit::VirtualMachine* v,rabbit::Bool retval,rabbit::Bool raiseerror); +const rabbit::Char *sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx); +rabbit::Result sq_getcallee(rabbit::VirtualMachine* v); +const rabbit::Char *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval); +rabbit::Result sq_throwerror(rabbit::VirtualMachine* v,const rabbit::Char *err); +rabbit::Result sq_throwobject(rabbit::VirtualMachine* v); +void sq_reseterror(rabbit::VirtualMachine* v); +void sq_getlasterror(rabbit::VirtualMachine* v); +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_API void sq_pushobject(rabbit::VirtualMachine* v,rabbit::Object obj); -RABBIT_API void sq_addref(rabbit::VirtualMachine* v,rabbit::Object *po); -RABBIT_API rabbit::Bool sq_release(rabbit::VirtualMachine* v,rabbit::Object *po); -RABBIT_API uint64_t sq_getrefcount(rabbit::VirtualMachine* v,rabbit::Object *po); -RABBIT_API void sq_resetobject(rabbit::Object *po); -RABBIT_API const rabbit::Char *sq_objtostring(const rabbit::Object *o); -RABBIT_API rabbit::Bool sq_objtobool(const rabbit::Object *o); -RABBIT_API int64_t sq_objtointeger(const rabbit::Object *o); -RABBIT_API float_t sq_objtofloat(const rabbit::Object *o); -RABBIT_API rabbit::UserPointer sq_objtouserpointer(const rabbit::Object *o); -RABBIT_API rabbit::Result sq_getobjtypetag(const rabbit::Object *o,rabbit::UserPointer * typetag); -RABBIT_API uint64_t sq_getvmrefcount(rabbit::VirtualMachine* v, const rabbit::Object *po); +rabbit::Result sq_getstackobj(rabbit::VirtualMachine* v,int64_t idx,rabbit::Object *po); +void sq_pushobject(rabbit::VirtualMachine* v,rabbit::Object obj); +void sq_addref(rabbit::VirtualMachine* v,rabbit::Object *po); +rabbit::Bool sq_release(rabbit::VirtualMachine* v,rabbit::Object *po); +uint64_t sq_getrefcount(rabbit::VirtualMachine* v,rabbit::Object *po); +void sq_resetobject(rabbit::Object *po); +const rabbit::Char *sq_objtostring(const rabbit::Object *o); +rabbit::Bool sq_objtobool(const rabbit::Object *o); +int64_t sq_objtointeger(const rabbit::Object *o); +float_t sq_objtofloat(const rabbit::Object *o); +rabbit::UserPointer sq_objtouserpointer(const rabbit::Object *o); +rabbit::Result sq_getobjtypetag(const rabbit::Object *o,rabbit::UserPointer * typetag); +uint64_t sq_getvmrefcount(rabbit::VirtualMachine* v, const rabbit::Object *po); /*GC*/ -RABBIT_API int64_t sq_collectgarbage(rabbit::VirtualMachine* v); -RABBIT_API rabbit::Result sq_resurrectunreachable(rabbit::VirtualMachine* v); +int64_t sq_collectgarbage(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_API rabbit::Result sq_readclosure(rabbit::VirtualMachine* vm,SQREADFUNC readf,rabbit::UserPointer up); +rabbit::Result sq_writeclosure(rabbit::VirtualMachine* vm,SQWRITEFUNC writef,rabbit::UserPointer up); +rabbit::Result sq_readclosure(rabbit::VirtualMachine* vm,SQREADFUNC readf,rabbit::UserPointer up); /*mem allocation*/ -RABBIT_API void *sq_malloc(uint64_t size); -RABBIT_API void *sq_realloc(void* p,uint64_t oldsize,uint64_t newsize); -RABBIT_API void sq_free(void *p,uint64_t size); +void *sq_malloc(uint64_t size); +void *sq_realloc(void* p,uint64_t oldsize,uint64_t newsize); +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_API void sq_setdebughook(rabbit::VirtualMachine* v); -RABBIT_API void sq_setnativedebughook(rabbit::VirtualMachine* v,SQDEBUGHOOK hook); +rabbit::Result sq_stackinfos(rabbit::VirtualMachine* v,int64_t level,rabbit::StackInfos *si); +void sq_setdebughook(rabbit::VirtualMachine* v); +void sq_setnativedebughook(rabbit::VirtualMachine* v,SQDEBUGHOOK hook); + +} /* deprecated */ #define sq_createslot(v,n) sq_newslot(v,n,SQFalse) diff --git a/rabbit/sqapi.cpp b/rabbit/sqapi.cpp index d844f8a..0d370b7 100644 --- a/rabbit/sqapi.cpp +++ b/rabbit/sqapi.cpp @@ -10,15 +10,26 @@ #include -#include -#include + + #include -#include -#include +#include +#include #include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + static bool sq_aux_gettypedarg(rabbit::VirtualMachine* v,int64_t idx,rabbit::ObjectType type,rabbit::ObjectPtr **o) { *o = &stack_get(v,idx); @@ -37,15 +48,15 @@ static bool sq_aux_gettypedarg(rabbit::VirtualMachine* v,int64_t idx,rabbit::Obj if(sq_gettop(v) < count){ v->raise_error(_SC("not enough params in the stack")); return SQ_ERROR; }\ } - -int64_t sq_aux_invalidtype(rabbit::VirtualMachine* v,rabbit::ObjectType type) -{ - uint64_t buf_size = 100 *sizeof(rabbit::Char); - scsprintf(_get_shared_state(v)->getScratchPad(buf_size), buf_size, _SC("unexpected type %s"), IdType2Name(type)); - return sq_throwerror(v, _get_shared_state(v)->getScratchPad(-1)); +namespace rabbit { + int64_t sq_aux_invalidtype(rabbit::VirtualMachine* v,rabbit::ObjectType type) + { + uint64_t buf_size = 100 *sizeof(rabbit::Char); + scsprintf(_get_shared_state(v)->getScratchPad(buf_size), buf_size, _SC("unexpected type %s"), IdType2Name(type)); + return sq_throwerror(v, _get_shared_state(v)->getScratchPad(-1)); + } } - -rabbit::VirtualMachine* sq_open(int64_t initialstacksize) +rabbit::VirtualMachine* rabbit::sq_open(int64_t initialstacksize) { rabbit::SharedState *ss; sq_new(ss, rabbit::SharedState); @@ -65,7 +76,7 @@ rabbit::VirtualMachine* sq_open(int64_t initialstacksize) return v; } -rabbit::VirtualMachine* sq_newthread(rabbit::VirtualMachine* friendvm, int64_t initialstacksize) +rabbit::VirtualMachine* rabbit::sq_newthread(rabbit::VirtualMachine* friendvm, int64_t initialstacksize) { rabbit::SharedState *ss; ss=_get_shared_state(friendvm); @@ -84,7 +95,7 @@ rabbit::VirtualMachine* sq_newthread(rabbit::VirtualMachine* friendvm, int64_t i } } -int64_t sq_getvmstate(rabbit::VirtualMachine* v) +int64_t rabbit::sq_getvmstate(rabbit::VirtualMachine* v) { if(v->_suspended) return SQ_VMSTATE_SUSPENDED; @@ -94,7 +105,7 @@ int64_t sq_getvmstate(rabbit::VirtualMachine* v) } } -void sq_seterrorhandler(rabbit::VirtualMachine* v) +void rabbit::sq_seterrorhandler(rabbit::VirtualMachine* v) { rabbit::Object o = stack_get(v, -1); if(sq_isclosure(o) || sq_isnativeclosure(o) || sq_isnull(o)) { @@ -103,14 +114,14 @@ void sq_seterrorhandler(rabbit::VirtualMachine* v) } } -void sq_setnativedebughook(rabbit::VirtualMachine* v,SQDEBUGHOOK hook) +void rabbit::sq_setnativedebughook(rabbit::VirtualMachine* v,SQDEBUGHOOK hook) { v->_debughook_native = hook; v->_debughook_closure.Null(); v->_debughook = hook?true:false; } -void sq_setdebughook(rabbit::VirtualMachine* v) +void rabbit::sq_setdebughook(rabbit::VirtualMachine* v) { rabbit::Object o = stack_get(v,-1); if(sq_isclosure(o) || sq_isnativeclosure(o) || sq_isnull(o)) { @@ -121,19 +132,19 @@ void sq_setdebughook(rabbit::VirtualMachine* v) } } -void sq_close(rabbit::VirtualMachine* v) +void rabbit::sq_close(rabbit::VirtualMachine* v) { rabbit::SharedState *ss = _get_shared_state(v); _thread(ss->_root_vm)->finalize(); - sq_delete(ss, rabbit::SharedState); + sq_delete(ss, SharedState); } -int64_t sq_getversion() +int64_t rabbit::sq_getversion() { return RABBIT_VERSION_NUMBER; } -rabbit::Result sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::UserPointer p,const rabbit::Char *sourcename,rabbit::Bool raiseerror) +rabbit::Result rabbit::sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::UserPointer p,const rabbit::Char *sourcename,rabbit::Bool raiseerror) { rabbit::ObjectPtr o; #ifndef NO_COMPILER @@ -147,29 +158,29 @@ rabbit::Result sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::U #endif } -void sq_enabledebuginfo(rabbit::VirtualMachine* v, rabbit::Bool enable) +void rabbit::sq_enabledebuginfo(rabbit::VirtualMachine* v, rabbit::Bool enable) { _get_shared_state(v)->_debuginfo = enable?true:false; } -void sq_notifyallexceptions(rabbit::VirtualMachine* v, rabbit::Bool enable) +void rabbit::sq_notifyallexceptions(rabbit::VirtualMachine* v, rabbit::Bool enable) { _get_shared_state(v)->_notifyallexceptions = enable?true:false; } -void sq_addref(rabbit::VirtualMachine* v,rabbit::Object *po) +void rabbit::sq_addref(rabbit::VirtualMachine* v,rabbit::Object *po) { if(!ISREFCOUNTED(sq_type(*po))) return; __addRef(po->_type,po->_unVal); } -uint64_t sq_getrefcount(rabbit::VirtualMachine* v,rabbit::Object *po) +uint64_t rabbit::sq_getrefcount(rabbit::VirtualMachine* v,rabbit::Object *po) { if(!ISREFCOUNTED(sq_type(*po))) return 0; return po->_unVal.pRefCounted->refCountget(); } -rabbit::Bool sq_release(rabbit::VirtualMachine* v,rabbit::Object *po) +rabbit::Bool rabbit::sq_release(rabbit::VirtualMachine* v,rabbit::Object *po) { if(!ISREFCOUNTED(sq_type(*po))) return SQTrue; bool ret = (po->_unVal.pRefCounted->refCountget() <= 1) ? SQTrue : SQFalse; @@ -177,13 +188,13 @@ rabbit::Bool sq_release(rabbit::VirtualMachine* v,rabbit::Object *po) return ret; //the ret val doesn't work(and cannot be fixed) } -uint64_t sq_getvmrefcount(rabbit::VirtualMachine* SQ_UNUSED_ARG(v), const rabbit::Object *po) +uint64_t rabbit::sq_getvmrefcount(rabbit::VirtualMachine* SQ_UNUSED_ARG(v), const rabbit::Object *po) { if (!ISREFCOUNTED(sq_type(*po))) return 0; return po->_unVal.pRefCounted->refCountget(); } -const rabbit::Char *sq_objtostring(const rabbit::Object *o) +const rabbit::Char * rabbit::sq_objtostring(const rabbit::Object *o) { if(sq_type(*o) == rabbit::OT_STRING) { return _stringval(*o); @@ -191,7 +202,7 @@ const rabbit::Char *sq_objtostring(const rabbit::Object *o) return NULL; } -int64_t sq_objtointeger(const rabbit::Object *o) +int64_t rabbit::sq_objtointeger(const rabbit::Object *o) { if(sq_isnumeric(*o)) { return tointeger(*o); @@ -199,7 +210,7 @@ int64_t sq_objtointeger(const rabbit::Object *o) return 0; } -float_t sq_objtofloat(const rabbit::Object *o) +float_t rabbit::sq_objtofloat(const rabbit::Object *o) { if(sq_isnumeric(*o)) { return tofloat(*o); @@ -207,7 +218,7 @@ float_t sq_objtofloat(const rabbit::Object *o) return 0; } -rabbit::Bool sq_objtobool(const rabbit::Object *o) +rabbit::Bool rabbit::sq_objtobool(const rabbit::Object *o) { if(sq_isbool(*o)) { return _integer(*o); @@ -215,7 +226,7 @@ rabbit::Bool sq_objtobool(const rabbit::Object *o) return SQFalse; } -rabbit::UserPointer sq_objtouserpointer(const rabbit::Object *o) +rabbit::UserPointer rabbit::sq_objtouserpointer(const rabbit::Object *o) { if(sq_isuserpointer(*o)) { return _userpointer(*o); @@ -223,66 +234,66 @@ rabbit::UserPointer sq_objtouserpointer(const rabbit::Object *o) return 0; } -void sq_pushnull(rabbit::VirtualMachine* v) +void rabbit::sq_pushnull(rabbit::VirtualMachine* v) { v->pushNull(); } -void sq_pushstring(rabbit::VirtualMachine* v,const rabbit::Char *s,int64_t len) +void rabbit::sq_pushstring(rabbit::VirtualMachine* v,const rabbit::Char *s,int64_t len) { if(s) v->push(rabbit::ObjectPtr(rabbit::String::create(_get_shared_state(v), s, len))); else v->pushNull(); } -void sq_pushinteger(rabbit::VirtualMachine* v,int64_t n) +void rabbit::sq_pushinteger(rabbit::VirtualMachine* v,int64_t n) { v->push(n); } -void sq_pushbool(rabbit::VirtualMachine* v,rabbit::Bool b) +void rabbit::sq_pushbool(rabbit::VirtualMachine* v,rabbit::Bool b) { v->push(b?true:false); } -void sq_pushfloat(rabbit::VirtualMachine* v,float_t n) +void rabbit::sq_pushfloat(rabbit::VirtualMachine* v,float_t n) { v->push(n); } -void sq_pushuserpointer(rabbit::VirtualMachine* v,rabbit::UserPointer p) +void rabbit::sq_pushuserpointer(rabbit::VirtualMachine* v,rabbit::UserPointer p) { v->push(p); } -void sq_pushthread(rabbit::VirtualMachine* v, rabbit::VirtualMachine* thread) +void rabbit::sq_pushthread(rabbit::VirtualMachine* v, rabbit::VirtualMachine* thread) { v->push(thread); } -rabbit::UserPointer sq_newuserdata(rabbit::VirtualMachine* v,uint64_t size) +rabbit::UserPointer rabbit::sq_newuserdata(rabbit::VirtualMachine* v,uint64_t size) { rabbit::UserData *ud = rabbit::UserData::create(_get_shared_state(v), size + SQ_ALIGNMENT); v->push(ud); return (rabbit::UserPointer)sq_aligning(ud + 1); } -void sq_newtable(rabbit::VirtualMachine* v) +void rabbit::sq_newtable(rabbit::VirtualMachine* v) { v->push(rabbit::Table::create(_get_shared_state(v), 0)); } -void sq_newtableex(rabbit::VirtualMachine* v,int64_t initialcapacity) +void rabbit::sq_newtableex(rabbit::VirtualMachine* v,int64_t initialcapacity) { v->push(rabbit::Table::create(_get_shared_state(v), initialcapacity)); } -void sq_newarray(rabbit::VirtualMachine* v,int64_t size) +void rabbit::sq_newarray(rabbit::VirtualMachine* v,int64_t size) { v->push(rabbit::Array::create(_get_shared_state(v), size)); } -rabbit::Result sq_newclass(rabbit::VirtualMachine* v,rabbit::Bool hasbase) +rabbit::Result rabbit::sq_newclass(rabbit::VirtualMachine* v,rabbit::Bool hasbase) { rabbit::Class *baseclass = NULL; if(hasbase) { @@ -297,7 +308,7 @@ rabbit::Result sq_newclass(rabbit::VirtualMachine* v,rabbit::Bool hasbase) return SQ_OK; } -rabbit::Bool sq_instanceof(rabbit::VirtualMachine* v) +rabbit::Bool rabbit::sq_instanceof(rabbit::VirtualMachine* v) { rabbit::ObjectPtr &inst = stack_get(v,-1); rabbit::ObjectPtr &cl = stack_get(v,-2); @@ -307,7 +318,7 @@ rabbit::Bool sq_instanceof(rabbit::VirtualMachine* v) return _instance(inst)->instanceOf(_class(cl))?SQTrue:SQFalse; } -rabbit::Result sq_arrayappend(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_arrayappend(rabbit::VirtualMachine* v,int64_t idx) { sq_aux_paramscheck(v,2); rabbit::ObjectPtr *arr; @@ -317,7 +328,7 @@ rabbit::Result sq_arrayappend(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -rabbit::Result sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval) +rabbit::Result rabbit::sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval) { sq_aux_paramscheck(v, 1); rabbit::ObjectPtr *arr; @@ -332,7 +343,7 @@ rabbit::Result sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pu return sq_throwerror(v, _SC("empty array")); } -rabbit::Result sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t newsize) +rabbit::Result rabbit::sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t newsize) { sq_aux_paramscheck(v,1); rabbit::ObjectPtr *arr; @@ -345,7 +356,7 @@ rabbit::Result sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t news } -rabbit::Result sq_arrayreverse(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_arrayreverse(rabbit::VirtualMachine* v,int64_t idx) { sq_aux_paramscheck(v, 1); rabbit::ObjectPtr *o; @@ -366,7 +377,7 @@ rabbit::Result sq_arrayreverse(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -rabbit::Result sq_arrayremove(rabbit::VirtualMachine* v,int64_t idx,int64_t itemidx) +rabbit::Result rabbit::sq_arrayremove(rabbit::VirtualMachine* v,int64_t idx,int64_t itemidx) { sq_aux_paramscheck(v, 1); rabbit::ObjectPtr *arr; @@ -374,7 +385,7 @@ rabbit::Result sq_arrayremove(rabbit::VirtualMachine* v,int64_t idx,int64_t item return _array(*arr)->remove(itemidx) ? SQ_OK : sq_throwerror(v,_SC("index out of range")); } -rabbit::Result sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int64_t destpos) +rabbit::Result rabbit::sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int64_t destpos) { sq_aux_paramscheck(v, 1); rabbit::ObjectPtr *arr; @@ -384,7 +395,7 @@ rabbit::Result sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int64_t dest return ret; } -void sq_newclosure(rabbit::VirtualMachine* v,SQFUNCTION func,uint64_t nfreevars) +void rabbit::sq_newclosure(rabbit::VirtualMachine* v,SQFUNCTION func,uint64_t nfreevars) { rabbit::NativeClosure *nc = rabbit::NativeClosure::create(_get_shared_state(v), func,nfreevars); nc->_nparamscheck = 0; @@ -395,7 +406,7 @@ void sq_newclosure(rabbit::VirtualMachine* v,SQFUNCTION func,uint64_t nfreevars) v->push(rabbit::ObjectPtr(nc)); } -rabbit::Result sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,uint64_t *nparams,uint64_t *nfreevars) +rabbit::Result rabbit::sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,uint64_t *nparams,uint64_t *nfreevars) { rabbit::Object o = stack_get(v, idx); if(sq_type(o) == rabbit::OT_CLOSURE) { @@ -415,7 +426,7 @@ rabbit::Result sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,uint64_t return sq_throwerror(v,_SC("the object is not a closure")); } -rabbit::Result sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char *name) +rabbit::Result rabbit::sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char *name) { rabbit::Object o = stack_get(v, idx); if(sq_isnativeclosure(o)) { @@ -426,7 +437,7 @@ rabbit::Result sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,con return sq_throwerror(v,_SC("the object is not a nativeclosure")); } -rabbit::Result sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const rabbit::Char *typemask) +rabbit::Result rabbit::sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const rabbit::Char *typemask) { rabbit::Object o = stack_get(v, -1); if(!sq_isnativeclosure(o)) @@ -448,7 +459,7 @@ rabbit::Result sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck, return SQ_OK; } -rabbit::Result sq_bindenv(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_bindenv(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &o = stack_get(v,idx); if(!sq_isnativeclosure(o) && @@ -485,7 +496,7 @@ rabbit::Result sq_bindenv(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -rabbit::Result sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &o = stack_get(v,idx); if(!sq_isnativeclosure(o) && @@ -501,7 +512,7 @@ rabbit::Result sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -rabbit::Result sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &c = stack_get(v,idx); rabbit::Object o = stack_get(v, -1); @@ -514,7 +525,7 @@ rabbit::Result sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx) return sq_throwerror(v, _SC("invalid type")); } -rabbit::Result sq_getclosureroot(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_getclosureroot(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &c = stack_get(v,idx); if(!sq_isclosure(c)) return sq_throwerror(v, _SC("closure expected")); @@ -522,7 +533,7 @@ rabbit::Result sq_getclosureroot(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -rabbit::Result sq_clear(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_clear(rabbit::VirtualMachine* v,int64_t idx) { rabbit::Object &o=stack_get(v,idx); switch(sq_type(o)) { @@ -536,22 +547,22 @@ rabbit::Result sq_clear(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -void sq_pushroottable(rabbit::VirtualMachine* v) +void rabbit::sq_pushroottable(rabbit::VirtualMachine* v) { v->push(v->_roottable); } -void sq_pushregistrytable(rabbit::VirtualMachine* v) +void rabbit::sq_pushregistrytable(rabbit::VirtualMachine* v) { v->push(_get_shared_state(v)->_registry); } -void sq_pushconsttable(rabbit::VirtualMachine* v) +void rabbit::sq_pushconsttable(rabbit::VirtualMachine* v) { v->push(_get_shared_state(v)->_consts); } -rabbit::Result sq_setroottable(rabbit::VirtualMachine* v) +rabbit::Result rabbit::sq_setroottable(rabbit::VirtualMachine* v) { rabbit::Object o = stack_get(v, -1); if(sq_istable(o) || sq_isnull(o)) { @@ -562,7 +573,7 @@ rabbit::Result sq_setroottable(rabbit::VirtualMachine* v) return sq_throwerror(v, _SC("invalid type")); } -rabbit::Result sq_setconsttable(rabbit::VirtualMachine* v) +rabbit::Result rabbit::sq_setconsttable(rabbit::VirtualMachine* v) { rabbit::Object o = stack_get(v, -1); if(sq_istable(o)) { @@ -573,57 +584,57 @@ rabbit::Result sq_setconsttable(rabbit::VirtualMachine* v) return sq_throwerror(v, _SC("invalid type, expected table")); } -void sq_setforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p) +void rabbit::sq_setforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p) { v->_foreignptr = p; } -rabbit::UserPointer sq_getforeignptr(rabbit::VirtualMachine* v) +rabbit::UserPointer rabbit::sq_getforeignptr(rabbit::VirtualMachine* v) { return v->_foreignptr; } -void sq_setsharedforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p) +void rabbit::sq_setsharedforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p) { _get_shared_state(v)->_foreignptr = p; } -rabbit::UserPointer sq_getsharedforeignptr(rabbit::VirtualMachine* v) +rabbit::UserPointer rabbit::sq_getsharedforeignptr(rabbit::VirtualMachine* v) { return _get_shared_state(v)->_foreignptr; } -void sq_setvmreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook) +void rabbit::sq_setvmreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook) { v->_releasehook = hook; } -SQRELEASEHOOK sq_getvmreleasehook(rabbit::VirtualMachine* v) +SQRELEASEHOOK rabbit::sq_getvmreleasehook(rabbit::VirtualMachine* v) { return v->_releasehook; } -void sq_setsharedreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook) +void rabbit::sq_setsharedreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook) { _get_shared_state(v)->_releasehook = hook; } -SQRELEASEHOOK sq_getsharedreleasehook(rabbit::VirtualMachine* v) +SQRELEASEHOOK rabbit::sq_getsharedreleasehook(rabbit::VirtualMachine* v) { return _get_shared_state(v)->_releasehook; } -void sq_push(rabbit::VirtualMachine* v,int64_t idx) +void rabbit::sq_push(rabbit::VirtualMachine* v,int64_t idx) { v->push(stack_get(v, idx)); } -rabbit::ObjectType sq_gettype(rabbit::VirtualMachine* v,int64_t idx) +rabbit::ObjectType rabbit::sq_gettype(rabbit::VirtualMachine* v,int64_t idx) { return sq_type(stack_get(v, idx)); } -rabbit::Result sq_typeof(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_typeof(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &o = stack_get(v, idx); rabbit::ObjectPtr res; @@ -634,7 +645,7 @@ rabbit::Result sq_typeof(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -rabbit::Result sq_tostring(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_tostring(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &o = stack_get(v, idx); rabbit::ObjectPtr res; @@ -645,13 +656,13 @@ rabbit::Result sq_tostring(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -void sq_tobool(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool *b) +void rabbit::sq_tobool(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool *b) { rabbit::ObjectPtr &o = stack_get(v, idx); *b = rabbit::VirtualMachine::IsFalse(o)?SQFalse:SQTrue; } -rabbit::Result sq_getinteger(rabbit::VirtualMachine* v,int64_t idx,int64_t *i) +rabbit::Result rabbit::sq_getinteger(rabbit::VirtualMachine* v,int64_t idx,int64_t *i) { rabbit::ObjectPtr &o = stack_get(v, idx); if(sq_isnumeric(o)) { @@ -665,7 +676,7 @@ rabbit::Result sq_getinteger(rabbit::VirtualMachine* v,int64_t idx,int64_t *i) return SQ_ERROR; } -rabbit::Result sq_getfloat(rabbit::VirtualMachine* v,int64_t idx,float_t *f) +rabbit::Result rabbit::sq_getfloat(rabbit::VirtualMachine* v,int64_t idx,float_t *f) { rabbit::ObjectPtr &o = stack_get(v, idx); if(sq_isnumeric(o)) { @@ -675,7 +686,7 @@ rabbit::Result sq_getfloat(rabbit::VirtualMachine* v,int64_t idx,float_t *f) return SQ_ERROR; } -rabbit::Result sq_getbool(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool *b) +rabbit::Result rabbit::sq_getbool(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool *b) { rabbit::ObjectPtr &o = stack_get(v, idx); if(sq_isbool(o)) { @@ -685,7 +696,7 @@ rabbit::Result sq_getbool(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool *b) return SQ_ERROR; } -rabbit::Result sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c,int64_t *size) +rabbit::Result rabbit::sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c,int64_t *size) { rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, rabbit::OT_STRING,o); @@ -694,7 +705,7 @@ rabbit::Result sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const r return SQ_OK; } -rabbit::Result sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c) +rabbit::Result rabbit::sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c) { rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, rabbit::OT_STRING,o); @@ -702,7 +713,7 @@ rabbit::Result sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const rabbit:: return SQ_OK; } -rabbit::Result sq_getthread(rabbit::VirtualMachine* v,int64_t idx,rabbit::VirtualMachine* *thread) +rabbit::Result rabbit::sq_getthread(rabbit::VirtualMachine* v,int64_t idx,rabbit::VirtualMachine* *thread) { rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, rabbit::OT_THREAD,o); @@ -710,7 +721,7 @@ rabbit::Result sq_getthread(rabbit::VirtualMachine* v,int64_t idx,rabbit::Virtua return SQ_OK; } -rabbit::Result sq_clone(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_clone(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &o = stack_get(v,idx); v->pushNull(); @@ -721,7 +732,7 @@ rabbit::Result sq_clone(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -int64_t sq_getsize(rabbit::VirtualMachine* v, int64_t idx) +int64_t rabbit::sq_getsize(rabbit::VirtualMachine* v, int64_t idx) { rabbit::ObjectPtr &o = stack_get(v, idx); rabbit::ObjectType type = sq_type(o); @@ -737,13 +748,13 @@ int64_t sq_getsize(rabbit::VirtualMachine* v, int64_t idx) } } -rabbit::Hash sq_gethash(rabbit::VirtualMachine* v, int64_t idx) +rabbit::Hash rabbit::sq_gethash(rabbit::VirtualMachine* v, int64_t idx) { rabbit::ObjectPtr &o = stack_get(v, idx); return HashObj(o); } -rabbit::Result sq_getuserdata(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *p,rabbit::UserPointer *typetag) +rabbit::Result rabbit::sq_getuserdata(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *p,rabbit::UserPointer *typetag) { rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, rabbit::OT_USERDATA,o); @@ -754,7 +765,7 @@ rabbit::Result sq_getuserdata(rabbit::VirtualMachine* v,int64_t idx,rabbit::User return SQ_OK; } -rabbit::Result sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer typetag) +rabbit::Result rabbit::sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer typetag) { rabbit::ObjectPtr &o = stack_get(v,idx); switch(sq_type(o)) { @@ -770,7 +781,7 @@ rabbit::Result sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserP return SQ_OK; } -rabbit::Result sq_getobjtypetag(const rabbit::Object *o,rabbit::UserPointer * typetag) +rabbit::Result rabbit::sq_getobjtypetag(const rabbit::Object *o,rabbit::UserPointer * typetag) { switch(sq_type(*o)) { case rabbit::OT_INSTANCE: *typetag = _instance(*o)->_class->_typetag; break; @@ -781,7 +792,7 @@ rabbit::Result sq_getobjtypetag(const rabbit::Object *o,rabbit::UserPointer * ty return SQ_OK; } -rabbit::Result sq_gettypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *typetag) +rabbit::Result rabbit::sq_gettypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *typetag) { rabbit::ObjectPtr &o = stack_get(v,idx); if (SQ_FAILED(sq_getobjtypetag(&o, typetag))) @@ -789,7 +800,7 @@ rabbit::Result sq_gettypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserP return SQ_OK; } -rabbit::Result sq_getuserpointer(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p) +rabbit::Result rabbit::sq_getuserpointer(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p) { rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, rabbit::OT_USERPOINTER,o); @@ -797,7 +808,7 @@ rabbit::Result sq_getuserpointer(rabbit::VirtualMachine* v, int64_t idx, rabbit: return SQ_OK; } -rabbit::Result sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer p) +rabbit::Result rabbit::sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer p) { rabbit::ObjectPtr &o = stack_get(v,idx); if(sq_type(o) != rabbit::OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance")); @@ -805,7 +816,7 @@ rabbit::Result sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit:: return SQ_OK; } -rabbit::Result sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize) +rabbit::Result rabbit::sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize) { rabbit::ObjectPtr &o = stack_get(v,idx); if(sq_type(o) != rabbit::OT_CLASS) return sq_throwerror(v,_SC("the object is not a class")); @@ -815,7 +826,7 @@ rabbit::Result sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t } -rabbit::Result sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p,rabbit::UserPointer typetag) +rabbit::Result rabbit::sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p,rabbit::UserPointer typetag) { rabbit::ObjectPtr &o = stack_get(v,idx); if(sq_type(o) != rabbit::OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance")); @@ -832,12 +843,12 @@ rabbit::Result sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit:: return SQ_OK; } -int64_t sq_gettop(rabbit::VirtualMachine* v) +int64_t rabbit::sq_gettop(rabbit::VirtualMachine* v) { return (v->_top) - v->_stackbase; } -void sq_settop(rabbit::VirtualMachine* v, int64_t newtop) +void rabbit::sq_settop(rabbit::VirtualMachine* v, int64_t newtop) { int64_t top = sq_gettop(v); if(top > newtop) @@ -846,32 +857,32 @@ void sq_settop(rabbit::VirtualMachine* v, int64_t newtop) while(top++ < newtop) sq_pushnull(v); } -void sq_pop(rabbit::VirtualMachine* v, int64_t nelemstopop) +void rabbit::sq_pop(rabbit::VirtualMachine* v, int64_t nelemstopop) { assert(v->_top >= nelemstopop); v->pop(nelemstopop); } -void sq_poptop(rabbit::VirtualMachine* v) +void rabbit::sq_poptop(rabbit::VirtualMachine* v) { assert(v->_top >= 1); v->pop(); } -void sq_remove(rabbit::VirtualMachine* v, int64_t idx) +void rabbit::sq_remove(rabbit::VirtualMachine* v, int64_t idx) { v->remove(idx); } -int64_t sq_cmp(rabbit::VirtualMachine* v) +int64_t rabbit::sq_cmp(rabbit::VirtualMachine* v) { int64_t res; v->objCmp(stack_get(v, -1), stack_get(v, -2),res); return res; } -rabbit::Result sq_newslot(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool bstatic) +rabbit::Result rabbit::sq_newslot(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool bstatic) { sq_aux_paramscheck(v, 3); rabbit::ObjectPtr &self = stack_get(v, idx); @@ -884,7 +895,7 @@ rabbit::Result sq_newslot(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool b return SQ_OK; } -rabbit::Result sq_deleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval) +rabbit::Result rabbit::sq_deleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval) { sq_aux_paramscheck(v, 2); rabbit::ObjectPtr *self; @@ -901,7 +912,7 @@ rabbit::Result sq_deleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool return SQ_OK; } -rabbit::Result sq_set(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_set(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &self = stack_get(v, idx); if(v->set(self, v->getUp(-2), v->getUp(-1),DONT_FALL_BACK)) { @@ -911,7 +922,7 @@ rabbit::Result sq_set(rabbit::VirtualMachine* v,int64_t idx) return SQ_ERROR; } -rabbit::Result sq_rawset(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_rawset(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &self = stack_get(v, idx); rabbit::ObjectPtr &key = v->getUp(-2); @@ -949,7 +960,7 @@ rabbit::Result sq_rawset(rabbit::VirtualMachine* v,int64_t idx) v->raise_Idxerror(v->getUp(-2));return SQ_ERROR; } -rabbit::Result sq_newmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic) +rabbit::Result rabbit::sq_newmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic) { rabbit::ObjectPtr &self = stack_get(v, idx); if(sq_type(self) != rabbit::OT_CLASS) return sq_throwerror(v, _SC("new member only works with classes")); @@ -963,7 +974,7 @@ rabbit::Result sq_newmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool b return SQ_OK; } -rabbit::Result sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic) +rabbit::Result rabbit::sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic) { rabbit::ObjectPtr &self = stack_get(v, idx); if(sq_type(self) != rabbit::OT_CLASS) return sq_throwerror(v, _SC("new member only works with classes")); @@ -977,7 +988,7 @@ rabbit::Result sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Boo return SQ_OK; } -rabbit::Result sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &self = stack_get(v, idx); rabbit::ObjectPtr &mt = v->getUp(-1); @@ -1008,7 +1019,7 @@ rabbit::Result sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -rabbit::Result sq_rawdeleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval) +rabbit::Result rabbit::sq_rawdeleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval) { sq_aux_paramscheck(v, 2); rabbit::ObjectPtr *self; @@ -1025,7 +1036,7 @@ rabbit::Result sq_rawdeleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bo return SQ_OK; } -rabbit::Result sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &self=stack_get(v,idx); switch(sq_type(self)){ @@ -1043,7 +1054,7 @@ rabbit::Result sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx) } -rabbit::Result sq_get(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_get(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &self=stack_get(v,idx); rabbit::ObjectPtr &obj = v->getUp(-1); @@ -1053,7 +1064,7 @@ rabbit::Result sq_get(rabbit::VirtualMachine* v,int64_t idx) return SQ_ERROR; } -rabbit::Result sq_rawget(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_rawget(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &self=stack_get(v,idx); rabbit::ObjectPtr &obj = v->getUp(-1); @@ -1090,13 +1101,13 @@ rabbit::Result sq_rawget(rabbit::VirtualMachine* v,int64_t idx) return sq_throwerror(v,_SC("the index doesn't exist")); } -rabbit::Result sq_getstackobj(rabbit::VirtualMachine* v,int64_t idx,rabbit::Object *po) +rabbit::Result rabbit::sq_getstackobj(rabbit::VirtualMachine* v,int64_t idx,rabbit::Object *po) { *po=stack_get(v,idx); return SQ_OK; } -const rabbit::Char *sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx) +const rabbit::Char * rabbit::sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx) { uint64_t cstksize=v->_callsstacksize; uint64_t lvl=(cstksize-level)-1; @@ -1121,23 +1132,23 @@ const rabbit::Char *sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_ return NULL; } -void sq_pushobject(rabbit::VirtualMachine* v,rabbit::Object obj) +void rabbit::sq_pushobject(rabbit::VirtualMachine* v,rabbit::Object obj) { v->push(rabbit::ObjectPtr(obj)); } -void sq_resetobject(rabbit::Object *po) +void rabbit::sq_resetobject(rabbit::Object *po) { po->_unVal.pUserPointer=NULL;po->_type=rabbit::OT_NULL; } -rabbit::Result sq_throwerror(rabbit::VirtualMachine* v,const rabbit::Char *err) +rabbit::Result rabbit::sq_throwerror(rabbit::VirtualMachine* v,const rabbit::Char *err) { v->_lasterror=rabbit::String::create(_get_shared_state(v),err); return SQ_ERROR; } -rabbit::Result sq_throwobject(rabbit::VirtualMachine* v) +rabbit::Result rabbit::sq_throwobject(rabbit::VirtualMachine* v) { v->_lasterror = v->getUp(-1); v->pop(); @@ -1145,17 +1156,17 @@ rabbit::Result sq_throwobject(rabbit::VirtualMachine* v) } -void sq_reseterror(rabbit::VirtualMachine* v) +void rabbit::sq_reseterror(rabbit::VirtualMachine* v) { v->_lasterror.Null(); } -void sq_getlasterror(rabbit::VirtualMachine* v) +void rabbit::sq_getlasterror(rabbit::VirtualMachine* v) { v->push(v->_lasterror); } -rabbit::Result sq_reservestack(rabbit::VirtualMachine* v,int64_t nsize) +rabbit::Result rabbit::sq_reservestack(rabbit::VirtualMachine* v,int64_t nsize) { if (((uint64_t)v->_top + nsize) > v->_stack.size()) { if(v->_nmetamethodscall) { @@ -1166,7 +1177,7 @@ rabbit::Result sq_reservestack(rabbit::VirtualMachine* v,int64_t nsize) return SQ_OK; } -rabbit::Result sq_resume(rabbit::VirtualMachine* v,rabbit::Bool retval,rabbit::Bool raiseerror) +rabbit::Result rabbit::sq_resume(rabbit::VirtualMachine* v,rabbit::Bool retval,rabbit::Bool raiseerror) { if (sq_type(v->getUp(-1)) == rabbit::OT_GENERATOR) { @@ -1180,7 +1191,7 @@ rabbit::Result sq_resume(rabbit::VirtualMachine* v,rabbit::Bool retval,rabbit::B return sq_throwerror(v,_SC("only generators can be resumed")); } -rabbit::Result sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::Bool retval,rabbit::Bool raiseerror) +rabbit::Result rabbit::sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::Bool retval,rabbit::Bool raiseerror) { rabbit::ObjectPtr res; if(v->call(v->getUp(-(params+1)),params,v->_top-params,res,raiseerror?true:false)){ @@ -1202,7 +1213,7 @@ rabbit::Result sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::Bool ret return sq_throwerror(v,_SC("call failed")); } -rabbit::Result sq_tailcall(rabbit::VirtualMachine* v, int64_t nparams) +rabbit::Result rabbit::sq_tailcall(rabbit::VirtualMachine* v, int64_t nparams) { rabbit::ObjectPtr &res = v->getUp(-(nparams + 1)); if (sq_type(res) != rabbit::OT_CLOSURE) { @@ -1221,12 +1232,12 @@ rabbit::Result sq_tailcall(rabbit::VirtualMachine* v, int64_t nparams) return SQ_TAILCALL_FLAG; } -rabbit::Result sq_suspendvm(rabbit::VirtualMachine* v) +rabbit::Result rabbit::sq_suspendvm(rabbit::VirtualMachine* v) { return v->Suspend(); } -rabbit::Result sq_wakeupvm(rabbit::VirtualMachine* v,rabbit::Bool wakeupret,rabbit::Bool retval,rabbit::Bool raiseerror,rabbit::Bool throwerror) +rabbit::Result rabbit::sq_wakeupvm(rabbit::VirtualMachine* v,rabbit::Bool wakeupret,rabbit::Bool retval,rabbit::Bool raiseerror,rabbit::Bool throwerror) { rabbit::ObjectPtr ret; if(!v->_suspended) @@ -1248,7 +1259,7 @@ rabbit::Result sq_wakeupvm(rabbit::VirtualMachine* v,rabbit::Bool wakeupret,rabb return SQ_OK; } -void sq_setreleasehook(rabbit::VirtualMachine* v,int64_t idx,SQRELEASEHOOK hook) +void rabbit::sq_setreleasehook(rabbit::VirtualMachine* v,int64_t idx,SQRELEASEHOOK hook) { rabbit::ObjectPtr &ud=stack_get(v,idx); switch(sq_type(ud) ) { @@ -1266,7 +1277,7 @@ void sq_setreleasehook(rabbit::VirtualMachine* v,int64_t idx,SQRELEASEHOOK hook) } } -SQRELEASEHOOK sq_getreleasehook(rabbit::VirtualMachine* v,int64_t idx) +SQRELEASEHOOK rabbit::sq_getreleasehook(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &ud=stack_get(v,idx); switch(sq_type(ud) ) { @@ -1284,12 +1295,12 @@ SQRELEASEHOOK sq_getreleasehook(rabbit::VirtualMachine* v,int64_t idx) } } -void sq_setcompilererrorhandler(rabbit::VirtualMachine* v,SQCOMPILERERROR f) +void rabbit::sq_setcompilererrorhandler(rabbit::VirtualMachine* v,SQCOMPILERERROR f) { _get_shared_state(v)->_compilererrorhandler = f; } -rabbit::Result sq_writeclosure(rabbit::VirtualMachine* v,SQWRITEFUNC w,rabbit::UserPointer up) +rabbit::Result rabbit::sq_writeclosure(rabbit::VirtualMachine* v,SQWRITEFUNC w,rabbit::UserPointer up) { rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, -1, rabbit::OT_CLOSURE,o); @@ -1303,7 +1314,7 @@ rabbit::Result sq_writeclosure(rabbit::VirtualMachine* v,SQWRITEFUNC w,rabbit::U return SQ_OK; } -rabbit::Result sq_readclosure(rabbit::VirtualMachine* v,SQREADFUNC r,rabbit::UserPointer up) +rabbit::Result rabbit::sq_readclosure(rabbit::VirtualMachine* v,SQREADFUNC r,rabbit::UserPointer up) { rabbit::ObjectPtr closure; @@ -1318,23 +1329,23 @@ rabbit::Result sq_readclosure(rabbit::VirtualMachine* v,SQREADFUNC r,rabbit::Use return SQ_OK; } -rabbit::Char *sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize) +rabbit::Char * rabbit::sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize) { return _get_shared_state(v)->getScratchPad(minsize); } -rabbit::Result sq_resurrectunreachable(rabbit::VirtualMachine* v) +rabbit::Result rabbit::sq_resurrectunreachable(rabbit::VirtualMachine* v) { return sq_throwerror(v,_SC("sq_resurrectunreachable requires a garbage collector build")); } // TODO: remove this... -int64_t sq_collectgarbage(rabbit::VirtualMachine* v) +int64_t rabbit::sq_collectgarbage(rabbit::VirtualMachine* v) { return -1; } -rabbit::Result sq_getcallee(rabbit::VirtualMachine* v) +rabbit::Result rabbit::sq_getcallee(rabbit::VirtualMachine* v) { if(v->_callsstacksize > 1) { @@ -1344,7 +1355,7 @@ rabbit::Result sq_getcallee(rabbit::VirtualMachine* v) return sq_throwerror(v,_SC("no closure in the calls stack")); } -const rabbit::Char *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval) +const rabbit::Char * rabbit::sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval) { rabbit::ObjectPtr &self=stack_get(v,idx); const rabbit::Char *name = NULL; @@ -1373,7 +1384,7 @@ const rabbit::Char *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uin return name; } -rabbit::Result sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval) +rabbit::Result rabbit::sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval) { rabbit::ObjectPtr &self=stack_get(v,idx); switch(sq_type(self)) @@ -1399,7 +1410,7 @@ rabbit::Result sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t return SQ_OK; } -rabbit::Result sq_setattributes(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_setattributes(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, rabbit::OT_CLASS,o); @@ -1421,7 +1432,7 @@ rabbit::Result sq_setattributes(rabbit::VirtualMachine* v,int64_t idx) return sq_throwerror(v,_SC("wrong index")); } -rabbit::Result sq_getattributes(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_getattributes(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, rabbit::OT_CLASS,o); @@ -1441,7 +1452,7 @@ rabbit::Result sq_getattributes(rabbit::VirtualMachine* v,int64_t idx) return sq_throwerror(v,_SC("wrong index")); } -rabbit::Result sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,rabbit::MemberHandle *handle) +rabbit::Result rabbit::sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,rabbit::MemberHandle *handle) { rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, rabbit::OT_CLASS,o); @@ -1488,7 +1499,7 @@ rabbit::Result _getmemberbyhandle(rabbit::VirtualMachine* v,rabbit::ObjectPtr &s return SQ_OK; } -rabbit::Result sq_getbyhandle(rabbit::VirtualMachine* v,int64_t idx,const rabbit::MemberHandle *handle) +rabbit::Result rabbit::sq_getbyhandle(rabbit::VirtualMachine* v,int64_t idx,const rabbit::MemberHandle *handle) { rabbit::ObjectPtr &self = stack_get(v,idx); rabbit::ObjectPtr *val = NULL; @@ -1499,7 +1510,7 @@ rabbit::Result sq_getbyhandle(rabbit::VirtualMachine* v,int64_t idx,const rabbit return SQ_OK; } -rabbit::Result sq_setbyhandle(rabbit::VirtualMachine* v,int64_t idx,const rabbit::MemberHandle *handle) +rabbit::Result rabbit::sq_setbyhandle(rabbit::VirtualMachine* v,int64_t idx,const rabbit::MemberHandle *handle) { rabbit::ObjectPtr &self = stack_get(v,idx); rabbit::ObjectPtr &newval = stack_get(v,-1); @@ -1512,7 +1523,7 @@ rabbit::Result sq_setbyhandle(rabbit::VirtualMachine* v,int64_t idx,const rabbit return SQ_OK; } -rabbit::Result sq_getbase(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_getbase(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, rabbit::OT_CLASS,o); @@ -1523,7 +1534,7 @@ rabbit::Result sq_getbase(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -rabbit::Result sq_getclass(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_getclass(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, rabbit::OT_INSTANCE,o); @@ -1531,7 +1542,7 @@ rabbit::Result sq_getclass(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -rabbit::Result sq_createinstance(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_createinstance(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr *o = NULL; _GETSAFE_OBJ(v, idx, rabbit::OT_CLASS,o); @@ -1539,7 +1550,7 @@ rabbit::Result sq_createinstance(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -void sq_weakref(rabbit::VirtualMachine* v,int64_t idx) +void rabbit::sq_weakref(rabbit::VirtualMachine* v,int64_t idx) { rabbit::Object &o=stack_get(v,idx); if(ISREFCOUNTED(sq_type(o))) { @@ -1549,7 +1560,7 @@ void sq_weakref(rabbit::VirtualMachine* v,int64_t idx) v->push(o); } -rabbit::Result sq_getweakrefval(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_getweakrefval(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr &o = stack_get(v,idx); if(sq_type(o) != rabbit::OT_WEAKREF) { @@ -1559,7 +1570,7 @@ rabbit::Result sq_getweakrefval(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -rabbit::Result sq_getdefaultdelegate(rabbit::VirtualMachine* v,rabbit::ObjectType t) +rabbit::Result rabbit::sq_getdefaultdelegate(rabbit::VirtualMachine* v,rabbit::ObjectType t) { rabbit::SharedState *ss = _get_shared_state(v); switch(t) { @@ -1578,7 +1589,7 @@ rabbit::Result sq_getdefaultdelegate(rabbit::VirtualMachine* v,rabbit::ObjectTyp return SQ_OK; } -rabbit::Result sq_next(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result rabbit::sq_next(rabbit::VirtualMachine* v,int64_t idx) { rabbit::ObjectPtr o=stack_get(v,idx),&refpos = stack_get(v,-1),realkey,val; if(sq_type(o) == rabbit::OT_GENERATOR) { @@ -1595,21 +1606,22 @@ rabbit::Result sq_next(rabbit::VirtualMachine* v,int64_t idx) return SQ_ERROR; } -struct BufState{ - const rabbit::Char *buf; - int64_t ptr; - int64_t size; -}; - -int64_t buf_lexfeed(rabbit::UserPointer file) -{ - BufState *buf=(BufState*)file; - if(buf->size<(buf->ptr+1)) - return 0; - return buf->buf[buf->ptr++]; +namespace rabbit { + struct BufState{ + const rabbit::Char *buf; + int64_t ptr; + int64_t size; + }; + + int64_t buf_lexfeed(rabbit::UserPointer file) + { + BufState *buf=(BufState*)file; + if(buf->size<(buf->ptr+1)) + return 0; + return buf->buf[buf->ptr++]; + } } - -rabbit::Result sq_compilebuffer(rabbit::VirtualMachine* v,const rabbit::Char *s,int64_t size,const rabbit::Char *sourcename,rabbit::Bool raiseerror) { +rabbit::Result rabbit::sq_compilebuffer(rabbit::VirtualMachine* v,const rabbit::Char *s,int64_t size,const rabbit::Char *sourcename,rabbit::Bool raiseerror) { BufState buf; buf.buf = s; buf.size = size; @@ -1617,38 +1629,38 @@ rabbit::Result sq_compilebuffer(rabbit::VirtualMachine* v,const rabbit::Char *s, return sq_compile(v, buf_lexfeed, &buf, sourcename, raiseerror); } -void sq_move(rabbit::VirtualMachine* dest,rabbit::VirtualMachine* src,int64_t idx) +void rabbit::sq_move(rabbit::VirtualMachine* dest,rabbit::VirtualMachine* src,int64_t idx) { dest->push(stack_get(src,idx)); } -void sq_setprintfunc(rabbit::VirtualMachine* v, SQPRINTFUNCTION printfunc,SQPRINTFUNCTION errfunc) +void rabbit::sq_setprintfunc(rabbit::VirtualMachine* v, SQPRINTFUNCTION printfunc,SQPRINTFUNCTION errfunc) { _get_shared_state(v)->_printfunc = printfunc; _get_shared_state(v)->_errorfunc = errfunc; } -SQPRINTFUNCTION sq_getprintfunc(rabbit::VirtualMachine* v) +SQPRINTFUNCTION rabbit::sq_getprintfunc(rabbit::VirtualMachine* v) { return _get_shared_state(v)->_printfunc; } -SQPRINTFUNCTION sq_geterrorfunc(rabbit::VirtualMachine* v) +SQPRINTFUNCTION rabbit::sq_geterrorfunc(rabbit::VirtualMachine* v) { return _get_shared_state(v)->_errorfunc; } -void *sq_malloc(uint64_t size) +void * rabbit::sq_malloc(uint64_t size) { return SQ_MALLOC(size); } -void *sq_realloc(void* p,uint64_t oldsize,uint64_t newsize) +void * rabbit::sq_realloc(void* p,uint64_t oldsize,uint64_t newsize) { return SQ_REALLOC(p,oldsize,newsize); } -void sq_free(void *p,uint64_t size) +void rabbit::sq_free(void *p,uint64_t size) { SQ_FREE(p,size); } diff --git a/rabbit/sqbaselib.cpp b/rabbit/sqbaselib.cpp index d65f424..6c6e5db 100644 --- a/rabbit/sqbaselib.cpp +++ b/rabbit/sqbaselib.cpp @@ -10,8 +10,16 @@ #include -#include -#include +#include + +#include +#include +#include +#include +#include +#include +#include + #include #include diff --git a/rabbit/sqconfig.hpp b/rabbit/sqconfig.hpp index 64cfaf9..1a0a654 100644 --- a/rabbit/sqconfig.hpp +++ b/rabbit/sqconfig.hpp @@ -8,7 +8,7 @@ #pragma once #include - +#include #ifdef SQUSEDOUBLE typedef double float_t; #else diff --git a/rabbit/sqdebug.cpp b/rabbit/sqdebug.cpp index 6123a06..555b63a 100644 --- a/rabbit/sqdebug.cpp +++ b/rabbit/sqdebug.cpp @@ -9,13 +9,20 @@ #include #include -#include -#include + +#include +#include +#include +#include +#include +#include +#include +#include #include #include -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) { diff --git a/rabbit/sqmem.cpp b/rabbit/sqmem.cpp index ab064a0..b92b86e 100644 --- a/rabbit/sqmem.cpp +++ b/rabbit/sqmem.cpp @@ -6,12 +6,13 @@ * @license MPL-2 (see license file) */ +#include #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 diff --git a/rabbit/squtils.hpp b/rabbit/squtils.hpp index e2502ff..174038d 100644 --- a/rabbit/squtils.hpp +++ b/rabbit/squtils.hpp @@ -6,6 +6,7 @@ * @license MPL-2 (see license file) */ #pragma once +#include 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(); \ } \ }