HeeroYui-deprecated/rabbit
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] big refacto that does not work

Browse Source
This commit is contained in:
Edouard DUPIN 2018-06-27 23:27:31 +02:00
parent d92da4207d
commit 1b59eb8c8e
70 changed files with 2511 additions and 2149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
cmdLine/rabbit.cpp
View File

@ -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<argc) {
const SQChar *filename=NULL;
const rabbit::Char *filename=NULL;
#ifdef SQUNICODE
mbstowcs(temp,argv[arg],strlen(argv[arg]));
filename=temp;
@ -164,11 +164,11 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
//sq_pop(v,1);
if(compiles_only) {
if(SQ_SUCCEEDED(sqstd_loadfile(v,filename,SQTrue))){
const SQChar *outfile = _SC("out.karrot");
const rabbit::Char *outfile = _SC("out.karrot");
if(output) {
#ifdef SQUNICODE
int len = (int)(strlen(output)+1);
mbstowcs(sq_getscratchpad(v,len*sizeof(SQChar)),output,len);
mbstowcs(sq_getscratchpad(v,len*sizeof(rabbit::Char)),output,len);
outfile = sq_getscratchpad(v,-1);
#else
outfile = output;
@ -187,10 +187,10 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
sq_pushroottable(v);
for(i=arg;i<argc;i++)
{
const SQChar *a;
const rabbit::Char *a;
#ifdef SQUNICODE
int alen=(int)strlen(argv[i]);
a=sq_getscratchpad(v,(int)(alen*sizeof(SQChar)));
a=sq_getscratchpad(v,(int)(alen*sizeof(rabbit::Char)));
mbstowcs(sq_getscratchpad(v,-1),argv[i],alen);
sq_getscratchpad(v,-1)[alen] = _SC('\0');
#else
@ -201,8 +201,8 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
//sq_arrayappend(v,-2);
}
if(SQ_SUCCEEDED(sq_call(v,callargs,SQTrue,SQTrue))) {
SQObjectType type = sq_gettype(v,-1);
if(type == OT_INTEGER) {
rabbit::ObjectType type = sq_gettype(v,-1);
if(type == rabbit::OT_INTEGER) {
*retval = type;
sq_getinteger(v,-1,retval);
}
@ -216,7 +216,7 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
}
//if this point is reached an error occurred
{
const SQChar *err;
const rabbit::Char *err;
sq_getlasterror(v);
if(SQ_SUCCEEDED(sq_getstring(v,-1,&err))) {
scprintf(_SC("error [%s]\n"),err);
@ -235,7 +235,7 @@ void Interactive(rabbit::VirtualMachine* v)
{
#define MAXINPUT 1024
SQChar buffer[MAXINPUT];
rabbit::Char buffer[MAXINPUT];
int64_t blocks =0;
int64_t string=0;
int64_t retval=0;
@ -266,28 +266,28 @@ void Interactive(rabbit::VirtualMachine* v)
else if(blocks==0)break;
buffer[i++] = _SC('\n');
}
else if (c==_SC('}')) {blocks--; buffer[i++] = (SQChar)c;}
else if (c==_SC('}')) {blocks--; buffer[i++] = (rabbit::Char)c;}
else if(c==_SC('{') && !string){
blocks++;
buffer[i++] = (SQChar)c;
buffer[i++] = (rabbit::Char)c;
}
else if(c==_SC('"') || c==_SC('\'')){
string=!string;
buffer[i++] = (SQChar)c;
buffer[i++] = (rabbit::Char)c;
}
else if (i >= 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);

6
etc/minimal.cpp
View File

@ -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

23
lutin_rabbit-core.py
View File

@ -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

48
rabbit-std/sqstdaux.cpp
View File

@ -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) {

26
rabbit-std/sqstdblob.cpp
View File

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

6
rabbit-std/sqstdblob.hpp
View File

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

2
rabbit-std/sqstdblobimpl.hpp
View File

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

60
rabbit-std/sqstdio.cpp
View File

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

18
rabbit-std/sqstdio.hpp
View File

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

4
rabbit-std/sqstdmath.cpp
View File

@ -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) {

2
rabbit-std/sqstdmath.hpp
View File

@ -9,5 +9,5 @@
#include <rabbit/rabbit.hpp>
RABBIT_API SQRESULT sqstd_register_mathlib(rabbit::VirtualMachine* v);
RABBIT_API rabbit::Result sqstd_register_mathlib(rabbit::VirtualMachine* v);

54
rabbit-std/sqstdrex.cpp
View File

@ -15,7 +15,7 @@
#ifdef _DEBUG
#include <stdio.h>
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];

20
rabbit-std/sqstdstream.cpp
View File

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

2
rabbit-std/sqstdstream.hpp
View File

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

112
rabbit-std/sqstdstring.cpp
View File

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

16
rabbit-std/sqstdstring.hpp
View File

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

12
rabbit-std/sqstdsystem.cpp
View File

@ -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),

30
rabbit/Array.hpp
View File

@ -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<m_data.size()){
//first found
_outkey=(int64_t)idx;
SQObjectPtr& o = m_data[idx];
rabbit::ObjectPtr& o = m_data[idx];
_outval = _realval(o);
//return idx for the next iteration
return ++idx;
@ -70,29 +70,29 @@ namespace rabbit {
return m_data.size();
}
void resize(int64_t _size) {
SQObjectPtr empty;
rabbit::ObjectPtr empty;
resize(_size, empty);
}
void resize(int64_t _size,
SQObjectPtr& _fill) {
rabbit::ObjectPtr& _fill) {
m_data.resize(_size, _fill);
shrinkIfNeeded();
}
void reserve(int64_t _size) {
m_data.reserve(_size);
}
void append(const SQObject& _o) {
void append(const rabbit::Object& _o) {
m_data.pushBack(_o);
}
void extend(const Array* _a);
SQObjectPtr &top(){
rabbit::ObjectPtr &top(){
return m_data.back();
}
void pop() {
m_data.popBack();
shrinkIfNeeded();
}
bool insert(int64_t _idx,const SQObject& _val) {
bool insert(int64_t _idx,const rabbit::Object& _val) {
if( _idx < 0
|| _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<rabbit::ObjectPtr> m_data;
};
}

40
rabbit/Delegable.cpp Normal file
View File

@ -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 <rabbit/Delegable.hpp>
#include <rabbit/sqtable.hpp>
#include <rabbit/VirtualMachine.hpp>
#include <rabbit/sqstate.hpp>
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;
}

25
rabbit/Delegable.hpp Normal file
View File

@ -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 <etk/types.hpp>
#include <rabbit/RefCounted.hpp>
#include <rabbit/MetaMethod.hpp>
#include <rabbit/ObjectPtr.hpp>
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;
};
}

9
rabbit/ExceptionTrap.cpp Normal file
View File

@ -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 <rabbit/ExceptionTrap.hpp>

38
rabbit/ExceptionTrap.hpp Normal file
View File

@ -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 <etk/types.hpp>
#include <rabbit/sqconfig.hpp>
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;
};
}

9
rabbit/FunctionInfo.cpp Normal file
View File

@ -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 <rabbit/FunctionInfo.hpp>

21
rabbit/FunctionInfo.hpp Normal file
View File

@ -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 <etk/types.hpp>
#include <rabbit/sqconfig.hpp>
namespace rabbit {
class FunctionInfo {
public:
rabbit::UserPointer funcid;
const rabbit::Char* name;
const rabbit::Char* source;
int64_t line;
};
}

9
rabbit/MemberHandle.cpp Normal file
View File

@ -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 <rabbit/MemberHandle.hpp>

19
rabbit/MemberHandle.hpp Normal file
View File

@ -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 <etk/types.hpp>
#include <rabbit/sqconfig.hpp>
namespace rabbit {
class MemberHandle{
public:
rabbit::Bool _static;
int64_t _index;
};
}

0
rabbit/MetaMethod Normal file
View File

9
rabbit/MetaMethod.cpp Normal file
View File

@ -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 <rabbit/MetaMethod.hpp>

53
rabbit/MetaMethod.hpp Normal file
View File

@ -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 <etk/types.hpp>
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")

9
rabbit/Object.cpp Normal file
View File

@ -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 <rabbit/Object.hpp>

84
rabbit/Object.hpp Normal file
View File

@ -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 <etk/types.hpp>
#include <rabbit/ObjectType.hpp>
#include <rabbit/ObjectValue.hpp>
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)
}

201
rabbit/ObjectPtr.cpp Normal file
View File

@ -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 <rabbit/ObjectPtr.hpp>
#include <rabbit/RefCounted.hpp>
#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));
}

69
rabbit/ObjectPtr.hpp Normal file
View File

@ -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 <etk/types.hpp>
#include <rabbit/ObjectType.hpp>
#include <rabbit/ObjectValue.hpp>
#include <rabbit/sqconfig.hpp>
#include <rabbit/Object.hpp>
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);
}

9
rabbit/ObjectType.cpp Normal file
View File

@ -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 <rabbit/ObjectType.hpp>

65
rabbit/ObjectType.hpp Normal file
View File

@ -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 <etk/types.hpp>
#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)

9
rabbit/ObjectValue.cpp Normal file
View File

@ -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 <rabbit/ObjectValue.hpp>

40
rabbit/ObjectValue.hpp Normal file
View File

@ -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 <etk/types.hpp>
#include <rabbit/sqconfig.hpp>
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;
};
}

4
rabbit/RefCounted.cpp
View File

@ -12,7 +12,7 @@
#include <rabbit/squtils.hpp>
#include <etk/Allocator.hpp>
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;
}
}

17
rabbit/RefCounted.hpp
View File

@ -8,7 +8,7 @@
#pragma once
#include <etk/types.hpp>
#include <rabbit/rabbit.hpp>
#include <rabbit/ObjectType.hpp>
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(); \
}
}

9
rabbit/RegFunction.cpp Normal file
View File

@ -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 <rabbit/RegFunction.hpp>

24
rabbit/RegFunction.hpp Normal file
View File

@ -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 <etk/types.hpp>
#include <rabbit/sqconfig.hpp>
#include <rabbit/rabbit.hpp>
namespace rabbit {
class RegFunction{
public:
const rabbit::Char *name;
SQFUNCTION f;
int64_t nparamscheck;
const rabbit::Char *typemask;
};
}

0
rabbit/StackInfos.cpp Normal file
View File

21
rabbit/StackInfos.hpp Normal file
View File

@ -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 <etk/types.hpp>
namespace rabbit {
class StackInfos{
public:
const rabbit::Char* funcname;
const rabbit::Char* source;
int64_t line;
};
}

10
rabbit/UserData.hpp
View File

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

510
rabbit/VirtualMachine.cpp
View File

File diff suppressed because it is too large Load Diff

138
rabbit/VirtualMachine.hpp
View File

@ -10,6 +10,9 @@
#include <rabbit/sqopcodes.hpp>
#include <rabbit/sqobject.hpp>
#include <rabbit/AutoDec.hpp>
#include <rabbit/sqconfig.hpp>
#include <rabbit/ExceptionTrap.hpp>
#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<rabbit::ObjectPtr> _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<callInfo> _callstackdata;
etk::Vector<SQExceptionTrap> _etraps;
etk::Vector<rabbit::ExceptionTrap> _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; \

3
rabbit/WeakRef.hpp
View File

@ -9,13 +9,14 @@
#include <etk/types.hpp>
#include <rabbit/RefCounted.hpp>
#include <rabbit/Object.hpp>
namespace rabbit {
class WeakRef: public RefCounted {
public:
void release();
public:
SQObject _obj;
rabbit::Object _obj;
protected:
friend RefCounted;
};

367
rabbit/rabbit.hpp
View File

@ -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 <rabbit/Object.hpp>
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)

690
rabbit/sqapi.cpp
View File

File diff suppressed because it is too large Load Diff

276
rabbit/sqbaselib.cpp
View File

@ -17,13 +17,13 @@
#include <stdarg.h>
#include <ctype.h>
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;i<eidx;i++){
_array(o)->get(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;i<eidx;i++) snew[i] = func(sthis[i]); \
v->push(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<f->_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<nc->_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(".")},

40
rabbit/sqclass.cpp
View File

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

42
rabbit/sqclass.hpp
View File

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

50
rabbit/sqclosure.hpp
View File

@ -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<rabbit::ObjectPtr> _stack;
rabbit::VirtualMachine::callInfo _ci;
etk::Vector<SQExceptionTrap> _etraps;
etk::Vector<rabbit::ExceptionTrap> _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<int64_t> _typecheck;
rabbit::ObjectPtr *_outervalues;
uint64_t _noutervalues;
rabbit::WeakRef *_env;
SQFUNCTION _function;
SQObjectPtr _name;
rabbit::ObjectPtr _name;
};

118
rabbit/sqcompiler.cpp
View File

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

4
rabbit/sqcompiler.hpp
View File

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

52
rabbit/sqconfig.hpp
View File

@ -31,18 +31,19 @@ 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 <wchar.h>
#include <wctype.h>
typedef wchar_t SQChar;
namespace rabbit {
using Char = wchar_t;
}
#define scstrcmp wcscmp
#ifdef _WIN32
#define scsprintf _snwprintf
@ -70,10 +71,7 @@ typedef wchar_t SQChar;
#define WCHAR_SHIFT_MUL 2
#define MAX_CHAR 0xFFFFFFFF
#endif
#define _SC(a) L##a
#define scisspace iswspace
#define scisdigit iswdigit
#define scisprint iswprint
@ -81,12 +79,11 @@ typedef wchar_t SQChar;
#define scisalpha iswalpha
#define sciscntrl iswcntrl
#define scisalnum iswalnum
#define sq_rsl(l) ((l)<<WCHAR_SHIFT_MUL)
#else
typedef char SQChar;
namespace rabbit {
using Char = char;
}
#define _SC(a) a
#define scstrcmp strcmp
#ifdef _MSC_VER
@ -124,3 +121,28 @@ typedef char SQChar;
#define _PRINT_INT_PREC _SC("ll")
#define _PRINT_INT_FMT _SC("%ld")
#define SQTrue (1)
#define SQFalse (0)
struct SQTable;
struct SQString;
struct SQClosure;
struct SQGenerator;
struct SQNativeClosure;
struct SQFunctionProto;
struct SQClass;
struct SQInstance;
struct SQOuter;
struct SQSharedState;
namespace rabbit {
class UserData;
class Array;
class RefCounted;
class WeakRef;
class VirtualMachine;
class Delegable;
class FunctionInfo;
class StackInfos;
class MemberHandle;
}

56
rabbit/sqdebug.cpp
View File

@ -13,7 +13,7 @@
#include <rabbit/sqclosure.hpp>
#include <rabbit/sqstring.hpp>
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));
}

46
rabbit/sqfuncproto.hpp
View File

@ -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<SQLocalVarInfo> SQLocalVarInfoVec;
typedef etk::Vector<SQLineInfo> 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;

66
rabbit/sqfuncstate.cpp
View File

@ -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<rabbit::ObjectPtr> 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; i<outers; i++) {
@ -402,13 +402,13 @@ int64_t SQFuncState::getOuterVariable(const SQObject &name)
if(pos == -1) {
pos = _parent->getOuterVariable(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;

46
rabbit/sqfuncstate.hpp
View File

@ -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<int64_t> _targetstack;
int64_t _stacksize;
bool _varparams;
bool _bgenerator;
SQIntVec _unresolvedbreaks;
SQIntVec _unresolvedcontinues;
SQObjectPtrVec _functions;
SQObjectPtrVec _parameters;
etk::Vector<int64_t> _unresolvedbreaks;
etk::Vector<int64_t> _unresolvedcontinues;
etk::Vector<rabbit::ObjectPtr> _functions;
etk::Vector<rabbit::ObjectPtr> _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<int64_t> _scope_blocks;
etk::Vector<int64_t> _breaktargets;
etk::Vector<int64_t> _continuetargets;
etk::Vector<int64_t> _defaultparams;
int64_t _lastline;
int64_t _traps; //contains number of nested exception traps
int64_t _outers;
bool _optimization;
SQSharedState *_sharedstate;
etk::Vector<SQFuncState*> _childstates;
int64_t getConstant(const SQObject &cons);
int64_t getConstant(const rabbit::Object &cons);
private:
compilererrorFunc _errfunc;
void *_errtarget;

60
rabbit/sqlexer.cpp
View File

@ -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)) ) {

20
rabbit/sqlexer.hpp
View File

@ -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<SQChar> _longstr;
etk::Vector<rabbit::Char> _longstr;
compilererrorFunc _errfunc;
void *_errtarget;
};

155
rabbit/sqobject.cpp
View File

@ -15,42 +15,7 @@
#include <rabbit/sqclass.hpp>
#include <rabbit/sqclosure.hpp>
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<target; n++) {
_stack[n] = v->_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<size; n++) {
v->_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<nvars;i++){
if(_localvarinfos[i]._start_op<=nop && _localvarinfos[i]._end_op>=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));

263
rabbit/sqobject.hpp
View File

@ -23,48 +23,6 @@
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) { \
for(int64_t n = 0; n < ((int64_t)size); n++) { \
new (&ptr[n]) type(); \
@ -89,228 +47,13 @@ enum SQMetaMethod{
} \
}
#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<SQObjectPtr> SQObjectPtrVec;
typedef etk::Vector<int64_t> SQIntVec;
const SQChar *getTypeName(const SQObjectPtr &obj1);
const SQChar *IdType2Name(SQObjectType type);

2
rabbit/sqopcodes.hpp
View File

@ -108,7 +108,7 @@ enum SQOpcode
};
struct SQInstructionDesc {
const SQChar *name;
const rabbit::Char *name;
};
struct SQInstruction

48
rabbit/sqstate.cpp
View File

@ -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<int64_t> &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<rabbit::ObjectPtr>);
sq_new(_systemstrings,etk::Vector<rabbit::ObjectPtr>);
sq_new(_types,etk::Vector<rabbit::ObjectPtr>);
_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<rabbit::ObjectPtr>);
sq_delete(_systemstrings,etk::Vector<rabbit::ObjectPtr>);
sq_delete(_metamethods,etk::Vector<rabbit::ObjectPtr>);
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);

88
rabbit/sqstate.hpp
View File

@ -9,6 +9,8 @@
#include <rabbit/squtils.hpp>
#include <rabbit/sqobject.hpp>
#include <rabbit/RegFunction.hpp>
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,57 +57,57 @@ 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<rabbit::ObjectPtr> *_metamethods;
rabbit::ObjectPtr _metamethodsmap;
etk::Vector<rabbit::ObjectPtr> *_systemstrings;
etk::Vector<rabbit::ObjectPtr> *_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;
};
@ -123,6 +125,6 @@ private:
#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<int64_t> &res,const rabbit::Char *typemask);

8
rabbit/sqstring.hpp
View File

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

26
rabbit/sqtable.cpp
View File

@ -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; i<oldsize; i++) {
_HashNode *old = nold+i;
if (sq_type(old->key) != OT_NULL)
if (sq_type(old->key) != rabbit::OT_NULL)
newSlot(old->key,old->val);
}
for(int64_t k=0;k<oldsize;k++)
@ -99,7 +99,7 @@ SQTable *SQTable::clone()
nt->_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) {

46
rabbit/sqtable.hpp
View File

@ -14,28 +14,38 @@
*/
#include <rabbit/sqstring.hpp>
#include <rabbit/Delegable.hpp>
#include <rabbit/squtils.hpp>
#include <etk/Allocator.hpp>
#include <rabbit/Object.hpp>
#include <rabbit/WeakRef.hpp>
#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();