diff --git a/include/lgi/common/Scripting.h b/include/lgi/common/Scripting.h
--- a/include/lgi/common/Scripting.h
+++ b/include/lgi/common/Scripting.h
@@ -1,488 +1,490 @@
 /// \file
 #ifndef _LGI_SCRIPTING_H_
 #define _LGI_SCRIPTING_H_
 
 #include "lgi/common/Variant.h"
 #include "lgi/common/List.h"
 
 class LScriptContext;
 class LScriptEnginePrivate;
 class LVmCallback;
 class LVirtualMachine;
 
 class LScriptArguments : public LArray<LVariant*>
 {
 	friend class LScriptEngine;
 	friend class LVirtualMachine;
 
 	LVirtualMachine *Vm;
 	LStream *Console;
 	LVariant _Return;
 	LVariant *PtrRet;
 
 public:
 	static LStream NullConsole;
 
 	LScriptArguments(LVirtualMachine *vm, LVariant *ret = NULL, LStream *console = NULL)
 	{
 		Vm = vm;
 		if (ret)
 			PtrRet = ret;
 		else
 			PtrRet = &_Return;
 		
 		if (console)
 			Console = console;
 		else
 			Console = &NullConsole;
 	}
 
 	LVirtualMachine *GetVm() { return Vm; }
+	void SetVm(LVirtualMachine *vm) { Vm = vm; }
 	LVariant *GetReturn() { return PtrRet; }
 	LStream *GetConsole() { return Console; }
 	bool Throw(const char *File, int Line, const char *Msg, ...);
 };
 
 typedef bool (LScriptContext::*ScriptCmd)(LScriptArguments &Args);
 
 #define SCOPE_REGISTER		0
 #define SCOPE_LOCAL			1
 #define SCOPE_GLOBAL		2
 #define SCOPE_OBJECT		3
 #define SCOPE_RETURN		4
 #define SCOPE_MAX			5
 
 /// Execution status
 enum LExecutionStatus
 {
 	ScriptNotStarted,
 	ScriptError,
 	ScriptWarning,
 	ScriptSuccess,
 };
 
 /// Various type of methods
 enum LFuncType
 {
 	/// No method type.
 	NullFunc,
 	/// This method is provided by the hosting application.
 	HostFunc,
 	/// This method is defined in the script itself.
 	ScriptFunc,
 	/// This method is defined in an external library.
 	ExternFunc
 };
 
 struct LFunc
 {
 	LFuncType Type;
 	LString Method;
 	bool InUse;
 
 	LFunc(const char *m = 0, LFuncType t = NullFunc)
 	{
 		Type = t;
 		Method = m;
 		InUse = false;
 
 		// LStackTrace("%p alloc\n", this);
 	}
 
 	virtual ~LFunc()
 	{
 		// LAssert(!InUse);
 	}
 
 	virtual LExecutionStatus Call(LScriptContext *Ctx, LScriptArguments &Args) = 0;
 };
 
 struct LHostFunc : public LFunc
 {
 	LScriptContext *Context;
 	LString Args;
 	ScriptCmd Func;
 	
 	LHostFunc(const LHostFunc &f)
 	{
 		Context = f.Context;
 		Args = f.Args;
 		Method = f.Method;
 		Func = f.Func;
 	}
 	
 	LHostFunc(const char *method, const char *args, ScriptCmd proc) : LFunc(method, HostFunc)
 	{
 		Args = args;
 		Func = proc;
 	}
 
 	LExecutionStatus Call(LScriptContext *Ctx, LScriptArguments &Args) override;
 };
 
 struct LExternFunc : public LFunc
 {
 	struct ExternType
 	{
 		int Ptr;
 		bool Unsigned;
 		bool Out;
 		int ArrayLen;
 		LVariantType Base;
 	};
 
 	LAutoString Lib;
 	ExternType ReturnType;
 	LArray<ExternType> ArgType;
 
 	LExecutionStatus Call(LScriptContext *Ctx, LScriptArguments &Args) override;
 };
 
 class LFunctionInfo : public LRefCount
 {
 	static int _Infos;
 
 	int32 StartAddr = INVALID_ADDR;
 	LString Name;
 
 	// The reason why this is a pointer is because during the function compilation the frame
 	// size is actually unknown. If the function calls itself then it won't know what
 	// frame size to insert in the assembly (this is NULL).
 	// In which case it has to insert a post compilation fix-up for the frame size.
 	LAutoPtr<uint16> FrameSize;
 
 	// The number and names of the parameters to the function.
 	LArray<LString> Params;
 
 public:
 	static constexpr int32 INVALID_ADDR = -1;
 
 	LFunctionInfo(const char *name)
 	{
 		if (name)
 			Name = name;
 	}
 
 	~LFunctionInfo()
 	{
 	}
 	
 	char *GetName()
 	{
 		return Name;
 	}
 
 	LArray<LString> &GetParams()
 	{
 		return Params;
 	}
 
 	bool ValidFrameSize()
 	{
 		return FrameSize.Get() != NULL;
 	}
 	
 	uint16 GetFrameSize()
 	{
 		if (!FrameSize)
 		{
 			LAssert(!"Invalid frame size");
 			return 0;
 		}
 		return *FrameSize;
 	}
 
 	template<typename T>
 	bool SetFrameSize(T size)
 	{
 		if (size >= 0xffff)
 		{
 			LAssert(!"Invalid frame size.");
 			return false;
 		}
 
 		return FrameSize.Reset(new uint16((uint16)size));
 	}
 
 	bool ValidStartAddr()
 	{
 		return StartAddr != INVALID_ADDR;
 	}
 
 	int32 GetStartAddr()
 	{
 		LAssert(ValidStartAddr());
 		return StartAddr;
 	}
 
 	bool SetStartAddr(int32_t addr)
 	{
 		if (addr < 0)
 		{
 			LAssert(!"Invalid start address");
 			return false;
 		}
 
 		StartAddr = addr;
 		return true;
 	}
 	
 	LFunctionInfo &operator =(LFunctionInfo &f)
 	{
 		StartAddr = f.StartAddr;
 		FrameSize = f.FrameSize;
 		Name = f.Name;
 		for (unsigned i=0; i<f.Params.Length(); i++)
 		{
 			Params[i] = f.Params[i];
 		}
 		return *this;
 	}
 };
 
 class LScriptUtils
 {
 public:
 	virtual ~LScriptUtils() {}
 
 	int atoi(char16 *s);
 	int64 atoi64(char16 *s);
 	double atof(char16 *s);
 	int htoi(char16 *s);
 };
 
 /// The base context class for scripting engines
 class LScriptContext : public LScriptUtils
 {
 public:
 	virtual ~LScriptContext() {}
 	
 	virtual LHostFunc *GetCommands() = 0;
 	virtual LString GetIncludeFile(const char *FileName) = 0;
 	virtual LAutoString GetDataFolder() { return LAutoString(); }
 	virtual LStream *GetLog() { return NULL; }
 	virtual bool SetLog(LStream *Log) { return false; }
 
 	// AddPrimitive: Add your primitives functions in a derived class using the format:
 	//
 	//		bool MyPrim(LVariant *Ret, ArgumentArray &Args) { ... }
 	//
 	// Where you return true if successful or false on error.
 };
 
 class LVariables : public LArray<LVariant>
 {
 	friend class LVirtualMachinePriv;
 
 	LHashTbl<ConstStrKey<char>,int> Lut;
 	
 public:
 	int Scope;
 	int NullIndex;
 	LCustomType *Obj;
 	
 	LVariables(int scope)
 	{
 		Scope = scope;
 		NullIndex = -1;
 		Obj = NULL;
 	}
 	
 	LVariables(LCustomType *obj)
 	{
 		Scope = SCOPE_OBJECT;
 		NullIndex = -1;
 		Obj = obj;
 	}
 
 	int Var(const char *n, bool create = false)
 	{
 		if (Obj)
 		{
 			return Obj->IndexOf(n);
 		}
 		else
 		{
 			int p = Lut.Find(n);
 			if (p)
 			{
 				return p - 1;
 			}
 
 			if (create)
 			{
 				int Len = (int)Length();
 
 				Lut.Add(n, Len + 1);
 				Length(Len + 1);
 
 				return Len;
 			}
 		}
 
 		return -1;
 	}
 };
 
 /// A block of compile byte code
 class LCompiledCode
 {
 	friend class LCompilerPriv;
+	friend class LVirtualMachine;
 	friend class LVirtualMachinePriv;
 	friend class LCompiler;
 	friend class LVmDebuggerWnd;
 
 	/// The global variables
 	LVariables Globals;
 	
 	/// The byte code of all the instructions
 	LArray<uint8_t> ByteCode;
 	
 	/// All the methods defined in the byte code and their arguments.
 	LArray< LAutoRefPtr<LFunctionInfo> > Methods;
 	
 	/// All the externs defined in the code.
 	LArray<LExternFunc*> Externs;
 	
 	/// All the user types defined
 	LHashTbl<StrKey<char16>, class LCustomType*> Types;
 	
 	/// The original script details
 	LString FileName;
 	LString Source;
 	
 	/// The system context (all the system functions)
 	LScriptContext *SysContext;
 	
 	/// Any user context (application functions)
 	LScriptContext *UserContext;
 
 	/// Debug info to map instruction address back to source line numbers
 	LHashTbl<IntKey<NativeInt>, int> Debug;
 
 public:
 	LCompiledCode();
 	LCompiledCode(LCompiledCode &copy);
 	~LCompiledCode();
 
 	/// Size of the byte code
 	size_t Length() { return ByteCode.Length(); }
 	/// Assignment operator
 	LCompiledCode &operator =(const LCompiledCode &c);
 	/// Gets a method defined in the code
 	LFunctionInfo *GetMethod(const char *Name, bool Create = false);
 	/// Sets a global variable
 	LVariant *Set(const char *Name, LVariant &v);
 	/// Gets the definition of a struct or custom type
 	LCustomType *GetType(char16 *Name) { return Types.Find(Name); }
 	/// Gets the file name this code was compiled from
 	const char *GetFileName() { return FileName; }
 	/// Gets the source
 	const char *GetSource() { return Source; }
 	/// Gets the source line number associated with an address
 	int ObjectToSourceAddress(size_t ObjAddr);
 	/// Turns an object address into a FileName:LineNumber string.
 	const char *AddrToSourceRef(size_t ObjAddr);
 
 	/// Sets the file name this code was compiled from
 	void SetSource(const char *file, const char *src)
 	{
 		if (file != FileName.Get())
 			FileName = file;
 		Source = src;
 	}
 };
 
 /// New compiler/byte code/VM scripting engine
 class LScriptEngine
 {
 	class LScriptEnginePrivate *d;
 
 public:
 	LScriptEngine(LViewI *parent, LScriptContext *UserContext, LVmCallback *Callback);
 	~LScriptEngine();
 
 	LStream *GetConsole();
 	bool SetConsole(LStream *t);
 
 	LCompiledCode *GetCurrentCode();
 	bool Compile(	LAutoPtr<LCompiledCode> &Obj,
 					LScriptContext *UserContext,
 					const char *Script,
 					const char *FileName = NULL,
 					LDom *Args = NULL);
 	LExecutionStatus Run(LCompiledCode *Obj, LVariant *Ret = NULL, const char *TempPath = NULL);
 	LExecutionStatus RunTemporary(LCompiledCode *Obj, char *Script, LVariant *Ret = NULL);
 	bool EvaluateExpression(LVariant *Result, LDom *VariableSource, const char *Expression);
 	bool CallMethod(LCompiledCode *Obj, const char *Method, LScriptArguments &Args);
 	LScriptContext *GetSystemContext();
 };
 
 class LVirtualMachine;
 
 class LVmDebugger : public LDom
 {
 public:
 	/// Set the VM ownership flag.
 	virtual void OwnVm(bool Own) = 0;
 	/// Makes the debugger the owner of the compiled code
 	virtual void OwnCompiledCode(LAutoPtr<LCompiledCode> Cc) = 0;
 	/// Gets the code owned by the debugger
 	virtual LCompiledCode *GetCode() = 0;
 	/// Set the source and asm
 	virtual void SetSource(const char *Mixed) = 0;
 	/// Show UI and wait for user response
 	virtual void Run() = 0;
 	
 	// Events
 		/// Called to update the debugger UI to the new current execution position
 		virtual void OnAddress(size_t Addr) = 0;
 		/// Called when an error occurs executing the script
 		virtual void OnError(const char *Msg) = 0;
 		/// Called when execution starts or ends
 		virtual void OnRun(bool Running) = 0;
 };
 
 class LVmCallback : public LDom
 {
 public:
 	/// Call a callback by name.
-	virtual bool CallCallback(LString CallbackName, LScriptArguments &Args) = 0;
+	virtual bool CallCallback(LVirtualMachine &Vm, LString CallbackName, LScriptArguments &Args) = 0;
 
 	/// Start a debugger instance to handle the execution in 'Vm'
 	virtual LVmDebugger *AttachVm(LVirtualMachine *Vm, LCompiledCode *Code, const char *Assembly) = 0;
 	
 	/// Compile a new script
 	virtual bool CompileScript(LAutoPtr<LCompiledCode> &Output, const char *FileName, const char *Source) = 0;
 };
 
 /// Debugger for vm script
 class LVmDebuggerWnd : public LWindow, public LVmDebugger
 {
 	struct LScriptVmDebuggerPriv *d;
 
 	void UpdateVariables(LList *Lst, LVariant *Arr, ssize_t Len, char Prefix);
 
 public:
 	LVmDebuggerWnd(LView *Parent, LVmCallback *Callback, LVirtualMachine *Vm, LCompiledCode *Code, const char *Assembly);
 	~LVmDebuggerWnd();
 
 	void OwnVm(bool Own);
 	void OnAddress(size_t Addr);
 	void OnError(const char *Msg);
 	void OnRun(bool Running);
 	void SetSource(const char *Mixed);
 	int OnNotify(LViewI *Ctrl, LNotification n);
 	int OnCommand(int Cmd, int Event, OsView Wnd);
 	bool OnRequestClose(bool OsShuttingDown);
 	LMessage::Param OnEvent(LMessage *Msg);
 	void LoadFile(const char *File);
 	LStream *GetLog();
 	void OwnCompiledCode(LAutoPtr<LCompiledCode> Cc);
 	LCompiledCode *GetCode();
 	
 	void Run();
 };
 
 #endif
 
diff --git a/src/common/Coding/ScriptLibrary.cpp b/src/common/Coding/ScriptLibrary.cpp
--- a/src/common/Coding/ScriptLibrary.cpp
+++ b/src/common/Coding/ScriptLibrary.cpp
@@ -1,1241 +1,1238 @@
 #include <stdio.h>
 #include <math.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/Scripting.h"
 #include "lgi/common/SubProcess.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/FileSelect.h"
 #include "ScriptingPriv.h"
 
 //////////////////////////////////////////////////////////////////////////////////////
 char16 sChar[]		= L"char";
 char16 sInt[]		= { 'i','n','t', 0 };
 char16 sUInt[]		= { 'u','i','n','t', 0 };
 char16 sInt32[]		= { 'i','n','t','3','2', 0 };
 char16 sUInt32[]	= { 'u','i','n','t','3','2', 0 };
 char16 sInt64[]		= { 'i','n','t','6','4', 0 };
 char16 sHWND[]		= { 'H','W','N','D', 0 };
 char16 sDWORD[]		= { 'D','W','O','R','D', 0 };
 char16 sLPTSTR[]	= { 's','L','P','T','S','T','R', 0 };
 char16 sLPCTSTR[]	= { 's','L','P','C','T','S','T','R', 0 };
 char16 sElse[]		= { 'e','l','s','e', 0 };
 char16 sIf[]		= { 'i','f',0 };
 char16 sFunction[]	= { 'f','u','n','c','t','i','o','n',0 };
 char16 sExtern[]	= { 'e','x','t','e','r','n',0 };
 char16 sFor[]		= { 'f','o','r',0 };
 char16 sWhile[]		= { 'w','h','i','l','e',0 };
 char16 sReturn[]	= { 'r','e','t','u','r','n',0 };
 char16 sInclude[]	= { 'i','n','c','l','u','d','e',0 };
 char16 sDefine[]	= { 'd','e','f','i','n','e',0 };
 char16 sStruct[]	= { 's','t','r','u','c','t',0 };
 char16 sTrue[]		= { 't','r','u','e',0 };
 char16 sFalse[]		= { 'f','a','l','s','e',0 };
 char16 sNull[]		= { 'n','u','l','l',0 };
 char16 sOutParam[]  = { '_','o','u','t','_',0};
 
 char16 sHash[]				= { '#', 0 };
 char16 sPeriod[]			= { '.', 0 };
 char16 sComma[]				= { ',', 0 };
 char16 sSemiColon[]			= { ';', 0 };
 char16 sStartRdBracket[]	= { '(', 0 };
 char16 sEndRdBracket[]		= { ')', 0 };
 char16 sStartSqBracket[]	= { '[', 0 };
 char16 sEndSqBracket[]		= { ']', 0 };
 char16 sStartCurlyBracket[]	= { '{', 0 };
 char16 sEndCurlyBracket[]	= { '}', 0 };
 
 //////////////////////////////////////////////////////////////////////////////////////
 LExecutionStatus LHostFunc::Call(LScriptContext *Ctx, LScriptArguments &Args)
 {
 	return (Ctx->*(Func))(Args) ? ScriptSuccess : ScriptError;
 }
 
 const char *InstToString(GInstruction i)
 {
 	#undef _i
 	#define _i(name, opcode, desc) \
 		case name: return desc;
 
 	switch (i)
 	{
 		AllInstructions
 	}
 
 	return "#err";
 }
 
 LStream LScriptArguments::NullConsole;
 
 //////////////////////////////////////////////////////////////////////////////////////
 int LScriptUtils::atoi(char16 *s)
 {
 	int i = 0;
 	if (s)
 	{
 		char b[64];
 		ssize_t Len = StrlenW(s) * sizeof(*s);
 		ssize_t Bytes = LBufConvertCp(b, "utf-8", sizeof(b), (const void*&)s, LGI_WideCharset, Len);
 		b[Bytes/sizeof(*b)] = 0;
 		i = ::atoi(b);
 	}
 	return i;
 }
 
 int64 LScriptUtils::atoi64(char16 *s)
 {
 	int64 i = 0;
 	if (s)
 	{
 		#ifdef _MSC_VER
 
 		i = _wtoi64(s);
 
 		#else
 
 		char b[64];
 		ssize_t Len = StrlenW(s) * sizeof(*s);
 		ssize_t Bytes = LBufConvertCp(b, "utf-8", sizeof(b), (const void*&)s, LGI_WideCharset, Len);
 		b[Bytes/sizeof(*b)] = 0;
 
 		i = strtoll(b, 0, 10);
 		
 		#endif
 	}
 	return i;
 }
 
 double LScriptUtils::atof(char16 *s)
 {
 	double i = 0;
 	if (s)
 	{
 		char b[64];
 		ssize_t Len = StrlenW(s) * sizeof(*s);
 		ssize_t Bytes = LBufConvertCp(b, "utf-8", sizeof(b), (const void*&)s, LGI_WideCharset, Len);
 		b[Bytes/sizeof(*b)] = 0;
 		i = ::atof(b);
 	}
 	return i;
 }
 
 int LScriptUtils::htoi(char16 *s)
 {
 	int i = 0;
 	if (s)
 	{
 		char b[64];
 		ssize_t Len = StrlenW(s) * sizeof(*s);
 		ssize_t Bytes = LBufConvertCp(b, "utf-8", sizeof(b), (const void*&)s, LGI_WideCharset, Len);
 		b[Bytes/sizeof(*b)] = 0;
 		i = ::htoi(b);
 	}
 	return i;
 }
 
 
 //////////////////////////////////////////////////////////////////////////////////////
 SystemFunctions::SystemFunctions()
 {
 	Engine = NULL;
 	Log = NULL;
 
 	#ifdef WINNATIVE
 	Brk = NULL;
 	#endif
 }
 
 SystemFunctions::~SystemFunctions()
 {
 }
 
 LStream *SystemFunctions::GetLog()
 {
 	return Log;
 }
 
 bool SystemFunctions::SetLog(LStream *log)
 {
 	LAssert(Log == NULL);
 	Log = log;
 	return true;
 }
 
 void SystemFunctions::SetEngine(LScriptEngine *Eng)
 {
 	Engine = Eng;
 }
 
 bool SystemFunctions::Assert(LScriptArguments &Args)
 {
 	*Args.GetReturn() = true;
 	if (Args.Length() == 0)
 		return true;
 
 	auto v = Args[0]->CastInt32();
 	if (!v)
 	{
 		const char *Msg = Args.Length() > 1 ? Args[1]->CastString() : NULL;
 		*Args.GetReturn() = false;
 		Args.Throw(NULL, -1, Msg);
 	}
 
 	return true;
 }
 
 bool SystemFunctions::DebuggerEnabled(LScriptArguments &Args)
 {
 	if (Args.Length() == 0)
 	{
 		LAssert(!"Wrong args.");
 		return false;
 	}
 
 	Args.GetVm()->SetDebuggerEnabled(Args[0]->CastInt32() != 0);
 	return true;
 }
 
 bool SystemFunctions::Throw(LScriptArguments &Args)
 {
 	const char *Msg = Args.Length() > 0 ? Args[0]->CastString() : NULL;
 	Args.Throw(NULL, -1, Msg);
 	return true;
 }
 
 bool SystemFunctions::LoadString(LScriptArguments &Args)
 {
 	if (Args.Length() != 1)
 	{
 		LAssert(!"Wrong args.");
 		return false;
 	}
 
 	*Args.GetReturn() = LLoadString(Args[0]->CastInt32());
 	return true;	
 }
 
 bool SystemFunctions::Sprintf(LScriptArguments &Args)
 {
 	if (Args.Length() < 1)
 	{
 		LAssert(!"Wrong args.");
 		return false;
 	}
 
 	char *Fmt = Args[0]->Str();
 	if (!Fmt)
 		return false;
 
 	#if defined(LINUX) || defined(MAC)
 	
 	// No support for sprintf with generated args... hack a string up
 	// Formatting widths etc not supported.
 	LArray<char> s;
 	int i = 1;
 	for (char *f = Fmt; *f; f++)
 	{
 		if (f[0] == '%' && f[1] != '%')
 		{
 			f++; // Skip '%'
 			
 			// char *Fmt = f;
 			while (*f && !IsAlpha(*f))
 				f++; // Skip formatting..
 			
 			if (i >= Args.Length())
 				break; // No more arguments...
 				
 			switch (*f)
 			{
 				case 's':
 				{
 					// String...
 					char *v = Args[i]->CastString();
 					if (v)
 						s.Add(v, strlen(v));
 					else
 						s.Add((char*)"(null)", 4);
 					break;
 				}
 				case 'c':
 				{
 					char *Str = Args[i]->Str();
 					s.Add(Str ? *Str : '?');
 					break;
 				}
 				case 'f':
 				case 'g':
 				{
 					break;
 				}
 				case 'u':
 				case 'd':
 				case 'i':
 				{
 					// Int...
 					LString v;
 					v.Printf("%i", Args[i]->CastInt32());
 					s.Add(v.Get(), v.Length());
 					break;
 				}
 			}
 			
 			i++;
 		}
 		else s.Add(*f);
 	}
 	
 	s.Add(0); // NULL terminate
 	*Args.GetReturn() = s.AddressOf();
 	
 	#else
 	
 	LArray<UNativeInt> Params;
 	va_list a;
 
 	unsigned i = 1;
 	for (char *f = Fmt; *f; f++)
 	{
 		if (f[0] == '%' && f[1] != '%')
 		{
 			char *t = f + 1;
 			while (*t && !IsAlpha(*t))
 				t++;
 
 			if (i >= Args.Length())
 			{
 				LAssert(!"Not enough args.");
 				break;
 			}
 
 			switch (*t)
 			{
 				case 's':
 				{
 					Params.Add((UNativeInt)Args[i++]->Str());
 					break;
 				}
 				case 'c':
 				{
 					char *Str = Args[i++]->Str();
 					Params.Add(Str ? *Str : '?');
 					break;
 				}
 				case 'f':
 				case 'g':
 				{
 					union tmp
 					{
 						double Dbl;
 						struct
 						{
 							uint32_t High;
 							uint32_t Low;
 						};
 					} Tmp;
 					Tmp.Dbl = Args[i++]->CastDouble();
 
 					Params.Add(Tmp.High);
 					Params.Add(Tmp.Low);
 					break;
 				}
 				default:
 				{
 					Params.Add(Args[i++]->CastInt32());
 					break;
 				}
 			}
 			
 			f = *t ? t + 1 : t;
 		}
 	}
 
 	a = (va_list) &Params[0];
 
 	#ifndef WIN32
 	#define _vsnprintf vsnprintf
 	#endif
 
 	char Buf[1024];
 	vsprintf_s(Buf, sizeof(Buf), Fmt, a);
 	*Args.GetReturn() = Buf;
 	
 	#endif
 
 	return true;
 }
 
 bool SystemFunctions::ReadTextFile(LScriptArguments &Args)
 {
 	if (Args.Length() == 1 &&
 		LFileExists(Args[0]->CastString()))
 	{
 		if (Args.GetReturn()->OwnStr(::LReadTextFile(Args[0]->CastString())))
 			return true;
 	}
 
 	return false;
 }
 
 bool SystemFunctions::WriteTextFile(LScriptArguments &Args)
 {
 	if (Args.Length() == 2)
 	{
 		LFile f;
 		if (f.Open(Args[0]->CastString(), O_WRITE))
 		{
 			f.SetSize(0);
 			
 			LVariant *v = Args[1];
 			if (v)
 			{
 				switch (v->Type)
 				{
 					default: break;
 					case GV_STRING:
 					{
 						size_t Len = strlen(v->Value.String);
 						*Args.GetReturn() = f.Write(v->Value.String, Len) == Len;
 						return true;
 						break;
 					}
 					case GV_BINARY:
 					{
 						*Args.GetReturn() = f.Write(v->Value.Binary.Data, v->Value.Binary.Length) == v->Value.Binary.Length;
 						return true;
 						break;
 					}
 				}
 			}
 		}
 	}
 
 	return false;
 }
 
 LView *SystemFunctions::CastLView(LVariant &v)
 {
 	switch (v.Type)
 	{
 		default: break;
 		case GV_DOM:
 			return dynamic_cast<LView*>(v.Value.Dom);
 		case GV_GVIEW:
 			return v.Value.View;
 	}
 	return 0;
 }
 
 bool SystemFunctions::SelectFiles(LScriptArguments &Args)
 {
 	Args.GetReturn()->Empty();
 	if (Args.Length() < 2)
 	{
 		Args.Throw(_FL, "SelectFiles(Parent, Callback[, FileTypes[, InitialDir[, MultiSelect[, SaveAs]]]]) expects at least 2 arguments.");
 		return false;
 	}
 
-	auto Ctx = Args.GetVm()->GetCallback();
+	auto Ctx = Args.GetVm()->SaveContext();
 	if (!Ctx)
 	{
 		Args.Throw(_FL, "SelectFiles(...) requires a valid callback context.");
 		return false;
 	}
 
 	LFileSelect *s = new LFileSelect;
 	if (!s)
 		return false;
 	
 	s->Parent(CastLView(*Args[0]));
 	auto Callback = Args[1]->Str();	
 	auto Types = LString(Args.IdxCheck(2) ? Args[2]->CastString() : NULL).SplitDelimit(",;:");
 	for (auto c: Types)
 	{
 		char *sp = strrchr(c, ' ');
 		if (sp)
 		{
 			*sp++ = 0;
 			s->Type(sp, c);
 		}
 		else
 		{
 			char *dot = strrchr(c, '.');
 			if (dot)
 			{
 				char Type[256];
 				sprintf_s(Type, sizeof(Type), "%s files", dot + 1);
 				s->Type(Type, c);
 			}
 		}
 	}
 	s->Type("All Files", LGI_ALL_FILES);
 
 	s->InitialDir (Args.IdxCheck(3) ? Args[3]->CastString() : 0);
 	s->MultiSelect(Args.IdxCheck(4) ? Args[4]->CastInt32() != 0 : true);
 	bool SaveAs =  Args.IdxCheck(5) ? Args[5]->CastInt32() != 0 : false;
 
 	auto Process = [Callback=LString(Callback),Ctx](LFileSelect *s, bool ok)
 	{
 		if (ok)
 		{
-			LVirtualMachine Vm;
-			LScriptArguments Args(&Vm);
+			LScriptArguments Args(NULL);
 
 			LVariant *v = new LVariant;
 			if (auto Lst = v->SetList())
 			{
 				for (unsigned i=0; i<s->Length(); i++)
 				{
 					auto path = (*s)[i];
 					Lst->Insert(new LVariant(path));
 				}
 			}
 			Args.Add(v);
 
-			Ctx->CallCallback(Callback, Args);
+			Ctx.Call(Callback, Args);
 			Args.DeleteObjects();
 		}
 
 		delete s;
 	};
 
 	if (SaveAs)
 		s->Save(Process);
 	else
 		s->Open(Process);
 
 	return true;
 }
 
 bool SystemFunctions::SelectFolder(LScriptArguments &Args)
 {
 	Args.GetReturn()->Empty();
 	if (Args.Length() < 2)
 	{
 		Args.Throw(_FL, "SelectFolder(Parent, Callback[, InitialDir]) expects at least 2 arguments.");
 		return false;
 	}
 
-	auto Ctx = Args.GetVm()->GetCallback();
+	auto Ctx = Args.GetVm()->SaveContext();
 	if (!Ctx)
 	{
 		Args.Throw(_FL, "SelectFiles(...) requires a valid callback context.");
 		return false;
 	}
 
 	LFileSelect *s = new LFileSelect;
 	if (!s)
 		return false;
 	
 	s->Parent(CastLView(*Args[0]));
 	auto Callback = Args[1]->Str();
 	if (Args.IdxCheck(2))
 		s->InitialDir(Args[2]->CastString());
 
-	s->OpenFolder([Ctx, Callback=LString(Callback)](auto s, bool ok)
+	s->OpenFolder([Ctx, Callback = LString(Callback)](auto s, bool ok)
 	{
 		if (ok)
 		{
-			LVirtualMachine Vm;
-			LScriptArguments Args(&Vm);
+			LScriptArguments Args(NULL);
 			Args.Add(new LVariant(s->Name()));
-			Ctx->CallCallback(Callback, Args);
+			Ctx.Call(Callback, Args);
 			Args.DeleteObjects();
 		}
 
 		delete s;
 	});
 
 	return true;
 }
 
 bool SystemFunctions::Sleep(LScriptArguments &Args)
 {
 	if (Args.Length() != 1)
 	{
 		LAssert(!"Wrong args.");
 		return false;
 	}
 
 	LSleep(Args[0]->CastInt32());
 	return true;
 }
 
 bool SystemFunctions::ToString(LScriptArguments &Args)
 {
 	LStringPipe p;
 	const char *Sep = ", ";
 
 	for (unsigned i=0; i<Args.Length(); i++)
 	{
 		LString s = Args[i]->ToString();
 		p.Print("%s%s", i?Sep:"", s.Get());
 	}
 
 	Args.GetReturn()->OwnStr(p.NewStr());
 	return true;
 }
 
 bool SystemFunctions::Print(LScriptArguments &Args)
 {
 	LStream *Out = Log ? Log : (Engine ? Engine->GetConsole() : NULL);
 
 	for (unsigned n=0; Out && n<Args.Length(); n++)
 	{
 		if (!Args[n])
 			continue;
 
 		LVariant v = *Args[n];
 		char *f = v.CastString();
 		if (!f)
 		{
 			Out->Write("NULL", 4);
 			continue;
 		}
 
 		#if 1
 			size_t Len = strlen(f);
 			Out->Write(f, Len);
 		#else
 			char *i = f, *o = f;
 			for (; *i; i++)
 			{
 				if (*i == '\\')
 				{
 					i++;
 					switch (*i)
 					{
 						case 'n':
 							*o++ = '\n';
 							break;
 						case 'r':
 							*o++ = '\r';
 							break;
 						case 't':
 							*o++ = '\t';
 							break;
 						case '\\':
 							*o++ = '\\';
 							break;
 						case '0':
 							*o++ = 0;
 							break;
 					}
 				}
 				else
 				{
 					*o++ = *i;
 				}
 			}
 			*o = 0;
 			Out->Write(f, o - f);
 		#endif
 	}
 
 	return true;
 }
 
 bool SystemFunctions::FormatSize(LScriptArguments &Args)
 {
 	if (Args.Length() != 1)
 		return false;
 
 	char s[64];
 	LFormatSize(s, sizeof(s), Args[0]->CastInt64());
 	*Args.GetReturn() = s;
 	return true;
 }
 
 bool SystemFunctions::ClockTick(LScriptArguments &Args)
 {
 	*Args.GetReturn() = (int64)LCurrentTime();
 	return true;
 }
 
 bool SystemFunctions::Now(LScriptArguments &Args)
 {
 	Args.GetReturn()->Empty();
 	Args.GetReturn()->Type = GV_DATETIME;
 	Args.GetReturn()->Value.Date = new LDateTime;
 	Args.GetReturn()->Value.Date->SetNow();
 	return true;
 }
 
 bool SystemFunctions::New(LScriptArguments &Args)
 {
 	if (Args.Length() < 1 || !Args[0])
 	{
 		LAssert(!"Wrong args.");
 		return false;
 	}
 
 	Args.GetReturn()->Empty();
 	char *sType = Args[0]->CastString();
 	if (!sType)
 		return false;
 
 	if (IsDigit(*sType))
 	{
 		// Binary block
 		int Bytes = ::atoi(sType);
 		if (!Bytes)
 			return false;
 		
 		return Args.GetReturn()->SetBinary(Bytes, new char[Bytes], true);
 	}
 
 	LVariant *Ret = Args.GetReturn();
 	LDomProperty Type = LStringToDomProp(sType);
 	switch (Type)
 	{	
 		case TypeList:
 		{
 			Ret->SetList();
 			break;
 		}
 		case TypeHashTable:
 		{
 			Ret->SetHashTable();
 			break;
 		}
 		case TypeSurface:
 		{
 			Ret->Empty();
 			Ret->Type = GV_LSURFACE;
 			if ((Ret->Value.Surface.Ptr = new LMemDC))
 			{
 				Ret->Value.Surface.Ptr->IncRef();
 				Ret->Value.Surface.Own = true;
 			}
 			break;
 		}
 		case TypeFile:
 		{
 			Ret->Empty();
 			
 			#if 1
 			Ret->Type = GV_STREAM;
 			Ret->Value.Stream.Ptr = new LFile;
 			if (Ret->Value.Stream.Ptr)
 				Ret->Value.Stream.Own = true;
 			#else
 			Ret->Type = GV_GFILE;
 			if ((Ret->Value.File.Ptr = new LFile))
 			{
 				Ret->Value.File.Ptr->AddRef();
 				Ret->Value.File.Own = true;
 			}
 			#endif
 			
 			break;
 		}
 		case TypeDateTime:
 		{
 			Ret->Empty();
 			Ret->Type = GV_DATETIME;
 			Ret->Value.Date = new LDateTime;
 			break;
 		}
 		default:
 		{
 			Ret->Empty();
 
 			LCompiledCode *c = Engine ? Engine->GetCurrentCode() : NULL;
 			if (!c)
 				return false;
 
 			LAutoWString o(Utf8ToWide(sType));
 			LCustomType *t = c->GetType(o);
 			if (t)
 			{
 				int ArrayLength = Args.Length() > 1 ? Args[1]->CastInt32() : 1;
 				if (ArrayLength > 0)
 				{
 					Ret->Type = GV_CUSTOM;
 					Ret->Value.Custom.Dom = t;
 					Ret->Value.Custom.Data = new uint8_t[t->Sizeof() * ArrayLength];
 				}
 			}
 		}
 	}
 
 	return true;
 }
 
 bool SystemFunctions::Len(LScriptArguments &Args)
 {
 	size_t i = 0;
 	for (LVariant *v: Args)
 	{
 		switch (v->Type)
 		{
 			case GV_LIST:
 				i += v->Value.Lst->Length();
 				break;
 			case GV_HASHTABLE:
 				i += v->Value.Hash->Length();
 				break;
 			case GV_BINARY:
 				i += v->Value.Binary.Length;
 				break;
 			case GV_STRING:
 				i += Strlen(v->Value.String);
 				break;
 			case GV_WSTRING:
 				i += Strlen(v->Value.WString);
 				break;
 			default:
 				i += 1;
 				break;
 		}
 	}
 
 	*Args.GetReturn() = i;
 	return true;
 }
 
 bool SystemFunctions::Delete(LScriptArguments &Args)
 {
 	if (Args.Length() != 1)
 	{
 		LAssert(!"Wrong args.");
 		return false;
 	}
 
 	LVariant *v = Args[0];
 	if (v->Type == GV_CUSTOM)
 	{
 		DeleteArray(v->Value.Custom.Data);
 		v->Empty();
 	}
 	else
 	{
 		v->Empty();
 	}
 
 	*Args.GetReturn() = true;
 	return true;
 }
 
 class LFileListEntry : public LDom
 {
 	bool Folder;
 	LVariant Name;
 	int64 Size;
 	LDateTime Modified;
 
 public:
 	LFileListEntry(LDirectory *d)
 	{
 		Folder = d->IsDir();
 		Name = d->GetName();
 		Size = d->GetSize();
 		Modified.Set(d->GetLastWriteTime());
 	}
 
 	bool GetVariant(const char *Var, LVariant &Value, const char *Arr = NULL) override
 	{
 		LDomProperty p = LStringToDomProp(Var);
 		switch (p)
 		{
 			case ObjName:
 				Value = Name;
 				break;
 			case ObjLength:
 				Value = Size;
 				break;
 			case FileFolder:
 				Value = Folder;
 				break;
 			case FileModified:
 				Value = &Modified;
 				break;
 			default:
 				return false;
 		}
 		return true;
 	}
 };
 
 bool SystemFunctions::DeleteFile(LScriptArguments &Args)
 {
 	if (Args.Length() != 1)
 	{
 		LAssert(!"Wrong args.");
 		return false;
 	}
 
 	char *f = Args[0]->CastString();
 	if (f)
 		*Args.GetReturn() = FileDev->Delete(Args[0]->CastString());
 	else
 		*Args.GetReturn() = false;
 	return true;
 }
 
 bool SystemFunctions::CurrentScript(LScriptArguments &Args)
 {
 	LCompiledCode *Code;
 	if (Engine &&
 		(Code = Engine->GetCurrentCode()))
 	{
 		*Args.GetReturn() = Code->GetFileName();
 		return true;
 	}
 	return false;
 }
 
 bool SystemFunctions::PathExists(LScriptArguments &Args)
 {
 	if (Args.Length() == 0)
 	{
 		LAssert(!"Wrong args.");
 		return false;
 	}
 		
 	LDirectory d;
 	if (d.First(Args[0]->CastString(), NULL))
 	{
 		if (d.IsDir())
 			*Args.GetReturn() = 2;
 		else
 			*Args.GetReturn() = 1;
 	}
 	else
 	{
 		*Args.GetReturn() = 0;
 	}
 	
 	return true;		
 }
 
 bool SystemFunctions::PathJoin(LScriptArguments &Args)
 {
 	char p[MAX_PATH_LEN] = "";
 	for (unsigned i=0; i<Args.Length(); i++)
 	{
 		char *s = Args[i]->CastString();
 		if (i)
 			LMakePath(p, sizeof(p), p, s);
 		else
 			strcpy_s(p, sizeof(p), s);
 	}
 	
 	if (*p)
 		*Args.GetReturn() = p;
 	else
 		Args.GetReturn()->Empty();
 	return true;
 }
 
 bool SystemFunctions::PathSep(LScriptArguments &Args)
 {
 	*Args.GetReturn() = DIR_STR;
 	return true;
 }
 
 bool SystemFunctions::ListFiles(LScriptArguments &Args)
 {
 	if (Args.Length() < 1)
 	{
 		Args.GetReturn()->Empty();
 		Args.Throw(_FL, "ListFiles(FolderPath[, FilterPattern]) expects at least one argument.");
 		return false;
 	}
 
 	Args.GetReturn()->SetList();
 
 	auto Folder  = Args[0]->CastString();
 	auto Pattern = Args.Length() > 1 ? Args[1]->CastString() : NULL;
 
 	LDirectory d;
 	for (auto b=d.First(Folder); b; b=d.Next())
 	{
 		if (!Pattern || MatchStr(Pattern, d.GetName()))
 			Args.GetReturn()->Value.Lst->Insert(new LVariant(new LFileListEntry(&d)));
 	}
 
 	return true;
 }
 
 bool SystemFunctions::CreateSurface(LScriptArguments &Args)
 {
 	Args.GetReturn()->Empty();
 	if (Args.Length() < 2)
 	{
 		Args.Throw(_FL, "CreateSurface(x, y[, Bits|ColourSpace]) expects at least two arguments.");
 		return false;
 	}
 
 	auto x = Args[0]->CastInt32();
 	auto y = Args[1]->CastInt32();
 	LColourSpace Cs = CsNone;
 
 	if (Args.Length() > 2)
 	{
 		LVariant *Type = Args[2];
 		const char *c;
 		if (Type->IsInt())
 		{
 			// Bit depth... convert to default Colour Space.
 			Cs = LBitsToColourSpace(Type->CastInt32());
 		}
 		else if ((c = Type->Str()))
 		{
 			// Parse string colour space def
 			Cs = LStringToColourSpace(Type->Str());
 		}
 	}
 
 	if (!Cs) // Catch all error cases and make it the default screen depth.
 		Cs = GdcD->GetColourSpace();
 
 	auto r = Args.GetReturn();
 	if ((r->Value.Surface.Ptr = new LMemDC(x, y, Cs)))
 	{
 		r->Type = GV_LSURFACE;
 		r->Value.Surface.Own = true;
 		r->Value.Surface.Ptr->IncRef();
 	}
 
 	return true;
 }
 
 bool SystemFunctions::ColourSpaceToString(LScriptArguments &Args)
 {
 	Args.GetReturn()->Empty();
 	if (Args.Length() != 1)
 	{
 		Args.Throw(_FL, "ColourSpaceToString(ColourSpaceInt) expects at least one argument.");
 		return false;
 	}
 
 	*Args.GetReturn() = LColourSpaceToString((LColourSpace)Args[0]->CastInt32());
 	return true;
 }
 
 bool SystemFunctions::StringToColourSpace(LScriptArguments &Args)
 {
 	Args.GetReturn()->Empty();
 	if (Args.Length() != 1)
 	{
 		Args.Throw(_FL, "StringToColourSpace(ColourSpaceStr) expects at least one argument.");
 		return false;
 	}
 
 	*Args.GetReturn() = (int)LStringToColourSpace(Args[0]->Str());
 	return true;
 }
 
 bool SystemFunctions::MessageDlg(LScriptArguments &Args)
 {
 	if (Args.Length() < 2)
 	{
 		Args.Throw(_FL, "MessageDlg(Parent, Message[, Title[, Buttons]]) expects at least 2 arguments.");
 		return false;
 	}
 
 	auto Parent = CastLView(*Args[0]);
 	auto Msg    = Args[1]->Str();
 	auto Title  = Args.IdxCheck(2) ? Args[2]->Str() : LAppInst->Name();
 	auto Btns   = Args.IdxCheck(3) ? Args[3]->CastInt32() : MB_OK;
 
 	auto Btn = LgiMsg(Parent, Msg, Title, Btns);
 	*Args.GetReturn() = Btn;
 
 	return true;
 }
 
 bool SystemFunctions::GetInputDlg(LScriptArguments &Args)
 {
 	if (Args.Length() < 5)
 	{
 		Args.Throw(_FL, "GetInputDlg(Parent, DefaultInput, Message, Title, IsPassword, Callback) expects 5 arguments.");
 		return false;
 	}
 
-	auto Ctx = Args.GetVm()->GetCallback();
+	auto Ctx = Args.GetVm()->SaveContext();
 	if (!Ctx)
 	{
 		Args.Throw(_FL, "GetInputDlg requires a valid VM context.");
 		return false;
 	}
 
 	auto Parent   = CastLView(*Args[0]);
 	auto InitVal  = Args[1]->Str();
 	auto Msg      = Args[2]->Str();
 	auto Title    = Args[3]->Str();
 	auto Pass     = Args[4]->CastInt32() != 0;
 	auto Callback = Args[5]->Str();
 
 	Args.GetReturn()->Empty();
 
 	auto Dlg = new LInput(Parent, InitVal, Msg, Title, Pass);
 	Dlg->DoModal([this, Dlg, Ctx, Callback=LString(Callback)](auto d, auto ok)
 	{
 		if (ok)
 		{
-			LVirtualMachine Vm;
-			LScriptArguments Args(&Vm);
+			LScriptArguments Args(NULL);
 			Args.Add(new LVariant(Dlg->GetStr()));
-			Ctx->CallCallback(Callback, Args);
+			Ctx.Call(Callback, Args);
 			Args.DeleteObjects();
 		}
 		delete Dlg;
 	});
 
 	// Don't wait here...
 	return true;
 }
 
 bool SystemFunctions::GetViewById(LScriptArguments &Args)
 {
 	Args.GetReturn()->Empty();
 
 	if (Args.Length() < 2)
 	{
 		LAssert(!"Wrong args.");
 		return false;
 	}
 
 	LViewI *Parent = CastLView(*Args[0]);
 	int Id = Args[1]->CastInt32();
 	if (!Parent || Id <= 0)
 		return false;
 
 	if (Parent->GetViewById(Id, Args.GetReturn()->Value.View))
 	{
 		Args.GetReturn()->Type = GV_GVIEW;
 	}
 
 	return true;
 }
 
 bool SystemFunctions::Execute(LScriptArguments &Args)
 {
 	if (Args.Length() < 2)
 	{
 		LAssert(!"Wrong args.");
 		return false;
 	}
 
 	LStringPipe p;
 	char *Exe = Args[0]->CastString();
 	char *Arguments = Args[1]->CastString();
 	LSubProcess e(Exe, Arguments);
 	bool Status = e.Start();
 	if (Status)
 	{
 		e.Communicate(&p);
 		LAutoString o(p.NewStr());
 		*Args.GetReturn() = o;
 	}
 	else if (Log)
 	{
 		uint32_t ErrCode = e.GetErrorCode();
 		LString ErrMsg = LErrorCodeToString(ErrCode);
 		if (ErrMsg)
 			Log->Print("Error: Execute(\"%s\",\"%s\") failed with '%s'\n", Exe, Arguments, ErrMsg.Get());
 		else
 			Log->Print("Error: Execute(\"%s\",\"%s\") failed with '0x%x'\n", Exe, Arguments, ErrCode);
 	}
 	
 	return Status;
 }
 
 bool SystemFunctions::System(LScriptArguments &Args)
 {
 	if (Args.Length() < 2)
 	{
 		LAssert(!"Wrong args.");
 		return false;
 	}
 
 	char *Exe = Args[0]->Str();
 	char *Arg = Args[1]->Str();
 	*Args.GetReturn() = LExecute(Exe, Arg);
 	return true;
 }
 
 bool SystemFunctions::OsName(LScriptArguments &Args)
 {
 	*Args.GetReturn() = LGetOsName();
 	return true;
 }
 
 bool SystemFunctions::OsVersion(LScriptArguments &Args)
 {
 	LArray<int> Ver;
 	LGetOs(&Ver);
 	Args.GetReturn()->SetList();
 	for (int i=0; i<3; i++)
 		Args.GetReturn()->Value.Lst->Insert(new LVariant(Ver[i]));
 
 	return true;
 }
 
 #define DefFn(Name) \
 	LHostFunc(#Name, 0, (ScriptCmd)&SystemFunctions::Name)
 
 LHostFunc SystemLibrary[] =
 {
 	// Debug
 	DefFn(Assert),
 	DefFn(Throw),
 	DefFn(DebuggerEnabled),
 
 	// String handling
 	DefFn(LoadString),
 	DefFn(FormatSize),
 	DefFn(Sprintf),
 	DefFn(Print),
 	DefFn(ToString),
 	
 	// Containers/objects
 	DefFn(New),
 	DefFn(Delete),
 	DefFn(Len),
 
 	// Files
 	DefFn(ReadTextFile),
 	DefFn(WriteTextFile),
 	DefFn(SelectFiles),
 	DefFn(SelectFolder),
 	DefFn(ListFiles),
 	DefFn(DeleteFile),
 
 	DefFn(CurrentScript),
 	DefFn(PathJoin),
 	DefFn(PathExists),
 	DefFn(PathSep),
 
 	// Time	
 	DefFn(ClockTick),
 	DefFn(Sleep),
 	DefFn(Now),
 
 	// Images
 	DefFn(CreateSurface),
 	DefFn(ColourSpaceToString),
 	DefFn(StringToColourSpace),
 
 	// UI
 	DefFn(MessageDlg),
 	DefFn(GetInputDlg),
 	DefFn(GetViewById),
 
 	// System
 	DefFn(Execute),
 	DefFn(System),
 	DefFn(OsName),
 	DefFn(OsVersion),
 
 	// End of list marker
 	LHostFunc(0, 0, 0),
 };
 
 LHostFunc *SystemFunctions::GetCommands()
 {
 	return SystemLibrary;
 }
 
diff --git a/src/common/Coding/ScriptVM.cpp b/src/common/Coding/ScriptVM.cpp
--- a/src/common/Coding/ScriptVM.cpp
+++ b/src/common/Coding/ScriptVM.cpp
@@ -1,2168 +1,2212 @@
 #include <math.h>
 #include "lgi/common/Lgi.h"
 #include "lgi/common/Scripting.h"
 #include "lgi/common/Box.h"
 #include "lgi/common/TabView.h"
 #include "lgi/common/TextLog.h"
 #include "lgi/common/List.h"
 #include "lgi/common/ToolBar.h"
 #include "lgi/common/TableLayout.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/ScrollBar.h"
 #include "lgi/common/Matrix.h"
 #include "lgi/common/Menu.h"
 #include "ScriptingPriv.h"
 
 #define TIME_INSTRUCTIONS		0
 #define POST_EXECUTE_STATE		0
 
 // #define BREAK_POINT				0x0000009F
 
 #define ExitScriptExecution		c.u8 = e
 #define SetScriptError			c.u8 = e; Status = ScriptError
 #define CurrentScriptAddress	(c.u8 - Base)
 #define CheckParam(ptr)			if (!(ptr)) \
 								{ \
 									OnException(_FL, CurrentScriptAddress-1, #ptr); \
 									c.u8 = e; \
 									Status = ScriptError; \
 									break; \
 								}
 
 #define AddLocalSize(NewSize) \
 	size_t LocalsBase = Locals.Length(); \
 	Locals.SetFixedLength(false); \
 	/* LgiTrace("%s:%i - Locals %i -> %i\n", _FL, LocalsBase, LocalsBase + NewSize); */ \
 	Locals.Length(LocalsBase + NewSize); \
 	Scope[SCOPE_LOCAL] = &Locals[LocalsBase]; \
 	Locals.SetFixedLength();
 
 
 #ifdef WIN32
 extern "C" uint64 __cdecl CallExtern64(void *FuncAddr, NativeInt *Ret, uint32_t Args, void *Arg);
 #elif defined(LINUX)
 #include <signal.h>
 #endif
 
 int LVariantCmp(LVariant *a, LVariant *b, NativeInt Data)
 {
 	LVariant *Param = (LVariant*) Data;
 	if (!a || !b)
 		return 0;
 		
 	if (a->Type == GV_STRING &&
 		b->Type == GV_STRING)
 	{	
 		const char *Empty = "";
 		const char *as = a->Str();
 		const char *bs = b->Str();
 
 		return _stricmp(as?as:Empty, bs?bs:Empty);
 	}
 	else if (a->Type == GV_DOM &&
 			 b->Type == GV_DOM &&
 			 Param)
 	{
 		const char *Fld = Param->Str();
 		int Dir = 1;
 		if (Fld && *Fld == '-')
 		{
 			Fld++;
 			Dir = -1;
 		}
 
 		LVariant av, bv;
 		if (a->Value.Dom->GetValue(Fld, av) &&
 			b->Value.Dom->GetValue(Fld, bv))
 		{
 			return LVariantCmp(&av, &bv, 0) * Dir;
 		}
 	}
 	else if (a->Type == GV_INT32 &&
 			 b->Type == GV_INT32)
 	{
 		return a->CastInt32() - b->CastInt32();
 	}
 	else if (a->Type == GV_DATETIME &&
 			 b->Type == GV_DATETIME)
 	{
 		return a->Value.Date->Compare(b->Value.Date);
 	}
 	else
 	{
 		LAssert(!"Impl a handler for this type.");
 	}
 	
 	return 0;
 }
 
 inline LVariantType DecidePrecision(LVariantType a, LVariantType b)
 {
 	if (a == GV_DOUBLE || b == GV_DOUBLE)
 		return GV_DOUBLE;
 
 	if (a == GV_INT64 || b == GV_INT64)
 		return GV_INT64;
 
 	return GV_INT32;
 }
 
 inline LVariantType ComparePrecision(LVariantType a, LVariantType b)
 {
 	if (a == GV_NULL || b == GV_NULL)
 		return GV_NULL;
 
 	if (a == GV_DATETIME && b == GV_DATETIME)
 		return GV_DATETIME;
 	
 	if (a == GV_DOUBLE || b == GV_DOUBLE)
 		return GV_DOUBLE;
 
 	if (a == GV_STRING || b == GV_STRING)
 		return GV_STRING;
 
 	if (a == GV_INT64 || b == GV_INT64)
 		return GV_INT64;
 
 	return GV_INT32;
 }
 
 inline char *CastString(LVariant *v, LVariant &cache)
 {
 	if (v->Type == GV_STRING)
 		return v->Str();
 
 	cache = *v;
 	return cache.CastString();
 }
 
 inline int CompareVariants(LVariant *a, LVariant *b)
 {
 	// Calculates "a - b"
 
 	switch (ComparePrecision(a->Type, b->Type))
 	{
 		case GV_DATETIME:
 			return a->Value.Date->Compare(b->Value.Date);
 			break;
 		case GV_DOUBLE:
 		{
 			double d = a->CastDouble() - b->CastDouble();
 			if (d < -MATRIX_DOUBLE_EPSILON)
 				return -1;
 			return d > MATRIX_DOUBLE_EPSILON;
 		}
 		case GV_STRING:
 		{
 			LVariant as, bs;
 			char *A = CastString(a, as);
 			char *B = CastString(b, bs);
 			if (!A || !B)
 				return -1;
 			else
 				return strcmp(A, B);
 			break;
 		}
 		case GV_INT64:
 		{
 			int64 d = a->CastInt64() - b->CastInt64();
 			if (d < 0)
 				return -1;
 			return d > 0;
 		}
 		case GV_NULL:
 		{
 			// One or more values is NULL
 			if (a->IsNull() && b->IsNull())
 				return 0; // The same..
 			LVariant *Val = a->IsNull() ? b : a;
 			if (Val->IsNull())
 			{
 				LAssert(0);
 				return 0;
 			}
 			switch (Val->Type)
 			{
 				case GV_INT32:
 				case GV_INT64:
 					return Val->CastInt64() != 0;
 				case GV_STRING:
 					return Val->Str() != NULL;
 				default:
 					return Val->CastVoidPtr() != NULL;
 			}			
 			break;
 		}
 		default:
 			return a->CastInt32() - b->CastInt32();
 			break;
 	}
 }
 
 LExecutionStatus LExternFunc::Call(LScriptContext *Ctx, LScriptArguments &Args)
 {
 	if (!Lib || !Method)
 		return ScriptError;
 
 	LStream *Log = Ctx ? Ctx->GetLog() : NULL;
 	if (Args.Length() != ArgType.Length())
 	{
 		if (Log)
 			Log->Print("Error: Extern '%s.%s' expecting %i arguments, not %i given.\n",
 						Lib.Get(), Method.Get(),
 						ArgType.Length(),
 						Args.Length());
 		return ScriptError;
 	}
 
 	LArray<NativeInt> Val;
 	LArray<char*> Mem;
 	bool UnsupportedArg = false;
 
 	Val.Length(Args.Length() << 1);
 	LPointer Ptr;
 	Ptr.ni = &Val[0];
 	for (unsigned i=0; !UnsupportedArg && i<Args.Length(); i++)
 	{
 		LVariant *v = Args[i];
 		ExternType &t = ArgType[i];
 		if (!v)
 			return ScriptError;
 		
 		if (t.Ptr)
 		{
 			// Allocate some memory for the pointer.
 			switch (t.Base)
 			{
 				case GV_STRING:
 				{
 					if (t.Out)
 					{
 						void *cp = v->CastVoidPtr();
 						*Ptr.vp++ = cp;
 					}
 					else
 					{
 						char *s = NewStr(v->CastString());
 						if (!s)
 						{
 							UnsupportedArg = true;
 							break;
 						}
 						
 						Mem.Add(s);
 						*Ptr.vp++ = s;
 					}					
 					break;
 				}
 				case GV_VOID_PTR:
 				{
 					*Ptr.vp++ = v->CastVoidPtr();
 					break;
 				}
 				default:
 				{
 					UnsupportedArg = true;
 					break;
 				}
 			}
 		}
 		else
 		{
 			// Plain type
 			switch (t.Base)
 			{
 				case GV_INT32:
 				{
 					#if defined(_WIN64)
 					*Ptr.s64++ = v->CastInt32();
 					#else
 					*Ptr.s32++ = v->CastInt32();
 					#endif
 					break;
 				}
 				case GV_INT64:
 				{
 					*Ptr.s64++ = v->CastInt64();
 					break;
 				}
 				default:
 				{
 					UnsupportedArg = true;
 					break;
 				}
 			}
 		}
 	}
 
 	LLibrary Library(Lib);
 	if (!Library.IsLoaded())
 	{
 		if (Log)
 			Log->Print("Error: Extern library '%s' missing.\n", Lib.Get());
 		return ScriptError;
 	}
 			
 	void *c = Library.GetAddress(Method);
 	if (!c)
 	{
 		if (Log)
 			Log->Print("Error: Extern library '%s' has no method '%s'.\n", Lib.Get(), Method.Get());
 		return ScriptError;
 	}
 	
 	#if defined(_MSC_VER) || (defined(MAC) && defined(LGI_32BIT) && !LGI_COCOA)
 	ssize_t a = Ptr.ni - &Val[0];
 	#endif
 	NativeInt r = 0;
 
 	#if defined(_MSC_VER)
 		#if defined(_WIN64)
 			// 64bit... boooo no inline asm!
 			void *b = &Val[0];
 			r = CallExtern64(c, &r, (uint32_t)a, b);
 		#else
 			// 32bit... yay inline asm!
 			void *b = Ptr.ni - 1;
 			_asm
 			{
 				mov ecx, a
 				mov ebx, b
 			}
 			label1:
 			_asm
 			{
 				push [ebx]
 				sub ebx, 4
 				loop label1
 				
 				mov ebx, c
 				call ebx
 				mov r, eax
 			}
 		#endif
 	#elif defined(MAC)
 		#if LGI_COCOA
 		#warning FIXME
 		#elif LGI_32BIT
 		// 32bit only
 		void *b = Ptr.ni - 1;
         asm (	"movl %2, %%ecx;"
 				"movl %3, %%ebx;"
 				"label1:"
 				"pushl (%%ebx);"
 				"subl %%ebx, 4;"
 				"loop label1;"
 				"call *%1;"
 				:"=a"(r)				/* output */
 				:"r"(c), "r"(a), "r"(b)	/* input */
 				:/*"%eax",*/ "%ecx", "%ebx"	/* clobbered register */
 				);
 		#endif
 	#else
 		// Not implemented, gcc???
 		LAssert(0);
 	#endif
 
 	*Args.GetReturn() = (int) r;
 	for (unsigned i=0; i<Args.Length(); i++)
 	{
 		LVariant *v = Args[i];
 		ExternType &t = ArgType[i];
 		if (t.Out)
 		{
 			if (v->Type == GV_BINARY &&
 				v->Value.Binary.Data != NULL &&
 				t.Base == GV_STRING)
 			{
 				// Cast the type back to t.Base
 				char *p = (char*)v->Value.Binary.Data;
 				v->Type = t.Base;
 				v->Value.String = p;
 			}
 		}
 	}	
 
 	Mem.DeleteArrays();
 
 	return ScriptSuccess;
 }
 
 struct CodeBlock
 {
 	unsigned SrcLine;
 	LArray<unsigned> AsmAddr;
 	unsigned ViewLine;
 
 	LAutoString Source;
 	int SrcLines;
 
 	LAutoString Asm;
 	int AsmLines;
 };
 
 class LVirtualMachinePriv : public LRefCount
 {
 	LVariant ArrayTemp;
 	
 	char *CastArrayIndex(LVariant *Idx)	
 	{
 		if (Idx == NULL || Idx->Type == GV_NULL)
 			return NULL;
 
 		if (Idx->Type == GV_STRING)
 			return Idx->Str();
 		
 		ArrayTemp = *Idx;
 		return ArrayTemp.CastString();
 	}
 
 public:
 	struct StackFrame
 	{
 		uint32_t CurrentFrameSize;
 		ssize_t  PrevFrameStart;
 		size_t   ReturnIp;
 		LVarRef  ReturnValue;
 	};
 
 	enum RunType
 	{
 		RunContinue,
 		RunStepInstruction,
 		RunStepLine,
 		RunStepOut
 	};
 
 	LVirtualMachine *Vm;
 	LStream *Log = NULL;
 	LCompiledCode *Code = NULL;
 	LExecutionStatus Status = ScriptNotStarted;
 	LScriptPtr c;
 	LVariant Reg[MAX_REGISTER];
 	LArray<LVariant> Locals;
 	LVariant *Scope[SCOPE_MAX];
 	LArray<StackFrame> Frames;
 	RunType StepType;
 	LVmCallback *Callback = NULL;
 	LVmDebugger *Debugger = NULL;
 	LScriptArguments *ArgsOutput = NULL;
 	LArray<ssize_t> BreakPts;
 	LString TempPath;
 	bool DebuggerEnabled = false;
 	bool BreakCpp = false;
 
 	LVirtualMachinePriv(LVirtualMachine *vm, LVmCallback *callback)
 	{
 		Vm = vm;
 		Callback = callback;
 		ZeroObj(Scope);
 	}
 	
 	~LVirtualMachinePriv()
 	{
 	}
 
 	void DumpVariant(LStream *Log, LVariant &v)
 	{
 		if (!Log)
 			return;
 
 		switch (v.Type)
 		{
 			case GV_INT32:
 				Log->Print("(int) %i", v.Value.Int);
 				break;
 			case GV_INT64:
 				Log->Print("(int64) %I64i", v.Value.Int64);
 				break;
 			case GV_STRING:
 			{
 				char *nl = strchr(v.Value.String, '\n');
 				if (nl)
 					Log->Print("(string) '%.*s...' (%i bytes)", nl - v.Value.String, v.Value.String, strlen(v.Value.String));
 				else
 					Log->Print("(string) '%s'", v.Value.String);
 				break;
 			}
 			case GV_DOUBLE:
 				Log->Print("(double) %g", v.Value.Dbl);
 				break;
 			case GV_BOOL:
 				Log->Print("(bool) %s", v.Value.Bool ? "true" : "false");
 				break;
 			case GV_DOM:
 				Log->Print("(LDom*) %p", v.Value.Dom);
 				break;
 			case GV_HASHTABLE:
 			{
 				Log->Print("(GHashTable*) %p {", v.Value.Hash);
 
 				int n = 0;
 				// const char *k;
 				// for (LVariant *p = v.Value.Hash->First(&k); p; p = v.Value.Hash->Next(&k), n++)
 				for (auto it : *v.Value.Hash)
 				{
 					Log->Print("%s\"%s\"=", n?",":"", it.key);
 					DumpVariant(Log, *it.value);
 				}
 
 				Log->Print("}");
 				break;
 			}
 			case GV_LIST:
 			{
 				Log->Print("(LList*) %p {", v.Value.Lst);
 
 				int n=0; 
 				for (auto i: *v.Value.Lst)
 				{
 					Log->Print("%s%i=", n?",":"", n);
 					DumpVariant(Log, *i);
 					n++;
 				}
 
 				Log->Print("}");
 				break;
 			}
 			case GV_NULL:
 			{
 				Log->Print("null");
 				break;
 			}
 			case GV_BINARY:
 			{
 				Log->Print("(Binary[%i])", v.Value.Binary.Length);
 				if (v.Value.Binary.Data)
 				{
 					int i;
 					for (i=0; i<16 && i < v.Value.Binary.Length; i++)
 						Log->Print(" %.2x", ((uint8_t*)v.Value.Binary.Data)[i]);
 					if (i < v.Value.Binary.Length)
 						Log->Print("...");
 				}
 				break;
 			}
 			default:
 				Log->Print("(Type-%i) ????", v.Type);
 				break;
 		}
 	}
 
 	void DumpVariables(LVariant *v, int len)
 	{
 		if (!Log)
 			return;
 
 		for (int i=0; i<len; i++)
 		{
 			if (v[i].Type != GV_NULL)
 			{
 				Log->Print("[%i] = ", i);
 				DumpVariant(Log, v[i]);
 				Log->Print("\n");
 			}
 		}
 	}
 
 	void OnException(const char *File, int Line, ssize_t Address, const char *Msg)
 	{
+		if (!Code)
+		{
+			LgiTrace("%s:%i - Exception without Code object: %s:%i, %s\n",
+				_FL,
+				File, Line,
+				Msg);
+			return;
+		}
+
 		if (Address < 0)
 		{
 			uint8_t *Base = &Code->ByteCode[0];
 			Address = c.u8 - Base;
 		}
 
 		if (!File || Line < 0)
 		{
 			// Extract the file / line from the current script location
 			File = Code->GetFileName();
 			Line = Code->ObjectToSourceAddress(Address);
 		}
 
 		if (Log)
 		{
 			char *Last = strrchr((char*)File, DIR_CHAR);
 			Log->Print("%s Exception: %s (%s:%i)\n", Code->AddrToSourceRef(Address), Msg, Last?Last+1:File, Line);
 		}
 		else
 		{
 			LgiTrace("%s:%i - Exception @ %i: %s\n", File, Line, Address, Msg);
 		}
 		
 		if (Vm && Vm->OpenDebugger(Code))
 		{
 			if (!Debugger->GetCode())
 			{
 				LAutoPtr<LCompiledCode> Cp(new LCompiledCode(*Code));
 				Debugger->OwnCompiledCode(Cp);
 				
 				LStringPipe AsmBuf;
 				Decompile(Code->UserContext, Code, &AsmBuf);
 				LAutoString Asm(AsmBuf.NewStr());
 				Debugger->SetSource(Asm);
 			}
 			
 			Debugger->OnAddress(Address);
 			
 			LString m;
 			m.Printf("%s (%s:%i)", Msg, LGetLeaf(File), Line);
 			Debugger->OnError(m);
 			
 			Debugger->Run();
 		}
 		else
 		{
 			// Set the script return value to FALSE
 			if (Frames.Length())
 			{
 				StackFrame Sf = Frames[0];
 				LVarRef &Ret = Sf.ReturnValue;
 				LVariant *RetVar = &Scope[Ret.Scope][Ret.Index];
 				*RetVar = false;
 			}			
 
 			// Exit the script
 			c.u8 = Code->ByteCode.AddressOf() + Code->ByteCode.Length();
 
 			// Set the script status...
 			Status = ScriptError;
 		}
 	}
 
 	LExecutionStatus Decompile(LScriptContext *Context, LCompiledCode *Code, LStream *log)
 	{
 		LExecutionStatus Status = ScriptSuccess;
 		LAssert(sizeof(LVarRef) == 4);
 
 		LScriptPtr c;
 		uint8_t *Base = &Code->ByteCode[0];
 		c.u8 = Base;
 		uint8_t *e = c.u8 + Code->ByteCode.Length();
 
 		LStream *OldLog = Log;
 		if (log)
 			Log = log;
 		for (unsigned k=0; k<Code->Globals.Length(); k++)
 		{
 			Log->Print("G%i = ", k);
 			DumpVariant(Log, Code->Globals[k]);
 			Log->Print("\n");
 		}
 		Log->Print("\n");
 
 		LHashTbl<IntKey<NativeInt>, char*> Fn;
 		for (unsigned m=0; m<Code->Methods.Length(); m++)
 		{
 			LFunctionInfo *Info = Code->Methods[m];
 			if (Info->ValidStartAddr())
 				Fn.Add(Info->GetStartAddr(), Info->GetName());
 			else
 				LAssert(!"Method not defined.");
 		}
 
 		int OldLineNum = 0;
 		while (c.u8 < e)
 		{
 			char *Meth = Fn.Find(CurrentScriptAddress);
 			if (Meth)
 			{
 				Log->Print("%s:\n", Meth);
 			}
 
 			int LineNum = Code->ObjectToSourceAddress(CurrentScriptAddress);
 			if (LineNum >= 0 && LineNum != OldLineNum)
 			{
 				Log->Print("  %i:\n", OldLineNum = LineNum);
 			}
 
 			switch (*c.u8++)
 			{
 				#define VM_DECOMP 1
 				#include "Instructions.h"
 				#undef VM_DECOMP
 			}
 		}
 
 		if (log)
 			Log = OldLog;
 
 		return Status;
 	}
 
 	LExecutionStatus Setup(LCompiledCode *code, uint32_t StartOffset, LStream *log, LFunctionInfo *Func, LScriptArguments *Args)
 	{
 		Status = ScriptSuccess;
 		
 		Code = code;
 		if (!Code)
 			return ScriptError;
 		
 		if (log)
 			Log = log;
 		else if (Code->SysContext && Code->SysContext->GetLog())
 			Log = Code->SysContext->GetLog();
 		else if (Code->UserContext && Code->UserContext->GetLog())
 			Log = Code->UserContext->GetLog();
 		// else LgiTrace("%s:%i - Execution without a log?\n", _FL);
 			
 		LAssert(sizeof(LVarRef) == 4);
 
 		uint8_t *Base = c.u8 = &Code->ByteCode[0];
 		uint8_t *e = c.u8 + Code->ByteCode.Length();
 
 		Scope[SCOPE_REGISTER] = Reg;
 		Scope[SCOPE_LOCAL] = NULL;
 		Scope[SCOPE_GLOBAL] = &Code->Globals[0];
 		Scope[SCOPE_OBJECT] = NULL;
 		Scope[SCOPE_RETURN] = Args->GetReturn();
 
 		#ifdef _DEBUG
 		const char *SourceFileName = Code->GetFileName();
 		char Obj[MAX_PATH_LEN];
 		if (SourceFileName)
 		{
 			if (strchr(SourceFileName, DIR_CHAR))
 				strcpy_s(Obj, sizeof(Obj), SourceFileName);
 			else if (TempPath != NULL)
 				LMakePath(Obj, sizeof(Obj), TempPath, SourceFileName);
 			else
 			{
 				LGetSystemPath(LSP_TEMP, Obj, sizeof(Obj));
 				LMakePath(Obj, sizeof(Obj), Obj, SourceFileName);
 			}
 
 			char *Ext = LGetExtension(Obj);
 			if (Ext)
 				strcpy_s(Ext, sizeof(Obj)-(Ext-Obj), "asm");
 			else
 				strcat_s(Obj, sizeof(Obj), ".asm");
 		}
 		else
 		{
 			LAutoString DataPath;
 			if (Code->UserContext)
 				DataPath = Code->UserContext->GetDataFolder();
 			if (!DataPath)
 			{
 				char p[256];
 				if (LGetSystemPath(LSP_APP_INSTALL, p, sizeof(p)))
 					DataPath.Reset(NewStr(p));
 			}
 		
 			LMakePath(Obj, sizeof(Obj), DataPath, "Script.asm");
 		}
 		
 		{
 			LDirectory SrcD, ObjD;
 			bool OutOfDate = true;
 			if (LFileExists(SourceFileName) &&
 				SrcD.First(SourceFileName, NULL) != 0 &&
 				ObjD.First(Obj, NULL) != 0)
 			{
 				OutOfDate = ObjD.GetLastWriteTime() < SrcD.GetLastWriteTime();
 			}			
 			if (OutOfDate || Debugger)
 			{
 				LFile f;
 				LStringPipe p;
 				LStream *Out = NULL;
 			
 				if (Debugger)
 				{
 					Out = &p;
 				}
 				else if (f.Open(Obj, O_WRITE))
 				{
 					f.SetSize(0);
 					Out = &f;
 				}
 
 				if (Out)
 				{
 					LExecutionStatus Decomp = Decompile(Code->UserContext, Code, Out);
 					f.Close();
 					if (Decomp != ScriptSuccess)
 					{
 						LAssert(!"Decompilation failed.");
 						return ScriptError;
 					}
 
 					if (Debugger)
 					{
 						LAutoString a(p.NewStr());
 						Debugger->OnAddress(CurrentScriptAddress);
 						Debugger->SetSource(a);
 					}
 				}
 			}
 		}
 		#endif
 
 		#if TIME_INSTRUCTIONS
 		LARGE_INTEGER freq = {0}, start, end;
 		QueryPerformanceFrequency(&freq);
 		LHashTbl<IntKey<int>, int64> Timings;
 		LHashTbl<IntKey<int>, int> TimingFreq;
 		#endif
 
 		// Calling a function only, not the whole script
 		StackFrame &Sf = Frames.New();
 		Sf.ReturnIp = e - c.u8;
 		Sf.PrevFrameStart = 0;
 		Sf.ReturnValue.Scope = SCOPE_RETURN;
 		Sf.ReturnValue.Index = 0; // array is only one item long anyway
 
 		if (Func)
 		{
 			// Set up stack for function call
 			if (!Func->ValidFrameSize())
 			{
 				Log->Print("%s:%i - Function '%s' has an invalid frame size. (Script: %s).\n",
 					_FL, Func->GetName(), Code->AddrToSourceRef(Func->GetStartAddr()));
 				return ScriptError;
 			}
 			Sf.CurrentFrameSize = Func->GetFrameSize();
 			AddLocalSize(Sf.CurrentFrameSize);
 
 			if (Args)
 			{
 				// Check the local frame size is at least big enough for the args...
 				if (Args->Length() > Sf.CurrentFrameSize)
 				{
 					Log->Print("%s:%i - Arg count mismatch, Supplied: %i, FrameSize: %i (Script: %s).\n",
 						_FL, (int)Args->Length(), (int)Sf.CurrentFrameSize,
 						Code->AddrToSourceRef(Func->GetStartAddr()));
 					return ScriptError;
 				}
 
 				// Put the arguments of the function call into the local array
 				for (unsigned i=0; i<Args->Length(); i++)
 				{
 					Locals[LocalsBase+i] = *(*Args)[i];
 				}
 			}
 			if (!Func->ValidStartAddr())
 			{
 				Log->Print("%s:%i - Function '%s' is not defined. (Script: %s).\n",
 					_FL, Func->GetName(), Code->AddrToSourceRef(Func->GetStartAddr()));
 				return ScriptError;
 			}
 
 			// Set IP to start of function
 			c.u8 = Base + Func->GetStartAddr();
 		}
 		else
 		{
 			// Executing body of script
 			Sf.CurrentFrameSize = 0;
 			if (StartOffset > 0)
 				c.u8 = Base + StartOffset;
 		}
 		
 		return Status;
 	}
 
 	int NearestLine(size_t Addr)
 	{
 		int l = Code->Debug.Find(Addr);
 		if (l >= 0)
 			return l;
 
 		for (int Off = 1; Off < 20; Off++)
 		{
 			int l = Code->Debug.Find(Addr + Off);
 			if (l >= 0)
 			{
 				return l;
 			}
 
 			l = Code->Debug.Find(Addr - Off);
 			if (l >= 0)
 			{
 				return l;
 			}
 		}
 		return -1;
 	}
 	
 	LExecutionStatus Run(RunType Type)
 	{
 		LAssert(Code != NULL);
 		
 		uint8_t *Base = &Code->ByteCode[0];
 		uint8_t *e = Base + Code->ByteCode.Length();
 		
 		if (Type == RunContinue && BreakPts.Length() == 0)
 		{
 			// Unconstrained execution
 			while (c.u8 < e)
 			{
 				#if TIME_INSTRUCTIONS
 				uint8 TimedOpCode = *c.u8;
 				QueryPerformanceCounter(&start);
 				#endif
 				
 				#ifdef BREAK_POINT
 				if (c.u8 - Base == BREAK_POINT)
 				{
 					int asd=0;
 				}
 				#endif
 
 				switch (*c.u8++)
 				{
 					#define VM_EXECUTE 1
 					#include "Instructions.h"
 					#undef VM_EXECUTE
 				}
 				
 				#if TIME_INSTRUCTIONS
 				QueryPerformanceCounter(&end);
 				int Ticks = end.QuadPart - start.QuadPart;
 				int64 i = Timings.Find(TimedOpCode);
 				Timings.Add(TimedOpCode, i + Ticks);
 				i = TimingFreq.Find(TimedOpCode);
 				TimingFreq.Add(TimedOpCode, i + 1);
 				#endif
 			}
 
 			if (Log)
 			{
 				#if TIME_INSTRUCTIONS
 				Log->Print("\nTimings:\n");
 				Log->Print("%-20s%-10s%-10s%-10s\n", "Instr", "Total", "Freq", "Ave");
 				int Op;
 				for (int64 t=Timings.First(&Op); t; t=Timings.Next(&Op))
 				{
 					int Frq = TimingFreq.Find(Op);
 					int MilliSec = t * 1000000 / freq.QuadPart;
 					Log->Print("%-20s%-10i%-10i%-10i\n", InstToString((GInstruction)Op), MilliSec, Frq, MilliSec / Frq);
 				}
 				Log->Print("\n");
 				#endif
 
 				#if POST_EXECUTE_STATE
 				Log->Print("Stack:\n");
 				char *v;
 				for (void *i=Code->Globals.Lut.First(&v); i; i=Code->Globals.Lut.Next(&v))
 				{
 					int Idx = (int)i - 1;
 					if (Idx >= 0 && Idx < Code->Globals.Length())
 					{
 						Log->Print("%s = ", v);
 						DumpVariant(Log, Code->Globals[Idx]);
 						Log->Print("\n");
 					}
 				}
 				Log->Print("\nRegisters:\n");
 				DumpVariables(Reg, MAX_REGISTER);
 				#endif
 			}
 		}
 		else
 		{
 			// Stepping through code
-			// LHashTbl<IntKey<int>, int> &Debug = Code->Debug;
 			int Param = 0;
 			switch (Type)
 			{
 				case RunStepLine:
 					Param = NearestLine(CurrentScriptAddress);
 					break;
 				case RunStepOut:
 					Param = (int)Frames.Length();
 					break;
 				default:
 					break;
 			}
 			
 			if (BreakCpp)
 			#if defined(WIN32) && !defined(_WIN64)
 				_asm int 3
 			#else
 				assert(!"BreakPoint");
 			#endif
 
 			while (c.u8 < e)
 			{
 				if (Type == RunContinue &&
 					BreakPts.HasItem(c.u8 - Base))
 					break;
 				
 				switch (*c.u8++)
 				{
 					#define VM_EXECUTE 1
 					#include "Instructions.h"
 					#undef VM_EXECUTE
 				}
 
+				if (Type == RunContinue)
+					continue;
+
 				if (Type == RunStepLine)
 				{
 					int CurLine = NearestLine(CurrentScriptAddress);
 					if (CurLine && CurLine != Param)
 						break;
 				}
 				else if (Type == RunStepOut)
 				{
 					if ((int)Frames.Length() < Param)
 						break;
 				}
 				else if (Type == RunStepInstruction)
+				{
 					break;
+				}
+				else LAssert(!"Invalid Type.");
 			}
 		}
 
 		if (Debugger && Status != ScriptError)
 			Debugger->OnAddress(CurrentScriptAddress);
 		
 		return Status;
 	}
 };
 
 bool LVirtualMachine::BreakOnWarning = false;
 
 LVirtualMachine::LVirtualMachine(LVmCallback *callback)
 {
 	d = new LVirtualMachinePriv(this, callback);
 	d->IncRef();
 }
 
+LVirtualMachine::LVirtualMachine(Context ctx)
+{
+	d = new LVirtualMachinePriv(this, ctx.Callback);
+	d->IncRef();
+
+	if (d->Code = ctx.Code)
+	{
+		if (d->Code->ByteCode.IdxCheck(ctx.Addr))
+			d->c.u8 = d->Code->ByteCode.AddressOf() + ctx.Addr;
+	}
+	else
+		d->c.u8 = NULL;
+}
+
 LVirtualMachine::LVirtualMachine(LVirtualMachine *vm)
 {
 	d = vm->d;
 	d->IncRef();
 }
 
 LVirtualMachine::~LVirtualMachine()
 {
 	if (d->Vm == this)
 		d->Vm = NULL;
 	d->DecRef();
 }
 
 LExecutionStatus LVirtualMachine::Execute(LCompiledCode *Code, uint32_t StartOffset, LStream *Log, bool StartImmediately, LVariant *Return)
 {
 	if (!Code)
 		return ScriptError;
 
 	LScriptArguments Args(this, Return);
 	LExecutionStatus s = d->Setup(Code, StartOffset, Log, NULL, &Args);
 	if (s != ScriptSuccess || !StartImmediately)
 		return s;
 
 	return d->Run(LVirtualMachinePriv::RunContinue);
 }
 
 LExecutionStatus LVirtualMachine::ExecuteFunction(LCompiledCode *Code, LFunctionInfo *Func, LScriptArguments &Args, LStream *Log, LScriptArguments *ArgsOut)
 {
 	LCompiledCode *Cc = dynamic_cast<LCompiledCode*>(Code);
 	if (!Cc || !Func)
 		return ScriptError;
 
 	LExecutionStatus s = d->Setup(Cc, 0, Log, Func, &Args);
 	if (s != ScriptSuccess)
 		return s;
 
 	d->ArgsOutput = ArgsOut;
+	auto Prev = Args.Vm;
 	Args.Vm = this;
 	LExecutionStatus r = d->Run(LVirtualMachinePriv::RunContinue);
-	Args.Vm = NULL;
+	Args.Vm = Prev;
+
 	return r;
 }
 
 void LVirtualMachine::SetDebuggerEnabled(bool b)
 {
 	d->DebuggerEnabled = b;
 }
 
 LVmDebugger *LVirtualMachine::OpenDebugger(LCompiledCode *Code, const char *Assembly)
 {
 	if (d->DebuggerEnabled && !d->Debugger)
 	{
 		if (!d->Callback)
 			return NULL;
 		
 		d->Debugger = d->Callback->AttachVm(this, Code, Assembly);
 	}
 	
 	return d->Debugger;
 }
 
 bool LVirtualMachine::StepInstruction()
 {
 	LExecutionStatus s = d->Run(LVirtualMachinePriv::RunStepInstruction);
 	return s != ScriptError;
 }
 
 bool LVirtualMachine::StepLine()
 {
 	LExecutionStatus s = d->Run(LVirtualMachinePriv::RunStepLine);
 	return s != ScriptError;
 }
 
 bool LVirtualMachine::StepOut()
 {
 	LExecutionStatus s = d->Run(LVirtualMachinePriv::RunStepOut);
 	return s != ScriptError;
 }
 
 bool LVirtualMachine::BreakExecution()
 {
 	return false;
 }
 
 bool LVirtualMachine::Continue()
 {
 	LExecutionStatus s = d->Run(LVirtualMachinePriv::RunContinue);
 	return s != ScriptError;
 }
 
 bool LVirtualMachine::BreakPoint(const char *File, int Line, bool Add)
 {
 	return false;
 }
 
 bool LVirtualMachine::BreakPoint(int Addr, bool Add)
 {
 	if (Add)
 		d->BreakPts.Add(Addr);
 	else
 		d->BreakPts.Delete(Addr);
 	return true;
 }
 
 void LVirtualMachine::SetBreakCpp(bool Brk)
 {
 	d->BreakCpp = Brk;
 }
 
+LVirtualMachine::Context LVirtualMachine::SaveContext()
+{
+	LVirtualMachine::Context ctx;
+	
+	ctx.Callback = d->Callback;
+	if ((ctx.Code = d->Code) &&
+		ctx.Code->ByteCode.PtrCheck(d->c.u8))
+	{
+		ctx.Addr = d->c.u8 - ctx.Code->ByteCode.AddressOf();
+	}
+
+	return ctx;
+}
+
 LVmCallback *LVirtualMachine::GetCallback()
 {
 	return d->Callback;
 }
 
 void LVirtualMachine::SetTempPath(const char *Path)
 {
 	d->TempPath = Path;
 }
 
 ////////////////////////////////////////////////////////////////////
 /*
 bool GTypeDef::GetVariant(const char *Name, LVariant &Value, char *Arr)
 {
 	GMember *m = Members.Find(Name);
 	if (!m || !Object)
 	{
 		LAssert(!"No member?");
 		return false;
 	}
 
 	GPtr p;
 	p.i8 = Object;
 	p.i8 += m->Offset;
 	switch (m->Type)
 	{
 		case GV_INT32:
 		{
 			Value = *p.i32;
 			break;
 		}
 		case GV_DOUBLE:
 		{
 			Value = *p.dbl;
 			break;
 		}
 		case GV_STRING:
 		{
 			Value = p.i8;
 			break;
 		}
 		case GV_CUSTOM:
 		{
 			Value.Empty();
 			Value.Type = GV_CUSTOM;
 			Value.Value.Custom.Dom = m->Nest;
 			Value.Value.Custom.Data = p.i8;
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	return true;
 }
 
 bool GTypeDef::SetVariant(const char *Name, LVariant &Value, char *Arr)
 {
 	GMember *m = Members.Find(Name);
 	if (!m || !Object)
 	{
 		LAssert(!"No member?");
 		return false;
 	}
 
 	GPtr p;
 	p.i8 = Object;
 	p.i8 += m->Offset;
 	switch (m->Type)
 	{
 		case GV_INT32:
 		{
 			*p.i32 = Value.CastInt32();
 			break;
 		}
 		case GV_DOUBLE:
 		{
 			*p.dbl = Value.CastDouble();
 			break;
 		}
 		case GV_STRING:
 		{
 			char *s = Value.CastString();
 			if (!s)
 				return false;
 
 			int i;
 			for (i = 0; *s && i < m->Size - 1; i++)
 			{
 				*p.i8++ = *s++;
 			}
 			if (i < m->Size - 1)
 				*p.i8 = 0;
 			break;
 		}
 		case GV_CUSTOM:
 		{
 			GTypeDef *t = dynamic_cast<GTypeDef*>(Value.Value.Custom.Dom);
 			if (m->Nest == t)
 			{
 				memcpy(p.i8, Value.Value.Custom.Data, t->Sizeof());
 			}
 			break;
 		}
 		default:
 		{
 			return false;
 		}
 	}
 
 	return true;
 }
 */
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
 uint32_t IconsData[] =
 {
 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x9D9CCEBE, 0x3B166419, 0x74594357, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x543CF81F, 0xCEDE647C, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 
 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x7C998D1B, 0xF81FB61C, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xCEBFF81F, 0x43DB4C1C, 0xDF1E955B, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 
 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x8C0CF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x8D5CF81F, 0x43595C1A, 0x3AF74338, 0x8CFA4B57, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xC69D6C39, 0xF81FF81F, 0xF81FF81F, 0x0000F81F, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0x647BADFD, 0x543C53FB, 0x3B1553FB, 0x329132B2, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81F64CB, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 
 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x8D9FF81F, 0x8D9F8D9F, 0x855E857E, 0x7CFD7D1D, 0x74BC74DC, 0xF81F74DC, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x8BEBF81F, 0xF81F83AB, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x7CBB8D5C, 0xF81FB63D, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81F5BD8, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x959D647C, 0xCEBDF81F, 0x32913AD3, 0xB61B5353, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x3BA564CB, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x8D9FF81F, 0x74DC8D9F, 
 0x8D9FF81F, 0x74DC8D9F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x8D9F8D9F, 0x855E857E, 0x7CFD7D1D, 0x74BC74DC, 0xF81F74DC, 0xF81FF81F, 0xF81FF81F, 0x8D9FF81F, 0xAE1EB65E, 0xD71FA5FE, 0x853D8D7D, 0x6CBD7CFD, 0xF81F2AB5, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x8BEBF81F, 0x7329FF98, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xCE9E5C1A, 0xF81FF81F, 0xF81FF81F, 0x0000F81F, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0xF81F5398, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x00000000, 0x00000000, 0xF81F0000, 0xF81F6C7C, 0x5BD6F81F, 0xD6DD5BB5, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xB6D45CAA, 0xF81F3BA5, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x8D9FF81F, 0x2AB5D71F, 0x8D9FF81F, 0x2AB5D71F, 0xF81FF81F, 
 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xD71F8D9F, 0xC6DFD71F, 0xB65FBE7F, 0x9DDEAE3F, 0xF81F2AB5, 0xF81FF81F, 0xF81FF81F, 0x857EF81F, 0x9DDEAE1E, 0xFFFFDF3F, 0x74FD853D, 0x647C6CBC, 0xF81F2274, 0xF81FF81F, 0xF81FF81F, 0x9C6CF81F, 0x944D944C, 0x944D8C0C, 0xFF54FF76, 0xF81F62A8, 0xF81FF81F, 0xF81FF81F, 0xBE5D4B99, 0x543CF81F, 0xC6BE5C7C, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81F5398, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81F53DB, 0xF81FF81F, 0xF81FF81F, 0x0000F81F, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x75ED5489, 0x3BA5B6D4, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x857EF81F, 0x2274DF3F, 0x857EF81F, 0x2274DF3F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 
 0xDF3F857E, 0xB65FCEDF, 0x9DBEAE1F, 0x851B959E, 0xF81F2274, 0xF81FF81F, 0xF81FF81F, 0x855EF81F, 0xE75F9DDE, 0xFFFFFFFF, 0x6CBC74DD, 0x543C647C, 0xF81F1A33, 0xF81FF81F, 0xF81FF81F, 0x944BF81F, 0xFFD9F756, 0xFF53FF97, 0xFEEEFF31, 0x5226F66A, 0xF81FF81F, 0xF81FF81F, 0x84DA6C3A, 0xBE7EADDC, 0x43DB4C1C, 0xF81F953B, 0xF81FF81F, 0x00000000, 0x00000000, 0xF81F0000, 0xF81F4B77, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x00000000, 0x00000000, 0xF81F0000, 0x9D7C5C3B, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x75ED4C48, 0x5D0A75ED, 0xF81F3BA5, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x855EF81F, 0x1A33D71F, 0x855EF81F, 0x1A33D71F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xD71F855E, 0xA5FFBE7F, 0x855E959E, 
 0x6C7A7CFD, 0xF81F1A33, 0xF81FF81F, 0xF81FF81F, 0x7D1DF81F, 0xFFFFDF1E, 0xFFFFFFFF, 0xFFFFFFFF, 0x4BFCC69D, 0xF81F11F2, 0xF81FF81F, 0xF81FF81F, 0x940AF81F, 0xFF75FF97, 0xFEEEFF31, 0xF6ABFECD, 0xBCA7E5E8, 0xF81F49C5, 0xF81FF81F, 0x7CBAB61C, 0x541C53FA, 0x3B1553FB, 0x329132B2, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81F4B57, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x6C9CB63D, 0x43584BBA, 0x3AD53B16, 0x743742F4, 0xF81FF81F, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x6D8B4407, 0x3C055D0A, 0x1B212B84, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x7D1DF81F, 0x11F2CEBF, 0x7D1DF81F, 0x11F2CEBF, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xCEBF7D1D, 0x9DBEAE3F, 0x7CFD8D5E, 0x53B76CBC, 0xF81F11F2, 0xF81FF81F, 
 0xF81FF81F, 0x7CFDF81F, 0xCEBD853D, 0xFFFFFFFF, 0x541C5C5C, 0x43BBFFFF, 0xF81F09B1, 0xF81FF81F, 0xF81FF81F, 0x83A9F81F, 0xFF31FF74, 0xF6ACF6CF, 0xDDEAF68B, 0x41A4B467, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xC69DF81F, 0x32913AD3, 0xB5FB4B53, 0xF81FF81F, 0x00000000, 0x00000000, 0xF81F0000, 0xF81F4336, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x5D0A33E5, 0x2B843C05, 0xF81F0B00, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x7CFDF81F, 0x09B1BE9F, 0x7CFDF81F, 0x09B1BE9F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xBE9F7CFD, 0x959EA5FF, 0x6C9C7CFD, 0x4B565C3B, 0xF81F09B1, 0xF81FF81F, 0xF81FF81F, 0x74DCF81F, 0x6CBC74FD, 
 0xFFFFBE3B, 0x43DC541C, 0x337BFFFF, 0xF81F0990, 0xF81FF81F, 0xF81FF81F, 0x8389F81F, 0x6AA472E7, 0x72C56264, 0xB487DDA9, 0xF81F41A4, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x5BD6F81F, 0xF81F5BB5, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81F4336, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x3C052BA4, 0x0B002B84, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x74DCF81F, 0x0990AE5F, 0x74DCF81F, 0x0990AE5F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xAE5F74DC, 0x7D1D95BE, 0x5C3B6CBC, 0x43354BD9, 0xF81F0990, 0xF81FF81F, 0xF81FF81F, 0x74BCF81F, 0x647C6CBC, 0x9D7A543C, 0x3B9B43DB, 0x2B5BFFFF, 
 0xF81F0170, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x5A45F81F, 0x41A4AC26, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x00000000, 0x00000000, 0xF81F0000, 0xF81F5377, 0xF81FF81F, 0xF81FF81F, 0x0000F81F, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x2B842363, 0xF81F0B00, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x74BCF81F, 0x0170A5FE, 0x74BCF81F, 0x0170A5FE, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xA5FE74BC, 0x6C79851A, 0x4B555BF8, 0x32D34314, 0xF81F0170, 0xF81FF81F, 0xF81FF81F, 0x74DCF81F, 0x543C5C7C, 0x43BB4BFC, 0x335B3B9B, 0x231BFFFF, 0xF81F0170, 0xF81FF81F, 0xF81FF81F, 
 0xF81FF81F, 0xF81FF81F, 0x49E4F81F, 0xF81F41A4, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x9D7A53B7, 0x4BBAF81F, 0xB61C6459, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x0B001B42, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x74DCF81F, 0x01700170, 0x74DCF81F, 0x01700170, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x3B1674DC, 0x2A9432F6, 0x11F22253, 0x017009B1, 0xF81F0170, 0xF81FF81F, 0xF81FF81F, 0x74DCF81F, 0x3B163B16, 0x2A9432F6, 0x11F22253, 0x017009B1, 0xF81F0170, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x41A4F81F, 
 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x0000F81F, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0x747863F7, 0x953BB61C, 0x4BB843B9, 0xB61B7C98, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81F1301, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 
 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x6C18ADBA, 0x53D953B7, 0x3B144B98, 0x32503291, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x0000F81F, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 
 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xB61BF81F, 0x32503291, 0xA5794B12, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 
 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x5B95F81F, 0xB61A5373, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 
 };
 LInlineBmp DbgIcons = {128, 16, 16, IconsData};
 
 enum DbgCtrls
 {
 	IDC_STATIC = -1,
 	IDC_TABS = 300,
 	IDC_BOX,
 	IDC_BOX2,
 	IDC_TEXT,
 	IDC_LOCALS,
 	IDC_GLOBALS,
 	IDC_REGISTERS,
 	IDC_STACK,
 	IDC_LOG,
 	IDC_RUN,
 	IDC_PAUSE,
 	IDC_STOP,
 	IDC_RESTART,
 	IDC_GOTO,
 	IDC_STEP_INSTR,
 	IDC_STEP_LINE,
 	IDC_STEP_OUT,
 	IDC_SOURCE_LST,
 	IDC_BREAK_POINT,
 	IDC_BREAK_CPP,
 	IDC_VARS_TBL
 };
 
 struct LScriptVmDebuggerPriv;
 class LDebugView : public LTextView3
 {
 	LScriptVmDebuggerPriv *d;
 	int CurLine;
 	
 	int ErrorLine;
 	LString Error;
 	
 	LArray<int> BreakPts;
 	
 public:
 	LDebugView(LScriptVmDebuggerPriv *priv);
 	~LDebugView();
 
 	void SetError(const char *Err);
 	int GetCurLine() { return CurLine; }
 	int GetAddr();
 	void ScrollToCurLine();
 	void PourText(size_t Start, ssize_t Length) override;
 	void OnPaintLeftMargin(LSurface *pDC, LRect &r, LColour &colour) override;
 	void OnPaint(LSurface *pDC) override;
 	bool Breakpoint(int Addr);
 };
 
 struct LScriptVmDebuggerPriv
 {
 	// Current script
 	bool OwnVm;
 	LAutoPtr<LVirtualMachine> Vm;
 	LVmCallback *Callback;
 	LString Script, Assembly;
 	LArray<CodeBlock> Blocks;
 	size_t CurrentAddr;
 	LArray<bool> LineIsAsm;
 	LAutoPtr<LCompiledCode> Obj;
 	LVariant Return;
 	bool AcceptNotify;
 
 	// Ui
 	bool RunLoop;
 	LView *Parent;
 	LBox *Main;
 	LBox *Sub;
 	LList *SourceLst;
 	LTabView *Tabs;
 	LDebugView *Text;
 	LList *Locals, *Globals, *Registers, *Stack;
 	LTextLog *Log;
 	LToolBar *Tools;
 	LTableLayout *VarsTbl;
 
 	LScriptVmDebuggerPriv()
 	{
 		RunLoop = false;
 		OwnVm = false;
 		CurrentAddr = -1;
 		Main = NULL;
 		Tabs = NULL;
 		Log = NULL;
 		Text = NULL;
 		Locals = NULL;
 		Globals = NULL;
 		Registers = NULL;
 		Stack = NULL;
 		Tools = NULL;
 		SourceLst = NULL;
 		Callback = NULL;
 		VarsTbl = NULL;
 	}
 };
 
 LDebugView::LDebugView(LScriptVmDebuggerPriv *priv) : LTextView3(IDC_TEXT, 0, 0, 100, 100)
 {
 	d = priv;
 	ErrorLine = -1;
 	SetWrapType(TEXTED_WRAP_NONE);
 	GetCss(true)->PaddingLeft(LCss::Len(LCss::LenPx, 18));
 }
 
 LDebugView::~LDebugView()
 {
 }
 
 void LDebugView::SetError(const char *Err)
 {
 	ErrorLine = CurLine;
 	Error = Err;
 }
 
 #define IsHexChar(c) \
 	( \
 		IsDigit(c) \
 		|| \
 		((c) >= 'a' && (c) <= 'f') \
 		|| \
 		((c) >= 'A' && (c) <= 'F') \
 	)
 
 int IsAddr(char16 *Ln)
 {
 	int Addr = 0;
 	for (char16 *s = Ln; *s && *s != '\n' && s < Ln + 8; s++)
 	{
 		Addr += IsHexChar(*s);
 	}
 	
 	if (Addr != 8)
 		return -1;
 	
 	return HtoiW(Ln);
 }
 
 int LDebugView::GetAddr()
 {
 	ssize_t Index;
 	LTextLine *t = GetTextLine(Cursor, &Index);
 	if (!t)
 		return -1;
 		
 	int Addr = IsAddr(Text + t->Start);
 	return Addr;
 }
 
 void LDebugView::ScrollToCurLine()
 {
 	SetLine(CurLine);
 }
 
 bool LDebugView::Breakpoint(int Addr)
 {
 	if (BreakPts.HasItem(Addr))
 	{
 		BreakPts.Delete(Addr);
 		Invalidate();
 		return false;
 	}
 	else
 	{
 		BreakPts.Add(Addr);
 		Invalidate();
 		return true;
 	}
 }
 
 void LDebugView::OnPaintLeftMargin(LSurface *pDC, LRect &r, LColour &colour)
 {
 	LTextView3::OnPaintLeftMargin(pDC, r, colour);
 
 	pDC->Colour(LColour(192, 0, 0));
 	LFont *f = GetFont();
 	f->Colour(L_LOW, L_WORKSPACE);
 	f->Transparent(true);
 	
 	int Fy = f->GetHeight();
 	int Start = VScroll ? (int)VScroll->Value() : 0;
 	int Page = (r.Y() + Fy - 1) / Fy;
 	int Ln = Start;
 	int Rad = (Fy >> 1) - 1;
 	int PadY = GetCss(true)->PaddingTop().ToPx(Y(), f) + ((Fy - Rad) >> 1);
 
 	auto It = Line.begin(Start);
 	for (auto i = *It; i && Ln <= Start + Page; i = *(++It), Ln++)
 	{
 		int OffY = (Ln - Start) * f->GetHeight();
 		/*
 		LString Num;
 		Num.Printf("%i", Ln);
 		LDisplayString Ds(f, Num);
 		Ds.Draw(pDC, 0, r.y1+OffY);
 		*/
 		
 		char16 *s = Text + i->Start;
 		int Addr = IsAddr(s);
 		if (BreakPts.HasItem(Addr))
 		{
 			pDC->FilledCircle(r.x1 + Rad + 2, OffY + PadY + Rad, Rad);
 		}		
 	}
 
 	f->Transparent(false);
 	f->Colour(L_TEXT, L_WORKSPACE);
 }
 
 void LDebugView::OnPaint(LSurface *pDC)
 {
 	LTextView3::OnPaint(pDC);
 	if (Error)
 	{
 		LTextLine *Ln = Line[ErrorLine];
 
 		LFont *f = GetFont();
 		LRect c = GetClient();
 		int Pad = 3;
 		LDisplayString Ds(f, Error);
 		LRect r(0, 0, Ds.X()-1, Ds.Y()-1);
 		r.Inset(-Pad, -Pad);
 		r.Offset(c.X()-r.X(), Ln ? Ln->r.y1 - ScrollYPixel(): 0);
 		f->Transparent(false);
 		f->Colour(LColour::White, LColour::Red);
 		Ds.Draw(pDC, r.x1 + Pad, r.y1 + Pad, &r);
 	}
 }
 
 void LDebugView::PourText(size_t Start, ssize_t Len)
 {
 	LTextView3::PourText(Start, Len);
 
 	CurLine = -1;
 	for (unsigned i=0; i<d->Blocks.Length(); i++)
 	{
 		CodeBlock &b = d->Blocks[i];
 		for (unsigned n=0; n<b.AsmAddr.Length(); n++)
 		{
 			if (d->CurrentAddr >= b.AsmAddr[n])
 			{
 				CurLine = b.ViewLine + b.SrcLines + n - 1;
 			}
 		}
 	}
 
 	unsigned Idx = 0;
 	for (auto l: Line)
 	{
 		// char16 *t = Text + l->Start;
 		// char16 *e = t + l->Len;
 		if (CurLine == Idx)
 		{
 			l->c.Rgb(0, 0, 0);
 			l->Back = LColour(L_DEBUG_CURRENT_LINE);
 		}
 		else
 		{
 			bool IsAsm = Idx < d->LineIsAsm.Length() ? d->LineIsAsm[Idx] : false;
 			if (IsAsm)
 			{
 				l->c.Rgb(0, 0, 255);
 				l->Back.Rgb(0xf0, 0xf0, 0xf0);
 			}
 		}
 		Idx++;
 	}
 }
 
 LVmDebuggerWnd::LVmDebuggerWnd(LView *Parent, LVmCallback *Callback, LVirtualMachine *Vm, LCompiledCode *Code, const char *Assembly)
 {
 	d = new LScriptVmDebuggerPriv;
 	d->Parent = Parent;
 	d->AcceptNotify = false;
 	if (Vm)
 		d->Vm.Reset(new LVirtualMachine(Vm));
 	d->Callback = Callback;
 	if (Code)
 		d->Script = Code->GetSource();
 	d->Assembly = Assembly;
 	
 	LRect r(0, 0, 1000, 900);
 	SetPos(r);
 	if (Parent)
 		MoveSameScreen(Parent);
 	else
 		MoveToCenter();
 	Name("Script Debugger");
 	
 	if (Attach(NULL))
 	{
 		if ((Menu = new LMenu))
 		{
 			Menu->Attach(this);
 			LSubMenu *s = Menu->AppendSub("Debug");
 			s->AppendItem("Run", IDC_RUN, true, -1, "F5");
 			s->AppendItem("Pause", IDC_PAUSE, true, -1, NULL);
 			s->AppendItem("Stop", IDC_STOP, true, -1, "Ctrl+Break");
 			s->AppendItem("Restart", IDC_RESTART, true, -1, NULL);
 			s->AppendItem("Goto", IDC_GOTO, true, -1, NULL);
 			s->AppendSeparator();
 			s->AppendItem("Step Instruction", IDC_STEP_INSTR, true, -1, "F11");
 			s->AppendItem("Step Line", IDC_STEP_LINE, true, -1, "F10");
 			s->AppendItem("Step Out", IDC_STEP_OUT, true, -1, "Shift+F11");
 			s->AppendSeparator();
 			s->AppendItem("Breakpoint", IDC_BREAK_POINT, true, -1, "F9");
 			s->AppendItem("Break Into C++", IDC_BREAK_CPP, true, -1, "Ctrl+F9");
 		}
 		
 		AddView(d->Tools = new LToolBar);
 		
 		uint16 *Px = (uint16*) DbgIcons.Data;
 		LImageList *il = new LImageList(16, 16, DbgIcons.Create(*Px));
 		if (il)
 			d->Tools->SetImageList(il, 16, 16, true);
 
 		d->Tools->AppendButton("Run", IDC_RUN);		
 		d->Tools->AppendButton("Pause", IDC_PAUSE);
 		d->Tools->AppendButton("Stop", IDC_STOP);
 		d->Tools->AppendButton("Restart", IDC_RESTART);
 		d->Tools->AppendButton("Goto", IDC_GOTO);
 		d->Tools->AppendSeparator();
 		d->Tools->AppendButton("Step Instruction", IDC_STEP_INSTR);
 		d->Tools->AppendButton("Step Line", IDC_STEP_LINE);
 		d->Tools->AppendButton("Step Out", IDC_STEP_OUT);
 		
 		AddView(d->Main = new LBox(IDC_BOX));		
 		d->Main->SetVertical(true);
 		
 		d->Main->AddView(d->Sub = new LBox(IDC_BOX2));
 		d->Sub->SetVertical(false);
 		
 		d->Sub->AddView(d->SourceLst = new LList(IDC_SOURCE_LST, 0, 0, 100, 100));
 		d->SourceLst->GetCss(true)->Width(LCss::Len("200px"));
 		d->SourceLst->AddColumn("Source", 200);
 		d->Sub->AddView(d->Text = new LDebugView(d));
 		
 		d->Main->AddView(d->Tabs = new LTabView(IDC_TABS));
 		d->Tabs->GetCss(true)->Height(LCss::Len("250px"));
 		
 		LTabPage *p = d->Tabs->Append("Variables");
 		p->Append(d->VarsTbl = new LTableLayout(IDC_VARS_TBL));		
 		
 		int x = 0, y = 0;
 		auto *c = d->VarsTbl->GetCell(x++, y);
 		c->Add(new LTextLabel(IDC_STATIC, 0, 0, -1, -1, "Globals:"));
 		c = d->VarsTbl->GetCell(x++, y);
 		c->Add(new LTextLabel(IDC_STATIC, 0, 0, -1, -1, "Locals:"));
 		c = d->VarsTbl->GetCell(x++, y);
 		c->Add(new LTextLabel(IDC_STATIC, 0, 0, -1, -1, "Registers:"));
 
 		x = 0; y++;
 		c = d->VarsTbl->GetCell(x++, y);
 		c->Add(d->Globals = new LList(IDC_GLOBALS, 0, 0, 100, 100));
 		d->Globals->AddColumn("Name",100);
 		d->Globals->AddColumn("Value",400);
 		c = d->VarsTbl->GetCell(x++, y);
 		c->Add(d->Locals = new LList(IDC_LOCALS, 0, 0, 100, 100));
 		d->Locals->AddColumn("Name",100);
 		d->Locals->AddColumn("Value",400);
 		c = d->VarsTbl->GetCell(x++, y);
 		c->Add(d->Registers = new LList(IDC_REGISTERS, 0, 0, 100, 100));
 		d->Registers->AddColumn("Name",100);
 		d->Registers->AddColumn("Value",400);
 
 		p = d->Tabs->Append("Stack");
 		p->Append(d->Stack = new LList(IDC_STACK, 0, 0, 100, 100));
 		d->Stack->SetPourLargest(true);
 		d->Stack->AddColumn("Address", 100);
 		d->Stack->AddColumn("Function", 300);
 		
 		p = d->Tabs->Append("Log");
 		p->Append(d->Log = new LTextLog(IDC_LOG));
 		
 		AttachChildren();
 		Visible(true);
 		
 		{
 			char p[MAX_PATH_LEN];
 			LMakePath(p, sizeof(p), LGetExePath(), "../Scripts");
 			LDirectory dir;
 			LListItem *Match = NULL;
 
 			d->SourceLst->MultiSelect(false);
 
 			for (int b = dir.First(p); b; b = dir.Next())
 			{
 				if (!dir.IsDir())
 				{
 					char *n = dir.GetName();
 					if (stristr(n, ".script") &&
 						dir.Path(p, sizeof(p)))
 					{
 						LListItem *it = new LListItem;
 						it->SetText(dir.GetName(), 0);
 						it->SetText(p, 1);
 
 						if (Code && Code->GetFileName())
 						{
 							if (_stricmp(p, Code->GetFileName()) == 0)
 								Match = it;
 						}
 
 						d->SourceLst->Insert(it);
 					}
 				}
 			}
 
 			if (!Match && Code)
 			{
 				LListItem *it = new LListItem;
 				if (it)
 				{
 					it->SetText(LGetLeaf(Code->GetFileName()), 0);
 					it->SetText(Code->GetFileName(), 1);
 					d->SourceLst->Insert(it);
 					it->Select(true);
 				}
 			}
 		}
 	}
 
 	d->AcceptNotify = true;
 }
 
 LVmDebuggerWnd::~LVmDebuggerWnd()
 {
 	LAssert(d->RunLoop == false);
 }
 
 bool LVmDebuggerWnd::OnRequestClose(bool OsShuttingDown)
 {
 	if (!d->RunLoop)
 		return LWindow::OnRequestClose(OsShuttingDown);
 
 	d->RunLoop = false;
 	return false; // Wait for Run() to exit in it's own time.
 }
 
 void LVmDebuggerWnd::Run()
 {
 	// This is to allow objects on the application's stack to 
 	// still be valid while the debugger UI is shown.
 	d->RunLoop = true;
 	while (d->RunLoop && Visible())
 	{
 		LYield();
 		LSleep(20);
 	}
 	Quit();
 }
 
 LStream *LVmDebuggerWnd::GetLog()
 {
 	return d->Log;
 }
 
 void LVmDebuggerWnd::OwnVm(bool Own)
 {
 	d->OwnVm = Own;
 }
 
 void LVmDebuggerWnd::OwnCompiledCode(LAutoPtr<LCompiledCode> Cc)
 {
 	d->Obj = Cc;
 }
 
 LCompiledCode *LVmDebuggerWnd::GetCode()
 {
 	return d->Obj;
 }
 
 void LVmDebuggerWnd::SetSource(const char *Mixed)
 {
 	#if 1
 	LStringPipe Glob(256);
 	LStringPipe Tmp(256);
 	
 	d->Blocks.Length(0);
 	CodeBlock *Cur = &d->Blocks.New();
 
 	// Parse the mixed source
 	auto t = LString(Mixed).SplitDelimit("\n", -1, false);
 	bool InGlobals = true;
 	int InAsm = -1;
 	
 	for (unsigned i=0; i<t.Length(); i++)
 	{
 		char *l = t[i];
 		if (!l)
 			continue;
 		if (InGlobals)
 		{
 			if (*l == 'G')
 			{
 				Glob.Print("%s\n", l);
 				continue;
 			}
 
 			InGlobals = false;
 		}
 
 		int IsAsm = IsDigit(*l);
 		if (InAsm < 0)
 			InAsm = IsAsm;
 		if (IsAsm ^ InAsm)
 		{
 			if (InAsm)
 			{
 				// Asm -> Code
 				Cur->Asm.Reset(Tmp.NewStr());
 				Cur = &d->Blocks.New();
 			}
 			else
 			{
 				// Code -> Asm
 				Tmp.Empty();
 			}
 			InAsm = IsAsm;
 		}
 		
 		Tmp.Print("%s\n", l);
 		if (InAsm)
 		{
 			Cur->AsmLines++;
 			Cur->AsmAddr.Add(htoi(l));
 		}
 		else if (!Cur->SrcLine)
 		{
 			while (*l == ' ') l++;
 			if (IsDigit(*l))
 				Cur->SrcLine = atoi(l);
 		}
 	}
 	if (InAsm)
 		Cur->Asm.Reset(Tmp.NewStr());
 
 	Tmp.Empty();
 	
 	LStringPipe Txt;
 	auto Src = d->Script.SplitDelimit("\n", -1, false);
 	unsigned SrcLine = 1;
 	unsigned ViewLine = 1;
 	for (unsigned i=0; i<d->Blocks.Length(); i++)
 	{
 		CodeBlock &b = d->Blocks[i];
 		if (b.SrcLine > 0)
 		{
 			while (SrcLine <= b.SrcLine)
 			{
 				char *s = Src[SrcLine-1];
 				Tmp.Print("%i: %s\n", SrcLine, s ? s : "");
 				b.SrcLines++;
 				SrcLine++;
 			}
 			
 			b.Source.Reset(Tmp.NewStr());
 		}
 
 		if (b.Source && b.Asm)
 		{
 			b.ViewLine = ViewLine;
 			ViewLine += b.SrcLines + b.AsmLines;
 			Txt.Print("%s%s", b.Source.Get(), b.Asm.Get());
 		}
 		else if (b.Source)
 		{
 			b.ViewLine = ViewLine;
 			ViewLine += b.SrcLines;
 			Txt.Print("%s", b.Source.Get());
 		}
 		else if (b.Asm)
 		{
 			b.ViewLine = ViewLine;
 			ViewLine += b.AsmLines;
 			Txt.Print("%s", b.Asm.Get());
 		}
 	}
 	while (SrcLine <= Src.Length())
 	{
 		Txt.Print("%i: %s\n", SrcLine, Src[SrcLine-1].Get());
 		SrcLine++;
 	}
 	
 	for (unsigned i=0; i<d->Blocks.Length(); i++)
 	{
 		CodeBlock &b = d->Blocks[i];
 		int Base = b.ViewLine + b.SrcLines;
 		for (int n = Base; n<Base+b.AsmLines; n++)
 			d->LineIsAsm[n-1] = true;
 	}
 	
 	LAutoString a(Txt.NewStr());
 	d->Text->Name(a);
 	#else
 	d->Text->Name(Mixed);
 	#endif
 }
 
 void LVmDebuggerWnd::UpdateVariables(LList *Lst, LVariant *Arr, ssize_t Len, char Prefix)
 {
 	if (!d->Vm || !Lst || !Arr)
 		return;
 
 	List<LListItem> all;
 	Lst->GetAll(all);
 	
 	LListItem *it;
 	for (ssize_t i=0; i<Len; i++)
 	{
 		LVariant *v = Arr + i;
 		LStringPipe p(64);
 		d->Vm->d->DumpVariant(&p, *v);
 		LAutoString a(p.NewStr());
 		char nm[32];
 		sprintf_s(nm, sizeof(nm), "%c" LPrintfSSizeT, Prefix, i);
 		
 		if (i >= (ssize_t)all.Length())
 		{
 			it = new LListItem;
 			all.Insert(it);
 			Lst->Insert(it);
 		}
 		it = i < (ssize_t)all.Length() ? all[i] : NULL;
 		if (it)
 		{
 			it->SetText(nm, 0);
 			it->SetText(a, 1);
 		}
 	}
 	
 	Lst->ResizeColumnsToContent();
 }
 
 void LVmDebuggerWnd::OnAddress(size_t Addr)
 {
 	d->CurrentAddr = Addr;
 	if (d->Text)
 	{
 		ssize_t Sz = d->Text->Length();
 		d->Text->PourText(0, Sz);
 		d->Text->ScrollToCurLine();
 		d->Text->Invalidate();
 	}
 
 	OnNotify(d->Tabs, LNotifyValueChanged);
 }
 
 void LVmDebuggerWnd::OnError(const char *Msg)
 {
 	if (Msg)
 		d->Text->SetError(Msg);
 }
 
 void LVmDebuggerWnd::OnRun(bool Running)
 {
 }
 
 void LVmDebuggerWnd::LoadFile(const char *File)
 {
 	if (!d->Vm || !d->Callback)
 	{
 		LAssert(0);
 		return;
 	}
 
 	LFile f;
 	if (f.Open(File, O_READ))
 		d->Script = f.Read();
 	else
 		d->Script.Empty();
 	d->Obj.Reset();
 	if (d->Callback->CompileScript(d->Obj, File, d->Script))
 	{
 		LCompiledCode *Code = dynamic_cast<LCompiledCode*>(d->Obj.Get());
 		if (Code)
 		{
 			d->Return.Empty();
 			d->Vm->d->Frames.Length(0);
 
 			LScriptArguments Args(d->Vm, &d->Return);
 			d->Vm->d->Setup(Code, 0, d->Log, NULL, &Args);
 		}
 	}
 }
 
 int LVmDebuggerWnd::OnCommand(int Cmd, int Event, OsView Wnd)
 {
 	if (d->Vm &&
 		d->Vm->d->Vm == NULL)
 	{
 		// This happens when the original VM decides to go away and leave
 		// our copy of the VM as the only one left. This means we have to
 		// update the pointer in the VM's private data to point to us.
 		d->Vm->d->Vm = d->Vm;
 	}
 	
 	switch (Cmd)
 	{
 		case IDC_RUN:
 		{
 			if (d->Vm)
 				d->Vm->Continue();
 			break;
 		}
 		case IDC_PAUSE:
 		{
 			if (d->Vm)
 				d->Vm->BreakExecution();
 			break;
 		}
 		case IDC_STOP:
 		{
 			d->Vm.Reset();
 			if (d->RunLoop)
 				d->RunLoop = false;
 			else
 				Quit();
 			break;
 		}
 		case IDC_RESTART:
 		{
 			if (d->Vm && d->Obj)
 			{
 				LCompiledCode *Code = dynamic_cast<LCompiledCode*>(d->Obj.Get());
 				if (Code)
 					d->Vm->Execute(Code, 0, d->Log, false);
 			}
 			break;
 		}
 		case IDC_GOTO:
 		{
 			break;
 		}
 		case IDC_STEP_INSTR:
 		{
 			if (d->Vm)
 				d->Vm->StepInstruction();
 			break;
 		}
 		case IDC_STEP_LINE:
 		{
 			if (d->Vm)
 				d->Vm->StepLine();
 			break;
 		}
 		case IDC_STEP_OUT:
 		{
 			if (d->Vm)
 				d->Vm->StepOut();
 			break;
 		}
 		case IDC_BREAK_POINT:
 		{
 			int Addr = d->Text->GetAddr();
 			if (Addr >= 0)
 				d->Vm->BreakPoint(Addr, d->Text->Breakpoint(Addr));
 			break;
 		}
 		case IDC_BREAK_CPP:
 		{
 			if (!d->Vm)
 			{
 				LAssert(0);
 				break;
 			}
 
 			LMenuItem *i = Menu->FindItem(IDC_BREAK_CPP);
 			if (!i)
 			{
 				LAssert(0);
 				break;
 			}
 			
 			bool b = !i->Checked();
 			i->Checked(b);
 			d->Vm->SetBreakCpp(b);
 			break;
 		}
 	}
 
 	return LWindow::OnCommand(Cmd, Event, Wnd);
 }
 
 int LVmDebuggerWnd::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	if (!d->AcceptNotify)
 		return 0;
 
 	switch (Ctrl->GetId())
 	{
 		case IDC_TABS:
 		{
 			switch (Ctrl->Value())
 			{
 				case 0: // Variables
 				{
 					if (d->Obj)
 					{
 						UpdateVariables(d->Globals,
 										d->Vm->d->Scope[SCOPE_GLOBAL],
 										d->Obj->Globals.Length(),
 										'G');
 					}
 					if (d->Vm->d->Frames.Length())
 					{
 						LVirtualMachinePriv::StackFrame &frm = d->Vm->d->Frames.Last();
 						UpdateVariables(d->Locals,
 									d->Vm->d->Scope[SCOPE_LOCAL],
 									frm.CurrentFrameSize,
 									'L');
 					}
 					else d->Locals->Empty();
 					
 					UpdateVariables(d->Registers,
 									d->Vm->d->Scope[SCOPE_REGISTER],
 									MAX_REGISTER,
 									'R');
 					break;
 				}
 				case 1: // Call stack
 				{
 					d->Stack->Empty();
 					
 					LArray<LVirtualMachinePriv::StackFrame> &Frames = d->Vm->d->Frames;
 					for (int i=(int)Frames.Length()-1; i>=0; i--)
 					{
 						LVirtualMachinePriv::StackFrame &Sf = Frames[i];
 						LListItem *li = new LListItem;
 						LString s;
 						s.Printf("%p/%i", Sf.ReturnIp, Sf.ReturnIp);
 						li->SetText(s, 0);
 						
 						const char *Src = d->Vm->d->Code->AddrToSourceRef(Sf.ReturnIp);
 						li->SetText(Src, 1);
 						
 						d->Stack->Insert(li);
 					}
 					break;
 				}					
 				case 2: // Log
 				{
 					break;
 				}
 			}
 			break;
 		}
 		case IDC_SOURCE_LST:
 		{
 			if (n.Type == LNotifyItemSelect)
 			{
 				LListItem *it = d->SourceLst->GetSelected();
 				if (!it)
 					break;
 
 				const char *full = it->GetText(1);
 				if (!LFileExists(full))
 					break;
 
 				LoadFile(full);
 			}
 			break;
 		}
 	}
 	
 	return LWindow::OnNotify(Ctrl, n);
 }
 
 LMessage::Param LVmDebuggerWnd::OnEvent(LMessage *Msg)
 {
 	return LWindow::OnEvent(Msg);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 bool LScriptArguments::Throw(const char *File, int Line, const char *Msg, ...)
 {
 	if (!Vm || !Vm->d)
 		return false;
 
 	va_list Arg;
 	va_start(Arg, Msg);
 
 	LString s;
 	s.Printf(Arg, Msg);
 
 	va_end(Arg);
 	
 	Vm->d->OnException(File, Line, -1, s);
 	return true;
 }
diff --git a/src/common/Coding/ScriptingPriv.h b/src/common/Coding/ScriptingPriv.h
--- a/src/common/Coding/ScriptingPriv.h
+++ b/src/common/Coding/ScriptingPriv.h
@@ -1,562 +1,591 @@
 #ifndef _GSCRIPTING_PRIV_H_
 #define _GSCRIPTING_PRIV_H_
 
 #include <stdio.h>
 #include "lgi/common/Scripting.h"
 #include "lgi/common/RefCount.h"
 
 // Instructions
 #define _i(name, opcode, desc) \
 	name = opcode,
 
 #define AllInstructions \
 	_i(INop,				0,					"Nop") \
 	_i(IAssign,				OpAssign,			"OpAssign") \
 	_i(IPlus,				OpPlus,				"OpPlus") \
 	_i(IUnaryPlus,			OpUnaryPlus,		"OpUnaryPlus") \
 	_i(IMinus,				OpMinus,			"OpMinus") \
 	_i(IUnaryMinus,			OpUnaryMinus,		"OpUnaryMinus") \
 	_i(IMul,				OpMul,				"OpMul") \
 	_i(IDiv,				OpDiv,				"OpDiv") \
 	_i(IMod,				OpMod,				"OpMod") \
 	_i(ILessThan,			OpLessThan,			"OpLessThan") \
 	_i(ILessThanEqual,		OpLessThanEqual,	"OpLessThanEqual") \
 	_i(IGreaterThan,		OpGreaterThan,		"OpGreaterThan") \
 	_i(IGreaterThanEqual,	OpGreaterThanEqual,	"OpGreaterThanEqual") \
 	_i(IEquals,				OpEquals,			"OpEquals") \
 	_i(INotEquals,			OpNotEquals,		"OpNotEquals") \
 	_i(IPlusEquals,			OpPlusEquals,		"OpPlusEquals") \
 	_i(IMinusEquals,		OpMinusEquals,		"OpMinusEquals") \
 	_i(IMulEquals,			OpMulEquals,		"OpMulEquals") \
 	_i(IDivEquals,			OpDivEquals,		"OpDivEquals") \
 	_i(IPostInc,			OpPostInc,			"OpPostInc") \
 	_i(IPostDec,			OpPostDec,			"OpPostDec") \
 	_i(IPreInc,				OpPreInc,			"OpPreInc") \
 	_i(IPreDec,				OpPreDec,			"OpPreDec") \
 	_i(IAnd,				OpAnd,				"OpAnd") \
 	_i(IOr,					OpOr,				"OpOr") \
 	_i(INot,				OpNot,				"OpNot") \
 	\
 	/** Calls a another part of the script */ \
 	_i(ICallScript,			64,					"CallScript") \
 	/** Calls a method defined by the script context */ \
 	_i(ICallMethod,			65,					"CallMethod") \
 	_i(IDomGet,				67,					"DomGet") \
 	_i(IDomSet,				68,					"DomSet") \
 	_i(IPush,				69,					"Push") \
 	_i(IPop,				70,					"Pop") \
 	_i(IJump,				71,					"Jump") \
 	_i(IJumpZero,			72,					"JumpZ") \
 	_i(IArrayGet,			73,					"ArrayGet") \
 	_i(IArraySet,			74,					"ArraySet") \
 	_i(IRet,				75,					"Return") \
 	_i(IDomCall,			76,					"DomCall") \
 	/* Stop in the VM at instruction */ \
 	_i(IBreakPoint,			77,					"BreakPoint") \
 	_i(ICast,				78,					"Cast") \
 	/* Open the debugger */ \
 	_i(IDebug,				79,					"Debug") \
 
 enum GInstruction {
 	AllInstructions
 };
 
 enum OperatorType
 {
 	OpPrefix,
 	OpInfix,
 	OpPostfix,
 };
 
 extern char16 sChar[];
 extern char16 sInt[];
 extern char16 sUInt[];
 extern char16 sInt32[];
 extern char16 sUInt32[];
 extern char16 sInt64[];
 extern char16 sHWND[];
 extern char16 sDWORD[];
 extern char16 sLPTSTR[];
 extern char16 sLPCTSTR[];
 extern char16 sElse[];
 extern char16 sIf[];
 extern char16 sFunction[];
 extern char16 sExtern[];
 extern char16 sFor[];
 extern char16 sWhile[];
 extern char16 sReturn[];
 extern char16 sInclude[];
 extern char16 sDefine[];
 extern char16 sStruct[];
 extern char16 sTrue[];
 extern char16 sFalse[];
 extern char16 sNull[];
 extern char16 sOutParam[];
 
 extern char16 sHash[];
 extern char16 sPeriod[];
 extern char16 sComma[];
 extern char16 sSemiColon[];
 extern char16 sStartRdBracket[];
 extern char16 sEndRdBracket[];
 extern char16 sStartSqBracket[];
 extern char16 sEndSqBracket[];
 extern char16 sStartCurlyBracket[];
 extern char16 sEndCurlyBracket[];
 
 extern const char *InstToString(GInstruction i);
 
 /*
 	Variable Reference:
 		Can either be a:
 			- stack variable
 			- global variable
 			- register (0 .. MAX_REGISTER - 1)
 
 		Thus a variable reference encodes 2 pieces of information, first the scope of
 		the reference (as above) and secondly the index into that scope. Scopes are
 		stored as arrays of variables.
 
 		The scope is one byte, the index is 3 bytes following, totally 4 bytes per ref.
 */
 
 #define MAX_REGISTER		16
 
 /// 32bit variable reference, used to track where a variable is during compilation.
 struct LVarRef
 {
 	/// \sa #SCOPE_REGISTER, #SCOPE_LOCAL or #SCOPE_GLOBAL
 	unsigned Scope : 8;
 	/// Index into scope
 	int Index : 24;
 
 	bool Valid()
 	{
 		return Index >= 0;
 	}
 
 	void Empty()
 	{
 		Scope = 0;
 		Index = -1;
 	}
 
 	bool IsReg()
 	{
 		return Scope == SCOPE_REGISTER && Index >= 0 && Index < MAX_REGISTER;
 	}
 
 	void SetReg(int i)
 	{
 		Scope = SCOPE_REGISTER;
 		Index = i;
 	}
 
 	bool operator ==(LVarRef &r)
 	{
 		return r.Scope == Scope && r.Index == Index;
 	}
 
 	bool operator !=(LVarRef &r)
 	{
 		return r.Scope != Scope || r.Index != Index;
 	}
 
 	const char *GetStr()
 	{
 		if (Index < 0)
 		{
 			LAssert(!"Invalid reference");
 			return "NoRef";
 		}
 
 		#define GETSTR_BUF_SIZE 16
 		static char Buf[8][GETSTR_BUF_SIZE];
 		static int Cur = 0;
 		static char Names[] = {'R', 'L', 'G'};
 		char *b = Buf[Cur++];
 		if (Cur >= 8) Cur = 0;
 
 		LAssert(Scope <= SCOPE_GLOBAL);
 		sprintf_s(b, GETSTR_BUF_SIZE, "%c%i", Names[Scope], Index);
 		return b;		
 	}
 };
 
 union LScriptPtr
 {
 	uint8_t *u8;
 	uint16 *u16;
 	uint32_t *u32;
 	int8 *i8;
 	int16 *i16;
 	int32 *i32;
 	double *dbl;
 	float *flt;
 	LVarRef *r;
 	LFunc **fn;
 };
 
 class SystemFunctions;
 
 class LCompileTools
 {
 protected:
 	OperatorType OpType(LOperator o)
 	{
 		switch (o)
 		{
 			case OpUnaryPlus:
 			case OpUnaryMinus:
 			case OpPreInc:
 			case OpPreDec:
 			case OpNot:
 				return OpPrefix;
 
 			case OpPostInc:
 			case OpPostDec:
 				return OpPostfix;
 			
 			default:
 				return OpInfix;
 		}
 	}
 
 	int GetPrecedence(LOperator o)
 	{
 		// Taken from:
 		// http://www.cppreference.com/operator_precedence.html
 		switch (o)
 		{
 			case OpAssign:
 			case OpMinusEquals:
 			case OpPlusEquals:
 			case OpMulEquals:
 			case OpDivEquals:
 				return 16;
 
 			case OpAnd:
 				return 13;
 
 			case OpOr:
 				return 14;
 
 			case OpEquals:
 			case OpNotEquals:
 				return 9;
 
 			case OpLessThan:
 			case OpLessThanEqual:
 			case OpGreaterThan:
 			case OpGreaterThanEqual:
 				return 8;
 
 			case OpPlus:
 			case OpMinus:
 				return 6;
 
 			case OpMul:
 			case OpDiv:
 			case OpMod:
 				return 5;
 
 			case OpUnaryPlus:
 			case OpUnaryMinus:
 			case OpPreInc:
 			case OpPreDec:
 			case OpNot:
 				return 3;
 			
 			case OpPostInc:
 			case OpPostDec:
 				return 2;
 			
 			case OpNull:
 				return 0;
 			
 			default:
 				LAssert(!"Really?");
 				break;
 		}
 
 		return -1;
 	}
 
 	LOperator IsOp(char16 *s, int PrevIsOp)
 	{
 		if (!s) return OpNull;
 
 		if (s[0] != 0 && !s[1])
 		{
 			// One character operator
 			switch (*s)
 			{
 				case '=': return OpAssign;
 				case '*': return OpMul;
 				case '/': return OpDiv;
 				case '<': return OpLessThan;
 				case '>': return OpGreaterThan;
 				case '%': return OpMod;
 				case '!': return OpNot;
 				case '+':
 				{
 					if (PrevIsOp == 0)
 						return OpPlus;
 					
 					return OpUnaryPlus;
 				}
 				case '-':
 				{
 					if (PrevIsOp == 0)
 						return OpMinus;
 
 					return OpUnaryMinus;
 				}
 			}
 		}
 		else if (s[0] != 0 && s[1] == '=' && !s[2])
 		{
 			// 2 chars, "something" equals operator
 			switch (*s)
 			{
 				case '!': return OpNotEquals;
 				case '=': return OpEquals;
 				case '<': return OpLessThanEqual;
 				case '>': return OpGreaterThanEqual;
 
 				case '+': return OpPlusEquals;
 				case '-': return OpMinusEquals;
 				case '*': return OpMulEquals;
 				case '/': return OpDivEquals;
 			}
 		}
 		else if (s[0] == '+' && s[1] == '+' && !s[2])
 		{
 			if (PrevIsOp == 0)
 				return OpPostInc;
 
 			return OpPreInc;
 		}
 		else if (s[0] == '-' && s[1] == '-' && !s[2])
 		{
 			if (PrevIsOp == 0)
 				return OpPostDec;
 
 			return OpPreDec;
 		}
 		else if (s[0] == '&' && s[1] == '&' && !s[2])
 		{
 			return OpAnd;
 		}
 		else if (s[0] == '|' && s[1] == '|' && !s[2])
 		{
 			return OpOr;
 		}
 
 		return OpNull;
 	}
 
 };
 
 /// This class compiles the source down to byte code
 class LCompiler : public LScriptUtils
 {
 	class LCompilerPriv *d;
 
 public:
 	/// Constructor
 	LCompiler();
 	~LCompiler();
 
 	/// Compile the source into byte code.
 	bool Compile
 	(
 		LAutoPtr<LCompiledCode> &Code,
 		LScriptContext *SysContext,
 		LScriptContext *UserContext,
 		const char *FileName,
 		const char *Script,
 		LDom *Args
 	);
 };
 
 /// This class is the VM for the byte language
 class LVirtualMachine : public LScriptUtils
 {
 	friend class LVmDebuggerWnd;
 	friend class LScriptArguments;
 	
 	class LVirtualMachinePriv *d;
 
 public:
 	static bool BreakOnWarning;
 
+	class Context
+	{
+		friend class LVirtualMachine;
+		LCompiledCode *Code = NULL;
+		LVmCallback *Callback = NULL;
+		ssize_t Addr = -1;
+
+	public:
+		operator bool()
+		{
+			return Code != NULL && Callback != NULL;
+		}
+
+		bool Call(LString CallbackName, LScriptArguments &Args) const
+		{
+			if (!Callback)
+				return false;
+
+			LVirtualMachine Vm(*this);
+			auto Prev = Args.GetVm();
+			Args.SetVm(&Vm);
+			auto result = Callback->CallCallback(Vm, CallbackName, Args);
+			Args.SetVm(Prev);
+			return result;
+		}
+	};
+
 	LVirtualMachine(LVmCallback *callback = NULL);
+	LVirtualMachine(Context ctx);
 	LVirtualMachine(LVirtualMachine *vm);
 	~LVirtualMachine();
 
 	/// Executes the whole script starting at the top
 	LExecutionStatus Execute
 	(
 		/// [In] The code to execute
 		LCompiledCode *Code,
 		/// [In] The instruction to start at... [defaults to the start of script)
 		uint32_t StartOffset = 0,
 		/// [Optional] Log file for execution
 		LStream *Log = NULL,
 		/// Start the script execution straight away?
 		bool StartImmediately = true,
 		/// Optional return value
 		LVariant *Return = NULL
 	);
 
 	/// Execute just one method and return
 	LExecutionStatus ExecuteFunction
 	(
 		/// [In] The code to execute
 		LCompiledCode *Code,
 		/// [In] The function to execute
 		LFunctionInfo *Func,
 		/// [In/Out] The function's arguments
 		LScriptArguments &Args,
 		/// [Optional] Log file for execution
 		LStream *Log = NULL,
 		/// [Optional] Copy arguments back to this array
 		LScriptArguments *ArgsOut = NULL
 	);
 
 	// Debugging commands
 	LVmDebugger *OpenDebugger(LCompiledCode *Code = NULL, const char *Assembly = NULL);
 	bool StepInstruction();
 	bool StepLine();
 	bool StepOut();
 	bool BreakExecution();
 	bool Continue();
 	bool BreakPoint(const char *File, int Line, bool Add);
 	bool BreakPoint(int Addr, bool Add);
 	void SetBreakCpp(bool Brk);
 	void SetDebuggerEnabled(bool b);
 	
-	// Properties
+	// Other methods
 	void SetTempPath(const char *Path);
 	LVmCallback *GetCallback();
+	Context SaveContext();
 };
 
 /// Scripting engine system functions
 class SystemFunctions : public LScriptContext
 {
 	LScriptEngine *Engine;
 	LStream *Log;
 	#ifdef WINNATIVE
 	HANDLE Brk;
 	#endif
 
 	LView *CastLView(LVariant &v);
 
 public:
 	SystemFunctions();
 	~SystemFunctions();
 
 	LStream *GetLog();
 	bool SetLog(LStream *log);
 	void SetEngine(LScriptEngine *Eng);	
 	
 	LString GetIncludeFile(const char *FileName) override
 	{
 		return NULL;
 	}
 	
 	LHostFunc *GetCommands();
 
 	// Debug
 		bool Assert(LScriptArguments &Args);
 		bool Throw(LScriptArguments &Args);
 		bool DebuggerEnabled(LScriptArguments &Args);
 
 	// String
 		bool LoadString(LScriptArguments &Args);
 		/// Formats a string
 		bool Sprintf(LScriptArguments &Args);
 		/// Formats a file size
 		bool FormatSize(LScriptArguments &Args);
 		/// Prints items to the console
 		bool Print(LScriptArguments &Args);
 		/// Converts args to string
 		bool ToString(LScriptArguments &Args);
 
 	// Object creation/deletion
 		bool New(LScriptArguments &Args);
 		bool Delete(LScriptArguments &Args);
 		bool Len(LScriptArguments &Args);
 
 	// File
 		/// Reads a text file into a variable
 		bool ReadTextFile(LScriptArguments &Args);
 		/// Writes a text file from a variable
 		bool WriteTextFile(LScriptArguments &Args);
 		/// \brief Opens a file open dialog to select files.
 		///
 		/// Args: LView *Parent, char *Patterns, 
 		///		  char *InitFolder, bool Multiselect
 		bool SelectFiles(LScriptArguments &Args);
 		/// Open a folder select dialog
 		///
 		/// Args: LView *Parent, char *InitFolder
 		bool SelectFolder(LScriptArguments &Args);
 		/// Lists file in folder
 		///
 		/// Args; char *Path, [optional] char *Pattern
 		/// Returns: List of DOM objects with the following fields:
 		///		Name - File/dir name
 		///		Size - Size of entry
 		///		Folder - bool, true if folder
 		///		Modified - LDateTime, modified time
 		bool ListFiles(LScriptArguments &Args);
 		/// Deletes a file
 		bool DeleteFile(LScriptArguments &Args);
 		/// Gets the current script path.
 		bool CurrentScript(LScriptArguments &Args);
 		/// Finds out if a path exists.
 		bool PathExists(LScriptArguments &Args);
 		/// Joins path segments together.
 		bool PathJoin(LScriptArguments &Args);
 		/// Returns the current OS path separator.
 		bool PathSep(LScriptArguments &Args);
 
 	// Time
 		/// Sleeps a number of milliseconds
 		bool Sleep(LScriptArguments &Args);
 		/// Get the current tick count
 		bool ClockTick(LScriptArguments &Args);
 		/// Get the date time
 		bool Now(LScriptArguments &Args);
 
 	// Bitmaps
 		/// Creates a memory context
 		bool CreateSurface(LScriptArguments &Args);
 		bool ColourSpaceToString(LScriptArguments &Args);
 		bool StringToColourSpace(LScriptArguments &Args);
 
 	// User interface
 		/// Standard alert message box
 		bool MessageDlg(LScriptArguments &Args);
 		/// Gets an input string from the user
 		/// String GetInputDlg(Window Parent, String InitialValue, String Question, String Title, bool IsPassword, String Callback.
 		bool GetInputDlg(LScriptArguments &Args);
 		/// Gets a view by id
 		bool GetViewById(LScriptArguments &Args);
 
 	// System
 		/// Executes a command, waits for it to finish, then returns it's output:
 		/// String Execute(String Application, String CmdLine);
 		bool Execute(LScriptArguments &Args);
 		/// Executes a command and doesn't wait for it to return:
 		/// Bool System(String Application, String CmdLine);
 		bool System(LScriptArguments &Args);
 		/// Gets the operating system name.
 		bool OsName(LScriptArguments &Args);
 		/// Gets the operating system version.
 		bool OsVersion(LScriptArguments &Args);
 };
 
 #endif