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

[DEV] continue refacto

Browse Source
This commit is contained in:
Edouard DUPIN 2018-06-27 00:48:45 +02:00
parent d7cdc92133
commit 92ffade769
34 changed files with 538 additions and 979 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
cmdLine/rabbit.cpp
View File

@ -48,7 +48,7 @@ int MemAllocHook(int allocType,
#endif #endif
SQInteger quit(HSQUIRRELVM v) SQInteger quit(HRABBITVM v)
{ {
int *done; int *done;
sq_getuserpointer(v,-1,(SQUserPointer*)&done); sq_getuserpointer(v,-1,(SQUserPointer*)&done);
@ -56,7 +56,7 @@ SQInteger quit(HSQUIRRELVM v)
return 0; return 0;
} }
void printfunc(HSQUIRRELVM SQ_UNUSED_ARG(v),const SQChar *s,...) void printfunc(HRABBITVM SQ_UNUSED_ARG(v),const SQChar *s,...)
{ {
va_list vl; va_list vl;
va_start(vl, s); va_start(vl, s);
@ -64,7 +64,7 @@ void printfunc(HSQUIRRELVM SQ_UNUSED_ARG(v),const SQChar *s,...)
va_end(vl); va_end(vl);
} }
void errorfunc(HSQUIRRELVM SQ_UNUSED_ARG(v),const SQChar *s,...) void errorfunc(HRABBITVM SQ_UNUSED_ARG(v),const SQChar *s,...)
{ {
va_list vl; va_list vl;
va_start(vl, s); va_start(vl, s);
@ -74,7 +74,7 @@ void errorfunc(HSQUIRRELVM SQ_UNUSED_ARG(v),const SQChar *s,...)
void PrintVersionInfos() void PrintVersionInfos()
{ {
scfprintf(stdout,_SC("%s %s (%d bits)\n"),SQUIRREL_VERSION,SQUIRREL_COPYRIGHT,((int)(sizeof(SQInteger)*8))); scfprintf(stdout,_SC("%s %s (%d bits)\n"),RABBIT_VERSION,RABBIT_COPYRIGHT,((int)(sizeof(SQInteger)*8)));
} }
void PrintUsage() void PrintUsage()
@ -93,7 +93,7 @@ void PrintUsage()
#define _DONE 2 #define _DONE 2
#define _ERROR 3 #define _ERROR 3
//<<FIXME>> this func is a mess //<<FIXME>> this func is a mess
int getargs(HSQUIRRELVM v,int argc, char* argv[],SQInteger *retval) int getargs(HRABBITVM v,int argc, char* argv[],SQInteger *retval)
{ {
int i; int i;
int compiles_only = 0; int compiles_only = 0;
@ -231,7 +231,7 @@ int getargs(HSQUIRRELVM v,int argc, char* argv[],SQInteger *retval)
return _INTERACTIVE; return _INTERACTIVE;
} }
void Interactive(HSQUIRRELVM v) void Interactive(HRABBITVM v)
{ {
#define MAXINPUT 1024 #define MAXINPUT 1024
@ -315,7 +315,7 @@ void Interactive(HSQUIRRELVM v)
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
HSQUIRRELVM v; HRABBITVM v;
SQInteger retval = 0; SQInteger retval = 0;
#if defined(_MSC_VER) && defined(_DEBUG) #if defined(_MSC_VER) && defined(_DEBUG)
_CrtSetAllocHook(MemAllocHook); _CrtSetAllocHook(MemAllocHook);

8
rabbit-std/sqstdaux.cpp
View File

@ -10,7 +10,7 @@
#include <rabbit-std/sqstdaux.hpp> #include <rabbit-std/sqstdaux.hpp>
#include <assert.h> #include <assert.h>
void sqstd_printcallstack(HSQUIRRELVM v) void sqstd_printcallstack(HRABBITVM v)
{ {
SQPRINTFUNCTION pf = sq_geterrorfunc(v); SQPRINTFUNCTION pf = sq_geterrorfunc(v);
if(pf) { if(pf) {
@ -103,7 +103,7 @@ void sqstd_printcallstack(HSQUIRRELVM v)
} }
} }
static SQInteger _sqstd_aux_printerror(HSQUIRRELVM v) static SQInteger _sqstd_aux_printerror(HRABBITVM v)
{ {
SQPRINTFUNCTION pf = sq_geterrorfunc(v); SQPRINTFUNCTION pf = sq_geterrorfunc(v);
if(pf) { if(pf) {
@ -121,7 +121,7 @@ static SQInteger _sqstd_aux_printerror(HSQUIRRELVM v)
return 0; return 0;
} }
void _sqstd_compiler_error(HSQUIRRELVM v,const SQChar *sErr,const SQChar *sSource,SQInteger line,SQInteger column) void _sqstd_compiler_error(HRABBITVM v,const SQChar *sErr,const SQChar *sSource,SQInteger line,SQInteger column)
{ {
SQPRINTFUNCTION pf = sq_geterrorfunc(v); SQPRINTFUNCTION pf = sq_geterrorfunc(v);
if(pf) { if(pf) {
@ -129,7 +129,7 @@ void _sqstd_compiler_error(HSQUIRRELVM v,const SQChar *sErr,const SQChar *sSourc
} }
} }
void sqstd_seterrorhandlers(HSQUIRRELVM v) void sqstd_seterrorhandlers(HRABBITVM v)
{ {
sq_setcompilererrorhandler(v,_sqstd_compiler_error); sq_setcompilererrorhandler(v,_sqstd_compiler_error);
sq_newclosure(v,_sqstd_aux_printerror,0); sq_newclosure(v,_sqstd_aux_printerror,0);

4
rabbit-std/sqstdaux.hpp
View File

@ -7,5 +7,5 @@
*/ */
#pragma once #pragma once
SQUIRREL_API void sqstd_seterrorhandlers(HSQUIRRELVM v); RABBIT_API void sqstd_seterrorhandlers(HRABBITVM v);
SQUIRREL_API void sqstd_printcallstack(HSQUIRRELVM v); RABBIT_API void sqstd_printcallstack(HRABBITVM v);

36
rabbit-std/sqstdblob.cpp
View File

@ -20,7 +20,7 @@
return sq_throwerror(v,_SC("the blob is invalid")); return sq_throwerror(v,_SC("the blob is invalid"));
static SQInteger _blob_resize(HSQUIRRELVM v) static SQInteger _blob_resize(HRABBITVM v)
{ {
SETUP_BLOB(v); SETUP_BLOB(v);
SQInteger size; SQInteger size;
@ -43,7 +43,7 @@ static void __swap_word(unsigned short *n)
*n=(unsigned short)((*n>>8)&0x00FF)| ((*n<<8)&0xFF00); *n=(unsigned short)((*n>>8)&0x00FF)| ((*n<<8)&0xFF00);
} }
static SQInteger _blob_swap4(HSQUIRRELVM v) static SQInteger _blob_swap4(HRABBITVM v)
{ {
SETUP_BLOB(v); SETUP_BLOB(v);
SQInteger num=(self->Len()-(self->Len()%4))>>2; SQInteger num=(self->Len()-(self->Len()%4))>>2;
@ -54,7 +54,7 @@ static SQInteger _blob_swap4(HSQUIRRELVM v)
return 0; return 0;
} }
static SQInteger _blob_swap2(HSQUIRRELVM v) static SQInteger _blob_swap2(HRABBITVM v)
{ {
SETUP_BLOB(v); SETUP_BLOB(v);
SQInteger num=(self->Len()-(self->Len()%2))>>1; SQInteger num=(self->Len()-(self->Len()%2))>>1;
@ -65,7 +65,7 @@ static SQInteger _blob_swap2(HSQUIRRELVM v)
return 0; return 0;
} }
static SQInteger _blob__set(HSQUIRRELVM v) static SQInteger _blob__set(HRABBITVM v)
{ {
SETUP_BLOB(v); SETUP_BLOB(v);
SQInteger idx,val; SQInteger idx,val;
@ -78,7 +78,7 @@ static SQInteger _blob__set(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger _blob__get(HSQUIRRELVM v) static SQInteger _blob__get(HRABBITVM v)
{ {
SETUP_BLOB(v); SETUP_BLOB(v);
SQInteger idx; SQInteger idx;
@ -95,7 +95,7 @@ static SQInteger _blob__get(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger _blob__nexti(HSQUIRRELVM v) static SQInteger _blob__nexti(HRABBITVM v)
{ {
SETUP_BLOB(v); SETUP_BLOB(v);
if(sq_gettype(v,2) == OT_NULL) { if(sq_gettype(v,2) == OT_NULL) {
@ -114,7 +114,7 @@ static SQInteger _blob__nexti(HSQUIRRELVM v)
return sq_throwerror(v,_SC("internal error (_nexti) wrong argument type")); return sq_throwerror(v,_SC("internal error (_nexti) wrong argument type"));
} }
static SQInteger _blob__typeof(HSQUIRRELVM v) static SQInteger _blob__typeof(HRABBITVM v)
{ {
sq_pushstring(v,_SC("blob"),-1); sq_pushstring(v,_SC("blob"),-1);
return 1; return 1;
@ -128,7 +128,7 @@ static SQInteger _blob_releasehook(SQUserPointer p, SQInteger SQ_UNUSED_ARG(size
return 1; return 1;
} }
static SQInteger _blob_constructor(HSQUIRRELVM v) static SQInteger _blob_constructor(HRABBITVM v)
{ {
SQInteger nparam = sq_gettop(v); SQInteger nparam = sq_gettop(v);
SQInteger size = 0; SQInteger size = 0;
@ -148,7 +148,7 @@ static SQInteger _blob_constructor(HSQUIRRELVM v)
return 0; return 0;
} }
static SQInteger _blob__cloned(HSQUIRRELVM v) static SQInteger _blob__cloned(HRABBITVM v)
{ {
SQBlob *other = NULL; SQBlob *other = NULL;
{ {
@ -185,7 +185,7 @@ static const SQRegFunction _blob_methods[] = {
//GLOBAL FUNCTIONS //GLOBAL FUNCTIONS
static SQInteger _g_blob_casti2f(HSQUIRRELVM v) static SQInteger _g_blob_casti2f(HRABBITVM v)
{ {
SQInteger i; SQInteger i;
sq_getinteger(v,2,&i); sq_getinteger(v,2,&i);
@ -193,7 +193,7 @@ static SQInteger _g_blob_casti2f(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger _g_blob_castf2i(HSQUIRRELVM v) static SQInteger _g_blob_castf2i(HRABBITVM v)
{ {
SQFloat f; SQFloat f;
sq_getfloat(v,2,&f); sq_getfloat(v,2,&f);
@ -201,7 +201,7 @@ static SQInteger _g_blob_castf2i(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger _g_blob_swap2(HSQUIRRELVM v) static SQInteger _g_blob_swap2(HRABBITVM v)
{ {
SQInteger i; SQInteger i;
sq_getinteger(v,2,&i); sq_getinteger(v,2,&i);
@ -210,7 +210,7 @@ static SQInteger _g_blob_swap2(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger _g_blob_swap4(HSQUIRRELVM v) static SQInteger _g_blob_swap4(HRABBITVM v)
{ {
SQInteger i; SQInteger i;
sq_getinteger(v,2,&i); sq_getinteger(v,2,&i);
@ -220,7 +220,7 @@ static SQInteger _g_blob_swap4(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger _g_blob_swapfloat(HSQUIRRELVM v) static SQInteger _g_blob_swapfloat(HRABBITVM v)
{ {
SQFloat f; SQFloat f;
sq_getfloat(v,2,&f); sq_getfloat(v,2,&f);
@ -239,7 +239,7 @@ static const SQRegFunction bloblib_funcs[]={
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
SQRESULT sqstd_getblob(HSQUIRRELVM v,SQInteger idx,SQUserPointer *ptr) SQRESULT sqstd_getblob(HRABBITVM v,SQInteger idx,SQUserPointer *ptr)
{ {
SQBlob *blob; SQBlob *blob;
if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG)))
@ -248,7 +248,7 @@ SQRESULT sqstd_getblob(HSQUIRRELVM v,SQInteger idx,SQUserPointer *ptr)
return SQ_OK; return SQ_OK;
} }
SQInteger sqstd_getblobsize(HSQUIRRELVM v,SQInteger idx) SQInteger sqstd_getblobsize(HRABBITVM v,SQInteger idx)
{ {
SQBlob *blob; SQBlob *blob;
if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG)))
@ -256,7 +256,7 @@ SQInteger sqstd_getblobsize(HSQUIRRELVM v,SQInteger idx)
return blob->Len(); return blob->Len();
} }
SQUserPointer sqstd_createblob(HSQUIRRELVM v, SQInteger size) SQUserPointer sqstd_createblob(HRABBITVM v, SQInteger size)
{ {
SQInteger top = sq_gettop(v); SQInteger top = sq_gettop(v);
sq_pushregistrytable(v); sq_pushregistrytable(v);
@ -276,7 +276,7 @@ SQUserPointer sqstd_createblob(HSQUIRRELVM v, SQInteger size)
return NULL; return NULL;
} }
SQRESULT sqstd_register_bloblib(HSQUIRRELVM v) SQRESULT sqstd_register_bloblib(HRABBITVM v)
{ {
return declare_stream(v,_SC("blob"),(SQUserPointer)SQSTD_BLOB_TYPE_TAG,_SC("std_blob"),_blob_methods,bloblib_funcs); return declare_stream(v,_SC("blob"),(SQUserPointer)SQSTD_BLOB_TYPE_TAG,_SC("std_blob"),_blob_methods,bloblib_funcs);
} }

8
rabbit-std/sqstdblob.hpp
View File

@ -7,9 +7,9 @@
*/ */
#pragma once #pragma once
SQUIRREL_API SQUserPointer sqstd_createblob(HSQUIRRELVM v, SQInteger size); RABBIT_API SQUserPointer sqstd_createblob(HRABBITVM v, SQInteger size);
SQUIRREL_API SQRESULT sqstd_getblob(HSQUIRRELVM v,SQInteger idx,SQUserPointer *ptr); RABBIT_API SQRESULT sqstd_getblob(HRABBITVM v,SQInteger idx,SQUserPointer *ptr);
SQUIRREL_API SQInteger sqstd_getblobsize(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQInteger sqstd_getblobsize(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sqstd_register_bloblib(HSQUIRRELVM v); RABBIT_API SQRESULT sqstd_register_bloblib(HRABBITVM v);

24
rabbit-std/sqstdio.cpp
View File

@ -116,7 +116,7 @@ private:
bool _owns; bool _owns;
}; };
static SQInteger _file__typeof(HSQUIRRELVM v) static SQInteger _file__typeof(HRABBITVM v)
{ {
sq_pushstring(v,_SC("file"),-1); sq_pushstring(v,_SC("file"),-1);
return 1; return 1;
@ -130,7 +130,7 @@ static SQInteger _file_releasehook(SQUserPointer p, SQInteger SQ_UNUSED_ARG(size
return 1; return 1;
} }
static SQInteger _file_constructor(HSQUIRRELVM v) static SQInteger _file_constructor(HRABBITVM v)
{ {
const SQChar *filename,*mode; const SQChar *filename,*mode;
bool owns = true; bool owns = true;
@ -158,7 +158,7 @@ static SQInteger _file_constructor(HSQUIRRELVM v)
return 0; return 0;
} }
static SQInteger _file_close(HSQUIRRELVM v) static SQInteger _file_close(HRABBITVM v)
{ {
SQFile *self = NULL; SQFile *self = NULL;
if(SQ_SUCCEEDED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)SQSTD_FILE_TYPE_TAG)) if(SQ_SUCCEEDED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)SQSTD_FILE_TYPE_TAG))
@ -180,7 +180,7 @@ static const SQRegFunction _file_methods[] = {
SQRESULT sqstd_createfile(HSQUIRRELVM v, SQFILE file,SQBool own) SQRESULT sqstd_createfile(HRABBITVM v, SQFILE file,SQBool own)
{ {
SQInteger top = sq_gettop(v); SQInteger top = sq_gettop(v);
sq_pushregistrytable(v); sq_pushregistrytable(v);
@ -204,7 +204,7 @@ SQRESULT sqstd_createfile(HSQUIRRELVM v, SQFILE file,SQBool own)
return SQ_ERROR; return SQ_ERROR;
} }
SQRESULT sqstd_getfile(HSQUIRRELVM v, SQInteger idx, SQFILE *file) SQRESULT sqstd_getfile(HRABBITVM v, SQInteger idx, SQFILE *file)
{ {
SQFile *fileobj = NULL; SQFile *fileobj = NULL;
if(SQ_SUCCEEDED(sq_getinstanceup(v,idx,(SQUserPointer*)&fileobj,(SQUserPointer)SQSTD_FILE_TYPE_TAG))) { if(SQ_SUCCEEDED(sq_getinstanceup(v,idx,(SQUserPointer*)&fileobj,(SQUserPointer)SQSTD_FILE_TYPE_TAG))) {
@ -344,7 +344,7 @@ SQInteger file_write(SQUserPointer file,SQUserPointer p,SQInteger size)
return sqstd_fwrite(p,1,size,(SQFILE)file); return sqstd_fwrite(p,1,size,(SQFILE)file);
} }
SQRESULT sqstd_loadfile(HSQUIRRELVM v,const SQChar *filename,SQBool printerror) SQRESULT sqstd_loadfile(HRABBITVM v,const SQChar *filename,SQBool printerror)
{ {
SQFILE file = sqstd_fopen(filename,_SC("rb")); SQFILE file = sqstd_fopen(filename,_SC("rb"));
@ -404,7 +404,7 @@ SQRESULT sqstd_loadfile(HSQUIRRELVM v,const SQChar *filename,SQBool printerror)
return sq_throwerror(v,_SC("cannot open the file")); return sq_throwerror(v,_SC("cannot open the file"));
} }
SQRESULT sqstd_dofile(HSQUIRRELVM v,const SQChar *filename,SQBool retval,SQBool printerror) SQRESULT sqstd_dofile(HRABBITVM v,const SQChar *filename,SQBool retval,SQBool printerror)
{ {
//at least one entry must exist in order for us to push it as the environment //at least one entry must exist in order for us to push it as the environment
if(sq_gettop(v) == 0) if(sq_gettop(v) == 0)
@ -421,7 +421,7 @@ SQRESULT sqstd_dofile(HSQUIRRELVM v,const SQChar *filename,SQBool retval,SQBool
return SQ_ERROR; return SQ_ERROR;
} }
SQRESULT sqstd_writeclosuretofile(HSQUIRRELVM v,const SQChar *filename) SQRESULT sqstd_writeclosuretofile(HRABBITVM v,const SQChar *filename)
{ {
SQFILE file = sqstd_fopen(filename,_SC("wb+")); SQFILE file = sqstd_fopen(filename,_SC("wb+"));
if(!file) return sq_throwerror(v,_SC("cannot open the file")); if(!file) return sq_throwerror(v,_SC("cannot open the file"));
@ -433,7 +433,7 @@ SQRESULT sqstd_writeclosuretofile(HSQUIRRELVM v,const SQChar *filename)
return SQ_ERROR; //forward the error return SQ_ERROR; //forward the error
} }
SQInteger _g_io_loadfile(HSQUIRRELVM v) SQInteger _g_io_loadfile(HRABBITVM v)
{ {
const SQChar *filename; const SQChar *filename;
SQBool printerror = SQFalse; SQBool printerror = SQFalse;
@ -446,7 +446,7 @@ SQInteger _g_io_loadfile(HSQUIRRELVM v)
return SQ_ERROR; //propagates the error return SQ_ERROR; //propagates the error
} }
SQInteger _g_io_writeclosuretofile(HSQUIRRELVM v) SQInteger _g_io_writeclosuretofile(HRABBITVM v)
{ {
const SQChar *filename; const SQChar *filename;
sq_getstring(v,2,&filename); sq_getstring(v,2,&filename);
@ -455,7 +455,7 @@ SQInteger _g_io_writeclosuretofile(HSQUIRRELVM v)
return SQ_ERROR; //propagates the error return SQ_ERROR; //propagates the error
} }
SQInteger _g_io_dofile(HSQUIRRELVM v) SQInteger _g_io_dofile(HRABBITVM v)
{ {
const SQChar *filename; const SQChar *filename;
SQBool printerror = SQFalse; SQBool printerror = SQFalse;
@ -477,7 +477,7 @@ static const SQRegFunction iolib_funcs[]={
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
SQRESULT sqstd_register_iolib(HSQUIRRELVM v) SQRESULT sqstd_register_iolib(HRABBITVM v)
{ {
SQInteger top = sq_gettop(v); SQInteger top = sq_gettop(v);
//create delegate //create delegate

28
rabbit-std/sqstdio.hpp
View File

@ -27,22 +27,22 @@ struct SQStream {
typedef void* SQFILE; typedef void* SQFILE;
SQUIRREL_API SQFILE sqstd_fopen(const SQChar *,const SQChar *); RABBIT_API SQFILE sqstd_fopen(const SQChar *,const SQChar *);
SQUIRREL_API SQInteger sqstd_fread(SQUserPointer, SQInteger, SQInteger, SQFILE); RABBIT_API SQInteger sqstd_fread(SQUserPointer, SQInteger, SQInteger, SQFILE);
SQUIRREL_API SQInteger sqstd_fwrite(const SQUserPointer, SQInteger, SQInteger, SQFILE); RABBIT_API SQInteger sqstd_fwrite(const SQUserPointer, SQInteger, SQInteger, SQFILE);
SQUIRREL_API SQInteger sqstd_fseek(SQFILE , SQInteger , SQInteger); RABBIT_API SQInteger sqstd_fseek(SQFILE , SQInteger , SQInteger);
SQUIRREL_API SQInteger sqstd_ftell(SQFILE); RABBIT_API SQInteger sqstd_ftell(SQFILE);
SQUIRREL_API SQInteger sqstd_fflush(SQFILE); RABBIT_API SQInteger sqstd_fflush(SQFILE);
SQUIRREL_API SQInteger sqstd_fclose(SQFILE); RABBIT_API SQInteger sqstd_fclose(SQFILE);
SQUIRREL_API SQInteger sqstd_feof(SQFILE); RABBIT_API SQInteger sqstd_feof(SQFILE);
SQUIRREL_API SQRESULT sqstd_createfile(HSQUIRRELVM v, SQFILE file,SQBool own); RABBIT_API SQRESULT sqstd_createfile(HRABBITVM v, SQFILE file,SQBool own);
SQUIRREL_API SQRESULT sqstd_getfile(HSQUIRRELVM v, SQInteger idx, SQFILE *file); RABBIT_API SQRESULT sqstd_getfile(HRABBITVM v, SQInteger idx, SQFILE *file);
//compiler helpers //compiler helpers
SQUIRREL_API SQRESULT sqstd_loadfile(HSQUIRRELVM v,const SQChar *filename,SQBool printerror); RABBIT_API SQRESULT sqstd_loadfile(HRABBITVM v,const SQChar *filename,SQBool printerror);
SQUIRREL_API SQRESULT sqstd_dofile(HSQUIRRELVM v,const SQChar *filename,SQBool retval,SQBool printerror); RABBIT_API SQRESULT sqstd_dofile(HRABBITVM v,const SQChar *filename,SQBool retval,SQBool printerror);
SQUIRREL_API SQRESULT sqstd_writeclosuretofile(HSQUIRRELVM v,const SQChar *filename); RABBIT_API SQRESULT sqstd_writeclosuretofile(HRABBITVM v,const SQChar *filename);
SQUIRREL_API SQRESULT sqstd_register_iolib(HSQUIRRELVM v); RABBIT_API SQRESULT sqstd_register_iolib(HRABBITVM v);

12
rabbit-std/sqstdmath.cpp
View File

@ -11,14 +11,14 @@
#include <stdlib.h> #include <stdlib.h>
#include <rabbit-std/sqstdmath.hpp> #include <rabbit-std/sqstdmath.hpp>
#define SINGLE_ARG_FUNC(_funcname) static SQInteger math_##_funcname(HSQUIRRELVM v){ \ #define SINGLE_ARG_FUNC(_funcname) static SQInteger math_##_funcname(HRABBITVM v){ \
SQFloat f; \ SQFloat f; \
sq_getfloat(v,2,&f); \ sq_getfloat(v,2,&f); \
sq_pushfloat(v,(SQFloat)_funcname(f)); \ sq_pushfloat(v,(SQFloat)_funcname(f)); \
return 1; \ return 1; \
} }
#define TWO_ARGS_FUNC(_funcname) static SQInteger math_##_funcname(HSQUIRRELVM v){ \ #define TWO_ARGS_FUNC(_funcname) static SQInteger math_##_funcname(HRABBITVM v){ \
SQFloat p1,p2; \ SQFloat p1,p2; \
sq_getfloat(v,2,&p1); \ sq_getfloat(v,2,&p1); \
sq_getfloat(v,3,&p2); \ sq_getfloat(v,3,&p2); \
@ -26,7 +26,7 @@
return 1; \ return 1; \
} }
static SQInteger math_srand(HSQUIRRELVM v) static SQInteger math_srand(HRABBITVM v)
{ {
SQInteger i; SQInteger i;
if(SQ_FAILED(sq_getinteger(v,2,&i))) if(SQ_FAILED(sq_getinteger(v,2,&i)))
@ -35,13 +35,13 @@ static SQInteger math_srand(HSQUIRRELVM v)
return 0; return 0;
} }
static SQInteger math_rand(HSQUIRRELVM v) static SQInteger math_rand(HRABBITVM v)
{ {
sq_pushinteger(v,rand()); sq_pushinteger(v,rand());
return 1; return 1;
} }
static SQInteger math_abs(HSQUIRRELVM v) static SQInteger math_abs(HRABBITVM v)
{ {
SQInteger n; SQInteger n;
sq_getinteger(v,2,&n); sq_getinteger(v,2,&n);
@ -93,7 +93,7 @@ static const SQRegFunction mathlib_funcs[] = {
#define M_PI (3.14159265358979323846) #define M_PI (3.14159265358979323846)
#endif #endif
SQRESULT sqstd_register_mathlib(HSQUIRRELVM v) SQRESULT sqstd_register_mathlib(HRABBITVM v)
{ {
SQInteger i=0; SQInteger i=0;
while(mathlib_funcs[i].name!=0) { while(mathlib_funcs[i].name!=0) {

4
rabbit-std/sqstdmath.hpp
View File

@ -7,5 +7,7 @@
*/ */
#pragma once #pragma once
SQUIRREL_API SQRESULT sqstd_register_mathlib(HSQUIRRELVM v); #include <rabbit/rabbit.hpp>
RABBIT_API SQRESULT sqstd_register_mathlib(HRABBITVM v);

24
rabbit-std/sqstdstream.cpp
View File

@ -23,7 +23,7 @@
if(!self || !self->IsValid()) \ if(!self || !self->IsValid()) \
return sq_throwerror(v,_SC("the stream is invalid")); return sq_throwerror(v,_SC("the stream is invalid"));
SQInteger _stream_readblob(HSQUIRRELVM v) SQInteger _stream_readblob(HRABBITVM v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
SQUserPointer data,blobp; SQUserPointer data,blobp;
@ -44,7 +44,7 @@ SQInteger _stream_readblob(HSQUIRRELVM v)
#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,_SC("io error")); \
} }
SQInteger _stream_readn(HSQUIRRELVM v) SQInteger _stream_readn(HRABBITVM v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
SQInteger format; SQInteger format;
@ -104,7 +104,7 @@ SQInteger _stream_readn(HSQUIRRELVM v)
return 1; return 1;
} }
SQInteger _stream_writeblob(HSQUIRRELVM v) SQInteger _stream_writeblob(HRABBITVM v)
{ {
SQUserPointer data; SQUserPointer data;
SQInteger size; SQInteger size;
@ -118,7 +118,7 @@ SQInteger _stream_writeblob(HSQUIRRELVM v)
return 1; return 1;
} }
SQInteger _stream_writen(HSQUIRRELVM v) SQInteger _stream_writen(HRABBITVM v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
SQInteger format, ti; SQInteger format, ti;
@ -187,7 +187,7 @@ SQInteger _stream_writen(HSQUIRRELVM v)
return 0; return 0;
} }
SQInteger _stream_seek(HSQUIRRELVM v) SQInteger _stream_seek(HRABBITVM v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
SQInteger offset, origin = SQ_SEEK_SET; SQInteger offset, origin = SQ_SEEK_SET;
@ -206,21 +206,21 @@ SQInteger _stream_seek(HSQUIRRELVM v)
return 1; return 1;
} }
SQInteger _stream_tell(HSQUIRRELVM v) SQInteger _stream_tell(HRABBITVM v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
sq_pushinteger(v, self->Tell()); sq_pushinteger(v, self->Tell());
return 1; return 1;
} }
SQInteger _stream_len(HSQUIRRELVM v) SQInteger _stream_len(HRABBITVM v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
sq_pushinteger(v, self->Len()); sq_pushinteger(v, self->Len());
return 1; return 1;
} }
SQInteger _stream_flush(HSQUIRRELVM v) SQInteger _stream_flush(HRABBITVM v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
if(!self->Flush()) if(!self->Flush())
@ -230,7 +230,7 @@ SQInteger _stream_flush(HSQUIRRELVM v)
return 1; return 1;
} }
SQInteger _stream_eos(HSQUIRRELVM v) SQInteger _stream_eos(HRABBITVM v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
if(self->EOS()) if(self->EOS())
@ -240,7 +240,7 @@ SQInteger _stream_eos(HSQUIRRELVM v)
return 1; return 1;
} }
SQInteger _stream__cloned(HSQUIRRELVM v) SQInteger _stream__cloned(HRABBITVM v)
{ {
return sq_throwerror(v,_SC("this object cannot be cloned")); return sq_throwerror(v,_SC("this object cannot be cloned"));
} }
@ -259,7 +259,7 @@ static const SQRegFunction _stream_methods[] = {
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
void init_streamclass(HSQUIRRELVM v) void init_streamclass(HRABBITVM v)
{ {
sq_pushregistrytable(v); sq_pushregistrytable(v);
sq_pushstring(v,_SC("std_stream"),-1); sq_pushstring(v,_SC("std_stream"),-1);
@ -290,7 +290,7 @@ void init_streamclass(HSQUIRRELVM v)
sq_pop(v,1); sq_pop(v,1);
} }
SQRESULT declare_stream(HSQUIRRELVM v,const SQChar* name,SQUserPointer typetag,const SQChar* reg_name,const SQRegFunction *methods,const SQRegFunction *globals) SQRESULT declare_stream(HRABBITVM v,const SQChar* name,SQUserPointer typetag,const SQChar* reg_name,const SQRegFunction *methods,const SQRegFunction *globals)
{ {
if(sq_gettype(v,-1) != OT_TABLE) if(sq_gettype(v,-1) != OT_TABLE)
return sq_throwerror(v,_SC("table expected")); return sq_throwerror(v,_SC("table expected"));

22
rabbit-std/sqstdstream.hpp
View File

@ -7,16 +7,16 @@
*/ */
#pragma once #pragma once
SQInteger _stream_readblob(HSQUIRRELVM v); SQInteger _stream_readblob(HRABBITVM v);
SQInteger _stream_readline(HSQUIRRELVM v); SQInteger _stream_readline(HRABBITVM v);
SQInteger _stream_readn(HSQUIRRELVM v); SQInteger _stream_readn(HRABBITVM v);
SQInteger _stream_writeblob(HSQUIRRELVM v); SQInteger _stream_writeblob(HRABBITVM v);
SQInteger _stream_writen(HSQUIRRELVM v); SQInteger _stream_writen(HRABBITVM v);
SQInteger _stream_seek(HSQUIRRELVM v); SQInteger _stream_seek(HRABBITVM v);
SQInteger _stream_tell(HSQUIRRELVM v); SQInteger _stream_tell(HRABBITVM v);
SQInteger _stream_len(HSQUIRRELVM v); SQInteger _stream_len(HRABBITVM v);
SQInteger _stream_eos(HSQUIRRELVM v); SQInteger _stream_eos(HRABBITVM v);
SQInteger _stream_flush(HSQUIRRELVM v); SQInteger _stream_flush(HRABBITVM v);
#define _DECL_STREAM_FUNC(name,nparams,typecheck) {_SC(#name),_stream_##name,nparams,typecheck} #define _DECL_STREAM_FUNC(name,nparams,typecheck) {_SC(#name),_stream_##name,nparams,typecheck}
SQRESULT declare_stream(HSQUIRRELVM v,const SQChar* name,SQUserPointer typetag,const SQChar* reg_name,const SQRegFunction *methods,const SQRegFunction *globals); SQRESULT declare_stream(HRABBITVM v,const SQChar* name,SQUserPointer typetag,const SQChar* reg_name,const SQRegFunction *methods,const SQRegFunction *globals);

38
rabbit-std/sqstdstring.cpp
View File

@ -26,7 +26,7 @@ static SQBool isfmtchr(SQChar ch)
return SQFalse; return SQFalse;
} }
static SQInteger validate_format(HSQUIRRELVM v, SQChar *fmt, const SQChar *src, SQInteger n,SQInteger &width) static SQInteger validate_format(HRABBITVM v, SQChar *fmt, const SQChar *src, SQInteger n,SQInteger &width)
{ {
SQChar *dummy; SQChar *dummy;
SQChar swidth[MAX_WFORMAT_LEN]; SQChar swidth[MAX_WFORMAT_LEN];
@ -71,7 +71,7 @@ static SQInteger validate_format(HSQUIRRELVM v, SQChar *fmt, const SQChar *src,
return n; return n;
} }
SQRESULT sqstd_format(HSQUIRRELVM v,SQInteger nformatstringidx,SQInteger *outlen,SQChar **output) SQRESULT sqstd_format(HRABBITVM v,SQInteger nformatstringidx,SQInteger *outlen,SQChar **output)
{ {
const SQChar *format; const SQChar *format;
SQChar *dest; SQChar *dest;
@ -160,7 +160,7 @@ SQRESULT sqstd_format(HSQUIRRELVM v,SQInteger nformatstringidx,SQInteger *outlen
return SQ_OK; return SQ_OK;
} }
static SQInteger _string_printf(HSQUIRRELVM v) static SQInteger _string_printf(HRABBITVM v)
{ {
SQChar *dest = NULL; SQChar *dest = NULL;
SQInteger length = 0; SQInteger length = 0;
@ -173,7 +173,7 @@ static SQInteger _string_printf(HSQUIRRELVM v)
return 0; return 0;
} }
static SQInteger _string_format(HSQUIRRELVM v) static SQInteger _string_format(HRABBITVM v)
{ {
SQChar *dest = NULL; SQChar *dest = NULL;
SQInteger length = 0; SQInteger length = 0;
@ -201,7 +201,7 @@ static void __strip_r(const SQChar *str,SQInteger len,const SQChar **end)
*end = t + 1; *end = t + 1;
} }
static SQInteger _string_strip(HSQUIRRELVM v) static SQInteger _string_strip(HRABBITVM v)
{ {
const SQChar *str,*start,*end; const SQChar *str,*start,*end;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
@ -212,7 +212,7 @@ static SQInteger _string_strip(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger _string_lstrip(HSQUIRRELVM v) static SQInteger _string_lstrip(HRABBITVM v)
{ {
const SQChar *str,*start; const SQChar *str,*start;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
@ -221,7 +221,7 @@ static SQInteger _string_lstrip(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger _string_rstrip(HSQUIRRELVM v) static SQInteger _string_rstrip(HRABBITVM v)
{ {
const SQChar *str,*end; const SQChar *str,*end;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
@ -231,7 +231,7 @@ static SQInteger _string_rstrip(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger _string_split(HSQUIRRELVM v) static SQInteger _string_split(HRABBITVM v)
{ {
const SQChar *str,*seps; const SQChar *str,*seps;
SQChar *stemp; SQChar *stemp;
@ -269,7 +269,7 @@ static SQInteger _string_split(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger _string_escape(HSQUIRRELVM v) static SQInteger _string_escape(HRABBITVM v)
{ {
const SQChar *str; const SQChar *str;
SQChar *dest,*resstr; SQChar *dest,*resstr;
@ -339,7 +339,7 @@ static SQInteger _string_escape(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger _string_startswith(HSQUIRRELVM v) static SQInteger _string_startswith(HRABBITVM v)
{ {
const SQChar *str,*cmp; const SQChar *str,*cmp;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
@ -354,7 +354,7 @@ static SQInteger _string_startswith(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger _string_endswith(HSQUIRRELVM v) static SQInteger _string_endswith(HRABBITVM v)
{ {
const SQChar *str,*cmp; const SQChar *str,*cmp;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
@ -380,7 +380,7 @@ static SQInteger _rexobj_releasehook(SQUserPointer p, SQInteger SQ_UNUSED_ARG(si
return 1; return 1;
} }
static SQInteger _regexp_match(HSQUIRRELVM v) static SQInteger _regexp_match(HRABBITVM v)
{ {
SETUP_REX(v); SETUP_REX(v);
const SQChar *str; const SQChar *str;
@ -394,7 +394,7 @@ static SQInteger _regexp_match(HSQUIRRELVM v)
return 1; return 1;
} }
static void _addrexmatch(HSQUIRRELVM v,const SQChar *str,const SQChar *begin,const SQChar *end) static void _addrexmatch(HRABBITVM v,const SQChar *str,const SQChar *begin,const SQChar *end)
{ {
sq_newtable(v); sq_newtable(v);
sq_pushstring(v,_SC("begin"),-1); sq_pushstring(v,_SC("begin"),-1);
@ -405,7 +405,7 @@ static void _addrexmatch(HSQUIRRELVM v,const SQChar *str,const SQChar *begin,con
sq_rawset(v,-3); sq_rawset(v,-3);
} }
static SQInteger _regexp_search(HSQUIRRELVM v) static SQInteger _regexp_search(HRABBITVM v)
{ {
SETUP_REX(v); SETUP_REX(v);
const SQChar *str,*begin,*end; const SQChar *str,*begin,*end;
@ -419,7 +419,7 @@ static SQInteger _regexp_search(HSQUIRRELVM v)
return 0; return 0;
} }
static SQInteger _regexp_capture(HSQUIRRELVM v) static SQInteger _regexp_capture(HRABBITVM v)
{ {
SETUP_REX(v); SETUP_REX(v);
const SQChar *str,*begin,*end; const SQChar *str,*begin,*end;
@ -443,14 +443,14 @@ static SQInteger _regexp_capture(HSQUIRRELVM v)
return 0; return 0;
} }
static SQInteger _regexp_subexpcount(HSQUIRRELVM v) static SQInteger _regexp_subexpcount(HRABBITVM v)
{ {
SETUP_REX(v); SETUP_REX(v);
sq_pushinteger(v,sqstd_rex_getsubexpcount(self)); sq_pushinteger(v,sqstd_rex_getsubexpcount(self));
return 1; return 1;
} }
static SQInteger _regexp_constructor(HSQUIRRELVM v) static SQInteger _regexp_constructor(HRABBITVM v)
{ {
const SQChar *error,*pattern; const SQChar *error,*pattern;
sq_getstring(v,2,&pattern); sq_getstring(v,2,&pattern);
@ -461,7 +461,7 @@ static SQInteger _regexp_constructor(HSQUIRRELVM v)
return 0; return 0;
} }
static SQInteger _regexp__typeof(HSQUIRRELVM v) static SQInteger _regexp__typeof(HRABBITVM v)
{ {
sq_pushstring(v,_SC("regexp"),-1); sq_pushstring(v,_SC("regexp"),-1);
return 1; return 1;
@ -495,7 +495,7 @@ static const SQRegFunction stringlib_funcs[]={
#undef _DECL_FUNC #undef _DECL_FUNC
SQInteger sqstd_register_stringlib(HSQUIRRELVM v) SQInteger sqstd_register_stringlib(HRABBITVM v)
{ {
sq_pushstring(v,_SC("regexp"),-1); sq_pushstring(v,_SC("regexp"),-1);
sq_newclass(v,SQFalse); sq_newclass(v,SQFalse);

18
rabbit-std/sqstdstring.hpp
View File

@ -15,15 +15,15 @@ typedef struct {
SQInteger len; SQInteger len;
} SQRexMatch; } SQRexMatch;
SQUIRREL_API SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error); RABBIT_API SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error);
SQUIRREL_API void sqstd_rex_free(SQRex *exp); RABBIT_API void sqstd_rex_free(SQRex *exp);
SQUIRREL_API SQBool sqstd_rex_match(SQRex* exp,const SQChar* text); RABBIT_API SQBool sqstd_rex_match(SQRex* exp,const SQChar* text);
SQUIRREL_API SQBool sqstd_rex_search(SQRex* exp,const SQChar* text, const SQChar** out_begin, const SQChar** out_end); RABBIT_API SQBool sqstd_rex_search(SQRex* exp,const SQChar* text, const SQChar** out_begin, const SQChar** out_end);
SQUIRREL_API SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const SQChar* text_end,const SQChar** out_begin, const SQChar** out_end); RABBIT_API SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const SQChar* text_end,const SQChar** out_begin, const SQChar** out_end);
SQUIRREL_API SQInteger sqstd_rex_getsubexpcount(SQRex* exp); RABBIT_API SQInteger sqstd_rex_getsubexpcount(SQRex* exp);
SQUIRREL_API SQBool sqstd_rex_getsubexp(SQRex* exp, SQInteger n, SQRexMatch *subexp); RABBIT_API SQBool sqstd_rex_getsubexp(SQRex* exp, SQInteger n, SQRexMatch *subexp);
SQUIRREL_API SQRESULT sqstd_format(HSQUIRRELVM v,SQInteger nformatstringidx,SQInteger *outlen,SQChar **output); RABBIT_API SQRESULT sqstd_format(HRABBITVM v,SQInteger nformatstringidx,SQInteger *outlen,SQChar **output);
SQUIRREL_API SQRESULT sqstd_register_stringlib(HSQUIRRELVM v); RABBIT_API SQRESULT sqstd_register_stringlib(HRABBITVM v);

18
rabbit-std/sqstdsystem.cpp
View File

@ -27,7 +27,7 @@
#define screname rename #define screname rename
#endif #endif
static SQInteger _system_getenv(HSQUIRRELVM v) static SQInteger _system_getenv(HRABBITVM v)
{ {
const SQChar *s; const SQChar *s;
if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){ if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){
@ -38,7 +38,7 @@ static SQInteger _system_getenv(HSQUIRRELVM v)
} }
static SQInteger _system_system(HSQUIRRELVM v) static SQInteger _system_system(HRABBITVM v)
{ {
const SQChar *s; const SQChar *s;
if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){ if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){
@ -49,20 +49,20 @@ static SQInteger _system_system(HSQUIRRELVM v)
} }
static SQInteger _system_clock(HSQUIRRELVM v) static SQInteger _system_clock(HRABBITVM v)
{ {
sq_pushfloat(v,((SQFloat)clock())/(SQFloat)CLOCKS_PER_SEC); sq_pushfloat(v,((SQFloat)clock())/(SQFloat)CLOCKS_PER_SEC);
return 1; return 1;
} }
static SQInteger _system_time(HSQUIRRELVM v) static SQInteger _system_time(HRABBITVM v)
{ {
SQInteger t = (SQInteger)time(NULL); SQInteger t = (SQInteger)time(NULL);
sq_pushinteger(v,t); sq_pushinteger(v,t);
return 1; return 1;
} }
static SQInteger _system_remove(HSQUIRRELVM v) static SQInteger _system_remove(HRABBITVM v)
{ {
const SQChar *s; const SQChar *s;
sq_getstring(v,2,&s); sq_getstring(v,2,&s);
@ -71,7 +71,7 @@ static SQInteger _system_remove(HSQUIRRELVM v)
return 0; return 0;
} }
static SQInteger _system_rename(HSQUIRRELVM v) static SQInteger _system_rename(HRABBITVM v)
{ {
const SQChar *oldn,*newn; const SQChar *oldn,*newn;
sq_getstring(v,2,&oldn); sq_getstring(v,2,&oldn);
@ -81,14 +81,14 @@ static SQInteger _system_rename(HSQUIRRELVM v)
return 0; return 0;
} }
static void _set_integer_slot(HSQUIRRELVM v,const SQChar *name,SQInteger val) static void _set_integer_slot(HRABBITVM v,const SQChar *name,SQInteger val)
{ {
sq_pushstring(v,name,-1); sq_pushstring(v,name,-1);
sq_pushinteger(v,val); sq_pushinteger(v,val);
sq_rawset(v,-3); sq_rawset(v,-3);
} }
static SQInteger _system_date(HSQUIRRELVM v) static SQInteger _system_date(HRABBITVM v)
{ {
time_t t; time_t t;
SQInteger it; SQInteger it;
@ -137,7 +137,7 @@ static const SQRegFunction systemlib_funcs[]={
}; };
#undef _DECL_FUNC #undef _DECL_FUNC
SQInteger sqstd_register_systemlib(HSQUIRRELVM v) SQInteger sqstd_register_systemlib(HRABBITVM v)
{ {
SQInteger i=0; SQInteger i=0;
while(systemlib_funcs[i].name!=0) while(systemlib_funcs[i].name!=0)

2
rabbit-std/sqstdsystem.hpp
View File

@ -7,4 +7,4 @@
*/ */
#pragma once #pragma once
SQUIRREL_API SQInteger sqstd_register_systemlib(HSQUIRRELVM v); RABBIT_API SQInteger sqstd_register_systemlib(HRABBITVM v);

318
rabbit/rabbit.hpp
View File

@ -15,8 +15,8 @@
extern "C" { extern "C" {
#endif #endif
#ifndef SQUIRREL_API #ifndef RABBIT_API
#define SQUIRREL_API extern #define RABBIT_API extern
#endif #endif
#if (defined(_WIN64) || defined(_LP64)) #if (defined(_WIN64) || defined(_LP64))
@ -50,16 +50,16 @@ struct SQOuter;
#include "sqconfig.hpp" #include "sqconfig.hpp"
#define SQUIRREL_VERSION _SC("Rabbit 0.1 un-stable") #define RABBIT_VERSION _SC("Rabbit 0.1 un-stable")
#define SQUIRREL_COPYRIGHT _SC("Copyright (C) 2003-2017 Alberto Demichelis") #define RABBIT_COPYRIGHT _SC("Copyright (C) 2003-2017 Alberto Demichelis")
#define SQUIRREL_AUTHOR _SC("Edouard DUPIN") #define RABBIT_AUTHOR _SC("Edouard DUPIN")
#define SQUIRREL_VERSION_NUMBER 010 #define RABBIT_VERSION_NUMBER 010
#define SQ_VMSTATE_IDLE 0 #define SQ_VMSTATE_IDLE 0
#define SQ_VMSTATE_RUNNING 1 #define SQ_VMSTATE_RUNNING 1
#define SQ_VMSTATE_SUSPENDED 2 #define SQ_VMSTATE_SUSPENDED 2
#define SQUIRREL_EOB 0 #define RABBIT_EOB 0
#define SQ_BYTECODE_STREAM_TAG 0xFAFA #define SQ_BYTECODE_STREAM_TAG 0xFAFA
#define SQOBJECT_REF_COUNTED 0x08000000 #define SQOBJECT_REF_COUNTED 0x08000000
@ -156,14 +156,14 @@ typedef struct tagSQStackInfos{
SQInteger line; SQInteger line;
}SQStackInfos; }SQStackInfos;
typedef struct SQVM* HSQUIRRELVM; typedef struct SQVM* HRABBITVM;
typedef SQObject HSQOBJECT; typedef SQObject HSQOBJECT;
typedef SQMemberHandle HSQMEMBERHANDLE; typedef SQMemberHandle HSQMEMBERHANDLE;
typedef SQInteger (*SQFUNCTION)(HSQUIRRELVM); typedef SQInteger (*SQFUNCTION)(HRABBITVM);
typedef SQInteger (*SQRELEASEHOOK)(SQUserPointer,SQInteger size); typedef SQInteger (*SQRELEASEHOOK)(SQUserPointer,SQInteger size);
typedef void (*SQCOMPILERERROR)(HSQUIRRELVM,const SQChar * /*desc*/,const SQChar * /*source*/,SQInteger /*line*/,SQInteger /*column*/); typedef void (*SQCOMPILERERROR)(HRABBITVM,const SQChar * /*desc*/,const SQChar * /*source*/,SQInteger /*line*/,SQInteger /*column*/);
typedef void (*SQPRINTFUNCTION)(HSQUIRRELVM,const SQChar * ,...); typedef void (*SQPRINTFUNCTION)(HRABBITVM,const SQChar * ,...);
typedef void (*SQDEBUGHOOK)(HSQUIRRELVM /*v*/, SQInteger /*type*/, const SQChar * /*sourcename*/, SQInteger /*line*/, const SQChar * /*funcname*/); typedef void (*SQDEBUGHOOK)(HRABBITVM /*v*/, SQInteger /*type*/, const SQChar * /*sourcename*/, SQInteger /*line*/, const SQChar * /*funcname*/);
typedef SQInteger (*SQWRITEFUNC)(SQUserPointer,SQUserPointer,SQInteger); typedef SQInteger (*SQWRITEFUNC)(SQUserPointer,SQUserPointer,SQInteger);
typedef SQInteger (*SQREADFUNC)(SQUserPointer,SQUserPointer,SQInteger); typedef SQInteger (*SQREADFUNC)(SQUserPointer,SQUserPointer,SQInteger);
@ -184,174 +184,174 @@ typedef struct tagSQFunctionInfo {
}SQFunctionInfo; }SQFunctionInfo;
/*vm*/ /*vm*/
SQUIRREL_API HSQUIRRELVM sq_open(SQInteger initialstacksize); RABBIT_API HRABBITVM sq_open(SQInteger initialstacksize);
SQUIRREL_API HSQUIRRELVM sq_newthread(HSQUIRRELVM friendvm, SQInteger initialstacksize); RABBIT_API HRABBITVM sq_newthread(HRABBITVM friendvm, SQInteger initialstacksize);
SQUIRREL_API void sq_seterrorhandler(HSQUIRRELVM v); RABBIT_API void sq_seterrorhandler(HRABBITVM v);
SQUIRREL_API void sq_close(HSQUIRRELVM v); RABBIT_API void sq_close(HRABBITVM v);
SQUIRREL_API void sq_setforeignptr(HSQUIRRELVM v,SQUserPointer p); RABBIT_API void sq_setforeignptr(HRABBITVM v,SQUserPointer p);
SQUIRREL_API SQUserPointer sq_getforeignptr(HSQUIRRELVM v); RABBIT_API SQUserPointer sq_getforeignptr(HRABBITVM v);
SQUIRREL_API void sq_setsharedforeignptr(HSQUIRRELVM v,SQUserPointer p); RABBIT_API void sq_setsharedforeignptr(HRABBITVM v,SQUserPointer p);
SQUIRREL_API SQUserPointer sq_getsharedforeignptr(HSQUIRRELVM v); RABBIT_API SQUserPointer sq_getsharedforeignptr(HRABBITVM v);
SQUIRREL_API void sq_setvmreleasehook(HSQUIRRELVM v,SQRELEASEHOOK hook); RABBIT_API void sq_setvmreleasehook(HRABBITVM v,SQRELEASEHOOK hook);
SQUIRREL_API SQRELEASEHOOK sq_getvmreleasehook(HSQUIRRELVM v); RABBIT_API SQRELEASEHOOK sq_getvmreleasehook(HRABBITVM v);
SQUIRREL_API void sq_setsharedreleasehook(HSQUIRRELVM v,SQRELEASEHOOK hook); RABBIT_API void sq_setsharedreleasehook(HRABBITVM v,SQRELEASEHOOK hook);
SQUIRREL_API SQRELEASEHOOK sq_getsharedreleasehook(HSQUIRRELVM v); RABBIT_API SQRELEASEHOOK sq_getsharedreleasehook(HRABBITVM v);
SQUIRREL_API void sq_setprintfunc(HSQUIRRELVM v, SQPRINTFUNCTION printfunc,SQPRINTFUNCTION errfunc); RABBIT_API void sq_setprintfunc(HRABBITVM v, SQPRINTFUNCTION printfunc,SQPRINTFUNCTION errfunc);
SQUIRREL_API SQPRINTFUNCTION sq_getprintfunc(HSQUIRRELVM v); RABBIT_API SQPRINTFUNCTION sq_getprintfunc(HRABBITVM v);
SQUIRREL_API SQPRINTFUNCTION sq_geterrorfunc(HSQUIRRELVM v); RABBIT_API SQPRINTFUNCTION sq_geterrorfunc(HRABBITVM v);
SQUIRREL_API SQRESULT sq_suspendvm(HSQUIRRELVM v); RABBIT_API SQRESULT sq_suspendvm(HRABBITVM v);
SQUIRREL_API SQRESULT sq_wakeupvm(HSQUIRRELVM v,SQBool resumedret,SQBool retval,SQBool raiseerror,SQBool throwerror); RABBIT_API SQRESULT sq_wakeupvm(HRABBITVM v,SQBool resumedret,SQBool retval,SQBool raiseerror,SQBool throwerror);
SQUIRREL_API SQInteger sq_getvmstate(HSQUIRRELVM v); RABBIT_API SQInteger sq_getvmstate(HRABBITVM v);
SQUIRREL_API SQInteger sq_getversion(); RABBIT_API SQInteger sq_getversion();
/*compiler*/ /*compiler*/
SQUIRREL_API SQRESULT sq_compile(HSQUIRRELVM v,SQLEXREADFUNC read,SQUserPointer p,const SQChar *sourcename,SQBool raiseerror); RABBIT_API SQRESULT sq_compile(HRABBITVM v,SQLEXREADFUNC read,SQUserPointer p,const SQChar *sourcename,SQBool raiseerror);
SQUIRREL_API SQRESULT sq_compilebuffer(HSQUIRRELVM v,const SQChar *s,SQInteger size,const SQChar *sourcename,SQBool raiseerror); RABBIT_API SQRESULT sq_compilebuffer(HRABBITVM v,const SQChar *s,SQInteger size,const SQChar *sourcename,SQBool raiseerror);
SQUIRREL_API void sq_enabledebuginfo(HSQUIRRELVM v, SQBool enable); RABBIT_API void sq_enabledebuginfo(HRABBITVM v, SQBool enable);
SQUIRREL_API void sq_notifyallexceptions(HSQUIRRELVM v, SQBool enable); RABBIT_API void sq_notifyallexceptions(HRABBITVM v, SQBool enable);
SQUIRREL_API void sq_setcompilererrorhandler(HSQUIRRELVM v,SQCOMPILERERROR f); RABBIT_API void sq_setcompilererrorhandler(HRABBITVM v,SQCOMPILERERROR f);
/*stack operations*/ /*stack operations*/
SQUIRREL_API void sq_push(HSQUIRRELVM v,SQInteger idx); RABBIT_API void sq_push(HRABBITVM v,SQInteger idx);
SQUIRREL_API void sq_pop(HSQUIRRELVM v,SQInteger nelemstopop); RABBIT_API void sq_pop(HRABBITVM v,SQInteger nelemstopop);
SQUIRREL_API void sq_poptop(HSQUIRRELVM v); RABBIT_API void sq_poptop(HRABBITVM v);
SQUIRREL_API void sq_remove(HSQUIRRELVM v,SQInteger idx); RABBIT_API void sq_remove(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQInteger sq_gettop(HSQUIRRELVM v); RABBIT_API SQInteger sq_gettop(HRABBITVM v);
SQUIRREL_API void sq_settop(HSQUIRRELVM v,SQInteger newtop); RABBIT_API void sq_settop(HRABBITVM v,SQInteger newtop);
SQUIRREL_API SQRESULT sq_reservestack(HSQUIRRELVM v,SQInteger nsize); RABBIT_API SQRESULT sq_reservestack(HRABBITVM v,SQInteger nsize);
SQUIRREL_API SQInteger sq_cmp(HSQUIRRELVM v); RABBIT_API SQInteger sq_cmp(HRABBITVM v);
SQUIRREL_API void sq_move(HSQUIRRELVM dest,HSQUIRRELVM src,SQInteger idx); RABBIT_API void sq_move(HRABBITVM dest,HRABBITVM src,SQInteger idx);
/*object creation handling*/ /*object creation handling*/
SQUIRREL_API SQUserPointer sq_newuserdata(HSQUIRRELVM v,SQUnsignedInteger size); RABBIT_API SQUserPointer sq_newuserdata(HRABBITVM v,SQUnsignedInteger size);
SQUIRREL_API void sq_newtable(HSQUIRRELVM v); RABBIT_API void sq_newtable(HRABBITVM v);
SQUIRREL_API void sq_newtableex(HSQUIRRELVM v,SQInteger initialcapacity); RABBIT_API void sq_newtableex(HRABBITVM v,SQInteger initialcapacity);
SQUIRREL_API void sq_newarray(HSQUIRRELVM v,SQInteger size); RABBIT_API void sq_newarray(HRABBITVM v,SQInteger size);
SQUIRREL_API void sq_newclosure(HSQUIRRELVM v,SQFUNCTION func,SQUnsignedInteger nfreevars); RABBIT_API void sq_newclosure(HRABBITVM v,SQFUNCTION func,SQUnsignedInteger nfreevars);
SQUIRREL_API SQRESULT sq_setparamscheck(HSQUIRRELVM v,SQInteger nparamscheck,const SQChar *typemask); RABBIT_API SQRESULT sq_setparamscheck(HRABBITVM v,SQInteger nparamscheck,const SQChar *typemask);
SQUIRREL_API SQRESULT sq_bindenv(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_bindenv(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_setclosureroot(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_setclosureroot(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_getclosureroot(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_getclosureroot(HRABBITVM v,SQInteger idx);
SQUIRREL_API void sq_pushstring(HSQUIRRELVM v,const SQChar *s,SQInteger len); RABBIT_API void sq_pushstring(HRABBITVM v,const SQChar *s,SQInteger len);
SQUIRREL_API void sq_pushfloat(HSQUIRRELVM v,SQFloat f); RABBIT_API void sq_pushfloat(HRABBITVM v,SQFloat f);
SQUIRREL_API void sq_pushinteger(HSQUIRRELVM v,SQInteger n); RABBIT_API void sq_pushinteger(HRABBITVM v,SQInteger n);
SQUIRREL_API void sq_pushbool(HSQUIRRELVM v,SQBool b); RABBIT_API void sq_pushbool(HRABBITVM v,SQBool b);
SQUIRREL_API void sq_pushuserpointer(HSQUIRRELVM v,SQUserPointer p); RABBIT_API void sq_pushuserpointer(HRABBITVM v,SQUserPointer p);
SQUIRREL_API void sq_pushnull(HSQUIRRELVM v); RABBIT_API void sq_pushnull(HRABBITVM v);
SQUIRREL_API void sq_pushthread(HSQUIRRELVM v, HSQUIRRELVM thread); RABBIT_API void sq_pushthread(HRABBITVM v, HRABBITVM thread);
SQUIRREL_API SQObjectType sq_gettype(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQObjectType sq_gettype(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_typeof(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_typeof(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQInteger sq_getsize(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQInteger sq_getsize(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQHash sq_gethash(HSQUIRRELVM v, SQInteger idx); RABBIT_API SQHash sq_gethash(HRABBITVM v, SQInteger idx);
SQUIRREL_API SQRESULT sq_getbase(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_getbase(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQBool sq_instanceof(HSQUIRRELVM v); RABBIT_API SQBool sq_instanceof(HRABBITVM v);
SQUIRREL_API SQRESULT sq_tostring(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_tostring(HRABBITVM v,SQInteger idx);
SQUIRREL_API void sq_tobool(HSQUIRRELVM v, SQInteger idx, SQBool *b); RABBIT_API void sq_tobool(HRABBITVM v, SQInteger idx, SQBool *b);
SQUIRREL_API SQRESULT sq_getstringandsize(HSQUIRRELVM v,SQInteger idx,const SQChar **c,SQInteger *size); RABBIT_API SQRESULT sq_getstringandsize(HRABBITVM v,SQInteger idx,const SQChar **c,SQInteger *size);
SQUIRREL_API SQRESULT sq_getstring(HSQUIRRELVM v,SQInteger idx,const SQChar **c); RABBIT_API SQRESULT sq_getstring(HRABBITVM v,SQInteger idx,const SQChar **c);
SQUIRREL_API SQRESULT sq_getinteger(HSQUIRRELVM v,SQInteger idx,SQInteger *i); RABBIT_API SQRESULT sq_getinteger(HRABBITVM v,SQInteger idx,SQInteger *i);
SQUIRREL_API SQRESULT sq_getfloat(HSQUIRRELVM v,SQInteger idx,SQFloat *f); RABBIT_API SQRESULT sq_getfloat(HRABBITVM v,SQInteger idx,SQFloat *f);
SQUIRREL_API SQRESULT sq_getbool(HSQUIRRELVM v,SQInteger idx,SQBool *b); RABBIT_API SQRESULT sq_getbool(HRABBITVM v,SQInteger idx,SQBool *b);
SQUIRREL_API SQRESULT sq_getthread(HSQUIRRELVM v,SQInteger idx,HSQUIRRELVM *thread); RABBIT_API SQRESULT sq_getthread(HRABBITVM v,SQInteger idx,HRABBITVM *thread);
SQUIRREL_API SQRESULT sq_getuserpointer(HSQUIRRELVM v,SQInteger idx,SQUserPointer *p); RABBIT_API SQRESULT sq_getuserpointer(HRABBITVM v,SQInteger idx,SQUserPointer *p);
SQUIRREL_API SQRESULT sq_getuserdata(HSQUIRRELVM v,SQInteger idx,SQUserPointer *p,SQUserPointer *typetag); RABBIT_API SQRESULT sq_getuserdata(HRABBITVM v,SQInteger idx,SQUserPointer *p,SQUserPointer *typetag);
SQUIRREL_API SQRESULT sq_settypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer typetag); RABBIT_API SQRESULT sq_settypetag(HRABBITVM v,SQInteger idx,SQUserPointer typetag);
SQUIRREL_API SQRESULT sq_gettypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer *typetag); RABBIT_API SQRESULT sq_gettypetag(HRABBITVM v,SQInteger idx,SQUserPointer *typetag);
SQUIRREL_API void sq_setreleasehook(HSQUIRRELVM v,SQInteger idx,SQRELEASEHOOK hook); RABBIT_API void sq_setreleasehook(HRABBITVM v,SQInteger idx,SQRELEASEHOOK hook);
SQUIRREL_API SQRELEASEHOOK sq_getreleasehook(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRELEASEHOOK sq_getreleasehook(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQChar *sq_getscratchpad(HSQUIRRELVM v,SQInteger minsize); RABBIT_API SQChar *sq_getscratchpad(HRABBITVM v,SQInteger minsize);
SQUIRREL_API SQRESULT sq_getfunctioninfo(HSQUIRRELVM v,SQInteger level,SQFunctionInfo *fi); RABBIT_API SQRESULT sq_getfunctioninfo(HRABBITVM v,SQInteger level,SQFunctionInfo *fi);
SQUIRREL_API SQRESULT sq_getclosureinfo(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger *nparams,SQUnsignedInteger *nfreevars); RABBIT_API SQRESULT sq_getclosureinfo(HRABBITVM v,SQInteger idx,SQUnsignedInteger *nparams,SQUnsignedInteger *nfreevars);
SQUIRREL_API SQRESULT sq_getclosurename(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_getclosurename(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_setnativeclosurename(HSQUIRRELVM v,SQInteger idx,const SQChar *name); RABBIT_API SQRESULT sq_setnativeclosurename(HRABBITVM v,SQInteger idx,const SQChar *name);
SQUIRREL_API SQRESULT sq_setinstanceup(HSQUIRRELVM v, SQInteger idx, SQUserPointer p); RABBIT_API SQRESULT sq_setinstanceup(HRABBITVM v, SQInteger idx, SQUserPointer p);
SQUIRREL_API SQRESULT sq_getinstanceup(HSQUIRRELVM v, SQInteger idx, SQUserPointer *p,SQUserPointer typetag); RABBIT_API SQRESULT sq_getinstanceup(HRABBITVM v, SQInteger idx, SQUserPointer *p,SQUserPointer typetag);
SQUIRREL_API SQRESULT sq_setclassudsize(HSQUIRRELVM v, SQInteger idx, SQInteger udsize); RABBIT_API SQRESULT sq_setclassudsize(HRABBITVM v, SQInteger idx, SQInteger udsize);
SQUIRREL_API SQRESULT sq_newclass(HSQUIRRELVM v,SQBool hasbase); RABBIT_API SQRESULT sq_newclass(HRABBITVM v,SQBool hasbase);
SQUIRREL_API SQRESULT sq_createinstance(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_createinstance(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_setattributes(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_setattributes(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_getattributes(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_getattributes(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_getclass(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_getclass(HRABBITVM v,SQInteger idx);
SQUIRREL_API void sq_weakref(HSQUIRRELVM v,SQInteger idx); RABBIT_API void sq_weakref(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_getdefaultdelegate(HSQUIRRELVM v,SQObjectType t); RABBIT_API SQRESULT sq_getdefaultdelegate(HRABBITVM v,SQObjectType t);
SQUIRREL_API SQRESULT sq_getmemberhandle(HSQUIRRELVM v,SQInteger idx,HSQMEMBERHANDLE *handle); RABBIT_API SQRESULT sq_getmemberhandle(HRABBITVM v,SQInteger idx,HSQMEMBERHANDLE *handle);
SQUIRREL_API SQRESULT sq_getbyhandle(HSQUIRRELVM v,SQInteger idx,const HSQMEMBERHANDLE *handle); RABBIT_API SQRESULT sq_getbyhandle(HRABBITVM v,SQInteger idx,const HSQMEMBERHANDLE *handle);
SQUIRREL_API SQRESULT sq_setbyhandle(HSQUIRRELVM v,SQInteger idx,const HSQMEMBERHANDLE *handle); RABBIT_API SQRESULT sq_setbyhandle(HRABBITVM v,SQInteger idx,const HSQMEMBERHANDLE *handle);
/*object manipulation*/ /*object manipulation*/
SQUIRREL_API void sq_pushroottable(HSQUIRRELVM v); RABBIT_API void sq_pushroottable(HRABBITVM v);
SQUIRREL_API void sq_pushregistrytable(HSQUIRRELVM v); RABBIT_API void sq_pushregistrytable(HRABBITVM v);
SQUIRREL_API void sq_pushconsttable(HSQUIRRELVM v); RABBIT_API void sq_pushconsttable(HRABBITVM v);
SQUIRREL_API SQRESULT sq_setroottable(HSQUIRRELVM v); RABBIT_API SQRESULT sq_setroottable(HRABBITVM v);
SQUIRREL_API SQRESULT sq_setconsttable(HSQUIRRELVM v); RABBIT_API SQRESULT sq_setconsttable(HRABBITVM v);
SQUIRREL_API SQRESULT sq_newslot(HSQUIRRELVM v, SQInteger idx, SQBool bstatic); RABBIT_API SQRESULT sq_newslot(HRABBITVM v, SQInteger idx, SQBool bstatic);
SQUIRREL_API SQRESULT sq_deleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval); RABBIT_API SQRESULT sq_deleteslot(HRABBITVM v,SQInteger idx,SQBool pushval);
SQUIRREL_API SQRESULT sq_set(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_set(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_get(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_get(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_rawget(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_rawget(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_rawset(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_rawset(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_rawdeleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval); RABBIT_API SQRESULT sq_rawdeleteslot(HRABBITVM v,SQInteger idx,SQBool pushval);
SQUIRREL_API SQRESULT sq_newmember(HSQUIRRELVM v,SQInteger idx,SQBool bstatic); RABBIT_API SQRESULT sq_newmember(HRABBITVM v,SQInteger idx,SQBool bstatic);
SQUIRREL_API SQRESULT sq_rawnewmember(HSQUIRRELVM v,SQInteger idx,SQBool bstatic); RABBIT_API SQRESULT sq_rawnewmember(HRABBITVM v,SQInteger idx,SQBool bstatic);
SQUIRREL_API SQRESULT sq_arrayappend(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_arrayappend(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_arraypop(HSQUIRRELVM v,SQInteger idx,SQBool pushval); RABBIT_API SQRESULT sq_arraypop(HRABBITVM v,SQInteger idx,SQBool pushval);
SQUIRREL_API SQRESULT sq_arrayresize(HSQUIRRELVM v,SQInteger idx,SQInteger newsize); RABBIT_API SQRESULT sq_arrayresize(HRABBITVM v,SQInteger idx,SQInteger newsize);
SQUIRREL_API SQRESULT sq_arrayreverse(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_arrayreverse(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_arrayremove(HSQUIRRELVM v,SQInteger idx,SQInteger itemidx); RABBIT_API SQRESULT sq_arrayremove(HRABBITVM v,SQInteger idx,SQInteger itemidx);
SQUIRREL_API SQRESULT sq_arrayinsert(HSQUIRRELVM v,SQInteger idx,SQInteger destpos); RABBIT_API SQRESULT sq_arrayinsert(HRABBITVM v,SQInteger idx,SQInteger destpos);
SQUIRREL_API SQRESULT sq_setdelegate(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_setdelegate(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_getdelegate(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_getdelegate(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_clone(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_clone(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_setfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger nval); RABBIT_API SQRESULT sq_setfreevariable(HRABBITVM v,SQInteger idx,SQUnsignedInteger nval);
SQUIRREL_API SQRESULT sq_next(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_next(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_getweakrefval(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_getweakrefval(HRABBITVM v,SQInteger idx);
SQUIRREL_API SQRESULT sq_clear(HSQUIRRELVM v,SQInteger idx); RABBIT_API SQRESULT sq_clear(HRABBITVM v,SQInteger idx);
/*calls*/ /*calls*/
SQUIRREL_API SQRESULT sq_call(HSQUIRRELVM v,SQInteger params,SQBool retval,SQBool raiseerror); RABBIT_API SQRESULT sq_call(HRABBITVM v,SQInteger params,SQBool retval,SQBool raiseerror);
SQUIRREL_API SQRESULT sq_resume(HSQUIRRELVM v,SQBool retval,SQBool raiseerror); RABBIT_API SQRESULT sq_resume(HRABBITVM v,SQBool retval,SQBool raiseerror);
SQUIRREL_API const SQChar *sq_getlocal(HSQUIRRELVM v,SQUnsignedInteger level,SQUnsignedInteger idx); RABBIT_API const SQChar *sq_getlocal(HRABBITVM v,SQUnsignedInteger level,SQUnsignedInteger idx);
SQUIRREL_API SQRESULT sq_getcallee(HSQUIRRELVM v); RABBIT_API SQRESULT sq_getcallee(HRABBITVM v);
SQUIRREL_API const SQChar *sq_getfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger nval); RABBIT_API const SQChar *sq_getfreevariable(HRABBITVM v,SQInteger idx,SQUnsignedInteger nval);
SQUIRREL_API SQRESULT sq_throwerror(HSQUIRRELVM v,const SQChar *err); RABBIT_API SQRESULT sq_throwerror(HRABBITVM v,const SQChar *err);
SQUIRREL_API SQRESULT sq_throwobject(HSQUIRRELVM v); RABBIT_API SQRESULT sq_throwobject(HRABBITVM v);
SQUIRREL_API void sq_reseterror(HSQUIRRELVM v); RABBIT_API void sq_reseterror(HRABBITVM v);
SQUIRREL_API void sq_getlasterror(HSQUIRRELVM v); RABBIT_API void sq_getlasterror(HRABBITVM v);
SQUIRREL_API SQRESULT sq_tailcall(HSQUIRRELVM v, SQInteger nparams); RABBIT_API SQRESULT sq_tailcall(HRABBITVM v, SQInteger nparams);
/*raw object handling*/ /*raw object handling*/
SQUIRREL_API SQRESULT sq_getstackobj(HSQUIRRELVM v,SQInteger idx,HSQOBJECT *po); RABBIT_API SQRESULT sq_getstackobj(HRABBITVM v,SQInteger idx,HSQOBJECT *po);
SQUIRREL_API void sq_pushobject(HSQUIRRELVM v,HSQOBJECT obj); RABBIT_API void sq_pushobject(HRABBITVM v,HSQOBJECT obj);
SQUIRREL_API void sq_addref(HSQUIRRELVM v,HSQOBJECT *po); RABBIT_API void sq_addref(HRABBITVM v,HSQOBJECT *po);
SQUIRREL_API SQBool sq_release(HSQUIRRELVM v,HSQOBJECT *po); RABBIT_API SQBool sq_release(HRABBITVM v,HSQOBJECT *po);
SQUIRREL_API SQUnsignedInteger sq_getrefcount(HSQUIRRELVM v,HSQOBJECT *po); RABBIT_API SQUnsignedInteger sq_getrefcount(HRABBITVM v,HSQOBJECT *po);
SQUIRREL_API void sq_resetobject(HSQOBJECT *po); RABBIT_API void sq_resetobject(HSQOBJECT *po);
SQUIRREL_API const SQChar *sq_objtostring(const HSQOBJECT *o); RABBIT_API const SQChar *sq_objtostring(const HSQOBJECT *o);
SQUIRREL_API SQBool sq_objtobool(const HSQOBJECT *o); RABBIT_API SQBool sq_objtobool(const HSQOBJECT *o);
SQUIRREL_API SQInteger sq_objtointeger(const HSQOBJECT *o); RABBIT_API SQInteger sq_objtointeger(const HSQOBJECT *o);
SQUIRREL_API SQFloat sq_objtofloat(const HSQOBJECT *o); RABBIT_API SQFloat sq_objtofloat(const HSQOBJECT *o);
SQUIRREL_API SQUserPointer sq_objtouserpointer(const HSQOBJECT *o); RABBIT_API SQUserPointer sq_objtouserpointer(const HSQOBJECT *o);
SQUIRREL_API SQRESULT sq_getobjtypetag(const HSQOBJECT *o,SQUserPointer * typetag); RABBIT_API SQRESULT sq_getobjtypetag(const HSQOBJECT *o,SQUserPointer * typetag);
SQUIRREL_API SQUnsignedInteger sq_getvmrefcount(HSQUIRRELVM v, const HSQOBJECT *po); RABBIT_API SQUnsignedInteger sq_getvmrefcount(HRABBITVM v, const HSQOBJECT *po);
/*GC*/ /*GC*/
SQUIRREL_API SQInteger sq_collectgarbage(HSQUIRRELVM v); RABBIT_API SQInteger sq_collectgarbage(HRABBITVM v);
SQUIRREL_API SQRESULT sq_resurrectunreachable(HSQUIRRELVM v); RABBIT_API SQRESULT sq_resurrectunreachable(HRABBITVM v);
/*serialization*/ /*serialization*/
SQUIRREL_API SQRESULT sq_writeclosure(HSQUIRRELVM vm,SQWRITEFUNC writef,SQUserPointer up); RABBIT_API SQRESULT sq_writeclosure(HRABBITVM vm,SQWRITEFUNC writef,SQUserPointer up);
SQUIRREL_API SQRESULT sq_readclosure(HSQUIRRELVM vm,SQREADFUNC readf,SQUserPointer up); RABBIT_API SQRESULT sq_readclosure(HRABBITVM vm,SQREADFUNC readf,SQUserPointer up);
/*mem allocation*/ /*mem allocation*/
SQUIRREL_API void *sq_malloc(SQUnsignedInteger size); RABBIT_API void *sq_malloc(SQUnsignedInteger size);
SQUIRREL_API void *sq_realloc(void* p,SQUnsignedInteger oldsize,SQUnsignedInteger newsize); RABBIT_API void *sq_realloc(void* p,SQUnsignedInteger oldsize,SQUnsignedInteger newsize);
SQUIRREL_API void sq_free(void *p,SQUnsignedInteger size); RABBIT_API void sq_free(void *p,SQUnsignedInteger size);
/*debug*/ /*debug*/
SQUIRREL_API SQRESULT sq_stackinfos(HSQUIRRELVM v,SQInteger level,SQStackInfos *si); RABBIT_API SQRESULT sq_stackinfos(HRABBITVM v,SQInteger level,SQStackInfos *si);
SQUIRREL_API void sq_setdebughook(HSQUIRRELVM v); RABBIT_API void sq_setdebughook(HRABBITVM v);
SQUIRREL_API void sq_setnativedebughook(HSQUIRRELVM v,SQDEBUGHOOK hook); RABBIT_API void sq_setnativedebughook(HRABBITVM v,SQDEBUGHOOK hook);
/*UTILITY MACRO*/ /*UTILITY MACRO*/
#define sq_isnumeric(o) ((o)._type&SQOBJECT_NUMERIC) #define sq_isnumeric(o) ((o)._type&SQOBJECT_NUMERIC)

298
rabbit/sqapi.cpp
View File

File diff suppressed because it is too large Load Diff

6
rabbit/sqarray.hpp
View File

@ -21,10 +21,6 @@ public:
new (newarray) SQArray(ss,nInitialSize); new (newarray) SQArray(ss,nInitialSize);
return newarray; return newarray;
} }
#ifndef NO_GARBAGE_COLLECTOR
void Mark(SQCollectable **chain);
SQObjectType GetType() {return OT_ARRAY;}
#endif
void Finalize(){ void Finalize(){
_values.resize(0); _values.resize(0);
} }
@ -59,7 +55,7 @@ public:
//nothing to iterate anymore //nothing to iterate anymore
return -1; return -1;
} }
SQArray *Clone(){SQArray *anew=Create(_opt_ss(this),0); anew->_values.copy(_values); return anew; } SQArray *Clone(){SQArray *anew=Create(NULL,0); anew->_values.copy(_values); return anew; }
SQInteger Size() const {return _values.size();} SQInteger Size() const {return _values.size();}
void Resize(SQInteger size) void Resize(SQInteger size)
{ {

183
rabbit/sqbaselib.cpp
View File

@ -45,38 +45,25 @@ static bool str2num(const SQChar *s,SQObjectPtr &res,SQInteger base)
return true; return true;
} }
static SQInteger base_dummy(HSQUIRRELVM SQ_UNUSED_ARG(v)) static SQInteger base_dummy(HRABBITVM SQ_UNUSED_ARG(v))
{ {
return 0; return 0;
} }
#ifndef NO_GARBAGE_COLLECTOR static SQInteger base_getroottable(HRABBITVM v)
static SQInteger base_collectgarbage(HSQUIRRELVM v)
{
sq_pushinteger(v, sq_collectgarbage(v));
return 1;
}
static SQInteger base_resurectureachable(HSQUIRRELVM v)
{
sq_resurrectunreachable(v);
return 1;
}
#endif
static SQInteger base_getroottable(HSQUIRRELVM v)
{ {
v->Push(v->_roottable); v->Push(v->_roottable);
return 1; return 1;
} }
static SQInteger base_getconsttable(HSQUIRRELVM v) static SQInteger base_getconsttable(HRABBITVM v)
{ {
v->Push(_ss(v)->_consts); v->Push(_ss(v)->_consts);
return 1; return 1;
} }
static SQInteger base_setroottable(HSQUIRRELVM v) static SQInteger base_setroottable(HRABBITVM v)
{ {
SQObjectPtr o = v->_roottable; SQObjectPtr o = v->_roottable;
if(SQ_FAILED(sq_setroottable(v))) return SQ_ERROR; if(SQ_FAILED(sq_setroottable(v))) return SQ_ERROR;
@ -84,7 +71,7 @@ static SQInteger base_setroottable(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger base_setconsttable(HSQUIRRELVM v) static SQInteger base_setconsttable(HRABBITVM v)
{ {
SQObjectPtr o = _ss(v)->_consts; SQObjectPtr o = _ss(v)->_consts;
if(SQ_FAILED(sq_setconsttable(v))) return SQ_ERROR; if(SQ_FAILED(sq_setconsttable(v))) return SQ_ERROR;
@ -92,19 +79,19 @@ static SQInteger base_setconsttable(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger base_seterrorhandler(HSQUIRRELVM v) static SQInteger base_seterrorhandler(HRABBITVM v)
{ {
sq_seterrorhandler(v); sq_seterrorhandler(v);
return 0; return 0;
} }
static SQInteger base_setdebughook(HSQUIRRELVM v) static SQInteger base_setdebughook(HRABBITVM v)
{ {
sq_setdebughook(v); sq_setdebughook(v);
return 0; return 0;
} }
static SQInteger base_enabledebuginfo(HSQUIRRELVM v) static SQInteger base_enabledebuginfo(HRABBITVM v)
{ {
SQObjectPtr &o=stack_get(v,2); SQObjectPtr &o=stack_get(v,2);
@ -112,7 +99,7 @@ static SQInteger base_enabledebuginfo(HSQUIRRELVM v)
return 0; return 0;
} }
static SQInteger __getcallstackinfos(HSQUIRRELVM v,SQInteger level) static SQInteger __getcallstackinfos(HRABBITVM v,SQInteger level)
{ {
SQStackInfos si; SQStackInfos si;
SQInteger seq = 0; SQInteger seq = 0;
@ -150,14 +137,14 @@ static SQInteger __getcallstackinfos(HSQUIRRELVM v,SQInteger level)
return 0; return 0;
} }
static SQInteger base_getstackinfos(HSQUIRRELVM v) static SQInteger base_getstackinfos(HRABBITVM v)
{ {
SQInteger level; SQInteger level;
sq_getinteger(v, -1, &level); sq_getinteger(v, -1, &level);
return __getcallstackinfos(v,level); return __getcallstackinfos(v,level);
} }
static SQInteger base_assert(HSQUIRRELVM v) static SQInteger base_assert(HRABBITVM v)
{ {
if(SQVM::IsFalse(stack_get(v,2))){ if(SQVM::IsFalse(stack_get(v,2))){
SQInteger top = sq_gettop(v); SQInteger top = sq_gettop(v);
@ -172,7 +159,7 @@ static SQInteger base_assert(HSQUIRRELVM v)
return 0; return 0;
} }
static SQInteger get_slice_params(HSQUIRRELVM v,SQInteger &sidx,SQInteger &eidx,SQObjectPtr &o) static SQInteger get_slice_params(HRABBITVM v,SQInteger &sidx,SQInteger &eidx,SQObjectPtr &o)
{ {
SQInteger top = sq_gettop(v); SQInteger top = sq_gettop(v);
sidx=0; sidx=0;
@ -196,7 +183,7 @@ static SQInteger get_slice_params(HSQUIRRELVM v,SQInteger &sidx,SQInteger &eidx,
return 1; return 1;
} }
static SQInteger base_print(HSQUIRRELVM v) static SQInteger base_print(HRABBITVM v)
{ {
const SQChar *str; const SQChar *str;
if(SQ_SUCCEEDED(sq_tostring(v,2))) if(SQ_SUCCEEDED(sq_tostring(v,2)))
@ -209,7 +196,7 @@ static SQInteger base_print(HSQUIRRELVM v)
return SQ_ERROR; return SQ_ERROR;
} }
static SQInteger base_error(HSQUIRRELVM v) static SQInteger base_error(HRABBITVM v)
{ {
const SQChar *str; const SQChar *str;
if(SQ_SUCCEEDED(sq_tostring(v,2))) if(SQ_SUCCEEDED(sq_tostring(v,2)))
@ -222,7 +209,7 @@ static SQInteger base_error(HSQUIRRELVM v)
return SQ_ERROR; return SQ_ERROR;
} }
static SQInteger base_compilestring(HSQUIRRELVM v) static SQInteger base_compilestring(HRABBITVM v)
{ {
SQInteger nargs=sq_gettop(v); SQInteger nargs=sq_gettop(v);
const SQChar *src=NULL,*name=_SC("unnamedbuffer"); const SQChar *src=NULL,*name=_SC("unnamedbuffer");
@ -238,21 +225,21 @@ static SQInteger base_compilestring(HSQUIRRELVM v)
return SQ_ERROR; return SQ_ERROR;
} }
static SQInteger base_newthread(HSQUIRRELVM v) static SQInteger base_newthread(HRABBITVM v)
{ {
SQObjectPtr &func = stack_get(v,2); SQObjectPtr &func = stack_get(v,2);
SQInteger stksize = (_closure(func)->_function->_stacksize << 1) +2; SQInteger stksize = (_closure(func)->_function->_stacksize << 1) +2;
HSQUIRRELVM newv = sq_newthread(v, (stksize < MIN_STACK_OVERHEAD + 2)? MIN_STACK_OVERHEAD + 2 : stksize); HRABBITVM newv = sq_newthread(v, (stksize < MIN_STACK_OVERHEAD + 2)? MIN_STACK_OVERHEAD + 2 : stksize);
sq_move(newv,v,-2); sq_move(newv,v,-2);
return 1; return 1;
} }
static SQInteger base_suspend(HSQUIRRELVM v) static SQInteger base_suspend(HRABBITVM v)
{ {
return sq_suspendvm(v); return sq_suspendvm(v);
} }
static SQInteger base_array(HSQUIRRELVM v) static SQInteger base_array(HRABBITVM v)
{ {
SQArray *a; SQArray *a;
SQObject &size = stack_get(v,2); SQObject &size = stack_get(v,2);
@ -267,14 +254,14 @@ static SQInteger base_array(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger base_type(HSQUIRRELVM v) static SQInteger base_type(HRABBITVM v)
{ {
SQObjectPtr &o = stack_get(v,2); SQObjectPtr &o = stack_get(v,2);
v->Push(SQString::Create(_ss(v),GetTypeName(o),-1)); v->Push(SQString::Create(_ss(v),GetTypeName(o),-1));
return 1; return 1;
} }
static SQInteger base_callee(HSQUIRRELVM v) static SQInteger base_callee(HRABBITVM v)
{ {
if(v->_callsstacksize > 1) if(v->_callsstacksize > 1)
{ {
@ -304,14 +291,10 @@ static const SQRegFunction base_funcs[]={
{_SC("type"),base_type,2, NULL}, {_SC("type"),base_type,2, NULL},
{_SC("callee"),base_callee,0,NULL}, {_SC("callee"),base_callee,0,NULL},
{_SC("dummy"),base_dummy,0,NULL}, {_SC("dummy"),base_dummy,0,NULL},
#ifndef NO_GARBAGE_COLLECTOR
{_SC("collectgarbage"),base_collectgarbage,0, NULL},
{_SC("resurrectunreachable"),base_resurectureachable,0, NULL},
#endif
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
void sq_base_register(HSQUIRRELVM v) void sq_base_register(HRABBITVM v)
{ {
SQInteger i=0; SQInteger i=0;
sq_pushroottable(v); sq_pushroottable(v);
@ -325,10 +308,10 @@ void sq_base_register(HSQUIRRELVM v)
} }
sq_pushstring(v,_SC("_versionnumber_"),-1); sq_pushstring(v,_SC("_versionnumber_"),-1);
sq_pushinteger(v,SQUIRREL_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,_SC("_version_"),-1);
sq_pushstring(v,SQUIRREL_VERSION,-1); sq_pushstring(v,RABBIT_VERSION,-1);
sq_newslot(v,-3, SQFalse); sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_charsize_"),-1); sq_pushstring(v,_SC("_charsize_"),-1);
sq_pushinteger(v,sizeof(SQChar)); sq_pushinteger(v,sizeof(SQChar));
@ -342,13 +325,13 @@ void sq_base_register(HSQUIRRELVM v)
sq_pop(v,1); sq_pop(v,1);
} }
static SQInteger default_delegate_len(HSQUIRRELVM v) static SQInteger default_delegate_len(HRABBITVM v)
{ {
v->Push(SQInteger(sq_getsize(v,1))); v->Push(SQInteger(sq_getsize(v,1)));
return 1; return 1;
} }
static SQInteger default_delegate_tofloat(HSQUIRRELVM v) static SQInteger default_delegate_tofloat(HRABBITVM v)
{ {
SQObjectPtr &o=stack_get(v,1); SQObjectPtr &o=stack_get(v,1);
switch(sq_type(o)){ switch(sq_type(o)){
@ -373,7 +356,7 @@ static SQInteger default_delegate_tofloat(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger default_delegate_tointeger(HSQUIRRELVM v) static SQInteger default_delegate_tointeger(HRABBITVM v)
{ {
SQObjectPtr &o=stack_get(v,1); SQObjectPtr &o=stack_get(v,1);
SQInteger base = 10; SQInteger base = 10;
@ -402,26 +385,26 @@ static SQInteger default_delegate_tointeger(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger default_delegate_tostring(HSQUIRRELVM v) static SQInteger default_delegate_tostring(HRABBITVM v)
{ {
if(SQ_FAILED(sq_tostring(v,1))) if(SQ_FAILED(sq_tostring(v,1)))
return SQ_ERROR; return SQ_ERROR;
return 1; return 1;
} }
static SQInteger obj_delegate_weakref(HSQUIRRELVM v) static SQInteger obj_delegate_weakref(HRABBITVM v)
{ {
sq_weakref(v,1); sq_weakref(v,1);
return 1; return 1;
} }
static SQInteger obj_clear(HSQUIRRELVM v) static SQInteger obj_clear(HRABBITVM v)
{ {
return SQ_SUCCEEDED(sq_clear(v,-1)) ? 1 : SQ_ERROR; return SQ_SUCCEEDED(sq_clear(v,-1)) ? 1 : SQ_ERROR;
} }
static SQInteger number_delegate_tochar(HSQUIRRELVM v) static SQInteger number_delegate_tochar(HRABBITVM v)
{ {
SQObject &o=stack_get(v,1); SQObject &o=stack_get(v,1);
SQChar c = (SQChar)tointeger(o); SQChar c = (SQChar)tointeger(o);
@ -434,7 +417,7 @@ static SQInteger number_delegate_tochar(HSQUIRRELVM v)
///////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////
//TABLE DEFAULT DELEGATE //TABLE DEFAULT DELEGATE
static SQInteger table_rawdelete(HSQUIRRELVM v) static SQInteger table_rawdelete(HRABBITVM v)
{ {
if(SQ_FAILED(sq_rawdeleteslot(v,1,SQTrue))) if(SQ_FAILED(sq_rawdeleteslot(v,1,SQTrue)))
return SQ_ERROR; return SQ_ERROR;
@ -442,7 +425,7 @@ static SQInteger table_rawdelete(HSQUIRRELVM v)
} }
static SQInteger container_rawexists(HSQUIRRELVM v) static SQInteger container_rawexists(HRABBITVM v)
{ {
if(SQ_SUCCEEDED(sq_rawget(v,-2))) { if(SQ_SUCCEEDED(sq_rawget(v,-2))) {
sq_pushbool(v,SQTrue); sq_pushbool(v,SQTrue);
@ -452,18 +435,18 @@ static SQInteger container_rawexists(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger container_rawset(HSQUIRRELVM v) static SQInteger container_rawset(HRABBITVM v)
{ {
return SQ_SUCCEEDED(sq_rawset(v,-3)) ? 1 : SQ_ERROR; return SQ_SUCCEEDED(sq_rawset(v,-3)) ? 1 : SQ_ERROR;
} }
static SQInteger container_rawget(HSQUIRRELVM v) static SQInteger container_rawget(HRABBITVM v)
{ {
return SQ_SUCCEEDED(sq_rawget(v,-2))?1:SQ_ERROR; return SQ_SUCCEEDED(sq_rawget(v,-2))?1:SQ_ERROR;
} }
static SQInteger table_setdelegate(HSQUIRRELVM v) static SQInteger table_setdelegate(HRABBITVM v)
{ {
if(SQ_FAILED(sq_setdelegate(v,-2))) if(SQ_FAILED(sq_setdelegate(v,-2)))
return SQ_ERROR; return SQ_ERROR;
@ -471,12 +454,12 @@ static SQInteger table_setdelegate(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger table_getdelegate(HSQUIRRELVM v) static SQInteger table_getdelegate(HRABBITVM v)
{ {
return SQ_SUCCEEDED(sq_getdelegate(v,-1))?1:SQ_ERROR; return SQ_SUCCEEDED(sq_getdelegate(v,-1))?1:SQ_ERROR;
} }
static SQInteger table_filter(HSQUIRRELVM v) static SQInteger table_filter(HRABBITVM v)
{ {
SQObject &o = stack_get(v,1); SQObject &o = stack_get(v,1);
SQTable *tbl = _table(o); SQTable *tbl = _table(o);
@ -521,29 +504,29 @@ const SQRegFunction SQSharedState::_table_default_delegate_funcz[]={
//ARRAY DEFAULT DELEGATE/////////////////////////////////////// //ARRAY DEFAULT DELEGATE///////////////////////////////////////
static SQInteger array_append(HSQUIRRELVM v) static SQInteger array_append(HRABBITVM v)
{ {
return SQ_SUCCEEDED(sq_arrayappend(v,-2)) ? 1 : SQ_ERROR; return SQ_SUCCEEDED(sq_arrayappend(v,-2)) ? 1 : SQ_ERROR;
} }
static SQInteger array_extend(HSQUIRRELVM v) static SQInteger array_extend(HRABBITVM v)
{ {
_array(stack_get(v,1))->Extend(_array(stack_get(v,2))); _array(stack_get(v,1))->Extend(_array(stack_get(v,2)));
sq_pop(v,1); sq_pop(v,1);
return 1; return 1;
} }
static SQInteger array_reverse(HSQUIRRELVM v) static SQInteger array_reverse(HRABBITVM v)
{ {
return SQ_SUCCEEDED(sq_arrayreverse(v,-1)) ? 1 : SQ_ERROR; return SQ_SUCCEEDED(sq_arrayreverse(v,-1)) ? 1 : SQ_ERROR;
} }
static SQInteger array_pop(HSQUIRRELVM v) static SQInteger array_pop(HRABBITVM v)
{ {
return SQ_SUCCEEDED(sq_arraypop(v,1,SQTrue))?1:SQ_ERROR; return SQ_SUCCEEDED(sq_arraypop(v,1,SQTrue))?1:SQ_ERROR;
} }
static SQInteger array_top(HSQUIRRELVM v) static SQInteger array_top(HRABBITVM v)
{ {
SQObject &o=stack_get(v,1); SQObject &o=stack_get(v,1);
if(_array(o)->Size()>0){ if(_array(o)->Size()>0){
@ -553,7 +536,7 @@ static SQInteger array_top(HSQUIRRELVM v)
else return sq_throwerror(v,_SC("top() on a empty array")); else return sq_throwerror(v,_SC("top() on a empty array"));
} }
static SQInteger array_insert(HSQUIRRELVM v) static SQInteger array_insert(HRABBITVM v)
{ {
SQObject &o=stack_get(v,1); SQObject &o=stack_get(v,1);
SQObject &idx=stack_get(v,2); SQObject &idx=stack_get(v,2);
@ -564,7 +547,7 @@ static SQInteger array_insert(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger array_remove(HSQUIRRELVM v) static SQInteger array_remove(HRABBITVM v)
{ {
SQObject &o = stack_get(v, 1); SQObject &o = stack_get(v, 1);
SQObject &idx = stack_get(v, 2); SQObject &idx = stack_get(v, 2);
@ -578,7 +561,7 @@ static SQInteger array_remove(HSQUIRRELVM v)
return sq_throwerror(v, _SC("idx out of range")); return sq_throwerror(v, _SC("idx out of range"));
} }
static SQInteger array_resize(HSQUIRRELVM v) static SQInteger array_resize(HRABBITVM v)
{ {
SQObject &o = stack_get(v, 1); SQObject &o = stack_get(v, 1);
SQObject &nsize = stack_get(v, 2); SQObject &nsize = stack_get(v, 2);
@ -597,7 +580,7 @@ static SQInteger array_resize(HSQUIRRELVM v)
return sq_throwerror(v, _SC("size must be a number")); return sq_throwerror(v, _SC("size must be a number"));
} }
static SQInteger __map_array(SQArray *dest,SQArray *src,HSQUIRRELVM v) { static SQInteger __map_array(SQArray *dest,SQArray *src,HRABBITVM v) {
SQObjectPtr temp; SQObjectPtr temp;
SQInteger size = src->Size(); SQInteger size = src->Size();
for(SQInteger n = 0; n < size; n++) { for(SQInteger n = 0; n < size; n++) {
@ -613,7 +596,7 @@ static SQInteger __map_array(SQArray *dest,SQArray *src,HSQUIRRELVM v) {
return 0; return 0;
} }
static SQInteger array_map(HSQUIRRELVM v) static SQInteger array_map(HRABBITVM v)
{ {
SQObject &o = stack_get(v,1); SQObject &o = stack_get(v,1);
SQInteger size = _array(o)->Size(); SQInteger size = _array(o)->Size();
@ -624,7 +607,7 @@ static SQInteger array_map(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger array_apply(HSQUIRRELVM v) static SQInteger array_apply(HRABBITVM v)
{ {
SQObject &o = stack_get(v,1); SQObject &o = stack_get(v,1);
if(SQ_FAILED(__map_array(_array(o),_array(o),v))) if(SQ_FAILED(__map_array(_array(o),_array(o),v)))
@ -633,7 +616,7 @@ static SQInteger array_apply(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger array_reduce(HSQUIRRELVM v) static SQInteger array_reduce(HRABBITVM v)
{ {
SQObject &o = stack_get(v,1); SQObject &o = stack_get(v,1);
SQArray *a = _array(o); SQArray *a = _array(o);
@ -661,7 +644,7 @@ static SQInteger array_reduce(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger array_filter(HSQUIRRELVM v) static SQInteger array_filter(HRABBITVM v)
{ {
SQObject &o = stack_get(v,1); SQObject &o = stack_get(v,1);
SQArray *a = _array(o); SQArray *a = _array(o);
@ -685,7 +668,7 @@ static SQInteger array_filter(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger array_find(HSQUIRRELVM v) static SQInteger array_find(HRABBITVM v)
{ {
SQObject &o = stack_get(v,1); SQObject &o = stack_get(v,1);
SQObjectPtr &val = stack_get(v,2); SQObjectPtr &val = stack_get(v,2);
@ -704,7 +687,7 @@ static SQInteger array_find(HSQUIRRELVM v)
} }
static bool _sort_compare(HSQUIRRELVM v,SQObjectPtr &a,SQObjectPtr &b,SQInteger func,SQInteger &ret) static bool _sort_compare(HRABBITVM v,SQObjectPtr &a,SQObjectPtr &b,SQInteger func,SQInteger &ret)
{ {
if(func < 0) { if(func < 0) {
if(!v->ObjCmp(a,b,ret)) return false; if(!v->ObjCmp(a,b,ret)) return false;
@ -730,7 +713,7 @@ static bool _sort_compare(HSQUIRRELVM v,SQObjectPtr &a,SQObjectPtr &b,SQInteger
return true; return true;
} }
static bool _hsort_sift_down(HSQUIRRELVM v,SQArray *arr, SQInteger root, SQInteger bottom, SQInteger func) static bool _hsort_sift_down(HRABBITVM v,SQArray *arr, SQInteger root, SQInteger bottom, SQInteger func)
{ {
SQInteger maxChild; SQInteger maxChild;
SQInteger done = 0; SQInteger done = 0;
@ -770,7 +753,7 @@ static bool _hsort_sift_down(HSQUIRRELVM v,SQArray *arr, SQInteger root, SQInteg
return true; return true;
} }
static bool _hsort(HSQUIRRELVM v,SQObjectPtr &arr, SQInteger SQ_UNUSED_ARG(l), SQInteger SQ_UNUSED_ARG(r),SQInteger func) static bool _hsort(HRABBITVM v,SQObjectPtr &arr, SQInteger SQ_UNUSED_ARG(l), SQInteger SQ_UNUSED_ARG(r),SQInteger func)
{ {
SQArray *a = _array(arr); SQArray *a = _array(arr);
SQInteger i; SQInteger i;
@ -787,7 +770,7 @@ static bool _hsort(HSQUIRRELVM v,SQObjectPtr &arr, SQInteger SQ_UNUSED_ARG(l), S
return true; return true;
} }
static SQInteger array_sort(HSQUIRRELVM v) static SQInteger array_sort(HRABBITVM v)
{ {
SQInteger func = -1; SQInteger func = -1;
SQObjectPtr &o = stack_get(v,1); SQObjectPtr &o = stack_get(v,1);
@ -801,7 +784,7 @@ static SQInteger array_sort(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger array_slice(HSQUIRRELVM v) static SQInteger array_slice(HRABBITVM v)
{ {
SQInteger sidx,eidx; SQInteger sidx,eidx;
SQObjectPtr o; SQObjectPtr o;
@ -848,7 +831,7 @@ const SQRegFunction SQSharedState::_array_default_delegate_funcz[]={
}; };
//STRING DEFAULT DELEGATE////////////////////////// //STRING DEFAULT DELEGATE//////////////////////////
static SQInteger string_slice(HSQUIRRELVM v) static SQInteger string_slice(HRABBITVM v)
{ {
SQInteger sidx,eidx; SQInteger sidx,eidx;
SQObjectPtr o; SQObjectPtr o;
@ -862,7 +845,7 @@ static SQInteger string_slice(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger string_find(HSQUIRRELVM v) static SQInteger string_find(HRABBITVM v)
{ {
SQInteger top,start_idx=0; SQInteger top,start_idx=0;
const SQChar *str,*substr,*ret; const SQChar *str,*substr,*ret;
@ -880,7 +863,7 @@ static SQInteger string_find(HSQUIRRELVM v)
return sq_throwerror(v,_SC("invalid param")); return sq_throwerror(v,_SC("invalid param"));
} }
#define STRING_TOFUNCZ(func) static SQInteger string_##func(HSQUIRRELVM v) \ #define STRING_TOFUNCZ(func) static SQInteger string_##func(HRABBITVM v) \
{\ {\
SQInteger sidx,eidx; \ SQInteger sidx,eidx; \
SQObjectPtr str; \ SQObjectPtr str; \
@ -927,12 +910,12 @@ const SQRegFunction SQSharedState::_number_default_delegate_funcz[]={
}; };
//CLOSURE DEFAULT DELEGATE////////////////////////// //CLOSURE DEFAULT DELEGATE//////////////////////////
static SQInteger closure_pcall(HSQUIRRELVM v) static SQInteger closure_pcall(HRABBITVM v)
{ {
return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQFalse))?1:SQ_ERROR; return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQFalse))?1:SQ_ERROR;
} }
static SQInteger closure_call(HSQUIRRELVM v) static SQInteger closure_call(HRABBITVM v)
{ {
SQObjectPtr &c = stack_get(v, -1); SQObjectPtr &c = stack_get(v, -1);
if (sq_type(c) == OT_CLOSURE && (_closure(c)->_function->_bgenerator == false)) if (sq_type(c) == OT_CLOSURE && (_closure(c)->_function->_bgenerator == false))
@ -942,7 +925,7 @@ static SQInteger closure_call(HSQUIRRELVM v)
return SQ_SUCCEEDED(sq_call(v, sq_gettop(v) - 1, SQTrue, SQTrue)) ? 1 : SQ_ERROR; return SQ_SUCCEEDED(sq_call(v, sq_gettop(v) - 1, SQTrue, SQTrue)) ? 1 : SQ_ERROR;
} }
static SQInteger _closure_acall(HSQUIRRELVM v,SQBool raiseerror) static SQInteger _closure_acall(HRABBITVM v,SQBool raiseerror)
{ {
SQArray *aparams=_array(stack_get(v,2)); SQArray *aparams=_array(stack_get(v,2));
SQInteger nparams=aparams->Size(); SQInteger nparams=aparams->Size();
@ -951,38 +934,38 @@ static SQInteger _closure_acall(HSQUIRRELVM v,SQBool raiseerror)
return SQ_SUCCEEDED(sq_call(v,nparams,SQTrue,raiseerror))?1:SQ_ERROR; return SQ_SUCCEEDED(sq_call(v,nparams,SQTrue,raiseerror))?1:SQ_ERROR;
} }
static SQInteger closure_acall(HSQUIRRELVM v) static SQInteger closure_acall(HRABBITVM v)
{ {
return _closure_acall(v,SQTrue); return _closure_acall(v,SQTrue);
} }
static SQInteger closure_pacall(HSQUIRRELVM v) static SQInteger closure_pacall(HRABBITVM v)
{ {
return _closure_acall(v,SQFalse); return _closure_acall(v,SQFalse);
} }
static SQInteger closure_bindenv(HSQUIRRELVM v) static SQInteger closure_bindenv(HRABBITVM v)
{ {
if(SQ_FAILED(sq_bindenv(v,1))) if(SQ_FAILED(sq_bindenv(v,1)))
return SQ_ERROR; return SQ_ERROR;
return 1; return 1;
} }
static SQInteger closure_getroot(HSQUIRRELVM v) static SQInteger closure_getroot(HRABBITVM v)
{ {
if(SQ_FAILED(sq_getclosureroot(v,-1))) if(SQ_FAILED(sq_getclosureroot(v,-1)))
return SQ_ERROR; return SQ_ERROR;
return 1; return 1;
} }
static SQInteger closure_setroot(HSQUIRRELVM v) static SQInteger closure_setroot(HRABBITVM v)
{ {
if(SQ_FAILED(sq_setclosureroot(v,-2))) if(SQ_FAILED(sq_setclosureroot(v,-2)))
return SQ_ERROR; return SQ_ERROR;
return 1; return 1;
} }
static SQInteger closure_getinfos(HSQUIRRELVM v) { static SQInteger closure_getinfos(HRABBITVM v) {
SQObject o = stack_get(v,1); SQObject o = stack_get(v,1);
SQTable *res = SQTable::Create(_ss(v),4); SQTable *res = SQTable::Create(_ss(v),4);
if(sq_type(o) == OT_CLOSURE) { if(sq_type(o) == OT_CLOSURE) {
@ -1042,7 +1025,7 @@ const SQRegFunction SQSharedState::_closure_default_delegate_funcz[]={
}; };
//GENERATOR DEFAULT DELEGATE //GENERATOR DEFAULT DELEGATE
static SQInteger generator_getstatus(HSQUIRRELVM v) static SQInteger generator_getstatus(HRABBITVM v)
{ {
SQObject &o=stack_get(v,1); SQObject &o=stack_get(v,1);
switch(_generator(o)->_state){ switch(_generator(o)->_state){
@ -1061,7 +1044,7 @@ const SQRegFunction SQSharedState::_generator_default_delegate_funcz[]={
}; };
//THREAD DEFAULT DELEGATE //THREAD DEFAULT DELEGATE
static SQInteger thread_call(HSQUIRRELVM v) static SQInteger thread_call(HRABBITVM v)
{ {
SQObjectPtr o = stack_get(v,1); SQObjectPtr o = stack_get(v,1);
if(sq_type(o) == OT_THREAD) { if(sq_type(o) == OT_THREAD) {
@ -1080,7 +1063,7 @@ static SQInteger thread_call(HSQUIRRELVM v)
return sq_throwerror(v,_SC("wrong parameter")); return sq_throwerror(v,_SC("wrong parameter"));
} }
static SQInteger thread_wakeup(HSQUIRRELVM v) static SQInteger thread_wakeup(HRABBITVM v)
{ {
SQObjectPtr o = stack_get(v,1); SQObjectPtr o = stack_get(v,1);
if(sq_type(o) == OT_THREAD) { if(sq_type(o) == OT_THREAD) {
@ -1116,7 +1099,7 @@ static SQInteger thread_wakeup(HSQUIRRELVM v)
return sq_throwerror(v,_SC("wrong parameter")); return sq_throwerror(v,_SC("wrong parameter"));
} }
static SQInteger thread_wakeupthrow(HSQUIRRELVM v) static SQInteger thread_wakeupthrow(HRABBITVM v)
{ {
SQObjectPtr o = stack_get(v,1); SQObjectPtr o = stack_get(v,1);
if(sq_type(o) == OT_THREAD) { if(sq_type(o) == OT_THREAD) {
@ -1157,7 +1140,7 @@ static SQInteger thread_wakeupthrow(HSQUIRRELVM v)
return sq_throwerror(v,_SC("wrong parameter")); return sq_throwerror(v,_SC("wrong parameter"));
} }
static SQInteger thread_getstatus(HSQUIRRELVM v) static SQInteger thread_getstatus(HRABBITVM v)
{ {
SQObjectPtr &o = stack_get(v,1); SQObjectPtr &o = stack_get(v,1);
switch(sq_getvmstate(_thread(o))) { switch(sq_getvmstate(_thread(o))) {
@ -1176,7 +1159,7 @@ static SQInteger thread_getstatus(HSQUIRRELVM v)
return 1; return 1;
} }
static SQInteger thread_getstackinfos(HSQUIRRELVM v) static SQInteger thread_getstackinfos(HRABBITVM v)
{ {
SQObjectPtr o = stack_get(v,1); SQObjectPtr o = stack_get(v,1);
if(sq_type(o) == OT_THREAD) { if(sq_type(o) == OT_THREAD) {
@ -1220,27 +1203,27 @@ const SQRegFunction SQSharedState::_thread_default_delegate_funcz[] = {
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
static SQInteger class_getattributes(HSQUIRRELVM v) static SQInteger class_getattributes(HRABBITVM v)
{ {
return SQ_SUCCEEDED(sq_getattributes(v,-2))?1:SQ_ERROR; return SQ_SUCCEEDED(sq_getattributes(v,-2))?1:SQ_ERROR;
} }
static SQInteger class_setattributes(HSQUIRRELVM v) static SQInteger class_setattributes(HRABBITVM v)
{ {
return SQ_SUCCEEDED(sq_setattributes(v,-3))?1:SQ_ERROR; return SQ_SUCCEEDED(sq_setattributes(v,-3))?1:SQ_ERROR;
} }
static SQInteger class_instance(HSQUIRRELVM v) static SQInteger class_instance(HRABBITVM v)
{ {
return SQ_SUCCEEDED(sq_createinstance(v,-1))?1:SQ_ERROR; return SQ_SUCCEEDED(sq_createinstance(v,-1))?1:SQ_ERROR;
} }
static SQInteger class_getbase(HSQUIRRELVM v) static SQInteger class_getbase(HRABBITVM v)
{ {
return SQ_SUCCEEDED(sq_getbase(v,-1))?1:SQ_ERROR; return SQ_SUCCEEDED(sq_getbase(v,-1))?1:SQ_ERROR;
} }
static SQInteger class_newmember(HSQUIRRELVM v) static SQInteger class_newmember(HRABBITVM v)
{ {
SQInteger top = sq_gettop(v); SQInteger top = sq_gettop(v);
SQBool bstatic = SQFalse; SQBool bstatic = SQFalse;
@ -1256,7 +1239,7 @@ static SQInteger class_newmember(HSQUIRRELVM v)
return SQ_SUCCEEDED(sq_newmember(v,-4,bstatic))?1:SQ_ERROR; return SQ_SUCCEEDED(sq_newmember(v,-4,bstatic))?1:SQ_ERROR;
} }
static SQInteger class_rawnewmember(HSQUIRRELVM v) static SQInteger class_rawnewmember(HRABBITVM v)
{ {
SQInteger top = sq_gettop(v); SQInteger top = sq_gettop(v);
SQBool bstatic = SQFalse; SQBool bstatic = SQFalse;
@ -1288,7 +1271,7 @@ const SQRegFunction SQSharedState::_class_default_delegate_funcz[] = {
}; };
static SQInteger instance_getclass(HSQUIRRELVM v) static SQInteger instance_getclass(HRABBITVM v)
{ {
if(SQ_SUCCEEDED(sq_getclass(v,1))) if(SQ_SUCCEEDED(sq_getclass(v,1)))
return 1; return 1;
@ -1305,7 +1288,7 @@ const SQRegFunction SQSharedState::_instance_default_delegate_funcz[] = {
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
static SQInteger weakref_ref(HSQUIRRELVM v) static SQInteger weakref_ref(HRABBITVM v)
{ {
if(SQ_FAILED(sq_getweakrefval(v,1))) if(SQ_FAILED(sq_getweakrefval(v,1)))
return SQ_ERROR; return SQ_ERROR;

2
rabbit/sqclass.cpp
View File

@ -105,7 +105,7 @@ bool SQClass::NewSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr
SQInstance *SQClass::CreateInstance() SQInstance *SQClass::CreateInstance()
{ {
if(!_locked) Lock(); if(!_locked) Lock();
return SQInstance::Create(_opt_ss(this),this); return SQInstance::Create(NULL,this);
} }
SQInteger SQClass::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval) SQInteger SQClass::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval)

8
rabbit/sqclass.hpp
View File

@ -70,10 +70,6 @@ public:
sq_delete(this, SQClass); sq_delete(this, SQClass);
} }
void Finalize(); void Finalize();
#ifndef NO_GARBAGE_COLLECTOR
void Mark(SQCollectable ** );
SQObjectType GetType() {return OT_CLASS;}
#endif
SQInteger Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); SQInteger Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval);
SQInstance *CreateInstance(); SQInstance *CreateInstance();
SQTable *_members; SQTable *_members;
@ -150,10 +146,6 @@ public:
SQ_FREE(this, size); SQ_FREE(this, size);
} }
void Finalize(); void Finalize();
#ifndef NO_GARBAGE_COLLECTOR
void Mark(SQCollectable ** );
SQObjectType GetType() {return OT_INSTANCE;}
#endif
bool InstanceOf(SQClass *trg); bool InstanceOf(SQClass *trg);
bool GetMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res); bool GetMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res);

29
rabbit/sqclosure.hpp
View File

@ -46,7 +46,7 @@ public:
SQClosure *Clone() SQClosure *Clone()
{ {
SQFunctionProto *f = _function; SQFunctionProto *f = _function;
SQClosure * ret = SQClosure::Create(_opt_ss(this),f,_root); SQClosure * ret = SQClosure::Create(NULL,f,_root);
ret->_env = _env; ret->_env = _env;
if(ret->_env) __ObjAddRef(ret->_env); if(ret->_env) __ObjAddRef(ret->_env);
_COPY_VECTOR(ret->_outervalues,_outervalues,f->_noutervalues); _COPY_VECTOR(ret->_outervalues,_outervalues,f->_noutervalues);
@ -57,15 +57,6 @@ public:
bool Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write); bool Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write);
static bool Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret); static bool Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret);
#ifndef NO_GARBAGE_COLLECTOR
void Mark(SQCollectable **chain);
void Finalize(){
SQFunctionProto *f = _function;
_NULL_SQOBJECT_VECTOR(_outervalues,f->_noutervalues);
_NULL_SQOBJECT_VECTOR(_defaultparams,f->_ndefaultparams);
}
SQObjectType GetType() {return OT_CLOSURE;}
#endif
SQWeakRef *_env; SQWeakRef *_env;
SQWeakRef *_root; SQWeakRef *_root;
SQClass *_base; SQClass *_base;
@ -96,12 +87,6 @@ public:
sq_vm_free(this,sizeof(SQOuter)); sq_vm_free(this,sizeof(SQOuter));
} }
#ifndef NO_GARBAGE_COLLECTOR
void Mark(SQCollectable **chain);
void Finalize() { _value.Null(); }
SQObjectType GetType() {return OT_OUTER;}
#endif
SQObjectPtr *_valptr; /* pointer to value on stack, or _value below */ SQObjectPtr *_valptr; /* pointer to value on stack, or _value below */
SQInteger _idx; /* idx in stack array, for relocation */ SQInteger _idx; /* idx in stack array, for relocation */
SQObjectPtr _value; /* value of outer after stack frame is closed */ SQObjectPtr _value; /* value of outer after stack frame is closed */
@ -134,11 +119,6 @@ public:
bool Yield(SQVM *v,SQInteger target); bool Yield(SQVM *v,SQInteger target);
bool Resume(SQVM *v,SQObjectPtr &dest); bool Resume(SQVM *v,SQObjectPtr &dest);
#ifndef NO_GARBAGE_COLLECTOR
void Mark(SQCollectable **chain);
void Finalize(){_stack.resize(0);_closure.Null();}
SQObjectType GetType() {return OT_GENERATOR;}
#endif
SQObjectPtr _closure; SQObjectPtr _closure;
SQObjectPtrVec _stack; SQObjectPtrVec _stack;
SQVM::CallInfo _ci; SQVM::CallInfo _ci;
@ -165,7 +145,7 @@ public:
} }
SQNativeClosure *Clone() SQNativeClosure *Clone()
{ {
SQNativeClosure * ret = SQNativeClosure::Create(_opt_ss(this),_function,_noutervalues); SQNativeClosure * ret = SQNativeClosure::Create(NULL,_function,_noutervalues);
ret->_env = _env; ret->_env = _env;
if(ret->_env) __ObjAddRef(ret->_env); if(ret->_env) __ObjAddRef(ret->_env);
ret->_name = _name; ret->_name = _name;
@ -186,11 +166,6 @@ public:
sq_free(this,size); sq_free(this,size);
} }
#ifndef NO_GARBAGE_COLLECTOR
void Mark(SQCollectable **chain);
void Finalize() { _NULL_SQOBJECT_VECTOR(_outervalues,_noutervalues); }
SQObjectType GetType() {return OT_NATIVECLOSURE;}
#endif
SQInteger _nparamscheck; SQInteger _nparamscheck;
SQIntVec _typecheck; SQIntVec _typecheck;
SQObjectPtr *_outervalues; SQObjectPtr *_outervalues;

2
rabbit/sqcompiler.cpp
View File

@ -150,7 +150,7 @@ public:
Lex(); Lex();
return ret; return ret;
} }
bool IsEndOfStatement() { return ((_lex._prevtoken == _SC('\n')) || (_token == SQUIRREL_EOB) || (_token == _SC('}')) || (_token == _SC(';'))); } bool IsEndOfStatement() { return ((_lex._prevtoken == _SC('\n')) || (_token == RABBIT_EOB) || (_token == _SC('}')) || (_token == _SC(';'))); }
void OptionalSemicolon() void OptionalSemicolon()
{ {
if(_token == _SC(';')) { Lex(); return; } if(_token == _SC(';')) { Lex(); return; }

4
rabbit/sqdebug.cpp
View File

@ -13,7 +13,7 @@
#include <rabbit/sqclosure.hpp> #include <rabbit/sqclosure.hpp>
#include <rabbit/sqstring.hpp> #include <rabbit/sqstring.hpp>
SQRESULT sq_getfunctioninfo(HSQUIRRELVM v,SQInteger level,SQFunctionInfo *fi) SQRESULT sq_getfunctioninfo(HRABBITVM v,SQInteger level,SQFunctionInfo *fi)
{ {
SQInteger cssize = v->_callsstacksize; SQInteger cssize = v->_callsstacksize;
if (cssize > level) { if (cssize > level) {
@ -31,7 +31,7 @@ SQRESULT sq_getfunctioninfo(HSQUIRRELVM v,SQInteger level,SQFunctionInfo *fi)
return sq_throwerror(v,_SC("the object is not a closure")); return sq_throwerror(v,_SC("the object is not a closure"));
} }
SQRESULT sq_stackinfos(HSQUIRRELVM v, SQInteger level, SQStackInfos *si) SQRESULT sq_stackinfos(HRABBITVM v, SQInteger level, SQStackInfos *si)
{ {
SQInteger cssize = v->_callsstacksize; SQInteger cssize = v->_callsstacksize;
if (cssize > level) { if (cssize > level) {

5
rabbit/sqfuncproto.hpp
View File

@ -120,11 +120,6 @@ public:
SQInteger GetLine(SQInstruction *curr); SQInteger GetLine(SQInstruction *curr);
bool Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write); bool Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write);
static bool Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret); static bool Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret);
#ifndef NO_GARBAGE_COLLECTOR
void Mark(SQCollectable **chain);
void Finalize(){ _NULL_SQOBJECT_VECTOR(_literals,_nliterals); }
SQObjectType GetType() {return OT_FUNCPROTO;}
#endif
SQObjectPtr _sourcename; SQObjectPtr _sourcename;
SQObjectPtr _name; SQObjectPtr _name;
SQInteger _stacksize; SQInteger _stacksize;

12
rabbit/sqlexer.cpp
View File

@ -16,7 +16,7 @@
#define CUR_CHAR (_currdata) #define CUR_CHAR (_currdata)
#define RETURN_TOKEN(t) { _prevtoken = _curtoken; _curtoken = t; return t;} #define RETURN_TOKEN(t) { _prevtoken = _curtoken; _curtoken = t; return t;}
#define IS_EOB() (CUR_CHAR <= SQUIRREL_EOB) #define IS_EOB() (CUR_CHAR <= RABBIT_EOB)
#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.push_back(c);} #define APPEND_CHAR(c) { _longstr.push_back(c);}
@ -97,7 +97,7 @@ void SQLexer::Next()
_currdata = (LexChar)t; _currdata = (LexChar)t;
return; return;
} }
_currdata = SQUIRREL_EOB; _currdata = RABBIT_EOB;
_reached_eof = SQTrue; _reached_eof = SQTrue;
} }
@ -120,7 +120,7 @@ void SQLexer::LexBlockComment()
switch(CUR_CHAR) { switch(CUR_CHAR) {
case _SC('*'): { NEXT(); if(CUR_CHAR == _SC('/')) { done = true; NEXT(); }}; continue; case _SC('*'): { NEXT(); if(CUR_CHAR == _SC('/')) { done = true; NEXT(); }}; continue;
case _SC('\n'): _currentline++; NEXT(); continue; case _SC('\n'): _currentline++; NEXT(); continue;
case SQUIRREL_EOB: Error(_SC("missing \"*/\" in comment")); case RABBIT_EOB: Error(_SC("missing \"*/\" in comment"));
default: NEXT(); default: NEXT();
} }
} }
@ -133,7 +133,7 @@ void SQLexer::LexLineComment()
SQInteger SQLexer::Lex() SQInteger SQLexer::Lex()
{ {
_lasttokenline = _currentline; _lasttokenline = _currentline;
while(CUR_CHAR != SQUIRREL_EOB) { while(CUR_CHAR != RABBIT_EOB) {
switch(CUR_CHAR){ switch(CUR_CHAR){
case _SC('\t'): case _SC('\r'): case _SC(' '): NEXT(); continue; case _SC('\t'): case _SC('\r'): case _SC(' '): NEXT(); continue;
case _SC('\n'): case _SC('\n'):
@ -261,7 +261,7 @@ SQInteger SQLexer::Lex()
if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_PLUSEQ);} if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_PLUSEQ);}
else if (CUR_CHAR == _SC('+')){ NEXT(); RETURN_TOKEN(TK_PLUSPLUS);} else if (CUR_CHAR == _SC('+')){ NEXT(); RETURN_TOKEN(TK_PLUSPLUS);}
else RETURN_TOKEN('+'); else RETURN_TOKEN('+');
case SQUIRREL_EOB: case RABBIT_EOB:
return 0; return 0;
default:{ default:{
if (scisdigit(CUR_CHAR)) { if (scisdigit(CUR_CHAR)) {
@ -363,7 +363,7 @@ SQInteger SQLexer::ReadString(SQInteger ndelim,bool verbatim)
while(CUR_CHAR != ndelim) { while(CUR_CHAR != ndelim) {
SQInteger x = CUR_CHAR; SQInteger x = CUR_CHAR;
switch (x) { switch (x) {
case SQUIRREL_EOB: case RABBIT_EOB:
Error(_SC("unfinished string")); Error(_SC("unfinished string"));
return -1; return -1;
case _SC('\n'): case _SC('\n'):

139
rabbit/sqobject.cpp
View File

@ -280,7 +280,7 @@ SQClosure::~SQClosure()
} }
#define _CHECK_IO(exp) { if(!exp)return false; } #define _CHECK_IO(exp) { if(!exp)return false; }
bool SafeWrite(HSQUIRRELVM v,SQWRITEFUNC write,SQUserPointer up,SQUserPointer dest,SQInteger size) bool SafeWrite(HRABBITVM v,SQWRITEFUNC write,SQUserPointer up,SQUserPointer dest,SQInteger size)
{ {
if(write(up,dest,size) != size) { if(write(up,dest,size) != size) {
v->Raise_Error(_SC("io error (write function failure)")); v->Raise_Error(_SC("io error (write function failure)"));
@ -289,7 +289,7 @@ bool SafeWrite(HSQUIRRELVM v,SQWRITEFUNC write,SQUserPointer up,SQUserPointer de
return true; return true;
} }
bool SafeRead(HSQUIRRELVM v,SQWRITEFUNC read,SQUserPointer up,SQUserPointer dest,SQInteger size) bool SafeRead(HRABBITVM v,SQWRITEFUNC read,SQUserPointer up,SQUserPointer dest,SQInteger size)
{ {
if(size && read(up,dest,size) != size) { if(size && read(up,dest,size) != size) {
v->Raise_Error(_SC("io error, read function failure, the origin stream could be corrupted/trucated")); v->Raise_Error(_SC("io error, read function failure, the origin stream could be corrupted/trucated"));
@ -298,12 +298,12 @@ bool SafeRead(HSQUIRRELVM v,SQWRITEFUNC read,SQUserPointer up,SQUserPointer dest
return true; return true;
} }
bool WriteTag(HSQUIRRELVM v,SQWRITEFUNC write,SQUserPointer up,SQUnsignedInteger32 tag) bool WriteTag(HRABBITVM v,SQWRITEFUNC write,SQUserPointer up,SQUnsignedInteger32 tag)
{ {
return SafeWrite(v,write,up,&tag,sizeof(tag)); return SafeWrite(v,write,up,&tag,sizeof(tag));
} }
bool CheckTag(HSQUIRRELVM v,SQWRITEFUNC read,SQUserPointer up,SQUnsignedInteger32 tag) bool CheckTag(HRABBITVM v,SQWRITEFUNC read,SQUserPointer up,SQUnsignedInteger32 tag)
{ {
SQUnsignedInteger32 t; SQUnsignedInteger32 t;
_CHECK_IO(SafeRead(v,read,up,&t,sizeof(t))); _CHECK_IO(SafeRead(v,read,up,&t,sizeof(t)));
@ -314,7 +314,7 @@ bool CheckTag(HSQUIRRELVM v,SQWRITEFUNC read,SQUserPointer up,SQUnsignedInteger3
return true; return true;
} }
bool WriteObject(HSQUIRRELVM v,SQUserPointer up,SQWRITEFUNC write,SQObjectPtr &o) bool WriteObject(HRABBITVM v,SQUserPointer up,SQWRITEFUNC write,SQObjectPtr &o)
{ {
SQUnsignedInteger32 _type = (SQUnsignedInteger32)sq_type(o); SQUnsignedInteger32 _type = (SQUnsignedInteger32)sq_type(o);
_CHECK_IO(SafeWrite(v,write,up,&_type,sizeof(_type))); _CHECK_IO(SafeWrite(v,write,up,&_type,sizeof(_type)));
@ -337,7 +337,7 @@ bool WriteObject(HSQUIRRELVM v,SQUserPointer up,SQWRITEFUNC write,SQObjectPtr &o
return true; return true;
} }
bool ReadObject(HSQUIRRELVM v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &o) bool ReadObject(HRABBITVM v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &o)
{ {
SQUnsignedInteger32 _type; SQUnsignedInteger32 _type;
_CHECK_IO(SafeRead(v,read,up,&_type,sizeof(_type))); _CHECK_IO(SafeRead(v,read,up,&_type,sizeof(_type)));
@ -494,7 +494,7 @@ bool SQFunctionProto::Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr
_CHECK_IO(SafeRead(v,read,up, &nfunctions, sizeof(nfunctions))); _CHECK_IO(SafeRead(v,read,up, &nfunctions, sizeof(nfunctions)));
SQFunctionProto *f = SQFunctionProto::Create(_opt_ss(v),ninstructions,nliterals,nparameters, SQFunctionProto *f = SQFunctionProto::Create(NULL,ninstructions,nliterals,nparameters,
nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams); nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams);
SQObjectPtr proto = f; //gets a ref in case of failure SQObjectPtr proto = f; //gets a ref in case of failure
f->_sourcename = sourcename; f->_sourcename = sourcename;
@ -554,128 +554,3 @@ bool SQFunctionProto::Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr
return true; return true;
} }
#ifndef NO_GARBAGE_COLLECTOR
#define START_MARK() if(!(_uiRef&MARK_FLAG)){ \
_uiRef|=MARK_FLAG;
#define END_MARK() RemoveFromChain(&_sharedstate->_gc_chain, this); \
AddToChain(chain, this); }
void SQVM::Mark(SQCollectable **chain)
{
START_MARK()
SQSharedState::MarkObject(_lasterror,chain);
SQSharedState::MarkObject(_errorhandler,chain);
SQSharedState::MarkObject(_debughook_closure,chain);
SQSharedState::MarkObject(_roottable, chain);
SQSharedState::MarkObject(temp_reg, chain);
for(SQUnsignedInteger i = 0; i < _stack.size(); i++) SQSharedState::MarkObject(_stack[i], chain);
for(SQInteger k = 0; k < _callsstacksize; k++) SQSharedState::MarkObject(_callsstack[k]._closure, chain);
END_MARK()
}
void SQArray::Mark(SQCollectable **chain)
{
START_MARK()
SQInteger len = _values.size();
for(SQInteger i = 0;i < len; i++) SQSharedState::MarkObject(_values[i], chain);
END_MARK()
}
void SQTable::Mark(SQCollectable **chain)
{
START_MARK()
if(_delegate) _delegate->Mark(chain);
SQInteger len = _numofnodes;
for(SQInteger i = 0; i < len; i++){
SQSharedState::MarkObject(_nodes[i].key, chain);
SQSharedState::MarkObject(_nodes[i].val, chain);
}
END_MARK()
}
void SQClass::Mark(SQCollectable **chain)
{
START_MARK()
_members->Mark(chain);
if(_base) _base->Mark(chain);
SQSharedState::MarkObject(_attributes, chain);
for(SQUnsignedInteger i =0; i< _defaultvalues.size(); i++) {
SQSharedState::MarkObject(_defaultvalues[i].val, chain);
SQSharedState::MarkObject(_defaultvalues[i].attrs, chain);
}
for(SQUnsignedInteger j =0; j< _methods.size(); j++) {
SQSharedState::MarkObject(_methods[j].val, chain);
SQSharedState::MarkObject(_methods[j].attrs, chain);
}
for(SQUnsignedInteger k =0; k< MT_LAST; k++) {
SQSharedState::MarkObject(_metamethods[k], chain);
}
END_MARK()
}
void SQInstance::Mark(SQCollectable **chain)
{
START_MARK()
_class->Mark(chain);
SQUnsignedInteger nvalues = _class->_defaultvalues.size();
for(SQUnsignedInteger i =0; i< nvalues; i++) {
SQSharedState::MarkObject(_values[i], chain);
}
END_MARK()
}
void SQGenerator::Mark(SQCollectable **chain)
{
START_MARK()
for(SQUnsignedInteger i = 0; i < _stack.size(); i++) SQSharedState::MarkObject(_stack[i], chain);
SQSharedState::MarkObject(_closure, chain);
END_MARK()
}
void SQFunctionProto::Mark(SQCollectable **chain)
{
START_MARK()
for(SQInteger i = 0; i < _nliterals; i++) SQSharedState::MarkObject(_literals[i], chain);
for(SQInteger k = 0; k < _nfunctions; k++) SQSharedState::MarkObject(_functions[k], chain);
END_MARK()
}
void SQClosure::Mark(SQCollectable **chain)
{
START_MARK()
if(_base) _base->Mark(chain);
SQFunctionProto *fp = _function;
fp->Mark(chain);
for(SQInteger i = 0; i < fp->_noutervalues; i++) SQSharedState::MarkObject(_outervalues[i], chain);
for(SQInteger k = 0; k < fp->_ndefaultparams; k++) SQSharedState::MarkObject(_defaultparams[k], chain);
END_MARK()
}
void SQNativeClosure::Mark(SQCollectable **chain)
{
START_MARK()
for(SQUnsignedInteger i = 0; i < _noutervalues; i++) SQSharedState::MarkObject(_outervalues[i], chain);
END_MARK()
}
void SQOuter::Mark(SQCollectable **chain)
{
START_MARK()
/* If the valptr points to a closed value, that value is alive */
if(_valptr == &_value) {
SQSharedState::MarkObject(_value, chain);
}
END_MARK()
}
void SQUserData::Mark(SQCollectable **chain){
START_MARK()
if(_delegate) _delegate->Mark(chain);
END_MARK()
}
void SQCollectable::UnMark() { _uiRef&=~MARK_FLAG; }
#endif

24
rabbit/sqobject.hpp
View File

@ -312,34 +312,10 @@ inline void _Swap(SQObject &a,SQObject &b)
b._unVal = unOldVal; b._unVal = unOldVal;
} }
/////////////////////////////////////////////////////////////////////////////////////
#ifndef NO_GARBAGE_COLLECTOR
#define MARK_FLAG 0x80000000
struct SQCollectable : public SQRefCounted {
SQCollectable *_next;
SQCollectable *_prev;
SQSharedState *_sharedstate;
virtual SQObjectType GetType()=0;
virtual void Release()=0;
virtual void Mark(SQCollectable **chain)=0;
void UnMark();
virtual void Finalize()=0;
static void AddToChain(SQCollectable **chain,SQCollectable *c);
static void RemoveFromChain(SQCollectable **chain,SQCollectable *c);
};
#define ADD_TO_CHAIN(chain,obj) AddToChain(chain,obj)
#define REMOVE_FROM_CHAIN(chain,obj) {if(!(_uiRef&MARK_FLAG))RemoveFromChain(chain,obj);}
#define CHAINABLE_OBJ SQCollectable
#define INIT_CHAIN() {_next=NULL;_prev=NULL;_sharedstate=ss;}
#else
#define ADD_TO_CHAIN(chain,obj) ((void)0) #define ADD_TO_CHAIN(chain,obj) ((void)0)
#define REMOVE_FROM_CHAIN(chain,obj) ((void)0) #define REMOVE_FROM_CHAIN(chain,obj) ((void)0)
#define CHAINABLE_OBJ SQRefCounted #define CHAINABLE_OBJ SQRefCounted
#define INIT_CHAIN() ((void)0) #define INIT_CHAIN() ((void)0)
#endif
struct SQDelegable : public CHAINABLE_OBJ { struct SQDelegable : public CHAINABLE_OBJ {
bool SetDelegate(SQTable *m); bool SetDelegate(SQTable *m);

184
rabbit/sqstate.cpp
View File

@ -97,9 +97,6 @@ void SQSharedState::Init()
{ {
_scratchpad=NULL; _scratchpad=NULL;
_scratchpadsize=0; _scratchpadsize=0;
#ifndef NO_GARBAGE_COLLECTOR
_gc_chain=NULL;
#endif
_stringtable = (SQStringTable*)SQ_MALLOC(sizeof(SQStringTable)); _stringtable = (SQStringTable*)SQ_MALLOC(sizeof(SQStringTable));
new (_stringtable) SQStringTable(this); new (_stringtable) SQStringTable(this);
sq_new(_metamethods,SQObjectPtrVec); sq_new(_metamethods,SQObjectPtrVec);
@ -185,26 +182,6 @@ SQSharedState::~SQSharedState()
_instance_default_delegate.Null(); _instance_default_delegate.Null();
_weakref_default_delegate.Null(); _weakref_default_delegate.Null();
_refs_table.Finalize(); _refs_table.Finalize();
#ifndef NO_GARBAGE_COLLECTOR
SQCollectable *t = _gc_chain;
SQCollectable *nx = NULL;
if(t) {
t->_uiRef++;
while(t) {
t->Finalize();
nx = t->_next;
if(nx) nx->_uiRef++;
if(--t->_uiRef == 0)
t->Release();
t = nx;
}
}
assert(_gc_chain==NULL); //just to proove a theory
while(_gc_chain){
_gc_chain->_uiRef++;
_gc_chain->Release();
}
#endif
sq_delete(_types,SQObjectPtrVec); sq_delete(_types,SQObjectPtrVec);
sq_delete(_systemstrings,SQObjectPtrVec); sq_delete(_systemstrings,SQObjectPtrVec);
@ -225,155 +202,6 @@ SQInteger SQSharedState::GetMetaMethodIdxByName(const SQObjectPtr &name)
return -1; return -1;
} }
#ifndef NO_GARBAGE_COLLECTOR
void SQSharedState::MarkObject(SQObjectPtr &o,SQCollectable **chain)
{
switch(sq_type(o)){
case OT_TABLE:_table(o)->Mark(chain);break;
case OT_ARRAY:_array(o)->Mark(chain);break;
case OT_USERDATA:_userdata(o)->Mark(chain);break;
case OT_CLOSURE:_closure(o)->Mark(chain);break;
case OT_NATIVECLOSURE:_nativeclosure(o)->Mark(chain);break;
case OT_GENERATOR:_generator(o)->Mark(chain);break;
case OT_THREAD:_thread(o)->Mark(chain);break;
case OT_CLASS:_class(o)->Mark(chain);break;
case OT_INSTANCE:_instance(o)->Mark(chain);break;
case OT_OUTER:_outer(o)->Mark(chain);break;
case OT_FUNCPROTO:_funcproto(o)->Mark(chain);break;
default: break; //shutup compiler
}
}
void SQSharedState::RunMark(SQVM* SQ_UNUSED_ARG(vm),SQCollectable **tchain)
{
SQVM *vms = _thread(_root_vm);
vms->Mark(tchain);
_refs_table.Mark(tchain);
MarkObject(_registry,tchain);
MarkObject(_consts,tchain);
MarkObject(_metamethodsmap,tchain);
MarkObject(_table_default_delegate,tchain);
MarkObject(_array_default_delegate,tchain);
MarkObject(_string_default_delegate,tchain);
MarkObject(_number_default_delegate,tchain);
MarkObject(_generator_default_delegate,tchain);
MarkObject(_thread_default_delegate,tchain);
MarkObject(_closure_default_delegate,tchain);
MarkObject(_class_default_delegate,tchain);
MarkObject(_instance_default_delegate,tchain);
MarkObject(_weakref_default_delegate,tchain);
}
SQInteger SQSharedState::ResurrectUnreachable(SQVM *vm)
{
SQInteger n=0;
SQCollectable *tchain=NULL;
RunMark(vm,&tchain);
SQCollectable *resurrected = _gc_chain;
SQCollectable *t = resurrected;
_gc_chain = tchain;
SQArray *ret = NULL;
if(resurrected) {
ret = SQArray::Create(this,0);
SQCollectable *rlast = NULL;
while(t) {
rlast = t;
SQObjectType type = t->GetType();
if(type != OT_FUNCPROTO && type != OT_OUTER) {
SQObject sqo;
sqo._type = type;
sqo._unVal.pRefCounted = t;
ret->Append(sqo);
}
t = t->_next;
n++;
}
assert(rlast->_next == NULL);
rlast->_next = _gc_chain;
if(_gc_chain)
{
_gc_chain->_prev = rlast;
}
_gc_chain = resurrected;
}
t = _gc_chain;
while(t) {
t->UnMark();
t = t->_next;
}
if(ret) {
SQObjectPtr temp = ret;
vm->Push(temp);
}
else {
vm->PushNull();
}
return n;
}
SQInteger SQSharedState::CollectGarbage(SQVM *vm)
{
SQInteger n = 0;
SQCollectable *tchain = NULL;
RunMark(vm,&tchain);
SQCollectable *t = _gc_chain;
SQCollectable *nx = NULL;
if(t) {
t->_uiRef++;
while(t) {
t->Finalize();
nx = t->_next;
if(nx) nx->_uiRef++;
if(--t->_uiRef == 0)
t->Release();
t = nx;
n++;
}
}
t = tchain;
while(t) {
t->UnMark();
t = t->_next;
}
_gc_chain = tchain;
return n;
}
#endif
#ifndef NO_GARBAGE_COLLECTOR
void SQCollectable::AddToChain(SQCollectable **chain,SQCollectable *c)
{
c->_prev = NULL;
c->_next = *chain;
if(*chain) (*chain)->_prev = c;
*chain = c;
}
void SQCollectable::RemoveFromChain(SQCollectable **chain,SQCollectable *c)
{
if(c->_prev) c->_prev->_next = c->_next;
else *chain = c->_next;
if(c->_next)
c->_next->_prev = c->_prev;
c->_next = NULL;
c->_prev = NULL;
}
#endif
SQChar* SQSharedState::GetScratchPad(SQInteger size) SQChar* SQSharedState::GetScratchPad(SQInteger size)
{ {
@ -412,18 +240,6 @@ RefTable::~RefTable()
SQ_FREE(_buckets,(_numofslots * sizeof(RefNode *)) + (_numofslots * sizeof(RefNode))); SQ_FREE(_buckets,(_numofslots * sizeof(RefNode *)) + (_numofslots * sizeof(RefNode)));
} }
#ifndef NO_GARBAGE_COLLECTOR
void RefTable::Mark(SQCollectable **chain)
{
RefNode *nodes = (RefNode *)_nodes;
for(SQUnsignedInteger n = 0; n < _numofslots; n++) {
if(sq_type(nodes->obj) != OT_NULL) {
SQSharedState::MarkObject(nodes->obj,chain);
}
nodes++;
}
}
#endif
void RefTable::AddRef(SQObject &obj) void RefTable::AddRef(SQObject &obj)
{ {

12
rabbit/sqstate.hpp
View File

@ -40,9 +40,6 @@ struct RefTable {
void AddRef(SQObject &obj); void AddRef(SQObject &obj);
SQBool Release(SQObject &obj); SQBool Release(SQObject &obj);
SQUnsignedInteger GetRefCount(SQObject &obj); SQUnsignedInteger GetRefCount(SQObject &obj);
#ifndef NO_GARBAGE_COLLECTOR
void Mark(SQCollectable **chain);
#endif
void Finalize(); void Finalize();
private: private:
RefNode *Get(SQObject &obj,SQHash &mainpos,RefNode **prev,bool add); RefNode *Get(SQObject &obj,SQHash &mainpos,RefNode **prev,bool add);
@ -69,12 +66,6 @@ struct SQSharedState
public: public:
SQChar* GetScratchPad(SQInteger size); SQChar* GetScratchPad(SQInteger size);
SQInteger GetMetaMethodIdxByName(const SQObjectPtr &name); SQInteger GetMetaMethodIdxByName(const SQObjectPtr &name);
#ifndef NO_GARBAGE_COLLECTOR
SQInteger CollectGarbage(SQVM *vm);
void RunMark(SQVM *vm,SQCollectable **tchain);
SQInteger ResurrectUnreachable(SQVM *vm);
static void MarkObject(SQObjectPtr &o,SQCollectable **chain);
#endif
SQObjectPtrVec *_metamethods; SQObjectPtrVec *_metamethods;
SQObjectPtr _metamethodsmap; SQObjectPtr _metamethodsmap;
SQObjectPtrVec *_systemstrings; SQObjectPtrVec *_systemstrings;
@ -84,9 +75,6 @@ public:
SQObjectPtr _registry; SQObjectPtr _registry;
SQObjectPtr _consts; SQObjectPtr _consts;
SQObjectPtr _constructoridx; SQObjectPtr _constructoridx;
#ifndef NO_GARBAGE_COLLECTOR
SQCollectable *_gc_chain;
#endif
SQObjectPtr _root_vm; SQObjectPtr _root_vm;
SQObjectPtr _table_default_delegate; SQObjectPtr _table_default_delegate;
static const SQRegFunction _table_default_delegate_funcz[]; static const SQRegFunction _table_default_delegate_funcz[];

2
rabbit/sqtable.cpp
View File

@ -77,7 +77,7 @@ void SQTable::Rehash(bool force)
SQTable *SQTable::Clone() SQTable *SQTable::Clone()
{ {
SQTable *nt=Create(_opt_ss(this),_numofnodes); SQTable *nt=Create(NULL,_numofnodes);
#ifdef _FAST_CLONE #ifdef _FAST_CLONE
_HashNode *basesrc = _nodes; _HashNode *basesrc = _nodes;
_HashNode *basedst = nt->_nodes; _HashNode *basedst = nt->_nodes;

4
rabbit/sqtable.hpp
View File

@ -65,10 +65,6 @@ public:
for (SQInteger i = 0; i < _numofnodes; i++) _nodes[i].~_HashNode(); for (SQInteger i = 0; i < _numofnodes; i++) _nodes[i].~_HashNode();
SQ_FREE(_nodes, _numofnodes * sizeof(_HashNode)); SQ_FREE(_nodes, _numofnodes * sizeof(_HashNode));
} }
#ifndef NO_GARBAGE_COLLECTOR
void Mark(SQCollectable **chain);
SQObjectType GetType() {return OT_TABLE;}
#endif
inline _HashNode *_Get(const SQObjectPtr &key,SQHash hash) inline _HashNode *_Get(const SQObjectPtr &key,SQHash hash)
{ {
_HashNode *n = &_nodes[hash]; _HashNode *n = &_nodes[hash];

5
rabbit/squserdata.hpp
View File

@ -23,11 +23,6 @@ struct SQUserData : SQDelegable
ud->_typetag = 0; ud->_typetag = 0;
return ud; return ud;
} }
#ifndef NO_GARBAGE_COLLECTOR
void Mark(SQCollectable **chain);
void Finalize(){SetDelegate(NULL);}
SQObjectType GetType(){ return OT_USERDATA;}
#endif
void Release() { void Release() {
if (_hook) _hook((SQUserPointer)sq_aligning(this + 1),_size); if (_hook) _hook((SQUserPointer)sq_aligning(this + 1),_size);
SQInteger tsize = _size; SQInteger tsize = _size;

20
rabbit/sqvm.hpp
View File

@ -21,7 +21,7 @@
#define GET_FLAG_RAW 0x00000001 #define GET_FLAG_RAW 0x00000001
#define GET_FLAG_DO_NOT_RAISE_ERROR 0x00000002 #define GET_FLAG_DO_NOT_RAISE_ERROR 0x00000002
//base lib //base lib
void sq_base_register(HSQUIRRELVM v); void sq_base_register(HRABBITVM v);
struct SQExceptionTrap{ struct SQExceptionTrap{
SQExceptionTrap() {} SQExceptionTrap() {}
@ -56,7 +56,7 @@ struct SQVM : public CHAINABLE_OBJ
typedef sqvector<CallInfo> CallInfoVec; typedef sqvector<CallInfo> CallInfoVec;
public: public:
void DebugHookProxy(SQInteger type, const SQChar * sourcename, SQInteger line, const SQChar * funcname); void DebugHookProxy(SQInteger type, const SQChar * sourcename, SQInteger line, const SQChar * funcname);
static void _DebugHookProxy(HSQUIRRELVM v, SQInteger type, const SQChar * sourcename, SQInteger line, const SQChar * funcname); static void _DebugHookProxy(HRABBITVM v, SQInteger type, const SQChar * sourcename, SQInteger line, const SQChar * funcname);
enum ExecutionType { ET_CALL, ET_RESUME_GENERATOR, ET_RESUME_VM,ET_RESUME_THROW_VM }; enum ExecutionType { ET_CALL, ET_RESUME_GENERATOR, ET_RESUME_VM,ET_RESUME_THROW_VM };
SQVM(SQSharedState *ss); SQVM(SQSharedState *ss);
~SQVM(); ~SQVM();
@ -65,10 +65,10 @@ public:
//starts a native call return when the NATIVE closure returns //starts a native call return when the NATIVE closure returns
bool CallNative(SQNativeClosure *nclosure, SQInteger nargs, SQInteger newbase, SQObjectPtr &retval, SQInt32 target, bool &suspend,bool &tailcall); bool CallNative(SQNativeClosure *nclosure, SQInteger nargs, SQInteger newbase, SQObjectPtr &retval, SQInt32 target, bool &suspend,bool &tailcall);
bool TailCall(SQClosure *closure, SQInteger firstparam, SQInteger nparams); bool TailCall(SQClosure *closure, SQInteger firstparam, SQInteger nparams);
//starts a SQUIRREL call in the same "Execution loop" //starts a RABBIT call in the same "Execution loop"
bool StartCall(SQClosure *closure, SQInteger target, SQInteger nargs, SQInteger stackbase, bool tailcall); bool StartCall(SQClosure *closure, SQInteger target, SQInteger nargs, SQInteger stackbase, bool tailcall);
bool CreateClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor); bool CreateClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor);
//call a generic closure pure SQUIRREL or NATIVE //call a generic closure pure RABBIT or NATIVE
bool Call(SQObjectPtr &closure, SQInteger nparams, SQInteger stackbase, SQObjectPtr &outres,SQBool raiseerror); bool Call(SQObjectPtr &closure, SQInteger nparams, SQInteger stackbase, SQObjectPtr &outres,SQBool raiseerror);
SQRESULT Suspend(); SQRESULT Suspend();
@ -120,10 +120,6 @@ public:
void dumpstack(SQInteger stackbase=-1, bool dumpall = false); void dumpstack(SQInteger stackbase=-1, bool dumpall = false);
#endif #endif
#ifndef NO_GARBAGE_COLLECTOR
void Mark(SQCollectable **chain);
SQObjectType GetType() {return OT_THREAD;}
#endif
void Finalize(); void Finalize();
void GrowCallStack() { void GrowCallStack() {
SQInteger newsize = _alloccallsstacksize*2; SQInteger newsize = _alloccallsstacksize*2;
@ -191,16 +187,10 @@ struct AutoDec{
SQInteger *_n; SQInteger *_n;
}; };
inline SQObjectPtr &stack_get(HSQUIRRELVM v,SQInteger idx){return ((idx>=0)?(v->GetAt(idx+v->_stackbase-1)):(v->GetUp(idx)));} inline SQObjectPtr &stack_get(HRABBITVM v,SQInteger idx){return ((idx>=0)?(v->GetAt(idx+v->_stackbase-1)):(v->GetUp(idx)));}
#define _ss(_vm_) (_vm_)->_sharedstate #define _ss(_vm_) (_vm_)->_sharedstate
#ifndef NO_GARBAGE_COLLECTOR
#define _opt_ss(_vm_) (_vm_)->_sharedstate
#else
#define _opt_ss(_vm_) NULL
#endif
#define PUSH_CALLINFO(v,nci){ \ #define PUSH_CALLINFO(v,nci){ \
SQInteger css = v->_callsstacksize; \ SQInteger css = v->_callsstacksize; \
if(css == v->_alloccallsstacksize) { \ if(css == v->_alloccallsstacksize) { \