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

[DEV] simplify typing (too much)

Browse Source
This commit is contained in:
Edouard DUPIN 2018-06-27 01:30:21 +02:00
parent bec51d5c0a
commit db219fa8e6
45 changed files with 1418 additions and 1453 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
cmdLine/rabbit.cpp
View File

@ -48,7 +48,7 @@ int MemAllocHook(int allocType,
#endif #endif
SQInteger quit(HRABBITVM v) int64_t quit(HRABBITVM v)
{ {
int *done; int *done;
sq_getuserpointer(v,-1,(SQUserPointer*)&done); sq_getuserpointer(v,-1,(SQUserPointer*)&done);
@ -74,7 +74,7 @@ void errorfunc(HRABBITVM SQ_UNUSED_ARG(v),const SQChar *s,...)
void PrintVersionInfos() void PrintVersionInfos()
{ {
scfprintf(stdout,_SC("%s %s (%d bits)\n"),RABBIT_VERSION,RABBIT_COPYRIGHT,((int)(sizeof(SQInteger)*8))); scfprintf(stdout,_SC("%s %s (%d bits)\n"),RABBIT_VERSION,RABBIT_COPYRIGHT,((int)(sizeof(int64_t)*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(HRABBITVM v,int argc, char* argv[],SQInteger *retval) int getargs(HRABBITVM v,int argc, char* argv[],int64_t *retval)
{ {
int i; int i;
int compiles_only = 0; int compiles_only = 0;
@ -236,10 +236,10 @@ void Interactive(HRABBITVM v)
#define MAXINPUT 1024 #define MAXINPUT 1024
SQChar buffer[MAXINPUT]; SQChar buffer[MAXINPUT];
SQInteger blocks =0; int64_t blocks =0;
SQInteger string=0; int64_t string=0;
SQInteger retval=0; int64_t retval=0;
SQInteger done=0; int64_t done=0;
PrintVersionInfos(); PrintVersionInfos();
sq_pushroottable(v); sq_pushroottable(v);
@ -252,7 +252,7 @@ void Interactive(HRABBITVM v)
while (!done) while (!done)
{ {
SQInteger i = 0; int64_t i = 0;
scprintf(_SC("\nrabbit> ")); scprintf(_SC("\nrabbit> "));
for(;;) { for(;;) {
int c; int c;
@ -292,7 +292,7 @@ void Interactive(HRABBITVM v)
} }
i=scstrlen(buffer); i=scstrlen(buffer);
if(i>0){ if(i>0){
SQInteger oldtop=sq_gettop(v); int64_t oldtop=sq_gettop(v);
if(SQ_SUCCEEDED(sq_compilebuffer(v,buffer,i,_SC("interactive console"),SQTrue))){ if(SQ_SUCCEEDED(sq_compilebuffer(v,buffer,i,_SC("interactive console"),SQTrue))){
sq_pushroottable(v); sq_pushroottable(v);
if(SQ_SUCCEEDED(sq_call(v,1,retval,SQTrue)) && retval){ if(SQ_SUCCEEDED(sq_call(v,1,retval,SQTrue)) && retval){
@ -316,7 +316,7 @@ void Interactive(HRABBITVM v)
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
HRABBITVM v; HRABBITVM v;
SQInteger retval = 0; int64_t retval = 0;
#if defined(_MSC_VER) && defined(_DEBUG) #if defined(_MSC_VER) && defined(_DEBUG)
_CrtSetAllocHook(MemAllocHook); _CrtSetAllocHook(MemAllocHook);
#endif #endif

2
etc/minimal.cpp
View File

@ -36,7 +36,7 @@ void errorfunc(HSQUIRRELVM v,const SQChar *s,...)
void call_foo(HSQUIRRELVM v, int n,float f,const SQChar *s) void call_foo(HSQUIRRELVM v, int n,float f,const SQChar *s)
{ {
SQInteger top = sq_gettop(v); //saves the stack size before the call int64_t top = sq_gettop(v); //saves the stack size before the call
sq_pushroottable(v); //pushes the global table sq_pushroottable(v); //pushes the global table
sq_pushstring(v,_SC("foo"),-1); sq_pushstring(v,_SC("foo"),-1);
if(SQ_SUCCEEDED(sq_get(v,-2))) { //gets the field 'foo' from the global table if(SQ_SUCCEEDED(sq_get(v,-2))) { //gets the field 'foo' from the global table

3
lutin_rabbit-core.py
View File

@ -44,7 +44,8 @@ def configure(target, my_module):
my_module.add_depend([ my_module.add_depend([
'z', 'z',
'm', 'm',
'c' 'c',
'etk-base',
]) ])
my_module.add_header_file([ my_module.add_header_file([
'rabbit/sqclass.hpp', 'rabbit/sqclass.hpp',

12
rabbit-std/sqstdaux.cpp
View File

@ -15,12 +15,12 @@ void sqstd_printcallstack(HRABBITVM v)
SQPRINTFUNCTION pf = sq_geterrorfunc(v); SQPRINTFUNCTION pf = sq_geterrorfunc(v);
if(pf) { if(pf) {
SQStackInfos si; SQStackInfos si;
SQInteger i; int64_t i;
SQFloat f; float_t f;
const SQChar *s; const SQChar *s;
SQInteger level=1; //1 is to skip this function that is level 0 int64_t level=1; //1 is to skip this function that is level 0
const SQChar *name=0; const SQChar *name=0;
SQInteger seq=0; int64_t seq=0;
pf(v,_SC("\nCALLSTACK\n")); pf(v,_SC("\nCALLSTACK\n"));
while(SQ_SUCCEEDED(sq_stackinfos(v,level,&si))) while(SQ_SUCCEEDED(sq_stackinfos(v,level,&si)))
{ {
@ -103,7 +103,7 @@ void sqstd_printcallstack(HRABBITVM v)
} }
} }
static SQInteger _sqstd_aux_printerror(HRABBITVM v) static int64_t _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(HRABBITVM v)
return 0; return 0;
} }
void _sqstd_compiler_error(HRABBITVM v,const SQChar *sErr,const SQChar *sSource,SQInteger line,SQInteger column) void _sqstd_compiler_error(HRABBITVM v,const SQChar *sErr,const SQChar *sSource,int64_t line,int64_t column)
{ {
SQPRINTFUNCTION pf = sq_geterrorfunc(v); SQPRINTFUNCTION pf = sq_geterrorfunc(v);
if(pf) { if(pf) {

76
rabbit-std/sqstdblob.cpp
View File

@ -7,7 +7,7 @@
#include <rabbit-std/sqstdstream.hpp> #include <rabbit-std/sqstdstream.hpp>
#include <rabbit-std/sqstdblobimpl.hpp> #include <rabbit-std/sqstdblobimpl.hpp>
#define SQSTD_BLOB_TYPE_TAG ((SQUnsignedInteger)(SQSTD_STREAM_TYPE_TAG | 0x00000002)) #define SQSTD_BLOB_TYPE_TAG ((uint64_t)(SQSTD_STREAM_TYPE_TAG | 0x00000002))
//Blob //Blob
@ -20,10 +20,10 @@
return sq_throwerror(v,_SC("the blob is invalid")); return sq_throwerror(v,_SC("the blob is invalid"));
static SQInteger _blob_resize(HRABBITVM v) static int64_t _blob_resize(HRABBITVM v)
{ {
SETUP_BLOB(v); SETUP_BLOB(v);
SQInteger size; int64_t size;
sq_getinteger(v,2,&size); sq_getinteger(v,2,&size);
if(!self->Resize(size)) if(!self->Resize(size))
return sq_throwerror(v,_SC("resize failed")); return sq_throwerror(v,_SC("resize failed"));
@ -43,32 +43,32 @@ 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(HRABBITVM v) static int64_t _blob_swap4(HRABBITVM v)
{ {
SETUP_BLOB(v); SETUP_BLOB(v);
SQInteger num=(self->Len()-(self->Len()%4))>>2; int64_t num=(self->Len()-(self->Len()%4))>>2;
unsigned int *t=(unsigned int *)self->GetBuf(); unsigned int *t=(unsigned int *)self->GetBuf();
for(SQInteger i = 0; i < num; i++) { for(int64_t i = 0; i < num; i++) {
__swap_dword(&t[i]); __swap_dword(&t[i]);
} }
return 0; return 0;
} }
static SQInteger _blob_swap2(HRABBITVM v) static int64_t _blob_swap2(HRABBITVM v)
{ {
SETUP_BLOB(v); SETUP_BLOB(v);
SQInteger num=(self->Len()-(self->Len()%2))>>1; int64_t num=(self->Len()-(self->Len()%2))>>1;
unsigned short *t = (unsigned short *)self->GetBuf(); unsigned short *t = (unsigned short *)self->GetBuf();
for(SQInteger i = 0; i < num; i++) { for(int64_t i = 0; i < num; i++) {
__swap_word(&t[i]); __swap_word(&t[i]);
} }
return 0; return 0;
} }
static SQInteger _blob__set(HRABBITVM v) static int64_t _blob__set(HRABBITVM v)
{ {
SETUP_BLOB(v); SETUP_BLOB(v);
SQInteger idx,val; int64_t idx,val;
sq_getinteger(v,2,&idx); sq_getinteger(v,2,&idx);
sq_getinteger(v,3,&val); sq_getinteger(v,3,&val);
if(idx < 0 || idx >= self->Len()) if(idx < 0 || idx >= self->Len())
@ -78,10 +78,10 @@ static SQInteger _blob__set(HRABBITVM v)
return 1; return 1;
} }
static SQInteger _blob__get(HRABBITVM v) static int64_t _blob__get(HRABBITVM v)
{ {
SETUP_BLOB(v); SETUP_BLOB(v);
SQInteger idx; int64_t idx;
if ((sq_gettype(v, 2) & SQOBJECT_NUMERIC) == 0) if ((sq_gettype(v, 2) & SQOBJECT_NUMERIC) == 0)
{ {
@ -95,14 +95,14 @@ static SQInteger _blob__get(HRABBITVM v)
return 1; return 1;
} }
static SQInteger _blob__nexti(HRABBITVM v) static int64_t _blob__nexti(HRABBITVM v)
{ {
SETUP_BLOB(v); SETUP_BLOB(v);
if(sq_gettype(v,2) == OT_NULL) { if(sq_gettype(v,2) == OT_NULL) {
sq_pushinteger(v, 0); sq_pushinteger(v, 0);
return 1; return 1;
} }
SQInteger idx; int64_t idx;
if(SQ_SUCCEEDED(sq_getinteger(v, 2, &idx))) { if(SQ_SUCCEEDED(sq_getinteger(v, 2, &idx))) {
if(idx+1 < self->Len()) { if(idx+1 < self->Len()) {
sq_pushinteger(v, idx+1); sq_pushinteger(v, idx+1);
@ -114,13 +114,13 @@ static SQInteger _blob__nexti(HRABBITVM 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(HRABBITVM v) static int64_t _blob__typeof(HRABBITVM v)
{ {
sq_pushstring(v,_SC("blob"),-1); sq_pushstring(v,_SC("blob"),-1);
return 1; return 1;
} }
static SQInteger _blob_releasehook(SQUserPointer p, SQInteger SQ_UNUSED_ARG(size)) static int64_t _blob_releasehook(SQUserPointer p, int64_t SQ_UNUSED_ARG(size))
{ {
SQBlob *self = (SQBlob*)p; SQBlob *self = (SQBlob*)p;
self->~SQBlob(); self->~SQBlob();
@ -128,10 +128,10 @@ static SQInteger _blob_releasehook(SQUserPointer p, SQInteger SQ_UNUSED_ARG(size
return 1; return 1;
} }
static SQInteger _blob_constructor(HRABBITVM v) static int64_t _blob_constructor(HRABBITVM v)
{ {
SQInteger nparam = sq_gettop(v); int64_t nparam = sq_gettop(v);
SQInteger size = 0; int64_t size = 0;
if(nparam == 2) { if(nparam == 2) {
sq_getinteger(v, 2, &size); sq_getinteger(v, 2, &size);
} }
@ -148,7 +148,7 @@ static SQInteger _blob_constructor(HRABBITVM v)
return 0; return 0;
} }
static SQInteger _blob__cloned(HRABBITVM v) static int64_t _blob__cloned(HRABBITVM v)
{ {
SQBlob *other = NULL; SQBlob *other = NULL;
{ {
@ -185,44 +185,44 @@ static const SQRegFunction _blob_methods[] = {
//GLOBAL FUNCTIONS //GLOBAL FUNCTIONS
static SQInteger _g_blob_casti2f(HRABBITVM v) static int64_t _g_blob_casti2f(HRABBITVM v)
{ {
SQInteger i; int64_t i;
sq_getinteger(v,2,&i); sq_getinteger(v,2,&i);
sq_pushfloat(v,*((const SQFloat *)&i)); sq_pushfloat(v,*((const float_t *)&i));
return 1; return 1;
} }
static SQInteger _g_blob_castf2i(HRABBITVM v) static int64_t _g_blob_castf2i(HRABBITVM v)
{ {
SQFloat f; float_t f;
sq_getfloat(v,2,&f); sq_getfloat(v,2,&f);
sq_pushinteger(v,*((const SQInteger *)&f)); sq_pushinteger(v,*((const int64_t *)&f));
return 1; return 1;
} }
static SQInteger _g_blob_swap2(HRABBITVM v) static int64_t _g_blob_swap2(HRABBITVM v)
{ {
SQInteger i; int64_t i;
sq_getinteger(v,2,&i); sq_getinteger(v,2,&i);
short s=(short)i; short s=(short)i;
sq_pushinteger(v,(s<<8)|((s>>8)&0x00FF)); sq_pushinteger(v,(s<<8)|((s>>8)&0x00FF));
return 1; return 1;
} }
static SQInteger _g_blob_swap4(HRABBITVM v) static int64_t _g_blob_swap4(HRABBITVM v)
{ {
SQInteger i; int64_t i;
sq_getinteger(v,2,&i); sq_getinteger(v,2,&i);
unsigned int t4 = (unsigned int)i; unsigned int t4 = (unsigned int)i;
__swap_dword(&t4); __swap_dword(&t4);
sq_pushinteger(v,(SQInteger)t4); sq_pushinteger(v,(int64_t)t4);
return 1; return 1;
} }
static SQInteger _g_blob_swapfloat(HRABBITVM v) static int64_t _g_blob_swapfloat(HRABBITVM v)
{ {
SQFloat f; float_t f;
sq_getfloat(v,2,&f); sq_getfloat(v,2,&f);
__swap_dword((unsigned int *)&f); __swap_dword((unsigned int *)&f);
sq_pushfloat(v,f); sq_pushfloat(v,f);
@ -239,7 +239,7 @@ static const SQRegFunction bloblib_funcs[]={
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
SQRESULT sqstd_getblob(HRABBITVM v,SQInteger idx,SQUserPointer *ptr) SQRESULT sqstd_getblob(HRABBITVM v,int64_t 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(HRABBITVM v,SQInteger idx,SQUserPointer *ptr)
return SQ_OK; return SQ_OK;
} }
SQInteger sqstd_getblobsize(HRABBITVM v,SQInteger idx) int64_t sqstd_getblobsize(HRABBITVM v,int64_t idx)
{ {
SQBlob *blob; SQBlob *blob;
if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG)))
@ -256,9 +256,9 @@ SQInteger sqstd_getblobsize(HRABBITVM v,SQInteger idx)
return blob->Len(); return blob->Len();
} }
SQUserPointer sqstd_createblob(HRABBITVM v, SQInteger size) SQUserPointer sqstd_createblob(HRABBITVM v, int64_t size)
{ {
SQInteger top = sq_gettop(v); int64_t top = sq_gettop(v);
sq_pushregistrytable(v); sq_pushregistrytable(v);
sq_pushstring(v,_SC("std_blob"),-1); sq_pushstring(v,_SC("std_blob"),-1);
if(SQ_SUCCEEDED(sq_get(v,-2))) { if(SQ_SUCCEEDED(sq_get(v,-2))) {

6
rabbit-std/sqstdblob.hpp
View File

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

28
rabbit-std/sqstdblobimpl.hpp
View File

@ -9,7 +9,7 @@
struct SQBlob : public SQStream struct SQBlob : public SQStream
{ {
SQBlob(SQInteger size) { SQBlob(int64_t size) {
_size = size; _size = size;
_allocated = size; _allocated = size;
_buf = (unsigned char *)sq_malloc(size); _buf = (unsigned char *)sq_malloc(size);
@ -20,7 +20,7 @@ struct SQBlob : public SQStream
virtual ~SQBlob() { virtual ~SQBlob() {
sq_free(_buf, _allocated); sq_free(_buf, _allocated);
} }
SQInteger Write(void *buffer, SQInteger size) { int64_t Write(void *buffer, int64_t size) {
if(!CanAdvance(size)) { if(!CanAdvance(size)) {
GrowBufOf(_ptr + size - _size); GrowBufOf(_ptr + size - _size);
} }
@ -28,8 +28,8 @@ struct SQBlob : public SQStream
_ptr += size; _ptr += size;
return size; return size;
} }
SQInteger Read(void *buffer,SQInteger size) { int64_t Read(void *buffer,int64_t size) {
SQInteger n = size; int64_t n = size;
if(!CanAdvance(size)) { if(!CanAdvance(size)) {
if((_size - _ptr) > 0) if((_size - _ptr) > 0)
n = _size - _ptr; n = _size - _ptr;
@ -39,7 +39,7 @@ struct SQBlob : public SQStream
_ptr += n; _ptr += n;
return n; return n;
} }
bool Resize(SQInteger n) { bool Resize(int64_t n) {
if(!_owns) return false; if(!_owns) return false;
if(n != _allocated) { if(n != _allocated) {
unsigned char *newbuf = (unsigned char *)sq_malloc(n); unsigned char *newbuf = (unsigned char *)sq_malloc(n);
@ -58,7 +58,7 @@ struct SQBlob : public SQStream
} }
return true; return true;
} }
bool GrowBufOf(SQInteger n) bool GrowBufOf(int64_t n)
{ {
bool ret = true; bool ret = true;
if(_size + n > _allocated) { if(_size + n > _allocated) {
@ -70,11 +70,11 @@ struct SQBlob : public SQStream
_size = _size + n; _size = _size + n;
return ret; return ret;
} }
bool CanAdvance(SQInteger n) { bool CanAdvance(int64_t n) {
if(_ptr+n>_size)return false; if(_ptr+n>_size)return false;
return true; return true;
} }
SQInteger Seek(SQInteger offset, SQInteger origin) { int64_t Seek(int64_t offset, int64_t origin) {
switch(origin) { switch(origin) {
case SQ_SEEK_SET: case SQ_SEEK_SET:
if(offset > _size || offset < 0) return -1; if(offset > _size || offset < 0) return -1;
@ -98,14 +98,14 @@ struct SQBlob : public SQStream
bool EOS() { bool EOS() {
return _ptr == _size; return _ptr == _size;
} }
SQInteger Flush() { return 0; } int64_t Flush() { return 0; }
SQInteger Tell() { return _ptr; } int64_t Tell() { return _ptr; }
SQInteger Len() { return _size; } int64_t Len() { return _size; }
SQUserPointer GetBuf(){ return _buf; } SQUserPointer GetBuf(){ return _buf; }
private: private:
SQInteger _size; int64_t _size;
SQInteger _allocated; int64_t _allocated;
SQInteger _ptr; int64_t _ptr;
unsigned char *_buf; unsigned char *_buf;
bool _owns; bool _owns;
}; };

104
rabbit-std/sqstdio.cpp
View File

@ -12,7 +12,7 @@
#include <rabbit-std/sqstdio.hpp> #include <rabbit-std/sqstdio.hpp>
#include <rabbit-std/sqstdstream.hpp> #include <rabbit-std/sqstdstream.hpp>
#define SQSTD_FILE_TYPE_TAG ((SQUnsignedInteger)(SQSTD_STREAM_TYPE_TAG | 0x00000001)) #define SQSTD_FILE_TYPE_TAG ((uint64_t)(SQSTD_STREAM_TYPE_TAG | 0x00000001))
//basic API //basic API
SQFILE sqstd_fopen(const SQChar *filename ,const SQChar *mode) SQFILE sqstd_fopen(const SQChar *filename ,const SQChar *mode)
{ {
@ -23,20 +23,20 @@ SQFILE sqstd_fopen(const SQChar *filename ,const SQChar *mode)
#endif #endif
} }
SQInteger sqstd_fread(void* buffer, SQInteger size, SQInteger count, SQFILE file) int64_t sqstd_fread(void* buffer, int64_t size, int64_t count, SQFILE file)
{ {
SQInteger ret = (SQInteger)fread(buffer,size,count,(FILE *)file); int64_t ret = (int64_t)fread(buffer,size,count,(FILE *)file);
return ret; return ret;
} }
SQInteger sqstd_fwrite(const SQUserPointer buffer, SQInteger size, SQInteger count, SQFILE file) int64_t sqstd_fwrite(const SQUserPointer buffer, int64_t size, int64_t count, SQFILE file)
{ {
return (SQInteger)fwrite(buffer,size,count,(FILE *)file); return (int64_t)fwrite(buffer,size,count,(FILE *)file);
} }
SQInteger sqstd_fseek(SQFILE file, SQInteger offset, SQInteger origin) int64_t sqstd_fseek(SQFILE file, int64_t offset, int64_t origin)
{ {
SQInteger realorigin; int64_t realorigin;
switch(origin) { switch(origin) {
case SQ_SEEK_CUR: realorigin = SEEK_CUR; break; case SQ_SEEK_CUR: realorigin = SEEK_CUR; break;
case SQ_SEEK_END: realorigin = SEEK_END; break; case SQ_SEEK_END: realorigin = SEEK_END; break;
@ -46,22 +46,22 @@ SQInteger sqstd_fseek(SQFILE file, SQInteger offset, SQInteger origin)
return fseek((FILE *)file,(long)offset,(int)realorigin); return fseek((FILE *)file,(long)offset,(int)realorigin);
} }
SQInteger sqstd_ftell(SQFILE file) int64_t sqstd_ftell(SQFILE file)
{ {
return ftell((FILE *)file); return ftell((FILE *)file);
} }
SQInteger sqstd_fflush(SQFILE file) int64_t sqstd_fflush(SQFILE file)
{ {
return fflush((FILE *)file); return fflush((FILE *)file);
} }
SQInteger sqstd_fclose(SQFILE file) int64_t sqstd_fclose(SQFILE file)
{ {
return fclose((FILE *)file); return fclose((FILE *)file);
} }
SQInteger sqstd_feof(SQFILE file) int64_t sqstd_feof(SQFILE file)
{ {
return feof((FILE *)file); return feof((FILE *)file);
} }
@ -86,26 +86,26 @@ struct SQFile : public SQStream {
_owns = false; _owns = false;
} }
} }
SQInteger Read(void *buffer,SQInteger size) { int64_t Read(void *buffer,int64_t size) {
return sqstd_fread(buffer,1,size,_handle); return sqstd_fread(buffer,1,size,_handle);
} }
SQInteger Write(void *buffer,SQInteger size) { int64_t Write(void *buffer,int64_t size) {
return sqstd_fwrite(buffer,1,size,_handle); return sqstd_fwrite(buffer,1,size,_handle);
} }
SQInteger Flush() { int64_t Flush() {
return sqstd_fflush(_handle); return sqstd_fflush(_handle);
} }
SQInteger Tell() { int64_t Tell() {
return sqstd_ftell(_handle); return sqstd_ftell(_handle);
} }
SQInteger Len() { int64_t Len() {
SQInteger prevpos=Tell(); int64_t prevpos=Tell();
Seek(0,SQ_SEEK_END); Seek(0,SQ_SEEK_END);
SQInteger size=Tell(); int64_t size=Tell();
Seek(prevpos,SQ_SEEK_SET); Seek(prevpos,SQ_SEEK_SET);
return size; return size;
} }
SQInteger Seek(SQInteger offset, SQInteger origin) { int64_t Seek(int64_t offset, int64_t origin) {
return sqstd_fseek(_handle,offset,origin); return sqstd_fseek(_handle,offset,origin);
} }
bool IsValid() { return _handle?true:false; } bool IsValid() { return _handle?true:false; }
@ -116,13 +116,13 @@ private:
bool _owns; bool _owns;
}; };
static SQInteger _file__typeof(HRABBITVM v) static int64_t _file__typeof(HRABBITVM v)
{ {
sq_pushstring(v,_SC("file"),-1); sq_pushstring(v,_SC("file"),-1);
return 1; return 1;
} }
static SQInteger _file_releasehook(SQUserPointer p, SQInteger SQ_UNUSED_ARG(size)) static int64_t _file_releasehook(SQUserPointer p, int64_t SQ_UNUSED_ARG(size))
{ {
SQFile *self = (SQFile*)p; SQFile *self = (SQFile*)p;
self->~SQFile(); self->~SQFile();
@ -130,7 +130,7 @@ static SQInteger _file_releasehook(SQUserPointer p, SQInteger SQ_UNUSED_ARG(size
return 1; return 1;
} }
static SQInteger _file_constructor(HRABBITVM v) static int64_t _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(HRABBITVM v)
return 0; return 0;
} }
static SQInteger _file_close(HRABBITVM v) static int64_t _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))
@ -182,7 +182,7 @@ static const SQRegFunction _file_methods[] = {
SQRESULT sqstd_createfile(HRABBITVM v, SQFILE file,SQBool own) SQRESULT sqstd_createfile(HRABBITVM v, SQFILE file,SQBool own)
{ {
SQInteger top = sq_gettop(v); int64_t top = sq_gettop(v);
sq_pushregistrytable(v); sq_pushregistrytable(v);
sq_pushstring(v,_SC("std_file"),-1); sq_pushstring(v,_SC("std_file"),-1);
if(SQ_SUCCEEDED(sq_get(v,-2))) { if(SQ_SUCCEEDED(sq_get(v,-2))) {
@ -204,7 +204,7 @@ SQRESULT sqstd_createfile(HRABBITVM v, SQFILE file,SQBool own)
return SQ_ERROR; return SQ_ERROR;
} }
SQRESULT sqstd_getfile(HRABBITVM v, SQInteger idx, SQFILE *file) SQRESULT sqstd_getfile(HRABBITVM v, int64_t idx, SQFILE *file)
{ {
SQFile *fileobj = NULL; SQFile *fileobj = NULL;
if(SQ_SUCCEEDED(sq_getinstanceup(v,idx,(SQUserPointer*)&fileobj,(SQUserPointer)SQSTD_FILE_TYPE_TAG))) { if(SQ_SUCCEEDED(sq_getinstanceup(v,idx,(SQUserPointer*)&fileobj,(SQUserPointer)SQSTD_FILE_TYPE_TAG))) {
@ -219,23 +219,23 @@ SQRESULT sqstd_getfile(HRABBITVM v, SQInteger idx, SQFILE *file)
#define IO_BUFFER_SIZE 2048 #define IO_BUFFER_SIZE 2048
struct IOBuffer { struct IOBuffer {
unsigned char buffer[IO_BUFFER_SIZE]; unsigned char buffer[IO_BUFFER_SIZE];
SQInteger size; int64_t size;
SQInteger ptr; int64_t ptr;
SQFILE file; SQFILE file;
}; };
SQInteger _read_byte(IOBuffer *iobuffer) int64_t _read_byte(IOBuffer *iobuffer)
{ {
if(iobuffer->ptr < iobuffer->size) { if(iobuffer->ptr < iobuffer->size) {
SQInteger ret = iobuffer->buffer[iobuffer->ptr]; int64_t ret = iobuffer->buffer[iobuffer->ptr];
iobuffer->ptr++; iobuffer->ptr++;
return ret; return ret;
} }
else { else {
if( (iobuffer->size = sqstd_fread(iobuffer->buffer,1,IO_BUFFER_SIZE,iobuffer->file )) > 0 ) if( (iobuffer->size = sqstd_fread(iobuffer->buffer,1,IO_BUFFER_SIZE,iobuffer->file )) > 0 )
{ {
SQInteger ret = iobuffer->buffer[0]; int64_t ret = iobuffer->buffer[0];
iobuffer->ptr = 1; iobuffer->ptr = 1;
return ret; return ret;
} }
@ -244,11 +244,11 @@ SQInteger _read_byte(IOBuffer *iobuffer)
return 0; return 0;
} }
SQInteger _read_two_bytes(IOBuffer *iobuffer) int64_t _read_two_bytes(IOBuffer *iobuffer)
{ {
if(iobuffer->ptr < iobuffer->size) { if(iobuffer->ptr < iobuffer->size) {
if(iobuffer->size < 2) return 0; if(iobuffer->size < 2) return 0;
SQInteger ret = *((const wchar_t*)&iobuffer->buffer[iobuffer->ptr]); int64_t ret = *((const wchar_t*)&iobuffer->buffer[iobuffer->ptr]);
iobuffer->ptr += 2; iobuffer->ptr += 2;
return ret; return ret;
} }
@ -256,7 +256,7 @@ SQInteger _read_two_bytes(IOBuffer *iobuffer)
if( (iobuffer->size = sqstd_fread(iobuffer->buffer,1,IO_BUFFER_SIZE,iobuffer->file )) > 0 ) if( (iobuffer->size = sqstd_fread(iobuffer->buffer,1,IO_BUFFER_SIZE,iobuffer->file )) > 0 )
{ {
if(iobuffer->size < 2) return 0; if(iobuffer->size < 2) return 0;
SQInteger ret = *((const wchar_t*)&iobuffer->buffer[0]); int64_t ret = *((const wchar_t*)&iobuffer->buffer[0]);
iobuffer->ptr = 2; iobuffer->ptr = 2;
return ret; return ret;
} }
@ -265,7 +265,7 @@ SQInteger _read_two_bytes(IOBuffer *iobuffer)
return 0; return 0;
} }
static SQInteger _io_file_lexfeed_PLAIN(SQUserPointer iobuf) static int64_t _io_file_lexfeed_PLAIN(SQUserPointer iobuf)
{ {
IOBuffer *iobuffer = (IOBuffer *)iobuf; IOBuffer *iobuffer = (IOBuffer *)iobuf;
return _read_byte(iobuffer); return _read_byte(iobuffer);
@ -273,14 +273,14 @@ static SQInteger _io_file_lexfeed_PLAIN(SQUserPointer iobuf)
} }
#ifdef SQUNICODE #ifdef SQUNICODE
static SQInteger _io_file_lexfeed_UTF8(SQUserPointer iobuf) static int64_t _io_file_lexfeed_UTF8(SQUserPointer iobuf)
{ {
IOBuffer *iobuffer = (IOBuffer *)iobuf; IOBuffer *iobuffer = (IOBuffer *)iobuf;
#define READ(iobuf) \ #define READ(iobuf) \
if((inchar = (unsigned char)_read_byte(iobuf)) == 0) \ if((inchar = (unsigned char)_read_byte(iobuf)) == 0) \
return 0; return 0;
static const SQInteger utf8_lengths[16] = static const int64_t utf8_lengths[16] =
{ {
1,1,1,1,1,1,1,1, /* 0000 to 0111 : 1 byte (plain ASCII) */ 1,1,1,1,1,1,1,1, /* 0000 to 0111 : 1 byte (plain ASCII) */
0,0,0,0, /* 1000 to 1011 : not valid */ 0,0,0,0, /* 1000 to 1011 : not valid */
@ -290,18 +290,18 @@ static SQInteger _io_file_lexfeed_UTF8(SQUserPointer iobuf)
}; };
static const unsigned char byte_masks[5] = {0,0,0x1f,0x0f,0x07}; static const unsigned char byte_masks[5] = {0,0,0x1f,0x0f,0x07};
unsigned char inchar; unsigned char inchar;
SQInteger c = 0; int64_t c = 0;
READ(iobuffer); READ(iobuffer);
c = inchar; c = inchar;
// //
if(c >= 0x80) { if(c >= 0x80) {
SQInteger tmp; int64_t tmp;
SQInteger codelen = utf8_lengths[c>>4]; int64_t codelen = utf8_lengths[c>>4];
if(codelen == 0) if(codelen == 0)
return 0; return 0;
//"invalid UTF-8 stream"; //"invalid UTF-8 stream";
tmp = c&byte_masks[codelen]; tmp = c&byte_masks[codelen];
for(SQInteger n = 0; n < codelen-1; n++) { for(int64_t n = 0; n < codelen-1; n++) {
tmp<<=6; tmp<<=6;
READ(iobuffer); READ(iobuffer);
tmp |= inchar & 0x3F; tmp |= inchar & 0x3F;
@ -312,18 +312,18 @@ static SQInteger _io_file_lexfeed_UTF8(SQUserPointer iobuf)
} }
#endif #endif
static SQInteger _io_file_lexfeed_UCS2_LE(SQUserPointer iobuf) static int64_t _io_file_lexfeed_UCS2_LE(SQUserPointer iobuf)
{ {
SQInteger ret; int64_t ret;
IOBuffer *iobuffer = (IOBuffer *)iobuf; IOBuffer *iobuffer = (IOBuffer *)iobuf;
if( (ret = _read_two_bytes(iobuffer)) > 0 ) if( (ret = _read_two_bytes(iobuffer)) > 0 )
return ret; return ret;
return 0; return 0;
} }
static SQInteger _io_file_lexfeed_UCS2_BE(SQUserPointer iobuf) static int64_t _io_file_lexfeed_UCS2_BE(SQUserPointer iobuf)
{ {
SQInteger c; int64_t c;
IOBuffer *iobuffer = (IOBuffer *)iobuf; IOBuffer *iobuffer = (IOBuffer *)iobuf;
if( (c = _read_two_bytes(iobuffer)) > 0 ) { if( (c = _read_two_bytes(iobuffer)) > 0 ) {
c = ((c>>8)&0x00FF)| ((c<<8)&0xFF00); c = ((c>>8)&0x00FF)| ((c<<8)&0xFF00);
@ -332,14 +332,14 @@ static SQInteger _io_file_lexfeed_UCS2_BE(SQUserPointer iobuf)
return 0; return 0;
} }
SQInteger file_read(SQUserPointer file,SQUserPointer buf,SQInteger size) int64_t file_read(SQUserPointer file,SQUserPointer buf,int64_t size)
{ {
SQInteger ret; int64_t ret;
if( ( ret = sqstd_fread(buf,1,size,(SQFILE)file ))!=0 )return ret; if( ( ret = sqstd_fread(buf,1,size,(SQFILE)file ))!=0 )return ret;
return -1; return -1;
} }
SQInteger file_write(SQUserPointer file,SQUserPointer p,SQInteger size) int64_t file_write(SQUserPointer file,SQUserPointer p,int64_t size)
{ {
return sqstd_fwrite(p,1,size,(SQFILE)file); return sqstd_fwrite(p,1,size,(SQFILE)file);
} }
@ -348,7 +348,7 @@ SQRESULT sqstd_loadfile(HRABBITVM v,const SQChar *filename,SQBool printerror)
{ {
SQFILE file = sqstd_fopen(filename,_SC("rb")); SQFILE file = sqstd_fopen(filename,_SC("rb"));
SQInteger ret; int64_t ret;
unsigned short us; unsigned short us;
unsigned char uc; unsigned char uc;
SQLEXREADFUNC func = _io_file_lexfeed_PLAIN; SQLEXREADFUNC func = _io_file_lexfeed_PLAIN;
@ -433,7 +433,7 @@ SQRESULT sqstd_writeclosuretofile(HRABBITVM v,const SQChar *filename)
return SQ_ERROR; //forward the error return SQ_ERROR; //forward the error
} }
SQInteger _g_io_loadfile(HRABBITVM v) int64_t _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(HRABBITVM v)
return SQ_ERROR; //propagates the error return SQ_ERROR; //propagates the error
} }
SQInteger _g_io_writeclosuretofile(HRABBITVM v) int64_t _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(HRABBITVM v)
return SQ_ERROR; //propagates the error return SQ_ERROR; //propagates the error
} }
SQInteger _g_io_dofile(HRABBITVM v) int64_t _g_io_dofile(HRABBITVM v)
{ {
const SQChar *filename; const SQChar *filename;
SQBool printerror = SQFalse; SQBool printerror = SQFalse;
@ -479,7 +479,7 @@ static const SQRegFunction iolib_funcs[]={
SQRESULT sqstd_register_iolib(HRABBITVM v) SQRESULT sqstd_register_iolib(HRABBITVM v)
{ {
SQInteger top = sq_gettop(v); int64_t top = sq_gettop(v);
//create delegate //create delegate
declare_stream(v,_SC("file"),(SQUserPointer)SQSTD_FILE_TYPE_TAG,_SC("std_file"),_file_methods,iolib_funcs); declare_stream(v,_SC("file"),(SQUserPointer)SQSTD_FILE_TYPE_TAG,_SC("std_file"),_file_methods,iolib_funcs);
sq_pushstring(v,_SC("stdout"),-1); sq_pushstring(v,_SC("stdout"),-1);

28
rabbit-std/sqstdio.hpp
View File

@ -11,12 +11,12 @@
struct SQStream { struct SQStream {
virtual ~SQStream() {} virtual ~SQStream() {}
virtual SQInteger Read(void *buffer, SQInteger size) = 0; virtual int64_t Read(void *buffer, int64_t size) = 0;
virtual SQInteger Write(void *buffer, SQInteger size) = 0; virtual int64_t Write(void *buffer, int64_t size) = 0;
virtual SQInteger Flush() = 0; virtual int64_t Flush() = 0;
virtual SQInteger Tell() = 0; virtual int64_t Tell() = 0;
virtual SQInteger Len() = 0; virtual int64_t Len() = 0;
virtual SQInteger Seek(SQInteger offset, SQInteger origin) = 0; virtual int64_t Seek(int64_t offset, int64_t origin) = 0;
virtual bool IsValid() = 0; virtual bool IsValid() = 0;
virtual bool EOS() = 0; virtual bool EOS() = 0;
}; };
@ -28,16 +28,16 @@ struct SQStream {
typedef void* SQFILE; typedef void* SQFILE;
RABBIT_API SQFILE sqstd_fopen(const SQChar *,const SQChar *); RABBIT_API SQFILE sqstd_fopen(const SQChar *,const SQChar *);
RABBIT_API SQInteger sqstd_fread(SQUserPointer, SQInteger, SQInteger, SQFILE); RABBIT_API int64_t sqstd_fread(SQUserPointer, int64_t, int64_t, SQFILE);
RABBIT_API SQInteger sqstd_fwrite(const SQUserPointer, SQInteger, SQInteger, SQFILE); RABBIT_API int64_t sqstd_fwrite(const SQUserPointer, int64_t, int64_t, SQFILE);
RABBIT_API SQInteger sqstd_fseek(SQFILE , SQInteger , SQInteger); RABBIT_API int64_t sqstd_fseek(SQFILE , int64_t , int64_t);
RABBIT_API SQInteger sqstd_ftell(SQFILE); RABBIT_API int64_t sqstd_ftell(SQFILE);
RABBIT_API SQInteger sqstd_fflush(SQFILE); RABBIT_API int64_t sqstd_fflush(SQFILE);
RABBIT_API SQInteger sqstd_fclose(SQFILE); RABBIT_API int64_t sqstd_fclose(SQFILE);
RABBIT_API SQInteger sqstd_feof(SQFILE); RABBIT_API int64_t sqstd_feof(SQFILE);
RABBIT_API SQRESULT sqstd_createfile(HRABBITVM v, SQFILE file,SQBool own); RABBIT_API SQRESULT sqstd_createfile(HRABBITVM v, SQFILE file,SQBool own);
RABBIT_API SQRESULT sqstd_getfile(HRABBITVM v, SQInteger idx, SQFILE *file); RABBIT_API SQRESULT sqstd_getfile(HRABBITVM v, int64_t idx, SQFILE *file);
//compiler helpers //compiler helpers
RABBIT_API SQRESULT sqstd_loadfile(HRABBITVM v,const SQChar *filename,SQBool printerror); RABBIT_API SQRESULT sqstd_loadfile(HRABBITVM v,const SQChar *filename,SQBool printerror);

28
rabbit-std/sqstdmath.cpp
View File

@ -11,41 +11,41 @@
#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(HRABBITVM v){ \ #define SINGLE_ARG_FUNC(_funcname) static int64_t math_##_funcname(HRABBITVM v){ \
SQFloat f; \ float_t f; \
sq_getfloat(v,2,&f); \ sq_getfloat(v,2,&f); \
sq_pushfloat(v,(SQFloat)_funcname(f)); \ sq_pushfloat(v,(float_t)_funcname(f)); \
return 1; \ return 1; \
} }
#define TWO_ARGS_FUNC(_funcname) static SQInteger math_##_funcname(HRABBITVM v){ \ #define TWO_ARGS_FUNC(_funcname) static int64_t math_##_funcname(HRABBITVM v){ \
SQFloat p1,p2; \ float_t p1,p2; \
sq_getfloat(v,2,&p1); \ sq_getfloat(v,2,&p1); \
sq_getfloat(v,3,&p2); \ sq_getfloat(v,3,&p2); \
sq_pushfloat(v,(SQFloat)_funcname(p1,p2)); \ sq_pushfloat(v,(float_t)_funcname(p1,p2)); \
return 1; \ return 1; \
} }
static SQInteger math_srand(HRABBITVM v) static int64_t math_srand(HRABBITVM v)
{ {
SQInteger i; int64_t i;
if(SQ_FAILED(sq_getinteger(v,2,&i))) if(SQ_FAILED(sq_getinteger(v,2,&i)))
return sq_throwerror(v,_SC("invalid param")); return sq_throwerror(v,_SC("invalid param"));
srand((unsigned int)i); srand((unsigned int)i);
return 0; return 0;
} }
static SQInteger math_rand(HRABBITVM v) static int64_t math_rand(HRABBITVM v)
{ {
sq_pushinteger(v,rand()); sq_pushinteger(v,rand());
return 1; return 1;
} }
static SQInteger math_abs(HRABBITVM v) static int64_t math_abs(HRABBITVM v)
{ {
SQInteger n; int64_t n;
sq_getinteger(v,2,&n); sq_getinteger(v,2,&n);
sq_pushinteger(v,(SQInteger)abs((int)n)); sq_pushinteger(v,(int64_t)abs((int)n));
return 1; return 1;
} }
@ -95,7 +95,7 @@ static const SQRegFunction mathlib_funcs[] = {
SQRESULT sqstd_register_mathlib(HRABBITVM v) SQRESULT sqstd_register_mathlib(HRABBITVM v)
{ {
SQInteger i=0; int64_t i=0;
while(mathlib_funcs[i].name!=0) { while(mathlib_funcs[i].name!=0) {
sq_pushstring(v,mathlib_funcs[i].name,-1); sq_pushstring(v,mathlib_funcs[i].name,-1);
sq_newclosure(v,mathlib_funcs[i].f,0); sq_newclosure(v,mathlib_funcs[i].f,0);
@ -108,7 +108,7 @@ SQRESULT sqstd_register_mathlib(HRABBITVM v)
sq_pushinteger(v,RAND_MAX); sq_pushinteger(v,RAND_MAX);
sq_newslot(v,-3,SQFalse); sq_newslot(v,-3,SQFalse);
sq_pushstring(v,_SC("PI"),-1); sq_pushstring(v,_SC("PI"),-1);
sq_pushfloat(v,(SQFloat)M_PI); sq_pushfloat(v,(float_t)M_PI);
sq_newslot(v,-3,SQFalse); sq_newslot(v,-3,SQFalse);
return SQ_OK; return SQ_OK;
} }

110
rabbit-std/sqstdrex.cpp
View File

@ -54,30 +54,30 @@ typedef int SQRexNodeType;
typedef struct tagSQRexNode{ typedef struct tagSQRexNode{
SQRexNodeType type; SQRexNodeType type;
SQInteger left; int64_t left;
SQInteger right; int64_t right;
SQInteger next; int64_t next;
}SQRexNode; }SQRexNode;
struct SQRex{ struct SQRex{
const SQChar *_eol; const SQChar *_eol;
const SQChar *_bol; const SQChar *_bol;
const SQChar *_p; const SQChar *_p;
SQInteger _first; int64_t _first;
SQInteger _op; int64_t _op;
SQRexNode *_nodes; SQRexNode *_nodes;
SQInteger _nallocated; int64_t _nallocated;
SQInteger _nsize; int64_t _nsize;
SQInteger _nsubexpr; int64_t _nsubexpr;
SQRexMatch *_matches; SQRexMatch *_matches;
SQInteger _currsubexp; int64_t _currsubexp;
void *_jmpbuf; void *_jmpbuf;
const SQChar **_error; const SQChar **_error;
}; };
static SQInteger sqstd_rex_list(SQRex *exp); static int64_t sqstd_rex_list(SQRex *exp);
static SQInteger sqstd_rex_newnode(SQRex *exp, SQRexNodeType type) static int64_t sqstd_rex_newnode(SQRex *exp, SQRexNodeType type)
{ {
SQRexNode n; SQRexNode n;
n.type = type; n.type = type;
@ -85,13 +85,13 @@ static SQInteger sqstd_rex_newnode(SQRex *exp, SQRexNodeType type)
if(type == OP_EXPR) if(type == OP_EXPR)
n.right = exp->_nsubexpr++; n.right = exp->_nsubexpr++;
if(exp->_nallocated < (exp->_nsize + 1)) { if(exp->_nallocated < (exp->_nsize + 1)) {
SQInteger oldsize = exp->_nallocated; int64_t oldsize = exp->_nallocated;
exp->_nallocated *= 2; exp->_nallocated *= 2;
exp->_nodes = (SQRexNode *)sq_realloc(exp->_nodes, oldsize * sizeof(SQRexNode) ,exp->_nallocated * sizeof(SQRexNode)); exp->_nodes = (SQRexNode *)sq_realloc(exp->_nodes, oldsize * sizeof(SQRexNode) ,exp->_nallocated * sizeof(SQRexNode));
} }
exp->_nodes[exp->_nsize++] = n; exp->_nodes[exp->_nsize++] = n;
SQInteger newid = exp->_nsize - 1; int64_t newid = exp->_nsize - 1;
return (SQInteger)newid; return (int64_t)newid;
} }
static void sqstd_rex_error(SQRex *exp,const SQChar *error) static void sqstd_rex_error(SQRex *exp,const SQChar *error)
@ -100,7 +100,7 @@ static void sqstd_rex_error(SQRex *exp,const SQChar *error)
longjmp(*((jmp_buf*)exp->_jmpbuf),-1); longjmp(*((jmp_buf*)exp->_jmpbuf),-1);
} }
static void sqstd_rex_expect(SQRex *exp, SQInteger n){ static void sqstd_rex_expect(SQRex *exp, int64_t n){
if((*exp->_p) != n) if((*exp->_p) != n)
sqstd_rex_error(exp, _SC("expected paren")); sqstd_rex_error(exp, _SC("expected paren"));
exp->_p++; exp->_p++;
@ -122,14 +122,14 @@ static SQChar sqstd_rex_escapechar(SQRex *exp)
return (*exp->_p++); return (*exp->_p++);
} }
static SQInteger sqstd_rex_charclass(SQRex *exp,SQInteger classid) static int64_t sqstd_rex_charclass(SQRex *exp,int64_t classid)
{ {
SQInteger n = sqstd_rex_newnode(exp,OP_CCLASS); int64_t n = sqstd_rex_newnode(exp,OP_CCLASS);
exp->_nodes[n].left = classid; exp->_nodes[n].left = classid;
return n; return n;
} }
static SQInteger sqstd_rex_charnode(SQRex *exp,SQBool isclass) static int64_t sqstd_rex_charnode(SQRex *exp,SQBool isclass)
{ {
SQChar t; SQChar t;
if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR) { if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR) {
@ -155,7 +155,7 @@ static SQInteger sqstd_rex_charnode(SQRex *exp,SQBool isclass)
exp->_p++; //points to the next char to be parsed exp->_p++; //points to the next char to be parsed
if ((!cb) || (!ce)) sqstd_rex_error(exp,_SC("balanced chars expected")); if ((!cb) || (!ce)) sqstd_rex_error(exp,_SC("balanced chars expected"));
if ( cb == ce ) sqstd_rex_error(exp,_SC("open/close char can't be the same")); if ( cb == ce ) sqstd_rex_error(exp,_SC("open/close char can't be the same"));
SQInteger node = sqstd_rex_newnode(exp,OP_MB); int64_t node = sqstd_rex_newnode(exp,OP_MB);
exp->_nodes[node].left = cb; exp->_nodes[node].left = cb;
exp->_nodes[node].right = ce; exp->_nodes[node].right = ce;
return node; return node;
@ -166,7 +166,7 @@ static SQInteger sqstd_rex_charnode(SQRex *exp,SQBool isclass)
case 'b': case 'b':
case 'B': case 'B':
if(!isclass) { if(!isclass) {
SQInteger node = sqstd_rex_newnode(exp,OP_WB); int64_t node = sqstd_rex_newnode(exp,OP_WB);
exp->_nodes[node].left = *exp->_p; exp->_nodes[node].left = *exp->_p;
exp->_p++; exp->_p++;
return node; return node;
@ -183,10 +183,10 @@ static SQInteger sqstd_rex_charnode(SQRex *exp,SQBool isclass)
t = *exp->_p; exp->_p++; t = *exp->_p; exp->_p++;
return sqstd_rex_newnode(exp,t); return sqstd_rex_newnode(exp,t);
} }
static SQInteger sqstd_rex_class(SQRex *exp) static int64_t sqstd_rex_class(SQRex *exp)
{ {
SQInteger ret = -1; int64_t ret = -1;
SQInteger first = -1,chain; int64_t first = -1,chain;
if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING){ if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING){
ret = sqstd_rex_newnode(exp,OP_NCLASS); ret = sqstd_rex_newnode(exp,OP_NCLASS);
exp->_p++; exp->_p++;
@ -196,13 +196,13 @@ static SQInteger sqstd_rex_class(SQRex *exp)
chain = ret; chain = ret;
while(*exp->_p != ']' && exp->_p != exp->_eol) { while(*exp->_p != ']' && exp->_p != exp->_eol) {
if(*exp->_p == '-' && first != -1){ if(*exp->_p == '-' && first != -1){
SQInteger r; int64_t r;
if(*exp->_p++ == ']') sqstd_rex_error(exp,_SC("unfinished range")); if(*exp->_p++ == ']') sqstd_rex_error(exp,_SC("unfinished range"));
r = sqstd_rex_newnode(exp,OP_RANGE); r = sqstd_rex_newnode(exp,OP_RANGE);
if(exp->_nodes[first].type>*exp->_p) sqstd_rex_error(exp,_SC("invalid range")); if(exp->_nodes[first].type>*exp->_p) sqstd_rex_error(exp,_SC("invalid range"));
if(exp->_nodes[first].type == OP_CCLASS) sqstd_rex_error(exp,_SC("cannot use character classes in ranges")); if(exp->_nodes[first].type == OP_CCLASS) sqstd_rex_error(exp,_SC("cannot use character classes in ranges"));
exp->_nodes[r].left = exp->_nodes[first].type; exp->_nodes[r].left = exp->_nodes[first].type;
SQInteger t = sqstd_rex_escapechar(exp); int64_t t = sqstd_rex_escapechar(exp);
exp->_nodes[r].right = t; exp->_nodes[r].right = t;
exp->_nodes[chain].next = r; exp->_nodes[chain].next = r;
chain = r; chain = r;
@ -210,7 +210,7 @@ static SQInteger sqstd_rex_class(SQRex *exp)
} }
else{ else{
if(first!=-1){ if(first!=-1){
SQInteger c = first; int64_t c = first;
exp->_nodes[chain].next = c; exp->_nodes[chain].next = c;
chain = c; chain = c;
first = sqstd_rex_charnode(exp,SQTrue); first = sqstd_rex_charnode(exp,SQTrue);
@ -221,7 +221,7 @@ static SQInteger sqstd_rex_class(SQRex *exp)
} }
} }
if(first!=-1){ if(first!=-1){
SQInteger c = first; int64_t c = first;
exp->_nodes[chain].next = c; exp->_nodes[chain].next = c;
} }
/* hack? */ /* hack? */
@ -230,10 +230,10 @@ static SQInteger sqstd_rex_class(SQRex *exp)
return ret; return ret;
} }
static SQInteger sqstd_rex_parsenumber(SQRex *exp) static int64_t sqstd_rex_parsenumber(SQRex *exp)
{ {
SQInteger ret = *exp->_p-'0'; int64_t ret = *exp->_p-'0';
SQInteger positions = 10; int64_t positions = 10;
exp->_p++; exp->_p++;
while(isdigit(*exp->_p)) { while(isdigit(*exp->_p)) {
ret = ret*10+(*exp->_p++-'0'); ret = ret*10+(*exp->_p++-'0');
@ -243,13 +243,13 @@ static SQInteger sqstd_rex_parsenumber(SQRex *exp)
return ret; return ret;
} }
static SQInteger sqstd_rex_element(SQRex *exp) static int64_t sqstd_rex_element(SQRex *exp)
{ {
SQInteger ret = -1; int64_t ret = -1;
switch(*exp->_p) switch(*exp->_p)
{ {
case '(': { case '(': {
SQInteger expr; int64_t expr;
exp->_p++; exp->_p++;
@ -260,7 +260,7 @@ static SQInteger sqstd_rex_element(SQRex *exp)
} }
else else
expr = sqstd_rex_newnode(exp,OP_EXPR); expr = sqstd_rex_newnode(exp,OP_EXPR);
SQInteger newn = sqstd_rex_list(exp); int64_t newn = sqstd_rex_list(exp);
exp->_nodes[expr].left = newn; exp->_nodes[expr].left = newn;
ret = expr; ret = expr;
sqstd_rex_expect(exp,')'); sqstd_rex_expect(exp,')');
@ -311,23 +311,23 @@ static SQInteger sqstd_rex_element(SQRex *exp)
} }
if(isgreedy) { if(isgreedy) {
SQInteger nnode = sqstd_rex_newnode(exp,OP_GREEDY); int64_t nnode = sqstd_rex_newnode(exp,OP_GREEDY);
exp->_nodes[nnode].left = ret; exp->_nodes[nnode].left = ret;
exp->_nodes[nnode].right = ((p0)<<16)|p1; exp->_nodes[nnode].right = ((p0)<<16)|p1;
ret = nnode; ret = nnode;
} }
if((*exp->_p != SQREX_SYMBOL_BRANCH) && (*exp->_p != ')') && (*exp->_p != SQREX_SYMBOL_GREEDY_ZERO_OR_MORE) && (*exp->_p != SQREX_SYMBOL_GREEDY_ONE_OR_MORE) && (*exp->_p != '\0')) { if((*exp->_p != SQREX_SYMBOL_BRANCH) && (*exp->_p != ')') && (*exp->_p != SQREX_SYMBOL_GREEDY_ZERO_OR_MORE) && (*exp->_p != SQREX_SYMBOL_GREEDY_ONE_OR_MORE) && (*exp->_p != '\0')) {
SQInteger nnode = sqstd_rex_element(exp); int64_t nnode = sqstd_rex_element(exp);
exp->_nodes[ret].next = nnode; exp->_nodes[ret].next = nnode;
} }
return ret; return ret;
} }
static SQInteger sqstd_rex_list(SQRex *exp) static int64_t sqstd_rex_list(SQRex *exp)
{ {
SQInteger ret=-1,e; int64_t ret=-1,e;
if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING) { if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING) {
exp->_p++; exp->_p++;
ret = sqstd_rex_newnode(exp,OP_BOL); ret = sqstd_rex_newnode(exp,OP_BOL);
@ -339,7 +339,7 @@ static SQInteger sqstd_rex_list(SQRex *exp)
else ret = e; else ret = e;
if(*exp->_p == SQREX_SYMBOL_BRANCH) { if(*exp->_p == SQREX_SYMBOL_BRANCH) {
SQInteger temp,tright; int64_t temp,tright;
exp->_p++; exp->_p++;
temp = sqstd_rex_newnode(exp,OP_OR); temp = sqstd_rex_newnode(exp,OP_OR);
exp->_nodes[temp].left = ret; exp->_nodes[temp].left = ret;
@ -350,7 +350,7 @@ static SQInteger sqstd_rex_list(SQRex *exp)
return ret; return ret;
} }
static SQBool sqstd_rex_matchcclass(SQInteger cclass,SQChar c) static SQBool sqstd_rex_matchcclass(int64_t cclass,SQChar c)
{ {
switch(cclass) { switch(cclass) {
case 'a': return isalpha(c)?SQTrue:SQFalse; case 'a': return isalpha(c)?SQTrue:SQFalse;
@ -398,7 +398,7 @@ static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar
case OP_GREEDY: { case OP_GREEDY: {
//SQRexNode *greedystop = (node->next != -1) ? &exp->_nodes[node->next] : NULL; //SQRexNode *greedystop = (node->next != -1) ? &exp->_nodes[node->next] : NULL;
SQRexNode *greedystop = NULL; SQRexNode *greedystop = NULL;
SQInteger p0 = (node->right >> 16)&0x0000FFFF, p1 = node->right&0x0000FFFF, nmaches = 0; int64_t p0 = (node->right >> 16)&0x0000FFFF, p1 = node->right&0x0000FFFF, nmaches = 0;
const SQChar *s=str, *good = str; const SQChar *s=str, *good = str;
if(node->next != -1) { if(node->next != -1) {
@ -469,13 +469,13 @@ static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar
case OP_NOCAPEXPR:{ case OP_NOCAPEXPR:{
SQRexNode *n = &exp->_nodes[node->left]; SQRexNode *n = &exp->_nodes[node->left];
const SQChar *cur = str; const SQChar *cur = str;
SQInteger capture = -1; int64_t capture = -1;
if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) { if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) {
capture = exp->_currsubexp; capture = exp->_currsubexp;
exp->_matches[capture].begin = cur; exp->_matches[capture].begin = cur;
exp->_currsubexp++; exp->_currsubexp++;
} }
SQInteger tempcap = exp->_currsubexp; int64_t tempcap = exp->_currsubexp;
do { do {
SQRexNode *subnext = NULL; SQRexNode *subnext = NULL;
if(n->next != -1) { if(n->next != -1) {
@ -533,10 +533,10 @@ static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar
return NULL; return NULL;
case OP_MB: case OP_MB:
{ {
SQInteger cb = node->left; //char that opens a balanced expression int64_t cb = node->left; //char that opens a balanced expression
if(*str != cb) return NULL; // string doesnt start with open char if(*str != cb) return NULL; // string doesnt start with open char
SQInteger ce = node->right; //char that closes a balanced expression int64_t ce = node->right; //char that closes a balanced expression
SQInteger cont = 1; int64_t cont = 1;
const SQChar *streol = exp->_eol; const SQChar *streol = exp->_eol;
while (++str < streol) { while (++str < streol) {
if (*str == ce) { if (*str == ce) {
@ -563,7 +563,7 @@ SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error)
SQRex * volatile exp = (SQRex *)sq_malloc(sizeof(SQRex)); // "volatile" is needed for setjmp() SQRex * volatile exp = (SQRex *)sq_malloc(sizeof(SQRex)); // "volatile" is needed for setjmp()
exp->_eol = exp->_bol = NULL; exp->_eol = exp->_bol = NULL;
exp->_p = pattern; exp->_p = pattern;
exp->_nallocated = (SQInteger)scstrlen(pattern) * sizeof(SQChar); exp->_nallocated = (int64_t)scstrlen(pattern) * sizeof(SQChar);
exp->_nodes = (SQRexNode *)sq_malloc(exp->_nallocated * sizeof(SQRexNode)); exp->_nodes = (SQRexNode *)sq_malloc(exp->_nallocated * sizeof(SQRexNode));
exp->_nsize = 0; exp->_nsize = 0;
exp->_matches = 0; exp->_matches = 0;
@ -572,23 +572,23 @@ SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error)
exp->_error = error; exp->_error = error;
exp->_jmpbuf = sq_malloc(sizeof(jmp_buf)); exp->_jmpbuf = sq_malloc(sizeof(jmp_buf));
if(setjmp(*((jmp_buf*)exp->_jmpbuf)) == 0) { if(setjmp(*((jmp_buf*)exp->_jmpbuf)) == 0) {
SQInteger res = sqstd_rex_list(exp); int64_t res = sqstd_rex_list(exp);
exp->_nodes[exp->_first].left = res; exp->_nodes[exp->_first].left = res;
if(*exp->_p!='\0') if(*exp->_p!='\0')
sqstd_rex_error(exp,_SC("unexpected character")); sqstd_rex_error(exp,_SC("unexpected character"));
#ifdef _DEBUG #ifdef _DEBUG
{ {
SQInteger nsize,i; int64_t nsize,i;
SQRexNode *t; SQRexNode *t;
nsize = exp->_nsize; nsize = exp->_nsize;
t = &exp->_nodes[0]; t = &exp->_nodes[0];
scprintf(_SC("\n")); scprintf(_SC("\n"));
for(i = 0;i < nsize; i++) { for(i = 0;i < nsize; i++) {
if(exp->_nodes[i].type>MAX_CHAR) if(exp->_nodes[i].type>MAX_CHAR)
scprintf(_SC("[%02d] %10s "), (SQInt32)i,g_nnames[exp->_nodes[i].type-MAX_CHAR]); scprintf(_SC("[%02d] %10s "), (int32_t)i,g_nnames[exp->_nodes[i].type-MAX_CHAR]);
else else
scprintf(_SC("[%02d] %10c "), (SQInt32)i,exp->_nodes[i].type); scprintf(_SC("[%02d] %10c "), (int32_t)i,exp->_nodes[i].type);
scprintf(_SC("left %02d right %02d next %02d\n"), (SQInt32)exp->_nodes[i].left, (SQInt32)exp->_nodes[i].right, (SQInt32)exp->_nodes[i].next); scprintf(_SC("left %02d right %02d next %02d\n"), (int32_t)exp->_nodes[i].left, (int32_t)exp->_nodes[i].right, (int32_t)exp->_nodes[i].next);
} }
scprintf(_SC("\n")); scprintf(_SC("\n"));
} }
@ -628,7 +628,7 @@ SQBool sqstd_rex_match(SQRex* exp,const SQChar* text)
SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const SQChar* text_end,const SQChar** out_begin, const SQChar** out_end) SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const SQChar* text_end,const SQChar** out_begin, const SQChar** out_end)
{ {
const SQChar *cur = NULL; const SQChar *cur = NULL;
SQInteger node = exp->_first; int64_t node = exp->_first;
if(text_begin >= text_end) return SQFalse; if(text_begin >= text_end) return SQFalse;
exp->_bol = text_begin; exp->_bol = text_begin;
exp->_eol = text_end; exp->_eol = text_end;
@ -659,12 +659,12 @@ SQBool sqstd_rex_search(SQRex* exp,const SQChar* text, const SQChar** out_begin,
return sqstd_rex_searchrange(exp,text,text + scstrlen(text),out_begin,out_end); return sqstd_rex_searchrange(exp,text,text + scstrlen(text),out_begin,out_end);
} }
SQInteger sqstd_rex_getsubexpcount(SQRex* exp) int64_t sqstd_rex_getsubexpcount(SQRex* exp)
{ {
return exp->_nsubexpr; return exp->_nsubexpr;
} }
SQBool sqstd_rex_getsubexp(SQRex* exp, SQInteger n, SQRexMatch *subexp) SQBool sqstd_rex_getsubexp(SQRex* exp, int64_t n, SQRexMatch *subexp)
{ {
if( n<0 || n >= exp->_nsubexpr) return SQFalse; if( n<0 || n >= exp->_nsubexpr) return SQFalse;
*subexp = exp->_matches[n]; *subexp = exp->_matches[n];

60
rabbit-std/sqstdstream.cpp
View File

@ -18,16 +18,16 @@
#define SETUP_STREAM(v) \ #define SETUP_STREAM(v) \
SQStream *self = NULL; \ SQStream *self = NULL; \
if(SQ_FAILED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)((SQUnsignedInteger)SQSTD_STREAM_TYPE_TAG)))) \ if(SQ_FAILED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)((uint64_t)SQSTD_STREAM_TYPE_TAG)))) \
return sq_throwerror(v,_SC("invalid type tag")); \ return sq_throwerror(v,_SC("invalid type tag")); \
if(!self || !self->IsValid()) \ if(!self || !self->IsValid()) \
return sq_throwerror(v,_SC("the stream is invalid")); return sq_throwerror(v,_SC("the stream is invalid"));
SQInteger _stream_readblob(HRABBITVM v) int64_t _stream_readblob(HRABBITVM v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
SQUserPointer data,blobp; SQUserPointer data,blobp;
SQInteger size,res; int64_t size,res;
sq_getinteger(v,2,&size); sq_getinteger(v,2,&size);
if(size > self->Len()) { if(size > self->Len()) {
size = self->Len(); size = self->Len();
@ -44,20 +44,20 @@ SQInteger _stream_readblob(HRABBITVM 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(HRABBITVM v) int64_t _stream_readn(HRABBITVM v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
SQInteger format; int64_t format;
sq_getinteger(v, 2, &format); sq_getinteger(v, 2, &format);
switch(format) { switch(format) {
case 'l': { case 'l': {
SQInteger i; int64_t i;
SAFE_READN(&i, sizeof(i)); SAFE_READN(&i, sizeof(i));
sq_pushinteger(v, i); sq_pushinteger(v, i);
} }
break; break;
case 'i': { case 'i': {
SQInt32 i; int32_t i;
SAFE_READN(&i, sizeof(i)); SAFE_READN(&i, sizeof(i));
sq_pushinteger(v, i); sq_pushinteger(v, i);
} }
@ -95,7 +95,7 @@ SQInteger _stream_readn(HRABBITVM v)
case 'd': { case 'd': {
double d; double d;
SAFE_READN(&d, sizeof(double)); SAFE_READN(&d, sizeof(double));
sq_pushfloat(v, (SQFloat)d); sq_pushfloat(v, (float_t)d);
} }
break; break;
default: default:
@ -104,10 +104,10 @@ SQInteger _stream_readn(HRABBITVM v)
return 1; return 1;
} }
SQInteger _stream_writeblob(HRABBITVM v) int64_t _stream_writeblob(HRABBITVM v)
{ {
SQUserPointer data; SQUserPointer data;
SQInteger size; int64_t size;
SETUP_STREAM(v); SETUP_STREAM(v);
if(SQ_FAILED(sqstd_getblob(v,2,&data))) if(SQ_FAILED(sqstd_getblob(v,2,&data)))
return sq_throwerror(v,_SC("invalid parameter")); return sq_throwerror(v,_SC("invalid parameter"));
@ -118,25 +118,25 @@ SQInteger _stream_writeblob(HRABBITVM v)
return 1; return 1;
} }
SQInteger _stream_writen(HRABBITVM v) int64_t _stream_writen(HRABBITVM v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
SQInteger format, ti; int64_t format, ti;
SQFloat tf; float_t tf;
sq_getinteger(v, 3, &format); sq_getinteger(v, 3, &format);
switch(format) { switch(format) {
case 'l': { case 'l': {
SQInteger i; int64_t i;
sq_getinteger(v, 2, &ti); sq_getinteger(v, 2, &ti);
i = ti; i = ti;
self->Write(&i, sizeof(SQInteger)); self->Write(&i, sizeof(int64_t));
} }
break; break;
case 'i': { case 'i': {
SQInt32 i; int32_t i;
sq_getinteger(v, 2, &ti); sq_getinteger(v, 2, &ti);
i = (SQInt32)ti; i = (int32_t)ti;
self->Write(&i, sizeof(SQInt32)); self->Write(&i, sizeof(int32_t));
} }
break; break;
case 's': { case 's': {
@ -187,13 +187,13 @@ SQInteger _stream_writen(HRABBITVM v)
return 0; return 0;
} }
SQInteger _stream_seek(HRABBITVM v) int64_t _stream_seek(HRABBITVM v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
SQInteger offset, origin = SQ_SEEK_SET; int64_t offset, origin = SQ_SEEK_SET;
sq_getinteger(v, 2, &offset); sq_getinteger(v, 2, &offset);
if(sq_gettop(v) > 2) { if(sq_gettop(v) > 2) {
SQInteger t; int64_t t;
sq_getinteger(v, 3, &t); sq_getinteger(v, 3, &t);
switch(t) { switch(t) {
case 'b': origin = SQ_SEEK_SET; break; case 'b': origin = SQ_SEEK_SET; break;
@ -206,21 +206,21 @@ SQInteger _stream_seek(HRABBITVM v)
return 1; return 1;
} }
SQInteger _stream_tell(HRABBITVM v) int64_t _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(HRABBITVM v) int64_t _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(HRABBITVM v) int64_t _stream_flush(HRABBITVM v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
if(!self->Flush()) if(!self->Flush())
@ -230,7 +230,7 @@ SQInteger _stream_flush(HRABBITVM v)
return 1; return 1;
} }
SQInteger _stream_eos(HRABBITVM v) int64_t _stream_eos(HRABBITVM v)
{ {
SETUP_STREAM(v); SETUP_STREAM(v);
if(self->EOS()) if(self->EOS())
@ -240,7 +240,7 @@ SQInteger _stream_eos(HRABBITVM v)
return 1; return 1;
} }
SQInteger _stream__cloned(HRABBITVM v) int64_t _stream__cloned(HRABBITVM v)
{ {
return sq_throwerror(v,_SC("this object cannot be cloned")); return sq_throwerror(v,_SC("this object cannot be cloned"));
} }
@ -266,8 +266,8 @@ void init_streamclass(HRABBITVM v)
if(SQ_FAILED(sq_get(v,-2))) { if(SQ_FAILED(sq_get(v,-2))) {
sq_pushstring(v,_SC("std_stream"),-1); sq_pushstring(v,_SC("std_stream"),-1);
sq_newclass(v,SQFalse); sq_newclass(v,SQFalse);
sq_settypetag(v,-1,(SQUserPointer)((SQUnsignedInteger)SQSTD_STREAM_TYPE_TAG)); sq_settypetag(v,-1,(SQUserPointer)((uint64_t)SQSTD_STREAM_TYPE_TAG));
SQInteger i = 0; int64_t i = 0;
while(_stream_methods[i].name != 0) { while(_stream_methods[i].name != 0) {
const SQRegFunction &f = _stream_methods[i]; const SQRegFunction &f = _stream_methods[i];
sq_pushstring(v,f.name,-1); sq_pushstring(v,f.name,-1);
@ -294,7 +294,7 @@ SQRESULT declare_stream(HRABBITVM v,const SQChar* name,SQUserPointer typetag,con
{ {
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"));
SQInteger top = sq_gettop(v); int64_t top = sq_gettop(v);
//create delegate //create delegate
init_streamclass(v); init_streamclass(v);
sq_pushregistrytable(v); sq_pushregistrytable(v);
@ -303,7 +303,7 @@ SQRESULT declare_stream(HRABBITVM v,const SQChar* name,SQUserPointer typetag,con
if(SQ_SUCCEEDED(sq_get(v,-3))) { if(SQ_SUCCEEDED(sq_get(v,-3))) {
sq_newclass(v,SQTrue); sq_newclass(v,SQTrue);
sq_settypetag(v,-1,typetag); sq_settypetag(v,-1,typetag);
SQInteger i = 0; int64_t i = 0;
while(methods[i].name != 0) { while(methods[i].name != 0) {
const SQRegFunction &f = methods[i]; const SQRegFunction &f = methods[i];
sq_pushstring(v,f.name,-1); sq_pushstring(v,f.name,-1);

20
rabbit-std/sqstdstream.hpp
View File

@ -7,16 +7,16 @@
*/ */
#pragma once #pragma once
SQInteger _stream_readblob(HRABBITVM v); int64_t _stream_readblob(HRABBITVM v);
SQInteger _stream_readline(HRABBITVM v); int64_t _stream_readline(HRABBITVM v);
SQInteger _stream_readn(HRABBITVM v); int64_t _stream_readn(HRABBITVM v);
SQInteger _stream_writeblob(HRABBITVM v); int64_t _stream_writeblob(HRABBITVM v);
SQInteger _stream_writen(HRABBITVM v); int64_t _stream_writen(HRABBITVM v);
SQInteger _stream_seek(HRABBITVM v); int64_t _stream_seek(HRABBITVM v);
SQInteger _stream_tell(HRABBITVM v); int64_t _stream_tell(HRABBITVM v);
SQInteger _stream_len(HRABBITVM v); int64_t _stream_len(HRABBITVM v);
SQInteger _stream_eos(HRABBITVM v); int64_t _stream_eos(HRABBITVM v);
SQInteger _stream_flush(HRABBITVM v); int64_t _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(HRABBITVM 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);

104
rabbit-std/sqstdstring.cpp
View File

@ -26,12 +26,12 @@ static SQBool isfmtchr(SQChar ch)
return SQFalse; return SQFalse;
} }
static SQInteger validate_format(HRABBITVM v, SQChar *fmt, const SQChar *src, SQInteger n,SQInteger &width) static int64_t validate_format(HRABBITVM v, SQChar *fmt, const SQChar *src, int64_t n,int64_t &width)
{ {
SQChar *dummy; SQChar *dummy;
SQChar swidth[MAX_WFORMAT_LEN]; SQChar swidth[MAX_WFORMAT_LEN];
SQInteger wc = 0; int64_t wc = 0;
SQInteger start = n; int64_t start = n;
fmt[0] = '%'; fmt[0] = '%';
while (isfmtchr(src[n])) n++; while (isfmtchr(src[n])) n++;
while (scisdigit(src[n])) { while (scisdigit(src[n])) {
@ -71,7 +71,7 @@ static SQInteger validate_format(HRABBITVM v, SQChar *fmt, const SQChar *src, SQ
return n; return n;
} }
SQRESULT sqstd_format(HRABBITVM v,SQInteger nformatstringidx,SQInteger *outlen,SQChar **output) SQRESULT sqstd_format(HRABBITVM v,int64_t nformatstringidx,int64_t *outlen,SQChar **output)
{ {
const SQChar *format; const SQChar *format;
SQChar *dest; SQChar *dest;
@ -80,10 +80,10 @@ SQRESULT sqstd_format(HRABBITVM v,SQInteger nformatstringidx,SQInteger *outlen,S
if (SQ_FAILED(res)) { if (SQ_FAILED(res)) {
return res; // propagate the error return res; // propagate the error
} }
SQInteger format_size = sq_getsize(v,nformatstringidx); int64_t format_size = sq_getsize(v,nformatstringidx);
SQInteger allocated = (format_size+2)*sizeof(SQChar); int64_t allocated = (format_size+2)*sizeof(SQChar);
dest = sq_getscratchpad(v,allocated); dest = sq_getscratchpad(v,allocated);
SQInteger n = 0,i = 0, nparam = nformatstringidx+1, w = 0; int64_t n = 0,i = 0, nparam = nformatstringidx+1, w = 0;
//while(format[n] != '\0') //while(format[n] != '\0')
while(n < format_size) while(n < format_size)
{ {
@ -102,11 +102,11 @@ SQRESULT sqstd_format(HRABBITVM v,SQInteger nformatstringidx,SQInteger *outlen,S
return sq_throwerror(v,_SC("not enough parameters for the given format string")); return sq_throwerror(v,_SC("not enough parameters for the given format string"));
n = validate_format(v,fmt,format,n,w); n = validate_format(v,fmt,format,n,w);
if(n < 0) return -1; if(n < 0) return -1;
SQInteger addlen = 0; int64_t addlen = 0;
SQInteger valtype = 0; int64_t valtype = 0;
const SQChar *ts = NULL; const SQChar *ts = NULL;
SQInteger ti = 0; int64_t ti = 0;
SQFloat tf = 0; float_t tf = 0;
switch(format[n]) { switch(format[n]) {
case 's': case 's':
if(SQ_FAILED(sq_getstring(v,nparam,&ts))) if(SQ_FAILED(sq_getstring(v,nparam,&ts)))
@ -118,7 +118,7 @@ SQRESULT sqstd_format(HRABBITVM v,SQInteger nformatstringidx,SQInteger *outlen,S
#ifdef _SQ64 #ifdef _SQ64
{ {
size_t flen = scstrlen(fmt); size_t flen = scstrlen(fmt);
SQInteger fpos = flen - 1; int64_t fpos = flen - 1;
SQChar f = fmt[fpos]; SQChar f = fmt[fpos];
const SQChar *prec = (const SQChar *)_PRINT_INT_PREC; const SQChar *prec = (const SQChar *)_PRINT_INT_PREC;
while(*prec != _SC('\0')) { while(*prec != _SC('\0')) {
@ -160,10 +160,10 @@ SQRESULT sqstd_format(HRABBITVM v,SQInteger nformatstringidx,SQInteger *outlen,S
return SQ_OK; return SQ_OK;
} }
static SQInteger _string_printf(HRABBITVM v) static int64_t _string_printf(HRABBITVM v)
{ {
SQChar *dest = NULL; SQChar *dest = NULL;
SQInteger length = 0; int64_t length = 0;
if(SQ_FAILED(sqstd_format(v,2,&length,&dest))) if(SQ_FAILED(sqstd_format(v,2,&length,&dest)))
return -1; return -1;
@ -173,10 +173,10 @@ static SQInteger _string_printf(HRABBITVM v)
return 0; return 0;
} }
static SQInteger _string_format(HRABBITVM v) static int64_t _string_format(HRABBITVM v)
{ {
SQChar *dest = NULL; SQChar *dest = NULL;
SQInteger length = 0; int64_t length = 0;
if(SQ_FAILED(sqstd_format(v,2,&length,&dest))) if(SQ_FAILED(sqstd_format(v,2,&length,&dest)))
return -1; return -1;
sq_pushstring(v,dest,length); sq_pushstring(v,dest,length);
@ -190,7 +190,7 @@ static void __strip_l(const SQChar *str,const SQChar **start)
*start = t; *start = t;
} }
static void __strip_r(const SQChar *str,SQInteger len,const SQChar **end) static void __strip_r(const SQChar *str,int64_t len,const SQChar **end)
{ {
if(len == 0) { if(len == 0) {
*end = str; *end = str;
@ -201,18 +201,18 @@ static void __strip_r(const SQChar *str,SQInteger len,const SQChar **end)
*end = t + 1; *end = t + 1;
} }
static SQInteger _string_strip(HRABBITVM v) static int64_t _string_strip(HRABBITVM v)
{ {
const SQChar *str,*start,*end; const SQChar *str,*start,*end;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
SQInteger len = sq_getsize(v,2); int64_t len = sq_getsize(v,2);
__strip_l(str,&start); __strip_l(str,&start);
__strip_r(str,len,&end); __strip_r(str,len,&end);
sq_pushstring(v,start,end - start); sq_pushstring(v,start,end - start);
return 1; return 1;
} }
static SQInteger _string_lstrip(HRABBITVM v) static int64_t _string_lstrip(HRABBITVM v)
{ {
const SQChar *str,*start; const SQChar *str,*start;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
@ -221,25 +221,25 @@ static SQInteger _string_lstrip(HRABBITVM v)
return 1; return 1;
} }
static SQInteger _string_rstrip(HRABBITVM v) static int64_t _string_rstrip(HRABBITVM v)
{ {
const SQChar *str,*end; const SQChar *str,*end;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
SQInteger len = sq_getsize(v,2); int64_t len = sq_getsize(v,2);
__strip_r(str,len,&end); __strip_r(str,len,&end);
sq_pushstring(v,str,end - str); sq_pushstring(v,str,end - str);
return 1; return 1;
} }
static SQInteger _string_split(HRABBITVM v) static int64_t _string_split(HRABBITVM v)
{ {
const SQChar *str,*seps; const SQChar *str,*seps;
SQChar *stemp; SQChar *stemp;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
sq_getstring(v,3,&seps); sq_getstring(v,3,&seps);
SQInteger sepsize = sq_getsize(v,3); int64_t sepsize = sq_getsize(v,3);
if(sepsize == 0) return sq_throwerror(v,_SC("empty separators string")); if(sepsize == 0) return sq_throwerror(v,_SC("empty separators string"));
SQInteger memsize = (sq_getsize(v,2)+1)*sizeof(SQChar); int64_t memsize = (sq_getsize(v,2)+1)*sizeof(SQChar);
stemp = sq_getscratchpad(v,memsize); stemp = sq_getscratchpad(v,memsize);
memcpy(stemp,str,memsize); memcpy(stemp,str,memsize);
SQChar *start = stemp; SQChar *start = stemp;
@ -248,7 +248,7 @@ static SQInteger _string_split(HRABBITVM v)
while(*end != '\0') while(*end != '\0')
{ {
SQChar cur = *end; SQChar cur = *end;
for(SQInteger i = 0; i < sepsize; i++) for(int64_t i = 0; i < sepsize; i++)
{ {
if(cur == seps[i]) if(cur == seps[i])
{ {
@ -269,11 +269,11 @@ static SQInteger _string_split(HRABBITVM v)
return 1; return 1;
} }
static SQInteger _string_escape(HRABBITVM v) static int64_t _string_escape(HRABBITVM v)
{ {
const SQChar *str; const SQChar *str;
SQChar *dest,*resstr; SQChar *dest,*resstr;
SQInteger size; int64_t size;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
size = sq_getsize(v,2); size = sq_getsize(v,2);
if(size == 0) { if(size == 0) {
@ -283,20 +283,20 @@ static SQInteger _string_escape(HRABBITVM v)
#ifdef SQUNICODE #ifdef SQUNICODE
#if WCHAR_SIZE == 2 #if WCHAR_SIZE == 2
const SQChar *escpat = _SC("\\x%04x"); const SQChar *escpat = _SC("\\x%04x");
const SQInteger maxescsize = 6; const int64_t maxescsize = 6;
#else //WCHAR_SIZE == 4 #else //WCHAR_SIZE == 4
const SQChar *escpat = _SC("\\x%08x"); const SQChar *escpat = _SC("\\x%08x");
const SQInteger maxescsize = 10; const int64_t maxescsize = 10;
#endif #endif
#else #else
const SQChar *escpat = _SC("\\x%02x"); const SQChar *escpat = _SC("\\x%02x");
const SQInteger maxescsize = 4; const int64_t maxescsize = 4;
#endif #endif
SQInteger destcharsize = (size * maxescsize); //assumes every char could be escaped int64_t destcharsize = (size * maxescsize); //assumes every char could be escaped
resstr = dest = (SQChar *)sq_getscratchpad(v,destcharsize * sizeof(SQChar)); resstr = dest = (SQChar *)sq_getscratchpad(v,destcharsize * sizeof(SQChar));
SQChar c; SQChar c;
SQChar escch; SQChar escch;
SQInteger escaped = 0; int64_t escaped = 0;
for(int n = 0; n < size; n++){ for(int n = 0; n < size; n++){
c = *str++; c = *str++;
escch = 0; escch = 0;
@ -339,13 +339,13 @@ static SQInteger _string_escape(HRABBITVM v)
return 1; return 1;
} }
static SQInteger _string_startswith(HRABBITVM v) static int64_t _string_startswith(HRABBITVM v)
{ {
const SQChar *str,*cmp; const SQChar *str,*cmp;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
sq_getstring(v,3,&cmp); sq_getstring(v,3,&cmp);
SQInteger len = sq_getsize(v,2); int64_t len = sq_getsize(v,2);
SQInteger cmplen = sq_getsize(v,3); int64_t cmplen = sq_getsize(v,3);
SQBool ret = SQFalse; SQBool ret = SQFalse;
if(cmplen <= len) { if(cmplen <= len) {
ret = memcmp(str,cmp,sq_rsl(cmplen)) == 0 ? SQTrue : SQFalse; ret = memcmp(str,cmp,sq_rsl(cmplen)) == 0 ? SQTrue : SQFalse;
@ -354,13 +354,13 @@ static SQInteger _string_startswith(HRABBITVM v)
return 1; return 1;
} }
static SQInteger _string_endswith(HRABBITVM v) static int64_t _string_endswith(HRABBITVM v)
{ {
const SQChar *str,*cmp; const SQChar *str,*cmp;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
sq_getstring(v,3,&cmp); sq_getstring(v,3,&cmp);
SQInteger len = sq_getsize(v,2); int64_t len = sq_getsize(v,2);
SQInteger cmplen = sq_getsize(v,3); int64_t cmplen = sq_getsize(v,3);
SQBool ret = SQFalse; SQBool ret = SQFalse;
if(cmplen <= len) { if(cmplen <= len) {
ret = memcmp(&str[len - cmplen],cmp,sq_rsl(cmplen)) == 0 ? SQTrue : SQFalse; ret = memcmp(&str[len - cmplen],cmp,sq_rsl(cmplen)) == 0 ? SQTrue : SQFalse;
@ -373,14 +373,14 @@ static SQInteger _string_endswith(HRABBITVM v)
SQRex *self = NULL; \ SQRex *self = NULL; \
sq_getinstanceup(v,1,(SQUserPointer *)&self,0); sq_getinstanceup(v,1,(SQUserPointer *)&self,0);
static SQInteger _rexobj_releasehook(SQUserPointer p, SQInteger SQ_UNUSED_ARG(size)) static int64_t _rexobj_releasehook(SQUserPointer p, int64_t SQ_UNUSED_ARG(size))
{ {
SQRex *self = ((SQRex *)p); SQRex *self = ((SQRex *)p);
sqstd_rex_free(self); sqstd_rex_free(self);
return 1; return 1;
} }
static SQInteger _regexp_match(HRABBITVM v) static int64_t _regexp_match(HRABBITVM v)
{ {
SETUP_REX(v); SETUP_REX(v);
const SQChar *str; const SQChar *str;
@ -405,11 +405,11 @@ static void _addrexmatch(HRABBITVM v,const SQChar *str,const SQChar *begin,const
sq_rawset(v,-3); sq_rawset(v,-3);
} }
static SQInteger _regexp_search(HRABBITVM v) static int64_t _regexp_search(HRABBITVM v)
{ {
SETUP_REX(v); SETUP_REX(v);
const SQChar *str,*begin,*end; const SQChar *str,*begin,*end;
SQInteger start = 0; int64_t start = 0;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
if(sq_gettop(v) > 2) sq_getinteger(v,3,&start); if(sq_gettop(v) > 2) sq_getinteger(v,3,&start);
if(sqstd_rex_search(self,str+start,&begin,&end) == SQTrue) { if(sqstd_rex_search(self,str+start,&begin,&end) == SQTrue) {
@ -419,18 +419,18 @@ static SQInteger _regexp_search(HRABBITVM v)
return 0; return 0;
} }
static SQInteger _regexp_capture(HRABBITVM v) static int64_t _regexp_capture(HRABBITVM v)
{ {
SETUP_REX(v); SETUP_REX(v);
const SQChar *str,*begin,*end; const SQChar *str,*begin,*end;
SQInteger start = 0; int64_t start = 0;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
if(sq_gettop(v) > 2) sq_getinteger(v,3,&start); if(sq_gettop(v) > 2) sq_getinteger(v,3,&start);
if(sqstd_rex_search(self,str+start,&begin,&end) == SQTrue) { if(sqstd_rex_search(self,str+start,&begin,&end) == SQTrue) {
SQInteger n = sqstd_rex_getsubexpcount(self); int64_t n = sqstd_rex_getsubexpcount(self);
SQRexMatch match; SQRexMatch match;
sq_newarray(v,0); sq_newarray(v,0);
for(SQInteger i = 0;i < n; i++) { for(int64_t i = 0;i < n; i++) {
sqstd_rex_getsubexp(self,i,&match); sqstd_rex_getsubexp(self,i,&match);
if(match.len > 0) if(match.len > 0)
_addrexmatch(v,str,match.begin,match.begin+match.len); _addrexmatch(v,str,match.begin,match.begin+match.len);
@ -443,14 +443,14 @@ static SQInteger _regexp_capture(HRABBITVM v)
return 0; return 0;
} }
static SQInteger _regexp_subexpcount(HRABBITVM v) static int64_t _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(HRABBITVM v) static int64_t _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(HRABBITVM v)
return 0; return 0;
} }
static SQInteger _regexp__typeof(HRABBITVM v) static int64_t _regexp__typeof(HRABBITVM v)
{ {
sq_pushstring(v,_SC("regexp"),-1); sq_pushstring(v,_SC("regexp"),-1);
return 1; return 1;
@ -495,11 +495,11 @@ static const SQRegFunction stringlib_funcs[]={
#undef _DECL_FUNC #undef _DECL_FUNC
SQInteger sqstd_register_stringlib(HRABBITVM v) int64_t 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);
SQInteger i = 0; int64_t i = 0;
while(rexobj_funcs[i].name != 0) { while(rexobj_funcs[i].name != 0) {
const SQRegFunction &f = rexobj_funcs[i]; const SQRegFunction &f = rexobj_funcs[i];
sq_pushstring(v,f.name,-1); sq_pushstring(v,f.name,-1);

8
rabbit-std/sqstdstring.hpp
View File

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

30
rabbit-std/sqstdsystem.cpp
View File

@ -27,7 +27,7 @@
#define screname rename #define screname rename
#endif #endif
static SQInteger _system_getenv(HRABBITVM v) static int64_t _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(HRABBITVM v)
} }
static SQInteger _system_system(HRABBITVM v) static int64_t _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(HRABBITVM v)
} }
static SQInteger _system_clock(HRABBITVM v) static int64_t _system_clock(HRABBITVM v)
{ {
sq_pushfloat(v,((SQFloat)clock())/(SQFloat)CLOCKS_PER_SEC); sq_pushfloat(v,((float_t)clock())/(float_t)CLOCKS_PER_SEC);
return 1; return 1;
} }
static SQInteger _system_time(HRABBITVM v) static int64_t _system_time(HRABBITVM v)
{ {
SQInteger t = (SQInteger)time(NULL); int64_t t = (int64_t)time(NULL);
sq_pushinteger(v,t); sq_pushinteger(v,t);
return 1; return 1;
} }
static SQInteger _system_remove(HRABBITVM v) static int64_t _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(HRABBITVM v)
return 0; return 0;
} }
static SQInteger _system_rename(HRABBITVM v) static int64_t _system_rename(HRABBITVM v)
{ {
const SQChar *oldn,*newn; const SQChar *oldn,*newn;
sq_getstring(v,2,&oldn); sq_getstring(v,2,&oldn);
@ -81,23 +81,23 @@ static SQInteger _system_rename(HRABBITVM v)
return 0; return 0;
} }
static void _set_integer_slot(HRABBITVM v,const SQChar *name,SQInteger val) static void _set_integer_slot(HRABBITVM v,const SQChar *name,int64_t 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(HRABBITVM v) static int64_t _system_date(HRABBITVM v)
{ {
time_t t; time_t t;
SQInteger it; int64_t it;
SQInteger format = 'l'; int64_t format = 'l';
if(sq_gettop(v) > 1) { if(sq_gettop(v) > 1) {
sq_getinteger(v,2,&it); sq_getinteger(v,2,&it);
t = it; t = it;
if(sq_gettop(v) > 2) { if(sq_gettop(v) > 2) {
sq_getinteger(v,3,(SQInteger*)&format); sq_getinteger(v,3,(int64_t*)&format);
} }
} }
else { else {
@ -137,9 +137,9 @@ static const SQRegFunction systemlib_funcs[]={
}; };
#undef _DECL_FUNC #undef _DECL_FUNC
SQInteger sqstd_register_systemlib(HRABBITVM v) int64_t sqstd_register_systemlib(HRABBITVM v)
{ {
SQInteger i=0; int64_t i=0;
while(systemlib_funcs[i].name!=0) while(systemlib_funcs[i].name!=0)
{ {
sq_pushstring(v,systemlib_funcs[i].name,-1); sq_pushstring(v,systemlib_funcs[i].name,-1);

2
rabbit-std/sqstdsystem.hpp
View File

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

8
rabbit/UserData.hpp
View File

@ -17,7 +17,7 @@ namespace rabbit {
~UserData() { ~UserData() {
SetDelegate(NULL); SetDelegate(NULL);
} }
static UserData* Create(SQSharedState *ss, SQInteger size) { static UserData* Create(SQSharedState *ss, int64_t size) {
UserData* ud = (UserData*)SQ_MALLOC(sq_aligning(sizeof(UserData))+size); UserData* ud = (UserData*)SQ_MALLOC(sq_aligning(sizeof(UserData))+size);
new (ud) UserData(ss); new (ud) UserData(ss);
ud->m_size = size; ud->m_size = size;
@ -28,11 +28,11 @@ namespace rabbit {
if (m_hook) { if (m_hook) {
m_hook((SQUserPointer)sq_aligning(this + 1),m_size); m_hook((SQUserPointer)sq_aligning(this + 1),m_size);
} }
SQInteger tsize = m_size; int64_t tsize = m_size;
this->~UserData(); this->~UserData();
SQ_FREE(this, sq_aligning(sizeof(UserData)) + tsize); SQ_FREE(this, sq_aligning(sizeof(UserData)) + tsize);
} }
const SQInteger& getSize() const { const int64_t& getSize() const {
return m_size; return m_size;
} }
const SQUserPointer& getTypeTag() const { const SQUserPointer& getTypeTag() const {
@ -48,7 +48,7 @@ namespace rabbit {
m_hook = _value; m_hook = _value;
} }
protected: protected:
SQInteger m_size; int64_t m_size;
SQRELEASEHOOK m_hook; SQRELEASEHOOK m_hook;
SQUserPointer m_typetag; SQUserPointer m_typetag;
}; };

224
rabbit/rabbit.hpp
View File

@ -11,10 +11,6 @@
#include _SQ_CONFIG_INCLUDE #include _SQ_CONFIG_INCLUDE
#endif #endif
#ifdef __cplusplus
extern "C" {
#endif
#ifndef RABBIT_API #ifndef RABBIT_API
#define RABBIT_API extern #define RABBIT_API extern
#endif #endif
@ -127,8 +123,8 @@ typedef union tagSQObjectValue
struct SQNativeClosure *pNativeClosure; struct SQNativeClosure *pNativeClosure;
struct SQString *pString; struct SQString *pString;
struct rabbit::UserData *pUserData; struct rabbit::UserData *pUserData;
SQInteger nInteger; int64_t nInteger;
SQFloat fFloat; float_t fFloat;
SQUserPointer pUserPointer; SQUserPointer pUserPointer;
struct SQFunctionProto *pFunctionProto; struct SQFunctionProto *pFunctionProto;
struct SQRefCounted *pRefCounted; struct SQRefCounted *pRefCounted;
@ -149,32 +145,32 @@ typedef struct tagSQObject
typedef struct tagSQMemberHandle{ typedef struct tagSQMemberHandle{
SQBool _static; SQBool _static;
SQInteger _index; int64_t _index;
}SQMemberHandle; }SQMemberHandle;
typedef struct tagSQStackInfos{ typedef struct tagSQStackInfos{
const SQChar* funcname; const SQChar* funcname;
const SQChar* source; const SQChar* source;
SQInteger line; int64_t line;
}SQStackInfos; }SQStackInfos;
typedef struct SQVM* HRABBITVM; typedef struct SQVM* HRABBITVM;
typedef SQObject HSQOBJECT; typedef SQObject HSQOBJECT;
typedef SQMemberHandle HSQMEMBERHANDLE; typedef SQMemberHandle HSQMEMBERHANDLE;
typedef SQInteger (*SQFUNCTION)(HRABBITVM); typedef int64_t (*SQFUNCTION)(HRABBITVM);
typedef SQInteger (*SQRELEASEHOOK)(SQUserPointer,SQInteger size); typedef int64_t (*SQRELEASEHOOK)(SQUserPointer,int64_t size);
typedef void (*SQCOMPILERERROR)(HRABBITVM,const SQChar * /*desc*/,const SQChar * /*source*/,SQInteger /*line*/,SQInteger /*column*/); typedef void (*SQCOMPILERERROR)(HRABBITVM,const SQChar * /*desc*/,const SQChar * /*source*/,int64_t /*line*/,int64_t /*column*/);
typedef void (*SQPRINTFUNCTION)(HRABBITVM,const SQChar * ,...); typedef void (*SQPRINTFUNCTION)(HRABBITVM,const SQChar * ,...);
typedef void (*SQDEBUGHOOK)(HRABBITVM /*v*/, SQInteger /*type*/, const SQChar * /*sourcename*/, SQInteger /*line*/, const SQChar * /*funcname*/); typedef void (*SQDEBUGHOOK)(HRABBITVM /*v*/, int64_t /*type*/, const SQChar * /*sourcename*/, int64_t /*line*/, const SQChar * /*funcname*/);
typedef SQInteger (*SQWRITEFUNC)(SQUserPointer,SQUserPointer,SQInteger); typedef int64_t (*SQWRITEFUNC)(SQUserPointer,SQUserPointer,int64_t);
typedef SQInteger (*SQREADFUNC)(SQUserPointer,SQUserPointer,SQInteger); typedef int64_t (*SQREADFUNC)(SQUserPointer,SQUserPointer,int64_t);
typedef SQInteger (*SQLEXREADFUNC)(SQUserPointer); typedef int64_t (*SQLEXREADFUNC)(SQUserPointer);
typedef struct tagSQRegFunction{ typedef struct tagSQRegFunction{
const SQChar *name; const SQChar *name;
SQFUNCTION f; SQFUNCTION f;
SQInteger nparamscheck; int64_t nparamscheck;
const SQChar *typemask; const SQChar *typemask;
}SQRegFunction; }SQRegFunction;
@ -182,12 +178,12 @@ typedef struct tagSQFunctionInfo {
SQUserPointer funcid; SQUserPointer funcid;
const SQChar *name; const SQChar *name;
const SQChar *source; const SQChar *source;
SQInteger line; int64_t line;
}SQFunctionInfo; }SQFunctionInfo;
/*vm*/ /*vm*/
RABBIT_API HRABBITVM sq_open(SQInteger initialstacksize); RABBIT_API HRABBITVM sq_open(int64_t initialstacksize);
RABBIT_API HRABBITVM sq_newthread(HRABBITVM friendvm, SQInteger initialstacksize); RABBIT_API HRABBITVM sq_newthread(HRABBITVM friendvm, int64_t initialstacksize);
RABBIT_API void sq_seterrorhandler(HRABBITVM v); RABBIT_API void sq_seterrorhandler(HRABBITVM v);
RABBIT_API void sq_close(HRABBITVM v); RABBIT_API void sq_close(HRABBITVM v);
RABBIT_API void sq_setforeignptr(HRABBITVM v,SQUserPointer p); RABBIT_API void sq_setforeignptr(HRABBITVM v,SQUserPointer p);
@ -203,82 +199,82 @@ RABBIT_API SQPRINTFUNCTION sq_getprintfunc(HRABBITVM v);
RABBIT_API SQPRINTFUNCTION sq_geterrorfunc(HRABBITVM v); RABBIT_API SQPRINTFUNCTION sq_geterrorfunc(HRABBITVM v);
RABBIT_API SQRESULT sq_suspendvm(HRABBITVM v); RABBIT_API SQRESULT sq_suspendvm(HRABBITVM v);
RABBIT_API SQRESULT sq_wakeupvm(HRABBITVM v,SQBool resumedret,SQBool retval,SQBool raiseerror,SQBool throwerror); RABBIT_API SQRESULT sq_wakeupvm(HRABBITVM v,SQBool resumedret,SQBool retval,SQBool raiseerror,SQBool throwerror);
RABBIT_API SQInteger sq_getvmstate(HRABBITVM v); RABBIT_API int64_t sq_getvmstate(HRABBITVM v);
RABBIT_API SQInteger sq_getversion(); RABBIT_API int64_t sq_getversion();
/*compiler*/ /*compiler*/
RABBIT_API SQRESULT sq_compile(HRABBITVM 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);
RABBIT_API SQRESULT sq_compilebuffer(HRABBITVM v,const SQChar *s,SQInteger size,const SQChar *sourcename,SQBool raiseerror); RABBIT_API SQRESULT sq_compilebuffer(HRABBITVM v,const SQChar *s,int64_t size,const SQChar *sourcename,SQBool raiseerror);
RABBIT_API void sq_enabledebuginfo(HRABBITVM v, SQBool enable); RABBIT_API void sq_enabledebuginfo(HRABBITVM v, SQBool enable);
RABBIT_API void sq_notifyallexceptions(HRABBITVM v, SQBool enable); RABBIT_API void sq_notifyallexceptions(HRABBITVM v, SQBool enable);
RABBIT_API void sq_setcompilererrorhandler(HRABBITVM v,SQCOMPILERERROR f); RABBIT_API void sq_setcompilererrorhandler(HRABBITVM v,SQCOMPILERERROR f);
/*stack operations*/ /*stack operations*/
RABBIT_API void sq_push(HRABBITVM v,SQInteger idx); RABBIT_API void sq_push(HRABBITVM v,int64_t idx);
RABBIT_API void sq_pop(HRABBITVM v,SQInteger nelemstopop); RABBIT_API void sq_pop(HRABBITVM v,int64_t nelemstopop);
RABBIT_API void sq_poptop(HRABBITVM v); RABBIT_API void sq_poptop(HRABBITVM v);
RABBIT_API void sq_remove(HRABBITVM v,SQInteger idx); RABBIT_API void sq_remove(HRABBITVM v,int64_t idx);
RABBIT_API SQInteger sq_gettop(HRABBITVM v); RABBIT_API int64_t sq_gettop(HRABBITVM v);
RABBIT_API void sq_settop(HRABBITVM v,SQInteger newtop); RABBIT_API void sq_settop(HRABBITVM v,int64_t newtop);
RABBIT_API SQRESULT sq_reservestack(HRABBITVM v,SQInteger nsize); RABBIT_API SQRESULT sq_reservestack(HRABBITVM v,int64_t nsize);
RABBIT_API SQInteger sq_cmp(HRABBITVM v); RABBIT_API int64_t sq_cmp(HRABBITVM v);
RABBIT_API void sq_move(HRABBITVM dest,HRABBITVM src,SQInteger idx); RABBIT_API void sq_move(HRABBITVM dest,HRABBITVM src,int64_t idx);
/*object creation handling*/ /*object creation handling*/
RABBIT_API SQUserPointer sq_newuserdata(HRABBITVM v,SQUnsignedInteger size); RABBIT_API SQUserPointer sq_newuserdata(HRABBITVM v,uint64_t size);
RABBIT_API void sq_newtable(HRABBITVM v); RABBIT_API void sq_newtable(HRABBITVM v);
RABBIT_API void sq_newtableex(HRABBITVM v,SQInteger initialcapacity); RABBIT_API void sq_newtableex(HRABBITVM v,int64_t initialcapacity);
RABBIT_API void sq_newarray(HRABBITVM v,SQInteger size); RABBIT_API void sq_newarray(HRABBITVM v,int64_t size);
RABBIT_API void sq_newclosure(HRABBITVM v,SQFUNCTION func,SQUnsignedInteger nfreevars); RABBIT_API void sq_newclosure(HRABBITVM v,SQFUNCTION func,uint64_t nfreevars);
RABBIT_API SQRESULT sq_setparamscheck(HRABBITVM v,SQInteger nparamscheck,const SQChar *typemask); RABBIT_API SQRESULT sq_setparamscheck(HRABBITVM v,int64_t nparamscheck,const SQChar *typemask);
RABBIT_API SQRESULT sq_bindenv(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_bindenv(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_setclosureroot(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_setclosureroot(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_getclosureroot(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_getclosureroot(HRABBITVM v,int64_t idx);
RABBIT_API void sq_pushstring(HRABBITVM v,const SQChar *s,SQInteger len); RABBIT_API void sq_pushstring(HRABBITVM v,const SQChar *s,int64_t len);
RABBIT_API void sq_pushfloat(HRABBITVM v,SQFloat f); RABBIT_API void sq_pushfloat(HRABBITVM v,float_t f);
RABBIT_API void sq_pushinteger(HRABBITVM v,SQInteger n); RABBIT_API void sq_pushinteger(HRABBITVM v,int64_t n);
RABBIT_API void sq_pushbool(HRABBITVM v,SQBool b); RABBIT_API void sq_pushbool(HRABBITVM v,SQBool b);
RABBIT_API void sq_pushuserpointer(HRABBITVM v,SQUserPointer p); RABBIT_API void sq_pushuserpointer(HRABBITVM v,SQUserPointer p);
RABBIT_API void sq_pushnull(HRABBITVM v); RABBIT_API void sq_pushnull(HRABBITVM v);
RABBIT_API void sq_pushthread(HRABBITVM v, HRABBITVM thread); RABBIT_API void sq_pushthread(HRABBITVM v, HRABBITVM thread);
RABBIT_API SQObjectType sq_gettype(HRABBITVM v,SQInteger idx); RABBIT_API SQObjectType sq_gettype(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_typeof(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_typeof(HRABBITVM v,int64_t idx);
RABBIT_API SQInteger sq_getsize(HRABBITVM v,SQInteger idx); RABBIT_API int64_t sq_getsize(HRABBITVM v,int64_t idx);
RABBIT_API SQHash sq_gethash(HRABBITVM v, SQInteger idx); RABBIT_API SQHash sq_gethash(HRABBITVM v, int64_t idx);
RABBIT_API SQRESULT sq_getbase(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_getbase(HRABBITVM v,int64_t idx);
RABBIT_API SQBool sq_instanceof(HRABBITVM v); RABBIT_API SQBool sq_instanceof(HRABBITVM v);
RABBIT_API SQRESULT sq_tostring(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_tostring(HRABBITVM v,int64_t idx);
RABBIT_API void sq_tobool(HRABBITVM v, SQInteger idx, SQBool *b); RABBIT_API void sq_tobool(HRABBITVM v, int64_t idx, SQBool *b);
RABBIT_API SQRESULT sq_getstringandsize(HRABBITVM v,SQInteger idx,const SQChar **c,SQInteger *size); RABBIT_API SQRESULT sq_getstringandsize(HRABBITVM v,int64_t idx,const SQChar **c,int64_t *size);
RABBIT_API SQRESULT sq_getstring(HRABBITVM v,SQInteger idx,const SQChar **c); RABBIT_API SQRESULT sq_getstring(HRABBITVM v,int64_t idx,const SQChar **c);
RABBIT_API SQRESULT sq_getinteger(HRABBITVM v,SQInteger idx,SQInteger *i); RABBIT_API SQRESULT sq_getinteger(HRABBITVM v,int64_t idx,int64_t *i);
RABBIT_API SQRESULT sq_getfloat(HRABBITVM v,SQInteger idx,SQFloat *f); RABBIT_API SQRESULT sq_getfloat(HRABBITVM v,int64_t idx,float_t *f);
RABBIT_API SQRESULT sq_getbool(HRABBITVM v,SQInteger idx,SQBool *b); RABBIT_API SQRESULT sq_getbool(HRABBITVM v,int64_t idx,SQBool *b);
RABBIT_API SQRESULT sq_getthread(HRABBITVM v,SQInteger idx,HRABBITVM *thread); RABBIT_API SQRESULT sq_getthread(HRABBITVM v,int64_t idx,HRABBITVM *thread);
RABBIT_API SQRESULT sq_getuserpointer(HRABBITVM v,SQInteger idx,SQUserPointer *p); RABBIT_API SQRESULT sq_getuserpointer(HRABBITVM v,int64_t idx,SQUserPointer *p);
RABBIT_API SQRESULT sq_getuserdata(HRABBITVM v,SQInteger idx,SQUserPointer *p,SQUserPointer *typetag); RABBIT_API SQRESULT sq_getuserdata(HRABBITVM v,int64_t idx,SQUserPointer *p,SQUserPointer *typetag);
RABBIT_API SQRESULT sq_settypetag(HRABBITVM v,SQInteger idx,SQUserPointer typetag); RABBIT_API SQRESULT sq_settypetag(HRABBITVM v,int64_t idx,SQUserPointer typetag);
RABBIT_API SQRESULT sq_gettypetag(HRABBITVM v,SQInteger idx,SQUserPointer *typetag); RABBIT_API SQRESULT sq_gettypetag(HRABBITVM v,int64_t idx,SQUserPointer *typetag);
RABBIT_API void sq_setreleasehook(HRABBITVM v,SQInteger idx,SQRELEASEHOOK hook); RABBIT_API void sq_setreleasehook(HRABBITVM v,int64_t idx,SQRELEASEHOOK hook);
RABBIT_API SQRELEASEHOOK sq_getreleasehook(HRABBITVM v,SQInteger idx); RABBIT_API SQRELEASEHOOK sq_getreleasehook(HRABBITVM v,int64_t idx);
RABBIT_API SQChar *sq_getscratchpad(HRABBITVM v,SQInteger minsize); RABBIT_API SQChar *sq_getscratchpad(HRABBITVM v,int64_t minsize);
RABBIT_API SQRESULT sq_getfunctioninfo(HRABBITVM v,SQInteger level,SQFunctionInfo *fi); RABBIT_API SQRESULT sq_getfunctioninfo(HRABBITVM v,int64_t level,SQFunctionInfo *fi);
RABBIT_API SQRESULT sq_getclosureinfo(HRABBITVM v,SQInteger idx,SQUnsignedInteger *nparams,SQUnsignedInteger *nfreevars); RABBIT_API SQRESULT sq_getclosureinfo(HRABBITVM v,int64_t idx,uint64_t *nparams,uint64_t *nfreevars);
RABBIT_API SQRESULT sq_getclosurename(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_getclosurename(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_setnativeclosurename(HRABBITVM v,SQInteger idx,const SQChar *name); RABBIT_API SQRESULT sq_setnativeclosurename(HRABBITVM v,int64_t idx,const SQChar *name);
RABBIT_API SQRESULT sq_setinstanceup(HRABBITVM v, SQInteger idx, SQUserPointer p); RABBIT_API SQRESULT sq_setinstanceup(HRABBITVM v, int64_t idx, SQUserPointer p);
RABBIT_API SQRESULT sq_getinstanceup(HRABBITVM v, SQInteger idx, SQUserPointer *p,SQUserPointer typetag); RABBIT_API SQRESULT sq_getinstanceup(HRABBITVM v, int64_t idx, SQUserPointer *p,SQUserPointer typetag);
RABBIT_API SQRESULT sq_setclassudsize(HRABBITVM v, SQInteger idx, SQInteger udsize); RABBIT_API SQRESULT sq_setclassudsize(HRABBITVM v, int64_t idx, int64_t udsize);
RABBIT_API SQRESULT sq_newclass(HRABBITVM v,SQBool hasbase); RABBIT_API SQRESULT sq_newclass(HRABBITVM v,SQBool hasbase);
RABBIT_API SQRESULT sq_createinstance(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_createinstance(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_setattributes(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_setattributes(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_getattributes(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_getattributes(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_getclass(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_getclass(HRABBITVM v,int64_t idx);
RABBIT_API void sq_weakref(HRABBITVM v,SQInteger idx); RABBIT_API void sq_weakref(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_getdefaultdelegate(HRABBITVM v,SQObjectType t); RABBIT_API SQRESULT sq_getdefaultdelegate(HRABBITVM v,SQObjectType t);
RABBIT_API SQRESULT sq_getmemberhandle(HRABBITVM v,SQInteger idx,HSQMEMBERHANDLE *handle); RABBIT_API SQRESULT sq_getmemberhandle(HRABBITVM v,int64_t idx,HSQMEMBERHANDLE *handle);
RABBIT_API SQRESULT sq_getbyhandle(HRABBITVM v,SQInteger idx,const HSQMEMBERHANDLE *handle); RABBIT_API SQRESULT sq_getbyhandle(HRABBITVM v,int64_t idx,const HSQMEMBERHANDLE *handle);
RABBIT_API SQRESULT sq_setbyhandle(HRABBITVM v,SQInteger idx,const HSQMEMBERHANDLE *handle); RABBIT_API SQRESULT sq_setbyhandle(HRABBITVM v,int64_t idx,const HSQMEMBERHANDLE *handle);
/*object manipulation*/ /*object manipulation*/
RABBIT_API void sq_pushroottable(HRABBITVM v); RABBIT_API void sq_pushroottable(HRABBITVM v);
@ -286,59 +282,59 @@ RABBIT_API void sq_pushregistrytable(HRABBITVM v);
RABBIT_API void sq_pushconsttable(HRABBITVM v); RABBIT_API void sq_pushconsttable(HRABBITVM v);
RABBIT_API SQRESULT sq_setroottable(HRABBITVM v); RABBIT_API SQRESULT sq_setroottable(HRABBITVM v);
RABBIT_API SQRESULT sq_setconsttable(HRABBITVM v); RABBIT_API SQRESULT sq_setconsttable(HRABBITVM v);
RABBIT_API SQRESULT sq_newslot(HRABBITVM v, SQInteger idx, SQBool bstatic); RABBIT_API SQRESULT sq_newslot(HRABBITVM v, int64_t idx, SQBool bstatic);
RABBIT_API SQRESULT sq_deleteslot(HRABBITVM v,SQInteger idx,SQBool pushval); RABBIT_API SQRESULT sq_deleteslot(HRABBITVM v,int64_t idx,SQBool pushval);
RABBIT_API SQRESULT sq_set(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_set(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_get(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_get(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_rawget(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_rawget(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_rawset(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_rawset(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_rawdeleteslot(HRABBITVM v,SQInteger idx,SQBool pushval); RABBIT_API SQRESULT sq_rawdeleteslot(HRABBITVM v,int64_t idx,SQBool pushval);
RABBIT_API SQRESULT sq_newmember(HRABBITVM v,SQInteger idx,SQBool bstatic); RABBIT_API SQRESULT sq_newmember(HRABBITVM v,int64_t idx,SQBool bstatic);
RABBIT_API SQRESULT sq_rawnewmember(HRABBITVM v,SQInteger idx,SQBool bstatic); RABBIT_API SQRESULT sq_rawnewmember(HRABBITVM v,int64_t idx,SQBool bstatic);
RABBIT_API SQRESULT sq_arrayappend(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_arrayappend(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_arraypop(HRABBITVM v,SQInteger idx,SQBool pushval); RABBIT_API SQRESULT sq_arraypop(HRABBITVM v,int64_t idx,SQBool pushval);
RABBIT_API SQRESULT sq_arrayresize(HRABBITVM v,SQInteger idx,SQInteger newsize); RABBIT_API SQRESULT sq_arrayresize(HRABBITVM v,int64_t idx,int64_t newsize);
RABBIT_API SQRESULT sq_arrayreverse(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_arrayreverse(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_arrayremove(HRABBITVM v,SQInteger idx,SQInteger itemidx); RABBIT_API SQRESULT sq_arrayremove(HRABBITVM v,int64_t idx,int64_t itemidx);
RABBIT_API SQRESULT sq_arrayinsert(HRABBITVM v,SQInteger idx,SQInteger destpos); RABBIT_API SQRESULT sq_arrayinsert(HRABBITVM v,int64_t idx,int64_t destpos);
RABBIT_API SQRESULT sq_setdelegate(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_setdelegate(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_getdelegate(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_getdelegate(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_clone(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_clone(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_setfreevariable(HRABBITVM v,SQInteger idx,SQUnsignedInteger nval); RABBIT_API SQRESULT sq_setfreevariable(HRABBITVM v,int64_t idx,uint64_t nval);
RABBIT_API SQRESULT sq_next(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_next(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_getweakrefval(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_getweakrefval(HRABBITVM v,int64_t idx);
RABBIT_API SQRESULT sq_clear(HRABBITVM v,SQInteger idx); RABBIT_API SQRESULT sq_clear(HRABBITVM v,int64_t idx);
/*calls*/ /*calls*/
RABBIT_API SQRESULT sq_call(HRABBITVM v,SQInteger params,SQBool retval,SQBool raiseerror); RABBIT_API SQRESULT sq_call(HRABBITVM v,int64_t params,SQBool retval,SQBool raiseerror);
RABBIT_API SQRESULT sq_resume(HRABBITVM v,SQBool retval,SQBool raiseerror); RABBIT_API SQRESULT sq_resume(HRABBITVM v,SQBool retval,SQBool raiseerror);
RABBIT_API const SQChar *sq_getlocal(HRABBITVM v,SQUnsignedInteger level,SQUnsignedInteger idx); RABBIT_API const SQChar *sq_getlocal(HRABBITVM v,uint64_t level,uint64_t idx);
RABBIT_API SQRESULT sq_getcallee(HRABBITVM v); RABBIT_API SQRESULT sq_getcallee(HRABBITVM v);
RABBIT_API const SQChar *sq_getfreevariable(HRABBITVM v,SQInteger idx,SQUnsignedInteger nval); RABBIT_API const SQChar *sq_getfreevariable(HRABBITVM v,int64_t idx,uint64_t nval);
RABBIT_API SQRESULT sq_throwerror(HRABBITVM v,const SQChar *err); RABBIT_API SQRESULT sq_throwerror(HRABBITVM v,const SQChar *err);
RABBIT_API SQRESULT sq_throwobject(HRABBITVM v); RABBIT_API SQRESULT sq_throwobject(HRABBITVM v);
RABBIT_API void sq_reseterror(HRABBITVM v); RABBIT_API void sq_reseterror(HRABBITVM v);
RABBIT_API void sq_getlasterror(HRABBITVM v); RABBIT_API void sq_getlasterror(HRABBITVM v);
RABBIT_API SQRESULT sq_tailcall(HRABBITVM v, SQInteger nparams); RABBIT_API SQRESULT sq_tailcall(HRABBITVM v, int64_t nparams);
/*raw object handling*/ /*raw object handling*/
RABBIT_API SQRESULT sq_getstackobj(HRABBITVM v,SQInteger idx,HSQOBJECT *po); RABBIT_API SQRESULT sq_getstackobj(HRABBITVM v,int64_t idx,HSQOBJECT *po);
RABBIT_API void sq_pushobject(HRABBITVM v,HSQOBJECT obj); RABBIT_API void sq_pushobject(HRABBITVM v,HSQOBJECT obj);
RABBIT_API void sq_addref(HRABBITVM v,HSQOBJECT *po); RABBIT_API void sq_addref(HRABBITVM v,HSQOBJECT *po);
RABBIT_API SQBool sq_release(HRABBITVM v,HSQOBJECT *po); RABBIT_API SQBool sq_release(HRABBITVM v,HSQOBJECT *po);
RABBIT_API SQUnsignedInteger sq_getrefcount(HRABBITVM v,HSQOBJECT *po); RABBIT_API uint64_t sq_getrefcount(HRABBITVM v,HSQOBJECT *po);
RABBIT_API void sq_resetobject(HSQOBJECT *po); RABBIT_API void sq_resetobject(HSQOBJECT *po);
RABBIT_API const SQChar *sq_objtostring(const HSQOBJECT *o); RABBIT_API const SQChar *sq_objtostring(const HSQOBJECT *o);
RABBIT_API SQBool sq_objtobool(const HSQOBJECT *o); RABBIT_API SQBool sq_objtobool(const HSQOBJECT *o);
RABBIT_API SQInteger sq_objtointeger(const HSQOBJECT *o); RABBIT_API int64_t sq_objtointeger(const HSQOBJECT *o);
RABBIT_API SQFloat sq_objtofloat(const HSQOBJECT *o); RABBIT_API float_t sq_objtofloat(const HSQOBJECT *o);
RABBIT_API SQUserPointer sq_objtouserpointer(const HSQOBJECT *o); RABBIT_API SQUserPointer sq_objtouserpointer(const HSQOBJECT *o);
RABBIT_API SQRESULT sq_getobjtypetag(const HSQOBJECT *o,SQUserPointer * typetag); RABBIT_API SQRESULT sq_getobjtypetag(const HSQOBJECT *o,SQUserPointer * typetag);
RABBIT_API SQUnsignedInteger sq_getvmrefcount(HRABBITVM v, const HSQOBJECT *po); RABBIT_API uint64_t sq_getvmrefcount(HRABBITVM v, const HSQOBJECT *po);
/*GC*/ /*GC*/
RABBIT_API SQInteger sq_collectgarbage(HRABBITVM v); RABBIT_API int64_t sq_collectgarbage(HRABBITVM v);
RABBIT_API SQRESULT sq_resurrectunreachable(HRABBITVM v); RABBIT_API SQRESULT sq_resurrectunreachable(HRABBITVM v);
/*serialization*/ /*serialization*/
@ -346,12 +342,12 @@ RABBIT_API SQRESULT sq_writeclosure(HRABBITVM vm,SQWRITEFUNC writef,SQUserPointe
RABBIT_API SQRESULT sq_readclosure(HRABBITVM vm,SQREADFUNC readf,SQUserPointer up); RABBIT_API SQRESULT sq_readclosure(HRABBITVM vm,SQREADFUNC readf,SQUserPointer up);
/*mem allocation*/ /*mem allocation*/
RABBIT_API void *sq_malloc(SQUnsignedInteger size); RABBIT_API void *sq_malloc(uint64_t size);
RABBIT_API void *sq_realloc(void* p,SQUnsignedInteger oldsize,SQUnsignedInteger newsize); RABBIT_API void *sq_realloc(void* p,uint64_t oldsize,uint64_t newsize);
RABBIT_API void sq_free(void *p,SQUnsignedInteger size); RABBIT_API void sq_free(void *p,uint64_t size);
/*debug*/ /*debug*/
RABBIT_API SQRESULT sq_stackinfos(HRABBITVM v,SQInteger level,SQStackInfos *si); RABBIT_API SQRESULT sq_stackinfos(HRABBITVM v,int64_t level,SQStackInfos *si);
RABBIT_API void sq_setdebughook(HRABBITVM v); RABBIT_API void sq_setdebughook(HRABBITVM v);
RABBIT_API void sq_setnativedebughook(HRABBITVM v,SQDEBUGHOOK hook); RABBIT_API void sq_setnativedebughook(HRABBITVM v,SQDEBUGHOOK hook);
@ -391,7 +387,3 @@ RABBIT_API void sq_setnativedebughook(HRABBITVM v,SQDEBUGHOOK hook);
# define SQ_UNUSED_ARG(x) x # define SQ_UNUSED_ARG(x) x
#endif #endif
#ifdef __cplusplus
} /*extern "C"*/
#endif

238
rabbit/sqapi.cpp
View File

@ -17,7 +17,7 @@
#include <rabbit/sqfuncstate.hpp> #include <rabbit/sqfuncstate.hpp>
#include <rabbit/sqclass.hpp> #include <rabbit/sqclass.hpp>
static bool sq_aux_gettypedarg(HRABBITVM v,SQInteger idx,SQObjectType type,SQObjectPtr **o) static bool sq_aux_gettypedarg(HRABBITVM v,int64_t idx,SQObjectType type,SQObjectPtr **o)
{ {
*o = &stack_get(v,idx); *o = &stack_get(v,idx);
if(sq_type(**o) != type){ if(sq_type(**o) != type){
@ -36,14 +36,14 @@ static bool sq_aux_gettypedarg(HRABBITVM v,SQInteger idx,SQObjectType type,SQObj
} }
SQInteger sq_aux_invalidtype(HRABBITVM v,SQObjectType type) int64_t sq_aux_invalidtype(HRABBITVM v,SQObjectType type)
{ {
SQUnsignedInteger buf_size = 100 *sizeof(SQChar); uint64_t buf_size = 100 *sizeof(SQChar);
scsprintf(_ss(v)->GetScratchPad(buf_size), buf_size, _SC("unexpected type %s"), IdType2Name(type)); scsprintf(_ss(v)->GetScratchPad(buf_size), buf_size, _SC("unexpected type %s"), IdType2Name(type));
return sq_throwerror(v, _ss(v)->GetScratchPad(-1)); return sq_throwerror(v, _ss(v)->GetScratchPad(-1));
} }
HRABBITVM sq_open(SQInteger initialstacksize) HRABBITVM sq_open(int64_t initialstacksize)
{ {
SQSharedState *ss; SQSharedState *ss;
SQVM *v; SQVM *v;
@ -61,7 +61,7 @@ HRABBITVM sq_open(SQInteger initialstacksize)
return v; return v;
} }
HRABBITVM sq_newthread(HRABBITVM friendvm, SQInteger initialstacksize) HRABBITVM sq_newthread(HRABBITVM friendvm, int64_t initialstacksize)
{ {
SQSharedState *ss; SQSharedState *ss;
SQVM *v; SQVM *v;
@ -79,7 +79,7 @@ HRABBITVM sq_newthread(HRABBITVM friendvm, SQInteger initialstacksize)
} }
} }
SQInteger sq_getvmstate(HRABBITVM v) int64_t sq_getvmstate(HRABBITVM v)
{ {
if(v->_suspended) if(v->_suspended)
return SQ_VMSTATE_SUSPENDED; return SQ_VMSTATE_SUSPENDED;
@ -123,7 +123,7 @@ void sq_close(HRABBITVM v)
sq_delete(ss, SQSharedState); sq_delete(ss, SQSharedState);
} }
SQInteger sq_getversion() int64_t sq_getversion()
{ {
return RABBIT_VERSION_NUMBER; return RABBIT_VERSION_NUMBER;
} }
@ -158,7 +158,7 @@ void sq_addref(HRABBITVM v,HSQOBJECT *po)
__AddRef(po->_type,po->_unVal); __AddRef(po->_type,po->_unVal);
} }
SQUnsignedInteger sq_getrefcount(HRABBITVM v,HSQOBJECT *po) uint64_t sq_getrefcount(HRABBITVM v,HSQOBJECT *po)
{ {
if(!ISREFCOUNTED(sq_type(*po))) return 0; if(!ISREFCOUNTED(sq_type(*po))) return 0;
return po->_unVal.pRefCounted->_uiRef; return po->_unVal.pRefCounted->_uiRef;
@ -172,7 +172,7 @@ SQBool sq_release(HRABBITVM v,HSQOBJECT *po)
return ret; //the ret val doesn't work(and cannot be fixed) return ret; //the ret val doesn't work(and cannot be fixed)
} }
SQUnsignedInteger sq_getvmrefcount(HRABBITVM SQ_UNUSED_ARG(v), const HSQOBJECT *po) uint64_t sq_getvmrefcount(HRABBITVM SQ_UNUSED_ARG(v), const HSQOBJECT *po)
{ {
if (!ISREFCOUNTED(sq_type(*po))) return 0; if (!ISREFCOUNTED(sq_type(*po))) return 0;
return po->_unVal.pRefCounted->_uiRef; return po->_unVal.pRefCounted->_uiRef;
@ -186,7 +186,7 @@ const SQChar *sq_objtostring(const HSQOBJECT *o)
return NULL; return NULL;
} }
SQInteger sq_objtointeger(const HSQOBJECT *o) int64_t sq_objtointeger(const HSQOBJECT *o)
{ {
if(sq_isnumeric(*o)) { if(sq_isnumeric(*o)) {
return tointeger(*o); return tointeger(*o);
@ -194,7 +194,7 @@ SQInteger sq_objtointeger(const HSQOBJECT *o)
return 0; return 0;
} }
SQFloat sq_objtofloat(const HSQOBJECT *o) float_t sq_objtofloat(const HSQOBJECT *o)
{ {
if(sq_isnumeric(*o)) { if(sq_isnumeric(*o)) {
return tofloat(*o); return tofloat(*o);
@ -223,14 +223,14 @@ void sq_pushnull(HRABBITVM v)
v->PushNull(); v->PushNull();
} }
void sq_pushstring(HRABBITVM v,const SQChar *s,SQInteger len) void sq_pushstring(HRABBITVM v,const SQChar *s,int64_t len)
{ {
if(s) if(s)
v->Push(SQObjectPtr(SQString::Create(_ss(v), s, len))); v->Push(SQObjectPtr(SQString::Create(_ss(v), s, len)));
else v->PushNull(); else v->PushNull();
} }
void sq_pushinteger(HRABBITVM v,SQInteger n) void sq_pushinteger(HRABBITVM v,int64_t n)
{ {
v->Push(n); v->Push(n);
} }
@ -240,7 +240,7 @@ void sq_pushbool(HRABBITVM v,SQBool b)
v->Push(b?true:false); v->Push(b?true:false);
} }
void sq_pushfloat(HRABBITVM v,SQFloat n) void sq_pushfloat(HRABBITVM v,float_t n)
{ {
v->Push(n); v->Push(n);
} }
@ -255,7 +255,7 @@ void sq_pushthread(HRABBITVM v, HRABBITVM thread)
v->Push(thread); v->Push(thread);
} }
SQUserPointer sq_newuserdata(HRABBITVM v,SQUnsignedInteger size) SQUserPointer sq_newuserdata(HRABBITVM v,uint64_t size)
{ {
rabbit::UserData *ud = rabbit::UserData::Create(_ss(v), size + SQ_ALIGNMENT); rabbit::UserData *ud = rabbit::UserData::Create(_ss(v), size + SQ_ALIGNMENT);
v->Push(ud); v->Push(ud);
@ -267,12 +267,12 @@ void sq_newtable(HRABBITVM v)
v->Push(SQTable::Create(_ss(v), 0)); v->Push(SQTable::Create(_ss(v), 0));
} }
void sq_newtableex(HRABBITVM v,SQInteger initialcapacity) void sq_newtableex(HRABBITVM v,int64_t initialcapacity)
{ {
v->Push(SQTable::Create(_ss(v), initialcapacity)); v->Push(SQTable::Create(_ss(v), initialcapacity));
} }
void sq_newarray(HRABBITVM v,SQInteger size) void sq_newarray(HRABBITVM v,int64_t size)
{ {
v->Push(SQArray::Create(_ss(v), size)); v->Push(SQArray::Create(_ss(v), size));
} }
@ -301,7 +301,7 @@ SQBool sq_instanceof(HRABBITVM v)
return _instance(inst)->InstanceOf(_class(cl))?SQTrue:SQFalse; return _instance(inst)->InstanceOf(_class(cl))?SQTrue:SQFalse;
} }
SQRESULT sq_arrayappend(HRABBITVM v,SQInteger idx) SQRESULT sq_arrayappend(HRABBITVM v,int64_t idx)
{ {
sq_aux_paramscheck(v,2); sq_aux_paramscheck(v,2);
SQObjectPtr *arr; SQObjectPtr *arr;
@ -311,7 +311,7 @@ SQRESULT sq_arrayappend(HRABBITVM v,SQInteger idx)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_arraypop(HRABBITVM v,SQInteger idx,SQBool pushval) SQRESULT sq_arraypop(HRABBITVM v,int64_t idx,SQBool pushval)
{ {
sq_aux_paramscheck(v, 1); sq_aux_paramscheck(v, 1);
SQObjectPtr *arr; SQObjectPtr *arr;
@ -324,7 +324,7 @@ SQRESULT sq_arraypop(HRABBITVM v,SQInteger idx,SQBool pushval)
return sq_throwerror(v, _SC("empty array")); return sq_throwerror(v, _SC("empty array"));
} }
SQRESULT sq_arrayresize(HRABBITVM v,SQInteger idx,SQInteger newsize) SQRESULT sq_arrayresize(HRABBITVM v,int64_t idx,int64_t newsize)
{ {
sq_aux_paramscheck(v,1); sq_aux_paramscheck(v,1);
SQObjectPtr *arr; SQObjectPtr *arr;
@ -337,7 +337,7 @@ SQRESULT sq_arrayresize(HRABBITVM v,SQInteger idx,SQInteger newsize)
} }
SQRESULT sq_arrayreverse(HRABBITVM v,SQInteger idx) SQRESULT sq_arrayreverse(HRABBITVM v,int64_t idx)
{ {
sq_aux_paramscheck(v, 1); sq_aux_paramscheck(v, 1);
SQObjectPtr *o; SQObjectPtr *o;
@ -345,9 +345,9 @@ SQRESULT sq_arrayreverse(HRABBITVM v,SQInteger idx)
SQArray *arr = _array(*o); SQArray *arr = _array(*o);
if(arr->Size() > 0) { if(arr->Size() > 0) {
SQObjectPtr t; SQObjectPtr t;
SQInteger size = arr->Size(); int64_t size = arr->Size();
SQInteger n = size >> 1; size -= 1; int64_t n = size >> 1; size -= 1;
for(SQInteger i = 0; i < n; i++) { for(int64_t i = 0; i < n; i++) {
t = arr->_values[i]; t = arr->_values[i];
arr->_values[i] = arr->_values[size-i]; arr->_values[i] = arr->_values[size-i];
arr->_values[size-i] = t; arr->_values[size-i] = t;
@ -357,7 +357,7 @@ SQRESULT sq_arrayreverse(HRABBITVM v,SQInteger idx)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_arrayremove(HRABBITVM v,SQInteger idx,SQInteger itemidx) SQRESULT sq_arrayremove(HRABBITVM v,int64_t idx,int64_t itemidx)
{ {
sq_aux_paramscheck(v, 1); sq_aux_paramscheck(v, 1);
SQObjectPtr *arr; SQObjectPtr *arr;
@ -365,7 +365,7 @@ SQRESULT sq_arrayremove(HRABBITVM v,SQInteger idx,SQInteger itemidx)
return _array(*arr)->Remove(itemidx) ? SQ_OK : sq_throwerror(v,_SC("index out of range")); return _array(*arr)->Remove(itemidx) ? SQ_OK : sq_throwerror(v,_SC("index out of range"));
} }
SQRESULT sq_arrayinsert(HRABBITVM v,SQInteger idx,SQInteger destpos) SQRESULT sq_arrayinsert(HRABBITVM v,int64_t idx,int64_t destpos)
{ {
sq_aux_paramscheck(v, 1); sq_aux_paramscheck(v, 1);
SQObjectPtr *arr; SQObjectPtr *arr;
@ -375,38 +375,38 @@ SQRESULT sq_arrayinsert(HRABBITVM v,SQInteger idx,SQInteger destpos)
return ret; return ret;
} }
void sq_newclosure(HRABBITVM v,SQFUNCTION func,SQUnsignedInteger nfreevars) void sq_newclosure(HRABBITVM v,SQFUNCTION func,uint64_t nfreevars)
{ {
SQNativeClosure *nc = SQNativeClosure::Create(_ss(v), func,nfreevars); SQNativeClosure *nc = SQNativeClosure::Create(_ss(v), func,nfreevars);
nc->_nparamscheck = 0; nc->_nparamscheck = 0;
for(SQUnsignedInteger i = 0; i < nfreevars; i++) { for(uint64_t i = 0; i < nfreevars; i++) {
nc->_outervalues[i] = v->Top(); nc->_outervalues[i] = v->Top();
v->Pop(); v->Pop();
} }
v->Push(SQObjectPtr(nc)); v->Push(SQObjectPtr(nc));
} }
SQRESULT sq_getclosureinfo(HRABBITVM v,SQInteger idx,SQUnsignedInteger *nparams,SQUnsignedInteger *nfreevars) SQRESULT sq_getclosureinfo(HRABBITVM v,int64_t idx,uint64_t *nparams,uint64_t *nfreevars)
{ {
SQObject o = stack_get(v, idx); SQObject o = stack_get(v, idx);
if(sq_type(o) == OT_CLOSURE) { if(sq_type(o) == OT_CLOSURE) {
SQClosure *c = _closure(o); SQClosure *c = _closure(o);
SQFunctionProto *proto = c->_function; SQFunctionProto *proto = c->_function;
*nparams = (SQUnsignedInteger)proto->_nparameters; *nparams = (uint64_t)proto->_nparameters;
*nfreevars = (SQUnsignedInteger)proto->_noutervalues; *nfreevars = (uint64_t)proto->_noutervalues;
return SQ_OK; return SQ_OK;
} }
else if(sq_type(o) == OT_NATIVECLOSURE) else if(sq_type(o) == OT_NATIVECLOSURE)
{ {
SQNativeClosure *c = _nativeclosure(o); SQNativeClosure *c = _nativeclosure(o);
*nparams = (SQUnsignedInteger)c->_nparamscheck; *nparams = (uint64_t)c->_nparamscheck;
*nfreevars = c->_noutervalues; *nfreevars = c->_noutervalues;
return SQ_OK; return SQ_OK;
} }
return sq_throwerror(v,_SC("the object is not a closure")); return sq_throwerror(v,_SC("the object is not a closure"));
} }
SQRESULT sq_setnativeclosurename(HRABBITVM v,SQInteger idx,const SQChar *name) SQRESULT sq_setnativeclosurename(HRABBITVM v,int64_t idx,const SQChar *name)
{ {
SQObject o = stack_get(v, idx); SQObject o = stack_get(v, idx);
if(sq_isnativeclosure(o)) { if(sq_isnativeclosure(o)) {
@ -417,7 +417,7 @@ SQRESULT sq_setnativeclosurename(HRABBITVM v,SQInteger idx,const SQChar *name)
return sq_throwerror(v,_SC("the object is not a nativeclosure")); return sq_throwerror(v,_SC("the object is not a nativeclosure"));
} }
SQRESULT sq_setparamscheck(HRABBITVM v,SQInteger nparamscheck,const SQChar *typemask) SQRESULT sq_setparamscheck(HRABBITVM v,int64_t nparamscheck,const SQChar *typemask)
{ {
SQObject o = stack_get(v, -1); SQObject o = stack_get(v, -1);
if(!sq_isnativeclosure(o)) if(!sq_isnativeclosure(o))
@ -439,7 +439,7 @@ SQRESULT sq_setparamscheck(HRABBITVM v,SQInteger nparamscheck,const SQChar *type
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_bindenv(HRABBITVM v,SQInteger idx) SQRESULT sq_bindenv(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &o = stack_get(v,idx); SQObjectPtr &o = stack_get(v,idx);
if(!sq_isnativeclosure(o) && if(!sq_isnativeclosure(o) &&
@ -476,7 +476,7 @@ SQRESULT sq_bindenv(HRABBITVM v,SQInteger idx)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_getclosurename(HRABBITVM v,SQInteger idx) SQRESULT sq_getclosurename(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &o = stack_get(v,idx); SQObjectPtr &o = stack_get(v,idx);
if(!sq_isnativeclosure(o) && if(!sq_isnativeclosure(o) &&
@ -492,7 +492,7 @@ SQRESULT sq_getclosurename(HRABBITVM v,SQInteger idx)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_setclosureroot(HRABBITVM v,SQInteger idx) SQRESULT sq_setclosureroot(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &c = stack_get(v,idx); SQObjectPtr &c = stack_get(v,idx);
SQObject o = stack_get(v, -1); SQObject o = stack_get(v, -1);
@ -505,7 +505,7 @@ SQRESULT sq_setclosureroot(HRABBITVM v,SQInteger idx)
return sq_throwerror(v, _SC("invalid type")); return sq_throwerror(v, _SC("invalid type"));
} }
SQRESULT sq_getclosureroot(HRABBITVM v,SQInteger idx) SQRESULT sq_getclosureroot(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &c = stack_get(v,idx); SQObjectPtr &c = stack_get(v,idx);
if(!sq_isclosure(c)) return sq_throwerror(v, _SC("closure expected")); if(!sq_isclosure(c)) return sq_throwerror(v, _SC("closure expected"));
@ -513,7 +513,7 @@ SQRESULT sq_getclosureroot(HRABBITVM v,SQInteger idx)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_clear(HRABBITVM v,SQInteger idx) SQRESULT sq_clear(HRABBITVM v,int64_t idx)
{ {
SQObject &o=stack_get(v,idx); SQObject &o=stack_get(v,idx);
switch(sq_type(o)) { switch(sq_type(o)) {
@ -604,17 +604,17 @@ SQRELEASEHOOK sq_getsharedreleasehook(HRABBITVM v)
return _ss(v)->_releasehook; return _ss(v)->_releasehook;
} }
void sq_push(HRABBITVM v,SQInteger idx) void sq_push(HRABBITVM v,int64_t idx)
{ {
v->Push(stack_get(v, idx)); v->Push(stack_get(v, idx));
} }
SQObjectType sq_gettype(HRABBITVM v,SQInteger idx) SQObjectType sq_gettype(HRABBITVM v,int64_t idx)
{ {
return sq_type(stack_get(v, idx)); return sq_type(stack_get(v, idx));
} }
SQRESULT sq_typeof(HRABBITVM v,SQInteger idx) SQRESULT sq_typeof(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &o = stack_get(v, idx); SQObjectPtr &o = stack_get(v, idx);
SQObjectPtr res; SQObjectPtr res;
@ -625,7 +625,7 @@ SQRESULT sq_typeof(HRABBITVM v,SQInteger idx)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_tostring(HRABBITVM v,SQInteger idx) SQRESULT sq_tostring(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &o = stack_get(v, idx); SQObjectPtr &o = stack_get(v, idx);
SQObjectPtr res; SQObjectPtr res;
@ -636,13 +636,13 @@ SQRESULT sq_tostring(HRABBITVM v,SQInteger idx)
return SQ_OK; return SQ_OK;
} }
void sq_tobool(HRABBITVM v, SQInteger idx, SQBool *b) void sq_tobool(HRABBITVM v, int64_t idx, SQBool *b)
{ {
SQObjectPtr &o = stack_get(v, idx); SQObjectPtr &o = stack_get(v, idx);
*b = SQVM::IsFalse(o)?SQFalse:SQTrue; *b = SQVM::IsFalse(o)?SQFalse:SQTrue;
} }
SQRESULT sq_getinteger(HRABBITVM v,SQInteger idx,SQInteger *i) SQRESULT sq_getinteger(HRABBITVM v,int64_t idx,int64_t *i)
{ {
SQObjectPtr &o = stack_get(v, idx); SQObjectPtr &o = stack_get(v, idx);
if(sq_isnumeric(o)) { if(sq_isnumeric(o)) {
@ -656,7 +656,7 @@ SQRESULT sq_getinteger(HRABBITVM v,SQInteger idx,SQInteger *i)
return SQ_ERROR; return SQ_ERROR;
} }
SQRESULT sq_getfloat(HRABBITVM v,SQInteger idx,SQFloat *f) SQRESULT sq_getfloat(HRABBITVM v,int64_t idx,float_t *f)
{ {
SQObjectPtr &o = stack_get(v, idx); SQObjectPtr &o = stack_get(v, idx);
if(sq_isnumeric(o)) { if(sq_isnumeric(o)) {
@ -666,7 +666,7 @@ SQRESULT sq_getfloat(HRABBITVM v,SQInteger idx,SQFloat *f)
return SQ_ERROR; return SQ_ERROR;
} }
SQRESULT sq_getbool(HRABBITVM v,SQInteger idx,SQBool *b) SQRESULT sq_getbool(HRABBITVM v,int64_t idx,SQBool *b)
{ {
SQObjectPtr &o = stack_get(v, idx); SQObjectPtr &o = stack_get(v, idx);
if(sq_isbool(o)) { if(sq_isbool(o)) {
@ -676,7 +676,7 @@ SQRESULT sq_getbool(HRABBITVM v,SQInteger idx,SQBool *b)
return SQ_ERROR; return SQ_ERROR;
} }
SQRESULT sq_getstringandsize(HRABBITVM v,SQInteger idx,const SQChar **c,SQInteger *size) SQRESULT sq_getstringandsize(HRABBITVM v,int64_t idx,const SQChar **c,int64_t *size)
{ {
SQObjectPtr *o = NULL; SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_STRING,o); _GETSAFE_OBJ(v, idx, OT_STRING,o);
@ -685,7 +685,7 @@ SQRESULT sq_getstringandsize(HRABBITVM v,SQInteger idx,const SQChar **c,SQIntege
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_getstring(HRABBITVM v,SQInteger idx,const SQChar **c) SQRESULT sq_getstring(HRABBITVM v,int64_t idx,const SQChar **c)
{ {
SQObjectPtr *o = NULL; SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_STRING,o); _GETSAFE_OBJ(v, idx, OT_STRING,o);
@ -693,7 +693,7 @@ SQRESULT sq_getstring(HRABBITVM v,SQInteger idx,const SQChar **c)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_getthread(HRABBITVM v,SQInteger idx,HRABBITVM *thread) SQRESULT sq_getthread(HRABBITVM v,int64_t idx,HRABBITVM *thread)
{ {
SQObjectPtr *o = NULL; SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_THREAD,o); _GETSAFE_OBJ(v, idx, OT_THREAD,o);
@ -701,7 +701,7 @@ SQRESULT sq_getthread(HRABBITVM v,SQInteger idx,HRABBITVM *thread)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_clone(HRABBITVM v,SQInteger idx) SQRESULT sq_clone(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &o = stack_get(v,idx); SQObjectPtr &o = stack_get(v,idx);
v->PushNull(); v->PushNull();
@ -712,7 +712,7 @@ SQRESULT sq_clone(HRABBITVM v,SQInteger idx)
return SQ_OK; return SQ_OK;
} }
SQInteger sq_getsize(HRABBITVM v, SQInteger idx) int64_t sq_getsize(HRABBITVM v, int64_t idx)
{ {
SQObjectPtr &o = stack_get(v, idx); SQObjectPtr &o = stack_get(v, idx);
SQObjectType type = sq_type(o); SQObjectType type = sq_type(o);
@ -728,13 +728,13 @@ SQInteger sq_getsize(HRABBITVM v, SQInteger idx)
} }
} }
SQHash sq_gethash(HRABBITVM v, SQInteger idx) SQHash sq_gethash(HRABBITVM v, int64_t idx)
{ {
SQObjectPtr &o = stack_get(v, idx); SQObjectPtr &o = stack_get(v, idx);
return HashObj(o); return HashObj(o);
} }
SQRESULT sq_getuserdata(HRABBITVM v,SQInteger idx,SQUserPointer *p,SQUserPointer *typetag) SQRESULT sq_getuserdata(HRABBITVM v,int64_t idx,SQUserPointer *p,SQUserPointer *typetag)
{ {
SQObjectPtr *o = NULL; SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_USERDATA,o); _GETSAFE_OBJ(v, idx, OT_USERDATA,o);
@ -745,7 +745,7 @@ SQRESULT sq_getuserdata(HRABBITVM v,SQInteger idx,SQUserPointer *p,SQUserPointer
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_settypetag(HRABBITVM v,SQInteger idx,SQUserPointer typetag) SQRESULT sq_settypetag(HRABBITVM v,int64_t idx,SQUserPointer typetag)
{ {
SQObjectPtr &o = stack_get(v,idx); SQObjectPtr &o = stack_get(v,idx);
switch(sq_type(o)) { switch(sq_type(o)) {
@ -772,7 +772,7 @@ SQRESULT sq_getobjtypetag(const HSQOBJECT *o,SQUserPointer * typetag)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_gettypetag(HRABBITVM v,SQInteger idx,SQUserPointer *typetag) SQRESULT sq_gettypetag(HRABBITVM v,int64_t idx,SQUserPointer *typetag)
{ {
SQObjectPtr &o = stack_get(v,idx); SQObjectPtr &o = stack_get(v,idx);
if (SQ_FAILED(sq_getobjtypetag(&o, typetag))) if (SQ_FAILED(sq_getobjtypetag(&o, typetag)))
@ -780,7 +780,7 @@ SQRESULT sq_gettypetag(HRABBITVM v,SQInteger idx,SQUserPointer *typetag)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_getuserpointer(HRABBITVM v, SQInteger idx, SQUserPointer *p) SQRESULT sq_getuserpointer(HRABBITVM v, int64_t idx, SQUserPointer *p)
{ {
SQObjectPtr *o = NULL; SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_USERPOINTER,o); _GETSAFE_OBJ(v, idx, OT_USERPOINTER,o);
@ -788,7 +788,7 @@ SQRESULT sq_getuserpointer(HRABBITVM v, SQInteger idx, SQUserPointer *p)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_setinstanceup(HRABBITVM v, SQInteger idx, SQUserPointer p) SQRESULT sq_setinstanceup(HRABBITVM v, int64_t idx, SQUserPointer p)
{ {
SQObjectPtr &o = stack_get(v,idx); SQObjectPtr &o = stack_get(v,idx);
if(sq_type(o) != OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance")); if(sq_type(o) != OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance"));
@ -796,7 +796,7 @@ SQRESULT sq_setinstanceup(HRABBITVM v, SQInteger idx, SQUserPointer p)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_setclassudsize(HRABBITVM v, SQInteger idx, SQInteger udsize) SQRESULT sq_setclassudsize(HRABBITVM v, int64_t idx, int64_t udsize)
{ {
SQObjectPtr &o = stack_get(v,idx); SQObjectPtr &o = stack_get(v,idx);
if(sq_type(o) != OT_CLASS) return sq_throwerror(v,_SC("the object is not a class")); if(sq_type(o) != OT_CLASS) return sq_throwerror(v,_SC("the object is not a class"));
@ -806,7 +806,7 @@ SQRESULT sq_setclassudsize(HRABBITVM v, SQInteger idx, SQInteger udsize)
} }
SQRESULT sq_getinstanceup(HRABBITVM v, SQInteger idx, SQUserPointer *p,SQUserPointer typetag) SQRESULT sq_getinstanceup(HRABBITVM v, int64_t idx, SQUserPointer *p,SQUserPointer typetag)
{ {
SQObjectPtr &o = stack_get(v,idx); SQObjectPtr &o = stack_get(v,idx);
if(sq_type(o) != OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance")); if(sq_type(o) != OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance"));
@ -823,21 +823,21 @@ SQRESULT sq_getinstanceup(HRABBITVM v, SQInteger idx, SQUserPointer *p,SQUserPoi
return SQ_OK; return SQ_OK;
} }
SQInteger sq_gettop(HRABBITVM v) int64_t sq_gettop(HRABBITVM v)
{ {
return (v->_top) - v->_stackbase; return (v->_top) - v->_stackbase;
} }
void sq_settop(HRABBITVM v, SQInteger newtop) void sq_settop(HRABBITVM v, int64_t newtop)
{ {
SQInteger top = sq_gettop(v); int64_t top = sq_gettop(v);
if(top > newtop) if(top > newtop)
sq_pop(v, top - newtop); sq_pop(v, top - newtop);
else else
while(top++ < newtop) sq_pushnull(v); while(top++ < newtop) sq_pushnull(v);
} }
void sq_pop(HRABBITVM v, SQInteger nelemstopop) void sq_pop(HRABBITVM v, int64_t nelemstopop)
{ {
assert(v->_top >= nelemstopop); assert(v->_top >= nelemstopop);
v->Pop(nelemstopop); v->Pop(nelemstopop);
@ -850,19 +850,19 @@ void sq_poptop(HRABBITVM v)
} }
void sq_remove(HRABBITVM v, SQInteger idx) void sq_remove(HRABBITVM v, int64_t idx)
{ {
v->Remove(idx); v->Remove(idx);
} }
SQInteger sq_cmp(HRABBITVM v) int64_t sq_cmp(HRABBITVM v)
{ {
SQInteger res; int64_t res;
v->ObjCmp(stack_get(v, -1), stack_get(v, -2),res); v->ObjCmp(stack_get(v, -1), stack_get(v, -2),res);
return res; return res;
} }
SQRESULT sq_newslot(HRABBITVM v, SQInteger idx, SQBool bstatic) SQRESULT sq_newslot(HRABBITVM v, int64_t idx, SQBool bstatic)
{ {
sq_aux_paramscheck(v, 3); sq_aux_paramscheck(v, 3);
SQObjectPtr &self = stack_get(v, idx); SQObjectPtr &self = stack_get(v, idx);
@ -875,7 +875,7 @@ SQRESULT sq_newslot(HRABBITVM v, SQInteger idx, SQBool bstatic)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_deleteslot(HRABBITVM v,SQInteger idx,SQBool pushval) SQRESULT sq_deleteslot(HRABBITVM v,int64_t idx,SQBool pushval)
{ {
sq_aux_paramscheck(v, 2); sq_aux_paramscheck(v, 2);
SQObjectPtr *self; SQObjectPtr *self;
@ -892,7 +892,7 @@ SQRESULT sq_deleteslot(HRABBITVM v,SQInteger idx,SQBool pushval)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_set(HRABBITVM v,SQInteger idx) SQRESULT sq_set(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &self = stack_get(v, idx); SQObjectPtr &self = stack_get(v, idx);
if(v->Set(self, v->GetUp(-2), v->GetUp(-1),DONT_FALL_BACK)) { if(v->Set(self, v->GetUp(-2), v->GetUp(-1),DONT_FALL_BACK)) {
@ -902,7 +902,7 @@ SQRESULT sq_set(HRABBITVM v,SQInteger idx)
return SQ_ERROR; return SQ_ERROR;
} }
SQRESULT sq_rawset(HRABBITVM v,SQInteger idx) SQRESULT sq_rawset(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &self = stack_get(v, idx); SQObjectPtr &self = stack_get(v, idx);
SQObjectPtr &key = v->GetUp(-2); SQObjectPtr &key = v->GetUp(-2);
@ -940,7 +940,7 @@ SQRESULT sq_rawset(HRABBITVM v,SQInteger idx)
v->Raise_IdxError(v->GetUp(-2));return SQ_ERROR; v->Raise_IdxError(v->GetUp(-2));return SQ_ERROR;
} }
SQRESULT sq_newmember(HRABBITVM v,SQInteger idx,SQBool bstatic) SQRESULT sq_newmember(HRABBITVM v,int64_t idx,SQBool bstatic)
{ {
SQObjectPtr &self = stack_get(v, idx); SQObjectPtr &self = stack_get(v, idx);
if(sq_type(self) != OT_CLASS) return sq_throwerror(v, _SC("new member only works with classes")); if(sq_type(self) != OT_CLASS) return sq_throwerror(v, _SC("new member only works with classes"));
@ -954,7 +954,7 @@ SQRESULT sq_newmember(HRABBITVM v,SQInteger idx,SQBool bstatic)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_rawnewmember(HRABBITVM v,SQInteger idx,SQBool bstatic) SQRESULT sq_rawnewmember(HRABBITVM v,int64_t idx,SQBool bstatic)
{ {
SQObjectPtr &self = stack_get(v, idx); SQObjectPtr &self = stack_get(v, idx);
if(sq_type(self) != OT_CLASS) return sq_throwerror(v, _SC("new member only works with classes")); if(sq_type(self) != OT_CLASS) return sq_throwerror(v, _SC("new member only works with classes"));
@ -968,7 +968,7 @@ SQRESULT sq_rawnewmember(HRABBITVM v,SQInteger idx,SQBool bstatic)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_setdelegate(HRABBITVM v,SQInteger idx) SQRESULT sq_setdelegate(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &self = stack_get(v, idx); SQObjectPtr &self = stack_get(v, idx);
SQObjectPtr &mt = v->GetUp(-1); SQObjectPtr &mt = v->GetUp(-1);
@ -999,7 +999,7 @@ SQRESULT sq_setdelegate(HRABBITVM v,SQInteger idx)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_rawdeleteslot(HRABBITVM v,SQInteger idx,SQBool pushval) SQRESULT sq_rawdeleteslot(HRABBITVM v,int64_t idx,SQBool pushval)
{ {
sq_aux_paramscheck(v, 2); sq_aux_paramscheck(v, 2);
SQObjectPtr *self; SQObjectPtr *self;
@ -1016,7 +1016,7 @@ SQRESULT sq_rawdeleteslot(HRABBITVM v,SQInteger idx,SQBool pushval)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_getdelegate(HRABBITVM v,SQInteger idx) SQRESULT sq_getdelegate(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &self=stack_get(v,idx); SQObjectPtr &self=stack_get(v,idx);
switch(sq_type(self)){ switch(sq_type(self)){
@ -1034,7 +1034,7 @@ SQRESULT sq_getdelegate(HRABBITVM v,SQInteger idx)
} }
SQRESULT sq_get(HRABBITVM v,SQInteger idx) SQRESULT sq_get(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &self=stack_get(v,idx); SQObjectPtr &self=stack_get(v,idx);
SQObjectPtr &obj = v->GetUp(-1); SQObjectPtr &obj = v->GetUp(-1);
@ -1044,7 +1044,7 @@ SQRESULT sq_get(HRABBITVM v,SQInteger idx)
return SQ_ERROR; return SQ_ERROR;
} }
SQRESULT sq_rawget(HRABBITVM v,SQInteger idx) SQRESULT sq_rawget(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &self=stack_get(v,idx); SQObjectPtr &self=stack_get(v,idx);
SQObjectPtr &obj = v->GetUp(-1); SQObjectPtr &obj = v->GetUp(-1);
@ -1081,19 +1081,19 @@ SQRESULT sq_rawget(HRABBITVM v,SQInteger idx)
return sq_throwerror(v,_SC("the index doesn't exist")); return sq_throwerror(v,_SC("the index doesn't exist"));
} }
SQRESULT sq_getstackobj(HRABBITVM v,SQInteger idx,HSQOBJECT *po) SQRESULT sq_getstackobj(HRABBITVM v,int64_t idx,HSQOBJECT *po)
{ {
*po=stack_get(v,idx); *po=stack_get(v,idx);
return SQ_OK; return SQ_OK;
} }
const SQChar *sq_getlocal(HRABBITVM v,SQUnsignedInteger level,SQUnsignedInteger idx) const SQChar *sq_getlocal(HRABBITVM v,uint64_t level,uint64_t idx)
{ {
SQUnsignedInteger cstksize=v->_callsstacksize; uint64_t cstksize=v->_callsstacksize;
SQUnsignedInteger lvl=(cstksize-level)-1; uint64_t lvl=(cstksize-level)-1;
SQInteger stackbase=v->_stackbase; int64_t stackbase=v->_stackbase;
if(lvl<cstksize){ if(lvl<cstksize){
for(SQUnsignedInteger i=0;i<level;i++){ for(uint64_t i=0;i<level;i++){
SQVM::CallInfo &ci=v->_callsstack[(cstksize-i)-1]; SQVM::CallInfo &ci=v->_callsstack[(cstksize-i)-1];
stackbase-=ci._prevstkbase; stackbase-=ci._prevstkbase;
} }
@ -1102,12 +1102,12 @@ const SQChar *sq_getlocal(HRABBITVM v,SQUnsignedInteger level,SQUnsignedInteger
return NULL; return NULL;
SQClosure *c=_closure(ci._closure); SQClosure *c=_closure(ci._closure);
SQFunctionProto *func=c->_function; SQFunctionProto *func=c->_function;
if(func->_noutervalues > (SQInteger)idx) { if(func->_noutervalues > (int64_t)idx) {
v->Push(*_outer(c->_outervalues[idx])->_valptr); v->Push(*_outer(c->_outervalues[idx])->_valptr);
return _stringval(func->_outervalues[idx]._name); return _stringval(func->_outervalues[idx]._name);
} }
idx -= func->_noutervalues; idx -= func->_noutervalues;
return func->GetLocal(v,stackbase,idx,(SQInteger)(ci._ip-func->_instructions)-1); return func->GetLocal(v,stackbase,idx,(int64_t)(ci._ip-func->_instructions)-1);
} }
return NULL; return NULL;
} }
@ -1146,9 +1146,9 @@ void sq_getlasterror(HRABBITVM v)
v->Push(v->_lasterror); v->Push(v->_lasterror);
} }
SQRESULT sq_reservestack(HRABBITVM v,SQInteger nsize) SQRESULT sq_reservestack(HRABBITVM v,int64_t nsize)
{ {
if (((SQUnsignedInteger)v->_top + nsize) > v->_stack.size()) { if (((uint64_t)v->_top + nsize) > v->_stack.size()) {
if(v->_nmetamethodscall) { if(v->_nmetamethodscall) {
return sq_throwerror(v,_SC("cannot resize stack while in a metamethod")); return sq_throwerror(v,_SC("cannot resize stack while in a metamethod"));
} }
@ -1171,7 +1171,7 @@ SQRESULT sq_resume(HRABBITVM v,SQBool retval,SQBool raiseerror)
return sq_throwerror(v,_SC("only generators can be resumed")); return sq_throwerror(v,_SC("only generators can be resumed"));
} }
SQRESULT sq_call(HRABBITVM v,SQInteger params,SQBool retval,SQBool raiseerror) SQRESULT sq_call(HRABBITVM v,int64_t params,SQBool retval,SQBool raiseerror)
{ {
SQObjectPtr res; SQObjectPtr res;
if(v->Call(v->GetUp(-(params+1)),params,v->_top-params,res,raiseerror?true:false)){ if(v->Call(v->GetUp(-(params+1)),params,v->_top-params,res,raiseerror?true:false)){
@ -1193,7 +1193,7 @@ SQRESULT sq_call(HRABBITVM v,SQInteger params,SQBool retval,SQBool raiseerror)
return sq_throwerror(v,_SC("call failed")); return sq_throwerror(v,_SC("call failed"));
} }
SQRESULT sq_tailcall(HRABBITVM v, SQInteger nparams) SQRESULT sq_tailcall(HRABBITVM v, int64_t nparams)
{ {
SQObjectPtr &res = v->GetUp(-(nparams + 1)); SQObjectPtr &res = v->GetUp(-(nparams + 1));
if (sq_type(res) != OT_CLOSURE) { if (sq_type(res) != OT_CLOSURE) {
@ -1205,7 +1205,7 @@ SQRESULT sq_tailcall(HRABBITVM v, SQInteger nparams)
return sq_throwerror(v, _SC("generators cannot be tail called")); return sq_throwerror(v, _SC("generators cannot be tail called"));
} }
SQInteger stackbase = (v->_top - nparams) - v->_stackbase; int64_t stackbase = (v->_top - nparams) - v->_stackbase;
if (!v->TailCall(clo, stackbase, nparams)) { if (!v->TailCall(clo, stackbase, nparams)) {
return SQ_ERROR; return SQ_ERROR;
} }
@ -1222,7 +1222,7 @@ SQRESULT sq_wakeupvm(HRABBITVM v,SQBool wakeupret,SQBool retval,SQBool raiseerro
SQObjectPtr ret; SQObjectPtr ret;
if(!v->_suspended) if(!v->_suspended)
return sq_throwerror(v,_SC("cannot resume a vm that is not running any code")); return sq_throwerror(v,_SC("cannot resume a vm that is not running any code"));
SQInteger target = v->_suspended_target; int64_t target = v->_suspended_target;
if(wakeupret) { if(wakeupret) {
if(target != -1) { if(target != -1) {
v->GetAt(v->_stackbase+v->_suspended_target)=v->GetUp(-1); //retval v->GetAt(v->_stackbase+v->_suspended_target)=v->GetUp(-1); //retval
@ -1239,7 +1239,7 @@ SQRESULT sq_wakeupvm(HRABBITVM v,SQBool wakeupret,SQBool retval,SQBool raiseerro
return SQ_OK; return SQ_OK;
} }
void sq_setreleasehook(HRABBITVM v,SQInteger idx,SQRELEASEHOOK hook) void sq_setreleasehook(HRABBITVM v,int64_t idx,SQRELEASEHOOK hook)
{ {
SQObjectPtr &ud=stack_get(v,idx); SQObjectPtr &ud=stack_get(v,idx);
switch(sq_type(ud) ) { switch(sq_type(ud) ) {
@ -1257,7 +1257,7 @@ void sq_setreleasehook(HRABBITVM v,SQInteger idx,SQRELEASEHOOK hook)
} }
} }
SQRELEASEHOOK sq_getreleasehook(HRABBITVM v,SQInteger idx) SQRELEASEHOOK sq_getreleasehook(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &ud=stack_get(v,idx); SQObjectPtr &ud=stack_get(v,idx);
switch(sq_type(ud) ) { switch(sq_type(ud) ) {
@ -1309,7 +1309,7 @@ SQRESULT sq_readclosure(HRABBITVM v,SQREADFUNC r,SQUserPointer up)
return SQ_OK; return SQ_OK;
} }
SQChar *sq_getscratchpad(HRABBITVM v,SQInteger minsize) SQChar *sq_getscratchpad(HRABBITVM v,int64_t minsize)
{ {
return _ss(v)->GetScratchPad(minsize); return _ss(v)->GetScratchPad(minsize);
} }
@ -1320,7 +1320,7 @@ SQRESULT sq_resurrectunreachable(HRABBITVM v)
} }
// TODO: Remove this... // TODO: Remove this...
SQInteger sq_collectgarbage(HRABBITVM v) int64_t sq_collectgarbage(HRABBITVM v)
{ {
return -1; return -1;
} }
@ -1335,7 +1335,7 @@ SQRESULT sq_getcallee(HRABBITVM v)
return sq_throwerror(v,_SC("no closure in the calls stack")); return sq_throwerror(v,_SC("no closure in the calls stack"));
} }
const SQChar *sq_getfreevariable(HRABBITVM v,SQInteger idx,SQUnsignedInteger nval) const SQChar *sq_getfreevariable(HRABBITVM v,int64_t idx,uint64_t nval)
{ {
SQObjectPtr &self=stack_get(v,idx); SQObjectPtr &self=stack_get(v,idx);
const SQChar *name = NULL; const SQChar *name = NULL;
@ -1344,7 +1344,7 @@ const SQChar *sq_getfreevariable(HRABBITVM v,SQInteger idx,SQUnsignedInteger nva
case OT_CLOSURE:{ case OT_CLOSURE:{
SQClosure *clo = _closure(self); SQClosure *clo = _closure(self);
SQFunctionProto *fp = clo->_function; SQFunctionProto *fp = clo->_function;
if(((SQUnsignedInteger)fp->_noutervalues) > nval) { if(((uint64_t)fp->_noutervalues) > nval) {
v->Push(*(_outer(clo->_outervalues[nval])->_valptr)); v->Push(*(_outer(clo->_outervalues[nval])->_valptr));
SQOuterVar &ov = fp->_outervalues[nval]; SQOuterVar &ov = fp->_outervalues[nval];
name = _stringval(ov._name); name = _stringval(ov._name);
@ -1364,14 +1364,14 @@ const SQChar *sq_getfreevariable(HRABBITVM v,SQInteger idx,SQUnsignedInteger nva
return name; return name;
} }
SQRESULT sq_setfreevariable(HRABBITVM v,SQInteger idx,SQUnsignedInteger nval) SQRESULT sq_setfreevariable(HRABBITVM v,int64_t idx,uint64_t nval)
{ {
SQObjectPtr &self=stack_get(v,idx); SQObjectPtr &self=stack_get(v,idx);
switch(sq_type(self)) switch(sq_type(self))
{ {
case OT_CLOSURE:{ case OT_CLOSURE:{
SQFunctionProto *fp = _closure(self)->_function; SQFunctionProto *fp = _closure(self)->_function;
if(((SQUnsignedInteger)fp->_noutervalues) > nval){ if(((uint64_t)fp->_noutervalues) > nval){
*(_outer(_closure(self)->_outervalues[nval])->_valptr) = stack_get(v,-1); *(_outer(_closure(self)->_outervalues[nval])->_valptr) = stack_get(v,-1);
} }
else return sq_throwerror(v,_SC("invalid free var index")); else return sq_throwerror(v,_SC("invalid free var index"));
@ -1390,7 +1390,7 @@ SQRESULT sq_setfreevariable(HRABBITVM v,SQInteger idx,SQUnsignedInteger nval)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_setattributes(HRABBITVM v,SQInteger idx) SQRESULT sq_setattributes(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr *o = NULL; SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_CLASS,o); _GETSAFE_OBJ(v, idx, OT_CLASS,o);
@ -1412,7 +1412,7 @@ SQRESULT sq_setattributes(HRABBITVM v,SQInteger idx)
return sq_throwerror(v,_SC("wrong index")); return sq_throwerror(v,_SC("wrong index"));
} }
SQRESULT sq_getattributes(HRABBITVM v,SQInteger idx) SQRESULT sq_getattributes(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr *o = NULL; SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_CLASS,o); _GETSAFE_OBJ(v, idx, OT_CLASS,o);
@ -1432,7 +1432,7 @@ SQRESULT sq_getattributes(HRABBITVM v,SQInteger idx)
return sq_throwerror(v,_SC("wrong index")); return sq_throwerror(v,_SC("wrong index"));
} }
SQRESULT sq_getmemberhandle(HRABBITVM v,SQInteger idx,HSQMEMBERHANDLE *handle) SQRESULT sq_getmemberhandle(HRABBITVM v,int64_t idx,HSQMEMBERHANDLE *handle)
{ {
SQObjectPtr *o = NULL; SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_CLASS,o); _GETSAFE_OBJ(v, idx, OT_CLASS,o);
@ -1479,7 +1479,7 @@ SQRESULT _getmemberbyhandle(HRABBITVM v,SQObjectPtr &self,const HSQMEMBERHANDLE
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_getbyhandle(HRABBITVM v,SQInteger idx,const HSQMEMBERHANDLE *handle) SQRESULT sq_getbyhandle(HRABBITVM v,int64_t idx,const HSQMEMBERHANDLE *handle)
{ {
SQObjectPtr &self = stack_get(v,idx); SQObjectPtr &self = stack_get(v,idx);
SQObjectPtr *val = NULL; SQObjectPtr *val = NULL;
@ -1490,7 +1490,7 @@ SQRESULT sq_getbyhandle(HRABBITVM v,SQInteger idx,const HSQMEMBERHANDLE *handle)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_setbyhandle(HRABBITVM v,SQInteger idx,const HSQMEMBERHANDLE *handle) SQRESULT sq_setbyhandle(HRABBITVM v,int64_t idx,const HSQMEMBERHANDLE *handle)
{ {
SQObjectPtr &self = stack_get(v,idx); SQObjectPtr &self = stack_get(v,idx);
SQObjectPtr &newval = stack_get(v,-1); SQObjectPtr &newval = stack_get(v,-1);
@ -1503,7 +1503,7 @@ SQRESULT sq_setbyhandle(HRABBITVM v,SQInteger idx,const HSQMEMBERHANDLE *handle)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_getbase(HRABBITVM v,SQInteger idx) SQRESULT sq_getbase(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr *o = NULL; SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_CLASS,o); _GETSAFE_OBJ(v, idx, OT_CLASS,o);
@ -1514,7 +1514,7 @@ SQRESULT sq_getbase(HRABBITVM v,SQInteger idx)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_getclass(HRABBITVM v,SQInteger idx) SQRESULT sq_getclass(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr *o = NULL; SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_INSTANCE,o); _GETSAFE_OBJ(v, idx, OT_INSTANCE,o);
@ -1522,7 +1522,7 @@ SQRESULT sq_getclass(HRABBITVM v,SQInteger idx)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_createinstance(HRABBITVM v,SQInteger idx) SQRESULT sq_createinstance(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr *o = NULL; SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_CLASS,o); _GETSAFE_OBJ(v, idx, OT_CLASS,o);
@ -1530,7 +1530,7 @@ SQRESULT sq_createinstance(HRABBITVM v,SQInteger idx)
return SQ_OK; return SQ_OK;
} }
void sq_weakref(HRABBITVM v,SQInteger idx) void sq_weakref(HRABBITVM v,int64_t idx)
{ {
SQObject &o=stack_get(v,idx); SQObject &o=stack_get(v,idx);
if(ISREFCOUNTED(sq_type(o))) { if(ISREFCOUNTED(sq_type(o))) {
@ -1540,7 +1540,7 @@ void sq_weakref(HRABBITVM v,SQInteger idx)
v->Push(o); v->Push(o);
} }
SQRESULT sq_getweakrefval(HRABBITVM v,SQInteger idx) SQRESULT sq_getweakrefval(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr &o = stack_get(v,idx); SQObjectPtr &o = stack_get(v,idx);
if(sq_type(o) != OT_WEAKREF) { if(sq_type(o) != OT_WEAKREF) {
@ -1569,7 +1569,7 @@ SQRESULT sq_getdefaultdelegate(HRABBITVM v,SQObjectType t)
return SQ_OK; return SQ_OK;
} }
SQRESULT sq_next(HRABBITVM v,SQInteger idx) SQRESULT sq_next(HRABBITVM v,int64_t idx)
{ {
SQObjectPtr o=stack_get(v,idx),&refpos = stack_get(v,-1),realkey,val; SQObjectPtr o=stack_get(v,idx),&refpos = stack_get(v,-1),realkey,val;
if(sq_type(o) == OT_GENERATOR) { if(sq_type(o) == OT_GENERATOR) {
@ -1588,11 +1588,11 @@ SQRESULT sq_next(HRABBITVM v,SQInteger idx)
struct BufState{ struct BufState{
const SQChar *buf; const SQChar *buf;
SQInteger ptr; int64_t ptr;
SQInteger size; int64_t size;
}; };
SQInteger buf_lexfeed(SQUserPointer file) int64_t buf_lexfeed(SQUserPointer file)
{ {
BufState *buf=(BufState*)file; BufState *buf=(BufState*)file;
if(buf->size<(buf->ptr+1)) if(buf->size<(buf->ptr+1))
@ -1600,7 +1600,7 @@ SQInteger buf_lexfeed(SQUserPointer file)
return buf->buf[buf->ptr++]; return buf->buf[buf->ptr++];
} }
SQRESULT sq_compilebuffer(HRABBITVM v,const SQChar *s,SQInteger size,const SQChar *sourcename,SQBool raiseerror) { SQRESULT sq_compilebuffer(HRABBITVM v,const SQChar *s,int64_t size,const SQChar *sourcename,SQBool raiseerror) {
BufState buf; BufState buf;
buf.buf = s; buf.buf = s;
buf.size = size; buf.size = size;
@ -1608,7 +1608,7 @@ SQRESULT sq_compilebuffer(HRABBITVM v,const SQChar *s,SQInteger size,const SQCha
return sq_compile(v, buf_lexfeed, &buf, sourcename, raiseerror); return sq_compile(v, buf_lexfeed, &buf, sourcename, raiseerror);
} }
void sq_move(HRABBITVM dest,HRABBITVM src,SQInteger idx) void sq_move(HRABBITVM dest,HRABBITVM src,int64_t idx)
{ {
dest->Push(stack_get(src,idx)); dest->Push(stack_get(src,idx));
} }
@ -1629,17 +1629,17 @@ SQPRINTFUNCTION sq_geterrorfunc(HRABBITVM v)
return _ss(v)->_errorfunc; return _ss(v)->_errorfunc;
} }
void *sq_malloc(SQUnsignedInteger size) void *sq_malloc(uint64_t size)
{ {
return SQ_MALLOC(size); return SQ_MALLOC(size);
} }
void *sq_realloc(void* p,SQUnsignedInteger oldsize,SQUnsignedInteger newsize) void *sq_realloc(void* p,uint64_t oldsize,uint64_t newsize)
{ {
return SQ_REALLOC(p,oldsize,newsize); return SQ_REALLOC(p,oldsize,newsize);
} }
void sq_free(void *p,SQUnsignedInteger size) void sq_free(void *p,uint64_t size)
{ {
SQ_FREE(p,size); SQ_FREE(p,size);
} }

36
rabbit/sqarray.hpp
View File

@ -7,17 +7,17 @@
*/ */
#pragma once #pragma once
struct SQArray : public CHAINABLE_OBJ struct SQArray : public SQRefCounted
{ {
private: private:
SQArray(SQSharedState *ss,SQInteger nsize) { SQArray(SQSharedState *ss,int64_t nsize) {
_values.resize(nsize); _values.resize(nsize);
} }
~SQArray() ~SQArray()
{ {
} }
public: public:
static SQArray* Create(SQSharedState *ss,SQInteger nInitialSize){ static SQArray* Create(SQSharedState *ss,int64_t nInitialSize){
SQArray *newarray=(SQArray*)SQ_MALLOC(sizeof(SQArray)); SQArray *newarray=(SQArray*)SQ_MALLOC(sizeof(SQArray));
new (newarray) SQArray(ss,nInitialSize); new (newarray) SQArray(ss,nInitialSize);
return newarray; return newarray;
@ -25,29 +25,29 @@ public:
void Finalize(){ void Finalize(){
_values.resize(0); _values.resize(0);
} }
bool Get(const SQInteger nidx,SQObjectPtr &val) bool Get(const int64_t nidx,SQObjectPtr &val)
{ {
if(nidx>=0 && nidx<(SQInteger)_values.size()){ if(nidx>=0 && nidx<(int64_t)_values.size()){
SQObjectPtr &o = _values[nidx]; SQObjectPtr &o = _values[nidx];
val = _realval(o); val = _realval(o);
return true; return true;
} }
else return false; else return false;
} }
bool Set(const SQInteger nidx,const SQObjectPtr &val) bool Set(const int64_t nidx,const SQObjectPtr &val)
{ {
if(nidx>=0 && nidx<(SQInteger)_values.size()){ if(nidx>=0 && nidx<(int64_t)_values.size()){
_values[nidx]=val; _values[nidx]=val;
return true; return true;
} }
else return false; else return false;
} }
SQInteger Next(const SQObjectPtr &refpos,SQObjectPtr &outkey,SQObjectPtr &outval) int64_t Next(const SQObjectPtr &refpos,SQObjectPtr &outkey,SQObjectPtr &outval)
{ {
SQUnsignedInteger idx=TranslateIndex(refpos); uint64_t idx=TranslateIndex(refpos);
while(idx<_values.size()){ while(idx<_values.size()){
//first found //first found
outkey=(SQInteger)idx; outkey=(int64_t)idx;
SQObjectPtr &o = _values[idx]; SQObjectPtr &o = _values[idx];
outval = _realval(o); outval = _realval(o);
//return idx for the next iteration //return idx for the next iteration
@ -57,20 +57,20 @@ public:
return -1; return -1;
} }
SQArray *Clone(){SQArray *anew=Create(NULL,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();} int64_t Size() const {return _values.size();}
void Resize(SQInteger size) void Resize(int64_t size)
{ {
SQObjectPtr _null; SQObjectPtr _null;
Resize(size,_null); Resize(size,_null);
} }
void Resize(SQInteger size,SQObjectPtr &fill) { _values.resize(size,fill); ShrinkIfNeeded(); } void Resize(int64_t size,SQObjectPtr &fill) { _values.resize(size,fill); ShrinkIfNeeded(); }
void Reserve(SQInteger size) { _values.reserve(size); } void Reserve(int64_t size) { _values.reserve(size); }
void Append(const SQObject &o){_values.push_back(o);} void Append(const SQObject &o){_values.push_back(o);}
void Extend(const SQArray *a); void Extend(const SQArray *a);
SQObjectPtr &Top(){return _values.top();} SQObjectPtr &Top(){return _values.top();}
void Pop(){_values.pop_back(); ShrinkIfNeeded(); } void Pop(){_values.pop_back(); ShrinkIfNeeded(); }
bool Insert(SQInteger idx,const SQObject &val){ bool Insert(int64_t idx,const SQObject &val){
if(idx < 0 || idx > (SQInteger)_values.size()) if(idx < 0 || idx > (int64_t)_values.size())
return false; return false;
_values.insert(idx,val); _values.insert(idx,val);
return true; return true;
@ -79,8 +79,8 @@ public:
if(_values.size() <= _values.capacity()>>2) //shrink the array if(_values.size() <= _values.capacity()>>2) //shrink the array
_values.shrinktofit(); _values.shrinktofit();
} }
bool Remove(SQInteger idx){ bool Remove(int64_t idx){
if(idx < 0 || idx >= (SQInteger)_values.size()) if(idx < 0 || idx >= (int64_t)_values.size())
return false; return false;
_values.remove(idx); _values.remove(idx);
ShrinkIfNeeded(); ShrinkIfNeeded();

292
rabbit/sqbaselib.cpp
View File

@ -17,7 +17,7 @@
#include <stdarg.h> #include <stdarg.h>
#include <ctype.h> #include <ctype.h>
static bool str2num(const SQChar *s,SQObjectPtr &res,SQInteger base) static bool str2num(const SQChar *s,SQObjectPtr &res,int64_t base)
{ {
SQChar *end; SQChar *end;
const SQChar *e = s; const SQChar *e = s;
@ -33,37 +33,37 @@ static bool str2num(const SQChar *s,SQObjectPtr &res,SQInteger base)
e++; e++;
} }
if(isfloat){ if(isfloat){
SQFloat r = SQFloat(scstrtod(s,&end)); float_t r = float_t(scstrtod(s,&end));
if(s == end) return false; if(s == end) return false;
res = r; res = r;
} }
else{ else{
SQInteger r = SQInteger(scstrtol(s,&end,(int)base)); int64_t r = int64_t(scstrtol(s,&end,(int)base));
if(s == end) return false; if(s == end) return false;
res = r; res = r;
} }
return true; return true;
} }
static SQInteger base_dummy(HRABBITVM SQ_UNUSED_ARG(v)) static int64_t base_dummy(HRABBITVM SQ_UNUSED_ARG(v))
{ {
return 0; return 0;
} }
static SQInteger base_getroottable(HRABBITVM v) static int64_t base_getroottable(HRABBITVM v)
{ {
v->Push(v->_roottable); v->Push(v->_roottable);
return 1; return 1;
} }
static SQInteger base_getconsttable(HRABBITVM v) static int64_t base_getconsttable(HRABBITVM v)
{ {
v->Push(_ss(v)->_consts); v->Push(_ss(v)->_consts);
return 1; return 1;
} }
static SQInteger base_setroottable(HRABBITVM v) static int64_t 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;
@ -71,7 +71,7 @@ static SQInteger base_setroottable(HRABBITVM v)
return 1; return 1;
} }
static SQInteger base_setconsttable(HRABBITVM v) static int64_t 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;
@ -79,19 +79,19 @@ static SQInteger base_setconsttable(HRABBITVM v)
return 1; return 1;
} }
static SQInteger base_seterrorhandler(HRABBITVM v) static int64_t base_seterrorhandler(HRABBITVM v)
{ {
sq_seterrorhandler(v); sq_seterrorhandler(v);
return 0; return 0;
} }
static SQInteger base_setdebughook(HRABBITVM v) static int64_t base_setdebughook(HRABBITVM v)
{ {
sq_setdebughook(v); sq_setdebughook(v);
return 0; return 0;
} }
static SQInteger base_enabledebuginfo(HRABBITVM v) static int64_t base_enabledebuginfo(HRABBITVM v)
{ {
SQObjectPtr &o=stack_get(v,2); SQObjectPtr &o=stack_get(v,2);
@ -99,10 +99,10 @@ static SQInteger base_enabledebuginfo(HRABBITVM v)
return 0; return 0;
} }
static SQInteger __getcallstackinfos(HRABBITVM v,SQInteger level) static int64_t __getcallstackinfos(HRABBITVM v,int64_t level)
{ {
SQStackInfos si; SQStackInfos si;
SQInteger seq = 0; int64_t seq = 0;
const SQChar *name = NULL; const SQChar *name = NULL;
if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si))) if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si)))
@ -137,17 +137,17 @@ static SQInteger __getcallstackinfos(HRABBITVM v,SQInteger level)
return 0; return 0;
} }
static SQInteger base_getstackinfos(HRABBITVM v) static int64_t base_getstackinfos(HRABBITVM v)
{ {
SQInteger level; int64_t level;
sq_getinteger(v, -1, &level); sq_getinteger(v, -1, &level);
return __getcallstackinfos(v,level); return __getcallstackinfos(v,level);
} }
static SQInteger base_assert(HRABBITVM v) static int64_t base_assert(HRABBITVM v)
{ {
if(SQVM::IsFalse(stack_get(v,2))){ if(SQVM::IsFalse(stack_get(v,2))){
SQInteger top = sq_gettop(v); int64_t top = sq_gettop(v);
if (top>2 && SQ_SUCCEEDED(sq_tostring(v,3))) { if (top>2 && SQ_SUCCEEDED(sq_tostring(v,3))) {
const SQChar *str = 0; const SQChar *str = 0;
if (SQ_SUCCEEDED(sq_getstring(v,-1,&str))) { if (SQ_SUCCEEDED(sq_getstring(v,-1,&str))) {
@ -159,9 +159,9 @@ static SQInteger base_assert(HRABBITVM v)
return 0; return 0;
} }
static SQInteger get_slice_params(HRABBITVM v,SQInteger &sidx,SQInteger &eidx,SQObjectPtr &o) static int64_t get_slice_params(HRABBITVM v,int64_t &sidx,int64_t &eidx,SQObjectPtr &o)
{ {
SQInteger top = sq_gettop(v); int64_t top = sq_gettop(v);
sidx=0; sidx=0;
eidx=0; eidx=0;
o=stack_get(v,1); o=stack_get(v,1);
@ -183,7 +183,7 @@ static SQInteger get_slice_params(HRABBITVM v,SQInteger &sidx,SQInteger &eidx,SQ
return 1; return 1;
} }
static SQInteger base_print(HRABBITVM v) static int64_t base_print(HRABBITVM v)
{ {
const SQChar *str; const SQChar *str;
if(SQ_SUCCEEDED(sq_tostring(v,2))) if(SQ_SUCCEEDED(sq_tostring(v,2)))
@ -196,7 +196,7 @@ static SQInteger base_print(HRABBITVM v)
return SQ_ERROR; return SQ_ERROR;
} }
static SQInteger base_error(HRABBITVM v) static int64_t base_error(HRABBITVM v)
{ {
const SQChar *str; const SQChar *str;
if(SQ_SUCCEEDED(sq_tostring(v,2))) if(SQ_SUCCEEDED(sq_tostring(v,2)))
@ -209,11 +209,11 @@ static SQInteger base_error(HRABBITVM v)
return SQ_ERROR; return SQ_ERROR;
} }
static SQInteger base_compilestring(HRABBITVM v) static int64_t base_compilestring(HRABBITVM v)
{ {
SQInteger nargs=sq_gettop(v); int64_t nargs=sq_gettop(v);
const SQChar *src=NULL,*name=_SC("unnamedbuffer"); const SQChar *src=NULL,*name=_SC("unnamedbuffer");
SQInteger size; int64_t size;
sq_getstring(v,2,&src); sq_getstring(v,2,&src);
size=sq_getsize(v,2); size=sq_getsize(v,2);
if(nargs>2){ if(nargs>2){
@ -225,21 +225,21 @@ static SQInteger base_compilestring(HRABBITVM v)
return SQ_ERROR; return SQ_ERROR;
} }
static SQInteger base_newthread(HRABBITVM v) static int64_t base_newthread(HRABBITVM v)
{ {
SQObjectPtr &func = stack_get(v,2); SQObjectPtr &func = stack_get(v,2);
SQInteger stksize = (_closure(func)->_function->_stacksize << 1) +2; int64_t stksize = (_closure(func)->_function->_stacksize << 1) +2;
HRABBITVM 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(HRABBITVM v) static int64_t base_suspend(HRABBITVM v)
{ {
return sq_suspendvm(v); return sq_suspendvm(v);
} }
static SQInteger base_array(HRABBITVM v) static int64_t base_array(HRABBITVM v)
{ {
SQArray *a; SQArray *a;
SQObject &size = stack_get(v,2); SQObject &size = stack_get(v,2);
@ -254,14 +254,14 @@ static SQInteger base_array(HRABBITVM v)
return 1; return 1;
} }
static SQInteger base_type(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t base_callee(HRABBITVM v)
{ {
if(v->_callsstacksize > 1) if(v->_callsstacksize > 1)
{ {
@ -296,7 +296,7 @@ static const SQRegFunction base_funcs[]={
void sq_base_register(HRABBITVM v) void sq_base_register(HRABBITVM v)
{ {
SQInteger i=0; int64_t i=0;
sq_pushroottable(v); sq_pushroottable(v);
while(base_funcs[i].name!=0) { while(base_funcs[i].name!=0) {
sq_pushstring(v,base_funcs[i].name,-1); sq_pushstring(v,base_funcs[i].name,-1);
@ -317,21 +317,21 @@ void sq_base_register(HRABBITVM v)
sq_pushinteger(v,sizeof(SQChar)); sq_pushinteger(v,sizeof(SQChar));
sq_newslot(v,-3, SQFalse); sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_intsize_"),-1); sq_pushstring(v,_SC("_intsize_"),-1);
sq_pushinteger(v,sizeof(SQInteger)); sq_pushinteger(v,sizeof(int64_t));
sq_newslot(v,-3, SQFalse); sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_floatsize_"),-1); sq_pushstring(v,_SC("_floatsize_"),-1);
sq_pushinteger(v,sizeof(SQFloat)); sq_pushinteger(v,sizeof(float_t));
sq_newslot(v,-3, SQFalse); sq_newslot(v,-3, SQFalse);
sq_pop(v,1); sq_pop(v,1);
} }
static SQInteger default_delegate_len(HRABBITVM v) static int64_t default_delegate_len(HRABBITVM v)
{ {
v->Push(SQInteger(sq_getsize(v,1))); v->Push(int64_t(sq_getsize(v,1)));
return 1; return 1;
} }
static SQInteger default_delegate_tofloat(HRABBITVM v) static int64_t 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)){
@ -347,7 +347,7 @@ static SQInteger default_delegate_tofloat(HRABBITVM v)
v->Push(SQObjectPtr(tofloat(o))); v->Push(SQObjectPtr(tofloat(o)));
break; break;
case OT_BOOL: case OT_BOOL:
v->Push(SQObjectPtr((SQFloat)(_integer(o)?1:0))); v->Push(SQObjectPtr((float_t)(_integer(o)?1:0)));
break; break;
default: default:
v->PushNull(); v->PushNull();
@ -356,10 +356,10 @@ static SQInteger default_delegate_tofloat(HRABBITVM v)
return 1; return 1;
} }
static SQInteger default_delegate_tointeger(HRABBITVM v) static int64_t default_delegate_tointeger(HRABBITVM v)
{ {
SQObjectPtr &o=stack_get(v,1); SQObjectPtr &o=stack_get(v,1);
SQInteger base = 10; int64_t base = 10;
if(sq_gettop(v) > 1) { if(sq_gettop(v) > 1) {
sq_getinteger(v,2,&base); sq_getinteger(v,2,&base);
} }
@ -376,7 +376,7 @@ static SQInteger default_delegate_tointeger(HRABBITVM v)
v->Push(SQObjectPtr(tointeger(o))); v->Push(SQObjectPtr(tointeger(o)));
break; break;
case OT_BOOL: case OT_BOOL:
v->Push(SQObjectPtr(_integer(o)?(SQInteger)1:(SQInteger)0)); v->Push(SQObjectPtr(_integer(o)?(int64_t)1:(int64_t)0));
break; break;
default: default:
v->PushNull(); v->PushNull();
@ -385,26 +385,26 @@ static SQInteger default_delegate_tointeger(HRABBITVM v)
return 1; return 1;
} }
static SQInteger default_delegate_tostring(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t obj_delegate_weakref(HRABBITVM v)
{ {
sq_weakref(v,1); sq_weakref(v,1);
return 1; return 1;
} }
static SQInteger obj_clear(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t 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);
@ -417,7 +417,7 @@ static SQInteger number_delegate_tochar(HRABBITVM v)
///////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////
//TABLE DEFAULT DELEGATE //TABLE DEFAULT DELEGATE
static SQInteger table_rawdelete(HRABBITVM v) static int64_t 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;
@ -425,7 +425,7 @@ static SQInteger table_rawdelete(HRABBITVM v)
} }
static SQInteger container_rawexists(HRABBITVM v) static int64_t 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);
@ -435,18 +435,18 @@ static SQInteger container_rawexists(HRABBITVM v)
return 1; return 1;
} }
static SQInteger container_rawset(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t table_setdelegate(HRABBITVM v)
{ {
if(SQ_FAILED(sq_setdelegate(v,-2))) if(SQ_FAILED(sq_setdelegate(v,-2)))
return SQ_ERROR; return SQ_ERROR;
@ -454,21 +454,21 @@ static SQInteger table_setdelegate(HRABBITVM v)
return 1; return 1;
} }
static SQInteger table_getdelegate(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t table_filter(HRABBITVM v)
{ {
SQObject &o = stack_get(v,1); SQObject &o = stack_get(v,1);
SQTable *tbl = _table(o); SQTable *tbl = _table(o);
SQObjectPtr ret = SQTable::Create(_ss(v),0); SQObjectPtr ret = SQTable::Create(_ss(v),0);
SQObjectPtr itr, key, val; SQObjectPtr itr, key, val;
SQInteger nitr; int64_t nitr;
while((nitr = tbl->Next(false, itr, key, val)) != -1) { while((nitr = tbl->Next(false, itr, key, val)) != -1) {
itr = (SQInteger)nitr; itr = (int64_t)nitr;
v->Push(o); v->Push(o);
v->Push(key); v->Push(key);
@ -504,29 +504,29 @@ const SQRegFunction SQSharedState::_table_default_delegate_funcz[]={
//ARRAY DEFAULT DELEGATE/////////////////////////////////////// //ARRAY DEFAULT DELEGATE///////////////////////////////////////
static SQInteger array_append(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t 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){
@ -536,7 +536,7 @@ static SQInteger array_top(HRABBITVM 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(HRABBITVM v) static int64_t 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);
@ -547,7 +547,7 @@ static SQInteger array_insert(HRABBITVM v)
return 1; return 1;
} }
static SQInteger array_remove(HRABBITVM v) static int64_t 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);
@ -561,13 +561,13 @@ static SQInteger array_remove(HRABBITVM v)
return sq_throwerror(v, _SC("idx out of range")); return sq_throwerror(v, _SC("idx out of range"));
} }
static SQInteger array_resize(HRABBITVM v) static int64_t 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);
SQObjectPtr fill; SQObjectPtr fill;
if(sq_isnumeric(nsize)) { if(sq_isnumeric(nsize)) {
SQInteger sz = tointeger(nsize); int64_t sz = tointeger(nsize);
if (sz<0) if (sz<0)
return sq_throwerror(v, _SC("resizing to negative length")); return sq_throwerror(v, _SC("resizing to negative length"));
@ -580,10 +580,10 @@ static SQInteger array_resize(HRABBITVM 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,HRABBITVM v) { static int64_t __map_array(SQArray *dest,SQArray *src,HRABBITVM v) {
SQObjectPtr temp; SQObjectPtr temp;
SQInteger size = src->Size(); int64_t size = src->Size();
for(SQInteger n = 0; n < size; n++) { for(int64_t n = 0; n < size; n++) {
src->Get(n,temp); src->Get(n,temp);
v->Push(src); v->Push(src);
v->Push(temp); v->Push(temp);
@ -596,10 +596,10 @@ static SQInteger __map_array(SQArray *dest,SQArray *src,HRABBITVM v) {
return 0; return 0;
} }
static SQInteger array_map(HRABBITVM v) static int64_t array_map(HRABBITVM v)
{ {
SQObject &o = stack_get(v,1); SQObject &o = stack_get(v,1);
SQInteger size = _array(o)->Size(); int64_t size = _array(o)->Size();
SQObjectPtr ret = SQArray::Create(_ss(v),size); SQObjectPtr ret = SQArray::Create(_ss(v),size);
if(SQ_FAILED(__map_array(_array(ret),_array(o),v))) if(SQ_FAILED(__map_array(_array(ret),_array(o),v)))
return SQ_ERROR; return SQ_ERROR;
@ -607,7 +607,7 @@ static SQInteger array_map(HRABBITVM v)
return 1; return 1;
} }
static SQInteger array_apply(HRABBITVM v) static int64_t 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)))
@ -616,11 +616,11 @@ static SQInteger array_apply(HRABBITVM v)
return 1; return 1;
} }
static SQInteger array_reduce(HRABBITVM v) static int64_t array_reduce(HRABBITVM v)
{ {
SQObject &o = stack_get(v,1); SQObject &o = stack_get(v,1);
SQArray *a = _array(o); SQArray *a = _array(o);
SQInteger size = a->Size(); int64_t size = a->Size();
if(size == 0) { if(size == 0) {
return 0; return 0;
} }
@ -628,7 +628,7 @@ static SQInteger array_reduce(HRABBITVM v)
a->Get(0,res); a->Get(0,res);
if(size > 1) { if(size > 1) {
SQObjectPtr other; SQObjectPtr other;
for(SQInteger n = 1; n < size; n++) { for(int64_t n = 1; n < size; n++) {
a->Get(n,other); a->Get(n,other);
v->Push(o); v->Push(o);
v->Push(res); v->Push(res);
@ -644,14 +644,14 @@ static SQInteger array_reduce(HRABBITVM v)
return 1; return 1;
} }
static SQInteger array_filter(HRABBITVM v) static int64_t array_filter(HRABBITVM v)
{ {
SQObject &o = stack_get(v,1); SQObject &o = stack_get(v,1);
SQArray *a = _array(o); SQArray *a = _array(o);
SQObjectPtr ret = SQArray::Create(_ss(v),0); SQObjectPtr ret = SQArray::Create(_ss(v),0);
SQInteger size = a->Size(); int64_t size = a->Size();
SQObjectPtr val; SQObjectPtr val;
for(SQInteger n = 0; n < size; n++) { for(int64_t n = 0; n < size; n++) {
a->Get(n,val); a->Get(n,val);
v->Push(o); v->Push(o);
v->Push(n); v->Push(n);
@ -668,14 +668,14 @@ static SQInteger array_filter(HRABBITVM v)
return 1; return 1;
} }
static SQInteger array_find(HRABBITVM v) static int64_t 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);
SQArray *a = _array(o); SQArray *a = _array(o);
SQInteger size = a->Size(); int64_t size = a->Size();
SQObjectPtr temp; SQObjectPtr temp;
for(SQInteger n = 0; n < size; n++) { for(int64_t n = 0; n < size; n++) {
bool res = false; bool res = false;
a->Get(n,temp); a->Get(n,temp);
if(SQVM::IsEqual(temp,val,res) && res) { if(SQVM::IsEqual(temp,val,res) && res) {
@ -687,13 +687,13 @@ static SQInteger array_find(HRABBITVM v)
} }
static bool _sort_compare(HRABBITVM v,SQObjectPtr &a,SQObjectPtr &b,SQInteger func,SQInteger &ret) static bool _sort_compare(HRABBITVM v,SQObjectPtr &a,SQObjectPtr &b,int64_t func,int64_t &ret)
{ {
if(func < 0) { if(func < 0) {
if(!v->ObjCmp(a,b,ret)) return false; if(!v->ObjCmp(a,b,ret)) return false;
} }
else { else {
SQInteger top = sq_gettop(v); int64_t top = sq_gettop(v);
sq_push(v, func); sq_push(v, func);
sq_pushroottable(v); sq_pushroottable(v);
v->Push(a); v->Push(a);
@ -713,12 +713,12 @@ static bool _sort_compare(HRABBITVM v,SQObjectPtr &a,SQObjectPtr &b,SQInteger fu
return true; return true;
} }
static bool _hsort_sift_down(HRABBITVM v,SQArray *arr, SQInteger root, SQInteger bottom, SQInteger func) static bool _hsort_sift_down(HRABBITVM v,SQArray *arr, int64_t root, int64_t bottom, int64_t func)
{ {
SQInteger maxChild; int64_t maxChild;
SQInteger done = 0; int64_t done = 0;
SQInteger ret; int64_t ret;
SQInteger root2; int64_t root2;
while (((root2 = root * 2) <= bottom) && (!done)) while (((root2 = root * 2) <= bottom) && (!done))
{ {
if (root2 == bottom) { if (root2 == bottom) {
@ -753,11 +753,11 @@ static bool _hsort_sift_down(HRABBITVM v,SQArray *arr, SQInteger root, SQInteger
return true; return true;
} }
static bool _hsort(HRABBITVM v,SQObjectPtr &arr, SQInteger SQ_UNUSED_ARG(l), SQInteger SQ_UNUSED_ARG(r),SQInteger func) static bool _hsort(HRABBITVM v,SQObjectPtr &arr, int64_t SQ_UNUSED_ARG(l), int64_t SQ_UNUSED_ARG(r),int64_t func)
{ {
SQArray *a = _array(arr); SQArray *a = _array(arr);
SQInteger i; int64_t i;
SQInteger array_size = a->Size(); int64_t array_size = a->Size();
for (i = (array_size / 2); i >= 0; i--) { for (i = (array_size / 2); i >= 0; i--) {
if(!_hsort_sift_down(v,a, i, array_size - 1,func)) return false; if(!_hsort_sift_down(v,a, i, array_size - 1,func)) return false;
} }
@ -770,9 +770,9 @@ static bool _hsort(HRABBITVM v,SQObjectPtr &arr, SQInteger SQ_UNUSED_ARG(l), SQI
return true; return true;
} }
static SQInteger array_sort(HRABBITVM v) static int64_t array_sort(HRABBITVM v)
{ {
SQInteger func = -1; int64_t func = -1;
SQObjectPtr &o = stack_get(v,1); SQObjectPtr &o = stack_get(v,1);
if(_array(o)->Size() > 1) { if(_array(o)->Size() > 1) {
if(sq_gettop(v) == 2) func = 2; if(sq_gettop(v) == 2) func = 2;
@ -784,20 +784,20 @@ static SQInteger array_sort(HRABBITVM v)
return 1; return 1;
} }
static SQInteger array_slice(HRABBITVM v) static int64_t array_slice(HRABBITVM v)
{ {
SQInteger sidx,eidx; int64_t sidx,eidx;
SQObjectPtr o; SQObjectPtr o;
if(get_slice_params(v,sidx,eidx,o)==-1)return -1; if(get_slice_params(v,sidx,eidx,o)==-1)return -1;
SQInteger alen = _array(o)->Size(); int64_t alen = _array(o)->Size();
if(sidx < 0)sidx = alen + sidx; if(sidx < 0)sidx = alen + sidx;
if(eidx < 0)eidx = alen + eidx; if(eidx < 0)eidx = alen + eidx;
if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes")); if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes"));
if(eidx > alen || sidx < 0)return sq_throwerror(v, _SC("slice out of range")); if(eidx > alen || sidx < 0)return sq_throwerror(v, _SC("slice out of range"));
SQArray *arr=SQArray::Create(_ss(v),eidx-sidx); SQArray *arr=SQArray::Create(_ss(v),eidx-sidx);
SQObjectPtr t; SQObjectPtr t;
SQInteger count=0; int64_t count=0;
for(SQInteger i=sidx;i<eidx;i++){ for(int64_t i=sidx;i<eidx;i++){
_array(o)->Get(i,t); _array(o)->Get(i,t);
arr->Set(count++,t); arr->Set(count++,t);
} }
@ -831,12 +831,12 @@ const SQRegFunction SQSharedState::_array_default_delegate_funcz[]={
}; };
//STRING DEFAULT DELEGATE////////////////////////// //STRING DEFAULT DELEGATE//////////////////////////
static SQInteger string_slice(HRABBITVM v) static int64_t string_slice(HRABBITVM v)
{ {
SQInteger sidx,eidx; int64_t sidx,eidx;
SQObjectPtr o; SQObjectPtr o;
if(SQ_FAILED(get_slice_params(v,sidx,eidx,o)))return -1; if(SQ_FAILED(get_slice_params(v,sidx,eidx,o)))return -1;
SQInteger slen = _string(o)->_len; int64_t slen = _string(o)->_len;
if(sidx < 0)sidx = slen + sidx; if(sidx < 0)sidx = slen + sidx;
if(eidx < 0)eidx = slen + eidx; if(eidx < 0)eidx = slen + eidx;
if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes")); if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes"));
@ -845,16 +845,16 @@ static SQInteger string_slice(HRABBITVM v)
return 1; return 1;
} }
static SQInteger string_find(HRABBITVM v) static int64_t string_find(HRABBITVM v)
{ {
SQInteger top,start_idx=0; int64_t top,start_idx=0;
const SQChar *str,*substr,*ret; const SQChar *str,*substr,*ret;
if(((top=sq_gettop(v))>1) && SQ_SUCCEEDED(sq_getstring(v,1,&str)) && SQ_SUCCEEDED(sq_getstring(v,2,&substr))){ if(((top=sq_gettop(v))>1) && SQ_SUCCEEDED(sq_getstring(v,1,&str)) && SQ_SUCCEEDED(sq_getstring(v,2,&substr))){
if(top>2)sq_getinteger(v,3,&start_idx); if(top>2)sq_getinteger(v,3,&start_idx);
if((sq_getsize(v,1)>start_idx) && (start_idx>=0)){ if((sq_getsize(v,1)>start_idx) && (start_idx>=0)){
ret=scstrstr(&str[start_idx],substr); ret=scstrstr(&str[start_idx],substr);
if(ret){ if(ret){
sq_pushinteger(v,(SQInteger)(ret-str)); sq_pushinteger(v,(int64_t)(ret-str));
return 1; return 1;
} }
} }
@ -863,21 +863,21 @@ static SQInteger string_find(HRABBITVM v)
return sq_throwerror(v,_SC("invalid param")); return sq_throwerror(v,_SC("invalid param"));
} }
#define STRING_TOFUNCZ(func) static SQInteger string_##func(HRABBITVM v) \ #define STRING_TOFUNCZ(func) static int64_t string_##func(HRABBITVM v) \
{\ {\
SQInteger sidx,eidx; \ int64_t sidx,eidx; \
SQObjectPtr str; \ SQObjectPtr str; \
if(SQ_FAILED(get_slice_params(v,sidx,eidx,str)))return -1; \ if(SQ_FAILED(get_slice_params(v,sidx,eidx,str)))return -1; \
SQInteger slen = _string(str)->_len; \ int64_t slen = _string(str)->_len; \
if(sidx < 0)sidx = slen + sidx; \ if(sidx < 0)sidx = slen + sidx; \
if(eidx < 0)eidx = slen + eidx; \ if(eidx < 0)eidx = slen + eidx; \
if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes")); \ if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes")); \
if(eidx > slen || sidx < 0) return sq_throwerror(v,_SC("slice out of range")); \ if(eidx > slen || sidx < 0) return sq_throwerror(v,_SC("slice out of range")); \
SQInteger len=_string(str)->_len; \ int64_t len=_string(str)->_len; \
const SQChar *sthis=_stringval(str); \ const SQChar *sthis=_stringval(str); \
SQChar *snew=(_ss(v)->GetScratchPad(sq_rsl(len))); \ SQChar *snew=(_ss(v)->GetScratchPad(sq_rsl(len))); \
memcpy(snew,sthis,sq_rsl(len));\ memcpy(snew,sthis,sq_rsl(len));\
for(SQInteger i=sidx;i<eidx;i++) snew[i] = func(sthis[i]); \ for(int64_t i=sidx;i<eidx;i++) snew[i] = func(sthis[i]); \
v->Push(SQString::Create(_ss(v),snew,len)); \ v->Push(SQString::Create(_ss(v),snew,len)); \
return 1; \ return 1; \
} }
@ -910,12 +910,12 @@ const SQRegFunction SQSharedState::_number_default_delegate_funcz[]={
}; };
//CLOSURE DEFAULT DELEGATE////////////////////////// //CLOSURE DEFAULT DELEGATE//////////////////////////
static SQInteger closure_pcall(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t 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))
@ -925,59 +925,59 @@ static SQInteger closure_call(HRABBITVM 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(HRABBITVM v,SQBool raiseerror) static int64_t _closure_acall(HRABBITVM v,SQBool raiseerror)
{ {
SQArray *aparams=_array(stack_get(v,2)); SQArray *aparams=_array(stack_get(v,2));
SQInteger nparams=aparams->Size(); int64_t nparams=aparams->Size();
v->Push(stack_get(v,1)); v->Push(stack_get(v,1));
for(SQInteger i=0;i<nparams;i++)v->Push(aparams->_values[i]); for(int64_t i=0;i<nparams;i++)v->Push(aparams->_values[i]);
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(HRABBITVM v) static int64_t closure_acall(HRABBITVM v)
{ {
return _closure_acall(v,SQTrue); return _closure_acall(v,SQTrue);
} }
static SQInteger closure_pacall(HRABBITVM v) static int64_t closure_pacall(HRABBITVM v)
{ {
return _closure_acall(v,SQFalse); return _closure_acall(v,SQFalse);
} }
static SQInteger closure_bindenv(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t 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(HRABBITVM v) { static int64_t 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) {
SQFunctionProto *f = _closure(o)->_function; SQFunctionProto *f = _closure(o)->_function;
SQInteger nparams = f->_nparameters + (f->_varparams?1:0); int64_t nparams = f->_nparameters + (f->_varparams?1:0);
SQObjectPtr params = SQArray::Create(_ss(v),nparams); SQObjectPtr params = SQArray::Create(_ss(v),nparams);
SQObjectPtr defparams = SQArray::Create(_ss(v),f->_ndefaultparams); SQObjectPtr defparams = SQArray::Create(_ss(v),f->_ndefaultparams);
for(SQInteger n = 0; n<f->_nparameters; n++) { for(int64_t n = 0; n<f->_nparameters; n++) {
_array(params)->Set((SQInteger)n,f->_parameters[n]); _array(params)->Set((int64_t)n,f->_parameters[n]);
} }
for(SQInteger j = 0; j<f->_ndefaultparams; j++) { for(int64_t j = 0; j<f->_ndefaultparams; j++) {
_array(defparams)->Set((SQInteger)j,_closure(o)->_defaultparams[j]); _array(defparams)->Set((int64_t)j,_closure(o)->_defaultparams[j]);
} }
if(f->_varparams) { if(f->_varparams) {
_array(params)->Set(nparams-1,SQString::Create(_ss(v),_SC("..."),-1)); _array(params)->Set(nparams-1,SQString::Create(_ss(v),_SC("..."),-1));
@ -998,8 +998,8 @@ static SQInteger closure_getinfos(HRABBITVM v) {
if(nc->_typecheck.size() > 0) { if(nc->_typecheck.size() > 0) {
typecheck = typecheck =
SQArray::Create(_ss(v), nc->_typecheck.size()); SQArray::Create(_ss(v), nc->_typecheck.size());
for(SQUnsignedInteger n = 0; n<nc->_typecheck.size(); n++) { for(uint64_t n = 0; n<nc->_typecheck.size(); n++) {
_array(typecheck)->Set((SQInteger)n,nc->_typecheck[n]); _array(typecheck)->Set((int64_t)n,nc->_typecheck[n]);
} }
} }
res->NewSlot(SQString::Create(_ss(v),_SC("typecheck"),-1),typecheck); res->NewSlot(SQString::Create(_ss(v),_SC("typecheck"),-1),typecheck);
@ -1025,7 +1025,7 @@ const SQRegFunction SQSharedState::_closure_default_delegate_funcz[]={
}; };
//GENERATOR DEFAULT DELEGATE //GENERATOR DEFAULT DELEGATE
static SQInteger generator_getstatus(HRABBITVM v) static int64_t generator_getstatus(HRABBITVM v)
{ {
SQObject &o=stack_get(v,1); SQObject &o=stack_get(v,1);
switch(_generator(o)->_state){ switch(_generator(o)->_state){
@ -1044,13 +1044,13 @@ const SQRegFunction SQSharedState::_generator_default_delegate_funcz[]={
}; };
//THREAD DEFAULT DELEGATE //THREAD DEFAULT DELEGATE
static SQInteger thread_call(HRABBITVM v) static int64_t 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) {
SQInteger nparams = sq_gettop(v); int64_t nparams = sq_gettop(v);
_thread(o)->Push(_thread(o)->_roottable); _thread(o)->Push(_thread(o)->_roottable);
for(SQInteger i = 2; i<(nparams+1); i++) for(int64_t i = 2; i<(nparams+1); i++)
sq_move(_thread(o),v,i); sq_move(_thread(o),v,i);
if(SQ_SUCCEEDED(sq_call(_thread(o),nparams,SQTrue,SQTrue))) { if(SQ_SUCCEEDED(sq_call(_thread(o),nparams,SQTrue,SQTrue))) {
sq_move(v,_thread(o),-1); sq_move(v,_thread(o),-1);
@ -1063,12 +1063,12 @@ static SQInteger thread_call(HRABBITVM v)
return sq_throwerror(v,_SC("wrong parameter")); return sq_throwerror(v,_SC("wrong parameter"));
} }
static SQInteger thread_wakeup(HRABBITVM v) static int64_t 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) {
SQVM *thread = _thread(o); SQVM *thread = _thread(o);
SQInteger state = sq_getvmstate(thread); int64_t state = sq_getvmstate(thread);
if(state != SQ_VMSTATE_SUSPENDED) { if(state != SQ_VMSTATE_SUSPENDED) {
switch(state) { switch(state) {
case SQ_VMSTATE_IDLE: case SQ_VMSTATE_IDLE:
@ -1080,7 +1080,7 @@ static SQInteger thread_wakeup(HRABBITVM v)
} }
} }
SQInteger wakeupret = sq_gettop(v)>1?SQTrue:SQFalse; int64_t wakeupret = sq_gettop(v)>1?SQTrue:SQFalse;
if(wakeupret) { if(wakeupret) {
sq_move(thread,v,2); sq_move(thread,v,2);
} }
@ -1099,12 +1099,12 @@ static SQInteger thread_wakeup(HRABBITVM v)
return sq_throwerror(v,_SC("wrong parameter")); return sq_throwerror(v,_SC("wrong parameter"));
} }
static SQInteger thread_wakeupthrow(HRABBITVM v) static int64_t 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) {
SQVM *thread = _thread(o); SQVM *thread = _thread(o);
SQInteger state = sq_getvmstate(thread); int64_t state = sq_getvmstate(thread);
if(state != SQ_VMSTATE_SUSPENDED) { if(state != SQ_VMSTATE_SUSPENDED) {
switch(state) { switch(state) {
case SQ_VMSTATE_IDLE: case SQ_VMSTATE_IDLE:
@ -1140,7 +1140,7 @@ static SQInteger thread_wakeupthrow(HRABBITVM v)
return sq_throwerror(v,_SC("wrong parameter")); return sq_throwerror(v,_SC("wrong parameter"));
} }
static SQInteger thread_getstatus(HRABBITVM v) static int64_t 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))) {
@ -1159,13 +1159,13 @@ static SQInteger thread_getstatus(HRABBITVM v)
return 1; return 1;
} }
static SQInteger thread_getstackinfos(HRABBITVM v) static int64_t 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) {
SQVM *thread = _thread(o); SQVM *thread = _thread(o);
SQInteger threadtop = sq_gettop(thread); int64_t threadtop = sq_gettop(thread);
SQInteger level; int64_t level;
sq_getinteger(v,-1,&level); sq_getinteger(v,-1,&level);
SQRESULT res = __getcallstackinfos(thread,level); SQRESULT res = __getcallstackinfos(thread,level);
if(SQ_FAILED(res)) if(SQ_FAILED(res))
@ -1203,29 +1203,29 @@ const SQRegFunction SQSharedState::_thread_default_delegate_funcz[] = {
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
static SQInteger class_getattributes(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t 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(HRABBITVM v) static int64_t class_newmember(HRABBITVM v)
{ {
SQInteger top = sq_gettop(v); int64_t top = sq_gettop(v);
SQBool bstatic = SQFalse; SQBool bstatic = SQFalse;
if(top == 5) if(top == 5)
{ {
@ -1239,9 +1239,9 @@ static SQInteger class_newmember(HRABBITVM 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(HRABBITVM v) static int64_t class_rawnewmember(HRABBITVM v)
{ {
SQInteger top = sq_gettop(v); int64_t top = sq_gettop(v);
SQBool bstatic = SQFalse; SQBool bstatic = SQFalse;
if(top == 5) if(top == 5)
{ {
@ -1271,7 +1271,7 @@ const SQRegFunction SQSharedState::_class_default_delegate_funcz[] = {
}; };
static SQInteger instance_getclass(HRABBITVM v) static int64_t instance_getclass(HRABBITVM v)
{ {
if(SQ_SUCCEEDED(sq_getclass(v,1))) if(SQ_SUCCEEDED(sq_getclass(v,1)))
return 1; return 1;
@ -1288,7 +1288,7 @@ const SQRegFunction SQSharedState::_instance_default_delegate_funcz[] = {
{NULL,(SQFUNCTION)0,0,NULL} {NULL,(SQFUNCTION)0,0,NULL}
}; };
static SQInteger weakref_ref(HRABBITVM v) static int64_t weakref_ref(HRABBITVM v)
{ {
if(SQ_FAILED(sq_getweakrefval(v,1))) if(SQ_FAILED(sq_getweakrefval(v,1)))
return SQ_ERROR; return SQ_ERROR;

22
rabbit/sqclass.cpp
View File

@ -62,7 +62,7 @@ bool SQClass::NewSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr
return true; return true;
} }
if(belongs_to_static_table) { if(belongs_to_static_table) {
SQInteger mmidx; int64_t mmidx;
if((sq_type(val) == OT_CLOSURE || sq_type(val) == OT_NATIVECLOSURE) && if((sq_type(val) == OT_CLOSURE || sq_type(val) == OT_NATIVECLOSURE) &&
(mmidx = ss->GetMetaMethodIdxByName(key)) != -1) { (mmidx = ss->GetMetaMethodIdxByName(key)) != -1) {
_metamethods[mmidx] = val; _metamethods[mmidx] = val;
@ -78,7 +78,7 @@ bool SQClass::NewSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr
bool isconstructor; bool isconstructor;
SQVM::IsEqual(ss->_constructoridx, key, isconstructor); SQVM::IsEqual(ss->_constructoridx, key, isconstructor);
if(isconstructor) { if(isconstructor) {
_constructoridx = (SQInteger)_methods.size(); _constructoridx = (int64_t)_methods.size();
} }
SQClassMember m; SQClassMember m;
m.val = theval; m.val = theval;
@ -104,10 +104,10 @@ SQInstance *SQClass::CreateInstance()
return SQInstance::Create(NULL,this); return SQInstance::Create(NULL,this);
} }
SQInteger SQClass::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval) int64_t SQClass::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval)
{ {
SQObjectPtr oval; SQObjectPtr oval;
SQInteger idx = _members->Next(false,refpos,outkey,oval); int64_t idx = _members->Next(false,refpos,outkey,oval);
if(idx != -1) { if(idx != -1) {
if(_ismethod(oval)) { if(_ismethod(oval)) {
outval = _methods[_member_idx(oval)].val; outval = _methods[_member_idx(oval)].val;
@ -152,23 +152,23 @@ void SQInstance::Init(SQSharedState *ss)
_delegate = _class->_members; _delegate = _class->_members;
} }
SQInstance::SQInstance(SQSharedState *ss, SQClass *c, SQInteger memsize) SQInstance::SQInstance(SQSharedState *ss, SQClass *c, int64_t memsize)
{ {
_memsize = memsize; _memsize = memsize;
_class = c; _class = c;
SQUnsignedInteger nvalues = _class->_defaultvalues.size(); uint64_t nvalues = _class->_defaultvalues.size();
for(SQUnsignedInteger n = 0; n < nvalues; n++) { for(uint64_t n = 0; n < nvalues; n++) {
new (&_values[n]) SQObjectPtr(_class->_defaultvalues[n].val); new (&_values[n]) SQObjectPtr(_class->_defaultvalues[n].val);
} }
Init(ss); Init(ss);
} }
SQInstance::SQInstance(SQSharedState *ss, SQInstance *i, SQInteger memsize) SQInstance::SQInstance(SQSharedState *ss, SQInstance *i, int64_t memsize)
{ {
_memsize = memsize; _memsize = memsize;
_class = i->_class; _class = i->_class;
SQUnsignedInteger nvalues = _class->_defaultvalues.size(); uint64_t nvalues = _class->_defaultvalues.size();
for(SQUnsignedInteger n = 0; n < nvalues; n++) { for(uint64_t n = 0; n < nvalues; n++) {
new (&_values[n]) SQObjectPtr(i->_values[n]); new (&_values[n]) SQObjectPtr(i->_values[n]);
} }
Init(ss); Init(ss);
@ -176,7 +176,7 @@ SQInstance::SQInstance(SQSharedState *ss, SQInstance *i, SQInteger memsize)
void SQInstance::Finalize() void SQInstance::Finalize()
{ {
SQUnsignedInteger nvalues = _class->_defaultvalues.size(); uint64_t nvalues = _class->_defaultvalues.size();
__ObjRelease(_class); __ObjRelease(_class);
_NULL_SQOBJECT_VECTOR(_values,nvalues); _NULL_SQOBJECT_VECTOR(_values,nvalues);
} }

22
rabbit/sqclass.hpp
View File

@ -25,8 +25,8 @@ typedef sqvector<SQClassMember> SQClassMemberVec;
#define _ismethod(o) (_integer(o)&MEMBER_TYPE_METHOD) #define _ismethod(o) (_integer(o)&MEMBER_TYPE_METHOD)
#define _isfield(o) (_integer(o)&MEMBER_TYPE_FIELD) #define _isfield(o) (_integer(o)&MEMBER_TYPE_FIELD)
#define _make_method_idx(i) ((SQInteger)(MEMBER_TYPE_METHOD|i)) #define _make_method_idx(i) ((int64_t)(MEMBER_TYPE_METHOD|i))
#define _make_field_idx(i) ((SQInteger)(MEMBER_TYPE_FIELD|i)) #define _make_field_idx(i) ((int64_t)(MEMBER_TYPE_FIELD|i))
#define _member_type(o) (_integer(o)&0xFF000000) #define _member_type(o) (_integer(o)&0xFF000000)
#define _member_idx(o) (_integer(o)&0x00FFFFFF) #define _member_idx(o) (_integer(o)&0x00FFFFFF)
@ -70,7 +70,7 @@ public:
sq_delete(this, SQClass); sq_delete(this, SQClass);
} }
void Finalize(); void Finalize();
SQInteger Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); int64_t Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval);
SQInstance *CreateInstance(); SQInstance *CreateInstance();
SQTable *_members; SQTable *_members;
SQClass *_base; SQClass *_base;
@ -81,8 +81,8 @@ public:
SQUserPointer _typetag; SQUserPointer _typetag;
SQRELEASEHOOK _hook; SQRELEASEHOOK _hook;
bool _locked; bool _locked;
SQInteger _constructoridx; int64_t _constructoridx;
SQInteger _udsize; int64_t _udsize;
}; };
#define calcinstancesize(_theclass_) \ #define calcinstancesize(_theclass_) \
@ -91,12 +91,12 @@ public:
struct SQInstance : public SQDelegable struct SQInstance : public SQDelegable
{ {
void Init(SQSharedState *ss); void Init(SQSharedState *ss);
SQInstance(SQSharedState *ss, SQClass *c, SQInteger memsize); SQInstance(SQSharedState *ss, SQClass *c, int64_t memsize);
SQInstance(SQSharedState *ss, SQInstance *c, SQInteger memsize); SQInstance(SQSharedState *ss, SQInstance *c, int64_t memsize);
public: public:
static SQInstance* Create(SQSharedState *ss,SQClass *theclass) { static SQInstance* Create(SQSharedState *ss,SQClass *theclass) {
SQInteger size = calcinstancesize(theclass); int64_t size = calcinstancesize(theclass);
SQInstance *newinst = (SQInstance *)SQ_MALLOC(size); SQInstance *newinst = (SQInstance *)SQ_MALLOC(size);
new (newinst) SQInstance(ss, theclass,size); new (newinst) SQInstance(ss, theclass,size);
if(theclass->_udsize) { if(theclass->_udsize) {
@ -106,7 +106,7 @@ public:
} }
SQInstance *Clone(SQSharedState *ss) SQInstance *Clone(SQSharedState *ss)
{ {
SQInteger size = calcinstancesize(_class); int64_t size = calcinstancesize(_class);
SQInstance *newinst = (SQInstance *)SQ_MALLOC(size); SQInstance *newinst = (SQInstance *)SQ_MALLOC(size);
new (newinst) SQInstance(ss, this,size); new (newinst) SQInstance(ss, this,size);
if(_class->_udsize) { if(_class->_udsize) {
@ -141,7 +141,7 @@ public:
if (_hook) { _hook(_userpointer,0);} if (_hook) { _hook(_userpointer,0);}
_uiRef--; _uiRef--;
if(_uiRef > 0) return; if(_uiRef > 0) return;
SQInteger size = _memsize; int64_t size = _memsize;
this->~SQInstance(); this->~SQInstance();
SQ_FREE(this, size); SQ_FREE(this, size);
} }
@ -152,7 +152,7 @@ public:
SQClass *_class; SQClass *_class;
SQUserPointer _userpointer; SQUserPointer _userpointer;
SQRELEASEHOOK _hook; SQRELEASEHOOK _hook;
SQInteger _memsize; int64_t _memsize;
SQObjectPtr _values[1]; SQObjectPtr _values[1];
}; };

18
rabbit/sqclosure.hpp
View File

@ -22,7 +22,7 @@ private:
} }
public: public:
static SQClosure *Create(SQSharedState *ss,SQFunctionProto *func,SQWeakRef *root){ static SQClosure *Create(SQSharedState *ss,SQFunctionProto *func,SQWeakRef *root){
SQInteger size = _CALC_CLOSURE_SIZE(func); int64_t size = _CALC_CLOSURE_SIZE(func);
SQClosure *nc=(SQClosure*)SQ_MALLOC(size); SQClosure *nc=(SQClosure*)SQ_MALLOC(size);
new (nc) SQClosure(ss,func); new (nc) SQClosure(ss,func);
nc->_outervalues = (SQObjectPtr *)(nc + 1); nc->_outervalues = (SQObjectPtr *)(nc + 1);
@ -35,7 +35,7 @@ public:
} }
void Release(){ void Release(){
SQFunctionProto *f = _function; SQFunctionProto *f = _function;
SQInteger size = _CALC_CLOSURE_SIZE(f); int64_t size = _CALC_CLOSURE_SIZE(f);
_DESTRUCT_VECTOR(SQObjectPtr,f->_noutervalues,_outervalues); _DESTRUCT_VECTOR(SQObjectPtr,f->_noutervalues,_outervalues);
_DESTRUCT_VECTOR(SQObjectPtr,f->_ndefaultparams,_defaultparams); _DESTRUCT_VECTOR(SQObjectPtr,f->_ndefaultparams,_defaultparams);
__ObjRelease(_function); __ObjRelease(_function);
@ -98,7 +98,7 @@ public:
} }
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 */ int64_t _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 */
SQOuter *_next; /* pointer to next outer when frame is open */ SQOuter *_next; /* pointer to next outer when frame is open */
}; };
@ -131,7 +131,7 @@ public:
sq_delete(this,SQGenerator); sq_delete(this,SQGenerator);
} }
bool Yield(SQVM *v,SQInteger target); bool Yield(SQVM *v,int64_t target);
bool Resume(SQVM *v,SQObjectPtr &dest); bool Resume(SQVM *v,SQObjectPtr &dest);
SQObjectPtr _closure; SQObjectPtr _closure;
SQObjectPtrVec _stack; SQObjectPtrVec _stack;
@ -150,9 +150,9 @@ private:
_env = NULL; _env = NULL;
} }
public: public:
static SQNativeClosure *Create(SQSharedState *ss,SQFUNCTION func,SQInteger nouters) static SQNativeClosure *Create(SQSharedState *ss,SQFUNCTION func,int64_t nouters)
{ {
SQInteger size = _CALC_NATVIVECLOSURE_SIZE(nouters); int64_t size = _CALC_NATVIVECLOSURE_SIZE(nouters);
SQNativeClosure *nc=(SQNativeClosure*)SQ_MALLOC(size); SQNativeClosure *nc=(SQNativeClosure*)SQ_MALLOC(size);
new (nc) SQNativeClosure(ss,func); new (nc) SQNativeClosure(ss,func);
nc->_outervalues = (SQObjectPtr *)(nc + 1); nc->_outervalues = (SQObjectPtr *)(nc + 1);
@ -176,16 +176,16 @@ public:
__ObjRelease(_env); __ObjRelease(_env);
} }
void Release(){ void Release(){
SQInteger size = _CALC_NATVIVECLOSURE_SIZE(_noutervalues); int64_t size = _CALC_NATVIVECLOSURE_SIZE(_noutervalues);
_DESTRUCT_VECTOR(SQObjectPtr,_noutervalues,_outervalues); _DESTRUCT_VECTOR(SQObjectPtr,_noutervalues,_outervalues);
this->~SQNativeClosure(); this->~SQNativeClosure();
sq_free(this,size); sq_free(this,size);
} }
SQInteger _nparamscheck; int64_t _nparamscheck;
SQIntVec _typecheck; SQIntVec _typecheck;
SQObjectPtr *_outervalues; SQObjectPtr *_outervalues;
SQUnsignedInteger _noutervalues; uint64_t _noutervalues;
SQWeakRef *_env; SQWeakRef *_env;
SQFUNCTION _function; SQFUNCTION _function;
SQObjectPtr _name; SQObjectPtr _name;

258
rabbit/sqcompiler.cpp
View File

@ -25,16 +25,16 @@
#define OUTER 5 #define OUTER 5
struct SQExpState { struct SQExpState {
SQInteger etype; /* expr. type; one of EXPR, OBJECT, BASE, OUTER or LOCAL */ int64_t etype; /* expr. type; one of EXPR, OBJECT, BASE, OUTER or LOCAL */
SQInteger epos; /* expr. location on stack; -1 for OBJECT and BASE */ int64_t epos; /* expr. location on stack; -1 for OBJECT and BASE */
bool donot_get; /* signal not to deref the next value */ bool donot_get; /* signal not to deref the next value */
}; };
#define MAX_COMPILER_ERROR_LEN 256 #define MAX_COMPILER_ERROR_LEN 256
struct SQScope { struct SQScope {
SQInteger outers; int64_t outers;
SQInteger stacksize; int64_t stacksize;
}; };
#define BEGIN_SCOPE() SQScope __oldscope__ = _scope; \ #define BEGIN_SCOPE() SQScope __oldscope__ = _scope; \
@ -53,7 +53,7 @@ struct SQScope {
_scope = __oldscope__; \ _scope = __oldscope__; \
} }
#define END_SCOPE() { SQInteger oldouters = _fs->_outers;\ #define END_SCOPE() { int64_t oldouters = _fs->_outers;\
if(_fs->GetStackSize() != _scope.stacksize) { \ if(_fs->GetStackSize() != _scope.stacksize) { \
_fs->SetStackSize(_scope.stacksize); \ _fs->SetStackSize(_scope.stacksize); \
if(oldouters != _fs->_outers) { \ if(oldouters != _fs->_outers) { \
@ -63,8 +63,8 @@ struct SQScope {
_scope = __oldscope__; \ _scope = __oldscope__; \
} }
#define BEGIN_BREAKBLE_BLOCK() SQInteger __nbreaks__=_fs->_unresolvedbreaks.size(); \ #define BEGIN_BREAKBLE_BLOCK() int64_t __nbreaks__=_fs->_unresolvedbreaks.size(); \
SQInteger __ncontinues__=_fs->_unresolvedcontinues.size(); \ int64_t __ncontinues__=_fs->_unresolvedcontinues.size(); \
_fs->_breaktargets.push_back(0);_fs->_continuetargets.push_back(0); _fs->_breaktargets.push_back(0);_fs->_continuetargets.push_back(0);
#define END_BREAKBLE_BLOCK(continue_target) {__nbreaks__=_fs->_unresolvedbreaks.size()-__nbreaks__; \ #define END_BREAKBLE_BLOCK(continue_target) {__nbreaks__=_fs->_unresolvedbreaks.size()-__nbreaks__; \
@ -99,7 +99,7 @@ public:
longjmp(_errorjmp,1); longjmp(_errorjmp,1);
} }
void Lex(){ _token = _lex.Lex();} void Lex(){ _token = _lex.Lex();}
SQObject Expect(SQInteger tok) SQObject Expect(int64_t tok)
{ {
if(_token != tok) { if(_token != tok) {
@ -159,7 +159,7 @@ public:
} }
} }
void MoveIfCurrentTargetIsLocal() { void MoveIfCurrentTargetIsLocal() {
SQInteger trg = _fs->TopTarget(); int64_t trg = _fs->TopTarget();
if(_fs->IsLocal(trg)) { if(_fs->IsLocal(trg)) {
trg = _fs->PopTarget(); //pops the target and moves it trg = _fs->PopTarget(); //pops the target and moves it
_fs->AddInstruction(_OP_MOVE, _fs->PushTarget(), trg); _fs->AddInstruction(_OP_MOVE, _fs->PushTarget(), trg);
@ -177,7 +177,7 @@ public:
_fs->AddParameter(_fs->CreateString(_SC("vargv"))); _fs->AddParameter(_fs->CreateString(_SC("vargv")));
_fs->_varparams = true; _fs->_varparams = true;
_fs->_sourcename = _sourcename; _fs->_sourcename = _sourcename;
SQInteger stacksize = _fs->GetStackSize(); int64_t stacksize = _fs->GetStackSize();
if(setjmp(_errorjmp) == 0) { if(setjmp(_errorjmp) == 0) {
Lex(); Lex();
while(_token > 0){ while(_token > 0){
@ -234,7 +234,7 @@ public:
} }
Lex(); Lex();
if(!IsEndOfStatement()) { if(!IsEndOfStatement()) {
SQInteger retexp = _fs->GetCurrentPos()+1; int64_t retexp = _fs->GetCurrentPos()+1;
CommaExpr(); CommaExpr();
if(op == _OP_RETURN && _fs->_traps > 0) if(op == _OP_RETURN && _fs->_traps > 0)
_fs->AddInstruction(_OP_POPTRAP, _fs->_traps, 0); _fs->AddInstruction(_OP_POPTRAP, _fs->_traps, 0);
@ -321,24 +321,24 @@ public:
} }
void EmitDerefOp(SQOpcode op) void EmitDerefOp(SQOpcode op)
{ {
SQInteger val = _fs->PopTarget(); int64_t val = _fs->PopTarget();
SQInteger key = _fs->PopTarget(); int64_t key = _fs->PopTarget();
SQInteger src = _fs->PopTarget(); int64_t src = _fs->PopTarget();
_fs->AddInstruction(op,_fs->PushTarget(),src,key,val); _fs->AddInstruction(op,_fs->PushTarget(),src,key,val);
} }
void Emit2ArgsOP(SQOpcode op, SQInteger p3 = 0) void Emit2ArgsOP(SQOpcode op, int64_t p3 = 0)
{ {
SQInteger p2 = _fs->PopTarget(); //src in OP_GET int64_t p2 = _fs->PopTarget(); //src in OP_GET
SQInteger p1 = _fs->PopTarget(); //key in OP_GET int64_t p1 = _fs->PopTarget(); //key in OP_GET
_fs->AddInstruction(op,_fs->PushTarget(), p1, p2, p3); _fs->AddInstruction(op,_fs->PushTarget(), p1, p2, p3);
} }
void EmitCompoundArith(SQInteger tok, SQInteger etype, SQInteger pos) void EmitCompoundArith(int64_t tok, int64_t etype, int64_t pos)
{ {
/* Generate code depending on the expression type */ /* Generate code depending on the expression type */
switch(etype) { switch(etype) {
case LOCAL:{ case LOCAL:{
SQInteger p2 = _fs->PopTarget(); //src in OP_GET int64_t p2 = _fs->PopTarget(); //src in OP_GET
SQInteger p1 = _fs->PopTarget(); //key in OP_GET int64_t p1 = _fs->PopTarget(); //key in OP_GET
_fs->PushTarget(p1); _fs->PushTarget(p1);
//EmitCompArithLocal(tok, p1, p1, p2); //EmitCompArithLocal(tok, p1, p1, p2);
_fs->AddInstruction(ChooseArithOpByToken(tok),p1, p2, p1, 0); _fs->AddInstruction(ChooseArithOpByToken(tok),p1, p2, p1, 0);
@ -348,17 +348,17 @@ public:
case OBJECT: case OBJECT:
case BASE: case BASE:
{ {
SQInteger val = _fs->PopTarget(); int64_t val = _fs->PopTarget();
SQInteger key = _fs->PopTarget(); int64_t key = _fs->PopTarget();
SQInteger src = _fs->PopTarget(); int64_t src = _fs->PopTarget();
/* _OP_COMPARITH mixes dest obj and source val in the arg1 */ /* _OP_COMPARITH mixes dest obj and source val in the arg1 */
_fs->AddInstruction(_OP_COMPARITH, _fs->PushTarget(), (src<<16)|val, key, ChooseCompArithCharByToken(tok)); _fs->AddInstruction(_OP_COMPARITH, _fs->PushTarget(), (src<<16)|val, key, ChooseCompArithCharByToken(tok));
} }
break; break;
case OUTER: case OUTER:
{ {
SQInteger val = _fs->TopTarget(); int64_t val = _fs->TopTarget();
SQInteger tmp = _fs->PushTarget(); int64_t tmp = _fs->PushTarget();
_fs->AddInstruction(_OP_GETOUTER, tmp, pos); _fs->AddInstruction(_OP_GETOUTER, tmp, pos);
_fs->AddInstruction(ChooseArithOpByToken(tok), tmp, val, tmp, 0); _fs->AddInstruction(ChooseArithOpByToken(tok), tmp, val, tmp, 0);
_fs->PopTarget(); _fs->PopTarget();
@ -387,9 +387,9 @@ public:
case TK_MULEQ: case TK_MULEQ:
case TK_DIVEQ: case TK_DIVEQ:
case TK_MODEQ:{ case TK_MODEQ:{
SQInteger op = _token; int64_t op = _token;
SQInteger ds = _es.etype; int64_t ds = _es.etype;
SQInteger pos = _es.epos; int64_t pos = _es.epos;
if(ds == EXPR) Error(_SC("can't assign expression")); if(ds == EXPR) Error(_SC("can't assign expression"));
else if(ds == BASE) Error(_SC("'base' cannot be modified")); else if(ds == BASE) Error(_SC("'base' cannot be modified"));
Lex(); Expression(); Lex(); Expression();
@ -405,8 +405,8 @@ public:
switch(ds) { switch(ds) {
case LOCAL: case LOCAL:
{ {
SQInteger src = _fs->PopTarget(); int64_t src = _fs->PopTarget();
SQInteger dst = _fs->TopTarget(); int64_t dst = _fs->TopTarget();
_fs->AddInstruction(_OP_MOVE, dst, src); _fs->AddInstruction(_OP_MOVE, dst, src);
} }
break; break;
@ -416,8 +416,8 @@ public:
break; break;
case OUTER: case OUTER:
{ {
SQInteger src = _fs->PopTarget(); int64_t src = _fs->PopTarget();
SQInteger dst = _fs->PushTarget(); int64_t dst = _fs->PushTarget();
_fs->AddInstruction(_OP_SETOUTER, dst, pos, src); _fs->AddInstruction(_OP_SETOUTER, dst, pos, src);
} }
} }
@ -435,17 +435,17 @@ public:
case _SC('?'): { case _SC('?'): {
Lex(); Lex();
_fs->AddInstruction(_OP_JZ, _fs->PopTarget()); _fs->AddInstruction(_OP_JZ, _fs->PopTarget());
SQInteger jzpos = _fs->GetCurrentPos(); int64_t jzpos = _fs->GetCurrentPos();
SQInteger trg = _fs->PushTarget(); int64_t trg = _fs->PushTarget();
Expression(); Expression();
SQInteger first_exp = _fs->PopTarget(); int64_t first_exp = _fs->PopTarget();
if(trg != first_exp) _fs->AddInstruction(_OP_MOVE, trg, first_exp); if(trg != first_exp) _fs->AddInstruction(_OP_MOVE, trg, first_exp);
SQInteger endfirstexp = _fs->GetCurrentPos(); int64_t endfirstexp = _fs->GetCurrentPos();
_fs->AddInstruction(_OP_JMP, 0, 0); _fs->AddInstruction(_OP_JMP, 0, 0);
Expect(_SC(':')); Expect(_SC(':'));
SQInteger jmppos = _fs->GetCurrentPos(); int64_t jmppos = _fs->GetCurrentPos();
Expression(); Expression();
SQInteger second_exp = _fs->PopTarget(); int64_t second_exp = _fs->PopTarget();
if(trg != second_exp) _fs->AddInstruction(_OP_MOVE, trg, second_exp); if(trg != second_exp) _fs->AddInstruction(_OP_MOVE, trg, second_exp);
_fs->SetIntructionParam(jmppos, 1, _fs->GetCurrentPos() - jmppos); _fs->SetIntructionParam(jmppos, 1, _fs->GetCurrentPos() - jmppos);
_fs->SetIntructionParam(jzpos, 1, endfirstexp - jzpos + 1); _fs->SetIntructionParam(jzpos, 1, endfirstexp - jzpos + 1);
@ -464,11 +464,11 @@ public:
(this->*f)(); (this->*f)();
_es = es; _es = es;
} }
template<typename T> void BIN_EXP(SQOpcode op, T f,SQInteger op3 = 0) template<typename T> void BIN_EXP(SQOpcode op, T f,int64_t op3 = 0)
{ {
Lex(); Lex();
INVOKE_EXP(f); INVOKE_EXP(f);
SQInteger op1 = _fs->PopTarget();SQInteger op2 = _fs->PopTarget(); int64_t op1 = _fs->PopTarget();int64_t op2 = _fs->PopTarget();
_fs->AddInstruction(op, _fs->PushTarget(), op1, op2, op3); _fs->AddInstruction(op, _fs->PushTarget(), op1, op2, op3);
_es.etype = EXPR; _es.etype = EXPR;
} }
@ -476,14 +476,14 @@ public:
{ {
LogicalAndExp(); LogicalAndExp();
for(;;) if(_token == TK_OR) { for(;;) if(_token == TK_OR) {
SQInteger first_exp = _fs->PopTarget(); int64_t first_exp = _fs->PopTarget();
SQInteger trg = _fs->PushTarget(); int64_t trg = _fs->PushTarget();
_fs->AddInstruction(_OP_OR, trg, 0, first_exp, 0); _fs->AddInstruction(_OP_OR, trg, 0, first_exp, 0);
SQInteger jpos = _fs->GetCurrentPos(); int64_t jpos = _fs->GetCurrentPos();
if(trg != first_exp) _fs->AddInstruction(_OP_MOVE, trg, first_exp); if(trg != first_exp) _fs->AddInstruction(_OP_MOVE, trg, first_exp);
Lex(); INVOKE_EXP(&SQCompiler::LogicalOrExp); Lex(); INVOKE_EXP(&SQCompiler::LogicalOrExp);
_fs->SnoozeOpt(); _fs->SnoozeOpt();
SQInteger second_exp = _fs->PopTarget(); int64_t second_exp = _fs->PopTarget();
if(trg != second_exp) _fs->AddInstruction(_OP_MOVE, trg, second_exp); if(trg != second_exp) _fs->AddInstruction(_OP_MOVE, trg, second_exp);
_fs->SnoozeOpt(); _fs->SnoozeOpt();
_fs->SetIntructionParam(jpos, 1, (_fs->GetCurrentPos() - jpos)); _fs->SetIntructionParam(jpos, 1, (_fs->GetCurrentPos() - jpos));
@ -496,14 +496,14 @@ public:
BitwiseOrExp(); BitwiseOrExp();
for(;;) switch(_token) { for(;;) switch(_token) {
case TK_AND: { case TK_AND: {
SQInteger first_exp = _fs->PopTarget(); int64_t first_exp = _fs->PopTarget();
SQInteger trg = _fs->PushTarget(); int64_t trg = _fs->PushTarget();
_fs->AddInstruction(_OP_AND, trg, 0, first_exp, 0); _fs->AddInstruction(_OP_AND, trg, 0, first_exp, 0);
SQInteger jpos = _fs->GetCurrentPos(); int64_t jpos = _fs->GetCurrentPos();
if(trg != first_exp) _fs->AddInstruction(_OP_MOVE, trg, first_exp); if(trg != first_exp) _fs->AddInstruction(_OP_MOVE, trg, first_exp);
Lex(); INVOKE_EXP(&SQCompiler::LogicalAndExp); Lex(); INVOKE_EXP(&SQCompiler::LogicalAndExp);
_fs->SnoozeOpt(); _fs->SnoozeOpt();
SQInteger second_exp = _fs->PopTarget(); int64_t second_exp = _fs->PopTarget();
if(trg != second_exp) _fs->AddInstruction(_OP_MOVE, trg, second_exp); if(trg != second_exp) _fs->AddInstruction(_OP_MOVE, trg, second_exp);
_fs->SnoozeOpt(); _fs->SnoozeOpt();
_fs->SetIntructionParam(jpos, 1, (_fs->GetCurrentPos() - jpos)); _fs->SetIntructionParam(jpos, 1, (_fs->GetCurrentPos() - jpos));
@ -569,7 +569,7 @@ public:
default: return; default: return;
} }
} }
SQOpcode ChooseArithOpByToken(SQInteger tok) SQOpcode ChooseArithOpByToken(int64_t tok)
{ {
switch(tok) { switch(tok) {
case TK_PLUSEQ: case '+': return _OP_ADD; case TK_PLUSEQ: case '+': return _OP_ADD;
@ -581,9 +581,9 @@ public:
} }
return _OP_ADD; return _OP_ADD;
} }
SQInteger ChooseCompArithCharByToken(SQInteger tok) int64_t ChooseCompArithCharByToken(int64_t tok)
{ {
SQInteger oper; int64_t oper;
switch(tok){ switch(tok){
case TK_MINUSEQ: oper = '-'; break; case TK_MINUSEQ: oper = '-'; break;
case TK_PLUSEQ: oper = '+'; break; case TK_PLUSEQ: oper = '+'; break;
@ -617,7 +617,7 @@ public:
//if 'pos' != -1 the previous variable is a local variable //if 'pos' != -1 the previous variable is a local variable
void PrefixedExpr() void PrefixedExpr()
{ {
SQInteger pos = Factor(); int64_t pos = Factor();
for(;;) { for(;;) {
switch(_token) { switch(_token) {
case _SC('.'): case _SC('.'):
@ -659,7 +659,7 @@ public:
case TK_PLUSPLUS: case TK_PLUSPLUS:
{ {
if(IsEndOfStatement()) return; if(IsEndOfStatement()) return;
SQInteger diff = (_token==TK_MINUSMINUS) ? -1 : 1; int64_t diff = (_token==TK_MINUSMINUS) ? -1 : 1;
Lex(); Lex();
switch(_es.etype) switch(_es.etype)
{ {
@ -670,13 +670,13 @@ public:
Emit2ArgsOP(_OP_PINC, diff); Emit2ArgsOP(_OP_PINC, diff);
break; break;
case LOCAL: { case LOCAL: {
SQInteger src = _fs->PopTarget(); int64_t src = _fs->PopTarget();
_fs->AddInstruction(_OP_PINCL, _fs->PushTarget(), src, 0, diff); _fs->AddInstruction(_OP_PINCL, _fs->PushTarget(), src, 0, diff);
} }
break; break;
case OUTER: { case OUTER: {
SQInteger tmp1 = _fs->PushTarget(); int64_t tmp1 = _fs->PushTarget();
SQInteger tmp2 = _fs->PushTarget(); int64_t tmp2 = _fs->PushTarget();
_fs->AddInstruction(_OP_GETOUTER, tmp2, _es.epos); _fs->AddInstruction(_OP_GETOUTER, tmp2, _es.epos);
_fs->AddInstruction(_OP_PINCL, tmp1, tmp2, 0, diff); _fs->AddInstruction(_OP_PINCL, tmp1, tmp2, 0, diff);
_fs->AddInstruction(_OP_SETOUTER, tmp2, _es.epos, tmp2); _fs->AddInstruction(_OP_SETOUTER, tmp2, _es.epos, tmp2);
@ -689,10 +689,10 @@ public:
case _SC('('): case _SC('('):
switch(_es.etype) { switch(_es.etype) {
case OBJECT: { case OBJECT: {
SQInteger key = _fs->PopTarget(); /* location of the key */ int64_t key = _fs->PopTarget(); /* location of the key */
SQInteger table = _fs->PopTarget(); /* location of the object */ int64_t table = _fs->PopTarget(); /* location of the object */
SQInteger closure = _fs->PushTarget(); /* location for the closure */ int64_t closure = _fs->PushTarget(); /* location for the closure */
SQInteger ttarget = _fs->PushTarget(); /* location for 'this' pointer */ int64_t ttarget = _fs->PushTarget(); /* location for 'this' pointer */
_fs->AddInstruction(_OP_PREPCALL, closure, key, table, ttarget); _fs->AddInstruction(_OP_PREPCALL, closure, key, table, ttarget);
} }
break; break;
@ -715,7 +715,7 @@ public:
} }
} }
} }
SQInteger Factor() int64_t Factor()
{ {
//_es.etype = EXPR; //_es.etype = EXPR;
switch(_token) switch(_token)
@ -743,7 +743,7 @@ public:
case TK_CONSTRUCTOR: id = _fs->CreateString(_SC("constructor"),11); break; case TK_CONSTRUCTOR: id = _fs->CreateString(_SC("constructor"),11); break;
} }
SQInteger pos = -1; int64_t pos = -1;
Lex(); Lex();
if((pos = _fs->GetLocalVariable(id)) != -1) { if((pos = _fs->GetLocalVariable(id)) != -1) {
/* Handle a local variable (includes 'this') */ /* Handle a local variable (includes 'this') */
@ -828,13 +828,13 @@ public:
break; break;
case _SC('['): { case _SC('['): {
_fs->AddInstruction(_OP_NEWOBJ, _fs->PushTarget(),0,0,NOT_ARRAY); _fs->AddInstruction(_OP_NEWOBJ, _fs->PushTarget(),0,0,NOT_ARRAY);
SQInteger apos = _fs->GetCurrentPos(),key = 0; int64_t apos = _fs->GetCurrentPos(),key = 0;
Lex(); Lex();
while(_token != _SC(']')) { while(_token != _SC(']')) {
Expression(); Expression();
if(_token == _SC(',')) Lex(); if(_token == _SC(',')) Lex();
SQInteger val = _fs->PopTarget(); int64_t val = _fs->PopTarget();
SQInteger array = _fs->TopTarget(); int64_t array = _fs->TopTarget();
_fs->AddInstruction(_OP_APPENDARRAY, array, val, AAT_STACK); _fs->AddInstruction(_OP_APPENDARRAY, array, val, AAT_STACK);
key++; key++;
} }
@ -879,7 +879,7 @@ public:
_es.etype = EXPR; _es.etype = EXPR;
return -1; return -1;
} }
void EmitLoadConstInt(SQInteger value,SQInteger target) void EmitLoadConstInt(int64_t value,int64_t target)
{ {
if(target < 0) { if(target < 0) {
target = _fs->PushTarget(); target = _fs->PushTarget();
@ -891,13 +891,13 @@ public:
_fs->AddInstruction(_OP_LOAD, target, _fs->GetNumericConstant(value)); _fs->AddInstruction(_OP_LOAD, target, _fs->GetNumericConstant(value));
} }
} }
void EmitLoadConstFloat(SQFloat value,SQInteger target) void EmitLoadConstFloat(float_t value,int64_t target)
{ {
if(target < 0) { if(target < 0) {
target = _fs->PushTarget(); target = _fs->PushTarget();
} }
if(sizeof(SQFloat) == sizeof(SQInt32)) { if(sizeof(float_t) == sizeof(int32_t)) {
_fs->AddInstruction(_OP_LOADFLOAT, target,*((SQInt32 *)&value)); _fs->AddInstruction(_OP_LOADFLOAT, target,*((int32_t *)&value));
} }
else { else {
_fs->AddInstruction(_OP_LOAD, target, _fs->GetNumericConstant(value)); _fs->AddInstruction(_OP_LOAD, target, _fs->GetNumericConstant(value));
@ -906,7 +906,7 @@ public:
void UnaryOP(SQOpcode op) void UnaryOP(SQOpcode op)
{ {
PrefixedExpr(); PrefixedExpr();
SQInteger src = _fs->PopTarget(); int64_t src = _fs->PopTarget();
_fs->AddInstruction(op, _fs->PushTarget(), src); _fs->AddInstruction(op, _fs->PushTarget(), src);
} }
bool NeedGet() bool NeedGet()
@ -925,7 +925,7 @@ public:
} }
void FunctionCallArgs(bool rawcall = false) void FunctionCallArgs(bool rawcall = false)
{ {
SQInteger nargs = 1;//this int64_t nargs = 1;//this
while(_token != _SC(')')) { while(_token != _SC(')')) {
Expression(); Expression();
MoveIfCurrentTargetIsLocal(); MoveIfCurrentTargetIsLocal();
@ -940,14 +940,14 @@ public:
if (nargs < 3) Error(_SC("rawcall requires at least 2 parameters (callee and this)")); if (nargs < 3) Error(_SC("rawcall requires at least 2 parameters (callee and this)"));
nargs -= 2; //removes callee and this from count nargs -= 2; //removes callee and this from count
} }
for(SQInteger i = 0; i < (nargs - 1); i++) _fs->PopTarget(); for(int64_t i = 0; i < (nargs - 1); i++) _fs->PopTarget();
SQInteger stackbase = _fs->PopTarget(); int64_t stackbase = _fs->PopTarget();
SQInteger closure = _fs->PopTarget(); int64_t closure = _fs->PopTarget();
_fs->AddInstruction(_OP_CALL, _fs->PushTarget(), closure, stackbase, nargs); _fs->AddInstruction(_OP_CALL, _fs->PushTarget(), closure, stackbase, nargs);
} }
void ParseTableOrClass(SQInteger separator,SQInteger terminator) void ParseTableOrClass(int64_t separator,int64_t terminator)
{ {
SQInteger tpos = _fs->GetCurrentPos(),nkeys = 0; int64_t tpos = _fs->GetCurrentPos(),nkeys = 0;
while(_token != terminator) { while(_token != terminator) {
bool hasattrs = false; bool hasattrs = false;
bool isstatic = false; bool isstatic = false;
@ -966,7 +966,7 @@ public:
switch(_token) { switch(_token) {
case TK_FUNCTION: case TK_FUNCTION:
case TK_CONSTRUCTOR:{ case TK_CONSTRUCTOR:{
SQInteger tk = _token; int64_t tk = _token;
Lex(); Lex();
SQObject id = tk == TK_FUNCTION ? Expect(TK_IDENTIFIER) : _fs->CreateString(_SC("constructor")); SQObject id = tk == TK_FUNCTION ? Expect(TK_IDENTIFIER) : _fs->CreateString(_SC("constructor"));
Expect(_SC('(')); Expect(_SC('('));
@ -991,13 +991,13 @@ public:
} }
if(_token == separator) Lex();//optional comma/semicolon if(_token == separator) Lex();//optional comma/semicolon
nkeys++; nkeys++;
SQInteger val = _fs->PopTarget(); int64_t val = _fs->PopTarget();
SQInteger key = _fs->PopTarget(); int64_t key = _fs->PopTarget();
SQInteger attrs = hasattrs ? _fs->PopTarget():-1; int64_t attrs = hasattrs ? _fs->PopTarget():-1;
((void)attrs); ((void)attrs);
assert((hasattrs && (attrs == key-1)) || !hasattrs); assert((hasattrs && (attrs == key-1)) || !hasattrs);
unsigned char flags = (hasattrs?NEW_SLOT_ATTRIBUTES_FLAG:0)|(isstatic?NEW_SLOT_STATIC_FLAG:0); unsigned char flags = (hasattrs?NEW_SLOT_ATTRIBUTES_FLAG:0)|(isstatic?NEW_SLOT_STATIC_FLAG:0);
SQInteger table = _fs->TopTarget(); //<<BECAUSE OF THIS NO COMMON EMIT FUNC IS POSSIBLE int64_t table = _fs->TopTarget(); //<<BECAUSE OF THIS NO COMMON EMIT FUNC IS POSSIBLE
if(separator == _SC(',')) { //hack recognizes a table from the separator if(separator == _SC(',')) { //hack recognizes a table from the separator
_fs->AddInstruction(_OP_NEWSLOT, 0xFF, table, key, val); _fs->AddInstruction(_OP_NEWSLOT, 0xFF, table, key, val);
} }
@ -1028,8 +1028,8 @@ public:
varname = Expect(TK_IDENTIFIER); varname = Expect(TK_IDENTIFIER);
if(_token == _SC('=')) { if(_token == _SC('=')) {
Lex(); Expression(); Lex(); Expression();
SQInteger src = _fs->PopTarget(); int64_t src = _fs->PopTarget();
SQInteger dest = _fs->PushTarget(); int64_t dest = _fs->PushTarget();
if(dest != src) _fs->AddInstruction(_OP_MOVE, dest, src); if(dest != src) _fs->AddInstruction(_OP_MOVE, dest, src);
} }
else{ else{
@ -1064,11 +1064,11 @@ public:
} }
void IfStatement() void IfStatement()
{ {
SQInteger jmppos; int64_t jmppos;
bool haselse = false; bool haselse = false;
Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')')); Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')'));
_fs->AddInstruction(_OP_JZ, _fs->PopTarget()); _fs->AddInstruction(_OP_JZ, _fs->PopTarget());
SQInteger jnepos = _fs->GetCurrentPos(); int64_t jnepos = _fs->GetCurrentPos();
@ -1086,7 +1086,7 @@ public:
}*/ }*/
SQInteger endifblock = _fs->GetCurrentPos(); int64_t endifblock = _fs->GetCurrentPos();
if(_token == TK_ELSE){ if(_token == TK_ELSE){
haselse = true; haselse = true;
//BEGIN_SCOPE(); //BEGIN_SCOPE();
@ -1102,7 +1102,7 @@ public:
} }
void WhileStatement() void WhileStatement()
{ {
SQInteger jzpos, jmppos; int64_t jzpos, jmppos;
jmppos = _fs->GetCurrentPos(); jmppos = _fs->GetCurrentPos();
Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')')); Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')'));
@ -1122,13 +1122,13 @@ public:
void DoWhileStatement() void DoWhileStatement()
{ {
Lex(); Lex();
SQInteger jmptrg = _fs->GetCurrentPos(); int64_t jmptrg = _fs->GetCurrentPos();
BEGIN_BREAKBLE_BLOCK() BEGIN_BREAKBLE_BLOCK()
BEGIN_SCOPE(); BEGIN_SCOPE();
Statement(); Statement();
END_SCOPE(); END_SCOPE();
Expect(TK_WHILE); Expect(TK_WHILE);
SQInteger continuetrg = _fs->GetCurrentPos(); int64_t continuetrg = _fs->GetCurrentPos();
Expect(_SC('(')); CommaExpr(); Expect(_SC(')')); Expect(_SC('(')); CommaExpr(); Expect(_SC(')'));
_fs->AddInstruction(_OP_JZ, _fs->PopTarget(), 1); _fs->AddInstruction(_OP_JZ, _fs->PopTarget(), 1);
_fs->AddInstruction(_OP_JMP, 0, jmptrg - _fs->GetCurrentPos() - 1); _fs->AddInstruction(_OP_JMP, 0, jmptrg - _fs->GetCurrentPos() - 1);
@ -1146,31 +1146,31 @@ public:
} }
Expect(_SC(';')); Expect(_SC(';'));
_fs->SnoozeOpt(); _fs->SnoozeOpt();
SQInteger jmppos = _fs->GetCurrentPos(); int64_t jmppos = _fs->GetCurrentPos();
SQInteger jzpos = -1; int64_t jzpos = -1;
if(_token != _SC(';')) { CommaExpr(); _fs->AddInstruction(_OP_JZ, _fs->PopTarget()); jzpos = _fs->GetCurrentPos(); } if(_token != _SC(';')) { CommaExpr(); _fs->AddInstruction(_OP_JZ, _fs->PopTarget()); jzpos = _fs->GetCurrentPos(); }
Expect(_SC(';')); Expect(_SC(';'));
_fs->SnoozeOpt(); _fs->SnoozeOpt();
SQInteger expstart = _fs->GetCurrentPos() + 1; int64_t expstart = _fs->GetCurrentPos() + 1;
if(_token != _SC(')')) { if(_token != _SC(')')) {
CommaExpr(); CommaExpr();
_fs->PopTarget(); _fs->PopTarget();
} }
Expect(_SC(')')); Expect(_SC(')'));
_fs->SnoozeOpt(); _fs->SnoozeOpt();
SQInteger expend = _fs->GetCurrentPos(); int64_t expend = _fs->GetCurrentPos();
SQInteger expsize = (expend - expstart) + 1; int64_t expsize = (expend - expstart) + 1;
SQInstructionVec exp; SQInstructionVec exp;
if(expsize > 0) { if(expsize > 0) {
for(SQInteger i = 0; i < expsize; i++) for(int64_t i = 0; i < expsize; i++)
exp.push_back(_fs->GetInstruction(expstart + i)); exp.push_back(_fs->GetInstruction(expstart + i));
_fs->PopInstructions(expsize); _fs->PopInstructions(expsize);
} }
BEGIN_BREAKBLE_BLOCK() BEGIN_BREAKBLE_BLOCK()
Statement(); Statement();
SQInteger continuetrg = _fs->GetCurrentPos(); int64_t continuetrg = _fs->GetCurrentPos();
if(expsize > 0) { if(expsize > 0) {
for(SQInteger i = 0; i < expsize; i++) for(int64_t i = 0; i < expsize; i++)
_fs->AddInstruction(exp[i]); _fs->AddInstruction(exp[i]);
} }
_fs->AddInstruction(_OP_JMP, 0, jmppos - _fs->GetCurrentPos() - 1, 0); _fs->AddInstruction(_OP_JMP, 0, jmppos - _fs->GetCurrentPos() - 1, 0);
@ -1197,19 +1197,19 @@ public:
BEGIN_SCOPE(); BEGIN_SCOPE();
//put the table in the stack(evaluate the table expression) //put the table in the stack(evaluate the table expression)
Expression(); Expect(_SC(')')); Expression(); Expect(_SC(')'));
SQInteger container = _fs->TopTarget(); int64_t container = _fs->TopTarget();
//push the index local var //push the index local var
SQInteger indexpos = _fs->PushLocalVariable(idxname); int64_t indexpos = _fs->PushLocalVariable(idxname);
_fs->AddInstruction(_OP_LOADNULLS, indexpos,1); _fs->AddInstruction(_OP_LOADNULLS, indexpos,1);
//push the value local var //push the value local var
SQInteger valuepos = _fs->PushLocalVariable(valname); int64_t valuepos = _fs->PushLocalVariable(valname);
_fs->AddInstruction(_OP_LOADNULLS, valuepos,1); _fs->AddInstruction(_OP_LOADNULLS, valuepos,1);
//push reference index //push reference index
SQInteger itrpos = _fs->PushLocalVariable(_fs->CreateString(_SC("@ITERATOR@"))); //use invalid id to make it inaccessible int64_t itrpos = _fs->PushLocalVariable(_fs->CreateString(_SC("@ITERATOR@"))); //use invalid id to make it inaccessible
_fs->AddInstruction(_OP_LOADNULLS, itrpos,1); _fs->AddInstruction(_OP_LOADNULLS, itrpos,1);
SQInteger jmppos = _fs->GetCurrentPos(); int64_t jmppos = _fs->GetCurrentPos();
_fs->AddInstruction(_OP_FOREACH, container, 0, indexpos); _fs->AddInstruction(_OP_FOREACH, container, 0, indexpos);
SQInteger foreachpos = _fs->GetCurrentPos(); int64_t foreachpos = _fs->GetCurrentPos();
_fs->AddInstruction(_OP_POSTFOREACH, container, 0, indexpos); _fs->AddInstruction(_OP_POSTFOREACH, container, 0, indexpos);
//generate the statement code //generate the statement code
BEGIN_BREAKBLE_BLOCK() BEGIN_BREAKBLE_BLOCK()
@ -1226,11 +1226,11 @@ public:
{ {
Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')')); Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')'));
Expect(_SC('{')); Expect(_SC('{'));
SQInteger expr = _fs->TopTarget(); int64_t expr = _fs->TopTarget();
bool bfirst = true; bool bfirst = true;
SQInteger tonextcondjmp = -1; int64_t tonextcondjmp = -1;
SQInteger skipcondjmp = -1; int64_t skipcondjmp = -1;
SQInteger __nbreaks__ = _fs->_unresolvedbreaks.size(); int64_t __nbreaks__ = _fs->_unresolvedbreaks.size();
_fs->_breaktargets.push_back(0); _fs->_breaktargets.push_back(0);
while(_token == TK_CASE) { while(_token == TK_CASE) {
if(!bfirst) { if(!bfirst) {
@ -1240,8 +1240,8 @@ public:
} }
//condition //condition
Lex(); Expression(); Expect(_SC(':')); Lex(); Expression(); Expect(_SC(':'));
SQInteger trg = _fs->PopTarget(); int64_t trg = _fs->PopTarget();
SQInteger eqtarget = trg; int64_t eqtarget = trg;
bool local = _fs->IsLocal(trg); bool local = _fs->IsLocal(trg);
if(local) { if(local) {
eqtarget = _fs->PushTarget(); //we need to allocate a extra reg eqtarget = _fs->PushTarget(); //we need to allocate a extra reg
@ -1366,7 +1366,7 @@ public:
Expect(_SC('{')); Expect(_SC('{'));
SQObject table = _fs->CreateTable(); SQObject table = _fs->CreateTable();
SQInteger nval = 0; int64_t nval = 0;
while(_token != _SC('}')) { while(_token != _SC('}')) {
SQObject key = Expect(TK_IDENTIFIER); SQObject key = Expect(TK_IDENTIFIER);
SQObject val; SQObject val;
@ -1395,7 +1395,7 @@ public:
_fs->_traps++; _fs->_traps++;
if(_fs->_breaktargets.size()) _fs->_breaktargets.top()++; if(_fs->_breaktargets.size()) _fs->_breaktargets.top()++;
if(_fs->_continuetargets.size()) _fs->_continuetargets.top()++; if(_fs->_continuetargets.size()) _fs->_continuetargets.top()++;
SQInteger trappos = _fs->GetCurrentPos(); int64_t trappos = _fs->GetCurrentPos();
{ {
BEGIN_SCOPE(); BEGIN_SCOPE();
Statement(); Statement();
@ -1406,19 +1406,19 @@ public:
if(_fs->_breaktargets.size()) _fs->_breaktargets.top()--; if(_fs->_breaktargets.size()) _fs->_breaktargets.top()--;
if(_fs->_continuetargets.size()) _fs->_continuetargets.top()--; if(_fs->_continuetargets.size()) _fs->_continuetargets.top()--;
_fs->AddInstruction(_OP_JMP, 0, 0); _fs->AddInstruction(_OP_JMP, 0, 0);
SQInteger jmppos = _fs->GetCurrentPos(); int64_t jmppos = _fs->GetCurrentPos();
_fs->SetIntructionParam(trappos, 1, (_fs->GetCurrentPos() - trappos)); _fs->SetIntructionParam(trappos, 1, (_fs->GetCurrentPos() - trappos));
Expect(TK_CATCH); Expect(_SC('(')); exid = Expect(TK_IDENTIFIER); Expect(_SC(')')); Expect(TK_CATCH); Expect(_SC('(')); exid = Expect(TK_IDENTIFIER); Expect(_SC(')'));
{ {
BEGIN_SCOPE(); BEGIN_SCOPE();
SQInteger ex_target = _fs->PushLocalVariable(exid); int64_t ex_target = _fs->PushLocalVariable(exid);
_fs->SetIntructionParam(trappos, 0, ex_target); _fs->SetIntructionParam(trappos, 0, ex_target);
Statement(); Statement();
_fs->SetIntructionParams(jmppos, 0, (_fs->GetCurrentPos() - jmppos), 0); _fs->SetIntructionParams(jmppos, 0, (_fs->GetCurrentPos() - jmppos), 0);
END_SCOPE(); END_SCOPE();
} }
} }
void FunctionExp(SQInteger ftype,bool lambda = false) void FunctionExp(int64_t ftype,bool lambda = false)
{ {
Lex(); Expect(_SC('(')); Lex(); Expect(_SC('('));
SQObjectPtr dummy; SQObjectPtr dummy;
@ -1427,8 +1427,8 @@ public:
} }
void ClassExp() void ClassExp()
{ {
SQInteger base = -1; int64_t base = -1;
SQInteger attrs = -1; int64_t attrs = -1;
if(_token == TK_EXTENDS) { if(_token == TK_EXTENDS) {
Lex(); Expression(); Lex(); Expression();
base = _fs->TopTarget(); base = _fs->TopTarget();
@ -1461,10 +1461,10 @@ public:
} }
_es = es; _es = es;
} }
void PrefixIncDec(SQInteger token) void PrefixIncDec(int64_t token)
{ {
SQExpState es; SQExpState es;
SQInteger diff = (token==TK_MINUSMINUS) ? -1 : 1; int64_t diff = (token==TK_MINUSMINUS) ? -1 : 1;
Lex(); Lex();
es = _es; es = _es;
_es.donot_get = true; _es.donot_get = true;
@ -1476,12 +1476,12 @@ public:
Emit2ArgsOP(_OP_INC, diff); Emit2ArgsOP(_OP_INC, diff);
} }
else if(_es.etype==LOCAL) { else if(_es.etype==LOCAL) {
SQInteger src = _fs->TopTarget(); int64_t src = _fs->TopTarget();
_fs->AddInstruction(_OP_INCL, src, src, 0, diff); _fs->AddInstruction(_OP_INCL, src, src, 0, diff);
} }
else if(_es.etype==OUTER) { else if(_es.etype==OUTER) {
SQInteger tmp = _fs->PushTarget(); int64_t tmp = _fs->PushTarget();
_fs->AddInstruction(_OP_GETOUTER, tmp, _es.epos); _fs->AddInstruction(_OP_GETOUTER, tmp, _es.epos);
_fs->AddInstruction(_OP_INCL, tmp, tmp, 0, diff); _fs->AddInstruction(_OP_INCL, tmp, tmp, 0, diff);
_fs->AddInstruction(_OP_SETOUTER, tmp, _es.epos, tmp); _fs->AddInstruction(_OP_SETOUTER, tmp, _es.epos, tmp);
@ -1495,7 +1495,7 @@ public:
SQObject paramname; SQObject paramname;
funcstate->AddParameter(_fs->CreateString(_SC("this"))); funcstate->AddParameter(_fs->CreateString(_SC("this")));
funcstate->_sourcename = _sourcename; funcstate->_sourcename = _sourcename;
SQInteger defparams = 0; int64_t defparams = 0;
while(_token!=_SC(')')) { while(_token!=_SC(')')) {
if(_token == TK_VARPARAMS) { if(_token == TK_VARPARAMS) {
if(defparams > 0) Error(_SC("function with default parameters cannot have variable number of parameters")); if(defparams > 0) Error(_SC("function with default parameters cannot have variable number of parameters"));
@ -1522,7 +1522,7 @@ public:
} }
} }
Expect(_SC(')')); Expect(_SC(')'));
for(SQInteger n = 0; n < defparams; n++) { for(int64_t n = 0; n < defparams; n++) {
_fs->PopTarget(); _fs->PopTarget();
} }
@ -1546,20 +1546,20 @@ public:
_fs->_functions.push_back(func); _fs->_functions.push_back(func);
_fs->PopChildState(); _fs->PopChildState();
} }
void ResolveBreaks(SQFuncState *funcstate, SQInteger ntoresolve) void ResolveBreaks(SQFuncState *funcstate, int64_t ntoresolve)
{ {
while(ntoresolve > 0) { while(ntoresolve > 0) {
SQInteger pos = funcstate->_unresolvedbreaks.back(); int64_t pos = funcstate->_unresolvedbreaks.back();
funcstate->_unresolvedbreaks.pop_back(); funcstate->_unresolvedbreaks.pop_back();
//set the jmp instruction //set the jmp instruction
funcstate->SetIntructionParams(pos, 0, funcstate->GetCurrentPos() - pos, 0); funcstate->SetIntructionParams(pos, 0, funcstate->GetCurrentPos() - pos, 0);
ntoresolve--; ntoresolve--;
} }
} }
void ResolveContinues(SQFuncState *funcstate, SQInteger ntoresolve, SQInteger targetpos) void ResolveContinues(SQFuncState *funcstate, int64_t ntoresolve, int64_t targetpos)
{ {
while(ntoresolve > 0) { while(ntoresolve > 0) {
SQInteger pos = funcstate->_unresolvedcontinues.back(); int64_t pos = funcstate->_unresolvedcontinues.back();
funcstate->_unresolvedcontinues.pop_back(); funcstate->_unresolvedcontinues.pop_back();
//set the jmp instruction //set the jmp instruction
funcstate->SetIntructionParams(pos, 0, targetpos - pos, 0); funcstate->SetIntructionParams(pos, 0, targetpos - pos, 0);
@ -1567,14 +1567,14 @@ public:
} }
} }
private: private:
SQInteger _token; int64_t _token;
SQFuncState *_fs; SQFuncState *_fs;
SQObjectPtr _sourcename; SQObjectPtr _sourcename;
SQLexer _lex; SQLexer _lex;
bool _lineinfo; bool _lineinfo;
bool _raiseerror; bool _raiseerror;
SQInteger _debugline; int64_t _debugline;
SQInteger _debugop; int64_t _debugop;
SQExpState _es; SQExpState _es;
SQScope _scope; SQScope _scope;
SQChar _compilererror[MAX_COMPILER_ERROR_LEN]; SQChar _compilererror[MAX_COMPILER_ERROR_LEN];

50
rabbit/sqconfig.hpp
View File

@ -7,57 +7,33 @@
*/ */
#pragma once #pragma once
#ifdef _SQ64 #include <etk/types.hpp>
#ifdef _MSC_VER // should be the same size of a pointer
typedef __int64 SQInteger; using SQHash = size_t;
typedef unsigned __int64 SQUnsignedInteger;
typedef unsigned __int64 SQHash; /*should be the same size of a pointer*/
#else
typedef long long SQInteger;
typedef unsigned long long SQUnsignedInteger;
typedef unsigned long long SQHash; /*should be the same size of a pointer*/
#endif
typedef int SQInt32;
typedef unsigned int SQUnsignedInteger32;
#else
typedef int SQInteger;
typedef int SQInt32; /*must be 32 bits(also on 64bits processors)*/
typedef unsigned int SQUnsignedInteger32; /*must be 32 bits(also on 64bits processors)*/
typedef unsigned int SQUnsignedInteger;
typedef unsigned int SQHash; /*should be the same size of a pointer*/
#endif
#ifdef SQUSEDOUBLE #ifdef SQUSEDOUBLE
typedef double SQFloat; typedef double float_t;
#else #else
typedef float SQFloat; typedef float float_t;
#endif #endif
#if defined(SQUSEDOUBLE) && !defined(_SQ64) || !defined(SQUSEDOUBLE) && defined(_SQ64) #if defined(SQUSEDOUBLE) && !defined(_SQ64) || !defined(SQUSEDOUBLE) && defined(_SQ64)
#ifdef _MSC_VER typedef uint64_t SQRawObjectVal; //must be 64bits
typedef __int64 SQRawObjectVal; //must be 64bits
#else
typedef long long SQRawObjectVal; //must be 64bits
#endif
#define SQ_OBJECT_RAWINIT() { _unVal.raw = 0; } #define SQ_OBJECT_RAWINIT() { _unVal.raw = 0; }
#else #else
typedef SQUnsignedInteger SQRawObjectVal; //is 32 bits on 32 bits builds and 64 bits otherwise typedef uint64_t SQRawObjectVal; //is 32 bits on 32 bits builds and 64 bits otherwise
#define SQ_OBJECT_RAWINIT() #define SQ_OBJECT_RAWINIT()
#endif #endif
#ifndef SQ_ALIGNMENT // SQ_ALIGNMENT shall be less than or equal to SQ_MALLOC alignments, and its value shall be power of 2. #ifndef SQ_ALIGNMENT
#if defined(SQUSEDOUBLE) || defined(_SQ64)
#define SQ_ALIGNMENT 8 #define SQ_ALIGNMENT 8
#else
#define SQ_ALIGNMENT 4
#endif
#endif #endif
typedef void* SQUserPointer; typedef void* SQUserPointer;
typedef SQUnsignedInteger SQBool; typedef uint64_t SQBool;
typedef SQInteger SQRESULT; typedef int64_t SQRESULT;
#ifdef SQUNICODE #ifdef SQUNICODE
#include <wchar.h> #include <wchar.h>
@ -146,9 +122,5 @@ typedef char SQChar;
#endif #endif
#ifdef _SQ64
#define _PRINT_INT_PREC _SC("ll") #define _PRINT_INT_PREC _SC("ll")
#define _PRINT_INT_FMT _SC("%lld") #define _PRINT_INT_FMT _SC("%ld")
#else
#define _PRINT_INT_FMT _SC("%d")
#endif

18
rabbit/sqdebug.cpp
View File

@ -13,9 +13,9 @@
#include <rabbit/sqclosure.hpp> #include <rabbit/sqclosure.hpp>
#include <rabbit/sqstring.hpp> #include <rabbit/sqstring.hpp>
SQRESULT sq_getfunctioninfo(HRABBITVM v,SQInteger level,SQFunctionInfo *fi) SQRESULT sq_getfunctioninfo(HRABBITVM v,int64_t level,SQFunctionInfo *fi)
{ {
SQInteger cssize = v->_callsstacksize; int64_t cssize = v->_callsstacksize;
if (cssize > level) { if (cssize > level) {
SQVM::CallInfo &ci = v->_callsstack[cssize-level-1]; SQVM::CallInfo &ci = v->_callsstack[cssize-level-1];
if(sq_isclosure(ci._closure)) { if(sq_isclosure(ci._closure)) {
@ -31,9 +31,9 @@ SQRESULT sq_getfunctioninfo(HRABBITVM 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(HRABBITVM v, SQInteger level, SQStackInfos *si) SQRESULT sq_stackinfos(HRABBITVM v, int64_t level, SQStackInfos *si)
{ {
SQInteger cssize = v->_callsstacksize; int64_t cssize = v->_callsstacksize;
if (cssize > level) { if (cssize > level) {
memset(si, 0, sizeof(SQStackInfos)); memset(si, 0, sizeof(SQStackInfos));
SQVM::CallInfo &ci = v->_callsstack[cssize-level-1]; SQVM::CallInfo &ci = v->_callsstack[cssize-level-1];
@ -65,7 +65,7 @@ void SQVM::Raise_Error(const SQChar *s, ...)
{ {
va_list vl; va_list vl;
va_start(vl, s); va_start(vl, s);
SQInteger buffersize = (SQInteger)scstrlen(s)+(NUMBER_MAX_CHAR*2); int64_t buffersize = (int64_t)scstrlen(s)+(NUMBER_MAX_CHAR*2);
scvsprintf(_sp(sq_rsl(buffersize)),buffersize, s, vl); scvsprintf(_sp(sq_rsl(buffersize)),buffersize, s, vl);
va_end(vl); va_end(vl);
_lasterror = SQString::Create(_ss(this),_spval,-1); _lasterror = SQString::Create(_ss(this),_spval,-1);
@ -106,13 +106,13 @@ void SQVM::Raise_CompareError(const SQObject &o1, const SQObject &o2)
} }
void SQVM::Raise_ParamTypeError(SQInteger nparam,SQInteger typemask,SQInteger type) void SQVM::Raise_ParamTypeError(int64_t nparam,int64_t typemask,int64_t type)
{ {
SQObjectPtr exptypes = SQString::Create(_ss(this), _SC(""), -1); SQObjectPtr exptypes = SQString::Create(_ss(this), _SC(""), -1);
SQInteger found = 0; int64_t found = 0;
for(SQInteger i=0; i<16; i++) for(int64_t i=0; i<16; i++)
{ {
SQInteger mask = ((SQInteger)1) << i; int64_t mask = ((int64_t)1) << i;
if(typemask & (mask)) { if(typemask & (mask)) {
if(found>0) StringCat(exptypes,SQString::Create(_ss(this), _SC("|"), -1), exptypes); if(found>0) StringCat(exptypes,SQString::Create(_ss(this), _SC("|"), -1), exptypes);
found ++; found ++;

48
rabbit/sqfuncproto.hpp
View File

@ -46,12 +46,12 @@ struct SQLocalVarInfo
_pos=lvi._pos; _pos=lvi._pos;
} }
SQObjectPtr _name; SQObjectPtr _name;
SQUnsignedInteger _start_op; uint64_t _start_op;
SQUnsignedInteger _end_op; uint64_t _end_op;
SQUnsignedInteger _pos; uint64_t _pos;
}; };
struct SQLineInfo { SQInteger _line;SQInteger _op; }; struct SQLineInfo { int64_t _line;int64_t _op; };
typedef sqvector<SQOuterVar> SQOuterVarVec; typedef sqvector<SQOuterVar> SQOuterVarVec;
typedef sqvector<SQLocalVarInfo> SQLocalVarInfoVec; typedef sqvector<SQLocalVarInfo> SQLocalVarInfoVec;
@ -61,7 +61,7 @@ typedef sqvector<SQLineInfo> SQLineInfoVec;
+((ni-1)*sizeof(SQInstruction))+(nl*sizeof(SQObjectPtr)) \ +((ni-1)*sizeof(SQInstruction))+(nl*sizeof(SQObjectPtr)) \
+(nparams*sizeof(SQObjectPtr))+(nfuncs*sizeof(SQObjectPtr)) \ +(nparams*sizeof(SQObjectPtr))+(nfuncs*sizeof(SQObjectPtr)) \
+(nouters*sizeof(SQOuterVar))+(nlineinf*sizeof(SQLineInfo)) \ +(nouters*sizeof(SQOuterVar))+(nlineinf*sizeof(SQLineInfo)) \
+(localinf*sizeof(SQLocalVarInfo))+(defparams*sizeof(SQInteger))) +(localinf*sizeof(SQLocalVarInfo))+(defparams*sizeof(int64_t)))
struct SQFunctionProto : public SQRefCounted struct SQFunctionProto : public SQRefCounted
@ -71,10 +71,10 @@ private:
~SQFunctionProto(); ~SQFunctionProto();
public: public:
static SQFunctionProto *Create(SQSharedState *ss,SQInteger ninstructions, static SQFunctionProto *Create(SQSharedState *ss,int64_t ninstructions,
SQInteger nliterals,SQInteger nparameters, int64_t nliterals,int64_t nparameters,
SQInteger nfunctions,SQInteger noutervalues, int64_t nfunctions,int64_t noutervalues,
SQInteger nlineinfos,SQInteger nlocalvarinfos,SQInteger ndefaultparams) int64_t nlineinfos,int64_t nlocalvarinfos,int64_t ndefaultparams)
{ {
SQFunctionProto *f; SQFunctionProto *f;
//I compact the whole class and members in a single memory allocation //I compact the whole class and members in a single memory allocation
@ -93,7 +93,7 @@ public:
f->_nlineinfos = nlineinfos; f->_nlineinfos = nlineinfos;
f->_localvarinfos = (SQLocalVarInfo *)&f->_lineinfos[nlineinfos]; f->_localvarinfos = (SQLocalVarInfo *)&f->_lineinfos[nlineinfos];
f->_nlocalvarinfos = nlocalvarinfos; f->_nlocalvarinfos = nlocalvarinfos;
f->_defaultparams = (SQInteger *)&f->_localvarinfos[nlocalvarinfos]; f->_defaultparams = (int64_t *)&f->_localvarinfos[nlocalvarinfos];
f->_ndefaultparams = ndefaultparams; f->_ndefaultparams = ndefaultparams;
_CONSTRUCT_VECTOR(SQObjectPtr,f->_nliterals,f->_literals); _CONSTRUCT_VECTOR(SQObjectPtr,f->_nliterals,f->_literals);
@ -111,42 +111,42 @@ public:
_DESTRUCT_VECTOR(SQOuterVar,_noutervalues,_outervalues); _DESTRUCT_VECTOR(SQOuterVar,_noutervalues,_outervalues);
//_DESTRUCT_VECTOR(SQLineInfo,_nlineinfos,_lineinfos); //not required are 2 integers //_DESTRUCT_VECTOR(SQLineInfo,_nlineinfos,_lineinfos); //not required are 2 integers
_DESTRUCT_VECTOR(SQLocalVarInfo,_nlocalvarinfos,_localvarinfos); _DESTRUCT_VECTOR(SQLocalVarInfo,_nlocalvarinfos,_localvarinfos);
SQInteger size = _FUNC_SIZE(_ninstructions,_nliterals,_nparameters,_nfunctions,_noutervalues,_nlineinfos,_nlocalvarinfos,_ndefaultparams); int64_t size = _FUNC_SIZE(_ninstructions,_nliterals,_nparameters,_nfunctions,_noutervalues,_nlineinfos,_nlocalvarinfos,_ndefaultparams);
this->~SQFunctionProto(); this->~SQFunctionProto();
sq_vm_free(this,size); sq_vm_free(this,size);
} }
const SQChar* GetLocal(SQVM *v,SQUnsignedInteger stackbase,SQUnsignedInteger nseq,SQUnsignedInteger nop); const SQChar* GetLocal(SQVM *v,uint64_t stackbase,uint64_t nseq,uint64_t nop);
SQInteger GetLine(SQInstruction *curr); int64_t 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);
SQObjectPtr _sourcename; SQObjectPtr _sourcename;
SQObjectPtr _name; SQObjectPtr _name;
SQInteger _stacksize; int64_t _stacksize;
bool _bgenerator; bool _bgenerator;
SQInteger _varparams; int64_t _varparams;
SQInteger _nlocalvarinfos; int64_t _nlocalvarinfos;
SQLocalVarInfo *_localvarinfos; SQLocalVarInfo *_localvarinfos;
SQInteger _nlineinfos; int64_t _nlineinfos;
SQLineInfo *_lineinfos; SQLineInfo *_lineinfos;
SQInteger _nliterals; int64_t _nliterals;
SQObjectPtr *_literals; SQObjectPtr *_literals;
SQInteger _nparameters; int64_t _nparameters;
SQObjectPtr *_parameters; SQObjectPtr *_parameters;
SQInteger _nfunctions; int64_t _nfunctions;
SQObjectPtr *_functions; SQObjectPtr *_functions;
SQInteger _noutervalues; int64_t _noutervalues;
SQOuterVar *_outervalues; SQOuterVar *_outervalues;
SQInteger _ndefaultparams; int64_t _ndefaultparams;
SQInteger *_defaultparams; int64_t *_defaultparams;
SQInteger _ninstructions; int64_t _ninstructions;
SQInstruction _instructions[1]; SQInstruction _instructions[1];
}; };

142
rabbit/sqfuncstate.cpp
View File

@ -120,15 +120,15 @@ void SQFuncState::Error(const SQChar *err)
#ifdef _DEBUG_DUMP #ifdef _DEBUG_DUMP
void SQFuncState::Dump(SQFunctionProto *func) void SQFuncState::Dump(SQFunctionProto *func)
{ {
SQUnsignedInteger n=0,i; uint64_t n=0,i;
SQInteger si; int64_t si;
scprintf(_SC("SQInstruction sizeof %d\n"),(SQInt32)sizeof(SQInstruction)); scprintf(_SC("SQInstruction sizeof %d\n"),(int32_t)sizeof(SQInstruction));
scprintf(_SC("SQObject sizeof %d\n"), (SQInt32)sizeof(SQObject)); scprintf(_SC("SQObject sizeof %d\n"), (int32_t)sizeof(SQObject));
scprintf(_SC("--------------------------------------------------------------------\n")); scprintf(_SC("--------------------------------------------------------------------\n"));
scprintf(_SC("*****FUNCTION [%s]\n"),sq_type(func->_name)==OT_STRING?_stringval(func->_name):_SC("unknown")); scprintf(_SC("*****FUNCTION [%s]\n"),sq_type(func->_name)==OT_STRING?_stringval(func->_name):_SC("unknown"));
scprintf(_SC("-----LITERALS\n")); scprintf(_SC("-----LITERALS\n"));
SQObjectPtr refidx,key,val; SQObjectPtr refidx,key,val;
SQInteger idx; int64_t idx;
SQObjectPtrVec templiterals; SQObjectPtrVec templiterals;
templiterals.resize(_nliterals); templiterals.resize(_nliterals);
while((idx=_table(_literals)->Next(false,refidx,key,val))!=-1) { while((idx=_table(_literals)->Next(false,refidx,key,val))!=-1) {
@ -136,7 +136,7 @@ void SQFuncState::Dump(SQFunctionProto *func)
templiterals[_integer(val)]=key; templiterals[_integer(val)]=key;
} }
for(i=0;i<templiterals.size();i++){ for(i=0;i<templiterals.size();i++){
scprintf(_SC("[%d] "), (SQInt32)n); scprintf(_SC("[%d] "), (int32_t)n);
DumpLiteral(templiterals[i]); DumpLiteral(templiterals[i]);
scprintf(_SC("\n")); scprintf(_SC("\n"));
n++; n++;
@ -146,7 +146,7 @@ void SQFuncState::Dump(SQFunctionProto *func)
scprintf(_SC("<<VARPARAMS>>\n")); scprintf(_SC("<<VARPARAMS>>\n"));
n=0; n=0;
for(i=0;i<_parameters.size();i++){ for(i=0;i<_parameters.size();i++){
scprintf(_SC("[%d] "), (SQInt32)n); scprintf(_SC("[%d] "), (int32_t)n);
DumpLiteral(_parameters[i]); DumpLiteral(_parameters[i]);
scprintf(_SC("\n")); scprintf(_SC("\n"));
n++; n++;
@ -154,13 +154,13 @@ void SQFuncState::Dump(SQFunctionProto *func)
scprintf(_SC("-----LOCALS\n")); scprintf(_SC("-----LOCALS\n"));
for(si=0;si<func->_nlocalvarinfos;si++){ for(si=0;si<func->_nlocalvarinfos;si++){
SQLocalVarInfo lvi=func->_localvarinfos[si]; SQLocalVarInfo lvi=func->_localvarinfos[si];
scprintf(_SC("[%d] %s \t%d %d\n"), (SQInt32)lvi._pos,_stringval(lvi._name), (SQInt32)lvi._start_op, (SQInt32)lvi._end_op); scprintf(_SC("[%d] %s \t%d %d\n"), (int32_t)lvi._pos,_stringval(lvi._name), (int32_t)lvi._start_op, (int32_t)lvi._end_op);
n++; n++;
} }
scprintf(_SC("-----LINE INFO\n")); scprintf(_SC("-----LINE INFO\n"));
for(i=0;i<_lineinfos.size();i++){ for(i=0;i<_lineinfos.size();i++){
SQLineInfo li=_lineinfos[i]; SQLineInfo li=_lineinfos[i];
scprintf(_SC("op [%d] line [%d] \n"), (SQInt32)li._op, (SQInt32)li._line); scprintf(_SC("op [%d] line [%d] \n"), (int32_t)li._op, (int32_t)li._line);
n++; n++;
} }
scprintf(_SC("-----dump\n")); scprintf(_SC("-----dump\n"));
@ -169,12 +169,12 @@ void SQFuncState::Dump(SQFunctionProto *func)
SQInstruction &inst=_instructions[i]; SQInstruction &inst=_instructions[i];
if(inst.op==_OP_LOAD || inst.op==_OP_DLOAD || inst.op==_OP_PREPCALLK || inst.op==_OP_GETK ){ if(inst.op==_OP_LOAD || inst.op==_OP_DLOAD || inst.op==_OP_PREPCALLK || inst.op==_OP_GETK ){
SQInteger lidx = inst._arg1; int64_t lidx = inst._arg1;
scprintf(_SC("[%03d] %15s %d "), (SQInt32)n,g_InstrDesc[inst.op].name,inst._arg0); scprintf(_SC("[%03d] %15s %d "), (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0);
if(lidx >= 0xFFFFFFFF) if(lidx >= 0xFFFFFFFF)
scprintf(_SC("null")); scprintf(_SC("null"));
else { else {
SQInteger refidx; int64_t refidx;
SQObjectPtr val,key,refo; SQObjectPtr val,key,refo;
while(((refidx=_table(_literals)->Next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) { while(((refidx=_table(_literals)->Next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) {
refo = refidx; refo = refidx;
@ -190,7 +190,7 @@ void SQFuncState::Dump(SQFunctionProto *func)
if(lidx >= 0xFFFFFFFF) if(lidx >= 0xFFFFFFFF)
scprintf(_SC("null")); scprintf(_SC("null"));
else { else {
SQInteger refidx; int64_t refidx;
SQObjectPtr val,key,refo; SQObjectPtr val,key,refo;
while(((refidx=_table(_literals)->Next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) { while(((refidx=_table(_literals)->Next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) {
refo = refidx; refo = refidx;
@ -201,33 +201,33 @@ void SQFuncState::Dump(SQFunctionProto *func)
} }
} }
else if(inst.op==_OP_LOADFLOAT) { else if(inst.op==_OP_LOADFLOAT) {
scprintf(_SC("[%03d] %15s %d %f %d %d\n"), (SQInt32)n,g_InstrDesc[inst.op].name,inst._arg0,*((SQFloat*)&inst._arg1),inst._arg2,inst._arg3); scprintf(_SC("[%03d] %15s %d %f %d %d\n"), (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0,*((float_t*)&inst._arg1),inst._arg2,inst._arg3);
} }
/* else if(inst.op==_OP_ARITH){ /* else if(inst.op==_OP_ARITH){
scprintf(_SC("[%03d] %15s %d %d %d %c\n"),n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3); scprintf(_SC("[%03d] %15s %d %d %d %c\n"),n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3);
}*/ }*/
else { else {
scprintf(_SC("[%03d] %15s %d %d %d %d\n"), (SQInt32)n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3); scprintf(_SC("[%03d] %15s %d %d %d %d\n"), (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3);
} }
n++; n++;
} }
scprintf(_SC("-----\n")); scprintf(_SC("-----\n"));
scprintf(_SC("stack size[%d]\n"), (SQInt32)func->_stacksize); scprintf(_SC("stack size[%d]\n"), (int32_t)func->_stacksize);
scprintf(_SC("--------------------------------------------------------------------\n\n")); scprintf(_SC("--------------------------------------------------------------------\n\n"));
} }
#endif #endif
SQInteger SQFuncState::GetNumericConstant(const SQInteger cons) int64_t SQFuncState::GetNumericConstant(const int64_t cons)
{ {
return GetConstant(SQObjectPtr(cons)); return GetConstant(SQObjectPtr(cons));
} }
SQInteger SQFuncState::GetNumericConstant(const SQFloat cons) int64_t SQFuncState::GetNumericConstant(const float_t cons)
{ {
return GetConstant(SQObjectPtr(cons)); return GetConstant(SQObjectPtr(cons));
} }
SQInteger SQFuncState::GetConstant(const SQObject &cons) int64_t SQFuncState::GetConstant(const SQObject &cons)
{ {
SQObjectPtr val; SQObjectPtr val;
if(!_table(_literals)->Get(cons,val)) if(!_table(_literals)->Get(cons,val))
@ -243,36 +243,36 @@ SQInteger SQFuncState::GetConstant(const SQObject &cons)
return _integer(val); return _integer(val);
} }
void SQFuncState::SetIntructionParams(SQInteger pos,SQInteger arg0,SQInteger arg1,SQInteger arg2,SQInteger arg3) void SQFuncState::SetIntructionParams(int64_t pos,int64_t arg0,int64_t arg1,int64_t arg2,int64_t arg3)
{ {
_instructions[pos]._arg0=(unsigned char)*((SQUnsignedInteger *)&arg0); _instructions[pos]._arg0=(unsigned char)*((uint64_t *)&arg0);
_instructions[pos]._arg1=(SQInt32)*((SQUnsignedInteger *)&arg1); _instructions[pos]._arg1=(int32_t)*((uint64_t *)&arg1);
_instructions[pos]._arg2=(unsigned char)*((SQUnsignedInteger *)&arg2); _instructions[pos]._arg2=(unsigned char)*((uint64_t *)&arg2);
_instructions[pos]._arg3=(unsigned char)*((SQUnsignedInteger *)&arg3); _instructions[pos]._arg3=(unsigned char)*((uint64_t *)&arg3);
} }
void SQFuncState::SetIntructionParam(SQInteger pos,SQInteger arg,SQInteger val) void SQFuncState::SetIntructionParam(int64_t pos,int64_t arg,int64_t val)
{ {
switch(arg){ switch(arg){
case 0:_instructions[pos]._arg0=(unsigned char)*((SQUnsignedInteger *)&val);break; case 0:_instructions[pos]._arg0=(unsigned char)*((uint64_t *)&val);break;
case 1:case 4:_instructions[pos]._arg1=(SQInt32)*((SQUnsignedInteger *)&val);break; case 1:case 4:_instructions[pos]._arg1=(int32_t)*((uint64_t *)&val);break;
case 2:_instructions[pos]._arg2=(unsigned char)*((SQUnsignedInteger *)&val);break; case 2:_instructions[pos]._arg2=(unsigned char)*((uint64_t *)&val);break;
case 3:_instructions[pos]._arg3=(unsigned char)*((SQUnsignedInteger *)&val);break; case 3:_instructions[pos]._arg3=(unsigned char)*((uint64_t *)&val);break;
}; };
} }
SQInteger SQFuncState::AllocStackPos() int64_t SQFuncState::AllocStackPos()
{ {
SQInteger npos=_vlocals.size(); int64_t npos=_vlocals.size();
_vlocals.push_back(SQLocalVarInfo()); _vlocals.push_back(SQLocalVarInfo());
if(_vlocals.size()>((SQUnsignedInteger)_stacksize)) { if(_vlocals.size()>((uint64_t)_stacksize)) {
if(_stacksize>MAX_FUNC_STACKSIZE) Error(_SC("internal compiler error: too many locals")); if(_stacksize>MAX_FUNC_STACKSIZE) Error(_SC("internal compiler error: too many locals"));
_stacksize=_vlocals.size(); _stacksize=_vlocals.size();
} }
return npos; return npos;
} }
SQInteger SQFuncState::PushTarget(SQInteger n) int64_t SQFuncState::PushTarget(int64_t n)
{ {
if(n!=-1){ if(n!=-1){
_targetstack.push_back(n); _targetstack.push_back(n);
@ -283,16 +283,16 @@ SQInteger SQFuncState::PushTarget(SQInteger n)
return n; return n;
} }
SQInteger SQFuncState::GetUpTarget(SQInteger n){ int64_t SQFuncState::GetUpTarget(int64_t n){
return _targetstack[((_targetstack.size()-1)-n)]; return _targetstack[((_targetstack.size()-1)-n)];
} }
SQInteger SQFuncState::TopTarget(){ int64_t SQFuncState::TopTarget(){
return _targetstack.back(); return _targetstack.back();
} }
SQInteger SQFuncState::PopTarget() int64_t SQFuncState::PopTarget()
{ {
SQUnsignedInteger npos=_targetstack.back(); uint64_t npos=_targetstack.back();
assert(npos < _vlocals.size()); assert(npos < _vlocals.size());
SQLocalVarInfo &t = _vlocals[npos]; SQLocalVarInfo &t = _vlocals[npos];
if(sq_type(t._name)==OT_NULL){ if(sq_type(t._name)==OT_NULL){
@ -302,15 +302,15 @@ SQInteger SQFuncState::PopTarget()
return npos; return npos;
} }
SQInteger SQFuncState::GetStackSize() int64_t SQFuncState::GetStackSize()
{ {
return _vlocals.size(); return _vlocals.size();
} }
SQInteger SQFuncState::CountOuters(SQInteger stacksize) int64_t SQFuncState::CountOuters(int64_t stacksize)
{ {
SQInteger outers = 0; int64_t outers = 0;
SQInteger k = _vlocals.size() - 1; int64_t k = _vlocals.size() - 1;
while(k >= stacksize) { while(k >= stacksize) {
SQLocalVarInfo &lvi = _vlocals[k]; SQLocalVarInfo &lvi = _vlocals[k];
k--; k--;
@ -321,9 +321,9 @@ SQInteger SQFuncState::CountOuters(SQInteger stacksize)
return outers; return outers;
} }
void SQFuncState::SetStackSize(SQInteger n) void SQFuncState::SetStackSize(int64_t n)
{ {
SQInteger size=_vlocals.size(); int64_t size=_vlocals.size();
while(size>n){ while(size>n){
size--; size--;
SQLocalVarInfo lvi = _vlocals.back(); SQLocalVarInfo lvi = _vlocals.back();
@ -348,30 +348,30 @@ bool SQFuncState::IsConstant(const SQObject &name,SQObject &e)
return false; return false;
} }
bool SQFuncState::IsLocal(SQUnsignedInteger stkpos) bool SQFuncState::IsLocal(uint64_t stkpos)
{ {
if(stkpos>=_vlocals.size())return false; if(stkpos>=_vlocals.size())return false;
else if(sq_type(_vlocals[stkpos]._name)!=OT_NULL)return true; else if(sq_type(_vlocals[stkpos]._name)!=OT_NULL)return true;
return false; return false;
} }
SQInteger SQFuncState::PushLocalVariable(const SQObject &name) int64_t SQFuncState::PushLocalVariable(const SQObject &name)
{ {
SQInteger pos=_vlocals.size(); int64_t pos=_vlocals.size();
SQLocalVarInfo lvi; SQLocalVarInfo lvi;
lvi._name=name; lvi._name=name;
lvi._start_op=GetCurrentPos()+1; lvi._start_op=GetCurrentPos()+1;
lvi._pos=_vlocals.size(); lvi._pos=_vlocals.size();
_vlocals.push_back(lvi); _vlocals.push_back(lvi);
if(_vlocals.size()>((SQUnsignedInteger)_stacksize))_stacksize=_vlocals.size(); if(_vlocals.size()>((uint64_t)_stacksize))_stacksize=_vlocals.size();
return pos; return pos;
} }
SQInteger SQFuncState::GetLocalVariable(const SQObject &name) int64_t SQFuncState::GetLocalVariable(const SQObject &name)
{ {
SQInteger locals=_vlocals.size(); int64_t locals=_vlocals.size();
while(locals>=1){ while(locals>=1){
SQLocalVarInfo &lvi = _vlocals[locals-1]; SQLocalVarInfo &lvi = _vlocals[locals-1];
if(sq_type(lvi._name)==OT_STRING && _string(lvi._name)==_string(name)){ if(sq_type(lvi._name)==OT_STRING && _string(lvi._name)==_string(name)){
@ -382,33 +382,33 @@ SQInteger SQFuncState::GetLocalVariable(const SQObject &name)
return -1; return -1;
} }
void SQFuncState::MarkLocalAsOuter(SQInteger pos) void SQFuncState::MarkLocalAsOuter(int64_t pos)
{ {
SQLocalVarInfo &lvi = _vlocals[pos]; SQLocalVarInfo &lvi = _vlocals[pos];
lvi._end_op = UINT_MINUS_ONE; lvi._end_op = UINT_MINUS_ONE;
_outers++; _outers++;
} }
SQInteger SQFuncState::GetOuterVariable(const SQObject &name) int64_t SQFuncState::GetOuterVariable(const SQObject &name)
{ {
SQInteger outers = _outervalues.size(); int64_t outers = _outervalues.size();
for(SQInteger i = 0; i<outers; i++) { for(int64_t i = 0; i<outers; i++) {
if(_string(_outervalues[i]._name) == _string(name)) if(_string(_outervalues[i]._name) == _string(name))
return i; return i;
} }
SQInteger pos=-1; int64_t pos=-1;
if(_parent) { if(_parent) {
pos = _parent->GetLocalVariable(name); pos = _parent->GetLocalVariable(name);
if(pos == -1) { if(pos == -1) {
pos = _parent->GetOuterVariable(name); pos = _parent->GetOuterVariable(name);
if(pos != -1) { if(pos != -1) {
_outervalues.push_back(SQOuterVar(name,SQObjectPtr(SQInteger(pos)),otOUTER)); //local _outervalues.push_back(SQOuterVar(name,SQObjectPtr(int64_t(pos)),otOUTER)); //local
return _outervalues.size() - 1; return _outervalues.size() - 1;
} }
} }
else { else {
_parent->MarkLocalAsOuter(pos); _parent->MarkLocalAsOuter(pos);
_outervalues.push_back(SQOuterVar(name,SQObjectPtr(SQInteger(pos)),otLOCAL)); //local _outervalues.push_back(SQOuterVar(name,SQObjectPtr(int64_t(pos)),otLOCAL)); //local
return _outervalues.size() - 1; return _outervalues.size() - 1;
@ -423,7 +423,7 @@ void SQFuncState::AddParameter(const SQObject &name)
_parameters.push_back(name); _parameters.push_back(name);
} }
void SQFuncState::AddLineInfos(SQInteger line,bool lineop,bool force) void SQFuncState::AddLineInfos(int64_t line,bool lineop,bool force)
{ {
if(_lastline!=line || force){ if(_lastline!=line || force){
SQLineInfo li; SQLineInfo li;
@ -438,8 +438,8 @@ void SQFuncState::AddLineInfos(SQInteger line,bool lineop,bool force)
void SQFuncState::DiscardTarget() void SQFuncState::DiscardTarget()
{ {
SQInteger discardedtarget = PopTarget(); int64_t discardedtarget = PopTarget();
SQInteger size = _instructions.size(); int64_t size = _instructions.size();
if(size > 0 && _optimization){ if(size > 0 && _optimization){
SQInstruction &pi = _instructions[size-1];//previous instruction SQInstruction &pi = _instructions[size-1];//previous instruction
switch(pi.op) { switch(pi.op) {
@ -453,7 +453,7 @@ void SQFuncState::DiscardTarget()
void SQFuncState::AddInstruction(SQInstruction &i) void SQFuncState::AddInstruction(SQInstruction &i)
{ {
SQInteger size = _instructions.size(); int64_t size = _instructions.size();
if(size > 0 && _optimization){ //simple optimizer if(size > 0 && _optimization){ //simple optimizer
SQInstruction &pi = _instructions[size-1];//previous instruction SQInstruction &pi = _instructions[size-1];//previous instruction
switch(i.op) { switch(i.op) {
@ -505,7 +505,7 @@ void SQFuncState::AddInstruction(SQInstruction &i)
} }
break; break;
case _OP_APPENDARRAY: { case _OP_APPENDARRAY: {
SQInteger aat = -1; int64_t aat = -1;
switch(pi.op) { switch(pi.op) {
case _OP_LOAD: aat = AAT_LITERAL; break; case _OP_LOAD: aat = AAT_LITERAL; break;
case _OP_LOADINT: aat = AAT_INT; break; case _OP_LOADINT: aat = AAT_INT; break;
@ -584,17 +584,17 @@ void SQFuncState::AddInstruction(SQInstruction &i)
_instructions.push_back(i); _instructions.push_back(i);
} }
SQObject SQFuncState::CreateString(const SQChar *s,SQInteger len) SQObject SQFuncState::CreateString(const SQChar *s,int64_t len)
{ {
SQObjectPtr ns(SQString::Create(_sharedstate,s,len)); SQObjectPtr ns(SQString::Create(_sharedstate,s,len));
_table(_strings)->NewSlot(ns,(SQInteger)1); _table(_strings)->NewSlot(ns,(int64_t)1);
return ns; return ns;
} }
SQObject SQFuncState::CreateTable() SQObject SQFuncState::CreateTable()
{ {
SQObjectPtr nt(SQTable::Create(_sharedstate,0)); SQObjectPtr nt(SQTable::Create(_sharedstate,0));
_table(_strings)->NewSlot(nt,(SQInteger)1); _table(_strings)->NewSlot(nt,(int64_t)1);
return nt; return nt;
} }
@ -606,7 +606,7 @@ SQFunctionProto *SQFuncState::BuildProto()
_lineinfos.size(),_localvarinfos.size(),_defaultparams.size()); _lineinfos.size(),_localvarinfos.size(),_defaultparams.size());
SQObjectPtr refidx,key,val; SQObjectPtr refidx,key,val;
SQInteger idx; int64_t idx;
f->_stacksize = _stacksize; f->_stacksize = _stacksize;
f->_sourcename = _sourcename; f->_sourcename = _sourcename;
@ -618,12 +618,12 @@ SQFunctionProto *SQFuncState::BuildProto()
refidx=idx; refidx=idx;
} }
for(SQUnsignedInteger nf = 0; nf < _functions.size(); nf++) f->_functions[nf] = _functions[nf]; for(uint64_t nf = 0; nf < _functions.size(); nf++) f->_functions[nf] = _functions[nf];
for(SQUnsignedInteger np = 0; np < _parameters.size(); np++) f->_parameters[np] = _parameters[np]; for(uint64_t np = 0; np < _parameters.size(); np++) f->_parameters[np] = _parameters[np];
for(SQUnsignedInteger no = 0; no < _outervalues.size(); no++) f->_outervalues[no] = _outervalues[no]; for(uint64_t no = 0; no < _outervalues.size(); no++) f->_outervalues[no] = _outervalues[no];
for(SQUnsignedInteger nl = 0; nl < _localvarinfos.size(); nl++) f->_localvarinfos[nl] = _localvarinfos[nl]; for(uint64_t nl = 0; nl < _localvarinfos.size(); nl++) f->_localvarinfos[nl] = _localvarinfos[nl];
for(SQUnsignedInteger ni = 0; ni < _lineinfos.size(); ni++) f->_lineinfos[ni] = _lineinfos[ni]; for(uint64_t ni = 0; ni < _lineinfos.size(); ni++) f->_lineinfos[ni] = _lineinfos[ni];
for(SQUnsignedInteger nd = 0; nd < _defaultparams.size(); nd++) f->_defaultparams[nd] = _defaultparams[nd]; for(uint64_t nd = 0; nd < _defaultparams.size(); nd++) f->_defaultparams[nd] = _defaultparams[nd];
memcpy(f->_instructions,&_instructions[0],_instructions.size()*sizeof(SQInstruction)); memcpy(f->_instructions,&_instructions[0],_instructions.size()*sizeof(SQInstruction));

68
rabbit/sqfuncstate.hpp
View File

@ -19,45 +19,45 @@ struct SQFuncState
void Error(const SQChar *err); void Error(const SQChar *err);
SQFuncState *PushChildState(SQSharedState *ss); SQFuncState *PushChildState(SQSharedState *ss);
void PopChildState(); void PopChildState();
void AddInstruction(SQOpcode _op,SQInteger arg0=0,SQInteger arg1=0,SQInteger arg2=0,SQInteger arg3=0){SQInstruction i(_op,arg0,arg1,arg2,arg3);AddInstruction(i);} void AddInstruction(SQOpcode _op,int64_t arg0=0,int64_t arg1=0,int64_t arg2=0,int64_t arg3=0){SQInstruction i(_op,arg0,arg1,arg2,arg3);AddInstruction(i);}
void AddInstruction(SQInstruction &i); void AddInstruction(SQInstruction &i);
void SetIntructionParams(SQInteger pos,SQInteger arg0,SQInteger arg1,SQInteger arg2=0,SQInteger arg3=0); void SetIntructionParams(int64_t pos,int64_t arg0,int64_t arg1,int64_t arg2=0,int64_t arg3=0);
void SetIntructionParam(SQInteger pos,SQInteger arg,SQInteger val); void SetIntructionParam(int64_t pos,int64_t arg,int64_t val);
SQInstruction &GetInstruction(SQInteger pos){return _instructions[pos];} SQInstruction &GetInstruction(int64_t pos){return _instructions[pos];}
void PopInstructions(SQInteger size){for(SQInteger i=0;i<size;i++)_instructions.pop_back();} void PopInstructions(int64_t size){for(int64_t i=0;i<size;i++)_instructions.pop_back();}
void SetStackSize(SQInteger n); void SetStackSize(int64_t n);
SQInteger CountOuters(SQInteger stacksize); int64_t CountOuters(int64_t stacksize);
void SnoozeOpt(){_optimization=false;} void SnoozeOpt(){_optimization=false;}
void AddDefaultParam(SQInteger trg) { _defaultparams.push_back(trg); } void AddDefaultParam(int64_t trg) { _defaultparams.push_back(trg); }
SQInteger GetDefaultParamCount() { return _defaultparams.size(); } int64_t GetDefaultParamCount() { return _defaultparams.size(); }
SQInteger GetCurrentPos(){return _instructions.size()-1;} int64_t GetCurrentPos(){return _instructions.size()-1;}
SQInteger GetNumericConstant(const SQInteger cons); int64_t GetNumericConstant(const int64_t cons);
SQInteger GetNumericConstant(const SQFloat cons); int64_t GetNumericConstant(const float_t cons);
SQInteger PushLocalVariable(const SQObject &name); int64_t PushLocalVariable(const SQObject &name);
void AddParameter(const SQObject &name); void AddParameter(const SQObject &name);
//void AddOuterValue(const SQObject &name); //void AddOuterValue(const SQObject &name);
SQInteger GetLocalVariable(const SQObject &name); int64_t GetLocalVariable(const SQObject &name);
void MarkLocalAsOuter(SQInteger pos); void MarkLocalAsOuter(int64_t pos);
SQInteger GetOuterVariable(const SQObject &name); int64_t GetOuterVariable(const SQObject &name);
SQInteger GenerateCode(); int64_t GenerateCode();
SQInteger GetStackSize(); int64_t GetStackSize();
SQInteger CalcStackFrameSize(); int64_t CalcStackFrameSize();
void AddLineInfos(SQInteger line,bool lineop,bool force=false); void AddLineInfos(int64_t line,bool lineop,bool force=false);
SQFunctionProto *BuildProto(); SQFunctionProto *BuildProto();
SQInteger AllocStackPos(); int64_t AllocStackPos();
SQInteger PushTarget(SQInteger n=-1); int64_t PushTarget(int64_t n=-1);
SQInteger PopTarget(); int64_t PopTarget();
SQInteger TopTarget(); int64_t TopTarget();
SQInteger GetUpTarget(SQInteger n); int64_t GetUpTarget(int64_t n);
void DiscardTarget(); void DiscardTarget();
bool IsLocal(SQUnsignedInteger stkpos); bool IsLocal(uint64_t stkpos);
SQObject CreateString(const SQChar *s,SQInteger len = -1); SQObject CreateString(const SQChar *s,int64_t len = -1);
SQObject CreateTable(); SQObject CreateTable();
bool IsConstant(const SQObject &name,SQObject &e); bool IsConstant(const SQObject &name,SQObject &e);
SQInteger _returnexp; int64_t _returnexp;
SQLocalVarInfoVec _vlocals; SQLocalVarInfoVec _vlocals;
SQIntVec _targetstack; SQIntVec _targetstack;
SQInteger _stacksize; int64_t _stacksize;
bool _varparams; bool _varparams;
bool _bgenerator; bool _bgenerator;
SQIntVec _unresolvedbreaks; SQIntVec _unresolvedbreaks;
@ -71,20 +71,20 @@ struct SQFuncState
SQObjectPtr _strings; SQObjectPtr _strings;
SQObjectPtr _name; SQObjectPtr _name;
SQObjectPtr _sourcename; SQObjectPtr _sourcename;
SQInteger _nliterals; int64_t _nliterals;
SQLineInfoVec _lineinfos; SQLineInfoVec _lineinfos;
SQFuncState *_parent; SQFuncState *_parent;
SQIntVec _scope_blocks; SQIntVec _scope_blocks;
SQIntVec _breaktargets; SQIntVec _breaktargets;
SQIntVec _continuetargets; SQIntVec _continuetargets;
SQIntVec _defaultparams; SQIntVec _defaultparams;
SQInteger _lastline; int64_t _lastline;
SQInteger _traps; //contains number of nested exception traps int64_t _traps; //contains number of nested exception traps
SQInteger _outers; int64_t _outers;
bool _optimization; bool _optimization;
SQSharedState *_sharedstate; SQSharedState *_sharedstate;
sqvector<SQFuncState*> _childstates; sqvector<SQFuncState*> _childstates;
SQInteger GetConstant(const SQObject &cons); int64_t GetConstant(const SQObject &cons);
private: private:
CompilerErrorFunc _errfunc; CompilerErrorFunc _errfunc;
void *_errtarget; void *_errtarget;

78
rabbit/sqlexer.cpp
View File

@ -21,7 +21,7 @@
#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);}
#define TERMINATE_BUFFER() {_longstr.push_back(_SC('\0'));} #define TERMINATE_BUFFER() {_longstr.push_back(_SC('\0'));}
#define ADD_KEYWORD(key,id) _keywords->NewSlot( SQString::Create(ss, _SC(#key)) ,SQInteger(id)) #define ADD_KEYWORD(key,id) _keywords->NewSlot( SQString::Create(ss, _SC(#key)) ,int64_t(id))
SQLexer::SQLexer(){} SQLexer::SQLexer(){}
SQLexer::~SQLexer() SQLexer::~SQLexer()
@ -91,7 +91,7 @@ void SQLexer::Error(const SQChar *err)
void SQLexer::Next() void SQLexer::Next()
{ {
SQInteger t = _readf(_up); int64_t t = _readf(_up);
if(t > MAX_CHAR) Error(_SC("Invalid character")); if(t > MAX_CHAR) Error(_SC("Invalid character"));
if(t != 0) { if(t != 0) {
_currdata = (LexChar)t; _currdata = (LexChar)t;
@ -101,13 +101,13 @@ void SQLexer::Next()
_reached_eof = SQTrue; _reached_eof = SQTrue;
} }
const SQChar *SQLexer::Tok2Str(SQInteger tok) const SQChar *SQLexer::Tok2Str(int64_t tok)
{ {
SQObjectPtr itr, key, val; SQObjectPtr itr, key, val;
SQInteger nitr; int64_t nitr;
while((nitr = _keywords->Next(false,itr, key, val)) != -1) { while((nitr = _keywords->Next(false,itr, key, val)) != -1) {
itr = (SQInteger)nitr; itr = (int64_t)nitr;
if(((SQInteger)_integer(val)) == tok) if(((int64_t)_integer(val)) == tok)
return _stringval(key); return _stringval(key);
} }
return NULL; return NULL;
@ -130,7 +130,7 @@ void SQLexer::LexLineComment()
do { NEXT(); } while (CUR_CHAR != _SC('\n') && (!IS_EOB())); do { NEXT(); } while (CUR_CHAR != _SC('\n') && (!IS_EOB()));
} }
SQInteger SQLexer::Lex() int64_t SQLexer::Lex()
{ {
_lasttokenline = _currentline; _lasttokenline = _currentline;
while(CUR_CHAR != RABBIT_EOB) { while(CUR_CHAR != RABBIT_EOB) {
@ -202,7 +202,7 @@ SQInteger SQLexer::Lex()
if (CUR_CHAR != _SC('=')){ RETURN_TOKEN('!')} if (CUR_CHAR != _SC('=')){ RETURN_TOKEN('!')}
else { NEXT(); RETURN_TOKEN(TK_NE); } else { NEXT(); RETURN_TOKEN(TK_NE); }
case _SC('@'): { case _SC('@'): {
SQInteger stype; int64_t stype;
NEXT(); NEXT();
if(CUR_CHAR != _SC('"')) { if(CUR_CHAR != _SC('"')) {
RETURN_TOKEN('@'); RETURN_TOKEN('@');
@ -214,7 +214,7 @@ SQInteger SQLexer::Lex()
} }
case _SC('"'): case _SC('"'):
case _SC('\''): { case _SC('\''): {
SQInteger stype; int64_t stype;
if((stype=ReadString(CUR_CHAR,false))!=-1){ if((stype=ReadString(CUR_CHAR,false))!=-1){
RETURN_TOKEN(stype); RETURN_TOKEN(stype);
} }
@ -222,7 +222,7 @@ SQInteger SQLexer::Lex()
} }
case _SC('{'): case _SC('}'): case _SC('('): case _SC(')'): case _SC('['): case _SC(']'): case _SC('{'): case _SC('}'): case _SC('('): case _SC(')'): case _SC('['): case _SC(']'):
case _SC(';'): case _SC(','): case _SC('?'): case _SC('^'): case _SC('~'): case _SC(';'): case _SC(','): case _SC('?'): case _SC('^'): case _SC('~'):
{SQInteger ret = CUR_CHAR; {int64_t ret = CUR_CHAR;
NEXT(); RETURN_TOKEN(ret); } NEXT(); RETURN_TOKEN(ret); }
case _SC('.'): case _SC('.'):
NEXT(); NEXT();
@ -265,15 +265,15 @@ SQInteger SQLexer::Lex()
return 0; return 0;
default:{ default:{
if (scisdigit(CUR_CHAR)) { if (scisdigit(CUR_CHAR)) {
SQInteger ret = ReadNumber(); int64_t ret = ReadNumber();
RETURN_TOKEN(ret); RETURN_TOKEN(ret);
} }
else if (scisalpha(CUR_CHAR) || CUR_CHAR == _SC('_')) { else if (scisalpha(CUR_CHAR) || CUR_CHAR == _SC('_')) {
SQInteger t = ReadID(); int64_t t = ReadID();
RETURN_TOKEN(t); RETURN_TOKEN(t);
} }
else { else {
SQInteger c = CUR_CHAR; int64_t c = CUR_CHAR;
if (sciscntrl((int)c)) Error(_SC("unexpected character(control)")); if (sciscntrl((int)c)) Error(_SC("unexpected character(control)"));
NEXT(); NEXT();
RETURN_TOKEN(c); RETURN_TOKEN(c);
@ -285,22 +285,22 @@ SQInteger SQLexer::Lex()
return 0; return 0;
} }
SQInteger SQLexer::GetIDType(const SQChar *s,SQInteger len) int64_t SQLexer::GetIDType(const SQChar *s,int64_t len)
{ {
SQObjectPtr t; SQObjectPtr t;
if(_keywords->GetStr(s,len, t)) { if(_keywords->GetStr(s,len, t)) {
return SQInteger(_integer(t)); return int64_t(_integer(t));
} }
return TK_IDENTIFIER; return TK_IDENTIFIER;
} }
#ifdef SQUNICODE #ifdef SQUNICODE
#if WCHAR_SIZE == 2 #if WCHAR_SIZE == 2
SQInteger SQLexer::AddUTF16(SQUnsignedInteger ch) int64_t SQLexer::AddUTF16(uint64_t ch)
{ {
if (ch >= 0x10000) if (ch >= 0x10000)
{ {
SQUnsignedInteger code = (ch - 0x10000); uint64_t code = (ch - 0x10000);
APPEND_CHAR((SQChar)(0xD800 | (code >> 10))); APPEND_CHAR((SQChar)(0xD800 | (code >> 10)));
APPEND_CHAR((SQChar)(0xDC00 | (code & 0x3FF))); APPEND_CHAR((SQChar)(0xDC00 | (code & 0x3FF)));
return 2; return 2;
@ -312,7 +312,7 @@ SQInteger SQLexer::AddUTF16(SQUnsignedInteger ch)
} }
#endif #endif
#else #else
SQInteger SQLexer::AddUTF8(SQUnsignedInteger ch) int64_t SQLexer::AddUTF8(uint64_t ch)
{ {
if (ch < 0x80) { if (ch < 0x80) {
APPEND_CHAR((char)ch); APPEND_CHAR((char)ch);
@ -340,11 +340,11 @@ SQInteger SQLexer::AddUTF8(SQUnsignedInteger ch)
} }
#endif #endif
SQInteger SQLexer::ProcessStringHexEscape(SQChar *dest, SQInteger maxdigits) int64_t SQLexer::ProcessStringHexEscape(SQChar *dest, int64_t maxdigits)
{ {
NEXT(); NEXT();
if (!isxdigit(CUR_CHAR)) Error(_SC("hexadecimal number expected")); if (!isxdigit(CUR_CHAR)) Error(_SC("hexadecimal number expected"));
SQInteger n = 0; int64_t n = 0;
while (isxdigit(CUR_CHAR) && n < maxdigits) { while (isxdigit(CUR_CHAR) && n < maxdigits) {
dest[n] = CUR_CHAR; dest[n] = CUR_CHAR;
n++; n++;
@ -354,14 +354,14 @@ SQInteger SQLexer::ProcessStringHexEscape(SQChar *dest, SQInteger maxdigits)
return n; return n;
} }
SQInteger SQLexer::ReadString(SQInteger ndelim,bool verbatim) int64_t SQLexer::ReadString(int64_t ndelim,bool verbatim)
{ {
INIT_TEMP_STRING(); INIT_TEMP_STRING();
NEXT(); NEXT();
if(IS_EOB()) return -1; if(IS_EOB()) return -1;
for(;;) { for(;;) {
while(CUR_CHAR != ndelim) { while(CUR_CHAR != ndelim) {
SQInteger x = CUR_CHAR; int64_t x = CUR_CHAR;
switch (x) { switch (x) {
case RABBIT_EOB: case RABBIT_EOB:
Error(_SC("unfinished string")); Error(_SC("unfinished string"));
@ -379,7 +379,7 @@ SQInteger SQLexer::ReadString(SQInteger ndelim,bool verbatim)
NEXT(); NEXT();
switch(CUR_CHAR) { switch(CUR_CHAR) {
case _SC('x'): { case _SC('x'): {
const SQInteger maxdigits = sizeof(SQChar) * 2; const int64_t maxdigits = sizeof(SQChar) * 2;
SQChar temp[maxdigits + 1]; SQChar temp[maxdigits + 1];
ProcessStringHexEscape(temp, maxdigits); ProcessStringHexEscape(temp, maxdigits);
SQChar *stemp; SQChar *stemp;
@ -388,7 +388,7 @@ SQInteger SQLexer::ReadString(SQInteger ndelim,bool verbatim)
break; break;
case _SC('U'): case _SC('U'):
case _SC('u'): { case _SC('u'): {
const SQInteger maxdigits = CUR_CHAR == 'u' ? 4 : 8; const int64_t maxdigits = CUR_CHAR == 'u' ? 4 : 8;
SQChar temp[8 + 1]; SQChar temp[8 + 1];
ProcessStringHexEscape(temp, maxdigits); ProcessStringHexEscape(temp, maxdigits);
SQChar *stemp; SQChar *stemp;
@ -435,7 +435,7 @@ SQInteger SQLexer::ReadString(SQInteger ndelim,bool verbatim)
} }
} }
TERMINATE_BUFFER(); TERMINATE_BUFFER();
SQInteger len = _longstr.size()-1; int64_t len = _longstr.size()-1;
if(ndelim == _SC('\'')) { if(ndelim == _SC('\'')) {
if(len == 0) Error(_SC("empty constant")); if(len == 0) Error(_SC("empty constant"));
if(len > 1) Error(_SC("constant too long")); if(len > 1) Error(_SC("constant too long"));
@ -446,7 +446,7 @@ SQInteger SQLexer::ReadString(SQInteger ndelim,bool verbatim)
return TK_STRING_LITERAL; return TK_STRING_LITERAL;
} }
void LexHexadecimal(const SQChar *s,SQUnsignedInteger *res) void LexHexadecimal(const SQChar *s,uint64_t *res)
{ {
*res = 0; *res = 0;
while(*s != 0) while(*s != 0)
@ -457,7 +457,7 @@ void LexHexadecimal(const SQChar *s,SQUnsignedInteger *res)
} }
} }
void LexInteger(const SQChar *s,SQUnsignedInteger *res) void LexInteger(const SQChar *s,uint64_t *res)
{ {
*res = 0; *res = 0;
while(*s != 0) while(*s != 0)
@ -466,9 +466,9 @@ void LexInteger(const SQChar *s,SQUnsignedInteger *res)
} }
} }
SQInteger scisodigit(SQInteger c) { return c >= _SC('0') && c <= _SC('7'); } int64_t scisodigit(int64_t c) { return c >= _SC('0') && c <= _SC('7'); }
void LexOctal(const SQChar *s,SQUnsignedInteger *res) void LexOctal(const SQChar *s,uint64_t *res)
{ {
*res = 0; *res = 0;
while(*s != 0) while(*s != 0)
@ -478,18 +478,18 @@ void LexOctal(const SQChar *s,SQUnsignedInteger *res)
} }
} }
SQInteger isexponent(SQInteger c) { return c == 'e' || c=='E'; } int64_t isexponent(int64_t c) { return c == 'e' || c=='E'; }
#define MAX_HEX_DIGITS (sizeof(SQInteger)*2) #define MAX_HEX_DIGITS (sizeof(int64_t)*2)
SQInteger SQLexer::ReadNumber() int64_t SQLexer::ReadNumber()
{ {
#define TINT 1 #define TINT 1
#define TFLOAT 2 #define TFLOAT 2
#define THEX 3 #define THEX 3
#define TSCIENTIFIC 4 #define TSCIENTIFIC 4
#define TOCTAL 5 #define TOCTAL 5
SQInteger type = TINT, firstchar = CUR_CHAR; int64_t type = TINT, firstchar = CUR_CHAR;
SQChar *sTemp; SQChar *sTemp;
INIT_TEMP_STRING(); INIT_TEMP_STRING();
NEXT(); NEXT();
@ -536,24 +536,24 @@ SQInteger SQLexer::ReadNumber()
switch(type) { switch(type) {
case TSCIENTIFIC: case TSCIENTIFIC:
case TFLOAT: case TFLOAT:
_fvalue = (SQFloat)scstrtod(&_longstr[0],&sTemp); _fvalue = (float_t)scstrtod(&_longstr[0],&sTemp);
return TK_FLOAT; return TK_FLOAT;
case TINT: case TINT:
LexInteger(&_longstr[0],(SQUnsignedInteger *)&_nvalue); LexInteger(&_longstr[0],(uint64_t *)&_nvalue);
return TK_INTEGER; return TK_INTEGER;
case THEX: case THEX:
LexHexadecimal(&_longstr[0],(SQUnsignedInteger *)&_nvalue); LexHexadecimal(&_longstr[0],(uint64_t *)&_nvalue);
return TK_INTEGER; return TK_INTEGER;
case TOCTAL: case TOCTAL:
LexOctal(&_longstr[0],(SQUnsignedInteger *)&_nvalue); LexOctal(&_longstr[0],(uint64_t *)&_nvalue);
return TK_INTEGER; return TK_INTEGER;
} }
return 0; return 0;
} }
SQInteger SQLexer::ReadID() int64_t SQLexer::ReadID()
{ {
SQInteger res; int64_t res;
INIT_TEMP_STRING(); INIT_TEMP_STRING();
do { do {
APPEND_CHAR(CUR_CHAR); APPEND_CHAR(CUR_CHAR);

32
rabbit/sqlexer.hpp
View File

@ -19,35 +19,35 @@ struct SQLexer
~SQLexer(); ~SQLexer();
void Init(SQSharedState *ss,SQLEXREADFUNC rg,SQUserPointer up,CompilerErrorFunc efunc,void *ed); void Init(SQSharedState *ss,SQLEXREADFUNC rg,SQUserPointer up,CompilerErrorFunc efunc,void *ed);
void Error(const SQChar *err); void Error(const SQChar *err);
SQInteger Lex(); int64_t Lex();
const SQChar *Tok2Str(SQInteger tok); const SQChar *Tok2Str(int64_t tok);
private: private:
SQInteger GetIDType(const SQChar *s,SQInteger len); int64_t GetIDType(const SQChar *s,int64_t len);
SQInteger ReadString(SQInteger ndelim,bool verbatim); int64_t ReadString(int64_t ndelim,bool verbatim);
SQInteger ReadNumber(); int64_t ReadNumber();
void LexBlockComment(); void LexBlockComment();
void LexLineComment(); void LexLineComment();
SQInteger ReadID(); int64_t ReadID();
void Next(); void Next();
#ifdef SQUNICODE #ifdef SQUNICODE
#if WCHAR_SIZE == 2 #if WCHAR_SIZE == 2
SQInteger AddUTF16(SQUnsignedInteger ch); int64_t AddUTF16(uint64_t ch);
#endif #endif
#else #else
SQInteger AddUTF8(SQUnsignedInteger ch); int64_t AddUTF8(uint64_t ch);
#endif #endif
SQInteger ProcessStringHexEscape(SQChar *dest, SQInteger maxdigits); int64_t ProcessStringHexEscape(SQChar *dest, int64_t maxdigits);
SQInteger _curtoken; int64_t _curtoken;
SQTable *_keywords; SQTable *_keywords;
SQBool _reached_eof; SQBool _reached_eof;
public: public:
SQInteger _prevtoken; int64_t _prevtoken;
SQInteger _currentline; int64_t _currentline;
SQInteger _lasttokenline; int64_t _lasttokenline;
SQInteger _currentcolumn; int64_t _currentcolumn;
const SQChar *_svalue; const SQChar *_svalue;
SQInteger _nvalue; int64_t _nvalue;
SQFloat _fvalue; float_t _fvalue;
SQLEXREADFUNC _readf; SQLEXREADFUNC _readf;
SQUserPointer _up; SQUserPointer _up;
LexChar _currdata; LexChar _currdata;

6
rabbit/sqmem.cpp
View File

@ -9,9 +9,9 @@
#include <rabbit/sqpcheader.hpp> #include <rabbit/sqpcheader.hpp>
#ifndef SQ_EXCLUDE_DEFAULT_MEMFUNCTIONS #ifndef SQ_EXCLUDE_DEFAULT_MEMFUNCTIONS
void *sq_vm_malloc(SQUnsignedInteger size){ return malloc(size); } void *sq_vm_malloc(uint64_t size){ return malloc(size); }
void *sq_vm_realloc(void *p, SQUnsignedInteger SQ_UNUSED_ARG(oldsize), SQUnsignedInteger size){ return realloc(p, size); } void *sq_vm_realloc(void *p, uint64_t SQ_UNUSED_ARG(oldsize), uint64_t size){ return realloc(p, size); }
void sq_vm_free(void *p, SQUnsignedInteger SQ_UNUSED_ARG(size)){ free(p); } void sq_vm_free(void *p, uint64_t SQ_UNUSED_ARG(size)){ free(p); }
#endif #endif

140
rabbit/sqobject.cpp
View File

@ -50,7 +50,7 @@ const SQChar *GetTypeName(const SQObjectPtr &obj1)
return IdType2Name(sq_type(obj1)); return IdType2Name(sq_type(obj1));
} }
SQString *SQString::Create(SQSharedState *ss,const SQChar *s,SQInteger len) SQString *SQString::Create(SQSharedState *ss,const SQChar *s,int64_t len)
{ {
SQString *str=ADD_STRING(ss,s,len); SQString *str=ADD_STRING(ss,s,len);
return str; return str;
@ -61,12 +61,12 @@ void SQString::Release()
REMOVE_STRING(_sharedstate,this); REMOVE_STRING(_sharedstate,this);
} }
SQInteger SQString::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval) int64_t SQString::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval)
{ {
SQInteger idx = (SQInteger)TranslateIndex(refpos); int64_t idx = (int64_t)TranslateIndex(refpos);
while(idx < _len){ while(idx < _len){
outkey = (SQInteger)idx; outkey = (int64_t)idx;
outval = (SQInteger)((SQUnsignedInteger)_val[idx]); outval = (int64_t)((uint64_t)_val[idx]);
//return idx for the next iteration //return idx for the next iteration
return ++idx; return ++idx;
} }
@ -74,13 +74,13 @@ SQInteger SQString::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjec
return -1; return -1;
} }
SQUnsignedInteger TranslateIndex(const SQObjectPtr &idx) uint64_t TranslateIndex(const SQObjectPtr &idx)
{ {
switch(sq_type(idx)){ switch(sq_type(idx)){
case OT_NULL: case OT_NULL:
return 0; return 0;
case OT_INTEGER: case OT_INTEGER:
return (SQUnsignedInteger)_integer(idx); return (uint64_t)_integer(idx);
default: assert(0); break; default: assert(0); break;
} }
return 0; return 0;
@ -135,26 +135,26 @@ bool SQDelegable::SetDelegate(SQTable *mt)
return true; return true;
} }
bool SQGenerator::Yield(SQVM *v,SQInteger target) bool SQGenerator::Yield(SQVM *v,int64_t target)
{ {
if(_state==eSuspended) { v->Raise_Error(_SC("internal vm error, yielding dead generator")); return false;} if(_state==eSuspended) { v->Raise_Error(_SC("internal vm error, yielding dead generator")); return false;}
if(_state==eDead) { v->Raise_Error(_SC("internal vm error, yielding a dead generator")); return false; } if(_state==eDead) { v->Raise_Error(_SC("internal vm error, yielding a dead generator")); return false; }
SQInteger size = v->_top-v->_stackbase; int64_t size = v->_top-v->_stackbase;
_stack.resize(size); _stack.resize(size);
SQObject _this = v->_stack[v->_stackbase]; SQObject _this = v->_stack[v->_stackbase];
_stack._vals[0] = ISREFCOUNTED(sq_type(_this)) ? SQObjectPtr(_refcounted(_this)->GetWeakRef(sq_type(_this))) : _this; _stack._vals[0] = ISREFCOUNTED(sq_type(_this)) ? SQObjectPtr(_refcounted(_this)->GetWeakRef(sq_type(_this))) : _this;
for(SQInteger n =1; n<target; n++) { for(int64_t n =1; n<target; n++) {
_stack._vals[n] = v->_stack[v->_stackbase+n]; _stack._vals[n] = v->_stack[v->_stackbase+n];
} }
for(SQInteger j =0; j < size; j++) for(int64_t j =0; j < size; j++)
{ {
v->_stack[v->_stackbase+j].Null(); v->_stack[v->_stackbase+j].Null();
} }
_ci = *v->ci; _ci = *v->ci;
_ci._generator=NULL; _ci._generator=NULL;
for(SQInteger i=0;i<_ci._etraps;i++) { for(int64_t i=0;i<_ci._etraps;i++) {
_etraps.push_back(v->_etraps.top()); _etraps.push_back(v->_etraps.top());
v->_etraps.pop_back(); v->_etraps.pop_back();
// store relative stack base and size in case of resume to other _top // store relative stack base and size in case of resume to other _top
@ -170,14 +170,14 @@ bool SQGenerator::Resume(SQVM *v,SQObjectPtr &dest)
{ {
if(_state==eDead){ v->Raise_Error(_SC("resuming dead generator")); return false; } if(_state==eDead){ v->Raise_Error(_SC("resuming dead generator")); return false; }
if(_state==eRunning){ v->Raise_Error(_SC("resuming active generator")); return false; } if(_state==eRunning){ v->Raise_Error(_SC("resuming active generator")); return false; }
SQInteger size = _stack.size(); int64_t size = _stack.size();
SQInteger target = &dest - &(v->_stack._vals[v->_stackbase]); int64_t target = &dest - &(v->_stack._vals[v->_stackbase]);
assert(target>=0 && target<=255); assert(target>=0 && target<=255);
SQInteger newbase = v->_top; int64_t newbase = v->_top;
if(!v->EnterFrame(v->_top, v->_top + size, false)) if(!v->EnterFrame(v->_top, v->_top + size, false))
return false; return false;
v->ci->_generator = this; v->ci->_generator = this;
v->ci->_target = (SQInt32)target; v->ci->_target = (int32_t)target;
v->ci->_closure = _ci._closure; v->ci->_closure = _ci._closure;
v->ci->_ip = _ci._ip; v->ci->_ip = _ci._ip;
v->ci->_literals = _ci._literals; v->ci->_literals = _ci._literals;
@ -186,7 +186,7 @@ bool SQGenerator::Resume(SQVM *v,SQObjectPtr &dest)
v->ci->_root = _ci._root; v->ci->_root = _ci._root;
for(SQInteger i=0;i<_ci._etraps;i++) { for(int64_t i=0;i<_ci._etraps;i++) {
v->_etraps.push_back(_etraps.top()); v->_etraps.push_back(_etraps.top());
_etraps.pop_back(); _etraps.pop_back();
SQExceptionTrap &et = v->_etraps.back(); SQExceptionTrap &et = v->_etraps.back();
@ -197,7 +197,7 @@ bool SQGenerator::Resume(SQVM *v,SQObjectPtr &dest)
SQObject _this = _stack._vals[0]; SQObject _this = _stack._vals[0];
v->_stack[v->_stackbase] = sq_type(_this) == OT_WEAKREF ? _weakref(_this)->_obj : _this; v->_stack[v->_stackbase] = sq_type(_this) == OT_WEAKREF ? _weakref(_this)->_obj : _this;
for(SQInteger n = 1; n<size; n++) { for(int64_t n = 1; n<size; n++) {
v->_stack[v->_stackbase+n] = _stack._vals[n]; v->_stack[v->_stackbase+n] = _stack._vals[n];
_stack._vals[n].Null(); _stack._vals[n].Null();
} }
@ -210,18 +210,18 @@ bool SQGenerator::Resume(SQVM *v,SQObjectPtr &dest)
} }
void SQArray::Extend(const SQArray *a){ void SQArray::Extend(const SQArray *a){
SQInteger xlen; int64_t xlen;
if((xlen=a->Size())) if((xlen=a->Size()))
for(SQInteger i=0;i<xlen;i++) for(int64_t i=0;i<xlen;i++)
Append(a->_values[i]); Append(a->_values[i]);
} }
const SQChar* SQFunctionProto::GetLocal(SQVM *vm,SQUnsignedInteger stackbase,SQUnsignedInteger nseq,SQUnsignedInteger nop) const SQChar* SQFunctionProto::GetLocal(SQVM *vm,uint64_t stackbase,uint64_t nseq,uint64_t nop)
{ {
SQUnsignedInteger nvars=_nlocalvarinfos; uint64_t nvars=_nlocalvarinfos;
const SQChar *res=NULL; const SQChar *res=NULL;
if(nvars>=nseq){ if(nvars>=nseq){
for(SQUnsignedInteger i=0;i<nvars;i++){ for(uint64_t i=0;i<nvars;i++){
if(_localvarinfos[i]._start_op<=nop && _localvarinfos[i]._end_op>=nop) if(_localvarinfos[i]._start_op<=nop && _localvarinfos[i]._end_op>=nop)
{ {
if(nseq==0){ if(nseq==0){
@ -237,17 +237,17 @@ const SQChar* SQFunctionProto::GetLocal(SQVM *vm,SQUnsignedInteger stackbase,SQU
} }
SQInteger SQFunctionProto::GetLine(SQInstruction *curr) int64_t SQFunctionProto::GetLine(SQInstruction *curr)
{ {
SQInteger op = (SQInteger)(curr-_instructions); int64_t op = (int64_t)(curr-_instructions);
SQInteger line=_lineinfos[0]._line; int64_t line=_lineinfos[0]._line;
SQInteger low = 0; int64_t low = 0;
SQInteger high = _nlineinfos - 1; int64_t high = _nlineinfos - 1;
SQInteger mid = 0; int64_t mid = 0;
while(low <= high) while(low <= high)
{ {
mid = low + ((high - low) >> 1); mid = low + ((high - low) >> 1);
SQInteger curop = _lineinfos[mid]._op; int64_t curop = _lineinfos[mid]._op;
if(curop > op) if(curop > op)
{ {
high = mid - 1; high = mid - 1;
@ -279,7 +279,7 @@ SQClosure::~SQClosure()
} }
#define _CHECK_IO(exp) { if(!exp)return false; } #define _CHECK_IO(exp) { if(!exp)return false; }
bool SafeWrite(HRABBITVM v,SQWRITEFUNC write,SQUserPointer up,SQUserPointer dest,SQInteger size) bool SafeWrite(HRABBITVM v,SQWRITEFUNC write,SQUserPointer up,SQUserPointer dest,int64_t size)
{ {
if(write(up,dest,size) != size) { if(write(up,dest,size) != size) {
v->Raise_Error(_SC("io error (write function failure)")); v->Raise_Error(_SC("io error (write function failure)"));
@ -288,7 +288,7 @@ bool SafeWrite(HRABBITVM v,SQWRITEFUNC write,SQUserPointer up,SQUserPointer dest
return true; return true;
} }
bool SafeRead(HRABBITVM v,SQWRITEFUNC read,SQUserPointer up,SQUserPointer dest,SQInteger size) bool SafeRead(HRABBITVM v,SQWRITEFUNC read,SQUserPointer up,SQUserPointer dest,int64_t size)
{ {
if(size && read(up,dest,size) != size) { if(size && read(up,dest,size) != size) {
v->Raise_Error(_SC("io error, read function failure, the origin stream could be corrupted/trucated")); v->Raise_Error(_SC("io error, read function failure, the origin stream could be corrupted/trucated"));
@ -297,14 +297,14 @@ bool SafeRead(HRABBITVM v,SQWRITEFUNC read,SQUserPointer up,SQUserPointer dest,S
return true; return true;
} }
bool WriteTag(HRABBITVM v,SQWRITEFUNC write,SQUserPointer up,SQUnsignedInteger32 tag) bool WriteTag(HRABBITVM v,SQWRITEFUNC write,SQUserPointer up,uint32_t tag)
{ {
return SafeWrite(v,write,up,&tag,sizeof(tag)); return SafeWrite(v,write,up,&tag,sizeof(tag));
} }
bool CheckTag(HRABBITVM v,SQWRITEFUNC read,SQUserPointer up,SQUnsignedInteger32 tag) bool CheckTag(HRABBITVM v,SQWRITEFUNC read,SQUserPointer up,uint32_t tag)
{ {
SQUnsignedInteger32 t; uint32_t t;
_CHECK_IO(SafeRead(v,read,up,&t,sizeof(t))); _CHECK_IO(SafeRead(v,read,up,&t,sizeof(t)));
if(t != tag){ if(t != tag){
v->Raise_Error(_SC("invalid or corrupted closure stream")); v->Raise_Error(_SC("invalid or corrupted closure stream"));
@ -315,18 +315,18 @@ bool CheckTag(HRABBITVM v,SQWRITEFUNC read,SQUserPointer up,SQUnsignedInteger32
bool WriteObject(HRABBITVM v,SQUserPointer up,SQWRITEFUNC write,SQObjectPtr &o) bool WriteObject(HRABBITVM v,SQUserPointer up,SQWRITEFUNC write,SQObjectPtr &o)
{ {
SQUnsignedInteger32 _type = (SQUnsignedInteger32)sq_type(o); uint32_t _type = (uint32_t)sq_type(o);
_CHECK_IO(SafeWrite(v,write,up,&_type,sizeof(_type))); _CHECK_IO(SafeWrite(v,write,up,&_type,sizeof(_type)));
switch(sq_type(o)){ switch(sq_type(o)){
case OT_STRING: case OT_STRING:
_CHECK_IO(SafeWrite(v,write,up,&_string(o)->_len,sizeof(SQInteger))); _CHECK_IO(SafeWrite(v,write,up,&_string(o)->_len,sizeof(int64_t)));
_CHECK_IO(SafeWrite(v,write,up,_stringval(o),sq_rsl(_string(o)->_len))); _CHECK_IO(SafeWrite(v,write,up,_stringval(o),sq_rsl(_string(o)->_len)));
break; break;
case OT_BOOL: case OT_BOOL:
case OT_INTEGER: case OT_INTEGER:
_CHECK_IO(SafeWrite(v,write,up,&_integer(o),sizeof(SQInteger)));break; _CHECK_IO(SafeWrite(v,write,up,&_integer(o),sizeof(int64_t)));break;
case OT_FLOAT: case OT_FLOAT:
_CHECK_IO(SafeWrite(v,write,up,&_float(o),sizeof(SQFloat)));break; _CHECK_IO(SafeWrite(v,write,up,&_float(o),sizeof(float_t)));break;
case OT_NULL: case OT_NULL:
break; break;
default: default:
@ -338,28 +338,28 @@ bool WriteObject(HRABBITVM v,SQUserPointer up,SQWRITEFUNC write,SQObjectPtr &o)
bool ReadObject(HRABBITVM v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &o) bool ReadObject(HRABBITVM v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &o)
{ {
SQUnsignedInteger32 _type; uint32_t _type;
_CHECK_IO(SafeRead(v,read,up,&_type,sizeof(_type))); _CHECK_IO(SafeRead(v,read,up,&_type,sizeof(_type)));
SQObjectType t = (SQObjectType)_type; SQObjectType t = (SQObjectType)_type;
switch(t){ switch(t){
case OT_STRING:{ case OT_STRING:{
SQInteger len; int64_t len;
_CHECK_IO(SafeRead(v,read,up,&len,sizeof(SQInteger))); _CHECK_IO(SafeRead(v,read,up,&len,sizeof(int64_t)));
_CHECK_IO(SafeRead(v,read,up,_ss(v)->GetScratchPad(sq_rsl(len)),sq_rsl(len))); _CHECK_IO(SafeRead(v,read,up,_ss(v)->GetScratchPad(sq_rsl(len)),sq_rsl(len)));
o=SQString::Create(_ss(v),_ss(v)->GetScratchPad(-1),len); o=SQString::Create(_ss(v),_ss(v)->GetScratchPad(-1),len);
} }
break; break;
case OT_INTEGER:{ case OT_INTEGER:{
SQInteger i; int64_t i;
_CHECK_IO(SafeRead(v,read,up,&i,sizeof(SQInteger))); o = i; break; _CHECK_IO(SafeRead(v,read,up,&i,sizeof(int64_t))); o = i; break;
} }
case OT_BOOL:{ case OT_BOOL:{
SQInteger i; int64_t i;
_CHECK_IO(SafeRead(v,read,up,&i,sizeof(SQInteger))); o._type = OT_BOOL; o._unVal.nInteger = i; break; _CHECK_IO(SafeRead(v,read,up,&i,sizeof(int64_t))); o._type = OT_BOOL; o._unVal.nInteger = i; break;
} }
case OT_FLOAT:{ case OT_FLOAT:{
SQFloat f; float_t f;
_CHECK_IO(SafeRead(v,read,up,&f,sizeof(SQFloat))); o = f; break; _CHECK_IO(SafeRead(v,read,up,&f,sizeof(float_t))); o = f; break;
} }
case OT_NULL: case OT_NULL:
o.Null(); o.Null();
@ -375,8 +375,8 @@ bool SQClosure::Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write)
{ {
_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_HEAD)); _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_HEAD));
_CHECK_IO(WriteTag(v,write,up,sizeof(SQChar))); _CHECK_IO(WriteTag(v,write,up,sizeof(SQChar)));
_CHECK_IO(WriteTag(v,write,up,sizeof(SQInteger))); _CHECK_IO(WriteTag(v,write,up,sizeof(int64_t)));
_CHECK_IO(WriteTag(v,write,up,sizeof(SQFloat))); _CHECK_IO(WriteTag(v,write,up,sizeof(float_t)));
_CHECK_IO(_function->Save(v,up,write)); _CHECK_IO(_function->Save(v,up,write));
_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_TAIL)); _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_TAIL));
return true; return true;
@ -386,8 +386,8 @@ bool SQClosure::Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret)
{ {
_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_HEAD)); _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_HEAD));
_CHECK_IO(CheckTag(v,read,up,sizeof(SQChar))); _CHECK_IO(CheckTag(v,read,up,sizeof(SQChar)));
_CHECK_IO(CheckTag(v,read,up,sizeof(SQInteger))); _CHECK_IO(CheckTag(v,read,up,sizeof(int64_t)));
_CHECK_IO(CheckTag(v,read,up,sizeof(SQFloat))); _CHECK_IO(CheckTag(v,read,up,sizeof(float_t)));
SQObjectPtr func; SQObjectPtr func;
_CHECK_IO(SQFunctionProto::Load(v,up,read,func)); _CHECK_IO(SQFunctionProto::Load(v,up,read,func));
_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_TAIL)); _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_TAIL));
@ -408,10 +408,10 @@ SQFunctionProto::~SQFunctionProto()
bool SQFunctionProto::Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write) bool SQFunctionProto::Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write)
{ {
SQInteger i,nliterals = _nliterals,nparameters = _nparameters; int64_t i,nliterals = _nliterals,nparameters = _nparameters;
SQInteger noutervalues = _noutervalues,nlocalvarinfos = _nlocalvarinfos; int64_t noutervalues = _noutervalues,nlocalvarinfos = _nlocalvarinfos;
SQInteger nlineinfos=_nlineinfos,ninstructions = _ninstructions,nfunctions=_nfunctions; int64_t nlineinfos=_nlineinfos,ninstructions = _ninstructions,nfunctions=_nfunctions;
SQInteger ndefaultparams = _ndefaultparams; int64_t ndefaultparams = _ndefaultparams;
_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART)); _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
_CHECK_IO(WriteObject(v,up,write,_sourcename)); _CHECK_IO(WriteObject(v,up,write,_sourcename));
_CHECK_IO(WriteObject(v,up,write,_name)); _CHECK_IO(WriteObject(v,up,write,_name));
@ -436,7 +436,7 @@ bool SQFunctionProto::Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write)
_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART)); _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
for(i=0;i<noutervalues;i++){ for(i=0;i<noutervalues;i++){
_CHECK_IO(SafeWrite(v,write,up,&_outervalues[i]._type,sizeof(SQUnsignedInteger))); _CHECK_IO(SafeWrite(v,write,up,&_outervalues[i]._type,sizeof(uint64_t)));
_CHECK_IO(WriteObject(v,up,write,_outervalues[i]._src)); _CHECK_IO(WriteObject(v,up,write,_outervalues[i]._src));
_CHECK_IO(WriteObject(v,up,write,_outervalues[i]._name)); _CHECK_IO(WriteObject(v,up,write,_outervalues[i]._name));
} }
@ -445,16 +445,16 @@ bool SQFunctionProto::Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write)
for(i=0;i<nlocalvarinfos;i++){ for(i=0;i<nlocalvarinfos;i++){
SQLocalVarInfo &lvi=_localvarinfos[i]; SQLocalVarInfo &lvi=_localvarinfos[i];
_CHECK_IO(WriteObject(v,up,write,lvi._name)); _CHECK_IO(WriteObject(v,up,write,lvi._name));
_CHECK_IO(SafeWrite(v,write,up,&lvi._pos,sizeof(SQUnsignedInteger))); _CHECK_IO(SafeWrite(v,write,up,&lvi._pos,sizeof(uint64_t)));
_CHECK_IO(SafeWrite(v,write,up,&lvi._start_op,sizeof(SQUnsignedInteger))); _CHECK_IO(SafeWrite(v,write,up,&lvi._start_op,sizeof(uint64_t)));
_CHECK_IO(SafeWrite(v,write,up,&lvi._end_op,sizeof(SQUnsignedInteger))); _CHECK_IO(SafeWrite(v,write,up,&lvi._end_op,sizeof(uint64_t)));
} }
_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART)); _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
_CHECK_IO(SafeWrite(v,write,up,_lineinfos,sizeof(SQLineInfo)*nlineinfos)); _CHECK_IO(SafeWrite(v,write,up,_lineinfos,sizeof(SQLineInfo)*nlineinfos));
_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART)); _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
_CHECK_IO(SafeWrite(v,write,up,_defaultparams,sizeof(SQInteger)*ndefaultparams)); _CHECK_IO(SafeWrite(v,write,up,_defaultparams,sizeof(int64_t)*ndefaultparams));
_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART)); _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
_CHECK_IO(SafeWrite(v,write,up,_instructions,sizeof(SQInstruction)*ninstructions)); _CHECK_IO(SafeWrite(v,write,up,_instructions,sizeof(SQInstruction)*ninstructions));
@ -471,9 +471,9 @@ bool SQFunctionProto::Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write)
bool SQFunctionProto::Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret) bool SQFunctionProto::Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret)
{ {
SQInteger i, nliterals,nparameters; int64_t i, nliterals,nparameters;
SQInteger noutervalues ,nlocalvarinfos ; int64_t noutervalues ,nlocalvarinfos ;
SQInteger nlineinfos,ninstructions ,nfunctions,ndefaultparams ; int64_t nlineinfos,ninstructions ,nfunctions,ndefaultparams ;
SQObjectPtr sourcename, name; SQObjectPtr sourcename, name;
SQObjectPtr o; SQObjectPtr o;
_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART)); _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
@ -512,9 +512,9 @@ bool SQFunctionProto::Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr
_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART)); _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
for(i = 0; i < noutervalues; i++){ for(i = 0; i < noutervalues; i++){
SQUnsignedInteger type; uint64_t type;
SQObjectPtr name; SQObjectPtr name;
_CHECK_IO(SafeRead(v,read,up, &type, sizeof(SQUnsignedInteger))); _CHECK_IO(SafeRead(v,read,up, &type, sizeof(uint64_t)));
_CHECK_IO(ReadObject(v, up, read, o)); _CHECK_IO(ReadObject(v, up, read, o));
_CHECK_IO(ReadObject(v, up, read, name)); _CHECK_IO(ReadObject(v, up, read, name));
f->_outervalues[i] = SQOuterVar(name,o, (SQOuterType)type); f->_outervalues[i] = SQOuterVar(name,o, (SQOuterType)type);
@ -524,16 +524,16 @@ bool SQFunctionProto::Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr
for(i = 0; i < nlocalvarinfos; i++){ for(i = 0; i < nlocalvarinfos; i++){
SQLocalVarInfo lvi; SQLocalVarInfo lvi;
_CHECK_IO(ReadObject(v, up, read, lvi._name)); _CHECK_IO(ReadObject(v, up, read, lvi._name));
_CHECK_IO(SafeRead(v,read,up, &lvi._pos, sizeof(SQUnsignedInteger))); _CHECK_IO(SafeRead(v,read,up, &lvi._pos, sizeof(uint64_t)));
_CHECK_IO(SafeRead(v,read,up, &lvi._start_op, sizeof(SQUnsignedInteger))); _CHECK_IO(SafeRead(v,read,up, &lvi._start_op, sizeof(uint64_t)));
_CHECK_IO(SafeRead(v,read,up, &lvi._end_op, sizeof(SQUnsignedInteger))); _CHECK_IO(SafeRead(v,read,up, &lvi._end_op, sizeof(uint64_t)));
f->_localvarinfos[i] = lvi; f->_localvarinfos[i] = lvi;
} }
_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART)); _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
_CHECK_IO(SafeRead(v,read,up, f->_lineinfos, sizeof(SQLineInfo)*nlineinfos)); _CHECK_IO(SafeRead(v,read,up, f->_lineinfos, sizeof(SQLineInfo)*nlineinfos));
_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART)); _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
_CHECK_IO(SafeRead(v,read,up, f->_defaultparams, sizeof(SQInteger)*ndefaultparams)); _CHECK_IO(SafeRead(v,read,up, f->_defaultparams, sizeof(int64_t)*ndefaultparams));
_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART)); _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
_CHECK_IO(SafeRead(v,read,up, f->_instructions, sizeof(SQInstruction)*ninstructions)); _CHECK_IO(SafeRead(v,read,up, f->_instructions, sizeof(SQInstruction)*ninstructions));

22
rabbit/sqobject.hpp
View File

@ -64,25 +64,25 @@ enum SQMetaMethod{
#define _CONSTRUCT_VECTOR(type,size,ptr) { \ #define _CONSTRUCT_VECTOR(type,size,ptr) { \
for(SQInteger n = 0; n < ((SQInteger)size); n++) { \ for(int64_t n = 0; n < ((int64_t)size); n++) { \
new (&ptr[n]) type(); \ new (&ptr[n]) type(); \
} \ } \
} }
#define _DESTRUCT_VECTOR(type,size,ptr) { \ #define _DESTRUCT_VECTOR(type,size,ptr) { \
for(SQInteger nl = 0; nl < ((SQInteger)size); nl++) { \ for(int64_t nl = 0; nl < ((int64_t)size); nl++) { \
ptr[nl].~type(); \ ptr[nl].~type(); \
} \ } \
} }
#define _COPY_VECTOR(dest,src,size) { \ #define _COPY_VECTOR(dest,src,size) { \
for(SQInteger _n_ = 0; _n_ < ((SQInteger)size); _n_++) { \ for(int64_t _n_ = 0; _n_ < ((int64_t)size); _n_++) { \
dest[_n_] = src[_n_]; \ dest[_n_] = src[_n_]; \
} \ } \
} }
#define _NULL_SQOBJECT_VECTOR(vec,size) { \ #define _NULL_SQOBJECT_VECTOR(vec,size) { \
for(SQInteger _n_ = 0; _n_ < ((SQInteger)size); _n_++) { \ for(int64_t _n_ = 0; _n_ < ((int64_t)size); _n_++) { \
vec[_n_].Null(); \ vec[_n_].Null(); \
} \ } \
} }
@ -91,7 +91,7 @@ enum SQMetaMethod{
struct SQRefCounted struct SQRefCounted
{ {
SQUnsignedInteger _uiRef; uint64_t _uiRef;
struct SQWeakRef *_weakref; struct SQWeakRef *_weakref;
SQRefCounted() { _uiRef = 0; _weakref = NULL; } SQRefCounted() { _uiRef = 0; _weakref = NULL; }
virtual ~SQRefCounted(); virtual ~SQRefCounted();
@ -159,8 +159,8 @@ struct SQObjectPtr;
#define _stringval(obj) (obj)._unVal.pString->_val #define _stringval(obj) (obj)._unVal.pString->_val
#define _userdataval(obj) ((SQUserPointer)sq_aligning((obj)._unVal.pUserData + 1)) #define _userdataval(obj) ((SQUserPointer)sq_aligning((obj)._unVal.pUserData + 1))
#define tofloat(num) ((sq_type(num)==OT_INTEGER)?(SQFloat)_integer(num):_float(num)) #define tofloat(num) ((sq_type(num)==OT_INTEGER)?(float_t)_integer(num):_float(num))
#define tointeger(num) ((sq_type(num)==OT_FLOAT)?(SQInteger)_float(num):_integer(num)) #define tointeger(num) ((sq_type(num)==OT_FLOAT)?(int64_t)_float(num):_integer(num))
///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////
#if defined(SQUSEDOUBLE) && !defined(_SQ64) || !defined(SQUSEDOUBLE) && defined(_SQ64) #if defined(SQUSEDOUBLE) && !defined(_SQ64) || !defined(SQUSEDOUBLE) && defined(_SQ64)
@ -241,8 +241,8 @@ struct SQObjectPtr : public SQObject
_REF_TYPE_DECL(OT_THREAD,SQVM,pThread) _REF_TYPE_DECL(OT_THREAD,SQVM,pThread)
_REF_TYPE_DECL(OT_FUNCPROTO,SQFunctionProto,pFunctionProto) _REF_TYPE_DECL(OT_FUNCPROTO,SQFunctionProto,pFunctionProto)
_SCALAR_TYPE_DECL(OT_INTEGER,SQInteger,nInteger) _SCALAR_TYPE_DECL(OT_INTEGER,int64_t,nInteger)
_SCALAR_TYPE_DECL(OT_FLOAT,SQFloat,fFloat) _SCALAR_TYPE_DECL(OT_FLOAT,float_t,fFloat)
_SCALAR_TYPE_DECL(OT_USERPOINTER,SQUserPointer,pUserPointer) _SCALAR_TYPE_DECL(OT_USERPOINTER,SQUserPointer,pUserPointer)
SQObjectPtr(bool bBool) SQObjectPtr(bool bBool)
@ -319,9 +319,9 @@ struct SQDelegable : public SQRefCounted {
SQTable *_delegate; SQTable *_delegate;
}; };
SQUnsignedInteger TranslateIndex(const SQObjectPtr &idx); uint64_t TranslateIndex(const SQObjectPtr &idx);
typedef sqvector<SQObjectPtr> SQObjectPtrVec; typedef sqvector<SQObjectPtr> SQObjectPtrVec;
typedef sqvector<SQInteger> SQIntVec; typedef sqvector<int64_t> SQIntVec;
const SQChar *GetTypeName(const SQObjectPtr &obj1); const SQChar *GetTypeName(const SQObjectPtr &obj1);
const SQChar *IdType2Name(SQObjectType type); const SQChar *IdType2Name(SQObjectType type);

8
rabbit/sqopcodes.hpp
View File

@ -8,7 +8,7 @@
#pragma once #pragma once
#define MAX_FUNC_STACKSIZE 0xFF #define MAX_FUNC_STACKSIZE 0xFF
#define MAX_LITERALS ((SQInteger)0x7FFFFFFF) #define MAX_LITERALS ((int64_t)0x7FFFFFFF)
enum BitWiseOP { enum BitWiseOP {
BW_AND = 0, BW_AND = 0,
@ -114,14 +114,14 @@ struct SQInstructionDesc {
struct SQInstruction struct SQInstruction
{ {
SQInstruction(){}; SQInstruction(){};
SQInstruction(SQOpcode _op,SQInteger a0=0,SQInteger a1=0,SQInteger a2=0,SQInteger a3=0) SQInstruction(SQOpcode _op,int64_t a0=0,int64_t a1=0,int64_t a2=0,int64_t a3=0)
{ op = (unsigned char)_op; { op = (unsigned char)_op;
_arg0 = (unsigned char)a0;_arg1 = (SQInt32)a1; _arg0 = (unsigned char)a0;_arg1 = (int32_t)a1;
_arg2 = (unsigned char)a2;_arg3 = (unsigned char)a3; _arg2 = (unsigned char)a2;_arg3 = (unsigned char)a3;
} }
SQInt32 _arg1; int32_t _arg1;
unsigned char op; unsigned char op;
unsigned char _arg0; unsigned char _arg0;
unsigned char _arg2; unsigned char _arg2;

44
rabbit/sqstate.cpp
View File

@ -33,13 +33,13 @@ SQSharedState::SQSharedState()
#define newmetamethod(s) { \ #define newmetamethod(s) { \
_metamethods->push_back(SQString::Create(this,s)); \ _metamethods->push_back(SQString::Create(this,s)); \
_table(_metamethodsmap)->NewSlot(_metamethods->back(),(SQInteger)(_metamethods->size()-1)); \ _table(_metamethodsmap)->NewSlot(_metamethods->back(),(int64_t)(_metamethods->size()-1)); \
} }
bool CompileTypemask(SQIntVec &res,const SQChar *typemask) bool CompileTypemask(SQIntVec &res,const SQChar *typemask)
{ {
SQInteger i = 0; int64_t i = 0;
SQInteger mask = 0; int64_t mask = 0;
while(typemask[i] != 0) { while(typemask[i] != 0) {
switch(typemask[i]) { switch(typemask[i]) {
case 'o': mask |= _RT_NULL; break; case 'o': mask |= _RT_NULL; break;
@ -79,7 +79,7 @@ bool CompileTypemask(SQIntVec &res,const SQChar *typemask)
SQTable *CreateDefaultDelegate(SQSharedState *ss,const SQRegFunction *funcz) SQTable *CreateDefaultDelegate(SQSharedState *ss,const SQRegFunction *funcz)
{ {
SQInteger i=0; int64_t i=0;
SQTable *t=SQTable::Create(ss,0); SQTable *t=SQTable::Create(ss,0);
while(funcz[i].name!=0){ while(funcz[i].name!=0){
SQNativeClosure *nc = SQNativeClosure::Create(ss,funcz[i].f,0); SQNativeClosure *nc = SQNativeClosure::Create(ss,funcz[i].f,0);
@ -191,7 +191,7 @@ SQSharedState::~SQSharedState()
} }
SQInteger SQSharedState::GetMetaMethodIdxByName(const SQObjectPtr &name) int64_t SQSharedState::GetMetaMethodIdxByName(const SQObjectPtr &name)
{ {
if(sq_type(name) != OT_STRING) if(sq_type(name) != OT_STRING)
return -1; return -1;
@ -203,9 +203,9 @@ SQInteger SQSharedState::GetMetaMethodIdxByName(const SQObjectPtr &name)
} }
SQChar* SQSharedState::GetScratchPad(SQInteger size) SQChar* SQSharedState::GetScratchPad(int64_t size)
{ {
SQInteger newsize; int64_t newsize;
if(size>0) { if(size>0) {
if(_scratchpadsize < size) { if(_scratchpadsize < size) {
newsize = size + (size>>1); newsize = size + (size>>1);
@ -229,7 +229,7 @@ RefTable::RefTable()
void RefTable::Finalize() void RefTable::Finalize()
{ {
RefNode *nodes = _nodes; RefNode *nodes = _nodes;
for(SQUnsignedInteger n = 0; n < _numofslots; n++) { for(uint64_t n = 0; n < _numofslots; n++) {
nodes->obj.Null(); nodes->obj.Null();
nodes++; nodes++;
} }
@ -249,7 +249,7 @@ void RefTable::AddRef(SQObject &obj)
ref->refs++; ref->refs++;
} }
SQUnsignedInteger RefTable::GetRefCount(SQObject &obj) uint64_t RefTable::GetRefCount(SQObject &obj)
{ {
SQHash mainpos; SQHash mainpos;
RefNode *prev; RefNode *prev;
@ -286,15 +286,15 @@ SQBool RefTable::Release(SQObject &obj)
return SQFalse; return SQFalse;
} }
void RefTable::Resize(SQUnsignedInteger size) void RefTable::Resize(uint64_t size)
{ {
RefNode **oldbucks = _buckets; RefNode **oldbucks = _buckets;
RefNode *t = _nodes; RefNode *t = _nodes;
SQUnsignedInteger oldnumofslots = _numofslots; uint64_t oldnumofslots = _numofslots;
AllocNodes(size); AllocNodes(size);
//rehash //rehash
SQUnsignedInteger nfound = 0; uint64_t nfound = 0;
for(SQUnsignedInteger n = 0; n < oldnumofslots; n++) { for(uint64_t n = 0; n < oldnumofslots; n++) {
if(sq_type(t->obj) != OT_NULL) { if(sq_type(t->obj) != OT_NULL) {
//add back; //add back;
assert(t->refs != 0); assert(t->refs != 0);
@ -344,14 +344,14 @@ RefTable::RefNode *RefTable::Get(SQObject &obj,SQHash &mainpos,RefNode **prev,bo
return ref; return ref;
} }
void RefTable::AllocNodes(SQUnsignedInteger size) void RefTable::AllocNodes(uint64_t size)
{ {
RefNode **bucks; RefNode **bucks;
RefNode *nodes; RefNode *nodes;
bucks = (RefNode **)SQ_MALLOC((size * sizeof(RefNode *)) + (size * sizeof(RefNode))); bucks = (RefNode **)SQ_MALLOC((size * sizeof(RefNode *)) + (size * sizeof(RefNode)));
nodes = (RefNode *)&bucks[size]; nodes = (RefNode *)&bucks[size];
RefNode *temp = nodes; RefNode *temp = nodes;
SQUnsignedInteger n; uint64_t n;
for(n = 0; n < size - 1; n++) { for(n = 0; n < size - 1; n++) {
bucks[n] = NULL; bucks[n] = NULL;
temp->refs = 0; temp->refs = 0;
@ -390,17 +390,17 @@ SQStringTable::~SQStringTable()
_strings = NULL; _strings = NULL;
} }
void SQStringTable::AllocNodes(SQInteger size) void SQStringTable::AllocNodes(int64_t size)
{ {
_numofslots = size; _numofslots = size;
_strings = (SQString**)SQ_MALLOC(sizeof(SQString*)*_numofslots); _strings = (SQString**)SQ_MALLOC(sizeof(SQString*)*_numofslots);
memset(_strings,0,sizeof(SQString*)*_numofslots); memset(_strings,0,sizeof(SQString*)*_numofslots);
} }
SQString *SQStringTable::Add(const SQChar *news,SQInteger len) SQString *SQStringTable::Add(const SQChar *news,int64_t len)
{ {
if(len<0) if(len<0)
len = (SQInteger)scstrlen(news); len = (int64_t)scstrlen(news);
SQHash newhash = ::_hashstr(news,len); SQHash newhash = ::_hashstr(news,len);
SQHash h = newhash&(_numofslots-1); SQHash h = newhash&(_numofslots-1);
SQString *s; SQString *s;
@ -424,12 +424,12 @@ SQString *SQStringTable::Add(const SQChar *news,SQInteger len)
return t; return t;
} }
void SQStringTable::Resize(SQInteger size) void SQStringTable::Resize(int64_t size)
{ {
SQInteger oldsize=_numofslots; int64_t oldsize=_numofslots;
SQString **oldtable=_strings; SQString **oldtable=_strings;
AllocNodes(size); AllocNodes(size);
for (SQInteger i=0; i<oldsize; i++){ for (int64_t i=0; i<oldsize; i++){
SQString *p = oldtable[i]; SQString *p = oldtable[i];
while(p){ while(p){
SQString *next = p->_next; SQString *next = p->_next;
@ -455,7 +455,7 @@ void SQStringTable::Remove(SQString *bs)
else else
_strings[h] = s->_next; _strings[h] = s->_next;
_slotused--; _slotused--;
SQInteger slen = s->_len; int64_t slen = s->_len;
s->~SQString(); s->~SQString();
SQ_FREE(s,sizeof(SQString) + sq_rsl(slen)); SQ_FREE(s,sizeof(SQString) + sq_rsl(slen));
return; return;

28
rabbit/sqstate.hpp
View File

@ -18,36 +18,36 @@ struct SQStringTable
{ {
SQStringTable(SQSharedState*ss); SQStringTable(SQSharedState*ss);
~SQStringTable(); ~SQStringTable();
SQString *Add(const SQChar *,SQInteger len); SQString *Add(const SQChar *,int64_t len);
void Remove(SQString *); void Remove(SQString *);
private: private:
void Resize(SQInteger size); void Resize(int64_t size);
void AllocNodes(SQInteger size); void AllocNodes(int64_t size);
SQString **_strings; SQString **_strings;
SQUnsignedInteger _numofslots; uint64_t _numofslots;
SQUnsignedInteger _slotused; uint64_t _slotused;
SQSharedState *_sharedstate; SQSharedState *_sharedstate;
}; };
struct RefTable { struct RefTable {
struct RefNode { struct RefNode {
SQObjectPtr obj; SQObjectPtr obj;
SQUnsignedInteger refs; uint64_t refs;
struct RefNode *next; struct RefNode *next;
}; };
RefTable(); RefTable();
~RefTable(); ~RefTable();
void AddRef(SQObject &obj); void AddRef(SQObject &obj);
SQBool Release(SQObject &obj); SQBool Release(SQObject &obj);
SQUnsignedInteger GetRefCount(SQObject &obj); uint64_t GetRefCount(SQObject &obj);
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);
RefNode *Add(SQHash mainpos,SQObject &obj); RefNode *Add(SQHash mainpos,SQObject &obj);
void Resize(SQUnsignedInteger size); void Resize(uint64_t size);
void AllocNodes(SQUnsignedInteger size); void AllocNodes(uint64_t size);
SQUnsignedInteger _numofslots; uint64_t _numofslots;
SQUnsignedInteger _slotused; uint64_t _slotused;
RefNode *_nodes; RefNode *_nodes;
RefNode *_freelist; RefNode *_freelist;
RefNode **_buckets; RefNode **_buckets;
@ -64,8 +64,8 @@ struct SQSharedState
~SQSharedState(); ~SQSharedState();
void Init(); void Init();
public: public:
SQChar* GetScratchPad(SQInteger size); SQChar* GetScratchPad(int64_t size);
SQInteger GetMetaMethodIdxByName(const SQObjectPtr &name); int64_t GetMetaMethodIdxByName(const SQObjectPtr &name);
SQObjectPtrVec *_metamethods; SQObjectPtrVec *_metamethods;
SQObjectPtr _metamethodsmap; SQObjectPtr _metamethodsmap;
SQObjectPtrVec *_systemstrings; SQObjectPtrVec *_systemstrings;
@ -106,7 +106,7 @@ public:
SQRELEASEHOOK _releasehook; SQRELEASEHOOK _releasehook;
private: private:
SQChar *_scratchpad; SQChar *_scratchpad;
SQInteger _scratchpadsize; int64_t _scratchpadsize;
}; };
#define _sp(s) (_sharedstate->GetScratchPad(s)) #define _sp(s) (_sharedstate->GetScratchPad(s))

6
rabbit/sqstring.hpp
View File

@ -21,12 +21,12 @@ struct SQString : public SQRefCounted
SQString(){} SQString(){}
~SQString(){} ~SQString(){}
public: public:
static SQString *Create(SQSharedState *ss, const SQChar *, SQInteger len = -1 ); static SQString *Create(SQSharedState *ss, const SQChar *, int64_t len = -1 );
SQInteger Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); int64_t Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval);
void Release(); void Release();
SQSharedState *_sharedstate; SQSharedState *_sharedstate;
SQString *_next; //chain for the string table SQString *_next; //chain for the string table
SQInteger _len; int64_t _len;
SQHash _hash; SQHash _hash;
SQChar _val[1]; SQChar _val[1];
}; };

26
rabbit/sqtable.cpp
View File

@ -12,9 +12,9 @@
#include <rabbit/sqfuncproto.hpp> #include <rabbit/sqfuncproto.hpp>
#include <rabbit/sqclosure.hpp> #include <rabbit/sqclosure.hpp>
SQTable::SQTable(SQSharedState *ss,SQInteger nInitialSize) SQTable::SQTable(SQSharedState *ss,int64_t nInitialSize)
{ {
SQInteger pow2size=MINPOWER2; int64_t pow2size=MINPOWER2;
while(nInitialSize>pow2size)pow2size=pow2size<<1; while(nInitialSize>pow2size)pow2size=pow2size<<1;
AllocNodes(pow2size); AllocNodes(pow2size);
_usednodes = 0; _usednodes = 0;
@ -33,10 +33,10 @@ void SQTable::Remove(const SQObjectPtr &key)
} }
} }
void SQTable::AllocNodes(SQInteger nSize) void SQTable::AllocNodes(int64_t nSize)
{ {
_HashNode *nodes=(_HashNode *)SQ_MALLOC(sizeof(_HashNode)*nSize); _HashNode *nodes=(_HashNode *)SQ_MALLOC(sizeof(_HashNode)*nSize);
for(SQInteger i=0;i<nSize;i++){ for(int64_t i=0;i<nSize;i++){
_HashNode &n = nodes[i]; _HashNode &n = nodes[i];
new (&n) _HashNode; new (&n) _HashNode;
n.next=NULL; n.next=NULL;
@ -48,11 +48,11 @@ void SQTable::AllocNodes(SQInteger nSize)
void SQTable::Rehash(bool force) void SQTable::Rehash(bool force)
{ {
SQInteger oldsize=_numofnodes; int64_t oldsize=_numofnodes;
//prevent problems with the integer division //prevent problems with the integer division
if(oldsize<4)oldsize=4; if(oldsize<4)oldsize=4;
_HashNode *nold=_nodes; _HashNode *nold=_nodes;
SQInteger nelems=CountUsed(); int64_t nelems=CountUsed();
if (nelems >= oldsize-oldsize/4) /* using more than 3/4? */ if (nelems >= oldsize-oldsize/4) /* using more than 3/4? */
AllocNodes(oldsize*2); AllocNodes(oldsize*2);
else if (nelems <= oldsize/4 && /* less than 1/4? */ else if (nelems <= oldsize/4 && /* less than 1/4? */
@ -63,12 +63,12 @@ void SQTable::Rehash(bool force)
else else
return; return;
_usednodes = 0; _usednodes = 0;
for (SQInteger i=0; i<oldsize; i++) { for (int64_t i=0; i<oldsize; i++) {
_HashNode *old = nold+i; _HashNode *old = nold+i;
if (sq_type(old->key) != OT_NULL) if (sq_type(old->key) != OT_NULL)
NewSlot(old->key,old->val); NewSlot(old->key,old->val);
} }
for(SQInteger k=0;k<oldsize;k++) for(int64_t k=0;k<oldsize;k++)
nold[k].~_HashNode(); nold[k].~_HashNode();
SQ_FREE(nold,oldsize*sizeof(_HashNode)); SQ_FREE(nold,oldsize*sizeof(_HashNode));
} }
@ -81,7 +81,7 @@ SQTable *SQTable::Clone()
_HashNode *basedst = nt->_nodes; _HashNode *basedst = nt->_nodes;
_HashNode *src = _nodes; _HashNode *src = _nodes;
_HashNode *dst = nt->_nodes; _HashNode *dst = nt->_nodes;
SQInteger n = 0; int64_t n = 0;
for(n = 0; n < _numofnodes; n++) { for(n = 0; n < _numofnodes; n++) {
dst->key = src->key; dst->key = src->key;
dst->val = src->val; dst->val = src->val;
@ -98,7 +98,7 @@ SQTable *SQTable::Clone()
nt->_firstfree = basedst + (_firstfree - basesrc); nt->_firstfree = basedst + (_firstfree - basesrc);
nt->_usednodes = _usednodes; nt->_usednodes = _usednodes;
#else #else
SQInteger ridx=0; int64_t ridx=0;
SQObjectPtr key,val; SQObjectPtr key,val;
while((ridx=Next(true,ridx,key,val))!=-1){ while((ridx=Next(true,ridx,key,val))!=-1){
nt->NewSlot(key,val); nt->NewSlot(key,val);
@ -176,9 +176,9 @@ bool SQTable::NewSlot(const SQObjectPtr &key,const SQObjectPtr &val)
return NewSlot(key, val); return NewSlot(key, val);
} }
SQInteger SQTable::Next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval) int64_t SQTable::Next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval)
{ {
SQInteger idx = (SQInteger)TranslateIndex(refpos); int64_t idx = (int64_t)TranslateIndex(refpos);
while (idx < _numofnodes) { while (idx < _numofnodes) {
if(sq_type(_nodes[idx].key) != OT_NULL) { if(sq_type(_nodes[idx].key) != OT_NULL) {
//first found //first found
@ -207,7 +207,7 @@ bool SQTable::Set(const SQObjectPtr &key, const SQObjectPtr &val)
void SQTable::_ClearNodes() void SQTable::_ClearNodes()
{ {
for(SQInteger i = 0;i < _numofnodes; i++) { _HashNode &n = _nodes[i]; n.key.Null(); n.val.Null(); } for(int64_t i = 0;i < _numofnodes; i++) { _HashNode &n = _nodes[i]; n.key.Null(); n.val.Null(); }
} }
void SQTable::Finalize() void SQTable::Finalize()

24
rabbit/sqtable.hpp
View File

@ -16,14 +16,14 @@
#include <rabbit/sqstring.hpp> #include <rabbit/sqstring.hpp>
#define hashptr(p) ((SQHash)(((SQInteger)p) >> 3)) #define hashptr(p) ((SQHash)(((int64_t)p) >> 3))
inline SQHash HashObj(const SQObjectPtr &key) inline SQHash HashObj(const SQObjectPtr &key)
{ {
switch(sq_type(key)) { switch(sq_type(key)) {
case OT_STRING: return _string(key)->_hash; case OT_STRING: return _string(key)->_hash;
case OT_FLOAT: return (SQHash)((SQInteger)_float(key)); case OT_FLOAT: return (SQHash)((int64_t)_float(key));
case OT_BOOL: case OT_INTEGER: return (SQHash)((SQInteger)_integer(key)); case OT_BOOL: case OT_INTEGER: return (SQHash)((int64_t)_integer(key));
default: return hashptr(key._unVal.pRefCounted); default: return hashptr(key._unVal.pRefCounted);
} }
} }
@ -40,16 +40,16 @@ private:
}; };
_HashNode *_firstfree; _HashNode *_firstfree;
_HashNode *_nodes; _HashNode *_nodes;
SQInteger _numofnodes; int64_t _numofnodes;
SQInteger _usednodes; int64_t _usednodes;
/////////////////////////// ///////////////////////////
void AllocNodes(SQInteger nSize); void AllocNodes(int64_t nSize);
void Rehash(bool force); void Rehash(bool force);
SQTable(SQSharedState *ss, SQInteger nInitialSize); SQTable(SQSharedState *ss, int64_t nInitialSize);
void _ClearNodes(); void _ClearNodes();
public: public:
static SQTable* Create(SQSharedState *ss,SQInteger nInitialSize) static SQTable* Create(SQSharedState *ss,int64_t nInitialSize)
{ {
SQTable *newtable = (SQTable*)SQ_MALLOC(sizeof(SQTable)); SQTable *newtable = (SQTable*)SQ_MALLOC(sizeof(SQTable));
new (newtable) SQTable(ss, nInitialSize); new (newtable) SQTable(ss, nInitialSize);
@ -61,7 +61,7 @@ public:
~SQTable() ~SQTable()
{ {
SetDelegate(NULL); SetDelegate(NULL);
for (SQInteger i = 0; i < _numofnodes; i++) _nodes[i].~_HashNode(); for (int64_t i = 0; i < _numofnodes; i++) _nodes[i].~_HashNode();
SQ_FREE(_nodes, _numofnodes * sizeof(_HashNode)); SQ_FREE(_nodes, _numofnodes * sizeof(_HashNode));
} }
inline _HashNode *_Get(const SQObjectPtr &key,SQHash hash) inline _HashNode *_Get(const SQObjectPtr &key,SQHash hash)
@ -75,7 +75,7 @@ public:
return NULL; return NULL;
} }
//for compiler use //for compiler use
inline bool GetStr(const SQChar* key,SQInteger keylen,SQObjectPtr &val) inline bool GetStr(const SQChar* key,int64_t keylen,SQObjectPtr &val)
{ {
SQHash hash = _hashstr(key,keylen); SQHash hash = _hashstr(key,keylen);
_HashNode *n = &_nodes[hash & (_numofnodes - 1)]; _HashNode *n = &_nodes[hash & (_numofnodes - 1)];
@ -97,9 +97,9 @@ public:
bool Set(const SQObjectPtr &key, const SQObjectPtr &val); bool Set(const SQObjectPtr &key, const SQObjectPtr &val);
//returns true if a new slot has been created false if it was already present //returns true if a new slot has been created false if it was already present
bool NewSlot(const SQObjectPtr &key,const SQObjectPtr &val); bool NewSlot(const SQObjectPtr &key,const SQObjectPtr &val);
SQInteger Next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval); int64_t Next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval);
SQInteger CountUsed(){ return _usednodes;} int64_t CountUsed(){ return _usednodes;}
void Clear(); void Clear();
void Release() void Release()
{ {

34
rabbit/squtils.hpp
View File

@ -7,9 +7,9 @@
*/ */
#pragma once #pragma once
void *sq_vm_malloc(SQUnsignedInteger size); void *sq_vm_malloc(uint64_t size);
void *sq_vm_realloc(void *p,SQUnsignedInteger oldsize,SQUnsignedInteger size); void *sq_vm_realloc(void *p,uint64_t oldsize,uint64_t size);
void sq_vm_free(void *p,SQUnsignedInteger size); void sq_vm_free(void *p,uint64_t size);
#define sq_new(__ptr,__type) {__ptr=(__type *)sq_vm_malloc(sizeof(__type));new (__ptr) __type;} #define sq_new(__ptr,__type) {__ptr=(__type *)sq_vm_malloc(sizeof(__type));new (__ptr) __type;}
#define sq_delete(__ptr,__type) {__ptr->~__type();sq_vm_free(__ptr,sizeof(__type));} #define sq_delete(__ptr,__type) {__ptr->~__type();sq_vm_free(__ptr,sizeof(__type));}
@ -42,7 +42,7 @@ public:
if(v._size > _allocated) { if(v._size > _allocated) {
_realloc(v._size); _realloc(v._size);
} }
for(SQUnsignedInteger i = 0; i < v._size; i++) { for(uint64_t i = 0; i < v._size; i++) {
new ((void *)&_vals[i]) T(v._vals[i]); new ((void *)&_vals[i]) T(v._vals[i]);
} }
_size = v._size; _size = v._size;
@ -50,13 +50,13 @@ public:
~sqvector() ~sqvector()
{ {
if(_allocated) { if(_allocated) {
for(SQUnsignedInteger i = 0; i < _size; i++) for(uint64_t i = 0; i < _size; i++)
_vals[i].~T(); _vals[i].~T();
SQ_FREE(_vals, (_allocated * sizeof(T))); SQ_FREE(_vals, (_allocated * sizeof(T)));
} }
} }
void reserve(SQUnsignedInteger newsize) { _realloc(newsize); } void reserve(uint64_t newsize) { _realloc(newsize); }
void resize(SQUnsignedInteger newsize, const T& fill = T()) void resize(uint64_t newsize, const T& fill = T())
{ {
if(newsize > _allocated) if(newsize > _allocated)
_realloc(newsize); _realloc(newsize);
@ -67,7 +67,7 @@ public:
} }
} }
else{ else{
for(SQUnsignedInteger i = newsize; i < _size; i++) { for(uint64_t i = newsize; i < _size; i++) {
_vals[i].~T(); _vals[i].~T();
} }
_size = newsize; _size = newsize;
@ -75,7 +75,7 @@ public:
} }
void shrinktofit() { if(_size > 4) { _realloc(_size); } } void shrinktofit() { if(_size > 4) { _realloc(_size); } }
T& top() const { return _vals[_size - 1]; } T& top() const { return _vals[_size - 1]; }
inline SQUnsignedInteger size() const { return _size; } inline uint64_t size() const { return _size; }
bool empty() const { return (_size <= 0); } bool empty() const { return (_size <= 0); }
inline T &push_back(const T& val = T()) inline T &push_back(const T& val = T())
{ {
@ -87,15 +87,15 @@ public:
{ {
_size--; _vals[_size].~T(); _size--; _vals[_size].~T();
} }
void insert(SQUnsignedInteger idx, const T& val) void insert(uint64_t idx, const T& val)
{ {
resize(_size + 1); resize(_size + 1);
for(SQUnsignedInteger i = _size - 1; i > idx; i--) { for(uint64_t i = _size - 1; i > idx; i--) {
_vals[i] = _vals[i - 1]; _vals[i] = _vals[i - 1];
} }
_vals[idx] = val; _vals[idx] = val;
} }
void remove(SQUnsignedInteger idx) void remove(uint64_t idx)
{ {
_vals[idx].~T(); _vals[idx].~T();
if(idx < (_size - 1)) { if(idx < (_size - 1)) {
@ -103,18 +103,18 @@ public:
} }
_size--; _size--;
} }
SQUnsignedInteger capacity() { return _allocated; } uint64_t capacity() { return _allocated; }
inline T &back() const { return _vals[_size - 1]; } inline T &back() const { return _vals[_size - 1]; }
inline T& operator[](SQUnsignedInteger pos) const{ return _vals[pos]; } inline T& operator[](uint64_t pos) const{ return _vals[pos]; }
T* _vals; T* _vals;
private: private:
void _realloc(SQUnsignedInteger newsize) void _realloc(uint64_t newsize)
{ {
newsize = (newsize > 0)?newsize:4; newsize = (newsize > 0)?newsize:4;
_vals = (T*)SQ_REALLOC(_vals, _allocated * sizeof(T), newsize * sizeof(T)); _vals = (T*)SQ_REALLOC(_vals, _allocated * sizeof(T), newsize * sizeof(T));
_allocated = newsize; _allocated = newsize;
} }
SQUnsignedInteger _size; uint64_t _size;
SQUnsignedInteger _allocated; uint64_t _allocated;
}; };

228
rabbit/sqvm.cpp
View File

@ -22,19 +22,19 @@
#define TARGET _stack._vals[_stackbase+arg0] #define TARGET _stack._vals[_stackbase+arg0]
#define STK(a) _stack._vals[_stackbase+(a)] #define STK(a) _stack._vals[_stackbase+(a)]
bool SQVM::BW_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2) bool SQVM::BW_OP(uint64_t op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
{ {
SQInteger res; int64_t res;
if((sq_type(o1)| sq_type(o2)) == OT_INTEGER) if((sq_type(o1)| sq_type(o2)) == OT_INTEGER)
{ {
SQInteger i1 = _integer(o1), i2 = _integer(o2); int64_t i1 = _integer(o1), i2 = _integer(o2);
switch(op) { switch(op) {
case BW_AND: res = i1 & i2; break; case BW_AND: res = i1 & i2; break;
case BW_OR: res = i1 | i2; break; case BW_OR: res = i1 | i2; break;
case BW_XOR: res = i1 ^ i2; break; case BW_XOR: res = i1 ^ i2; break;
case BW_SHIFTL: res = i1 << i2; break; case BW_SHIFTL: res = i1 << i2; break;
case BW_SHIFTR: res = i1 >> i2; break; case BW_SHIFTR: res = i1 >> i2; break;
case BW_USHIFTR:res = (SQInteger)(*((SQUnsignedInteger*)&i1) >> i2); break; case BW_USHIFTR:res = (int64_t)(*((uint64_t*)&i1) >> i2); break;
default: { Raise_Error(_SC("internal vm error bitwise op failed")); return false; } default: { Raise_Error(_SC("internal vm error bitwise op failed")); return false; }
} }
} }
@ -45,7 +45,7 @@ bool SQVM::BW_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,con
#define _ARITH_(op,trg,o1,o2) \ #define _ARITH_(op,trg,o1,o2) \
{ \ { \
SQInteger tmask = sq_type(o1)|sq_type(o2); \ int64_t tmask = sq_type(o1)|sq_type(o2); \
switch(tmask) { \ switch(tmask) { \
case OT_INTEGER: trg = _integer(o1) op _integer(o2);break; \ case OT_INTEGER: trg = _integer(o1) op _integer(o2);break; \
case (OT_FLOAT|OT_INTEGER): \ case (OT_FLOAT|OT_INTEGER): \
@ -56,21 +56,21 @@ bool SQVM::BW_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,con
#define _ARITH_NOZERO(op,trg,o1,o2,err) \ #define _ARITH_NOZERO(op,trg,o1,o2,err) \
{ \ { \
SQInteger tmask = sq_type(o1)|sq_type(o2); \ int64_t tmask = sq_type(o1)|sq_type(o2); \
switch(tmask) { \ switch(tmask) { \
case OT_INTEGER: { SQInteger i2 = _integer(o2); if(i2 == 0) { Raise_Error(err); SQ_THROW(); } trg = _integer(o1) op i2; } break;\ case OT_INTEGER: { int64_t i2 = _integer(o2); if(i2 == 0) { Raise_Error(err); SQ_THROW(); } trg = _integer(o1) op i2; } break;\
case (OT_FLOAT|OT_INTEGER): \ case (OT_FLOAT|OT_INTEGER): \
case (OT_FLOAT): trg = tofloat(o1) op tofloat(o2); break;\ case (OT_FLOAT): trg = tofloat(o1) op tofloat(o2); break;\
default: _GUARD(ARITH_OP((#op)[0],trg,o1,o2)); break;\ default: _GUARD(ARITH_OP((#op)[0],trg,o1,o2)); break;\
} \ } \
} }
bool SQVM::ARITH_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2) bool SQVM::ARITH_OP(uint64_t op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2)
{ {
SQInteger tmask = sq_type(o1)| sq_type(o2); int64_t tmask = sq_type(o1)| sq_type(o2);
switch(tmask) { switch(tmask) {
case OT_INTEGER:{ case OT_INTEGER:{
SQInteger res, i1 = _integer(o1), i2 = _integer(o2); int64_t res, i1 = _integer(o1), i2 = _integer(o2);
switch(op) { switch(op) {
case '+': res = i1 + i2; break; case '+': res = i1 + i2; break;
case '-': res = i1 - i2; break; case '-': res = i1 - i2; break;
@ -89,13 +89,13 @@ bool SQVM::ARITH_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,
break; break;
case (OT_FLOAT|OT_INTEGER): case (OT_FLOAT|OT_INTEGER):
case (OT_FLOAT):{ case (OT_FLOAT):{
SQFloat res, f1 = tofloat(o1), f2 = tofloat(o2); float_t res, f1 = tofloat(o1), f2 = tofloat(o2);
switch(op) { switch(op) {
case '+': res = f1 + f2; break; case '+': res = f1 + f2; break;
case '-': res = f1 - f2; break; case '-': res = f1 - f2; break;
case '/': res = f1 / f2; break; case '/': res = f1 / f2; break;
case '*': res = f1 * f2; break; case '*': res = f1 * f2; break;
case '%': res = SQFloat(fmod((double)f1,(double)f2)); break; case '%': res = float_t(fmod((double)f1,(double)f2)); break;
default: res = 0x0f; default: res = 0x0f;
} }
trg = res; } trg = res; }
@ -143,8 +143,8 @@ void SQVM::Finalize()
_debughook_closure.Null(); _debughook_closure.Null();
temp_reg.Null(); temp_reg.Null();
_callstackdata.resize(0); _callstackdata.resize(0);
SQInteger size=_stack.size(); int64_t size=_stack.size();
for(SQInteger i=0;i<size;i++) for(int64_t i=0;i<size;i++)
_stack[i].Null(); _stack[i].Null();
} }
@ -153,7 +153,7 @@ SQVM::~SQVM()
Finalize(); Finalize();
} }
bool SQVM::ArithMetaMethod(SQInteger op,const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &dest) bool SQVM::ArithMetaMethod(int64_t op,const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &dest)
{ {
SQMetaMethod mm; SQMetaMethod mm;
switch(op){ switch(op){
@ -206,7 +206,7 @@ bool SQVM::NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o)
} }
#define _RET_SUCCEED(exp) { result = (exp); return true; } #define _RET_SUCCEED(exp) { result = (exp); return true; }
bool SQVM::ObjCmp(const SQObjectPtr &o1,const SQObjectPtr &o2,SQInteger &result) bool SQVM::ObjCmp(const SQObjectPtr &o1,const SQObjectPtr &o2,int64_t &result)
{ {
SQObjectType t1 = sq_type(o1), t2 = sq_type(o2); SQObjectType t1 = sq_type(o1), t2 = sq_type(o2);
if(t1 == t2) { if(t1 == t2) {
@ -269,7 +269,7 @@ bool SQVM::ObjCmp(const SQObjectPtr &o1,const SQObjectPtr &o2,SQInteger &result)
bool SQVM::CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res) bool SQVM::CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res)
{ {
SQInteger r; int64_t r;
if(ObjCmp(o1,o2,r)) { if(ObjCmp(o1,o2,r)) {
switch(op) { switch(op) {
case CMP_G: res = (r > 0); return true; case CMP_G: res = (r > 0); return true;
@ -327,7 +327,7 @@ bool SQVM::StringCat(const SQObjectPtr &str,const SQObjectPtr &obj,SQObjectPtr &
SQObjectPtr a, b; SQObjectPtr a, b;
if(!ToString(str, a)) return false; if(!ToString(str, a)) return false;
if(!ToString(obj, b)) return false; if(!ToString(obj, b)) return false;
SQInteger l = _string(a)->_len , ol = _string(b)->_len; int64_t l = _string(a)->_len , ol = _string(b)->_len;
SQChar *s = _sp(sq_rsl(l + ol + 1)); SQChar *s = _sp(sq_rsl(l + ol + 1));
memcpy(s, _stringval(a), sq_rsl(l)); memcpy(s, _stringval(a), sq_rsl(l));
memcpy(s + l, _stringval(b), sq_rsl(ol)); memcpy(s + l, _stringval(b), sq_rsl(ol));
@ -348,7 +348,7 @@ bool SQVM::TypeOf(const SQObjectPtr &obj1,SQObjectPtr &dest)
return true; return true;
} }
bool SQVM::Init(SQVM *friendvm, SQInteger stacksize) bool SQVM::Init(SQVM *friendvm, int64_t stacksize)
{ {
_stack.resize(stacksize); _stack.resize(stacksize);
_alloccallsstacksize = 4; _alloccallsstacksize = 4;
@ -374,13 +374,13 @@ bool SQVM::Init(SQVM *friendvm, SQInteger stacksize)
} }
bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger args,SQInteger stackbase,bool tailcall) bool SQVM::StartCall(SQClosure *closure,int64_t target,int64_t args,int64_t stackbase,bool tailcall)
{ {
SQFunctionProto *func = closure->_function; SQFunctionProto *func = closure->_function;
SQInteger paramssize = func->_nparameters; int64_t paramssize = func->_nparameters;
const SQInteger newtop = stackbase + func->_stacksize; const int64_t newtop = stackbase + func->_stacksize;
SQInteger nargs = args; int64_t nargs = args;
if(func->_varparams) if(func->_varparams)
{ {
paramssize--; paramssize--;
@ -390,10 +390,10 @@ bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger args,SQIntege
} }
//dumpstack(stackbase); //dumpstack(stackbase);
SQInteger nvargs = nargs - paramssize; int64_t nvargs = nargs - paramssize;
SQArray *arr = SQArray::Create(_ss(this),nvargs); SQArray *arr = SQArray::Create(_ss(this),nvargs);
SQInteger pbase = stackbase+paramssize; int64_t pbase = stackbase+paramssize;
for(SQInteger n = 0; n < nvargs; n++) { for(int64_t n = 0; n < nvargs; n++) {
arr->_values[n] = _stack._vals[pbase]; arr->_values[n] = _stack._vals[pbase];
_stack._vals[pbase].Null(); _stack._vals[pbase].Null();
pbase++; pbase++;
@ -403,10 +403,10 @@ bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger args,SQIntege
//dumpstack(stackbase); //dumpstack(stackbase);
} }
else if (paramssize != nargs) { else if (paramssize != nargs) {
SQInteger ndef = func->_ndefaultparams; int64_t ndef = func->_ndefaultparams;
SQInteger diff; int64_t diff;
if(ndef && nargs < paramssize && (diff = paramssize - nargs) <= ndef) { if(ndef && nargs < paramssize && (diff = paramssize - nargs) <= ndef) {
for(SQInteger n = ndef - diff; n < ndef; n++) { for(int64_t n = ndef - diff; n < ndef; n++) {
_stack._vals[stackbase + (nargs++)] = closure->_defaultparams[n]; _stack._vals[stackbase + (nargs++)] = closure->_defaultparams[n];
} }
} }
@ -425,7 +425,7 @@ bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger args,SQIntege
ci->_closure = closure; ci->_closure = closure;
ci->_literals = func->_literals; ci->_literals = func->_literals;
ci->_ip = func->_instructions; ci->_ip = func->_instructions;
ci->_target = (SQInt32)target; ci->_target = (int32_t)target;
if (_debughook) { if (_debughook) {
CallDebugHook(_SC('c')); CallDebugHook(_SC('c'));
@ -445,13 +445,13 @@ bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger args,SQIntege
return true; return true;
} }
bool SQVM::Return(SQInteger _arg0, SQInteger _arg1, SQObjectPtr &retval) bool SQVM::Return(int64_t _arg0, int64_t _arg1, SQObjectPtr &retval)
{ {
SQBool _isroot = ci->_root; SQBool _isroot = ci->_root;
SQInteger callerbase = _stackbase - ci->_prevstkbase; int64_t callerbase = _stackbase - ci->_prevstkbase;
if (_debughook) { if (_debughook) {
for(SQInteger i=0; i<ci->_ncalls; i++) { for(int64_t i=0; i<ci->_ncalls; i++) {
CallDebugHook(_SC('r')); CallDebugHook(_SC('r'));
} }
} }
@ -479,7 +479,7 @@ bool SQVM::Return(SQInteger _arg0, SQInteger _arg1, SQObjectPtr &retval)
#define _RET_ON_FAIL(exp) { if(!exp) return false; } #define _RET_ON_FAIL(exp) { if(!exp) return false; }
bool SQVM::PLOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr) bool SQVM::PLOCAL_INC(int64_t op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr)
{ {
SQObjectPtr trg; SQObjectPtr trg;
_RET_ON_FAIL(ARITH_OP( op , trg, a, incr)); _RET_ON_FAIL(ARITH_OP( op , trg, a, incr));
@ -488,7 +488,7 @@ bool SQVM::PLOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObject
return true; return true;
} }
bool SQVM::DerefInc(SQInteger op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix,SQInteger selfidx) bool SQVM::DerefInc(int64_t op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix,int64_t selfidx)
{ {
SQObjectPtr tmp, tself = self, tkey = key; SQObjectPtr tmp, tself = self, tkey = key;
if (!Get(tself, tkey, tmp, 0, selfidx)) { return false; } if (!Get(tself, tkey, tmp, 0, selfidx)) { return false; }
@ -499,12 +499,12 @@ bool SQVM::DerefInc(SQInteger op,SQObjectPtr &target, SQObjectPtr &self, SQObjec
} }
#define arg0 (_i_._arg0) #define arg0 (_i_._arg0)
#define sarg0 ((SQInteger)*((const signed char *)&_i_._arg0)) #define sarg0 ((int64_t)*((const signed char *)&_i_._arg0))
#define arg1 (_i_._arg1) #define arg1 (_i_._arg1)
#define sarg1 (*((const SQInt32 *)&_i_._arg1)) #define sarg1 (*((const int32_t *)&_i_._arg1))
#define arg2 (_i_._arg2) #define arg2 (_i_._arg2)
#define arg3 (_i_._arg3) #define arg3 (_i_._arg3)
#define sarg3 ((SQInteger)*((const signed char *)&_i_._arg3)) #define sarg3 ((int64_t)*((const signed char *)&_i_._arg3))
SQRESULT SQVM::Suspend() SQRESULT SQVM::Suspend()
{ {
@ -518,22 +518,22 @@ SQRESULT SQVM::Suspend()
#define _FINISH(howmuchtojump) {jump = howmuchtojump; return true; } #define _FINISH(howmuchtojump) {jump = howmuchtojump; return true; }
bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr
&o3,SQObjectPtr &o4,SQInteger SQ_UNUSED_ARG(arg_2),int exitpos,int &jump) &o3,SQObjectPtr &o4,int64_t SQ_UNUSED_ARG(arg_2),int exitpos,int &jump)
{ {
SQInteger nrefidx; int64_t nrefidx;
switch(sq_type(o1)) { switch(sq_type(o1)) {
case OT_TABLE: case OT_TABLE:
if((nrefidx = _table(o1)->Next(false,o4, o2, o3)) == -1) _FINISH(exitpos); if((nrefidx = _table(o1)->Next(false,o4, o2, o3)) == -1) _FINISH(exitpos);
o4 = (SQInteger)nrefidx; _FINISH(1); o4 = (int64_t)nrefidx; _FINISH(1);
case OT_ARRAY: case OT_ARRAY:
if((nrefidx = _array(o1)->Next(o4, o2, o3)) == -1) _FINISH(exitpos); if((nrefidx = _array(o1)->Next(o4, o2, o3)) == -1) _FINISH(exitpos);
o4 = (SQInteger) nrefidx; _FINISH(1); o4 = (int64_t) nrefidx; _FINISH(1);
case OT_STRING: case OT_STRING:
if((nrefidx = _string(o1)->Next(o4, o2, o3)) == -1)_FINISH(exitpos); if((nrefidx = _string(o1)->Next(o4, o2, o3)) == -1)_FINISH(exitpos);
o4 = (SQInteger)nrefidx; _FINISH(1); o4 = (int64_t)nrefidx; _FINISH(1);
case OT_CLASS: case OT_CLASS:
if((nrefidx = _class(o1)->Next(o4, o2, o3)) == -1)_FINISH(exitpos); if((nrefidx = _class(o1)->Next(o4, o2, o3)) == -1)_FINISH(exitpos);
o4 = (SQInteger)nrefidx; _FINISH(1); o4 = (int64_t)nrefidx; _FINISH(1);
case OT_USERDATA: case OT_USERDATA:
case OT_INSTANCE: case OT_INSTANCE:
if(_delegable(o1)->_delegate) { if(_delegable(o1)->_delegate) {
@ -562,7 +562,7 @@ bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr
case OT_GENERATOR: case OT_GENERATOR:
if(_generator(o1)->_state == SQGenerator::eDead) _FINISH(exitpos); if(_generator(o1)->_state == SQGenerator::eDead) _FINISH(exitpos);
if(_generator(o1)->_state == SQGenerator::eSuspended) { if(_generator(o1)->_state == SQGenerator::eSuspended) {
SQInteger idx = 0; int64_t idx = 0;
if(sq_type(o4) == OT_INTEGER) { if(sq_type(o4) == OT_INTEGER) {
idx = _integer(o4) + 1; idx = _integer(o4) + 1;
} }
@ -585,10 +585,10 @@ bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr
bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func) bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func)
{ {
SQInteger nouters; int64_t nouters;
SQClosure *closure = SQClosure::Create(_ss(this), func,_table(_roottable)->GetWeakRef(OT_TABLE)); SQClosure *closure = SQClosure::Create(_ss(this), func,_table(_roottable)->GetWeakRef(OT_TABLE));
if((nouters = func->_noutervalues)) { if((nouters = func->_noutervalues)) {
for(SQInteger i = 0; i<nouters; i++) { for(int64_t i = 0; i<nouters; i++) {
SQOuterVar &v = func->_outervalues[i]; SQOuterVar &v = func->_outervalues[i];
switch(v._type){ switch(v._type){
case otLOCAL: case otLOCAL:
@ -600,10 +600,10 @@ bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func)
} }
} }
} }
SQInteger ndefparams; int64_t ndefparams;
if((ndefparams = func->_ndefaultparams)) { if((ndefparams = func->_ndefaultparams)) {
for(SQInteger i = 0; i < ndefparams; i++) { for(int64_t i = 0; i < ndefparams; i++) {
SQInteger spos = func->_defaultparams[i]; int64_t spos = func->_defaultparams[i];
closure->_defaultparams[i] = _stack._vals[_stackbase + spos]; closure->_defaultparams[i] = _stack._vals[_stackbase + spos];
} }
} }
@ -613,7 +613,7 @@ bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func)
} }
bool SQVM::CLASS_OP(SQObjectPtr &target,SQInteger baseclass,SQInteger attributes) bool SQVM::CLASS_OP(SQObjectPtr &target,int64_t baseclass,int64_t attributes)
{ {
SQClass *base = NULL; SQClass *base = NULL;
SQObjectPtr attrs; SQObjectPtr attrs;
@ -658,7 +658,7 @@ bool SQVM::IsEqual(const SQObjectPtr &o1,const SQObjectPtr &o2,bool &res)
bool SQVM::IsFalse(SQObjectPtr &o) bool SQVM::IsFalse(SQObjectPtr &o)
{ {
if(((sq_type(o) & SQOBJECT_CANBEFALSE) if(((sq_type(o) & SQOBJECT_CANBEFALSE)
&& ( ((sq_type(o) == OT_FLOAT) && (_float(o) == SQFloat(0.0))) )) && ( ((sq_type(o) == OT_FLOAT) && (_float(o) == float_t(0.0))) ))
#if !defined(SQUSEDOUBLE) || (defined(SQUSEDOUBLE) && defined(_SQ64)) #if !defined(SQUSEDOUBLE) || (defined(SQUSEDOUBLE) && defined(_SQ64))
|| (_integer(o) == 0) ) //OT_NULL|OT_INTEGER|OT_BOOL || (_integer(o) == 0) ) //OT_NULL|OT_INTEGER|OT_BOOL
#else #else
@ -670,12 +670,12 @@ bool SQVM::IsFalse(SQObjectPtr &o)
return false; return false;
} }
extern SQInstructionDesc g_InstrDesc[]; extern SQInstructionDesc g_InstrDesc[];
bool SQVM::Execute(SQObjectPtr &closure, SQInteger nargs, SQInteger stackbase,SQObjectPtr &outres, SQBool raiseerror,ExecutionType et) bool SQVM::Execute(SQObjectPtr &closure, int64_t nargs, int64_t stackbase,SQObjectPtr &outres, SQBool raiseerror,ExecutionType et)
{ {
if ((_nnativecalls + 1) > MAX_NATIVE_CALLS) { Raise_Error(_SC("Native stack overflow")); return false; } if ((_nnativecalls + 1) > MAX_NATIVE_CALLS) { Raise_Error(_SC("Native stack overflow")); return false; }
_nnativecalls++; _nnativecalls++;
AutoDec ad(&_nnativecalls); AutoDec ad(&_nnativecalls);
SQInteger traps = 0; int64_t traps = 0;
CallInfo *prevci = ci; CallInfo *prevci = ci;
switch(et) { switch(et) {
@ -717,20 +717,20 @@ exception_restore:
case _OP_LOAD: TARGET = ci->_literals[arg1]; continue; case _OP_LOAD: TARGET = ci->_literals[arg1]; continue;
case _OP_LOADINT: case _OP_LOADINT:
#ifndef _SQ64 #ifndef _SQ64
TARGET = (SQInteger)arg1; continue; TARGET = (int64_t)arg1; continue;
#else #else
TARGET = (SQInteger)((SQInt32)arg1); continue; TARGET = (int64_t)((int32_t)arg1); continue;
#endif #endif
case _OP_LOADFLOAT: TARGET = *((const SQFloat *)&arg1); continue; case _OP_LOADFLOAT: TARGET = *((const float_t *)&arg1); continue;
case _OP_DLOAD: TARGET = ci->_literals[arg1]; STK(arg2) = ci->_literals[arg3];continue; case _OP_DLOAD: TARGET = ci->_literals[arg1]; STK(arg2) = ci->_literals[arg3];continue;
case _OP_TAILCALL:{ case _OP_TAILCALL:{
SQObjectPtr &t = STK(arg1); SQObjectPtr &t = STK(arg1);
if (sq_type(t) == OT_CLOSURE if (sq_type(t) == OT_CLOSURE
&& (!_closure(t)->_function->_bgenerator)){ && (!_closure(t)->_function->_bgenerator)){
SQObjectPtr clo = t; SQObjectPtr clo = t;
SQInteger last_top = _top; int64_t last_top = _top;
if(_openouters) CloseOuters(&(_stack._vals[_stackbase])); if(_openouters) CloseOuters(&(_stack._vals[_stackbase]));
for (SQInteger i = 0; i < arg3; i++) STK(i) = STK(arg2 + i); for (int64_t i = 0; i < arg3; i++) STK(i) = STK(arg2 + i);
_GUARD(StartCall(_closure(clo), ci->_target, arg3, _stackbase, true)); _GUARD(StartCall(_closure(clo), ci->_target, arg3, _stackbase, true));
if (last_top >= _top) { if (last_top >= _top) {
_top = last_top; _top = last_top;
@ -747,7 +747,7 @@ exception_restore:
case OT_NATIVECLOSURE: { case OT_NATIVECLOSURE: {
bool suspend; bool suspend;
bool tailcall; bool tailcall;
_GUARD(CallNative(_nativeclosure(clo), arg3, _stackbase+arg2, clo, (SQInt32)sarg0, suspend, tailcall)); _GUARD(CallNative(_nativeclosure(clo), arg3, _stackbase+arg2, clo, (int32_t)sarg0, suspend, tailcall));
if(suspend){ if(suspend){
_suspended = SQTrue; _suspended = SQTrue;
_suspended_target = sarg0; _suspended_target = sarg0;
@ -767,7 +767,7 @@ exception_restore:
if(sarg0 != -1) { if(sarg0 != -1) {
STK(arg0) = inst; STK(arg0) = inst;
} }
SQInteger stkbase; int64_t stkbase;
switch(sq_type(clo)) { switch(sq_type(clo)) {
case OT_CLOSURE: case OT_CLOSURE:
stkbase = _stackbase+arg2; stkbase = _stackbase+arg2;
@ -790,7 +790,7 @@ exception_restore:
SQObjectPtr closure; SQObjectPtr closure;
if(_delegable(clo)->_delegate && _delegable(clo)->GetMetaMethod(this,MT_CALL,closure)) { if(_delegable(clo)->_delegate && _delegable(clo)->GetMetaMethod(this,MT_CALL,closure)) {
Push(clo); Push(clo);
for (SQInteger i = 0; i < arg3; i++) Push(STK(arg2 + i)); for (int64_t i = 0; i < arg3; i++) Push(STK(arg2 + i));
if(!CallMetaMethod(closure, MT_CALL, arg3+1, clo)) SQ_THROW(); if(!CallMetaMethod(closure, MT_CALL, arg3+1, clo)) SQ_THROW();
if(sarg0 != -1) { if(sarg0 != -1) {
STK(arg0) = clo; STK(arg0) = clo;
@ -863,7 +863,7 @@ exception_restore:
return true; return true;
} }
continue; continue;
case _OP_LOADNULLS:{ for(SQInt32 n=0; n < arg1; n++) STK(arg0+n).Null(); }continue; case _OP_LOADNULLS:{ for(int32_t n=0; n < arg1; n++) STK(arg0+n).Null(); }continue;
case _OP_LOADROOT: { case _OP_LOADROOT: {
SQWeakRef *w = _closure(ci->_closure)->_root; SQWeakRef *w = _closure(ci->_closure)->_root;
if(sq_type(w->_obj) != OT_NULL) { if(sq_type(w->_obj) != OT_NULL) {
@ -916,14 +916,14 @@ exception_restore:
case AAT_INT: case AAT_INT:
val._type = OT_INTEGER; val._type = OT_INTEGER;
#ifndef _SQ64 #ifndef _SQ64
val._unVal.nInteger = (SQInteger)arg1; val._unVal.nInteger = (int64_t)arg1;
#else #else
val._unVal.nInteger = (SQInteger)((SQInt32)arg1); val._unVal.nInteger = (int64_t)((int32_t)arg1);
#endif #endif
break; break;
case AAT_FLOAT: case AAT_FLOAT:
val._type = OT_FLOAT; val._type = OT_FLOAT;
val._unVal.fFloat = *((const SQFloat *)&arg1); val._unVal.fFloat = *((const float_t *)&arg1);
break; break;
case AAT_BOOL: case AAT_BOOL:
val._type = OT_BOOL; val._type = OT_BOOL;
@ -935,7 +935,7 @@ exception_restore:
_array(STK(arg0))->Append(val); continue; _array(STK(arg0))->Append(val); continue;
} }
case _OP_COMPARITH: { case _OP_COMPARITH: {
SQInteger selfidx = (((SQUnsignedInteger)arg1&0xFFFF0000)>>16); int64_t selfidx = (((uint64_t)arg1&0xFFFF0000)>>16);
_GUARD(DerefInc(arg3, TARGET, STK(selfidx), STK(arg2), STK(arg1&0x0000FFFF), false, selfidx)); _GUARD(DerefInc(arg3, TARGET, STK(selfidx), STK(arg2), STK(arg1&0x0000FFFF), false, selfidx));
} }
continue; continue;
@ -985,8 +985,8 @@ exception_restore:
case _OP_NOT: TARGET = IsFalse(STK(arg1)); continue; case _OP_NOT: TARGET = IsFalse(STK(arg1)); continue;
case _OP_BWNOT: case _OP_BWNOT:
if(sq_type(STK(arg1)) == OT_INTEGER) { if(sq_type(STK(arg1)) == OT_INTEGER) {
SQInteger t = _integer(STK(arg1)); int64_t t = _integer(STK(arg1));
TARGET = SQInteger(~t); TARGET = int64_t(~t);
continue; continue;
} }
Raise_Error(_SC("attempt to perform a bitwise op on a %s"), GetTypeName(STK(arg1))); Raise_Error(_SC("attempt to perform a bitwise op on a %s"), GetTypeName(STK(arg1)));
@ -1036,7 +1036,7 @@ exception_restore:
} }
continue; continue;
case _OP_POPTRAP: { case _OP_POPTRAP: {
for(SQInteger i = 0; i < arg0; i++) { for(int64_t i = 0; i < arg0; i++) {
_etraps.pop_back(); traps--; _etraps.pop_back(); traps--;
ci->_etraps--; ci->_etraps--;
} }
@ -1067,8 +1067,8 @@ exception_trap:
{ {
SQObjectPtr currerror = _lasterror; SQObjectPtr currerror = _lasterror;
// dumpstack(_stackbase); // dumpstack(_stackbase);
// SQInteger n = 0; // int64_t n = 0;
SQInteger last_top = _top; int64_t last_top = _top;
if(_ss(this)->_notifyallexceptions || (!traps && raiseerror)) CallErrorHandler(currerror); if(_ss(this)->_notifyallexceptions || (!traps && raiseerror)) CallErrorHandler(currerror);
@ -1086,7 +1086,7 @@ exception_trap:
else if (_debughook) { else if (_debughook) {
//notify debugger of a "return" //notify debugger of a "return"
//even if it really an exception unwinding the stack //even if it really an exception unwinding the stack
for(SQInteger i = 0; i < ci->_ncalls; i++) { for(int64_t i = 0; i < ci->_ncalls; i++) {
CallDebugHook(_SC('r')); CallDebugHook(_SC('r'));
} }
} }
@ -1122,19 +1122,19 @@ void SQVM::CallErrorHandler(SQObjectPtr &error)
} }
void SQVM::CallDebugHook(SQInteger type,SQInteger forcedline) void SQVM::CallDebugHook(int64_t type,int64_t forcedline)
{ {
_debughook = false; _debughook = false;
SQFunctionProto *func=_closure(ci->_closure)->_function; SQFunctionProto *func=_closure(ci->_closure)->_function;
if(_debughook_native) { if(_debughook_native) {
const SQChar *src = sq_type(func->_sourcename) == OT_STRING?_stringval(func->_sourcename):NULL; const SQChar *src = sq_type(func->_sourcename) == OT_STRING?_stringval(func->_sourcename):NULL;
const SQChar *fname = sq_type(func->_name) == OT_STRING?_stringval(func->_name):NULL; const SQChar *fname = sq_type(func->_name) == OT_STRING?_stringval(func->_name):NULL;
SQInteger line = forcedline?forcedline:func->GetLine(ci->_ip); int64_t line = forcedline?forcedline:func->GetLine(ci->_ip);
_debughook_native(this,type,src,line,fname); _debughook_native(this,type,src,line,fname);
} }
else { else {
SQObjectPtr temp_reg; SQObjectPtr temp_reg;
SQInteger nparams=5; int64_t nparams=5;
Push(_roottable); Push(type); Push(func->_sourcename); Push(forcedline?forcedline:func->GetLine(ci->_ip)); Push(func->_name); Push(_roottable); Push(type); Push(func->_sourcename); Push(forcedline?forcedline:func->GetLine(ci->_ip)); Push(func->_name);
Call(_debughook_closure,nparams,_top-nparams,temp_reg,SQFalse); Call(_debughook_closure,nparams,_top-nparams,temp_reg,SQFalse);
Pop(nparams); Pop(nparams);
@ -1142,10 +1142,10 @@ void SQVM::CallDebugHook(SQInteger type,SQInteger forcedline)
_debughook = true; _debughook = true;
} }
bool SQVM::CallNative(SQNativeClosure *nclosure, SQInteger nargs, SQInteger newbase, SQObjectPtr &retval, SQInt32 target,bool &suspend, bool &tailcall) bool SQVM::CallNative(SQNativeClosure *nclosure, int64_t nargs, int64_t newbase, SQObjectPtr &retval, int32_t target,bool &suspend, bool &tailcall)
{ {
SQInteger nparamscheck = nclosure->_nparamscheck; int64_t nparamscheck = nclosure->_nparamscheck;
SQInteger newtop = newbase + nargs + nclosure->_noutervalues; int64_t newtop = newbase + nargs + nclosure->_noutervalues;
if (_nnativecalls + 1 > MAX_NATIVE_CALLS) { if (_nnativecalls + 1 > MAX_NATIVE_CALLS) {
Raise_Error(_SC("Native stack overflow")); Raise_Error(_SC("Native stack overflow"));
@ -1159,10 +1159,10 @@ bool SQVM::CallNative(SQNativeClosure *nclosure, SQInteger nargs, SQInteger newb
return false; return false;
} }
SQInteger tcs; int64_t tcs;
SQIntVec &tc = nclosure->_typecheck; SQIntVec &tc = nclosure->_typecheck;
if((tcs = tc.size())) { if((tcs = tc.size())) {
for(SQInteger i = 0; i < nargs && i < tcs; i++) { for(int64_t i = 0; i < nargs && i < tcs; i++) {
if((tc._vals[i] != -1) && !(sq_type(_stack._vals[newbase+i]) & tc._vals[i])) { if((tc._vals[i] != -1) && !(sq_type(_stack._vals[newbase+i]) & tc._vals[i])) {
Raise_ParamTypeError(i,tc._vals[i], sq_type(_stack._vals[newbase+i])); Raise_ParamTypeError(i,tc._vals[i], sq_type(_stack._vals[newbase+i]));
return false; return false;
@ -1174,8 +1174,8 @@ bool SQVM::CallNative(SQNativeClosure *nclosure, SQInteger nargs, SQInteger newb
ci->_closure = nclosure; ci->_closure = nclosure;
ci->_target = target; ci->_target = target;
SQInteger outers = nclosure->_noutervalues; int64_t outers = nclosure->_noutervalues;
for (SQInteger i = 0; i < outers; i++) { for (int64_t i = 0; i < outers; i++) {
_stack._vals[newbase+nargs+i] = nclosure->_outervalues[i]; _stack._vals[newbase+nargs+i] = nclosure->_outervalues[i];
} }
if(nclosure->_env) { if(nclosure->_env) {
@ -1183,7 +1183,7 @@ bool SQVM::CallNative(SQNativeClosure *nclosure, SQInteger nargs, SQInteger newb
} }
_nnativecalls++; _nnativecalls++;
SQInteger ret = (nclosure->_function)(this); int64_t ret = (nclosure->_function)(this);
_nnativecalls--; _nnativecalls--;
suspend = false; suspend = false;
@ -1211,16 +1211,16 @@ bool SQVM::CallNative(SQNativeClosure *nclosure, SQInteger nargs, SQInteger newb
return true; return true;
} }
bool SQVM::TailCall(SQClosure *closure, SQInteger parambase,SQInteger nparams) bool SQVM::TailCall(SQClosure *closure, int64_t parambase,int64_t nparams)
{ {
SQInteger last_top = _top; int64_t last_top = _top;
SQObjectPtr clo = closure; SQObjectPtr clo = closure;
if (ci->_root) if (ci->_root)
{ {
Raise_Error("root calls cannot invoke tailcalls"); Raise_Error("root calls cannot invoke tailcalls");
return false; return false;
} }
for (SQInteger i = 0; i < nparams; i++) STK(i) = STK(parambase + i); for (int64_t i = 0; i < nparams; i++) STK(i) = STK(parambase + i);
bool ret = StartCall(closure, ci->_target, nparams, _stackbase, true); bool ret = StartCall(closure, ci->_target, nparams, _stackbase, true);
if (last_top >= _top) { if (last_top >= _top) {
_top = last_top; _top = last_top;
@ -1232,7 +1232,7 @@ bool SQVM::TailCall(SQClosure *closure, SQInteger parambase,SQInteger nparams)
#define FALLBACK_NO_MATCH 1 #define FALLBACK_NO_MATCH 1
#define FALLBACK_ERROR 2 #define FALLBACK_ERROR 2
bool SQVM::Get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &dest, SQUnsignedInteger getflags, SQInteger selfidx) bool SQVM::Get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &dest, uint64_t getflags, int64_t selfidx)
{ {
switch(sq_type(self)){ switch(sq_type(self)){
case OT_TABLE: case OT_TABLE:
@ -1249,11 +1249,11 @@ bool SQVM::Get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &des
break; break;
case OT_STRING: case OT_STRING:
if(sq_isnumeric(key)){ if(sq_isnumeric(key)){
SQInteger n = tointeger(key); int64_t n = tointeger(key);
SQInteger len = _string(self)->_len; int64_t len = _string(self)->_len;
if (n < 0) { n += len; } if (n < 0) { n += len; }
if (n >= 0 && n < len) { if (n >= 0 && n < len) {
dest = SQInteger(_stringval(self)[n]); dest = int64_t(_stringval(self)[n]);
return true; return true;
} }
if ((getflags & GET_FLAG_DO_NOT_RAISE_ERROR) == 0) Raise_IdxError(key); if ((getflags & GET_FLAG_DO_NOT_RAISE_ERROR) == 0) Raise_IdxError(key);
@ -1306,7 +1306,7 @@ bool SQVM::InvokeDefaultDelegate(const SQObjectPtr &self,const SQObjectPtr &key,
} }
SQInteger SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest) int64_t SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest)
{ {
switch(sq_type(self)){ switch(sq_type(self)){
case OT_TABLE: case OT_TABLE:
@ -1344,7 +1344,7 @@ SQInteger SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObj
return FALLBACK_NO_MATCH; return FALLBACK_NO_MATCH;
} }
bool SQVM::Set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,SQInteger selfidx) bool SQVM::Set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,int64_t selfidx)
{ {
switch(sq_type(self)){ switch(sq_type(self)){
case OT_TABLE: case OT_TABLE:
@ -1379,7 +1379,7 @@ bool SQVM::Set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr
return false; return false;
} }
SQInteger SQVM::FallBackSet(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val) int64_t SQVM::FallBackSet(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val)
{ {
switch(sq_type(self)) { switch(sq_type(self)) {
case OT_TABLE: case OT_TABLE:
@ -1567,10 +1567,10 @@ bool SQVM::DeleteSlot(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr
return true; return true;
} }
bool SQVM::Call(SQObjectPtr &closure,SQInteger nparams,SQInteger stackbase,SQObjectPtr &outres,SQBool raiseerror) bool SQVM::Call(SQObjectPtr &closure,int64_t nparams,int64_t stackbase,SQObjectPtr &outres,SQBool raiseerror)
{ {
#ifdef _DEBUG #ifdef _DEBUG
SQInteger prevstackbase = _stackbase; int64_t prevstackbase = _stackbase;
#endif #endif
switch(sq_type(closure)) { switch(sq_type(closure)) {
case OT_CLOSURE: case OT_CLOSURE:
@ -1605,7 +1605,7 @@ SQInteger prevstackbase = _stackbase;
return true; return true;
} }
bool SQVM::CallMetaMethod(SQObjectPtr &closure,SQMetaMethod SQ_UNUSED_ARG(mm),SQInteger nparams,SQObjectPtr &outres) bool SQVM::CallMetaMethod(SQObjectPtr &closure,SQMetaMethod SQ_UNUSED_ARG(mm),int64_t nparams,SQObjectPtr &outres)
{ {
//SQObjectPtr closure; //SQObjectPtr closure;
@ -1642,15 +1642,15 @@ void SQVM::FindOuter(SQObjectPtr &target, SQObjectPtr *stackindex)
target = SQObjectPtr(otr); target = SQObjectPtr(otr);
} }
bool SQVM::EnterFrame(SQInteger newbase, SQInteger newtop, bool tailcall) bool SQVM::EnterFrame(int64_t newbase, int64_t newtop, bool tailcall)
{ {
if( !tailcall ) { if( !tailcall ) {
if( _callsstacksize == _alloccallsstacksize ) { if( _callsstacksize == _alloccallsstacksize ) {
GrowCallStack(); GrowCallStack();
} }
ci = &_callsstack[_callsstacksize++]; ci = &_callsstack[_callsstacksize++];
ci->_prevstkbase = (SQInt32)(newbase - _stackbase); ci->_prevstkbase = (int32_t)(newbase - _stackbase);
ci->_prevtop = (SQInt32)(_top - _stackbase); ci->_prevtop = (int32_t)(_top - _stackbase);
ci->_etraps = 0; ci->_etraps = 0;
ci->_ncalls = 1; ci->_ncalls = 1;
ci->_generator = NULL; ci->_generator = NULL;
@ -1662,7 +1662,7 @@ bool SQVM::EnterFrame(SQInteger newbase, SQInteger newtop, bool tailcall)
_stackbase = newbase; _stackbase = newbase;
_top = newtop; _top = newtop;
if(newtop + MIN_STACK_OVERHEAD > (SQInteger)_stack.size()) { if(newtop + MIN_STACK_OVERHEAD > (int64_t)_stack.size()) {
if(_nmetamethodscall) { if(_nmetamethodscall) {
Raise_Error(_SC("stack overflow, cannot resize stack while in a metamethod")); Raise_Error(_SC("stack overflow, cannot resize stack while in a metamethod"));
return false; return false;
@ -1674,9 +1674,9 @@ bool SQVM::EnterFrame(SQInteger newbase, SQInteger newtop, bool tailcall)
} }
void SQVM::LeaveFrame() { void SQVM::LeaveFrame() {
SQInteger last_top = _top; int64_t last_top = _top;
SQInteger last_stackbase = _stackbase; int64_t last_stackbase = _stackbase;
SQInteger css = --_callsstacksize; int64_t css = --_callsstacksize;
/* First clean out the call stack frame */ /* First clean out the call stack frame */
ci->_closure.Null(); ci->_closure.Null();
@ -1709,9 +1709,9 @@ void SQVM::CloseOuters(SQObjectPtr *stackindex) {
} }
} }
void SQVM::Remove(SQInteger n) { void SQVM::Remove(int64_t n) {
n = (n >= 0)?n + _stackbase - 1:_top + n; n = (n >= 0)?n + _stackbase - 1:_top + n;
for(SQInteger i = n; i < _top; i++){ for(int64_t i = n; i < _top; i++){
_stack[i] = _stack[i+1]; _stack[i] = _stack[i+1];
} }
_stack[_top].Null(); _stack[_top].Null();
@ -1722,8 +1722,8 @@ void SQVM::Pop() {
_stack[--_top].Null(); _stack[--_top].Null();
} }
void SQVM::Pop(SQInteger n) { void SQVM::Pop(int64_t n) {
for(SQInteger i = 0; i < n; i++){ for(int64_t i = 0; i < n; i++){
_stack[--_top].Null(); _stack[--_top].Null();
} }
} }
@ -1732,20 +1732,20 @@ void SQVM::PushNull() { _stack[_top++].Null(); }
void SQVM::Push(const SQObjectPtr &o) { _stack[_top++] = o; } void SQVM::Push(const SQObjectPtr &o) { _stack[_top++] = o; }
SQObjectPtr &SQVM::Top() { return _stack[_top-1]; } SQObjectPtr &SQVM::Top() { return _stack[_top-1]; }
SQObjectPtr &SQVM::PopGet() { return _stack[--_top]; } SQObjectPtr &SQVM::PopGet() { return _stack[--_top]; }
SQObjectPtr &SQVM::GetUp(SQInteger n) { return _stack[_top+n]; } SQObjectPtr &SQVM::GetUp(int64_t n) { return _stack[_top+n]; }
SQObjectPtr &SQVM::GetAt(SQInteger n) { return _stack[n]; } SQObjectPtr &SQVM::GetAt(int64_t n) { return _stack[n]; }
#ifdef _DEBUG_DUMP #ifdef _DEBUG_DUMP
void SQVM::dumpstack(SQInteger stackbase,bool dumpall) void SQVM::dumpstack(int64_t stackbase,bool dumpall)
{ {
SQInteger size=dumpall?_stack.size():_top; int64_t size=dumpall?_stack.size():_top;
SQInteger n=0; int64_t n=0;
scprintf(_SC("\n>>>>stack dump<<<<\n")); scprintf(_SC("\n>>>>stack dump<<<<\n"));
CallInfo &ci=_callsstack[_callsstacksize-1]; CallInfo &ci=_callsstack[_callsstacksize-1];
scprintf(_SC("IP: %p\n"),ci._ip); scprintf(_SC("IP: %p\n"),ci._ip);
scprintf(_SC("prev stack base: %d\n"),ci._prevstkbase); scprintf(_SC("prev stack base: %d\n"),ci._prevstkbase);
scprintf(_SC("prev top: %d\n"),ci._prevtop); scprintf(_SC("prev top: %d\n"),ci._prevtop);
for(SQInteger i=0;i<size;i++){ for(int64_t i=0;i<size;i++){
SQObjectPtr &obj=_stack[i]; SQObjectPtr &obj=_stack[i];
if(stackbase==i)scprintf(_SC(">"));else scprintf(_SC(" ")); if(stackbase==i)scprintf(_SC(">"));else scprintf(_SC(" "));
scprintf(_SC("[" _PRINT_INT_FMT "]:"),n); scprintf(_SC("[" _PRINT_INT_FMT "]:"),n);

108
rabbit/sqvm.hpp
View File

@ -25,12 +25,12 @@ void sq_base_register(HRABBITVM v);
struct SQExceptionTrap{ struct SQExceptionTrap{
SQExceptionTrap() {} SQExceptionTrap() {}
SQExceptionTrap(SQInteger ss, SQInteger stackbase,SQInstruction *ip, SQInteger ex_target){ _stacksize = ss; _stackbase = stackbase; _ip = ip; _extarget = ex_target;} SQExceptionTrap(int64_t ss, int64_t stackbase,SQInstruction *ip, int64_t ex_target){ _stacksize = ss; _stackbase = stackbase; _ip = ip; _extarget = ex_target;}
SQExceptionTrap(const SQExceptionTrap &et) { (*this) = et; } SQExceptionTrap(const SQExceptionTrap &et) { (*this) = et; }
SQInteger _stackbase; int64_t _stackbase;
SQInteger _stacksize; int64_t _stacksize;
SQInstruction *_ip; SQInstruction *_ip;
SQInteger _extarget; int64_t _extarget;
}; };
#define _INLINE #define _INLINE
@ -45,45 +45,45 @@ struct SQVM : public SQRefCounted
SQObjectPtr *_literals; SQObjectPtr *_literals;
SQObjectPtr _closure; SQObjectPtr _closure;
SQGenerator *_generator; SQGenerator *_generator;
SQInt32 _etraps; int32_t _etraps;
SQInt32 _prevstkbase; int32_t _prevstkbase;
SQInt32 _prevtop; int32_t _prevtop;
SQInt32 _target; int32_t _target;
SQInt32 _ncalls; int32_t _ncalls;
SQBool _root; SQBool _root;
}; };
typedef sqvector<CallInfo> CallInfoVec; typedef sqvector<CallInfo> CallInfoVec;
public: public:
void DebugHookProxy(SQInteger type, const SQChar * sourcename, SQInteger line, const SQChar * funcname); void DebugHookProxy(int64_t type, const SQChar * sourcename, int64_t line, const SQChar * funcname);
static void _DebugHookProxy(HRABBITVM v, SQInteger type, const SQChar * sourcename, SQInteger line, const SQChar * funcname); static void _DebugHookProxy(HRABBITVM v, int64_t type, const SQChar * sourcename, int64_t 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();
bool Init(SQVM *friendvm, SQInteger stacksize); bool Init(SQVM *friendvm, int64_t stacksize);
bool Execute(SQObjectPtr &func, SQInteger nargs, SQInteger stackbase, SQObjectPtr &outres, SQBool raiseerror, ExecutionType et = ET_CALL); bool Execute(SQObjectPtr &func, int64_t nargs, int64_t stackbase, SQObjectPtr &outres, SQBool raiseerror, ExecutionType et = ET_CALL);
//starts a native call return when the NATIVE closure returns //starts a native call return when the NATIVE closure returns
bool CallNative(SQNativeClosure *nclosure, SQInteger nargs, SQInteger newbase, SQObjectPtr &retval, SQInt32 target, bool &suspend,bool &tailcall); bool CallNative(SQNativeClosure *nclosure, int64_t nargs, int64_t newbase, SQObjectPtr &retval, int32_t target, bool &suspend,bool &tailcall);
bool TailCall(SQClosure *closure, SQInteger firstparam, SQInteger nparams); bool TailCall(SQClosure *closure, int64_t firstparam, int64_t nparams);
//starts a RABBIT call in the same "Execution loop" //starts a RABBIT call in the same "Execution loop"
bool StartCall(SQClosure *closure, SQInteger target, SQInteger nargs, SQInteger stackbase, bool tailcall); bool StartCall(SQClosure *closure, int64_t target, int64_t nargs, int64_t stackbase, bool tailcall);
bool CreateClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor); bool CreateClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor);
//call a generic closure pure RABBIT 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, int64_t nparams, int64_t stackbase, SQObjectPtr &outres,SQBool raiseerror);
SQRESULT Suspend(); SQRESULT Suspend();
void CallDebugHook(SQInteger type,SQInteger forcedline=0); void CallDebugHook(int64_t type,int64_t forcedline=0);
void CallErrorHandler(SQObjectPtr &e); void CallErrorHandler(SQObjectPtr &e);
bool Get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &dest, SQUnsignedInteger getflags, SQInteger selfidx); bool Get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &dest, uint64_t getflags, int64_t selfidx);
SQInteger FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest); int64_t FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest);
bool InvokeDefaultDelegate(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest); bool InvokeDefaultDelegate(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest);
bool Set(const SQObjectPtr &self, const SQObjectPtr &key, const SQObjectPtr &val, SQInteger selfidx); bool Set(const SQObjectPtr &self, const SQObjectPtr &key, const SQObjectPtr &val, int64_t selfidx);
SQInteger FallBackSet(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val); int64_t FallBackSet(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val);
bool NewSlot(const SQObjectPtr &self, const SQObjectPtr &key, const SQObjectPtr &val,bool bstatic); bool NewSlot(const SQObjectPtr &self, const SQObjectPtr &key, const SQObjectPtr &val,bool bstatic);
bool NewSlotA(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,const SQObjectPtr &attrs,bool bstatic,bool raw); bool NewSlotA(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr &val,const SQObjectPtr &attrs,bool bstatic,bool raw);
bool DeleteSlot(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &res); bool DeleteSlot(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &res);
bool Clone(const SQObjectPtr &self, SQObjectPtr &target); bool Clone(const SQObjectPtr &self, SQObjectPtr &target);
bool ObjCmp(const SQObjectPtr &o1, const SQObjectPtr &o2,SQInteger &res); bool ObjCmp(const SQObjectPtr &o1, const SQObjectPtr &o2,int64_t &res);
bool StringCat(const SQObjectPtr &str, const SQObjectPtr &obj, SQObjectPtr &dest); bool StringCat(const SQObjectPtr &str, const SQObjectPtr &obj, SQObjectPtr &dest);
static bool IsEqual(const SQObjectPtr &o1,const SQObjectPtr &o2,bool &res); static bool IsEqual(const SQObjectPtr &o1,const SQObjectPtr &o2,bool &res);
bool ToString(const SQObjectPtr &o,SQObjectPtr &res); bool ToString(const SQObjectPtr &o,SQObjectPtr &res);
@ -94,61 +94,61 @@ public:
void Raise_Error(const SQObjectPtr &desc); void Raise_Error(const SQObjectPtr &desc);
void Raise_IdxError(const SQObjectPtr &o); void Raise_IdxError(const SQObjectPtr &o);
void Raise_CompareError(const SQObject &o1, const SQObject &o2); void Raise_CompareError(const SQObject &o1, const SQObject &o2);
void Raise_ParamTypeError(SQInteger nparam,SQInteger typemask,SQInteger type); void Raise_ParamTypeError(int64_t nparam,int64_t typemask,int64_t type);
void FindOuter(SQObjectPtr &target, SQObjectPtr *stackindex); void FindOuter(SQObjectPtr &target, SQObjectPtr *stackindex);
void RelocateOuters(); void RelocateOuters();
void CloseOuters(SQObjectPtr *stackindex); void CloseOuters(SQObjectPtr *stackindex);
bool TypeOf(const SQObjectPtr &obj1, SQObjectPtr &dest); bool TypeOf(const SQObjectPtr &obj1, SQObjectPtr &dest);
bool CallMetaMethod(SQObjectPtr &closure, SQMetaMethod mm, SQInteger nparams, SQObjectPtr &outres); bool CallMetaMethod(SQObjectPtr &closure, SQMetaMethod mm, int64_t nparams, SQObjectPtr &outres);
bool ArithMetaMethod(SQInteger op, const SQObjectPtr &o1, const SQObjectPtr &o2, SQObjectPtr &dest); bool ArithMetaMethod(int64_t op, const SQObjectPtr &o1, const SQObjectPtr &o2, SQObjectPtr &dest);
bool Return(SQInteger _arg0, SQInteger _arg1, SQObjectPtr &retval); bool Return(int64_t _arg0, int64_t _arg1, SQObjectPtr &retval);
//new stuff //new stuff
bool ARITH_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2); bool ARITH_OP(uint64_t op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2);
bool BW_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2); bool BW_OP(uint64_t op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2);
bool NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o1); bool NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o1);
bool CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res); bool CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res);
bool CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func); bool CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func);
bool CLASS_OP(SQObjectPtr &target,SQInteger base,SQInteger attrs); bool CLASS_OP(SQObjectPtr &target,int64_t base,int64_t attrs);
//return true if the loop is finished //return true if the loop is finished
bool FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr &o3,SQObjectPtr &o4,SQInteger arg_2,int exitpos,int &jump); bool FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr &o3,SQObjectPtr &o4,int64_t arg_2,int exitpos,int &jump);
//bool LOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr); //bool LOCAL_INC(int64_t op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr);
bool PLOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr); bool PLOCAL_INC(int64_t op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr);
bool DerefInc(SQInteger op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix,SQInteger arg0); bool DerefInc(int64_t op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix,int64_t arg0);
#ifdef _DEBUG_DUMP #ifdef _DEBUG_DUMP
void dumpstack(SQInteger stackbase=-1, bool dumpall = false); void dumpstack(int64_t stackbase=-1, bool dumpall = false);
#endif #endif
void Finalize(); void Finalize();
void GrowCallStack() { void GrowCallStack() {
SQInteger newsize = _alloccallsstacksize*2; int64_t newsize = _alloccallsstacksize*2;
_callstackdata.resize(newsize); _callstackdata.resize(newsize);
_callsstack = &_callstackdata[0]; _callsstack = &_callstackdata[0];
_alloccallsstacksize = newsize; _alloccallsstacksize = newsize;
} }
bool EnterFrame(SQInteger newbase, SQInteger newtop, bool tailcall); bool EnterFrame(int64_t newbase, int64_t newtop, bool tailcall);
void LeaveFrame(); void LeaveFrame();
void Release(){ sq_delete(this,SQVM); } void Release(){ sq_delete(this,SQVM); }
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
//stack functions for the api //stack functions for the api
void Remove(SQInteger n); void Remove(int64_t n);
static bool IsFalse(SQObjectPtr &o); static bool IsFalse(SQObjectPtr &o);
void Pop(); void Pop();
void Pop(SQInteger n); void Pop(int64_t n);
void Push(const SQObjectPtr &o); void Push(const SQObjectPtr &o);
void PushNull(); void PushNull();
SQObjectPtr &Top(); SQObjectPtr &Top();
SQObjectPtr &PopGet(); SQObjectPtr &PopGet();
SQObjectPtr &GetUp(SQInteger n); SQObjectPtr &GetUp(int64_t n);
SQObjectPtr &GetAt(SQInteger n); SQObjectPtr &GetAt(int64_t n);
SQObjectPtrVec _stack; SQObjectPtrVec _stack;
SQInteger _top; int64_t _top;
SQInteger _stackbase; int64_t _stackbase;
SQOuter *_openouters; SQOuter *_openouters;
SQObjectPtr _roottable; SQObjectPtr _roottable;
SQObjectPtr _lasterror; SQObjectPtr _lasterror;
@ -162,8 +162,8 @@ public:
CallInfo* _callsstack; CallInfo* _callsstack;
SQInteger _callsstacksize; int64_t _callsstacksize;
SQInteger _alloccallsstacksize; int64_t _alloccallsstacksize;
sqvector<CallInfo> _callstackdata; sqvector<CallInfo> _callstackdata;
ExceptionsTraps _etraps; ExceptionsTraps _etraps;
@ -171,28 +171,28 @@ public:
SQUserPointer _foreignptr; SQUserPointer _foreignptr;
//VMs sharing the same state //VMs sharing the same state
SQSharedState *_sharedstate; SQSharedState *_sharedstate;
SQInteger _nnativecalls; int64_t _nnativecalls;
SQInteger _nmetamethodscall; int64_t _nmetamethodscall;
SQRELEASEHOOK _releasehook; SQRELEASEHOOK _releasehook;
//suspend infos //suspend infos
SQBool _suspended; SQBool _suspended;
SQBool _suspended_root; SQBool _suspended_root;
SQInteger _suspended_target; int64_t _suspended_target;
SQInteger _suspended_traps; int64_t _suspended_traps;
}; };
struct AutoDec{ struct AutoDec{
AutoDec(SQInteger *n) { _n = n; } AutoDec(int64_t *n) { _n = n; }
~AutoDec() { (*_n)--; } ~AutoDec() { (*_n)--; }
SQInteger *_n; int64_t *_n;
}; };
inline SQObjectPtr &stack_get(HRABBITVM v,SQInteger idx){return ((idx>=0)?(v->GetAt(idx+v->_stackbase-1)):(v->GetUp(idx)));} inline SQObjectPtr &stack_get(HRABBITVM v,int64_t idx){return ((idx>=0)?(v->GetAt(idx+v->_stackbase-1)):(v->GetUp(idx)));}
#define _ss(_vm_) (_vm_)->_sharedstate #define _ss(_vm_) (_vm_)->_sharedstate
#define PUSH_CALLINFO(v,nci){ \ #define PUSH_CALLINFO(v,nci){ \
SQInteger css = v->_callsstacksize; \ int64_t css = v->_callsstacksize; \
if(css == v->_alloccallsstacksize) { \ if(css == v->_alloccallsstacksize) { \
v->GrowCallStack(); \ v->GrowCallStack(); \
} \ } \
@ -202,7 +202,7 @@ inline SQObjectPtr &stack_get(HRABBITVM v,SQInteger idx){return ((idx>=0)?(v->Ge
} }
#define POP_CALLINFO(v){ \ #define POP_CALLINFO(v){ \
SQInteger css = --v->_callsstacksize; \ int64_t css = --v->_callsstacksize; \
v->ci->_closure.Null(); \ v->ci->_closure.Null(); \
v->ci = css?&v->_callsstack[css-1]:NULL; \ v->ci = css?&v->_callsstack[css-1]:NULL; \
} }