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
SQInteger quit(HRABBITVM v)
int64_t quit(HRABBITVM v)
{
int *done;
sq_getuserpointer(v,-1,(SQUserPointer*)&done);
@ -74,7 +74,7 @@ void errorfunc(HRABBITVM SQ_UNUSED_ARG(v),const SQChar *s,...)
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()
@ -93,7 +93,7 @@ void PrintUsage()
#define _DONE 2
#define _ERROR 3
//<<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 compiles_only = 0;
@ -236,10 +236,10 @@ void Interactive(HRABBITVM v)
#define MAXINPUT 1024
SQChar buffer[MAXINPUT];
SQInteger blocks =0;
SQInteger string=0;
SQInteger retval=0;
SQInteger done=0;
int64_t blocks =0;
int64_t string=0;
int64_t retval=0;
int64_t done=0;
PrintVersionInfos();
sq_pushroottable(v);
@ -252,7 +252,7 @@ void Interactive(HRABBITVM v)
while (!done)
{
SQInteger i = 0;
int64_t i = 0;
scprintf(_SC("\nrabbit> "));
for(;;) {
int c;
@ -292,7 +292,7 @@ void Interactive(HRABBITVM v)
}
i=scstrlen(buffer);
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))){
sq_pushroottable(v);
if(SQ_SUCCEEDED(sq_call(v,1,retval,SQTrue)) && retval){
@ -316,7 +316,7 @@ void Interactive(HRABBITVM v)
int main(int argc, char* argv[])
{
HRABBITVM v;
SQInteger retval = 0;
int64_t retval = 0;
#if defined(_MSC_VER) && defined(_DEBUG)
_CrtSetAllocHook(MemAllocHook);
#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)
{
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_pushstring(v,_SC("foo"),-1);
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([
'z',
'm',
'c'
'c',
'etk-base',
])
my_module.add_header_file([
'rabbit/sqclass.hpp',

12
rabbit-std/sqstdaux.cpp
View File

@ -15,12 +15,12 @@ void sqstd_printcallstack(HRABBITVM v)
SQPRINTFUNCTION pf = sq_geterrorfunc(v);
if(pf) {
SQStackInfos si;
SQInteger i;
SQFloat f;
int64_t i;
float_t f;
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;
SQInteger seq=0;
int64_t seq=0;
pf(v,_SC("\nCALLSTACK\n"));
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);
if(pf) {
@ -121,7 +121,7 @@ static SQInteger _sqstd_aux_printerror(HRABBITVM v)
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);
if(pf) {

76
rabbit-std/sqstdblob.cpp
View File

@ -7,7 +7,7 @@
#include <rabbit-std/sqstdstream.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
@ -20,10 +20,10 @@
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);
SQInteger size;
int64_t size;
sq_getinteger(v,2,&size);
if(!self->Resize(size))
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);
}
static SQInteger _blob_swap4(HRABBITVM v)
static int64_t _blob_swap4(HRABBITVM 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();
for(SQInteger i = 0; i < num; i++) {
for(int64_t i = 0; i < num; i++) {
__swap_dword(&t[i]);
}
return 0;
}
static SQInteger _blob_swap2(HRABBITVM v)
static int64_t _blob_swap2(HRABBITVM 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();
for(SQInteger i = 0; i < num; i++) {
for(int64_t i = 0; i < num; i++) {
__swap_word(&t[i]);
}
return 0;
}
static SQInteger _blob__set(HRABBITVM v)
static int64_t _blob__set(HRABBITVM v)
{
SETUP_BLOB(v);
SQInteger idx,val;
int64_t idx,val;
sq_getinteger(v,2,&idx);
sq_getinteger(v,3,&val);
if(idx < 0 || idx >= self->Len())
@ -78,10 +78,10 @@ static SQInteger _blob__set(HRABBITVM v)
return 1;
}
static SQInteger _blob__get(HRABBITVM v)
static int64_t _blob__get(HRABBITVM v)
{
SETUP_BLOB(v);
SQInteger idx;
int64_t idx;
if ((sq_gettype(v, 2) & SQOBJECT_NUMERIC) == 0)
{
@ -95,14 +95,14 @@ static SQInteger _blob__get(HRABBITVM v)
return 1;
}
static SQInteger _blob__nexti(HRABBITVM v)
static int64_t _blob__nexti(HRABBITVM v)
{
SETUP_BLOB(v);
if(sq_gettype(v,2) == OT_NULL) {
sq_pushinteger(v, 0);
return 1;
}
SQInteger idx;
int64_t idx;
if(SQ_SUCCEEDED(sq_getinteger(v, 2, &idx))) {
if(idx+1 < self->Len()) {
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"));
}
static SQInteger _blob__typeof(HRABBITVM v)
static int64_t _blob__typeof(HRABBITVM v)
{
sq_pushstring(v,_SC("blob"),-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;
self->~SQBlob();
@ -128,10 +128,10 @@ static SQInteger _blob_releasehook(SQUserPointer p, SQInteger SQ_UNUSED_ARG(size
return 1;
}
static SQInteger _blob_constructor(HRABBITVM v)
static int64_t _blob_constructor(HRABBITVM v)
{
SQInteger nparam = sq_gettop(v);
SQInteger size = 0;
int64_t nparam = sq_gettop(v);
int64_t size = 0;
if(nparam == 2) {
sq_getinteger(v, 2, &size);
}
@ -148,7 +148,7 @@ static SQInteger _blob_constructor(HRABBITVM v)
return 0;
}
static SQInteger _blob__cloned(HRABBITVM v)
static int64_t _blob__cloned(HRABBITVM v)
{
SQBlob *other = NULL;
{
@ -185,44 +185,44 @@ static const SQRegFunction _blob_methods[] = {
//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_pushfloat(v,*((const SQFloat *)&i));
sq_pushfloat(v,*((const float_t *)&i));
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_pushinteger(v,*((const SQInteger *)&f));
sq_pushinteger(v,*((const int64_t *)&f));
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);
short s=(short)i;
sq_pushinteger(v,(s<<8)|((s>>8)&0x00FF));
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);
unsigned int t4 = (unsigned int)i;
__swap_dword(&t4);
sq_pushinteger(v,(SQInteger)t4);
sq_pushinteger(v,(int64_t)t4);
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);
__swap_dword((unsigned int *)&f);
sq_pushfloat(v,f);
@ -239,7 +239,7 @@ static const SQRegFunction bloblib_funcs[]={
{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;
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;
}
SQInteger sqstd_getblobsize(HRABBITVM v,SQInteger idx)
int64_t sqstd_getblobsize(HRABBITVM v,int64_t idx)
{
SQBlob *blob;
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();
}
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_pushstring(v,_SC("std_blob"),-1);
if(SQ_SUCCEEDED(sq_get(v,-2))) {

6
rabbit-std/sqstdblob.hpp
View File

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

28
rabbit-std/sqstdblobimpl.hpp
View File

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

104
rabbit-std/sqstdio.cpp
View File

@ -12,7 +12,7 @@
#include <rabbit-std/sqstdio.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
SQFILE sqstd_fopen(const SQChar *filename ,const SQChar *mode)
{
@ -23,20 +23,20 @@ SQFILE sqstd_fopen(const SQChar *filename ,const SQChar *mode)
#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;
}
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) {
case SQ_SEEK_CUR: realorigin = SEEK_CUR; 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);
}
SQInteger sqstd_ftell(SQFILE file)
int64_t sqstd_ftell(SQFILE file)
{
return ftell((FILE *)file);
}
SQInteger sqstd_fflush(SQFILE file)
int64_t sqstd_fflush(SQFILE file)
{
return fflush((FILE *)file);
}
SQInteger sqstd_fclose(SQFILE file)
int64_t sqstd_fclose(SQFILE file)
{
return fclose((FILE *)file);
}
SQInteger sqstd_feof(SQFILE file)
int64_t sqstd_feof(SQFILE file)
{
return feof((FILE *)file);
}
@ -86,26 +86,26 @@ struct SQFile : public SQStream {
_owns = false;
}
}
SQInteger Read(void *buffer,SQInteger size) {
int64_t Read(void *buffer,int64_t size) {
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);
}
SQInteger Flush() {
int64_t Flush() {
return sqstd_fflush(_handle);
}
SQInteger Tell() {
int64_t Tell() {
return sqstd_ftell(_handle);
}
SQInteger Len() {
SQInteger prevpos=Tell();
int64_t Len() {
int64_t prevpos=Tell();
Seek(0,SQ_SEEK_END);
SQInteger size=Tell();
int64_t size=Tell();
Seek(prevpos,SQ_SEEK_SET);
return size;
}
SQInteger Seek(SQInteger offset, SQInteger origin) {
int64_t Seek(int64_t offset, int64_t origin) {
return sqstd_fseek(_handle,offset,origin);
}
bool IsValid() { return _handle?true:false; }
@ -116,13 +116,13 @@ private:
bool _owns;
};
static SQInteger _file__typeof(HRABBITVM v)
static int64_t _file__typeof(HRABBITVM v)
{
sq_pushstring(v,_SC("file"),-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;
self->~SQFile();
@ -130,7 +130,7 @@ static SQInteger _file_releasehook(SQUserPointer p, SQInteger SQ_UNUSED_ARG(size
return 1;
}
static SQInteger _file_constructor(HRABBITVM v)
static int64_t _file_constructor(HRABBITVM v)
{
const SQChar *filename,*mode;
bool owns = true;
@ -158,7 +158,7 @@ static SQInteger _file_constructor(HRABBITVM v)
return 0;
}
static SQInteger _file_close(HRABBITVM v)
static int64_t _file_close(HRABBITVM v)
{
SQFile *self = NULL;
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)
{
SQInteger top = sq_gettop(v);
int64_t top = sq_gettop(v);
sq_pushregistrytable(v);
sq_pushstring(v,_SC("std_file"),-1);
if(SQ_SUCCEEDED(sq_get(v,-2))) {
@ -204,7 +204,7 @@ SQRESULT sqstd_createfile(HRABBITVM v, SQFILE file,SQBool own)
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;
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
struct IOBuffer {
unsigned char buffer[IO_BUFFER_SIZE];
SQInteger size;
SQInteger ptr;
int64_t size;
int64_t ptr;
SQFILE file;
};
SQInteger _read_byte(IOBuffer *iobuffer)
int64_t _read_byte(IOBuffer *iobuffer)
{
if(iobuffer->ptr < iobuffer->size) {
SQInteger ret = iobuffer->buffer[iobuffer->ptr];
int64_t ret = iobuffer->buffer[iobuffer->ptr];
iobuffer->ptr++;
return ret;
}
else {
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;
return ret;
}
@ -244,11 +244,11 @@ SQInteger _read_byte(IOBuffer *iobuffer)
return 0;
}
SQInteger _read_two_bytes(IOBuffer *iobuffer)
int64_t _read_two_bytes(IOBuffer *iobuffer)
{
if(iobuffer->ptr < iobuffer->size) {
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;
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 < 2) return 0;
SQInteger ret = *((const wchar_t*)&iobuffer->buffer[0]);
int64_t ret = *((const wchar_t*)&iobuffer->buffer[0]);
iobuffer->ptr = 2;
return ret;
}
@ -265,7 +265,7 @@ SQInteger _read_two_bytes(IOBuffer *iobuffer)
return 0;
}
static SQInteger _io_file_lexfeed_PLAIN(SQUserPointer iobuf)
static int64_t _io_file_lexfeed_PLAIN(SQUserPointer iobuf)
{
IOBuffer *iobuffer = (IOBuffer *)iobuf;
return _read_byte(iobuffer);
@ -273,14 +273,14 @@ static SQInteger _io_file_lexfeed_PLAIN(SQUserPointer iobuf)
}
#ifdef SQUNICODE
static SQInteger _io_file_lexfeed_UTF8(SQUserPointer iobuf)
static int64_t _io_file_lexfeed_UTF8(SQUserPointer iobuf)
{
IOBuffer *iobuffer = (IOBuffer *)iobuf;
#define READ(iobuf) \
if((inchar = (unsigned char)_read_byte(iobuf)) == 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) */
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};
unsigned char inchar;
SQInteger c = 0;
int64_t c = 0;
READ(iobuffer);
c = inchar;
//
if(c >= 0x80) {
SQInteger tmp;
SQInteger codelen = utf8_lengths[c>>4];
int64_t tmp;
int64_t codelen = utf8_lengths[c>>4];
if(codelen == 0)
return 0;
//"invalid UTF-8 stream";
tmp = c&byte_masks[codelen];
for(SQInteger n = 0; n < codelen-1; n++) {
for(int64_t n = 0; n < codelen-1; n++) {
tmp<<=6;
READ(iobuffer);
tmp |= inchar & 0x3F;
@ -312,18 +312,18 @@ static SQInteger _io_file_lexfeed_UTF8(SQUserPointer iobuf)
}
#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;
if( (ret = _read_two_bytes(iobuffer)) > 0 )
return ret;
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;
if( (c = _read_two_bytes(iobuffer)) > 0 ) {
c = ((c>>8)&0x00FF)| ((c<<8)&0xFF00);
@ -332,14 +332,14 @@ static SQInteger _io_file_lexfeed_UCS2_BE(SQUserPointer iobuf)
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;
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);
}
@ -348,7 +348,7 @@ SQRESULT sqstd_loadfile(HRABBITVM v,const SQChar *filename,SQBool printerror)
{
SQFILE file = sqstd_fopen(filename,_SC("rb"));
SQInteger ret;
int64_t ret;
unsigned short us;
unsigned char uc;
SQLEXREADFUNC func = _io_file_lexfeed_PLAIN;
@ -433,7 +433,7 @@ SQRESULT sqstd_writeclosuretofile(HRABBITVM v,const SQChar *filename)
return SQ_ERROR; //forward the error
}
SQInteger _g_io_loadfile(HRABBITVM v)
int64_t _g_io_loadfile(HRABBITVM v)
{
const SQChar *filename;
SQBool printerror = SQFalse;
@ -446,7 +446,7 @@ SQInteger _g_io_loadfile(HRABBITVM v)
return SQ_ERROR; //propagates the error
}
SQInteger _g_io_writeclosuretofile(HRABBITVM v)
int64_t _g_io_writeclosuretofile(HRABBITVM v)
{
const SQChar *filename;
sq_getstring(v,2,&filename);
@ -455,7 +455,7 @@ SQInteger _g_io_writeclosuretofile(HRABBITVM v)
return SQ_ERROR; //propagates the error
}
SQInteger _g_io_dofile(HRABBITVM v)
int64_t _g_io_dofile(HRABBITVM v)
{
const SQChar *filename;
SQBool printerror = SQFalse;
@ -479,7 +479,7 @@ static const SQRegFunction iolib_funcs[]={
SQRESULT sqstd_register_iolib(HRABBITVM v)
{
SQInteger top = sq_gettop(v);
int64_t top = sq_gettop(v);
//create delegate
declare_stream(v,_SC("file"),(SQUserPointer)SQSTD_FILE_TYPE_TAG,_SC("std_file"),_file_methods,iolib_funcs);
sq_pushstring(v,_SC("stdout"),-1);

28
rabbit-std/sqstdio.hpp
View File

@ -11,12 +11,12 @@
struct SQStream {
virtual ~SQStream() {}
virtual SQInteger Read(void *buffer, SQInteger size) = 0;
virtual SQInteger Write(void *buffer, SQInteger size) = 0;
virtual SQInteger Flush() = 0;
virtual SQInteger Tell() = 0;
virtual SQInteger Len() = 0;
virtual SQInteger Seek(SQInteger offset, SQInteger origin) = 0;
virtual int64_t Read(void *buffer, int64_t size) = 0;
virtual int64_t Write(void *buffer, int64_t size) = 0;
virtual int64_t Flush() = 0;
virtual int64_t Tell() = 0;
virtual int64_t Len() = 0;
virtual int64_t Seek(int64_t offset, int64_t origin) = 0;
virtual bool IsValid() = 0;
virtual bool EOS() = 0;
};
@ -28,16 +28,16 @@ struct SQStream {
typedef void* SQFILE;
RABBIT_API SQFILE sqstd_fopen(const SQChar *,const SQChar *);
RABBIT_API SQInteger sqstd_fread(SQUserPointer, SQInteger, SQInteger, SQFILE);
RABBIT_API SQInteger sqstd_fwrite(const SQUserPointer, SQInteger, SQInteger, SQFILE);
RABBIT_API SQInteger sqstd_fseek(SQFILE , SQInteger , SQInteger);
RABBIT_API SQInteger sqstd_ftell(SQFILE);
RABBIT_API SQInteger sqstd_fflush(SQFILE);
RABBIT_API SQInteger sqstd_fclose(SQFILE);
RABBIT_API SQInteger sqstd_feof(SQFILE);
RABBIT_API int64_t sqstd_fread(SQUserPointer, int64_t, int64_t, SQFILE);
RABBIT_API int64_t sqstd_fwrite(const SQUserPointer, int64_t, int64_t, SQFILE);
RABBIT_API int64_t sqstd_fseek(SQFILE , int64_t , int64_t);
RABBIT_API int64_t sqstd_ftell(SQFILE);
RABBIT_API int64_t sqstd_fflush(SQFILE);
RABBIT_API int64_t sqstd_fclose(SQFILE);
RABBIT_API int64_t sqstd_feof(SQFILE);
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
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 <rabbit-std/sqstdmath.hpp>
#define SINGLE_ARG_FUNC(_funcname) static SQInteger math_##_funcname(HRABBITVM v){ \
SQFloat f; \
#define SINGLE_ARG_FUNC(_funcname) static int64_t math_##_funcname(HRABBITVM v){ \
float_t f; \
sq_getfloat(v,2,&f); \
sq_pushfloat(v,(SQFloat)_funcname(f)); \
sq_pushfloat(v,(float_t)_funcname(f)); \
return 1; \
}
#define TWO_ARGS_FUNC(_funcname) static SQInteger math_##_funcname(HRABBITVM v){ \
SQFloat p1,p2; \
#define TWO_ARGS_FUNC(_funcname) static int64_t math_##_funcname(HRABBITVM v){ \
float_t p1,p2; \
sq_getfloat(v,2,&p1); \
sq_getfloat(v,3,&p2); \
sq_pushfloat(v,(SQFloat)_funcname(p1,p2)); \
sq_pushfloat(v,(float_t)_funcname(p1,p2)); \
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)))
return sq_throwerror(v,_SC("invalid param"));
srand((unsigned int)i);
return 0;
}
static SQInteger math_rand(HRABBITVM v)
static int64_t math_rand(HRABBITVM v)
{
sq_pushinteger(v,rand());
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_pushinteger(v,(SQInteger)abs((int)n));
sq_pushinteger(v,(int64_t)abs((int)n));
return 1;
}
@ -95,7 +95,7 @@ static const SQRegFunction mathlib_funcs[] = {
SQRESULT sqstd_register_mathlib(HRABBITVM v)
{
SQInteger i=0;
int64_t i=0;
while(mathlib_funcs[i].name!=0) {
sq_pushstring(v,mathlib_funcs[i].name,-1);
sq_newclosure(v,mathlib_funcs[i].f,0);
@ -108,7 +108,7 @@ SQRESULT sqstd_register_mathlib(HRABBITVM v)
sq_pushinteger(v,RAND_MAX);
sq_newslot(v,-3,SQFalse);
sq_pushstring(v,_SC("PI"),-1);
sq_pushfloat(v,(SQFloat)M_PI);
sq_pushfloat(v,(float_t)M_PI);
sq_newslot(v,-3,SQFalse);
return SQ_OK;
}

110
rabbit-std/sqstdrex.cpp
View File

@ -54,30 +54,30 @@ typedef int SQRexNodeType;
typedef struct tagSQRexNode{
SQRexNodeType type;
SQInteger left;
SQInteger right;
SQInteger next;
int64_t left;
int64_t right;
int64_t next;
}SQRexNode;
struct SQRex{
const SQChar *_eol;
const SQChar *_bol;
const SQChar *_p;
SQInteger _first;
SQInteger _op;
int64_t _first;
int64_t _op;
SQRexNode *_nodes;
SQInteger _nallocated;
SQInteger _nsize;
SQInteger _nsubexpr;
int64_t _nallocated;
int64_t _nsize;
int64_t _nsubexpr;
SQRexMatch *_matches;
SQInteger _currsubexp;
int64_t _currsubexp;
void *_jmpbuf;
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;
n.type = type;
@ -85,13 +85,13 @@ static SQInteger sqstd_rex_newnode(SQRex *exp, SQRexNodeType type)
if(type == OP_EXPR)
n.right = exp->_nsubexpr++;
if(exp->_nallocated < (exp->_nsize + 1)) {
SQInteger oldsize = exp->_nallocated;
int64_t oldsize = exp->_nallocated;
exp->_nallocated *= 2;
exp->_nodes = (SQRexNode *)sq_realloc(exp->_nodes, oldsize * sizeof(SQRexNode) ,exp->_nallocated * sizeof(SQRexNode));
}
exp->_nodes[exp->_nsize++] = n;
SQInteger newid = exp->_nsize - 1;
return (SQInteger)newid;
int64_t newid = exp->_nsize - 1;
return (int64_t)newid;
}
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);
}
static void sqstd_rex_expect(SQRex *exp, SQInteger n){
static void sqstd_rex_expect(SQRex *exp, int64_t n){
if((*exp->_p) != n)
sqstd_rex_error(exp, _SC("expected paren"));
exp->_p++;
@ -122,14 +122,14 @@ static SQChar sqstd_rex_escapechar(SQRex *exp)
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;
return n;
}
static SQInteger sqstd_rex_charnode(SQRex *exp,SQBool isclass)
static int64_t sqstd_rex_charnode(SQRex *exp,SQBool isclass)
{
SQChar t;
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
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"));
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].right = ce;
return node;
@ -166,7 +166,7 @@ static SQInteger sqstd_rex_charnode(SQRex *exp,SQBool isclass)
case 'b':
case 'B':
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->_p++;
return node;
@ -183,10 +183,10 @@ static SQInteger sqstd_rex_charnode(SQRex *exp,SQBool isclass)
t = *exp->_p; exp->_p++;
return sqstd_rex_newnode(exp,t);
}
static SQInteger sqstd_rex_class(SQRex *exp)
static int64_t sqstd_rex_class(SQRex *exp)
{
SQInteger ret = -1;
SQInteger first = -1,chain;
int64_t ret = -1;
int64_t first = -1,chain;
if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING){
ret = sqstd_rex_newnode(exp,OP_NCLASS);
exp->_p++;
@ -196,13 +196,13 @@ static SQInteger sqstd_rex_class(SQRex *exp)
chain = ret;
while(*exp->_p != ']' && exp->_p != exp->_eol) {
if(*exp->_p == '-' && first != -1){
SQInteger r;
int64_t r;
if(*exp->_p++ == ']') sqstd_rex_error(exp,_SC("unfinished 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 == OP_CCLASS) sqstd_rex_error(exp,_SC("cannot use character classes in ranges"));
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[chain].next = r;
chain = r;
@ -210,7 +210,7 @@ static SQInteger sqstd_rex_class(SQRex *exp)
}
else{
if(first!=-1){
SQInteger c = first;
int64_t c = first;
exp->_nodes[chain].next = c;
chain = c;
first = sqstd_rex_charnode(exp,SQTrue);
@ -221,7 +221,7 @@ static SQInteger sqstd_rex_class(SQRex *exp)
}
}
if(first!=-1){
SQInteger c = first;
int64_t c = first;
exp->_nodes[chain].next = c;
}
/* hack? */
@ -230,10 +230,10 @@ static SQInteger sqstd_rex_class(SQRex *exp)
return ret;
}
static SQInteger sqstd_rex_parsenumber(SQRex *exp)
static int64_t sqstd_rex_parsenumber(SQRex *exp)
{
SQInteger ret = *exp->_p-'0';
SQInteger positions = 10;
int64_t ret = *exp->_p-'0';
int64_t positions = 10;
exp->_p++;
while(isdigit(*exp->_p)) {
ret = ret*10+(*exp->_p++-'0');
@ -243,13 +243,13 @@ static SQInteger sqstd_rex_parsenumber(SQRex *exp)
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)
{
case '(': {
SQInteger expr;
int64_t expr;
exp->_p++;
@ -260,7 +260,7 @@ static SQInteger sqstd_rex_element(SQRex *exp)
}
else
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;
ret = expr;
sqstd_rex_expect(exp,')');
@ -311,23 +311,23 @@ static SQInteger sqstd_rex_element(SQRex *exp)
}
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].right = ((p0)<<16)|p1;
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')) {
SQInteger nnode = sqstd_rex_element(exp);
int64_t nnode = sqstd_rex_element(exp);
exp->_nodes[ret].next = nnode;
}
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) {
exp->_p++;
ret = sqstd_rex_newnode(exp,OP_BOL);
@ -339,7 +339,7 @@ static SQInteger sqstd_rex_list(SQRex *exp)
else ret = e;
if(*exp->_p == SQREX_SYMBOL_BRANCH) {
SQInteger temp,tright;
int64_t temp,tright;
exp->_p++;
temp = sqstd_rex_newnode(exp,OP_OR);
exp->_nodes[temp].left = ret;
@ -350,7 +350,7 @@ static SQInteger sqstd_rex_list(SQRex *exp)
return ret;
}
static SQBool sqstd_rex_matchcclass(SQInteger cclass,SQChar c)
static SQBool sqstd_rex_matchcclass(int64_t cclass,SQChar c)
{
switch(cclass) {
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: {
//SQRexNode *greedystop = (node->next != -1) ? &exp->_nodes[node->next] : 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;
if(node->next != -1) {
@ -469,13 +469,13 @@ static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar
case OP_NOCAPEXPR:{
SQRexNode *n = &exp->_nodes[node->left];
const SQChar *cur = str;
SQInteger capture = -1;
int64_t capture = -1;
if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) {
capture = exp->_currsubexp;
exp->_matches[capture].begin = cur;
exp->_currsubexp++;
}
SQInteger tempcap = exp->_currsubexp;
int64_t tempcap = exp->_currsubexp;
do {
SQRexNode *subnext = NULL;
if(n->next != -1) {
@ -533,10 +533,10 @@ static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar
return NULL;
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
SQInteger ce = node->right; //char that closes a balanced expression
SQInteger cont = 1;
int64_t ce = node->right; //char that closes a balanced expression
int64_t cont = 1;
const SQChar *streol = exp->_eol;
while (++str < streol) {
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()
exp->_eol = exp->_bol = NULL;
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->_nsize = 0;
exp->_matches = 0;
@ -572,23 +572,23 @@ SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error)
exp->_error = error;
exp->_jmpbuf = sq_malloc(sizeof(jmp_buf));
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;
if(*exp->_p!='\0')
sqstd_rex_error(exp,_SC("unexpected character"));
#ifdef _DEBUG
{
SQInteger nsize,i;
int64_t nsize,i;
SQRexNode *t;
nsize = exp->_nsize;
t = &exp->_nodes[0];
scprintf(_SC("\n"));
for(i = 0;i < nsize; i++) {
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
scprintf(_SC("[%02d] %10c "), (SQInt32)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("[%02d] %10c "), (int32_t)i,exp->_nodes[i].type);
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"));
}
@ -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)
{
const SQChar *cur = NULL;
SQInteger node = exp->_first;
int64_t node = exp->_first;
if(text_begin >= text_end) return SQFalse;
exp->_bol = text_begin;
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);
}
SQInteger sqstd_rex_getsubexpcount(SQRex* exp)
int64_t sqstd_rex_getsubexpcount(SQRex* exp)
{
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;
*subexp = exp->_matches[n];

60
rabbit-std/sqstdstream.cpp
View File

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

20
rabbit-std/sqstdstream.hpp
View File

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

104
rabbit-std/sqstdstring.cpp
View File

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

8
rabbit-std/sqstdstring.hpp
View File

@ -12,7 +12,7 @@ typedef struct SQRex SQRex;
typedef struct {
const SQChar *begin;
SQInteger len;
int64_t len;
} SQRexMatch;
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_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 SQInteger sqstd_rex_getsubexpcount(SQRex* exp);
RABBIT_API SQBool sqstd_rex_getsubexp(SQRex* exp, SQInteger n, SQRexMatch *subexp);
RABBIT_API int64_t sqstd_rex_getsubexpcount(SQRex* exp);
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);

30
rabbit-std/sqstdsystem.cpp
View File

@ -27,7 +27,7 @@
#define screname rename
#endif
static SQInteger _system_getenv(HRABBITVM v)
static int64_t _system_getenv(HRABBITVM v)
{
const SQChar *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;
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;
}
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);
return 1;
}
static SQInteger _system_remove(HRABBITVM v)
static int64_t _system_remove(HRABBITVM v)
{
const SQChar *s;
sq_getstring(v,2,&s);
@ -71,7 +71,7 @@ static SQInteger _system_remove(HRABBITVM v)
return 0;
}
static SQInteger _system_rename(HRABBITVM v)
static int64_t _system_rename(HRABBITVM v)
{
const SQChar *oldn,*newn;
sq_getstring(v,2,&oldn);
@ -81,23 +81,23 @@ static SQInteger _system_rename(HRABBITVM v)
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_pushinteger(v,val);
sq_rawset(v,-3);
}
static SQInteger _system_date(HRABBITVM v)
static int64_t _system_date(HRABBITVM v)
{
time_t t;
SQInteger it;
SQInteger format = 'l';
int64_t it;
int64_t format = 'l';
if(sq_gettop(v) > 1) {
sq_getinteger(v,2,&it);
t = it;
if(sq_gettop(v) > 2) {
sq_getinteger(v,3,(SQInteger*)&format);
sq_getinteger(v,3,(int64_t*)&format);
}
}
else {
@ -137,9 +137,9 @@ static const SQRegFunction systemlib_funcs[]={
};
#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)
{
sq_pushstring(v,systemlib_funcs[i].name,-1);

2
rabbit-std/sqstdsystem.hpp
View File

@ -7,4 +7,4 @@
*/
#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() {
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);
new (ud) UserData(ss);
ud->m_size = size;
@ -28,11 +28,11 @@ namespace rabbit {
if (m_hook) {
m_hook((SQUserPointer)sq_aligning(this + 1),m_size);
}
SQInteger tsize = m_size;
int64_t tsize = m_size;
this->~UserData();
SQ_FREE(this, sq_aligning(sizeof(UserData)) + tsize);
}
const SQInteger& getSize() const {
const int64_t& getSize() const {
return m_size;
}
const SQUserPointer& getTypeTag() const {
@ -48,7 +48,7 @@ namespace rabbit {
m_hook = _value;
}
protected:
SQInteger m_size;
int64_t m_size;
SQRELEASEHOOK m_hook;
SQUserPointer m_typetag;
};

224
rabbit/rabbit.hpp
View File

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

238
rabbit/sqapi.cpp
View File

@ -17,7 +17,7 @@
#include <rabbit/sqfuncstate.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);
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));
return sq_throwerror(v, _ss(v)->GetScratchPad(-1));
}
HRABBITVM sq_open(SQInteger initialstacksize)
HRABBITVM sq_open(int64_t initialstacksize)
{
SQSharedState *ss;
SQVM *v;
@ -61,7 +61,7 @@ HRABBITVM sq_open(SQInteger initialstacksize)
return v;
}
HRABBITVM sq_newthread(HRABBITVM friendvm, SQInteger initialstacksize)
HRABBITVM sq_newthread(HRABBITVM friendvm, int64_t initialstacksize)
{
SQSharedState *ss;
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)
return SQ_VMSTATE_SUSPENDED;
@ -123,7 +123,7 @@ void sq_close(HRABBITVM v)
sq_delete(ss, SQSharedState);
}
SQInteger sq_getversion()
int64_t sq_getversion()
{
return RABBIT_VERSION_NUMBER;
}
@ -158,7 +158,7 @@ void sq_addref(HRABBITVM v,HSQOBJECT *po)
__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;
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)
}
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;
return po->_unVal.pRefCounted->_uiRef;
@ -186,7 +186,7 @@ const SQChar *sq_objtostring(const HSQOBJECT *o)
return NULL;
}
SQInteger sq_objtointeger(const HSQOBJECT *o)
int64_t sq_objtointeger(const HSQOBJECT *o)
{
if(sq_isnumeric(*o)) {
return tointeger(*o);
@ -194,7 +194,7 @@ SQInteger sq_objtointeger(const HSQOBJECT *o)
return 0;
}
SQFloat sq_objtofloat(const HSQOBJECT *o)
float_t sq_objtofloat(const HSQOBJECT *o)
{
if(sq_isnumeric(*o)) {
return tofloat(*o);
@ -223,14 +223,14 @@ void sq_pushnull(HRABBITVM v)
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)
v->Push(SQObjectPtr(SQString::Create(_ss(v), s, len)));
else v->PushNull();
}
void sq_pushinteger(HRABBITVM v,SQInteger n)
void sq_pushinteger(HRABBITVM v,int64_t n)
{
v->Push(n);
}
@ -240,7 +240,7 @@ void sq_pushbool(HRABBITVM v,SQBool b)
v->Push(b?true:false);
}
void sq_pushfloat(HRABBITVM v,SQFloat n)
void sq_pushfloat(HRABBITVM v,float_t n)
{
v->Push(n);
}
@ -255,7 +255,7 @@ void sq_pushthread(HRABBITVM v, HRABBITVM 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);
v->Push(ud);
@ -267,12 +267,12 @@ void sq_newtable(HRABBITVM v)
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));
}
void sq_newarray(HRABBITVM v,SQInteger size)
void sq_newarray(HRABBITVM v,int64_t 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;
}
SQRESULT sq_arrayappend(HRABBITVM v,SQInteger idx)
SQRESULT sq_arrayappend(HRABBITVM v,int64_t idx)
{
sq_aux_paramscheck(v,2);
SQObjectPtr *arr;
@ -311,7 +311,7 @@ SQRESULT sq_arrayappend(HRABBITVM v,SQInteger idx)
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);
SQObjectPtr *arr;
@ -324,7 +324,7 @@ SQRESULT sq_arraypop(HRABBITVM v,SQInteger idx,SQBool pushval)
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);
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);
SQObjectPtr *o;
@ -345,9 +345,9 @@ SQRESULT sq_arrayreverse(HRABBITVM v,SQInteger idx)
SQArray *arr = _array(*o);
if(arr->Size() > 0) {
SQObjectPtr t;
SQInteger size = arr->Size();
SQInteger n = size >> 1; size -= 1;
for(SQInteger i = 0; i < n; i++) {
int64_t size = arr->Size();
int64_t n = size >> 1; size -= 1;
for(int64_t i = 0; i < n; i++) {
t = arr->_values[i];
arr->_values[i] = arr->_values[size-i];
arr->_values[size-i] = t;
@ -357,7 +357,7 @@ SQRESULT sq_arrayreverse(HRABBITVM v,SQInteger idx)
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);
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"));
}
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);
SQObjectPtr *arr;
@ -375,38 +375,38 @@ SQRESULT sq_arrayinsert(HRABBITVM v,SQInteger idx,SQInteger destpos)
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);
nc->_nparamscheck = 0;
for(SQUnsignedInteger i = 0; i < nfreevars; i++) {
for(uint64_t i = 0; i < nfreevars; i++) {
nc->_outervalues[i] = v->Top();
v->Pop();
}
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);
if(sq_type(o) == OT_CLOSURE) {
SQClosure *c = _closure(o);
SQFunctionProto *proto = c->_function;
*nparams = (SQUnsignedInteger)proto->_nparameters;
*nfreevars = (SQUnsignedInteger)proto->_noutervalues;
*nparams = (uint64_t)proto->_nparameters;
*nfreevars = (uint64_t)proto->_noutervalues;
return SQ_OK;
}
else if(sq_type(o) == OT_NATIVECLOSURE)
{
SQNativeClosure *c = _nativeclosure(o);
*nparams = (SQUnsignedInteger)c->_nparamscheck;
*nparams = (uint64_t)c->_nparamscheck;
*nfreevars = c->_noutervalues;
return SQ_OK;
}
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);
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"));
}
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);
if(!sq_isnativeclosure(o))
@ -439,7 +439,7 @@ SQRESULT sq_setparamscheck(HRABBITVM v,SQInteger nparamscheck,const SQChar *type
return SQ_OK;
}
SQRESULT sq_bindenv(HRABBITVM v,SQInteger idx)
SQRESULT sq_bindenv(HRABBITVM v,int64_t idx)
{
SQObjectPtr &o = stack_get(v,idx);
if(!sq_isnativeclosure(o) &&
@ -476,7 +476,7 @@ SQRESULT sq_bindenv(HRABBITVM v,SQInteger idx)
return SQ_OK;
}
SQRESULT sq_getclosurename(HRABBITVM v,SQInteger idx)
SQRESULT sq_getclosurename(HRABBITVM v,int64_t idx)
{
SQObjectPtr &o = stack_get(v,idx);
if(!sq_isnativeclosure(o) &&
@ -492,7 +492,7 @@ SQRESULT sq_getclosurename(HRABBITVM v,SQInteger idx)
return SQ_OK;
}
SQRESULT sq_setclosureroot(HRABBITVM v,SQInteger idx)
SQRESULT sq_setclosureroot(HRABBITVM v,int64_t idx)
{
SQObjectPtr &c = stack_get(v,idx);
SQObject o = stack_get(v, -1);
@ -505,7 +505,7 @@ SQRESULT sq_setclosureroot(HRABBITVM v,SQInteger idx)
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);
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;
}
SQRESULT sq_clear(HRABBITVM v,SQInteger idx)
SQRESULT sq_clear(HRABBITVM v,int64_t idx)
{
SQObject &o=stack_get(v,idx);
switch(sq_type(o)) {
@ -604,17 +604,17 @@ SQRELEASEHOOK sq_getsharedreleasehook(HRABBITVM v)
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));
}
SQObjectType sq_gettype(HRABBITVM v,SQInteger idx)
SQObjectType sq_gettype(HRABBITVM v,int64_t 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 res;
@ -625,7 +625,7 @@ SQRESULT sq_typeof(HRABBITVM v,SQInteger idx)
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 res;
@ -636,13 +636,13 @@ SQRESULT sq_tostring(HRABBITVM v,SQInteger idx)
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);
*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);
if(sq_isnumeric(o)) {
@ -656,7 +656,7 @@ SQRESULT sq_getinteger(HRABBITVM v,SQInteger idx,SQInteger *i)
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);
if(sq_isnumeric(o)) {
@ -666,7 +666,7 @@ SQRESULT sq_getfloat(HRABBITVM v,SQInteger idx,SQFloat *f)
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);
if(sq_isbool(o)) {
@ -676,7 +676,7 @@ SQRESULT sq_getbool(HRABBITVM v,SQInteger idx,SQBool *b)
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;
_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;
}
SQRESULT sq_getstring(HRABBITVM v,SQInteger idx,const SQChar **c)
SQRESULT sq_getstring(HRABBITVM v,int64_t idx,const SQChar **c)
{
SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_STRING,o);
@ -693,7 +693,7 @@ SQRESULT sq_getstring(HRABBITVM v,SQInteger idx,const SQChar **c)
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;
_GETSAFE_OBJ(v, idx, OT_THREAD,o);
@ -701,7 +701,7 @@ SQRESULT sq_getthread(HRABBITVM v,SQInteger idx,HRABBITVM *thread)
return SQ_OK;
}
SQRESULT sq_clone(HRABBITVM v,SQInteger idx)
SQRESULT sq_clone(HRABBITVM v,int64_t idx)
{
SQObjectPtr &o = stack_get(v,idx);
v->PushNull();
@ -712,7 +712,7 @@ SQRESULT sq_clone(HRABBITVM v,SQInteger idx)
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);
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);
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;
_GETSAFE_OBJ(v, idx, OT_USERDATA,o);
@ -745,7 +745,7 @@ SQRESULT sq_getuserdata(HRABBITVM v,SQInteger idx,SQUserPointer *p,SQUserPointer
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);
switch(sq_type(o)) {
@ -772,7 +772,7 @@ SQRESULT sq_getobjtypetag(const HSQOBJECT *o,SQUserPointer * typetag)
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);
if (SQ_FAILED(sq_getobjtypetag(&o, typetag)))
@ -780,7 +780,7 @@ SQRESULT sq_gettypetag(HRABBITVM v,SQInteger idx,SQUserPointer *typetag)
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;
_GETSAFE_OBJ(v, idx, OT_USERPOINTER,o);
@ -788,7 +788,7 @@ SQRESULT sq_getuserpointer(HRABBITVM v, SQInteger idx, SQUserPointer *p)
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);
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;
}
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);
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);
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;
}
SQInteger sq_gettop(HRABBITVM v)
int64_t sq_gettop(HRABBITVM v)
{
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)
sq_pop(v, top - newtop);
else
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);
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);
}
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);
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);
SQObjectPtr &self = stack_get(v, idx);
@ -875,7 +875,7 @@ SQRESULT sq_newslot(HRABBITVM v, SQInteger idx, SQBool bstatic)
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);
SQObjectPtr *self;
@ -892,7 +892,7 @@ SQRESULT sq_deleteslot(HRABBITVM v,SQInteger idx,SQBool pushval)
return SQ_OK;
}
SQRESULT sq_set(HRABBITVM v,SQInteger idx)
SQRESULT sq_set(HRABBITVM v,int64_t idx)
{
SQObjectPtr &self = stack_get(v, idx);
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;
}
SQRESULT sq_rawset(HRABBITVM v,SQInteger idx)
SQRESULT sq_rawset(HRABBITVM v,int64_t idx)
{
SQObjectPtr &self = stack_get(v, idx);
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;
}
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);
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;
}
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);
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;
}
SQRESULT sq_setdelegate(HRABBITVM v,SQInteger idx)
SQRESULT sq_setdelegate(HRABBITVM v,int64_t idx)
{
SQObjectPtr &self = stack_get(v, idx);
SQObjectPtr &mt = v->GetUp(-1);
@ -999,7 +999,7 @@ SQRESULT sq_setdelegate(HRABBITVM v,SQInteger idx)
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);
SQObjectPtr *self;
@ -1016,7 +1016,7 @@ SQRESULT sq_rawdeleteslot(HRABBITVM v,SQInteger idx,SQBool pushval)
return SQ_OK;
}
SQRESULT sq_getdelegate(HRABBITVM v,SQInteger idx)
SQRESULT sq_getdelegate(HRABBITVM v,int64_t idx)
{
SQObjectPtr &self=stack_get(v,idx);
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 &obj = v->GetUp(-1);
@ -1044,7 +1044,7 @@ SQRESULT sq_get(HRABBITVM v,SQInteger idx)
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 &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"));
}
SQRESULT sq_getstackobj(HRABBITVM v,SQInteger idx,HSQOBJECT *po)
SQRESULT sq_getstackobj(HRABBITVM v,int64_t idx,HSQOBJECT *po)
{
*po=stack_get(v,idx);
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;
SQUnsignedInteger lvl=(cstksize-level)-1;
SQInteger stackbase=v->_stackbase;
uint64_t cstksize=v->_callsstacksize;
uint64_t lvl=(cstksize-level)-1;
int64_t stackbase=v->_stackbase;
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];
stackbase-=ci._prevstkbase;
}
@ -1102,12 +1102,12 @@ const SQChar *sq_getlocal(HRABBITVM v,SQUnsignedInteger level,SQUnsignedInteger
return NULL;
SQClosure *c=_closure(ci._closure);
SQFunctionProto *func=c->_function;
if(func->_noutervalues > (SQInteger)idx) {
if(func->_noutervalues > (int64_t)idx) {
v->Push(*_outer(c->_outervalues[idx])->_valptr);
return _stringval(func->_outervalues[idx]._name);
}
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;
}
@ -1146,9 +1146,9 @@ void sq_getlasterror(HRABBITVM v)
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) {
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"));
}
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;
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"));
}
SQRESULT sq_tailcall(HRABBITVM v, SQInteger nparams)
SQRESULT sq_tailcall(HRABBITVM v, int64_t nparams)
{
SQObjectPtr &res = v->GetUp(-(nparams + 1));
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"));
}
SQInteger stackbase = (v->_top - nparams) - v->_stackbase;
int64_t stackbase = (v->_top - nparams) - v->_stackbase;
if (!v->TailCall(clo, stackbase, nparams)) {
return SQ_ERROR;
}
@ -1222,7 +1222,7 @@ SQRESULT sq_wakeupvm(HRABBITVM v,SQBool wakeupret,SQBool retval,SQBool raiseerro
SQObjectPtr ret;
if(!v->_suspended)
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(target != -1) {
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;
}
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);
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);
switch(sq_type(ud) ) {
@ -1309,7 +1309,7 @@ SQRESULT sq_readclosure(HRABBITVM v,SQREADFUNC r,SQUserPointer up)
return SQ_OK;
}
SQChar *sq_getscratchpad(HRABBITVM v,SQInteger minsize)
SQChar *sq_getscratchpad(HRABBITVM v,int64_t minsize)
{
return _ss(v)->GetScratchPad(minsize);
}
@ -1320,7 +1320,7 @@ SQRESULT sq_resurrectunreachable(HRABBITVM v)
}
// TODO: Remove this...
SQInteger sq_collectgarbage(HRABBITVM v)
int64_t sq_collectgarbage(HRABBITVM v)
{
return -1;
}
@ -1335,7 +1335,7 @@ SQRESULT sq_getcallee(HRABBITVM v)
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);
const SQChar *name = NULL;
@ -1344,7 +1344,7 @@ const SQChar *sq_getfreevariable(HRABBITVM v,SQInteger idx,SQUnsignedInteger nva
case OT_CLOSURE:{
SQClosure *clo = _closure(self);
SQFunctionProto *fp = clo->_function;
if(((SQUnsignedInteger)fp->_noutervalues) > nval) {
if(((uint64_t)fp->_noutervalues) > nval) {
v->Push(*(_outer(clo->_outervalues[nval])->_valptr));
SQOuterVar &ov = fp->_outervalues[nval];
name = _stringval(ov._name);
@ -1364,14 +1364,14 @@ const SQChar *sq_getfreevariable(HRABBITVM v,SQInteger idx,SQUnsignedInteger nva
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);
switch(sq_type(self))
{
case OT_CLOSURE:{
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);
}
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;
}
SQRESULT sq_setattributes(HRABBITVM v,SQInteger idx)
SQRESULT sq_setattributes(HRABBITVM v,int64_t idx)
{
SQObjectPtr *o = NULL;
_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"));
}
SQRESULT sq_getattributes(HRABBITVM v,SQInteger idx)
SQRESULT sq_getattributes(HRABBITVM v,int64_t idx)
{
SQObjectPtr *o = NULL;
_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"));
}
SQRESULT sq_getmemberhandle(HRABBITVM v,SQInteger idx,HSQMEMBERHANDLE *handle)
SQRESULT sq_getmemberhandle(HRABBITVM v,int64_t idx,HSQMEMBERHANDLE *handle)
{
SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_CLASS,o);
@ -1479,7 +1479,7 @@ SQRESULT _getmemberbyhandle(HRABBITVM v,SQObjectPtr &self,const HSQMEMBERHANDLE
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 *val = NULL;
@ -1490,7 +1490,7 @@ SQRESULT sq_getbyhandle(HRABBITVM v,SQInteger idx,const HSQMEMBERHANDLE *handle)
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 &newval = stack_get(v,-1);
@ -1503,7 +1503,7 @@ SQRESULT sq_setbyhandle(HRABBITVM v,SQInteger idx,const HSQMEMBERHANDLE *handle)
return SQ_OK;
}
SQRESULT sq_getbase(HRABBITVM v,SQInteger idx)
SQRESULT sq_getbase(HRABBITVM v,int64_t idx)
{
SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_CLASS,o);
@ -1514,7 +1514,7 @@ SQRESULT sq_getbase(HRABBITVM v,SQInteger idx)
return SQ_OK;
}
SQRESULT sq_getclass(HRABBITVM v,SQInteger idx)
SQRESULT sq_getclass(HRABBITVM v,int64_t idx)
{
SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_INSTANCE,o);
@ -1522,7 +1522,7 @@ SQRESULT sq_getclass(HRABBITVM v,SQInteger idx)
return SQ_OK;
}
SQRESULT sq_createinstance(HRABBITVM v,SQInteger idx)
SQRESULT sq_createinstance(HRABBITVM v,int64_t idx)
{
SQObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, OT_CLASS,o);
@ -1530,7 +1530,7 @@ SQRESULT sq_createinstance(HRABBITVM v,SQInteger idx)
return SQ_OK;
}
void sq_weakref(HRABBITVM v,SQInteger idx)
void sq_weakref(HRABBITVM v,int64_t idx)
{
SQObject &o=stack_get(v,idx);
if(ISREFCOUNTED(sq_type(o))) {
@ -1540,7 +1540,7 @@ void sq_weakref(HRABBITVM v,SQInteger idx)
v->Push(o);
}
SQRESULT sq_getweakrefval(HRABBITVM v,SQInteger idx)
SQRESULT sq_getweakrefval(HRABBITVM v,int64_t idx)
{
SQObjectPtr &o = stack_get(v,idx);
if(sq_type(o) != OT_WEAKREF) {
@ -1569,7 +1569,7 @@ SQRESULT sq_getdefaultdelegate(HRABBITVM v,SQObjectType t)
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;
if(sq_type(o) == OT_GENERATOR) {
@ -1588,11 +1588,11 @@ SQRESULT sq_next(HRABBITVM v,SQInteger idx)
struct BufState{
const SQChar *buf;
SQInteger ptr;
SQInteger size;
int64_t ptr;
int64_t size;
};
SQInteger buf_lexfeed(SQUserPointer file)
int64_t buf_lexfeed(SQUserPointer file)
{
BufState *buf=(BufState*)file;
if(buf->size<(buf->ptr+1))
@ -1600,7 +1600,7 @@ SQInteger buf_lexfeed(SQUserPointer file)
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;
buf.buf = s;
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);
}
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));
}
@ -1629,17 +1629,17 @@ SQPRINTFUNCTION sq_geterrorfunc(HRABBITVM v)
return _ss(v)->_errorfunc;
}
void *sq_malloc(SQUnsignedInteger size)
void *sq_malloc(uint64_t 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);
}
void sq_free(void *p,SQUnsignedInteger size)
void sq_free(void *p,uint64_t size)
{
SQ_FREE(p,size);
}

36
rabbit/sqarray.hpp
View File

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

292
rabbit/sqbaselib.cpp
View File

@ -17,7 +17,7 @@
#include <stdarg.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;
const SQChar *e = s;
@ -33,37 +33,37 @@ static bool str2num(const SQChar *s,SQObjectPtr &res,SQInteger base)
e++;
}
if(isfloat){
SQFloat r = SQFloat(scstrtod(s,&end));
float_t r = float_t(scstrtod(s,&end));
if(s == end) return false;
res = r;
}
else{
SQInteger r = SQInteger(scstrtol(s,&end,(int)base));
int64_t r = int64_t(scstrtol(s,&end,(int)base));
if(s == end) return false;
res = r;
}
return true;
}
static SQInteger base_dummy(HRABBITVM SQ_UNUSED_ARG(v))
static int64_t base_dummy(HRABBITVM SQ_UNUSED_ARG(v))
{
return 0;
}
static SQInteger base_getroottable(HRABBITVM v)
static int64_t base_getroottable(HRABBITVM v)
{
v->Push(v->_roottable);
return 1;
}
static SQInteger base_getconsttable(HRABBITVM v)
static int64_t base_getconsttable(HRABBITVM v)
{
v->Push(_ss(v)->_consts);
return 1;
}
static SQInteger base_setroottable(HRABBITVM v)
static int64_t base_setroottable(HRABBITVM v)
{
SQObjectPtr o = v->_roottable;
if(SQ_FAILED(sq_setroottable(v))) return SQ_ERROR;
@ -71,7 +71,7 @@ static SQInteger base_setroottable(HRABBITVM v)
return 1;
}
static SQInteger base_setconsttable(HRABBITVM v)
static int64_t base_setconsttable(HRABBITVM v)
{
SQObjectPtr o = _ss(v)->_consts;
if(SQ_FAILED(sq_setconsttable(v))) return SQ_ERROR;
@ -79,19 +79,19 @@ static SQInteger base_setconsttable(HRABBITVM v)
return 1;
}
static SQInteger base_seterrorhandler(HRABBITVM v)
static int64_t base_seterrorhandler(HRABBITVM v)
{
sq_seterrorhandler(v);
return 0;
}
static SQInteger base_setdebughook(HRABBITVM v)
static int64_t base_setdebughook(HRABBITVM v)
{
sq_setdebughook(v);
return 0;
}
static SQInteger base_enabledebuginfo(HRABBITVM v)
static int64_t base_enabledebuginfo(HRABBITVM v)
{
SQObjectPtr &o=stack_get(v,2);
@ -99,10 +99,10 @@ static SQInteger base_enabledebuginfo(HRABBITVM v)
return 0;
}
static SQInteger __getcallstackinfos(HRABBITVM v,SQInteger level)
static int64_t __getcallstackinfos(HRABBITVM v,int64_t level)
{
SQStackInfos si;
SQInteger seq = 0;
int64_t seq = 0;
const SQChar *name = NULL;
if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si)))
@ -137,17 +137,17 @@ static SQInteger __getcallstackinfos(HRABBITVM v,SQInteger level)
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);
return __getcallstackinfos(v,level);
}
static SQInteger base_assert(HRABBITVM v)
static int64_t base_assert(HRABBITVM v)
{
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))) {
const SQChar *str = 0;
if (SQ_SUCCEEDED(sq_getstring(v,-1,&str))) {
@ -159,9 +159,9 @@ static SQInteger base_assert(HRABBITVM v)
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;
eidx=0;
o=stack_get(v,1);
@ -183,7 +183,7 @@ static SQInteger get_slice_params(HRABBITVM v,SQInteger &sidx,SQInteger &eidx,SQ
return 1;
}
static SQInteger base_print(HRABBITVM v)
static int64_t base_print(HRABBITVM v)
{
const SQChar *str;
if(SQ_SUCCEEDED(sq_tostring(v,2)))
@ -196,7 +196,7 @@ static SQInteger base_print(HRABBITVM v)
return SQ_ERROR;
}
static SQInteger base_error(HRABBITVM v)
static int64_t base_error(HRABBITVM v)
{
const SQChar *str;
if(SQ_SUCCEEDED(sq_tostring(v,2)))
@ -209,11 +209,11 @@ static SQInteger base_error(HRABBITVM v)
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");
SQInteger size;
int64_t size;
sq_getstring(v,2,&src);
size=sq_getsize(v,2);
if(nargs>2){
@ -225,21 +225,21 @@ static SQInteger base_compilestring(HRABBITVM v)
return SQ_ERROR;
}
static SQInteger base_newthread(HRABBITVM v)
static int64_t base_newthread(HRABBITVM v)
{
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);
sq_move(newv,v,-2);
return 1;
}
static SQInteger base_suspend(HRABBITVM v)
static int64_t base_suspend(HRABBITVM v)
{
return sq_suspendvm(v);
}
static SQInteger base_array(HRABBITVM v)
static int64_t base_array(HRABBITVM v)
{
SQArray *a;
SQObject &size = stack_get(v,2);
@ -254,14 +254,14 @@ static SQInteger base_array(HRABBITVM v)
return 1;
}
static SQInteger base_type(HRABBITVM v)
static int64_t base_type(HRABBITVM v)
{
SQObjectPtr &o = stack_get(v,2);
v->Push(SQString::Create(_ss(v),GetTypeName(o),-1));
return 1;
}
static SQInteger base_callee(HRABBITVM v)
static int64_t base_callee(HRABBITVM v)
{
if(v->_callsstacksize > 1)
{
@ -296,7 +296,7 @@ static const SQRegFunction base_funcs[]={
void sq_base_register(HRABBITVM v)
{
SQInteger i=0;
int64_t i=0;
sq_pushroottable(v);
while(base_funcs[i].name!=0) {
sq_pushstring(v,base_funcs[i].name,-1);
@ -317,21 +317,21 @@ void sq_base_register(HRABBITVM v)
sq_pushinteger(v,sizeof(SQChar));
sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_intsize_"),-1);
sq_pushinteger(v,sizeof(SQInteger));
sq_pushinteger(v,sizeof(int64_t));
sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_floatsize_"),-1);
sq_pushinteger(v,sizeof(SQFloat));
sq_pushinteger(v,sizeof(float_t));
sq_newslot(v,-3, SQFalse);
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;
}
static SQInteger default_delegate_tofloat(HRABBITVM v)
static int64_t default_delegate_tofloat(HRABBITVM v)
{
SQObjectPtr &o=stack_get(v,1);
switch(sq_type(o)){
@ -347,7 +347,7 @@ static SQInteger default_delegate_tofloat(HRABBITVM v)
v->Push(SQObjectPtr(tofloat(o)));
break;
case OT_BOOL:
v->Push(SQObjectPtr((SQFloat)(_integer(o)?1:0)));
v->Push(SQObjectPtr((float_t)(_integer(o)?1:0)));
break;
default:
v->PushNull();
@ -356,10 +356,10 @@ static SQInteger default_delegate_tofloat(HRABBITVM v)
return 1;
}
static SQInteger default_delegate_tointeger(HRABBITVM v)
static int64_t default_delegate_tointeger(HRABBITVM v)
{
SQObjectPtr &o=stack_get(v,1);
SQInteger base = 10;
int64_t base = 10;
if(sq_gettop(v) > 1) {
sq_getinteger(v,2,&base);
}
@ -376,7 +376,7 @@ static SQInteger default_delegate_tointeger(HRABBITVM v)
v->Push(SQObjectPtr(tointeger(o)));
break;
case OT_BOOL:
v->Push(SQObjectPtr(_integer(o)?(SQInteger)1:(SQInteger)0));
v->Push(SQObjectPtr(_integer(o)?(int64_t)1:(int64_t)0));
break;
default:
v->PushNull();
@ -385,26 +385,26 @@ static SQInteger default_delegate_tointeger(HRABBITVM v)
return 1;
}
static SQInteger default_delegate_tostring(HRABBITVM v)
static int64_t default_delegate_tostring(HRABBITVM v)
{
if(SQ_FAILED(sq_tostring(v,1)))
return SQ_ERROR;
return 1;
}
static SQInteger obj_delegate_weakref(HRABBITVM v)
static int64_t obj_delegate_weakref(HRABBITVM v)
{
sq_weakref(v,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;
}
static SQInteger number_delegate_tochar(HRABBITVM v)
static int64_t number_delegate_tochar(HRABBITVM v)
{
SQObject &o=stack_get(v,1);
SQChar c = (SQChar)tointeger(o);
@ -417,7 +417,7 @@ static SQInteger number_delegate_tochar(HRABBITVM v)
/////////////////////////////////////////////////////////////////
//TABLE DEFAULT DELEGATE
static SQInteger table_rawdelete(HRABBITVM v)
static int64_t table_rawdelete(HRABBITVM v)
{
if(SQ_FAILED(sq_rawdeleteslot(v,1,SQTrue)))
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))) {
sq_pushbool(v,SQTrue);
@ -435,18 +435,18 @@ static SQInteger container_rawexists(HRABBITVM v)
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;
}
static SQInteger container_rawget(HRABBITVM v)
static int64_t container_rawget(HRABBITVM v)
{
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)))
return SQ_ERROR;
@ -454,21 +454,21 @@ static SQInteger table_setdelegate(HRABBITVM v)
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;
}
static SQInteger table_filter(HRABBITVM v)
static int64_t table_filter(HRABBITVM v)
{
SQObject &o = stack_get(v,1);
SQTable *tbl = _table(o);
SQObjectPtr ret = SQTable::Create(_ss(v),0);
SQObjectPtr itr, key, val;
SQInteger nitr;
int64_t nitr;
while((nitr = tbl->Next(false, itr, key, val)) != -1) {
itr = (SQInteger)nitr;
itr = (int64_t)nitr;
v->Push(o);
v->Push(key);
@ -504,29 +504,29 @@ const SQRegFunction SQSharedState::_table_default_delegate_funcz[]={
//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;
}
static SQInteger array_extend(HRABBITVM v)
static int64_t array_extend(HRABBITVM v)
{
_array(stack_get(v,1))->Extend(_array(stack_get(v,2)));
sq_pop(v,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;
}
static SQInteger array_pop(HRABBITVM v)
static int64_t array_pop(HRABBITVM v)
{
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);
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"));
}
static SQInteger array_insert(HRABBITVM v)
static int64_t array_insert(HRABBITVM v)
{
SQObject &o=stack_get(v,1);
SQObject &idx=stack_get(v,2);
@ -547,7 +547,7 @@ static SQInteger array_insert(HRABBITVM v)
return 1;
}
static SQInteger array_remove(HRABBITVM v)
static int64_t array_remove(HRABBITVM v)
{
SQObject &o = stack_get(v, 1);
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"));
}
static SQInteger array_resize(HRABBITVM v)
static int64_t array_resize(HRABBITVM v)
{
SQObject &o = stack_get(v, 1);
SQObject &nsize = stack_get(v, 2);
SQObjectPtr fill;
if(sq_isnumeric(nsize)) {
SQInteger sz = tointeger(nsize);
int64_t sz = tointeger(nsize);
if (sz<0)
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"));
}
static SQInteger __map_array(SQArray *dest,SQArray *src,HRABBITVM v) {
static int64_t __map_array(SQArray *dest,SQArray *src,HRABBITVM v) {
SQObjectPtr temp;
SQInteger size = src->Size();
for(SQInteger n = 0; n < size; n++) {
int64_t size = src->Size();
for(int64_t n = 0; n < size; n++) {
src->Get(n,temp);
v->Push(src);
v->Push(temp);
@ -596,10 +596,10 @@ static SQInteger __map_array(SQArray *dest,SQArray *src,HRABBITVM v) {
return 0;
}
static SQInteger array_map(HRABBITVM v)
static int64_t array_map(HRABBITVM v)
{
SQObject &o = stack_get(v,1);
SQInteger size = _array(o)->Size();
int64_t size = _array(o)->Size();
SQObjectPtr ret = SQArray::Create(_ss(v),size);
if(SQ_FAILED(__map_array(_array(ret),_array(o),v)))
return SQ_ERROR;
@ -607,7 +607,7 @@ static SQInteger array_map(HRABBITVM v)
return 1;
}
static SQInteger array_apply(HRABBITVM v)
static int64_t array_apply(HRABBITVM v)
{
SQObject &o = stack_get(v,1);
if(SQ_FAILED(__map_array(_array(o),_array(o),v)))
@ -616,11 +616,11 @@ static SQInteger array_apply(HRABBITVM v)
return 1;
}
static SQInteger array_reduce(HRABBITVM v)
static int64_t array_reduce(HRABBITVM v)
{
SQObject &o = stack_get(v,1);
SQArray *a = _array(o);
SQInteger size = a->Size();
int64_t size = a->Size();
if(size == 0) {
return 0;
}
@ -628,7 +628,7 @@ static SQInteger array_reduce(HRABBITVM v)
a->Get(0,res);
if(size > 1) {
SQObjectPtr other;
for(SQInteger n = 1; n < size; n++) {
for(int64_t n = 1; n < size; n++) {
a->Get(n,other);
v->Push(o);
v->Push(res);
@ -644,14 +644,14 @@ static SQInteger array_reduce(HRABBITVM v)
return 1;
}
static SQInteger array_filter(HRABBITVM v)
static int64_t array_filter(HRABBITVM v)
{
SQObject &o = stack_get(v,1);
SQArray *a = _array(o);
SQObjectPtr ret = SQArray::Create(_ss(v),0);
SQInteger size = a->Size();
int64_t size = a->Size();
SQObjectPtr val;
for(SQInteger n = 0; n < size; n++) {
for(int64_t n = 0; n < size; n++) {
a->Get(n,val);
v->Push(o);
v->Push(n);
@ -668,14 +668,14 @@ static SQInteger array_filter(HRABBITVM v)
return 1;
}
static SQInteger array_find(HRABBITVM v)
static int64_t array_find(HRABBITVM v)
{
SQObject &o = stack_get(v,1);
SQObjectPtr &val = stack_get(v,2);
SQArray *a = _array(o);
SQInteger size = a->Size();
int64_t size = a->Size();
SQObjectPtr temp;
for(SQInteger n = 0; n < size; n++) {
for(int64_t n = 0; n < size; n++) {
bool res = false;
a->Get(n,temp);
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(!v->ObjCmp(a,b,ret)) return false;
}
else {
SQInteger top = sq_gettop(v);
int64_t top = sq_gettop(v);
sq_push(v, func);
sq_pushroottable(v);
v->Push(a);
@ -713,12 +713,12 @@ static bool _sort_compare(HRABBITVM v,SQObjectPtr &a,SQObjectPtr &b,SQInteger fu
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;
SQInteger done = 0;
SQInteger ret;
SQInteger root2;
int64_t maxChild;
int64_t done = 0;
int64_t ret;
int64_t root2;
while (((root2 = root * 2) <= bottom) && (!done))
{
if (root2 == bottom) {
@ -753,11 +753,11 @@ static bool _hsort_sift_down(HRABBITVM v,SQArray *arr, SQInteger root, SQInteger
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);
SQInteger i;
SQInteger array_size = a->Size();
int64_t i;
int64_t array_size = a->Size();
for (i = (array_size / 2); i >= 0; i--) {
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;
}
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);
if(_array(o)->Size() > 1) {
if(sq_gettop(v) == 2) func = 2;
@ -784,20 +784,20 @@ static SQInteger array_sort(HRABBITVM v)
return 1;
}
static SQInteger array_slice(HRABBITVM v)
static int64_t array_slice(HRABBITVM v)
{
SQInteger sidx,eidx;
int64_t sidx,eidx;
SQObjectPtr o;
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(eidx < 0)eidx = alen + eidx;
if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes"));
if(eidx > alen || sidx < 0)return sq_throwerror(v, _SC("slice out of range"));
SQArray *arr=SQArray::Create(_ss(v),eidx-sidx);
SQObjectPtr t;
SQInteger count=0;
for(SQInteger i=sidx;i<eidx;i++){
int64_t count=0;
for(int64_t i=sidx;i<eidx;i++){
_array(o)->Get(i,t);
arr->Set(count++,t);
}
@ -831,12 +831,12 @@ const SQRegFunction SQSharedState::_array_default_delegate_funcz[]={
};
//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;
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(eidx < 0)eidx = slen + eidx;
if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes"));
@ -845,16 +845,16 @@ static SQInteger string_slice(HRABBITVM v)
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;
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((sq_getsize(v,1)>start_idx) && (start_idx>=0)){
ret=scstrstr(&str[start_idx],substr);
if(ret){
sq_pushinteger(v,(SQInteger)(ret-str));
sq_pushinteger(v,(int64_t)(ret-str));
return 1;
}
}
@ -863,21 +863,21 @@ static SQInteger string_find(HRABBITVM v)
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; \
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(eidx < 0)eidx = slen + eidx; \
if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes")); \
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); \
SQChar *snew=(_ss(v)->GetScratchPad(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)); \
return 1; \
}
@ -910,12 +910,12 @@ const SQRegFunction SQSharedState::_number_default_delegate_funcz[]={
};
//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;
}
static SQInteger closure_call(HRABBITVM v)
static int64_t closure_call(HRABBITVM v)
{
SQObjectPtr &c = stack_get(v, -1);
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;
}
static SQInteger _closure_acall(HRABBITVM v,SQBool raiseerror)
static int64_t _closure_acall(HRABBITVM v,SQBool raiseerror)
{
SQArray *aparams=_array(stack_get(v,2));
SQInteger nparams=aparams->Size();
int64_t nparams=aparams->Size();
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;
}
static SQInteger closure_acall(HRABBITVM v)
static int64_t closure_acall(HRABBITVM v)
{
return _closure_acall(v,SQTrue);
}
static SQInteger closure_pacall(HRABBITVM v)
static int64_t closure_pacall(HRABBITVM v)
{
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)))
return SQ_ERROR;
return 1;
}
static SQInteger closure_getroot(HRABBITVM v)
static int64_t closure_getroot(HRABBITVM v)
{
if(SQ_FAILED(sq_getclosureroot(v,-1)))
return SQ_ERROR;
return 1;
}
static SQInteger closure_setroot(HRABBITVM v)
static int64_t closure_setroot(HRABBITVM v)
{
if(SQ_FAILED(sq_setclosureroot(v,-2)))
return SQ_ERROR;
return 1;
}
static SQInteger closure_getinfos(HRABBITVM v) {
static int64_t closure_getinfos(HRABBITVM v) {
SQObject o = stack_get(v,1);
SQTable *res = SQTable::Create(_ss(v),4);
if(sq_type(o) == OT_CLOSURE) {
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 defparams = SQArray::Create(_ss(v),f->_ndefaultparams);
for(SQInteger n = 0; n<f->_nparameters; n++) {
_array(params)->Set((SQInteger)n,f->_parameters[n]);
for(int64_t n = 0; n<f->_nparameters; n++) {
_array(params)->Set((int64_t)n,f->_parameters[n]);
}
for(SQInteger j = 0; j<f->_ndefaultparams; j++) {
_array(defparams)->Set((SQInteger)j,_closure(o)->_defaultparams[j]);
for(int64_t j = 0; j<f->_ndefaultparams; j++) {
_array(defparams)->Set((int64_t)j,_closure(o)->_defaultparams[j]);
}
if(f->_varparams) {
_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) {
typecheck =
SQArray::Create(_ss(v), nc->_typecheck.size());
for(SQUnsignedInteger n = 0; n<nc->_typecheck.size(); n++) {
_array(typecheck)->Set((SQInteger)n,nc->_typecheck[n]);
for(uint64_t n = 0; n<nc->_typecheck.size(); n++) {
_array(typecheck)->Set((int64_t)n,nc->_typecheck[n]);
}
}
res->NewSlot(SQString::Create(_ss(v),_SC("typecheck"),-1),typecheck);
@ -1025,7 +1025,7 @@ const SQRegFunction SQSharedState::_closure_default_delegate_funcz[]={
};
//GENERATOR DEFAULT DELEGATE
static SQInteger generator_getstatus(HRABBITVM v)
static int64_t generator_getstatus(HRABBITVM v)
{
SQObject &o=stack_get(v,1);
switch(_generator(o)->_state){
@ -1044,13 +1044,13 @@ const SQRegFunction SQSharedState::_generator_default_delegate_funcz[]={
};
//THREAD DEFAULT DELEGATE
static SQInteger thread_call(HRABBITVM v)
static int64_t thread_call(HRABBITVM v)
{
SQObjectPtr o = stack_get(v,1);
if(sq_type(o) == OT_THREAD) {
SQInteger nparams = sq_gettop(v);
int64_t nparams = sq_gettop(v);
_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);
if(SQ_SUCCEEDED(sq_call(_thread(o),nparams,SQTrue,SQTrue))) {
sq_move(v,_thread(o),-1);
@ -1063,12 +1063,12 @@ static SQInteger thread_call(HRABBITVM v)
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);
if(sq_type(o) == OT_THREAD) {
SQVM *thread = _thread(o);
SQInteger state = sq_getvmstate(thread);
int64_t state = sq_getvmstate(thread);
if(state != SQ_VMSTATE_SUSPENDED) {
switch(state) {
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) {
sq_move(thread,v,2);
}
@ -1099,12 +1099,12 @@ static SQInteger thread_wakeup(HRABBITVM v)
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);
if(sq_type(o) == OT_THREAD) {
SQVM *thread = _thread(o);
SQInteger state = sq_getvmstate(thread);
int64_t state = sq_getvmstate(thread);
if(state != SQ_VMSTATE_SUSPENDED) {
switch(state) {
case SQ_VMSTATE_IDLE:
@ -1140,7 +1140,7 @@ static SQInteger thread_wakeupthrow(HRABBITVM v)
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);
switch(sq_getvmstate(_thread(o))) {
@ -1159,13 +1159,13 @@ static SQInteger thread_getstatus(HRABBITVM v)
return 1;
}
static SQInteger thread_getstackinfos(HRABBITVM v)
static int64_t thread_getstackinfos(HRABBITVM v)
{
SQObjectPtr o = stack_get(v,1);
if(sq_type(o) == OT_THREAD) {
SQVM *thread = _thread(o);
SQInteger threadtop = sq_gettop(thread);
SQInteger level;
int64_t threadtop = sq_gettop(thread);
int64_t level;
sq_getinteger(v,-1,&level);
SQRESULT res = __getcallstackinfos(thread,level);
if(SQ_FAILED(res))
@ -1203,29 +1203,29 @@ const SQRegFunction SQSharedState::_thread_default_delegate_funcz[] = {
{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;
}
static SQInteger class_setattributes(HRABBITVM v)
static int64_t class_setattributes(HRABBITVM v)
{
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;
}
static SQInteger class_getbase(HRABBITVM v)
static int64_t class_getbase(HRABBITVM v)
{
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;
if(top == 5)
{
@ -1239,9 +1239,9 @@ static SQInteger class_newmember(HRABBITVM v)
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;
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)))
return 1;
@ -1288,7 +1288,7 @@ const SQRegFunction SQSharedState::_instance_default_delegate_funcz[] = {
{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)))
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;
}
if(belongs_to_static_table) {
SQInteger mmidx;
int64_t mmidx;
if((sq_type(val) == OT_CLOSURE || sq_type(val) == OT_NATIVECLOSURE) &&
(mmidx = ss->GetMetaMethodIdxByName(key)) != -1) {
_metamethods[mmidx] = val;
@ -78,7 +78,7 @@ bool SQClass::NewSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr
bool isconstructor;
SQVM::IsEqual(ss->_constructoridx, key, isconstructor);
if(isconstructor) {
_constructoridx = (SQInteger)_methods.size();
_constructoridx = (int64_t)_methods.size();
}
SQClassMember m;
m.val = theval;
@ -104,10 +104,10 @@ SQInstance *SQClass::CreateInstance()
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;
SQInteger idx = _members->Next(false,refpos,outkey,oval);
int64_t idx = _members->Next(false,refpos,outkey,oval);
if(idx != -1) {
if(_ismethod(oval)) {
outval = _methods[_member_idx(oval)].val;
@ -152,23 +152,23 @@ void SQInstance::Init(SQSharedState *ss)
_delegate = _class->_members;
}
SQInstance::SQInstance(SQSharedState *ss, SQClass *c, SQInteger memsize)
SQInstance::SQInstance(SQSharedState *ss, SQClass *c, int64_t memsize)
{
_memsize = memsize;
_class = c;
SQUnsignedInteger nvalues = _class->_defaultvalues.size();
for(SQUnsignedInteger n = 0; n < nvalues; n++) {
uint64_t nvalues = _class->_defaultvalues.size();
for(uint64_t n = 0; n < nvalues; n++) {
new (&_values[n]) SQObjectPtr(_class->_defaultvalues[n].val);
}
Init(ss);
}
SQInstance::SQInstance(SQSharedState *ss, SQInstance *i, SQInteger memsize)
SQInstance::SQInstance(SQSharedState *ss, SQInstance *i, int64_t memsize)
{
_memsize = memsize;
_class = i->_class;
SQUnsignedInteger nvalues = _class->_defaultvalues.size();
for(SQUnsignedInteger n = 0; n < nvalues; n++) {
uint64_t nvalues = _class->_defaultvalues.size();
for(uint64_t n = 0; n < nvalues; n++) {
new (&_values[n]) SQObjectPtr(i->_values[n]);
}
Init(ss);
@ -176,7 +176,7 @@ SQInstance::SQInstance(SQSharedState *ss, SQInstance *i, SQInteger memsize)
void SQInstance::Finalize()
{
SQUnsignedInteger nvalues = _class->_defaultvalues.size();
uint64_t nvalues = _class->_defaultvalues.size();
__ObjRelease(_class);
_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 _isfield(o) (_integer(o)&MEMBER_TYPE_FIELD)
#define _make_method_idx(i) ((SQInteger)(MEMBER_TYPE_METHOD|i))
#define _make_field_idx(i) ((SQInteger)(MEMBER_TYPE_FIELD|i))
#define _make_method_idx(i) ((int64_t)(MEMBER_TYPE_METHOD|i))
#define _make_field_idx(i) ((int64_t)(MEMBER_TYPE_FIELD|i))
#define _member_type(o) (_integer(o)&0xFF000000)
#define _member_idx(o) (_integer(o)&0x00FFFFFF)
@ -70,7 +70,7 @@ public:
sq_delete(this, SQClass);
}
void Finalize();
SQInteger Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval);
int64_t Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval);
SQInstance *CreateInstance();
SQTable *_members;
SQClass *_base;
@ -81,8 +81,8 @@ public:
SQUserPointer _typetag;
SQRELEASEHOOK _hook;
bool _locked;
SQInteger _constructoridx;
SQInteger _udsize;
int64_t _constructoridx;
int64_t _udsize;
};
#define calcinstancesize(_theclass_) \
@ -91,12 +91,12 @@ public:
struct SQInstance : public SQDelegable
{
void Init(SQSharedState *ss);
SQInstance(SQSharedState *ss, SQClass *c, SQInteger memsize);
SQInstance(SQSharedState *ss, SQInstance *c, SQInteger memsize);
SQInstance(SQSharedState *ss, SQClass *c, int64_t memsize);
SQInstance(SQSharedState *ss, SQInstance *c, int64_t memsize);
public:
static SQInstance* Create(SQSharedState *ss,SQClass *theclass) {
SQInteger size = calcinstancesize(theclass);
int64_t size = calcinstancesize(theclass);
SQInstance *newinst = (SQInstance *)SQ_MALLOC(size);
new (newinst) SQInstance(ss, theclass,size);
if(theclass->_udsize) {
@ -106,7 +106,7 @@ public:
}
SQInstance *Clone(SQSharedState *ss)
{
SQInteger size = calcinstancesize(_class);
int64_t size = calcinstancesize(_class);
SQInstance *newinst = (SQInstance *)SQ_MALLOC(size);
new (newinst) SQInstance(ss, this,size);
if(_class->_udsize) {
@ -141,7 +141,7 @@ public:
if (_hook) { _hook(_userpointer,0);}
_uiRef--;
if(_uiRef > 0) return;
SQInteger size = _memsize;
int64_t size = _memsize;
this->~SQInstance();
SQ_FREE(this, size);
}
@ -152,7 +152,7 @@ public:
SQClass *_class;
SQUserPointer _userpointer;
SQRELEASEHOOK _hook;
SQInteger _memsize;
int64_t _memsize;
SQObjectPtr _values[1];
};

18
rabbit/sqclosure.hpp
View File

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

258
rabbit/sqcompiler.cpp
View File

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

52
rabbit/sqconfig.hpp
View File

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

18
rabbit/sqdebug.cpp
View File

@ -13,9 +13,9 @@
#include <rabbit/sqclosure.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) {
SQVM::CallInfo &ci = v->_callsstack[cssize-level-1];
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"));
}
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) {
memset(si, 0, sizeof(SQStackInfos));
SQVM::CallInfo &ci = v->_callsstack[cssize-level-1];
@ -65,7 +65,7 @@ void SQVM::Raise_Error(const SQChar *s, ...)
{
va_list vl;
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);
va_end(vl);
_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);
SQInteger found = 0;
for(SQInteger i=0; i<16; i++)
int64_t found = 0;
for(int64_t i=0; i<16; i++)
{
SQInteger mask = ((SQInteger)1) << i;
int64_t mask = ((int64_t)1) << i;
if(typemask & (mask)) {
if(found>0) StringCat(exptypes,SQString::Create(_ss(this), _SC("|"), -1), exptypes);
found ++;

48
rabbit/sqfuncproto.hpp
View File

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

142
rabbit/sqfuncstate.cpp
View File

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

78
rabbit/sqlexer.cpp
View File

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

32
rabbit/sqlexer.hpp
View File

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

6
rabbit/sqmem.cpp
View File

@ -9,9 +9,9 @@
#include <rabbit/sqpcheader.hpp>
#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

140
rabbit/sqobject.cpp
View File

@ -50,7 +50,7 @@ const SQChar *GetTypeName(const SQObjectPtr &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);
return str;
@ -61,12 +61,12 @@ void SQString::Release()
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){
outkey = (SQInteger)idx;
outval = (SQInteger)((SQUnsignedInteger)_val[idx]);
outkey = (int64_t)idx;
outval = (int64_t)((uint64_t)_val[idx]);
//return idx for the next iteration
return ++idx;
}
@ -74,13 +74,13 @@ SQInteger SQString::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjec
return -1;
}
SQUnsignedInteger TranslateIndex(const SQObjectPtr &idx)
uint64_t TranslateIndex(const SQObjectPtr &idx)
{
switch(sq_type(idx)){
case OT_NULL:
return 0;
case OT_INTEGER:
return (SQUnsignedInteger)_integer(idx);
return (uint64_t)_integer(idx);
default: assert(0); break;
}
return 0;
@ -135,26 +135,26 @@ bool SQDelegable::SetDelegate(SQTable *mt)
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==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);
SQObject _this = v->_stack[v->_stackbase];
_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];
}
for(SQInteger j =0; j < size; j++)
for(int64_t j =0; j < size; j++)
{
v->_stack[v->_stackbase+j].Null();
}
_ci = *v->ci;
_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());
v->_etraps.pop_back();
// 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==eRunning){ v->Raise_Error(_SC("resuming active generator")); return false; }
SQInteger size = _stack.size();
SQInteger target = &dest - &(v->_stack._vals[v->_stackbase]);
int64_t size = _stack.size();
int64_t target = &dest - &(v->_stack._vals[v->_stackbase]);
assert(target>=0 && target<=255);
SQInteger newbase = v->_top;
int64_t newbase = v->_top;
if(!v->EnterFrame(v->_top, v->_top + size, false))
return false;
v->ci->_generator = this;
v->ci->_target = (SQInt32)target;
v->ci->_target = (int32_t)target;
v->ci->_closure = _ci._closure;
v->ci->_ip = _ci._ip;
v->ci->_literals = _ci._literals;
@ -186,7 +186,7 @@ bool SQGenerator::Resume(SQVM *v,SQObjectPtr &dest)
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());
_etraps.pop_back();
SQExceptionTrap &et = v->_etraps.back();
@ -197,7 +197,7 @@ bool SQGenerator::Resume(SQVM *v,SQObjectPtr &dest)
SQObject _this = _stack._vals[0];
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];
_stack._vals[n].Null();
}
@ -210,18 +210,18 @@ bool SQGenerator::Resume(SQVM *v,SQObjectPtr &dest)
}
void SQArray::Extend(const SQArray *a){
SQInteger xlen;
int64_t xlen;
if((xlen=a->Size()))
for(SQInteger i=0;i<xlen;i++)
for(int64_t i=0;i<xlen;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;
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(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);
SQInteger line=_lineinfos[0]._line;
SQInteger low = 0;
SQInteger high = _nlineinfos - 1;
SQInteger mid = 0;
int64_t op = (int64_t)(curr-_instructions);
int64_t line=_lineinfos[0]._line;
int64_t low = 0;
int64_t high = _nlineinfos - 1;
int64_t mid = 0;
while(low <= high)
{
mid = low + ((high - low) >> 1);
SQInteger curop = _lineinfos[mid]._op;
int64_t curop = _lineinfos[mid]._op;
if(curop > op)
{
high = mid - 1;
@ -279,7 +279,7 @@ SQClosure::~SQClosure()
}
#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) {
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;
}
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) {
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;
}
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));
}
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)));
if(t != tag){
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)
{
SQUnsignedInteger32 _type = (SQUnsignedInteger32)sq_type(o);
uint32_t _type = (uint32_t)sq_type(o);
_CHECK_IO(SafeWrite(v,write,up,&_type,sizeof(_type)));
switch(sq_type(o)){
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)));
break;
case OT_BOOL:
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:
_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:
break;
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)
{
SQUnsignedInteger32 _type;
uint32_t _type;
_CHECK_IO(SafeRead(v,read,up,&_type,sizeof(_type)));
SQObjectType t = (SQObjectType)_type;
switch(t){
case OT_STRING:{
SQInteger len;
_CHECK_IO(SafeRead(v,read,up,&len,sizeof(SQInteger)));
int64_t len;
_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)));
o=SQString::Create(_ss(v),_ss(v)->GetScratchPad(-1),len);
}
break;
case OT_INTEGER:{
SQInteger i;
_CHECK_IO(SafeRead(v,read,up,&i,sizeof(SQInteger))); o = i; break;
int64_t i;
_CHECK_IO(SafeRead(v,read,up,&i,sizeof(int64_t))); o = i; break;
}
case OT_BOOL:{
SQInteger i;
_CHECK_IO(SafeRead(v,read,up,&i,sizeof(SQInteger))); o._type = OT_BOOL; o._unVal.nInteger = i; break;
int64_t i;
_CHECK_IO(SafeRead(v,read,up,&i,sizeof(int64_t))); o._type = OT_BOOL; o._unVal.nInteger = i; break;
}
case OT_FLOAT:{
SQFloat f;
_CHECK_IO(SafeRead(v,read,up,&f,sizeof(SQFloat))); o = f; break;
float_t f;
_CHECK_IO(SafeRead(v,read,up,&f,sizeof(float_t))); o = f; break;
}
case OT_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,sizeof(SQChar)));
_CHECK_IO(WriteTag(v,write,up,sizeof(SQInteger)));
_CHECK_IO(WriteTag(v,write,up,sizeof(SQFloat)));
_CHECK_IO(WriteTag(v,write,up,sizeof(int64_t)));
_CHECK_IO(WriteTag(v,write,up,sizeof(float_t)));
_CHECK_IO(_function->Save(v,up,write));
_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_TAIL));
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,sizeof(SQChar)));
_CHECK_IO(CheckTag(v,read,up,sizeof(SQInteger)));
_CHECK_IO(CheckTag(v,read,up,sizeof(SQFloat)));
_CHECK_IO(CheckTag(v,read,up,sizeof(int64_t)));
_CHECK_IO(CheckTag(v,read,up,sizeof(float_t)));
SQObjectPtr func;
_CHECK_IO(SQFunctionProto::Load(v,up,read,func));
_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_TAIL));
@ -408,10 +408,10 @@ SQFunctionProto::~SQFunctionProto()
bool SQFunctionProto::Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write)
{
SQInteger i,nliterals = _nliterals,nparameters = _nparameters;
SQInteger noutervalues = _noutervalues,nlocalvarinfos = _nlocalvarinfos;
SQInteger nlineinfos=_nlineinfos,ninstructions = _ninstructions,nfunctions=_nfunctions;
SQInteger ndefaultparams = _ndefaultparams;
int64_t i,nliterals = _nliterals,nparameters = _nparameters;
int64_t noutervalues = _noutervalues,nlocalvarinfos = _nlocalvarinfos;
int64_t nlineinfos=_nlineinfos,ninstructions = _ninstructions,nfunctions=_nfunctions;
int64_t ndefaultparams = _ndefaultparams;
_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
_CHECK_IO(WriteObject(v,up,write,_sourcename));
_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));
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]._name));
}
@ -445,16 +445,16 @@ bool SQFunctionProto::Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write)
for(i=0;i<nlocalvarinfos;i++){
SQLocalVarInfo &lvi=_localvarinfos[i];
_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._start_op,sizeof(SQUnsignedInteger)));
_CHECK_IO(SafeWrite(v,write,up,&lvi._end_op,sizeof(SQUnsignedInteger)));
_CHECK_IO(SafeWrite(v,write,up,&lvi._pos,sizeof(uint64_t)));
_CHECK_IO(SafeWrite(v,write,up,&lvi._start_op,sizeof(uint64_t)));
_CHECK_IO(SafeWrite(v,write,up,&lvi._end_op,sizeof(uint64_t)));
}
_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
_CHECK_IO(SafeWrite(v,write,up,_lineinfos,sizeof(SQLineInfo)*nlineinfos));
_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(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)
{
SQInteger i, nliterals,nparameters;
SQInteger noutervalues ,nlocalvarinfos ;
SQInteger nlineinfos,ninstructions ,nfunctions,ndefaultparams ;
int64_t i, nliterals,nparameters;
int64_t noutervalues ,nlocalvarinfos ;
int64_t nlineinfos,ninstructions ,nfunctions,ndefaultparams ;
SQObjectPtr sourcename, name;
SQObjectPtr o;
_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));
for(i = 0; i < noutervalues; i++){
SQUnsignedInteger type;
uint64_t type;
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, name));
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++){
SQLocalVarInfo lvi;
_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._start_op, sizeof(SQUnsignedInteger)));
_CHECK_IO(SafeRead(v,read,up, &lvi._end_op, sizeof(SQUnsignedInteger)));
_CHECK_IO(SafeRead(v,read,up, &lvi._pos, sizeof(uint64_t)));
_CHECK_IO(SafeRead(v,read,up, &lvi._start_op, sizeof(uint64_t)));
_CHECK_IO(SafeRead(v,read,up, &lvi._end_op, sizeof(uint64_t)));
f->_localvarinfos[i] = lvi;
}
_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
_CHECK_IO(SafeRead(v,read,up, f->_lineinfos, sizeof(SQLineInfo)*nlineinfos));
_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(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) { \
for(SQInteger n = 0; n < ((SQInteger)size); n++) { \
for(int64_t n = 0; n < ((int64_t)size); n++) { \
new (&ptr[n]) type(); \
} \
}
#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(); \
} \
}
#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_]; \
} \
}
#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(); \
} \
}
@ -91,7 +91,7 @@ enum SQMetaMethod{
struct SQRefCounted
{
SQUnsignedInteger _uiRef;
uint64_t _uiRef;
struct SQWeakRef *_weakref;
SQRefCounted() { _uiRef = 0; _weakref = NULL; }
virtual ~SQRefCounted();
@ -159,8 +159,8 @@ struct SQObjectPtr;
#define _stringval(obj) (obj)._unVal.pString->_val
#define _userdataval(obj) ((SQUserPointer)sq_aligning((obj)._unVal.pUserData + 1))
#define tofloat(num) ((sq_type(num)==OT_INTEGER)?(SQFloat)_integer(num):_float(num))
#define tointeger(num) ((sq_type(num)==OT_FLOAT)?(SQInteger)_float(num):_integer(num))
#define tofloat(num) ((sq_type(num)==OT_INTEGER)?(float_t)_integer(num):_float(num))
#define tointeger(num) ((sq_type(num)==OT_FLOAT)?(int64_t)_float(num):_integer(num))
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
#if defined(SQUSEDOUBLE) && !defined(_SQ64) || !defined(SQUSEDOUBLE) && defined(_SQ64)
@ -241,8 +241,8 @@ struct SQObjectPtr : public SQObject
_REF_TYPE_DECL(OT_THREAD,SQVM,pThread)
_REF_TYPE_DECL(OT_FUNCPROTO,SQFunctionProto,pFunctionProto)
_SCALAR_TYPE_DECL(OT_INTEGER,SQInteger,nInteger)
_SCALAR_TYPE_DECL(OT_FLOAT,SQFloat,fFloat)
_SCALAR_TYPE_DECL(OT_INTEGER,int64_t,nInteger)
_SCALAR_TYPE_DECL(OT_FLOAT,float_t,fFloat)
_SCALAR_TYPE_DECL(OT_USERPOINTER,SQUserPointer,pUserPointer)
SQObjectPtr(bool bBool)
@ -319,9 +319,9 @@ struct SQDelegable : public SQRefCounted {
SQTable *_delegate;
};
SQUnsignedInteger TranslateIndex(const SQObjectPtr &idx);
uint64_t TranslateIndex(const SQObjectPtr &idx);
typedef sqvector<SQObjectPtr> SQObjectPtrVec;
typedef sqvector<SQInteger> SQIntVec;
typedef sqvector<int64_t> SQIntVec;
const SQChar *GetTypeName(const SQObjectPtr &obj1);
const SQChar *IdType2Name(SQObjectType type);

8
rabbit/sqopcodes.hpp
View File

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

44
rabbit/sqstate.cpp
View File

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

28
rabbit/sqstate.hpp
View File

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

6
rabbit/sqstring.hpp
View File

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

26
rabbit/sqtable.cpp
View File

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

24
rabbit/sqtable.hpp
View File

@ -16,14 +16,14 @@
#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)
{
switch(sq_type(key)) {
case OT_STRING: return _string(key)->_hash;
case OT_FLOAT: return (SQHash)((SQInteger)_float(key));
case OT_BOOL: case OT_INTEGER: return (SQHash)((SQInteger)_integer(key));
case OT_FLOAT: return (SQHash)((int64_t)_float(key));
case OT_BOOL: case OT_INTEGER: return (SQHash)((int64_t)_integer(key));
default: return hashptr(key._unVal.pRefCounted);
}
}
@ -40,16 +40,16 @@ private:
};
_HashNode *_firstfree;
_HashNode *_nodes;
SQInteger _numofnodes;
SQInteger _usednodes;
int64_t _numofnodes;
int64_t _usednodes;
///////////////////////////
void AllocNodes(SQInteger nSize);
void AllocNodes(int64_t nSize);
void Rehash(bool force);
SQTable(SQSharedState *ss, SQInteger nInitialSize);
SQTable(SQSharedState *ss, int64_t nInitialSize);
void _ClearNodes();
public:
static SQTable* Create(SQSharedState *ss,SQInteger nInitialSize)
static SQTable* Create(SQSharedState *ss,int64_t nInitialSize)
{
SQTable *newtable = (SQTable*)SQ_MALLOC(sizeof(SQTable));
new (newtable) SQTable(ss, nInitialSize);
@ -61,7 +61,7 @@ public:
~SQTable()
{
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));
}
inline _HashNode *_Get(const SQObjectPtr &key,SQHash hash)
@ -75,7 +75,7 @@ public:
return NULL;
}
//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);
_HashNode *n = &_nodes[hash & (_numofnodes - 1)];
@ -97,9 +97,9 @@ public:
bool Set(const SQObjectPtr &key, const SQObjectPtr &val);
//returns true if a new slot has been created false if it was already present
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 Release()
{

34
rabbit/squtils.hpp
View File

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

228
rabbit/sqvm.cpp
View File

@ -22,19 +22,19 @@
#define TARGET _stack._vals[_stackbase+arg0]
#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)
{
SQInteger i1 = _integer(o1), i2 = _integer(o2);
int64_t i1 = _integer(o1), i2 = _integer(o2);
switch(op) {
case BW_AND: res = i1 & i2; break;
case BW_OR: res = i1 | i2; break;
case BW_XOR: res = i1 ^ i2; break;
case BW_SHIFTL: 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; }
}
}
@ -45,7 +45,7 @@ bool SQVM::BW_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,con
#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) { \
case OT_INTEGER: trg = _integer(o1) op _integer(o2);break; \
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) \
{ \
SQInteger tmask = sq_type(o1)|sq_type(o2); \
int64_t tmask = sq_type(o1)|sq_type(o2); \
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): trg = tofloat(o1) op tofloat(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) {
case OT_INTEGER:{
SQInteger res, i1 = _integer(o1), i2 = _integer(o2);
int64_t res, i1 = _integer(o1), i2 = _integer(o2);
switch(op) {
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;
case (OT_FLOAT|OT_INTEGER):
case (OT_FLOAT):{
SQFloat res, f1 = tofloat(o1), f2 = tofloat(o2);
float_t res, f1 = tofloat(o1), f2 = tofloat(o2);
switch(op) {
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;
}
trg = res; }
@ -143,8 +143,8 @@ void SQVM::Finalize()
_debughook_closure.Null();
temp_reg.Null();
_callstackdata.resize(0);
SQInteger size=_stack.size();
for(SQInteger i=0;i<size;i++)
int64_t size=_stack.size();
for(int64_t i=0;i<size;i++)
_stack[i].Null();
}
@ -153,7 +153,7 @@ SQVM::~SQVM()
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;
switch(op){
@ -206,7 +206,7 @@ bool SQVM::NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o)
}
#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);
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)
{
SQInteger r;
int64_t r;
if(ObjCmp(o1,o2,r)) {
switch(op) {
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;
if(!ToString(str, a)) 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));
memcpy(s, _stringval(a), sq_rsl(l));
memcpy(s + l, _stringval(b), sq_rsl(ol));
@ -348,7 +348,7 @@ bool SQVM::TypeOf(const SQObjectPtr &obj1,SQObjectPtr &dest)
return true;
}
bool SQVM::Init(SQVM *friendvm, SQInteger stacksize)
bool SQVM::Init(SQVM *friendvm, int64_t stacksize)
{
_stack.resize(stacksize);
_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;
SQInteger paramssize = func->_nparameters;
const SQInteger newtop = stackbase + func->_stacksize;
SQInteger nargs = args;
int64_t paramssize = func->_nparameters;
const int64_t newtop = stackbase + func->_stacksize;
int64_t nargs = args;
if(func->_varparams)
{
paramssize--;
@ -390,10 +390,10 @@ bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger args,SQIntege
}
//dumpstack(stackbase);
SQInteger nvargs = nargs - paramssize;
int64_t nvargs = nargs - paramssize;
SQArray *arr = SQArray::Create(_ss(this),nvargs);
SQInteger pbase = stackbase+paramssize;
for(SQInteger n = 0; n < nvargs; n++) {
int64_t pbase = stackbase+paramssize;
for(int64_t n = 0; n < nvargs; n++) {
arr->_values[n] = _stack._vals[pbase];
_stack._vals[pbase].Null();
pbase++;
@ -403,10 +403,10 @@ bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger args,SQIntege
//dumpstack(stackbase);
}
else if (paramssize != nargs) {
SQInteger ndef = func->_ndefaultparams;
SQInteger diff;
int64_t ndef = func->_ndefaultparams;
int64_t diff;
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];
}
}
@ -425,7 +425,7 @@ bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger args,SQIntege
ci->_closure = closure;
ci->_literals = func->_literals;
ci->_ip = func->_instructions;
ci->_target = (SQInt32)target;
ci->_target = (int32_t)target;
if (_debughook) {
CallDebugHook(_SC('c'));
@ -445,13 +445,13 @@ bool SQVM::StartCall(SQClosure *closure,SQInteger target,SQInteger args,SQIntege
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;
SQInteger callerbase = _stackbase - ci->_prevstkbase;
int64_t callerbase = _stackbase - ci->_prevstkbase;
if (_debughook) {
for(SQInteger i=0; i<ci->_ncalls; i++) {
for(int64_t i=0; i<ci->_ncalls; i++) {
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; }
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;
_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;
}
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;
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 sarg0 ((SQInteger)*((const signed char *)&_i_._arg0))
#define sarg0 ((int64_t)*((const signed char *)&_i_._arg0))
#define arg1 (_i_._arg1)
#define sarg1 (*((const SQInt32 *)&_i_._arg1))
#define sarg1 (*((const int32_t *)&_i_._arg1))
#define arg2 (_i_._arg2)
#define arg3 (_i_._arg3)
#define sarg3 ((SQInteger)*((const signed char *)&_i_._arg3))
#define sarg3 ((int64_t)*((const signed char *)&_i_._arg3))
SQRESULT SQVM::Suspend()
{
@ -518,22 +518,22 @@ SQRESULT SQVM::Suspend()
#define _FINISH(howmuchtojump) {jump = howmuchtojump; return true; }
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)) {
case OT_TABLE:
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:
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:
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:
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_INSTANCE:
if(_delegable(o1)->_delegate) {
@ -562,7 +562,7 @@ bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr
case OT_GENERATOR:
if(_generator(o1)->_state == SQGenerator::eDead) _FINISH(exitpos);
if(_generator(o1)->_state == SQGenerator::eSuspended) {
SQInteger idx = 0;
int64_t idx = 0;
if(sq_type(o4) == OT_INTEGER) {
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)
{
SQInteger nouters;
int64_t nouters;
SQClosure *closure = SQClosure::Create(_ss(this), func,_table(_roottable)->GetWeakRef(OT_TABLE));
if((nouters = func->_noutervalues)) {
for(SQInteger i = 0; i<nouters; i++) {
for(int64_t i = 0; i<nouters; i++) {
SQOuterVar &v = func->_outervalues[i];
switch(v._type){
case otLOCAL:
@ -600,10 +600,10 @@ bool SQVM::CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func)
}
}
}
SQInteger ndefparams;
int64_t ndefparams;
if((ndefparams = func->_ndefaultparams)) {
for(SQInteger i = 0; i < ndefparams; i++) {
SQInteger spos = func->_defaultparams[i];
for(int64_t i = 0; i < ndefparams; i++) {
int64_t spos = func->_defaultparams[i];
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;
SQObjectPtr attrs;
@ -658,7 +658,7 @@ bool SQVM::IsEqual(const SQObjectPtr &o1,const SQObjectPtr &o2,bool &res)
bool SQVM::IsFalse(SQObjectPtr &o)
{
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))
|| (_integer(o) == 0) ) //OT_NULL|OT_INTEGER|OT_BOOL
#else
@ -670,12 +670,12 @@ bool SQVM::IsFalse(SQObjectPtr &o)
return false;
}
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; }
_nnativecalls++;
AutoDec ad(&_nnativecalls);
SQInteger traps = 0;
int64_t traps = 0;
CallInfo *prevci = ci;
switch(et) {
@ -717,20 +717,20 @@ exception_restore:
case _OP_LOAD: TARGET = ci->_literals[arg1]; continue;
case _OP_LOADINT:
#ifndef _SQ64
TARGET = (SQInteger)arg1; continue;
TARGET = (int64_t)arg1; continue;
#else
TARGET = (SQInteger)((SQInt32)arg1); continue;
TARGET = (int64_t)((int32_t)arg1); continue;
#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_TAILCALL:{
SQObjectPtr &t = STK(arg1);
if (sq_type(t) == OT_CLOSURE
&& (!_closure(t)->_function->_bgenerator)){
SQObjectPtr clo = t;
SQInteger last_top = _top;
int64_t last_top = _top;
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));
if (last_top >= _top) {
_top = last_top;
@ -747,7 +747,7 @@ exception_restore:
case OT_NATIVECLOSURE: {
bool suspend;
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){
_suspended = SQTrue;
_suspended_target = sarg0;
@ -767,7 +767,7 @@ exception_restore:
if(sarg0 != -1) {
STK(arg0) = inst;
}
SQInteger stkbase;
int64_t stkbase;
switch(sq_type(clo)) {
case OT_CLOSURE:
stkbase = _stackbase+arg2;
@ -790,7 +790,7 @@ exception_restore:
SQObjectPtr closure;
if(_delegable(clo)->_delegate && _delegable(clo)->GetMetaMethod(this,MT_CALL,closure)) {
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(sarg0 != -1) {
STK(arg0) = clo;
@ -863,7 +863,7 @@ exception_restore:
return true;
}
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: {
SQWeakRef *w = _closure(ci->_closure)->_root;
if(sq_type(w->_obj) != OT_NULL) {
@ -916,14 +916,14 @@ exception_restore:
case AAT_INT:
val._type = OT_INTEGER;
#ifndef _SQ64
val._unVal.nInteger = (SQInteger)arg1;
val._unVal.nInteger = (int64_t)arg1;
#else
val._unVal.nInteger = (SQInteger)((SQInt32)arg1);
val._unVal.nInteger = (int64_t)((int32_t)arg1);
#endif
break;
case AAT_FLOAT:
val._type = OT_FLOAT;
val._unVal.fFloat = *((const SQFloat *)&arg1);
val._unVal.fFloat = *((const float_t *)&arg1);
break;
case AAT_BOOL:
val._type = OT_BOOL;
@ -935,7 +935,7 @@ exception_restore:
_array(STK(arg0))->Append(val); continue;
}
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));
}
continue;
@ -985,8 +985,8 @@ exception_restore:
case _OP_NOT: TARGET = IsFalse(STK(arg1)); continue;
case _OP_BWNOT:
if(sq_type(STK(arg1)) == OT_INTEGER) {
SQInteger t = _integer(STK(arg1));
TARGET = SQInteger(~t);
int64_t t = _integer(STK(arg1));
TARGET = int64_t(~t);
continue;
}
Raise_Error(_SC("attempt to perform a bitwise op on a %s"), GetTypeName(STK(arg1)));
@ -1036,7 +1036,7 @@ exception_restore:
}
continue;
case _OP_POPTRAP: {
for(SQInteger i = 0; i < arg0; i++) {
for(int64_t i = 0; i < arg0; i++) {
_etraps.pop_back(); traps--;
ci->_etraps--;
}
@ -1067,8 +1067,8 @@ exception_trap:
{
SQObjectPtr currerror = _lasterror;
// dumpstack(_stackbase);
// SQInteger n = 0;
SQInteger last_top = _top;
// int64_t n = 0;
int64_t last_top = _top;
if(_ss(this)->_notifyallexceptions || (!traps && raiseerror)) CallErrorHandler(currerror);
@ -1086,7 +1086,7 @@ exception_trap:
else if (_debughook) {
//notify debugger of a "return"
//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'));
}
}
@ -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;
SQFunctionProto *func=_closure(ci->_closure)->_function;
if(_debughook_native) {
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;
SQInteger line = forcedline?forcedline:func->GetLine(ci->_ip);
int64_t line = forcedline?forcedline:func->GetLine(ci->_ip);
_debughook_native(this,type,src,line,fname);
}
else {
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);
Call(_debughook_closure,nparams,_top-nparams,temp_reg,SQFalse);
Pop(nparams);
@ -1142,10 +1142,10 @@ void SQVM::CallDebugHook(SQInteger type,SQInteger forcedline)
_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;
SQInteger newtop = newbase + nargs + nclosure->_noutervalues;
int64_t nparamscheck = nclosure->_nparamscheck;
int64_t newtop = newbase + nargs + nclosure->_noutervalues;
if (_nnativecalls + 1 > MAX_NATIVE_CALLS) {
Raise_Error(_SC("Native stack overflow"));
@ -1159,10 +1159,10 @@ bool SQVM::CallNative(SQNativeClosure *nclosure, SQInteger nargs, SQInteger newb
return false;
}
SQInteger tcs;
int64_t tcs;
SQIntVec &tc = nclosure->_typecheck;
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])) {
Raise_ParamTypeError(i,tc._vals[i], sq_type(_stack._vals[newbase+i]));
return false;
@ -1174,8 +1174,8 @@ bool SQVM::CallNative(SQNativeClosure *nclosure, SQInteger nargs, SQInteger newb
ci->_closure = nclosure;
ci->_target = target;
SQInteger outers = nclosure->_noutervalues;
for (SQInteger i = 0; i < outers; i++) {
int64_t outers = nclosure->_noutervalues;
for (int64_t i = 0; i < outers; i++) {
_stack._vals[newbase+nargs+i] = nclosure->_outervalues[i];
}
if(nclosure->_env) {
@ -1183,7 +1183,7 @@ bool SQVM::CallNative(SQNativeClosure *nclosure, SQInteger nargs, SQInteger newb
}
_nnativecalls++;
SQInteger ret = (nclosure->_function)(this);
int64_t ret = (nclosure->_function)(this);
_nnativecalls--;
suspend = false;
@ -1211,16 +1211,16 @@ bool SQVM::CallNative(SQNativeClosure *nclosure, SQInteger nargs, SQInteger newb
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;
if (ci->_root)
{
Raise_Error("root calls cannot invoke tailcalls");
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);
if (last_top >= _top) {
_top = last_top;
@ -1232,7 +1232,7 @@ bool SQVM::TailCall(SQClosure *closure, SQInteger parambase,SQInteger nparams)
#define FALLBACK_NO_MATCH 1
#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)){
case OT_TABLE:
@ -1249,11 +1249,11 @@ bool SQVM::Get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &des
break;
case OT_STRING:
if(sq_isnumeric(key)){
SQInteger n = tointeger(key);
SQInteger len = _string(self)->_len;
int64_t n = tointeger(key);
int64_t len = _string(self)->_len;
if (n < 0) { n += len; }
if (n >= 0 && n < len) {
dest = SQInteger(_stringval(self)[n]);
dest = int64_t(_stringval(self)[n]);
return true;
}
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)){
case OT_TABLE:
@ -1344,7 +1344,7 @@ SQInteger SQVM::FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObj
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)){
case OT_TABLE:
@ -1379,7 +1379,7 @@ bool SQVM::Set(const SQObjectPtr &self,const SQObjectPtr &key,const SQObjectPtr
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)) {
case OT_TABLE:
@ -1567,10 +1567,10 @@ bool SQVM::DeleteSlot(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr
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
SQInteger prevstackbase = _stackbase;
int64_t prevstackbase = _stackbase;
#endif
switch(sq_type(closure)) {
case OT_CLOSURE:
@ -1605,7 +1605,7 @@ SQInteger prevstackbase = _stackbase;
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;
@ -1642,15 +1642,15 @@ void SQVM::FindOuter(SQObjectPtr &target, SQObjectPtr *stackindex)
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( _callsstacksize == _alloccallsstacksize ) {
GrowCallStack();
}
ci = &_callsstack[_callsstacksize++];
ci->_prevstkbase = (SQInt32)(newbase - _stackbase);
ci->_prevtop = (SQInt32)(_top - _stackbase);
ci->_prevstkbase = (int32_t)(newbase - _stackbase);
ci->_prevtop = (int32_t)(_top - _stackbase);
ci->_etraps = 0;
ci->_ncalls = 1;
ci->_generator = NULL;
@ -1662,7 +1662,7 @@ bool SQVM::EnterFrame(SQInteger newbase, SQInteger newtop, bool tailcall)
_stackbase = newbase;
_top = newtop;
if(newtop + MIN_STACK_OVERHEAD > (SQInteger)_stack.size()) {
if(newtop + MIN_STACK_OVERHEAD > (int64_t)_stack.size()) {
if(_nmetamethodscall) {
Raise_Error(_SC("stack overflow, cannot resize stack while in a metamethod"));
return false;
@ -1674,9 +1674,9 @@ bool SQVM::EnterFrame(SQInteger newbase, SQInteger newtop, bool tailcall)
}
void SQVM::LeaveFrame() {
SQInteger last_top = _top;
SQInteger last_stackbase = _stackbase;
SQInteger css = --_callsstacksize;
int64_t last_top = _top;
int64_t last_stackbase = _stackbase;
int64_t css = --_callsstacksize;
/* First clean out the call stack frame */
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;
for(SQInteger i = n; i < _top; i++){
for(int64_t i = n; i < _top; i++){
_stack[i] = _stack[i+1];
}
_stack[_top].Null();
@ -1722,8 +1722,8 @@ void SQVM::Pop() {
_stack[--_top].Null();
}
void SQVM::Pop(SQInteger n) {
for(SQInteger i = 0; i < n; i++){
void SQVM::Pop(int64_t n) {
for(int64_t i = 0; i < n; i++){
_stack[--_top].Null();
}
}
@ -1732,20 +1732,20 @@ void SQVM::PushNull() { _stack[_top++].Null(); }
void SQVM::Push(const SQObjectPtr &o) { _stack[_top++] = o; }
SQObjectPtr &SQVM::Top() { return _stack[_top-1]; }
SQObjectPtr &SQVM::PopGet() { return _stack[--_top]; }
SQObjectPtr &SQVM::GetUp(SQInteger n) { return _stack[_top+n]; }
SQObjectPtr &SQVM::GetAt(SQInteger n) { return _stack[n]; }
SQObjectPtr &SQVM::GetUp(int64_t n) { return _stack[_top+n]; }
SQObjectPtr &SQVM::GetAt(int64_t n) { return _stack[n]; }
#ifdef _DEBUG_DUMP
void SQVM::dumpstack(SQInteger stackbase,bool dumpall)
void SQVM::dumpstack(int64_t stackbase,bool dumpall)
{
SQInteger size=dumpall?_stack.size():_top;
SQInteger n=0;
int64_t size=dumpall?_stack.size():_top;
int64_t n=0;
scprintf(_SC("\n>>>>stack dump<<<<\n"));
CallInfo &ci=_callsstack[_callsstacksize-1];
scprintf(_SC("IP: %p\n"),ci._ip);
scprintf(_SC("prev stack base: %d\n"),ci._prevstkbase);
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];
if(stackbase==i)scprintf(_SC(">"));else scprintf(_SC(" "));
scprintf(_SC("[" _PRINT_INT_FMT "]:"),n);

108
rabbit/sqvm.hpp
View File

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