diff --git a/cmdLine/rabbit.cpp b/cmdLine/rabbit.cpp
index 99b2140..4d43edf 100644
--- a/cmdLine/rabbit.cpp
+++ b/cmdLine/rabbit.cpp
@@ -65,19 +65,19 @@ void errorfunc(rabbit::VirtualMachine* SQ_UNUSED_ARG(v),const char *s,...)
 
 void PrintVersionInfos()
 {
-	fprintf(stdout,_SC("%s %s (%d bits)\n"),RABBIT_VERSION,RABBIT_COPYRIGHT,((int)(sizeof(int64_t)*8)));
+	fprintf(stdout,"%s %s (%d bits)\n",RABBIT_VERSION,RABBIT_COPYRIGHT,((int)(sizeof(int64_t)*8)));
 }
 
 void PrintUsage()
 {
-	fprintf(stderr,_SC("usage: sq <options> <scriptpath [args]>.\n")
-		_SC("Available options are:\n")
-		_SC("   -c			  compiles the file to bytecode(default output 'out.karrot')\n")
-		_SC("   -o			  specifies output file for the -c option\n")
-		_SC("   -c			  compiles only\n")
-		_SC("   -d			  generates debug infos\n")
-		_SC("   -v			  displays version infos\n")
-		_SC("   -h			  prints help\n"));
+	fprintf(stderr,"usage: sq <options> <scriptpath [args]>.\n"
+		"Available options are:\n"
+		"   -c			  compiles the file to bytecode(default output 'out.karrot')\n"
+		"   -o			  specifies output file for the -c option\n"
+		"   -c			  compiles only\n"
+		"   -d			  generates debug infos\n"
+		"   -v			  displays version infos\n"
+		"   -h			  prints help\n");
 }
 
 #define _INTERACTIVE 0
@@ -123,7 +123,7 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
 					return _DONE;
 				default:
 					PrintVersionInfos();
-					printf(_SC("unknown prameter '-%c'\n"),argv[arg][1]);
+					printf("unknown prameter '-%c'\n",argv[arg][1]);
 					PrintUsage();
 					*retval = -1;
 					return _ERROR;
@@ -140,14 +140,14 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
 
 			arg++;
 
-			//sq_pushstring(v,_SC("ARGS"),-1);
+			//sq_pushstring(v,"ARGS",-1);
 			//sq_newarray(v,0);
 
 			//sq_createslot(v,-3);
 			//sq_pop(v,1);
 			if(compiles_only) {
 				if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,SQTrue))){
-					const char *outfile = _SC("out.karrot");
+					const char *outfile = "out.karrot";
 					if(output) {
 						outfile = output;
 					}
@@ -189,7 +189,7 @@ int getargs(rabbit::VirtualMachine* v,int argc, char* argv[],int64_t *retval)
 				const char *err;
 				sq_getlasterror(v);
 				if(SQ_SUCCEEDED(sq_getstring(v,-1,&err))) {
-					printf(_SC("error [%s]\n"),err);
+					printf("error [%s]\n",err);
 					*retval = -2;
 					return _ERROR;
 				}
@@ -213,7 +213,7 @@ void Interactive(rabbit::VirtualMachine* v)
 	PrintVersionInfos();
 
 	sq_pushroottable(v);
-	sq_pushstring(v,_SC("quit"),-1);
+	sq_pushstring(v,"quit",-1);
 	sq_pushuserpointer(v,&done);
 	sq_newclosure(v,quit,1);
 	sq_setparamscheck(v,1,NULL);
@@ -223,58 +223,58 @@ void Interactive(rabbit::VirtualMachine* v)
 	while (!done)
 	{
 		int64_t i = 0;
-		printf(_SC("\nrabbit> "));
+		printf("\nrabbit> ");
 		for(;;) {
 			int c;
 			if(done)return;
 			c = getchar();
-			if (c == _SC('\n')) {
-				if (i>0 && buffer[i-1] == _SC('\\'))
+			if (c == '\n') {
+				if (i>0 && buffer[i-1] == '\\')
 				{
-					buffer[i-1] = _SC('\n');
+					buffer[i-1] = '\n';
 				}
 				else if(blocks==0)break;
-				buffer[i++] = _SC('\n');
+				buffer[i++] = '\n';
 			}
-			else if (c==_SC('}')) {blocks--; buffer[i++] = (char)c;}
-			else if(c==_SC('{') && !string){
+			else if (c=='}') {blocks--; buffer[i++] = (char)c;}
+			else if(c=='{' && !string){
 					blocks++;
 					buffer[i++] = (char)c;
 			}
-			else if(c==_SC('"') || c==_SC('\'')){
+			else if(c=='"' || c=='\''){
 					string=!string;
 					buffer[i++] = (char)c;
 			}
 			else if (i >= MAXINPUT-1) {
-				fprintf(stderr, _SC("sq : input line too long\n"));
+				fprintf(stderr, "rabbit: input line too long\n");
 				break;
 			}
 			else{
 				buffer[i++] = (char)c;
 			}
 		}
-		buffer[i] = _SC('\0');
+		buffer[i] = '\0';
 
-		if(buffer[0]==_SC('=')){
-			snprintf(sq_getscratchpad(v,MAXINPUT),(size_t)MAXINPUT,_SC("return (%s)"),&buffer[1]);
+		if(buffer[0]=='='){
+			snprintf(sq_getscratchpad(v,MAXINPUT),(size_t)MAXINPUT,"return (%s)",&buffer[1]);
 			memcpy(buffer,sq_getscratchpad(v,-1),(strlen(sq_getscratchpad(v,-1))+1)*sizeof(char));
 			retval=1;
 		}
 		i=strlen(buffer);
 		if(i>0){
 			int64_t oldtop=sq_gettop(v);
-			if(SQ_SUCCEEDED(sq_compilebuffer(v,buffer,i,_SC("interactive console"),SQTrue))){
+			if(SQ_SUCCEEDED(sq_compilebuffer(v,buffer,i,"interactive console",SQTrue))){
 				sq_pushroottable(v);
 				if(SQ_SUCCEEDED(sq_call(v,1,retval,SQTrue)) &&  retval){
-					printf(_SC("\n"));
+					printf("\n");
 					sq_pushroottable(v);
-					sq_pushstring(v,_SC("print"),-1);
+					sq_pushstring(v,"print",-1);
 					sq_get(v,-2);
 					sq_pushroottable(v);
 					sq_push(v,-4);
 					sq_call(v,2,SQFalse,SQTrue);
 					retval=0;
-					printf(_SC("\n"));
+					printf("\n");
 				}
 			}
 
diff --git a/etc/minimal.cpp b/etc/minimal.cpp
index 77164da..67b03d6 100644
--- a/etc/minimal.cpp
+++ b/etc/minimal.cpp
@@ -25,7 +25,7 @@ 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
-	sq_pushstring(v,_SC("foo"),-1);
+	sq_pushstring(v,"foo",-1);
 	if(SQ_SUCCEEDED(sq_get(v,-2))) { //gets the field 'foo' from the global table
 		sq_pushroottable(v); //push the 'this' (in this case is the global table)
 		sq_pushinteger(v,n);
@@ -53,9 +53,9 @@ int main(int argc, char* argv[])
 	sq_setprintfunc(v, printfunc,errorfunc); //sets the print function
 
 	sq_pushroottable(v); //push the root table(were the globals of the script will be stored)
-	if(SQ_SUCCEEDED(rabbit::std::dofile(v, _SC("test.nut"), SQFalse, SQTrue))) // also prints syntax errors if any
+	if(SQ_SUCCEEDED(rabbit::std::dofile(v, "test.nut", SQFalse, SQTrue))) // also prints syntax errors if any
 	{
-		call_foo(v,1,2.5,_SC("teststring"));
+		call_foo(v,1,2.5,"teststring");
 	}
 
 	sq_pop(v,1); //pops the root table
diff --git a/rabbit-std/sqstdaux.cpp b/rabbit-std/sqstdaux.cpp
index de54855..199e76f 100644
--- a/rabbit-std/sqstdaux.cpp
+++ b/rabbit-std/sqstdaux.cpp
@@ -22,18 +22,18 @@ void rabbit::std::printcallstack(rabbit::VirtualMachine* v)
 		int64_t level=1; //1 is to skip this function that is level 0
 		const char *name=0;
 		int64_t seq=0;
-		pf(v,_SC("\nCALLSTACK\n"));
+		pf(v,"\nCALLSTACK\n");
 		while(SQ_SUCCEEDED(sq_stackinfos(v,level,&si)))
 		{
-			const char *fn=_SC("unknown");
-			const char *src=_SC("unknown");
+			const char *fn="unknown";
+			const char *src="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);
+			pf(v,"*FUNCTION [%s()] %s line [%d]\n",fn,src,si.line);
 			level++;
 		}
 		level=0;
-		pf(v,_SC("\nLOCALS\n"));
+		pf(v,"\nLOCALS\n");
 
 		for(level=0;level<10;level++){
 			seq=0;
@@ -43,58 +43,58 @@ void rabbit::std::printcallstack(rabbit::VirtualMachine* v)
 				switch(sq_gettype(v,-1))
 				{
 				case rabbit::OT_NULL:
-					pf(v,_SC("[%s] NULL\n"),name);
+					pf(v,"[%s] NULL\n",name);
 					break;
 				case rabbit::OT_INTEGER:
 					sq_getinteger(v,-1,&i);
-					pf(v,_SC("[%s] %d\n"),name,i);
+					pf(v,"[%s] %d\n",name,i);
 					break;
 				case rabbit::OT_FLOAT:
 					sq_getfloat(v,-1,&f);
-					pf(v,_SC("[%s] %.14g\n"),name,f);
+					pf(v,"[%s] %.14g\n",name,f);
 					break;
 				case rabbit::OT_USERPOINTER:
-					pf(v,_SC("[%s] USERPOINTER\n"),name);
+					pf(v,"[%s] USERPOINTER\n",name);
 					break;
 				case rabbit::OT_STRING:
 					sq_getstring(v,-1,&s);
-					pf(v,_SC("[%s] \"%s\"\n"),name,s);
+					pf(v,"[%s] \"%s\"\n",name,s);
 					break;
 				case rabbit::OT_TABLE:
-					pf(v,_SC("[%s] TABLE\n"),name);
+					pf(v,"[%s] TABLE\n",name);
 					break;
 				case rabbit::OT_ARRAY:
-					pf(v,_SC("[%s] ARRAY\n"),name);
+					pf(v,"[%s] ARRAY\n",name);
 					break;
 				case rabbit::OT_CLOSURE:
-					pf(v,_SC("[%s] CLOSURE\n"),name);
+					pf(v,"[%s] CLOSURE\n",name);
 					break;
 				case rabbit::OT_NATIVECLOSURE:
-					pf(v,_SC("[%s] NATIVECLOSURE\n"),name);
+					pf(v,"[%s] NATIVECLOSURE\n",name);
 					break;
 				case rabbit::OT_GENERATOR:
-					pf(v,_SC("[%s] GENERATOR\n"),name);
+					pf(v,"[%s] GENERATOR\n",name);
 					break;
 				case rabbit::OT_USERDATA:
-					pf(v,_SC("[%s] USERDATA\n"),name);
+					pf(v,"[%s] USERDATA\n",name);
 					break;
 				case rabbit::OT_THREAD:
-					pf(v,_SC("[%s] THREAD\n"),name);
+					pf(v,"[%s] THREAD\n",name);
 					break;
 				case rabbit::OT_CLASS:
-					pf(v,_SC("[%s] CLASS\n"),name);
+					pf(v,"[%s] CLASS\n",name);
 					break;
 				case rabbit::OT_INSTANCE:
-					pf(v,_SC("[%s] INSTANCE\n"),name);
+					pf(v,"[%s] INSTANCE\n",name);
 					break;
 				case rabbit::OT_WEAKREF:
-					pf(v,_SC("[%s] WEAKREF\n"),name);
+					pf(v,"[%s] WEAKREF\n",name);
 					break;
 				case rabbit::OT_BOOL:
 					{
 						rabbit::Bool bval;
 						sq_getbool(v,-1,&bval);
-						pf(v,_SC("[%s] %s\n"),name,bval == SQTrue ? _SC("true"):_SC("false"));
+						pf(v,"[%s] %s\n",name,bval == SQTrue ? "true":"false");
 					}
 					break;
 				default: assert(0); break;
@@ -113,10 +113,10 @@ namespace rabbit {
 				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);
+						pf(v,"\nAN ERROR HAS OCCURRED [%s]\n",sErr);
 					}
 					else{
-						pf(v,_SC("\nAN ERROR HAS OCCURRED [unknown]\n"));
+						pf(v,"\nAN ERROR HAS OCCURRED [unknown]\n");
 					}
 					rabbit::std::printcallstack(v);
 				}
@@ -127,7 +127,7 @@ namespace rabbit {
 		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);
+				pf(v,"%s line = (%d) column = (%d) : error %s\n",sSource,line,column,sErr);
 			}
 		}
 	}
diff --git a/rabbit-std/sqstdblob.cpp b/rabbit-std/sqstdblob.cpp
index 903b16c..fd6ec94 100644
--- a/rabbit-std/sqstdblob.cpp
+++ b/rabbit-std/sqstdblob.cpp
@@ -15,9 +15,9 @@
 #define SETUP_BLOB(v) \
 	rabbit::std::Blob *self = NULL; \
 	{ if(SQ_FAILED(rabbit::sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG))) \
-		return rabbit::sq_throwerror(v,_SC("invalid type tag"));  } \
+		return rabbit::sq_throwerror(v,"invalid type tag");  } \
 	if(!self || !self->IsValid())  \
-		return rabbit::sq_throwerror(v,_SC("the blob is invalid"));
+		return rabbit::sq_throwerror(v,"the blob is invalid");
 
 
 static int64_t _blob_resize(rabbit::VirtualMachine* v)
@@ -26,7 +26,7 @@ static int64_t _blob_resize(rabbit::VirtualMachine* v)
 	int64_t size;
 	rabbit::sq_getinteger(v,2,&size);
 	if(!self->resize(size))
-		return rabbit::sq_throwerror(v,_SC("resize failed"));
+		return rabbit::sq_throwerror(v,"resize failed");
 	return 0;
 }
 
@@ -72,7 +72,7 @@ static int64_t _blob__set(rabbit::VirtualMachine* v)
 	rabbit::sq_getinteger(v,2,&idx);
 	rabbit::sq_getinteger(v,3,&val);
 	if(idx < 0 || idx >= self->Len())
-		return rabbit::sq_throwerror(v,_SC("index out of range"));
+		return rabbit::sq_throwerror(v,"index out of range");
 	((unsigned char *)self->getBuf())[idx] = (unsigned char) val;
 	rabbit::sq_push(v,3);
 	return 1;
@@ -90,7 +90,7 @@ static int64_t _blob__get(rabbit::VirtualMachine* v)
 	}
 	rabbit::sq_getinteger(v,2,&idx);
 	if(idx < 0 || idx >= self->Len())
-		return rabbit::sq_throwerror(v,_SC("index out of range"));
+		return rabbit::sq_throwerror(v,"index out of range");
 	rabbit::sq_pushinteger(v,((unsigned char *)self->getBuf())[idx]);
 	return 1;
 }
@@ -111,12 +111,12 @@ static int64_t _blob__nexti(rabbit::VirtualMachine* v)
 		rabbit::sq_pushnull(v);
 		return 1;
 	}
-	return rabbit::sq_throwerror(v,_SC("internal error (_nexti) wrong argument type"));
+	return rabbit::sq_throwerror(v,"internal error (_nexti) wrong argument type");
 }
 
 static int64_t _blob__typeof(rabbit::VirtualMachine* v)
 {
-	rabbit::sq_pushstring(v,_SC("blob"),-1);
+	rabbit::sq_pushstring(v,"blob",-1);
 	return 1;
 }
 
@@ -135,14 +135,14 @@ static int64_t _blob_constructor(rabbit::VirtualMachine* v)
 	if(nparam == 2) {
 		rabbit::sq_getinteger(v, 2, &size);
 	}
-	if(size < 0) return rabbit::sq_throwerror(v, _SC("cannot create blob with negative size"));
+	if(size < 0) return rabbit::sq_throwerror(v, "cannot create blob with negative size");
 	//rabbit::std::Blob *b = new rabbit::std::Blob(size);
 
 	rabbit::std::Blob *b = new (rabbit::sq_malloc(sizeof(rabbit::std::Blob)))rabbit::std::Blob(size);
 	if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,b))) {
 		b->~Blob();
 		rabbit::sq_free(b,sizeof(rabbit::std::Blob));
-		return rabbit::sq_throwerror(v, _SC("cannot create blob"));
+		return rabbit::sq_throwerror(v, "cannot create blob");
 	}
 	rabbit::sq_setreleasehook(v,1,_blob_releasehook);
 	return 0;
@@ -161,23 +161,23 @@ static int64_t _blob__cloned(rabbit::VirtualMachine* v)
 	if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,thisone))) {
 		thisone->~Blob();
 		rabbit::sq_free(thisone,sizeof(rabbit::std::Blob));
-		return rabbit::sq_throwerror(v, _SC("cannot clone blob"));
+		return rabbit::sq_throwerror(v, "cannot clone blob");
 	}
 	rabbit::sq_setreleasehook(v,1,_blob_releasehook);
 	return 0;
 }
 
-#define _DECL_BLOB_FUNC(name,nparams,typecheck) {_SC(#name),_blob_##name,nparams,typecheck}
+#define _DECL_BLOB_FUNC(name,nparams,typecheck) {#name,_blob_##name,nparams,typecheck}
 static const rabbit::RegFunction _blob_methods[] = {
-	_DECL_BLOB_FUNC(constructor,-1,_SC("xn")),
-	_DECL_BLOB_FUNC(resize,2,_SC("xn")),
-	_DECL_BLOB_FUNC(swap2,1,_SC("x")),
-	_DECL_BLOB_FUNC(swap4,1,_SC("x")),
-	_DECL_BLOB_FUNC(_set,3,_SC("xnn")),
-	_DECL_BLOB_FUNC(_get,2,_SC("x.")),
-	_DECL_BLOB_FUNC(_typeof,1,_SC("x")),
-	_DECL_BLOB_FUNC(_nexti,2,_SC("x")),
-	_DECL_BLOB_FUNC(_cloned,2,_SC("xx")),
+	_DECL_BLOB_FUNC(constructor,-1,"xn"),
+	_DECL_BLOB_FUNC(resize,2,"xn"),
+	_DECL_BLOB_FUNC(swap2,1,"x"),
+	_DECL_BLOB_FUNC(swap4,1,"x"),
+	_DECL_BLOB_FUNC(_set,3,"xnn"),
+	_DECL_BLOB_FUNC(_get,2,"x."),
+	_DECL_BLOB_FUNC(_typeof,1,"x"),
+	_DECL_BLOB_FUNC(_nexti,2,"x"),
+	_DECL_BLOB_FUNC(_cloned,2,"xx"),
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
@@ -229,13 +229,13 @@ static int64_t _g_blob_swapfloat(rabbit::VirtualMachine* v)
 	return 1;
 }
 
-#define _DECL_GLOBALBLOB_FUNC(name,nparams,typecheck) {_SC(#name),_g_blob_##name,nparams,typecheck}
+#define _DECL_GLOBALBLOB_FUNC(name,nparams,typecheck) {#name,_g_blob_##name,nparams,typecheck}
 static const rabbit::RegFunction bloblib_funcs[]={
-	_DECL_GLOBALBLOB_FUNC(casti2f,2,_SC(".n")),
-	_DECL_GLOBALBLOB_FUNC(castf2i,2,_SC(".n")),
-	_DECL_GLOBALBLOB_FUNC(swap2,2,_SC(".n")),
-	_DECL_GLOBALBLOB_FUNC(swap4,2,_SC(".n")),
-	_DECL_GLOBALBLOB_FUNC(swapfloat,2,_SC(".n")),
+	_DECL_GLOBALBLOB_FUNC(casti2f,2,".n"),
+	_DECL_GLOBALBLOB_FUNC(castf2i,2,".n"),
+	_DECL_GLOBALBLOB_FUNC(swap2,2,".n"),
+	_DECL_GLOBALBLOB_FUNC(swap4,2,".n"),
+	_DECL_GLOBALBLOB_FUNC(swapfloat,2,".n"),
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
@@ -260,7 +260,7 @@ rabbit::UserPointer rabbit::std::createblob(rabbit::VirtualMachine* v, int64_t s
 {
 	int64_t top = rabbit::sq_gettop(v);
 	rabbit::sq_pushregistrytable(v);
-	rabbit::sq_pushstring(v,_SC("std_blob"),-1);
+	rabbit::sq_pushstring(v,"std_blob",-1);
 	if(SQ_SUCCEEDED(rabbit::sq_get(v,-2))) {
 		rabbit::sq_remove(v,-2); //removes the registry
 		rabbit::sq_push(v,1); // push the this
@@ -278,6 +278,6 @@ rabbit::UserPointer rabbit::std::createblob(rabbit::VirtualMachine* v, int64_t s
 
 rabbit::Result rabbit::std::register_bloblib(rabbit::VirtualMachine* v)
 {
-	return declare_stream(v,_SC("blob"),(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG,_SC("std_blob"),_blob_methods,bloblib_funcs);
+	return declare_stream(v,"blob",(rabbit::UserPointer)SQSTD_BLOB_TYPE_TAG,"std_blob",_blob_methods,bloblib_funcs);
 }
 
diff --git a/rabbit-std/sqstdio.cpp b/rabbit-std/sqstdio.cpp
index 608361e..d677e43 100644
--- a/rabbit-std/sqstdio.cpp
+++ b/rabbit-std/sqstdio.cpp
@@ -117,7 +117,7 @@ namespace rabbit {
 }
 static int64_t _file__typeof(rabbit::VirtualMachine* v)
 {
-	sq_pushstring(v,_SC("file"),-1);
+	sq_pushstring(v,"file",-1);
 	return 1;
 }
 
@@ -139,19 +139,19 @@ static int64_t _file_constructor(rabbit::VirtualMachine* v)
 		rabbit::sq_getstring(v, 2, &filename);
 		rabbit::sq_getstring(v, 3, &mode);
 		newf = rabbit::std::fopen(filename, mode);
-		if(!newf) return rabbit::sq_throwerror(v, _SC("cannot open file"));
+		if(!newf) return rabbit::sq_throwerror(v, "cannot open file");
 	} else if(rabbit::sq_gettype(v,2) == rabbit::OT_USERPOINTER) {
 		owns = !(rabbit::sq_gettype(v,3) == rabbit::OT_NULL);
 		rabbit::sq_getuserpointer(v,2,&newf);
 	} else {
-		return rabbit::sq_throwerror(v,_SC("wrong parameter"));
+		return rabbit::sq_throwerror(v,"wrong parameter");
 	}
 
 	f = new (rabbit::sq_malloc(sizeof(rabbit::std::File)))rabbit::std::File(newf,owns);
 	if(SQ_FAILED(rabbit::sq_setinstanceup(v,1,f))) {
 		f->~File();
 		rabbit::sq_free(f,sizeof(rabbit::std::File));
-		return rabbit::sq_throwerror(v, _SC("cannot create blob with negative size"));
+		return rabbit::sq_throwerror(v, "cannot create blob with negative size");
 	}
 	rabbit::sq_setreleasehook(v,1,_file_releasehook);
 	return 0;
@@ -169,11 +169,11 @@ static int64_t _file_close(rabbit::VirtualMachine* v)
 }
 
 //bindings
-#define _DECL_FILE_FUNC(name,nparams,typecheck) {_SC(#name),_file_##name,nparams,typecheck}
+#define _DECL_FILE_FUNC(name,nparams,typecheck) {#name,_file_##name,nparams,typecheck}
 static const rabbit::RegFunction _file_methods[] = {
-	_DECL_FILE_FUNC(constructor,3,_SC("x")),
-	_DECL_FILE_FUNC(_typeof,1,_SC("x")),
-	_DECL_FILE_FUNC(close,1,_SC("x")),
+	_DECL_FILE_FUNC(constructor,3,"x"),
+	_DECL_FILE_FUNC(_typeof,1,"x"),
+	_DECL_FILE_FUNC(close,1,"x"),
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
@@ -183,7 +183,7 @@ rabbit::Result rabbit::std::createfile(rabbit::VirtualMachine* v, SQFILE file,ra
 {
 	int64_t top = sq_gettop(v);
 	sq_pushregistrytable(v);
-	sq_pushstring(v,_SC("std_file"),-1);
+	sq_pushstring(v,"std_file",-1);
 	if(SQ_SUCCEEDED(sq_get(v,-2))) {
 		sq_remove(v,-2); //removes the registry
 		sq_pushroottable(v); // push the this
@@ -210,7 +210,7 @@ rabbit::Result rabbit::std::getfile(rabbit::VirtualMachine* v, int64_t idx, SQFI
 		*file = fileobj->getHandle();
 		return SQ_OK;
 	}
-	return sq_throwerror(v,_SC("not a file"));
+	return sq_throwerror(v,"not a file");
 }
 
 
@@ -305,7 +305,7 @@ int64_t file_write(rabbit::UserPointer file,rabbit::UserPointer p,int64_t size)
 
 rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const char *filename,rabbit::Bool printerror)
 {
-	SQFILE file = rabbit::std::fopen(filename,_SC("rb"));
+	SQFILE file = rabbit::std::fopen(filename,"rb");
 
 	int64_t ret;
 	unsigned short us;
@@ -334,11 +334,11 @@ rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const char *filen
 				case 0xBBEF:
 					if(rabbit::std::fread(&uc,1,sizeof(uc),file) == 0) {
 						rabbit::std::fclose(file);
-						return sq_throwerror(v,_SC("io error"));
+						return sq_throwerror(v,"io error");
 					}
 					if(uc != 0xBF) {
 						rabbit::std::fclose(file);
-						return sq_throwerror(v,_SC("Unrecognized encoding"));
+						return sq_throwerror(v,"Unrecognized encoding");
 					}
 					func = _io_file_lexfeed_PLAIN;
 					break;//UTF-8 ;
@@ -356,14 +356,14 @@ rabbit::Result rabbit::std::loadfile(rabbit::VirtualMachine* v,const char *filen
 		rabbit::std::fclose(file);
 		return SQ_ERROR;
 	}
-	return sq_throwerror(v,_SC("cannot open the file"));
+	return sq_throwerror(v,"cannot open the file");
 }
 
 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)
-		return sq_throwerror(v,_SC("environment table expected"));
+		return sq_throwerror(v,"environment table expected");
 
 	if(SQ_SUCCEEDED(rabbit::std::loadfile(v,filename,printerror))) {
 		sq_push(v,-2);
@@ -378,8 +378,8 @@ rabbit::Result rabbit::std::dofile(rabbit::VirtualMachine* v,const char *filenam
 
 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"));
+	SQFILE file = rabbit::std::fopen(filename,"wb+");
+	if(!file) return sq_throwerror(v,"cannot open the file");
 	if(SQ_SUCCEEDED(sq_writeclosure(v,file_write,file))) {
 		rabbit::std::fclose(file);
 		return SQ_OK;
@@ -424,11 +424,11 @@ int64_t _g_io_dofile(rabbit::VirtualMachine* v)
 	return SQ_ERROR; //propagates the error
 }
 
-#define _DECL_GLOBALIO_FUNC(name,nparams,typecheck) {_SC(#name),_g_io_##name,nparams,typecheck}
+#define _DECL_GLOBALIO_FUNC(name,nparams,typecheck) {#name,_g_io_##name,nparams,typecheck}
 static const rabbit::RegFunction iolib_funcs[]={
-	_DECL_GLOBALIO_FUNC(loadfile,-2,_SC(".sb")),
-	_DECL_GLOBALIO_FUNC(dofile,-2,_SC(".sb")),
-	_DECL_GLOBALIO_FUNC(writeclosuretofile,3,_SC(".sc")),
+	_DECL_GLOBALIO_FUNC(loadfile,-2,".sb"),
+	_DECL_GLOBALIO_FUNC(dofile,-2,".sb"),
+	_DECL_GLOBALIO_FUNC(writeclosuretofile,3,".sc"),
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
@@ -436,14 +436,14 @@ rabbit::Result rabbit::std::register_iolib(rabbit::VirtualMachine* v)
 {
 	int64_t top = sq_gettop(v);
 	//create delegate
-	declare_stream(v,_SC("file"),(rabbit::UserPointer)SQSTD_FILE_TYPE_TAG,_SC("std_file"),_file_methods,iolib_funcs);
-	sq_pushstring(v,_SC("stdout"),-1);
+	declare_stream(v,"file",(rabbit::UserPointer)SQSTD_FILE_TYPE_TAG, "std_file",_file_methods,iolib_funcs);
+	sq_pushstring(v,"stdout",-1);
 	rabbit::std::createfile(v,stdout,SQFalse);
 	sq_newslot(v,-3,SQFalse);
-	sq_pushstring(v,_SC("stdin"),-1);
+	sq_pushstring(v,"stdin",-1);
 	rabbit::std::createfile(v,stdin,SQFalse);
 	sq_newslot(v,-3,SQFalse);
-	sq_pushstring(v,_SC("stderr"),-1);
+	sq_pushstring(v,"stderr",-1);
 	rabbit::std::createfile(v,stderr,SQFalse);
 	sq_newslot(v,-3,SQFalse);
 	sq_settop(v,top);
diff --git a/rabbit-std/sqstdmath.cpp b/rabbit-std/sqstdmath.cpp
index 0075920..f05a620 100644
--- a/rabbit-std/sqstdmath.cpp
+++ b/rabbit-std/sqstdmath.cpp
@@ -30,7 +30,7 @@ static int64_t math_srand(rabbit::VirtualMachine* v)
 {
 	int64_t i;
 	if(SQ_FAILED(sq_getinteger(v,2,&i)))
-		return sq_throwerror(v,_SC("invalid param"));
+		return sq_throwerror(v,"invalid param");
 	srand((unsigned int)i);
 	return 0;
 }
@@ -65,26 +65,26 @@ SINGLE_ARG_FUNC(floor)
 SINGLE_ARG_FUNC(ceil)
 SINGLE_ARG_FUNC(exp)
 
-#define _DECL_FUNC(name,nparams,tycheck) {_SC(#name),math_##name,nparams,tycheck}
+#define _DECL_FUNC(name,nparams,tycheck) {#name,math_##name,nparams,tycheck}
 static const rabbit::RegFunction mathlib_funcs[] = {
-	_DECL_FUNC(sqrt,2,_SC(".n")),
-	_DECL_FUNC(sin,2,_SC(".n")),
-	_DECL_FUNC(cos,2,_SC(".n")),
-	_DECL_FUNC(asin,2,_SC(".n")),
-	_DECL_FUNC(acos,2,_SC(".n")),
-	_DECL_FUNC(log,2,_SC(".n")),
-	_DECL_FUNC(log10,2,_SC(".n")),
-	_DECL_FUNC(tan,2,_SC(".n")),
-	_DECL_FUNC(atan,2,_SC(".n")),
-	_DECL_FUNC(atan2,3,_SC(".nn")),
-	_DECL_FUNC(pow,3,_SC(".nn")),
-	_DECL_FUNC(floor,2,_SC(".n")),
-	_DECL_FUNC(ceil,2,_SC(".n")),
-	_DECL_FUNC(exp,2,_SC(".n")),
-	_DECL_FUNC(srand,2,_SC(".n")),
+	_DECL_FUNC(sqrt,2,".n"),
+	_DECL_FUNC(sin,2,".n"),
+	_DECL_FUNC(cos,2,".n"),
+	_DECL_FUNC(asin,2,".n"),
+	_DECL_FUNC(acos,2,".n"),
+	_DECL_FUNC(log,2,".n"),
+	_DECL_FUNC(log10,2,".n"),
+	_DECL_FUNC(tan,2,".n"),
+	_DECL_FUNC(atan,2,".n"),
+	_DECL_FUNC(atan2,3,".nn"),
+	_DECL_FUNC(pow,3,".nn"),
+	_DECL_FUNC(floor,2,".n"),
+	_DECL_FUNC(ceil,2,".n"),
+	_DECL_FUNC(exp,2,".n"),
+	_DECL_FUNC(srand,2,".n"),
 	_DECL_FUNC(rand,1,NULL),
-	_DECL_FUNC(fabs,2,_SC(".n")),
-	_DECL_FUNC(abs,2,_SC(".n")),
+	_DECL_FUNC(fabs,2,".n"),
+	_DECL_FUNC(abs,2,".n"),
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 #undef _DECL_FUNC
@@ -104,10 +104,10 @@ rabbit::Result rabbit::std::register_mathlib(rabbit::VirtualMachine* v)
 		sq_newslot(v,-3,SQFalse);
 		i++;
 	}
-	sq_pushstring(v,_SC("RAND_MAX"),-1);
+	sq_pushstring(v,"RAND_MAX",-1);
 	sq_pushinteger(v,RAND_MAX);
 	sq_newslot(v,-3,SQFalse);
-	sq_pushstring(v,_SC("PI"),-1);
+	sq_pushstring(v,"PI",-1);
 	sq_pushfloat(v,(float_t)M_PI);
 	sq_newslot(v,-3,SQFalse);
 	return SQ_OK;
diff --git a/rabbit-std/sqstdrex.cpp b/rabbit-std/sqstdrex.cpp
index b98ce92..ffae39f 100644
--- a/rabbit-std/sqstdrex.cpp
+++ b/rabbit-std/sqstdrex.cpp
@@ -15,12 +15,22 @@
 #ifdef _DEBUG
 #include <stdio.h>
 
-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"),
-	_SC("OP_CCLASS"),_SC("OP_NCLASS"),_SC("OP_RANGE"),_SC("OP_CHAR"),
-	_SC("OP_EOL"),_SC("OP_BOL"),_SC("OP_WB"),_SC("OP_MB")
+static const char *g_nnames[] = {
+	"NONE",
+	"OP_GREEDY",
+	"OP_OR",
+	"OP_EXPR",
+	"OP_NOCAPEXPR",
+	"OP_DOT",
+	"OP_CLASS",
+	"OP_CCLASS",
+	"OP_NCLASS",
+	"OP_RANGE",
+	"OP_CHAR",
+	"OP_EOL",
+	"OP_BOL",
+	"OP_WB",
+	"OP_MB"
 };
 
 #endif
@@ -105,7 +115,7 @@ namespace std {
 		
 		static void rex_expect(SQRex *exp, int64_t n){
 			if((*exp->_p) != n)
-				rabbit::std::rex_error(exp, _SC("expected paren"));
+				rabbit::std::rex_error(exp, "expected paren");
 			exp->_p++;
 		}
 		
@@ -121,7 +131,7 @@ namespace std {
 				case 'f': exp->_p++; return '\f';
 				default: return (*exp->_p++);
 				}
-			} else if(!isprint(*exp->_p)) rabbit::std::rex_error(exp,_SC("letter expected"));
+			} else if(!isprint(*exp->_p)) rabbit::std::rex_error(exp,"letter expected");
 			return (*exp->_p++);
 		}
 		
@@ -156,15 +166,15 @@ namespace std {
 							 cb = *++exp->_p; //skip 'm'
 							 ce = *++exp->_p;
 							 exp->_p++; //points to the next char to be parsed
-							 if ((!cb) || (!ce)) rabbit::std::rex_error(exp,_SC("balanced chars expected"));
-							 if ( cb == ce ) rabbit::std::rex_error(exp,_SC("open/close char can't be the same"));
+							 if ((!cb) || (!ce)) rabbit::std::rex_error(exp,"balanced chars expected");
+							 if ( cb == ce ) rabbit::std::rex_error(exp,"open/close char can't be the same");
 							 int64_t node =  rabbit::std::rex_newnode(exp,OP_MB);
 							 exp->_nodes[node].left = cb;
 							 exp->_nodes[node].right = ce;
 							 return node;
 						}
 					case 0:
-						rabbit::std::rex_error(exp,_SC("letter expected for argument of escape sequence"));
+						rabbit::std::rex_error(exp,"letter expected for argument of escape sequence");
 						break;
 					case 'b':
 					case 'B':
@@ -181,7 +191,7 @@ namespace std {
 			}
 			else if(!isprint(*exp->_p)) {
 		
-				rabbit::std::rex_error(exp,_SC("letter expected"));
+				rabbit::std::rex_error(exp,"letter expected");
 			}
 			t = *exp->_p; exp->_p++;
 			return rabbit::std::rex_newnode(exp,t);
@@ -195,15 +205,15 @@ namespace std {
 				exp->_p++;
 			}else ret = rabbit::std::rex_newnode(exp,OP_CLASS);
 		
-			if(*exp->_p == ']') rabbit::std::rex_error(exp,_SC("empty class"));
+			if(*exp->_p == ']') rabbit::std::rex_error(exp,"empty class");
 			chain = ret;
 			while(*exp->_p != ']' && exp->_p != exp->_eol) {
 				if(*exp->_p == '-' && first != -1){
 					int64_t r;
-					if(*exp->_p++ == ']') rabbit::std::rex_error(exp,_SC("unfinished range"));
+					if(*exp->_p++ == ']') rabbit::std::rex_error(exp,"unfinished range");
 					r = rabbit::std::rex_newnode(exp,OP_RANGE);
-					if(exp->_nodes[first].type>*exp->_p) rabbit::std::rex_error(exp,_SC("invalid range"));
-					if(exp->_nodes[first].type == OP_CCLASS) rabbit::std::rex_error(exp,_SC("cannot use character classes in ranges"));
+					if(exp->_nodes[first].type>*exp->_p) rabbit::std::rex_error(exp,"invalid range");
+					if(exp->_nodes[first].type == OP_CCLASS) rabbit::std::rex_error(exp,"cannot use character classes in ranges");
 					exp->_nodes[r].left = exp->_nodes[first].type;
 					int64_t t = rabbit::std::rex_escapechar(exp);
 					exp->_nodes[r].right = t;
@@ -240,7 +250,7 @@ namespace std {
 			exp->_p++;
 			while(isdigit(*exp->_p)) {
 				ret = ret*10+(*exp->_p++-'0');
-				if(positions==1000000000) rabbit::std::rex_error(exp,_SC("overflow in numeric constant"));
+				if(positions==1000000000) rabbit::std::rex_error(exp,"overflow in numeric constant");
 				positions *= 10;
 			};
 			return ret;
@@ -290,7 +300,7 @@ namespace std {
 				case SQREX_SYMBOL_GREEDY_ZERO_OR_ONE: p0 = 0; p1 = 1; exp->_p++; isgreedy = SQTrue; break;
 				case '{':
 					exp->_p++;
-					if(!isdigit(*exp->_p)) rabbit::std::rex_error(exp,_SC("number expected"));
+					if(!isdigit(*exp->_p)) rabbit::std::rex_error(exp,"number expected");
 					p0 = (unsigned short)rabbit::std::rex_parsenumber(exp);
 					/*******************************/
 					switch(*exp->_p) {
@@ -306,7 +316,7 @@ namespace std {
 					rabbit::std::rex_expect(exp,'}');
 					break;
 				default:
-					rabbit::std::rex_error(exp,_SC(", or } expected"));
+					rabbit::std::rex_error(exp,", or } expected");
 					}
 					/*******************************/
 					isgreedy = SQTrue;
@@ -579,22 +589,22 @@ rabbit::std::SQRex *rabbit::std::rex_compile(const char *pattern,const char **er
 		int64_t res = rabbit::std::rex_list(exp);
 		exp->_nodes[exp->_first].left = res;
 		if(*exp->_p!='\0')
-			rabbit::std::rex_error(exp,_SC("unexpected character"));
+			rabbit::std::rex_error(exp,"unexpected character");
 #ifdef _DEBUG
 		{
 			int64_t nsize,i;
 			SQRexNode *t;
 			nsize = exp->_nsize;
 			t = &exp->_nodes[0];
-			printf(_SC("\n"));
+			printf("\n");
 			for(i = 0;i < nsize; i++) {
 				if(exp->_nodes[i].type>UINT8_MAX)
-					printf(_SC("[%02d] %10s "), (int32_t)i,g_nnames[exp->_nodes[i].type-UINT8_MAX]);
+					printf("[%02d] %10s ", (int32_t)i,g_nnames[exp->_nodes[i].type-UINT8_MAX]);
 				else
-					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);
+					printf("[%02d] %10c ", (int32_t)i,exp->_nodes[i].type);
+				printf("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("\n"));
+			printf("\n");
 		}
 #endif
 		exp->_matches = (SQRexMatch *) sq_malloc(exp->_nsubexpr * sizeof(SQRexMatch));
diff --git a/rabbit-std/sqstdstream.cpp b/rabbit-std/sqstdstream.cpp
index d51d5e8..9c56a92 100644
--- a/rabbit-std/sqstdstream.cpp
+++ b/rabbit-std/sqstdstream.cpp
@@ -19,9 +19,9 @@
 #define SETUP_STREAM(v) \
 	rabbit::std::SQStream *self = NULL; \
 	if(SQ_FAILED(sq_getinstanceup(v,1,(rabbit::UserPointer*)&self,(rabbit::UserPointer)((uint64_t)SQSTD_STREAM_TYPE_TAG)))) \
-		return rabbit::sq_throwerror(v,_SC("invalid type tag")); \
+		return rabbit::sq_throwerror(v,"invalid type tag"); \
 	if(!self || !self->IsValid())  \
-		return rabbit::sq_throwerror(v,_SC("the stream is invalid"));
+		return rabbit::sq_throwerror(v,"the stream is invalid");
 
 int64_t _stream_readblob(rabbit::VirtualMachine* v)
 {
@@ -35,14 +35,14 @@ int64_t _stream_readblob(rabbit::VirtualMachine* v)
 	data = sq_getscratchpad(v,size);
 	res = self->Read(data,size);
 	if(res <= 0)
-		return sq_throwerror(v,_SC("no data left to read"));
+		return sq_throwerror(v,"no data left to read");
 	blobp = rabbit::std::createblob(v,res);
 	memcpy(blobp,data,res);
 	return 1;
 }
 
 #define SAFE_READN(ptr,len) { \
-	if(self->Read(ptr,len) != len) return sq_throwerror(v,_SC("io error")); \
+	if(self->Read(ptr,len) != len) return sq_throwerror(v,"io error"); \
 	}
 int64_t _stream_readn(rabbit::VirtualMachine* v)
 {
@@ -99,7 +99,7 @@ int64_t _stream_readn(rabbit::VirtualMachine* v)
 			  }
 		break;
 	default:
-		return sq_throwerror(v, _SC("invalid format"));
+		return sq_throwerror(v, "invalid format");
 	}
 	return 1;
 }
@@ -110,10 +110,10 @@ int64_t _stream_writeblob(rabbit::VirtualMachine* v)
 	int64_t size;
 	SETUP_STREAM(v);
 	if(SQ_FAILED(rabbit::std::getblob(v,2,&data)))
-		return sq_throwerror(v,_SC("invalid parameter"));
+		return sq_throwerror(v,"invalid parameter");
 	size = rabbit::std::getblobsize(v,2);
 	if(self->Write(data,size) != size)
-		return sq_throwerror(v,_SC("io error"));
+		return sq_throwerror(v,"io error");
 	sq_pushinteger(v,size);
 	return 1;
 }
@@ -182,7 +182,7 @@ int64_t _stream_writen(rabbit::VirtualMachine* v)
 			  }
 		break;
 	default:
-		return sq_throwerror(v, _SC("invalid format"));
+		return sq_throwerror(v, "invalid format");
 	}
 	return 0;
 }
@@ -199,7 +199,7 @@ int64_t _stream_seek(rabbit::VirtualMachine* v)
 			case 'b': origin = SQ_SEEK_SET; break;
 			case 'c': origin = SQ_SEEK_CUR; break;
 			case 'e': origin = SQ_SEEK_END; break;
-			default: return sq_throwerror(v,_SC("invalid origin"));
+			default: return sq_throwerror(v,"invalid origin");
 		}
 	}
 	sq_pushinteger(v, self->Seek(offset, origin));
@@ -242,19 +242,19 @@ int64_t _stream_eos(rabbit::VirtualMachine* v)
 
  int64_t _stream__cloned(rabbit::VirtualMachine* v)
  {
-	 return sq_throwerror(v,_SC("this object cannot be cloned"));
+	 return sq_throwerror(v,"this object cannot be cloned");
  }
 
 static const rabbit::RegFunction _stream_methods[] = {
-	_DECL_STREAM_FUNC(readblob,2,_SC("xn")),
-	_DECL_STREAM_FUNC(readn,2,_SC("xn")),
-	_DECL_STREAM_FUNC(writeblob,-2,_SC("xx")),
-	_DECL_STREAM_FUNC(writen,3,_SC("xnn")),
-	_DECL_STREAM_FUNC(seek,-2,_SC("xnn")),
-	_DECL_STREAM_FUNC(tell,1,_SC("x")),
-	_DECL_STREAM_FUNC(len,1,_SC("x")),
-	_DECL_STREAM_FUNC(eos,1,_SC("x")),
-	_DECL_STREAM_FUNC(flush,1,_SC("x")),
+	_DECL_STREAM_FUNC(readblob,2,"xn"),
+	_DECL_STREAM_FUNC(readn,2,"xn"),
+	_DECL_STREAM_FUNC(writeblob,-2,"xx"),
+	_DECL_STREAM_FUNC(writen,3,"xnn"),
+	_DECL_STREAM_FUNC(seek,-2,"xnn"),
+	_DECL_STREAM_FUNC(tell,1,"x"),
+	_DECL_STREAM_FUNC(len,1,"x"),
+	_DECL_STREAM_FUNC(eos,1,"x"),
+	_DECL_STREAM_FUNC(flush,1,"x"),
 	_DECL_STREAM_FUNC(_cloned,0,NULL),
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
@@ -262,9 +262,9 @@ static const rabbit::RegFunction _stream_methods[] = {
 void init_streamclass(rabbit::VirtualMachine* v)
 {
 	sq_pushregistrytable(v);
-	sq_pushstring(v,_SC("std_stream"),-1);
+	sq_pushstring(v,"std_stream",-1);
 	if(SQ_FAILED(sq_get(v,-2))) {
-		sq_pushstring(v,_SC("std_stream"),-1);
+		sq_pushstring(v,"std_stream",-1);
 		sq_newclass(v,SQFalse);
 		sq_settypetag(v,-1,(rabbit::UserPointer)((uint64_t)SQSTD_STREAM_TYPE_TAG));
 		int64_t i = 0;
@@ -278,8 +278,8 @@ void init_streamclass(rabbit::VirtualMachine* v)
 		}
 		sq_newslot(v,-3,SQFalse);
 		sq_pushroottable(v);
-		sq_pushstring(v,_SC("stream"),-1);
-		sq_pushstring(v,_SC("std_stream"),-1);
+		sq_pushstring(v,"stream",-1);
+		sq_pushstring(v,"std_stream",-1);
 		sq_get(v,-4);
 		sq_newslot(v,-3,SQFalse);
 		sq_pop(v,1);
@@ -293,13 +293,13 @@ void init_streamclass(rabbit::VirtualMachine* v)
 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"));
+		return sq_throwerror(v,"table expected");
 	int64_t top = sq_gettop(v);
 	//create delegate
 	init_streamclass(v);
 	sq_pushregistrytable(v);
 	sq_pushstring(v,reg_name,-1);
-	sq_pushstring(v,_SC("std_stream"),-1);
+	sq_pushstring(v,"std_stream",-1);
 	if(SQ_SUCCEEDED(sq_get(v,-3))) {
 		sq_newclass(v,SQTrue);
 		sq_settypetag(v,-1,typetag);
diff --git a/rabbit-std/sqstdstream.hpp b/rabbit-std/sqstdstream.hpp
index 70431b9..575bba3 100644
--- a/rabbit-std/sqstdstream.hpp
+++ b/rabbit-std/sqstdstream.hpp
@@ -22,7 +22,7 @@ namespace rabbit {
 		int64_t _stream_eos(rabbit::VirtualMachine* v);
 		int64_t _stream_flush(rabbit::VirtualMachine* v);
 		
-		#define _DECL_STREAM_FUNC(name,nparams,typecheck) {_SC(#name),_stream_##name,nparams,typecheck}
+		#define _DECL_STREAM_FUNC(name,nparams,typecheck) {#name,_stream_##name,nparams,typecheck}
 		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 0b195b5..0225027 100644
--- a/rabbit-std/sqstdstring.cpp
+++ b/rabbit-std/sqstdstring.cpp
@@ -44,7 +44,7 @@ static int64_t validate_format(rabbit::VirtualMachine* v, char *fmt, const char
 		n++;
 		wc++;
 		if(wc>=MAX_WFORMAT_LEN)
-			return sq_throwerror(v,_SC("width format too long"));
+			return sq_throwerror(v,"width format too long");
 	}
 	swidth[wc] = '\0';
 	if(wc > 0) {
@@ -61,7 +61,7 @@ static int64_t validate_format(rabbit::VirtualMachine* v, char *fmt, const char
 			n++;
 			wc++;
 			if(wc>=MAX_WFORMAT_LEN)
-				return sq_throwerror(v,_SC("precision format too long"));
+				return sq_throwerror(v,"precision format too long");
 		}
 		swidth[wc] = '\0';
 		if(wc > 0) {
@@ -70,7 +70,7 @@ static int64_t validate_format(rabbit::VirtualMachine* v, char *fmt, const char
 		}
 	}
 	if (n-start > MAX_FORMAT_LEN )
-		return sq_throwerror(v,_SC("format too long"));
+		return sq_throwerror(v,"format too long");
 	memcpy(&fmt[1],&src[start],((n-start)+1)*sizeof(char));
 	fmt[(n-start)+2] = '\0';
 	return n;
@@ -104,7 +104,7 @@ rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstri
 		else {
 			n++;
 			if( nparam > sq_gettop(v) )
-				return sq_throwerror(v,_SC("not enough parameters for the given format string"));
+				return sq_throwerror(v,"not enough parameters for the given format string");
 			n = validate_format(v,fmt,format,n,w);
 			if(n < 0) return -1;
 			int64_t addlen = 0;
@@ -115,7 +115,7 @@ rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstri
 			switch(format[n]) {
 			case 's':
 				if(SQ_FAILED(sq_getstring(v,nparam,&ts)))
-					return sq_throwerror(v,_SC("string expected for the specified format"));
+					return sq_throwerror(v,"string expected for the specified format");
 				addlen = (sq_getsize(v,nparam)*sizeof(char))+((w+1)*sizeof(char));
 				valtype = 's';
 				break;
@@ -126,27 +126,27 @@ rabbit::Result rabbit::std::format(rabbit::VirtualMachine* v,int64_t nformatstri
 				int64_t fpos = flen - 1;
 				char f = fmt[fpos];
 				const char *prec = (const char *)_PRINT_INT_PREC;
-				while(*prec != _SC('\0')) {
+				while(*prec != '\0') {
 					fmt[fpos++] = *prec++;
 				}
 				fmt[fpos++] = f;
-				fmt[fpos++] = _SC('\0');
+				fmt[fpos++] = '\0';
 				}
 #endif
 			case 'c':
 				if(SQ_FAILED(sq_getinteger(v,nparam,&ti)))
-					return sq_throwerror(v,_SC("integer expected for the specified format"));
+					return sq_throwerror(v,"integer expected for the specified format");
 				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"));
+					return sq_throwerror(v,"float expected for the specified format");
 				addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(char));
 				valtype = 'f';
 				break;
 			default:
-				return sq_throwerror(v,_SC("invalid format"));
+				return sq_throwerror(v,"invalid format");
 			}
 			n++;
 			allocated += addlen + sizeof(char);
@@ -243,7 +243,7 @@ static int64_t _string_split(rabbit::VirtualMachine* v)
 	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"));
+	if(sepsize == 0) return sq_throwerror(v,"empty separators string");
 	int64_t memsize = (sq_getsize(v,2)+1)*sizeof(char);
 	stemp = sq_getscratchpad(v,memsize);
 	memcpy(stemp,str,memsize);
@@ -285,7 +285,7 @@ static int64_t _string_escape(rabbit::VirtualMachine* v)
 		sq_push(v,2);
 		return 1;
 	}
-	const char *escpat = _SC("\\x%02x");
+	const char *escpat = "\\x%02x";
 	const int64_t maxescsize = 4;
 	int64_t destcharsize = (size * maxescsize); //assumes every char could be escaped
 	resstr = dest = (char *)sq_getscratchpad(v,destcharsize * sizeof(char));
@@ -392,10 +392,10 @@ static int64_t _regexp_match(rabbit::VirtualMachine* v)
 static void _addrexmatch(rabbit::VirtualMachine* v,const char *str,const char *begin,const char *end)
 {
 	sq_newtable(v);
-	sq_pushstring(v,_SC("begin"),-1);
+	sq_pushstring(v,"begin",-1);
 	sq_pushinteger(v,begin - str);
 	sq_rawset(v,-3);
-	sq_pushstring(v,_SC("end"),-1);
+	sq_pushstring(v,"end",-1);
 	sq_pushinteger(v,end - str);
 	sq_rawset(v,-3);
 }
@@ -458,33 +458,33 @@ static int64_t _regexp_constructor(rabbit::VirtualMachine* v)
 
 static int64_t _regexp__typeof(rabbit::VirtualMachine* v)
 {
-	sq_pushstring(v,_SC("regexp"),-1);
+	sq_pushstring(v,"regexp",-1);
 	return 1;
 }
 
-#define _DECL_REX_FUNC(name,nparams,pmask) {_SC(#name),_regexp_##name,nparams,pmask}
+#define _DECL_REX_FUNC(name,nparams,pmask) {#name,_regexp_##name,nparams,pmask}
 static const rabbit::RegFunction rexobj_funcs[]={
-	_DECL_REX_FUNC(constructor,2,_SC(".s")),
-	_DECL_REX_FUNC(search,-2,_SC("xsn")),
-	_DECL_REX_FUNC(match,2,_SC("xs")),
-	_DECL_REX_FUNC(capture,-2,_SC("xsn")),
-	_DECL_REX_FUNC(subexpcount,1,_SC("x")),
-	_DECL_REX_FUNC(_typeof,1,_SC("x")),
+	_DECL_REX_FUNC(constructor,2,".s"),
+	_DECL_REX_FUNC(search,-2,"xsn"),
+	_DECL_REX_FUNC(match,2,"xs"),
+	_DECL_REX_FUNC(capture,-2,"xsn"),
+	_DECL_REX_FUNC(subexpcount,1,"x"),
+	_DECL_REX_FUNC(_typeof,1,"x"),
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 #undef _DECL_REX_FUNC
 
-#define _DECL_FUNC(name,nparams,pmask) {_SC(#name),_string_##name,nparams,pmask}
+#define _DECL_FUNC(name,nparams,pmask) {#name,_string_##name,nparams,pmask}
 static const rabbit::RegFunction stringlib_funcs[]={
-	_DECL_FUNC(format,-2,_SC(".s")),
-	_DECL_FUNC(printf,-2,_SC(".s")),
-	_DECL_FUNC(strip,2,_SC(".s")),
-	_DECL_FUNC(lstrip,2,_SC(".s")),
-	_DECL_FUNC(rstrip,2,_SC(".s")),
-	_DECL_FUNC(split,3,_SC(".ss")),
-	_DECL_FUNC(escape,2,_SC(".s")),
-	_DECL_FUNC(startswith,3,_SC(".ss")),
-	_DECL_FUNC(endswith,3,_SC(".ss")),
+	_DECL_FUNC(format,-2,".s"),
+	_DECL_FUNC(printf,-2,".s"),
+	_DECL_FUNC(strip,2,".s"),
+	_DECL_FUNC(lstrip,2,".s"),
+	_DECL_FUNC(rstrip,2,".s"),
+	_DECL_FUNC(split,3,".ss"),
+	_DECL_FUNC(escape,2,".s"),
+	_DECL_FUNC(startswith,3,".ss"),
+	_DECL_FUNC(endswith,3,".ss"),
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 #undef _DECL_FUNC
@@ -492,7 +492,7 @@ static const rabbit::RegFunction stringlib_funcs[]={
 
 int64_t rabbit::std::register_stringlib(rabbit::VirtualMachine* v)
 {
-	sq_pushstring(v,_SC("regexp"),-1);
+	sq_pushstring(v,"regexp",-1);
 	sq_newclass(v,SQFalse);
 	int64_t i = 0;
 	while(rexobj_funcs[i].name != 0) {
diff --git a/rabbit-std/sqstdsystem.cpp b/rabbit-std/sqstdsystem.cpp
index f43aad6..fa91388 100644
--- a/rabbit-std/sqstdsystem.cpp
+++ b/rabbit-std/sqstdsystem.cpp
@@ -32,7 +32,7 @@ static int64_t _system_system(rabbit::VirtualMachine* v)
 		sq_pushinteger(v,system(s));
 		return 1;
 	}
-	return sq_throwerror(v,_SC("wrong param"));
+	return sq_throwerror(v,"wrong param");
 }
 
 
@@ -54,7 +54,7 @@ static int64_t _system_remove(rabbit::VirtualMachine* v)
 	const char *s;
 	sq_getstring(v,2,&s);
 	if(remove(s)==-1)
-		return sq_throwerror(v,_SC("remove() failed"));
+		return sq_throwerror(v,"remove() failed");
 	return 0;
 }
 
@@ -64,7 +64,7 @@ static int64_t _system_rename(rabbit::VirtualMachine* v)
 	sq_getstring(v,2,&oldn);
 	sq_getstring(v,3,&newn);
 	if(rename(oldn,newn)==-1)
-		return sq_throwerror(v,_SC("rename() failed"));
+		return sq_throwerror(v,"rename() failed");
 	return 0;
 }
 
@@ -96,30 +96,30 @@ static int64_t _system_date(rabbit::VirtualMachine* v)
 	else
 		date = localtime(&t);
 	if(!date)
-		return sq_throwerror(v,_SC("crt api failure"));
+		return sq_throwerror(v,"crt api failure");
 	sq_newtable(v);
-	_set_integer_slot(v, _SC("sec"), date->tm_sec);
-	_set_integer_slot(v, _SC("min"), date->tm_min);
-	_set_integer_slot(v, _SC("hour"), date->tm_hour);
-	_set_integer_slot(v, _SC("day"), date->tm_mday);
-	_set_integer_slot(v, _SC("month"), date->tm_mon);
-	_set_integer_slot(v, _SC("year"), date->tm_year+1900);
-	_set_integer_slot(v, _SC("wday"), date->tm_wday);
-	_set_integer_slot(v, _SC("yday"), date->tm_yday);
+	_set_integer_slot(v, "sec", date->tm_sec);
+	_set_integer_slot(v, "min", date->tm_min);
+	_set_integer_slot(v, "hour", date->tm_hour);
+	_set_integer_slot(v, "day", date->tm_mday);
+	_set_integer_slot(v, "month", date->tm_mon);
+	_set_integer_slot(v, "year", date->tm_year+1900);
+	_set_integer_slot(v, "wday", date->tm_wday);
+	_set_integer_slot(v, "yday", date->tm_yday);
 	return 1;
 }
 
 
 
-#define _DECL_FUNC(name,nparams,pmask) {_SC(#name),_system_##name,nparams,pmask}
+#define _DECL_FUNC(name,nparams,pmask) {#name,_system_##name,nparams,pmask}
 static const rabbit::RegFunction systemlib_funcs[]={
-	_DECL_FUNC(getenv,2,_SC(".s")),
-	_DECL_FUNC(system,2,_SC(".s")),
+	_DECL_FUNC(getenv,2,".s"),
+	_DECL_FUNC(system,2,".s"),
 	_DECL_FUNC(clock,0,NULL),
 	_DECL_FUNC(time,1,NULL),
-	_DECL_FUNC(date,-1,_SC(".nn")),
-	_DECL_FUNC(remove,2,_SC(".s")),
-	_DECL_FUNC(rename,3,_SC(".ss")),
+	_DECL_FUNC(date,-1,".nn"),
+	_DECL_FUNC(remove,2,".s"),
+	_DECL_FUNC(rename,3,".ss"),
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 #undef _DECL_FUNC
diff --git a/rabbit/Closure.cpp b/rabbit/Closure.cpp
index 308cfac..f1e98cb 100644
--- a/rabbit/Closure.cpp
+++ b/rabbit/Closure.cpp
@@ -28,7 +28,7 @@
 bool rabbit::SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size)
 {
 	if(write(up,dest,size) != size) {
-		v->raise_error(_SC("io error (write function failure)"));
+		v->raise_error("io error (write function failure)");
 		return false;
 	}
 	return true;
@@ -37,7 +37,7 @@ bool rabbit::SafeWrite(rabbit::VirtualMachine* v,SQWRITEFUNC write,rabbit::UserP
 bool rabbit::SafeRead(rabbit::VirtualMachine* v,SQWRITEFUNC read,rabbit::UserPointer up,rabbit::UserPointer dest,int64_t size)
 {
 	if(size && read(up,dest,size) != size) {
-		v->raise_error(_SC("io error, read function failure, the origin stream could be corrupted/trucated"));
+		v->raise_error("io error, read function failure, the origin stream could be corrupted/trucated");
 		return false;
 	}
 	return true;
@@ -53,7 +53,7 @@ bool rabbit::CheckTag(rabbit::VirtualMachine* v,SQWRITEFUNC read,rabbit::UserPoi
 	uint32_t t;
 	_CHECK_IO(SafeRead(v,read,up,&t,sizeof(t)));
 	if(t != tag){
-		v->raise_error(_SC("invalid or corrupted closure stream"));
+		v->raise_error("invalid or corrupted closure stream");
 		return false;
 	}
 	return true;
@@ -76,7 +76,7 @@ bool rabbit::WriteObject(rabbit::VirtualMachine* v,rabbit::UserPointer up,SQWRIT
 	case rabbit::OT_NULL:
 		break;
 	default:
-		v->raise_error(_SC("cannot serialize a %s"),getTypeName(o));
+		v->raise_error("cannot serialize a %s",getTypeName(o));
 		return false;
 	}
 	return true;
@@ -111,7 +111,7 @@ bool rabbit::ReadObject(rabbit::VirtualMachine* v,rabbit::UserPointer up,SQREADF
 		o.Null();
 		break;
 	default:
-		v->raise_error(_SC("cannot serialize a %s"),IdType2Name(t));
+		v->raise_error("cannot serialize a %s",IdType2Name(t));
 		return false;
 	}
 	return true;
diff --git a/rabbit/Compiler.cpp b/rabbit/Compiler.cpp
index 9b6aba6..c59956d 100644
--- a/rabbit/Compiler.cpp
+++ b/rabbit/Compiler.cpp
@@ -95,7 +95,7 @@ public:
 		_lineinfo = lineinfo;_raiseerror = raiseerror;
 		_scope.outers = 0;
 		_scope.stacksize = 0;
-		_compilererror[0] = _SC('\0');
+		_compilererror[0] = '\0';
 	}
 	static void Throwerror(void *ud, const char *s) {
 		rabbit::Compiler *c = (rabbit::Compiler *)ud;
@@ -123,23 +123,23 @@ public:
 					switch(tok)
 					{
 					case TK_IDENTIFIER:
-						etypename = _SC("IDENTIFIER");
+						etypename = "IDENTIFIER";
 						break;
 					case TK_STRING_LITERAL:
-						etypename = _SC("STRING_LITERAL");
+						etypename = "STRING_LITERAL";
 						break;
 					case TK_INTEGER:
-						etypename = _SC("INTEGER");
+						etypename = "INTEGER";
 						break;
 					case TK_FLOAT:
-						etypename = _SC("FLOAT");
+						etypename = "FLOAT";
 						break;
 					default:
 						etypename = _lex.tok2Str(tok);
 					}
-					error(_SC("expected '%s'"), etypename);
+					error("expected '%s'", etypename);
 				}
-				error(_SC("expected '%c'"), tok);
+				error("expected '%c'", tok);
 			}
 		}
 		rabbit::ObjectPtr ret;
@@ -161,12 +161,16 @@ public:
 		Lex();
 		return ret;
 	}
-	bool IsEndOfStatement() { return ((_lex._prevtoken == _SC('\n')) || (_token == RABBIT_EOB) || (_token == _SC('}')) || (_token == _SC(';'))); }
-	void OptionalSemicolon()
-	{
-		if(_token == _SC(';')) { Lex(); return; }
+	bool IsEndOfStatement() {
+		return    _lex._prevtoken == '\n'
+		       || _token == RABBIT_EOB
+		       || _token == '}'
+		       || _token == ';';
+	}
+	void OptionalSemicolon() {
+		if(_token == ';') { Lex(); return; }
 		if(!IsEndOfStatement()) {
-			error(_SC("end of statement expected (; or lf)"));
+			error("end of statement expected (; or lf)");
 		}
 	}
 	void MoveIfCurrentTargetisLocal() {
@@ -182,10 +186,10 @@ public:
 		_debugop = 0;
 
 		FuncState funcstate(_get_shared_state(_vm), NULL,Throwerror,this);
-		funcstate._name = rabbit::String::create(_get_shared_state(_vm), _SC("main"));
+		funcstate._name = rabbit::String::create(_get_shared_state(_vm), "main");
 		_fs = &funcstate;
-		_fs->addParameter(_fs->createString(_SC("this")));
-		_fs->addParameter(_fs->createString(_SC("vargv")));
+		_fs->addParameter(_fs->createString("this"));
+		_fs->addParameter(_fs->createString("vargv"));
 		_fs->_varparams = true;
 		_fs->_sourcename = _sourcename;
 		int64_t stacksize = _fs->getStacksize();
@@ -193,7 +197,7 @@ public:
 			Lex();
 			while(_token > 0){
 				Statement();
-				if(_lex._prevtoken != _SC('}') && _lex._prevtoken != _SC(';')) OptionalSemicolon();
+				if(_lex._prevtoken != '}' && _lex._prevtoken != ';') OptionalSemicolon();
 			}
 			_fs->setStacksize(stacksize);
 			_fs->addLineInfos(_lex._currentline, _lineinfo, true);
@@ -206,7 +210,7 @@ public:
 		}
 		else {
 			if(_raiseerror && _get_shared_state(_vm)->_compilererrorhandler) {
-				_get_shared_state(_vm)->_compilererrorhandler(_vm, _compilererror, sq_type(_sourcename) == rabbit::OT_STRING?_stringval(_sourcename):_SC("unknown"),
+				_get_shared_state(_vm)->_compilererrorhandler(_vm, _compilererror, sq_type(_sourcename) == rabbit::OT_STRING?_stringval(_sourcename):"unknown",
 					_lex._currentline, _lex._currentcolumn);
 			}
 			_vm->_lasterror = rabbit::String::create(_get_shared_state(_vm), _compilererror, -1);
@@ -216,16 +220,16 @@ public:
 	}
 	void Statements()
 	{
-		while(_token != _SC('}') && _token != TK_DEFAULT && _token != TK_CASE) {
+		while(_token != '}' && _token != TK_DEFAULT && _token != TK_CASE) {
 			Statement();
-			if(_lex._prevtoken != _SC('}') && _lex._prevtoken != _SC(';')) OptionalSemicolon();
+			if(_lex._prevtoken != '}' && _lex._prevtoken != ';') OptionalSemicolon();
 		}
 	}
 	void Statement(bool closeframe = true)
 	{
 		_fs->addLineInfos(_lex._currentline, _lineinfo);
 		switch(_token){
-		case _SC(';'):  Lex();				  break;
+		case ';':  Lex();				  break;
 		case TK_IF:	 IfStatement();		  break;
 		case TK_WHILE:	  WhileStatement();	   break;
 		case TK_DO:	 DoWhileStatement();	 break;
@@ -260,7 +264,7 @@ public:
 			}
 			break;}
 		case TK_BREAK:
-			if(_fs->_breaktargets.size() <= 0)error(_SC("'break' has to be in a loop block"));
+			if(_fs->_breaktargets.size() <= 0)error("'break' has to be in a loop block");
 			if(_fs->_breaktargets.back() > 0){
 				_fs->addInstruction(_OP_POPTRAP, _fs->_breaktargets.back(), 0);
 			}
@@ -270,7 +274,7 @@ public:
 			Lex();
 			break;
 		case TK_CONTINUE:
-			if(_fs->_continuetargets.size() <= 0)error(_SC("'continue' has to be in a loop block"));
+			if(_fs->_continuetargets.size() <= 0)error("'continue' has to be in a loop block");
 			if(_fs->_continuetargets.back() > 0) {
 				_fs->addInstruction(_OP_POPTRAP, _fs->_continuetargets.back(), 0);
 			}
@@ -288,11 +292,11 @@ public:
 		case TK_ENUM:
 			EnumStatement();
 			break;
-		case _SC('{'):{
+		case '{':{
 				BEGIN_SCOPE();
 				Lex();
 				Statements();
-				Expect(_SC('}'));
+				Expect('}');
 				if(closeframe) {
 					END_SCOPE();
 				}
@@ -391,7 +395,7 @@ public:
 		_es.donot_get = false;
 		LogicalOrExp();
 		switch(_token)  {
-		case _SC('='):
+		case '=':
 		case TK_NEWSLOT:
 		case TK_MINUSEQ:
 		case TK_PLUSEQ:
@@ -401,8 +405,8 @@ public:
 			int64_t op = _token;
 			int64_t ds = _es.etype;
 			int64_t pos = _es.epos;
-			if(ds == EXPR) error(_SC("can't assign expression"));
-			else if(ds == BASE) error(_SC("'base' cannot be modified"));
+			if(ds == EXPR) error("can't assign expression");
+			else if(ds == BASE) error("'base' cannot be modified");
 			Lex(); Expression();
 
 			switch(op){
@@ -410,9 +414,9 @@ public:
 				if(ds == OBJECT || ds == BASE)
 					EmitDerefOp(_OP_NEWSLOT);
 				else //if _derefstate != DEREF_NO_DEREF && DEREF_FIELD so is the index of a local
-					error(_SC("can't 'create' a local slot"));
+					error("can't 'create' a local slot");
 				break;
-			case _SC('='): //ASSIGN
+			case '=': //ASSIGN
 				switch(ds) {
 				case LOCAL:
 					{
@@ -443,7 +447,7 @@ public:
 			}
 			}
 			break;
-		case _SC('?'): {
+		case '?': {
 			Lex();
 			_fs->addInstruction(_OP_JZ, _fs->popTarget());
 			int64_t jzpos = _fs->getCurrentPos();
@@ -453,7 +457,7 @@ public:
 			if(trg != first_exp) _fs->addInstruction(_OP_MOVE, trg, first_exp);
 			int64_t endfirstexp = _fs->getCurrentPos();
 			_fs->addInstruction(_OP_JMP, 0, 0);
-			Expect(_SC(':'));
+			Expect(':');
 			int64_t jmppos = _fs->getCurrentPos();
 			Expression();
 			int64_t second_exp = _fs->popTarget();
@@ -529,21 +533,21 @@ public:
 	void BitwiseOrExp()
 	{
 		BitwiseXorExp();
-		for(;;) if(_token == _SC('|'))
+		for(;;) if(_token == '|')
 		{BIN_EXP(_OP_BITW, &rabbit::Compiler::BitwiseXorExp,BW_OR);
 		}else return;
 	}
 	void BitwiseXorExp()
 	{
 		BitwiseAndExp();
-		for(;;) if(_token == _SC('^'))
+		for(;;) if(_token == '^')
 		{BIN_EXP(_OP_BITW, &rabbit::Compiler::BitwiseAndExp,BW_XOR);
 		}else return;
 	}
 	void BitwiseAndExp()
 	{
 		EqExp();
-		for(;;) if(_token == _SC('&'))
+		for(;;) if(_token == '&')
 		{BIN_EXP(_OP_BITW, &rabbit::Compiler::EqExp,BW_AND);
 		}else return;
 	}
@@ -561,8 +565,8 @@ public:
 	{
 		ShiftExp();
 		for(;;) switch(_token) {
-		case _SC('>'): BIN_EXP(_OP_CMP, &rabbit::Compiler::ShiftExp,CMP_G); break;
-		case _SC('<'): BIN_EXP(_OP_CMP, &rabbit::Compiler::ShiftExp,CMP_L); break;
+		case '>': BIN_EXP(_OP_CMP, &rabbit::Compiler::ShiftExp,CMP_G); break;
+		case '<': BIN_EXP(_OP_CMP, &rabbit::Compiler::ShiftExp,CMP_L); break;
 		case TK_GE: BIN_EXP(_OP_CMP, &rabbit::Compiler::ShiftExp,CMP_GE); break;
 		case TK_LE: BIN_EXP(_OP_CMP, &rabbit::Compiler::ShiftExp,CMP_LE); break;
 		case TK_IN: BIN_EXP(_OP_EXISTS, &rabbit::Compiler::ShiftExp); break;
@@ -610,7 +614,7 @@ public:
 	{
 		MultExp();
 		for(;;) switch(_token) {
-		case _SC('+'): case _SC('-'):
+		case '+': case '-':
 			BIN_EXP(ChooseArithOpByToken(_token), &rabbit::Compiler::MultExp); break;
 		default: return;
 		}
@@ -620,7 +624,7 @@ public:
 	{
 		PrefixedExpr();
 		for(;;) switch(_token) {
-		case _SC('*'): case _SC('/'): case _SC('%'):
+		case '*': case '/': case '%':
 			BIN_EXP(ChooseArithOpByToken(_token), &rabbit::Compiler::PrefixedExpr); break;
 		default: return;
 		}
@@ -631,7 +635,7 @@ public:
 		int64_t pos = Factor();
 		for(;;) {
 			switch(_token) {
-			case _SC('.'):
+			case '.':
 				pos = -1;
 				Lex();
 
@@ -649,9 +653,9 @@ public:
 					_es.etype = OBJECT;
 				}
 				break;
-			case _SC('['):
-				if(_lex._prevtoken == _SC('\n')) error(_SC("cannot brake deref/or comma needed after [exp]=exp slot declaration"));
-				Lex(); Expression(); Expect(_SC(']'));
+			case '[':
+				if(_lex._prevtoken == '\n') error("cannot brake deref/or comma needed after [exp]=exp slot declaration");
+				Lex(); Expression(); Expect(']');
 				pos = -1;
 				if(_es.etype==BASE) {
 					Emit2ArgsOP(_OP_GET);
@@ -674,10 +678,10 @@ public:
 					Lex();
 					switch(_es.etype)
 					{
-						case EXPR: error(_SC("can't '++' or '--' an expression")); break;
+						case EXPR: error("can't '++' or '--' an expression"); break;
 						case OBJECT:
 						case BASE:
-							if(_es.donot_get == true)  { error(_SC("can't '++' or '--' an expression")); break; } //mmh dor this make sense?
+							if(_es.donot_get == true)  { error("can't '++' or '--' an expression"); break; } //mmh dor this make sense?
 							Emit2ArgsOP(_OP_PINC, diff);
 							break;
 						case LOCAL: {
@@ -697,7 +701,7 @@ public:
 				}
 				return;
 				break;
-			case _SC('('):
+			case '(':
 				switch(_es.etype) {
 					case OBJECT: {
 						int64_t key	 = _fs->popTarget();  /* location of the key */
@@ -750,8 +754,8 @@ public:
 
 				switch(_token) {
 					case TK_IDENTIFIER:  id = _fs->createString(_lex._svalue);	   break;
-					case TK_THIS:		id = _fs->createString(_SC("this"),4);		break;
-					case TK_CONSTRUCTOR: id = _fs->createString(_SC("constructor"),11); break;
+					case TK_THIS:		id = _fs->createString("this",4);		break;
+					case TK_CONSTRUCTOR: id = _fs->createString("constructor",11); break;
 				}
 
 				int64_t pos = -1;
@@ -785,7 +789,7 @@ public:
 						constid = Expect(TK_IDENTIFIER);
 						if(!_table(constant)->get(constid, constval)) {
 							constval.Null();
-							error(_SC("invalid constant [%s.%s]"), _stringval(id), _stringval(constid));
+							error("invalid constant [%s.%s]", _stringval(id), _stringval(constid));
 						}
 					}
 					else {
@@ -823,7 +827,7 @@ public:
 		case TK_DOUBLE_COLON:  // "::"
 			_fs->addInstruction(_OP_LOADROOT, _fs->pushTarget());
 			_es.etype = OBJECT;
-			_token = _SC('.'); /* hack: drop into PrefixExpr, case '.'*/
+			_token = '.'; /* hack: drop into PrefixExpr, case '.'*/
 			_es.epos = -1;
 			return _es.epos;
 			break;
@@ -837,13 +841,13 @@ public:
 			_fs->addInstruction(_OP_LOADBOOL, _fs->pushTarget(),_token == TK_TRUE?1:0);
 			Lex();
 			break;
-		case _SC('['): {
+		case '[': {
 				_fs->addInstruction(_OP_NEWOBJ, _fs->pushTarget(),0,0,NOT_ARRAY);
 				int64_t apos = _fs->getCurrentPos(),key = 0;
 				Lex();
-				while(_token != _SC(']')) {
+				while(_token != ']') {
 					Expression();
-					if(_token == _SC(',')) Lex();
+					if(_token == ',') Lex();
 					int64_t val = _fs->popTarget();
 					int64_t array = _fs->topTarget();
 					_fs->addInstruction(_OP_APPENDARRAY, array, val, AAT_STACK);
@@ -853,14 +857,14 @@ public:
 				Lex();
 			}
 			break;
-		case _SC('{'):
+		case '{':
 			_fs->addInstruction(_OP_NEWOBJ, _fs->pushTarget(),0,NOT_TABLE);
-			Lex();ParseTableOrClass(_SC(','),_SC('}'));
+			Lex();ParseTableOrClass(',','}');
 			break;
 		case TK_FUNCTION: FunctionExp(_token);break;
-		case _SC('@'): FunctionExp(_token,true);break;
+		case '@': FunctionExp(_token,true);break;
 		case TK_CLASS: Lex(); ClassExp();break;
-		case _SC('-'):
+		case '-':
 			Lex();
 			switch(_token) {
 			case TK_INTEGER: EmitloadConstInt(-_lex._nvalue,-1); Lex(); break;
@@ -868,8 +872,8 @@ public:
 			default: UnaryOP(_OP_NEG);
 			}
 			break;
-		case _SC('!'): Lex(); UnaryOP(_OP_NOT); break;
-		case _SC('~'):
+		case '!': Lex(); UnaryOP(_OP_NOT); break;
+		case '~':
 			Lex();
 			if(_token == TK_INTEGER)  { EmitloadConstInt(~_lex._nvalue,-1); Lex(); break; }
 			UnaryOP(_OP_BWNOT);
@@ -881,11 +885,11 @@ public:
 		case TK_MINUSMINUS :
 		case TK_PLUSPLUS :PrefixIncDec(_token); break;
 		case TK_DELETE : DeleteExpr(); break;
-		case _SC('('): Lex(); CommaExpr(); Expect(_SC(')'));
+		case '(': Lex(); CommaExpr(); Expect(')');
 			break;
 		case TK___LINE__: EmitloadConstInt(_lex._currentline,-1); Lex(); break;
 		case TK___FILE__: _fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(_sourcename)); Lex(); break;
-		default: error(_SC("expression expected"));
+		default: error("expression expected");
 		}
 		_es.etype = EXPR;
 		return -1;
@@ -923,32 +927,39 @@ public:
 	bool Needget()
 	{
 		switch(_token) {
-		case _SC('='): case _SC('('): case TK_NEWSLOT: case TK_MODEQ: case TK_MULEQ:
-		case TK_DIVEQ: case TK_MINUSEQ: case TK_PLUSEQ:
-			return false;
-		case TK_PLUSPLUS: case TK_MINUSMINUS:
-			if (!IsEndOfStatement()) {
+			case '=':
+			case '(':
+			case TK_NEWSLOT:
+			case TK_MODEQ:
+			case TK_MULEQ:
+			case TK_DIVEQ:
+			case TK_MINUSEQ:
+			case TK_PLUSEQ:
 				return false;
-			}
-		break;
+			case TK_PLUSPLUS:
+			case TK_MINUSMINUS:
+				if (!IsEndOfStatement()) {
+					return false;
+				}
+				break;
 		}
-		return (!_es.donot_get || ( _es.donot_get && (_token == _SC('.') || _token == _SC('['))));
+		return (!_es.donot_get || ( _es.donot_get && (_token == '.' || _token == '[')));
 	}
 	void FunctioncallArgs(bool rawcall = false)
 	{
 		int64_t nargs = 1;//this
-		 while(_token != _SC(')')) {
+		 while(_token != ')') {
 			 Expression();
 			 MoveIfCurrentTargetisLocal();
 			 nargs++;
-			 if(_token == _SC(',')){
+			 if(_token == ','){
 				 Lex();
-				 if(_token == ')') error(_SC("expression expected, found ')'"));
+				 if(_token == ')') error("expression expected, found ')'");
 			 }
 		 }
 		 Lex();
 		 if (rawcall) {
-			 if (nargs < 3) error(_SC("rawcall requires at least 2 parameters (callee and this)"));
+			 if (nargs < 3) error("rawcall requires at least 2 parameters (callee and this)");
 			 nargs -= 2; //removes callee and this from count
 		 }
 		 for(int64_t i = 0; i < (nargs - 1); i++) _fs->popTarget();
@@ -979,26 +990,26 @@ public:
 			case TK_CONSTRUCTOR:{
 				int64_t tk = _token;
 				Lex();
-				rabbit::Object id = tk == TK_FUNCTION ? Expect(TK_IDENTIFIER) : _fs->createString(_SC("constructor"));
-				Expect(_SC('('));
+				rabbit::Object id = tk == TK_FUNCTION ? Expect(TK_IDENTIFIER) : _fs->createString("constructor");
+				Expect('(');
 				_fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(id));
 				createFunction(id);
 				_fs->addInstruction(_OP_CLOSURE, _fs->pushTarget(), _fs->_functions.size() - 1, 0);
 								}
 								break;
-			case _SC('['):
-				Lex(); CommaExpr(); Expect(_SC(']'));
-				Expect(_SC('=')); Expression();
+			case '[':
+				Lex(); CommaExpr(); Expect(']');
+				Expect('='); Expression();
 				break;
 			case TK_STRING_LITERAL: //JSON
 				if(separator == ',') { //only works for tables
 					_fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(Expect(TK_STRING_LITERAL)));
-					Expect(_SC(':')); Expression();
+					Expect(':'); Expression();
 					break;
 				}
 			default :
 				_fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(Expect(TK_IDENTIFIER)));
-				Expect(_SC('=')); Expression();
+				Expect('='); Expression();
 			}
 			if(_token == separator) Lex();//optional comma/semicolon
 			nkeys++;
@@ -1009,14 +1020,14 @@ public:
 			assert((hasattrs && (attrs == key-1)) || !hasattrs);
 			unsigned char flags = (hasattrs?NEW_SLOT_ATTRIBUTES_FLAG:0)|(isstatic?NEW_SLOT_STATIC_FLAG:0);
 			int64_t table = _fs->topTarget(); //<<BECAUSE OF THIS NO COMMON EMIT FUNC IS POSSIBLE
-			if(separator == _SC(',')) { //hack recognizes a table from the separator
+			if(separator == ',') { //hack recognizes a table from the separator
 				_fs->addInstruction(_OP_NEWSLOT, 0xFF, table, key, val);
 			}
 			else {
 				_fs->addInstruction(_OP_NEWSLOTA, flags, table, key, val); //this for classes only as it invokes _newmember
 			}
 		}
-		if(separator == _SC(',')) //hack recognizes a table from the separator
+		if(separator == ',') //hack recognizes a table from the separator
 			_fs->setIntructionParam(tpos, 1, nkeys);
 		Lex();
 	}
@@ -1027,7 +1038,7 @@ public:
 		if( _token == TK_FUNCTION) {
 			Lex();
 			varname = Expect(TK_IDENTIFIER);
-			Expect(_SC('('));
+			Expect('(');
 			createFunction(varname,false);
 			_fs->addInstruction(_OP_CLOSURE, _fs->pushTarget(), _fs->_functions.size() - 1, 0);
 			_fs->popTarget();
@@ -1037,7 +1048,7 @@ public:
 
 		do {
 			varname = Expect(TK_IDENTIFIER);
-			if(_token == _SC('=')) {
+			if(_token == '=') {
 				Lex(); Expression();
 				int64_t src = _fs->popTarget();
 				int64_t dest = _fs->pushTarget();
@@ -1048,17 +1059,17 @@ public:
 			}
 			_fs->popTarget();
 			_fs->pushLocalVariable(varname);
-			if(_token == _SC(',')) Lex(); else break;
+			if(_token == ',') Lex(); else break;
 		} while(1);
 	}
 	void IfBlock()
 	{
-		if (_token == _SC('{'))
+		if (_token == '{')
 		{
 			BEGIN_SCOPE();
 			Lex();
 			Statements();
-			Expect(_SC('}'));
+			Expect('}');
 			if (true) {
 				END_SCOPE();
 			}
@@ -1069,7 +1080,7 @@ public:
 		else {
 			//BEGIN_SCOPE();
 			Statement();
-			if (_lex._prevtoken != _SC('}') && _lex._prevtoken != _SC(';')) OptionalSemicolon();
+			if (_lex._prevtoken != '}' && _lex._prevtoken != ';') OptionalSemicolon();
 			//END_SCOPE();
 		}
 	}
@@ -1077,7 +1088,7 @@ public:
 	{
 		int64_t jmppos;
 		bool haselse = false;
-		Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')'));
+		Lex(); Expect('('); CommaExpr(); Expect(')');
 		_fs->addInstruction(_OP_JZ, _fs->popTarget());
 		int64_t jnepos = _fs->getCurrentPos();
 
@@ -1086,7 +1097,7 @@ public:
 		IfBlock();
 		//
 		/*static int n = 0;
-		if (_token != _SC('}') && _token != TK_ELSE) {
+		if (_token != '}' && _token != TK_ELSE) {
 			printf("IF %d-----------------------!!!!!!!!!\n", n);
 			if (n == 5)
 			{
@@ -1104,7 +1115,7 @@ public:
 			_fs->addInstruction(_OP_JMP);
 			jmppos = _fs->getCurrentPos();
 			Lex();
-			//Statement(); if(_lex._prevtoken != _SC('}')) OptionalSemicolon();
+			//Statement(); if(_lex._prevtoken != '}') OptionalSemicolon();
 			IfBlock();
 			//END_SCOPE();
 			_fs->setIntructionParam(jmppos, 1, _fs->getCurrentPos() - jmppos);
@@ -1115,7 +1126,7 @@ public:
 	{
 		int64_t jzpos, jmppos;
 		jmppos = _fs->getCurrentPos();
-		Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')'));
+		Lex(); Expect('('); CommaExpr(); Expect(')');
 
 		BEGIN_BREAKBLE_BLOCK();
 		_fs->addInstruction(_OP_JZ, _fs->popTarget());
@@ -1140,7 +1151,7 @@ public:
 		END_SCOPE();
 		Expect(TK_WHILE);
 		int64_t continuetrg = _fs->getCurrentPos();
-		Expect(_SC('(')); CommaExpr(); Expect(_SC(')'));
+		Expect('('); CommaExpr(); Expect(')');
 		_fs->addInstruction(_OP_JZ, _fs->popTarget(), 1);
 		_fs->addInstruction(_OP_JMP, 0, jmptrg - _fs->getCurrentPos() - 1);
 		END_BREAKBLE_BLOCK(continuetrg);
@@ -1149,25 +1160,25 @@ public:
 	{
 		Lex();
 		BEGIN_SCOPE();
-		Expect(_SC('('));
+		Expect('(');
 		if(_token == TK_LOCAL) LocalDeclStatement();
-		else if(_token != _SC(';')){
+		else if(_token != ';'){
 			CommaExpr();
 			_fs->popTarget();
 		}
-		Expect(_SC(';'));
+		Expect(';');
 		_fs->snoozeOpt();
 		int64_t jmppos = _fs->getCurrentPos();
 		int64_t jzpos = -1;
-		if(_token != _SC(';')) { CommaExpr(); _fs->addInstruction(_OP_JZ, _fs->popTarget()); jzpos = _fs->getCurrentPos(); }
-		Expect(_SC(';'));
+		if(_token != ';') { CommaExpr(); _fs->addInstruction(_OP_JZ, _fs->popTarget()); jzpos = _fs->getCurrentPos(); }
+		Expect(';');
 		_fs->snoozeOpt();
 		int64_t expstart = _fs->getCurrentPos() + 1;
-		if(_token != _SC(')')) {
+		if(_token != ')') {
 			CommaExpr();
 			_fs->popTarget();
 		}
-		Expect(_SC(')'));
+		Expect(')');
 		_fs->snoozeOpt();
 		int64_t expend = _fs->getCurrentPos();
 		int64_t expsize = (expend - expstart) + 1;
@@ -1194,20 +1205,20 @@ public:
 	void ForEachStatement()
 	{
 		rabbit::Object idxname, valname;
-		Lex(); Expect(_SC('(')); valname = Expect(TK_IDENTIFIER);
-		if(_token == _SC(',')) {
+		Lex(); Expect('('); valname = Expect(TK_IDENTIFIER);
+		if(_token == ',') {
 			idxname = valname;
 			Lex(); valname = Expect(TK_IDENTIFIER);
 		}
 		else{
-			idxname = _fs->createString(_SC("@INDEX@"));
+			idxname = _fs->createString("@INDEX@");
 		}
 		Expect(TK_IN);
 
 		//save the stack size
 		BEGIN_SCOPE();
 		//put the table in the stack(evaluate the table expression)
-		Expression(); Expect(_SC(')'));
+		Expression(); Expect(')');
 		int64_t container = _fs->topTarget();
 		//push the index local var
 		int64_t indexpos = _fs->pushLocalVariable(idxname);
@@ -1216,7 +1227,7 @@ public:
 		int64_t valuepos = _fs->pushLocalVariable(valname);
 		_fs->addInstruction(_OP_LOADNULLS, valuepos,1);
 		//push reference index
-		int64_t itrpos = _fs->pushLocalVariable(_fs->createString(_SC("@ITERATOR@"))); //use invalid id to make it inaccessible
+		int64_t itrpos = _fs->pushLocalVariable(_fs->createString("@ITERATOR@")); //use invalid id to make it inaccessible
 		_fs->addInstruction(_OP_LOADNULLS, itrpos,1);
 		int64_t jmppos = _fs->getCurrentPos();
 		_fs->addInstruction(_OP_FOREACH, container, 0, indexpos);
@@ -1235,8 +1246,8 @@ public:
 	}
 	void SwitchStatement()
 	{
-		Lex(); Expect(_SC('(')); CommaExpr(); Expect(_SC(')'));
-		Expect(_SC('{'));
+		Lex(); Expect('('); CommaExpr(); Expect(')');
+		Expect('{');
 		int64_t expr = _fs->topTarget();
 		bool bfirst = true;
 		int64_t tonextcondjmp = -1;
@@ -1250,7 +1261,7 @@ public:
 				_fs->setIntructionParam(tonextcondjmp, 1, _fs->getCurrentPos() - tonextcondjmp);
 			}
 			//condition
-			Lex(); Expression(); Expect(_SC(':'));
+			Lex(); Expression(); Expect(':');
 			int64_t trg = _fs->popTarget();
 			int64_t eqtarget = trg;
 			bool local = _fs->isLocal(trg);
@@ -1276,12 +1287,12 @@ public:
 		if(tonextcondjmp != -1)
 			_fs->setIntructionParam(tonextcondjmp, 1, _fs->getCurrentPos() - tonextcondjmp);
 		if(_token == TK_DEFAULT) {
-			Lex(); Expect(_SC(':'));
+			Lex(); Expect(':');
 			BEGIN_SCOPE();
 			Statements();
 			END_SCOPE();
 		}
-		Expect(_SC('}'));
+		Expect('}');
 		_fs->popTarget();
 		__nbreaks__ = _fs->_unresolvedbreaks.size() - __nbreaks__;
 		if(__nbreaks__ > 0)ResolveBreaks(_fs, __nbreaks__);
@@ -1301,7 +1312,7 @@ public:
 			_fs->addInstruction(_OP_LOAD, _fs->pushTarget(), _fs->getConstant(id));
 			if(_token == TK_DOUBLE_COLON) Emit2ArgsOP(_OP_GET);
 		}
-		Expect(_SC('('));
+		Expect('(');
 		createFunction(id);
 		_fs->addInstruction(_OP_CLOSURE, _fs->pushTarget(), _fs->_functions.size() - 1, 0);
 		EmitDerefOp(_OP_NEWSLOT);
@@ -1315,7 +1326,7 @@ public:
 		_es.donot_get = true;
 		PrefixedExpr();
 		if(_es.etype == EXPR) {
-			error(_SC("invalid class name"));
+			error("invalid class name");
 		}
 		else if(_es.etype == OBJECT || _es.etype == BASE) {
 			ClassExp();
@@ -1323,7 +1334,7 @@ public:
 			_fs->popTarget();
 		}
 		else {
-			error(_SC("cannot create a class in a local with the syntax(class <local>)"));
+			error("cannot create a class in a local with the syntax(class <local>)");
 		}
 		_es = es;
 	}
@@ -1361,11 +1372,11 @@ public:
 					val._unVal.fFloat = -_lex._fvalue;
 				break;
 				default:
-					error(_SC("scalar expected : integer, float"));
+					error("scalar expected : integer, float");
 				}
 				break;
 			default:
-				error(_SC("scalar expected : integer, float, or string"));
+				error("scalar expected : integer, float, or string");
 		}
 		Lex();
 		return val;
@@ -1374,14 +1385,14 @@ public:
 	{
 		Lex();
 		rabbit::Object id = Expect(TK_IDENTIFIER);
-		Expect(_SC('{'));
+		Expect('{');
 
 		rabbit::Object table = _fs->createTable();
 		int64_t nval = 0;
-		while(_token != _SC('}')) {
+		while(_token != '}') {
 			rabbit::Object key = Expect(TK_IDENTIFIER);
 			rabbit::Object val;
-			if(_token == _SC('=')) {
+			if(_token == '=') {
 				Lex();
 				val = ExpectScalar();
 			}
@@ -1419,7 +1430,7 @@ public:
 		_fs->addInstruction(_OP_JMP, 0, 0);
 		int64_t jmppos = _fs->getCurrentPos();
 		_fs->setIntructionParam(trappos, 1, (_fs->getCurrentPos() - trappos));
-		Expect(TK_CATCH); Expect(_SC('(')); exid = Expect(TK_IDENTIFIER); Expect(_SC(')'));
+		Expect(TK_CATCH); Expect('('); exid = Expect(TK_IDENTIFIER); Expect(')');
 		{
 			BEGIN_SCOPE();
 			int64_t ex_target = _fs->pushLocalVariable(exid);
@@ -1431,7 +1442,7 @@ public:
 	}
 	void FunctionExp(int64_t ftype,bool lambda = false)
 	{
-		Lex(); Expect(_SC('('));
+		Lex(); Expect('(');
 		rabbit::ObjectPtr dummy;
 		createFunction(dummy,lambda);
 		_fs->addInstruction(_OP_CLOSURE, _fs->pushTarget(), _fs->_functions.size() - 1, ftype == TK_FUNCTION?0:1);
@@ -1447,14 +1458,14 @@ public:
 		if(_token == TK_ATTR_OPEN) {
 			Lex();
 			_fs->addInstruction(_OP_NEWOBJ, _fs->pushTarget(),0,NOT_TABLE);
-			ParseTableOrClass(_SC(','),TK_ATTR_CLOSE);
+			ParseTableOrClass(',',TK_ATTR_CLOSE);
 			attrs = _fs->topTarget();
 		}
-		Expect(_SC('{'));
+		Expect('{');
 		if(attrs != -1) _fs->popTarget();
 		if(base != -1) _fs->popTarget();
 		_fs->addInstruction(_OP_NEWOBJ, _fs->pushTarget(), base, attrs,NOT_CLASS);
-		ParseTableOrClass(_SC(';'),_SC('}'));
+		ParseTableOrClass(';','}');
 	}
 	void DeleteExpr()
 	{
@@ -1463,12 +1474,12 @@ public:
 		es = _es;
 		_es.donot_get = true;
 		PrefixedExpr();
-		if(_es.etype==EXPR) error(_SC("can't delete an expression"));
+		if(_es.etype==EXPR) error("can't delete an expression");
 		if(_es.etype==OBJECT || _es.etype==BASE) {
 			Emit2ArgsOP(_OP_DELETE);
 		}
 		else {
-			error(_SC("cannot delete an (outer) local"));
+			error("cannot delete an (outer) local");
 		}
 		_es = es;
 	}
@@ -1481,7 +1492,7 @@ public:
 		_es.donot_get = true;
 		PrefixedExpr();
 		if(_es.etype==EXPR) {
-			error(_SC("can't '++' or '--' an expression"));
+			error("can't '++' or '--' an expression");
 		}
 		else if(_es.etype==OBJECT || _es.etype==BASE) {
 			Emit2ArgsOP(_OP_INC, diff);
@@ -1504,35 +1515,35 @@ public:
 		FuncState *funcstate = _fs->pushChildState(_get_shared_state(_vm));
 		funcstate->_name = name;
 		rabbit::Object paramname;
-		funcstate->addParameter(_fs->createString(_SC("this")));
+		funcstate->addParameter(_fs->createString("this"));
 		funcstate->_sourcename = _sourcename;
 		int64_t defparams = 0;
-		while(_token!=_SC(')')) {
+		while(_token!=')') {
 			if(_token == TK_VARPARAMS) {
-				if(defparams > 0) error(_SC("function with default parameters cannot have variable number of parameters"));
-				funcstate->addParameter(_fs->createString(_SC("vargv")));
+				if(defparams > 0) error("function with default parameters cannot have variable number of parameters");
+				funcstate->addParameter(_fs->createString("vargv"));
 				funcstate->_varparams = true;
 				Lex();
-				if(_token != _SC(')')) error(_SC("expected ')'"));
+				if(_token != ')') error("expected ')'");
 				break;
 			}
 			else {
 				paramname = Expect(TK_IDENTIFIER);
 				funcstate->addParameter(paramname);
-				if(_token == _SC('=')) {
+				if(_token == '=') {
 					Lex();
 					Expression();
 					funcstate->addDefaultParam(_fs->topTarget());
 					defparams++;
 				}
 				else {
-					if(defparams > 0) error(_SC("expected '='"));
+					if(defparams > 0) error("expected '='");
 				}
-				if(_token == _SC(',')) Lex();
-				else if(_token != _SC(')')) error(_SC("expected ')' or ','"));
+				if(_token == ',') Lex();
+				else if(_token != ')') error("expected ')' or ','");
 			}
 		}
-		Expect(_SC(')'));
+		Expect(')');
 		for(int64_t n = 0; n < defparams; n++) {
 			_fs->popTarget();
 		}
@@ -1545,7 +1556,7 @@ public:
 		else {
 			Statement(false);
 		}
-		funcstate->addLineInfos(_lex._prevtoken == _SC('\n')?_lex._lasttokenline:_lex._currentline, _lineinfo, true);
+		funcstate->addLineInfos(_lex._prevtoken == '\n'?_lex._lasttokenline:_lex._currentline, _lineinfo, true);
 		funcstate->addInstruction(_OP_RETURN, -1);
 		funcstate->setStacksize(0);
 
diff --git a/rabbit/FuncState.cpp b/rabbit/FuncState.cpp
index 27b79b0..18d1a13 100644
--- a/rabbit/FuncState.cpp
+++ b/rabbit/FuncState.cpp
@@ -25,67 +25,67 @@
 
 #ifdef _DEBUG_DUMP
 rabbit::InstructionDesc g_InstrDesc[]={
-	{_SC("_OP_LINE")},
-	{_SC("_OP_LOAD")},
-	{_SC("_OP_LOADINT")},
-	{_SC("_OP_LOADFLOAT")},
-	{_SC("_OP_DLOAD")},
-	{_SC("_OP_TAILCALL")},
-	{_SC("_OP_CALL")},
-	{_SC("_OP_PREPCALL")},
-	{_SC("_OP_PREPCALLK")},
-	{_SC("_OP_GETK")},
-	{_SC("_OP_MOVE")},
-	{_SC("_OP_NEWSLOT")},
-	{_SC("_OP_DELETE")},
-	{_SC("_OP_SET")},
-	{_SC("_OP_GET")},
-	{_SC("_OP_EQ")},
-	{_SC("_OP_NE")},
-	{_SC("_OP_ADD")},
-	{_SC("_OP_SUB")},
-	{_SC("_OP_MUL")},
-	{_SC("_OP_DIV")},
-	{_SC("_OP_MOD")},
-	{_SC("_OP_BITW")},
-	{_SC("_OP_RETURN")},
-	{_SC("_OP_LOADNULLS")},
-	{_SC("_OP_LOADROOT")},
-	{_SC("_OP_LOADBOOL")},
-	{_SC("_OP_DMOVE")},
-	{_SC("_OP_JMP")},
-	{_SC("_OP_JCMP")},
-	{_SC("_OP_JZ")},
-	{_SC("_OP_SETOUTER")},
-	{_SC("_OP_GETOUTER")},
-	{_SC("_OP_NEWOBJ")},
-	{_SC("_OP_APPENDARRAY")},
-	{_SC("_OP_COMPARITH")},
-	{_SC("_OP_INC")},
-	{_SC("_OP_INCL")},
-	{_SC("_OP_PINC")},
-	{_SC("_OP_PINCL")},
-	{_SC("_OP_CMP")},
-	{_SC("_OP_EXISTS")},
-	{_SC("_OP_INSTANCEOF")},
-	{_SC("_OP_AND")},
-	{_SC("_OP_OR")},
-	{_SC("_OP_NEG")},
-	{_SC("_OP_NOT")},
-	{_SC("_OP_BWNOT")},
-	{_SC("_OP_CLOSURE")},
-	{_SC("_OP_YIELD")},
-	{_SC("_OP_RESUME")},
-	{_SC("_OP_FOREACH")},
-	{_SC("_OP_POSTFOREACH")},
-	{_SC("_OP_CLONE")},
-	{_SC("_OP_TYPEOF")},
-	{_SC("_OP_PUSHTRAP")},
-	{_SC("_OP_POPTRAP")},
-	{_SC("_OP_THROW")},
-	{_SC("_OP_NEWSLOTA")},
-	{_SC("_OP_GETBASE")},
-	{_SC("_OP_CLOSE")},
+	{"_OP_LINE"},
+	{"_OP_LOAD"},
+	{"_OP_LOADINT"},
+	{"_OP_LOADFLOAT"},
+	{"_OP_DLOAD"},
+	{"_OP_TAILCALL"},
+	{"_OP_CALL"},
+	{"_OP_PREPCALL"},
+	{"_OP_PREPCALLK"},
+	{"_OP_GETK"},
+	{"_OP_MOVE"},
+	{"_OP_NEWSLOT"},
+	{"_OP_DELETE"},
+	{"_OP_SET"},
+	{"_OP_GET"},
+	{"_OP_EQ"},
+	{"_OP_NE"},
+	{"_OP_ADD"},
+	{"_OP_SUB"},
+	{"_OP_MUL"},
+	{"_OP_DIV"},
+	{"_OP_MOD"},
+	{"_OP_BITW"},
+	{"_OP_RETURN"},
+	{"_OP_LOADNULLS"},
+	{"_OP_LOADROOT"},
+	{"_OP_LOADBOOL"},
+	{"_OP_DMOVE"},
+	{"_OP_JMP"},
+	{"_OP_JCMP"},
+	{"_OP_JZ"},
+	{"_OP_SETOUTER"},
+	{"_OP_GETOUTER"},
+	{"_OP_NEWOBJ"},
+	{"_OP_APPENDARRAY"},
+	{"_OP_COMPARITH"},
+	{"_OP_INC"},
+	{"_OP_INCL"},
+	{"_OP_PINC"},
+	{"_OP_PINCL"},
+	{"_OP_CMP"},
+	{"_OP_EXISTS"},
+	{"_OP_INSTANCEOF"},
+	{"_OP_AND"},
+	{"_OP_OR"},
+	{"_OP_NEG"},
+	{"_OP_NOT"},
+	{"_OP_BWNOT"},
+	{"_OP_CLOSURE"},
+	{"_OP_YIELD"},
+	{"_OP_RESUME"},
+	{"_OP_FOREACH"},
+	{"_OP_POSTFOREACH"},
+	{"_OP_CLONE"},
+	{"_OP_TYPEOF"},
+	{"_OP_PUSHTRAP"},
+	{"_OP_POPTRAP"},
+	{"_OP_THROW"},
+	{"_OP_NEWSLOTA"},
+	{"_OP_GETBASE"},
+	{"_OP_CLOSE"},
 };
 #endif
 
@@ -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: 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
+		case rabbit::OT_STRING: printf("\"%s\"",_stringval(o));break;
+		case rabbit::OT_FLOAT: printf("{%f}",_float(o));break;
+		case rabbit::OT_INTEGER: printf("{" _PRINT_INT_FMT "}",_integer(o));break;
+		case rabbit::OT_BOOL: printf("%s",_integer(o)?"true":"false");break;
+		default: printf("(%s %p)",getTypeName(o),(void*)_rawval(o));break; break; //shut up compiler
 	}
 }
 
@@ -136,11 +136,11 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
 {
 	uint64_t n=0,i;
 	int64_t si;
-	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"));
+	printf("rabbit::Instruction sizeof %d\n",(int32_t)sizeof(rabbit::Instruction));
+	printf("rabbit::Object sizeof %d\n", (int32_t)sizeof(rabbit::Object));
+	printf("--------------------------------------------------------------------\n");
+	printf("*****FUNCTION [%s]\n",sq_type(func->_name)==rabbit::OT_STRING?_stringval(func->_name):"unknown");
+	printf("-----LITERALS\n");
 	rabbit::ObjectPtr refidx,key,val;
 	int64_t idx;
 	etk::Vector<rabbit::ObjectPtr> templiterals;
@@ -150,43 +150,43 @@ void rabbit::FuncState::dump(rabbit::FunctionProto *func)
 		templiterals[_integer(val)]=key;
 	}
 	for(i=0;i<templiterals.size();i++){
-		printf(_SC("[%d] "), (int32_t)n);
+		printf("[%d] ", (int32_t)n);
 		dumpLiteral(templiterals[i]);
-		printf(_SC("\n"));
+		printf("\n");
 		n++;
 	}
-	printf(_SC("-----PARAMS\n"));
+	printf("-----PARAMS\n");
 	if(_varparams)
-		printf(_SC("<<VARPARAMS>>\n"));
+		printf("<<VARPARAMS>>\n");
 	n=0;
 	for(i=0;i<_parameters.size();i++){
-		printf(_SC("[%d] "), (int32_t)n);
+		printf("[%d] ", (int32_t)n);
 		dumpLiteral(_parameters[i]);
-		printf(_SC("\n"));
+		printf("\n");
 		n++;
 	}
-	printf(_SC("-----LOCALS\n"));
+	printf("-----LOCALS\n");
 	for(si=0;si<func->_nlocalvarinfos;si++){
 		rabbit::LocalVarInfo lvi=func->_localvarinfos[si];
-		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);
+		printf("[%d] %s \t%d %d\n", (int32_t)lvi._pos,_stringval(lvi._name), (int32_t)lvi._start_op, (int32_t)lvi._end_op);
 		n++;
 	}
-	printf(_SC("-----LINE INFO\n"));
+	printf("-----LINE INFO\n");
 	for(i=0;i<_lineinfos.size();i++){
 		rabbit::LineInfo li=_lineinfos[i];
-		printf(_SC("op [%d] line [%d] \n"), (int32_t)li._op, (int32_t)li._line);
+		printf("op [%d] line [%d] \n", (int32_t)li._op, (int32_t)li._line);
 		n++;
 	}
-	printf(_SC("-----dump\n"));
+	printf("-----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;
-			printf(_SC("[%03d] %15s %d "), (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0);
+			printf("[%03d] %15s %d ", (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0);
 			if(lidx >= 0xFFFFFFFF)
-				printf(_SC("null"));
+				printf("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) {
-				printf(_SC(" %d %d \n"),inst._arg2,inst._arg3);
+				printf(" %d %d \n",inst._arg2,inst._arg3);
 			}
 			else {
-				printf(_SC(" %d "),inst._arg2);
+				printf(" %d ",inst._arg2);
 				lidx = inst._arg3;
 				if(lidx >= 0xFFFFFFFF)
-					printf(_SC("null"));
+					printf("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);
-				printf(_SC("\n"));
+				printf("\n");
 			}
 			}
 		}
 		else if(inst.op==_OP_LOADFLOAT) {
-			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);
+			printf("[%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){
-			printf(_SC("[%03d] %15s %d %d %d %c\n"),n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3);
+			printf("[%03d] %15s %d %d %d %c\n",n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3);
 		}*/
 		else {
-			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);
+			printf("[%03d] %15s %d %d %d %d\n", (int32_t)n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3);
 		}
 		n++;
 	}
-	printf(_SC("-----\n"));
-	printf(_SC("stack size[%d]\n"), (int32_t)func->_stacksize);
-	printf(_SC("--------------------------------------------------------------------\n\n"));
+	printf("-----\n");
+	printf("stack size[%d]\n", (int32_t)func->_stacksize);
+	printf("--------------------------------------------------------------------\n\n");
 }
 #endif
 
@@ -251,7 +251,7 @@ int64_t rabbit::FuncState::getConstant(const rabbit::Object &cons)
 		_nliterals++;
 		if(_nliterals > MAX_LITERALS) {
 			val.Null();
-			error(_SC("internal compiler error: too many literals"));
+			error("internal compiler error: too many literals");
 		}
 	}
 	return _integer(val);
@@ -280,7 +280,7 @@ int64_t rabbit::FuncState::allocStackPos()
 	int64_t npos=_vlocals.size();
 	_vlocals.pushBack(rabbit::LocalVarInfo());
 	if(_vlocals.size()>((uint64_t)_stacksize)) {
-		if(_stacksize>MAX_FUNC_STACKSIZE) error(_SC("internal compiler error: too many locals"));
+		if(_stacksize>MAX_FUNC_STACKSIZE) error("internal compiler error: too many locals");
 		_stacksize=_vlocals.size();
 	}
 	return npos;
diff --git a/rabbit/Generator.cpp b/rabbit/Generator.cpp
index 99a16cf..8731b12 100644
--- a/rabbit/Generator.cpp
+++ b/rabbit/Generator.cpp
@@ -16,8 +16,8 @@
 
 bool rabbit::Generator::yield(rabbit::VirtualMachine *v,int64_t target)
 {
-	if(_state==eSuspended) { v->raise_error(_SC("internal vm error, yielding dead generator"));  return false;}
-	if(_state==eDead) { v->raise_error(_SC("internal vm error, yielding a dead generator")); return false; }
+	if(_state==eSuspended) { v->raise_error("internal vm error, yielding dead generator");  return false;}
+	if(_state==eDead) { v->raise_error("internal vm error, yielding a dead generator"); return false; }
 	int64_t size = v->_top-v->_stackbase;
 
 	_stack.resize(size);
@@ -47,8 +47,8 @@ bool rabbit::Generator::yield(rabbit::VirtualMachine *v,int64_t target)
 
 bool rabbit::Generator::resume(rabbit::VirtualMachine *v,rabbit::ObjectPtr &dest)
 {
-	if(_state==eDead){ v->raise_error(_SC("resuming dead generator")); return false; }
-	if(_state==eRunning){ v->raise_error(_SC("resuming active generator")); return false; }
+	if(_state==eDead){ v->raise_error("resuming dead generator"); return false; }
+	if(_state==eRunning){ v->raise_error("resuming active generator"); return false; }
 	int64_t size = _stack.size();
 	int64_t target = &dest - &(v->_stack[v->_stackbase]);
 	assert(target>=0 && target<=255);
@@ -83,7 +83,7 @@ bool rabbit::Generator::resume(rabbit::VirtualMachine *v,rabbit::ObjectPtr &dest
 
 	_state=eRunning;
 	if (v->_debughook)
-		v->callDebugHook(_SC('c'));
+		v->callDebugHook('c');
 
 	return true;
 }
diff --git a/rabbit/Lexer.cpp b/rabbit/Lexer.cpp
index 85832fa..a4b3b9f 100644
--- a/rabbit/Lexer.cpp
+++ b/rabbit/Lexer.cpp
@@ -17,8 +17,8 @@
 #define NEXT() {next();_currentcolumn++;}
 #define INIT_TEMP_STRING() { _longstr.resize(0);}
 #define APPEND_CHAR(c) { _longstr.pushBack(c);}
-#define TERMINATE_BUFFER() {_longstr.pushBack(_SC('\0'));}
-#define ADD_KEYWORD(key,id) _keywords->newSlot( rabbit::String::create(ss, _SC(#key)) ,int64_t(id))
+#define TERMINATE_BUFFER() {_longstr.pushBack('\0');}
+#define ADD_KEYWORD(key,id) _keywords->newSlot( rabbit::String::create(ss, #key) ,int64_t(id))
 
 rabbit::Lexer::Lexer(){}
 rabbit::Lexer::~Lexer()
@@ -89,7 +89,7 @@ void rabbit::Lexer::error(const char *err)
 void rabbit::Lexer::next()
 {
 	int64_t t = _readf(_up);
-	if(t > UINT8_MAX) error(_SC("Invalid character"));
+	if(t > UINT8_MAX) error("Invalid character");
 	if(t != 0) {
 		_currdata = (Lexchar)t;
 		return;
@@ -115,16 +115,16 @@ void rabbit::Lexer::lexBlockComment()
 	bool done = false;
 	while(!done) {
 		switch(CUR_CHAR) {
-			case _SC('*'): { NEXT(); if(CUR_CHAR == _SC('/')) { done = true; NEXT(); }}; continue;
-			case _SC('\n'): _currentline++; NEXT(); continue;
-			case RABBIT_EOB: error(_SC("missing \"*/\" in comment"));
+			case '*': { NEXT(); if(CUR_CHAR == '/') { done = true; NEXT(); }}; continue;
+			case '\n': _currentline++; NEXT(); continue;
+			case RABBIT_EOB: error("missing \"*/\" in comment");
 			default: NEXT();
 		}
 	}
 }
 void rabbit::Lexer::lexLineComment()
 {
-	do { NEXT(); } while (CUR_CHAR != _SC('\n') && (!IS_EOB()));
+	do { NEXT(); } while (CUR_CHAR != '\n' && (!IS_EOB()));
 }
 
 int64_t rabbit::Lexer::Lex()
@@ -132,131 +132,131 @@ int64_t rabbit::Lexer::Lex()
 	_lasttokenline = _currentline;
 	while(CUR_CHAR != RABBIT_EOB) {
 		switch(CUR_CHAR){
-		case _SC('\t'): case _SC('\r'): case _SC(' '): NEXT(); continue;
-		case _SC('\n'):
+		case '\t': case '\r': case ' ': NEXT(); continue;
+		case '\n':
 			_currentline++;
 			_prevtoken=_curtoken;
-			_curtoken=_SC('\n');
+			_curtoken='\n';
 			NEXT();
 			_currentcolumn=1;
 			continue;
-		case _SC('#'): lexLineComment(); continue;
-		case _SC('/'):
+		case '#': lexLineComment(); continue;
+		case '/':
 			NEXT();
 			switch(CUR_CHAR){
-			case _SC('*'):
+			case '*':
 				NEXT();
 				lexBlockComment();
 				continue;
-			case _SC('/'):
+			case '/':
 				lexLineComment();
 				continue;
-			case _SC('='):
+			case '=':
 				NEXT();
 				RETURN_TOKEN(TK_DIVEQ);
 				continue;
-			case _SC('>'):
+			case '>':
 				NEXT();
 				RETURN_TOKEN(TK_ATTR_CLOSE);
 				continue;
 			default:
 				RETURN_TOKEN('/');
 			}
-		case _SC('='):
+		case '=':
 			NEXT();
-			if (CUR_CHAR != _SC('=')){ RETURN_TOKEN('=') }
+			if (CUR_CHAR != '='){ RETURN_TOKEN('=') }
 			else { NEXT(); RETURN_TOKEN(TK_EQ); }
-		case _SC('<'):
+		case '<':
 			NEXT();
 			switch(CUR_CHAR) {
-			case _SC('='):
+			case '=':
 				NEXT();
-				if(CUR_CHAR == _SC('>')) {
+				if(CUR_CHAR == '>') {
 					NEXT();
 					RETURN_TOKEN(TK_3WAYSCMP);
 				}
 				RETURN_TOKEN(TK_LE)
 				break;
-			case _SC('-'): NEXT(); RETURN_TOKEN(TK_NEWSLOT); break;
-			case _SC('<'): NEXT(); RETURN_TOKEN(TK_SHIFTL); break;
-			case _SC('/'): NEXT(); RETURN_TOKEN(TK_ATTR_OPEN); break;
+			case '-': NEXT(); RETURN_TOKEN(TK_NEWSLOT); break;
+			case '<': NEXT(); RETURN_TOKEN(TK_SHIFTL); break;
+			case '/': NEXT(); RETURN_TOKEN(TK_ATTR_OPEN); break;
 			}
 			RETURN_TOKEN('<');
-		case _SC('>'):
+		case '>':
 			NEXT();
-			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_GE);}
-			else if(CUR_CHAR == _SC('>')){
+			if (CUR_CHAR == '='){ NEXT(); RETURN_TOKEN(TK_GE);}
+			else if(CUR_CHAR == '>'){
 				NEXT();
-				if(CUR_CHAR == _SC('>')){
+				if(CUR_CHAR == '>'){
 					NEXT();
 					RETURN_TOKEN(TK_USHIFTR);
 				}
 				RETURN_TOKEN(TK_SHIFTR);
 			}
 			else { RETURN_TOKEN('>') }
-		case _SC('!'):
+		case '!':
 			NEXT();
-			if (CUR_CHAR != _SC('=')){ RETURN_TOKEN('!')}
+			if (CUR_CHAR != '='){ RETURN_TOKEN('!')}
 			else { NEXT(); RETURN_TOKEN(TK_NE); }
-		case _SC('@'): {
+		case '@': {
 			int64_t stype;
 			NEXT();
-			if(CUR_CHAR != _SC('"')) {
+			if(CUR_CHAR != '"') {
 				RETURN_TOKEN('@');
 			}
 			if((stype=readString('"',true))!=-1) {
 				RETURN_TOKEN(stype);
 			}
-			error(_SC("error parsing the string"));
+			error("error parsing the string");
 					   }
-		case _SC('"'):
-		case _SC('\''): {
+		case '"':
+		case '\'': {
 			int64_t stype;
 			if((stype=readString(CUR_CHAR,false))!=-1){
 				RETURN_TOKEN(stype);
 			}
-			error(_SC("error parsing the string"));
+			error("error parsing the string");
 			}
-		case _SC('{'): case _SC('}'): case _SC('('): case _SC(')'): case _SC('['): case _SC(']'):
-		case _SC(';'): case _SC(','): case _SC('?'): case _SC('^'): case _SC('~'):
+		case '{': case '}': case '(': case ')': case '[': case ']':
+		case ';': case ',': case '?': case '^': case '~':
 			{int64_t ret = CUR_CHAR;
 			NEXT(); RETURN_TOKEN(ret); }
-		case _SC('.'):
+		case '.':
 			NEXT();
-			if (CUR_CHAR != _SC('.')){ RETURN_TOKEN('.') }
+			if (CUR_CHAR != '.'){ RETURN_TOKEN('.') }
 			NEXT();
-			if (CUR_CHAR != _SC('.')){ error(_SC("invalid token '..'")); }
+			if (CUR_CHAR != '.'){ error("invalid token '..'"); }
 			NEXT();
 			RETURN_TOKEN(TK_VARPARAMS);
-		case _SC('&'):
+		case '&':
 			NEXT();
-			if (CUR_CHAR != _SC('&')){ RETURN_TOKEN('&') }
+			if (CUR_CHAR != '&'){ RETURN_TOKEN('&') }
 			else { NEXT(); RETURN_TOKEN(TK_AND); }
-		case _SC('|'):
+		case '|':
 			NEXT();
-			if (CUR_CHAR != _SC('|')){ RETURN_TOKEN('|') }
+			if (CUR_CHAR != '|'){ RETURN_TOKEN('|') }
 			else { NEXT(); RETURN_TOKEN(TK_OR); }
-		case _SC(':'):
+		case ':':
 			NEXT();
-			if (CUR_CHAR != _SC(':')){ RETURN_TOKEN(':') }
+			if (CUR_CHAR != ':'){ RETURN_TOKEN(':') }
 			else { NEXT(); RETURN_TOKEN(TK_DOUBLE_COLON); }
-		case _SC('*'):
+		case '*':
 			NEXT();
-			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_MULEQ);}
+			if (CUR_CHAR == '='){ NEXT(); RETURN_TOKEN(TK_MULEQ);}
 			else RETURN_TOKEN('*');
-		case _SC('%'):
+		case '%':
 			NEXT();
-			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_MODEQ);}
+			if (CUR_CHAR == '='){ NEXT(); RETURN_TOKEN(TK_MODEQ);}
 			else RETURN_TOKEN('%');
-		case _SC('-'):
+		case '-':
 			NEXT();
-			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_MINUSEQ);}
-			else if  (CUR_CHAR == _SC('-')){ NEXT(); RETURN_TOKEN(TK_MINUSMINUS);}
+			if (CUR_CHAR == '='){ NEXT(); RETURN_TOKEN(TK_MINUSEQ);}
+			else if  (CUR_CHAR == '-'){ NEXT(); RETURN_TOKEN(TK_MINUSMINUS);}
 			else RETURN_TOKEN('-');
-		case _SC('+'):
+		case '+':
 			NEXT();
-			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_PLUSEQ);}
-			else if (CUR_CHAR == _SC('+')){ NEXT(); RETURN_TOKEN(TK_PLUSPLUS);}
+			if (CUR_CHAR == '='){ NEXT(); RETURN_TOKEN(TK_PLUSEQ);}
+			else if (CUR_CHAR == '+'){ NEXT(); RETURN_TOKEN(TK_PLUSPLUS);}
 			else RETURN_TOKEN('+');
 		case RABBIT_EOB:
 			return 0;
@@ -265,13 +265,13 @@ int64_t rabbit::Lexer::Lex()
 					int64_t ret = readNumber();
 					RETURN_TOKEN(ret);
 				}
-				else if (isalpha(CUR_CHAR) || CUR_CHAR == _SC('_')) {
+				else if (isalpha(CUR_CHAR) || CUR_CHAR == '_') {
 					int64_t t = readId();
 					RETURN_TOKEN(t);
 				}
 				else {
 					int64_t c = CUR_CHAR;
-					if (iscntrl((int)c)) error(_SC("unexpected character(control)"));
+					if (iscntrl((int)c)) error("unexpected character(control)");
 					NEXT();
 					RETURN_TOKEN(c);
 				}
@@ -321,7 +321,7 @@ int64_t rabbit::Lexer::addUTF8(uint64_t ch)
 int64_t rabbit::Lexer::processStringHexEscape(char *dest, int64_t maxdigits)
 {
 	NEXT();
-	if (!isxdigit(CUR_CHAR)) error(_SC("hexadecimal number expected"));
+	if (!isxdigit(CUR_CHAR)) error("hexadecimal number expected");
 	int64_t n = 0;
 	while (isxdigit(CUR_CHAR) && n < maxdigits) {
 		dest[n] = CUR_CHAR;
@@ -342,21 +342,21 @@ int64_t rabbit::Lexer::readString(int64_t ndelim,bool verbatim)
 			int64_t x = CUR_CHAR;
 			switch (x) {
 			case RABBIT_EOB:
-				error(_SC("unfinished string"));
+				error("unfinished string");
 				return -1;
-			case _SC('\n'):
-				if(!verbatim) error(_SC("newline in a constant"));
+			case '\n':
+				if(!verbatim) error("newline in a constant");
 				APPEND_CHAR(CUR_CHAR); NEXT();
 				_currentline++;
 				break;
-			case _SC('\\'):
+			case '\\':
 				if(verbatim) {
 					APPEND_CHAR('\\'); NEXT();
 				}
 				else {
 					NEXT();
 					switch(CUR_CHAR) {
-					case _SC('x'):  {
+					case 'x':  {
 						const int64_t maxdigits = sizeof(char) * 2;
 						char temp[maxdigits + 1];
 						processStringHexEscape(temp, maxdigits);
@@ -364,8 +364,8 @@ int64_t rabbit::Lexer::readString(int64_t ndelim,bool verbatim)
 						APPEND_CHAR((char)strtoul(temp, &stemp, 16));
 					}
 					break;
-					case _SC('U'):
-					case _SC('u'):  {
+					case 'U':
+					case 'u':  {
 						const int64_t maxdigits = CUR_CHAR == 'u' ? 4 : 8;
 						char temp[8 + 1];
 						processStringHexEscape(temp, maxdigits);
@@ -373,19 +373,19 @@ int64_t rabbit::Lexer::readString(int64_t ndelim,bool verbatim)
 						addUTF8(strtoul(temp, &stemp, 16));
 					}
 					break;
-					case _SC('t'): APPEND_CHAR(_SC('\t')); NEXT(); break;
-					case _SC('a'): APPEND_CHAR(_SC('\a')); NEXT(); break;
-					case _SC('b'): APPEND_CHAR(_SC('\b')); NEXT(); break;
-					case _SC('n'): APPEND_CHAR(_SC('\n')); NEXT(); break;
-					case _SC('r'): APPEND_CHAR(_SC('\r')); NEXT(); break;
-					case _SC('v'): APPEND_CHAR(_SC('\v')); NEXT(); break;
-					case _SC('f'): APPEND_CHAR(_SC('\f')); NEXT(); break;
-					case _SC('0'): APPEND_CHAR(_SC('\0')); NEXT(); break;
-					case _SC('\\'): APPEND_CHAR(_SC('\\')); NEXT(); break;
-					case _SC('"'): APPEND_CHAR(_SC('"')); NEXT(); break;
-					case _SC('\''): APPEND_CHAR(_SC('\'')); NEXT(); break;
+					case 't': APPEND_CHAR('\t'); NEXT(); break;
+					case 'a': APPEND_CHAR('\a'); NEXT(); break;
+					case 'b': APPEND_CHAR('\b'); NEXT(); break;
+					case 'n': APPEND_CHAR('\n'); NEXT(); break;
+					case 'r': APPEND_CHAR('\r'); NEXT(); break;
+					case 'v': APPEND_CHAR('\v'); NEXT(); break;
+					case 'f': APPEND_CHAR('\f'); NEXT(); break;
+					case '0': APPEND_CHAR('\0'); NEXT(); break;
+					case '\\': APPEND_CHAR('\\'); NEXT(); break;
+					case '"': APPEND_CHAR('"'); NEXT(); break;
+					case '\'': APPEND_CHAR('\''); NEXT(); break;
 					default:
-						error(_SC("unrecognised escaper char"));
+						error("unrecognised escaper char");
 					break;
 					}
 				}
@@ -406,9 +406,9 @@ int64_t rabbit::Lexer::readString(int64_t ndelim,bool verbatim)
 	}
 	TERMINATE_BUFFER();
 	int64_t len = _longstr.size()-1;
-	if(ndelim == _SC('\'')) {
-		if(len == 0) error(_SC("empty constant"));
-		if(len > 1) error(_SC("constant too long"));
+	if(ndelim == '\'') {
+		if(len == 0) error("empty constant");
+		if(len > 1) error("constant too long");
 		_nvalue = _longstr[0];
 		return TK_INTEGER;
 	}
@@ -436,7 +436,7 @@ void LexInteger(const char *s,uint64_t *res)
 	}
 }
 
-int64_t scisodigit(int64_t c) { return c >= _SC('0') && c <= _SC('7'); }
+int64_t scisodigit(int64_t c) { return c >= '0' && c <= '7'; }
 
 void LexOctal(const char *s,uint64_t *res)
 {
@@ -463,14 +463,14 @@ int64_t rabbit::Lexer::readNumber()
 	char *sTemp;
 	INIT_TEMP_STRING();
 	NEXT();
-	if(firstchar == _SC('0') && (toupper(CUR_CHAR) == _SC('X') || scisodigit(CUR_CHAR)) ) {
+	if(firstchar == '0' && (toupper(CUR_CHAR) == 'X' || scisodigit(CUR_CHAR)) ) {
 		if(scisodigit(CUR_CHAR)) {
 			type = TOCTAL;
 			while(scisodigit(CUR_CHAR)) {
 				APPEND_CHAR(CUR_CHAR);
 				NEXT();
 			}
-			if(isdigit(CUR_CHAR)) error(_SC("invalid octal number"));
+			if(isdigit(CUR_CHAR)) error("invalid octal number");
 		}
 		else {
 			NEXT();
@@ -479,15 +479,15 @@ int64_t rabbit::Lexer::readNumber()
 				APPEND_CHAR(CUR_CHAR);
 				NEXT();
 			}
-			if(_longstr.size() > MAX_HEX_DIGITS) error(_SC("too many digits for an Hex number"));
+			if(_longstr.size() > MAX_HEX_DIGITS) error("too many digits for an Hex number");
 		}
 	}
 	else {
 		APPEND_CHAR((int)firstchar);
-		while (CUR_CHAR == _SC('.') || isdigit(CUR_CHAR) || isexponent(CUR_CHAR)) {
-			if(CUR_CHAR == _SC('.') || isexponent(CUR_CHAR)) type = TFLOAT;
+		while (CUR_CHAR == '.' || isdigit(CUR_CHAR) || isexponent(CUR_CHAR)) {
+			if(CUR_CHAR == '.' || isexponent(CUR_CHAR)) type = TFLOAT;
 			if(isexponent(CUR_CHAR)) {
-				if(type != TFLOAT) error(_SC("invalid numeric format"));
+				if(type != TFLOAT) error("invalid numeric format");
 				type = TSCIENTIFIC;
 				APPEND_CHAR(CUR_CHAR);
 				NEXT();
@@ -495,7 +495,7 @@ int64_t rabbit::Lexer::readNumber()
 					APPEND_CHAR(CUR_CHAR);
 					NEXT();
 				}
-				if(!isdigit(CUR_CHAR)) error(_SC("exponent expected"));
+				if(!isdigit(CUR_CHAR)) error("exponent expected");
 			}
 
 			APPEND_CHAR(CUR_CHAR);
@@ -528,7 +528,7 @@ int64_t rabbit::Lexer::readId()
 	do {
 		APPEND_CHAR(CUR_CHAR);
 		NEXT();
-	} while(isalnum(CUR_CHAR) || CUR_CHAR == _SC('_'));
+	} while(isalnum(CUR_CHAR) || CUR_CHAR == '_');
 	TERMINATE_BUFFER();
 	res = getIDType(&_longstr[0],_longstr.size() - 1);
 	if(res == TK_IDENTIFIER || res == TK_CONSTRUCTOR) {
diff --git a/rabbit/MetaMethod.hpp b/rabbit/MetaMethod.hpp
index 736a051..39a89d1 100644
--- a/rabbit/MetaMethod.hpp
+++ b/rabbit/MetaMethod.hpp
@@ -36,21 +36,21 @@ namespace rabbit {
 	};
 }
 
-#define MM_ADD	  _SC("_add")
-#define MM_SUB	  _SC("_sub")
-#define MM_MUL	  _SC("_mul")
-#define MM_DIV	  _SC("_div")
-#define MM_UNM	  _SC("_unm")
-#define MM_MODULO   _SC("_modulo")
-#define MM_SET	  _SC("_set")
-#define MM_GET	  _SC("_get")
-#define MM_TYPEOF   _SC("_typeof")
-#define MM_NEXTI	_SC("_nexti")
-#define MM_CMP	  _SC("_cmp")
-#define MM_CALL	 _SC("_call")
-#define MM_CLONED   _SC("_cloned")
-#define MM_NEWSLOT  _SC("_newslot")
-#define MM_DELSLOT  _SC("_delslot")
-#define MM_TOSTRING _SC("_tostring")
-#define MM_NEWMEMBER _SC("_newmember")
-#define MM_INHERITED _SC("_inherited")
+#define MM_ADD	  "_add"
+#define MM_SUB	  "_sub"
+#define MM_MUL	  "_mul"
+#define MM_DIV	  "_div"
+#define MM_UNM	  "_unm"
+#define MM_MODULO   "_modulo"
+#define MM_SET	  "_set"
+#define MM_GET	  "_get"
+#define MM_TYPEOF   "_typeof"
+#define MM_NEXTI	"_nexti"
+#define MM_CMP	  "_cmp"
+#define MM_CALL	 "_call"
+#define MM_CLONED   "_cloned"
+#define MM_NEWSLOT  "_newslot"
+#define MM_DELSLOT  "_delslot"
+#define MM_TOSTRING "_tostring"
+#define MM_NEWMEMBER "_newmember"
+#define MM_INHERITED "_inherited"
diff --git a/rabbit/ObjectPtr.cpp b/rabbit/ObjectPtr.cpp
index 23639cd..951d66f 100644
--- a/rabbit/ObjectPtr.cpp
+++ b/rabbit/ObjectPtr.cpp
@@ -157,39 +157,39 @@ const char* rabbit::IdType2Name(rabbit::ObjectType type)
 	switch(_RAW_TYPE(type))
 	{
 		case _RT_NULL:
-			return _SC("null");
+			return "null";
 		case _RT_INTEGER:
-			return _SC("integer");
+			return "integer";
 		case _RT_FLOAT:
-			return _SC("float");
+			return "float";
 		case _RT_BOOL:
-			return _SC("bool");
+			return "bool";
 		case _RT_STRING:
-			return _SC("string");
+			return "string";
 		case _RT_TABLE:
-			return _SC("table");
+			return "table";
 		case _RT_ARRAY:
-			return _SC("array");
+			return "array";
 		case _RT_GENERATOR:
-			return _SC("generator");
+			return "generator";
 		case _RT_CLOSURE:
 		case _RT_NATIVECLOSURE:
-			return _SC("function");
+			return "function";
 		case _RT_USERDATA:
 		case _RT_USERPOINTER:
-			return _SC("userdata");
+			return "userdata";
 		case _RT_THREAD:
-			return _SC("thread");
+			return "thread";
 		case _RT_FUNCPROTO:
-			return _SC("function");
+			return "function";
 		case _RT_CLASS:
-			return _SC("class");
+			return "class";
 		case _RT_INSTANCE:
-			return _SC("instance");
+			return "instance";
 		case _RT_WEAKREF:
-			return _SC("weakref");
+			return "weakref";
 		case _RT_OUTER:
-			return _SC("outer");
+			return "outer";
 		default:
 			return NULL;
 	}
diff --git a/rabbit/SharedState.cpp b/rabbit/SharedState.cpp
index b83820b..173886c 100644
--- a/rabbit/SharedState.cpp
+++ b/rabbit/SharedState.cpp
@@ -105,21 +105,21 @@ void rabbit::SharedState::init()
 	_metamethodsmap = rabbit::Table::create(this,rabbit::MT_LAST-1);
 	//adding type strings to avoid memory trashing
 	//types names
-	newsysstring(_SC("null"));
-	newsysstring(_SC("table"));
-	newsysstring(_SC("array"));
-	newsysstring(_SC("closure"));
-	newsysstring(_SC("string"));
-	newsysstring(_SC("userdata"));
-	newsysstring(_SC("integer"));
-	newsysstring(_SC("float"));
-	newsysstring(_SC("userpointer"));
-	newsysstring(_SC("function"));
-	newsysstring(_SC("generator"));
-	newsysstring(_SC("thread"));
-	newsysstring(_SC("class"));
-	newsysstring(_SC("instance"));
-	newsysstring(_SC("bool"));
+	newsysstring("null");
+	newsysstring("table");
+	newsysstring("array");
+	newsysstring("closure");
+	newsysstring("string");
+	newsysstring("userdata");
+	newsysstring("integer");
+	newsysstring("float");
+	newsysstring("userpointer");
+	newsysstring("function");
+	newsysstring("generator");
+	newsysstring("thread");
+	newsysstring("class");
+	newsysstring("instance");
+	newsysstring("bool");
 	//meta methods
 	newmetamethod(MM_ADD);
 	newmetamethod(MM_SUB);
@@ -140,7 +140,7 @@ void rabbit::SharedState::init()
 	newmetamethod(MM_NEWMEMBER);
 	newmetamethod(MM_INHERITED);
 
-	_constructoridx = rabbit::String::create(this,_SC("constructor"));
+	_constructoridx = rabbit::String::create(this,"constructor");
 	_registry = rabbit::Table::create(this,0);
 	_consts = rabbit::Table::create(this,0);
 	_table_default_delegate = createDefaultDelegate(this,_table_default_delegate_funcz);
diff --git a/rabbit/StringTable.cpp b/rabbit/StringTable.cpp
index 6dc9daa..8aef7b3 100644
--- a/rabbit/StringTable.cpp
+++ b/rabbit/StringTable.cpp
@@ -50,7 +50,7 @@ rabbit::String *rabbit::StringTable::add(const char *news,int64_t len)
 	new ((char*)t) rabbit::String;
 	t->_sharedstate = _sharedstate;
 	memcpy(t->_val,news,sq_rsl(len));
-	t->_val[len] = _SC('\0');
+	t->_val[len] = '\0';
 	t->_len = len;
 	t->_hash = newhash;
 	t->_next = _strings[h];
diff --git a/rabbit/VirtualMachine.cpp b/rabbit/VirtualMachine.cpp
index 1f1bef9..d47229a 100644
--- a/rabbit/VirtualMachine.cpp
+++ b/rabbit/VirtualMachine.cpp
@@ -47,10 +47,10 @@ bool rabbit::VirtualMachine::BW_OP(uint64_t op,rabbit::ObjectPtr &trg,const rabb
 			case BW_SHIFTL: res = i1 << i2; break;
 			case BW_SHIFTR: res = i1 >> i2; break;
 			case BW_USHIFTR:res = (int64_t)(*((uint64_t*)&i1) >> i2); break;
-			default: { raise_error(_SC("internal vm error bitwise op failed")); return false; }
+			default: { raise_error("internal vm error bitwise op failed"); return false; }
 		}
 	}
-	else { raise_error(_SC("bitwise op between '%s' and '%s'"),getTypeName(o1),getTypeName(o2)); return false;}
+	else { raise_error("bitwise op between '%s' and '%s'",getTypeName(o1),getTypeName(o2)); return false;}
 	trg = res;
 	return true;
 }
@@ -90,12 +90,12 @@ bool rabbit::VirtualMachine::ARITH_OP(uint64_t op,rabbit::ObjectPtr &trg,const r
 			switch(op) {
 			case '+': res = i1 + i2; break;
 			case '-': res = i1 - i2; break;
-			case '/': if (i2 == 0) { raise_error(_SC("division by zero")); return false; }
-					else if (i2 == -1 && i1 == INT64_MIN) { raise_error(_SC("integer overflow")); return false; }
+			case '/': if (i2 == 0) { raise_error("division by zero"); return false; }
+					else if (i2 == -1 && i1 == INT64_MIN) { raise_error("integer overflow"); return false; }
 					res = i1 / i2;
 					break;
 			case '*': res = i1 * i2; break;
-			case '%': if (i2 == 0) { raise_error(_SC("modulo by zero")); return false; }
+			case '%': if (i2 == 0) { raise_error("modulo by zero"); return false; }
 					else if (i2 == -1 && i1 == INT64_MAX) { res = 0; break; }
 					res = i1 % i2;
 					break;
@@ -173,11 +173,11 @@ bool rabbit::VirtualMachine::arithMetaMethod(int64_t op,const rabbit::ObjectPtr
 {
 	rabbit::MetaMethod mm;
 	switch(op){
-		case _SC('+'): mm=MT_ADD; break;
-		case _SC('-'): mm=MT_SUB; break;
-		case _SC('/'): mm=MT_DIV; break;
-		case _SC('*'): mm=MT_MUL; break;
-		case _SC('%'): mm=MT_MODULO; break;
+		case '+': mm=MT_ADD; break;
+		case '-': mm=MT_SUB; break;
+		case '/': mm=MT_DIV; break;
+		case '*': mm=MT_MUL; break;
+		case '%': mm=MT_MODULO; break;
 		default: mm = MT_ADD; assert(0); break; //shutup compiler
 	}
 	if(is_delegable(o1) && _delegable(o1)->_delegate) {
@@ -189,7 +189,7 @@ bool rabbit::VirtualMachine::arithMetaMethod(int64_t op,const rabbit::ObjectPtr
 			return callMetaMethod(closure,mm,2,dest);
 		}
 	}
-	raise_error(_SC("arith op %c on between '%s' and '%s'"),op,getTypeName(o1),getTypeName(o2));
+	raise_error("arith op %c on between '%s' and '%s'",op,getTypeName(o1),getTypeName(o2));
 	return false;
 }
 
@@ -218,7 +218,7 @@ bool rabbit::VirtualMachine::NEG_OP(rabbit::ObjectPtr &trg,const rabbit::ObjectP
 		}
 	default:break; //shutup compiler
 	}
-	raise_error(_SC("attempt to negate a %s"), getTypeName(o));
+	raise_error("attempt to negate a %s", getTypeName(o));
 	return false;
 }
 
@@ -245,7 +245,7 @@ bool rabbit::VirtualMachine::objCmp(const rabbit::ObjectPtr &o1,const rabbit::Ob
 					push(o1);push(o2);
 					if(callMetaMethod(closure,MT_CMP,2,res)) {
 						if(sq_type(res) != rabbit::OT_INTEGER) {
-							raise_error(_SC("_cmp must return an integer"));
+							raise_error("_cmp must return an integer");
 							return false;
 						}
 						_RET_SUCCEED(_integer(res))
@@ -307,13 +307,13 @@ bool rabbit::VirtualMachine::toString(const rabbit::ObjectPtr &o,rabbit::ObjectP
 		res = o;
 		return true;
 	case rabbit::OT_FLOAT:
-		snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)),sq_rsl(NUMBER_UINT8_MAX),_SC("%g"),_float(o));
+		snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)),sq_rsl(NUMBER_UINT8_MAX),"%g",_float(o));
 		break;
 	case rabbit::OT_INTEGER:
 		snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)),sq_rsl(NUMBER_UINT8_MAX),_PRINT_INT_FMT,_integer(o));
 		break;
 	case rabbit::OT_BOOL:
-		snprintf(_sp(sq_rsl(6)),sq_rsl(6),_integer(o)?_SC("true"):_SC("false"));
+		snprintf(_sp(sq_rsl(6)),sq_rsl(6),_integer(o)?"true":"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:
-		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));
+		snprintf(_sp(sq_rsl((sizeof(void*)*2)+NUMBER_UINT8_MAX)),sq_rsl((sizeof(void*)*2)+NUMBER_UINT8_MAX),"(%s : 0x%p)",getTypeName(o),(void*)_rawval(o));
 	}
 	res = rabbit::String::create(_get_shared_state(this),_spval);
 	return true;
@@ -402,7 +402,7 @@ bool rabbit::VirtualMachine::startcall(rabbit::Closure *closure,int64_t target,i
 	{
 		paramssize--;
 		if (nargs < paramssize) {
-			raise_error(_SC("wrong number of parameters"));
+			raise_error("wrong number of parameters");
 			return false;
 		}
 
@@ -428,7 +428,7 @@ bool rabbit::VirtualMachine::startcall(rabbit::Closure *closure,int64_t target,i
 			}
 		}
 		else {
-			raise_error(_SC("wrong number of parameters"));
+			raise_error("wrong number of parameters");
 			return false;
 		}
 	}
@@ -445,7 +445,7 @@ bool rabbit::VirtualMachine::startcall(rabbit::Closure *closure,int64_t target,i
 	ci->_target   = (int32_t)target;
 
 	if (_debughook) {
-		callDebugHook(_SC('c'));
+		callDebugHook('c');
 	}
 
 	if (closure->_function->_bgenerator) {
@@ -469,7 +469,7 @@ bool rabbit::VirtualMachine::Return(int64_t _arg0, int64_t _arg1, rabbit::Object
 
 	if (_debughook) {
 		for(int64_t i=0; i<ci->_ncalls; i++) {
-			callDebugHook(_SC('r'));
+			callDebugHook('r');
 		}
 	}
 
@@ -526,9 +526,9 @@ bool rabbit::VirtualMachine::derefInc(int64_t op,rabbit::ObjectPtr &target, rabb
 rabbit::Result rabbit::VirtualMachine::Suspend()
 {
 	if (_suspended)
-		return sq_throwerror(this, _SC("cannot suspend an already suspended vm"));
+		return sq_throwerror(this, "cannot suspend an already suspended vm");
 	if (_nnativecalls!=2)
-		return sq_throwerror(this, _SC("cannot suspend through native calls/metamethods"));
+		return sq_throwerror(this, "cannot suspend through native calls/metamethods");
 	return SQ_SUSPEND_FLAG;
 }
 
@@ -563,7 +563,7 @@ bool rabbit::VirtualMachine::FOREACH_OP(rabbit::ObjectPtr &o1,rabbit::ObjectPtr
 					o4 = o2 = itr;
 					if(sq_type(itr) == rabbit::OT_NULL) _FINISH(exitpos);
 					if(!get(o1, itr, o3, 0, DONT_FALL_BACK)) {
-						raise_error(_SC("_nexti returned an invalid idx")); // cloud be changed
+						raise_error("_nexti returned an invalid idx"); // cloud be changed
 						return false;
 					}
 					_FINISH(1);
@@ -572,7 +572,7 @@ bool rabbit::VirtualMachine::FOREACH_OP(rabbit::ObjectPtr &o1,rabbit::ObjectPtr
 					return false;
 				}
 			}
-			raise_error(_SC("_nexti failed"));
+			raise_error("_nexti failed");
 			return false;
 		}
 		break;
@@ -589,7 +589,7 @@ bool rabbit::VirtualMachine::FOREACH_OP(rabbit::ObjectPtr &o1,rabbit::ObjectPtr
 			_FINISH(0);
 		}
 	default:
-		raise_error(_SC("cannot iterate %s"), getTypeName(o1));
+		raise_error("cannot iterate %s", getTypeName(o1));
 	}
 	return false; //cannot be hit(just to avoid warnings)
 }
@@ -635,7 +635,7 @@ bool rabbit::VirtualMachine::CLASS_OP(rabbit::ObjectPtr &target,int64_t baseclas
 	rabbit::Class *base = NULL;
 	rabbit::ObjectPtr attrs;
 	if(baseclass != -1) {
-		if(sq_type(_stack[_stackbase+baseclass]) != rabbit::OT_CLASS) { raise_error(_SC("trying to inherit from a %s"),getTypeName(_stack[_stackbase+baseclass])); return false; }
+		if(sq_type(_stack[_stackbase+baseclass]) != rabbit::OT_CLASS) { raise_error("trying to inherit from a %s",getTypeName(_stack[_stackbase+baseclass])); return false; }
 		base = _class(_stack[_stackbase + baseclass]);
 	}
 	if(attributes != MAX_FUNC_STACKSIZE) {
@@ -689,7 +689,7 @@ bool rabbit::VirtualMachine::IsFalse(rabbit::ObjectPtr &o)
 extern rabbit::InstructionDesc g_InstrDesc[];
 bool rabbit::VirtualMachine::execute(rabbit::ObjectPtr &closure, int64_t nargs, int64_t stackbase,rabbit::ObjectPtr &outres, rabbit::Bool raiseerror,ExecutionType et)
 {
-	if ((_nnativecalls + 1) > MAX_NATIVE_CALLS) { raise_error(_SC("Native stack overflow")); return false; }
+	if ((_nnativecalls + 1) > MAX_NATIVE_CALLS) { raise_error("Native stack overflow"); return false; }
 	_nnativecalls++;
 	AutoDec ad(&_nnativecalls);
 	int64_t traps = 0;
@@ -730,7 +730,7 @@ exception_restore:
 			//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;
+			case _OP_LINE: if (_debughook) callDebugHook('l',arg1); continue;
 			case _OP_LOAD: TARGET = ci->_literals[arg1]; continue;
 			case _OP_LOADINT:
 #ifndef _SQ64
@@ -815,11 +815,11 @@ exception_restore:
 							break;
 						}
 
-						//raise_error(_SC("attempt to call '%s'"), getTypeName(clo));
+						//raise_error("attempt to call '%s'", getTypeName(clo));
 						//SQ_THROW();
 					  }
 					default:
-						raise_error(_SC("attempt to call '%s'"), getTypeName(clo));
+						raise_error("attempt to call '%s'", getTypeName(clo));
 						SQ_THROW();
 					}
 				}
@@ -866,7 +866,7 @@ exception_restore:
 			case _OP_ADD: _ARITH_(+,TARGET,STK(arg2),STK(arg1)); continue;
 			case _OP_SUB: _ARITH_(-,TARGET,STK(arg2),STK(arg1)); continue;
 			case _OP_MUL: _ARITH_(*,TARGET,STK(arg2),STK(arg1)); continue;
-			case _OP_DIV: _ARITH_NOZERO(/,TARGET,STK(arg2),STK(arg1),_SC("division by zero")); continue;
+			case _OP_DIV: _ARITH_NOZERO(/,TARGET,STK(arg2),STK(arg1),"division by zero"); continue;
 			case _OP_MOD: ARITH_OP('%',TARGET,STK(arg2),STK(arg1)); continue;
 			case _OP_BITW:  _GUARD(BW_OP( arg3,TARGET,STK(arg2),STK(arg1))); continue;
 			case _OP_RETURN:
@@ -983,7 +983,7 @@ exception_restore:
 			case _OP_EXISTS: TARGET = get(STK(arg1), STK(arg2), temp_reg, GET_FLAG_DO_NOT_RAISE_ERROR | GET_FLAG_RAW, DONT_FALL_BACK) ? true : false; continue;
 			case _OP_INSTANCEOF:
 				if(sq_type(STK(arg1)) != rabbit::OT_CLASS)
-				{raise_error(_SC("cannot apply instanceof between a %s and a %s"),getTypeName(STK(arg1)),getTypeName(STK(arg2))); SQ_THROW();}
+				{raise_error("cannot apply instanceof between a %s and a %s",getTypeName(STK(arg1)),getTypeName(STK(arg2))); SQ_THROW();}
 				TARGET = (sq_type(STK(arg2)) == rabbit::OT_INSTANCE) ? (_instance(STK(arg2))->instanceOf(_class(STK(arg1)))?true:false) : false;
 				continue;
 			case _OP_AND:
@@ -1006,7 +1006,7 @@ exception_restore:
 					TARGET = int64_t(~t);
 					continue;
 				}
-				raise_error(_SC("attempt to perform a bitwise op on a %s"), getTypeName(STK(arg1)));
+				raise_error("attempt to perform a bitwise op on a %s", getTypeName(STK(arg1)));
 				SQ_THROW();
 			case _OP_CLOSURE: {
 				rabbit::Closure *c = ci->_closure._unVal.pClosure;
@@ -1021,7 +1021,7 @@ exception_restore:
 					traps -= ci->_etraps;
 					if(sarg1 != MAX_FUNC_STACKSIZE) _Swap(STK(arg1),temp_reg);//STK(arg1) = temp_reg;
 				}
-				else { raise_error(_SC("trying to yield a '%s',only genenerator can be yielded"), getTypeName(ci->_generator)); SQ_THROW();}
+				else { raise_error("trying to yield a '%s',only genenerator can be yielded", getTypeName(ci->_generator)); SQ_THROW();}
 				if(Return(arg0, arg1, temp_reg)){
 					assert(traps == 0);
 					outres = temp_reg;
@@ -1031,7 +1031,7 @@ exception_restore:
 				}
 				continue;
 			case _OP_RESUME:
-				if(sq_type(STK(arg1)) != rabbit::OT_GENERATOR){ raise_error(_SC("trying to resume a '%s',only genenerator can be resumed"), getTypeName(STK(arg1))); SQ_THROW();}
+				if(sq_type(STK(arg1)) != rabbit::OT_GENERATOR){ raise_error("trying to resume a '%s',only genenerator can be resumed", getTypeName(STK(arg1))); SQ_THROW();}
 				_GUARD(_generator(STK(arg1))->resume(this, TARGET));
 				traps += ci->_etraps;
 				continue;
@@ -1104,7 +1104,7 @@ exception_trap:
 					//notify debugger of a "return"
 					//even if it really an exception unwinding the stack
 					for(int64_t i = 0; i < ci->_ncalls; i++) {
-						callDebugHook(_SC('r'));
+						callDebugHook('r');
 					}
 			}
 			if(ci->_generator) ci->_generator->kill();
@@ -1169,14 +1169,14 @@ bool rabbit::VirtualMachine::callNative(rabbit::NativeClosure *nclosure, int64_t
 	int64_t newtop = newbase + nargs + nclosure->_noutervalues;
 
 	if (_nnativecalls + 1 > MAX_NATIVE_CALLS) {
-		raise_error(_SC("Native stack overflow"));
+		raise_error("Native stack overflow");
 		return false;
 	}
 
 	if(nparamscheck && (((nparamscheck > 0) && (nparamscheck != nargs)) ||
 		((nparamscheck < 0) && (nargs < (-nparamscheck)))))
 	{
-		raise_error(_SC("wrong number of parameters"));
+		raise_error("wrong number of parameters");
 		return false;
 	}
 
@@ -1375,7 +1375,7 @@ bool rabbit::VirtualMachine::set(const rabbit::ObjectPtr &self,const rabbit::Obj
 		if(_instance(self)->set(key,val)) return true;
 		break;
 	case rabbit::OT_ARRAY:
-		if(!sq_isnumeric(key)) { raise_error(_SC("indexing %s with %s"),getTypeName(self),getTypeName(key)); return false; }
+		if(!sq_isnumeric(key)) { raise_error("indexing %s with %s",getTypeName(self),getTypeName(key)); return false; }
 		if(!_array(self)->set(tointeger(key),val)) {
 			raise_Idxerror(key);
 			return false;
@@ -1383,7 +1383,7 @@ bool rabbit::VirtualMachine::set(const rabbit::ObjectPtr &self,const rabbit::Obj
 		return true;
 	case rabbit::OT_USERDATA: break; // must fall back
 	default:
-		raise_error(_SC("trying to set '%s'"),getTypeName(self));
+		raise_error("trying to set '%s'",getTypeName(self));
 		return false;
 	}
 
@@ -1460,7 +1460,7 @@ cloned_mt:
 		target = _array(self)->clone();
 		return true;
 	default:
-		raise_error(_SC("cloning a %s"), getTypeName(self));
+		raise_error("cloning a %s", getTypeName(self));
 		return false;
 	}
 }
@@ -1468,7 +1468,7 @@ cloned_mt:
 bool rabbit::VirtualMachine::newSlotA(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,const rabbit::ObjectPtr &attrs,bool bstatic,bool raw)
 {
 	if(sq_type(self) != rabbit::OT_CLASS) {
-		raise_error(_SC("object must be a class"));
+		raise_error("object must be a class");
 		return false;
 	}
 	rabbit::Class *c = _class(self);
@@ -1491,7 +1491,7 @@ bool rabbit::VirtualMachine::newSlotA(const rabbit::ObjectPtr &self,const rabbit
 
 bool rabbit::VirtualMachine::newSlot(const rabbit::ObjectPtr &self,const rabbit::ObjectPtr &key,const rabbit::ObjectPtr &val,bool bstatic)
 {
-	if(sq_type(key) == rabbit::OT_NULL) { raise_error(_SC("null cannot be used as index")); return false; }
+	if(sq_type(key) == rabbit::OT_NULL) { raise_error("null cannot be used as index"); return false; }
 	switch(sq_type(self)) {
 	case rabbit::OT_TABLE: {
 		bool rawcall = true;
@@ -1524,24 +1524,24 @@ bool rabbit::VirtualMachine::newSlot(const rabbit::ObjectPtr &self,const rabbit:
 			}
 			break;
 		}
-		raise_error(_SC("class instances do not support the new slot operator"));
+		raise_error("class instances do not support the new slot operator");
 		return false;
 		break;}
 	case rabbit::OT_CLASS:
 		if(!_class(self)->newSlot(_get_shared_state(this),key,val,bstatic)) {
 			if(_class(self)->_locked) {
-				raise_error(_SC("trying to modify a class that has already been instantiated"));
+				raise_error("trying to modify a class that has already been instantiated");
 				return false;
 			}
 			else {
 				rabbit::ObjectPtr oval = printObjVal(key);
-				raise_error(_SC("the property '%s' already exists"),_stringval(oval));
+				raise_error("the property '%s' already exists",_stringval(oval));
 				return false;
 			}
 		}
 		break;
 	default:
-		raise_error(_SC("indexing %s with %s"),getTypeName(self),getTypeName(key));
+		raise_error("indexing %s with %s",getTypeName(self),getTypeName(key));
 		return false;
 		break;
 	}
@@ -1574,7 +1574,7 @@ bool rabbit::VirtualMachine::deleteSlot(const rabbit::ObjectPtr &self,const rabb
 				}
 			}
 			else {
-				raise_error(_SC("cannot delete a slot from %s"),getTypeName(self));
+				raise_error("cannot delete a slot from %s",getTypeName(self));
 				return false;
 			}
 		}
@@ -1582,7 +1582,7 @@ bool rabbit::VirtualMachine::deleteSlot(const rabbit::ObjectPtr &self,const rabb
 				}
 		break;
 	default:
-		raise_error(_SC("attempt to delete a slot from a %s"),getTypeName(self));
+		raise_error("attempt to delete a slot from a %s",getTypeName(self));
 		return false;
 	}
 	return true;
@@ -1686,7 +1686,7 @@ bool rabbit::VirtualMachine::enterFrame(int64_t newbase, int64_t newtop, bool ta
 	_top = newtop;
 	if(newtop + MIN_STACK_OVERHEAD > (int64_t)_stack.size()) {
 		if(_nmetamethodscall) {
-			raise_error(_SC("stack overflow, cannot resize stack while in a metamethod"));
+			raise_error("stack overflow, cannot resize stack while in a metamethod");
 			return false;
 		}
 		_stack.resize(newtop + (MIN_STACK_OVERHEAD << 2));
@@ -1762,37 +1762,41 @@ void rabbit::VirtualMachine::dumpstack(int64_t stackbase,bool dumpall)
 {
 	int64_t size=dumpall?_stack.size():_top;
 	int64_t n=0;
-	printf(_SC("\n>>>>stack dump<<<<\n"));
+	printf("\n>>>>stack dump<<<<\n");
 	callInfo &ci=_callsstack[_callsstacksize-1];
-	printf(_SC("IP: %p\n"),ci._ip);
-	printf(_SC("prev stack base: %d\n"),ci._prevstkbase);
-	printf(_SC("prev top: %d\n"),ci._prevtop);
+	printf("IP: %p\n",ci._ip);
+	printf("prev stack base: %d\n",ci._prevstkbase);
+	printf("prev top: %d\n",ci._prevtop);
 	for(int64_t i=0;i<size;i++){
 		rabbit::ObjectPtr &obj=_stack[i];
-		if(stackbase==i)printf(_SC(">"));else printf(_SC(" "));
-		printf(_SC("[" _PRINT_INT_FMT "]:"),n);
+		if(stackbase==i) {
+			printf(">");
+		} else {
+			printf(" ");
+		}
+		printf("[" _PRINT_INT_FMT "]:",n);
 		switch(sq_type(obj)){
-		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;
+		case rabbit::OT_FLOAT:		  printf("FLOAT %.3f",_float(obj));break;
+		case rabbit::OT_INTEGER:		printf("INTEGER " _PRINT_INT_FMT,_integer(obj));break;
+		case rabbit::OT_BOOL:		   printf("BOOL %s",_integer(obj)?"true":"false");break;
+		case rabbit::OT_STRING:		 printf("STRING %s",_stringval(obj));break;
+		case rabbit::OT_NULL:		   printf("NULL");  break;
+		case rabbit::OT_TABLE:		  printf("TABLE %p[%p]",_table(obj),_table(obj)->_delegate);break;
+		case rabbit::OT_ARRAY:		  printf("ARRAY %p",_array(obj));break;
+		case rabbit::OT_CLOSURE:		printf("CLOSURE [%p]",_closure(obj));break;
+		case rabbit::OT_NATIVECLOSURE:  printf("NATIVECLOSURE");break;
+		case rabbit::OT_USERDATA:	   printf("USERDATA %p[%p]",_userdataval(obj),_userdata(obj)->_delegate);break;
+		case rabbit::OT_GENERATOR:	  printf("GENERATOR %p",_generator(obj));break;
+		case rabbit::OT_THREAD:		 printf("THREAD [%p]",_thread(obj));break;
+		case rabbit::OT_USERPOINTER:	printf("USERPOINTER %p",_userpointer(obj));break;
+		case rabbit::OT_CLASS:		  printf("CLASS %p",_class(obj));break;
+		case rabbit::OT_INSTANCE:	   printf("INSTANCE %p",_instance(obj));break;
+		case rabbit::OT_WEAKREF:		printf("WEAKERF %p",_weakref(obj));break;
 		default:
 			assert(0);
 			break;
 		};
-		printf(_SC("\n"));
+		printf("\n");
 		++n;
 	}
 }
diff --git a/rabbit/rabbit.hpp b/rabbit/rabbit.hpp
index 1bb0de2..5f1db84 100644
--- a/rabbit/rabbit.hpp
+++ b/rabbit/rabbit.hpp
@@ -19,9 +19,9 @@
 
 #include "sqconfig.hpp"
 
-#define RABBIT_VERSION    _SC("Rabbit 0.1 un-stable")
-#define RABBIT_COPYRIGHT  _SC("Copyright (C) 2003-2017 Alberto Demichelis")
-#define RABBIT_AUTHOR     _SC("Edouard DUPIN")
+#define RABBIT_VERSION    "Rabbit 0.1 un-stable"
+#define RABBIT_COPYRIGHT  "Copyright (C) 2003-2017 Alberto Demichelis"
+#define RABBIT_AUTHOR     "Edouard DUPIN"
 #define RABBIT_VERSION_NUMBER 010
 
 #define SQ_VMSTATE_IDLE       0
diff --git a/rabbit/sqapi.cpp b/rabbit/sqapi.cpp
index 7893817..3b44975 100644
--- a/rabbit/sqapi.cpp
+++ b/rabbit/sqapi.cpp
@@ -35,7 +35,7 @@ static bool sq_aux_gettypedarg(rabbit::VirtualMachine* v,int64_t idx,rabbit::Obj
 	*o = &stack_get(v,idx);
 	if(sq_type(**o) != type){
 		rabbit::ObjectPtr oval = v->printObjVal(**o);
-		v->raise_error(_SC("wrong argument type, expected '%s' got '%.50s'"),IdType2Name(type),_stringval(oval));
+		v->raise_error("wrong argument type, expected '%s' got '%.50s'",IdType2Name(type),_stringval(oval));
 		return false;
 	}
 	return true;
@@ -45,14 +45,14 @@ static bool sq_aux_gettypedarg(rabbit::VirtualMachine* v,int64_t idx,rabbit::Obj
 
 #define sq_aux_paramscheck(v,count) \
 { \
-	if(sq_gettop(v) < count){ v->raise_error(_SC("not enough params in the stack")); return SQ_ERROR; }\
+	if(sq_gettop(v) < count){ v->raise_error("not enough params in the stack"); return SQ_ERROR; }\
 }
 
 namespace rabbit {
 	int64_t sq_aux_invalidtype(rabbit::VirtualMachine* v,rabbit::ObjectType type)
 	{
 		uint64_t buf_size = 100 *sizeof(char);
-		snprintf(_get_shared_state(v)->getScratchPad(buf_size), buf_size, _SC("unexpected type %s"), IdType2Name(type));
+		snprintf(_get_shared_state(v)->getScratchPad(buf_size), buf_size, "unexpected type %s", IdType2Name(type));
 		return sq_throwerror(v, _get_shared_state(v)->getScratchPad(-1));
 	}
 }
@@ -154,7 +154,7 @@ rabbit::Result rabbit::sq_compile(rabbit::VirtualMachine* v,SQLEXREADFUNC read,r
 	}
 	return SQ_ERROR;
 #else
-	return sq_throwerror(v,_SC("this is a no compiler build"));
+	return sq_throwerror(v,"this is a no compiler build");
 #endif
 }
 
@@ -299,7 +299,7 @@ rabbit::Result rabbit::sq_newclass(rabbit::VirtualMachine* v,rabbit::Bool hasbas
 	if(hasbase) {
 		rabbit::ObjectPtr &base = stack_get(v,-1);
 		if(sq_type(base) != rabbit::OT_CLASS)
-			return sq_throwerror(v,_SC("invalid base type"));
+			return sq_throwerror(v,"invalid base type");
 		baseclass = _class(base);
 	}
 	rabbit::Class *newclass = rabbit::Class::create(_get_shared_state(v), baseclass);
@@ -314,7 +314,7 @@ rabbit::Bool rabbit::sq_instanceof(rabbit::VirtualMachine* v)
 	rabbit::ObjectPtr &cl = stack_get(v,-2);
 	if(    sq_type(inst) != rabbit::OT_INSTANCE
 	    || sq_type(cl) != rabbit::OT_CLASS)
-		return sq_throwerror(v,_SC("invalid param type"));
+		return sq_throwerror(v,"invalid param type");
 	return _instance(inst)->instanceOf(_class(cl))?SQTrue:SQFalse;
 }
 
@@ -340,7 +340,7 @@ rabbit::Result rabbit::sq_arraypop(rabbit::VirtualMachine* v,int64_t idx,rabbit:
 		_array(*arr)->pop();
 		return SQ_OK;
 	}
-	return sq_throwerror(v, _SC("empty array"));
+	return sq_throwerror(v, "empty array");
 }
 
 rabbit::Result rabbit::sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int64_t newsize)
@@ -352,7 +352,7 @@ rabbit::Result rabbit::sq_arrayresize(rabbit::VirtualMachine* v,int64_t idx,int6
 		_array(*arr)->resize(newsize);
 		return SQ_OK;
 	}
-	return sq_throwerror(v,_SC("negative size"));
+	return sq_throwerror(v,"negative size");
 }
 
 
@@ -382,7 +382,7 @@ rabbit::Result rabbit::sq_arrayremove(rabbit::VirtualMachine* v,int64_t idx,int6
 	sq_aux_paramscheck(v, 1);
 	rabbit::ObjectPtr *arr;
 	_GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr);
-	return _array(*arr)->remove(itemidx) ? SQ_OK : sq_throwerror(v,_SC("index out of range"));
+	return _array(*arr)->remove(itemidx) ? SQ_OK : sq_throwerror(v,"index out of range");
 }
 
 rabbit::Result rabbit::sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int64_t destpos)
@@ -390,7 +390,7 @@ rabbit::Result rabbit::sq_arrayinsert(rabbit::VirtualMachine* v,int64_t idx,int6
 	sq_aux_paramscheck(v, 1);
 	rabbit::ObjectPtr *arr;
 	_GETSAFE_OBJ(v, idx, rabbit::OT_ARRAY,arr);
-	rabbit::Result ret = _array(*arr)->insert(destpos, v->getUp(-1)) ? SQ_OK : sq_throwerror(v,_SC("index out of range"));
+	rabbit::Result ret = _array(*arr)->insert(destpos, v->getUp(-1)) ? SQ_OK : sq_throwerror(v,"index out of range");
 	v->pop();
 	return ret;
 }
@@ -423,7 +423,7 @@ rabbit::Result rabbit::sq_getclosureinfo(rabbit::VirtualMachine* v,int64_t idx,u
 		*nfreevars = c->_noutervalues;
 		return SQ_OK;
 	}
-	return sq_throwerror(v,_SC("the object is not a closure"));
+	return sq_throwerror(v,"the object is not a closure");
 }
 
 rabbit::Result rabbit::sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t idx,const char *name)
@@ -434,20 +434,20 @@ rabbit::Result rabbit::sq_setnativeclosurename(rabbit::VirtualMachine* v,int64_t
 		nc->_name = rabbit::String::create(_get_shared_state(v),name);
 		return SQ_OK;
 	}
-	return sq_throwerror(v,_SC("the object is not a nativeclosure"));
+	return sq_throwerror(v,"the object is not a nativeclosure");
 }
 
 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))
-		return sq_throwerror(v, _SC("native closure expected"));
+		return sq_throwerror(v, "native closure expected");
 	rabbit::NativeClosure *nc = _nativeclosure(o);
 	nc->_nparamscheck = nparamscheck;
 	if(typemask) {
 		etk::Vector<int64_t> res;
 		if(!compileTypemask(res, typemask))
-			return sq_throwerror(v, _SC("invalid typemask"));
+			return sq_throwerror(v, "invalid typemask");
 		nc->_typecheck = res;
 	}
 	else {
@@ -464,13 +464,13 @@ rabbit::Result rabbit::sq_bindenv(rabbit::VirtualMachine* v,int64_t idx)
 	rabbit::ObjectPtr &o = stack_get(v,idx);
 	if(!sq_isnativeclosure(o) &&
 		!sq_isclosure(o))
-		return sq_throwerror(v,_SC("the target is not a closure"));
+		return sq_throwerror(v, "the target is not a closure");
 	rabbit::ObjectPtr &env = stack_get(v,-1);
 	if(!sq_istable(env) &&
 		!sq_isarray(env) &&
 		!sq_isclass(env) &&
 		!sq_isinstance(env))
-		return sq_throwerror(v,_SC("invalid environment"));
+		return sq_throwerror(v,"invalid environment");
 	rabbit::WeakRef *w = _refcounted(env)->getWeakRef(sq_type(env));
 	rabbit::ObjectPtr ret;
 	if(sq_isclosure(o)) {
@@ -501,7 +501,7 @@ rabbit::Result rabbit::sq_getclosurename(rabbit::VirtualMachine* v,int64_t idx)
 	rabbit::ObjectPtr &o = stack_get(v,idx);
 	if(!sq_isnativeclosure(o) &&
 		!sq_isclosure(o))
-		return sq_throwerror(v,_SC("the target is not a closure"));
+		return sq_throwerror(v,"the target is not a closure");
 	if(sq_isnativeclosure(o))
 	{
 		v->push(_nativeclosure(o)->_name);
@@ -516,19 +516,19 @@ rabbit::Result rabbit::sq_setclosureroot(rabbit::VirtualMachine* v,int64_t idx)
 {
 	rabbit::ObjectPtr &c = stack_get(v,idx);
 	rabbit::Object o = stack_get(v, -1);
-	if(!sq_isclosure(c)) return sq_throwerror(v, _SC("closure expected"));
+	if(!sq_isclosure(c)) return sq_throwerror(v, "closure expected");
 	if(sq_istable(o)) {
 		_closure(c)->setRoot(_table(o)->getWeakRef(rabbit::OT_TABLE));
 		v->pop();
 		return SQ_OK;
 	}
-	return sq_throwerror(v, _SC("invalid type"));
+	return sq_throwerror(v, "invalid type");
 }
 
 rabbit::Result rabbit::sq_getclosureroot(rabbit::VirtualMachine* v,int64_t idx)
 {
 	rabbit::ObjectPtr &c = stack_get(v,idx);
-	if(!sq_isclosure(c)) return sq_throwerror(v, _SC("closure expected"));
+	if(!sq_isclosure(c)) return sq_throwerror(v, "closure expected");
 	v->push(_closure(c)->_root->_obj);
 	return SQ_OK;
 }
@@ -540,7 +540,7 @@ rabbit::Result rabbit::sq_clear(rabbit::VirtualMachine* v,int64_t idx)
 		case rabbit::OT_TABLE: _table(o)->clear();  break;
 		case rabbit::OT_ARRAY: _array(o)->resize(0); break;
 		default:
-			return sq_throwerror(v, _SC("clear only works on table and array"));
+			return sq_throwerror(v, "clear only works on table and array");
 		break;
 
 	}
@@ -570,7 +570,7 @@ rabbit::Result rabbit::sq_setroottable(rabbit::VirtualMachine* v)
 		v->pop();
 		return SQ_OK;
 	}
-	return sq_throwerror(v, _SC("invalid type"));
+	return sq_throwerror(v, "invalid type");
 }
 
 rabbit::Result rabbit::sq_setconsttable(rabbit::VirtualMachine* v)
@@ -581,7 +581,7 @@ rabbit::Result rabbit::sq_setconsttable(rabbit::VirtualMachine* v)
 		v->pop();
 		return SQ_OK;
 	}
-	return sq_throwerror(v, _SC("invalid type, expected table"));
+	return sq_throwerror(v, "invalid type, expected table");
 }
 
 void rabbit::sq_setforeignptr(rabbit::VirtualMachine* v,rabbit::UserPointer p)
@@ -776,7 +776,7 @@ rabbit::Result rabbit::sq_settypetag(rabbit::VirtualMachine* v,int64_t idx,rabbi
 			_class(o)->_typetag = typetag;
 			break;
 		default:
-			return sq_throwerror(v,_SC("invalid object type"));
+			return sq_throwerror(v,"invalid object type");
 	}
 	return SQ_OK;
 }
@@ -811,7 +811,7 @@ rabbit::Result rabbit::sq_getuserpointer(rabbit::VirtualMachine* v, int64_t idx,
 rabbit::Result rabbit::sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer p)
 {
 	rabbit::ObjectPtr &o = stack_get(v,idx);
-	if(sq_type(o) != rabbit::OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance"));
+	if(sq_type(o) != rabbit::OT_INSTANCE) return sq_throwerror(v,"the object is not a class instance");
 	_instance(o)->_userpointer = p;
 	return SQ_OK;
 }
@@ -819,8 +819,8 @@ rabbit::Result rabbit::sq_setinstanceup(rabbit::VirtualMachine* v, int64_t idx,
 rabbit::Result rabbit::sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx, int64_t udsize)
 {
 	rabbit::ObjectPtr &o = stack_get(v,idx);
-	if(sq_type(o) != rabbit::OT_CLASS) return sq_throwerror(v,_SC("the object is not a class"));
-	if(_class(o)->_locked) return sq_throwerror(v,_SC("the class is locked"));
+	if(sq_type(o) != rabbit::OT_CLASS) return sq_throwerror(v,"the object is not a class");
+	if(_class(o)->_locked) return sq_throwerror(v,"the class is locked");
 	_class(o)->_udsize = udsize;
 	return SQ_OK;
 }
@@ -829,7 +829,7 @@ rabbit::Result rabbit::sq_setclassudsize(rabbit::VirtualMachine* v, int64_t idx,
 rabbit::Result rabbit::sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx, rabbit::UserPointer *p,rabbit::UserPointer typetag)
 {
 	rabbit::ObjectPtr &o = stack_get(v,idx);
-	if(sq_type(o) != rabbit::OT_INSTANCE) return sq_throwerror(v,_SC("the object is not a class instance"));
+	if(sq_type(o) != rabbit::OT_INSTANCE) return sq_throwerror(v,"the object is not a class instance");
 	(*p) = _instance(o)->_userpointer;
 	if(typetag != 0) {
 		rabbit::Class *cl = _instance(o)->_class;
@@ -838,7 +838,7 @@ rabbit::Result rabbit::sq_getinstanceup(rabbit::VirtualMachine* v, int64_t idx,
 				return SQ_OK;
 			cl = cl->_base;
 		}while(cl != NULL);
-		return sq_throwerror(v,_SC("invalid type tag"));
+		return sq_throwerror(v,"invalid type tag");
 	}
 	return SQ_OK;
 }
@@ -888,7 +888,7 @@ rabbit::Result rabbit::sq_newslot(rabbit::VirtualMachine* v, int64_t idx, rabbit
 	rabbit::ObjectPtr &self = stack_get(v, idx);
 	if(sq_type(self) == rabbit::OT_TABLE || sq_type(self) == rabbit::OT_CLASS) {
 		rabbit::ObjectPtr &key = v->getUp(-2);
-		if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, _SC("null is not a valid key"));
+		if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, "null is not a valid key");
 		v->newSlot(self, key, v->getUp(-1),bstatic?true:false);
 		v->pop(2);
 	}
@@ -901,7 +901,7 @@ rabbit::Result rabbit::sq_deleteslot(rabbit::VirtualMachine* v,int64_t idx,rabbi
 	rabbit::ObjectPtr *self;
 	_GETSAFE_OBJ(v, idx, rabbit::OT_TABLE,self);
 	rabbit::ObjectPtr &key = v->getUp(-1);
-	if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, _SC("null is not a valid key"));
+	if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, "null is not a valid key");
 	rabbit::ObjectPtr res;
 	if(!v->deleteSlot(*self, key, res)){
 		v->pop();
@@ -928,7 +928,7 @@ rabbit::Result rabbit::sq_rawset(rabbit::VirtualMachine* v,int64_t idx)
 	rabbit::ObjectPtr &key = v->getUp(-2);
 	if(sq_type(key) == rabbit::OT_NULL) {
 		v->pop(2);
-		return sq_throwerror(v, _SC("null key"));
+		return sq_throwerror(v, "null key");
 	}
 	switch(sq_type(self)) {
 	case rabbit::OT_TABLE:
@@ -955,7 +955,7 @@ rabbit::Result rabbit::sq_rawset(rabbit::VirtualMachine* v,int64_t idx)
 	break;
 	default:
 		v->pop(2);
-		return sq_throwerror(v, _SC("rawset works only on array/table/class and instance"));
+		return sq_throwerror(v, "rawset works only on array/table/class and instance");
 	}
 	v->raise_Idxerror(v->getUp(-2));return SQ_ERROR;
 }
@@ -963,9 +963,9 @@ rabbit::Result rabbit::sq_rawset(rabbit::VirtualMachine* v,int64_t idx)
 rabbit::Result rabbit::sq_newmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic)
 {
 	rabbit::ObjectPtr &self = stack_get(v, idx);
-	if(sq_type(self) != rabbit::OT_CLASS) return sq_throwerror(v, _SC("new member only works with classes"));
+	if(sq_type(self) != rabbit::OT_CLASS) return sq_throwerror(v, "new member only works with classes");
 	rabbit::ObjectPtr &key = v->getUp(-3);
-	if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, _SC("null key"));
+	if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, "null key");
 	if(!v->newSlotA(self,key,v->getUp(-2),v->getUp(-1),bstatic?true:false,false)) {
 		v->pop(3);
 		return SQ_ERROR;
@@ -977,9 +977,9 @@ rabbit::Result rabbit::sq_newmember(rabbit::VirtualMachine* v,int64_t idx,rabbit
 rabbit::Result rabbit::sq_rawnewmember(rabbit::VirtualMachine* v,int64_t idx,rabbit::Bool bstatic)
 {
 	rabbit::ObjectPtr &self = stack_get(v, idx);
-	if(sq_type(self) != rabbit::OT_CLASS) return sq_throwerror(v, _SC("new member only works with classes"));
+	if(sq_type(self) != rabbit::OT_CLASS) return sq_throwerror(v, "new member only works with classes");
 	rabbit::ObjectPtr &key = v->getUp(-3);
-	if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, _SC("null key"));
+	if(sq_type(key) == rabbit::OT_NULL) return sq_throwerror(v, "null key");
 	if(!v->newSlotA(self,key,v->getUp(-2),v->getUp(-1),bstatic?true:false,true)) {
 		v->pop(3);
 		return SQ_ERROR;
@@ -997,7 +997,7 @@ rabbit::Result rabbit::sq_setdelegate(rabbit::VirtualMachine* v,int64_t idx)
 	case rabbit::OT_TABLE:
 		if(sq_type(mt) == rabbit::OT_TABLE) {
 			if(!_table(self)->setDelegate(_table(mt))) {
-				return sq_throwerror(v, _SC("delagate cycle"));
+				return sq_throwerror(v, "delagate cycle");
 			}
 			v->pop();
 		}
@@ -1048,7 +1048,7 @@ rabbit::Result rabbit::sq_getdelegate(rabbit::VirtualMachine* v,int64_t idx)
 		}
 		v->push(rabbit::ObjectPtr(_delegable(self)->_delegate));
 		break;
-	default: return sq_throwerror(v,_SC("wrong type")); break;
+	default: return sq_throwerror(v,"wrong type"); break;
 	}
 	return SQ_OK;
 
@@ -1089,16 +1089,16 @@ rabbit::Result rabbit::sq_rawget(rabbit::VirtualMachine* v,int64_t idx)
 		}
 		else {
 			v->pop();
-			return sq_throwerror(v,_SC("invalid index type for an array"));
+			return sq_throwerror(v,"invalid index type for an array");
 		}
 				  }
 		break;
 	default:
 		v->pop();
-		return sq_throwerror(v,_SC("rawget works only on array/table/instance and class"));
+		return sq_throwerror(v,"rawget works only on array/table/instance and class");
 	}
 	v->pop();
-	return sq_throwerror(v,_SC("the index doesn't exist"));
+	return sq_throwerror(v,"the index doesn't exist");
 }
 
 rabbit::Result rabbit::sq_getstackobj(rabbit::VirtualMachine* v,int64_t idx,rabbit::Object *po)
@@ -1170,7 +1170,7 @@ rabbit::Result rabbit::sq_reservestack(rabbit::VirtualMachine* v,int64_t nsize)
 {
 	if (((uint64_t)v->_top + nsize) > v->_stack.size()) {
 		if(v->_nmetamethodscall) {
-			return sq_throwerror(v,_SC("cannot resize stack while in a metamethod"));
+			return sq_throwerror(v,"cannot resize stack while in a metamethod");
 		}
 		v->_stack.resize(v->_stack.size() + ((v->_top + nsize) - v->_stack.size()));
 	}
@@ -1188,7 +1188,7 @@ rabbit::Result rabbit::sq_resume(rabbit::VirtualMachine* v,rabbit::Bool retval,r
 			v->pop();
 		return SQ_OK;
 	}
-	return sq_throwerror(v,_SC("only generators can be resumed"));
+	return sq_throwerror(v,"only generators can be resumed");
 }
 
 rabbit::Result rabbit::sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::Bool retval,rabbit::Bool raiseerror)
@@ -1210,19 +1210,19 @@ rabbit::Result rabbit::sq_call(rabbit::VirtualMachine* v,int64_t params,rabbit::
 	}
 	if(!v->_suspended)
 		v->pop(params);
-	return sq_throwerror(v,_SC("call failed"));
+	return sq_throwerror(v,"call failed");
 }
 
 rabbit::Result rabbit::sq_tailcall(rabbit::VirtualMachine* v, int64_t nparams)
 {
 	rabbit::ObjectPtr &res = v->getUp(-(nparams + 1));
 	if (sq_type(res) != rabbit::OT_CLOSURE) {
-		return sq_throwerror(v, _SC("only closure can be tail called"));
+		return sq_throwerror(v, "only closure can be tail called");
 	}
 	rabbit::Closure *clo = _closure(res);
 	if (clo->_function->_bgenerator)
 	{
-		return sq_throwerror(v, _SC("generators cannot be tail called"));
+		return sq_throwerror(v, "generators cannot be tail called");
 	}
 	
 	int64_t stackbase = (v->_top - nparams) - v->_stackbase;
@@ -1241,7 +1241,7 @@ rabbit::Result rabbit::sq_wakeupvm(rabbit::VirtualMachine* v,rabbit::Bool wakeup
 {
 	rabbit::ObjectPtr ret;
 	if(!v->_suspended)
-		return sq_throwerror(v,_SC("cannot resume a vm that is not running any code"));
+		return sq_throwerror(v,"cannot resume a vm that is not running any code");
 	int64_t target = v->_suspended_target;
 	if(wakeupret) {
 		if(target != -1) {
@@ -1306,9 +1306,9 @@ rabbit::Result rabbit::sq_writeclosure(rabbit::VirtualMachine* v,SQWRITEFUNC w,r
 	_GETSAFE_OBJ(v, -1, rabbit::OT_CLOSURE,o);
 	unsigned short tag = SQ_BYTECODE_STREAM_TAG;
 	if(_closure(*o)->_function->_noutervalues)
-		return sq_throwerror(v,_SC("a closure with free variables bound cannot be serialized"));
+		return sq_throwerror(v,"a closure with free variables bound cannot be serialized");
 	if(w(up,&tag,2) != 2)
-		return sq_throwerror(v,_SC("io error"));
+		return sq_throwerror(v,"io error");
 	if(!_closure(*o)->save(v,up,w))
 		return SQ_ERROR;
 	return SQ_OK;
@@ -1320,9 +1320,9 @@ rabbit::Result rabbit::sq_readclosure(rabbit::VirtualMachine* v,SQREADFUNC r,rab
 
 	unsigned short tag;
 	if(r(up,&tag,2) != 2)
-		return sq_throwerror(v,_SC("io error"));
+		return sq_throwerror(v,"io error");
 	if(tag != SQ_BYTECODE_STREAM_TAG)
-		return sq_throwerror(v,_SC("invalid stream"));
+		return sq_throwerror(v,"invalid stream");
 	if(!rabbit::Closure::load(v,up,r,closure))
 		return SQ_ERROR;
 	v->push(closure);
@@ -1336,7 +1336,7 @@ char * rabbit::sq_getscratchpad(rabbit::VirtualMachine* v,int64_t minsize)
 
 rabbit::Result rabbit::sq_resurrectunreachable(rabbit::VirtualMachine* v)
 {
-	return sq_throwerror(v,_SC("sq_resurrectunreachable requires a garbage collector build"));
+	return sq_throwerror(v,"sq_resurrectunreachable requires a garbage collector build");
 }
 
 // TODO: remove this...
@@ -1352,7 +1352,7 @@ rabbit::Result rabbit::sq_getcallee(rabbit::VirtualMachine* v)
 		v->push(v->_callsstack[v->_callsstacksize - 2]._closure);
 		return SQ_OK;
 	}
-	return sq_throwerror(v,_SC("no closure in the calls stack"));
+	return sq_throwerror(v,"no closure in the calls stack");
 }
 
 const char * rabbit::sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,uint64_t nval)
@@ -1375,7 +1375,7 @@ const char * rabbit::sq_getfreevariable(rabbit::VirtualMachine* v,int64_t idx,ui
 		rabbit::NativeClosure *clo = _nativeclosure(self);
 		if(clo->_noutervalues > nval) {
 			v->push(clo->_outervalues[nval]);
-			name = _SC("@NATIVE");
+			name = "@NATIVE";
 		}
 						  }
 		break;
@@ -1394,14 +1394,14 @@ rabbit::Result rabbit::sq_setfreevariable(rabbit::VirtualMachine* v,int64_t idx,
 		if(((uint64_t)fp->_noutervalues) > nval){
 			*(_outer(_closure(self)->_outervalues[nval])->_valptr) = stack_get(v,-1);
 		}
-		else return sq_throwerror(v,_SC("invalid free var index"));
+		else return sq_throwerror(v,"invalid free var index");
 					}
 		break;
 	case rabbit::OT_NATIVECLOSURE:
 		if(_nativeclosure(self)->_noutervalues > nval){
 			_nativeclosure(self)->_outervalues[nval] = stack_get(v,-1);
 		}
-		else return sq_throwerror(v,_SC("invalid free var index"));
+		else return sq_throwerror(v,"invalid free var index");
 		break;
 	default:
 		return sq_aux_invalidtype(v, sq_type(self));
@@ -1429,7 +1429,7 @@ rabbit::Result rabbit::sq_setattributes(rabbit::VirtualMachine* v,int64_t idx)
 		v->push(attrs);
 		return SQ_OK;
 	}
-	return sq_throwerror(v,_SC("wrong index"));
+	return sq_throwerror(v,"wrong index");
 }
 
 rabbit::Result rabbit::sq_getattributes(rabbit::VirtualMachine* v,int64_t idx)
@@ -1449,7 +1449,7 @@ rabbit::Result rabbit::sq_getattributes(rabbit::VirtualMachine* v,int64_t idx)
 		v->push(attrs);
 		return SQ_OK;
 	}
-	return sq_throwerror(v,_SC("wrong index"));
+	return sq_throwerror(v,"wrong index");
 }
 
 rabbit::Result rabbit::sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,rabbit::MemberHandle *handle)
@@ -1465,7 +1465,7 @@ rabbit::Result rabbit::sq_getmemberhandle(rabbit::VirtualMachine* v,int64_t idx,
 		v->pop();
 		return SQ_OK;
 	}
-	return sq_throwerror(v,_SC("wrong index"));
+	return sq_throwerror(v,"wrong index");
 }
 
 rabbit::Result _getmemberbyhandle(rabbit::VirtualMachine* v,rabbit::ObjectPtr &self,const rabbit::MemberHandle *handle,rabbit::ObjectPtr *&val)
@@ -1494,7 +1494,7 @@ rabbit::Result _getmemberbyhandle(rabbit::VirtualMachine* v,rabbit::ObjectPtr &s
 			}
 			break;
 		default:
-			return sq_throwerror(v,_SC("wrong type(expected class or instance)"));
+			return sq_throwerror(v,"wrong type(expected class or instance)");
 	}
 	return SQ_OK;
 }
@@ -1564,7 +1564,7 @@ rabbit::Result rabbit::sq_getweakrefval(rabbit::VirtualMachine* v,int64_t idx)
 {
 	rabbit::ObjectPtr &o = stack_get(v,idx);
 	if(sq_type(o) != rabbit::OT_WEAKREF) {
-		return sq_throwerror(v,_SC("the object must be a weakref"));
+		return sq_throwerror(v,"the object must be a weakref");
 	}
 	v->push(_weakref(o)->_obj);
 	return SQ_OK;
@@ -1584,7 +1584,7 @@ rabbit::Result rabbit::sq_getdefaultdelegate(rabbit::VirtualMachine* v,rabbit::O
 	case rabbit::OT_CLASS: v->push(ss->_class_default_delegate); break;
 	case rabbit::OT_INSTANCE: v->push(ss->_instance_default_delegate); break;
 	case rabbit::OT_WEAKREF: v->push(ss->_weakref_default_delegate); break;
-	default: return sq_throwerror(v,_SC("the type doesn't have a default delegate"));
+	default: return sq_throwerror(v,"the type doesn't have a default delegate");
 	}
 	return SQ_OK;
 }
@@ -1593,7 +1593,7 @@ rabbit::Result rabbit::sq_next(rabbit::VirtualMachine* v,int64_t idx)
 {
 	rabbit::ObjectPtr o=stack_get(v,idx),&refpos = stack_get(v,-1),realkey,val;
 	if(sq_type(o) == rabbit::OT_GENERATOR) {
-		return sq_throwerror(v,_SC("cannot iterate a generator"));
+		return sq_throwerror(v,"cannot iterate a generator");
 	}
 	int faketojump;
 	if(!v->FOREACH_OP(o,realkey,val,refpos,0,666,faketojump))
diff --git a/rabbit/sqbaselib.cpp b/rabbit/sqbaselib.cpp
index 65b919d..5d503af 100644
--- a/rabbit/sqbaselib.cpp
+++ b/rabbit/sqbaselib.cpp
@@ -33,9 +33,9 @@ static bool str2num(const char *s,rabbit::ObjectPtr &res,int64_t base)
 	bool iseintbase = base > 13; //to fix error converting hexadecimals with e like 56f0791e
 	bool isfloat = false;
 	char c;
-	while((c = *e) != _SC('\0'))
+	while((c = *e) != '\0')
 	{
-		if (c == _SC('.') || (!iseintbase && (c == _SC('E') || c == _SC('e')))) { //e and E is for scientific notation
+		if (c == '.' || (!iseintbase && (c == 'E' || c == 'e'))) { //e and E is for scientific notation
 			isfloat = true;
 			break;
 		}
@@ -116,21 +116,21 @@ static int64_t __getcallstackinfos(rabbit::VirtualMachine* v,int64_t level)
 
 	if (SQ_SUCCEEDED(sq_stackinfos(v, level, &si)))
 	{
-		const char *fn = _SC("unknown");
-		const char *src = _SC("unknown");
+		const char *fn = "unknown";
+		const char *src = "unknown";
 		if(si.funcname)fn = si.funcname;
 		if(si.source)src = si.source;
 		sq_newtable(v);
-		sq_pushstring(v, _SC("func"), -1);
+		sq_pushstring(v, "func", -1);
 		sq_pushstring(v, fn, -1);
 		sq_newslot(v, -3, SQFalse);
-		sq_pushstring(v, _SC("src"), -1);
+		sq_pushstring(v, "src", -1);
 		sq_pushstring(v, src, -1);
 		sq_newslot(v, -3, SQFalse);
-		sq_pushstring(v, _SC("line"), -1);
+		sq_pushstring(v, "line", -1);
 		sq_pushinteger(v, si.line);
 		sq_newslot(v, -3, SQFalse);
-		sq_pushstring(v, _SC("locals"), -1);
+		sq_pushstring(v, "locals", -1);
 		sq_newtable(v);
 		seq=0;
 		while ((name = sq_getlocal(v, level, seq))) {
@@ -163,7 +163,7 @@ static int64_t base_assert(rabbit::VirtualMachine* v)
 				return sq_throwerror(v, str);
 			}
 		}
-		return sq_throwerror(v, _SC("assertion failed"));
+		return sq_throwerror(v, "assertion failed");
 	}
 	return 0;
 }
@@ -198,7 +198,7 @@ static int64_t base_print(rabbit::VirtualMachine* v)
 	if(SQ_SUCCEEDED(sq_tostring(v,2)))
 	{
 		if(SQ_SUCCEEDED(sq_getstring(v,-1,&str))) {
-			if(_get_shared_state(v)->_printfunc) _get_shared_state(v)->_printfunc(v,_SC("%s"),str);
+			if(_get_shared_state(v)->_printfunc) _get_shared_state(v)->_printfunc(v,"%s",str);
 			return 0;
 		}
 	}
@@ -211,7 +211,7 @@ static int64_t base_error(rabbit::VirtualMachine* v)
 	if(SQ_SUCCEEDED(sq_tostring(v,2)))
 	{
 		if(SQ_SUCCEEDED(sq_getstring(v,-1,&str))) {
-			if(_get_shared_state(v)->_errorfunc) _get_shared_state(v)->_errorfunc(v,_SC("%s"),str);
+			if(_get_shared_state(v)->_errorfunc) _get_shared_state(v)->_errorfunc(v,"%s",str);
 			return 0;
 		}
 	}
@@ -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 char *src=NULL,*name=_SC("unnamedbuffer");
+	const char *src=NULL,*name="unnamedbuffer";
 	int64_t size;
 	sq_getstring(v,2,&src);
 	size=sq_getsize(v,2);
@@ -277,29 +277,29 @@ static int64_t base_callee(rabbit::VirtualMachine* v)
 		v->push(v->_callsstack[v->_callsstacksize - 2]._closure);
 		return 1;
 	}
-	return sq_throwerror(v,_SC("no closure in the calls stack"));
+	return sq_throwerror(v,"no closure in the calls stack");
 }
 
 static const rabbit::RegFunction base_funcs[]={
 	//generic
-	{_SC("seterrorhandler"),base_seterrorhandler,2, NULL},
-	{_SC("setdebughook"),base_setdebughook,2, NULL},
-	{_SC("enabledebuginfo"),base_enabledebuginfo,2, NULL},
-	{_SC("getstackinfos"),base_getstackinfos,2, _SC(".n")},
-	{_SC("getroottable"),base_getroottable,1, NULL},
-	{_SC("setroottable"),base_setroottable,2, NULL},
-	{_SC("getconsttable"),base_getconsttable,1, NULL},
-	{_SC("setconsttable"),base_setconsttable,2, NULL},
-	{_SC("assert"),base_assert,-2, NULL},
-	{_SC("print"),base_print,2, NULL},
-	{_SC("error"),base_error,2, NULL},
-	{_SC("compilestring"),base_compilestring,-2, _SC(".ss")},
-	{_SC("newthread"),base_newthread,2, _SC(".c")},
-	{_SC("suspend"),base_suspend,-1, NULL},
-	{_SC("array"),base_array,-2, _SC(".n")},
-	{_SC("type"),base_type,2, NULL},
-	{_SC("callee"),base_callee,0,NULL},
-	{_SC("dummy"),base_dummy,0,NULL},
+	{"seterrorhandler",base_seterrorhandler,2, NULL},
+	{"setdebughook",base_setdebughook,2, NULL},
+	{"enabledebuginfo",base_enabledebuginfo,2, NULL},
+	{"getstackinfos",base_getstackinfos,2, ".n"},
+	{"getroottable",base_getroottable,1, NULL},
+	{"setroottable",base_setroottable,2, NULL},
+	{"getconsttable",base_getconsttable,1, NULL},
+	{"setconsttable",base_setconsttable,2, NULL},
+	{"assert",base_assert,-2, NULL},
+	{"print",base_print,2, NULL},
+	{"error",base_error,2, NULL},
+	{"compilestring",base_compilestring,-2, ".ss"},
+	{"newthread",base_newthread,2, ".c"},
+	{"suspend",base_suspend,-1, NULL},
+	{"array",base_array,-2, ".n"},
+	{"type",base_type,2, NULL},
+	{"callee",base_callee,0,NULL},
+	{"dummy",base_dummy,0,NULL},
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
@@ -316,19 +316,19 @@ void sq_base_register(rabbit::VirtualMachine* v)
 		i++;
 	}
 
-	sq_pushstring(v,_SC("_versionnumber_"),-1);
+	sq_pushstring(v,"_versionnumber_",-1);
 	sq_pushinteger(v,RABBIT_VERSION_NUMBER);
 	sq_newslot(v,-3, SQFalse);
-	sq_pushstring(v,_SC("_version_"),-1);
+	sq_pushstring(v,"_version_",-1);
 	sq_pushstring(v,RABBIT_VERSION,-1);
 	sq_newslot(v,-3, SQFalse);
-	sq_pushstring(v,_SC("_charsize_"),-1);
+	sq_pushstring(v,"_charsize_",-1);
 	sq_pushinteger(v,sizeof(char));
 	sq_newslot(v,-3, SQFalse);
-	sq_pushstring(v,_SC("_intsize_"),-1);
+	sq_pushstring(v,"_intsize_",-1);
 	sq_pushinteger(v,sizeof(int64_t));
 	sq_newslot(v,-3, SQFalse);
-	sq_pushstring(v,_SC("_floatsize_"),-1);
+	sq_pushstring(v,"_floatsize_",-1);
 	sq_pushinteger(v,sizeof(float_t));
 	sq_newslot(v,-3, SQFalse);
 	sq_pop(v,1);
@@ -350,7 +350,7 @@ static int64_t default_delegate_tofloat(rabbit::VirtualMachine* v)
 			v->push(rabbit::ObjectPtr(tofloat(res)));
 			break;
 		}}
-		return sq_throwerror(v, _SC("cannot convert the string"));
+		return sq_throwerror(v, "cannot convert the string");
 		break;
 	case rabbit::OT_INTEGER:
 	case rabbit::OT_FLOAT:
@@ -380,7 +380,7 @@ static int64_t default_delegate_tointeger(rabbit::VirtualMachine* v)
 			v->push(rabbit::ObjectPtr(tointeger(res)));
 			break;
 		}}
-		return sq_throwerror(v, _SC("cannot convert the string"));
+		return sq_throwerror(v, "cannot convert the string");
 		break;
 	case rabbit::OT_INTEGER:
 	case rabbit::OT_FLOAT:
@@ -499,17 +499,17 @@ static int64_t table_filter(rabbit::VirtualMachine* v)
 
 
 const rabbit::RegFunction rabbit::SharedState::_table_default_delegate_funcz[]={
-	{_SC("len"),default_delegate_len,1, _SC("t")},
-	{_SC("rawget"),container_rawget,2, _SC("t")},
-	{_SC("rawset"),container_rawset,3, _SC("t")},
-	{_SC("rawdelete"),table_rawdelete,2, _SC("t")},
-	{_SC("rawin"),container_rawexists,2, _SC("t")},
-	{_SC("weakref"),obj_delegate_weakref,1, NULL },
-	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
-	{_SC("clear"),obj_clear,1, _SC(".")},
-	{_SC("setdelegate"),table_setdelegate,2, _SC(".t|o")},
-	{_SC("getdelegate"),table_getdelegate,1, _SC(".")},
-	{_SC("filter"),table_filter,2, _SC("tc")},
+	{"len",default_delegate_len,1, "t"},
+	{"rawget",container_rawget,2, "t"},
+	{"rawset",container_rawset,3, "t"},
+	{"rawdelete",table_rawdelete,2, "t"},
+	{"rawin",container_rawexists,2, "t"},
+	{"weakref",obj_delegate_weakref,1, NULL },
+	{"tostring",default_delegate_tostring,1, "."},
+	{"clear",obj_clear,1, "."},
+	{"setdelegate",table_setdelegate,2, ".t|o"},
+	{"getdelegate",table_getdelegate,1, "."},
+	{"filter",table_filter,2, "tc"},
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
@@ -544,7 +544,7 @@ static int64_t array_top(rabbit::VirtualMachine* v)
 		v->push(_array(o)->top());
 		return 1;
 	}
-	else return sq_throwerror(v,_SC("top() on a empty array"));
+	else return sq_throwerror(v,"top() on a empty array");
 }
 
 static int64_t array_insert(rabbit::VirtualMachine* v)
@@ -553,7 +553,7 @@ static int64_t array_insert(rabbit::VirtualMachine* v)
 	rabbit::Object &idx=stack_get(v,2);
 	rabbit::Object &val=stack_get(v,3);
 	if(!_array(o)->insert(tointeger(idx),val))
-		return sq_throwerror(v,_SC("index out of range"));
+		return sq_throwerror(v,"index out of range");
 	sq_pop(v,2);
 	return 1;
 }
@@ -562,14 +562,14 @@ static int64_t array_remove(rabbit::VirtualMachine* v)
 {
 	rabbit::Object &o = stack_get(v, 1);
 	rabbit::Object &idx = stack_get(v, 2);
-	if(!sq_isnumeric(idx)) return sq_throwerror(v, _SC("wrong type"));
+	if(!sq_isnumeric(idx)) return sq_throwerror(v, "wrong type");
 	rabbit::ObjectPtr val;
 	if(_array(o)->get(tointeger(idx), val)) {
 		_array(o)->remove(tointeger(idx));
 		v->push(val);
 		return 1;
 	}
-	return sq_throwerror(v, _SC("idx out of range"));
+	return sq_throwerror(v, "idx out of range");
 }
 
 static int64_t array_resize(rabbit::VirtualMachine* v)
@@ -580,7 +580,7 @@ static int64_t array_resize(rabbit::VirtualMachine* v)
 	if(sq_isnumeric(nsize)) {
 		int64_t sz = tointeger(nsize);
 		if (sz<0)
-		  return sq_throwerror(v, _SC("resizing to negative length"));
+		  return sq_throwerror(v, "resizing to negative length");
 
 		if(sq_gettop(v) > 2)
 			fill = stack_get(v, 3);
@@ -588,7 +588,7 @@ static int64_t array_resize(rabbit::VirtualMachine* v)
 		sq_settop(v, 1);
 		return 1;
 	}
-	return sq_throwerror(v, _SC("size must be a number"));
+	return sq_throwerror(v, "size must be a number");
 }
 
 static int64_t __map_array(rabbit::Array *dest,rabbit::Array *src,rabbit::VirtualMachine* v) {
@@ -711,11 +711,11 @@ static bool _sort_compare(rabbit::VirtualMachine* v,rabbit::ObjectPtr &a,rabbit:
 		v->push(b);
 		if(SQ_FAILED(sq_call(v, 3, SQTrue, SQFalse))) {
 			if(!sq_isstring( v->_lasterror))
-				v->raise_error(_SC("compare func failed"));
+				v->raise_error("compare func failed");
 			return false;
 		}
 		if(SQ_FAILED(sq_getinteger(v, -1, &ret))) {
-			v->raise_error(_SC("numeric value expected as return value of the compare function"));
+			v->raise_error("numeric value expected as return value of the compare function");
 			return false;
 		}
 		sq_settop(v, top);
@@ -750,7 +750,7 @@ static bool _hsort_sift_down(rabbit::VirtualMachine* v,rabbit::Array *arr, int64
 			return false;
 		if (ret < 0) {
 			if (root == maxChild) {
-				v->raise_error(_SC("inconsistent compare function"));
+				v->raise_error("inconsistent compare function");
 				return false; // We'd be swapping ourselve. The compare function is incorrect
 			}
 
@@ -803,8 +803,8 @@ static int64_t array_slice(rabbit::VirtualMachine* v)
 	int64_t alen = _array(o)->size();
 	if(sidx < 0)sidx = alen + sidx;
 	if(eidx < 0)eidx = alen + eidx;
-	if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes"));
-	if(eidx > alen || sidx < 0)return sq_throwerror(v, _SC("slice out of range"));
+	if(eidx < sidx)return sq_throwerror(v,"wrong indexes");
+	if(eidx > alen || sidx < 0)return sq_throwerror(v, "slice out of range");
 	rabbit::Array *arr=rabbit::Array::create(_get_shared_state(v),eidx-sidx);
 	rabbit::ObjectPtr t;
 	int64_t count=0;
@@ -818,26 +818,26 @@ static int64_t array_slice(rabbit::VirtualMachine* v)
 }
 
 const rabbit::RegFunction rabbit::SharedState::_array_default_delegate_funcz[]={
-	{_SC("len"),default_delegate_len,1, _SC("a")},
-	{_SC("append"),array_append,2, _SC("a")},
-	{_SC("extend"),array_extend,2, _SC("aa")},
-	{_SC("push"),array_append,2, _SC("a")},
-	{_SC("pop"),array_pop,1, _SC("a")},
-	{_SC("top"),array_top,1, _SC("a")},
-	{_SC("insert"),array_insert,3, _SC("an")},
-	{_SC("remove"),array_remove,2, _SC("an")},
-	{_SC("resize"),array_resize,-2, _SC("an")},
-	{_SC("reverse"),array_reverse,1, _SC("a")},
-	{_SC("sort"),array_sort,-1, _SC("ac")},
-	{_SC("slice"),array_slice,-1, _SC("ann")},
-	{_SC("weakref"),obj_delegate_weakref,1, NULL },
-	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
-	{_SC("clear"),obj_clear,1, _SC(".")},
-	{_SC("map"),array_map,2, _SC("ac")},
-	{_SC("apply"),array_apply,2, _SC("ac")},
-	{_SC("reduce"),array_reduce,2, _SC("ac")},
-	{_SC("filter"),array_filter,2, _SC("ac")},
-	{_SC("find"),array_find,2, _SC("a.")},
+	{"len",default_delegate_len,1, "a"},
+	{"append",array_append,2, "a"},
+	{"extend",array_extend,2, "aa"},
+	{"push",array_append,2, "a"},
+	{"pop",array_pop,1, "a"},
+	{"top",array_top,1, "a"},
+	{"insert",array_insert,3, "an"},
+	{"remove",array_remove,2, "an"},
+	{"resize",array_resize,-2, "an"},
+	{"reverse",array_reverse,1, "a"},
+	{"sort",array_sort,-1, "ac"},
+	{"slice",array_slice,-1, "ann"},
+	{"weakref",obj_delegate_weakref,1, NULL },
+	{"tostring",default_delegate_tostring,1, "."},
+	{"clear",obj_clear,1, "."},
+	{"map",array_map,2, "ac"},
+	{"apply",array_apply,2, "ac"},
+	{"reduce",array_reduce,2, "ac"},
+	{"filter",array_filter,2, "ac"},
+	{"find",array_find,2, "a."},
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
@@ -850,8 +850,8 @@ static int64_t string_slice(rabbit::VirtualMachine* v)
 	int64_t slen = _string(o)->_len;
 	if(sidx < 0)sidx = slen + sidx;
 	if(eidx < 0)eidx = slen + eidx;
-	if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes"));
-	if(eidx > slen || sidx < 0) return sq_throwerror(v, _SC("slice out of range"));
+	if(eidx < sidx) return sq_throwerror(v,"wrong indexes");
+	if(eidx > slen || sidx < 0) return sq_throwerror(v, "slice out of range");
 	v->push(rabbit::String::create(_get_shared_state(v),&_stringval(o)[sidx],eidx-sidx));
 	return 1;
 }
@@ -871,7 +871,7 @@ static int64_t string_find(rabbit::VirtualMachine* v)
 		}
 		return 0;
 	}
-	return sq_throwerror(v,_SC("invalid param"));
+	return sq_throwerror(v,"invalid param");
 }
 
 #define STRING_TOFUNCZ(func) static int64_t string_##func(rabbit::VirtualMachine* v) \
@@ -882,8 +882,8 @@ static int64_t string_find(rabbit::VirtualMachine* v)
 	int64_t slen = _string(str)->_len; \
 	if(sidx < 0)sidx = slen + sidx; \
 	if(eidx < 0)eidx = slen + eidx; \
-	if(eidx < sidx) return sq_throwerror(v,_SC("wrong indexes")); \
-	if(eidx > slen || sidx < 0) return sq_throwerror(v,_SC("slice out of range")); \
+	if(eidx < sidx) return sq_throwerror(v,"wrong indexes"); \
+	if(eidx > slen || sidx < 0) return sq_throwerror(v,"slice out of range"); \
 	int64_t len=_string(str)->_len; \
 	const char *sthis=_stringval(str); \
 	char *snew=(_get_shared_state(v)->getScratchPad(sq_rsl(len))); \
@@ -898,25 +898,25 @@ STRING_TOFUNCZ(tolower)
 STRING_TOFUNCZ(toupper)
 
 const rabbit::RegFunction rabbit::SharedState::_string_default_delegate_funcz[]={
-	{_SC("len"),default_delegate_len,1, _SC("s")},
-	{_SC("tointeger"),default_delegate_tointeger,-1, _SC("sn")},
-	{_SC("tofloat"),default_delegate_tofloat,1, _SC("s")},
-	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
-	{_SC("slice"),string_slice,-1, _SC("s n  n")},
-	{_SC("find"),string_find,-2, _SC("s s n")},
-	{_SC("tolower"),string_tolower,-1, _SC("s n n")},
-	{_SC("toupper"),string_toupper,-1, _SC("s n n")},
-	{_SC("weakref"),obj_delegate_weakref,1, NULL },
+	{"len",default_delegate_len,1, "s"},
+	{"tointeger",default_delegate_tointeger,-1, "sn"},
+	{"tofloat",default_delegate_tofloat,1, "s"},
+	{"tostring",default_delegate_tostring,1, "."},
+	{"slice",string_slice,-1, "s n  n"},
+	{"find",string_find,-2, "s s n"},
+	{"tolower",string_tolower,-1, "s n n"},
+	{"toupper",string_toupper,-1, "s n n"},
+	{"weakref",obj_delegate_weakref,1, NULL },
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
 //INTEGER DEFAULT DELEGATE//////////////////////////
 const rabbit::RegFunction rabbit::SharedState::_number_default_delegate_funcz[]={
-	{_SC("tointeger"),default_delegate_tointeger,1, _SC("n|b")},
-	{_SC("tofloat"),default_delegate_tofloat,1, _SC("n|b")},
-	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
-	{_SC("tochar"),number_delegate_tochar,1, _SC("n|b")},
-	{_SC("weakref"),obj_delegate_weakref,1, NULL },
+	{"tointeger",default_delegate_tointeger,1, "n|b"},
+	{"tofloat",default_delegate_tofloat,1, "n|b"},
+	{"tostring",default_delegate_tostring,1, "."},
+	{"tochar",number_delegate_tochar,1, "n|b"},
+	{"weakref",obj_delegate_weakref,1, NULL },
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
@@ -991,20 +991,20 @@ static int64_t closure_getinfos(rabbit::VirtualMachine* v) {
 			_array(defparams)->set((int64_t)j,_closure(o)->_defaultparams[j]);
 		}
 		if(f->_varparams) {
-			_array(params)->set(nparams-1,rabbit::String::create(_get_shared_state(v),_SC("..."),-1));
+			_array(params)->set(nparams-1,rabbit::String::create(_get_shared_state(v),"...",-1));
 		}
-		res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("native"),-1),false);
-		res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("name"),-1),f->_name);
-		res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("src"),-1),f->_sourcename);
-		res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("parameters"),-1),params);
-		res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("varargs"),-1),f->_varparams);
-	res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("defparams"),-1),defparams);
+		res->newSlot(rabbit::String::create(_get_shared_state(v),"native",-1),false);
+		res->newSlot(rabbit::String::create(_get_shared_state(v),"name",-1),f->_name);
+		res->newSlot(rabbit::String::create(_get_shared_state(v),"src",-1),f->_sourcename);
+		res->newSlot(rabbit::String::create(_get_shared_state(v),"parameters",-1),params);
+		res->newSlot(rabbit::String::create(_get_shared_state(v),"varargs",-1),f->_varparams);
+	res->newSlot(rabbit::String::create(_get_shared_state(v),"defparams",-1),defparams);
 	}
 	else { //rabbit::OT_NATIVECLOSURE
 		rabbit::NativeClosure *nc = _nativeclosure(o);
-		res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("native"),-1),true);
-		res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("name"),-1),nc->_name);
-		res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("paramscheck"),-1),nc->_nparamscheck);
+		res->newSlot(rabbit::String::create(_get_shared_state(v),"native",-1),true);
+		res->newSlot(rabbit::String::create(_get_shared_state(v),"name",-1),nc->_name);
+		res->newSlot(rabbit::String::create(_get_shared_state(v),"paramscheck",-1),nc->_nparamscheck);
 		rabbit::ObjectPtr typecheck;
 		if(nc->_typecheck.size() > 0) {
 			typecheck =
@@ -1013,7 +1013,7 @@ static int64_t closure_getinfos(rabbit::VirtualMachine* v) {
 					_array(typecheck)->set((int64_t)n,nc->_typecheck[n]);
 			}
 		}
-		res->newSlot(rabbit::String::create(_get_shared_state(v),_SC("typecheck"),-1),typecheck);
+		res->newSlot(rabbit::String::create(_get_shared_state(v),"typecheck",-1),typecheck);
 	}
 	v->push(res);
 	return 1;
@@ -1022,16 +1022,16 @@ static int64_t closure_getinfos(rabbit::VirtualMachine* v) {
 
 
 const rabbit::RegFunction rabbit::SharedState::_closure_default_delegate_funcz[]={
-	{_SC("call"),closure_call,-1, _SC("c")},
-	{_SC("pcall"),closure_pcall,-1, _SC("c")},
-	{_SC("acall"),closure_acall,2, _SC("ca")},
-	{_SC("pacall"),closure_pacall,2, _SC("ca")},
-	{_SC("weakref"),obj_delegate_weakref,1, NULL },
-	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
-	{_SC("bindenv"),closure_bindenv,2, _SC("c x|y|t")},
-	{_SC("getinfos"),closure_getinfos,1, _SC("c")},
-	{_SC("getroot"),closure_getroot,1, _SC("c")},
-	{_SC("setroot"),closure_setroot,2, _SC("ct")},
+	{"call",closure_call,-1, "c"},
+	{"pcall",closure_pcall,-1, "c"},
+	{"acall",closure_acall,2, "ca"},
+	{"pacall",closure_pacall,2, "ca"},
+	{"weakref",obj_delegate_weakref,1, NULL },
+	{"tostring",default_delegate_tostring,1, "."},
+	{"bindenv",closure_bindenv,2, "c x|y|t"},
+	{"getinfos",closure_getinfos,1, "c"},
+	{"getroot",closure_getroot,1, "c"},
+	{"setroot",closure_setroot,2, "ct"},
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
@@ -1040,17 +1040,17 @@ static int64_t generator_getstatus(rabbit::VirtualMachine* v)
 {
 	rabbit::Object &o=stack_get(v,1);
 	switch(_generator(o)->_state){
-		case rabbit::Generator::eSuspended:v->push(rabbit::String::create(_get_shared_state(v),_SC("suspended")));break;
-		case rabbit::Generator::eRunning:v->push(rabbit::String::create(_get_shared_state(v),_SC("running")));break;
-		case rabbit::Generator::eDead:v->push(rabbit::String::create(_get_shared_state(v),_SC("dead")));break;
+		case rabbit::Generator::eSuspended:v->push(rabbit::String::create(_get_shared_state(v),"suspended"));break;
+		case rabbit::Generator::eRunning:v->push(rabbit::String::create(_get_shared_state(v),"running"));break;
+		case rabbit::Generator::eDead:v->push(rabbit::String::create(_get_shared_state(v),"dead"));break;
 	}
 	return 1;
 }
 
 const rabbit::RegFunction rabbit::SharedState::_generator_default_delegate_funcz[]={
-	{_SC("getstatus"),generator_getstatus,1, _SC("g")},
-	{_SC("weakref"),obj_delegate_weakref,1, NULL },
-	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
+	{"getstatus",generator_getstatus,1, "g"},
+	{"weakref",obj_delegate_weakref,1, NULL },
+	{"tostring",default_delegate_tostring,1, "."},
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
@@ -1071,7 +1071,7 @@ static int64_t thread_call(rabbit::VirtualMachine* v)
 		v->_lasterror = _thread(o)->_lasterror;
 		return SQ_ERROR;
 	}
-	return sq_throwerror(v,_SC("wrong parameter"));
+	return sq_throwerror(v,"wrong parameter");
 }
 
 static int64_t thread_wakeup(rabbit::VirtualMachine* v)
@@ -1083,10 +1083,10 @@ static int64_t thread_wakeup(rabbit::VirtualMachine* v)
 		if(state != SQ_VMSTATE_SUSPENDED) {
 			switch(state) {
 				case SQ_VMSTATE_IDLE:
-					return sq_throwerror(v,_SC("cannot wakeup a idle thread"));
+					return sq_throwerror(v,"cannot wakeup a idle thread");
 				break;
 				case SQ_VMSTATE_RUNNING:
-					return sq_throwerror(v,_SC("cannot wakeup a running thread"));
+					return sq_throwerror(v,"cannot wakeup a running thread");
 				break;
 			}
 		}
@@ -1107,7 +1107,7 @@ static int64_t thread_wakeup(rabbit::VirtualMachine* v)
 		v->_lasterror = thread->_lasterror;
 		return SQ_ERROR;
 	}
-	return sq_throwerror(v,_SC("wrong parameter"));
+	return sq_throwerror(v,"wrong parameter");
 }
 
 static int64_t thread_wakeupthrow(rabbit::VirtualMachine* v)
@@ -1119,10 +1119,10 @@ static int64_t thread_wakeupthrow(rabbit::VirtualMachine* v)
 		if(state != SQ_VMSTATE_SUSPENDED) {
 			switch(state) {
 				case SQ_VMSTATE_IDLE:
-					return sq_throwerror(v,_SC("cannot wakeup a idle thread"));
+					return sq_throwerror(v,"cannot wakeup a idle thread");
 				break;
 				case SQ_VMSTATE_RUNNING:
-					return sq_throwerror(v,_SC("cannot wakeup a running thread"));
+					return sq_throwerror(v,"cannot wakeup a running thread");
 				break;
 			}
 		}
@@ -1148,7 +1148,7 @@ static int64_t thread_wakeupthrow(rabbit::VirtualMachine* v)
 		}
 		return SQ_OK;
 	}
-	return sq_throwerror(v,_SC("wrong parameter"));
+	return sq_throwerror(v,"wrong parameter");
 }
 
 static int64_t thread_getstatus(rabbit::VirtualMachine* v)
@@ -1156,16 +1156,16 @@ static int64_t thread_getstatus(rabbit::VirtualMachine* v)
 	rabbit::ObjectPtr &o = stack_get(v,1);
 	switch(sq_getvmstate(_thread(o))) {
 		case SQ_VMSTATE_IDLE:
-			sq_pushstring(v,_SC("idle"),-1);
+			sq_pushstring(v,"idle",-1);
 		break;
 		case SQ_VMSTATE_RUNNING:
-			sq_pushstring(v,_SC("running"),-1);
+			sq_pushstring(v,"running",-1);
 		break;
 		case SQ_VMSTATE_SUSPENDED:
-			sq_pushstring(v,_SC("suspended"),-1);
+			sq_pushstring(v,"suspended",-1);
 		break;
 		default:
-			return sq_throwerror(v,_SC("internal VM error"));
+			return sq_throwerror(v,"internal VM error");
 	}
 	return 1;
 }
@@ -1186,7 +1186,7 @@ static int64_t thread_getstackinfos(rabbit::VirtualMachine* v)
 				sq_throwerror(v,_stringval(thread->_lasterror));
 			}
 			else {
-				sq_throwerror(v,_SC("unknown error"));
+				sq_throwerror(v,"unknown error");
 			}
 		}
 		if(res > 0) {
@@ -1200,17 +1200,17 @@ static int64_t thread_getstackinfos(rabbit::VirtualMachine* v)
 		return 0;
 
 	}
-	return sq_throwerror(v,_SC("wrong parameter"));
+	return sq_throwerror(v,"wrong parameter");
 }
 
 const rabbit::RegFunction rabbit::SharedState::_thread_default_delegate_funcz[] = {
-	{_SC("call"), thread_call, -1, _SC("v")},
-	{_SC("wakeup"), thread_wakeup, -1, _SC("v")},
-	{_SC("wakeupthrow"), thread_wakeupthrow, -2, _SC("v.b")},
-	{_SC("getstatus"), thread_getstatus, 1, _SC("v")},
-	{_SC("weakref"),obj_delegate_weakref,1, NULL },
-	{_SC("getstackinfos"),thread_getstackinfos,2, _SC("vn")},
-	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
+	{"call", thread_call, -1, "v"},
+	{"wakeup", thread_wakeup, -1, "v"},
+	{"wakeupthrow", thread_wakeupthrow, -2, "v.b"},
+	{"getstatus", thread_getstatus, 1, "v"},
+	{"weakref",obj_delegate_weakref,1, NULL },
+	{"getstackinfos",thread_getstackinfos,2, "vn"},
+	{"tostring",default_delegate_tostring,1, "."},
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
@@ -1267,17 +1267,17 @@ static int64_t class_rawnewmember(rabbit::VirtualMachine* v)
 }
 
 const rabbit::RegFunction rabbit::SharedState::_class_default_delegate_funcz[] = {
-	{_SC("getattributes"), class_getattributes, 2, _SC("y.")},
-	{_SC("setattributes"), class_setattributes, 3, _SC("y..")},
-	{_SC("rawget"),container_rawget,2, _SC("y")},
-	{_SC("rawset"),container_rawset,3, _SC("y")},
-	{_SC("rawin"),container_rawexists,2, _SC("y")},
-	{_SC("weakref"),obj_delegate_weakref,1, NULL },
-	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
-	{_SC("instance"),class_instance,1, _SC("y")},
-	{_SC("getbase"),class_getbase,1, _SC("y")},
-	{_SC("newmember"),class_newmember,-3, _SC("y")},
-	{_SC("rawnewmember"),class_rawnewmember,-3, _SC("y")},
+	{"getattributes", class_getattributes, 2, "y."},
+	{"setattributes", class_setattributes, 3, "y.."},
+	{"rawget",container_rawget,2, "y"},
+	{"rawset",container_rawset,3, "y"},
+	{"rawin",container_rawexists,2, "y"},
+	{"weakref",obj_delegate_weakref,1, NULL },
+	{"tostring",default_delegate_tostring,1, "."},
+	{"instance",class_instance,1, "y"},
+	{"getbase",class_getbase,1, "y"},
+	{"newmember",class_newmember,-3, "y"},
+	{"rawnewmember",class_rawnewmember,-3, "y"},
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
@@ -1290,12 +1290,12 @@ static int64_t instance_getclass(rabbit::VirtualMachine* v)
 }
 
 const rabbit::RegFunction rabbit::SharedState::_instance_default_delegate_funcz[] = {
-	{_SC("getclass"), instance_getclass, 1, _SC("x")},
-	{_SC("rawget"),container_rawget,2, _SC("x")},
-	{_SC("rawset"),container_rawset,3, _SC("x")},
-	{_SC("rawin"),container_rawexists,2, _SC("x")},
-	{_SC("weakref"),obj_delegate_weakref,1, NULL },
-	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
+	{"getclass", instance_getclass, 1, "x"},
+	{"rawget",container_rawget,2, "x"},
+	{"rawset",container_rawset,3, "x"},
+	{"rawin",container_rawexists,2, "x"},
+	{"weakref",obj_delegate_weakref,1, NULL },
+	{"tostring",default_delegate_tostring,1, "."},
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
@@ -1307,8 +1307,8 @@ static int64_t weakref_ref(rabbit::VirtualMachine* v)
 }
 
 const rabbit::RegFunction rabbit::SharedState::_weakref_default_delegate_funcz[] = {
-	{_SC("ref"),weakref_ref,1, _SC("r")},
-	{_SC("weakref"),obj_delegate_weakref,1, NULL },
-	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
+	{"ref",weakref_ref,1, "r"},
+	{"weakref",obj_delegate_weakref,1, NULL },
+	{"tostring",default_delegate_tostring,1, "."},
 	{NULL,(SQFUNCTION)0,0,NULL}
 };
diff --git a/rabbit/sqconfig.hpp b/rabbit/sqconfig.hpp
index dc08b06..77f9776 100644
--- a/rabbit/sqconfig.hpp
+++ b/rabbit/sqconfig.hpp
@@ -41,8 +41,8 @@ namespace rabbit {
 
 #define sq_rsl(l) (l)
 
-#define _PRINT_INT_PREC _SC("ll")
-#define _PRINT_INT_FMT _SC("%ld")
+#define _PRINT_INT_PREC "ll"
+#define _PRINT_INT_FMT "%ld"
 
 #define SQTrue  (1)
 #define SQFalse (0)
@@ -54,9 +54,6 @@ namespace rabbit {
 #define UINT_MINUS_ONE (0xFFFFFFFF)
 #endif
 
-#define _SC(a) a
-
-
 namespace rabbit {
 	class UserData;
 	class Array;
diff --git a/rabbit/sqdebug.cpp b/rabbit/sqdebug.cpp
index 4554423..9cbaf5f 100644
--- a/rabbit/sqdebug.cpp
+++ b/rabbit/sqdebug.cpp
@@ -31,13 +31,13 @@ rabbit::Result rabbit::sq_getfunctioninfo(rabbit::VirtualMachine* v,int64_t leve
 			rabbit::Closure *c = _closure(ci._closure);
 			rabbit::FunctionProto *proto = c->_function;
 			fi->funcid = proto;
-			fi->name = sq_type(proto->_name) == rabbit::OT_STRING?_stringval(proto->_name):_SC("unknown");
-			fi->source = sq_type(proto->_sourcename) == rabbit::OT_STRING?_stringval(proto->_sourcename):_SC("unknown");
+			fi->name = sq_type(proto->_name) == rabbit::OT_STRING?_stringval(proto->_name):"unknown";
+			fi->source = sq_type(proto->_sourcename) == rabbit::OT_STRING?_stringval(proto->_sourcename):"unknown";
 			fi->line = proto->_lineinfos[0]._line;
 			return SQ_OK;
 		}
 	}
-	return sq_throwerror(v,_SC("the object is not a closure"));
+	return sq_throwerror(v,"the object is not a closure");
 }
 
 rabbit::Result rabbit::sq_stackinfos(rabbit::VirtualMachine* v, int64_t level, rabbit::StackInfos *si)
@@ -57,8 +57,8 @@ rabbit::Result rabbit::sq_stackinfos(rabbit::VirtualMachine* v, int64_t level, r
 						}
 			break;
 		case rabbit::OT_NATIVECLOSURE:
-			si->source = _SC("NATIVE");
-			si->funcname = _SC("unknown");
+			si->source = "NATIVE";
+			si->funcname = "unknown";
 			if(sq_type(_nativeclosure(ci._closure)->_name) == rabbit::OT_STRING)
 				si->funcname = _stringval(_nativeclosure(ci._closure)->_name);
 			si->line = -1;
@@ -94,7 +94,7 @@ rabbit::String *rabbit::VirtualMachine::printObjVal(const rabbit::ObjectPtr &o)
 		return rabbit::String::create(_get_shared_state(this), _spval);
 		break;
 	case rabbit::OT_FLOAT:
-		snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)), sq_rsl(NUMBER_UINT8_MAX), _SC("%.14g"), _float(o));
+		snprintf(_sp(sq_rsl(NUMBER_UINT8_MAX+1)), sq_rsl(NUMBER_UINT8_MAX), "%.14g", _float(o));
 		return rabbit::String::create(_get_shared_state(this), _spval);
 		break;
 	default:
@@ -105,28 +105,28 @@ rabbit::String *rabbit::VirtualMachine::printObjVal(const rabbit::ObjectPtr &o)
 void rabbit::VirtualMachine::raise_Idxerror(const rabbit::ObjectPtr &o)
 {
 	rabbit::ObjectPtr oval = printObjVal(o);
-	raise_error(_SC("the index '%.50s' does not exist"), _stringval(oval));
+	raise_error("the index '%.50s' does not exist", _stringval(oval));
 }
 
 void rabbit::VirtualMachine::raise_Compareerror(const rabbit::Object &o1, const rabbit::Object &o2)
 {
 	rabbit::ObjectPtr oval1 = printObjVal(o1), oval2 = printObjVal(o2);
-	raise_error(_SC("comparison between '%.50s' and '%.50s'"), _stringval(oval1), _stringval(oval2));
+	raise_error("comparison between '%.50s' and '%.50s'", _stringval(oval1), _stringval(oval2));
 }
 
 
 void rabbit::VirtualMachine::raise_ParamTypeerror(int64_t nparam,int64_t typemask,int64_t type)
 {
-	rabbit::ObjectPtr exptypes = rabbit::String::create(_get_shared_state(this), _SC(""), -1);
+	rabbit::ObjectPtr exptypes = rabbit::String::create(_get_shared_state(this), "", -1);
 	int64_t found = 0;
 	for(int64_t i=0; i<16; i++)
 	{
 		int64_t mask = ((int64_t)1) << i;
 		if(typemask & (mask)) {
-			if(found>0) stringCat(exptypes,rabbit::String::create(_get_shared_state(this), _SC("|"), -1), exptypes);
+			if(found>0) stringCat(exptypes,rabbit::String::create(_get_shared_state(this), "|", -1), exptypes);
 			found ++;
 			stringCat(exptypes,rabbit::String::create(_get_shared_state(this), IdType2Name((rabbit::ObjectType)mask), -1), exptypes);
 		}
 	}
-	raise_error(_SC("parameter %d has an invalid type '%s' ; expected: '%s'"), nparam, IdType2Name((rabbit::ObjectType)type), _stringval(exptypes));
+	raise_error("parameter %d has an invalid type '%s' ; expected: '%s'", nparam, IdType2Name((rabbit::ObjectType)type), _stringval(exptypes));
 }