From c6875d59bf99945e56d5a7649a1b6f520393052b Mon Sep 17 00:00:00 2001 From: Edouard DUPIN Date: Sun, 1 Jul 2018 21:56:13 +0200 Subject: [PATCH] [DEV] remove basic unicode(step 1) --- cmdLine/rabbit.cpp | 78 +++++++---------------- etc/minimal.cpp | 23 ++----- rabbit-std/sqstdaux.cpp | 12 ++-- rabbit-std/sqstdio.cpp | 66 +++---------------- rabbit-std/sqstdio.hpp | 8 +-- rabbit-std/sqstdrex.cpp | 96 ++++++++++++++-------------- rabbit-std/sqstdstream.cpp | 2 +- rabbit-std/sqstdstream.hpp | 2 +- rabbit-std/sqstdstring.cpp | 126 +++++++++++++++++-------------------- rabbit-std/sqstdstring.hpp | 12 ++-- rabbit-std/sqstdsystem.cpp | 33 +++------- rabbit/Closure.cpp | 4 +- rabbit/Compiler.cpp | 18 +++--- rabbit/Compiler.hpp | 4 +- rabbit/FuncState.cpp | 70 ++++++++++----------- rabbit/FuncState.hpp | 4 +- rabbit/FunctionInfo.hpp | 4 +- rabbit/FunctionProto.cpp | 4 +- rabbit/FunctionProto.hpp | 2 +- rabbit/Instruction.hpp | 2 +- rabbit/Lexer.cpp | 99 +++++++++++------------------ rabbit/Lexer.hpp | 28 +++------ rabbit/ObjectPtr.cpp | 4 +- rabbit/ObjectPtr.hpp | 6 +- rabbit/RegFunction.hpp | 4 +- rabbit/SharedState.cpp | 8 +-- rabbit/SharedState.hpp | 6 +- rabbit/StackInfos.hpp | 4 +- rabbit/String.cpp | 4 +- rabbit/String.hpp | 6 +- rabbit/StringTable.cpp | 4 +- rabbit/StringTable.hpp | 2 +- rabbit/Table.cpp | 4 +- rabbit/Table.hpp | 2 +- rabbit/VirtualMachine.cpp | 64 +++++++++---------- rabbit/VirtualMachine.hpp | 6 +- rabbit/rabbit.hpp | 35 +++++------ rabbit/sqapi.cpp | 32 +++++----- rabbit/sqbaselib.cpp | 40 ++++++------ rabbit/sqconfig.hpp | 85 +------------------------ rabbit/sqdebug.cpp | 10 +-- 41 files changed, 393 insertions(+), 630 deletions(-) diff --git a/cmdLine/rabbit.cpp b/cmdLine/rabbit.cpp index 6608570..99b2140 100644 --- a/cmdLine/rabbit.cpp +++ b/cmdLine/rabbit.cpp @@ -23,15 +23,6 @@ #include #include -#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 .\n") + fprintf(stderr,_SC("usage: sq .\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 ")); + 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")); } } diff --git a/etc/minimal.cpp b/etc/minimal.cpp index fdb8e70..77164da 100644 --- a/etc/minimal.cpp +++ b/etc/minimal.cpp @@ -5,36 +5,23 @@ #include #include -#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 diff --git a/rabbit-std/sqstdaux.cpp b/rabbit-std/sqstdaux.cpp index 27f7ec1..de54855 100644 --- a/rabbit-std/sqstdaux.cpp +++ b/rabbit-std/sqstdaux.cpp @@ -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); diff --git a/rabbit-std/sqstdio.cpp b/rabbit-std/sqstdio.cpp index b52f64f..608361e 100644 --- a/rabbit-std/sqstdio.cpp +++ b/rabbit-std/sqstdio.cpp @@ -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) { diff --git a/rabbit-std/sqstdio.hpp b/rabbit-std/sqstdio.hpp index c4b3ea7..da1e62c 100644 --- a/rabbit-std/sqstdio.hpp +++ b/rabbit-std/sqstdio.hpp @@ -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); diff --git a/rabbit-std/sqstdrex.cpp b/rabbit-std/sqstdrex.cpp index d1be2f1..b98ce92 100644 --- a/rabbit-std/sqstdrex.cpp +++ b/rabbit-std/sqstdrex.cpp @@ -15,7 +15,7 @@ #ifdef _DEBUG #include -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) diff --git a/rabbit-std/sqstdstream.cpp b/rabbit-std/sqstdstream.cpp index 0952d24..d51d5e8 100644 --- a/rabbit-std/sqstdstream.cpp +++ b/rabbit-std/sqstdstream.cpp @@ -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")); diff --git a/rabbit-std/sqstdstream.hpp b/rabbit-std/sqstdstream.hpp index 65e241e..70431b9 100644 --- a/rabbit-std/sqstdstream.hpp +++ b/rabbit-std/sqstdstream.hpp @@ -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); } } diff --git a/rabbit-std/sqstdstring.cpp b/rabbit-std/sqstdstring.cpp index d24fae4..0b195b5 100644 --- a/rabbit-std/sqstdstring.cpp +++ b/rabbit-std/sqstdstring.cpp @@ -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); diff --git a/rabbit-std/sqstdstring.hpp b/rabbit-std/sqstdstring.hpp index b17b6c5..39405f6 100644 --- a/rabbit-std/sqstdstring.hpp +++ b/rabbit-std/sqstdstring.hpp @@ -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); diff --git a/rabbit-std/sqstdsystem.cpp b/rabbit-std/sqstdsystem.cpp index 8b675f9..f43aad6 100644 --- a/rabbit-std/sqstdsystem.cpp +++ b/rabbit-std/sqstdsystem.cpp @@ -12,28 +12,13 @@ #include #include -#ifdef SQUNICODE -#include -#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 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); diff --git a/rabbit/Closure.cpp b/rabbit/Closure.cpp index 6957958..308cfac 100644 --- a/rabbit/Closure.cpp +++ b/rabbit/Closure.cpp @@ -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; diff --git a/rabbit/Compiler.cpp b/rabbit/Compiler.cpp index 8096a2e..9b6aba6 100644 --- a/rabbit/Compiler.cpp +++ b/rabbit/Compiler.cpp @@ -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); diff --git a/rabbit/Compiler.hpp b/rabbit/Compiler.hpp index f1be6c6..ee94eb3 100644 --- a/rabbit/Compiler.hpp +++ b/rabbit/Compiler.hpp @@ -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); } \ No newline at end of file diff --git a/rabbit/FuncState.cpp b/rabbit/FuncState.cpp index 5776522..27b79b0 100644 --- a/rabbit/FuncState.cpp +++ b/rabbit/FuncState.cpp @@ -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 templiterals; @@ -150,43 +150,43 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func) templiterals[_integer(val)]=key; } for(i=0;i>\n")); + printf(_SC("<>\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_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); diff --git a/rabbit/FuncState.hpp b/rabbit/FuncState.hpp index 636cd68..accdc77 100644 --- a/rabbit/FuncState.hpp +++ b/rabbit/FuncState.hpp @@ -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; diff --git a/rabbit/FunctionInfo.hpp b/rabbit/FunctionInfo.hpp index be055a4..9eeed64 100644 --- a/rabbit/FunctionInfo.hpp +++ b/rabbit/FunctionInfo.hpp @@ -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; }; } diff --git a/rabbit/FunctionProto.cpp b/rabbit/FunctionProto.cpp index ef37c28..abcaffe 100644 --- a/rabbit/FunctionProto.cpp +++ b/rabbit/FunctionProto.cpp @@ -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=nop) diff --git a/rabbit/FunctionProto.hpp b/rabbit/FunctionProto.hpp index b620031..d54c027 100644 --- a/rabbit/FunctionProto.hpp +++ b/rabbit/FunctionProto.hpp @@ -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); diff --git a/rabbit/Instruction.hpp b/rabbit/Instruction.hpp index 1aa83f0..b31c3ea 100644 --- a/rabbit/Instruction.hpp +++ b/rabbit/Instruction.hpp @@ -15,7 +15,7 @@ namespace rabbit { class InstructionDesc { public: - const rabbit::Char *name; + const char *name; }; class Instruction { diff --git a/rabbit/Lexer.cpp b/rabbit/Lexer.cpp index 3fcb90e..85832fa 100644 --- a/rabbit/Lexer.cpp +++ b/rabbit/Lexer.cpp @@ -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) { diff --git a/rabbit/Lexer.hpp b/rabbit/Lexer.hpp index 430e59b..a7eb851 100644 --- a/rabbit/Lexer.hpp +++ b/rabbit/Lexer.hpp @@ -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 _longstr; + etk::Vector _longstr; compilererrorFunc _errfunc; void *_errtarget; }; diff --git a/rabbit/ObjectPtr.cpp b/rabbit/ObjectPtr.cpp index 86992b9..23639cd 100644 --- a/rabbit/ObjectPtr.cpp +++ b/rabbit/ObjectPtr.cpp @@ -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)); } diff --git a/rabbit/ObjectPtr.hpp b/rabbit/ObjectPtr.hpp index e5eba99..d3ab15e 100644 --- a/rabbit/ObjectPtr.hpp +++ b/rabbit/ObjectPtr.hpp @@ -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); } diff --git a/rabbit/RegFunction.hpp b/rabbit/RegFunction.hpp index 5dedfc4..03d43f2 100644 --- a/rabbit/RegFunction.hpp +++ b/rabbit/RegFunction.hpp @@ -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; }; } diff --git a/rabbit/SharedState.cpp b/rabbit/SharedState.cpp index 402ee39..b83820b 100644 --- a/rabbit/SharedState.cpp +++ b/rabbit/SharedState.cpp @@ -51,7 +51,7 @@ rabbit::SharedState::SharedState() _table(_metamethodsmap)->newSlot(_metamethods->back(),(int64_t)(_metamethods->size()-1)); \ } -bool rabbit::compileTypemask(etk::Vector &res,const rabbit::Char *typemask) +bool rabbit::compileTypemask(etk::Vector &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; } } diff --git a/rabbit/SharedState.hpp b/rabbit/SharedState.hpp index 2892dd9..a218212 100644 --- a/rabbit/SharedState.hpp +++ b/rabbit/SharedState.hpp @@ -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 *_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 &res,const rabbit::Char *typemask); + bool compileTypemask(etk::Vector &res,const char *typemask); } diff --git a/rabbit/StackInfos.hpp b/rabbit/StackInfos.hpp index 26ac8bf..0aa1c00 100644 --- a/rabbit/StackInfos.hpp +++ b/rabbit/StackInfos.hpp @@ -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; }; diff --git a/rabbit/String.cpp b/rabbit/String.cpp index 7f37d7c..d43c5be 100644 --- a/rabbit/String.cpp +++ b/rabbit/String.cpp @@ -11,7 +11,7 @@ #include -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; diff --git a/rabbit/String.hpp b/rabbit/String.hpp index 012ceff..658de9a 100644 --- a/rabbit/String.hpp +++ b/rabbit/String.hpp @@ -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]; }; diff --git a/rabbit/StringTable.cpp b/rabbit/StringTable.cpp index 8bd884d..6dc9daa 100644 --- a/rabbit/StringTable.cpp +++ b/rabbit/StringTable.cpp @@ -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; diff --git a/rabbit/StringTable.hpp b/rabbit/StringTable.hpp index 0ac5a70..518629c 100644 --- a/rabbit/StringTable.hpp +++ b/rabbit/StringTable.hpp @@ -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); diff --git a/rabbit/Table.cpp b/rabbit/Table.cpp index d7b9ca8..9c3cec2 100644 --- a/rabbit/Table.cpp +++ b/rabbit/Table.cpp @@ -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; } diff --git a/rabbit/Table.hpp b/rabbit/Table.hpp index 239ed85..7fc2a55 100644 --- a/rabbit/Table.hpp +++ b/rabbit/Table.hpp @@ -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); diff --git a/rabbit/VirtualMachine.cpp b/rabbit/VirtualMachine.cpp index 991875f..1f1bef9 100644 --- a/rabbit/VirtualMachine.cpp +++ b/rabbit/VirtualMachine.cpp @@ -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"));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; } } diff --git a/rabbit/VirtualMachine.hpp b/rabbit/VirtualMachine.hpp index 3f981b3..f2aef71 100644 --- a/rabbit/VirtualMachine.hpp +++ b/rabbit/VirtualMachine.hpp @@ -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); diff --git a/rabbit/rabbit.hpp b/rabbit/rabbit.hpp index 47bfa31..1bb0de2 100644 --- a/rabbit/rabbit.hpp +++ b/rabbit/rabbit.hpp @@ -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); diff --git a/rabbit/sqapi.cpp b/rabbit/sqapi.cpp index 0d370b7..7893817 100644 --- a/rabbit/sqapi.cpp +++ b/rabbit/sqapi.cpp @@ -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; diff --git a/rabbit/sqbaselib.cpp b/rabbit/sqbaselib.cpp index 6c6e5db..65b919d 100644 --- a/rabbit/sqbaselib.cpp +++ b/rabbit/sqbaselib.cpp @@ -26,13 +26,13 @@ #include #include -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;ipush(rabbit::String::create(_get_shared_state(v),snew,len)); \ diff --git a/rabbit/sqconfig.hpp b/rabbit/sqconfig.hpp index 1a0a654..dc08b06 100644 --- a/rabbit/sqconfig.hpp +++ b/rabbit/sqconfig.hpp @@ -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 - #include - 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)<