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) int64_t quit(rabbit::VirtualMachine* v)
{ {
int *done; int *done;
sq_getuserpointer(v,-1,(SQUserPointer*)&done); sq_getuserpointer(v,-1,(rabbit::UserPointer*)&done);
*done=1; *done=1;
return 0; 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_list vl;
va_start(vl, s); va_start(vl, s);
@ -64,7 +64,7 @@ void printfunc(rabbit::VirtualMachine* SQ_UNUSED_ARG(v),const SQChar *s,...)
va_end(vl); 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_list vl;
va_start(vl, s); va_start(vl, s);
@ -98,7 +98,7 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
int i; int i;
int compiles_only = 0; int compiles_only = 0;
#ifdef SQUNICODE #ifdef SQUNICODE
static SQChar temp[500]; static rabbit::Char temp[500];
#endif #endif
char * output = NULL; char * output = NULL;
*retval = 0; *retval = 0;
@ -147,7 +147,7 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
// src file // src file
if(arg<argc) { if(arg<argc) {
const SQChar *filename=NULL; const rabbit::Char *filename=NULL;
#ifdef SQUNICODE #ifdef SQUNICODE
mbstowcs(temp,argv[arg],strlen(argv[arg])); mbstowcs(temp,argv[arg],strlen(argv[arg]));
filename=temp; filename=temp;
@ -164,11 +164,11 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
//sq_pop(v,1); //sq_pop(v,1);
if(compiles_only) { if(compiles_only) {
if(SQ_SUCCEEDED(sqstd_loadfile(v,filename,SQTrue))){ if(SQ_SUCCEEDED(sqstd_loadfile(v,filename,SQTrue))){
const SQChar *outfile = _SC("out.karrot"); const rabbit::Char *outfile = _SC("out.karrot");
if(output) { if(output) {
#ifdef SQUNICODE #ifdef SQUNICODE
int len = (int)(strlen(output)+1); 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); outfile = sq_getscratchpad(v,-1);
#else #else
outfile = output; outfile = output;
@ -187,10 +187,10 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
sq_pushroottable(v); sq_pushroottable(v);
for(i=arg;i<argc;i++) for(i=arg;i<argc;i++)
{ {
const SQChar *a; const rabbit::Char *a;
#ifdef SQUNICODE #ifdef SQUNICODE
int alen=(int)strlen(argv[i]); 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); mbstowcs(sq_getscratchpad(v,-1),argv[i],alen);
sq_getscratchpad(v,-1)[alen] = _SC('\0'); sq_getscratchpad(v,-1)[alen] = _SC('\0');
#else #else
@ -201,8 +201,8 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
//sq_arrayappend(v,-2); //sq_arrayappend(v,-2);
} }
if(SQ_SUCCEEDED(sq_call(v,callargs,SQTrue,SQTrue))) { if(SQ_SUCCEEDED(sq_call(v,callargs,SQTrue,SQTrue))) {
SQObjectType type = sq_gettype(v,-1); rabbit::ObjectType type = sq_gettype(v,-1);
if(type == OT_INTEGER) { if(type == rabbit::OT_INTEGER) {
*retval = type; *retval = type;
sq_getinteger(v,-1,retval); 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 //if this point is reached an error occurred
{ {
const SQChar *err; const rabbit::Char *err;
sq_getlasterror(v); sq_getlasterror(v);
if(SQ_SUCCEEDED(sq_getstring(v,-1,&err))) { if(SQ_SUCCEEDED(sq_getstring(v,-1,&err))) {
scprintf(_SC("error [%s]\n"),err); scprintf(_SC("error [%s]\n"),err);
@ -235,7 +235,7 @@ void Interactive(rabbit::VirtualMachine* v)
{ {
#define MAXINPUT 1024 #define MAXINPUT 1024
SQChar buffer[MAXINPUT]; rabbit::Char buffer[MAXINPUT];
int64_t blocks =0; int64_t blocks =0;
int64_t string=0; int64_t string=0;
int64_t retval=0; int64_t retval=0;
@ -266,28 +266,28 @@ void Interactive(rabbit::VirtualMachine* v)
else if(blocks==0)break; else if(blocks==0)break;
buffer[i++] = _SC('\n'); 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){ else if(c==_SC('{') && !string){
blocks++; blocks++;
buffer[i++] = (SQChar)c; buffer[i++] = (rabbit::Char)c;
} }
else if(c==_SC('"') || c==_SC('\'')){ else if(c==_SC('"') || c==_SC('\'')){
string=!string; string=!string;
buffer[i++] = (SQChar)c; buffer[i++] = (rabbit::Char)c;
} }
else if (i >= MAXINPUT-1) { else if (i >= MAXINPUT-1) {
scfprintf(stderr, _SC("sq : input line too long\n")); scfprintf(stderr, _SC("sq : input line too long\n"));
break; break;
} }
else{ else{
buffer[i++] = (SQChar)c; buffer[i++] = (rabbit::Char)c;
} }
} }
buffer[i] = _SC('\0'); buffer[i] = _SC('\0');
if(buffer[0]==_SC('=')){ if(buffer[0]==_SC('=')){
scsprintf(sq_getscratchpad(v,MAXINPUT),(size_t)MAXINPUT,_SC("return (%s)"),&buffer[1]); 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; retval=1;
} }
i=scstrlen(buffer); i=scstrlen(buffer);

6
etc/minimal.cpp
View File

@ -18,7 +18,7 @@
#define scvprintf vfprintf #define scvprintf vfprintf
#endif #endif
void printfunc(HSQUIRRELVM v,const SQChar *s,...) void printfunc(HSQUIRRELVM v,const rabbit::Char *s,...)
{ {
va_list vl; va_list vl;
va_start(vl, s); va_start(vl, s);
@ -26,7 +26,7 @@ void printfunc(HSQUIRRELVM v,const SQChar *s,...)
va_end(vl); va_end(vl);
} }
void errorfunc(HSQUIRRELVM v,const SQChar *s,...) void errorfunc(HSQUIRRELVM v,const rabbit::Char *s,...)
{ {
va_list vl; va_list vl;
va_start(vl, s); va_start(vl, s);
@ -34,7 +34,7 @@ void errorfunc(HSQUIRRELVM v,const SQChar *s,...)
va_end(vl); 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 int64_t top = sq_gettop(v); //saves the stack size before the call
sq_pushroottable(v); //pushes the global table 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/sqfuncstate.cpp',
'rabbit/RefCounted.cpp', 'rabbit/RefCounted.cpp',
'rabbit/WeakRef.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.compile_version("c++", 2011)
my_module.add_depend([ my_module.add_depend([
@ -72,7 +83,19 @@ def configure(target, my_module):
'rabbit/sqtable.hpp', 'rabbit/sqtable.hpp',
'rabbit/RefCounted.hpp', 'rabbit/RefCounted.hpp',
'rabbit/WeakRef.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 return True

48
rabbit-std/sqstdaux.cpp
View File

@ -14,18 +14,18 @@ void sqstd_printcallstack(rabbit::VirtualMachine* v)
{ {
SQPRINTFUNCTION pf = sq_geterrorfunc(v); SQPRINTFUNCTION pf = sq_geterrorfunc(v);
if(pf) { if(pf) {
SQStackInfos si; rabbit::StackInfos si;
int64_t i; int64_t i;
float_t f; float_t f;
const SQChar *s; const rabbit::Char *s;
int64_t level=1; //1 is to skip this function that is level 0 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; int64_t seq=0;
pf(v,_SC("\nCALLSTACK\n")); pf(v,_SC("\nCALLSTACK\n"));
while(SQ_SUCCEEDED(sq_stackinfos(v,level,&si))) while(SQ_SUCCEEDED(sq_stackinfos(v,level,&si)))
{ {
const SQChar *fn=_SC("unknown"); const rabbit::Char *fn=_SC("unknown");
const SQChar *src=_SC("unknown"); const rabbit::Char *src=_SC("unknown");
if(si.funcname)fn=si.funcname; if(si.funcname)fn=si.funcname;
if(si.source)src=si.source; if(si.source)src=si.source;
pf(v,_SC("*FUNCTION [%s()] %s line [%d]\n"),fn,src,si.line); pf(v,_SC("*FUNCTION [%s()] %s line [%d]\n"),fn,src,si.line);
@ -41,56 +41,56 @@ void sqstd_printcallstack(rabbit::VirtualMachine* v)
seq++; seq++;
switch(sq_gettype(v,-1)) switch(sq_gettype(v,-1))
{ {
case OT_NULL: case rabbit::OT_NULL:
pf(v,_SC("[%s] NULL\n"),name); pf(v,_SC("[%s] NULL\n"),name);
break; break;
case OT_INTEGER: case rabbit::OT_INTEGER:
sq_getinteger(v,-1,&i); sq_getinteger(v,-1,&i);
pf(v,_SC("[%s] %d\n"),name,i); pf(v,_SC("[%s] %d\n"),name,i);
break; break;
case OT_FLOAT: case rabbit::OT_FLOAT:
sq_getfloat(v,-1,&f); sq_getfloat(v,-1,&f);
pf(v,_SC("[%s] %.14g\n"),name,f); pf(v,_SC("[%s] %.14g\n"),name,f);
break; break;
case OT_USERPOINTER: case rabbit::OT_USERPOINTER:
pf(v,_SC("[%s] USERPOINTER\n"),name); pf(v,_SC("[%s] USERPOINTER\n"),name);
break; break;
case OT_STRING: case rabbit::OT_STRING:
sq_getstring(v,-1,&s); sq_getstring(v,-1,&s);
pf(v,_SC("[%s] \"%s\"\n"),name,s); pf(v,_SC("[%s] \"%s\"\n"),name,s);
break; break;
case OT_TABLE: case rabbit::OT_TABLE:
pf(v,_SC("[%s] TABLE\n"),name); pf(v,_SC("[%s] TABLE\n"),name);
break; break;
case OT_ARRAY: case rabbit::OT_ARRAY:
pf(v,_SC("[%s] ARRAY\n"),name); pf(v,_SC("[%s] ARRAY\n"),name);
break; break;
case OT_CLOSURE: case rabbit::OT_CLOSURE:
pf(v,_SC("[%s] CLOSURE\n"),name); pf(v,_SC("[%s] CLOSURE\n"),name);
break; break;
case OT_NATIVECLOSURE: case rabbit::OT_NATIVECLOSURE:
pf(v,_SC("[%s] NATIVECLOSURE\n"),name); pf(v,_SC("[%s] NATIVECLOSURE\n"),name);
break; break;
case OT_GENERATOR: case rabbit::OT_GENERATOR:
pf(v,_SC("[%s] GENERATOR\n"),name); pf(v,_SC("[%s] GENERATOR\n"),name);
break; break;
case OT_USERDATA: case rabbit::OT_USERDATA:
pf(v,_SC("[%s] USERDATA\n"),name); pf(v,_SC("[%s] USERDATA\n"),name);
break; break;
case OT_THREAD: case rabbit::OT_THREAD:
pf(v,_SC("[%s] THREAD\n"),name); pf(v,_SC("[%s] THREAD\n"),name);
break; break;
case OT_CLASS: case rabbit::OT_CLASS:
pf(v,_SC("[%s] CLASS\n"),name); pf(v,_SC("[%s] CLASS\n"),name);
break; break;
case OT_INSTANCE: case rabbit::OT_INSTANCE:
pf(v,_SC("[%s] INSTANCE\n"),name); pf(v,_SC("[%s] INSTANCE\n"),name);
break; break;
case OT_WEAKREF: case rabbit::OT_WEAKREF:
pf(v,_SC("[%s] WEAKREF\n"),name); pf(v,_SC("[%s] WEAKREF\n"),name);
break; break;
case OT_BOOL:{ case rabbit::OT_BOOL:{
SQBool bval; rabbit::Bool bval;
sq_getbool(v,-1,&bval); sq_getbool(v,-1,&bval);
pf(v,_SC("[%s] %s\n"),name,bval == SQTrue ? _SC("true"):_SC("false")); 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); SQPRINTFUNCTION pf = sq_geterrorfunc(v);
if(pf) { if(pf) {
const SQChar *sErr = 0; const rabbit::Char *sErr = 0;
if(sq_gettop(v)>=1) { if(sq_gettop(v)>=1) {
if(SQ_SUCCEEDED(sq_getstring(v,2,&sErr))) { if(SQ_SUCCEEDED(sq_getstring(v,2,&sErr))) {
pf(v,_SC("\nAN ERROR HAS OCCURRED [%s]\n"),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; 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); SQPRINTFUNCTION pf = sq_geterrorfunc(v);
if(pf) { if(pf) {

26
rabbit-std/sqstdblob.cpp
View File

@ -14,7 +14,7 @@
#define SETUP_BLOB(v) \ #define SETUP_BLOB(v) \
SQBlob *self = NULL; \ 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")); } \ return sq_throwerror(v,_SC("invalid type tag")); } \
if(!self || !self->IsValid()) \ if(!self || !self->IsValid()) \
return sq_throwerror(v,_SC("the blob is invalid")); 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) static int64_t _blob__nexti(rabbit::VirtualMachine* v)
{ {
SETUP_BLOB(v); SETUP_BLOB(v);
if(sq_gettype(v,2) == OT_NULL) { if(sq_gettype(v,2) == rabbit::OT_NULL) {
sq_pushinteger(v, 0); sq_pushinteger(v, 0);
return 1; return 1;
} }
@ -120,7 +120,7 @@ static int64_t _blob__typeof(rabbit::VirtualMachine* v)
return 1; 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; SQBlob *self = (SQBlob*)p;
self->~SQBlob(); self->~SQBlob();
@ -152,7 +152,7 @@ static int64_t _blob__cloned(rabbit::VirtualMachine* v)
{ {
SQBlob *other = NULL; 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; return SQ_ERROR;
} }
//SQBlob *thisone = new SQBlob(other->Len()); //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} #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(constructor,-1,_SC("xn")),
_DECL_BLOB_FUNC(resize,2,_SC("xn")), _DECL_BLOB_FUNC(resize,2,_SC("xn")),
_DECL_BLOB_FUNC(swap2,1,_SC("x")), _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} #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(casti2f,2,_SC(".n")),
_DECL_GLOBALBLOB_FUNC(castf2i,2,_SC(".n")), _DECL_GLOBALBLOB_FUNC(castf2i,2,_SC(".n")),
_DECL_GLOBALBLOB_FUNC(swap2,2,_SC(".n")), _DECL_GLOBALBLOB_FUNC(swap2,2,_SC(".n")),
@ -239,10 +239,10 @@ static const SQRegFunction bloblib_funcs[]={
{NULL,(SQFUNCTION)0,0,NULL} {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; 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 -1;
*ptr = blob->getBuf(); *ptr = blob->getBuf();
return SQ_OK; 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) int64_t sqstd_getblobsize(rabbit::VirtualMachine* v,int64_t idx)
{ {
SQBlob *blob; 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 -1;
return blob->Len(); 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); int64_t top = sq_gettop(v);
sq_pushregistrytable(v); sq_pushregistrytable(v);
@ -267,7 +267,7 @@ SQUserPointer sqstd_createblob(rabbit::VirtualMachine* v, int64_t size)
sq_pushinteger(v,size); //size sq_pushinteger(v,size); //size
SQBlob *blob = NULL; SQBlob *blob = NULL;
if(SQ_SUCCEEDED(sq_call(v,2,SQTrue,SQFalse)) 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); sq_remove(v,-2);
return blob->getBuf(); return blob->getBuf();
} }
@ -276,8 +276,8 @@ SQUserPointer sqstd_createblob(rabbit::VirtualMachine* v, int64_t size)
return NULL; 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 #pragma once
RABBIT_API SQUserPointer sqstd_createblob(rabbit::VirtualMachine* v, int64_t size); RABBIT_API rabbit::UserPointer sqstd_createblob(rabbit::VirtualMachine* v, int64_t size);
RABBIT_API SQRESULT sqstd_getblob(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer *ptr); 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 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 Flush() { return 0; }
int64_t Tell() { return _ptr; } int64_t Tell() { return _ptr; }
int64_t Len() { return _size; } int64_t Len() { return _size; }
SQUserPointer getBuf(){ return _buf; } rabbit::UserPointer getBuf(){ return _buf; }
private: private:
int64_t _size; int64_t _size;
int64_t _allocated; 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)) #define SQSTD_FILE_TYPE_TAG ((uint64_t)(SQSTD_STREAM_TYPE_TAG | 0x00000001))
//basic API //basic API
SQFILE sqstd_fopen(const SQChar *filename ,const SQChar *mode) SQFILE sqstd_fopen(const rabbit::Char *filename ,const rabbit::Char *mode)
{ {
#ifndef SQUNICODE #ifndef SQUNICODE
return (SQFILE)fopen(filename,mode); 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; 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); return (int64_t)fwrite(buffer,size,count,(FILE *)file);
} }
@ -71,7 +71,7 @@ struct SQFile : public SQStream {
SQFile() { _handle = NULL; _owns = false;} SQFile() { _handle = NULL; _owns = false;}
SQFile(SQFILE file, bool owns) { _handle = file; _owns = owns;} SQFile(SQFILE file, bool owns) { _handle = file; _owns = owns;}
virtual ~SQFile() { close(); } virtual ~SQFile() { close(); }
bool Open(const SQChar *filename ,const SQChar *mode) { bool Open(const rabbit::Char *filename ,const rabbit::Char *mode) {
close(); close();
if( (_handle = sqstd_fopen(filename,mode)) ) { if( (_handle = sqstd_fopen(filename,mode)) ) {
_owns = true; _owns = true;
@ -122,7 +122,7 @@ static int64_t _file__typeof(rabbit::VirtualMachine* v)
return 1; 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; SQFile *self = (SQFile*)p;
self->~SQFile(); 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) static int64_t _file_constructor(rabbit::VirtualMachine* v)
{ {
const SQChar *filename,*mode; const rabbit::Char *filename,*mode;
bool owns = true; bool owns = true;
SQFile *f; SQFile *f;
SQFILE newf; 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, 2, &filename);
sq_getstring(v, 3, &mode); sq_getstring(v, 3, &mode);
newf = sqstd_fopen(filename, mode); newf = sqstd_fopen(filename, mode);
if(!newf) return sq_throwerror(v, _SC("cannot open file")); if(!newf) return sq_throwerror(v, _SC("cannot open file"));
} else if(sq_gettype(v,2) == OT_USERPOINTER) { } else if(sq_gettype(v,2) == rabbit::OT_USERPOINTER) {
owns = !(sq_gettype(v,3) == OT_NULL); owns = !(sq_gettype(v,3) == rabbit::OT_NULL);
sq_getuserpointer(v,2,&newf); sq_getuserpointer(v,2,&newf);
} else { } else {
return sq_throwerror(v,_SC("wrong parameter")); 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) static int64_t _file_close(rabbit::VirtualMachine* v)
{ {
SQFile *self = NULL; 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 != NULL)
{ {
self->close(); self->close();
@ -171,7 +171,7 @@ static int64_t _file_close(rabbit::VirtualMachine* v)
//bindings //bindings
#define _DECL_FILE_FUNC(name,nparams,typecheck) {_SC(#name),_file_##name,nparams,typecheck} #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(constructor,3,_SC("x")),
_DECL_FILE_FUNC(_typeof,1,_SC("x")), _DECL_FILE_FUNC(_typeof,1,_SC("x")),
_DECL_FILE_FUNC(close,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); int64_t top = sq_gettop(v);
sq_pushregistrytable(v); sq_pushregistrytable(v);
@ -204,10 +204,10 @@ SQRESULT sqstd_createfile(rabbit::VirtualMachine* v, SQFILE file,SQBool own)
return SQ_ERROR; 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; 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(); *file = fileobj->getHandle();
return SQ_OK; return SQ_OK;
} }
@ -265,7 +265,7 @@ int64_t _read_two_bytes(IOBuffer *iobuffer)
return 0; 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; IOBuffer *iobuffer = (IOBuffer *)iobuf;
return _read_byte(iobuffer); return _read_byte(iobuffer);
@ -273,7 +273,7 @@ static int64_t _io_file_lexfeed_PLAIN(SQUserPointer iobuf)
} }
#ifdef SQUNICODE #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; IOBuffer *iobuffer = (IOBuffer *)iobuf;
#define READ(iobuf) \ #define READ(iobuf) \
@ -312,7 +312,7 @@ static int64_t _io_file_lexfeed_UTF8(SQUserPointer iobuf)
} }
#endif #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; int64_t ret;
IOBuffer *iobuffer = (IOBuffer *)iobuf; IOBuffer *iobuffer = (IOBuffer *)iobuf;
@ -321,7 +321,7 @@ static int64_t _io_file_lexfeed_UCS2_LE(SQUserPointer iobuf)
return 0; 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; int64_t c;
IOBuffer *iobuffer = (IOBuffer *)iobuf; IOBuffer *iobuffer = (IOBuffer *)iobuf;
@ -332,19 +332,19 @@ static int64_t _io_file_lexfeed_UCS2_BE(SQUserPointer iobuf)
return 0; 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; int64_t ret;
if( ( ret = sqstd_fread(buf,1,size,(SQFILE)file ))!=0 )return ret; if( ( ret = sqstd_fread(buf,1,size,(SQFILE)file ))!=0 )return ret;
return -1; 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); 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")); 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")); 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 //at least one entry must exist in order for us to push it as the environment
if(sq_gettop(v) == 0) if(sq_gettop(v) == 0)
@ -421,7 +421,7 @@ SQRESULT sqstd_dofile(rabbit::VirtualMachine* v,const SQChar *filename,SQBool re
return SQ_ERROR; 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+")); SQFILE file = sqstd_fopen(filename,_SC("wb+"));
if(!file) return sq_throwerror(v,_SC("cannot open the file")); 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) int64_t _g_io_loadfile(rabbit::VirtualMachine* v)
{ {
const SQChar *filename; const rabbit::Char *filename;
SQBool printerror = SQFalse; rabbit::Bool printerror = SQFalse;
sq_getstring(v,2,&filename); sq_getstring(v,2,&filename);
if(sq_gettop(v) >= 3) { if(sq_gettop(v) >= 3) {
sq_getbool(v,3,&printerror); 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) int64_t _g_io_writeclosuretofile(rabbit::VirtualMachine* v)
{ {
const SQChar *filename; const rabbit::Char *filename;
sq_getstring(v,2,&filename); sq_getstring(v,2,&filename);
if(SQ_SUCCEEDED(sqstd_writeclosuretofile(v,filename))) if(SQ_SUCCEEDED(sqstd_writeclosuretofile(v,filename)))
return 1; return 1;
@ -457,8 +457,8 @@ int64_t _g_io_writeclosuretofile(rabbit::VirtualMachine* v)
int64_t _g_io_dofile(rabbit::VirtualMachine* v) int64_t _g_io_dofile(rabbit::VirtualMachine* v)
{ {
const SQChar *filename; const rabbit::Char *filename;
SQBool printerror = SQFalse; rabbit::Bool printerror = SQFalse;
sq_getstring(v,2,&filename); sq_getstring(v,2,&filename);
if(sq_gettop(v) >= 3) { if(sq_gettop(v) >= 3) {
sq_getbool(v,3,&printerror); 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} #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(loadfile,-2,_SC(".sb")),
_DECL_GLOBALIO_FUNC(dofile,-2,_SC(".sb")), _DECL_GLOBALIO_FUNC(dofile,-2,_SC(".sb")),
_DECL_GLOBALIO_FUNC(writeclosuretofile,3,_SC(".sc")), _DECL_GLOBALIO_FUNC(writeclosuretofile,3,_SC(".sc")),
{NULL,(SQFUNCTION)0,0,NULL} {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); int64_t top = sq_gettop(v);
//create delegate //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); sq_pushstring(v,_SC("stdout"),-1);
sqstd_createfile(v,stdout,SQFalse); sqstd_createfile(v,stdout,SQFalse);
sq_newslot(v,-3,SQFalse); sq_newslot(v,-3,SQFalse);

18
rabbit-std/sqstdio.hpp
View File

@ -27,22 +27,22 @@ struct SQStream {
typedef void* SQFILE; typedef void* SQFILE;
RABBIT_API SQFILE sqstd_fopen(const SQChar *,const SQChar *); RABBIT_API SQFILE sqstd_fopen(const rabbit::Char *,const rabbit::Char *);
RABBIT_API int64_t sqstd_fread(SQUserPointer, int64_t, int64_t, SQFILE); RABBIT_API int64_t sqstd_fread(rabbit::UserPointer, int64_t, int64_t, SQFILE);
RABBIT_API int64_t sqstd_fwrite(const SQUserPointer, 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_fseek(SQFILE , int64_t , int64_t);
RABBIT_API int64_t sqstd_ftell(SQFILE); RABBIT_API int64_t sqstd_ftell(SQFILE);
RABBIT_API int64_t sqstd_fflush(SQFILE); RABBIT_API int64_t sqstd_fflush(SQFILE);
RABBIT_API int64_t sqstd_fclose(SQFILE); RABBIT_API int64_t sqstd_fclose(SQFILE);
RABBIT_API int64_t sqstd_feof(SQFILE); RABBIT_API int64_t sqstd_feof(SQFILE);
RABBIT_API SQRESULT sqstd_createfile(rabbit::VirtualMachine* v, SQFILE file,SQBool own); RABBIT_API rabbit::Result sqstd_createfile(rabbit::VirtualMachine* v, SQFILE file,rabbit::Bool own);
RABBIT_API SQRESULT sqstd_getfile(rabbit::VirtualMachine* v, int64_t idx, SQFILE *file); RABBIT_API rabbit::Result sqstd_getfile(rabbit::VirtualMachine* v, int64_t idx, SQFILE *file);
//compiler helpers //compiler helpers
RABBIT_API SQRESULT sqstd_loadfile(rabbit::VirtualMachine* v,const SQChar *filename,SQBool printerror); RABBIT_API rabbit::Result sqstd_loadfile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool printerror);
RABBIT_API SQRESULT sqstd_dofile(rabbit::VirtualMachine* v,const SQChar *filename,SQBool retval,SQBool printerror); RABBIT_API rabbit::Result sqstd_dofile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool retval,rabbit::Bool printerror);
RABBIT_API SQRESULT sqstd_writeclosuretofile(rabbit::VirtualMachine* v,const SQChar *filename); 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) SINGLE_ARG_FUNC(exp)
#define _DECL_FUNC(name,nparams,tycheck) {_SC(#name),math_##name,nparams,tycheck} #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(sqrt,2,_SC(".n")),
_DECL_FUNC(sin,2,_SC(".n")), _DECL_FUNC(sin,2,_SC(".n")),
_DECL_FUNC(cos,2,_SC(".n")), _DECL_FUNC(cos,2,_SC(".n")),
@ -93,7 +93,7 @@ static const SQRegFunction mathlib_funcs[] = {
#define M_PI (3.14159265358979323846) #define M_PI (3.14159265358979323846)
#endif #endif
SQRESULT sqstd_register_mathlib(rabbit::VirtualMachine* v) rabbit::Result sqstd_register_mathlib(rabbit::VirtualMachine* v)
{ {
int64_t i=0; int64_t i=0;
while(mathlib_funcs[i].name!=0) { while(mathlib_funcs[i].name!=0) {

2
rabbit-std/sqstdmath.hpp
View File

@ -9,5 +9,5 @@
#include <rabbit/rabbit.hpp> #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 #ifdef _DEBUG
#include <stdio.h> #include <stdio.h>
static const SQChar *g_nnames[] = static const rabbit::Char *g_nnames[] =
{ {
_SC("NONE"),_SC("OP_GREEDY"), _SC("OP_OR"), _SC("NONE"),_SC("OP_GREEDY"), _SC("OP_OR"),
_SC("OP_EXPR"),_SC("OP_NOCAPEXPR"),_SC("OP_DOT"), _SC("OP_CLASS"), _SC("OP_EXPR"),_SC("OP_NOCAPEXPR"),_SC("OP_DOT"), _SC("OP_CLASS"),
@ -60,9 +60,9 @@ typedef struct tagSQRexNode{
}SQRexNode; }SQRexNode;
struct SQRex{ struct SQRex{
const SQChar *_eol; const rabbit::Char *_eol;
const SQChar *_bol; const rabbit::Char *_bol;
const SQChar *_p; const rabbit::Char *_p;
int64_t _first; int64_t _first;
int64_t _op; int64_t _op;
SQRexNode *_nodes; SQRexNode *_nodes;
@ -72,7 +72,7 @@ struct SQRex{
SQRexMatch *_matches; SQRexMatch *_matches;
int64_t _currsubexp; int64_t _currsubexp;
void *_jmpbuf; void *_jmpbuf;
const SQChar **_error; const rabbit::Char **_error;
}; };
static int64_t sqstd_rex_list(SQRex *exp); 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; 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; if(exp->_error) *exp->_error = error;
longjmp(*((jmp_buf*)exp->_jmpbuf),-1); longjmp(*((jmp_buf*)exp->_jmpbuf),-1);
@ -106,7 +106,7 @@ static void sqstd_rex_expect(SQRex *exp, int64_t n){
exp->_p++; exp->_p++;
} }
static SQChar sqstd_rex_escapechar(SQRex *exp) static rabbit::Char sqstd_rex_escapechar(SQRex *exp)
{ {
if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR){ if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR){
exp->_p++; exp->_p++;
@ -129,9 +129,9 @@ static int64_t sqstd_rex_charclass(SQRex *exp,int64_t classid)
return n; 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) { if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR) {
exp->_p++; exp->_p++;
switch(*exp->_p) { switch(*exp->_p) {
@ -149,7 +149,7 @@ static int64_t sqstd_rex_charnode(SQRex *exp,SQBool isclass)
} }
case 'm': 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' cb = *++exp->_p; //skip 'm'
ce = *++exp->_p; ce = *++exp->_p;
exp->_p++; //points to the next char to be parsed 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; unsigned short p0 = 0, p1 = 0;
switch(*exp->_p){ switch(*exp->_p){
case SQREX_SYMBOL_GREEDY_ZERO_OR_MORE: p0 = 0; p1 = 0xFFFF; exp->_p++; isgreedy = SQTrue; break; 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; 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) { switch(cclass) {
case 'a': return isalpha(c)?SQTrue:SQFalse; 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*/ 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 { do {
switch(node->type) { switch(node->type) {
@ -390,7 +390,7 @@ static SQBool sqstd_rex_matchclass(SQRex* exp,SQRexNode *node,SQChar c)
return SQFalse; 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; 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 = (node->next != -1) ? &exp->_nodes[node->next] : NULL;
SQRexNode *greedystop = NULL; SQRexNode *greedystop = NULL;
int64_t p0 = (node->right >> 16)&0x0000FFFF, p1 = node->right&0x0000FFFF, nmaches = 0; 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) { if(node->next != -1) {
greedystop = &exp->_nodes[node->next]; 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)) { while((nmaches == 0xFFFF || nmaches < p1)) {
const SQChar *stop; const rabbit::Char *stop;
if(!(s = sqstd_rex_matchnode(exp,&exp->_nodes[node->left],s,greedystop))) if(!(s = sqstd_rex_matchnode(exp,&exp->_nodes[node->left],s,greedystop)))
break; break;
nmaches++; nmaches++;
@ -446,7 +446,7 @@ static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar
return NULL; return NULL;
} }
case OP_OR: { case OP_OR: {
const SQChar *asd = str; const rabbit::Char *asd = str;
SQRexNode *temp=&exp->_nodes[node->left]; SQRexNode *temp=&exp->_nodes[node->left];
while( (asd = sqstd_rex_matchnode(exp,temp,asd,NULL)) ) { while( (asd = sqstd_rex_matchnode(exp,temp,asd,NULL)) ) {
if(temp->next != -1) 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_EXPR:
case OP_NOCAPEXPR:{ case OP_NOCAPEXPR:{
SQRexNode *n = &exp->_nodes[node->left]; SQRexNode *n = &exp->_nodes[node->left];
const SQChar *cur = str; const rabbit::Char *cur = str;
int64_t capture = -1; int64_t capture = -1;
if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) { if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) {
capture = 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 if(*str != cb) return NULL; // string doesnt start with open char
int64_t ce = node->right; //char that closes a balanced expression int64_t ce = node->right; //char that closes a balanced expression
int64_t cont = 1; int64_t cont = 1;
const SQChar *streol = exp->_eol; const rabbit::Char *streol = exp->_eol;
while (++str < streol) { while (++str < streol) {
if (*str == ce) { if (*str == ce) {
if (--cont == 0) { if (--cont == 0) {
@ -558,12 +558,12 @@ static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar
} }
/* public api */ /* 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() SQRex * volatile exp = (SQRex *)sq_malloc(sizeof(SQRex)); // "volatile" is needed for setjmp()
exp->_eol = exp->_bol = NULL; exp->_eol = exp->_bol = NULL;
exp->_p = pattern; 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->_nodes = (SQRexNode *)sq_malloc(exp->_nallocated * sizeof(SQRexNode));
exp->_nsize = 0; exp->_nsize = 0;
exp->_matches = 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->_bol = text;
exp->_eol = text + scstrlen(text); exp->_eol = text + scstrlen(text);
exp->_currsubexp = 0; exp->_currsubexp = 0;
@ -625,9 +625,9 @@ SQBool sqstd_rex_match(SQRex* exp,const SQChar* text)
return SQTrue; 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; int64_t node = exp->_first;
if(text_begin >= text_end) return SQFalse; if(text_begin >= text_end) return SQFalse;
exp->_bol = text_begin; exp->_bol = text_begin;
@ -654,7 +654,7 @@ SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const SQChar* t
return SQTrue; 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); 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; 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; if( n<0 || n >= exp->_nsubexpr) return SQFalse;
*subexp = exp->_matches[n]; *subexp = exp->_matches[n];

20
rabbit-std/sqstdstream.cpp
View File

@ -18,7 +18,7 @@
#define SETUP_STREAM(v) \ #define SETUP_STREAM(v) \
SQStream *self = NULL; \ 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")); \ return sq_throwerror(v,_SC("invalid type tag")); \
if(!self || !self->IsValid()) \ if(!self || !self->IsValid()) \
return sq_throwerror(v,_SC("the stream is invalid")); return sq_throwerror(v,_SC("the stream is invalid"));
@ -26,7 +26,7 @@
int64_t _stream_readblob(rabbit::VirtualMachine* v) int64_t _stream_readblob(rabbit::VirtualMachine* v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
SQUserPointer data,blobp; rabbit::UserPointer data,blobp;
int64_t size,res; int64_t size,res;
sq_getinteger(v,2,&size); sq_getinteger(v,2,&size);
if(size > self->Len()) { if(size > self->Len()) {
@ -106,7 +106,7 @@ int64_t _stream_readn(rabbit::VirtualMachine* v)
int64_t _stream_writeblob(rabbit::VirtualMachine* v) int64_t _stream_writeblob(rabbit::VirtualMachine* v)
{ {
SQUserPointer data; rabbit::UserPointer data;
int64_t size; int64_t size;
SETUP_STREAM(v); SETUP_STREAM(v);
if(SQ_FAILED(sqstd_getblob(v,2,&data))) 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")); 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(readblob,2,_SC("xn")),
_DECL_STREAM_FUNC(readn,2,_SC("xn")), _DECL_STREAM_FUNC(readn,2,_SC("xn")),
_DECL_STREAM_FUNC(writeblob,-2,_SC("xx")), _DECL_STREAM_FUNC(writeblob,-2,_SC("xx")),
@ -266,10 +266,10 @@ void init_streamclass(rabbit::VirtualMachine* v)
if(SQ_FAILED(sq_get(v,-2))) { if(SQ_FAILED(sq_get(v,-2))) {
sq_pushstring(v,_SC("std_stream"),-1); sq_pushstring(v,_SC("std_stream"),-1);
sq_newclass(v,SQFalse); 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; int64_t i = 0;
while(_stream_methods[i].name != 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_pushstring(v,f.name,-1);
sq_newclosure(v,f.f,0); sq_newclosure(v,f.f,0);
sq_setparamscheck(v,f.nparamscheck,f.typemask); sq_setparamscheck(v,f.nparamscheck,f.typemask);
@ -290,9 +290,9 @@ void init_streamclass(rabbit::VirtualMachine* v)
sq_pop(v,1); 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")); return sq_throwerror(v,_SC("table expected"));
int64_t top = sq_gettop(v); int64_t top = sq_gettop(v);
//create delegate //create delegate
@ -305,7 +305,7 @@ SQRESULT declare_stream(rabbit::VirtualMachine* v,const SQChar* name,SQUserPoint
sq_settypetag(v,-1,typetag); sq_settypetag(v,-1,typetag);
int64_t i = 0; int64_t i = 0;
while(methods[i].name != 0) { while(methods[i].name != 0) {
const SQRegFunction &f = methods[i]; const rabbit::RegFunction &f = methods[i];
sq_pushstring(v,f.name,-1); sq_pushstring(v,f.name,-1);
sq_newclosure(v,f.f,0); sq_newclosure(v,f.f,0);
sq_setparamscheck(v,f.nparamscheck,f.typemask); sq_setparamscheck(v,f.nparamscheck,f.typemask);
@ -319,7 +319,7 @@ SQRESULT declare_stream(rabbit::VirtualMachine* v,const SQChar* name,SQUserPoint
i = 0; i = 0;
while(globals[i].name!=0) while(globals[i].name!=0)
{ {
const SQRegFunction &f = globals[i]; const rabbit::RegFunction &f = globals[i];
sq_pushstring(v,f.name,-1); sq_pushstring(v,f.name,-1);
sq_newclosure(v,f.f,0); sq_newclosure(v,f.f,0);
sq_setparamscheck(v,f.nparamscheck,f.typemask); 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); int64_t _stream_flush(rabbit::VirtualMachine* v);
#define _DECL_STREAM_FUNC(name,nparams,typecheck) {_SC(#name),_stream_##name,nparams,typecheck} #define _DECL_STREAM_FUNC(name,nparams,typecheck) {_SC(#name),_stream_##name,nparams,typecheck}
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_FORMAT_LEN 20
#define MAX_WFORMAT_LEN 3 #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) { switch(ch) {
case '-': case '+': case ' ': case '#': case '0': return SQTrue; case '-': case '+': case ' ': case '#': case '0': return SQTrue;
@ -26,10 +26,10 @@ static SQBool isfmtchr(SQChar ch)
return SQFalse; 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; rabbit::Char *dummy;
SQChar swidth[MAX_WFORMAT_LEN]; rabbit::Char swidth[MAX_WFORMAT_LEN];
int64_t wc = 0; int64_t wc = 0;
int64_t start = n; int64_t start = n;
fmt[0] = '%'; fmt[0] = '%';
@ -66,22 +66,22 @@ static int64_t validate_format(rabbit::VirtualMachine* v, SQChar *fmt, const SQC
} }
if (n-start > MAX_FORMAT_LEN ) if (n-start > MAX_FORMAT_LEN )
return sq_throwerror(v,_SC("format too long")); 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'; fmt[(n-start)+2] = '\0';
return n; 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; const rabbit::Char *format;
SQChar *dest; rabbit::Char *dest;
SQChar fmt[MAX_FORMAT_LEN]; rabbit::Char fmt[MAX_FORMAT_LEN];
const SQRESULT res = sq_getstring(v,nformatstringidx,&format); const rabbit::Result res = sq_getstring(v,nformatstringidx,&format);
if (SQ_FAILED(res)) { if (SQ_FAILED(res)) {
return res; // propagate the error return res; // propagate the error
} }
int64_t format_size = sq_getsize(v,nformatstringidx); 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); dest = sq_getscratchpad(v,allocated);
int64_t n = 0,i = 0, nparam = nformatstringidx+1, w = 0; int64_t n = 0,i = 0, nparam = nformatstringidx+1, w = 0;
//while(format[n] != '\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; if(n < 0) return -1;
int64_t addlen = 0; int64_t addlen = 0;
int64_t valtype = 0; int64_t valtype = 0;
const SQChar *ts = NULL; const rabbit::Char *ts = NULL;
int64_t ti = 0; int64_t ti = 0;
float_t tf = 0; float_t tf = 0;
switch(format[n]) { switch(format[n]) {
case 's': case 's':
if(SQ_FAILED(sq_getstring(v,nparam,&ts))) if(SQ_FAILED(sq_getstring(v,nparam,&ts)))
return sq_throwerror(v,_SC("string expected for the specified format")); 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'; valtype = 's';
break; break;
case 'i': case 'd': case 'o': case 'u': case 'x': case 'X': 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); size_t flen = scstrlen(fmt);
int64_t fpos = flen - 1; int64_t fpos = flen - 1;
SQChar f = fmt[fpos]; rabbit::Char f = fmt[fpos];
const SQChar *prec = (const SQChar *)_PRINT_INT_PREC; const rabbit::Char *prec = (const rabbit::Char *)_PRINT_INT_PREC;
while(*prec != _SC('\0')) { while(*prec != _SC('\0')) {
fmt[fpos++] = *prec++; fmt[fpos++] = *prec++;
} }
@ -131,20 +131,20 @@ SQRESULT sqstd_format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t
case 'c': case 'c':
if(SQ_FAILED(sq_getinteger(v,nparam,&ti))) if(SQ_FAILED(sq_getinteger(v,nparam,&ti)))
return sq_throwerror(v,_SC("integer expected for the specified format")); 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'; valtype = 'i';
break; break;
case 'f': case 'g': case 'G': case 'e': case 'E': case 'f': case 'g': case 'G': case 'e': case 'E':
if(SQ_FAILED(sq_getfloat(v,nparam,&tf))) if(SQ_FAILED(sq_getfloat(v,nparam,&tf)))
return sq_throwerror(v,_SC("float expected for the specified format")); 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'; valtype = 'f';
break; break;
default: default:
return sq_throwerror(v,_SC("invalid format")); return sq_throwerror(v,_SC("invalid format"));
} }
n++; n++;
allocated += addlen + sizeof(SQChar); allocated += addlen + sizeof(rabbit::Char);
dest = sq_getscratchpad(v,allocated); dest = sq_getscratchpad(v,allocated);
switch(valtype) { switch(valtype) {
case 's': i += scsprintf(&dest[i],allocated,fmt,ts); break; 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) static int64_t _string_printf(rabbit::VirtualMachine* v)
{ {
SQChar *dest = NULL; rabbit::Char *dest = NULL;
int64_t length = 0; int64_t length = 0;
if(SQ_FAILED(sqstd_format(v,2,&length,&dest))) if(SQ_FAILED(sqstd_format(v,2,&length,&dest)))
return -1; return -1;
@ -175,7 +175,7 @@ static int64_t _string_printf(rabbit::VirtualMachine* v)
static int64_t _string_format(rabbit::VirtualMachine* v) static int64_t _string_format(rabbit::VirtualMachine* v)
{ {
SQChar *dest = NULL; rabbit::Char *dest = NULL;
int64_t length = 0; int64_t length = 0;
if(SQ_FAILED(sqstd_format(v,2,&length,&dest))) if(SQ_FAILED(sqstd_format(v,2,&length,&dest)))
return -1; return -1;
@ -183,27 +183,27 @@ static int64_t _string_format(rabbit::VirtualMachine* v)
return 1; 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++; } while(((*t) != '\0') && scisspace(*t)){ t++; }
*start = 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) { if(len == 0) {
*end = str; *end = str;
return; return;
} }
const SQChar *t = &str[len-1]; const rabbit::Char *t = &str[len-1];
while(t >= str && scisspace(*t)) { t--; } while(t >= str && scisspace(*t)) { t--; }
*end = t + 1; *end = t + 1;
} }
static int64_t _string_strip(rabbit::VirtualMachine* v) static int64_t _string_strip(rabbit::VirtualMachine* v)
{ {
const SQChar *str,*start,*end; const rabbit::Char *str,*start,*end;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
int64_t len = sq_getsize(v,2); int64_t len = sq_getsize(v,2);
__strip_l(str,&start); __strip_l(str,&start);
@ -214,7 +214,7 @@ static int64_t _string_strip(rabbit::VirtualMachine* v)
static int64_t _string_lstrip(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); sq_getstring(v,2,&str);
__strip_l(str,&start); __strip_l(str,&start);
sq_pushstring(v,start,-1); 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) static int64_t _string_rstrip(rabbit::VirtualMachine* v)
{ {
const SQChar *str,*end; const rabbit::Char *str,*end;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
int64_t len = sq_getsize(v,2); int64_t len = sq_getsize(v,2);
__strip_r(str,len,&end); __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) static int64_t _string_split(rabbit::VirtualMachine* v)
{ {
const SQChar *str,*seps; const rabbit::Char *str,*seps;
SQChar *stemp; rabbit::Char *stemp;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
sq_getstring(v,3,&seps); sq_getstring(v,3,&seps);
int64_t sepsize = sq_getsize(v,3); int64_t sepsize = sq_getsize(v,3);
if(sepsize == 0) return sq_throwerror(v,_SC("empty separators string")); 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); stemp = sq_getscratchpad(v,memsize);
memcpy(stemp,str,memsize); memcpy(stemp,str,memsize);
SQChar *start = stemp; rabbit::Char *start = stemp;
SQChar *end = stemp; rabbit::Char *end = stemp;
sq_newarray(v,0); sq_newarray(v,0);
while(*end != '\0') while(*end != '\0')
{ {
SQChar cur = *end; rabbit::Char cur = *end;
for(int64_t i = 0; i < sepsize; i++) for(int64_t i = 0; i < sepsize; i++)
{ {
if(cur == seps[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) static int64_t _string_escape(rabbit::VirtualMachine* v)
{ {
const SQChar *str; const rabbit::Char *str;
SQChar *dest,*resstr; rabbit::Char *dest,*resstr;
int64_t size; int64_t size;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
size = sq_getsize(v,2); size = sq_getsize(v,2);
@ -282,20 +282,20 @@ static int64_t _string_escape(rabbit::VirtualMachine* v)
} }
#ifdef SQUNICODE #ifdef SQUNICODE
#if WCHAR_SIZE == 2 #if WCHAR_SIZE == 2
const SQChar *escpat = _SC("\\x%04x"); const rabbit::Char *escpat = _SC("\\x%04x");
const int64_t maxescsize = 6; const int64_t maxescsize = 6;
#else //WCHAR_SIZE == 4 #else //WCHAR_SIZE == 4
const SQChar *escpat = _SC("\\x%08x"); const rabbit::Char *escpat = _SC("\\x%08x");
const int64_t maxescsize = 10; const int64_t maxescsize = 10;
#endif #endif
#else #else
const SQChar *escpat = _SC("\\x%02x"); const rabbit::Char *escpat = _SC("\\x%02x");
const int64_t maxescsize = 4; const int64_t maxescsize = 4;
#endif #endif
int64_t destcharsize = (size * maxescsize); //assumes every char could be escaped int64_t destcharsize = (size * maxescsize); //assumes every char could be escaped
resstr = dest = (SQChar *)sq_getscratchpad(v,destcharsize * sizeof(SQChar)); resstr = dest = (rabbit::Char *)sq_getscratchpad(v,destcharsize * sizeof(rabbit::Char));
SQChar c; rabbit::Char c;
SQChar escch; rabbit::Char escch;
int64_t escaped = 0; int64_t escaped = 0;
for(int n = 0; n < size; n++){ for(int n = 0; n < size; n++){
c = *str++; c = *str++;
@ -341,12 +341,12 @@ static int64_t _string_escape(rabbit::VirtualMachine* v)
static int64_t _string_startswith(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,2,&str);
sq_getstring(v,3,&cmp); sq_getstring(v,3,&cmp);
int64_t len = sq_getsize(v,2); int64_t len = sq_getsize(v,2);
int64_t cmplen = sq_getsize(v,3); int64_t cmplen = sq_getsize(v,3);
SQBool ret = SQFalse; rabbit::Bool ret = SQFalse;
if(cmplen <= len) { if(cmplen <= len) {
ret = memcmp(str,cmp,sq_rsl(cmplen)) == 0 ? SQTrue : SQFalse; 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) 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,2,&str);
sq_getstring(v,3,&cmp); sq_getstring(v,3,&cmp);
int64_t len = sq_getsize(v,2); int64_t len = sq_getsize(v,2);
int64_t cmplen = sq_getsize(v,3); int64_t cmplen = sq_getsize(v,3);
SQBool ret = SQFalse; rabbit::Bool ret = SQFalse;
if(cmplen <= len) { if(cmplen <= len) {
ret = memcmp(&str[len - cmplen],cmp,sq_rsl(cmplen)) == 0 ? SQTrue : SQFalse; 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) \ #define SETUP_REX(v) \
SQRex *self = NULL; \ 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); SQRex *self = ((SQRex *)p);
sqstd_rex_free(self); 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) static int64_t _regexp_match(rabbit::VirtualMachine* v)
{ {
SETUP_REX(v); SETUP_REX(v);
const SQChar *str; const rabbit::Char *str;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
if(sqstd_rex_match(self,str) == SQTrue) if(sqstd_rex_match(self,str) == SQTrue)
{ {
@ -394,7 +394,7 @@ static int64_t _regexp_match(rabbit::VirtualMachine* v)
return 1; 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_newtable(v);
sq_pushstring(v,_SC("begin"),-1); 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) static int64_t _regexp_search(rabbit::VirtualMachine* v)
{ {
SETUP_REX(v); SETUP_REX(v);
const SQChar *str,*begin,*end; const rabbit::Char *str,*begin,*end;
int64_t start = 0; int64_t start = 0;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
if(sq_gettop(v) > 2) sq_getinteger(v,3,&start); 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) static int64_t _regexp_capture(rabbit::VirtualMachine* v)
{ {
SETUP_REX(v); SETUP_REX(v);
const SQChar *str,*begin,*end; const rabbit::Char *str,*begin,*end;
int64_t start = 0; int64_t start = 0;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
if(sq_gettop(v) > 2) sq_getinteger(v,3,&start); 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) static int64_t _regexp_constructor(rabbit::VirtualMachine* v)
{ {
const SQChar *error,*pattern; const rabbit::Char *error,*pattern;
sq_getstring(v,2,&pattern); sq_getstring(v,2,&pattern);
SQRex *rex = sqstd_rex_compile(pattern,&error); SQRex *rex = sqstd_rex_compile(pattern,&error);
if(!rex) return sq_throwerror(v,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} #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(constructor,2,_SC(".s")),
_DECL_REX_FUNC(search,-2,_SC("xsn")), _DECL_REX_FUNC(search,-2,_SC("xsn")),
_DECL_REX_FUNC(match,2,_SC("xs")), _DECL_REX_FUNC(match,2,_SC("xs")),
@ -480,7 +480,7 @@ static const SQRegFunction rexobj_funcs[]={
#undef _DECL_REX_FUNC #undef _DECL_REX_FUNC
#define _DECL_FUNC(name,nparams,pmask) {_SC(#name),_string_##name,nparams,pmask} #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(format,-2,_SC(".s")),
_DECL_FUNC(printf,-2,_SC(".s")), _DECL_FUNC(printf,-2,_SC(".s")),
_DECL_FUNC(strip,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); sq_newclass(v,SQFalse);
int64_t i = 0; int64_t i = 0;
while(rexobj_funcs[i].name != 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_pushstring(v,f.name,-1);
sq_newclosure(v,f.f,0); sq_newclosure(v,f.f,0);
sq_setparamscheck(v,f.nparamscheck,f.typemask); 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 SQRex SQRex;
typedef struct { typedef struct {
const SQChar *begin; const rabbit::Char *begin;
int64_t len; int64_t len;
} SQRexMatch; } 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 void sqstd_rex_free(SQRex *exp);
RABBIT_API SQBool sqstd_rex_match(SQRex* exp,const SQChar* text); RABBIT_API rabbit::Bool sqstd_rex_match(SQRex* exp,const rabbit::Char* text);
RABBIT_API SQBool sqstd_rex_search(SQRex* exp,const SQChar* text, const SQChar** out_begin, const SQChar** out_end); 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 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_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 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) static int64_t _system_getenv(rabbit::VirtualMachine* v)
{ {
const SQChar *s; const rabbit::Char *s;
if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){ if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){
sq_pushstring(v,scgetenv(s),-1); sq_pushstring(v,scgetenv(s),-1);
return 1; return 1;
@ -40,7 +40,7 @@ static int64_t _system_getenv(rabbit::VirtualMachine* v)
static int64_t _system_system(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))){ if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){
sq_pushinteger(v,scsystem(s)); sq_pushinteger(v,scsystem(s));
return 1; return 1;
@ -64,7 +64,7 @@ static int64_t _system_time(rabbit::VirtualMachine* v)
static int64_t _system_remove(rabbit::VirtualMachine* v) static int64_t _system_remove(rabbit::VirtualMachine* v)
{ {
const SQChar *s; const rabbit::Char *s;
sq_getstring(v,2,&s); sq_getstring(v,2,&s);
if(scremove(s)==-1) if(scremove(s)==-1)
return sq_throwerror(v,_SC("remove() failed")); 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) 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,2,&oldn);
sq_getstring(v,3,&newn); sq_getstring(v,3,&newn);
if(screname(oldn,newn)==-1) if(screname(oldn,newn)==-1)
@ -81,7 +81,7 @@ static int64_t _system_rename(rabbit::VirtualMachine* v)
return 0; 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_pushstring(v,name,-1);
sq_pushinteger(v,val); 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} #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(getenv,2,_SC(".s")),
_DECL_FUNC(system,2,_SC(".s")), _DECL_FUNC(system,2,_SC(".s")),
_DECL_FUNC(clock,0,NULL), _DECL_FUNC(clock,0,NULL),

30
rabbit/Array.hpp
View File

@ -30,30 +30,30 @@ namespace rabbit {
m_data.resize(0); m_data.resize(0);
} }
bool get(const int64_t _nidx, bool get(const int64_t _nidx,
SQObjectPtr& _val) { rabbit::ObjectPtr& _val) {
if( _nidx >= 0 if( _nidx >= 0
&& _nidx < (int64_t)m_data.size()){ && _nidx < (int64_t)m_data.size()){
SQObjectPtr &o = m_data[_nidx]; rabbit::ObjectPtr &o = m_data[_nidx];
_val = _realval(o); _val = _realval(o);
return true; return true;
} }
return false; 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()){ if(_nidx>=0 && _nidx<(int64_t)m_data.size()){
m_data[_nidx] = _val; m_data[_nidx] = _val;
return true; return true;
} }
return false; return false;
} }
int64_t next(const SQObjectPtr& _refpos, int64_t next(const rabbit::ObjectPtr& _refpos,
SQObjectPtr& _outkey, rabbit::ObjectPtr& _outkey,
SQObjectPtr& _outval) { rabbit::ObjectPtr& _outval) {
uint64_t idx=translateIndex(_refpos); uint64_t idx=translateIndex(_refpos);
while(idx<m_data.size()){ while(idx<m_data.size()){
//first found //first found
_outkey=(int64_t)idx; _outkey=(int64_t)idx;
SQObjectPtr& o = m_data[idx]; rabbit::ObjectPtr& o = m_data[idx];
_outval = _realval(o); _outval = _realval(o);
//return idx for the next iteration //return idx for the next iteration
return ++idx; return ++idx;
@ -70,29 +70,29 @@ namespace rabbit {
return m_data.size(); return m_data.size();
} }
void resize(int64_t _size) { void resize(int64_t _size) {
SQObjectPtr empty; rabbit::ObjectPtr empty;
resize(_size, empty); resize(_size, empty);
} }
void resize(int64_t _size, void resize(int64_t _size,
SQObjectPtr& _fill) { rabbit::ObjectPtr& _fill) {
m_data.resize(_size, _fill); m_data.resize(_size, _fill);
shrinkIfNeeded(); shrinkIfNeeded();
} }
void reserve(int64_t _size) { void reserve(int64_t _size) {
m_data.reserve(_size); m_data.reserve(_size);
} }
void append(const SQObject& _o) { void append(const rabbit::Object& _o) {
m_data.pushBack(_o); m_data.pushBack(_o);
} }
void extend(const Array* _a); void extend(const Array* _a);
SQObjectPtr &top(){ rabbit::ObjectPtr &top(){
return m_data.back(); return m_data.back();
} }
void pop() { void pop() {
m_data.popBack(); m_data.popBack();
shrinkIfNeeded(); shrinkIfNeeded();
} }
bool insert(int64_t _idx,const SQObject& _val) { bool insert(int64_t _idx,const rabbit::Object& _val) {
if( _idx < 0 if( _idx < 0
|| _idx > (int64_t)m_data.size()) { || _idx > (int64_t)m_data.size()) {
return false; return false;
@ -121,14 +121,14 @@ namespace rabbit {
void release() { void release() {
sq_delete(this, Array); sq_delete(this, Array);
} }
SQObjectPtr& operator[] (const size_t _pos) { rabbit::ObjectPtr& operator[] (const size_t _pos) {
return m_data[_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]; return m_data[_pos];
} }
private: 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 <rabbit/squtils.hpp>
#include <etk/Allocator.hpp> #include <etk/Allocator.hpp>
rabbit::WeakRef * rabbit::RefCounted::getWeakRef(SQObjectType type) { rabbit::WeakRef * rabbit::RefCounted::getWeakRef(rabbit::ObjectType type) {
if(!_weakref) { if(!_weakref) {
sq_new(_weakref, WeakRef); sq_new(_weakref, WeakRef);
#if defined(SQUSEDOUBLE) && !defined(_SQ64) #if defined(SQUSEDOUBLE) && !defined(_SQ64)
@ -26,7 +26,7 @@ rabbit::WeakRef * rabbit::RefCounted::getWeakRef(SQObjectType type) {
rabbit::RefCounted::~RefCounted() { rabbit::RefCounted::~RefCounted() {
if(_weakref) { if(_weakref) {
_weakref->_obj._type = OT_NULL; _weakref->_obj._type = rabbit::OT_NULL;
_weakref->_obj._unVal.pRefCounted = NULL; _weakref->_obj._unVal.pRefCounted = NULL;
} }
} }

17
rabbit/RefCounted.hpp
View File

@ -8,7 +8,7 @@
#pragma once #pragma once
#include <etk/types.hpp> #include <etk/types.hpp>
#include <rabbit/rabbit.hpp> #include <rabbit/ObjectType.hpp>
namespace rabbit { namespace rabbit {
class WeakRef; class WeakRef;
@ -19,12 +19,25 @@ namespace rabbit {
public: public:
RefCounted() {} RefCounted() {}
virtual ~RefCounted(); virtual ~RefCounted();
WeakRef *getWeakRef(SQObjectType _type); WeakRef *getWeakRef(rabbit::ObjectType _type);
virtual void release() = 0; virtual void release() = 0;
void refCountIncrement(); void refCountIncrement();
int64_t refCountDecrement(); int64_t refCountDecrement();
int64_t refCountget(); int64_t refCountget();
friend WeakRef; 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 #pragma once
namespace rabbit { namespace rabbit {
class UserData : public SQDelegable { class UserData : public rabbit::Delegable {
public: public:
UserData(SQSharedState *ss) { UserData(SQSharedState *ss) {
_delegate = 0; _delegate = 0;
@ -26,7 +26,7 @@ namespace rabbit {
} }
void release() { void release() {
if (m_hook) { 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; int64_t tsize = m_size;
this->~UserData(); this->~UserData();
@ -35,10 +35,10 @@ namespace rabbit {
const int64_t& getsize() const { const int64_t& getsize() const {
return m_size; return m_size;
} }
const SQUserPointer& getTypeTag() const { const rabbit::UserPointer& getTypeTag() const {
return m_typetag; return m_typetag;
} }
void setTypeTag(const SQUserPointer& _value) { void setTypeTag(const rabbit::UserPointer& _value) {
m_typetag = _value; m_typetag = _value;
} }
const SQRELEASEHOOK& getHook() const { const SQRELEASEHOOK& getHook() const {
@ -50,6 +50,6 @@ namespace rabbit {
protected: protected:
int64_t m_size; int64_t m_size;
SQRELEASEHOOK m_hook; 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/sqopcodes.hpp>
#include <rabbit/sqobject.hpp> #include <rabbit/sqobject.hpp>
#include <rabbit/AutoDec.hpp> #include <rabbit/AutoDec.hpp>
#include <rabbit/sqconfig.hpp>
#include <rabbit/ExceptionTrap.hpp>
#define MAX_NATIVE_CALLS 100 #define MAX_NATIVE_CALLS 100
#define MIN_STACK_OVERHEAD 15 #define MIN_STACK_OVERHEAD 15
@ -25,15 +28,6 @@
//base lib //base lib
void sq_base_register(rabbit::VirtualMachine* v); 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 #define _INLINE
@ -43,20 +37,20 @@ namespace rabbit {
public: public:
struct callInfo{ struct callInfo{
SQInstruction *_ip; SQInstruction *_ip;
SQObjectPtr *_literals; rabbit::ObjectPtr *_literals;
SQObjectPtr _closure; rabbit::ObjectPtr _closure;
SQGenerator *_generator; SQGenerator *_generator;
int32_t _etraps; int32_t _etraps;
int32_t _prevstkbase; int32_t _prevstkbase;
int32_t _prevtop; int32_t _prevtop;
int32_t _target; int32_t _target;
int32_t _ncalls; int32_t _ncalls;
SQBool _root; rabbit::Bool _root;
}; };
public: public:
void DebugHookProxy(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 SQChar * sourcename, int64_t line, const SQChar * funcname); static void _DebugHookProxy(rabbit::VirtualMachine* v, int64_t type, const rabbit::Char * sourcename, int64_t line, const rabbit::Char * funcname);
enum ExecutionType { enum ExecutionType {
ET_CALL, ET_CALL,
ET_RESUME_GENERATOR, ET_RESUME_GENERATOR,
@ -66,61 +60,61 @@ namespace rabbit {
VirtualMachine(SQSharedState *ss); VirtualMachine(SQSharedState *ss);
~VirtualMachine(); ~VirtualMachine();
bool init(VirtualMachine *friendvm, int64_t stacksize); 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 //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); bool tailcall(SQClosure *closure, int64_t firstparam, int64_t nparams);
//starts a RABBIT call in the same "Execution loop" //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 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 //call a generic closure pure RABBIT or NATIVE
bool call(SQObjectPtr &closure, int64_t nparams, int64_t stackbase, SQObjectPtr &outres,SQBool raiseerror); bool call(rabbit::ObjectPtr &closure, int64_t nparams, int64_t stackbase, rabbit::ObjectPtr &outres,rabbit::Bool raiseerror);
SQRESULT Suspend(); rabbit::Result Suspend();
void callDebugHook(int64_t type,int64_t forcedline=0); void callDebugHook(int64_t type,int64_t forcedline=0);
void callerrorHandler(SQObjectPtr &e); void callerrorHandler(rabbit::ObjectPtr &e);
bool get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &dest, uint64_t getflags, int64_t selfidx); bool get(const rabbit::ObjectPtr &self, const rabbit::ObjectPtr &key, rabbit::ObjectPtr &dest, uint64_t getflags, int64_t selfidx);
int64_t fallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest); int64_t fallBackGet(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,rabbit::ObjectPtr &dest);
bool invokeDefaultDelegate(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest); bool invokeDefaultDelegate(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,rabbit::ObjectPtr &dest);
bool set(const SQObjectPtr &self, const SQObjectPtr &key, const SQObjectPtr &val, int64_t selfidx); bool set(const rabbit::ObjectPtr &self, const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &val, int64_t selfidx);
int64_t fallBackSet(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val); int64_t fallBackSet(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val);
bool newSlot(const SQObjectPtr &self, const SQObjectPtr &key, const SQObjectPtr &val,bool bstatic); bool newSlot(const rabbit::ObjectPtr &self, const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &val,bool bstatic);
bool newSlotA(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,const SQObjectPtr &attrs,bool bstatic,bool raw); 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 SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &res); bool deleteSlot(const rabbit::ObjectPtr &self, const rabbit::ObjectPtr &key, rabbit::ObjectPtr &res);
bool clone(const SQObjectPtr &self, SQObjectPtr &target); bool clone(const rabbit::ObjectPtr &self, rabbit::ObjectPtr &target);
bool objCmp(const SQObjectPtr &o1, const SQObjectPtr &o2,int64_t &res); bool objCmp(const rabbit::ObjectPtr &o1, const rabbit::ObjectPtr &o2,int64_t &res);
bool stringCat(const SQObjectPtr &str, const SQObjectPtr &obj, SQObjectPtr &dest); bool stringCat(const rabbit::ObjectPtr &str, const rabbit::ObjectPtr &obj, rabbit::ObjectPtr &dest);
static bool isEqual(const SQObjectPtr &o1,const SQObjectPtr &o2,bool &res); static bool isEqual(const rabbit::ObjectPtr &o1,const rabbit::ObjectPtr &o2,bool &res);
bool toString(const SQObjectPtr &o,SQObjectPtr &res); bool toString(const rabbit::ObjectPtr &o,rabbit::ObjectPtr &res);
SQString *printObjVal(const SQObjectPtr &o); SQString *printObjVal(const rabbit::ObjectPtr &o);
void raise_error(const SQChar *s, ...); void raise_error(const rabbit::Char *s, ...);
void raise_error(const SQObjectPtr &desc); void raise_error(const rabbit::ObjectPtr &desc);
void raise_Idxerror(const SQObjectPtr &o); void raise_Idxerror(const rabbit::ObjectPtr &o);
void raise_Compareerror(const SQObject &o1, const SQObject &o2); void raise_Compareerror(const rabbit::Object &o1, const rabbit::Object &o2);
void raise_ParamTypeerror(int64_t nparam,int64_t typemask,int64_t type); 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 relocateOuters();
void closeOuters(SQObjectPtr *stackindex); void closeOuters(rabbit::ObjectPtr *stackindex);
bool typeOf(const SQObjectPtr &obj1, SQObjectPtr &dest); bool typeOf(const rabbit::ObjectPtr &obj1, rabbit::ObjectPtr &dest);
bool callMetaMethod(SQObjectPtr &closure, SQMetaMethod mm, int64_t nparams, SQObjectPtr &outres); bool callMetaMethod(rabbit::ObjectPtr &closure, rabbit::MetaMethod mm, int64_t nparams, rabbit::ObjectPtr &outres);
bool arithMetaMethod(int64_t op, const SQObjectPtr &o1, const SQObjectPtr &o2, SQObjectPtr &dest); bool arithMetaMethod(int64_t op, const rabbit::ObjectPtr &o1, const rabbit::ObjectPtr &o2, rabbit::ObjectPtr &dest);
bool Return(int64_t _arg0, int64_t _arg1, SQObjectPtr &retval); bool Return(int64_t _arg0, int64_t _arg1, rabbit::ObjectPtr &retval);
//new stuff //new stuff
bool ARITH_OP(uint64_t op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2); bool ARITH_OP(uint64_t op,rabbit::ObjectPtr &trg,const rabbit::ObjectPtr &o1,const rabbit::ObjectPtr &o2);
bool BW_OP(uint64_t op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2); bool BW_OP(uint64_t op,rabbit::ObjectPtr &trg,const rabbit::ObjectPtr &o1,const rabbit::ObjectPtr &o2);
bool NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o1); bool NEG_OP(rabbit::ObjectPtr &trg,const rabbit::ObjectPtr &o1);
bool CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res); bool CMP_OP(CmpOP op, const rabbit::ObjectPtr &o1,const rabbit::ObjectPtr &o2,rabbit::ObjectPtr &res);
bool CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func); bool CLOSURE_OP(rabbit::ObjectPtr &target, SQFunctionProto *func);
bool CLASS_OP(SQObjectPtr &target,int64_t base,int64_t attrs); bool CLASS_OP(rabbit::ObjectPtr &target,int64_t base,int64_t attrs);
//return true if the loop is finished //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 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,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr); //bool LOCAL_INC(int64_t op,rabbit::ObjectPtr &target, rabbit::ObjectPtr &a, rabbit::ObjectPtr &incr);
bool PLOCAL_INC(int64_t op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr); bool PLOCAL_INC(int64_t op,rabbit::ObjectPtr &target, rabbit::ObjectPtr &a, rabbit::ObjectPtr &incr);
bool derefInc(int64_t op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix,int64_t arg0); 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 #ifdef _DEBUG_DUMP
void dumpstack(int64_t stackbase=-1, bool dumpall = false); void dumpstack(int64_t stackbase=-1, bool dumpall = false);
#endif #endif
@ -141,31 +135,31 @@ namespace rabbit {
//stack functions for the api //stack functions for the api
void remove(int64_t n); void remove(int64_t n);
static bool IsFalse(SQObjectPtr &o); static bool IsFalse(rabbit::ObjectPtr &o);
void pop(); void pop();
void pop(int64_t n); void pop(int64_t n);
void push(const SQObjectPtr &o); void push(const rabbit::ObjectPtr &o);
void pushNull(); void pushNull();
SQObjectPtr& top(); rabbit::ObjectPtr& top();
SQObjectPtr& popGet(); rabbit::ObjectPtr& popGet();
SQObjectPtr& getUp(int64_t n); rabbit::ObjectPtr& getUp(int64_t n);
SQObjectPtr& getAt(int64_t n); rabbit::ObjectPtr& getAt(int64_t n);
SQObjectPtrVec _stack; etk::Vector<rabbit::ObjectPtr> _stack;
int64_t _top; int64_t _top;
int64_t _stackbase; int64_t _stackbase;
SQOuter* _openouters; SQOuter* _openouters;
SQObjectPtr _roottable; rabbit::ObjectPtr _roottable;
SQObjectPtr _lasterror; rabbit::ObjectPtr _lasterror;
SQObjectPtr _errorhandler; rabbit::ObjectPtr _errorhandler;
bool _debughook; bool _debughook;
SQDEBUGHOOK _debughook_native; SQDEBUGHOOK _debughook_native;
SQObjectPtr _debughook_closure; rabbit::ObjectPtr _debughook_closure;
SQObjectPtr temp_reg; rabbit::ObjectPtr temp_reg;
callInfo* _callsstack; callInfo* _callsstack;
@ -173,23 +167,23 @@ namespace rabbit {
int64_t _alloccallsstacksize; int64_t _alloccallsstacksize;
etk::Vector<callInfo> _callstackdata; etk::Vector<callInfo> _callstackdata;
etk::Vector<SQExceptionTrap> _etraps; etk::Vector<rabbit::ExceptionTrap> _etraps;
callInfo *ci; callInfo *ci;
SQUserPointer _foreignptr; rabbit::UserPointer _foreignptr;
//VMs sharing the same state //VMs sharing the same state
SQSharedState *_sharedstate; SQSharedState *_sharedstate;
int64_t _nnativecalls; int64_t _nnativecalls;
int64_t _nmetamethodscall; int64_t _nmetamethodscall;
SQRELEASEHOOK _releasehook; SQRELEASEHOOK _releasehook;
//suspend infos //suspend infos
SQBool _suspended; rabbit::Bool _suspended;
SQBool _suspended_root; rabbit::Bool _suspended_root;
int64_t _suspended_target; int64_t _suspended_target;
int64_t _suspended_traps; 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) { if (_idx>=0) {
return _vm->getAt(_idx+_vm->_stackbase-1); 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){ \ #define PUSH_CALLINFO(v,nci){ \
int64_t css = v->_callsstacksize; \ int64_t css = v->_callsstacksize; \

3
rabbit/WeakRef.hpp
View File

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

367
rabbit/rabbit.hpp
View File

@ -22,27 +22,6 @@
#endif #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 #ifdef _UNICODE
#define SQUNICODE #define SQUNICODE
#endif #endif
@ -61,137 +40,30 @@ namespace rabbit {
#define RABBIT_EOB 0 #define RABBIT_EOB 0
#define SQ_BYTECODE_STREAM_TAG 0xFAFA #define SQ_BYTECODE_STREAM_TAG 0xFAFA
#define SQOBJECT_REF_COUNTED 0x08000000 #include <rabbit/Object.hpp>
#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)
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 (*SQFUNCTION)(rabbit::VirtualMachine*);
typedef int64_t (*SQRELEASEHOOK)(SQUserPointer,int64_t size); typedef int64_t (*SQRELEASEHOOK)(rabbit::UserPointer,int64_t size);
typedef void (*SQCOMPILERERROR)(rabbit::VirtualMachine*,const SQChar * /*desc*/,const SQChar * /*source*/,int64_t /*line*/,int64_t /*column*/); 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 SQChar * ,...); typedef void (*SQPRINTFUNCTION)(rabbit::VirtualMachine*,const rabbit::Char * ,...);
typedef void (*SQDEBUGHOOK)(rabbit::VirtualMachine* /*v*/, int64_t /*type*/, const SQChar * /*sourcename*/, int64_t /*line*/, const SQChar * /*funcname*/); typedef void (*SQDEBUGHOOK)(rabbit::VirtualMachine* /*v*/, int64_t /*type*/, const rabbit::Char * /*sourcename*/, int64_t /*line*/, const rabbit::Char * /*funcname*/);
typedef int64_t (*SQWRITEFUNC)(SQUserPointer,SQUserPointer,int64_t); typedef int64_t (*SQWRITEFUNC)(rabbit::UserPointer,rabbit::UserPointer,int64_t);
typedef int64_t (*SQREADFUNC)(SQUserPointer,SQUserPointer,int64_t); typedef int64_t (*SQREADFUNC)(rabbit::UserPointer,rabbit::UserPointer,int64_t);
typedef int64_t (*SQLEXREADFUNC)(SQUserPointer); typedef int64_t (*SQLEXREADFUNC)(rabbit::UserPointer);
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;
/*vm*/ /*vm*/
RABBIT_API rabbit::VirtualMachine* sq_open(int64_t initialstacksize); RABBIT_API rabbit::VirtualMachine* sq_open(int64_t initialstacksize);
RABBIT_API rabbit::VirtualMachine* sq_newthread(rabbit::VirtualMachine* friendvm, 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_seterrorhandler(rabbit::VirtualMachine* v);
RABBIT_API void sq_close(rabbit::VirtualMachine* v); RABBIT_API void sq_close(rabbit::VirtualMachine* v);
RABBIT_API void sq_setforeignptr(rabbit::VirtualMachine* v,SQUserPointer p); RABBIT_API void sq_setforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p);
RABBIT_API SQUserPointer sq_getforeignptr(rabbit::VirtualMachine* v); RABBIT_API rabbit::UserPointer sq_getforeignptr(rabbit::VirtualMachine* v);
RABBIT_API void sq_setsharedforeignptr(rabbit::VirtualMachine* v,SQUserPointer p); RABBIT_API void sq_setsharedforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p);
RABBIT_API SQUserPointer sq_getsharedforeignptr(rabbit::VirtualMachine* v); RABBIT_API rabbit::UserPointer sq_getsharedforeignptr(rabbit::VirtualMachine* v);
RABBIT_API void sq_setvmreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook); RABBIT_API void sq_setvmreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook);
RABBIT_API SQRELEASEHOOK sq_getvmreleasehook(rabbit::VirtualMachine* v); RABBIT_API SQRELEASEHOOK sq_getvmreleasehook(rabbit::VirtualMachine* v);
RABBIT_API void sq_setsharedreleasehook(rabbit::VirtualMachine* v,SQRELEASEHOOK hook); 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 void sq_setprintfunc(rabbit::VirtualMachine* v, SQPRINTFUNCTION printfunc,SQPRINTFUNCTION errfunc);
RABBIT_API SQPRINTFUNCTION sq_getprintfunc(rabbit::VirtualMachine* v); RABBIT_API SQPRINTFUNCTION sq_getprintfunc(rabbit::VirtualMachine* v);
RABBIT_API SQPRINTFUNCTION sq_geterrorfunc(rabbit::VirtualMachine* v); RABBIT_API SQPRINTFUNCTION sq_geterrorfunc(rabbit::VirtualMachine* v);
RABBIT_API SQRESULT sq_suspendvm(rabbit::VirtualMachine* v); RABBIT_API rabbit::Result 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_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_getvmstate(rabbit::VirtualMachine* v);
RABBIT_API int64_t sq_getversion(); RABBIT_API int64_t sq_getversion();
/*compiler*/ /*compiler*/
RABBIT_API SQRESULT sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,SQUserPointer p,const SQChar *sourcename,SQBool raiseerror); RABBIT_API rabbit::Result sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::UserPointer p,const rabbit::Char *sourcename,rabbit::Bool raiseerror);
RABBIT_API SQRESULT sq_compilebuffer(rabbit::VirtualMachine* v,const SQChar *s,int64_t size,const SQChar *sourcename,SQBool 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, SQBool enable); RABBIT_API void sq_enabledebuginfo(rabbit::VirtualMachine* v, rabbit::Bool enable);
RABBIT_API void sq_notifyallexceptions(rabbit::VirtualMachine* v, SQBool enable); RABBIT_API void sq_notifyallexceptions(rabbit::VirtualMachine* v, rabbit::Bool enable);
RABBIT_API void sq_setcompilererrorhandler(rabbit::VirtualMachine* v,SQCOMPILERERROR f); RABBIT_API void sq_setcompilererrorhandler(rabbit::VirtualMachine* v,SQCOMPILERERROR f);
/*stack operations*/ /*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 void sq_remove(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API int64_t sq_gettop(rabbit::VirtualMachine* v); RABBIT_API int64_t sq_gettop(rabbit::VirtualMachine* v);
RABBIT_API void sq_settop(rabbit::VirtualMachine* v,int64_t newtop); 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 int64_t sq_cmp(rabbit::VirtualMachine* v);
RABBIT_API void sq_move(rabbit::VirtualMachine* dest,rabbit::VirtualMachine* src,int64_t idx); RABBIT_API void sq_move(rabbit::VirtualMachine* dest,rabbit::VirtualMachine* src,int64_t idx);
/*object creation handling*/ /*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_newtable(rabbit::VirtualMachine* v);
RABBIT_API void sq_newtableex(rabbit::VirtualMachine* v,int64_t initialcapacity); 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_newarray(rabbit::VirtualMachine* v,int64_t size);
RABBIT_API void sq_newclosure(rabbit::VirtualMachine* v,SQFUNCTION func,uint64_t nfreevars); 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 rabbit::Result sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const rabbit::Char *typemask);
RABBIT_API SQRESULT sq_bindenv(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_bindenv(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_getclosureroot(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 SQChar *s,int64_t len); 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_pushfloat(rabbit::VirtualMachine* v,float_t f);
RABBIT_API void sq_pushinteger(rabbit::VirtualMachine* v,int64_t n); 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_pushbool(rabbit::VirtualMachine* v,rabbit::Bool b);
RABBIT_API void sq_pushuserpointer(rabbit::VirtualMachine* v,SQUserPointer p); RABBIT_API void sq_pushuserpointer(rabbit::VirtualMachine* v,rabbit::UserPointer p);
RABBIT_API void sq_pushnull(rabbit::VirtualMachine* v); RABBIT_API void sq_pushnull(rabbit::VirtualMachine* v);
RABBIT_API void sq_pushthread(rabbit::VirtualMachine* v, rabbit::VirtualMachine* thread); RABBIT_API void sq_pushthread(rabbit::VirtualMachine* v, rabbit::VirtualMachine* thread);
RABBIT_API SQObjectType sq_gettype(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::ObjectType sq_gettype(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_typeof(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 int64_t sq_getsize(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQHash sq_gethash(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 rabbit::Result sq_getbase(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQBool sq_instanceof(rabbit::VirtualMachine* v); RABBIT_API rabbit::Bool sq_instanceof(rabbit::VirtualMachine* v);
RABBIT_API SQRESULT sq_tostring(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_tostring(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API void sq_tobool(rabbit::VirtualMachine* v, int64_t idx, SQBool *b); RABBIT_API void sq_tobool(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool *b);
RABBIT_API SQRESULT sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const SQChar **c,int64_t *size); RABBIT_API rabbit::Result sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c,int64_t *size);
RABBIT_API SQRESULT sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const SQChar **c); RABBIT_API rabbit::Result sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c);
RABBIT_API SQRESULT sq_getinteger(rabbit::VirtualMachine* v,int64_t idx,int64_t *i); RABBIT_API rabbit::Result 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 rabbit::Result 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 rabbit::Result sq_getbool(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool *b);
RABBIT_API SQRESULT sq_getthread(rabbit::VirtualMachine* v,int64_t idx,rabbit::VirtualMachine* *thread); RABBIT_API rabbit::Result 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 rabbit::Result sq_getuserpointer(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *p);
RABBIT_API SQRESULT sq_getuserdata(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer *p,SQUserPointer *typetag); RABBIT_API rabbit::Result sq_getuserdata(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *p,rabbit::UserPointer *typetag);
RABBIT_API SQRESULT sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer typetag); RABBIT_API rabbit::Result sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer typetag);
RABBIT_API SQRESULT sq_gettypetag(rabbit::VirtualMachine* v,int64_t idx,SQUserPointer *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 void sq_setreleasehook(rabbit::VirtualMachine* v,int64_t idx,SQRELEASEHOOK hook);
RABBIT_API SQRELEASEHOOK sq_getreleasehook(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API SQRELEASEHOOK sq_getreleasehook(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQChar *sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize); RABBIT_API rabbit::Char *sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize);
RABBIT_API SQRESULT sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,SQFunctionInfo *fi); RABBIT_API rabbit::Result sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,rabbit::FunctionInfo *fi);
RABBIT_API SQRESULT sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,uint64_t *nparams,uint64_t *nfreevars); RABBIT_API rabbit::Result 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 rabbit::Result sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const SQChar *name); RABBIT_API rabbit::Result sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char *name);
RABBIT_API SQRESULT sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, SQUserPointer p); RABBIT_API rabbit::Result sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer p);
RABBIT_API SQRESULT sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, SQUserPointer *p,SQUserPointer typetag); RABBIT_API rabbit::Result sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p,rabbit::UserPointer typetag);
RABBIT_API SQRESULT sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize); RABBIT_API rabbit::Result sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize);
RABBIT_API SQRESULT sq_newclass(rabbit::VirtualMachine* v,SQBool hasbase); RABBIT_API rabbit::Result sq_newclass(rabbit::VirtualMachine* v,rabbit::Bool hasbase);
RABBIT_API SQRESULT sq_createinstance(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_createinstance(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_setattributes(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_setattributes(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_getattributes(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_getattributes(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_getclass(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 void sq_weakref(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_getdefaultdelegate(rabbit::VirtualMachine* v,SQObjectType t); RABBIT_API rabbit::Result sq_getdefaultdelegate(rabbit::VirtualMachine* v,rabbit::ObjectType t);
RABBIT_API SQRESULT sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,HSQMEMBERHANDLE *handle); RABBIT_API rabbit::Result sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,rabbit::MemberHandle *handle);
RABBIT_API SQRESULT sq_getbyhandle(rabbit::VirtualMachine* v,int64_t idx,const HSQMEMBERHANDLE *handle); RABBIT_API rabbit::Result sq_getbyhandle(rabbit::VirtualMachine* v,int64_t idx,const rabbit::MemberHandle *handle);
RABBIT_API SQRESULT sq_setbyhandle(rabbit::VirtualMachine* v,int64_t idx,const HSQMEMBERHANDLE *handle); RABBIT_API rabbit::Result sq_setbyhandle(rabbit::VirtualMachine* v,int64_t idx,const rabbit::MemberHandle *handle);
/*object manipulation*/ /*object manipulation*/
RABBIT_API void sq_pushroottable(rabbit::VirtualMachine* v); RABBIT_API void sq_pushroottable(rabbit::VirtualMachine* v);
RABBIT_API void sq_pushregistrytable(rabbit::VirtualMachine* v); RABBIT_API void sq_pushregistrytable(rabbit::VirtualMachine* v);
RABBIT_API void sq_pushconsttable(rabbit::VirtualMachine* v); RABBIT_API void sq_pushconsttable(rabbit::VirtualMachine* v);
RABBIT_API SQRESULT sq_setroottable(rabbit::VirtualMachine* v); RABBIT_API rabbit::Result sq_setroottable(rabbit::VirtualMachine* v);
RABBIT_API SQRESULT sq_setconsttable(rabbit::VirtualMachine* v); RABBIT_API rabbit::Result sq_setconsttable(rabbit::VirtualMachine* v);
RABBIT_API SQRESULT sq_newslot(rabbit::VirtualMachine* v, int64_t idx, SQBool bstatic); RABBIT_API rabbit::Result sq_newslot(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool bstatic);
RABBIT_API SQRESULT sq_deleteslot(rabbit::VirtualMachine* v,int64_t idx,SQBool pushval); RABBIT_API rabbit::Result sq_deleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval);
RABBIT_API SQRESULT sq_set(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_set(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_get(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_get(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_rawget(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_rawget(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_rawset(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_rawset(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_rawdeleteslot(rabbit::VirtualMachine* v,int64_t idx,SQBool pushval); RABBIT_API rabbit::Result sq_rawdeleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval);
RABBIT_API SQRESULT sq_newmember(rabbit::VirtualMachine* v,int64_t idx,SQBool bstatic); RABBIT_API rabbit::Result sq_newmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic);
RABBIT_API SQRESULT sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,SQBool bstatic); RABBIT_API rabbit::Result sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic);
RABBIT_API SQRESULT sq_arrayappend(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_arrayappend(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,SQBool pushval); RABBIT_API rabbit::Result sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool pushval);
RABBIT_API SQRESULT sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t newsize); RABBIT_API rabbit::Result sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t newsize);
RABBIT_API SQRESULT sq_arrayreverse(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_arrayreverse(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_arrayremove(rabbit::VirtualMachine* v,int64_t idx,int64_t itemidx); RABBIT_API rabbit::Result 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 rabbit::Result sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int64_t destpos);
RABBIT_API SQRESULT sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_clone(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_clone(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval); RABBIT_API rabbit::Result sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval);
RABBIT_API SQRESULT sq_next(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_next(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_getweakrefval(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_getweakrefval(rabbit::VirtualMachine* v,int64_t idx);
RABBIT_API SQRESULT sq_clear(rabbit::VirtualMachine* v,int64_t idx); RABBIT_API rabbit::Result sq_clear(rabbit::VirtualMachine* v,int64_t idx);
/*calls*/ /*calls*/
RABBIT_API SQRESULT sq_call(rabbit::VirtualMachine* v,int64_t params,SQBool retval,SQBool raiseerror); RABBIT_API rabbit::Result sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::Bool retval,rabbit::Bool raiseerror);
RABBIT_API SQRESULT sq_resume(rabbit::VirtualMachine* v,SQBool retval,SQBool raiseerror); RABBIT_API rabbit::Result sq_resume(rabbit::VirtualMachine* v,rabbit::Bool retval,rabbit::Bool raiseerror);
RABBIT_API const SQChar *sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx); RABBIT_API const rabbit::Char *sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx);
RABBIT_API SQRESULT sq_getcallee(rabbit::VirtualMachine* v); RABBIT_API rabbit::Result sq_getcallee(rabbit::VirtualMachine* v);
RABBIT_API const SQChar *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval); RABBIT_API const rabbit::Char *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval);
RABBIT_API SQRESULT sq_throwerror(rabbit::VirtualMachine* v,const SQChar *err); RABBIT_API rabbit::Result sq_throwerror(rabbit::VirtualMachine* v,const rabbit::Char *err);
RABBIT_API SQRESULT sq_throwobject(rabbit::VirtualMachine* v); RABBIT_API rabbit::Result sq_throwobject(rabbit::VirtualMachine* v);
RABBIT_API void sq_reseterror(rabbit::VirtualMachine* v); RABBIT_API void sq_reseterror(rabbit::VirtualMachine* v);
RABBIT_API void sq_getlasterror(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*/ /*raw object handling*/
RABBIT_API SQRESULT sq_getstackobj(rabbit::VirtualMachine* v,int64_t idx,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,HSQOBJECT obj); RABBIT_API void sq_pushobject(rabbit::VirtualMachine* v,rabbit::Object obj);
RABBIT_API void sq_addref(rabbit::VirtualMachine* v,HSQOBJECT *po); RABBIT_API void sq_addref(rabbit::VirtualMachine* v,rabbit::Object *po);
RABBIT_API SQBool sq_release(rabbit::VirtualMachine* v,HSQOBJECT *po); RABBIT_API rabbit::Bool sq_release(rabbit::VirtualMachine* v,rabbit::Object *po);
RABBIT_API uint64_t sq_getrefcount(rabbit::VirtualMachine* v,HSQOBJECT *po); RABBIT_API uint64_t sq_getrefcount(rabbit::VirtualMachine* v,rabbit::Object *po);
RABBIT_API void sq_resetobject(HSQOBJECT *po); RABBIT_API void sq_resetobject(rabbit::Object *po);
RABBIT_API const SQChar *sq_objtostring(const HSQOBJECT *o); RABBIT_API const rabbit::Char *sq_objtostring(const rabbit::Object *o);
RABBIT_API SQBool sq_objtobool(const HSQOBJECT *o); RABBIT_API rabbit::Bool sq_objtobool(const rabbit::Object *o);
RABBIT_API int64_t sq_objtointeger(const HSQOBJECT *o); RABBIT_API int64_t sq_objtointeger(const rabbit::Object *o);
RABBIT_API float_t sq_objtofloat(const HSQOBJECT *o); RABBIT_API float_t sq_objtofloat(const rabbit::Object *o);
RABBIT_API SQUserPointer sq_objtouserpointer(const HSQOBJECT *o); RABBIT_API rabbit::UserPointer sq_objtouserpointer(const rabbit::Object *o);
RABBIT_API SQRESULT sq_getobjtypetag(const HSQOBJECT *o,SQUserPointer * typetag); RABBIT_API rabbit::Result sq_getobjtypetag(const rabbit::Object *o,rabbit::UserPointer * typetag);
RABBIT_API uint64_t sq_getvmrefcount(rabbit::VirtualMachine* v, const HSQOBJECT *po); RABBIT_API uint64_t sq_getvmrefcount(rabbit::VirtualMachine* v, const rabbit::Object *po);
/*GC*/ /*GC*/
RABBIT_API int64_t sq_collectgarbage(rabbit::VirtualMachine* v); 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*/ /*serialization*/
RABBIT_API SQRESULT sq_writeclosure(rabbit::VirtualMachine* vm,SQWRITEFUNC writef,SQUserPointer up); RABBIT_API rabbit::Result sq_writeclosure(rabbit::VirtualMachine* vm,SQWRITEFUNC writef,rabbit::UserPointer up);
RABBIT_API SQRESULT sq_readclosure(rabbit::VirtualMachine* vm,SQREADFUNC readf,SQUserPointer up); RABBIT_API rabbit::Result sq_readclosure(rabbit::VirtualMachine* vm,SQREADFUNC readf,rabbit::UserPointer up);
/*mem allocation*/ /*mem allocation*/
RABBIT_API void *sq_malloc(uint64_t size); 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); RABBIT_API void sq_free(void *p,uint64_t size);
/*debug*/ /*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_setdebughook(rabbit::VirtualMachine* v);
RABBIT_API void sq_setnativedebughook(rabbit::VirtualMachine* v,SQDEBUGHOOK hook); 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 */ /* deprecated */
#define sq_createslot(v,n) sq_newslot(v,n,SQFalse) #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 <stdarg.h>
#include <ctype.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; rabbit::Char *end;
const SQChar *e = s; const rabbit::Char *e = s;
bool iseintbase = base > 13; //to fix error converting hexadecimals with e like 56f0791e bool iseintbase = base > 13; //to fix error converting hexadecimals with e like 56f0791e
bool isfloat = false; bool isfloat = false;
SQChar c; rabbit::Char c;
while((c = *e) != _SC('\0')) while((c = *e) != _SC('\0'))
{ {
if (c == _SC('.') || (!iseintbase && (c == _SC('E') || c == _SC('e')))) { //e and E is for scientific notation 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) static int64_t base_getconsttable(rabbit::VirtualMachine* v)
{ {
v->push(_ss(v)->_consts); v->push(_get_shared_state(v)->_consts);
return 1; return 1;
} }
static int64_t base_setroottable(rabbit::VirtualMachine* v) 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; if(SQ_FAILED(sq_setroottable(v))) return SQ_ERROR;
v->push(o); v->push(o);
return 1; return 1;
@ -73,7 +73,7 @@ static int64_t base_setroottable(rabbit::VirtualMachine* v)
static int64_t base_setconsttable(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; if(SQ_FAILED(sq_setconsttable(v))) return SQ_ERROR;
v->push(o); v->push(o);
return 1; return 1;
@ -93,7 +93,7 @@ static int64_t base_setdebughook(rabbit::VirtualMachine* v)
static int64_t base_enabledebuginfo(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); sq_enabledebuginfo(v,rabbit::VirtualMachine::IsFalse(o)?SQFalse:SQTrue);
return 0; return 0;
@ -101,14 +101,14 @@ static int64_t base_enabledebuginfo(rabbit::VirtualMachine* v)
static int64_t __getcallstackinfos(rabbit::VirtualMachine* v,int64_t level) static int64_t __getcallstackinfos(rabbit::VirtualMachine* v,int64_t level)
{ {
SQStackInfos si; rabbit::StackInfos si;
int64_t seq = 0; int64_t seq = 0;
const SQChar *name = NULL; const rabbit::Char *name = NULL;
if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si))) if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si)))
{ {
const SQChar *fn = _SC("unknown"); const rabbit::Char *fn = _SC("unknown");
const SQChar *src = _SC("unknown"); const rabbit::Char *src = _SC("unknown");
if(si.funcname)fn = si.funcname; if(si.funcname)fn = si.funcname;
if(si.source)src = si.source; if(si.source)src = si.source;
sq_newtable(v); sq_newtable(v);
@ -149,7 +149,7 @@ static int64_t base_assert(rabbit::VirtualMachine* v)
if(rabbit::VirtualMachine::IsFalse(stack_get(v,2))){ if(rabbit::VirtualMachine::IsFalse(stack_get(v,2))){
int64_t top = sq_gettop(v); int64_t top = sq_gettop(v);
if (top>2 && SQ_SUCCEEDED(sq_tostring(v,3))) { 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))) { if (SQ_SUCCEEDED(sq_getstring(v,-1,&str))) {
return sq_throwerror(v, str); return sq_throwerror(v, str);
} }
@ -159,20 +159,20 @@ static int64_t base_assert(rabbit::VirtualMachine* v)
return 0; 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); int64_t top = sq_gettop(v);
sidx=0; sidx=0;
eidx=0; eidx=0;
o=stack_get(v,1); o=stack_get(v,1);
if(top>1){ if(top>1){
SQObjectPtr &start=stack_get(v,2); rabbit::ObjectPtr &start=stack_get(v,2);
if(sq_type(start)!=OT_NULL && sq_isnumeric(start)){ if(sq_type(start)!=rabbit::OT_NULL && sq_isnumeric(start)){
sidx=tointeger(start); sidx=tointeger(start);
} }
} }
if(top>2){ if(top>2){
SQObjectPtr &end=stack_get(v,3); rabbit::ObjectPtr &end=stack_get(v,3);
if(sq_isnumeric(end)){ if(sq_isnumeric(end)){
eidx=tointeger(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) 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_tostring(v,2)))
{ {
if(SQ_SUCCEEDED(sq_getstring(v,-1,&str))) { 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; return 0;
} }
} }
@ -198,11 +198,11 @@ static int64_t base_print(rabbit::VirtualMachine* v)
static int64_t base_error(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_tostring(v,2)))
{ {
if(SQ_SUCCEEDED(sq_getstring(v,-1,&str))) { 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; return 0;
} }
} }
@ -212,7 +212,7 @@ static int64_t base_error(rabbit::VirtualMachine* v)
static int64_t base_compilestring(rabbit::VirtualMachine* v) static int64_t base_compilestring(rabbit::VirtualMachine* v)
{ {
int64_t nargs=sq_gettop(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; int64_t size;
sq_getstring(v,2,&src); sq_getstring(v,2,&src);
size=sq_getsize(v,2); 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) 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; 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); rabbit::VirtualMachine* newv = sq_newthread(v, (stksize < MIN_STACK_OVERHEAD + 2)? MIN_STACK_OVERHEAD + 2 : stksize);
sq_move(newv,v,-2); 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) static int64_t base_array(rabbit::VirtualMachine* v)
{ {
rabbit::Array *a; rabbit::Array *a;
SQObject &size = stack_get(v,2); rabbit::Object &size = stack_get(v,2);
if(sq_gettop(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)); a->resize(tointeger(size),stack_get(v,3));
} }
else { else {
a = rabbit::Array::create(_ss(v),tointeger(size)); a = rabbit::Array::create(_get_shared_state(v),tointeger(size));
} }
v->push(a); v->push(a);
return 1; return 1;
@ -256,8 +256,8 @@ static int64_t base_array(rabbit::VirtualMachine* v)
static int64_t base_type(rabbit::VirtualMachine* v) static int64_t base_type(rabbit::VirtualMachine* v)
{ {
SQObjectPtr &o = stack_get(v,2); rabbit::ObjectPtr &o = stack_get(v,2);
v->push(SQString::create(_ss(v),getTypeName(o),-1)); v->push(SQString::create(_get_shared_state(v),getTypeName(o),-1));
return 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")); return sq_throwerror(v,_SC("no closure in the calls stack"));
} }
static const SQRegFunction base_funcs[]={ static const rabbit::RegFunction base_funcs[]={
//generic //generic
{_SC("seterrorhandler"),base_seterrorhandler,2, NULL}, {_SC("seterrorhandler"),base_seterrorhandler,2, NULL},
{_SC("setdebughook"),base_setdebughook,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_pushstring(v,RABBIT_VERSION,-1);
sq_newslot(v,-3, SQFalse); sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_charsize_"),-1); sq_pushstring(v,_SC("_charsize_"),-1);
sq_pushinteger(v,sizeof(SQChar)); sq_pushinteger(v,sizeof(rabbit::Char));
sq_newslot(v,-3, SQFalse); sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_intsize_"),-1); sq_pushstring(v,_SC("_intsize_"),-1);
sq_pushinteger(v,sizeof(int64_t)); 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) 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)){ switch(sq_type(o)){
case OT_STRING:{ case rabbit::OT_STRING:{
SQObjectPtr res; rabbit::ObjectPtr res;
if(str2num(_stringval(o),res,10)){ if(str2num(_stringval(o),res,10)){
v->push(SQObjectPtr(tofloat(res))); v->push(rabbit::ObjectPtr(tofloat(res)));
break; break;
}} }}
return sq_throwerror(v, _SC("cannot convert the string")); return sq_throwerror(v, _SC("cannot convert the string"));
break; break;
case OT_INTEGER:case OT_FLOAT: case rabbit::OT_INTEGER:case OT_FLOAT:
v->push(SQObjectPtr(tofloat(o))); v->push(rabbit::ObjectPtr(tofloat(o)));
break; break;
case OT_BOOL: case rabbit::OT_BOOL:
v->push(SQObjectPtr((float_t)(_integer(o)?1:0))); v->push(rabbit::ObjectPtr((float_t)(_integer(o)?1:0)));
break; break;
default: default:
v->pushNull(); v->pushNull();
@ -358,25 +358,25 @@ static int64_t default_delegate_tofloat(rabbit::VirtualMachine* v)
static int64_t default_delegate_tointeger(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; int64_t base = 10;
if(sq_gettop(v) > 1) { if(sq_gettop(v) > 1) {
sq_getinteger(v,2,&base); sq_getinteger(v,2,&base);
} }
switch(sq_type(o)){ switch(sq_type(o)){
case OT_STRING:{ case rabbit::OT_STRING:{
SQObjectPtr res; rabbit::ObjectPtr res;
if(str2num(_stringval(o),res,base)){ if(str2num(_stringval(o),res,base)){
v->push(SQObjectPtr(tointeger(res))); v->push(rabbit::ObjectPtr(tointeger(res)));
break; break;
}} }}
return sq_throwerror(v, _SC("cannot convert the string")); return sq_throwerror(v, _SC("cannot convert the string"));
break; break;
case OT_INTEGER:case OT_FLOAT: case rabbit::OT_INTEGER:case OT_FLOAT:
v->push(SQObjectPtr(tointeger(o))); v->push(rabbit::ObjectPtr(tointeger(o)));
break; break;
case OT_BOOL: case rabbit::OT_BOOL:
v->push(SQObjectPtr(_integer(o)?(int64_t)1:(int64_t)0)); v->push(rabbit::ObjectPtr(_integer(o)?(int64_t)1:(int64_t)0));
break; break;
default: default:
v->pushNull(); v->pushNull();
@ -406,9 +406,9 @@ static int64_t obj_clear(rabbit::VirtualMachine* v)
static int64_t number_delegate_tochar(rabbit::VirtualMachine* v) static int64_t number_delegate_tochar(rabbit::VirtualMachine* v)
{ {
SQObject &o=stack_get(v,1); rabbit::Object &o=stack_get(v,1);
SQChar c = (SQChar)tointeger(o); rabbit::Char c = (rabbit::Char)tointeger(o);
v->push(SQString::create(_ss(v),(const SQChar *)&c,1)); v->push(SQString::create(_get_shared_state(v),(const rabbit::Char *)&c,1));
return 1; return 1;
} }
@ -461,11 +461,11 @@ static int64_t table_getdelegate(rabbit::VirtualMachine* v)
static int64_t table_filter(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); 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; int64_t nitr;
while((nitr = tbl->next(false, itr, key, val)) != -1) { while((nitr = tbl->next(false, itr, key, val)) != -1) {
itr = (int64_t)nitr; 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("len"),default_delegate_len,1, _SC("t")},
{_SC("rawget"),container_rawget,2, _SC("t")}, {_SC("rawget"),container_rawget,2, _SC("t")},
{_SC("rawset"),container_rawset,3, _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) 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){ if(_array(o)->size()>0){
v->push(_array(o)->top()); v->push(_array(o)->top());
return 1; return 1;
@ -538,9 +538,9 @@ static int64_t array_top(rabbit::VirtualMachine* v)
static int64_t array_insert(rabbit::VirtualMachine* v) static int64_t array_insert(rabbit::VirtualMachine* v)
{ {
SQObject &o=stack_get(v,1); rabbit::Object &o=stack_get(v,1);
SQObject &idx=stack_get(v,2); rabbit::Object &idx=stack_get(v,2);
SQObject &val=stack_get(v,3); rabbit::Object &val=stack_get(v,3);
if(!_array(o)->insert(tointeger(idx),val)) if(!_array(o)->insert(tointeger(idx),val))
return sq_throwerror(v,_SC("index out of range")); return sq_throwerror(v,_SC("index out of range"));
sq_pop(v,2); sq_pop(v,2);
@ -549,10 +549,10 @@ static int64_t array_insert(rabbit::VirtualMachine* v)
static int64_t array_remove(rabbit::VirtualMachine* v) static int64_t array_remove(rabbit::VirtualMachine* v)
{ {
SQObject &o = stack_get(v, 1); rabbit::Object &o = stack_get(v, 1);
SQObject &idx = stack_get(v, 2); rabbit::Object &idx = stack_get(v, 2);
if(!sq_isnumeric(idx)) return sq_throwerror(v, _SC("wrong type")); if(!sq_isnumeric(idx)) return sq_throwerror(v, _SC("wrong type"));
SQObjectPtr val; rabbit::ObjectPtr val;
if(_array(o)->get(tointeger(idx), val)) { if(_array(o)->get(tointeger(idx), val)) {
_array(o)->remove(tointeger(idx)); _array(o)->remove(tointeger(idx));
v->push(val); v->push(val);
@ -563,9 +563,9 @@ static int64_t array_remove(rabbit::VirtualMachine* v)
static int64_t array_resize(rabbit::VirtualMachine* v) static int64_t array_resize(rabbit::VirtualMachine* v)
{ {
SQObject &o = stack_get(v, 1); rabbit::Object &o = stack_get(v, 1);
SQObject &nsize = stack_get(v, 2); rabbit::Object &nsize = stack_get(v, 2);
SQObjectPtr fill; rabbit::ObjectPtr fill;
if(sq_isnumeric(nsize)) { if(sq_isnumeric(nsize)) {
int64_t sz = tointeger(nsize); int64_t sz = tointeger(nsize);
if (sz<0) 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) { static int64_t __map_array(rabbit::Array *dest,rabbit::Array *src,rabbit::VirtualMachine* v) {
SQObjectPtr temp; rabbit::ObjectPtr temp;
int64_t size = src->size(); int64_t size = src->size();
for(int64_t n = 0; n < size; n++) { for(int64_t n = 0; n < size; n++) {
src->get(n,temp); 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) 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(); 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))) if(SQ_FAILED(__map_array(_array(ret),_array(o),v)))
return SQ_ERROR; return SQ_ERROR;
v->push(ret); v->push(ret);
@ -609,7 +609,7 @@ static int64_t array_map(rabbit::VirtualMachine* v)
static int64_t array_apply(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))) if(SQ_FAILED(__map_array(_array(o),_array(o),v)))
return SQ_ERROR; return SQ_ERROR;
sq_pop(v,1); sq_pop(v,1);
@ -618,16 +618,16 @@ static int64_t array_apply(rabbit::VirtualMachine* v)
static int64_t array_reduce(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); rabbit::Array *a = _array(o);
int64_t size = a->size(); int64_t size = a->size();
if(size == 0) { if(size == 0) {
return 0; return 0;
} }
SQObjectPtr res; rabbit::ObjectPtr res;
a->get(0,res); a->get(0,res);
if(size > 1) { if(size > 1) {
SQObjectPtr other; rabbit::ObjectPtr other;
for(int64_t n = 1; n < size; n++) { for(int64_t n = 1; n < size; n++) {
a->get(n,other); a->get(n,other);
v->push(o); v->push(o);
@ -646,11 +646,11 @@ static int64_t array_reduce(rabbit::VirtualMachine* v)
static int64_t array_filter(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); 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(); int64_t size = a->size();
SQObjectPtr val; rabbit::ObjectPtr val;
for(int64_t n = 0; n < size; n++) { for(int64_t n = 0; n < size; n++) {
a->get(n,val); a->get(n,val);
v->push(o); v->push(o);
@ -670,11 +670,11 @@ static int64_t array_filter(rabbit::VirtualMachine* v)
static int64_t array_find(rabbit::VirtualMachine* v) static int64_t array_find(rabbit::VirtualMachine* v)
{ {
SQObject &o = stack_get(v,1); rabbit::Object &o = stack_get(v,1);
SQObjectPtr &val = stack_get(v,2); rabbit::ObjectPtr &val = stack_get(v,2);
rabbit::Array *a = _array(o); rabbit::Array *a = _array(o);
int64_t size = a->size(); int64_t size = a->size();
SQObjectPtr temp; rabbit::ObjectPtr temp;
for(int64_t n = 0; n < size; n++) { for(int64_t n = 0; n < size; n++) {
bool res = false; bool res = false;
a->get(n,temp); 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(func < 0) {
if(!v->objCmp(a,b,ret)) return false; 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; 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); rabbit::Array *a = _array(arr);
int64_t i; 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) static int64_t array_sort(rabbit::VirtualMachine* v)
{ {
int64_t func = -1; int64_t func = -1;
SQObjectPtr &o = stack_get(v,1); rabbit::ObjectPtr &o = stack_get(v,1);
if(_array(o)->size() > 1) { if(_array(o)->size() > 1) {
if(sq_gettop(v) == 2) func = 2; if(sq_gettop(v) == 2) func = 2;
if(!_hsort(v, o, 0, _array(o)->size()-1, func)) 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) static int64_t array_slice(rabbit::VirtualMachine* v)
{ {
int64_t sidx,eidx; int64_t sidx,eidx;
SQObjectPtr o; rabbit::ObjectPtr o;
if(get_slice_params(v,sidx,eidx,o)==-1)return -1; if(get_slice_params(v,sidx,eidx,o)==-1)return -1;
int64_t alen = _array(o)->size(); int64_t alen = _array(o)->size();
if(sidx < 0)sidx = alen + sidx; if(sidx < 0)sidx = alen + sidx;
if(eidx < 0)eidx = alen + eidx; if(eidx < 0)eidx = alen + eidx;
if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes")); if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes"));
if(eidx > alen || sidx < 0)return sq_throwerror(v, _SC("slice out of range")); if(eidx > alen || sidx < 0)return sq_throwerror(v, _SC("slice out of range"));
rabbit::Array *arr=rabbit::Array::create(_ss(v),eidx-sidx); rabbit::Array *arr=rabbit::Array::create(_get_shared_state(v),eidx-sidx);
SQObjectPtr t; rabbit::ObjectPtr t;
int64_t count=0; int64_t count=0;
for(int64_t i=sidx;i<eidx;i++){ for(int64_t i=sidx;i<eidx;i++){
_array(o)->get(i,t); _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("len"),default_delegate_len,1, _SC("a")},
{_SC("append"),array_append,2, _SC("a")}, {_SC("append"),array_append,2, _SC("a")},
{_SC("extend"),array_extend,2, _SC("aa")}, {_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) static int64_t string_slice(rabbit::VirtualMachine* v)
{ {
int64_t sidx,eidx; int64_t sidx,eidx;
SQObjectPtr o; rabbit::ObjectPtr o;
if(SQ_FAILED(get_slice_params(v,sidx,eidx,o)))return -1; if(SQ_FAILED(get_slice_params(v,sidx,eidx,o)))return -1;
int64_t slen = _string(o)->_len; int64_t slen = _string(o)->_len;
if(sidx < 0)sidx = slen + sidx; if(sidx < 0)sidx = slen + sidx;
if(eidx < 0)eidx = slen + eidx; if(eidx < 0)eidx = slen + eidx;
if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes")); if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes"));
if(eidx > slen || sidx < 0) return sq_throwerror(v, _SC("slice out of range")); 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; return 1;
} }
static int64_t string_find(rabbit::VirtualMachine* v) static int64_t string_find(rabbit::VirtualMachine* v)
{ {
int64_t top,start_idx=0; 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=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(top>2)sq_getinteger(v,3,&start_idx);
if((sq_getsize(v,1)>start_idx) && (start_idx>=0)){ 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) \ #define STRING_TOFUNCZ(func) static int64_t string_##func(rabbit::VirtualMachine* v) \
{\ {\
int64_t sidx,eidx; \ int64_t sidx,eidx; \
SQObjectPtr str; \ rabbit::ObjectPtr str; \
if(SQ_FAILED(get_slice_params(v,sidx,eidx,str)))return -1; \ if(SQ_FAILED(get_slice_params(v,sidx,eidx,str)))return -1; \
int64_t slen = _string(str)->_len; \ int64_t slen = _string(str)->_len; \
if(sidx < 0)sidx = slen + sidx; \ 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 < sidx) return sq_throwerror(v,_SC("wrong indexes")); \
if(eidx > slen || sidx < 0) return sq_throwerror(v,_SC("slice out of range")); \ if(eidx > slen || sidx < 0) return sq_throwerror(v,_SC("slice out of range")); \
int64_t len=_string(str)->_len; \ int64_t len=_string(str)->_len; \
const SQChar *sthis=_stringval(str); \ const rabbit::Char *sthis=_stringval(str); \
SQChar *snew=(_ss(v)->getScratchPad(sq_rsl(len))); \ rabbit::Char *snew=(_get_shared_state(v)->getScratchPad(sq_rsl(len))); \
memcpy(snew,sthis,sq_rsl(len));\ memcpy(snew,sthis,sq_rsl(len));\
for(int64_t i=sidx;i<eidx;i++) snew[i] = func(sthis[i]); \ 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; \ return 1; \
} }
@ -886,7 +886,7 @@ static int64_t string_find(rabbit::VirtualMachine* v)
STRING_TOFUNCZ(tolower) STRING_TOFUNCZ(tolower)
STRING_TOFUNCZ(toupper) 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("len"),default_delegate_len,1, _SC("s")},
{_SC("tointeger"),default_delegate_tointeger,-1, _SC("sn")}, {_SC("tointeger"),default_delegate_tointeger,-1, _SC("sn")},
{_SC("tofloat"),default_delegate_tofloat,1, _SC("s")}, {_SC("tofloat"),default_delegate_tofloat,1, _SC("s")},
@ -900,7 +900,7 @@ const SQRegFunction SQSharedState::_string_default_delegate_funcz[]={
}; };
//INTEGER DEFAULT DELEGATE////////////////////////// //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("tointeger"),default_delegate_tointeger,1, _SC("n|b")},
{_SC("tofloat"),default_delegate_tofloat,1, _SC("n|b")}, {_SC("tofloat"),default_delegate_tofloat,1, _SC("n|b")},
{_SC("tostring"),default_delegate_tostring,1, _SC(".")}, {_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) static int64_t closure_call(rabbit::VirtualMachine* v)
{ {
SQObjectPtr &c = stack_get(v, -1); rabbit::ObjectPtr &c = stack_get(v, -1);
if (sq_type(c) == OT_CLOSURE && (_closure(c)->_function->_bgenerator == false)) if (sq_type(c) == rabbit::OT_CLOSURE && (_closure(c)->_function->_bgenerator == false))
{ {
return sq_tailcall(v, sq_gettop(v) - 1); return sq_tailcall(v, sq_gettop(v) - 1);
} }
return SQ_SUCCEEDED(sq_call(v, sq_gettop(v) - 1, SQTrue, SQTrue)) ? 1 : SQ_ERROR; 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)); rabbit::Array *aparams=_array(stack_get(v,2));
int64_t nparams=aparams->size(); 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) { static int64_t closure_getinfos(rabbit::VirtualMachine* v) {
SQObject o = stack_get(v,1); rabbit::Object o = stack_get(v,1);
SQTable *res = SQTable::create(_ss(v),4); SQTable *res = SQTable::create(_get_shared_state(v),4);
if(sq_type(o) == OT_CLOSURE) { if(sq_type(o) == rabbit::OT_CLOSURE) {
SQFunctionProto *f = _closure(o)->_function; SQFunctionProto *f = _closure(o)->_function;
int64_t nparams = f->_nparameters + (f->_varparams?1:0); int64_t nparams = f->_nparameters + (f->_varparams?1:0);
SQObjectPtr params = rabbit::Array::create(_ss(v),nparams); rabbit::ObjectPtr params = rabbit::Array::create(_get_shared_state(v),nparams);
SQObjectPtr defparams = rabbit::Array::create(_ss(v),f->_ndefaultparams); rabbit::ObjectPtr defparams = rabbit::Array::create(_get_shared_state(v),f->_ndefaultparams);
for(int64_t n = 0; n<f->_nparameters; n++) { for(int64_t n = 0; n<f->_nparameters; n++) {
_array(params)->set((int64_t)n,f->_parameters[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]); _array(defparams)->set((int64_t)j,_closure(o)->_defaultparams[j]);
} }
if(f->_varparams) { 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(_get_shared_state(v),_SC("native"),-1),false);
res->newSlot(SQString::create(_ss(v),_SC("name"),-1),f->_name); res->newSlot(SQString::create(_get_shared_state(v),_SC("name"),-1),f->_name);
res->newSlot(SQString::create(_ss(v),_SC("src"),-1),f->_sourcename); res->newSlot(SQString::create(_get_shared_state(v),_SC("src"),-1),f->_sourcename);
res->newSlot(SQString::create(_ss(v),_SC("parameters"),-1),params); res->newSlot(SQString::create(_get_shared_state(v),_SC("parameters"),-1),params);
res->newSlot(SQString::create(_ss(v),_SC("varargs"),-1),f->_varparams); res->newSlot(SQString::create(_get_shared_state(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("defparams"),-1),defparams);
} }
else { //OT_NATIVECLOSURE else { //rabbit::OT_NATIVECLOSURE
SQNativeClosure *nc = _nativeclosure(o); SQNativeClosure *nc = _nativeclosure(o);
res->newSlot(SQString::create(_ss(v),_SC("native"),-1),true); res->newSlot(SQString::create(_get_shared_state(v),_SC("native"),-1),true);
res->newSlot(SQString::create(_ss(v),_SC("name"),-1),nc->_name); res->newSlot(SQString::create(_get_shared_state(v),_SC("name"),-1),nc->_name);
res->newSlot(SQString::create(_ss(v),_SC("paramscheck"),-1),nc->_nparamscheck); res->newSlot(SQString::create(_get_shared_state(v),_SC("paramscheck"),-1),nc->_nparamscheck);
SQObjectPtr typecheck; rabbit::ObjectPtr typecheck;
if(nc->_typecheck.size() > 0) { if(nc->_typecheck.size() > 0) {
typecheck = 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++) { for(uint64_t n = 0; n<nc->_typecheck.size(); n++) {
_array(typecheck)->set((int64_t)n,nc->_typecheck[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); v->push(res);
return 1; 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("call"),closure_call,-1, _SC("c")},
{_SC("pcall"),closure_pcall,-1, _SC("c")}, {_SC("pcall"),closure_pcall,-1, _SC("c")},
{_SC("acall"),closure_acall,2, _SC("ca")}, {_SC("acall"),closure_acall,2, _SC("ca")},
@ -1027,16 +1027,16 @@ const SQRegFunction SQSharedState::_closure_default_delegate_funcz[]={
//GENERATOR DEFAULT DELEGATE //GENERATOR DEFAULT DELEGATE
static int64_t generator_getstatus(rabbit::VirtualMachine* v) 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){ switch(_generator(o)->_state){
case SQGenerator::eSuspended:v->push(SQString::create(_ss(v),_SC("suspended")));break; case SQGenerator::eSuspended:v->push(SQString::create(_get_shared_state(v),_SC("suspended")));break;
case SQGenerator::eRunning:v->push(SQString::create(_ss(v),_SC("running")));break; case SQGenerator::eRunning:v->push(SQString::create(_get_shared_state(v),_SC("running")));break;
case SQGenerator::eDead:v->push(SQString::create(_ss(v),_SC("dead")));break; case SQGenerator::eDead:v->push(SQString::create(_get_shared_state(v),_SC("dead")));break;
} }
return 1; 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("getstatus"),generator_getstatus,1, _SC("g")},
{_SC("weakref"),obj_delegate_weakref,1, NULL }, {_SC("weakref"),obj_delegate_weakref,1, NULL },
{_SC("tostring"),default_delegate_tostring,1, _SC(".")}, {_SC("tostring"),default_delegate_tostring,1, _SC(".")},
@ -1046,8 +1046,8 @@ const SQRegFunction SQSharedState::_generator_default_delegate_funcz[]={
//THREAD DEFAULT DELEGATE //THREAD DEFAULT DELEGATE
static int64_t thread_call(rabbit::VirtualMachine* v) static int64_t thread_call(rabbit::VirtualMachine* v)
{ {
SQObjectPtr o = stack_get(v,1); rabbit::ObjectPtr o = stack_get(v,1);
if(sq_type(o) == OT_THREAD) { if(sq_type(o) == rabbit::OT_THREAD) {
int64_t nparams = sq_gettop(v); int64_t nparams = sq_gettop(v);
_thread(o)->push(_thread(o)->_roottable); _thread(o)->push(_thread(o)->_roottable);
for(int64_t i = 2; i<(nparams+1); i++) 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) static int64_t thread_wakeup(rabbit::VirtualMachine* v)
{ {
SQObjectPtr o = stack_get(v,1); rabbit::ObjectPtr o = stack_get(v,1);
if(sq_type(o) == OT_THREAD) { if(sq_type(o) == rabbit::OT_THREAD) {
rabbit::VirtualMachine *thread = _thread(o); rabbit::VirtualMachine *thread = _thread(o);
int64_t state = sq_getvmstate(thread); int64_t state = sq_getvmstate(thread);
if(state != SQ_VMSTATE_SUSPENDED) { 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) static int64_t thread_wakeupthrow(rabbit::VirtualMachine* v)
{ {
SQObjectPtr o = stack_get(v,1); rabbit::ObjectPtr o = stack_get(v,1);
if(sq_type(o) == OT_THREAD) { if(sq_type(o) == rabbit::OT_THREAD) {
rabbit::VirtualMachine *thread = _thread(o); rabbit::VirtualMachine *thread = _thread(o);
int64_t state = sq_getvmstate(thread); int64_t state = sq_getvmstate(thread);
if(state != SQ_VMSTATE_SUSPENDED) { if(state != SQ_VMSTATE_SUSPENDED) {
@ -1118,7 +1118,7 @@ static int64_t thread_wakeupthrow(rabbit::VirtualMachine* v)
sq_move(thread,v,2); sq_move(thread,v,2);
sq_throwobject(thread); sq_throwobject(thread);
SQBool rethrow_error = SQTrue; rabbit::Bool rethrow_error = SQTrue;
if(sq_gettop(v) > 2) { if(sq_gettop(v) > 2) {
sq_getbool(v,3,&rethrow_error); 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) 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))) { switch(sq_getvmstate(_thread(o))) {
case SQ_VMSTATE_IDLE: case SQ_VMSTATE_IDLE:
sq_pushstring(v,_SC("idle"),-1); 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) static int64_t thread_getstackinfos(rabbit::VirtualMachine* v)
{ {
SQObjectPtr o = stack_get(v,1); rabbit::ObjectPtr o = stack_get(v,1);
if(sq_type(o) == OT_THREAD) { if(sq_type(o) == rabbit::OT_THREAD) {
rabbit::VirtualMachine *thread = _thread(o); rabbit::VirtualMachine *thread = _thread(o);
int64_t threadtop = sq_gettop(thread); int64_t threadtop = sq_gettop(thread);
int64_t level; int64_t level;
sq_getinteger(v,-1,&level); sq_getinteger(v,-1,&level);
SQRESULT res = __getcallstackinfos(thread,level); rabbit::Result res = __getcallstackinfos(thread,level);
if(SQ_FAILED(res)) if(SQ_FAILED(res))
{ {
sq_settop(thread,threadtop); 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)); sq_throwerror(v,_stringval(thread->_lasterror));
} }
else { else {
@ -1192,7 +1192,7 @@ static int64_t thread_getstackinfos(rabbit::VirtualMachine* v)
return sq_throwerror(v,_SC("wrong parameter")); 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("call"), thread_call, -1, _SC("v")},
{_SC("wakeup"), thread_wakeup, -1, _SC("v")}, {_SC("wakeup"), thread_wakeup, -1, _SC("v")},
{_SC("wakeupthrow"), thread_wakeupthrow, -2, _SC("v.b")}, {_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) static int64_t class_newmember(rabbit::VirtualMachine* v)
{ {
int64_t top = sq_gettop(v); int64_t top = sq_gettop(v);
SQBool bstatic = SQFalse; rabbit::Bool bstatic = SQFalse;
if(top == 5) if(top == 5)
{ {
sq_tobool(v,-1,&bstatic); 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) static int64_t class_rawnewmember(rabbit::VirtualMachine* v)
{ {
int64_t top = sq_gettop(v); int64_t top = sq_gettop(v);
SQBool bstatic = SQFalse; rabbit::Bool bstatic = SQFalse;
if(top == 5) if(top == 5)
{ {
sq_tobool(v,-1,&bstatic); 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; 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("getattributes"), class_getattributes, 2, _SC("y.")},
{_SC("setattributes"), class_setattributes, 3, _SC("y..")}, {_SC("setattributes"), class_setattributes, 3, _SC("y..")},
{_SC("rawget"),container_rawget,2, _SC("y")}, {_SC("rawget"),container_rawget,2, _SC("y")},
@ -1278,7 +1278,7 @@ static int64_t instance_getclass(rabbit::VirtualMachine* v)
return SQ_ERROR; 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("getclass"), instance_getclass, 1, _SC("x")},
{_SC("rawget"),container_rawget,2, _SC("x")}, {_SC("rawget"),container_rawget,2, _SC("x")},
{_SC("rawset"),container_rawset,3, _SC("x")}, {_SC("rawset"),container_rawset,3, _SC("x")},
@ -1295,7 +1295,7 @@ static int64_t weakref_ref(rabbit::VirtualMachine* v)
return 1; 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("ref"),weakref_ref,1, _SC("r")},
{_SC("weakref"),obj_delegate_weakref,1, NULL }, {_SC("weakref"),obj_delegate_weakref,1, NULL },
{_SC("tostring"),default_delegate_tostring,1, _SC(".")}, {_SC("tostring"),default_delegate_tostring,1, _SC(".")},

40
rabbit/sqclass.cpp
View File

@ -50,10 +50,10 @@ SQClass::~SQClass()
finalize(); 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; rabbit::ObjectPtr temp;
bool belongs_to_static_table = sq_type(val) == OT_CLOSURE || sq_type(val) == OT_NATIVECLOSURE || bstatic; bool belongs_to_static_table = sq_type(val) == rabbit::OT_CLOSURE || sq_type(val) == OT_NATIVECLOSURE || bstatic;
if(_locked && !belongs_to_static_table) if(_locked && !belongs_to_static_table)
return false; //the class already has an instance so cannot be modified return false; //the class already has an instance so cannot be modified
if(_members->get(key,temp) && _isfield(temp)) //overrides the default value 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) { if(belongs_to_static_table) {
int64_t mmidx; 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) { (mmidx = ss->getMetaMethodIdxByName(key)) != -1) {
_metamethods[mmidx] = val; _metamethods[mmidx] = val;
} }
else { else {
SQObjectPtr theval = val; rabbit::ObjectPtr theval = val;
if(_base && sq_type(val) == OT_CLOSURE) { if(_base && sq_type(val) == rabbit::OT_CLOSURE) {
theval = _closure(val)->clone(); theval = _closure(val)->clone();
_closure(theval)->_base = _base; _closure(theval)->_base = _base;
__ObjaddRef(_base); //ref for the closure __ObjaddRef(_base); //ref for the closure
} }
if(sq_type(temp) == OT_NULL) { if(sq_type(temp) == rabbit::OT_NULL) {
bool isconstructor; bool isconstructor;
rabbit::VirtualMachine::isEqual(ss->_constructoridx, key, isconstructor); rabbit::VirtualMachine::isEqual(ss->_constructoridx, key, isconstructor);
if(isconstructor) { if(isconstructor) {
@ -82,7 +82,7 @@ bool SQClass::newSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr
} }
SQClassMember m; SQClassMember m;
m.val = theval; 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); _methods.pushBack(m);
} }
else { else {
@ -93,7 +93,7 @@ bool SQClass::newSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr
} }
SQClassMember m; SQClassMember m;
m.val = val; 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); _defaultvalues.pushBack(m);
return true; return true;
} }
@ -104,25 +104,25 @@ SQInstance *SQClass::createInstance()
return SQInstance::create(NULL,this); 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); int64_t idx = _members->next(false,refpos,outkey,oval);
if(idx != -1) { if(idx != -1) {
if(_ismethod(oval)) { if(_ismethod(oval)) {
outval = _methods[_member_idx(oval)].val; outval = _methods[_member_idx(oval)].val;
} }
else { else {
SQObjectPtr &o = _defaultvalues[_member_idx(oval)].val; rabbit::ObjectPtr &o = _defaultvalues[_member_idx(oval)].val;
outval = _realval(o); outval = _realval(o);
} }
} }
return idx; 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(_members->get(key,idx)) {
if(_isfield(idx)) if(_isfield(idx))
_defaultvalues[_member_idx(idx)].attrs = val; _defaultvalues[_member_idx(idx)].attrs = val;
@ -133,9 +133,9 @@ bool SQClass::setAttributes(const SQObjectPtr &key,const SQObjectPtr &val)
return false; 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)) { if(_members->get(key,idx)) {
outval = (_isfield(idx)?_defaultvalues[_member_idx(idx)].attrs:_methods[_member_idx(idx)].attrs); outval = (_isfield(idx)?_defaultvalues[_member_idx(idx)].attrs:_methods[_member_idx(idx)].attrs);
return true; return true;
@ -158,7 +158,7 @@ SQInstance::SQInstance(SQSharedState *ss, SQClass *c, int64_t memsize)
_class = c; _class = c;
uint64_t nvalues = _class->_defaultvalues.size(); uint64_t nvalues = _class->_defaultvalues.size();
for(uint64_t n = 0; n < nvalues; n++) { 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); init(ss);
} }
@ -169,7 +169,7 @@ SQInstance::SQInstance(SQSharedState *ss, SQInstance *i, int64_t memsize)
_class = i->_class; _class = i->_class;
uint64_t nvalues = _class->_defaultvalues.size(); uint64_t nvalues = _class->_defaultvalues.size();
for(uint64_t n = 0; n < nvalues; n++) { 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); init(ss);
} }
@ -186,9 +186,9 @@ SQInstance::~SQInstance()
if(_class){ finalize(); } //if _class is null it was already finalized by the GC 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]; res = _class->_metamethods[mm];
return true; return true;
} }

42
rabbit/sqclass.hpp
View File

@ -10,8 +10,8 @@
struct SQInstance; struct SQInstance;
struct SQClassMember { struct SQClassMember {
SQObjectPtr val; rabbit::ObjectPtr val;
SQObjectPtr attrs; rabbit::ObjectPtr attrs;
void Null() { void Null() {
val.Null(); val.Null();
attrs.Null(); attrs.Null();
@ -40,11 +40,11 @@ public:
return newclass; return newclass;
} }
~SQClass(); ~SQClass();
bool newSlot(SQSharedState *ss, const SQObjectPtr &key,const SQObjectPtr &val,bool bstatic); bool newSlot(SQSharedState *ss, const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,bool bstatic);
bool get(const SQObjectPtr &key,SQObjectPtr &val) { bool get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val) {
if(_members->get(key,val)) { if(_members->get(key,val)) {
if(_isfield(val)) { if(_isfield(val)) {
SQObjectPtr &o = _defaultvalues[_member_idx(val)].val; rabbit::ObjectPtr &o = _defaultvalues[_member_idx(val)].val;
val = _realval(o); val = _realval(o);
} }
else { else {
@ -54,7 +54,7 @@ public:
} }
return false; return false;
} }
bool getConstructor(SQObjectPtr &ctor) bool getConstructor(rabbit::ObjectPtr &ctor)
{ {
if(_constructoridx != -1) { if(_constructoridx != -1) {
ctor = _methods[_constructoridx].val; ctor = _methods[_constructoridx].val;
@ -62,23 +62,23 @@ public:
} }
return false; return false;
} }
bool setAttributes(const SQObjectPtr &key,const SQObjectPtr &val); bool setAttributes(const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val);
bool getAttributes(const SQObjectPtr &key,SQObjectPtr &outval); bool getAttributes(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &outval);
void lock() { _locked = true; if(_base) _base->lock(); } void lock() { _locked = true; if(_base) _base->lock(); }
void release() { void release() {
if (_hook) { _hook(_typetag,0);} if (_hook) { _hook(_typetag,0);}
sq_delete(this, SQClass); sq_delete(this, SQClass);
} }
void finalize(); 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(); SQInstance *createInstance();
SQTable *_members; SQTable *_members;
SQClass *_base; SQClass *_base;
SQClassMemberVec _defaultvalues; SQClassMemberVec _defaultvalues;
SQClassMemberVec _methods; SQClassMemberVec _methods;
SQObjectPtr _metamethods[MT_LAST]; rabbit::ObjectPtr _metamethods[MT_LAST];
SQObjectPtr _attributes; rabbit::ObjectPtr _attributes;
SQUserPointer _typetag; rabbit::UserPointer _typetag;
SQRELEASEHOOK _hook; SQRELEASEHOOK _hook;
bool _locked; bool _locked;
int64_t _constructoridx; int64_t _constructoridx;
@ -86,9 +86,9 @@ public:
}; };
#define calcinstancesize(_theclass_) \ #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); void init(SQSharedState *ss);
SQInstance(SQSharedState *ss, SQClass *c, int64_t memsize); SQInstance(SQSharedState *ss, SQClass *c, int64_t memsize);
@ -115,10 +115,10 @@ public:
return newinst; return newinst;
} }
~SQInstance(); ~SQInstance();
bool get(const SQObjectPtr &key,SQObjectPtr &val) { bool get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val) {
if(_class->_members->get(key,val)) { if(_class->_members->get(key,val)) {
if(_isfield(val)) { if(_isfield(val)) {
SQObjectPtr &o = _values[_member_idx(val)]; rabbit::ObjectPtr &o = _values[_member_idx(val)];
val = _realval(o); val = _realval(o);
} }
else { else {
@ -128,8 +128,8 @@ public:
} }
return false; return false;
} }
bool set(const SQObjectPtr &key,const SQObjectPtr &val) { bool set(const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val) {
SQObjectPtr idx; rabbit::ObjectPtr idx;
if(_class->_members->get(key,idx) && _isfield(idx)) { if(_class->_members->get(key,idx) && _isfield(idx)) {
_values[_member_idx(idx)] = val; _values[_member_idx(idx)] = val;
return true; return true;
@ -147,12 +147,12 @@ public:
} }
void finalize(); void finalize();
bool instanceOf(SQClass *trg); 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; SQClass *_class;
SQUserPointer _userpointer; rabbit::UserPointer _userpointer;
SQRELEASEHOOK _hook; SQRELEASEHOOK _hook;
int64_t _memsize; int64_t _memsize;
SQObjectPtr _values[1]; rabbit::ObjectPtr _values[1];
}; };

50
rabbit/sqclosure.hpp
View File

@ -7,7 +7,7 @@
*/ */
#pragma once #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 SQFunctionProto;
struct SQClass; struct SQClass;
@ -25,19 +25,19 @@ public:
int64_t size = _CALC_CLOSURE_SIZE(func); int64_t size = _CALC_CLOSURE_SIZE(func);
SQClosure *nc=(SQClosure*)SQ_MALLOC(size); SQClosure *nc=(SQClosure*)SQ_MALLOC(size);
new (nc) SQClosure(ss,func); new (nc) SQClosure(ss,func);
nc->_outervalues = (SQObjectPtr *)(nc + 1); nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1);
nc->_defaultparams = &nc->_outervalues[func->_noutervalues]; nc->_defaultparams = &nc->_outervalues[func->_noutervalues];
nc->_root = root; nc->_root = root;
__ObjaddRef(nc->_root); __ObjaddRef(nc->_root);
_CONSTRUCT_VECTOR(SQObjectPtr,func->_noutervalues,nc->_outervalues); _CONSTRUCT_VECTOR(rabbit::ObjectPtr,func->_noutervalues,nc->_outervalues);
_CONSTRUCT_VECTOR(SQObjectPtr,func->_ndefaultparams,nc->_defaultparams); _CONSTRUCT_VECTOR(rabbit::ObjectPtr,func->_ndefaultparams,nc->_defaultparams);
return nc; return nc;
} }
void release(){ void release(){
SQFunctionProto *f = _function; SQFunctionProto *f = _function;
int64_t size = _CALC_CLOSURE_SIZE(f); int64_t size = _CALC_CLOSURE_SIZE(f);
_DESTRUCT_VECTOR(SQObjectPtr,f->_noutervalues,_outervalues); _DESTRUCT_VECTOR(rabbit::ObjectPtr,f->_noutervalues,_outervalues);
_DESTRUCT_VECTOR(SQObjectPtr,f->_ndefaultparams,_defaultparams); _DESTRUCT_VECTOR(rabbit::ObjectPtr,f->_ndefaultparams,_defaultparams);
__Objrelease(_function); __Objrelease(_function);
this->~SQClosure(); this->~SQClosure();
sq_vm_free(this,size); sq_vm_free(this,size);
@ -60,14 +60,14 @@ public:
} }
~SQClosure(); ~SQClosure();
bool save(rabbit::VirtualMachine *v,SQUserPointer up,SQWRITEFUNC write); bool save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write);
static bool load(rabbit::VirtualMachine *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret); static bool load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &ret);
rabbit::WeakRef *_env; rabbit::WeakRef *_env;
rabbit::WeakRef *_root; rabbit::WeakRef *_root;
SQClass *_base; SQClass *_base;
SQFunctionProto *_function; SQFunctionProto *_function;
SQObjectPtr *_outervalues; rabbit::ObjectPtr *_outervalues;
SQObjectPtr *_defaultparams; rabbit::ObjectPtr *_defaultparams;
}; };
////////////////////////////////////////////// //////////////////////////////////////////////
@ -75,13 +75,13 @@ struct SQOuter : public rabbit::RefCounted
{ {
private: private:
SQOuter(SQSharedState *ss, SQObjectPtr *outer){ SQOuter(SQSharedState *ss, rabbit::ObjectPtr *outer){
_valptr = outer; _valptr = outer;
_next = NULL; _next = NULL;
} }
public: public:
static SQOuter *create(SQSharedState *ss, SQObjectPtr *outer) static SQOuter *create(SQSharedState *ss, rabbit::ObjectPtr *outer)
{ {
SQOuter *nc = (SQOuter*)SQ_MALLOC(sizeof(SQOuter)); SQOuter *nc = (SQOuter*)SQ_MALLOC(sizeof(SQOuter));
new (nc) SQOuter(ss, outer); new (nc) SQOuter(ss, outer);
@ -97,9 +97,9 @@ public:
sq_vm_free(this,sizeof(SQOuter)); 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 */ 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 */ SQOuter *_next; /* pointer to next outer when frame is open */
}; };
@ -132,15 +132,15 @@ public:
} }
bool yield(rabbit::VirtualMachine *v,int64_t target); bool yield(rabbit::VirtualMachine *v,int64_t target);
bool resume(rabbit::VirtualMachine *v,SQObjectPtr &dest); bool resume(rabbit::VirtualMachine *v,rabbit::ObjectPtr &dest);
SQObjectPtr _closure; rabbit::ObjectPtr _closure;
SQObjectPtrVec _stack; etk::Vector<rabbit::ObjectPtr> _stack;
rabbit::VirtualMachine::callInfo _ci; rabbit::VirtualMachine::callInfo _ci;
etk::Vector<SQExceptionTrap> _etraps; etk::Vector<rabbit::ExceptionTrap> _etraps;
SQGeneratorState _state; 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 struct SQNativeClosure : public rabbit::RefCounted
{ {
@ -155,9 +155,9 @@ public:
int64_t size = _CALC_NATVIVECLOSURE_SIZE(nouters); int64_t size = _CALC_NATVIVECLOSURE_SIZE(nouters);
SQNativeClosure *nc=(SQNativeClosure*)SQ_MALLOC(size); SQNativeClosure *nc=(SQNativeClosure*)SQ_MALLOC(size);
new (nc) SQNativeClosure(ss,func); new (nc) SQNativeClosure(ss,func);
nc->_outervalues = (SQObjectPtr *)(nc + 1); nc->_outervalues = (rabbit::ObjectPtr *)(nc + 1);
nc->_noutervalues = nouters; nc->_noutervalues = nouters;
_CONSTRUCT_VECTOR(SQObjectPtr,nc->_noutervalues,nc->_outervalues); _CONSTRUCT_VECTOR(rabbit::ObjectPtr,nc->_noutervalues,nc->_outervalues);
return nc; return nc;
} }
SQNativeClosure *clone() SQNativeClosure *clone()
@ -177,18 +177,18 @@ public:
} }
void release(){ void release(){
int64_t size = _CALC_NATVIVECLOSURE_SIZE(_noutervalues); int64_t size = _CALC_NATVIVECLOSURE_SIZE(_noutervalues);
_DESTRUCT_VECTOR(SQObjectPtr,_noutervalues,_outervalues); _DESTRUCT_VECTOR(rabbit::ObjectPtr,_noutervalues,_outervalues);
this->~SQNativeClosure(); this->~SQNativeClosure();
sq_free(this,size); sq_free(this,size);
} }
int64_t _nparamscheck; int64_t _nparamscheck;
SQIntVec _typecheck; etk::Vector<int64_t> _typecheck;
SQObjectPtr *_outervalues; rabbit::ObjectPtr *_outervalues;
uint64_t _noutervalues; uint64_t _noutervalues;
rabbit::WeakRef *_env; rabbit::WeakRef *_env;
SQFUNCTION _function; SQFUNCTION _function;
SQObjectPtr _name; rabbit::ObjectPtr _name;
}; };

118
rabbit/sqcompiler.cpp
View File

@ -76,21 +76,21 @@ struct SQScope {
class SQcompiler class SQcompiler
{ {
public: 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; _vm=v;
_lex.init(_ss(v), rg, up,Throwerror,this); _lex.init(_get_shared_state(v), rg, up,Throwerror,this);
_sourcename = SQString::create(_ss(v), sourcename); _sourcename = SQString::create(_get_shared_state(v), sourcename);
_lineinfo = lineinfo;_raiseerror = raiseerror; _lineinfo = lineinfo;_raiseerror = raiseerror;
_scope.outers = 0; _scope.outers = 0;
_scope.stacksize = 0; _scope.stacksize = 0;
_compilererror[0] = _SC('\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; SQcompiler *c = (SQcompiler *)ud;
c->error(s); c->error(s);
} }
void error(const SQChar *s, ...) void error(const rabbit::Char *s, ...)
{ {
va_list vl; va_list vl;
va_start(vl, s); va_start(vl, s);
@ -99,7 +99,7 @@ public:
longjmp(_errorjmp,1); longjmp(_errorjmp,1);
} }
void Lex(){ _token = _lex.Lex();} void Lex(){ _token = _lex.Lex();}
SQObject Expect(int64_t tok) rabbit::Object Expect(int64_t tok)
{ {
if(_token != tok) { if(_token != tok) {
@ -107,7 +107,7 @@ public:
//do nothing //do nothing
} }
else { else {
const SQChar *etypename; const rabbit::Char *etypename;
if(tok > 255) { if(tok > 255) {
switch(tok) switch(tok)
{ {
@ -131,7 +131,7 @@ public:
error(_SC("expected '%c'"), tok); error(_SC("expected '%c'"), tok);
} }
} }
SQObjectPtr ret; rabbit::ObjectPtr ret;
switch(tok) switch(tok)
{ {
case TK_IDENTIFIER: case TK_IDENTIFIER:
@ -141,10 +141,10 @@ public:
ret = _fs->createString(_lex._svalue,_lex._longstr.size()-1); ret = _fs->createString(_lex._svalue,_lex._longstr.size()-1);
break; break;
case TK_INTEGER: case TK_INTEGER:
ret = SQObjectPtr(_lex._nvalue); ret = rabbit::ObjectPtr(_lex._nvalue);
break; break;
case TK_FLOAT: case TK_FLOAT:
ret = SQObjectPtr(_lex._fvalue); ret = rabbit::ObjectPtr(_lex._fvalue);
break; break;
} }
Lex(); Lex();
@ -165,13 +165,13 @@ public:
_fs->addInstruction(_OP_MOVE, _fs->pushTarget(), trg); _fs->addInstruction(_OP_MOVE, _fs->pushTarget(), trg);
} }
} }
bool compile(SQObjectPtr &o) bool compile(rabbit::ObjectPtr &o)
{ {
_debugline = 1; _debugline = 1;
_debugop = 0; _debugop = 0;
SQFuncState funcstate(_ss(_vm), NULL,Throwerror,this); SQFuncState funcstate(_get_shared_state(_vm), NULL,Throwerror,this);
funcstate._name = SQString::create(_ss(_vm), _SC("main")); funcstate._name = SQString::create(_get_shared_state(_vm), _SC("main"));
_fs = &funcstate; _fs = &funcstate;
_fs->addParameter(_fs->createString(_SC("this"))); _fs->addParameter(_fs->createString(_SC("this")));
_fs->addParameter(_fs->createString(_SC("vargv"))); _fs->addParameter(_fs->createString(_SC("vargv")));
@ -194,11 +194,11 @@ public:
#endif #endif
} }
else { else {
if(_raiseerror && _ss(_vm)->_compilererrorhandler) { if(_raiseerror && _get_shared_state(_vm)->_compilererrorhandler) {
_ss(_vm)->_compilererrorhandler(_vm, _compilererror, sq_type(_sourcename) == OT_STRING?_stringval(_sourcename):_SC("unknown"), _get_shared_state(_vm)->_compilererrorhandler(_vm, _compilererror, sq_type(_sourcename) == rabbit::OT_STRING?_stringval(_sourcename):_SC("unknown"),
_lex._currentline, _lex._currentcolumn); _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 false;
} }
return true; return true;
@ -301,13 +301,13 @@ public:
case TK_CONST: case TK_CONST:
{ {
Lex(); Lex();
SQObject id = Expect(TK_IDENTIFIER); rabbit::Object id = Expect(TK_IDENTIFIER);
Expect('='); Expect('=');
SQObject val = ExpectScalar(); rabbit::Object val = ExpectScalar();
OptionalSemicolon(); OptionalSemicolon();
SQTable *enums = _table(_ss(_vm)->_consts); SQTable *enums = _table(_get_shared_state(_vm)->_consts);
SQObjectPtr strongid = id; rabbit::ObjectPtr strongid = id;
enums->newSlot(strongid,SQObjectPtr(val)); enums->newSlot(strongid,rabbit::ObjectPtr(val));
strongid.Null(); strongid.Null();
} }
break; break;
@ -734,8 +734,8 @@ public:
case TK_IDENTIFIER: case TK_IDENTIFIER:
case TK_CONSTRUCTOR: case TK_CONSTRUCTOR:
case TK_THIS:{ case TK_THIS:{
SQObject id; rabbit::Object id;
SQObject constant; rabbit::Object constant;
switch(_token) { switch(_token) {
case TK_IDENTIFIER: id = _fs->createString(_lex._svalue); break; case TK_IDENTIFIER: id = _fs->createString(_lex._svalue); break;
@ -767,9 +767,9 @@ public:
else if(_fs->isConstant(id, constant)) { else if(_fs->isConstant(id, constant)) {
/* Handle named constant */ /* Handle named constant */
SQObjectPtr constval; rabbit::ObjectPtr constval;
SQObject constid; rabbit::Object constid;
if(sq_type(constant) == OT_TABLE) { if(sq_type(constant) == rabbit::OT_TABLE) {
Expect('.'); Expect('.');
constid = Expect(TK_IDENTIFIER); constid = Expect(TK_IDENTIFIER);
if(!_table(constant)->get(constid, constval)) { if(!_table(constant)->get(constid, constval)) {
@ -783,11 +783,11 @@ public:
_es.epos = _fs->pushTarget(); _es.epos = _fs->pushTarget();
/* generate direct or literal function depending on size */ /* generate direct or literal function depending on size */
SQObjectType ctype = sq_type(constval); rabbit::ObjectType ctype = sq_type(constval);
switch(ctype) { switch(ctype) {
case OT_INTEGER: EmitloadConstInt(_integer(constval),_es.epos); break; case rabbit::OT_INTEGER: EmitloadConstInt(_integer(constval),_es.epos); break;
case OT_FLOAT: EmitloadConstFloat(_float(constval),_es.epos); break; case rabbit::OT_FLOAT: EmitloadConstFloat(_float(constval),_es.epos); break;
case OT_BOOL: _fs->addInstruction(_OP_LOADBOOL, _es.epos, _integer(constval)); 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; default: _fs->addInstruction(_OP_LOAD,_es.epos,_fs->getConstant(constval)); break;
} }
_es.etype = EXPR; _es.etype = EXPR;
@ -968,7 +968,7 @@ public:
case TK_CONSTRUCTOR:{ case TK_CONSTRUCTOR:{
int64_t tk = _token; int64_t tk = _token;
Lex(); 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('(')); Expect(_SC('('));
_fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(id)); _fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(id));
createFunction(id); createFunction(id);
@ -1011,7 +1011,7 @@ public:
} }
void LocalDeclStatement() void LocalDeclStatement()
{ {
SQObject varname; rabbit::Object varname;
Lex(); Lex();
if( _token == TK_FUNCTION) { if( _token == TK_FUNCTION) {
Lex(); Lex();
@ -1182,7 +1182,7 @@ public:
} }
void ForEachStatement() void ForEachStatement()
{ {
SQObject idxname, valname; rabbit::Object idxname, valname;
Lex(); Expect(_SC('(')); valname = Expect(TK_IDENTIFIER); Lex(); Expect(_SC('(')); valname = Expect(TK_IDENTIFIER);
if(_token == _SC(',')) { if(_token == _SC(',')) {
idxname = valname; idxname = valname;
@ -1278,7 +1278,7 @@ public:
} }
void FunctionStatement() void FunctionStatement()
{ {
SQObject id; rabbit::Object id;
Lex(); id = Expect(TK_IDENTIFIER); Lex(); id = Expect(TK_IDENTIFIER);
_fs->pushTarget(0); _fs->pushTarget(0);
_fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(id)); _fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(id));
@ -1316,17 +1316,17 @@ public:
} }
_es = es; _es = es;
} }
SQObject ExpectScalar() rabbit::Object ExpectScalar()
{ {
SQObject val; rabbit::Object val;
val._type = OT_NULL; val._unVal.nInteger = 0; //shut up GCC 4.x val._type = rabbit::OT_NULL; val._unVal.nInteger = 0; //shut up GCC 4.x
switch(_token) { switch(_token) {
case TK_INTEGER: case TK_INTEGER:
val._type = OT_INTEGER; val._type = rabbit::OT_INTEGER;
val._unVal.nInteger = _lex._nvalue; val._unVal.nInteger = _lex._nvalue;
break; break;
case TK_FLOAT: case TK_FLOAT:
val._type = OT_FLOAT; val._type = rabbit::OT_FLOAT;
val._unVal.fFloat = _lex._fvalue; val._unVal.fFloat = _lex._fvalue;
break; break;
case TK_STRING_LITERAL: case TK_STRING_LITERAL:
@ -1334,7 +1334,7 @@ public:
break; break;
case TK_TRUE: case TK_TRUE:
case TK_FALSE: case TK_FALSE:
val._type = OT_BOOL; val._type = rabbit::OT_BOOL;
val._unVal.nInteger = _token == TK_TRUE ? 1 : 0; val._unVal.nInteger = _token == TK_TRUE ? 1 : 0;
break; break;
case '-': case '-':
@ -1342,11 +1342,11 @@ public:
switch(_token) switch(_token)
{ {
case TK_INTEGER: case TK_INTEGER:
val._type = OT_INTEGER; val._type = rabbit::OT_INTEGER;
val._unVal.nInteger = -_lex._nvalue; val._unVal.nInteger = -_lex._nvalue;
break; break;
case TK_FLOAT: case TK_FLOAT:
val._type = OT_FLOAT; val._type = rabbit::OT_FLOAT;
val._unVal.fFloat = -_lex._fvalue; val._unVal.fFloat = -_lex._fvalue;
break; break;
default: default:
@ -1362,34 +1362,34 @@ public:
void EnumStatement() void EnumStatement()
{ {
Lex(); Lex();
SQObject id = Expect(TK_IDENTIFIER); rabbit::Object id = Expect(TK_IDENTIFIER);
Expect(_SC('{')); Expect(_SC('{'));
SQObject table = _fs->createTable(); rabbit::Object table = _fs->createTable();
int64_t nval = 0; int64_t nval = 0;
while(_token != _SC('}')) { while(_token != _SC('}')) {
SQObject key = Expect(TK_IDENTIFIER); rabbit::Object key = Expect(TK_IDENTIFIER);
SQObject val; rabbit::Object val;
if(_token == _SC('=')) { if(_token == _SC('=')) {
Lex(); Lex();
val = ExpectScalar(); val = ExpectScalar();
} }
else { else {
val._type = OT_INTEGER; val._type = rabbit::OT_INTEGER;
val._unVal.nInteger = nval++; val._unVal.nInteger = nval++;
} }
_table(table)->newSlot(SQObjectPtr(key),SQObjectPtr(val)); _table(table)->newSlot(rabbit::ObjectPtr(key),rabbit::ObjectPtr(val));
if(_token == ',') Lex(); if(_token == ',') Lex();
} }
SQTable *enums = _table(_ss(_vm)->_consts); SQTable *enums = _table(_get_shared_state(_vm)->_consts);
SQObjectPtr strongid = id; rabbit::ObjectPtr strongid = id;
enums->newSlot(SQObjectPtr(strongid),SQObjectPtr(table)); enums->newSlot(rabbit::ObjectPtr(strongid),rabbit::ObjectPtr(table));
strongid.Null(); strongid.Null();
Lex(); Lex();
} }
void TryCatchStatement() void TryCatchStatement()
{ {
SQObject exid; rabbit::Object exid;
Lex(); Lex();
_fs->addInstruction(_OP_PUSHTRAP,0,0); _fs->addInstruction(_OP_PUSHTRAP,0,0);
_fs->_traps++; _fs->_traps++;
@ -1421,7 +1421,7 @@ public:
void FunctionExp(int64_t ftype,bool lambda = false) void FunctionExp(int64_t ftype,bool lambda = false)
{ {
Lex(); Expect(_SC('(')); Lex(); Expect(_SC('('));
SQObjectPtr dummy; rabbit::ObjectPtr dummy;
createFunction(dummy,lambda); createFunction(dummy,lambda);
_fs->addInstruction(_OP_CLOSURE, _fs->pushTarget(), _fs->_functions.size() - 1, ftype == TK_FUNCTION?0:1); _fs->addInstruction(_OP_CLOSURE, _fs->pushTarget(), _fs->_functions.size() - 1, ftype == TK_FUNCTION?0:1);
} }
@ -1488,11 +1488,11 @@ public:
} }
_es = es; _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; funcstate->_name = name;
SQObject paramname; rabbit::Object paramname;
funcstate->addParameter(_fs->createString(_SC("this"))); funcstate->addParameter(_fs->createString(_SC("this")));
funcstate->_sourcename = _sourcename; funcstate->_sourcename = _sourcename;
int64_t defparams = 0; int64_t defparams = 0;
@ -1569,7 +1569,7 @@ public:
private: private:
int64_t _token; int64_t _token;
SQFuncState *_fs; SQFuncState *_fs;
SQObjectPtr _sourcename; rabbit::ObjectPtr _sourcename;
SQLexer _lex; SQLexer _lex;
bool _lineinfo; bool _lineinfo;
bool _raiseerror; bool _raiseerror;
@ -1577,12 +1577,12 @@ private:
int64_t _debugop; int64_t _debugop;
SQExpState _es; SQExpState _es;
SQScope _scope; SQScope _scope;
SQChar _compilererror[MAX_COMPILER_ERROR_LEN]; rabbit::Char _compilererror[MAX_COMPILER_ERROR_LEN];
jmp_buf _errorjmp; jmp_buf _errorjmp;
rabbit::VirtualMachine *_vm; 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); SQcompiler p(vm, rg, up, sourcename, raiseerror, lineinfo);
return p.compile(out); return p.compile(out);

4
rabbit/sqcompiler.hpp
View File

@ -80,5 +80,5 @@ namespace rabbit {
typedef void(*compilererrorFunc)(void *ud, const SQChar *s); typedef void(*compilererrorFunc)(void *ud, const rabbit::Char *s);
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);

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 #define SQ_ALIGNMENT 8
#endif #endif
typedef void* SQUserPointer; namespace rabbit {
typedef uint64_t SQBool; using UserPointer = void*;
typedef int64_t SQRESULT; using Bool = uint64_t;
using Result = int64_t;
}
#ifdef SQUNICODE #ifdef SQUNICODE
#include <wchar.h> #include <wchar.h>
#include <wctype.h> #include <wctype.h>
namespace rabbit {
using Char = wchar_t;
typedef wchar_t SQChar; }
#define scstrcmp wcscmp #define scstrcmp wcscmp
#ifdef _WIN32 #ifdef _WIN32
#define scsprintf _snwprintf #define scsprintf _snwprintf
@ -70,10 +71,7 @@ typedef wchar_t SQChar;
#define WCHAR_SHIFT_MUL 2 #define WCHAR_SHIFT_MUL 2
#define MAX_CHAR 0xFFFFFFFF #define MAX_CHAR 0xFFFFFFFF
#endif #endif
#define _SC(a) L##a #define _SC(a) L##a
#define scisspace iswspace #define scisspace iswspace
#define scisdigit iswdigit #define scisdigit iswdigit
#define scisprint iswprint #define scisprint iswprint
@ -81,12 +79,11 @@ typedef wchar_t SQChar;
#define scisalpha iswalpha #define scisalpha iswalpha
#define sciscntrl iswcntrl #define sciscntrl iswcntrl
#define scisalnum iswalnum #define scisalnum iswalnum
#define sq_rsl(l) ((l)<<WCHAR_SHIFT_MUL) #define sq_rsl(l) ((l)<<WCHAR_SHIFT_MUL)
#else #else
typedef char SQChar; namespace rabbit {
using Char = char;
}
#define _SC(a) a #define _SC(a) a
#define scstrcmp strcmp #define scstrcmp strcmp
#ifdef _MSC_VER #ifdef _MSC_VER
@ -124,3 +121,28 @@ typedef char SQChar;
#define _PRINT_INT_PREC _SC("ll") #define _PRINT_INT_PREC _SC("ll")
#define _PRINT_INT_FMT _SC("%ld") #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/sqclosure.hpp>
#include <rabbit/sqstring.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; int64_t cssize = v->_callsstacksize;
if (cssize > level) { if (cssize > level) {
@ -22,8 +22,8 @@ SQRESULT sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,SQFunctionIn
SQClosure *c = _closure(ci._closure); SQClosure *c = _closure(ci._closure);
SQFunctionProto *proto = c->_function; SQFunctionProto *proto = c->_function;
fi->funcid = proto; fi->funcid = proto;
fi->name = sq_type(proto->_name) == OT_STRING?_stringval(proto->_name):_SC("unknown"); fi->name = sq_type(proto->_name) == rabbit::OT_STRING?_stringval(proto->_name):_SC("unknown");
fi->source = sq_type(proto->_sourcename) == OT_STRING?_stringval(proto->_sourcename):_SC("unknown"); fi->source = sq_type(proto->_sourcename) == rabbit::OT_STRING?_stringval(proto->_sourcename):_SC("unknown");
fi->line = proto->_lineinfos[0]._line; fi->line = proto->_lineinfos[0]._line;
return SQ_OK; 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")); 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; int64_t cssize = v->_callsstacksize;
if (cssize > level) { if (cssize > level) {
memset(si, 0, sizeof(SQStackInfos)); memset(si, 0, sizeof(rabbit::StackInfos));
rabbit::VirtualMachine::callInfo &ci = v->_callsstack[cssize-level-1]; rabbit::VirtualMachine::callInfo &ci = v->_callsstack[cssize-level-1];
switch (sq_type(ci._closure)) { switch (sq_type(ci._closure)) {
case OT_CLOSURE:{ case rabbit::OT_CLOSURE:{
SQFunctionProto *func = _closure(ci._closure)->_function; 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); 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->source = _stringval(func->_sourcename);
si->line = func->getLine(ci._ip); si->line = func->getLine(ci._ip);
} }
break; break;
case OT_NATIVECLOSURE: case rabbit::OT_NATIVECLOSURE:
si->source = _SC("NATIVE"); si->source = _SC("NATIVE");
si->funcname = _SC("unknown"); 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->funcname = _stringval(_nativeclosure(ci._closure)->_name);
si->line = -1; si->line = -1;
break; break;
@ -61,63 +61,63 @@ SQRESULT sq_stackinfos(rabbit::VirtualMachine* v, int64_t level, SQStackInfos *s
return SQ_ERROR; return SQ_ERROR;
} }
void rabbit::VirtualMachine::raise_error(const SQChar *s, ...) void rabbit::VirtualMachine::raise_error(const rabbit::Char *s, ...)
{ {
va_list vl; va_list vl;
va_start(vl, s); va_start(vl, s);
int64_t buffersize = (int64_t)scstrlen(s)+(NUMBER_MAX_CHAR*2); int64_t buffersize = (int64_t)scstrlen(s)+(NUMBER_MAX_CHAR*2);
scvsprintf(_sp(sq_rsl(buffersize)),buffersize, s, vl); scvsprintf(_sp(sq_rsl(buffersize)),buffersize, s, vl);
va_end(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; _lasterror = desc;
} }
SQString *rabbit::VirtualMachine::printObjVal(const SQObjectPtr &o) SQString *rabbit::VirtualMachine::printObjVal(const rabbit::ObjectPtr &o)
{ {
switch(sq_type(o)) { switch(sq_type(o)) {
case OT_STRING: return _string(o); case rabbit::OT_STRING: return _string(o);
case OT_INTEGER: case rabbit::OT_INTEGER:
scsprintf(_sp(sq_rsl(NUMBER_MAX_CHAR+1)),sq_rsl(NUMBER_MAX_CHAR), _PRINT_INT_FMT, _integer(o)); 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; 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)); 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; break;
default: 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)); 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)); 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) 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; int64_t found = 0;
for(int64_t i=0; i<16; i++) for(int64_t i=0; i<16; i++)
{ {
int64_t mask = ((int64_t)1) << i; int64_t mask = ((int64_t)1) << i;
if(typemask & (mask)) { 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 ++; 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(){}
SQOuterVar(const SQObjectPtr &name,const SQObjectPtr &src,SQOuterType t) SQOuterVar(const rabbit::ObjectPtr &name,const rabbit::ObjectPtr &src,SQOuterType t)
{ {
_name = name; _name = name;
_src=src; _src=src;
@ -31,8 +31,8 @@ struct SQOuterVar
_name=ov._name; _name=ov._name;
} }
SQOuterType _type; SQOuterType _type;
SQObjectPtr _name; rabbit::ObjectPtr _name;
SQObjectPtr _src; rabbit::ObjectPtr _src;
}; };
struct SQLocalVarInfo struct SQLocalVarInfo
@ -45,7 +45,7 @@ struct SQLocalVarInfo
_end_op=lvi._end_op; _end_op=lvi._end_op;
_pos=lvi._pos; _pos=lvi._pos;
} }
SQObjectPtr _name; rabbit::ObjectPtr _name;
uint64_t _start_op; uint64_t _start_op;
uint64_t _end_op; uint64_t _end_op;
uint64_t _pos; uint64_t _pos;
@ -58,8 +58,8 @@ typedef etk::Vector<SQLocalVarInfo> SQLocalVarInfoVec;
typedef etk::Vector<SQLineInfo> SQLineInfoVec; typedef etk::Vector<SQLineInfo> SQLineInfoVec;
#define _FUNC_SIZE(ni,nl,nparams,nfuncs,nouters,nlineinf,localinf,defparams) (sizeof(SQFunctionProto) \ #define _FUNC_SIZE(ni,nl,nparams,nfuncs,nouters,nlineinf,localinf,defparams) (sizeof(SQFunctionProto) \
+((ni-1)*sizeof(SQInstruction))+(nl*sizeof(SQObjectPtr)) \ +((ni-1)*sizeof(SQInstruction))+(nl*sizeof(rabbit::ObjectPtr)) \
+(nparams*sizeof(SQObjectPtr))+(nfuncs*sizeof(SQObjectPtr)) \ +(nparams*sizeof(rabbit::ObjectPtr))+(nfuncs*sizeof(rabbit::ObjectPtr)) \
+(nouters*sizeof(SQOuterVar))+(nlineinf*sizeof(SQLineInfo)) \ +(nouters*sizeof(SQOuterVar))+(nlineinf*sizeof(SQLineInfo)) \
+(localinf*sizeof(SQLocalVarInfo))+(defparams*sizeof(int64_t))) +(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)); f = (SQFunctionProto *)sq_vm_malloc(_FUNC_SIZE(ninstructions,nliterals,nparameters,nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams));
new (f) SQFunctionProto(ss); new (f) SQFunctionProto(ss);
f->_ninstructions = ninstructions; f->_ninstructions = ninstructions;
f->_literals = (SQObjectPtr*)&f->_instructions[ninstructions]; f->_literals = (rabbit::ObjectPtr*)&f->_instructions[ninstructions];
f->_nliterals = nliterals; f->_nliterals = nliterals;
f->_parameters = (SQObjectPtr*)&f->_literals[nliterals]; f->_parameters = (rabbit::ObjectPtr*)&f->_literals[nliterals];
f->_nparameters = nparameters; f->_nparameters = nparameters;
f->_functions = (SQObjectPtr*)&f->_parameters[nparameters]; f->_functions = (rabbit::ObjectPtr*)&f->_parameters[nparameters];
f->_nfunctions = nfunctions; f->_nfunctions = nfunctions;
f->_outervalues = (SQOuterVar*)&f->_functions[nfunctions]; f->_outervalues = (SQOuterVar*)&f->_functions[nfunctions];
f->_noutervalues = noutervalues; f->_noutervalues = noutervalues;
@ -96,18 +96,18 @@ public:
f->_defaultparams = (int64_t *)&f->_localvarinfos[nlocalvarinfos]; f->_defaultparams = (int64_t *)&f->_localvarinfos[nlocalvarinfos];
f->_ndefaultparams = ndefaultparams; f->_ndefaultparams = ndefaultparams;
_CONSTRUCT_VECTOR(SQObjectPtr,f->_nliterals,f->_literals); _CONSTRUCT_VECTOR(rabbit::ObjectPtr,f->_nliterals,f->_literals);
_CONSTRUCT_VECTOR(SQObjectPtr,f->_nparameters,f->_parameters); _CONSTRUCT_VECTOR(rabbit::ObjectPtr,f->_nparameters,f->_parameters);
_CONSTRUCT_VECTOR(SQObjectPtr,f->_nfunctions,f->_functions); _CONSTRUCT_VECTOR(rabbit::ObjectPtr,f->_nfunctions,f->_functions);
_CONSTRUCT_VECTOR(SQOuterVar,f->_noutervalues,f->_outervalues); _CONSTRUCT_VECTOR(SQOuterVar,f->_noutervalues,f->_outervalues);
//_CONSTRUCT_VECTOR(SQLineInfo,f->_nlineinfos,f->_lineinfos); //not required are 2 integers //_CONSTRUCT_VECTOR(SQLineInfo,f->_nlineinfos,f->_lineinfos); //not required are 2 integers
_CONSTRUCT_VECTOR(SQLocalVarInfo,f->_nlocalvarinfos,f->_localvarinfos); _CONSTRUCT_VECTOR(SQLocalVarInfo,f->_nlocalvarinfos,f->_localvarinfos);
return f; return f;
} }
void release(){ void release(){
_DESTRUCT_VECTOR(SQObjectPtr,_nliterals,_literals); _DESTRUCT_VECTOR(rabbit::ObjectPtr,_nliterals,_literals);
_DESTRUCT_VECTOR(SQObjectPtr,_nparameters,_parameters); _DESTRUCT_VECTOR(rabbit::ObjectPtr,_nparameters,_parameters);
_DESTRUCT_VECTOR(SQObjectPtr,_nfunctions,_functions); _DESTRUCT_VECTOR(rabbit::ObjectPtr,_nfunctions,_functions);
_DESTRUCT_VECTOR(SQOuterVar,_noutervalues,_outervalues); _DESTRUCT_VECTOR(SQOuterVar,_noutervalues,_outervalues);
//_DESTRUCT_VECTOR(SQLineInfo,_nlineinfos,_lineinfos); //not required are 2 integers //_DESTRUCT_VECTOR(SQLineInfo,_nlineinfos,_lineinfos); //not required are 2 integers
_DESTRUCT_VECTOR(SQLocalVarInfo,_nlocalvarinfos,_localvarinfos); _DESTRUCT_VECTOR(SQLocalVarInfo,_nlocalvarinfos,_localvarinfos);
@ -116,12 +116,12 @@ public:
sq_vm_free(this,size); 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); int64_t getLine(SQInstruction *curr);
bool save(rabbit::VirtualMachine *v,SQUserPointer up,SQWRITEFUNC write); bool save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write);
static bool load(rabbit::VirtualMachine *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret); static bool load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &ret);
SQObjectPtr _sourcename; rabbit::ObjectPtr _sourcename;
SQObjectPtr _name; rabbit::ObjectPtr _name;
int64_t _stacksize; int64_t _stacksize;
bool _bgenerator; bool _bgenerator;
int64_t _varparams; int64_t _varparams;
@ -133,13 +133,13 @@ public:
SQLineInfo *_lineinfos; SQLineInfo *_lineinfos;
int64_t _nliterals; int64_t _nliterals;
SQObjectPtr *_literals; rabbit::ObjectPtr *_literals;
int64_t _nparameters; int64_t _nparameters;
SQObjectPtr *_parameters; rabbit::ObjectPtr *_parameters;
int64_t _nfunctions; int64_t _nfunctions;
SQObjectPtr *_functions; rabbit::ObjectPtr *_functions;
int64_t _noutervalues; int64_t _noutervalues;
SQOuterVar *_outervalues; SQOuterVar *_outervalues;

66
rabbit/sqfuncstate.cpp
View File

@ -80,13 +80,13 @@ SQInstructionDesc g_InstrDesc[]={
{_SC("_OP_CLOSE")}, {_SC("_OP_CLOSE")},
}; };
#endif #endif
void dumpLiteral(SQObjectPtr &o) void dumpLiteral(rabbit::ObjectPtr &o)
{ {
switch(sq_type(o)){ switch(sq_type(o)){
case OT_STRING: scprintf(_SC("\"%s\""),_stringval(o));break; case rabbit::OT_STRING: scprintf(_SC("\"%s\""),_stringval(o));break;
case OT_FLOAT: scprintf(_SC("{%f}"),_float(o));break; case rabbit::OT_FLOAT: scprintf(_SC("{%f}"),_float(o));break;
case OT_INTEGER: scprintf(_SC("{") _PRINT_INT_FMT _SC("}"),_integer(o));break; case rabbit::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_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 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); _errfunc(_errtarget,err);
} }
@ -123,13 +123,13 @@ void SQFuncState::dump(SQFunctionProto *func)
uint64_t n=0,i; uint64_t n=0,i;
int64_t si; int64_t si;
scprintf(_SC("SQInstruction sizeof %d\n"),(int32_t)sizeof(SQInstruction)); 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("--------------------------------------------------------------------\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")); scprintf(_SC("-----LITERALS\n"));
SQObjectPtr refidx,key,val; rabbit::ObjectPtr refidx,key,val;
int64_t idx; int64_t idx;
SQObjectPtrVec templiterals; etk::Vector<rabbit::ObjectPtr> templiterals;
templiterals.resize(_nliterals); templiterals.resize(_nliterals);
while((idx=_table(_literals)->next(false,refidx,key,val))!=-1) { while((idx=_table(_literals)->next(false,refidx,key,val))!=-1) {
refidx=idx; refidx=idx;
@ -175,7 +175,7 @@ void SQFuncState::dump(SQFunctionProto *func)
scprintf(_SC("null")); scprintf(_SC("null"));
else { else {
int64_t refidx; 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)) { while(((refidx=_table(_literals)->next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) {
refo = refidx; refo = refidx;
} }
@ -191,7 +191,7 @@ void SQFuncState::dump(SQFunctionProto *func)
scprintf(_SC("null")); scprintf(_SC("null"));
else { else {
int64_t refidx; 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)) { while(((refidx=_table(_literals)->next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) {
refo = refidx; refo = refidx;
} }
@ -219,17 +219,17 @@ void SQFuncState::dump(SQFunctionProto *func)
int64_t SQFuncState::getNumericConstant(const int64_t cons) 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) 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)) if(!_table(_literals)->get(cons,val))
{ {
val = _nliterals; val = _nliterals;
@ -295,7 +295,7 @@ int64_t SQFuncState::popTarget()
uint64_t npos=_targetstack.back(); uint64_t npos=_targetstack.back();
assert(npos < _vlocals.size()); assert(npos < _vlocals.size());
SQLocalVarInfo &t = _vlocals[npos]; SQLocalVarInfo &t = _vlocals[npos];
if(sq_type(t._name)==OT_NULL){ if(sq_type(t._name)==rabbit::OT_NULL){
_vlocals.popBack(); _vlocals.popBack();
} }
_targetstack.popBack(); _targetstack.popBack();
@ -327,7 +327,7 @@ void SQFuncState::setStacksize(int64_t n)
while(size>n){ while(size>n){
size--; size--;
SQLocalVarInfo lvi = _vlocals.back(); 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 if(lvi._end_op == UINT_MINUS_ONE) { //this means is an outer
_outers--; _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)) { if(_table(_sharedstate->_consts)->get(name,val)) {
e = val; e = val;
return true; return true;
@ -351,11 +351,11 @@ bool SQFuncState::isConstant(const SQObject &name,SQObject &e)
bool SQFuncState::isLocal(uint64_t stkpos) bool SQFuncState::isLocal(uint64_t stkpos)
{ {
if(stkpos>=_vlocals.size())return false; 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; return false;
} }
int64_t SQFuncState::pushLocalVariable(const SQObject &name) int64_t SQFuncState::pushLocalVariable(const rabbit::Object &name)
{ {
int64_t pos=_vlocals.size(); int64_t pos=_vlocals.size();
SQLocalVarInfo lvi; 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(); int64_t locals=_vlocals.size();
while(locals>=1){ while(locals>=1){
SQLocalVarInfo &lvi = _vlocals[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; return locals-1;
} }
locals--; locals--;
@ -389,7 +389,7 @@ void SQFuncState::markLocalAsOuter(int64_t pos)
_outers++; _outers++;
} }
int64_t SQFuncState::getOuterVariable(const SQObject &name) int64_t SQFuncState::getOuterVariable(const rabbit::Object &name)
{ {
int64_t outers = _outervalues.size(); int64_t outers = _outervalues.size();
for(int64_t i = 0; i<outers; i++) { for(int64_t i = 0; i<outers; i++) {
@ -402,13 +402,13 @@ int64_t SQFuncState::getOuterVariable(const SQObject &name)
if(pos == -1) { if(pos == -1) {
pos = _parent->getOuterVariable(name); pos = _parent->getOuterVariable(name);
if(pos != -1) { 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; return _outervalues.size() - 1;
} }
} }
else { else {
_parent->markLocalAsOuter(pos); _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; return _outervalues.size() - 1;
@ -417,7 +417,7 @@ int64_t SQFuncState::getOuterVariable(const SQObject &name)
return -1; return -1;
} }
void SQFuncState::addParameter(const SQObject &name) void SQFuncState::addParameter(const rabbit::Object &name)
{ {
pushLocalVariable(name); pushLocalVariable(name);
_parameters.pushBack(name); _parameters.pushBack(name);
@ -584,16 +584,16 @@ void SQFuncState::addInstruction(SQInstruction &i)
_instructions.pushBack(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); _table(_strings)->newSlot(ns,(int64_t)1);
return ns; 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); _table(_strings)->newSlot(nt,(int64_t)1);
return nt; return nt;
} }
@ -605,7 +605,7 @@ SQFunctionProto *SQFuncState::buildProto()
_nliterals,_parameters.size(),_functions.size(),_outervalues.size(), _nliterals,_parameters.size(),_functions.size(),_outervalues.size(),
_lineinfos.size(),_localvarinfos.size(),_defaultparams.size()); _lineinfos.size(),_localvarinfos.size(),_defaultparams.size());
SQObjectPtr refidx,key,val; rabbit::ObjectPtr refidx,key,val;
int64_t idx; int64_t idx;
f->_stacksize = _stacksize; f->_stacksize = _stacksize;

46
rabbit/sqfuncstate.hpp
View File

@ -16,7 +16,7 @@ struct SQFuncState
#ifdef _DEBUG_DUMP #ifdef _DEBUG_DUMP
void dump(SQFunctionProto *func); void dump(SQFunctionProto *func);
#endif #endif
void error(const SQChar *err); void error(const rabbit::Char *err);
SQFuncState *pushChildState(SQSharedState *ss); SQFuncState *pushChildState(SQSharedState *ss);
void popChildState(); 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);} 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 getCurrentPos(){return _instructions.size()-1;}
int64_t getNumericConstant(const int64_t cons); int64_t getNumericConstant(const int64_t cons);
int64_t getNumericConstant(const float_t cons); int64_t getNumericConstant(const float_t cons);
int64_t pushLocalVariable(const SQObject &name); int64_t pushLocalVariable(const rabbit::Object &name);
void addParameter(const SQObject &name); void addParameter(const rabbit::Object &name);
//void addOuterValue(const SQObject &name); //void addOuterValue(const rabbit::Object &name);
int64_t getLocalVariable(const SQObject &name); int64_t getLocalVariable(const rabbit::Object &name);
void markLocalAsOuter(int64_t pos); void markLocalAsOuter(int64_t pos);
int64_t getOuterVariable(const SQObject &name); int64_t getOuterVariable(const rabbit::Object &name);
int64_t generateCode(); int64_t generateCode();
int64_t getStacksize(); int64_t getStacksize();
int64_t calcStackFramesize(); int64_t calcStackFramesize();
@ -51,40 +51,40 @@ struct SQFuncState
int64_t getUpTarget(int64_t n); int64_t getUpTarget(int64_t n);
void discardTarget(); void discardTarget();
bool isLocal(uint64_t stkpos); bool isLocal(uint64_t stkpos);
SQObject createString(const SQChar *s,int64_t len = -1); rabbit::Object createString(const rabbit::Char *s,int64_t len = -1);
SQObject createTable(); rabbit::Object createTable();
bool isConstant(const SQObject &name,SQObject &e); bool isConstant(const rabbit::Object &name,rabbit::Object &e);
int64_t _returnexp; int64_t _returnexp;
SQLocalVarInfoVec _vlocals; SQLocalVarInfoVec _vlocals;
SQIntVec _targetstack; etk::Vector<int64_t> _targetstack;
int64_t _stacksize; int64_t _stacksize;
bool _varparams; bool _varparams;
bool _bgenerator; bool _bgenerator;
SQIntVec _unresolvedbreaks; etk::Vector<int64_t> _unresolvedbreaks;
SQIntVec _unresolvedcontinues; etk::Vector<int64_t> _unresolvedcontinues;
SQObjectPtrVec _functions; etk::Vector<rabbit::ObjectPtr> _functions;
SQObjectPtrVec _parameters; etk::Vector<rabbit::ObjectPtr> _parameters;
SQOuterVarVec _outervalues; SQOuterVarVec _outervalues;
SQInstructionVec _instructions; SQInstructionVec _instructions;
SQLocalVarInfoVec _localvarinfos; SQLocalVarInfoVec _localvarinfos;
SQObjectPtr _literals; rabbit::ObjectPtr _literals;
SQObjectPtr _strings; rabbit::ObjectPtr _strings;
SQObjectPtr _name; rabbit::ObjectPtr _name;
SQObjectPtr _sourcename; rabbit::ObjectPtr _sourcename;
int64_t _nliterals; int64_t _nliterals;
SQLineInfoVec _lineinfos; SQLineInfoVec _lineinfos;
SQFuncState *_parent; SQFuncState *_parent;
SQIntVec _scope_blocks; etk::Vector<int64_t> _scope_blocks;
SQIntVec _breaktargets; etk::Vector<int64_t> _breaktargets;
SQIntVec _continuetargets; etk::Vector<int64_t> _continuetargets;
SQIntVec _defaultparams; etk::Vector<int64_t> _defaultparams;
int64_t _lastline; int64_t _lastline;
int64_t _traps; //contains number of nested exception traps int64_t _traps; //contains number of nested exception traps
int64_t _outers; int64_t _outers;
bool _optimization; bool _optimization;
SQSharedState *_sharedstate; SQSharedState *_sharedstate;
etk::Vector<SQFuncState*> _childstates; etk::Vector<SQFuncState*> _childstates;
int64_t getConstant(const SQObject &cons); int64_t getConstant(const rabbit::Object &cons);
private: private:
compilererrorFunc _errfunc; compilererrorFunc _errfunc;
void *_errtarget; void *_errtarget;

60
rabbit/sqlexer.cpp
View File

@ -29,7 +29,7 @@ SQLexer::~SQLexer()
_keywords->release(); _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; _errfunc = efunc;
_errtarget = ed; _errtarget = ed;
@ -84,7 +84,7 @@ void SQLexer::init(SQSharedState *ss, SQLEXREADFUNC rg, SQUserPointer up,compile
next(); next();
} }
void SQLexer::error(const SQChar *err) void SQLexer::error(const rabbit::Char *err)
{ {
_errfunc(_errtarget,err); _errfunc(_errtarget,err);
} }
@ -101,9 +101,9 @@ void SQLexer::next()
_reached_eof = SQTrue; _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; int64_t nitr;
while((nitr = _keywords->next(false,itr, key, val)) != -1) { while((nitr = _keywords->next(false,itr, key, val)) != -1) {
itr = (int64_t)nitr; itr = (int64_t)nitr;
@ -285,9 +285,9 @@ int64_t SQLexer::Lex()
return 0; 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)) { if(_keywords->getStr(s,len, t)) {
return int64_t(_integer(t)); return int64_t(_integer(t));
} }
@ -301,12 +301,12 @@ int64_t SQLexer::addUTF16(uint64_t ch)
if (ch >= 0x10000) if (ch >= 0x10000)
{ {
uint64_t code = (ch - 0x10000); uint64_t code = (ch - 0x10000);
APPEND_CHAR((SQChar)(0xD800 | (code >> 10))); APPEND_CHAR((rabbit::Char)(0xD800 | (code >> 10)));
APPEND_CHAR((SQChar)(0xDC00 | (code & 0x3FF))); APPEND_CHAR((rabbit::Char)(0xDC00 | (code & 0x3FF)));
return 2; return 2;
} }
else { else {
APPEND_CHAR((SQChar)ch); APPEND_CHAR((rabbit::Char)ch);
return 1; return 1;
} }
} }
@ -319,28 +319,28 @@ int64_t SQLexer::addUTF8(uint64_t ch)
return 1; return 1;
} }
if (ch < 0x800) { if (ch < 0x800) {
APPEND_CHAR((SQChar)((ch >> 6) | 0xC0)); APPEND_CHAR((rabbit::Char)((ch >> 6) | 0xC0));
APPEND_CHAR((SQChar)((ch & 0x3F) | 0x80)); APPEND_CHAR((rabbit::Char)((ch & 0x3F) | 0x80));
return 2; return 2;
} }
if (ch < 0x10000) { if (ch < 0x10000) {
APPEND_CHAR((SQChar)((ch >> 12) | 0xE0)); APPEND_CHAR((rabbit::Char)((ch >> 12) | 0xE0));
APPEND_CHAR((SQChar)(((ch >> 6) & 0x3F) | 0x80)); APPEND_CHAR((rabbit::Char)(((ch >> 6) & 0x3F) | 0x80));
APPEND_CHAR((SQChar)((ch & 0x3F) | 0x80)); APPEND_CHAR((rabbit::Char)((ch & 0x3F) | 0x80));
return 3; return 3;
} }
if (ch < 0x110000) { if (ch < 0x110000) {
APPEND_CHAR((SQChar)((ch >> 18) | 0xF0)); APPEND_CHAR((rabbit::Char)((ch >> 18) | 0xF0));
APPEND_CHAR((SQChar)(((ch >> 12) & 0x3F) | 0x80)); APPEND_CHAR((rabbit::Char)(((ch >> 12) & 0x3F) | 0x80));
APPEND_CHAR((SQChar)(((ch >> 6) & 0x3F) | 0x80)); APPEND_CHAR((rabbit::Char)(((ch >> 6) & 0x3F) | 0x80));
APPEND_CHAR((SQChar)((ch & 0x3F) | 0x80)); APPEND_CHAR((rabbit::Char)((ch & 0x3F) | 0x80));
return 4; return 4;
} }
return 0; return 0;
} }
#endif #endif
int64_t SQLexer::processStringHexEscape(SQChar *dest, int64_t maxdigits) int64_t SQLexer::processStringHexEscape(rabbit::Char *dest, int64_t maxdigits)
{ {
NEXT(); NEXT();
if (!isxdigit(CUR_CHAR)) error(_SC("hexadecimal number expected")); if (!isxdigit(CUR_CHAR)) error(_SC("hexadecimal number expected"));
@ -379,24 +379,24 @@ int64_t SQLexer::readString(int64_t ndelim,bool verbatim)
NEXT(); NEXT();
switch(CUR_CHAR) { switch(CUR_CHAR) {
case _SC('x'): { case _SC('x'): {
const int64_t maxdigits = sizeof(SQChar) * 2; const int64_t maxdigits = sizeof(rabbit::Char) * 2;
SQChar temp[maxdigits + 1]; rabbit::Char temp[maxdigits + 1];
processStringHexEscape(temp, maxdigits); processStringHexEscape(temp, maxdigits);
SQChar *stemp; rabbit::Char *stemp;
APPEND_CHAR((SQChar)scstrtoul(temp, &stemp, 16)); APPEND_CHAR((rabbit::Char)scstrtoul(temp, &stemp, 16));
} }
break; break;
case _SC('U'): case _SC('U'):
case _SC('u'): { case _SC('u'): {
const int64_t maxdigits = CUR_CHAR == 'u' ? 4 : 8; const int64_t maxdigits = CUR_CHAR == 'u' ? 4 : 8;
SQChar temp[8 + 1]; rabbit::Char temp[8 + 1];
processStringHexEscape(temp, maxdigits); processStringHexEscape(temp, maxdigits);
SQChar *stemp; rabbit::Char *stemp;
#ifdef SQUNICODE #ifdef SQUNICODE
#if WCHAR_SIZE == 2 #if WCHAR_SIZE == 2
addUTF16(scstrtoul(temp, &stemp, 16)); addUTF16(scstrtoul(temp, &stemp, 16));
#else #else
APPEND_CHAR((SQChar)scstrtoul(temp, &stemp, 16)); APPEND_CHAR((rabbit::Char)scstrtoul(temp, &stemp, 16));
#endif #endif
#else #else
addUTF8(scstrtoul(temp, &stemp, 16)); addUTF8(scstrtoul(temp, &stemp, 16));
@ -446,7 +446,7 @@ int64_t SQLexer::readString(int64_t ndelim,bool verbatim)
return TK_STRING_LITERAL; return TK_STRING_LITERAL;
} }
void LexHexadecimal(const SQChar *s,uint64_t *res) void LexHexadecimal(const rabbit::Char *s,uint64_t *res)
{ {
*res = 0; *res = 0;
while(*s != 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; *res = 0;
while(*s != 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'); } 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; *res = 0;
while(*s != 0) while(*s != 0)
@ -490,7 +490,7 @@ int64_t SQLexer::readNumber()
#define TSCIENTIFIC 4 #define TSCIENTIFIC 4
#define TOCTAL 5 #define TOCTAL 5
int64_t type = TINT, firstchar = CUR_CHAR; int64_t type = TINT, firstchar = CUR_CHAR;
SQChar *sTemp; rabbit::Char *sTemp;
INIT_TEMP_STRING(); INIT_TEMP_STRING();
NEXT(); NEXT();
if(firstchar == _SC('0') && (toupper(CUR_CHAR) == _SC('X') || scisodigit(CUR_CHAR)) ) { if(firstchar == _SC('0') && (toupper(CUR_CHAR) == _SC('X') || scisodigit(CUR_CHAR)) ) {

20
rabbit/sqlexer.hpp
View File

@ -8,7 +8,7 @@
#pragma once #pragma once
#ifdef SQUNICODE #ifdef SQUNICODE
typedef SQChar LexChar; typedef rabbit::Char LexChar;
#else #else
typedef unsigned char LexChar; typedef unsigned char LexChar;
#endif #endif
@ -17,12 +17,12 @@ struct SQLexer
{ {
SQLexer(); SQLexer();
~SQLexer(); ~SQLexer();
void init(SQSharedState *ss,SQLEXREADFUNC rg,SQUserPointer up,compilererrorFunc efunc,void *ed); void init(SQSharedState *ss,SQLEXREADFUNC rg,rabbit::UserPointer up,compilererrorFunc efunc,void *ed);
void error(const SQChar *err); void error(const rabbit::Char *err);
int64_t Lex(); int64_t Lex();
const SQChar *tok2Str(int64_t tok); const rabbit::Char *tok2Str(int64_t tok);
private: 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 readString(int64_t ndelim,bool verbatim);
int64_t readNumber(); int64_t readNumber();
void lexBlockComment(); void lexBlockComment();
@ -36,23 +36,23 @@ private:
#else #else
int64_t addUTF8(uint64_t ch); int64_t addUTF8(uint64_t ch);
#endif #endif
int64_t processStringHexEscape(SQChar *dest, int64_t maxdigits); int64_t processStringHexEscape(rabbit::Char *dest, int64_t maxdigits);
int64_t _curtoken; int64_t _curtoken;
SQTable *_keywords; SQTable *_keywords;
SQBool _reached_eof; rabbit::Bool _reached_eof;
public: public:
int64_t _prevtoken; int64_t _prevtoken;
int64_t _currentline; int64_t _currentline;
int64_t _lasttokenline; int64_t _lasttokenline;
int64_t _currentcolumn; int64_t _currentcolumn;
const SQChar *_svalue; const rabbit::Char *_svalue;
int64_t _nvalue; int64_t _nvalue;
float_t _fvalue; float_t _fvalue;
SQLEXREADFUNC _readf; SQLEXREADFUNC _readf;
SQUserPointer _up; rabbit::UserPointer _up;
LexChar _currdata; LexChar _currdata;
SQSharedState *_sharedstate; SQSharedState *_sharedstate;
etk::Vector<SQChar> _longstr; etk::Vector<rabbit::Char> _longstr;
compilererrorFunc _errfunc; compilererrorFunc _errfunc;
void *_errtarget; void *_errtarget;
}; };

155
rabbit/sqobject.cpp
View File

@ -15,42 +15,7 @@
#include <rabbit/sqclass.hpp> #include <rabbit/sqclass.hpp>
#include <rabbit/sqclosure.hpp> #include <rabbit/sqclosure.hpp>
SQString *SQString::create(SQSharedState *ss,const rabbit::Char *s,int64_t len)
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 *str=ADD_STRING(ss,s,len); SQString *str=ADD_STRING(ss,s,len);
return str; return str;
@ -61,7 +26,7 @@ void SQString::release()
REMOVE_STRING(_sharedstate,this); 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); int64_t idx = (int64_t)translateIndex(refpos);
while(idx < _len){ while(idx < _len){
@ -74,40 +39,6 @@ int64_t SQString::next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectP
return -1; 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) 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; int64_t size = v->_top-v->_stackbase;
_stack.resize(size); _stack.resize(size);
SQObject _this = v->_stack[v->_stackbase]; rabbit::Object _this = v->_stack[v->_stackbase];
_stack[0] = ISREFCOUNTED(sq_type(_this)) ? SQObjectPtr(_refcounted(_this)->getWeakRef(sq_type(_this))) : _this; _stack[0] = ISREFCOUNTED(sq_type(_this)) ? rabbit::ObjectPtr(_refcounted(_this)->getWeakRef(sq_type(_this))) : _this;
for(int64_t n =1; n<target; n++) { for(int64_t n =1; n<target; n++) {
_stack[n] = v->_stack[v->_stackbase+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()); _etraps.pushBack(v->_etraps.back());
v->_etraps.popBack(); v->_etraps.popBack();
// store relative stack base and size in case of resume to other _top // 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._stackbase -= v->_stackbase;
et._stacksize -= v->_stackbase; et._stacksize -= v->_stackbase;
} }
@ -140,7 +71,7 @@ bool SQGenerator::yield(rabbit::VirtualMachine *v,int64_t target)
return true; 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==eDead){ v->raise_error(_SC("resuming dead generator")); return false; }
if(_state==eRunning){ v->raise_error(_SC("resuming active 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++) { for(int64_t i=0;i<_ci._etraps;i++) {
v->_etraps.pushBack(_etraps.back()); v->_etraps.pushBack(_etraps.back());
_etraps.popBack(); _etraps.popBack();
SQExceptionTrap &et = v->_etraps.back(); rabbit::ExceptionTrap &et = v->_etraps.back();
// restore absolute stack base and size // restore absolute stack base and size
et._stackbase += newbase; et._stackbase += newbase;
et._stacksize += newbase; et._stacksize += newbase;
} }
SQObject _this = _stack[0]; rabbit::Object _this = _stack[0];
v->_stack[v->_stackbase] = sq_type(_this) == OT_WEAKREF ? _weakref(_this)->_obj : _this; v->_stack[v->_stackbase] = sq_type(_this) == rabbit::OT_WEAKREF ? _weakref(_this)->_obj : _this;
for(int64_t n = 1; n<size; n++) { for(int64_t n = 1; n<size; n++) {
v->_stack[v->_stackbase+n] = _stack[n]; v->_stack[v->_stackbase+n] = _stack[n];
@ -190,10 +121,10 @@ void rabbit::Array::extend(const rabbit::Array *a){
append((*a)[i]); 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; uint64_t nvars=_nlocalvarinfos;
const SQChar *res=NULL; const rabbit::Char *res=NULL;
if(nvars>=nseq){ if(nvars>=nseq){
for(uint64_t i=0;i<nvars;i++){ for(uint64_t i=0;i<nvars;i++){
if(_localvarinfos[i]._start_op<=nop && _localvarinfos[i]._end_op>=nop) 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; } #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) { if(write(up,dest,size) != size) {
v->raise_error(_SC("io error (write function failure)")); 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; 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) { if(size && read(up,dest,size) != size) {
v->raise_error(_SC("io error, read function failure, the origin stream could be corrupted/trucated")); 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; 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)); 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; uint32_t t;
_CHECK_IO(SafeRead(v,read,up,&t,sizeof(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; 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); uint32_t _type = (uint32_t)sq_type(o);
_CHECK_IO(SafeWrite(v,write,up,&_type,sizeof(_type))); _CHECK_IO(SafeWrite(v,write,up,&_type,sizeof(_type)));
switch(sq_type(o)){ 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,&_string(o)->_len,sizeof(int64_t)));
_CHECK_IO(SafeWrite(v,write,up,_stringval(o),sq_rsl(_string(o)->_len))); _CHECK_IO(SafeWrite(v,write,up,_stringval(o),sq_rsl(_string(o)->_len)));
break; break;
case OT_BOOL: case rabbit::OT_BOOL:
case OT_INTEGER: case rabbit::OT_INTEGER:
_CHECK_IO(SafeWrite(v,write,up,&_integer(o),sizeof(int64_t)));break; _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; _CHECK_IO(SafeWrite(v,write,up,&_float(o),sizeof(float_t)));break;
case OT_NULL: case rabbit::OT_NULL:
break; break;
default: default:
v->raise_error(_SC("cannot serialize a %s"),getTypeName(o)); 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; 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; uint32_t _type;
_CHECK_IO(SafeRead(v,read,up,&_type,sizeof(_type))); _CHECK_IO(SafeRead(v,read,up,&_type,sizeof(_type)));
SQObjectType t = (SQObjectType)_type; rabbit::ObjectType t = (rabbit::ObjectType)_type;
switch(t){ switch(t){
case OT_STRING:{ case rabbit::OT_STRING:{
int64_t len; int64_t len;
_CHECK_IO(SafeRead(v,read,up,&len,sizeof(int64_t))); _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))); _CHECK_IO(SafeRead(v,read,up,_get_shared_state(v)->getScratchPad(sq_rsl(len)),sq_rsl(len)));
o=SQString::create(_ss(v),_ss(v)->getScratchPad(-1),len); o=SQString::create(_get_shared_state(v),_ss(v)->getScratchPad(-1),len);
} }
break; break;
case OT_INTEGER:{ case rabbit::OT_INTEGER:{
int64_t i; int64_t i;
_CHECK_IO(SafeRead(v,read,up,&i,sizeof(int64_t))); o = i; break; _CHECK_IO(SafeRead(v,read,up,&i,sizeof(int64_t))); o = i; break;
} }
case OT_BOOL:{ case rabbit::OT_BOOL:{
int64_t i; 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; float_t f;
_CHECK_IO(SafeRead(v,read,up,&f,sizeof(float_t))); o = f; break; _CHECK_IO(SafeRead(v,read,up,&f,sizeof(float_t))); o = f; break;
} }
case OT_NULL: case rabbit::OT_NULL:
o.Null(); o.Null();
break; break;
default: default:
@ -345,10 +276,10 @@ bool ReadObject(rabbit::VirtualMachine* v,SQUserPointer up,SQREADFUNC read,SQObj
return true; 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,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(int64_t)));
_CHECK_IO(WriteTag(v,write,up,sizeof(float_t))); _CHECK_IO(WriteTag(v,write,up,sizeof(float_t)));
_CHECK_IO(_function->save(v,up,write)); _CHECK_IO(_function->save(v,up,write));
@ -356,16 +287,16 @@ bool SQClosure::save(rabbit::VirtualMachine *v,SQUserPointer up,SQWRITEFUNC writ
return true; 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,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(int64_t)));
_CHECK_IO(CheckTag(v,read,up,sizeof(float_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(SQFunctionProto::load(v,up,read,func));
_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_TAIL)); _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 //FIXME: load an root for this closure
return true; 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 i,nliterals = _nliterals,nparameters = _nparameters;
int64_t noutervalues = _noutervalues,nlocalvarinfos = _nlocalvarinfos; int64_t noutervalues = _noutervalues,nlocalvarinfos = _nlocalvarinfos;
@ -443,13 +374,13 @@ bool SQFunctionProto::save(rabbit::VirtualMachine *v,SQUserPointer up,SQWRITEFUN
return true; 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 i, nliterals,nparameters;
int64_t noutervalues ,nlocalvarinfos ; int64_t noutervalues ,nlocalvarinfos ;
int64_t nlineinfos,ninstructions ,nfunctions,ndefaultparams ; int64_t nlineinfos,ninstructions ,nfunctions,ndefaultparams ;
SQObjectPtr sourcename, name; rabbit::ObjectPtr sourcename, name;
SQObjectPtr o; rabbit::ObjectPtr o;
_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART)); _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
_CHECK_IO(ReadObject(v, up, read, sourcename)); _CHECK_IO(ReadObject(v, up, read, sourcename));
_CHECK_IO(ReadObject(v, up, read, name)); _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, SQFunctionProto *f = SQFunctionProto::create(NULL,ninstructions,nliterals,nparameters,
nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams); 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->_sourcename = sourcename;
f->_name = name; f->_name = name;
@ -487,7 +418,7 @@ bool SQFunctionProto::load(rabbit::VirtualMachine *v,SQUserPointer up,SQREADFUNC
for(i = 0; i < noutervalues; i++){ for(i = 0; i < noutervalues; i++){
uint64_t type; uint64_t type;
SQObjectPtr name; rabbit::ObjectPtr name;
_CHECK_IO(SafeRead(v,read,up, &type, sizeof(uint64_t))); _CHECK_IO(SafeRead(v,read,up, &type, sizeof(uint64_t)));
_CHECK_IO(ReadObject(v, up, read, o)); _CHECK_IO(ReadObject(v, up, read, o));
_CHECK_IO(ReadObject(v, up, read, name)); _CHECK_IO(ReadObject(v, up, read, name));

263
rabbit/sqobject.hpp
View File

@ -23,48 +23,6 @@
struct SQSharedState; struct SQSharedState;
enum SQMetaMethod{
MT_ADD=0,
MT_SUB=1,
MT_MUL=2,
MT_DIV=3,
MT_UNM=4,
MT_MODULO=5,
MT_SET=6,
MT_GET=7,
MT_TYPEOF=8,
MT_NEXTI=9,
MT_CMP=10,
MT_CALL=11,
MT_CLONED=12,
MT_NEWSLOT=13,
MT_DELSLOT=14,
MT_TOSTRING=15,
MT_NEWMEMBER=16,
MT_INHERITED=17,
MT_LAST = 18
};
#define MM_ADD _SC("_add")
#define MM_SUB _SC("_sub")
#define MM_MUL _SC("_mul")
#define MM_DIV _SC("_div")
#define MM_UNM _SC("_unm")
#define MM_MODULO _SC("_modulo")
#define MM_SET _SC("_set")
#define MM_GET _SC("_get")
#define MM_TYPEOF _SC("_typeof")
#define MM_NEXTI _SC("_nexti")
#define MM_CMP _SC("_cmp")
#define MM_CALL _SC("_call")
#define MM_CLONED _SC("_cloned")
#define MM_NEWSLOT _SC("_newslot")
#define MM_DELSLOT _SC("_delslot")
#define MM_TOSTRING _SC("_tostring")
#define MM_NEWMEMBER _SC("_newmember")
#define MM_INHERITED _SC("_inherited")
#define _CONSTRUCT_VECTOR(type, size, ptr) { \ #define _CONSTRUCT_VECTOR(type, size, ptr) { \
for(int64_t n = 0; n < ((int64_t)size); n++) { \ for(int64_t n = 0; n < ((int64_t)size); n++) { \
new (&ptr[n]) type(); \ new (&ptr[n]) type(); \
@ -89,228 +47,13 @@ enum SQMetaMethod{
} \ } \
} }
#define MINPOWER2 4
inline void _Swap(rabbit::Object &a,rabbit::Object &b)
#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
{ {
SQObjectPtr() rabbit::ObjectType tOldType = a._type;
{ rabbit::ObjectValue unOldVal = a._unVal;
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;
a._type = b._type; a._type = b._type;
a._unVal = b._unVal; a._unVal = b._unVal;
b._type = tOldType; b._type = tOldType;
b._unVal = unOldVal; 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 { struct SQInstructionDesc {
const SQChar *name; const rabbit::Char *name;
}; };
struct SQInstruction struct SQInstruction

48
rabbit/sqstate.cpp
View File

@ -36,7 +36,7 @@ SQSharedState::SQSharedState()
_table(_metamethodsmap)->newSlot(_metamethods->back(),(int64_t)(_metamethods->size()-1)); \ _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 i = 0;
int64_t mask = 0; int64_t mask = 0;
@ -77,7 +77,7 @@ bool compileTypemask(SQIntVec &res,const SQChar *typemask)
return true; return true;
} }
SQTable *createDefaultDelegate(SQSharedState *ss,const SQRegFunction *funcz) SQTable *createDefaultDelegate(SQSharedState *ss,const rabbit::RegFunction *funcz)
{ {
int64_t i=0; int64_t i=0;
SQTable *t=SQTable::create(ss,0); SQTable *t=SQTable::create(ss,0);
@ -99,9 +99,9 @@ void SQSharedState::init()
_scratchpadsize=0; _scratchpadsize=0;
_stringtable = (SQStringTable*)SQ_MALLOC(sizeof(SQStringTable)); _stringtable = (SQStringTable*)SQ_MALLOC(sizeof(SQStringTable));
new (_stringtable) SQStringTable(this); new (_stringtable) SQStringTable(this);
sq_new(_metamethods,SQObjectPtrVec); sq_new(_metamethods,etk::Vector<rabbit::ObjectPtr>);
sq_new(_systemstrings,SQObjectPtrVec); sq_new(_systemstrings,etk::Vector<rabbit::ObjectPtr>);
sq_new(_types,SQObjectPtrVec); sq_new(_types,etk::Vector<rabbit::ObjectPtr>);
_metamethodsmap = SQTable::create(this,MT_LAST-1); _metamethodsmap = SQTable::create(this,MT_LAST-1);
//adding type strings to avoid memory trashing //adding type strings to avoid memory trashing
//types names //types names
@ -183,19 +183,19 @@ SQSharedState::~SQSharedState()
_weakref_default_delegate.Null(); _weakref_default_delegate.Null();
_refs_table.finalize(); _refs_table.finalize();
sq_delete(_types,SQObjectPtrVec); sq_delete(_types,etk::Vector<rabbit::ObjectPtr>);
sq_delete(_systemstrings,SQObjectPtrVec); sq_delete(_systemstrings,etk::Vector<rabbit::ObjectPtr>);
sq_delete(_metamethods,SQObjectPtrVec); sq_delete(_metamethods,etk::Vector<rabbit::ObjectPtr>);
sq_delete(_stringtable,SQStringTable); sq_delete(_stringtable,SQStringTable);
if(_scratchpad)SQ_FREE(_scratchpad,_scratchpadsize); 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; return -1;
SQObjectPtr ret; rabbit::ObjectPtr ret;
if(_table(_metamethodsmap)->get(name,ret)) { if(_table(_metamethodsmap)->get(name,ret)) {
return _integer(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; int64_t newsize;
if(size>0) { if(size>0) {
if(_scratchpadsize < size) { if(_scratchpadsize < size) {
newsize = size + (size>>1); newsize = size + (size>>1);
_scratchpad = (SQChar *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize); _scratchpad = (rabbit::Char *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
_scratchpadsize = newsize; _scratchpadsize = newsize;
}else if(_scratchpadsize >= (size<<5)) { }else if(_scratchpadsize >= (size<<5)) {
newsize = _scratchpadsize >> 1; newsize = _scratchpadsize >> 1;
_scratchpad = (SQChar *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize); _scratchpad = (rabbit::Char *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
_scratchpadsize = newsize; _scratchpadsize = newsize;
} }
} }
@ -241,7 +241,7 @@ RefTable::~RefTable()
} }
void RefTable::addRef(SQObject &obj) void RefTable::addRef(rabbit::Object &obj)
{ {
SQHash mainpos; SQHash mainpos;
RefNode *prev; RefNode *prev;
@ -249,7 +249,7 @@ void RefTable::addRef(SQObject &obj)
ref->refs++; ref->refs++;
} }
uint64_t RefTable::getRefCount(SQObject &obj) uint64_t RefTable::getRefCount(rabbit::Object &obj)
{ {
SQHash mainpos; SQHash mainpos;
RefNode *prev; 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; SQHash mainpos;
RefNode *prev; RefNode *prev;
RefNode *ref = get(obj,mainpos,&prev,false); RefNode *ref = get(obj,mainpos,&prev,false);
if(ref) { if(ref) {
if(--ref->refs == 0) { if(--ref->refs == 0) {
SQObjectPtr o = ref->obj; rabbit::ObjectPtr o = ref->obj;
if(prev) { if(prev) {
prev->next = ref->next; prev->next = ref->next;
} }
@ -295,7 +295,7 @@ void RefTable::resize(uint64_t size)
//rehash //rehash
uint64_t nfound = 0; uint64_t nfound = 0;
for(uint64_t n = 0; n < oldnumofslots; n++) { 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; //add back;
assert(t->refs != 0); assert(t->refs != 0);
RefNode *nn = add(::HashObj(t->obj)&(_numofslots-1),t->obj); 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))); 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 *t = _buckets[mainpos];
RefNode *newnode = _freelist; RefNode *newnode = _freelist;
@ -322,7 +322,7 @@ RefTable::RefNode *RefTable::add(SQHash mainpos,SQObject &obj)
return newnode; 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; RefNode *ref;
mainpos = ::HashObj(obj)&(_numofslots-1); mainpos = ::HashObj(obj)&(_numofslots-1);
@ -355,13 +355,13 @@ void RefTable::allocNodes(uint64_t size)
for(n = 0; n < size - 1; n++) { for(n = 0; n < size - 1; n++) {
bucks[n] = NULL; bucks[n] = NULL;
temp->refs = 0; temp->refs = 0;
new (&temp->obj) SQObjectPtr; new (&temp->obj) rabbit::ObjectPtr;
temp->next = temp+1; temp->next = temp+1;
temp++; temp++;
} }
bucks[n] = NULL; bucks[n] = NULL;
temp->refs = 0; temp->refs = 0;
new (&temp->obj) SQObjectPtr; new (&temp->obj) rabbit::ObjectPtr;
temp->next = NULL; temp->next = NULL;
_freelist = nodes; _freelist = nodes;
_nodes = nodes; _nodes = nodes;
@ -397,7 +397,7 @@ void SQStringTable::allocNodes(int64_t size)
memset(_strings,0,sizeof(SQString*)*_numofslots); 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) if(len<0)
len = (int64_t)scstrlen(news); len = (int64_t)scstrlen(news);

88
rabbit/sqstate.hpp
View File

@ -9,6 +9,8 @@
#include <rabbit/squtils.hpp> #include <rabbit/squtils.hpp>
#include <rabbit/sqobject.hpp> #include <rabbit/sqobject.hpp>
#include <rabbit/RegFunction.hpp>
struct SQString; struct SQString;
struct SQTable; struct SQTable;
//max number of character for a printed number //max number of character for a printed number
@ -18,7 +20,7 @@ struct SQStringTable
{ {
SQStringTable(SQSharedState*ss); SQStringTable(SQSharedState*ss);
~SQStringTable(); ~SQStringTable();
SQString *add(const SQChar *,int64_t len); SQString *add(const rabbit::Char *,int64_t len);
void remove(SQString *); void remove(SQString *);
private: private:
void resize(int64_t size); void resize(int64_t size);
@ -31,19 +33,19 @@ private:
struct RefTable { struct RefTable {
struct RefNode { struct RefNode {
SQObjectPtr obj; rabbit::ObjectPtr obj;
uint64_t refs; uint64_t refs;
struct RefNode *next; struct RefNode *next;
}; };
RefTable(); RefTable();
~RefTable(); ~RefTable();
void addRef(SQObject &obj); void addRef(rabbit::Object &obj);
SQBool release(SQObject &obj); rabbit::Bool release(rabbit::Object &obj);
uint64_t getRefCount(SQObject &obj); uint64_t getRefCount(rabbit::Object &obj);
void finalize(); void finalize();
private: private:
RefNode *get(SQObject &obj,SQHash &mainpos,RefNode **prev,bool add); RefNode *get(rabbit::Object &obj,SQHash &mainpos,RefNode **prev,bool add);
RefNode *add(SQHash mainpos,SQObject &obj); RefNode *add(SQHash mainpos,rabbit::Object &obj);
void resize(uint64_t size); void resize(uint64_t size);
void allocNodes(uint64_t size); void allocNodes(uint64_t size);
uint64_t _numofslots; uint64_t _numofslots;
@ -55,57 +57,57 @@ private:
#define ADD_STRING(ss,str,len) ss->_stringtable->add(str,len) #define ADD_STRING(ss,str,len) ss->_stringtable->add(str,len)
#define REMOVE_STRING(ss,bstr) ss->_stringtable->remove(bstr) #define REMOVE_STRING(ss,bstr) ss->_stringtable->remove(bstr)
namespace rabbit {
struct SQObjectPtr; class ObjectPtr;
}
struct SQSharedState struct SQSharedState
{ {
SQSharedState(); SQSharedState();
~SQSharedState(); ~SQSharedState();
void init(); void init();
public: public:
SQChar* getScratchPad(int64_t size); rabbit::Char* getScratchPad(int64_t size);
int64_t getMetaMethodIdxByName(const SQObjectPtr &name); int64_t getMetaMethodIdxByName(const rabbit::ObjectPtr &name);
SQObjectPtrVec *_metamethods; etk::Vector<rabbit::ObjectPtr> *_metamethods;
SQObjectPtr _metamethodsmap; rabbit::ObjectPtr _metamethodsmap;
SQObjectPtrVec *_systemstrings; etk::Vector<rabbit::ObjectPtr> *_systemstrings;
SQObjectPtrVec *_types; etk::Vector<rabbit::ObjectPtr> *_types;
SQStringTable *_stringtable; SQStringTable *_stringtable;
RefTable _refs_table; RefTable _refs_table;
SQObjectPtr _registry; rabbit::ObjectPtr _registry;
SQObjectPtr _consts; rabbit::ObjectPtr _consts;
SQObjectPtr _constructoridx; rabbit::ObjectPtr _constructoridx;
SQObjectPtr _root_vm; rabbit::ObjectPtr _root_vm;
SQObjectPtr _table_default_delegate; rabbit::ObjectPtr _table_default_delegate;
static const SQRegFunction _table_default_delegate_funcz[]; static const rabbit::RegFunction _table_default_delegate_funcz[];
SQObjectPtr _array_default_delegate; rabbit::ObjectPtr _array_default_delegate;
static const SQRegFunction _array_default_delegate_funcz[]; static const rabbit::RegFunction _array_default_delegate_funcz[];
SQObjectPtr _string_default_delegate; rabbit::ObjectPtr _string_default_delegate;
static const SQRegFunction _string_default_delegate_funcz[]; static const rabbit::RegFunction _string_default_delegate_funcz[];
SQObjectPtr _number_default_delegate; rabbit::ObjectPtr _number_default_delegate;
static const SQRegFunction _number_default_delegate_funcz[]; static const rabbit::RegFunction _number_default_delegate_funcz[];
SQObjectPtr _generator_default_delegate; rabbit::ObjectPtr _generator_default_delegate;
static const SQRegFunction _generator_default_delegate_funcz[]; static const rabbit::RegFunction _generator_default_delegate_funcz[];
SQObjectPtr _closure_default_delegate; rabbit::ObjectPtr _closure_default_delegate;
static const SQRegFunction _closure_default_delegate_funcz[]; static const rabbit::RegFunction _closure_default_delegate_funcz[];
SQObjectPtr _thread_default_delegate; rabbit::ObjectPtr _thread_default_delegate;
static const SQRegFunction _thread_default_delegate_funcz[]; static const rabbit::RegFunction _thread_default_delegate_funcz[];
SQObjectPtr _class_default_delegate; rabbit::ObjectPtr _class_default_delegate;
static const SQRegFunction _class_default_delegate_funcz[]; static const rabbit::RegFunction _class_default_delegate_funcz[];
SQObjectPtr _instance_default_delegate; rabbit::ObjectPtr _instance_default_delegate;
static const SQRegFunction _instance_default_delegate_funcz[]; static const rabbit::RegFunction _instance_default_delegate_funcz[];
SQObjectPtr _weakref_default_delegate; rabbit::ObjectPtr _weakref_default_delegate;
static const SQRegFunction _weakref_default_delegate_funcz[]; static const rabbit::RegFunction _weakref_default_delegate_funcz[];
SQCOMPILERERROR _compilererrorhandler; SQCOMPILERERROR _compilererrorhandler;
SQPRINTFUNCTION _printfunc; SQPRINTFUNCTION _printfunc;
SQPRINTFUNCTION _errorfunc; SQPRINTFUNCTION _errorfunc;
bool _debuginfo; bool _debuginfo;
bool _notifyallexceptions; bool _notifyallexceptions;
SQUserPointer _foreignptr; rabbit::UserPointer _foreignptr;
SQRELEASEHOOK _releasehook; SQRELEASEHOOK _releasehook;
private: private:
SQChar *_scratchpad; rabbit::Char *_scratchpad;
int64_t _scratchpadsize; int64_t _scratchpadsize;
}; };
@ -123,6 +125,6 @@ private:
#define _instance_ddel _table(_sharedstate->_instance_default_delegate) #define _instance_ddel _table(_sharedstate->_instance_default_delegate)
#define _weakref_ddel _table(_sharedstate->_weakref_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 #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 */ SQHash h = (SQHash)l; /* seed */
size_t step = (l>>5)|1; /* if string is too long, don't hash all its chars */ 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(){}
~SQString(){} ~SQString(){}
public: public:
static SQString *create(SQSharedState *ss, const SQChar *, int64_t len = -1 ); static SQString *create(SQSharedState *ss, const rabbit::Char *, int64_t len = -1 );
int64_t next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); int64_t next(const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval);
void release(); void release();
SQSharedState *_sharedstate; SQSharedState *_sharedstate;
SQString *_next; //chain for the string table SQString *_next; //chain for the string table
int64_t _len; int64_t _len;
SQHash _hash; 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; _delegate = NULL;
} }
void SQTable::remove(const SQObjectPtr &key) void SQTable::remove(const rabbit::ObjectPtr &key)
{ {
_HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1)); _HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1));
@ -65,7 +65,7 @@ void SQTable::Rehash(bool force)
_usednodes = 0; _usednodes = 0;
for (int64_t i=0; i<oldsize; i++) { for (int64_t i=0; i<oldsize; i++) {
_HashNode *old = nold+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); newSlot(old->key,old->val);
} }
for(int64_t k=0;k<oldsize;k++) for(int64_t k=0;k<oldsize;k++)
@ -99,7 +99,7 @@ SQTable *SQTable::clone()
nt->_usednodes = _usednodes; nt->_usednodes = _usednodes;
#else #else
int64_t ridx=0; int64_t ridx=0;
SQObjectPtr key,val; rabbit::ObjectPtr key,val;
while((ridx=next(true,ridx,key,val))!=-1){ while((ridx=next(true,ridx,key,val))!=-1){
nt->newSlot(key,val); nt->newSlot(key,val);
} }
@ -108,9 +108,9 @@ SQTable *SQTable::clone()
return nt; 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; return false;
_HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1)); _HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1));
if (n) { if (n) {
@ -119,9 +119,9 @@ bool SQTable::get(const SQObjectPtr &key,SQObjectPtr &val)
} }
return false; 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); SQHash h = HashObj(key) & (_numofnodes - 1);
_HashNode *n = _get(key, h); _HashNode *n = _get(key, h);
if (n) { if (n) {
@ -135,7 +135,7 @@ bool SQTable::newSlot(const SQObjectPtr &key,const SQObjectPtr &val)
//key not found I'll insert it //key not found I'll insert it
//main pos is not free //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 */ n = _firstfree; /* get a free place */
SQHash mph = HashObj(mp->key) & (_numofnodes - 1); SQHash mph = HashObj(mp->key) & (_numofnodes - 1);
_HashNode *othern; /* main position of colliding node */ _HashNode *othern; /* main position of colliding node */
@ -164,7 +164,7 @@ bool SQTable::newSlot(const SQObjectPtr &key,const SQObjectPtr &val)
mp->key = key; mp->key = key;
for (;;) { /* correct `firstfree' */ 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; mp->val = val;
_usednodes++; _usednodes++;
return true; /* OK; table still has a free place */ 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); 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); int64_t idx = (int64_t)translateIndex(refpos);
while (idx < _numofnodes) { while (idx < _numofnodes) {
if(sq_type(_nodes[idx].key) != OT_NULL) { if(sq_type(_nodes[idx].key) != rabbit::OT_NULL) {
//first found //first found
_HashNode &n = _nodes[idx]; _HashNode &n = _nodes[idx];
outkey = n.key; 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 for the next iteration
return ++idx; 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)); _HashNode *n = _get(key, HashObj(key) & (_numofnodes - 1));
if (n) { if (n) {

46
rabbit/sqtable.hpp
View File

@ -14,28 +14,38 @@
*/ */
#include <rabbit/sqstring.hpp> #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)) #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)) { switch(sq_type(key)) {
case OT_STRING: return _string(key)->_hash; case rabbit::OT_STRING:
case OT_FLOAT: return (SQHash)((int64_t)_float(key)); return _string(key)->_hash;
case OT_BOOL: case OT_INTEGER: return (SQHash)((int64_t)_integer(key)); case rabbit::OT_FLOAT:
default: return hashptr(key._unVal.pRefCounted); 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: private:
struct _HashNode struct _HashNode
{ {
_HashNode() { next = NULL; } _HashNode() { next = NULL; }
SQObjectPtr val; rabbit::ObjectPtr val;
SQObjectPtr key; rabbit::ObjectPtr key;
_HashNode *next; _HashNode *next;
}; };
_HashNode *_firstfree; _HashNode *_firstfree;
@ -51,8 +61,8 @@ private:
public: public:
static SQTable* create(SQSharedState *ss,int64_t ninitialsize) static SQTable* create(SQSharedState *ss,int64_t ninitialsize)
{ {
SQTable *newtable = (SQTable*)SQ_MALLOC(sizeof(SQTable)); char* tmp = (char*)SQ_MALLOC(sizeof(SQTable));
new (newtable) SQTable(ss, ninitialsize); SQTable *newtable = new (tmp) SQTable(ss, ninitialsize);
newtable->_delegate = NULL; newtable->_delegate = NULL;
return newtable; return newtable;
} }
@ -64,7 +74,7 @@ public:
for (int64_t i = 0; i < _numofnodes; i++) _nodes[i].~_HashNode(); for (int64_t i = 0; i < _numofnodes; i++) _nodes[i].~_HashNode();
SQ_FREE(_nodes, _numofnodes * sizeof(_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]; _HashNode *n = &_nodes[hash];
do{ do{
@ -75,13 +85,13 @@ public:
return NULL; return NULL;
} }
//for compiler use //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); SQHash hash = _hashstr(key,keylen);
_HashNode *n = &_nodes[hash & (_numofnodes - 1)]; _HashNode *n = &_nodes[hash & (_numofnodes - 1)];
_HashNode *res = NULL; _HashNode *res = NULL;
do{ 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; res = n;
break; break;
} }
@ -92,12 +102,12 @@ public:
} }
return false; return false;
} }
bool get(const SQObjectPtr &key,SQObjectPtr &val); bool get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val);
void remove(const SQObjectPtr &key); void remove(const rabbit::ObjectPtr &key);
bool set(const SQObjectPtr &key, const SQObjectPtr &val); 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 //returns true if a new slot has been created false if it was already present
bool newSlot(const SQObjectPtr &key,const SQObjectPtr &val); bool newSlot(const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val);
int64_t next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); int64_t next(bool getweakrefs,const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval);
int64_t countUsed(){ return _usednodes;} int64_t countUsed(){ return _usednodes;}
void clear(); void clear();