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

[DEV] remove the unicode (step2)

Browse Source
This commit is contained in:
Edouard DUPIN 2018-07-02 22:49:55 +02:00
parent c6875d59bf
commit ab2fc34e1c
26 changed files with 961 additions and 939 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
cmdLine/rabbit.cpp
View File

@ -65,19 +65,19 @@ void errorfunc(rabbit::VirtualMachine* SQ_UNUSED_ARG(v),const char *s,...)
void PrintVersionInfos() void PrintVersionInfos()
{ {
fprintf(stdout,_SC("%s %s (%d bits)\n"),RABBIT_VERSION,RABBIT_COPYRIGHT,((int)(sizeof(int64_t)*8))); fprintf(stdout,"%s %s (%d bits)\n",RABBIT_VERSION,RABBIT_COPYRIGHT,((int)(sizeof(int64_t)*8)));
} }
void PrintUsage() void PrintUsage()
{ {
fprintf(stderr,_SC("usage: sq <options> <scriptpath [args]>.\n") fprintf(stderr,"usage: sq <options> <scriptpath [args]>.\n"
_SC("Available options are:\n") "Available options are:\n"
_SC(" -c compiles the file to bytecode(default output 'out.karrot')\n") " -c compiles the file to bytecode(default output 'out.karrot')\n"
_SC(" -o specifies output file for the -c option\n") " -o specifies output file for the -c option\n"
_SC(" -c compiles only\n") " -c compiles only\n"
_SC(" -d generates debug infos\n") " -d generates debug infos\n"
_SC(" -v displays version infos\n") " -v displays version infos\n"
_SC(" -h prints help\n")); " -h prints help\n");
} }
#define _INTERACTIVE 0 #define _INTERACTIVE 0
@ -123,7 +123,7 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
return _DONE; return _DONE;
default: default:
PrintVersionInfos(); PrintVersionInfos();
printf(_SC("unknown prameter '-%c'\n"),argv[arg][1]); printf("unknown prameter '-%c'\n",argv[arg][1]);
PrintUsage(); PrintUsage();
*retval = -1; *retval = -1;
return _ERROR; return _ERROR;
@ -140,14 +140,14 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
arg++; arg++;
//sq_pushstring(v,_SC("ARGS"),-1); //sq_pushstring(v,"ARGS",-1);
//sq_newarray(v,0); //sq_newarray(v,0);
//sq_createslot(v,-3); //sq_createslot(v,-3);
//sq_pop(v,1); //sq_pop(v,1);
if(compiles_only) { if(compiles_only) {
if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,SQTrue))){ if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,SQTrue))){
const char *outfile = _SC("out.karrot"); const char *outfile = "out.karrot";
if(output) { if(output) {
outfile = output; outfile = output;
} }
@ -189,7 +189,7 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
const char *err; const char *err;
sq_getlasterror(v); sq_getlasterror(v);
if(SQ_SUCCEEDED(sq_getstring(v,-1,&err))) { if(SQ_SUCCEEDED(sq_getstring(v,-1,&err))) {
printf(_SC("error [%s]\n"),err); printf("error [%s]\n",err);
*retval = -2; *retval = -2;
return _ERROR; return _ERROR;
} }
@ -213,7 +213,7 @@ void Interactive(rabbit::VirtualMachine* v)
PrintVersionInfos(); PrintVersionInfos();
sq_pushroottable(v); sq_pushroottable(v);
sq_pushstring(v,_SC("quit"),-1); sq_pushstring(v,"quit",-1);
sq_pushuserpointer(v,&done); sq_pushuserpointer(v,&done);
sq_newclosure(v,quit,1); sq_newclosure(v,quit,1);
sq_setparamscheck(v,1,NULL); sq_setparamscheck(v,1,NULL);
@ -223,58 +223,58 @@ void Interactive(rabbit::VirtualMachine* v)
while (!done) while (!done)
{ {
int64_t i = 0; int64_t i = 0;
printf(_SC("\nrabbit> ")); printf("\nrabbit> ");
for(;;) { for(;;) {
int c; int c;
if(done)return; if(done)return;
c = getchar(); c = getchar();
if (c == _SC('\n')) { if (c == '\n') {
if (i>0 && buffer[i-1] == _SC('\\')) if (i>0 && buffer[i-1] == '\\')
{ {
buffer[i-1] = _SC('\n'); buffer[i-1] = '\n';
} }
else if(blocks==0)break; else if(blocks==0)break;
buffer[i++] = _SC('\n'); buffer[i++] = '\n';
} }
else if (c==_SC('}')) {blocks--; buffer[i++] = (char)c;} else if (c=='}') {blocks--; buffer[i++] = (char)c;}
else if(c==_SC('{') && !string){ else if(c=='{' && !string){
blocks++; blocks++;
buffer[i++] = (char)c; buffer[i++] = (char)c;
} }
else if(c==_SC('"') || c==_SC('\'')){ else if(c=='"' || c=='\''){
string=!string; string=!string;
buffer[i++] = (char)c; buffer[i++] = (char)c;
} }
else if (i >= MAXINPUT-1) { else if (i >= MAXINPUT-1) {
fprintf(stderr, _SC("sq : input line too long\n")); fprintf(stderr, "rabbit: input line too long\n");
break; break;
} }
else{ else{
buffer[i++] = (char)c; buffer[i++] = (char)c;
} }
} }
buffer[i] = _SC('\0'); buffer[i] = '\0';
if(buffer[0]==_SC('=')){ if(buffer[0]=='='){
snprintf(sq_getscratchpad(v,MAXINPUT),(size_t)MAXINPUT,_SC("return (%s)"),&buffer[1]); snprintf(sq_getscratchpad(v,MAXINPUT),(size_t)MAXINPUT,"return (%s)",&buffer[1]);
memcpy(buffer,sq_getscratchpad(v,-1),(strlen(sq_getscratchpad(v,-1))+1)*sizeof(char)); memcpy(buffer,sq_getscratchpad(v,-1),(strlen(sq_getscratchpad(v,-1))+1)*sizeof(char));
retval=1; retval=1;
} }
i=strlen(buffer); i=strlen(buffer);
if(i>0){ if(i>0){
int64_t oldtop=sq_gettop(v); int64_t oldtop=sq_gettop(v);
if(SQ_SUCCEEDED(sq_compilebuffer(v,buffer,i,_SC("interactive console"),SQTrue))){ if(SQ_SUCCEEDED(sq_compilebuffer(v,buffer,i,"interactive console",SQTrue))){
sq_pushroottable(v); sq_pushroottable(v);
if(SQ_SUCCEEDED(sq_call(v,1,retval,SQTrue)) && retval){ if(SQ_SUCCEEDED(sq_call(v,1,retval,SQTrue)) && retval){
printf(_SC("\n")); printf("\n");
sq_pushroottable(v); sq_pushroottable(v);
sq_pushstring(v,_SC("print"),-1); sq_pushstring(v,"print",-1);
sq_get(v,-2); sq_get(v,-2);
sq_pushroottable(v); sq_pushroottable(v);
sq_push(v,-4); sq_push(v,-4);
sq_call(v,2,SQFalse,SQTrue); sq_call(v,2,SQFalse,SQTrue);
retval=0; retval=0;
printf(_SC("\n")); printf("\n");
} }
} }

6
etc/minimal.cpp
View File

@ -25,7 +25,7 @@ void call_foo(HSQUIRRELVM v, int n,float f,const 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
sq_pushstring(v,_SC("foo"),-1); sq_pushstring(v,"foo",-1);
if(SQ_SUCCEEDED(sq_get(v,-2))) { //gets the field 'foo' from the global table if(SQ_SUCCEEDED(sq_get(v,-2))) { //gets the field 'foo' from the global table
sq_pushroottable(v); //push the 'this' (in this case is the global table) sq_pushroottable(v); //push the 'this' (in this case is the global table)
sq_pushinteger(v,n); sq_pushinteger(v,n);
@ -53,9 +53,9 @@ int main(int argc, char* argv[])
sq_setprintfunc(v, printfunc,errorfunc); //sets the print function sq_setprintfunc(v, printfunc,errorfunc); //sets the print function
sq_pushroottable(v); //push the root table(were the globals of the script will be stored) sq_pushroottable(v); //push the root table(were the globals of the script will be stored)
if(SQ_SUCCEEDED(rabbit::std::dofile(v, _SC("test.nut"), SQFalse, SQTrue))) // also prints syntax errors if any if(SQ_SUCCEEDED(rabbit::std::dofile(v, "test.nut", SQFalse, SQTrue))) // also prints syntax errors if any
{ {
call_foo(v,1,2.5,_SC("teststring")); call_foo(v,1,2.5,"teststring");
} }
sq_pop(v,1); //pops the root table sq_pop(v,1); //pops the root table

48
rabbit-std/sqstdaux.cpp
View File

@ -22,18 +22,18 @@ void rabbit::std::printcallstack(rabbit::VirtualMachine* v)
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 char *name=0; const char *name=0;
int64_t seq=0; int64_t seq=0;
pf(v,_SC("\nCALLSTACK\n")); pf(v,"\nCALLSTACK\n");
while(SQ_SUCCEEDED(sq_stackinfos(v,level,&si))) while(SQ_SUCCEEDED(sq_stackinfos(v,level,&si)))
{ {
const char *fn=_SC("unknown"); const char *fn="unknown";
const char *src=_SC("unknown"); const char *src="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,"*FUNCTION [%s()] %s line [%d]\n",fn,src,si.line);
level++; level++;
} }
level=0; level=0;
pf(v,_SC("\nLOCALS\n")); pf(v,"\nLOCALS\n");
for(level=0;level<10;level++){ for(level=0;level<10;level++){
seq=0; seq=0;
@ -43,58 +43,58 @@ void rabbit::std::printcallstack(rabbit::VirtualMachine* v)
switch(sq_gettype(v,-1)) switch(sq_gettype(v,-1))
{ {
case rabbit::OT_NULL: case rabbit::OT_NULL:
pf(v,_SC("[%s] NULL\n"),name); pf(v,"[%s] NULL\n",name);
break; break;
case rabbit::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,"[%s] %d\n",name,i);
break; break;
case rabbit::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,"[%s] %.14g\n",name,f);
break; break;
case rabbit::OT_USERPOINTER: case rabbit::OT_USERPOINTER:
pf(v,_SC("[%s] USERPOINTER\n"),name); pf(v,"[%s] USERPOINTER\n",name);
break; break;
case rabbit::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,"[%s] \"%s\"\n",name,s);
break; break;
case rabbit::OT_TABLE: case rabbit::OT_TABLE:
pf(v,_SC("[%s] TABLE\n"),name); pf(v,"[%s] TABLE\n",name);
break; break;
case rabbit::OT_ARRAY: case rabbit::OT_ARRAY:
pf(v,_SC("[%s] ARRAY\n"),name); pf(v,"[%s] ARRAY\n",name);
break; break;
case rabbit::OT_CLOSURE: case rabbit::OT_CLOSURE:
pf(v,_SC("[%s] CLOSURE\n"),name); pf(v,"[%s] CLOSURE\n",name);
break; break;
case rabbit::OT_NATIVECLOSURE: case rabbit::OT_NATIVECLOSURE:
pf(v,_SC("[%s] NATIVECLOSURE\n"),name); pf(v,"[%s] NATIVECLOSURE\n",name);
break; break;
case rabbit::OT_GENERATOR: case rabbit::OT_GENERATOR:
pf(v,_SC("[%s] GENERATOR\n"),name); pf(v,"[%s] GENERATOR\n",name);
break; break;
case rabbit::OT_USERDATA: case rabbit::OT_USERDATA:
pf(v,_SC("[%s] USERDATA\n"),name); pf(v,"[%s] USERDATA\n",name);
break; break;
case rabbit::OT_THREAD: case rabbit::OT_THREAD:
pf(v,_SC("[%s] THREAD\n"),name); pf(v,"[%s] THREAD\n",name);
break; break;
case rabbit::OT_CLASS: case rabbit::OT_CLASS:
pf(v,_SC("[%s] CLASS\n"),name); pf(v,"[%s] CLASS\n",name);
break; break;
case rabbit::OT_INSTANCE: case rabbit::OT_INSTANCE:
pf(v,_SC("[%s] INSTANCE\n"),name); pf(v,"[%s] INSTANCE\n",name);
break; break;
case rabbit::OT_WEAKREF: case rabbit::OT_WEAKREF:
pf(v,_SC("[%s] WEAKREF\n"),name); pf(v,"[%s] WEAKREF\n",name);
break; break;
case rabbit::OT_BOOL: case rabbit::OT_BOOL:
{ {
rabbit::Bool 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,"[%s] %s\n",name,bval == SQTrue ? "true":"false");
} }
break; break;
default: assert(0); break; default: assert(0); break;
@ -113,10 +113,10 @@ namespace rabbit {
const char *sErr = 0; const 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,"\nAN ERROR HAS OCCURRED [%s]\n",sErr);
} }
else{ else{
pf(v,_SC("\nAN ERROR HAS OCCURRED [unknown]\n")); pf(v,"\nAN ERROR HAS OCCURRED [unknown]\n");
} }
rabbit::std::printcallstack(v); rabbit::std::printcallstack(v);
} }
@ -127,7 +127,7 @@ namespace rabbit {
void compiler_error(rabbit::VirtualMachine* v,const char *sErr,const char *sSource,int64_t line,int64_t column) { void compiler_error(rabbit::VirtualMachine* v,const char *sErr,const char *sSource,int64_t line,int64_t column) {
SQPRINTFUNCTION pf = sq_geterrorfunc(v); SQPRINTFUNCTION pf = sq_geterrorfunc(v);
if(pf) { if(pf) {
pf(v,_SC("%s line = (%d) column = (%d) : error %s\n"),sSource,line,column,sErr); pf(v,"%s line = (%d) column = (%d) : error %s\n",sSource,line,column,sErr);
} }
} }
} }

56
rabbit-std/sqstdblob.cpp
View File

@ -15,9 +15,9 @@
#define SETUP_BLOB(v) \ #define SETUP_BLOB(v) \
rabbit::std::Blob *self = NULL; \ rabbit::std::Blob *self = NULL; \
{ if(SQ_FAILED(rabbit::sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) \ { if(SQ_FAILED(rabbit::sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) \
return rabbit::sq_throwerror(v,_SC("invalid type tag")); } \ return rabbit::sq_throwerror(v,"invalid type tag"); } \
if(!self || !self->IsValid()) \ if(!self || !self->IsValid()) \
return rabbit::sq_throwerror(v,_SC("the blob is invalid")); return rabbit::sq_throwerror(v,"the blob is invalid");
static int64_t _blob_resize(rabbit::VirtualMachine* v) static int64_t _blob_resize(rabbit::VirtualMachine* v)
@ -26,7 +26,7 @@ static int64_t _blob_resize(rabbit::VirtualMachine* v)
int64_t size; int64_t size;
rabbit::sq_getinteger(v,2,&size); rabbit::sq_getinteger(v,2,&size);
if(!self->resize(size)) if(!self->resize(size))
return rabbit::sq_throwerror(v,_SC("resize failed")); return rabbit::sq_throwerror(v,"resize failed");
return 0; return 0;
} }
@ -72,7 +72,7 @@ static int64_t _blob__set(rabbit::VirtualMachine* v)
rabbit::sq_getinteger(v,2,&idx); rabbit::sq_getinteger(v,2,&idx);
rabbit::sq_getinteger(v,3,&val); rabbit::sq_getinteger(v,3,&val);
if(idx < 0 || idx >= self->Len()) if(idx < 0 || idx >= self->Len())
return rabbit::sq_throwerror(v,_SC("index out of range")); return rabbit::sq_throwerror(v,"index out of range");
((unsigned char *)self->getBuf())[idx] = (unsigned char) val; ((unsigned char *)self->getBuf())[idx] = (unsigned char) val;
rabbit::sq_push(v,3); rabbit::sq_push(v,3);
return 1; return 1;
@ -90,7 +90,7 @@ static int64_t _blob__get(rabbit::VirtualMachine* v)
} }
rabbit::sq_getinteger(v,2,&idx); rabbit::sq_getinteger(v,2,&idx);
if(idx < 0 || idx >= self->Len()) if(idx < 0 || idx >= self->Len())
return rabbit::sq_throwerror(v,_SC("index out of range")); return rabbit::sq_throwerror(v,"index out of range");
rabbit::sq_pushinteger(v,((unsigned char *)self->getBuf())[idx]); rabbit::sq_pushinteger(v,((unsigned char *)self->getBuf())[idx]);
return 1; return 1;
} }
@ -111,12 +111,12 @@ static int64_t _blob__nexti(rabbit::VirtualMachine* v)
rabbit::sq_pushnull(v); rabbit::sq_pushnull(v);
return 1; return 1;
} }
return rabbit::sq_throwerror(v,_SC("internal error (_nexti) wrong argument type")); return rabbit::sq_throwerror(v,"internal error (_nexti) wrong argument type");
} }
static int64_t _blob__typeof(rabbit::VirtualMachine* v) static int64_t _blob__typeof(rabbit::VirtualMachine* v)
{ {
rabbit::sq_pushstring(v,_SC("blob"),-1); rabbit::sq_pushstring(v,"blob",-1);
return 1; return 1;
} }
@ -135,14 +135,14 @@ static int64_t _blob_constructor(rabbit::VirtualMachine* v)
if(nparam == 2) { if(nparam == 2) {
rabbit::sq_getinteger(v, 2, &size); rabbit::sq_getinteger(v, 2, &size);
} }
if(size < 0) return rabbit::sq_throwerror(v, _SC("cannot create blob with negative size")); if(size < 0) return rabbit::sq_throwerror(v, "cannot create blob with negative size");
//rabbit::std::Blob *b = new rabbit::std::Blob(size); //rabbit::std::Blob *b = new rabbit::std::Blob(size);
rabbit::std::Blob *b = new (rabbit::sq_malloc(sizeof(rabbit::std::Blob)))rabbit::std::Blob(size); rabbit::std::Blob *b = new (rabbit::sq_malloc(sizeof(rabbit::std::Blob)))rabbit::std::Blob(size);
if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,b))) { if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,b))) {
b->~Blob(); b->~Blob();
rabbit::sq_free(b,sizeof(rabbit::std::Blob)); rabbit::sq_free(b,sizeof(rabbit::std::Blob));
return rabbit::sq_throwerror(v, _SC("cannot create blob")); return rabbit::sq_throwerror(v, "cannot create blob");
} }
rabbit::sq_setreleasehook(v,1,_blob_releasehook); rabbit::sq_setreleasehook(v,1,_blob_releasehook);
return 0; return 0;
@ -161,23 +161,23 @@ static int64_t _blob__cloned(rabbit::VirtualMachine* v)
if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,thisone))) { if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,thisone))) {
thisone->~Blob(); thisone->~Blob();
rabbit::sq_free(thisone,sizeof(rabbit::std::Blob)); rabbit::sq_free(thisone,sizeof(rabbit::std::Blob));
return rabbit::sq_throwerror(v, _SC("cannot clone blob")); return rabbit::sq_throwerror(v, "cannot clone blob");
} }
rabbit::sq_setreleasehook(v,1,_blob_releasehook); rabbit::sq_setreleasehook(v,1,_blob_releasehook);
return 0; return 0;
} }
#define _DECL_BLOB_FUNC(name,nparams,typecheck) {_SC(#name),_blob_##name,nparams,typecheck} #define _DECL_BLOB_FUNC(name,nparams,typecheck) {#name,_blob_##name,nparams,typecheck}
static const rabbit::RegFunction _blob_methods[] = { static const rabbit::RegFunction _blob_methods[] = {
_DECL_BLOB_FUNC(constructor,-1,_SC("xn")), _DECL_BLOB_FUNC(constructor,-1,"xn"),
_DECL_BLOB_FUNC(resize,2,_SC("xn")), _DECL_BLOB_FUNC(resize,2,"xn"),
_DECL_BLOB_FUNC(swap2,1,_SC("x")), _DECL_BLOB_FUNC(swap2,1,"x"),
_DECL_BLOB_FUNC(swap4,1,_SC("x")), _DECL_BLOB_FUNC(swap4,1,"x"),
_DECL_BLOB_FUNC(_set,3,_SC("xnn")), _DECL_BLOB_FUNC(_set,3,"xnn"),
_DECL_BLOB_FUNC(_get,2,_SC("x.")), _DECL_BLOB_FUNC(_get,2,"x."),
_DECL_BLOB_FUNC(_typeof,1,_SC("x")), _DECL_BLOB_FUNC(_typeof,1,"x"),
_DECL_BLOB_FUNC(_nexti,2,_SC("x")), _DECL_BLOB_FUNC(_nexti,2,"x"),
_DECL_BLOB_FUNC(_cloned,2,_SC("xx")), _DECL_BLOB_FUNC(_cloned,2,"xx"),
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
@ -229,13 +229,13 @@ static int64_t _g_blob_swapfloat(rabbit::VirtualMachine* v)
return 1; return 1;
} }
#define _DECL_GLOBALBLOB_FUNC(name,nparams,typecheck) {_SC(#name),_g_blob_##name,nparams,typecheck} #define _DECL_GLOBALBLOB_FUNC(name,nparams,typecheck) {#name,_g_blob_##name,nparams,typecheck}
static const rabbit::RegFunction bloblib_funcs[]={ static const rabbit::RegFunction bloblib_funcs[]={
_DECL_GLOBALBLOB_FUNC(casti2f,2,_SC(".n")), _DECL_GLOBALBLOB_FUNC(casti2f,2,".n"),
_DECL_GLOBALBLOB_FUNC(castf2i,2,_SC(".n")), _DECL_GLOBALBLOB_FUNC(castf2i,2,".n"),
_DECL_GLOBALBLOB_FUNC(swap2,2,_SC(".n")), _DECL_GLOBALBLOB_FUNC(swap2,2,".n"),
_DECL_GLOBALBLOB_FUNC(swap4,2,_SC(".n")), _DECL_GLOBALBLOB_FUNC(swap4,2,".n"),
_DECL_GLOBALBLOB_FUNC(swapfloat,2,_SC(".n")), _DECL_GLOBALBLOB_FUNC(swapfloat,2,".n"),
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
@ -260,7 +260,7 @@ rabbit::UserPointer rabbit::std::createblob(rabbit::VirtualMachine* v, int64_t s
{ {
int64_t top = rabbit::sq_gettop(v); int64_t top = rabbit::sq_gettop(v);
rabbit::sq_pushregistrytable(v); rabbit::sq_pushregistrytable(v);
rabbit::sq_pushstring(v,_SC("std_blob"),-1); rabbit::sq_pushstring(v,"std_blob",-1);
if(SQ_SUCCEEDED(rabbit::sq_get(v,-2))) { if(SQ_SUCCEEDED(rabbit::sq_get(v,-2))) {
rabbit::sq_remove(v,-2); //removes the registry rabbit::sq_remove(v,-2); //removes the registry
rabbit::sq_push(v,1); // push the this rabbit::sq_push(v,1); // push the this
@ -278,6 +278,6 @@ rabbit::UserPointer rabbit::std::createblob(rabbit::VirtualMachine* v, int64_t s
rabbit::Result rabbit::std::register_bloblib(rabbit::VirtualMachine* v) rabbit::Result rabbit::std::register_bloblib(rabbit::VirtualMachine* v)
{ {
return declare_stream(v,_SC("blob"),(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG,_SC("std_blob"),_blob_methods,bloblib_funcs); return declare_stream(v,"blob",(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG,"std_blob",_blob_methods,bloblib_funcs);
} }

50
rabbit-std/sqstdio.cpp
View File

@ -117,7 +117,7 @@ namespace rabbit {
} }
static int64_t _file__typeof(rabbit::VirtualMachine* v) static int64_t _file__typeof(rabbit::VirtualMachine* v)
{ {
sq_pushstring(v,_SC("file"),-1); sq_pushstring(v,"file",-1);
return 1; return 1;
} }
@ -139,19 +139,19 @@ static int64_t _file_constructor(rabbit::VirtualMachine* v)
rabbit::sq_getstring(v, 2, &filename); rabbit::sq_getstring(v, 2, &filename);
rabbit::sq_getstring(v, 3, &mode); rabbit::sq_getstring(v, 3, &mode);
newf = rabbit::std::fopen(filename, mode); newf = rabbit::std::fopen(filename, mode);
if(!newf) return rabbit::sq_throwerror(v, _SC("cannot open file")); if(!newf) return rabbit::sq_throwerror(v, "cannot open file");
} else if(rabbit::sq_gettype(v,2) == rabbit::OT_USERPOINTER) { } else if(rabbit::sq_gettype(v,2) == rabbit::OT_USERPOINTER) {
owns = !(rabbit::sq_gettype(v,3) == rabbit::OT_NULL); owns = !(rabbit::sq_gettype(v,3) == rabbit::OT_NULL);
rabbit::sq_getuserpointer(v,2,&newf); rabbit::sq_getuserpointer(v,2,&newf);
} else { } else {
return rabbit::sq_throwerror(v,_SC("wrong parameter")); return rabbit::sq_throwerror(v,"wrong parameter");
} }
f = new (rabbit::sq_malloc(sizeof(rabbit::std::File)))rabbit::std::File(newf,owns); f = new (rabbit::sq_malloc(sizeof(rabbit::std::File)))rabbit::std::File(newf,owns);
if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,f))) { if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,f))) {
f->~File(); f->~File();
rabbit::sq_free(f,sizeof(rabbit::std::File)); rabbit::sq_free(f,sizeof(rabbit::std::File));
return rabbit::sq_throwerror(v, _SC("cannot create blob with negative size")); return rabbit::sq_throwerror(v, "cannot create blob with negative size");
} }
rabbit::sq_setreleasehook(v,1,_file_releasehook); rabbit::sq_setreleasehook(v,1,_file_releasehook);
return 0; return 0;
@ -169,11 +169,11 @@ 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) {#name,_file_##name,nparams,typecheck}
static const rabbit::RegFunction _file_methods[] = { static const rabbit::RegFunction _file_methods[] = {
_DECL_FILE_FUNC(constructor,3,_SC("x")), _DECL_FILE_FUNC(constructor,3,"x"),
_DECL_FILE_FUNC(_typeof,1,_SC("x")), _DECL_FILE_FUNC(_typeof,1,"x"),
_DECL_FILE_FUNC(close,1,_SC("x")), _DECL_FILE_FUNC(close,1,"x"),
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
@ -183,7 +183,7 @@ rabbit::Result rabbit::std::createfile(rabbit::VirtualMachine* v, SQFILE file,ra
{ {
int64_t top = sq_gettop(v); int64_t top = sq_gettop(v);
sq_pushregistrytable(v); sq_pushregistrytable(v);
sq_pushstring(v,_SC("std_file"),-1); sq_pushstring(v,"std_file",-1);
if(SQ_SUCCEEDED(sq_get(v,-2))) { if(SQ_SUCCEEDED(sq_get(v,-2))) {
sq_remove(v,-2); //removes the registry sq_remove(v,-2); //removes the registry
sq_pushroottable(v); // push the this sq_pushroottable(v); // push the this
@ -210,7 +210,7 @@ rabbit::Result rabbit::std::getfile(rabbit::VirtualMachine* v, int64_t idx, SQFI
*file = fileobj->getHandle(); *file = fileobj->getHandle();
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v,_SC("not a file")); return sq_throwerror(v,"not a file");
} }
@ -305,7 +305,7 @@ int64_t file_write(rabbit::UserPointer file,rabbit::UserPointer p,int64_t size)
rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const char *filename,rabbit::Bool printerror) rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const char *filename,rabbit::Bool printerror)
{ {
SQFILE file = rabbit::std::fopen(filename,_SC("rb")); SQFILE file = rabbit::std::fopen(filename,"rb");
int64_t ret; int64_t ret;
unsigned short us; unsigned short us;
@ -334,11 +334,11 @@ rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const char *filen
case 0xBBEF: case 0xBBEF:
if(rabbit::std::fread(&uc,1,sizeof(uc),file) == 0) { if(rabbit::std::fread(&uc,1,sizeof(uc),file) == 0) {
rabbit::std::fclose(file); rabbit::std::fclose(file);
return sq_throwerror(v,_SC("io error")); return sq_throwerror(v,"io error");
} }
if(uc != 0xBF) { if(uc != 0xBF) {
rabbit::std::fclose(file); rabbit::std::fclose(file);
return sq_throwerror(v,_SC("Unrecognized encoding")); return sq_throwerror(v,"Unrecognized encoding");
} }
func = _io_file_lexfeed_PLAIN; func = _io_file_lexfeed_PLAIN;
break;//UTF-8 ; break;//UTF-8 ;
@ -356,14 +356,14 @@ rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const char *filen
rabbit::std::fclose(file); rabbit::std::fclose(file);
return SQ_ERROR; return SQ_ERROR;
} }
return sq_throwerror(v,_SC("cannot open the file")); return sq_throwerror(v,"cannot open the file");
} }
rabbit::Result rabbit::std::dofile(rabbit::VirtualMachine* v,const char *filename,rabbit::Bool retval,rabbit::Bool printerror) rabbit::Result rabbit::std::dofile(rabbit::VirtualMachine* v,const 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)
return sq_throwerror(v,_SC("environment table expected")); return sq_throwerror(v,"environment table expected");
if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,printerror))) { if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,printerror))) {
sq_push(v,-2); sq_push(v,-2);
@ -378,8 +378,8 @@ rabbit::Result rabbit::std::dofile(rabbit::VirtualMachine* v,const char *filenam
rabbit::Result rabbit::std::writeclosuretofile(rabbit::VirtualMachine* v,const char *filename) rabbit::Result rabbit::std::writeclosuretofile(rabbit::VirtualMachine* v,const char *filename)
{ {
SQFILE file = rabbit::std::fopen(filename,_SC("wb+")); SQFILE file = rabbit::std::fopen(filename,"wb+");
if(!file) return sq_throwerror(v,_SC("cannot open the file")); if(!file) return sq_throwerror(v,"cannot open the file");
if(SQ_SUCCEEDED(sq_writeclosure(v,file_write,file))) { if(SQ_SUCCEEDED(sq_writeclosure(v,file_write,file))) {
rabbit::std::fclose(file); rabbit::std::fclose(file);
return SQ_OK; return SQ_OK;
@ -424,11 +424,11 @@ int64_t _g_io_dofile(rabbit::VirtualMachine* v)
return SQ_ERROR; //propagates the error return SQ_ERROR; //propagates the error
} }
#define _DECL_GLOBALIO_FUNC(name,nparams,typecheck) {_SC(#name),_g_io_##name,nparams,typecheck} #define _DECL_GLOBALIO_FUNC(name,nparams,typecheck) {#name,_g_io_##name,nparams,typecheck}
static const rabbit::RegFunction iolib_funcs[]={ static const rabbit::RegFunction iolib_funcs[]={
_DECL_GLOBALIO_FUNC(loadfile,-2,_SC(".sb")), _DECL_GLOBALIO_FUNC(loadfile,-2,".sb"),
_DECL_GLOBALIO_FUNC(dofile,-2,_SC(".sb")), _DECL_GLOBALIO_FUNC(dofile,-2,".sb"),
_DECL_GLOBALIO_FUNC(writeclosuretofile,3,_SC(".sc")), _DECL_GLOBALIO_FUNC(writeclosuretofile,3,".sc"),
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
@ -436,14 +436,14 @@ rabbit::Result rabbit::std::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"),(rabbit::UserPointer)SQSTD_FILE_TYPE_TAG,_SC("std_file"),_file_methods,iolib_funcs); declare_stream(v,"file",(rabbit::UserPointer)SQSTD_FILE_TYPE_TAG, "std_file",_file_methods,iolib_funcs);
sq_pushstring(v,_SC("stdout"),-1); sq_pushstring(v,"stdout",-1);
rabbit::std::createfile(v,stdout,SQFalse); rabbit::std::createfile(v,stdout,SQFalse);
sq_newslot(v,-3,SQFalse); sq_newslot(v,-3,SQFalse);
sq_pushstring(v,_SC("stdin"),-1); sq_pushstring(v,"stdin",-1);
rabbit::std::createfile(v,stdin,SQFalse); rabbit::std::createfile(v,stdin,SQFalse);
sq_newslot(v,-3,SQFalse); sq_newslot(v,-3,SQFalse);
sq_pushstring(v,_SC("stderr"),-1); sq_pushstring(v,"stderr",-1);
rabbit::std::createfile(v,stderr,SQFalse); rabbit::std::createfile(v,stderr,SQFalse);
sq_newslot(v,-3,SQFalse); sq_newslot(v,-3,SQFalse);
sq_settop(v,top); sq_settop(v,top);

42
rabbit-std/sqstdmath.cpp
View File

@ -30,7 +30,7 @@ static int64_t math_srand(rabbit::VirtualMachine* v)
{ {
int64_t i; int64_t i;
if(SQ_FAILED(sq_getinteger(v,2,&i))) if(SQ_FAILED(sq_getinteger(v,2,&i)))
return sq_throwerror(v,_SC("invalid param")); return sq_throwerror(v,"invalid param");
srand((unsigned int)i); srand((unsigned int)i);
return 0; return 0;
} }
@ -65,26 +65,26 @@ SINGLE_ARG_FUNC(floor)
SINGLE_ARG_FUNC(ceil) 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) {#name,math_##name,nparams,tycheck}
static const rabbit::RegFunction mathlib_funcs[] = { static const rabbit::RegFunction mathlib_funcs[] = {
_DECL_FUNC(sqrt,2,_SC(".n")), _DECL_FUNC(sqrt,2,".n"),
_DECL_FUNC(sin,2,_SC(".n")), _DECL_FUNC(sin,2,".n"),
_DECL_FUNC(cos,2,_SC(".n")), _DECL_FUNC(cos,2,".n"),
_DECL_FUNC(asin,2,_SC(".n")), _DECL_FUNC(asin,2,".n"),
_DECL_FUNC(acos,2,_SC(".n")), _DECL_FUNC(acos,2,".n"),
_DECL_FUNC(log,2,_SC(".n")), _DECL_FUNC(log,2,".n"),
_DECL_FUNC(log10,2,_SC(".n")), _DECL_FUNC(log10,2,".n"),
_DECL_FUNC(tan,2,_SC(".n")), _DECL_FUNC(tan,2,".n"),
_DECL_FUNC(atan,2,_SC(".n")), _DECL_FUNC(atan,2,".n"),
_DECL_FUNC(atan2,3,_SC(".nn")), _DECL_FUNC(atan2,3,".nn"),
_DECL_FUNC(pow,3,_SC(".nn")), _DECL_FUNC(pow,3,".nn"),
_DECL_FUNC(floor,2,_SC(".n")), _DECL_FUNC(floor,2,".n"),
_DECL_FUNC(ceil,2,_SC(".n")), _DECL_FUNC(ceil,2,".n"),
_DECL_FUNC(exp,2,_SC(".n")), _DECL_FUNC(exp,2,".n"),
_DECL_FUNC(srand,2,_SC(".n")), _DECL_FUNC(srand,2,".n"),
_DECL_FUNC(rand,1,NULL), _DECL_FUNC(rand,1,NULL),
_DECL_FUNC(fabs,2,_SC(".n")), _DECL_FUNC(fabs,2,".n"),
_DECL_FUNC(abs,2,_SC(".n")), _DECL_FUNC(abs,2,".n"),
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
#undef _DECL_FUNC #undef _DECL_FUNC
@ -104,10 +104,10 @@ rabbit::Result rabbit::std::register_mathlib(rabbit::VirtualMachine* v)
sq_newslot(v,-3,SQFalse); sq_newslot(v,-3,SQFalse);
i++; i++;
} }
sq_pushstring(v,_SC("RAND_MAX"),-1); sq_pushstring(v,"RAND_MAX",-1);
sq_pushinteger(v,RAND_MAX); sq_pushinteger(v,RAND_MAX);
sq_newslot(v,-3,SQFalse); sq_newslot(v,-3,SQFalse);
sq_pushstring(v,_SC("PI"),-1); sq_pushstring(v,"PI",-1);
sq_pushfloat(v,(float_t)M_PI); sq_pushfloat(v,(float_t)M_PI);
sq_newslot(v,-3,SQFalse); sq_newslot(v,-3,SQFalse);
return SQ_OK; return SQ_OK;

60
rabbit-std/sqstdrex.cpp
View File

@ -15,12 +15,22 @@
#ifdef _DEBUG #ifdef _DEBUG
#include <stdio.h> #include <stdio.h>
static const char *g_nnames[] = static const char *g_nnames[] = {
{ "NONE",
_SC("NONE"),_SC("OP_GREEDY"), _SC("OP_OR"), "OP_GREEDY",
_SC("OP_EXPR"),_SC("OP_NOCAPEXPR"),_SC("OP_DOT"), _SC("OP_CLASS"), "OP_OR",
_SC("OP_CCLASS"),_SC("OP_NCLASS"),_SC("OP_RANGE"),_SC("OP_CHAR"), "OP_EXPR",
_SC("OP_EOL"),_SC("OP_BOL"),_SC("OP_WB"),_SC("OP_MB") "OP_NOCAPEXPR",
"OP_DOT",
"OP_CLASS",
"OP_CCLASS",
"OP_NCLASS",
"OP_RANGE",
"OP_CHAR",
"OP_EOL",
"OP_BOL",
"OP_WB",
"OP_MB"
}; };
#endif #endif
@ -105,7 +115,7 @@ namespace std {
static void rex_expect(SQRex *exp, int64_t n){ static void rex_expect(SQRex *exp, int64_t n){
if((*exp->_p) != n) if((*exp->_p) != n)
rabbit::std::rex_error(exp, _SC("expected paren")); rabbit::std::rex_error(exp, "expected paren");
exp->_p++; exp->_p++;
} }
@ -121,7 +131,7 @@ namespace std {
case 'f': exp->_p++; return '\f'; case 'f': exp->_p++; return '\f';
default: return (*exp->_p++); default: return (*exp->_p++);
} }
} else if(!isprint(*exp->_p)) rabbit::std::rex_error(exp,_SC("letter expected")); } else if(!isprint(*exp->_p)) rabbit::std::rex_error(exp,"letter expected");
return (*exp->_p++); return (*exp->_p++);
} }
@ -156,15 +166,15 @@ namespace std {
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
if ((!cb) || (!ce)) rabbit::std::rex_error(exp,_SC("balanced chars expected")); if ((!cb) || (!ce)) rabbit::std::rex_error(exp,"balanced chars expected");
if ( cb == ce ) rabbit::std::rex_error(exp,_SC("open/close char can't be the same")); if ( cb == ce ) rabbit::std::rex_error(exp,"open/close char can't be the same");
int64_t node = rabbit::std::rex_newnode(exp,OP_MB); int64_t node = rabbit::std::rex_newnode(exp,OP_MB);
exp->_nodes[node].left = cb; exp->_nodes[node].left = cb;
exp->_nodes[node].right = ce; exp->_nodes[node].right = ce;
return node; return node;
} }
case 0: case 0:
rabbit::std::rex_error(exp,_SC("letter expected for argument of escape sequence")); rabbit::std::rex_error(exp,"letter expected for argument of escape sequence");
break; break;
case 'b': case 'b':
case 'B': case 'B':
@ -181,7 +191,7 @@ namespace std {
} }
else if(!isprint(*exp->_p)) { else if(!isprint(*exp->_p)) {
rabbit::std::rex_error(exp,_SC("letter expected")); rabbit::std::rex_error(exp,"letter expected");
} }
t = *exp->_p; exp->_p++; t = *exp->_p; exp->_p++;
return rabbit::std::rex_newnode(exp,t); return rabbit::std::rex_newnode(exp,t);
@ -195,15 +205,15 @@ namespace std {
exp->_p++; exp->_p++;
}else ret = rabbit::std::rex_newnode(exp,OP_CLASS); }else ret = rabbit::std::rex_newnode(exp,OP_CLASS);
if(*exp->_p == ']') rabbit::std::rex_error(exp,_SC("empty class")); if(*exp->_p == ']') rabbit::std::rex_error(exp,"empty class");
chain = ret; chain = ret;
while(*exp->_p != ']' && exp->_p != exp->_eol) { while(*exp->_p != ']' && exp->_p != exp->_eol) {
if(*exp->_p == '-' && first != -1){ if(*exp->_p == '-' && first != -1){
int64_t r; int64_t r;
if(*exp->_p++ == ']') rabbit::std::rex_error(exp,_SC("unfinished range")); if(*exp->_p++ == ']') rabbit::std::rex_error(exp,"unfinished range");
r = rabbit::std::rex_newnode(exp,OP_RANGE); r = rabbit::std::rex_newnode(exp,OP_RANGE);
if(exp->_nodes[first].type>*exp->_p) rabbit::std::rex_error(exp,_SC("invalid range")); if(exp->_nodes[first].type>*exp->_p) rabbit::std::rex_error(exp,"invalid range");
if(exp->_nodes[first].type == OP_CCLASS) rabbit::std::rex_error(exp,_SC("cannot use character classes in ranges")); if(exp->_nodes[first].type == OP_CCLASS) rabbit::std::rex_error(exp,"cannot use character classes in ranges");
exp->_nodes[r].left = exp->_nodes[first].type; exp->_nodes[r].left = exp->_nodes[first].type;
int64_t t = rabbit::std::rex_escapechar(exp); int64_t t = rabbit::std::rex_escapechar(exp);
exp->_nodes[r].right = t; exp->_nodes[r].right = t;
@ -240,7 +250,7 @@ namespace std {
exp->_p++; exp->_p++;
while(isdigit(*exp->_p)) { while(isdigit(*exp->_p)) {
ret = ret*10+(*exp->_p++-'0'); ret = ret*10+(*exp->_p++-'0');
if(positions==1000000000) rabbit::std::rex_error(exp,_SC("overflow in numeric constant")); if(positions==1000000000) rabbit::std::rex_error(exp,"overflow in numeric constant");
positions *= 10; positions *= 10;
}; };
return ret; return ret;
@ -290,7 +300,7 @@ namespace std {
case SQREX_SYMBOL_GREEDY_ZERO_OR_ONE: p0 = 0; p1 = 1; exp->_p++; isgreedy = SQTrue; break; case SQREX_SYMBOL_GREEDY_ZERO_OR_ONE: p0 = 0; p1 = 1; exp->_p++; isgreedy = SQTrue; break;
case '{': case '{':
exp->_p++; exp->_p++;
if(!isdigit(*exp->_p)) rabbit::std::rex_error(exp,_SC("number expected")); if(!isdigit(*exp->_p)) rabbit::std::rex_error(exp,"number expected");
p0 = (unsigned short)rabbit::std::rex_parsenumber(exp); p0 = (unsigned short)rabbit::std::rex_parsenumber(exp);
/*******************************/ /*******************************/
switch(*exp->_p) { switch(*exp->_p) {
@ -306,7 +316,7 @@ namespace std {
rabbit::std::rex_expect(exp,'}'); rabbit::std::rex_expect(exp,'}');
break; break;
default: default:
rabbit::std::rex_error(exp,_SC(", or } expected")); rabbit::std::rex_error(exp,", or } expected");
} }
/*******************************/ /*******************************/
isgreedy = SQTrue; isgreedy = SQTrue;
@ -579,22 +589,22 @@ rabbit::std::SQRex *rabbit::std::rex_compile(const char *pattern,const char **er
int64_t res = rabbit::std::rex_list(exp); int64_t res = rabbit::std::rex_list(exp);
exp->_nodes[exp->_first].left = res; exp->_nodes[exp->_first].left = res;
if(*exp->_p!='\0') if(*exp->_p!='\0')
rabbit::std::rex_error(exp,_SC("unexpected character")); rabbit::std::rex_error(exp,"unexpected character");
#ifdef _DEBUG #ifdef _DEBUG
{ {
int64_t nsize,i; int64_t nsize,i;
SQRexNode *t; SQRexNode *t;
nsize = exp->_nsize; nsize = exp->_nsize;
t = &exp->_nodes[0]; t = &exp->_nodes[0];
printf(_SC("\n")); printf("\n");
for(i = 0;i < nsize; i++) { for(i = 0;i < nsize; i++) {
if(exp->_nodes[i].type>UINT8_MAX) if(exp->_nodes[i].type>UINT8_MAX)
printf(_SC("[%02d] %10s "), (int32_t)i,g_nnames[exp->_nodes[i].type-UINT8_MAX]); printf("[%02d] %10s ", (int32_t)i,g_nnames[exp->_nodes[i].type-UINT8_MAX]);
else else
printf(_SC("[%02d] %10c "), (int32_t)i,exp->_nodes[i].type); printf("[%02d] %10c ", (int32_t)i,exp->_nodes[i].type);
printf(_SC("left %02d right %02d next %02d\n"), (int32_t)exp->_nodes[i].left, (int32_t)exp->_nodes[i].right, (int32_t)exp->_nodes[i].next); printf("left %02d right %02d next %02d\n", (int32_t)exp->_nodes[i].left, (int32_t)exp->_nodes[i].right, (int32_t)exp->_nodes[i].next);
} }
printf(_SC("\n")); printf("\n");
} }
#endif #endif
exp->_matches = (SQRexMatch *) sq_malloc(exp->_nsubexpr * sizeof(SQRexMatch)); exp->_matches = (SQRexMatch *) sq_malloc(exp->_nsubexpr * sizeof(SQRexMatch));

50
rabbit-std/sqstdstream.cpp
View File

@ -19,9 +19,9 @@
#define SETUP_STREAM(v) \ #define SETUP_STREAM(v) \
rabbit::std::SQStream *self = NULL; \ rabbit::std::SQStream *self = NULL; \
if(SQ_FAILED(sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)((uint64_t)SQSTD_STREAM_TYPE_TAG)))) \ if(SQ_FAILED(sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)((uint64_t)SQSTD_STREAM_TYPE_TAG)))) \
return rabbit::sq_throwerror(v,_SC("invalid type tag")); \ return rabbit::sq_throwerror(v,"invalid type tag"); \
if(!self || !self->IsValid()) \ if(!self || !self->IsValid()) \
return rabbit::sq_throwerror(v,_SC("the stream is invalid")); return rabbit::sq_throwerror(v,"the stream is invalid");
int64_t _stream_readblob(rabbit::VirtualMachine* v) int64_t _stream_readblob(rabbit::VirtualMachine* v)
{ {
@ -35,14 +35,14 @@ int64_t _stream_readblob(rabbit::VirtualMachine* v)
data = sq_getscratchpad(v,size); data = sq_getscratchpad(v,size);
res = self->Read(data,size); res = self->Read(data,size);
if(res <= 0) if(res <= 0)
return sq_throwerror(v,_SC("no data left to read")); return sq_throwerror(v,"no data left to read");
blobp = rabbit::std::createblob(v,res); blobp = rabbit::std::createblob(v,res);
memcpy(blobp,data,res); memcpy(blobp,data,res);
return 1; return 1;
} }
#define SAFE_READN(ptr,len) { \ #define SAFE_READN(ptr,len) { \
if(self->Read(ptr,len) != len) return sq_throwerror(v,_SC("io error")); \ if(self->Read(ptr,len) != len) return sq_throwerror(v,"io error"); \
} }
int64_t _stream_readn(rabbit::VirtualMachine* v) int64_t _stream_readn(rabbit::VirtualMachine* v)
{ {
@ -99,7 +99,7 @@ int64_t _stream_readn(rabbit::VirtualMachine* v)
} }
break; break;
default: default:
return sq_throwerror(v, _SC("invalid format")); return sq_throwerror(v, "invalid format");
} }
return 1; return 1;
} }
@ -110,10 +110,10 @@ int64_t _stream_writeblob(rabbit::VirtualMachine* v)
int64_t size; int64_t size;
SETUP_STREAM(v); SETUP_STREAM(v);
if(SQ_FAILED(rabbit::std::getblob(v,2,&data))) if(SQ_FAILED(rabbit::std::getblob(v,2,&data)))
return sq_throwerror(v,_SC("invalid parameter")); return sq_throwerror(v,"invalid parameter");
size = rabbit::std::getblobsize(v,2); size = rabbit::std::getblobsize(v,2);
if(self->Write(data,size) != size) if(self->Write(data,size) != size)
return sq_throwerror(v,_SC("io error")); return sq_throwerror(v,"io error");
sq_pushinteger(v,size); sq_pushinteger(v,size);
return 1; return 1;
} }
@ -182,7 +182,7 @@ int64_t _stream_writen(rabbit::VirtualMachine* v)
} }
break; break;
default: default:
return sq_throwerror(v, _SC("invalid format")); return sq_throwerror(v, "invalid format");
} }
return 0; return 0;
} }
@ -199,7 +199,7 @@ int64_t _stream_seek(rabbit::VirtualMachine* v)
case 'b': origin = SQ_SEEK_SET; break; case 'b': origin = SQ_SEEK_SET; break;
case 'c': origin = SQ_SEEK_CUR; break; case 'c': origin = SQ_SEEK_CUR; break;
case 'e': origin = SQ_SEEK_END; break; case 'e': origin = SQ_SEEK_END; break;
default: return sq_throwerror(v,_SC("invalid origin")); default: return sq_throwerror(v,"invalid origin");
} }
} }
sq_pushinteger(v, self->Seek(offset, origin)); sq_pushinteger(v, self->Seek(offset, origin));
@ -242,19 +242,19 @@ int64_t _stream_eos(rabbit::VirtualMachine* v)
int64_t _stream__cloned(rabbit::VirtualMachine* v) int64_t _stream__cloned(rabbit::VirtualMachine* v)
{ {
return sq_throwerror(v,_SC("this object cannot be cloned")); return sq_throwerror(v,"this object cannot be cloned");
} }
static const rabbit::RegFunction _stream_methods[] = { static const rabbit::RegFunction _stream_methods[] = {
_DECL_STREAM_FUNC(readblob,2,_SC("xn")), _DECL_STREAM_FUNC(readblob,2,"xn"),
_DECL_STREAM_FUNC(readn,2,_SC("xn")), _DECL_STREAM_FUNC(readn,2,"xn"),
_DECL_STREAM_FUNC(writeblob,-2,_SC("xx")), _DECL_STREAM_FUNC(writeblob,-2,"xx"),
_DECL_STREAM_FUNC(writen,3,_SC("xnn")), _DECL_STREAM_FUNC(writen,3,"xnn"),
_DECL_STREAM_FUNC(seek,-2,_SC("xnn")), _DECL_STREAM_FUNC(seek,-2,"xnn"),
_DECL_STREAM_FUNC(tell,1,_SC("x")), _DECL_STREAM_FUNC(tell,1,"x"),
_DECL_STREAM_FUNC(len,1,_SC("x")), _DECL_STREAM_FUNC(len,1,"x"),
_DECL_STREAM_FUNC(eos,1,_SC("x")), _DECL_STREAM_FUNC(eos,1,"x"),
_DECL_STREAM_FUNC(flush,1,_SC("x")), _DECL_STREAM_FUNC(flush,1,"x"),
_DECL_STREAM_FUNC(_cloned,0,NULL), _DECL_STREAM_FUNC(_cloned,0,NULL),
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
@ -262,9 +262,9 @@ static const rabbit::RegFunction _stream_methods[] = {
void init_streamclass(rabbit::VirtualMachine* v) void init_streamclass(rabbit::VirtualMachine* v)
{ {
sq_pushregistrytable(v); sq_pushregistrytable(v);
sq_pushstring(v,_SC("std_stream"),-1); sq_pushstring(v,"std_stream",-1);
if(SQ_FAILED(sq_get(v,-2))) { if(SQ_FAILED(sq_get(v,-2))) {
sq_pushstring(v,_SC("std_stream"),-1); sq_pushstring(v,"std_stream",-1);
sq_newclass(v,SQFalse); sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(rabbit::UserPointer)((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;
@ -278,8 +278,8 @@ void init_streamclass(rabbit::VirtualMachine* v)
} }
sq_newslot(v,-3,SQFalse); sq_newslot(v,-3,SQFalse);
sq_pushroottable(v); sq_pushroottable(v);
sq_pushstring(v,_SC("stream"),-1); sq_pushstring(v,"stream",-1);
sq_pushstring(v,_SC("std_stream"),-1); sq_pushstring(v,"std_stream",-1);
sq_get(v,-4); sq_get(v,-4);
sq_newslot(v,-3,SQFalse); sq_newslot(v,-3,SQFalse);
sq_pop(v,1); sq_pop(v,1);
@ -293,13 +293,13 @@ void init_streamclass(rabbit::VirtualMachine* v)
rabbit::Result rabbit::std::declare_stream(rabbit::VirtualMachine* v,const char* name,rabbit::UserPointer typetag,const char* reg_name,const rabbit::RegFunction *methods,const rabbit::RegFunction *globals) rabbit::Result rabbit::std::declare_stream(rabbit::VirtualMachine* v,const char* name,rabbit::UserPointer typetag,const char* reg_name,const rabbit::RegFunction *methods,const rabbit::RegFunction *globals)
{ {
if(sq_gettype(v,-1) != rabbit::OT_TABLE) if(sq_gettype(v,-1) != rabbit::OT_TABLE)
return sq_throwerror(v,_SC("table expected")); return sq_throwerror(v,"table expected");
int64_t top = sq_gettop(v); int64_t top = sq_gettop(v);
//create delegate //create delegate
init_streamclass(v); init_streamclass(v);
sq_pushregistrytable(v); sq_pushregistrytable(v);
sq_pushstring(v,reg_name,-1); sq_pushstring(v,reg_name,-1);
sq_pushstring(v,_SC("std_stream"),-1); sq_pushstring(v,"std_stream",-1);
if(SQ_SUCCEEDED(sq_get(v,-3))) { if(SQ_SUCCEEDED(sq_get(v,-3))) {
sq_newclass(v,SQTrue); sq_newclass(v,SQTrue);
sq_settypetag(v,-1,typetag); sq_settypetag(v,-1,typetag);

2
rabbit-std/sqstdstream.hpp
View File

@ -22,7 +22,7 @@ namespace rabbit {
int64_t _stream_eos(rabbit::VirtualMachine* v); 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) {#name,_stream_##name,nparams,typecheck}
rabbit::Result declare_stream(rabbit::VirtualMachine* v,const char* name,rabbit::UserPointer typetag,const char* reg_name,const rabbit::RegFunction *methods,const rabbit::RegFunction *globals); rabbit::Result declare_stream(rabbit::VirtualMachine* v,const char* name,rabbit::UserPointer typetag,const char* reg_name,const rabbit::RegFunction *methods,const rabbit::RegFunction *globals);
} }
} }

66
rabbit-std/sqstdstring.cpp
View File

@ -44,7 +44,7 @@ static int64_t validate_format(rabbit::VirtualMachine* v, char *fmt, const char
n++; n++;
wc++; wc++;
if(wc>=MAX_WFORMAT_LEN) if(wc>=MAX_WFORMAT_LEN)
return sq_throwerror(v,_SC("width format too long")); return sq_throwerror(v,"width format too long");
} }
swidth[wc] = '\0'; swidth[wc] = '\0';
if(wc > 0) { if(wc > 0) {
@ -61,7 +61,7 @@ static int64_t validate_format(rabbit::VirtualMachine* v, char *fmt, const char
n++; n++;
wc++; wc++;
if(wc>=MAX_WFORMAT_LEN) if(wc>=MAX_WFORMAT_LEN)
return sq_throwerror(v,_SC("precision format too long")); return sq_throwerror(v,"precision format too long");
} }
swidth[wc] = '\0'; swidth[wc] = '\0';
if(wc > 0) { if(wc > 0) {
@ -70,7 +70,7 @@ static int64_t validate_format(rabbit::VirtualMachine* v, char *fmt, const char
} }
} }
if (n-start > MAX_FORMAT_LEN ) if (n-start > MAX_FORMAT_LEN )
return sq_throwerror(v,_SC("format too long")); return sq_throwerror(v,"format too long");
memcpy(&fmt[1],&src[start],((n-start)+1)*sizeof(char)); memcpy(&fmt[1],&src[start],((n-start)+1)*sizeof(char));
fmt[(n-start)+2] = '\0'; fmt[(n-start)+2] = '\0';
return n; return n;
@ -104,7 +104,7 @@ rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstri
else { else {
n++; n++;
if( nparam > sq_gettop(v) ) if( nparam > sq_gettop(v) )
return sq_throwerror(v,_SC("not enough parameters for the given format string")); return sq_throwerror(v,"not enough parameters for the given format string");
n = validate_format(v,fmt,format,n,w); n = validate_format(v,fmt,format,n,w);
if(n < 0) return -1; if(n < 0) return -1;
int64_t addlen = 0; int64_t addlen = 0;
@ -115,7 +115,7 @@ rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstri
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,"string expected for the specified format");
addlen = (sq_getsize(v,nparam)*sizeof(char))+((w+1)*sizeof(char)); addlen = (sq_getsize(v,nparam)*sizeof(char))+((w+1)*sizeof(char));
valtype = 's'; valtype = 's';
break; break;
@ -126,27 +126,27 @@ rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstri
int64_t fpos = flen - 1; int64_t fpos = flen - 1;
char f = fmt[fpos]; char f = fmt[fpos];
const char *prec = (const char *)_PRINT_INT_PREC; const char *prec = (const char *)_PRINT_INT_PREC;
while(*prec != _SC('\0')) { while(*prec != '\0') {
fmt[fpos++] = *prec++; fmt[fpos++] = *prec++;
} }
fmt[fpos++] = f; fmt[fpos++] = f;
fmt[fpos++] = _SC('\0'); fmt[fpos++] = '\0';
} }
#endif #endif
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,"integer expected for the specified format");
addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(char)); addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(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,"float expected for the specified format");
addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(char)); addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(char));
valtype = 'f'; valtype = 'f';
break; break;
default: default:
return sq_throwerror(v,_SC("invalid format")); return sq_throwerror(v,"invalid format");
} }
n++; n++;
allocated += addlen + sizeof(char); allocated += addlen + sizeof(char);
@ -243,7 +243,7 @@ static int64_t _string_split(rabbit::VirtualMachine* v)
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,"empty separators string");
int64_t memsize = (sq_getsize(v,2)+1)*sizeof(char); int64_t memsize = (sq_getsize(v,2)+1)*sizeof(char);
stemp = sq_getscratchpad(v,memsize); stemp = sq_getscratchpad(v,memsize);
memcpy(stemp,str,memsize); memcpy(stemp,str,memsize);
@ -285,7 +285,7 @@ static int64_t _string_escape(rabbit::VirtualMachine* v)
sq_push(v,2); sq_push(v,2);
return 1; return 1;
} }
const char *escpat = _SC("\\x%02x"); const char *escpat = "\\x%02x";
const int64_t maxescsize = 4; const int64_t maxescsize = 4;
int64_t destcharsize = (size * maxescsize); //assumes every char could be escaped int64_t destcharsize = (size * maxescsize); //assumes every char could be escaped
resstr = dest = (char *)sq_getscratchpad(v,destcharsize * sizeof(char)); resstr = dest = (char *)sq_getscratchpad(v,destcharsize * sizeof(char));
@ -392,10 +392,10 @@ static int64_t _regexp_match(rabbit::VirtualMachine* v)
static void _addrexmatch(rabbit::VirtualMachine* v,const char *str,const char *begin,const char *end) static void _addrexmatch(rabbit::VirtualMachine* v,const char *str,const char *begin,const char *end)
{ {
sq_newtable(v); sq_newtable(v);
sq_pushstring(v,_SC("begin"),-1); sq_pushstring(v,"begin",-1);
sq_pushinteger(v,begin - str); sq_pushinteger(v,begin - str);
sq_rawset(v,-3); sq_rawset(v,-3);
sq_pushstring(v,_SC("end"),-1); sq_pushstring(v,"end",-1);
sq_pushinteger(v,end - str); sq_pushinteger(v,end - str);
sq_rawset(v,-3); sq_rawset(v,-3);
} }
@ -458,33 +458,33 @@ static int64_t _regexp_constructor(rabbit::VirtualMachine* v)
static int64_t _regexp__typeof(rabbit::VirtualMachine* v) static int64_t _regexp__typeof(rabbit::VirtualMachine* v)
{ {
sq_pushstring(v,_SC("regexp"),-1); sq_pushstring(v,"regexp",-1);
return 1; return 1;
} }
#define _DECL_REX_FUNC(name,nparams,pmask) {_SC(#name),_regexp_##name,nparams,pmask} #define _DECL_REX_FUNC(name,nparams,pmask) {#name,_regexp_##name,nparams,pmask}
static const rabbit::RegFunction rexobj_funcs[]={ static const rabbit::RegFunction rexobj_funcs[]={
_DECL_REX_FUNC(constructor,2,_SC(".s")), _DECL_REX_FUNC(constructor,2,".s"),
_DECL_REX_FUNC(search,-2,_SC("xsn")), _DECL_REX_FUNC(search,-2,"xsn"),
_DECL_REX_FUNC(match,2,_SC("xs")), _DECL_REX_FUNC(match,2,"xs"),
_DECL_REX_FUNC(capture,-2,_SC("xsn")), _DECL_REX_FUNC(capture,-2,"xsn"),
_DECL_REX_FUNC(subexpcount,1,_SC("x")), _DECL_REX_FUNC(subexpcount,1,"x"),
_DECL_REX_FUNC(_typeof,1,_SC("x")), _DECL_REX_FUNC(_typeof,1,"x"),
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
#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) {#name,_string_##name,nparams,pmask}
static const rabbit::RegFunction stringlib_funcs[]={ static const rabbit::RegFunction stringlib_funcs[]={
_DECL_FUNC(format,-2,_SC(".s")), _DECL_FUNC(format,-2,".s"),
_DECL_FUNC(printf,-2,_SC(".s")), _DECL_FUNC(printf,-2,".s"),
_DECL_FUNC(strip,2,_SC(".s")), _DECL_FUNC(strip,2,".s"),
_DECL_FUNC(lstrip,2,_SC(".s")), _DECL_FUNC(lstrip,2,".s"),
_DECL_FUNC(rstrip,2,_SC(".s")), _DECL_FUNC(rstrip,2,".s"),
_DECL_FUNC(split,3,_SC(".ss")), _DECL_FUNC(split,3,".ss"),
_DECL_FUNC(escape,2,_SC(".s")), _DECL_FUNC(escape,2,".s"),
_DECL_FUNC(startswith,3,_SC(".ss")), _DECL_FUNC(startswith,3,".ss"),
_DECL_FUNC(endswith,3,_SC(".ss")), _DECL_FUNC(endswith,3,".ss"),
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
#undef _DECL_FUNC #undef _DECL_FUNC
@ -492,7 +492,7 @@ static const rabbit::RegFunction stringlib_funcs[]={
int64_t rabbit::std::register_stringlib(rabbit::VirtualMachine* v) int64_t rabbit::std::register_stringlib(rabbit::VirtualMachine* v)
{ {
sq_pushstring(v,_SC("regexp"),-1); sq_pushstring(v,"regexp",-1);
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) {

36
rabbit-std/sqstdsystem.cpp
View File

@ -32,7 +32,7 @@ static int64_t _system_system(rabbit::VirtualMachine* v)
sq_pushinteger(v,system(s)); sq_pushinteger(v,system(s));
return 1; return 1;
} }
return sq_throwerror(v,_SC("wrong param")); return sq_throwerror(v,"wrong param");
} }
@ -54,7 +54,7 @@ static int64_t _system_remove(rabbit::VirtualMachine* v)
const char *s; const char *s;
sq_getstring(v,2,&s); sq_getstring(v,2,&s);
if(remove(s)==-1) if(remove(s)==-1)
return sq_throwerror(v,_SC("remove() failed")); return sq_throwerror(v,"remove() failed");
return 0; return 0;
} }
@ -64,7 +64,7 @@ static int64_t _system_rename(rabbit::VirtualMachine* v)
sq_getstring(v,2,&oldn); sq_getstring(v,2,&oldn);
sq_getstring(v,3,&newn); sq_getstring(v,3,&newn);
if(rename(oldn,newn)==-1) if(rename(oldn,newn)==-1)
return sq_throwerror(v,_SC("rename() failed")); return sq_throwerror(v,"rename() failed");
return 0; return 0;
} }
@ -96,30 +96,30 @@ static int64_t _system_date(rabbit::VirtualMachine* v)
else else
date = localtime(&t); date = localtime(&t);
if(!date) if(!date)
return sq_throwerror(v,_SC("crt api failure")); return sq_throwerror(v,"crt api failure");
sq_newtable(v); sq_newtable(v);
_set_integer_slot(v, _SC("sec"), date->tm_sec); _set_integer_slot(v, "sec", date->tm_sec);
_set_integer_slot(v, _SC("min"), date->tm_min); _set_integer_slot(v, "min", date->tm_min);
_set_integer_slot(v, _SC("hour"), date->tm_hour); _set_integer_slot(v, "hour", date->tm_hour);
_set_integer_slot(v, _SC("day"), date->tm_mday); _set_integer_slot(v, "day", date->tm_mday);
_set_integer_slot(v, _SC("month"), date->tm_mon); _set_integer_slot(v, "month", date->tm_mon);
_set_integer_slot(v, _SC("year"), date->tm_year+1900); _set_integer_slot(v, "year", date->tm_year+1900);
_set_integer_slot(v, _SC("wday"), date->tm_wday); _set_integer_slot(v, "wday", date->tm_wday);
_set_integer_slot(v, _SC("yday"), date->tm_yday); _set_integer_slot(v, "yday", date->tm_yday);
return 1; return 1;
} }
#define _DECL_FUNC(name,nparams,pmask) {_SC(#name),_system_##name,nparams,pmask} #define _DECL_FUNC(name,nparams,pmask) {#name,_system_##name,nparams,pmask}
static const rabbit::RegFunction systemlib_funcs[]={ static const rabbit::RegFunction systemlib_funcs[]={
_DECL_FUNC(getenv,2,_SC(".s")), _DECL_FUNC(getenv,2,".s"),
_DECL_FUNC(system,2,_SC(".s")), _DECL_FUNC(system,2,".s"),
_DECL_FUNC(clock,0,NULL), _DECL_FUNC(clock,0,NULL),
_DECL_FUNC(time,1,NULL), _DECL_FUNC(time,1,NULL),
_DECL_FUNC(date,-1,_SC(".nn")), _DECL_FUNC(date,-1,".nn"),
_DECL_FUNC(remove,2,_SC(".s")), _DECL_FUNC(remove,2,".s"),
_DECL_FUNC(rename,3,_SC(".ss")), _DECL_FUNC(rename,3,".ss"),
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
#undef _DECL_FUNC #undef _DECL_FUNC

10
rabbit/Closure.cpp
View File

@ -28,7 +28,7 @@
bool rabbit::SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size) bool rabbit::SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size)
{ {
if(write(up,dest,size) != size) { if(write(up,dest,size) != size) {
v->raise_error(_SC("io error (write function failure)")); v->raise_error("io error (write function failure)");
return false; return false;
} }
return true; return true;
@ -37,7 +37,7 @@ bool rabbit::SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserP
bool rabbit::SafeRead(rabbit::VirtualMachine* v,SQWRITEFUNC read,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size) bool rabbit::SafeRead(rabbit::VirtualMachine* v,SQWRITEFUNC read,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size)
{ {
if(size && read(up,dest,size) != size) { 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("io error, read function failure, the origin stream could be corrupted/trucated");
return false; return false;
} }
return true; return true;
@ -53,7 +53,7 @@ bool rabbit::CheckTag(rabbit::VirtualMachine* v,SQWRITEFUNC read,rabbit::UserPoi
uint32_t t; uint32_t t;
_CHECK_IO(SafeRead(v,read,up,&t,sizeof(t))); _CHECK_IO(SafeRead(v,read,up,&t,sizeof(t)));
if(t != tag){ if(t != tag){
v->raise_error(_SC("invalid or corrupted closure stream")); v->raise_error("invalid or corrupted closure stream");
return false; return false;
} }
return true; return true;
@ -76,7 +76,7 @@ bool rabbit::WriteObject(rabbit::VirtualMachine* v,rabbit::UserPointer up,SQWRIT
case rabbit::OT_NULL: case rabbit::OT_NULL:
break; break;
default: default:
v->raise_error(_SC("cannot serialize a %s"),getTypeName(o)); v->raise_error("cannot serialize a %s",getTypeName(o));
return false; return false;
} }
return true; return true;
@ -111,7 +111,7 @@ bool rabbit::ReadObject(rabbit::VirtualMachine* v,rabbit::UserPointer up,SQREADF
o.Null(); o.Null();
break; break;
default: default:
v->raise_error(_SC("cannot serialize a %s"),IdType2Name(t)); v->raise_error("cannot serialize a %s",IdType2Name(t));
return false; return false;
} }
return true; return true;

283
rabbit/Compiler.cpp
View File

@ -95,7 +95,7 @@ public:
_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] = '\0';
} }
static void Throwerror(void *ud, const char *s) { static void Throwerror(void *ud, const char *s) {
rabbit::Compiler *c = (rabbit::Compiler *)ud; rabbit::Compiler *c = (rabbit::Compiler *)ud;
@ -123,23 +123,23 @@ public:
switch(tok) switch(tok)
{ {
case TK_IDENTIFIER: case TK_IDENTIFIER:
etypename = _SC("IDENTIFIER"); etypename = "IDENTIFIER";
break; break;
case TK_STRING_LITERAL: case TK_STRING_LITERAL:
etypename = _SC("STRING_LITERAL"); etypename = "STRING_LITERAL";
break; break;
case TK_INTEGER: case TK_INTEGER:
etypename = _SC("INTEGER"); etypename = "INTEGER";
break; break;
case TK_FLOAT: case TK_FLOAT:
etypename = _SC("FLOAT"); etypename = "FLOAT";
break; break;
default: default:
etypename = _lex.tok2Str(tok); etypename = _lex.tok2Str(tok);
} }
error(_SC("expected '%s'"), etypename); error("expected '%s'", etypename);
} }
error(_SC("expected '%c'"), tok); error("expected '%c'", tok);
} }
} }
rabbit::ObjectPtr ret; rabbit::ObjectPtr ret;
@ -161,12 +161,16 @@ public:
Lex(); Lex();
return ret; return ret;
} }
bool IsEndOfStatement() { return ((_lex._prevtoken == _SC('\n')) || (_token == RABBIT_EOB) || (_token == _SC('}')) || (_token == _SC(';'))); } bool IsEndOfStatement() {
void OptionalSemicolon() return _lex._prevtoken == '\n'
{ || _token == RABBIT_EOB
if(_token == _SC(';')) { Lex(); return; } || _token == '}'
|| _token == ';';
}
void OptionalSemicolon() {
if(_token == ';') { Lex(); return; }
if(!IsEndOfStatement()) { if(!IsEndOfStatement()) {
error(_SC("end of statement expected (; or lf)")); error("end of statement expected (; or lf)");
} }
} }
void MoveIfCurrentTargetisLocal() { void MoveIfCurrentTargetisLocal() {
@ -182,10 +186,10 @@ public:
_debugop = 0; _debugop = 0;
FuncState funcstate(_get_shared_state(_vm), NULL,Throwerror,this); FuncState funcstate(_get_shared_state(_vm), NULL,Throwerror,this);
funcstate._name = rabbit::String::create(_get_shared_state(_vm), _SC("main")); funcstate._name = rabbit::String::create(_get_shared_state(_vm), "main");
_fs = &funcstate; _fs = &funcstate;
_fs->addParameter(_fs->createString(_SC("this"))); _fs->addParameter(_fs->createString("this"));
_fs->addParameter(_fs->createString(_SC("vargv"))); _fs->addParameter(_fs->createString("vargv"));
_fs->_varparams = true; _fs->_varparams = true;
_fs->_sourcename = _sourcename; _fs->_sourcename = _sourcename;
int64_t stacksize = _fs->getStacksize(); int64_t stacksize = _fs->getStacksize();
@ -193,7 +197,7 @@ public:
Lex(); Lex();
while(_token > 0){ while(_token > 0){
Statement(); Statement();
if(_lex._prevtoken != _SC('}') && _lex._prevtoken != _SC(';')) OptionalSemicolon(); if(_lex._prevtoken != '}' && _lex._prevtoken != ';') OptionalSemicolon();
} }
_fs->setStacksize(stacksize); _fs->setStacksize(stacksize);
_fs->addLineInfos(_lex._currentline, _lineinfo, true); _fs->addLineInfos(_lex._currentline, _lineinfo, true);
@ -206,7 +210,7 @@ public:
} }
else { else {
if(_raiseerror && _get_shared_state(_vm)->_compilererrorhandler) { if(_raiseerror && _get_shared_state(_vm)->_compilererrorhandler) {
_get_shared_state(_vm)->_compilererrorhandler(_vm, _compilererror, sq_type(_sourcename) == rabbit::OT_STRING?_stringval(_sourcename):_SC("unknown"), _get_shared_state(_vm)->_compilererrorhandler(_vm, _compilererror, sq_type(_sourcename) == rabbit::OT_STRING?_stringval(_sourcename):"unknown",
_lex._currentline, _lex._currentcolumn); _lex._currentline, _lex._currentcolumn);
} }
_vm->_lasterror = rabbit::String::create(_get_shared_state(_vm), _compilererror, -1); _vm->_lasterror = rabbit::String::create(_get_shared_state(_vm), _compilererror, -1);
@ -216,16 +220,16 @@ public:
} }
void Statements() void Statements()
{ {
while(_token != _SC('}') && _token != TK_DEFAULT && _token != TK_CASE) { while(_token != '}' && _token != TK_DEFAULT && _token != TK_CASE) {
Statement(); Statement();
if(_lex._prevtoken != _SC('}') && _lex._prevtoken != _SC(';')) OptionalSemicolon(); if(_lex._prevtoken != '}' && _lex._prevtoken != ';') OptionalSemicolon();
} }
} }
void Statement(bool closeframe = true) void Statement(bool closeframe = true)
{ {
_fs->addLineInfos(_lex._currentline, _lineinfo); _fs->addLineInfos(_lex._currentline, _lineinfo);
switch(_token){ switch(_token){
case _SC(';'): Lex(); break; case ';': Lex(); break;
case TK_IF: IfStatement(); break; case TK_IF: IfStatement(); break;
case TK_WHILE: WhileStatement(); break; case TK_WHILE: WhileStatement(); break;
case TK_DO: DoWhileStatement(); break; case TK_DO: DoWhileStatement(); break;
@ -260,7 +264,7 @@ public:
} }
break;} break;}
case TK_BREAK: case TK_BREAK:
if(_fs->_breaktargets.size() <= 0)error(_SC("'break' has to be in a loop block")); if(_fs->_breaktargets.size() <= 0)error("'break' has to be in a loop block");
if(_fs->_breaktargets.back() > 0){ if(_fs->_breaktargets.back() > 0){
_fs->addInstruction(_OP_POPTRAP, _fs->_breaktargets.back(), 0); _fs->addInstruction(_OP_POPTRAP, _fs->_breaktargets.back(), 0);
} }
@ -270,7 +274,7 @@ public:
Lex(); Lex();
break; break;
case TK_CONTINUE: case TK_CONTINUE:
if(_fs->_continuetargets.size() <= 0)error(_SC("'continue' has to be in a loop block")); if(_fs->_continuetargets.size() <= 0)error("'continue' has to be in a loop block");
if(_fs->_continuetargets.back() > 0) { if(_fs->_continuetargets.back() > 0) {
_fs->addInstruction(_OP_POPTRAP, _fs->_continuetargets.back(), 0); _fs->addInstruction(_OP_POPTRAP, _fs->_continuetargets.back(), 0);
} }
@ -288,11 +292,11 @@ public:
case TK_ENUM: case TK_ENUM:
EnumStatement(); EnumStatement();
break; break;
case _SC('{'):{ case '{':{
BEGIN_SCOPE(); BEGIN_SCOPE();
Lex(); Lex();
Statements(); Statements();
Expect(_SC('}')); Expect('}');
if(closeframe) { if(closeframe) {
END_SCOPE(); END_SCOPE();
} }
@ -391,7 +395,7 @@ public:
_es.donot_get = false; _es.donot_get = false;
LogicalOrExp(); LogicalOrExp();
switch(_token) { switch(_token) {
case _SC('='): case '=':
case TK_NEWSLOT: case TK_NEWSLOT:
case TK_MINUSEQ: case TK_MINUSEQ:
case TK_PLUSEQ: case TK_PLUSEQ:
@ -401,8 +405,8 @@ public:
int64_t op = _token; int64_t op = _token;
int64_t ds = _es.etype; int64_t ds = _es.etype;
int64_t pos = _es.epos; int64_t pos = _es.epos;
if(ds == EXPR) error(_SC("can't assign expression")); if(ds == EXPR) error("can't assign expression");
else if(ds == BASE) error(_SC("'base' cannot be modified")); else if(ds == BASE) error("'base' cannot be modified");
Lex(); Expression(); Lex(); Expression();
switch(op){ switch(op){
@ -410,9 +414,9 @@ public:
if(ds == OBJECT || ds == BASE) if(ds == OBJECT || ds == BASE)
EmitDerefOp(_OP_NEWSLOT); EmitDerefOp(_OP_NEWSLOT);
else //if _derefstate != DEREF_NO_DEREF && DEREF_FIELD so is the index of a local else //if _derefstate != DEREF_NO_DEREF && DEREF_FIELD so is the index of a local
error(_SC("can't 'create' a local slot")); error("can't 'create' a local slot");
break; break;
case _SC('='): //ASSIGN case '=': //ASSIGN
switch(ds) { switch(ds) {
case LOCAL: case LOCAL:
{ {
@ -443,7 +447,7 @@ public:
} }
} }
break; break;
case _SC('?'): { case '?': {
Lex(); Lex();
_fs->addInstruction(_OP_JZ, _fs->popTarget()); _fs->addInstruction(_OP_JZ, _fs->popTarget());
int64_t jzpos = _fs->getCurrentPos(); int64_t jzpos = _fs->getCurrentPos();
@ -453,7 +457,7 @@ public:
if(trg != first_exp) _fs->addInstruction(_OP_MOVE, trg, first_exp); if(trg != first_exp) _fs->addInstruction(_OP_MOVE, trg, first_exp);
int64_t endfirstexp = _fs->getCurrentPos(); int64_t endfirstexp = _fs->getCurrentPos();
_fs->addInstruction(_OP_JMP, 0, 0); _fs->addInstruction(_OP_JMP, 0, 0);
Expect(_SC(':')); Expect(':');
int64_t jmppos = _fs->getCurrentPos(); int64_t jmppos = _fs->getCurrentPos();
Expression(); Expression();
int64_t second_exp = _fs->popTarget(); int64_t second_exp = _fs->popTarget();
@ -529,21 +533,21 @@ public:
void BitwiseOrExp() void BitwiseOrExp()
{ {
BitwiseXorExp(); BitwiseXorExp();
for(;;) if(_token == _SC('|')) for(;;) if(_token == '|')
{BIN_EXP(_OP_BITW, &rabbit::Compiler::BitwiseXorExp,BW_OR); {BIN_EXP(_OP_BITW, &rabbit::Compiler::BitwiseXorExp,BW_OR);
}else return; }else return;
} }
void BitwiseXorExp() void BitwiseXorExp()
{ {
BitwiseAndExp(); BitwiseAndExp();
for(;;) if(_token == _SC('^')) for(;;) if(_token == '^')
{BIN_EXP(_OP_BITW, &rabbit::Compiler::BitwiseAndExp,BW_XOR); {BIN_EXP(_OP_BITW, &rabbit::Compiler::BitwiseAndExp,BW_XOR);
}else return; }else return;
} }
void BitwiseAndExp() void BitwiseAndExp()
{ {
EqExp(); EqExp();
for(;;) if(_token == _SC('&')) for(;;) if(_token == '&')
{BIN_EXP(_OP_BITW, &rabbit::Compiler::EqExp,BW_AND); {BIN_EXP(_OP_BITW, &rabbit::Compiler::EqExp,BW_AND);
}else return; }else return;
} }
@ -561,8 +565,8 @@ public:
{ {
ShiftExp(); ShiftExp();
for(;;) switch(_token) { for(;;) switch(_token) {
case _SC('>'): BIN_EXP(_OP_CMP, &rabbit::Compiler::ShiftExp,CMP_G); break; case '>': BIN_EXP(_OP_CMP, &rabbit::Compiler::ShiftExp,CMP_G); break;
case _SC('<'): BIN_EXP(_OP_CMP, &rabbit::Compiler::ShiftExp,CMP_L); break; case '<': BIN_EXP(_OP_CMP, &rabbit::Compiler::ShiftExp,CMP_L); break;
case TK_GE: BIN_EXP(_OP_CMP, &rabbit::Compiler::ShiftExp,CMP_GE); break; case TK_GE: BIN_EXP(_OP_CMP, &rabbit::Compiler::ShiftExp,CMP_GE); break;
case TK_LE: BIN_EXP(_OP_CMP, &rabbit::Compiler::ShiftExp,CMP_LE); break; case TK_LE: BIN_EXP(_OP_CMP, &rabbit::Compiler::ShiftExp,CMP_LE); break;
case TK_IN: BIN_EXP(_OP_EXISTS, &rabbit::Compiler::ShiftExp); break; case TK_IN: BIN_EXP(_OP_EXISTS, &rabbit::Compiler::ShiftExp); break;
@ -610,7 +614,7 @@ public:
{ {
MultExp(); MultExp();
for(;;) switch(_token) { for(;;) switch(_token) {
case _SC('+'): case _SC('-'): case '+': case '-':
BIN_EXP(ChooseArithOpByToken(_token), &rabbit::Compiler::MultExp); break; BIN_EXP(ChooseArithOpByToken(_token), &rabbit::Compiler::MultExp); break;
default: return; default: return;
} }
@ -620,7 +624,7 @@ public:
{ {
PrefixedExpr(); PrefixedExpr();
for(;;) switch(_token) { for(;;) switch(_token) {
case _SC('*'): case _SC('/'): case _SC('%'): case '*': case '/': case '%':
BIN_EXP(ChooseArithOpByToken(_token), &rabbit::Compiler::PrefixedExpr); break; BIN_EXP(ChooseArithOpByToken(_token), &rabbit::Compiler::PrefixedExpr); break;
default: return; default: return;
} }
@ -631,7 +635,7 @@ public:
int64_t pos = Factor(); int64_t pos = Factor();
for(;;) { for(;;) {
switch(_token) { switch(_token) {
case _SC('.'): case '.':
pos = -1; pos = -1;
Lex(); Lex();
@ -649,9 +653,9 @@ public:
_es.etype = OBJECT; _es.etype = OBJECT;
} }
break; break;
case _SC('['): case '[':
if(_lex._prevtoken == _SC('\n')) error(_SC("cannot brake deref/or comma needed after [exp]=exp slot declaration")); if(_lex._prevtoken == '\n') error("cannot brake deref/or comma needed after [exp]=exp slot declaration");
Lex(); Expression(); Expect(_SC(']')); Lex(); Expression(); Expect(']');
pos = -1; pos = -1;
if(_es.etype==BASE) { if(_es.etype==BASE) {
Emit2ArgsOP(_OP_GET); Emit2ArgsOP(_OP_GET);
@ -674,10 +678,10 @@ public:
Lex(); Lex();
switch(_es.etype) switch(_es.etype)
{ {
case EXPR: error(_SC("can't '++' or '--' an expression")); break; case EXPR: error("can't '++' or '--' an expression"); break;
case OBJECT: case OBJECT:
case BASE: case BASE:
if(_es.donot_get == true) { error(_SC("can't '++' or '--' an expression")); break; } //mmh dor this make sense? if(_es.donot_get == true) { error("can't '++' or '--' an expression"); break; } //mmh dor this make sense?
Emit2ArgsOP(_OP_PINC, diff); Emit2ArgsOP(_OP_PINC, diff);
break; break;
case LOCAL: { case LOCAL: {
@ -697,7 +701,7 @@ public:
} }
return; return;
break; break;
case _SC('('): case '(':
switch(_es.etype) { switch(_es.etype) {
case OBJECT: { case OBJECT: {
int64_t key = _fs->popTarget(); /* location of the key */ int64_t key = _fs->popTarget(); /* location of the key */
@ -750,8 +754,8 @@ public:
switch(_token) { switch(_token) {
case TK_IDENTIFIER: id = _fs->createString(_lex._svalue); break; case TK_IDENTIFIER: id = _fs->createString(_lex._svalue); break;
case TK_THIS: id = _fs->createString(_SC("this"),4); break; case TK_THIS: id = _fs->createString("this",4); break;
case TK_CONSTRUCTOR: id = _fs->createString(_SC("constructor"),11); break; case TK_CONSTRUCTOR: id = _fs->createString("constructor",11); break;
} }
int64_t pos = -1; int64_t pos = -1;
@ -785,7 +789,7 @@ public:
constid = Expect(TK_IDENTIFIER); constid = Expect(TK_IDENTIFIER);
if(!_table(constant)->get(constid, constval)) { if(!_table(constant)->get(constid, constval)) {
constval.Null(); constval.Null();
error(_SC("invalid constant [%s.%s]"), _stringval(id), _stringval(constid)); error("invalid constant [%s.%s]", _stringval(id), _stringval(constid));
} }
} }
else { else {
@ -823,7 +827,7 @@ public:
case TK_DOUBLE_COLON: // "::" case TK_DOUBLE_COLON: // "::"
_fs->addInstruction(_OP_LOADROOT, _fs->pushTarget()); _fs->addInstruction(_OP_LOADROOT, _fs->pushTarget());
_es.etype = OBJECT; _es.etype = OBJECT;
_token = _SC('.'); /* hack: drop into PrefixExpr, case '.'*/ _token = '.'; /* hack: drop into PrefixExpr, case '.'*/
_es.epos = -1; _es.epos = -1;
return _es.epos; return _es.epos;
break; break;
@ -837,13 +841,13 @@ public:
_fs->addInstruction(_OP_LOADBOOL, _fs->pushTarget(),_token == TK_TRUE?1:0); _fs->addInstruction(_OP_LOADBOOL, _fs->pushTarget(),_token == TK_TRUE?1:0);
Lex(); Lex();
break; break;
case _SC('['): { case '[': {
_fs->addInstruction(_OP_NEWOBJ, _fs->pushTarget(),0,0,NOT_ARRAY); _fs->addInstruction(_OP_NEWOBJ, _fs->pushTarget(),0,0,NOT_ARRAY);
int64_t apos = _fs->getCurrentPos(),key = 0; int64_t apos = _fs->getCurrentPos(),key = 0;
Lex(); Lex();
while(_token != _SC(']')) { while(_token != ']') {
Expression(); Expression();
if(_token == _SC(',')) Lex(); if(_token == ',') Lex();
int64_t val = _fs->popTarget(); int64_t val = _fs->popTarget();
int64_t array = _fs->topTarget(); int64_t array = _fs->topTarget();
_fs->addInstruction(_OP_APPENDARRAY, array, val, AAT_STACK); _fs->addInstruction(_OP_APPENDARRAY, array, val, AAT_STACK);
@ -853,14 +857,14 @@ public:
Lex(); Lex();
} }
break; break;
case _SC('{'): case '{':
_fs->addInstruction(_OP_NEWOBJ, _fs->pushTarget(),0,NOT_TABLE); _fs->addInstruction(_OP_NEWOBJ, _fs->pushTarget(),0,NOT_TABLE);
Lex();ParseTableOrClass(_SC(','),_SC('}')); Lex();ParseTableOrClass(',','}');
break; break;
case TK_FUNCTION: FunctionExp(_token);break; case TK_FUNCTION: FunctionExp(_token);break;
case _SC('@'): FunctionExp(_token,true);break; case '@': FunctionExp(_token,true);break;
case TK_CLASS: Lex(); ClassExp();break; case TK_CLASS: Lex(); ClassExp();break;
case _SC('-'): case '-':
Lex(); Lex();
switch(_token) { switch(_token) {
case TK_INTEGER: EmitloadConstInt(-_lex._nvalue,-1); Lex(); break; case TK_INTEGER: EmitloadConstInt(-_lex._nvalue,-1); Lex(); break;
@ -868,8 +872,8 @@ public:
default: UnaryOP(_OP_NEG); default: UnaryOP(_OP_NEG);
} }
break; break;
case _SC('!'): Lex(); UnaryOP(_OP_NOT); break; case '!': Lex(); UnaryOP(_OP_NOT); break;
case _SC('~'): case '~':
Lex(); Lex();
if(_token == TK_INTEGER) { EmitloadConstInt(~_lex._nvalue,-1); Lex(); break; } if(_token == TK_INTEGER) { EmitloadConstInt(~_lex._nvalue,-1); Lex(); break; }
UnaryOP(_OP_BWNOT); UnaryOP(_OP_BWNOT);
@ -881,11 +885,11 @@ public:
case TK_MINUSMINUS : case TK_MINUSMINUS :
case TK_PLUSPLUS :PrefixIncDec(_token); break; case TK_PLUSPLUS :PrefixIncDec(_token); break;
case TK_DELETE : DeleteExpr(); break; case TK_DELETE : DeleteExpr(); break;
case _SC('('): Lex(); CommaExpr(); Expect(_SC(')')); case '(': Lex(); CommaExpr(); Expect(')');
break; break;
case TK___LINE__: EmitloadConstInt(_lex._currentline,-1); Lex(); break; case TK___LINE__: EmitloadConstInt(_lex._currentline,-1); Lex(); break;
case TK___FILE__: _fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(_sourcename)); Lex(); break; case TK___FILE__: _fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(_sourcename)); Lex(); break;
default: error(_SC("expression expected")); default: error("expression expected");
} }
_es.etype = EXPR; _es.etype = EXPR;
return -1; return -1;
@ -923,32 +927,39 @@ public:
bool Needget() bool Needget()
{ {
switch(_token) { switch(_token) {
case _SC('='): case _SC('('): case TK_NEWSLOT: case TK_MODEQ: case TK_MULEQ: case '=':
case TK_DIVEQ: case TK_MINUSEQ: case TK_PLUSEQ: case '(':
return false; case TK_NEWSLOT:
case TK_PLUSPLUS: case TK_MINUSMINUS: case TK_MODEQ:
if (!IsEndOfStatement()) { case TK_MULEQ:
case TK_DIVEQ:
case TK_MINUSEQ:
case TK_PLUSEQ:
return false; return false;
} case TK_PLUSPLUS:
break; case TK_MINUSMINUS:
if (!IsEndOfStatement()) {
return false;
}
break;
} }
return (!_es.donot_get || ( _es.donot_get && (_token == _SC('.') || _token == _SC('[')))); return (!_es.donot_get || ( _es.donot_get && (_token == '.' || _token == '[')));
} }
void FunctioncallArgs(bool rawcall = false) void FunctioncallArgs(bool rawcall = false)
{ {
int64_t nargs = 1;//this int64_t nargs = 1;//this
while(_token != _SC(')')) { while(_token != ')') {
Expression(); Expression();
MoveIfCurrentTargetisLocal(); MoveIfCurrentTargetisLocal();
nargs++; nargs++;
if(_token == _SC(',')){ if(_token == ','){
Lex(); Lex();
if(_token == ')') error(_SC("expression expected, found ')'")); if(_token == ')') error("expression expected, found ')'");
} }
} }
Lex(); Lex();
if (rawcall) { if (rawcall) {
if (nargs < 3) error(_SC("rawcall requires at least 2 parameters (callee and this)")); if (nargs < 3) error("rawcall requires at least 2 parameters (callee and this)");
nargs -= 2; //removes callee and this from count nargs -= 2; //removes callee and this from count
} }
for(int64_t i = 0; i < (nargs - 1); i++) _fs->popTarget(); for(int64_t i = 0; i < (nargs - 1); i++) _fs->popTarget();
@ -979,26 +990,26 @@ public:
case TK_CONSTRUCTOR:{ case TK_CONSTRUCTOR:{
int64_t tk = _token; int64_t tk = _token;
Lex(); Lex();
rabbit::Object id = tk == TK_FUNCTION ? Expect(TK_IDENTIFIER) : _fs->createString(_SC("constructor")); rabbit::Object id = tk == TK_FUNCTION ? Expect(TK_IDENTIFIER) : _fs->createString("constructor");
Expect(_SC('(')); Expect('(');
_fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(id)); _fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(id));
createFunction(id); createFunction(id);
_fs->addInstruction(_OP_CLOSURE, _fs->pushTarget(), _fs->_functions.size() - 1, 0); _fs->addInstruction(_OP_CLOSURE, _fs->pushTarget(), _fs->_functions.size() - 1, 0);
} }
break; break;
case _SC('['): case '[':
Lex(); CommaExpr(); Expect(_SC(']')); Lex(); CommaExpr(); Expect(']');
Expect(_SC('=')); Expression(); Expect('='); Expression();
break; break;
case TK_STRING_LITERAL: //JSON case TK_STRING_LITERAL: //JSON
if(separator == ',') { //only works for tables if(separator == ',') { //only works for tables
_fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(Expect(TK_STRING_LITERAL))); _fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(Expect(TK_STRING_LITERAL)));
Expect(_SC(':')); Expression(); Expect(':'); Expression();
break; break;
} }
default : default :
_fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(Expect(TK_IDENTIFIER))); _fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(Expect(TK_IDENTIFIER)));
Expect(_SC('=')); Expression(); Expect('='); Expression();
} }
if(_token == separator) Lex();//optional comma/semicolon if(_token == separator) Lex();//optional comma/semicolon
nkeys++; nkeys++;
@ -1009,14 +1020,14 @@ public:
assert((hasattrs && (attrs == key-1)) || !hasattrs); assert((hasattrs && (attrs == key-1)) || !hasattrs);
unsigned char flags = (hasattrs?NEW_SLOT_ATTRIBUTES_FLAG:0)|(isstatic?NEW_SLOT_STATIC_FLAG:0); unsigned char flags = (hasattrs?NEW_SLOT_ATTRIBUTES_FLAG:0)|(isstatic?NEW_SLOT_STATIC_FLAG:0);
int64_t table = _fs->topTarget(); //<<BECAUSE OF THIS NO COMMON EMIT FUNC IS POSSIBLE int64_t table = _fs->topTarget(); //<<BECAUSE OF THIS NO COMMON EMIT FUNC IS POSSIBLE
if(separator == _SC(',')) { //hack recognizes a table from the separator if(separator == ',') { //hack recognizes a table from the separator
_fs->addInstruction(_OP_NEWSLOT, 0xFF, table, key, val); _fs->addInstruction(_OP_NEWSLOT, 0xFF, table, key, val);
} }
else { else {
_fs->addInstruction(_OP_NEWSLOTA, flags, table, key, val); //this for classes only as it invokes _newmember _fs->addInstruction(_OP_NEWSLOTA, flags, table, key, val); //this for classes only as it invokes _newmember
} }
} }
if(separator == _SC(',')) //hack recognizes a table from the separator if(separator == ',') //hack recognizes a table from the separator
_fs->setIntructionParam(tpos, 1, nkeys); _fs->setIntructionParam(tpos, 1, nkeys);
Lex(); Lex();
} }
@ -1027,7 +1038,7 @@ public:
if( _token == TK_FUNCTION) { if( _token == TK_FUNCTION) {
Lex(); Lex();
varname = Expect(TK_IDENTIFIER); varname = Expect(TK_IDENTIFIER);
Expect(_SC('(')); Expect('(');
createFunction(varname,false); createFunction(varname,false);
_fs->addInstruction(_OP_CLOSURE, _fs->pushTarget(), _fs->_functions.size() - 1, 0); _fs->addInstruction(_OP_CLOSURE, _fs->pushTarget(), _fs->_functions.size() - 1, 0);
_fs->popTarget(); _fs->popTarget();
@ -1037,7 +1048,7 @@ public:
do { do {
varname = Expect(TK_IDENTIFIER); varname = Expect(TK_IDENTIFIER);
if(_token == _SC('=')) { if(_token == '=') {
Lex(); Expression(); Lex(); Expression();
int64_t src = _fs->popTarget(); int64_t src = _fs->popTarget();
int64_t dest = _fs->pushTarget(); int64_t dest = _fs->pushTarget();
@ -1048,17 +1059,17 @@ public:
} }
_fs->popTarget(); _fs->popTarget();
_fs->pushLocalVariable(varname); _fs->pushLocalVariable(varname);
if(_token == _SC(',')) Lex(); else break; if(_token == ',') Lex(); else break;
} while(1); } while(1);
} }
void IfBlock() void IfBlock()
{ {
if (_token == _SC('{')) if (_token == '{')
{ {
BEGIN_SCOPE(); BEGIN_SCOPE();
Lex(); Lex();
Statements(); Statements();
Expect(_SC('}')); Expect('}');
if (true) { if (true) {
END_SCOPE(); END_SCOPE();
} }
@ -1069,7 +1080,7 @@ public:
else { else {
//BEGIN_SCOPE(); //BEGIN_SCOPE();
Statement(); Statement();
if (_lex._prevtoken != _SC('}') && _lex._prevtoken != _SC(';')) OptionalSemicolon(); if (_lex._prevtoken != '}' && _lex._prevtoken != ';') OptionalSemicolon();
//END_SCOPE(); //END_SCOPE();
} }
} }
@ -1077,7 +1088,7 @@ public:
{ {
int64_t jmppos; int64_t jmppos;
bool haselse = false; bool haselse = false;
Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')')); Lex(); Expect('('); CommaExpr(); Expect(')');
_fs->addInstruction(_OP_JZ, _fs->popTarget()); _fs->addInstruction(_OP_JZ, _fs->popTarget());
int64_t jnepos = _fs->getCurrentPos(); int64_t jnepos = _fs->getCurrentPos();
@ -1086,7 +1097,7 @@ public:
IfBlock(); IfBlock();
// //
/*static int n = 0; /*static int n = 0;
if (_token != _SC('}') && _token != TK_ELSE) { if (_token != '}' && _token != TK_ELSE) {
printf("IF %d-----------------------!!!!!!!!!\n", n); printf("IF %d-----------------------!!!!!!!!!\n", n);
if (n == 5) if (n == 5)
{ {
@ -1104,7 +1115,7 @@ public:
_fs->addInstruction(_OP_JMP); _fs->addInstruction(_OP_JMP);
jmppos = _fs->getCurrentPos(); jmppos = _fs->getCurrentPos();
Lex(); Lex();
//Statement(); if(_lex._prevtoken != _SC('}')) OptionalSemicolon(); //Statement(); if(_lex._prevtoken != '}') OptionalSemicolon();
IfBlock(); IfBlock();
//END_SCOPE(); //END_SCOPE();
_fs->setIntructionParam(jmppos, 1, _fs->getCurrentPos() - jmppos); _fs->setIntructionParam(jmppos, 1, _fs->getCurrentPos() - jmppos);
@ -1115,7 +1126,7 @@ public:
{ {
int64_t jzpos, jmppos; int64_t jzpos, jmppos;
jmppos = _fs->getCurrentPos(); jmppos = _fs->getCurrentPos();
Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')')); Lex(); Expect('('); CommaExpr(); Expect(')');
BEGIN_BREAKBLE_BLOCK(); BEGIN_BREAKBLE_BLOCK();
_fs->addInstruction(_OP_JZ, _fs->popTarget()); _fs->addInstruction(_OP_JZ, _fs->popTarget());
@ -1140,7 +1151,7 @@ public:
END_SCOPE(); END_SCOPE();
Expect(TK_WHILE); Expect(TK_WHILE);
int64_t continuetrg = _fs->getCurrentPos(); int64_t continuetrg = _fs->getCurrentPos();
Expect(_SC('(')); CommaExpr(); Expect(_SC(')')); Expect('('); CommaExpr(); Expect(')');
_fs->addInstruction(_OP_JZ, _fs->popTarget(), 1); _fs->addInstruction(_OP_JZ, _fs->popTarget(), 1);
_fs->addInstruction(_OP_JMP, 0, jmptrg - _fs->getCurrentPos() - 1); _fs->addInstruction(_OP_JMP, 0, jmptrg - _fs->getCurrentPos() - 1);
END_BREAKBLE_BLOCK(continuetrg); END_BREAKBLE_BLOCK(continuetrg);
@ -1149,25 +1160,25 @@ public:
{ {
Lex(); Lex();
BEGIN_SCOPE(); BEGIN_SCOPE();
Expect(_SC('(')); Expect('(');
if(_token == TK_LOCAL) LocalDeclStatement(); if(_token == TK_LOCAL) LocalDeclStatement();
else if(_token != _SC(';')){ else if(_token != ';'){
CommaExpr(); CommaExpr();
_fs->popTarget(); _fs->popTarget();
} }
Expect(_SC(';')); Expect(';');
_fs->snoozeOpt(); _fs->snoozeOpt();
int64_t jmppos = _fs->getCurrentPos(); int64_t jmppos = _fs->getCurrentPos();
int64_t jzpos = -1; int64_t jzpos = -1;
if(_token != _SC(';')) { CommaExpr(); _fs->addInstruction(_OP_JZ, _fs->popTarget()); jzpos = _fs->getCurrentPos(); } if(_token != ';') { CommaExpr(); _fs->addInstruction(_OP_JZ, _fs->popTarget()); jzpos = _fs->getCurrentPos(); }
Expect(_SC(';')); Expect(';');
_fs->snoozeOpt(); _fs->snoozeOpt();
int64_t expstart = _fs->getCurrentPos() + 1; int64_t expstart = _fs->getCurrentPos() + 1;
if(_token != _SC(')')) { if(_token != ')') {
CommaExpr(); CommaExpr();
_fs->popTarget(); _fs->popTarget();
} }
Expect(_SC(')')); Expect(')');
_fs->snoozeOpt(); _fs->snoozeOpt();
int64_t expend = _fs->getCurrentPos(); int64_t expend = _fs->getCurrentPos();
int64_t expsize = (expend - expstart) + 1; int64_t expsize = (expend - expstart) + 1;
@ -1194,20 +1205,20 @@ public:
void ForEachStatement() void ForEachStatement()
{ {
rabbit::Object idxname, valname; rabbit::Object idxname, valname;
Lex(); Expect(_SC('(')); valname = Expect(TK_IDENTIFIER); Lex(); Expect('('); valname = Expect(TK_IDENTIFIER);
if(_token == _SC(',')) { if(_token == ',') {
idxname = valname; idxname = valname;
Lex(); valname = Expect(TK_IDENTIFIER); Lex(); valname = Expect(TK_IDENTIFIER);
} }
else{ else{
idxname = _fs->createString(_SC("@INDEX@")); idxname = _fs->createString("@INDEX@");
} }
Expect(TK_IN); Expect(TK_IN);
//save the stack size //save the stack size
BEGIN_SCOPE(); BEGIN_SCOPE();
//put the table in the stack(evaluate the table expression) //put the table in the stack(evaluate the table expression)
Expression(); Expect(_SC(')')); Expression(); Expect(')');
int64_t container = _fs->topTarget(); int64_t container = _fs->topTarget();
//push the index local var //push the index local var
int64_t indexpos = _fs->pushLocalVariable(idxname); int64_t indexpos = _fs->pushLocalVariable(idxname);
@ -1216,7 +1227,7 @@ public:
int64_t valuepos = _fs->pushLocalVariable(valname); int64_t valuepos = _fs->pushLocalVariable(valname);
_fs->addInstruction(_OP_LOADNULLS, valuepos,1); _fs->addInstruction(_OP_LOADNULLS, valuepos,1);
//push reference index //push reference index
int64_t itrpos = _fs->pushLocalVariable(_fs->createString(_SC("@ITERATOR@"))); //use invalid id to make it inaccessible int64_t itrpos = _fs->pushLocalVariable(_fs->createString("@ITERATOR@")); //use invalid id to make it inaccessible
_fs->addInstruction(_OP_LOADNULLS, itrpos,1); _fs->addInstruction(_OP_LOADNULLS, itrpos,1);
int64_t jmppos = _fs->getCurrentPos(); int64_t jmppos = _fs->getCurrentPos();
_fs->addInstruction(_OP_FOREACH, container, 0, indexpos); _fs->addInstruction(_OP_FOREACH, container, 0, indexpos);
@ -1235,8 +1246,8 @@ public:
} }
void SwitchStatement() void SwitchStatement()
{ {
Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')')); Lex(); Expect('('); CommaExpr(); Expect(')');
Expect(_SC('{')); Expect('{');
int64_t expr = _fs->topTarget(); int64_t expr = _fs->topTarget();
bool bfirst = true; bool bfirst = true;
int64_t tonextcondjmp = -1; int64_t tonextcondjmp = -1;
@ -1250,7 +1261,7 @@ public:
_fs->setIntructionParam(tonextcondjmp, 1, _fs->getCurrentPos() - tonextcondjmp); _fs->setIntructionParam(tonextcondjmp, 1, _fs->getCurrentPos() - tonextcondjmp);
} }
//condition //condition
Lex(); Expression(); Expect(_SC(':')); Lex(); Expression(); Expect(':');
int64_t trg = _fs->popTarget(); int64_t trg = _fs->popTarget();
int64_t eqtarget = trg; int64_t eqtarget = trg;
bool local = _fs->isLocal(trg); bool local = _fs->isLocal(trg);
@ -1276,12 +1287,12 @@ public:
if(tonextcondjmp != -1) if(tonextcondjmp != -1)
_fs->setIntructionParam(tonextcondjmp, 1, _fs->getCurrentPos() - tonextcondjmp); _fs->setIntructionParam(tonextcondjmp, 1, _fs->getCurrentPos() - tonextcondjmp);
if(_token == TK_DEFAULT) { if(_token == TK_DEFAULT) {
Lex(); Expect(_SC(':')); Lex(); Expect(':');
BEGIN_SCOPE(); BEGIN_SCOPE();
Statements(); Statements();
END_SCOPE(); END_SCOPE();
} }
Expect(_SC('}')); Expect('}');
_fs->popTarget(); _fs->popTarget();
__nbreaks__ = _fs->_unresolvedbreaks.size() - __nbreaks__; __nbreaks__ = _fs->_unresolvedbreaks.size() - __nbreaks__;
if(__nbreaks__ > 0)ResolveBreaks(_fs, __nbreaks__); if(__nbreaks__ > 0)ResolveBreaks(_fs, __nbreaks__);
@ -1301,7 +1312,7 @@ public:
_fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(id)); _fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(id));
if(_token == TK_DOUBLE_COLON) Emit2ArgsOP(_OP_GET); if(_token == TK_DOUBLE_COLON) Emit2ArgsOP(_OP_GET);
} }
Expect(_SC('(')); Expect('(');
createFunction(id); createFunction(id);
_fs->addInstruction(_OP_CLOSURE, _fs->pushTarget(), _fs->_functions.size() - 1, 0); _fs->addInstruction(_OP_CLOSURE, _fs->pushTarget(), _fs->_functions.size() - 1, 0);
EmitDerefOp(_OP_NEWSLOT); EmitDerefOp(_OP_NEWSLOT);
@ -1315,7 +1326,7 @@ public:
_es.donot_get = true; _es.donot_get = true;
PrefixedExpr(); PrefixedExpr();
if(_es.etype == EXPR) { if(_es.etype == EXPR) {
error(_SC("invalid class name")); error("invalid class name");
} }
else if(_es.etype == OBJECT || _es.etype == BASE) { else if(_es.etype == OBJECT || _es.etype == BASE) {
ClassExp(); ClassExp();
@ -1323,7 +1334,7 @@ public:
_fs->popTarget(); _fs->popTarget();
} }
else { else {
error(_SC("cannot create a class in a local with the syntax(class <local>)")); error("cannot create a class in a local with the syntax(class <local>)");
} }
_es = es; _es = es;
} }
@ -1361,11 +1372,11 @@ public:
val._unVal.fFloat = -_lex._fvalue; val._unVal.fFloat = -_lex._fvalue;
break; break;
default: default:
error(_SC("scalar expected : integer, float")); error("scalar expected : integer, float");
} }
break; break;
default: default:
error(_SC("scalar expected : integer, float, or string")); error("scalar expected : integer, float, or string");
} }
Lex(); Lex();
return val; return val;
@ -1374,14 +1385,14 @@ public:
{ {
Lex(); Lex();
rabbit::Object id = Expect(TK_IDENTIFIER); rabbit::Object id = Expect(TK_IDENTIFIER);
Expect(_SC('{')); Expect('{');
rabbit::Object table = _fs->createTable(); rabbit::Object table = _fs->createTable();
int64_t nval = 0; int64_t nval = 0;
while(_token != _SC('}')) { while(_token != '}') {
rabbit::Object key = Expect(TK_IDENTIFIER); rabbit::Object key = Expect(TK_IDENTIFIER);
rabbit::Object val; rabbit::Object val;
if(_token == _SC('=')) { if(_token == '=') {
Lex(); Lex();
val = ExpectScalar(); val = ExpectScalar();
} }
@ -1419,7 +1430,7 @@ public:
_fs->addInstruction(_OP_JMP, 0, 0); _fs->addInstruction(_OP_JMP, 0, 0);
int64_t jmppos = _fs->getCurrentPos(); int64_t jmppos = _fs->getCurrentPos();
_fs->setIntructionParam(trappos, 1, (_fs->getCurrentPos() - trappos)); _fs->setIntructionParam(trappos, 1, (_fs->getCurrentPos() - trappos));
Expect(TK_CATCH); Expect(_SC('(')); exid = Expect(TK_IDENTIFIER); Expect(_SC(')')); Expect(TK_CATCH); Expect('('); exid = Expect(TK_IDENTIFIER); Expect(')');
{ {
BEGIN_SCOPE(); BEGIN_SCOPE();
int64_t ex_target = _fs->pushLocalVariable(exid); int64_t ex_target = _fs->pushLocalVariable(exid);
@ -1431,7 +1442,7 @@ public:
} }
void FunctionExp(int64_t ftype,bool lambda = false) void FunctionExp(int64_t ftype,bool lambda = false)
{ {
Lex(); Expect(_SC('(')); Lex(); Expect('(');
rabbit::ObjectPtr 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);
@ -1447,14 +1458,14 @@ public:
if(_token == TK_ATTR_OPEN) { if(_token == TK_ATTR_OPEN) {
Lex(); Lex();
_fs->addInstruction(_OP_NEWOBJ, _fs->pushTarget(),0,NOT_TABLE); _fs->addInstruction(_OP_NEWOBJ, _fs->pushTarget(),0,NOT_TABLE);
ParseTableOrClass(_SC(','),TK_ATTR_CLOSE); ParseTableOrClass(',',TK_ATTR_CLOSE);
attrs = _fs->topTarget(); attrs = _fs->topTarget();
} }
Expect(_SC('{')); Expect('{');
if(attrs != -1) _fs->popTarget(); if(attrs != -1) _fs->popTarget();
if(base != -1) _fs->popTarget(); if(base != -1) _fs->popTarget();
_fs->addInstruction(_OP_NEWOBJ, _fs->pushTarget(), base, attrs,NOT_CLASS); _fs->addInstruction(_OP_NEWOBJ, _fs->pushTarget(), base, attrs,NOT_CLASS);
ParseTableOrClass(_SC(';'),_SC('}')); ParseTableOrClass(';','}');
} }
void DeleteExpr() void DeleteExpr()
{ {
@ -1463,12 +1474,12 @@ public:
es = _es; es = _es;
_es.donot_get = true; _es.donot_get = true;
PrefixedExpr(); PrefixedExpr();
if(_es.etype==EXPR) error(_SC("can't delete an expression")); if(_es.etype==EXPR) error("can't delete an expression");
if(_es.etype==OBJECT || _es.etype==BASE) { if(_es.etype==OBJECT || _es.etype==BASE) {
Emit2ArgsOP(_OP_DELETE); Emit2ArgsOP(_OP_DELETE);
} }
else { else {
error(_SC("cannot delete an (outer) local")); error("cannot delete an (outer) local");
} }
_es = es; _es = es;
} }
@ -1481,7 +1492,7 @@ public:
_es.donot_get = true; _es.donot_get = true;
PrefixedExpr(); PrefixedExpr();
if(_es.etype==EXPR) { if(_es.etype==EXPR) {
error(_SC("can't '++' or '--' an expression")); error("can't '++' or '--' an expression");
} }
else if(_es.etype==OBJECT || _es.etype==BASE) { else if(_es.etype==OBJECT || _es.etype==BASE) {
Emit2ArgsOP(_OP_INC, diff); Emit2ArgsOP(_OP_INC, diff);
@ -1504,35 +1515,35 @@ public:
FuncState *funcstate = _fs->pushChildState(_get_shared_state(_vm)); FuncState *funcstate = _fs->pushChildState(_get_shared_state(_vm));
funcstate->_name = name; funcstate->_name = name;
rabbit::Object paramname; rabbit::Object paramname;
funcstate->addParameter(_fs->createString(_SC("this"))); funcstate->addParameter(_fs->createString("this"));
funcstate->_sourcename = _sourcename; funcstate->_sourcename = _sourcename;
int64_t defparams = 0; int64_t defparams = 0;
while(_token!=_SC(')')) { while(_token!=')') {
if(_token == TK_VARPARAMS) { if(_token == TK_VARPARAMS) {
if(defparams > 0) error(_SC("function with default parameters cannot have variable number of parameters")); if(defparams > 0) error("function with default parameters cannot have variable number of parameters");
funcstate->addParameter(_fs->createString(_SC("vargv"))); funcstate->addParameter(_fs->createString("vargv"));
funcstate->_varparams = true; funcstate->_varparams = true;
Lex(); Lex();
if(_token != _SC(')')) error(_SC("expected ')'")); if(_token != ')') error("expected ')'");
break; break;
} }
else { else {
paramname = Expect(TK_IDENTIFIER); paramname = Expect(TK_IDENTIFIER);
funcstate->addParameter(paramname); funcstate->addParameter(paramname);
if(_token == _SC('=')) { if(_token == '=') {
Lex(); Lex();
Expression(); Expression();
funcstate->addDefaultParam(_fs->topTarget()); funcstate->addDefaultParam(_fs->topTarget());
defparams++; defparams++;
} }
else { else {
if(defparams > 0) error(_SC("expected '='")); if(defparams > 0) error("expected '='");
} }
if(_token == _SC(',')) Lex(); if(_token == ',') Lex();
else if(_token != _SC(')')) error(_SC("expected ')' or ','")); else if(_token != ')') error("expected ')' or ','");
} }
} }
Expect(_SC(')')); Expect(')');
for(int64_t n = 0; n < defparams; n++) { for(int64_t n = 0; n < defparams; n++) {
_fs->popTarget(); _fs->popTarget();
} }
@ -1545,7 +1556,7 @@ public:
else { else {
Statement(false); Statement(false);
} }
funcstate->addLineInfos(_lex._prevtoken == _SC('\n')?_lex._lasttokenline:_lex._currentline, _lineinfo, true); funcstate->addLineInfos(_lex._prevtoken == '\n'?_lex._lasttokenline:_lex._currentline, _lineinfo, true);
funcstate->addInstruction(_OP_RETURN, -1); funcstate->addInstruction(_OP_RETURN, -1);
funcstate->setStacksize(0); funcstate->setStacksize(0);

192
rabbit/FuncState.cpp
View File

@ -25,67 +25,67 @@
#ifdef _DEBUG_DUMP #ifdef _DEBUG_DUMP
rabbit::InstructionDesc g_InstrDesc[]={ rabbit::InstructionDesc g_InstrDesc[]={
{_SC("_OP_LINE")}, {"_OP_LINE"},
{_SC("_OP_LOAD")}, {"_OP_LOAD"},
{_SC("_OP_LOADINT")}, {"_OP_LOADINT"},
{_SC("_OP_LOADFLOAT")}, {"_OP_LOADFLOAT"},
{_SC("_OP_DLOAD")}, {"_OP_DLOAD"},
{_SC("_OP_TAILCALL")}, {"_OP_TAILCALL"},
{_SC("_OP_CALL")}, {"_OP_CALL"},
{_SC("_OP_PREPCALL")}, {"_OP_PREPCALL"},
{_SC("_OP_PREPCALLK")}, {"_OP_PREPCALLK"},
{_SC("_OP_GETK")}, {"_OP_GETK"},
{_SC("_OP_MOVE")}, {"_OP_MOVE"},
{_SC("_OP_NEWSLOT")}, {"_OP_NEWSLOT"},
{_SC("_OP_DELETE")}, {"_OP_DELETE"},
{_SC("_OP_SET")}, {"_OP_SET"},
{_SC("_OP_GET")}, {"_OP_GET"},
{_SC("_OP_EQ")}, {"_OP_EQ"},
{_SC("_OP_NE")}, {"_OP_NE"},
{_SC("_OP_ADD")}, {"_OP_ADD"},
{_SC("_OP_SUB")}, {"_OP_SUB"},
{_SC("_OP_MUL")}, {"_OP_MUL"},
{_SC("_OP_DIV")}, {"_OP_DIV"},
{_SC("_OP_MOD")}, {"_OP_MOD"},
{_SC("_OP_BITW")}, {"_OP_BITW"},
{_SC("_OP_RETURN")}, {"_OP_RETURN"},
{_SC("_OP_LOADNULLS")}, {"_OP_LOADNULLS"},
{_SC("_OP_LOADROOT")}, {"_OP_LOADROOT"},
{_SC("_OP_LOADBOOL")}, {"_OP_LOADBOOL"},
{_SC("_OP_DMOVE")}, {"_OP_DMOVE"},
{_SC("_OP_JMP")}, {"_OP_JMP"},
{_SC("_OP_JCMP")}, {"_OP_JCMP"},
{_SC("_OP_JZ")}, {"_OP_JZ"},
{_SC("_OP_SETOUTER")}, {"_OP_SETOUTER"},
{_SC("_OP_GETOUTER")}, {"_OP_GETOUTER"},
{_SC("_OP_NEWOBJ")}, {"_OP_NEWOBJ"},
{_SC("_OP_APPENDARRAY")}, {"_OP_APPENDARRAY"},
{_SC("_OP_COMPARITH")}, {"_OP_COMPARITH"},
{_SC("_OP_INC")}, {"_OP_INC"},
{_SC("_OP_INCL")}, {"_OP_INCL"},
{_SC("_OP_PINC")}, {"_OP_PINC"},
{_SC("_OP_PINCL")}, {"_OP_PINCL"},
{_SC("_OP_CMP")}, {"_OP_CMP"},
{_SC("_OP_EXISTS")}, {"_OP_EXISTS"},
{_SC("_OP_INSTANCEOF")}, {"_OP_INSTANCEOF"},
{_SC("_OP_AND")}, {"_OP_AND"},
{_SC("_OP_OR")}, {"_OP_OR"},
{_SC("_OP_NEG")}, {"_OP_NEG"},
{_SC("_OP_NOT")}, {"_OP_NOT"},
{_SC("_OP_BWNOT")}, {"_OP_BWNOT"},
{_SC("_OP_CLOSURE")}, {"_OP_CLOSURE"},
{_SC("_OP_YIELD")}, {"_OP_YIELD"},
{_SC("_OP_RESUME")}, {"_OP_RESUME"},
{_SC("_OP_FOREACH")}, {"_OP_FOREACH"},
{_SC("_OP_POSTFOREACH")}, {"_OP_POSTFOREACH"},
{_SC("_OP_CLONE")}, {"_OP_CLONE"},
{_SC("_OP_TYPEOF")}, {"_OP_TYPEOF"},
{_SC("_OP_PUSHTRAP")}, {"_OP_PUSHTRAP"},
{_SC("_OP_POPTRAP")}, {"_OP_POPTRAP"},
{_SC("_OP_THROW")}, {"_OP_THROW"},
{_SC("_OP_NEWSLOTA")}, {"_OP_NEWSLOTA"},
{_SC("_OP_GETBASE")}, {"_OP_GETBASE"},
{_SC("_OP_CLOSE")}, {"_OP_CLOSE"},
}; };
#endif #endif
@ -97,11 +97,11 @@ void rabbit::FuncState::addInstruction(SQOpcode _op,int64_t arg0,int64_t arg1,in
static void dumpLiteral(rabbit::ObjectPtr &o) { static void dumpLiteral(rabbit::ObjectPtr &o) {
switch(sq_type(o)){ switch(sq_type(o)){
case rabbit::OT_STRING: printf(_SC("\"%s\""),_stringval(o));break; case rabbit::OT_STRING: printf("\"%s\"",_stringval(o));break;
case rabbit::OT_FLOAT: printf(_SC("{%f}"),_float(o));break; case rabbit::OT_FLOAT: printf("{%f}",_float(o));break;
case rabbit::OT_INTEGER: printf(_SC("{") _PRINT_INT_FMT _SC("}"),_integer(o));break; case rabbit::OT_INTEGER: printf("{" _PRINT_INT_FMT "}",_integer(o));break;
case rabbit::OT_BOOL: printf(_SC("%s"),_integer(o)?_SC("true"):_SC("false"));break; case rabbit::OT_BOOL: printf("%s",_integer(o)?"true":"false");break;
default: printf(_SC("(%s %p)"),getTypeName(o),(void*)_rawval(o));break; break; //shut up compiler default: printf("(%s %p)",getTypeName(o),(void*)_rawval(o));break; break; //shut up compiler
} }
} }
@ -136,11 +136,11 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
{ {
uint64_t n=0,i; uint64_t n=0,i;
int64_t si; int64_t si;
printf(_SC("rabbit::Instruction sizeof %d\n"),(int32_t)sizeof(rabbit::Instruction)); printf("rabbit::Instruction sizeof %d\n",(int32_t)sizeof(rabbit::Instruction));
printf(_SC("rabbit::Object sizeof %d\n"), (int32_t)sizeof(rabbit::Object)); printf("rabbit::Object sizeof %d\n", (int32_t)sizeof(rabbit::Object));
printf(_SC("--------------------------------------------------------------------\n")); printf("--------------------------------------------------------------------\n");
printf(_SC("*****FUNCTION [%s]\n"),sq_type(func->_name)==rabbit::OT_STRING?_stringval(func->_name):_SC("unknown")); printf("*****FUNCTION [%s]\n",sq_type(func->_name)==rabbit::OT_STRING?_stringval(func->_name):"unknown");
printf(_SC("-----LITERALS\n")); printf("-----LITERALS\n");
rabbit::ObjectPtr refidx,key,val; rabbit::ObjectPtr refidx,key,val;
int64_t idx; int64_t idx;
etk::Vector<rabbit::ObjectPtr> templiterals; etk::Vector<rabbit::ObjectPtr> templiterals;
@ -150,43 +150,43 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
templiterals[_integer(val)]=key; templiterals[_integer(val)]=key;
} }
for(i=0;i<templiterals.size();i++){ for(i=0;i<templiterals.size();i++){
printf(_SC("[%d] "), (int32_t)n); printf("[%d] ", (int32_t)n);
dumpLiteral(templiterals[i]); dumpLiteral(templiterals[i]);
printf(_SC("\n")); printf("\n");
n++; n++;
} }
printf(_SC("-----PARAMS\n")); printf("-----PARAMS\n");
if(_varparams) if(_varparams)
printf(_SC("<<VARPARAMS>>\n")); printf("<<VARPARAMS>>\n");
n=0; n=0;
for(i=0;i<_parameters.size();i++){ for(i=0;i<_parameters.size();i++){
printf(_SC("[%d] "), (int32_t)n); printf("[%d] ", (int32_t)n);
dumpLiteral(_parameters[i]); dumpLiteral(_parameters[i]);
printf(_SC("\n")); printf("\n");
n++; n++;
} }
printf(_SC("-----LOCALS\n")); printf("-----LOCALS\n");
for(si=0;si<func->_nlocalvarinfos;si++){ for(si=0;si<func->_nlocalvarinfos;si++){
rabbit::LocalVarInfo lvi=func->_localvarinfos[si]; rabbit::LocalVarInfo lvi=func->_localvarinfos[si];
printf(_SC("[%d] %s \t%d %d\n"), (int32_t)lvi._pos,_stringval(lvi._name), (int32_t)lvi._start_op, (int32_t)lvi._end_op); printf("[%d] %s \t%d %d\n", (int32_t)lvi._pos,_stringval(lvi._name), (int32_t)lvi._start_op, (int32_t)lvi._end_op);
n++; n++;
} }
printf(_SC("-----LINE INFO\n")); printf("-----LINE INFO\n");
for(i=0;i<_lineinfos.size();i++){ for(i=0;i<_lineinfos.size();i++){
rabbit::LineInfo li=_lineinfos[i]; rabbit::LineInfo li=_lineinfos[i];
printf(_SC("op [%d] line [%d] \n"), (int32_t)li._op, (int32_t)li._line); printf("op [%d] line [%d] \n", (int32_t)li._op, (int32_t)li._line);
n++; n++;
} }
printf(_SC("-----dump\n")); printf("-----dump\n");
n=0; n=0;
for(i=0;i<_instructions.size();i++){ for(i=0;i<_instructions.size();i++){
rabbit::Instruction &inst=_instructions[i]; rabbit::Instruction &inst=_instructions[i];
if(inst.op==_OP_LOAD || inst.op==_OP_DLOAD || inst.op==_OP_PREPCALLK || inst.op==_OP_GETK ){ if(inst.op==_OP_LOAD || inst.op==_OP_DLOAD || inst.op==_OP_PREPCALLK || inst.op==_OP_GETK ){
int64_t lidx = inst._arg1; int64_t lidx = inst._arg1;
printf(_SC("[%03d] %15s %d "), (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0); printf("[%03d] %15s %d ", (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0);
if(lidx >= 0xFFFFFFFF) if(lidx >= 0xFFFFFFFF)
printf(_SC("null")); printf("null");
else { else {
int64_t refidx; int64_t refidx;
rabbit::ObjectPtr val,key,refo; rabbit::ObjectPtr val,key,refo;
@ -196,13 +196,13 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
dumpLiteral(key); dumpLiteral(key);
} }
if(inst.op != _OP_DLOAD) { if(inst.op != _OP_DLOAD) {
printf(_SC(" %d %d \n"),inst._arg2,inst._arg3); printf(" %d %d \n",inst._arg2,inst._arg3);
} }
else { else {
printf(_SC(" %d "),inst._arg2); printf(" %d ",inst._arg2);
lidx = inst._arg3; lidx = inst._arg3;
if(lidx >= 0xFFFFFFFF) if(lidx >= 0xFFFFFFFF)
printf(_SC("null")); printf("null");
else { else {
int64_t refidx; int64_t refidx;
rabbit::ObjectPtr val,key,refo; rabbit::ObjectPtr val,key,refo;
@ -210,24 +210,24 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
refo = refidx; refo = refidx;
} }
dumpLiteral(key); dumpLiteral(key);
printf(_SC("\n")); printf("\n");
} }
} }
} }
else if(inst.op==_OP_LOADFLOAT) { else if(inst.op==_OP_LOADFLOAT) {
printf(_SC("[%03d] %15s %d %f %d %d\n"), (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0,*((float_t*)&inst._arg1),inst._arg2,inst._arg3); printf("[%03d] %15s %d %f %d %d\n", (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0,*((float_t*)&inst._arg1),inst._arg2,inst._arg3);
} }
/* else if(inst.op==_OP_ARITH){ /* else if(inst.op==_OP_ARITH){
printf(_SC("[%03d] %15s %d %d %d %c\n"),n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3); printf("[%03d] %15s %d %d %d %c\n",n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3);
}*/ }*/
else { else {
printf(_SC("[%03d] %15s %d %d %d %d\n"), (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3); printf("[%03d] %15s %d %d %d %d\n", (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3);
} }
n++; n++;
} }
printf(_SC("-----\n")); printf("-----\n");
printf(_SC("stack size[%d]\n"), (int32_t)func->_stacksize); printf("stack size[%d]\n", (int32_t)func->_stacksize);
printf(_SC("--------------------------------------------------------------------\n\n")); printf("--------------------------------------------------------------------\n\n");
} }
#endif #endif
@ -251,7 +251,7 @@ int64_t rabbit::FuncState::getConstant(const rabbit::Object &cons)
_nliterals++; _nliterals++;
if(_nliterals > MAX_LITERALS) { if(_nliterals > MAX_LITERALS) {
val.Null(); val.Null();
error(_SC("internal compiler error: too many literals")); error("internal compiler error: too many literals");
} }
} }
return _integer(val); return _integer(val);
@ -280,7 +280,7 @@ int64_t rabbit::FuncState::allocStackPos()
int64_t npos=_vlocals.size(); int64_t npos=_vlocals.size();
_vlocals.pushBack(rabbit::LocalVarInfo()); _vlocals.pushBack(rabbit::LocalVarInfo());
if(_vlocals.size()>((uint64_t)_stacksize)) { if(_vlocals.size()>((uint64_t)_stacksize)) {
if(_stacksize>MAX_FUNC_STACKSIZE) error(_SC("internal compiler error: too many locals")); if(_stacksize>MAX_FUNC_STACKSIZE) error("internal compiler error: too many locals");
_stacksize=_vlocals.size(); _stacksize=_vlocals.size();
} }
return npos; return npos;

10
rabbit/Generator.cpp
View File

@ -16,8 +16,8 @@
bool rabbit::Generator::yield(rabbit::VirtualMachine *v,int64_t target) bool rabbit::Generator::yield(rabbit::VirtualMachine *v,int64_t target)
{ {
if(_state==eSuspended) { v->raise_error(_SC("internal vm error, yielding dead generator")); return false;} if(_state==eSuspended) { v->raise_error("internal vm error, yielding dead generator"); return false;}
if(_state==eDead) { v->raise_error(_SC("internal vm error, yielding a dead generator")); return false; } if(_state==eDead) { v->raise_error("internal vm error, yielding a dead generator"); return false; }
int64_t size = v->_top-v->_stackbase; int64_t size = v->_top-v->_stackbase;
_stack.resize(size); _stack.resize(size);
@ -47,8 +47,8 @@ bool rabbit::Generator::yield(rabbit::VirtualMachine *v,int64_t target)
bool rabbit::Generator::resume(rabbit::VirtualMachine *v,rabbit::ObjectPtr &dest) bool rabbit::Generator::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("resuming dead generator"); return false; }
if(_state==eRunning){ v->raise_error(_SC("resuming active generator")); return false; } if(_state==eRunning){ v->raise_error("resuming active generator"); return false; }
int64_t size = _stack.size(); int64_t size = _stack.size();
int64_t target = &dest - &(v->_stack[v->_stackbase]); int64_t target = &dest - &(v->_stack[v->_stackbase]);
assert(target>=0 && target<=255); assert(target>=0 && target<=255);
@ -83,7 +83,7 @@ bool rabbit::Generator::resume(rabbit::VirtualMachine *v,rabbit::ObjectPtr &dest
_state=eRunning; _state=eRunning;
if (v->_debughook) if (v->_debughook)
v->callDebugHook(_SC('c')); v->callDebugHook('c');
return true; return true;
} }

182
rabbit/Lexer.cpp
View File

@ -17,8 +17,8 @@
#define NEXT() {next();_currentcolumn++;} #define NEXT() {next();_currentcolumn++;}
#define INIT_TEMP_STRING() { _longstr.resize(0);} #define INIT_TEMP_STRING() { _longstr.resize(0);}
#define APPEND_CHAR(c) { _longstr.pushBack(c);} #define APPEND_CHAR(c) { _longstr.pushBack(c);}
#define TERMINATE_BUFFER() {_longstr.pushBack(_SC('\0'));} #define TERMINATE_BUFFER() {_longstr.pushBack('\0');}
#define ADD_KEYWORD(key,id) _keywords->newSlot( rabbit::String::create(ss, _SC(#key)) ,int64_t(id)) #define ADD_KEYWORD(key,id) _keywords->newSlot( rabbit::String::create(ss, #key) ,int64_t(id))
rabbit::Lexer::Lexer(){} rabbit::Lexer::Lexer(){}
rabbit::Lexer::~Lexer() rabbit::Lexer::~Lexer()
@ -89,7 +89,7 @@ void rabbit::Lexer::error(const char *err)
void rabbit::Lexer::next() void rabbit::Lexer::next()
{ {
int64_t t = _readf(_up); int64_t t = _readf(_up);
if(t > UINT8_MAX) error(_SC("Invalid character")); if(t > UINT8_MAX) error("Invalid character");
if(t != 0) { if(t != 0) {
_currdata = (Lexchar)t; _currdata = (Lexchar)t;
return; return;
@ -115,16 +115,16 @@ void rabbit::Lexer::lexBlockComment()
bool done = false; bool done = false;
while(!done) { while(!done) {
switch(CUR_CHAR) { switch(CUR_CHAR) {
case _SC('*'): { NEXT(); if(CUR_CHAR == _SC('/')) { done = true; NEXT(); }}; continue; case '*': { NEXT(); if(CUR_CHAR == '/') { done = true; NEXT(); }}; continue;
case _SC('\n'): _currentline++; NEXT(); continue; case '\n': _currentline++; NEXT(); continue;
case RABBIT_EOB: error(_SC("missing \"*/\" in comment")); case RABBIT_EOB: error("missing \"*/\" in comment");
default: NEXT(); default: NEXT();
} }
} }
} }
void rabbit::Lexer::lexLineComment() void rabbit::Lexer::lexLineComment()
{ {
do { NEXT(); } while (CUR_CHAR != _SC('\n') && (!IS_EOB())); do { NEXT(); } while (CUR_CHAR != '\n' && (!IS_EOB()));
} }
int64_t rabbit::Lexer::Lex() int64_t rabbit::Lexer::Lex()
@ -132,131 +132,131 @@ int64_t rabbit::Lexer::Lex()
_lasttokenline = _currentline; _lasttokenline = _currentline;
while(CUR_CHAR != RABBIT_EOB) { while(CUR_CHAR != RABBIT_EOB) {
switch(CUR_CHAR){ switch(CUR_CHAR){
case _SC('\t'): case _SC('\r'): case _SC(' '): NEXT(); continue; case '\t': case '\r': case ' ': NEXT(); continue;
case _SC('\n'): case '\n':
_currentline++; _currentline++;
_prevtoken=_curtoken; _prevtoken=_curtoken;
_curtoken=_SC('\n'); _curtoken='\n';
NEXT(); NEXT();
_currentcolumn=1; _currentcolumn=1;
continue; continue;
case _SC('#'): lexLineComment(); continue; case '#': lexLineComment(); continue;
case _SC('/'): case '/':
NEXT(); NEXT();
switch(CUR_CHAR){ switch(CUR_CHAR){
case _SC('*'): case '*':
NEXT(); NEXT();
lexBlockComment(); lexBlockComment();
continue; continue;
case _SC('/'): case '/':
lexLineComment(); lexLineComment();
continue; continue;
case _SC('='): case '=':
NEXT(); NEXT();
RETURN_TOKEN(TK_DIVEQ); RETURN_TOKEN(TK_DIVEQ);
continue; continue;
case _SC('>'): case '>':
NEXT(); NEXT();
RETURN_TOKEN(TK_ATTR_CLOSE); RETURN_TOKEN(TK_ATTR_CLOSE);
continue; continue;
default: default:
RETURN_TOKEN('/'); RETURN_TOKEN('/');
} }
case _SC('='): case '=':
NEXT(); NEXT();
if (CUR_CHAR != _SC('=')){ RETURN_TOKEN('=') } if (CUR_CHAR != '='){ RETURN_TOKEN('=') }
else { NEXT(); RETURN_TOKEN(TK_EQ); } else { NEXT(); RETURN_TOKEN(TK_EQ); }
case _SC('<'): case '<':
NEXT(); NEXT();
switch(CUR_CHAR) { switch(CUR_CHAR) {
case _SC('='): case '=':
NEXT(); NEXT();
if(CUR_CHAR == _SC('>')) { if(CUR_CHAR == '>') {
NEXT(); NEXT();
RETURN_TOKEN(TK_3WAYSCMP); RETURN_TOKEN(TK_3WAYSCMP);
} }
RETURN_TOKEN(TK_LE) RETURN_TOKEN(TK_LE)
break; break;
case _SC('-'): NEXT(); RETURN_TOKEN(TK_NEWSLOT); break; case '-': NEXT(); RETURN_TOKEN(TK_NEWSLOT); break;
case _SC('<'): NEXT(); RETURN_TOKEN(TK_SHIFTL); break; case '<': NEXT(); RETURN_TOKEN(TK_SHIFTL); break;
case _SC('/'): NEXT(); RETURN_TOKEN(TK_ATTR_OPEN); break; case '/': NEXT(); RETURN_TOKEN(TK_ATTR_OPEN); break;
} }
RETURN_TOKEN('<'); RETURN_TOKEN('<');
case _SC('>'): case '>':
NEXT(); NEXT();
if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_GE);} if (CUR_CHAR == '='){ NEXT(); RETURN_TOKEN(TK_GE);}
else if(CUR_CHAR == _SC('>')){ else if(CUR_CHAR == '>'){
NEXT(); NEXT();
if(CUR_CHAR == _SC('>')){ if(CUR_CHAR == '>'){
NEXT(); NEXT();
RETURN_TOKEN(TK_USHIFTR); RETURN_TOKEN(TK_USHIFTR);
} }
RETURN_TOKEN(TK_SHIFTR); RETURN_TOKEN(TK_SHIFTR);
} }
else { RETURN_TOKEN('>') } else { RETURN_TOKEN('>') }
case _SC('!'): case '!':
NEXT(); NEXT();
if (CUR_CHAR != _SC('=')){ RETURN_TOKEN('!')} if (CUR_CHAR != '='){ RETURN_TOKEN('!')}
else { NEXT(); RETURN_TOKEN(TK_NE); } else { NEXT(); RETURN_TOKEN(TK_NE); }
case _SC('@'): { case '@': {
int64_t stype; int64_t stype;
NEXT(); NEXT();
if(CUR_CHAR != _SC('"')) { if(CUR_CHAR != '"') {
RETURN_TOKEN('@'); RETURN_TOKEN('@');
} }
if((stype=readString('"',true))!=-1) { if((stype=readString('"',true))!=-1) {
RETURN_TOKEN(stype); RETURN_TOKEN(stype);
} }
error(_SC("error parsing the string")); error("error parsing the string");
} }
case _SC('"'): case '"':
case _SC('\''): { case '\'': {
int64_t stype; int64_t stype;
if((stype=readString(CUR_CHAR,false))!=-1){ if((stype=readString(CUR_CHAR,false))!=-1){
RETURN_TOKEN(stype); RETURN_TOKEN(stype);
} }
error(_SC("error parsing the string")); error("error parsing the string");
} }
case _SC('{'): case _SC('}'): case _SC('('): case _SC(')'): case _SC('['): case _SC(']'): case '{': case '}': case '(': case ')': case '[': case ']':
case _SC(';'): case _SC(','): case _SC('?'): case _SC('^'): case _SC('~'): case ';': case ',': case '?': case '^': case '~':
{int64_t ret = CUR_CHAR; {int64_t ret = CUR_CHAR;
NEXT(); RETURN_TOKEN(ret); } NEXT(); RETURN_TOKEN(ret); }
case _SC('.'): case '.':
NEXT(); NEXT();
if (CUR_CHAR != _SC('.')){ RETURN_TOKEN('.') } if (CUR_CHAR != '.'){ RETURN_TOKEN('.') }
NEXT(); NEXT();
if (CUR_CHAR != _SC('.')){ error(_SC("invalid token '..'")); } if (CUR_CHAR != '.'){ error("invalid token '..'"); }
NEXT(); NEXT();
RETURN_TOKEN(TK_VARPARAMS); RETURN_TOKEN(TK_VARPARAMS);
case _SC('&'): case '&':
NEXT(); NEXT();
if (CUR_CHAR != _SC('&')){ RETURN_TOKEN('&') } if (CUR_CHAR != '&'){ RETURN_TOKEN('&') }
else { NEXT(); RETURN_TOKEN(TK_AND); } else { NEXT(); RETURN_TOKEN(TK_AND); }
case _SC('|'): case '|':
NEXT(); NEXT();
if (CUR_CHAR != _SC('|')){ RETURN_TOKEN('|') } if (CUR_CHAR != '|'){ RETURN_TOKEN('|') }
else { NEXT(); RETURN_TOKEN(TK_OR); } else { NEXT(); RETURN_TOKEN(TK_OR); }
case _SC(':'): case ':':
NEXT(); NEXT();
if (CUR_CHAR != _SC(':')){ RETURN_TOKEN(':') } if (CUR_CHAR != ':'){ RETURN_TOKEN(':') }
else { NEXT(); RETURN_TOKEN(TK_DOUBLE_COLON); } else { NEXT(); RETURN_TOKEN(TK_DOUBLE_COLON); }
case _SC('*'): case '*':
NEXT(); NEXT();
if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_MULEQ);} if (CUR_CHAR == '='){ NEXT(); RETURN_TOKEN(TK_MULEQ);}
else RETURN_TOKEN('*'); else RETURN_TOKEN('*');
case _SC('%'): case '%':
NEXT(); NEXT();
if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_MODEQ);} if (CUR_CHAR == '='){ NEXT(); RETURN_TOKEN(TK_MODEQ);}
else RETURN_TOKEN('%'); else RETURN_TOKEN('%');
case _SC('-'): case '-':
NEXT(); NEXT();
if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_MINUSEQ);} if (CUR_CHAR == '='){ NEXT(); RETURN_TOKEN(TK_MINUSEQ);}
else if (CUR_CHAR == _SC('-')){ NEXT(); RETURN_TOKEN(TK_MINUSMINUS);} else if (CUR_CHAR == '-'){ NEXT(); RETURN_TOKEN(TK_MINUSMINUS);}
else RETURN_TOKEN('-'); else RETURN_TOKEN('-');
case _SC('+'): case '+':
NEXT(); NEXT();
if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_PLUSEQ);} if (CUR_CHAR == '='){ NEXT(); RETURN_TOKEN(TK_PLUSEQ);}
else if (CUR_CHAR == _SC('+')){ NEXT(); RETURN_TOKEN(TK_PLUSPLUS);} else if (CUR_CHAR == '+'){ NEXT(); RETURN_TOKEN(TK_PLUSPLUS);}
else RETURN_TOKEN('+'); else RETURN_TOKEN('+');
case RABBIT_EOB: case RABBIT_EOB:
return 0; return 0;
@ -265,13 +265,13 @@ int64_t rabbit::Lexer::Lex()
int64_t ret = readNumber(); int64_t ret = readNumber();
RETURN_TOKEN(ret); RETURN_TOKEN(ret);
} }
else if (isalpha(CUR_CHAR) || CUR_CHAR == _SC('_')) { else if (isalpha(CUR_CHAR) || CUR_CHAR == '_') {
int64_t t = readId(); int64_t t = readId();
RETURN_TOKEN(t); RETURN_TOKEN(t);
} }
else { else {
int64_t c = CUR_CHAR; int64_t c = CUR_CHAR;
if (iscntrl((int)c)) error(_SC("unexpected character(control)")); if (iscntrl((int)c)) error("unexpected character(control)");
NEXT(); NEXT();
RETURN_TOKEN(c); RETURN_TOKEN(c);
} }
@ -321,7 +321,7 @@ int64_t rabbit::Lexer::addUTF8(uint64_t ch)
int64_t rabbit::Lexer::processStringHexEscape(char *dest, int64_t maxdigits) int64_t rabbit::Lexer::processStringHexEscape(char *dest, int64_t maxdigits)
{ {
NEXT(); NEXT();
if (!isxdigit(CUR_CHAR)) error(_SC("hexadecimal number expected")); if (!isxdigit(CUR_CHAR)) error("hexadecimal number expected");
int64_t n = 0; int64_t n = 0;
while (isxdigit(CUR_CHAR) && n < maxdigits) { while (isxdigit(CUR_CHAR) && n < maxdigits) {
dest[n] = CUR_CHAR; dest[n] = CUR_CHAR;
@ -342,21 +342,21 @@ int64_t rabbit::Lexer::readString(int64_t ndelim,bool verbatim)
int64_t x = CUR_CHAR; int64_t x = CUR_CHAR;
switch (x) { switch (x) {
case RABBIT_EOB: case RABBIT_EOB:
error(_SC("unfinished string")); error("unfinished string");
return -1; return -1;
case _SC('\n'): case '\n':
if(!verbatim) error(_SC("newline in a constant")); if(!verbatim) error("newline in a constant");
APPEND_CHAR(CUR_CHAR); NEXT(); APPEND_CHAR(CUR_CHAR); NEXT();
_currentline++; _currentline++;
break; break;
case _SC('\\'): case '\\':
if(verbatim) { if(verbatim) {
APPEND_CHAR('\\'); NEXT(); APPEND_CHAR('\\'); NEXT();
} }
else { else {
NEXT(); NEXT();
switch(CUR_CHAR) { switch(CUR_CHAR) {
case _SC('x'): { case 'x': {
const int64_t maxdigits = sizeof(char) * 2; const int64_t maxdigits = sizeof(char) * 2;
char temp[maxdigits + 1]; char temp[maxdigits + 1];
processStringHexEscape(temp, maxdigits); processStringHexEscape(temp, maxdigits);
@ -364,8 +364,8 @@ int64_t rabbit::Lexer::readString(int64_t ndelim,bool verbatim)
APPEND_CHAR((char)strtoul(temp, &stemp, 16)); APPEND_CHAR((char)strtoul(temp, &stemp, 16));
} }
break; break;
case _SC('U'): case 'U':
case _SC('u'): { case 'u': {
const int64_t maxdigits = CUR_CHAR == 'u' ? 4 : 8; const int64_t maxdigits = CUR_CHAR == 'u' ? 4 : 8;
char temp[8 + 1]; char temp[8 + 1];
processStringHexEscape(temp, maxdigits); processStringHexEscape(temp, maxdigits);
@ -373,19 +373,19 @@ int64_t rabbit::Lexer::readString(int64_t ndelim,bool verbatim)
addUTF8(strtoul(temp, &stemp, 16)); addUTF8(strtoul(temp, &stemp, 16));
} }
break; break;
case _SC('t'): APPEND_CHAR(_SC('\t')); NEXT(); break; case 't': APPEND_CHAR('\t'); NEXT(); break;
case _SC('a'): APPEND_CHAR(_SC('\a')); NEXT(); break; case 'a': APPEND_CHAR('\a'); NEXT(); break;
case _SC('b'): APPEND_CHAR(_SC('\b')); NEXT(); break; case 'b': APPEND_CHAR('\b'); NEXT(); break;
case _SC('n'): APPEND_CHAR(_SC('\n')); NEXT(); break; case 'n': APPEND_CHAR('\n'); NEXT(); break;
case _SC('r'): APPEND_CHAR(_SC('\r')); NEXT(); break; case 'r': APPEND_CHAR('\r'); NEXT(); break;
case _SC('v'): APPEND_CHAR(_SC('\v')); NEXT(); break; case 'v': APPEND_CHAR('\v'); NEXT(); break;
case _SC('f'): APPEND_CHAR(_SC('\f')); NEXT(); break; case 'f': APPEND_CHAR('\f'); NEXT(); break;
case _SC('0'): APPEND_CHAR(_SC('\0')); NEXT(); break; case '0': APPEND_CHAR('\0'); NEXT(); break;
case _SC('\\'): APPEND_CHAR(_SC('\\')); NEXT(); break; case '\\': APPEND_CHAR('\\'); NEXT(); break;
case _SC('"'): APPEND_CHAR(_SC('"')); NEXT(); break; case '"': APPEND_CHAR('"'); NEXT(); break;
case _SC('\''): APPEND_CHAR(_SC('\'')); NEXT(); break; case '\'': APPEND_CHAR('\''); NEXT(); break;
default: default:
error(_SC("unrecognised escaper char")); error("unrecognised escaper char");
break; break;
} }
} }
@ -406,9 +406,9 @@ int64_t rabbit::Lexer::readString(int64_t ndelim,bool verbatim)
} }
TERMINATE_BUFFER(); TERMINATE_BUFFER();
int64_t len = _longstr.size()-1; int64_t len = _longstr.size()-1;
if(ndelim == _SC('\'')) { if(ndelim == '\'') {
if(len == 0) error(_SC("empty constant")); if(len == 0) error("empty constant");
if(len > 1) error(_SC("constant too long")); if(len > 1) error("constant too long");
_nvalue = _longstr[0]; _nvalue = _longstr[0];
return TK_INTEGER; return TK_INTEGER;
} }
@ -436,7 +436,7 @@ void LexInteger(const char *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 >= '0' && c <= '7'; }
void LexOctal(const char *s,uint64_t *res) void LexOctal(const char *s,uint64_t *res)
{ {
@ -463,14 +463,14 @@ int64_t rabbit::Lexer::readNumber()
char *sTemp; char *sTemp;
INIT_TEMP_STRING(); INIT_TEMP_STRING();
NEXT(); NEXT();
if(firstchar == _SC('0') && (toupper(CUR_CHAR) == _SC('X') || scisodigit(CUR_CHAR)) ) { if(firstchar == '0' && (toupper(CUR_CHAR) == 'X' || scisodigit(CUR_CHAR)) ) {
if(scisodigit(CUR_CHAR)) { if(scisodigit(CUR_CHAR)) {
type = TOCTAL; type = TOCTAL;
while(scisodigit(CUR_CHAR)) { while(scisodigit(CUR_CHAR)) {
APPEND_CHAR(CUR_CHAR); APPEND_CHAR(CUR_CHAR);
NEXT(); NEXT();
} }
if(isdigit(CUR_CHAR)) error(_SC("invalid octal number")); if(isdigit(CUR_CHAR)) error("invalid octal number");
} }
else { else {
NEXT(); NEXT();
@ -479,15 +479,15 @@ int64_t rabbit::Lexer::readNumber()
APPEND_CHAR(CUR_CHAR); APPEND_CHAR(CUR_CHAR);
NEXT(); NEXT();
} }
if(_longstr.size() > MAX_HEX_DIGITS) error(_SC("too many digits for an Hex number")); if(_longstr.size() > MAX_HEX_DIGITS) error("too many digits for an Hex number");
} }
} }
else { else {
APPEND_CHAR((int)firstchar); APPEND_CHAR((int)firstchar);
while (CUR_CHAR == _SC('.') || isdigit(CUR_CHAR) || isexponent(CUR_CHAR)) { while (CUR_CHAR == '.' || isdigit(CUR_CHAR) || isexponent(CUR_CHAR)) {
if(CUR_CHAR == _SC('.') || isexponent(CUR_CHAR)) type = TFLOAT; if(CUR_CHAR == '.' || isexponent(CUR_CHAR)) type = TFLOAT;
if(isexponent(CUR_CHAR)) { if(isexponent(CUR_CHAR)) {
if(type != TFLOAT) error(_SC("invalid numeric format")); if(type != TFLOAT) error("invalid numeric format");
type = TSCIENTIFIC; type = TSCIENTIFIC;
APPEND_CHAR(CUR_CHAR); APPEND_CHAR(CUR_CHAR);
NEXT(); NEXT();
@ -495,7 +495,7 @@ int64_t rabbit::Lexer::readNumber()
APPEND_CHAR(CUR_CHAR); APPEND_CHAR(CUR_CHAR);
NEXT(); NEXT();
} }
if(!isdigit(CUR_CHAR)) error(_SC("exponent expected")); if(!isdigit(CUR_CHAR)) error("exponent expected");
} }
APPEND_CHAR(CUR_CHAR); APPEND_CHAR(CUR_CHAR);
@ -528,7 +528,7 @@ int64_t rabbit::Lexer::readId()
do { do {
APPEND_CHAR(CUR_CHAR); APPEND_CHAR(CUR_CHAR);
NEXT(); NEXT();
} while(isalnum(CUR_CHAR) || CUR_CHAR == _SC('_')); } while(isalnum(CUR_CHAR) || CUR_CHAR == '_');
TERMINATE_BUFFER(); TERMINATE_BUFFER();
res = getIDType(&_longstr[0],_longstr.size() - 1); res = getIDType(&_longstr[0],_longstr.size() - 1);
if(res == TK_IDENTIFIER || res == TK_CONSTRUCTOR) { if(res == TK_IDENTIFIER || res == TK_CONSTRUCTOR) {

36
rabbit/MetaMethod.hpp
View File

@ -36,21 +36,21 @@ namespace rabbit {
}; };
} }
#define MM_ADD _SC("_add") #define MM_ADD "_add"
#define MM_SUB _SC("_sub") #define MM_SUB "_sub"
#define MM_MUL _SC("_mul") #define MM_MUL "_mul"
#define MM_DIV _SC("_div") #define MM_DIV "_div"
#define MM_UNM _SC("_unm") #define MM_UNM "_unm"
#define MM_MODULO _SC("_modulo") #define MM_MODULO "_modulo"
#define MM_SET _SC("_set") #define MM_SET "_set"
#define MM_GET _SC("_get") #define MM_GET "_get"
#define MM_TYPEOF _SC("_typeof") #define MM_TYPEOF "_typeof"
#define MM_NEXTI _SC("_nexti") #define MM_NEXTI "_nexti"
#define MM_CMP _SC("_cmp") #define MM_CMP "_cmp"
#define MM_CALL _SC("_call") #define MM_CALL "_call"
#define MM_CLONED _SC("_cloned") #define MM_CLONED "_cloned"
#define MM_NEWSLOT _SC("_newslot") #define MM_NEWSLOT "_newslot"
#define MM_DELSLOT _SC("_delslot") #define MM_DELSLOT "_delslot"
#define MM_TOSTRING _SC("_tostring") #define MM_TOSTRING "_tostring"
#define MM_NEWMEMBER _SC("_newmember") #define MM_NEWMEMBER "_newmember"
#define MM_INHERITED _SC("_inherited") #define MM_INHERITED "_inherited"

32
rabbit/ObjectPtr.cpp
View File

@ -157,39 +157,39 @@ const char* rabbit::IdType2Name(rabbit::ObjectType type)
switch(_RAW_TYPE(type)) switch(_RAW_TYPE(type))
{ {
case _RT_NULL: case _RT_NULL:
return _SC("null"); return "null";
case _RT_INTEGER: case _RT_INTEGER:
return _SC("integer"); return "integer";
case _RT_FLOAT: case _RT_FLOAT:
return _SC("float"); return "float";
case _RT_BOOL: case _RT_BOOL:
return _SC("bool"); return "bool";
case _RT_STRING: case _RT_STRING:
return _SC("string"); return "string";
case _RT_TABLE: case _RT_TABLE:
return _SC("table"); return "table";
case _RT_ARRAY: case _RT_ARRAY:
return _SC("array"); return "array";
case _RT_GENERATOR: case _RT_GENERATOR:
return _SC("generator"); return "generator";
case _RT_CLOSURE: case _RT_CLOSURE:
case _RT_NATIVECLOSURE: case _RT_NATIVECLOSURE:
return _SC("function"); return "function";
case _RT_USERDATA: case _RT_USERDATA:
case _RT_USERPOINTER: case _RT_USERPOINTER:
return _SC("userdata"); return "userdata";
case _RT_THREAD: case _RT_THREAD:
return _SC("thread"); return "thread";
case _RT_FUNCPROTO: case _RT_FUNCPROTO:
return _SC("function"); return "function";
case _RT_CLASS: case _RT_CLASS:
return _SC("class"); return "class";
case _RT_INSTANCE: case _RT_INSTANCE:
return _SC("instance"); return "instance";
case _RT_WEAKREF: case _RT_WEAKREF:
return _SC("weakref"); return "weakref";
case _RT_OUTER: case _RT_OUTER:
return _SC("outer"); return "outer";
default: default:
return NULL; return NULL;
} }

32
rabbit/SharedState.cpp
View File

@ -105,21 +105,21 @@ void rabbit::SharedState::init()
_metamethodsmap = rabbit::Table::create(this,rabbit::MT_LAST-1); _metamethodsmap = rabbit::Table::create(this,rabbit::MT_LAST-1);
//adding type strings to avoid memory trashing //adding type strings to avoid memory trashing
//types names //types names
newsysstring(_SC("null")); newsysstring("null");
newsysstring(_SC("table")); newsysstring("table");
newsysstring(_SC("array")); newsysstring("array");
newsysstring(_SC("closure")); newsysstring("closure");
newsysstring(_SC("string")); newsysstring("string");
newsysstring(_SC("userdata")); newsysstring("userdata");
newsysstring(_SC("integer")); newsysstring("integer");
newsysstring(_SC("float")); newsysstring("float");
newsysstring(_SC("userpointer")); newsysstring("userpointer");
newsysstring(_SC("function")); newsysstring("function");
newsysstring(_SC("generator")); newsysstring("generator");
newsysstring(_SC("thread")); newsysstring("thread");
newsysstring(_SC("class")); newsysstring("class");
newsysstring(_SC("instance")); newsysstring("instance");
newsysstring(_SC("bool")); newsysstring("bool");
//meta methods //meta methods
newmetamethod(MM_ADD); newmetamethod(MM_ADD);
newmetamethod(MM_SUB); newmetamethod(MM_SUB);
@ -140,7 +140,7 @@ void rabbit::SharedState::init()
newmetamethod(MM_NEWMEMBER); newmetamethod(MM_NEWMEMBER);
newmetamethod(MM_INHERITED); newmetamethod(MM_INHERITED);
_constructoridx = rabbit::String::create(this,_SC("constructor")); _constructoridx = rabbit::String::create(this,"constructor");
_registry = rabbit::Table::create(this,0); _registry = rabbit::Table::create(this,0);
_consts = rabbit::Table::create(this,0); _consts = rabbit::Table::create(this,0);
_table_default_delegate = createDefaultDelegate(this,_table_default_delegate_funcz); _table_default_delegate = createDefaultDelegate(this,_table_default_delegate_funcz);

2
rabbit/StringTable.cpp
View File

@ -50,7 +50,7 @@ rabbit::String *rabbit::StringTable::add(const char *news,int64_t len)
new ((char*)t) rabbit::String; new ((char*)t) rabbit::String;
t->_sharedstate = _sharedstate; t->_sharedstate = _sharedstate;
memcpy(t->_val,news,sq_rsl(len)); memcpy(t->_val,news,sq_rsl(len));
t->_val[len] = _SC('\0'); t->_val[len] = '\0';
t->_len = len; t->_len = len;
t->_hash = newhash; t->_hash = newhash;
t->_next = _strings[h]; t->_next = _strings[h];

150
rabbit/VirtualMachine.cpp
View File

@ -47,10 +47,10 @@ bool rabbit::VirtualMachine::BW_OP(uint64_t op,rabbit::ObjectPtr &trg,const rabb
case BW_SHIFTL: res = i1 << i2; break; case BW_SHIFTL: res = i1 << i2; break;
case BW_SHIFTR: res = i1 >> i2; break; case BW_SHIFTR: res = i1 >> i2; break;
case BW_USHIFTR:res = (int64_t)(*((uint64_t*)&i1) >> i2); break; case BW_USHIFTR:res = (int64_t)(*((uint64_t*)&i1) >> i2); break;
default: { raise_error(_SC("internal vm error bitwise op failed")); return false; } default: { raise_error("internal vm error bitwise op failed"); return false; }
} }
} }
else { raise_error(_SC("bitwise op between '%s' and '%s'"),getTypeName(o1),getTypeName(o2)); return false;} else { raise_error("bitwise op between '%s' and '%s'",getTypeName(o1),getTypeName(o2)); return false;}
trg = res; trg = res;
return true; return true;
} }
@ -90,12 +90,12 @@ bool rabbit::VirtualMachine::ARITH_OP(uint64_t op,rabbit::ObjectPtr &trg,const r
switch(op) { switch(op) {
case '+': res = i1 + i2; break; case '+': res = i1 + i2; break;
case '-': res = i1 - i2; break; case '-': res = i1 - i2; break;
case '/': if (i2 == 0) { raise_error(_SC("division by zero")); return false; } case '/': if (i2 == 0) { raise_error("division by zero"); return false; }
else if (i2 == -1 && i1 == INT64_MIN) { raise_error(_SC("integer overflow")); return false; } else if (i2 == -1 && i1 == INT64_MIN) { raise_error("integer overflow"); return false; }
res = i1 / i2; res = i1 / i2;
break; break;
case '*': res = i1 * i2; break; case '*': res = i1 * i2; break;
case '%': if (i2 == 0) { raise_error(_SC("modulo by zero")); return false; } case '%': if (i2 == 0) { raise_error("modulo by zero"); return false; }
else if (i2 == -1 && i1 == INT64_MAX) { res = 0; break; } else if (i2 == -1 && i1 == INT64_MAX) { res = 0; break; }
res = i1 % i2; res = i1 % i2;
break; break;
@ -173,11 +173,11 @@ bool rabbit::VirtualMachine::arithMetaMethod(int64_t op,const rabbit::ObjectPtr
{ {
rabbit::MetaMethod mm; rabbit::MetaMethod mm;
switch(op){ switch(op){
case _SC('+'): mm=MT_ADD; break; case '+': mm=MT_ADD; break;
case _SC('-'): mm=MT_SUB; break; case '-': mm=MT_SUB; break;
case _SC('/'): mm=MT_DIV; break; case '/': mm=MT_DIV; break;
case _SC('*'): mm=MT_MUL; break; case '*': mm=MT_MUL; break;
case _SC('%'): mm=MT_MODULO; break; case '%': mm=MT_MODULO; break;
default: mm = MT_ADD; assert(0); break; //shutup compiler default: mm = MT_ADD; assert(0); break; //shutup compiler
} }
if(is_delegable(o1) && _delegable(o1)->_delegate) { if(is_delegable(o1) && _delegable(o1)->_delegate) {
@ -189,7 +189,7 @@ bool rabbit::VirtualMachine::arithMetaMethod(int64_t op,const rabbit::ObjectPtr
return callMetaMethod(closure,mm,2,dest); return callMetaMethod(closure,mm,2,dest);
} }
} }
raise_error(_SC("arith op %c on between '%s' and '%s'"),op,getTypeName(o1),getTypeName(o2)); raise_error("arith op %c on between '%s' and '%s'",op,getTypeName(o1),getTypeName(o2));
return false; return false;
} }
@ -218,7 +218,7 @@ bool rabbit::VirtualMachine::NEG_OP(rabbit::ObjectPtr &trg,const rabbit::ObjectP
} }
default:break; //shutup compiler default:break; //shutup compiler
} }
raise_error(_SC("attempt to negate a %s"), getTypeName(o)); raise_error("attempt to negate a %s", getTypeName(o));
return false; return false;
} }
@ -245,7 +245,7 @@ bool rabbit::VirtualMachine::objCmp(const rabbit::ObjectPtr &o1,const rabbit::Ob
push(o1);push(o2); push(o1);push(o2);
if(callMetaMethod(closure,MT_CMP,2,res)) { if(callMetaMethod(closure,MT_CMP,2,res)) {
if(sq_type(res) != rabbit::OT_INTEGER) { if(sq_type(res) != rabbit::OT_INTEGER) {
raise_error(_SC("_cmp must return an integer")); raise_error("_cmp must return an integer");
return false; return false;
} }
_RET_SUCCEED(_integer(res)) _RET_SUCCEED(_integer(res))
@ -307,13 +307,13 @@ bool rabbit::VirtualMachine::toString(const rabbit::ObjectPtr &o,rabbit::ObjectP
res = o; res = o;
return true; return true;
case rabbit::OT_FLOAT: case rabbit::OT_FLOAT:
snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)),sq_rsl(NUMBER_UINT8_MAX),_SC("%g"),_float(o)); snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)),sq_rsl(NUMBER_UINT8_MAX),"%g",_float(o));
break; break;
case rabbit::OT_INTEGER: case rabbit::OT_INTEGER:
snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)),sq_rsl(NUMBER_UINT8_MAX),_PRINT_INT_FMT,_integer(o)); snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)),sq_rsl(NUMBER_UINT8_MAX),_PRINT_INT_FMT,_integer(o));
break; break;
case rabbit::OT_BOOL: case rabbit::OT_BOOL:
snprintf(_sp(sq_rsl(6)),sq_rsl(6),_integer(o)?_SC("true"):_SC("false")); snprintf(_sp(sq_rsl(6)),sq_rsl(6),_integer(o)?"true":"false");
break; break;
case rabbit::OT_TABLE: case rabbit::OT_TABLE:
case rabbit::OT_USERDATA: case rabbit::OT_USERDATA:
@ -332,7 +332,7 @@ bool rabbit::VirtualMachine::toString(const rabbit::ObjectPtr &o,rabbit::ObjectP
} }
} }
default: default:
snprintf(_sp(sq_rsl((sizeof(void*)*2)+NUMBER_UINT8_MAX)),sq_rsl((sizeof(void*)*2)+NUMBER_UINT8_MAX),_SC("(%s : 0x%p)"),getTypeName(o),(void*)_rawval(o)); snprintf(_sp(sq_rsl((sizeof(void*)*2)+NUMBER_UINT8_MAX)),sq_rsl((sizeof(void*)*2)+NUMBER_UINT8_MAX),"(%s : 0x%p)",getTypeName(o),(void*)_rawval(o));
} }
res = rabbit::String::create(_get_shared_state(this),_spval); res = rabbit::String::create(_get_shared_state(this),_spval);
return true; return true;
@ -402,7 +402,7 @@ bool rabbit::VirtualMachine::startcall(rabbit::Closure *closure,int64_t target,i
{ {
paramssize--; paramssize--;
if (nargs < paramssize) { if (nargs < paramssize) {
raise_error(_SC("wrong number of parameters")); raise_error("wrong number of parameters");
return false; return false;
} }
@ -428,7 +428,7 @@ bool rabbit::VirtualMachine::startcall(rabbit::Closure *closure,int64_t target,i
} }
} }
else { else {
raise_error(_SC("wrong number of parameters")); raise_error("wrong number of parameters");
return false; return false;
} }
} }
@ -445,7 +445,7 @@ bool rabbit::VirtualMachine::startcall(rabbit::Closure *closure,int64_t target,i
ci->_target = (int32_t)target; ci->_target = (int32_t)target;
if (_debughook) { if (_debughook) {
callDebugHook(_SC('c')); callDebugHook('c');
} }
if (closure->_function->_bgenerator) { if (closure->_function->_bgenerator) {
@ -469,7 +469,7 @@ bool rabbit::VirtualMachine::Return(int64_t _arg0, int64_t _arg1, rabbit::Object
if (_debughook) { if (_debughook) {
for(int64_t i=0; i<ci->_ncalls; i++) { for(int64_t i=0; i<ci->_ncalls; i++) {
callDebugHook(_SC('r')); callDebugHook('r');
} }
} }
@ -526,9 +526,9 @@ bool rabbit::VirtualMachine::derefInc(int64_t op,rabbit::ObjectPtr &target, rabb
rabbit::Result rabbit::VirtualMachine::Suspend() rabbit::Result rabbit::VirtualMachine::Suspend()
{ {
if (_suspended) if (_suspended)
return sq_throwerror(this, _SC("cannot suspend an already suspended vm")); return sq_throwerror(this, "cannot suspend an already suspended vm");
if (_nnativecalls!=2) if (_nnativecalls!=2)
return sq_throwerror(this, _SC("cannot suspend through native calls/metamethods")); return sq_throwerror(this, "cannot suspend through native calls/metamethods");
return SQ_SUSPEND_FLAG; return SQ_SUSPEND_FLAG;
} }
@ -563,7 +563,7 @@ bool rabbit::VirtualMachine::FOREACH_OP(rabbit::ObjectPtr &o1,rabbit::ObjectPtr
o4 = o2 = itr; o4 = o2 = itr;
if(sq_type(itr) == rabbit::OT_NULL) _FINISH(exitpos); if(sq_type(itr) == rabbit::OT_NULL) _FINISH(exitpos);
if(!get(o1, itr, o3, 0, DONT_FALL_BACK)) { if(!get(o1, itr, o3, 0, DONT_FALL_BACK)) {
raise_error(_SC("_nexti returned an invalid idx")); // cloud be changed raise_error("_nexti returned an invalid idx"); // cloud be changed
return false; return false;
} }
_FINISH(1); _FINISH(1);
@ -572,7 +572,7 @@ bool rabbit::VirtualMachine::FOREACH_OP(rabbit::ObjectPtr &o1,rabbit::ObjectPtr
return false; return false;
} }
} }
raise_error(_SC("_nexti failed")); raise_error("_nexti failed");
return false; return false;
} }
break; break;
@ -589,7 +589,7 @@ bool rabbit::VirtualMachine::FOREACH_OP(rabbit::ObjectPtr &o1,rabbit::ObjectPtr
_FINISH(0); _FINISH(0);
} }
default: default:
raise_error(_SC("cannot iterate %s"), getTypeName(o1)); raise_error("cannot iterate %s", getTypeName(o1));
} }
return false; //cannot be hit(just to avoid warnings) return false; //cannot be hit(just to avoid warnings)
} }
@ -635,7 +635,7 @@ bool rabbit::VirtualMachine::CLASS_OP(rabbit::ObjectPtr &target,int64_t baseclas
rabbit::Class *base = NULL; rabbit::Class *base = NULL;
rabbit::ObjectPtr attrs; rabbit::ObjectPtr attrs;
if(baseclass != -1) { if(baseclass != -1) {
if(sq_type(_stack[_stackbase+baseclass]) != rabbit::OT_CLASS) { raise_error(_SC("trying to inherit from a %s"),getTypeName(_stack[_stackbase+baseclass])); return false; } if(sq_type(_stack[_stackbase+baseclass]) != rabbit::OT_CLASS) { raise_error("trying to inherit from a %s",getTypeName(_stack[_stackbase+baseclass])); return false; }
base = _class(_stack[_stackbase + baseclass]); base = _class(_stack[_stackbase + baseclass]);
} }
if(attributes != MAX_FUNC_STACKSIZE) { if(attributes != MAX_FUNC_STACKSIZE) {
@ -689,7 +689,7 @@ bool rabbit::VirtualMachine::IsFalse(rabbit::ObjectPtr &o)
extern rabbit::InstructionDesc g_InstrDesc[]; extern rabbit::InstructionDesc g_InstrDesc[];
bool rabbit::VirtualMachine::execute(rabbit::ObjectPtr &closure, int64_t nargs, int64_t stackbase,rabbit::ObjectPtr &outres, rabbit::Bool raiseerror,ExecutionType et) bool rabbit::VirtualMachine::execute(rabbit::ObjectPtr &closure, int64_t nargs, int64_t stackbase,rabbit::ObjectPtr &outres, rabbit::Bool raiseerror,ExecutionType et)
{ {
if ((_nnativecalls + 1) > MAX_NATIVE_CALLS) { raise_error(_SC("Native stack overflow")); return false; } if ((_nnativecalls + 1) > MAX_NATIVE_CALLS) { raise_error("Native stack overflow"); return false; }
_nnativecalls++; _nnativecalls++;
AutoDec ad(&_nnativecalls); AutoDec ad(&_nnativecalls);
int64_t traps = 0; int64_t traps = 0;
@ -730,7 +730,7 @@ exception_restore:
//printf("\n[%d] %s %d %d %d %d\n",ci->_ip-_closure(ci->_closure)->_function->_instructions,g_InstrDesc[_i_.op].name,arg0,arg1,arg2,arg3); //printf("\n[%d] %s %d %d %d %d\n",ci->_ip-_closure(ci->_closure)->_function->_instructions,g_InstrDesc[_i_.op].name,arg0,arg1,arg2,arg3);
switch(_i_.op) switch(_i_.op)
{ {
case _OP_LINE: if (_debughook) callDebugHook(_SC('l'),arg1); continue; case _OP_LINE: if (_debughook) callDebugHook('l',arg1); continue;
case _OP_LOAD: TARGET = ci->_literals[arg1]; continue; case _OP_LOAD: TARGET = ci->_literals[arg1]; continue;
case _OP_LOADINT: case _OP_LOADINT:
#ifndef _SQ64 #ifndef _SQ64
@ -815,11 +815,11 @@ exception_restore:
break; break;
} }
//raise_error(_SC("attempt to call '%s'"), getTypeName(clo)); //raise_error("attempt to call '%s'", getTypeName(clo));
//SQ_THROW(); //SQ_THROW();
} }
default: default:
raise_error(_SC("attempt to call '%s'"), getTypeName(clo)); raise_error("attempt to call '%s'", getTypeName(clo));
SQ_THROW(); SQ_THROW();
} }
} }
@ -866,7 +866,7 @@ exception_restore:
case _OP_ADD: _ARITH_(+,TARGET,STK(arg2),STK(arg1)); continue; case _OP_ADD: _ARITH_(+,TARGET,STK(arg2),STK(arg1)); continue;
case _OP_SUB: _ARITH_(-,TARGET,STK(arg2),STK(arg1)); continue; case _OP_SUB: _ARITH_(-,TARGET,STK(arg2),STK(arg1)); continue;
case _OP_MUL: _ARITH_(*,TARGET,STK(arg2),STK(arg1)); continue; case _OP_MUL: _ARITH_(*,TARGET,STK(arg2),STK(arg1)); continue;
case _OP_DIV: _ARITH_NOZERO(/,TARGET,STK(arg2),STK(arg1),_SC("division by zero")); continue; case _OP_DIV: _ARITH_NOZERO(/,TARGET,STK(arg2),STK(arg1),"division by zero"); continue;
case _OP_MOD: ARITH_OP('%',TARGET,STK(arg2),STK(arg1)); continue; case _OP_MOD: ARITH_OP('%',TARGET,STK(arg2),STK(arg1)); continue;
case _OP_BITW: _GUARD(BW_OP( arg3,TARGET,STK(arg2),STK(arg1))); continue; case _OP_BITW: _GUARD(BW_OP( arg3,TARGET,STK(arg2),STK(arg1))); continue;
case _OP_RETURN: case _OP_RETURN:
@ -983,7 +983,7 @@ exception_restore:
case _OP_EXISTS: TARGET = get(STK(arg1), STK(arg2), temp_reg, GET_FLAG_DO_NOT_RAISE_ERROR | GET_FLAG_RAW, DONT_FALL_BACK) ? true : false; continue; case _OP_EXISTS: TARGET = get(STK(arg1), STK(arg2), temp_reg, GET_FLAG_DO_NOT_RAISE_ERROR | GET_FLAG_RAW, DONT_FALL_BACK) ? true : false; continue;
case _OP_INSTANCEOF: case _OP_INSTANCEOF:
if(sq_type(STK(arg1)) != rabbit::OT_CLASS) if(sq_type(STK(arg1)) != rabbit::OT_CLASS)
{raise_error(_SC("cannot apply instanceof between a %s and a %s"),getTypeName(STK(arg1)),getTypeName(STK(arg2))); SQ_THROW();} {raise_error("cannot apply instanceof between a %s and a %s",getTypeName(STK(arg1)),getTypeName(STK(arg2))); SQ_THROW();}
TARGET = (sq_type(STK(arg2)) == rabbit::OT_INSTANCE) ? (_instance(STK(arg2))->instanceOf(_class(STK(arg1)))?true:false) : false; TARGET = (sq_type(STK(arg2)) == rabbit::OT_INSTANCE) ? (_instance(STK(arg2))->instanceOf(_class(STK(arg1)))?true:false) : false;
continue; continue;
case _OP_AND: case _OP_AND:
@ -1006,7 +1006,7 @@ exception_restore:
TARGET = int64_t(~t); TARGET = int64_t(~t);
continue; continue;
} }
raise_error(_SC("attempt to perform a bitwise op on a %s"), getTypeName(STK(arg1))); raise_error("attempt to perform a bitwise op on a %s", getTypeName(STK(arg1)));
SQ_THROW(); SQ_THROW();
case _OP_CLOSURE: { case _OP_CLOSURE: {
rabbit::Closure *c = ci->_closure._unVal.pClosure; rabbit::Closure *c = ci->_closure._unVal.pClosure;
@ -1021,7 +1021,7 @@ exception_restore:
traps -= ci->_etraps; traps -= ci->_etraps;
if(sarg1 != MAX_FUNC_STACKSIZE) _Swap(STK(arg1),temp_reg);//STK(arg1) = temp_reg; if(sarg1 != MAX_FUNC_STACKSIZE) _Swap(STK(arg1),temp_reg);//STK(arg1) = temp_reg;
} }
else { raise_error(_SC("trying to yield a '%s',only genenerator can be yielded"), getTypeName(ci->_generator)); SQ_THROW();} else { raise_error("trying to yield a '%s',only genenerator can be yielded", getTypeName(ci->_generator)); SQ_THROW();}
if(Return(arg0, arg1, temp_reg)){ if(Return(arg0, arg1, temp_reg)){
assert(traps == 0); assert(traps == 0);
outres = temp_reg; outres = temp_reg;
@ -1031,7 +1031,7 @@ exception_restore:
} }
continue; continue;
case _OP_RESUME: case _OP_RESUME:
if(sq_type(STK(arg1)) != rabbit::OT_GENERATOR){ raise_error(_SC("trying to resume a '%s',only genenerator can be resumed"), getTypeName(STK(arg1))); SQ_THROW();} if(sq_type(STK(arg1)) != rabbit::OT_GENERATOR){ raise_error("trying to resume a '%s',only genenerator can be resumed", getTypeName(STK(arg1))); SQ_THROW();}
_GUARD(_generator(STK(arg1))->resume(this, TARGET)); _GUARD(_generator(STK(arg1))->resume(this, TARGET));
traps += ci->_etraps; traps += ci->_etraps;
continue; continue;
@ -1104,7 +1104,7 @@ exception_trap:
//notify debugger of a "return" //notify debugger of a "return"
//even if it really an exception unwinding the stack //even if it really an exception unwinding the stack
for(int64_t i = 0; i < ci->_ncalls; i++) { for(int64_t i = 0; i < ci->_ncalls; i++) {
callDebugHook(_SC('r')); callDebugHook('r');
} }
} }
if(ci->_generator) ci->_generator->kill(); if(ci->_generator) ci->_generator->kill();
@ -1169,14 +1169,14 @@ bool rabbit::VirtualMachine::callNative(rabbit::NativeClosure *nclosure, int64_t
int64_t newtop = newbase + nargs + nclosure->_noutervalues; int64_t newtop = newbase + nargs + nclosure->_noutervalues;
if (_nnativecalls + 1 > MAX_NATIVE_CALLS) { if (_nnativecalls + 1 > MAX_NATIVE_CALLS) {
raise_error(_SC("Native stack overflow")); raise_error("Native stack overflow");
return false; return false;
} }
if(nparamscheck && (((nparamscheck > 0) && (nparamscheck != nargs)) || if(nparamscheck && (((nparamscheck > 0) && (nparamscheck != nargs)) ||
((nparamscheck < 0) && (nargs < (-nparamscheck))))) ((nparamscheck < 0) && (nargs < (-nparamscheck)))))
{ {
raise_error(_SC("wrong number of parameters")); raise_error("wrong number of parameters");
return false; return false;
} }
@ -1375,7 +1375,7 @@ bool rabbit::VirtualMachine::set(const rabbit::ObjectPtr &self,const rabbit::Obj
if(_instance(self)->set(key,val)) return true; if(_instance(self)->set(key,val)) return true;
break; break;
case rabbit::OT_ARRAY: case rabbit::OT_ARRAY:
if(!sq_isnumeric(key)) { raise_error(_SC("indexing %s with %s"),getTypeName(self),getTypeName(key)); return false; } if(!sq_isnumeric(key)) { raise_error("indexing %s with %s",getTypeName(self),getTypeName(key)); return false; }
if(!_array(self)->set(tointeger(key),val)) { if(!_array(self)->set(tointeger(key),val)) {
raise_Idxerror(key); raise_Idxerror(key);
return false; return false;
@ -1383,7 +1383,7 @@ bool rabbit::VirtualMachine::set(const rabbit::ObjectPtr &self,const rabbit::Obj
return true; return true;
case rabbit::OT_USERDATA: break; // must fall back case rabbit::OT_USERDATA: break; // must fall back
default: default:
raise_error(_SC("trying to set '%s'"),getTypeName(self)); raise_error("trying to set '%s'",getTypeName(self));
return false; return false;
} }
@ -1460,7 +1460,7 @@ cloned_mt:
target = _array(self)->clone(); target = _array(self)->clone();
return true; return true;
default: default:
raise_error(_SC("cloning a %s"), getTypeName(self)); raise_error("cloning a %s", getTypeName(self));
return false; return false;
} }
} }
@ -1468,7 +1468,7 @@ cloned_mt:
bool rabbit::VirtualMachine::newSlotA(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,const rabbit::ObjectPtr &attrs,bool bstatic,bool raw) bool rabbit::VirtualMachine::newSlotA(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,const rabbit::ObjectPtr &attrs,bool bstatic,bool raw)
{ {
if(sq_type(self) != rabbit::OT_CLASS) { if(sq_type(self) != rabbit::OT_CLASS) {
raise_error(_SC("object must be a class")); raise_error("object must be a class");
return false; return false;
} }
rabbit::Class *c = _class(self); rabbit::Class *c = _class(self);
@ -1491,7 +1491,7 @@ bool rabbit::VirtualMachine::newSlotA(const rabbit::ObjectPtr &self,const rabbit
bool rabbit::VirtualMachine::newSlot(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,bool bstatic) bool rabbit::VirtualMachine::newSlot(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,bool bstatic)
{ {
if(sq_type(key) == rabbit::OT_NULL) { raise_error(_SC("null cannot be used as index")); return false; } if(sq_type(key) == rabbit::OT_NULL) { raise_error("null cannot be used as index"); return false; }
switch(sq_type(self)) { switch(sq_type(self)) {
case rabbit::OT_TABLE: { case rabbit::OT_TABLE: {
bool rawcall = true; bool rawcall = true;
@ -1524,24 +1524,24 @@ bool rabbit::VirtualMachine::newSlot(const rabbit::ObjectPtr &self,const rabbit:
} }
break; break;
} }
raise_error(_SC("class instances do not support the new slot operator")); raise_error("class instances do not support the new slot operator");
return false; return false;
break;} break;}
case rabbit::OT_CLASS: case rabbit::OT_CLASS:
if(!_class(self)->newSlot(_get_shared_state(this),key,val,bstatic)) { if(!_class(self)->newSlot(_get_shared_state(this),key,val,bstatic)) {
if(_class(self)->_locked) { if(_class(self)->_locked) {
raise_error(_SC("trying to modify a class that has already been instantiated")); raise_error("trying to modify a class that has already been instantiated");
return false; return false;
} }
else { else {
rabbit::ObjectPtr oval = printObjVal(key); rabbit::ObjectPtr oval = printObjVal(key);
raise_error(_SC("the property '%s' already exists"),_stringval(oval)); raise_error("the property '%s' already exists",_stringval(oval));
return false; return false;
} }
} }
break; break;
default: default:
raise_error(_SC("indexing %s with %s"),getTypeName(self),getTypeName(key)); raise_error("indexing %s with %s",getTypeName(self),getTypeName(key));
return false; return false;
break; break;
} }
@ -1574,7 +1574,7 @@ bool rabbit::VirtualMachine::deleteSlot(const rabbit::ObjectPtr &self,const rabb
} }
} }
else { else {
raise_error(_SC("cannot delete a slot from %s"),getTypeName(self)); raise_error("cannot delete a slot from %s",getTypeName(self));
return false; return false;
} }
} }
@ -1582,7 +1582,7 @@ bool rabbit::VirtualMachine::deleteSlot(const rabbit::ObjectPtr &self,const rabb
} }
break; break;
default: default:
raise_error(_SC("attempt to delete a slot from a %s"),getTypeName(self)); raise_error("attempt to delete a slot from a %s",getTypeName(self));
return false; return false;
} }
return true; return true;
@ -1686,7 +1686,7 @@ bool rabbit::VirtualMachine::enterFrame(int64_t newbase, int64_t newtop, bool ta
_top = newtop; _top = newtop;
if(newtop + MIN_STACK_OVERHEAD > (int64_t)_stack.size()) { if(newtop + MIN_STACK_OVERHEAD > (int64_t)_stack.size()) {
if(_nmetamethodscall) { if(_nmetamethodscall) {
raise_error(_SC("stack overflow, cannot resize stack while in a metamethod")); raise_error("stack overflow, cannot resize stack while in a metamethod");
return false; return false;
} }
_stack.resize(newtop + (MIN_STACK_OVERHEAD << 2)); _stack.resize(newtop + (MIN_STACK_OVERHEAD << 2));
@ -1762,37 +1762,41 @@ void rabbit::VirtualMachine::dumpstack(int64_t stackbase,bool dumpall)
{ {
int64_t size=dumpall?_stack.size():_top; int64_t size=dumpall?_stack.size():_top;
int64_t n=0; int64_t n=0;
printf(_SC("\n>>>>stack dump<<<<\n")); printf("\n>>>>stack dump<<<<\n");
callInfo &ci=_callsstack[_callsstacksize-1]; callInfo &ci=_callsstack[_callsstacksize-1];
printf(_SC("IP: %p\n"),ci._ip); printf("IP: %p\n",ci._ip);
printf(_SC("prev stack base: %d\n"),ci._prevstkbase); printf("prev stack base: %d\n",ci._prevstkbase);
printf(_SC("prev top: %d\n"),ci._prevtop); printf("prev top: %d\n",ci._prevtop);
for(int64_t i=0;i<size;i++){ for(int64_t i=0;i<size;i++){
rabbit::ObjectPtr &obj=_stack[i]; rabbit::ObjectPtr &obj=_stack[i];
if(stackbase==i)printf(_SC(">"));else printf(_SC(" ")); if(stackbase==i) {
printf(_SC("[" _PRINT_INT_FMT "]:"),n); printf(">");
} else {
printf(" ");
}
printf("[" _PRINT_INT_FMT "]:",n);
switch(sq_type(obj)){ switch(sq_type(obj)){
case rabbit::OT_FLOAT: printf(_SC("FLOAT %.3f"),_float(obj));break; case rabbit::OT_FLOAT: printf("FLOAT %.3f",_float(obj));break;
case rabbit::OT_INTEGER: printf(_SC("INTEGER " _PRINT_INT_FMT),_integer(obj));break; case rabbit::OT_INTEGER: printf("INTEGER " _PRINT_INT_FMT,_integer(obj));break;
case rabbit::OT_BOOL: printf(_SC("BOOL %s"),_integer(obj)?"true":"false");break; case rabbit::OT_BOOL: printf("BOOL %s",_integer(obj)?"true":"false");break;
case rabbit::OT_STRING: printf(_SC("STRING %s"),_stringval(obj));break; case rabbit::OT_STRING: printf("STRING %s",_stringval(obj));break;
case rabbit::OT_NULL: printf(_SC("NULL")); break; case rabbit::OT_NULL: printf("NULL"); break;
case rabbit::OT_TABLE: printf(_SC("TABLE %p[%p]"),_table(obj),_table(obj)->_delegate);break; case rabbit::OT_TABLE: printf("TABLE %p[%p]",_table(obj),_table(obj)->_delegate);break;
case rabbit::OT_ARRAY: printf(_SC("ARRAY %p"),_array(obj));break; case rabbit::OT_ARRAY: printf("ARRAY %p",_array(obj));break;
case rabbit::OT_CLOSURE: printf(_SC("CLOSURE [%p]"),_closure(obj));break; case rabbit::OT_CLOSURE: printf("CLOSURE [%p]",_closure(obj));break;
case rabbit::OT_NATIVECLOSURE: printf(_SC("NATIVECLOSURE"));break; case rabbit::OT_NATIVECLOSURE: printf("NATIVECLOSURE");break;
case rabbit::OT_USERDATA: printf(_SC("USERDATA %p[%p]"),_userdataval(obj),_userdata(obj)->_delegate);break; case rabbit::OT_USERDATA: printf("USERDATA %p[%p]",_userdataval(obj),_userdata(obj)->_delegate);break;
case rabbit::OT_GENERATOR: printf(_SC("GENERATOR %p"),_generator(obj));break; case rabbit::OT_GENERATOR: printf("GENERATOR %p",_generator(obj));break;
case rabbit::OT_THREAD: printf(_SC("THREAD [%p]"),_thread(obj));break; case rabbit::OT_THREAD: printf("THREAD [%p]",_thread(obj));break;
case rabbit::OT_USERPOINTER: printf(_SC("USERPOINTER %p"),_userpointer(obj));break; case rabbit::OT_USERPOINTER: printf("USERPOINTER %p",_userpointer(obj));break;
case rabbit::OT_CLASS: printf(_SC("CLASS %p"),_class(obj));break; case rabbit::OT_CLASS: printf("CLASS %p",_class(obj));break;
case rabbit::OT_INSTANCE: printf(_SC("INSTANCE %p"),_instance(obj));break; case rabbit::OT_INSTANCE: printf("INSTANCE %p",_instance(obj));break;
case rabbit::OT_WEAKREF: printf(_SC("WEAKERF %p"),_weakref(obj));break; case rabbit::OT_WEAKREF: printf("WEAKERF %p",_weakref(obj));break;
default: default:
assert(0); assert(0);
break; break;
}; };
printf(_SC("\n")); printf("\n");
++n; ++n;
} }
} }

6
rabbit/rabbit.hpp
View File

@ -19,9 +19,9 @@
#include "sqconfig.hpp" #include "sqconfig.hpp"
#define RABBIT_VERSION _SC("Rabbit 0.1 un-stable") #define RABBIT_VERSION "Rabbit 0.1 un-stable"
#define RABBIT_COPYRIGHT _SC("Copyright (C) 2003-2017 Alberto Demichelis") #define RABBIT_COPYRIGHT "Copyright (C) 2003-2017 Alberto Demichelis"
#define RABBIT_AUTHOR _SC("Edouard DUPIN") #define RABBIT_AUTHOR "Edouard DUPIN"
#define RABBIT_VERSION_NUMBER 010 #define RABBIT_VERSION_NUMBER 010
#define SQ_VMSTATE_IDLE 0 #define SQ_VMSTATE_IDLE 0

128
rabbit/sqapi.cpp
View File

@ -35,7 +35,7 @@ static bool sq_aux_gettypedarg(rabbit::VirtualMachine* v,int64_t idx,rabbit::Obj
*o = &stack_get(v,idx); *o = &stack_get(v,idx);
if(sq_type(**o) != type){ if(sq_type(**o) != type){
rabbit::ObjectPtr oval = v->printObjVal(**o); rabbit::ObjectPtr oval = v->printObjVal(**o);
v->raise_error(_SC("wrong argument type, expected '%s' got '%.50s'"),IdType2Name(type),_stringval(oval)); v->raise_error("wrong argument type, expected '%s' got '%.50s'",IdType2Name(type),_stringval(oval));
return false; return false;
} }
return true; return true;
@ -45,14 +45,14 @@ static bool sq_aux_gettypedarg(rabbit::VirtualMachine* v,int64_t idx,rabbit::Obj
#define sq_aux_paramscheck(v,count) \ #define sq_aux_paramscheck(v,count) \
{ \ { \
if(sq_gettop(v) < count){ v->raise_error(_SC("not enough params in the stack")); return SQ_ERROR; }\ if(sq_gettop(v) < count){ v->raise_error("not enough params in the stack"); return SQ_ERROR; }\
} }
namespace rabbit { namespace rabbit {
int64_t sq_aux_invalidtype(rabbit::VirtualMachine* v,rabbit::ObjectType type) int64_t sq_aux_invalidtype(rabbit::VirtualMachine* v,rabbit::ObjectType type)
{ {
uint64_t buf_size = 100 *sizeof(char); uint64_t buf_size = 100 *sizeof(char);
snprintf(_get_shared_state(v)->getScratchPad(buf_size), buf_size, _SC("unexpected type %s"), IdType2Name(type)); snprintf(_get_shared_state(v)->getScratchPad(buf_size), buf_size, "unexpected type %s", IdType2Name(type));
return sq_throwerror(v, _get_shared_state(v)->getScratchPad(-1)); return sq_throwerror(v, _get_shared_state(v)->getScratchPad(-1));
} }
} }
@ -154,7 +154,7 @@ rabbit::Result rabbit::sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,r
} }
return SQ_ERROR; return SQ_ERROR;
#else #else
return sq_throwerror(v,_SC("this is a no compiler build")); return sq_throwerror(v,"this is a no compiler build");
#endif #endif
} }
@ -299,7 +299,7 @@ rabbit::Result rabbit::sq_newclass(rabbit::VirtualMachine* v,rabbit::Bool hasbas
if(hasbase) { if(hasbase) {
rabbit::ObjectPtr &base = stack_get(v,-1); rabbit::ObjectPtr &base = stack_get(v,-1);
if(sq_type(base) != rabbit::OT_CLASS) if(sq_type(base) != rabbit::OT_CLASS)
return sq_throwerror(v,_SC("invalid base type")); return sq_throwerror(v,"invalid base type");
baseclass = _class(base); baseclass = _class(base);
} }
rabbit::Class *newclass = rabbit::Class::create(_get_shared_state(v), baseclass); rabbit::Class *newclass = rabbit::Class::create(_get_shared_state(v), baseclass);
@ -314,7 +314,7 @@ rabbit::Bool rabbit::sq_instanceof(rabbit::VirtualMachine* v)
rabbit::ObjectPtr &cl = stack_get(v,-2); rabbit::ObjectPtr &cl = stack_get(v,-2);
if( sq_type(inst) != rabbit::OT_INSTANCE if( sq_type(inst) != rabbit::OT_INSTANCE
|| sq_type(cl) != rabbit::OT_CLASS) || sq_type(cl) != rabbit::OT_CLASS)
return sq_throwerror(v,_SC("invalid param type")); return sq_throwerror(v,"invalid param type");
return _instance(inst)->instanceOf(_class(cl))?SQTrue:SQFalse; return _instance(inst)->instanceOf(_class(cl))?SQTrue:SQFalse;
} }
@ -340,7 +340,7 @@ rabbit::Result rabbit::sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,rabbit:
_array(*arr)->pop(); _array(*arr)->pop();
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v, _SC("empty array")); return sq_throwerror(v, "empty array");
} }
rabbit::Result rabbit::sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t newsize) rabbit::Result rabbit::sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t newsize)
@ -352,7 +352,7 @@ rabbit::Result rabbit::sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int6
_array(*arr)->resize(newsize); _array(*arr)->resize(newsize);
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v,_SC("negative size")); return sq_throwerror(v,"negative size");
} }
@ -382,7 +382,7 @@ rabbit::Result rabbit::sq_arrayremove(rabbit::VirtualMachine* v,int64_t idx,int6
sq_aux_paramscheck(v, 1); sq_aux_paramscheck(v, 1);
rabbit::ObjectPtr *arr; rabbit::ObjectPtr *arr;
_GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr); _GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr);
return _array(*arr)->remove(itemidx) ? SQ_OK : sq_throwerror(v,_SC("index out of range")); return _array(*arr)->remove(itemidx) ? SQ_OK : sq_throwerror(v,"index out of range");
} }
rabbit::Result rabbit::sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int64_t destpos) rabbit::Result rabbit::sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int64_t destpos)
@ -390,7 +390,7 @@ rabbit::Result rabbit::sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int6
sq_aux_paramscheck(v, 1); sq_aux_paramscheck(v, 1);
rabbit::ObjectPtr *arr; rabbit::ObjectPtr *arr;
_GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr); _GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr);
rabbit::Result ret = _array(*arr)->insert(destpos, v->getUp(-1)) ? SQ_OK : sq_throwerror(v,_SC("index out of range")); rabbit::Result ret = _array(*arr)->insert(destpos, v->getUp(-1)) ? SQ_OK : sq_throwerror(v,"index out of range");
v->pop(); v->pop();
return ret; return ret;
} }
@ -423,7 +423,7 @@ rabbit::Result rabbit::sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,u
*nfreevars = c->_noutervalues; *nfreevars = c->_noutervalues;
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v,_SC("the object is not a closure")); return sq_throwerror(v,"the object is not a closure");
} }
rabbit::Result rabbit::sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const char *name) rabbit::Result rabbit::sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const char *name)
@ -434,20 +434,20 @@ rabbit::Result rabbit::sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t
nc->_name = rabbit::String::create(_get_shared_state(v),name); nc->_name = rabbit::String::create(_get_shared_state(v),name);
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v,_SC("the object is not a nativeclosure")); return sq_throwerror(v,"the object is not a nativeclosure");
} }
rabbit::Result rabbit::sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const char *typemask) rabbit::Result rabbit::sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const char *typemask)
{ {
rabbit::Object o = stack_get(v, -1); rabbit::Object o = stack_get(v, -1);
if(!sq_isnativeclosure(o)) if(!sq_isnativeclosure(o))
return sq_throwerror(v, _SC("native closure expected")); return sq_throwerror(v, "native closure expected");
rabbit::NativeClosure *nc = _nativeclosure(o); rabbit::NativeClosure *nc = _nativeclosure(o);
nc->_nparamscheck = nparamscheck; nc->_nparamscheck = nparamscheck;
if(typemask) { if(typemask) {
etk::Vector<int64_t> res; etk::Vector<int64_t> res;
if(!compileTypemask(res, typemask)) if(!compileTypemask(res, typemask))
return sq_throwerror(v, _SC("invalid typemask")); return sq_throwerror(v, "invalid typemask");
nc->_typecheck = res; nc->_typecheck = res;
} }
else { else {
@ -464,13 +464,13 @@ rabbit::Result rabbit::sq_bindenv(rabbit::VirtualMachine* v,int64_t idx)
rabbit::ObjectPtr &o = stack_get(v,idx); rabbit::ObjectPtr &o = stack_get(v,idx);
if(!sq_isnativeclosure(o) && if(!sq_isnativeclosure(o) &&
!sq_isclosure(o)) !sq_isclosure(o))
return sq_throwerror(v,_SC("the target is not a closure")); return sq_throwerror(v, "the target is not a closure");
rabbit::ObjectPtr &env = stack_get(v,-1); rabbit::ObjectPtr &env = stack_get(v,-1);
if(!sq_istable(env) && if(!sq_istable(env) &&
!sq_isarray(env) && !sq_isarray(env) &&
!sq_isclass(env) && !sq_isclass(env) &&
!sq_isinstance(env)) !sq_isinstance(env))
return sq_throwerror(v,_SC("invalid environment")); return sq_throwerror(v,"invalid environment");
rabbit::WeakRef *w = _refcounted(env)->getWeakRef(sq_type(env)); rabbit::WeakRef *w = _refcounted(env)->getWeakRef(sq_type(env));
rabbit::ObjectPtr ret; rabbit::ObjectPtr ret;
if(sq_isclosure(o)) { if(sq_isclosure(o)) {
@ -501,7 +501,7 @@ rabbit::Result rabbit::sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx)
rabbit::ObjectPtr &o = stack_get(v,idx); rabbit::ObjectPtr &o = stack_get(v,idx);
if(!sq_isnativeclosure(o) && if(!sq_isnativeclosure(o) &&
!sq_isclosure(o)) !sq_isclosure(o))
return sq_throwerror(v,_SC("the target is not a closure")); return sq_throwerror(v,"the target is not a closure");
if(sq_isnativeclosure(o)) if(sq_isnativeclosure(o))
{ {
v->push(_nativeclosure(o)->_name); v->push(_nativeclosure(o)->_name);
@ -516,19 +516,19 @@ rabbit::Result rabbit::sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx)
{ {
rabbit::ObjectPtr &c = stack_get(v,idx); rabbit::ObjectPtr &c = stack_get(v,idx);
rabbit::Object o = stack_get(v, -1); rabbit::Object o = stack_get(v, -1);
if(!sq_isclosure(c)) return sq_throwerror(v, _SC("closure expected")); if(!sq_isclosure(c)) return sq_throwerror(v, "closure expected");
if(sq_istable(o)) { if(sq_istable(o)) {
_closure(c)->setRoot(_table(o)->getWeakRef(rabbit::OT_TABLE)); _closure(c)->setRoot(_table(o)->getWeakRef(rabbit::OT_TABLE));
v->pop(); v->pop();
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v, _SC("invalid type")); return sq_throwerror(v, "invalid type");
} }
rabbit::Result rabbit::sq_getclosureroot(rabbit::VirtualMachine* v,int64_t idx) rabbit::Result rabbit::sq_getclosureroot(rabbit::VirtualMachine* v,int64_t idx)
{ {
rabbit::ObjectPtr &c = stack_get(v,idx); rabbit::ObjectPtr &c = stack_get(v,idx);
if(!sq_isclosure(c)) return sq_throwerror(v, _SC("closure expected")); if(!sq_isclosure(c)) return sq_throwerror(v, "closure expected");
v->push(_closure(c)->_root->_obj); v->push(_closure(c)->_root->_obj);
return SQ_OK; return SQ_OK;
} }
@ -540,7 +540,7 @@ rabbit::Result rabbit::sq_clear(rabbit::VirtualMachine* v,int64_t idx)
case rabbit::OT_TABLE: _table(o)->clear(); break; case rabbit::OT_TABLE: _table(o)->clear(); break;
case rabbit::OT_ARRAY: _array(o)->resize(0); break; case rabbit::OT_ARRAY: _array(o)->resize(0); break;
default: default:
return sq_throwerror(v, _SC("clear only works on table and array")); return sq_throwerror(v, "clear only works on table and array");
break; break;
} }
@ -570,7 +570,7 @@ rabbit::Result rabbit::sq_setroottable(rabbit::VirtualMachine* v)
v->pop(); v->pop();
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v, _SC("invalid type")); return sq_throwerror(v, "invalid type");
} }
rabbit::Result rabbit::sq_setconsttable(rabbit::VirtualMachine* v) rabbit::Result rabbit::sq_setconsttable(rabbit::VirtualMachine* v)
@ -581,7 +581,7 @@ rabbit::Result rabbit::sq_setconsttable(rabbit::VirtualMachine* v)
v->pop(); v->pop();
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v, _SC("invalid type, expected table")); return sq_throwerror(v, "invalid type, expected table");
} }
void rabbit::sq_setforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p) void rabbit::sq_setforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p)
@ -776,7 +776,7 @@ rabbit::Result rabbit::sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,rabbi
_class(o)->_typetag = typetag; _class(o)->_typetag = typetag;
break; break;
default: default:
return sq_throwerror(v,_SC("invalid object type")); return sq_throwerror(v,"invalid object type");
} }
return SQ_OK; return SQ_OK;
} }
@ -811,7 +811,7 @@ rabbit::Result rabbit::sq_getuserpointer(rabbit::VirtualMachine* v, int64_t idx,
rabbit::Result rabbit::sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer p) rabbit::Result rabbit::sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer p)
{ {
rabbit::ObjectPtr &o = stack_get(v,idx); rabbit::ObjectPtr &o = stack_get(v,idx);
if(sq_type(o) != rabbit::OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance")); if(sq_type(o) != rabbit::OT_INSTANCE) return sq_throwerror(v,"the object is not a class instance");
_instance(o)->_userpointer = p; _instance(o)->_userpointer = p;
return SQ_OK; return SQ_OK;
} }
@ -819,8 +819,8 @@ rabbit::Result rabbit::sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx,
rabbit::Result rabbit::sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize) rabbit::Result rabbit::sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize)
{ {
rabbit::ObjectPtr &o = stack_get(v,idx); rabbit::ObjectPtr &o = stack_get(v,idx);
if(sq_type(o) != rabbit::OT_CLASS) return sq_throwerror(v,_SC("the object is not a class")); if(sq_type(o) != rabbit::OT_CLASS) return sq_throwerror(v,"the object is not a class");
if(_class(o)->_locked) return sq_throwerror(v,_SC("the class is locked")); if(_class(o)->_locked) return sq_throwerror(v,"the class is locked");
_class(o)->_udsize = udsize; _class(o)->_udsize = udsize;
return SQ_OK; return SQ_OK;
} }
@ -829,7 +829,7 @@ rabbit::Result rabbit::sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx,
rabbit::Result rabbit::sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p,rabbit::UserPointer typetag) rabbit::Result rabbit::sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p,rabbit::UserPointer typetag)
{ {
rabbit::ObjectPtr &o = stack_get(v,idx); rabbit::ObjectPtr &o = stack_get(v,idx);
if(sq_type(o) != rabbit::OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance")); if(sq_type(o) != rabbit::OT_INSTANCE) return sq_throwerror(v,"the object is not a class instance");
(*p) = _instance(o)->_userpointer; (*p) = _instance(o)->_userpointer;
if(typetag != 0) { if(typetag != 0) {
rabbit::Class *cl = _instance(o)->_class; rabbit::Class *cl = _instance(o)->_class;
@ -838,7 +838,7 @@ rabbit::Result rabbit::sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx,
return SQ_OK; return SQ_OK;
cl = cl->_base; cl = cl->_base;
}while(cl != NULL); }while(cl != NULL);
return sq_throwerror(v,_SC("invalid type tag")); return sq_throwerror(v,"invalid type tag");
} }
return SQ_OK; return SQ_OK;
} }
@ -888,7 +888,7 @@ rabbit::Result rabbit::sq_newslot(rabbit::VirtualMachine* v, int64_t idx, rabbit
rabbit::ObjectPtr &self = stack_get(v, idx); rabbit::ObjectPtr &self = stack_get(v, idx);
if(sq_type(self) == rabbit::OT_TABLE || sq_type(self) == rabbit::OT_CLASS) { if(sq_type(self) == rabbit::OT_TABLE || sq_type(self) == rabbit::OT_CLASS) {
rabbit::ObjectPtr &key = v->getUp(-2); rabbit::ObjectPtr &key = v->getUp(-2);
if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, _SC("null is not a valid key")); if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, "null is not a valid key");
v->newSlot(self, key, v->getUp(-1),bstatic?true:false); v->newSlot(self, key, v->getUp(-1),bstatic?true:false);
v->pop(2); v->pop(2);
} }
@ -901,7 +901,7 @@ rabbit::Result rabbit::sq_deleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbi
rabbit::ObjectPtr *self; rabbit::ObjectPtr *self;
_GETSAFE_OBJ(v, idx, rabbit::OT_TABLE,self); _GETSAFE_OBJ(v, idx, rabbit::OT_TABLE,self);
rabbit::ObjectPtr &key = v->getUp(-1); rabbit::ObjectPtr &key = v->getUp(-1);
if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, _SC("null is not a valid key")); if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, "null is not a valid key");
rabbit::ObjectPtr res; rabbit::ObjectPtr res;
if(!v->deleteSlot(*self, key, res)){ if(!v->deleteSlot(*self, key, res)){
v->pop(); v->pop();
@ -928,7 +928,7 @@ rabbit::Result rabbit::sq_rawset(rabbit::VirtualMachine* v,int64_t idx)
rabbit::ObjectPtr &key = v->getUp(-2); rabbit::ObjectPtr &key = v->getUp(-2);
if(sq_type(key) == rabbit::OT_NULL) { if(sq_type(key) == rabbit::OT_NULL) {
v->pop(2); v->pop(2);
return sq_throwerror(v, _SC("null key")); return sq_throwerror(v, "null key");
} }
switch(sq_type(self)) { switch(sq_type(self)) {
case rabbit::OT_TABLE: case rabbit::OT_TABLE:
@ -955,7 +955,7 @@ rabbit::Result rabbit::sq_rawset(rabbit::VirtualMachine* v,int64_t idx)
break; break;
default: default:
v->pop(2); v->pop(2);
return sq_throwerror(v, _SC("rawset works only on array/table/class and instance")); return sq_throwerror(v, "rawset works only on array/table/class and instance");
} }
v->raise_Idxerror(v->getUp(-2));return SQ_ERROR; v->raise_Idxerror(v->getUp(-2));return SQ_ERROR;
} }
@ -963,9 +963,9 @@ rabbit::Result rabbit::sq_rawset(rabbit::VirtualMachine* v,int64_t idx)
rabbit::Result rabbit::sq_newmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic) rabbit::Result rabbit::sq_newmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic)
{ {
rabbit::ObjectPtr &self = stack_get(v, idx); rabbit::ObjectPtr &self = stack_get(v, idx);
if(sq_type(self) != rabbit::OT_CLASS) return sq_throwerror(v, _SC("new member only works with classes")); if(sq_type(self) != rabbit::OT_CLASS) return sq_throwerror(v, "new member only works with classes");
rabbit::ObjectPtr &key = v->getUp(-3); rabbit::ObjectPtr &key = v->getUp(-3);
if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, _SC("null key")); if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, "null key");
if(!v->newSlotA(self,key,v->getUp(-2),v->getUp(-1),bstatic?true:false,false)) { if(!v->newSlotA(self,key,v->getUp(-2),v->getUp(-1),bstatic?true:false,false)) {
v->pop(3); v->pop(3);
return SQ_ERROR; return SQ_ERROR;
@ -977,9 +977,9 @@ rabbit::Result rabbit::sq_newmember(rabbit::VirtualMachine* v,int64_t idx,rabbit
rabbit::Result rabbit::sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic) rabbit::Result rabbit::sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic)
{ {
rabbit::ObjectPtr &self = stack_get(v, idx); rabbit::ObjectPtr &self = stack_get(v, idx);
if(sq_type(self) != rabbit::OT_CLASS) return sq_throwerror(v, _SC("new member only works with classes")); if(sq_type(self) != rabbit::OT_CLASS) return sq_throwerror(v, "new member only works with classes");
rabbit::ObjectPtr &key = v->getUp(-3); rabbit::ObjectPtr &key = v->getUp(-3);
if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, _SC("null key")); if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, "null key");
if(!v->newSlotA(self,key,v->getUp(-2),v->getUp(-1),bstatic?true:false,true)) { if(!v->newSlotA(self,key,v->getUp(-2),v->getUp(-1),bstatic?true:false,true)) {
v->pop(3); v->pop(3);
return SQ_ERROR; return SQ_ERROR;
@ -997,7 +997,7 @@ rabbit::Result rabbit::sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx)
case rabbit::OT_TABLE: case rabbit::OT_TABLE:
if(sq_type(mt) == rabbit::OT_TABLE) { if(sq_type(mt) == rabbit::OT_TABLE) {
if(!_table(self)->setDelegate(_table(mt))) { if(!_table(self)->setDelegate(_table(mt))) {
return sq_throwerror(v, _SC("delagate cycle")); return sq_throwerror(v, "delagate cycle");
} }
v->pop(); v->pop();
} }
@ -1048,7 +1048,7 @@ rabbit::Result rabbit::sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx)
} }
v->push(rabbit::ObjectPtr(_delegable(self)->_delegate)); v->push(rabbit::ObjectPtr(_delegable(self)->_delegate));
break; break;
default: return sq_throwerror(v,_SC("wrong type")); break; default: return sq_throwerror(v,"wrong type"); break;
} }
return SQ_OK; return SQ_OK;
@ -1089,16 +1089,16 @@ rabbit::Result rabbit::sq_rawget(rabbit::VirtualMachine* v,int64_t idx)
} }
else { else {
v->pop(); v->pop();
return sq_throwerror(v,_SC("invalid index type for an array")); return sq_throwerror(v,"invalid index type for an array");
} }
} }
break; break;
default: default:
v->pop(); v->pop();
return sq_throwerror(v,_SC("rawget works only on array/table/instance and class")); return sq_throwerror(v,"rawget works only on array/table/instance and class");
} }
v->pop(); v->pop();
return sq_throwerror(v,_SC("the index doesn't exist")); return sq_throwerror(v,"the index doesn't exist");
} }
rabbit::Result rabbit::sq_getstackobj(rabbit::VirtualMachine* v,int64_t idx,rabbit::Object *po) rabbit::Result rabbit::sq_getstackobj(rabbit::VirtualMachine* v,int64_t idx,rabbit::Object *po)
@ -1170,7 +1170,7 @@ rabbit::Result rabbit::sq_reservestack(rabbit::VirtualMachine* v,int64_t nsize)
{ {
if (((uint64_t)v->_top + nsize) > v->_stack.size()) { if (((uint64_t)v->_top + nsize) > v->_stack.size()) {
if(v->_nmetamethodscall) { if(v->_nmetamethodscall) {
return sq_throwerror(v,_SC("cannot resize stack while in a metamethod")); return sq_throwerror(v,"cannot resize stack while in a metamethod");
} }
v->_stack.resize(v->_stack.size() + ((v->_top + nsize) - v->_stack.size())); v->_stack.resize(v->_stack.size() + ((v->_top + nsize) - v->_stack.size()));
} }
@ -1188,7 +1188,7 @@ rabbit::Result rabbit::sq_resume(rabbit::VirtualMachine* v,rabbit::Bool retval,r
v->pop(); v->pop();
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v,_SC("only generators can be resumed")); return sq_throwerror(v,"only generators can be resumed");
} }
rabbit::Result rabbit::sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::Bool retval,rabbit::Bool raiseerror) rabbit::Result rabbit::sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::Bool retval,rabbit::Bool raiseerror)
@ -1210,19 +1210,19 @@ rabbit::Result rabbit::sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::
} }
if(!v->_suspended) if(!v->_suspended)
v->pop(params); v->pop(params);
return sq_throwerror(v,_SC("call failed")); return sq_throwerror(v,"call failed");
} }
rabbit::Result rabbit::sq_tailcall(rabbit::VirtualMachine* v, int64_t nparams) rabbit::Result rabbit::sq_tailcall(rabbit::VirtualMachine* v, int64_t nparams)
{ {
rabbit::ObjectPtr &res = v->getUp(-(nparams + 1)); rabbit::ObjectPtr &res = v->getUp(-(nparams + 1));
if (sq_type(res) != rabbit::OT_CLOSURE) { if (sq_type(res) != rabbit::OT_CLOSURE) {
return sq_throwerror(v, _SC("only closure can be tail called")); return sq_throwerror(v, "only closure can be tail called");
} }
rabbit::Closure *clo = _closure(res); rabbit::Closure *clo = _closure(res);
if (clo->_function->_bgenerator) if (clo->_function->_bgenerator)
{ {
return sq_throwerror(v, _SC("generators cannot be tail called")); return sq_throwerror(v, "generators cannot be tail called");
} }
int64_t stackbase = (v->_top - nparams) - v->_stackbase; int64_t stackbase = (v->_top - nparams) - v->_stackbase;
@ -1241,7 +1241,7 @@ rabbit::Result rabbit::sq_wakeupvm(rabbit::VirtualMachine* v,rabbit::Bool wakeup
{ {
rabbit::ObjectPtr ret; rabbit::ObjectPtr ret;
if(!v->_suspended) if(!v->_suspended)
return sq_throwerror(v,_SC("cannot resume a vm that is not running any code")); return sq_throwerror(v,"cannot resume a vm that is not running any code");
int64_t target = v->_suspended_target; int64_t target = v->_suspended_target;
if(wakeupret) { if(wakeupret) {
if(target != -1) { if(target != -1) {
@ -1306,9 +1306,9 @@ rabbit::Result rabbit::sq_writeclosure(rabbit::VirtualMachine* v,SQWRITEFUNC w,r
_GETSAFE_OBJ(v, -1, rabbit::OT_CLOSURE,o); _GETSAFE_OBJ(v, -1, rabbit::OT_CLOSURE,o);
unsigned short tag = SQ_BYTECODE_STREAM_TAG; unsigned short tag = SQ_BYTECODE_STREAM_TAG;
if(_closure(*o)->_function->_noutervalues) if(_closure(*o)->_function->_noutervalues)
return sq_throwerror(v,_SC("a closure with free variables bound cannot be serialized")); return sq_throwerror(v,"a closure with free variables bound cannot be serialized");
if(w(up,&tag,2) != 2) if(w(up,&tag,2) != 2)
return sq_throwerror(v,_SC("io error")); return sq_throwerror(v,"io error");
if(!_closure(*o)->save(v,up,w)) if(!_closure(*o)->save(v,up,w))
return SQ_ERROR; return SQ_ERROR;
return SQ_OK; return SQ_OK;
@ -1320,9 +1320,9 @@ rabbit::Result rabbit::sq_readclosure(rabbit::VirtualMachine* v,SQREADFUNC r,rab
unsigned short tag; unsigned short tag;
if(r(up,&tag,2) != 2) if(r(up,&tag,2) != 2)
return sq_throwerror(v,_SC("io error")); return sq_throwerror(v,"io error");
if(tag != SQ_BYTECODE_STREAM_TAG) if(tag != SQ_BYTECODE_STREAM_TAG)
return sq_throwerror(v,_SC("invalid stream")); return sq_throwerror(v,"invalid stream");
if(!rabbit::Closure::load(v,up,r,closure)) if(!rabbit::Closure::load(v,up,r,closure))
return SQ_ERROR; return SQ_ERROR;
v->push(closure); v->push(closure);
@ -1336,7 +1336,7 @@ char * rabbit::sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize)
rabbit::Result rabbit::sq_resurrectunreachable(rabbit::VirtualMachine* v) rabbit::Result rabbit::sq_resurrectunreachable(rabbit::VirtualMachine* v)
{ {
return sq_throwerror(v,_SC("sq_resurrectunreachable requires a garbage collector build")); return sq_throwerror(v,"sq_resurrectunreachable requires a garbage collector build");
} }
// TODO: remove this... // TODO: remove this...
@ -1352,7 +1352,7 @@ rabbit::Result rabbit::sq_getcallee(rabbit::VirtualMachine* v)
v->push(v->_callsstack[v->_callsstacksize - 2]._closure); v->push(v->_callsstack[v->_callsstacksize - 2]._closure);
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v,_SC("no closure in the calls stack")); return sq_throwerror(v,"no closure in the calls stack");
} }
const char * rabbit::sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval) const char * rabbit::sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval)
@ -1375,7 +1375,7 @@ const char * rabbit::sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,ui
rabbit::NativeClosure *clo = _nativeclosure(self); rabbit::NativeClosure *clo = _nativeclosure(self);
if(clo->_noutervalues > nval) { if(clo->_noutervalues > nval) {
v->push(clo->_outervalues[nval]); v->push(clo->_outervalues[nval]);
name = _SC("@NATIVE"); name = "@NATIVE";
} }
} }
break; break;
@ -1394,14 +1394,14 @@ rabbit::Result rabbit::sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,
if(((uint64_t)fp->_noutervalues) > nval){ if(((uint64_t)fp->_noutervalues) > nval){
*(_outer(_closure(self)->_outervalues[nval])->_valptr) = stack_get(v,-1); *(_outer(_closure(self)->_outervalues[nval])->_valptr) = stack_get(v,-1);
} }
else return sq_throwerror(v,_SC("invalid free var index")); else return sq_throwerror(v,"invalid free var index");
} }
break; break;
case rabbit::OT_NATIVECLOSURE: case rabbit::OT_NATIVECLOSURE:
if(_nativeclosure(self)->_noutervalues > nval){ if(_nativeclosure(self)->_noutervalues > nval){
_nativeclosure(self)->_outervalues[nval] = stack_get(v,-1); _nativeclosure(self)->_outervalues[nval] = stack_get(v,-1);
} }
else return sq_throwerror(v,_SC("invalid free var index")); else return sq_throwerror(v,"invalid free var index");
break; break;
default: default:
return sq_aux_invalidtype(v, sq_type(self)); return sq_aux_invalidtype(v, sq_type(self));
@ -1429,7 +1429,7 @@ rabbit::Result rabbit::sq_setattributes(rabbit::VirtualMachine* v,int64_t idx)
v->push(attrs); v->push(attrs);
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v,_SC("wrong index")); return sq_throwerror(v,"wrong index");
} }
rabbit::Result rabbit::sq_getattributes(rabbit::VirtualMachine* v,int64_t idx) rabbit::Result rabbit::sq_getattributes(rabbit::VirtualMachine* v,int64_t idx)
@ -1449,7 +1449,7 @@ rabbit::Result rabbit::sq_getattributes(rabbit::VirtualMachine* v,int64_t idx)
v->push(attrs); v->push(attrs);
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v,_SC("wrong index")); return sq_throwerror(v,"wrong index");
} }
rabbit::Result rabbit::sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,rabbit::MemberHandle *handle) rabbit::Result rabbit::sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,rabbit::MemberHandle *handle)
@ -1465,7 +1465,7 @@ rabbit::Result rabbit::sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,
v->pop(); v->pop();
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v,_SC("wrong index")); return sq_throwerror(v,"wrong index");
} }
rabbit::Result _getmemberbyhandle(rabbit::VirtualMachine* v,rabbit::ObjectPtr &self,const rabbit::MemberHandle *handle,rabbit::ObjectPtr *&val) rabbit::Result _getmemberbyhandle(rabbit::VirtualMachine* v,rabbit::ObjectPtr &self,const rabbit::MemberHandle *handle,rabbit::ObjectPtr *&val)
@ -1494,7 +1494,7 @@ rabbit::Result _getmemberbyhandle(rabbit::VirtualMachine* v,rabbit::ObjectPtr &s
} }
break; break;
default: default:
return sq_throwerror(v,_SC("wrong type(expected class or instance)")); return sq_throwerror(v,"wrong type(expected class or instance)");
} }
return SQ_OK; return SQ_OK;
} }
@ -1564,7 +1564,7 @@ rabbit::Result rabbit::sq_getweakrefval(rabbit::VirtualMachine* v,int64_t idx)
{ {
rabbit::ObjectPtr &o = stack_get(v,idx); rabbit::ObjectPtr &o = stack_get(v,idx);
if(sq_type(o) != rabbit::OT_WEAKREF) { if(sq_type(o) != rabbit::OT_WEAKREF) {
return sq_throwerror(v,_SC("the object must be a weakref")); return sq_throwerror(v,"the object must be a weakref");
} }
v->push(_weakref(o)->_obj); v->push(_weakref(o)->_obj);
return SQ_OK; return SQ_OK;
@ -1584,7 +1584,7 @@ rabbit::Result rabbit::sq_getdefaultdelegate(rabbit::VirtualMachine* v,rabbit::O
case rabbit::OT_CLASS: v->push(ss->_class_default_delegate); break; case rabbit::OT_CLASS: v->push(ss->_class_default_delegate); break;
case rabbit::OT_INSTANCE: v->push(ss->_instance_default_delegate); break; case rabbit::OT_INSTANCE: v->push(ss->_instance_default_delegate); break;
case rabbit::OT_WEAKREF: v->push(ss->_weakref_default_delegate); break; case rabbit::OT_WEAKREF: v->push(ss->_weakref_default_delegate); break;
default: return sq_throwerror(v,_SC("the type doesn't have a default delegate")); default: return sq_throwerror(v,"the type doesn't have a default delegate");
} }
return SQ_OK; return SQ_OK;
} }
@ -1593,7 +1593,7 @@ rabbit::Result rabbit::sq_next(rabbit::VirtualMachine* v,int64_t idx)
{ {
rabbit::ObjectPtr o=stack_get(v,idx),&refpos = stack_get(v,-1),realkey,val; rabbit::ObjectPtr o=stack_get(v,idx),&refpos = stack_get(v,-1),realkey,val;
if(sq_type(o) == rabbit::OT_GENERATOR) { if(sq_type(o) == rabbit::OT_GENERATOR) {
return sq_throwerror(v,_SC("cannot iterate a generator")); return sq_throwerror(v,"cannot iterate a generator");
} }
int faketojump; int faketojump;
if(!v->FOREACH_OP(o,realkey,val,refpos,0,666,faketojump)) if(!v->FOREACH_OP(o,realkey,val,refpos,0,666,faketojump))

332
rabbit/sqbaselib.cpp
View File

@ -33,9 +33,9 @@ static bool str2num(const char *s,rabbit::ObjectPtr &res,int64_t base)
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;
char c; char c;
while((c = *e) != _SC('\0')) while((c = *e) != '\0')
{ {
if (c == _SC('.') || (!iseintbase && (c == _SC('E') || c == _SC('e')))) { //e and E is for scientific notation if (c == '.' || (!iseintbase && (c == 'E' || c == 'e'))) { //e and E is for scientific notation
isfloat = true; isfloat = true;
break; break;
} }
@ -116,21 +116,21 @@ static int64_t __getcallstackinfos(rabbit::VirtualMachine* v,int64_t level)
if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si))) if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si)))
{ {
const char *fn = _SC("unknown"); const char *fn = "unknown";
const char *src = _SC("unknown"); const char *src = "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);
sq_pushstring(v, _SC("func"), -1); sq_pushstring(v, "func", -1);
sq_pushstring(v, fn, -1); sq_pushstring(v, fn, -1);
sq_newslot(v, -3, SQFalse); sq_newslot(v, -3, SQFalse);
sq_pushstring(v, _SC("src"), -1); sq_pushstring(v, "src", -1);
sq_pushstring(v, src, -1); sq_pushstring(v, src, -1);
sq_newslot(v, -3, SQFalse); sq_newslot(v, -3, SQFalse);
sq_pushstring(v, _SC("line"), -1); sq_pushstring(v, "line", -1);
sq_pushinteger(v, si.line); sq_pushinteger(v, si.line);
sq_newslot(v, -3, SQFalse); sq_newslot(v, -3, SQFalse);
sq_pushstring(v, _SC("locals"), -1); sq_pushstring(v, "locals", -1);
sq_newtable(v); sq_newtable(v);
seq=0; seq=0;
while ((name = sq_getlocal(v, level, seq))) { while ((name = sq_getlocal(v, level, seq))) {
@ -163,7 +163,7 @@ static int64_t base_assert(rabbit::VirtualMachine* v)
return sq_throwerror(v, str); return sq_throwerror(v, str);
} }
} }
return sq_throwerror(v, _SC("assertion failed")); return sq_throwerror(v, "assertion failed");
} }
return 0; return 0;
} }
@ -198,7 +198,7 @@ static int64_t base_print(rabbit::VirtualMachine* v)
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(_get_shared_state(v)->_printfunc) _get_shared_state(v)->_printfunc(v,_SC("%s"),str); if(_get_shared_state(v)->_printfunc) _get_shared_state(v)->_printfunc(v,"%s",str);
return 0; return 0;
} }
} }
@ -211,7 +211,7 @@ static int64_t base_error(rabbit::VirtualMachine* v)
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(_get_shared_state(v)->_errorfunc) _get_shared_state(v)->_errorfunc(v,_SC("%s"),str); if(_get_shared_state(v)->_errorfunc) _get_shared_state(v)->_errorfunc(v,"%s",str);
return 0; return 0;
} }
} }
@ -221,7 +221,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 char *src=NULL,*name=_SC("unnamedbuffer"); const char *src=NULL,*name="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);
@ -277,29 +277,29 @@ static int64_t base_callee(rabbit::VirtualMachine* v)
v->push(v->_callsstack[v->_callsstacksize - 2]._closure); v->push(v->_callsstack[v->_callsstacksize - 2]._closure);
return 1; return 1;
} }
return sq_throwerror(v,_SC("no closure in the calls stack")); return sq_throwerror(v,"no closure in the calls stack");
} }
static const rabbit::RegFunction base_funcs[]={ static const rabbit::RegFunction base_funcs[]={
//generic //generic
{_SC("seterrorhandler"),base_seterrorhandler,2, NULL}, {"seterrorhandler",base_seterrorhandler,2, NULL},
{_SC("setdebughook"),base_setdebughook,2, NULL}, {"setdebughook",base_setdebughook,2, NULL},
{_SC("enabledebuginfo"),base_enabledebuginfo,2, NULL}, {"enabledebuginfo",base_enabledebuginfo,2, NULL},
{_SC("getstackinfos"),base_getstackinfos,2, _SC(".n")}, {"getstackinfos",base_getstackinfos,2, ".n"},
{_SC("getroottable"),base_getroottable,1, NULL}, {"getroottable",base_getroottable,1, NULL},
{_SC("setroottable"),base_setroottable,2, NULL}, {"setroottable",base_setroottable,2, NULL},
{_SC("getconsttable"),base_getconsttable,1, NULL}, {"getconsttable",base_getconsttable,1, NULL},
{_SC("setconsttable"),base_setconsttable,2, NULL}, {"setconsttable",base_setconsttable,2, NULL},
{_SC("assert"),base_assert,-2, NULL}, {"assert",base_assert,-2, NULL},
{_SC("print"),base_print,2, NULL}, {"print",base_print,2, NULL},
{_SC("error"),base_error,2, NULL}, {"error",base_error,2, NULL},
{_SC("compilestring"),base_compilestring,-2, _SC(".ss")}, {"compilestring",base_compilestring,-2, ".ss"},
{_SC("newthread"),base_newthread,2, _SC(".c")}, {"newthread",base_newthread,2, ".c"},
{_SC("suspend"),base_suspend,-1, NULL}, {"suspend",base_suspend,-1, NULL},
{_SC("array"),base_array,-2, _SC(".n")}, {"array",base_array,-2, ".n"},
{_SC("type"),base_type,2, NULL}, {"type",base_type,2, NULL},
{_SC("callee"),base_callee,0,NULL}, {"callee",base_callee,0,NULL},
{_SC("dummy"),base_dummy,0,NULL}, {"dummy",base_dummy,0,NULL},
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
@ -316,19 +316,19 @@ void sq_base_register(rabbit::VirtualMachine* v)
i++; i++;
} }
sq_pushstring(v,_SC("_versionnumber_"),-1); sq_pushstring(v,"_versionnumber_",-1);
sq_pushinteger(v,RABBIT_VERSION_NUMBER); sq_pushinteger(v,RABBIT_VERSION_NUMBER);
sq_newslot(v,-3, SQFalse); sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_version_"),-1); sq_pushstring(v,"_version_",-1);
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,"_charsize_",-1);
sq_pushinteger(v,sizeof(char)); sq_pushinteger(v,sizeof(char));
sq_newslot(v,-3, SQFalse); sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_intsize_"),-1); sq_pushstring(v,"_intsize_",-1);
sq_pushinteger(v,sizeof(int64_t)); sq_pushinteger(v,sizeof(int64_t));
sq_newslot(v,-3, SQFalse); sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_floatsize_"),-1); sq_pushstring(v,"_floatsize_",-1);
sq_pushinteger(v,sizeof(float_t)); sq_pushinteger(v,sizeof(float_t));
sq_newslot(v,-3, SQFalse); sq_newslot(v,-3, SQFalse);
sq_pop(v,1); sq_pop(v,1);
@ -350,7 +350,7 @@ static int64_t default_delegate_tofloat(rabbit::VirtualMachine* v)
v->push(rabbit::ObjectPtr(tofloat(res))); v->push(rabbit::ObjectPtr(tofloat(res)));
break; break;
}} }}
return sq_throwerror(v, _SC("cannot convert the string")); return sq_throwerror(v, "cannot convert the string");
break; break;
case rabbit::OT_INTEGER: case rabbit::OT_INTEGER:
case rabbit::OT_FLOAT: case rabbit::OT_FLOAT:
@ -380,7 +380,7 @@ static int64_t default_delegate_tointeger(rabbit::VirtualMachine* v)
v->push(rabbit::ObjectPtr(tointeger(res))); v->push(rabbit::ObjectPtr(tointeger(res)));
break; break;
}} }}
return sq_throwerror(v, _SC("cannot convert the string")); return sq_throwerror(v, "cannot convert the string");
break; break;
case rabbit::OT_INTEGER: case rabbit::OT_INTEGER:
case rabbit::OT_FLOAT: case rabbit::OT_FLOAT:
@ -499,17 +499,17 @@ static int64_t table_filter(rabbit::VirtualMachine* v)
const rabbit::RegFunction rabbit::SharedState::_table_default_delegate_funcz[]={ const rabbit::RegFunction rabbit::SharedState::_table_default_delegate_funcz[]={
{_SC("len"),default_delegate_len,1, _SC("t")}, {"len",default_delegate_len,1, "t"},
{_SC("rawget"),container_rawget,2, _SC("t")}, {"rawget",container_rawget,2, "t"},
{_SC("rawset"),container_rawset,3, _SC("t")}, {"rawset",container_rawset,3, "t"},
{_SC("rawdelete"),table_rawdelete,2, _SC("t")}, {"rawdelete",table_rawdelete,2, "t"},
{_SC("rawin"),container_rawexists,2, _SC("t")}, {"rawin",container_rawexists,2, "t"},
{_SC("weakref"),obj_delegate_weakref,1, NULL }, {"weakref",obj_delegate_weakref,1, NULL },
{_SC("tostring"),default_delegate_tostring,1, _SC(".")}, {"tostring",default_delegate_tostring,1, "."},
{_SC("clear"),obj_clear,1, _SC(".")}, {"clear",obj_clear,1, "."},
{_SC("setdelegate"),table_setdelegate,2, _SC(".t|o")}, {"setdelegate",table_setdelegate,2, ".t|o"},
{_SC("getdelegate"),table_getdelegate,1, _SC(".")}, {"getdelegate",table_getdelegate,1, "."},
{_SC("filter"),table_filter,2, _SC("tc")}, {"filter",table_filter,2, "tc"},
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
@ -544,7 +544,7 @@ static int64_t array_top(rabbit::VirtualMachine* v)
v->push(_array(o)->top()); v->push(_array(o)->top());
return 1; return 1;
} }
else return sq_throwerror(v,_SC("top() on a empty array")); else return sq_throwerror(v,"top() on a empty array");
} }
static int64_t array_insert(rabbit::VirtualMachine* v) static int64_t array_insert(rabbit::VirtualMachine* v)
@ -553,7 +553,7 @@ static int64_t array_insert(rabbit::VirtualMachine* v)
rabbit::Object &idx=stack_get(v,2); rabbit::Object &idx=stack_get(v,2);
rabbit::Object &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,"index out of range");
sq_pop(v,2); sq_pop(v,2);
return 1; return 1;
} }
@ -562,14 +562,14 @@ static int64_t array_remove(rabbit::VirtualMachine* v)
{ {
rabbit::Object &o = stack_get(v, 1); rabbit::Object &o = stack_get(v, 1);
rabbit::Object &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, "wrong type");
rabbit::ObjectPtr 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);
return 1; return 1;
} }
return sq_throwerror(v, _SC("idx out of range")); return sq_throwerror(v, "idx out of range");
} }
static int64_t array_resize(rabbit::VirtualMachine* v) static int64_t array_resize(rabbit::VirtualMachine* v)
@ -580,7 +580,7 @@ static int64_t array_resize(rabbit::VirtualMachine* v)
if(sq_isnumeric(nsize)) { if(sq_isnumeric(nsize)) {
int64_t sz = tointeger(nsize); int64_t sz = tointeger(nsize);
if (sz<0) if (sz<0)
return sq_throwerror(v, _SC("resizing to negative length")); return sq_throwerror(v, "resizing to negative length");
if(sq_gettop(v) > 2) if(sq_gettop(v) > 2)
fill = stack_get(v, 3); fill = stack_get(v, 3);
@ -588,7 +588,7 @@ static int64_t array_resize(rabbit::VirtualMachine* v)
sq_settop(v, 1); sq_settop(v, 1);
return 1; return 1;
} }
return sq_throwerror(v, _SC("size must be a number")); return sq_throwerror(v, "size must be a number");
} }
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) {
@ -711,11 +711,11 @@ static bool _sort_compare(rabbit::VirtualMachine* v,rabbit::ObjectPtr &a,rabbit:
v->push(b); v->push(b);
if(SQ_FAILED(sq_call(v, 3, SQTrue, SQFalse))) { if(SQ_FAILED(sq_call(v, 3, SQTrue, SQFalse))) {
if(!sq_isstring( v->_lasterror)) if(!sq_isstring( v->_lasterror))
v->raise_error(_SC("compare func failed")); v->raise_error("compare func failed");
return false; return false;
} }
if(SQ_FAILED(sq_getinteger(v, -1, &ret))) { if(SQ_FAILED(sq_getinteger(v, -1, &ret))) {
v->raise_error(_SC("numeric value expected as return value of the compare function")); v->raise_error("numeric value expected as return value of the compare function");
return false; return false;
} }
sq_settop(v, top); sq_settop(v, top);
@ -750,7 +750,7 @@ static bool _hsort_sift_down(rabbit::VirtualMachine* v,rabbit::Array *arr, int64
return false; return false;
if (ret < 0) { if (ret < 0) {
if (root == maxChild) { if (root == maxChild) {
v->raise_error(_SC("inconsistent compare function")); v->raise_error("inconsistent compare function");
return false; // We'd be swapping ourselve. The compare function is incorrect return false; // We'd be swapping ourselve. The compare function is incorrect
} }
@ -803,8 +803,8 @@ static int64_t array_slice(rabbit::VirtualMachine* v)
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,"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, "slice out of range");
rabbit::Array *arr=rabbit::Array::create(_get_shared_state(v),eidx-sidx); rabbit::Array *arr=rabbit::Array::create(_get_shared_state(v),eidx-sidx);
rabbit::ObjectPtr t; rabbit::ObjectPtr t;
int64_t count=0; int64_t count=0;
@ -818,26 +818,26 @@ static int64_t array_slice(rabbit::VirtualMachine* v)
} }
const rabbit::RegFunction rabbit::SharedState::_array_default_delegate_funcz[]={ const rabbit::RegFunction rabbit::SharedState::_array_default_delegate_funcz[]={
{_SC("len"),default_delegate_len,1, _SC("a")}, {"len",default_delegate_len,1, "a"},
{_SC("append"),array_append,2, _SC("a")}, {"append",array_append,2, "a"},
{_SC("extend"),array_extend,2, _SC("aa")}, {"extend",array_extend,2, "aa"},
{_SC("push"),array_append,2, _SC("a")}, {"push",array_append,2, "a"},
{_SC("pop"),array_pop,1, _SC("a")}, {"pop",array_pop,1, "a"},
{_SC("top"),array_top,1, _SC("a")}, {"top",array_top,1, "a"},
{_SC("insert"),array_insert,3, _SC("an")}, {"insert",array_insert,3, "an"},
{_SC("remove"),array_remove,2, _SC("an")}, {"remove",array_remove,2, "an"},
{_SC("resize"),array_resize,-2, _SC("an")}, {"resize",array_resize,-2, "an"},
{_SC("reverse"),array_reverse,1, _SC("a")}, {"reverse",array_reverse,1, "a"},
{_SC("sort"),array_sort,-1, _SC("ac")}, {"sort",array_sort,-1, "ac"},
{_SC("slice"),array_slice,-1, _SC("ann")}, {"slice",array_slice,-1, "ann"},
{_SC("weakref"),obj_delegate_weakref,1, NULL }, {"weakref",obj_delegate_weakref,1, NULL },
{_SC("tostring"),default_delegate_tostring,1, _SC(".")}, {"tostring",default_delegate_tostring,1, "."},
{_SC("clear"),obj_clear,1, _SC(".")}, {"clear",obj_clear,1, "."},
{_SC("map"),array_map,2, _SC("ac")}, {"map",array_map,2, "ac"},
{_SC("apply"),array_apply,2, _SC("ac")}, {"apply",array_apply,2, "ac"},
{_SC("reduce"),array_reduce,2, _SC("ac")}, {"reduce",array_reduce,2, "ac"},
{_SC("filter"),array_filter,2, _SC("ac")}, {"filter",array_filter,2, "ac"},
{_SC("find"),array_find,2, _SC("a.")}, {"find",array_find,2, "a."},
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
@ -850,8 +850,8 @@ static int64_t string_slice(rabbit::VirtualMachine* v)
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,"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, "slice out of range");
v->push(rabbit::String::create(_get_shared_state(v),&_stringval(o)[sidx],eidx-sidx)); v->push(rabbit::String::create(_get_shared_state(v),&_stringval(o)[sidx],eidx-sidx));
return 1; return 1;
} }
@ -871,7 +871,7 @@ static int64_t string_find(rabbit::VirtualMachine* v)
} }
return 0; return 0;
} }
return sq_throwerror(v,_SC("invalid param")); return sq_throwerror(v,"invalid param");
} }
#define STRING_TOFUNCZ(func) static int64_t string_##func(rabbit::VirtualMachine* v) \ #define STRING_TOFUNCZ(func) static int64_t string_##func(rabbit::VirtualMachine* v) \
@ -882,8 +882,8 @@ static int64_t string_find(rabbit::VirtualMachine* v)
int64_t slen = _string(str)->_len; \ int64_t slen = _string(str)->_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,"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,"slice out of range"); \
int64_t len=_string(str)->_len; \ int64_t len=_string(str)->_len; \
const char *sthis=_stringval(str); \ const char *sthis=_stringval(str); \
char *snew=(_get_shared_state(v)->getScratchPad(sq_rsl(len))); \ char *snew=(_get_shared_state(v)->getScratchPad(sq_rsl(len))); \
@ -898,25 +898,25 @@ STRING_TOFUNCZ(tolower)
STRING_TOFUNCZ(toupper) STRING_TOFUNCZ(toupper)
const rabbit::RegFunction rabbit::SharedState::_string_default_delegate_funcz[]={ const rabbit::RegFunction rabbit::SharedState::_string_default_delegate_funcz[]={
{_SC("len"),default_delegate_len,1, _SC("s")}, {"len",default_delegate_len,1, "s"},
{_SC("tointeger"),default_delegate_tointeger,-1, _SC("sn")}, {"tointeger",default_delegate_tointeger,-1, "sn"},
{_SC("tofloat"),default_delegate_tofloat,1, _SC("s")}, {"tofloat",default_delegate_tofloat,1, "s"},
{_SC("tostring"),default_delegate_tostring,1, _SC(".")}, {"tostring",default_delegate_tostring,1, "."},
{_SC("slice"),string_slice,-1, _SC("s n n")}, {"slice",string_slice,-1, "s n n"},
{_SC("find"),string_find,-2, _SC("s s n")}, {"find",string_find,-2, "s s n"},
{_SC("tolower"),string_tolower,-1, _SC("s n n")}, {"tolower",string_tolower,-1, "s n n"},
{_SC("toupper"),string_toupper,-1, _SC("s n n")}, {"toupper",string_toupper,-1, "s n n"},
{_SC("weakref"),obj_delegate_weakref,1, NULL }, {"weakref",obj_delegate_weakref,1, NULL },
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
//INTEGER DEFAULT DELEGATE////////////////////////// //INTEGER DEFAULT DELEGATE//////////////////////////
const rabbit::RegFunction rabbit::SharedState::_number_default_delegate_funcz[]={ const rabbit::RegFunction rabbit::SharedState::_number_default_delegate_funcz[]={
{_SC("tointeger"),default_delegate_tointeger,1, _SC("n|b")}, {"tointeger",default_delegate_tointeger,1, "n|b"},
{_SC("tofloat"),default_delegate_tofloat,1, _SC("n|b")}, {"tofloat",default_delegate_tofloat,1, "n|b"},
{_SC("tostring"),default_delegate_tostring,1, _SC(".")}, {"tostring",default_delegate_tostring,1, "."},
{_SC("tochar"),number_delegate_tochar,1, _SC("n|b")}, {"tochar",number_delegate_tochar,1, "n|b"},
{_SC("weakref"),obj_delegate_weakref,1, NULL }, {"weakref",obj_delegate_weakref,1, NULL },
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
@ -991,20 +991,20 @@ 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,rabbit::String::create(_get_shared_state(v),_SC("..."),-1)); _array(params)->set(nparams-1,rabbit::String::create(_get_shared_state(v),"...",-1));
} }
res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("native"),-1),false); res->newSlot(rabbit::String::create(_get_shared_state(v),"native",-1),false);
res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("name"),-1),f->_name); res->newSlot(rabbit::String::create(_get_shared_state(v),"name",-1),f->_name);
res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("src"),-1),f->_sourcename); res->newSlot(rabbit::String::create(_get_shared_state(v),"src",-1),f->_sourcename);
res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("parameters"),-1),params); res->newSlot(rabbit::String::create(_get_shared_state(v),"parameters",-1),params);
res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("varargs"),-1),f->_varparams); res->newSlot(rabbit::String::create(_get_shared_state(v),"varargs",-1),f->_varparams);
res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("defparams"),-1),defparams); res->newSlot(rabbit::String::create(_get_shared_state(v),"defparams",-1),defparams);
} }
else { //rabbit::OT_NATIVECLOSURE else { //rabbit::OT_NATIVECLOSURE
rabbit::NativeClosure *nc = _nativeclosure(o); rabbit::NativeClosure *nc = _nativeclosure(o);
res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("native"),-1),true); res->newSlot(rabbit::String::create(_get_shared_state(v),"native",-1),true);
res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("name"),-1),nc->_name); res->newSlot(rabbit::String::create(_get_shared_state(v),"name",-1),nc->_name);
res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("paramscheck"),-1),nc->_nparamscheck); res->newSlot(rabbit::String::create(_get_shared_state(v),"paramscheck",-1),nc->_nparamscheck);
rabbit::ObjectPtr typecheck; rabbit::ObjectPtr typecheck;
if(nc->_typecheck.size() > 0) { if(nc->_typecheck.size() > 0) {
typecheck = typecheck =
@ -1013,7 +1013,7 @@ static int64_t closure_getinfos(rabbit::VirtualMachine* v) {
_array(typecheck)->set((int64_t)n,nc->_typecheck[n]); _array(typecheck)->set((int64_t)n,nc->_typecheck[n]);
} }
} }
res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("typecheck"),-1),typecheck); res->newSlot(rabbit::String::create(_get_shared_state(v),"typecheck",-1),typecheck);
} }
v->push(res); v->push(res);
return 1; return 1;
@ -1022,16 +1022,16 @@ static int64_t closure_getinfos(rabbit::VirtualMachine* v) {
const rabbit::RegFunction rabbit::SharedState::_closure_default_delegate_funcz[]={ const rabbit::RegFunction rabbit::SharedState::_closure_default_delegate_funcz[]={
{_SC("call"),closure_call,-1, _SC("c")}, {"call",closure_call,-1, "c"},
{_SC("pcall"),closure_pcall,-1, _SC("c")}, {"pcall",closure_pcall,-1, "c"},
{_SC("acall"),closure_acall,2, _SC("ca")}, {"acall",closure_acall,2, "ca"},
{_SC("pacall"),closure_pacall,2, _SC("ca")}, {"pacall",closure_pacall,2, "ca"},
{_SC("weakref"),obj_delegate_weakref,1, NULL }, {"weakref",obj_delegate_weakref,1, NULL },
{_SC("tostring"),default_delegate_tostring,1, _SC(".")}, {"tostring",default_delegate_tostring,1, "."},
{_SC("bindenv"),closure_bindenv,2, _SC("c x|y|t")}, {"bindenv",closure_bindenv,2, "c x|y|t"},
{_SC("getinfos"),closure_getinfos,1, _SC("c")}, {"getinfos",closure_getinfos,1, "c"},
{_SC("getroot"),closure_getroot,1, _SC("c")}, {"getroot",closure_getroot,1, "c"},
{_SC("setroot"),closure_setroot,2, _SC("ct")}, {"setroot",closure_setroot,2, "ct"},
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
@ -1040,17 +1040,17 @@ static int64_t generator_getstatus(rabbit::VirtualMachine* v)
{ {
rabbit::Object &o=stack_get(v,1); rabbit::Object &o=stack_get(v,1);
switch(_generator(o)->_state){ switch(_generator(o)->_state){
case rabbit::Generator::eSuspended:v->push(rabbit::String::create(_get_shared_state(v),_SC("suspended")));break; case rabbit::Generator::eSuspended:v->push(rabbit::String::create(_get_shared_state(v),"suspended"));break;
case rabbit::Generator::eRunning:v->push(rabbit::String::create(_get_shared_state(v),_SC("running")));break; case rabbit::Generator::eRunning:v->push(rabbit::String::create(_get_shared_state(v),"running"));break;
case rabbit::Generator::eDead:v->push(rabbit::String::create(_get_shared_state(v),_SC("dead")));break; case rabbit::Generator::eDead:v->push(rabbit::String::create(_get_shared_state(v),"dead"));break;
} }
return 1; return 1;
} }
const rabbit::RegFunction rabbit::SharedState::_generator_default_delegate_funcz[]={ const rabbit::RegFunction rabbit::SharedState::_generator_default_delegate_funcz[]={
{_SC("getstatus"),generator_getstatus,1, _SC("g")}, {"getstatus",generator_getstatus,1, "g"},
{_SC("weakref"),obj_delegate_weakref,1, NULL }, {"weakref",obj_delegate_weakref,1, NULL },
{_SC("tostring"),default_delegate_tostring,1, _SC(".")}, {"tostring",default_delegate_tostring,1, "."},
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
@ -1071,7 +1071,7 @@ static int64_t thread_call(rabbit::VirtualMachine* v)
v->_lasterror = _thread(o)->_lasterror; v->_lasterror = _thread(o)->_lasterror;
return SQ_ERROR; return SQ_ERROR;
} }
return sq_throwerror(v,_SC("wrong parameter")); return sq_throwerror(v,"wrong parameter");
} }
static int64_t thread_wakeup(rabbit::VirtualMachine* v) static int64_t thread_wakeup(rabbit::VirtualMachine* v)
@ -1083,10 +1083,10 @@ static int64_t thread_wakeup(rabbit::VirtualMachine* v)
if(state != SQ_VMSTATE_SUSPENDED) { if(state != SQ_VMSTATE_SUSPENDED) {
switch(state) { switch(state) {
case SQ_VMSTATE_IDLE: case SQ_VMSTATE_IDLE:
return sq_throwerror(v,_SC("cannot wakeup a idle thread")); return sq_throwerror(v,"cannot wakeup a idle thread");
break; break;
case SQ_VMSTATE_RUNNING: case SQ_VMSTATE_RUNNING:
return sq_throwerror(v,_SC("cannot wakeup a running thread")); return sq_throwerror(v,"cannot wakeup a running thread");
break; break;
} }
} }
@ -1107,7 +1107,7 @@ static int64_t thread_wakeup(rabbit::VirtualMachine* v)
v->_lasterror = thread->_lasterror; v->_lasterror = thread->_lasterror;
return SQ_ERROR; return SQ_ERROR;
} }
return sq_throwerror(v,_SC("wrong parameter")); return sq_throwerror(v,"wrong parameter");
} }
static int64_t thread_wakeupthrow(rabbit::VirtualMachine* v) static int64_t thread_wakeupthrow(rabbit::VirtualMachine* v)
@ -1119,10 +1119,10 @@ static int64_t thread_wakeupthrow(rabbit::VirtualMachine* v)
if(state != SQ_VMSTATE_SUSPENDED) { if(state != SQ_VMSTATE_SUSPENDED) {
switch(state) { switch(state) {
case SQ_VMSTATE_IDLE: case SQ_VMSTATE_IDLE:
return sq_throwerror(v,_SC("cannot wakeup a idle thread")); return sq_throwerror(v,"cannot wakeup a idle thread");
break; break;
case SQ_VMSTATE_RUNNING: case SQ_VMSTATE_RUNNING:
return sq_throwerror(v,_SC("cannot wakeup a running thread")); return sq_throwerror(v,"cannot wakeup a running thread");
break; break;
} }
} }
@ -1148,7 +1148,7 @@ static int64_t thread_wakeupthrow(rabbit::VirtualMachine* v)
} }
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v,_SC("wrong parameter")); return sq_throwerror(v,"wrong parameter");
} }
static int64_t thread_getstatus(rabbit::VirtualMachine* v) static int64_t thread_getstatus(rabbit::VirtualMachine* v)
@ -1156,16 +1156,16 @@ static int64_t thread_getstatus(rabbit::VirtualMachine* v)
rabbit::ObjectPtr &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,"idle",-1);
break; break;
case SQ_VMSTATE_RUNNING: case SQ_VMSTATE_RUNNING:
sq_pushstring(v,_SC("running"),-1); sq_pushstring(v,"running",-1);
break; break;
case SQ_VMSTATE_SUSPENDED: case SQ_VMSTATE_SUSPENDED:
sq_pushstring(v,_SC("suspended"),-1); sq_pushstring(v,"suspended",-1);
break; break;
default: default:
return sq_throwerror(v,_SC("internal VM error")); return sq_throwerror(v,"internal VM error");
} }
return 1; return 1;
} }
@ -1186,7 +1186,7 @@ static int64_t thread_getstackinfos(rabbit::VirtualMachine* v)
sq_throwerror(v,_stringval(thread->_lasterror)); sq_throwerror(v,_stringval(thread->_lasterror));
} }
else { else {
sq_throwerror(v,_SC("unknown error")); sq_throwerror(v,"unknown error");
} }
} }
if(res > 0) { if(res > 0) {
@ -1200,17 +1200,17 @@ static int64_t thread_getstackinfos(rabbit::VirtualMachine* v)
return 0; return 0;
} }
return sq_throwerror(v,_SC("wrong parameter")); return sq_throwerror(v,"wrong parameter");
} }
const rabbit::RegFunction rabbit::SharedState::_thread_default_delegate_funcz[] = { const rabbit::RegFunction rabbit::SharedState::_thread_default_delegate_funcz[] = {
{_SC("call"), thread_call, -1, _SC("v")}, {"call", thread_call, -1, "v"},
{_SC("wakeup"), thread_wakeup, -1, _SC("v")}, {"wakeup", thread_wakeup, -1, "v"},
{_SC("wakeupthrow"), thread_wakeupthrow, -2, _SC("v.b")}, {"wakeupthrow", thread_wakeupthrow, -2, "v.b"},
{_SC("getstatus"), thread_getstatus, 1, _SC("v")}, {"getstatus", thread_getstatus, 1, "v"},
{_SC("weakref"),obj_delegate_weakref,1, NULL }, {"weakref",obj_delegate_weakref,1, NULL },
{_SC("getstackinfos"),thread_getstackinfos,2, _SC("vn")}, {"getstackinfos",thread_getstackinfos,2, "vn"},
{_SC("tostring"),default_delegate_tostring,1, _SC(".")}, {"tostring",default_delegate_tostring,1, "."},
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
@ -1267,17 +1267,17 @@ static int64_t class_rawnewmember(rabbit::VirtualMachine* v)
} }
const rabbit::RegFunction rabbit::SharedState::_class_default_delegate_funcz[] = { const rabbit::RegFunction rabbit::SharedState::_class_default_delegate_funcz[] = {
{_SC("getattributes"), class_getattributes, 2, _SC("y.")}, {"getattributes", class_getattributes, 2, "y."},
{_SC("setattributes"), class_setattributes, 3, _SC("y..")}, {"setattributes", class_setattributes, 3, "y.."},
{_SC("rawget"),container_rawget,2, _SC("y")}, {"rawget",container_rawget,2, "y"},
{_SC("rawset"),container_rawset,3, _SC("y")}, {"rawset",container_rawset,3, "y"},
{_SC("rawin"),container_rawexists,2, _SC("y")}, {"rawin",container_rawexists,2, "y"},
{_SC("weakref"),obj_delegate_weakref,1, NULL }, {"weakref",obj_delegate_weakref,1, NULL },
{_SC("tostring"),default_delegate_tostring,1, _SC(".")}, {"tostring",default_delegate_tostring,1, "."},
{_SC("instance"),class_instance,1, _SC("y")}, {"instance",class_instance,1, "y"},
{_SC("getbase"),class_getbase,1, _SC("y")}, {"getbase",class_getbase,1, "y"},
{_SC("newmember"),class_newmember,-3, _SC("y")}, {"newmember",class_newmember,-3, "y"},
{_SC("rawnewmember"),class_rawnewmember,-3, _SC("y")}, {"rawnewmember",class_rawnewmember,-3, "y"},
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
@ -1290,12 +1290,12 @@ static int64_t instance_getclass(rabbit::VirtualMachine* v)
} }
const rabbit::RegFunction rabbit::SharedState::_instance_default_delegate_funcz[] = { const rabbit::RegFunction rabbit::SharedState::_instance_default_delegate_funcz[] = {
{_SC("getclass"), instance_getclass, 1, _SC("x")}, {"getclass", instance_getclass, 1, "x"},
{_SC("rawget"),container_rawget,2, _SC("x")}, {"rawget",container_rawget,2, "x"},
{_SC("rawset"),container_rawset,3, _SC("x")}, {"rawset",container_rawset,3, "x"},
{_SC("rawin"),container_rawexists,2, _SC("x")}, {"rawin",container_rawexists,2, "x"},
{_SC("weakref"),obj_delegate_weakref,1, NULL }, {"weakref",obj_delegate_weakref,1, NULL },
{_SC("tostring"),default_delegate_tostring,1, _SC(".")}, {"tostring",default_delegate_tostring,1, "."},
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
@ -1307,8 +1307,8 @@ static int64_t weakref_ref(rabbit::VirtualMachine* v)
} }
const rabbit::RegFunction rabbit::SharedState::_weakref_default_delegate_funcz[] = { const rabbit::RegFunction rabbit::SharedState::_weakref_default_delegate_funcz[] = {
{_SC("ref"),weakref_ref,1, _SC("r")}, {"ref",weakref_ref,1, "r"},
{_SC("weakref"),obj_delegate_weakref,1, NULL }, {"weakref",obj_delegate_weakref,1, NULL },
{_SC("tostring"),default_delegate_tostring,1, _SC(".")}, {"tostring",default_delegate_tostring,1, "."},
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };

7
rabbit/sqconfig.hpp
View File

@ -41,8 +41,8 @@ namespace rabbit {
#define sq_rsl(l) (l) #define sq_rsl(l) (l)
#define _PRINT_INT_PREC _SC("ll") #define _PRINT_INT_PREC "ll"
#define _PRINT_INT_FMT _SC("%ld") #define _PRINT_INT_FMT "%ld"
#define SQTrue (1) #define SQTrue (1)
#define SQFalse (0) #define SQFalse (0)
@ -54,9 +54,6 @@ namespace rabbit {
#define UINT_MINUS_ONE (0xFFFFFFFF) #define UINT_MINUS_ONE (0xFFFFFFFF)
#endif #endif
#define _SC(a) a
namespace rabbit { namespace rabbit {
class UserData; class UserData;
class Array; class Array;

22
rabbit/sqdebug.cpp
View File

@ -31,13 +31,13 @@ rabbit::Result rabbit::sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t leve
rabbit::Closure *c = _closure(ci._closure); rabbit::Closure *c = _closure(ci._closure);
rabbit::FunctionProto *proto = c->_function; rabbit::FunctionProto *proto = c->_function;
fi->funcid = proto; fi->funcid = proto;
fi->name = sq_type(proto->_name) == rabbit::OT_STRING?_stringval(proto->_name):_SC("unknown"); fi->name = sq_type(proto->_name) == rabbit::OT_STRING?_stringval(proto->_name):"unknown";
fi->source = sq_type(proto->_sourcename) == rabbit::OT_STRING?_stringval(proto->_sourcename):_SC("unknown"); fi->source = sq_type(proto->_sourcename) == rabbit::OT_STRING?_stringval(proto->_sourcename):"unknown";
fi->line = proto->_lineinfos[0]._line; fi->line = proto->_lineinfos[0]._line;
return SQ_OK; return SQ_OK;
} }
} }
return sq_throwerror(v,_SC("the object is not a closure")); return sq_throwerror(v,"the object is not a closure");
} }
rabbit::Result rabbit::sq_stackinfos(rabbit::VirtualMachine* v, int64_t level, rabbit::StackInfos *si) rabbit::Result rabbit::sq_stackinfos(rabbit::VirtualMachine* v, int64_t level, rabbit::StackInfos *si)
@ -57,8 +57,8 @@ rabbit::Result rabbit::sq_stackinfos(rabbit::VirtualMachine* v, int64_t level, r
} }
break; break;
case rabbit::OT_NATIVECLOSURE: case rabbit::OT_NATIVECLOSURE:
si->source = _SC("NATIVE"); si->source = "NATIVE";
si->funcname = _SC("unknown"); si->funcname = "unknown";
if(sq_type(_nativeclosure(ci._closure)->_name) == rabbit::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;
@ -94,7 +94,7 @@ rabbit::String *rabbit::VirtualMachine::printObjVal(const rabbit::ObjectPtr &o)
return rabbit::String::create(_get_shared_state(this), _spval); return rabbit::String::create(_get_shared_state(this), _spval);
break; break;
case rabbit::OT_FLOAT: case rabbit::OT_FLOAT:
snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)), sq_rsl(NUMBER_UINT8_MAX), _SC("%.14g"), _float(o)); snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)), sq_rsl(NUMBER_UINT8_MAX), "%.14g", _float(o));
return rabbit::String::create(_get_shared_state(this), _spval); return rabbit::String::create(_get_shared_state(this), _spval);
break; break;
default: default:
@ -105,28 +105,28 @@ rabbit::String *rabbit::VirtualMachine::printObjVal(const rabbit::ObjectPtr &o)
void rabbit::VirtualMachine::raise_Idxerror(const rabbit::ObjectPtr &o) void rabbit::VirtualMachine::raise_Idxerror(const rabbit::ObjectPtr &o)
{ {
rabbit::ObjectPtr oval = printObjVal(o); rabbit::ObjectPtr oval = printObjVal(o);
raise_error(_SC("the index '%.50s' does not exist"), _stringval(oval)); raise_error("the index '%.50s' does not exist", _stringval(oval));
} }
void rabbit::VirtualMachine::raise_Compareerror(const rabbit::Object &o1, const rabbit::Object &o2) void rabbit::VirtualMachine::raise_Compareerror(const rabbit::Object &o1, const rabbit::Object &o2)
{ {
rabbit::ObjectPtr 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("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)
{ {
rabbit::ObjectPtr exptypes = rabbit::String::create(_get_shared_state(this), _SC(""), -1); rabbit::ObjectPtr exptypes = rabbit::String::create(_get_shared_state(this), "", -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,rabbit::String::create(_get_shared_state(this), _SC("|"), -1), exptypes); if(found>0) stringCat(exptypes,rabbit::String::create(_get_shared_state(this), "|", -1), exptypes);
found ++; found ++;
stringCat(exptypes,rabbit::String::create(_get_shared_state(this), IdType2Name((rabbit::ObjectType)mask), -1), exptypes); stringCat(exptypes,rabbit::String::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((rabbit::ObjectType)type), _stringval(exptypes)); raise_error("parameter %d has an invalid type '%s' ; expected: '%s'", nparam, IdType2Name((rabbit::ObjectType)type), _stringval(exptypes));
} }