Update with squirrel, spaces/tabs changed

SquiLu/etc/minimal.c

@@ -1,78 +1,78 @@
-#include <stdarg.h> 
-#include <stdio.h> 
+#include <stdarg.h>
+#include <stdio.h>
 
-#include <squirrel.h> 
-#include <sqstdio.h> 
-#include <sqstdaux.h> 
+#include <squirrel.h>
+#include <sqstdio.h>
+#include <sqstdaux.h>
 
 #ifdef _MSC_VER
 #pragma comment (lib ,"squirrel.lib")
 #pragma comment (lib ,"sqstdlib.lib")
 #endif
 
-#ifdef SQUNICODE 
+#ifdef SQUNICODE
 
 #define scvprintf vfwprintf
-#else 
+#else
 
 #define scvprintf vfprintf
-#endif 
+#endif
 
 void printfunc(HSQUIRRELVM v,const SQChar *s,...)
 {
-	va_list vl;
-	va_start(vl, s);
-	scvprintf(stdout, s, vl);
-	va_end(vl);
+    va_list vl;
+    va_start(vl, s);
+    scvprintf(stdout, s, vl);
+    va_end(vl);
 }
 
 void errorfunc(HSQUIRRELVM v,const SQChar *s,...)
 {
-	va_list vl;
-	va_start(vl, s);
-	scvprintf(stderr, s, vl);
-	va_end(vl);
+    va_list vl;
+    va_start(vl, s);
+    scvprintf(stderr, s, vl);
+    va_end(vl);
 }
 
 void call_foo(HSQUIRRELVM v, int n,float f,const SQChar *s)
 {
-	SQInteger top = sq_gettop(v); //saves the stack size before the call
-	sq_pushroottable(v); //pushes the global table
-	sq_pushstring(v,_SC("foo"),-1);
-	if(SQ_SUCCEEDED(sq_get(v,-2))) { //gets the field 'foo' from the global table
-		sq_pushroottable(v); //push the 'this' (in this case is the global table)
-		sq_pushinteger(v,n); 
-		sq_pushfloat(v,f);
-		sq_pushstring(v,s,-1);
-		sq_call(v,4,SQFalse,SQTrue); //calls the function 
-	}
-	sq_settop(v,top); //restores the original stack size
+    SQInteger top = sq_gettop(v); //saves the stack size before the call
+    sq_pushroottable(v); //pushes the global table
+    sq_pushstring(v,_SC("foo"),-1);
+    if(SQ_SUCCEEDED(sq_get(v,-2))) { //gets the field 'foo' from the global table
+        sq_pushroottable(v); //push the 'this' (in this case is the global table)
+        sq_pushinteger(v,n);
+        sq_pushfloat(v,f);
+        sq_pushstring(v,s,-1);
+        sq_call(v,4,SQFalse,SQTrue); //calls the function
+    }
+    sq_settop(v,top); //restores the original stack size
 }
 
-int main(int argc, char* argv[]) 
-{ 
-	HSQUIRRELVM v; 
-	v = sq_open(1024); // creates a VM with initial stack size 1024 
+int main(int argc, char* argv[])
+{
+    HSQUIRRELVM v;
+    v = sq_open(1024); // creates a VM with initial stack size 1024
+
+    //REGISTRATION OF STDLIB
+    //sq_pushroottable(v); //push the root table where the std function will be registered
+    //sqstd_register_iolib(v);  //registers a library
+    // ... call here other stdlibs string,math etc...
+    //sq_pop(v,1); //pops the root table
+    //END REGISTRATION OF STDLIB
 
-	//REGISTRATION OF STDLIB
-	//sq_pushroottable(v); //push the root table where the std function will be registered
-	//sqstd_register_iolib(v);  //registers a library
-	// ... call here other stdlibs string,math etc...
-	//sq_pop(v,1); //pops the root table
-	//END REGISTRATION OF STDLIB
-	
-	sqstd_seterrorhandlers(v); //registers the default error handlers
+    sqstd_seterrorhandlers(v); //registers the default error handlers
 
-	sq_setprintfunc(v, printfunc,errorfunc); //sets the print function
+    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(sqstd_dofile(v, _SC("test.nut"), SQFalse, SQTrue))) // also prints syntax errors if any 
-	{
-		call_foo(v,1,2.5,_SC("teststring"));
-	}
+    sq_pushroottable(v); //push the root table(were the globals of the script will be stored)
+    if(SQ_SUCCEEDED(sqstd_dofile(v, _SC("test.nut"), SQFalse, SQTrue))) // also prints syntax errors if any
+    {
+        call_foo(v,1,2.5,_SC("teststring"));
+    }
 
-	sq_pop(v,1); //pops the root table
-	sq_close(v); 
+    sq_pop(v,1); //pops the root table
+    sq_close(v);
 
-	return 0; 
-} 
+    return 0;
+}

SquiLu/include/sqconfig.h

@@ -1,6 +1,9 @@
 
 #ifdef _SQ64
 
+typedef short SQInt16;
+typedef unsigned short SQUnsignedInt16;
+
 #ifdef _MSC_VER
 typedef __int64 SQInteger;
 typedef unsigned __int64 SQUnsignedInteger;
@@ -17,7 +20,9 @@ typedef int SQInteger;
 typedef int SQInt32; /*must be 32 bits(also on 64bits processors)*/
 typedef unsigned int SQUnsignedInteger32; /*must be 32 bits(also on 64bits processors)*/
 typedef unsigned int SQUnsignedInteger;
-typedef unsigned int SQHash; /*should be the same size of a pointer*/
+typedef short SQInt16;
+typedef unsigned short SQUnsignedInt16;
+typedef unsigned int /*ptrdiff_t*/ SQHash; /*should be the same size of a pointer*/
 #endif
 
 

SquiLu/include/squirrel.h

@@ -30,7 +30,7 @@ extern "C" {
 #include <stdarg.h>
 
 #ifndef SQUIRREL_API
-#define SQUIRREL_API extern
+#define SQUIRREL_API extern //__attribute__ ((visibility ("default")))
 #endif
 
 #if (defined(_WIN64) || defined(_LP64))
@@ -122,10 +122,10 @@ struct SQOuter;
 
 #include "sqconfig.h"
 
-#define SQUIRREL_VERSION	_SC("SquiLu based on Squirrel 3.0.4 stable and Lua 5.1.5")
-#define SQUIRREL_COPYRIGHT	_SC("Copyright (C) 2003-2012 Alberto Demichelis, Domingo Alvarez Duarte")
+#define SQUIRREL_VERSION	_SC("SquiLu based on Squirrel 3.1 stable and Lua 5.1.5")
+#define SQUIRREL_COPYRIGHT	_SC("Copyright (C) 2003-2016 Alberto Demichelis, Domingo Alvarez Duarte")
 #define SQUIRREL_AUTHOR		_SC("Alberto Demichelis, Domingo Alvarez Duarte")
-#define SQUIRREL_VERSION_NUMBER	304
+#define SQUIRREL_VERSION_NUMBER	310
 
 #define SQ_VMSTATE_IDLE			0
 #define SQ_VMSTATE_RUNNING		1
@@ -274,6 +274,12 @@ SQUIRREL_API SQRESULT sq_getatexithandler(HSQUIRRELVM v);
 SQUIRREL_API void sq_close(HSQUIRRELVM v);
 SQUIRREL_API void sq_setforeignptr(HSQUIRRELVM v,SQUserPointer p);
 SQUIRREL_API SQUserPointer sq_getforeignptr(HSQUIRRELVM v);
+SQUIRREL_API void sq_setsharedforeignptr(HSQUIRRELVM v,SQUserPointer p);
+SQUIRREL_API SQUserPointer sq_getsharedforeignptr(HSQUIRRELVM v);
+SQUIRREL_API void sq_setvmreleasehook(HSQUIRRELVM v,SQRELEASEHOOK hook);
+SQUIRREL_API SQRELEASEHOOK sq_getvmreleasehook(HSQUIRRELVM v);
+SQUIRREL_API void sq_setsharedreleasehook(HSQUIRRELVM v,SQRELEASEHOOK hook);
+SQUIRREL_API SQRELEASEHOOK sq_getsharedreleasehook(HSQUIRRELVM v);
 SQUIRREL_API void sq_setprintfunc(HSQUIRRELVM v, SQPRINTFUNCTION printfunc,SQPRINTFUNCTION errfunc);
 SQUIRREL_API SQPRINTFUNCTION sq_getprintfunc(HSQUIRRELVM v);
 SQUIRREL_API SQPRINTFUNCTION sq_geterrorfunc(HSQUIRRELVM v);
@@ -315,6 +321,8 @@ SQUIRREL_API SQRESULT sq_setparamscheck(HSQUIRRELVM v,SQInteger nparamscheck,con
 SQUIRREL_API SQRESULT sq_setfenv(HSQUIRRELVM v,SQInteger idx, SQBool cloning);
 SQUIRREL_API SQRESULT sq_getfenv(HSQUIRRELVM v,SQInteger idx, SQBool roottable_when_null);
 SQUIRREL_API SQRESULT sq_bindenv(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_setclosureroot(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_getclosureroot(HSQUIRRELVM v,SQInteger idx);
 SQUIRREL_API void sq_pushstring(HSQUIRRELVM v,const SQChar *s,SQInteger len);
 SQUIRREL_API void sq_pushfstring(HSQUIRRELVM v,const SQChar *fmt, ...);
 SQUIRREL_API void sq_pushfloat(HSQUIRRELVM v,SQFloat f);
@@ -322,6 +330,7 @@ SQUIRREL_API void sq_pushinteger(HSQUIRRELVM v,SQInteger n);
 SQUIRREL_API void sq_pushbool(HSQUIRRELVM v,SQBool b);
 SQUIRREL_API void sq_pushuserpointer(HSQUIRRELVM v,SQUserPointer p);
 SQUIRREL_API void sq_pushnull(HSQUIRRELVM v);
+SQUIRREL_API void sq_pushthread(HSQUIRRELVM v, HSQUIRRELVM thread);
 SQUIRREL_API SQRESULT sq_checkoption (HSQUIRRELVM v, SQInteger narg, const SQChar *def,
                                  const SQChar *const lst[]);
 SQUIRREL_API SQObjectType sq_gettype(HSQUIRRELVM v,SQInteger idx);
@@ -346,6 +355,7 @@ SQUIRREL_API SQRESULT sq_getuserdata(HSQUIRRELVM v,SQInteger idx,SQUserPointer *
 SQUIRREL_API SQRESULT sq_settypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer typetag);
 SQUIRREL_API SQRESULT sq_gettypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer *typetag);
 SQUIRREL_API void sq_setreleasehook(HSQUIRRELVM v,SQInteger idx,SQRELEASEHOOK hook);
+SQUIRREL_API SQRELEASEHOOK sq_getreleasehook(HSQUIRRELVM v,SQInteger idx);
 SQUIRREL_API SQChar *sq_getscratchpad(HSQUIRRELVM v,SQInteger minsize);
 SQUIRREL_API SQRESULT sq_getfunctioninfo(HSQUIRRELVM v,SQInteger level,SQFunctionInfo *fi);
 SQUIRREL_API SQRESULT sq_getclosureinfo(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger *nparams,SQUnsignedInteger *nfreevars);
@@ -373,14 +383,6 @@ SQUIRREL_API void sq_insert_reg_funcs(HSQUIRRELVM sqvm, SQRegFunction *obj_funcs
 SQUIRREL_API const SQChar *sq_optstring(HSQUIRRELVM sqvm, SQInteger idx, const SQChar *dflt, SQInteger *size);
 SQUIRREL_API SQRESULT sq_optinteger(HSQUIRRELVM sqvm, SQInteger idx, SQInteger *value, SQInteger default_value);
 
-/*object manipulation*/
-SQUIRREL_API void sq_pushroottable(HSQUIRRELVM v);
-SQUIRREL_API SQRESULT sq_getonroottable(HSQUIRRELVM v);
-SQUIRREL_API SQRESULT sq_setonroottable(HSQUIRRELVM v);
-SQUIRREL_API void sq_pushregistrytable(HSQUIRRELVM v);
-SQUIRREL_API SQRESULT sq_getonregistrytable(HSQUIRRELVM v);
-SQUIRREL_API SQRESULT sq_setonregistrytable(HSQUIRRELVM v);
-SQUIRREL_API SQRESULT sq_delete_on_registry_table(HSQUIRRELVM v, SQUserPointer uptr);
 
 #define SQ_EXTENSIONS_KEY _SC("sq__Extensions")
 typedef struct {
@@ -389,6 +391,14 @@ typedef struct {
 } sq_modules_preload_st;
 int sq_preload_modules(HSQUIRRELVM v, sq_modules_preload_st *modules);
 
+/*object manipulation*/
+SQUIRREL_API void sq_pushroottable(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_getonroottable(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_setonroottable(HSQUIRRELVM v);
+SQUIRREL_API void sq_pushregistrytable(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_getonregistrytable(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_setonregistrytable(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_delete_on_registry_table(HSQUIRRELVM v, SQUserPointer uptr);
 SQUIRREL_API void sq_pushconsttable(HSQUIRRELVM v);
 SQUIRREL_API SQRESULT sq_setroottable(HSQUIRRELVM v);
 SQUIRREL_API SQRESULT sq_setconsttable(HSQUIRRELVM v);
@@ -449,6 +459,8 @@ SQUIRREL_API SQInteger sq_objtointeger(const HSQOBJECT *o);
 SQUIRREL_API SQFloat sq_objtofloat(const HSQOBJECT *o);
 SQUIRREL_API SQUserPointer sq_objtouserpointer(const HSQOBJECT *o);
 SQUIRREL_API SQRESULT sq_getobjtypetag(const HSQOBJECT *o,SQUserPointer * typetag);
+SQUIRREL_API SQUnsignedInteger sq_getvmrefcount(HSQUIRRELVM v, const HSQOBJECT *po);
+
 
 /*GC*/
 SQUIRREL_API SQInteger sq_collectgarbage(HSQUIRRELVM v);
@@ -503,6 +515,12 @@ SQUIRREL_API void sq_getlaststackinfo(HSQUIRRELVM v);
 #define SQ_SUCCEEDED(res) (res>=0)
 #define SQ_RETURN_IF_ERROR(res) if(SQ_FAILED(res)) return res
 
+#ifdef __GNUC__
+# define SQ_UNUSED_ARG(x) __attribute__((unused)) x
+#else
+# define SQ_UNUSED_ARG(x) x
+#endif
+
 /*DAD*/
 #define SQ_FUNC_VARS(v) \
     SQRESULT _rc_; SQInteger _top_=sq_gettop(v);

SquiLu/sqstdlib/sqstdaux.cpp

@@ -1,18 +1,18 @@
-/* see copyright notice in squirrel.h */
-#include <squirrel.h>
-#include <sqstdaux.h>
-#include <assert.h>
-
-void sqstd_printcallstack(HSQUIRRELVM v)
-{
-	SQPRINTFUNCTION pf = sq_geterrorfunc(v);
-	if(pf) {
-		SQStackInfos si;
-		SQInteger i;
-		SQFloat f;
-		const SQChar *s;
-		SQInteger level=1; //1 is to skip this function that is level 0
-		const SQChar *name=0;
+/* see copyright notice in squirrel.h */
+#include <squirrel.h>
+#include <sqstdaux.h>
+#include <assert.h>
+
+void sqstd_printcallstack(HSQUIRRELVM v)
+{
+	SQPRINTFUNCTION pf = sq_geterrorfunc(v);
+	if(pf) {
+		SQStackInfos si;
+		SQInteger i;
+		SQFloat f;
+		const SQChar *s;
+		SQInteger level=1; //1 is to skip this function that is level 0
+		const SQChar *name=0;
 		SQInteger seq=0;
 		SQInteger max_str_size = 10 * 1024; //to not print long strings in stack trace
 		sq_pushliteral(v, _SC("__max_print_stack_str_size")); //can be overwritten at runtime
@@ -20,42 +20,42 @@ void sqstd_printcallstack(HSQUIRRELVM v)
 		{
 		    sq_getinteger(v, -1, &max_str_size);
 		    sq_poptop(v); //remove the result
-		}
-		pf(v,_SC("\nCALLSTACK\n"));
-		while(SQ_SUCCEEDED(sq_stackinfos(v,level,&si)))
-		{
-			const SQChar *fn=_SC("unknown");
-			const SQChar *src=_SC("unknown");
-			if(si.funcname)fn=si.funcname;
-			if(si.source)src=si.source;
-			pf(v,_SC("%s:%d:0 *FUNCTION [%s()]\n"),src,si.line,fn);
-			level++;
-		}
-		//level=0;
-		pf(v,_SC("\nLOCALS\n"));
-
-		for(level=0;level<10;level++){
-			seq=0;
-			while((name = sq_getlocal(v,level,seq)))
-			{
-				seq++;
-				switch(sq_gettype(v,-1))
-				{
-				case OT_NULL:
-					pf(v,_SC("[%s] NULL\n"),name);
-					break;
-				case OT_INTEGER:
-					sq_getinteger(v,-1,&i);
-					pf(v,_SC("[%s] %d\n"),name,i);
-					break;
-				case OT_FLOAT:
-					sq_getfloat(v,-1,&f);
-					pf(v,_SC("[%s] %.14g\n"),name,f);
-					break;
-				case OT_USERPOINTER:
-					pf(v,_SC("[%s] USERPOINTER\n"),name);
-					break;
-				case OT_STRING:
+		}
+		pf(v,_SC("\nCALLSTACK\n"));
+		while(SQ_SUCCEEDED(sq_stackinfos(v,level,&si)))
+		{
+			const SQChar *fn=_SC("unknown");
+			const SQChar *src=_SC("unknown");
+			if(si.funcname)fn=si.funcname;
+			if(si.source)src=si.source;
+			pf(v,_SC("%s:%d:0 *FUNCTION [%s()]\n"),src,si.line,fn);
+			level++;
+		}
+		//level=0;
+		pf(v,_SC("\nLOCALS\n"));
+
+		for(level=0;level<10;level++){
+			seq=0;
+			while((name = sq_getlocal(v,level,seq)))
+			{
+				seq++;
+				switch(sq_gettype(v,-1))
+				{
+				case OT_NULL:
+					pf(v,_SC("[%s] NULL\n"),name);
+					break;
+				case OT_INTEGER:
+					sq_getinteger(v,-1,&i);
+					pf(v,_SC("[%s] %d\n"),name,i);
+					break;
+				case OT_FLOAT:
+					sq_getfloat(v,-1,&f);
+					pf(v,_SC("[%s] %.14g\n"),name,f);
+					break;
+				case OT_USERPOINTER:
+					pf(v,_SC("[%s] USERPOINTER\n"),name);
+					break;
+				case OT_STRING:
 					sq_getstring(v,-1,&s);
 					if(sq_getsize(v, -1) > max_str_size)
 					{
@@ -64,82 +64,82 @@ void sqstd_printcallstack(HSQUIRRELVM v)
 					else
 					{
 						pf(v,_SC("[%s] \"%s\"\n"), name, s);
-					}
-					break;
-				case OT_TABLE:
-					pf(v,_SC("[%s] TABLE\n"),name);
-					break;
-				case OT_ARRAY:
-					pf(v,_SC("[%s] ARRAY\n"),name);
-					break;
-				case OT_CLOSURE:
-					pf(v,_SC("[%s] CLOSURE\n"),name);
-					break;
-				case OT_NATIVECLOSURE:
-					pf(v,_SC("[%s] NATIVECLOSURE\n"),name);
-					break;
-				case OT_GENERATOR:
-					pf(v,_SC("[%s] GENERATOR\n"),name);
-					break;
-				case OT_USERDATA:
-					pf(v,_SC("[%s] USERDATA\n"),name);
-					break;
-				case OT_THREAD:
-					pf(v,_SC("[%s] THREAD\n"),name);
-					break;
-				case OT_CLASS:
-					pf(v,_SC("[%s] CLASS\n"),name);
-					break;
-				case OT_INSTANCE:
-					pf(v,_SC("[%s] INSTANCE\n"),name);
-					break;
-				case OT_WEAKREF:
-					pf(v,_SC("[%s] WEAKREF\n"),name);
-					break;
+					}
+					break;
+				case OT_TABLE:
+					pf(v,_SC("[%s] TABLE\n"),name);
+					break;
+				case OT_ARRAY:
+					pf(v,_SC("[%s] ARRAY\n"),name);
+					break;
+				case OT_CLOSURE:
+					pf(v,_SC("[%s] CLOSURE\n"),name);
+					break;
+				case OT_NATIVECLOSURE:
+					pf(v,_SC("[%s] NATIVECLOSURE\n"),name);
+					break;
+				case OT_GENERATOR:
+					pf(v,_SC("[%s] GENERATOR\n"),name);
+					break;
+				case OT_USERDATA:
+					pf(v,_SC("[%s] USERDATA\n"),name);
+					break;
+				case OT_THREAD:
+					pf(v,_SC("[%s] THREAD\n"),name);
+					break;
+				case OT_CLASS:
+					pf(v,_SC("[%s] CLASS\n"),name);
+					break;
+				case OT_INSTANCE:
+					pf(v,_SC("[%s] INSTANCE\n"),name);
+					break;
+				case OT_WEAKREF:
+					pf(v,_SC("[%s] WEAKREF\n"),name);
+					break;
 				case OT_BOOL:{
-				    SQBool bval;
-					sq_getbool(v,-1,&bval);
-					pf(v,_SC("[%s] %s\n"),name, bval == SQTrue ? _SC("true") : _SC("false"));
-							 }
-					break;
-				default: assert(0); break;
-				}
-				sq_pop(v,1);
-			}
-		}
-	}
-}
-
-static SQRESULT _sqstd_aux_printerror(HSQUIRRELVM v)
-{
-	SQPRINTFUNCTION pf = sq_geterrorfunc(v);
-	if(pf) {
-		const SQChar *sErr = 0;
-		if(sq_gettop(v)>=1) {
-			if(SQ_SUCCEEDED(sq_getstring(v,2,&sErr)))	{
-				pf(v,_SC("\nAN ERROR HAS OCCURED [%s]\n"),sErr);
-			}
-			else{
-				pf(v,_SC("\nAN ERROR HAS OCCURED [unknown]\n"));
-			}
-			sqstd_printcallstack(v);
-		}
-	}
-	return 0;
-}
-
-void _sqstd_compiler_error(HSQUIRRELVM v,const SQChar *sErr,const SQChar *sSource,SQInteger line,SQInteger 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,_SC("%s:%d:%d : error %s\n"),sSource,line,column,sErr);
-	}
-}
-
-void sqstd_seterrorhandlers(HSQUIRRELVM v)
-{
-	sq_setcompilererrorhandler(v,_sqstd_compiler_error);
-	sq_newclosure(v,_sqstd_aux_printerror,0);
-	sq_seterrorhandler(v);
-}
+				    SQBool bval;
+					sq_getbool(v,-1,&bval);
+					pf(v,_SC("[%s] %s\n"),name, bval == SQTrue ? _SC("true") : _SC("false"));
+							 }
+					break;
+				default: assert(0); break;
+				}
+				sq_pop(v,1);
+			}
+		}
+	}
+}
+
+static SQRESULT _sqstd_aux_printerror(HSQUIRRELVM v)
+{
+	SQPRINTFUNCTION pf = sq_geterrorfunc(v);
+	if(pf) {
+		const SQChar *sErr = 0;
+		if(sq_gettop(v)>=1) {
+			if(SQ_SUCCEEDED(sq_getstring(v,2,&sErr)))	{
+				pf(v,_SC("\nAN ERROR HAS OCCURED [%s]\n"),sErr);
+			}
+			else{
+				pf(v,_SC("\nAN ERROR HAS OCCURED [unknown]\n"));
+			}
+			sqstd_printcallstack(v);
+		}
+	}
+	return 0;
+}
+
+void _sqstd_compiler_error(HSQUIRRELVM v,const SQChar *sErr,const SQChar *sSource,SQInteger line,SQInteger 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,_SC("%s:%d:%d : error %s\n"),sSource,line,column,sErr);
+	}
+}
+
+void sqstd_seterrorhandlers(HSQUIRRELVM v)
+{
+	sq_setcompilererrorhandler(v,_sqstd_compiler_error);
+	sq_newclosure(v,_sqstd_aux_printerror,0);
+	sq_seterrorhandler(v);
+}

SquiLu/sqstdlib/sqstdblob.cpp

@@ -1,39 +1,39 @@
-/* see copyright notice in squirrel.h */
-#include <new>
-#include <squirrel.h>
-#include <sqstdio.h>
-#include <string.h>
-#include <sqstdblob.h>
-#include "sqstdstream.h"
-#include "sqstdblobimpl.h"
-
+/* see copyright notice in squirrel.h */
+#include <new>
+#include <squirrel.h>
+#include <sqstdio.h>
+#include <string.h>
+#include <sqstdblob.h>
+#include "sqstdstream.h"
+#include "sqstdblobimpl.h"
+
 //#define SQSTD_BLOB_TYPE_TAG (SQSTD_STREAM_TYPE_TAG | 0x00000002)
-static const SQChar  SQSTD_BLOB_TYPE_TAG[] = _SC("std_stream_blob");
-
-
+static const SQChar  SQSTD_BLOB_TYPE_TAG[] = _SC("std_stream_blob");
+
+
 //Blob
-
-
-SQUserPointer SQBlob::SQBlob_TAG = (SQUserPointer)SQSTD_BLOB_TYPE_TAG;
-
-SQBlob::SQBlob(SQInteger size, SQInteger allocated) {
-    _size = size;
-    _allocated = allocated > size ? allocated : size;
-    _buf = (unsigned char *)sq_malloc(_allocated);
-    memset(_buf, 0, _allocated);
-    _ptr = 0;
-    _owns = true;
-}
-SQBlob::~SQBlob() {
-    if(_buf) sq_free(_buf, _allocated);
-}
-SQInteger SQBlob::Write(const void *buffer, SQInteger size) {
-    if(!CanAdvance(size)) {
-        GrowBufOf(_ptr + size - _size);
-    }
-    memcpy(&_buf[_ptr], buffer, size);
-    _ptr += size;
-    return size;
+
+
+SQUserPointer SQBlob::SQBlob_TAG = (SQUserPointer)SQSTD_BLOB_TYPE_TAG;
+
+SQBlob::SQBlob(SQInteger size, SQInteger allocated) {
+    _size = size;
+    _allocated = allocated > size ? allocated : size;
+    _buf = (unsigned char *)sq_malloc(_allocated);
+    memset(_buf, 0, _allocated);
+    _ptr = 0;
+    _owns = true;
+}
+SQBlob::~SQBlob() {
+    if(_buf) sq_free(_buf, _allocated);
+}
+SQInteger SQBlob::Write(const void *buffer, SQInteger size) {
+    if(!CanAdvance(size)) {
+        GrowBufOf(_ptr + size - _size);
+    }
+    memcpy(&_buf[_ptr], buffer, size);
+    _ptr += size;
+    return size;
 }
 SQInteger SQBlob::WriteZstr(const char *zStr) {
     if(zStr) //do not try to strlen(NULL)
@@ -42,27 +42,27 @@ SQInteger SQBlob::WriteZstr(const char *zStr) {
         return Write(zStr, size);
     }
     return 0;
-}
+}
 SQInteger SQBlob::WriteChar(const char c) {
-    return Write(&c, 1);
-}
-SQInteger SQBlob::Read(void *buffer,SQInteger size) {
-    SQInteger n = size;
-    if(!CanAdvance(size)) {
-        if((_size - _ptr) > 0)
-            n = _size - _ptr;
-        else return 0;
-    }
-    memcpy(buffer, &_buf[_ptr], n);
-    _ptr += n;
-    return n;
-}
-SQInteger SQBlob::Gets(char *buffer,SQInteger size) {
-    SQInteger n = size;
-    if(!CanAdvance(size)) {
-        if((_size - _ptr) > 0)
-            n = _size - _ptr;
-        else return 0;
+    return Write(&c, 1);
+}
+SQInteger SQBlob::Read(void *buffer,SQInteger size) {
+    SQInteger n = size;
+    if(!CanAdvance(size)) {
+        if((_size - _ptr) > 0)
+            n = _size - _ptr;
+        else return 0;
+    }
+    memcpy(buffer, &_buf[_ptr], n);
+    _ptr += n;
+    return n;
+}
+SQInteger SQBlob::Gets(char *buffer,SQInteger size) {
+    SQInteger n = size;
+    if(!CanAdvance(size)) {
+        if((_size - _ptr) > 0)
+            n = _size - _ptr;
+        else return 0;
     }
     SQInteger i=0;
     for(; i < n; ++i)
@@ -70,414 +70,414 @@ SQInteger SQBlob::Gets(char *buffer,SQInteger size) {
         char c = _buf[_ptr+i];
         buffer[i] = c;
         if(c == '\n') break;
-    }
-    _ptr += i;
-    return i;
-}
-bool SQBlob::Resize(SQInteger n) {
-    if(!_owns) return false;
-    if(n != _allocated) {
-        unsigned char *newbuf = (unsigned char *)sq_malloc(n);
-        memset(newbuf,0,n);
-        if(_size > n)
-            memcpy(newbuf,_buf,n);
-        else
-            memcpy(newbuf,_buf,_size);
-        sq_free(_buf,_allocated);
-        _buf=newbuf;
-        _allocated = n;
-        if(_size > _allocated)
-            _size = _allocated;
-        if(_ptr > _size)
-            _ptr = _size;
-    }
-    return true;
-}
-bool SQBlob::GrowBufOf(SQInteger n)
-{
-    bool ret = true;
-    if(_size + n > _allocated) {
-        if(_size + n > _size * 2)
-            ret = Resize(_size + n);
-        else
-            ret = Resize(_size * 2);
-    }
-    _size = _size + n;
-    return ret;
-}
-SQInteger SQBlob::Seek(SQInteger offset, SQInteger origin) {
-    switch(origin) {
-        case SQ_SEEK_SET:
-            if(offset > _size || offset < 0) return -1;
-            _ptr = offset;
-            break;
-        case SQ_SEEK_CUR:
-            if(_ptr + offset > _size || _ptr + offset < 0) return -1;
-            _ptr += offset;
-            break;
-        case SQ_SEEK_END:
-            if(_size + offset > _size || _size + offset < 0) return -1;
-            _ptr = _size + offset;
-            break;
-        default: return -1;
-    }
-    return 0;
+    }
+    _ptr += i;
+    return i;
+}
+bool SQBlob::Resize(SQInteger n) {
+    if(!_owns) return false;
+    if(n != _allocated) {
+        unsigned char *newbuf = (unsigned char *)sq_malloc(n);
+        memset(newbuf,0,n);
+        if(_size > n)
+            memcpy(newbuf,_buf,n);
+        else
+            memcpy(newbuf,_buf,_size);
+        sq_free(_buf,_allocated);
+        _buf=newbuf;
+        _allocated = n;
+        if(_size > _allocated)
+            _size = _allocated;
+        if(_ptr > _size)
+            _ptr = _size;
+    }
+    return true;
+}
+bool SQBlob::GrowBufOf(SQInteger n)
+{
+    bool ret = true;
+    if(_size + n > _allocated) {
+        if(_size + n > _size * 2)
+            ret = Resize(_size + n);
+        else
+            ret = Resize(_size * 2);
+    }
+    _size = _size + n;
+    return ret;
+}
+SQInteger SQBlob::Seek(SQInteger offset, SQInteger origin) {
+    switch(origin) {
+        case SQ_SEEK_SET:
+            if(offset > _size || offset < 0) return -1;
+            _ptr = offset;
+            break;
+        case SQ_SEEK_CUR:
+            if(_ptr + offset > _size || _ptr + offset < 0) return -1;
+            _ptr += offset;
+            break;
+        case SQ_SEEK_END:
+            if(_size + offset > _size || _size + offset < 0) return -1;
+            _ptr = _size + offset;
+            break;
+        default: return -1;
+    }
+    return 0;
 }
 
 bool SQBlob::SetLen(SQInteger len){
     if(len <= _allocated || Resize(len)){
         _size = len;
-        if(_ptr > _size)
-            _ptr = _size;
+        if(_ptr > _size)
+            _ptr = _size;
         return true;
-    }
-    return false;
-}
-
-#define SETUP_BLOB(v) \
-	SQBlob *self = NULL; \
-	{ if(SQ_FAILED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) \
-		return sq_throwerror(v,_SC("invalid type tag"));  } \
-	if(!self || !self->IsValid())  \
-		return sq_throwerror(v,_SC("the blob is invalid"));
-
-
-static SQRESULT _blob_resize(HSQUIRRELVM v)
-{
-	SETUP_BLOB(v);
-	SQInteger size;
-	sq_getinteger(v,2,&size);
-	if(!self->Resize(size))
-		return sq_throwerror(v,_SC("resize failed"));
-	return 0;
-}
-
-static SQRESULT _blob_reserve(HSQUIRRELVM v)
+    }
+    return false;
+}
+
+#define SETUP_BLOB(v) \
+	SQBlob *self = NULL; \
+	{ if(SQ_FAILED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) \
+		return sq_throwerror(v,_SC("invalid type tag"));  } \
+	if(!self || !self->IsValid())  \
+		return sq_throwerror(v,_SC("the blob is invalid"));
+
+
+static SQRESULT _blob_resize(HSQUIRRELVM v)
+{
+	SETUP_BLOB(v);
+	SQInteger size;
+	sq_getinteger(v,2,&size);
+	if(!self->Resize(size))
+		return sq_throwerror(v,_SC("resize failed"));
+	return 0;
+}
+
+static SQRESULT _blob_reserve(HSQUIRRELVM v)
+{
+	SETUP_BLOB(v);
+	SQInteger size;
+	sq_getinteger(v,2,&size);
+	if(!self->GrowBufOf(size))
+		return sq_throwerror(v,_SC("reserve failed"));
+	return 0;
+}
+
+static void __swap_dword(unsigned int *n)
+{
+	*n=(unsigned int)(((*n&0xFF000000)>>24)  |
+			((*n&0x00FF0000)>>8)  |
+			((*n&0x0000FF00)<<8)  |
+			((*n&0x000000FF)<<24));
+}
+
+static void __swap_word(unsigned short *n)
+{
+	*n=(unsigned short)((*n>>8)&0x00FF)| ((*n<<8)&0xFF00);
+}
+
+static SQRESULT _blob_swap4(HSQUIRRELVM v)
+{
+	SETUP_BLOB(v);
+	SQInteger num=(self->Len()-(self->Len()%4))>>2;
+	unsigned int *t=(unsigned int *)self->GetBuf();
+	for(SQInteger i = 0; i < num; i++) {
+		__swap_dword(&t[i]);
+	}
+	return 0;
+}
+
+static SQRESULT _blob_swap2(HSQUIRRELVM v)
+{
+	SETUP_BLOB(v);
+	SQInteger num=(self->Len()-(self->Len()%2))>>1;
+	unsigned short *t = (unsigned short *)self->GetBuf();
+	for(SQInteger i = 0; i < num; i++) {
+		__swap_word(&t[i]);
+	}
+	return 0;
+}
+
+static SQRESULT _blob_memset(HSQUIRRELVM v)
 {
+    SQ_FUNC_VARS_NO_TOP(v);
 	SETUP_BLOB(v);
-	SQInteger size;
-	sq_getinteger(v,2,&size);
-	if(!self->GrowBufOf(size))
-		return sq_throwerror(v,_SC("reserve failed"));
-	return 0;
-}
-
-static void __swap_dword(unsigned int *n)
-{
-	*n=(unsigned int)(((*n&0xFF000000)>>24)  |
-			((*n&0x00FF0000)>>8)  |
-			((*n&0x0000FF00)<<8)  |
-			((*n&0x000000FF)<<24));
-}
-
-static void __swap_word(unsigned short *n)
-{
-	*n=(unsigned short)((*n>>8)&0x00FF)| ((*n<<8)&0xFF00);
-}
-
-static SQRESULT _blob_swap4(HSQUIRRELVM v)
-{
-	SETUP_BLOB(v);
-	SQInteger num=(self->Len()-(self->Len()%4))>>2;
-	unsigned int *t=(unsigned int *)self->GetBuf();
-	for(SQInteger i = 0; i < num; i++) {
-		__swap_dword(&t[i]);
-	}
-	return 0;
-}
-
-static SQRESULT _blob_swap2(HSQUIRRELVM v)
-{
-	SETUP_BLOB(v);
-	SQInteger num=(self->Len()-(self->Len()%2))>>1;
-	unsigned short *t = (unsigned short *)self->GetBuf();
-	for(SQInteger i = 0; i < num; i++) {
-		__swap_word(&t[i]);
-	}
-	return 0;
-}
-
-static SQRESULT _blob_memset(HSQUIRRELVM v)
-{
-    SQ_FUNC_VARS_NO_TOP(v);
-	SETUP_BLOB(v);
-	SQ_GET_INTEGER(v, 2, idx);
-	SQ_GET_INTEGER(v, 3, val);
-	SQ_GET_INTEGER(v, 4, size);
-	if(idx < 0 || idx >= self->Len())
-		return sq_throwerror(v,_SC("index out of range"));
-	if(idx+size < 0 || idx+size >= self->Len())
+	SQ_GET_INTEGER(v, 2, idx);
+	SQ_GET_INTEGER(v, 3, val);
+	SQ_GET_INTEGER(v, 4, size);
+	if(idx < 0 || idx >= self->Len())
+		return sq_throwerror(v,_SC("index out of range"));
+	if(idx+size < 0 || idx+size >= self->Len())
 		return sq_throwerror(v,_SC("index+size out of range"));
-    memset(((unsigned char*)self->GetBuf())+idx, val, size);
-	return 0;
-}
-
-static SQRESULT _blob__set(HSQUIRRELVM v)
-{
-	SETUP_BLOB(v);
-	SQInteger idx,val;
-	sq_getinteger(v,2,&idx);
-	sq_getinteger(v,3,&val);
-	if(idx < 0 || idx >= self->Len())
-		return sq_throwerror(v,_SC("index out of range"));
-	((unsigned char *)self->GetBuf())[idx] = (unsigned char) val;
-	sq_push(v,3);
-	return 1;
-}
-
-static SQRESULT _blob__get(HSQUIRRELVM v)
-{
-	SETUP_BLOB(v);
+    memset(((unsigned char*)self->GetBuf())+idx, val, size);
+	return 0;
+}
+
+static SQRESULT _blob__set(HSQUIRRELVM v)
+{
+	SETUP_BLOB(v);
+	SQInteger idx,val;
+	sq_getinteger(v,2,&idx);
+	sq_getinteger(v,3,&val);
+	if(idx < 0 || idx >= self->Len())
+		return sq_throwerror(v,_SC("index out of range"));
+	((unsigned char *)self->GetBuf())[idx] = (unsigned char) val;
+	sq_push(v,3);
+	return 1;
+}
+
+static SQRESULT _blob__get(HSQUIRRELVM v)
+{
+	SETUP_BLOB(v);
 	SQInteger idx;
 	SQObjectType ptype = sq_gettype(v, 2);
 	if( !(ptype & SQOBJECT_NUMERIC) ){
 	    //allow call metatable methods indexed by strings
 	    sq_reseterror(v);
 	    return SQ_ERROR;
-	}
-	sq_getinteger(v,2,&idx);
-	if(idx < 0 || idx >= self->Len())
-		return sq_throwerror(v,_SC("index out of range"));
-	sq_pushinteger(v,((unsigned char *)self->GetBuf())[idx]);
-	return 1;
-}
-
-static SQRESULT _blob__nexti(HSQUIRRELVM v)
+	}
+	sq_getinteger(v,2,&idx);
+	if(idx < 0 || idx >= self->Len())
+		return sq_throwerror(v,_SC("index out of range"));
+	sq_pushinteger(v,((unsigned char *)self->GetBuf())[idx]);
+	return 1;
+}
+
+static SQRESULT _blob__nexti(HSQUIRRELVM v)
+{
+	SETUP_BLOB(v);
+	if(sq_gettype(v,2) == OT_NULL) {
+		sq_pushinteger(v, 0);
+		return 1;
+	}
+	SQInteger idx;
+	if(SQ_SUCCEEDED(sq_getinteger(v, 2, &idx))) {
+		if(idx+1 < self->Len()) {
+			sq_pushinteger(v, idx+1);
+			return 1;
+		}
+		sq_pushnull(v);
+		return 1;
+	}
+	return sq_throwerror(v,_SC("internal error (_nexti) wrong argument type"));
+}
+
+static SQRESULT _blob__typeof(HSQUIRRELVM v)
+{
+	sq_pushstring(v,_SC("blob"),-1);
+	return 1;
+}
+
+static SQRESULT _blob_releasehook(SQUserPointer p, SQInteger /*size*/, void */*ep*/)
+{
+	SQBlob *self = (SQBlob*)p;
+	self->~SQBlob();
+	sq_free(self,sizeof(SQBlob));
+	return 1;
+}
+
+static SQRESULT _blob_constructor(HSQUIRRELVM v)
+{
+	SQInteger nparam = sq_gettop(v);
+	SQInteger size = 0, allocate = 0;
+	if(nparam >= 2) {
+		sq_getinteger(v, 2, &size);
+	}
+	if(nparam >= 3) {
+		sq_getinteger(v, 2, &allocate);
+	}
+	if(size < 0) return sq_throwerror(v, _SC("cannot create blob with negative size"));
+	if(allocate < 0) return sq_throwerror(v, _SC("cannot create blob with negative allocate"));
+	//SQBlob *b = new SQBlob(size);
+
+	SQBlob *b = new (sq_malloc(sizeof(SQBlob)))SQBlob(size, allocate);
+	if(SQ_FAILED(sq_setinstanceup(v,1,b))) {
+		b->~SQBlob();
+		sq_free(b,sizeof(SQBlob));
+		return sq_throwerror(v, _SC("cannot create blob"));
+	}
+	sq_setreleasehook(v,1,_blob_releasehook);
+	return 0;
+}
+
+static SQRESULT _blob__cloned(HSQUIRRELVM v)
+{
+	SQBlob *other = NULL;
+	{
+		if(SQ_FAILED(sq_getinstanceup(v,2,(SQUserPointer*)&other,(SQUserPointer)SQSTD_BLOB_TYPE_TAG)))
+			return SQ_ERROR;
+	}
+	//SQBlob *thisone = new SQBlob(other->Len());
+	SQBlob *thisone = new (sq_malloc(sizeof(SQBlob)))SQBlob(other->Len());
+	memcpy(thisone->GetBuf(),other->GetBuf(),thisone->Len());
+	if(SQ_FAILED(sq_setinstanceup(v,1,thisone))) {
+		thisone->~SQBlob();
+		sq_free(thisone,sizeof(SQBlob));
+		return sq_throwerror(v, _SC("cannot clone blob"));
+	}
+	sq_setreleasehook(v,1,_blob_releasehook);
+	return 0;
+}
+
+static SQRESULT _blob__tostring(HSQUIRRELVM v)
 {
-	SETUP_BLOB(v);
-	if(sq_gettype(v,2) == OT_NULL) {
-		sq_pushinteger(v, 0);
-		return 1;
-	}
-	SQInteger idx;
-	if(SQ_SUCCEEDED(sq_getinteger(v, 2, &idx))) {
-		if(idx+1 < self->Len()) {
-			sq_pushinteger(v, idx+1);
-			return 1;
-		}
-		sq_pushnull(v);
-		return 1;
-	}
-	return sq_throwerror(v,_SC("internal error (_nexti) wrong argument type"));
-}
-
-static SQRESULT _blob__typeof(HSQUIRRELVM v)
-{
-	sq_pushstring(v,_SC("blob"),-1);
-	return 1;
-}
-
-static SQRESULT _blob_releasehook(SQUserPointer p, SQInteger /*size*/, void */*ep*/)
-{
-	SQBlob *self = (SQBlob*)p;
-	self->~SQBlob();
-	sq_free(self,sizeof(SQBlob));
-	return 1;
-}
-
-static SQRESULT _blob_constructor(HSQUIRRELVM v)
+    SETUP_BLOB(v);
+	sq_pushstring(v, (const SQChar*)self->GetBuf(), self->Len());
+	return 1;
+}
+
+static SQRESULT _blob_tostring(HSQUIRRELVM v)
 {
-	SQInteger nparam = sq_gettop(v);
-	SQInteger size = 0, allocate = 0;
-	if(nparam >= 2) {
-		sq_getinteger(v, 2, &size);
-	}
-	if(nparam >= 3) {
-		sq_getinteger(v, 2, &allocate);
-	}
-	if(size < 0) return sq_throwerror(v, _SC("cannot create blob with negative size"));
-	if(allocate < 0) return sq_throwerror(v, _SC("cannot create blob with negative allocate"));
-	//SQBlob *b = new SQBlob(size);
-
-	SQBlob *b = new (sq_malloc(sizeof(SQBlob)))SQBlob(size, allocate);
-	if(SQ_FAILED(sq_setinstanceup(v,1,b))) {
-		b->~SQBlob();
-		sq_free(b,sizeof(SQBlob));
-		return sq_throwerror(v, _SC("cannot create blob"));
-	}
-	sq_setreleasehook(v,1,_blob_releasehook);
-	return 0;
-}
-
-static SQRESULT _blob__cloned(HSQUIRRELVM v)
-{
-	SQBlob *other = NULL;
-	{
-		if(SQ_FAILED(sq_getinstanceup(v,2,(SQUserPointer*)&other,(SQUserPointer)SQSTD_BLOB_TYPE_TAG)))
-			return SQ_ERROR;
-	}
-	//SQBlob *thisone = new SQBlob(other->Len());
-	SQBlob *thisone = new (sq_malloc(sizeof(SQBlob)))SQBlob(other->Len());
-	memcpy(thisone->GetBuf(),other->GetBuf(),thisone->Len());
-	if(SQ_FAILED(sq_setinstanceup(v,1,thisone))) {
-		thisone->~SQBlob();
-		sq_free(thisone,sizeof(SQBlob));
-		return sq_throwerror(v, _SC("cannot clone blob"));
-	}
-	sq_setreleasehook(v,1,_blob_releasehook);
-	return 0;
-}
-
-static SQRESULT _blob__tostring(HSQUIRRELVM v)
-{
-    SETUP_BLOB(v);
-	sq_pushstring(v, (const SQChar*)self->GetBuf(), self->Len());
-	return 1;
-}
-
-static SQRESULT _blob_tostring(HSQUIRRELVM v)
-{
-    return _blob__tostring(v);
-}
-
-static SQRESULT _blob_setLen(HSQUIRRELVM v)
+    return _blob__tostring(v);
+}
+
+static SQRESULT _blob_setLen(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS_NO_TOP(v);
     SETUP_BLOB(v);
     SQ_GET_INTEGER(v, 2, newLen);
     self->SetLen(newLen);
     return 0;
-}
+}
 
-static SQRESULT _blob_clear(HSQUIRRELVM v)
+static SQRESULT _blob_clear(HSQUIRRELVM v)
 {
     SETUP_BLOB(v);
     self->SetLen(0);
     return 0;
-}
-
-#define _DECL_BLOB_FUNC(name,nparams,typecheck) {_SC(#name),_blob_##name,nparams,typecheck}
-static SQRegFunction _blob_methods[] = {
-	_DECL_BLOB_FUNC(constructor,-1,_SC("xnn")),
-	_DECL_BLOB_FUNC(resize,2,_SC("xn")),
-	_DECL_BLOB_FUNC(reserve,2,_SC("xn")),
-	_DECL_BLOB_FUNC(swap2,1,_SC("x")),
-	_DECL_BLOB_FUNC(swap4,1,_SC("x")),
-	_DECL_BLOB_FUNC(memset,4,_SC("xiii")),
-	_DECL_BLOB_FUNC(_set,3,_SC("xnn")),
-	_DECL_BLOB_FUNC(_get,2,_SC("x n|s")), //allow call metatable methods indexed by strings
-	_DECL_BLOB_FUNC(_typeof,1,_SC("x")),
-	_DECL_BLOB_FUNC(_nexti,2,_SC("x")),
-	_DECL_BLOB_FUNC(_cloned,2,_SC("xx")),
-	//_DECL_BLOB_FUNC(_tostring,1,_SC("x")),
-	_DECL_BLOB_FUNC(tostring,1,_SC("x")),
-	_DECL_BLOB_FUNC(setLen,2,_SC("xi")),
-	_DECL_BLOB_FUNC(clear,1,_SC("x")),
-	{NULL,(SQFUNCTION)0,0,NULL}
-};
-
-
-
-//GLOBAL FUNCTIONS
-
-static SQRESULT _g_blob_casti2f(HSQUIRRELVM v)
-{
-	SQInteger i;
-	sq_getinteger(v,2,&i);
-	sq_pushfloat(v,*((SQFloat *)&i));
-	return 1;
-}
-
-static SQRESULT _g_blob_castf2i(HSQUIRRELVM v)
-{
-	SQFloat f;
-	sq_getfloat(v,2,&f);
-	sq_pushinteger(v,*((SQInteger *)&f));
-	return 1;
-}
-
-static SQRESULT _g_blob_swap2(HSQUIRRELVM v)
-{
-	SQInteger i;
-	sq_getinteger(v,2,&i);
-	short s=(short)i;
-	sq_pushinteger(v,(s<<8)|((s>>8)&0x00FF));
-	return 1;
-}
-
-static SQRESULT _g_blob_swap4(HSQUIRRELVM v)
-{
-	SQInteger i;
-	sq_getinteger(v,2,&i);
-	unsigned int t4 = (unsigned int)i;
-	__swap_dword(&t4);
-	sq_pushinteger(v,(SQInteger)t4);
-	return 1;
-}
-
-static SQRESULT _g_blob_swapfloat(HSQUIRRELVM v)
-{
-	SQFloat f;
-	sq_getfloat(v,2,&f);
-	__swap_dword((unsigned int *)&f);
-	sq_pushfloat(v,f);
-	return 1;
-}
-
-#define _DECL_GLOBALBLOB_FUNC(name,nparams,typecheck) {_SC(#name),_g_blob_##name,nparams,typecheck}
-static SQRegFunction 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")),
-	{NULL,(SQFUNCTION)0,0,NULL}
-};
-
-SQRESULT sqstd_getblob(HSQUIRRELVM v,SQInteger idx,SQUserPointer *ptr)
-{
-	SQBlob *blob;
-	if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG)))
-		return -1;
-	*ptr = blob->GetBuf();
-	return SQ_OK;
-}
-
-SQInteger sqstd_getblobsize(HSQUIRRELVM v,SQInteger idx)
-{
-	SQBlob *blob;
-	if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG)))
-		return -1;
-	return blob->Len();
-}
-
-SQInteger blob_read(SQUserPointer file,SQUserPointer buf,SQInteger size)
-{
+}
+
+#define _DECL_BLOB_FUNC(name,nparams,typecheck) {_SC(#name),_blob_##name,nparams,typecheck}
+static SQRegFunction _blob_methods[] = {
+	_DECL_BLOB_FUNC(constructor,-1,_SC("xnn")),
+	_DECL_BLOB_FUNC(resize,2,_SC("xn")),
+	_DECL_BLOB_FUNC(reserve,2,_SC("xn")),
+	_DECL_BLOB_FUNC(swap2,1,_SC("x")),
+	_DECL_BLOB_FUNC(swap4,1,_SC("x")),
+	_DECL_BLOB_FUNC(memset,4,_SC("xiii")),
+	_DECL_BLOB_FUNC(_set,3,_SC("xnn")),
+	_DECL_BLOB_FUNC(_get,2,_SC("x n|s")), //allow call metatable methods indexed by strings
+	_DECL_BLOB_FUNC(_typeof,1,_SC("x")),
+	_DECL_BLOB_FUNC(_nexti,2,_SC("x")),
+	_DECL_BLOB_FUNC(_cloned,2,_SC("xx")),
+	//_DECL_BLOB_FUNC(_tostring,1,_SC("x")),
+	_DECL_BLOB_FUNC(tostring,1,_SC("x")),
+	_DECL_BLOB_FUNC(setLen,2,_SC("xi")),
+	_DECL_BLOB_FUNC(clear,1,_SC("x")),
+	{NULL,(SQFUNCTION)0,0,NULL}
+};
+
+
+
+//GLOBAL FUNCTIONS
+
+static SQRESULT _g_blob_casti2f(HSQUIRRELVM v)
+{
+	SQInteger i;
+	sq_getinteger(v,2,&i);
+	sq_pushfloat(v,*((SQFloat *)&i));
+	return 1;
+}
+
+static SQRESULT _g_blob_castf2i(HSQUIRRELVM v)
+{
+	SQFloat f;
+	sq_getfloat(v,2,&f);
+	sq_pushinteger(v,*((SQInteger *)&f));
+	return 1;
+}
+
+static SQRESULT _g_blob_swap2(HSQUIRRELVM v)
+{
+	SQInteger i;
+	sq_getinteger(v,2,&i);
+	short s=(short)i;
+	sq_pushinteger(v,(s<<8)|((s>>8)&0x00FF));
+	return 1;
+}
+
+static SQRESULT _g_blob_swap4(HSQUIRRELVM v)
+{
+	SQInteger i;
+	sq_getinteger(v,2,&i);
+	unsigned int t4 = (unsigned int)i;
+	__swap_dword(&t4);
+	sq_pushinteger(v,(SQInteger)t4);
+	return 1;
+}
+
+static SQRESULT _g_blob_swapfloat(HSQUIRRELVM v)
+{
+	SQFloat f;
+	sq_getfloat(v,2,&f);
+	__swap_dword((unsigned int *)&f);
+	sq_pushfloat(v,f);
+	return 1;
+}
+
+#define _DECL_GLOBALBLOB_FUNC(name,nparams,typecheck) {_SC(#name),_g_blob_##name,nparams,typecheck}
+static SQRegFunction 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")),
+	{NULL,(SQFUNCTION)0,0,NULL}
+};
+
+SQRESULT sqstd_getblob(HSQUIRRELVM v,SQInteger idx,SQUserPointer *ptr)
+{
+	SQBlob *blob;
+	if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG)))
+		return -1;
+	*ptr = blob->GetBuf();
+	return SQ_OK;
+}
+
+SQInteger sqstd_getblobsize(HSQUIRRELVM v,SQInteger idx)
+{
+	SQBlob *blob;
+	if(SQ_FAILED(sq_getinstanceup(v,idx,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG)))
+		return -1;
+	return blob->Len();
+}
+
+SQInteger blob_read(SQUserPointer file,SQUserPointer buf,SQInteger size)
+{
 	SQInteger ret;
-	SQBlob *blob = (SQBlob *)file;
-	if( ( ret = blob->Read(buf, size)) !=0 ) return ret;
-	return -1;
-}
+	SQBlob *blob = (SQBlob *)file;
+	if( ( ret = blob->Read(buf, size)) !=0 ) return ret;
+	return -1;
+}
 
-SQInteger blob_write(SQUserPointer file,SQUserPointer p,SQInteger size)
+SQInteger blob_write(SQUserPointer file,SQUserPointer p,SQInteger size)
 {
-    SQBlob *blob = (SQBlob *)file;
-	return blob->Write(p,size);
-}
-
-
-SQUserPointer sqstd_createblob(HSQUIRRELVM v, SQInteger size)
-{
-	SQInteger top = sq_gettop(v);
-	sq_pushregistrytable(v);
-	sq_pushstring(v,_SC("std_blob"),-1);
-	if(SQ_SUCCEEDED(sq_get(v,-2))) {
-		sq_remove(v,-2); //removes the registry
-		sq_push(v,1); // push the this
-		sq_pushinteger(v,size); //size
-		SQBlob *blob = NULL;
-		if(SQ_SUCCEEDED(sq_call(v,2,SQTrue,SQFalse))
-			&& SQ_SUCCEEDED(sq_getinstanceup(v,-1,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) {
-			sq_remove(v,-2);
-			return blob->GetBuf();
-		}
-	}
-	sq_settop(v,top);
-	return NULL;
-}
-
-SQRESULT sqstd_register_bloblib(HSQUIRRELVM v)
-{
-	return declare_stream(v,_SC("blob"),(SQUserPointer)SQSTD_BLOB_TYPE_TAG,_SC("std_blob"),_blob_methods,bloblib_funcs);
-}
-
+    SQBlob *blob = (SQBlob *)file;
+	return blob->Write(p,size);
+}
+
+
+SQUserPointer sqstd_createblob(HSQUIRRELVM v, SQInteger size)
+{
+	SQInteger top = sq_gettop(v);
+	sq_pushregistrytable(v);
+	sq_pushstring(v,_SC("std_blob"),-1);
+	if(SQ_SUCCEEDED(sq_get(v,-2))) {
+		sq_remove(v,-2); //removes the registry
+		sq_push(v,1); // push the this
+		sq_pushinteger(v,size); //size
+		SQBlob *blob = NULL;
+		if(SQ_SUCCEEDED(sq_call(v,2,SQTrue,SQFalse))
+			&& SQ_SUCCEEDED(sq_getinstanceup(v,-1,(SQUserPointer *)&blob,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) {
+			sq_remove(v,-2);
+			return blob->GetBuf();
+		}
+	}
+	sq_settop(v,top);
+	return NULL;
+}
+
+SQRESULT sqstd_register_bloblib(HSQUIRRELVM v)
+{
+	return declare_stream(v,_SC("blob"),(SQUserPointer)SQSTD_BLOB_TYPE_TAG,_SC("std_blob"),_blob_methods,bloblib_funcs);
+}
+

SquiLu/sqstdlib/sqstdblobimpl.h

@@ -1,44 +1,44 @@
-/*	see copyright notice in squirrel.h */
-#ifndef _SQSTD_BLOBIMPL_H_
-#define _SQSTD_BLOBIMPL_H_
-
+/*	see copyright notice in squirrel.h */
+#ifndef _SQSTD_BLOBIMPL_H_
+#define _SQSTD_BLOBIMPL_H_
+
 #include "sqstdio.h"
 #define BLOB_BUFSIZE 8192
 
-struct SQBlob : public SQStream
-{
-	SQBlob(SQInteger size, SQInteger allocated=0);
-	virtual ~SQBlob();
-	SQInteger Write(const void *buffer, SQInteger size);
+struct SQBlob : public SQStream
+{
+	SQBlob(SQInteger size, SQInteger allocated=0);
+	virtual ~SQBlob();
+	SQInteger Write(const void *buffer, SQInteger size);
 	SQInteger WriteZstr(const char *zStr);
-	SQInteger WriteChar(const char c);
-	SQInteger Read(void *buffer,SQInteger size);
-	SQInteger Gets(char *buffer,SQInteger size);
-	bool Resize(SQInteger n);
-	bool GrowBufOf(SQInteger n);
-	bool CanAdvance(SQInteger n) {
-		if(_ptr+n>_size)return false;
-		return true;
-	}
-	SQInteger Seek(SQInteger offset, SQInteger origin);
-	bool IsValid() {
-		return _buf?true:false;
-	}
-	bool EOS() {
-		return _ptr == _size;
-	}
-	SQInteger Flush() { return 0; }
-	SQInteger Tell() { return _ptr; }
-	SQInteger Len() { return _size; }
+	SQInteger WriteChar(const char c);
+	SQInteger Read(void *buffer,SQInteger size);
+	SQInteger Gets(char *buffer,SQInteger size);
+	bool Resize(SQInteger n);
+	bool GrowBufOf(SQInteger n);
+	bool CanAdvance(SQInteger n) {
+		if(_ptr+n>_size)return false;
+		return true;
+	}
+	SQInteger Seek(SQInteger offset, SQInteger origin);
+	bool IsValid() {
+		return _buf?true:false;
+	}
+	bool EOS() {
+		return _ptr == _size;
+	}
+	SQInteger Flush() { return 0; }
+	SQInteger Tell() { return _ptr; }
+	SQInteger Len() { return _size; }
 	SQUserPointer GetBuf(){ return _buf; }
-	bool SetLen(SQInteger len);
-	static SQUserPointer SQBlob_TAG;
-private:
-	SQInteger _size;
-	SQInteger _allocated;
-	SQInteger _ptr;
-	unsigned char *_buf;
-	bool _owns;
-};
-
-#endif //_SQSTD_BLOBIMPL_H_
+	bool SetLen(SQInteger len);
+	static SQUserPointer SQBlob_TAG;
+private:
+	SQInteger _size;
+	SQInteger _allocated;
+	SQInteger _ptr;
+	unsigned char *_buf;
+	bool _owns;
+};
+
+#endif //_SQSTD_BLOBIMPL_H_

SquiLu/sqstdlib/sqstdio.cpp

@@ -558,7 +558,7 @@ SQInteger _g_io_writefile(HSQUIRRELVM v)
 }
 
 #define _DECL_GLOBALIO_FUNC(name,nparams,typecheck) {_SC(#name),_g_io_##name,nparams,typecheck}
-static SQRegFunction iolib_funcs[]={
+static const SQRegFunction iolib_funcs[]={
 	_DECL_GLOBALIO_FUNC(loadfile,-2,_SC(".sbb")),
 	_DECL_GLOBALIO_FUNC(dofile,-2,_SC(".sbb")),
 	_DECL_GLOBALIO_FUNC(writeclosuretofile,3,_SC(".sc")),

SquiLu/sqstdlib/sqstdmath.cpp

@@ -311,7 +311,7 @@ static SQRESULT math_number_format(HSQUIRRELVM v) {
 //DAD end
 
 #define _DECL_FUNC(name,nparams,tycheck) {_SC(#name),math_##name,nparams,tycheck}
-static SQRegFunction mathlib_funcs[] = {
+static const SQRegFunction mathlib_funcs[] = {
 	_DECL_FUNC(sqrt,2,_SC(".n")),
 	_DECL_FUNC(sin,2,_SC(".n")),
 	_DECL_FUNC(cos,2,_SC(".n")),

SquiLu/sqstdlib/sqstdstream.cpp

@@ -1,25 +1,25 @@
-/* see copyright notice in squirrel.h */
-#include <new>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <squirrel.h>
-#include <sqstdio.h>
-#include <sqstdblob.h>
-#include "sqstdstream.h"
+/* see copyright notice in squirrel.h */
+#include <new>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <squirrel.h>
+#include <sqstdio.h>
+#include <sqstdblob.h>
+#include "sqstdstream.h"
 #include "sqstdblobimpl.h"
 
-static const SQChar SQSTD_STREAM_TYPE_TAG[] = _SC("std_stream");
-
-#define SETUP_STREAM(v) \
-	SQStream *self = NULL; \
-	if(SQ_FAILED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)SQSTD_STREAM_TYPE_TAG))) \
-		return sq_throwerror(v,_SC("invalid type tag")); \
-	if(!self || !self->IsValid())  \
-		return sq_throwerror(v,_SC("the stream is invalid"));
+static const SQChar SQSTD_STREAM_TYPE_TAG[] = _SC("std_stream");
+
+#define SETUP_STREAM(v) \
+	SQStream *self = NULL; \
+	if(SQ_FAILED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)SQSTD_STREAM_TYPE_TAG))) \
+		return sq_throwerror(v,_SC("invalid type tag")); \
+	if(!self || !self->IsValid())  \
+		return sq_throwerror(v,_SC("the stream is invalid"));
 
 SQInteger _stream_read_line(HSQUIRRELVM v) {
-	SETUP_STREAM(v);
+	SETUP_STREAM(v);
     const SQChar nl = _SC('\n');
     const SQChar rc = _SC('\r');
     SQInteger size, read_size;
@@ -64,424 +64,428 @@ SQInteger _stream_read_line(HSQUIRRELVM v) {
     return 1;
 }
 
-SQInteger _stream_read(HSQUIRRELVM v)
-{
-	SETUP_STREAM(v);
-	SQChar *data;
-	SQInteger size,res;
+SQInteger _stream_read(HSQUIRRELVM v)
+{
+	SETUP_STREAM(v);
+	SQChar *data;
+	SQInteger size,res;
 	sq_getinteger(v,2,&size);
-	/* DAD come back here
-	if(self->GetHandle() != stdin && size > self->Len()) {
-		size = self->Len();
+	/* DAD come back here
+	if(self->GetHandle() != stdin && size > self->Len()) {
+		size = self->Len();
 	}
-	*/
-	data = sq_getscratchpad(v,size);
-	res = self->Read(data,size);
-	if(res <= 0)
-		return sq_throwerror(v,_SC("no data left to read"));
-	sq_pushstring(v,data,res);
-	return 1;
-}
-
-SQInteger _stream_gets(HSQUIRRELVM v)
-{
-	SETUP_STREAM(v);
-	SQChar *data;
+	*/
+	data = sq_getscratchpad(v,size);
+	res = self->Read(data,size);
+	if(res <= 0)
+		return sq_throwerror(v,_SC("no data left to read"));
+	sq_pushstring(v,data,res);
+	return 1;
+}
+
+SQInteger _stream_gets(HSQUIRRELVM v)
+{
+	SETUP_STREAM(v);
+	SQChar *data;
 	SQInteger size, read_size;
 	sq_getinteger(v,2,&size);
-	/* DAD come back here
-	if(self->GetHandle() != stdin && size > self->Len()) {
-		size = self->Len();
-	}
-	*/
-	data = sq_getscratchpad(v,size);
-	read_size = self->Gets(data,size);
-	if(!read_size)
-		return sq_throwerror(v,_SC("no data left to read"));
-	sq_pushstring(v,data,read_size);
-	return 1;
-}
-
-SQInteger _stream_readblob(HSQUIRRELVM v)
-{
-	SETUP_STREAM(v);
-	SQUserPointer blobp;
-	SQInteger size,res;
-	sq_getinteger(v,2,&size);
-	if(size > self->Len()) {
-		size = self->Len();
-	}
-	blobp = sqstd_createblob(v,size);
-	res = self->Read(blobp,size);
-	if(res <= 0)
-		return sq_throwerror(v,_SC("no data left to read"));
-	return 1;
-}
-
-#define SAFE_READN(ptr,len) { \
-	if(self->Read(ptr,len) != len) return sq_throwerror(v,_SC("io error")); \
-	}
-SQInteger _stream_readn(HSQUIRRELVM v)
-{
-	SETUP_STREAM(v);
-	SQInteger format;
-	sq_getinteger(v, 2, &format);
-	switch(format) {
-	case 'l': {
-		SQInteger i;
-		SAFE_READN(&i, sizeof(i));
-		sq_pushinteger(v, i);
-			  }
-		break;
-	case 'i': {
-		SQInt32 i;
-		SAFE_READN(&i, sizeof(i));
-		sq_pushinteger(v, i);
-			  }
-		break;
-	case 's': {
-		short s;
-		SAFE_READN(&s, sizeof(short));
-		sq_pushinteger(v, s);
-			  }
-		break;
-	case 'w': {
-		unsigned short w;
-		SAFE_READN(&w, sizeof(unsigned short));
-		sq_pushinteger(v, w);
-			  }
-		break;
-	case 'c': {
-		char c;
-		SAFE_READN(&c, sizeof(char));
-		sq_pushinteger(v, c);
-			  }
-		break;
-	case 'b': {
-		unsigned char c;
-		SAFE_READN(&c, sizeof(unsigned char));
-		sq_pushinteger(v, c);
-			  }
-		break;
-	case 'f': {
-		float f;
-		SAFE_READN(&f, sizeof(float));
-		sq_pushfloat(v, f);
-			  }
-		break;
-	case 'd': {
-		double d;
-		SAFE_READN(&d, sizeof(double));
-		sq_pushfloat(v, (SQFloat)d);
-			  }
-		break;
-	default:
-		return sq_throwerror(v, _SC("invalid format"));
+	/* DAD come back here
+	if(self->GetHandle() != stdin && size > self->Len()) {
+		size = self->Len();
 	}
-	return 1;
-}
-
-SQInteger _stream_write_str(HSQUIRRELVM v)
+	*/
+	data = sq_getscratchpad(v,size);
+	read_size = self->Gets(data,size);
+	if(!read_size)
+		return sq_throwerror(v,_SC("no data left to read"));
+	sq_pushstring(v,data,read_size);
+	return 1;
+}
+
+SQInteger _stream_readblob(HSQUIRRELVM v)
+{
+	SETUP_STREAM(v);
+	SQUserPointer blobp;
+	SQInteger size,res;
+	sq_getinteger(v,2,&size);
+	if(size > self->Len()) {
+		size = self->Len();
+	}
+	blobp = sqstd_createblob(v,size);
+	res = self->Read(blobp,size);
+	if(res <= 0)
+		return sq_throwerror(v,_SC("no data left to read"));
+	return 1;
+}
+
+#define SAFE_READN(ptr,len) { \
+	if(self->Read(ptr,len) != len) return sq_throwerror(v,_SC("io error")); \
+	}
+SQInteger _stream_readn(HSQUIRRELVM v)
+{
+	SETUP_STREAM(v);
+	SQInteger format;
+	sq_getinteger(v, 2, &format);
+	switch(format) {
+	case 'l': {
+		SQInteger i;
+		SAFE_READN(&i, sizeof(i));
+		sq_pushinteger(v, i);
+			  }
+		break;
+	case 'i': {
+		SQInt32 i;
+		SAFE_READN(&i, sizeof(i));
+		sq_pushinteger(v, i);
+			  }
+		break;
+	case 's': {
+		short s;
+		SAFE_READN(&s, sizeof(short));
+		sq_pushinteger(v, s);
+			  }
+		break;
+	case 'w': {
+		unsigned short w;
+		SAFE_READN(&w, sizeof(unsigned short));
+		sq_pushinteger(v, w);
+			  }
+		break;
+	case 'c': {
+		char c;
+		SAFE_READN(&c, sizeof(char));
+		sq_pushinteger(v, c);
+			  }
+		break;
+	case 'b': {
+		unsigned char c;
+		SAFE_READN(&c, sizeof(unsigned char));
+		sq_pushinteger(v, c);
+			  }
+		break;
+	case 'f': {
+		float f;
+		SAFE_READN(&f, sizeof(float));
+		sq_pushfloat(v, f);
+			  }
+		break;
+	case 'd': {
+		double d;
+		SAFE_READN(&d, sizeof(double));
+		sq_pushfloat(v, (SQFloat)d);
+			  }
+		break;
+	default:
+		return sq_throwerror(v, _SC("invalid format"));
+	}
+	return 1;
+}
+
+SQInteger _stream_write_str(HSQUIRRELVM v)
 {
-    SQ_FUNC_VARS(v);
+    SQ_FUNC_VARS(v);
 	SETUP_STREAM(v);
     SQ_GET_STRING(v, 2, str);
     SQ_OPT_INTEGER(v, 3, start, 0);
-    if(start < 0 || start > str_size) return sq_throwerror(v, _SC("start position out of range (%d)"), start);
+    if(start < 0 || start > str_size) return sq_throwerror(v, _SC("start position out of range (%d)"), start);
     SQ_OPT_INTEGER(v, 4, len, str_size - start);
-    if(len < 0 || len > (str_size-start)) return sq_throwerror(v, _SC("len value out of range (%d)"), len);
+    if(len < 0 || len > (str_size-start)) return sq_throwerror(v, _SC("len value out of range (%d)"), len);
+
+    if(self->Write(((SQChar*)str)+start, len) != len)
+            return sq_throwerror(v,_SC("io error"));
+	sq_pushinteger(v,len);
+	return 1;
+}
 
-    if(self->Write(((SQChar*)str)+start, len) != len)
-            return sq_throwerror(v,_SC("io error"));
-	sq_pushinteger(v,len);
-	return 1;
-}
-
-SQInteger _stream_write(HSQUIRRELVM v)
-{
-	const SQChar *str;
-	SQInteger total_size, size;
+SQInteger _stream_write(HSQUIRRELVM v)
+{
+	const SQChar *str;
+	SQInteger total_size, size;
 	SETUP_STREAM(v);
-	total_size = 0;
+	total_size = 0;
 	for(SQInteger i=2, len=sq_gettop(v); i <= len; ++i){
-        if(SQ_FAILED(sq_tostring(v,i)))
-            return sq_throwerror(v,_SC("invalid parameter"));
-        sq_getstring(v,-1,&str);
-        size = sq_getsize(v,-1);
-        if(self->Write((SQChar*)str,size) != size)
-            return sq_throwerror(v,_SC("io error"));
+        if(SQ_FAILED(sq_tostring(v,i)))
+            return sq_throwerror(v,_SC("invalid parameter"));
+        sq_getstring(v,-1,&str);
+        size = sq_getsize(v,-1);
+        if(self->Write((SQChar*)str,size) != size)
+            return sq_throwerror(v,_SC("io error"));
         sq_poptop(v); //remove converted string
         total_size += size;
-	}
-	sq_pushinteger(v,total_size);
-	return 1;
-}
+	}
+	sq_pushinteger(v,total_size);
+	return 1;
+}
 
-SQInteger _stream_write_non_null(HSQUIRRELVM v)
+SQInteger _stream_write_non_null(HSQUIRRELVM v)
 {
     if(sq_gettype(v, 2) != OT_NULL)
     {
         return _stream_write(v);
-    }
-	return 0;
-}
-
-SQInteger _stream_write_fmt(HSQUIRRELVM v)
-{
-	const SQChar *str;
-	SQInteger size;
-	SETUP_STREAM(v);
-	if(SQ_FAILED(sq_tostring(v,2)))
-		return sq_throwerror(v,_SC("invalid parameter"));
-    sq_getstring(v,-1,&str);
-	size = sq_getsize(v,-1);
-	if(self->Write((SQChar*)str,size) != size)
-		return sq_throwerror(v,_SC("io error"));
-    sq_poptop(v); //remove converted string
-	sq_pushinteger(v,size);
-	return 1;
-}
-
-SQInteger _stream_writeblob(HSQUIRRELVM v)
-{
-	SQUserPointer data;
-	SQInteger size;
-	SETUP_STREAM(v);
-	if(SQ_FAILED(sqstd_getblob(v,2,&data)))
-		return sq_throwerror(v,_SC("invalid parameter"));
-	size = sqstd_getblobsize(v,2);
-	if(self->Write(data,size) != size)
-		return sq_throwerror(v,_SC("io error"));
-	sq_pushinteger(v,size);
-	return 1;
-}
-
-SQInteger _stream_writen(HSQUIRRELVM v)
-{
-	SETUP_STREAM(v);
-	SQInteger format, ti;
-	SQFloat tf;
-	sq_getinteger(v, 3, &format);
-	switch(format) {
-	case 'l': {
-		SQInteger i;
-		sq_getinteger(v, 2, &ti);
-		i = ti;
-		self->Write(&i, sizeof(SQInteger));
-			  }
-		break;
-	case 'i': {
-		SQInt32 i;
-		sq_getinteger(v, 2, &ti);
-		i = (SQInt32)ti;
-		self->Write(&i, sizeof(SQInt32));
-			  }
-		break;
-	case 's': {
-		short s;
-		sq_getinteger(v, 2, &ti);
-		s = (short)ti;
-		self->Write(&s, sizeof(short));
-			  }
-		break;
-	case 'w': {
-		unsigned short w;
-		sq_getinteger(v, 2, &ti);
-		w = (unsigned short)ti;
-		self->Write(&w, sizeof(unsigned short));
-			  }
-		break;
-	case 'c': {
-		char c;
-		sq_getinteger(v, 2, &ti);
-		c = (char)ti;
-		self->Write(&c, sizeof(char));
-				  }
-		break;
-	case 'b': {
-		unsigned char b;
-		sq_getinteger(v, 2, &ti);
-		b = (unsigned char)ti;
-		self->Write(&b, sizeof(unsigned char));
-			  }
-		break;
-	case 'f': {
-		float f;
-		sq_getfloat(v, 2, &tf);
-		f = (float)tf;
-		self->Write(&f, sizeof(float));
-			  }
-		break;
-	case 'd': {
-		double d;
-		sq_getfloat(v, 2, &tf);
-		d = tf;
-		self->Write(&d, sizeof(double));
-			  }
-		break;
-	default:
-		return sq_throwerror(v, _SC("invalid format"));
-	}
-	return 0;
-}
-
-SQInteger _stream_seek(HSQUIRRELVM v)
-{
-	SETUP_STREAM(v);
-	SQInteger offset, origin = SQ_SEEK_SET;
-	sq_getinteger(v, 2, &offset);
-	if(sq_gettop(v) > 2) {
-		SQInteger t;
-		sq_getinteger(v, 3, &t);
-		switch(t) {
-			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"));
-		}
-	}
-	sq_pushinteger(v, self->Seek(offset, origin));
-	return 1;
-}
-
-SQInteger _stream_tell(HSQUIRRELVM v)
-{
-	SETUP_STREAM(v);
-	sq_pushinteger(v, self->Tell());
-	return 1;
-}
-
-SQInteger _stream_len(HSQUIRRELVM v)
-{
-	SETUP_STREAM(v);
-	sq_pushinteger(v, self->Len());
-	return 1;
-}
+    }
+	return 0;
+}
 
-SQInteger _stream_flush(HSQUIRRELVM v)
-{
-	SETUP_STREAM(v);
-	if(!self->Flush())
-		sq_pushinteger(v, 1);
-	else
-		sq_pushnull(v);
-	return 1;
-}
+SQInteger _stream_write_fmt(HSQUIRRELVM v)
+{
+	const SQChar *str;
+	SQInteger size;
+	SETUP_STREAM(v);
+	if(SQ_FAILED(sq_tostring(v,2)))
+		return sq_throwerror(v,_SC("invalid parameter"));
+    sq_getstring(v,-1,&str);
+	size = sq_getsize(v,-1);
+	if(self->Write((SQChar*)str,size) != size)
+		return sq_throwerror(v,_SC("io error"));
+    sq_poptop(v); //remove converted string
+	sq_pushinteger(v,size);
+	return 1;
+}
 
-SQInteger _stream_eos(HSQUIRRELVM v)
-{
-	SETUP_STREAM(v);
-	if(self->EOS())
-		sq_pushinteger(v, 1);
-	else
-		sq_pushnull(v);
-	return 1;
-}
+SQInteger _stream_writeblob(HSQUIRRELVM v)
+{
+	SQUserPointer data;
+	SQInteger size;
+	SETUP_STREAM(v);
+	if(SQ_FAILED(sqstd_getblob(v,2,&data)))
+		return sq_throwerror(v,_SC("invalid parameter"));
+	size = sqstd_getblobsize(v,2);
+	if(self->Write(data,size) != size)
+		return sq_throwerror(v,_SC("io error"));
+	sq_pushinteger(v,size);
+	return 1;
+}
+
+SQInteger _stream_writen(HSQUIRRELVM v)
+{
+	SETUP_STREAM(v);
+	SQInteger format, ti;
+	SQFloat tf;
+	sq_getinteger(v, 3, &format);
+	switch(format) {
+	case 'l': {
+		SQInteger i;
+		sq_getinteger(v, 2, &ti);
+		i = ti;
+		self->Write(&i, sizeof(SQInteger));
+			  }
+		break;
+	case 'i': {
+		SQInt32 i;
+		sq_getinteger(v, 2, &ti);
+		i = (SQInt32)ti;
+		self->Write(&i, sizeof(SQInt32));
+			  }
+		break;
+	case 's': {
+		short s;
+		sq_getinteger(v, 2, &ti);
+		s = (short)ti;
+		self->Write(&s, sizeof(short));
+			  }
+		break;
+	case 'w': {
+		unsigned short w;
+		sq_getinteger(v, 2, &ti);
+		w = (unsigned short)ti;
+		self->Write(&w, sizeof(unsigned short));
+			  }
+		break;
+	case 'c': {
+		char c;
+		sq_getinteger(v, 2, &ti);
+		c = (char)ti;
+		self->Write(&c, sizeof(char));
+				  }
+		break;
+	case 'b': {
+		unsigned char b;
+		sq_getinteger(v, 2, &ti);
+		b = (unsigned char)ti;
+		self->Write(&b, sizeof(unsigned char));
+			  }
+		break;
+	case 'f': {
+		float f;
+		sq_getfloat(v, 2, &tf);
+		f = (float)tf;
+		self->Write(&f, sizeof(float));
+			  }
+		break;
+	case 'd': {
+		double d;
+		sq_getfloat(v, 2, &tf);
+		d = tf;
+		self->Write(&d, sizeof(double));
+			  }
+		break;
+	default:
+		return sq_throwerror(v, _SC("invalid format"));
+	}
+	return 0;
+}
+
+SQInteger _stream_seek(HSQUIRRELVM v)
+{
+	SETUP_STREAM(v);
+	SQInteger offset, origin = SQ_SEEK_SET;
+	sq_getinteger(v, 2, &offset);
+	if(sq_gettop(v) > 2) {
+		SQInteger t;
+		sq_getinteger(v, 3, &t);
+		switch(t) {
+			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"));
+		}
+	}
+	sq_pushinteger(v, self->Seek(offset, origin));
+	return 1;
+}
+
+SQInteger _stream_tell(HSQUIRRELVM v)
+{
+	SETUP_STREAM(v);
+	sq_pushinteger(v, self->Tell());
+	return 1;
+}
+
+SQInteger _stream_len(HSQUIRRELVM v)
+{
+	SETUP_STREAM(v);
+	sq_pushinteger(v, self->Len());
+	return 1;
+}
+
+SQInteger _stream_flush(HSQUIRRELVM v)
+{
+	SETUP_STREAM(v);
+	if(!self->Flush())
+		sq_pushinteger(v, 1);
+	else
+		sq_pushnull(v);
+	return 1;
+}
+
+SQInteger _stream_eos(HSQUIRRELVM v)
+{
+	SETUP_STREAM(v);
+	if(self->EOS())
+		sq_pushinteger(v, 1);
+	else
+		sq_pushnull(v);
+	return 1;
+}
+
+ SQInteger _stream__cloned(HSQUIRRELVM v)
+ {
+	 return sq_throwerror(v,_SC("this object cannot be cloned"));
+ }
 
- SQInteger _stream__cloned(HSQUIRRELVM v)
- {
-	 return sq_throwerror(v,_SC("this object cannot be cloned"));
- }
-
-static SQRegFunction _stream_methods[] = {
-	_DECL_STREAM_FUNC(read_line,-1,_SC("xi")),
-	_DECL_STREAM_FUNC(read,2,_SC("xn")),
-	_DECL_STREAM_FUNC(gets,2,_SC("xn")),
-	_DECL_STREAM_FUNC(readblob,2,_SC("xn")),
-	_DECL_STREAM_FUNC(readn,2,_SC("xn")),
-	_DECL_STREAM_FUNC(write_str,-2,_SC("xsii")),
-	_DECL_STREAM_FUNC(write,-2,_SC("x.")),
-	_DECL_STREAM_FUNC(writeblob,-2,_SC("xx")),
-	_DECL_STREAM_FUNC(writen,3,_SC("xnn")),
-	_DECL_STREAM_FUNC(write_non_null,2,_SC("x.")),
-	_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(_cloned,0,NULL),
-	{NULL,(SQFUNCTION)0,0,NULL}
+#define _DECL_STREAM_FUNC2(name,name2, nparams,typecheck) {_SC(#name2),_stream_##name,nparams,typecheck}
+
+static SQRegFunction _stream_methods[] = {
+	_DECL_STREAM_FUNC(read_line,-1,_SC("xi")),
+	_DECL_STREAM_FUNC(read,2,_SC("xn")),
+	_DECL_STREAM_FUNC(gets,2,_SC("xn")),
+	_DECL_STREAM_FUNC(readblob,2,_SC("xn")),
+	_DECL_STREAM_FUNC(readn,2,_SC("xn")),
+	_DECL_STREAM_FUNC(write_str,-2,_SC("xsii")),
+	_DECL_STREAM_FUNC(write,-2,_SC("x.")),
+	_DECL_STREAM_FUNC(writeblob,-2,_SC("xx")),
+	_DECL_STREAM_FUNC(writen,3,_SC("xnn")),
+	_DECL_STREAM_FUNC(write_non_null,2,_SC("x.")),
+	_DECL_STREAM_FUNC(seek,-2,_SC("xnn")),
+	_DECL_STREAM_FUNC(tell,1,_SC("x")),
+	_DECL_STREAM_FUNC(len,1,_SC("x")),
+	_DECL_STREAM_FUNC2(len,size,1,_SC("x")),
+	_DECL_STREAM_FUNC2(len,length,1,_SC("x")),
+	_DECL_STREAM_FUNC(eos,1,_SC("x")),
+	_DECL_STREAM_FUNC(flush,1,_SC("x")),
+	_DECL_STREAM_FUNC(_cloned,0,NULL),
+	{NULL,(SQFUNCTION)0,0,NULL}
 };
 
-void init_streamclass(HSQUIRRELVM v)
-{
-	sq_pushregistrytable(v);
-	sq_pushstring(v,SQSTD_STREAM_TYPE_TAG,-1);
-	if(SQ_FAILED(sq_get(v,-2))) {
-		sq_pushstring(v,SQSTD_STREAM_TYPE_TAG,-1);
-		sq_newclass(v,SQFalse);
-		sq_settypetag(v,-1,(SQUserPointer)SQSTD_STREAM_TYPE_TAG);
-		SQInteger i = 0;
-		while(_stream_methods[i].name != 0) {
-			SQRegFunction &f = _stream_methods[i];
-			sq_pushstring(v,f.name,-1);
-			sq_newclosure(v,f.f,0);
-			sq_setparamscheck(v,f.nparamscheck,f.typemask);
-			sq_newslot(v,-3,SQFalse);
-			i++;
-		}
-		sq_newslot(v,-3,SQFalse);
-		sq_pushroottable(v);
-		sq_pushstring(v,_SC("stream"),-1);
-		sq_pushstring(v,_SC("std_stream"),-1);
-		sq_get(v,-4);
-		sq_newslot(v,-3,SQFalse);
-		sq_pop(v,1);
-	}
-	else {
-		sq_pop(v,1); //result
-	}
-	sq_pop(v,1);
-}
-
-SQRESULT declare_stream(HSQUIRRELVM v,const SQChar* name,SQUserPointer typetag,const SQChar* reg_name,const SQRegFunction *methods,const SQRegFunction *globals)
-{
-	if(sq_gettype(v,-1) != OT_TABLE)
-		return sq_throwerror(v,_SC("table expected"));
-	SQInteger 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);
-	if(SQ_SUCCEEDED(sq_get(v,-3))) {
-		sq_newclass(v,SQTrue);
-		sq_settypetag(v,-1,typetag);
-		SQInteger i = 0;
-		while(methods[i].name != 0) {
-			const SQRegFunction &f = methods[i];
-			sq_pushstring(v,f.name,-1);
-			sq_newclosure(v,f.f,0);
-			sq_setparamscheck(v,f.nparamscheck,f.typemask);
-			sq_setnativeclosurename(v,-1,f.name);
-			sq_newslot(v,-3,SQFalse);
-			i++;
-		}
-		sq_newslot(v,-3,SQFalse);
-		sq_pop(v,1);
-
-		i = 0;
-		while(globals[i].name!=0)
-		{
-			const SQRegFunction &f = globals[i];
-			sq_pushstring(v,f.name,-1);
-			sq_newclosure(v,f.f,0);
-			sq_setparamscheck(v,f.nparamscheck,f.typemask);
-			sq_setnativeclosurename(v,-1,f.name);
-			sq_newslot(v,-3,SQFalse);
-			i++;
-		}
-		//register the class in the target table
-		sq_pushstring(v,name,-1);
-		sq_pushregistrytable(v);
-		sq_pushstring(v,reg_name,-1);
-		sq_get(v,-2);
-		sq_remove(v,-2);
-		sq_newslot(v,-3,SQFalse);
-
-		sq_settop(v,top);
-		return SQ_OK;
-	}
-	sq_settop(v,top);
-	return SQ_ERROR;
-}
+void init_streamclass(HSQUIRRELVM v)
+{
+	sq_pushregistrytable(v);
+	sq_pushstring(v,SQSTD_STREAM_TYPE_TAG,-1);
+	if(SQ_FAILED(sq_get(v,-2))) {
+		sq_pushstring(v,SQSTD_STREAM_TYPE_TAG,-1);
+		sq_newclass(v,SQFalse);
+		sq_settypetag(v,-1,(SQUserPointer)SQSTD_STREAM_TYPE_TAG);
+		SQInteger i = 0;
+		while(_stream_methods[i].name != 0) {
+			SQRegFunction &f = _stream_methods[i];
+			sq_pushstring(v,f.name,-1);
+			sq_newclosure(v,f.f,0);
+			sq_setparamscheck(v,f.nparamscheck,f.typemask);
+			sq_newslot(v,-3,SQFalse);
+			i++;
+		}
+		sq_newslot(v,-3,SQFalse);
+		sq_pushroottable(v);
+		sq_pushstring(v,_SC("stream"),-1);
+		sq_pushstring(v,_SC("std_stream"),-1);
+		sq_get(v,-4);
+		sq_newslot(v,-3,SQFalse);
+		sq_pop(v,1);
+	}
+	else {
+		sq_pop(v,1); //result
+	}
+	sq_pop(v,1);
+}
+
+SQRESULT declare_stream(HSQUIRRELVM v,const SQChar* name,SQUserPointer typetag,const SQChar* reg_name,const SQRegFunction *methods,const SQRegFunction *globals)
+{
+	if(sq_gettype(v,-1) != OT_TABLE)
+		return sq_throwerror(v,_SC("table expected"));
+	SQInteger 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);
+	if(SQ_SUCCEEDED(sq_get(v,-3))) {
+		sq_newclass(v,SQTrue);
+		sq_settypetag(v,-1,typetag);
+		SQInteger i = 0;
+		while(methods[i].name != 0) {
+			const SQRegFunction &f = methods[i];
+			sq_pushstring(v,f.name,-1);
+			sq_newclosure(v,f.f,0);
+			sq_setparamscheck(v,f.nparamscheck,f.typemask);
+			sq_setnativeclosurename(v,-1,f.name);
+			sq_newslot(v,-3,SQFalse);
+			i++;
+		}
+		sq_newslot(v,-3,SQFalse);
+		sq_pop(v,1);
+
+		i = 0;
+		while(globals[i].name!=0)
+		{
+			const SQRegFunction &f = globals[i];
+			sq_pushstring(v,f.name,-1);
+			sq_newclosure(v,f.f,0);
+			sq_setparamscheck(v,f.nparamscheck,f.typemask);
+			sq_setnativeclosurename(v,-1,f.name);
+			sq_newslot(v,-3,SQFalse);
+			i++;
+		}
+		//register the class in the target table
+		sq_pushstring(v,name,-1);
+		sq_pushregistrytable(v);
+		sq_pushstring(v,reg_name,-1);
+		sq_get(v,-2);
+		sq_remove(v,-2);
+		sq_newslot(v,-3,SQFalse);
+
+		sq_settop(v,top);
+		return SQ_OK;
+	}
+	sq_settop(v,top);
+	return SQ_ERROR;
+}

SquiLu/sqstdlib/sqstdsystem.cpp

@@ -1,39 +1,39 @@
-/* see copyright notice in squirrel.h */
+/* see copyright notice in squirrel.h */
 #include <squirrel.h>
 #include <string.h>
-#include "sqstdblobimpl.h"
-#include <time.h>
-#include <stdlib.h>
+#include "sqstdblobimpl.h"
+#include <time.h>
+#include <stdlib.h>
 #include <stdio.h>
 #ifdef _WIN32_WCE
 #include "celibc.h"
 #else
 #include <signal.h>
-#endif
+#endif
 #include <sqstdsystem.h>
 
 #ifdef _WIN32
 #include <windows.h>
 #else
 #include <unistd.h>
-#endif
-
-#ifdef SQUNICODE
-#include <wchar.h>
-#define scgetenv _wgetenv
-#define scsystem _wsystem
-#define scasctime _wasctime
-#define scstrftime _wstrftime
-#define scremove _wremove
-#define screname _wrename
-#else
-#define scgetenv getenv
-#define scsystem system
-#define scasctime asctime
-#define scstrftime strftime
-#define scremove remove
-#define screname rename
-#endif
+#endif
+
+#ifdef SQUNICODE
+#include <wchar.h>
+#define scgetenv _wgetenv
+#define scsystem _wsystem
+#define scasctime _wasctime
+#define scstrftime _wstrftime
+#define scremove _wremove
+#define screname _wrename
+#else
+#define scgetenv getenv
+#define scsystem system
+#define scasctime asctime
+#define scstrftime strftime
+#define scremove remove
+#define screname rename
+#endif
 
 SQ_OPT_STRING_STRLEN();
 
@@ -45,11 +45,11 @@ SQ_OPT_STRING_STRLEN();
 #include <uuid/uuid.h>
 #endif
 
-static SQRESULT _system_getuuid(HSQUIRRELVM v)
-{
+static SQRESULT _system_getuuid(HSQUIRRELVM v)
+{
     char s[64];
 #ifdef _WIN32
-    UUID uuid;
+    UUID uuid;
     UuidCreate ( &uuid );
 
     UuidToStringA ( &uuid, (unsigned char**)&s );
@@ -62,44 +62,44 @@ static SQRESULT _system_getuuid(HSQUIRRELVM v)
     uuid_generate_random ( uuid );
     uuid_unparse ( uuid, s );
     sq_pushstring(v,s,-1);
-#endif
-	return 1;
-}
-#endif
-static SQRESULT _system_getenv(HSQUIRRELVM v)
-{
-	const SQChar *s;
-	if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){
-        sq_pushstring(v,scgetenv(s),-1);
-		return 1;
-	}
-	return 0;
-}
-
-static SQRESULT _system_system(HSQUIRRELVM v)
-{
-	const SQChar *s;
-	if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){
-		sq_pushinteger(v,scsystem(s));
-		return 1;
-	}
-	return sq_throwerror(v,_SC("wrong param"));
-}
-
-
-static SQRESULT _system_clock(HSQUIRRELVM v)
-{
-	sq_pushfloat(v,((SQFloat)clock())/(SQFloat)CLOCKS_PER_SEC);
-	return 1;
-}
-
-/*
-static SQRESULT _system_time(HSQUIRRELVM v)
-{
-	time_t t;
-	time(&t);
-	sq_pushinteger(v,*((SQInteger *)&t));
-	return 1;
+#endif
+	return 1;
+}
+#endif
+static SQRESULT _system_getenv(HSQUIRRELVM v)
+{
+	const SQChar *s;
+	if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){
+        sq_pushstring(v,scgetenv(s),-1);
+		return 1;
+	}
+	return 0;
+}
+
+static SQRESULT _system_system(HSQUIRRELVM v)
+{
+	const SQChar *s;
+	if(SQ_SUCCEEDED(sq_getstring(v,2,&s))){
+		sq_pushinteger(v,scsystem(s));
+		return 1;
+	}
+	return sq_throwerror(v,_SC("wrong param"));
+}
+
+
+static SQRESULT _system_clock(HSQUIRRELVM v)
+{
+	sq_pushfloat(v,((SQFloat)clock())/(SQFloat)CLOCKS_PER_SEC);
+	return 1;
+}
+
+/*
+static SQRESULT _system_time(HSQUIRRELVM v)
+{
+	time_t t;
+	time(&t);
+	sq_pushinteger(v,*((SQInteger *)&t));
+	return 1;
 }
 */
 
@@ -167,43 +167,43 @@ static SQRESULT _system_time(HSQUIRRELVM v) {
   else sq_pushinteger(v,(SQInteger)t);
   return 1;
 }
-
-
+
+
 static SQRESULT _system_difftime (HSQUIRRELVM v) {
     SQ_FUNC_VARS(v);
     SQ_GET_FLOAT(v, 2, t1);
     SQ_OPT_FLOAT(v, 3, t2, 0);
     sq_pushfloat(v, difftime( (time_t)t1, (time_t)t2));
   return 1;
-}
-
-static SQRESULT _system_remove(HSQUIRRELVM v)
-{
-	const SQChar *s;
-	sq_getstring(v,2,&s);
-	if(scremove(s)==-1)
-		return sq_throwerror(v,_SC("remove() failed"));
-	return 0;
-}
-
-static SQRESULT _system_rename(HSQUIRRELVM v)
-{
-	const SQChar *oldn,*newn;
-	sq_getstring(v,2,&oldn);
-	sq_getstring(v,3,&newn);
-	if(screname(oldn,newn)==-1)
-		return sq_throwerror(v,_SC("rename() failed"));
-	return 0;
-}
-
-static void _set_integer_slot(HSQUIRRELVM v,const SQChar *name,SQInteger val)
-{
-	sq_pushstring(v,name,-1);
-	sq_pushinteger(v,val);
-	sq_rawset(v,-3);
-}
-
-static SQRESULT _system_date(HSQUIRRELVM v)
+}
+
+static SQRESULT _system_remove(HSQUIRRELVM v)
+{
+	const SQChar *s;
+	sq_getstring(v,2,&s);
+	if(scremove(s)==-1)
+		return sq_throwerror(v,_SC("remove() failed"));
+	return 0;
+}
+
+static SQRESULT _system_rename(HSQUIRRELVM v)
+{
+	const SQChar *oldn,*newn;
+	sq_getstring(v,2,&oldn);
+	sq_getstring(v,3,&newn);
+	if(screname(oldn,newn)==-1)
+		return sq_throwerror(v,_SC("rename() failed"));
+	return 0;
+}
+
+static void _set_integer_slot(HSQUIRRELVM v,const SQChar *name,SQInteger val)
+{
+	sq_pushstring(v,name,-1);
+	sq_pushinteger(v,val);
+	sq_rawset(v,-3);
+}
+
+static SQRESULT _system_date(HSQUIRRELVM v)
 {
     SQ_FUNC_VARS(v);
     const SQChar *arg_format;
@@ -230,7 +230,7 @@ static SQRESULT _system_date(HSQUIRRELVM v)
         arg_format = _SC("%c");
         arg_time = time(NULL);
     }
-	time_t t = (time_t)arg_time;
+	time_t t = (time_t)arg_time;
 
     struct tm *stm;
 #ifdef SQ_USE_LOCALTIME_R
@@ -251,14 +251,14 @@ static SQRESULT _system_date(HSQUIRRELVM v)
     if (stm == NULL)  /* invalid date? */
         sq_pushnull(v);
     else if (scstrcmp(arg_format, _SC("*t")) == 0) {
-        sq_newtableex(v, 9); /* 9 = number of fields */
-        _set_integer_slot(v, _SC("sec"), stm->tm_sec);
-        _set_integer_slot(v, _SC("min"), stm->tm_min);
-        _set_integer_slot(v, _SC("hour"), stm->tm_hour);
-        _set_integer_slot(v, _SC("day"), stm->tm_mday);
-        _set_integer_slot(v, _SC("month"), stm->tm_mon);
-        _set_integer_slot(v, _SC("year"), stm->tm_year+1900);
-        _set_integer_slot(v, _SC("wday"), stm->tm_wday);
+        sq_newtableex(v, 9); /* 9 = number of fields */
+        _set_integer_slot(v, _SC("sec"), stm->tm_sec);
+        _set_integer_slot(v, _SC("min"), stm->tm_min);
+        _set_integer_slot(v, _SC("hour"), stm->tm_hour);
+        _set_integer_slot(v, _SC("day"), stm->tm_mday);
+        _set_integer_slot(v, _SC("month"), stm->tm_mon);
+        _set_integer_slot(v, _SC("year"), stm->tm_year+1900);
+        _set_integer_slot(v, _SC("wday"), stm->tm_wday);
         _set_integer_slot(v, _SC("yday"), stm->tm_yday);
         sq_pushliteral(v, _SC("isdst"));
         sq_pushbool(v, stm->tm_isdst);
@@ -281,9 +281,9 @@ static SQRESULT _system_date(HSQUIRRELVM v)
         }
         sq_pushstring(v, (const SQChar*)b.GetBuf(), b.Len());
     }
-    return 1;
+    return 1;
 }
-
+
 static SQRESULT _system_exit (HSQUIRRELVM v) {
   SQRESULT status = 0;
   SQ_FUNC_VARS(v);
@@ -348,7 +348,7 @@ static SQRESULT _system_setlocale (HSQUIRRELVM v) {
   return 0;
 #endif
 }
-
+
 /*-------------------------------------------------------------------------*\
 * Sleep for n miliseconds.
 \*-------------------------------------------------------------------------*/
@@ -609,56 +609,56 @@ static SQRESULT _system_raise(HSQUIRRELVM v)
     return sig;
 }
 #endif
-
-#define _DECL_FUNC(name,nparams,pmask) {_SC(#name),_system_##name,nparams,pmask}
+
+#define _DECL_FUNC(name,nparams,pmask) {_SC(#name),_system_##name,nparams,pmask}
 static SQRegFunction systemlib_funcs[]={
-	_DECL_FUNC(getenv,2,_SC(".s")),
-	_DECL_FUNC(system,2,_SC(".s")),
-	_DECL_FUNC(clock,0,NULL),
-	_DECL_FUNC(remove,2,_SC(".s")),
-	_DECL_FUNC(rename,3,_SC(".ss")),
-	_DECL_FUNC(date,-1,_SC(". s|n")),
-	_DECL_FUNC(tmpname,1,_SC(".")),
-	_DECL_FUNC(setlocale,-1,_SC(".ss")),
+	_DECL_FUNC(getenv,2,_SC(".s")),
+	_DECL_FUNC(system,2,_SC(".s")),
+	_DECL_FUNC(clock,0,NULL),
+	_DECL_FUNC(remove,2,_SC(".s")),
+	_DECL_FUNC(rename,3,_SC(".ss")),
+	_DECL_FUNC(date,-1,_SC(". s|n")),
+	_DECL_FUNC(tmpname,1,_SC(".")),
+	_DECL_FUNC(setlocale,-1,_SC(".ss")),
 	_DECL_FUNC(time,-1,_SC(".t")),
-	_DECL_FUNC(difftime,-2,_SC(".nn")),
-	_DECL_FUNC(exit, -1,_SC(". b|i b")),
+	_DECL_FUNC(difftime,-2,_SC(".nn")),
+	_DECL_FUNC(exit, -1,_SC(". b|i b")),
 	_DECL_FUNC(sleep, 2,_SC(".i")),
-#ifdef WITH_UUID
+#ifdef WITH_UUID
 	_DECL_FUNC(getuuid, 0, NULL),
-#endif
-#ifndef _WIN32_WCE
-	_DECL_FUNC(getmillicount,1,_SC(".")),
-	_DECL_FUNC(getmillispan,2,_SC(".i")),
+#endif
+#ifndef _WIN32_WCE
+	_DECL_FUNC(getmillicount,1,_SC(".")),
+	_DECL_FUNC(getmillispan,2,_SC(".i")),
 #endif
 #ifdef USE_SIGNAL_HANDLER
-	_DECL_FUNC(set_signal_received,2,_SC(".i")),
-	_DECL_FUNC(get_signal_received,1,_SC(".")),
-	_DECL_FUNC(signal,2,_SC(". i|s")),
+	_DECL_FUNC(set_signal_received,2,_SC(".i")),
+	_DECL_FUNC(get_signal_received,1,_SC(".")),
+	_DECL_FUNC(signal,2,_SC(". i|s")),
 	_DECL_FUNC(raise,2,_SC(". i|s")),
 	_DECL_FUNC(signal_str2int,2,_SC(".s")),
 	_DECL_FUNC(signal_int2str,2,_SC(".i")),
-#endif
-	{NULL,(SQFUNCTION)0,0,NULL}
-};
-#undef _DECL_FUNC
-
-SQInteger sqstd_register_systemlib(HSQUIRRELVM v)
-{
+#endif
+	{NULL,(SQFUNCTION)0,0,NULL}
+};
+#undef _DECL_FUNC
+
+SQInteger sqstd_register_systemlib(HSQUIRRELVM v)
+{
     sq_pushstring(v,_SC("os"),-1);
     sq_newtable(v);
 
-	SQInteger i=0;
-	while(systemlib_funcs[i].name!=0)
-	{
-		sq_pushstring(v,systemlib_funcs[i].name,-1);
-		sq_newclosure(v,systemlib_funcs[i].f,0);
-		sq_setparamscheck(v,systemlib_funcs[i].nparamscheck,systemlib_funcs[i].typemask);
-		sq_setnativeclosurename(v,-1,systemlib_funcs[i].name);
-		sq_newslot(v,-3,SQFalse);
-		i++;
-	}
-
-	sq_newslot(v,-3,SQTrue); //insert os
-	return 1;
-}
+	SQInteger i=0;
+	while(systemlib_funcs[i].name!=0)
+	{
+		sq_pushstring(v,systemlib_funcs[i].name,-1);
+		sq_newclosure(v,systemlib_funcs[i].f,0);
+		sq_setparamscheck(v,systemlib_funcs[i].nparamscheck,systemlib_funcs[i].typemask);
+		sq_setnativeclosurename(v,-1,systemlib_funcs[i].name);
+		sq_newslot(v,-3,SQFalse);
+		i++;
+	}
+
+	sq_newslot(v,-3,SQTrue); //insert os
+	return 1;
+}

SquiLu/squirrel/sq_lexer.cpp

@@ -79,7 +79,7 @@ static SQRESULT sq_SQLexer_constructor(HSQUIRRELVM v){
 
     self->lex->Init(v->_sharedstate, sq_strbuf_lexfeed, &self->buf, NULL, NULL, want_comments);
 
-    sq_setinstanceup(v, 1, self);
+    sq_setinstanceup(v, 1, self);
     sq_setreleasehook(v,1, SQLexer_release_hook);
 
 	return 1;

SquiLu/squirrel/sqapi.cpp

@@ -14,6 +14,13 @@
 #include "sqclass.h"
 #include <stdarg.h>
 
+void sq_raise_type_error(HSQUIRRELVM v, SQObjectType type,SQObjectPtr &o)
+{
+    SQObjectPtr oval = v->PrintObjVal(o);
+    v->Raise_Error(_SC("wrong argument type, expected '%s' got '%.50s'"),IdType2Name(type),_stringval(oval));
+}
+#define _CHECK_OBJ_TYPE(v,otype,o) if(type(o) != otype) {sq_raise_type_error(v, otype, o); return SQ_ERROR;}
+
 bool sq_aux_gettypedarg(HSQUIRRELVM v,SQInteger idx,SQObjectType type,SQObjectPtr **o)
 {
 	*o = &stack_get(v,idx);
@@ -123,13 +130,13 @@ void sq_setnativedebughook(HSQUIRRELVM v,SQDEBUGHOOK hook)
 
 void sq_setdebughook(HSQUIRRELVM v)
 {
-	SQObjectPtr &o = stack_get(v,-1);
-	if(sq_isclosure(o) || sq_isnativeclosure(o) || sq_isnull(o)) {
-		v->_debughook_closure = o;
-		v->_debughook_native = NULL;
-		v->_debughook = !sq_isnull(o);
-		v->Pop();
-	}
+    SQObjectPtr &o = stack_get(v,-1);
+    if(sq_isclosure(o) || sq_isnativeclosure(o) || sq_isnull(o)) {
+        v->_debughook_closure = o;
+        v->_debughook_native = NULL;
+        v->_debughook = !sq_isnull(o);
+        v->Pop();
+    }
 }
 
 void sq_close(HSQUIRRELVM v)
@@ -201,6 +208,12 @@ SQBool sq_release(HSQUIRRELVM v,HSQOBJECT *po)
 #endif
 }
 
+SQUnsignedInteger sq_getvmrefcount(HSQUIRRELVM SQ_UNUSED_ARG(v), const HSQOBJECT *po)
+{
+    if (!ISREFCOUNTED(type(*po))) return 0;
+    return po->_unVal.pRefCounted->_uiRef;
+}
+
 const SQChar *sq_objtostring(const HSQOBJECT *o)
 {
 	if(sq_type(*o) == OT_STRING) {
@@ -283,7 +296,12 @@ void sq_pushfloat(HSQUIRRELVM v,SQFloat n)
 
 void sq_pushuserpointer(HSQUIRRELVM v,SQUserPointer p)
 {
-	v->Push(p);
+    v->Push(p);
+}
+
+void sq_pushthread(HSQUIRRELVM v, HSQUIRRELVM thread)
+{
+    v->Push(thread);
 }
 
 SQUserPointer sq_newuserdata(HSQUIRRELVM v,SQUnsignedInteger size)
@@ -370,9 +388,9 @@ SQBool sq_instanceof(HSQUIRRELVM v)
 SQRESULT sq_arrayappend(HSQUIRRELVM v,SQInteger idx)
 {
 	sq_aux_paramscheck(v,2);
-	SQObjectPtr *arr;
-	_GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
-	_array(*arr)->Append(v->GetUp(-1));
+	SQObjectPtr &arr = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_ARRAY, arr);
+	_array(arr)->Append(v->GetUp(-1));
 	v->Pop();
 	return SQ_OK;
 }
@@ -380,11 +398,11 @@ SQRESULT sq_arrayappend(HSQUIRRELVM v,SQInteger idx)
 SQRESULT sq_arraypop(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
 {
 	sq_aux_paramscheck(v, 1);
-	SQObjectPtr *arr;
-	_GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
-	if(_array(*arr)->Size() > 0) {
-        if(pushval != 0){ v->Push(_array(*arr)->Top()); }
-		_array(*arr)->Pop();
+	SQObjectPtr &arr = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_ARRAY, arr);
+	if(_array(arr)->Size() > 0) {
+        if(pushval != 0){ v->Push(_array(arr)->Top()); }
+		_array(arr)->Pop();
 		return SQ_OK;
 	}
 	return sq_throwerror(v, _SC("empty array"));
@@ -393,10 +411,10 @@ SQRESULT sq_arraypop(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
 SQRESULT sq_arrayresize(HSQUIRRELVM v,SQInteger idx,SQInteger newsize)
 {
 	sq_aux_paramscheck(v,1);
-	SQObjectPtr *arr;
-	_GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
+	SQObjectPtr &arr = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_ARRAY, arr);
 	if(newsize >= 0) {
-		_array(*arr)->Resize(newsize);
+		_array(arr)->Resize(newsize);
 		return SQ_OK;
 	}
 	return sq_throwerror(v,_SC("negative size"));
@@ -406,9 +424,9 @@ SQRESULT sq_arrayresize(HSQUIRRELVM v,SQInteger idx,SQInteger newsize)
 SQRESULT sq_arrayreverse(HSQUIRRELVM v,SQInteger idx)
 {
 	sq_aux_paramscheck(v, 1);
-	SQObjectPtr *o;
-	_GETSAFE_OBJ(v, idx, OT_ARRAY,o);
-	SQArray *arr = _array(*o);
+	SQObjectPtr &o = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_ARRAY, o);
+	SQArray *arr = _array(o);
 	if(arr->Size() > 0) {
 		SQObjectPtr t;
 		SQInteger size = arr->Size();
@@ -426,17 +444,17 @@ SQRESULT sq_arrayreverse(HSQUIRRELVM v,SQInteger idx)
 SQRESULT sq_arrayremove(HSQUIRRELVM v,SQInteger idx,SQInteger itemidx)
 {
 	sq_aux_paramscheck(v, 1);
-	SQObjectPtr *arr;
-	_GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
-	return _array(*arr)->Remove(itemidx) ? SQ_OK : sq_throwerror(v,_SC("index out of range"));
+	SQObjectPtr &arr = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_ARRAY, arr);
+	return _array(arr)->Remove(itemidx) ? SQ_OK : sq_throwerror(v,_SC("index out of range"));
 }
 
 SQRESULT sq_arrayinsert(HSQUIRRELVM v,SQInteger idx,SQInteger destpos)
 {
 	sq_aux_paramscheck(v, 1);
-	SQObjectPtr *arr;
-	_GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
-	SQRESULT ret = _array(*arr)->Insert(destpos, v->GetUp(-1)) ? SQ_OK : sq_throwerror(v,_SC("index out of range"));
+	SQObjectPtr &arr = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_ARRAY, arr);
+	SQRESULT ret = _array(arr)->Insert(destpos, v->GetUp(-1)) ? SQ_OK : sq_throwerror(v,_SC("index out of range"));
 	v->Pop();
 	return ret;
 }
@@ -444,9 +462,9 @@ SQRESULT sq_arrayinsert(HSQUIRRELVM v,SQInteger idx,SQInteger destpos)
 SQRESULT sq_arrayset(HSQUIRRELVM v,SQInteger idx,SQInteger destpos)
 {
 	sq_aux_paramscheck(v, 1);
-	SQObjectPtr *arr;
-	_GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
-	SQRESULT ret = _array(*arr)->Set(destpos, v->GetUp(-1)) ? SQ_OK : sq_throwerror(v,_SC("index out of range"));
+	SQObjectPtr &arr = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_ARRAY, arr);
+	SQRESULT ret = _array(arr)->Set(destpos, v->GetUp(-1)) ? SQ_OK : sq_throwerror(v,_SC("index out of range"));
 	v->Pop();
 	return ret;
 }
@@ -454,10 +472,10 @@ SQRESULT sq_arrayset(HSQUIRRELVM v,SQInteger idx,SQInteger destpos)
 SQRESULT sq_arrayget(HSQUIRRELVM v,SQInteger idx,SQInteger pos)
 {
 	sq_aux_paramscheck(v, 1);
-	SQObjectPtr *arr;
-	_GETSAFE_OBJ(v, idx, OT_ARRAY,arr);
+	SQObjectPtr &arr = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_ARRAY, arr);
 	v->PushNull();
-	if(!_array(*arr)->Get(pos, v->GetUp(-1)))
+	if(!_array(arr)->Get(pos, v->GetUp(-1)))
 	{
         v->Pop();
         return sq_throwerror(v,_SC("index out of range"));
@@ -611,6 +629,27 @@ SQRESULT sq_getclosurename(HSQUIRRELVM v,SQInteger idx)
 	return SQ_OK;
 }
 
+SQRESULT sq_setclosureroot(HSQUIRRELVM v,SQInteger idx)
+{
+    SQObjectPtr &c = stack_get(v,idx);
+    SQObject o = stack_get(v, -1);
+    if(!sq_isclosure(c)) return sq_throwerror(v, _SC("closure expected"));
+    if(sq_istable(o)) {
+        _closure(c)->SetRoot(_table(o)->GetWeakRef(OT_TABLE));
+        v->Pop();
+        return SQ_OK;
+    }
+    return sq_throwerror(v, _SC("ivalid type"));
+}
+
+SQRESULT sq_getclosureroot(HSQUIRRELVM v,SQInteger idx)
+{
+    SQObjectPtr &c = stack_get(v,idx);
+    if(!sq_isclosure(c)) return sq_throwerror(v, _SC("closure expected"));
+    v->Push(_closure(c)->_root->_obj);
+    return SQ_OK;
+}
+
 SQRESULT sq_clear(HSQUIRRELVM v,SQInteger idx)
 {
 	SQObjectPtr &o=stack_get(v,idx);
@@ -746,12 +785,42 @@ SQRESULT sq_setconsttable(HSQUIRRELVM v)
 
 void sq_setforeignptr(HSQUIRRELVM v,SQUserPointer p)
 {
-	v->_foreignptr = p;
+    v->_foreignptr = p;
 }
 
 SQUserPointer sq_getforeignptr(HSQUIRRELVM v)
 {
-	return v->_foreignptr;
+    return v->_foreignptr;
+}
+
+void sq_setsharedforeignptr(HSQUIRRELVM v,SQUserPointer p)
+{
+    _ss(v)->_foreignptr = p;
+}
+
+SQUserPointer sq_getsharedforeignptr(HSQUIRRELVM v)
+{
+    return _ss(v)->_foreignptr;
+}
+
+void sq_setvmreleasehook(HSQUIRRELVM v,SQRELEASEHOOK hook)
+{
+    v->_releasehook = hook;
+}
+
+SQRELEASEHOOK sq_getvmreleasehook(HSQUIRRELVM v)
+{
+    return v->_releasehook;
+}
+
+void sq_setsharedreleasehook(HSQUIRRELVM v,SQRELEASEHOOK hook)
+{
+    _ss(v)->_releasehook = hook;
+}
+
+SQRELEASEHOOK sq_getsharedreleasehook(HSQUIRRELVM v)
+{
+    return _ss(v)->_releasehook;
 }
 
 void sq_push(HSQUIRRELVM v,SQInteger idx)
@@ -853,26 +922,26 @@ SQRESULT sq_getbool(HSQUIRRELVM v,SQInteger idx,SQBool *b)
 
 SQRESULT sq_getstring(HSQUIRRELVM v,SQInteger idx,const SQChar **c)
 {
-	SQObjectPtr *o = NULL;
-	_GETSAFE_OBJ(v, idx, OT_STRING,o);
-	*c = _stringval(*o);
+	SQObjectPtr &o = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_STRING, o);
+	*c = _stringval(o);
 	return SQ_OK;
 }
 
 SQRESULT sq_getstr_and_size(HSQUIRRELVM v,SQInteger idx,const SQChar **c, SQInteger *size)
 {
-	SQObjectPtr *o = NULL;
-	_GETSAFE_OBJ(v, idx, OT_STRING,o);
-	*c = _stringval(*o);
-	*size = _string(*o)->_len;
+	SQObjectPtr &o = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_STRING, o);
+	*c = _stringval(o);
+	*size = _string(o)->_len;
 	return SQ_OK;
 }
 
 SQRESULT sq_getthread(HSQUIRRELVM v,SQInteger idx,HSQUIRRELVM *thread)
 {
-	SQObjectPtr *o = NULL;
-	_GETSAFE_OBJ(v, idx, OT_THREAD,o);
-	*thread = _thread(*o);
+	SQObjectPtr &o = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_THREAD, o);
+	*thread = _thread(o);
 	return SQ_OK;
 }
 
@@ -911,10 +980,10 @@ SQHash sq_gethash(HSQUIRRELVM v, SQInteger idx)
 
 SQRESULT sq_getuserdata(HSQUIRRELVM v,SQInteger idx,SQUserPointer *p,SQUserPointer *typetag)
 {
-	SQObjectPtr *o = NULL;
-	_GETSAFE_OBJ(v, idx, OT_USERDATA,o);
-	(*p) = _userdataval(*o);
-	if(typetag) *typetag = _userdata(*o)->_typetag;
+	SQObjectPtr &o = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_USERDATA, o);
+	(*p) = _userdataval(o);
+	if(typetag) *typetag = _userdata(o)->_typetag;
 	return SQ_OK;
 }
 
@@ -950,9 +1019,9 @@ SQRESULT sq_gettypetag(HSQUIRRELVM v,SQInteger idx,SQUserPointer *typetag)
 
 SQRESULT sq_getuserpointer(HSQUIRRELVM v, SQInteger idx, SQUserPointer *p)
 {
-	SQObjectPtr *o = NULL;
-	_GETSAFE_OBJ(v, idx, OT_USERPOINTER,o);
-	(*p) = _userpointer(*o);
+	SQObjectPtr &o = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_USERPOINTER, o);
+	(*p) = _userpointer(o);
 	return SQ_OK;
 }
 
@@ -1074,12 +1143,12 @@ SQRESULT sq_newslot(HSQUIRRELVM v, SQInteger idx, SQBool bstatic)
 SQRESULT sq_deleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
 {
 	sq_aux_paramscheck(v, 2);
-	SQObjectPtr *self;
-	_GETSAFE_OBJ(v, idx, OT_TABLE,self);
+	SQObjectPtr &self = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_TABLE, self);
 	SQObjectPtr &key = v->GetUp(-1);
 	if(type(key) == OT_NULL) return sq_throwerror(v, _SC("null is not a valid key"));
 	SQObjectPtr res;
-	if(!v->DeleteSlot(*self, key, res)){
+	if(!v->DeleteSlot(self, key, res)){
 		v->Pop();
 		return SQ_ERROR;
 	}
@@ -1188,12 +1257,12 @@ SQRESULT sq_setdelegate(HSQUIRRELVM v,SQInteger idx)
 SQRESULT sq_rawdeleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval)
 {
 	sq_aux_paramscheck(v, 2);
-	SQObjectPtr *self;
-	_GETSAFE_OBJ(v, idx, OT_TABLE,self);
+	SQObjectPtr &self = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_TABLE, self);
 	SQObjectPtr &key = v->GetUp(-1);
 	SQObjectPtr t;
-	if(_table(*self)->Get(key,t)) {
-		_table(*self)->Remove(key);
+	if(_table(self)->Get(key,t)) {
+		_table(self)->Remove(key);
 	}
 	if(pushval != 0)
 		v->GetUp(-1) = t;
@@ -1503,6 +1572,20 @@ void sq_setreleasehook(HSQUIRRELVM v,SQInteger idx,SQRELEASEHOOK hook)
 	}
 }
 
+SQRELEASEHOOK sq_getreleasehook(HSQUIRRELVM v,SQInteger idx)
+{
+    if(sq_gettop(v) >= 1){
+        SQObjectPtr &ud=stack_get(v,idx);
+        switch( type(ud) ) {
+        case OT_USERDATA:   return _userdata(ud)->_hook;    break;
+        case OT_INSTANCE:   return _instance(ud)->_hook;    break;
+        case OT_CLASS:      return _class(ud)->_hook;       break;
+        default: break; //shutup compiler
+        }
+    }
+    return NULL;
+}
+
 void sq_setcompilererrorhandler(HSQUIRRELVM v,SQCOMPILERERROR f)
 {
 	_ss(v)->_compilererrorhandler = f;
@@ -1510,28 +1593,28 @@ void sq_setcompilererrorhandler(HSQUIRRELVM v,SQCOMPILERERROR f)
 
 SQRESULT sq_writeclosure(HSQUIRRELVM v,SQWRITEFUNC w,SQUserPointer up)
 {
-	SQObjectPtr *o = NULL;
-	_GETSAFE_OBJ(v, -1, OT_CLOSURE,o);
+	SQObjectPtr &o = stack_get(v,-1);
+	_CHECK_OBJ_TYPE(v, OT_CLOSURE, o);
 	unsigned short tag = SQ_BYTECODE_STREAM_TAG;
-	if(_closure(*o)->_function->_noutervalues)
+	if(_closure(o)->_function->_noutervalues)
 		return sq_throwerror(v,_SC("a closure with free valiables bound cannot be serialized"));
 	if(w(up,&tag,2) != 2)
 		return sq_throwerror(v,_SC("io error"));
-	if(!_closure(*o)->Save(v,up,w))
+	if(!_closure(o)->Save(v,up,w))
 		return SQ_ERROR;
 	return SQ_OK;
 }
 
 SQRESULT sq_writeclosure_as_source(HSQUIRRELVM v,SQWRITEFUNC w,SQUserPointer up)
 {
-	SQObjectPtr *o = NULL;
-	_GETSAFE_OBJ(v, -1, OT_CLOSURE,o);
-	if(_closure(*o)->_function->_noutervalues)
+	SQObjectPtr &o = stack_get(v,-1);
+	_CHECK_OBJ_TYPE(v, OT_CLOSURE, o);
+	if(_closure(o)->_function->_noutervalues)
 		return sq_throwerror(v,_SC("a closure with free valiables bound cannot be serialized"));
     const SQChar decl[] = _SC("local bytecode = ");
 	if(w(up, (void*)decl, scstrlen(decl)) != scstrlen(decl))
 		return sq_throwerror(v,_SC("io error"));
-	if(!_closure(*o)->SaveAsSource(v,up,w))
+	if(!_closure(o)->SaveAsSource(v,up,w))
 		return SQ_ERROR;
 	return SQ_OK;
 }
@@ -1645,19 +1728,19 @@ SQRESULT sq_setfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger nval)
 
 SQRESULT sq_setattributes(HSQUIRRELVM v,SQInteger idx)
 {
-	SQObjectPtr *o = NULL;
-	_GETSAFE_OBJ(v, idx, OT_CLASS,o);
+	SQObjectPtr &o = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_CLASS, o);
 	SQObjectPtr &key = stack_get(v,-2);
 	SQObjectPtr &val = stack_get(v,-1);
 	SQObjectPtr attrs;
 	if(type(key) == OT_NULL) {
-		attrs = _class(*o)->_attributes;
-		_class(*o)->_attributes = val;
+		attrs = _class(o)->_attributes;
+		_class(o)->_attributes = val;
 		v->Pop(2);
 		v->Push(attrs);
 		return SQ_OK;
-	}else if(_class(*o)->GetAttributes(key,attrs)) {
-		_class(*o)->SetAttributes(key,val);
+	}else if(_class(o)->GetAttributes(key,attrs)) {
+		_class(o)->SetAttributes(key,val);
 		v->Pop(2);
 		v->Push(attrs);
 		return SQ_OK;
@@ -1667,17 +1750,17 @@ SQRESULT sq_setattributes(HSQUIRRELVM v,SQInteger idx)
 
 SQRESULT sq_getattributes(HSQUIRRELVM v,SQInteger idx)
 {
-	SQObjectPtr *o = NULL;
-	_GETSAFE_OBJ(v, idx, OT_CLASS,o);
+	SQObjectPtr &o = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_CLASS, o);
 	SQObjectPtr &key = stack_get(v,-1);
 	SQObjectPtr attrs;
 	if(type(key) == OT_NULL) {
-		attrs = _class(*o)->_attributes;
+		attrs = _class(o)->_attributes;
 		v->Pop();
 		v->Push(attrs);
 		return SQ_OK;
 	}
-	else if(_class(*o)->GetAttributes(key,attrs)) {
+	else if(_class(o)->GetAttributes(key,attrs)) {
 		v->Pop();
 		v->Push(attrs);
 		return SQ_OK;
@@ -1687,10 +1770,10 @@ SQRESULT sq_getattributes(HSQUIRRELVM v,SQInteger idx)
 
 SQRESULT sq_getmemberhandle(HSQUIRRELVM v,SQInteger idx,HSQMEMBERHANDLE *handle)
 {
-	SQObjectPtr *o = NULL;
-	_GETSAFE_OBJ(v, idx, OT_CLASS,o);
+	SQObjectPtr &o = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_CLASS, o);
 	SQObjectPtr &key = stack_get(v,-1);
-	SQTable *m = _class(*o)->_members;
+	SQTable *m = _class(o)->_members;
 	SQObjectPtr val;
 	if(m->Get(key,val)) {
 		handle->_static = _isfield(val) ? SQFalse : SQTrue;
@@ -1758,10 +1841,10 @@ SQRESULT sq_setbyhandle(HSQUIRRELVM v,SQInteger idx,const HSQMEMBERHANDLE *handl
 
 SQRESULT sq_getbase(HSQUIRRELVM v,SQInteger idx)
 {
-	SQObjectPtr *o = NULL;
-	_GETSAFE_OBJ(v, idx, OT_CLASS,o);
-	if(_class(*o)->_base)
-		v->Push(SQObjectPtr(_class(*o)->_base));
+	SQObjectPtr &o = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_CLASS, o);
+	if(_class(o)->_base)
+		v->Push(SQObjectPtr(_class(o)->_base));
 	else
 		v->PushNull();
 	return SQ_OK;
@@ -1769,17 +1852,17 @@ SQRESULT sq_getbase(HSQUIRRELVM v,SQInteger idx)
 
 SQRESULT sq_getclass(HSQUIRRELVM v,SQInteger idx)
 {
-	SQObjectPtr *o = NULL;
-	_GETSAFE_OBJ(v, idx, OT_INSTANCE,o);
-	v->Push(SQObjectPtr(_instance(*o)->_class));
+	SQObjectPtr &o = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_INSTANCE, o);
+	v->Push(SQObjectPtr(_instance(o)->_class));
 	return SQ_OK;
 }
 
 SQRESULT sq_createinstance(HSQUIRRELVM v,SQInteger idx)
 {
-	SQObjectPtr *o = NULL;
-	_GETSAFE_OBJ(v, idx, OT_CLASS,o);
-	v->Push(_class(*o)->CreateInstance());
+	SQObjectPtr &o = stack_get(v,idx);
+	_CHECK_OBJ_TYPE(v, OT_CLASS, o);
+	v->Push(_class(o)->CreateInstance());
 	return SQ_OK;
 }
 

SquiLu/squirrel/sqarray.h

@@ -1,103 +1,103 @@
-/*	see copyright notice in squirrel.h */
-#ifndef _SQARRAY_H_
-#define _SQARRAY_H_
-
-struct SQArray : public CHAINABLE_OBJ
-{
-private:
-	SQArray(SQSharedState *ss,SQInteger nsize){_values.resize(nsize); INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);}
-	~SQArray()
-	{
-		REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);
-	}
-public:
-	static SQArray* Create(SQSharedState *ss,SQInteger nInitialSize){
-		SQArray *newarray=(SQArray*)SQ_MALLOC(sizeof(SQArray));
-		new (newarray) SQArray(ss,nInitialSize);
-		return newarray;
-	}
-#ifndef NO_GARBAGE_COLLECTOR
-	void Mark(SQCollectable **chain);
-	SQObjectType GetType() {return OT_ARRAY;}
-#endif
-	void Finalize(){
-		_values.resize(0);
-	}
-	bool Get(const SQInteger nidx,SQObjectPtr &val)
-	{
-		if(nidx>=0 && nidx<(SQInteger)_values.size()){
-			SQObjectPtr &o = _values[nidx];
-			val = _realval(o);
-			return true;
-		}
-		else return false;
-	}
-	SQObjectPtr operator[](SQInteger nidx) {
-        SQObjectPtr val;
-        Get(nidx, val);
-        return val;
-    }
-	bool Exists(const SQInteger nidx)
-	{
-		return (nidx>=0 && nidx<(SQInteger)_values.size());
-	}
-	bool Set(const SQInteger nidx,const SQObjectPtr &val)
-	{
-		if(nidx>=0 && nidx<(SQInteger)_values.size()){
-			_values[nidx]=val;
-			return true;
-		}
-		else return false;
-	}
-	SQInteger Next(const SQObjectPtr &refpos,SQObjectPtr &outkey,SQObjectPtr &outval)
-	{
-		SQUnsignedInteger idx=SQTranslateIndex(refpos);
-		while(idx<_values.size()){
-			//first found
-			outkey=(SQInteger)idx;
-			SQObjectPtr &o = _values[idx];
-			outval = _realval(o);
-			//return idx for the next iteration
-			return ++idx;
-		}
-		//nothing to iterate anymore
-		return -1;
-	}
-	SQArray *Clone(){SQArray *anew=Create(_opt_ss(this),0); anew->_values.copy(_values); return anew; }
-	SQInteger Size() const {return _values.size();}
-	void Resize(SQInteger size)
-	{
-		SQObjectPtr _null;
-		Resize(size,_null);
-	}
-	void Resize(SQInteger size,SQObjectPtr &fill) { _values.resize(size,fill); ShrinkIfNeeded(); }
-	void Reserve(SQInteger size) { _values.reserve(size); }
-	void Append(const SQObject &o){_values.push_back(o);}
-	void Extend(const SQArray *a);
-	SQObjectPtr &Top(){return _values.top();}
-	void Pop(){_values.pop_back(); ShrinkIfNeeded(); }
-	bool Insert(SQInteger idx,const SQObject &val){
-		if(idx < 0 || idx > (SQInteger)_values.size())
-			return false;
-		_values.insert(idx,val);
-		return true;
-	}
-	void ShrinkIfNeeded() {
-		if(_values.size() <= _values.capacity()>>2) //shrink the array
-			_values.shrinktofit();
-	}
-	bool Remove(SQInteger idx){
-		if(idx < 0 || idx >= (SQInteger)_values.size())
-			return false;
-		_values.remove(idx);
-		ShrinkIfNeeded();
-		return true;
-	}
-	void Release()
-	{
-		sq_delete(this,SQArray);
-	}
-
-	SQObjectPtrVec _values;
-};
-#endif //_SQARRAY_H_
+/*	see copyright notice in squirrel.h */
+#ifndef _SQARRAY_H_
+#define _SQARRAY_H_
+
+struct SQArray : public CHAINABLE_OBJ
+{
+private:
+	SQArray(SQSharedState *ss,SQInteger nsize){_values.resize(nsize); INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);}
+	~SQArray()
+	{
+		REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);
+	}
+public:
+	static SQArray* Create(SQSharedState *ss,SQInteger nInitialSize){
+		SQArray *newarray=(SQArray*)SQ_MALLOC(sizeof(SQArray));
+		new (newarray) SQArray(ss,nInitialSize);
+		return newarray;
+	}
+#ifndef NO_GARBAGE_COLLECTOR
+	void Mark(SQCollectable **chain);
+	SQObjectType GetType() {return OT_ARRAY;}
+#endif
+	void Finalize(){
+		_values.resize(0);
+	}
+	bool Get(const SQInteger nidx,SQObjectPtr &val)
+	{
+		if(nidx>=0 && nidx<(SQInteger)_values.size()){
+			SQObjectPtr &o = _values[nidx];
+			val = _realval(o);
+			return true;
+		}
+		else return false;
+	}
+	SQObjectPtr operator[](SQInteger nidx) {
+        SQObjectPtr val;
+        Get(nidx, val);
+        return val;
+    }
+	bool Exists(const SQInteger nidx)
+	{
+		return (nidx>=0 && nidx<(SQInteger)_values.size());
+	}
+	bool Set(const SQInteger nidx,const SQObjectPtr &val)
+	{
+		if(nidx>=0 && nidx<(SQInteger)_values.size()){
+			_values[nidx]=val;
+			return true;
+		}
+		else return false;
+	}
+	SQInteger Next(const SQObjectPtr &refpos,SQObjectPtr &outkey,SQObjectPtr &outval)
+	{
+		SQUnsignedInteger idx=SQTranslateIndex(refpos);
+		while(idx<_values.size()){
+			//first found
+			outkey=(SQInteger)idx;
+			SQObjectPtr &o = _values[idx];
+			outval = _realval(o);
+			//return idx for the next iteration
+			return ++idx;
+		}
+		//nothing to iterate anymore
+		return -1;
+	}
+	SQArray *Clone(){SQArray *anew=Create(_opt_ss(this),0); anew->_values.copy(_values); return anew; }
+	SQInteger Size() const {return _values.size();}
+	void Resize(SQInteger size)
+	{
+		SQObjectPtr _null;
+		Resize(size,_null);
+	}
+	void Resize(SQInteger size,SQObjectPtr &fill) { _values.resize(size,fill); ShrinkIfNeeded(); }
+	void Reserve(SQInteger size) { _values.reserve(size); }
+	void Append(const SQObject &o){_values.push_back(o);}
+	void Extend(const SQArray *a);
+	SQObjectPtr &Top(){return _values.top();}
+	void Pop(){_values.pop_back(); ShrinkIfNeeded(); }
+	bool Insert(SQInteger idx,const SQObject &val){
+		if(idx < 0 || idx > (SQInteger)_values.size())
+			return false;
+		_values.insert(idx,val);
+		return true;
+	}
+	void ShrinkIfNeeded() {
+		if(_values.size() <= _values.capacity()>>2) //shrink the array
+			_values.shrinktofit();
+	}
+	bool Remove(SQInteger idx){
+		if(idx < 0 || idx >= (SQInteger)_values.size())
+			return false;
+		_values.remove(idx);
+		ShrinkIfNeeded();
+		return true;
+	}
+	void Release()
+	{
+		sq_delete(this,SQArray);
+	}
+
+	SQObjectPtrVec _values;
+};
+#endif //_SQARRAY_H_

SquiLu/squirrel/sqbaselib.cpp

@@ -43,7 +43,7 @@ bool str2num(const SQChar *s,SQObjectPtr &res, SQInteger base=10)
 	return true;
 }
 
-static SQRESULT base_dummy(HSQUIRRELVM /*v*/)
+static SQRESULT base_dummy(HSQUIRRELVM SQ_UNUSED_ARG(v))
 {
 	return 0;
 }

SquiLu/squirrel/sqclass.cpp

@@ -194,7 +194,7 @@ SQInstance::~SQInstance()
 	if(_class){ Finalize(); } //if _class is null it was already finalized by the GC
 }
 
-bool SQInstance::GetMetaMethod(SQVM */*v*/,SQMetaMethod mm,SQObjectPtr &res)
+bool SQInstance::GetMetaMethod(SQVM SQ_UNUSED_ARG(*v),SQMetaMethod mm,SQObjectPtr &res)
 {
 	if(type(_class->_metamethods[mm]) != OT_NULL) {
 		res = _class->_metamethods[mm];

SquiLu/squirrel/sqclosure.h

@@ -51,8 +51,8 @@ public:
     }
     ~SQClosure();
 
-	bool Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write);
 	bool SaveAsSource(SQVM *v,SQUserPointer up,SQWRITEFUNC write);
+	bool Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write);
 	static bool Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret);
 #ifndef NO_GARBAGE_COLLECTOR
 	void Mark(SQCollectable **chain);

SquiLu/squirrel/sqcompiler.h

@@ -1,8 +1,8 @@
-/*	see copyright notice in squirrel.h */
-#ifndef _SQCOMPILER_H_
-#define _SQCOMPILER_H_
-
-struct SQVM;
+/*	see copyright notice in squirrel.h */
+#ifndef _SQCOMPILER_H_
+#define _SQCOMPILER_H_
+
+struct SQVM;
 
 #define SQ_KEYWORDS_LIST() \
     ENUM_TK(3WAYSCMP)\
@@ -129,7 +129,7 @@ struct SQVM;
     //ENUM_TK(VARGV)
 
 #define ENUM_TK(tk) TK_##tk,
-enum SQKeywordsEnum {
+enum SQKeywordsEnum {
     TK_FIRST_ENUM_TOKEN = 258,
     /*
     the above token is only for internal purposes
@@ -143,8 +143,8 @@ enum SQKeywordsEnum {
     TK_LAST_ENUM_TOKEN
 };
 #undef ENUM_TK
-
-typedef void(*CompilerErrorFunc)(void *ud, const SQChar *s);
+
+typedef void(*CompilerErrorFunc)(void *ud, const SQChar *s);
 bool Compile(SQVM *vm, SQLEXREADFUNC rg, SQUserPointer up, const SQChar *sourcename, SQObjectPtr &out,
-             bool raiseerror, bool lineinfo, bool show_warnings, SQInteger max_nested_includes=10);
-#endif //_SQCOMPILER_H_
+             bool raiseerror, bool lineinfo, bool show_warnings, SQInteger max_nested_includes=10);
+#endif //_SQCOMPILER_H_

SquiLu/squirrel/sqfuncproto.h

@@ -1,193 +1,193 @@
-/*	see copyright notice in squirrel.h */
-#ifndef _SQFUNCTION_H_
-#define _SQFUNCTION_H_
-
-#include "sqopcodes.h"
-
-enum SQOuterType {
-	otLOCAL = 0,
-	otOUTER = 1
-};
-
-struct SQOuterVar
-{
-
-	SQOuterVar(){}
-	SQOuterVar(const SQObjectPtr &name,const SQObjectPtr &src,SQOuterType t)
-	{
-		_name = name;
-		_src=src;
-		_type=t;
-	}
-	SQOuterVar(const SQOuterVar &ov)
-	{
-		_type=ov._type;
-		_src=ov._src;
-		_name=ov._name;
-	}
-	SQOuterType _type;
-	SQObjectPtr _name;
-	SQObjectPtr _src;
-};
-
-#define _VAR_ANY			0x00000001
-#define _VAR_INTEGER		0x00000002
-#define _VAR_FLOAT			0x00000004
-#define _VAR_BOOL			0x00000008
-#define _VAR_STRING			0x00000010
-#define _VAR_TABLE			0x00000020
-#define _VAR_ARRAY			0x00000040
-#define _VAR_CLOSURE		0x00000080
-#define _VAR_CLASS			0x00000100
-#define _VAR_REFERENCE  	0x00000200
-#define _VAR_CONST  		0x00000400
-
-struct SQLocalVarInfo
-{
+/*	see copyright notice in squirrel.h */
+#ifndef _SQFUNCTION_H_
+#define _SQFUNCTION_H_
+
+#include "sqopcodes.h"
+
+enum SQOuterType {
+	otLOCAL = 0,
+	otOUTER = 1
+};
+
+struct SQOuterVar
+{
+
+	SQOuterVar(){}
+	SQOuterVar(const SQObjectPtr &name,const SQObjectPtr &src,SQOuterType t)
+	{
+		_name = name;
+		_src=src;
+		_type=t;
+	}
+	SQOuterVar(const SQOuterVar &ov)
+	{
+		_type=ov._type;
+		_src=ov._src;
+		_name=ov._name;
+	}
+	SQOuterType _type;
+	SQObjectPtr _name;
+	SQObjectPtr _src;
+};
+
+#define _VAR_ANY			0x00000001
+#define _VAR_INTEGER		0x00000002
+#define _VAR_FLOAT			0x00000004
+#define _VAR_BOOL			0x00000008
+#define _VAR_STRING			0x00000010
+#define _VAR_TABLE			0x00000020
+#define _VAR_ARRAY			0x00000040
+#define _VAR_CLOSURE		0x00000080
+#define _VAR_CLASS			0x00000100
+#define _VAR_REFERENCE  	0x00000200
+#define _VAR_CONST  		0x00000400
+
+struct SQLocalVarInfo
+{
 	SQLocalVarInfo():_start_op(0),_end_op(0),_pos(0),
-        _type(_VAR_ANY),_scope(0) {}
-	SQLocalVarInfo(const SQLocalVarInfo &lvi)
-	{
-		_name=lvi._name;
-		_type_name=lvi._type_name;
-		_start_op=lvi._start_op;
-		_end_op=lvi._end_op;
+        _type(_VAR_ANY),_scope(0) {}
+	SQLocalVarInfo(const SQLocalVarInfo &lvi)
+	{
+		_name=lvi._name;
+		_type_name=lvi._type_name;
+		_start_op=lvi._start_op;
+		_end_op=lvi._end_op;
 		_pos=lvi._pos;
-		_type=lvi._type;
+		_type=lvi._type;
 		_scope=lvi._scope;
-	}
-	SQObjectPtr _name;
-	SQObjectPtr _type_name;
-	SQUnsignedInteger _start_op;
-	SQUnsignedInteger _end_op;
-	SQUnsignedInteger _pos;
-	unsigned short _type;
+	}
+	SQObjectPtr _name;
+	SQObjectPtr _type_name;
+	SQUnsignedInteger _start_op;
+	SQUnsignedInteger _end_op;
+	SQUnsignedInteger _pos;
+	unsigned short _type;
 	unsigned short _scope;
-};
-
-struct SQLineInfo { SQInteger _line;SQInteger _op; };
-
-typedef sqvector<SQOuterVar> SQOuterVarVec;
-typedef sqvector<SQLocalVarInfo> SQLocalVarInfoVec;
-typedef sqvector<SQLineInfo> SQLineInfoVec;
-
+};
+
+struct SQLineInfo { SQInteger _line;SQInteger _op; };
+
+typedef sqvector<SQOuterVar> SQOuterVarVec;
+typedef sqvector<SQLocalVarInfo> SQLocalVarInfoVec;
+typedef sqvector<SQLineInfo> SQLineInfoVec;
+
 #define _FUNC_SIZE(ni,nl,nparams,nfuncs,nouters,nlineinf,localinf,defparams) \
-        (sizeof(SQFunctionProto) \
-		+((ni-1)*sizeof(SQInstruction))+(nl*sizeof(SQObjectPtr)) \
+        (sizeof(SQFunctionProto) \
+		+((ni-1)*sizeof(SQInstruction))+(nl*sizeof(SQObjectPtr)) \
 		+(nparams*sizeof(SQObjectPtr))+(/*param_types*/nparams*sizeof(SQObjectPtr)) \
-        +(nfuncs*sizeof(SQObjectPtr)) \
-		+(nouters*sizeof(SQOuterVar))+(nlineinf*sizeof(SQLineInfo)) \
-		+(localinf*sizeof(SQLocalVarInfo))+(defparams*sizeof(SQInteger)))
-
-
-struct SQFunctionProto : public CHAINABLE_OBJ
-{
-private:
-	SQFunctionProto(SQSharedState *ss);
-	~SQFunctionProto();
-
-public:
-	static SQFunctionProto *Create(SQSharedState *ss,SQInteger ninstructions,
-		SQInteger nliterals,SQInteger nparameters,
-		SQInteger nfunctions,SQInteger noutervalues,
-		SQInteger nlineinfos,SQInteger nlocalvarinfos,SQInteger ndefaultparams)
-	{
-		SQFunctionProto *f;
-		//I compact the whole class and members in a single memory allocation
-		f = (SQFunctionProto *)sq_vm_malloc(_FUNC_SIZE(ninstructions,nliterals,nparameters,nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams));
-		new (f) SQFunctionProto(ss);
+        +(nfuncs*sizeof(SQObjectPtr)) \
+		+(nouters*sizeof(SQOuterVar))+(nlineinf*sizeof(SQLineInfo)) \
+		+(localinf*sizeof(SQLocalVarInfo))+(defparams*sizeof(SQInteger)))
+
+
+struct SQFunctionProto : public CHAINABLE_OBJ
+{
+private:
+	SQFunctionProto(SQSharedState *ss);
+	~SQFunctionProto();
+
+public:
+	static SQFunctionProto *Create(SQSharedState *ss,SQInteger ninstructions,
+		SQInteger nliterals,SQInteger nparameters,
+		SQInteger nfunctions,SQInteger noutervalues,
+		SQInteger nlineinfos,SQInteger nlocalvarinfos,SQInteger ndefaultparams)
+	{
+		SQFunctionProto *f;
+		//I compact the whole class and members in a single memory allocation
+		f = (SQFunctionProto *)sq_vm_malloc(_FUNC_SIZE(ninstructions,nliterals,nparameters,nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams));
+		new (f) SQFunctionProto(ss);
 		f->_ninstructions = ninstructions;
-		//literals start at then end of _instructions
-		f->_literals = (SQObjectPtr*)&f->_instructions[ninstructions];
-		f->_nliterals = nliterals;
-		//parameters start at then end of _literals
-		f->_parameters = (SQObjectPtr*)&f->_literals[nliterals];
+		//literals start at then end of _instructions
+		f->_literals = (SQObjectPtr*)&f->_instructions[ninstructions];
+		f->_nliterals = nliterals;
+		//parameters start at then end of _literals
+		f->_parameters = (SQObjectPtr*)&f->_literals[nliterals];
 		f->_nparameters = nparameters;
-		//the same as above repeat till the end
-		f->_parameters_type = (SQObjectPtr*)&f->_parameters[nparameters];
-		f->_functions = (SQObjectPtr*)&f->_parameters_type[nparameters];
-		f->_nfunctions = nfunctions;
-		f->_outervalues = (SQOuterVar*)&f->_functions[nfunctions];
-		f->_noutervalues = noutervalues;
-		f->_lineinfos = (SQLineInfo *)&f->_outervalues[noutervalues];
-		f->_nlineinfos = nlineinfos;
-		f->_localvarinfos = (SQLocalVarInfo *)&f->_lineinfos[nlineinfos];
-		f->_nlocalvarinfos = nlocalvarinfos;
-		f->_defaultparams = (SQInteger *)&f->_localvarinfos[nlocalvarinfos];
-		f->_ndefaultparams = ndefaultparams;
-
-		_CONSTRUCT_VECTOR(SQObjectPtr,f->_nliterals,f->_literals);
-		_CONSTRUCT_VECTOR(SQObjectPtr,f->_nparameters,f->_parameters);
-		_CONSTRUCT_VECTOR(SQObjectPtr,f->_nparameters,f->_parameters_type);
-		_CONSTRUCT_VECTOR(SQObjectPtr,f->_nfunctions,f->_functions);
-		_CONSTRUCT_VECTOR(SQOuterVar,f->_noutervalues,f->_outervalues);
-		//_CONSTRUCT_VECTOR(SQLineInfo,f->_nlineinfos,f->_lineinfos); //not required are 2 integers
-		_CONSTRUCT_VECTOR(SQLocalVarInfo,f->_nlocalvarinfos,f->_localvarinfos);
-		return f;
-	}
-	void Release(){
-		_DESTRUCT_VECTOR(SQObjectPtr,_nliterals,_literals);
-		_DESTRUCT_VECTOR(SQObjectPtr,_nparameters,_parameters);
-		_DESTRUCT_VECTOR(SQObjectPtr,_nparameters,_parameters_type);
-		_DESTRUCT_VECTOR(SQObjectPtr,_nfunctions,_functions);
-		_DESTRUCT_VECTOR(SQOuterVar,_noutervalues,_outervalues);
-		//_DESTRUCT_VECTOR(SQLineInfo,_nlineinfos,_lineinfos); //not required are 2 integers
-		_DESTRUCT_VECTOR(SQLocalVarInfo,_nlocalvarinfos,_localvarinfos);
-		SQInteger size = _FUNC_SIZE(_ninstructions,_nliterals,_nparameters,_nfunctions,_noutervalues,_nlineinfos,_nlocalvarinfos,_ndefaultparams);
-		this->~SQFunctionProto();
-		sq_vm_free(this,size);
-	}
-
-	const SQChar* GetLocal(SQVM *v,SQUnsignedInteger stackbase,SQUnsignedInteger nseq,SQUnsignedInteger nop);
-	SQInteger GetLine(SQInstruction *curr);
+		//the same as above repeat till the end
+		f->_parameters_type = (SQObjectPtr*)&f->_parameters[nparameters];
+		f->_functions = (SQObjectPtr*)&f->_parameters_type[nparameters];
+		f->_nfunctions = nfunctions;
+		f->_outervalues = (SQOuterVar*)&f->_functions[nfunctions];
+		f->_noutervalues = noutervalues;
+		f->_lineinfos = (SQLineInfo *)&f->_outervalues[noutervalues];
+		f->_nlineinfos = nlineinfos;
+		f->_localvarinfos = (SQLocalVarInfo *)&f->_lineinfos[nlineinfos];
+		f->_nlocalvarinfos = nlocalvarinfos;
+		f->_defaultparams = (SQInteger *)&f->_localvarinfos[nlocalvarinfos];
+		f->_ndefaultparams = ndefaultparams;
+
+		_CONSTRUCT_VECTOR(SQObjectPtr,f->_nliterals,f->_literals);
+		_CONSTRUCT_VECTOR(SQObjectPtr,f->_nparameters,f->_parameters);
+		_CONSTRUCT_VECTOR(SQObjectPtr,f->_nparameters,f->_parameters_type);
+		_CONSTRUCT_VECTOR(SQObjectPtr,f->_nfunctions,f->_functions);
+		_CONSTRUCT_VECTOR(SQOuterVar,f->_noutervalues,f->_outervalues);
+		//_CONSTRUCT_VECTOR(SQLineInfo,f->_nlineinfos,f->_lineinfos); //not required are 2 integers
+		_CONSTRUCT_VECTOR(SQLocalVarInfo,f->_nlocalvarinfos,f->_localvarinfos);
+		return f;
+	}
+	void Release(){
+		_DESTRUCT_VECTOR(SQObjectPtr,_nliterals,_literals);
+		_DESTRUCT_VECTOR(SQObjectPtr,_nparameters,_parameters);
+		_DESTRUCT_VECTOR(SQObjectPtr,_nparameters,_parameters_type);
+		_DESTRUCT_VECTOR(SQObjectPtr,_nfunctions,_functions);
+		_DESTRUCT_VECTOR(SQOuterVar,_noutervalues,_outervalues);
+		//_DESTRUCT_VECTOR(SQLineInfo,_nlineinfos,_lineinfos); //not required are 2 integers
+		_DESTRUCT_VECTOR(SQLocalVarInfo,_nlocalvarinfos,_localvarinfos);
+		SQInteger size = _FUNC_SIZE(_ninstructions,_nliterals,_nparameters,_nfunctions,_noutervalues,_nlineinfos,_nlocalvarinfos,_ndefaultparams);
+		this->~SQFunctionProto();
+		sq_vm_free(this,size);
+	}
+
+	const SQChar* GetLocal(SQVM *v,SQUnsignedInteger stackbase,SQUnsignedInteger nseq,SQUnsignedInteger nop);
+	SQInteger GetLine(SQInstruction *curr);
 	bool Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write);
-	bool SaveAsSource(SQVM *v,SQUserPointer up,SQWRITEFUNC write);
-	static bool Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret);
-
-#ifdef SQ_JIT_LLVM
-	void JitCompile();
-#endif
-
-#ifndef NO_GARBAGE_COLLECTOR
-	void Mark(SQCollectable **chain);
-	void Finalize(){ _NULL_SQOBJECT_VECTOR(_literals,_nliterals); }
-	SQObjectType GetType() {return OT_FUNCPROTO;}
-#endif
-	SQObjectPtr _sourcename;
-	SQObjectPtr _name;
-	SQObjectPtr _return_type;
-    SQInteger _stacksize;
-	bool _bgenerator;
-	SQInteger _varparams;
-
-#ifdef SQ_JIT_LLVM
-	llvm::Function* _jitfunction;
-#endif
-
-	SQInteger _nlocalvarinfos;
-	SQLocalVarInfo *_localvarinfos;
-
-	SQInteger _nlineinfos;
-	SQLineInfo *_lineinfos;
-
-	SQInteger _nliterals;
-	SQObjectPtr *_literals;
-
-	SQInteger _nparameters;
-	SQObjectPtr *_parameters;
-	SQObjectPtr *_parameters_type;
-
-	SQInteger _nfunctions;
-	SQObjectPtr *_functions;
-
-	SQInteger _noutervalues;
-	SQOuterVar *_outervalues;
-
-	SQInteger _ndefaultparams;
-	SQInteger *_defaultparams;
-
-	SQInteger _ninstructions;
-	SQInstruction _instructions[1];
-};
-
-#endif //_SQFUNCTION_H_
+	bool SaveAsSource(SQVM *v,SQUserPointer up,SQWRITEFUNC write);
+	static bool Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret);
+
+#ifdef SQ_JIT_LLVM
+	void JitCompile();
+#endif
+
+#ifndef NO_GARBAGE_COLLECTOR
+	void Mark(SQCollectable **chain);
+	void Finalize(){ _NULL_SQOBJECT_VECTOR(_literals,_nliterals); }
+	SQObjectType GetType() {return OT_FUNCPROTO;}
+#endif
+	SQObjectPtr _sourcename;
+	SQObjectPtr _name;
+	SQObjectPtr _return_type;
+    SQInteger _stacksize;
+	bool _bgenerator;
+	SQInteger _varparams;
+
+#ifdef SQ_JIT_LLVM
+	llvm::Function* _jitfunction;
+#endif
+
+	SQInteger _nlocalvarinfos;
+	SQLocalVarInfo *_localvarinfos;
+
+	SQInteger _nlineinfos;
+	SQLineInfo *_lineinfos;
+
+	SQInteger _nliterals;
+	SQObjectPtr *_literals;
+
+	SQInteger _nparameters;
+	SQObjectPtr *_parameters;
+	SQObjectPtr *_parameters_type;
+
+	SQInteger _nfunctions;
+	SQObjectPtr *_functions;
+
+	SQInteger _noutervalues;
+	SQOuterVar *_outervalues;
+
+	SQInteger _ndefaultparams;
+	SQInteger *_defaultparams;
+
+	SQInteger _ninstructions;
+	SQInstruction _instructions[1];
+};
+
+#endif //_SQFUNCTION_H_

SquiLu/squirrel/sqlexer.cpp

@@ -1,55 +1,55 @@
-/*
-	see copyright notice in squirrel.h
-*/
-#include "sqpcheader.h"
-#include <ctype.h>
-#include <stdlib.h>
-#include <limits.h>
-#include "sqtable.h"
-#include "sqstring.h"
-#include "sqcompiler.h"
-#include "sqlexer.h"
-
-#define CUR_CHAR (_currdata)
-#define RETURN_TOKEN(t) { _prevtoken = _curtoken; _curtoken = t; return t;}
-#define IS_EOB() (CUR_CHAR <= SQUIRREL_EOB)
-#define NEXT() {SQInteger rc = Next(); if(rc < 0) return rc; _currentcolumn++;}
-#define INIT_TEMP_STRING() { _longstr.resize(0);}
-#define APPEND_CHAR(c) { _longstr.push_back(c);}
-#define TERMINATE_BUFFER() {_longstr.push_back(_SC('\0'));}
-#define ADD_KEYWORD(key,id) tbl->NewSlot( SQString::Create(_sharedstate, _SC(#key)) ,SQInteger(id))
-
-SQLexer::SQLexer(){_keywords=0;}
-SQLexer::~SQLexer()
-{
-	_keywords->Release();
-}
-
+/*
+	see copyright notice in squirrel.h
+*/
+#include "sqpcheader.h"
+#include <ctype.h>
+#include <stdlib.h>
+#include <limits.h>
+#include "sqtable.h"
+#include "sqstring.h"
+#include "sqcompiler.h"
+#include "sqlexer.h"
+
+#define CUR_CHAR (_currdata)
+#define RETURN_TOKEN(t) { _prevtoken = _curtoken; _curtoken = t; return t;}
+#define IS_EOB() (CUR_CHAR <= SQUIRREL_EOB)
+#define NEXT() {SQInteger rc = Next(); if(rc < 0) return rc; _currentcolumn++;}
+#define INIT_TEMP_STRING() { _longstr.resize(0);}
+#define APPEND_CHAR(c) { _longstr.push_back(c);}
+#define TERMINATE_BUFFER() {_longstr.push_back(_SC('\0'));}
+#define ADD_KEYWORD(key,id) tbl->NewSlot( SQString::Create(_sharedstate, _SC(#key)) ,SQInteger(id))
+
+SQLexer::SQLexer(){_keywords=0;}
+SQLexer::~SQLexer()
+{
+	_keywords->Release();
+}
+
 SQInteger SQLexer::Init(SQSharedState *ss, SQLEXREADFUNC rg,
-                        SQUserPointer up,CompilerErrorFunc efunc,void *ed, SQBool want_comments)
+                        SQUserPointer up,CompilerErrorFunc efunc,void *ed, SQBool want_comments)
 {
     _want_comments = want_comments;
-    _lasterror[0] = '\0';
-    _svalue = NULL;
-	_errfunc = efunc;
-	_errtarget = ed;
+    _lasterror[0] = '\0';
+    _svalue = NULL;
+	_errfunc = efunc;
+	_errtarget = ed;
 	_sharedstate = ss;
-	if(_keywords) _keywords->Release();
-    _keywords = GetKeywords();
-	return ResetReader(rg, up, 1);
-}
+	if(_keywords) _keywords->Release();
+    _keywords = GetKeywords();
+	return ResetReader(rg, up, 1);
+}
 
-SQInteger SQLexer::ResetReader(SQLEXREADFUNC rg, SQUserPointer up, SQInteger line)
-{
-	_readf = rg;
-	_up = up;
+SQInteger SQLexer::ResetReader(SQLEXREADFUNC rg, SQUserPointer up, SQInteger line)
+{
+	_readf = rg;
+	_up = up;
 	_lasttokenline = _currentline = line;
-	_lasttokencolumn = 0;
-	_currentcolumn = 0;
-	_prevtoken = -1;
-	_reached_eof = SQFalse;
-	return Next();
-}
+	_lasttokencolumn = 0;
+	_currentcolumn = 0;
+	_prevtoken = -1;
+	_reached_eof = SQFalse;
+	return Next();
+}
 
 SQTable * SQLexer::GetKeywords()
 {
@@ -142,40 +142,40 @@ SQTable * SQLexer::GetKeywords()
 
 	return tbl;
 }
-
-SQInteger SQLexer::Error(const SQChar *fmt, ...)
-{
-    va_list vl;
-    va_start(vl, fmt);
-    scvsprintf(_lasterror, sizeof(_lasterror), fmt, vl);
-    va_end(vl);
+
+SQInteger SQLexer::Error(const SQChar *fmt, ...)
+{
+    va_list vl;
+    va_start(vl, fmt);
+    scvsprintf(_lasterror, sizeof(_lasterror), fmt, vl);
+    va_end(vl);
 	if(_errfunc) _errfunc(_errtarget,_lasterror);
-	return -1;
-}
-
-SQInteger SQLexer::Next()
-{
-	SQInteger t = _readf(_up);
-	if(t > MAX_CHAR) return Error(_SC("Invalid character"));
-	if(t != 0) {
-		_currdata = (LexChar)t;
-		return 0;
-	}
-	_currdata = SQUIRREL_EOB;
+	return -1;
+}
+
+SQInteger SQLexer::Next()
+{
+	SQInteger t = _readf(_up);
+	if(t > MAX_CHAR) return Error(_SC("Invalid character"));
+	if(t != 0) {
+		_currdata = (LexChar)t;
+		return 0;
+	}
+	_currdata = SQUIRREL_EOB;
 	_reached_eof = SQTrue;
-	return 0;
-}
-
-const SQChar *SQLexer::Tok2Str(SQInteger tok)
-{
-	SQObjectPtr itr, key, val;
-	SQInteger nitr;
-	while((nitr = _keywords->Next(false,itr, key, val)) != -1) {
-		itr = (SQInteger)nitr;
-		if(((SQInteger)_integer(val)) == tok)
-			return _stringval(key);
-	}
-	return NULL;
+	return 0;
+}
+
+const SQChar *SQLexer::Tok2Str(SQInteger tok)
+{
+	SQObjectPtr itr, key, val;
+	SQInteger nitr;
+	while((nitr = _keywords->Next(false,itr, key, val)) != -1) {
+		itr = (SQInteger)nitr;
+		if(((SQInteger)_integer(val)) == tok)
+			return _stringval(key);
+	}
+	return NULL;
 }
 
 const SQChar *SQLexer::GetTokenName(int tk_code) {
@@ -190,9 +190,9 @@ const SQChar *SQLexer::GetTokenName(int tk_code) {
     }
     return str_tk;
 }
-
-
-SQInteger SQLexer::LexBlockComment()
+
+
+SQInteger SQLexer::LexBlockComment()
 {
 /*
     if(CUR_CHAR == _SC('*'))
@@ -202,18 +202,18 @@ SQInteger SQLexer::LexBlockComment()
             printf("Doument comment found at line %d\n", _currentline);
         }
     }
-*/
+*/
 	bool done = false;
 	if(_want_comments) INIT_TEMP_STRING();
-	NEXT(); //remove the comment token '*'
-	while(!done) {
-		switch(CUR_CHAR) {
-			case _SC('*'): { NEXT(); if(CUR_CHAR == _SC('/')) { done = true; NEXT(); continue;}}; break;
-			case _SC('\n'): _currentline++; break;
-			case SQUIRREL_EOB: return Error(_SC("missing \"*/\" in comment"));
+	NEXT(); //remove the comment token '*'
+	while(!done) {
+		switch(CUR_CHAR) {
+			case _SC('*'): { NEXT(); if(CUR_CHAR == _SC('/')) { done = true; NEXT(); continue;}}; break;
+			case _SC('\n'): _currentline++; break;
+			case SQUIRREL_EOB: return Error(_SC("missing \"*/\" in comment"));
 		}
 		if(_want_comments) APPEND_CHAR(CUR_CHAR);
-		NEXT();
+		NEXT();
 	}
     if(_want_comments)
     {
@@ -221,35 +221,35 @@ SQInteger SQLexer::LexBlockComment()
         if(_longstr.size() > 0) _longstr.pop_back(); //remove the last '*'
         _svalue = &_longstr[0];
     }
-	return 0;
-}
-SQInteger SQLexer::LexLineComment()
+	return 0;
+}
+SQInteger SQLexer::LexLineComment()
 {
     if(_want_comments) INIT_TEMP_STRING();
-    NEXT(); //remove the comment token
+    NEXT(); //remove the comment token
 	while (CUR_CHAR != _SC('\n') && (!IS_EOB())) {if(_want_comments) APPEND_CHAR(CUR_CHAR); NEXT();}
     if(_want_comments)
     {
         TERMINATE_BUFFER();
         _svalue = &_longstr[0];
     }
-	return 0;
-}
-
-SQInteger SQLexer::Lex()
-{
+	return 0;
+}
+
+SQInteger SQLexer::Lex()
+{
 	_lasttokenline = _currentline;
-	_lasttokencolumn = _currentcolumn;
-	while(CUR_CHAR != SQUIRREL_EOB) {
-		switch(CUR_CHAR){
-		case _SC('\t'): case _SC('\r'): case _SC(' '): NEXT(); continue;
-		case _SC('\n'):
-			_currentline++;
-			_prevtoken=_curtoken;
-			_curtoken=_SC('\n');
-			NEXT();
-			_currentcolumn=1;
-			continue;
+	_lasttokencolumn = _currentcolumn;
+	while(CUR_CHAR != SQUIRREL_EOB) {
+		switch(CUR_CHAR){
+		case _SC('\t'): case _SC('\r'): case _SC(' '): NEXT(); continue;
+		case _SC('\n'):
+			_currentline++;
+			_prevtoken=_curtoken;
+			_curtoken=_SC('\n');
+			NEXT();
+			_currentcolumn=1;
+			continue;
 		case _SC('#'):
 		    NEXT();
 		    if(CUR_CHAR == '!') //shell shebang
@@ -260,184 +260,184 @@ SQInteger SQLexer::Lex()
             }
             RETURN_TOKEN(TK_PRAGMA);
             continue;
-		case _SC('/'):
-			NEXT();
-			switch(CUR_CHAR){
-			case _SC('*'):
-				if(LexBlockComment()) return -1;
+		case _SC('/'):
+			NEXT();
+			switch(CUR_CHAR){
+			case _SC('*'):
+				if(LexBlockComment()) return -1;
                 if(_want_comments) RETURN_TOKEN(TK_COMMENT_BLOCK)
-				continue;
-			case _SC('/'):
-				if(LexLineComment()) return -1;
+				continue;
+			case _SC('/'):
+				if(LexLineComment()) return -1;
                 if(_want_comments) RETURN_TOKEN(TK_COMMENT_LINE)
-				continue;
-			case _SC('='):
-				NEXT();
-				RETURN_TOKEN(TK_DIVEQ);
-				continue;
-			case _SC('>'):
-				NEXT();
-				RETURN_TOKEN(TK_ATTR_CLOSE);
-				continue;
-			default:
-				RETURN_TOKEN('/');
-			}
-		case _SC('='):
-			NEXT();
-			if (CUR_CHAR != _SC('=')){ RETURN_TOKEN('=') }
+				continue;
+			case _SC('='):
+				NEXT();
+				RETURN_TOKEN(TK_DIVEQ);
+				continue;
+			case _SC('>'):
+				NEXT();
+				RETURN_TOKEN(TK_ATTR_CLOSE);
+				continue;
+			default:
+				RETURN_TOKEN('/');
+			}
+		case _SC('='):
+			NEXT();
+			if (CUR_CHAR != _SC('=')){ RETURN_TOKEN('=') }
 			else {
                 NEXT();
                 if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_EQ_IDENTITY) }
                 else { RETURN_TOKEN(TK_EQ); }
-            }
-		case _SC('<'):
-			NEXT();
-			switch(CUR_CHAR) {
-			case _SC('='):
-				NEXT();
-				if(CUR_CHAR == _SC('>')) {
-					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;
-			}
-			RETURN_TOKEN('<');
-		case _SC('>'):
-			NEXT();
-			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_GE);}
-			else if(CUR_CHAR == _SC('>')){
-				NEXT();
-				if(CUR_CHAR == _SC('>')){
-					NEXT();
-					RETURN_TOKEN(TK_USHIFTR);
-				}
-				RETURN_TOKEN(TK_SHIFTR);
-			}
-			else { RETURN_TOKEN('>') }
-		case _SC('!'):
-			NEXT();
-			if (CUR_CHAR != _SC('=')){ RETURN_TOKEN('!')}
+            }
+		case _SC('<'):
+			NEXT();
+			switch(CUR_CHAR) {
+			case _SC('='):
+				NEXT();
+				if(CUR_CHAR == _SC('>')) {
+					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;
+			}
+			RETURN_TOKEN('<');
+		case _SC('>'):
+			NEXT();
+			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_GE);}
+			else if(CUR_CHAR == _SC('>')){
+				NEXT();
+				if(CUR_CHAR == _SC('>')){
+					NEXT();
+					RETURN_TOKEN(TK_USHIFTR);
+				}
+				RETURN_TOKEN(TK_SHIFTR);
+			}
+			else { RETURN_TOKEN('>') }
+		case _SC('!'):
+			NEXT();
+			if (CUR_CHAR != _SC('=')){ RETURN_TOKEN('!')}
 			else {
                 NEXT();
                 if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_NE_IDENTITY)}
                 else { RETURN_TOKEN(TK_NE); }
-            }
-		case _SC('@'): {
-			SQInteger stype;
-			NEXT();
-			if(CUR_CHAR != _SC('"')) {
-				RETURN_TOKEN('@');
-			}
-			if((stype=ReadString('"',true))!=-1) {
-				RETURN_TOKEN(stype);
-			}
-			return Error(_SC("error parsing the string"));
-					   }
-		case _SC('"'):
-		case _SC('\''): {
-			SQInteger stype;
-			if((stype=ReadString(CUR_CHAR,false))!=-1){
-				RETURN_TOKEN(stype);
-			}
-			return Error(_SC("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('@'): {
+			SQInteger stype;
+			NEXT();
+			if(CUR_CHAR != _SC('"')) {
+				RETURN_TOKEN('@');
+			}
+			if((stype=ReadString('"',true))!=-1) {
+				RETURN_TOKEN(stype);
+			}
+			return Error(_SC("error parsing the string"));
+					   }
+		case _SC('"'):
+		case _SC('\''): {
+			SQInteger stype;
+			if((stype=ReadString(CUR_CHAR,false))!=-1){
+				RETURN_TOKEN(stype);
+			}
+			return Error(_SC("error parsing the string"));
+			}
+		case _SC('{'): case _SC('}'): case _SC('('): case _SC(')'): case _SC('['): case _SC(']'):
+		case _SC(';'): case _SC(','): case _SC('?'): case _SC('~'):
 			{
-			    SQInteger ret = CUR_CHAR;
+			    SQInteger ret = CUR_CHAR;
                 NEXT();
                 if((ret == _SC('[') || ret == _SC('{') || ret == _SC('(')) && CUR_CHAR == _SC('=')){
                     //lets try lua literal delimiters
-                    SQInteger stype;
-                    if((stype=ReadString(ret,true))!=-1){
-                        RETURN_TOKEN(stype);
-                    }
-                    return Error(_SC("error parsing the string"));
+                    SQInteger stype;
+                    if((stype=ReadString(ret,true))!=-1){
+                        RETURN_TOKEN(stype);
+                    }
+                    return Error(_SC("error parsing the string"));
                 }
                 else RETURN_TOKEN(ret);
-            }
-		case _SC('.'):
-			NEXT();
-			if (CUR_CHAR != _SC('.')){ RETURN_TOKEN('.') }
+            }
+		case _SC('.'):
+			NEXT();
+			if (CUR_CHAR != _SC('.')){ RETURN_TOKEN('.') }
+			NEXT();
+			if (CUR_CHAR != _SC('.')){ return Error(_SC("invalid token '..'")); }
+			NEXT();
+			RETURN_TOKEN(TK_VARPARAMS);
+		case _SC('^'):
+			NEXT();
+			//if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_BIT_XOR_EQ);}
+			RETURN_TOKEN('^');
+		case _SC('&'):
+			NEXT();
+			//if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_BIT_AND_EQ);}
+			if (CUR_CHAR != _SC('&')){ RETURN_TOKEN('&') }
+			else { NEXT(); RETURN_TOKEN(TK_AND); }
+		case _SC('|'):
 			NEXT();
-			if (CUR_CHAR != _SC('.')){ return Error(_SC("invalid token '..'")); }
-			NEXT();
-			RETURN_TOKEN(TK_VARPARAMS);
-		case _SC('^'):
-			NEXT();
-			//if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_BIT_XOR_EQ);}
-			RETURN_TOKEN('^');
-		case _SC('&'):
-			NEXT();
-			//if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_BIT_AND_EQ);}
-			if (CUR_CHAR != _SC('&')){ RETURN_TOKEN('&') }
-			else { NEXT(); RETURN_TOKEN(TK_AND); }
-		case _SC('|'):
-			NEXT();
-			//if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_BIT_OR_EQ);}
-			if (CUR_CHAR != _SC('|')){ RETURN_TOKEN('|') }
-			else { NEXT(); RETURN_TOKEN(TK_OR); }
-		case _SC(':'):
-			NEXT();
-			if (CUR_CHAR != _SC(':')){ RETURN_TOKEN(':') }
-			else { NEXT(); RETURN_TOKEN(TK_DOUBLE_COLON); }
-		case _SC('*'):
-			NEXT();
-			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_MULEQ);}
-			else RETURN_TOKEN('*');
-		case _SC('%'):
-			NEXT();
-			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_MODEQ);}
-			else RETURN_TOKEN('%');
-		case _SC('-'):
-			NEXT();
-			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_MINUSEQ);}
-			else if  (CUR_CHAR == _SC('-')){ NEXT(); RETURN_TOKEN(TK_MINUSMINUS);}
-			else if  (CUR_CHAR == _SC('>')){ NEXT(); RETURN_TOKEN('.');} //accept C/C++ like pointers
-			else RETURN_TOKEN('-');
-		case _SC('+'):
-			NEXT();
-			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_PLUSEQ);}
-			else if (CUR_CHAR == _SC('+')){ NEXT(); RETURN_TOKEN(TK_PLUSPLUS);}
-			else RETURN_TOKEN('+');
-		case SQUIRREL_EOB:
-			return 0;
-		default:{
-				if (scisdigit(CUR_CHAR)) {
+			//if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_BIT_OR_EQ);}
+			if (CUR_CHAR != _SC('|')){ RETURN_TOKEN('|') }
+			else { NEXT(); RETURN_TOKEN(TK_OR); }
+		case _SC(':'):
+			NEXT();
+			if (CUR_CHAR != _SC(':')){ RETURN_TOKEN(':') }
+			else { NEXT(); RETURN_TOKEN(TK_DOUBLE_COLON); }
+		case _SC('*'):
+			NEXT();
+			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_MULEQ);}
+			else RETURN_TOKEN('*');
+		case _SC('%'):
+			NEXT();
+			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_MODEQ);}
+			else RETURN_TOKEN('%');
+		case _SC('-'):
+			NEXT();
+			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_MINUSEQ);}
+			else if  (CUR_CHAR == _SC('-')){ NEXT(); RETURN_TOKEN(TK_MINUSMINUS);}
+			else if  (CUR_CHAR == _SC('>')){ NEXT(); RETURN_TOKEN('.');} //accept C/C++ like pointers
+			else RETURN_TOKEN('-');
+		case _SC('+'):
+			NEXT();
+			if (CUR_CHAR == _SC('=')){ NEXT(); RETURN_TOKEN(TK_PLUSEQ);}
+			else if (CUR_CHAR == _SC('+')){ NEXT(); RETURN_TOKEN(TK_PLUSPLUS);}
+			else RETURN_TOKEN('+');
+		case SQUIRREL_EOB:
+			return 0;
+		default:{
+				if (scisdigit(CUR_CHAR)) {
 					SQInteger ret = ReadNumber();
-					if(ret < 0) return -1;
-					RETURN_TOKEN(ret);
-				}
-				else if (scisalpha(CUR_CHAR) || CUR_CHAR == _SC('_')) {
+					if(ret < 0) return -1;
+					RETURN_TOKEN(ret);
+				}
+				else if (scisalpha(CUR_CHAR) || CUR_CHAR == _SC('_')) {
 					SQInteger t = ReadID();
-					if(t < 0) return -1;
-					RETURN_TOKEN(t);
-				}
-				else {
-					SQInteger c = CUR_CHAR;
-					if (sciscntrl((int)c)) return Error(_SC("unexpected character(control)"));
-					NEXT();
-					RETURN_TOKEN(c);
-				}
-				RETURN_TOKEN(0);
-			}
-		}
-	}
-	return 0;
-}
-
+					if(t < 0) return -1;
+					RETURN_TOKEN(t);
+				}
+				else {
+					SQInteger c = CUR_CHAR;
+					if (sciscntrl((int)c)) return Error(_SC("unexpected character(control)"));
+					NEXT();
+					RETURN_TOKEN(c);
+				}
+				RETURN_TOKEN(0);
+			}
+		}
+	}
+	return 0;
+}
+
 SQInteger SQLexer::GetIDType(const SQChar *s,SQInteger len)
 {
 	SQObjectPtr t;
 	if(_keywords->GetStr(s,len, t)) {
-		return SQInteger(_integer(t));
-	}
-	return TK_IDENTIFIER;
-}
+		return SQInteger(_integer(t));
+	}
+	return TK_IDENTIFIER;
+}
 
 #ifdef SQUNICODE
 #if WCHAR_SIZE == 2
@@ -498,10 +498,10 @@ SQInteger SQLexer::ProcessStringHexEscape(SQChar *dest, SQInteger maxdigits)
     dest[n] = 0;
     return n;
 }
-
-SQInteger SQLexer::ReadString(SQInteger ndelim,bool verbatim)
-{
-	INIT_TEMP_STRING();
+
+SQInteger SQLexer::ReadString(SQInteger ndelim,bool verbatim)
+{
+	INIT_TEMP_STRING();
 	SQInteger start_equals = 0;
 	SQChar cdelim1, cdelim2;
 	if(ndelim == _SC('{')){
@@ -527,9 +527,9 @@ SQInteger SQLexer::ReadString(SQInteger ndelim,bool verbatim)
 	        return Error(_SC("expect '%c' on literal delimiter"), cdelim1);
 	    }
 	    ndelim = cdelim2;
-	}
-	NEXT();
-	if(IS_EOB()) return -1;
+	}
+	NEXT();
+	if(IS_EOB()) return -1;
 	if(start_equals) {
 	    int cr_nl = CUR_CHAR == _SC('\r');
         if(cr_nl) NEXT();
@@ -541,26 +541,26 @@ SQInteger SQLexer::ReadString(SQInteger ndelim,bool verbatim)
             {
                 return Error(_SC("unfinished string"));
             }
-        }
+        }
 	}
-	for(;;) {
+	for(;;) {
 		while(CUR_CHAR != ndelim) {
-            SQInteger x = CUR_CHAR;
-			switch(x) {
-			case SQUIRREL_EOB:
-				return Error(_SC("unfinished string"));
-			case _SC('\n'):
-				if(!verbatim) return Error(_SC("newline in a constant"));
-				APPEND_CHAR(CUR_CHAR); NEXT();
-				_currentline++;
-				break;
-			case _SC('\\'):
-				if(verbatim) {
-					APPEND_CHAR('\\'); NEXT();
-				}
-				else {
-					NEXT();
-					switch(CUR_CHAR) {
+            SQInteger x = CUR_CHAR;
+			switch(x) {
+			case SQUIRREL_EOB:
+				return Error(_SC("unfinished string"));
+			case _SC('\n'):
+				if(!verbatim) return Error(_SC("newline in a constant"));
+				APPEND_CHAR(CUR_CHAR); NEXT();
+				_currentline++;
+				break;
+			case _SC('\\'):
+				if(verbatim) {
+					APPEND_CHAR('\\'); NEXT();
+				}
+				else {
+					NEXT();
+					switch(CUR_CHAR) {
                     case _SC('x'):  {
                         const SQInteger maxdigits = sizeof(SQChar) * 2;
                         SQChar temp[maxdigits + 1];
@@ -584,31 +584,31 @@ SQInteger SQLexer::ReadString(SQInteger ndelim,bool verbatim)
 #else
                         AddUTF8(scstrtoul(temp, &stemp, 16));
 #endif
-					}
-				    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;
-					default:
-						return Error(_SC("unrecognised escaper char"));
-					break;
-					}
-				}
-				break;
-			default:
-				APPEND_CHAR(CUR_CHAR);
-				NEXT();
-			}
-		}
-		NEXT();
+					}
+				    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;
+					default:
+						return Error(_SC("unrecognised escaper char"));
+					break;
+					}
+				}
+				break;
+			default:
+				APPEND_CHAR(CUR_CHAR);
+				NEXT();
+			}
+		}
+		NEXT();
 		if(start_equals){
 		    bool lastBraceAdded = false;
 		    if(CUR_CHAR == _SC('=')){
@@ -632,154 +632,154 @@ SQInteger SQLexer::ReadString(SQInteger ndelim,bool verbatim)
 		    if(!lastBraceAdded) APPEND_CHAR(cdelim2); //the first NEXT() after break the while loop
 		    APPEND_CHAR(CUR_CHAR);
 		    NEXT();
-		}
-		else if(verbatim && CUR_CHAR == '"') { //double quotation
-			APPEND_CHAR(CUR_CHAR);
-			NEXT();
-		}
-		else {
-			break;
-		}
-	}
-	TERMINATE_BUFFER();
-	SQInteger len = _longstr.size()-1;
-	if(ndelim == _SC('\'')) {
-		if(len == 0) return Error(_SC("empty constant"));
-		if(len > 1) return Error(_SC("constant too long"));
-		_nvalue = _longstr[0];
-		return TK_INTEGER;
-	}
-	_svalue = &_longstr[0];
-	return TK_STRING_LITERAL;
-}
-
-void LexHexadecimal(const SQChar *s,SQUnsignedInteger *res)
-{
-	*res = 0;
-	while(*s != 0)
-	{
-		if(scisdigit(*s)) *res = (*res)*16+((*s++)-'0');
-		else if(scisxdigit(*s)) *res = (*res)*16+(toupper(*s++)-'A'+10);
-		else { assert(0); }
-	}
-}
-
-void LexInteger(const SQChar *s,SQUnsignedInteger *res)
-{
-	*res = 0;
-	while(*s != 0)
-	{
-		*res = (*res)*10+((*s++)-'0');
-	}
-}
-
-SQInteger scisodigit(SQInteger c) { return c >= _SC('0') && c <= _SC('7'); }
-
-void LexOctal(const SQChar *s,SQUnsignedInteger *res)
-{
-	*res = 0;
-	while(*s != 0)
-	{
-		if(scisodigit(*s)) *res = (*res)*8+((*s++)-'0');
-		else { assert(0); }
+		}
+		else if(verbatim && CUR_CHAR == '"') { //double quotation
+			APPEND_CHAR(CUR_CHAR);
+			NEXT();
+		}
+		else {
+			break;
+		}
+	}
+	TERMINATE_BUFFER();
+	SQInteger len = _longstr.size()-1;
+	if(ndelim == _SC('\'')) {
+		if(len == 0) return Error(_SC("empty constant"));
+		if(len > 1) return Error(_SC("constant too long"));
+		_nvalue = _longstr[0];
+		return TK_INTEGER;
+	}
+	_svalue = &_longstr[0];
+	return TK_STRING_LITERAL;
+}
+
+void LexHexadecimal(const SQChar *s,SQUnsignedInteger *res)
+{
+	*res = 0;
+	while(*s != 0)
+	{
+		if(scisdigit(*s)) *res = (*res)*16+((*s++)-'0');
+		else if(scisxdigit(*s)) *res = (*res)*16+(toupper(*s++)-'A'+10);
+		else { assert(0); }
+	}
+}
+
+void LexInteger(const SQChar *s,SQUnsignedInteger *res)
+{
+	*res = 0;
+	while(*s != 0)
+	{
+		*res = (*res)*10+((*s++)-'0');
 	}
-}
-
-SQInteger isexponent(SQInteger c) { return c == 'e' || c=='E'; }
-
-
-#define MAX_HEX_DIGITS (sizeof(SQInteger)*2)
-SQInteger SQLexer::ReadNumber()
-{
-#define TINT 1
-#define TFLOAT 2
-#define THEX 3
-#define TSCIENTIFIC 4
-#define TOCTAL 5
+}
+
+SQInteger scisodigit(SQInteger c) { return c >= _SC('0') && c <= _SC('7'); }
+
+void LexOctal(const SQChar *s,SQUnsignedInteger *res)
+{
+	*res = 0;
+	while(*s != 0)
+	{
+		if(scisodigit(*s)) *res = (*res)*8+((*s++)-'0');
+		else { assert(0); }
+	}
+}
+
+SQInteger isexponent(SQInteger c) { return c == 'e' || c=='E'; }
+
+
+#define MAX_HEX_DIGITS (sizeof(SQInteger)*2)
+SQInteger SQLexer::ReadNumber()
+{
+#define TINT 1
+#define TFLOAT 2
+#define THEX 3
+#define TSCIENTIFIC 4
+#define TOCTAL 5
 	SQInteger type = TINT, firstchar = CUR_CHAR;
-	SQUnsignedInteger itmp=0;
-	SQChar *sTemp;
-	INIT_TEMP_STRING();
-	NEXT();
-	if(firstchar == _SC('0') && (toupper(CUR_CHAR) == _SC('X') || scisodigit(CUR_CHAR)) ) {
-		if(scisodigit(CUR_CHAR)) {
-			type = TOCTAL;
-			while(scisodigit(CUR_CHAR)) {
-				APPEND_CHAR(CUR_CHAR);
-				NEXT();
-			}
-			if(scisdigit(CUR_CHAR)) return Error(_SC("invalid octal number"));
-		}
-		else {
-			NEXT();
-			type = THEX;
-			while(isxdigit(CUR_CHAR)) {
-				APPEND_CHAR(CUR_CHAR);
-				NEXT();
-			}
-			if(_longstr.size() > MAX_HEX_DIGITS) return Error(_SC("too many digits for an Hex number"));
-		}
-	}
-	else {
-		APPEND_CHAR((int)firstchar);
-		while (CUR_CHAR == _SC('.') || scisdigit(CUR_CHAR) || isexponent(CUR_CHAR)) {
-            if(CUR_CHAR == _SC('.') || isexponent(CUR_CHAR)) type = TFLOAT;
-			if(isexponent(CUR_CHAR)) {
-				if(type != TFLOAT) return Error(_SC("invalid numeric format"));
-				type = TSCIENTIFIC;
-				APPEND_CHAR(CUR_CHAR);
-				NEXT();
-				if(CUR_CHAR == '+' || CUR_CHAR == '-'){
-					APPEND_CHAR(CUR_CHAR);
-					NEXT();
-				}
-				if(!scisdigit(CUR_CHAR)) return Error(_SC("exponent expected"));
-			}
-
-			APPEND_CHAR(CUR_CHAR);
-			NEXT();
-		}
-	}
-	TERMINATE_BUFFER();
-	switch(type) {
-	case TSCIENTIFIC:
-	case TFLOAT:
-		_fvalue = (SQFloat)scstrtod(&_longstr[0],&sTemp);
-		return TK_FLOAT;
-	case TINT:
+	SQUnsignedInteger itmp=0;
+	SQChar *sTemp;
+	INIT_TEMP_STRING();
+	NEXT();
+	if(firstchar == _SC('0') && (toupper(CUR_CHAR) == _SC('X') || scisodigit(CUR_CHAR)) ) {
+		if(scisodigit(CUR_CHAR)) {
+			type = TOCTAL;
+			while(scisodigit(CUR_CHAR)) {
+				APPEND_CHAR(CUR_CHAR);
+				NEXT();
+			}
+			if(scisdigit(CUR_CHAR)) return Error(_SC("invalid octal number"));
+		}
+		else {
+			NEXT();
+			type = THEX;
+			while(isxdigit(CUR_CHAR)) {
+				APPEND_CHAR(CUR_CHAR);
+				NEXT();
+			}
+			if(_longstr.size() > MAX_HEX_DIGITS) return Error(_SC("too many digits for an Hex number"));
+		}
+	}
+	else {
+		APPEND_CHAR((int)firstchar);
+		while (CUR_CHAR == _SC('.') || scisdigit(CUR_CHAR) || isexponent(CUR_CHAR)) {
+            if(CUR_CHAR == _SC('.') || isexponent(CUR_CHAR)) type = TFLOAT;
+			if(isexponent(CUR_CHAR)) {
+				if(type != TFLOAT) return Error(_SC("invalid numeric format"));
+				type = TSCIENTIFIC;
+				APPEND_CHAR(CUR_CHAR);
+				NEXT();
+				if(CUR_CHAR == '+' || CUR_CHAR == '-'){
+					APPEND_CHAR(CUR_CHAR);
+					NEXT();
+				}
+				if(!scisdigit(CUR_CHAR)) return Error(_SC("exponent expected"));
+			}
+
+			APPEND_CHAR(CUR_CHAR);
+			NEXT();
+		}
+	}
+	TERMINATE_BUFFER();
+	switch(type) {
+	case TSCIENTIFIC:
+	case TFLOAT:
+		_fvalue = (SQFloat)scstrtod(&_longstr[0],&sTemp);
+		return TK_FLOAT;
+	case TINT:
 		LexInteger(&_longstr[0],&itmp);
-		break;
-	case THEX:
-		LexHexadecimal(&_longstr[0],&itmp);
-		break;
-	case TOCTAL:
-		LexOctal(&_longstr[0],&itmp);
-		break;
-	}
-	switch(type) {
-	case TINT:
-	case THEX:
+		break;
+	case THEX:
+		LexHexadecimal(&_longstr[0],&itmp);
+		break;
+	case TOCTAL:
+		LexOctal(&_longstr[0],&itmp);
+		break;
+	}
+	switch(type) {
+	case TINT:
+	case THEX:
 	case TOCTAL:
 	    //to allow 64 bits integers comment bellow
         //if(itmp > INT_MAX) return Error(_SC("integer overflow %ulld %d"));
-        _nvalue = (SQInteger) itmp;
-		return TK_INTEGER;
-	}
-	return 0;
-}
-
-SQInteger SQLexer::ReadID()
-{
-	SQInteger res;
-	INIT_TEMP_STRING();
-	do {
-		APPEND_CHAR(CUR_CHAR);
-		NEXT();
-	} while(scisalnum(CUR_CHAR) || CUR_CHAR == _SC('_'));
-	TERMINATE_BUFFER();
+        _nvalue = (SQInteger) itmp;
+		return TK_INTEGER;
+	}
+	return 0;
+}
+
+SQInteger SQLexer::ReadID()
+{
+	SQInteger res;
+	INIT_TEMP_STRING();
+	do {
+		APPEND_CHAR(CUR_CHAR);
+		NEXT();
+	} while(scisalnum(CUR_CHAR) || CUR_CHAR == _SC('_'));
+	TERMINATE_BUFFER();
 	res = GetIDType(&_longstr[0],_longstr.size() - 1);
-	if(res == TK_IDENTIFIER || res == TK_CONSTRUCTOR || res == TK_DESTRUCTOR) {
-		_svalue = &_longstr[0];
-	}
-	return res;
-}
+	if(res == TK_IDENTIFIER || res == TK_CONSTRUCTOR || res == TK_DESTRUCTOR) {
+		_svalue = &_longstr[0];
+	}
+	return res;
+}

SquiLu/squirrel/sqlexer.h

@@ -1,32 +1,32 @@
-/*	see copyright notice in squirrel.h */
-#ifndef _SQLEXER_H_
-#define _SQLEXER_H_
-
-#ifdef SQUNICODE
-typedef SQChar LexChar;
-#else
-typedef	unsigned char LexChar;
-#endif
-
-struct SQLexer
-{
-	SQLexer();
-	virtual ~SQLexer();
+/*	see copyright notice in squirrel.h */
+#ifndef _SQLEXER_H_
+#define _SQLEXER_H_
+
+#ifdef SQUNICODE
+typedef SQChar LexChar;
+#else
+typedef	unsigned char LexChar;
+#endif
+
+struct SQLexer
+{
+	SQLexer();
+	virtual ~SQLexer();
 	SQInteger Init(SQSharedState *ss,SQLEXREADFUNC rg,SQUserPointer up,
                 CompilerErrorFunc efunc,void *ed, SQBool want_comments=SQFalse);
 	SQInteger ResetReader(SQLEXREADFUNC rg, SQUserPointer up, SQInteger line);
-	SQTable * GetKeywords();
-	SQInteger Error(const SQChar *err, ...);
-	SQInteger Lex();
+	SQTable * GetKeywords();
+	SQInteger Error(const SQChar *err, ...);
+	SQInteger Lex();
 	const SQChar *Tok2Str(SQInteger tok);
-	const SQChar *GetTokenName(int tk_code);
-private:
+	const SQChar *GetTokenName(int tk_code);
+private:
 	SQInteger GetIDType(const SQChar *s,SQInteger len);
-	SQInteger ReadString(SQInteger ndelim,bool verbatim);
-	SQInteger ReadNumber();
-	SQInteger LexBlockComment();
-	SQInteger LexLineComment();
-	SQInteger ReadID();
+	SQInteger ReadString(SQInteger ndelim,bool verbatim);
+	SQInteger ReadNumber();
+	SQInteger LexBlockComment();
+	SQInteger LexLineComment();
+	SQInteger ReadID();
 	SQInteger Next();
 #ifdef SQUNICODE
 #if WCHAR_SIZE == 2
@@ -35,28 +35,28 @@ private:
 #else
     SQInteger AddUTF8(SQUnsignedInteger ch);
 #endif
-    SQInteger ProcessStringHexEscape(SQChar *dest, SQInteger maxdigits);
-	SQInteger _curtoken;
-	SQTable *_keywords;
-	SQBool _reached_eof;
-public:
-	SQInteger _prevtoken;
-	SQInteger _currentline;
-	SQInteger _lasttokenline;
-	SQInteger _lasttokencolumn;
-	SQInteger _currentcolumn;
-	const SQChar *_svalue;
-	SQInteger _nvalue;
-	SQFloat _fvalue;
-	SQLEXREADFUNC _readf;
-	SQUserPointer _up;
-	LexChar _currdata;
-	SQSharedState *_sharedstate;
-	sqvector<SQChar> _longstr;
-	CompilerErrorFunc _errfunc;
+    SQInteger ProcessStringHexEscape(SQChar *dest, SQInteger maxdigits);
+	SQInteger _curtoken;
+	SQTable *_keywords;
+	SQBool _reached_eof;
+public:
+	SQInteger _prevtoken;
+	SQInteger _currentline;
+	SQInteger _lasttokenline;
+	SQInteger _lasttokencolumn;
+	SQInteger _currentcolumn;
+	const SQChar *_svalue;
+	SQInteger _nvalue;
+	SQFloat _fvalue;
+	SQLEXREADFUNC _readf;
+	SQUserPointer _up;
+	LexChar _currdata;
+	SQSharedState *_sharedstate;
+	sqvector<SQChar> _longstr;
+	CompilerErrorFunc _errfunc;
 	void *_errtarget;
 	SQChar _lasterror[256];
-	SQBool _want_comments;
-};
-
-#endif
+	SQBool _want_comments;
+};
+
+#endif

SquiLu/squirrel/sqmem.cpp

@@ -1,11 +1,11 @@
 /*
-	see copyright notice in squirrel.h
+    see copyright notice in squirrel.h
 */
 #include "sqpcheader.h"
 #ifndef SQ_EXCLUDE_DEFAULT_MEMFUNCTIONS
-void *sq_vm_malloc(SQUnsignedInteger size){	return malloc(size); }
+void *sq_vm_malloc(SQUnsignedInteger size){ return malloc(size); }
 
-void *sq_vm_realloc(void *p, SQUnsignedInteger /*oldsize*/, SQUnsignedInteger size){ return realloc(p, size); }
+void *sq_vm_realloc(void *p, SQUnsignedInteger SQ_UNUSED_ARG(oldsize), SQUnsignedInteger size){ return realloc(p, size); }
 
-void sq_vm_free(void *p, SQUnsignedInteger /*size*/){	free(p); }
+void sq_vm_free(void *p, SQUnsignedInteger SQ_UNUSED_ARG(size)){ free(p); }
 #endif

SquiLu/squirrel/sqobject.cpp

@@ -84,15 +84,15 @@ SQUnsignedInteger SQTranslateIndex(const SQObjectPtr &idx)
 
 SQWeakRef *SQRefCounted::GetWeakRef(SQObjectType type)
 {
-	if(!_weakref) {
-		sq_new(_weakref,SQWeakRef);
-#if defined(SQUSEDOUBLE) && !defined(_SQ64) || !defined(SQUSEDOUBLE) && defined(_SQ64)
-		_weakref->_obj._unVal.raw = 0; //without this on 32bits using double the comparison operator do not work
+    if(!_weakref) {
+        sq_new(_weakref,SQWeakRef);
+#if defined(SQUSEDOUBLE) && !defined(_SQ64)
+        _weakref->_obj._unVal.raw = 0; //clean the whole union on 32 bits with double
 #endif
-		_weakref->_obj._type = type;
-		_weakref->_obj._unVal.pRefCounted = this;
-	}
-	return _weakref;
+        _weakref->_obj._type = type;
+        _weakref->_obj._unVal.pRefCounted = this;
+    }
+    return _weakref;
 }
 
 SQRefCounted::~SQRefCounted()
@@ -269,9 +269,10 @@ SQInteger SQFunctionProto::GetLine(SQInstruction *curr)
 
 SQClosure::~SQClosure()
 {
-	__ObjRelease(_env);
-	__ObjRelease(_base);
-	REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);
+    __ObjRelease(_root);
+    __ObjRelease(_env);
+    __ObjRelease(_base);
+    REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);
 }
 
 #define _CHECK_IO(exp)  { if(!exp)return false; }

SquiLu/squirrel/sqobject.h

@@ -1,375 +1,379 @@
-/*	see copyright notice in squirrel.h */
-#ifndef _SQOBJECT_H_
-#define _SQOBJECT_H_
-
-#include "squtils.h"
-
-#ifdef _SQ64
-#define UINT_MINUS_ONE (0xFFFFFFFFFFFFFFFF)
-#else
-#define UINT_MINUS_ONE (0xFFFFFFFF)
-#endif
-
-#define SQ_CLOSURESTREAM_HEAD (('S'<<24)|('Q'<<16)|('I'<<8)|('R'))
-#define SQ_CLOSURESTREAM_PART (('P'<<24)|('A'<<16)|('R'<<8)|('T'))
-#define SQ_CLOSURESTREAM_TAIL (('T'<<24)|('A'<<16)|('I'<<8)|('L'))
-
-struct SQSharedState;
-
-enum SQMetaMethod{
-	MT_ADD=0,
-	MT_SUB=1,
-	MT_MUL=2,
-	MT_DIV=3,
-	MT_UNM=4,
-	MT_MODULO=5,
-	MT_SET=6,
-	MT_GET=7,
-	MT_TYPEOF=8,
-	MT_NEXTI=9,
-	MT_CMP=10,
-	MT_CALL=11,
-	MT_CLONED=12,
-	MT_NEWSLOT=13,
-	MT_DELSLOT=14,
-	MT_TOSTRING=15,
-	MT_NEWMEMBER=16,
-	MT_INHERITED=17,
-	MT_LAST = 18
-};
-
-#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 _CONSTRUCT_VECTOR(type,size,ptr) { \
-	for(SQInteger n = 0; n < ((SQInteger)size); n++) { \
-			new (&ptr[n]) type(); \
-		} \
-}
-
-#define _DESTRUCT_VECTOR(type,size,ptr) { \
-	for(SQInteger nl = 0; nl < ((SQInteger)size); nl++) { \
-			ptr[nl].~type(); \
-	} \
-}
-
-#define _COPY_VECTOR(dest,src,size) { \
-	for(SQInteger _n_ = 0; _n_ < ((SQInteger)size); _n_++) { \
-		dest[_n_] = src[_n_]; \
-	} \
-}
-
-#define _NULL_SQOBJECT_VECTOR(vec,size) { \
-	for(SQInteger _n_ = 0; _n_ < ((SQInteger)size); _n_++) { \
-		vec[_n_].Null(); \
-	} \
-}
-
-#define MINPOWER2 4
-
-struct SQRefCounted
-{
-	SQUnsignedInteger _uiRef;
-	struct SQWeakRef *_weakref;
-	SQRefCounted() { _uiRef = 0; _weakref = NULL; }
-	virtual ~SQRefCounted();
-	SQWeakRef *GetWeakRef(SQObjectType type);
-	virtual void Release()=0;
-
-};
-
-struct SQWeakRef : SQRefCounted
-{
-	void Release();
-	SQObject _obj;
-};
-
-#define _realval(o) (type((o)) != OT_WEAKREF?(SQObject)o:_weakref(o)->_obj)
-
-struct SQObjectPtr;
-
-#define __AddRefRefCounted(unval) { unval.pRefCounted->_uiRef++; }
-
-#define __AddRef(type,unval) if(ISREFCOUNTED(type))	__AddRefRefCounted(unval)
-
-#define __ReleaseRefCounted(unval) if((--unval.pRefCounted->_uiRef)==0)	\
-		{	\
-			unval.pRefCounted->Release();	\
-		}
+/*	see copyright notice in squirrel.h */
+#ifndef _SQOBJECT_H_
+#define _SQOBJECT_H_
+
+#include "squtils.h"
+
+#ifdef _SQ64
+#define UINT_MINUS_ONE (0xFFFFFFFFFFFFFFFF)
+#else
+#define UINT_MINUS_ONE (0xFFFFFFFF)
+#endif
+
+#define SQ_CLOSURESTREAM_HEAD (('S'<<24)|('Q'<<16)|('I'<<8)|('R'))
+#define SQ_CLOSURESTREAM_PART (('P'<<24)|('A'<<16)|('R'<<8)|('T'))
+#define SQ_CLOSURESTREAM_TAIL (('T'<<24)|('A'<<16)|('I'<<8)|('L'))
+
+struct SQSharedState;
+
+enum SQMetaMethod{
+	MT_ADD=0,
+	MT_SUB=1,
+	MT_MUL=2,
+	MT_DIV=3,
+	MT_UNM=4,
+	MT_MODULO=5,
+	MT_SET=6,
+	MT_GET=7,
+	MT_TYPEOF=8,
+	MT_NEXTI=9,
+	MT_CMP=10,
+	MT_CALL=11,
+	MT_CLONED=12,
+	MT_NEWSLOT=13,
+	MT_DELSLOT=14,
+	MT_TOSTRING=15,
+	MT_NEWMEMBER=16,
+	MT_INHERITED=17,
+	MT_LAST = 18
+};
+
+#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 _CONSTRUCT_VECTOR(type,size,ptr) { \
+	for(SQInteger n = 0; n < ((SQInteger)size); n++) { \
+			new (&ptr[n]) type(); \
+		} \
+}
+
+#define _DESTRUCT_VECTOR(type,size,ptr) { \
+	for(SQInteger nl = 0; nl < ((SQInteger)size); nl++) { \
+			ptr[nl].~type(); \
+	} \
+}
+
+#define _COPY_VECTOR(dest,src,size) { \
+	for(SQInteger _n_ = 0; _n_ < ((SQInteger)size); _n_++) { \
+		dest[_n_] = src[_n_]; \
+	} \
+}
+
+#define _NULL_SQOBJECT_VECTOR(vec,size) { \
+	for(SQInteger _n_ = 0; _n_ < ((SQInteger)size); _n_++) { \
+		vec[_n_].Null(); \
+	} \
+}
+
+#define MINPOWER2 4
+
+struct SQRefCounted
+{
+	SQUnsignedInteger _uiRef;
+	struct SQWeakRef *_weakref;
+	SQRefCounted() { _uiRef = 0; _weakref = NULL; }
+	virtual ~SQRefCounted();
+	SQWeakRef *GetWeakRef(SQObjectType type);
+	virtual void Release()=0;
+
+};
+
+struct SQWeakRef : SQRefCounted
+{
+	void Release();
+	SQObject _obj;
+};
+
+#define _realval(o) (type((o)) != OT_WEAKREF?(SQObject)o:_weakref(o)->_obj)
+
+struct SQObjectPtr;
+
+#define __AddRefRefCounted(unval) { unval.pRefCounted->_uiRef++; }
+
+#define __AddRef(type,unval) if(ISREFCOUNTED(type))	__AddRefRefCounted(unval)
+
+#define __ReleaseRefCounted(unval) if((--unval.pRefCounted->_uiRef)==0)	\
+		{	\
+			unval.pRefCounted->Release();	\
+		}
 
 #define __Release(type,unval) if(ISREFCOUNTED(type)) __ReleaseRefCounted(unval)
-
-#define __ObjRelease(obj) { \
-	if((obj)) {	\
-		(obj)->_uiRef--; \
-		if((obj)->_uiRef == 0) \
-			(obj)->Release(); \
-		(obj) = NULL;	\
-	} \
-}
-
-#define __ObjAddRef(obj) { \
-	(obj)->_uiRef++; \
-}
-
-#define type(obj) ((obj)._type)
-#define is_delegable(t) (type(t)&SQOBJECT_DELEGABLE)
-#define raw_type(obj) _RAW_TYPE((obj)._type)
-
-#define _integer(obj) ((obj)._unVal.nInteger)
-#define _float(obj) ((obj)._unVal.fFloat)
-#define _string(obj) ((obj)._unVal.pString)
-#define _table(obj) ((obj)._unVal.pTable)
-#define _array(obj) ((obj)._unVal.pArray)
-#define _closure(obj) ((obj)._unVal.pClosure)
-#define _generator(obj) ((obj)._unVal.pGenerator)
-#define _nativeclosure(obj) ((obj)._unVal.pNativeClosure)
-#define _userdata(obj) ((obj)._unVal.pUserData)
-#define _userpointer(obj) ((obj)._unVal.pUserPointer)
-#define _thread(obj) ((obj)._unVal.pThread)
-#define _funcproto(obj) ((obj)._unVal.pFunctionProto)
-#define _class(obj) ((obj)._unVal.pClass)
-#define _instance(obj) ((obj)._unVal.pInstance)
-#define _delegable(obj) ((SQDelegable *)(obj)._unVal.pDelegable)
-#define _weakref(obj) ((obj)._unVal.pWeakRef)
-#define _outer(obj) ((obj)._unVal.pOuter)
-#define _refcounted(obj) ((obj)._unVal.pRefCounted)
-#define _rawval(obj) ((obj)._unVal.raw)
-
-#define _stringval(obj) (obj)._unVal.pString->_val
-#define _userdataval(obj) ((SQUserPointer)sq_aligning((obj)._unVal.pUserData + 1))
-
-#define tofloat(num) ((type(num)==OT_INTEGER)?(SQFloat)_integer(num):_float(num))
-#define tointeger(num) ((type(num)==OT_FLOAT)?(SQInteger)_float(num):_integer(num))
-/////////////////////////////////////////////////////////////////////////////////////
-/////////////////////////////////////////////////////////////////////////////////////
-#if defined(SQUSEDOUBLE) && !defined(_SQ64) || !defined(SQUSEDOUBLE) && defined(_SQ64)
-#define SQ_REFOBJECT_INIT()	SQ_OBJECT_RAWINIT()
-#else
-#define SQ_REFOBJECT_INIT()
-#endif
-
-#define _REF_TYPE_DECL(type,_class,sym) \
-	SQObjectPtr(_class * x) \
-	{ \
-		SQ_OBJECT_RAWINIT() \
-		_type=type; \
-		_unVal.p##sym = x; \
-		assert(_unVal.pTable); \
-		_unVal.pRefCounted->_uiRef++; \
-	} \
-	inline SQObjectPtr& operator=(_class *x) \
-	{  \
+
+#define __ObjRelease(obj) { \
+	if((obj)) {	\
+		(obj)->_uiRef--; \
+		if((obj)->_uiRef == 0) \
+			(obj)->Release(); \
+		(obj) = NULL;	\
+	} \
+}
+
+#define __ObjAddRef(obj) { \
+	(obj)->_uiRef++; \
+}
+
+#define type(obj) ((obj)._type)
+#define is_delegable(t) (type(t)&SQOBJECT_DELEGABLE)
+#define raw_type(obj) _RAW_TYPE((obj)._type)
+
+#define _integer(obj) ((obj)._unVal.nInteger)
+#define _float(obj) ((obj)._unVal.fFloat)
+#define _string(obj) ((obj)._unVal.pString)
+#define _table(obj) ((obj)._unVal.pTable)
+#define _array(obj) ((obj)._unVal.pArray)
+#define _closure(obj) ((obj)._unVal.pClosure)
+#define _generator(obj) ((obj)._unVal.pGenerator)
+#define _nativeclosure(obj) ((obj)._unVal.pNativeClosure)
+#define _userdata(obj) ((obj)._unVal.pUserData)
+#define _userpointer(obj) ((obj)._unVal.pUserPointer)
+#define _thread(obj) ((obj)._unVal.pThread)
+#define _funcproto(obj) ((obj)._unVal.pFunctionProto)
+#define _class(obj) ((obj)._unVal.pClass)
+#define _instance(obj) ((obj)._unVal.pInstance)
+#define _delegable(obj) ((SQDelegable *)(obj)._unVal.pDelegable)
+#define _weakref(obj) ((obj)._unVal.pWeakRef)
+#define _outer(obj) ((obj)._unVal.pOuter)
+#define _refcounted(obj) ((obj)._unVal.pRefCounted)
+#define _rawval(obj) ((obj)._unVal.raw)
+
+#define _stringval(obj) (obj)._unVal.pString->_val
+#define _userdataval(obj) ((SQUserPointer)sq_aligning((obj)._unVal.pUserData + 1))
+
+#define tofloat(num) ((type(num)==OT_INTEGER)?(SQFloat)_integer(num):_float(num))
+#define tointeger(num) ((type(num)==OT_FLOAT)?(SQInteger)_float(num):_integer(num))
+/////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
+#if defined(SQUSEDOUBLE) && !defined(_SQ64) || !defined(SQUSEDOUBLE) && defined(_SQ64)
+#define SQ_REFOBJECT_INIT()	SQ_OBJECT_RAWINIT()
+#else
+#define SQ_REFOBJECT_INIT()
+#endif
+
+#define _REF_TYPE_DECL(type,_class,sym) \
+	SQObjectPtr(_class * x) \
+	{ \
+		SQ_OBJECT_RAWINIT() \
+		_type=type; \
+		_unVal.p##sym = x; \
+		assert(_unVal.pTable); \
+		_unVal.pRefCounted->_uiRef++; \
+	} \
+	inline SQObjectPtr& operator=(_class *x) \
+	{  \
 		SQObjectValue old_unVal; \
 		bool isRefCounted = ISREFCOUNTED(_type);\
-		if(isRefCounted) old_unVal = _unVal;\
-		_type = type; \
-		SQ_REFOBJECT_INIT() \
-		_unVal.p##sym = x; \
-		_unVal.pRefCounted->_uiRef++; \
-		if(isRefCounted) __ReleaseRefCounted(old_unVal); \
-		return *this; \
+		if(isRefCounted) old_unVal = _unVal;\
+		_type = type; \
+		SQ_REFOBJECT_INIT() \
+		_unVal.p##sym = x; \
+		_unVal.pRefCounted->_uiRef++; \
+		if(isRefCounted) __ReleaseRefCounted(old_unVal); \
+		return *this; \
 	} \
 	inline _class *to##sym()\
 	{ \
         assert(_type == type); \
         return _unVal.p##sym;\
-	}
-
-#define _SCALAR_TYPE_DECL(type,_class,prefix,sym) \
-	SQObjectPtr(_class x) \
-	{ \
-		SQ_OBJECT_RAWINIT() \
-		_type=type; \
-		_unVal.prefix##sym = x; \
-	} \
-	inline SQObjectPtr& operator=(_class x) \
+	}
+
+#define _SCALAR_TYPE_DECL(type,_class,prefix,sym) \
+	SQObjectPtr(_class x) \
+	{ \
+		SQ_OBJECT_RAWINIT() \
+		_type=type; \
+		_unVal.prefix##sym = x; \
+	} \
+	inline SQObjectPtr& operator=(_class x) \
 	{  \
-		if(_type != type){\
-			__Release(_type,_unVal); \
-			_type = type; \
+		if(_type != type){\
+			__Release(_type,_unVal); \
+			_type = type; \
 			SQ_OBJECT_RAWINIT() \
-		}\
-		_unVal.prefix##sym = x; \
-		return *this; \
-	} \
+		}\
+		_unVal.prefix##sym = x; \
+		return *this; \
+	} \
 	inline _class to##sym()\
 	{ \
         assert(_type == type); \
         return _unVal.prefix##sym;\
-	}
-struct SQObjectPtr : public SQObject
-{
-	SQObjectPtr()
-	{
-		SQ_OBJECT_RAWINIT()
-		_type=OT_NULL;
-		_unVal.pUserPointer=NULL;
-	}
-	SQObjectPtr(const SQObjectPtr &o)
-	{
-		_type = o._type;
-		_unVal = o._unVal;
-		__AddRef(_type,_unVal);
-	}
-	SQObjectPtr(const SQObject &o)
-	{
-		_type = o._type;
-		_unVal = o._unVal;
-		__AddRef(_type,_unVal);
-	}
-	_REF_TYPE_DECL(OT_TABLE,SQTable,Table)
-	_REF_TYPE_DECL(OT_CLASS,SQClass,Class)
-	_REF_TYPE_DECL(OT_INSTANCE,SQInstance,Instance)
-	_REF_TYPE_DECL(OT_ARRAY,SQArray,Array)
-	_REF_TYPE_DECL(OT_CLOSURE,SQClosure,Closure)
-	_REF_TYPE_DECL(OT_NATIVECLOSURE,SQNativeClosure,NativeClosure)
-	_REF_TYPE_DECL(OT_OUTER,SQOuter,Outer)
-	_REF_TYPE_DECL(OT_GENERATOR,SQGenerator,Generator)
-	_REF_TYPE_DECL(OT_STRING,SQString,String)
-	_REF_TYPE_DECL(OT_USERDATA,SQUserData,UserData)
-	_REF_TYPE_DECL(OT_WEAKREF,SQWeakRef,WeakRef)
-	_REF_TYPE_DECL(OT_THREAD,SQVM,Thread)
-	_REF_TYPE_DECL(OT_FUNCPROTO,SQFunctionProto,FunctionProto)
-
-	_SCALAR_TYPE_DECL(OT_INTEGER,SQInteger,n, Integer)
-	_SCALAR_TYPE_DECL(OT_FLOAT,SQFloat,f, Float)
-	_SCALAR_TYPE_DECL(OT_USERPOINTER,SQUserPointer,p, UserPointer)
-
-	SQObjectPtr(bool bBool)
-	{
-		SQ_OBJECT_RAWINIT()
-		_type = OT_BOOL;
-		_unVal.nInteger = bBool?1:0;
-	}
-	inline SQObjectPtr& operator=(bool b)
+	}
+struct SQObjectPtr : public SQObject
+{
+	SQObjectPtr()
+	{
+		SQ_OBJECT_RAWINIT()
+		_type=OT_NULL;
+		_unVal.pUserPointer=NULL;
+	}
+	SQObjectPtr(const SQObjectPtr &o)
+	{
+		_type = o._type;
+		_unVal = o._unVal;
+		__AddRef(_type,_unVal);
+	}
+	SQObjectPtr(const SQObject &o)
+	{
+		_type = o._type;
+		_unVal = o._unVal;
+		__AddRef(_type,_unVal);
+	}
+	_REF_TYPE_DECL(OT_TABLE,SQTable,Table)
+	_REF_TYPE_DECL(OT_CLASS,SQClass,Class)
+	_REF_TYPE_DECL(OT_INSTANCE,SQInstance,Instance)
+	_REF_TYPE_DECL(OT_ARRAY,SQArray,Array)
+	_REF_TYPE_DECL(OT_CLOSURE,SQClosure,Closure)
+	_REF_TYPE_DECL(OT_NATIVECLOSURE,SQNativeClosure,NativeClosure)
+	_REF_TYPE_DECL(OT_OUTER,SQOuter,Outer)
+	_REF_TYPE_DECL(OT_GENERATOR,SQGenerator,Generator)
+	_REF_TYPE_DECL(OT_STRING,SQString,String)
+	_REF_TYPE_DECL(OT_USERDATA,SQUserData,UserData)
+	_REF_TYPE_DECL(OT_WEAKREF,SQWeakRef,WeakRef)
+	_REF_TYPE_DECL(OT_THREAD,SQVM,Thread)
+	_REF_TYPE_DECL(OT_FUNCPROTO,SQFunctionProto,FunctionProto)
+
+	_SCALAR_TYPE_DECL(OT_INTEGER,SQInteger,n, Integer)
+	_SCALAR_TYPE_DECL(OT_FLOAT,SQFloat,f, Float)
+	_SCALAR_TYPE_DECL(OT_USERPOINTER,SQUserPointer,p, UserPointer)
+
+	SQObjectPtr(bool bBool)
+	{
+		SQ_OBJECT_RAWINIT()
+		_type = OT_BOOL;
+		_unVal.nInteger = bBool?1:0;
+	}
+	inline SQObjectPtr& operator=(bool b)
 	{
 		if(_type != OT_BOOL){
-			__Release(_type,_unVal);
-			SQ_OBJECT_RAWINIT()
+			__Release(_type,_unVal);
+			SQ_OBJECT_RAWINIT()
 			_type = OT_BOOL;
-		}
-		_unVal.nInteger = b?1:0;
-		return *this;
-	}
-
-	~SQObjectPtr()
-	{
-		__Release(_type,_unVal);
-	}
-
-	inline SQObjectPtr& operator=(const SQObjectPtr& obj)
+		}
+		_unVal.nInteger = b?1:0;
+		return *this;
+	}
+
+	~SQObjectPtr()
+	{
+		__Release(_type,_unVal);
+	}
+
+	inline SQObjectPtr& operator=(const SQObjectPtr& obj)
 	{
 		//saving temporarily the old value for cases
 		//where we are assigning a inner value to the old value
 		//local tbl = {a=2, b=4}; tbl = tbl.a;
 		SQObjectValue old_unVal;
 		bool isRefCounted = ISREFCOUNTED(_type);
-		if(isRefCounted) old_unVal = _unVal;
-		_unVal = obj._unVal;
-		_type = obj._type;
-		__AddRef(_type,_unVal);
+		if(isRefCounted) old_unVal = _unVal;
+		_unVal = obj._unVal;
+		_type = obj._type;
+		__AddRef(_type,_unVal);
 		if(isRefCounted) __ReleaseRefCounted(old_unVal);
-		return *this;
-	}
-	inline SQObjectPtr& operator=(const SQObject& obj)
+		return *this;
+	}
+	inline SQObjectPtr& operator=(const SQObject& obj)
 	{
 		SQObjectValue old_unVal;
 		bool isRefCounted = ISREFCOUNTED(_type);
-		if(isRefCounted) old_unVal = _unVal;
-		_unVal = obj._unVal;
-		_type = obj._type;
-		__AddRef(_type,_unVal);
+		if(isRefCounted) old_unVal = _unVal;
+		_unVal = obj._unVal;
+		_type = obj._type;
+		__AddRef(_type,_unVal);
 		if(isRefCounted) __ReleaseRefCounted(old_unVal);
-		return *this;
-	}
+		return *this;
+	}
 
-	inline void Null()
+	inline void Null()
 	{
 		if(_type != OT_NULL){
 			__Release(_type,_unVal);
-			_type = OT_NULL;
-			_unVal.raw = (SQRawObjectVal)NULL;
-		}
-	}
-	private:
-		SQObjectPtr(const SQChar *){} //safety
-};
-
-
-inline void _Swap(SQObject &a,SQObject &b)
-{
-	SQObjectType tOldType = a._type;
-	SQObjectValue unOldVal = a._unVal;
-	a._type = b._type;
-	a._unVal = b._unVal;
-	b._type = tOldType;
-	b._unVal = unOldVal;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////
-#ifndef NO_GARBAGE_COLLECTOR
-#define MARK_FLAG 0x80000000
-struct SQCollectable : public SQRefCounted {
-	SQCollectable *_next;
-	SQCollectable *_prev;
-	SQSharedState *_sharedstate;
-	virtual SQObjectType GetType()=0;
-	virtual void Release()=0;
-	virtual void Mark(SQCollectable **chain)=0;
-	void UnMark();
-	virtual void Finalize()=0;
-	static void AddToChain(SQCollectable **chain,SQCollectable *c);
-	static void RemoveFromChain(SQCollectable **chain,SQCollectable *c);
-};
-
-
-#define ADD_TO_CHAIN(chain,obj) AddToChain(chain,obj)
-#define REMOVE_FROM_CHAIN(chain,obj) {if(!(_uiRef&MARK_FLAG))RemoveFromChain(chain,obj);}
-#define CHAINABLE_OBJ SQCollectable
-#define INIT_CHAIN() {_next=NULL;_prev=NULL;_sharedstate=ss;}
-#else
-
-#define ADD_TO_CHAIN(chain,obj) ((void)0)
-#define REMOVE_FROM_CHAIN(chain,obj) ((void)0)
-#define CHAINABLE_OBJ SQRefCounted
-#define INIT_CHAIN() ((void)0)
-#endif
-
-struct SQDelegable : public CHAINABLE_OBJ {
-	bool SetDelegate(SQTable *m);
-	virtual bool GetMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res);
-	SQTable *_delegate;
-};
-
-SQUnsignedInteger SQTranslateIndex(const SQObjectPtr &idx);
-typedef sqvector<SQObjectPtr> SQObjectPtrVec;
-typedef sqvector<SQInteger> SQIntVec;
-const SQChar *GetTypeName(const SQObjectPtr &obj1);
-const SQChar *IdType2Name(SQObjectType type);
-
+			_type = OT_NULL;
+			_unVal.raw = (SQRawObjectVal)NULL;
+		}
+	}
+	inline bool isNull()
+	{
+		return _type == OT_NULL;
+	}
+	private:
+		SQObjectPtr(const SQChar *){} //safety
+};
+
+
+inline void _Swap(SQObject &a,SQObject &b)
+{
+	SQObjectType tOldType = a._type;
+	SQObjectValue unOldVal = a._unVal;
+	a._type = b._type;
+	a._unVal = b._unVal;
+	b._type = tOldType;
+	b._unVal = unOldVal;
+}
+
+/////////////////////////////////////////////////////////////////////////////////////
+#ifndef NO_GARBAGE_COLLECTOR
+#define MARK_FLAG 0x80000000
+struct SQCollectable : public SQRefCounted {
+	SQCollectable *_next;
+	SQCollectable *_prev;
+	SQSharedState *_sharedstate;
+	virtual SQObjectType GetType()=0;
+	virtual void Release()=0;
+	virtual void Mark(SQCollectable **chain)=0;
+	void UnMark();
+	virtual void Finalize()=0;
+	static void AddToChain(SQCollectable **chain,SQCollectable *c);
+	static void RemoveFromChain(SQCollectable **chain,SQCollectable *c);
+};
+
+
+#define ADD_TO_CHAIN(chain,obj) AddToChain(chain,obj)
+#define REMOVE_FROM_CHAIN(chain,obj) {if(!(_uiRef&MARK_FLAG))RemoveFromChain(chain,obj);}
+#define CHAINABLE_OBJ SQCollectable
+#define INIT_CHAIN() {_next=NULL;_prev=NULL;_sharedstate=ss;}
+#else
+
+#define ADD_TO_CHAIN(chain,obj) ((void)0)
+#define REMOVE_FROM_CHAIN(chain,obj) ((void)0)
+#define CHAINABLE_OBJ SQRefCounted
+#define INIT_CHAIN() ((void)0)
+#endif
+
+struct SQDelegable : public CHAINABLE_OBJ {
+	bool SetDelegate(SQTable *m);
+	virtual bool GetMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res);
+	SQTable *_delegate;
+};
+
+SQUnsignedInteger SQTranslateIndex(const SQObjectPtr &idx);
+typedef sqvector<SQObjectPtr> SQObjectPtrVec;
+typedef sqvector<SQInteger> SQIntVec;
+const SQChar *GetTypeName(const SQObjectPtr &obj1);
+const SQChar *IdType2Name(SQObjectType type);
+
 const SQChar *SQGetOpName(int op_code);
 const SQChar *SQGetArithOpName(int it);
 const SQChar *SQGetNewObjTypeName(int it);
 const SQChar *SQGetArrayAppendTypeName(int it);
 const SQChar *SQGetCmpOpName(int it);
-const SQChar *SQGetBitwiseOpName(int it);
-
-#endif //_SQOBJECT_H_
+const SQChar *SQGetBitwiseOpName(int it);
+
+#endif //_SQOBJECT_H_

SquiLu/squirrel/sqopcodes.h

@@ -1,40 +1,40 @@
-/*	see copyright notice in squirrel.h */
-#ifndef _SQOPCODES_H_
-#define _SQOPCODES_H_
-
-#define MAX_FUNC_STACKSIZE 0xFF
-#define MAX_LITERALS ((SQInteger)0x7FFFFFFF)
-
-enum BitWiseOP {
-	BW_AND = 0,
-	BW_OR = 2,
-	BW_XOR = 3,
-	BW_SHIFTL = 4,
-	BW_SHIFTR = 5,
-	BW_USHIFTR = 6
-};
-
-enum CmpOP {
-	CMP_G = 0,
-	CMP_GE = 2,
-	CMP_L = 3,
-	CMP_LE = 4,
-	CMP_3W = 5
-};
-
-enum NewObjectType {
-	NOT_TABLE = 0,
-	NOT_ARRAY = 1,
-	NOT_CLASS = 2
-};
-
-enum AppendArrayType {
-	AAT_STACK = 0,
-	AAT_LITERAL = 1,
-	AAT_INT = 2,
-	AAT_FLOAT = 3,
-	AAT_BOOL = 4
-};
+/*	see copyright notice in squirrel.h */
+#ifndef _SQOPCODES_H_
+#define _SQOPCODES_H_
+
+#define MAX_FUNC_STACKSIZE 0xFF
+#define MAX_LITERALS ((SQInteger)0x7FFFFFFF)
+
+enum BitWiseOP {
+	BW_AND = 0,
+	BW_OR = 2,
+	BW_XOR = 3,
+	BW_SHIFTL = 4,
+	BW_SHIFTR = 5,
+	BW_USHIFTR = 6
+};
+
+enum CmpOP {
+	CMP_G = 0,
+	CMP_GE = 2,
+	CMP_L = 3,
+	CMP_LE = 4,
+	CMP_3W = 5
+};
+
+enum NewObjectType {
+	NOT_TABLE = 0,
+	NOT_ARRAY = 1,
+	NOT_CLASS = 2
+};
+
+enum AppendArrayType {
+	AAT_STACK = 0,
+	AAT_LITERAL = 1,
+	AAT_INT = 2,
+	AAT_FLOAT = 3,
+	AAT_BOOL = 4
+};
 
 #define SQ_OP_CODE_LIST() \
 	ENUM_OP(_OP_LINE, 0x00)\
@@ -103,39 +103,39 @@ enum AppendArrayType {
 	ENUM_OP(_OP__LAST__, 0x3F)
 
 //#define ENUM_OP(a,b) a = b,
-//there is no point right now to manually number the opcodes
-#define ENUM_OP(a,b) a,
-enum SQOpcode
+//there is no point right now to manually number the opcodes
+#define ENUM_OP(a,b) a,
+enum SQOpcode
 {
-    SQ_OP_CODE_LIST()
+    SQ_OP_CODE_LIST()
 };
-#undef ENUM_OP
-
-struct SQInstructionDesc {
-	const SQChar *name;
-};
-
-struct SQInstruction
-{
-	SQInstruction(){};
-	SQInstruction(SQOpcode _op,SQInteger a0=0,SQInteger a1=0,SQInteger a2=0,SQInteger a3=0)
-	{	op = (unsigned char)_op;
-		_arg0 = (unsigned char)a0;_arg1 = (SQInt32)a1;
-		_arg2 = (unsigned char)a2;_arg3 = (unsigned char)a3;
-	}
-
-
-	SQInt32 _arg1;
-	unsigned char op;
-	unsigned char _arg0;
-	unsigned char _arg2;
-	unsigned char _arg3;
-};
-
-#include "squtils.h"
-typedef sqvector<SQInstruction> SQInstructionVec;
-
-#define NEW_SLOT_ATTRIBUTES_FLAG	0x01
-#define NEW_SLOT_STATIC_FLAG		0x02
-
-#endif // _SQOPCODES_H_
+#undef ENUM_OP
+
+struct SQInstructionDesc {
+	const SQChar *name;
+};
+
+struct SQInstruction
+{
+	SQInstruction(){};
+	SQInstruction(SQOpcode _op,SQInteger a0=0,SQInteger a1=0,SQInteger a2=0,SQInteger a3=0)
+	{	op = (unsigned char)_op;
+		_arg0 = (unsigned char)a0;_arg1 = (SQInt32)a1;
+		_arg2 = (unsigned char)a2;_arg3 = (unsigned char)a3;
+	}
+
+
+	SQInt32 _arg1;
+	unsigned char op;
+	unsigned char _arg0;
+	unsigned char _arg2;
+	unsigned char _arg3;
+};
+
+#include "squtils.h"
+typedef sqvector<SQInstruction> SQInstructionVec;
+
+#define NEW_SLOT_ATTRIBUTES_FLAG	0x01
+#define NEW_SLOT_STATIC_FLAG		0x02
+
+#endif // _SQOPCODES_H_

SquiLu/squirrel/sqpcheader.h

@@ -1,10 +1,10 @@
-/*	see copyright notice in squirrel.h */
+/*  see copyright notice in squirrel.h */
 #ifndef _SQPCHEADER_H_
 #define _SQPCHEADER_H_
 
 #if defined(_MSC_VER) && defined(_DEBUG)
 #include <crtdbg.h>
-#endif 
+#endif
 
 #include <limits.h>
 #include <stdio.h>

SquiLu/squirrel/sqstate.cpp

@@ -25,6 +25,8 @@ SQSharedState::SQSharedState()
 	_errorfunc = NULL;
 	_debuginfo = false;
 	_notifyallexceptions = false;
+    _foreignptr = NULL;
+    _releasehook = NULL;
 #ifdef SQ_WITH_DELAYED_RELEASE_HOOKS
 	_already_in_CallDelayedReleaseHooks = false;
 #endif // SQ_WITH_DELAYED_RELEASE_HOOKS
@@ -85,7 +87,7 @@ bool CompileTypemask(SQIntVec &res,const SQChar *typemask)
 	return true;
 }
 
-SQTable *CreateDefaultDelegate(SQSharedState *ss,SQRegFunction *funcz)
+SQTable *CreateDefaultDelegate(SQSharedState *ss,const SQRegFunction *funcz)
 {
 	SQInteger i=0;
 	SQTable *t=SQTable::Create(ss,0);
@@ -170,6 +172,7 @@ void SQSharedState::Init()
 
 SQSharedState::~SQSharedState()
 {
+    if(_releasehook) { _releasehook(_foreignptr,0,0); _releasehook = NULL; }
 	_constructoridx.Null();
 	_destructoridx.Null();
 	_table(_registry)->Finalize();
@@ -288,8 +291,7 @@ void SQSharedState::MarkObject(SQObjectPtr &o,SQCollectable **chain)
 	}
 }
 
-
-void SQSharedState::RunMark(SQVM */*vm*/,SQCollectable **tchain)
+void SQSharedState::RunMark(SQVM SQ_UNUSED_ARG(*vm),SQCollectable **tchain)
 {
 	SQVM *vms = _thread(_root_vm);
 

SquiLu/squirrel/sqstate.h

@@ -128,13 +128,15 @@ public:
 	SQPRINTFUNCTION _errorfunc;
 	bool _debuginfo;
 	bool _notifyallexceptions;
+    SQUserPointer _foreignptr;
+    SQRELEASEHOOK _releasehook;
 private:
+	SQChar *_scratchpad;
+	SQInteger _scratchpadsize;
 #ifdef SQ_WITH_DELAYED_RELEASE_HOOKS
     bool _already_in_CallDelayedReleaseHooks;
     sqvector<SQDelayedReleseHook> _delayed_release_hook;
 #endif // SQ_WITH_DELAYED_RELEASE_HOOKS
-	SQChar *_scratchpad;
-	SQInteger _scratchpadsize;
 };
 
 #define _sp(s) (_sharedstate->GetScratchPad(s))

SquiLu/squirrel/squserdata.h

@@ -1,46 +1,46 @@
-/*	see copyright notice in squirrel.h */
-#ifndef _SQUSERDATA_H_
-#define _SQUSERDATA_H_
-
-struct SQUserData : SQDelegable
-{
-	SQUserData(SQSharedState *ss){ _delegate = 0; _hook = NULL; INIT_CHAIN(); ADD_TO_CHAIN(&_ss(this)->_gc_chain, this); }
-	~SQUserData()
-	{
-		REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain, this);
-		SetDelegate(NULL);
-	}
-	static SQUserData* Create(SQSharedState *ss, SQInteger size)
-	{
-		SQUserData* ud = (SQUserData*)SQ_MALLOC(sq_aligning(sizeof(SQUserData))+size);
-		new (ud) SQUserData(ss);
-		ud->_size = size;
-		ud->_typetag = 0;
-		return ud;
-	}
-#ifndef NO_GARBAGE_COLLECTOR
-	void Mark(SQCollectable **chain);
-	void Finalize(){SetDelegate(NULL);}
-	SQObjectType GetType(){ return OT_USERDATA;}
-#endif
-	void Release() {
+/*	see copyright notice in squirrel.h */
+#ifndef _SQUSERDATA_H_
+#define _SQUSERDATA_H_
+
+struct SQUserData : SQDelegable
+{
+	SQUserData(SQSharedState *ss){ _delegate = 0; _hook = NULL; INIT_CHAIN(); ADD_TO_CHAIN(&_ss(this)->_gc_chain, this); }
+	~SQUserData()
+	{
+		REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain, this);
+		SetDelegate(NULL);
+	}
+	static SQUserData* Create(SQSharedState *ss, SQInteger size)
+	{
+		SQUserData* ud = (SQUserData*)SQ_MALLOC(sq_aligning(sizeof(SQUserData))+size);
+		new (ud) SQUserData(ss);
+		ud->_size = size;
+		ud->_typetag = 0;
+		return ud;
+	}
+#ifndef NO_GARBAGE_COLLECTOR
+	void Mark(SQCollectable **chain);
+	void Finalize(){SetDelegate(NULL);}
+	SQObjectType GetType(){ return OT_USERDATA;}
+#endif
+	void Release() {
 		if (_hook) {
-#if !defined(NO_GARBAGE_COLLECTOR) && defined(SQ_WITH_DELAYED_RELEASE_HOOKS)
+#if !defined(NO_GARBAGE_COLLECTOR) && defined(SQ_WITH_DELAYED_RELEASE_HOOKS)
 		    _sharedstate->AddDelayedReleaseHook(_hook, (SQUserPointer)sq_aligning(this + 1), _size);
 #else
 		    _hook((SQUserPointer)sq_aligning(this + 1),_size, 0);
-#endif
-		}
-		SQInteger tsize = _size;
-		this->~SQUserData();
-		SQ_FREE(this, sq_aligning(sizeof(SQUserData)) + tsize);
-	}
-
-
-	SQInteger _size;
-	SQRELEASEHOOK _hook;
-	SQUserPointer _typetag;
-	//SQChar _val[1];
-};
-
-#endif //_SQUSERDATA_H_
+#endif
+		}
+		SQInteger tsize = _size;
+		this->~SQUserData();
+		SQ_FREE(this, sq_aligning(sizeof(SQUserData)) + tsize);
+	}
+
+
+	SQInteger _size;
+	SQRELEASEHOOK _hook;
+	SQUserPointer _typetag;
+	//SQChar _val[1];
+};
+
+#endif //_SQUSERDATA_H_

SquiLu/squirrel/squtils.h

@@ -1,123 +1,123 @@
-/*	see copyright notice in squirrel.h */
-#ifndef _SQUTILS_H_
-#define _SQUTILS_H_
-
-void *sq_vm_malloc(SQUnsignedInteger size);
-void *sq_vm_realloc(void *p,SQUnsignedInteger oldsize,SQUnsignedInteger size);
-void sq_vm_free(void *p,SQUnsignedInteger size);
-
-#define sq_new(__ptr,__type) {__ptr=(__type *)sq_vm_malloc(sizeof(__type));new (__ptr) __type;}
-#define sq_delete(__ptr,__type) {__ptr->~__type();sq_vm_free(__ptr,sizeof(__type));}
-#define SQ_MALLOC(__size) sq_vm_malloc((__size));
-#define SQ_FREE(__ptr,__size) sq_vm_free((__ptr),(__size));
-#define SQ_REALLOC(__ptr,__oldsize,__size) sq_vm_realloc((__ptr),(__oldsize),(__size));
-
-#define sq_aligning(v) (((size_t)(v) + (SQ_ALIGNMENT-1)) & (~(SQ_ALIGNMENT-1)))
-
-//sqvector mini vector class, supports objects by value
-template<typename T> class sqvector
-{
-public:
-	sqvector():_vals(NULL),_size(0),_allocated(0)
-	{
-	}
-	sqvector(const sqvector<T>& v)
-	{
-		copy(v);
-	}
-	void copy(const sqvector<T>& v)
-	{
-		if(_size) {
-			resize(0); //destroys all previous stuff
-		}
-		//resize(v._size);
-		if(v._size > _allocated) {
-			_realloc(v._size);
-		}
-		for(SQUnsignedInteger i = 0; i < v._size; i++) {
-			new ((void *)&_vals[i]) T(v._vals[i]);
-		}
-		_size = v._size;
-	}
-	~sqvector()
-	{
-		if(_allocated) {
-			for(SQUnsignedInteger i = 0; i < _size; i++)
-				_vals[i].~T();
-			SQ_FREE(_vals, (_allocated * sizeof(T)));
-		}
-	}
-	void reserve(SQUnsignedInteger newsize) { _realloc(newsize); }
-	void resize(SQUnsignedInteger newsize, const T& fill = T())
-	{
-		if(newsize > _allocated)
-			_realloc(newsize);
-		if(newsize > _size) {
-			while(_size < newsize) {
-				new ((void *)&_vals[_size]) T(fill);
-				_size++;
-			}
-		}
-		else{
-			for(SQUnsignedInteger i = newsize; i < _size; i++) {
-				_vals[i].~T();
-			}
-			_size = newsize;
-		}
-	}
-	void shrinktofit() { if(_size > 4) { _realloc(_size); } }
-	T& top() const { return _vals[_size - 1]; }
-	inline SQUnsignedInteger size() const { return _size; }
-	bool empty() const { return (_size <= 0); }
-	inline T &push_back(const T& val = T())
-	{
-		if(_allocated <= _size)
-			_realloc(_size * 2);
-		return *(new ((void *)&_vals[_size++]) T(val));
-	}
-	inline void pop_back()
-	{
-		_size--; _vals[_size].~T();
-	}
-	void insert(SQUnsignedInteger idx, const T& val)
-	{
-		resize(_size + 1);
-		for(SQUnsignedInteger i = _size - 1; i > idx; i--) {
-			_vals[i] = _vals[i - 1];
-		}
-    	_vals[idx] = val;
-	}
-	void remove(SQUnsignedInteger idx)
-	{
-		_vals[idx].~T();
-		if(idx < (_size - 1)) {
-			memmove(&_vals[idx], &_vals[idx+1], sizeof(T) * (_size - idx - 1));
-		}
-		_size--;
-	}
-	void removeFromBegining(SQUnsignedInteger count)
+/*	see copyright notice in squirrel.h */
+#ifndef _SQUTILS_H_
+#define _SQUTILS_H_
+
+void *sq_vm_malloc(SQUnsignedInteger size);
+void *sq_vm_realloc(void *p,SQUnsignedInteger oldsize,SQUnsignedInteger size);
+void sq_vm_free(void *p,SQUnsignedInteger size);
+
+#define sq_new(__ptr,__type) {__ptr=(__type *)sq_vm_malloc(sizeof(__type));new (__ptr) __type;}
+#define sq_delete(__ptr,__type) {__ptr->~__type();sq_vm_free(__ptr,sizeof(__type));}
+#define SQ_MALLOC(__size) sq_vm_malloc((__size));
+#define SQ_FREE(__ptr,__size) sq_vm_free((__ptr),(__size));
+#define SQ_REALLOC(__ptr,__oldsize,__size) sq_vm_realloc((__ptr),(__oldsize),(__size));
+
+#define sq_aligning(v) (((size_t)(v) + (SQ_ALIGNMENT-1)) & (~(SQ_ALIGNMENT-1)))
+
+//sqvector mini vector class, supports objects by value
+template<typename T> class sqvector
+{
+public:
+	sqvector():_vals(NULL),_size(0),_allocated(0)
+	{
+	}
+	sqvector(const sqvector<T>& v)
+	{
+		copy(v);
+	}
+	void copy(const sqvector<T>& v)
+	{
+		if(_size) {
+			resize(0); //destroys all previous stuff
+		}
+		//resize(v._size);
+		if(v._size > _allocated) {
+			_realloc(v._size);
+		}
+		for(SQUnsignedInteger i = 0; i < v._size; i++) {
+			new ((void *)&_vals[i]) T(v._vals[i]);
+		}
+		_size = v._size;
+	}
+	~sqvector()
+	{
+		if(_allocated) {
+			for(SQUnsignedInteger i = 0; i < _size; i++)
+				_vals[i].~T();
+			SQ_FREE(_vals, (_allocated * sizeof(T)));
+		}
+	}
+	void reserve(SQUnsignedInteger newsize) { _realloc(newsize); }
+	void resize(SQUnsignedInteger newsize, const T& fill = T())
+	{
+		if(newsize > _allocated)
+			_realloc(newsize);
+		if(newsize > _size) {
+			while(_size < newsize) {
+				new ((void *)&_vals[_size]) T(fill);
+				_size++;
+			}
+		}
+		else{
+			for(SQUnsignedInteger i = newsize; i < _size; i++) {
+				_vals[i].~T();
+			}
+			_size = newsize;
+		}
+	}
+	void shrinktofit() { if(_size > 4) { _realloc(_size); } }
+	T& top() const { return _vals[_size - 1]; }
+	inline SQUnsignedInteger size() const { return _size; }
+	bool empty() const { return (_size <= 0); }
+	inline T &push_back(const T& val = T())
+	{
+		if(_allocated <= _size)
+			_realloc(_size * 2);
+		return *(new ((void *)&_vals[_size++]) T(val));
+	}
+	inline void pop_back()
+	{
+		_size--; _vals[_size].~T();
+	}
+	void insert(SQUnsignedInteger idx, const T& val)
+	{
+		resize(_size + 1);
+		for(SQUnsignedInteger i = _size - 1; i > idx; i--) {
+			_vals[i] = _vals[i - 1];
+		}
+    	_vals[idx] = val;
+	}
+	void remove(SQUnsignedInteger idx)
+	{
+		_vals[idx].~T();
+		if(idx < (_size - 1)) {
+			memmove(&_vals[idx], &_vals[idx+1], sizeof(T) * (_size - idx - 1));
+		}
+		_size--;
+	}
+	void removeFromBegining(SQUnsignedInteger count)
 	{
 	    if(count <= _size){
-	        for(SQUnsignedInteger i=0; i < count; ++i) _vals[i].~T();
-            if(count < (_size - 1)) {
-                memmove(&_vals[0], &_vals[count], sizeof(T) * (_size - count));
-            }
-            _size -= count;
-	    }
-	}
-	SQUnsignedInteger capacity() { return _allocated; }
-	inline T &back() const { return _vals[_size - 1]; }
-	inline T& operator[](SQUnsignedInteger pos) const{ return _vals[pos]; }
-	T* _vals;
-private:
-	void _realloc(SQUnsignedInteger newsize)
-	{
-		newsize = (newsize > 0)?newsize:4;
-		_vals = (T*)SQ_REALLOC(_vals, _allocated * sizeof(T), newsize * sizeof(T));
-		_allocated = newsize;
-	}
-	SQUnsignedInteger _size;
-	SQUnsignedInteger _allocated;
+	        for(SQUnsignedInteger i=0; i < count; ++i) _vals[i].~T();
+            if(count < (_size - 1)) {
+                memmove(&_vals[0], &_vals[count], sizeof(T) * (_size - count));
+            }
+            _size -= count;
+	    }
+	}
+	SQUnsignedInteger capacity() { return _allocated; }
+	inline T &back() const { return _vals[_size - 1]; }
+	inline T& operator[](SQUnsignedInteger pos) const{ return _vals[pos]; }
+	T* _vals;
+private:
+	void _realloc(SQUnsignedInteger newsize)
+	{
+		newsize = (newsize > 0)?newsize:4;
+		_vals = (T*)SQ_REALLOC(_vals, _allocated * sizeof(T), newsize * sizeof(T));
+		_allocated = newsize;
+	}
+	SQUnsignedInteger _size;
+	SQUnsignedInteger _allocated;
 };
 
 class SQCharBuf : public sqvector<char>
@@ -130,6 +130,6 @@ public:
         memcpy(_vals+old_size, p, count);
     }
     const char *data(){return _vals;}
-};
-
-#endif //_SQUTILS_H_
+};
+
+#endif //_SQUTILS_H_

SquiLu/squirrel/sqvm.cpp

@@ -140,8 +140,11 @@ SQVM::SQVM(SQSharedState *ss)
 	_debughook_closure.Null();
 	_openouters = NULL;
 	ci = NULL;
+    _releasehook = NULL;
 	INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);
+#ifdef SQ_WITH_DELAYED_RELEASE_HOOKS
 	_check_delayed_relase_hooks = true;
+#endif
 #ifdef PROFILE_SQVM
 	printf("SQVM::SQVM : %p\n", this);
 	_op_profile_timer.start();
@@ -159,6 +162,8 @@ void SQVM::Finalize()
     CallAtExitHandler();
 #ifdef SQ_WITH_DELAYED_RELEASE_HOOKS
     _sharedstate->CallDelayedReleaseHooks(this);
+#else
+    if(_releasehook) { _releasehook(_foreignptr,0,0); _releasehook = NULL; }
 #endif
 	if(_openouters) CloseOuters(&_stack._vals[0]);
 	_roottable.Null();
@@ -536,12 +541,12 @@ bool SQVM::DerefInc(SQInteger op,SQObjectPtr &target, SQObjectPtr &self, SQObjec
 }
 
 #define arg0 (_i_._arg0)
-#define sarg0 ((SQInteger)*((signed char *)&_i_._arg0))
+#define sarg0 ((SQInteger)*((const signed char *)&_i_._arg0))
 #define arg1 (_i_._arg1)
-#define sarg1 (*((SQInt32 *)&_i_._arg1))
+#define sarg1 (*((const SQInt32 *)&_i_._arg1))
 #define arg2 (_i_._arg2)
 #define arg3 (_i_._arg3)
-#define sarg3 ((SQInteger)*((signed char *)&_i_._arg3))
+#define sarg3 ((SQInteger)*((const signed char *)&_i_._arg3))
 
 SQRESULT SQVM::Suspend()
 {
@@ -555,7 +560,7 @@ SQRESULT SQVM::Suspend()
 
 #define _FINISH(howmuchtojump) {jump = howmuchtojump; return true; }
 bool SQVM::FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr
-&o3,SQObjectPtr &o4,SQInteger /*arg_2*/,int exitpos,int &jump)
+&o3,SQObjectPtr &o4,SQInteger SQ_UNUSED_ARG(arg_2),int exitpos,int &jump)
 {
 	SQInteger nrefidx;
 	switch(type(o1)) {

SquiLu/squirrel/sqvm.h

@@ -188,12 +188,15 @@ public:
 	SQSharedState *_sharedstate;
 	SQInteger _nnativecalls;
 	SQInteger _nmetamethodscall;
+    SQRELEASEHOOK _releasehook;
 	//suspend infos
 	SQBool _suspended;
 	SQBool _suspended_root;
-	SQBool _check_delayed_relase_hooks;
 	SQInteger _suspended_target;
 	SQInteger _suspended_traps;
+#ifdef SQ_WITH_DELAYED_RELEASE_HOOKS
+	SQBool _check_delayed_relase_hooks;
+#endif
 #ifdef PROFILE_SQVM
 	OpProfileVec _op_profile;
 	HighResolutionTimer _op_profile_timer;