(svn r15578) -Change: unexternalise squirrel.

15 years ago · 1ad50ce4e6
parent 66a8c0a132
commit 1ad50ce4e6
81 changed files with 14906 additions and 0 deletions
--- a/readme.txt
+++ b/readme.txt
@ -498,6 +498,7 @@ Thanks to:
  Cian Duffy (MYOB)              - BeOS port / manual writing
  Christian Rosentreter (tokai)  - MorphOS / AmigaOS port
  Richard Kempton (RichK67)      - Additional airports, initial TGP implementation
+  Alberto Demichelis             - Squirrel scripting language
  Michael Blunck                 - For revolutionizing TTD with awesome graphics
  George                         - Canal graphics
  David Dallaston (Pikka)        - Tram tracks
--- a/src/3rdparty/squirrel/COMPILE
+++ b/src/3rdparty/squirrel/COMPILE
@ -0,0 +1,41 @@
+Squirrel 2.2.1 stable
+--------------------------------------------------------
+What is in this distribution?
+
+squirrel
+	static library implementing the compiler and interpreter of the language
+
+sqstdlib
+	the standard utility libraries
+
+sq
+	stand alone interpreter
+
+doc
+	The manual
+
+etc
+	a minimalistic embedding sample
+
+samples
+	samples programs
+
+
+HOW TO COMPILE
+---------------------------------------------------------
+GCC USERS
+.........................................................
+There is a very simple makefile that compiles all libraries and exes
+from the root of the project run 'make'
+
+for 32 bits systems
+
+ $ make
+
+for 64 bits systems
+
+ $ make sq64
+
+VISUAL C++ USERS
+.........................................................
+Open squirrel.dsw from the root project directory and build(dho!)
--- a/src/3rdparty/squirrel/COPYRIGHT
+++ b/src/3rdparty/squirrel/COPYRIGHT
@ -0,0 +1,29 @@
+Copyright (c) 2003-2008 Alberto Demichelis
+
+This software is provided 'as-is', without any
+express or implied warranty. In no event will the
+authors be held liable for any damages arising from
+the use of this software.
+
+Permission is granted to anyone to use this software
+for any purpose, including commercial applications,
+and to alter it and redistribute it freely, subject
+to the following restrictions:
+
+		1. The origin of this software must not be
+		misrepresented; you must not claim that
+		you wrote the original software. If you
+		use this software in a product, an
+		acknowledgment in the product
+		documentation would be appreciated but is
+		not required.
+
+		2. Altered source versions must be plainly
+		marked as such, and must not be
+		misrepresented as being the original
+		software.
+
+		3. This notice may not be removed or
+		altered from any source distribution.
+-----------------------------------------------------
+END OF COPYRIGHT
--- a/src/3rdparty/squirrel/HISTORY
+++ b/src/3rdparty/squirrel/HISTORY
@ -0,0 +1,327 @@
+***version 2.2.2 stable***
+-fixed some behaviour inconsistencies in thread.call() and thread.wakeup() (thx Mr.Accident)
+-fixed coroutine error propagation
+-fixed lingering return value from native function (thx Tom Leonard)
+-fixed a bug if array.sort() is given a bad sort function (thx Tom Leonard)
+-fixed some minor api bug
+-added sq_arrayremove() and sq_arrayinsert()
+
+***2008-05-16          ***
+***version 2.2.1 stable***
+-fixed a tailcall bug
+
+***2008-02-17          ***
+***version 2.2 stable  ***
+-added _newslot metamethod in classes
+-added enums added constants
+-added sq_pushconsttable, sq_setconsttable
+-added default param
+-added octal literals(thx Dinosaur)
+-fixed debug hook, 'calls' and 'returns' are properly notified in the same number.
+-fixed a coroutine bug
+
+***2007-07-29          ***
+***version 2.1.2 stable***
+-new behaviour for generators iteration using foreach
+now when a generator is iterated by foreach the value returned by a 'return val' statement
+will terminate the iteration but will not be returned as foreach iteration
+-added sq_setclassudsize()
+-added sq_clear()
+-added table.clear(), array.clear()
+-fixed sq_cmp() (thx jyuill)
+-fixed minor bugs
+
+***2006-08-21	     ***
+***version 2.1.1 stable***
+-vm refactoring
+-optimized internal function memory layout
+-new global symbol _version_ (is the version string)
+-code size optimization for float literals(on 32bits float builts)
+-now the raw ref API(sq_addref etc...) is fully reentrant.
+-fixed a bug in sq_getdelegate() now pushes null if the object doesn't have a delegate(thx MatzeB)
+-improved C reference performances in NO_GARBAGE_COLLECTOR builds
+-sq_getlocal() now enumerates also outer values.
+-fixed regexp library for GCC users.
+
+***2006-03-19	     ***
+***version 2.1 stable***
+-added static class fields, new keyword static
+-added 64bits architecture support
+-added global slot _intsize_ int the base lib to recognize 32bits and 64bits builds
+-added functions with fixed environment, closure.bindenv() built-in function
+-all types except userdata and null implement the tostring() method
+-string concatenation now invokes metamethod _tostring
+-new metamethods for class objects _newmember and _inherited
+-sq_call() sq_resume() sq_wakeupvm() have a new signature
+-new C referencing implementation(scales more with the amount of references)
+-refactored hash table
+-new api functions sq_newslot(),sq_tobool(),sq_getbase(), sq_instanceof(), sq_bindenv()
+-the api func sq_createslot was deprecated but still supported in form of C macro on top of sq_newslot
+-sq_setreleasehook() now also works for classes
+-stream.readstr() and stream.writestr() have been deprecated(this affects file and blob)
+-fixed squirrel.h undeclared api calls
+-fixed few minor bugs
+-SQChar is now defined as wchar_t
+-removed warning when building with -Wall -pedantic for GCC users
+-added new std io function writeclosuretofile()
+-added new std string functions strip(),rstrip(),lstrip() and split()
+-regular expressions operators (+,*) now have more POSIX greedyness behaviour
+-class constructors are now invoked as normal functions
+
+***2005-10-02	       ***
+***version 2.0.5 stable***
+-fixed some 64bits incompatibilities (thx sarge)
+-fixed minor bug in the stdlib format() function (thx Rick)
+-fixed a bug in dofile() that was preventing to compile empty files
+-added new API sq_poptop() & sq_getfreevariable()
+-some performance improvements
+
+***2005-08-14	       ***
+***version 2.0.4 stable***
+-weak references and related API calls
+-added sq_objtobool()
+-class instances memory policies improved(1 mem allocation for the whole instance)
+-typetags are now declared as SQUserPointer instead of unsigned int
+-first pass for 64bits compatibility
+-fixed minor bug in the stdio stream
+-fixed a bug in format()
+-fixed bug in string.tointeger() and string.tofloat()
+
+***2005-06-24	       ***
+***version 2.0.3 stable***
+-dofile() and loadfile() in the iolib now can decode ASCII, UTF8 files UCS2 big-endian and little-endian
+-sq_setparamscheck() : now typemesk can check for null
+-added string escape sequence \xhhhh
+-fixed some C++ standard incompatibilities
+
+***2005-05-15	       ***
+***version 2.0.2 stable***
+-performances improvements (expecially for GCC users)
+-removed all dependencies from C++ exception handling
+-various bugfixes
+
+***2005-04-12		 ***
+***version 2.0.1 stable***
+-various bugfixes
+-sq_setparamscheck() now allows spaces in the typemask
+
+***2005-04-03		 ***
+***version 2.0 stable***
+-added API sq_gettypetag()
+-added built-in function to the bool type(tointeger, tostring etc...)
+
+***2005-02-27							***
+***version 2.0 release candidate 1(RC 1)***
+-added API sq_reseterror()
+-modified sq_release()
+-now class instances can be cloned
+-various bufixes
+
+***2005-01-26        ***
+***version 2.0 beta 1***
+-added bool type
+-class properties can be redefined in a derived class
+-added ops *= /= and %=
+-new syntax for class attributes declaration </ and /> instead of ( and )
+-increased the max number of literals per function from 65535 to 16777215
+-now free variables have proper lexical scoping
+-added API sq_createinstance(), sq_pushbool(), sq_getbool()
+-added built-in function type()
+-added built-in function obj.rawin(key) in table,class and instance
+-sq_rawget() and sq_rawset() now work also on classes and instances
+-the VM no longer uses C++ exception handling (more suitable for embedded devices)
+-various bufixes
+
+***2004-12-21         ***
+***version 2.0 alpha 2***
+-globals scoping changed, now if :: is omitted the VM automatically falls back on the root table
+-various bufixes
+-added class level attributes
+
+***2004-12-12         ***
+***version 2.0 alpha 1***
+-codebase branch from version 1.x
+-added classes
+-added functions with variable number of parameters(vargc & vargv and the ...)
+-0 and 0.0 are now considered 'false' by all conditional statements(if,while,for,?,do-while)
+-added new api functions sq_newclass() sq_setinstanceup() sq_getinstanceup() sq_getattributes() sq_setattributes()
+-modified api sq_settypetag()
+
+***2004-11-01        ***
+***version 1.0 stable***
+-fixed some minor bug
+-improoved operator 'delete' performances
+-added scientific notation for float numbers( eg. 2.e16 or 2.e-2)
+
+***2004-08-30        ***
+***version 1.0 release candidate 2(RC 2)***
+-fixed bug in the vm(thx Pierre Renaux)
+-fixed bug in the optimizer(thx Pierre Renaux)
+-fixed some bug in the documentation(thx JD)
+-added new api functions for raw object handling
+-removed nested multiline comments
+-reduced memory footprint in C references
+
+***2004-08-23        ***
+***version 1.0 release candidate 1(RC 1)***
+-fixed division by zero
+-the 'in' operator and obj.rawget() do not query the default delegate anymore
+-added function sq_getprintfunc()
+-added new standard library 'auxlib'(implements default error handlers)
+
+***2004-07-12        ***
+***version 1.0 beta 4***
+-fixed a bug in the integer.tochar() built-in method
+-fixed unary minus operator
+-fixed bug in dofile()
+-fixed inconsistency between != and == operators(on float/integer comparison)
+-added javascript style unsigned right shift operator '>>>'
+-added array(size) constructor built-in function
+-array.resize(size,[fill]) built-in function accepts an optional 'fill' value
+-improved debug API, added sq_getclosureinfo() and sq_setnativeclosurename()
+
+***2004-05-23        ***
+***version 1.0 beta 3***
+-minor vm bug fixes
+-string allocation is now faster
+-tables and array memory usage is now less conservative(they shrink)
+-added regular expression routines in the standard library
+-The 'c' expression now accepts only 1 character(thx irbrian)
+-multiline strings <[ ]> have been substituted with C# style verbatim strings (eg. @"string")
+-added new keyword 'parent' for accessing the delegate of tables and unserdata
+-The metamethod '_clone' has been renamed '_cloned'
+-the _delslot metamethod's behaviour and prototype have been changed
+-new default function in the integer and float object 'tochar()'
+-the built-in function chcode2string has been removed
+-the default method [table].getdelegate() has been removed
+-new api sq_rawdeleteslot()
+-new table built-in method rawdelete(key)
+-the dynamic mudule loading has been removed from the standard distribution
+-some optimizations in the VM
+
+***2004-04-21        ***
+***version 1.0 beta 2***
+-minor compiler/parser bug fixes
+-sq_newclosure has a different prototype, the "paramscheck" of paramter has been moved to the new function sq_setparamscheck()
+-sq_setparamscheck allows to add automatic parameters type checking in native closures
+-sq_compile() lost the lineinfo parameter
+-new api sq_enabledebuginfo() globally sets compiler's debug info generation
+-added consistency check on bytecode serialization
+-fixed += operator, now works on strings like +
+-added global slot in the base lib _charsize_ to recognize unicode builds from ascii builds runtime
+-added registry table
+-new api call sq_pushregistrytable()
+-added type tag to the userdata type sq_settypetag()
+-sq_getuserdata now queries the userdata typetag
+-the built in function collect_garbage() as been renamed collectgarbage() for consistency reasons
+-new standard libraries(sqlibs are now obsolete)
+
+***2004-02-20	     ***
+***version 1.0 beta 1***
+-fixed a bug in the compiler (thanks Martin Kofler)
+-fixed bug in the switch case statement
+-fixed the _unm metamethod
+-fixed minor bugs in the API
+-fixed automatic stack resizing
+-first beta version
+	first pass code clean up in the VM and base lib
+	first pass code coverege test has been done on VM and built-in lib
+-new VM creation API sq_open() sq_close() (sq_newvm and sq_releasevm are now obsolete)
+-new api allows to specifiy a "print" function to output text(sq_printfunc)
+-added some small optimizations
+-new cooperative multi-threading capabilities in the base library(coroutines), VMs are now a built in type("thread")
+-new built in functions have been added for manipulating the new "thread" type
+-friend virtual machines share the same root table, error handler and debug hook by default
+-new compile time options
+
+***2004-01-19       ***
+***version 0.9 alpha***
+-fixed a garbage collection bug
+-fixed some API bugs(thanks to Joshua Jensen)
+-fixed tail calls (in the version 0.8 the tail call optimization was erroneously disabled)
+-new function parameters semantic, now passing a wrong number of parameters generates an exception
+-native closures have now a built in parameter number checking
+-sq_rawget and sq_rawset now work also on arrays
+-sq_getsize now woks also on userdata
+-the userdata release hook prototype is changed(now passes the size of the userdata)
+-the lexer reader function now returns an integer instead of a char that allows better error checking on the input(thx Joshua Jensen)
+-faster compiler
+-try/catch blocks do not cause any runtime memory allocation anymore
+
+***2003-12-06       ***
+***version 0.8 alpha***
+-fixed a bug that was preventing to have callable userdata throught the metamethod _call
+-fixed a garbage collection bug
+-fixed == operator now can compare correctly different types
+-new built in method getstackinfos(level)
+-improoved line informations precision for the debug hook
+-new api call sq_compilebuffer()
+-new built-in api function compilestring()
+-new syntactic sugar for function declarations inside tables
+-the debug API has been finalized
+
+***2003-11-17       ***
+***version 0.7 alpha***
+-fixed critical bug SQInteger the tail call system
+-fixed bug in the continue statement code generation
+-fixed func call param issue(thanks to Rewoonenco Andrew)
+-added _delslot metamethod(thanks to Rewoonenco Andrew)
+-new multiline string expression ( delimited by <[ and ]> )
+-normal strings ("") do not allow embedded new line anymore
+-reduced vm memory footprint(C refs are shared between friend VMs)
+-new api method sq_deleteslot()
+-new debug hook event 'r' is triggered when a function returns
+
+***2003-11-04       ***
+***version 0.6 alpha***
+-fixed switch statement(was executing the default case after a break)
+-sq_call() doesn't pop the closure (just the params)
+-the vm execution can be suspended from the C API anytime (micro-threads)
+-new api calls sq_suspendvm() sq_wakeupvm() sq_getvmstate() and sq_reservestack()
+
+***2003-10-13       ***
+***version 0.5 alpha***
+-fixed some minor bug
+-tested with non ASCII identifiers in unicode mode(I've tried chinese chars)
+-added built-in function string.find()
+-the built-in function array.sort() optionally accepts a cmp(a,b) function
+-the debug hook function now has a new prototype debug_hook(event_type,sourcefile,line,functionname)
+-fixed some debug info imprecision
+
+***2003-10-01       ***
+***version 0.4 alpha***
+-faster VM
+-sq_call will pop arguments and closure also in case of failure
+-fixed a bug in sq_remove
+-now the VM detects delegation cycles(and throws an exception)
+-new operators ++ and --
+-new operator ',' comma operator
+-fixed some expression precedence issue
+-fixed bug in sq_arraypop
+
+***2003-09-15       ***
+***version 0.3 alpha***
+-fixed a bug in array::insert()
+-optional Unicode core(define SQUNICODE or _UNICODE on Win32)
+-sq_compiler uses a new reader function SQLEXREADFUNC
+-the debug hook passes 'l' instead of 'line' for line callbacks
+	and 'c' instead of 'call' for call callbacks
+-new array.extend() bulit-in function
+-new API sq_clone()
+
+***2003-09-10           ***
+***version 0.2 pre-alpha***
+-new completely reentrant VM (sq_open and sq_close are now obsolete)
+-sq_newvm() has a new prototype
+-allocators are now global and linked in the VM
+-_newslot meta method added
+-rawset creates a slot if doesn't exists
+-the compiler error callback pass the vm handle(thanks Pierre Renaux)
+-sq_setforeignptr() sq_getforeingptr() are now public
+-sq_resume() now is possible to resume generators from C
+-sq_getlasterror() retrieve the last thrown error
+-improved docs
+
+***2003-09-06           ***
+***version 0.1 pre-alpha***
+first release
--- a/src/3rdparty/squirrel/Makefile
+++ b/src/3rdparty/squirrel/Makefile
@ -0,0 +1,23 @@
+
+SQUIRREL=.
+MAKE=make
+
+sq32:
+	cd squirrel; $(MAKE)
+	cd sqstdlib; $(MAKE)
+	cd sq; $(MAKE)
+
+sqprof:
+	cd squirrel; $(MAKE) sqprof
+	cd sqstdlib; $(MAKE) sqprof
+	cd sq; $(MAKE) sqprof
+
+sq64:
+	cd squirrel; $(MAKE) sq64
+	cd sqstdlib; $(MAKE) sq64
+	cd sq; $(MAKE) sq64
+
+clean:
+	$(MAKE) -C squirrel clean
+	$(MAKE) -C sqstdlib clean
+	$(MAKE) -C sq clean
--- a/src/3rdparty/squirrel/README
+++ b/src/3rdparty/squirrel/README
@ -0,0 +1,22 @@
+The programming language SQUIRREL 2.2.1 stable
+
+--------------------------------------------------
+The project has been compiled and run on Windows(Windows XP/2000 on Intel x86 Windows XP Pro on AMD x64) and
+Linux(Slackware 9.0 on Intel x86, Fedora Core 4 on AMD x64).
+
+Has been tested with the following compilers:
+	MS Visual C++ 6.0,7.0,7.1 and 8.0 (32 and 64bits)
+	MinGW gcc 3.2 (mingw special 20020817-1)
+	Cygnus gcc 3.2
+	Linux gcc 3.2.3
+	Linux gcc 4.0.0 (x86 64bits)
+
+
+Feedback and suggestions are appreciated
+project page - http://www.squirrel-lang.org
+community forums - http://www.squirrel-lang.org/Forums
+wiki - http://wiki.squirrel-lang.org
+author - alberto@demichelis.net
+
+END OF README
+
--- a/src/3rdparty/squirrel/README.OpenTTD
+++ b/src/3rdparty/squirrel/README.OpenTTD
@ -0,0 +1,4 @@
+This folder contains a modified version of Squirrel that is tailored to meet
+the needs of OpenTTD.
+We have based this modification on the version as described in:
+include/squirrel.h
--- a/src/3rdparty/squirrel/doc/sqstdlib2.chm
+++ b/src/3rdparty/squirrel/doc/sqstdlib2.chm
--- a/src/3rdparty/squirrel/doc/squirrel2.chm
+++ b/src/3rdparty/squirrel/doc/squirrel2.chm
--- a/src/3rdparty/squirrel/etc/minimal.c
+++ b/src/3rdparty/squirrel/etc/minimal.c
@ -0,0 +1,63 @@
+#include <stdarg.h>
+#include <stdio.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
+#define scvprintf vwprintf
+#else
+#define scvprintf vprintf
+#endif
+
+void printfunc(HSQUIRRELVM v, const SQChar *s, ...)
+{
+va_list arglist;
+va_start(arglist, s);
+scvprintf(s, arglist);
+va_end(arglist);
+}
+
+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
+}
+
+int main(int argc, char* argv[])
+{
+	HSQUIRRELVM v;
+	v = sq_open(1024); // creates a VM with initial stack size 1024
+
+	//sq_pushroottable(v); //push the root table were to register the lib function
+	//sqstd_register_iolib(v);
+	sqstd_seterrorhandlers(v); //registers the default error handlers
+
+	sq_setprintfunc(v, printfunc); //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_pop(v,1); //pops the root table
+	sq_close(v);
+
+	return 0;
+}
--- a/src/3rdparty/squirrel/etc/test.nut
+++ b/src/3rdparty/squirrel/etc/test.nut
@ -0,0 +1,4 @@
+function foo(i, f, s)
+{
+    print("Called foo(), i="+i+", f="+f+", s='"+s+"'\n");
+}
--- a/src/3rdparty/squirrel/include/sqstdaux.h
+++ b/src/3rdparty/squirrel/include/sqstdaux.h
@ -0,0 +1,16 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQSTD_AUXLIB_H_
+#define _SQSTD_AUXLIB_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SQUIRREL_API void sqstd_seterrorhandlers(HSQUIRRELVM v);
+SQUIRREL_API void sqstd_printcallstack(HSQUIRRELVM v);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /* _SQSTD_AUXLIB_H_ */
--- a/src/3rdparty/squirrel/include/sqstdblob.h
+++ b/src/3rdparty/squirrel/include/sqstdblob.h
@ -0,0 +1,20 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQSTDBLOB_H_
+#define _SQSTDBLOB_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SQUIRREL_API SQUserPointer sqstd_createblob(HSQUIRRELVM v, SQInteger size);
+SQUIRREL_API SQRESULT sqstd_getblob(HSQUIRRELVM v,SQInteger idx,SQUserPointer *ptr);
+SQUIRREL_API SQInteger sqstd_getblobsize(HSQUIRRELVM v,SQInteger idx);
+
+SQUIRREL_API SQRESULT sqstd_register_bloblib(HSQUIRRELVM v);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*_SQSTDBLOB_H_*/
+
--- a/src/3rdparty/squirrel/include/sqstdio.h
+++ b/src/3rdparty/squirrel/include/sqstdio.h
@ -0,0 +1,54 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQSTDIO_H_
+#define _SQSTDIO_H_
+
+#ifdef __cplusplus
+
+#define SQSTD_STREAM_TYPE_TAG 0x80000000
+
+struct SQStream {
+	virtual ~SQStream() {}
+	virtual SQInteger Read(void *buffer, SQInteger size) = 0;
+	virtual SQInteger Write(void *buffer, SQInteger size) = 0;
+	virtual SQInteger Flush() = 0;
+	virtual SQInteger Tell() = 0;
+	virtual SQInteger Len() = 0;
+	virtual SQInteger Seek(SQInteger offset, SQInteger origin) = 0;
+	virtual bool IsValid() = 0;
+	virtual bool EOS() = 0;
+};
+
+extern "C" {
+#endif
+
+#define SQ_SEEK_CUR 0
+#define SQ_SEEK_END 1
+#define SQ_SEEK_SET 2
+
+typedef void* SQFILE;
+
+SQUIRREL_API SQFILE sqstd_fopen(const SQChar *,const SQChar *);
+SQUIRREL_API SQInteger sqstd_fread(SQUserPointer, SQInteger, SQInteger, SQFILE);
+SQUIRREL_API SQInteger sqstd_fwrite(const SQUserPointer, SQInteger, SQInteger, SQFILE);
+SQUIRREL_API SQInteger sqstd_fseek(SQFILE , SQInteger , SQInteger);
+SQUIRREL_API SQInteger sqstd_ftell(SQFILE);
+SQUIRREL_API SQInteger sqstd_fflush(SQFILE);
+SQUIRREL_API SQInteger sqstd_fclose(SQFILE);
+SQUIRREL_API SQInteger sqstd_feof(SQFILE);
+
+SQUIRREL_API SQRESULT sqstd_createfile(HSQUIRRELVM v, SQFILE file,SQBool own);
+SQUIRREL_API SQRESULT sqstd_getfile(HSQUIRRELVM v, SQInteger idx, SQFILE *file);
+
+//compiler helpers
+SQUIRREL_API SQRESULT sqstd_loadfile(HSQUIRRELVM v,const SQChar *filename,SQBool printerror);
+SQUIRREL_API SQRESULT sqstd_dofile(HSQUIRRELVM v,const SQChar *filename,SQBool retval,SQBool printerror);
+SQUIRREL_API SQRESULT sqstd_writeclosuretofile(HSQUIRRELVM v,const SQChar *filename);
+
+SQUIRREL_API SQRESULT sqstd_register_iolib(HSQUIRRELVM v);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*_SQSTDIO_H_*/
+
--- a/src/3rdparty/squirrel/include/sqstdmath.h
+++ b/src/3rdparty/squirrel/include/sqstdmath.h
@ -0,0 +1,15 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQSTD_MATH_H_
+#define _SQSTD_MATH_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SQUIRREL_API SQRESULT sqstd_register_mathlib(HSQUIRRELVM v);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*_SQSTD_MATH_H_*/
--- a/src/3rdparty/squirrel/include/sqstdstring.h
+++ b/src/3rdparty/squirrel/include/sqstdstring.h
@ -0,0 +1,31 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQSTD_STRING_H_
+#define _SQSTD_STRING_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef unsigned int SQRexBool;
+typedef struct SQRex SQRex;
+
+typedef struct {
+	const SQChar *begin;
+	SQInteger len;
+} SQRexMatch;
+
+SQUIRREL_API SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error);
+SQUIRREL_API void sqstd_rex_free(SQRex *exp);
+SQUIRREL_API SQBool sqstd_rex_match(SQRex* exp,const SQChar* text);
+SQUIRREL_API SQBool sqstd_rex_search(SQRex* exp,const SQChar* text, const SQChar** out_begin, const SQChar** out_end);
+SQUIRREL_API SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const SQChar* text_end,const SQChar** out_begin, const SQChar** out_end);
+SQUIRREL_API SQInteger sqstd_rex_getsubexpcount(SQRex* exp);
+SQUIRREL_API SQBool sqstd_rex_getsubexp(SQRex* exp, SQInteger n, SQRexMatch *subexp);
+
+SQUIRREL_API SQRESULT sqstd_register_stringlib(HSQUIRRELVM v);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*_SQSTD_STRING_H_*/
--- a/src/3rdparty/squirrel/include/sqstdsystem.h
+++ b/src/3rdparty/squirrel/include/sqstdsystem.h
@ -0,0 +1,15 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQSTD_SYSTEMLIB_H_
+#define _SQSTD_SYSTEMLIB_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+SQUIRREL_API SQInteger sqstd_register_systemlib(HSQUIRRELVM v);
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /* _SQSTD_SYSTEMLIB_H_ */
--- a/src/3rdparty/squirrel/include/squirrel.h
+++ b/src/3rdparty/squirrel/include/squirrel.h
@ -0,0 +1,450 @@
+/*
+Copyright (c) 2003-2008 Alberto Demichelis
+
+This software is provided 'as-is', without any
+express or implied warranty. In no event will the
+authors be held liable for any damages arising from
+the use of this software.
+
+Permission is granted to anyone to use this software
+for any purpose, including commercial applications,
+and to alter it and redistribute it freely, subject
+to the following restrictions:
+
+		1. The origin of this software must not be
+		misrepresented; you must not claim that
+		you wrote the original software. If you
+		use this software in a product, an
+		acknowledgment in the product
+		documentation would be appreciated but is
+		not required.
+
+		2. Altered source versions must be plainly
+		marked as such, and must not be
+		misrepresented as being the original
+		software.
+
+		3. This notice may not be removed or
+		altered from any source distribution.
+
+*/
+#ifndef _SQUIRREL_H_
+#define _SQUIRREL_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER >= 1400 // MSVC 2005 safety checks
+# pragma warning(disable: 4996)   // '_wfopen' was declared deprecated
+# define _CRT_SECURE_NO_DEPRECATE // all deprecated 'unsafe string functions
+# define _CRT_NON_CONFORMING_SWPRINTFS // another deprecated stuff
+#endif /* _MSC_VER >= 1400 */
+
+#ifndef SQUIRREL_API
+#define SQUIRREL_API extern
+#endif
+
+#if (defined(_WIN64) || defined(_LP64)) && !defined(_SQ64)
+#define _SQ64
+#endif
+
+#ifdef _SQ64
+#ifdef _MSC_VER
+typedef __int64 SQInteger;
+typedef unsigned __int64 SQUnsignedInteger;
+typedef unsigned __int64 SQHash; /*should be the same size of a pointer*/
+#else
+typedef long SQInteger;
+typedef unsigned long SQUnsignedInteger;
+typedef unsigned long SQHash; /*should be the same size of a pointer*/
+#endif
+typedef int SQInt32;
+#else
+typedef int SQInteger;
+typedef int SQInt32; /*must be 32 bits(also on 64bits processors)*/
+typedef unsigned int SQUnsignedInteger;
+typedef unsigned int SQHash; /*should be the same size of a pointer*/
+#endif
+
+
+typedef float SQFloat;
+typedef void* SQUserPointer;
+typedef SQUnsignedInteger SQBool;
+typedef SQInteger SQRESULT;
+
+#define SQTrue	(1)
+#define SQFalse	(0)
+
+struct SQVM;
+struct SQTable;
+struct SQArray;
+struct SQString;
+struct SQClosure;
+struct SQGenerator;
+struct SQNativeClosure;
+struct SQUserData;
+struct SQFunctionProto;
+struct SQRefCounted;
+struct SQClass;
+struct SQInstance;
+struct SQDelegable;
+
+#ifdef _UNICODE
+#define SQUNICODE
+#endif
+
+#ifdef SQUNICODE
+#if (defined(_MSC_VER) && _MSC_VER >= 1400) // 1400 = VS8
+
+#ifndef _WCHAR_T_DEFINED //this is if the compiler considers wchar_t as native type
+typedef unsigned short wchar_t;
+#endif
+#endif
+
+typedef wchar_t SQChar;
+#define _SC(a) L##a
+#define	scstrcmp	wcscmp
+#define scsprintf	swprintf
+#define scsnprintf	_snwprintf
+#define scstrlen	wcslen
+#define scstrtod	wcstod
+#define scstrtol	wcstol
+#define scatoi		_wtoi
+#define scstrtoul	wcstoul
+#define scvsprintf	vswprintf
+#define scstrstr	wcsstr
+#define scisspace	iswspace
+#define scisdigit	iswdigit
+#define scisxdigit	iswxdigit
+#define scisalpha	iswalpha
+#define sciscntrl	iswcntrl
+#define scisalnum	iswalnum
+#define scprintf	wprintf
+#define scfprintf	fwprintf
+#define scvprintf	vwprintf
+#define scvfprintf	vfwprintf
+#define scvsnprintf	_vsnwprintf
+#define scstrdup	_wcsdup
+#define scstrrchr	wcsrchr
+#define scstrcat	wcscat
+#define MAX_CHAR 0xFFFF
+#else
+typedef char SQChar;
+#define _SC(a) a
+#define	scstrcmp	strcmp
+#define scsprintf	sprintf
+#define scsnprintf	snprintf
+#define scstrlen	strlen
+#define scstrtod	strtod
+#define scstrtol	strtol
+#define scatoi		atoi
+#define scstrtoul	strtoul
+#define scvsprintf	vsprintf
+#define scstrstr	strstr
+#define scisspace	isspace
+#define scisdigit	isdigit
+#define scisxdigit	isxdigit
+#define sciscntrl	iscntrl
+#define scisalpha	isalpha
+#define scisalnum	isalnum
+#define scprintf	printf
+#define scfprintf	fprintf
+#define scvprintf	vprintf
+#define scvfprintf	vfprintf
+#define scvsnprintf	vsnprintf
+#define scstrdup	strdup
+#define scstrrchr	strrchr
+#define scstrcat	strcat
+#define MAX_CHAR 0xFF
+#endif
+
+#define SQUIRREL_VERSION	_SC("Squirrel 2.2.2 stable - With custom OpenTTD modifications")
+#define SQUIRREL_COPYRIGHT	_SC("Copyright (C) 2003-2008 Alberto Demichelis")
+#define SQUIRREL_AUTHOR		_SC("Alberto Demichelis")
+
+#define SQ_VMSTATE_IDLE			0
+#define SQ_VMSTATE_RUNNING		1
+#define SQ_VMSTATE_SUSPENDED	2
+
+#define SQUIRREL_EOB 0
+#define SQ_BYTECODE_STREAM_TAG	0xFAFA
+
+#define SQOBJECT_REF_COUNTED	0x08000000
+#define SQOBJECT_NUMERIC		0x04000000
+#define SQOBJECT_DELEGABLE		0x02000000
+#define SQOBJECT_CANBEFALSE		0x01000000
+
+#define SQ_MATCHTYPEMASKSTRING (-99999)
+
+#define _RT_MASK 0x00FFFFFF
+#define _RAW_TYPE(type) (type&_RT_MASK)
+
+#define _RT_NULL			0x00000001
+#define _RT_INTEGER			0x00000002
+#define _RT_FLOAT			0x00000004
+#define _RT_BOOL			0x00000008
+#define _RT_STRING			0x00000010
+#define _RT_TABLE			0x00000020
+#define _RT_ARRAY			0x00000040
+#define _RT_USERDATA		0x00000080
+#define _RT_CLOSURE			0x00000100
+#define _RT_NATIVECLOSURE	0x00000200
+#define _RT_GENERATOR		0x00000400
+#define _RT_USERPOINTER		0x00000800
+#define _RT_THREAD			0x00001000
+#define _RT_FUNCPROTO		0x00002000
+#define _RT_CLASS			0x00004000
+#define _RT_INSTANCE		0x00008000
+#define _RT_WEAKREF			0x00010000
+
+typedef enum tagSQObjectType{
+	OT_NULL =			(_RT_NULL|SQOBJECT_CANBEFALSE),
+	OT_INTEGER =		(_RT_INTEGER|SQOBJECT_NUMERIC|SQOBJECT_CANBEFALSE),
+	OT_FLOAT =			(_RT_FLOAT|SQOBJECT_NUMERIC|SQOBJECT_CANBEFALSE),
+	OT_BOOL =			(_RT_BOOL|SQOBJECT_CANBEFALSE),
+	OT_STRING =			(_RT_STRING|SQOBJECT_REF_COUNTED),
+	OT_TABLE =			(_RT_TABLE|SQOBJECT_REF_COUNTED|SQOBJECT_DELEGABLE),
+	OT_ARRAY =			(_RT_ARRAY|SQOBJECT_REF_COUNTED),
+	OT_USERDATA =		(_RT_USERDATA|SQOBJECT_REF_COUNTED|SQOBJECT_DELEGABLE),
+	OT_CLOSURE =		(_RT_CLOSURE|SQOBJECT_REF_COUNTED),
+	OT_NATIVECLOSURE =	(_RT_NATIVECLOSURE|SQOBJECT_REF_COUNTED),
+	OT_GENERATOR =		(_RT_GENERATOR|SQOBJECT_REF_COUNTED),
+	OT_USERPOINTER =	_RT_USERPOINTER,
+	OT_THREAD =			(_RT_THREAD|SQOBJECT_REF_COUNTED) ,
+	OT_FUNCPROTO =		(_RT_FUNCPROTO|SQOBJECT_REF_COUNTED), //internal usage only
+	OT_CLASS =			(_RT_CLASS|SQOBJECT_REF_COUNTED),
+	OT_INSTANCE =		(_RT_INSTANCE|SQOBJECT_REF_COUNTED|SQOBJECT_DELEGABLE),
+	OT_WEAKREF =		(_RT_WEAKREF|SQOBJECT_REF_COUNTED)
+}SQObjectType;
+
+#define ISREFCOUNTED(t) (t&SQOBJECT_REF_COUNTED)
+
+
+typedef union tagSQObjectValue
+{
+	struct SQTable *pTable;
+	struct SQArray *pArray;
+	struct SQClosure *pClosure;
+	struct SQGenerator *pGenerator;
+	struct SQNativeClosure *pNativeClosure;
+	struct SQString *pString;
+	struct SQUserData *pUserData;
+	SQInteger nInteger;
+	SQFloat fFloat;
+	SQUserPointer pUserPointer;
+	struct SQFunctionProto *pFunctionProto;
+	struct SQRefCounted *pRefCounted;
+	struct SQDelegable *pDelegable;
+	struct SQVM *pThread;
+	struct SQClass *pClass;
+	struct SQInstance *pInstance;
+	struct SQWeakRef *pWeakRef;
+}SQObjectValue;
+
+
+typedef struct tagSQObject
+{
+	SQObjectType _type;
+	SQObjectValue _unVal;
+}SQObject;
+
+typedef struct tagSQStackInfos{
+	const SQChar* funcname;
+	const SQChar* source;
+	SQInteger line;
+}SQStackInfos;
+
+typedef struct SQVM* HSQUIRRELVM;
+typedef SQObject HSQOBJECT;
+typedef SQInteger (*SQFUNCTION)(HSQUIRRELVM);
+typedef SQInteger (*SQRELEASEHOOK)(SQUserPointer,SQInteger size);
+typedef void (*SQCOMPILERERROR)(HSQUIRRELVM,const SQChar * /*desc*/,const SQChar * /*source*/,SQInteger /*line*/,SQInteger /*column*/);
+typedef void (*SQPRINTFUNCTION)(HSQUIRRELVM,const SQChar * ,...);
+
+typedef SQInteger (*SQWRITEFUNC)(SQUserPointer,SQUserPointer,SQInteger);
+typedef SQInteger (*SQREADFUNC)(SQUserPointer,SQUserPointer,SQInteger);
+
+typedef SQInteger (*SQLEXREADFUNC)(SQUserPointer);
+
+typedef struct tagSQRegFunction{
+	const SQChar *name;
+	SQFUNCTION f;
+	SQInteger nparamscheck;
+	const SQChar *typemask;
+}SQRegFunction;
+
+/*vm*/
+SQUIRREL_API HSQUIRRELVM sq_open(SQInteger initialstacksize);
+SQUIRREL_API HSQUIRRELVM sq_newthread(HSQUIRRELVM friendvm, SQInteger initialstacksize);
+SQUIRREL_API void sq_seterrorhandler(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_setprintfunc(HSQUIRRELVM v, SQPRINTFUNCTION printfunc);
+SQUIRREL_API SQPRINTFUNCTION sq_getprintfunc(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_suspendvm(HSQUIRRELVM v);
+SQUIRREL_API bool sq_resumecatch(HSQUIRRELVM v, int suspend = -1);
+SQUIRREL_API SQRESULT sq_wakeupvm(HSQUIRRELVM v,SQBool resumedret,SQBool retval,SQBool raiseerror);
+SQUIRREL_API SQInteger sq_getvmstate(HSQUIRRELVM v);
+
+/*compiler*/
+SQUIRREL_API SQRESULT sq_compile(HSQUIRRELVM v,SQLEXREADFUNC read,SQUserPointer p,const SQChar *sourcename,SQBool raiseerror);
+SQUIRREL_API SQRESULT sq_compilebuffer(HSQUIRRELVM v,const SQChar *s,SQInteger size,const SQChar *sourcename,SQBool raiseerror);
+SQUIRREL_API void sq_enabledebuginfo(HSQUIRRELVM v, SQBool enable);
+SQUIRREL_API void sq_notifyallexceptions(HSQUIRRELVM v, SQBool enable);
+SQUIRREL_API void sq_setcompilererrorhandler(HSQUIRRELVM v,SQCOMPILERERROR f);
+
+/*stack operations*/
+SQUIRREL_API void sq_push(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API void sq_pop(HSQUIRRELVM v,SQInteger nelemstopop);
+SQUIRREL_API void sq_poptop(HSQUIRRELVM v);
+SQUIRREL_API void sq_remove(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQInteger sq_gettop(HSQUIRRELVM v);
+SQUIRREL_API void sq_settop(HSQUIRRELVM v,SQInteger newtop);
+SQUIRREL_API void sq_reservestack(HSQUIRRELVM v,SQInteger nsize);
+SQUIRREL_API SQInteger sq_cmp(HSQUIRRELVM v);
+SQUIRREL_API void sq_move(HSQUIRRELVM dest,HSQUIRRELVM src,SQInteger idx);
+
+/*object creation handling*/
+SQUIRREL_API SQUserPointer sq_newuserdata(HSQUIRRELVM v,SQUnsignedInteger size);
+SQUIRREL_API void sq_newtable(HSQUIRRELVM v);
+SQUIRREL_API void sq_newarray(HSQUIRRELVM v,SQInteger size);
+SQUIRREL_API void sq_newclosure(HSQUIRRELVM v,SQFUNCTION func,SQUnsignedInteger nfreevars);
+SQUIRREL_API SQRESULT sq_setparamscheck(HSQUIRRELVM v,SQInteger nparamscheck,const SQChar *typemask);
+SQUIRREL_API SQRESULT sq_bindenv(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API void sq_pushstring(HSQUIRRELVM v,const SQChar *s,SQInteger len);
+SQUIRREL_API void sq_pushfloat(HSQUIRRELVM v,SQFloat f);
+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 SQObjectType sq_gettype(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQInteger sq_getsize(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_getbase(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQBool sq_instanceof(HSQUIRRELVM v);
+SQUIRREL_API void sq_tostring(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API void sq_tobool(HSQUIRRELVM v, SQInteger idx, SQBool *b);
+SQUIRREL_API SQRESULT sq_getstring(HSQUIRRELVM v,SQInteger idx,const SQChar **c);
+SQUIRREL_API SQRESULT sq_getinteger(HSQUIRRELVM v,SQInteger idx,SQInteger *i);
+SQUIRREL_API SQRESULT sq_getfloat(HSQUIRRELVM v,SQInteger idx,SQFloat *f);
+SQUIRREL_API SQRESULT sq_getbool(HSQUIRRELVM v,SQInteger idx,SQBool *b);
+SQUIRREL_API SQRESULT sq_getthread(HSQUIRRELVM v,SQInteger idx,HSQUIRRELVM *thread);
+SQUIRREL_API SQRESULT sq_getuserpointer(HSQUIRRELVM v,SQInteger idx,SQUserPointer *p);
+SQUIRREL_API SQRESULT sq_getuserdata(HSQUIRRELVM v,SQInteger idx,SQUserPointer *p,SQUserPointer *typetag);
+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 SQChar *sq_getscratchpad(HSQUIRRELVM v,SQInteger minsize);
+SQUIRREL_API SQRESULT sq_getclosureinfo(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger *nparams,SQUnsignedInteger *nfreevars);
+SQUIRREL_API SQRESULT sq_setnativeclosurename(HSQUIRRELVM v,SQInteger idx,const SQChar *name);
+SQUIRREL_API SQRESULT sq_setinstanceup(HSQUIRRELVM v, SQInteger idx, SQUserPointer p);
+SQUIRREL_API SQRESULT sq_getinstanceup(HSQUIRRELVM v, SQInteger idx, SQUserPointer *p,SQUserPointer typetag);
+SQUIRREL_API SQRESULT sq_setclassudsize(HSQUIRRELVM v, SQInteger idx, SQInteger udsize);
+SQUIRREL_API SQRESULT sq_newclass(HSQUIRRELVM v,SQBool hasbase);
+SQUIRREL_API SQRESULT sq_createinstance(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_setattributes(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_getattributes(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_getclass(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API void sq_weakref(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_getdefaultdelegate(HSQUIRRELVM v,SQObjectType t);
+
+/*object manipulation*/
+SQUIRREL_API void sq_pushroottable(HSQUIRRELVM v);
+SQUIRREL_API void sq_pushregistrytable(HSQUIRRELVM v);
+SQUIRREL_API void sq_pushconsttable(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_setroottable(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_setconsttable(HSQUIRRELVM v);
+SQUIRREL_API SQRESULT sq_newslot(HSQUIRRELVM v, SQInteger idx, SQBool bstatic);
+SQUIRREL_API SQRESULT sq_deleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval);
+SQUIRREL_API SQRESULT sq_set(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_get(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_rawget(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_rawset(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_rawdeleteslot(HSQUIRRELVM v,SQInteger idx,SQBool pushval);
+SQUIRREL_API SQRESULT sq_arrayappend(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_arraypop(HSQUIRRELVM v,SQInteger idx,SQBool pushval);
+SQUIRREL_API SQRESULT sq_arrayresize(HSQUIRRELVM v,SQInteger idx,SQInteger newsize);
+SQUIRREL_API SQRESULT sq_arrayreverse(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_arrayremove(HSQUIRRELVM v,SQInteger idx,SQInteger itemidx);
+SQUIRREL_API SQRESULT sq_arrayinsert(HSQUIRRELVM v,SQInteger idx,SQInteger destpos);
+SQUIRREL_API SQRESULT sq_setdelegate(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_getdelegate(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_clone(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_setfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger nval);
+SQUIRREL_API SQRESULT sq_next(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_getweakrefval(HSQUIRRELVM v,SQInteger idx);
+SQUIRREL_API SQRESULT sq_clear(HSQUIRRELVM v,SQInteger idx);
+
+/*calls*/
+SQUIRREL_API SQRESULT sq_call(HSQUIRRELVM v,SQInteger params,SQBool retval,SQBool raiseerror, int suspend = -1);
+SQUIRREL_API SQRESULT sq_resume(HSQUIRRELVM v,SQBool retval,SQBool raiseerror);
+SQUIRREL_API const SQChar *sq_getlocal(HSQUIRRELVM v,SQUnsignedInteger level,SQUnsignedInteger idx);
+SQUIRREL_API const SQChar *sq_getfreevariable(HSQUIRRELVM v,SQInteger idx,SQUnsignedInteger nval);
+SQUIRREL_API SQRESULT sq_throwerror(HSQUIRRELVM v,const SQChar *err);
+SQUIRREL_API void sq_reseterror(HSQUIRRELVM v);
+SQUIRREL_API void sq_getlasterror(HSQUIRRELVM v);
+
+/*raw object handling*/
+SQUIRREL_API SQRESULT sq_getstackobj(HSQUIRRELVM v,SQInteger idx,HSQOBJECT *po);
+SQUIRREL_API void sq_pushobject(HSQUIRRELVM v,HSQOBJECT obj);
+SQUIRREL_API void sq_addref(HSQUIRRELVM v,HSQOBJECT *po);
+SQUIRREL_API SQBool sq_release(HSQUIRRELVM v,HSQOBJECT *po);
+SQUIRREL_API void sq_resetobject(HSQOBJECT *po);
+SQUIRREL_API const SQChar *sq_objtostring(HSQOBJECT *o);
+SQUIRREL_API SQBool sq_objtobool(HSQOBJECT *o);
+SQUIRREL_API SQInteger sq_objtointeger(HSQOBJECT *o);
+SQUIRREL_API SQFloat sq_objtofloat(HSQOBJECT *o);
+SQUIRREL_API SQRESULT sq_getobjtypetag(HSQOBJECT *o,SQUserPointer * typetag);
+
+/*GC*/
+SQUIRREL_API SQInteger sq_collectgarbage(HSQUIRRELVM v);
+
+/*serialization*/
+SQUIRREL_API SQRESULT sq_writeclosure(HSQUIRRELVM vm,SQWRITEFUNC writef,SQUserPointer up);
+SQUIRREL_API SQRESULT sq_readclosure(HSQUIRRELVM vm,SQREADFUNC readf,SQUserPointer up);
+
+/*mem allocation*/
+SQUIRREL_API void *sq_malloc(SQUnsignedInteger size);
+SQUIRREL_API void *sq_realloc(void* p,SQUnsignedInteger oldsize,SQUnsignedInteger newsize);
+SQUIRREL_API void sq_free(void *p,SQUnsignedInteger size);
+
+/*debug*/
+SQUIRREL_API SQRESULT sq_stackinfos(HSQUIRRELVM v,SQInteger level,SQStackInfos *si);
+SQUIRREL_API void sq_setdebughook(HSQUIRRELVM v);
+
+/*UTILITY MACRO*/
+#define sq_isnumeric(o) ((o)._type&SQOBJECT_NUMERIC)
+#define sq_istable(o) ((o)._type==OT_TABLE)
+#define sq_isarray(o) ((o)._type==OT_ARRAY)
+#define sq_isfunction(o) ((o)._type==OT_FUNCPROTO)
+#define sq_isclosure(o) ((o)._type==OT_CLOSURE)
+#define sq_isgenerator(o) ((o)._type==OT_GENERATOR)
+#define sq_isnativeclosure(o) ((o)._type==OT_NATIVECLOSURE)
+#define sq_isstring(o) ((o)._type==OT_STRING)
+#define sq_isinteger(o) ((o)._type==OT_INTEGER)
+#define sq_isfloat(o) ((o)._type==OT_FLOAT)
+#define sq_isuserpointer(o) ((o)._type==OT_USERPOINTER)
+#define sq_isuserdata(o) ((o)._type==OT_USERDATA)
+#define sq_isthread(o) ((o)._type==OT_THREAD)
+#define sq_isnull(o) ((o)._type==OT_NULL)
+#define sq_isclass(o) ((o)._type==OT_CLASS)
+#define sq_isinstance(o) ((o)._type==OT_INSTANCE)
+#define sq_isbool(o) ((o)._type==OT_BOOL)
+#define sq_isweakref(o) ((o)._type==OT_WEAKREF)
+#define sq_type(o) ((o)._type)
+
+/* deprecated */
+#define sq_createslot(v,n) sq_newslot(v,n,SQFalse)
+
+#define SQ_OK (0)
+#define SQ_ERROR (-1)
+
+#define SQ_FAILED(res) (res<0)
+#define SQ_SUCCEEDED(res) (res>=0)
+
+#ifdef __cplusplus
+} /*extern "C"*/
+#endif
+
+#endif /*_SQUIRREL_H_*/
--- a/src/3rdparty/squirrel/samples/ackermann.nut
+++ b/src/3rdparty/squirrel/samples/ackermann.nut
@ -0,0 +1,22 @@
+/*
+*
+* Original Javascript version by David Hedbor(http://www.bagley.org/~doug/shootout/)
+*
+*/
+
+function Ack(M, N) {
+    if (M == 0) return( N + 1 );
+    if (N == 0) return( Ack(M - 1, 1) );
+    return( Ack(M - 1, Ack(M, (N - 1))) );
+}
+
+local n;
+
+if(ARGS.len()!=0) {
+   n = ARGS[0].tointeger();
+  if(n < 1) n = 1;
+} else {
+  n = 1;
+}
+print("n="+n+"\n");
+print("Ack(3,"+ n+ "):"+ Ack(3, n));
--- a/src/3rdparty/squirrel/samples/array.nut
+++ b/src/3rdparty/squirrel/samples/array.nut
@ -0,0 +1,28 @@
+/*
+*
+* Original Javascript version by David Hedbor(http://www.bagley.org/~doug/shootout/)
+*
+*/
+local n, i, k;
+
+if(ARGS.len()!=0) {
+   n = ARGS[0].tointeger();
+  if(n < 1) n = 1;
+} else {
+  n = 1;
+}
+
+local x = []; x.resize(n);
+local y = []; y.resize(n);
+
+for (i = 0; i < n; i+=1) {
+  x[i] = i + 1;
+  y[i] = 0;
+}
+
+for (k = 0 ; k < n; k+=1) {
+  for (i = n-1; i >= 0; i-=1) {
+	y[i] = y[i]+ x[i];
+  }
+}
+print(y[0].tostring()+" "+y[n-1]);
--- a/src/3rdparty/squirrel/samples/class.nut
+++ b/src/3rdparty/squirrel/samples/class.nut
@ -0,0 +1,49 @@
+//////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////////
+class BaseVector {
+	constructor(...)
+	{
+		if(vargc >= 3) {
+			x = vargv[0];
+			y = vargv[1];
+			z = vargv[2];
+		}
+	}
+
+
+	x = 0;
+	y = 0;
+	z = 0;
+}
+
+class Vector3 extends BaseVector {
+	function _add(other)
+	{
+		if(other instanceof this.getclass())
+			return ::Vector3(x+other.x,y+other.y,z+other.z);
+		else
+			throw "wrong parameter";
+	}
+	function Print()
+	{
+		::print(x+","+y+","+z+"\n");
+	}
+}
+
+local v0 = Vector3(1,2,3)
+local v1 = Vector3(11,12,13)
+local v2 = v0 + v1;
+v2.Print();
+
+FakeNamespace <- {
+	Utils = {}
+}
+
+class FakeNamespace.Utils.SuperClass {
+	constructor()
+	{
+		::print("FakeNamespace.Utils.SuperClass")
+	}
+}
+
+local testy = FakeNamespace.Utils.SuperClass();
--- a/src/3rdparty/squirrel/samples/classattributes.nut
+++ b/src/3rdparty/squirrel/samples/classattributes.nut
@ -0,0 +1,35 @@
+class Foo {
+	//constructor
+	constructor(a)
+	{
+		testy = ["stuff",1,2,3];
+	}
+	//attributes of PrintTesty
+	</ test = "freakin attribute"/>
+	function PrintTesty()
+	{
+		foreach(i,val in testy)
+		{
+			::print("idx = "+i+" = "+val+" \n");
+		}
+	}
+	//attributes of testy
+	</ flippy = 10 , second = [1,2,3] />
+	testy = null;
+
+}
+
+foreach(member,val in Foo)
+{
+	::print(member+"\n");
+	local attr;
+	if((attr = Foo.getattributes(member)) != null) {
+		foreach(i,v in attr)
+		{
+			::print("\t"+i+" = "+(typeof v)+"\n");
+		}
+	}
+	else {
+		::print("\t<no attributes>\n")
+	}
+}
--- a/src/3rdparty/squirrel/samples/coroutines.nut
+++ b/src/3rdparty/squirrel/samples/coroutines.nut
@ -0,0 +1,25 @@
+function coroutine_test(a,b)
+{
+	::print(a+" "+b+"\n");
+	local ret = ::suspend("suspend 1");
+	::print("the coroutine says "+ret+"\n");
+	ret = ::suspend("suspend 2");
+	::print("the coroutine says "+ret+"\n");
+	ret = ::suspend("suspend 3");
+	::print("the coroutine says "+ret+"\n");
+	return "I'm done"
+}
+
+local coro = ::newthread(coroutine_test);
+
+local susparam = coro.call("test","coroutine"); //starts the coroutine
+
+local i = 1;
+do
+{
+	::print("suspend passed ["+susparam+"]\n")
+	susparam = coro.wakeup("ciao "+i);
+	++i;
+}while(coro.getstatus()=="suspended")
+
+::print("return passed ["+susparam+"]\n")
--- a/src/3rdparty/squirrel/samples/delegation.nut
+++ b/src/3rdparty/squirrel/samples/delegation.nut
@ -0,0 +1,52 @@
+
+PEntity <- {
+	name="noname"
+	pos={x=0,y=0,z=0}
+	type="entity"
+	//methamethod
+	_typeof=function()
+	{
+		return type;
+	}
+}
+
+function PEntity::PrintPos()
+{
+	::print("x="+pos.x+" y="+pos.y+" z="+pos.z+"\n");
+}
+
+function PEntity::new(name,pos)
+{
+	local newentity=clone ::PEntity;
+	if(name)
+		newentity.name=name;
+	if(pos)
+		newentity.pos=pos;
+	return newentity;
+}
+
+PPlayer <- {
+	model="warrior.mdl"
+	weapon="fist"
+	health=100
+	armor=0
+	//overrides the parent type
+	type="player"
+}
+
+function PPlayer::new(name,pos)
+{
+	local newplayer=delegate ::PEntity.new(name,pos) : clone ::PPlayer;
+	return newplayer;
+}
+
+local player=PPlayer.new("godzilla",{x=10,y=20,z=30});
+
+::print("PLAYER NAME"+player.name+"\n");
+::print("ENTITY TYPE"+typeof player+"\n");
+
+player.PrintPos();
+
+player.pos.x=123;
+
+player.PrintPos();
--- a/src/3rdparty/squirrel/samples/fibonacci.nut
+++ b/src/3rdparty/squirrel/samples/fibonacci.nut
@ -0,0 +1,15 @@
+/*
+*
+* Original Javascript version by David Hedbor(http://www.bagley.org/~doug/shootout/)
+*
+*/
+
+function fib(n)
+{
+    if (n < 2) return 1
+    return fib(n-2) + fib(n-1)
+}
+
+local n = ARGS.len()!=0?ARGS[0].tointeger():1
+
+print(fib(n)+"\n")
--- a/src/3rdparty/squirrel/samples/flow.nut
+++ b/src/3rdparty/squirrel/samples/flow.nut
@ -0,0 +1,33 @@
+function min(x,y)
+	return x<y?x:y;
+
+function max(x,y)
+	return x>y?x:y;
+
+if(min(100,200)>max(50,20))
+	print("I'm useless statement just to show up the if/else\n");
+else
+	print("squirrel!!\n");
+
+print("\n")
+
+function typy(obj)
+{
+	switch(typeof obj)
+	{
+		case "integer":
+		case "float":
+			return "is a number";
+		case "table":
+		case "array":
+			return "is a container";
+		default:
+			return "is other stuff"
+	}
+}
+
+local a=1,b={},c=function(a,b){return a+b;}
+
+print("a "+typy(a)+"\n");
+print("b "+typy(b)+"\n");
+print("c "+typy(c)+"\n");
--- a/src/3rdparty/squirrel/samples/generators.nut
+++ b/src/3rdparty/squirrel/samples/generators.nut
@ -0,0 +1,42 @@
+/*
+*Random number function from The Great Computer Language shootout
+*converted to a generator func
+*/
+
+function gen_random(max) {
+	local last=42
+	local IM = 139968;
+	local IA = 3877;
+	local IC = 29573;
+	for(;;){  //loops forever
+		yield (max * (last = (last * IA + IC) % IM) / IM);
+	}
+}
+
+local randtor=gen_random(100);
+
+print("RAND NUMBERS \n")
+
+for(local i=0;i<10;i+=1)
+	print(">"+resume randtor+"\n");
+
+print("FIBONACCI \n")
+function fiboz(n)
+{
+	local prev=0;
+	local curr=1;
+	yield 1;
+
+	for(local i=0;i<n-1;i+=1)
+	{
+		local res=prev+curr;
+		prev=curr;
+		yield curr=res;
+	}
+	return prev+curr;
+}
+
+foreach(val in fiboz(10))
+{
+	::print(">"+val+"\n");
+}
--- a/src/3rdparty/squirrel/samples/hello.nut
+++ b/src/3rdparty/squirrel/samples/hello.nut
@ -0,0 +1 @@
+print("Hello World!")
--- a/src/3rdparty/squirrel/samples/list.nut
+++ b/src/3rdparty/squirrel/samples/list.nut
@ -0,0 +1,39 @@
+/*translation of the list test from The Great Computer Language Shootout
+*/
+
+function compare_arr(a1,a2)
+{
+	foreach(i,val in a1)
+		if(val!=a2[i])return null;
+	return 1;
+}
+
+function test()
+{
+	local size=10000
+	local l1=[]; l1.resize(size);
+	for(local i=0;i<size;i+=1) l1[i]=i;
+	local l2=clone l1;
+	local l3=[]
+
+	l2.reverse();
+	while(l2.len()>0)
+		l3.append(l2.pop());
+	while(l3.len()>0)
+		l2.append(l3.pop());
+	l1.reverse();
+
+	if(compare_arr(l1,l2))
+		return l1.len();
+	return null;
+}
+
+local n = ARGS.len()!=0?ARGS[0].tointeger():1
+for(local i=0;i<n;i+=1)
+	if(!test())
+	{
+		print("failed");
+		return;
+	}
+
+print("oki doki");
--- a/src/3rdparty/squirrel/samples/loops.nut
+++ b/src/3rdparty/squirrel/samples/loops.nut
@ -0,0 +1,32 @@
+local arr=["one","two","three"]
+
+::print("FOREACH\n");
+
+foreach(i,val in arr)
+{
+	::print("index ["+i+"]="+val+"\n");
+}
+
+::print("FOR\n");
+
+for(local i=0;i<arr.len();i+=1)
+{
+	::print("index ["+i+"]="+arr[i]+"\n");
+}
+
+::print("WHILE\n");
+
+local i=0;
+while(i<arr.len())
+{
+	::print("index ["+i+"]="+arr[i]+"\n");
+	i+=1;
+}
+::print("DO WHILE\n");
+
+local i=0;
+do
+{
+	::print("index ["+i+"]="+arr[i]+"\n");
+	i+=1;
+}while(i<arr.len());
--- a/src/3rdparty/squirrel/samples/matrix.nut
+++ b/src/3rdparty/squirrel/samples/matrix.nut
@ -0,0 +1,44 @@
+/*
+*
+* Original Javascript version by David Hedbor(http://www.bagley.org/~doug/shootout/)
+*
+*/
+local SIZE=30;
+
+function mkmatrix(rows, cols) {
+  local i, j, count = 1;
+  local m = []; m.resize(rows);
+  for (i = 0; i < rows; i+=1) {
+    m[i] = [];m[i].resize(cols)
+    for (j = 0; j < cols; j+=1) {
+      m[i][j] = count+=1;
+    }
+  }
+  return m;
+}
+
+function mmult(rows, cols,  m1, m2, m3) {
+  local i, j, k, val;
+  for (i = 0; i < rows; i+=1) {
+    for (j = 0; j < cols; j+=1) {
+      val = 0;
+      for (k = 0; k < cols; k+=1) {
+	val += m1[i][k] * m2[k][j];
+      }
+      m3[i][j] = val;
+    }
+  }
+  return m3;
+}
+
+local n = ARGS.len()!=0?ARGS[0].tointeger():1
+
+local m1 = mkmatrix(SIZE, SIZE);
+local m2 = mkmatrix(SIZE, SIZE);
+local mm = mkmatrix(SIZE, SIZE);
+
+for (local i = 0; i < n; i+=1) {
+  mmult(SIZE, SIZE, m1, m2, mm);
+}
+
+print(mm[0][0]+" "+mm[2][3]+" "+mm[3][2]+" "+mm[4][4]);
--- a/src/3rdparty/squirrel/samples/metamethods.nut
+++ b/src/3rdparty/squirrel/samples/metamethods.nut
@ -0,0 +1,115 @@
+
+local base_vec={
+	function _add(n)
+	{
+		return {
+			x=x+n.x,
+			y=y+n.y,
+			z=z+n.z,
+		}
+	}
+	function _sub(n)
+	{
+		return {
+			x=x-n.x,
+			y=y-n.y,
+			z=z-n.z,
+		}
+	}
+	function _div(n)
+	{
+		return {
+			x=x/n.x,
+			y=y/n.y,
+			z=z/n.z,
+		}
+	}
+	function _mul(n)
+	{
+		return {
+			x=x*n.x,
+			y=y*n.y,
+			z=z*n.z,
+		}
+	}
+	function _modulo(n)
+	{
+		return {
+			x=x%n,
+			y=y%n,
+			z=z%n,
+		}
+	}
+	function _typeof() {return "vector";}
+	function _get(key)
+	{
+		if(key==100)
+		{
+			return test_field;
+		}
+	},
+	function _set(key,val)
+	{
+		::print("key = "+key+"\n");
+		::print("val = "+val+"\n")
+		if(key==100)
+		{
+			return test_field=val;
+		}
+	}
+	test_field="nothing"
+}
+
+function vector(_x,_y,_z):(base_vec)
+{
+	return delegate base_vec : {x=_x,y=_y,z=_z }
+}
+////////////////////////////////////////////////////////////
+
+local v1=vector(1.5,2.5,3.5);
+local v2=vector(1.5,2.5,3.5);
+
+local r=v1+v2;
+
+
+foreach(i,val in r)
+{
+	print(i+" = "+val+"\n");
+}
+
+r=v1*v2;
+
+foreach(i,val in r)
+{
+	print(i+" = "+val+"\n");
+}
+
+r=v1/v2;
+
+foreach(i,val in r)
+{
+	print(i+" = "+val+"\n");
+}
+
+r=v1-v2;
+
+foreach(i,val in r)
+{
+	print(i+" = "+val+"\n");
+}
+
+r=v1%2;
+
+foreach(i,val in r)
+{
+	print(i+" = "+val+"\n");
+}
+
+print(v1[100]+"\n");
+v1[100]="set SUCCEEDED";
+print(v1[100]+"\n");
+
+if(typeof v1=="vector")
+	print("<SUCCEEDED>\n");
+else
+	print("<FAILED>\n");
--- a/src/3rdparty/squirrel/samples/methcall.nut
+++ b/src/3rdparty/squirrel/samples/methcall.nut
@ -0,0 +1,61 @@
+/*translation of the methcall test from The Great Computer Language Shootout
+*/
+
+Toggle <- {
+	bool=null
+}
+
+function Toggle::value() {
+	return bool;
+}
+
+function Toggle::activate() {
+	bool = !bool;
+	return this;
+}
+
+function Toggle::new(startstate) {
+	local newo=clone this;
+	newo.bool = startstate;
+	return newo;
+}
+
+NthToggle <- {
+	count_max=null
+	count=0
+}
+
+function NthToggle::new(start_state,max_counter)
+{
+	local newo=delegate ::Toggle.new(start_state) : clone this;
+	newo.count_max <- max_counter
+	return newo;
+}
+
+function NthToggle::activate ()
+{
+	count+=1
+    if (count >= count_max) {
+      bool = !bool;
+      count = 0;
+    }
+    return this;
+}
+
+
+local n = ARGS.len()!=0?ARGS[0].tointeger():1
+
+local val = 1;
+local toggle = Toggle.new(val);
+for (local i=0; i<n; i+=1) {
+  val = toggle.activate().value();
+
+}
+print(toggle.value() ? "true\n" : "false\n");
+
+val = 1;
+local ntoggle = NthToggle.new(val, 3);
+for (local i=0; i<n; i+=1) {
+  val = ntoggle.activate().value();
+}
+print(ntoggle.value() ? "true\n" : "false\n");
--- a/src/3rdparty/squirrel/samples/tailstate.nut
+++ b/src/3rdparty/squirrel/samples/tailstate.nut
@ -0,0 +1,24 @@
+function state1()
+{
+	::suspend("state1");
+	return state2();
+}
+
+function state2()
+{
+	::suspend("state2");
+	return state3();
+}
+
+function state3()
+{
+	::suspend("state3");
+	return state1();
+}
+
+local statethread = ::newthread(state1)
+
+::print(statethread.call()+"\n");
+
+for(local i = 0; i < 10000; i++)
+	::print(statethread.wakeup()+"\n");
--- a/src/3rdparty/squirrel/sq/Makefile
+++ b/src/3rdparty/squirrel/sq/Makefile
@ -0,0 +1,24 @@
+SQUIRREL= ..
+
+
+OUT= $(SQUIRREL)/bin/sq
+INCZ= -I$(SQUIRREL)/include -I. -I$(SQUIRREL)/sqlibs
+LIBZ= -L$(SQUIRREL)/lib
+LIB= -lsquirrel -lsqstdlib
+
+OBJS= sq.o
+
+SRCS= sq.c
+
+
+sq32:
+	g++ -O2 -fno-rtti -o $(OUT) $(SRCS) $(INCZ) $(LIBZ) $(LIB)
+
+sqprof:
+	g++ -O2 -pg -fno-rtti -pie -gstabs -g3 -o $(OUT) $(SRCS) $(INCZ) $(LIBZ) $(LIB)
+
+sq64:
+	g++ -O2 -fno-rtti -D_SQ64 -o $(OUT) $(SRCS) $(INCZ) $(LIBZ) $(LIB)
+
+clean:
+	rm -f $(OUT)
--- a/src/3rdparty/squirrel/sq/sq.c
+++ b/src/3rdparty/squirrel/sq/sq.c
@ -0,0 +1,321 @@
+/*	see copyright notice in squirrel.h */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdarg.h>
+
+#if defined(_MSC_VER) && defined(_DEBUG)
+#include <crtdbg.h>
+#include <conio.h>
+#endif
+#include <squirrel.h>
+#include <sqstdblob.h>
+#include <sqstdsystem.h>
+#include <sqstdio.h>
+#include <sqstdmath.h>
+#include <sqstdstring.h>
+#include <sqstdaux.h>
+
+#ifdef SQUNICODE
+#define scfprintf fwprintf
+#define scfopen	_wfopen
+#define scvprintf vwprintf
+#else
+#define scfprintf fprintf
+#define scfopen	fopen
+#define scvprintf vprintf
+#endif
+
+
+void PrintVersionInfos();
+
+#if defined(_MSC_VER) && defined(_DEBUG)
+int MemAllocHook( int allocType, void *userData, size_t size, int blockType,
+   long requestNumber, const unsigned char *filename, int lineNumber)
+{
+//	if(requestNumber==585)_asm int 3;
+	return 1;
+}
+#endif
+
+
+SQInteger quit(HSQUIRRELVM v)
+{
+	int *done;
+	sq_getuserpointer(v,-1,(SQUserPointer*)&done);
+	*done=1;
+	return 0;
+}
+
+void printfunc(HSQUIRRELVM v,const SQChar *s,...)
+{
+	va_list vl;
+	va_start(vl, s);
+	scvprintf( s, vl);
+	va_end(vl);
+}
+
+void PrintVersionInfos()
+{
+	scfprintf(stdout,_SC("%s %s (%d bits)\n"),SQUIRREL_VERSION,SQUIRREL_COPYRIGHT,sizeof(SQInteger)*8);
+}
+
+void PrintUsage()
+{
+	scfprintf(stderr,_SC("usage: sq <options> <scriptpath [args]>.\n")
+		_SC("Available options are:\n")
+		_SC("   -c              compiles the file to bytecode(default output 'out.cnut')\n")
+		_SC("   -o              specifies output file for the -c option\n")
+		_SC("   -c              compiles only\n")
+		_SC("   -d              generates debug infos\n")
+		_SC("   -v              displays version infos\n")
+		_SC("   -h              prints help\n"));
+}
+
+#define _INTERACTIVE 0
+#define _DONE 2
+//<<FIXME>> this func is a mess
+int getargs(HSQUIRRELVM v,int argc, char* argv[])
+{
+	int i;
+	int compiles_only = 0;
+	static SQChar temp[500];
+	const SQChar *ret=NULL;
+	char * output = NULL;
+	int lineinfo=0;
+	if(argc>1)
+	{
+		int arg=1,exitloop=0;
+		while(arg < argc && !exitloop)
+		{
+
+			if(argv[arg][0]=='-')
+			{
+				switch(argv[arg][1])
+				{
+				case 'd': //DEBUG(debug infos)
+					sq_enabledebuginfo(v,1);
+					break;
+				case 'c':
+					compiles_only = 1;
+					break;
+				case 'o':
+					if(arg < argc) {
+						arg++;
+						output = argv[arg];
+					}
+					break;
+				case 'v':
+					PrintVersionInfos();
+					return _DONE;
+
+				case 'h':
+					PrintVersionInfos();
+					PrintUsage();
+					return _DONE;
+				default:
+					PrintVersionInfos();
+					scprintf(_SC("unknown prameter '-%c'\n"),argv[arg][1]);
+					PrintUsage();
+					return _DONE;
+				}
+			}else break;
+			arg++;
+		}
+
+		// src file
+
+		if(arg<argc) {
+			const SQChar *filename=NULL;
+#ifdef SQUNICODE
+			mbstowcs(temp,argv[arg],strlen(argv[arg]));
+			filename=temp;
+#else
+			filename=argv[arg];
+#endif
+
+			arg++;
+			sq_pushroottable(v);
+			sq_pushstring(v,_SC("ARGS"),-1);
+			sq_newarray(v,0);
+			for(i=arg;i<argc;i++)
+			{
+				const SQChar *a;
+#ifdef SQUNICODE
+				int alen=(int)strlen(argv[i]);
+				a=sq_getscratchpad(v,(int)(alen*sizeof(SQChar)));
+				mbstowcs(sq_getscratchpad(v,-1),argv[i],alen);
+				sq_getscratchpad(v,-1)[alen] = _SC('\0');
+#else
+				a=argv[i];
+#endif
+				sq_pushstring(v,a,-1);
+
+				sq_arrayappend(v,-2);
+			}
+			sq_createslot(v,-3);
+			sq_pop(v,1);
+			if(compiles_only) {
+				if(SQ_SUCCEEDED(sqstd_loadfile(v,filename,SQTrue))){
+					SQChar *outfile = _SC("out.cnut");
+					if(output) {
+#ifdef SQUNICODE
+						int len = (int)(strlen(output)+1);
+						mbstowcs(sq_getscratchpad(v,len*sizeof(SQChar)),output,len);
+						outfile = sq_getscratchpad(v,-1);
+#else
+						outfile = output;
+#endif
+					}
+					if(SQ_SUCCEEDED(sqstd_writeclosuretofile(v,outfile)))
+						return _DONE;
+				}
+			}
+			else {
+				if(SQ_SUCCEEDED(sqstd_dofile(v,filename,SQFalse,SQTrue))) {
+					return _DONE;
+				}
+			}
+			//if this point is reached an error occured
+			{
+				const SQChar *err;
+				sq_getlasterror(v);
+				if(SQ_SUCCEEDED(sq_getstring(v,-1,&err))) {
+					scprintf(_SC("Error [%s]\n"),err);
+					return _DONE;
+				}
+			}
+
+		}
+	}
+
+	return _INTERACTIVE;
+}
+
+void Interactive(HSQUIRRELVM v)
+{
+
+#define MAXINPUT 1024
+	SQChar buffer[MAXINPUT];
+	SQInteger blocks =0;
+	SQInteger string=0;
+	SQInteger retval=0;
+	SQInteger done=0;
+	PrintVersionInfos();
+
+	sq_pushroottable(v);
+	sq_pushstring(v,_SC("quit"),-1);
+	sq_pushuserpointer(v,&done);
+	sq_newclosure(v,quit,1);
+	sq_setparamscheck(v,1,NULL);
+	sq_createslot(v,-3);
+	sq_pop(v,1);
+
+    while (!done)
+	{
+		SQInteger i = 0;
+		scprintf(_SC("\nsq>"));
+		for(;;) {
+			int c;
+			if(done)return;
+			c = getchar();
+			if (c == _SC('\n')) {
+				if (i>0 && buffer[i-1] == _SC('\\'))
+				{
+					buffer[i-1] = _SC('\n');
+				}
+				else if(blocks==0)break;
+				buffer[i++] = _SC('\n');
+			}
+			else if (c==_SC('}')) {blocks--; buffer[i++] = (SQChar)c;}
+			else if(c==_SC('{') && !string){
+					blocks++;
+					buffer[i++] = (SQChar)c;
+			}
+			else if(c==_SC('"') || c==_SC('\'')){
+					string=!string;
+					buffer[i++] = (SQChar)c;
+			}
+			else if (i >= MAXINPUT-1) {
+				scfprintf(stderr, _SC("sq : input line too long\n"));
+				break;
+			}
+			else{
+				buffer[i++] = (SQChar)c;
+			}
+		}
+		buffer[i] = _SC('\0');
+
+		if(buffer[0]==_SC('=')){
+			scsprintf(sq_getscratchpad(v,MAXINPUT),_SC("return (%s)"),&buffer[1]);
+			memcpy(buffer,sq_getscratchpad(v,-1),(scstrlen(sq_getscratchpad(v,-1))+1)*sizeof(SQChar));
+			retval=1;
+		}
+		i=scstrlen(buffer);
+		if(i>0){
+			SQInteger oldtop=sq_gettop(v);
+			if(SQ_SUCCEEDED(sq_compilebuffer(v,buffer,i,_SC("interactive console"),SQTrue))){
+				sq_pushroottable(v);
+				if(SQ_SUCCEEDED(sq_call(v,1,retval,SQTrue)) &&	retval){
+					scprintf(_SC("\n"));
+					sq_pushroottable(v);
+					sq_pushstring(v,_SC("print"),-1);
+					sq_get(v,-2);
+					sq_pushroottable(v);
+					sq_push(v,-4);
+					sq_call(v,2,SQFalse,SQTrue);
+					retval=0;
+					scprintf(_SC("\n"));
+				}
+			}
+
+			sq_settop(v,oldtop);
+		}
+	}
+}
+
+int main(int argc, char* argv[])
+{
+	HSQUIRRELVM v;
+
+	const SQChar *filename=NULL;
+#if defined(_MSC_VER) && defined(_DEBUG)
+	_CrtSetAllocHook(MemAllocHook);
+#endif
+
+	v=sq_open(1024);
+	sq_setprintfunc(v,printfunc);
+
+	sq_pushroottable(v);
+
+	sqstd_register_bloblib(v);
+	sqstd_register_iolib(v);
+	sqstd_register_systemlib(v);
+	sqstd_register_mathlib(v);
+	sqstd_register_stringlib(v);
+
+	//aux library
+	//sets error handlers
+	sqstd_seterrorhandlers(v);
+
+	//gets arguments
+	switch(getargs(v,argc,argv))
+	{
+	case _INTERACTIVE:
+		Interactive(v);
+		break;
+	case _DONE:
+	default:
+		break;
+	}
+
+	sq_close(v);
+
+#if defined(_MSC_VER) && defined(_DEBUG)
+	_getch();
+	_CrtMemDumpAllObjectsSince( NULL );
+#endif
+	return 0;
+}
+
--- a/src/3rdparty/squirrel/sq/sq.dsp
+++ b/src/3rdparty/squirrel/sq/sq.dsp
@ -0,0 +1,101 @@
+# Microsoft Developer Studio Project File - Name="sq" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Console Application" 0x0103
+
+CFG=sq - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "sq.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "sq.mak" CFG="sq - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "sq - Win32 Release" (based on "Win32 (x86) Console Application")
+!MESSAGE "sq - Win32 Debug" (based on "Win32 (x86) Console Application")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_LocalPath ".."
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "sq - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /I "..\include" /I "..\sqstdlib" /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
+# ADD BASE RSC /l 0x410 /d "NDEBUG"
+# ADD RSC /l 0x410 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
+# ADD LINK32 squirrel.lib sqstdlib.lib /nologo /subsystem:console /machine:I386 /out:"../bin/sq.exe" /libpath:"../lib"
+
+!ELSEIF  "$(CFG)" == "sq - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Ignore_Export_Lib 0
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "..\include" /I "..\sqstdlib" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x410 /d "_DEBUG"
+# ADD RSC /l 0x410 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LINK32=link.exe
+# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
+# ADD LINK32 squirrel.lib sqstdlib.lib /nologo /subsystem:console /debug /machine:I386 /out:"../bin/sq.exe" /pdbtype:sept /libpath:"../lib"
+
+!ENDIF
+
+# Begin Target
+
+# Name "sq - Win32 Release"
+# Name "sq - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\sq.c
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# End Group
+# Begin Group "Resource Files"
+
+# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
+# End Group
+# End Target
+# End Project
--- a/src/3rdparty/squirrel/sqstdlib/Makefile
+++ b/src/3rdparty/squirrel/sqstdlib/Makefile
@ -0,0 +1,31 @@
+SQUIRREL= ..
+
+
+OUT= $(SQUIRREL)/lib/libsqstdlib.a
+INCZ= -I$(SQUIRREL)/include -I. -Iinclude
+
+SRCS= \
+	sqstdblob.cpp \
+	sqstdio.cpp \
+	sqstdstream.cpp \
+	sqstdmath.cpp \
+	sqstdsystem.cpp \
+	sqstdstring.cpp \
+	sqstdaux.cpp \
+	sqstdrex.cpp
+
+
+sq32:
+	gcc -O2  -fno-rtti -Wall -c $(SRCS) $(INCZ)
+	ar rc $(OUT) *.o
+
+sqprof:
+	gcc -O2 -pg -fno-rtti -pie -gstabs -g3 -Wall -c $(SRCS) $(INCZ)
+	ar rc $(OUT) *.o
+
+sq64:
+	gcc -O2 -D_SQ64 -fno-rtti -Wall -c $(SRCS) $(INCZ)
+	ar rc $(OUT) *.o
+
+clean:
+	rm -f $(OUT) $(SRCS:%.cpp=%.o)
--- a/src/3rdparty/squirrel/sqstdlib/sqstdaux.cpp
+++ b/src/3rdparty/squirrel/sqstdlib/sqstdaux.cpp
@ -0,0 +1,129 @@
+/* see copyright notice in squirrel.h */
+#include <squirrel.h>
+#include <sqstdaux.h>
+#include <assert.h>
+
+void sqstd_printcallstack(HSQUIRRELVM v)
+{
+	SQPRINTFUNCTION pf = sq_getprintfunc(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;
+		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("*FUNCTION [%s()] %s line [%d]\n"),fn,src,si.line);
+			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);
+					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;
+				case OT_BOOL:{
+					sq_getinteger(v,-1,&i);
+					pf(v,_SC("[%s] %s\n"),name,i?_SC("true"):_SC("false"));
+							 }
+					break;
+				default: assert(0); break;
+				}
+				sq_pop(v,1);
+			}
+		}
+	}
+}
+
+static SQInteger _sqstd_aux_printerror(HSQUIRRELVM v)
+{
+	SQPRINTFUNCTION pf = sq_getprintfunc(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_getprintfunc(v);
+	if(pf) {
+		pf(v,_SC("%s line = (%d) column = (%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);
+}
--- a/src/3rdparty/squirrel/sqstdlib/sqstdblob.cpp
+++ b/src/3rdparty/squirrel/sqstdlib/sqstdblob.cpp
@ -0,0 +1,251 @@
+/* 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)
+
+//Blob
+
+
+#define SETUP_BLOB(v) \
+	SQBlob *self = NULL; \
+	{ if(SQ_FAILED(sq_getinstanceup(v,1,(SQUserPointer*)&self,(SQUserPointer)SQSTD_BLOB_TYPE_TAG))) \
+		return SQ_ERROR; }
+
+
+static SQInteger _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 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 SQInteger _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 SQInteger _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 SQInteger _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 SQInteger _blob__get(HSQUIRRELVM v)
+{
+	SETUP_BLOB(v);
+	SQInteger idx;
+	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 SQInteger _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 SQInteger _blob__typeof(HSQUIRRELVM v)
+{
+	sq_pushstring(v,_SC("blob"),-1);
+	return 1;
+}
+
+static SQInteger _blob_releasehook(SQUserPointer p, SQInteger size)
+{
+	SQBlob *self = (SQBlob*)p;
+	delete self;
+	return 1;
+}
+
+static SQInteger _blob_constructor(HSQUIRRELVM v)
+{
+	SQInteger nparam = sq_gettop(v);
+	SQInteger size = 0;
+	if(nparam == 2) {
+		sq_getinteger(v, 2, &size);
+	}
+	if(size < 0) return sq_throwerror(v, _SC("cannot create blob with negative size"));
+	SQBlob *b = new SQBlob(size);
+	if(SQ_FAILED(sq_setinstanceup(v,1,b))) {
+		delete b;
+		return sq_throwerror(v, _SC("cannot create blob with negative size"));
+	}
+	sq_setreleasehook(v,1,_blob_releasehook);
+	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("xn")),
+	_DECL_BLOB_FUNC(resize,2,_SC("xn")),
+	_DECL_BLOB_FUNC(swap2,1,_SC("x")),
+	_DECL_BLOB_FUNC(swap4,1,_SC("x")),
+	_DECL_BLOB_FUNC(_set,3,_SC("xnn")),
+	_DECL_BLOB_FUNC(_get,2,_SC("xn")),
+	_DECL_BLOB_FUNC(_typeof,1,_SC("x")),
+	_DECL_BLOB_FUNC(_nexti,2,_SC("x")),
+	{0,0,0,0}
+};
+
+
+
+//GLOBAL FUNCTIONS
+
+static SQInteger _g_blob_casti2f(HSQUIRRELVM v)
+{
+	SQInteger i;
+	sq_getinteger(v,2,&i);
+	sq_pushfloat(v,*((SQFloat *)&i));
+	return 1;
+}
+
+static SQInteger _g_blob_castf2i(HSQUIRRELVM v)
+{
+	SQFloat f;
+	sq_getfloat(v,2,&f);
+	sq_pushinteger(v,*((SQInteger *)&f));
+	return 1;
+}
+
+static SQInteger _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 SQInteger _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 SQInteger _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")),
+	{0,0,0,0}
+};
+
+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();
+}
+
+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);
+}
+
--- a/src/3rdparty/squirrel/sqstdlib/sqstdblobimpl.h
+++ b/src/3rdparty/squirrel/sqstdlib/sqstdblobimpl.h
@ -0,0 +1,108 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQSTD_BLOBIMPL_H_
+#define _SQSTD_BLOBIMPL_H_
+
+struct SQBlob : public SQStream
+{
+	SQBlob(SQInteger size) {
+		_size = size;
+		_allocated = size;
+		_buf = (unsigned char *)sq_malloc(size);
+		memset(_buf, 0, _size);
+		_ptr = 0;
+		_owns = true;
+	}
+	virtual ~SQBlob() {
+		sq_free(_buf, _allocated);
+	}
+	SQInteger Write(void *buffer, SQInteger size) {
+		if(!CanAdvance(size)) {
+			GrowBufOf(_ptr + size - _size);
+		}
+		memcpy(&_buf[_ptr], buffer, size);
+		_ptr += size;
+		return size;
+	}
+	SQInteger 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;
+	}
+	bool 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 > _allocated)
+				_ptr = _allocated;
+		}
+		return true;
+	}
+	bool 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;
+	}
+	bool CanAdvance(SQInteger n) {
+		if(_ptr+n>_size)return false;
+		return true;
+	}
+	SQInteger 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 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; }
+private:
+	SQInteger _size;
+	SQInteger _allocated;
+	SQInteger _ptr;
+	unsigned char *_buf;
+	bool _owns;
+};
+
+#endif //_SQSTD_BLOBIMPL_H_
--- a/src/3rdparty/squirrel/sqstdlib/sqstdio.cpp
+++ b/src/3rdparty/squirrel/sqstdlib/sqstdio.cpp
@ -0,0 +1,410 @@
+/* see copyright notice in squirrel.h */
+#include <stdio.h>
+#include <squirrel.h>
+#include <new>
+#include <sqstdio.h>
+#include "sqstdstream.h"
+
+#define SQSTD_FILE_TYPE_TAG (SQSTD_STREAM_TYPE_TAG | 0x00000001)
+//basic API
+SQFILE sqstd_fopen(const SQChar *filename ,const SQChar *mode)
+{
+#ifndef SQUNICODE
+	return (SQFILE)fopen(filename,mode);
+#else
+	return (SQFILE)_wfopen(filename,mode);
+#endif
+}
+
+SQInteger sqstd_fread(void* buffer, SQInteger size, SQInteger count, SQFILE file)
+{
+	return (SQInteger)fread(buffer,size,count,(FILE *)file);
+}
+
+SQInteger sqstd_fwrite(const SQUserPointer buffer, SQInteger size, SQInteger count, SQFILE file)
+{
+	return (SQInteger)fwrite(buffer,size,count,(FILE *)file);
+}
+
+SQInteger sqstd_fseek(SQFILE file, SQInteger offset, SQInteger origin)
+{
+	SQInteger realorigin;
+	switch(origin) {
+		case SQ_SEEK_CUR: realorigin = SEEK_CUR; break;
+		case SQ_SEEK_END: realorigin = SEEK_END; break;
+		case SQ_SEEK_SET: realorigin = SEEK_SET; break;
+		default: return -1; //failed
+	}
+	return fseek((FILE *)file,(long)offset,(int)realorigin);
+}
+
+SQInteger sqstd_ftell(SQFILE file)
+{
+	return ftell((FILE *)file);
+}
+
+SQInteger sqstd_fflush(SQFILE file)
+{
+	return fflush((FILE *)file);
+}
+
+SQInteger sqstd_fclose(SQFILE file)
+{
+	return fclose((FILE *)file);
+}
+
+SQInteger sqstd_feof(SQFILE file)
+{
+	return feof((FILE *)file);
+}
+
+//File
+struct SQFile : public SQStream {
+	SQFile() { _handle = NULL; _owns = false;}
+	SQFile(SQFILE file, bool owns) { _handle = file; _owns = owns;}
+	virtual ~SQFile() { Close(); }
+	bool Open(const SQChar *filename ,const SQChar *mode) {
+		Close();
+		if( (_handle = sqstd_fopen(filename,mode)) ) {
+			_owns = true;
+			return true;
+		}
+		return false;
+	}
+	void Close() {
+		if(_handle && _owns) {
+			sqstd_fclose(_handle);
+			_handle = NULL;
+			_owns = false;
+		}
+	}
+	SQInteger Read(void *buffer,SQInteger size) {
+		return sqstd_fread(buffer,1,size,_handle);
+	}
+	SQInteger Write(void *buffer,SQInteger size) {
+		return sqstd_fwrite(buffer,1,size,_handle);
+	}
+	SQInteger Flush() {
+		return sqstd_fflush(_handle);
+	}
+	SQInteger Tell() {
+		return sqstd_ftell(_handle);
+	}
+	SQInteger Len() {
+		SQInteger prevpos=Tell();
+		Seek(0,SQ_SEEK_END);
+		SQInteger size=Tell();
+		Seek(prevpos,SQ_SEEK_SET);
+		return size;
+	}
+	SQInteger Seek(SQInteger offset, SQInteger origin)	{
+		return sqstd_fseek(_handle,offset,origin);
+	}
+	bool IsValid() { return _handle?true:false; }
+	bool EOS() { return Tell()==Len()?true:false;}
+	SQFILE GetHandle() {return _handle;}
+private:
+	SQFILE _handle;
+	bool _owns;
+};
+
+static SQInteger _file__typeof(HSQUIRRELVM v)
+{
+	sq_pushstring(v,_SC("file"),-1);
+	return 1;
+}
+
+static SQInteger _file_releasehook(SQUserPointer p, SQInteger size)
+{
+	SQFile *self = (SQFile*)p;
+	delete self;
+	return 1;
+}
+
+static SQInteger _file_constructor(HSQUIRRELVM v)
+{
+	const SQChar *filename,*mode;
+	bool owns = true;
+	SQFile *f;
+	SQFILE newf;
+	if(sq_gettype(v,2) == OT_STRING && sq_gettype(v,3) == OT_STRING) {
+		sq_getstring(v, 2, &filename);
+		sq_getstring(v, 3, &mode);
+		newf = sqstd_fopen(filename, mode);
+		if(!newf) return sq_throwerror(v, _SC("cannot open file"));
+	} else if(sq_gettype(v,2) == OT_USERPOINTER) {
+		owns = !(sq_gettype(v,3) == OT_NULL);
+		sq_getuserpointer(v,2,&newf);
+	} else {
+		return sq_throwerror(v,_SC("wrong parameter"));
+	}
+	f = new SQFile(newf,owns);
+	if(SQ_FAILED(sq_setinstanceup(v,1,f))) {
+		delete f;
+		return sq_throwerror(v, _SC("cannot create blob with negative size"));
+	}
+	sq_setreleasehook(v,1,_file_releasehook);
+	return 0;
+}
+
+//bindings
+#define _DECL_FILE_FUNC(name,nparams,typecheck) {_SC(#name),_file_##name,nparams,typecheck}
+static SQRegFunction _file_methods[] = {
+	_DECL_FILE_FUNC(constructor,3,_SC("x")),
+	_DECL_FILE_FUNC(_typeof,1,_SC("x")),
+	{0,0,0,0},
+};
+
+
+
+SQRESULT sqstd_createfile(HSQUIRRELVM v, SQFILE file,SQBool own)
+{
+	SQInteger top = sq_gettop(v);
+	sq_pushregistrytable(v);
+	sq_pushstring(v,_SC("std_file"),-1);
+	if(SQ_SUCCEEDED(sq_get(v,-2))) {
+		sq_remove(v,-2); //removes the registry
+		sq_pushroottable(v); // push the this
+		sq_pushuserpointer(v,file); //file
+		if(own){
+			sq_pushinteger(v,1); //true
+		}
+		else{
+			sq_pushnull(v); //false
+		}
+		if(SQ_SUCCEEDED( sq_call(v,3,SQTrue,SQFalse) )) {
+			sq_remove(v,-2);
+			return SQ_OK;
+		}
+	}
+	sq_settop(v,top);
+	return SQ_OK;
+}
+
+SQRESULT sqstd_getfile(HSQUIRRELVM v, SQInteger idx, SQFILE *file)
+{
+	SQFile *fileobj = NULL;
+	if(SQ_SUCCEEDED(sq_getinstanceup(v,idx,(SQUserPointer*)&fileobj,(SQUserPointer)SQSTD_FILE_TYPE_TAG))) {
+		*file = fileobj->GetHandle();
+		return SQ_OK;
+	}
+	return sq_throwerror(v,_SC("not a file"));
+}
+
+
+
+static SQInteger _io_file_lexfeed_ASCII(SQUserPointer file)
+{
+	SQInteger ret;
+	char c;
+	if( ( ret=sqstd_fread(&c,sizeof(c),1,(FILE *)file )>0) )
+		return c;
+	return 0;
+}
+
+static SQInteger _io_file_lexfeed_UTF8(SQUserPointer file)
+{
+#define READ() \
+	if(sqstd_fread(&inchar,sizeof(inchar),1,(FILE *)file) != 1) \
+		return 0;
+
+	static const SQInteger utf8_lengths[16] =
+	{
+		1,1,1,1,1,1,1,1,        /* 0000 to 0111 : 1 byte (plain ASCII) */
+		0,0,0,0,                /* 1000 to 1011 : not valid */
+		2,2,                    /* 1100, 1101 : 2 bytes */
+		3,                      /* 1110 : 3 bytes */
+		4                       /* 1111 :4 bytes */
+	};
+	static unsigned char byte_masks[5] = {0,0,0x1f,0x0f,0x07};
+	unsigned char inchar;
+	SQInteger c = 0;
+	READ();
+	c = inchar;
+	//
+	if(c >= 0x80) {
+		SQInteger tmp;
+		SQInteger codelen = utf8_lengths[c>>4];
+		if(codelen == 0)
+			return 0;
+			//"invalid UTF-8 stream";
+		tmp = c&byte_masks[codelen];
+		for(SQInteger n = 0; n < codelen-1; n++) {
+			tmp<<=6;
+			READ();
+			tmp |= inchar & 0x3F;
+		}
+		c = tmp;
+	}
+	return c;
+}
+
+static SQInteger _io_file_lexfeed_UCS2_LE(SQUserPointer file)
+{
+	SQInteger ret;
+	wchar_t c;
+	if( ( ret=sqstd_fread(&c,sizeof(c),1,(FILE *)file )>0) )
+		return (SQChar)c;
+	return 0;
+}
+
+static SQInteger _io_file_lexfeed_UCS2_BE(SQUserPointer file)
+{
+	SQInteger ret;
+	unsigned short c;
+	if( ( ret=sqstd_fread(&c,sizeof(c),1,(FILE *)file )>0) ) {
+		c = ((c>>8)&0x00FF)| ((c<<8)&0xFF00);
+		return (SQChar)c;
+	}
+	return 0;
+}
+
+SQInteger file_read(SQUserPointer file,SQUserPointer buf,SQInteger size)
+{
+	SQInteger ret;
+	if( ( ret = sqstd_fread(buf,1,size,(SQFILE)file ))!=0 )return ret;
+	return -1;
+}
+
+SQInteger file_write(SQUserPointer file,SQUserPointer p,SQInteger size)
+{
+	return sqstd_fwrite(p,1,size,(SQFILE)file);
+}
+
+SQRESULT sqstd_loadfile(HSQUIRRELVM v,const SQChar *filename,SQBool printerror)
+{
+	SQFILE file = sqstd_fopen(filename,_SC("rb"));
+	SQInteger ret;
+	unsigned short us;
+	unsigned char uc;
+	SQLEXREADFUNC func = _io_file_lexfeed_ASCII;
+	if(file){
+		ret = sqstd_fread(&us,1,2,file);
+		if(ret != 2) {
+			//probably an empty file
+			us = 0;
+		}
+		if(us == SQ_BYTECODE_STREAM_TAG) { //BYTECODE
+			sqstd_fseek(file,0,SQ_SEEK_SET);
+			if(SQ_SUCCEEDED(sq_readclosure(v,file_read,file))) {
+				sqstd_fclose(file);
+				return SQ_OK;
+			}
+		}
+		else { //SCRIPT
+			switch(us)
+			{
+				//gotta swap the next 2 lines on BIG endian machines
+				case 0xFFFE: func = _io_file_lexfeed_UCS2_BE; break;//UTF-16 little endian;
+				case 0xFEFF: func = _io_file_lexfeed_UCS2_LE; break;//UTF-16 big endian;
+				case 0xBBEF:
+					if(sqstd_fread(&uc,1,sizeof(uc),file) == 0) {
+						sqstd_fclose(file);
+						return sq_throwerror(v,_SC("io error"));
+					}
+					if(uc != 0xBF) {
+						sqstd_fclose(file);
+						return sq_throwerror(v,_SC("Unrecognozed ecoding"));
+					}
+					func = _io_file_lexfeed_UTF8;
+					break;//UTF-8 ;
+				default: sqstd_fseek(file,0,SQ_SEEK_SET); break; // ascii
+			}
+
+			if(SQ_SUCCEEDED(sq_compile(v,func,file,filename,printerror))){
+				sqstd_fclose(file);
+				return SQ_OK;
+			}
+		}
+		sqstd_fclose(file);
+		return SQ_ERROR;
+	}
+	return sq_throwerror(v,_SC("cannot open the file"));
+}
+
+SQRESULT sqstd_dofile(HSQUIRRELVM v,const SQChar *filename,SQBool retval,SQBool printerror)
+{
+	if(SQ_SUCCEEDED(sqstd_loadfile(v,filename,printerror))) {
+		sq_push(v,-2);
+		if(SQ_SUCCEEDED(sq_call(v,1,retval,SQTrue))) {
+			sq_remove(v,retval?-2:-1); //removes the closure
+			return 1;
+		}
+		sq_pop(v,1); //removes the closure
+	}
+	return SQ_ERROR;
+}
+
+SQRESULT sqstd_writeclosuretofile(HSQUIRRELVM v,const SQChar *filename)
+{
+	SQFILE file = sqstd_fopen(filename,_SC("wb+"));
+	if(!file) return sq_throwerror(v,_SC("cannot open the file"));
+	if(SQ_SUCCEEDED(sq_writeclosure(v,file_write,file))) {
+		sqstd_fclose(file);
+		return SQ_OK;
+	}
+	sqstd_fclose(file);
+	return SQ_ERROR; //forward the error
+}
+
+SQInteger _g_io_loadfile(HSQUIRRELVM v)
+{
+	const SQChar *filename;
+	SQBool printerror = SQFalse;
+	sq_getstring(v,2,&filename);
+	if(sq_gettop(v) >= 3) {
+		sq_getbool(v,3,&printerror);
+	}
+	if(SQ_SUCCEEDED(sqstd_loadfile(v,filename,printerror)))
+		return 1;
+	return SQ_ERROR; //propagates the error
+}
+
+SQInteger _g_io_writeclosuretofile(HSQUIRRELVM v)
+{
+	const SQChar *filename;
+	sq_getstring(v,2,&filename);
+	if(SQ_SUCCEEDED(sqstd_writeclosuretofile(v,filename)))
+		return 1;
+	return SQ_ERROR; //propagates the error
+}
+
+SQInteger _g_io_dofile(HSQUIRRELVM v)
+{
+	const SQChar *filename;
+	SQBool printerror = SQFalse;
+	sq_getstring(v,2,&filename);
+	if(sq_gettop(v) >= 3) {
+		sq_getbool(v,3,&printerror);
+	}
+	sq_push(v,1); //repush the this
+	if(SQ_SUCCEEDED(sqstd_dofile(v,filename,SQTrue,printerror)))
+		return 1;
+	return SQ_ERROR; //propagates the error
+}
+
+#define _DECL_GLOBALIO_FUNC(name,nparams,typecheck) {_SC(#name),_g_io_##name,nparams,typecheck}
+static SQRegFunction iolib_funcs[]={
+	_DECL_GLOBALIO_FUNC(loadfile,-2,_SC(".sb")),
+	_DECL_GLOBALIO_FUNC(dofile,-2,_SC(".sb")),
+	_DECL_GLOBALIO_FUNC(writeclosuretofile,3,_SC(".sc")),
+	{0,0,0,0}
+};
+
+SQRESULT sqstd_register_iolib(HSQUIRRELVM v)
+{
+	SQInteger top = sq_gettop(v);
+	//create delegate
+	declare_stream(v,_SC("file"),(SQUserPointer)SQSTD_FILE_TYPE_TAG,_SC("std_file"),_file_methods,iolib_funcs);
+	sq_pushstring(v,_SC("stdout"),-1);
+	sqstd_createfile(v,stdout,SQFalse);
+	sq_createslot(v,-3);
+	sq_pushstring(v,_SC("stdin"),-1);
+	sqstd_createfile(v,stdin,SQFalse);
+	sq_createslot(v,-3);
+	sq_pushstring(v,_SC("stderr"),-1);
+	sqstd_createfile(v,stderr,SQFalse);
+	sq_createslot(v,-3);
+	sq_settop(v,top);
+	return SQ_OK;
+}
--- a/src/3rdparty/squirrel/sqstdlib/sqstdlib.dsp
+++ b/src/3rdparty/squirrel/sqstdlib/sqstdlib.dsp
@ -0,0 +1,131 @@
+# Microsoft Developer Studio Project File - Name="sqstdlib" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=sqstdlib - Win32 Release
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "sqstdlib.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "sqstdlib.mak" CFG="sqstdlib - Win32 Release"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "sqstdlib - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "sqstdlib - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_LocalPath ".."
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "sqstdlib - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /I "..\include" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD BASE RSC /l 0x410 /d "NDEBUG"
+# ADD RSC /l 0x410 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\lib\sqstdlib.lib"
+
+!ELSEIF  "$(CFG)" == "sqstdlib - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "..\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x410 /d "_DEBUG"
+# ADD RSC /l 0x410 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\lib\sqstdlib.lib"
+
+!ENDIF
+
+# Begin Target
+
+# Name "sqstdlib - Win32 Release"
+# Name "sqstdlib - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\sqstdblob.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqstdio.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqstdmath.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqstdrex.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqstdstream.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqstdstring.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqstdaux.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqstdsystem.cpp
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\sqstdblobimpl.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqstdstream.h
+# End Source File
+# End Group
+# End Target
+# End Project
--- a/src/3rdparty/squirrel/sqstdlib/sqstdmath.cpp
+++ b/src/3rdparty/squirrel/sqstdlib/sqstdmath.cpp
@ -0,0 +1,106 @@
+/* see copyright notice in squirrel.h */
+#include <squirrel.h>
+#include <math.h>
+#include <stdlib.h>
+#include <sqstdmath.h>
+
+#define SINGLE_ARG_FUNC(_funcname) static SQInteger math_##_funcname(HSQUIRRELVM v){ \
+	SQFloat f; \
+	sq_getfloat(v,2,&f); \
+	sq_pushfloat(v,(SQFloat)_funcname(f)); \
+	return 1; \
+}
+
+#define TWO_ARGS_FUNC(_funcname) static SQInteger math_##_funcname(HSQUIRRELVM v){ \
+	SQFloat p1,p2; \
+	sq_getfloat(v,2,&p1); \
+	sq_getfloat(v,3,&p2); \
+	sq_pushfloat(v,(SQFloat)_funcname(p1,p2)); \
+	return 1; \
+}
+
+static SQInteger math_srand(HSQUIRRELVM v)
+{
+	SQInteger i;
+	if(SQ_FAILED(sq_getinteger(v,2,&i)))
+		return sq_throwerror(v,_SC("invalid param"));
+	srand((unsigned int)i);
+	return 0;
+}
+
+static SQInteger math_rand(HSQUIRRELVM v)
+{
+	sq_pushinteger(v,rand());
+	return 1;
+}
+
+static SQInteger math_abs(HSQUIRRELVM v)
+{
+	SQInteger n;
+	sq_getinteger(v,2,&n);
+	sq_pushinteger(v,(SQInteger)abs((int)n));
+	return 1;
+}
+
+SINGLE_ARG_FUNC(sqrt)
+SINGLE_ARG_FUNC(fabs)
+SINGLE_ARG_FUNC(sin)
+SINGLE_ARG_FUNC(cos)
+SINGLE_ARG_FUNC(asin)
+SINGLE_ARG_FUNC(acos)
+SINGLE_ARG_FUNC(log)
+SINGLE_ARG_FUNC(log10)
+SINGLE_ARG_FUNC(tan)
+SINGLE_ARG_FUNC(atan)
+TWO_ARGS_FUNC(atan2)
+TWO_ARGS_FUNC(pow)
+SINGLE_ARG_FUNC(floor)
+SINGLE_ARG_FUNC(ceil)
+SINGLE_ARG_FUNC(exp)
+
+#define _DECL_FUNC(name,nparams,tycheck) {_SC(#name),math_##name,nparams,tycheck}
+static SQRegFunction mathlib_funcs[] = {
+	_DECL_FUNC(sqrt,2,_SC(".n")),
+	_DECL_FUNC(sin,2,_SC(".n")),
+	_DECL_FUNC(cos,2,_SC(".n")),
+	_DECL_FUNC(asin,2,_SC(".n")),
+	_DECL_FUNC(acos,2,_SC(".n")),
+	_DECL_FUNC(log,2,_SC(".n")),
+	_DECL_FUNC(log10,2,_SC(".n")),
+	_DECL_FUNC(tan,2,_SC(".n")),
+	_DECL_FUNC(atan,2,_SC(".n")),
+	_DECL_FUNC(atan2,3,_SC(".nn")),
+	_DECL_FUNC(pow,3,_SC(".nn")),
+	_DECL_FUNC(floor,2,_SC(".n")),
+	_DECL_FUNC(ceil,2,_SC(".n")),
+	_DECL_FUNC(exp,2,_SC(".n")),
+	_DECL_FUNC(srand,2,_SC(".n")),
+	_DECL_FUNC(rand,1,NULL),
+	_DECL_FUNC(fabs,2,_SC(".n")),
+	_DECL_FUNC(abs,2,_SC(".n")),
+	{0,0,0,0},
+};
+
+#ifndef M_PI
+#define M_PI (3.14159265358979323846)
+#endif
+
+SQRESULT sqstd_register_mathlib(HSQUIRRELVM v)
+{
+	SQInteger i=0;
+	while(mathlib_funcs[i].name!=0)	{
+		sq_pushstring(v,mathlib_funcs[i].name,-1);
+		sq_newclosure(v,mathlib_funcs[i].f,0);
+		sq_setparamscheck(v,mathlib_funcs[i].nparamscheck,mathlib_funcs[i].typemask);
+		sq_setnativeclosurename(v,-1,mathlib_funcs[i].name);
+		sq_createslot(v,-3);
+		i++;
+	}
+	sq_pushstring(v,_SC("RAND_MAX"),-1);
+	sq_pushinteger(v,RAND_MAX);
+	sq_createslot(v,-3);
+	sq_pushstring(v,_SC("PI"),-1);
+	sq_pushfloat(v,(SQFloat)M_PI);
+	sq_createslot(v,-3);
+	return SQ_OK;
+}
--- a/src/3rdparty/squirrel/sqstdlib/sqstdrex.cpp
+++ b/src/3rdparty/squirrel/sqstdlib/sqstdrex.cpp
@ -0,0 +1,635 @@
+/* see copyright notice in squirrel.h */
+#include <squirrel.h>
+#include <string.h>
+#include <ctype.h>
+#include <exception>
+#include "sqstdstring.h"
+
+#ifdef _UNICODE
+#define scisprint iswprint
+#else
+#define scisprint isprint
+#endif
+
+#ifdef _DEBUG
+#include <stdio.h>
+
+static const SQChar *g_nnames[] =
+{
+	_SC("NONE"),_SC("OP_GREEDY"),	_SC("OP_OR"),
+	_SC("OP_EXPR"),_SC("OP_NOCAPEXPR"),_SC("OP_DOT"),	_SC("OP_CLASS"),
+	_SC("OP_CCLASS"),_SC("OP_NCLASS"),_SC("OP_RANGE"),_SC("OP_CHAR"),
+	_SC("OP_EOL"),_SC("OP_BOL"),_SC("OP_WB")
+};
+
+#endif
+
+#define OP_GREEDY		(MAX_CHAR+1) // * + ? {n}
+#define OP_OR			(MAX_CHAR+2)
+#define OP_EXPR			(MAX_CHAR+3) //parentesis ()
+#define OP_NOCAPEXPR	(MAX_CHAR+4) //parentesis (?:)
+#define OP_DOT			(MAX_CHAR+5)
+#define OP_CLASS		(MAX_CHAR+6)
+#define OP_CCLASS		(MAX_CHAR+7)
+#define OP_NCLASS		(MAX_CHAR+8) //negates class the [^
+#define OP_RANGE		(MAX_CHAR+9)
+#define OP_CHAR			(MAX_CHAR+10)
+#define OP_EOL			(MAX_CHAR+11)
+#define OP_BOL			(MAX_CHAR+12)
+#define OP_WB			(MAX_CHAR+13)
+
+#define SQREX_SYMBOL_ANY_CHAR ('.')
+#define SQREX_SYMBOL_GREEDY_ONE_OR_MORE ('+')
+#define SQREX_SYMBOL_GREEDY_ZERO_OR_MORE ('*')
+#define SQREX_SYMBOL_GREEDY_ZERO_OR_ONE ('?')
+#define SQREX_SYMBOL_BRANCH ('|')
+#define SQREX_SYMBOL_END_OF_STRING ('$')
+#define SQREX_SYMBOL_BEGINNING_OF_STRING ('^')
+#define SQREX_SYMBOL_ESCAPE_CHAR ('\\')
+
+
+typedef int SQRexNodeType;
+
+typedef struct tagSQRexNode{
+	SQRexNodeType type;
+	SQInteger left;
+	SQInteger right;
+	SQInteger next;
+}SQRexNode;
+
+struct SQRex{
+	const SQChar *_eol;
+	const SQChar *_bol;
+	const SQChar *_p;
+	SQInteger _first;
+	SQInteger _op;
+	SQRexNode *_nodes;
+	SQInteger _nallocated;
+	SQInteger _nsize;
+	SQInteger _nsubexpr;
+	SQRexMatch *_matches;
+	SQInteger _currsubexp;
+	const SQChar **_error;
+};
+
+static SQInteger sqstd_rex_list(SQRex *exp);
+
+static SQInteger sqstd_rex_newnode(SQRex *exp, SQRexNodeType type)
+{
+	SQRexNode n;
+	n.type = type;
+	n.next = n.right = n.left = -1;
+	if(type == OP_EXPR)
+		n.right = exp->_nsubexpr++;
+	if(exp->_nallocated < (exp->_nsize + 1)) {
+		SQInteger oldsize = exp->_nallocated;
+		exp->_nallocated *= 2;
+		exp->_nodes = (SQRexNode *)sq_realloc(exp->_nodes, oldsize * sizeof(SQRexNode) ,exp->_nallocated * sizeof(SQRexNode));
+	}
+	exp->_nodes[exp->_nsize++] = n;
+	SQInteger newid = exp->_nsize - 1;
+	return (SQInteger)newid;
+}
+
+static void sqstd_rex_error(SQRex *exp,const SQChar *error)
+{
+	if(exp->_error) *exp->_error = error;
+	throw std::exception();
+}
+
+static void sqstd_rex_expect(SQRex *exp, SQChar n){
+	if((*exp->_p) != n)
+		sqstd_rex_error(exp, _SC("expected paren"));
+	exp->_p++;
+}
+
+static SQChar sqstd_rex_escapechar(SQRex *exp)
+{
+	if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR){
+		exp->_p++;
+		switch(*exp->_p) {
+		case 'v': exp->_p++; return '\v';
+		case 'n': exp->_p++; return '\n';
+		case 't': exp->_p++; return '\t';
+		case 'r': exp->_p++; return '\r';
+		case 'f': exp->_p++; return '\f';
+		default: return (*exp->_p++);
+		}
+	} else if(!scisprint(*exp->_p)) sqstd_rex_error(exp,_SC("letter expected"));
+	return (*exp->_p++);
+}
+
+static SQInteger sqstd_rex_charclass(SQRex *exp,SQInteger classid)
+{
+	SQInteger n = sqstd_rex_newnode(exp,OP_CCLASS);
+	exp->_nodes[n].left = classid;
+	return n;
+}
+
+static SQInteger sqstd_rex_charnode(SQRex *exp,SQBool isclass)
+{
+	SQChar t;
+	if(*exp->_p == SQREX_SYMBOL_ESCAPE_CHAR) {
+		exp->_p++;
+		switch(*exp->_p) {
+			case 'n': exp->_p++; return sqstd_rex_newnode(exp,'\n');
+			case 't': exp->_p++; return sqstd_rex_newnode(exp,'\t');
+			case 'r': exp->_p++; return sqstd_rex_newnode(exp,'\r');
+			case 'f': exp->_p++; return sqstd_rex_newnode(exp,'\f');
+			case 'v': exp->_p++; return sqstd_rex_newnode(exp,'\v');
+			case 'a': case 'A': case 'w': case 'W': case 's': case 'S':
+			case 'd': case 'D': case 'x': case 'X': case 'c': case 'C':
+			case 'p': case 'P': case 'l': case 'u':
+				{
+				t = *exp->_p; exp->_p++;
+				return sqstd_rex_charclass(exp,t);
+				}
+			case 'b':
+			case 'B':
+				if(!isclass) {
+					SQInteger node = sqstd_rex_newnode(exp,OP_WB);
+					exp->_nodes[node].left = *exp->_p;
+					exp->_p++;
+					return node;
+				} //else default
+			default:
+				t = *exp->_p; exp->_p++;
+				return sqstd_rex_newnode(exp,t);
+		}
+	}
+	else if(!scisprint(*exp->_p)) {
+
+		sqstd_rex_error(exp,_SC("letter expected"));
+	}
+	t = *exp->_p; exp->_p++;
+	return sqstd_rex_newnode(exp,t);
+}
+static SQInteger sqstd_rex_class(SQRex *exp)
+{
+	SQInteger ret = -1;
+	SQInteger first = -1,chain;
+	if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING){
+		ret = sqstd_rex_newnode(exp,OP_NCLASS);
+		exp->_p++;
+	}else ret = sqstd_rex_newnode(exp,OP_CLASS);
+
+	if(*exp->_p == ']') sqstd_rex_error(exp,_SC("empty class"));
+	chain = ret;
+	while(*exp->_p != ']' && exp->_p != exp->_eol) {
+		if(*exp->_p == '-' && first != -1){
+			SQInteger r;
+			if(*exp->_p++ == ']') sqstd_rex_error(exp,_SC("unfinished range"));
+			r = sqstd_rex_newnode(exp,OP_RANGE);
+			if((SQChar)first>*exp->_p) sqstd_rex_error(exp,_SC("invalid range"));
+			if(exp->_nodes[first].type == OP_CCLASS) sqstd_rex_error(exp,_SC("cannot use character classes in ranges"));
+			exp->_nodes[r].left = exp->_nodes[first].type;
+			SQInteger t = sqstd_rex_escapechar(exp);
+			exp->_nodes[r].right = t;
+            exp->_nodes[chain].next = r;
+			chain = r;
+			first = -1;
+		}
+		else{
+			if(first!=-1){
+				SQInteger c = first;
+				exp->_nodes[chain].next = c;
+				chain = c;
+				first = sqstd_rex_charnode(exp,SQTrue);
+			}
+			else{
+				first = sqstd_rex_charnode(exp,SQTrue);
+			}
+		}
+	}
+	if(first!=-1){
+		SQInteger c = first;
+		exp->_nodes[chain].next = c;
+		chain = c;
+		first = -1;
+	}
+	/* hack? */
+	exp->_nodes[ret].left = exp->_nodes[ret].next;
+	exp->_nodes[ret].next = -1;
+	return ret;
+}
+
+static SQInteger sqstd_rex_parsenumber(SQRex *exp)
+{
+	SQInteger ret = *exp->_p-'0';
+	SQInteger positions = 10;
+	exp->_p++;
+	while(isdigit(*exp->_p)) {
+		ret = ret*10+(*exp->_p++-'0');
+		if(positions==1000000000) sqstd_rex_error(exp,_SC("overflow in numeric constant"));
+		positions *= 10;
+	};
+	return ret;
+}
+
+static SQInteger sqstd_rex_element(SQRex *exp)
+{
+	SQInteger ret = -1;
+	switch(*exp->_p)
+	{
+	case '(': {
+		SQInteger expr;
+		exp->_p++;
+
+
+		if(*exp->_p =='?') {
+			exp->_p++;
+			sqstd_rex_expect(exp,_SC(':'));
+			expr = sqstd_rex_newnode(exp,OP_NOCAPEXPR);
+		}
+		else
+			expr = sqstd_rex_newnode(exp,OP_EXPR);
+		SQInteger newn = sqstd_rex_list(exp);
+		exp->_nodes[expr].left = newn;
+		ret = expr;
+		sqstd_rex_expect(exp,_SC(')'));
+			  }
+			  break;
+	case '[':
+		exp->_p++;
+		ret = sqstd_rex_class(exp);
+		sqstd_rex_expect(exp,_SC(']'));
+		break;
+	case SQREX_SYMBOL_END_OF_STRING: exp->_p++; ret = sqstd_rex_newnode(exp,OP_EOL);break;
+	case SQREX_SYMBOL_ANY_CHAR: exp->_p++; ret = sqstd_rex_newnode(exp,OP_DOT);break;
+	default:
+		ret = sqstd_rex_charnode(exp,SQFalse);
+		break;
+	}
+
+
+	SQInteger op;
+	SQBool isgreedy = SQFalse;
+	unsigned short p0 = 0, p1 = 0;
+	switch(*exp->_p){
+		case SQREX_SYMBOL_GREEDY_ZERO_OR_MORE: p0 = 0; p1 = 0xFFFF; exp->_p++; isgreedy = SQTrue; break;
+		case SQREX_SYMBOL_GREEDY_ONE_OR_MORE: p0 = 1; p1 = 0xFFFF; exp->_p++; isgreedy = SQTrue; break;
+		case SQREX_SYMBOL_GREEDY_ZERO_OR_ONE: p0 = 0; p1 = 1; exp->_p++; isgreedy = SQTrue; break;
+		case '{':
+			exp->_p++;
+			if(!isdigit(*exp->_p)) sqstd_rex_error(exp,_SC("number expected"));
+			p0 = (unsigned short)sqstd_rex_parsenumber(exp);
+			/*******************************/
+			switch(*exp->_p) {
+		case '}':
+			p1 = p0; exp->_p++;
+			break;
+		case ',':
+			exp->_p++;
+			p1 = 0xFFFF;
+			if(isdigit(*exp->_p)){
+				p1 = (unsigned short)sqstd_rex_parsenumber(exp);
+			}
+			sqstd_rex_expect(exp,_SC('}'));
+			break;
+		default:
+			sqstd_rex_error(exp,_SC(", or } expected"));
+			}
+			/*******************************/
+			isgreedy = SQTrue;
+			break;
+
+	}
+	if(isgreedy) {
+		SQInteger nnode = sqstd_rex_newnode(exp,OP_GREEDY);
+		op = OP_GREEDY;
+		exp->_nodes[nnode].left = ret;
+		exp->_nodes[nnode].right = ((p0)<<16)|p1;
+		ret = nnode;
+	}
+
+	if((*exp->_p != SQREX_SYMBOL_BRANCH) && (*exp->_p != ')') && (*exp->_p != SQREX_SYMBOL_GREEDY_ZERO_OR_MORE) && (*exp->_p != SQREX_SYMBOL_GREEDY_ONE_OR_MORE) && (*exp->_p != '\0')) {
+		SQInteger nnode = sqstd_rex_element(exp);
+		exp->_nodes[ret].next = nnode;
+	}
+
+	return ret;
+}
+
+static SQInteger sqstd_rex_list(SQRex *exp)
+{
+	SQInteger ret=-1,e;
+	if(*exp->_p == SQREX_SYMBOL_BEGINNING_OF_STRING) {
+		exp->_p++;
+		ret = sqstd_rex_newnode(exp,OP_BOL);
+	}
+	e = sqstd_rex_element(exp);
+	if(ret != -1) {
+		exp->_nodes[ret].next = e;
+	}
+	else ret = e;
+
+	if(*exp->_p == SQREX_SYMBOL_BRANCH) {
+		SQInteger temp,tright;
+		exp->_p++;
+		temp = sqstd_rex_newnode(exp,OP_OR);
+		exp->_nodes[temp].left = ret;
+		tright = sqstd_rex_list(exp);
+		exp->_nodes[temp].right = tright;
+		ret = temp;
+	}
+	return ret;
+}
+
+static SQBool sqstd_rex_matchcclass(SQInteger cclass,SQChar c)
+{
+	switch(cclass) {
+	case 'a': return isalpha(c)?SQTrue:SQFalse;
+	case 'A': return !isalpha(c)?SQTrue:SQFalse;
+	case 'w': return (isalnum(c) || c == '_')?SQTrue:SQFalse;
+	case 'W': return (!isalnum(c) && c != '_')?SQTrue:SQFalse;
+	case 's': return isspace(c)?SQTrue:SQFalse;
+	case 'S': return !isspace(c)?SQTrue:SQFalse;
+	case 'd': return isdigit(c)?SQTrue:SQFalse;
+	case 'D': return !isdigit(c)?SQTrue:SQFalse;
+	case 'x': return isxdigit(c)?SQTrue:SQFalse;
+	case 'X': return !isxdigit(c)?SQTrue:SQFalse;
+	case 'c': return iscntrl(c)?SQTrue:SQFalse;
+	case 'C': return !iscntrl(c)?SQTrue:SQFalse;
+	case 'p': return ispunct(c)?SQTrue:SQFalse;
+	case 'P': return !ispunct(c)?SQTrue:SQFalse;
+	case 'l': return islower(c)?SQTrue:SQFalse;
+	case 'u': return isupper(c)?SQTrue:SQFalse;
+	}
+	return SQFalse; /*cannot happen*/
+}
+
+static SQBool sqstd_rex_matchclass(SQRex* exp,SQRexNode *node,SQInteger c)
+{
+	do {
+		switch(node->type) {
+			case OP_RANGE:
+				if(c >= node->left && c <= node->right) return SQTrue;
+				break;
+			case OP_CCLASS:
+				if(sqstd_rex_matchcclass(node->left,c)) return SQTrue;
+				break;
+			default:
+				if(c == node->type)return SQTrue;
+		}
+	} while((node->next != -1) && (node = &exp->_nodes[node->next]));
+	return SQFalse;
+}
+
+static const SQChar *sqstd_rex_matchnode(SQRex* exp,SQRexNode *node,const SQChar *str,SQRexNode *next)
+{
+
+	SQRexNodeType type = node->type;
+	switch(type) {
+	case OP_GREEDY: {
+		//SQRexNode *greedystop = (node->next != -1) ? &exp->_nodes[node->next] : NULL;
+		SQRexNode *greedystop = NULL;
+		SQInteger p0 = (node->right >> 16)&0x0000FFFF, p1 = node->right&0x0000FFFF, nmaches = 0;
+		const SQChar *s=str, *good = str;
+
+		if(node->next != -1) {
+			greedystop = &exp->_nodes[node->next];
+		}
+		else {
+			greedystop = next;
+		}
+
+		while((nmaches == 0xFFFF || nmaches < p1)) {
+
+			const SQChar *stop;
+			if(!(s = sqstd_rex_matchnode(exp,&exp->_nodes[node->left],s,greedystop)))
+				break;
+			nmaches++;
+			good=s;
+			if(greedystop) {
+				//checks that 0 matches satisfy the expression(if so skips)
+				//if not would always stop(for instance if is a '?')
+				if(greedystop->type != OP_GREEDY ||
+				(greedystop->type == OP_GREEDY && ((greedystop->right >> 16)&0x0000FFFF) != 0))
+				{
+					SQRexNode *gnext = NULL;
+					if(greedystop->next != -1) {
+						gnext = &exp->_nodes[greedystop->next];
+					}else if(next && next->next != -1){
+						gnext = &exp->_nodes[next->next];
+					}
+					stop = sqstd_rex_matchnode(exp,greedystop,s,gnext);
+					if(stop) {
+						//if satisfied stop it
+						if(p0 == p1 && p0 == nmaches) break;
+						else if(nmaches >= p0 && p1 == 0xFFFF) break;
+						else if(nmaches >= p0 && nmaches <= p1) break;
+					}
+				}
+			}
+
+			if(s >= exp->_eol)
+				break;
+		}
+		if(p0 == p1 && p0 == nmaches) return good;
+		else if(nmaches >= p0 && p1 == 0xFFFF) return good;
+		else if(nmaches >= p0 && nmaches <= p1) return good;
+		return NULL;
+	}
+	case OP_OR: {
+			const SQChar *asd = str;
+			SQRexNode *temp=&exp->_nodes[node->left];
+			while( (asd = sqstd_rex_matchnode(exp,temp,asd,NULL)) ) {
+				if(temp->next != -1)
+					temp = &exp->_nodes[temp->next];
+				else
+					return asd;
+			}
+			asd = str;
+			temp = &exp->_nodes[node->right];
+			while( (asd = sqstd_rex_matchnode(exp,temp,asd,NULL)) ) {
+				if(temp->next != -1)
+					temp = &exp->_nodes[temp->next];
+				else
+					return asd;
+			}
+			return NULL;
+			break;
+	}
+	case OP_EXPR:
+	case OP_NOCAPEXPR:{
+			SQRexNode *n = &exp->_nodes[node->left];
+			const SQChar *cur = str;
+			SQInteger capture = -1;
+			if(node->type != OP_NOCAPEXPR && node->right == exp->_currsubexp) {
+				capture = exp->_currsubexp;
+				exp->_matches[capture].begin = cur;
+				exp->_currsubexp++;
+			}
+
+			do {
+				SQRexNode *subnext = NULL;
+				if(n->next != -1) {
+					subnext = &exp->_nodes[n->next];
+				}else {
+					subnext = next;
+				}
+				if(!(cur = sqstd_rex_matchnode(exp,n,cur,subnext))) {
+					if(capture != -1){
+						exp->_matches[capture].begin = 0;
+						exp->_matches[capture].len = 0;
+					}
+					return NULL;
+				}
+			} while((n->next != -1) && (n = &exp->_nodes[n->next]));
+
+			if(capture != -1)
+				exp->_matches[capture].len = cur - exp->_matches[capture].begin;
+			return cur;
+	}
+	case OP_WB:
+		if((str == exp->_bol && !isspace(*str))
+		 || (str == exp->_eol && !isspace(*(str-1)))
+		 || (!isspace(*str) && isspace(*(str+1)))
+		 || (isspace(*str) && !isspace(*(str+1))) ) {
+			return (node->left == 'b')?str:NULL;
+		}
+		return (node->left == 'b')?NULL:str;
+	case OP_BOL:
+		if(str == exp->_bol) return str;
+		return NULL;
+	case OP_EOL:
+		if(str == exp->_eol) return str;
+		return NULL;
+	case OP_DOT:{
+		*str++;
+				}
+		return str;
+	case OP_NCLASS:
+	case OP_CLASS:
+		if(sqstd_rex_matchclass(exp,&exp->_nodes[node->left],*str)?(type == OP_CLASS?SQTrue:SQFalse):(type == OP_NCLASS?SQTrue:SQFalse)) {
+			*str++;
+			return str;
+		}
+		return NULL;
+	case OP_CCLASS:
+		if(sqstd_rex_matchcclass(node->left,*str)) {
+			*str++;
+			return str;
+		}
+		return NULL;
+	default: /* char */
+		if(*str != (SQChar)node->type) return NULL;
+		*str++;
+		return str;
+	}
+	return NULL;
+}
+
+/* public api */
+SQRex *sqstd_rex_compile(const SQChar *pattern,const SQChar **error)
+{
+	SQRex *exp = (SQRex *)sq_malloc(sizeof(SQRex));
+	exp->_eol = exp->_bol = NULL;
+	exp->_p = pattern;
+	exp->_nallocated = (SQInteger)scstrlen(pattern) * sizeof(SQChar);
+	exp->_nodes = (SQRexNode *)sq_malloc(exp->_nallocated * sizeof(SQRexNode));
+	exp->_nsize = 0;
+	exp->_matches = 0;
+	exp->_nsubexpr = 0;
+	exp->_first = sqstd_rex_newnode(exp,OP_EXPR);
+	exp->_error = error;
+	try {
+		SQInteger res = sqstd_rex_list(exp);
+		exp->_nodes[exp->_first].left = res;
+		if(*exp->_p!='\0')
+			sqstd_rex_error(exp,_SC("unexpected character"));
+#ifdef _DEBUG
+		{
+			SQInteger nsize,i;
+			SQRexNode *t;
+			nsize = exp->_nsize;
+			t = &exp->_nodes[0];
+			scprintf(_SC("\n"));
+			/* XXX -- The (int) casts are needed to silent warnings on 64bit systems (SQInteger is 64bit, %d assumes 32bit, (int) is 32bit) */
+			for(i = 0;i < nsize; i++) {
+				if(exp->_nodes[i].type>MAX_CHAR)
+					scprintf(_SC("[%02d] %10s "),(int)i,g_nnames[exp->_nodes[i].type-MAX_CHAR]);
+				else
+					scprintf(_SC("[%02d] %10c "),(int)i,exp->_nodes[i].type);
+				scprintf(_SC("left %02d right %02d next %02d\n"),(int)exp->_nodes[i].left,(int)exp->_nodes[i].right,(int)exp->_nodes[i].next);
+			}
+			scprintf(_SC("\n"));
+		}
+#endif
+		exp->_matches = (SQRexMatch *) sq_malloc(exp->_nsubexpr * sizeof(SQRexMatch));
+		memset(exp->_matches,0,exp->_nsubexpr * sizeof(SQRexMatch));
+		return exp;
+	}
+	catch (...) {
+		sqstd_rex_free(exp);
+		return NULL;
+	}
+}
+
+void sqstd_rex_free(SQRex *exp)
+{
+	if(exp)	{
+		if(exp->_nodes) sq_free(exp->_nodes,exp->_nallocated * sizeof(SQRexNode));
+		if(exp->_matches) sq_free(exp->_matches,exp->_nsubexpr * sizeof(SQRexMatch));
+		sq_free(exp,sizeof(SQRex));
+	}
+}
+
+SQBool sqstd_rex_match(SQRex* exp,const SQChar* text)
+{
+	const SQChar* res = NULL;
+	exp->_bol = text;
+	exp->_eol = text + scstrlen(text);
+	exp->_currsubexp = 0;
+	res = sqstd_rex_matchnode(exp,exp->_nodes,text,NULL);
+	if(res == NULL || res != exp->_eol)
+		return SQFalse;
+	return SQTrue;
+}
+
+SQBool sqstd_rex_searchrange(SQRex* exp,const SQChar* text_begin,const SQChar* text_end,const SQChar** out_begin, const SQChar** out_end)
+{
+	const SQChar *cur = NULL;
+	SQInteger node = exp->_first;
+	if(text_begin >= text_end) return SQFalse;
+	exp->_bol = text_begin;
+	exp->_eol = text_end;
+	do {
+		cur = text_begin;
+		while(node != -1) {
+			exp->_currsubexp = 0;
+			cur = sqstd_rex_matchnode(exp,&exp->_nodes[node],cur,NULL);
+			if(!cur)
+				break;
+			node = exp->_nodes[node].next;
+		}
+		*text_begin++;
+	} while(cur == NULL && text_begin != text_end);
+
+	if(cur == NULL)
+		return SQFalse;
+
+	--text_begin;
+
+	if(out_begin) *out_begin = text_begin;
+	if(out_end) *out_end = cur;
+	return SQTrue;
+}
+
+SQBool sqstd_rex_search(SQRex* exp,const SQChar* text, const SQChar** out_begin, const SQChar** out_end)
+{
+	return sqstd_rex_searchrange(exp,text,text + scstrlen(text),out_begin,out_end);
+}
+
+SQInteger sqstd_rex_getsubexpcount(SQRex* exp)
+{
+	return exp->_nsubexpr;
+}
+
+SQBool sqstd_rex_getsubexp(SQRex* exp, SQInteger n, SQRexMatch *subexp)
+{
+	if( n<0 || n >= exp->_nsubexpr) return SQFalse;
+	*subexp = exp->_matches[n];
+	return SQTrue;
+}
+
--- a/src/3rdparty/squirrel/sqstdlib/sqstdstream.cpp
+++ b/src/3rdparty/squirrel/sqstdlib/sqstdstream.cpp
@ -0,0 +1,330 @@
+/* see copyright notice in squirrel.h */
+#include <stdio.h>
+#include <new>
+#include <stdlib.h>
+#include <string.h>
+#include <squirrel.h>
+#include <sqstdio.h>
+#include <sqstdblob.h>
+#include "sqstdstream.h"
+#include "sqstdblobimpl.h"
+
+#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->IsValid())  \
+		return sq_throwerror(v,_SC("the stream is invalid"));
+
+SQInteger _stream_readblob(HSQUIRRELVM v)
+{
+	SETUP_STREAM(v);
+	SQUserPointer data,blobp;
+	SQInteger size,res;
+	sq_getinteger(v,2,&size);
+	if(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"));
+	blobp = sqstd_createblob(v,res);
+	memcpy(blobp,data,res);
+	return 1;
+}
+
+#define SAFE_READN(ptr,len) { \
+	if(self->Read(ptr,len) != len) return sq_throwerror(v,_SC("io error")); \
+	}
+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_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;
+}
+
+static SQRegFunction _stream_methods[] = {
+	_DECL_STREAM_FUNC(readblob,2,_SC("xn")),
+	_DECL_STREAM_FUNC(readn,2,_SC("xn")),
+	_DECL_STREAM_FUNC(writeblob,-2,_SC("xx")),
+	_DECL_STREAM_FUNC(writen,3,_SC("xnn")),
+	_DECL_STREAM_FUNC(seek,-2,_SC("xnn")),
+	_DECL_STREAM_FUNC(tell,1,_SC("x")),
+	_DECL_STREAM_FUNC(len,1,_SC("x")),
+	_DECL_STREAM_FUNC(eos,1,_SC("x")),
+	_DECL_STREAM_FUNC(flush,1,_SC("x")),
+	{0,0,0,0}
+};
+
+void init_streamclass(HSQUIRRELVM v)
+{
+	sq_pushregistrytable(v);
+	sq_pushstring(v,_SC("std_stream"),-1);
+	if(SQ_FAILED(sq_get(v,-2))) {
+		sq_pushstring(v,_SC("std_stream"),-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_createslot(v,-3);
+			i++;
+		}
+		sq_createslot(v,-3);
+		sq_pushroottable(v);
+		sq_pushstring(v,_SC("stream"),-1);
+		sq_pushstring(v,_SC("std_stream"),-1);
+		sq_get(v,-4);
+		sq_createslot(v,-3);
+		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,SQRegFunction *methods,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) {
+			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_createslot(v,-3);
+			i++;
+		}
+		sq_createslot(v,-3);
+		sq_pop(v,1);
+
+		i = 0;
+		while(globals[i].name!=0)
+		{
+			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_createslot(v,-3);
+			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_createslot(v,-3);
+
+		sq_settop(v,top);
+		return SQ_OK;
+	}
+	sq_settop(v,top);
+	return SQ_ERROR;
+}
--- a/src/3rdparty/squirrel/sqstdlib/sqstdstream.h
+++ b/src/3rdparty/squirrel/sqstdlib/sqstdstream.h
@ -0,0 +1,18 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQSTD_STREAM_H_
+#define _SQSTD_STREAM_H_
+
+SQInteger _stream_readblob(HSQUIRRELVM v);
+SQInteger _stream_readline(HSQUIRRELVM v);
+SQInteger _stream_readn(HSQUIRRELVM v);
+SQInteger _stream_writeblob(HSQUIRRELVM v);
+SQInteger _stream_writen(HSQUIRRELVM v);
+SQInteger _stream_seek(HSQUIRRELVM v);
+SQInteger _stream_tell(HSQUIRRELVM v);
+SQInteger _stream_len(HSQUIRRELVM v);
+SQInteger _stream_eos(HSQUIRRELVM v);
+SQInteger _stream_flush(HSQUIRRELVM v);
+
+#define _DECL_STREAM_FUNC(name,nparams,typecheck) {_SC(#name),_stream_##name,nparams,typecheck}
+SQRESULT declare_stream(HSQUIRRELVM v,const SQChar* name,SQUserPointer typetag,const SQChar* reg_name,SQRegFunction *methods,SQRegFunction *globals);
+#endif /*_SQSTD_STREAM_H_*/
--- a/src/3rdparty/squirrel/sqstdlib/sqstdstring.cpp
+++ b/src/3rdparty/squirrel/sqstdlib/sqstdstring.cpp
@ -0,0 +1,364 @@
+/* see copyright notice in squirrel.h */
+#include <squirrel.h>
+#include <sqstdstring.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <assert.h>
+#include <stdarg.h>
+
+#ifdef SQUNICODE
+#define scstrchr wcschr
+#define scatoi _wtoi
+#define scstrtok wcstok
+#else
+#define scstrchr strchr
+#define scatoi atoi
+#define scstrtok strtok
+#endif
+#define MAX_FORMAT_LEN	20
+#define MAX_WFORMAT_LEN	3
+#define ADDITIONAL_FORMAT_SPACE (100*sizeof(SQChar))
+
+static SQInteger validate_format(HSQUIRRELVM v, SQChar *fmt, const SQChar *src, SQInteger n,SQInteger &width)
+{
+	SQChar swidth[MAX_WFORMAT_LEN];
+	SQInteger wc = 0;
+	SQInteger start = n;
+	fmt[0] = '%';
+	while (scstrchr(_SC("-+ #0"), src[n])) n++;
+	while (scisdigit(src[n])) {
+		swidth[wc] = src[n];
+		n++;
+		wc++;
+		if(wc>=MAX_WFORMAT_LEN)
+			return sq_throwerror(v,_SC("width format too long"));
+	}
+	swidth[wc] = '\0';
+	if(wc > 0) {
+		width = scatoi(swidth);
+	}
+	else
+		width = 0;
+	if (src[n] == '.') {
+	    n++;
+
+		wc = 0;
+		while (scisdigit(src[n])) {
+			swidth[wc] = src[n];
+			n++;
+			wc++;
+			if(wc>=MAX_WFORMAT_LEN)
+				return sq_throwerror(v,_SC("precision format too long"));
+		}
+		swidth[wc] = '\0';
+		if(wc > 0) {
+			width += scatoi(swidth);
+		}
+	}
+	if (n-start > MAX_FORMAT_LEN )
+		return sq_throwerror(v,_SC("format too long"));
+	memcpy(&fmt[1],&src[start],((n-start)+1)*sizeof(SQChar));
+	fmt[(n-start)+2] = '\0';
+	return n;
+}
+
+/*
+ * Little hack to remove the "format not a string literal, argument types not checked" warning.
+ * This check has been added to OpenTTD to make sure that nobody passes wrong string literals,
+ * but three lines in Squirrel have a little problem with those. Therefor we use this hack
+ * which basically uses vsnprintf instead of sprintf as vsnprintf is not testing for the right
+ * string literal at compile time.
+ */
+static void _append_string(SQInteger &i, SQChar *dest, SQInteger allocated, const SQChar *fmt, ...)
+{
+	va_list va;
+	va_start(va, fmt);
+	i += scvsnprintf(&dest[i],allocated-i,fmt,va);
+	va_end(va);
+}
+
+static SQInteger _string_format(HSQUIRRELVM v)
+{
+	const SQChar *format;
+	SQChar *dest;
+	SQChar fmt[MAX_FORMAT_LEN];
+	sq_getstring(v,2,&format);
+	SQInteger allocated = (sq_getsize(v,2)+1)*sizeof(SQChar);
+	dest = sq_getscratchpad(v,allocated);
+	SQInteger n = 0,i = 0, nparam = 3, w = 0;
+	while(format[n] != '\0') {
+		if(format[n] != '%') {
+			assert(i < allocated);
+			dest[i++] = format[n];
+			n++;
+		}
+		else if(format[n+1] == '%') { //handles %%
+				dest[i++] = '%';
+				n += 2;
+		}
+		else {
+			n++;
+			if( nparam > sq_gettop(v) )
+				return sq_throwerror(v,_SC("not enough paramters for the given format string"));
+			n = validate_format(v,fmt,format,n,w);
+			if(n < 0) return -1;
+			SQInteger addlen = 0;
+			SQInteger valtype = 0;
+			const SQChar *ts;
+			SQInteger ti;
+			SQFloat tf;
+			switch(format[n]) {
+			case 's':
+				if(SQ_FAILED(sq_getstring(v,nparam,&ts)))
+					return sq_throwerror(v,_SC("string expected for the specified format"));
+				addlen = (sq_getsize(v,nparam)*sizeof(SQChar))+((w+1)*sizeof(SQChar));
+				valtype = 's';
+				break;
+			case 'i': case 'd': case 'c':case 'o':  case 'u':  case 'x':  case 'X':
+				if(SQ_FAILED(sq_getinteger(v,nparam,&ti)))
+					return sq_throwerror(v,_SC("integer expected for the specified format"));
+				addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(SQChar));
+				valtype = 'i';
+				break;
+			case 'f': case 'g': case 'G': case 'e':  case 'E':
+				if(SQ_FAILED(sq_getfloat(v,nparam,&tf)))
+					return sq_throwerror(v,_SC("float expected for the specified format"));
+				addlen = (ADDITIONAL_FORMAT_SPACE)+((w+1)*sizeof(SQChar));
+				valtype = 'f';
+				break;
+			default:
+				return sq_throwerror(v,_SC("invalid format"));
+			}
+			n++;
+			allocated += addlen;
+			dest = sq_getscratchpad(v,allocated);
+			switch(valtype) {
+			case 's': _append_string(i,dest,allocated,fmt,ts); break;
+			case 'i': _append_string(i,dest,allocated,fmt,ti); break;
+			case 'f': _append_string(i,dest,allocated,fmt,tf); break;
+			};
+			nparam ++;
+		}
+	}
+	sq_pushstring(v,dest,i);
+	return 1;
+}
+
+static void __strip_l(const SQChar *str,const SQChar **start)
+{
+	const SQChar *t = str;
+	while(((*t) != '\0') && scisspace(*t)){ t++; }
+	*start = t;
+}
+
+static void __strip_r(const SQChar *str,SQInteger len,const SQChar **end)
+{
+	if(len == 0) {
+		*end = str;
+		return;
+	}
+	const SQChar *t = &str[len-1];
+	while(t != str && scisspace(*t)) { t--; }
+	*end = t+1;
+}
+
+static SQInteger _string_strip(HSQUIRRELVM v)
+{
+	const SQChar *str,*start,*end;
+	sq_getstring(v,2,&str);
+	SQInteger len = sq_getsize(v,2);
+	__strip_l(str,&start);
+	__strip_r(str,len,&end);
+	sq_pushstring(v,start,end - start);
+	return 1;
+}
+
+static SQInteger _string_lstrip(HSQUIRRELVM v)
+{
+	const SQChar *str,*start;
+	sq_getstring(v,2,&str);
+	__strip_l(str,&start);
+	sq_pushstring(v,start,-1);
+	return 1;
+}
+
+static SQInteger _string_rstrip(HSQUIRRELVM v)
+{
+	const SQChar *str,*end;
+	sq_getstring(v,2,&str);
+	SQInteger len = sq_getsize(v,2);
+	__strip_r(str,len,&end);
+	sq_pushstring(v,str,end - str);
+	return 1;
+}
+
+static SQInteger _string_split(HSQUIRRELVM v)
+{
+	const SQChar *str,*seps;
+	SQChar *stemp,*tok;
+	sq_getstring(v,2,&str);
+	sq_getstring(v,3,&seps);
+	if(sq_getsize(v,3) == 0) return sq_throwerror(v,_SC("empty separators string"));
+	SQInteger memsize = (sq_getsize(v,2)+1)*sizeof(SQChar);
+	stemp = sq_getscratchpad(v,memsize);
+	memcpy(stemp,str,memsize);
+	tok = scstrtok(stemp,seps);
+	sq_newarray(v,0);
+	while( tok != NULL ) {
+		sq_pushstring(v,tok,-1);
+		sq_arrayappend(v,-2);
+		tok = scstrtok( NULL, seps );
+	}
+	return 1;
+}
+
+#define SETUP_REX(v) \
+	SQRex *self = NULL; \
+	sq_getinstanceup(v,1,(SQUserPointer *)&self,0);
+
+static SQInteger _rexobj_releasehook(SQUserPointer p, SQInteger size)
+{
+	SQRex *self = ((SQRex *)p);
+	sqstd_rex_free(self);
+	return 1;
+}
+
+static SQInteger _regexp_match(HSQUIRRELVM v)
+{
+	SETUP_REX(v);
+	const SQChar *str;
+	sq_getstring(v,2,&str);
+	if(sqstd_rex_match(self,str) == SQTrue)
+	{
+		sq_pushbool(v,SQTrue);
+		return 1;
+	}
+	sq_pushbool(v,SQFalse);
+	return 1;
+}
+
+static void _addrexmatch(HSQUIRRELVM v,const SQChar *str,const SQChar *begin,const SQChar *end)
+{
+	sq_newtable(v);
+	sq_pushstring(v,_SC("begin"),-1);
+	sq_pushinteger(v,begin - str);
+	sq_rawset(v,-3);
+	sq_pushstring(v,_SC("end"),-1);
+	sq_pushinteger(v,end - str);
+	sq_rawset(v,-3);
+}
+
+static SQInteger _regexp_search(HSQUIRRELVM v)
+{
+	SETUP_REX(v);
+	const SQChar *str,*begin,*end;
+	SQInteger start = 0;
+	sq_getstring(v,2,&str);
+	if(sq_gettop(v) > 2) sq_getinteger(v,3,&start);
+	if(sqstd_rex_search(self,str+start,&begin,&end) == SQTrue) {
+		_addrexmatch(v,str,begin,end);
+		return 1;
+	}
+	return 0;
+}
+
+static SQInteger _regexp_capture(HSQUIRRELVM v)
+{
+	SETUP_REX(v);
+	const SQChar *str,*begin,*end;
+	SQInteger start = 0;
+	sq_getstring(v,2,&str);
+	if(sq_gettop(v) > 2) sq_getinteger(v,3,&start);
+	if(sqstd_rex_search(self,str+start,&begin,&end) == SQTrue) {
+		SQInteger n = sqstd_rex_getsubexpcount(self);
+		SQRexMatch match;
+		sq_newarray(v,0);
+		for(SQInteger i = 0;i < n; i++) {
+			sqstd_rex_getsubexp(self,i,&match);
+			if(match.len > 0)
+				_addrexmatch(v,str,match.begin,match.begin+match.len);
+			else
+				_addrexmatch(v,str,str,str); //empty match
+			sq_arrayappend(v,-2);
+		}
+		return 1;
+	}
+	return 0;
+}
+
+static SQInteger _regexp_subexpcount(HSQUIRRELVM v)
+{
+	SETUP_REX(v);
+	sq_pushinteger(v,sqstd_rex_getsubexpcount(self));
+	return 1;
+}
+
+static SQInteger _regexp_constructor(HSQUIRRELVM v)
+{
+	const SQChar *error,*pattern;
+	sq_getstring(v,2,&pattern);
+	SQRex *rex = sqstd_rex_compile(pattern,&error);
+	if(!rex) return sq_throwerror(v,error);
+	sq_setinstanceup(v,1,rex);
+	sq_setreleasehook(v,1,_rexobj_releasehook);
+	return 0;
+}
+
+static SQInteger _regexp__typeof(HSQUIRRELVM v)
+{
+	sq_pushstring(v,_SC("regexp"),-1);
+	return 1;
+}
+
+#define _DECL_REX_FUNC(name,nparams,pmask) {_SC(#name),_regexp_##name,nparams,pmask}
+static SQRegFunction rexobj_funcs[]={
+	_DECL_REX_FUNC(constructor,2,_SC(".s")),
+	_DECL_REX_FUNC(search,-2,_SC("xsn")),
+	_DECL_REX_FUNC(match,2,_SC("xs")),
+	_DECL_REX_FUNC(capture,-2,_SC("xsn")),
+	_DECL_REX_FUNC(subexpcount,1,_SC("x")),
+	_DECL_REX_FUNC(_typeof,1,_SC("x")),
+	{0,0,0,0}
+};
+
+#define _DECL_FUNC(name,nparams,pmask) {_SC(#name),_string_##name,nparams,pmask}
+static SQRegFunction stringlib_funcs[]={
+	_DECL_FUNC(format,-2,_SC(".s")),
+	_DECL_FUNC(strip,2,_SC(".s")),
+	_DECL_FUNC(lstrip,2,_SC(".s")),
+	_DECL_FUNC(rstrip,2,_SC(".s")),
+	_DECL_FUNC(split,3,_SC(".ss")),
+	{0,0,0,0}
+};
+
+
+SQInteger sqstd_register_stringlib(HSQUIRRELVM v)
+{
+	sq_pushstring(v,_SC("regexp"),-1);
+	sq_newclass(v,SQFalse);
+	SQInteger i = 0;
+	while(rexobj_funcs[i].name != 0) {
+		SQRegFunction &f = rexobj_funcs[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_createslot(v,-3);
+		i++;
+	}
+	sq_createslot(v,-3);
+
+	i = 0;
+	while(stringlib_funcs[i].name!=0)
+	{
+		sq_pushstring(v,stringlib_funcs[i].name,-1);
+		sq_newclosure(v,stringlib_funcs[i].f,0);
+		sq_setparamscheck(v,stringlib_funcs[i].nparamscheck,stringlib_funcs[i].typemask);
+		sq_setnativeclosurename(v,-1,stringlib_funcs[i].name);
+		sq_createslot(v,-3);
+		i++;
+	}
+	return 1;
+}
--- a/src/3rdparty/squirrel/sqstdlib/sqstdsystem.cpp
+++ b/src/3rdparty/squirrel/sqstdlib/sqstdsystem.cpp
@ -0,0 +1,147 @@
+/* see copyright notice in squirrel.h */
+#include <squirrel.h>
+#include <time.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sqstdsystem.h>
+
+#ifdef SQUNICODE
+#include <wchar.h>
+#define scgetenv _wgetenv
+#define scsystem _wsystem
+#define scasctime _wasctime
+#define scremove _wremove
+#define screname _wrename
+#else
+#define scgetenv getenv
+#define scsystem system
+#define scasctime asctime
+#define scremove remove
+#define screname rename
+#endif
+
+static SQInteger _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 SQInteger _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 SQInteger _system_clock(HSQUIRRELVM v)
+{
+	sq_pushfloat(v,((SQFloat)clock())/(SQFloat)CLOCKS_PER_SEC);
+	return 1;
+}
+
+static SQInteger _system_time(HSQUIRRELVM v)
+{
+	time_t t;
+	time(&t);
+	sq_pushinteger(v,*((SQInteger *)&t));
+	return 1;
+}
+
+static SQInteger _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 SQInteger _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 SQInteger _system_date(HSQUIRRELVM v)
+{
+	time_t t;
+	SQInteger it;
+	SQInteger format = 'l';
+	if(sq_gettop(v) > 1) {
+		sq_getinteger(v,2,&it);
+		t = it;
+		if(sq_gettop(v) > 2) {
+			sq_getinteger(v,3,(SQInteger*)&format);
+		}
+	}
+	else {
+		time(&t);
+	}
+	tm *date;
+    if(format == 'u')
+		date = gmtime(&t);
+	else
+		date = localtime(&t);
+	if(!date)
+		return sq_throwerror(v,_SC("crt api failure"));
+	sq_newtable(v);
+	_set_integer_slot(v, _SC("sec"), date->tm_sec);
+    _set_integer_slot(v, _SC("min"), date->tm_min);
+    _set_integer_slot(v, _SC("hour"), date->tm_hour);
+    _set_integer_slot(v, _SC("day"), date->tm_mday);
+    _set_integer_slot(v, _SC("month"), date->tm_mon);
+    _set_integer_slot(v, _SC("year"), date->tm_year+1900);
+    _set_integer_slot(v, _SC("wday"), date->tm_wday);
+    _set_integer_slot(v, _SC("yday"), date->tm_yday);
+	return 1;
+}
+
+
+
+#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,1,NULL),
+	_DECL_FUNC(time,1,NULL),
+	_DECL_FUNC(date,-1,_SC(".nn")),
+	_DECL_FUNC(remove,2,_SC(".s")),
+	_DECL_FUNC(rename,3,_SC(".ss")),
+	{0,0,0,0}
+};
+
+
+SQInteger sqstd_register_systemlib(HSQUIRRELVM 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_createslot(v,-3);
+		i++;
+	}
+	return 1;
+}
--- a/src/3rdparty/squirrel/squirrel.dsw
+++ b/src/3rdparty/squirrel/squirrel.dsw
@ -0,0 +1,77 @@
+Microsoft Developer Studio Workspace File, Format Version 6.00
+# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
+
+###############################################################################
+
+Project: "sq"=.\sq\sq.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+    begin source code control
+    .
+    end source code control
+}}}
+
+Package=<4>
+{{{
+    Begin Project Dependency
+    Project_Dep_Name sqlibs
+    End Project Dependency
+    Begin Project Dependency
+    Project_Dep_Name squirrel
+    End Project Dependency
+    Begin Project Dependency
+    Project_Dep_Name sqstdlib
+    End Project Dependency
+}}}
+
+###############################################################################
+
+Project: "sqstdlib"=.\sqstdlib\sqstdlib.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+    begin source code control
+    "$/squirrel", HAAAAAAA
+    .
+    end source code control
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Project: "squirrel"=.\squirrel\squirrel.dsp - Package Owner=<4>
+
+Package=<5>
+{{{
+    begin source code control
+    "$/squirrel", HAAAAAAA
+    .
+    end source code control
+}}}
+
+Package=<4>
+{{{
+}}}
+
+###############################################################################
+
+Global:
+
+Package=<5>
+{{{
+    begin source code control
+    "$/squirrel", HAAAAAAA
+    .
+    end source code control
+}}}
+
+Package=<3>
+{{{
+}}}
+
+###############################################################################
+
--- a/src/3rdparty/squirrel/squirrel/Makefile
+++ b/src/3rdparty/squirrel/squirrel/Makefile
@ -0,0 +1,52 @@
+SQUIRREL= ..
+
+
+OUT= $(SQUIRREL)/lib/libsquirrel.a
+INCZ= -I$(SQUIRREL)/include -I. -Iinclude
+DEFS=
+LIB=
+
+OBJS= \
+	sqapi.o \
+	sqbaselib.o \
+	sqcompiler.o \
+	sqdebug.o \
+	sqlexer.o \
+	sqobject.o \
+	sqparser.o \
+	sqstate.o \
+	sqtable.o \
+	sqvm.o \
+	sqmem.o \
+	sqclass.o
+
+SRCS= \
+	sqapi.cpp \
+	sqbaselib.cpp \
+	sqfuncstate.cpp \
+	sqdebug.cpp \
+	sqlexer.cpp \
+	sqobject.cpp \
+	sqcompiler.cpp \
+	sqstate.cpp \
+	sqtable.cpp \
+	sqmem.cpp \
+	sqvm.cpp \
+	sqclass.cpp
+
+
+
+sq32:
+	gcc -O2  -fno-rtti -Wall -c $(SRCS) $(INCZ) $(DEFS)
+	ar rc $(OUT) *.o
+
+sqprof:
+	gcc -O2 -pg -fno-rtti -pie -gstabs -g3 -Wall -c $(SRCS) $(INCZ) $(DEFS)
+	ar rc $(OUT) *.o
+
+sq64:
+	gcc -O2  -D_SQ64 -fno-rtti -Wall -c $(SRCS) $(INCZ) $(DEFS)
+	ar rc $(OUT) *.o
+
+clean:
+	rm -f $(OUT) $(SRCS:%.cpp=%.o)
--- a/src/3rdparty/squirrel/squirrel/sqapi.cpp
+++ b/src/3rdparty/squirrel/squirrel/sqapi.cpp
--- a/src/3rdparty/squirrel/squirrel/sqarray.h
+++ b/src/3rdparty/squirrel/squirrel/sqarray.h
@ -0,0 +1,87 @@
+/*	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);
+#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;
+	}
+	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=TranslateIndex(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),Size()); anew->_values.copy(_values); return anew; }
+	SQInteger Size() const {return _values.size();}
+	void Resize(SQInteger size,SQObjectPtr &fill = _null_) { _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_
--- a/src/3rdparty/squirrel/squirrel/sqbaselib.cpp
+++ b/src/3rdparty/squirrel/squirrel/sqbaselib.cpp
@ -0,0 +1,921 @@
+/*
+	see copyright notice in squirrel.h
+*/
+#include "sqpcheader.h"
+#include "sqvm.h"
+#include "sqstring.h"
+#include "sqtable.h"
+#include "sqarray.h"
+#include "sqfuncproto.h"
+#include "sqclosure.h"
+#include "sqclass.h"
+#include <stdlib.h>
+#include <stdarg.h>
+#include <ctype.h>
+
+bool str2num(const SQChar *s,SQObjectPtr &res)
+{
+	SQChar *end;
+	if(scstrstr(s,_SC("."))){
+		SQFloat r = SQFloat(scstrtod(s,&end));
+		if(s == end) return false;
+		res = r;
+		return true;
+	}
+	else{
+		SQInteger r = SQInteger(scstrtol(s,&end,10));
+		if(s == end) return false;
+		res = r;
+		return true;
+	}
+}
+
+#ifdef EXPORT_DEFAULT_SQUIRREL_FUNCTIONS
+static SQInteger base_dummy(HSQUIRRELVM v)
+{
+	return 0;
+}
+
+#ifndef NO_GARBAGE_COLLECTOR
+static SQInteger base_collectgarbage(HSQUIRRELVM v)
+{
+	sq_pushinteger(v, sq_collectgarbage(v));
+	return 1;
+}
+#endif
+
+static SQInteger base_getroottable(HSQUIRRELVM v)
+{
+	v->Push(v->_roottable);
+	return 1;
+}
+
+static SQInteger base_getconsttable(HSQUIRRELVM v)
+{
+	v->Push(_ss(v)->_consts);
+	return 1;
+}
+
+
+static SQInteger base_setroottable(HSQUIRRELVM v)
+{
+	SQObjectPtr &o=stack_get(v,2);
+	if(SQ_FAILED(sq_setroottable(v))) return SQ_ERROR;
+	v->Push(o);
+	return 1;
+}
+
+static SQInteger base_setconsttable(HSQUIRRELVM v)
+{
+	SQObjectPtr &o=stack_get(v,2);
+	if(SQ_FAILED(sq_setconsttable(v))) return SQ_ERROR;
+	v->Push(o);
+	return 1;
+}
+
+static SQInteger base_seterrorhandler(HSQUIRRELVM v)
+{
+	sq_seterrorhandler(v);
+	return 0;
+}
+
+static SQInteger base_setdebughook(HSQUIRRELVM v)
+{
+	sq_setdebughook(v);
+	return 0;
+}
+
+static SQInteger base_enabledebuginfo(HSQUIRRELVM v)
+{
+	SQObjectPtr &o=stack_get(v,2);
+	sq_enabledebuginfo(v,(type(o) != OT_NULL)?1:0);
+	return 0;
+}
+
+static SQInteger base_getstackinfos(HSQUIRRELVM v)
+{
+	SQInteger level;
+	SQStackInfos si;
+	SQInteger seq = 0;
+	const SQChar *name = NULL;
+	sq_getinteger(v, -1, &level);
+	if (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;
+		sq_newtable(v);
+		sq_pushstring(v, _SC("func"), -1);
+		sq_pushstring(v, fn, -1);
+		sq_createslot(v, -3);
+		sq_pushstring(v, _SC("src"), -1);
+		sq_pushstring(v, src, -1);
+		sq_createslot(v, -3);
+		sq_pushstring(v, _SC("line"), -1);
+		sq_pushinteger(v, si.line);
+		sq_createslot(v, -3);
+		sq_pushstring(v, _SC("locals"), -1);
+		sq_newtable(v);
+		seq=0;
+		while ((name = sq_getlocal(v, level, seq))) {
+			sq_pushstring(v, name, -1);
+			sq_push(v, -2);
+			sq_createslot(v, -4);
+			sq_pop(v, 1);
+			seq++;
+		}
+		sq_createslot(v, -3);
+		return 1;
+	}
+
+	return 0;
+}
+#endif /* EXPORT_DEFAULT_SQUIRREL_FUNCTIONS */
+
+static SQInteger base_assert(HSQUIRRELVM v)
+{
+	if(v->IsFalse(stack_get(v,2))){
+		return sq_throwerror(v,_SC("assertion failed"));
+	}
+	return 0;
+}
+
+static SQInteger get_slice_params(HSQUIRRELVM v,SQInteger &sidx,SQInteger &eidx,SQObjectPtr &o)
+{
+	SQInteger top = sq_gettop(v);
+	sidx=0;
+	eidx=0;
+	o=stack_get(v,1);
+	SQObjectPtr &start=stack_get(v,2);
+	if(type(start)!=OT_NULL && sq_isnumeric(start)){
+		sidx=tointeger(start);
+	}
+	if(top>2){
+		SQObjectPtr &end=stack_get(v,3);
+		if(sq_isnumeric(end)){
+			eidx=tointeger(end);
+		}
+	}
+	else {
+		eidx = sq_getsize(v,1);
+	}
+	return 1;
+}
+
+static SQInteger base_print(HSQUIRRELVM v)
+{
+	const SQChar *str;
+	sq_tostring(v,2);
+	sq_getstring(v,-1,&str);
+	if(_ss(v)->_printfunc) _ss(v)->_printfunc(v,_SC("%s"),str);
+	return 0;
+}
+
+#ifdef EXPORT_DEFAULT_SQUIRREL_FUNCTIONS
+static SQInteger base_compilestring(HSQUIRRELVM v)
+{
+	SQInteger nargs=sq_gettop(v);
+	const SQChar *src=NULL,*name=_SC("unnamedbuffer");
+	SQInteger size;
+	sq_getstring(v,2,&src);
+	size=sq_getsize(v,2);
+	if(nargs>2){
+		sq_getstring(v,3,&name);
+	}
+	if(SQ_SUCCEEDED(sq_compilebuffer(v,src,size,name,SQFalse)))
+		return 1;
+	else
+		return SQ_ERROR;
+}
+
+static SQInteger base_newthread(HSQUIRRELVM v)
+{
+	SQObjectPtr &func = stack_get(v,2);
+	SQInteger stksize = (_funcproto(_closure(func)->_function)->_stacksize << 1) +2;
+	HSQUIRRELVM newv = sq_newthread(v, (stksize < MIN_STACK_OVERHEAD + 2)? MIN_STACK_OVERHEAD + 2 : stksize);
+	sq_move(newv,v,-2);
+	return 1;
+}
+
+static SQInteger base_suspend(HSQUIRRELVM v)
+{
+	return sq_suspendvm(v);
+}
+#endif /* EXPORT_DEFAULT_SQUIRREL_FUNCTIONS */
+
+static SQInteger base_array(HSQUIRRELVM v)
+{
+	SQArray *a;
+	SQObject &size = stack_get(v,2);
+	if(sq_gettop(v) > 2) {
+		a = SQArray::Create(_ss(v),0);
+		a->Resize(tointeger(size),stack_get(v,3));
+	}
+	else {
+		a = SQArray::Create(_ss(v),tointeger(size));
+	}
+	v->Push(a);
+	return 1;
+}
+
+static SQInteger base_type(HSQUIRRELVM v)
+{
+	SQObjectPtr &o = stack_get(v,2);
+	v->Push(SQString::Create(_ss(v),GetTypeName(o),-1));
+	return 1;
+}
+
+static SQRegFunction base_funcs[]={
+	//generic
+#ifdef EXPORT_DEFAULT_SQUIRREL_FUNCTIONS
+	{_SC("seterrorhandler"),base_seterrorhandler,2, NULL},
+	{_SC("setdebughook"),base_setdebughook,2, NULL},
+	{_SC("enabledebuginfo"),base_enabledebuginfo,2, NULL},
+	{_SC("getstackinfos"),base_getstackinfos,2, _SC(".n")},
+	{_SC("getroottable"),base_getroottable,1, NULL},
+	{_SC("setroottable"),base_setroottable,2, NULL},
+	{_SC("getconsttable"),base_getconsttable,1, NULL},
+	{_SC("setconsttable"),base_setconsttable,2, NULL},
+#endif
+	{_SC("assert"),base_assert,2, NULL},
+	{_SC("print"),base_print,2, NULL},
+#ifdef EXPORT_DEFAULT_SQUIRREL_FUNCTIONS
+	{_SC("compilestring"),base_compilestring,-2, _SC(".ss")},
+	{_SC("newthread"),base_newthread,2, _SC(".c")},
+	{_SC("suspend"),base_suspend,-1, NULL},
+#endif
+	{_SC("array"),base_array,-2, _SC(".n")},
+	{_SC("type"),base_type,2, NULL},
+#ifdef EXPORT_DEFAULT_SQUIRREL_FUNCTIONS
+	{_SC("dummy"),base_dummy,0,NULL},
+#ifndef NO_GARBAGE_COLLECTOR
+	{_SC("collectgarbage"),base_collectgarbage,1, _SC("t")},
+#endif
+#endif
+	{0,0,0,0}
+};
+
+void sq_base_register(HSQUIRRELVM v)
+{
+	SQInteger i=0;
+	sq_pushroottable(v);
+	while(base_funcs[i].name!=0) {
+		sq_pushstring(v,base_funcs[i].name,-1);
+		sq_newclosure(v,base_funcs[i].f,0);
+		sq_setnativeclosurename(v,-1,base_funcs[i].name);
+		sq_setparamscheck(v,base_funcs[i].nparamscheck,base_funcs[i].typemask);
+		sq_createslot(v,-3);
+		i++;
+	}
+	sq_pushstring(v,_SC("_version_"),-1);
+	sq_pushstring(v,SQUIRREL_VERSION,-1);
+	sq_createslot(v,-3);
+	sq_pushstring(v,_SC("_charsize_"),-1);
+	sq_pushinteger(v,sizeof(SQChar));
+	sq_createslot(v,-3);
+	sq_pushstring(v,_SC("_intsize_"),-1);
+	sq_pushinteger(v,sizeof(SQInteger));
+	sq_createslot(v,-3);
+	sq_pop(v,1);
+}
+
+static SQInteger default_delegate_len(HSQUIRRELVM v)
+{
+	v->Push(SQInteger(sq_getsize(v,1)));
+	return 1;
+}
+
+static SQInteger default_delegate_tofloat(HSQUIRRELVM v)
+{
+	SQObjectPtr &o=stack_get(v,1);
+	switch(type(o)){
+	case OT_STRING:{
+		SQObjectPtr res;
+		if(str2num(_stringval(o),res)){
+			v->Push(SQObjectPtr(tofloat(res)));
+			break;
+		}}
+		return sq_throwerror(v, _SC("cannot convert the string"));
+		break;
+	case OT_INTEGER:case OT_FLOAT:
+		v->Push(SQObjectPtr(tofloat(o)));
+		break;
+	case OT_BOOL:
+		v->Push(SQObjectPtr((SQFloat)(_integer(o)?1:0)));
+		break;
+	default:
+		v->Push(_null_);
+		break;
+	}
+	return 1;
+}
+
+static SQInteger default_delegate_tointeger(HSQUIRRELVM v)
+{
+	SQObjectPtr &o=stack_get(v,1);
+	switch(type(o)){
+	case OT_STRING:{
+		SQObjectPtr res;
+		if(str2num(_stringval(o),res)){
+			v->Push(SQObjectPtr(tointeger(res)));
+			break;
+		}}
+		return sq_throwerror(v, _SC("cannot convert the string"));
+		break;
+	case OT_INTEGER:case OT_FLOAT:
+		v->Push(SQObjectPtr(tointeger(o)));
+		break;
+	case OT_BOOL:
+		v->Push(SQObjectPtr(_integer(o)?(SQInteger)1:(SQInteger)0));
+		break;
+	default:
+		v->Push(_null_);
+		break;
+	}
+	return 1;
+}
+
+static SQInteger default_delegate_tostring(HSQUIRRELVM v)
+{
+	sq_tostring(v,1);
+	return 1;
+}
+
+static SQInteger obj_delegate_weakref(HSQUIRRELVM v)
+{
+	sq_weakref(v,1);
+	return 1;
+}
+
+static SQInteger obj_clear(HSQUIRRELVM v)
+{
+	return sq_clear(v,-1);
+}
+
+
+static SQInteger number_delegate_tochar(HSQUIRRELVM v)
+{
+	SQObject &o=stack_get(v,1);
+	SQChar c = (SQChar)tointeger(o);
+	v->Push(SQString::Create(_ss(v),(const SQChar *)&c,1));
+	return 1;
+}
+
+
+/////////////////////////////////////////////////////////////////
+//TABLE DEFAULT DELEGATE
+
+static SQInteger table_rawdelete(HSQUIRRELVM v)
+{
+	if(SQ_FAILED(sq_rawdeleteslot(v,1,SQTrue)))
+		return SQ_ERROR;
+	return 1;
+}
+
+
+static SQInteger container_rawexists(HSQUIRRELVM v)
+{
+	if(SQ_SUCCEEDED(sq_rawget(v,-2))) {
+		sq_pushbool(v,SQTrue);
+		return 1;
+	}
+	sq_pushbool(v,SQFalse);
+	return 1;
+}
+
+static SQInteger table_rawset(HSQUIRRELVM v)
+{
+	return sq_rawset(v,-3);
+}
+
+
+static SQInteger table_rawget(HSQUIRRELVM v)
+{
+	return SQ_SUCCEEDED(sq_rawget(v,-2))?1:SQ_ERROR;
+}
+
+
+SQRegFunction SQSharedState::_table_default_delegate_funcz[]={
+	{_SC("len"),default_delegate_len,1, _SC("t")},
+	{_SC("rawget"),table_rawget,2, _SC("t")},
+	{_SC("rawset"),table_rawset,3, _SC("t")},
+	{_SC("rawdelete"),table_rawdelete,2, _SC("t")},
+	{_SC("rawin"),container_rawexists,2, _SC("t")},
+	{_SC("weakref"),obj_delegate_weakref,1, NULL },
+	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
+	{_SC("clear"),obj_clear,1, _SC(".")},
+	{0,0,0,0}
+};
+
+//ARRAY DEFAULT DELEGATE///////////////////////////////////////
+
+static SQInteger array_append(HSQUIRRELVM v)
+{
+	return sq_arrayappend(v,-2);
+}
+
+static SQInteger array_extend(HSQUIRRELVM v)
+{
+	_array(stack_get(v,1))->Extend(_array(stack_get(v,2)));
+	return 0;
+}
+
+static SQInteger array_reverse(HSQUIRRELVM v)
+{
+	return sq_arrayreverse(v,-1);
+}
+
+static SQInteger array_pop(HSQUIRRELVM v)
+{
+	return SQ_SUCCEEDED(sq_arraypop(v,1,SQTrue))?1:SQ_ERROR;
+}
+
+static SQInteger array_top(HSQUIRRELVM v)
+{
+	SQObject &o=stack_get(v,1);
+	if(_array(o)->Size()>0){
+		v->Push(_array(o)->Top());
+		return 1;
+	}
+	else return sq_throwerror(v,_SC("top() on a empty array"));
+}
+
+static SQInteger array_insert(HSQUIRRELVM v)
+{
+	SQObject &o=stack_get(v,1);
+	SQObject &idx=stack_get(v,2);
+	SQObject &val=stack_get(v,3);
+	if(!_array(o)->Insert(tointeger(idx),val))
+		return sq_throwerror(v,_SC("index out of range"));
+	return 0;
+}
+
+static SQInteger array_remove(HSQUIRRELVM v)
+{
+	SQObject &o = stack_get(v, 1);
+	SQObject &idx = stack_get(v, 2);
+	if(!sq_isnumeric(idx)) return sq_throwerror(v, _SC("wrong type"));
+	SQObjectPtr val;
+	if(_array(o)->Get(tointeger(idx), val)) {
+		_array(o)->Remove(tointeger(idx));
+		v->Push(val);
+		return 1;
+	}
+	return sq_throwerror(v, _SC("idx out of range"));
+}
+
+static SQInteger array_resize(HSQUIRRELVM v)
+{
+	SQObject &o = stack_get(v, 1);
+	SQObject &nsize = stack_get(v, 2);
+	SQObjectPtr fill;
+	if(sq_isnumeric(nsize)) {
+		if(sq_gettop(v) > 2)
+			fill = stack_get(v, 3);
+		_array(o)->Resize(tointeger(nsize),fill);
+		return 0;
+	}
+	return sq_throwerror(v, _SC("size must be a number"));
+}
+
+
+//QSORT ala Sedgewick
+bool _qsort_compare(HSQUIRRELVM v,SQObjectPtr &arr,SQObjectPtr &a,SQObjectPtr &b,SQInteger func,SQInteger &ret)
+{
+	if(func < 0) {
+		if(!v->ObjCmp(a,b,ret)) return false;
+	}
+	else {
+		SQInteger top = sq_gettop(v);
+		sq_push(v, func);
+		sq_pushroottable(v);
+		v->Push(a);
+		v->Push(b);
+		if(SQ_FAILED(sq_call(v, 3, SQTrue, SQFalse))) {
+			if(!sq_isstring( v->_lasterror))
+				v->Raise_Error(_SC("compare func failed"));
+			return false;
+		}
+		sq_getinteger(v, -1, &ret);
+		sq_settop(v, top);
+		return true;
+	}
+	return true;
+}
+//QSORT ala Sedgewick
+bool _qsort(HSQUIRRELVM v,SQObjectPtr &arr, SQInteger l, SQInteger r,SQInteger func)
+{
+	SQInteger i, j;
+	SQArray *a=_array(arr);
+	SQObjectPtr pivot,t;
+	if( l < r ){
+		pivot = a->_values[l];
+		i = l; j = r+1;
+		while(1){
+			SQInteger ret;
+			do {
+				++i;
+				if(i > r) break;
+				if(!_qsort_compare(v,arr,a->_values[i],pivot,func,ret))
+					return false;
+			} while( ret <= 0);
+			do {
+				--j;
+				if ( j < 0 ) {
+					v->Raise_Error( _SC("Invalid qsort, probably compare function defect") );
+					return false;
+				}
+				if(!_qsort_compare(v,arr,a->_values[j],pivot,func,ret))
+					return false;
+			}
+			while( ret > 0 );
+			if( i >= j ) break;
+			t = a->_values[i]; a->_values[i] = a->_values[j]; a->_values[j] = t;
+		}
+		t = a->_values[l]; a->_values[l] = a->_values[j]; a->_values[j] = t;
+		if(!_qsort( v, arr, l, j-1,func)) return false;
+		if(!_qsort( v, arr, j+1, r,func)) return false;
+	}
+	return true;
+}
+
+static SQInteger array_sort(HSQUIRRELVM v)
+{
+	SQInteger func = -1;
+	SQObjectPtr &o = stack_get(v,1);
+	SQObject &funcobj = stack_get(v,2);
+	if(_array(o)->Size() > 1) {
+		if(type(funcobj) == OT_CLOSURE || type(funcobj) == OT_NATIVECLOSURE) func = 2;
+		if(!_qsort(v, o, 0, _array(o)->Size()-1, func))
+			return SQ_ERROR;
+
+	}
+	return 0;
+}
+static SQInteger array_slice(HSQUIRRELVM v)
+{
+	SQInteger sidx,eidx;
+	SQObjectPtr o;
+	if(get_slice_params(v,sidx,eidx,o)==-1)return -1;
+	SQInteger alen = _array(o)->Size();
+	if(sidx < 0)sidx = alen + sidx;
+	if(eidx < 0)eidx = alen + eidx;
+	if(eidx < sidx)return sq_throwerror(v,_SC("wrong indexes"));
+	if(eidx > alen)return sq_throwerror(v,_SC("slice out of range"));
+	SQArray *arr=SQArray::Create(_ss(v),eidx-sidx);
+	SQObjectPtr t;
+	SQInteger count=0;
+	for(SQInteger i=sidx;i<eidx;i++){
+		_array(o)->Get(i,t);
+		arr->Set(count++,t);
+	}
+	v->Push(arr);
+	return 1;
+
+}
+
+SQRegFunction SQSharedState::_array_default_delegate_funcz[]={
+	{_SC("len"),default_delegate_len,1, _SC("a")},
+	{_SC("append"),array_append,2, _SC("a")},
+	{_SC("extend"),array_extend,2, _SC("aa")},
+	{_SC("push"),array_append,2, _SC("a")},
+	{_SC("pop"),array_pop,1, _SC("a")},
+	{_SC("top"),array_top,1, _SC("a")},
+	{_SC("insert"),array_insert,3, _SC("an")},
+	{_SC("remove"),array_remove,2, _SC("an")},
+	{_SC("resize"),array_resize,-2, _SC("an")},
+	{_SC("reverse"),array_reverse,1, _SC("a")},
+	{_SC("sort"),array_sort,-1, _SC("ac")},
+	{_SC("slice"),array_slice,-1, _SC("ann")},
+	{_SC("weakref"),obj_delegate_weakref,1, NULL },
+	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
+	{_SC("clear"),obj_clear,1, _SC(".")},
+	{0,0,0,0}
+};
+
+//STRING DEFAULT DELEGATE//////////////////////////
+static SQInteger string_slice(HSQUIRRELVM v)
+{
+	SQInteger sidx,eidx;
+	SQObjectPtr o;
+	if(SQ_FAILED(get_slice_params(v,sidx,eidx,o)))return -1;
+	SQInteger slen = _string(o)->_len;
+	if(sidx < 0)sidx = slen + sidx;
+	if(eidx < 0)eidx = slen + eidx;
+	if(eidx < sidx)	return sq_throwerror(v,_SC("wrong indexes"));
+	if(eidx > slen)	return sq_throwerror(v,_SC("slice out of range"));
+	v->Push(SQString::Create(_ss(v),&_stringval(o)[sidx],eidx-sidx));
+	return 1;
+}
+
+static SQInteger string_find(HSQUIRRELVM v)
+{
+	SQInteger top,start_idx=0;
+	const SQChar *str,*substr,*ret;
+	if(((top=sq_gettop(v))>1) && SQ_SUCCEEDED(sq_getstring(v,1,&str)) && SQ_SUCCEEDED(sq_getstring(v,2,&substr))){
+		if(top>2)sq_getinteger(v,3,&start_idx);
+		if((sq_getsize(v,1)>start_idx) && (start_idx>=0)){
+			ret=scstrstr(&str[start_idx],substr);
+			if(ret){
+				sq_pushinteger(v,(SQInteger)(ret-str));
+				return 1;
+			}
+		}
+		return 0;
+	}
+	return sq_throwerror(v,_SC("invalid param"));
+}
+
+#define STRING_TOFUNCZ(func) static SQInteger string_##func(HSQUIRRELVM v) \
+{ \
+	SQObject str=stack_get(v,1); \
+	SQInteger len=_string(str)->_len; \
+	const SQChar *sThis=_stringval(str); \
+	SQChar *sNew=(_ss(v)->GetScratchPad(rsl(len))); \
+	for(SQInteger i=0;i<len;i++) sNew[i]=func(sThis[i]); \
+	v->Push(SQString::Create(_ss(v),sNew,len)); \
+	return 1; \
+}
+
+
+STRING_TOFUNCZ(tolower)
+STRING_TOFUNCZ(toupper)
+
+SQRegFunction SQSharedState::_string_default_delegate_funcz[]={
+	{_SC("len"),default_delegate_len,1, _SC("s")},
+	{_SC("tointeger"),default_delegate_tointeger,1, _SC("s")},
+	{_SC("tofloat"),default_delegate_tofloat,1, _SC("s")},
+	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
+	{_SC("slice"),string_slice,-1, _SC(" s n  n")},
+	{_SC("find"),string_find,-2, _SC("s s n ")},
+	{_SC("tolower"),string_tolower,1, _SC("s")},
+	{_SC("toupper"),string_toupper,1, _SC("s")},
+	{_SC("weakref"),obj_delegate_weakref,1, NULL },
+	{0,0,0,0}
+};
+
+//INTEGER DEFAULT DELEGATE//////////////////////////
+SQRegFunction SQSharedState::_number_default_delegate_funcz[]={
+	{_SC("tointeger"),default_delegate_tointeger,1, _SC("n|b")},
+	{_SC("tofloat"),default_delegate_tofloat,1, _SC("n|b")},
+	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
+	{_SC("tochar"),number_delegate_tochar,1, _SC("n|b")},
+	{_SC("weakref"),obj_delegate_weakref,1, NULL },
+	{0,0,0,0}
+};
+
+//CLOSURE DEFAULT DELEGATE//////////////////////////
+static SQInteger closure_pcall(HSQUIRRELVM v)
+{
+	return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQFalse))?1:SQ_ERROR;
+}
+
+static SQInteger closure_call(HSQUIRRELVM v)
+{
+	return SQ_SUCCEEDED(sq_call(v,sq_gettop(v)-1,SQTrue,SQTrue))?1:SQ_ERROR;
+}
+
+static SQInteger _closure_acall(HSQUIRRELVM v,SQBool raiseerror)
+{
+	SQArray *aparams=_array(stack_get(v,2));
+	SQInteger nparams=aparams->Size();
+	v->Push(stack_get(v,1));
+	for(SQInteger i=0;i<nparams;i++)v->Push(aparams->_values[i]);
+	return SQ_SUCCEEDED(sq_call(v,nparams,SQTrue,raiseerror))?1:SQ_ERROR;
+}
+
+static SQInteger closure_acall(HSQUIRRELVM v)
+{
+	return _closure_acall(v,SQTrue);
+}
+
+static SQInteger closure_pacall(HSQUIRRELVM v)
+{
+	return _closure_acall(v,SQFalse);
+}
+
+static SQInteger closure_bindenv(HSQUIRRELVM v)
+{
+	if(SQ_FAILED(sq_bindenv(v,1)))
+		return SQ_ERROR;
+	return 1;
+}
+
+static SQInteger closure_getinfos(HSQUIRRELVM v) {
+	SQObject o = stack_get(v,1);
+	SQTable *res = SQTable::Create(_ss(v),4);
+	if(type(o) == OT_CLOSURE) {
+		SQFunctionProto *f = _funcproto(_closure(o)->_function);
+		SQInteger nparams = f->_nparameters + (f->_varparams?1:0);
+		SQObjectPtr params = SQArray::Create(_ss(v),nparams);
+		for(SQInteger n = 0; n<f->_nparameters; n++) {
+			_array(params)->Set((SQInteger)n,f->_parameters[n]);
+		}
+		if(f->_varparams) {
+			_array(params)->Set(nparams-1,SQString::Create(_ss(v),_SC("..."),-1));
+		}
+		res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),false);
+		res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),f->_name);
+		res->NewSlot(SQString::Create(_ss(v),_SC("src"),-1),f->_sourcename);
+		res->NewSlot(SQString::Create(_ss(v),_SC("parameters"),-1),params);
+		res->NewSlot(SQString::Create(_ss(v),_SC("varargs"),-1),f->_varparams);
+	}
+	else { //OT_NATIVECLOSURE
+		SQNativeClosure *nc = _nativeclosure(o);
+		res->NewSlot(SQString::Create(_ss(v),_SC("native"),-1),true);
+		res->NewSlot(SQString::Create(_ss(v),_SC("name"),-1),nc->_name);
+		res->NewSlot(SQString::Create(_ss(v),_SC("paramscheck"),-1),nc->_nparamscheck);
+		SQObjectPtr typecheck;
+		if(nc->_typecheck.size() > 0) {
+			typecheck =
+				SQArray::Create(_ss(v), nc->_typecheck.size());
+			for(SQUnsignedInteger n = 0; n<nc->_typecheck.size(); n++) {
+					_array(typecheck)->Set((SQInteger)n,nc->_typecheck[n]);
+			}
+		}
+		res->NewSlot(SQString::Create(_ss(v),_SC("typecheck"),-1),typecheck);
+	}
+	v->Push(res);
+	return 1;
+}
+
+
+SQRegFunction SQSharedState::_closure_default_delegate_funcz[]={
+	{_SC("call"),closure_call,-1, _SC("c")},
+	{_SC("pcall"),closure_pcall,-1, _SC("c")},
+	{_SC("acall"),closure_acall,2, _SC("ca")},
+	{_SC("pacall"),closure_pacall,2, _SC("ca")},
+	{_SC("weakref"),obj_delegate_weakref,1, NULL },
+	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
+	{_SC("bindenv"),closure_bindenv,2, _SC("c x|y|t")},
+	{_SC("getinfos"),closure_getinfos,1, _SC("c")},
+	{0,0,0,0}
+};
+
+//GENERATOR DEFAULT DELEGATE
+static SQInteger generator_getstatus(HSQUIRRELVM v)
+{
+	SQObject &o=stack_get(v,1);
+	switch(_generator(o)->_state){
+		case SQGenerator::eSuspended:v->Push(SQString::Create(_ss(v),_SC("suspended")));break;
+		case SQGenerator::eRunning:v->Push(SQString::Create(_ss(v),_SC("running")));break;
+		case SQGenerator::eDead:v->Push(SQString::Create(_ss(v),_SC("dead")));break;
+	}
+	return 1;
+}
+
+SQRegFunction SQSharedState::_generator_default_delegate_funcz[]={
+	{_SC("getstatus"),generator_getstatus,1, _SC("g")},
+	{_SC("weakref"),obj_delegate_weakref,1, NULL },
+	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
+	{0,0,0,0}
+};
+
+//THREAD DEFAULT DELEGATE
+
+static SQInteger thread_call(HSQUIRRELVM v)
+{
+
+	SQObjectPtr o = stack_get(v,1);
+	if(type(o) == OT_THREAD) {
+		SQInteger nparams = sq_gettop(v);
+		_thread(o)->Push(_thread(o)->_roottable);
+		for(SQInteger i = 2; i<(nparams+1); i++)
+			sq_move(_thread(o),v,i);
+		if(SQ_SUCCEEDED(sq_call(_thread(o),nparams,SQTrue,SQFalse))) {
+			sq_move(v,_thread(o),-1);
+			sq_pop(_thread(o),1);
+			return 1;
+		}
+		v->_lasterror = _thread(o)->_lasterror;
+		return SQ_ERROR;
+	}
+	return sq_throwerror(v,_SC("wrong parameter"));
+}
+
+static SQInteger thread_wakeup(HSQUIRRELVM v)
+{
+	SQObjectPtr o = stack_get(v,1);
+	if(type(o) == OT_THREAD) {
+		SQVM *thread = _thread(o);
+		SQInteger state = sq_getvmstate(thread);
+		if(state != SQ_VMSTATE_SUSPENDED) {
+			switch(state) {
+				case SQ_VMSTATE_IDLE:
+					return sq_throwerror(v,_SC("cannot wakeup a idle thread"));
+				break;
+				case SQ_VMSTATE_RUNNING:
+					return sq_throwerror(v,_SC("cannot wakeup a running thread"));
+				break;
+			}
+		}
+
+		SQInteger wakeupret = sq_gettop(v)>1?1:0;
+		if(wakeupret) {
+			sq_move(thread,v,2);
+		}
+		if(SQ_SUCCEEDED(sq_wakeupvm(thread,wakeupret,SQTrue,SQFalse))) {
+			sq_move(v,thread,-1);
+			sq_pop(thread,1); //pop retval
+			if(sq_getvmstate(thread) == SQ_VMSTATE_IDLE) {
+				sq_settop(thread,1); //pop roottable
+			}
+			return 1;
+		}
+		sq_settop(thread,1);
+		v->_lasterror = thread->_lasterror;
+		return SQ_ERROR;
+	}
+	return sq_throwerror(v,_SC("wrong parameter"));
+}
+
+static SQInteger thread_getstatus(HSQUIRRELVM v)
+{
+	SQObjectPtr &o = stack_get(v,1);
+	switch(sq_getvmstate(_thread(o))) {
+		case SQ_VMSTATE_IDLE:
+			sq_pushstring(v,_SC("idle"),-1);
+		break;
+		case SQ_VMSTATE_RUNNING:
+			sq_pushstring(v,_SC("running"),-1);
+		break;
+		case SQ_VMSTATE_SUSPENDED:
+			sq_pushstring(v,_SC("suspended"),-1);
+		break;
+		default:
+			return sq_throwerror(v,_SC("internal VM error"));
+	}
+	return 1;
+}
+
+SQRegFunction SQSharedState::_thread_default_delegate_funcz[] = {
+	{_SC("call"), thread_call, -1, _SC("v")},
+	{_SC("wakeup"), thread_wakeup, -1, _SC("v")},
+	{_SC("getstatus"), thread_getstatus, 1, _SC("v")},
+	{_SC("weakref"),obj_delegate_weakref,1, NULL },
+	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
+	{0,0,0,0},
+};
+
+static SQInteger class_getattributes(HSQUIRRELVM v)
+{
+	if(SQ_SUCCEEDED(sq_getattributes(v,-2)))
+		return 1;
+	return SQ_ERROR;
+}
+
+static SQInteger class_setattributes(HSQUIRRELVM v)
+{
+	if(SQ_SUCCEEDED(sq_setattributes(v,-3)))
+		return 1;
+	return SQ_ERROR;
+}
+
+static SQInteger class_instance(HSQUIRRELVM v)
+{
+	if(SQ_SUCCEEDED(sq_createinstance(v,-1)))
+		return 1;
+	return SQ_ERROR;
+}
+
+SQRegFunction SQSharedState::_class_default_delegate_funcz[] = {
+	{_SC("getattributes"), class_getattributes, 2, _SC("y.")},
+	{_SC("setattributes"), class_setattributes, 3, _SC("y..")},
+	{_SC("rawin"),container_rawexists,2, _SC("y")},
+	{_SC("weakref"),obj_delegate_weakref,1, NULL },
+	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
+	{_SC("instance"),class_instance,1, _SC("y")},
+	{0,0,0,0}
+};
+
+static SQInteger instance_getclass(HSQUIRRELVM v)
+{
+	if(SQ_SUCCEEDED(sq_getclass(v,1)))
+		return 1;
+	return SQ_ERROR;
+}
+
+SQRegFunction SQSharedState::_instance_default_delegate_funcz[] = {
+	{_SC("getclass"), instance_getclass, 1, _SC("x")},
+	{_SC("rawin"),container_rawexists,2, _SC("x")},
+	{_SC("weakref"),obj_delegate_weakref,1, NULL },
+	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
+	{0,0,0,0}
+};
+
+static SQInteger weakref_ref(HSQUIRRELVM v)
+{
+	if(SQ_FAILED(sq_getweakrefval(v,1)))
+		return SQ_ERROR;
+	return 1;
+}
+
+SQRegFunction SQSharedState::_weakref_default_delegate_funcz[] = {
+	{_SC("ref"),weakref_ref,1, _SC("r")},
+	{_SC("weakref"),obj_delegate_weakref,1, NULL },
+	{_SC("tostring"),default_delegate_tostring,1, _SC(".")},
+	{0,0,0,0}
+};
+
+
--- a/src/3rdparty/squirrel/squirrel/sqclass.cpp
+++ b/src/3rdparty/squirrel/squirrel/sqclass.cpp
@ -0,0 +1,194 @@
+/*
+	see copyright notice in squirrel.h
+*/
+#include "sqpcheader.h"
+#include "sqvm.h"
+#include "sqtable.h"
+#include "sqclass.h"
+#include "sqclosure.h"
+
+SQClass::SQClass(SQSharedState *ss,SQClass *base)
+{
+	_base = base;
+	_typetag = 0;
+	_hook = NULL;
+	_udsize = 0;
+	_metamethods.resize(MT_LAST); //size it to max size
+	if(_base) {
+		_defaultvalues.copy(base->_defaultvalues);
+		_methods.copy(base->_methods);
+		_metamethods.copy(base->_metamethods);
+		__ObjAddRef(_base);
+	}
+	_members = base?base->_members->Clone() : SQTable::Create(ss,0);
+	__ObjAddRef(_members);
+	_locked = false;
+	INIT_CHAIN();
+	ADD_TO_CHAIN(&_sharedstate->_gc_chain, this);
+}
+
+void SQClass::Finalize() {
+	_attributes = _null_;
+	_defaultvalues.resize(0);
+	_methods.resize(0);
+	_metamethods.resize(0);
+	__ObjRelease(_members);
+	if(_base) {
+		__ObjRelease(_base);
+	}
+}
+
+SQClass::~SQClass()
+{
+	REMOVE_FROM_CHAIN(&_sharedstate->_gc_chain, this);
+	Finalize();
+}
+
+bool SQClass::NewSlot(SQSharedState *ss,const SQObjectPtr &key,const SQObjectPtr &val,bool bstatic)
+{
+	SQObjectPtr temp;
+	if(_locked)
+		return false; //the class already has an instance so cannot be modified
+	if(_members->Get(key,temp) && _isfield(temp)) //overrides the default value
+	{
+		_defaultvalues[_member_idx(temp)].val = val;
+		return true;
+	}
+	if(type(val) == OT_CLOSURE || type(val) == OT_NATIVECLOSURE || bstatic) {
+		SQInteger mmidx;
+		if((type(val) == OT_CLOSURE || type(val) == OT_NATIVECLOSURE) &&
+			(mmidx = ss->GetMetaMethodIdxByName(key)) != -1) {
+			_metamethods[mmidx] = val;
+		}
+		else {
+			if(type(temp) == OT_NULL) {
+				SQClassMember m;
+				m.val = val;
+				_members->NewSlot(key,SQObjectPtr(_make_method_idx(_methods.size())));
+				_methods.push_back(m);
+			}
+			else {
+				_methods[_member_idx(temp)].val = val;
+			}
+		}
+		return true;
+	}
+	SQClassMember m;
+	m.val = val;
+	_members->NewSlot(key,SQObjectPtr(_make_field_idx(_defaultvalues.size())));
+	_defaultvalues.push_back(m);
+	return true;
+}
+
+SQInstance *SQClass::CreateInstance()
+{
+	if(!_locked) Lock();
+	return SQInstance::Create(_opt_ss(this),this);
+}
+
+SQInteger SQClass::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval)
+{
+	SQObjectPtr oval;
+	SQInteger idx = _members->Next(false,refpos,outkey,oval);
+	if(idx != -1) {
+		if(_ismethod(oval)) {
+			outval = _methods[_member_idx(oval)].val;
+		}
+		else {
+			SQObjectPtr &o = _defaultvalues[_member_idx(oval)].val;
+			outval = _realval(o);
+		}
+	}
+	return idx;
+}
+
+bool SQClass::SetAttributes(const SQObjectPtr &key,const SQObjectPtr &val)
+{
+	SQObjectPtr idx;
+	if(_members->Get(key,idx)) {
+		if(_isfield(idx))
+			_defaultvalues[_member_idx(idx)].attrs = val;
+		else
+			_methods[_member_idx(idx)].attrs = val;
+		return true;
+	}
+	return false;
+}
+
+bool SQClass::GetAttributes(const SQObjectPtr &key,SQObjectPtr &outval)
+{
+	SQObjectPtr idx;
+	if(_members->Get(key,idx)) {
+		outval = (_isfield(idx)?_defaultvalues[_member_idx(idx)].attrs:_methods[_member_idx(idx)].attrs);
+		return true;
+	}
+	return false;
+}
+
+///////////////////////////////////////////////////////////////////////
+void SQInstance::Init(SQSharedState *ss)
+{
+	_userpointer = NULL;
+	_hook = NULL;
+	__ObjAddRef(_class);
+	_delegate = _class->_members;
+	INIT_CHAIN();
+	ADD_TO_CHAIN(&_sharedstate->_gc_chain, this);
+}
+
+SQInstance::SQInstance(SQSharedState *ss, SQClass *c, SQInteger memsize)
+{
+	_memsize = memsize;
+	_class = c;
+	SQUnsignedInteger nvalues = _class->_defaultvalues.size();
+	for(SQUnsignedInteger n = 0; n < nvalues; n++) {
+		new (&_values[n]) SQObjectPtr(_class->_defaultvalues[n].val);
+	}
+	Init(ss);
+}
+
+SQInstance::SQInstance(SQSharedState *ss, SQInstance *i, SQInteger memsize)
+{
+	_memsize = memsize;
+	_class = i->_class;
+	SQUnsignedInteger nvalues = _class->_defaultvalues.size();
+	for(SQUnsignedInteger n = 0; n < nvalues; n++) {
+		new (&_values[n]) SQObjectPtr(i->_values[n]);
+	}
+	Init(ss);
+}
+
+void SQInstance::Finalize()
+{
+	SQUnsignedInteger nvalues = _class->_defaultvalues.size();
+	__ObjRelease(_class);
+	for(SQUnsignedInteger i = 0; i < nvalues; i++) {
+		_values[i] = _null_;
+	}
+}
+
+SQInstance::~SQInstance()
+{
+	REMOVE_FROM_CHAIN(&_sharedstate->_gc_chain, this);
+	if(_class){ Finalize(); } //if _class is null it was already finalized by the GC
+}
+
+bool SQInstance::GetMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res)
+{
+	if(type(_class->_metamethods[mm]) != OT_NULL) {
+		res = _class->_metamethods[mm];
+		return true;
+	}
+	return false;
+}
+
+bool SQInstance::InstanceOf(SQClass *trg)
+{
+	SQClass *parent = _class;
+	while(parent != NULL) {
+		if(parent == trg)
+			return true;
+		parent = parent->_base;
+	}
+	return false;
+}
--- a/src/3rdparty/squirrel/squirrel/sqclass.h
+++ b/src/3rdparty/squirrel/squirrel/sqclass.h
@ -0,0 +1,152 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQCLASS_H_
+#define _SQCLASS_H_
+
+struct SQInstance;
+
+struct SQClassMember {
+	SQClassMember(){}
+	SQClassMember(const SQClassMember &o) {
+		val = o.val;
+		attrs = o.attrs;
+	}
+	SQObjectPtr val;
+	SQObjectPtr attrs;
+};
+
+typedef sqvector<SQClassMember> SQClassMemberVec;
+
+#define MEMBER_TYPE_METHOD 0x01000000
+#define MEMBER_TYPE_FIELD 0x02000000
+
+#define _ismethod(o) (_integer(o)&MEMBER_TYPE_METHOD)
+#define _isfield(o) (_integer(o)&MEMBER_TYPE_FIELD)
+#define _make_method_idx(i) ((SQInteger)(MEMBER_TYPE_METHOD|i))
+#define _make_field_idx(i) ((SQInteger)(MEMBER_TYPE_FIELD|i))
+#define _member_type(o) (_integer(o)&0xFF000000)
+#define _member_idx(o) (_integer(o)&0x00FFFFFF)
+
+struct SQClass : public CHAINABLE_OBJ
+{
+	SQClass(SQSharedState *ss,SQClass *base);
+public:
+	static SQClass* Create(SQSharedState *ss,SQClass *base) {
+		SQClass *newclass = (SQClass *)SQ_MALLOC(sizeof(SQClass));
+		new (newclass) SQClass(ss, base);
+		return newclass;
+	}
+	~SQClass();
+	bool NewSlot(SQSharedState *ss, const SQObjectPtr &key,const SQObjectPtr &val,bool bstatic);
+	bool Get(const SQObjectPtr &key,SQObjectPtr &val) {
+		if(_members->Get(key,val)) {
+			if(_isfield(val)) {
+				SQObjectPtr &o = _defaultvalues[_member_idx(val)].val;
+				val = _realval(o);
+			}
+			else {
+				val = _methods[_member_idx(val)].val;
+			}
+			return true;
+		}
+		return false;
+	}
+	bool SetAttributes(const SQObjectPtr &key,const SQObjectPtr &val);
+	bool GetAttributes(const SQObjectPtr &key,SQObjectPtr &outval);
+	void Lock() { _locked = true; if(_base) _base->Lock(); }
+	void Release() {
+		if (_hook) { _hook(_typetag,0);}
+		sq_delete(this, SQClass);
+	}
+	void Finalize();
+#ifndef NO_GARBAGE_COLLECTOR
+	void Mark(SQCollectable ** );
+#endif
+	SQInteger Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval);
+	SQInstance *CreateInstance();
+	SQTable *_members;
+	SQClass *_base;
+	SQClassMemberVec _defaultvalues;
+	SQClassMemberVec _methods;
+	SQObjectPtrVec _metamethods;
+	SQObjectPtr _attributes;
+	SQUserPointer _typetag;
+	SQRELEASEHOOK _hook;
+	bool _locked;
+	SQInteger _udsize;
+};
+
+#define calcinstancesize(_theclass_) \
+	(_theclass_->_udsize + sizeof(SQInstance) + (sizeof(SQObjectPtr)*(_theclass_->_defaultvalues.size()>0?_theclass_->_defaultvalues.size()-1:0)))
+
+struct SQInstance : public SQDelegable
+{
+	void Init(SQSharedState *ss);
+	SQInstance(SQSharedState *ss, SQClass *c, SQInteger memsize);
+	SQInstance(SQSharedState *ss, SQInstance *c, SQInteger memsize);
+public:
+	static SQInstance* Create(SQSharedState *ss,SQClass *theclass) {
+
+		SQInteger size = calcinstancesize(theclass);
+		SQInstance *newinst = (SQInstance *)SQ_MALLOC(size);
+		new (newinst) SQInstance(ss, theclass,size);
+		if(theclass->_udsize) {
+			newinst->_userpointer = ((unsigned char *)newinst) + (size - theclass->_udsize);
+		}
+		return newinst;
+	}
+	SQInstance *Clone(SQSharedState *ss)
+	{
+		SQInteger size = calcinstancesize(_class);
+		SQInstance *newinst = (SQInstance *)SQ_MALLOC(size);
+		new (newinst) SQInstance(ss, this,size);
+		if(_class->_udsize) {
+			newinst->_userpointer = ((unsigned char *)newinst) + (size - _class->_udsize);
+		}
+		return newinst;
+	}
+	~SQInstance();
+	bool Get(const SQObjectPtr &key,SQObjectPtr &val)  {
+		if(_class->_members->Get(key,val)) {
+			if(_isfield(val)) {
+				SQObjectPtr &o = _values[_member_idx(val)];
+				val = _realval(o);
+			}
+			else {
+				val = _class->_methods[_member_idx(val)].val;
+			}
+			return true;
+		}
+		return false;
+	}
+	bool Set(const SQObjectPtr &key,const SQObjectPtr &val) {
+		SQObjectPtr idx;
+		if(_class->_members->Get(key,idx) && _isfield(idx)) {
+            _values[_member_idx(idx)] = val;
+			return true;
+		}
+		return false;
+	}
+	void Release() {
+		_uiRef++;
+		if (_hook) { _hook(_userpointer,0);}
+		_uiRef--;
+		if(_uiRef > 0) return;
+		SQInteger size = _memsize;
+		this->~SQInstance();
+		SQ_FREE(this, size);
+	}
+	void Finalize();
+#ifndef NO_GARBAGE_COLLECTOR
+	void Mark(SQCollectable ** );
+#endif
+	bool InstanceOf(SQClass *trg);
+	bool GetMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res);
+
+	SQClass *_class;
+	SQUserPointer _userpointer;
+	SQRELEASEHOOK _hook;
+	SQInteger _memsize;
+	SQObjectPtr _values[1];
+};
+
+#endif //_SQCLASS_H_
--- a/src/3rdparty/squirrel/squirrel/sqclosure.h
+++ b/src/3rdparty/squirrel/squirrel/sqclosure.h
@ -0,0 +1,122 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQCLOSURE_H_
+#define _SQCLOSURE_H_
+
+struct SQFunctionProto;
+
+struct SQClosure : public CHAINABLE_OBJ
+{
+private:
+	SQClosure(SQSharedState *ss,SQFunctionProto *func){_function=func; INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);}
+public:
+	static SQClosure *Create(SQSharedState *ss,SQFunctionProto *func){
+		SQClosure *nc=(SQClosure*)SQ_MALLOC(sizeof(SQClosure));
+		new (nc) SQClosure(ss,func);
+		return nc;
+	}
+	void Release(){
+		sq_delete(this,SQClosure);
+	}
+	SQClosure *Clone()
+	{
+		SQClosure * ret = SQClosure::Create(_opt_ss(this),_funcproto(_function));
+		ret->_env = _env;
+		ret->_outervalues.copy(_outervalues);
+		ret->_defaultparams.copy(_defaultparams);
+		return ret;
+	}
+	~SQClosure()
+	{
+		REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);
+	}
+	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);
+	void Finalize(){_outervalues.resize(0); }
+#endif
+	SQObjectPtr _env;
+	SQObjectPtr _function;
+	SQObjectPtrVec _outervalues;
+	SQObjectPtrVec _defaultparams;
+};
+//////////////////////////////////////////////
+struct SQGenerator : public CHAINABLE_OBJ
+{
+	enum SQGeneratorState{eRunning,eSuspended,eDead};
+private:
+	SQGenerator(SQSharedState *ss,SQClosure *closure){_closure=closure;_state=eRunning;_ci._generator=NULL;INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);}
+public:
+	static SQGenerator *Create(SQSharedState *ss,SQClosure *closure){
+		SQGenerator *nc=(SQGenerator*)SQ_MALLOC(sizeof(SQGenerator));
+		new (nc) SQGenerator(ss,closure);
+		return nc;
+	}
+	~SQGenerator()
+	{
+		REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);
+	}
+    void Kill(){
+		_state=eDead;
+		_stack.resize(0);
+		_closure=_null_;}
+	void Release(){
+		sq_delete(this,SQGenerator);
+	}
+	bool Yield(SQVM *v);
+	bool Resume(SQVM *v,SQInteger target);
+#ifndef NO_GARBAGE_COLLECTOR
+	void Mark(SQCollectable **chain);
+	void Finalize(){_stack.resize(0);_closure=_null_;}
+#endif
+	SQObjectPtr _closure;
+	SQObjectPtrVec _stack;
+	SQObjectPtrVec _vargsstack;
+	SQVM::CallInfo _ci;
+	ExceptionsTraps _etraps;
+	SQGeneratorState _state;
+};
+
+struct SQNativeClosure : public CHAINABLE_OBJ
+{
+private:
+	SQNativeClosure(SQSharedState *ss,SQFUNCTION func){_function=func;INIT_CHAIN();ADD_TO_CHAIN(&_ss(this)->_gc_chain,this);	}
+public:
+	static SQNativeClosure *Create(SQSharedState *ss,SQFUNCTION func)
+	{
+		SQNativeClosure *nc=(SQNativeClosure*)SQ_MALLOC(sizeof(SQNativeClosure));
+		new (nc) SQNativeClosure(ss,func);
+		return nc;
+	}
+	SQNativeClosure *Clone()
+	{
+		SQNativeClosure * ret = SQNativeClosure::Create(_opt_ss(this),_function);
+		ret->_env = _env;
+		ret->_name = _name;
+		ret->_outervalues.copy(_outervalues);
+		ret->_typecheck.copy(_typecheck);
+		ret->_nparamscheck = _nparamscheck;
+		return ret;
+	}
+	~SQNativeClosure()
+	{
+		REMOVE_FROM_CHAIN(&_ss(this)->_gc_chain,this);
+	}
+	void Release(){
+		sq_delete(this,SQNativeClosure);
+	}
+#ifndef NO_GARBAGE_COLLECTOR
+	void Mark(SQCollectable **chain);
+	void Finalize(){_outervalues.resize(0);}
+#endif
+	SQInteger _nparamscheck;
+	SQIntVec _typecheck;
+	SQObjectPtrVec _outervalues;
+	SQObjectPtr _env;
+	SQFUNCTION _function;
+	SQObjectPtr _name;
+};
+
+
+
+#endif //_SQCLOSURE_H_
--- a/src/3rdparty/squirrel/squirrel/sqcompiler.cpp
+++ b/src/3rdparty/squirrel/squirrel/sqcompiler.cpp
--- a/src/3rdparty/squirrel/squirrel/sqcompiler.h
+++ b/src/3rdparty/squirrel/squirrel/sqcompiler.h
@ -0,0 +1,77 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQCOMPILER_H_
+#define _SQCOMPILER_H_
+
+struct SQVM;
+
+#define	TK_IDENTIFIER	258
+#define	TK_STRING_LITERAL	259
+#define	TK_INTEGER	260
+#define	TK_FLOAT	261
+#define	TK_DELEGATE	262
+#define	TK_DELETE	263
+#define	TK_EQ	264
+#define	TK_NE	265
+#define	TK_LE	266
+#define	TK_GE	267
+#define	TK_SWITCH	268
+#define	TK_ARROW	269
+#define	TK_AND	270
+#define	TK_OR	271
+#define	TK_IF	272
+#define	TK_ELSE	273
+#define	TK_WHILE	274
+#define	TK_BREAK	275
+#define	TK_FOR	276
+#define	TK_DO	277
+#define	TK_NULL	278
+#define	TK_FOREACH	279
+#define	TK_IN	280
+#define	TK_NEWSLOT	281
+#define	TK_MODULO	282
+#define	TK_LOCAL	283
+#define	TK_CLONE	284
+#define	TK_FUNCTION	285
+#define	TK_RETURN	286
+#define	TK_TYPEOF	287
+#define	TK_UMINUS	288
+#define	TK_PLUSEQ	289
+#define	TK_MINUSEQ	290
+#define	TK_CONTINUE	291
+#define TK_YIELD 292
+#define TK_TRY 293
+#define TK_CATCH 294
+#define TK_THROW 295
+#define TK_SHIFTL 296
+#define TK_SHIFTR 297
+#define TK_RESUME 298
+#define TK_DOUBLE_COLON 299
+#define TK_CASE 300
+#define TK_DEFAULT 301
+#define TK_THIS 302
+#define TK_PLUSPLUS 303
+#define TK_MINUSMINUS 304
+#define TK_PARENT 305
+#define TK_USHIFTR 306
+#define TK_CLASS 307
+#define TK_EXTENDS 308
+#define TK_CONSTRUCTOR 310
+#define TK_INSTANCEOF 311
+#define TK_VARPARAMS 312
+#define TK_VARGC 313
+#define TK_VARGV 314
+#define TK_TRUE 315
+#define TK_FALSE 316
+#define TK_MULEQ 317
+#define TK_DIVEQ 318
+#define TK_MODEQ 319
+#define TK_ATTR_OPEN 320
+#define TK_ATTR_CLOSE 321
+#define TK_STATIC 322
+#define TK_ENUM 323
+#define TK_CONST 324
+
+
+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);
+#endif //_SQCOMPILER_H_
--- a/src/3rdparty/squirrel/squirrel/sqdebug.cpp
+++ b/src/3rdparty/squirrel/squirrel/sqdebug.cpp
@ -0,0 +1,104 @@
+/*
+	see copyright notice in squirrel.h
+*/
+#include <squirrel.h>
+#include "sqpcheader.h"
+#include <stdarg.h>
+#include "sqvm.h"
+#include "sqfuncproto.h"
+#include "sqclosure.h"
+#include "sqstring.h"
+
+SQRESULT sq_stackinfos(HSQUIRRELVM v, SQInteger level, SQStackInfos *si)
+{
+	SQInteger cssize = v->_callsstacksize;
+	if (cssize > level) {
+		memset(si, 0, sizeof(SQStackInfos));
+		SQVM::CallInfo &ci = v->_callsstack[cssize-level-1];
+		switch (type(ci._closure)) {
+		case OT_CLOSURE:{
+			SQFunctionProto *func = _funcproto(_closure(ci._closure)->_function);
+			if (type(func->_name) == OT_STRING)
+				si->funcname = _stringval(func->_name);
+			if (type(func->_sourcename) == OT_STRING)
+				si->source = _stringval(func->_sourcename);
+			si->line = func->GetLine(ci._ip);
+						}
+			break;
+		case OT_NATIVECLOSURE:
+			si->source = _SC("NATIVE");
+			si->funcname = _SC("unknown");
+			if(type(_nativeclosure(ci._closure)->_name) == OT_STRING)
+				si->funcname = _stringval(_nativeclosure(ci._closure)->_name);
+			si->line = -1;
+			break;
+		default: break; //shutup compiler
+		}
+		return SQ_OK;
+	}
+	return SQ_ERROR;
+}
+
+void SQVM::Raise_Error(const SQChar *s, ...)
+{
+	va_list vl;
+	va_start(vl, s);
+	scvsprintf(_sp(rsl((SQInteger)scstrlen(s)+(NUMBER_MAX_CHAR*2))), s, vl);
+	va_end(vl);
+	_lasterror = SQString::Create(_ss(this),_spval,-1);
+}
+
+void SQVM::Raise_Error(SQObjectPtr &desc)
+{
+	_lasterror = desc;
+}
+
+SQString *SQVM::PrintObjVal(const SQObject &o)
+{
+	switch(type(o)) {
+	case OT_STRING: return _string(o);
+	case OT_INTEGER:
+#if defined(_SQ64)
+		scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%ld"), _integer(o));
+#else
+		scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%d"), _integer(o));
+#endif
+		return SQString::Create(_ss(this), _spval);
+		break;
+	case OT_FLOAT:
+		scsprintf(_sp(rsl(NUMBER_MAX_CHAR+1)), _SC("%.14g"), _float(o));
+		return SQString::Create(_ss(this), _spval);
+		break;
+	default:
+		return SQString::Create(_ss(this), GetTypeName(o));
+	}
+}
+
+void SQVM::Raise_IdxError(SQObject &o)
+{
+	SQObjectPtr oval = PrintObjVal(o);
+	Raise_Error(_SC("the index '%.50s' does not exist"), _stringval(oval));
+}
+
+void SQVM::Raise_CompareError(const SQObject &o1, const SQObject &o2)
+{
+	SQObjectPtr oval1 = PrintObjVal(o1), oval2 = PrintObjVal(o2);
+	Raise_Error(_SC("comparsion between '%.50s' and '%.50s'"), _stringval(oval1), _stringval(oval2));
+}
+
+
+void SQVM::Raise_ParamTypeError(SQInteger nparam,SQInteger typemask,SQInteger type)
+{
+	SQObjectPtr exptypes = SQString::Create(_ss(this), _SC(""), -1);
+	SQInteger found = 0;
+	for(SQInteger i=0; i<16; i++)
+	{
+		SQInteger mask = 0x00000001 << i;
+		if(typemask & (mask)) {
+			if(found>0) StringCat(exptypes,SQString::Create(_ss(this), _SC("|"), -1), exptypes);
+			found ++;
+			StringCat(exptypes,SQString::Create(_ss(this), IdType2Name((SQObjectType)mask), -1), exptypes);
+		}
+	}
+	Raise_Error(_SC("parameter %d has an invalid type '%s' ; expected: '%s'"), nparam, IdType2Name((SQObjectType)type), _stringval(exptypes));
+}
--- a/src/3rdparty/squirrel/squirrel/sqfuncproto.h
+++ b/src/3rdparty/squirrel/squirrel/sqfuncproto.h
@ -0,0 +1,160 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQFUNCTION_H_
+#define _SQFUNCTION_H_
+
+#include "sqopcodes.h"
+
+enum SQOuterType {
+	otLOCAL = 0,
+	otSYMBOL = 1,
+	otOUTER = 2
+};
+
+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;
+};
+
+struct SQLocalVarInfo
+{
+	SQLocalVarInfo():_start_op(0),_end_op(0){}
+	SQLocalVarInfo(const SQLocalVarInfo &lvi)
+	{
+		_name=lvi._name;
+		_start_op=lvi._start_op;
+		_end_op=lvi._end_op;
+		_pos=lvi._pos;
+	}
+	SQObjectPtr _name;
+	SQUnsignedInteger _start_op;
+	SQUnsignedInteger _end_op;
+	SQUnsignedInteger _pos;
+};
+
+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)) \
+		+(nparams*sizeof(SQObjectPtr))+(nfuncs*sizeof(SQObjectPtr)) \
+		+(nouters*sizeof(SQOuterVar))+(nlineinf*sizeof(SQLineInfo)) \
+		+(localinf*sizeof(SQLocalVarInfo))+(defparams*sizeof(SQInteger)))
+
+#define _CONSTRUCT_VECTOR(type,size,ptr) { \
+	for(SQInteger n = 0; n < size; n++) { \
+			new (&ptr[n]) type(); \
+		} \
+}
+
+#define _DESTRUCT_VECTOR(type,size,ptr) { \
+	for(SQInteger nl = 0; nl < size; nl++) { \
+			ptr[nl].~type(); \
+	} \
+}
+struct SQFunctionProto : public SQRefCounted
+{
+private:
+	SQFunctionProto(){
+	_stacksize=0;
+	_bgenerator=false;}
+public:
+	static SQFunctionProto *Create(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;
+		f->_ninstructions = ninstructions;
+		f->_literals = (SQObjectPtr*)&f->_instructions[ninstructions];
+		f->_nliterals = nliterals;
+		f->_parameters = (SQObjectPtr*)&f->_literals[nliterals];
+		f->_nparameters = nparameters;
+		f->_functions = (SQObjectPtr*)&f->_parameters[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->_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,_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);
+	static bool Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret);
+
+	SQObjectPtr _sourcename;
+	SQObjectPtr _name;
+    SQInteger _stacksize;
+	bool _bgenerator;
+	bool _varparams;
+
+	SQInteger _nlocalvarinfos;
+	SQLocalVarInfo *_localvarinfos;
+
+	SQInteger _nlineinfos;
+	SQLineInfo *_lineinfos;
+
+	SQInteger _nliterals;
+	SQObjectPtr *_literals;
+
+	SQInteger _nparameters;
+	SQObjectPtr *_parameters;
+
+	SQInteger _nfunctions;
+	SQObjectPtr *_functions;
+
+	SQInteger _noutervalues;
+	SQOuterVar *_outervalues;
+
+	SQInteger _ndefaultparams;
+	SQInteger *_defaultparams;
+
+	SQInteger _ninstructions;
+	SQInstruction _instructions[1];
+};
+
+#endif //_SQFUNCTION_H_
--- a/src/3rdparty/squirrel/squirrel/sqfuncstate.cpp
+++ b/src/3rdparty/squirrel/squirrel/sqfuncstate.cpp
@ -0,0 +1,572 @@
+/*
+	see copyright notice in squirrel.h
+*/
+#include "sqpcheader.h"
+#include "sqcompiler.h"
+#include "sqfuncproto.h"
+#include "sqstring.h"
+#include "sqtable.h"
+#include "sqopcodes.h"
+#include "sqfuncstate.h"
+
+#ifdef _DEBUG_DUMP
+SQInstructionDesc g_InstrDesc[]={
+	{_SC("_OP_LINE")},
+	{_SC("_OP_LOAD")},
+	{_SC("_OP_LOADINT")},
+	{_SC("_OP_LOADFLOAT")},
+	{_SC("_OP_DLOAD")},
+	{_SC("_OP_TAILCALL")},
+	{_SC("_OP_CALL")},
+	{_SC("_OP_PREPCALL")},
+	{_SC("_OP_PREPCALLK")},
+	{_SC("_OP_GETK")},
+	{_SC("_OP_MOVE")},
+	{_SC("_OP_NEWSLOT")},
+	{_SC("_OP_DELETE")},
+	{_SC("_OP_SET")},
+	{_SC("_OP_GET")},
+	{_SC("_OP_EQ")},
+	{_SC("_OP_NE")},
+	{_SC("_OP_ARITH")},
+	{_SC("_OP_BITW")},
+	{_SC("_OP_RETURN")},
+	{_SC("_OP_LOADNULLS")},
+	{_SC("_OP_LOADROOTTABLE")},
+	{_SC("_OP_LOADBOOL")},
+	{_SC("_OP_DMOVE")},
+	{_SC("_OP_JMP")},
+	{_SC("_OP_JNZ")},
+	{_SC("_OP_JZ")},
+	{_SC("_OP_LOADFREEVAR")},
+	{_SC("_OP_VARGC")},
+	{_SC("_OP_GETVARGV")},
+	{_SC("_OP_NEWTABLE")},
+	{_SC("_OP_NEWARRAY")},
+	{_SC("_OP_APPENDARRAY")},
+	{_SC("_OP_GETPARENT")},
+	{_SC("_OP_COMPARITH")},
+	{_SC("_OP_COMPARITHL")},
+	{_SC("_OP_INC")},
+	{_SC("_OP_INCL")},
+	{_SC("_OP_PINC")},
+	{_SC("_OP_PINCL")},
+	{_SC("_OP_CMP")},
+	{_SC("_OP_EXISTS")},
+	{_SC("_OP_INSTANCEOF")},
+	{_SC("_OP_AND")},
+	{_SC("_OP_OR")},
+	{_SC("_OP_NEG")},
+	{_SC("_OP_NOT")},
+	{_SC("_OP_BWNOT")},
+	{_SC("_OP_CLOSURE")},
+	{_SC("_OP_YIELD")},
+	{_SC("_OP_RESUME")},
+	{_SC("_OP_FOREACH")},
+	{_SC("_OP_POSTFOREACH")},
+	{_SC("_OP_DELEGATE")},
+	{_SC("_OP_CLONE")},
+	{_SC("_OP_TYPEOF")},
+	{_SC("_OP_PUSHTRAP")},
+	{_SC("_OP_POPTRAP")},
+	{_SC("_OP_THROW")},
+	{_SC("_OP_CLASS")},
+	{_SC("_OP_NEWSLOTA")},
+	{_SC("_OP_SCOPE_END")}
+};
+#endif
+void DumpLiteral(SQObjectPtr &o)
+{
+	switch(type(o)){
+		case OT_STRING:	scprintf(_SC("\"%s\""),_stringval(o));break;
+		case OT_FLOAT: scprintf(_SC("{%f}"),_float(o));break;
+#if defined(_SQ64)
+		case OT_INTEGER: scprintf(_SC("{%ld}"),_integer(o));break;
+#else
+		case OT_INTEGER: scprintf(_SC("{%d}"),_integer(o));break;
+#endif
+		case OT_BOOL: scprintf(_SC("%s"),_integer(o)?_SC("true"):_SC("false"));break;
+		default: scprintf(_SC("(%s %p)"),GetTypeName(o),_rawval(o));break; break; //shut up compiler
+	}
+}
+
+SQFuncState::SQFuncState(SQSharedState *ss,SQFuncState *parent,CompilerErrorFunc efunc,void *ed)
+{
+		_nliterals = 0;
+		_literals = SQTable::Create(ss,0);
+		_strings =  SQTable::Create(ss,0);
+		_sharedstate = ss;
+		_lastline = 0;
+		_optimization = true;
+		_parent = parent;
+		_stacksize = 0;
+		_traps = 0;
+		_returnexp = 0;
+		_varparams = false;
+		_errfunc = efunc;
+		_errtarget = ed;
+		_bgenerator = false;
+
+}
+
+void SQFuncState::Error(const SQChar *err)
+{
+	_errfunc(_errtarget,err);
+}
+
+#ifdef _DEBUG_DUMP
+void SQFuncState::Dump(SQFunctionProto *func)
+{
+	SQUnsignedInteger n=0,i;
+	SQInteger si;
+	scprintf(_SC("SQInstruction sizeof %d\n"),sizeof(SQInstruction));
+	scprintf(_SC("SQObject sizeof %d\n"),sizeof(SQObject));
+	scprintf(_SC("--------------------------------------------------------------------\n"));
+	scprintf(_SC("*****FUNCTION [%s]\n"),type(func->_name)==OT_STRING?_stringval(func->_name):_SC("unknown"));
+	scprintf(_SC("-----LITERALS\n"));
+	SQObjectPtr refidx,key,val;
+	SQInteger idx;
+	SQObjectPtrVec templiterals;
+	templiterals.resize(_nliterals);
+	while((idx=_table(_literals)->Next(false,refidx,key,val))!=-1) {
+		refidx=idx;
+		templiterals[_integer(val)]=key;
+	}
+	for(i=0;i<templiterals.size();i++){
+		scprintf(_SC("[%d] "),n);
+		DumpLiteral(templiterals[i]);
+		scprintf(_SC("\n"));
+		n++;
+	}
+	scprintf(_SC("-----PARAMS\n"));
+	if(_varparams)
+		scprintf(_SC("<<VARPARAMS>>\n"));
+	n=0;
+	for(i=0;i<_parameters.size();i++){
+		scprintf(_SC("[%d] "),n);
+		DumpLiteral(_parameters[i]);
+		scprintf(_SC("\n"));
+		n++;
+	}
+	scprintf(_SC("-----LOCALS\n"));
+	for(si=0;si<func->_nlocalvarinfos;si++){
+		SQLocalVarInfo lvi=func->_localvarinfos[si];
+		scprintf(_SC("[%d] %s \t%d %d\n"),lvi._pos,_stringval(lvi._name),lvi._start_op,lvi._end_op);
+		n++;
+	}
+	scprintf(_SC("-----LINE INFO\n"));
+	for(i=0;i<_lineinfos.size();i++){
+		SQLineInfo li=_lineinfos[i];
+		scprintf(_SC("op [%d] line [%d] \n"),li._op,li._line);
+		n++;
+	}
+	scprintf(_SC("-----dump\n"));
+	n=0;
+	for(i=0;i<_instructions.size();i++){
+		SQInstruction &inst=_instructions[i];
+		if(inst.op==_OP_LOAD || inst.op==_OP_DLOAD || inst.op==_OP_PREPCALLK || inst.op==_OP_GETK ){
+
+			SQInteger lidx = inst._arg1;
+			scprintf(_SC("[%03d] %15s %d "),n,g_InstrDesc[inst.op].name,inst._arg0);
+			if(lidx >= 0xFFFFFFFF)
+				scprintf(_SC("null"));
+			else {
+				SQInteger refidx;
+				SQObjectPtr val,key,refo;
+				while(((refidx=_table(_literals)->Next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) {
+					refo = refidx;
+				}
+				DumpLiteral(key);
+			}
+			if(inst.op != _OP_DLOAD) {
+				scprintf(_SC(" %d %d \n"),inst._arg2,inst._arg3);
+			}
+			else {
+				scprintf(_SC(" %d "),inst._arg2);
+				lidx = inst._arg3;
+				if(lidx >= 0xFFFFFFFF)
+					scprintf(_SC("null"));
+				else {
+					SQInteger refidx;
+					SQObjectPtr val,key,refo;
+					while(((refidx=_table(_literals)->Next(false,refo,key,val))!= -1) && (_integer(val) != lidx)) {
+						refo = refidx;
+				}
+				DumpLiteral(key);
+				scprintf(_SC("\n"));
+			}
+			}
+		}
+		else if(inst.op==_OP_LOADFLOAT) {
+			scprintf(_SC("[%03d] %15s %d %f %d %d\n"),n,g_InstrDesc[inst.op].name,inst._arg0,*((SQFloat*)&inst._arg1),inst._arg2,inst._arg3);
+		}
+		else if(inst.op==_OP_ARITH){
+			scprintf(_SC("[%03d] %15s %d %d %d %c\n"),n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3);
+		}
+		else
+			scprintf(_SC("[%03d] %15s %d %d %d %d\n"),n,g_InstrDesc[inst.op].name,inst._arg0,inst._arg1,inst._arg2,inst._arg3);
+		n++;
+	}
+	scprintf(_SC("-----\n"));
+	scprintf(_SC("stack size[%d]\n"),func->_stacksize);
+	scprintf(_SC("--------------------------------------------------------------------\n\n"));
+}
+#endif
+
+SQInteger SQFuncState::GetNumericConstant(const SQInteger cons)
+{
+	return GetConstant(SQObjectPtr(cons));
+}
+
+SQInteger SQFuncState::GetNumericConstant(const SQFloat cons)
+{
+	return GetConstant(SQObjectPtr(cons));
+}
+
+SQInteger SQFuncState::GetConstant(const SQObject &cons)
+{
+	SQObjectPtr val;
+	if(!_table(_literals)->Get(cons,val))
+	{
+		val = _nliterals;
+		_table(_literals)->NewSlot(cons,val);
+		_nliterals++;
+		if(_nliterals > MAX_LITERALS) {
+			val.Null();
+			Error(_SC("internal compiler error: too many literals"));
+		}
+	}
+	return _integer(val);
+}
+
+void SQFuncState::SetIntructionParams(SQInteger pos,SQInteger arg0,SQInteger arg1,SQInteger arg2,SQInteger arg3)
+{
+	_instructions[pos]._arg0=(unsigned char)*((SQUnsignedInteger *)&arg0);
+	_instructions[pos]._arg1=(SQInt32)*((SQUnsignedInteger *)&arg1);
+	_instructions[pos]._arg2=(unsigned char)*((SQUnsignedInteger *)&arg2);
+	_instructions[pos]._arg3=(unsigned char)*((SQUnsignedInteger *)&arg3);
+}
+
+void SQFuncState::SetIntructionParam(SQInteger pos,SQInteger arg,SQInteger val)
+{
+	switch(arg){
+		case 0:_instructions[pos]._arg0=(unsigned char)*((SQUnsignedInteger *)&val);break;
+		case 1:case 4:_instructions[pos]._arg1=(SQInt32)*((SQUnsignedInteger *)&val);break;
+		case 2:_instructions[pos]._arg2=(unsigned char)*((SQUnsignedInteger *)&val);break;
+		case 3:_instructions[pos]._arg3=(unsigned char)*((SQUnsignedInteger *)&val);break;
+	};
+}
+
+SQInteger SQFuncState::AllocStackPos()
+{
+	SQInteger npos=_vlocals.size();
+	_vlocals.push_back(SQLocalVarInfo());
+	if(_vlocals.size()>((SQUnsignedInteger)_stacksize)) {
+		if(_stacksize>MAX_FUNC_STACKSIZE) Error(_SC("internal compiler error: too many locals"));
+		_stacksize=_vlocals.size();
+	}
+	return npos;
+}
+
+SQInteger SQFuncState::PushTarget(SQInteger n)
+{
+	if(n!=-1){
+		_targetstack.push_back(n);
+		return n;
+	}
+	n=AllocStackPos();
+	_targetstack.push_back(n);
+	return n;
+}
+
+SQInteger SQFuncState::GetUpTarget(SQInteger n){
+	return _targetstack[((_targetstack.size()-1)-n)];
+}
+
+SQInteger SQFuncState::TopTarget(){
+	return _targetstack.back();
+}
+SQInteger SQFuncState::PopTarget()
+{
+	SQInteger npos=_targetstack.back();
+	SQLocalVarInfo t=_vlocals[_targetstack.back()];
+	if(type(t._name)==OT_NULL){
+		_vlocals.pop_back();
+	}
+	_targetstack.pop_back();
+	return npos;
+}
+
+SQInteger SQFuncState::GetStackSize()
+{
+	return _vlocals.size();
+}
+
+void SQFuncState::SetStackSize(SQInteger n)
+{
+	SQInteger size=_vlocals.size();
+	while(size>n){
+		size--;
+		SQLocalVarInfo lvi=_vlocals.back();
+		if(type(lvi._name)!=OT_NULL){
+			lvi._end_op=GetCurrentPos();
+			_localvarinfos.push_back(lvi);
+		}
+		_vlocals.pop_back();
+	}
+}
+
+bool SQFuncState::IsConstant(const SQObject &name,SQObject &e)
+{
+	SQObjectPtr val;
+	if(_table(_sharedstate->_consts)->Get(name,val)) {
+		e = val;
+		return true;
+	}
+	return false;
+}
+
+bool SQFuncState::IsLocal(SQUnsignedInteger stkpos)
+{
+	if(stkpos>=_vlocals.size())return false;
+	else if(type(_vlocals[stkpos]._name)!=OT_NULL)return true;
+	return false;
+}
+
+SQInteger SQFuncState::PushLocalVariable(const SQObject &name)
+{
+	SQInteger pos=_vlocals.size();
+	SQLocalVarInfo lvi;
+	lvi._name=name;
+	lvi._start_op=GetCurrentPos()+1;
+	lvi._pos=_vlocals.size();
+	_vlocals.push_back(lvi);
+	if(_vlocals.size()>((SQUnsignedInteger)_stacksize))_stacksize=_vlocals.size();
+
+	return pos;
+}
+
+SQInteger SQFuncState::GetLocalVariable(const SQObject &name)
+{
+	SQInteger locals=_vlocals.size();
+	while(locals>=1){
+		if(type(_vlocals[locals-1]._name)==OT_STRING && _string(_vlocals[locals-1]._name)==_string(name)){
+			return locals-1;
+		}
+		locals--;
+	}
+	return -1;
+}
+
+SQInteger SQFuncState::GetOuterVariable(const SQObject &name)
+{
+	SQInteger outers = _outervalues.size();
+	for(SQInteger i = 0; i<outers; i++) {
+		if(_string(_outervalues[i]._name) == _string(name))
+			return i;
+	}
+	return -1;
+}
+
+void SQFuncState::AddOuterValue(const SQObject &name)
+{
+	SQInteger pos=-1;
+	if(_parent) {
+		pos = _parent->GetLocalVariable(name);
+		if(pos == -1) {
+			pos = _parent->GetOuterVariable(name);
+			if(pos != -1) {
+				_outervalues.push_back(SQOuterVar(name,SQObjectPtr(SQInteger(pos)),otOUTER)); //local
+				return;
+			}
+		}
+		else {
+			_outervalues.push_back(SQOuterVar(name,SQObjectPtr(SQInteger(pos)),otLOCAL)); //local
+			return;
+		}
+	}
+	_outervalues.push_back(SQOuterVar(name,name,otSYMBOL)); //global
+}
+
+void SQFuncState::AddParameter(const SQObject &name)
+{
+	PushLocalVariable(name);
+	_parameters.push_back(name);
+}
+
+void SQFuncState::AddLineInfos(SQInteger line,bool lineop,bool force)
+{
+	if(_lastline!=line || force){
+		SQLineInfo li;
+		li._line=line;li._op=(GetCurrentPos()+1);
+		if(lineop)AddInstruction(_OP_LINE,0,line);
+		_lineinfos.push_back(li);
+		_lastline=line;
+	}
+}
+
+void SQFuncState::AddInstruction(SQInstruction &i)
+{
+	SQInteger size = _instructions.size();
+	if(size > 0 && _optimization){ //simple optimizer
+		SQInstruction &pi = _instructions[size-1];//previous instruction
+		switch(i.op) {
+		case _OP_RETURN:
+			if( _parent && i._arg0 != MAX_FUNC_STACKSIZE && pi.op == _OP_CALL && _returnexp < size-1) {
+				pi.op = _OP_TAILCALL;
+			}
+		break;
+		case _OP_GET:
+			if( pi.op == _OP_LOAD && pi._arg0 == i._arg2 && (!IsLocal(pi._arg0))){
+				pi._arg1 = pi._arg1;
+				pi._arg2 = (unsigned char)i._arg1;
+				pi.op = _OP_GETK;
+				pi._arg0 = i._arg0;
+
+				return;
+			}
+		break;
+		case _OP_PREPCALL:
+			if( pi.op == _OP_LOAD  && pi._arg0 == i._arg1 && (!IsLocal(pi._arg0))){
+				pi.op = _OP_PREPCALLK;
+				pi._arg0 = i._arg0;
+				pi._arg1 = pi._arg1;
+				pi._arg2 = i._arg2;
+				pi._arg3 = i._arg3;
+				return;
+			}
+			break;
+		case _OP_APPENDARRAY:
+			if(pi.op == _OP_LOAD && pi._arg0 == i._arg1 && (!IsLocal(pi._arg0))){
+				pi.op = _OP_APPENDARRAY;
+				pi._arg0 = i._arg0;
+				pi._arg1 = pi._arg1;
+				pi._arg2 = MAX_FUNC_STACKSIZE;
+				pi._arg3 = MAX_FUNC_STACKSIZE;
+				return;
+			}
+			break;
+		case _OP_MOVE:
+			if((pi.op == _OP_GET || pi.op == _OP_ARITH || pi.op == _OP_BITW) && (pi._arg0 == i._arg1))
+			{
+				pi._arg0 = i._arg0;
+				_optimization = false;
+				return;
+			}
+
+			if(pi.op == _OP_MOVE)
+			{
+				pi.op = _OP_DMOVE;
+				pi._arg2 = i._arg0;
+				pi._arg3 = (unsigned char)i._arg1;
+				return;
+			}
+			break;
+		case _OP_LOAD:
+			if(pi.op == _OP_LOAD && i._arg1 < 256) {
+				pi.op = _OP_DLOAD;
+				pi._arg2 = i._arg0;
+				pi._arg3 = (unsigned char)i._arg1;
+				return;
+			}
+			break;
+		case _OP_EQ:case _OP_NE:
+			if(pi.op == _OP_LOAD && pi._arg0 == i._arg1 && (!IsLocal(pi._arg0) ))
+			{
+				pi.op = i.op;
+				pi._arg0 = i._arg0;
+				pi._arg1 = pi._arg1;
+				pi._arg2 = i._arg2;
+				pi._arg3 = MAX_FUNC_STACKSIZE;
+				return;
+			}
+			break;
+		case _OP_LOADNULLS:
+			if((pi.op == _OP_LOADNULLS && pi._arg0+pi._arg1 == i._arg0)) {
+
+				pi._arg1 = pi._arg1 + 1;
+				pi.op = _OP_LOADNULLS;
+				return;
+			}
+            break;
+		case _OP_LINE:
+			if(pi.op == _OP_LINE) {
+				_instructions.pop_back();
+				_lineinfos.pop_back();
+			}
+			break;
+		}
+	}
+	_optimization = true;
+	_instructions.push_back(i);
+}
+
+SQObject SQFuncState::CreateString(const SQChar *s,SQInteger len)
+{
+	SQObjectPtr ns(SQString::Create(_sharedstate,s,len));
+	_table(_strings)->NewSlot(ns,(SQInteger)1);
+	return ns;
+}
+
+SQObject SQFuncState::CreateTable()
+{
+	SQObjectPtr nt(SQTable::Create(_sharedstate,0));
+	_table(_strings)->NewSlot(nt,(SQInteger)1);
+	return nt;
+}
+
+SQFunctionProto *SQFuncState::BuildProto()
+{
+	SQFunctionProto *f=SQFunctionProto::Create(_instructions.size(),
+		_nliterals,_parameters.size(),_functions.size(),_outervalues.size(),
+		_lineinfos.size(),_localvarinfos.size(),_defaultparams.size());
+
+	SQObjectPtr refidx,key,val;
+	SQInteger idx;
+
+	f->_stacksize = _stacksize;
+	f->_sourcename = _sourcename;
+	f->_bgenerator = _bgenerator;
+	f->_name = _name;
+
+	while((idx=_table(_literals)->Next(false,refidx,key,val))!=-1) {
+		f->_literals[_integer(val)]=key;
+		refidx=idx;
+	}
+
+	for(SQUnsignedInteger nf = 0; nf < _functions.size(); nf++) f->_functions[nf] = _functions[nf];
+	for(SQUnsignedInteger np = 0; np < _parameters.size(); np++) f->_parameters[np] = _parameters[np];
+	for(SQUnsignedInteger no = 0; no < _outervalues.size(); no++) f->_outervalues[no] = _outervalues[no];
+	for(SQUnsignedInteger no = 0; no < _localvarinfos.size(); no++) f->_localvarinfos[no] = _localvarinfos[no];
+	for(SQUnsignedInteger no = 0; no < _lineinfos.size(); no++) f->_lineinfos[no] = _lineinfos[no];
+	for(SQUnsignedInteger no = 0; no < _defaultparams.size(); no++) f->_defaultparams[no] = _defaultparams[no];
+
+	memcpy(f->_instructions,&_instructions[0],_instructions.size()*sizeof(SQInstruction));
+
+	f->_varparams = _varparams;
+
+	return f;
+}
+
+SQFuncState *SQFuncState::PushChildState(SQSharedState *ss)
+{
+	SQFuncState *child = (SQFuncState *)sq_malloc(sizeof(SQFuncState));
+	new (child) SQFuncState(ss,this,_errfunc,_errtarget);
+	_childstates.push_back(child);
+	return child;
+}
+
+void SQFuncState::PopChildState()
+{
+	SQFuncState *child = _childstates.back();
+	sq_delete(child,SQFuncState);
+	_childstates.pop_back();
+}
+
+SQFuncState::~SQFuncState()
+{
+	while(_childstates.size() > 0)
+	{
+		PopChildState();
+	}
+}
--- a/src/3rdparty/squirrel/squirrel/sqfuncstate.h
+++ b/src/3rdparty/squirrel/squirrel/sqfuncstate.h
@ -0,0 +1,85 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQFUNCSTATE_H_
+#define _SQFUNCSTATE_H_
+///////////////////////////////////
+#include "squtils.h"
+
+struct SQFuncState
+{
+	SQFuncState(SQSharedState *ss,SQFuncState *parent,CompilerErrorFunc efunc,void *ed);
+	~SQFuncState();
+#ifdef _DEBUG_DUMP
+	void Dump(SQFunctionProto *func);
+#endif
+	void Error(const SQChar *err);
+	SQFuncState *PushChildState(SQSharedState *ss);
+	void PopChildState();
+	void AddInstruction(SQOpcode _op,SQInteger arg0=0,SQInteger arg1=0,SQInteger arg2=0,SQInteger arg3=0){SQInstruction i(_op,arg0,arg1,arg2,arg3);AddInstruction(i);}
+	void AddInstruction(SQInstruction &i);
+	void SetIntructionParams(SQInteger pos,SQInteger arg0,SQInteger arg1,SQInteger arg2=0,SQInteger arg3=0);
+	void SetIntructionParam(SQInteger pos,SQInteger arg,SQInteger val);
+	SQInstruction &GetInstruction(SQInteger pos){return _instructions[pos];}
+	void PopInstructions(SQInteger size){for(SQInteger i=0;i<size;i++)_instructions.pop_back();}
+	void SetStackSize(SQInteger n);
+	void SnoozeOpt(){_optimization=false;}
+	void AddDefaultParam(SQInteger trg) { _defaultparams.push_back(trg); }
+	SQInteger GetDefaultParamCount() { return _defaultparams.size(); }
+	SQInteger GetCurrentPos(){return _instructions.size()-1;}
+	SQInteger GetNumericConstant(const SQInteger cons);
+	SQInteger GetNumericConstant(const SQFloat cons);
+	SQInteger PushLocalVariable(const SQObject &name);
+	void AddParameter(const SQObject &name);
+	void AddOuterValue(const SQObject &name);
+	SQInteger GetLocalVariable(const SQObject &name);
+	SQInteger GetOuterVariable(const SQObject &name);
+	SQInteger GenerateCode();
+	SQInteger GetStackSize();
+	SQInteger CalcStackFrameSize();
+	void AddLineInfos(SQInteger line,bool lineop,bool force=false);
+	SQFunctionProto *BuildProto();
+	SQInteger AllocStackPos();
+	SQInteger PushTarget(SQInteger n=-1);
+	SQInteger PopTarget();
+	SQInteger TopTarget();
+	SQInteger GetUpTarget(SQInteger n);
+	bool IsLocal(SQUnsignedInteger stkpos);
+	SQObject CreateString(const SQChar *s,SQInteger len = -1);
+	SQObject CreateTable();
+	bool IsConstant(const SQObject &name,SQObject &e);
+	SQInteger _returnexp;
+	SQLocalVarInfoVec _vlocals;
+	SQIntVec _targetstack;
+	SQInteger _stacksize;
+	bool _varparams;
+	bool _bgenerator;
+	SQIntVec _unresolvedbreaks;
+	SQIntVec _unresolvedcontinues;
+	SQObjectPtrVec _functions;
+	SQObjectPtrVec _parameters;
+	SQOuterVarVec _outervalues;
+	SQInstructionVec _instructions;
+	SQLocalVarInfoVec _localvarinfos;
+	SQObjectPtr _literals;
+	SQObjectPtr _strings;
+	SQObjectPtr _name;
+	SQObjectPtr _sourcename;
+	SQInteger _nliterals;
+	SQLineInfoVec _lineinfos;
+	SQFuncState *_parent;
+	SQIntVec _breaktargets;
+	SQIntVec _continuetargets;
+	SQIntVec _defaultparams;
+	SQInteger _lastline;
+	SQInteger _traps; //contains number of nested exception traps
+	bool _optimization;
+	SQSharedState *_sharedstate;
+	sqvector<SQFuncState*> _childstates;
+	SQInteger GetConstant(const SQObject &cons);
+private:
+	CompilerErrorFunc _errfunc;
+	void *_errtarget;
+};
+
+
+#endif //_SQFUNCSTATE_H_
+
--- a/src/3rdparty/squirrel/squirrel/sqlexer.cpp
+++ b/src/3rdparty/squirrel/squirrel/sqlexer.cpp
@ -0,0 +1,476 @@
+/*
+	see copyright notice in squirrel.h
+*/
+#include "sqpcheader.h"
+#include <ctype.h>
+#include <stdlib.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() {Next();_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) _keywords->NewSlot( SQString::Create(ss, _SC(#key)) ,SQInteger(id))
+
+SQLexer::SQLexer(){}
+SQLexer::~SQLexer()
+{
+	_keywords->Release();
+}
+
+void SQLexer::Init(SQSharedState *ss, SQLEXREADFUNC rg, SQUserPointer up,CompilerErrorFunc efunc,void *ed)
+{
+	_errfunc = efunc;
+	_errtarget = ed;
+	_sharedstate = ss;
+	_keywords = SQTable::Create(ss, 26);
+	ADD_KEYWORD(while, TK_WHILE);
+	ADD_KEYWORD(do, TK_DO);
+	ADD_KEYWORD(if, TK_IF);
+	ADD_KEYWORD(else, TK_ELSE);
+	ADD_KEYWORD(break, TK_BREAK);
+	ADD_KEYWORD(continue, TK_CONTINUE);
+	ADD_KEYWORD(return, TK_RETURN);
+	ADD_KEYWORD(null, TK_NULL);
+	ADD_KEYWORD(function, TK_FUNCTION);
+	ADD_KEYWORD(local, TK_LOCAL);
+	ADD_KEYWORD(for, TK_FOR);
+	ADD_KEYWORD(foreach, TK_FOREACH);
+	ADD_KEYWORD(in, TK_IN);
+	ADD_KEYWORD(typeof, TK_TYPEOF);
+	ADD_KEYWORD(delegate, TK_DELEGATE);
+	ADD_KEYWORD(delete, TK_DELETE);
+	ADD_KEYWORD(try, TK_TRY);
+	ADD_KEYWORD(catch, TK_CATCH);
+	ADD_KEYWORD(throw, TK_THROW);
+	ADD_KEYWORD(clone, TK_CLONE);
+	ADD_KEYWORD(yield, TK_YIELD);
+	ADD_KEYWORD(resume, TK_RESUME);
+	ADD_KEYWORD(switch, TK_SWITCH);
+	ADD_KEYWORD(case, TK_CASE);
+	ADD_KEYWORD(default, TK_DEFAULT);
+	ADD_KEYWORD(this, TK_THIS);
+	ADD_KEYWORD(parent,TK_PARENT);
+	ADD_KEYWORD(class,TK_CLASS);
+	ADD_KEYWORD(extends,TK_EXTENDS);
+	ADD_KEYWORD(constructor,TK_CONSTRUCTOR);
+	ADD_KEYWORD(instanceof,TK_INSTANCEOF);
+	ADD_KEYWORD(vargc,TK_VARGC);
+	ADD_KEYWORD(vargv,TK_VARGV);
+	ADD_KEYWORD(true,TK_TRUE);
+	ADD_KEYWORD(false,TK_FALSE);
+	ADD_KEYWORD(static,TK_STATIC);
+	ADD_KEYWORD(enum,TK_ENUM);
+	ADD_KEYWORD(const,TK_CONST);
+
+	_readf = rg;
+	_up = up;
+	_lasttokenline = _currentline = 1;
+	_currentcolumn = 0;
+	_prevtoken = -1;
+	Next();
+}
+
+void SQLexer::Error(const SQChar *err)
+{
+	_errfunc(_errtarget,err);
+}
+
+void SQLexer::Next()
+{
+	SQInteger t = _readf(_up);
+	if(t > MAX_CHAR) Error(_SC("Invalid character"));
+	if(t != 0) {
+		_currdata = (LexChar)t;
+		return;
+	}
+	_currdata = SQUIRREL_EOB;
+}
+
+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;
+}
+
+void SQLexer::LexBlockComment()
+{
+	bool done = false;
+	while(!done) {
+		switch(CUR_CHAR) {
+			case _SC('*'): { NEXT(); if(CUR_CHAR == _SC('/')) { done = true; NEXT(); }}; continue;
+			case _SC('\n'): _currentline++; NEXT(); continue;
+			case SQUIRREL_EOB: Error(_SC("missing \"*/\" in comment"));
+			default: NEXT();
+		}
+	}
+}
+
+SQInteger SQLexer::Lex()
+{
+	_lasttokenline = _currentline;
+	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();
+			switch(CUR_CHAR){
+			case _SC('*'):
+				NEXT();
+				LexBlockComment();
+				continue;
+			case _SC('/'):
+				do { NEXT(); } while (CUR_CHAR != _SC('\n') && (!IS_EOB()));
+				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(); RETURN_TOKEN(TK_EQ); }
+		case _SC('<'):
+			NEXT();
+			if ( CUR_CHAR == _SC('=') ) { NEXT(); RETURN_TOKEN(TK_LE) }
+			else if ( CUR_CHAR == _SC('-') ) { NEXT(); RETURN_TOKEN(TK_NEWSLOT); }
+			else if ( CUR_CHAR == _SC('<') ) { NEXT(); RETURN_TOKEN(TK_SHIFTL); }
+			else if ( CUR_CHAR == _SC('/') ) { NEXT(); RETURN_TOKEN(TK_ATTR_OPEN); }
+			//else if ( CUR_CHAR == _SC('[') ) { NEXT(); ReadMultilineString(); RETURN_TOKEN(TK_STRING_LITERAL); }
+			else { 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(); RETURN_TOKEN(TK_NE); }
+		case _SC('@'): {
+			SQInteger stype;
+			NEXT();
+			if(CUR_CHAR != _SC('"'))
+				Error(_SC("string expected"));
+			if((stype=ReadString(_SC('"'),true))!=-1) {
+				RETURN_TOKEN(stype);
+			}
+			Error(_SC("error parsing the string"));
+					   }
+		case _SC('"'):
+		case _SC('\''): {
+			SQInteger stype;
+			if((stype=ReadString(CUR_CHAR,false))!=-1){
+				RETURN_TOKEN(stype);
+			}
+			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 ret = CUR_CHAR;
+			NEXT(); RETURN_TOKEN(ret); }
+		case _SC('.'):
+			NEXT();
+			if (CUR_CHAR != _SC('.')){ RETURN_TOKEN('.') }
+			NEXT();
+			if (CUR_CHAR != _SC('.')){ Error(_SC("invalid token '..'")); }
+			NEXT();
+			RETURN_TOKEN(TK_VARPARAMS);
+		case _SC('&'):
+			NEXT();
+			if (CUR_CHAR != _SC('&')){ RETURN_TOKEN('&') }
+			else { NEXT(); RETURN_TOKEN(TK_AND); }
+		case _SC('|'):
+			NEXT();
+			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 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();
+					RETURN_TOKEN(ret);
+				}
+				else if (scisalpha(CUR_CHAR) || CUR_CHAR == _SC('_')) {
+					SQInteger t = ReadID();
+					RETURN_TOKEN(t);
+				}
+				else {
+					SQInteger c = CUR_CHAR;
+					if (sciscntrl((int)c)) Error(_SC("unexpected character(control)"));
+					NEXT();
+					RETURN_TOKEN(c);
+				}
+				RETURN_TOKEN(0);
+			}
+		}
+	}
+	return 0;
+}
+
+SQInteger SQLexer::GetIDType(SQChar *s)
+{
+	SQObjectPtr t;
+	if(_keywords->Get(SQString::Create(_sharedstate, s), t)) {
+		return SQInteger(_integer(t));
+	}
+	return TK_IDENTIFIER;
+}
+
+
+SQInteger SQLexer::ReadString(SQChar ndelim,bool verbatim)
+{
+	INIT_TEMP_STRING();
+	NEXT();
+	if(IS_EOB()) return -1;
+	for(;;) {
+		while(CUR_CHAR != ndelim) {
+			switch(CUR_CHAR) {
+			case SQUIRREL_EOB:
+				Error(_SC("unfinished string"));
+				return -1;
+			case _SC('\n'):
+				if(!verbatim) 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'): NEXT(); {
+						if(!isxdigit(CUR_CHAR)) Error(_SC("hexadecimal number expected"));
+						const SQInteger maxdigits = 4;
+						SQChar temp[maxdigits+1];
+						SQInteger n = 0;
+						while(isxdigit(CUR_CHAR) && n < maxdigits) {
+							temp[n] = CUR_CHAR;
+							n++;
+							NEXT();
+						}
+						temp[n] = 0;
+						SQChar *sTemp;
+						APPEND_CHAR((SQChar)scstrtoul(temp,&sTemp,16));
+					}
+				    break;
+					case _SC('t'): APPEND_CHAR(_SC('\t')); NEXT(); break;
+					case _SC('a'): APPEND_CHAR(_SC('\a')); NEXT(); break;
+					case _SC('b'): APPEND_CHAR(_SC('\b')); NEXT(); break;
+					case _SC('n'): APPEND_CHAR(_SC('\n')); NEXT(); break;
+					case _SC('r'): APPEND_CHAR(_SC('\r')); NEXT(); break;
+					case _SC('v'): APPEND_CHAR(_SC('\v')); NEXT(); break;
+					case _SC('f'): APPEND_CHAR(_SC('\f')); NEXT(); break;
+					case _SC('0'): APPEND_CHAR(_SC('\0')); NEXT(); break;
+					case _SC('\\'): APPEND_CHAR(_SC('\\')); NEXT(); break;
+					case _SC('"'): APPEND_CHAR(_SC('"')); NEXT(); break;
+					case _SC('\''): APPEND_CHAR(_SC('\'')); NEXT(); break;
+					default:
+						Error(_SC("unrecognised escaper char"));
+					break;
+					}
+				}
+				break;
+			default:
+				APPEND_CHAR(CUR_CHAR);
+				NEXT();
+			}
+		}
+		NEXT();
+		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) Error(_SC("empty constant"));
+		if(len > 1) 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(SQChar 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;
+	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)) Error(_SC("invalid octal number"));
+		}
+		else {
+			NEXT();
+			type = THEX;
+			while(isxdigit(CUR_CHAR)) {
+				APPEND_CHAR(CUR_CHAR);
+				NEXT();
+			}
+			if(_longstr.size() > MAX_HEX_DIGITS) 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('.')) type = TFLOAT;
+			if(isexponent(CUR_CHAR)) {
+				if(type != TFLOAT) 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)) 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],(SQUnsignedInteger *)&_nvalue);
+		return TK_INTEGER;
+	case THEX:
+		LexHexadecimal(&_longstr[0],(SQUnsignedInteger *)&_nvalue);
+		return TK_INTEGER;
+	case TOCTAL:
+		LexOctal(&_longstr[0],(SQUnsignedInteger *)&_nvalue);
+		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]);
+	if(res == TK_IDENTIFIER || res == TK_CONSTRUCTOR) {
+		_svalue = &_longstr[0];
+	}
+	return res;
+}
--- a/src/3rdparty/squirrel/squirrel/sqlexer.h
+++ b/src/3rdparty/squirrel/squirrel/sqlexer.h
@ -0,0 +1,45 @@
+/*	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();
+	~SQLexer();
+	void Init(SQSharedState *ss,SQLEXREADFUNC rg,SQUserPointer up,CompilerErrorFunc efunc,void *ed);
+	void Error(const SQChar *err);
+	SQInteger Lex();
+	const SQChar *Tok2Str(SQInteger tok);
+private:
+	SQInteger GetIDType(SQChar *s);
+	SQInteger ReadString(SQChar ndelim,bool verbatim);
+	SQInteger ReadNumber();
+	void LexBlockComment();
+	SQInteger ReadID();
+	void Next();
+	SQInteger _curtoken;
+	SQTable *_keywords;
+public:
+	SQInteger _prevtoken;
+	SQInteger _currentline;
+	SQInteger _lasttokenline;
+	SQInteger _currentcolumn;
+	const SQChar *_svalue;
+	SQInteger _nvalue;
+	SQFloat _fvalue;
+	SQLEXREADFUNC _readf;
+	SQUserPointer _up;
+	LexChar _currdata;
+	SQSharedState *_sharedstate;
+	sqvector<SQChar> _longstr;
+	CompilerErrorFunc _errfunc;
+	void *_errtarget;
+};
+
+#endif
--- a/src/3rdparty/squirrel/squirrel/sqmem.cpp
+++ b/src/3rdparty/squirrel/squirrel/sqmem.cpp
@ -0,0 +1,9 @@
+/*
+	see copyright notice in squirrel.h
+*/
+#include "sqpcheader.h"
+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_free(void *p, SQUnsignedInteger size){	free(p); }
--- a/src/3rdparty/squirrel/squirrel/sqobject.cpp
+++ b/src/3rdparty/squirrel/squirrel/sqobject.cpp
@ -0,0 +1,587 @@
+/*
+	see copyright notice in squirrel.h
+*/
+#include "sqpcheader.h"
+#include "sqvm.h"
+#include "sqstring.h"
+#include "sqarray.h"
+#include "sqtable.h"
+#include "squserdata.h"
+#include "sqfuncproto.h"
+#include "sqclass.h"
+#include "sqclosure.h"
+
+
+const SQChar *IdType2Name(SQObjectType type)
+{
+	switch(_RAW_TYPE(type))
+	{
+	case _RT_NULL:return _SC("null");
+	case _RT_INTEGER:return _SC("integer");
+	case _RT_FLOAT:return _SC("float");
+	case _RT_BOOL:return _SC("bool");
+	case _RT_STRING:return _SC("string");
+	case _RT_TABLE:return _SC("table");
+	case _RT_ARRAY:return _SC("array");
+	case _RT_GENERATOR:return _SC("generator");
+	case _RT_CLOSURE:
+	case _RT_NATIVECLOSURE:
+		return _SC("function");
+	case _RT_USERDATA:
+	case _RT_USERPOINTER:
+		return _SC("userdata");
+	case _RT_THREAD: return _SC("thread");
+	case _RT_FUNCPROTO: return _SC("function");
+	case _RT_CLASS: return _SC("class");
+	case _RT_INSTANCE: return _SC("instance");
+	case _RT_WEAKREF: return _SC("weakref");
+	default:
+		return NULL;
+	}
+}
+
+const SQChar *GetTypeName(const SQObjectPtr &obj1)
+{
+	return IdType2Name(type(obj1));
+}
+
+SQString *SQString::Create(SQSharedState *ss,const SQChar *s,SQInteger len)
+{
+	SQString *str=ADD_STRING(ss,s,len);
+	str->_sharedstate=ss;
+	return str;
+}
+
+void SQString::Release()
+{
+	REMOVE_STRING(_sharedstate,this);
+}
+
+SQInteger SQString::Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval)
+{
+	SQInteger idx = (SQInteger)TranslateIndex(refpos);
+	while(idx < _len){
+		outkey = (SQInteger)idx;
+		outval = SQInteger(_val[idx]);
+		//return idx for the next iteration
+		return ++idx;
+	}
+	//nothing to iterate anymore
+	return -1;
+}
+
+SQUnsignedInteger TranslateIndex(const SQObjectPtr &idx)
+{
+	switch(type(idx)){
+		case OT_NULL:
+			return 0;
+		case OT_INTEGER:
+			return (SQUnsignedInteger)_integer(idx);
+		default: assert(0); break;
+	}
+	return 0;
+}
+
+SQWeakRef *SQRefCounted::GetWeakRef(SQObjectType type)
+{
+	if(!_weakref) {
+		sq_new(_weakref,SQWeakRef);
+		_weakref->_obj._type = type;
+		_weakref->_obj._unVal.pRefCounted = this;
+	}
+	return _weakref;
+}
+
+SQRefCounted::~SQRefCounted()
+{
+	if(_weakref) {
+		_weakref->_obj._type = OT_NULL;
+		_weakref->_obj._unVal.pRefCounted = NULL;
+	}
+}
+
+void SQWeakRef::Release() {
+	if(ISREFCOUNTED(_obj._type)) {
+		_obj._unVal.pRefCounted->_weakref = NULL;
+	}
+	sq_delete(this,SQWeakRef);
+}
+
+bool SQDelegable::GetMetaMethod(SQVM *v,SQMetaMethod mm,SQObjectPtr &res) {
+	if(_delegate) {
+		return _delegate->Get((*_ss(v)->_metamethods)[mm],res);
+	}
+	return false;
+}
+
+bool SQDelegable::SetDelegate(SQTable *mt)
+{
+	SQTable *temp = mt;
+	if(temp == this) return false;
+	while (temp) {
+		if (temp->_delegate == this) return false; //cycle detected
+		temp = temp->_delegate;
+	}
+	if (mt)	__ObjAddRef(mt);
+	__ObjRelease(_delegate);
+	_delegate = mt;
+	return true;
+}
+
+bool SQGenerator::Yield(SQVM *v)
+{
+	if(_state==eSuspended) { v->Raise_Error(_SC("internal vm error, yielding dead generator"));  return false;}
+	if(_state==eDead) { v->Raise_Error(_SC("internal vm error, yielding a dead generator")); return false; }
+	SQInteger size = v->_top-v->_stackbase;
+	_ci=*v->ci;
+	_stack.resize(size);
+	for(SQInteger n =0; n<size; n++) {
+		_stack._vals[n] = v->_stack[v->_stackbase+n];
+		v->_stack[v->_stackbase+n] = _null_;
+	}
+	SQInteger nvargs = v->ci->_vargs.size;
+	SQInteger vargsbase = v->ci->_vargs.base;
+	for(SQInteger j = nvargs - 1; j >= 0; j--) {
+		_vargsstack.push_back(v->_vargsstack[vargsbase+j]);
+	}
+	_ci._generator=NULL;
+	for(SQInteger i=0;i<_ci._etraps;i++) {
+		_etraps.push_back(v->_etraps.top());
+		v->_etraps.pop_back();
+	}
+	_state=eSuspended;
+	return true;
+}
+
+bool SQGenerator::Resume(SQVM *v,SQInteger target)
+{
+	SQInteger size=_stack.size();
+	if(_state==eDead){ v->Raise_Error(_SC("resuming dead generator")); return false; }
+	if(_state==eRunning){ v->Raise_Error(_SC("resuming active generator")); return false; }
+	SQInteger prevtop=v->_top-v->_stackbase;
+	PUSH_CALLINFO(v,_ci);
+	SQInteger oldstackbase=v->_stackbase;
+	v->_stackbase = v->_top;
+	v->ci->_target = (SQInt32)target;
+	v->ci->_generator = this;
+	v->ci->_vargs.size = (unsigned short)_vargsstack.size();
+
+	for(SQInteger i=0;i<_ci._etraps;i++) {
+		v->_etraps.push_back(_etraps.top());
+		_etraps.pop_back();
+	}
+	for(SQInteger n =0; n<size; n++) {
+		v->_stack[v->_stackbase+n] = _stack._vals[n];
+		_stack._vals[0] = _null_;
+	}
+	while(_vargsstack.size()) {
+		v->_vargsstack.push_back(_vargsstack.back());
+		_vargsstack.pop_back();
+	}
+	v->ci->_vargs.base = (unsigned short)(v->_vargsstack.size() - v->ci->_vargs.size);
+	v->_top=v->_stackbase+size;
+	v->ci->_prevtop = (SQInt32)prevtop;
+	v->ci->_prevstkbase = (SQInt32)(v->_stackbase - oldstackbase);
+	_state=eRunning;
+	if (type(v->_debughook) != OT_NULL && _rawval(v->_debughook) != _rawval(v->ci->_closure))
+		v->CallDebugHook(_SC('c'));
+
+	return true;
+}
+
+void SQArray::Extend(const SQArray *a){
+	SQInteger xlen;
+	if((xlen=a->Size()))
+		for(SQInteger i=0;i<xlen;i++)
+			Append(a->_values[i]);
+}
+
+const SQChar* SQFunctionProto::GetLocal(SQVM *vm,SQUnsignedInteger stackbase,SQUnsignedInteger nseq,SQUnsignedInteger nop)
+{
+	SQUnsignedInteger nvars=_nlocalvarinfos;
+	const SQChar *res=NULL;
+	if(nvars>=nseq){
+ 		for(SQUnsignedInteger i=0;i<nvars;i++){
+			if(_localvarinfos[i]._start_op<=nop && _localvarinfos[i]._end_op>=nop)
+			{
+				if(nseq==0){
+					vm->Push(vm->_stack[stackbase+_localvarinfos[i]._pos]);
+					res=_stringval(_localvarinfos[i]._name);
+					break;
+				}
+				nseq--;
+			}
+		}
+	}
+	return res;
+}
+
+SQInteger SQFunctionProto::GetLine(SQInstruction *curr)
+{
+	SQInteger op = (SQInteger)(curr-_instructions);
+	SQInteger line=_lineinfos[0]._line;
+	for(SQInteger i=1;i<_nlineinfos;i++){
+		if(_lineinfos[i]._op>=op)
+			return line;
+		line=_lineinfos[i]._line;
+	}
+	return line;
+}
+
+#define _CHECK_IO(exp)  { if(!exp)return false; }
+bool SafeWrite(HSQUIRRELVM v,SQWRITEFUNC write,SQUserPointer up,SQUserPointer dest,SQInteger size)
+{
+	if(write(up,dest,size) != size) {
+		v->Raise_Error(_SC("io error (write function failure)"));
+		return false;
+	}
+	return true;
+}
+
+bool SafeRead(HSQUIRRELVM v,SQWRITEFUNC read,SQUserPointer up,SQUserPointer dest,SQInteger size)
+{
+	if(size && read(up,dest,size) != size) {
+		v->Raise_Error(_SC("io error, read function failure, the origin stream could be corrupted/trucated"));
+		return false;
+	}
+	return true;
+}
+
+bool WriteTag(HSQUIRRELVM v,SQWRITEFUNC write,SQUserPointer up,SQInteger tag)
+{
+	return SafeWrite(v,write,up,&tag,sizeof(tag));
+}
+
+bool CheckTag(HSQUIRRELVM v,SQWRITEFUNC read,SQUserPointer up,SQInteger tag)
+{
+	SQInteger t;
+	_CHECK_IO(SafeRead(v,read,up,&t,sizeof(t)));
+	if(t != tag){
+		v->Raise_Error(_SC("invalid or corrupted closure stream"));
+		return false;
+	}
+	return true;
+}
+
+bool WriteObject(HSQUIRRELVM v,SQUserPointer up,SQWRITEFUNC write,SQObjectPtr &o)
+{
+	_CHECK_IO(SafeWrite(v,write,up,&type(o),sizeof(SQObjectType)));
+	switch(type(o)){
+	case OT_STRING:
+		_CHECK_IO(SafeWrite(v,write,up,&_string(o)->_len,sizeof(SQInteger)));
+		_CHECK_IO(SafeWrite(v,write,up,_stringval(o),rsl(_string(o)->_len)));
+		break;
+	case OT_INTEGER:
+		_CHECK_IO(SafeWrite(v,write,up,&_integer(o),sizeof(SQInteger)));break;
+	case OT_FLOAT:
+		_CHECK_IO(SafeWrite(v,write,up,&_float(o),sizeof(SQFloat)));break;
+	case OT_NULL:
+		break;
+	default:
+		v->Raise_Error(_SC("cannot serialize a %s"),GetTypeName(o));
+		return false;
+	}
+	return true;
+}
+
+bool ReadObject(HSQUIRRELVM v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &o)
+{
+	SQObjectType t;
+	_CHECK_IO(SafeRead(v,read,up,&t,sizeof(SQObjectType)));
+	switch(t){
+	case OT_STRING:{
+		SQInteger len;
+		_CHECK_IO(SafeRead(v,read,up,&len,sizeof(SQInteger)));
+		_CHECK_IO(SafeRead(v,read,up,_ss(v)->GetScratchPad(rsl(len)),rsl(len)));
+		o=SQString::Create(_ss(v),_ss(v)->GetScratchPad(-1),len);
+				   }
+		break;
+	case OT_INTEGER:{
+		SQInteger i;
+		_CHECK_IO(SafeRead(v,read,up,&i,sizeof(SQInteger))); o = i; break;
+					}
+	case OT_FLOAT:{
+		SQFloat f;
+		_CHECK_IO(SafeRead(v,read,up,&f,sizeof(SQFloat))); o = f; break;
+				  }
+	case OT_NULL:
+		o=_null_;
+		break;
+	default:
+		v->Raise_Error(_SC("cannot serialize a %s"),IdType2Name(t));
+		return false;
+	}
+	return true;
+}
+
+bool SQClosure::Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write)
+{
+	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_HEAD));
+	_CHECK_IO(WriteTag(v,write,up,sizeof(SQChar)));
+	_CHECK_IO(_funcproto(_function)->Save(v,up,write));
+	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_TAIL));
+	return true;
+}
+
+bool SQClosure::Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret)
+{
+	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_HEAD));
+	_CHECK_IO(CheckTag(v,read,up,sizeof(SQChar)));
+	SQObjectPtr func;
+	_CHECK_IO(SQFunctionProto::Load(v,up,read,func));
+	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_TAIL));
+	ret = SQClosure::Create(_ss(v),_funcproto(func));
+	return true;
+}
+
+bool SQFunctionProto::Save(SQVM *v,SQUserPointer up,SQWRITEFUNC write)
+{
+	SQInteger i,nliterals = _nliterals,nparameters = _nparameters;
+	SQInteger noutervalues = _noutervalues,nlocalvarinfos = _nlocalvarinfos;
+	SQInteger nlineinfos=_nlineinfos,ninstructions = _ninstructions,nfunctions=_nfunctions;
+	SQInteger ndefaultparams = _ndefaultparams;
+	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
+	_CHECK_IO(WriteObject(v,up,write,_sourcename));
+	_CHECK_IO(WriteObject(v,up,write,_name));
+	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
+	_CHECK_IO(SafeWrite(v,write,up,&nliterals,sizeof(nliterals)));
+	_CHECK_IO(SafeWrite(v,write,up,&nparameters,sizeof(nparameters)));
+	_CHECK_IO(SafeWrite(v,write,up,&noutervalues,sizeof(noutervalues)));
+	_CHECK_IO(SafeWrite(v,write,up,&nlocalvarinfos,sizeof(nlocalvarinfos)));
+	_CHECK_IO(SafeWrite(v,write,up,&nlineinfos,sizeof(nlineinfos)));
+	_CHECK_IO(SafeWrite(v,write,up,&ndefaultparams,sizeof(ndefaultparams)));
+	_CHECK_IO(SafeWrite(v,write,up,&ninstructions,sizeof(ninstructions)));
+	_CHECK_IO(SafeWrite(v,write,up,&nfunctions,sizeof(nfunctions)));
+	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
+	for(i=0;i<nliterals;i++){
+		_CHECK_IO(WriteObject(v,up,write,_literals[i]));
+	}
+
+	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
+	for(i=0;i<nparameters;i++){
+		_CHECK_IO(WriteObject(v,up,write,_parameters[i]));
+	}
+
+	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
+	for(i=0;i<noutervalues;i++){
+		_CHECK_IO(SafeWrite(v,write,up,&_outervalues[i]._type,sizeof(SQUnsignedInteger)));
+		_CHECK_IO(WriteObject(v,up,write,_outervalues[i]._src));
+		_CHECK_IO(WriteObject(v,up,write,_outervalues[i]._name));
+	}
+
+	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
+	for(i=0;i<nlocalvarinfos;i++){
+		SQLocalVarInfo &lvi=_localvarinfos[i];
+		_CHECK_IO(WriteObject(v,up,write,lvi._name));
+		_CHECK_IO(SafeWrite(v,write,up,&lvi._pos,sizeof(SQUnsignedInteger)));
+		_CHECK_IO(SafeWrite(v,write,up,&lvi._start_op,sizeof(SQUnsignedInteger)));
+		_CHECK_IO(SafeWrite(v,write,up,&lvi._end_op,sizeof(SQUnsignedInteger)));
+	}
+
+	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
+	_CHECK_IO(SafeWrite(v,write,up,_lineinfos,sizeof(SQLineInfo)*nlineinfos));
+
+	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
+	_CHECK_IO(SafeWrite(v,write,up,_defaultparams,sizeof(SQInteger)*ndefaultparams));
+
+	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
+	_CHECK_IO(SafeWrite(v,write,up,_instructions,sizeof(SQInstruction)*ninstructions));
+
+	_CHECK_IO(WriteTag(v,write,up,SQ_CLOSURESTREAM_PART));
+	for(i=0;i<nfunctions;i++){
+		_CHECK_IO(_funcproto(_functions[i])->Save(v,up,write));
+	}
+	_CHECK_IO(SafeWrite(v,write,up,&_stacksize,sizeof(_stacksize)));
+	_CHECK_IO(SafeWrite(v,write,up,&_bgenerator,sizeof(_bgenerator)));
+	_CHECK_IO(SafeWrite(v,write,up,&_varparams,sizeof(_varparams)));
+	return true;
+}
+
+bool SQFunctionProto::Load(SQVM *v,SQUserPointer up,SQREADFUNC read,SQObjectPtr &ret)
+{
+	SQInteger i, nliterals,nparameters;
+	SQInteger noutervalues ,nlocalvarinfos ;
+	SQInteger nlineinfos,ninstructions ,nfunctions,ndefaultparams ;
+	SQObjectPtr sourcename, name;
+	SQObjectPtr o;
+	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
+	_CHECK_IO(ReadObject(v, up, read, sourcename));
+	_CHECK_IO(ReadObject(v, up, read, name));
+
+	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
+	_CHECK_IO(SafeRead(v,read,up, &nliterals, sizeof(nliterals)));
+	_CHECK_IO(SafeRead(v,read,up, &nparameters, sizeof(nparameters)));
+	_CHECK_IO(SafeRead(v,read,up, &noutervalues, sizeof(noutervalues)));
+	_CHECK_IO(SafeRead(v,read,up, &nlocalvarinfos, sizeof(nlocalvarinfos)));
+	_CHECK_IO(SafeRead(v,read,up, &nlineinfos, sizeof(nlineinfos)));
+	_CHECK_IO(SafeRead(v,read,up, &ndefaultparams, sizeof(ndefaultparams)));
+	_CHECK_IO(SafeRead(v,read,up, &ninstructions, sizeof(ninstructions)));
+	_CHECK_IO(SafeRead(v,read,up, &nfunctions, sizeof(nfunctions)));
+
+
+	SQFunctionProto *f = SQFunctionProto::Create(ninstructions,nliterals,nparameters,
+			nfunctions,noutervalues,nlineinfos,nlocalvarinfos,ndefaultparams);
+	SQObjectPtr proto = f; //gets a ref in case of failure
+	f->_sourcename = sourcename;
+	f->_name = name;
+
+	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
+
+	for(i = 0;i < nliterals; i++){
+		_CHECK_IO(ReadObject(v, up, read, o));
+		f->_literals[i] = o;
+	}
+	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
+
+	for(i = 0; i < nparameters; i++){
+		_CHECK_IO(ReadObject(v, up, read, o));
+		f->_parameters[i] = o;
+	}
+	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
+
+	for(i = 0; i < noutervalues; i++){
+		SQUnsignedInteger type;
+		SQObjectPtr name;
+		_CHECK_IO(SafeRead(v,read,up, &type, sizeof(SQUnsignedInteger)));
+		_CHECK_IO(ReadObject(v, up, read, o));
+		_CHECK_IO(ReadObject(v, up, read, name));
+		f->_outervalues[i] = SQOuterVar(name,o, (SQOuterType)type);
+	}
+	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
+
+	for(i = 0; i < nlocalvarinfos; i++){
+		SQLocalVarInfo lvi;
+		_CHECK_IO(ReadObject(v, up, read, lvi._name));
+		_CHECK_IO(SafeRead(v,read,up, &lvi._pos, sizeof(SQUnsignedInteger)));
+		_CHECK_IO(SafeRead(v,read,up, &lvi._start_op, sizeof(SQUnsignedInteger)));
+		_CHECK_IO(SafeRead(v,read,up, &lvi._end_op, sizeof(SQUnsignedInteger)));
+		f->_localvarinfos[i] = lvi;
+	}
+	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
+	_CHECK_IO(SafeRead(v,read,up, f->_lineinfos, sizeof(SQLineInfo)*nlineinfos));
+
+	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
+	_CHECK_IO(SafeRead(v,read,up, f->_defaultparams, sizeof(SQInteger)*ndefaultparams));
+
+	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
+	_CHECK_IO(SafeRead(v,read,up, f->_instructions, sizeof(SQInstruction)*ninstructions));
+
+	_CHECK_IO(CheckTag(v,read,up,SQ_CLOSURESTREAM_PART));
+	for(i = 0; i < nfunctions; i++){
+		_CHECK_IO(_funcproto(o)->Load(v, up, read, o));
+		f->_functions[i] = o;
+	}
+	_CHECK_IO(SafeRead(v,read,up, &f->_stacksize, sizeof(f->_stacksize)));
+	_CHECK_IO(SafeRead(v,read,up, &f->_bgenerator, sizeof(f->_bgenerator)));
+	_CHECK_IO(SafeRead(v,read,up, &f->_varparams, sizeof(f->_varparams)));
+
+	ret = f;
+	return true;
+}
+
+#ifndef NO_GARBAGE_COLLECTOR
+
+#define START_MARK() 	if(!(_uiRef&MARK_FLAG)){ \
+		_uiRef|=MARK_FLAG;
+
+#define END_MARK() RemoveFromChain(&_sharedstate->_gc_chain, this); \
+		AddToChain(chain, this); }
+
+void SQVM::Mark(SQCollectable **chain)
+{
+	START_MARK()
+		SQSharedState::MarkObject(_lasterror,chain);
+		SQSharedState::MarkObject(_errorhandler,chain);
+		SQSharedState::MarkObject(_debughook,chain);
+		SQSharedState::MarkObject(_roottable, chain);
+		SQSharedState::MarkObject(temp_reg, chain);
+		for(SQUnsignedInteger i = 0; i < _stack.size(); i++) SQSharedState::MarkObject(_stack[i], chain);
+		for(SQUnsignedInteger j = 0; j < _vargsstack.size(); j++) SQSharedState::MarkObject(_vargsstack[j], chain);
+		for(SQInteger k = 0; k < _callsstacksize; k++) SQSharedState::MarkObject(_callsstack[k]._closure, chain);
+	END_MARK()
+}
+
+void SQArray::Mark(SQCollectable **chain)
+{
+	START_MARK()
+		SQInteger len = _values.size();
+		for(SQInteger i = 0;i < len; i++) SQSharedState::MarkObject(_values[i], chain);
+	END_MARK()
+}
+void SQTable::Mark(SQCollectable **chain)
+{
+	START_MARK()
+		if(_delegate) _delegate->Mark(chain);
+		SQInteger len = _numofnodes;
+		for(SQInteger i = 0; i < len; i++){
+			SQSharedState::MarkObject(_nodes[i].key, chain);
+			SQSharedState::MarkObject(_nodes[i].val, chain);
+		}
+	END_MARK()
+}
+
+void SQClass::Mark(SQCollectable **chain)
+{
+	START_MARK()
+		_members->Mark(chain);
+		if(_base) _base->Mark(chain);
+		SQSharedState::MarkObject(_attributes, chain);
+		for(SQUnsignedInteger i =0; i< _defaultvalues.size(); i++) {
+			SQSharedState::MarkObject(_defaultvalues[i].val, chain);
+			SQSharedState::MarkObject(_defaultvalues[i].attrs, chain);
+		}
+		for(SQUnsignedInteger j =0; j< _methods.size(); j++) {
+			SQSharedState::MarkObject(_methods[j].val, chain);
+			SQSharedState::MarkObject(_methods[j].attrs, chain);
+		}
+		for(SQUnsignedInteger k =0; k< _metamethods.size(); k++) {
+			SQSharedState::MarkObject(_metamethods[k], chain);
+		}
+	END_MARK()
+}
+
+void SQInstance::Mark(SQCollectable **chain)
+{
+	START_MARK()
+		_class->Mark(chain);
+		SQUnsignedInteger nvalues = _class->_defaultvalues.size();
+		for(SQUnsignedInteger i =0; i< nvalues; i++) {
+			SQSharedState::MarkObject(_values[i], chain);
+		}
+	END_MARK()
+}
+
+void SQGenerator::Mark(SQCollectable **chain)
+{
+	START_MARK()
+		for(SQUnsignedInteger i = 0; i < _stack.size(); i++) SQSharedState::MarkObject(_stack[i], chain);
+		for(SQUnsignedInteger j = 0; j < _vargsstack.size(); j++) SQSharedState::MarkObject(_vargsstack[j], chain);
+		SQSharedState::MarkObject(_closure, chain);
+	END_MARK()
+}
+
+void SQClosure::Mark(SQCollectable **chain)
+{
+	START_MARK()
+		for(SQUnsignedInteger i = 0; i < _outervalues.size(); i++) SQSharedState::MarkObject(_outervalues[i], chain);
+		for(SQUnsignedInteger i = 0; i < _defaultparams.size(); i++) SQSharedState::MarkObject(_defaultparams[i], chain);
+	END_MARK()
+}
+
+void SQNativeClosure::Mark(SQCollectable **chain)
+{
+	START_MARK()
+		for(SQUnsignedInteger i = 0; i < _outervalues.size(); i++) SQSharedState::MarkObject(_outervalues[i], chain);
+	END_MARK()
+}
+
+void SQUserData::Mark(SQCollectable **chain){
+	START_MARK()
+		if(_delegate) _delegate->Mark(chain);
+	END_MARK()
+}
+
+void SQCollectable::UnMark() { _uiRef&=~MARK_FLAG; }
+
+#endif
+
--- a/src/3rdparty/squirrel/squirrel/sqobject.h
+++ b/src/3rdparty/squirrel/squirrel/sqobject.h
@ -0,0 +1,352 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQOBJECT_H_
+#define _SQOBJECT_H_
+
+#include "squtils.h"
+
+#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 MINPOWER2 4
+
+struct SQRefCounted
+{
+	SQRefCounted() { _uiRef = 0; _weakref = NULL; }
+	virtual ~SQRefCounted();
+	SQWeakRef *GetWeakRef(SQObjectType type);
+	SQUnsignedInteger _uiRef;
+	struct SQWeakRef *_weakref;
+	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 __AddRef(type,unval) if(ISREFCOUNTED(type))	\
+		{ \
+			unval.pRefCounted->_uiRef++; \
+		}
+
+#define __Release(type,unval) if(ISREFCOUNTED(type) && ((--unval.pRefCounted->_uiRef)<=0))	\
+		{	\
+			unval.pRefCounted->Release();	\
+		}
+
+#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 _refcounted(obj) ((obj)._unVal.pRefCounted)
+#define _rawval(obj) ((obj)._unVal.pRefCounted)
+
+#define _stringval(obj) (obj)._unVal.pString->_val
+#define _userdataval(obj) (obj)._unVal.pUserData->_val
+
+#define tofloat(num) ((type(num)==OT_INTEGER)?(SQFloat)_integer(num):_float(num))
+#define tointeger(num) ((type(num)==OT_FLOAT)?(SQInteger)_float(num):_integer(num))
+/////////////////////////////////////////////////////////////////////////////////////
+/////////////////////////////////////////////////////////////////////////////////////
+struct SQObjectPtr : public SQObject
+{
+	SQObjectPtr()
+	{
+		_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);
+	}
+	SQObjectPtr(SQTable *pTable)
+	{
+		_type=OT_TABLE;
+		_unVal.pTable=pTable;
+		assert(_unVal.pTable);
+		__AddRef(_type,_unVal);
+	}
+	SQObjectPtr(SQClass *pClass)
+	{
+		_type=OT_CLASS;
+		_unVal.pClass=pClass;
+		assert(_unVal.pClass);
+		__AddRef(_type,_unVal);
+	}
+	SQObjectPtr(SQInstance *pInstance)
+	{
+		_type=OT_INSTANCE;
+		_unVal.pInstance=pInstance;
+		assert(_unVal.pInstance);
+		__AddRef(_type,_unVal);
+	}
+	SQObjectPtr(SQArray *pArray)
+	{
+		_type=OT_ARRAY;
+		_unVal.pArray=pArray;
+		assert(_unVal.pArray);
+		__AddRef(_type,_unVal);
+	}
+	SQObjectPtr(SQClosure *pClosure)
+	{
+		_type=OT_CLOSURE;
+		_unVal.pClosure=pClosure;
+		assert(_unVal.pClosure);
+		__AddRef(_type,_unVal);
+	}
+	SQObjectPtr(SQGenerator *pGenerator)
+	{
+		_type=OT_GENERATOR;
+		_unVal.pGenerator=pGenerator;
+		assert(_unVal.pGenerator);
+		__AddRef(_type,_unVal);
+	}
+	SQObjectPtr(SQNativeClosure *pNativeClosure)
+	{
+		_type=OT_NATIVECLOSURE;
+		_unVal.pNativeClosure=pNativeClosure;
+		assert(_unVal.pNativeClosure);
+		__AddRef(_type,_unVal);
+	}
+	SQObjectPtr(SQString *pString)
+	{
+		_type=OT_STRING;
+		_unVal.pString=pString;
+		assert(_unVal.pString);
+		__AddRef(_type,_unVal);
+	}
+	SQObjectPtr(SQUserData *pUserData)
+	{
+		_type=OT_USERDATA;
+		_unVal.pUserData=pUserData;
+		assert(_unVal.pUserData);
+		__AddRef(_type,_unVal);
+	}
+	SQObjectPtr(SQVM *pThread)
+	{
+		_type=OT_THREAD;
+		_unVal.pThread=pThread;
+		assert(_unVal.pThread);
+		__AddRef(_type,_unVal);
+	}
+	SQObjectPtr(SQWeakRef *pWeakRef)
+	{
+		_type=OT_WEAKREF;
+		_unVal.pWeakRef=pWeakRef;
+		assert(_unVal.pWeakRef);
+		__AddRef(_type,_unVal);
+	}
+	SQObjectPtr(SQFunctionProto *pFunctionProto)
+	{
+		_type=OT_FUNCPROTO;
+		_unVal.pFunctionProto=pFunctionProto;
+		assert(_unVal.pFunctionProto);
+		__AddRef(_type,_unVal);
+	}
+	SQObjectPtr(SQInteger nInteger)
+	{
+		_unVal.pUserPointer=NULL;
+		_type=OT_INTEGER;
+		_unVal.nInteger=nInteger;
+	}
+	SQObjectPtr(SQFloat fFloat)
+	{
+		_unVal.pUserPointer=NULL;
+		_type=OT_FLOAT;
+		_unVal.fFloat=fFloat;
+	}
+	SQObjectPtr(bool bBool)
+	{
+		_unVal.pUserPointer=NULL;
+		_type = OT_BOOL;
+		_unVal.nInteger = bBool?1:0;
+	}
+	SQObjectPtr(SQUserPointer pUserPointer)
+	{
+		_type=OT_USERPOINTER;
+		_unVal.pUserPointer=pUserPointer;
+	}
+	~SQObjectPtr()
+	{
+		__Release(_type,_unVal);
+	}
+	inline void Null()
+	{
+		SQObjectType tOldType;
+		SQObjectValue unOldVal;
+		tOldType = _type;
+		unOldVal = _unVal;
+		_type = OT_NULL;
+		_unVal.pUserPointer = NULL;
+		__Release(tOldType,unOldVal);
+	}
+	inline SQObjectPtr& operator=(SQInteger i)
+	{
+		__Release(_type,_unVal);
+		_unVal.nInteger = i;
+		_type = OT_INTEGER;
+		return *this;
+	}
+	inline SQObjectPtr& operator=(SQFloat f)
+	{
+		__Release(_type,_unVal);
+		_unVal.fFloat = f;
+		_type = OT_FLOAT;
+		return *this;
+	}
+	inline SQObjectPtr& operator=(const SQObjectPtr& obj)
+	{
+		SQObjectType tOldType;
+		SQObjectValue unOldVal;
+		tOldType=_type;
+		unOldVal=_unVal;
+		_unVal = obj._unVal;
+		_type = obj._type;
+		__AddRef(_type,_unVal);
+		__Release(tOldType,unOldVal);
+		return *this;
+	}
+	inline SQObjectPtr& operator=(const SQObject& obj)
+	{
+		SQObjectType tOldType;
+		SQObjectValue unOldVal;
+		tOldType=_type;
+		unOldVal=_unVal;
+		_unVal = obj._unVal;
+		_type = obj._type;
+		__AddRef(_type,_unVal);
+		__Release(tOldType,unOldVal);
+		return *this;
+	}
+	private:
+		SQObjectPtr(const SQChar *){} //safety
+};
+/////////////////////////////////////////////////////////////////////////////////////
+#ifndef NO_GARBAGE_COLLECTOR
+#define MARK_FLAG 0x80000000
+struct SQCollectable : public SQRefCounted {
+	SQCollectable *_next;
+	SQCollectable *_prev;
+	SQSharedState *_sharedstate;
+	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 TranslateIndex(const SQObjectPtr &idx);
+typedef sqvector<SQObjectPtr> SQObjectPtrVec;
+typedef sqvector<SQInteger> SQIntVec;
+const SQChar *GetTypeName(const SQObjectPtr &obj1);
+const SQChar *IdType2Name(SQObjectType type);
+
+
+
+#endif //_SQOBJECT_H_
--- a/src/3rdparty/squirrel/squirrel/sqopcodes.h
+++ b/src/3rdparty/squirrel/squirrel/sqopcodes.h
@ -0,0 +1,116 @@
+/*	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
+};
+enum SQOpcode
+{
+	_OP_LINE=				0x00,
+	_OP_LOAD=				0x01,
+	_OP_LOADINT=			0x02,
+	_OP_LOADFLOAT=			0x03,
+	_OP_DLOAD=				0x04,
+	_OP_TAILCALL=			0x05,
+	_OP_CALL=				0x06,
+	_OP_PREPCALL=			0x07,
+	_OP_PREPCALLK=			0x08,
+	_OP_GETK=				0x09,
+	_OP_MOVE=				0x0A,
+	_OP_NEWSLOT=			0x0B,
+	_OP_DELETE=				0x0C,
+	_OP_SET=				0x0D,
+	_OP_GET=				0x0E,
+	_OP_EQ=					0x0F,
+	_OP_NE=					0x10,
+	_OP_ARITH=				0x11,
+	_OP_BITW=				0x12,
+	_OP_RETURN=				0x13,
+	_OP_LOADNULLS=			0x14,
+	_OP_LOADROOTTABLE=		0x15,
+	_OP_LOADBOOL=			0x16,
+	_OP_DMOVE=				0x17,
+	_OP_JMP=				0x18,
+	_OP_JNZ=				0x19,
+	_OP_JZ=					0x1A,
+	_OP_LOADFREEVAR=		0x1B,
+	_OP_VARGC=				0x1C,
+	_OP_GETVARGV=			0x1D,
+	_OP_NEWTABLE=			0x1E,
+	_OP_NEWARRAY=			0x1F,
+	_OP_APPENDARRAY=		0x20,
+	_OP_GETPARENT=			0x21,
+	_OP_COMPARITH=			0x22,
+	_OP_COMPARITHL=			0x23,
+	_OP_INC=				0x24,
+	_OP_INCL=				0x25,
+	_OP_PINC=				0x26,
+	_OP_PINCL=				0x27,
+	_OP_CMP=				0x28,
+	_OP_EXISTS=				0x29,
+	_OP_INSTANCEOF=			0x2A,
+	_OP_AND=				0x2B,
+	_OP_OR=					0x2C,
+	_OP_NEG=				0x2D,
+	_OP_NOT=				0x2E,
+	_OP_BWNOT=				0x2F,
+	_OP_CLOSURE=			0x30,
+	_OP_YIELD=				0x31,
+	_OP_RESUME=				0x32,
+	_OP_FOREACH=			0x33,
+	_OP_POSTFOREACH=		0x34,
+	_OP_DELEGATE=			0x35,
+	_OP_CLONE=				0x36,
+	_OP_TYPEOF=				0x37,
+	_OP_PUSHTRAP=			0x38,
+	_OP_POPTRAP=			0x39,
+	_OP_THROW=				0x3A,
+	_OP_CLASS=				0x3B,
+	_OP_NEWSLOTA=			0x3C,
+	_OP_SCOPE_END=		0x3D,
+};
+
+struct SQInstructionDesc {
+	const SQChar *name;
+};
+
+struct SQInstruction
+{
+	SQInstruction(){};
+	SQInstruction(SQOpcode _op,SQInteger a0=0,SQInteger a1=0,SQInteger a2=0,SQInteger a3=0)
+	{	op = _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_
--- a/src/3rdparty/squirrel/squirrel/sqpcheader.h
+++ b/src/3rdparty/squirrel/squirrel/sqpcheader.h
@ -0,0 +1,19 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQPCHEADER_H_
+#define _SQPCHEADER_H_
+
+#if defined(_MSC_VER) && defined(_DEBUG)
+#include <crtdbg.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include <new>
+//squirrel stuff
+#include <squirrel.h>
+#include "sqobject.h"
+#include "sqstate.h"
+
+#endif //_SQPCHEADER_H_
--- a/src/3rdparty/squirrel/squirrel/sqstate.cpp
+++ b/src/3rdparty/squirrel/squirrel/sqstate.cpp
@ -0,0 +1,572 @@
+/*
+	see copyright notice in squirrel.h
+*/
+#include "sqpcheader.h"
+#include "sqopcodes.h"
+#include "sqvm.h"
+#include "sqfuncproto.h"
+#include "sqclosure.h"
+#include "sqstring.h"
+#include "sqtable.h"
+#include "sqarray.h"
+#include "squserdata.h"
+#include "sqclass.h"
+
+SQObjectPtr _null_;
+SQObjectPtr _true_(true);
+SQObjectPtr _false_(false);
+SQObjectPtr _one_((SQInteger)1);
+SQObjectPtr _minusone_((SQInteger)-1);
+
+SQSharedState::SQSharedState()
+{
+	_compilererrorhandler = NULL;
+	_printfunc = NULL;
+	_debuginfo = false;
+	_notifyallexceptions = false;
+}
+
+#define newsysstring(s) {	\
+	_systemstrings->push_back(SQString::Create(this,s));	\
+	}
+
+#define newmetamethod(s) {	\
+	_metamethods->push_back(SQString::Create(this,s));	\
+	_table(_metamethodsmap)->NewSlot(_metamethods->back(),(SQInteger)(_metamethods->size()-1)); \
+	}
+
+bool CompileTypemask(SQIntVec &res,const SQChar *typemask)
+{
+	SQInteger i = 0;
+
+	SQInteger mask = 0;
+	while(typemask[i] != 0) {
+
+		switch(typemask[i]){
+				case 'o': mask |= _RT_NULL; break;
+				case 'i': mask |= _RT_INTEGER; break;
+				case 'f': mask |= _RT_FLOAT; break;
+				case 'n': mask |= (_RT_FLOAT | _RT_INTEGER); break;
+				case 's': mask |= _RT_STRING; break;
+				case 't': mask |= _RT_TABLE; break;
+				case 'a': mask |= _RT_ARRAY; break;
+				case 'u': mask |= _RT_USERDATA; break;
+				case 'c': mask |= (_RT_CLOSURE | _RT_NATIVECLOSURE); break;
+				case 'b': mask |= _RT_BOOL; break;
+				case 'g': mask |= _RT_GENERATOR; break;
+				case 'p': mask |= _RT_USERPOINTER; break;
+				case 'v': mask |= _RT_THREAD; break;
+				case 'x': mask |= _RT_INSTANCE; break;
+				case 'y': mask |= _RT_CLASS; break;
+				case 'r': mask |= _RT_WEAKREF; break;
+				case '.': mask = -1; res.push_back(mask); i++; mask = 0; continue;
+				case ' ': i++; continue; //ignores spaces
+				default:
+					return false;
+		}
+		i++;
+		if(typemask[i] == '|') {
+			i++;
+			if(typemask[i] == 0)
+				return false;
+			continue;
+		}
+		res.push_back(mask);
+		mask = 0;
+
+	}
+	return true;
+}
+
+SQTable *CreateDefaultDelegate(SQSharedState *ss,SQRegFunction *funcz)
+{
+	SQInteger i=0;
+	SQTable *t=SQTable::Create(ss,0);
+	while(funcz[i].name!=0){
+		SQNativeClosure *nc = SQNativeClosure::Create(ss,funcz[i].f);
+		nc->_nparamscheck = funcz[i].nparamscheck;
+		nc->_name = SQString::Create(ss,funcz[i].name);
+		if(funcz[i].typemask && !CompileTypemask(nc->_typecheck,funcz[i].typemask))
+			return NULL;
+		t->NewSlot(SQString::Create(ss,funcz[i].name),nc);
+		i++;
+	}
+	return t;
+}
+
+void SQSharedState::Init()
+{
+	_scratchpad=NULL;
+	_scratchpadsize=0;
+#ifndef NO_GARBAGE_COLLECTOR
+	_gc_chain=NULL;
+#endif
+	sq_new(_stringtable,StringTable);
+	sq_new(_metamethods,SQObjectPtrVec);
+	sq_new(_systemstrings,SQObjectPtrVec);
+	sq_new(_types,SQObjectPtrVec);
+	_metamethodsmap = SQTable::Create(this,MT_LAST-1);
+	//adding type strings to avoid memory trashing
+	//types names
+	newsysstring(_SC("null"));
+	newsysstring(_SC("table"));
+	newsysstring(_SC("array"));
+	newsysstring(_SC("closure"));
+	newsysstring(_SC("string"));
+	newsysstring(_SC("userdata"));
+	newsysstring(_SC("integer"));
+	newsysstring(_SC("float"));
+	newsysstring(_SC("userpointer"));
+	newsysstring(_SC("function"));
+	newsysstring(_SC("generator"));
+	newsysstring(_SC("thread"));
+	newsysstring(_SC("class"));
+	newsysstring(_SC("instance"));
+	newsysstring(_SC("bool"));
+	//meta methods
+	newmetamethod(MM_ADD);
+	newmetamethod(MM_SUB);
+	newmetamethod(MM_MUL);
+	newmetamethod(MM_DIV);
+	newmetamethod(MM_UNM);
+	newmetamethod(MM_MODULO);
+	newmetamethod(MM_SET);
+	newmetamethod(MM_GET);
+	newmetamethod(MM_TYPEOF);
+	newmetamethod(MM_NEXTI);
+	newmetamethod(MM_CMP);
+	newmetamethod(MM_CALL);
+	newmetamethod(MM_CLONED);
+	newmetamethod(MM_NEWSLOT);
+	newmetamethod(MM_DELSLOT);
+	newmetamethod(MM_TOSTRING);
+	newmetamethod(MM_NEWMEMBER);
+	newmetamethod(MM_INHERITED);
+
+	_constructoridx = SQString::Create(this,_SC("constructor"));
+	_registry = SQTable::Create(this,0);
+	_consts = SQTable::Create(this,0);
+	_table_default_delegate = CreateDefaultDelegate(this,_table_default_delegate_funcz);
+	_array_default_delegate = CreateDefaultDelegate(this,_array_default_delegate_funcz);
+	_string_default_delegate = CreateDefaultDelegate(this,_string_default_delegate_funcz);
+	_number_default_delegate = CreateDefaultDelegate(this,_number_default_delegate_funcz);
+	_closure_default_delegate = CreateDefaultDelegate(this,_closure_default_delegate_funcz);
+	_generator_default_delegate = CreateDefaultDelegate(this,_generator_default_delegate_funcz);
+	_thread_default_delegate = CreateDefaultDelegate(this,_thread_default_delegate_funcz);
+	_class_default_delegate = CreateDefaultDelegate(this,_class_default_delegate_funcz);
+	_instance_default_delegate = CreateDefaultDelegate(this,_instance_default_delegate_funcz);
+	_weakref_default_delegate = CreateDefaultDelegate(this,_weakref_default_delegate_funcz);
+
+}
+
+SQSharedState::~SQSharedState()
+{
+	_constructoridx = _null_;
+	_table(_registry)->Finalize();
+	_table(_consts)->Finalize();
+	_table(_metamethodsmap)->Finalize();
+	_registry = _null_;
+	_consts = _null_;
+	_metamethodsmap = _null_;
+	while(!_systemstrings->empty()) {
+		_systemstrings->back()=_null_;
+		_systemstrings->pop_back();
+	}
+	_thread(_root_vm)->Finalize();
+	_root_vm = _null_;
+	_table_default_delegate = _null_;
+	_array_default_delegate = _null_;
+	_string_default_delegate = _null_;
+	_number_default_delegate = _null_;
+	_closure_default_delegate = _null_;
+	_generator_default_delegate = _null_;
+	_thread_default_delegate = _null_;
+	_class_default_delegate = _null_;
+	_instance_default_delegate = _null_;
+	_weakref_default_delegate = _null_;
+	_refs_table.Finalize();
+#ifndef NO_GARBAGE_COLLECTOR
+	SQCollectable *t = _gc_chain;
+	SQCollectable *nx = NULL;
+	while(t) {
+		t->_uiRef++;
+		t->Finalize();
+		nx = t->_next;
+		if(--t->_uiRef == 0)
+			t->Release();
+		t=nx;
+	}
+//	assert(_gc_chain==NULL); //just to proove a theory
+	while(_gc_chain){
+		_gc_chain->_uiRef++;
+		_gc_chain->Release();
+	}
+#endif
+
+	sq_delete(_types,SQObjectPtrVec);
+	sq_delete(_systemstrings,SQObjectPtrVec);
+	sq_delete(_metamethods,SQObjectPtrVec);
+	sq_delete(_stringtable,StringTable);
+	if(_scratchpad)SQ_FREE(_scratchpad,_scratchpadsize);
+}
+
+
+SQInteger SQSharedState::GetMetaMethodIdxByName(const SQObjectPtr &name)
+{
+	if(type(name) != OT_STRING)
+		return -1;
+	SQObjectPtr ret;
+	if(_table(_metamethodsmap)->Get(name,ret)) {
+		return _integer(ret);
+	}
+	return -1;
+}
+
+#ifndef NO_GARBAGE_COLLECTOR
+
+void SQSharedState::MarkObject(SQObjectPtr &o,SQCollectable **chain)
+{
+	switch(type(o)){
+	case OT_TABLE:_table(o)->Mark(chain);break;
+	case OT_ARRAY:_array(o)->Mark(chain);break;
+	case OT_USERDATA:_userdata(o)->Mark(chain);break;
+	case OT_CLOSURE:_closure(o)->Mark(chain);break;
+	case OT_NATIVECLOSURE:_nativeclosure(o)->Mark(chain);break;
+	case OT_GENERATOR:_generator(o)->Mark(chain);break;
+	case OT_THREAD:_thread(o)->Mark(chain);break;
+	case OT_CLASS:_class(o)->Mark(chain);break;
+	case OT_INSTANCE:_instance(o)->Mark(chain);break;
+	default: break; //shutup compiler
+	}
+}
+
+
+SQInteger SQSharedState::CollectGarbage(SQVM *vm)
+{
+	SQInteger n=0;
+	SQCollectable *tchain=NULL;
+	SQVM *vms = _thread(_root_vm);
+
+	vms->Mark(&tchain);
+	SQInteger x = _table(_thread(_root_vm)->_roottable)->CountUsed();
+	_refs_table.Mark(&tchain);
+	MarkObject(_registry,&tchain);
+	MarkObject(_consts,&tchain);
+	MarkObject(_metamethodsmap,&tchain);
+	MarkObject(_table_default_delegate,&tchain);
+	MarkObject(_array_default_delegate,&tchain);
+	MarkObject(_string_default_delegate,&tchain);
+	MarkObject(_number_default_delegate,&tchain);
+	MarkObject(_generator_default_delegate,&tchain);
+	MarkObject(_thread_default_delegate,&tchain);
+	MarkObject(_closure_default_delegate,&tchain);
+	MarkObject(_class_default_delegate,&tchain);
+	MarkObject(_instance_default_delegate,&tchain);
+	MarkObject(_weakref_default_delegate,&tchain);
+
+	SQCollectable *t = _gc_chain;
+	SQCollectable *nx = NULL;
+	while(t) {
+		t->_uiRef++;
+		t->Finalize();
+		nx = t->_next;
+		if(--t->_uiRef == 0)
+			t->Release();
+		t = nx;
+		n++;
+	}
+
+	t = tchain;
+	while(t) {
+		t->UnMark();
+		t = t->_next;
+	}
+	_gc_chain = tchain;
+	SQInteger z = _table(_thread(_root_vm)->_roottable)->CountUsed();
+	assert(z == x);
+	return n;
+}
+#endif
+
+#ifndef NO_GARBAGE_COLLECTOR
+void SQCollectable::AddToChain(SQCollectable **chain,SQCollectable *c)
+{
+    c->_prev = NULL;
+	c->_next = *chain;
+	if(*chain) (*chain)->_prev = c;
+	*chain = c;
+}
+
+void SQCollectable::RemoveFromChain(SQCollectable **chain,SQCollectable *c)
+{
+	if(c->_prev) c->_prev->_next = c->_next;
+	else *chain = c->_next;
+	if(c->_next)
+		c->_next->_prev = c->_prev;
+	c->_next = NULL;
+	c->_prev = NULL;
+}
+#endif
+
+SQChar* SQSharedState::GetScratchPad(SQInteger size)
+{
+	SQInteger newsize;
+	if(size>0) {
+		if(_scratchpadsize < size) {
+			newsize = size + (size>>1);
+			_scratchpad = (SQChar *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
+			_scratchpadsize = newsize;
+
+		}else if(_scratchpadsize >= (size<<5)) {
+			newsize = _scratchpadsize >> 1;
+			_scratchpad = (SQChar *)SQ_REALLOC(_scratchpad,_scratchpadsize,newsize);
+			_scratchpadsize = newsize;
+		}
+	}
+	return _scratchpad;
+}
+
+RefTable::RefTable()
+{
+	AllocNodes(4);
+}
+
+void RefTable::Finalize()
+{
+	RefNode *nodes = _nodes;
+	for(SQUnsignedInteger n = 0; n < _numofslots; n++) {
+		nodes->obj = _null_;
+		nodes++;
+	}
+}
+
+RefTable::~RefTable()
+{
+	SQ_FREE(_buckets,(_numofslots * sizeof(RefNode *)) + (_numofslots * sizeof(RefNode)));
+}
+
+#ifndef NO_GARBAGE_COLLECTOR
+void RefTable::Mark(SQCollectable **chain)
+{
+	RefNode *nodes = (RefNode *)_nodes;
+	for(SQUnsignedInteger n = 0; n < _numofslots; n++) {
+		if(type(nodes->obj) != OT_NULL) {
+			SQSharedState::MarkObject(nodes->obj,chain);
+		}
+		nodes++;
+	}
+}
+#endif
+
+void RefTable::AddRef(SQObject &obj)
+{
+	SQHash mainpos;
+	RefNode *prev;
+	RefNode *ref = Get(obj,mainpos,&prev,true);
+	ref->refs++;
+}
+
+SQBool RefTable::Release(SQObject &obj)
+{
+	SQHash mainpos;
+	RefNode *prev;
+	RefNode *ref = Get(obj,mainpos,&prev,false);
+	if(ref) {
+		if(--ref->refs == 0) {
+			SQObjectPtr o = ref->obj;
+			if(prev) {
+				prev->next = ref->next;
+			}
+			else {
+				_buckets[mainpos] = ref->next;
+			}
+			ref->next = _freelist;
+			_freelist = ref;
+			_slotused--;
+			ref->obj = _null_;
+			//<<FIXME>>test for shrink?
+			return SQTrue;
+		}
+	}
+	else {
+		assert(0);
+	}
+	return SQFalse;
+}
+
+void RefTable::Resize(SQUnsignedInteger size)
+{
+	RefNode **oldbucks = _buckets;
+	RefNode *t = _nodes;
+	SQUnsignedInteger oldnumofslots = _numofslots;
+	AllocNodes(size);
+	//rehash
+	SQUnsignedInteger nfound = 0;
+	for(SQUnsignedInteger n = 0; n < oldnumofslots; n++) {
+		if(type(t->obj) != OT_NULL) {
+			//add back;
+			assert(t->refs != 0);
+			RefNode *nn = Add(::HashObj(t->obj)&(_numofslots-1),t->obj);
+			nn->refs = t->refs;
+			t->obj = _null_;
+			nfound++;
+		}
+		t++;
+	}
+	assert(nfound == oldnumofslots);
+	SQ_FREE(oldbucks,(oldnumofslots * sizeof(RefNode *)) + (oldnumofslots * sizeof(RefNode)));
+}
+
+RefTable::RefNode *RefTable::Add(SQHash mainpos,SQObject &obj)
+{
+	RefNode *t = _buckets[mainpos];
+	RefNode *newnode = _freelist;
+	newnode->obj = obj;
+	_buckets[mainpos] = newnode;
+	_freelist = _freelist->next;
+	newnode->next = t;
+	assert(newnode->refs == 0);
+	_slotused++;
+	return newnode;
+}
+
+RefTable::RefNode *RefTable::Get(SQObject &obj,SQHash &mainpos,RefNode **prev,bool add)
+{
+	RefNode *ref;
+	mainpos = ::HashObj(obj)&(_numofslots-1);
+	*prev = NULL;
+	for (ref = _buckets[mainpos]; ref; ) {
+		if(_rawval(ref->obj) == _rawval(obj) && type(ref->obj) == type(obj))
+			break;
+		*prev = ref;
+		ref = ref->next;
+	}
+	if(ref == NULL && add) {
+		if(_numofslots == _slotused) {
+			assert(_freelist == 0);
+			Resize(_numofslots*2);
+			mainpos = ::HashObj(obj)&(_numofslots-1);
+		}
+		ref = Add(mainpos,obj);
+	}
+	return ref;
+}
+
+void RefTable::AllocNodes(SQUnsignedInteger size)
+{
+	RefNode **bucks;
+	RefNode *nodes;
+	bucks = (RefNode **)SQ_MALLOC((size * sizeof(RefNode *)) + (size * sizeof(RefNode)));
+	nodes = (RefNode *)&bucks[size];
+	RefNode *temp = nodes;
+	SQUnsignedInteger n;
+	for(n = 0; n < size - 1; n++) {
+		bucks[n] = NULL;
+		temp->refs = 0;
+		new (&temp->obj) SQObjectPtr;
+		temp->next = temp+1;
+		temp++;
+	}
+	bucks[n] = NULL;
+	temp->refs = 0;
+	new (&temp->obj) SQObjectPtr;
+	temp->next = NULL;
+	_freelist = nodes;
+	_nodes = nodes;
+	_buckets = bucks;
+	_slotused = 0;
+	_numofslots = size;
+}
+//////////////////////////////////////////////////////////////////////////
+//StringTable
+/*
+* The following code is based on Lua 4.0 (Copyright 1994-2002 Tecgraf, PUC-Rio.)
+* http://www.lua.org/copyright.html#4
+* http://www.lua.org/source/4.0.1/src_lstring.c.html
+*/
+
+StringTable::StringTable()
+{
+	AllocNodes(4);
+	_slotused = 0;
+}
+
+StringTable::~StringTable()
+{
+	SQ_FREE(_strings,sizeof(SQString*)*_numofslots);
+	_strings = NULL;
+}
+
+void StringTable::AllocNodes(SQInteger size)
+{
+	_numofslots = size;
+	_strings = (SQString**)SQ_MALLOC(sizeof(SQString*)*_numofslots);
+	memset(_strings,0,sizeof(SQString*)*_numofslots);
+}
+
+SQString *StringTable::Add(const SQChar *news,SQInteger len)
+{
+	if(len<0)
+		len = (SQInteger)scstrlen(news);
+	SQHash h = ::_hashstr(news,len)&(_numofslots-1);
+	SQString *s;
+	for (s = _strings[h]; s; s = s->_next){
+		if(s->_len == len && (!memcmp(news,s->_val,rsl(len))))
+			return s; //found
+	}
+
+	SQString *t=(SQString *)SQ_MALLOC(rsl(len)+sizeof(SQString));
+	new (t) SQString;
+	memcpy(t->_val,news,rsl(len));
+	t->_val[len] = _SC('\0');
+	t->_len = len;
+	t->_hash = ::_hashstr(news,len);
+	t->_next = _strings[h];
+	_strings[h] = t;
+	_slotused++;
+	if (_slotused > _numofslots)  /* too crowded? */
+		Resize(_numofslots*2);
+	return t;
+}
+
+void StringTable::Resize(SQInteger size)
+{
+	SQInteger oldsize=_numofslots;
+	SQString **oldtable=_strings;
+	AllocNodes(size);
+	for (SQInteger i=0; i<oldsize; i++){
+		SQString *p = oldtable[i];
+		while(p){
+			SQString *next = p->_next;
+			SQHash h = p->_hash&(_numofslots-1);
+			p->_next = _strings[h];
+			_strings[h] = p;
+			p = next;
+		}
+	}
+	SQ_FREE(oldtable,oldsize*sizeof(SQString*));
+}
+
+void StringTable::Remove(SQString *bs)
+{
+	SQString *s;
+	SQString *prev=NULL;
+	SQHash h = bs->_hash&(_numofslots - 1);
+
+	for (s = _strings[h]; s; ){
+		if(s == bs){
+			if(prev)
+				prev->_next = s->_next;
+			else
+				_strings[h] = s->_next;
+			_slotused--;
+			SQInteger slen = s->_len;
+			s->~SQString();
+			SQ_FREE(s,sizeof(SQString) + rsl(slen));
+			return;
+		}
+		prev = s;
+		s = s->_next;
+	}
+	assert(0);//if this fail something is wrong
+}
--- a/src/3rdparty/squirrel/squirrel/sqstate.h
+++ b/src/3rdparty/squirrel/squirrel/sqstate.h
@ -0,0 +1,143 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQSTATE_H_
+#define _SQSTATE_H_
+
+#include "squtils.h"
+#include "sqobject.h"
+struct SQString;
+struct SQTable;
+//max number of character for a printed number
+#define NUMBER_MAX_CHAR 50
+
+struct StringTable
+{
+	StringTable();
+	~StringTable();
+	SQString *Add(const SQChar *,SQInteger len);
+	void Remove(SQString *);
+private:
+	void Resize(SQInteger size);
+	void AllocNodes(SQInteger size);
+	SQString **_strings;
+	SQUnsignedInteger _numofslots;
+	SQUnsignedInteger _slotused;
+};
+
+struct RefTable {
+	struct RefNode {
+		SQObjectPtr obj;
+		SQUnsignedInteger refs;
+		struct RefNode *next;
+	};
+	RefTable();
+	~RefTable();
+	void AddRef(SQObject &obj);
+	SQBool Release(SQObject &obj);
+#ifndef NO_GARBAGE_COLLECTOR
+	void Mark(SQCollectable **chain);
+#endif
+	void Finalize();
+private:
+	RefNode *Get(SQObject &obj,SQHash &mainpos,RefNode **prev,bool add);
+	RefNode *Add(SQHash mainpos,SQObject &obj);
+	void Resize(SQUnsignedInteger size);
+	void AllocNodes(SQUnsignedInteger size);
+	SQUnsignedInteger _numofslots;
+	SQUnsignedInteger _slotused;
+	RefNode *_nodes;
+	RefNode *_freelist;
+	RefNode **_buckets;
+};
+
+#define ADD_STRING(ss,str,len) ss->_stringtable->Add(str,len)
+#define REMOVE_STRING(ss,bstr) ss->_stringtable->Remove(bstr)
+
+struct SQObjectPtr;
+
+struct SQSharedState
+{
+	SQSharedState();
+	~SQSharedState();
+	void Init();
+public:
+	SQChar* GetScratchPad(SQInteger size);
+	SQInteger GetMetaMethodIdxByName(const SQObjectPtr &name);
+#ifndef NO_GARBAGE_COLLECTOR
+	SQInteger CollectGarbage(SQVM *vm);
+	static void MarkObject(SQObjectPtr &o,SQCollectable **chain);
+#endif
+	SQObjectPtrVec *_metamethods;
+	SQObjectPtr _metamethodsmap;
+	SQObjectPtrVec *_systemstrings;
+	SQObjectPtrVec *_types;
+	StringTable *_stringtable;
+	RefTable _refs_table;
+	SQObjectPtr _registry;
+	SQObjectPtr _consts;
+	SQObjectPtr _constructoridx;
+#ifndef NO_GARBAGE_COLLECTOR
+	SQCollectable *_gc_chain;
+#endif
+	SQObjectPtr _root_vm;
+	SQObjectPtr _table_default_delegate;
+	static SQRegFunction _table_default_delegate_funcz[];
+	SQObjectPtr _array_default_delegate;
+	static SQRegFunction _array_default_delegate_funcz[];
+	SQObjectPtr _string_default_delegate;
+	static SQRegFunction _string_default_delegate_funcz[];
+	SQObjectPtr _number_default_delegate;
+	static SQRegFunction _number_default_delegate_funcz[];
+	SQObjectPtr _generator_default_delegate;
+	static SQRegFunction _generator_default_delegate_funcz[];
+	SQObjectPtr _closure_default_delegate;
+	static SQRegFunction _closure_default_delegate_funcz[];
+	SQObjectPtr _thread_default_delegate;
+	static SQRegFunction _thread_default_delegate_funcz[];
+	SQObjectPtr _class_default_delegate;
+	static SQRegFunction _class_default_delegate_funcz[];
+	SQObjectPtr _instance_default_delegate;
+	static SQRegFunction _instance_default_delegate_funcz[];
+	SQObjectPtr _weakref_default_delegate;
+	static SQRegFunction _weakref_default_delegate_funcz[];
+
+	SQCOMPILERERROR _compilererrorhandler;
+	SQPRINTFUNCTION _printfunc;
+	bool _debuginfo;
+	bool _notifyallexceptions;
+private:
+	SQChar *_scratchpad;
+	SQInteger _scratchpadsize;
+};
+
+#define _sp(s) (_sharedstate->GetScratchPad(s))
+#define _spval (_sharedstate->GetScratchPad(-1))
+
+#define _table_ddel		_table(_sharedstate->_table_default_delegate)
+#define _array_ddel		_table(_sharedstate->_array_default_delegate)
+#define _string_ddel	_table(_sharedstate->_string_default_delegate)
+#define _number_ddel	_table(_sharedstate->_number_default_delegate)
+#define _generator_ddel	_table(_sharedstate->_generator_default_delegate)
+#define _closure_ddel	_table(_sharedstate->_closure_default_delegate)
+#define _thread_ddel	_table(_sharedstate->_thread_default_delegate)
+#define _class_ddel		_table(_sharedstate->_class_default_delegate)
+#define _instance_ddel	_table(_sharedstate->_instance_default_delegate)
+#define _weakref_ddel	_table(_sharedstate->_weakref_default_delegate)
+
+#ifdef SQUNICODE //rsl REAL STRING LEN
+#define rsl(l) ((l)<<1)
+#else
+#define rsl(l) (l)
+#endif
+
+extern SQObjectPtr _null_;
+extern SQObjectPtr _true_;
+extern SQObjectPtr _false_;
+extern SQObjectPtr _one_;
+extern SQObjectPtr _minusone_;
+
+bool CompileTypemask(SQIntVec &res,const SQChar *typemask);
+
+void *sq_vm_malloc(SQUnsignedInteger size);
+void *sq_vm_realloc(void *p,SQUnsignedInteger oldsize,SQUnsignedInteger size);
+void sq_vm_free(void *p,SQUnsignedInteger size);
+#endif //_SQSTATE_H_
--- a/src/3rdparty/squirrel/squirrel/sqstring.h
+++ b/src/3rdparty/squirrel/squirrel/sqstring.h
@ -0,0 +1,31 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQSTRING_H_
+#define _SQSTRING_H_
+
+inline SQHash _hashstr (const SQChar *s, size_t l)
+{
+		SQHash h = (SQHash)l;  /* seed */
+		size_t step = (l>>5)|1;  /* if string is too long, don't hash all its chars */
+		for (; l>=step; l-=step)
+			h = h ^ ((h<<5)+(h>>2)+(unsigned short)*(s++));
+		return h;
+}
+
+struct SQString : public SQRefCounted
+{
+	SQString(){}
+	~SQString(){}
+public:
+	static SQString *Create(SQSharedState *ss, const SQChar *, SQInteger len = -1 );
+	SQInteger Next(const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval);
+	void Release();
+	SQSharedState *_sharedstate;
+	SQString *_next; //chain for the string table
+	SQInteger _len;
+	SQHash _hash;
+	SQChar _val[1];
+};
+
+
+
+#endif //_SQSTRING_H_
--- a/src/3rdparty/squirrel/squirrel/sqtable.cpp
+++ b/src/3rdparty/squirrel/squirrel/sqtable.cpp
@ -0,0 +1,196 @@
+/*
+see copyright notice in squirrel.h
+*/
+#include "sqpcheader.h"
+#include "sqvm.h"
+#include "sqtable.h"
+#include "sqfuncproto.h"
+#include "sqclosure.h"
+
+SQTable::SQTable(SQSharedState *ss,SQInteger nInitialSize)
+{
+	SQInteger pow2size=MINPOWER2;
+	while(nInitialSize>pow2size)pow2size=pow2size<<1;
+	AllocNodes(pow2size);
+	_usednodes = 0;
+	_delegate = NULL;
+	INIT_CHAIN();
+	ADD_TO_CHAIN(&_sharedstate->_gc_chain,this);
+}
+
+void SQTable::Remove(const SQObjectPtr &key)
+{
+
+	_HashNode *n = _Get(key, HashObj(key) & (_numofnodes - 1));
+	if (n) {
+		n->val = n->key = _null_;
+		_usednodes--;
+		Rehash(false);
+	}
+}
+
+void SQTable::AllocNodes(SQInteger nSize)
+{
+	_HashNode *nodes=(_HashNode *)SQ_MALLOC(sizeof(_HashNode)*nSize);
+	for(SQInteger i=0;i<nSize;i++){
+		new (&nodes[i]) _HashNode;
+		nodes[i].next=NULL;
+	}
+	_numofnodes=nSize;
+	_nodes=nodes;
+	_firstfree=&_nodes[_numofnodes-1];
+}
+
+void SQTable::Rehash(bool force)
+{
+	SQInteger oldsize=_numofnodes;
+	//prevent problems with the integer division
+	if(oldsize<4)oldsize=4;
+	_HashNode *nold=_nodes;
+	SQInteger nelems=CountUsed();
+	if (nelems >= oldsize-oldsize/4)  /* using more than 3/4? */
+		AllocNodes(oldsize*2);
+	else if (nelems <= oldsize/4 &&  /* less than 1/4? */
+		oldsize > MINPOWER2)
+		AllocNodes(oldsize/2);
+	else if(force)
+		AllocNodes(oldsize);
+	else
+		return;
+	_usednodes = 0;
+	for (SQInteger i=0; i<oldsize; i++) {
+		_HashNode *old = nold+i;
+		if (type(old->key) != OT_NULL)
+			NewSlot(old->key,old->val);
+	}
+	for(SQInteger k=0;k<oldsize;k++)
+		nold[k].~_HashNode();
+	SQ_FREE(nold,oldsize*sizeof(_HashNode));
+}
+
+SQTable *SQTable::Clone()
+{
+	SQTable *nt=Create(_opt_ss(this),_numofnodes);
+	SQInteger ridx=0;
+	SQObjectPtr key,val;
+	while((ridx=Next(true,ridx,key,val))!=-1){
+		nt->NewSlot(key,val);
+	}
+	nt->SetDelegate(_delegate);
+	return nt;
+}
+
+bool SQTable::Get(const SQObjectPtr &key,SQObjectPtr &val)
+{
+	if(type(key) == OT_NULL)
+		return false;
+	_HashNode *n = _Get(key, HashObj(key) & (_numofnodes - 1));
+	if (n) {
+		val = _realval(n->val);
+		return true;
+	}
+	return false;
+}
+bool SQTable::NewSlot(const SQObjectPtr &key,const SQObjectPtr &val)
+{
+	assert(type(key) != OT_NULL);
+	SQHash h = HashObj(key) & (_numofnodes - 1);
+	_HashNode *n = _Get(key, h);
+	if (n) {
+		n->val = val;
+		return false;
+	}
+	_HashNode *mp = &_nodes[h];
+	n = mp;
+
+
+	//key not found I'll insert it
+	//main pos is not free
+
+	if(type(mp->key) != OT_NULL) {
+		n = _firstfree;  /* get a free place */
+		SQHash mph = HashObj(mp->key) & (_numofnodes - 1);
+		_HashNode *othern;  /* main position of colliding node */
+
+		if (mp > n && (othern = &_nodes[mph]) != mp){
+			/* yes; move colliding node into free position */
+			while (othern->next != mp){
+				assert(othern->next != NULL);
+				othern = othern->next;  /* find previous */
+			}
+			othern->next = n;  /* redo the chain with `n' in place of `mp' */
+			n->key = mp->key;
+			n->val = mp->val;/* copy colliding node into free pos. (mp->next also goes) */
+			n->next = mp->next;
+			mp->key = _null_;
+			mp->val = _null_;
+			mp->next = NULL;  /* now `mp' is free */
+		}
+		else{
+			/* new node will go into free position */
+			n->next = mp->next;  /* chain new position */
+			mp->next = n;
+			mp = n;
+		}
+	}
+	mp->key = key;
+
+	for (;;) {  /* correct `firstfree' */
+		if (type(_firstfree->key) == OT_NULL && _firstfree->next == NULL) {
+			mp->val = val;
+			_usednodes++;
+			return true;  /* OK; table still has a free place */
+		}
+		else if (_firstfree == _nodes) break;  /* cannot decrement from here */
+		else (_firstfree)--;
+	}
+	Rehash(true);
+	return NewSlot(key, val);
+}
+
+SQInteger SQTable::Next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval)
+{
+	SQInteger idx = (SQInteger)TranslateIndex(refpos);
+	while (idx < _numofnodes) {
+		if(type(_nodes[idx].key) != OT_NULL) {
+			//first found
+			_HashNode &n = _nodes[idx];
+			outkey = n.key;
+			outval = getweakrefs?(SQObject)n.val:_realval(n.val);
+			//return idx for the next iteration
+			return ++idx;
+		}
+		++idx;
+	}
+	//nothing to iterate anymore
+	return -1;
+}
+
+
+bool SQTable::Set(const SQObjectPtr &key, const SQObjectPtr &val)
+{
+	_HashNode *n = _Get(key, HashObj(key) & (_numofnodes - 1));
+	if (n) {
+		n->val = val;
+		return true;
+	}
+	return false;
+}
+
+void SQTable::_ClearNodes()
+{
+	for(SQInteger i = 0;i < _numofnodes; i++) { _nodes[i].key = _null_; _nodes[i].val = _null_; }
+}
+
+void SQTable::Finalize()
+{
+	_ClearNodes();
+	SetDelegate(NULL);
+}
+
+void SQTable::Clear()
+{
+	_ClearNodes();
+	_usednodes = 0;
+	Rehash(true);
+}
--- a/src/3rdparty/squirrel/squirrel/sqtable.h
+++ b/src/3rdparty/squirrel/squirrel/sqtable.h
@ -0,0 +1,91 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQTABLE_H_
+#define _SQTABLE_H_
+/*
+* The following code is based on Lua 4.0 (Copyright 1994-2002 Tecgraf, PUC-Rio.)
+* http://www.lua.org/copyright.html#4
+* http://www.lua.org/source/4.0.1/src_ltable.c.html
+*/
+
+#include "sqstring.h"
+
+
+#define hashptr(p)  ((SQHash)(((SQInteger)p) >> 3))
+
+inline SQHash HashObj(const SQObjectPtr &key)
+{
+	switch(type(key)) {
+		case OT_STRING:		return _string(key)->_hash;
+		case OT_FLOAT:		return (SQHash)((SQInteger)_float(key));
+		case OT_BOOL: case OT_INTEGER:	return (SQHash)((SQInteger)_integer(key));
+		default:			return hashptr(key._unVal.pRefCounted);
+	}
+}
+
+struct SQTable : public SQDelegable
+{
+private:
+	struct _HashNode
+	{
+		_HashNode() { next = NULL; }
+		SQObjectPtr val;
+		SQObjectPtr key;
+		_HashNode *next;
+	};
+	_HashNode *_firstfree;
+	_HashNode *_nodes;
+	SQInteger _numofnodes;
+	SQInteger _usednodes;
+
+///////////////////////////
+	void AllocNodes(SQInteger nSize);
+	void Rehash(bool force);
+	SQTable(SQSharedState *ss, SQInteger nInitialSize);
+	void _ClearNodes();
+public:
+	static SQTable* Create(SQSharedState *ss,SQInteger nInitialSize)
+	{
+		SQTable *newtable = (SQTable*)SQ_MALLOC(sizeof(SQTable));
+		new (newtable) SQTable(ss, nInitialSize);
+		newtable->_delegate = NULL;
+		return newtable;
+	}
+	void Finalize();
+	SQTable *Clone();
+	~SQTable()
+	{
+		SetDelegate(NULL);
+		REMOVE_FROM_CHAIN(&_sharedstate->_gc_chain, this);
+		for (SQInteger i = 0; i < _numofnodes; i++) _nodes[i].~_HashNode();
+		SQ_FREE(_nodes, _numofnodes * sizeof(_HashNode));
+	}
+#ifndef NO_GARBAGE_COLLECTOR
+	void Mark(SQCollectable **chain);
+#endif
+	inline _HashNode *_Get(const SQObjectPtr &key,SQHash hash)
+	{
+		_HashNode *n = &_nodes[hash];
+		do{
+			if(_rawval(n->key) == _rawval(key) && type(n->key) == type(key)){
+				return n;
+			}
+		}while((n = n->next));
+		return NULL;
+	}
+	bool Get(const SQObjectPtr &key,SQObjectPtr &val);
+	void Remove(const SQObjectPtr &key);
+	bool Set(const SQObjectPtr &key, const SQObjectPtr &val);
+	//returns true if a new slot has been created false if it was already present
+	bool NewSlot(const SQObjectPtr &key,const SQObjectPtr &val);
+	SQInteger Next(bool getweakrefs,const SQObjectPtr &refpos, SQObjectPtr &outkey, SQObjectPtr &outval);
+
+	SQInteger CountUsed(){ return _usednodes;}
+	void Clear();
+	void Release()
+	{
+		sq_delete(this, SQTable);
+	}
+
+};
+
+#endif //_SQTABLE_H_
--- a/src/3rdparty/squirrel/squirrel/squirrel.dsp
+++ b/src/3rdparty/squirrel/squirrel/squirrel.dsp
@ -0,0 +1,302 @@
+# Microsoft Developer Studio Project File - Name="squirrel" - Package Owner=<4>
+# Microsoft Developer Studio Generated Build File, Format Version 6.00
+# ** DO NOT EDIT **
+
+# TARGTYPE "Win32 (x86) Static Library" 0x0104
+
+CFG=squirrel - Win32 Debug
+!MESSAGE This is not a valid makefile. To build this project using NMAKE,
+!MESSAGE use the Export Makefile command and run
+!MESSAGE
+!MESSAGE NMAKE /f "squirrel.mak".
+!MESSAGE
+!MESSAGE You can specify a configuration when running NMAKE
+!MESSAGE by defining the macro CFG on the command line. For example:
+!MESSAGE
+!MESSAGE NMAKE /f "squirrel.mak" CFG="squirrel - Win32 Debug"
+!MESSAGE
+!MESSAGE Possible choices for configuration are:
+!MESSAGE
+!MESSAGE "squirrel - Win32 Release" (based on "Win32 (x86) Static Library")
+!MESSAGE "squirrel - Win32 Debug" (based on "Win32 (x86) Static Library")
+!MESSAGE
+
+# Begin Project
+# PROP AllowPerConfigDependencies 0
+# PROP Scc_LocalPath ".."
+CPP=cl.exe
+RSC=rc.exe
+
+!IF  "$(CFG)" == "squirrel - Win32 Release"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 0
+# PROP BASE Output_Dir "Release"
+# PROP BASE Intermediate_Dir "Release"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 0
+# PROP Output_Dir "Release"
+# PROP Intermediate_Dir "Release"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
+# ADD CPP /nologo /W3 /GX /O2 /I "..\include" /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /D "GARBAGE_COLLECTOR" /YX /FD /c
+# ADD BASE RSC /l 0x410 /d "NDEBUG"
+# ADD RSC /l 0x410 /d "NDEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\lib\squirrel.lib"
+
+!ELSEIF  "$(CFG)" == "squirrel - Win32 Debug"
+
+# PROP BASE Use_MFC 0
+# PROP BASE Use_Debug_Libraries 1
+# PROP BASE Output_Dir "Debug"
+# PROP BASE Intermediate_Dir "Debug"
+# PROP BASE Target_Dir ""
+# PROP Use_MFC 0
+# PROP Use_Debug_Libraries 1
+# PROP Output_Dir "Debug"
+# PROP Intermediate_Dir "Debug"
+# PROP Target_Dir ""
+# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
+# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /I "..\include" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /D "GARBAGE_COLLECTOR" /YX /FD /GZ /c
+# ADD BASE RSC /l 0x410 /d "_DEBUG"
+# ADD RSC /l 0x410 /d "_DEBUG"
+BSC32=bscmake.exe
+# ADD BASE BSC32 /nologo
+# ADD BSC32 /nologo
+LIB32=link.exe -lib
+# ADD BASE LIB32 /nologo
+# ADD LIB32 /nologo /out:"..\lib\squirrel.lib"
+
+!ENDIF
+
+# Begin Target
+
+# Name "squirrel - Win32 Release"
+# Name "squirrel - Win32 Debug"
+# Begin Group "Source Files"
+
+# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
+# Begin Source File
+
+SOURCE=.\sqapi.cpp
+
+!IF  "$(CFG)" == "squirrel - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "squirrel - Win32 Debug"
+
+# ADD CPP /YX"stdafx.h"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqbaselib.cpp
+
+!IF  "$(CFG)" == "squirrel - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "squirrel - Win32 Debug"
+
+# ADD CPP /YX"stdafx.h"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqcompiler.cpp
+
+!IF  "$(CFG)" == "squirrel - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "squirrel - Win32 Debug"
+
+# ADD CPP /YX"stdafx.h"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqdebug.cpp
+
+!IF  "$(CFG)" == "squirrel - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "squirrel - Win32 Debug"
+
+# ADD CPP /YX"stdafx.h"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqfuncstate.cpp
+
+!IF  "$(CFG)" == "squirrel - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "squirrel - Win32 Debug"
+
+# ADD CPP /YX"stdafx.h"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqlexer.cpp
+
+!IF  "$(CFG)" == "squirrel - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "squirrel - Win32 Debug"
+
+# ADD CPP /YX"stdafx.h"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqmem.cpp
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqobject.cpp
+
+!IF  "$(CFG)" == "squirrel - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "squirrel - Win32 Debug"
+
+# ADD CPP /YX"stdafx.h"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqstate.cpp
+
+!IF  "$(CFG)" == "squirrel - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "squirrel - Win32 Debug"
+
+# ADD CPP /YX"stdafx.h"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqtable.cpp
+
+!IF  "$(CFG)" == "squirrel - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "squirrel - Win32 Debug"
+
+# ADD CPP /YX"stdafx.h"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqclass.cpp
+
+!IF  "$(CFG)" == "squirrel - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "squirrel - Win32 Debug"
+
+# ADD CPP /YX"stdafx.h"
+
+!ENDIF
+
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqvm.cpp
+
+!IF  "$(CFG)" == "squirrel - Win32 Release"
+
+!ELSEIF  "$(CFG)" == "squirrel - Win32 Debug"
+
+# ADD CPP /YX"stdafx.h"
+
+!ENDIF
+
+# End Source File
+# End Group
+# Begin Group "Header Files"
+
+# PROP Default_Filter "h;hpp;hxx;hm;inl"
+# Begin Source File
+
+SOURCE=.\sqarray.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqclosure.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqcompiler.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqfuncproto.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqfuncstate.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqlexer.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqobject.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqopcodes.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqpcheader.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqstate.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqstring.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqtable.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\squserdata.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\squtils.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqclass.h
+# End Source File
+# Begin Source File
+
+SOURCE=.\sqvm.h
+# End Source File
+# End Group
+# End Target
+# End Project
--- a/src/3rdparty/squirrel/squirrel/squserdata.h
+++ b/src/3rdparty/squirrel/squirrel/squserdata.h
@ -0,0 +1,38 @@
+/*	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(sizeof(SQUserData)+(size-1));
+		new (ud) SQUserData(ss);
+		ud->_size = size;
+		ud->_typetag = 0;
+		return ud;
+	}
+#ifndef NO_GARBAGE_COLLECTOR
+	void Mark(SQCollectable **chain);
+	void Finalize(){SetDelegate(NULL);}
+#endif
+	void Release() {
+		if (_hook) _hook(_val,_size);
+		SQInteger tsize = _size - 1;
+		this->~SQUserData();
+		SQ_FREE(this, sizeof(SQUserData) + tsize);
+	}
+
+	SQInteger _size;
+	SQRELEASEHOOK _hook;
+	SQUserPointer _typetag;
+	SQChar _val[1];
+};
+
+#endif //_SQUSERDATA_H_
--- a/src/3rdparty/squirrel/squirrel/squtils.h
+++ b/src/3rdparty/squirrel/squirrel/squtils.h
@ -0,0 +1,104 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQUTILS_H_
+#define _SQUTILS_H_
+
+#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));
+
+//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)
+	{
+		resize(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--;
+	}
+	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;
+};
+
+#endif //_SQUTILS_H_
--- a/src/3rdparty/squirrel/squirrel/sqvm.cpp
+++ b/src/3rdparty/squirrel/squirrel/sqvm.cpp
--- a/src/3rdparty/squirrel/squirrel/sqvm.h
+++ b/src/3rdparty/squirrel/squirrel/sqvm.h
@ -0,0 +1,217 @@
+/*	see copyright notice in squirrel.h */
+#ifndef _SQVM_H_
+#define _SQVM_H_
+
+#include "sqopcodes.h"
+#include "sqobject.h"
+#define MAX_NATIVE_CALLS 100
+#define MIN_STACK_OVERHEAD 10
+
+#define SQ_SUSPEND_FLAG -666
+//base lib
+void sq_base_register(HSQUIRRELVM v);
+
+struct SQExceptionTrap{
+	SQExceptionTrap() {}
+	SQExceptionTrap(SQInteger ss, SQInteger stackbase,SQInstruction *ip, SQInteger ex_target){ _stacksize = ss; _stackbase = stackbase; _ip = ip; _extarget = ex_target;}
+	SQExceptionTrap(const SQExceptionTrap &et) { (*this) = et;	}
+	SQInteger _stackbase;
+	SQInteger _stacksize;
+	SQInstruction *_ip;
+	SQInteger _extarget;
+};
+
+#define _INLINE
+
+#define STK(a) _stack._vals[_stackbase+(a)]
+#define TARGET _stack._vals[_stackbase+arg0]
+
+typedef sqvector<SQExceptionTrap> ExceptionsTraps;
+
+struct SQVM : public CHAINABLE_OBJ
+{
+	struct VarArgs {
+		VarArgs() { size = 0; base = 0; }
+		unsigned short size;
+		unsigned short base;
+	};
+
+	struct CallInfo{
+		//CallInfo() { _generator._type = OT_NULL;}
+		SQInstruction *_ip;
+		SQObjectPtr *_literals;
+		SQObjectPtr _closure;
+		SQGenerator *_generator;
+		SQInt32 _etraps;
+		SQInt32 _prevstkbase;
+		SQInt32 _prevtop;
+		SQInt32 _target;
+		SQInt32 _ncalls;
+		SQBool _root;
+		VarArgs _vargs;
+	};
+
+typedef sqvector<CallInfo> CallInfoVec;
+public:
+	enum ExecutionType { ET_CALL, ET_RESUME_GENERATOR, ET_RESUME_VM, ET_RESUME_OPENTTD };
+	SQVM(SQSharedState *ss);
+	~SQVM();
+	bool Init(SQVM *friendvm, SQInteger stacksize);
+	bool Execute(SQObjectPtr &func, SQInteger target, SQInteger nargs, SQInteger stackbase, SQObjectPtr &outres, SQBool raiseerror, ExecutionType et = ET_CALL);
+	//starts a native call return when the NATIVE closure returns
+	bool CallNative(SQNativeClosure *nclosure, SQInteger nargs, SQInteger stackbase, SQObjectPtr &retval,bool &suspend);
+	//starts a SQUIRREL call in the same "Execution loop"
+	bool StartCall(SQClosure *closure, SQInteger target, SQInteger nargs, SQInteger stackbase, bool tailcall);
+	bool CreateClassInstance(SQClass *theclass, SQObjectPtr &inst, SQObjectPtr &constructor);
+	//call a generic closure pure SQUIRREL or NATIVE
+	bool Call(SQObjectPtr &closure, SQInteger nparams, SQInteger stackbase, SQObjectPtr &outres,SQBool raiseerror,SQBool can_suspend);
+	SQRESULT Suspend();
+
+	void CallDebugHook(SQInteger type,SQInteger forcedline=0);
+	void CallErrorHandler(SQObjectPtr &e);
+	bool Get(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &dest, bool raw, bool fetchroot);
+	bool FallBackGet(const SQObjectPtr &self,const SQObjectPtr &key,SQObjectPtr &dest,bool raw);
+	bool Set(const SQObjectPtr &self, const SQObjectPtr &key, const SQObjectPtr &val, bool fetchroot);
+	bool NewSlot(const SQObjectPtr &self, const SQObjectPtr &key, const SQObjectPtr &val,bool bstatic);
+	bool DeleteSlot(const SQObjectPtr &self, const SQObjectPtr &key, SQObjectPtr &res);
+	bool Clone(const SQObjectPtr &self, SQObjectPtr &target);
+	bool ObjCmp(const SQObjectPtr &o1, const SQObjectPtr &o2,SQInteger &res);
+	bool StringCat(const SQObjectPtr &str, const SQObjectPtr &obj, SQObjectPtr &dest);
+	bool IsEqual(SQObjectPtr &o1,SQObjectPtr &o2,bool &res);
+	void ToString(const SQObjectPtr &o,SQObjectPtr &res);
+	SQString *PrintObjVal(const SQObject &o);
+
+
+	void Raise_Error(const SQChar *s, ...);
+	void Raise_Error(SQObjectPtr &desc);
+	void Raise_IdxError(SQObject &o);
+	void Raise_CompareError(const SQObject &o1, const SQObject &o2);
+	void Raise_ParamTypeError(SQInteger nparam,SQInteger typemask,SQInteger type);
+
+	void TypeOf(const SQObjectPtr &obj1, SQObjectPtr &dest);
+	bool CallMetaMethod(SQDelegable *del, SQMetaMethod mm, SQInteger nparams, SQObjectPtr &outres);
+	bool ArithMetaMethod(SQInteger op, const SQObjectPtr &o1, const SQObjectPtr &o2, SQObjectPtr &dest);
+	bool Return(SQInteger _arg0, SQInteger _arg1, SQObjectPtr &retval);
+	//new stuff
+	_INLINE bool ARITH_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2);
+	_INLINE bool BW_OP(SQUnsignedInteger op,SQObjectPtr &trg,const SQObjectPtr &o1,const SQObjectPtr &o2);
+	_INLINE bool NEG_OP(SQObjectPtr &trg,const SQObjectPtr &o1);
+	_INLINE bool CMP_OP(CmpOP op, const SQObjectPtr &o1,const SQObjectPtr &o2,SQObjectPtr &res);
+	bool CLOSURE_OP(SQObjectPtr &target, SQFunctionProto *func);
+	bool GETVARGV_OP(SQObjectPtr &target,SQObjectPtr &idx,CallInfo *ci);
+	bool CLASS_OP(SQObjectPtr &target,SQInteger base,SQInteger attrs);
+	bool GETPARENT_OP(SQObjectPtr &o,SQObjectPtr &target);
+	//return true if the loop is finished
+	bool FOREACH_OP(SQObjectPtr &o1,SQObjectPtr &o2,SQObjectPtr &o3,SQObjectPtr &o4,SQInteger arg_2,int exitpos,int &jump);
+	bool DELEGATE_OP(SQObjectPtr &trg,SQObjectPtr &o1,SQObjectPtr &o2);
+	_INLINE bool LOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr);
+	_INLINE bool PLOCAL_INC(SQInteger op,SQObjectPtr &target, SQObjectPtr &a, SQObjectPtr &incr);
+	_INLINE bool DerefInc(SQInteger op,SQObjectPtr &target, SQObjectPtr &self, SQObjectPtr &key, SQObjectPtr &incr, bool postfix);
+	void PopVarArgs(VarArgs &vargs);
+#ifdef _DEBUG_DUMP
+	void dumpstack(SQInteger stackbase=-1, bool dumpall = false);
+#endif
+
+#ifndef NO_GARBAGE_COLLECTOR
+	void Mark(SQCollectable **chain);
+#endif
+	void Finalize();
+	void GrowCallStack() {
+		SQInteger newsize = _alloccallsstacksize*2;
+		_callstackdata.resize(newsize);
+		_callsstack = &_callstackdata[0];
+		_alloccallsstacksize = newsize;
+	}
+	void Release(){ sq_delete(this,SQVM); } //does nothing
+////////////////////////////////////////////////////////////////////////////
+	//stack functions for the api
+	void Remove(SQInteger n);
+
+	bool IsFalse(SQObjectPtr &o);
+
+	void Pop();
+	void Pop(SQInteger n);
+	void Push(const SQObjectPtr &o);
+	SQObjectPtr &Top();
+	SQObjectPtr &PopGet();
+	SQObjectPtr &GetUp(SQInteger n);
+	SQObjectPtr &GetAt(SQInteger n);
+
+	SQObjectPtrVec _stack;
+	SQObjectPtrVec _vargsstack;
+	SQInteger _top;
+	SQInteger _stackbase;
+	SQObjectPtr _roottable;
+	SQObjectPtr _lasterror;
+	SQObjectPtr _errorhandler;
+	SQObjectPtr _debughook;
+
+	SQObjectPtr temp_reg;
+
+
+	CallInfo* _callsstack;
+	SQInteger _callsstacksize;
+	SQInteger _alloccallsstacksize;
+	sqvector<CallInfo>  _callstackdata;
+
+	ExceptionsTraps _etraps;
+	CallInfo *ci;
+	void *_foreignptr;
+	//VMs sharing the same state
+	SQSharedState *_sharedstate;
+	SQInteger _nnativecalls;
+	//suspend infos
+	SQBool _suspended;
+	SQBool _suspended_root;
+	SQInteger _suspended_target;
+	SQInteger _suspended_traps;
+	VarArgs _suspend_varargs;
+
+	SQBool _can_suspend;
+	SQInteger _ops_till_suspend;
+
+	bool ShouldSuspend()
+	{
+		return _can_suspend && _ops_till_suspend <= 0;
+	}
+
+	void DecreaseOps(SQInteger amount)
+	{
+		if (_ops_till_suspend - amount < _ops_till_suspend) _ops_till_suspend -= amount;
+	}
+};
+
+struct AutoDec{
+	AutoDec(SQInteger *n) { _n = n; }
+	~AutoDec() { (*_n)--; }
+	SQInteger *_n;
+};
+
+inline SQObjectPtr &stack_get(HSQUIRRELVM v,SQInteger idx){return ((idx>=0)?(v->GetAt(idx+v->_stackbase-1)):(v->GetUp(idx)));}
+
+#define _ss(_vm_) (_vm_)->_sharedstate
+
+#ifndef NO_GARBAGE_COLLECTOR
+#define _opt_ss(_vm_) (_vm_)->_sharedstate
+#else
+#define _opt_ss(_vm_) NULL
+#endif
+
+#define PUSH_CALLINFO(v,nci){ \
+	if(v->_callsstacksize == v->_alloccallsstacksize) { \
+		v->GrowCallStack(); \
+	} \
+	v->ci = &v->_callsstack[v->_callsstacksize]; \
+	*(v->ci) = nci; \
+	v->_callsstacksize++; \
+}
+
+#define POP_CALLINFO(v){ \
+	v->_callsstacksize--; \
+	v->ci->_closure.Null(); \
+	if(v->_callsstacksize)	\
+		v->ci = &v->_callsstack[v->_callsstacksize-1] ; \
+	else	\
+		v->ci = NULL; \
+}
+#endif //_SQVM_H_
--- a/src/misc_gui.cpp
+++ b/src/misc_gui.cpp
@ -343,6 +343,7 @@ struct AboutWindow : public Window {
 			"  Christian Rosentreter (tokai) - MorphOS / AmigaOS port",
 			"  Richard Kempton (richK) - additional airports, initial TGP implementation",
 			"",
+			"  Alberto Demichelis - Squirrel scripting language © 2003-2008",
 			"  Michael Blunck - Pre-Signals and Semaphores © 2003",
 			"  George - Canal/Lock graphics © 2003-2004",
 			"  David Dallaston - Tram tracks",