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

23
etc/minimal.cpp
View File

@ -5,36 +5,23 @@
#include <sqstdio.h>
#include <sqstdaux.h>
#ifdef _MSC_VER
#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,...)
void printfunc(HSQUIRRELVM v,const char *s,...)
{
va_list vl;
va_start(vl, s);
scvprintf(stdout, s, vl);
vfprintf(stdout, s, vl);
va_end(vl);
}
void errorfunc(HSQUIRRELVM v,const rabbit::Char *s,...)
void errorfunc(HSQUIRRELVM v,const char *s,...)
{
va_list vl;
va_start(vl, s);
scvprintf(stderr, s, vl);
vfprintf(stderr, s, 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
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;
int64_t i;
float_t f;
const rabbit::Char *s;
const char *s;
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;
pf(v,_SC("\nCALLSTACK\n"));
while(SQ_SUCCEEDED(sq_stackinfos(v,level,&si)))
{
const rabbit::Char *fn=_SC("unknown");
const rabbit::Char *src=_SC("unknown");
const char *fn=_SC("unknown");
const char *src=_SC("unknown");
if(si.funcname)fn=si.funcname;
if(si.source)src=si.source;
pf(v,_SC("*FUNCTION [%s()] %s line [%d]\n"),fn,src,si.line);
@ -110,7 +110,7 @@ namespace rabbit {
static int64_t aux_printerror(rabbit::VirtualMachine* v) {
SQPRINTFUNCTION pf = sq_geterrorfunc(v);
if(pf) {
const rabbit::Char *sErr = 0;
const char *sErr = 0;
if(sq_gettop(v)>=1) {
if(SQ_SUCCEEDED(sq_getstring(v,2,&sErr))) {
pf(v,_SC("\nAN ERROR HAS OCCURRED [%s]\n"),sErr);
@ -124,7 +124,7 @@ namespace rabbit {
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);
if(pf) {
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))
//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);
#else
return (SQFILE)::_wfopen(filename,mode);
#endif
}
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(SQFILE file, bool owns) { _handle = file; _owns = owns;}
virtual ~File() { close(); }
bool Open(const rabbit::Char *filename ,const rabbit::Char *mode) {
bool Open(const char *filename ,const char *mode) {
close();
if( (_handle = rabbit::std::fopen(filename,mode)) ) {
_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)
{
const rabbit::Char *filename,*mode;
const char *filename,*mode;
bool owns = true;
rabbit::std::File *f;
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)
{
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);
}
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"));
@ -384,11 +340,7 @@ rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const rabbit::Cha
rabbit::std::fclose(file);
return sq_throwerror(v,_SC("Unrecognized encoding"));
}
#ifdef SQUNICODE
func = _io_file_lexfeed_UTF8;
#else
func = _io_file_lexfeed_PLAIN;
#endif
break;//UTF-8 ;
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"));
}
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
if(sq_gettop(v) == 0)
@ -424,7 +376,7 @@ rabbit::Result rabbit::std::dofile(rabbit::VirtualMachine* v,const rabbit::Char
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+"));
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)
{
const rabbit::Char *filename;
const char *filename;
rabbit::Bool printerror = SQFalse;
sq_getstring(v,2,&filename);
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)
{
const rabbit::Char *filename;
const char *filename;
sq_getstring(v,2,&filename);
if(SQ_SUCCEEDED(rabbit::std::writeclosuretofile(v,filename)))
return 1;
@ -460,7 +412,7 @@ int64_t _g_io_writeclosuretofile(rabbit::VirtualMachine* v)
int64_t _g_io_dofile(rabbit::VirtualMachine* v)
{
const rabbit::Char *filename;
const char *filename;
rabbit::Bool printerror = SQFalse;
sq_getstring(v,2,&filename);
if(sq_gettop(v) >= 3) {

8
rabbit-std/sqstdio.hpp
View File

@ -29,7 +29,7 @@ struct SQStream {
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 fwrite(const rabbit::UserPointer, int64_t, int64_t, SQFILE);
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);
//compiler helpers
rabbit::Result loadfile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool printerror);
rabbit::Result dofile(rabbit::VirtualMachine* v,const rabbit::Char *filename,rabbit::Bool retval,rabbit::Bool printerror);
rabbit::Result writeclosuretofile(rabbit::VirtualMachine* v,const rabbit::Char *filename);
rabbit::Result loadfile(rabbit::VirtualMachine* v,const char *filename,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 char *filename);
rabbit::Result register_iolib(rabbit::VirtualMachine* v);

96
rabbit-std/sqstdrex.cpp
View File

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

2
rabbit-std/sqstdstream.cpp
View File

@ -290,7 +290,7 @@ void init_streamclass(rabbit::VirtualMachine* v)
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)
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);
#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_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) {
case '-':
@ -31,15 +31,15 @@ static rabbit::Bool isfmtchr(rabbit::Char ch)
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;
rabbit::Char swidth[MAX_WFORMAT_LEN];
char *dummy;
char swidth[MAX_WFORMAT_LEN];
int64_t wc = 0;
int64_t start = n;
fmt[0] = '%';
while (isfmtchr(src[n])) n++;
while (scisdigit(src[n])) {
while (isdigit(src[n])) {
swidth[wc] = src[n];
n++;
wc++;
@ -48,7 +48,7 @@ static int64_t validate_format(rabbit::VirtualMachine* v, rabbit::Char *fmt, con
}
swidth[wc] = '\0';
if(wc > 0) {
width = scstrtol(swidth,&dummy,10);
width = strtol(swidth,&dummy,10);
}
else
width = 0;
@ -56,7 +56,7 @@ static int64_t validate_format(rabbit::VirtualMachine* v, rabbit::Char *fmt, con
n++;
wc = 0;
while (scisdigit(src[n])) {
while (isdigit(src[n])) {
swidth[wc] = src[n];
n++;
wc++;
@ -65,28 +65,28 @@ static int64_t validate_format(rabbit::VirtualMachine* v, rabbit::Char *fmt, con
}
swidth[wc] = '\0';
if(wc > 0) {
width += scstrtol(swidth,&dummy,10);
width += strtol(swidth,&dummy,10);
}
}
if (n-start > MAX_FORMAT_LEN )
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';
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;
rabbit::Char *dest;
rabbit::Char fmt[MAX_FORMAT_LEN];
const char *format;
char *dest;
char fmt[MAX_FORMAT_LEN];
const rabbit::Result res = sq_getstring(v,nformatstringidx,&format);
if (SQ_FAILED(res)) {
return res; // propagate the error
}
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);
int64_t n = 0,i = 0, nparam = nformatstringidx+1, w = 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;
int64_t addlen = 0;
int64_t valtype = 0;
const rabbit::Char *ts = NULL;
const char *ts = NULL;
int64_t ti = 0;
float_t tf = 0;
switch(format[n]) {
case 's':
if(SQ_FAILED(sq_getstring(v,nparam,&ts)))
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';
break;
case 'i': case 'd': case 'o': case 'u': case 'x': case 'X':
#ifdef _SQ64
{
size_t flen = scstrlen(fmt);
size_t flen = strlen(fmt);
int64_t fpos = flen - 1;
rabbit::Char f = fmt[fpos];
const rabbit::Char *prec = (const rabbit::Char *)_PRINT_INT_PREC;
char f = fmt[fpos];
const char *prec = (const char *)_PRINT_INT_PREC;
while(*prec != _SC('\0')) {
fmt[fpos++] = *prec++;
}
@ -136,25 +136,25 @@ rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstri
case 'c':
if(SQ_FAILED(sq_getinteger(v,nparam,&ti)))
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';
break;
case 'f': case 'g': case 'G': case 'e': case 'E':
if(SQ_FAILED(sq_getfloat(v,nparam,&tf)))
return sq_throwerror(v,_SC("float expected for the specified format"));
addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(rabbit::Char));
addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(char));
valtype = 'f';
break;
default:
return sq_throwerror(v,_SC("invalid format"));
}
n++;
allocated += addlen + sizeof(rabbit::Char);
allocated += addlen + sizeof(char);
dest = sq_getscratchpad(v,allocated);
switch(valtype) {
case 's': i += scsprintf(&dest[i],allocated,fmt,ts); break;
case 'i': i += scsprintf(&dest[i],allocated,fmt,ti); break;
case 'f': i += scsprintf(&dest[i],allocated,fmt,tf); break;
case 's': i += snprintf(&dest[i],allocated,fmt,ts); break;
case 'i': i += snprintf(&dest[i],allocated,fmt,ti); break;
case 'f': i += snprintf(&dest[i],allocated,fmt,tf); break;
};
nparam ++;
}
@ -167,7 +167,7 @@ rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstri
static int64_t _string_printf(rabbit::VirtualMachine* v)
{
rabbit::Char *dest = NULL;
char *dest = NULL;
int64_t length = 0;
if(SQ_FAILED(rabbit::std::format(v,2,&length,&dest)))
return -1;
@ -180,7 +180,7 @@ static int64_t _string_printf(rabbit::VirtualMachine* v)
static int64_t _string_format(rabbit::VirtualMachine* v)
{
rabbit::Char *dest = NULL;
char *dest = NULL;
int64_t length = 0;
if(SQ_FAILED(rabbit::std::format(v,2,&length,&dest)))
return -1;
@ -188,27 +188,27 @@ static int64_t _string_format(rabbit::VirtualMachine* v)
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;
while(((*t) != '\0') && scisspace(*t)){ t++; }
const char *t = str;
while(((*t) != '\0') && isspace(*t)){ 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) {
*end = str;
return;
}
const rabbit::Char *t = &str[len-1];
while(t >= str && scisspace(*t)) { t--; }
const char *t = &str[len-1];
while(t >= str && isspace(*t)) { t--; }
*end = t + 1;
}
static int64_t _string_strip(rabbit::VirtualMachine* v)
{
const rabbit::Char *str,*start,*end;
const char *str,*start,*end;
sq_getstring(v,2,&str);
int64_t len = sq_getsize(v,2);
__strip_l(str,&start);
@ -219,7 +219,7 @@ static int64_t _string_strip(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);
__strip_l(str,&start);
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)
{
const rabbit::Char *str,*end;
const char *str,*end;
sq_getstring(v,2,&str);
int64_t len = sq_getsize(v,2);
__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)
{
const rabbit::Char *str,*seps;
rabbit::Char *stemp;
const char *str,*seps;
char *stemp;
sq_getstring(v,2,&str);
sq_getstring(v,3,&seps);
int64_t sepsize = sq_getsize(v,3);
if(sepsize == 0) return sq_throwerror(v,_SC("empty separators string"));
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);
memcpy(stemp,str,memsize);
rabbit::Char *start = stemp;
rabbit::Char *end = stemp;
char *start = stemp;
char *end = stemp;
sq_newarray(v,0);
while(*end != '\0')
{
rabbit::Char cur = *end;
char cur = *end;
for(int64_t i = 0; i < sepsize; 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)
{
const rabbit::Char *str;
rabbit::Char *dest,*resstr;
const char *str;
char *dest,*resstr;
int64_t size;
sq_getstring(v,2,&str);
size = sq_getsize(v,2);
@ -285,27 +285,17 @@ static int64_t _string_escape(rabbit::VirtualMachine* v)
sq_push(v,2);
return 1;
}
#ifdef SQUNICODE
#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 char *escpat = _SC("\\x%02x");
const int64_t maxescsize = 4;
#endif
int64_t destcharsize = (size * maxescsize); //assumes every char could be escaped
resstr = dest = (rabbit::Char *)sq_getscratchpad(v,destcharsize * sizeof(rabbit::Char));
rabbit::Char c;
rabbit::Char escch;
resstr = dest = (char *)sq_getscratchpad(v,destcharsize * sizeof(char));
char c;
char escch;
int64_t escaped = 0;
for(int n = 0; n < size; n++){
c = *str++;
escch = 0;
if(scisprint(c) || c == 0) {
if(isprint(c) || c == 0) {
switch(c) {
case '\a': escch = 'a'; break;
case '\b': escch = 'b'; break;
@ -330,7 +320,7 @@ static int64_t _string_escape(rabbit::VirtualMachine* v)
}
else {
dest += scsprintf(dest, destcharsize, escpat, c);
dest += snprintf(dest, destcharsize, escpat, c);
escaped++;
}
}
@ -346,7 +336,7 @@ static int64_t _string_escape(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,3,&cmp);
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)
{
const rabbit::Char *str,*cmp;
const char *str,*cmp;
sq_getstring(v,2,&str);
sq_getstring(v,3,&cmp);
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)
{
SETUP_REX(v);
const rabbit::Char *str;
const char *str;
sq_getstring(v,2,&str);
if(rabbit::std::rex_match(self,str) == SQTrue)
{
@ -399,7 +389,7 @@ static int64_t _regexp_match(rabbit::VirtualMachine* v)
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_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)
{
SETUP_REX(v);
const rabbit::Char *str,*begin,*end;
const char *str,*begin,*end;
int64_t start = 0;
sq_getstring(v,2,&str);
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)
{
SETUP_REX(v);
const rabbit::Char *str,*begin,*end;
const char *str,*begin,*end;
int64_t start = 0;
sq_getstring(v,2,&str);
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)
{
const rabbit::Char *error,*pattern;
const char *error,*pattern;
sq_getstring(v,2,&pattern);
rabbit::std::SQRex *rex = rabbit::std::rex_compile(pattern,&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;
typedef struct {
const rabbit::Char *begin;
const char *begin;
int64_t len;
} 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);
rabbit::Bool rex_match(SQRex* exp,const rabbit::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_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_match(SQRex* exp,const char* text);
rabbit::Bool rex_search(SQRex* exp,const char* text, const char** out_begin, const 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);
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);

33
rabbit-std/sqstdsystem.cpp
View File

@ -12,28 +12,13 @@
#include <stdio.h>
#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>
static int64_t _system_getenv(rabbit::VirtualMachine* v)
{
const rabbit::Char *s;
const char *s;
if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){
sq_pushstring(v,scgetenv(s),-1);
sq_pushstring(v,getenv(s),-1);
return 1;
}
return 0;
@ -42,9 +27,9 @@ static int64_t _system_getenv(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))){
sq_pushinteger(v,scsystem(s));
sq_pushinteger(v,system(s));
return 1;
}
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)
{
const rabbit::Char *s;
const char *s;
sq_getstring(v,2,&s);
if(scremove(s)==-1)
if(remove(s)==-1)
return sq_throwerror(v,_SC("remove() failed"));
return 0;
}
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,3,&newn);
if(screname(oldn,newn)==-1)
if(rename(oldn,newn)==-1)
return sq_throwerror(v,_SC("rename() failed"));
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_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)
{
_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(float_t)));
_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)
{
_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(float_t)));
rabbit::ObjectPtr func;

18
rabbit/Compiler.cpp
View File

@ -87,7 +87,7 @@ struct SQScope {
class Compiler
{
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;
_lex.init(_get_shared_state(v), rg, up,Throwerror,this);
@ -97,15 +97,15 @@ public:
_scope.stacksize = 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;
c->error(s);
}
void error(const rabbit::Char *s, ...)
void error(const char *s, ...)
{
va_list vl;
va_start(vl, s);
scvsprintf(_compilererror, MAX_COMPILER_ERROR_LEN, s, vl);
vsnprintf(_compilererror, MAX_COMPILER_ERROR_LEN, s, vl);
va_end(vl);
longjmp(_errorjmp,1);
}
@ -118,7 +118,7 @@ public:
//do nothing
}
else {
const rabbit::Char *etypename;
const char *etypename;
if(tok > 255) {
switch(tok)
{
@ -363,7 +363,7 @@ public:
int64_t key = _fs->popTarget();
int64_t src = _fs->popTarget();
/* _OP_COMPARITH mixes dest obj and source val in the arg1 */
_fs->addInstruction(_OP_COMPARITH, _fs->pushTarget(), (src<<16)|val, key, ChooseCompArithCharByToken(tok));
_fs->addInstruction(_OP_COMPARITH, _fs->pushTarget(), (src<<16)|val, key, ChooseCompArithcharByToken(tok));
}
break;
case OUTER:
@ -592,7 +592,7 @@ public:
}
return _OP_ADD;
}
int64_t ChooseCompArithCharByToken(int64_t tok)
int64_t ChooseCompArithcharByToken(int64_t tok)
{
int64_t oper;
switch(tok){
@ -1588,13 +1588,13 @@ private:
int64_t _debugop;
SQExpState _es;
SQScope _scope;
rabbit::Char _compilererror[MAX_COMPILER_ERROR_LEN];
char _compilererror[MAX_COMPILER_ERROR_LEN];
jmp_buf _errorjmp;
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);
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);
bool compile(rabbit::VirtualMachine *vm, SQLEXREADFUNC rg, rabbit::UserPointer up, const rabbit::Char *sourcename, rabbit::ObjectPtr &out, bool raiseerror, bool lineinfo);
typedef void(*compilererrorFunc)(void *ud, const char *s);
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) {
switch(sq_type(o)){
case rabbit::OT_STRING: scprintf(_SC("\"%s\""),_stringval(o));break;
case rabbit::OT_FLOAT: scprintf(_SC("{%f}"),_float(o));break;
case rabbit::OT_INTEGER: scprintf(_SC("{") _PRINT_INT_FMT _SC("}"),_integer(o));break;
case rabbit::OT_BOOL: scprintf(_SC("%s"),_integer(o)?_SC("true"):_SC("false"));break;
default: scprintf(_SC("(%s %p)"),getTypeName(o),(void*)_rawval(o));break; break; //shut up compiler
case rabbit::OT_STRING: printf(_SC("\"%s\""),_stringval(o));break;
case rabbit::OT_FLOAT: printf(_SC("{%f}"),_float(o));break;
case rabbit::OT_INTEGER: printf(_SC("{") _PRINT_INT_FMT _SC("}"),_integer(o));break;
case rabbit::OT_BOOL: printf(_SC("%s"),_integer(o)?_SC("true"):_SC("false"));break;
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);
}
@ -136,11 +136,11 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
{
uint64_t n=0,i;
int64_t si;
scprintf(_SC("rabbit::Instruction sizeof %d\n"),(int32_t)sizeof(rabbit::Instruction));
scprintf(_SC("rabbit::Object sizeof %d\n"), (int32_t)sizeof(rabbit::Object));
scprintf(_SC("--------------------------------------------------------------------\n"));
scprintf(_SC("*****FUNCTION [%s]\n"),sq_type(func->_name)==rabbit::OT_STRING?_stringval(func->_name):_SC("unknown"));
scprintf(_SC("-----LITERALS\n"));
printf(_SC("rabbit::Instruction sizeof %d\n"),(int32_t)sizeof(rabbit::Instruction));
printf(_SC("rabbit::Object sizeof %d\n"), (int32_t)sizeof(rabbit::Object));
printf(_SC("--------------------------------------------------------------------\n"));
printf(_SC("*****FUNCTION [%s]\n"),sq_type(func->_name)==rabbit::OT_STRING?_stringval(func->_name):_SC("unknown"));
printf(_SC("-----LITERALS\n"));
rabbit::ObjectPtr refidx,key,val;
int64_t idx;
etk::Vector<rabbit::ObjectPtr> templiterals;
@ -150,43 +150,43 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
templiterals[_integer(val)]=key;
}
for(i=0;i<templiterals.size();i++){
scprintf(_SC("[%d] "), (int32_t)n);
printf(_SC("[%d] "), (int32_t)n);
dumpLiteral(templiterals[i]);
scprintf(_SC("\n"));
printf(_SC("\n"));
n++;
}
scprintf(_SC("-----PARAMS\n"));
printf(_SC("-----PARAMS\n"));
if(_varparams)
scprintf(_SC("<<VARPARAMS>>\n"));
printf(_SC("<<VARPARAMS>>\n"));
n=0;
for(i=0;i<_parameters.size();i++){
scprintf(_SC("[%d] "), (int32_t)n);
printf(_SC("[%d] "), (int32_t)n);
dumpLiteral(_parameters[i]);
scprintf(_SC("\n"));
printf(_SC("\n"));
n++;
}
scprintf(_SC("-----LOCALS\n"));
printf(_SC("-----LOCALS\n"));
for(si=0;si<func->_nlocalvarinfos;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++;
}
scprintf(_SC("-----LINE INFO\n"));
printf(_SC("-----LINE INFO\n"));
for(i=0;i<_lineinfos.size();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++;
}
scprintf(_SC("-----dump\n"));
printf(_SC("-----dump\n"));
n=0;
for(i=0;i<_instructions.size();i++){
rabbit::Instruction &inst=_instructions[i];
if(inst.op==_OP_LOAD || inst.op==_OP_DLOAD || inst.op==_OP_PREPCALLK || inst.op==_OP_GETK ){
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)
scprintf(_SC("null"));
printf(_SC("null"));
else {
int64_t refidx;
rabbit::ObjectPtr val,key,refo;
@ -196,13 +196,13 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
dumpLiteral(key);
}
if(inst.op != _OP_DLOAD) {
scprintf(_SC(" %d %d \n"),inst._arg2,inst._arg3);
printf(_SC(" %d %d \n"),inst._arg2,inst._arg3);
}
else {
scprintf(_SC(" %d "),inst._arg2);
printf(_SC(" %d "),inst._arg2);
lidx = inst._arg3;
if(lidx >= 0xFFFFFFFF)
scprintf(_SC("null"));
printf(_SC("null"));
else {
int64_t refidx;
rabbit::ObjectPtr val,key,refo;
@ -210,24 +210,24 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
refo = refidx;
}
dumpLiteral(key);
scprintf(_SC("\n"));
printf(_SC("\n"));
}
}
}
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){
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 {
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++;
}
scprintf(_SC("-----\n"));
scprintf(_SC("stack size[%d]\n"), (int32_t)func->_stacksize);
scprintf(_SC("--------------------------------------------------------------------\n\n"));
printf(_SC("-----\n"));
printf(_SC("stack size[%d]\n"), (int32_t)func->_stacksize);
printf(_SC("--------------------------------------------------------------------\n\n"));
}
#endif
@ -595,7 +595,7 @@ void rabbit::FuncState::addInstruction(rabbit::Instruction &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));
_table(_strings)->newSlot(ns,(int64_t)1);

4
rabbit/FuncState.hpp
View File

@ -21,7 +21,7 @@ namespace rabbit {
#ifdef _DEBUG_DUMP
void dump(rabbit::FunctionProto *func);
#endif
void error(const rabbit::Char *err);
void error(const char *err);
FuncState *pushChildState(rabbit::SharedState *ss);
void popChildState();
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);
void discardTarget();
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();
bool isConstant(const rabbit::Object &name,rabbit::Object &e);
int64_t _returnexp;

4
rabbit/FunctionInfo.hpp
View File

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

4
rabbit/FunctionProto.cpp
View File

@ -65,10 +65,10 @@ void rabbit::FunctionProto::release(){
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;
const rabbit::Char *res=NULL;
const char *res=NULL;
if(nvars>=nseq){
for(uint64_t i=0;i<nvars;i++){
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);
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);
bool save(rabbit::VirtualMachine *v,rabbit::UserPointer up,SQWRITEFUNC write);
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 {
public:
const rabbit::Char *name;
const char *name;
};
class Instruction {

99
rabbit/Lexer.cpp
View File

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

28
rabbit/Lexer.hpp
View File

@ -15,36 +15,26 @@
namespace rabbit {
#ifdef SQUNICODE
typedef Char LexChar;
#else
typedef unsigned char LexChar;
#endif
typedef unsigned char Lexchar;
class Lexer {
public:
Lexer();
~Lexer();
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();
const Char *tok2Str(int64_t tok);
const char *tok2Str(int64_t tok);
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 readNumber();
void lexBlockComment();
void lexLineComment();
int64_t readId();
void next();
#ifdef SQUNICODE
#if WCHAR_SIZE == 2
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 addUTF8(uint64_t ch);
int64_t processStringHexEscape(char *dest, int64_t maxdigits);
int64_t _curtoken;
Table *_keywords;
Bool _reached_eof;
@ -53,14 +43,14 @@ namespace rabbit {
int64_t _currentline;
int64_t _lasttokenline;
int64_t _currentcolumn;
const Char *_svalue;
const char *_svalue;
int64_t _nvalue;
float_t _fvalue;
SQLEXREADFUNC _readf;
UserPointer _up;
LexChar _currdata;
Lexchar _currdata;
SharedState *_sharedstate;
etk::Vector<Char> _longstr;
etk::Vector<char> _longstr;
compilererrorFunc _errfunc;
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))
{
@ -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));
}

6
rabbit/ObjectPtr.hpp
View File

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

4
rabbit/RegFunction.hpp
View File

@ -15,10 +15,10 @@ namespace rabbit {
class RegFunction{
public:
const rabbit::Char *name;
const char *name;
SQFUNCTION f;
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)); \
}
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 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;
if(size>0) {
if(_scratchpadsize < size) {
newsize = size + (size>>1);
_scratchpad = (rabbit::Char *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
_scratchpad = (char *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
_scratchpadsize = newsize;
} else if(_scratchpadsize >= (size<<5)) {
newsize = _scratchpadsize >> 1;
_scratchpad = (rabbit::Char *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
_scratchpad = (char *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
_scratchpadsize = newsize;
}
}

6
rabbit/SharedState.hpp
View File

@ -22,7 +22,7 @@ namespace rabbit {
~SharedState();
void init();
public:
rabbit::Char* getScratchPad(int64_t size);
char* getScratchPad(int64_t size);
int64_t getMetaMethodIdxByName(const rabbit::ObjectPtr &name);
etk::Vector<rabbit::ObjectPtr> *_metamethods;
rabbit::ObjectPtr _metamethodsmap;
@ -63,7 +63,7 @@ namespace rabbit {
rabbit::UserPointer _foreignptr;
SQRELEASEHOOK _releasehook;
private:
rabbit::Char *_scratchpad;
char *_scratchpad;
int64_t _scratchpadsize;
};
@ -81,7 +81,7 @@ namespace rabbit {
#define _instance_ddel _table(_sharedstate->_instance_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{
public:
const rabbit::Char* funcname;
const rabbit::Char* source;
const char* funcname;
const char* source;
int64_t line;
};

4
rabbit/String.cpp
View File

@ -11,7 +11,7 @@
#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 */
size_t step = (l>>5)|1; /* if string is too long, don't hash all its chars */
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);
return str;

6
rabbit/String.hpp
View File

@ -16,21 +16,21 @@ namespace rabbit {
class SharedState;
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 {
public:
String(){}
~String(){}
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);
void release();
rabbit::SharedState *_sharedstate;
rabbit::String *_next; //chain for the string table
int64_t _len;
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);
}
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)
len = (int64_t)scstrlen(news);
len = (int64_t)strlen(news);
rabbit::Hash newhash = _hashstr(news,len);
rabbit::Hash h = newhash&(_numofslots-1);
rabbit::String *s;

2
rabbit/StringTable.hpp
View File

@ -16,7 +16,7 @@ namespace rabbit {
public:
StringTable(rabbit::SharedState*ss);
~StringTable();
rabbit::String *add(const rabbit::Char *,int64_t len);
rabbit::String *add(const char *,int64_t len);
void remove(rabbit::String *);
private:
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
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);
_HashNode *n = &_nodes[hash & (_numofnodes - 1)];
_HashNode *res = NULL;
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;
break;
}

2
rabbit/Table.hpp
View File

@ -40,7 +40,7 @@ namespace rabbit {
~Table();
_HashNode *_get(const rabbit::ObjectPtr &key,rabbit::Hash hash);
//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);
void remove(const rabbit::ObjectPtr &key);
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;
switch(t1){
case rabbit::OT_STRING:
_RET_SUCCEED(scstrcmp(_stringval(o1),_stringval(o2)));
_RET_SUCCEED(strcmp(_stringval(o1),_stringval(o2)));
case rabbit::OT_INTEGER:
_RET_SUCCEED((_integer(o1)<_integer(o2))?-1:1);
case rabbit::OT_FLOAT:
@ -307,13 +307,13 @@ bool rabbit::VirtualMachine::toString(const rabbit::ObjectPtr &o,rabbit::ObjectP
res = o;
return true;
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;
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;
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;
case rabbit::OT_TABLE:
case rabbit::OT_USERDATA:
@ -332,7 +332,7 @@ bool rabbit::VirtualMachine::toString(const rabbit::ObjectPtr &o,rabbit::ObjectP
}
}
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);
return true;
@ -345,7 +345,7 @@ bool rabbit::VirtualMachine::stringCat(const rabbit::ObjectPtr &str,const rabbit
if(!toString(str, a)) return false;
if(!toString(obj, b)) return false;
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 + l, _stringval(b), sq_rsl(ol));
dest = rabbit::String::create(_get_shared_state(this), _spval, l + ol);
@ -727,7 +727,7 @@ exception_restore:
{
const rabbit::Instruction &_i_ = *ci->_ip++;
//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)
{
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;
rabbit::FunctionProto *func=_closure(ci->_closure)->_function;
if(_debughook_native) {
const rabbit::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 *src = sq_type(func->_sourcename) == rabbit::OT_STRING?_stringval(func->_sourcename):NULL;
const char *fname = sq_type(func->_name) == rabbit::OT_STRING?_stringval(func->_name):NULL;
int64_t line = forcedline?forcedline:func->getLine(ci->_ip);
_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 n=0;
scprintf(_SC("\n>>>>stack dump<<<<\n"));
printf(_SC("\n>>>>stack dump<<<<\n"));
callInfo &ci=_callsstack[_callsstacksize-1];
scprintf(_SC("IP: %p\n"),ci._ip);
scprintf(_SC("prev stack base: %d\n"),ci._prevstkbase);
scprintf(_SC("prev top: %d\n"),ci._prevtop);
printf(_SC("IP: %p\n"),ci._ip);
printf(_SC("prev stack base: %d\n"),ci._prevstkbase);
printf(_SC("prev top: %d\n"),ci._prevtop);
for(int64_t i=0;i<size;i++){
rabbit::ObjectPtr &obj=_stack[i];
if(stackbase==i)scprintf(_SC(">"));else scprintf(_SC(" "));
scprintf(_SC("[" _PRINT_INT_FMT "]:"),n);
if(stackbase==i)printf(_SC(">"));else printf(_SC(" "));
printf(_SC("[" _PRINT_INT_FMT "]:"),n);
switch(sq_type(obj)){
case rabbit::OT_FLOAT: scprintf(_SC("FLOAT %.3f"),_float(obj));break;
case rabbit::OT_INTEGER: scprintf(_SC("INTEGER " _PRINT_INT_FMT),_integer(obj));break;
case rabbit::OT_BOOL: scprintf(_SC("BOOL %s"),_integer(obj)?"true":"false");break;
case rabbit::OT_STRING: scprintf(_SC("STRING %s"),_stringval(obj));break;
case rabbit::OT_NULL: scprintf(_SC("NULL")); break;
case rabbit::OT_TABLE: scprintf(_SC("TABLE %p[%p]"),_table(obj),_table(obj)->_delegate);break;
case rabbit::OT_ARRAY: scprintf(_SC("ARRAY %p"),_array(obj));break;
case rabbit::OT_CLOSURE: scprintf(_SC("CLOSURE [%p]"),_closure(obj));break;
case rabbit::OT_NATIVECLOSURE: scprintf(_SC("NATIVECLOSURE"));break;
case rabbit::OT_USERDATA: scprintf(_SC("USERDATA %p[%p]"),_userdataval(obj),_userdata(obj)->_delegate);break;
case rabbit::OT_GENERATOR: scprintf(_SC("GENERATOR %p"),_generator(obj));break;
case rabbit::OT_THREAD: scprintf(_SC("THREAD [%p]"),_thread(obj));break;
case rabbit::OT_USERPOINTER: scprintf(_SC("USERPOINTER %p"),_userpointer(obj));break;
case rabbit::OT_CLASS: scprintf(_SC("CLASS %p"),_class(obj));break;
case rabbit::OT_INSTANCE: scprintf(_SC("INSTANCE %p"),_instance(obj));break;
case rabbit::OT_WEAKREF: scprintf(_SC("WEAKERF %p"),_weakref(obj));break;
case rabbit::OT_FLOAT: printf(_SC("FLOAT %.3f"),_float(obj));break;
case rabbit::OT_INTEGER: printf(_SC("INTEGER " _PRINT_INT_FMT),_integer(obj));break;
case rabbit::OT_BOOL: printf(_SC("BOOL %s"),_integer(obj)?"true":"false");break;
case rabbit::OT_STRING: printf(_SC("STRING %s"),_stringval(obj));break;
case rabbit::OT_NULL: printf(_SC("NULL")); break;
case rabbit::OT_TABLE: printf(_SC("TABLE %p[%p]"),_table(obj),_table(obj)->_delegate);break;
case rabbit::OT_ARRAY: printf(_SC("ARRAY %p"),_array(obj));break;
case rabbit::OT_CLOSURE: printf(_SC("CLOSURE [%p]"),_closure(obj));break;
case rabbit::OT_NATIVECLOSURE: printf(_SC("NATIVECLOSURE"));break;
case rabbit::OT_USERDATA: printf(_SC("USERDATA %p[%p]"),_userdataval(obj),_userdata(obj)->_delegate);break;
case rabbit::OT_GENERATOR: printf(_SC("GENERATOR %p"),_generator(obj));break;
case rabbit::OT_THREAD: printf(_SC("THREAD [%p]"),_thread(obj));break;
case rabbit::OT_USERPOINTER: printf(_SC("USERPOINTER %p"),_userpointer(obj));break;
case rabbit::OT_CLASS: printf(_SC("CLASS %p"),_class(obj));break;
case rabbit::OT_INSTANCE: printf(_SC("INSTANCE %p"),_instance(obj));break;
case rabbit::OT_WEAKREF: printf(_SC("WEAKERF %p"),_weakref(obj));break;
default:
assert(0);
break;
};
scprintf(_SC("\n"));
printf(_SC("\n"));
++n;
}
}

6
rabbit/VirtualMachine.hpp
View File

@ -51,8 +51,8 @@ namespace rabbit {
rabbit::Bool _root;
};
public:
void DebugHookProxy(int64_t type, const rabbit::Char * sourcename, int64_t line, const rabbit::Char * funcname);
static void _DebugHookProxy(rabbit::VirtualMachine* v, 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 char * sourcename, int64_t line, const char * funcname);
enum ExecutionType {
ET_CALL,
ET_RESUME_GENERATOR,
@ -91,7 +91,7 @@ namespace rabbit {
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_Idxerror(const rabbit::ObjectPtr &o);
void raise_Compareerror(const rabbit::Object &o1, const rabbit::Object &o2);

35
rabbit/rabbit.hpp
View File

@ -17,11 +17,6 @@
#endif
#endif
#ifdef _UNICODE
#define SQUNICODE
#endif
#include "sqconfig.hpp"
#define RABBIT_VERSION _SC("Rabbit 0.1 un-stable")
@ -44,9 +39,9 @@
typedef int64_t (*SQFUNCTION)(rabbit::VirtualMachine*);
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 (*SQPRINTFUNCTION)(rabbit::VirtualMachine*,const rabbit::Char * ,...);
typedef void (*SQDEBUGHOOK)(rabbit::VirtualMachine* /*v*/, int64_t /*type*/, const rabbit::Char * /*sourcename*/, int64_t /*line*/, const rabbit::Char * /*funcname*/);
typedef void (*SQCOMPILERERROR)(rabbit::VirtualMachine*,const char * /*desc*/,const char * /*source*/,int64_t /*line*/,int64_t /*column*/);
typedef void (*SQPRINTFUNCTION)(rabbit::VirtualMachine*,const char * ,...);
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 (*SQREADFUNC)(rabbit::UserPointer,rabbit::UserPointer,int64_t);
@ -75,8 +70,8 @@ int64_t sq_getvmstate(rabbit::VirtualMachine* v);
int64_t sq_getversion();
/*compiler*/
rabbit::Result sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::UserPointer p,const rabbit::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_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,rabbit::UserPointer p,const 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_notifyallexceptions(rabbit::VirtualMachine* v, rabbit::Bool enable);
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_newarray(rabbit::VirtualMachine* v,int64_t size);
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_setclosureroot(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_pushinteger(rabbit::VirtualMachine* v,int64_t n);
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::Result sq_tostring(rabbit::VirtualMachine* v,int64_t idx);
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_getstring(rabbit::VirtualMachine* v,int64_t idx,const rabbit::Char **c);
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 char **c);
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_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);
void sq_setreleasehook(rabbit::VirtualMachine* v,int64_t idx,SQRELEASEHOOK hook);
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_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_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_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);
@ -180,10 +175,10 @@ rabbit::Result sq_clear(rabbit::VirtualMachine* v,int64_t idx);
/*calls*/
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);
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);
const rabbit::Char *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval);
rabbit::Result sq_throwerror(rabbit::VirtualMachine* v,const rabbit::Char *err);
const char *sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval);
rabbit::Result sq_throwerror(rabbit::VirtualMachine* v,const char *err);
rabbit::Result sq_throwobject(rabbit::VirtualMachine* v);
void sq_reseterror(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);
uint64_t sq_getrefcount(rabbit::VirtualMachine* v,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);
int64_t sq_objtointeger(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 {
int64_t sq_aux_invalidtype(rabbit::VirtualMachine* v,rabbit::ObjectType type)
{
uint64_t buf_size = 100 *sizeof(rabbit::Char);
scsprintf(_get_shared_state(v)->getScratchPad(buf_size), buf_size, _SC("unexpected type %s"), IdType2Name(type));
uint64_t buf_size = 100 *sizeof(char);
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));
}
}
@ -144,7 +144,7 @@ int64_t rabbit::sq_getversion()
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;
#ifndef NO_COMPILER
@ -194,7 +194,7 @@ uint64_t rabbit::sq_getvmrefcount(rabbit::VirtualMachine* SQ_UNUSED_ARG(v), cons
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) {
return _stringval(*o);
@ -239,7 +239,7 @@ void rabbit::sq_pushnull(rabbit::VirtualMachine* v)
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)
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"));
}
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);
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"));
}
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);
if(!sq_isnativeclosure(o))
@ -696,7 +696,7 @@ rabbit::Result rabbit::sq_getbool(rabbit::VirtualMachine* v,int64_t idx,rabbit::
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;
_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;
}
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;
_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;
}
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 lvl=(cstksize-level)-1;
@ -1142,7 +1142,7 @@ void rabbit::sq_resetobject(rabbit::Object *po)
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);
return SQ_ERROR;
@ -1329,7 +1329,7 @@ rabbit::Result rabbit::sq_readclosure(rabbit::VirtualMachine* v,SQREADFUNC r,rab
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);
}
@ -1355,10 +1355,10 @@ rabbit::Result rabbit::sq_getcallee(rabbit::VirtualMachine* v)
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);
const rabbit::Char *name = NULL;
const char *name = NULL;
switch(sq_type(self))
{
case rabbit::OT_CLOSURE:{
@ -1608,7 +1608,7 @@ rabbit::Result rabbit::sq_next(rabbit::VirtualMachine* v,int64_t idx)
namespace rabbit {
struct BufState{
const rabbit::Char *buf;
const char *buf;
int64_t ptr;
int64_t size;
};
@ -1621,7 +1621,7 @@ namespace rabbit {
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;
buf.buf = s;
buf.size = size;

40
rabbit/sqbaselib.cpp
View File

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

85
rabbit/sqconfig.hpp
View File

@ -30,7 +30,7 @@ namespace rabbit {
#endif
//max number of character for a printed number
#define NUMBER_MAX_CHAR 50
#define NUMBER_UINT8_MAX 50
namespace rabbit {
using UserPointer = void*;
@ -39,86 +39,7 @@ namespace rabbit {
}
#ifdef SQUNICODE
#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 sq_rsl(l) (l)
#define _PRINT_INT_PREC _SC("ll")
#define _PRINT_INT_FMT _SC("%ld")
@ -133,7 +54,7 @@ namespace rabbit {
#define UINT_MINUS_ONE (0xFFFFFFFF)
#endif
#define _SC(a) a
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;
}
void rabbit::VirtualMachine::raise_error(const rabbit::Char *s, ...)
void rabbit::VirtualMachine::raise_error(const char *s, ...)
{
va_list vl;
va_start(vl, s);
int64_t buffersize = (int64_t)scstrlen(s)+(NUMBER_MAX_CHAR*2);
scvsprintf(_sp(sq_rsl(buffersize)),buffersize, s, vl);
int64_t buffersize = (int64_t)strlen(s)+(NUMBER_UINT8_MAX*2);
vsnprintf(_sp(sq_rsl(buffersize)),buffersize, s, vl);
va_end(vl);
_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)) {
case rabbit::OT_STRING: return _string(o);
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);
break;
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);
break;
default: