diff --git a/cmdLine/rabbit.cpp b/cmdLine/rabbit.cpp index cfcd93f..96bf569 100644 --- a/cmdLine/rabbit.cpp +++ b/cmdLine/rabbit.cpp @@ -51,12 +51,12 @@ int MemAllocHook(int allocType, int64_t quit(rabbit::VirtualMachine* v) { int *done; - sq_getuserpointer(v,-1,(SQUserPointer*)&done); + sq_getuserpointer(v,-1,(rabbit::UserPointer*)&done); *done=1; return 0; } -void printfunc(rabbit::VirtualMachine* SQ_UNUSED_ARG(v),const SQChar *s,...) +void printfunc(rabbit::VirtualMachine* SQ_UNUSED_ARG(v),const rabbit::Char *s,...) { va_list vl; va_start(vl, s); @@ -64,7 +64,7 @@ void printfunc(rabbit::VirtualMachine* SQ_UNUSED_ARG(v),const SQChar *s,...) va_end(vl); } -void errorfunc(rabbit::VirtualMachine* SQ_UNUSED_ARG(v),const SQChar *s,...) +void errorfunc(rabbit::VirtualMachine* SQ_UNUSED_ARG(v),const rabbit::Char *s,...) { va_list vl; va_start(vl, s); @@ -98,7 +98,7 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval) int i; int compiles_only = 0; #ifdef SQUNICODE - static SQChar temp[500]; + static rabbit::Char temp[500]; #endif char * output = NULL; *retval = 0; @@ -147,7 +147,7 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval) // src file if(arg= MAXINPUT-1) { scfprintf(stderr, _SC("sq : input line too long\n")); break; } else{ - buffer[i++] = (SQChar)c; + buffer[i++] = (rabbit::Char)c; } } buffer[i] = _SC('\0'); if(buffer[0]==_SC('=')){ scsprintf(sq_getscratchpad(v,MAXINPUT),(size_t)MAXINPUT,_SC("return (%s)"),&buffer[1]); - memcpy(buffer,sq_getscratchpad(v,-1),(scstrlen(sq_getscratchpad(v,-1))+1)*sizeof(SQChar)); + memcpy(buffer,sq_getscratchpad(v,-1),(scstrlen(sq_getscratchpad(v,-1))+1)*sizeof(rabbit::Char)); retval=1; } i=scstrlen(buffer); diff --git a/etc/minimal.cpp b/etc/minimal.cpp index 9569a24..5e9ec88 100644 --- a/etc/minimal.cpp +++ b/etc/minimal.cpp @@ -18,7 +18,7 @@ #define scvprintf vfprintf #endif -void printfunc(HSQUIRRELVM v,const SQChar *s,...) +void printfunc(HSQUIRRELVM v,const rabbit::Char *s,...) { va_list vl; va_start(vl, s); @@ -26,7 +26,7 @@ void printfunc(HSQUIRRELVM v,const SQChar *s,...) va_end(vl); } -void errorfunc(HSQUIRRELVM v,const SQChar *s,...) +void errorfunc(HSQUIRRELVM v,const rabbit::Char *s,...) { va_list vl; va_start(vl, s); @@ -34,7 +34,7 @@ void errorfunc(HSQUIRRELVM v,const SQChar *s,...) va_end(vl); } -void call_foo(HSQUIRRELVM v, int n,float f,const SQChar *s) +void call_foo(HSQUIRRELVM v, int n,float f,const rabbit::Char *s) { int64_t top = sq_gettop(v); //saves the stack size before the call sq_pushroottable(v); //pushes the global table diff --git a/lutin_rabbit-core.py b/lutin_rabbit-core.py index cd6cd8d..53fc448 100644 --- a/lutin_rabbit-core.py +++ b/lutin_rabbit-core.py @@ -42,6 +42,17 @@ def configure(target, my_module): 'rabbit/sqfuncstate.cpp', 'rabbit/RefCounted.cpp', 'rabbit/WeakRef.cpp', + 'rabbit/Delegable.cpp', + 'rabbit/ObjectType.cpp', + 'rabbit/ObjectValue.cpp', + 'rabbit/Object.cpp', + 'rabbit/ObjectPtr.cpp', + 'rabbit/MemberHandle.cpp', + 'rabbit/StackInfos.cpp', + 'rabbit/RegFunction.cpp', + 'rabbit/FunctionInfo.cpp', + 'rabbit/MetaMethod.cpp', + 'rabbit/ExceptionTrap.cpp', ]) my_module.compile_version("c++", 2011) my_module.add_depend([ @@ -72,7 +83,19 @@ def configure(target, my_module): 'rabbit/sqtable.hpp', 'rabbit/RefCounted.hpp', 'rabbit/WeakRef.hpp', + 'rabbit/Delegable.hpp', + 'rabbit/ObjectType.hpp', + 'rabbit/ObjectValue.hpp', + 'rabbit/Object.hpp', + 'rabbit/ObjectPtr.hpp', + 'rabbit/MemberHandle.hpp', + 'rabbit/StackInfos.hpp', + 'rabbit/RegFunction.hpp', + 'rabbit/FunctionInfo.hpp', + 'rabbit/MetaMethod.hpp', + 'rabbit/ExceptionTrap.hpp', ]) + return True diff --git a/rabbit-std/sqstdaux.cpp b/rabbit-std/sqstdaux.cpp index c3ca5b1..f0e5bd4 100644 --- a/rabbit-std/sqstdaux.cpp +++ b/rabbit-std/sqstdaux.cpp @@ -14,18 +14,18 @@ void sqstd_printcallstack(rabbit::VirtualMachine* v) { SQPRINTFUNCTION pf = sq_geterrorfunc(v); if(pf) { - SQStackInfos si; + rabbit::StackInfos si; int64_t i; float_t f; - const SQChar *s; + const rabbit::Char *s; int64_t level=1; //1 is to skip this function that is level 0 - const SQChar *name=0; + const rabbit::Char *name=0; int64_t seq=0; pf(v,_SC("\nCALLSTACK\n")); while(SQ_SUCCEEDED(sq_stackinfos(v,level,&si))) { - const SQChar *fn=_SC("unknown"); - const SQChar *src=_SC("unknown"); + const rabbit::Char *fn=_SC("unknown"); + const rabbit::Char *src=_SC("unknown"); if(si.funcname)fn=si.funcname; if(si.source)src=si.source; pf(v,_SC("*FUNCTION [%s()] %s line [%d]\n"),fn,src,si.line); @@ -41,56 +41,56 @@ void sqstd_printcallstack(rabbit::VirtualMachine* v) seq++; switch(sq_gettype(v,-1)) { - case OT_NULL: + case rabbit::OT_NULL: pf(v,_SC("[%s] NULL\n"),name); break; - case OT_INTEGER: + case rabbit::OT_INTEGER: sq_getinteger(v,-1,&i); pf(v,_SC("[%s] %d\n"),name,i); break; - case OT_FLOAT: + case rabbit::OT_FLOAT: sq_getfloat(v,-1,&f); pf(v,_SC("[%s] %.14g\n"),name,f); break; - case OT_USERPOINTER: + case rabbit::OT_USERPOINTER: pf(v,_SC("[%s] USERPOINTER\n"),name); break; - case OT_STRING: + case rabbit::OT_STRING: sq_getstring(v,-1,&s); pf(v,_SC("[%s] \"%s\"\n"),name,s); break; - case OT_TABLE: + case rabbit::OT_TABLE: pf(v,_SC("[%s] TABLE\n"),name); break; - case OT_ARRAY: + case rabbit::OT_ARRAY: pf(v,_SC("[%s] ARRAY\n"),name); break; - case OT_CLOSURE: + case rabbit::OT_CLOSURE: pf(v,_SC("[%s] CLOSURE\n"),name); break; - case OT_NATIVECLOSURE: + case rabbit::OT_NATIVECLOSURE: pf(v,_SC("[%s] NATIVECLOSURE\n"),name); break; - case OT_GENERATOR: + case rabbit::OT_GENERATOR: pf(v,_SC("[%s] GENERATOR\n"),name); break; - case OT_USERDATA: + case rabbit::OT_USERDATA: pf(v,_SC("[%s] USERDATA\n"),name); break; - case OT_THREAD: + case rabbit::OT_THREAD: pf(v,_SC("[%s] THREAD\n"),name); break; - case OT_CLASS: + case rabbit::OT_CLASS: pf(v,_SC("[%s] CLASS\n"),name); break; - case OT_INSTANCE: + case rabbit::OT_INSTANCE: pf(v,_SC("[%s] INSTANCE\n"),name); break; - case OT_WEAKREF: + case rabbit::OT_WEAKREF: pf(v,_SC("[%s] WEAKREF\n"),name); break; - case OT_BOOL:{ - SQBool bval; + 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")); } @@ -107,7 +107,7 @@ static int64_t _sqstd_aux_printerror(rabbit::VirtualMachine* v) { SQPRINTFUNCTION pf = sq_geterrorfunc(v); if(pf) { - const SQChar *sErr = 0; + 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); @@ -121,7 +121,7 @@ static int64_t _sqstd_aux_printerror(rabbit::VirtualMachine* v) return 0; } -void _sqstd_compiler_error(rabbit::VirtualMachine* v,const SQChar *sErr,const SQChar *sSource,int64_t line,int64_t column) +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) { diff --git a/rabbit-std/sqstdblob.cpp b/rabbit-std/sqstdblob.cpp index ea54e3f..51ce17f 100644 --- a/rabbit-std/sqstdblob.cpp +++ b/rabbit-std/sqstdblob.cpp @@ -14,7 +14,7 @@ #define SETUP_BLOB(v) \ SQBlob *self = NULL; \ - { if(SQ_FAILED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) \ + { if(SQ_FAILED(sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) \ return sq_throwerror(v,_SC("invalid type tag")); } \ if(!self || !self->IsValid()) \ return sq_throwerror(v,_SC("the blob is invalid")); @@ -98,7 +98,7 @@ static int64_t _blob__get(rabbit::VirtualMachine* v) static int64_t _blob__nexti(rabbit::VirtualMachine* v) { SETUP_BLOB(v); - if(sq_gettype(v,2) == OT_NULL) { + if(sq_gettype(v,2) == rabbit::OT_NULL) { sq_pushinteger(v, 0); return 1; } @@ -120,7 +120,7 @@ static int64_t _blob__typeof(rabbit::VirtualMachine* v) return 1; } -static int64_t _blob_releasehook(SQUserPointer p, int64_t SQ_UNUSED_ARG(size)) +static int64_t _blob_releasehook(rabbit::UserPointer p, int64_t SQ_UNUSED_ARG(size)) { SQBlob *self = (SQBlob*)p; self->~SQBlob(); @@ -152,7 +152,7 @@ static int64_t _blob__cloned(rabbit::VirtualMachine* v) { SQBlob *other = NULL; { - if(SQ_FAILED(sq_getinstanceup(v,2,(SQUserPointer*)&other,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) + if(SQ_FAILED(sq_getinstanceup(v,2,(rabbit::UserPointer*)&other,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) return SQ_ERROR; } //SQBlob *thisone = new SQBlob(other->Len()); @@ -168,7 +168,7 @@ static int64_t _blob__cloned(rabbit::VirtualMachine* v) } #define _DECL_BLOB_FUNC(name,nparams,typecheck) {_SC(#name),_blob_##name,nparams,typecheck} -static const SQRegFunction _blob_methods[] = { +static const rabbit::RegFunction _blob_methods[] = { _DECL_BLOB_FUNC(constructor,-1,_SC("xn")), _DECL_BLOB_FUNC(resize,2,_SC("xn")), _DECL_BLOB_FUNC(swap2,1,_SC("x")), @@ -230,7 +230,7 @@ static int64_t _g_blob_swapfloat(rabbit::VirtualMachine* v) } #define _DECL_GLOBALBLOB_FUNC(name,nparams,typecheck) {_SC(#name),_g_blob_##name,nparams,typecheck} -static const SQRegFunction bloblib_funcs[]={ +static const rabbit::RegFunction bloblib_funcs[]={ _DECL_GLOBALBLOB_FUNC(casti2f,2,_SC(".n")), _DECL_GLOBALBLOB_FUNC(castf2i,2,_SC(".n")), _DECL_GLOBALBLOB_FUNC(swap2,2,_SC(".n")), @@ -239,10 +239,10 @@ static const SQRegFunction bloblib_funcs[]={ {NULL,(SQFUNCTION)0,0,NULL} }; -SQRESULT sqstd_getblob(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer *ptr) +rabbit::Result sqstd_getblob(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *ptr) { SQBlob *blob; - if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) + if(SQ_FAILED(sq_getinstanceup(v,idx,(rabbit::UserPointer *)&blob,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) return -1; *ptr = blob->getBuf(); return SQ_OK; @@ -251,12 +251,12 @@ SQRESULT sqstd_getblob(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer *ptr) int64_t sqstd_getblobsize(rabbit::VirtualMachine* v,int64_t idx) { SQBlob *blob; - if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) + if(SQ_FAILED(sq_getinstanceup(v,idx,(rabbit::UserPointer *)&blob,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) return -1; return blob->Len(); } -SQUserPointer sqstd_createblob(rabbit::VirtualMachine* v, int64_t size) +rabbit::UserPointer sqstd_createblob(rabbit::VirtualMachine* v, int64_t size) { int64_t top = sq_gettop(v); sq_pushregistrytable(v); @@ -267,7 +267,7 @@ SQUserPointer sqstd_createblob(rabbit::VirtualMachine* v, int64_t size) sq_pushinteger(v,size); //size SQBlob *blob = NULL; if(SQ_SUCCEEDED(sq_call(v,2,SQTrue,SQFalse)) - && SQ_SUCCEEDED(sq_getinstanceup(v,-1,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) { + && SQ_SUCCEEDED(sq_getinstanceup(v,-1,(rabbit::UserPointer *)&blob,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) { sq_remove(v,-2); return blob->getBuf(); } @@ -276,8 +276,8 @@ SQUserPointer sqstd_createblob(rabbit::VirtualMachine* v, int64_t size) return NULL; } -SQRESULT sqstd_register_bloblib(rabbit::VirtualMachine* v) +rabbit::Result sqstd_register_bloblib(rabbit::VirtualMachine* v) { - return declare_stream(v,_SC("blob"),(SQUserPointer)SQSTD_BLOB_TYPE_TAG,_SC("std_blob"),_blob_methods,bloblib_funcs); + 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 4f66686..7265f5e 100644 --- a/rabbit-std/sqstdblob.hpp +++ b/rabbit-std/sqstdblob.hpp @@ -7,9 +7,9 @@ */ #pragma once -RABBIT_API SQUserPointer sqstd_createblob(rabbit::VirtualMachine* v, int64_t size); -RABBIT_API SQRESULT sqstd_getblob(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer *ptr); +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 SQRESULT sqstd_register_bloblib(rabbit::VirtualMachine* v); +RABBIT_API rabbit::Result sqstd_register_bloblib(rabbit::VirtualMachine* v); diff --git a/rabbit-std/sqstdblobimpl.hpp b/rabbit-std/sqstdblobimpl.hpp index ddacd11..f3826d9 100644 --- a/rabbit-std/sqstdblobimpl.hpp +++ b/rabbit-std/sqstdblobimpl.hpp @@ -101,7 +101,7 @@ struct SQBlob : public SQStream int64_t Flush() { return 0; } int64_t Tell() { return _ptr; } int64_t Len() { return _size; } - SQUserPointer getBuf(){ return _buf; } + rabbit::UserPointer getBuf(){ return _buf; } private: int64_t _size; int64_t _allocated; diff --git a/rabbit-std/sqstdio.cpp b/rabbit-std/sqstdio.cpp index 980013c..03f3bf0 100644 --- a/rabbit-std/sqstdio.cpp +++ b/rabbit-std/sqstdio.cpp @@ -14,7 +14,7 @@ #define SQSTD_FILE_TYPE_TAG ((uint64_t)(SQSTD_STREAM_TYPE_TAG | 0x00000001)) //basic API -SQFILE sqstd_fopen(const SQChar *filename ,const SQChar *mode) +SQFILE sqstd_fopen(const rabbit::Char *filename ,const rabbit::Char *mode) { #ifndef SQUNICODE return (SQFILE)fopen(filename,mode); @@ -29,7 +29,7 @@ int64_t sqstd_fread(void* buffer, int64_t size, int64_t count, SQFILE file) return ret; } -int64_t sqstd_fwrite(const SQUserPointer buffer, int64_t size, int64_t count, SQFILE file) +int64_t sqstd_fwrite(const rabbit::UserPointer buffer, int64_t size, int64_t count, SQFILE file) { return (int64_t)fwrite(buffer,size,count,(FILE *)file); } @@ -71,7 +71,7 @@ struct SQFile : public SQStream { SQFile() { _handle = NULL; _owns = false;} SQFile(SQFILE file, bool owns) { _handle = file; _owns = owns;} virtual ~SQFile() { close(); } - bool Open(const SQChar *filename ,const SQChar *mode) { + bool Open(const rabbit::Char *filename ,const rabbit::Char *mode) { close(); if( (_handle = sqstd_fopen(filename,mode)) ) { _owns = true; @@ -122,7 +122,7 @@ static int64_t _file__typeof(rabbit::VirtualMachine* v) return 1; } -static int64_t _file_releasehook(SQUserPointer p, int64_t SQ_UNUSED_ARG(size)) +static int64_t _file_releasehook(rabbit::UserPointer p, int64_t SQ_UNUSED_ARG(size)) { SQFile *self = (SQFile*)p; self->~SQFile(); @@ -132,17 +132,17 @@ static int64_t _file_releasehook(SQUserPointer p, int64_t SQ_UNUSED_ARG(size)) static int64_t _file_constructor(rabbit::VirtualMachine* v) { - const SQChar *filename,*mode; + const rabbit::Char *filename,*mode; bool owns = true; SQFile *f; SQFILE newf; - if(sq_gettype(v,2) == OT_STRING && sq_gettype(v,3) == OT_STRING) { + if(sq_gettype(v,2) == rabbit::OT_STRING && sq_gettype(v,3) == 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) == OT_USERPOINTER) { - owns = !(sq_gettype(v,3) == OT_NULL); + } else if(sq_gettype(v,2) == rabbit::OT_USERPOINTER) { + owns = !(sq_gettype(v,3) == rabbit::OT_NULL); sq_getuserpointer(v,2,&newf); } else { return sq_throwerror(v,_SC("wrong parameter")); @@ -161,7 +161,7 @@ static int64_t _file_constructor(rabbit::VirtualMachine* v) static int64_t _file_close(rabbit::VirtualMachine* v) { SQFile *self = NULL; - if(SQ_SUCCEEDED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)SQSTD_FILE_TYPE_TAG)) + if(SQ_SUCCEEDED(sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)SQSTD_FILE_TYPE_TAG)) && self != NULL) { self->close(); @@ -171,7 +171,7 @@ static int64_t _file_close(rabbit::VirtualMachine* v) //bindings #define _DECL_FILE_FUNC(name,nparams,typecheck) {_SC(#name),_file_##name,nparams,typecheck} -static const SQRegFunction _file_methods[] = { +static const rabbit::RegFunction _file_methods[] = { _DECL_FILE_FUNC(constructor,3,_SC("x")), _DECL_FILE_FUNC(_typeof,1,_SC("x")), _DECL_FILE_FUNC(close,1,_SC("x")), @@ -180,7 +180,7 @@ static const SQRegFunction _file_methods[] = { -SQRESULT sqstd_createfile(rabbit::VirtualMachine* v, SQFILE file,SQBool own) +rabbit::Result sqstd_createfile(rabbit::VirtualMachine* v, SQFILE file,rabbit::Bool own) { int64_t top = sq_gettop(v); sq_pushregistrytable(v); @@ -204,10 +204,10 @@ SQRESULT sqstd_createfile(rabbit::VirtualMachine* v, SQFILE file,SQBool own) return SQ_ERROR; } -SQRESULT sqstd_getfile(rabbit::VirtualMachine* v, int64_t idx, SQFILE *file) +rabbit::Result sqstd_getfile(rabbit::VirtualMachine* v, int64_t idx, SQFILE *file) { SQFile *fileobj = NULL; - if(SQ_SUCCEEDED(sq_getinstanceup(v,idx,(SQUserPointer*)&fileobj,(SQUserPointer)SQSTD_FILE_TYPE_TAG))) { + if(SQ_SUCCEEDED(sq_getinstanceup(v,idx,(rabbit::UserPointer*)&fileobj,(rabbit::UserPointer)SQSTD_FILE_TYPE_TAG))) { *file = fileobj->getHandle(); return SQ_OK; } @@ -265,7 +265,7 @@ int64_t _read_two_bytes(IOBuffer *iobuffer) return 0; } -static int64_t _io_file_lexfeed_PLAIN(SQUserPointer iobuf) +static int64_t _io_file_lexfeed_PLAIN(rabbit::UserPointer iobuf) { IOBuffer *iobuffer = (IOBuffer *)iobuf; return _read_byte(iobuffer); @@ -273,7 +273,7 @@ static int64_t _io_file_lexfeed_PLAIN(SQUserPointer iobuf) } #ifdef SQUNICODE -static int64_t _io_file_lexfeed_UTF8(SQUserPointer iobuf) +static int64_t _io_file_lexfeed_UTF8(rabbit::UserPointer iobuf) { IOBuffer *iobuffer = (IOBuffer *)iobuf; #define READ(iobuf) \ @@ -312,7 +312,7 @@ static int64_t _io_file_lexfeed_UTF8(SQUserPointer iobuf) } #endif -static int64_t _io_file_lexfeed_UCS2_LE(SQUserPointer iobuf) +static int64_t _io_file_lexfeed_UCS2_LE(rabbit::UserPointer iobuf) { int64_t ret; IOBuffer *iobuffer = (IOBuffer *)iobuf; @@ -321,7 +321,7 @@ static int64_t _io_file_lexfeed_UCS2_LE(SQUserPointer iobuf) return 0; } -static int64_t _io_file_lexfeed_UCS2_BE(SQUserPointer iobuf) +static int64_t _io_file_lexfeed_UCS2_BE(rabbit::UserPointer iobuf) { int64_t c; IOBuffer *iobuffer = (IOBuffer *)iobuf; @@ -332,19 +332,19 @@ static int64_t _io_file_lexfeed_UCS2_BE(SQUserPointer iobuf) return 0; } -int64_t file_read(SQUserPointer file,SQUserPointer buf,int64_t size) +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; return -1; } -int64_t file_write(SQUserPointer file,SQUserPointer p,int64_t size) +int64_t file_write(rabbit::UserPointer file,rabbit::UserPointer p,int64_t size) { return sqstd_fwrite(p,1,size,(SQFILE)file); } -SQRESULT sqstd_loadfile(rabbit::VirtualMachine* v,const SQChar *filename,SQBool printerror) +rabbit::Result sqstd_loadfile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool printerror) { SQFILE file = sqstd_fopen(filename,_SC("rb")); @@ -404,7 +404,7 @@ SQRESULT sqstd_loadfile(rabbit::VirtualMachine* v,const SQChar *filename,SQBool return sq_throwerror(v,_SC("cannot open the file")); } -SQRESULT sqstd_dofile(rabbit::VirtualMachine* v,const SQChar *filename,SQBool retval,SQBool printerror) +rabbit::Result sqstd_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) @@ -421,7 +421,7 @@ SQRESULT sqstd_dofile(rabbit::VirtualMachine* v,const SQChar *filename,SQBool re return SQ_ERROR; } -SQRESULT sqstd_writeclosuretofile(rabbit::VirtualMachine* v,const SQChar *filename) +rabbit::Result sqstd_writeclosuretofile(rabbit::VirtualMachine* v,const rabbit::Char *filename) { SQFILE file = sqstd_fopen(filename,_SC("wb+")); if(!file) return sq_throwerror(v,_SC("cannot open the file")); @@ -435,8 +435,8 @@ SQRESULT sqstd_writeclosuretofile(rabbit::VirtualMachine* v,const SQChar *filena int64_t _g_io_loadfile(rabbit::VirtualMachine* v) { - const SQChar *filename; - SQBool printerror = SQFalse; + const rabbit::Char *filename; + rabbit::Bool printerror = SQFalse; sq_getstring(v,2,&filename); if(sq_gettop(v) >= 3) { sq_getbool(v,3,&printerror); @@ -448,7 +448,7 @@ int64_t _g_io_loadfile(rabbit::VirtualMachine* v) int64_t _g_io_writeclosuretofile(rabbit::VirtualMachine* v) { - const SQChar *filename; + const rabbit::Char *filename; sq_getstring(v,2,&filename); if(SQ_SUCCEEDED(sqstd_writeclosuretofile(v,filename))) return 1; @@ -457,8 +457,8 @@ int64_t _g_io_writeclosuretofile(rabbit::VirtualMachine* v) int64_t _g_io_dofile(rabbit::VirtualMachine* v) { - const SQChar *filename; - SQBool printerror = SQFalse; + const rabbit::Char *filename; + rabbit::Bool printerror = SQFalse; sq_getstring(v,2,&filename); if(sq_gettop(v) >= 3) { sq_getbool(v,3,&printerror); @@ -470,18 +470,18 @@ int64_t _g_io_dofile(rabbit::VirtualMachine* v) } #define _DECL_GLOBALIO_FUNC(name,nparams,typecheck) {_SC(#name),_g_io_##name,nparams,typecheck} -static const SQRegFunction iolib_funcs[]={ +static const rabbit::RegFunction iolib_funcs[]={ _DECL_GLOBALIO_FUNC(loadfile,-2,_SC(".sb")), _DECL_GLOBALIO_FUNC(dofile,-2,_SC(".sb")), _DECL_GLOBALIO_FUNC(writeclosuretofile,3,_SC(".sc")), {NULL,(SQFUNCTION)0,0,NULL} }; -SQRESULT sqstd_register_iolib(rabbit::VirtualMachine* v) +rabbit::Result sqstd_register_iolib(rabbit::VirtualMachine* v) { int64_t top = sq_gettop(v); //create delegate - declare_stream(v,_SC("file"),(SQUserPointer)SQSTD_FILE_TYPE_TAG,_SC("std_file"),_file_methods,iolib_funcs); + 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); sq_newslot(v,-3,SQFalse); diff --git a/rabbit-std/sqstdio.hpp b/rabbit-std/sqstdio.hpp index d8b2e01..9d5a51c 100644 --- a/rabbit-std/sqstdio.hpp +++ b/rabbit-std/sqstdio.hpp @@ -27,22 +27,22 @@ struct SQStream { typedef void* SQFILE; -RABBIT_API SQFILE sqstd_fopen(const SQChar *,const SQChar *); -RABBIT_API int64_t sqstd_fread(SQUserPointer, int64_t, int64_t, SQFILE); -RABBIT_API int64_t sqstd_fwrite(const SQUserPointer, int64_t, int64_t, SQFILE); +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); -RABBIT_API SQRESULT sqstd_createfile(rabbit::VirtualMachine* v, SQFILE file,SQBool own); -RABBIT_API SQRESULT sqstd_getfile(rabbit::VirtualMachine* v, int64_t idx, SQFILE *file); +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); //compiler helpers -RABBIT_API SQRESULT sqstd_loadfile(rabbit::VirtualMachine* v,const SQChar *filename,SQBool printerror); -RABBIT_API SQRESULT sqstd_dofile(rabbit::VirtualMachine* v,const SQChar *filename,SQBool retval,SQBool printerror); -RABBIT_API SQRESULT sqstd_writeclosuretofile(rabbit::VirtualMachine* v,const SQChar *filename); +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_API SQRESULT sqstd_register_iolib(rabbit::VirtualMachine* v); +RABBIT_API rabbit::Result sqstd_register_iolib(rabbit::VirtualMachine* v); diff --git a/rabbit-std/sqstdmath.cpp b/rabbit-std/sqstdmath.cpp index 5a384d5..5225054 100644 --- a/rabbit-std/sqstdmath.cpp +++ b/rabbit-std/sqstdmath.cpp @@ -66,7 +66,7 @@ SINGLE_ARG_FUNC(ceil) SINGLE_ARG_FUNC(exp) #define _DECL_FUNC(name,nparams,tycheck) {_SC(#name),math_##name,nparams,tycheck} -static const SQRegFunction mathlib_funcs[] = { +static const rabbit::RegFunction mathlib_funcs[] = { _DECL_FUNC(sqrt,2,_SC(".n")), _DECL_FUNC(sin,2,_SC(".n")), _DECL_FUNC(cos,2,_SC(".n")), @@ -93,7 +93,7 @@ static const SQRegFunction mathlib_funcs[] = { #define M_PI (3.14159265358979323846) #endif -SQRESULT sqstd_register_mathlib(rabbit::VirtualMachine* v) +rabbit::Result sqstd_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 6761f1f..3722a48 100644 --- a/rabbit-std/sqstdmath.hpp +++ b/rabbit-std/sqstdmath.hpp @@ -9,5 +9,5 @@ #include -RABBIT_API SQRESULT sqstd_register_mathlib(rabbit::VirtualMachine* v); +RABBIT_API rabbit::Result sqstd_register_mathlib(rabbit::VirtualMachine* v); diff --git a/rabbit-std/sqstdrex.cpp b/rabbit-std/sqstdrex.cpp index e509f2c..667e76a 100644 --- a/rabbit-std/sqstdrex.cpp +++ b/rabbit-std/sqstdrex.cpp @@ -15,7 +15,7 @@ #ifdef _DEBUG #include -static const SQChar *g_nnames[] = +static const rabbit::Char *g_nnames[] = { _SC("NONE"),_SC("OP_GREEDY"), _SC("OP_OR"), _SC("OP_EXPR"),_SC("OP_NOCAPEXPR"),_SC("OP_DOT"), _SC("OP_CLASS"), @@ -60,9 +60,9 @@ typedef struct tagSQRexNode{ }SQRexNode; struct SQRex{ - const SQChar *_eol; - const SQChar *_bol; - const SQChar *_p; + const rabbit::Char *_eol; + const rabbit::Char *_bol; + const rabbit::Char *_p; int64_t _first; int64_t _op; SQRexNode *_nodes; @@ -72,7 +72,7 @@ struct SQRex{ SQRexMatch *_matches; int64_t _currsubexp; void *_jmpbuf; - const SQChar **_error; + const rabbit::Char **_error; }; static int64_t sqstd_rex_list(SQRex *exp); @@ -94,7 +94,7 @@ static int64_t sqstd_rex_newnode(SQRex *exp, SQRexNodeType type) return (int64_t)newid; } -static void sqstd_rex_error(SQRex *exp,const SQChar *error) +static void sqstd_rex_error(SQRex *exp,const rabbit::Char *error) { if(exp->_error) *exp->_error = error; longjmp(*((jmp_buf*)exp->_jmpbuf),-1); @@ -106,7 +106,7 @@ static void sqstd_rex_expect(SQRex *exp, int64_t n){ exp->_p++; } -static SQChar sqstd_rex_escapechar(SQRex *exp) +static rabbit::Char sqstd_rex_escapechar(SQRex *exp) { if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR){ exp->_p++; @@ -129,9 +129,9 @@ static int64_t sqstd_rex_charclass(SQRex *exp,int64_t classid) return n; } -static int64_t sqstd_rex_charnode(SQRex *exp,SQBool isclass) +static int64_t sqstd_rex_charnode(SQRex *exp,rabbit::Bool isclass) { - SQChar t; + rabbit::Char t; if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR) { exp->_p++; switch(*exp->_p) { @@ -149,7 +149,7 @@ static int64_t sqstd_rex_charnode(SQRex *exp,SQBool isclass) } case 'm': { - SQChar cb, ce; //cb = character begin match ce = character end match + 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 @@ -279,7 +279,7 @@ static int64_t sqstd_rex_element(SQRex *exp) } - SQBool isgreedy = SQFalse; + 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; @@ -350,7 +350,7 @@ static int64_t sqstd_rex_list(SQRex *exp) return ret; } -static SQBool sqstd_rex_matchcclass(int64_t cclass,SQChar c) +static rabbit::Bool sqstd_rex_matchcclass(int64_t cclass,rabbit::Char c) { switch(cclass) { case 'a': return isalpha(c)?SQTrue:SQFalse; @@ -373,7 +373,7 @@ static SQBool sqstd_rex_matchcclass(int64_t cclass,SQChar c) return SQFalse; /*cannot happen*/ } -static SQBool sqstd_rex_matchclass(SQRex* exp,SQRexNode *node,SQChar c) +static rabbit::Bool sqstd_rex_matchclass(SQRex* exp,SQRexNode *node,rabbit::Char c) { do { switch(node->type) { @@ -390,7 +390,7 @@ static SQBool sqstd_rex_matchclass(SQRex* exp,SQRexNode *node,SQChar c) return SQFalse; } -static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar *str,SQRexNode *next) +static const rabbit::Char *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const rabbit::Char *str,SQRexNode *next) { SQRexNodeType type = node->type; @@ -399,7 +399,7 @@ static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar //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 SQChar *s=str, *good = str; + const rabbit::Char *s=str, *good = str; if(node->next != -1) { greedystop = &exp->_nodes[node->next]; @@ -410,7 +410,7 @@ static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar while((nmaches == 0xFFFF || nmaches < p1)) { - const SQChar *stop; + const rabbit::Char *stop; if(!(s = sqstd_rex_matchnode(exp,&exp->_nodes[node->left],s,greedystop))) break; nmaches++; @@ -446,7 +446,7 @@ static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar return NULL; } case OP_OR: { - const SQChar *asd = str; + const rabbit::Char *asd = str; SQRexNode *temp=&exp->_nodes[node->left]; while( (asd = sqstd_rex_matchnode(exp,temp,asd,NULL)) ) { if(temp->next != -1) @@ -468,7 +468,7 @@ static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar case OP_EXPR: case OP_NOCAPEXPR:{ SQRexNode *n = &exp->_nodes[node->left]; - const SQChar *cur = str; + const rabbit::Char *cur = str; int64_t capture = -1; if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) { capture = exp->_currsubexp; @@ -537,7 +537,7 @@ static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar 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 SQChar *streol = exp->_eol; + const rabbit::Char *streol = exp->_eol; while (++str < streol) { if (*str == ce) { if (--cont == 0) { @@ -558,12 +558,12 @@ static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar } /* public api */ -SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error) +SQRex *sqstd_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; exp->_p = pattern; - exp->_nallocated = (int64_t)scstrlen(pattern) * sizeof(SQChar); + exp->_nallocated = (int64_t)scstrlen(pattern) * sizeof(rabbit::Char); exp->_nodes = (SQRexNode *)sq_malloc(exp->_nallocated * sizeof(SQRexNode)); exp->_nsize = 0; exp->_matches = 0; @@ -613,9 +613,9 @@ void sqstd_rex_free(SQRex *exp) } } -SQBool sqstd_rex_match(SQRex* exp,const SQChar* text) +rabbit::Bool sqstd_rex_match(SQRex* exp,const rabbit::Char* text) { - const SQChar* res = NULL; + const rabbit::Char* res = NULL; exp->_bol = text; exp->_eol = text + scstrlen(text); exp->_currsubexp = 0; @@ -625,9 +625,9 @@ SQBool sqstd_rex_match(SQRex* exp,const SQChar* text) return SQTrue; } -SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const SQChar* text_end,const SQChar** out_begin, const SQChar** out_end) +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) { - const SQChar *cur = NULL; + const rabbit::Char *cur = NULL; int64_t node = exp->_first; if(text_begin >= text_end) return SQFalse; exp->_bol = text_begin; @@ -654,7 +654,7 @@ SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const SQChar* t return SQTrue; } -SQBool sqstd_rex_search(SQRex* exp,const SQChar* text, const SQChar** out_begin, const SQChar** out_end) +rabbit::Bool sqstd_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); } @@ -664,7 +664,7 @@ int64_t sqstd_rex_getsubexpcount(SQRex* exp) return exp->_nsubexpr; } -SQBool sqstd_rex_getsubexp(SQRex* exp, int64_t n, SQRexMatch *subexp) +rabbit::Bool sqstd_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 1e3bb45..923666d 100644 --- a/rabbit-std/sqstdstream.cpp +++ b/rabbit-std/sqstdstream.cpp @@ -18,7 +18,7 @@ #define SETUP_STREAM(v) \ SQStream *self = NULL; \ - if(SQ_FAILED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)((uint64_t)SQSTD_STREAM_TYPE_TAG)))) \ + 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")); \ if(!self || !self->IsValid()) \ return sq_throwerror(v,_SC("the stream is invalid")); @@ -26,7 +26,7 @@ int64_t _stream_readblob(rabbit::VirtualMachine* v) { SETUP_STREAM(v); - SQUserPointer data,blobp; + rabbit::UserPointer data,blobp; int64_t size,res; sq_getinteger(v,2,&size); if(size > self->Len()) { @@ -106,7 +106,7 @@ int64_t _stream_readn(rabbit::VirtualMachine* v) int64_t _stream_writeblob(rabbit::VirtualMachine* v) { - SQUserPointer data; + rabbit::UserPointer data; int64_t size; SETUP_STREAM(v); if(SQ_FAILED(sqstd_getblob(v,2,&data))) @@ -245,7 +245,7 @@ int64_t _stream_eos(rabbit::VirtualMachine* v) return sq_throwerror(v,_SC("this object cannot be cloned")); } -static const SQRegFunction _stream_methods[] = { +static const rabbit::RegFunction _stream_methods[] = { _DECL_STREAM_FUNC(readblob,2,_SC("xn")), _DECL_STREAM_FUNC(readn,2,_SC("xn")), _DECL_STREAM_FUNC(writeblob,-2,_SC("xx")), @@ -266,10 +266,10 @@ void init_streamclass(rabbit::VirtualMachine* v) if(SQ_FAILED(sq_get(v,-2))) { sq_pushstring(v,_SC("std_stream"),-1); sq_newclass(v,SQFalse); - sq_settypetag(v,-1,(SQUserPointer)((uint64_t)SQSTD_STREAM_TYPE_TAG)); + sq_settypetag(v,-1,(rabbit::UserPointer)((uint64_t)SQSTD_STREAM_TYPE_TAG)); int64_t i = 0; while(_stream_methods[i].name != 0) { - const SQRegFunction &f = _stream_methods[i]; + const rabbit::RegFunction &f = _stream_methods[i]; sq_pushstring(v,f.name,-1); sq_newclosure(v,f.f,0); sq_setparamscheck(v,f.nparamscheck,f.typemask); @@ -290,9 +290,9 @@ void init_streamclass(rabbit::VirtualMachine* v) sq_pop(v,1); } -SQRESULT declare_stream(rabbit::VirtualMachine* v,const SQChar* name,SQUserPointer typetag,const SQChar* reg_name,const SQRegFunction *methods,const SQRegFunction *globals) +rabbit::Result declare_stream(rabbit::VirtualMachine* v,const rabbit::Char* name,rabbit::UserPointer typetag,const rabbit::Char* reg_name,const rabbit::RegFunction *methods,const rabbit::RegFunction *globals) { - if(sq_gettype(v,-1) != OT_TABLE) + if(sq_gettype(v,-1) != rabbit::OT_TABLE) return sq_throwerror(v,_SC("table expected")); int64_t top = sq_gettop(v); //create delegate @@ -305,7 +305,7 @@ SQRESULT declare_stream(rabbit::VirtualMachine* v,const SQChar* name,SQUserPoint sq_settypetag(v,-1,typetag); int64_t i = 0; while(methods[i].name != 0) { - const SQRegFunction &f = methods[i]; + const rabbit::RegFunction &f = methods[i]; sq_pushstring(v,f.name,-1); sq_newclosure(v,f.f,0); sq_setparamscheck(v,f.nparamscheck,f.typemask); @@ -319,7 +319,7 @@ SQRESULT declare_stream(rabbit::VirtualMachine* v,const SQChar* name,SQUserPoint i = 0; while(globals[i].name!=0) { - const SQRegFunction &f = globals[i]; + const rabbit::RegFunction &f = globals[i]; sq_pushstring(v,f.name,-1); sq_newclosure(v,f.f,0); sq_setparamscheck(v,f.nparamscheck,f.typemask); diff --git a/rabbit-std/sqstdstream.hpp b/rabbit-std/sqstdstream.hpp index 4caf9d3..c9c8b7f 100644 --- a/rabbit-std/sqstdstream.hpp +++ b/rabbit-std/sqstdstream.hpp @@ -19,4 +19,4 @@ 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} -SQRESULT declare_stream(rabbit::VirtualMachine* v,const SQChar* name,SQUserPointer typetag,const SQChar* reg_name,const SQRegFunction *methods,const SQRegFunction *globals); +rabbit::Result declare_stream(rabbit::VirtualMachine* v,const rabbit::Char* name,rabbit::UserPointer typetag,const rabbit::Char* reg_name,const rabbit::RegFunction *methods,const rabbit::RegFunction *globals); diff --git a/rabbit-std/sqstdstring.cpp b/rabbit-std/sqstdstring.cpp index b1418e5..1557ba4 100644 --- a/rabbit-std/sqstdstring.cpp +++ b/rabbit-std/sqstdstring.cpp @@ -16,9 +16,9 @@ #define MAX_FORMAT_LEN 20 #define MAX_WFORMAT_LEN 3 -#define ADDITIONAL_FORMAT_SPACE (100*sizeof(SQChar)) +#define ADDITIONAL_FORMAT_SPACE (100*sizeof(rabbit::Char)) -static SQBool isfmtchr(SQChar ch) +static rabbit::Bool isfmtchr(rabbit::Char ch) { switch(ch) { case '-': case '+': case ' ': case '#': case '0': return SQTrue; @@ -26,10 +26,10 @@ static SQBool isfmtchr(SQChar ch) return SQFalse; } -static int64_t validate_format(rabbit::VirtualMachine* v, SQChar *fmt, const SQChar *src, int64_t n,int64_t &width) +static int64_t validate_format(rabbit::VirtualMachine* v, rabbit::Char *fmt, const rabbit::Char *src, int64_t n,int64_t &width) { - SQChar *dummy; - SQChar swidth[MAX_WFORMAT_LEN]; + rabbit::Char *dummy; + rabbit::Char swidth[MAX_WFORMAT_LEN]; int64_t wc = 0; int64_t start = n; fmt[0] = '%'; @@ -66,22 +66,22 @@ static int64_t validate_format(rabbit::VirtualMachine* v, SQChar *fmt, const SQC } if (n-start > MAX_FORMAT_LEN ) return sq_throwerror(v,_SC("format too long")); - memcpy(&fmt[1],&src[start],((n-start)+1)*sizeof(SQChar)); + memcpy(&fmt[1],&src[start],((n-start)+1)*sizeof(rabbit::Char)); fmt[(n-start)+2] = '\0'; return n; } -SQRESULT sqstd_format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t *outlen,SQChar **output) +rabbit::Result sqstd_format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t *outlen,rabbit::Char **output) { - const SQChar *format; - SQChar *dest; - SQChar fmt[MAX_FORMAT_LEN]; - const SQRESULT res = sq_getstring(v,nformatstringidx,&format); + const rabbit::Char *format; + rabbit::Char *dest; + rabbit::Char fmt[MAX_FORMAT_LEN]; + const rabbit::Result res = sq_getstring(v,nformatstringidx,&format); if (SQ_FAILED(res)) { return res; // propagate the error } int64_t format_size = sq_getsize(v,nformatstringidx); - int64_t allocated = (format_size+2)*sizeof(SQChar); + int64_t allocated = (format_size+2)*sizeof(rabbit::Char); dest = sq_getscratchpad(v,allocated); int64_t n = 0,i = 0, nparam = nformatstringidx+1, w = 0; //while(format[n] != '\0') @@ -104,14 +104,14 @@ SQRESULT sqstd_format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t if(n < 0) return -1; int64_t addlen = 0; int64_t valtype = 0; - const SQChar *ts = NULL; + const rabbit::Char *ts = NULL; int64_t ti = 0; float_t tf = 0; switch(format[n]) { case 's': if(SQ_FAILED(sq_getstring(v,nparam,&ts))) return sq_throwerror(v,_SC("string expected for the specified format")); - addlen = (sq_getsize(v,nparam)*sizeof(SQChar))+((w+1)*sizeof(SQChar)); + addlen = (sq_getsize(v,nparam)*sizeof(rabbit::Char))+((w+1)*sizeof(rabbit::Char)); valtype = 's'; break; case 'i': case 'd': case 'o': case 'u': case 'x': case 'X': @@ -119,8 +119,8 @@ SQRESULT sqstd_format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t { size_t flen = scstrlen(fmt); int64_t fpos = flen - 1; - SQChar f = fmt[fpos]; - const SQChar *prec = (const SQChar *)_PRINT_INT_PREC; + rabbit::Char f = fmt[fpos]; + const rabbit::Char *prec = (const rabbit::Char *)_PRINT_INT_PREC; while(*prec != _SC('\0')) { fmt[fpos++] = *prec++; } @@ -131,20 +131,20 @@ SQRESULT sqstd_format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t case 'c': if(SQ_FAILED(sq_getinteger(v,nparam,&ti))) return sq_throwerror(v,_SC("integer expected for the specified format")); - addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(SQChar)); + addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(rabbit::Char)); valtype = 'i'; break; case 'f': case 'g': case 'G': case 'e': case 'E': if(SQ_FAILED(sq_getfloat(v,nparam,&tf))) return sq_throwerror(v,_SC("float expected for the specified format")); - addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(SQChar)); + addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(rabbit::Char)); valtype = 'f'; break; default: return sq_throwerror(v,_SC("invalid format")); } n++; - allocated += addlen + sizeof(SQChar); + allocated += addlen + sizeof(rabbit::Char); dest = sq_getscratchpad(v,allocated); switch(valtype) { case 's': i += scsprintf(&dest[i],allocated,fmt,ts); break; @@ -162,7 +162,7 @@ SQRESULT sqstd_format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t static int64_t _string_printf(rabbit::VirtualMachine* v) { - SQChar *dest = NULL; + rabbit::Char *dest = NULL; int64_t length = 0; if(SQ_FAILED(sqstd_format(v,2,&length,&dest))) return -1; @@ -175,7 +175,7 @@ static int64_t _string_printf(rabbit::VirtualMachine* v) static int64_t _string_format(rabbit::VirtualMachine* v) { - SQChar *dest = NULL; + rabbit::Char *dest = NULL; int64_t length = 0; if(SQ_FAILED(sqstd_format(v,2,&length,&dest))) return -1; @@ -183,27 +183,27 @@ static int64_t _string_format(rabbit::VirtualMachine* v) return 1; } -static void __strip_l(const SQChar *str,const SQChar **start) +static void __strip_l(const rabbit::Char *str,const rabbit::Char **start) { - const SQChar *t = str; + const rabbit::Char *t = str; while(((*t) != '\0') && scisspace(*t)){ t++; } *start = t; } -static void __strip_r(const SQChar *str,int64_t len,const SQChar **end) +static void __strip_r(const rabbit::Char *str,int64_t len,const rabbit::Char **end) { if(len == 0) { *end = str; return; } - const SQChar *t = &str[len-1]; + const rabbit::Char *t = &str[len-1]; while(t >= str && scisspace(*t)) { t--; } *end = t + 1; } static int64_t _string_strip(rabbit::VirtualMachine* v) { - const SQChar *str,*start,*end; + const rabbit::Char *str,*start,*end; sq_getstring(v,2,&str); int64_t len = sq_getsize(v,2); __strip_l(str,&start); @@ -214,7 +214,7 @@ static int64_t _string_strip(rabbit::VirtualMachine* v) static int64_t _string_lstrip(rabbit::VirtualMachine* v) { - const SQChar *str,*start; + const rabbit::Char *str,*start; sq_getstring(v,2,&str); __strip_l(str,&start); sq_pushstring(v,start,-1); @@ -223,7 +223,7 @@ static int64_t _string_lstrip(rabbit::VirtualMachine* v) static int64_t _string_rstrip(rabbit::VirtualMachine* v) { - const SQChar *str,*end; + const rabbit::Char *str,*end; sq_getstring(v,2,&str); int64_t len = sq_getsize(v,2); __strip_r(str,len,&end); @@ -233,21 +233,21 @@ static int64_t _string_rstrip(rabbit::VirtualMachine* v) static int64_t _string_split(rabbit::VirtualMachine* v) { - const SQChar *str,*seps; - SQChar *stemp; + const rabbit::Char *str,*seps; + rabbit::Char *stemp; sq_getstring(v,2,&str); sq_getstring(v,3,&seps); int64_t sepsize = sq_getsize(v,3); if(sepsize == 0) return sq_throwerror(v,_SC("empty separators string")); - int64_t memsize = (sq_getsize(v,2)+1)*sizeof(SQChar); + int64_t memsize = (sq_getsize(v,2)+1)*sizeof(rabbit::Char); stemp = sq_getscratchpad(v,memsize); memcpy(stemp,str,memsize); - SQChar *start = stemp; - SQChar *end = stemp; + rabbit::Char *start = stemp; + rabbit::Char *end = stemp; sq_newarray(v,0); while(*end != '\0') { - SQChar cur = *end; + rabbit::Char cur = *end; for(int64_t i = 0; i < sepsize; i++) { if(cur == seps[i]) @@ -271,8 +271,8 @@ static int64_t _string_split(rabbit::VirtualMachine* v) static int64_t _string_escape(rabbit::VirtualMachine* v) { - const SQChar *str; - SQChar *dest,*resstr; + const rabbit::Char *str; + rabbit::Char *dest,*resstr; int64_t size; sq_getstring(v,2,&str); size = sq_getsize(v,2); @@ -282,20 +282,20 @@ static int64_t _string_escape(rabbit::VirtualMachine* v) } #ifdef SQUNICODE #if WCHAR_SIZE == 2 - const SQChar *escpat = _SC("\\x%04x"); + const rabbit::Char *escpat = _SC("\\x%04x"); const int64_t maxescsize = 6; #else //WCHAR_SIZE == 4 - const SQChar *escpat = _SC("\\x%08x"); + const rabbit::Char *escpat = _SC("\\x%08x"); const int64_t maxescsize = 10; #endif #else - const SQChar *escpat = _SC("\\x%02x"); + const rabbit::Char *escpat = _SC("\\x%02x"); const int64_t maxescsize = 4; #endif int64_t destcharsize = (size * maxescsize); //assumes every char could be escaped - resstr = dest = (SQChar *)sq_getscratchpad(v,destcharsize * sizeof(SQChar)); - SQChar c; - SQChar escch; + resstr = dest = (rabbit::Char *)sq_getscratchpad(v,destcharsize * sizeof(rabbit::Char)); + rabbit::Char c; + rabbit::Char escch; int64_t escaped = 0; for(int n = 0; n < size; n++){ c = *str++; @@ -341,12 +341,12 @@ static int64_t _string_escape(rabbit::VirtualMachine* v) static int64_t _string_startswith(rabbit::VirtualMachine* v) { - const SQChar *str,*cmp; + const rabbit::Char *str,*cmp; sq_getstring(v,2,&str); sq_getstring(v,3,&cmp); int64_t len = sq_getsize(v,2); int64_t cmplen = sq_getsize(v,3); - SQBool ret = SQFalse; + rabbit::Bool ret = SQFalse; if(cmplen <= len) { ret = memcmp(str,cmp,sq_rsl(cmplen)) == 0 ? SQTrue : SQFalse; } @@ -356,12 +356,12 @@ static int64_t _string_startswith(rabbit::VirtualMachine* v) static int64_t _string_endswith(rabbit::VirtualMachine* v) { - const SQChar *str,*cmp; + const rabbit::Char *str,*cmp; sq_getstring(v,2,&str); sq_getstring(v,3,&cmp); int64_t len = sq_getsize(v,2); int64_t cmplen = sq_getsize(v,3); - SQBool ret = SQFalse; + rabbit::Bool ret = SQFalse; if(cmplen <= len) { ret = memcmp(&str[len - cmplen],cmp,sq_rsl(cmplen)) == 0 ? SQTrue : SQFalse; } @@ -371,9 +371,9 @@ static int64_t _string_endswith(rabbit::VirtualMachine* v) #define SETUP_REX(v) \ SQRex *self = NULL; \ - sq_getinstanceup(v,1,(SQUserPointer *)&self,0); + sq_getinstanceup(v,1,(rabbit::UserPointer *)&self,0); -static int64_t _rexobj_releasehook(SQUserPointer p, int64_t SQ_UNUSED_ARG(size)) +static int64_t _rexobj_releasehook(rabbit::UserPointer p, int64_t SQ_UNUSED_ARG(size)) { SQRex *self = ((SQRex *)p); sqstd_rex_free(self); @@ -383,7 +383,7 @@ static int64_t _rexobj_releasehook(SQUserPointer p, int64_t SQ_UNUSED_ARG(size)) static int64_t _regexp_match(rabbit::VirtualMachine* v) { SETUP_REX(v); - const SQChar *str; + const rabbit::Char *str; sq_getstring(v,2,&str); if(sqstd_rex_match(self,str) == SQTrue) { @@ -394,7 +394,7 @@ static int64_t _regexp_match(rabbit::VirtualMachine* v) return 1; } -static void _addrexmatch(rabbit::VirtualMachine* v,const SQChar *str,const SQChar *begin,const SQChar *end) +static void _addrexmatch(rabbit::VirtualMachine* v,const rabbit::Char *str,const rabbit::Char *begin,const rabbit::Char *end) { sq_newtable(v); sq_pushstring(v,_SC("begin"),-1); @@ -408,7 +408,7 @@ static void _addrexmatch(rabbit::VirtualMachine* v,const SQChar *str,const SQCha static int64_t _regexp_search(rabbit::VirtualMachine* v) { SETUP_REX(v); - const SQChar *str,*begin,*end; + const rabbit::Char *str,*begin,*end; int64_t start = 0; sq_getstring(v,2,&str); if(sq_gettop(v) > 2) sq_getinteger(v,3,&start); @@ -422,7 +422,7 @@ static int64_t _regexp_search(rabbit::VirtualMachine* v) static int64_t _regexp_capture(rabbit::VirtualMachine* v) { SETUP_REX(v); - const SQChar *str,*begin,*end; + const rabbit::Char *str,*begin,*end; int64_t start = 0; sq_getstring(v,2,&str); if(sq_gettop(v) > 2) sq_getinteger(v,3,&start); @@ -452,7 +452,7 @@ static int64_t _regexp_subexpcount(rabbit::VirtualMachine* v) static int64_t _regexp_constructor(rabbit::VirtualMachine* v) { - const SQChar *error,*pattern; + const rabbit::Char *error,*pattern; sq_getstring(v,2,&pattern); SQRex *rex = sqstd_rex_compile(pattern,&error); if(!rex) return sq_throwerror(v,error); @@ -468,7 +468,7 @@ static int64_t _regexp__typeof(rabbit::VirtualMachine* v) } #define _DECL_REX_FUNC(name,nparams,pmask) {_SC(#name),_regexp_##name,nparams,pmask} -static const SQRegFunction rexobj_funcs[]={ +static const rabbit::RegFunction rexobj_funcs[]={ _DECL_REX_FUNC(constructor,2,_SC(".s")), _DECL_REX_FUNC(search,-2,_SC("xsn")), _DECL_REX_FUNC(match,2,_SC("xs")), @@ -480,7 +480,7 @@ static const SQRegFunction rexobj_funcs[]={ #undef _DECL_REX_FUNC #define _DECL_FUNC(name,nparams,pmask) {_SC(#name),_string_##name,nparams,pmask} -static const SQRegFunction stringlib_funcs[]={ +static const rabbit::RegFunction stringlib_funcs[]={ _DECL_FUNC(format,-2,_SC(".s")), _DECL_FUNC(printf,-2,_SC(".s")), _DECL_FUNC(strip,2,_SC(".s")), @@ -501,7 +501,7 @@ int64_t sqstd_register_stringlib(rabbit::VirtualMachine* v) sq_newclass(v,SQFalse); int64_t i = 0; while(rexobj_funcs[i].name != 0) { - const SQRegFunction &f = rexobj_funcs[i]; + const rabbit::RegFunction &f = rexobj_funcs[i]; sq_pushstring(v,f.name,-1); sq_newclosure(v,f.f,0); sq_setparamscheck(v,f.nparamscheck,f.typemask); diff --git a/rabbit-std/sqstdstring.hpp b/rabbit-std/sqstdstring.hpp index df2188a..84bf7da 100644 --- a/rabbit-std/sqstdstring.hpp +++ b/rabbit-std/sqstdstring.hpp @@ -11,19 +11,19 @@ typedef unsigned int SQRexBool; typedef struct SQRex SQRex; typedef struct { - const SQChar *begin; + const rabbit::Char *begin; int64_t len; } SQRexMatch; -RABBIT_API SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error); +RABBIT_API SQRex *sqstd_rex_compile(const rabbit::Char *pattern,const rabbit::Char **error); RABBIT_API void sqstd_rex_free(SQRex *exp); -RABBIT_API SQBool sqstd_rex_match(SQRex* exp,const SQChar* text); -RABBIT_API SQBool sqstd_rex_search(SQRex* exp,const SQChar* text, const SQChar** out_begin, const SQChar** out_end); -RABBIT_API SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const SQChar* text_end,const SQChar** out_begin, const SQChar** out_end); +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 SQBool sqstd_rex_getsubexp(SQRex* exp, int64_t n, SQRexMatch *subexp); +RABBIT_API rabbit::Bool sqstd_rex_getsubexp(SQRex* exp, int64_t n, SQRexMatch *subexp); -RABBIT_API SQRESULT sqstd_format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t *outlen,SQChar **output); +RABBIT_API rabbit::Result sqstd_format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t *outlen,rabbit::Char **output); -RABBIT_API SQRESULT sqstd_register_stringlib(rabbit::VirtualMachine* v); +RABBIT_API rabbit::Result sqstd_register_stringlib(rabbit::VirtualMachine* v); diff --git a/rabbit-std/sqstdsystem.cpp b/rabbit-std/sqstdsystem.cpp index bdbb11f..3d46e30 100644 --- a/rabbit-std/sqstdsystem.cpp +++ b/rabbit-std/sqstdsystem.cpp @@ -29,7 +29,7 @@ static int64_t _system_getenv(rabbit::VirtualMachine* v) { - const SQChar *s; + const rabbit::Char *s; if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){ sq_pushstring(v,scgetenv(s),-1); return 1; @@ -40,7 +40,7 @@ static int64_t _system_getenv(rabbit::VirtualMachine* v) static int64_t _system_system(rabbit::VirtualMachine* v) { - const SQChar *s; + const rabbit::Char *s; if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){ sq_pushinteger(v,scsystem(s)); return 1; @@ -64,7 +64,7 @@ static int64_t _system_time(rabbit::VirtualMachine* v) static int64_t _system_remove(rabbit::VirtualMachine* v) { - const SQChar *s; + const rabbit::Char *s; sq_getstring(v,2,&s); if(scremove(s)==-1) return sq_throwerror(v,_SC("remove() failed")); @@ -73,7 +73,7 @@ static int64_t _system_remove(rabbit::VirtualMachine* v) static int64_t _system_rename(rabbit::VirtualMachine* v) { - const SQChar *oldn,*newn; + const rabbit::Char *oldn,*newn; sq_getstring(v,2,&oldn); sq_getstring(v,3,&newn); if(screname(oldn,newn)==-1) @@ -81,7 +81,7 @@ static int64_t _system_rename(rabbit::VirtualMachine* v) return 0; } -static void _set_integer_slot(rabbit::VirtualMachine* v,const SQChar *name,int64_t val) +static void _set_integer_slot(rabbit::VirtualMachine* v,const rabbit::Char *name,int64_t val) { sq_pushstring(v,name,-1); sq_pushinteger(v,val); @@ -125,7 +125,7 @@ static int64_t _system_date(rabbit::VirtualMachine* v) #define _DECL_FUNC(name,nparams,pmask) {_SC(#name),_system_##name,nparams,pmask} -static const SQRegFunction systemlib_funcs[]={ +static const rabbit::RegFunction systemlib_funcs[]={ _DECL_FUNC(getenv,2,_SC(".s")), _DECL_FUNC(system,2,_SC(".s")), _DECL_FUNC(clock,0,NULL), diff --git a/rabbit/Array.hpp b/rabbit/Array.hpp index 2538be1..4192581 100644 --- a/rabbit/Array.hpp +++ b/rabbit/Array.hpp @@ -30,30 +30,30 @@ namespace rabbit { m_data.resize(0); } bool get(const int64_t _nidx, - SQObjectPtr& _val) { + rabbit::ObjectPtr& _val) { if( _nidx >= 0 && _nidx < (int64_t)m_data.size()){ - SQObjectPtr &o = m_data[_nidx]; + rabbit::ObjectPtr &o = m_data[_nidx]; _val = _realval(o); return true; } return false; } - bool set(const int64_t _nidx,const SQObjectPtr& _val) { + bool set(const int64_t _nidx,const rabbit::ObjectPtr& _val) { if(_nidx>=0 && _nidx<(int64_t)m_data.size()){ m_data[_nidx] = _val; return true; } return false; } - int64_t next(const SQObjectPtr& _refpos, - SQObjectPtr& _outkey, - SQObjectPtr& _outval) { + int64_t next(const rabbit::ObjectPtr& _refpos, + rabbit::ObjectPtr& _outkey, + rabbit::ObjectPtr& _outval) { uint64_t idx=translateIndex(_refpos); while(idx (int64_t)m_data.size()) { return false; @@ -121,14 +121,14 @@ namespace rabbit { void release() { sq_delete(this, Array); } - SQObjectPtr& operator[] (const size_t _pos) { + rabbit::ObjectPtr& operator[] (const size_t _pos) { return m_data[_pos]; } - const SQObjectPtr& operator[] (const size_t _pos) const { + const rabbit::ObjectPtr& operator[] (const size_t _pos) const { return m_data[_pos]; } private: - SQObjectPtrVec m_data; + etk::Vector m_data; }; } diff --git a/rabbit/Delegable.cpp b/rabbit/Delegable.cpp new file mode 100644 index 0000000..9aada09 --- /dev/null +++ b/rabbit/Delegable.cpp @@ -0,0 +1,40 @@ +/** + * @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 +#include +#include + +bool rabbit::Delegable::getMetaMethod(rabbit::VirtualMachine *v,rabbit::MetaMethod mm,rabbit::ObjectPtr &res) { + if(_delegate) { + return _delegate->get((*_get_shared_state(v)->_metamethods)[mm],res); + } + return false; +} + +bool rabbit::Delegable::setDelegate(SQTable *mt) { + SQTable *temp = mt; + if(temp == this) { + return false; + } + while (temp) { + if (temp->_delegate == this) { + //cycle detected + return false; + } + temp = temp->_delegate; + } + if (mt) { + __ObjaddRef(mt); + } + __Objrelease(_delegate); + _delegate = mt; + return true; +} + diff --git a/rabbit/Delegable.hpp b/rabbit/Delegable.hpp new file mode 100644 index 0000000..f8bd789 --- /dev/null +++ b/rabbit/Delegable.hpp @@ -0,0 +1,25 @@ +/** + * @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) + */ +#pragma once + +#include +#include +#include +#include + +struct SQTable; +namespace rabbit { + class VirtualMachine; + class Delegable : public rabbit::RefCounted { + public: + bool setDelegate(SQTable *m); + public: + virtual bool getMetaMethod(rabbit::VirtualMachine *v, rabbit::MetaMethod mm, rabbit::ObjectPtr& res); + SQTable *_delegate; + }; +} diff --git a/rabbit/ExceptionTrap.cpp b/rabbit/ExceptionTrap.cpp new file mode 100644 index 0000000..bb6ef32 --- /dev/null +++ b/rabbit/ExceptionTrap.cpp @@ -0,0 +1,9 @@ +/** + * @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 diff --git a/rabbit/ExceptionTrap.hpp b/rabbit/ExceptionTrap.hpp new file mode 100644 index 0000000..6e924b3 --- /dev/null +++ b/rabbit/ExceptionTrap.hpp @@ -0,0 +1,38 @@ +/** + * @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) + */ +#pragma once + +#include +#include + +namespace rabbit { + struct SQInstruction; + class ExceptionTrap { + public: + ExceptionTrap() { + + } + ExceptionTrap(int64_t ss, + int64_t stackbase, + SQInstruction *ip, + int64_t ex_target) { + _stacksize = ss; + _stackbase = stackbase; + _ip = ip; + _extarget = ex_target; + } + ExceptionTrap(const rabbit::ExceptionTrap &et) { + (*this) = et; + } + + int64_t _stackbase; + int64_t _stacksize; + SQInstruction *_ip; + int64_t _extarget; + }; +} diff --git a/rabbit/FunctionInfo.cpp b/rabbit/FunctionInfo.cpp new file mode 100644 index 0000000..d0df0ad --- /dev/null +++ b/rabbit/FunctionInfo.cpp @@ -0,0 +1,9 @@ +/** + * @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 diff --git a/rabbit/FunctionInfo.hpp b/rabbit/FunctionInfo.hpp new file mode 100644 index 0000000..be055a4 --- /dev/null +++ b/rabbit/FunctionInfo.hpp @@ -0,0 +1,21 @@ +/** + * @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) + */ +#pragma once + +#include +#include + +namespace rabbit { + class FunctionInfo { + public: + rabbit::UserPointer funcid; + const rabbit::Char* name; + const rabbit::Char* source; + int64_t line; + }; +} diff --git a/rabbit/MemberHandle.cpp b/rabbit/MemberHandle.cpp new file mode 100644 index 0000000..938ddbf --- /dev/null +++ b/rabbit/MemberHandle.cpp @@ -0,0 +1,9 @@ +/** + * @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 diff --git a/rabbit/MemberHandle.hpp b/rabbit/MemberHandle.hpp new file mode 100644 index 0000000..e355cc9 --- /dev/null +++ b/rabbit/MemberHandle.hpp @@ -0,0 +1,19 @@ +/** + * @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) + */ +#pragma once + +#include +#include + +namespace rabbit { + class MemberHandle{ + public: + rabbit::Bool _static; + int64_t _index; + }; +} diff --git a/rabbit/MetaMethod b/rabbit/MetaMethod new file mode 100644 index 0000000..e69de29 diff --git a/rabbit/MetaMethod.cpp b/rabbit/MetaMethod.cpp new file mode 100644 index 0000000..b8f6aa0 --- /dev/null +++ b/rabbit/MetaMethod.cpp @@ -0,0 +1,9 @@ +/** + * @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 diff --git a/rabbit/MetaMethod.hpp b/rabbit/MetaMethod.hpp new file mode 100644 index 0000000..6005f4f --- /dev/null +++ b/rabbit/MetaMethod.hpp @@ -0,0 +1,53 @@ +/** + * @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) + */ +#pragma once + +#include + +namespace rabbit { + enum MetaMethod { + MT_ADD=0, + MT_SUB=1, + MT_MUL=2, + MT_DIV=3, + MT_UNM=4, + MT_MODULO=5, + MT_SET=6, + MT_GET=7, + MT_TYPEOF=8, + MT_NEXTI=9, + MT_CMP=10, + MT_CALL=11, + MT_CLONED=12, + MT_NEWSLOT=13, + MT_DELSLOT=14, + MT_TOSTRING=15, + MT_NEWMEMBER=16, + MT_INHERITED=17, + MT_LAST = 18 + }; +} + +#define MM_ADD _SC("_add") +#define MM_SUB _SC("_sub") +#define MM_MUL _SC("_mul") +#define MM_DIV _SC("_div") +#define MM_UNM _SC("_unm") +#define MM_MODULO _SC("_modulo") +#define MM_SET _SC("_set") +#define MM_GET _SC("_get") +#define MM_TYPEOF _SC("_typeof") +#define MM_NEXTI _SC("_nexti") +#define MM_CMP _SC("_cmp") +#define MM_CALL _SC("_call") +#define MM_CLONED _SC("_cloned") +#define MM_NEWSLOT _SC("_newslot") +#define MM_DELSLOT _SC("_delslot") +#define MM_TOSTRING _SC("_tostring") +#define MM_NEWMEMBER _SC("_newmember") +#define MM_INHERITED _SC("_inherited") diff --git a/rabbit/Object.cpp b/rabbit/Object.cpp new file mode 100644 index 0000000..06ebfb3 --- /dev/null +++ b/rabbit/Object.cpp @@ -0,0 +1,9 @@ +/** + * @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 diff --git a/rabbit/Object.hpp b/rabbit/Object.hpp new file mode 100644 index 0000000..fe038f7 --- /dev/null +++ b/rabbit/Object.hpp @@ -0,0 +1,84 @@ +/** + * @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) + */ +#pragma once + +#include +#include +#include + +namespace rabbit { + + class Object { + public: + rabbit::ObjectType _type; + rabbit::ObjectValue _unVal; + }; + + #define __addRef(type,unval) if(ISREFCOUNTED(type)) \ + { \ + unval.pRefCounted->refCountIncrement(); \ + } + + #define __release(type,unval) if(ISREFCOUNTED(type) && (unval.pRefCounted->refCountDecrement()==0)) \ + { \ + unval.pRefCounted->release(); \ + } + + #define _realval(o) (sq_type((o)) != rabbit::OT_WEAKREF?(rabbit::Object)o:_weakref(o)->_obj) + + #define is_delegable(t) (sq_type(t)&SQOBJECT_DELEGABLE) + #define raw_type(obj) _RAW_TYPE((obj)._type) + + #define _integer(obj) ((obj)._unVal.nInteger) + #define _float(obj) ((obj)._unVal.fFloat) + #define _string(obj) ((obj)._unVal.pString) + #define _table(obj) ((obj)._unVal.pTable) + #define _array(obj) ((obj)._unVal.pArray) + #define _closure(obj) ((obj)._unVal.pClosure) + #define _generator(obj) ((obj)._unVal.pGenerator) + #define _nativeclosure(obj) ((obj)._unVal.pNativeClosure) + #define _userdata(obj) ((obj)._unVal.pUserData) + #define _userpointer(obj) ((obj)._unVal.pUserPointer) + #define _thread(obj) ((obj)._unVal.pThread) + #define _funcproto(obj) ((obj)._unVal.pFunctionProto) + #define _class(obj) ((obj)._unVal.pClass) + #define _instance(obj) ((obj)._unVal.pInstance) + #define _delegable(obj) ((rabbit::Delegable *)(obj)._unVal.pDelegable) + #define _weakref(obj) ((obj)._unVal.pWeakRef) + #define _outer(obj) ((obj)._unVal.pOuter) + #define _refcounted(obj) ((obj)._unVal.pRefCounted) + #define _rawval(obj) ((obj)._unVal.raw) + + #define _stringval(obj) (obj)._unVal.pString->_val + #define _userdataval(obj) ((rabbit::UserPointer)sq_aligning((obj)._unVal.pUserData + 1)) + + #define tofloat(num) ((sq_type(num)==rabbit::OT_INTEGER)?(float_t)_integer(num):_float(num)) + #define tointeger(num) ((sq_type(num)==rabbit::OT_FLOAT)?(int64_t)_float(num):_integer(num)) + + + #define sq_isnumeric(o) ((o)._type&SQOBJECT_NUMERIC) + #define sq_istable(o) ((o)._type==rabbit::OT_TABLE) + #define sq_isarray(o) ((o)._type==rabbit::OT_ARRAY) + #define sq_isfunction(o) ((o)._type==rabbit::OT_FUNCPROTO) + #define sq_isclosure(o) ((o)._type==rabbit::OT_CLOSURE) + #define sq_isgenerator(o) ((o)._type==rabbit::OT_GENERATOR) + #define sq_isnativeclosure(o) ((o)._type==rabbit::OT_NATIVECLOSURE) + #define sq_isstring(o) ((o)._type==rabbit::OT_STRING) + #define sq_isinteger(o) ((o)._type==rabbit::OT_INTEGER) + #define sq_isfloat(o) ((o)._type==rabbit::OT_FLOAT) + #define sq_isuserpointer(o) ((o)._type==rabbit::OT_USERPOINTER) + #define sq_isuserdata(o) ((o)._type==rabbit::OT_USERDATA) + #define sq_isthread(o) ((o)._type==rabbit::OT_THREAD) + #define sq_isnull(o) ((o)._type==rabbit::OT_NULL) + #define sq_isclass(o) ((o)._type==rabbit::OT_CLASS) + #define sq_isinstance(o) ((o)._type==rabbit::OT_INSTANCE) + #define sq_isbool(o) ((o)._type==rabbit::OT_BOOL) + #define sq_isweakref(o) ((o)._type==rabbit::OT_WEAKREF) + #define sq_type(o) ((o)._type) + +} diff --git a/rabbit/ObjectPtr.cpp b/rabbit/ObjectPtr.cpp new file mode 100644 index 0000000..f81094e --- /dev/null +++ b/rabbit/ObjectPtr.cpp @@ -0,0 +1,201 @@ +/** + * @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 + +#define RABBIT_OBJ_REF_TYPE_INSTANCIATE(type,_class,sym) \ + rabbit::ObjectPtr::ObjectPtr(_class * x) \ + { \ + SQ_OBJECT_RAWINIT() \ + _type=type; \ + _unVal.sym = x; \ + assert(_unVal.pTable); \ + _unVal.pRefCounted->refCountIncrement(); \ + } \ + rabbit::ObjectPtr& rabbit::ObjectPtr::operator=(_class *x) \ + { \ + rabbit::ObjectType tOldType; \ + rabbit::ObjectValue unOldVal; \ + tOldType=_type; \ + unOldVal=_unVal; \ + _type = type; \ + SQ_REFOBJECT_INIT() \ + _unVal.sym = x; \ + _unVal.pRefCounted->refCountIncrement(); \ + __release(tOldType,unOldVal); \ + return *this; \ + } + +#define RABBIT_SCALAR_TYPE_INSTANCIATE(type,_class,sym) \ + rabbit::ObjectPtr::ObjectPtr(_class x) \ + { \ + SQ_OBJECT_RAWINIT() \ + _type=type; \ + _unVal.sym = x; \ + } \ + rabbit::ObjectPtr& rabbit::ObjectPtr::operator=(_class x) \ + { \ + __release(_type,_unVal); \ + _type = type; \ + SQ_OBJECT_RAWINIT() \ + _unVal.sym = x; \ + return *this; \ + } + + +RABBIT_OBJ_REF_TYPE_INSTANCIATE(rabbit::OT_TABLE, SQTable, pTable) +RABBIT_OBJ_REF_TYPE_INSTANCIATE(rabbit::OT_CLASS, SQClass, pClass) +RABBIT_OBJ_REF_TYPE_INSTANCIATE(rabbit::OT_INSTANCE, SQInstance, pInstance) +RABBIT_OBJ_REF_TYPE_INSTANCIATE(rabbit::OT_ARRAY, rabbit::Array, pArray) +RABBIT_OBJ_REF_TYPE_INSTANCIATE(rabbit::OT_CLOSURE, SQClosure, pClosure) +RABBIT_OBJ_REF_TYPE_INSTANCIATE(rabbit::OT_NATIVECLOSURE, SQNativeClosure, pNativeClosure) +RABBIT_OBJ_REF_TYPE_INSTANCIATE(rabbit::OT_OUTER, SQOuter, pOuter) +RABBIT_OBJ_REF_TYPE_INSTANCIATE(rabbit::OT_GENERATOR, SQGenerator, pGenerator) +RABBIT_OBJ_REF_TYPE_INSTANCIATE(rabbit::OT_STRING, SQString, pString) +RABBIT_OBJ_REF_TYPE_INSTANCIATE(rabbit::OT_USERDATA, rabbit::UserData, pUserData) +RABBIT_OBJ_REF_TYPE_INSTANCIATE(rabbit::OT_WEAKREF, rabbit::WeakRef, pWeakRef) +RABBIT_OBJ_REF_TYPE_INSTANCIATE(rabbit::OT_THREAD, rabbit::VirtualMachine, pThread) +RABBIT_OBJ_REF_TYPE_INSTANCIATE(rabbit::OT_FUNCPROTO, SQFunctionProto, pFunctionProto) + +RABBIT_SCALAR_TYPE_INSTANCIATE(rabbit::OT_INTEGER, int64_t, nInteger) +RABBIT_SCALAR_TYPE_INSTANCIATE(rabbit::OT_FLOAT, float_t, fFloat) +RABBIT_SCALAR_TYPE_INSTANCIATE(rabbit::OT_USERPOINTER, rabbit::UserPointer, pUserPointer) + + + +rabbit::ObjectPtr::ObjectPtr() { + SQ_OBJECT_RAWINIT() + _type = rabbit::OT_NULL; + _unVal.pUserPointer = NULL; +} + +rabbit::ObjectPtr::ObjectPtr(const rabbit::ObjectPtr& _obj) { + _type = _obj._type; + _unVal = _obj._unVal; + __addRef(_type,_unVal); +} + +rabbit::ObjectPtr::ObjectPtr(const rabbit::Object& _obj) { + _type = _obj._type; + _unVal = _obj._unVal; + __addRef(_type,_unVal); +} + +rabbit::ObjectPtr::ObjectPtr(bool _value) { + SQ_OBJECT_RAWINIT() + _type = rabbit::OT_BOOL; + _unVal.nInteger = _value?1:0; +} + +rabbit::ObjectPtr& rabbit::ObjectPtr::operator=(bool _value) { + __release(_type,_unVal); + SQ_OBJECT_RAWINIT() + _type = rabbit::OT_BOOL; + _unVal.nInteger = _value?1:0; + return *this; +} + +rabbit::ObjectPtr::~ObjectPtr() { + __release(_type,_unVal); +} + +rabbit::ObjectPtr& rabbit::ObjectPtr::operator=(const rabbit::ObjectPtr& _obj) { + rabbit::ObjectType tOldType; + rabbit::ObjectValue unOldVal; + tOldType=_type; + unOldVal=_unVal; + _unVal = _obj._unVal; + _type = _obj._type; + __addRef(_type,_unVal); + __release(tOldType,unOldVal); + return *this; +} + +rabbit::ObjectPtr& rabbit::ObjectPtr::operator=(const rabbit::Object& _obj) { + rabbit::ObjectType tOldType; + rabbit::ObjectValue unOldVal; + tOldType=_type; + unOldVal=_unVal; + _unVal = _obj._unVal; + _type = _obj._type; + __addRef(_type,_unVal); + __release(tOldType,unOldVal); + return *this; +} + +void rabbit::ObjectPtr::Null() { + rabbit::ObjectType tOldType = _type; + rabbit::ObjectValue unOldVal = _unVal; + _type = rabbit::OT_NULL; + _unVal.raw = (SQRawObjectVal)NULL; + __release(tOldType ,unOldVal); +} + + + +uint64_t rabbit::translateIndex(const rabbit::ObjectPtr &idx) +{ + switch(sq_type(idx)){ + case rabbit::OT_NULL: + return 0; + case rabbit::OT_INTEGER: + return (uint64_t)_integer(idx); + default: assert(0); break; + } + return 0; +} + + +const rabbit::Char* rabbit::IdType2Name(rabbit::ObjectType type) +{ + switch(_RAW_TYPE(type)) + { + case _RT_NULL: + return _SC("null"); + case _RT_INTEGER: + return _SC("integer"); + case _RT_FLOAT: + return _SC("float"); + case _RT_BOOL: + return _SC("bool"); + case _RT_STRING: + return _SC("string"); + case _RT_TABLE: + return _SC("table"); + case _RT_ARRAY: + return _SC("array"); + case _RT_GENERATOR: + return _SC("generator"); + case _RT_CLOSURE: + case _RT_NATIVECLOSURE: + return _SC("function"); + case _RT_USERDATA: + case _RT_USERPOINTER: + return _SC("userdata"); + case _RT_THREAD: + return _SC("thread"); + case _RT_FUNCPROTO: + return _SC("function"); + case _RT_CLASS: + return _SC("class"); + case _RT_INSTANCE: + return _SC("instance"); + case _RT_WEAKREF: + return _SC("weakref"); + case _RT_OUTER: + return _SC("outer"); + default: + return NULL; + } +} + +const rabbit::Char* rabbit::getTypeName(const rabbit::ObjectPtr &obj1) +{ + return IdType2Name(sq_type(obj1)); +} diff --git a/rabbit/ObjectPtr.hpp b/rabbit/ObjectPtr.hpp new file mode 100644 index 0000000..cbdf488 --- /dev/null +++ b/rabbit/ObjectPtr.hpp @@ -0,0 +1,69 @@ +/** + * @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) + */ +#pragma once + +#include +#include +#include +#include +#include + +namespace rabbit { + #if defined(SQUSEDOUBLE) && !defined(_SQ64) || !defined(SQUSEDOUBLE) && defined(_SQ64) + #define SQ_REFOBJECT_INIT() SQ_OBJECT_RAWINIT() + #else + #define SQ_REFOBJECT_INIT() + #endif + #define RABBIT_OBJ_REF_TYPE_DECLARE(type,_class,sym) \ + ObjectPtr(_class * x);\ + ObjectPtr& operator=(_class *x); + + #define RABBIT_SCALAR_TYPE_DECLARE(type,_class,sym) \ + ObjectPtr(_class x); \ + ObjectPtr& operator=(_class x); + + class ObjectPtr : public rabbit::Object { + public: + ObjectPtr(); + ObjectPtr(const ObjectPtr& _obj); + ObjectPtr(const Object& _obj); + + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_TABLE, SQTable, pTable) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_CLASS, SQClass, pClass) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_INSTANCE, SQInstance, pInstance) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_ARRAY, rabbit::Array, pArray) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_CLOSURE, SQClosure, pClosure) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_NATIVECLOSURE, SQNativeClosure, pNativeClosure) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_OUTER, SQOuter, pOuter) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_GENERATOR, SQGenerator, pGenerator) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_STRING, SQString, pString) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_USERDATA, UserData, pUserData) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_WEAKREF, WeakRef, pWeakRef) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_THREAD, VirtualMachine, pThread) + RABBIT_OBJ_REF_TYPE_DECLARE(rabbit::OT_FUNCPROTO, SQFunctionProto, pFunctionProto) + + RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_INTEGER, int64_t, nInteger) + RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_FLOAT, float_t, fFloat) + RABBIT_SCALAR_TYPE_DECLARE(rabbit::OT_USERPOINTER, UserPointer, pUserPointer) + + ObjectPtr(bool _value); + ObjectPtr& operator=(bool _value); + ~ObjectPtr(); + ObjectPtr& operator=(const ObjectPtr& _obj); + ObjectPtr& operator=(const Object& _obj); + void Null(); + private: + ObjectPtr(const rabbit::Char * _obj){} //safety + }; + + + uint64_t translateIndex(const rabbit::ObjectPtr &idx); + const rabbit::Char *getTypeName(const rabbit::ObjectPtr &obj1); + const rabbit::Char *IdType2Name(rabbit::ObjectType type); + +} diff --git a/rabbit/ObjectType.cpp b/rabbit/ObjectType.cpp new file mode 100644 index 0000000..67337a3 --- /dev/null +++ b/rabbit/ObjectType.cpp @@ -0,0 +1,9 @@ +/** + * @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 diff --git a/rabbit/ObjectType.hpp b/rabbit/ObjectType.hpp new file mode 100644 index 0000000..1a59a9a --- /dev/null +++ b/rabbit/ObjectType.hpp @@ -0,0 +1,65 @@ +/** + * @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) + */ +#pragma once + +#include + +#define SQOBJECT_REF_COUNTED 0x08000000 +#define SQOBJECT_NUMERIC 0x04000000 +#define SQOBJECT_DELEGABLE 0x02000000 +#define SQOBJECT_CANBEFALSE 0x01000000 + +#define SQ_MATCHTYPEMASKSTRING (-99999) + +#define _RT_MASK 0x00FFFFFF +#define _RAW_TYPE(type) (type&_RT_MASK) + +#define _RT_NULL 0x00000001 +#define _RT_INTEGER 0x00000002 +#define _RT_FLOAT 0x00000004 +#define _RT_BOOL 0x00000008 +#define _RT_STRING 0x00000010 +#define _RT_TABLE 0x00000020 +#define _RT_ARRAY 0x00000040 +#define _RT_USERDATA 0x00000080 +#define _RT_CLOSURE 0x00000100 +#define _RT_NATIVECLOSURE 0x00000200 +#define _RT_GENERATOR 0x00000400 +#define _RT_USERPOINTER 0x00000800 +#define _RT_THREAD 0x00001000 +#define _RT_FUNCPROTO 0x00002000 +#define _RT_CLASS 0x00004000 +#define _RT_INSTANCE 0x00008000 +#define _RT_WEAKREF 0x00010000 +#define _RT_OUTER 0x00020000 + +namespace rabbit { + enum ObjectType{ + OT_NULL = (_RT_NULL|SQOBJECT_CANBEFALSE), + OT_INTEGER = (_RT_INTEGER|SQOBJECT_NUMERIC|SQOBJECT_CANBEFALSE), + OT_FLOAT = (_RT_FLOAT|SQOBJECT_NUMERIC|SQOBJECT_CANBEFALSE), + OT_BOOL = (_RT_BOOL|SQOBJECT_CANBEFALSE), + OT_STRING = (_RT_STRING|SQOBJECT_REF_COUNTED), + OT_TABLE = (_RT_TABLE|SQOBJECT_REF_COUNTED|SQOBJECT_DELEGABLE), + OT_ARRAY = (_RT_ARRAY|SQOBJECT_REF_COUNTED), + OT_USERDATA = (_RT_USERDATA|SQOBJECT_REF_COUNTED|SQOBJECT_DELEGABLE), + OT_CLOSURE = (_RT_CLOSURE|SQOBJECT_REF_COUNTED), + OT_NATIVECLOSURE = (_RT_NATIVECLOSURE|SQOBJECT_REF_COUNTED), + OT_GENERATOR = (_RT_GENERATOR|SQOBJECT_REF_COUNTED), + OT_USERPOINTER = _RT_USERPOINTER, + OT_THREAD = (_RT_THREAD|SQOBJECT_REF_COUNTED) , + OT_FUNCPROTO = (_RT_FUNCPROTO|SQOBJECT_REF_COUNTED), //internal usage only + OT_CLASS = (_RT_CLASS|SQOBJECT_REF_COUNTED), + OT_INSTANCE = (_RT_INSTANCE|SQOBJECT_REF_COUNTED|SQOBJECT_DELEGABLE), + OT_WEAKREF = (_RT_WEAKREF|SQOBJECT_REF_COUNTED), + OT_OUTER = (_RT_OUTER|SQOBJECT_REF_COUNTED) //internal usage only + }; +} + +#define ISREFCOUNTED(t) (t&SQOBJECT_REF_COUNTED) + diff --git a/rabbit/ObjectValue.cpp b/rabbit/ObjectValue.cpp new file mode 100644 index 0000000..544dea3 --- /dev/null +++ b/rabbit/ObjectValue.cpp @@ -0,0 +1,9 @@ +/** + * @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 diff --git a/rabbit/ObjectValue.hpp b/rabbit/ObjectValue.hpp new file mode 100644 index 0000000..81aaab1 --- /dev/null +++ b/rabbit/ObjectValue.hpp @@ -0,0 +1,40 @@ +/** + * @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) + */ +#pragma once + +#include +#include + +namespace rabbit { + + union ObjectValue + { + struct SQTable *pTable; + struct SQClosure *pClosure; + struct SQOuter *pOuter; + struct SQGenerator *pGenerator; + struct SQNativeClosure *pNativeClosure; + struct SQString *pString; + int64_t nInteger; + float_t fFloat; + struct SQFunctionProto *pFunctionProto; + struct SQClass *pClass; + struct SQInstance *pInstance; + + rabbit::Delegable *pDelegable; + rabbit::UserPointer pUserPointer; + rabbit::WeakRef* pWeakRef; + rabbit::VirtualMachine* pThread; + rabbit::RefCounted* pRefCounted; + rabbit::Array* pArray; + rabbit::UserData* pUserData; + + SQRawObjectVal raw; + }; + +} diff --git a/rabbit/RefCounted.cpp b/rabbit/RefCounted.cpp index 4cd05e3..543c328 100644 --- a/rabbit/RefCounted.cpp +++ b/rabbit/RefCounted.cpp @@ -12,7 +12,7 @@ #include #include -rabbit::WeakRef * rabbit::RefCounted::getWeakRef(SQObjectType type) { +rabbit::WeakRef * rabbit::RefCounted::getWeakRef(rabbit::ObjectType type) { if(!_weakref) { sq_new(_weakref, WeakRef); #if defined(SQUSEDOUBLE) && !defined(_SQ64) @@ -26,7 +26,7 @@ rabbit::WeakRef * rabbit::RefCounted::getWeakRef(SQObjectType type) { rabbit::RefCounted::~RefCounted() { if(_weakref) { - _weakref->_obj._type = OT_NULL; + _weakref->_obj._type = rabbit::OT_NULL; _weakref->_obj._unVal.pRefCounted = NULL; } } diff --git a/rabbit/RefCounted.hpp b/rabbit/RefCounted.hpp index 1b8550c..89d6891 100644 --- a/rabbit/RefCounted.hpp +++ b/rabbit/RefCounted.hpp @@ -8,7 +8,7 @@ #pragma once #include -#include +#include namespace rabbit { class WeakRef; @@ -19,12 +19,25 @@ namespace rabbit { public: RefCounted() {} virtual ~RefCounted(); - WeakRef *getWeakRef(SQObjectType _type); + WeakRef *getWeakRef(rabbit::ObjectType _type); virtual void release() = 0; void refCountIncrement(); int64_t refCountDecrement(); int64_t refCountget(); friend WeakRef; }; + #define __Objrelease(obj) { \ + if((obj)) { \ + auto val = (obj)->refCountDecrement(); \ + if(val == 0) { \ + (obj)->release(); \ + } \ + (obj) = NULL; \ + } \ + } + #define __ObjaddRef(obj) { \ + (obj)->refCountIncrement(); \ + } + } diff --git a/rabbit/RegFunction.cpp b/rabbit/RegFunction.cpp new file mode 100644 index 0000000..1119377 --- /dev/null +++ b/rabbit/RegFunction.cpp @@ -0,0 +1,9 @@ +/** + * @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 diff --git a/rabbit/RegFunction.hpp b/rabbit/RegFunction.hpp new file mode 100644 index 0000000..5dedfc4 --- /dev/null +++ b/rabbit/RegFunction.hpp @@ -0,0 +1,24 @@ +/** + * @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) + */ +#pragma once + +#include +#include +#include + +namespace rabbit { + + class RegFunction{ + public: + const rabbit::Char *name; + SQFUNCTION f; + int64_t nparamscheck; + const rabbit::Char *typemask; + }; + +} diff --git a/rabbit/StackInfos.cpp b/rabbit/StackInfos.cpp new file mode 100644 index 0000000..e69de29 diff --git a/rabbit/StackInfos.hpp b/rabbit/StackInfos.hpp new file mode 100644 index 0000000..26ac8bf --- /dev/null +++ b/rabbit/StackInfos.hpp @@ -0,0 +1,21 @@ +/** + * @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) + */ +#pragma once + +#include + +namespace rabbit { + + class StackInfos{ + public: + const rabbit::Char* funcname; + const rabbit::Char* source; + int64_t line; + }; + +} diff --git a/rabbit/UserData.hpp b/rabbit/UserData.hpp index 7d26e3c..4f57ea8 100644 --- a/rabbit/UserData.hpp +++ b/rabbit/UserData.hpp @@ -8,7 +8,7 @@ #pragma once namespace rabbit { - class UserData : public SQDelegable { + class UserData : public rabbit::Delegable { public: UserData(SQSharedState *ss) { _delegate = 0; @@ -26,7 +26,7 @@ namespace rabbit { } void release() { if (m_hook) { - m_hook((SQUserPointer)sq_aligning(this + 1),m_size); + m_hook((rabbit::UserPointer)sq_aligning(this + 1),m_size); } int64_t tsize = m_size; this->~UserData(); @@ -35,10 +35,10 @@ namespace rabbit { const int64_t& getsize() const { return m_size; } - const SQUserPointer& getTypeTag() const { + const rabbit::UserPointer& getTypeTag() const { return m_typetag; } - void setTypeTag(const SQUserPointer& _value) { + void setTypeTag(const rabbit::UserPointer& _value) { m_typetag = _value; } const SQRELEASEHOOK& getHook() const { @@ -50,6 +50,6 @@ namespace rabbit { protected: int64_t m_size; SQRELEASEHOOK m_hook; - SQUserPointer m_typetag; + rabbit::UserPointer m_typetag; }; } diff --git a/rabbit/VirtualMachine.cpp b/rabbit/VirtualMachine.cpp index b9c2893..2ea9adc 100644 --- a/rabbit/VirtualMachine.cpp +++ b/rabbit/VirtualMachine.cpp @@ -22,10 +22,10 @@ #define TARGET _stack[_stackbase+arg0] #define STK(a) _stack[_stackbase+(a)] -bool rabbit::VirtualMachine::BW_OP(uint64_t op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2) +bool rabbit::VirtualMachine::BW_OP(uint64_t op,rabbit::ObjectPtr &trg,const rabbit::ObjectPtr &o1,const rabbit::ObjectPtr &o2) { int64_t res; - if((sq_type(o1)| sq_type(o2)) == OT_INTEGER) + if((sq_type(o1)| sq_type(o2)) == rabbit::OT_INTEGER) { int64_t i1 = _integer(o1), i2 = _integer(o2); switch(op) { @@ -47,9 +47,9 @@ bool rabbit::VirtualMachine::BW_OP(uint64_t op,SQObjectPtr &trg,const SQObjectPt { \ int64_t tmask = sq_type(o1)|sq_type(o2); \ switch(tmask) { \ - case OT_INTEGER: trg = _integer(o1) op _integer(o2);break; \ - case (OT_FLOAT|OT_INTEGER): \ - case (OT_FLOAT): trg = tofloat(o1) op tofloat(o2); break;\ + case rabbit::OT_INTEGER: trg = _integer(o1) op _integer(o2);break; \ + case (rabbit::OT_FLOAT|OT_INTEGER): \ + case (rabbit::OT_FLOAT): trg = tofloat(o1) op tofloat(o2); break;\ default: _GUARD(ARITH_OP((#op)[0],trg,o1,o2)); break;\ } \ } @@ -58,18 +58,18 @@ bool rabbit::VirtualMachine::BW_OP(uint64_t op,SQObjectPtr &trg,const SQObjectPt { \ int64_t tmask = sq_type(o1)|sq_type(o2); \ switch(tmask) { \ - case OT_INTEGER: { int64_t i2 = _integer(o2); if(i2 == 0) { raise_error(err); SQ_THROW(); } trg = _integer(o1) op i2; } break;\ - case (OT_FLOAT|OT_INTEGER): \ - case (OT_FLOAT): trg = tofloat(o1) op tofloat(o2); break;\ + case rabbit::OT_INTEGER: { int64_t i2 = _integer(o2); if(i2 == 0) { raise_error(err); SQ_THROW(); } trg = _integer(o1) op i2; } break;\ + case (rabbit::OT_FLOAT|OT_INTEGER): \ + case (rabbit::OT_FLOAT): trg = tofloat(o1) op tofloat(o2); break;\ default: _GUARD(ARITH_OP((#op)[0],trg,o1,o2)); break;\ } \ } -bool rabbit::VirtualMachine::ARITH_OP(uint64_t op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2) +bool rabbit::VirtualMachine::ARITH_OP(uint64_t op,rabbit::ObjectPtr &trg,const rabbit::ObjectPtr &o1,const rabbit::ObjectPtr &o2) { int64_t tmask = sq_type(o1)| sq_type(o2); switch(tmask) { - case OT_INTEGER:{ + case rabbit::OT_INTEGER:{ int64_t res, i1 = _integer(o1), i2 = _integer(o2); switch(op) { case '+': res = i1 + i2; break; @@ -87,8 +87,8 @@ bool rabbit::VirtualMachine::ARITH_OP(uint64_t op,SQObjectPtr &trg,const SQObjec } trg = res; } break; - case (OT_FLOAT|OT_INTEGER): - case (OT_FLOAT):{ + case (rabbit::OT_FLOAT|OT_INTEGER): + case (rabbit::OT_FLOAT):{ float_t res, f1 = tofloat(o1), f2 = tofloat(o2); switch(op) { case '+': res = f1 + f2; break; @@ -153,9 +153,9 @@ rabbit::VirtualMachine::~VirtualMachine() finalize(); } -bool rabbit::VirtualMachine::arithMetaMethod(int64_t op,const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &dest) +bool rabbit::VirtualMachine::arithMetaMethod(int64_t op,const rabbit::ObjectPtr &o1,const rabbit::ObjectPtr &o2,rabbit::ObjectPtr &dest) { - SQMetaMethod mm; + rabbit::MetaMethod mm; switch(op){ case _SC('+'): mm=MT_ADD; break; case _SC('-'): mm=MT_SUB; break; @@ -166,7 +166,7 @@ bool rabbit::VirtualMachine::arithMetaMethod(int64_t op,const SQObjectPtr &o1,co } if(is_delegable(o1) && _delegable(o1)->_delegate) { - SQObjectPtr closure; + rabbit::ObjectPtr closure; if(_delegable(o1)->getMetaMethod(this, mm, closure)) { push(o1); push(o2); @@ -177,21 +177,21 @@ bool rabbit::VirtualMachine::arithMetaMethod(int64_t op,const SQObjectPtr &o1,co return false; } -bool rabbit::VirtualMachine::NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o) +bool rabbit::VirtualMachine::NEG_OP(rabbit::ObjectPtr &trg,const rabbit::ObjectPtr &o) { switch(sq_type(o)) { - case OT_INTEGER: + case rabbit::OT_INTEGER: trg = -_integer(o); return true; - case OT_FLOAT: + case rabbit::OT_FLOAT: trg = -_float(o); return true; - case OT_TABLE: - case OT_USERDATA: - case OT_INSTANCE: + case rabbit::OT_TABLE: + case rabbit::OT_USERDATA: + case rabbit::OT_INSTANCE: if(_delegable(o)->_delegate) { - SQObjectPtr closure; + rabbit::ObjectPtr closure; if(_delegable(o)->getMetaMethod(this, MT_UNM, closure)) { push(o); if(!callMetaMethod(closure, MT_UNM, 1, temp_reg)) return false; @@ -207,28 +207,28 @@ bool rabbit::VirtualMachine::NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o) } #define _RET_SUCCEED(exp) { result = (exp); return true; } -bool rabbit::VirtualMachine::objCmp(const SQObjectPtr &o1,const SQObjectPtr &o2,int64_t &result) +bool rabbit::VirtualMachine::objCmp(const rabbit::ObjectPtr &o1,const rabbit::ObjectPtr &o2,int64_t &result) { - SQObjectType t1 = sq_type(o1), t2 = sq_type(o2); + rabbit::ObjectType t1 = sq_type(o1), t2 = sq_type(o2); if(t1 == t2) { if(_rawval(o1) == _rawval(o2))_RET_SUCCEED(0); - SQObjectPtr res; + rabbit::ObjectPtr res; switch(t1){ - case OT_STRING: + case rabbit::OT_STRING: _RET_SUCCEED(scstrcmp(_stringval(o1),_stringval(o2))); - case OT_INTEGER: + case rabbit::OT_INTEGER: _RET_SUCCEED((_integer(o1)<_integer(o2))?-1:1); - case OT_FLOAT: + case rabbit::OT_FLOAT: _RET_SUCCEED((_float(o1)<_float(o2))?-1:1); - case OT_TABLE: - case OT_USERDATA: - case OT_INSTANCE: + case rabbit::OT_TABLE: + case rabbit::OT_USERDATA: + case rabbit::OT_INSTANCE: if(_delegable(o1)->_delegate) { - SQObjectPtr closure; + rabbit::ObjectPtr closure; if(_delegable(o1)->getMetaMethod(this, MT_CMP, closure)) { push(o1);push(o2); if(callMetaMethod(closure,MT_CMP,2,res)) { - if(sq_type(res) != OT_INTEGER) { + if(sq_type(res) != rabbit::OT_INTEGER) { raise_error(_SC("_cmp must return an integer")); return false; } @@ -242,13 +242,13 @@ bool rabbit::VirtualMachine::objCmp(const SQObjectPtr &o1,const SQObjectPtr &o2, _RET_SUCCEED( _userpointer(o1) < _userpointer(o2)?-1:1 ); } assert(0); - //if(type(res)!=OT_INTEGER) { raise_Compareerror(o1,o2); return false; } + //if(type(res)!=rabbit::OT_INTEGER) { raise_Compareerror(o1,o2); return false; } // _RET_SUCCEED(_integer(res)); } else{ if(sq_isnumeric(o1) && sq_isnumeric(o2)){ - if((t1==OT_INTEGER) && (t2==OT_FLOAT)) { + if((t1==rabbit::OT_INTEGER) && (t2==OT_FLOAT)) { if( _integer(o1)==_float(o2) ) { _RET_SUCCEED(0); } else if( _integer(o1)<_float(o2) ) { _RET_SUCCEED(-1); } _RET_SUCCEED(1); @@ -259,8 +259,8 @@ bool rabbit::VirtualMachine::objCmp(const SQObjectPtr &o1,const SQObjectPtr &o2, _RET_SUCCEED(1); } } - else if(t1==OT_NULL) {_RET_SUCCEED(-1);} - else if(t2==OT_NULL) {_RET_SUCCEED(1);} + else if(t1==rabbit::OT_NULL) {_RET_SUCCEED(-1);} + else if(t2==rabbit::OT_NULL) {_RET_SUCCEED(1);} else { raise_Compareerror(o1,o2); return false; } } @@ -268,7 +268,7 @@ bool rabbit::VirtualMachine::objCmp(const SQObjectPtr &o1,const SQObjectPtr &o2, _RET_SUCCEED(0); //cannot happen } -bool rabbit::VirtualMachine::CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res) +bool rabbit::VirtualMachine::CMP_OP(CmpOP op, const rabbit::ObjectPtr &o1,const rabbit::ObjectPtr &o2,rabbit::ObjectPtr &res) { int64_t r; if(objCmp(o1,o2,r)) { @@ -284,30 +284,30 @@ bool rabbit::VirtualMachine::CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObje return false; } -bool rabbit::VirtualMachine::toString(const SQObjectPtr &o,SQObjectPtr &res) +bool rabbit::VirtualMachine::toString(const rabbit::ObjectPtr &o,rabbit::ObjectPtr &res) { switch(sq_type(o)) { - case OT_STRING: + case rabbit::OT_STRING: res = o; return true; - case OT_FLOAT: + case rabbit::OT_FLOAT: scsprintf(_sp(sq_rsl(NUMBER_MAX_CHAR+1)),sq_rsl(NUMBER_MAX_CHAR),_SC("%g"),_float(o)); break; - case OT_INTEGER: + case rabbit::OT_INTEGER: scsprintf(_sp(sq_rsl(NUMBER_MAX_CHAR+1)),sq_rsl(NUMBER_MAX_CHAR),_PRINT_INT_FMT,_integer(o)); break; - case OT_BOOL: + case rabbit::OT_BOOL: scsprintf(_sp(sq_rsl(6)),sq_rsl(6),_integer(o)?_SC("true"):_SC("false")); break; - case OT_TABLE: - case OT_USERDATA: - case OT_INSTANCE: + case rabbit::OT_TABLE: + case rabbit::OT_USERDATA: + case rabbit::OT_INSTANCE: if(_delegable(o)->_delegate) { - SQObjectPtr closure; + rabbit::ObjectPtr closure; if(_delegable(o)->getMetaMethod(this, MT_TOSTRING, closure)) { push(o); if(callMetaMethod(closure,MT_TOSTRING,1,res)) { - if(sq_type(res) == OT_STRING) + if(sq_type(res) == rabbit::OT_STRING) return true; } else { @@ -318,34 +318,34 @@ bool rabbit::VirtualMachine::toString(const SQObjectPtr &o,SQObjectPtr &res) default: scsprintf(_sp(sq_rsl((sizeof(void*)*2)+NUMBER_MAX_CHAR)),sq_rsl((sizeof(void*)*2)+NUMBER_MAX_CHAR),_SC("(%s : 0x%p)"),getTypeName(o),(void*)_rawval(o)); } - res = SQString::create(_ss(this),_spval); + res = SQString::create(_get_shared_state(this),_spval); return true; } -bool rabbit::VirtualMachine::stringCat(const SQObjectPtr &str,const SQObjectPtr &obj,SQObjectPtr &dest) +bool rabbit::VirtualMachine::stringCat(const rabbit::ObjectPtr &str,const rabbit::ObjectPtr &obj,rabbit::ObjectPtr &dest) { - SQObjectPtr a, b; + rabbit::ObjectPtr a, b; if(!toString(str, a)) return false; if(!toString(obj, b)) return false; int64_t l = _string(a)->_len , ol = _string(b)->_len; - SQChar *s = _sp(sq_rsl(l + ol + 1)); + rabbit::Char *s = _sp(sq_rsl(l + ol + 1)); memcpy(s, _stringval(a), sq_rsl(l)); memcpy(s + l, _stringval(b), sq_rsl(ol)); - dest = SQString::create(_ss(this), _spval, l + ol); + dest = SQString::create(_get_shared_state(this), _spval, l + ol); return true; } -bool rabbit::VirtualMachine::typeOf(const SQObjectPtr &obj1,SQObjectPtr &dest) +bool rabbit::VirtualMachine::typeOf(const rabbit::ObjectPtr &obj1,rabbit::ObjectPtr &dest) { if(is_delegable(obj1) && _delegable(obj1)->_delegate) { - SQObjectPtr closure; + rabbit::ObjectPtr closure; if(_delegable(obj1)->getMetaMethod(this, MT_TYPEOF, closure)) { push(obj1); return callMetaMethod(closure,MT_TYPEOF,1,dest); } } - dest = SQString::create(_ss(this),getTypeName(obj1)); + dest = SQString::create(_get_shared_state(this),getTypeName(obj1)); return true; } @@ -359,7 +359,7 @@ bool rabbit::VirtualMachine::init(rabbit::VirtualMachine *friendvm, int64_t stac _stackbase = 0; _top = 0; if(!friendvm) { - _roottable = SQTable::create(_ss(this), 0); + _roottable = SQTable::create(_get_shared_state(this), 0); sq_base_register(this); } else { @@ -392,7 +392,7 @@ bool rabbit::VirtualMachine::startcall(SQClosure *closure,int64_t target,int64_t //dumpstack(stackbase); int64_t nvargs = nargs - paramssize; - rabbit::Array *arr = rabbit::Array::create(_ss(this),nvargs); + rabbit::Array *arr = rabbit::Array::create(_get_shared_state(this),nvargs); int64_t pbase = stackbase+paramssize; for(int64_t n = 0; n < nvargs; n++) { (*arr)[n] = _stack[pbase]; @@ -434,10 +434,10 @@ bool rabbit::VirtualMachine::startcall(SQClosure *closure,int64_t target,int64_t if (closure->_function->_bgenerator) { SQFunctionProto *f = closure->_function; - SQGenerator *gen = SQGenerator::create(_ss(this), closure); + SQGenerator *gen = SQGenerator::create(_get_shared_state(this), closure); if(!gen->yield(this,f->_stacksize)) return false; - SQObjectPtr temp; + rabbit::ObjectPtr temp; Return(1, target, temp); STK(target) = gen; } @@ -446,9 +446,9 @@ bool rabbit::VirtualMachine::startcall(SQClosure *closure,int64_t target,int64_t return true; } -bool rabbit::VirtualMachine::Return(int64_t _arg0, int64_t _arg1, SQObjectPtr &retval) +bool rabbit::VirtualMachine::Return(int64_t _arg0, int64_t _arg1, rabbit::ObjectPtr &retval) { - SQBool _isroot = ci->_root; + rabbit::Bool _isroot = ci->_root; int64_t callerbase = _stackbase - ci->_prevstkbase; if (_debughook) { @@ -457,7 +457,7 @@ bool rabbit::VirtualMachine::Return(int64_t _arg0, int64_t _arg1, SQObjectPtr &r } } - SQObjectPtr *dest; + rabbit::ObjectPtr *dest; if (_isroot) { dest = &(retval); } else if (ci->_target == -1) { @@ -480,18 +480,18 @@ bool rabbit::VirtualMachine::Return(int64_t _arg0, int64_t _arg1, SQObjectPtr &r #define _RET_ON_FAIL(exp) { if(!exp) return false; } -bool rabbit::VirtualMachine::PLOCAL_INC(int64_t op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr) +bool rabbit::VirtualMachine::PLOCAL_INC(int64_t op,rabbit::ObjectPtr &target, rabbit::ObjectPtr &a, rabbit::ObjectPtr &incr) { - SQObjectPtr trg; + rabbit::ObjectPtr trg; _RET_ON_FAIL(ARITH_OP( op , trg, a, incr)); target = a; a = trg; return true; } -bool rabbit::VirtualMachine::derefInc(int64_t op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix,int64_t selfidx) +bool rabbit::VirtualMachine::derefInc(int64_t op,rabbit::ObjectPtr &target, rabbit::ObjectPtr &self, rabbit::ObjectPtr &key, rabbit::ObjectPtr &incr, bool postfix,int64_t selfidx) { - SQObjectPtr tmp, tself = self, tkey = key; + rabbit::ObjectPtr tmp, tself = self, tkey = key; if (!get(tself, tkey, tmp, 0, selfidx)) { return false; } _RET_ON_FAIL(ARITH_OP( op , target, tmp, incr)) if (!set(tself, tkey, target,selfidx)) { return false; } @@ -507,7 +507,7 @@ bool rabbit::VirtualMachine::derefInc(int64_t op,SQObjectPtr &target, SQObjectPt #define arg3 (_i_._arg3) #define sarg3 ((int64_t)*((const signed char *)&_i_._arg3)) -SQRESULT rabbit::VirtualMachine::Suspend() +rabbit::Result rabbit::VirtualMachine::Suspend() { if (_suspended) return sq_throwerror(this, _SC("cannot suspend an already suspended vm")); @@ -518,34 +518,34 @@ SQRESULT rabbit::VirtualMachine::Suspend() #define _FINISH(howmuchtojump) {jump = howmuchtojump; return true; } -bool rabbit::VirtualMachine::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr -&o3,SQObjectPtr &o4,int64_t SQ_UNUSED_ARG(arg_2),int exitpos,int &jump) +bool rabbit::VirtualMachine::FOREACH_OP(rabbit::ObjectPtr &o1,rabbit::ObjectPtr &o2,rabbit::ObjectPtr +&o3,rabbit::ObjectPtr &o4,int64_t SQ_UNUSED_ARG(arg_2),int exitpos,int &jump) { int64_t nrefidx; switch(sq_type(o1)) { - case OT_TABLE: + case rabbit::OT_TABLE: if((nrefidx = _table(o1)->next(false,o4, o2, o3)) == -1) _FINISH(exitpos); o4 = (int64_t)nrefidx; _FINISH(1); - case OT_ARRAY: + case rabbit::OT_ARRAY: if((nrefidx = _array(o1)->next(o4, o2, o3)) == -1) _FINISH(exitpos); o4 = (int64_t) nrefidx; _FINISH(1); - case OT_STRING: + case rabbit::OT_STRING: if((nrefidx = _string(o1)->next(o4, o2, o3)) == -1)_FINISH(exitpos); o4 = (int64_t)nrefidx; _FINISH(1); - case OT_CLASS: + case rabbit::OT_CLASS: if((nrefidx = _class(o1)->next(o4, o2, o3)) == -1)_FINISH(exitpos); o4 = (int64_t)nrefidx; _FINISH(1); - case OT_USERDATA: - case OT_INSTANCE: + case rabbit::OT_USERDATA: + case rabbit::OT_INSTANCE: if(_delegable(o1)->_delegate) { - SQObjectPtr itr; - SQObjectPtr closure; + rabbit::ObjectPtr itr; + rabbit::ObjectPtr closure; if(_delegable(o1)->getMetaMethod(this, MT_NEXTI, closure)) { push(o1); push(o4); if(callMetaMethod(closure, MT_NEXTI, 2, itr)) { o4 = o2 = itr; - if(sq_type(itr) == OT_NULL) _FINISH(exitpos); + if(sq_type(itr) == rabbit::OT_NULL) _FINISH(exitpos); if(!get(o1, itr, o3, 0, DONT_FALL_BACK)) { raise_error(_SC("_nexti returned an invalid idx")); // cloud be changed return false; @@ -560,11 +560,11 @@ bool rabbit::VirtualMachine::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObject return false; } break; - case OT_GENERATOR: + case rabbit::OT_GENERATOR: if(_generator(o1)->_state == SQGenerator::eDead) _FINISH(exitpos); if(_generator(o1)->_state == SQGenerator::eSuspended) { int64_t idx = 0; - if(sq_type(o4) == OT_INTEGER) { + if(sq_type(o4) == rabbit::OT_INTEGER) { idx = _integer(o4) + 1; } o2 = idx; @@ -584,10 +584,10 @@ bool rabbit::VirtualMachine::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObject #define _GUARD(exp) { if(!exp) { SQ_THROW();} } -bool rabbit::VirtualMachine::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func) +bool rabbit::VirtualMachine::CLOSURE_OP(rabbit::ObjectPtr &target, SQFunctionProto *func) { int64_t nouters; - SQClosure *closure = SQClosure::create(_ss(this), func,_table(_roottable)->getWeakRef(OT_TABLE)); + SQClosure *closure = SQClosure::create(_get_shared_state(this), func,_table(_roottable)->getWeakRef(rabbit::OT_TABLE)); if((nouters = func->_noutervalues)) { for(int64_t i = 0; i_outervalues[i]; @@ -614,21 +614,21 @@ bool rabbit::VirtualMachine::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *fu } -bool rabbit::VirtualMachine::CLASS_OP(SQObjectPtr &target,int64_t baseclass,int64_t attributes) +bool rabbit::VirtualMachine::CLASS_OP(rabbit::ObjectPtr &target,int64_t baseclass,int64_t attributes) { SQClass *base = NULL; - SQObjectPtr attrs; + rabbit::ObjectPtr attrs; if(baseclass != -1) { - if(sq_type(_stack[_stackbase+baseclass]) != OT_CLASS) { raise_error(_SC("trying to inherit from a %s"),getTypeName(_stack[_stackbase+baseclass])); return false; } + if(sq_type(_stack[_stackbase+baseclass]) != rabbit::OT_CLASS) { raise_error(_SC("trying to inherit from a %s"),getTypeName(_stack[_stackbase+baseclass])); return false; } base = _class(_stack[_stackbase + baseclass]); } if(attributes != MAX_FUNC_STACKSIZE) { attrs = _stack[_stackbase+attributes]; } - target = SQClass::create(_ss(this),base); - if(sq_type(_class(target)->_metamethods[MT_INHERITED]) != OT_NULL) { + target = SQClass::create(_get_shared_state(this),base); + if(sq_type(_class(target)->_metamethods[MT_INHERITED]) != rabbit::OT_NULL) { int nparams = 2; - SQObjectPtr ret; + rabbit::ObjectPtr ret; push(target); push(attrs); if(!call(_class(target)->_metamethods[MT_INHERITED],nparams,_top - nparams, ret, false)) { pop(nparams); @@ -640,7 +640,7 @@ bool rabbit::VirtualMachine::CLASS_OP(SQObjectPtr &target,int64_t baseclass,int6 return true; } -bool rabbit::VirtualMachine::isEqual(const SQObjectPtr &o1,const SQObjectPtr &o2,bool &res) +bool rabbit::VirtualMachine::isEqual(const rabbit::ObjectPtr &o1,const rabbit::ObjectPtr &o2,bool &res) { if(sq_type(o1) == sq_type(o2)) { res = (_rawval(o1) == _rawval(o2)); @@ -656,14 +656,14 @@ bool rabbit::VirtualMachine::isEqual(const SQObjectPtr &o1,const SQObjectPtr &o2 return true; } -bool rabbit::VirtualMachine::IsFalse(SQObjectPtr &o) +bool rabbit::VirtualMachine::IsFalse(rabbit::ObjectPtr &o) { if(((sq_type(o) & SQOBJECT_CANBEFALSE) - && ( ((sq_type(o) == OT_FLOAT) && (_float(o) == float_t(0.0))) )) + && ( ((sq_type(o) == rabbit::OT_FLOAT) && (_float(o) == float_t(0.0))) )) #if !defined(SQUSEDOUBLE) || (defined(SQUSEDOUBLE) && defined(_SQ64)) - || (_integer(o) == 0) ) //OT_NULL|OT_INTEGER|OT_BOOL + || (_integer(o) == 0) ) //rabbit::OT_NULL|OT_INTEGER|OT_BOOL #else - || (((type(o) != OT_FLOAT) && (_integer(o) == 0))) ) //OT_NULL|OT_INTEGER|OT_BOOL + || (((type(o) != rabbit::OT_FLOAT) && (_integer(o) == 0))) ) //OT_NULL|OT_INTEGER|OT_BOOL #endif { return true; @@ -671,7 +671,7 @@ bool rabbit::VirtualMachine::IsFalse(SQObjectPtr &o) return false; } extern SQInstructionDesc g_InstrDesc[]; -bool rabbit::VirtualMachine::execute(SQObjectPtr &closure, int64_t nargs, int64_t stackbase,SQObjectPtr &outres, SQBool raiseerror,ExecutionType et) +bool rabbit::VirtualMachine::execute(rabbit::ObjectPtr &closure, int64_t nargs, int64_t stackbase,rabbit::ObjectPtr &outres, rabbit::Bool raiseerror,ExecutionType et) { if ((_nnativecalls + 1) > MAX_NATIVE_CALLS) { raise_error(_SC("Native stack overflow")); return false; } _nnativecalls++; @@ -725,10 +725,10 @@ exception_restore: case _OP_LOADFLOAT: TARGET = *((const float_t *)&arg1); continue; case _OP_DLOAD: TARGET = ci->_literals[arg1]; STK(arg2) = ci->_literals[arg3];continue; case _OP_TAILCALL:{ - SQObjectPtr &t = STK(arg1); - if (sq_type(t) == OT_CLOSURE + rabbit::ObjectPtr &t = STK(arg1); + if (sq_type(t) == rabbit::OT_CLOSURE && (!_closure(t)->_function->_bgenerator)){ - SQObjectPtr clo = t; + rabbit::ObjectPtr clo = t; int64_t last_top = _top; if(_openouters) closeOuters(&(_stack[_stackbase])); for (int64_t i = 0; i < arg3; i++) STK(i) = STK(arg2 + i); @@ -740,12 +740,12 @@ exception_restore: } } case _OP_CALL: { - SQObjectPtr clo = STK(arg1); + rabbit::ObjectPtr clo = STK(arg1); switch (sq_type(clo)) { - case OT_CLOSURE: + case rabbit::OT_CLOSURE: _GUARD(startcall(_closure(clo), sarg0, arg3, _stackbase+arg2, false)); continue; - case OT_NATIVECLOSURE: { + case rabbit::OT_NATIVECLOSURE: { bool suspend; bool tailcall; _GUARD(callNative(_nativeclosure(clo), arg3, _stackbase+arg2, clo, (int32_t)sarg0, suspend, tailcall)); @@ -762,20 +762,20 @@ exception_restore: } } continue; - case OT_CLASS:{ - SQObjectPtr inst; + case rabbit::OT_CLASS:{ + rabbit::ObjectPtr inst; _GUARD(createClassInstance(_class(clo),inst,clo)); if(sarg0 != -1) { STK(arg0) = inst; } int64_t stkbase; switch(sq_type(clo)) { - case OT_CLOSURE: + case rabbit::OT_CLOSURE: stkbase = _stackbase+arg2; _stack[stkbase] = inst; _GUARD(startcall(_closure(clo), -1, arg3, stkbase, false)); break; - case OT_NATIVECLOSURE: + case rabbit::OT_NATIVECLOSURE: bool dummy; stkbase = _stackbase+arg2; _stack[stkbase] = inst; @@ -785,10 +785,10 @@ exception_restore: } } break; - case OT_TABLE: - case OT_USERDATA: - case OT_INSTANCE:{ - SQObjectPtr closure; + case rabbit::OT_TABLE: + case rabbit::OT_USERDATA: + case rabbit::OT_INSTANCE:{ + rabbit::ObjectPtr closure; if(_delegable(clo)->_delegate && _delegable(clo)->getMetaMethod(this,MT_CALL,closure)) { push(clo); for (int64_t i = 0; i < arg3; i++) push(STK(arg2 + i)); @@ -810,8 +810,8 @@ exception_restore: continue; case _OP_PREPCALL: case _OP_PREPCALLK: { - SQObjectPtr &key = _i_.op == _OP_PREPCALLK?(ci->_literals)[arg1]:STK(arg1); - SQObjectPtr &o = STK(arg2); + rabbit::ObjectPtr &key = _i_.op == _OP_PREPCALLK?(ci->_literals)[arg1]:STK(arg1); + rabbit::ObjectPtr &o = STK(arg2); if (!get(o, key, temp_reg,0,arg2)) { SQ_THROW(); } @@ -867,7 +867,7 @@ exception_restore: case _OP_LOADNULLS:{ for(int32_t n=0; n < arg1; n++) STK(arg0+n).Null(); }continue; case _OP_LOADROOT: { rabbit::WeakRef *w = _closure(ci->_closure)->_root; - if(sq_type(w->_obj) != OT_NULL) { + if(sq_type(w->_obj) != rabbit::OT_NULL) { TARGET = w->_obj; } else { TARGET = _roottable; //shoud this be like this? or null @@ -900,14 +900,14 @@ exception_restore: continue; case _OP_NEWOBJ: switch(arg3) { - case NOT_TABLE: TARGET = SQTable::create(_ss(this), arg1); continue; - case NOT_ARRAY: TARGET = rabbit::Array::create(_ss(this), 0); _array(TARGET)->reserve(arg1); continue; + case NOT_TABLE: TARGET = SQTable::create(_get_shared_state(this), arg1); continue; + case NOT_ARRAY: TARGET = rabbit::Array::create(_get_shared_state(this), 0); _array(TARGET)->reserve(arg1); continue; case NOT_CLASS: _GUARD(CLASS_OP(TARGET,arg1,arg2)); continue; default: assert(0); continue; } case _OP_APPENDARRAY: { - SQObject val; + rabbit::Object val; val._unVal.raw = 0; switch(arg2) { case AAT_STACK: @@ -915,7 +915,7 @@ exception_restore: case AAT_LITERAL: val = ci->_literals[arg1]; break; case AAT_INT: - val._type = OT_INTEGER; + val._type = rabbit::OT_INTEGER; #ifndef _SQ64 val._unVal.nInteger = (int64_t)arg1; #else @@ -923,14 +923,14 @@ exception_restore: #endif break; case AAT_FLOAT: - val._type = OT_FLOAT; + val._type = rabbit::OT_FLOAT; val._unVal.fFloat = *((const float_t *)&arg1); break; case AAT_BOOL: - val._type = OT_BOOL; + val._type = rabbit::OT_BOOL; val._unVal.nInteger = arg1; break; - default: val._type = OT_INTEGER; assert(0); break; + default: val._type = rabbit::OT_INTEGER; assert(0); break; } _array(STK(arg0))->append(val); continue; @@ -940,35 +940,35 @@ exception_restore: _GUARD(derefInc(arg3, TARGET, STK(selfidx), STK(arg2), STK(arg1&0x0000FFFF), false, selfidx)); } continue; - case _OP_INC: {SQObjectPtr o(sarg3); _GUARD(derefInc('+',TARGET, STK(arg1), STK(arg2), o, false, arg1));} continue; + case _OP_INC: {rabbit::ObjectPtr o(sarg3); _GUARD(derefInc('+',TARGET, STK(arg1), STK(arg2), o, false, arg1));} continue; case _OP_INCL: { - SQObjectPtr &a = STK(arg1); - if(sq_type(a) == OT_INTEGER) { + rabbit::ObjectPtr &a = STK(arg1); + if(sq_type(a) == rabbit::OT_INTEGER) { a._unVal.nInteger = _integer(a) + sarg3; } else { - SQObjectPtr o(sarg3); //_GUARD(LOCAL_INC('+',TARGET, STK(arg1), o)); + rabbit::ObjectPtr o(sarg3); //_GUARD(LOCAL_INC('+',TARGET, STK(arg1), o)); _ARITH_(+,a,a,o); } } continue; - case _OP_PINC: {SQObjectPtr o(sarg3); _GUARD(derefInc('+',TARGET, STK(arg1), STK(arg2), o, true, arg1));} continue; + case _OP_PINC: {rabbit::ObjectPtr o(sarg3); _GUARD(derefInc('+',TARGET, STK(arg1), STK(arg2), o, true, arg1));} continue; case _OP_PINCL: { - SQObjectPtr &a = STK(arg1); - if(sq_type(a) == OT_INTEGER) { + rabbit::ObjectPtr &a = STK(arg1); + if(sq_type(a) == rabbit::OT_INTEGER) { TARGET = a; a._unVal.nInteger = _integer(a) + sarg3; } else { - SQObjectPtr o(sarg3); _GUARD(PLOCAL_INC('+',TARGET, STK(arg1), o)); + rabbit::ObjectPtr o(sarg3); _GUARD(PLOCAL_INC('+',TARGET, STK(arg1), o)); } } continue; case _OP_CMP: _GUARD(CMP_OP((CmpOP)arg3,STK(arg2),STK(arg1),TARGET)) continue; case _OP_EXISTS: TARGET = get(STK(arg1), STK(arg2), temp_reg, GET_FLAG_DO_NOT_RAISE_ERROR | GET_FLAG_RAW, DONT_FALL_BACK) ? true : false; continue; case _OP_INSTANCEOF: - if(sq_type(STK(arg1)) != OT_CLASS) + if(sq_type(STK(arg1)) != rabbit::OT_CLASS) {raise_error(_SC("cannot apply instanceof between a %s and a %s"),getTypeName(STK(arg1)),getTypeName(STK(arg2))); SQ_THROW();} - TARGET = (sq_type(STK(arg2)) == OT_INSTANCE) ? (_instance(STK(arg2))->instanceOf(_class(STK(arg1)))?true:false) : false; + TARGET = (sq_type(STK(arg2)) == rabbit::OT_INSTANCE) ? (_instance(STK(arg2))->instanceOf(_class(STK(arg1)))?true:false) : false; continue; case _OP_AND: if(IsFalse(STK(arg2))) { @@ -985,7 +985,7 @@ exception_restore: case _OP_NEG: _GUARD(NEG_OP(TARGET,STK(arg1))); continue; case _OP_NOT: TARGET = IsFalse(STK(arg1)); continue; case _OP_BWNOT: - if(sq_type(STK(arg1)) == OT_INTEGER) { + if(sq_type(STK(arg1)) == rabbit::OT_INTEGER) { int64_t t = _integer(STK(arg1)); TARGET = int64_t(~t); continue; @@ -1015,7 +1015,7 @@ exception_restore: } continue; case _OP_RESUME: - if(sq_type(STK(arg1)) != OT_GENERATOR){ raise_error(_SC("trying to resume a '%s',only genenerator can be resumed"), getTypeName(STK(arg1))); SQ_THROW();} + if(sq_type(STK(arg1)) != rabbit::OT_GENERATOR){ raise_error(_SC("trying to resume a '%s',only genenerator can be resumed"), getTypeName(STK(arg1))); SQ_THROW();} _GUARD(_generator(STK(arg1))->resume(this, TARGET)); traps += ci->_etraps; continue; @@ -1024,7 +1024,7 @@ exception_restore: ci->_ip += tojump; } continue; case _OP_POSTFOREACH: - assert(sq_type(STK(arg0)) == OT_GENERATOR); + assert(sq_type(STK(arg0)) == rabbit::OT_GENERATOR); if(_generator(STK(arg0))->_state == SQGenerator::eDead) ci->_ip += (sarg1 - 1); continue; @@ -1032,7 +1032,7 @@ exception_restore: case _OP_TYPEOF: _GUARD(typeOf(STK(arg1), TARGET)) continue; case _OP_PUSHTRAP:{ SQInstruction *_iv = _closure(ci->_closure)->_function->_instructions; - _etraps.pushBack(SQExceptionTrap(_top,_stackbase, &_iv[(ci->_ip-_iv)+arg1], arg0)); traps++; + _etraps.pushBack(rabbit::ExceptionTrap(_top,_stackbase, &_iv[(ci->_ip-_iv)+arg1], arg0)); traps++; ci->_etraps++; } continue; @@ -1045,7 +1045,7 @@ exception_restore: continue; case _OP_THROW: raise_error(TARGET); SQ_THROW(); continue; case _OP_NEWSLOTA: - _GUARD(newSlotA(STK(arg1),STK(arg2),STK(arg3),(arg0&NEW_SLOT_ATTRIBUTES_FLAG) ? STK(arg2-1) : SQObjectPtr(),(arg0&NEW_SLOT_STATIC_FLAG)?true:false,false)); + _GUARD(newSlotA(STK(arg1),STK(arg2),STK(arg3),(arg0&NEW_SLOT_ATTRIBUTES_FLAG) ? STK(arg2-1) : rabbit::ObjectPtr(),(arg0&NEW_SLOT_STATIC_FLAG)?true:false,false)); continue; case _OP_GETBASE:{ SQClosure *clo = _closure(ci->_closure); @@ -1066,16 +1066,16 @@ exception_restore: } exception_trap: { - SQObjectPtr currerror = _lasterror; + rabbit::ObjectPtr currerror = _lasterror; // dumpstack(_stackbase); // int64_t n = 0; int64_t last_top = _top; - if(_ss(this)->_notifyallexceptions || (!traps && raiseerror)) callerrorHandler(currerror); + if(_get_shared_state(this)->_notifyallexceptions || (!traps && raiseerror)) callerrorHandler(currerror); while( ci ) { if(ci->_etraps > 0) { - SQExceptionTrap &et = _etraps.back(); + rabbit::ExceptionTrap &et = _etraps.back(); ci->_ip = et._ip; _top = et._stacksize; _stackbase = et._stackbase; @@ -1103,7 +1103,7 @@ exception_trap: assert(0); } -bool rabbit::VirtualMachine::createClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor) +bool rabbit::VirtualMachine::createClassInstance(SQClass *theclass, rabbit::ObjectPtr &inst, rabbit::ObjectPtr &constructor) { inst = theclass->createInstance(); if(!theclass->getConstructor(constructor)) { @@ -1112,10 +1112,10 @@ bool rabbit::VirtualMachine::createClassInstance(SQClass *theclass, SQObjectPtr return true; } -void rabbit::VirtualMachine::callerrorHandler(SQObjectPtr &error) +void rabbit::VirtualMachine::callerrorHandler(rabbit::ObjectPtr &error) { - if(sq_type(_errorhandler) != OT_NULL) { - SQObjectPtr out; + if(sq_type(_errorhandler) != rabbit::OT_NULL) { + rabbit::ObjectPtr out; push(_roottable); push(error); call(_errorhandler, 2, _top-2, out,SQFalse); pop(2); @@ -1128,13 +1128,13 @@ void rabbit::VirtualMachine::callDebugHook(int64_t type,int64_t forcedline) _debughook = false; SQFunctionProto *func=_closure(ci->_closure)->_function; if(_debughook_native) { - const SQChar *src = sq_type(func->_sourcename) == OT_STRING?_stringval(func->_sourcename):NULL; - const SQChar *fname = sq_type(func->_name) == OT_STRING?_stringval(func->_name):NULL; + const rabbit::Char *src = sq_type(func->_sourcename) == rabbit::OT_STRING?_stringval(func->_sourcename):NULL; + const rabbit::Char *fname = sq_type(func->_name) == rabbit::OT_STRING?_stringval(func->_name):NULL; int64_t line = forcedline?forcedline:func->getLine(ci->_ip); _debughook_native(this,type,src,line,fname); } else { - SQObjectPtr temp_reg; + rabbit::ObjectPtr temp_reg; int64_t nparams=5; push(_roottable); push(type); @@ -1147,7 +1147,7 @@ void rabbit::VirtualMachine::callDebugHook(int64_t type,int64_t forcedline) _debughook = true; } -bool rabbit::VirtualMachine::callNative(SQNativeClosure *nclosure, int64_t nargs, int64_t newbase, SQObjectPtr &retval, int32_t target,bool &suspend, bool &tailcall) +bool rabbit::VirtualMachine::callNative(SQNativeClosure *nclosure, int64_t nargs, int64_t newbase, rabbit::ObjectPtr &retval, int32_t target,bool &suspend, bool &tailcall) { int64_t nparamscheck = nclosure->_nparamscheck; int64_t newtop = newbase + nargs + nclosure->_noutervalues; @@ -1165,7 +1165,7 @@ bool rabbit::VirtualMachine::callNative(SQNativeClosure *nclosure, int64_t nargs } int64_t tcs; - SQIntVec &tc = nclosure->_typecheck; + etk::Vector &tc = nclosure->_typecheck; if((tcs = tc.size())) { for(int64_t i = 0; i < nargs && i < tcs; i++) { if((tc[i] != -1) && !(sq_type(_stack[newbase+i]) & tc[i])) { @@ -1219,7 +1219,7 @@ bool rabbit::VirtualMachine::callNative(SQNativeClosure *nclosure, int64_t nargs bool rabbit::VirtualMachine::tailcall(SQClosure *closure, int64_t parambase,int64_t nparams) { int64_t last_top = _top; - SQObjectPtr clo = closure; + rabbit::ObjectPtr clo = closure; if (ci->_root) { raise_error("root calls cannot invoke tailcalls"); @@ -1237,22 +1237,22 @@ bool rabbit::VirtualMachine::tailcall(SQClosure *closure, int64_t parambase,int6 #define FALLBACK_NO_MATCH 1 #define FALLBACK_ERROR 2 -bool rabbit::VirtualMachine::get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &dest, uint64_t getflags, int64_t selfidx) +bool rabbit::VirtualMachine::get(const rabbit::ObjectPtr &self, const rabbit::ObjectPtr &key, rabbit::ObjectPtr &dest, uint64_t getflags, int64_t selfidx) { switch(sq_type(self)){ - case OT_TABLE: + case rabbit::OT_TABLE: if(_table(self)->get(key,dest))return true; break; - case OT_ARRAY: + case rabbit::OT_ARRAY: if (sq_isnumeric(key)) { if (_array(self)->get(tointeger(key), dest)) { return true; } if ((getflags & GET_FLAG_DO_NOT_RAISE_ERROR) == 0) raise_Idxerror(key); return false; } break; - case OT_INSTANCE: + case rabbit::OT_INSTANCE: if(_instance(self)->get(key,dest)) return true; break; - case OT_CLASS: + case rabbit::OT_CLASS: if(_class(self)->get(key,dest)) return true; break; - case OT_STRING: + case rabbit::OT_STRING: if(sq_isnumeric(key)){ int64_t n = tointeger(key); int64_t len = _string(self)->_len; @@ -1277,12 +1277,12 @@ bool rabbit::VirtualMachine::get(const SQObjectPtr &self, const SQObjectPtr &key return true; } } -//#ifdef ROOT_FALLBACK +//#ifdef ROrabbit::OT_FALLBACK if(selfidx == 0) { rabbit::WeakRef *w = _closure(ci->_closure)->_root; - if(sq_type(w->_obj) != OT_NULL) + if(sq_type(w->_obj) != rabbit::OT_NULL) { - if(get(*((const SQObjectPtr *)&w->_obj),key,dest,0,DONT_FALL_BACK)) return true; + if(get(*((const rabbit::ObjectPtr *)&w->_obj),key,dest,0,DONT_FALL_BACK)) return true; } } @@ -1291,41 +1291,41 @@ bool rabbit::VirtualMachine::get(const SQObjectPtr &self, const SQObjectPtr &key return false; } -bool rabbit::VirtualMachine::invokeDefaultDelegate(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest) +bool rabbit::VirtualMachine::invokeDefaultDelegate(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,rabbit::ObjectPtr &dest) { SQTable *ddel = NULL; switch(sq_type(self)) { - case OT_CLASS: ddel = _class_ddel; break; - case OT_TABLE: ddel = _table_ddel; break; - case OT_ARRAY: ddel = _array_ddel; break; - case OT_STRING: ddel = _string_ddel; break; - case OT_INSTANCE: ddel = _instance_ddel; break; - case OT_INTEGER:case OT_FLOAT:case OT_BOOL: ddel = _number_ddel; break; - case OT_GENERATOR: ddel = _generator_ddel; break; - case OT_CLOSURE: case OT_NATIVECLOSURE: ddel = _closure_ddel; break; - case OT_THREAD: ddel = _thread_ddel; break; - case OT_WEAKREF: ddel = _weakref_ddel; break; + case rabbit::OT_CLASS: ddel = _class_ddel; break; + case rabbit::OT_TABLE: ddel = _table_ddel; break; + case rabbit::OT_ARRAY: ddel = _array_ddel; break; + case rabbit::OT_STRING: ddel = _string_ddel; break; + case rabbit::OT_INSTANCE: ddel = _instance_ddel; break; + case rabbit::OT_INTEGER:case OT_FLOAT:case OT_BOOL: ddel = _number_ddel; break; + case rabbit::OT_GENERATOR: ddel = _generator_ddel; break; + case rabbit::OT_CLOSURE: case OT_NATIVECLOSURE: ddel = _closure_ddel; break; + case rabbit::OT_THREAD: ddel = _thread_ddel; break; + case rabbit::OT_WEAKREF: ddel = _weakref_ddel; break; default: return false; } return ddel->get(key,dest); } -int64_t rabbit::VirtualMachine::fallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest) +int64_t rabbit::VirtualMachine::fallBackGet(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,rabbit::ObjectPtr &dest) { switch(sq_type(self)){ - case OT_TABLE: - case OT_USERDATA: + case rabbit::OT_TABLE: + case rabbit::OT_USERDATA: //delegation if(_delegable(self)->_delegate) { - if(get(SQObjectPtr(_delegable(self)->_delegate),key,dest,0,DONT_FALL_BACK)) return FALLBACK_OK; + if(get(rabbit::ObjectPtr(_delegable(self)->_delegate),key,dest,0,DONT_FALL_BACK)) return FALLBACK_OK; } else { return FALLBACK_NO_MATCH; } //go through - case OT_INSTANCE: { - SQObjectPtr closure; + case rabbit::OT_INSTANCE: { + rabbit::ObjectPtr closure; if(_delegable(self)->getMetaMethod(this, MT_GET, closure)) { push(self);push(key); _nmetamethodscall++; @@ -1336,7 +1336,7 @@ int64_t rabbit::VirtualMachine::fallBackGet(const SQObjectPtr &self,const SQObje } else { pop(2); - if(sq_type(_lasterror) != OT_NULL) { //NULL means "clean failure" (not found) + if(sq_type(_lasterror) != rabbit::OT_NULL) { //NULL means "clean failure" (not found) return FALLBACK_ERROR; } } @@ -1349,23 +1349,23 @@ int64_t rabbit::VirtualMachine::fallBackGet(const SQObjectPtr &self,const SQObje return FALLBACK_NO_MATCH; } -bool rabbit::VirtualMachine::set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,int64_t selfidx) +bool rabbit::VirtualMachine::set(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,int64_t selfidx) { switch(sq_type(self)){ - case OT_TABLE: + case rabbit::OT_TABLE: if(_table(self)->set(key,val)) return true; break; - case OT_INSTANCE: + case rabbit::OT_INSTANCE: if(_instance(self)->set(key,val)) return true; break; - case OT_ARRAY: + case rabbit::OT_ARRAY: if(!sq_isnumeric(key)) { raise_error(_SC("indexing %s with %s"),getTypeName(self),getTypeName(key)); return false; } if(!_array(self)->set(tointeger(key),val)) { raise_Idxerror(key); return false; } return true; - case OT_USERDATA: break; // must fall back + case rabbit::OT_USERDATA: break; // must fall back default: raise_error(_SC("trying to set '%s'"),getTypeName(self)); return false; @@ -1384,18 +1384,18 @@ bool rabbit::VirtualMachine::set(const SQObjectPtr &self,const SQObjectPtr &key, return false; } -int64_t rabbit::VirtualMachine::fallBackSet(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val) +int64_t rabbit::VirtualMachine::fallBackSet(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val) { switch(sq_type(self)) { - case OT_TABLE: + case rabbit::OT_TABLE: if(_table(self)->_delegate) { if(set(_table(self)->_delegate,key,val,DONT_FALL_BACK)) return FALLBACK_OK; } //keps on going - case OT_INSTANCE: - case OT_USERDATA:{ - SQObjectPtr closure; - SQObjectPtr t; + case rabbit::OT_INSTANCE: + case rabbit::OT_USERDATA:{ + rabbit::ObjectPtr closure; + rabbit::ObjectPtr t; if(_delegable(self)->getMetaMethod(this, MT_SET, closure)) { push(self);push(key);push(val); _nmetamethodscall++; @@ -1406,7 +1406,7 @@ int64_t rabbit::VirtualMachine::fallBackSet(const SQObjectPtr &self,const SQObje } else { pop(3); - if(sq_type(_lasterror) != OT_NULL) { //NULL means "clean failure" (not found) + if(sq_type(_lasterror) != rabbit::OT_NULL) { //NULL means "clean failure" (not found) return FALLBACK_ERROR; } } @@ -1419,18 +1419,18 @@ int64_t rabbit::VirtualMachine::fallBackSet(const SQObjectPtr &self,const SQObje return FALLBACK_NO_MATCH; } -bool rabbit::VirtualMachine::clone(const SQObjectPtr &self,SQObjectPtr &target) +bool rabbit::VirtualMachine::clone(const rabbit::ObjectPtr &self,rabbit::ObjectPtr &target) { - SQObjectPtr temp_reg; - SQObjectPtr newobj; + rabbit::ObjectPtr temp_reg; + rabbit::ObjectPtr newobj; switch(sq_type(self)){ - case OT_TABLE: + case rabbit::OT_TABLE: newobj = _table(self)->clone(); goto cloned_mt; - case OT_INSTANCE: { - newobj = _instance(self)->clone(_ss(this)); + case rabbit::OT_INSTANCE: { + newobj = _instance(self)->clone(_get_shared_state(this)); cloned_mt: - SQObjectPtr closure; + rabbit::ObjectPtr closure; if(_delegable(newobj)->_delegate && _delegable(newobj)->getMetaMethod(this,MT_CLONED,closure)) { push(newobj); push(self); @@ -1440,7 +1440,7 @@ cloned_mt: } target = newobj; return true; - case OT_ARRAY: + case rabbit::OT_ARRAY: target = _array(self)->clone(); return true; default: @@ -1449,16 +1449,16 @@ cloned_mt: } } -bool rabbit::VirtualMachine::newSlotA(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,const SQObjectPtr &attrs,bool bstatic,bool raw) +bool rabbit::VirtualMachine::newSlotA(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,const rabbit::ObjectPtr &attrs,bool bstatic,bool raw) { - if(sq_type(self) != OT_CLASS) { + if(sq_type(self) != rabbit::OT_CLASS) { raise_error(_SC("object must be a class")); return false; } SQClass *c = _class(self); if(!raw) { - SQObjectPtr &mm = c->_metamethods[MT_NEWMEMBER]; - if(sq_type(mm) != OT_NULL ) { + rabbit::ObjectPtr &mm = c->_metamethods[MT_NEWMEMBER]; + if(sq_type(mm) != rabbit::OT_NULL ) { push(self); push(key); push(val); push(attrs); push(bstatic); @@ -1467,22 +1467,22 @@ bool rabbit::VirtualMachine::newSlotA(const SQObjectPtr &self,const SQObjectPtr } if(!newSlot(self, key, val,bstatic)) return false; - if(sq_type(attrs) != OT_NULL) { + if(sq_type(attrs) != rabbit::OT_NULL) { c->setAttributes(key,attrs); } return true; } -bool rabbit::VirtualMachine::newSlot(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,bool bstatic) +bool rabbit::VirtualMachine::newSlot(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,bool bstatic) { - if(sq_type(key) == OT_NULL) { raise_error(_SC("null cannot be used as index")); return false; } + if(sq_type(key) == rabbit::OT_NULL) { raise_error(_SC("null cannot be used as index")); return false; } switch(sq_type(self)) { - case OT_TABLE: { + case rabbit::OT_TABLE: { bool rawcall = true; if(_table(self)->_delegate) { - SQObjectPtr res; + rabbit::ObjectPtr res; if(!_table(self)->get(key,res)) { - SQObjectPtr closure; + rabbit::ObjectPtr closure; if(_delegable(self)->_delegate && _delegable(self)->getMetaMethod(this,MT_NEWSLOT,closure)) { push(self);push(key);push(val); if(!callMetaMethod(closure,MT_NEWSLOT,3,res)) { @@ -1498,9 +1498,9 @@ bool rabbit::VirtualMachine::newSlot(const SQObjectPtr &self,const SQObjectPtr & if(rawcall) _table(self)->newSlot(key,val); //cannot fail break;} - case OT_INSTANCE: { - SQObjectPtr res; - SQObjectPtr closure; + case rabbit::OT_INSTANCE: { + rabbit::ObjectPtr res; + rabbit::ObjectPtr closure; if(_delegable(self)->_delegate && _delegable(self)->getMetaMethod(this,MT_NEWSLOT,closure)) { push(self);push(key);push(val); if(!callMetaMethod(closure,MT_NEWSLOT,3,res)) { @@ -1511,14 +1511,14 @@ bool rabbit::VirtualMachine::newSlot(const SQObjectPtr &self,const SQObjectPtr & raise_error(_SC("class instances do not support the new slot operator")); return false; break;} - case OT_CLASS: - if(!_class(self)->newSlot(_ss(this),key,val,bstatic)) { + case rabbit::OT_CLASS: + if(!_class(self)->newSlot(_get_shared_state(this),key,val,bstatic)) { if(_class(self)->_locked) { raise_error(_SC("trying to modify a class that has already been instantiated")); return false; } else { - SQObjectPtr oval = printObjVal(key); + rabbit::ObjectPtr oval = printObjVal(key); raise_error(_SC("the property '%s' already exists"),_stringval(oval)); return false; } @@ -1534,26 +1534,26 @@ bool rabbit::VirtualMachine::newSlot(const SQObjectPtr &self,const SQObjectPtr & -bool rabbit::VirtualMachine::deleteSlot(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &res) +bool rabbit::VirtualMachine::deleteSlot(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,rabbit::ObjectPtr &res) { switch(sq_type(self)) { - case OT_TABLE: - case OT_INSTANCE: - case OT_USERDATA: { - SQObjectPtr t; + case rabbit::OT_TABLE: + case rabbit::OT_INSTANCE: + case rabbit::OT_USERDATA: { + rabbit::ObjectPtr t; //bool handled = false; - SQObjectPtr closure; + rabbit::ObjectPtr closure; if(_delegable(self)->_delegate && _delegable(self)->getMetaMethod(this,MT_DELSLOT,closure)) { push(self);push(key); return callMetaMethod(closure,MT_DELSLOT,2,res); } else { - if(sq_type(self) == OT_TABLE) { + if(sq_type(self) == rabbit::OT_TABLE) { if(_table(self)->get(key,t)) { _table(self)->remove(key); } else { - raise_Idxerror((const SQObject &)key); + raise_Idxerror((const rabbit::Object &)key); return false; } } @@ -1572,27 +1572,27 @@ bool rabbit::VirtualMachine::deleteSlot(const SQObjectPtr &self,const SQObjectPt return true; } -bool rabbit::VirtualMachine::call(SQObjectPtr &closure,int64_t nparams,int64_t stackbase,SQObjectPtr &outres,SQBool raiseerror) +bool rabbit::VirtualMachine::call(rabbit::ObjectPtr &closure,int64_t nparams,int64_t stackbase,rabbit::ObjectPtr &outres,rabbit::Bool raiseerror) { #ifdef _DEBUG int64_t prevstackbase = _stackbase; #endif switch(sq_type(closure)) { - case OT_CLOSURE: + case rabbit::OT_CLOSURE: return execute(closure, nparams, stackbase, outres, raiseerror); break; - case OT_NATIVECLOSURE:{ + case rabbit::OT_NATIVECLOSURE:{ bool dummy; return callNative(_nativeclosure(closure), nparams, stackbase, outres, -1, dummy, dummy); } break; - case OT_CLASS: { - SQObjectPtr constr; - SQObjectPtr temp; + case rabbit::OT_CLASS: { + rabbit::ObjectPtr constr; + rabbit::ObjectPtr temp; createClassInstance(_class(closure),outres,constr); - SQObjectType ctype = sq_type(constr); - if (ctype == OT_NATIVECLOSURE || ctype == OT_CLOSURE) { + rabbit::ObjectType ctype = sq_type(constr); + if (ctype == rabbit::OT_NATIVECLOSURE || ctype == OT_CLOSURE) { _stack[stackbase] = outres; return call(constr,nparams,stackbase,temp,raiseerror); } @@ -1610,9 +1610,9 @@ int64_t prevstackbase = _stackbase; return true; } -bool rabbit::VirtualMachine::callMetaMethod(SQObjectPtr &closure,SQMetaMethod SQ_UNUSED_ARG(mm),int64_t nparams,SQObjectPtr &outres) +bool rabbit::VirtualMachine::callMetaMethod(rabbit::ObjectPtr &closure,rabbit::MetaMethod SQ_UNUSED_ARG(mm),int64_t nparams,rabbit::ObjectPtr &outres) { - //SQObjectPtr closure; + //rabbit::ObjectPtr closure; _nmetamethodscall++; if(call(closure, nparams, _top - nparams, outres, SQFalse)) { @@ -1626,7 +1626,7 @@ bool rabbit::VirtualMachine::callMetaMethod(SQObjectPtr &closure,SQMetaMethod SQ return false; } -void rabbit::VirtualMachine::findOuter(SQObjectPtr &target, SQObjectPtr *stackindex) +void rabbit::VirtualMachine::findOuter(rabbit::ObjectPtr &target, rabbit::ObjectPtr *stackindex) { SQOuter **pp = &_openouters; SQOuter *p; @@ -1634,18 +1634,18 @@ void rabbit::VirtualMachine::findOuter(SQObjectPtr &target, SQObjectPtr *stackin while ((p = *pp) != NULL && p->_valptr >= stackindex) { if (p->_valptr == stackindex) { - target = SQObjectPtr(p); + target = rabbit::ObjectPtr(p); return; } pp = &p->_next; } - otr = SQOuter::create(_ss(this), stackindex); + otr = SQOuter::create(_get_shared_state(this), stackindex); otr->_next = *pp; // TODO: rework this, this is absolutly not safe... otr->_idx = (stackindex - &_stack[0]); __ObjaddRef(otr); *pp = otr; - target = SQObjectPtr(otr); + target = rabbit::ObjectPtr(otr); } bool rabbit::VirtualMachine::enterFrame(int64_t newbase, int64_t newtop, bool tailcall) @@ -1705,7 +1705,7 @@ void rabbit::VirtualMachine::relocateOuters() } } -void rabbit::VirtualMachine::closeOuters(SQObjectPtr *stackindex) { +void rabbit::VirtualMachine::closeOuters(rabbit::ObjectPtr *stackindex) { SQOuter *p; while ((p = _openouters) != NULL && p->_valptr >= stackindex) { p->_value = *(p->_valptr); @@ -1735,11 +1735,11 @@ void rabbit::VirtualMachine::pop(int64_t n) { } void rabbit::VirtualMachine::pushNull() { _stack[_top++].Null(); } -void rabbit::VirtualMachine::push(const SQObjectPtr &o) { _stack[_top++] = o; } -SQObjectPtr &rabbit::VirtualMachine::top() { return _stack[_top-1]; } -SQObjectPtr &rabbit::VirtualMachine::popGet() { return _stack[--_top]; } -SQObjectPtr &rabbit::VirtualMachine::getUp(int64_t n) { return _stack[_top+n]; } -SQObjectPtr &rabbit::VirtualMachine::getAt(int64_t n) { return _stack[n]; } +void rabbit::VirtualMachine::push(const rabbit::ObjectPtr &o) { _stack[_top++] = o; } +rabbit::ObjectPtr &rabbit::VirtualMachine::top() { return _stack[_top-1]; } +rabbit::ObjectPtr &rabbit::VirtualMachine::popGet() { return _stack[--_top]; } +rabbit::ObjectPtr &rabbit::VirtualMachine::getUp(int64_t n) { return _stack[_top+n]; } +rabbit::ObjectPtr &rabbit::VirtualMachine::getAt(int64_t n) { return _stack[n]; } #ifdef _DEBUG_DUMP void rabbit::VirtualMachine::dumpstack(int64_t stackbase,bool dumpall) @@ -1752,26 +1752,26 @@ void rabbit::VirtualMachine::dumpstack(int64_t stackbase,bool dumpall) scprintf(_SC("prev stack base: %d\n"),ci._prevstkbase); scprintf(_SC("prev top: %d\n"),ci._prevtop); for(int64_t i=0;i"));else scprintf(_SC(" ")); scprintf(_SC("[" _PRINT_INT_FMT "]:"),n); switch(sq_type(obj)){ - case OT_FLOAT: scprintf(_SC("FLOAT %.3f"),_float(obj));break; - case OT_INTEGER: scprintf(_SC("INTEGER " _PRINT_INT_FMT),_integer(obj));break; - case OT_BOOL: scprintf(_SC("BOOL %s"),_integer(obj)?"true":"false");break; - case OT_STRING: scprintf(_SC("STRING %s"),_stringval(obj));break; - case OT_NULL: scprintf(_SC("NULL")); break; - case OT_TABLE: scprintf(_SC("TABLE %p[%p]"),_table(obj),_table(obj)->_delegate);break; - case OT_ARRAY: scprintf(_SC("ARRAY %p"),_array(obj));break; - case OT_CLOSURE: scprintf(_SC("CLOSURE [%p]"),_closure(obj));break; - case OT_NATIVECLOSURE: scprintf(_SC("NATIVECLOSURE"));break; - case OT_USERDATA: scprintf(_SC("USERDATA %p[%p]"),_userdataval(obj),_userdata(obj)->_delegate);break; - case OT_GENERATOR: scprintf(_SC("GENERATOR %p"),_generator(obj));break; - case OT_THREAD: scprintf(_SC("THREAD [%p]"),_thread(obj));break; - case OT_USERPOINTER: scprintf(_SC("USERPOINTER %p"),_userpointer(obj));break; - case OT_CLASS: scprintf(_SC("CLASS %p"),_class(obj));break; - case OT_INSTANCE: scprintf(_SC("INSTANCE %p"),_instance(obj));break; - case OT_WEAKREF: scprintf(_SC("WEAKERF %p"),_weakref(obj));break; + case rabbit::OT_FLOAT: scprintf(_SC("FLOAT %.3f"),_float(obj));break; + case rabbit::OT_INTEGER: scprintf(_SC("INTEGER " _PRINT_INT_FMT),_integer(obj));break; + case rabbit::OT_BOOL: scprintf(_SC("BOOL %s"),_integer(obj)?"true":"false");break; + case rabbit::OT_STRING: scprintf(_SC("STRING %s"),_stringval(obj));break; + case rabbit::OT_NULL: scprintf(_SC("NULL")); break; + case rabbit::OT_TABLE: scprintf(_SC("TABLE %p[%p]"),_table(obj),_table(obj)->_delegate);break; + case rabbit::OT_ARRAY: scprintf(_SC("ARRAY %p"),_array(obj));break; + case rabbit::OT_CLOSURE: scprintf(_SC("CLOSURE [%p]"),_closure(obj));break; + case rabbit::OT_NATIVECLOSURE: scprintf(_SC("NATIVECLOSURE"));break; + case rabbit::OT_USERDATA: scprintf(_SC("USERDATA %p[%p]"),_userdataval(obj),_userdata(obj)->_delegate);break; + case rabbit::OT_GENERATOR: scprintf(_SC("GENERATOR %p"),_generator(obj));break; + case rabbit::OT_THREAD: scprintf(_SC("THREAD [%p]"),_thread(obj));break; + case rabbit::OT_USERPOINTER: scprintf(_SC("USERPOINTER %p"),_userpointer(obj));break; + case rabbit::OT_CLASS: scprintf(_SC("CLASS %p"),_class(obj));break; + case rabbit::OT_INSTANCE: scprintf(_SC("INSTANCE %p"),_instance(obj));break; + case rabbit::OT_WEAKREF: scprintf(_SC("WEAKERF %p"),_weakref(obj));break; default: assert(0); break; diff --git a/rabbit/VirtualMachine.hpp b/rabbit/VirtualMachine.hpp index 75e66e5..d9de73b 100644 --- a/rabbit/VirtualMachine.hpp +++ b/rabbit/VirtualMachine.hpp @@ -10,6 +10,9 @@ #include #include #include +#include +#include + #define MAX_NATIVE_CALLS 100 #define MIN_STACK_OVERHEAD 15 @@ -25,15 +28,6 @@ //base lib void sq_base_register(rabbit::VirtualMachine* v); -struct SQExceptionTrap { - SQExceptionTrap() {} - SQExceptionTrap(int64_t ss, int64_t stackbase,SQInstruction *ip, int64_t ex_target){ _stacksize = ss; _stackbase = stackbase; _ip = ip; _extarget = ex_target;} - SQExceptionTrap(const SQExceptionTrap &et) { (*this) = et; } - int64_t _stackbase; - int64_t _stacksize; - SQInstruction *_ip; - int64_t _extarget; -}; #define _INLINE @@ -43,20 +37,20 @@ namespace rabbit { public: struct callInfo{ SQInstruction *_ip; - SQObjectPtr *_literals; - SQObjectPtr _closure; + rabbit::ObjectPtr *_literals; + rabbit::ObjectPtr _closure; SQGenerator *_generator; int32_t _etraps; int32_t _prevstkbase; int32_t _prevtop; int32_t _target; int32_t _ncalls; - SQBool _root; + rabbit::Bool _root; }; public: - void DebugHookProxy(int64_t type, const SQChar * sourcename, int64_t line, const SQChar * funcname); - static void _DebugHookProxy(rabbit::VirtualMachine* v, int64_t type, const SQChar * sourcename, int64_t line, const SQChar * funcname); + 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); enum ExecutionType { ET_CALL, ET_RESUME_GENERATOR, @@ -66,61 +60,61 @@ namespace rabbit { VirtualMachine(SQSharedState *ss); ~VirtualMachine(); bool init(VirtualMachine *friendvm, int64_t stacksize); - bool execute(SQObjectPtr &func, int64_t nargs, int64_t stackbase, SQObjectPtr &outres, SQBool raiseerror, ExecutionType et = ET_CALL); + bool execute(rabbit::ObjectPtr &func, int64_t nargs, int64_t stackbase, rabbit::ObjectPtr &outres, rabbit::Bool raiseerror, ExecutionType et = ET_CALL); //starts a native call return when the NATIVE closure returns - bool callNative(SQNativeClosure *nclosure, int64_t nargs, int64_t newbase, SQObjectPtr &retval, int32_t target, bool &suspend,bool &tailcall); + bool callNative(SQNativeClosure *nclosure, int64_t nargs, int64_t newbase, rabbit::ObjectPtr &retval, int32_t target, bool &suspend,bool &tailcall); bool tailcall(SQClosure *closure, int64_t firstparam, int64_t nparams); //starts a RABBIT call in the same "Execution loop" bool startcall(SQClosure *closure, int64_t target, int64_t nargs, int64_t stackbase, bool tailcall); - bool createClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor); + bool createClassInstance(SQClass *theclass, rabbit::ObjectPtr &inst, rabbit::ObjectPtr &constructor); //call a generic closure pure RABBIT or NATIVE - bool call(SQObjectPtr &closure, int64_t nparams, int64_t stackbase, SQObjectPtr &outres,SQBool raiseerror); - SQRESULT Suspend(); + bool call(rabbit::ObjectPtr &closure, int64_t nparams, int64_t stackbase, rabbit::ObjectPtr &outres,rabbit::Bool raiseerror); + rabbit::Result Suspend(); void callDebugHook(int64_t type,int64_t forcedline=0); - void callerrorHandler(SQObjectPtr &e); - bool get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &dest, uint64_t getflags, int64_t selfidx); - int64_t fallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest); - bool invokeDefaultDelegate(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest); - bool set(const SQObjectPtr &self, const SQObjectPtr &key, const SQObjectPtr &val, int64_t selfidx); - int64_t fallBackSet(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val); - bool newSlot(const SQObjectPtr &self, const SQObjectPtr &key, const SQObjectPtr &val,bool bstatic); - bool newSlotA(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,const SQObjectPtr &attrs,bool bstatic,bool raw); - bool deleteSlot(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &res); - bool clone(const SQObjectPtr &self, SQObjectPtr &target); - bool objCmp(const SQObjectPtr &o1, const SQObjectPtr &o2,int64_t &res); - bool stringCat(const SQObjectPtr &str, const SQObjectPtr &obj, SQObjectPtr &dest); - static bool isEqual(const SQObjectPtr &o1,const SQObjectPtr &o2,bool &res); - bool toString(const SQObjectPtr &o,SQObjectPtr &res); - SQString *printObjVal(const SQObjectPtr &o); + void callerrorHandler(rabbit::ObjectPtr &e); + bool get(const rabbit::ObjectPtr &self, const rabbit::ObjectPtr &key, rabbit::ObjectPtr &dest, uint64_t getflags, int64_t selfidx); + int64_t fallBackGet(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,rabbit::ObjectPtr &dest); + bool invokeDefaultDelegate(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,rabbit::ObjectPtr &dest); + bool set(const rabbit::ObjectPtr &self, const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &val, int64_t selfidx); + int64_t fallBackSet(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val); + bool newSlot(const rabbit::ObjectPtr &self, const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &val,bool bstatic); + bool newSlotA(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,const rabbit::ObjectPtr &attrs,bool bstatic,bool raw); + bool deleteSlot(const rabbit::ObjectPtr &self, const rabbit::ObjectPtr &key, rabbit::ObjectPtr &res); + bool clone(const rabbit::ObjectPtr &self, rabbit::ObjectPtr &target); + bool objCmp(const rabbit::ObjectPtr &o1, const rabbit::ObjectPtr &o2,int64_t &res); + bool stringCat(const rabbit::ObjectPtr &str, const rabbit::ObjectPtr &obj, rabbit::ObjectPtr &dest); + static bool isEqual(const rabbit::ObjectPtr &o1,const rabbit::ObjectPtr &o2,bool &res); + bool toString(const rabbit::ObjectPtr &o,rabbit::ObjectPtr &res); + SQString *printObjVal(const rabbit::ObjectPtr &o); - void raise_error(const SQChar *s, ...); - void raise_error(const SQObjectPtr &desc); - void raise_Idxerror(const SQObjectPtr &o); - void raise_Compareerror(const SQObject &o1, const SQObject &o2); + void raise_error(const rabbit::Char *s, ...); + void raise_error(const rabbit::ObjectPtr &desc); + void raise_Idxerror(const rabbit::ObjectPtr &o); + void raise_Compareerror(const rabbit::Object &o1, const rabbit::Object &o2); void raise_ParamTypeerror(int64_t nparam,int64_t typemask,int64_t type); - void findOuter(SQObjectPtr &target, SQObjectPtr *stackindex); + void findOuter(rabbit::ObjectPtr &target, rabbit::ObjectPtr *stackindex); void relocateOuters(); - void closeOuters(SQObjectPtr *stackindex); + void closeOuters(rabbit::ObjectPtr *stackindex); - bool typeOf(const SQObjectPtr &obj1, SQObjectPtr &dest); - bool callMetaMethod(SQObjectPtr &closure, SQMetaMethod mm, int64_t nparams, SQObjectPtr &outres); - bool arithMetaMethod(int64_t op, const SQObjectPtr &o1, const SQObjectPtr &o2, SQObjectPtr &dest); - bool Return(int64_t _arg0, int64_t _arg1, SQObjectPtr &retval); + bool typeOf(const rabbit::ObjectPtr &obj1, rabbit::ObjectPtr &dest); + bool callMetaMethod(rabbit::ObjectPtr &closure, rabbit::MetaMethod mm, int64_t nparams, rabbit::ObjectPtr &outres); + bool arithMetaMethod(int64_t op, const rabbit::ObjectPtr &o1, const rabbit::ObjectPtr &o2, rabbit::ObjectPtr &dest); + bool Return(int64_t _arg0, int64_t _arg1, rabbit::ObjectPtr &retval); //new stuff - bool ARITH_OP(uint64_t op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2); - bool BW_OP(uint64_t op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2); - bool NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o1); - bool CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res); - bool CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func); - bool CLASS_OP(SQObjectPtr &target,int64_t base,int64_t attrs); + bool ARITH_OP(uint64_t op,rabbit::ObjectPtr &trg,const rabbit::ObjectPtr &o1,const rabbit::ObjectPtr &o2); + bool BW_OP(uint64_t op,rabbit::ObjectPtr &trg,const rabbit::ObjectPtr &o1,const rabbit::ObjectPtr &o2); + bool NEG_OP(rabbit::ObjectPtr &trg,const rabbit::ObjectPtr &o1); + bool CMP_OP(CmpOP op, const rabbit::ObjectPtr &o1,const rabbit::ObjectPtr &o2,rabbit::ObjectPtr &res); + bool CLOSURE_OP(rabbit::ObjectPtr &target, SQFunctionProto *func); + bool CLASS_OP(rabbit::ObjectPtr &target,int64_t base,int64_t attrs); //return true if the loop is finished - bool FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr &o3,SQObjectPtr &o4,int64_t arg_2,int exitpos,int &jump); - //bool LOCAL_INC(int64_t op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr); - bool PLOCAL_INC(int64_t op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr); - bool derefInc(int64_t op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix,int64_t arg0); + bool FOREACH_OP(rabbit::ObjectPtr &o1,rabbit::ObjectPtr &o2,rabbit::ObjectPtr &o3,rabbit::ObjectPtr &o4,int64_t arg_2,int exitpos,int &jump); + //bool LOCAL_INC(int64_t op,rabbit::ObjectPtr &target, rabbit::ObjectPtr &a, rabbit::ObjectPtr &incr); + bool PLOCAL_INC(int64_t op,rabbit::ObjectPtr &target, rabbit::ObjectPtr &a, rabbit::ObjectPtr &incr); + bool derefInc(int64_t op,rabbit::ObjectPtr &target, rabbit::ObjectPtr &self, rabbit::ObjectPtr &key, rabbit::ObjectPtr &incr, bool postfix,int64_t arg0); #ifdef _DEBUG_DUMP void dumpstack(int64_t stackbase=-1, bool dumpall = false); #endif @@ -141,31 +135,31 @@ namespace rabbit { //stack functions for the api void remove(int64_t n); - static bool IsFalse(SQObjectPtr &o); + static bool IsFalse(rabbit::ObjectPtr &o); void pop(); void pop(int64_t n); - void push(const SQObjectPtr &o); + void push(const rabbit::ObjectPtr &o); void pushNull(); - SQObjectPtr& top(); - SQObjectPtr& popGet(); - SQObjectPtr& getUp(int64_t n); - SQObjectPtr& getAt(int64_t n); + rabbit::ObjectPtr& top(); + rabbit::ObjectPtr& popGet(); + rabbit::ObjectPtr& getUp(int64_t n); + rabbit::ObjectPtr& getAt(int64_t n); - SQObjectPtrVec _stack; + etk::Vector _stack; int64_t _top; int64_t _stackbase; SQOuter* _openouters; - SQObjectPtr _roottable; - SQObjectPtr _lasterror; - SQObjectPtr _errorhandler; + rabbit::ObjectPtr _roottable; + rabbit::ObjectPtr _lasterror; + rabbit::ObjectPtr _errorhandler; bool _debughook; SQDEBUGHOOK _debughook_native; - SQObjectPtr _debughook_closure; + rabbit::ObjectPtr _debughook_closure; - SQObjectPtr temp_reg; + rabbit::ObjectPtr temp_reg; callInfo* _callsstack; @@ -173,23 +167,23 @@ namespace rabbit { int64_t _alloccallsstacksize; etk::Vector _callstackdata; - etk::Vector _etraps; + etk::Vector _etraps; callInfo *ci; - SQUserPointer _foreignptr; + rabbit::UserPointer _foreignptr; //VMs sharing the same state SQSharedState *_sharedstate; int64_t _nnativecalls; int64_t _nmetamethodscall; SQRELEASEHOOK _releasehook; //suspend infos - SQBool _suspended; - SQBool _suspended_root; + rabbit::Bool _suspended; + rabbit::Bool _suspended_root; int64_t _suspended_target; int64_t _suspended_traps; }; - inline SQObjectPtr &stack_get(rabbit::VirtualMachine* _vm,int64_t _idx) { + inline rabbit::ObjectPtr &stack_get(rabbit::VirtualMachine* _vm,int64_t _idx) { if (_idx>=0) { return _vm->getAt(_idx+_vm->_stackbase-1); } @@ -197,7 +191,7 @@ namespace rabbit { } } -#define _ss(_vm_) (_vm_)->_sharedstate +#define _get_shared_state(_vm_) (_vm_)->_sharedstate #define PUSH_CALLINFO(v,nci){ \ int64_t css = v->_callsstacksize; \ diff --git a/rabbit/WeakRef.hpp b/rabbit/WeakRef.hpp index b576f55..1908922 100644 --- a/rabbit/WeakRef.hpp +++ b/rabbit/WeakRef.hpp @@ -9,13 +9,14 @@ #include #include +#include namespace rabbit { class WeakRef: public RefCounted { public: void release(); public: - SQObject _obj; + rabbit::Object _obj; protected: friend RefCounted; }; diff --git a/rabbit/rabbit.hpp b/rabbit/rabbit.hpp index 88333d1..1bd8aca 100644 --- a/rabbit/rabbit.hpp +++ b/rabbit/rabbit.hpp @@ -22,27 +22,6 @@ #endif -#define SQTrue (1) -#define SQFalse (0) - -struct SQTable; -struct SQString; -struct SQClosure; -struct SQGenerator; -struct SQNativeClosure; -struct SQFunctionProto; -struct SQClass; -struct SQInstance; -struct SQDelegable; -struct SQOuter; -namespace rabbit { - class UserData; - class Array; - class RefCounted; - class WeakRef; - class VirtualMachine; - -} #ifdef _UNICODE #define SQUNICODE #endif @@ -61,137 +40,30 @@ namespace rabbit { #define RABBIT_EOB 0 #define SQ_BYTECODE_STREAM_TAG 0xFAFA -#define SQOBJECT_REF_COUNTED 0x08000000 -#define SQOBJECT_NUMERIC 0x04000000 -#define SQOBJECT_DELEGABLE 0x02000000 -#define SQOBJECT_CANBEFALSE 0x01000000 - -#define SQ_MATCHTYPEMASKSTRING (-99999) - -#define _RT_MASK 0x00FFFFFF -#define _RAW_TYPE(type) (type&_RT_MASK) - -#define _RT_NULL 0x00000001 -#define _RT_INTEGER 0x00000002 -#define _RT_FLOAT 0x00000004 -#define _RT_BOOL 0x00000008 -#define _RT_STRING 0x00000010 -#define _RT_TABLE 0x00000020 -#define _RT_ARRAY 0x00000040 -#define _RT_USERDATA 0x00000080 -#define _RT_CLOSURE 0x00000100 -#define _RT_NATIVECLOSURE 0x00000200 -#define _RT_GENERATOR 0x00000400 -#define _RT_USERPOINTER 0x00000800 -#define _RT_THREAD 0x00001000 -#define _RT_FUNCPROTO 0x00002000 -#define _RT_CLASS 0x00004000 -#define _RT_INSTANCE 0x00008000 -#define _RT_WEAKREF 0x00010000 -#define _RT_OUTER 0x00020000 - -typedef enum tagSQObjectType{ - OT_NULL = (_RT_NULL|SQOBJECT_CANBEFALSE), - OT_INTEGER = (_RT_INTEGER|SQOBJECT_NUMERIC|SQOBJECT_CANBEFALSE), - OT_FLOAT = (_RT_FLOAT|SQOBJECT_NUMERIC|SQOBJECT_CANBEFALSE), - OT_BOOL = (_RT_BOOL|SQOBJECT_CANBEFALSE), - OT_STRING = (_RT_STRING|SQOBJECT_REF_COUNTED), - OT_TABLE = (_RT_TABLE|SQOBJECT_REF_COUNTED|SQOBJECT_DELEGABLE), - OT_ARRAY = (_RT_ARRAY|SQOBJECT_REF_COUNTED), - OT_USERDATA = (_RT_USERDATA|SQOBJECT_REF_COUNTED|SQOBJECT_DELEGABLE), - OT_CLOSURE = (_RT_CLOSURE|SQOBJECT_REF_COUNTED), - OT_NATIVECLOSURE = (_RT_NATIVECLOSURE|SQOBJECT_REF_COUNTED), - OT_GENERATOR = (_RT_GENERATOR|SQOBJECT_REF_COUNTED), - OT_USERPOINTER = _RT_USERPOINTER, - OT_THREAD = (_RT_THREAD|SQOBJECT_REF_COUNTED) , - OT_FUNCPROTO = (_RT_FUNCPROTO|SQOBJECT_REF_COUNTED), //internal usage only - OT_CLASS = (_RT_CLASS|SQOBJECT_REF_COUNTED), - OT_INSTANCE = (_RT_INSTANCE|SQOBJECT_REF_COUNTED|SQOBJECT_DELEGABLE), - OT_WEAKREF = (_RT_WEAKREF|SQOBJECT_REF_COUNTED), - OT_OUTER = (_RT_OUTER|SQOBJECT_REF_COUNTED) //internal usage only -}SQObjectType; - -#define ISREFCOUNTED(t) (t&SQOBJECT_REF_COUNTED) +#include -typedef union tagSQObjectValue -{ - struct SQTable *pTable; - struct SQClosure *pClosure; - struct SQOuter *pOuter; - struct SQGenerator *pGenerator; - struct SQNativeClosure *pNativeClosure; - struct SQString *pString; - int64_t nInteger; - float_t fFloat; - SQUserPointer pUserPointer; - struct SQFunctionProto *pFunctionProto; - struct SQDelegable *pDelegable; - struct SQClass *pClass; - struct SQInstance *pInstance; - - struct rabbit::WeakRef *pWeakRef; - struct rabbit::VirtualMachine* pThread; - struct rabbit::RefCounted *pRefCounted; - struct rabbit::Array *pArray; - struct rabbit::UserData *pUserData; - - SQRawObjectVal raw; -}SQObjectValue; -typedef struct tagSQObject -{ - SQObjectType _type; - SQObjectValue _unVal; -}SQObject; - -typedef struct tagSQMemberHandle{ - SQBool _static; - int64_t _index; -}SQMemberHandle; - -typedef struct tagSQStackInfos{ - const SQChar* funcname; - const SQChar* source; - int64_t line; -}SQStackInfos; - -typedef SQObject HSQOBJECT; -typedef SQMemberHandle HSQMEMBERHANDLE; typedef int64_t (*SQFUNCTION)(rabbit::VirtualMachine*); -typedef int64_t (*SQRELEASEHOOK)(SQUserPointer,int64_t size); -typedef void (*SQCOMPILERERROR)(rabbit::VirtualMachine*,const SQChar * /*desc*/,const SQChar * /*source*/,int64_t /*line*/,int64_t /*column*/); -typedef void (*SQPRINTFUNCTION)(rabbit::VirtualMachine*,const SQChar * ,...); -typedef void (*SQDEBUGHOOK)(rabbit::VirtualMachine* /*v*/, int64_t /*type*/, const SQChar * /*sourcename*/, int64_t /*line*/, const SQChar * /*funcname*/); -typedef int64_t (*SQWRITEFUNC)(SQUserPointer,SQUserPointer,int64_t); -typedef int64_t (*SQREADFUNC)(SQUserPointer,SQUserPointer,int64_t); +typedef int64_t (*SQRELEASEHOOK)(rabbit::UserPointer,int64_t size); +typedef void (*SQCOMPILERERROR)(rabbit::VirtualMachine*,const rabbit::Char * /*desc*/,const rabbit::Char * /*source*/,int64_t /*line*/,int64_t /*column*/); +typedef void (*SQPRINTFUNCTION)(rabbit::VirtualMachine*,const rabbit::Char * ,...); +typedef void (*SQDEBUGHOOK)(rabbit::VirtualMachine* /*v*/, int64_t /*type*/, const rabbit::Char * /*sourcename*/, int64_t /*line*/, const rabbit::Char * /*funcname*/); +typedef int64_t (*SQWRITEFUNC)(rabbit::UserPointer,rabbit::UserPointer,int64_t); +typedef int64_t (*SQREADFUNC)(rabbit::UserPointer,rabbit::UserPointer,int64_t); -typedef int64_t (*SQLEXREADFUNC)(SQUserPointer); - -typedef struct tagSQRegFunction{ - const SQChar *name; - SQFUNCTION f; - int64_t nparamscheck; - const SQChar *typemask; -}SQRegFunction; - -typedef struct tagSQFunctionInfo { - SQUserPointer funcid; - const SQChar *name; - const SQChar *source; - int64_t line; -}SQFunctionInfo; +typedef int64_t (*SQLEXREADFUNC)(rabbit::UserPointer); /*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,SQUserPointer p); -RABBIT_API SQUserPointer sq_getforeignptr(rabbit::VirtualMachine* v); -RABBIT_API void sq_setsharedforeignptr(rabbit::VirtualMachine* v,SQUserPointer p); -RABBIT_API SQUserPointer sq_getsharedforeignptr(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); @@ -199,16 +71,16 @@ 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 SQRESULT sq_suspendvm(rabbit::VirtualMachine* v); -RABBIT_API SQRESULT sq_wakeupvm(rabbit::VirtualMachine* v,SQBool resumedret,SQBool retval,SQBool raiseerror,SQBool throwerror); +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(); /*compiler*/ -RABBIT_API SQRESULT sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,SQUserPointer p,const SQChar *sourcename,SQBool raiseerror); -RABBIT_API SQRESULT sq_compilebuffer(rabbit::VirtualMachine* v,const SQChar *s,int64_t size,const SQChar *sourcename,SQBool raiseerror); -RABBIT_API void sq_enabledebuginfo(rabbit::VirtualMachine* v, SQBool enable); -RABBIT_API void sq_notifyallexceptions(rabbit::VirtualMachine* v, SQBool enable); +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); /*stack operations*/ @@ -218,130 +90,130 @@ 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 SQRESULT sq_reservestack(rabbit::VirtualMachine* v,int64_t nsize); +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); /*object creation handling*/ -RABBIT_API SQUserPointer sq_newuserdata(rabbit::VirtualMachine* v,uint64_t size); +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 SQRESULT sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const SQChar *typemask); -RABBIT_API SQRESULT sq_bindenv(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_getclosureroot(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API void sq_pushstring(rabbit::VirtualMachine* v,const SQChar *s,int64_t len); +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,SQBool b); -RABBIT_API void sq_pushuserpointer(rabbit::VirtualMachine* v,SQUserPointer p); +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 SQObjectType sq_gettype(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_typeof(rabbit::VirtualMachine* v,int64_t idx); +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 SQHash sq_gethash(rabbit::VirtualMachine* v, int64_t idx); -RABBIT_API SQRESULT sq_getbase(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQBool sq_instanceof(rabbit::VirtualMachine* v); -RABBIT_API SQRESULT sq_tostring(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API void sq_tobool(rabbit::VirtualMachine* v, int64_t idx, SQBool *b); -RABBIT_API SQRESULT sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const SQChar **c,int64_t *size); -RABBIT_API SQRESULT sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const SQChar **c); -RABBIT_API SQRESULT sq_getinteger(rabbit::VirtualMachine* v,int64_t idx,int64_t *i); -RABBIT_API SQRESULT sq_getfloat(rabbit::VirtualMachine* v,int64_t idx,float_t *f); -RABBIT_API SQRESULT sq_getbool(rabbit::VirtualMachine* v,int64_t idx,SQBool *b); -RABBIT_API SQRESULT sq_getthread(rabbit::VirtualMachine* v,int64_t idx,rabbit::VirtualMachine* *thread); -RABBIT_API SQRESULT sq_getuserpointer(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer *p); -RABBIT_API SQRESULT sq_getuserdata(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer *p,SQUserPointer *typetag); -RABBIT_API SQRESULT sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer typetag); -RABBIT_API SQRESULT sq_gettypetag(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer *typetag); +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 SQChar *sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize); -RABBIT_API SQRESULT sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,SQFunctionInfo *fi); -RABBIT_API SQRESULT sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,uint64_t *nparams,uint64_t *nfreevars); -RABBIT_API SQRESULT sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const SQChar *name); -RABBIT_API SQRESULT sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, SQUserPointer p); -RABBIT_API SQRESULT sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, SQUserPointer *p,SQUserPointer typetag); -RABBIT_API SQRESULT sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize); -RABBIT_API SQRESULT sq_newclass(rabbit::VirtualMachine* v,SQBool hasbase); -RABBIT_API SQRESULT sq_createinstance(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_setattributes(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_getattributes(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_getclass(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 SQRESULT sq_getdefaultdelegate(rabbit::VirtualMachine* v,SQObjectType t); -RABBIT_API SQRESULT sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,HSQMEMBERHANDLE *handle); -RABBIT_API SQRESULT sq_getbyhandle(rabbit::VirtualMachine* v,int64_t idx,const HSQMEMBERHANDLE *handle); -RABBIT_API SQRESULT sq_setbyhandle(rabbit::VirtualMachine* v,int64_t idx,const HSQMEMBERHANDLE *handle); +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); /*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 SQRESULT sq_setroottable(rabbit::VirtualMachine* v); -RABBIT_API SQRESULT sq_setconsttable(rabbit::VirtualMachine* v); -RABBIT_API SQRESULT sq_newslot(rabbit::VirtualMachine* v, int64_t idx, SQBool bstatic); -RABBIT_API SQRESULT sq_deleteslot(rabbit::VirtualMachine* v,int64_t idx,SQBool pushval); -RABBIT_API SQRESULT sq_set(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_get(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_rawget(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_rawset(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_rawdeleteslot(rabbit::VirtualMachine* v,int64_t idx,SQBool pushval); -RABBIT_API SQRESULT sq_newmember(rabbit::VirtualMachine* v,int64_t idx,SQBool bstatic); -RABBIT_API SQRESULT sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,SQBool bstatic); -RABBIT_API SQRESULT sq_arrayappend(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,SQBool pushval); -RABBIT_API SQRESULT sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t newsize); -RABBIT_API SQRESULT sq_arrayreverse(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_arrayremove(rabbit::VirtualMachine* v,int64_t idx,int64_t itemidx); -RABBIT_API SQRESULT sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int64_t destpos); -RABBIT_API SQRESULT sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_clone(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval); -RABBIT_API SQRESULT sq_next(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_getweakrefval(rabbit::VirtualMachine* v,int64_t idx); -RABBIT_API SQRESULT sq_clear(rabbit::VirtualMachine* v,int64_t idx); +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); /*calls*/ -RABBIT_API SQRESULT sq_call(rabbit::VirtualMachine* v,int64_t params,SQBool retval,SQBool raiseerror); -RABBIT_API SQRESULT sq_resume(rabbit::VirtualMachine* v,SQBool retval,SQBool raiseerror); -RABBIT_API const SQChar *sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx); -RABBIT_API SQRESULT sq_getcallee(rabbit::VirtualMachine* v); -RABBIT_API const SQChar *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval); -RABBIT_API SQRESULT sq_throwerror(rabbit::VirtualMachine* v,const SQChar *err); -RABBIT_API SQRESULT sq_throwobject(rabbit::VirtualMachine* v); +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 SQRESULT sq_tailcall(rabbit::VirtualMachine* v, int64_t nparams); +RABBIT_API rabbit::Result sq_tailcall(rabbit::VirtualMachine* v, int64_t nparams); /*raw object handling*/ -RABBIT_API SQRESULT sq_getstackobj(rabbit::VirtualMachine* v,int64_t idx,HSQOBJECT *po); -RABBIT_API void sq_pushobject(rabbit::VirtualMachine* v,HSQOBJECT obj); -RABBIT_API void sq_addref(rabbit::VirtualMachine* v,HSQOBJECT *po); -RABBIT_API SQBool sq_release(rabbit::VirtualMachine* v,HSQOBJECT *po); -RABBIT_API uint64_t sq_getrefcount(rabbit::VirtualMachine* v,HSQOBJECT *po); -RABBIT_API void sq_resetobject(HSQOBJECT *po); -RABBIT_API const SQChar *sq_objtostring(const HSQOBJECT *o); -RABBIT_API SQBool sq_objtobool(const HSQOBJECT *o); -RABBIT_API int64_t sq_objtointeger(const HSQOBJECT *o); -RABBIT_API float_t sq_objtofloat(const HSQOBJECT *o); -RABBIT_API SQUserPointer sq_objtouserpointer(const HSQOBJECT *o); -RABBIT_API SQRESULT sq_getobjtypetag(const HSQOBJECT *o,SQUserPointer * typetag); -RABBIT_API uint64_t sq_getvmrefcount(rabbit::VirtualMachine* v, const HSQOBJECT *po); +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); /*GC*/ RABBIT_API int64_t sq_collectgarbage(rabbit::VirtualMachine* v); -RABBIT_API SQRESULT sq_resurrectunreachable(rabbit::VirtualMachine* v); +RABBIT_API rabbit::Result sq_resurrectunreachable(rabbit::VirtualMachine* v); /*serialization*/ -RABBIT_API SQRESULT sq_writeclosure(rabbit::VirtualMachine* vm,SQWRITEFUNC writef,SQUserPointer up); -RABBIT_API SQRESULT sq_readclosure(rabbit::VirtualMachine* vm,SQREADFUNC readf,SQUserPointer up); +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); /*mem allocation*/ RABBIT_API void *sq_malloc(uint64_t size); @@ -349,31 +221,10 @@ RABBIT_API void *sq_realloc(void* p,uint64_t oldsize,uint64_t newsize); RABBIT_API void sq_free(void *p,uint64_t size); /*debug*/ -RABBIT_API SQRESULT sq_stackinfos(rabbit::VirtualMachine* v,int64_t level,SQStackInfos *si); +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); -/*UTILITY MACRO*/ -#define sq_isnumeric(o) ((o)._type&SQOBJECT_NUMERIC) -#define sq_istable(o) ((o)._type==OT_TABLE) -#define sq_isarray(o) ((o)._type==OT_ARRAY) -#define sq_isfunction(o) ((o)._type==OT_FUNCPROTO) -#define sq_isclosure(o) ((o)._type==OT_CLOSURE) -#define sq_isgenerator(o) ((o)._type==OT_GENERATOR) -#define sq_isnativeclosure(o) ((o)._type==OT_NATIVECLOSURE) -#define sq_isstring(o) ((o)._type==OT_STRING) -#define sq_isinteger(o) ((o)._type==OT_INTEGER) -#define sq_isfloat(o) ((o)._type==OT_FLOAT) -#define sq_isuserpointer(o) ((o)._type==OT_USERPOINTER) -#define sq_isuserdata(o) ((o)._type==OT_USERDATA) -#define sq_isthread(o) ((o)._type==OT_THREAD) -#define sq_isnull(o) ((o)._type==OT_NULL) -#define sq_isclass(o) ((o)._type==OT_CLASS) -#define sq_isinstance(o) ((o)._type==OT_INSTANCE) -#define sq_isbool(o) ((o)._type==OT_BOOL) -#define sq_isweakref(o) ((o)._type==OT_WEAKREF) -#define sq_type(o) ((o)._type) - /* deprecated */ #define sq_createslot(v,n) sq_newslot(v,n,SQFalse) diff --git a/rabbit/sqapi.cpp b/rabbit/sqapi.cpp index 694ba79..6ebe8a6 100644 --- a/rabbit/sqapi.cpp +++ b/rabbit/sqapi.cpp @@ -17,11 +17,11 @@ #include #include -static bool sq_aux_gettypedarg(rabbit::VirtualMachine* v,int64_t idx,SQObjectType type,SQObjectPtr **o) +static bool sq_aux_gettypedarg(rabbit::VirtualMachine* v,int64_t idx,rabbit::ObjectType type,rabbit::ObjectPtr **o) { *o = &stack_get(v,idx); if(sq_type(**o) != type){ - SQObjectPtr oval = v->printObjVal(**o); + rabbit::ObjectPtr oval = v->printObjVal(**o); v->raise_error(_SC("wrong argument type, expected '%s' got '%.50s'"),IdType2Name(type),_stringval(oval)); return false; } @@ -36,11 +36,11 @@ static bool sq_aux_gettypedarg(rabbit::VirtualMachine* v,int64_t idx,SQObjectTyp } -int64_t sq_aux_invalidtype(rabbit::VirtualMachine* v,SQObjectType type) +int64_t sq_aux_invalidtype(rabbit::VirtualMachine* v,rabbit::ObjectType type) { - uint64_t buf_size = 100 *sizeof(SQChar); - scsprintf(_ss(v)->getScratchPad(buf_size), buf_size, _SC("unexpected type %s"), IdType2Name(type)); - return sq_throwerror(v, _ss(v)->getScratchPad(-1)); + 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) @@ -66,7 +66,7 @@ rabbit::VirtualMachine* sq_open(int64_t initialstacksize) rabbit::VirtualMachine* sq_newthread(rabbit::VirtualMachine* friendvm, int64_t initialstacksize) { SQSharedState *ss; - ss=_ss(friendvm); + ss=_get_shared_state(friendvm); char* allocatedData = (char*)SQ_MALLOC(sizeof(rabbit::VirtualMachine)); rabbit::VirtualMachine *v = new (allocatedData) rabbit::VirtualMachine(ss); @@ -94,7 +94,7 @@ int64_t sq_getvmstate(rabbit::VirtualMachine* v) void sq_seterrorhandler(rabbit::VirtualMachine* v) { - SQObject o = stack_get(v, -1); + rabbit::Object o = stack_get(v, -1); if(sq_isclosure(o) || sq_isnativeclosure(o) || sq_isnull(o)) { v->_errorhandler = o; v->pop(); @@ -110,7 +110,7 @@ void sq_setnativedebughook(rabbit::VirtualMachine* v,SQDEBUGHOOK hook) void sq_setdebughook(rabbit::VirtualMachine* v) { - SQObject o = stack_get(v,-1); + rabbit::Object o = stack_get(v,-1); if(sq_isclosure(o) || sq_isnativeclosure(o) || sq_isnull(o)) { v->_debughook_closure = o; v->_debughook_native = NULL; @@ -121,7 +121,7 @@ void sq_setdebughook(rabbit::VirtualMachine* v) void sq_close(rabbit::VirtualMachine* v) { - SQSharedState *ss = _ss(v); + SQSharedState *ss = _get_shared_state(v); _thread(ss->_root_vm)->finalize(); sq_delete(ss, SQSharedState); } @@ -131,12 +131,12 @@ int64_t sq_getversion() return RABBIT_VERSION_NUMBER; } -SQRESULT sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,SQUserPointer p,const SQChar *sourcename,SQBool raiseerror) +rabbit::Result sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::UserPointer p,const rabbit::Char *sourcename,rabbit::Bool raiseerror) { - SQObjectPtr o; + rabbit::ObjectPtr o; #ifndef NO_COMPILER - if(compile(v, read, p, sourcename, o, raiseerror?true:false, _ss(v)->_debuginfo)) { - v->push(SQClosure::create(_ss(v), _funcproto(o), _table(v->_roottable)->getWeakRef(OT_TABLE))); + if(compile(v, read, p, sourcename, o, raiseerror?true:false, _get_shared_state(v)->_debuginfo)) { + v->push(SQClosure::create(_get_shared_state(v), _funcproto(o), _table(v->_roottable)->getWeakRef(rabbit::OT_TABLE))); return SQ_OK; } return SQ_ERROR; @@ -145,29 +145,29 @@ SQRESULT sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,SQUserPointer p #endif } -void sq_enabledebuginfo(rabbit::VirtualMachine* v, SQBool enable) +void sq_enabledebuginfo(rabbit::VirtualMachine* v, rabbit::Bool enable) { - _ss(v)->_debuginfo = enable?true:false; + _get_shared_state(v)->_debuginfo = enable?true:false; } -void sq_notifyallexceptions(rabbit::VirtualMachine* v, SQBool enable) +void sq_notifyallexceptions(rabbit::VirtualMachine* v, rabbit::Bool enable) { - _ss(v)->_notifyallexceptions = enable?true:false; + _get_shared_state(v)->_notifyallexceptions = enable?true:false; } -void sq_addref(rabbit::VirtualMachine* v,HSQOBJECT *po) +void 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,HSQOBJECT *po) +uint64_t sq_getrefcount(rabbit::VirtualMachine* v,rabbit::Object *po) { if(!ISREFCOUNTED(sq_type(*po))) return 0; return po->_unVal.pRefCounted->refCountget(); } -SQBool sq_release(rabbit::VirtualMachine* v,HSQOBJECT *po) +rabbit::Bool sq_release(rabbit::VirtualMachine* v,rabbit::Object *po) { if(!ISREFCOUNTED(sq_type(*po))) return SQTrue; bool ret = (po->_unVal.pRefCounted->refCountget() <= 1) ? SQTrue : SQFalse; @@ -175,21 +175,21 @@ SQBool sq_release(rabbit::VirtualMachine* v,HSQOBJECT *po) return ret; //the ret val doesn't work(and cannot be fixed) } -uint64_t sq_getvmrefcount(rabbit::VirtualMachine* SQ_UNUSED_ARG(v), const HSQOBJECT *po) +uint64_t 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 SQChar *sq_objtostring(const HSQOBJECT *o) +const rabbit::Char *sq_objtostring(const rabbit::Object *o) { - if(sq_type(*o) == OT_STRING) { + if(sq_type(*o) == rabbit::OT_STRING) { return _stringval(*o); } return NULL; } -int64_t sq_objtointeger(const HSQOBJECT *o) +int64_t sq_objtointeger(const rabbit::Object *o) { if(sq_isnumeric(*o)) { return tointeger(*o); @@ -197,7 +197,7 @@ int64_t sq_objtointeger(const HSQOBJECT *o) return 0; } -float_t sq_objtofloat(const HSQOBJECT *o) +float_t sq_objtofloat(const rabbit::Object *o) { if(sq_isnumeric(*o)) { return tofloat(*o); @@ -205,7 +205,7 @@ float_t sq_objtofloat(const HSQOBJECT *o) return 0; } -SQBool sq_objtobool(const HSQOBJECT *o) +rabbit::Bool sq_objtobool(const rabbit::Object *o) { if(sq_isbool(*o)) { return _integer(*o); @@ -213,7 +213,7 @@ SQBool sq_objtobool(const HSQOBJECT *o) return SQFalse; } -SQUserPointer sq_objtouserpointer(const HSQOBJECT *o) +rabbit::UserPointer sq_objtouserpointer(const rabbit::Object *o) { if(sq_isuserpointer(*o)) { return _userpointer(*o); @@ -226,10 +226,10 @@ void sq_pushnull(rabbit::VirtualMachine* v) v->pushNull(); } -void sq_pushstring(rabbit::VirtualMachine* v,const SQChar *s,int64_t len) +void sq_pushstring(rabbit::VirtualMachine* v,const rabbit::Char *s,int64_t len) { if(s) - v->push(SQObjectPtr(SQString::create(_ss(v), s, len))); + v->push(rabbit::ObjectPtr(SQString::create(_get_shared_state(v), s, len))); else v->pushNull(); } @@ -238,7 +238,7 @@ void sq_pushinteger(rabbit::VirtualMachine* v,int64_t n) v->push(n); } -void sq_pushbool(rabbit::VirtualMachine* v,SQBool b) +void sq_pushbool(rabbit::VirtualMachine* v,rabbit::Bool b) { v->push(b?true:false); } @@ -248,7 +248,7 @@ void sq_pushfloat(rabbit::VirtualMachine* v,float_t n) v->push(n); } -void sq_pushuserpointer(rabbit::VirtualMachine* v,SQUserPointer p) +void sq_pushuserpointer(rabbit::VirtualMachine* v,rabbit::UserPointer p) { v->push(p); } @@ -258,67 +258,67 @@ void sq_pushthread(rabbit::VirtualMachine* v, rabbit::VirtualMachine* thread) v->push(thread); } -SQUserPointer sq_newuserdata(rabbit::VirtualMachine* v,uint64_t size) +rabbit::UserPointer sq_newuserdata(rabbit::VirtualMachine* v,uint64_t size) { - rabbit::UserData *ud = rabbit::UserData::create(_ss(v), size + SQ_ALIGNMENT); + rabbit::UserData *ud = rabbit::UserData::create(_get_shared_state(v), size + SQ_ALIGNMENT); v->push(ud); - return (SQUserPointer)sq_aligning(ud + 1); + return (rabbit::UserPointer)sq_aligning(ud + 1); } void sq_newtable(rabbit::VirtualMachine* v) { - v->push(SQTable::create(_ss(v), 0)); + v->push(SQTable::create(_get_shared_state(v), 0)); } void sq_newtableex(rabbit::VirtualMachine* v,int64_t initialcapacity) { - v->push(SQTable::create(_ss(v), initialcapacity)); + v->push(SQTable::create(_get_shared_state(v), initialcapacity)); } void sq_newarray(rabbit::VirtualMachine* v,int64_t size) { - v->push(rabbit::Array::create(_ss(v), size)); + v->push(rabbit::Array::create(_get_shared_state(v), size)); } -SQRESULT sq_newclass(rabbit::VirtualMachine* v,SQBool hasbase) +rabbit::Result sq_newclass(rabbit::VirtualMachine* v,rabbit::Bool hasbase) { SQClass *baseclass = NULL; if(hasbase) { - SQObjectPtr &base = stack_get(v,-1); - if(sq_type(base) != OT_CLASS) + rabbit::ObjectPtr &base = stack_get(v,-1); + if(sq_type(base) != rabbit::OT_CLASS) return sq_throwerror(v,_SC("invalid base type")); baseclass = _class(base); } - SQClass *newclass = SQClass::create(_ss(v), baseclass); + SQClass *newclass = SQClass::create(_get_shared_state(v), baseclass); if(baseclass) v->pop(); v->push(newclass); return SQ_OK; } -SQBool sq_instanceof(rabbit::VirtualMachine* v) +rabbit::Bool sq_instanceof(rabbit::VirtualMachine* v) { - SQObjectPtr &inst = stack_get(v,-1); - SQObjectPtr &cl = stack_get(v,-2); - if(sq_type(inst) != OT_INSTANCE || sq_type(cl) != OT_CLASS) + rabbit::ObjectPtr &inst = stack_get(v,-1); + rabbit::ObjectPtr &cl = stack_get(v,-2); + if(sq_type(inst) != rabbit::OT_INSTANCE || sq_type(cl) != OT_CLASS) return sq_throwerror(v,_SC("invalid param type")); return _instance(inst)->instanceOf(_class(cl))?SQTrue:SQFalse; } -SQRESULT sq_arrayappend(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_arrayappend(rabbit::VirtualMachine* v,int64_t idx) { sq_aux_paramscheck(v,2); - SQObjectPtr *arr; - _GETSAFE_OBJ(v, idx, OT_ARRAY,arr); + rabbit::ObjectPtr *arr; + _GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr); _array(*arr)->append(v->getUp(-1)); v->pop(); return SQ_OK; } -SQRESULT sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,SQBool pushval) +rabbit::Result sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval) { sq_aux_paramscheck(v, 1); - SQObjectPtr *arr; - _GETSAFE_OBJ(v, idx, OT_ARRAY,arr); + rabbit::ObjectPtr *arr; + _GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr); if(_array(*arr)->size() > 0) { if(pushval != 0){ v->push(_array(*arr)->top()); @@ -329,11 +329,11 @@ SQRESULT sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,SQBool pushval) return sq_throwerror(v, _SC("empty array")); } -SQRESULT sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t newsize) +rabbit::Result sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t newsize) { sq_aux_paramscheck(v,1); - SQObjectPtr *arr; - _GETSAFE_OBJ(v, idx, OT_ARRAY,arr); + rabbit::ObjectPtr *arr; + _GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr); if(newsize >= 0) { _array(*arr)->resize(newsize); return SQ_OK; @@ -342,14 +342,14 @@ SQRESULT sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t newsize) } -SQRESULT sq_arrayreverse(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_arrayreverse(rabbit::VirtualMachine* v,int64_t idx) { sq_aux_paramscheck(v, 1); - SQObjectPtr *o; - _GETSAFE_OBJ(v, idx, OT_ARRAY,o); + rabbit::ObjectPtr *o; + _GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,o); rabbit::Array *arr = _array(*o); if(arr->size() > 0) { - SQObjectPtr t; + rabbit::ObjectPtr t; int64_t size = arr->size(); int64_t n = size >> 1; size -= 1; for(int64_t i = 0; i < n; i++) { @@ -363,46 +363,46 @@ SQRESULT sq_arrayreverse(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -SQRESULT sq_arrayremove(rabbit::VirtualMachine* v,int64_t idx,int64_t itemidx) +rabbit::Result sq_arrayremove(rabbit::VirtualMachine* v,int64_t idx,int64_t itemidx) { sq_aux_paramscheck(v, 1); - SQObjectPtr *arr; - _GETSAFE_OBJ(v, idx, OT_ARRAY,arr); + rabbit::ObjectPtr *arr; + _GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr); return _array(*arr)->remove(itemidx) ? SQ_OK : sq_throwerror(v,_SC("index out of range")); } -SQRESULT sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int64_t destpos) +rabbit::Result sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int64_t destpos) { sq_aux_paramscheck(v, 1); - SQObjectPtr *arr; - _GETSAFE_OBJ(v, idx, OT_ARRAY,arr); - SQRESULT ret = _array(*arr)->insert(destpos, v->getUp(-1)) ? SQ_OK : sq_throwerror(v,_SC("index out of range")); + rabbit::ObjectPtr *arr; + _GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr); + rabbit::Result ret = _array(*arr)->insert(destpos, v->getUp(-1)) ? SQ_OK : sq_throwerror(v,_SC("index out of range")); v->pop(); return ret; } void sq_newclosure(rabbit::VirtualMachine* v,SQFUNCTION func,uint64_t nfreevars) { - SQNativeClosure *nc = SQNativeClosure::create(_ss(v), func,nfreevars); + SQNativeClosure *nc = SQNativeClosure::create(_get_shared_state(v), func,nfreevars); nc->_nparamscheck = 0; for(uint64_t i = 0; i < nfreevars; i++) { nc->_outervalues[i] = v->top(); v->pop(); } - v->push(SQObjectPtr(nc)); + v->push(rabbit::ObjectPtr(nc)); } -SQRESULT sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,uint64_t *nparams,uint64_t *nfreevars) +rabbit::Result sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,uint64_t *nparams,uint64_t *nfreevars) { - SQObject o = stack_get(v, idx); - if(sq_type(o) == OT_CLOSURE) { + rabbit::Object o = stack_get(v, idx); + if(sq_type(o) == rabbit::OT_CLOSURE) { SQClosure *c = _closure(o); SQFunctionProto *proto = c->_function; *nparams = (uint64_t)proto->_nparameters; *nfreevars = (uint64_t)proto->_noutervalues; return SQ_OK; } - else if(sq_type(o) == OT_NATIVECLOSURE) + else if(sq_type(o) == rabbit::OT_NATIVECLOSURE) { SQNativeClosure *c = _nativeclosure(o); *nparams = (uint64_t)c->_nparamscheck; @@ -412,26 +412,26 @@ SQRESULT sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,uint64_t *npara return sq_throwerror(v,_SC("the object is not a closure")); } -SQRESULT sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const SQChar *name) +rabbit::Result sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char *name) { - SQObject o = stack_get(v, idx); + rabbit::Object o = stack_get(v, idx); if(sq_isnativeclosure(o)) { SQNativeClosure *nc = _nativeclosure(o); - nc->_name = SQString::create(_ss(v),name); + nc->_name = SQString::create(_get_shared_state(v),name); return SQ_OK; } return sq_throwerror(v,_SC("the object is not a nativeclosure")); } -SQRESULT sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const SQChar *typemask) +rabbit::Result sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const rabbit::Char *typemask) { - SQObject o = stack_get(v, -1); + rabbit::Object o = stack_get(v, -1); if(!sq_isnativeclosure(o)) return sq_throwerror(v, _SC("native closure expected")); SQNativeClosure *nc = _nativeclosure(o); nc->_nparamscheck = nparamscheck; if(typemask) { - SQIntVec res; + etk::Vector res; if(!compileTypemask(res, typemask)) return sq_throwerror(v, _SC("invalid typemask")); nc->_typecheck = res; @@ -445,20 +445,20 @@ SQRESULT sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const return SQ_OK; } -SQRESULT sq_bindenv(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_bindenv(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &o = stack_get(v,idx); + rabbit::ObjectPtr &o = stack_get(v,idx); if(!sq_isnativeclosure(o) && !sq_isclosure(o)) return sq_throwerror(v,_SC("the target is not a closure")); - SQObjectPtr &env = stack_get(v,-1); + rabbit::ObjectPtr &env = stack_get(v,-1); if(!sq_istable(env) && !sq_isarray(env) && !sq_isclass(env) && !sq_isinstance(env)) return sq_throwerror(v,_SC("invalid environment")); rabbit::WeakRef *w = _refcounted(env)->getWeakRef(sq_type(env)); - SQObjectPtr ret; + rabbit::ObjectPtr ret; if(sq_isclosure(o)) { SQClosure *c = _closure(o)->clone(); __Objrelease(c->_env); @@ -482,9 +482,9 @@ SQRESULT sq_bindenv(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -SQRESULT sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &o = stack_get(v,idx); + rabbit::ObjectPtr &o = stack_get(v,idx); if(!sq_isnativeclosure(o) && !sq_isclosure(o)) return sq_throwerror(v,_SC("the target is not a closure")); @@ -498,33 +498,33 @@ SQRESULT sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -SQRESULT sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &c = stack_get(v,idx); - SQObject o = stack_get(v, -1); + rabbit::ObjectPtr &c = stack_get(v,idx); + rabbit::Object o = stack_get(v, -1); if(!sq_isclosure(c)) return sq_throwerror(v, _SC("closure expected")); if(sq_istable(o)) { - _closure(c)->setRoot(_table(o)->getWeakRef(OT_TABLE)); + _closure(c)->setRoot(_table(o)->getWeakRef(rabbit::OT_TABLE)); v->pop(); return SQ_OK; } return sq_throwerror(v, _SC("invalid type")); } -SQRESULT sq_getclosureroot(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_getclosureroot(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &c = stack_get(v,idx); + rabbit::ObjectPtr &c = stack_get(v,idx); if(!sq_isclosure(c)) return sq_throwerror(v, _SC("closure expected")); v->push(_closure(c)->_root->_obj); return SQ_OK; } -SQRESULT sq_clear(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_clear(rabbit::VirtualMachine* v,int64_t idx) { - SQObject &o=stack_get(v,idx); + rabbit::Object &o=stack_get(v,idx); switch(sq_type(o)) { - case OT_TABLE: _table(o)->clear(); break; - case OT_ARRAY: _array(o)->resize(0); break; + case rabbit::OT_TABLE: _table(o)->clear(); break; + case rabbit::OT_ARRAY: _array(o)->resize(0); break; default: return sq_throwerror(v, _SC("clear only works on table and array")); break; @@ -540,17 +540,17 @@ void sq_pushroottable(rabbit::VirtualMachine* v) void sq_pushregistrytable(rabbit::VirtualMachine* v) { - v->push(_ss(v)->_registry); + v->push(_get_shared_state(v)->_registry); } void sq_pushconsttable(rabbit::VirtualMachine* v) { - v->push(_ss(v)->_consts); + v->push(_get_shared_state(v)->_consts); } -SQRESULT sq_setroottable(rabbit::VirtualMachine* v) +rabbit::Result sq_setroottable(rabbit::VirtualMachine* v) { - SQObject o = stack_get(v, -1); + rabbit::Object o = stack_get(v, -1); if(sq_istable(o) || sq_isnull(o)) { v->_roottable = o; v->pop(); @@ -559,35 +559,35 @@ SQRESULT sq_setroottable(rabbit::VirtualMachine* v) return sq_throwerror(v, _SC("invalid type")); } -SQRESULT sq_setconsttable(rabbit::VirtualMachine* v) +rabbit::Result sq_setconsttable(rabbit::VirtualMachine* v) { - SQObject o = stack_get(v, -1); + rabbit::Object o = stack_get(v, -1); if(sq_istable(o)) { - _ss(v)->_consts = o; + _get_shared_state(v)->_consts = o; v->pop(); return SQ_OK; } return sq_throwerror(v, _SC("invalid type, expected table")); } -void sq_setforeignptr(rabbit::VirtualMachine* v,SQUserPointer p) +void sq_setforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p) { v->_foreignptr = p; } -SQUserPointer sq_getforeignptr(rabbit::VirtualMachine* v) +rabbit::UserPointer sq_getforeignptr(rabbit::VirtualMachine* v) { return v->_foreignptr; } -void sq_setsharedforeignptr(rabbit::VirtualMachine* v,SQUserPointer p) +void sq_setsharedforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p) { - _ss(v)->_foreignptr = p; + _get_shared_state(v)->_foreignptr = p; } -SQUserPointer sq_getsharedforeignptr(rabbit::VirtualMachine* v) +rabbit::UserPointer sq_getsharedforeignptr(rabbit::VirtualMachine* v) { - return _ss(v)->_foreignptr; + return _get_shared_state(v)->_foreignptr; } void sq_setvmreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook) @@ -602,12 +602,12 @@ SQRELEASEHOOK sq_getvmreleasehook(rabbit::VirtualMachine* v) void sq_setsharedreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook) { - _ss(v)->_releasehook = hook; + _get_shared_state(v)->_releasehook = hook; } SQRELEASEHOOK sq_getsharedreleasehook(rabbit::VirtualMachine* v) { - return _ss(v)->_releasehook; + return _get_shared_state(v)->_releasehook; } void sq_push(rabbit::VirtualMachine* v,int64_t idx) @@ -615,15 +615,15 @@ void sq_push(rabbit::VirtualMachine* v,int64_t idx) v->push(stack_get(v, idx)); } -SQObjectType sq_gettype(rabbit::VirtualMachine* v,int64_t idx) +rabbit::ObjectType sq_gettype(rabbit::VirtualMachine* v,int64_t idx) { return sq_type(stack_get(v, idx)); } -SQRESULT sq_typeof(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_typeof(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &o = stack_get(v, idx); - SQObjectPtr res; + rabbit::ObjectPtr &o = stack_get(v, idx); + rabbit::ObjectPtr res; if(!v->typeOf(o,res)) { return SQ_ERROR; } @@ -631,10 +631,10 @@ SQRESULT sq_typeof(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -SQRESULT sq_tostring(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_tostring(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &o = stack_get(v, idx); - SQObjectPtr res; + rabbit::ObjectPtr &o = stack_get(v, idx); + rabbit::ObjectPtr res; if(!v->toString(o,res)) { return SQ_ERROR; } @@ -642,15 +642,15 @@ SQRESULT sq_tostring(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -void sq_tobool(rabbit::VirtualMachine* v, int64_t idx, SQBool *b) +void sq_tobool(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool *b) { - SQObjectPtr &o = stack_get(v, idx); + rabbit::ObjectPtr &o = stack_get(v, idx); *b = rabbit::VirtualMachine::IsFalse(o)?SQFalse:SQTrue; } -SQRESULT sq_getinteger(rabbit::VirtualMachine* v,int64_t idx,int64_t *i) +rabbit::Result sq_getinteger(rabbit::VirtualMachine* v,int64_t idx,int64_t *i) { - SQObjectPtr &o = stack_get(v, idx); + rabbit::ObjectPtr &o = stack_get(v, idx); if(sq_isnumeric(o)) { *i = tointeger(o); return SQ_OK; @@ -662,9 +662,9 @@ SQRESULT sq_getinteger(rabbit::VirtualMachine* v,int64_t idx,int64_t *i) return SQ_ERROR; } -SQRESULT sq_getfloat(rabbit::VirtualMachine* v,int64_t idx,float_t *f) +rabbit::Result sq_getfloat(rabbit::VirtualMachine* v,int64_t idx,float_t *f) { - SQObjectPtr &o = stack_get(v, idx); + rabbit::ObjectPtr &o = stack_get(v, idx); if(sq_isnumeric(o)) { *f = tofloat(o); return SQ_OK; @@ -672,9 +672,9 @@ SQRESULT sq_getfloat(rabbit::VirtualMachine* v,int64_t idx,float_t *f) return SQ_ERROR; } -SQRESULT sq_getbool(rabbit::VirtualMachine* v,int64_t idx,SQBool *b) +rabbit::Result sq_getbool(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool *b) { - SQObjectPtr &o = stack_get(v, idx); + rabbit::ObjectPtr &o = stack_get(v, idx); if(sq_isbool(o)) { *b = _integer(o); return SQ_OK; @@ -682,34 +682,34 @@ SQRESULT sq_getbool(rabbit::VirtualMachine* v,int64_t idx,SQBool *b) return SQ_ERROR; } -SQRESULT sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const SQChar **c,int64_t *size) +rabbit::Result sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c,int64_t *size) { - SQObjectPtr *o = NULL; - _GETSAFE_OBJ(v, idx, OT_STRING,o); + rabbit::ObjectPtr *o = NULL; + _GETSAFE_OBJ(v, idx, rabbit::OT_STRING,o); *c = _stringval(*o); *size = _string(*o)->_len; return SQ_OK; } -SQRESULT sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const SQChar **c) +rabbit::Result sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c) { - SQObjectPtr *o = NULL; - _GETSAFE_OBJ(v, idx, OT_STRING,o); + rabbit::ObjectPtr *o = NULL; + _GETSAFE_OBJ(v, idx, rabbit::OT_STRING,o); *c = _stringval(*o); return SQ_OK; } -SQRESULT sq_getthread(rabbit::VirtualMachine* v,int64_t idx,rabbit::VirtualMachine* *thread) +rabbit::Result sq_getthread(rabbit::VirtualMachine* v,int64_t idx,rabbit::VirtualMachine* *thread) { - SQObjectPtr *o = NULL; - _GETSAFE_OBJ(v, idx, OT_THREAD,o); + rabbit::ObjectPtr *o = NULL; + _GETSAFE_OBJ(v, idx, rabbit::OT_THREAD,o); *thread = _thread(*o); return SQ_OK; } -SQRESULT sq_clone(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_clone(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &o = stack_get(v,idx); + rabbit::ObjectPtr &o = stack_get(v,idx); v->pushNull(); if(!v->clone(o, stack_get(v, -1))){ v->pop(); @@ -720,15 +720,15 @@ SQRESULT sq_clone(rabbit::VirtualMachine* v,int64_t idx) int64_t sq_getsize(rabbit::VirtualMachine* v, int64_t idx) { - SQObjectPtr &o = stack_get(v, idx); - SQObjectType type = sq_type(o); + rabbit::ObjectPtr &o = stack_get(v, idx); + rabbit::ObjectType type = sq_type(o); switch(type) { - case OT_STRING: return _string(o)->_len; - case OT_TABLE: return _table(o)->countUsed(); - case OT_ARRAY: return _array(o)->size(); - case OT_USERDATA: return _userdata(o)->getsize(); - case OT_INSTANCE: return _instance(o)->_class->_udsize; - case OT_CLASS: return _class(o)->_udsize; + case rabbit::OT_STRING: return _string(o)->_len; + case rabbit::OT_TABLE: return _table(o)->countUsed(); + case rabbit::OT_ARRAY: return _array(o)->size(); + case rabbit::OT_USERDATA: return _userdata(o)->getsize(); + case rabbit::OT_INSTANCE: return _instance(o)->_class->_udsize; + case rabbit::OT_CLASS: return _class(o)->_udsize; default: return sq_aux_invalidtype(v, type); } @@ -736,14 +736,14 @@ int64_t sq_getsize(rabbit::VirtualMachine* v, int64_t idx) SQHash sq_gethash(rabbit::VirtualMachine* v, int64_t idx) { - SQObjectPtr &o = stack_get(v, idx); + rabbit::ObjectPtr &o = stack_get(v, idx); return HashObj(o); } -SQRESULT sq_getuserdata(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer *p,SQUserPointer *typetag) +rabbit::Result sq_getuserdata(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *p,rabbit::UserPointer *typetag) { - SQObjectPtr *o = NULL; - _GETSAFE_OBJ(v, idx, OT_USERDATA,o); + rabbit::ObjectPtr *o = NULL; + _GETSAFE_OBJ(v, idx, rabbit::OT_USERDATA,o); (*p) = _userdataval(*o); if(typetag) { *typetag = _userdata(*o)->getTypeTag(); @@ -751,14 +751,14 @@ SQRESULT sq_getuserdata(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer *p,S return SQ_OK; } -SQRESULT sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer typetag) +rabbit::Result sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer typetag) { - SQObjectPtr &o = stack_get(v,idx); + rabbit::ObjectPtr &o = stack_get(v,idx); switch(sq_type(o)) { - case OT_USERDATA: + case rabbit::OT_USERDATA: _userdata(o)->setTypeTag(typetag); break; - case OT_CLASS: + case rabbit::OT_CLASS: _class(o)->_typetag = typetag; break; default: @@ -767,55 +767,55 @@ SQRESULT sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer typet return SQ_OK; } -SQRESULT sq_getobjtypetag(const HSQOBJECT *o,SQUserPointer * typetag) +rabbit::Result sq_getobjtypetag(const rabbit::Object *o,rabbit::UserPointer * typetag) { switch(sq_type(*o)) { - case OT_INSTANCE: *typetag = _instance(*o)->_class->_typetag; break; - case OT_USERDATA: *typetag = _userdata(*o)->getTypeTag(); break; - case OT_CLASS: *typetag = _class(*o)->_typetag; break; + case rabbit::OT_INSTANCE: *typetag = _instance(*o)->_class->_typetag; break; + case rabbit::OT_USERDATA: *typetag = _userdata(*o)->getTypeTag(); break; + case rabbit::OT_CLASS: *typetag = _class(*o)->_typetag; break; default: return SQ_ERROR; } return SQ_OK; } -SQRESULT sq_gettypetag(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer *typetag) +rabbit::Result sq_gettypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *typetag) { - SQObjectPtr &o = stack_get(v,idx); + rabbit::ObjectPtr &o = stack_get(v,idx); if (SQ_FAILED(sq_getobjtypetag(&o, typetag))) return SQ_ERROR;// this is not an error it should be a bool but would break backward compatibility return SQ_OK; } -SQRESULT sq_getuserpointer(rabbit::VirtualMachine* v, int64_t idx, SQUserPointer *p) +rabbit::Result sq_getuserpointer(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p) { - SQObjectPtr *o = NULL; - _GETSAFE_OBJ(v, idx, OT_USERPOINTER,o); + rabbit::ObjectPtr *o = NULL; + _GETSAFE_OBJ(v, idx, rabbit::OT_USERPOINTER,o); (*p) = _userpointer(*o); return SQ_OK; } -SQRESULT sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, SQUserPointer p) +rabbit::Result sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer p) { - SQObjectPtr &o = stack_get(v,idx); - if(sq_type(o) != OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance")); + 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")); _instance(o)->_userpointer = p; return SQ_OK; } -SQRESULT sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize) +rabbit::Result sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize) { - SQObjectPtr &o = stack_get(v,idx); - if(sq_type(o) != OT_CLASS) return sq_throwerror(v,_SC("the object is not a class")); + 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")); if(_class(o)->_locked) return sq_throwerror(v,_SC("the class is locked")); _class(o)->_udsize = udsize; return SQ_OK; } -SQRESULT sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, SQUserPointer *p,SQUserPointer typetag) +rabbit::Result sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p,rabbit::UserPointer typetag) { - SQObjectPtr &o = stack_get(v,idx); - if(sq_type(o) != OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance")); + 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")); (*p) = _instance(o)->_userpointer; if(typetag != 0) { SQClass *cl = _instance(o)->_class; @@ -868,27 +868,27 @@ int64_t sq_cmp(rabbit::VirtualMachine* v) return res; } -SQRESULT sq_newslot(rabbit::VirtualMachine* v, int64_t idx, SQBool bstatic) +rabbit::Result sq_newslot(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool bstatic) { sq_aux_paramscheck(v, 3); - SQObjectPtr &self = stack_get(v, idx); - if(sq_type(self) == OT_TABLE || sq_type(self) == OT_CLASS) { - SQObjectPtr &key = v->getUp(-2); - if(sq_type(key) == OT_NULL) return sq_throwerror(v, _SC("null is not a valid key")); + rabbit::ObjectPtr &self = stack_get(v, idx); + if(sq_type(self) == rabbit::OT_TABLE || sq_type(self) == OT_CLASS) { + rabbit::ObjectPtr &key = v->getUp(-2); + if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, _SC("null is not a valid key")); v->newSlot(self, key, v->getUp(-1),bstatic?true:false); v->pop(2); } return SQ_OK; } -SQRESULT sq_deleteslot(rabbit::VirtualMachine* v,int64_t idx,SQBool pushval) +rabbit::Result sq_deleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval) { sq_aux_paramscheck(v, 2); - SQObjectPtr *self; - _GETSAFE_OBJ(v, idx, OT_TABLE,self); - SQObjectPtr &key = v->getUp(-1); - if(sq_type(key) == OT_NULL) return sq_throwerror(v, _SC("null is not a valid key")); - SQObjectPtr res; + rabbit::ObjectPtr *self; + _GETSAFE_OBJ(v, idx, rabbit::OT_TABLE,self); + rabbit::ObjectPtr &key = v->getUp(-1); + if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, _SC("null is not a valid key")); + rabbit::ObjectPtr res; if(!v->deleteSlot(*self, key, res)){ v->pop(); return SQ_ERROR; @@ -898,9 +898,9 @@ SQRESULT sq_deleteslot(rabbit::VirtualMachine* v,int64_t idx,SQBool pushval) return SQ_OK; } -SQRESULT sq_set(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_set(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &self = stack_get(v, idx); + rabbit::ObjectPtr &self = stack_get(v, idx); if(v->set(self, v->getUp(-2), v->getUp(-1),DONT_FALL_BACK)) { v->pop(2); return SQ_OK; @@ -908,32 +908,32 @@ SQRESULT sq_set(rabbit::VirtualMachine* v,int64_t idx) return SQ_ERROR; } -SQRESULT sq_rawset(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_rawset(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &self = stack_get(v, idx); - SQObjectPtr &key = v->getUp(-2); - if(sq_type(key) == OT_NULL) { + rabbit::ObjectPtr &self = stack_get(v, idx); + rabbit::ObjectPtr &key = v->getUp(-2); + if(sq_type(key) == rabbit::OT_NULL) { v->pop(2); return sq_throwerror(v, _SC("null key")); } switch(sq_type(self)) { - case OT_TABLE: + case rabbit::OT_TABLE: _table(self)->newSlot(key, v->getUp(-1)); v->pop(2); return SQ_OK; break; - case OT_CLASS: - _class(self)->newSlot(_ss(v), key, v->getUp(-1),false); + case rabbit::OT_CLASS: + _class(self)->newSlot(_get_shared_state(v), key, v->getUp(-1),false); v->pop(2); return SQ_OK; break; - case OT_INSTANCE: + case rabbit::OT_INSTANCE: if(_instance(self)->set(key, v->getUp(-1))) { v->pop(2); return SQ_OK; } break; - case OT_ARRAY: + case rabbit::OT_ARRAY: if(v->set(self, key, v->getUp(-1),false)) { v->pop(2); return SQ_OK; @@ -946,12 +946,12 @@ SQRESULT sq_rawset(rabbit::VirtualMachine* v,int64_t idx) v->raise_Idxerror(v->getUp(-2));return SQ_ERROR; } -SQRESULT sq_newmember(rabbit::VirtualMachine* v,int64_t idx,SQBool bstatic) +rabbit::Result sq_newmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic) { - SQObjectPtr &self = stack_get(v, idx); - if(sq_type(self) != OT_CLASS) return sq_throwerror(v, _SC("new member only works with classes")); - SQObjectPtr &key = v->getUp(-3); - if(sq_type(key) == OT_NULL) return sq_throwerror(v, _SC("null key")); + 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")); + rabbit::ObjectPtr &key = v->getUp(-3); + if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, _SC("null key")); if(!v->newSlotA(self,key,v->getUp(-2),v->getUp(-1),bstatic?true:false,false)) { v->pop(3); return SQ_ERROR; @@ -960,12 +960,12 @@ SQRESULT sq_newmember(rabbit::VirtualMachine* v,int64_t idx,SQBool bstatic) return SQ_OK; } -SQRESULT sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,SQBool bstatic) +rabbit::Result sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic) { - SQObjectPtr &self = stack_get(v, idx); - if(sq_type(self) != OT_CLASS) return sq_throwerror(v, _SC("new member only works with classes")); - SQObjectPtr &key = v->getUp(-3); - if(sq_type(key) == OT_NULL) return sq_throwerror(v, _SC("null key")); + 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")); + rabbit::ObjectPtr &key = v->getUp(-3); + if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, _SC("null key")); if(!v->newSlotA(self,key,v->getUp(-2),v->getUp(-1),bstatic?true:false,true)) { v->pop(3); return SQ_ERROR; @@ -974,27 +974,27 @@ SQRESULT sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,SQBool bstatic) return SQ_OK; } -SQRESULT sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &self = stack_get(v, idx); - SQObjectPtr &mt = v->getUp(-1); - SQObjectType type = sq_type(self); + rabbit::ObjectPtr &self = stack_get(v, idx); + rabbit::ObjectPtr &mt = v->getUp(-1); + rabbit::ObjectType type = sq_type(self); switch(type) { - case OT_TABLE: - if(sq_type(mt) == OT_TABLE) { + case rabbit::OT_TABLE: + if(sq_type(mt) == rabbit::OT_TABLE) { if(!_table(self)->setDelegate(_table(mt))) { return sq_throwerror(v, _SC("delagate cycle")); } v->pop(); } - else if(sq_type(mt)==OT_NULL) { + else if(sq_type(mt)==rabbit::OT_NULL) { _table(self)->setDelegate(NULL); v->pop(); } else return sq_aux_invalidtype(v,type); break; - case OT_USERDATA: - if(sq_type(mt)==OT_TABLE) { + case rabbit::OT_USERDATA: + if(sq_type(mt)==rabbit::OT_TABLE) { _userdata(self)->setDelegate(_table(mt)); v->pop(); } - else if(sq_type(mt)==OT_NULL) { + else if(sq_type(mt)==rabbit::OT_NULL) { _userdata(self)->setDelegate(NULL); v->pop(); } else return sq_aux_invalidtype(v, type); break; @@ -1005,13 +1005,13 @@ SQRESULT sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx) return SQ_OK; } -SQRESULT sq_rawdeleteslot(rabbit::VirtualMachine* v,int64_t idx,SQBool pushval) +rabbit::Result sq_rawdeleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval) { sq_aux_paramscheck(v, 2); - SQObjectPtr *self; - _GETSAFE_OBJ(v, idx, OT_TABLE,self); - SQObjectPtr &key = v->getUp(-1); - SQObjectPtr t; + rabbit::ObjectPtr *self; + _GETSAFE_OBJ(v, idx, rabbit::OT_TABLE,self); + rabbit::ObjectPtr &key = v->getUp(-1); + rabbit::ObjectPtr t; if(_table(*self)->get(key,t)) { _table(*self)->remove(key); } @@ -1022,17 +1022,17 @@ SQRESULT sq_rawdeleteslot(rabbit::VirtualMachine* v,int64_t idx,SQBool pushval) return SQ_OK; } -SQRESULT sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &self=stack_get(v,idx); + rabbit::ObjectPtr &self=stack_get(v,idx); switch(sq_type(self)){ - case OT_TABLE: - case OT_USERDATA: + case rabbit::OT_TABLE: + case rabbit::OT_USERDATA: if(!_delegable(self)->_delegate){ v->pushNull(); break; } - v->push(SQObjectPtr(_delegable(self)->_delegate)); + v->push(rabbit::ObjectPtr(_delegable(self)->_delegate)); break; default: return sq_throwerror(v,_SC("wrong type")); break; } @@ -1040,34 +1040,34 @@ SQRESULT sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx) } -SQRESULT sq_get(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_get(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &self=stack_get(v,idx); - SQObjectPtr &obj = v->getUp(-1); + rabbit::ObjectPtr &self=stack_get(v,idx); + rabbit::ObjectPtr &obj = v->getUp(-1); if(v->get(self,obj,obj,false,DONT_FALL_BACK)) return SQ_OK; v->pop(); return SQ_ERROR; } -SQRESULT sq_rawget(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_rawget(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &self=stack_get(v,idx); - SQObjectPtr &obj = v->getUp(-1); + rabbit::ObjectPtr &self=stack_get(v,idx); + rabbit::ObjectPtr &obj = v->getUp(-1); switch(sq_type(self)) { - case OT_TABLE: + case rabbit::OT_TABLE: if(_table(self)->get(obj,obj)) return SQ_OK; break; - case OT_CLASS: + case rabbit::OT_CLASS: if(_class(self)->get(obj,obj)) return SQ_OK; break; - case OT_INSTANCE: + case rabbit::OT_INSTANCE: if(_instance(self)->get(obj,obj)) return SQ_OK; break; - case OT_ARRAY:{ + case rabbit::OT_ARRAY:{ if(sq_isnumeric(obj)){ if(_array(self)->get(tointeger(obj),obj)) { return SQ_OK; @@ -1087,13 +1087,13 @@ SQRESULT sq_rawget(rabbit::VirtualMachine* v,int64_t idx) return sq_throwerror(v,_SC("the index doesn't exist")); } -SQRESULT sq_getstackobj(rabbit::VirtualMachine* v,int64_t idx,HSQOBJECT *po) +rabbit::Result sq_getstackobj(rabbit::VirtualMachine* v,int64_t idx,rabbit::Object *po) { *po=stack_get(v,idx); return SQ_OK; } -const SQChar *sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx) +const rabbit::Char *sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx) { uint64_t cstksize=v->_callsstacksize; uint64_t lvl=(cstksize-level)-1; @@ -1104,7 +1104,7 @@ const SQChar *sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx) stackbase-=ci._prevstkbase; } rabbit::VirtualMachine::callInfo &ci=v->_callsstack[lvl]; - if(sq_type(ci._closure)!=OT_CLOSURE) + if(sq_type(ci._closure)!=rabbit::OT_CLOSURE) return NULL; SQClosure *c=_closure(ci._closure); SQFunctionProto *func=c->_function; @@ -1118,23 +1118,23 @@ const SQChar *sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx) return NULL; } -void sq_pushobject(rabbit::VirtualMachine* v,HSQOBJECT obj) +void sq_pushobject(rabbit::VirtualMachine* v,rabbit::Object obj) { - v->push(SQObjectPtr(obj)); + v->push(rabbit::ObjectPtr(obj)); } -void sq_resetobject(HSQOBJECT *po) +void sq_resetobject(rabbit::Object *po) { - po->_unVal.pUserPointer=NULL;po->_type=OT_NULL; + po->_unVal.pUserPointer=NULL;po->_type=rabbit::OT_NULL; } -SQRESULT sq_throwerror(rabbit::VirtualMachine* v,const SQChar *err) +rabbit::Result sq_throwerror(rabbit::VirtualMachine* v,const rabbit::Char *err) { - v->_lasterror=SQString::create(_ss(v),err); + v->_lasterror=SQString::create(_get_shared_state(v),err); return SQ_ERROR; } -SQRESULT sq_throwobject(rabbit::VirtualMachine* v) +rabbit::Result sq_throwobject(rabbit::VirtualMachine* v) { v->_lasterror = v->getUp(-1); v->pop(); @@ -1152,7 +1152,7 @@ void sq_getlasterror(rabbit::VirtualMachine* v) v->push(v->_lasterror); } -SQRESULT sq_reservestack(rabbit::VirtualMachine* v,int64_t nsize) +rabbit::Result sq_reservestack(rabbit::VirtualMachine* v,int64_t nsize) { if (((uint64_t)v->_top + nsize) > v->_stack.size()) { if(v->_nmetamethodscall) { @@ -1163,9 +1163,9 @@ SQRESULT sq_reservestack(rabbit::VirtualMachine* v,int64_t nsize) return SQ_OK; } -SQRESULT sq_resume(rabbit::VirtualMachine* v,SQBool retval,SQBool raiseerror) +rabbit::Result sq_resume(rabbit::VirtualMachine* v,rabbit::Bool retval,rabbit::Bool raiseerror) { - if (sq_type(v->getUp(-1)) == OT_GENERATOR) + if (sq_type(v->getUp(-1)) == rabbit::OT_GENERATOR) { v->pushNull(); //retval if (!v->execute(v->getUp(-2), 0, v->_top, v->getUp(-1), raiseerror, rabbit::VirtualMachine::ET_RESUME_GENERATOR)) @@ -1177,9 +1177,9 @@ SQRESULT sq_resume(rabbit::VirtualMachine* v,SQBool retval,SQBool raiseerror) return sq_throwerror(v,_SC("only generators can be resumed")); } -SQRESULT sq_call(rabbit::VirtualMachine* v,int64_t params,SQBool retval,SQBool raiseerror) +rabbit::Result sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::Bool retval,rabbit::Bool raiseerror) { - SQObjectPtr res; + rabbit::ObjectPtr res; if(v->call(v->getUp(-(params+1)),params,v->_top-params,res,raiseerror?true:false)){ if(!v->_suspended) { @@ -1199,10 +1199,10 @@ SQRESULT sq_call(rabbit::VirtualMachine* v,int64_t params,SQBool retval,SQBool r return sq_throwerror(v,_SC("call failed")); } -SQRESULT sq_tailcall(rabbit::VirtualMachine* v, int64_t nparams) +rabbit::Result sq_tailcall(rabbit::VirtualMachine* v, int64_t nparams) { - SQObjectPtr &res = v->getUp(-(nparams + 1)); - if (sq_type(res) != OT_CLOSURE) { + rabbit::ObjectPtr &res = v->getUp(-(nparams + 1)); + if (sq_type(res) != rabbit::OT_CLOSURE) { return sq_throwerror(v, _SC("only closure can be tail called")); } SQClosure *clo = _closure(res); @@ -1218,14 +1218,14 @@ SQRESULT sq_tailcall(rabbit::VirtualMachine* v, int64_t nparams) return SQ_TAILCALL_FLAG; } -SQRESULT sq_suspendvm(rabbit::VirtualMachine* v) +rabbit::Result sq_suspendvm(rabbit::VirtualMachine* v) { return v->Suspend(); } -SQRESULT sq_wakeupvm(rabbit::VirtualMachine* v,SQBool wakeupret,SQBool retval,SQBool raiseerror,SQBool throwerror) +rabbit::Result sq_wakeupvm(rabbit::VirtualMachine* v,rabbit::Bool wakeupret,rabbit::Bool retval,rabbit::Bool raiseerror,rabbit::Bool throwerror) { - SQObjectPtr ret; + rabbit::ObjectPtr ret; if(!v->_suspended) return sq_throwerror(v,_SC("cannot resume a vm that is not running any code")); int64_t target = v->_suspended_target; @@ -1235,7 +1235,7 @@ SQRESULT sq_wakeupvm(rabbit::VirtualMachine* v,SQBool wakeupret,SQBool retval,SQ } v->pop(); } else if(target != -1) { v->getAt(v->_stackbase+v->_suspended_target).Null(); } - SQObjectPtr dummy; + rabbit::ObjectPtr dummy; if(!v->execute(dummy,-1,-1,ret,raiseerror,throwerror?rabbit::VirtualMachine::ET_RESUME_THROW_VM : rabbit::VirtualMachine::ET_RESUME_VM)) { return SQ_ERROR; } @@ -1247,15 +1247,15 @@ SQRESULT sq_wakeupvm(rabbit::VirtualMachine* v,SQBool wakeupret,SQBool retval,SQ void sq_setreleasehook(rabbit::VirtualMachine* v,int64_t idx,SQRELEASEHOOK hook) { - SQObjectPtr &ud=stack_get(v,idx); + rabbit::ObjectPtr &ud=stack_get(v,idx); switch(sq_type(ud) ) { - case OT_USERDATA: + case rabbit::OT_USERDATA: _userdata(ud)->setHook(hook); break; - case OT_INSTANCE: + case rabbit::OT_INSTANCE: _instance(ud)->_hook = hook; break; - case OT_CLASS: + case rabbit::OT_CLASS: _class(ud)->_hook = hook; break; default: @@ -1265,15 +1265,15 @@ void sq_setreleasehook(rabbit::VirtualMachine* v,int64_t idx,SQRELEASEHOOK hook) SQRELEASEHOOK sq_getreleasehook(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &ud=stack_get(v,idx); + rabbit::ObjectPtr &ud=stack_get(v,idx); switch(sq_type(ud) ) { - case OT_USERDATA: + case rabbit::OT_USERDATA: return _userdata(ud)->getHook(); break; - case OT_INSTANCE: + case rabbit::OT_INSTANCE: return _instance(ud)->_hook; break; - case OT_CLASS: + case rabbit::OT_CLASS: return _class(ud)->_hook; break; default: @@ -1283,13 +1283,13 @@ SQRELEASEHOOK sq_getreleasehook(rabbit::VirtualMachine* v,int64_t idx) void sq_setcompilererrorhandler(rabbit::VirtualMachine* v,SQCOMPILERERROR f) { - _ss(v)->_compilererrorhandler = f; + _get_shared_state(v)->_compilererrorhandler = f; } -SQRESULT sq_writeclosure(rabbit::VirtualMachine* v,SQWRITEFUNC w,SQUserPointer up) +rabbit::Result sq_writeclosure(rabbit::VirtualMachine* v,SQWRITEFUNC w,rabbit::UserPointer up) { - SQObjectPtr *o = NULL; - _GETSAFE_OBJ(v, -1, OT_CLOSURE,o); + rabbit::ObjectPtr *o = NULL; + _GETSAFE_OBJ(v, -1, rabbit::OT_CLOSURE,o); unsigned short tag = SQ_BYTECODE_STREAM_TAG; if(_closure(*o)->_function->_noutervalues) return sq_throwerror(v,_SC("a closure with free variables bound cannot be serialized")); @@ -1300,9 +1300,9 @@ SQRESULT sq_writeclosure(rabbit::VirtualMachine* v,SQWRITEFUNC w,SQUserPointer u return SQ_OK; } -SQRESULT sq_readclosure(rabbit::VirtualMachine* v,SQREADFUNC r,SQUserPointer up) +rabbit::Result sq_readclosure(rabbit::VirtualMachine* v,SQREADFUNC r,rabbit::UserPointer up) { - SQObjectPtr closure; + rabbit::ObjectPtr closure; unsigned short tag; if(r(up,&tag,2) != 2) @@ -1315,12 +1315,12 @@ SQRESULT sq_readclosure(rabbit::VirtualMachine* v,SQREADFUNC r,SQUserPointer up) return SQ_OK; } -SQChar *sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize) +rabbit::Char *sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize) { - return _ss(v)->getScratchPad(minsize); + return _get_shared_state(v)->getScratchPad(minsize); } -SQRESULT sq_resurrectunreachable(rabbit::VirtualMachine* v) +rabbit::Result sq_resurrectunreachable(rabbit::VirtualMachine* v) { return sq_throwerror(v,_SC("sq_resurrectunreachable requires a garbage collector build")); } @@ -1331,7 +1331,7 @@ int64_t sq_collectgarbage(rabbit::VirtualMachine* v) return -1; } -SQRESULT sq_getcallee(rabbit::VirtualMachine* v) +rabbit::Result sq_getcallee(rabbit::VirtualMachine* v) { if(v->_callsstacksize > 1) { @@ -1341,13 +1341,13 @@ SQRESULT sq_getcallee(rabbit::VirtualMachine* v) return sq_throwerror(v,_SC("no closure in the calls stack")); } -const SQChar *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval) +const rabbit::Char *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval) { - SQObjectPtr &self=stack_get(v,idx); - const SQChar *name = NULL; + rabbit::ObjectPtr &self=stack_get(v,idx); + const rabbit::Char *name = NULL; switch(sq_type(self)) { - case OT_CLOSURE:{ + case rabbit::OT_CLOSURE:{ SQClosure *clo = _closure(self); SQFunctionProto *fp = clo->_function; if(((uint64_t)fp->_noutervalues) > nval) { @@ -1357,7 +1357,7 @@ const SQChar *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t } } break; - case OT_NATIVECLOSURE:{ + case rabbit::OT_NATIVECLOSURE:{ SQNativeClosure *clo = _nativeclosure(self); if(clo->_noutervalues > nval) { v->push(clo->_outervalues[nval]); @@ -1370,12 +1370,12 @@ const SQChar *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t return name; } -SQRESULT sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval) +rabbit::Result sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval) { - SQObjectPtr &self=stack_get(v,idx); + rabbit::ObjectPtr &self=stack_get(v,idx); switch(sq_type(self)) { - case OT_CLOSURE:{ + case rabbit::OT_CLOSURE:{ SQFunctionProto *fp = _closure(self)->_function; if(((uint64_t)fp->_noutervalues) > nval){ *(_outer(_closure(self)->_outervalues[nval])->_valptr) = stack_get(v,-1); @@ -1383,7 +1383,7 @@ SQRESULT sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval) else return sq_throwerror(v,_SC("invalid free var index")); } break; - case OT_NATIVECLOSURE: + case rabbit::OT_NATIVECLOSURE: if(_nativeclosure(self)->_noutervalues > nval){ _nativeclosure(self)->_outervalues[nval] = stack_get(v,-1); } @@ -1396,14 +1396,14 @@ SQRESULT sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval) return SQ_OK; } -SQRESULT sq_setattributes(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_setattributes(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr *o = NULL; - _GETSAFE_OBJ(v, idx, OT_CLASS,o); - SQObjectPtr &key = stack_get(v,-2); - SQObjectPtr &val = stack_get(v,-1); - SQObjectPtr attrs; - if(sq_type(key) == OT_NULL) { + rabbit::ObjectPtr *o = NULL; + _GETSAFE_OBJ(v, idx, rabbit::OT_CLASS,o); + rabbit::ObjectPtr &key = stack_get(v,-2); + rabbit::ObjectPtr &val = stack_get(v,-1); + rabbit::ObjectPtr attrs; + if(sq_type(key) == rabbit::OT_NULL) { attrs = _class(*o)->_attributes; _class(*o)->_attributes = val; v->pop(2); @@ -1418,13 +1418,13 @@ SQRESULT sq_setattributes(rabbit::VirtualMachine* v,int64_t idx) return sq_throwerror(v,_SC("wrong index")); } -SQRESULT sq_getattributes(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_getattributes(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr *o = NULL; - _GETSAFE_OBJ(v, idx, OT_CLASS,o); - SQObjectPtr &key = stack_get(v,-1); - SQObjectPtr attrs; - if(sq_type(key) == OT_NULL) { + rabbit::ObjectPtr *o = NULL; + _GETSAFE_OBJ(v, idx, rabbit::OT_CLASS,o); + rabbit::ObjectPtr &key = stack_get(v,-1); + rabbit::ObjectPtr attrs; + if(sq_type(key) == rabbit::OT_NULL) { attrs = _class(*o)->_attributes; v->pop(); v->push(attrs); @@ -1438,13 +1438,13 @@ SQRESULT sq_getattributes(rabbit::VirtualMachine* v,int64_t idx) return sq_throwerror(v,_SC("wrong index")); } -SQRESULT sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,HSQMEMBERHANDLE *handle) +rabbit::Result sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,rabbit::MemberHandle *handle) { - SQObjectPtr *o = NULL; - _GETSAFE_OBJ(v, idx, OT_CLASS,o); - SQObjectPtr &key = stack_get(v,-1); + rabbit::ObjectPtr *o = NULL; + _GETSAFE_OBJ(v, idx, rabbit::OT_CLASS,o); + rabbit::ObjectPtr &key = stack_get(v,-1); SQTable *m = _class(*o)->_members; - SQObjectPtr val; + rabbit::ObjectPtr val; if(m->get(key,val)) { handle->_static = _isfield(val) ? SQFalse : SQTrue; handle->_index = _member_idx(val); @@ -1454,10 +1454,10 @@ SQRESULT sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,HSQMEMBERHANDL return sq_throwerror(v,_SC("wrong index")); } -SQRESULT _getmemberbyhandle(rabbit::VirtualMachine* v,SQObjectPtr &self,const HSQMEMBERHANDLE *handle,SQObjectPtr *&val) +rabbit::Result _getmemberbyhandle(rabbit::VirtualMachine* v,rabbit::ObjectPtr &self,const rabbit::MemberHandle *handle,rabbit::ObjectPtr *&val) { switch(sq_type(self)) { - case OT_INSTANCE: { + case rabbit::OT_INSTANCE: { SQInstance *i = _instance(self); if(handle->_static) { SQClass *c = i->_class; @@ -1469,7 +1469,7 @@ SQRESULT _getmemberbyhandle(rabbit::VirtualMachine* v,SQObjectPtr &self,const HS } } break; - case OT_CLASS: { + case rabbit::OT_CLASS: { SQClass *c = _class(self); if(handle->_static) { val = &c->_methods[handle->_index].val; @@ -1485,10 +1485,10 @@ SQRESULT _getmemberbyhandle(rabbit::VirtualMachine* v,SQObjectPtr &self,const HS return SQ_OK; } -SQRESULT sq_getbyhandle(rabbit::VirtualMachine* v,int64_t idx,const HSQMEMBERHANDLE *handle) +rabbit::Result sq_getbyhandle(rabbit::VirtualMachine* v,int64_t idx,const rabbit::MemberHandle *handle) { - SQObjectPtr &self = stack_get(v,idx); - SQObjectPtr *val = NULL; + rabbit::ObjectPtr &self = stack_get(v,idx); + rabbit::ObjectPtr *val = NULL; if(SQ_FAILED(_getmemberbyhandle(v,self,handle,val))) { return SQ_ERROR; } @@ -1496,11 +1496,11 @@ SQRESULT sq_getbyhandle(rabbit::VirtualMachine* v,int64_t idx,const HSQMEMBERHAN return SQ_OK; } -SQRESULT sq_setbyhandle(rabbit::VirtualMachine* v,int64_t idx,const HSQMEMBERHANDLE *handle) +rabbit::Result sq_setbyhandle(rabbit::VirtualMachine* v,int64_t idx,const rabbit::MemberHandle *handle) { - SQObjectPtr &self = stack_get(v,idx); - SQObjectPtr &newval = stack_get(v,-1); - SQObjectPtr *val = NULL; + rabbit::ObjectPtr &self = stack_get(v,idx); + rabbit::ObjectPtr &newval = stack_get(v,-1); + rabbit::ObjectPtr *val = NULL; if(SQ_FAILED(_getmemberbyhandle(v,self,handle,val))) { return SQ_ERROR; } @@ -1509,36 +1509,36 @@ SQRESULT sq_setbyhandle(rabbit::VirtualMachine* v,int64_t idx,const HSQMEMBERHAN return SQ_OK; } -SQRESULT sq_getbase(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_getbase(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr *o = NULL; - _GETSAFE_OBJ(v, idx, OT_CLASS,o); + rabbit::ObjectPtr *o = NULL; + _GETSAFE_OBJ(v, idx, rabbit::OT_CLASS,o); if(_class(*o)->_base) - v->push(SQObjectPtr(_class(*o)->_base)); + v->push(rabbit::ObjectPtr(_class(*o)->_base)); else v->pushNull(); return SQ_OK; } -SQRESULT sq_getclass(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_getclass(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr *o = NULL; - _GETSAFE_OBJ(v, idx, OT_INSTANCE,o); - v->push(SQObjectPtr(_instance(*o)->_class)); + rabbit::ObjectPtr *o = NULL; + _GETSAFE_OBJ(v, idx, rabbit::OT_INSTANCE,o); + v->push(rabbit::ObjectPtr(_instance(*o)->_class)); return SQ_OK; } -SQRESULT sq_createinstance(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_createinstance(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr *o = NULL; - _GETSAFE_OBJ(v, idx, OT_CLASS,o); + rabbit::ObjectPtr *o = NULL; + _GETSAFE_OBJ(v, idx, rabbit::OT_CLASS,o); v->push(_class(*o)->createInstance()); return SQ_OK; } void sq_weakref(rabbit::VirtualMachine* v,int64_t idx) { - SQObject &o=stack_get(v,idx); + rabbit::Object &o=stack_get(v,idx); if(ISREFCOUNTED(sq_type(o))) { v->push(_refcounted(o)->getWeakRef(sq_type(o))); return; @@ -1546,39 +1546,39 @@ void sq_weakref(rabbit::VirtualMachine* v,int64_t idx) v->push(o); } -SQRESULT sq_getweakrefval(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_getweakrefval(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr &o = stack_get(v,idx); - if(sq_type(o) != OT_WEAKREF) { + rabbit::ObjectPtr &o = stack_get(v,idx); + if(sq_type(o) != rabbit::OT_WEAKREF) { return sq_throwerror(v,_SC("the object must be a weakref")); } v->push(_weakref(o)->_obj); return SQ_OK; } -SQRESULT sq_getdefaultdelegate(rabbit::VirtualMachine* v,SQObjectType t) +rabbit::Result sq_getdefaultdelegate(rabbit::VirtualMachine* v,rabbit::ObjectType t) { - SQSharedState *ss = _ss(v); + SQSharedState *ss = _get_shared_state(v); switch(t) { - case OT_TABLE: v->push(ss->_table_default_delegate); break; - case OT_ARRAY: v->push(ss->_array_default_delegate); break; - case OT_STRING: v->push(ss->_string_default_delegate); break; - case OT_INTEGER: case OT_FLOAT: v->push(ss->_number_default_delegate); break; - case OT_GENERATOR: v->push(ss->_generator_default_delegate); break; - case OT_CLOSURE: case OT_NATIVECLOSURE: v->push(ss->_closure_default_delegate); break; - case OT_THREAD: v->push(ss->_thread_default_delegate); break; - case OT_CLASS: v->push(ss->_class_default_delegate); break; - case OT_INSTANCE: v->push(ss->_instance_default_delegate); break; - case OT_WEAKREF: v->push(ss->_weakref_default_delegate); break; + case rabbit::OT_TABLE: v->push(ss->_table_default_delegate); break; + case rabbit::OT_ARRAY: v->push(ss->_array_default_delegate); break; + case rabbit::OT_STRING: v->push(ss->_string_default_delegate); break; + case rabbit::OT_INTEGER: case OT_FLOAT: v->push(ss->_number_default_delegate); break; + case rabbit::OT_GENERATOR: v->push(ss->_generator_default_delegate); break; + case rabbit::OT_CLOSURE: case OT_NATIVECLOSURE: v->push(ss->_closure_default_delegate); break; + case rabbit::OT_THREAD: v->push(ss->_thread_default_delegate); break; + case rabbit::OT_CLASS: v->push(ss->_class_default_delegate); break; + case rabbit::OT_INSTANCE: v->push(ss->_instance_default_delegate); break; + case rabbit::OT_WEAKREF: v->push(ss->_weakref_default_delegate); break; default: return sq_throwerror(v,_SC("the type doesn't have a default delegate")); } return SQ_OK; } -SQRESULT sq_next(rabbit::VirtualMachine* v,int64_t idx) +rabbit::Result sq_next(rabbit::VirtualMachine* v,int64_t idx) { - SQObjectPtr o=stack_get(v,idx),&refpos = stack_get(v,-1),realkey,val; - if(sq_type(o) == OT_GENERATOR) { + rabbit::ObjectPtr o=stack_get(v,idx),&refpos = stack_get(v,-1),realkey,val; + if(sq_type(o) == rabbit::OT_GENERATOR) { return sq_throwerror(v,_SC("cannot iterate a generator")); } int faketojump; @@ -1593,12 +1593,12 @@ SQRESULT sq_next(rabbit::VirtualMachine* v,int64_t idx) } struct BufState{ - const SQChar *buf; + const rabbit::Char *buf; int64_t ptr; int64_t size; }; -int64_t buf_lexfeed(SQUserPointer file) +int64_t buf_lexfeed(rabbit::UserPointer file) { BufState *buf=(BufState*)file; if(buf->size<(buf->ptr+1)) @@ -1606,7 +1606,7 @@ int64_t buf_lexfeed(SQUserPointer file) return buf->buf[buf->ptr++]; } -SQRESULT sq_compilebuffer(rabbit::VirtualMachine* v,const SQChar *s,int64_t size,const SQChar *sourcename,SQBool raiseerror) { +rabbit::Result 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; @@ -1621,18 +1621,18 @@ void sq_move(rabbit::VirtualMachine* dest,rabbit::VirtualMachine* src,int64_t id void sq_setprintfunc(rabbit::VirtualMachine* v, SQPRINTFUNCTION printfunc,SQPRINTFUNCTION errfunc) { - _ss(v)->_printfunc = printfunc; - _ss(v)->_errorfunc = errfunc; + _get_shared_state(v)->_printfunc = printfunc; + _get_shared_state(v)->_errorfunc = errfunc; } SQPRINTFUNCTION sq_getprintfunc(rabbit::VirtualMachine* v) { - return _ss(v)->_printfunc; + return _get_shared_state(v)->_printfunc; } SQPRINTFUNCTION sq_geterrorfunc(rabbit::VirtualMachine* v) { - return _ss(v)->_errorfunc; + return _get_shared_state(v)->_errorfunc; } void *sq_malloc(uint64_t size) diff --git a/rabbit/sqbaselib.cpp b/rabbit/sqbaselib.cpp index 3fd1ae5..6a0f548 100644 --- a/rabbit/sqbaselib.cpp +++ b/rabbit/sqbaselib.cpp @@ -17,13 +17,13 @@ #include #include -static bool str2num(const SQChar *s,SQObjectPtr &res,int64_t base) +static bool str2num(const rabbit::Char *s,rabbit::ObjectPtr &res,int64_t base) { - SQChar *end; - const SQChar *e = s; + rabbit::Char *end; + const rabbit::Char *e = s; bool iseintbase = base > 13; //to fix error converting hexadecimals with e like 56f0791e bool isfloat = false; - SQChar c; + rabbit::Char c; while((c = *e) != _SC('\0')) { if (c == _SC('.') || (!iseintbase && (c == _SC('E') || c == _SC('e')))) { //e and E is for scientific notation @@ -58,14 +58,14 @@ static int64_t base_getroottable(rabbit::VirtualMachine* v) static int64_t base_getconsttable(rabbit::VirtualMachine* v) { - v->push(_ss(v)->_consts); + v->push(_get_shared_state(v)->_consts); return 1; } static int64_t base_setroottable(rabbit::VirtualMachine* v) { - SQObjectPtr o = v->_roottable; + rabbit::ObjectPtr o = v->_roottable; if(SQ_FAILED(sq_setroottable(v))) return SQ_ERROR; v->push(o); return 1; @@ -73,7 +73,7 @@ static int64_t base_setroottable(rabbit::VirtualMachine* v) static int64_t base_setconsttable(rabbit::VirtualMachine* v) { - SQObjectPtr o = _ss(v)->_consts; + rabbit::ObjectPtr o = _get_shared_state(v)->_consts; if(SQ_FAILED(sq_setconsttable(v))) return SQ_ERROR; v->push(o); return 1; @@ -93,7 +93,7 @@ static int64_t base_setdebughook(rabbit::VirtualMachine* v) static int64_t base_enabledebuginfo(rabbit::VirtualMachine* v) { - SQObjectPtr &o=stack_get(v,2); + rabbit::ObjectPtr &o=stack_get(v,2); sq_enabledebuginfo(v,rabbit::VirtualMachine::IsFalse(o)?SQFalse:SQTrue); return 0; @@ -101,14 +101,14 @@ static int64_t base_enabledebuginfo(rabbit::VirtualMachine* v) static int64_t __getcallstackinfos(rabbit::VirtualMachine* v,int64_t level) { - SQStackInfos si; + rabbit::StackInfos si; int64_t seq = 0; - const SQChar *name = NULL; + const rabbit::Char *name = NULL; if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si))) { - const SQChar *fn = _SC("unknown"); - const SQChar *src = _SC("unknown"); + const rabbit::Char *fn = _SC("unknown"); + const rabbit::Char *src = _SC("unknown"); if(si.funcname)fn = si.funcname; if(si.source)src = si.source; sq_newtable(v); @@ -149,7 +149,7 @@ static int64_t base_assert(rabbit::VirtualMachine* v) if(rabbit::VirtualMachine::IsFalse(stack_get(v,2))){ int64_t top = sq_gettop(v); if (top>2 && SQ_SUCCEEDED(sq_tostring(v,3))) { - const SQChar *str = 0; + const rabbit::Char *str = 0; if (SQ_SUCCEEDED(sq_getstring(v,-1,&str))) { return sq_throwerror(v, str); } @@ -159,20 +159,20 @@ static int64_t base_assert(rabbit::VirtualMachine* v) return 0; } -static int64_t get_slice_params(rabbit::VirtualMachine* v,int64_t &sidx,int64_t &eidx,SQObjectPtr &o) +static int64_t get_slice_params(rabbit::VirtualMachine* v,int64_t &sidx,int64_t &eidx,rabbit::ObjectPtr &o) { int64_t top = sq_gettop(v); sidx=0; eidx=0; o=stack_get(v,1); if(top>1){ - SQObjectPtr &start=stack_get(v,2); - if(sq_type(start)!=OT_NULL && sq_isnumeric(start)){ + rabbit::ObjectPtr &start=stack_get(v,2); + if(sq_type(start)!=rabbit::OT_NULL && sq_isnumeric(start)){ sidx=tointeger(start); } } if(top>2){ - SQObjectPtr &end=stack_get(v,3); + rabbit::ObjectPtr &end=stack_get(v,3); if(sq_isnumeric(end)){ eidx=tointeger(end); } @@ -185,11 +185,11 @@ static int64_t get_slice_params(rabbit::VirtualMachine* v,int64_t &sidx,int64_t static int64_t base_print(rabbit::VirtualMachine* v) { - const SQChar *str; + const rabbit::Char *str; if(SQ_SUCCEEDED(sq_tostring(v,2))) { if(SQ_SUCCEEDED(sq_getstring(v,-1,&str))) { - if(_ss(v)->_printfunc) _ss(v)->_printfunc(v,_SC("%s"),str); + if(_get_shared_state(v)->_printfunc) _ss(v)->_printfunc(v,_SC("%s"),str); return 0; } } @@ -198,11 +198,11 @@ static int64_t base_print(rabbit::VirtualMachine* v) static int64_t base_error(rabbit::VirtualMachine* v) { - const SQChar *str; + const rabbit::Char *str; if(SQ_SUCCEEDED(sq_tostring(v,2))) { if(SQ_SUCCEEDED(sq_getstring(v,-1,&str))) { - if(_ss(v)->_errorfunc) _ss(v)->_errorfunc(v,_SC("%s"),str); + if(_get_shared_state(v)->_errorfunc) _ss(v)->_errorfunc(v,_SC("%s"),str); return 0; } } @@ -212,7 +212,7 @@ static int64_t base_error(rabbit::VirtualMachine* v) static int64_t base_compilestring(rabbit::VirtualMachine* v) { int64_t nargs=sq_gettop(v); - const SQChar *src=NULL,*name=_SC("unnamedbuffer"); + const rabbit::Char *src=NULL,*name=_SC("unnamedbuffer"); int64_t size; sq_getstring(v,2,&src); size=sq_getsize(v,2); @@ -227,7 +227,7 @@ static int64_t base_compilestring(rabbit::VirtualMachine* v) static int64_t base_newthread(rabbit::VirtualMachine* v) { - SQObjectPtr &func = stack_get(v,2); + rabbit::ObjectPtr &func = stack_get(v,2); int64_t stksize = (_closure(func)->_function->_stacksize << 1) +2; rabbit::VirtualMachine* newv = sq_newthread(v, (stksize < MIN_STACK_OVERHEAD + 2)? MIN_STACK_OVERHEAD + 2 : stksize); sq_move(newv,v,-2); @@ -242,13 +242,13 @@ static int64_t base_suspend(rabbit::VirtualMachine* v) static int64_t base_array(rabbit::VirtualMachine* v) { rabbit::Array *a; - SQObject &size = stack_get(v,2); + rabbit::Object &size = stack_get(v,2); if(sq_gettop(v) > 2) { - a = rabbit::Array::create(_ss(v),0); + a = rabbit::Array::create(_get_shared_state(v),0); a->resize(tointeger(size),stack_get(v,3)); } else { - a = rabbit::Array::create(_ss(v),tointeger(size)); + a = rabbit::Array::create(_get_shared_state(v),tointeger(size)); } v->push(a); return 1; @@ -256,8 +256,8 @@ static int64_t base_array(rabbit::VirtualMachine* v) static int64_t base_type(rabbit::VirtualMachine* v) { - SQObjectPtr &o = stack_get(v,2); - v->push(SQString::create(_ss(v),getTypeName(o),-1)); + rabbit::ObjectPtr &o = stack_get(v,2); + v->push(SQString::create(_get_shared_state(v),getTypeName(o),-1)); return 1; } @@ -271,7 +271,7 @@ static int64_t base_callee(rabbit::VirtualMachine* v) return sq_throwerror(v,_SC("no closure in the calls stack")); } -static const SQRegFunction base_funcs[]={ +static const rabbit::RegFunction base_funcs[]={ //generic {_SC("seterrorhandler"),base_seterrorhandler,2, NULL}, {_SC("setdebughook"),base_setdebughook,2, NULL}, @@ -314,7 +314,7 @@ void sq_base_register(rabbit::VirtualMachine* v) sq_pushstring(v,RABBIT_VERSION,-1); sq_newslot(v,-3, SQFalse); sq_pushstring(v,_SC("_charsize_"),-1); - sq_pushinteger(v,sizeof(SQChar)); + sq_pushinteger(v,sizeof(rabbit::Char)); sq_newslot(v,-3, SQFalse); sq_pushstring(v,_SC("_intsize_"),-1); sq_pushinteger(v,sizeof(int64_t)); @@ -333,21 +333,21 @@ static int64_t default_delegate_len(rabbit::VirtualMachine* v) static int64_t default_delegate_tofloat(rabbit::VirtualMachine* v) { - SQObjectPtr &o=stack_get(v,1); + rabbit::ObjectPtr &o=stack_get(v,1); switch(sq_type(o)){ - case OT_STRING:{ - SQObjectPtr res; + case rabbit::OT_STRING:{ + rabbit::ObjectPtr res; if(str2num(_stringval(o),res,10)){ - v->push(SQObjectPtr(tofloat(res))); + v->push(rabbit::ObjectPtr(tofloat(res))); break; }} return sq_throwerror(v, _SC("cannot convert the string")); break; - case OT_INTEGER:case OT_FLOAT: - v->push(SQObjectPtr(tofloat(o))); + case rabbit::OT_INTEGER:case OT_FLOAT: + v->push(rabbit::ObjectPtr(tofloat(o))); break; - case OT_BOOL: - v->push(SQObjectPtr((float_t)(_integer(o)?1:0))); + case rabbit::OT_BOOL: + v->push(rabbit::ObjectPtr((float_t)(_integer(o)?1:0))); break; default: v->pushNull(); @@ -358,25 +358,25 @@ static int64_t default_delegate_tofloat(rabbit::VirtualMachine* v) static int64_t default_delegate_tointeger(rabbit::VirtualMachine* v) { - SQObjectPtr &o=stack_get(v,1); + rabbit::ObjectPtr &o=stack_get(v,1); int64_t base = 10; if(sq_gettop(v) > 1) { sq_getinteger(v,2,&base); } switch(sq_type(o)){ - case OT_STRING:{ - SQObjectPtr res; + case rabbit::OT_STRING:{ + rabbit::ObjectPtr res; if(str2num(_stringval(o),res,base)){ - v->push(SQObjectPtr(tointeger(res))); + v->push(rabbit::ObjectPtr(tointeger(res))); break; }} return sq_throwerror(v, _SC("cannot convert the string")); break; - case OT_INTEGER:case OT_FLOAT: - v->push(SQObjectPtr(tointeger(o))); + case rabbit::OT_INTEGER:case OT_FLOAT: + v->push(rabbit::ObjectPtr(tointeger(o))); break; - case OT_BOOL: - v->push(SQObjectPtr(_integer(o)?(int64_t)1:(int64_t)0)); + case rabbit::OT_BOOL: + v->push(rabbit::ObjectPtr(_integer(o)?(int64_t)1:(int64_t)0)); break; default: v->pushNull(); @@ -406,9 +406,9 @@ static int64_t obj_clear(rabbit::VirtualMachine* v) static int64_t number_delegate_tochar(rabbit::VirtualMachine* v) { - SQObject &o=stack_get(v,1); - SQChar c = (SQChar)tointeger(o); - v->push(SQString::create(_ss(v),(const SQChar *)&c,1)); + rabbit::Object &o=stack_get(v,1); + rabbit::Char c = (rabbit::Char)tointeger(o); + v->push(SQString::create(_get_shared_state(v),(const rabbit::Char *)&c,1)); return 1; } @@ -461,11 +461,11 @@ static int64_t table_getdelegate(rabbit::VirtualMachine* v) static int64_t table_filter(rabbit::VirtualMachine* v) { - SQObject &o = stack_get(v,1); + rabbit::Object &o = stack_get(v,1); SQTable *tbl = _table(o); - SQObjectPtr ret = SQTable::create(_ss(v),0); + rabbit::ObjectPtr ret = SQTable::create(_get_shared_state(v),0); - SQObjectPtr itr, key, val; + rabbit::ObjectPtr itr, key, val; int64_t nitr; while((nitr = tbl->next(false, itr, key, val)) != -1) { itr = (int64_t)nitr; @@ -487,7 +487,7 @@ static int64_t table_filter(rabbit::VirtualMachine* v) } -const SQRegFunction SQSharedState::_table_default_delegate_funcz[]={ +const rabbit::RegFunction SQSharedState::_table_default_delegate_funcz[]={ {_SC("len"),default_delegate_len,1, _SC("t")}, {_SC("rawget"),container_rawget,2, _SC("t")}, {_SC("rawset"),container_rawset,3, _SC("t")}, @@ -528,7 +528,7 @@ static int64_t array_pop(rabbit::VirtualMachine* v) static int64_t array_top(rabbit::VirtualMachine* v) { - SQObject &o=stack_get(v,1); + rabbit::Object &o=stack_get(v,1); if(_array(o)->size()>0){ v->push(_array(o)->top()); return 1; @@ -538,9 +538,9 @@ static int64_t array_top(rabbit::VirtualMachine* v) static int64_t array_insert(rabbit::VirtualMachine* v) { - SQObject &o=stack_get(v,1); - SQObject &idx=stack_get(v,2); - SQObject &val=stack_get(v,3); + rabbit::Object &o=stack_get(v,1); + rabbit::Object &idx=stack_get(v,2); + rabbit::Object &val=stack_get(v,3); if(!_array(o)->insert(tointeger(idx),val)) return sq_throwerror(v,_SC("index out of range")); sq_pop(v,2); @@ -549,10 +549,10 @@ static int64_t array_insert(rabbit::VirtualMachine* v) static int64_t array_remove(rabbit::VirtualMachine* v) { - SQObject &o = stack_get(v, 1); - SQObject &idx = stack_get(v, 2); + rabbit::Object &o = stack_get(v, 1); + rabbit::Object &idx = stack_get(v, 2); if(!sq_isnumeric(idx)) return sq_throwerror(v, _SC("wrong type")); - SQObjectPtr val; + rabbit::ObjectPtr val; if(_array(o)->get(tointeger(idx), val)) { _array(o)->remove(tointeger(idx)); v->push(val); @@ -563,9 +563,9 @@ static int64_t array_remove(rabbit::VirtualMachine* v) static int64_t array_resize(rabbit::VirtualMachine* v) { - SQObject &o = stack_get(v, 1); - SQObject &nsize = stack_get(v, 2); - SQObjectPtr fill; + rabbit::Object &o = stack_get(v, 1); + rabbit::Object &nsize = stack_get(v, 2); + rabbit::ObjectPtr fill; if(sq_isnumeric(nsize)) { int64_t sz = tointeger(nsize); if (sz<0) @@ -581,7 +581,7 @@ static int64_t array_resize(rabbit::VirtualMachine* v) } static int64_t __map_array(rabbit::Array *dest,rabbit::Array *src,rabbit::VirtualMachine* v) { - SQObjectPtr temp; + rabbit::ObjectPtr temp; int64_t size = src->size(); for(int64_t n = 0; n < size; n++) { src->get(n,temp); @@ -598,9 +598,9 @@ static int64_t __map_array(rabbit::Array *dest,rabbit::Array *src,rabbit::Virtua static int64_t array_map(rabbit::VirtualMachine* v) { - SQObject &o = stack_get(v,1); + rabbit::Object &o = stack_get(v,1); int64_t size = _array(o)->size(); - SQObjectPtr ret = rabbit::Array::create(_ss(v),size); + rabbit::ObjectPtr ret = rabbit::Array::create(_get_shared_state(v),size); if(SQ_FAILED(__map_array(_array(ret),_array(o),v))) return SQ_ERROR; v->push(ret); @@ -609,7 +609,7 @@ static int64_t array_map(rabbit::VirtualMachine* v) static int64_t array_apply(rabbit::VirtualMachine* v) { - SQObject &o = stack_get(v,1); + rabbit::Object &o = stack_get(v,1); if(SQ_FAILED(__map_array(_array(o),_array(o),v))) return SQ_ERROR; sq_pop(v,1); @@ -618,16 +618,16 @@ static int64_t array_apply(rabbit::VirtualMachine* v) static int64_t array_reduce(rabbit::VirtualMachine* v) { - SQObject &o = stack_get(v,1); + rabbit::Object &o = stack_get(v,1); rabbit::Array *a = _array(o); int64_t size = a->size(); if(size == 0) { return 0; } - SQObjectPtr res; + rabbit::ObjectPtr res; a->get(0,res); if(size > 1) { - SQObjectPtr other; + rabbit::ObjectPtr other; for(int64_t n = 1; n < size; n++) { a->get(n,other); v->push(o); @@ -646,11 +646,11 @@ static int64_t array_reduce(rabbit::VirtualMachine* v) static int64_t array_filter(rabbit::VirtualMachine* v) { - SQObject &o = stack_get(v,1); + rabbit::Object &o = stack_get(v,1); rabbit::Array *a = _array(o); - SQObjectPtr ret = rabbit::Array::create(_ss(v),0); + rabbit::ObjectPtr ret = rabbit::Array::create(_get_shared_state(v),0); int64_t size = a->size(); - SQObjectPtr val; + rabbit::ObjectPtr val; for(int64_t n = 0; n < size; n++) { a->get(n,val); v->push(o); @@ -670,11 +670,11 @@ static int64_t array_filter(rabbit::VirtualMachine* v) static int64_t array_find(rabbit::VirtualMachine* v) { - SQObject &o = stack_get(v,1); - SQObjectPtr &val = stack_get(v,2); + rabbit::Object &o = stack_get(v,1); + rabbit::ObjectPtr &val = stack_get(v,2); rabbit::Array *a = _array(o); int64_t size = a->size(); - SQObjectPtr temp; + rabbit::ObjectPtr temp; for(int64_t n = 0; n < size; n++) { bool res = false; a->get(n,temp); @@ -687,7 +687,7 @@ static int64_t array_find(rabbit::VirtualMachine* v) } -static bool _sort_compare(rabbit::VirtualMachine* v,SQObjectPtr &a,SQObjectPtr &b,int64_t func,int64_t &ret) +static bool _sort_compare(rabbit::VirtualMachine* v,rabbit::ObjectPtr &a,rabbit::ObjectPtr &b,int64_t func,int64_t &ret) { if(func < 0) { if(!v->objCmp(a,b,ret)) return false; @@ -753,7 +753,7 @@ static bool _hsort_sift_down(rabbit::VirtualMachine* v,rabbit::Array *arr, int64 return true; } -static bool _hsort(rabbit::VirtualMachine* v,SQObjectPtr &arr, int64_t SQ_UNUSED_ARG(l), int64_t SQ_UNUSED_ARG(r),int64_t func) +static bool _hsort(rabbit::VirtualMachine* v,rabbit::ObjectPtr &arr, int64_t SQ_UNUSED_ARG(l), int64_t SQ_UNUSED_ARG(r),int64_t func) { rabbit::Array *a = _array(arr); int64_t i; @@ -773,7 +773,7 @@ static bool _hsort(rabbit::VirtualMachine* v,SQObjectPtr &arr, int64_t SQ_UNUSED static int64_t array_sort(rabbit::VirtualMachine* v) { int64_t func = -1; - SQObjectPtr &o = stack_get(v,1); + rabbit::ObjectPtr &o = stack_get(v,1); if(_array(o)->size() > 1) { if(sq_gettop(v) == 2) func = 2; if(!_hsort(v, o, 0, _array(o)->size()-1, func)) @@ -787,15 +787,15 @@ static int64_t array_sort(rabbit::VirtualMachine* v) static int64_t array_slice(rabbit::VirtualMachine* v) { int64_t sidx,eidx; - SQObjectPtr o; + rabbit::ObjectPtr o; if(get_slice_params(v,sidx,eidx,o)==-1)return -1; int64_t alen = _array(o)->size(); if(sidx < 0)sidx = alen + sidx; if(eidx < 0)eidx = alen + eidx; if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes")); if(eidx > alen || sidx < 0)return sq_throwerror(v, _SC("slice out of range")); - rabbit::Array *arr=rabbit::Array::create(_ss(v),eidx-sidx); - SQObjectPtr t; + rabbit::Array *arr=rabbit::Array::create(_get_shared_state(v),eidx-sidx); + rabbit::ObjectPtr t; int64_t count=0; for(int64_t i=sidx;iget(i,t); @@ -806,7 +806,7 @@ static int64_t array_slice(rabbit::VirtualMachine* v) } -const SQRegFunction SQSharedState::_array_default_delegate_funcz[]={ +const rabbit::RegFunction SQSharedState::_array_default_delegate_funcz[]={ {_SC("len"),default_delegate_len,1, _SC("a")}, {_SC("append"),array_append,2, _SC("a")}, {_SC("extend"),array_extend,2, _SC("aa")}, @@ -834,21 +834,21 @@ const SQRegFunction SQSharedState::_array_default_delegate_funcz[]={ static int64_t string_slice(rabbit::VirtualMachine* v) { int64_t sidx,eidx; - SQObjectPtr o; + rabbit::ObjectPtr o; if(SQ_FAILED(get_slice_params(v,sidx,eidx,o)))return -1; int64_t slen = _string(o)->_len; if(sidx < 0)sidx = slen + sidx; if(eidx < 0)eidx = slen + eidx; if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes")); if(eidx > slen || sidx < 0) return sq_throwerror(v, _SC("slice out of range")); - v->push(SQString::create(_ss(v),&_stringval(o)[sidx],eidx-sidx)); + v->push(SQString::create(_get_shared_state(v),&_stringval(o)[sidx],eidx-sidx)); return 1; } static int64_t string_find(rabbit::VirtualMachine* v) { int64_t top,start_idx=0; - const SQChar *str,*substr,*ret; + const rabbit::Char *str,*substr,*ret; if(((top=sq_gettop(v))>1) && SQ_SUCCEEDED(sq_getstring(v,1,&str)) && SQ_SUCCEEDED(sq_getstring(v,2,&substr))){ if(top>2)sq_getinteger(v,3,&start_idx); if((sq_getsize(v,1)>start_idx) && (start_idx>=0)){ @@ -866,7 +866,7 @@ static int64_t string_find(rabbit::VirtualMachine* v) #define STRING_TOFUNCZ(func) static int64_t string_##func(rabbit::VirtualMachine* v) \ {\ int64_t sidx,eidx; \ - SQObjectPtr str; \ + rabbit::ObjectPtr str; \ if(SQ_FAILED(get_slice_params(v,sidx,eidx,str)))return -1; \ int64_t slen = _string(str)->_len; \ if(sidx < 0)sidx = slen + sidx; \ @@ -874,11 +874,11 @@ static int64_t string_find(rabbit::VirtualMachine* v) if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes")); \ if(eidx > slen || sidx < 0) return sq_throwerror(v,_SC("slice out of range")); \ int64_t len=_string(str)->_len; \ - const SQChar *sthis=_stringval(str); \ - SQChar *snew=(_ss(v)->getScratchPad(sq_rsl(len))); \ + const rabbit::Char *sthis=_stringval(str); \ + rabbit::Char *snew=(_get_shared_state(v)->getScratchPad(sq_rsl(len))); \ memcpy(snew,sthis,sq_rsl(len));\ for(int64_t i=sidx;ipush(SQString::create(_ss(v),snew,len)); \ + v->push(SQString::create(_get_shared_state(v),snew,len)); \ return 1; \ } @@ -886,7 +886,7 @@ static int64_t string_find(rabbit::VirtualMachine* v) STRING_TOFUNCZ(tolower) STRING_TOFUNCZ(toupper) -const SQRegFunction SQSharedState::_string_default_delegate_funcz[]={ +const rabbit::RegFunction SQSharedState::_string_default_delegate_funcz[]={ {_SC("len"),default_delegate_len,1, _SC("s")}, {_SC("tointeger"),default_delegate_tointeger,-1, _SC("sn")}, {_SC("tofloat"),default_delegate_tofloat,1, _SC("s")}, @@ -900,7 +900,7 @@ const SQRegFunction SQSharedState::_string_default_delegate_funcz[]={ }; //INTEGER DEFAULT DELEGATE////////////////////////// -const SQRegFunction SQSharedState::_number_default_delegate_funcz[]={ +const rabbit::RegFunction SQSharedState::_number_default_delegate_funcz[]={ {_SC("tointeger"),default_delegate_tointeger,1, _SC("n|b")}, {_SC("tofloat"),default_delegate_tofloat,1, _SC("n|b")}, {_SC("tostring"),default_delegate_tostring,1, _SC(".")}, @@ -917,15 +917,15 @@ static int64_t closure_pcall(rabbit::VirtualMachine* v) static int64_t closure_call(rabbit::VirtualMachine* v) { - SQObjectPtr &c = stack_get(v, -1); - if (sq_type(c) == OT_CLOSURE && (_closure(c)->_function->_bgenerator == false)) + rabbit::ObjectPtr &c = stack_get(v, -1); + if (sq_type(c) == rabbit::OT_CLOSURE && (_closure(c)->_function->_bgenerator == false)) { return sq_tailcall(v, sq_gettop(v) - 1); } return SQ_SUCCEEDED(sq_call(v, sq_gettop(v) - 1, SQTrue, SQTrue)) ? 1 : SQ_ERROR; } -static int64_t _closure_acall(rabbit::VirtualMachine* v,SQBool raiseerror) +static int64_t _closure_acall(rabbit::VirtualMachine* v,rabbit::Bool raiseerror) { rabbit::Array *aparams=_array(stack_get(v,2)); int64_t nparams=aparams->size(); @@ -966,13 +966,13 @@ static int64_t closure_setroot(rabbit::VirtualMachine* v) } static int64_t closure_getinfos(rabbit::VirtualMachine* v) { - SQObject o = stack_get(v,1); - SQTable *res = SQTable::create(_ss(v),4); - if(sq_type(o) == OT_CLOSURE) { + rabbit::Object o = stack_get(v,1); + SQTable *res = SQTable::create(_get_shared_state(v),4); + if(sq_type(o) == rabbit::OT_CLOSURE) { SQFunctionProto *f = _closure(o)->_function; int64_t nparams = f->_nparameters + (f->_varparams?1:0); - SQObjectPtr params = rabbit::Array::create(_ss(v),nparams); - SQObjectPtr defparams = rabbit::Array::create(_ss(v),f->_ndefaultparams); + rabbit::ObjectPtr params = rabbit::Array::create(_get_shared_state(v),nparams); + rabbit::ObjectPtr defparams = rabbit::Array::create(_get_shared_state(v),f->_ndefaultparams); for(int64_t n = 0; n_nparameters; n++) { _array(params)->set((int64_t)n,f->_parameters[n]); } @@ -980,29 +980,29 @@ static int64_t closure_getinfos(rabbit::VirtualMachine* v) { _array(defparams)->set((int64_t)j,_closure(o)->_defaultparams[j]); } if(f->_varparams) { - _array(params)->set(nparams-1,SQString::create(_ss(v),_SC("..."),-1)); + _array(params)->set(nparams-1,SQString::create(_get_shared_state(v),_SC("..."),-1)); } - res->newSlot(SQString::create(_ss(v),_SC("native"),-1),false); - res->newSlot(SQString::create(_ss(v),_SC("name"),-1),f->_name); - res->newSlot(SQString::create(_ss(v),_SC("src"),-1),f->_sourcename); - res->newSlot(SQString::create(_ss(v),_SC("parameters"),-1),params); - res->newSlot(SQString::create(_ss(v),_SC("varargs"),-1),f->_varparams); - res->newSlot(SQString::create(_ss(v),_SC("defparams"),-1),defparams); + res->newSlot(SQString::create(_get_shared_state(v),_SC("native"),-1),false); + res->newSlot(SQString::create(_get_shared_state(v),_SC("name"),-1),f->_name); + res->newSlot(SQString::create(_get_shared_state(v),_SC("src"),-1),f->_sourcename); + res->newSlot(SQString::create(_get_shared_state(v),_SC("parameters"),-1),params); + res->newSlot(SQString::create(_get_shared_state(v),_SC("varargs"),-1),f->_varparams); + res->newSlot(SQString::create(_get_shared_state(v),_SC("defparams"),-1),defparams); } - else { //OT_NATIVECLOSURE + else { //rabbit::OT_NATIVECLOSURE SQNativeClosure *nc = _nativeclosure(o); - res->newSlot(SQString::create(_ss(v),_SC("native"),-1),true); - res->newSlot(SQString::create(_ss(v),_SC("name"),-1),nc->_name); - res->newSlot(SQString::create(_ss(v),_SC("paramscheck"),-1),nc->_nparamscheck); - SQObjectPtr typecheck; + res->newSlot(SQString::create(_get_shared_state(v),_SC("native"),-1),true); + res->newSlot(SQString::create(_get_shared_state(v),_SC("name"),-1),nc->_name); + res->newSlot(SQString::create(_get_shared_state(v),_SC("paramscheck"),-1),nc->_nparamscheck); + rabbit::ObjectPtr typecheck; if(nc->_typecheck.size() > 0) { typecheck = - rabbit::Array::create(_ss(v), nc->_typecheck.size()); + rabbit::Array::create(_get_shared_state(v), nc->_typecheck.size()); for(uint64_t n = 0; n_typecheck.size(); n++) { _array(typecheck)->set((int64_t)n,nc->_typecheck[n]); } } - res->newSlot(SQString::create(_ss(v),_SC("typecheck"),-1),typecheck); + res->newSlot(SQString::create(_get_shared_state(v),_SC("typecheck"),-1),typecheck); } v->push(res); return 1; @@ -1010,7 +1010,7 @@ static int64_t closure_getinfos(rabbit::VirtualMachine* v) { -const SQRegFunction SQSharedState::_closure_default_delegate_funcz[]={ +const rabbit::RegFunction SQSharedState::_closure_default_delegate_funcz[]={ {_SC("call"),closure_call,-1, _SC("c")}, {_SC("pcall"),closure_pcall,-1, _SC("c")}, {_SC("acall"),closure_acall,2, _SC("ca")}, @@ -1027,16 +1027,16 @@ const SQRegFunction SQSharedState::_closure_default_delegate_funcz[]={ //GENERATOR DEFAULT DELEGATE static int64_t generator_getstatus(rabbit::VirtualMachine* v) { - SQObject &o=stack_get(v,1); + rabbit::Object &o=stack_get(v,1); switch(_generator(o)->_state){ - case SQGenerator::eSuspended:v->push(SQString::create(_ss(v),_SC("suspended")));break; - case SQGenerator::eRunning:v->push(SQString::create(_ss(v),_SC("running")));break; - case SQGenerator::eDead:v->push(SQString::create(_ss(v),_SC("dead")));break; + case SQGenerator::eSuspended:v->push(SQString::create(_get_shared_state(v),_SC("suspended")));break; + case SQGenerator::eRunning:v->push(SQString::create(_get_shared_state(v),_SC("running")));break; + case SQGenerator::eDead:v->push(SQString::create(_get_shared_state(v),_SC("dead")));break; } return 1; } -const SQRegFunction SQSharedState::_generator_default_delegate_funcz[]={ +const rabbit::RegFunction SQSharedState::_generator_default_delegate_funcz[]={ {_SC("getstatus"),generator_getstatus,1, _SC("g")}, {_SC("weakref"),obj_delegate_weakref,1, NULL }, {_SC("tostring"),default_delegate_tostring,1, _SC(".")}, @@ -1046,8 +1046,8 @@ const SQRegFunction SQSharedState::_generator_default_delegate_funcz[]={ //THREAD DEFAULT DELEGATE static int64_t thread_call(rabbit::VirtualMachine* v) { - SQObjectPtr o = stack_get(v,1); - if(sq_type(o) == OT_THREAD) { + rabbit::ObjectPtr o = stack_get(v,1); + if(sq_type(o) == rabbit::OT_THREAD) { int64_t nparams = sq_gettop(v); _thread(o)->push(_thread(o)->_roottable); for(int64_t i = 2; i<(nparams+1); i++) @@ -1065,8 +1065,8 @@ static int64_t thread_call(rabbit::VirtualMachine* v) static int64_t thread_wakeup(rabbit::VirtualMachine* v) { - SQObjectPtr o = stack_get(v,1); - if(sq_type(o) == OT_THREAD) { + rabbit::ObjectPtr o = stack_get(v,1); + if(sq_type(o) == rabbit::OT_THREAD) { rabbit::VirtualMachine *thread = _thread(o); int64_t state = sq_getvmstate(thread); if(state != SQ_VMSTATE_SUSPENDED) { @@ -1101,8 +1101,8 @@ static int64_t thread_wakeup(rabbit::VirtualMachine* v) static int64_t thread_wakeupthrow(rabbit::VirtualMachine* v) { - SQObjectPtr o = stack_get(v,1); - if(sq_type(o) == OT_THREAD) { + rabbit::ObjectPtr o = stack_get(v,1); + if(sq_type(o) == rabbit::OT_THREAD) { rabbit::VirtualMachine *thread = _thread(o); int64_t state = sq_getvmstate(thread); if(state != SQ_VMSTATE_SUSPENDED) { @@ -1118,7 +1118,7 @@ static int64_t thread_wakeupthrow(rabbit::VirtualMachine* v) sq_move(thread,v,2); sq_throwobject(thread); - SQBool rethrow_error = SQTrue; + rabbit::Bool rethrow_error = SQTrue; if(sq_gettop(v) > 2) { sq_getbool(v,3,&rethrow_error); } @@ -1142,7 +1142,7 @@ static int64_t thread_wakeupthrow(rabbit::VirtualMachine* v) static int64_t thread_getstatus(rabbit::VirtualMachine* v) { - SQObjectPtr &o = stack_get(v,1); + rabbit::ObjectPtr &o = stack_get(v,1); switch(sq_getvmstate(_thread(o))) { case SQ_VMSTATE_IDLE: sq_pushstring(v,_SC("idle"),-1); @@ -1161,17 +1161,17 @@ static int64_t thread_getstatus(rabbit::VirtualMachine* v) static int64_t thread_getstackinfos(rabbit::VirtualMachine* v) { - SQObjectPtr o = stack_get(v,1); - if(sq_type(o) == OT_THREAD) { + rabbit::ObjectPtr o = stack_get(v,1); + if(sq_type(o) == rabbit::OT_THREAD) { rabbit::VirtualMachine *thread = _thread(o); int64_t threadtop = sq_gettop(thread); int64_t level; sq_getinteger(v,-1,&level); - SQRESULT res = __getcallstackinfos(thread,level); + rabbit::Result res = __getcallstackinfos(thread,level); if(SQ_FAILED(res)) { sq_settop(thread,threadtop); - if(sq_type(thread->_lasterror) == OT_STRING) { + if(sq_type(thread->_lasterror) == rabbit::OT_STRING) { sq_throwerror(v,_stringval(thread->_lasterror)); } else { @@ -1192,7 +1192,7 @@ static int64_t thread_getstackinfos(rabbit::VirtualMachine* v) return sq_throwerror(v,_SC("wrong parameter")); } -const SQRegFunction SQSharedState::_thread_default_delegate_funcz[] = { +const rabbit::RegFunction SQSharedState::_thread_default_delegate_funcz[] = { {_SC("call"), thread_call, -1, _SC("v")}, {_SC("wakeup"), thread_wakeup, -1, _SC("v")}, {_SC("wakeupthrow"), thread_wakeupthrow, -2, _SC("v.b")}, @@ -1226,7 +1226,7 @@ static int64_t class_getbase(rabbit::VirtualMachine* v) static int64_t class_newmember(rabbit::VirtualMachine* v) { int64_t top = sq_gettop(v); - SQBool bstatic = SQFalse; + rabbit::Bool bstatic = SQFalse; if(top == 5) { sq_tobool(v,-1,&bstatic); @@ -1242,7 +1242,7 @@ static int64_t class_newmember(rabbit::VirtualMachine* v) static int64_t class_rawnewmember(rabbit::VirtualMachine* v) { int64_t top = sq_gettop(v); - SQBool bstatic = SQFalse; + rabbit::Bool bstatic = SQFalse; if(top == 5) { sq_tobool(v,-1,&bstatic); @@ -1255,7 +1255,7 @@ static int64_t class_rawnewmember(rabbit::VirtualMachine* v) return SQ_SUCCEEDED(sq_rawnewmember(v,-4,bstatic))?1:SQ_ERROR; } -const SQRegFunction SQSharedState::_class_default_delegate_funcz[] = { +const rabbit::RegFunction SQSharedState::_class_default_delegate_funcz[] = { {_SC("getattributes"), class_getattributes, 2, _SC("y.")}, {_SC("setattributes"), class_setattributes, 3, _SC("y..")}, {_SC("rawget"),container_rawget,2, _SC("y")}, @@ -1278,7 +1278,7 @@ static int64_t instance_getclass(rabbit::VirtualMachine* v) return SQ_ERROR; } -const SQRegFunction SQSharedState::_instance_default_delegate_funcz[] = { +const rabbit::RegFunction SQSharedState::_instance_default_delegate_funcz[] = { {_SC("getclass"), instance_getclass, 1, _SC("x")}, {_SC("rawget"),container_rawget,2, _SC("x")}, {_SC("rawset"),container_rawset,3, _SC("x")}, @@ -1295,7 +1295,7 @@ static int64_t weakref_ref(rabbit::VirtualMachine* v) return 1; } -const SQRegFunction SQSharedState::_weakref_default_delegate_funcz[] = { +const rabbit::RegFunction SQSharedState::_weakref_default_delegate_funcz[] = { {_SC("ref"),weakref_ref,1, _SC("r")}, {_SC("weakref"),obj_delegate_weakref,1, NULL }, {_SC("tostring"),default_delegate_tostring,1, _SC(".")}, diff --git a/rabbit/sqclass.cpp b/rabbit/sqclass.cpp index 05caee3..fb7cc4f 100644 --- a/rabbit/sqclass.cpp +++ b/rabbit/sqclass.cpp @@ -50,10 +50,10 @@ SQClass::~SQClass() finalize(); } -bool SQClass::newSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr &val,bool bstatic) +bool SQClass::newSlot(SQSharedState *ss,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,bool bstatic) { - SQObjectPtr temp; - bool belongs_to_static_table = sq_type(val) == OT_CLOSURE || sq_type(val) == OT_NATIVECLOSURE || bstatic; + rabbit::ObjectPtr temp; + bool belongs_to_static_table = sq_type(val) == rabbit::OT_CLOSURE || sq_type(val) == OT_NATIVECLOSURE || bstatic; if(_locked && !belongs_to_static_table) return false; //the class already has an instance so cannot be modified if(_members->get(key,temp) && _isfield(temp)) //overrides the default value @@ -63,18 +63,18 @@ bool SQClass::newSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr } if(belongs_to_static_table) { int64_t mmidx; - if((sq_type(val) == OT_CLOSURE || sq_type(val) == OT_NATIVECLOSURE) && + if((sq_type(val) == rabbit::OT_CLOSURE || sq_type(val) == OT_NATIVECLOSURE) && (mmidx = ss->getMetaMethodIdxByName(key)) != -1) { _metamethods[mmidx] = val; } else { - SQObjectPtr theval = val; - if(_base && sq_type(val) == OT_CLOSURE) { + rabbit::ObjectPtr theval = val; + if(_base && sq_type(val) == rabbit::OT_CLOSURE) { theval = _closure(val)->clone(); _closure(theval)->_base = _base; __ObjaddRef(_base); //ref for the closure } - if(sq_type(temp) == OT_NULL) { + if(sq_type(temp) == rabbit::OT_NULL) { bool isconstructor; rabbit::VirtualMachine::isEqual(ss->_constructoridx, key, isconstructor); if(isconstructor) { @@ -82,7 +82,7 @@ bool SQClass::newSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr } SQClassMember m; m.val = theval; - _members->newSlot(key,SQObjectPtr(_make_method_idx(_methods.size()))); + _members->newSlot(key,rabbit::ObjectPtr(_make_method_idx(_methods.size()))); _methods.pushBack(m); } else { @@ -93,7 +93,7 @@ bool SQClass::newSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr } SQClassMember m; m.val = val; - _members->newSlot(key,SQObjectPtr(_make_field_idx(_defaultvalues.size()))); + _members->newSlot(key,rabbit::ObjectPtr(_make_field_idx(_defaultvalues.size()))); _defaultvalues.pushBack(m); return true; } @@ -104,25 +104,25 @@ SQInstance *SQClass::createInstance() return SQInstance::create(NULL,this); } -int64_t SQClass::next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval) +int64_t SQClass::next(const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval) { - SQObjectPtr oval; + rabbit::ObjectPtr oval; int64_t idx = _members->next(false,refpos,outkey,oval); if(idx != -1) { if(_ismethod(oval)) { outval = _methods[_member_idx(oval)].val; } else { - SQObjectPtr &o = _defaultvalues[_member_idx(oval)].val; + rabbit::ObjectPtr &o = _defaultvalues[_member_idx(oval)].val; outval = _realval(o); } } return idx; } -bool SQClass::setAttributes(const SQObjectPtr &key,const SQObjectPtr &val) +bool SQClass::setAttributes(const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val) { - SQObjectPtr idx; + rabbit::ObjectPtr idx; if(_members->get(key,idx)) { if(_isfield(idx)) _defaultvalues[_member_idx(idx)].attrs = val; @@ -133,9 +133,9 @@ bool SQClass::setAttributes(const SQObjectPtr &key,const SQObjectPtr &val) return false; } -bool SQClass::getAttributes(const SQObjectPtr &key,SQObjectPtr &outval) +bool SQClass::getAttributes(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &outval) { - SQObjectPtr idx; + rabbit::ObjectPtr idx; if(_members->get(key,idx)) { outval = (_isfield(idx)?_defaultvalues[_member_idx(idx)].attrs:_methods[_member_idx(idx)].attrs); return true; @@ -158,7 +158,7 @@ SQInstance::SQInstance(SQSharedState *ss, SQClass *c, int64_t memsize) _class = c; uint64_t nvalues = _class->_defaultvalues.size(); for(uint64_t n = 0; n < nvalues; n++) { - new (&_values[n]) SQObjectPtr(_class->_defaultvalues[n].val); + new (&_values[n]) rabbit::ObjectPtr(_class->_defaultvalues[n].val); } init(ss); } @@ -169,7 +169,7 @@ SQInstance::SQInstance(SQSharedState *ss, SQInstance *i, int64_t memsize) _class = i->_class; uint64_t nvalues = _class->_defaultvalues.size(); for(uint64_t n = 0; n < nvalues; n++) { - new (&_values[n]) SQObjectPtr(i->_values[n]); + new (&_values[n]) rabbit::ObjectPtr(i->_values[n]); } init(ss); } @@ -186,9 +186,9 @@ SQInstance::~SQInstance() if(_class){ finalize(); } //if _class is null it was already finalized by the GC } -bool SQInstance::getMetaMethod(rabbit::VirtualMachine* SQ_UNUSED_ARG(v),SQMetaMethod mm,SQObjectPtr &res) +bool SQInstance::getMetaMethod(rabbit::VirtualMachine* SQ_UNUSED_ARG(v),rabbit::MetaMethod mm,rabbit::ObjectPtr &res) { - if(sq_type(_class->_metamethods[mm]) != OT_NULL) { + if(sq_type(_class->_metamethods[mm]) != rabbit::OT_NULL) { res = _class->_metamethods[mm]; return true; } diff --git a/rabbit/sqclass.hpp b/rabbit/sqclass.hpp index 42f66ee..b9d212b 100644 --- a/rabbit/sqclass.hpp +++ b/rabbit/sqclass.hpp @@ -10,8 +10,8 @@ struct SQInstance; struct SQClassMember { - SQObjectPtr val; - SQObjectPtr attrs; + rabbit::ObjectPtr val; + rabbit::ObjectPtr attrs; void Null() { val.Null(); attrs.Null(); @@ -40,11 +40,11 @@ public: return newclass; } ~SQClass(); - bool newSlot(SQSharedState *ss, const SQObjectPtr &key,const SQObjectPtr &val,bool bstatic); - bool get(const SQObjectPtr &key,SQObjectPtr &val) { + bool newSlot(SQSharedState *ss, const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,bool bstatic); + bool get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val) { if(_members->get(key,val)) { if(_isfield(val)) { - SQObjectPtr &o = _defaultvalues[_member_idx(val)].val; + rabbit::ObjectPtr &o = _defaultvalues[_member_idx(val)].val; val = _realval(o); } else { @@ -54,7 +54,7 @@ public: } return false; } - bool getConstructor(SQObjectPtr &ctor) + bool getConstructor(rabbit::ObjectPtr &ctor) { if(_constructoridx != -1) { ctor = _methods[_constructoridx].val; @@ -62,23 +62,23 @@ public: } return false; } - bool setAttributes(const SQObjectPtr &key,const SQObjectPtr &val); - bool getAttributes(const SQObjectPtr &key,SQObjectPtr &outval); + bool setAttributes(const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val); + bool getAttributes(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &outval); void lock() { _locked = true; if(_base) _base->lock(); } void release() { if (_hook) { _hook(_typetag,0);} sq_delete(this, SQClass); } void finalize(); - int64_t next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); + int64_t next(const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval); SQInstance *createInstance(); SQTable *_members; SQClass *_base; SQClassMemberVec _defaultvalues; SQClassMemberVec _methods; - SQObjectPtr _metamethods[MT_LAST]; - SQObjectPtr _attributes; - SQUserPointer _typetag; + rabbit::ObjectPtr _metamethods[MT_LAST]; + rabbit::ObjectPtr _attributes; + rabbit::UserPointer _typetag; SQRELEASEHOOK _hook; bool _locked; int64_t _constructoridx; @@ -86,9 +86,9 @@ public: }; #define calcinstancesize(_theclass_) \ - (_theclass_->_udsize + sq_aligning(sizeof(SQInstance) + (sizeof(SQObjectPtr)*(_theclass_->_defaultvalues.size()>0?_theclass_->_defaultvalues.size()-1:0)))) + (_theclass_->_udsize + sq_aligning(sizeof(SQInstance) + (sizeof(rabbit::ObjectPtr)*(_theclass_->_defaultvalues.size()>0?_theclass_->_defaultvalues.size()-1:0)))) -struct SQInstance : public SQDelegable +struct SQInstance : public rabbit::Delegable { void init(SQSharedState *ss); SQInstance(SQSharedState *ss, SQClass *c, int64_t memsize); @@ -115,10 +115,10 @@ public: return newinst; } ~SQInstance(); - bool get(const SQObjectPtr &key,SQObjectPtr &val) { + bool get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val) { if(_class->_members->get(key,val)) { if(_isfield(val)) { - SQObjectPtr &o = _values[_member_idx(val)]; + rabbit::ObjectPtr &o = _values[_member_idx(val)]; val = _realval(o); } else { @@ -128,8 +128,8 @@ public: } return false; } - bool set(const SQObjectPtr &key,const SQObjectPtr &val) { - SQObjectPtr idx; + bool set(const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val) { + rabbit::ObjectPtr idx; if(_class->_members->get(key,idx) && _isfield(idx)) { _values[_member_idx(idx)] = val; return true; @@ -147,12 +147,12 @@ public: } void finalize(); bool instanceOf(SQClass *trg); - bool getMetaMethod(rabbit::VirtualMachine *v,SQMetaMethod mm,SQObjectPtr &res); + bool getMetaMethod(rabbit::VirtualMachine *v,rabbit::MetaMethod mm,rabbit::ObjectPtr &res); SQClass *_class; - SQUserPointer _userpointer; + rabbit::UserPointer _userpointer; SQRELEASEHOOK _hook; int64_t _memsize; - SQObjectPtr _values[1]; + rabbit::ObjectPtr _values[1]; }; diff --git a/rabbit/sqclosure.hpp b/rabbit/sqclosure.hpp index 56df677..fd7ffe1 100644 --- a/rabbit/sqclosure.hpp +++ b/rabbit/sqclosure.hpp @@ -7,7 +7,7 @@ */ #pragma once -#define _CALC_CLOSURE_SIZE(func) (sizeof(SQClosure) + (func->_noutervalues*sizeof(SQObjectPtr)) + (func->_ndefaultparams*sizeof(SQObjectPtr))) +#define _CALC_CLOSURE_SIZE(func) (sizeof(SQClosure) + (func->_noutervalues*sizeof(rabbit::ObjectPtr)) + (func->_ndefaultparams*sizeof(rabbit::ObjectPtr))) struct SQFunctionProto; struct SQClass; @@ -25,19 +25,19 @@ public: int64_t size = _CALC_CLOSURE_SIZE(func); SQClosure *nc=(SQClosure*)SQ_MALLOC(size); new (nc) SQClosure(ss,func); - nc->_outervalues = (SQObjectPtr *)(nc + 1); + nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1); nc->_defaultparams = &nc->_outervalues[func->_noutervalues]; nc->_root = root; __ObjaddRef(nc->_root); - _CONSTRUCT_VECTOR(SQObjectPtr,func->_noutervalues,nc->_outervalues); - _CONSTRUCT_VECTOR(SQObjectPtr,func->_ndefaultparams,nc->_defaultparams); + _CONSTRUCT_VECTOR(rabbit::ObjectPtr,func->_noutervalues,nc->_outervalues); + _CONSTRUCT_VECTOR(rabbit::ObjectPtr,func->_ndefaultparams,nc->_defaultparams); return nc; } void release(){ SQFunctionProto *f = _function; int64_t size = _CALC_CLOSURE_SIZE(f); - _DESTRUCT_VECTOR(SQObjectPtr,f->_noutervalues,_outervalues); - _DESTRUCT_VECTOR(SQObjectPtr,f->_ndefaultparams,_defaultparams); + _DESTRUCT_VECTOR(rabbit::ObjectPtr,f->_noutervalues,_outervalues); + _DESTRUCT_VECTOR(rabbit::ObjectPtr,f->_ndefaultparams,_defaultparams); __Objrelease(_function); this->~SQClosure(); sq_vm_free(this,size); @@ -60,14 +60,14 @@ public: } ~SQClosure(); - bool save(rabbit::VirtualMachine *v,SQUserPointer up,SQWRITEFUNC write); - static bool load(rabbit::VirtualMachine *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret); + bool save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write); + static bool load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &ret); rabbit::WeakRef *_env; rabbit::WeakRef *_root; SQClass *_base; SQFunctionProto *_function; - SQObjectPtr *_outervalues; - SQObjectPtr *_defaultparams; + rabbit::ObjectPtr *_outervalues; + rabbit::ObjectPtr *_defaultparams; }; ////////////////////////////////////////////// @@ -75,13 +75,13 @@ struct SQOuter : public rabbit::RefCounted { private: - SQOuter(SQSharedState *ss, SQObjectPtr *outer){ + SQOuter(SQSharedState *ss, rabbit::ObjectPtr *outer){ _valptr = outer; _next = NULL; } public: - static SQOuter *create(SQSharedState *ss, SQObjectPtr *outer) + static SQOuter *create(SQSharedState *ss, rabbit::ObjectPtr *outer) { SQOuter *nc = (SQOuter*)SQ_MALLOC(sizeof(SQOuter)); new (nc) SQOuter(ss, outer); @@ -97,9 +97,9 @@ public: sq_vm_free(this,sizeof(SQOuter)); } - SQObjectPtr *_valptr; /* pointer to value on stack, or _value below */ + rabbit::ObjectPtr *_valptr; /* pointer to value on stack, or _value below */ int64_t _idx; /* idx in stack array, for relocation */ - SQObjectPtr _value; /* value of outer after stack frame is closed */ + rabbit::ObjectPtr _value; /* value of outer after stack frame is closed */ SQOuter *_next; /* pointer to next outer when frame is open */ }; @@ -132,15 +132,15 @@ public: } bool yield(rabbit::VirtualMachine *v,int64_t target); - bool resume(rabbit::VirtualMachine *v,SQObjectPtr &dest); - SQObjectPtr _closure; - SQObjectPtrVec _stack; + bool resume(rabbit::VirtualMachine *v,rabbit::ObjectPtr &dest); + rabbit::ObjectPtr _closure; + etk::Vector _stack; rabbit::VirtualMachine::callInfo _ci; - etk::Vector _etraps; + etk::Vector _etraps; SQGeneratorState _state; }; -#define _CALC_NATVIVECLOSURE_SIZE(noutervalues) (sizeof(SQNativeClosure) + (noutervalues*sizeof(SQObjectPtr))) +#define _CALC_NATVIVECLOSURE_SIZE(noutervalues) (sizeof(SQNativeClosure) + (noutervalues*sizeof(rabbit::ObjectPtr))) struct SQNativeClosure : public rabbit::RefCounted { @@ -155,9 +155,9 @@ public: int64_t size = _CALC_NATVIVECLOSURE_SIZE(nouters); SQNativeClosure *nc=(SQNativeClosure*)SQ_MALLOC(size); new (nc) SQNativeClosure(ss,func); - nc->_outervalues = (SQObjectPtr *)(nc + 1); + nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1); nc->_noutervalues = nouters; - _CONSTRUCT_VECTOR(SQObjectPtr,nc->_noutervalues,nc->_outervalues); + _CONSTRUCT_VECTOR(rabbit::ObjectPtr,nc->_noutervalues,nc->_outervalues); return nc; } SQNativeClosure *clone() @@ -177,18 +177,18 @@ public: } void release(){ int64_t size = _CALC_NATVIVECLOSURE_SIZE(_noutervalues); - _DESTRUCT_VECTOR(SQObjectPtr,_noutervalues,_outervalues); + _DESTRUCT_VECTOR(rabbit::ObjectPtr,_noutervalues,_outervalues); this->~SQNativeClosure(); sq_free(this,size); } int64_t _nparamscheck; - SQIntVec _typecheck; - SQObjectPtr *_outervalues; + etk::Vector _typecheck; + rabbit::ObjectPtr *_outervalues; uint64_t _noutervalues; rabbit::WeakRef *_env; SQFUNCTION _function; - SQObjectPtr _name; + rabbit::ObjectPtr _name; }; diff --git a/rabbit/sqcompiler.cpp b/rabbit/sqcompiler.cpp index 94ef956..8288adf 100644 --- a/rabbit/sqcompiler.cpp +++ b/rabbit/sqcompiler.cpp @@ -76,21 +76,21 @@ struct SQScope { class SQcompiler { public: - SQcompiler(rabbit::VirtualMachine *v, SQLEXREADFUNC rg, SQUserPointer up, const SQChar* sourcename, bool raiseerror, bool lineinfo) + SQcompiler(rabbit::VirtualMachine *v, SQLEXREADFUNC rg, rabbit::UserPointer up, const rabbit::Char* sourcename, bool raiseerror, bool lineinfo) { _vm=v; - _lex.init(_ss(v), rg, up,Throwerror,this); - _sourcename = SQString::create(_ss(v), sourcename); + _lex.init(_get_shared_state(v), rg, up,Throwerror,this); + _sourcename = SQString::create(_get_shared_state(v), sourcename); _lineinfo = lineinfo;_raiseerror = raiseerror; _scope.outers = 0; _scope.stacksize = 0; _compilererror[0] = _SC('\0'); } - static void Throwerror(void *ud, const SQChar *s) { + static void Throwerror(void *ud, const rabbit::Char *s) { SQcompiler *c = (SQcompiler *)ud; c->error(s); } - void error(const SQChar *s, ...) + void error(const rabbit::Char *s, ...) { va_list vl; va_start(vl, s); @@ -99,7 +99,7 @@ public: longjmp(_errorjmp,1); } void Lex(){ _token = _lex.Lex();} - SQObject Expect(int64_t tok) + rabbit::Object Expect(int64_t tok) { if(_token != tok) { @@ -107,7 +107,7 @@ public: //do nothing } else { - const SQChar *etypename; + const rabbit::Char *etypename; if(tok > 255) { switch(tok) { @@ -131,7 +131,7 @@ public: error(_SC("expected '%c'"), tok); } } - SQObjectPtr ret; + rabbit::ObjectPtr ret; switch(tok) { case TK_IDENTIFIER: @@ -141,10 +141,10 @@ public: ret = _fs->createString(_lex._svalue,_lex._longstr.size()-1); break; case TK_INTEGER: - ret = SQObjectPtr(_lex._nvalue); + ret = rabbit::ObjectPtr(_lex._nvalue); break; case TK_FLOAT: - ret = SQObjectPtr(_lex._fvalue); + ret = rabbit::ObjectPtr(_lex._fvalue); break; } Lex(); @@ -165,13 +165,13 @@ public: _fs->addInstruction(_OP_MOVE, _fs->pushTarget(), trg); } } - bool compile(SQObjectPtr &o) + bool compile(rabbit::ObjectPtr &o) { _debugline = 1; _debugop = 0; - SQFuncState funcstate(_ss(_vm), NULL,Throwerror,this); - funcstate._name = SQString::create(_ss(_vm), _SC("main")); + SQFuncState funcstate(_get_shared_state(_vm), NULL,Throwerror,this); + funcstate._name = SQString::create(_get_shared_state(_vm), _SC("main")); _fs = &funcstate; _fs->addParameter(_fs->createString(_SC("this"))); _fs->addParameter(_fs->createString(_SC("vargv"))); @@ -194,11 +194,11 @@ public: #endif } else { - if(_raiseerror && _ss(_vm)->_compilererrorhandler) { - _ss(_vm)->_compilererrorhandler(_vm, _compilererror, sq_type(_sourcename) == OT_STRING?_stringval(_sourcename):_SC("unknown"), + if(_raiseerror && _get_shared_state(_vm)->_compilererrorhandler) { + _get_shared_state(_vm)->_compilererrorhandler(_vm, _compilererror, sq_type(_sourcename) == rabbit::OT_STRING?_stringval(_sourcename):_SC("unknown"), _lex._currentline, _lex._currentcolumn); } - _vm->_lasterror = SQString::create(_ss(_vm), _compilererror, -1); + _vm->_lasterror = SQString::create(_get_shared_state(_vm), _compilererror, -1); return false; } return true; @@ -301,13 +301,13 @@ public: case TK_CONST: { Lex(); - SQObject id = Expect(TK_IDENTIFIER); + rabbit::Object id = Expect(TK_IDENTIFIER); Expect('='); - SQObject val = ExpectScalar(); + rabbit::Object val = ExpectScalar(); OptionalSemicolon(); - SQTable *enums = _table(_ss(_vm)->_consts); - SQObjectPtr strongid = id; - enums->newSlot(strongid,SQObjectPtr(val)); + SQTable *enums = _table(_get_shared_state(_vm)->_consts); + rabbit::ObjectPtr strongid = id; + enums->newSlot(strongid,rabbit::ObjectPtr(val)); strongid.Null(); } break; @@ -734,8 +734,8 @@ public: case TK_IDENTIFIER: case TK_CONSTRUCTOR: case TK_THIS:{ - SQObject id; - SQObject constant; + rabbit::Object id; + rabbit::Object constant; switch(_token) { case TK_IDENTIFIER: id = _fs->createString(_lex._svalue); break; @@ -767,9 +767,9 @@ public: else if(_fs->isConstant(id, constant)) { /* Handle named constant */ - SQObjectPtr constval; - SQObject constid; - if(sq_type(constant) == OT_TABLE) { + rabbit::ObjectPtr constval; + rabbit::Object constid; + if(sq_type(constant) == rabbit::OT_TABLE) { Expect('.'); constid = Expect(TK_IDENTIFIER); if(!_table(constant)->get(constid, constval)) { @@ -783,11 +783,11 @@ public: _es.epos = _fs->pushTarget(); /* generate direct or literal function depending on size */ - SQObjectType ctype = sq_type(constval); + rabbit::ObjectType ctype = sq_type(constval); switch(ctype) { - case OT_INTEGER: EmitloadConstInt(_integer(constval),_es.epos); break; - case OT_FLOAT: EmitloadConstFloat(_float(constval),_es.epos); break; - case OT_BOOL: _fs->addInstruction(_OP_LOADBOOL, _es.epos, _integer(constval)); break; + case rabbit::OT_INTEGER: EmitloadConstInt(_integer(constval),_es.epos); break; + case rabbit::OT_FLOAT: EmitloadConstFloat(_float(constval),_es.epos); break; + case rabbit::OT_BOOL: _fs->addInstruction(_OP_LOADBOOL, _es.epos, _integer(constval)); break; default: _fs->addInstruction(_OP_LOAD,_es.epos,_fs->getConstant(constval)); break; } _es.etype = EXPR; @@ -968,7 +968,7 @@ public: case TK_CONSTRUCTOR:{ int64_t tk = _token; Lex(); - SQObject id = tk == TK_FUNCTION ? Expect(TK_IDENTIFIER) : _fs->createString(_SC("constructor")); + rabbit::Object id = tk == TK_FUNCTION ? Expect(TK_IDENTIFIER) : _fs->createString(_SC("constructor")); Expect(_SC('(')); _fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(id)); createFunction(id); @@ -1011,7 +1011,7 @@ public: } void LocalDeclStatement() { - SQObject varname; + rabbit::Object varname; Lex(); if( _token == TK_FUNCTION) { Lex(); @@ -1182,7 +1182,7 @@ public: } void ForEachStatement() { - SQObject idxname, valname; + rabbit::Object idxname, valname; Lex(); Expect(_SC('(')); valname = Expect(TK_IDENTIFIER); if(_token == _SC(',')) { idxname = valname; @@ -1278,7 +1278,7 @@ public: } void FunctionStatement() { - SQObject id; + rabbit::Object id; Lex(); id = Expect(TK_IDENTIFIER); _fs->pushTarget(0); _fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(id)); @@ -1316,17 +1316,17 @@ public: } _es = es; } - SQObject ExpectScalar() + rabbit::Object ExpectScalar() { - SQObject val; - val._type = OT_NULL; val._unVal.nInteger = 0; //shut up GCC 4.x + rabbit::Object val; + val._type = rabbit::OT_NULL; val._unVal.nInteger = 0; //shut up GCC 4.x switch(_token) { case TK_INTEGER: - val._type = OT_INTEGER; + val._type = rabbit::OT_INTEGER; val._unVal.nInteger = _lex._nvalue; break; case TK_FLOAT: - val._type = OT_FLOAT; + val._type = rabbit::OT_FLOAT; val._unVal.fFloat = _lex._fvalue; break; case TK_STRING_LITERAL: @@ -1334,7 +1334,7 @@ public: break; case TK_TRUE: case TK_FALSE: - val._type = OT_BOOL; + val._type = rabbit::OT_BOOL; val._unVal.nInteger = _token == TK_TRUE ? 1 : 0; break; case '-': @@ -1342,11 +1342,11 @@ public: switch(_token) { case TK_INTEGER: - val._type = OT_INTEGER; + val._type = rabbit::OT_INTEGER; val._unVal.nInteger = -_lex._nvalue; break; case TK_FLOAT: - val._type = OT_FLOAT; + val._type = rabbit::OT_FLOAT; val._unVal.fFloat = -_lex._fvalue; break; default: @@ -1362,34 +1362,34 @@ public: void EnumStatement() { Lex(); - SQObject id = Expect(TK_IDENTIFIER); + rabbit::Object id = Expect(TK_IDENTIFIER); Expect(_SC('{')); - SQObject table = _fs->createTable(); + rabbit::Object table = _fs->createTable(); int64_t nval = 0; while(_token != _SC('}')) { - SQObject key = Expect(TK_IDENTIFIER); - SQObject val; + rabbit::Object key = Expect(TK_IDENTIFIER); + rabbit::Object val; if(_token == _SC('=')) { Lex(); val = ExpectScalar(); } else { - val._type = OT_INTEGER; + val._type = rabbit::OT_INTEGER; val._unVal.nInteger = nval++; } - _table(table)->newSlot(SQObjectPtr(key),SQObjectPtr(val)); + _table(table)->newSlot(rabbit::ObjectPtr(key),rabbit::ObjectPtr(val)); if(_token == ',') Lex(); } - SQTable *enums = _table(_ss(_vm)->_consts); - SQObjectPtr strongid = id; - enums->newSlot(SQObjectPtr(strongid),SQObjectPtr(table)); + SQTable *enums = _table(_get_shared_state(_vm)->_consts); + rabbit::ObjectPtr strongid = id; + enums->newSlot(rabbit::ObjectPtr(strongid),rabbit::ObjectPtr(table)); strongid.Null(); Lex(); } void TryCatchStatement() { - SQObject exid; + rabbit::Object exid; Lex(); _fs->addInstruction(_OP_PUSHTRAP,0,0); _fs->_traps++; @@ -1421,7 +1421,7 @@ public: void FunctionExp(int64_t ftype,bool lambda = false) { Lex(); Expect(_SC('(')); - SQObjectPtr dummy; + rabbit::ObjectPtr dummy; createFunction(dummy,lambda); _fs->addInstruction(_OP_CLOSURE, _fs->pushTarget(), _fs->_functions.size() - 1, ftype == TK_FUNCTION?0:1); } @@ -1488,11 +1488,11 @@ public: } _es = es; } - void createFunction(SQObject &name,bool lambda = false) + void createFunction(rabbit::Object &name,bool lambda = false) { - SQFuncState *funcstate = _fs->pushChildState(_ss(_vm)); + SQFuncState *funcstate = _fs->pushChildState(_get_shared_state(_vm)); funcstate->_name = name; - SQObject paramname; + rabbit::Object paramname; funcstate->addParameter(_fs->createString(_SC("this"))); funcstate->_sourcename = _sourcename; int64_t defparams = 0; @@ -1569,7 +1569,7 @@ public: private: int64_t _token; SQFuncState *_fs; - SQObjectPtr _sourcename; + rabbit::ObjectPtr _sourcename; SQLexer _lex; bool _lineinfo; bool _raiseerror; @@ -1577,12 +1577,12 @@ private: int64_t _debugop; SQExpState _es; SQScope _scope; - SQChar _compilererror[MAX_COMPILER_ERROR_LEN]; + rabbit::Char _compilererror[MAX_COMPILER_ERROR_LEN]; jmp_buf _errorjmp; rabbit::VirtualMachine *_vm; }; -bool compile(rabbit::VirtualMachine *vm,SQLEXREADFUNC rg, SQUserPointer up, const SQChar *sourcename, SQObjectPtr &out, bool raiseerror, bool lineinfo) +bool compile(rabbit::VirtualMachine *vm,SQLEXREADFUNC rg, rabbit::UserPointer up, const rabbit::Char *sourcename, rabbit::ObjectPtr &out, bool raiseerror, bool lineinfo) { SQcompiler p(vm, rg, up, sourcename, raiseerror, lineinfo); return p.compile(out); diff --git a/rabbit/sqcompiler.hpp b/rabbit/sqcompiler.hpp index adfbb0f..91066ef 100644 --- a/rabbit/sqcompiler.hpp +++ b/rabbit/sqcompiler.hpp @@ -80,5 +80,5 @@ namespace rabbit { -typedef void(*compilererrorFunc)(void *ud, const SQChar *s); -bool compile(rabbit::VirtualMachine *vm, SQLEXREADFUNC rg, SQUserPointer up, const SQChar *sourcename, SQObjectPtr &out, bool raiseerror, bool lineinfo); +typedef void(*compilererrorFunc)(void *ud, const rabbit::Char *s); +bool compile(rabbit::VirtualMachine *vm, SQLEXREADFUNC rg, rabbit::UserPointer up, const rabbit::Char *sourcename, rabbit::ObjectPtr &out, bool raiseerror, bool lineinfo); diff --git a/rabbit/sqconfig.hpp b/rabbit/sqconfig.hpp index 46b1a7d..82beddb 100644 --- a/rabbit/sqconfig.hpp +++ b/rabbit/sqconfig.hpp @@ -31,96 +31,118 @@ typedef uint64_t SQRawObjectVal; //is 32 bits on 32 bits builds and 64 bits othe #define SQ_ALIGNMENT 8 #endif -typedef void* SQUserPointer; -typedef uint64_t SQBool; -typedef int64_t SQRESULT; +namespace rabbit { + using UserPointer = void*; + using Bool = uint64_t; + using Result = int64_t; + +} #ifdef SQUNICODE -#include -#include + #include + #include + namespace rabbit { + using Char = wchar_t; + } + #define scstrcmp wcscmp + #ifdef _WIN32 + #define scsprintf _snwprintf + #else + #define scsprintf swprintf + #endif + #define scstrlen wcslen + #define scstrtod wcstod + #ifdef _SQ64 + #define scstrtol wcstoll + #else + #define scstrtol wcstol + #endif + #define scstrtoul wcstoul + #define scvsprintf vswprintf + #define scstrstr wcsstr + #define scprintf wprintf - -typedef wchar_t SQChar; - - -#define scstrcmp wcscmp -#ifdef _WIN32 -#define scsprintf _snwprintf + #ifdef _WIN32 + #define WCHAR_SIZE 2 + #define WCHAR_SHIFT_MUL 1 + #define MAX_CHAR 0xFFFF + #else + #define WCHAR_SIZE 4 + #define WCHAR_SHIFT_MUL 2 + #define MAX_CHAR 0xFFFFFFFF + #endif + #define _SC(a) L##a + #define scisspace iswspace + #define scisdigit iswdigit + #define scisprint iswprint + #define scisxdigit iswxdigit + #define scisalpha iswalpha + #define sciscntrl iswcntrl + #define scisalnum iswalnum + #define sq_rsl(l) ((l)< #include -SQRESULT sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,SQFunctionInfo *fi) +rabbit::Result sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,rabbit::FunctionInfo *fi) { int64_t cssize = v->_callsstacksize; if (cssize > level) { @@ -22,8 +22,8 @@ SQRESULT sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,SQFunctionIn SQClosure *c = _closure(ci._closure); SQFunctionProto *proto = c->_function; fi->funcid = proto; - fi->name = sq_type(proto->_name) == OT_STRING?_stringval(proto->_name):_SC("unknown"); - fi->source = sq_type(proto->_sourcename) == OT_STRING?_stringval(proto->_sourcename):_SC("unknown"); + fi->name = sq_type(proto->_name) == rabbit::OT_STRING?_stringval(proto->_name):_SC("unknown"); + fi->source = sq_type(proto->_sourcename) == rabbit::OT_STRING?_stringval(proto->_sourcename):_SC("unknown"); fi->line = proto->_lineinfos[0]._line; return SQ_OK; } @@ -31,26 +31,26 @@ SQRESULT sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,SQFunctionIn return sq_throwerror(v,_SC("the object is not a closure")); } -SQRESULT sq_stackinfos(rabbit::VirtualMachine* v, int64_t level, SQStackInfos *si) +rabbit::Result sq_stackinfos(rabbit::VirtualMachine* v, int64_t level, rabbit::StackInfos *si) { int64_t cssize = v->_callsstacksize; if (cssize > level) { - memset(si, 0, sizeof(SQStackInfos)); + memset(si, 0, sizeof(rabbit::StackInfos)); rabbit::VirtualMachine::callInfo &ci = v->_callsstack[cssize-level-1]; switch (sq_type(ci._closure)) { - case OT_CLOSURE:{ + case rabbit::OT_CLOSURE:{ SQFunctionProto *func = _closure(ci._closure)->_function; - if (sq_type(func->_name) == OT_STRING) + if (sq_type(func->_name) == rabbit::OT_STRING) si->funcname = _stringval(func->_name); - if (sq_type(func->_sourcename) == OT_STRING) + if (sq_type(func->_sourcename) == rabbit::OT_STRING) si->source = _stringval(func->_sourcename); si->line = func->getLine(ci._ip); } break; - case OT_NATIVECLOSURE: + case rabbit::OT_NATIVECLOSURE: si->source = _SC("NATIVE"); si->funcname = _SC("unknown"); - if(sq_type(_nativeclosure(ci._closure)->_name) == OT_STRING) + if(sq_type(_nativeclosure(ci._closure)->_name) == rabbit::OT_STRING) si->funcname = _stringval(_nativeclosure(ci._closure)->_name); si->line = -1; break; @@ -61,63 +61,63 @@ SQRESULT sq_stackinfos(rabbit::VirtualMachine* v, int64_t level, SQStackInfos *s return SQ_ERROR; } -void rabbit::VirtualMachine::raise_error(const SQChar *s, ...) +void rabbit::VirtualMachine::raise_error(const rabbit::Char *s, ...) { va_list vl; va_start(vl, s); int64_t buffersize = (int64_t)scstrlen(s)+(NUMBER_MAX_CHAR*2); scvsprintf(_sp(sq_rsl(buffersize)),buffersize, s, vl); va_end(vl); - _lasterror = SQString::create(_ss(this),_spval,-1); + _lasterror = SQString::create(_get_shared_state(this),_spval,-1); } -void rabbit::VirtualMachine::raise_error(const SQObjectPtr &desc) +void rabbit::VirtualMachine::raise_error(const rabbit::ObjectPtr &desc) { _lasterror = desc; } -SQString *rabbit::VirtualMachine::printObjVal(const SQObjectPtr &o) +SQString *rabbit::VirtualMachine::printObjVal(const rabbit::ObjectPtr &o) { switch(sq_type(o)) { - case OT_STRING: return _string(o); - case OT_INTEGER: + case rabbit::OT_STRING: return _string(o); + case rabbit::OT_INTEGER: scsprintf(_sp(sq_rsl(NUMBER_MAX_CHAR+1)),sq_rsl(NUMBER_MAX_CHAR), _PRINT_INT_FMT, _integer(o)); - return SQString::create(_ss(this), _spval); + return SQString::create(_get_shared_state(this), _spval); break; - case OT_FLOAT: + case rabbit::OT_FLOAT: scsprintf(_sp(sq_rsl(NUMBER_MAX_CHAR+1)), sq_rsl(NUMBER_MAX_CHAR), _SC("%.14g"), _float(o)); - return SQString::create(_ss(this), _spval); + return SQString::create(_get_shared_state(this), _spval); break; default: - return SQString::create(_ss(this), getTypeName(o)); + return SQString::create(_get_shared_state(this), getTypeName(o)); } } -void rabbit::VirtualMachine::raise_Idxerror(const SQObjectPtr &o) +void rabbit::VirtualMachine::raise_Idxerror(const rabbit::ObjectPtr &o) { - SQObjectPtr oval = printObjVal(o); + rabbit::ObjectPtr oval = printObjVal(o); raise_error(_SC("the index '%.50s' does not exist"), _stringval(oval)); } -void rabbit::VirtualMachine::raise_Compareerror(const SQObject &o1, const SQObject &o2) +void rabbit::VirtualMachine::raise_Compareerror(const rabbit::Object &o1, const rabbit::Object &o2) { - SQObjectPtr oval1 = printObjVal(o1), oval2 = printObjVal(o2); + rabbit::ObjectPtr oval1 = printObjVal(o1), oval2 = printObjVal(o2); raise_error(_SC("comparison between '%.50s' and '%.50s'"), _stringval(oval1), _stringval(oval2)); } void rabbit::VirtualMachine::raise_ParamTypeerror(int64_t nparam,int64_t typemask,int64_t type) { - SQObjectPtr exptypes = SQString::create(_ss(this), _SC(""), -1); + rabbit::ObjectPtr exptypes = SQString::create(_get_shared_state(this), _SC(""), -1); int64_t found = 0; for(int64_t i=0; i<16; i++) { int64_t mask = ((int64_t)1) << i; if(typemask & (mask)) { - if(found>0) stringCat(exptypes,SQString::create(_ss(this), _SC("|"), -1), exptypes); + if(found>0) stringCat(exptypes,SQString::create(_get_shared_state(this), _SC("|"), -1), exptypes); found ++; - stringCat(exptypes,SQString::create(_ss(this), IdType2Name((SQObjectType)mask), -1), exptypes); + stringCat(exptypes,SQString::create(_get_shared_state(this), IdType2Name((rabbit::ObjectType)mask), -1), exptypes); } } - raise_error(_SC("parameter %d has an invalid type '%s' ; expected: '%s'"), nparam, IdType2Name((SQObjectType)type), _stringval(exptypes)); + raise_error(_SC("parameter %d has an invalid type '%s' ; expected: '%s'"), nparam, IdType2Name((rabbit::ObjectType)type), _stringval(exptypes)); } diff --git a/rabbit/sqfuncproto.hpp b/rabbit/sqfuncproto.hpp index 828687c..1b4af44 100644 --- a/rabbit/sqfuncproto.hpp +++ b/rabbit/sqfuncproto.hpp @@ -18,7 +18,7 @@ struct SQOuterVar { SQOuterVar(){} - SQOuterVar(const SQObjectPtr &name,const SQObjectPtr &src,SQOuterType t) + SQOuterVar(const rabbit::ObjectPtr &name,const rabbit::ObjectPtr &src,SQOuterType t) { _name = name; _src=src; @@ -31,8 +31,8 @@ struct SQOuterVar _name=ov._name; } SQOuterType _type; - SQObjectPtr _name; - SQObjectPtr _src; + rabbit::ObjectPtr _name; + rabbit::ObjectPtr _src; }; struct SQLocalVarInfo @@ -45,7 +45,7 @@ struct SQLocalVarInfo _end_op=lvi._end_op; _pos=lvi._pos; } - SQObjectPtr _name; + rabbit::ObjectPtr _name; uint64_t _start_op; uint64_t _end_op; uint64_t _pos; @@ -58,8 +58,8 @@ typedef etk::Vector SQLocalVarInfoVec; typedef etk::Vector SQLineInfoVec; #define _FUNC_SIZE(ni,nl,nparams,nfuncs,nouters,nlineinf,localinf,defparams) (sizeof(SQFunctionProto) \ - +((ni-1)*sizeof(SQInstruction))+(nl*sizeof(SQObjectPtr)) \ - +(nparams*sizeof(SQObjectPtr))+(nfuncs*sizeof(SQObjectPtr)) \ + +((ni-1)*sizeof(SQInstruction))+(nl*sizeof(rabbit::ObjectPtr)) \ + +(nparams*sizeof(rabbit::ObjectPtr))+(nfuncs*sizeof(rabbit::ObjectPtr)) \ +(nouters*sizeof(SQOuterVar))+(nlineinf*sizeof(SQLineInfo)) \ +(localinf*sizeof(SQLocalVarInfo))+(defparams*sizeof(int64_t))) @@ -81,11 +81,11 @@ public: f = (SQFunctionProto *)sq_vm_malloc(_FUNC_SIZE(ninstructions,nliterals,nparameters,nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams)); new (f) SQFunctionProto(ss); f->_ninstructions = ninstructions; - f->_literals = (SQObjectPtr*)&f->_instructions[ninstructions]; + f->_literals = (rabbit::ObjectPtr*)&f->_instructions[ninstructions]; f->_nliterals = nliterals; - f->_parameters = (SQObjectPtr*)&f->_literals[nliterals]; + f->_parameters = (rabbit::ObjectPtr*)&f->_literals[nliterals]; f->_nparameters = nparameters; - f->_functions = (SQObjectPtr*)&f->_parameters[nparameters]; + f->_functions = (rabbit::ObjectPtr*)&f->_parameters[nparameters]; f->_nfunctions = nfunctions; f->_outervalues = (SQOuterVar*)&f->_functions[nfunctions]; f->_noutervalues = noutervalues; @@ -96,18 +96,18 @@ public: f->_defaultparams = (int64_t *)&f->_localvarinfos[nlocalvarinfos]; f->_ndefaultparams = ndefaultparams; - _CONSTRUCT_VECTOR(SQObjectPtr,f->_nliterals,f->_literals); - _CONSTRUCT_VECTOR(SQObjectPtr,f->_nparameters,f->_parameters); - _CONSTRUCT_VECTOR(SQObjectPtr,f->_nfunctions,f->_functions); + _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(SQOuterVar,f->_noutervalues,f->_outervalues); //_CONSTRUCT_VECTOR(SQLineInfo,f->_nlineinfos,f->_lineinfos); //not required are 2 integers _CONSTRUCT_VECTOR(SQLocalVarInfo,f->_nlocalvarinfos,f->_localvarinfos); return f; } void release(){ - _DESTRUCT_VECTOR(SQObjectPtr,_nliterals,_literals); - _DESTRUCT_VECTOR(SQObjectPtr,_nparameters,_parameters); - _DESTRUCT_VECTOR(SQObjectPtr,_nfunctions,_functions); + _DESTRUCT_VECTOR(rabbit::ObjectPtr,_nliterals,_literals); + _DESTRUCT_VECTOR(rabbit::ObjectPtr,_nparameters,_parameters); + _DESTRUCT_VECTOR(rabbit::ObjectPtr,_nfunctions,_functions); _DESTRUCT_VECTOR(SQOuterVar,_noutervalues,_outervalues); //_DESTRUCT_VECTOR(SQLineInfo,_nlineinfos,_lineinfos); //not required are 2 integers _DESTRUCT_VECTOR(SQLocalVarInfo,_nlocalvarinfos,_localvarinfos); @@ -116,12 +116,12 @@ public: sq_vm_free(this,size); } - const SQChar* getLocal(rabbit::VirtualMachine *v,uint64_t stackbase,uint64_t nseq,uint64_t nop); + const rabbit::Char* getLocal(rabbit::VirtualMachine *v,uint64_t stackbase,uint64_t nseq,uint64_t nop); int64_t getLine(SQInstruction *curr); - bool save(rabbit::VirtualMachine *v,SQUserPointer up,SQWRITEFUNC write); - static bool load(rabbit::VirtualMachine *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret); - SQObjectPtr _sourcename; - SQObjectPtr _name; + bool save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write); + static bool load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &ret); + rabbit::ObjectPtr _sourcename; + rabbit::ObjectPtr _name; int64_t _stacksize; bool _bgenerator; int64_t _varparams; @@ -133,13 +133,13 @@ public: SQLineInfo *_lineinfos; int64_t _nliterals; - SQObjectPtr *_literals; + rabbit::ObjectPtr *_literals; int64_t _nparameters; - SQObjectPtr *_parameters; + rabbit::ObjectPtr *_parameters; int64_t _nfunctions; - SQObjectPtr *_functions; + rabbit::ObjectPtr *_functions; int64_t _noutervalues; SQOuterVar *_outervalues; diff --git a/rabbit/sqfuncstate.cpp b/rabbit/sqfuncstate.cpp index b7a9ac6..037a073 100644 --- a/rabbit/sqfuncstate.cpp +++ b/rabbit/sqfuncstate.cpp @@ -80,13 +80,13 @@ SQInstructionDesc g_InstrDesc[]={ {_SC("_OP_CLOSE")}, }; #endif -void dumpLiteral(SQObjectPtr &o) +void dumpLiteral(rabbit::ObjectPtr &o) { switch(sq_type(o)){ - case OT_STRING: scprintf(_SC("\"%s\""),_stringval(o));break; - case OT_FLOAT: scprintf(_SC("{%f}"),_float(o));break; - case OT_INTEGER: scprintf(_SC("{") _PRINT_INT_FMT _SC("}"),_integer(o));break; - case OT_BOOL: scprintf(_SC("%s"),_integer(o)?_SC("true"):_SC("false"));break; + case rabbit::OT_STRING: scprintf(_SC("\"%s\""),_stringval(o));break; + case rabbit::OT_FLOAT: scprintf(_SC("{%f}"),_float(o));break; + case rabbit::OT_INTEGER: scprintf(_SC("{") _PRINT_INT_FMT _SC("}"),_integer(o));break; + case rabbit::OT_BOOL: scprintf(_SC("%s"),_integer(o)?_SC("true"):_SC("false"));break; default: scprintf(_SC("(%s %p)"),getTypeName(o),(void*)_rawval(o));break; break; //shut up compiler } } @@ -112,7 +112,7 @@ SQFuncState::SQFuncState(SQSharedState *ss,SQFuncState *parent,compilererrorFunc } -void SQFuncState::error(const SQChar *err) +void SQFuncState::error(const rabbit::Char *err) { _errfunc(_errtarget,err); } @@ -123,13 +123,13 @@ void SQFuncState::dump(SQFunctionProto *func) uint64_t n=0,i; int64_t si; scprintf(_SC("SQInstruction sizeof %d\n"),(int32_t)sizeof(SQInstruction)); - scprintf(_SC("SQObject sizeof %d\n"), (int32_t)sizeof(SQObject)); + scprintf(_SC("rabbit::Object sizeof %d\n"), (int32_t)sizeof(rabbit::Object)); scprintf(_SC("--------------------------------------------------------------------\n")); - scprintf(_SC("*****FUNCTION [%s]\n"),sq_type(func->_name)==OT_STRING?_stringval(func->_name):_SC("unknown")); + scprintf(_SC("*****FUNCTION [%s]\n"),sq_type(func->_name)==rabbit::OT_STRING?_stringval(func->_name):_SC("unknown")); scprintf(_SC("-----LITERALS\n")); - SQObjectPtr refidx,key,val; + rabbit::ObjectPtr refidx,key,val; int64_t idx; - SQObjectPtrVec templiterals; + etk::Vector templiterals; templiterals.resize(_nliterals); while((idx=_table(_literals)->next(false,refidx,key,val))!=-1) { refidx=idx; @@ -175,7 +175,7 @@ void SQFuncState::dump(SQFunctionProto *func) scprintf(_SC("null")); else { int64_t refidx; - SQObjectPtr val,key,refo; + rabbit::ObjectPtr val,key,refo; while(((refidx=_table(_literals)->next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) { refo = refidx; } @@ -191,7 +191,7 @@ void SQFuncState::dump(SQFunctionProto *func) scprintf(_SC("null")); else { int64_t refidx; - SQObjectPtr val,key,refo; + rabbit::ObjectPtr val,key,refo; while(((refidx=_table(_literals)->next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) { refo = refidx; } @@ -219,17 +219,17 @@ void SQFuncState::dump(SQFunctionProto *func) int64_t SQFuncState::getNumericConstant(const int64_t cons) { - return getConstant(SQObjectPtr(cons)); + return getConstant(rabbit::ObjectPtr(cons)); } int64_t SQFuncState::getNumericConstant(const float_t cons) { - return getConstant(SQObjectPtr(cons)); + return getConstant(rabbit::ObjectPtr(cons)); } -int64_t SQFuncState::getConstant(const SQObject &cons) +int64_t SQFuncState::getConstant(const rabbit::Object &cons) { - SQObjectPtr val; + rabbit::ObjectPtr val; if(!_table(_literals)->get(cons,val)) { val = _nliterals; @@ -295,7 +295,7 @@ int64_t SQFuncState::popTarget() uint64_t npos=_targetstack.back(); assert(npos < _vlocals.size()); SQLocalVarInfo &t = _vlocals[npos]; - if(sq_type(t._name)==OT_NULL){ + if(sq_type(t._name)==rabbit::OT_NULL){ _vlocals.popBack(); } _targetstack.popBack(); @@ -327,7 +327,7 @@ void SQFuncState::setStacksize(int64_t n) while(size>n){ size--; SQLocalVarInfo lvi = _vlocals.back(); - if(sq_type(lvi._name)!=OT_NULL){ + if(sq_type(lvi._name)!=rabbit::OT_NULL){ if(lvi._end_op == UINT_MINUS_ONE) { //this means is an outer _outers--; } @@ -338,9 +338,9 @@ void SQFuncState::setStacksize(int64_t n) } } -bool SQFuncState::isConstant(const SQObject &name,SQObject &e) +bool SQFuncState::isConstant(const rabbit::Object &name,rabbit::Object &e) { - SQObjectPtr val; + rabbit::ObjectPtr val; if(_table(_sharedstate->_consts)->get(name,val)) { e = val; return true; @@ -351,11 +351,11 @@ bool SQFuncState::isConstant(const SQObject &name,SQObject &e) bool SQFuncState::isLocal(uint64_t stkpos) { if(stkpos>=_vlocals.size())return false; - else if(sq_type(_vlocals[stkpos]._name)!=OT_NULL)return true; + else if(sq_type(_vlocals[stkpos]._name)!=rabbit::OT_NULL)return true; return false; } -int64_t SQFuncState::pushLocalVariable(const SQObject &name) +int64_t SQFuncState::pushLocalVariable(const rabbit::Object &name) { int64_t pos=_vlocals.size(); SQLocalVarInfo lvi; @@ -369,12 +369,12 @@ int64_t SQFuncState::pushLocalVariable(const SQObject &name) -int64_t SQFuncState::getLocalVariable(const SQObject &name) +int64_t SQFuncState::getLocalVariable(const rabbit::Object &name) { int64_t locals=_vlocals.size(); while(locals>=1){ SQLocalVarInfo &lvi = _vlocals[locals-1]; - if(sq_type(lvi._name)==OT_STRING && _string(lvi._name)==_string(name)){ + if(sq_type(lvi._name)==rabbit::OT_STRING && _string(lvi._name)==_string(name)){ return locals-1; } locals--; @@ -389,7 +389,7 @@ void SQFuncState::markLocalAsOuter(int64_t pos) _outers++; } -int64_t SQFuncState::getOuterVariable(const SQObject &name) +int64_t SQFuncState::getOuterVariable(const rabbit::Object &name) { int64_t outers = _outervalues.size(); for(int64_t i = 0; igetOuterVariable(name); if(pos != -1) { - _outervalues.pushBack(SQOuterVar(name,SQObjectPtr(int64_t(pos)),otOUTER)); //local + _outervalues.pushBack(SQOuterVar(name,rabbit::ObjectPtr(int64_t(pos)),otOUTER)); //local return _outervalues.size() - 1; } } else { _parent->markLocalAsOuter(pos); - _outervalues.pushBack(SQOuterVar(name,SQObjectPtr(int64_t(pos)),otLOCAL)); //local + _outervalues.pushBack(SQOuterVar(name,rabbit::ObjectPtr(int64_t(pos)),otLOCAL)); //local return _outervalues.size() - 1; @@ -417,7 +417,7 @@ int64_t SQFuncState::getOuterVariable(const SQObject &name) return -1; } -void SQFuncState::addParameter(const SQObject &name) +void SQFuncState::addParameter(const rabbit::Object &name) { pushLocalVariable(name); _parameters.pushBack(name); @@ -584,16 +584,16 @@ void SQFuncState::addInstruction(SQInstruction &i) _instructions.pushBack(i); } -SQObject SQFuncState::createString(const SQChar *s,int64_t len) +rabbit::Object SQFuncState::createString(const rabbit::Char *s,int64_t len) { - SQObjectPtr ns(SQString::create(_sharedstate,s,len)); + rabbit::ObjectPtr ns(SQString::create(_sharedstate,s,len)); _table(_strings)->newSlot(ns,(int64_t)1); return ns; } -SQObject SQFuncState::createTable() +rabbit::Object SQFuncState::createTable() { - SQObjectPtr nt(SQTable::create(_sharedstate,0)); + rabbit::ObjectPtr nt(SQTable::create(_sharedstate,0)); _table(_strings)->newSlot(nt,(int64_t)1); return nt; } @@ -605,7 +605,7 @@ SQFunctionProto *SQFuncState::buildProto() _nliterals,_parameters.size(),_functions.size(),_outervalues.size(), _lineinfos.size(),_localvarinfos.size(),_defaultparams.size()); - SQObjectPtr refidx,key,val; + rabbit::ObjectPtr refidx,key,val; int64_t idx; f->_stacksize = _stacksize; diff --git a/rabbit/sqfuncstate.hpp b/rabbit/sqfuncstate.hpp index 0f2136c..4c532fd 100644 --- a/rabbit/sqfuncstate.hpp +++ b/rabbit/sqfuncstate.hpp @@ -16,7 +16,7 @@ struct SQFuncState #ifdef _DEBUG_DUMP void dump(SQFunctionProto *func); #endif - void error(const SQChar *err); + void error(const rabbit::Char *err); SQFuncState *pushChildState(SQSharedState *ss); void popChildState(); void addInstruction(SQOpcode _op,int64_t arg0=0,int64_t arg1=0,int64_t arg2=0,int64_t arg3=0){SQInstruction i(_op,arg0,arg1,arg2,arg3);addInstruction(i);} @@ -33,12 +33,12 @@ struct SQFuncState int64_t getCurrentPos(){return _instructions.size()-1;} int64_t getNumericConstant(const int64_t cons); int64_t getNumericConstant(const float_t cons); - int64_t pushLocalVariable(const SQObject &name); - void addParameter(const SQObject &name); - //void addOuterValue(const SQObject &name); - int64_t getLocalVariable(const SQObject &name); + int64_t pushLocalVariable(const rabbit::Object &name); + void addParameter(const rabbit::Object &name); + //void addOuterValue(const rabbit::Object &name); + int64_t getLocalVariable(const rabbit::Object &name); void markLocalAsOuter(int64_t pos); - int64_t getOuterVariable(const SQObject &name); + int64_t getOuterVariable(const rabbit::Object &name); int64_t generateCode(); int64_t getStacksize(); int64_t calcStackFramesize(); @@ -51,40 +51,40 @@ struct SQFuncState int64_t getUpTarget(int64_t n); void discardTarget(); bool isLocal(uint64_t stkpos); - SQObject createString(const SQChar *s,int64_t len = -1); - SQObject createTable(); - bool isConstant(const SQObject &name,SQObject &e); + rabbit::Object createString(const rabbit::Char *s,int64_t len = -1); + rabbit::Object createTable(); + bool isConstant(const rabbit::Object &name,rabbit::Object &e); int64_t _returnexp; SQLocalVarInfoVec _vlocals; - SQIntVec _targetstack; + etk::Vector _targetstack; int64_t _stacksize; bool _varparams; bool _bgenerator; - SQIntVec _unresolvedbreaks; - SQIntVec _unresolvedcontinues; - SQObjectPtrVec _functions; - SQObjectPtrVec _parameters; + etk::Vector _unresolvedbreaks; + etk::Vector _unresolvedcontinues; + etk::Vector _functions; + etk::Vector _parameters; SQOuterVarVec _outervalues; SQInstructionVec _instructions; SQLocalVarInfoVec _localvarinfos; - SQObjectPtr _literals; - SQObjectPtr _strings; - SQObjectPtr _name; - SQObjectPtr _sourcename; + rabbit::ObjectPtr _literals; + rabbit::ObjectPtr _strings; + rabbit::ObjectPtr _name; + rabbit::ObjectPtr _sourcename; int64_t _nliterals; SQLineInfoVec _lineinfos; SQFuncState *_parent; - SQIntVec _scope_blocks; - SQIntVec _breaktargets; - SQIntVec _continuetargets; - SQIntVec _defaultparams; + etk::Vector _scope_blocks; + etk::Vector _breaktargets; + etk::Vector _continuetargets; + etk::Vector _defaultparams; int64_t _lastline; int64_t _traps; //contains number of nested exception traps int64_t _outers; bool _optimization; SQSharedState *_sharedstate; etk::Vector _childstates; - int64_t getConstant(const SQObject &cons); + int64_t getConstant(const rabbit::Object &cons); private: compilererrorFunc _errfunc; void *_errtarget; diff --git a/rabbit/sqlexer.cpp b/rabbit/sqlexer.cpp index e158c32..22e307d 100644 --- a/rabbit/sqlexer.cpp +++ b/rabbit/sqlexer.cpp @@ -29,7 +29,7 @@ SQLexer::~SQLexer() _keywords->release(); } -void SQLexer::init(SQSharedState *ss, SQLEXREADFUNC rg, SQUserPointer up,compilererrorFunc efunc,void *ed) +void SQLexer::init(SQSharedState *ss, SQLEXREADFUNC rg, rabbit::UserPointer up,compilererrorFunc efunc,void *ed) { _errfunc = efunc; _errtarget = ed; @@ -84,7 +84,7 @@ void SQLexer::init(SQSharedState *ss, SQLEXREADFUNC rg, SQUserPointer up,compile next(); } -void SQLexer::error(const SQChar *err) +void SQLexer::error(const rabbit::Char *err) { _errfunc(_errtarget,err); } @@ -101,9 +101,9 @@ void SQLexer::next() _reached_eof = SQTrue; } -const SQChar *SQLexer::tok2Str(int64_t tok) +const rabbit::Char *SQLexer::tok2Str(int64_t tok) { - SQObjectPtr itr, key, val; + rabbit::ObjectPtr itr, key, val; int64_t nitr; while((nitr = _keywords->next(false,itr, key, val)) != -1) { itr = (int64_t)nitr; @@ -285,9 +285,9 @@ int64_t SQLexer::Lex() return 0; } -int64_t SQLexer::getIDType(const SQChar *s,int64_t len) +int64_t SQLexer::getIDType(const rabbit::Char *s,int64_t len) { - SQObjectPtr t; + rabbit::ObjectPtr t; if(_keywords->getStr(s,len, t)) { return int64_t(_integer(t)); } @@ -301,12 +301,12 @@ int64_t SQLexer::addUTF16(uint64_t ch) if (ch >= 0x10000) { uint64_t code = (ch - 0x10000); - APPEND_CHAR((SQChar)(0xD800 | (code >> 10))); - APPEND_CHAR((SQChar)(0xDC00 | (code & 0x3FF))); + APPEND_CHAR((rabbit::Char)(0xD800 | (code >> 10))); + APPEND_CHAR((rabbit::Char)(0xDC00 | (code & 0x3FF))); return 2; } else { - APPEND_CHAR((SQChar)ch); + APPEND_CHAR((rabbit::Char)ch); return 1; } } @@ -319,28 +319,28 @@ int64_t SQLexer::addUTF8(uint64_t ch) return 1; } if (ch < 0x800) { - APPEND_CHAR((SQChar)((ch >> 6) | 0xC0)); - APPEND_CHAR((SQChar)((ch & 0x3F) | 0x80)); + APPEND_CHAR((rabbit::Char)((ch >> 6) | 0xC0)); + APPEND_CHAR((rabbit::Char)((ch & 0x3F) | 0x80)); return 2; } if (ch < 0x10000) { - APPEND_CHAR((SQChar)((ch >> 12) | 0xE0)); - APPEND_CHAR((SQChar)(((ch >> 6) & 0x3F) | 0x80)); - APPEND_CHAR((SQChar)((ch & 0x3F) | 0x80)); + APPEND_CHAR((rabbit::Char)((ch >> 12) | 0xE0)); + APPEND_CHAR((rabbit::Char)(((ch >> 6) & 0x3F) | 0x80)); + APPEND_CHAR((rabbit::Char)((ch & 0x3F) | 0x80)); return 3; } if (ch < 0x110000) { - APPEND_CHAR((SQChar)((ch >> 18) | 0xF0)); - APPEND_CHAR((SQChar)(((ch >> 12) & 0x3F) | 0x80)); - APPEND_CHAR((SQChar)(((ch >> 6) & 0x3F) | 0x80)); - APPEND_CHAR((SQChar)((ch & 0x3F) | 0x80)); + APPEND_CHAR((rabbit::Char)((ch >> 18) | 0xF0)); + APPEND_CHAR((rabbit::Char)(((ch >> 12) & 0x3F) | 0x80)); + APPEND_CHAR((rabbit::Char)(((ch >> 6) & 0x3F) | 0x80)); + APPEND_CHAR((rabbit::Char)((ch & 0x3F) | 0x80)); return 4; } return 0; } #endif -int64_t SQLexer::processStringHexEscape(SQChar *dest, int64_t maxdigits) +int64_t SQLexer::processStringHexEscape(rabbit::Char *dest, int64_t maxdigits) { NEXT(); if (!isxdigit(CUR_CHAR)) error(_SC("hexadecimal number expected")); @@ -379,24 +379,24 @@ int64_t SQLexer::readString(int64_t ndelim,bool verbatim) NEXT(); switch(CUR_CHAR) { case _SC('x'): { - const int64_t maxdigits = sizeof(SQChar) * 2; - SQChar temp[maxdigits + 1]; + const int64_t maxdigits = sizeof(rabbit::Char) * 2; + rabbit::Char temp[maxdigits + 1]; processStringHexEscape(temp, maxdigits); - SQChar *stemp; - APPEND_CHAR((SQChar)scstrtoul(temp, &stemp, 16)); + rabbit::Char *stemp; + APPEND_CHAR((rabbit::Char)scstrtoul(temp, &stemp, 16)); } break; case _SC('U'): case _SC('u'): { const int64_t maxdigits = CUR_CHAR == 'u' ? 4 : 8; - SQChar temp[8 + 1]; + rabbit::Char temp[8 + 1]; processStringHexEscape(temp, maxdigits); - SQChar *stemp; + rabbit::Char *stemp; #ifdef SQUNICODE #if WCHAR_SIZE == 2 addUTF16(scstrtoul(temp, &stemp, 16)); #else - APPEND_CHAR((SQChar)scstrtoul(temp, &stemp, 16)); + APPEND_CHAR((rabbit::Char)scstrtoul(temp, &stemp, 16)); #endif #else addUTF8(scstrtoul(temp, &stemp, 16)); @@ -446,7 +446,7 @@ int64_t SQLexer::readString(int64_t ndelim,bool verbatim) return TK_STRING_LITERAL; } -void LexHexadecimal(const SQChar *s,uint64_t *res) +void LexHexadecimal(const rabbit::Char *s,uint64_t *res) { *res = 0; while(*s != 0) @@ -457,7 +457,7 @@ void LexHexadecimal(const SQChar *s,uint64_t *res) } } -void LexInteger(const SQChar *s,uint64_t *res) +void LexInteger(const rabbit::Char *s,uint64_t *res) { *res = 0; while(*s != 0) @@ -468,7 +468,7 @@ void LexInteger(const SQChar *s,uint64_t *res) int64_t scisodigit(int64_t c) { return c >= _SC('0') && c <= _SC('7'); } -void LexOctal(const SQChar *s,uint64_t *res) +void LexOctal(const rabbit::Char *s,uint64_t *res) { *res = 0; while(*s != 0) @@ -490,7 +490,7 @@ int64_t SQLexer::readNumber() #define TSCIENTIFIC 4 #define TOCTAL 5 int64_t type = TINT, firstchar = CUR_CHAR; - SQChar *sTemp; + rabbit::Char *sTemp; INIT_TEMP_STRING(); NEXT(); if(firstchar == _SC('0') && (toupper(CUR_CHAR) == _SC('X') || scisodigit(CUR_CHAR)) ) { diff --git a/rabbit/sqlexer.hpp b/rabbit/sqlexer.hpp index 1936aad..0a31f24 100644 --- a/rabbit/sqlexer.hpp +++ b/rabbit/sqlexer.hpp @@ -8,7 +8,7 @@ #pragma once #ifdef SQUNICODE -typedef SQChar LexChar; +typedef rabbit::Char LexChar; #else typedef unsigned char LexChar; #endif @@ -17,12 +17,12 @@ struct SQLexer { SQLexer(); ~SQLexer(); - void init(SQSharedState *ss,SQLEXREADFUNC rg,SQUserPointer up,compilererrorFunc efunc,void *ed); - void error(const SQChar *err); + void init(SQSharedState *ss,SQLEXREADFUNC rg,rabbit::UserPointer up,compilererrorFunc efunc,void *ed); + void error(const rabbit::Char *err); int64_t Lex(); - const SQChar *tok2Str(int64_t tok); + const rabbit::Char *tok2Str(int64_t tok); private: - int64_t getIDType(const SQChar *s,int64_t len); + int64_t getIDType(const rabbit::Char *s,int64_t len); int64_t readString(int64_t ndelim,bool verbatim); int64_t readNumber(); void lexBlockComment(); @@ -36,23 +36,23 @@ private: #else int64_t addUTF8(uint64_t ch); #endif - int64_t processStringHexEscape(SQChar *dest, int64_t maxdigits); + int64_t processStringHexEscape(rabbit::Char *dest, int64_t maxdigits); int64_t _curtoken; SQTable *_keywords; - SQBool _reached_eof; + rabbit::Bool _reached_eof; public: int64_t _prevtoken; int64_t _currentline; int64_t _lasttokenline; int64_t _currentcolumn; - const SQChar *_svalue; + const rabbit::Char *_svalue; int64_t _nvalue; float_t _fvalue; SQLEXREADFUNC _readf; - SQUserPointer _up; + rabbit::UserPointer _up; LexChar _currdata; SQSharedState *_sharedstate; - etk::Vector _longstr; + etk::Vector _longstr; compilererrorFunc _errfunc; void *_errtarget; }; diff --git a/rabbit/sqobject.cpp b/rabbit/sqobject.cpp index e930f3b..83201d0 100644 --- a/rabbit/sqobject.cpp +++ b/rabbit/sqobject.cpp @@ -15,42 +15,7 @@ #include #include - -const SQChar *IdType2Name(SQObjectType type) -{ - switch(_RAW_TYPE(type)) - { - case _RT_NULL:return _SC("null"); - case _RT_INTEGER:return _SC("integer"); - case _RT_FLOAT:return _SC("float"); - case _RT_BOOL:return _SC("bool"); - case _RT_STRING:return _SC("string"); - case _RT_TABLE:return _SC("table"); - case _RT_ARRAY:return _SC("array"); - case _RT_GENERATOR:return _SC("generator"); - case _RT_CLOSURE: - case _RT_NATIVECLOSURE: - return _SC("function"); - case _RT_USERDATA: - case _RT_USERPOINTER: - return _SC("userdata"); - case _RT_THREAD: return _SC("thread"); - case _RT_FUNCPROTO: return _SC("function"); - case _RT_CLASS: return _SC("class"); - case _RT_INSTANCE: return _SC("instance"); - case _RT_WEAKREF: return _SC("weakref"); - case _RT_OUTER: return _SC("outer"); - default: - return NULL; - } -} - -const SQChar *getTypeName(const SQObjectPtr &obj1) -{ - return IdType2Name(sq_type(obj1)); -} - -SQString *SQString::create(SQSharedState *ss,const SQChar *s,int64_t len) +SQString *SQString::create(SQSharedState *ss,const rabbit::Char *s,int64_t len) { SQString *str=ADD_STRING(ss,s,len); return str; @@ -61,7 +26,7 @@ void SQString::release() REMOVE_STRING(_sharedstate,this); } -int64_t SQString::next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval) +int64_t SQString::next(const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval) { int64_t idx = (int64_t)translateIndex(refpos); while(idx < _len){ @@ -74,40 +39,6 @@ int64_t SQString::next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectP return -1; } -uint64_t translateIndex(const SQObjectPtr &idx) -{ - switch(sq_type(idx)){ - case OT_NULL: - return 0; - case OT_INTEGER: - return (uint64_t)_integer(idx); - default: assert(0); break; - } - return 0; -} - - - -bool SQDelegable::getMetaMethod(rabbit::VirtualMachine *v,SQMetaMethod mm,SQObjectPtr &res) { - if(_delegate) { - return _delegate->get((*_ss(v)->_metamethods)[mm],res); - } - return false; -} - -bool SQDelegable::setDelegate(SQTable *mt) -{ - SQTable *temp = mt; - if(temp == this) return false; - while (temp) { - if (temp->_delegate == this) return false; //cycle detected - temp = temp->_delegate; - } - if (mt) __ObjaddRef(mt); - __Objrelease(_delegate); - _delegate = mt; - return true; -} bool SQGenerator::yield(rabbit::VirtualMachine *v,int64_t target) { @@ -116,8 +47,8 @@ bool SQGenerator::yield(rabbit::VirtualMachine *v,int64_t target) int64_t size = v->_top-v->_stackbase; _stack.resize(size); - SQObject _this = v->_stack[v->_stackbase]; - _stack[0] = ISREFCOUNTED(sq_type(_this)) ? SQObjectPtr(_refcounted(_this)->getWeakRef(sq_type(_this))) : _this; + rabbit::Object _this = v->_stack[v->_stackbase]; + _stack[0] = ISREFCOUNTED(sq_type(_this)) ? rabbit::ObjectPtr(_refcounted(_this)->getWeakRef(sq_type(_this))) : _this; for(int64_t n =1; n_stack[v->_stackbase+n]; } @@ -132,7 +63,7 @@ bool SQGenerator::yield(rabbit::VirtualMachine *v,int64_t target) _etraps.pushBack(v->_etraps.back()); v->_etraps.popBack(); // store relative stack base and size in case of resume to other _top - SQExceptionTrap &et = _etraps.back(); + rabbit::ExceptionTrap &et = _etraps.back(); et._stackbase -= v->_stackbase; et._stacksize -= v->_stackbase; } @@ -140,7 +71,7 @@ bool SQGenerator::yield(rabbit::VirtualMachine *v,int64_t target) return true; } -bool SQGenerator::resume(rabbit::VirtualMachine *v,SQObjectPtr &dest) +bool SQGenerator::resume(rabbit::VirtualMachine *v,rabbit::ObjectPtr &dest) { if(_state==eDead){ v->raise_error(_SC("resuming dead generator")); return false; } if(_state==eRunning){ v->raise_error(_SC("resuming active generator")); return false; } @@ -163,13 +94,13 @@ bool SQGenerator::resume(rabbit::VirtualMachine *v,SQObjectPtr &dest) for(int64_t i=0;i<_ci._etraps;i++) { v->_etraps.pushBack(_etraps.back()); _etraps.popBack(); - SQExceptionTrap &et = v->_etraps.back(); + rabbit::ExceptionTrap &et = v->_etraps.back(); // restore absolute stack base and size et._stackbase += newbase; et._stacksize += newbase; } - SQObject _this = _stack[0]; - v->_stack[v->_stackbase] = sq_type(_this) == OT_WEAKREF ? _weakref(_this)->_obj : _this; + rabbit::Object _this = _stack[0]; + v->_stack[v->_stackbase] = sq_type(_this) == rabbit::OT_WEAKREF ? _weakref(_this)->_obj : _this; for(int64_t n = 1; n_stack[v->_stackbase+n] = _stack[n]; @@ -190,10 +121,10 @@ void rabbit::Array::extend(const rabbit::Array *a){ append((*a)[i]); } -const SQChar* SQFunctionProto::getLocal(rabbit::VirtualMachine *vm,uint64_t stackbase,uint64_t nseq,uint64_t nop) +const rabbit::Char* SQFunctionProto::getLocal(rabbit::VirtualMachine *vm,uint64_t stackbase,uint64_t nseq,uint64_t nop) { uint64_t nvars=_nlocalvarinfos; - const SQChar *res=NULL; + const rabbit::Char *res=NULL; if(nvars>=nseq){ for(uint64_t i=0;i=nop) @@ -253,7 +184,7 @@ SQClosure::~SQClosure() } #define _CHECK_IO(exp) { if(!exp)return false; } -bool SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,SQUserPointer up,SQUserPointer dest,int64_t size) +bool SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size) { if(write(up,dest,size) != size) { v->raise_error(_SC("io error (write function failure)")); @@ -262,7 +193,7 @@ bool SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,SQUserPointer up,SQUs return true; } -bool SafeRead(rabbit::VirtualMachine* v,SQWRITEFUNC read,SQUserPointer up,SQUserPointer dest,int64_t size) +bool 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")); @@ -271,12 +202,12 @@ bool SafeRead(rabbit::VirtualMachine* v,SQWRITEFUNC read,SQUserPointer up,SQUser return true; } -bool WriteTag(rabbit::VirtualMachine* v,SQWRITEFUNC write,SQUserPointer up,uint32_t tag) +bool 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,SQUserPointer up,uint32_t tag) +bool CheckTag(rabbit::VirtualMachine* v,SQWRITEFUNC read,rabbit::UserPointer up,uint32_t tag) { uint32_t t; _CHECK_IO(SafeRead(v,read,up,&t,sizeof(t))); @@ -287,21 +218,21 @@ bool CheckTag(rabbit::VirtualMachine* v,SQWRITEFUNC read,SQUserPointer up,uint32 return true; } -bool WriteObject(rabbit::VirtualMachine* v,SQUserPointer up,SQWRITEFUNC write,SQObjectPtr &o) +bool 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))); switch(sq_type(o)){ - case OT_STRING: + case rabbit::OT_STRING: _CHECK_IO(SafeWrite(v,write,up,&_string(o)->_len,sizeof(int64_t))); _CHECK_IO(SafeWrite(v,write,up,_stringval(o),sq_rsl(_string(o)->_len))); break; - case OT_BOOL: - case OT_INTEGER: + case rabbit::OT_BOOL: + case rabbit::OT_INTEGER: _CHECK_IO(SafeWrite(v,write,up,&_integer(o),sizeof(int64_t)));break; - case OT_FLOAT: + case rabbit::OT_FLOAT: _CHECK_IO(SafeWrite(v,write,up,&_float(o),sizeof(float_t)));break; - case OT_NULL: + case rabbit::OT_NULL: break; default: v->raise_error(_SC("cannot serialize a %s"),getTypeName(o)); @@ -310,32 +241,32 @@ bool WriteObject(rabbit::VirtualMachine* v,SQUserPointer up,SQWRITEFUNC write,SQ return true; } -bool ReadObject(rabbit::VirtualMachine* v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &o) +bool ReadObject(rabbit::VirtualMachine* v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &o) { uint32_t _type; _CHECK_IO(SafeRead(v,read,up,&_type,sizeof(_type))); - SQObjectType t = (SQObjectType)_type; + rabbit::ObjectType t = (rabbit::ObjectType)_type; switch(t){ - case OT_STRING:{ + case rabbit::OT_STRING:{ int64_t len; _CHECK_IO(SafeRead(v,read,up,&len,sizeof(int64_t))); - _CHECK_IO(SafeRead(v,read,up,_ss(v)->getScratchPad(sq_rsl(len)),sq_rsl(len))); - o=SQString::create(_ss(v),_ss(v)->getScratchPad(-1),len); + _CHECK_IO(SafeRead(v,read,up,_get_shared_state(v)->getScratchPad(sq_rsl(len)),sq_rsl(len))); + o=SQString::create(_get_shared_state(v),_ss(v)->getScratchPad(-1),len); } break; - case OT_INTEGER:{ + case rabbit::OT_INTEGER:{ int64_t i; _CHECK_IO(SafeRead(v,read,up,&i,sizeof(int64_t))); o = i; break; } - case OT_BOOL:{ + case rabbit::OT_BOOL:{ int64_t i; - _CHECK_IO(SafeRead(v,read,up,&i,sizeof(int64_t))); o._type = OT_BOOL; o._unVal.nInteger = i; break; + _CHECK_IO(SafeRead(v,read,up,&i,sizeof(int64_t))); o._type = rabbit::OT_BOOL; o._unVal.nInteger = i; break; } - case OT_FLOAT:{ + case rabbit::OT_FLOAT:{ float_t f; _CHECK_IO(SafeRead(v,read,up,&f,sizeof(float_t))); o = f; break; } - case OT_NULL: + case rabbit::OT_NULL: o.Null(); break; default: @@ -345,10 +276,10 @@ bool ReadObject(rabbit::VirtualMachine* v,SQUserPointer up,SQREADFUNC read,SQObj return true; } -bool SQClosure::save(rabbit::VirtualMachine *v,SQUserPointer up,SQWRITEFUNC write) +bool SQClosure::save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write) { _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_HEAD)); - _CHECK_IO(WriteTag(v,write,up,sizeof(SQChar))); + _CHECK_IO(WriteTag(v,write,up,sizeof(rabbit::Char))); _CHECK_IO(WriteTag(v,write,up,sizeof(int64_t))); _CHECK_IO(WriteTag(v,write,up,sizeof(float_t))); _CHECK_IO(_function->save(v,up,write)); @@ -356,16 +287,16 @@ bool SQClosure::save(rabbit::VirtualMachine *v,SQUserPointer up,SQWRITEFUNC writ return true; } -bool SQClosure::load(rabbit::VirtualMachine *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret) +bool SQClosure::load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &ret) { _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_HEAD)); - _CHECK_IO(CheckTag(v,read,up,sizeof(SQChar))); + _CHECK_IO(CheckTag(v,read,up,sizeof(rabbit::Char))); _CHECK_IO(CheckTag(v,read,up,sizeof(int64_t))); _CHECK_IO(CheckTag(v,read,up,sizeof(float_t))); - SQObjectPtr func; + rabbit::ObjectPtr func; _CHECK_IO(SQFunctionProto::load(v,up,read,func)); _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_TAIL)); - ret = SQClosure::create(_ss(v),_funcproto(func),_table(v->_roottable)->getWeakRef(OT_TABLE)); + ret = SQClosure::create(_get_shared_state(v),_funcproto(func),_table(v->_roottable)->getWeakRef(rabbit::OT_TABLE)); //FIXME: load an root for this closure return true; } @@ -380,7 +311,7 @@ SQFunctionProto::~SQFunctionProto() { } -bool SQFunctionProto::save(rabbit::VirtualMachine *v,SQUserPointer up,SQWRITEFUNC write) +bool SQFunctionProto::save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write) { int64_t i,nliterals = _nliterals,nparameters = _nparameters; int64_t noutervalues = _noutervalues,nlocalvarinfos = _nlocalvarinfos; @@ -443,13 +374,13 @@ bool SQFunctionProto::save(rabbit::VirtualMachine *v,SQUserPointer up,SQWRITEFUN return true; } -bool SQFunctionProto::load(rabbit::VirtualMachine *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret) +bool SQFunctionProto::load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &ret) { int64_t i, nliterals,nparameters; int64_t noutervalues ,nlocalvarinfos ; int64_t nlineinfos,ninstructions ,nfunctions,ndefaultparams ; - SQObjectPtr sourcename, name; - SQObjectPtr o; + rabbit::ObjectPtr sourcename, name; + rabbit::ObjectPtr o; _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART)); _CHECK_IO(ReadObject(v, up, read, sourcename)); _CHECK_IO(ReadObject(v, up, read, name)); @@ -467,7 +398,7 @@ bool SQFunctionProto::load(rabbit::VirtualMachine *v,SQUserPointer up,SQREADFUNC SQFunctionProto *f = SQFunctionProto::create(NULL,ninstructions,nliterals,nparameters, nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams); - SQObjectPtr proto = f; //gets a ref in case of failure + rabbit::ObjectPtr proto = f; //gets a ref in case of failure f->_sourcename = sourcename; f->_name = name; @@ -487,7 +418,7 @@ bool SQFunctionProto::load(rabbit::VirtualMachine *v,SQUserPointer up,SQREADFUNC for(i = 0; i < noutervalues; i++){ uint64_t type; - SQObjectPtr name; + rabbit::ObjectPtr name; _CHECK_IO(SafeRead(v,read,up, &type, sizeof(uint64_t))); _CHECK_IO(ReadObject(v, up, read, o)); _CHECK_IO(ReadObject(v, up, read, name)); diff --git a/rabbit/sqobject.hpp b/rabbit/sqobject.hpp index 7f6c0cc..35206c9 100644 --- a/rabbit/sqobject.hpp +++ b/rabbit/sqobject.hpp @@ -23,294 +23,37 @@ struct SQSharedState; -enum SQMetaMethod{ - MT_ADD=0, - MT_SUB=1, - MT_MUL=2, - MT_DIV=3, - MT_UNM=4, - MT_MODULO=5, - MT_SET=6, - MT_GET=7, - MT_TYPEOF=8, - MT_NEXTI=9, - MT_CMP=10, - MT_CALL=11, - MT_CLONED=12, - MT_NEWSLOT=13, - MT_DELSLOT=14, - MT_TOSTRING=15, - MT_NEWMEMBER=16, - MT_INHERITED=17, - MT_LAST = 18 -}; - -#define MM_ADD _SC("_add") -#define MM_SUB _SC("_sub") -#define MM_MUL _SC("_mul") -#define MM_DIV _SC("_div") -#define MM_UNM _SC("_unm") -#define MM_MODULO _SC("_modulo") -#define MM_SET _SC("_set") -#define MM_GET _SC("_get") -#define MM_TYPEOF _SC("_typeof") -#define MM_NEXTI _SC("_nexti") -#define MM_CMP _SC("_cmp") -#define MM_CALL _SC("_call") -#define MM_CLONED _SC("_cloned") -#define MM_NEWSLOT _SC("_newslot") -#define MM_DELSLOT _SC("_delslot") -#define MM_TOSTRING _SC("_tostring") -#define MM_NEWMEMBER _SC("_newmember") -#define MM_INHERITED _SC("_inherited") - - -#define _CONSTRUCT_VECTOR(type,size,ptr) { \ +#define _CONSTRUCT_VECTOR(type, size, ptr) { \ for(int64_t n = 0; n < ((int64_t)size); n++) { \ new (&ptr[n]) type(); \ } \ } -#define _DESTRUCT_VECTOR(type,size,ptr) { \ +#define _DESTRUCT_VECTOR(type, size, ptr) { \ for(int64_t nl = 0; nl < ((int64_t)size); nl++) { \ ptr[nl].~type(); \ } \ } -#define _COPY_VECTOR(dest,src,size) { \ +#define _COPY_VECTOR(dest, src, size) { \ for(int64_t _n_ = 0; _n_ < ((int64_t)size); _n_++) { \ dest[_n_] = src[_n_]; \ } \ } -#define _NULL_SQOBJECT_VECTOR(vec,size) { \ +#define _NULL_SQOBJECT_VECTOR(vec, size) { \ for(int64_t _n_ = 0; _n_ < ((int64_t)size); _n_++) { \ vec[_n_].Null(); \ } \ } -#define MINPOWER2 4 - -#define _realval(o) (sq_type((o)) != OT_WEAKREF?(SQObject)o:_weakref(o)->_obj) - -struct SQObjectPtr; - -#define __addRef(type,unval) if(ISREFCOUNTED(type)) \ - { \ - unval.pRefCounted->refCountIncrement(); \ - } - -#define __release(type,unval) if(ISREFCOUNTED(type) && (unval.pRefCounted->refCountDecrement()==0)) \ - { \ - unval.pRefCounted->release(); \ - } - -#define __Objrelease(obj) { \ - if((obj)) { \ - auto val = (obj)->refCountDecrement(); \ - if(val == 0) { \ - (obj)->release(); \ - } \ - (obj) = NULL; \ - } \ -} - -#define __ObjaddRef(obj) { \ - (obj)->refCountIncrement(); \ -} - -#define is_delegable(t) (sq_type(t)&SQOBJECT_DELEGABLE) -#define raw_type(obj) _RAW_TYPE((obj)._type) - -#define _integer(obj) ((obj)._unVal.nInteger) -#define _float(obj) ((obj)._unVal.fFloat) -#define _string(obj) ((obj)._unVal.pString) -#define _table(obj) ((obj)._unVal.pTable) -#define _array(obj) ((obj)._unVal.pArray) -#define _closure(obj) ((obj)._unVal.pClosure) -#define _generator(obj) ((obj)._unVal.pGenerator) -#define _nativeclosure(obj) ((obj)._unVal.pNativeClosure) -#define _userdata(obj) ((obj)._unVal.pUserData) -#define _userpointer(obj) ((obj)._unVal.pUserPointer) -#define _thread(obj) ((obj)._unVal.pThread) -#define _funcproto(obj) ((obj)._unVal.pFunctionProto) -#define _class(obj) ((obj)._unVal.pClass) -#define _instance(obj) ((obj)._unVal.pInstance) -#define _delegable(obj) ((SQDelegable *)(obj)._unVal.pDelegable) -#define _weakref(obj) ((obj)._unVal.pWeakRef) -#define _outer(obj) ((obj)._unVal.pOuter) -#define _refcounted(obj) ((obj)._unVal.pRefCounted) -#define _rawval(obj) ((obj)._unVal.raw) - -#define _stringval(obj) (obj)._unVal.pString->_val -#define _userdataval(obj) ((SQUserPointer)sq_aligning((obj)._unVal.pUserData + 1)) - -#define tofloat(num) ((sq_type(num)==OT_INTEGER)?(float_t)_integer(num):_float(num)) -#define tointeger(num) ((sq_type(num)==OT_FLOAT)?(int64_t)_float(num):_integer(num)) -///////////////////////////////////////////////////////////////////////////////////// -///////////////////////////////////////////////////////////////////////////////////// -#if defined(SQUSEDOUBLE) && !defined(_SQ64) || !defined(SQUSEDOUBLE) && defined(_SQ64) -#define SQ_REFOBJECT_INIT() SQ_OBJECT_RAWINIT() -#else -#define SQ_REFOBJECT_INIT() -#endif - -#define _REF_TYPE_DECL(type,_class,sym) \ - SQObjectPtr(_class * x) \ - { \ - SQ_OBJECT_RAWINIT() \ - _type=type; \ - _unVal.sym = x; \ - assert(_unVal.pTable); \ - _unVal.pRefCounted->refCountIncrement(); \ - } \ - inline SQObjectPtr& operator=(_class *x) \ - { \ - SQObjectType tOldType; \ - SQObjectValue unOldVal; \ - tOldType=_type; \ - unOldVal=_unVal; \ - _type = type; \ - SQ_REFOBJECT_INIT() \ - _unVal.sym = x; \ - _unVal.pRefCounted->refCountIncrement(); \ - __release(tOldType,unOldVal); \ - return *this; \ - } - -#define _SCALAR_TYPE_DECL(type,_class,sym) \ - SQObjectPtr(_class x) \ - { \ - SQ_OBJECT_RAWINIT() \ - _type=type; \ - _unVal.sym = x; \ - } \ - inline SQObjectPtr& operator=(_class x) \ - { \ - __release(_type,_unVal); \ - _type = type; \ - SQ_OBJECT_RAWINIT() \ - _unVal.sym = x; \ - return *this; \ - } -struct SQObjectPtr : public SQObject +inline void _Swap(rabbit::Object &a,rabbit::Object &b) { - SQObjectPtr() - { - SQ_OBJECT_RAWINIT() - _type=OT_NULL; - _unVal.pUserPointer=NULL; - } - SQObjectPtr(const SQObjectPtr &o) - { - _type = o._type; - _unVal = o._unVal; - __addRef(_type,_unVal); - } - SQObjectPtr(const SQObject &o) - { - _type = o._type; - _unVal = o._unVal; - __addRef(_type,_unVal); - } - _REF_TYPE_DECL(OT_TABLE,SQTable,pTable) - _REF_TYPE_DECL(OT_CLASS,SQClass,pClass) - _REF_TYPE_DECL(OT_INSTANCE,SQInstance,pInstance) - _REF_TYPE_DECL(OT_ARRAY,rabbit::Array,pArray) - _REF_TYPE_DECL(OT_CLOSURE,SQClosure,pClosure) - _REF_TYPE_DECL(OT_NATIVECLOSURE,SQNativeClosure,pNativeClosure) - _REF_TYPE_DECL(OT_OUTER,SQOuter,pOuter) - _REF_TYPE_DECL(OT_GENERATOR,SQGenerator,pGenerator) - _REF_TYPE_DECL(OT_STRING,SQString,pString) - _REF_TYPE_DECL(OT_USERDATA,rabbit::UserData,pUserData) - _REF_TYPE_DECL(OT_WEAKREF,rabbit::WeakRef,pWeakRef) - _REF_TYPE_DECL(OT_THREAD,rabbit::VirtualMachine,pThread) - _REF_TYPE_DECL(OT_FUNCPROTO,SQFunctionProto,pFunctionProto) - - _SCALAR_TYPE_DECL(OT_INTEGER,int64_t,nInteger) - _SCALAR_TYPE_DECL(OT_FLOAT,float_t,fFloat) - _SCALAR_TYPE_DECL(OT_USERPOINTER,SQUserPointer,pUserPointer) - - SQObjectPtr(bool bBool) - { - SQ_OBJECT_RAWINIT() - _type = OT_BOOL; - _unVal.nInteger = bBool?1:0; - } - inline SQObjectPtr& operator=(bool b) - { - __release(_type,_unVal); - SQ_OBJECT_RAWINIT() - _type = OT_BOOL; - _unVal.nInteger = b?1:0; - return *this; - } - - ~SQObjectPtr() - { - __release(_type,_unVal); - } - - inline SQObjectPtr& operator=(const SQObjectPtr& obj) - { - SQObjectType tOldType; - SQObjectValue unOldVal; - tOldType=_type; - unOldVal=_unVal; - _unVal = obj._unVal; - _type = obj._type; - __addRef(_type,_unVal); - __release(tOldType,unOldVal); - return *this; - } - inline SQObjectPtr& operator=(const SQObject& obj) - { - SQObjectType tOldType; - SQObjectValue unOldVal; - tOldType=_type; - unOldVal=_unVal; - _unVal = obj._unVal; - _type = obj._type; - __addRef(_type,_unVal); - __release(tOldType,unOldVal); - return *this; - } - inline void Null() - { - SQObjectType tOldType = _type; - SQObjectValue unOldVal = _unVal; - _type = OT_NULL; - _unVal.raw = (SQRawObjectVal)NULL; - __release(tOldType ,unOldVal); - } - private: - SQObjectPtr(const SQChar *){} //safety -}; - - -inline void _Swap(SQObject &a,SQObject &b) -{ - SQObjectType tOldType = a._type; - SQObjectValue unOldVal = a._unVal; + rabbit::ObjectType tOldType = a._type; + rabbit::ObjectValue unOldVal = a._unVal; a._type = b._type; a._unVal = b._unVal; b._type = tOldType; b._unVal = unOldVal; -} - - -struct SQDelegable : public rabbit::RefCounted { - bool setDelegate(SQTable *m); - virtual bool getMetaMethod(rabbit::VirtualMachine *v,SQMetaMethod mm,SQObjectPtr &res); - SQTable *_delegate; -}; - -uint64_t translateIndex(const SQObjectPtr &idx); -typedef etk::Vector SQObjectPtrVec; -typedef etk::Vector SQIntVec; -const SQChar *getTypeName(const SQObjectPtr &obj1); -const SQChar *IdType2Name(SQObjectType type); - - - +} \ No newline at end of file diff --git a/rabbit/sqopcodes.hpp b/rabbit/sqopcodes.hpp index 8c53026..0fa4ace 100644 --- a/rabbit/sqopcodes.hpp +++ b/rabbit/sqopcodes.hpp @@ -108,7 +108,7 @@ enum SQOpcode }; struct SQInstructionDesc { - const SQChar *name; + const rabbit::Char *name; }; struct SQInstruction diff --git a/rabbit/sqstate.cpp b/rabbit/sqstate.cpp index 074b26a..e9ecf05 100644 --- a/rabbit/sqstate.cpp +++ b/rabbit/sqstate.cpp @@ -36,7 +36,7 @@ SQSharedState::SQSharedState() _table(_metamethodsmap)->newSlot(_metamethods->back(),(int64_t)(_metamethods->size()-1)); \ } -bool compileTypemask(SQIntVec &res,const SQChar *typemask) +bool compileTypemask(etk::Vector &res,const rabbit::Char *typemask) { int64_t i = 0; int64_t mask = 0; @@ -77,7 +77,7 @@ bool compileTypemask(SQIntVec &res,const SQChar *typemask) return true; } -SQTable *createDefaultDelegate(SQSharedState *ss,const SQRegFunction *funcz) +SQTable *createDefaultDelegate(SQSharedState *ss,const rabbit::RegFunction *funcz) { int64_t i=0; SQTable *t=SQTable::create(ss,0); @@ -99,9 +99,9 @@ void SQSharedState::init() _scratchpadsize=0; _stringtable = (SQStringTable*)SQ_MALLOC(sizeof(SQStringTable)); new (_stringtable) SQStringTable(this); - sq_new(_metamethods,SQObjectPtrVec); - sq_new(_systemstrings,SQObjectPtrVec); - sq_new(_types,SQObjectPtrVec); + sq_new(_metamethods,etk::Vector); + sq_new(_systemstrings,etk::Vector); + sq_new(_types,etk::Vector); _metamethodsmap = SQTable::create(this,MT_LAST-1); //adding type strings to avoid memory trashing //types names @@ -183,19 +183,19 @@ SQSharedState::~SQSharedState() _weakref_default_delegate.Null(); _refs_table.finalize(); - sq_delete(_types,SQObjectPtrVec); - sq_delete(_systemstrings,SQObjectPtrVec); - sq_delete(_metamethods,SQObjectPtrVec); + sq_delete(_types,etk::Vector); + sq_delete(_systemstrings,etk::Vector); + sq_delete(_metamethods,etk::Vector); sq_delete(_stringtable,SQStringTable); if(_scratchpad)SQ_FREE(_scratchpad,_scratchpadsize); } -int64_t SQSharedState::getMetaMethodIdxByName(const SQObjectPtr &name) +int64_t SQSharedState::getMetaMethodIdxByName(const rabbit::ObjectPtr &name) { - if(sq_type(name) != OT_STRING) + if(sq_type(name) != rabbit::OT_STRING) return -1; - SQObjectPtr ret; + rabbit::ObjectPtr ret; if(_table(_metamethodsmap)->get(name,ret)) { return _integer(ret); } @@ -203,18 +203,18 @@ int64_t SQSharedState::getMetaMethodIdxByName(const SQObjectPtr &name) } -SQChar* SQSharedState::getScratchPad(int64_t size) +rabbit::Char* SQSharedState::getScratchPad(int64_t size) { int64_t newsize; if(size>0) { if(_scratchpadsize < size) { newsize = size + (size>>1); - _scratchpad = (SQChar *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize); + _scratchpad = (rabbit::Char *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize); _scratchpadsize = newsize; }else if(_scratchpadsize >= (size<<5)) { newsize = _scratchpadsize >> 1; - _scratchpad = (SQChar *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize); + _scratchpad = (rabbit::Char *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize); _scratchpadsize = newsize; } } @@ -241,7 +241,7 @@ RefTable::~RefTable() } -void RefTable::addRef(SQObject &obj) +void RefTable::addRef(rabbit::Object &obj) { SQHash mainpos; RefNode *prev; @@ -249,7 +249,7 @@ void RefTable::addRef(SQObject &obj) ref->refs++; } -uint64_t RefTable::getRefCount(SQObject &obj) +uint64_t RefTable::getRefCount(rabbit::Object &obj) { SQHash mainpos; RefNode *prev; @@ -258,14 +258,14 @@ uint64_t RefTable::getRefCount(SQObject &obj) } -SQBool RefTable::release(SQObject &obj) +rabbit::Bool RefTable::release(rabbit::Object &obj) { SQHash mainpos; RefNode *prev; RefNode *ref = get(obj,mainpos,&prev,false); if(ref) { if(--ref->refs == 0) { - SQObjectPtr o = ref->obj; + rabbit::ObjectPtr o = ref->obj; if(prev) { prev->next = ref->next; } @@ -295,7 +295,7 @@ void RefTable::resize(uint64_t size) //rehash uint64_t nfound = 0; for(uint64_t n = 0; n < oldnumofslots; n++) { - if(sq_type(t->obj) != OT_NULL) { + if(sq_type(t->obj) != rabbit::OT_NULL) { //add back; assert(t->refs != 0); RefNode *nn = add(::HashObj(t->obj)&(_numofslots-1),t->obj); @@ -309,7 +309,7 @@ void RefTable::resize(uint64_t size) SQ_FREE(oldbucks,(oldnumofslots * sizeof(RefNode *)) + (oldnumofslots * sizeof(RefNode))); } -RefTable::RefNode *RefTable::add(SQHash mainpos,SQObject &obj) +RefTable::RefNode *RefTable::add(SQHash mainpos,rabbit::Object &obj) { RefNode *t = _buckets[mainpos]; RefNode *newnode = _freelist; @@ -322,7 +322,7 @@ RefTable::RefNode *RefTable::add(SQHash mainpos,SQObject &obj) return newnode; } -RefTable::RefNode *RefTable::get(SQObject &obj,SQHash &mainpos,RefNode **prev,bool addIfNeeded) +RefTable::RefNode *RefTable::get(rabbit::Object &obj,SQHash &mainpos,RefNode **prev,bool addIfNeeded) { RefNode *ref; mainpos = ::HashObj(obj)&(_numofslots-1); @@ -355,13 +355,13 @@ void RefTable::allocNodes(uint64_t size) for(n = 0; n < size - 1; n++) { bucks[n] = NULL; temp->refs = 0; - new (&temp->obj) SQObjectPtr; + new (&temp->obj) rabbit::ObjectPtr; temp->next = temp+1; temp++; } bucks[n] = NULL; temp->refs = 0; - new (&temp->obj) SQObjectPtr; + new (&temp->obj) rabbit::ObjectPtr; temp->next = NULL; _freelist = nodes; _nodes = nodes; @@ -397,7 +397,7 @@ void SQStringTable::allocNodes(int64_t size) memset(_strings,0,sizeof(SQString*)*_numofslots); } -SQString *SQStringTable::add(const SQChar *news,int64_t len) +SQString *SQStringTable::add(const rabbit::Char *news,int64_t len) { if(len<0) len = (int64_t)scstrlen(news); diff --git a/rabbit/sqstate.hpp b/rabbit/sqstate.hpp index 680c861..622c61e 100644 --- a/rabbit/sqstate.hpp +++ b/rabbit/sqstate.hpp @@ -9,6 +9,8 @@ #include #include +#include + struct SQString; struct SQTable; //max number of character for a printed number @@ -18,7 +20,7 @@ struct SQStringTable { SQStringTable(SQSharedState*ss); ~SQStringTable(); - SQString *add(const SQChar *,int64_t len); + SQString *add(const rabbit::Char *,int64_t len); void remove(SQString *); private: void resize(int64_t size); @@ -31,19 +33,19 @@ private: struct RefTable { struct RefNode { - SQObjectPtr obj; + rabbit::ObjectPtr obj; uint64_t refs; struct RefNode *next; }; RefTable(); ~RefTable(); - void addRef(SQObject &obj); - SQBool release(SQObject &obj); - uint64_t getRefCount(SQObject &obj); + void addRef(rabbit::Object &obj); + rabbit::Bool release(rabbit::Object &obj); + uint64_t getRefCount(rabbit::Object &obj); void finalize(); private: - RefNode *get(SQObject &obj,SQHash &mainpos,RefNode **prev,bool add); - RefNode *add(SQHash mainpos,SQObject &obj); + RefNode *get(rabbit::Object &obj,SQHash &mainpos,RefNode **prev,bool add); + RefNode *add(SQHash mainpos,rabbit::Object &obj); void resize(uint64_t size); void allocNodes(uint64_t size); uint64_t _numofslots; @@ -55,74 +57,74 @@ private: #define ADD_STRING(ss,str,len) ss->_stringtable->add(str,len) #define REMOVE_STRING(ss,bstr) ss->_stringtable->remove(bstr) - -struct SQObjectPtr; - +namespace rabbit { + class ObjectPtr; +} struct SQSharedState { SQSharedState(); ~SQSharedState(); void init(); public: - SQChar* getScratchPad(int64_t size); - int64_t getMetaMethodIdxByName(const SQObjectPtr &name); - SQObjectPtrVec *_metamethods; - SQObjectPtr _metamethodsmap; - SQObjectPtrVec *_systemstrings; - SQObjectPtrVec *_types; + rabbit::Char* getScratchPad(int64_t size); + int64_t getMetaMethodIdxByName(const rabbit::ObjectPtr &name); + etk::Vector *_metamethods; + rabbit::ObjectPtr _metamethodsmap; + etk::Vector *_systemstrings; + etk::Vector *_types; SQStringTable *_stringtable; RefTable _refs_table; - SQObjectPtr _registry; - SQObjectPtr _consts; - SQObjectPtr _constructoridx; - SQObjectPtr _root_vm; - SQObjectPtr _table_default_delegate; - static const SQRegFunction _table_default_delegate_funcz[]; - SQObjectPtr _array_default_delegate; - static const SQRegFunction _array_default_delegate_funcz[]; - SQObjectPtr _string_default_delegate; - static const SQRegFunction _string_default_delegate_funcz[]; - SQObjectPtr _number_default_delegate; - static const SQRegFunction _number_default_delegate_funcz[]; - SQObjectPtr _generator_default_delegate; - static const SQRegFunction _generator_default_delegate_funcz[]; - SQObjectPtr _closure_default_delegate; - static const SQRegFunction _closure_default_delegate_funcz[]; - SQObjectPtr _thread_default_delegate; - static const SQRegFunction _thread_default_delegate_funcz[]; - SQObjectPtr _class_default_delegate; - static const SQRegFunction _class_default_delegate_funcz[]; - SQObjectPtr _instance_default_delegate; - static const SQRegFunction _instance_default_delegate_funcz[]; - SQObjectPtr _weakref_default_delegate; - static const SQRegFunction _weakref_default_delegate_funcz[]; + rabbit::ObjectPtr _registry; + rabbit::ObjectPtr _consts; + rabbit::ObjectPtr _constructoridx; + rabbit::ObjectPtr _root_vm; + rabbit::ObjectPtr _table_default_delegate; + static const rabbit::RegFunction _table_default_delegate_funcz[]; + rabbit::ObjectPtr _array_default_delegate; + static const rabbit::RegFunction _array_default_delegate_funcz[]; + rabbit::ObjectPtr _string_default_delegate; + static const rabbit::RegFunction _string_default_delegate_funcz[]; + rabbit::ObjectPtr _number_default_delegate; + static const rabbit::RegFunction _number_default_delegate_funcz[]; + rabbit::ObjectPtr _generator_default_delegate; + static const rabbit::RegFunction _generator_default_delegate_funcz[]; + rabbit::ObjectPtr _closure_default_delegate; + static const rabbit::RegFunction _closure_default_delegate_funcz[]; + rabbit::ObjectPtr _thread_default_delegate; + static const rabbit::RegFunction _thread_default_delegate_funcz[]; + rabbit::ObjectPtr _class_default_delegate; + static const rabbit::RegFunction _class_default_delegate_funcz[]; + rabbit::ObjectPtr _instance_default_delegate; + static const rabbit::RegFunction _instance_default_delegate_funcz[]; + rabbit::ObjectPtr _weakref_default_delegate; + static const rabbit::RegFunction _weakref_default_delegate_funcz[]; SQCOMPILERERROR _compilererrorhandler; SQPRINTFUNCTION _printfunc; SQPRINTFUNCTION _errorfunc; bool _debuginfo; bool _notifyallexceptions; - SQUserPointer _foreignptr; + rabbit::UserPointer _foreignptr; SQRELEASEHOOK _releasehook; private: - SQChar *_scratchpad; + rabbit::Char *_scratchpad; int64_t _scratchpadsize; }; #define _sp(s) (_sharedstate->getScratchPad(s)) #define _spval (_sharedstate->getScratchPad(-1)) -#define _table_ddel _table(_sharedstate->_table_default_delegate) -#define _array_ddel _table(_sharedstate->_array_default_delegate) -#define _string_ddel _table(_sharedstate->_string_default_delegate) -#define _number_ddel _table(_sharedstate->_number_default_delegate) +#define _table_ddel _table(_sharedstate->_table_default_delegate) +#define _array_ddel _table(_sharedstate->_array_default_delegate) +#define _string_ddel _table(_sharedstate->_string_default_delegate) +#define _number_ddel _table(_sharedstate->_number_default_delegate) #define _generator_ddel _table(_sharedstate->_generator_default_delegate) #define _closure_ddel _table(_sharedstate->_closure_default_delegate) -#define _thread_ddel _table(_sharedstate->_thread_default_delegate) -#define _class_ddel _table(_sharedstate->_class_default_delegate) +#define _thread_ddel _table(_sharedstate->_thread_default_delegate) +#define _class_ddel _table(_sharedstate->_class_default_delegate) #define _instance_ddel _table(_sharedstate->_instance_default_delegate) #define _weakref_ddel _table(_sharedstate->_weakref_default_delegate) -bool compileTypemask(SQIntVec &res,const SQChar *typemask); +bool compileTypemask(etk::Vector &res,const rabbit::Char *typemask); diff --git a/rabbit/sqstring.hpp b/rabbit/sqstring.hpp index e7a2739..c0baaf2 100644 --- a/rabbit/sqstring.hpp +++ b/rabbit/sqstring.hpp @@ -7,7 +7,7 @@ */ #pragma once -inline SQHash _hashstr (const SQChar *s, size_t l) +inline SQHash _hashstr (const rabbit::Char *s, size_t l) { SQHash h = (SQHash)l; /* seed */ size_t step = (l>>5)|1; /* if string is too long, don't hash all its chars */ @@ -21,14 +21,14 @@ struct SQString : public rabbit::RefCounted SQString(){} ~SQString(){} public: - static SQString *create(SQSharedState *ss, const SQChar *, int64_t len = -1 ); - int64_t next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); + static SQString *create(SQSharedState *ss, const rabbit::Char *, int64_t len = -1 ); + int64_t next(const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval); void release(); SQSharedState *_sharedstate; SQString *_next; //chain for the string table int64_t _len; SQHash _hash; - SQChar _val[1]; + rabbit::Char _val[1]; }; diff --git a/rabbit/sqtable.cpp b/rabbit/sqtable.cpp index d1fb91b..da7be2a 100644 --- a/rabbit/sqtable.cpp +++ b/rabbit/sqtable.cpp @@ -21,7 +21,7 @@ SQTable::SQTable(SQSharedState *ss,int64_t ninitialsize) _delegate = NULL; } -void SQTable::remove(const SQObjectPtr &key) +void SQTable::remove(const rabbit::ObjectPtr &key) { _HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1)); @@ -65,7 +65,7 @@ void SQTable::Rehash(bool force) _usednodes = 0; for (int64_t i=0; ikey) != OT_NULL) + if (sq_type(old->key) != rabbit::OT_NULL) newSlot(old->key,old->val); } for(int64_t k=0;k_usednodes = _usednodes; #else int64_t ridx=0; - SQObjectPtr key,val; + rabbit::ObjectPtr key,val; while((ridx=next(true,ridx,key,val))!=-1){ nt->newSlot(key,val); } @@ -108,9 +108,9 @@ SQTable *SQTable::clone() return nt; } -bool SQTable::get(const SQObjectPtr &key,SQObjectPtr &val) +bool SQTable::get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val) { - if(sq_type(key) == OT_NULL) + if(sq_type(key) == rabbit::OT_NULL) return false; _HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1)); if (n) { @@ -119,9 +119,9 @@ bool SQTable::get(const SQObjectPtr &key,SQObjectPtr &val) } return false; } -bool SQTable::newSlot(const SQObjectPtr &key,const SQObjectPtr &val) +bool SQTable::newSlot(const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val) { - assert(sq_type(key) != OT_NULL); + assert(sq_type(key) != rabbit::OT_NULL); SQHash h = HashObj(key) & (_numofnodes - 1); _HashNode *n = _get(key, h); if (n) { @@ -135,7 +135,7 @@ bool SQTable::newSlot(const SQObjectPtr &key,const SQObjectPtr &val) //key not found I'll insert it //main pos is not free - if(sq_type(mp->key) != OT_NULL) { + if(sq_type(mp->key) != rabbit::OT_NULL) { n = _firstfree; /* get a free place */ SQHash mph = HashObj(mp->key) & (_numofnodes - 1); _HashNode *othern; /* main position of colliding node */ @@ -164,7 +164,7 @@ bool SQTable::newSlot(const SQObjectPtr &key,const SQObjectPtr &val) mp->key = key; for (;;) { /* correct `firstfree' */ - if (sq_type(_firstfree->key) == OT_NULL && _firstfree->next == NULL) { + if (sq_type(_firstfree->key) == rabbit::OT_NULL && _firstfree->next == NULL) { mp->val = val; _usednodes++; return true; /* OK; table still has a free place */ @@ -176,15 +176,15 @@ bool SQTable::newSlot(const SQObjectPtr &key,const SQObjectPtr &val) return newSlot(key, val); } -int64_t SQTable::next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval) +int64_t SQTable::next(bool getweakrefs,const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval) { int64_t idx = (int64_t)translateIndex(refpos); while (idx < _numofnodes) { - if(sq_type(_nodes[idx].key) != OT_NULL) { + if(sq_type(_nodes[idx].key) != rabbit::OT_NULL) { //first found _HashNode &n = _nodes[idx]; outkey = n.key; - outval = getweakrefs?(SQObject)n.val:_realval(n.val); + outval = getweakrefs?(rabbit::Object)n.val:_realval(n.val); //return idx for the next iteration return ++idx; } @@ -195,7 +195,7 @@ int64_t SQTable::next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &o } -bool SQTable::set(const SQObjectPtr &key, const SQObjectPtr &val) +bool SQTable::set(const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &val) { _HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1)); if (n) { diff --git a/rabbit/sqtable.hpp b/rabbit/sqtable.hpp index f37a3ec..5235d56 100644 --- a/rabbit/sqtable.hpp +++ b/rabbit/sqtable.hpp @@ -14,28 +14,38 @@ */ #include +#include +#include +#include +#include +#include #define hashptr(p) ((SQHash)(((int64_t)p) >> 3)) -inline SQHash HashObj(const SQObjectPtr &key) +inline SQHash HashObj(const rabbit::ObjectPtr &key) { switch(sq_type(key)) { - case OT_STRING: return _string(key)->_hash; - case OT_FLOAT: return (SQHash)((int64_t)_float(key)); - case OT_BOOL: case OT_INTEGER: return (SQHash)((int64_t)_integer(key)); - default: return hashptr(key._unVal.pRefCounted); + case rabbit::OT_STRING: + return _string(key)->_hash; + case rabbit::OT_FLOAT: + return (SQHash)((int64_t)_float(key)); + case rabbit::OT_BOOL: + case rabbit::OT_INTEGER: + return (SQHash)((int64_t)_integer(key)); + default: + return hashptr(key._unVal.pRefCounted); } } -struct SQTable : public SQDelegable +struct SQTable : public rabbit::Delegable { private: struct _HashNode { _HashNode() { next = NULL; } - SQObjectPtr val; - SQObjectPtr key; + rabbit::ObjectPtr val; + rabbit::ObjectPtr key; _HashNode *next; }; _HashNode *_firstfree; @@ -51,8 +61,8 @@ private: public: static SQTable* create(SQSharedState *ss,int64_t ninitialsize) { - SQTable *newtable = (SQTable*)SQ_MALLOC(sizeof(SQTable)); - new (newtable) SQTable(ss, ninitialsize); + char* tmp = (char*)SQ_MALLOC(sizeof(SQTable)); + SQTable *newtable = new (tmp) SQTable(ss, ninitialsize); newtable->_delegate = NULL; return newtable; } @@ -64,7 +74,7 @@ public: for (int64_t i = 0; i < _numofnodes; i++) _nodes[i].~_HashNode(); SQ_FREE(_nodes, _numofnodes * sizeof(_HashNode)); } - inline _HashNode *_get(const SQObjectPtr &key,SQHash hash) + inline _HashNode *_get(const rabbit::ObjectPtr &key,SQHash hash) { _HashNode *n = &_nodes[hash]; do{ @@ -75,13 +85,13 @@ public: return NULL; } //for compiler use - inline bool getStr(const SQChar* key,int64_t keylen,SQObjectPtr &val) + inline bool getStr(const rabbit::Char* key,int64_t keylen,rabbit::ObjectPtr &val) { SQHash hash = _hashstr(key,keylen); _HashNode *n = &_nodes[hash & (_numofnodes - 1)]; _HashNode *res = NULL; do{ - if(sq_type(n->key) == OT_STRING && (scstrcmp(_stringval(n->key),key) == 0)){ + if(sq_type(n->key) == rabbit::OT_STRING && (scstrcmp(_stringval(n->key),key) == 0)){ res = n; break; } @@ -92,12 +102,12 @@ public: } return false; } - bool get(const SQObjectPtr &key,SQObjectPtr &val); - void remove(const SQObjectPtr &key); - bool set(const SQObjectPtr &key, const SQObjectPtr &val); + bool get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val); + void remove(const rabbit::ObjectPtr &key); + bool set(const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &val); //returns true if a new slot has been created false if it was already present - bool newSlot(const SQObjectPtr &key,const SQObjectPtr &val); - int64_t next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); + bool newSlot(const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val); + int64_t next(bool getweakrefs,const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval); int64_t countUsed(){ return _usednodes;} void clear();