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

[DEV] remove basic unicode(step 1)

Browse Source
This commit is contained in:
Edouard DUPIN 2018-07-01 21:56:13 +02:00
parent ad27afec61
commit c6875d59bf
41 changed files with 393 additions and 630 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
cmdLine/rabbit.cpp
View File

@ -23,15 +23,6 @@
#include <rabbit-std/sqstdstring.hpp> #include <rabbit-std/sqstdstring.hpp>
#include <rabbit-std/sqstdaux.hpp> #include <rabbit-std/sqstdaux.hpp>
#ifdef SQUNICODE
#define scfprintf fwprintf
#define scvprintf vfwprintf
#else
#define scfprintf fprintf
#define scvprintf vfprintf
#endif
void PrintVersionInfos(); void PrintVersionInfos();
#if defined(_MSC_VER) && defined(_DEBUG) #if defined(_MSC_VER) && defined(_DEBUG)
@ -56,30 +47,30 @@ int64_t quit(rabbit::VirtualMachine* v)
return 0; return 0;
} }
void printfunc(rabbit::VirtualMachine* SQ_UNUSED_ARG(v),const rabbit::Char *s,...) void printfunc(rabbit::VirtualMachine* SQ_UNUSED_ARG(v),const char *s,...)
{ {
va_list vl; va_list vl;
va_start(vl, s); va_start(vl, s);
scvprintf(stdout, s, vl); vfprintf(stdout, s, vl);
va_end(vl); va_end(vl);
} }
void errorfunc(rabbit::VirtualMachine* SQ_UNUSED_ARG(v),const rabbit::Char *s,...) void errorfunc(rabbit::VirtualMachine* SQ_UNUSED_ARG(v),const char *s,...)
{ {
va_list vl; va_list vl;
va_start(vl, s); va_start(vl, s);
scvprintf(stderr, s, vl); vfprintf(stderr, s, vl);
va_end(vl); va_end(vl);
} }
void PrintVersionInfos() void PrintVersionInfos()
{ {
scfprintf(stdout,_SC("%s %s (%d bits)\n"),RABBIT_VERSION,RABBIT_COPYRIGHT,((int)(sizeof(int64_t)*8))); fprintf(stdout,_SC("%s %s (%d bits)\n"),RABBIT_VERSION,RABBIT_COPYRIGHT,((int)(sizeof(int64_t)*8)));
} }
void PrintUsage() void PrintUsage()
{ {
scfprintf(stderr,_SC("usage: sq <options> <scriptpath [args]>.\n") fprintf(stderr,_SC("usage: sq <options> <scriptpath [args]>.\n")
_SC("Available options are:\n") _SC("Available options are:\n")
_SC(" -c compiles the file to bytecode(default output 'out.karrot')\n") _SC(" -c compiles the file to bytecode(default output 'out.karrot')\n")
_SC(" -o specifies output file for the -c option\n") _SC(" -o specifies output file for the -c option\n")
@ -97,9 +88,6 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
{ {
int i; int i;
int compiles_only = 0; int compiles_only = 0;
#ifdef SQUNICODE
static rabbit::Char temp[500];
#endif
char * output = NULL; char * output = NULL;
*retval = 0; *retval = 0;
if(argc>1) if(argc>1)
@ -135,7 +123,7 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
return _DONE; return _DONE;
default: default:
PrintVersionInfos(); PrintVersionInfos();
scprintf(_SC("unknown prameter '-%c'\n"),argv[arg][1]); printf(_SC("unknown prameter '-%c'\n"),argv[arg][1]);
PrintUsage(); PrintUsage();
*retval = -1; *retval = -1;
return _ERROR; return _ERROR;
@ -147,13 +135,8 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
// src file // src file
if(arg<argc) { if(arg<argc) {
const rabbit::Char *filename=NULL; const char *filename=NULL;
#ifdef SQUNICODE
mbstowcs(temp,argv[arg],strlen(argv[arg]));
filename=temp;
#else
filename=argv[arg]; filename=argv[arg];
#endif
arg++; arg++;
@ -164,15 +147,9 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
//sq_pop(v,1); //sq_pop(v,1);
if(compiles_only) { if(compiles_only) {
if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,SQTrue))){ if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,SQTrue))){
const rabbit::Char *outfile = _SC("out.karrot"); const char *outfile = _SC("out.karrot");
if(output) { if(output) {
#ifdef SQUNICODE
int len = (int)(strlen(output)+1);
mbstowcs(sq_getscratchpad(v,len*sizeof(rabbit::Char)),output,len);
outfile = sq_getscratchpad(v,-1);
#else
outfile = output; outfile = output;
#endif
} }
if(SQ_SUCCEEDED(rabbit::std::writeclosuretofile(v,outfile))) if(SQ_SUCCEEDED(rabbit::std::writeclosuretofile(v,outfile)))
return _DONE; return _DONE;
@ -187,15 +164,8 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
sq_pushroottable(v); sq_pushroottable(v);
for(i=arg;i<argc;i++) for(i=arg;i<argc;i++)
{ {
const rabbit::Char *a; const char *a;
#ifdef SQUNICODE
int alen=(int)strlen(argv[i]);
a=sq_getscratchpad(v,(int)(alen*sizeof(rabbit::Char)));
mbstowcs(sq_getscratchpad(v,-1),argv[i],alen);
sq_getscratchpad(v,-1)[alen] = _SC('\0');
#else
a=argv[i]; a=argv[i];
#endif
sq_pushstring(v,a,-1); sq_pushstring(v,a,-1);
callargs++; callargs++;
//sq_arrayappend(v,-2); //sq_arrayappend(v,-2);
@ -216,10 +186,10 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
} }
//if this point is reached an error occurred //if this point is reached an error occurred
{ {
const rabbit::Char *err; const char *err;
sq_getlasterror(v); sq_getlasterror(v);
if(SQ_SUCCEEDED(sq_getstring(v,-1,&err))) { if(SQ_SUCCEEDED(sq_getstring(v,-1,&err))) {
scprintf(_SC("error [%s]\n"),err); printf(_SC("error [%s]\n"),err);
*retval = -2; *retval = -2;
return _ERROR; return _ERROR;
} }
@ -235,7 +205,7 @@ void Interactive(rabbit::VirtualMachine* v)
{ {
#define MAXINPUT 1024 #define MAXINPUT 1024
rabbit::Char buffer[MAXINPUT]; char buffer[MAXINPUT];
int64_t blocks =0; int64_t blocks =0;
int64_t string=0; int64_t string=0;
int64_t retval=0; int64_t retval=0;
@ -253,7 +223,7 @@ void Interactive(rabbit::VirtualMachine* v)
while (!done) while (!done)
{ {
int64_t i = 0; int64_t i = 0;
scprintf(_SC("\nrabbit> ")); printf(_SC("\nrabbit> "));
for(;;) { for(;;) {
int c; int c;
if(done)return; if(done)return;
@ -266,37 +236,37 @@ void Interactive(rabbit::VirtualMachine* v)
else if(blocks==0)break; else if(blocks==0)break;
buffer[i++] = _SC('\n'); buffer[i++] = _SC('\n');
} }
else if (c==_SC('}')) {blocks--; buffer[i++] = (rabbit::Char)c;} else if (c==_SC('}')) {blocks--; buffer[i++] = (char)c;}
else if(c==_SC('{') && !string){ else if(c==_SC('{') && !string){
blocks++; blocks++;
buffer[i++] = (rabbit::Char)c; buffer[i++] = (char)c;
} }
else if(c==_SC('"') || c==_SC('\'')){ else if(c==_SC('"') || c==_SC('\'')){
string=!string; string=!string;
buffer[i++] = (rabbit::Char)c; buffer[i++] = (char)c;
} }
else if (i >= MAXINPUT-1) { else if (i >= MAXINPUT-1) {
scfprintf(stderr, _SC("sq : input line too long\n")); fprintf(stderr, _SC("sq : input line too long\n"));
break; break;
} }
else{ else{
buffer[i++] = (rabbit::Char)c; buffer[i++] = (char)c;
} }
} }
buffer[i] = _SC('\0'); buffer[i] = _SC('\0');
if(buffer[0]==_SC('=')){ if(buffer[0]==_SC('=')){
scsprintf(sq_getscratchpad(v,MAXINPUT),(size_t)MAXINPUT,_SC("return (%s)"),&buffer[1]); snprintf(sq_getscratchpad(v,MAXINPUT),(size_t)MAXINPUT,_SC("return (%s)"),&buffer[1]);
memcpy(buffer,sq_getscratchpad(v,-1),(scstrlen(sq_getscratchpad(v,-1))+1)*sizeof(rabbit::Char)); memcpy(buffer,sq_getscratchpad(v,-1),(strlen(sq_getscratchpad(v,-1))+1)*sizeof(char));
retval=1; retval=1;
} }
i=scstrlen(buffer); i=strlen(buffer);
if(i>0){ if(i>0){
int64_t oldtop=sq_gettop(v); int64_t oldtop=sq_gettop(v);
if(SQ_SUCCEEDED(sq_compilebuffer(v,buffer,i,_SC("interactive console"),SQTrue))){ if(SQ_SUCCEEDED(sq_compilebuffer(v,buffer,i,_SC("interactive console"),SQTrue))){
sq_pushroottable(v); sq_pushroottable(v);
if(SQ_SUCCEEDED(sq_call(v,1,retval,SQTrue)) && retval){ if(SQ_SUCCEEDED(sq_call(v,1,retval,SQTrue)) && retval){
scprintf(_SC("\n")); printf(_SC("\n"));
sq_pushroottable(v); sq_pushroottable(v);
sq_pushstring(v,_SC("print"),-1); sq_pushstring(v,_SC("print"),-1);
sq_get(v,-2); sq_get(v,-2);
@ -304,7 +274,7 @@ void Interactive(rabbit::VirtualMachine* v)
sq_push(v,-4); sq_push(v,-4);
sq_call(v,2,SQFalse,SQTrue); sq_call(v,2,SQFalse,SQTrue);
retval=0; retval=0;
scprintf(_SC("\n")); printf(_SC("\n"));
} }
} }

23
etc/minimal.cpp
View File

@ -5,36 +5,23 @@
#include <sqstdio.h> #include <sqstdio.h>
#include <sqstdaux.h> #include <sqstdaux.h>
#ifdef _MSC_VER void printfunc(HSQUIRRELVM v,const char *s,...)
#pragma comment (lib ,"squirrel.lib")
#pragma comment (lib ,"sqstdlib.lib")
#endif
#ifdef SQUNICODE
#define scvprintf vfwprintf
#else
#define scvprintf vfprintf
#endif
void printfunc(HSQUIRRELVM v,const rabbit::Char *s,...)
{ {
va_list vl; va_list vl;
va_start(vl, s); va_start(vl, s);
scvprintf(stdout, s, vl); vfprintf(stdout, s, vl);
va_end(vl); va_end(vl);
} }
void errorfunc(HSQUIRRELVM v,const rabbit::Char *s,...) void errorfunc(HSQUIRRELVM v,const char *s,...)
{ {
va_list vl; va_list vl;
va_start(vl, s); va_start(vl, s);
scvprintf(stderr, s, vl); vfprintf(stderr, s, vl);
va_end(vl); va_end(vl);
} }
void call_foo(HSQUIRRELVM v, int n,float f,const rabbit::Char *s) void call_foo(HSQUIRRELVM v, int n,float f,const char *s)
{ {
int64_t top = sq_gettop(v); //saves the stack size before the call int64_t top = sq_gettop(v); //saves the stack size before the call
sq_pushroottable(v); //pushes the global table sq_pushroottable(v); //pushes the global table

12
rabbit-std/sqstdaux.cpp
View File

@ -18,15 +18,15 @@ void rabbit::std::printcallstack(rabbit::VirtualMachine* v)
rabbit::StackInfos si; rabbit::StackInfos si;
int64_t i; int64_t i;
float_t f; float_t f;
const rabbit::Char *s; const char *s;
int64_t level=1; //1 is to skip this function that is level 0 int64_t level=1; //1 is to skip this function that is level 0
const rabbit::Char *name=0; const char *name=0;
int64_t seq=0; int64_t seq=0;
pf(v,_SC("\nCALLSTACK\n")); pf(v,_SC("\nCALLSTACK\n"));
while(SQ_SUCCEEDED(sq_stackinfos(v,level,&si))) while(SQ_SUCCEEDED(sq_stackinfos(v,level,&si)))
{ {
const rabbit::Char *fn=_SC("unknown"); const char *fn=_SC("unknown");
const rabbit::Char *src=_SC("unknown"); const char *src=_SC("unknown");
if(si.funcname)fn=si.funcname; if(si.funcname)fn=si.funcname;
if(si.source)src=si.source; if(si.source)src=si.source;
pf(v,_SC("*FUNCTION [%s()] %s line [%d]\n"),fn,src,si.line); pf(v,_SC("*FUNCTION [%s()] %s line [%d]\n"),fn,src,si.line);
@ -110,7 +110,7 @@ namespace rabbit {
static int64_t aux_printerror(rabbit::VirtualMachine* v) { static int64_t aux_printerror(rabbit::VirtualMachine* v) {
SQPRINTFUNCTION pf = sq_geterrorfunc(v); SQPRINTFUNCTION pf = sq_geterrorfunc(v);
if(pf) { if(pf) {
const rabbit::Char *sErr = 0; const char *sErr = 0;
if(sq_gettop(v)>=1) { if(sq_gettop(v)>=1) {
if(SQ_SUCCEEDED(sq_getstring(v,2,&sErr))) { if(SQ_SUCCEEDED(sq_getstring(v,2,&sErr))) {
pf(v,_SC("\nAN ERROR HAS OCCURRED [%s]\n"),sErr); pf(v,_SC("\nAN ERROR HAS OCCURRED [%s]\n"),sErr);
@ -124,7 +124,7 @@ namespace rabbit {
return 0; return 0;
} }
void compiler_error(rabbit::VirtualMachine* v,const rabbit::Char *sErr,const rabbit::Char *sSource,int64_t line,int64_t column) { void compiler_error(rabbit::VirtualMachine* v,const char *sErr,const char *sSource,int64_t line,int64_t column) {
SQPRINTFUNCTION pf = sq_geterrorfunc(v); SQPRINTFUNCTION pf = sq_geterrorfunc(v);
if(pf) { if(pf) {
pf(v,_SC("%s line = (%d) column = (%d) : error %s\n"),sSource,line,column,sErr); pf(v,_SC("%s line = (%d) column = (%d) : error %s\n"),sSource,line,column,sErr);

66
rabbit-std/sqstdio.cpp
View File

@ -14,13 +14,9 @@
#define SQSTD_FILE_TYPE_TAG ((uint64_t)(SQSTD_STREAM_TYPE_TAG | 0x00000001)) #define SQSTD_FILE_TYPE_TAG ((uint64_t)(SQSTD_STREAM_TYPE_TAG | 0x00000001))
//basic API //basic API
rabbit::std::SQFILE rabbit::std::fopen(const rabbit::Char *filename ,const rabbit::Char *mode) rabbit::std::SQFILE rabbit::std::fopen(const char *filename ,const char *mode)
{ {
#ifndef SQUNICODE
return (SQFILE)::fopen(filename,mode); return (SQFILE)::fopen(filename,mode);
#else
return (SQFILE)::_wfopen(filename,mode);
#endif
} }
int64_t rabbit::std::fread(void* buffer, int64_t size, int64_t count, SQFILE file) int64_t rabbit::std::fread(void* buffer, int64_t size, int64_t count, SQFILE file)
@ -73,7 +69,7 @@ namespace rabbit {
File() { _handle = NULL; _owns = false;} File() { _handle = NULL; _owns = false;}
File(SQFILE file, bool owns) { _handle = file; _owns = owns;} File(SQFILE file, bool owns) { _handle = file; _owns = owns;}
virtual ~File() { close(); } virtual ~File() { close(); }
bool Open(const rabbit::Char *filename ,const rabbit::Char *mode) { bool Open(const char *filename ,const char *mode) {
close(); close();
if( (_handle = rabbit::std::fopen(filename,mode)) ) { if( (_handle = rabbit::std::fopen(filename,mode)) ) {
_owns = true; _owns = true;
@ -135,7 +131,7 @@ static int64_t _file_releasehook(rabbit::UserPointer p, int64_t SQ_UNUSED_ARG(si
static int64_t _file_constructor(rabbit::VirtualMachine* v) static int64_t _file_constructor(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *filename,*mode; const char *filename,*mode;
bool owns = true; bool owns = true;
rabbit::std::File *f; rabbit::std::File *f;
rabbit::std::SQFILE newf; rabbit::std::SQFILE newf;
@ -275,46 +271,6 @@ static int64_t _io_file_lexfeed_PLAIN(rabbit::UserPointer iobuf)
} }
#ifdef SQUNICODE
static int64_t _io_file_lexfeed_UTF8(rabbit::UserPointer iobuf)
{
IOBuffer *iobuffer = (IOBuffer *)iobuf;
#define READ(iobuf) \
if((inchar = (unsigned char)_read_byte(iobuf)) == 0) \
return 0;
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 */
2,2, /* 1100, 1101 : 2 bytes */
3, /* 1110 : 3 bytes */
4 /* 1111 :4 bytes */
};
static const unsigned char byte_masks[5] = {0,0,0x1f,0x0f,0x07};
unsigned char inchar;
int64_t c = 0;
READ(iobuffer);
c = inchar;
//
if(c >= 0x80) {
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(int64_t n = 0; n < codelen-1; n++) {
tmp<<=6;
READ(iobuffer);
tmp |= inchar & 0x3F;
}
c = tmp;
}
return c;
}
#endif
static int64_t _io_file_lexfeed_UCS2_LE(rabbit::UserPointer iobuf) static int64_t _io_file_lexfeed_UCS2_LE(rabbit::UserPointer iobuf)
{ {
int64_t ret; int64_t ret;
@ -347,7 +303,7 @@ int64_t file_write(rabbit::UserPointer file,rabbit::UserPointer p,int64_t size)
return rabbit::std::fwrite(p,1,size,(rabbit::std::SQFILE)file); return rabbit::std::fwrite(p,1,size,(rabbit::std::SQFILE)file);
} }
rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool printerror) rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const char *filename,rabbit::Bool printerror)
{ {
SQFILE file = rabbit::std::fopen(filename,_SC("rb")); SQFILE file = rabbit::std::fopen(filename,_SC("rb"));
@ -384,11 +340,7 @@ rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const rabbit::Cha
rabbit::std::fclose(file); rabbit::std::fclose(file);
return sq_throwerror(v,_SC("Unrecognized encoding")); return sq_throwerror(v,_SC("Unrecognized encoding"));
} }
#ifdef SQUNICODE
func = _io_file_lexfeed_UTF8;
#else
func = _io_file_lexfeed_PLAIN; func = _io_file_lexfeed_PLAIN;
#endif
break;//UTF-8 ; break;//UTF-8 ;
default: rabbit::std::fseek(file,0,SQ_SEEK_SET); break; // ascii default: rabbit::std::fseek(file,0,SQ_SEEK_SET); break; // ascii
} }
@ -407,7 +359,7 @@ rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const rabbit::Cha
return sq_throwerror(v,_SC("cannot open the file")); return sq_throwerror(v,_SC("cannot open the file"));
} }
rabbit::Result rabbit::std::dofile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool retval,rabbit::Bool printerror) rabbit::Result rabbit::std::dofile(rabbit::VirtualMachine* v,const char *filename,rabbit::Bool retval,rabbit::Bool printerror)
{ {
//at least one entry must exist in order for us to push it as the environment //at least one entry must exist in order for us to push it as the environment
if(sq_gettop(v) == 0) if(sq_gettop(v) == 0)
@ -424,7 +376,7 @@ rabbit::Result rabbit::std::dofile(rabbit::VirtualMachine* v,const rabbit::Char
return SQ_ERROR; return SQ_ERROR;
} }
rabbit::Result rabbit::std::writeclosuretofile(rabbit::VirtualMachine* v,const rabbit::Char *filename) rabbit::Result rabbit::std::writeclosuretofile(rabbit::VirtualMachine* v,const char *filename)
{ {
SQFILE file = rabbit::std::fopen(filename,_SC("wb+")); SQFILE file = rabbit::std::fopen(filename,_SC("wb+"));
if(!file) return sq_throwerror(v,_SC("cannot open the file")); if(!file) return sq_throwerror(v,_SC("cannot open the file"));
@ -438,7 +390,7 @@ rabbit::Result rabbit::std::writeclosuretofile(rabbit::VirtualMachine* v,const r
int64_t _g_io_loadfile(rabbit::VirtualMachine* v) int64_t _g_io_loadfile(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *filename; const char *filename;
rabbit::Bool printerror = SQFalse; rabbit::Bool printerror = SQFalse;
sq_getstring(v,2,&filename); sq_getstring(v,2,&filename);
if(sq_gettop(v) >= 3) { if(sq_gettop(v) >= 3) {
@ -451,7 +403,7 @@ int64_t _g_io_loadfile(rabbit::VirtualMachine* v)
int64_t _g_io_writeclosuretofile(rabbit::VirtualMachine* v) int64_t _g_io_writeclosuretofile(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *filename; const char *filename;
sq_getstring(v,2,&filename); sq_getstring(v,2,&filename);
if(SQ_SUCCEEDED(rabbit::std::writeclosuretofile(v,filename))) if(SQ_SUCCEEDED(rabbit::std::writeclosuretofile(v,filename)))
return 1; return 1;
@ -460,7 +412,7 @@ int64_t _g_io_writeclosuretofile(rabbit::VirtualMachine* v)
int64_t _g_io_dofile(rabbit::VirtualMachine* v) int64_t _g_io_dofile(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *filename; const char *filename;
rabbit::Bool printerror = SQFalse; rabbit::Bool printerror = SQFalse;
sq_getstring(v,2,&filename); sq_getstring(v,2,&filename);
if(sq_gettop(v) >= 3) { if(sq_gettop(v) >= 3) {

8
rabbit-std/sqstdio.hpp
View File

@ -29,7 +29,7 @@ struct SQStream {
using SQFILE = void*; using SQFILE = void*;
SQFILE fopen(const rabbit::Char *,const rabbit::Char *); SQFILE fopen(const char *,const char *);
int64_t fread(rabbit::UserPointer, int64_t, int64_t, SQFILE); int64_t fread(rabbit::UserPointer, int64_t, int64_t, SQFILE);
int64_t fwrite(const rabbit::UserPointer, int64_t, int64_t, SQFILE); int64_t fwrite(const rabbit::UserPointer, int64_t, int64_t, SQFILE);
int64_t fseek(SQFILE , int64_t , int64_t); int64_t fseek(SQFILE , int64_t , int64_t);
@ -42,9 +42,9 @@ rabbit::Result createfile(rabbit::VirtualMachine* v, SQFILE file,rabbit::Bool ow
rabbit::Result getfile(rabbit::VirtualMachine* v, int64_t idx, SQFILE *file); rabbit::Result getfile(rabbit::VirtualMachine* v, int64_t idx, SQFILE *file);
//compiler helpers //compiler helpers
rabbit::Result loadfile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool printerror); rabbit::Result loadfile(rabbit::VirtualMachine* v,const char *filename,rabbit::Bool printerror);
rabbit::Result dofile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool retval,rabbit::Bool printerror); rabbit::Result dofile(rabbit::VirtualMachine* v,const char *filename,rabbit::Bool retval,rabbit::Bool printerror);
rabbit::Result writeclosuretofile(rabbit::VirtualMachine* v,const rabbit::Char *filename); rabbit::Result writeclosuretofile(rabbit::VirtualMachine* v,const char *filename);
rabbit::Result register_iolib(rabbit::VirtualMachine* v); rabbit::Result register_iolib(rabbit::VirtualMachine* v);

96
rabbit-std/sqstdrex.cpp
View File

@ -15,7 +15,7 @@
#ifdef _DEBUG #ifdef _DEBUG
#include <stdio.h> #include <stdio.h>
static const rabbit::Char *g_nnames[] = static const char *g_nnames[] =
{ {
_SC("NONE"),_SC("OP_GREEDY"), _SC("OP_OR"), _SC("NONE"),_SC("OP_GREEDY"), _SC("OP_OR"),
_SC("OP_EXPR"),_SC("OP_NOCAPEXPR"),_SC("OP_DOT"), _SC("OP_CLASS"), _SC("OP_EXPR"),_SC("OP_NOCAPEXPR"),_SC("OP_DOT"), _SC("OP_CLASS"),
@ -25,20 +25,20 @@ static const rabbit::Char *g_nnames[] =
#endif #endif
#define OP_GREEDY (MAX_CHAR+1) // * + ? {n} #define OP_GREEDY (UINT8_MAX+1) // * + ? {n}
#define OP_OR (MAX_CHAR+2) #define OP_OR (UINT8_MAX+2)
#define OP_EXPR (MAX_CHAR+3) //parentesis () #define OP_EXPR (UINT8_MAX+3) //parentesis ()
#define OP_NOCAPEXPR (MAX_CHAR+4) //parentesis (?:) #define OP_NOCAPEXPR (UINT8_MAX+4) //parentesis (?:)
#define OP_DOT (MAX_CHAR+5) #define OP_DOT (UINT8_MAX+5)
#define OP_CLASS (MAX_CHAR+6) #define OP_CLASS (UINT8_MAX+6)
#define OP_CCLASS (MAX_CHAR+7) #define OP_CCLASS (UINT8_MAX+7)
#define OP_NCLASS (MAX_CHAR+8) //negates class the [^ #define OP_NCLASS (UINT8_MAX+8) //negates class the [^
#define OP_RANGE (MAX_CHAR+9) #define OP_RANGE (UINT8_MAX+9)
#define OP_CHAR (MAX_CHAR+10) #define OP_CHAR (UINT8_MAX+10)
#define OP_EOL (MAX_CHAR+11) #define OP_EOL (UINT8_MAX+11)
#define OP_BOL (MAX_CHAR+12) #define OP_BOL (UINT8_MAX+12)
#define OP_WB (MAX_CHAR+13) #define OP_WB (UINT8_MAX+13)
#define OP_MB (MAX_CHAR+14) //match balanced #define OP_MB (UINT8_MAX+14) //match balanced
#define SQREX_SYMBOL_ANY_CHAR ('.') #define SQREX_SYMBOL_ANY_CHAR ('.')
#define SQREX_SYMBOL_GREEDY_ONE_OR_MORE ('+') #define SQREX_SYMBOL_GREEDY_ONE_OR_MORE ('+')
@ -63,9 +63,9 @@ namespace std {
}SQRexNode; }SQRexNode;
struct SQRex{ struct SQRex{
const rabbit::Char *_eol; const char *_eol;
const rabbit::Char *_bol; const char *_bol;
const rabbit::Char *_p; const char *_p;
int64_t _first; int64_t _first;
int64_t _op; int64_t _op;
SQRexNode *_nodes; SQRexNode *_nodes;
@ -75,7 +75,7 @@ namespace std {
rabbit::std::SQRexMatch *_matches; rabbit::std::SQRexMatch *_matches;
int64_t _currsubexp; int64_t _currsubexp;
void *_jmpbuf; void *_jmpbuf;
const rabbit::Char **_error; const char **_error;
}; };
static int64_t rex_list(SQRex *exp); static int64_t rex_list(SQRex *exp);
@ -97,7 +97,7 @@ namespace std {
return (int64_t)newid; return (int64_t)newid;
} }
static void rex_error(SQRex *exp,const rabbit::Char *error) static void rex_error(SQRex *exp,const char *error)
{ {
if(exp->_error) *exp->_error = error; if(exp->_error) *exp->_error = error;
longjmp(*((jmp_buf*)exp->_jmpbuf),-1); longjmp(*((jmp_buf*)exp->_jmpbuf),-1);
@ -109,7 +109,7 @@ namespace std {
exp->_p++; exp->_p++;
} }
static rabbit::Char rex_escapechar(SQRex *exp) static char rex_escapechar(SQRex *exp)
{ {
if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR){ if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR){
exp->_p++; exp->_p++;
@ -121,7 +121,7 @@ namespace std {
case 'f': exp->_p++; return '\f'; case 'f': exp->_p++; return '\f';
default: return (*exp->_p++); default: return (*exp->_p++);
} }
} else if(!scisprint(*exp->_p)) rabbit::std::rex_error(exp,_SC("letter expected")); } else if(!isprint(*exp->_p)) rabbit::std::rex_error(exp,_SC("letter expected"));
return (*exp->_p++); return (*exp->_p++);
} }
@ -134,7 +134,7 @@ namespace std {
static int64_t rex_charnode(SQRex *exp,rabbit::Bool isclass) static int64_t rex_charnode(SQRex *exp,rabbit::Bool isclass)
{ {
rabbit::Char t; char t;
if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR) { if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR) {
exp->_p++; exp->_p++;
switch(*exp->_p) { switch(*exp->_p) {
@ -152,7 +152,7 @@ namespace std {
} }
case 'm': case 'm':
{ {
rabbit::Char cb, ce; //cb = character begin match ce = character end match char cb, ce; //cb = character begin match ce = character end match
cb = *++exp->_p; //skip 'm' cb = *++exp->_p; //skip 'm'
ce = *++exp->_p; ce = *++exp->_p;
exp->_p++; //points to the next char to be parsed exp->_p++; //points to the next char to be parsed
@ -179,7 +179,7 @@ namespace std {
return rabbit::std::rex_newnode(exp,t); return rabbit::std::rex_newnode(exp,t);
} }
} }
else if(!scisprint(*exp->_p)) { else if(!isprint(*exp->_p)) {
rabbit::std::rex_error(exp,_SC("letter expected")); rabbit::std::rex_error(exp,_SC("letter expected"));
} }
@ -353,7 +353,7 @@ namespace std {
return ret; return ret;
} }
static rabbit::Bool rex_matchcclass(int64_t cclass,rabbit::Char c) static rabbit::Bool rex_matchcclass(int64_t cclass,char c)
{ {
switch(cclass) { switch(cclass) {
case 'a': return isalpha(c)?SQTrue:SQFalse; case 'a': return isalpha(c)?SQTrue:SQFalse;
@ -376,7 +376,7 @@ namespace std {
return SQFalse; /*cannot happen*/ return SQFalse; /*cannot happen*/
} }
static rabbit::Bool rex_matchclass(SQRex* exp,SQRexNode *node,rabbit::Char c) static rabbit::Bool rex_matchclass(SQRex* exp,SQRexNode *node,char c)
{ {
do { do {
switch(node->type) { switch(node->type) {
@ -393,7 +393,7 @@ namespace std {
return SQFalse; return SQFalse;
} }
static const rabbit::Char * rex_matchnode(SQRex* exp,SQRexNode *node,const rabbit::Char *str,SQRexNode *next) static const char * rex_matchnode(SQRex* exp,SQRexNode *node,const char *str,SQRexNode *next)
{ {
SQRexNodeType type = node->type; SQRexNodeType type = node->type;
@ -402,7 +402,7 @@ namespace std {
//SQRexNode *greedystop = (node->next != -1) ? &exp->_nodes[node->next] : NULL; //SQRexNode *greedystop = (node->next != -1) ? &exp->_nodes[node->next] : NULL;
SQRexNode *greedystop = NULL; SQRexNode *greedystop = NULL;
int64_t 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 rabbit::Char *s=str, *good = str; const char *s=str, *good = str;
if(node->next != -1) { if(node->next != -1) {
greedystop = &exp->_nodes[node->next]; greedystop = &exp->_nodes[node->next];
@ -413,7 +413,7 @@ namespace std {
while((nmaches == 0xFFFF || nmaches < p1)) { while((nmaches == 0xFFFF || nmaches < p1)) {
const rabbit::Char *stop; const char *stop;
if(!(s = rabbit::std::rex_matchnode(exp,&exp->_nodes[node->left],s,greedystop))) if(!(s = rabbit::std::rex_matchnode(exp,&exp->_nodes[node->left],s,greedystop)))
break; break;
nmaches++; nmaches++;
@ -449,7 +449,7 @@ namespace std {
return NULL; return NULL;
} }
case OP_OR: { case OP_OR: {
const rabbit::Char *asd = str; const char *asd = str;
SQRexNode *temp=&exp->_nodes[node->left]; SQRexNode *temp=&exp->_nodes[node->left];
while( (asd = rabbit::std::rex_matchnode(exp,temp,asd,NULL)) ) { while( (asd = rabbit::std::rex_matchnode(exp,temp,asd,NULL)) ) {
if(temp->next != -1) if(temp->next != -1)
@ -471,7 +471,7 @@ namespace std {
case OP_EXPR: case OP_EXPR:
case OP_NOCAPEXPR:{ case OP_NOCAPEXPR:{
SQRexNode *n = &exp->_nodes[node->left]; SQRexNode *n = &exp->_nodes[node->left];
const rabbit::Char *cur = str; const char *cur = str;
int64_t capture = -1; int64_t capture = -1;
if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) { if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) {
capture = exp->_currsubexp; capture = exp->_currsubexp;
@ -540,7 +540,7 @@ namespace std {
if(*str != cb) return NULL; // string doesnt start with open char if(*str != cb) return NULL; // string doesnt start with open char
int64_t ce = node->right; //char that closes a balanced expression int64_t ce = node->right; //char that closes a balanced expression
int64_t cont = 1; int64_t cont = 1;
const rabbit::Char *streol = exp->_eol; const char *streol = exp->_eol;
while (++str < streol) { while (++str < streol) {
if (*str == ce) { if (*str == ce) {
if (--cont == 0) { if (--cont == 0) {
@ -562,12 +562,12 @@ namespace std {
} }
} }
/* public api */ /* public api */
rabbit::std::SQRex *rabbit::std::rex_compile(const rabbit::Char *pattern,const rabbit::Char **error) rabbit::std::SQRex *rabbit::std::rex_compile(const char *pattern,const char **error)
{ {
SQRex * volatile exp = (SQRex *)sq_malloc(sizeof(SQRex)); // "volatile" is needed for setjmp() SQRex * volatile exp = (SQRex *)sq_malloc(sizeof(SQRex)); // "volatile" is needed for setjmp()
exp->_eol = exp->_bol = NULL; exp->_eol = exp->_bol = NULL;
exp->_p = pattern; exp->_p = pattern;
exp->_nallocated = (int64_t)scstrlen(pattern) * sizeof(rabbit::Char); exp->_nallocated = (int64_t)strlen(pattern) * sizeof(char);
exp->_nodes = (SQRexNode *)sq_malloc(exp->_nallocated * sizeof(SQRexNode)); exp->_nodes = (SQRexNode *)sq_malloc(exp->_nallocated * sizeof(SQRexNode));
exp->_nsize = 0; exp->_nsize = 0;
exp->_matches = 0; exp->_matches = 0;
@ -586,15 +586,15 @@ rabbit::std::SQRex *rabbit::std::rex_compile(const rabbit::Char *pattern,const r
SQRexNode *t; SQRexNode *t;
nsize = exp->_nsize; nsize = exp->_nsize;
t = &exp->_nodes[0]; t = &exp->_nodes[0];
scprintf(_SC("\n")); printf(_SC("\n"));
for(i = 0;i < nsize; i++) { for(i = 0;i < nsize; i++) {
if(exp->_nodes[i].type>MAX_CHAR) if(exp->_nodes[i].type>UINT8_MAX)
scprintf(_SC("[%02d] %10s "), (int32_t)i,g_nnames[exp->_nodes[i].type-MAX_CHAR]); printf(_SC("[%02d] %10s "), (int32_t)i,g_nnames[exp->_nodes[i].type-UINT8_MAX]);
else else
scprintf(_SC("[%02d] %10c "), (int32_t)i,exp->_nodes[i].type); printf(_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); printf(_SC("left %02d right %02d next %02d\n"), (int32_t)exp->_nodes[i].left, (int32_t)exp->_nodes[i].right, (int32_t)exp->_nodes[i].next);
} }
scprintf(_SC("\n")); printf(_SC("\n"));
} }
#endif #endif
exp->_matches = (SQRexMatch *) sq_malloc(exp->_nsubexpr * sizeof(SQRexMatch)); exp->_matches = (SQRexMatch *) sq_malloc(exp->_nsubexpr * sizeof(SQRexMatch));
@ -617,11 +617,11 @@ void rabbit::std::rex_free(SQRex *exp)
} }
} }
rabbit::Bool rabbit::std::rex_match(SQRex* exp,const rabbit::Char* text) rabbit::Bool rabbit::std::rex_match(SQRex* exp,const char* text)
{ {
const rabbit::Char* res = NULL; const char* res = NULL;
exp->_bol = text; exp->_bol = text;
exp->_eol = text + scstrlen(text); exp->_eol = text + strlen(text);
exp->_currsubexp = 0; exp->_currsubexp = 0;
res = rabbit::std::rex_matchnode(exp,exp->_nodes,text,NULL); res = rabbit::std::rex_matchnode(exp,exp->_nodes,text,NULL);
if(res == NULL || res != exp->_eol) if(res == NULL || res != exp->_eol)
@ -629,9 +629,9 @@ rabbit::Bool rabbit::std::rex_match(SQRex* exp,const rabbit::Char* text)
return SQTrue; return SQTrue;
} }
rabbit::Bool rabbit::std::rex_searchrange(SQRex* exp,const rabbit::Char* text_begin,const rabbit::Char* text_end,const rabbit::Char** out_begin, const rabbit::Char** out_end) rabbit::Bool rabbit::std::rex_searchrange(SQRex* exp,const char* text_begin,const char* text_end,const char** out_begin, const char** out_end)
{ {
const rabbit::Char *cur = NULL; const char *cur = NULL;
int64_t node = exp->_first; int64_t node = exp->_first;
if(text_begin >= text_end) return SQFalse; if(text_begin >= text_end) return SQFalse;
exp->_bol = text_begin; exp->_bol = text_begin;
@ -658,9 +658,9 @@ rabbit::Bool rabbit::std::rex_searchrange(SQRex* exp,const rabbit::Char* text_be
return SQTrue; return SQTrue;
} }
rabbit::Bool rabbit::std::rex_search(SQRex* exp,const rabbit::Char* text, const rabbit::Char** out_begin, const rabbit::Char** out_end) rabbit::Bool rabbit::std::rex_search(SQRex* exp,const char* text, const char** out_begin, const char** out_end)
{ {
return rabbit::std::rex_searchrange(exp,text,text + scstrlen(text),out_begin,out_end); return rabbit::std::rex_searchrange(exp,text,text + strlen(text),out_begin,out_end);
} }
int64_t rabbit::std::rex_getsubexpcount(SQRex* exp) int64_t rabbit::std::rex_getsubexpcount(SQRex* exp)

2
rabbit-std/sqstdstream.cpp
View File

@ -290,7 +290,7 @@ void init_streamclass(rabbit::VirtualMachine* v)
sq_pop(v,1); sq_pop(v,1);
} }
rabbit::Result rabbit::std::declare_stream(rabbit::VirtualMachine* v,const rabbit::Char* name,rabbit::UserPointer typetag,const rabbit::Char* reg_name,const rabbit::RegFunction *methods,const rabbit::RegFunction *globals) rabbit::Result rabbit::std::declare_stream(rabbit::VirtualMachine* v,const char* name,rabbit::UserPointer typetag,const char* reg_name,const rabbit::RegFunction *methods,const rabbit::RegFunction *globals)
{ {
if(sq_gettype(v,-1) != rabbit::OT_TABLE) if(sq_gettype(v,-1) != rabbit::OT_TABLE)
return sq_throwerror(v,_SC("table expected")); return sq_throwerror(v,_SC("table expected"));

2
rabbit-std/sqstdstream.hpp
View File

@ -23,6 +23,6 @@ namespace rabbit {
int64_t _stream_flush(rabbit::VirtualMachine* v); int64_t _stream_flush(rabbit::VirtualMachine* v);
#define _DECL_STREAM_FUNC(name,nparams,typecheck) {_SC(#name),_stream_##name,nparams,typecheck} #define _DECL_STREAM_FUNC(name,nparams,typecheck) {_SC(#name),_stream_##name,nparams,typecheck}
rabbit::Result declare_stream(rabbit::VirtualMachine* v,const rabbit::Char* name,rabbit::UserPointer typetag,const rabbit::Char* reg_name,const rabbit::RegFunction *methods,const rabbit::RegFunction *globals); rabbit::Result declare_stream(rabbit::VirtualMachine* v,const char* name,rabbit::UserPointer typetag,const char* reg_name,const rabbit::RegFunction *methods,const rabbit::RegFunction *globals);
} }
} }

126
rabbit-std/sqstdstring.cpp
View File

@ -16,9 +16,9 @@
#define MAX_FORMAT_LEN 20 #define MAX_FORMAT_LEN 20
#define MAX_WFORMAT_LEN 3 #define MAX_WFORMAT_LEN 3
#define ADDITIONAL_FORMAT_SPACE (100*sizeof(rabbit::Char)) #define ADDITIONAL_FORMAT_SPACE (100*sizeof(char))
static rabbit::Bool isfmtchr(rabbit::Char ch) static rabbit::Bool isfmtchr(char ch)
{ {
switch(ch) { switch(ch) {
case '-': case '-':
@ -31,15 +31,15 @@ static rabbit::Bool isfmtchr(rabbit::Char ch)
return SQFalse; return SQFalse;
} }
static int64_t validate_format(rabbit::VirtualMachine* v, rabbit::Char *fmt, const rabbit::Char *src, int64_t n,int64_t &width) static int64_t validate_format(rabbit::VirtualMachine* v, char *fmt, const char *src, int64_t n,int64_t &width)
{ {
rabbit::Char *dummy; char *dummy;
rabbit::Char swidth[MAX_WFORMAT_LEN]; char swidth[MAX_WFORMAT_LEN];
int64_t wc = 0; int64_t wc = 0;
int64_t start = n; int64_t start = n;
fmt[0] = '%'; fmt[0] = '%';
while (isfmtchr(src[n])) n++; while (isfmtchr(src[n])) n++;
while (scisdigit(src[n])) { while (isdigit(src[n])) {
swidth[wc] = src[n]; swidth[wc] = src[n];
n++; n++;
wc++; wc++;
@ -48,7 +48,7 @@ static int64_t validate_format(rabbit::VirtualMachine* v, rabbit::Char *fmt, con
} }
swidth[wc] = '\0'; swidth[wc] = '\0';
if(wc > 0) { if(wc > 0) {
width = scstrtol(swidth,&dummy,10); width = strtol(swidth,&dummy,10);
} }
else else
width = 0; width = 0;
@ -56,7 +56,7 @@ static int64_t validate_format(rabbit::VirtualMachine* v, rabbit::Char *fmt, con
n++; n++;
wc = 0; wc = 0;
while (scisdigit(src[n])) { while (isdigit(src[n])) {
swidth[wc] = src[n]; swidth[wc] = src[n];
n++; n++;
wc++; wc++;
@ -65,28 +65,28 @@ static int64_t validate_format(rabbit::VirtualMachine* v, rabbit::Char *fmt, con
} }
swidth[wc] = '\0'; swidth[wc] = '\0';
if(wc > 0) { if(wc > 0) {
width += scstrtol(swidth,&dummy,10); width += strtol(swidth,&dummy,10);
} }
} }
if (n-start > MAX_FORMAT_LEN ) if (n-start > MAX_FORMAT_LEN )
return sq_throwerror(v,_SC("format too long")); return sq_throwerror(v,_SC("format too long"));
memcpy(&fmt[1],&src[start],((n-start)+1)*sizeof(rabbit::Char)); memcpy(&fmt[1],&src[start],((n-start)+1)*sizeof(char));
fmt[(n-start)+2] = '\0'; fmt[(n-start)+2] = '\0';
return n; return n;
} }
rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t *outlen,rabbit::Char **output) rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t *outlen,char **output)
{ {
const rabbit::Char *format; const char *format;
rabbit::Char *dest; char *dest;
rabbit::Char fmt[MAX_FORMAT_LEN]; char fmt[MAX_FORMAT_LEN];
const rabbit::Result res = sq_getstring(v,nformatstringidx,&format); const rabbit::Result res = sq_getstring(v,nformatstringidx,&format);
if (SQ_FAILED(res)) { if (SQ_FAILED(res)) {
return res; // propagate the error return res; // propagate the error
} }
int64_t format_size = sq_getsize(v,nformatstringidx); int64_t format_size = sq_getsize(v,nformatstringidx);
int64_t allocated = (format_size+2)*sizeof(rabbit::Char); int64_t allocated = (format_size+2)*sizeof(char);
dest = sq_getscratchpad(v,allocated); dest = sq_getscratchpad(v,allocated);
int64_t n = 0,i = 0, nparam = nformatstringidx+1, w = 0; int64_t n = 0,i = 0, nparam = nformatstringidx+1, w = 0;
//while(format[n] != '\0') //while(format[n] != '\0')
@ -109,23 +109,23 @@ rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstri
if(n < 0) return -1; if(n < 0) return -1;
int64_t addlen = 0; int64_t addlen = 0;
int64_t valtype = 0; int64_t valtype = 0;
const rabbit::Char *ts = NULL; const char *ts = NULL;
int64_t ti = 0; int64_t ti = 0;
float_t tf = 0; float_t tf = 0;
switch(format[n]) { switch(format[n]) {
case 's': case 's':
if(SQ_FAILED(sq_getstring(v,nparam,&ts))) if(SQ_FAILED(sq_getstring(v,nparam,&ts)))
return sq_throwerror(v,_SC("string expected for the specified format")); return sq_throwerror(v,_SC("string expected for the specified format"));
addlen = (sq_getsize(v,nparam)*sizeof(rabbit::Char))+((w+1)*sizeof(rabbit::Char)); addlen = (sq_getsize(v,nparam)*sizeof(char))+((w+1)*sizeof(char));
valtype = 's'; valtype = 's';
break; break;
case 'i': case 'd': case 'o': case 'u': case 'x': case 'X': case 'i': case 'd': case 'o': case 'u': case 'x': case 'X':
#ifdef _SQ64 #ifdef _SQ64
{ {
size_t flen = scstrlen(fmt); size_t flen = strlen(fmt);
int64_t fpos = flen - 1; int64_t fpos = flen - 1;
rabbit::Char f = fmt[fpos]; char f = fmt[fpos];
const rabbit::Char *prec = (const rabbit::Char *)_PRINT_INT_PREC; const char *prec = (const char *)_PRINT_INT_PREC;
while(*prec != _SC('\0')) { while(*prec != _SC('\0')) {
fmt[fpos++] = *prec++; fmt[fpos++] = *prec++;
} }
@ -136,25 +136,25 @@ rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstri
case 'c': case 'c':
if(SQ_FAILED(sq_getinteger(v,nparam,&ti))) if(SQ_FAILED(sq_getinteger(v,nparam,&ti)))
return sq_throwerror(v,_SC("integer expected for the specified format")); return sq_throwerror(v,_SC("integer expected for the specified format"));
addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(rabbit::Char)); addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(char));
valtype = 'i'; valtype = 'i';
break; break;
case 'f': case 'g': case 'G': case 'e': case 'E': case 'f': case 'g': case 'G': case 'e': case 'E':
if(SQ_FAILED(sq_getfloat(v,nparam,&tf))) if(SQ_FAILED(sq_getfloat(v,nparam,&tf)))
return sq_throwerror(v,_SC("float expected for the specified format")); return sq_throwerror(v,_SC("float expected for the specified format"));
addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(rabbit::Char)); addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(char));
valtype = 'f'; valtype = 'f';
break; break;
default: default:
return sq_throwerror(v,_SC("invalid format")); return sq_throwerror(v,_SC("invalid format"));
} }
n++; n++;
allocated += addlen + sizeof(rabbit::Char); allocated += addlen + sizeof(char);
dest = sq_getscratchpad(v,allocated); dest = sq_getscratchpad(v,allocated);
switch(valtype) { switch(valtype) {
case 's': i += scsprintf(&dest[i],allocated,fmt,ts); break; case 's': i += snprintf(&dest[i],allocated,fmt,ts); break;
case 'i': i += scsprintf(&dest[i],allocated,fmt,ti); break; case 'i': i += snprintf(&dest[i],allocated,fmt,ti); break;
case 'f': i += scsprintf(&dest[i],allocated,fmt,tf); break; case 'f': i += snprintf(&dest[i],allocated,fmt,tf); break;
}; };
nparam ++; nparam ++;
} }
@ -167,7 +167,7 @@ rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstri
static int64_t _string_printf(rabbit::VirtualMachine* v) static int64_t _string_printf(rabbit::VirtualMachine* v)
{ {
rabbit::Char *dest = NULL; char *dest = NULL;
int64_t length = 0; int64_t length = 0;
if(SQ_FAILED(rabbit::std::format(v,2,&length,&dest))) if(SQ_FAILED(rabbit::std::format(v,2,&length,&dest)))
return -1; return -1;
@ -180,7 +180,7 @@ static int64_t _string_printf(rabbit::VirtualMachine* v)
static int64_t _string_format(rabbit::VirtualMachine* v) static int64_t _string_format(rabbit::VirtualMachine* v)
{ {
rabbit::Char *dest = NULL; char *dest = NULL;
int64_t length = 0; int64_t length = 0;
if(SQ_FAILED(rabbit::std::format(v,2,&length,&dest))) if(SQ_FAILED(rabbit::std::format(v,2,&length,&dest)))
return -1; return -1;
@ -188,27 +188,27 @@ static int64_t _string_format(rabbit::VirtualMachine* v)
return 1; return 1;
} }
static void __strip_l(const rabbit::Char *str,const rabbit::Char **start) static void __strip_l(const char *str,const char **start)
{ {
const rabbit::Char *t = str; const char *t = str;
while(((*t) != '\0') && scisspace(*t)){ t++; } while(((*t) != '\0') && isspace(*t)){ t++; }
*start = t; *start = t;
} }
static void __strip_r(const rabbit::Char *str,int64_t len,const rabbit::Char **end) static void __strip_r(const char *str,int64_t len,const char **end)
{ {
if(len == 0) { if(len == 0) {
*end = str; *end = str;
return; return;
} }
const rabbit::Char *t = &str[len-1]; const char *t = &str[len-1];
while(t >= str && scisspace(*t)) { t--; } while(t >= str && isspace(*t)) { t--; }
*end = t + 1; *end = t + 1;
} }
static int64_t _string_strip(rabbit::VirtualMachine* v) static int64_t _string_strip(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *str,*start,*end; const char *str,*start,*end;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
int64_t len = sq_getsize(v,2); int64_t len = sq_getsize(v,2);
__strip_l(str,&start); __strip_l(str,&start);
@ -219,7 +219,7 @@ static int64_t _string_strip(rabbit::VirtualMachine* v)
static int64_t _string_lstrip(rabbit::VirtualMachine* v) static int64_t _string_lstrip(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *str,*start; const char *str,*start;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
__strip_l(str,&start); __strip_l(str,&start);
sq_pushstring(v,start,-1); sq_pushstring(v,start,-1);
@ -228,7 +228,7 @@ static int64_t _string_lstrip(rabbit::VirtualMachine* v)
static int64_t _string_rstrip(rabbit::VirtualMachine* v) static int64_t _string_rstrip(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *str,*end; const char *str,*end;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
int64_t len = sq_getsize(v,2); int64_t len = sq_getsize(v,2);
__strip_r(str,len,&end); __strip_r(str,len,&end);
@ -238,21 +238,21 @@ static int64_t _string_rstrip(rabbit::VirtualMachine* v)
static int64_t _string_split(rabbit::VirtualMachine* v) static int64_t _string_split(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *str,*seps; const char *str,*seps;
rabbit::Char *stemp; char *stemp;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
sq_getstring(v,3,&seps); sq_getstring(v,3,&seps);
int64_t sepsize = sq_getsize(v,3); int64_t sepsize = sq_getsize(v,3);
if(sepsize == 0) return sq_throwerror(v,_SC("empty separators string")); if(sepsize == 0) return sq_throwerror(v,_SC("empty separators string"));
int64_t memsize = (sq_getsize(v,2)+1)*sizeof(rabbit::Char); int64_t memsize = (sq_getsize(v,2)+1)*sizeof(char);
stemp = sq_getscratchpad(v,memsize); stemp = sq_getscratchpad(v,memsize);
memcpy(stemp,str,memsize); memcpy(stemp,str,memsize);
rabbit::Char *start = stemp; char *start = stemp;
rabbit::Char *end = stemp; char *end = stemp;
sq_newarray(v,0); sq_newarray(v,0);
while(*end != '\0') while(*end != '\0')
{ {
rabbit::Char cur = *end; char cur = *end;
for(int64_t i = 0; i < sepsize; i++) for(int64_t i = 0; i < sepsize; i++)
{ {
if(cur == seps[i]) if(cur == seps[i])
@ -276,8 +276,8 @@ static int64_t _string_split(rabbit::VirtualMachine* v)
static int64_t _string_escape(rabbit::VirtualMachine* v) static int64_t _string_escape(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *str; const char *str;
rabbit::Char *dest,*resstr; char *dest,*resstr;
int64_t size; int64_t size;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
size = sq_getsize(v,2); size = sq_getsize(v,2);
@ -285,27 +285,17 @@ static int64_t _string_escape(rabbit::VirtualMachine* v)
sq_push(v,2); sq_push(v,2);
return 1; return 1;
} }
#ifdef SQUNICODE const char *escpat = _SC("\\x%02x");
#if WCHAR_SIZE == 2
const rabbit::Char *escpat = _SC("\\x%04x");
const int64_t maxescsize = 6;
#else //WCHAR_SIZE == 4
const rabbit::Char *escpat = _SC("\\x%08x");
const int64_t maxescsize = 10;
#endif
#else
const rabbit::Char *escpat = _SC("\\x%02x");
const int64_t maxescsize = 4; const int64_t maxescsize = 4;
#endif
int64_t destcharsize = (size * maxescsize); //assumes every char could be escaped int64_t destcharsize = (size * maxescsize); //assumes every char could be escaped
resstr = dest = (rabbit::Char *)sq_getscratchpad(v,destcharsize * sizeof(rabbit::Char)); resstr = dest = (char *)sq_getscratchpad(v,destcharsize * sizeof(char));
rabbit::Char c; char c;
rabbit::Char escch; char escch;
int64_t escaped = 0; int64_t escaped = 0;
for(int n = 0; n < size; n++){ for(int n = 0; n < size; n++){
c = *str++; c = *str++;
escch = 0; escch = 0;
if(scisprint(c) || c == 0) { if(isprint(c) || c == 0) {
switch(c) { switch(c) {
case '\a': escch = 'a'; break; case '\a': escch = 'a'; break;
case '\b': escch = 'b'; break; case '\b': escch = 'b'; break;
@ -330,7 +320,7 @@ static int64_t _string_escape(rabbit::VirtualMachine* v)
} }
else { else {
dest += scsprintf(dest, destcharsize, escpat, c); dest += snprintf(dest, destcharsize, escpat, c);
escaped++; escaped++;
} }
} }
@ -346,7 +336,7 @@ static int64_t _string_escape(rabbit::VirtualMachine* v)
static int64_t _string_startswith(rabbit::VirtualMachine* v) static int64_t _string_startswith(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *str,*cmp; const char *str,*cmp;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
sq_getstring(v,3,&cmp); sq_getstring(v,3,&cmp);
int64_t len = sq_getsize(v,2); int64_t len = sq_getsize(v,2);
@ -361,7 +351,7 @@ static int64_t _string_startswith(rabbit::VirtualMachine* v)
static int64_t _string_endswith(rabbit::VirtualMachine* v) static int64_t _string_endswith(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *str,*cmp; const char *str,*cmp;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
sq_getstring(v,3,&cmp); sq_getstring(v,3,&cmp);
int64_t len = sq_getsize(v,2); int64_t len = sq_getsize(v,2);
@ -388,7 +378,7 @@ static int64_t _rexobj_releasehook(rabbit::UserPointer p, int64_t SQ_UNUSED_ARG(
static int64_t _regexp_match(rabbit::VirtualMachine* v) static int64_t _regexp_match(rabbit::VirtualMachine* v)
{ {
SETUP_REX(v); SETUP_REX(v);
const rabbit::Char *str; const char *str;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
if(rabbit::std::rex_match(self,str) == SQTrue) if(rabbit::std::rex_match(self,str) == SQTrue)
{ {
@ -399,7 +389,7 @@ static int64_t _regexp_match(rabbit::VirtualMachine* v)
return 1; return 1;
} }
static void _addrexmatch(rabbit::VirtualMachine* v,const rabbit::Char *str,const rabbit::Char *begin,const rabbit::Char *end) static void _addrexmatch(rabbit::VirtualMachine* v,const char *str,const char *begin,const char *end)
{ {
sq_newtable(v); sq_newtable(v);
sq_pushstring(v,_SC("begin"),-1); sq_pushstring(v,_SC("begin"),-1);
@ -413,7 +403,7 @@ static void _addrexmatch(rabbit::VirtualMachine* v,const rabbit::Char *str,const
static int64_t _regexp_search(rabbit::VirtualMachine* v) static int64_t _regexp_search(rabbit::VirtualMachine* v)
{ {
SETUP_REX(v); SETUP_REX(v);
const rabbit::Char *str,*begin,*end; const char *str,*begin,*end;
int64_t start = 0; int64_t start = 0;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
if(sq_gettop(v) > 2) sq_getinteger(v,3,&start); if(sq_gettop(v) > 2) sq_getinteger(v,3,&start);
@ -427,7 +417,7 @@ static int64_t _regexp_search(rabbit::VirtualMachine* v)
static int64_t _regexp_capture(rabbit::VirtualMachine* v) static int64_t _regexp_capture(rabbit::VirtualMachine* v)
{ {
SETUP_REX(v); SETUP_REX(v);
const rabbit::Char *str,*begin,*end; const char *str,*begin,*end;
int64_t start = 0; int64_t start = 0;
sq_getstring(v,2,&str); sq_getstring(v,2,&str);
if(sq_gettop(v) > 2) sq_getinteger(v,3,&start); if(sq_gettop(v) > 2) sq_getinteger(v,3,&start);
@ -457,7 +447,7 @@ static int64_t _regexp_subexpcount(rabbit::VirtualMachine* v)
static int64_t _regexp_constructor(rabbit::VirtualMachine* v) static int64_t _regexp_constructor(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *error,*pattern; const char *error,*pattern;
sq_getstring(v,2,&pattern); sq_getstring(v,2,&pattern);
rabbit::std::SQRex *rex = rabbit::std::rex_compile(pattern,&error); rabbit::std::SQRex *rex = rabbit::std::rex_compile(pattern,&error);
if(!rex) return sq_throwerror(v,error); if(!rex) return sq_throwerror(v,error);

12
rabbit-std/sqstdstring.hpp
View File

@ -15,19 +15,19 @@ namespace rabbit {
using SQRex = struct SQRex; using SQRex = struct SQRex;
typedef struct { typedef struct {
const rabbit::Char *begin; const char *begin;
int64_t len; int64_t len;
} SQRexMatch; } SQRexMatch;
SQRex *rex_compile(const rabbit::Char *pattern,const rabbit::Char **error); SQRex *rex_compile(const char *pattern,const char **error);
void rex_free(SQRex *exp); void rex_free(SQRex *exp);
rabbit::Bool rex_match(SQRex* exp,const rabbit::Char* text); rabbit::Bool rex_match(SQRex* exp,const char* text);
rabbit::Bool rex_search(SQRex* exp,const rabbit::Char* text, const rabbit::Char** out_begin, const rabbit::Char** out_end); rabbit::Bool rex_search(SQRex* exp,const char* text, const char** out_begin, const char** out_end);
rabbit::Bool rex_searchrange(SQRex* exp,const rabbit::Char* text_begin,const rabbit::Char* text_end,const rabbit::Char** out_begin, const rabbit::Char** out_end); rabbit::Bool rex_searchrange(SQRex* exp,const char* text_begin,const char* text_end,const char** out_begin, const char** out_end);
int64_t rex_getsubexpcount(SQRex* exp); int64_t rex_getsubexpcount(SQRex* exp);
rabbit::Bool rex_getsubexp(SQRex* exp, int64_t n, SQRexMatch *subexp); rabbit::Bool rex_getsubexp(SQRex* exp, int64_t n, SQRexMatch *subexp);
rabbit::Result format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t *outlen,rabbit::Char **output); rabbit::Result format(rabbit::VirtualMachine* v,int64_t nformatstringidx,int64_t *outlen,char **output);
rabbit::Result register_stringlib(rabbit::VirtualMachine* v); rabbit::Result register_stringlib(rabbit::VirtualMachine* v);

33
rabbit-std/sqstdsystem.cpp
View File

@ -12,28 +12,13 @@
#include <stdio.h> #include <stdio.h>
#include <rabbit-std/sqstdsystem.hpp> #include <rabbit-std/sqstdsystem.hpp>
#ifdef SQUNICODE
#include <wchar.h>
#define scgetenv _wgetenv
#define scsystem _wsystem
#define scasctime _wasctime
#define scremove _wremove
#define screname _wrename
#else
#define scgetenv getenv
#define scsystem system
#define scasctime asctime
#define scremove remove
#define screname rename
#endif
#include <rabbit/RegFunction.hpp> #include <rabbit/RegFunction.hpp>
static int64_t _system_getenv(rabbit::VirtualMachine* v) static int64_t _system_getenv(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *s; const char *s;
if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){ if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){
sq_pushstring(v,scgetenv(s),-1); sq_pushstring(v,getenv(s),-1);
return 1; return 1;
} }
return 0; return 0;
@ -42,9 +27,9 @@ static int64_t _system_getenv(rabbit::VirtualMachine* v)
static int64_t _system_system(rabbit::VirtualMachine* v) static int64_t _system_system(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *s; const char *s;
if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){ if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){
sq_pushinteger(v,scsystem(s)); sq_pushinteger(v,system(s));
return 1; return 1;
} }
return sq_throwerror(v,_SC("wrong param")); return sq_throwerror(v,_SC("wrong param"));
@ -66,24 +51,24 @@ static int64_t _system_time(rabbit::VirtualMachine* v)
static int64_t _system_remove(rabbit::VirtualMachine* v) static int64_t _system_remove(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *s; const char *s;
sq_getstring(v,2,&s); sq_getstring(v,2,&s);
if(scremove(s)==-1) if(remove(s)==-1)
return sq_throwerror(v,_SC("remove() failed")); return sq_throwerror(v,_SC("remove() failed"));
return 0; return 0;
} }
static int64_t _system_rename(rabbit::VirtualMachine* v) static int64_t _system_rename(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *oldn,*newn; const char *oldn,*newn;
sq_getstring(v,2,&oldn); sq_getstring(v,2,&oldn);
sq_getstring(v,3,&newn); sq_getstring(v,3,&newn);
if(screname(oldn,newn)==-1) if(rename(oldn,newn)==-1)
return sq_throwerror(v,_SC("rename() failed")); return sq_throwerror(v,_SC("rename() failed"));
return 0; return 0;
} }
static void _set_integer_slot(rabbit::VirtualMachine* v,const rabbit::Char *name,int64_t val) static void _set_integer_slot(rabbit::VirtualMachine* v,const char *name,int64_t val)
{ {
sq_pushstring(v,name,-1); sq_pushstring(v,name,-1);
sq_pushinteger(v,val); sq_pushinteger(v,val);

4
rabbit/Closure.cpp
View File

@ -120,7 +120,7 @@ bool rabbit::ReadObject(rabbit::VirtualMachine* v,rabbit::UserPointer up,SQREADF
bool rabbit::Closure::save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write) bool rabbit::Closure::save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write)
{ {
_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_HEAD)); _CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_HEAD));
_CHECK_IO(WriteTag(v,write,up,sizeof(rabbit::Char))); _CHECK_IO(WriteTag(v,write,up,sizeof(char)));
_CHECK_IO(WriteTag(v,write,up,sizeof(int64_t))); _CHECK_IO(WriteTag(v,write,up,sizeof(int64_t)));
_CHECK_IO(WriteTag(v,write,up,sizeof(float_t))); _CHECK_IO(WriteTag(v,write,up,sizeof(float_t)));
_CHECK_IO(_function->save(v,up,write)); _CHECK_IO(_function->save(v,up,write));
@ -131,7 +131,7 @@ bool rabbit::Closure::save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWR
bool rabbit::Closure::load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &ret) bool rabbit::Closure::load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &ret)
{ {
_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_HEAD)); _CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_HEAD));
_CHECK_IO(CheckTag(v,read,up,sizeof(rabbit::Char))); _CHECK_IO(CheckTag(v,read,up,sizeof(char)));
_CHECK_IO(CheckTag(v,read,up,sizeof(int64_t))); _CHECK_IO(CheckTag(v,read,up,sizeof(int64_t)));
_CHECK_IO(CheckTag(v,read,up,sizeof(float_t))); _CHECK_IO(CheckTag(v,read,up,sizeof(float_t)));
rabbit::ObjectPtr func; rabbit::ObjectPtr func;

18
rabbit/Compiler.cpp
View File

@ -87,7 +87,7 @@ struct SQScope {
class Compiler class Compiler
{ {
public: public:
Compiler(rabbit::VirtualMachine *v, SQLEXREADFUNC rg, rabbit::UserPointer up, const rabbit::Char* sourcename, bool raiseerror, bool lineinfo) Compiler(rabbit::VirtualMachine *v, SQLEXREADFUNC rg, rabbit::UserPointer up, const char* sourcename, bool raiseerror, bool lineinfo)
{ {
_vm=v; _vm=v;
_lex.init(_get_shared_state(v), rg, up,Throwerror,this); _lex.init(_get_shared_state(v), rg, up,Throwerror,this);
@ -97,15 +97,15 @@ public:
_scope.stacksize = 0; _scope.stacksize = 0;
_compilererror[0] = _SC('\0'); _compilererror[0] = _SC('\0');
} }
static void Throwerror(void *ud, const rabbit::Char *s) { static void Throwerror(void *ud, const char *s) {
rabbit::Compiler *c = (rabbit::Compiler *)ud; rabbit::Compiler *c = (rabbit::Compiler *)ud;
c->error(s); c->error(s);
} }
void error(const rabbit::Char *s, ...) void error(const char *s, ...)
{ {
va_list vl; va_list vl;
va_start(vl, s); va_start(vl, s);
scvsprintf(_compilererror, MAX_COMPILER_ERROR_LEN, s, vl); vsnprintf(_compilererror, MAX_COMPILER_ERROR_LEN, s, vl);
va_end(vl); va_end(vl);
longjmp(_errorjmp,1); longjmp(_errorjmp,1);
} }
@ -118,7 +118,7 @@ public:
//do nothing //do nothing
} }
else { else {
const rabbit::Char *etypename; const char *etypename;
if(tok > 255) { if(tok > 255) {
switch(tok) switch(tok)
{ {
@ -363,7 +363,7 @@ public:
int64_t key = _fs->popTarget(); int64_t key = _fs->popTarget();
int64_t src = _fs->popTarget(); int64_t src = _fs->popTarget();
/* _OP_COMPARITH mixes dest obj and source val in the arg1 */ /* _OP_COMPARITH mixes dest obj and source val in the arg1 */
_fs->addInstruction(_OP_COMPARITH, _fs->pushTarget(), (src<<16)|val, key, ChooseCompArithCharByToken(tok)); _fs->addInstruction(_OP_COMPARITH, _fs->pushTarget(), (src<<16)|val, key, ChooseCompArithcharByToken(tok));
} }
break; break;
case OUTER: case OUTER:
@ -592,7 +592,7 @@ public:
} }
return _OP_ADD; return _OP_ADD;
} }
int64_t ChooseCompArithCharByToken(int64_t tok) int64_t ChooseCompArithcharByToken(int64_t tok)
{ {
int64_t oper; int64_t oper;
switch(tok){ switch(tok){
@ -1588,13 +1588,13 @@ private:
int64_t _debugop; int64_t _debugop;
SQExpState _es; SQExpState _es;
SQScope _scope; SQScope _scope;
rabbit::Char _compilererror[MAX_COMPILER_ERROR_LEN]; char _compilererror[MAX_COMPILER_ERROR_LEN];
jmp_buf _errorjmp; jmp_buf _errorjmp;
rabbit::VirtualMachine *_vm; rabbit::VirtualMachine *_vm;
}; };
} }
bool rabbit::compile(rabbit::VirtualMachine *vm,SQLEXREADFUNC rg, rabbit::UserPointer up, const rabbit::Char *sourcename, rabbit::ObjectPtr &out, bool raiseerror, bool lineinfo) bool rabbit::compile(rabbit::VirtualMachine *vm,SQLEXREADFUNC rg, rabbit::UserPointer up, const char *sourcename, rabbit::ObjectPtr &out, bool raiseerror, bool lineinfo)
{ {
rabbit::Compiler p(vm, rg, up, sourcename, raiseerror, lineinfo); rabbit::Compiler p(vm, rg, up, sourcename, raiseerror, lineinfo);
return p.compile(out); return p.compile(out);

4
rabbit/Compiler.hpp
View File

@ -82,7 +82,7 @@ namespace rabbit {
typedef void(*compilererrorFunc)(void *ud, const rabbit::Char *s); typedef void(*compilererrorFunc)(void *ud, const char *s);
bool compile(rabbit::VirtualMachine *vm, SQLEXREADFUNC rg, rabbit::UserPointer up, const rabbit::Char *sourcename, rabbit::ObjectPtr &out, bool raiseerror, bool lineinfo); bool compile(rabbit::VirtualMachine *vm, SQLEXREADFUNC rg, rabbit::UserPointer up, const char *sourcename, rabbit::ObjectPtr &out, bool raiseerror, bool lineinfo);
} }

70
rabbit/FuncState.cpp
View File

@ -97,11 +97,11 @@ void rabbit::FuncState::addInstruction(SQOpcode _op,int64_t arg0,int64_t arg1,in
static void dumpLiteral(rabbit::ObjectPtr &o) { static void dumpLiteral(rabbit::ObjectPtr &o) {
switch(sq_type(o)){ switch(sq_type(o)){
case rabbit::OT_STRING: scprintf(_SC("\"%s\""),_stringval(o));break; case rabbit::OT_STRING: printf(_SC("\"%s\""),_stringval(o));break;
case rabbit::OT_FLOAT: scprintf(_SC("{%f}"),_float(o));break; case rabbit::OT_FLOAT: printf(_SC("{%f}"),_float(o));break;
case rabbit::OT_INTEGER: scprintf(_SC("{") _PRINT_INT_FMT _SC("}"),_integer(o));break; case rabbit::OT_INTEGER: printf(_SC("{") _PRINT_INT_FMT _SC("}"),_integer(o));break;
case rabbit::OT_BOOL: scprintf(_SC("%s"),_integer(o)?_SC("true"):_SC("false"));break; case rabbit::OT_BOOL: printf(_SC("%s"),_integer(o)?_SC("true"):_SC("false"));break;
default: scprintf(_SC("(%s %p)"),getTypeName(o),(void*)_rawval(o));break; break; //shut up compiler default: printf(_SC("(%s %p)"),getTypeName(o),(void*)_rawval(o));break; break; //shut up compiler
} }
} }
@ -126,7 +126,7 @@ rabbit::FuncState::FuncState(rabbit::SharedState *ss,rabbit::FuncState *parent,c
} }
void rabbit::FuncState::error(const rabbit::Char *err) void rabbit::FuncState::error(const char *err)
{ {
_errfunc(_errtarget,err); _errfunc(_errtarget,err);
} }
@ -136,11 +136,11 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
{ {
uint64_t n=0,i; uint64_t n=0,i;
int64_t si; int64_t si;
scprintf(_SC("rabbit::Instruction sizeof %d\n"),(int32_t)sizeof(rabbit::Instruction)); printf(_SC("rabbit::Instruction sizeof %d\n"),(int32_t)sizeof(rabbit::Instruction));
scprintf(_SC("rabbit::Object sizeof %d\n"), (int32_t)sizeof(rabbit::Object)); printf(_SC("rabbit::Object sizeof %d\n"), (int32_t)sizeof(rabbit::Object));
scprintf(_SC("--------------------------------------------------------------------\n")); printf(_SC("--------------------------------------------------------------------\n"));
scprintf(_SC("*****FUNCTION [%s]\n"),sq_type(func->_name)==rabbit::OT_STRING?_stringval(func->_name):_SC("unknown")); printf(_SC("*****FUNCTION [%s]\n"),sq_type(func->_name)==rabbit::OT_STRING?_stringval(func->_name):_SC("unknown"));
scprintf(_SC("-----LITERALS\n")); printf(_SC("-----LITERALS\n"));
rabbit::ObjectPtr refidx,key,val; rabbit::ObjectPtr refidx,key,val;
int64_t idx; int64_t idx;
etk::Vector<rabbit::ObjectPtr> templiterals; etk::Vector<rabbit::ObjectPtr> templiterals;
@ -150,43 +150,43 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
templiterals[_integer(val)]=key; templiterals[_integer(val)]=key;
} }
for(i=0;i<templiterals.size();i++){ for(i=0;i<templiterals.size();i++){
scprintf(_SC("[%d] "), (int32_t)n); printf(_SC("[%d] "), (int32_t)n);
dumpLiteral(templiterals[i]); dumpLiteral(templiterals[i]);
scprintf(_SC("\n")); printf(_SC("\n"));
n++; n++;
} }
scprintf(_SC("-----PARAMS\n")); printf(_SC("-----PARAMS\n"));
if(_varparams) if(_varparams)
scprintf(_SC("<<VARPARAMS>>\n")); printf(_SC("<<VARPARAMS>>\n"));
n=0; n=0;
for(i=0;i<_parameters.size();i++){ for(i=0;i<_parameters.size();i++){
scprintf(_SC("[%d] "), (int32_t)n); printf(_SC("[%d] "), (int32_t)n);
dumpLiteral(_parameters[i]); dumpLiteral(_parameters[i]);
scprintf(_SC("\n")); printf(_SC("\n"));
n++; n++;
} }
scprintf(_SC("-----LOCALS\n")); printf(_SC("-----LOCALS\n"));
for(si=0;si<func->_nlocalvarinfos;si++){ for(si=0;si<func->_nlocalvarinfos;si++){
rabbit::LocalVarInfo lvi=func->_localvarinfos[si]; rabbit::LocalVarInfo lvi=func->_localvarinfos[si];
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); printf(_SC("[%d] %s \t%d %d\n"), (int32_t)lvi._pos,_stringval(lvi._name), (int32_t)lvi._start_op, (int32_t)lvi._end_op);
n++; n++;
} }
scprintf(_SC("-----LINE INFO\n")); printf(_SC("-----LINE INFO\n"));
for(i=0;i<_lineinfos.size();i++){ for(i=0;i<_lineinfos.size();i++){
rabbit::LineInfo li=_lineinfos[i]; rabbit::LineInfo li=_lineinfos[i];
scprintf(_SC("op [%d] line [%d] \n"), (int32_t)li._op, (int32_t)li._line); printf(_SC("op [%d] line [%d] \n"), (int32_t)li._op, (int32_t)li._line);
n++; n++;
} }
scprintf(_SC("-----dump\n")); printf(_SC("-----dump\n"));
n=0; n=0;
for(i=0;i<_instructions.size();i++){ for(i=0;i<_instructions.size();i++){
rabbit::Instruction &inst=_instructions[i]; rabbit::Instruction &inst=_instructions[i];
if(inst.op==_OP_LOAD || inst.op==_OP_DLOAD || inst.op==_OP_PREPCALLK || inst.op==_OP_GETK ){ if(inst.op==_OP_LOAD || inst.op==_OP_DLOAD || inst.op==_OP_PREPCALLK || inst.op==_OP_GETK ){
int64_t lidx = inst._arg1; int64_t lidx = inst._arg1;
scprintf(_SC("[%03d] %15s %d "), (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0); printf(_SC("[%03d] %15s %d "), (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0);
if(lidx >= 0xFFFFFFFF) if(lidx >= 0xFFFFFFFF)
scprintf(_SC("null")); printf(_SC("null"));
else { else {
int64_t refidx; int64_t refidx;
rabbit::ObjectPtr val,key,refo; rabbit::ObjectPtr val,key,refo;
@ -196,13 +196,13 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
dumpLiteral(key); dumpLiteral(key);
} }
if(inst.op != _OP_DLOAD) { if(inst.op != _OP_DLOAD) {
scprintf(_SC(" %d %d \n"),inst._arg2,inst._arg3); printf(_SC(" %d %d \n"),inst._arg2,inst._arg3);
} }
else { else {
scprintf(_SC(" %d "),inst._arg2); printf(_SC(" %d "),inst._arg2);
lidx = inst._arg3; lidx = inst._arg3;
if(lidx >= 0xFFFFFFFF) if(lidx >= 0xFFFFFFFF)
scprintf(_SC("null")); printf(_SC("null"));
else { else {
int64_t refidx; int64_t refidx;
rabbit::ObjectPtr val,key,refo; rabbit::ObjectPtr val,key,refo;
@ -210,24 +210,24 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
refo = refidx; refo = refidx;
} }
dumpLiteral(key); dumpLiteral(key);
scprintf(_SC("\n")); printf(_SC("\n"));
} }
} }
} }
else if(inst.op==_OP_LOADFLOAT) { else if(inst.op==_OP_LOADFLOAT) {
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); printf(_SC("[%03d] %15s %d %f %d %d\n"), (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0,*((float_t*)&inst._arg1),inst._arg2,inst._arg3);
} }
/* else if(inst.op==_OP_ARITH){ /* else if(inst.op==_OP_ARITH){
scprintf(_SC("[%03d] %15s %d %d %d %c\n"),n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3); printf(_SC("[%03d] %15s %d %d %d %c\n"),n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3);
}*/ }*/
else { else {
scprintf(_SC("[%03d] %15s %d %d %d %d\n"), (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3); printf(_SC("[%03d] %15s %d %d %d %d\n"), (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3);
} }
n++; n++;
} }
scprintf(_SC("-----\n")); printf(_SC("-----\n"));
scprintf(_SC("stack size[%d]\n"), (int32_t)func->_stacksize); printf(_SC("stack size[%d]\n"), (int32_t)func->_stacksize);
scprintf(_SC("--------------------------------------------------------------------\n\n")); printf(_SC("--------------------------------------------------------------------\n\n"));
} }
#endif #endif
@ -595,7 +595,7 @@ void rabbit::FuncState::addInstruction(rabbit::Instruction &i)
_instructions.pushBack(i); _instructions.pushBack(i);
} }
rabbit::Object rabbit::FuncState::createString(const rabbit::Char *s,int64_t len) rabbit::Object rabbit::FuncState::createString(const char *s,int64_t len)
{ {
rabbit::ObjectPtr ns(rabbit::String::create(_sharedstate,s,len)); rabbit::ObjectPtr ns(rabbit::String::create(_sharedstate,s,len));
_table(_strings)->newSlot(ns,(int64_t)1); _table(_strings)->newSlot(ns,(int64_t)1);

4
rabbit/FuncState.hpp
View File

@ -21,7 +21,7 @@ namespace rabbit {
#ifdef _DEBUG_DUMP #ifdef _DEBUG_DUMP
void dump(rabbit::FunctionProto *func); void dump(rabbit::FunctionProto *func);
#endif #endif
void error(const rabbit::Char *err); void error(const char *err);
FuncState *pushChildState(rabbit::SharedState *ss); FuncState *pushChildState(rabbit::SharedState *ss);
void popChildState(); void popChildState();
void addInstruction(SQOpcode _op,int64_t arg0=0,int64_t arg1=0,int64_t arg2=0,int64_t arg3=0); void addInstruction(SQOpcode _op,int64_t arg0=0,int64_t arg1=0,int64_t arg2=0,int64_t arg3=0);
@ -56,7 +56,7 @@ namespace rabbit {
int64_t getUpTarget(int64_t n); int64_t getUpTarget(int64_t n);
void discardTarget(); void discardTarget();
bool isLocal(uint64_t stkpos); bool isLocal(uint64_t stkpos);
rabbit::Object createString(const rabbit::Char *s,int64_t len = -1); rabbit::Object createString(const char *s,int64_t len = -1);
rabbit::Object createTable(); rabbit::Object createTable();
bool isConstant(const rabbit::Object &name,rabbit::Object &e); bool isConstant(const rabbit::Object &name,rabbit::Object &e);
int64_t _returnexp; int64_t _returnexp;

4
rabbit/FunctionInfo.hpp
View File

@ -14,8 +14,8 @@ namespace rabbit {
class FunctionInfo { class FunctionInfo {
public: public:
rabbit::UserPointer funcid; rabbit::UserPointer funcid;
const rabbit::Char* name; const char* name;
const rabbit::Char* source; const char* source;
int64_t line; int64_t line;
}; };
} }

4
rabbit/FunctionProto.cpp
View File

@ -65,10 +65,10 @@ void rabbit::FunctionProto::release(){
sq_vm_free(this,size); sq_vm_free(this,size);
} }
const rabbit::Char* rabbit::FunctionProto::getLocal(rabbit::VirtualMachine *vm,uint64_t stackbase,uint64_t nseq,uint64_t nop) const char* rabbit::FunctionProto::getLocal(rabbit::VirtualMachine *vm,uint64_t stackbase,uint64_t nseq,uint64_t nop)
{ {
uint64_t nvars=_nlocalvarinfos; uint64_t nvars=_nlocalvarinfos;
const rabbit::Char *res=NULL; const char *res=NULL;
if(nvars>=nseq){ if(nvars>=nseq){
for(uint64_t i=0;i<nvars;i++){ for(uint64_t i=0;i<nvars;i++){
if(_localvarinfos[i]._start_op<=nop && _localvarinfos[i]._end_op>=nop) if(_localvarinfos[i]._start_op<=nop && _localvarinfos[i]._end_op>=nop)

2
rabbit/FunctionProto.hpp
View File

@ -35,7 +35,7 @@ namespace rabbit {
int64_t nlineinfos,int64_t nlocalvarinfos,int64_t ndefaultparams); int64_t nlineinfos,int64_t nlocalvarinfos,int64_t ndefaultparams);
void release(); void release();
const rabbit::Char* getLocal(rabbit::VirtualMachine *v,uint64_t stackbase,uint64_t nseq,uint64_t nop); const char* getLocal(rabbit::VirtualMachine *v,uint64_t stackbase,uint64_t nseq,uint64_t nop);
int64_t getLine(rabbit::Instruction *curr); int64_t getLine(rabbit::Instruction *curr);
bool save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write); bool save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write);
static bool load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &ret); static bool load(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQREADFUNC read,rabbit::ObjectPtr &ret);

2
rabbit/Instruction.hpp
View File

@ -15,7 +15,7 @@ namespace rabbit {
class InstructionDesc { class InstructionDesc {
public: public:
const rabbit::Char *name; const char *name;
}; };
class Instruction { class Instruction {

99
rabbit/Lexer.cpp
View File

@ -81,7 +81,7 @@ void rabbit::Lexer::init(rabbit::SharedState *ss, SQLEXREADFUNC rg, rabbit::User
next(); next();
} }
void rabbit::Lexer::error(const rabbit::Char *err) void rabbit::Lexer::error(const char *err)
{ {
_errfunc(_errtarget,err); _errfunc(_errtarget,err);
} }
@ -89,16 +89,16 @@ void rabbit::Lexer::error(const rabbit::Char *err)
void rabbit::Lexer::next() void rabbit::Lexer::next()
{ {
int64_t t = _readf(_up); int64_t t = _readf(_up);
if(t > MAX_CHAR) error(_SC("Invalid character")); if(t > UINT8_MAX) error(_SC("Invalid character"));
if(t != 0) { if(t != 0) {
_currdata = (LexChar)t; _currdata = (Lexchar)t;
return; return;
} }
_currdata = RABBIT_EOB; _currdata = RABBIT_EOB;
_reached_eof = SQTrue; _reached_eof = SQTrue;
} }
const rabbit::Char *rabbit::Lexer::tok2Str(int64_t tok) const char *rabbit::Lexer::tok2Str(int64_t tok)
{ {
rabbit::ObjectPtr itr, key, val; rabbit::ObjectPtr itr, key, val;
int64_t nitr; int64_t nitr;
@ -261,17 +261,17 @@ int64_t rabbit::Lexer::Lex()
case RABBIT_EOB: case RABBIT_EOB:
return 0; return 0;
default:{ default:{
if (scisdigit(CUR_CHAR)) { if (isdigit(CUR_CHAR)) {
int64_t ret = readNumber(); int64_t ret = readNumber();
RETURN_TOKEN(ret); RETURN_TOKEN(ret);
} }
else if (scisalpha(CUR_CHAR) || CUR_CHAR == _SC('_')) { else if (isalpha(CUR_CHAR) || CUR_CHAR == _SC('_')) {
int64_t t = readId(); int64_t t = readId();
RETURN_TOKEN(t); RETURN_TOKEN(t);
} }
else { else {
int64_t c = CUR_CHAR; int64_t c = CUR_CHAR;
if (sciscntrl((int)c)) error(_SC("unexpected character(control)")); if (iscntrl((int)c)) error(_SC("unexpected character(control)"));
NEXT(); NEXT();
RETURN_TOKEN(c); RETURN_TOKEN(c);
} }
@ -282,7 +282,7 @@ int64_t rabbit::Lexer::Lex()
return 0; return 0;
} }
int64_t rabbit::Lexer::getIDType(const rabbit::Char *s,int64_t len) int64_t rabbit::Lexer::getIDType(const char *s,int64_t len)
{ {
rabbit::ObjectPtr t; rabbit::ObjectPtr t;
if(_keywords->getStr(s,len, t)) { if(_keywords->getStr(s,len, t)) {
@ -291,24 +291,6 @@ int64_t rabbit::Lexer::getIDType(const rabbit::Char *s,int64_t len)
return TK_IDENTIFIER; return TK_IDENTIFIER;
} }
#ifdef SQUNICODE
#if WCHAR_SIZE == 2
int64_t rabbit::Lexer::addUTF16(uint64_t ch)
{
if (ch >= 0x10000)
{
uint64_t code = (ch - 0x10000);
APPEND_CHAR((rabbit::Char)(0xD800 | (code >> 10)));
APPEND_CHAR((rabbit::Char)(0xDC00 | (code & 0x3FF)));
return 2;
}
else {
APPEND_CHAR((rabbit::Char)ch);
return 1;
}
}
#endif
#else
int64_t rabbit::Lexer::addUTF8(uint64_t ch) int64_t rabbit::Lexer::addUTF8(uint64_t ch)
{ {
if (ch < 0x80) { if (ch < 0x80) {
@ -316,28 +298,27 @@ int64_t rabbit::Lexer::addUTF8(uint64_t ch)
return 1; return 1;
} }
if (ch < 0x800) { if (ch < 0x800) {
APPEND_CHAR((rabbit::Char)((ch >> 6) | 0xC0)); APPEND_CHAR((char)((ch >> 6) | 0xC0));
APPEND_CHAR((rabbit::Char)((ch & 0x3F) | 0x80)); APPEND_CHAR((char)((ch & 0x3F) | 0x80));
return 2; return 2;
} }
if (ch < 0x10000) { if (ch < 0x10000) {
APPEND_CHAR((rabbit::Char)((ch >> 12) | 0xE0)); APPEND_CHAR((char)((ch >> 12) | 0xE0));
APPEND_CHAR((rabbit::Char)(((ch >> 6) & 0x3F) | 0x80)); APPEND_CHAR((char)(((ch >> 6) & 0x3F) | 0x80));
APPEND_CHAR((rabbit::Char)((ch & 0x3F) | 0x80)); APPEND_CHAR((char)((ch & 0x3F) | 0x80));
return 3; return 3;
} }
if (ch < 0x110000) { if (ch < 0x110000) {
APPEND_CHAR((rabbit::Char)((ch >> 18) | 0xF0)); APPEND_CHAR((char)((ch >> 18) | 0xF0));
APPEND_CHAR((rabbit::Char)(((ch >> 12) & 0x3F) | 0x80)); APPEND_CHAR((char)(((ch >> 12) & 0x3F) | 0x80));
APPEND_CHAR((rabbit::Char)(((ch >> 6) & 0x3F) | 0x80)); APPEND_CHAR((char)(((ch >> 6) & 0x3F) | 0x80));
APPEND_CHAR((rabbit::Char)((ch & 0x3F) | 0x80)); APPEND_CHAR((char)((ch & 0x3F) | 0x80));
return 4; return 4;
} }
return 0; return 0;
} }
#endif
int64_t rabbit::Lexer::processStringHexEscape(rabbit::Char *dest, int64_t maxdigits) int64_t rabbit::Lexer::processStringHexEscape(char *dest, int64_t maxdigits)
{ {
NEXT(); NEXT();
if (!isxdigit(CUR_CHAR)) error(_SC("hexadecimal number expected")); if (!isxdigit(CUR_CHAR)) error(_SC("hexadecimal number expected"));
@ -376,28 +357,20 @@ int64_t rabbit::Lexer::readString(int64_t ndelim,bool verbatim)
NEXT(); NEXT();
switch(CUR_CHAR) { switch(CUR_CHAR) {
case _SC('x'): { case _SC('x'): {
const int64_t maxdigits = sizeof(rabbit::Char) * 2; const int64_t maxdigits = sizeof(char) * 2;
rabbit::Char temp[maxdigits + 1]; char temp[maxdigits + 1];
processStringHexEscape(temp, maxdigits); processStringHexEscape(temp, maxdigits);
rabbit::Char *stemp; char *stemp;
APPEND_CHAR((rabbit::Char)scstrtoul(temp, &stemp, 16)); APPEND_CHAR((char)strtoul(temp, &stemp, 16));
} }
break; break;
case _SC('U'): case _SC('U'):
case _SC('u'): { case _SC('u'): {
const int64_t maxdigits = CUR_CHAR == 'u' ? 4 : 8; const int64_t maxdigits = CUR_CHAR == 'u' ? 4 : 8;
rabbit::Char temp[8 + 1]; char temp[8 + 1];
processStringHexEscape(temp, maxdigits); processStringHexEscape(temp, maxdigits);
rabbit::Char *stemp; char *stemp;
#ifdef SQUNICODE addUTF8(strtoul(temp, &stemp, 16));
#if WCHAR_SIZE == 2
addUTF16(scstrtoul(temp, &stemp, 16));
#else
APPEND_CHAR((rabbit::Char)scstrtoul(temp, &stemp, 16));
#endif
#else
addUTF8(scstrtoul(temp, &stemp, 16));
#endif
} }
break; break;
case _SC('t'): APPEND_CHAR(_SC('\t')); NEXT(); break; case _SC('t'): APPEND_CHAR(_SC('\t')); NEXT(); break;
@ -443,18 +416,18 @@ int64_t rabbit::Lexer::readString(int64_t ndelim,bool verbatim)
return TK_STRING_LITERAL; return TK_STRING_LITERAL;
} }
void LexHexadecimal(const rabbit::Char *s,uint64_t *res) void LexHexadecimal(const char *s,uint64_t *res)
{ {
*res = 0; *res = 0;
while(*s != 0) while(*s != 0)
{ {
if(scisdigit(*s)) *res = (*res)*16+((*s++)-'0'); if(isdigit(*s)) *res = (*res)*16+((*s++)-'0');
else if(scisxdigit(*s)) *res = (*res)*16+(toupper(*s++)-'A'+10); else if(isxdigit(*s)) *res = (*res)*16+(toupper(*s++)-'A'+10);
else { assert(0); } else { assert(0); }
} }
} }
void LexInteger(const rabbit::Char *s,uint64_t *res) void LexInteger(const char *s,uint64_t *res)
{ {
*res = 0; *res = 0;
while(*s != 0) while(*s != 0)
@ -465,7 +438,7 @@ void LexInteger(const rabbit::Char *s,uint64_t *res)
int64_t scisodigit(int64_t c) { return c >= _SC('0') && c <= _SC('7'); } int64_t scisodigit(int64_t c) { return c >= _SC('0') && c <= _SC('7'); }
void LexOctal(const rabbit::Char *s,uint64_t *res) void LexOctal(const char *s,uint64_t *res)
{ {
*res = 0; *res = 0;
while(*s != 0) while(*s != 0)
@ -487,7 +460,7 @@ int64_t rabbit::Lexer::readNumber()
#define TSCIENTIFIC 4 #define TSCIENTIFIC 4
#define TOCTAL 5 #define TOCTAL 5
int64_t type = TINT, firstchar = CUR_CHAR; int64_t type = TINT, firstchar = CUR_CHAR;
rabbit::Char *sTemp; char *sTemp;
INIT_TEMP_STRING(); INIT_TEMP_STRING();
NEXT(); NEXT();
if(firstchar == _SC('0') && (toupper(CUR_CHAR) == _SC('X') || scisodigit(CUR_CHAR)) ) { if(firstchar == _SC('0') && (toupper(CUR_CHAR) == _SC('X') || scisodigit(CUR_CHAR)) ) {
@ -497,7 +470,7 @@ int64_t rabbit::Lexer::readNumber()
APPEND_CHAR(CUR_CHAR); APPEND_CHAR(CUR_CHAR);
NEXT(); NEXT();
} }
if(scisdigit(CUR_CHAR)) error(_SC("invalid octal number")); if(isdigit(CUR_CHAR)) error(_SC("invalid octal number"));
} }
else { else {
NEXT(); NEXT();
@ -511,7 +484,7 @@ int64_t rabbit::Lexer::readNumber()
} }
else { else {
APPEND_CHAR((int)firstchar); APPEND_CHAR((int)firstchar);
while (CUR_CHAR == _SC('.') || scisdigit(CUR_CHAR) || isexponent(CUR_CHAR)) { while (CUR_CHAR == _SC('.') || isdigit(CUR_CHAR) || isexponent(CUR_CHAR)) {
if(CUR_CHAR == _SC('.') || isexponent(CUR_CHAR)) type = TFLOAT; if(CUR_CHAR == _SC('.') || isexponent(CUR_CHAR)) type = TFLOAT;
if(isexponent(CUR_CHAR)) { if(isexponent(CUR_CHAR)) {
if(type != TFLOAT) error(_SC("invalid numeric format")); if(type != TFLOAT) error(_SC("invalid numeric format"));
@ -522,7 +495,7 @@ int64_t rabbit::Lexer::readNumber()
APPEND_CHAR(CUR_CHAR); APPEND_CHAR(CUR_CHAR);
NEXT(); NEXT();
} }
if(!scisdigit(CUR_CHAR)) error(_SC("exponent expected")); if(!isdigit(CUR_CHAR)) error(_SC("exponent expected"));
} }
APPEND_CHAR(CUR_CHAR); APPEND_CHAR(CUR_CHAR);
@ -533,7 +506,7 @@ int64_t rabbit::Lexer::readNumber()
switch(type) { switch(type) {
case TSCIENTIFIC: case TSCIENTIFIC:
case TFLOAT: case TFLOAT:
_fvalue = (float_t)scstrtod(&_longstr[0],&sTemp); _fvalue = (float_t)strtod(&_longstr[0],&sTemp);
return TK_FLOAT; return TK_FLOAT;
case TINT: case TINT:
LexInteger(&_longstr[0],(uint64_t *)&_nvalue); LexInteger(&_longstr[0],(uint64_t *)&_nvalue);
@ -555,7 +528,7 @@ int64_t rabbit::Lexer::readId()
do { do {
APPEND_CHAR(CUR_CHAR); APPEND_CHAR(CUR_CHAR);
NEXT(); NEXT();
} while(scisalnum(CUR_CHAR) || CUR_CHAR == _SC('_')); } while(isalnum(CUR_CHAR) || CUR_CHAR == _SC('_'));
TERMINATE_BUFFER(); TERMINATE_BUFFER();
res = getIDType(&_longstr[0],_longstr.size() - 1); res = getIDType(&_longstr[0],_longstr.size() - 1);
if(res == TK_IDENTIFIER || res == TK_CONSTRUCTOR) { if(res == TK_IDENTIFIER || res == TK_CONSTRUCTOR) {

28
rabbit/Lexer.hpp
View File

@ -15,36 +15,26 @@
namespace rabbit { namespace rabbit {
#ifdef SQUNICODE typedef unsigned char Lexchar;
typedef Char LexChar;
#else
typedef unsigned char LexChar;
#endif
class Lexer { class Lexer {
public: public:
Lexer(); Lexer();
~Lexer(); ~Lexer();
void init(SharedState *ss,SQLEXREADFUNC rg,UserPointer up,compilererrorFunc efunc,void *ed); void init(SharedState *ss,SQLEXREADFUNC rg,UserPointer up,compilererrorFunc efunc,void *ed);
void error(const Char *err); void error(const char *err);
int64_t Lex(); int64_t Lex();
const Char *tok2Str(int64_t tok); const char *tok2Str(int64_t tok);
private: private:
int64_t getIDType(const Char *s,int64_t len); int64_t getIDType(const char *s,int64_t len);
int64_t readString(int64_t ndelim,bool verbatim); int64_t readString(int64_t ndelim,bool verbatim);
int64_t readNumber(); int64_t readNumber();
void lexBlockComment(); void lexBlockComment();
void lexLineComment(); void lexLineComment();
int64_t readId(); int64_t readId();
void next(); void next();
#ifdef SQUNICODE int64_t addUTF8(uint64_t ch);
#if WCHAR_SIZE == 2 int64_t processStringHexEscape(char *dest, int64_t maxdigits);
int64_t addUTF16(uint64_t ch);
#endif
#else
int64_t addUTF8(uint64_t ch);
#endif
int64_t processStringHexEscape(Char *dest, int64_t maxdigits);
int64_t _curtoken; int64_t _curtoken;
Table *_keywords; Table *_keywords;
Bool _reached_eof; Bool _reached_eof;
@ -53,14 +43,14 @@ namespace rabbit {
int64_t _currentline; int64_t _currentline;
int64_t _lasttokenline; int64_t _lasttokenline;
int64_t _currentcolumn; int64_t _currentcolumn;
const Char *_svalue; const char *_svalue;
int64_t _nvalue; int64_t _nvalue;
float_t _fvalue; float_t _fvalue;
SQLEXREADFUNC _readf; SQLEXREADFUNC _readf;
UserPointer _up; UserPointer _up;
LexChar _currdata; Lexchar _currdata;
SharedState *_sharedstate; SharedState *_sharedstate;
etk::Vector<Char> _longstr; etk::Vector<char> _longstr;
compilererrorFunc _errfunc; compilererrorFunc _errfunc;
void *_errtarget; void *_errtarget;
}; };

4
rabbit/ObjectPtr.cpp
View File

@ -152,7 +152,7 @@ uint64_t rabbit::translateIndex(const rabbit::ObjectPtr &idx)
} }
const rabbit::Char* rabbit::IdType2Name(rabbit::ObjectType type) const char* rabbit::IdType2Name(rabbit::ObjectType type)
{ {
switch(_RAW_TYPE(type)) switch(_RAW_TYPE(type))
{ {
@ -195,7 +195,7 @@ const rabbit::Char* rabbit::IdType2Name(rabbit::ObjectType type)
} }
} }
const rabbit::Char* rabbit::getTypeName(const rabbit::ObjectPtr &obj1) const char* rabbit::getTypeName(const rabbit::ObjectPtr &obj1)
{ {
return IdType2Name(sq_type(obj1)); return IdType2Name(sq_type(obj1));
} }

6
rabbit/ObjectPtr.hpp
View File

@ -58,12 +58,12 @@ namespace rabbit {
ObjectPtr& operator=(const Object& _obj); ObjectPtr& operator=(const Object& _obj);
void Null(); void Null();
private: private:
ObjectPtr(const rabbit::Char * _obj){} //safety ObjectPtr(const char * _obj){} //safety
}; };
uint64_t translateIndex(const rabbit::ObjectPtr &idx); uint64_t translateIndex(const rabbit::ObjectPtr &idx);
const rabbit::Char *getTypeName(const rabbit::ObjectPtr &obj1); const char *getTypeName(const rabbit::ObjectPtr &obj1);
const rabbit::Char *IdType2Name(rabbit::ObjectType type); const char *IdType2Name(rabbit::ObjectType type);
} }

4
rabbit/RegFunction.hpp
View File

@ -15,10 +15,10 @@ namespace rabbit {
class RegFunction{ class RegFunction{
public: public:
const rabbit::Char *name; const char *name;
SQFUNCTION f; SQFUNCTION f;
int64_t nparamscheck; int64_t nparamscheck;
const rabbit::Char *typemask; const char *typemask;
}; };
} }

8
rabbit/SharedState.cpp
View File

@ -51,7 +51,7 @@ rabbit::SharedState::SharedState()
_table(_metamethodsmap)->newSlot(_metamethods->back(),(int64_t)(_metamethods->size()-1)); \ _table(_metamethodsmap)->newSlot(_metamethods->back(),(int64_t)(_metamethods->size()-1)); \
} }
bool rabbit::compileTypemask(etk::Vector<int64_t> &res,const rabbit::Char *typemask) bool rabbit::compileTypemask(etk::Vector<int64_t> &res,const char *typemask)
{ {
int64_t i = 0; int64_t i = 0;
int64_t mask = 0; int64_t mask = 0;
@ -206,16 +206,16 @@ int64_t rabbit::SharedState::getMetaMethodIdxByName(const rabbit::ObjectPtr &nam
} }
rabbit::Char* rabbit::SharedState::getScratchPad(int64_t size) { char* rabbit::SharedState::getScratchPad(int64_t size) {
int64_t newsize; int64_t newsize;
if(size>0) { if(size>0) {
if(_scratchpadsize < size) { if(_scratchpadsize < size) {
newsize = size + (size>>1); newsize = size + (size>>1);
_scratchpad = (rabbit::Char *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize); _scratchpad = (char *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
_scratchpadsize = newsize; _scratchpadsize = newsize;
} else if(_scratchpadsize >= (size<<5)) { } else if(_scratchpadsize >= (size<<5)) {
newsize = _scratchpadsize >> 1; newsize = _scratchpadsize >> 1;
_scratchpad = (rabbit::Char *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize); _scratchpad = (char *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
_scratchpadsize = newsize; _scratchpadsize = newsize;
} }
} }

6
rabbit/SharedState.hpp
View File

@ -22,7 +22,7 @@ namespace rabbit {
~SharedState(); ~SharedState();
void init(); void init();
public: public:
rabbit::Char* getScratchPad(int64_t size); char* getScratchPad(int64_t size);
int64_t getMetaMethodIdxByName(const rabbit::ObjectPtr &name); int64_t getMetaMethodIdxByName(const rabbit::ObjectPtr &name);
etk::Vector<rabbit::ObjectPtr> *_metamethods; etk::Vector<rabbit::ObjectPtr> *_metamethods;
rabbit::ObjectPtr _metamethodsmap; rabbit::ObjectPtr _metamethodsmap;
@ -63,7 +63,7 @@ namespace rabbit {
rabbit::UserPointer _foreignptr; rabbit::UserPointer _foreignptr;
SQRELEASEHOOK _releasehook; SQRELEASEHOOK _releasehook;
private: private:
rabbit::Char *_scratchpad; char *_scratchpad;
int64_t _scratchpadsize; int64_t _scratchpadsize;
}; };
@ -81,7 +81,7 @@ namespace rabbit {
#define _instance_ddel _table(_sharedstate->_instance_default_delegate) #define _instance_ddel _table(_sharedstate->_instance_default_delegate)
#define _weakref_ddel _table(_sharedstate->_weakref_default_delegate) #define _weakref_ddel _table(_sharedstate->_weakref_default_delegate)
bool compileTypemask(etk::Vector<int64_t> &res,const rabbit::Char *typemask); bool compileTypemask(etk::Vector<int64_t> &res,const char *typemask);
} }

4
rabbit/StackInfos.hpp
View File

@ -13,8 +13,8 @@ namespace rabbit {
class StackInfos{ class StackInfos{
public: public:
const rabbit::Char* funcname; const char* funcname;
const rabbit::Char* source; const char* source;
int64_t line; int64_t line;
}; };

4
rabbit/String.cpp
View File

@ -11,7 +11,7 @@
#include <rabbit/StringTable.hpp> #include <rabbit/StringTable.hpp>
rabbit::Hash rabbit::_hashstr(const rabbit::Char *s, size_t l) { rabbit::Hash rabbit::_hashstr(const char *s, size_t l) {
rabbit::Hash h = (rabbit::Hash)l; /* seed */ rabbit::Hash h = (rabbit::Hash)l; /* seed */
size_t step = (l>>5)|1; /* if string is too long, don't hash all its chars */ size_t step = (l>>5)|1; /* if string is too long, don't hash all its chars */
for (; l>=step; l-=step) for (; l>=step; l-=step)
@ -20,7 +20,7 @@ rabbit::Hash rabbit::_hashstr(const rabbit::Char *s, size_t l) {
} }
rabbit::String *rabbit::String::create(rabbit::SharedState *ss,const rabbit::Char *s,int64_t len) rabbit::String *rabbit::String::create(rabbit::SharedState *ss,const char *s,int64_t len)
{ {
rabbit::String *str=ADD_STRING(ss,s,len); rabbit::String *str=ADD_STRING(ss,s,len);
return str; return str;

6
rabbit/String.hpp
View File

@ -16,21 +16,21 @@ namespace rabbit {
class SharedState; class SharedState;
class ObjectPtr; class ObjectPtr;
rabbit::Hash _hashstr (const rabbit::Char *s, size_t l); rabbit::Hash _hashstr (const char *s, size_t l);
class String : public rabbit::RefCounted { class String : public rabbit::RefCounted {
public: public:
String(){} String(){}
~String(){} ~String(){}
public: public:
static rabbit::String *create(rabbit::SharedState *ss, const rabbit::Char *, int64_t len = -1 ); static rabbit::String *create(rabbit::SharedState *ss, const char *, int64_t len = -1 );
int64_t next(const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval); int64_t next(const rabbit::ObjectPtr &refpos, rabbit::ObjectPtr &outkey, rabbit::ObjectPtr &outval);
void release(); void release();
rabbit::SharedState *_sharedstate; rabbit::SharedState *_sharedstate;
rabbit::String *_next; //chain for the string table rabbit::String *_next; //chain for the string table
int64_t _len; int64_t _len;
rabbit::Hash _hash; rabbit::Hash _hash;
rabbit::Char _val[1]; char _val[1];
}; };

4
rabbit/StringTable.cpp
View File

@ -34,10 +34,10 @@ void rabbit::StringTable::allocNodes(int64_t size)
memset(_strings,0,sizeof(rabbit::String*)*_numofslots); memset(_strings,0,sizeof(rabbit::String*)*_numofslots);
} }
rabbit::String *rabbit::StringTable::add(const rabbit::Char *news,int64_t len) rabbit::String *rabbit::StringTable::add(const char *news,int64_t len)
{ {
if(len<0) if(len<0)
len = (int64_t)scstrlen(news); len = (int64_t)strlen(news);
rabbit::Hash newhash = _hashstr(news,len); rabbit::Hash newhash = _hashstr(news,len);
rabbit::Hash h = newhash&(_numofslots-1); rabbit::Hash h = newhash&(_numofslots-1);
rabbit::String *s; rabbit::String *s;

2
rabbit/StringTable.hpp
View File

@ -16,7 +16,7 @@ namespace rabbit {
public: public:
StringTable(rabbit::SharedState*ss); StringTable(rabbit::SharedState*ss);
~StringTable(); ~StringTable();
rabbit::String *add(const rabbit::Char *,int64_t len); rabbit::String *add(const char *,int64_t len);
void remove(rabbit::String *); void remove(rabbit::String *);
private: private:
void resize(int64_t size); void resize(int64_t size);

4
rabbit/Table.cpp
View File

@ -262,12 +262,12 @@ rabbit::Table::_HashNode* rabbit::Table::_get(const rabbit::ObjectPtr &key,rabbi
} }
//for compiler use //for compiler use
bool rabbit::Table::getStr(const rabbit::Char* key,int64_t keylen,rabbit::ObjectPtr &val) { bool rabbit::Table::getStr(const char* key,int64_t keylen,rabbit::ObjectPtr &val) {
rabbit::Hash hash = _hashstr(key,keylen); rabbit::Hash hash = _hashstr(key,keylen);
_HashNode *n = &_nodes[hash & (_numofnodes - 1)]; _HashNode *n = &_nodes[hash & (_numofnodes - 1)];
_HashNode *res = NULL; _HashNode *res = NULL;
do{ do{
if(sq_type(n->key) == rabbit::OT_STRING && (scstrcmp(_stringval(n->key),key) == 0)){ if(sq_type(n->key) == rabbit::OT_STRING && (strcmp(_stringval(n->key),key) == 0)){
res = n; res = n;
break; break;
} }

2
rabbit/Table.hpp
View File

@ -40,7 +40,7 @@ namespace rabbit {
~Table(); ~Table();
_HashNode *_get(const rabbit::ObjectPtr &key,rabbit::Hash hash); _HashNode *_get(const rabbit::ObjectPtr &key,rabbit::Hash hash);
//for compiler use //for compiler use
bool getStr(const rabbit::Char* key,int64_t keylen,rabbit::ObjectPtr &val); bool getStr(const char* key,int64_t keylen,rabbit::ObjectPtr &val);
bool get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val); bool get(const rabbit::ObjectPtr &key,rabbit::ObjectPtr &val);
void remove(const rabbit::ObjectPtr &key); void remove(const rabbit::ObjectPtr &key);
bool set(const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &val); bool set(const rabbit::ObjectPtr &key, const rabbit::ObjectPtr &val);

64
rabbit/VirtualMachine.cpp
View File

@ -231,7 +231,7 @@ bool rabbit::VirtualMachine::objCmp(const rabbit::ObjectPtr &o1,const rabbit::Ob
rabbit::ObjectPtr res; rabbit::ObjectPtr res;
switch(t1){ switch(t1){
case rabbit::OT_STRING: case rabbit::OT_STRING:
_RET_SUCCEED(scstrcmp(_stringval(o1),_stringval(o2))); _RET_SUCCEED(strcmp(_stringval(o1),_stringval(o2)));
case rabbit::OT_INTEGER: case rabbit::OT_INTEGER:
_RET_SUCCEED((_integer(o1)<_integer(o2))?-1:1); _RET_SUCCEED((_integer(o1)<_integer(o2))?-1:1);
case rabbit::OT_FLOAT: case rabbit::OT_FLOAT:
@ -307,13 +307,13 @@ bool rabbit::VirtualMachine::toString(const rabbit::ObjectPtr &o,rabbit::ObjectP
res = o; res = o;
return true; return true;
case rabbit::OT_FLOAT: case rabbit::OT_FLOAT:
scsprintf(_sp(sq_rsl(NUMBER_MAX_CHAR+1)),sq_rsl(NUMBER_MAX_CHAR),_SC("%g"),_float(o)); snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)),sq_rsl(NUMBER_UINT8_MAX),_SC("%g"),_float(o));
break; break;
case rabbit::OT_INTEGER: case rabbit::OT_INTEGER:
scsprintf(_sp(sq_rsl(NUMBER_MAX_CHAR+1)),sq_rsl(NUMBER_MAX_CHAR),_PRINT_INT_FMT,_integer(o)); snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)),sq_rsl(NUMBER_UINT8_MAX),_PRINT_INT_FMT,_integer(o));
break; break;
case rabbit::OT_BOOL: case rabbit::OT_BOOL:
scsprintf(_sp(sq_rsl(6)),sq_rsl(6),_integer(o)?_SC("true"):_SC("false")); snprintf(_sp(sq_rsl(6)),sq_rsl(6),_integer(o)?_SC("true"):_SC("false"));
break; break;
case rabbit::OT_TABLE: case rabbit::OT_TABLE:
case rabbit::OT_USERDATA: case rabbit::OT_USERDATA:
@ -332,7 +332,7 @@ bool rabbit::VirtualMachine::toString(const rabbit::ObjectPtr &o,rabbit::ObjectP
} }
} }
default: default:
scsprintf(_sp(sq_rsl((sizeof(void*)*2)+NUMBER_MAX_CHAR)),sq_rsl((sizeof(void*)*2)+NUMBER_MAX_CHAR),_SC("(%s : 0x%p)"),getTypeName(o),(void*)_rawval(o)); snprintf(_sp(sq_rsl((sizeof(void*)*2)+NUMBER_UINT8_MAX)),sq_rsl((sizeof(void*)*2)+NUMBER_UINT8_MAX),_SC("(%s : 0x%p)"),getTypeName(o),(void*)_rawval(o));
} }
res = rabbit::String::create(_get_shared_state(this),_spval); res = rabbit::String::create(_get_shared_state(this),_spval);
return true; return true;
@ -345,7 +345,7 @@ bool rabbit::VirtualMachine::stringCat(const rabbit::ObjectPtr &str,const rabbit
if(!toString(str, a)) return false; if(!toString(str, a)) return false;
if(!toString(obj, b)) return false; if(!toString(obj, b)) return false;
int64_t l = _string(a)->_len , ol = _string(b)->_len; int64_t l = _string(a)->_len , ol = _string(b)->_len;
rabbit::Char *s = _sp(sq_rsl(l + ol + 1)); char *s = _sp(sq_rsl(l + ol + 1));
memcpy(s, _stringval(a), sq_rsl(l)); memcpy(s, _stringval(a), sq_rsl(l));
memcpy(s + l, _stringval(b), sq_rsl(ol)); memcpy(s + l, _stringval(b), sq_rsl(ol));
dest = rabbit::String::create(_get_shared_state(this), _spval, l + ol); dest = rabbit::String::create(_get_shared_state(this), _spval, l + ol);
@ -727,7 +727,7 @@ exception_restore:
{ {
const rabbit::Instruction &_i_ = *ci->_ip++; const rabbit::Instruction &_i_ = *ci->_ip++;
//dumpstack(_stackbase); //dumpstack(_stackbase);
//scprintf("\n[%d] %s %d %d %d %d\n",ci->_ip-_closure(ci->_closure)->_function->_instructions,g_InstrDesc[_i_.op].name,arg0,arg1,arg2,arg3); //printf("\n[%d] %s %d %d %d %d\n",ci->_ip-_closure(ci->_closure)->_function->_instructions,g_InstrDesc[_i_.op].name,arg0,arg1,arg2,arg3);
switch(_i_.op) switch(_i_.op)
{ {
case _OP_LINE: if (_debughook) callDebugHook(_SC('l'),arg1); continue; case _OP_LINE: if (_debughook) callDebugHook(_SC('l'),arg1); continue;
@ -1144,8 +1144,8 @@ void rabbit::VirtualMachine::callDebugHook(int64_t type,int64_t forcedline)
_debughook = false; _debughook = false;
rabbit::FunctionProto *func=_closure(ci->_closure)->_function; rabbit::FunctionProto *func=_closure(ci->_closure)->_function;
if(_debughook_native) { if(_debughook_native) {
const rabbit::Char *src = sq_type(func->_sourcename) == rabbit::OT_STRING?_stringval(func->_sourcename):NULL; const char *src = sq_type(func->_sourcename) == rabbit::OT_STRING?_stringval(func->_sourcename):NULL;
const rabbit::Char *fname = sq_type(func->_name) == rabbit::OT_STRING?_stringval(func->_name):NULL; const char *fname = sq_type(func->_name) == rabbit::OT_STRING?_stringval(func->_name):NULL;
int64_t line = forcedline?forcedline:func->getLine(ci->_ip); int64_t line = forcedline?forcedline:func->getLine(ci->_ip);
_debughook_native(this,type,src,line,fname); _debughook_native(this,type,src,line,fname);
} }
@ -1762,37 +1762,37 @@ void rabbit::VirtualMachine::dumpstack(int64_t stackbase,bool dumpall)
{ {
int64_t size=dumpall?_stack.size():_top; int64_t size=dumpall?_stack.size():_top;
int64_t n=0; int64_t n=0;
scprintf(_SC("\n>>>>stack dump<<<<\n")); printf(_SC("\n>>>>stack dump<<<<\n"));
callInfo &ci=_callsstack[_callsstacksize-1]; callInfo &ci=_callsstack[_callsstacksize-1];
scprintf(_SC("IP: %p\n"),ci._ip); printf(_SC("IP: %p\n"),ci._ip);
scprintf(_SC("prev stack base: %d\n"),ci._prevstkbase); printf(_SC("prev stack base: %d\n"),ci._prevstkbase);
scprintf(_SC("prev top: %d\n"),ci._prevtop); printf(_SC("prev top: %d\n"),ci._prevtop);
for(int64_t i=0;i<size;i++){ for(int64_t i=0;i<size;i++){
rabbit::ObjectPtr &obj=_stack[i]; rabbit::ObjectPtr &obj=_stack[i];
if(stackbase==i)scprintf(_SC(">"));else scprintf(_SC(" ")); if(stackbase==i)printf(_SC(">"));else printf(_SC(" "));
scprintf(_SC("[" _PRINT_INT_FMT "]:"),n); printf(_SC("[" _PRINT_INT_FMT "]:"),n);
switch(sq_type(obj)){ switch(sq_type(obj)){
case rabbit::OT_FLOAT: scprintf(_SC("FLOAT %.3f"),_float(obj));break; case rabbit::OT_FLOAT: printf(_SC("FLOAT %.3f"),_float(obj));break;
case rabbit::OT_INTEGER: scprintf(_SC("INTEGER " _PRINT_INT_FMT),_integer(obj));break; case rabbit::OT_INTEGER: printf(_SC("INTEGER " _PRINT_INT_FMT),_integer(obj));break;
case rabbit::OT_BOOL: scprintf(_SC("BOOL %s"),_integer(obj)?"true":"false");break; case rabbit::OT_BOOL: printf(_SC("BOOL %s"),_integer(obj)?"true":"false");break;
case rabbit::OT_STRING: scprintf(_SC("STRING %s"),_stringval(obj));break; case rabbit::OT_STRING: printf(_SC("STRING %s"),_stringval(obj));break;
case rabbit::OT_NULL: scprintf(_SC("NULL")); break; case rabbit::OT_NULL: printf(_SC("NULL")); break;
case rabbit::OT_TABLE: scprintf(_SC("TABLE %p[%p]"),_table(obj),_table(obj)->_delegate);break; case rabbit::OT_TABLE: printf(_SC("TABLE %p[%p]"),_table(obj),_table(obj)->_delegate);break;
case rabbit::OT_ARRAY: scprintf(_SC("ARRAY %p"),_array(obj));break; case rabbit::OT_ARRAY: printf(_SC("ARRAY %p"),_array(obj));break;
case rabbit::OT_CLOSURE: scprintf(_SC("CLOSURE [%p]"),_closure(obj));break; case rabbit::OT_CLOSURE: printf(_SC("CLOSURE [%p]"),_closure(obj));break;
case rabbit::OT_NATIVECLOSURE: scprintf(_SC("NATIVECLOSURE"));break; case rabbit::OT_NATIVECLOSURE: printf(_SC("NATIVECLOSURE"));break;
case rabbit::OT_USERDATA: scprintf(_SC("USERDATA %p[%p]"),_userdataval(obj),_userdata(obj)->_delegate);break; case rabbit::OT_USERDATA: printf(_SC("USERDATA %p[%p]"),_userdataval(obj),_userdata(obj)->_delegate);break;
case rabbit::OT_GENERATOR: scprintf(_SC("GENERATOR %p"),_generator(obj));break; case rabbit::OT_GENERATOR: printf(_SC("GENERATOR %p"),_generator(obj));break;
case rabbit::OT_THREAD: scprintf(_SC("THREAD [%p]"),_thread(obj));break; case rabbit::OT_THREAD: printf(_SC("THREAD [%p]"),_thread(obj));break;
case rabbit::OT_USERPOINTER: scprintf(_SC("USERPOINTER %p"),_userpointer(obj));break; case rabbit::OT_USERPOINTER: printf(_SC("USERPOINTER %p"),_userpointer(obj));break;
case rabbit::OT_CLASS: scprintf(_SC("CLASS %p"),_class(obj));break; case rabbit::OT_CLASS: printf(_SC("CLASS %p"),_class(obj));break;
case rabbit::OT_INSTANCE: scprintf(_SC("INSTANCE %p"),_instance(obj));break; case rabbit::OT_INSTANCE: printf(_SC("INSTANCE %p"),_instance(obj));break;
case rabbit::OT_WEAKREF: scprintf(_SC("WEAKERF %p"),_weakref(obj));break; case rabbit::OT_WEAKREF: printf(_SC("WEAKERF %p"),_weakref(obj));break;
default: default:
assert(0); assert(0);
break; break;
}; };
scprintf(_SC("\n")); printf(_SC("\n"));
++n; ++n;
} }
} }

6
rabbit/VirtualMachine.hpp
View File

@ -51,8 +51,8 @@ namespace rabbit {
rabbit::Bool _root; rabbit::Bool _root;
}; };
public: public:
void DebugHookProxy(int64_t type, const rabbit::Char * sourcename, int64_t line, const rabbit::Char * funcname); void DebugHookProxy(int64_t type, const char * sourcename, int64_t line, const char * funcname);
static void _DebugHookProxy(rabbit::VirtualMachine* v, int64_t type, const rabbit::Char * sourcename, int64_t line, const rabbit::Char * funcname); static void _DebugHookProxy(rabbit::VirtualMachine* v, int64_t type, const char * sourcename, int64_t line, const char * funcname);
enum ExecutionType { enum ExecutionType {
ET_CALL, ET_CALL,
ET_RESUME_GENERATOR, ET_RESUME_GENERATOR,
@ -91,7 +91,7 @@ namespace rabbit {
rabbit::String *printObjVal(const rabbit::ObjectPtr &o); rabbit::String *printObjVal(const rabbit::ObjectPtr &o);
void raise_error(const rabbit::Char *s, ...); void raise_error(const char *s, ...);
void raise_error(const rabbit::ObjectPtr &desc); void raise_error(const rabbit::ObjectPtr &desc);
void raise_Idxerror(const rabbit::ObjectPtr &o); void raise_Idxerror(const rabbit::ObjectPtr &o);
void raise_Compareerror(const rabbit::Object &o1, const rabbit::Object &o2); void raise_Compareerror(const rabbit::Object &o1, const rabbit::Object &o2);

35
rabbit/rabbit.hpp
View File

@ -17,11 +17,6 @@
#endif #endif
#endif #endif
#ifdef _UNICODE
#define SQUNICODE
#endif
#include "sqconfig.hpp" #include "sqconfig.hpp"
#define RABBIT_VERSION _SC("Rabbit 0.1 un-stable") #define RABBIT_VERSION _SC("Rabbit 0.1 un-stable")
@ -44,9 +39,9 @@
typedef int64_t (*SQFUNCTION)(rabbit::VirtualMachine*); typedef int64_t (*SQFUNCTION)(rabbit::VirtualMachine*);
typedef int64_t (*SQRELEASEHOOK)(rabbit::UserPointer,int64_t size); typedef int64_t (*SQRELEASEHOOK)(rabbit::UserPointer,int64_t size);
typedef void (*SQCOMPILERERROR)(rabbit::VirtualMachine*,const rabbit::Char * /*desc*/,const rabbit::Char * /*source*/,int64_t /*line*/,int64_t /*column*/); typedef void (*SQCOMPILERERROR)(rabbit::VirtualMachine*,const char * /*desc*/,const char * /*source*/,int64_t /*line*/,int64_t /*column*/);
typedef void (*SQPRINTFUNCTION)(rabbit::VirtualMachine*,const rabbit::Char * ,...); typedef void (*SQPRINTFUNCTION)(rabbit::VirtualMachine*,const char * ,...);
typedef void (*SQDEBUGHOOK)(rabbit::VirtualMachine* /*v*/, int64_t /*type*/, const rabbit::Char * /*sourcename*/, int64_t /*line*/, const rabbit::Char * /*funcname*/); typedef void (*SQDEBUGHOOK)(rabbit::VirtualMachine* /*v*/, int64_t /*type*/, const char * /*sourcename*/, int64_t /*line*/, const char * /*funcname*/);
typedef int64_t (*SQWRITEFUNC)(rabbit::UserPointer,rabbit::UserPointer,int64_t); typedef int64_t (*SQWRITEFUNC)(rabbit::UserPointer,rabbit::UserPointer,int64_t);
typedef int64_t (*SQREADFUNC)(rabbit::UserPointer,rabbit::UserPointer,int64_t); typedef int64_t (*SQREADFUNC)(rabbit::UserPointer,rabbit::UserPointer,int64_t);
@ -75,8 +70,8 @@ int64_t sq_getvmstate(rabbit::VirtualMachine* v);
int64_t sq_getversion(); int64_t sq_getversion();
/*compiler*/ /*compiler*/
rabbit::Result sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::UserPointer p,const rabbit::Char *sourcename,rabbit::Bool raiseerror); rabbit::Result sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::UserPointer p,const char *sourcename,rabbit::Bool raiseerror);
rabbit::Result sq_compilebuffer(rabbit::VirtualMachine* v,const rabbit::Char *s,int64_t size,const rabbit::Char *sourcename,rabbit::Bool raiseerror); rabbit::Result sq_compilebuffer(rabbit::VirtualMachine* v,const char *s,int64_t size,const char *sourcename,rabbit::Bool raiseerror);
void sq_enabledebuginfo(rabbit::VirtualMachine* v, rabbit::Bool enable); void sq_enabledebuginfo(rabbit::VirtualMachine* v, rabbit::Bool enable);
void sq_notifyallexceptions(rabbit::VirtualMachine* v, rabbit::Bool enable); void sq_notifyallexceptions(rabbit::VirtualMachine* v, rabbit::Bool enable);
void sq_setcompilererrorhandler(rabbit::VirtualMachine* v,SQCOMPILERERROR f); void sq_setcompilererrorhandler(rabbit::VirtualMachine* v,SQCOMPILERERROR f);
@ -98,11 +93,11 @@ void sq_newtable(rabbit::VirtualMachine* v);
void sq_newtableex(rabbit::VirtualMachine* v,int64_t initialcapacity); void sq_newtableex(rabbit::VirtualMachine* v,int64_t initialcapacity);
void sq_newarray(rabbit::VirtualMachine* v,int64_t size); void sq_newarray(rabbit::VirtualMachine* v,int64_t size);
void sq_newclosure(rabbit::VirtualMachine* v,SQFUNCTION func,uint64_t nfreevars); void sq_newclosure(rabbit::VirtualMachine* v,SQFUNCTION func,uint64_t nfreevars);
rabbit::Result sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const rabbit::Char *typemask); rabbit::Result sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const char *typemask);
rabbit::Result sq_bindenv(rabbit::VirtualMachine* v,int64_t idx); rabbit::Result sq_bindenv(rabbit::VirtualMachine* v,int64_t idx);
rabbit::Result sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx); rabbit::Result sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx);
rabbit::Result sq_getclosureroot(rabbit::VirtualMachine* v,int64_t idx); rabbit::Result sq_getclosureroot(rabbit::VirtualMachine* v,int64_t idx);
void sq_pushstring(rabbit::VirtualMachine* v,const rabbit::Char *s,int64_t len); void sq_pushstring(rabbit::VirtualMachine* v,const char *s,int64_t len);
void sq_pushfloat(rabbit::VirtualMachine* v,float_t f); void sq_pushfloat(rabbit::VirtualMachine* v,float_t f);
void sq_pushinteger(rabbit::VirtualMachine* v,int64_t n); void sq_pushinteger(rabbit::VirtualMachine* v,int64_t n);
void sq_pushbool(rabbit::VirtualMachine* v,rabbit::Bool b); void sq_pushbool(rabbit::VirtualMachine* v,rabbit::Bool b);
@ -117,8 +112,8 @@ rabbit::Result sq_getbase(rabbit::VirtualMachine* v,int64_t idx);
rabbit::Bool sq_instanceof(rabbit::VirtualMachine* v); rabbit::Bool sq_instanceof(rabbit::VirtualMachine* v);
rabbit::Result sq_tostring(rabbit::VirtualMachine* v,int64_t idx); rabbit::Result sq_tostring(rabbit::VirtualMachine* v,int64_t idx);
void sq_tobool(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool *b); void sq_tobool(rabbit::VirtualMachine* v, int64_t idx, rabbit::Bool *b);
rabbit::Result sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c,int64_t *size); rabbit::Result sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const char **c,int64_t *size);
rabbit::Result sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c); rabbit::Result sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const char **c);
rabbit::Result sq_getinteger(rabbit::VirtualMachine* v,int64_t idx,int64_t *i); rabbit::Result sq_getinteger(rabbit::VirtualMachine* v,int64_t idx,int64_t *i);
rabbit::Result sq_getfloat(rabbit::VirtualMachine* v,int64_t idx,float_t *f); rabbit::Result sq_getfloat(rabbit::VirtualMachine* v,int64_t idx,float_t *f);
rabbit::Result sq_getbool(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool *b); rabbit::Result sq_getbool(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool *b);
@ -129,11 +124,11 @@ rabbit::Result sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserP
rabbit::Result sq_gettypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *typetag); rabbit::Result sq_gettypetag(rabbit::VirtualMachine* v,int64_t idx,rabbit::UserPointer *typetag);
void sq_setreleasehook(rabbit::VirtualMachine* v,int64_t idx,SQRELEASEHOOK hook); void sq_setreleasehook(rabbit::VirtualMachine* v,int64_t idx,SQRELEASEHOOK hook);
SQRELEASEHOOK sq_getreleasehook(rabbit::VirtualMachine* v,int64_t idx); SQRELEASEHOOK sq_getreleasehook(rabbit::VirtualMachine* v,int64_t idx);
rabbit::Char *sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize); char *sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize);
rabbit::Result sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,rabbit::FunctionInfo *fi); rabbit::Result sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t level,rabbit::FunctionInfo *fi);
rabbit::Result sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,uint64_t *nparams,uint64_t *nfreevars); rabbit::Result sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,uint64_t *nparams,uint64_t *nfreevars);
rabbit::Result sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx); rabbit::Result sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx);
rabbit::Result sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char *name); rabbit::Result sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const char *name);
rabbit::Result sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer p); rabbit::Result sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer p);
rabbit::Result sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p,rabbit::UserPointer typetag); rabbit::Result sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p,rabbit::UserPointer typetag);
rabbit::Result sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize); rabbit::Result sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize);
@ -180,10 +175,10 @@ rabbit::Result sq_clear(rabbit::VirtualMachine* v,int64_t idx);
/*calls*/ /*calls*/
rabbit::Result sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::Bool retval,rabbit::Bool raiseerror); rabbit::Result sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::Bool retval,rabbit::Bool raiseerror);
rabbit::Result sq_resume(rabbit::VirtualMachine* v,rabbit::Bool retval,rabbit::Bool raiseerror); rabbit::Result sq_resume(rabbit::VirtualMachine* v,rabbit::Bool retval,rabbit::Bool raiseerror);
const rabbit::Char *sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx); const char *sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx);
rabbit::Result sq_getcallee(rabbit::VirtualMachine* v); rabbit::Result sq_getcallee(rabbit::VirtualMachine* v);
const rabbit::Char *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval); const char *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval);
rabbit::Result sq_throwerror(rabbit::VirtualMachine* v,const rabbit::Char *err); rabbit::Result sq_throwerror(rabbit::VirtualMachine* v,const char *err);
rabbit::Result sq_throwobject(rabbit::VirtualMachine* v); rabbit::Result sq_throwobject(rabbit::VirtualMachine* v);
void sq_reseterror(rabbit::VirtualMachine* v); void sq_reseterror(rabbit::VirtualMachine* v);
void sq_getlasterror(rabbit::VirtualMachine* v); void sq_getlasterror(rabbit::VirtualMachine* v);
@ -196,7 +191,7 @@ void sq_addref(rabbit::VirtualMachine* v,rabbit::Object *po);
rabbit::Bool sq_release(rabbit::VirtualMachine* v,rabbit::Object *po); rabbit::Bool sq_release(rabbit::VirtualMachine* v,rabbit::Object *po);
uint64_t sq_getrefcount(rabbit::VirtualMachine* v,rabbit::Object *po); uint64_t sq_getrefcount(rabbit::VirtualMachine* v,rabbit::Object *po);
void sq_resetobject(rabbit::Object *po); void sq_resetobject(rabbit::Object *po);
const rabbit::Char *sq_objtostring(const rabbit::Object *o); const char *sq_objtostring(const rabbit::Object *o);
rabbit::Bool sq_objtobool(const rabbit::Object *o); rabbit::Bool sq_objtobool(const rabbit::Object *o);
int64_t sq_objtointeger(const rabbit::Object *o); int64_t sq_objtointeger(const rabbit::Object *o);
float_t sq_objtofloat(const rabbit::Object *o); float_t sq_objtofloat(const rabbit::Object *o);

32
rabbit/sqapi.cpp
View File

@ -51,8 +51,8 @@ static bool sq_aux_gettypedarg(rabbit::VirtualMachine* v,int64_t idx,rabbit::Obj
namespace rabbit { namespace rabbit {
int64_t sq_aux_invalidtype(rabbit::VirtualMachine* v,rabbit::ObjectType type) int64_t sq_aux_invalidtype(rabbit::VirtualMachine* v,rabbit::ObjectType type)
{ {
uint64_t buf_size = 100 *sizeof(rabbit::Char); uint64_t buf_size = 100 *sizeof(char);
scsprintf(_get_shared_state(v)->getScratchPad(buf_size), buf_size, _SC("unexpected type %s"), IdType2Name(type)); snprintf(_get_shared_state(v)->getScratchPad(buf_size), buf_size, _SC("unexpected type %s"), IdType2Name(type));
return sq_throwerror(v, _get_shared_state(v)->getScratchPad(-1)); return sq_throwerror(v, _get_shared_state(v)->getScratchPad(-1));
} }
} }
@ -144,7 +144,7 @@ int64_t rabbit::sq_getversion()
return RABBIT_VERSION_NUMBER; return RABBIT_VERSION_NUMBER;
} }
rabbit::Result rabbit::sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::UserPointer p,const rabbit::Char *sourcename,rabbit::Bool raiseerror) rabbit::Result rabbit::sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::UserPointer p,const char *sourcename,rabbit::Bool raiseerror)
{ {
rabbit::ObjectPtr o; rabbit::ObjectPtr o;
#ifndef NO_COMPILER #ifndef NO_COMPILER
@ -194,7 +194,7 @@ uint64_t rabbit::sq_getvmrefcount(rabbit::VirtualMachine* SQ_UNUSED_ARG(v), cons
return po->_unVal.pRefCounted->refCountget(); return po->_unVal.pRefCounted->refCountget();
} }
const rabbit::Char * rabbit::sq_objtostring(const rabbit::Object *o) const char * rabbit::sq_objtostring(const rabbit::Object *o)
{ {
if(sq_type(*o) == rabbit::OT_STRING) { if(sq_type(*o) == rabbit::OT_STRING) {
return _stringval(*o); return _stringval(*o);
@ -239,7 +239,7 @@ void rabbit::sq_pushnull(rabbit::VirtualMachine* v)
v->pushNull(); v->pushNull();
} }
void rabbit::sq_pushstring(rabbit::VirtualMachine* v,const rabbit::Char *s,int64_t len) void rabbit::sq_pushstring(rabbit::VirtualMachine* v,const char *s,int64_t len)
{ {
if(s) if(s)
v->push(rabbit::ObjectPtr(rabbit::String::create(_get_shared_state(v), s, len))); v->push(rabbit::ObjectPtr(rabbit::String::create(_get_shared_state(v), s, len)));
@ -426,7 +426,7 @@ rabbit::Result rabbit::sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,u
return sq_throwerror(v,_SC("the object is not a closure")); return sq_throwerror(v,_SC("the object is not a closure"));
} }
rabbit::Result rabbit::sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char *name) rabbit::Result rabbit::sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const char *name)
{ {
rabbit::Object o = stack_get(v, idx); rabbit::Object o = stack_get(v, idx);
if(sq_isnativeclosure(o)) { if(sq_isnativeclosure(o)) {
@ -437,7 +437,7 @@ rabbit::Result rabbit::sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t
return sq_throwerror(v,_SC("the object is not a nativeclosure")); return sq_throwerror(v,_SC("the object is not a nativeclosure"));
} }
rabbit::Result rabbit::sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const rabbit::Char *typemask) rabbit::Result rabbit::sq_setparamscheck(rabbit::VirtualMachine* v,int64_t nparamscheck,const char *typemask)
{ {
rabbit::Object o = stack_get(v, -1); rabbit::Object o = stack_get(v, -1);
if(!sq_isnativeclosure(o)) if(!sq_isnativeclosure(o))
@ -696,7 +696,7 @@ rabbit::Result rabbit::sq_getbool(rabbit::VirtualMachine* v,int64_t idx,rabbit::
return SQ_ERROR; return SQ_ERROR;
} }
rabbit::Result rabbit::sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c,int64_t *size) rabbit::Result rabbit::sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx,const char **c,int64_t *size)
{ {
rabbit::ObjectPtr *o = NULL; rabbit::ObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, rabbit::OT_STRING,o); _GETSAFE_OBJ(v, idx, rabbit::OT_STRING,o);
@ -705,7 +705,7 @@ rabbit::Result rabbit::sq_getstringandsize(rabbit::VirtualMachine* v,int64_t idx
return SQ_OK; return SQ_OK;
} }
rabbit::Result rabbit::sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c) rabbit::Result rabbit::sq_getstring(rabbit::VirtualMachine* v,int64_t idx,const char **c)
{ {
rabbit::ObjectPtr *o = NULL; rabbit::ObjectPtr *o = NULL;
_GETSAFE_OBJ(v, idx, rabbit::OT_STRING,o); _GETSAFE_OBJ(v, idx, rabbit::OT_STRING,o);
@ -1107,7 +1107,7 @@ rabbit::Result rabbit::sq_getstackobj(rabbit::VirtualMachine* v,int64_t idx,rabb
return SQ_OK; return SQ_OK;
} }
const rabbit::Char * rabbit::sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx) const char * rabbit::sq_getlocal(rabbit::VirtualMachine* v,uint64_t level,uint64_t idx)
{ {
uint64_t cstksize=v->_callsstacksize; uint64_t cstksize=v->_callsstacksize;
uint64_t lvl=(cstksize-level)-1; uint64_t lvl=(cstksize-level)-1;
@ -1142,7 +1142,7 @@ void rabbit::sq_resetobject(rabbit::Object *po)
po->_unVal.pUserPointer=NULL;po->_type=rabbit::OT_NULL; po->_unVal.pUserPointer=NULL;po->_type=rabbit::OT_NULL;
} }
rabbit::Result rabbit::sq_throwerror(rabbit::VirtualMachine* v,const rabbit::Char *err) rabbit::Result rabbit::sq_throwerror(rabbit::VirtualMachine* v,const char *err)
{ {
v->_lasterror=rabbit::String::create(_get_shared_state(v),err); v->_lasterror=rabbit::String::create(_get_shared_state(v),err);
return SQ_ERROR; return SQ_ERROR;
@ -1329,7 +1329,7 @@ rabbit::Result rabbit::sq_readclosure(rabbit::VirtualMachine* v,SQREADFUNC r,rab
return SQ_OK; return SQ_OK;
} }
rabbit::Char * rabbit::sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize) char * rabbit::sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize)
{ {
return _get_shared_state(v)->getScratchPad(minsize); return _get_shared_state(v)->getScratchPad(minsize);
} }
@ -1355,10 +1355,10 @@ rabbit::Result rabbit::sq_getcallee(rabbit::VirtualMachine* v)
return sq_throwerror(v,_SC("no closure in the calls stack")); return sq_throwerror(v,_SC("no closure in the calls stack"));
} }
const rabbit::Char * rabbit::sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval) const char * rabbit::sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval)
{ {
rabbit::ObjectPtr &self=stack_get(v,idx); rabbit::ObjectPtr &self=stack_get(v,idx);
const rabbit::Char *name = NULL; const char *name = NULL;
switch(sq_type(self)) switch(sq_type(self))
{ {
case rabbit::OT_CLOSURE:{ case rabbit::OT_CLOSURE:{
@ -1608,7 +1608,7 @@ rabbit::Result rabbit::sq_next(rabbit::VirtualMachine* v,int64_t idx)
namespace rabbit { namespace rabbit {
struct BufState{ struct BufState{
const rabbit::Char *buf; const char *buf;
int64_t ptr; int64_t ptr;
int64_t size; int64_t size;
}; };
@ -1621,7 +1621,7 @@ namespace rabbit {
return buf->buf[buf->ptr++]; return buf->buf[buf->ptr++];
} }
} }
rabbit::Result rabbit::sq_compilebuffer(rabbit::VirtualMachine* v,const rabbit::Char *s,int64_t size,const rabbit::Char *sourcename,rabbit::Bool raiseerror) { rabbit::Result rabbit::sq_compilebuffer(rabbit::VirtualMachine* v,const char *s,int64_t size,const char *sourcename,rabbit::Bool raiseerror) {
BufState buf; BufState buf;
buf.buf = s; buf.buf = s;
buf.size = size; buf.size = size;

40
rabbit/sqbaselib.cpp
View File

@ -26,13 +26,13 @@
#include <ctype.h> #include <ctype.h>
#include <rabbit/StackInfos.hpp> #include <rabbit/StackInfos.hpp>
static bool str2num(const rabbit::Char *s,rabbit::ObjectPtr &res,int64_t base) static bool str2num(const char *s,rabbit::ObjectPtr &res,int64_t base)
{ {
rabbit::Char *end; char *end;
const rabbit::Char *e = s; const char *e = s;
bool iseintbase = base > 13; //to fix error converting hexadecimals with e like 56f0791e bool iseintbase = base > 13; //to fix error converting hexadecimals with e like 56f0791e
bool isfloat = false; bool isfloat = false;
rabbit::Char c; char c;
while((c = *e) != _SC('\0')) while((c = *e) != _SC('\0'))
{ {
if (c == _SC('.') || (!iseintbase && (c == _SC('E') || c == _SC('e')))) { //e and E is for scientific notation if (c == _SC('.') || (!iseintbase && (c == _SC('E') || c == _SC('e')))) { //e and E is for scientific notation
@ -42,12 +42,12 @@ static bool str2num(const rabbit::Char *s,rabbit::ObjectPtr &res,int64_t base)
e++; e++;
} }
if(isfloat){ if(isfloat){
float_t r = float_t(scstrtod(s,&end)); float_t r = float_t(strtod(s,&end));
if(s == end) return false; if(s == end) return false;
res = r; res = r;
} }
else{ else{
int64_t r = int64_t(scstrtol(s,&end,(int)base)); int64_t r = int64_t(strtol(s,&end,(int)base));
if(s == end) return false; if(s == end) return false;
res = r; res = r;
} }
@ -112,12 +112,12 @@ static int64_t __getcallstackinfos(rabbit::VirtualMachine* v,int64_t level)
{ {
rabbit::StackInfos si; rabbit::StackInfos si;
int64_t seq = 0; int64_t seq = 0;
const rabbit::Char *name = NULL; const char *name = NULL;
if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si))) if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si)))
{ {
const rabbit::Char *fn = _SC("unknown"); const char *fn = _SC("unknown");
const rabbit::Char *src = _SC("unknown"); const char *src = _SC("unknown");
if(si.funcname)fn = si.funcname; if(si.funcname)fn = si.funcname;
if(si.source)src = si.source; if(si.source)src = si.source;
sq_newtable(v); sq_newtable(v);
@ -158,7 +158,7 @@ static int64_t base_assert(rabbit::VirtualMachine* v)
if(rabbit::VirtualMachine::IsFalse(stack_get(v,2))){ if(rabbit::VirtualMachine::IsFalse(stack_get(v,2))){
int64_t top = sq_gettop(v); int64_t top = sq_gettop(v);
if (top>2 && SQ_SUCCEEDED(sq_tostring(v,3))) { if (top>2 && SQ_SUCCEEDED(sq_tostring(v,3))) {
const rabbit::Char *str = 0; const char *str = 0;
if (SQ_SUCCEEDED(sq_getstring(v,-1,&str))) { if (SQ_SUCCEEDED(sq_getstring(v,-1,&str))) {
return sq_throwerror(v, str); return sq_throwerror(v, str);
} }
@ -194,7 +194,7 @@ static int64_t get_slice_params(rabbit::VirtualMachine* v,int64_t &sidx,int64_t
static int64_t base_print(rabbit::VirtualMachine* v) static int64_t base_print(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *str; const char *str;
if(SQ_SUCCEEDED(sq_tostring(v,2))) if(SQ_SUCCEEDED(sq_tostring(v,2)))
{ {
if(SQ_SUCCEEDED(sq_getstring(v,-1,&str))) { if(SQ_SUCCEEDED(sq_getstring(v,-1,&str))) {
@ -207,7 +207,7 @@ static int64_t base_print(rabbit::VirtualMachine* v)
static int64_t base_error(rabbit::VirtualMachine* v) static int64_t base_error(rabbit::VirtualMachine* v)
{ {
const rabbit::Char *str; const char *str;
if(SQ_SUCCEEDED(sq_tostring(v,2))) if(SQ_SUCCEEDED(sq_tostring(v,2)))
{ {
if(SQ_SUCCEEDED(sq_getstring(v,-1,&str))) { if(SQ_SUCCEEDED(sq_getstring(v,-1,&str))) {
@ -221,7 +221,7 @@ static int64_t base_error(rabbit::VirtualMachine* v)
static int64_t base_compilestring(rabbit::VirtualMachine* v) static int64_t base_compilestring(rabbit::VirtualMachine* v)
{ {
int64_t nargs=sq_gettop(v); int64_t nargs=sq_gettop(v);
const rabbit::Char *src=NULL,*name=_SC("unnamedbuffer"); const char *src=NULL,*name=_SC("unnamedbuffer");
int64_t size; int64_t size;
sq_getstring(v,2,&src); sq_getstring(v,2,&src);
size=sq_getsize(v,2); size=sq_getsize(v,2);
@ -323,7 +323,7 @@ void sq_base_register(rabbit::VirtualMachine* v)
sq_pushstring(v,RABBIT_VERSION,-1); sq_pushstring(v,RABBIT_VERSION,-1);
sq_newslot(v,-3, SQFalse); sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_charsize_"),-1); sq_pushstring(v,_SC("_charsize_"),-1);
sq_pushinteger(v,sizeof(rabbit::Char)); sq_pushinteger(v,sizeof(char));
sq_newslot(v,-3, SQFalse); sq_newslot(v,-3, SQFalse);
sq_pushstring(v,_SC("_intsize_"),-1); sq_pushstring(v,_SC("_intsize_"),-1);
sq_pushinteger(v,sizeof(int64_t)); sq_pushinteger(v,sizeof(int64_t));
@ -418,8 +418,8 @@ static int64_t obj_clear(rabbit::VirtualMachine* v)
static int64_t number_delegate_tochar(rabbit::VirtualMachine* v) static int64_t number_delegate_tochar(rabbit::VirtualMachine* v)
{ {
rabbit::Object &o=stack_get(v,1); rabbit::Object &o=stack_get(v,1);
rabbit::Char c = (rabbit::Char)tointeger(o); char c = (char)tointeger(o);
v->push(rabbit::String::create(_get_shared_state(v),(const rabbit::Char *)&c,1)); v->push(rabbit::String::create(_get_shared_state(v),(const char *)&c,1));
return 1; return 1;
} }
@ -859,11 +859,11 @@ static int64_t string_slice(rabbit::VirtualMachine* v)
static int64_t string_find(rabbit::VirtualMachine* v) static int64_t string_find(rabbit::VirtualMachine* v)
{ {
int64_t top,start_idx=0; int64_t top,start_idx=0;
const rabbit::Char *str,*substr,*ret; const char *str,*substr,*ret;
if(((top=sq_gettop(v))>1) && SQ_SUCCEEDED(sq_getstring(v,1,&str)) && SQ_SUCCEEDED(sq_getstring(v,2,&substr))){ if(((top=sq_gettop(v))>1) && SQ_SUCCEEDED(sq_getstring(v,1,&str)) && SQ_SUCCEEDED(sq_getstring(v,2,&substr))){
if(top>2)sq_getinteger(v,3,&start_idx); if(top>2)sq_getinteger(v,3,&start_idx);
if((sq_getsize(v,1)>start_idx) && (start_idx>=0)){ if((sq_getsize(v,1)>start_idx) && (start_idx>=0)){
ret=scstrstr(&str[start_idx],substr); ret=strstr(&str[start_idx],substr);
if(ret){ if(ret){
sq_pushinteger(v,(int64_t)(ret-str)); sq_pushinteger(v,(int64_t)(ret-str));
return 1; return 1;
@ -885,8 +885,8 @@ static int64_t string_find(rabbit::VirtualMachine* v)
if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes")); \ if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes")); \
if(eidx > slen || sidx < 0) return sq_throwerror(v,_SC("slice out of range")); \ if(eidx > slen || sidx < 0) return sq_throwerror(v,_SC("slice out of range")); \
int64_t len=_string(str)->_len; \ int64_t len=_string(str)->_len; \
const rabbit::Char *sthis=_stringval(str); \ const char *sthis=_stringval(str); \
rabbit::Char *snew=(_get_shared_state(v)->getScratchPad(sq_rsl(len))); \ char *snew=(_get_shared_state(v)->getScratchPad(sq_rsl(len))); \
memcpy(snew,sthis,sq_rsl(len));\ memcpy(snew,sthis,sq_rsl(len));\
for(int64_t 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(rabbit::String::create(_get_shared_state(v),snew,len)); \ v->push(rabbit::String::create(_get_shared_state(v),snew,len)); \

85
rabbit/sqconfig.hpp
View File

@ -30,7 +30,7 @@ namespace rabbit {
#endif #endif
//max number of character for a printed number //max number of character for a printed number
#define NUMBER_MAX_CHAR 50 #define NUMBER_UINT8_MAX 50
namespace rabbit { namespace rabbit {
using UserPointer = void*; using UserPointer = void*;
@ -39,86 +39,7 @@ namespace rabbit {
} }
#ifdef SQUNICODE #define sq_rsl(l) (l)
#include <wchar.h>
#include <wctype.h>
namespace rabbit {
using Char = wchar_t;
}
#define scstrcmp wcscmp
#ifdef _WIN32
#define scsprintf _snwprintf
#else
#define scsprintf swprintf
#endif
#define scstrlen wcslen
#define scstrtod wcstod
#ifdef _SQ64
#define scstrtol wcstoll
#else
#define scstrtol wcstol
#endif
#define scstrtoul wcstoul
#define scvsprintf vswprintf
#define scstrstr wcsstr
#define scprintf wprintf
#ifdef _WIN32
#define WCHAR_SIZE 2
#define WCHAR_SHIFT_MUL 1
#define MAX_CHAR 0xFFFF
#else
#define WCHAR_SIZE 4
#define WCHAR_SHIFT_MUL 2
#define MAX_CHAR 0xFFFFFFFF
#endif
#define _SC(a) L##a
#define scisspace iswspace
#define scisdigit iswdigit
#define scisprint iswprint
#define scisxdigit iswxdigit
#define scisalpha iswalpha
#define sciscntrl iswcntrl
#define scisalnum iswalnum
#define sq_rsl(l) ((l)<<WCHAR_SHIFT_MUL)
#else
namespace rabbit {
using Char = char;
}
#define _SC(a) a
#define scstrcmp strcmp
#ifdef _MSC_VER
#define scsprintf _snprintf
#else
#define scsprintf snprintf
#endif
#define scstrlen strlen
#define scstrtod strtod
#ifdef _SQ64
#ifdef _MSC_VER
#define scstrtol _strtoi64
#else
#define scstrtol strtoll
#endif
#else
#define scstrtol strtol
#endif
#define scstrtoul strtoul
#define scvsprintf vsnprintf
#define scstrstr strstr
#define scisspace isspace
#define scisdigit isdigit
#define scisprint isprint
#define scisxdigit isxdigit
#define sciscntrl iscntrl
#define scisalpha isalpha
#define scisalnum isalnum
#define scprintf printf
#define MAX_CHAR 0xFF
#define sq_rsl(l) (l)
#endif
#define _PRINT_INT_PREC _SC("ll") #define _PRINT_INT_PREC _SC("ll")
#define _PRINT_INT_FMT _SC("%ld") #define _PRINT_INT_FMT _SC("%ld")
@ -133,7 +54,7 @@ namespace rabbit {
#define UINT_MINUS_ONE (0xFFFFFFFF) #define UINT_MINUS_ONE (0xFFFFFFFF)
#endif #endif
#define _SC(a) a
namespace rabbit { namespace rabbit {

10
rabbit/sqdebug.cpp
View File

@ -70,12 +70,12 @@ rabbit::Result rabbit::sq_stackinfos(rabbit::VirtualMachine* v, int64_t level, r
return SQ_ERROR; return SQ_ERROR;
} }
void rabbit::VirtualMachine::raise_error(const rabbit::Char *s, ...) void rabbit::VirtualMachine::raise_error(const char *s, ...)
{ {
va_list vl; va_list vl;
va_start(vl, s); va_start(vl, s);
int64_t buffersize = (int64_t)scstrlen(s)+(NUMBER_MAX_CHAR*2); int64_t buffersize = (int64_t)strlen(s)+(NUMBER_UINT8_MAX*2);
scvsprintf(_sp(sq_rsl(buffersize)),buffersize, s, vl); vsnprintf(_sp(sq_rsl(buffersize)),buffersize, s, vl);
va_end(vl); va_end(vl);
_lasterror = rabbit::String::create(_get_shared_state(this),_spval,-1); _lasterror = rabbit::String::create(_get_shared_state(this),_spval,-1);
} }
@ -90,11 +90,11 @@ rabbit::String *rabbit::VirtualMachine::printObjVal(const rabbit::ObjectPtr &o)
switch(sq_type(o)) { switch(sq_type(o)) {
case rabbit::OT_STRING: return _string(o); case rabbit::OT_STRING: return _string(o);
case rabbit::OT_INTEGER: case rabbit::OT_INTEGER:
scsprintf(_sp(sq_rsl(NUMBER_MAX_CHAR+1)),sq_rsl(NUMBER_MAX_CHAR), _PRINT_INT_FMT, _integer(o)); snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)),sq_rsl(NUMBER_UINT8_MAX), _PRINT_INT_FMT, _integer(o));
return rabbit::String::create(_get_shared_state(this), _spval); return rabbit::String::create(_get_shared_state(this), _spval);
break; break;
case rabbit::OT_FLOAT: case rabbit::OT_FLOAT:
scsprintf(_sp(sq_rsl(NUMBER_MAX_CHAR+1)), sq_rsl(NUMBER_MAX_CHAR), _SC("%.14g"), _float(o)); snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)), sq_rsl(NUMBER_UINT8_MAX), _SC("%.14g"), _float(o));
return rabbit::String::create(_get_shared_state(this), _spval); return rabbit::String::create(_get_shared_state(this), _spval);
break; break;
default: default: