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
Download Patch File Download Diff File Expand all files Collapse all files

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
const char *name=0;
int64_t seq=0;
pf(v,_SC("\nCALLSTACK\n"));
pf(v,"\nCALLSTACK\n");
while(SQ_SUCCEEDED(sq_stackinfos(v,level,&si)))
{
const char *fn=_SC("unknown");
const char *src=_SC("unknown");
const char *fn="unknown";
const char *src="unknown";
if(si.funcname)fn=si.funcname;
if(si.source)src=si.source;
pf(v,_SC("*FUNCTION [%s()] %s line [%d]\n"),fn,src,si.line);
pf(v,"*FUNCTION [%s()] %s line [%d]\n",fn,src,si.line);
level++;
}
level=0;
pf(v,_SC("\nLOCALS\n"));
pf(v,"\nLOCALS\n");
for(level=0;level<10;level++){
seq=0;
@@ -43,58 +43,58 @@ void rabbit::std::printcallstack(rabbit::VirtualMachine* v)
switch(sq_gettype(v,-1))
{
case rabbit::OT_NULL:
pf(v,_SC("[%s] NULL\n"),name);
pf(v,"[%s] NULL\n",name);
break;
case rabbit::OT_INTEGER:
sq_getinteger(v,-1,&i);
pf(v,_SC("[%s] %d\n"),name,i);
pf(v,"[%s] %d\n",name,i);
break;
case rabbit::OT_FLOAT:
sq_getfloat(v,-1,&f);
pf(v,_SC("[%s] %.14g\n"),name,f);
pf(v,"[%s] %.14g\n",name,f);
break;
case rabbit::OT_USERPOINTER:
pf(v,_SC("[%s] USERPOINTER\n"),name);
pf(v,"[%s] USERPOINTER\n",name);
break;
case rabbit::OT_STRING:
sq_getstring(v,-1,&s);
pf(v,_SC("[%s] \"%s\"\n"),name,s);
pf(v,"[%s] \"%s\"\n",name,s);
break;
case rabbit::OT_TABLE:
pf(v,_SC("[%s] TABLE\n"),name);
pf(v,"[%s] TABLE\n",name);
break;
case rabbit::OT_ARRAY:
pf(v,_SC("[%s] ARRAY\n"),name);
pf(v,"[%s] ARRAY\n",name);
break;
case rabbit::OT_CLOSURE:
pf(v,_SC("[%s] CLOSURE\n"),name);
pf(v,"[%s] CLOSURE\n",name);
break;
case rabbit::OT_NATIVECLOSURE:
pf(v,_SC("[%s] NATIVECLOSURE\n"),name);
pf(v,"[%s] NATIVECLOSURE\n",name);
break;
case rabbit::OT_GENERATOR:
pf(v,_SC("[%s] GENERATOR\n"),name);
pf(v,"[%s] GENERATOR\n",name);
break;
case rabbit::OT_USERDATA:
pf(v,_SC("[%s] USERDATA\n"),name);
pf(v,"[%s] USERDATA\n",name);
break;
case rabbit::OT_THREAD:
pf(v,_SC("[%s] THREAD\n"),name);
pf(v,"[%s] THREAD\n",name);
break;
case rabbit::OT_CLASS:
pf(v,_SC("[%s] CLASS\n"),name);
pf(v,"[%s] CLASS\n",name);
break;
case rabbit::OT_INSTANCE:
pf(v,_SC("[%s] INSTANCE\n"),name);
pf(v,"[%s] INSTANCE\n",name);
break;
case rabbit::OT_WEAKREF:
pf(v,_SC("[%s] WEAKREF\n"),name);
pf(v,"[%s] WEAKREF\n",name);
break;
case rabbit::OT_BOOL:
{
rabbit::Bool bval;
sq_getbool(v,-1,&bval);
pf(v,_SC("[%s] %s\n"),name,bval == SQTrue ? _SC("true"):_SC("false"));
pf(v,"[%s] %s\n",name,bval == SQTrue ? "true":"false");
}
break;
default: assert(0); break;
@@ -113,10 +113,10 @@ namespace rabbit {
const char *sErr = 0;
if(sq_gettop(v)>=1) {
if(SQ_SUCCEEDED(sq_getstring(v,2,&sErr))) {
pf(v,_SC("\nAN ERROR HAS OCCURRED [%s]\n"),sErr);
pf(v,"\nAN ERROR HAS OCCURRED [%s]\n",sErr);
}
else{
pf(v,_SC("\nAN ERROR HAS OCCURRED [unknown]\n"));
pf(v,"\nAN ERROR HAS OCCURRED [unknown]\n");
}
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) {
SQPRINTFUNCTION pf = sq_geterrorfunc(v);
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) \
rabbit::std::Blob *self = NULL; \
{ if(SQ_FAILED(rabbit::sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) \
return rabbit::sq_throwerror(v,_SC("invalid type tag")); } \
return rabbit::sq_throwerror(v,"invalid type tag"); } \
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)
@@ -26,7 +26,7 @@ static int64_t _blob_resize(rabbit::VirtualMachine* v)
int64_t size;
rabbit::sq_getinteger(v,2,&size);
if(!self->resize(size))
return rabbit::sq_throwerror(v,_SC("resize failed"));
return rabbit::sq_throwerror(v,"resize failed");
return 0;
}
@@ -72,7 +72,7 @@ static int64_t _blob__set(rabbit::VirtualMachine* v)
rabbit::sq_getinteger(v,2,&idx);
rabbit::sq_getinteger(v,3,&val);
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;
rabbit::sq_push(v,3);
return 1;
@@ -90,7 +90,7 @@ static int64_t _blob__get(rabbit::VirtualMachine* v)
}
rabbit::sq_getinteger(v,2,&idx);
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]);
return 1;
}
@@ -111,12 +111,12 @@ static int64_t _blob__nexti(rabbit::VirtualMachine* v)
rabbit::sq_pushnull(v);
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)
{
rabbit::sq_pushstring(v,_SC("blob"),-1);
rabbit::sq_pushstring(v,"blob",-1);
return 1;
}
@@ -135,14 +135,14 @@ static int64_t _blob_constructor(rabbit::VirtualMachine* v)
if(nparam == 2) {
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::sq_malloc(sizeof(rabbit::std::Blob)))rabbit::std::Blob(size);
if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,b))) {
b->~Blob();
rabbit::sq_free(b,sizeof(rabbit::std::Blob));
return rabbit::sq_throwerror(v, _SC("cannot create blob"));
return rabbit::sq_throwerror(v, "cannot create blob");
}
rabbit::sq_setreleasehook(v,1,_blob_releasehook);
return 0;
@@ -161,23 +161,23 @@ static int64_t _blob__cloned(rabbit::VirtualMachine* v)
if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,thisone))) {
thisone->~Blob();
rabbit::sq_free(thisone,sizeof(rabbit::std::Blob));
return rabbit::sq_throwerror(v, _SC("cannot clone blob"));
return rabbit::sq_throwerror(v, "cannot clone blob");
}
rabbit::sq_setreleasehook(v,1,_blob_releasehook);
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[] = {
_DECL_BLOB_FUNC(constructor,-1,_SC("xn")),
_DECL_BLOB_FUNC(resize,2,_SC("xn")),
_DECL_BLOB_FUNC(swap2,1,_SC("x")),
_DECL_BLOB_FUNC(swap4,1,_SC("x")),
_DECL_BLOB_FUNC(_set,3,_SC("xnn")),
_DECL_BLOB_FUNC(_get,2,_SC("x.")),
_DECL_BLOB_FUNC(_typeof,1,_SC("x")),
_DECL_BLOB_FUNC(_nexti,2,_SC("x")),
_DECL_BLOB_FUNC(_cloned,2,_SC("xx")),
_DECL_BLOB_FUNC(constructor,-1,"xn"),
_DECL_BLOB_FUNC(resize,2,"xn"),
_DECL_BLOB_FUNC(swap2,1,"x"),
_DECL_BLOB_FUNC(swap4,1,"x"),
_DECL_BLOB_FUNC(_set,3,"xnn"),
_DECL_BLOB_FUNC(_get,2,"x."),
_DECL_BLOB_FUNC(_typeof,1,"x"),
_DECL_BLOB_FUNC(_nexti,2,"x"),
_DECL_BLOB_FUNC(_cloned,2,"xx"),
{NULL,(SQFUNCTION)0,0,NULL}
};
@@ -229,13 +229,13 @@ static int64_t _g_blob_swapfloat(rabbit::VirtualMachine* v)
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[]={
_DECL_GLOBALBLOB_FUNC(casti2f,2,_SC(".n")),
_DECL_GLOBALBLOB_FUNC(castf2i,2,_SC(".n")),
_DECL_GLOBALBLOB_FUNC(swap2,2,_SC(".n")),
_DECL_GLOBALBLOB_FUNC(swap4,2,_SC(".n")),
_DECL_GLOBALBLOB_FUNC(swapfloat,2,_SC(".n")),
_DECL_GLOBALBLOB_FUNC(casti2f,2,".n"),
_DECL_GLOBALBLOB_FUNC(castf2i,2,".n"),
_DECL_GLOBALBLOB_FUNC(swap2,2,".n"),
_DECL_GLOBALBLOB_FUNC(swap4,2,".n"),
_DECL_GLOBALBLOB_FUNC(swapfloat,2,".n"),
{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);
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))) {
rabbit::sq_remove(v,-2); //removes the registry
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)
{
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)
{
sq_pushstring(v,_SC("file"),-1);
sq_pushstring(v,"file",-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, 3, &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) {
owns = !(rabbit::sq_gettype(v,3) == rabbit::OT_NULL);
rabbit::sq_getuserpointer(v,2,&newf);
} 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);
if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,f))) {
f->~File();
rabbit::sq_free(f,sizeof(rabbit::std::File));
return rabbit::sq_throwerror(v, _SC("cannot create blob with negative size"));
return rabbit::sq_throwerror(v, "cannot create blob with negative size");
}
rabbit::sq_setreleasehook(v,1,_file_releasehook);
return 0;
@@ -169,11 +169,11 @@ static int64_t _file_close(rabbit::VirtualMachine* v)
}
//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[] = {
_DECL_FILE_FUNC(constructor,3,_SC("x")),
_DECL_FILE_FUNC(_typeof,1,_SC("x")),
_DECL_FILE_FUNC(close,1,_SC("x")),
_DECL_FILE_FUNC(constructor,3,"x"),
_DECL_FILE_FUNC(_typeof,1,"x"),
_DECL_FILE_FUNC(close,1,"x"),
{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);
sq_pushregistrytable(v);
sq_pushstring(v,_SC("std_file"),-1);
sq_pushstring(v,"std_file",-1);
if(SQ_SUCCEEDED(sq_get(v,-2))) {
sq_remove(v,-2); //removes the registry
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();
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)
{
SQFILE file = rabbit::std::fopen(filename,_SC("rb"));
SQFILE file = rabbit::std::fopen(filename,"rb");
int64_t ret;
unsigned short us;
@@ -334,11 +334,11 @@ rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const char *filen
case 0xBBEF:
if(rabbit::std::fread(&uc,1,sizeof(uc),file) == 0) {
rabbit::std::fclose(file);
return sq_throwerror(v,_SC("io error"));
return sq_throwerror(v,"io error");
}
if(uc != 0xBF) {
rabbit::std::fclose(file);
return sq_throwerror(v,_SC("Unrecognized encoding"));
return sq_throwerror(v,"Unrecognized encoding");
}
func = _io_file_lexfeed_PLAIN;
break;//UTF-8 ;
@@ -356,14 +356,14 @@ rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const char *filen
rabbit::std::fclose(file);
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)
{
//at least one entry must exist in order for us to push it as the environment
if(sq_gettop(v) == 0)
return sq_throwerror(v,_SC("environment table expected"));
return sq_throwerror(v,"environment table expected");
if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,printerror))) {
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)
{
SQFILE file = rabbit::std::fopen(filename,_SC("wb+"));
if(!file) return sq_throwerror(v,_SC("cannot open the file"));
SQFILE file = rabbit::std::fopen(filename,"wb+");
if(!file) return sq_throwerror(v,"cannot open the file");
if(SQ_SUCCEEDED(sq_writeclosure(v,file_write,file))) {
rabbit::std::fclose(file);
return SQ_OK;
@@ -424,11 +424,11 @@ int64_t _g_io_dofile(rabbit::VirtualMachine* v)
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[]={
_DECL_GLOBALIO_FUNC(loadfile,-2,_SC(".sb")),
_DECL_GLOBALIO_FUNC(dofile,-2,_SC(".sb")),
_DECL_GLOBALIO_FUNC(writeclosuretofile,3,_SC(".sc")),
_DECL_GLOBALIO_FUNC(loadfile,-2,".sb"),
_DECL_GLOBALIO_FUNC(dofile,-2,".sb"),
_DECL_GLOBALIO_FUNC(writeclosuretofile,3,".sc"),
{NULL,(SQFUNCTION)0,0,NULL}
};
@@ -436,14 +436,14 @@ rabbit::Result rabbit::std::register_iolib(rabbit::VirtualMachine* v)
{
int64_t top = sq_gettop(v);
//create delegate
declare_stream(v,_SC("file"),(rabbit::UserPointer)SQSTD_FILE_TYPE_TAG,_SC("std_file"),_file_methods,iolib_funcs);
sq_pushstring(v,_SC("stdout"),-1);
declare_stream(v,"file",(rabbit::UserPointer)SQSTD_FILE_TYPE_TAG, "std_file",_file_methods,iolib_funcs);
sq_pushstring(v,"stdout",-1);
rabbit::std::createfile(v,stdout,SQFalse);
sq_newslot(v,-3,SQFalse);
sq_pushstring(v,_SC("stdin"),-1);
sq_pushstring(v,"stdin",-1);
rabbit::std::createfile(v,stdin,SQFalse);
sq_newslot(v,-3,SQFalse);
sq_pushstring(v,_SC("stderr"),-1);
sq_pushstring(v,"stderr",-1);
rabbit::std::createfile(v,stderr,SQFalse);
sq_newslot(v,-3,SQFalse);
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;
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);
return 0;
}
@@ -65,26 +65,26 @@ SINGLE_ARG_FUNC(floor)
SINGLE_ARG_FUNC(ceil)
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[] = {
_DECL_FUNC(sqrt,2,_SC(".n")),
_DECL_FUNC(sin,2,_SC(".n")),
_DECL_FUNC(cos,2,_SC(".n")),
_DECL_FUNC(asin,2,_SC(".n")),
_DECL_FUNC(acos,2,_SC(".n")),
_DECL_FUNC(log,2,_SC(".n")),
_DECL_FUNC(log10,2,_SC(".n")),
_DECL_FUNC(tan,2,_SC(".n")),
_DECL_FUNC(atan,2,_SC(".n")),
_DECL_FUNC(atan2,3,_SC(".nn")),
_DECL_FUNC(pow,3,_SC(".nn")),
_DECL_FUNC(floor,2,_SC(".n")),
_DECL_FUNC(ceil,2,_SC(".n")),
_DECL_FUNC(exp,2,_SC(".n")),
_DECL_FUNC(srand,2,_SC(".n")),
_DECL_FUNC(sqrt,2,".n"),
_DECL_FUNC(sin,2,".n"),
_DECL_FUNC(cos,2,".n"),
_DECL_FUNC(asin,2,".n"),
_DECL_FUNC(acos,2,".n"),
_DECL_FUNC(log,2,".n"),
_DECL_FUNC(log10,2,".n"),
_DECL_FUNC(tan,2,".n"),
_DECL_FUNC(atan,2,".n"),
_DECL_FUNC(atan2,3,".nn"),
_DECL_FUNC(pow,3,".nn"),
_DECL_FUNC(floor,2,".n"),
_DECL_FUNC(ceil,2,".n"),
_DECL_FUNC(exp,2,".n"),
_DECL_FUNC(srand,2,".n"),
_DECL_FUNC(rand,1,NULL),
_DECL_FUNC(fabs,2,_SC(".n")),
_DECL_FUNC(abs,2,_SC(".n")),
_DECL_FUNC(fabs,2,".n"),
_DECL_FUNC(abs,2,".n"),
{NULL,(SQFUNCTION)0,0,NULL}
};
#undef _DECL_FUNC
@@ -104,10 +104,10 @@ rabbit::Result rabbit::std::register_mathlib(rabbit::VirtualMachine* v)
sq_newslot(v,-3,SQFalse);
i++;
}
sq_pushstring(v,_SC("RAND_MAX"),-1);
sq_pushstring(v,"RAND_MAX",-1);
sq_pushinteger(v,RAND_MAX);
sq_newslot(v,-3,SQFalse);
sq_pushstring(v,_SC("PI"),-1);
sq_pushstring(v,"PI",-1);
sq_pushfloat(v,(float_t)M_PI);
sq_newslot(v,-3,SQFalse);
return SQ_OK;

60
rabbit-std/sqstdrex.cpp
View File

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

50
rabbit-std/sqstdstream.cpp
View File

@@ -19,9 +19,9 @@
#define SETUP_STREAM(v) \
rabbit::std::SQStream *self = NULL; \
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()) \
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)
{
@@ -35,14 +35,14 @@ int64_t _stream_readblob(rabbit::VirtualMachine* v)
data = sq_getscratchpad(v,size);
res = self->Read(data,size);
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);
memcpy(blobp,data,res);
return 1;
}
#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)
{
@@ -99,7 +99,7 @@ int64_t _stream_readn(rabbit::VirtualMachine* v)
}
break;
default:
return sq_throwerror(v, _SC("invalid format"));
return sq_throwerror(v, "invalid format");
}
return 1;
}
@@ -110,10 +110,10 @@ int64_t _stream_writeblob(rabbit::VirtualMachine* v)
int64_t size;
SETUP_STREAM(v);
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);
if(self->Write(data,size) != size)
return sq_throwerror(v,_SC("io error"));
return sq_throwerror(v,"io error");
sq_pushinteger(v,size);
return 1;
}
@@ -182,7 +182,7 @@ int64_t _stream_writen(rabbit::VirtualMachine* v)
}
break;
default:
return sq_throwerror(v, _SC("invalid format"));
return sq_throwerror(v, "invalid format");
}
return 0;
}
@@ -199,7 +199,7 @@ int64_t _stream_seek(rabbit::VirtualMachine* v)
case 'b': origin = SQ_SEEK_SET; break;
case 'c': origin = SQ_SEEK_CUR; 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));
@@ -242,19 +242,19 @@ int64_t _stream_eos(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[] = {
_DECL_STREAM_FUNC(readblob,2,_SC("xn")),
_DECL_STREAM_FUNC(readn,2,_SC("xn")),
_DECL_STREAM_FUNC(writeblob,-2,_SC("xx")),
_DECL_STREAM_FUNC(writen,3,_SC("xnn")),
_DECL_STREAM_FUNC(seek,-2,_SC("xnn")),
_DECL_STREAM_FUNC(tell,1,_SC("x")),
_DECL_STREAM_FUNC(len,1,_SC("x")),
_DECL_STREAM_FUNC(eos,1,_SC("x")),
_DECL_STREAM_FUNC(flush,1,_SC("x")),
_DECL_STREAM_FUNC(readblob,2,"xn"),
_DECL_STREAM_FUNC(readn,2,"xn"),
_DECL_STREAM_FUNC(writeblob,-2,"xx"),
_DECL_STREAM_FUNC(writen,3,"xnn"),
_DECL_STREAM_FUNC(seek,-2,"xnn"),
_DECL_STREAM_FUNC(tell,1,"x"),
_DECL_STREAM_FUNC(len,1,"x"),
_DECL_STREAM_FUNC(eos,1,"x"),
_DECL_STREAM_FUNC(flush,1,"x"),
_DECL_STREAM_FUNC(_cloned,0,NULL),
{NULL,(SQFUNCTION)0,0,NULL}
};
@@ -262,9 +262,9 @@ static const rabbit::RegFunction _stream_methods[] = {
void init_streamclass(rabbit::VirtualMachine* v)
{
sq_pushregistrytable(v);
sq_pushstring(v,_SC("std_stream"),-1);
sq_pushstring(v,"std_stream",-1);
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_settypetag(v,-1,(rabbit::UserPointer)((uint64_t)SQSTD_STREAM_TYPE_TAG));
int64_t i = 0;
@@ -278,8 +278,8 @@ void init_streamclass(rabbit::VirtualMachine* v)
}
sq_newslot(v,-3,SQFalse);
sq_pushroottable(v);
sq_pushstring(v,_SC("stream"),-1);
sq_pushstring(v,_SC("std_stream"),-1);
sq_pushstring(v,"stream",-1);
sq_pushstring(v,"std_stream",-1);
sq_get(v,-4);
sq_newslot(v,-3,SQFalse);
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)
{
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);
//create delegate
init_streamclass(v);
sq_pushregistrytable(v);
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))) {
sq_newclass(v,SQTrue);
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_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);
}
}

66
rabbit-std/sqstdstring.cpp
View File

@@ -44,7 +44,7 @@ static int64_t validate_format(rabbit::VirtualMachine* v, char *fmt, const char
n++;
wc++;
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';
if(wc > 0) {
@@ -61,7 +61,7 @@ static int64_t validate_format(rabbit::VirtualMachine* v, char *fmt, const char
n++;
wc++;
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';
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 )
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));
fmt[(n-start)+2] = '\0';
return n;
@@ -104,7 +104,7 @@ rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstri
else {
n++;
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);
if(n < 0) return -1;
int64_t addlen = 0;
@@ -115,7 +115,7 @@ rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstri
switch(format[n]) {
case 's':
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));
valtype = 's';
break;
@@ -126,27 +126,27 @@ rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstri
int64_t fpos = flen - 1;
char f = fmt[fpos];
const char *prec = (const char *)_PRINT_INT_PREC;
while(*prec != _SC('\0')) {
while(*prec != '\0') {
fmt[fpos++] = *prec++;
}
fmt[fpos++] = f;
fmt[fpos++] = _SC('\0');
fmt[fpos++] = '\0';
}
#endif
case 'c':
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));
valtype = 'i';
break;
case 'f': case 'g': case 'G': case 'e': case 'E':
if(SQ_FAILED(sq_getfloat(v,nparam,&tf)))
return sq_throwerror(v,_SC("float expected for the specified format"));
return sq_throwerror(v,"float expected for the specified format");
addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(char));
valtype = 'f';
break;
default:
return sq_throwerror(v,_SC("invalid format"));
return sq_throwerror(v,"invalid format");
}
n++;
allocated += addlen + sizeof(char);
@@ -243,7 +243,7 @@ static int64_t _string_split(rabbit::VirtualMachine* v)
sq_getstring(v,2,&str);
sq_getstring(v,3,&seps);
int64_t sepsize = sq_getsize(v,3);
if(sepsize == 0) return sq_throwerror(v,_SC("empty separators string"));
if(sepsize == 0) return sq_throwerror(v,"empty separators string");
int64_t memsize = (sq_getsize(v,2)+1)*sizeof(char);
stemp = sq_getscratchpad(v,memsize);
memcpy(stemp,str,memsize);
@@ -285,7 +285,7 @@ static int64_t _string_escape(rabbit::VirtualMachine* v)
sq_push(v,2);
return 1;
}
const char *escpat = _SC("\\x%02x");
const char *escpat = "\\x%02x";
const int64_t maxescsize = 4;
int64_t destcharsize = (size * maxescsize); //assumes every char could be escaped
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)
{
sq_newtable(v);
sq_pushstring(v,_SC("begin"),-1);
sq_pushstring(v,"begin",-1);
sq_pushinteger(v,begin - str);
sq_rawset(v,-3);
sq_pushstring(v,_SC("end"),-1);
sq_pushstring(v,"end",-1);
sq_pushinteger(v,end - str);
sq_rawset(v,-3);
}
@@ -458,33 +458,33 @@ static int64_t _regexp_constructor(rabbit::VirtualMachine* v)
static int64_t _regexp__typeof(rabbit::VirtualMachine* v)
{
sq_pushstring(v,_SC("regexp"),-1);
sq_pushstring(v,"regexp",-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[]={
_DECL_REX_FUNC(constructor,2,_SC(".s")),
_DECL_REX_FUNC(search,-2,_SC("xsn")),
_DECL_REX_FUNC(match,2,_SC("xs")),
_DECL_REX_FUNC(capture,-2,_SC("xsn")),
_DECL_REX_FUNC(subexpcount,1,_SC("x")),
_DECL_REX_FUNC(_typeof,1,_SC("x")),
_DECL_REX_FUNC(constructor,2,".s"),
_DECL_REX_FUNC(search,-2,"xsn"),
_DECL_REX_FUNC(match,2,"xs"),
_DECL_REX_FUNC(capture,-2,"xsn"),
_DECL_REX_FUNC(subexpcount,1,"x"),
_DECL_REX_FUNC(_typeof,1,"x"),
{NULL,(SQFUNCTION)0,0,NULL}
};
#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[]={
_DECL_FUNC(format,-2,_SC(".s")),
_DECL_FUNC(printf,-2,_SC(".s")),
_DECL_FUNC(strip,2,_SC(".s")),
_DECL_FUNC(lstrip,2,_SC(".s")),
_DECL_FUNC(rstrip,2,_SC(".s")),
_DECL_FUNC(split,3,_SC(".ss")),
_DECL_FUNC(escape,2,_SC(".s")),
_DECL_FUNC(startswith,3,_SC(".ss")),
_DECL_FUNC(endswith,3,_SC(".ss")),
_DECL_FUNC(format,-2,".s"),
_DECL_FUNC(printf,-2,".s"),
_DECL_FUNC(strip,2,".s"),
_DECL_FUNC(lstrip,2,".s"),
_DECL_FUNC(rstrip,2,".s"),
_DECL_FUNC(split,3,".ss"),
_DECL_FUNC(escape,2,".s"),
_DECL_FUNC(startswith,3,".ss"),
_DECL_FUNC(endswith,3,".ss"),
{NULL,(SQFUNCTION)0,0,NULL}
};
#undef _DECL_FUNC
@@ -492,7 +492,7 @@ static const rabbit::RegFunction stringlib_funcs[]={
int64_t rabbit::std::register_stringlib(rabbit::VirtualMachine* v)
{
sq_pushstring(v,_SC("regexp"),-1);
sq_pushstring(v,"regexp",-1);
sq_newclass(v,SQFalse);
int64_t i = 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));
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;
sq_getstring(v,2,&s);
if(remove(s)==-1)
return sq_throwerror(v,_SC("remove() failed"));
return sq_throwerror(v,"remove() failed");
return 0;
}
@@ -64,7 +64,7 @@ static int64_t _system_rename(rabbit::VirtualMachine* v)
sq_getstring(v,2,&oldn);
sq_getstring(v,3,&newn);
if(rename(oldn,newn)==-1)
return sq_throwerror(v,_SC("rename() failed"));
return sq_throwerror(v,"rename() failed");
return 0;
}
@@ -96,30 +96,30 @@ static int64_t _system_date(rabbit::VirtualMachine* v)
else
date = localtime(&t);
if(!date)
return sq_throwerror(v,_SC("crt api failure"));
return sq_throwerror(v,"crt api failure");
sq_newtable(v);
_set_integer_slot(v, _SC("sec"), date->tm_sec);
_set_integer_slot(v, _SC("min"), date->tm_min);
_set_integer_slot(v, _SC("hour"), date->tm_hour);
_set_integer_slot(v, _SC("day"), date->tm_mday);
_set_integer_slot(v, _SC("month"), date->tm_mon);
_set_integer_slot(v, _SC("year"), date->tm_year+1900);
_set_integer_slot(v, _SC("wday"), date->tm_wday);
_set_integer_slot(v, _SC("yday"), date->tm_yday);
_set_integer_slot(v, "sec", date->tm_sec);
_set_integer_slot(v, "min", date->tm_min);
_set_integer_slot(v, "hour", date->tm_hour);
_set_integer_slot(v, "day", date->tm_mday);
_set_integer_slot(v, "month", date->tm_mon);
_set_integer_slot(v, "year", date->tm_year+1900);
_set_integer_slot(v, "wday", date->tm_wday);
_set_integer_slot(v, "yday", date->tm_yday);
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[]={
_DECL_FUNC(getenv,2,_SC(".s")),
_DECL_FUNC(system,2,_SC(".s")),
_DECL_FUNC(getenv,2,".s"),
_DECL_FUNC(system,2,".s"),
_DECL_FUNC(clock,0,NULL),
_DECL_FUNC(time,1,NULL),
_DECL_FUNC(date,-1,_SC(".nn")),
_DECL_FUNC(remove,2,_SC(".s")),
_DECL_FUNC(rename,3,_SC(".ss")),
_DECL_FUNC(date,-1,".nn"),
_DECL_FUNC(remove,2,".s"),
_DECL_FUNC(rename,3,".ss"),
{NULL,(SQFUNCTION)0,0,NULL}
};
#undef _DECL_FUNC