__index

src/MoonSharp.Debugger/ValueBrowser.cs

@@ -90,11 +90,6 @@ namespace MoonSharp.Debugger
 					AddProperty("Count", V.Tuple.Length);
 					BuildTupleTable(V);
 					break;
-				case DataType.Symbol:
-					lblData.Text = "SYMBOL / TABLE-REF";
-					txtString.Text = V.String.ToString();
-					BuildSymbolTable(V);
-					break;
 				case DataType.ClrFunction:
 					txtString.Visible = true;
 					txtString.Text = "Value is a CLR function.";
@@ -131,13 +126,7 @@ namespace MoonSharp.Debugger
 			}
 		}
 
-		private void BuildSymbolTable(DynValue V)
-		{
-			var S = V.Symbol;
-			lvTableData.Add("Type", S.Type);
-			lvTableData.Add("Index", S.Index);
-			lvTableData.Add("Name", S.Name);
-		}
+
 
 		private void BuildFunctionTable(DynValue V)
 		{

src/MoonSharp.Interpreter/CoreLib/LoadMethods.cs

@@ -58,27 +58,27 @@ namespace MoonSharp.Interpreter.CoreLib
 		}
 
 
-//		[MoonSharpMethod] 
-//		public const string require = @"
-//			function(modulename)
-//				if (package == nil) then package = { }; end
-//				if (package.loaded == nil) then package.loaded = { }; end
-//
-//				local m = package.loaded[modulename];
-//
-//				if (m ~= nil) then
-//					return m;
-//				end
-//
-//				local func = __require_clr_impl(modulename);
-//
-//				local res = func();
-//
-//				package.loaded[modulename] = res;
-//
-//				return res;
-//			end
-//		";
+		[MoonSharpMethod]
+		public const string require = @"
+			function(modulename)
+				if (package == nil) then package = { }; end
+				if (package.loaded == nil) then package.loaded = { }; end
+
+				local m = package.loaded[modulename];
+
+				if (m ~= nil) then
+					return m;
+				end
+
+				local func = __require_clr_impl(modulename);
+
+				local res = func();
+
+				package.loaded[modulename] = res;
+
+				return res;
+			end
+		";
 
 
 

src/MoonSharp.Interpreter/CoreLib/MetaTableMethods.cs

@@ -28,7 +28,7 @@ namespace MoonSharp.Interpreter.CoreLib
 				throw new ScriptRuntimeException(null, "cannot change a protected metatable");
 			}
 
-			table.Meta = metatable;
+			table.MetaTable = metatable.Table;
 			return table;
 		}
 
@@ -51,7 +51,10 @@ namespace MoonSharp.Interpreter.CoreLib
 				return curmeta;
 			}
 
-			return obj.Meta ?? DynValue.Nil;
+			if (obj.MetaTable != null)
+				return DynValue.NewTable(obj.MetaTable);
+
+			return DynValue.Nil;
 		}
 
 		// rawget (table, index)

src/MoonSharp.Interpreter/CoreLib/RawTableAccess.cs

@@ -1,33 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using MoonSharp.Interpreter.Execution;
-
-namespace MoonSharp.Interpreter.CoreLib
-{
-	[MoonSharpModule]
-	public class RawTableAccess
-	{
-		[MoonSharpMethod]
-		static DynValue rawget(ScriptExecutionContext executionContext, CallbackArguments args)
-		{
-			DynValue table = args.AsType(0, "rawget", DataType.Table);
-			DynValue index = args[1];
-
-			return table.Table[index];
-		}
-
-		[MoonSharpMethod]
-		static DynValue rawset(ScriptExecutionContext executionContext, CallbackArguments args)
-		{
-			DynValue table = args.AsType(0, "rawset", DataType.Table);
-			DynValue index = args[1];
-			DynValue val = args[2];
-
-			table.Table[index] = val;
-
-			return table;
-		}
-	}
-}

src/MoonSharp.Interpreter/DataTypes/DataType.cs

@@ -19,7 +19,6 @@ namespace MoonSharp.Interpreter
 		UserData,
 		Thread,
 
-		Symbol,
 		ClrFunction,
 		TailCallRequest,
 	}
@@ -50,7 +49,6 @@ namespace MoonSharp.Interpreter
 					return "thread";
 				case DataType.Tuple:
 				case DataType.TailCallRequest:
-				case DataType.Symbol:
 				default:
 					throw new ScriptRuntimeException(null, "Unexpected LuaType {0}", type);
 			}

src/MoonSharp.Interpreter/DataTypes/DynValue.cs

@@ -54,17 +54,13 @@ namespace MoonSharp.Interpreter
 		/// </summary>
 		public string String { get; private set; }
 		/// <summary>
-		/// Gets the symbol reference contained in this value (valid only if the <seealso cref="Type"/> is <seealso cref="DataType.Symbol"/>)
-		/// </summary>
-		public SymbolRef Symbol { get; private set; }
-		/// <summary>
 		/// Gets the CLR callback (valid only if the <seealso cref="Type"/> is <seealso cref="DataType.Callback"/>)
 		/// </summary>
 		public CallbackFunction Callback { get; set; }
 		/// <summary>
 		/// Gets the meta-table associated with this instance.
 		/// </summary>
-		public DynValue Meta { get; set; }
+		public Table MetaTable { get; set; }
 		/// <summary>
 		/// Gets or sets the user object, if this value is userdata
 		/// </summary>
@@ -109,18 +105,6 @@ namespace MoonSharp.Interpreter
 			};
 		}
 
-		/// <summary>
-		/// Creates a new writable value initialized to the specified symbol reference.
-		/// </summary>
-		public static DynValue NewReference(SymbolRef symbol)
-		{
-			return new DynValue()
-			{
-				Symbol = symbol,
-				Type = DataType.Symbol,
-			};
-		}
-
 		/// <summary>
 		/// Creates a new writable value initialized to the specified string.
 		/// </summary>
@@ -204,7 +188,7 @@ namespace MoonSharp.Interpreter
 		{
 			return new DynValue()
 			{
-				Meta = tailFn,
+				UserObject = tailFn,
 				Tuple = args,
 				Type = DataType.TailCallRequest,
 			};
@@ -274,13 +258,13 @@ namespace MoonSharp.Interpreter
 		/// </summary>
 		/// <param name="obj">The CLR object.</param>
 		/// <param name="metatable">Optional - the metatable.</param>
-		public static DynValue NewObject(object obj, DynValue metatable = null)
+		public static DynValue NewObject(object obj, Table metatable = null)
 		{
 			return new DynValue()
 			{
 				UserObject = obj,
 				Type = DataType.UserData,
-				Meta = metatable
+				MetaTable = metatable
 			};
 		}
 
@@ -307,9 +291,6 @@ namespace MoonSharp.Interpreter
 		/// <exception cref="System.ArgumentException">Can't clone Symbol values</exception>
 		public DynValue Clone()
 		{
-			if (this.Type == DataType.Symbol)
-				throw new ArgumentException("Can't clone Symbol values");
-
 			DynValue v = new DynValue();
 			v.Boolean = this.Boolean;
 			v.Callback = this.Callback;
@@ -320,7 +301,7 @@ namespace MoonSharp.Interpreter
 			v.Table = this.Table;
 			v.Tuple = this.Tuple;
 			v.Type = this.Type;
-			v.Meta = this.Meta;
+			v.MetaTable = this.MetaTable;
 			v.m_HashCode = this.m_HashCode;
 			return v;
 		}
@@ -331,9 +312,6 @@ namespace MoonSharp.Interpreter
 		/// <exception cref="System.ArgumentException">Can't clone Symbol values</exception>
 		public DynValue CloneAsWritable()
 		{
-			if (this.Type == DataType.Symbol)
-				throw new ArgumentException("Can't clone Symbol values");
-
 			DynValue v = new DynValue();
 			v.Boolean = this.Boolean;
 			v.Function = this.Function;
@@ -344,7 +322,7 @@ namespace MoonSharp.Interpreter
 			v.Table = this.Table;
 			v.Tuple = this.Tuple;
 			v.Type = this.Type;
-			v.Meta = this.Meta;
+			v.MetaTable = this.MetaTable;
 			v.m_HashCode = this.m_HashCode;
 			return v;
 		}
@@ -385,8 +363,6 @@ namespace MoonSharp.Interpreter
 					return "(Table)";
 				case DataType.Tuple:
 					return string.Join("\t", Tuple.Select(t => t.ToPrintString()).ToArray());
-				case DataType.Symbol:
-					return "(Symbol -- INTERNAL!)";
 				case DataType.TailCallRequest:
 					return "(TailCallRequest -- INTERNAL!)";
 				case DataType.UserData:
@@ -426,8 +402,6 @@ namespace MoonSharp.Interpreter
 					return string.Join(", ", Tuple.Select(t => t.ToString()).ToArray());
 				case DataType.TailCallRequest:
 					return "Tail:(" + string.Join(", ", Tuple.Select(t => t.ToString()).ToArray()) + ")";
-				case DataType.Symbol:
-					return Symbol.ToString();
 				case DataType.UserData:
 					return "(UserData)";
 				case DataType.Thread:
@@ -501,7 +475,7 @@ namespace MoonSharp.Interpreter
 			if (other == null) return false;
 			if (other.Type != this.Type) return false;
 
-			if (other.Meta != this.Meta) return false;
+			if (other.MetaTable != this.MetaTable) return false;
 
 			switch (Type)
 			{
@@ -614,7 +588,7 @@ namespace MoonSharp.Interpreter
 			this.Table = value.Table;
 			this.Tuple = value.Tuple;
 			this.Type = value.Type;
-			this.Meta = value.Meta;
+			this.MetaTable = value.MetaTable;
 			this.m_HashCode = -1;
 		}
 

src/MoonSharp.Interpreter/Execution/VM/ByteCode.cs

@@ -48,6 +48,11 @@ namespace MoonSharp.Interpreter.Execution.VM
 			return Code.Count - 1;
 		}
 
+		public Instruction GetLastInstruction()
+		{
+			return Code[Code.Count - 1];
+		}
+
 		private Instruction AppendInstruction(Instruction c)
 		{
 			Code.Add(c);
@@ -72,7 +77,6 @@ namespace MoonSharp.Interpreter.Execution.VM
 		public void Emit_Call(int argCount)
 		{
 			AppendInstruction(new Instruction() { OpCode = OpCode.Call, NumVal = argCount });
-			AppendInstruction(new Instruction() { OpCode = OpCode.TailChk });
 		}
 
 
@@ -190,15 +194,14 @@ namespace MoonSharp.Interpreter.Execution.VM
 			switch (sym.Type)
 			{
 				case SymbolRefType.Global:
-					AppendInstruction(new Instruction() { OpCode = OpCode.Global });
-					Emit_Literal(DynValue.NewString(sym.i_Name));
-					AppendInstruction(new Instruction() { OpCode = OpCode.LoadIdx });
-					return 3;
+					AppendInstruction(new Instruction() { OpCode = OpCode.PushEnv });
+					AppendInstruction(new Instruction() { OpCode = OpCode.Index, Value = DynValue.NewString(sym.i_Name) });
+					return 2;
 				case SymbolRefType.Local:
-					AppendInstruction(new Instruction() { OpCode = OpCode.LoadLcl, Symbol = sym });
+					AppendInstruction(new Instruction() { OpCode = OpCode.Local, Symbol = sym });
 					return 1;
 				case SymbolRefType.Upvalue:
-					AppendInstruction(new Instruction() { OpCode = OpCode.LoadUpv, Symbol = sym });
+					AppendInstruction(new Instruction() { OpCode = OpCode.Upvalue, Symbol = sym });
 					return 1;
 				default:
 					throw new InternalErrorException("Unexpected symbol type : {0}", sym);
@@ -210,10 +213,9 @@ namespace MoonSharp.Interpreter.Execution.VM
 			switch (sym.Type)
 			{
 				case SymbolRefType.Global:
-					AppendInstruction(new Instruction() { OpCode = OpCode.Global });
-					Emit_Literal(DynValue.NewString(sym.i_Name));
-					AppendInstruction(new Instruction() { OpCode = OpCode.StoreIdx, Symbol = sym, NumVal = stackofs, NumVal2 = tupleidx });
-					return 3;
+					AppendInstruction(new Instruction() { OpCode = OpCode.PushEnv });
+					AppendInstruction(new Instruction() { OpCode = OpCode.IndexSet, Symbol = sym, NumVal = stackofs, NumVal2 = tupleidx, Value = DynValue.NewString(sym.i_Name) });
+					return 2;
 				case SymbolRefType.Local:
 					AppendInstruction(new Instruction() { OpCode = OpCode.StoreLcl, Symbol = sym, NumVal = stackofs, NumVal2 = tupleidx });
 					return 1;
@@ -235,14 +237,14 @@ namespace MoonSharp.Interpreter.Execution.VM
 			return AppendInstruction(new Instruction() { OpCode = OpCode.TblInitI });
 		}
 
-		public Instruction Emit_LoadIdx()
+		public Instruction Emit_Index(DynValue index = null)
 		{
-			return AppendInstruction(new Instruction() { OpCode = OpCode.LoadIdx });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Index, Value = index });
 		}
 
-		public Instruction Emit_StoreIdx(int stackofs, int tupleidx)
+		public Instruction Emit_IndexSet(int stackofs, int tupleidx, DynValue index = null)
 		{
-			return AppendInstruction(new Instruction() { OpCode = OpCode.StoreIdx, NumVal = stackofs, NumVal2 = tupleidx });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.IndexSet, NumVal = stackofs, NumVal2 = tupleidx, Value = index });
 		}
 
 		public Instruction Emit_Copy(int numval)

src/MoonSharp.Interpreter/Execution/VM/Instruction.cs

@@ -39,8 +39,12 @@ namespace MoonSharp.Interpreter.Execution.VM
 				case OpCode.Debug:
 					return string.Format("[[ {0} ]]", Name);
 				case OpCode.Literal:
+				case OpCode.Index:
 					append = string.Format("{0}{1}", GenSpaces(), PurifyFromNewLines(Value));
 					break;
+				case OpCode.IndexSet:
+					append = string.Format("{0}{1} <- {2}:{3}", GenSpaces(), PurifyFromNewLines(Value), NumVal, NumVal2);
+					break;
 				case OpCode.Nop:
 					append = string.Format("{0}#{1}", GenSpaces(), Name);
 					break;
@@ -50,19 +54,21 @@ namespace MoonSharp.Interpreter.Execution.VM
 				case OpCode.ExpTuple:
 				case OpCode.Incr:
 				case OpCode.Pop:
+				case OpCode.Copy:
 					append = string.Format("{0}{1}", GenSpaces(), NumVal);
 					break;
+				case OpCode.Swap:
+					append = string.Format("{0}{1},{2}", GenSpaces(), NumVal, NumVal2);
+					break;
 				case OpCode.BeginFn:
 					append = string.Format("{0}{1}:{2},{3}", GenSpaces(), Name, NumVal, NumVal2);
 					break;
-				case OpCode.TMP_Load:
-				case OpCode.LoadLcl:
-				case OpCode.LoadUpv:
+				case OpCode.Local:
+				case OpCode.Upvalue:
 					append = string.Format("{0}{1}", GenSpaces(), Symbol);
 					break;
 				case OpCode.StoreUpv:
 				case OpCode.StoreLcl:
-				case OpCode.TMP_Store:
 					append = string.Format("{0}{1} <- {2}:{3}", GenSpaces(), Symbol, NumVal, NumVal2);
 					break;
 				case OpCode.JtOrPop:
@@ -93,6 +99,9 @@ namespace MoonSharp.Interpreter.Execution.VM
 
 		private string PurifyFromNewLines(DynValue Value)
 		{
+			if (Value == null)
+				return "";
+
 			return Value.ToString().Replace('\n', ' ').Replace('\r', ' ');
 		}
 

src/MoonSharp.Interpreter/Execution/VM/OpCode.cs

@@ -23,14 +23,11 @@ namespace MoonSharp.Interpreter.Execution.VM
 		TblInitN,	// Initializes a table named entry
 		TblInitI,	// Initializes a table positional entry
 
-		TMP_Load,
-		TMP_Store,
+		PushEnv,	// Pushes the current ENV table on the stack
 
-		Global,
-
-		StoreLcl, LoadLcl,
-		StoreUpv, LoadUpv,
-		StoreIdx, LoadIdx, 
+		StoreLcl, Local,
+		StoreUpv, Upvalue,
+		IndexSet, Index, 
 
 		// Stack-frame ops and calls
 		Enter,		// Enters a new stack frame
@@ -40,7 +37,6 @@ namespace MoonSharp.Interpreter.Execution.VM
 		Args,		// Takes the arguments passed to a function and sets the appropriate symbols in the local scope
 		Call,		// Calls the function specified on the specified element from the top of the v-stack. If the function is a Moon# function, it pushes its numeric value on the v-stack, then pushes the current PC onto the x-stack, enters the function closure and jumps to the function first instruction. If the function is a CLR function, it pops the function value from the v-stack, then invokes the function synchronously and finally pushes the result on the v-stack.
 		Ret,		// Pops the top n values of the v-stack. Then pops an X value from the v-stack. Then pops X values from the v-stack. Afterwards, it pushes the top n values popped in the first step, pops the top of the x-stack and jumps to that location.
-		TailChk,	// Checks if the return value from a Ret or Clr call is a tail call request, in case it repeats the call 
 
 		// Jumps
 		Jump,		// Jumps to the specified PC

src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_IExecutionContext.cs

@@ -24,13 +24,10 @@ namespace MoonSharp.Interpreter.Execution.VM
 
 		internal DynValue GetMetamethod(DynValue value, string metamethod)
 		{
-			if (value.Meta == null || value.Type == DataType.Nil)
+			if (value.MetaTable == null || value.Type == DataType.Nil)
 				return null;
 
-			if (value.Meta.Type != DataType.Table)
-				throw new InternalErrorException("Metatable is not a table!");
-
-			var metameth = value.Meta.Table.RawGet(metamethod);
+			var metameth = value.MetaTable.RawGet(metamethod);
 			
 			if (metameth == null || metameth.Type == DataType.Nil)
 				return null;

src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_InstructionLoop.cs

@@ -78,9 +78,6 @@ namespace MoonSharp.Interpreter.Execution.VM
 					case OpCode.Call:
 						instructionPtr = Internal_ExecCall(i.NumVal, instructionPtr);
 						break;
-					case OpCode.TailChk:
-						instructionPtr = ExecTailChk(i, instructionPtr);
-						break;
 					case OpCode.Scalar:
 						m_ValueStack.Push(m_ValueStack.Pop().ToScalar());
 						break;
@@ -153,18 +150,17 @@ namespace MoonSharp.Interpreter.Execution.VM
 					case OpCode.ExpTuple:
 						ExecExpTuple(i);
 						break;
-					case OpCode.TMP_Load:
-					case OpCode.LoadLcl:
-					case OpCode.LoadUpv:
-						m_ValueStack.Push(this.GetGenericSymbol(i.Symbol));
+					case OpCode.Local:
+						m_ValueStack.Push(m_ExecutionStack.Peek().LocalScope[i.Symbol.i_Index]);
+						break;
+					case OpCode.Upvalue:
+						m_ValueStack.Push(m_ExecutionStack.Peek().ClosureScope[i.Symbol.i_Index]);
 						break;
 					case OpCode.StoreUpv:
+						ExecStoreUpv(i);
+						break;
 					case OpCode.StoreLcl:
-					case OpCode.TMP_Store:
-						{
-							DynValue v = GetStoreValue(i);
-							AssignGenericSymbol(i.Symbol, v);
-						}
+						ExecStoreLcl(i);
 						break;
 					case OpCode.TblInitN:
 						ExecTblInitN(i);
@@ -172,14 +168,14 @@ namespace MoonSharp.Interpreter.Execution.VM
 					case OpCode.TblInitI:
 						ExecTblInitI(i);
 						break;
-					case OpCode.LoadIdx:
-						instructionPtr = ExecLoadIdx(i, instructionPtr);
+					case OpCode.Index:
+						instructionPtr = ExecIndex(i, instructionPtr);
 						break;
-					case OpCode.Global:
+					case OpCode.PushEnv:
 						m_ValueStack.Push(DynValue.NewTable(m_GlobalTable));
 						break;
-					case OpCode.StoreIdx:
-						instructionPtr = ExecStoreIdx(i, instructionPtr);
+					case OpCode.IndexSet:
+						instructionPtr = ExecIndexSet(i, instructionPtr);
 						break;
 					case OpCode.Invalid:
 						throw new NotImplementedException(string.Format("Invalid opcode : {0}", i.Name));
@@ -199,6 +195,40 @@ namespace MoonSharp.Interpreter.Execution.VM
 
 		}
 
+
+		private void AssignLocal(SymbolRef symref, DynValue value)
+		{
+			var stackframe = m_ExecutionStack.Peek();
+
+			DynValue v = stackframe.LocalScope[symref.i_Index];
+			if (v == null)
+				stackframe.LocalScope[symref.i_Index] = v = DynValue.NewNil();
+
+			v.Assign(value);
+		}
+
+		private void ExecStoreLcl(Instruction i)
+		{
+			DynValue value = GetStoreValue(i);
+			SymbolRef symref = i.Symbol;
+
+			AssignLocal(symref, value);
+		}
+
+		private void ExecStoreUpv(Instruction i)
+		{
+			DynValue value = GetStoreValue(i);
+			SymbolRef symref = i.Symbol;
+
+			var stackframe = m_ExecutionStack.Peek();
+
+			DynValue v = stackframe.ClosureScope[symref.i_Index];
+			if (v == null)
+				stackframe.ClosureScope[symref.i_Index] = v = DynValue.NewNil();
+
+			v.Assign(value);
+		}
+
 		private void ExecSwap(Instruction i)
 		{
 			DynValue v1 = m_ValueStack.Peek(i.NumVal);
@@ -353,30 +383,6 @@ namespace MoonSharp.Interpreter.Execution.VM
 		}
 
 
-		private int ExecRet(Instruction i)
-		{
-			if (i.NumVal == 0)
-			{
-				int retpoint = PopToBasePointer();
-				var argscnt = (int)(m_ValueStack.Pop().Number);
-				m_ValueStack.RemoveLast(argscnt + 1);
-				m_ValueStack.Push(DynValue.Nil);
-				return retpoint;
-			}
-			else if (i.NumVal == 1)
-			{
-				var retval = m_ValueStack.Pop();
-				int retpoint = PopToBasePointer();
-				var argscnt = (int)(m_ValueStack.Pop().Number);
-				m_ValueStack.RemoveLast(argscnt + 1);
-				m_ValueStack.Push(retval);
-				return retpoint;
-			}
-			else
-			{
-				throw new InternalErrorException("RET supports only 0 and 1 ret val scenarios");
-			}
-		}
 
 		private void ExecBeginFn(Instruction i)
 		{
@@ -417,7 +423,7 @@ namespace MoonSharp.Interpreter.Execution.VM
 			{
 				if (i >= numargs)
 				{
-					this.AssignGenericSymbol(I.SymbolList[i], DynValue.NewNil());
+					this.AssignLocal(I.SymbolList[i], DynValue.NewNil());
 				}
 				else if ((i == I.SymbolList.Length - 1) && (I.SymbolList[i].i_Name == "..."))
 				{
@@ -429,16 +435,17 @@ namespace MoonSharp.Interpreter.Execution.VM
 						varargs[ii] = m_ValueStack.Peek(numargs - i - ii).CloneAsWritable();
 					}
 
-					this.AssignGenericSymbol(I.SymbolList[i], DynValue.NewTuple(varargs));
+					this.AssignLocal(I.SymbolList[i], DynValue.NewTuple(varargs));
 				}
 				else
 				{
-					this.AssignGenericSymbol(I.SymbolList[i], m_ValueStack.Peek(numargs - i).CloneAsWritable());
+					this.AssignLocal(I.SymbolList[i], m_ValueStack.Peek(numargs - i).CloneAsWritable());
 				}
 			}
 		}
 
 
+
 		private int Internal_ExecCall(int argsCount, int instructionPtr)
 		{
 			DynValue fn = m_ValueStack.Peek(argsCount);
@@ -449,7 +456,8 @@ namespace MoonSharp.Interpreter.Execution.VM
 				var ret = fn.Callback.Invoke(new ScriptExecutionContext(this, fn.Callback), args);
 				m_ValueStack.RemoveLast(argsCount + 1);
 				m_ValueStack.Push(ret);
-				return instructionPtr;
+
+				return ExecTailChk(null, instructionPtr);
 			}
 			else if (fn.Type == DataType.Function)
 			{
@@ -465,9 +473,9 @@ namespace MoonSharp.Interpreter.Execution.VM
 			}
 			else
 			{
-				if (fn.Meta != null)
+				if (fn.MetaTable != null)
 				{
-					var m = fn.Meta.Table.RawGet("__call");
+					var m = fn.MetaTable.RawGet("__call");
 
 					if (m != null && m.Type != DataType.Nil)
 					{
@@ -489,6 +497,32 @@ namespace MoonSharp.Interpreter.Execution.VM
 		}
 
 
+		private int ExecRet(Instruction i)
+		{
+			int retpoint = 0;
+
+			if (i.NumVal == 0)
+			{
+				retpoint = PopToBasePointer();
+				var argscnt = (int)(m_ValueStack.Pop().Number);
+				m_ValueStack.RemoveLast(argscnt + 1);
+				m_ValueStack.Push(DynValue.Nil);
+				return retpoint;
+			}
+			else if (i.NumVal == 1)
+			{
+				var retval = m_ValueStack.Pop();
+				retpoint = PopToBasePointer();
+				var argscnt = (int)(m_ValueStack.Pop().Number);
+				m_ValueStack.RemoveLast(argscnt + 1);
+				m_ValueStack.Push(retval);
+				return ExecTailChk(i, retpoint);
+			}
+			else
+			{
+				throw new InternalErrorException("RET supports only 0 and 1 ret val scenarios");
+			}
+		}
 
 		private int ExecTailChk(Instruction i, int instructionPtr)
 		{
@@ -498,12 +532,12 @@ namespace MoonSharp.Interpreter.Execution.VM
 			{
 				m_ValueStack.Pop(); // discard tail call request
 
-				m_ValueStack.Push(tail.Meta);
+				m_ValueStack.Push((DynValue)tail.UserObject);
 
 				for (int ii = 0; ii < tail.Tuple.Length; ii++)
 					m_ValueStack.Push(tail.Tuple[ii]);
 
-				instructionPtr -= 1;
+				//instructionPtr -= 1;
 				return Internal_ExecCall(tail.Tuple.Length, instructionPtr);
 			}
 
@@ -701,7 +735,7 @@ namespace MoonSharp.Interpreter.Execution.VM
 			{
 				m_ValueStack.Push(DynValue.False);
 			}
-			else if ((l.Type == DataType.Table || l.Type == DataType.UserData) && (l.Meta != null) && (l.Meta == r.Meta))
+			else if ((l.Type == DataType.Table || l.Type == DataType.UserData) && (l.MetaTable != null) && (l.MetaTable == r.MetaTable))
 			{
 				int ip = Internal_InvokeBinaryMetaMethod(l, r, "__eq", instructionPtr);
 				if (ip < 0)
@@ -841,10 +875,10 @@ namespace MoonSharp.Interpreter.Execution.VM
 			tbl.Table[key] = val.ToScalar();
 		}
 
-		private int ExecStoreIdx(Instruction i, int instructionPtr)
+		private int ExecIndexSet(Instruction i, int instructionPtr)
 		{
 			// stack: vals.. - base - index
-			DynValue idx = m_ValueStack.Pop();
+			DynValue idx = i.Value ?? m_ValueStack.Pop();
 			DynValue obj = m_ValueStack.Pop();
 			var v = GetStoreValue(i);
 
@@ -859,22 +893,63 @@ namespace MoonSharp.Interpreter.Execution.VM
 			}
 		}
 
-		private int ExecLoadIdx(Instruction i, int instructionPtr)
+		private int ExecIndex(Instruction i, int instructionPtr)
 		{
+			int nestedMetaOps = 100; // sanity check, to avoid potential infinite loop here
+
 			// stack: base - index
-			DynValue idx = m_ValueStack.Pop();
+			DynValue idx = i.Value ?? m_ValueStack.Pop();
 			DynValue obj = m_ValueStack.Pop();
 
-			if (obj.Type == DataType.Table)
-			{
-				var v = obj.Table[idx];
-				m_ValueStack.Push(v);
-				return instructionPtr;
-			}
-			else
+			DynValue h = null;
+
+			while (nestedMetaOps > 0)
 			{
-				throw new NotImplementedException();
+				--nestedMetaOps;
+
+				if (obj.Type == DataType.Table)
+				{
+					var v = obj.Table[idx];
+
+					if (!v.IsNil())
+					{
+						m_ValueStack.Push(v);
+						return instructionPtr;
+					}
+
+					if (obj.MetaTable != null)
+						h = obj.MetaTable.RawGet("__index");
+
+					if (h == null || h.IsNil())
+					{
+						m_ValueStack.Push(DynValue.NewNil());
+						return instructionPtr;
+					}
+				}
+				else
+				{
+					if (obj.MetaTable != null)
+						h = obj.MetaTable.RawGet("__index");
+
+					if (h == null || h.IsNil())
+						throw new ScriptRuntimeException("Can't index non table: {0}", obj);
+				}
+
+				if (h.Type == DataType.Function)
+				{
+					m_ValueStack.Push(h);
+					m_ValueStack.Push(obj);
+					m_ValueStack.Push(idx);
+					return Internal_ExecCall(2, instructionPtr);
+				}
+				else
+				{
+					obj = h;
+					h = null;
+				}
 			}
+
+			throw new ScriptRuntimeException("__index returning too many nested tables");
 		}
 
 

src/MoonSharp.Interpreter/Execution/VM/Processor/Processor_UtilityFunctions.cs

@@ -53,9 +53,9 @@ namespace MoonSharp.Interpreter.Execution.VM
 		{
 			DynValue m = null;
 
-			if (op1.Meta != null)
+			if (op1.MetaTable != null)
 			{
-				DynValue meta1 = op1.Meta.Table.RawGet(eventName);
+				DynValue meta1 = op1.MetaTable.RawGet(eventName);
 				if (meta1 != null && meta1.Type != DataType.Nil)
 					m = meta1;
 			}
@@ -90,15 +90,15 @@ namespace MoonSharp.Interpreter.Execution.VM
 
 		private DynValue Internal_GetBinHandler(DynValue op1, DynValue op2, string eventName)
 		{
-			if (op1.Meta != null)
+			if (op1.MetaTable != null)
 			{
-				DynValue meta1 = op1.Meta.Table.RawGet(eventName);
+				DynValue meta1 = op1.MetaTable.RawGet(eventName);
 				if (meta1 != null && meta1.Type != DataType.Nil)
 					return meta1;
 			}
-			if (op2.Meta != null)
+			if (op2.MetaTable != null)
 			{
-				DynValue meta2 = op2.Meta.Table.RawGet(eventName);
+				DynValue meta2 = op2.MetaTable.RawGet(eventName);
 				if (meta2 != null && meta2.Type != DataType.Nil)
 					return meta2;
 			}

src/MoonSharp.Interpreter/Modules/CoreModules.cs

@@ -14,13 +14,12 @@ namespace MoonSharp.Interpreter
 		String = 0x8,
 		LoadMethods = 0x10,
 		Table = 0x20,
-		RawTableAccess = 0x40,
 
 
 
 		Preset_HardSandbox = GlobalConsts | TableIterators | String | Table,
 		Preset_SoftSandbox = Preset_HardSandbox | Metatables,
-		Preset_Default = Preset_SoftSandbox | LoadMethods | RawTableAccess,
+		Preset_Default = Preset_SoftSandbox | LoadMethods ,
 		Preset_Complete = Preset_Default,
 
 	}

src/MoonSharp.Interpreter/Modules/ModuleRegister.cs

@@ -19,7 +19,6 @@ namespace MoonSharp.Interpreter
 			if (modules.Has(CoreModules.LoadMethods)) RegisterModuleType<LoadMethods>(table);
 			if (modules.Has(CoreModules.Table)) RegisterModuleType<TableModule>(table);
 			if (modules.Has(CoreModules.Table)) RegisterModuleType<TableModule_Globals>(table);
-			if (modules.Has(CoreModules.RawTableAccess)) RegisterModuleType<RawTableAccess>(table);
 
 			return table;
 		}

src/MoonSharp.Interpreter/MoonSharp.Interpreter.csproj

@@ -89,7 +89,6 @@
     <Compile Include="CoreLib\Patterns\PatternMatching.cs">
       <SubType>Code</SubType>
     </Compile>
-    <Compile Include="CoreLib\RawTableAccess.cs" />
     <Compile Include="CoreLib\StringModule.cs" />
     <Compile Include="CoreLib\TableIterators.cs" />
     <Compile Include="CoreLib\TableModule.cs" />

src/MoonSharp.Interpreter/Tree/Expressions/FunctionDefinitionExpression.cs

@@ -105,7 +105,8 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 
 			m_Statement.Compile(bc);
 
-			bc.Emit_Ret(0);
+			if (bc.GetLastInstruction().OpCode != OpCode.Ret)
+				bc.Emit_Ret(0);
 
 			I.NumVal = bc.GetJumpPointForNextInstruction();
 

src/MoonSharp.Interpreter/Tree/Expressions/IndexExpression.cs

@@ -26,15 +26,35 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 		public override void Compile(ByteCode bc)
 		{
 			m_BaseExp.Compile(bc);
-			m_IndexExp.Compile(bc);
-			bc.Emit_LoadIdx();
+
+			if (m_IndexExp is LiteralExpression)
+			{
+				LiteralExpression lit = (LiteralExpression)m_IndexExp;
+				bc.Emit_Index(lit.Value);
+			}
+			else
+			{
+				m_IndexExp.Compile(bc);
+				bc.Emit_Index();
+			}
 		}
 
 		public void CompileAssignment(ByteCode bc, int stackofs, int tupleidx)
 		{
 			m_BaseExp.Compile(bc);
-			m_IndexExp.Compile(bc);
-			bc.Emit_StoreIdx(stackofs, tupleidx);
+
+			if (m_IndexExp is LiteralExpression)
+			{
+				LiteralExpression lit = (LiteralExpression)m_IndexExp;
+				bc.Emit_IndexSet(stackofs, tupleidx, lit.Value);
+			}
+			else
+			{
+				m_IndexExp.Compile(bc);
+				bc.Emit_IndexSet(stackofs, tupleidx);
+			}
+
+
 		}
 	}
 }

src/MoonSharp.Interpreter/Tree/Expressions/LiteralExpression.cs

@@ -13,6 +13,11 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 	{
 		DynValue m_Value;
 
+		public DynValue Value
+		{
+			get { return m_Value; }
+		}
+
 		public LiteralExpression(IParseTree context, ScriptLoadingContext lcontext, DynValue rvalue)
 			: base(context, lcontext)
 		{

src/MoonSharp.Interpreter/Tree/FunctionCall.cs

@@ -31,7 +31,7 @@ namespace MoonSharp.Interpreter.Tree
 			{
 				bc.Emit_Copy(0);
 				bc.Emit_Literal(DynValue.NewString(m_Name));
-				bc.Emit_LoadIdx();
+				bc.Emit_Index();
 				bc.Emit_Swap(0, 1);
 				++argslen;
 			}

src/MoonSharp.Interpreter/Tree/Statements/FunctionDefinitionStatement.cs

@@ -76,12 +76,11 @@ namespace MoonSharp.Interpreter.Tree.Statements
 			{
 				bc.Emit_Literal(DynValue.Nil);
 				bc.Emit_Store(m_FuncSymbol, 0, 0);
-				bc.Emit_Pop();
-				m_FuncDef.Compile(bc, () => SetFunction(bc), m_FriendlyName);
+				m_FuncDef.Compile(bc, () => SetFunction(bc, 2), m_FriendlyName);
 			}
 			else if (m_MethodName == null)
 			{
-				m_FuncDef.Compile(bc, () => SetFunction(bc), m_FriendlyName);
+				m_FuncDef.Compile(bc, () => SetFunction(bc, 1), m_FriendlyName);
 			}
 			else
 			{
@@ -98,21 +97,21 @@ namespace MoonSharp.Interpreter.Tree.Statements
 			foreach (string str in m_TableAccessors)
 			{
 				bc.Emit_Literal(DynValue.NewString(str));
-				bc.Emit_LoadIdx();
+				bc.Emit_Index();
 				cnt += 2;
 			}
 
 			bc.Emit_Literal(DynValue.NewString(m_MethodName));
 
-			bc.Emit_StoreIdx(0, 0);
+			bc.Emit_IndexSet(0, 0);
 
 			return 2 + cnt;
 		}
 
-		private int SetFunction(Execution.VM.ByteCode bc)
+		private int SetFunction(Execution.VM.ByteCode bc, int numPop)
 		{
 			int num = bc.Emit_Store(m_FuncSymbol, 0, 0);
-			bc.Emit_Pop();
+			bc.Emit_Pop(numPop);
 			return num + 1;
 		}
 

src/MoonSharp/Program.cs

@@ -51,8 +51,51 @@ namespace MoonSharp
 			}
 			else
 			{
-				Console.WriteLine("Sorry, at the moment, only file operations are supported:");
-				Console.WriteLine("\tUsage : MoonSharp [filename]");
+				Console.WriteLine("Type <enter> twice to execute code.\n");
+
+				Script script = new Script();
+
+				script.Globals["print"] = DynValue.NewCallback(new CallbackFunction(Print));
+
+				string cmd = "";
+
+				while (true)
+				{
+					Console.Write("{0}> ", string.IsNullOrEmpty(cmd) ? "" : ">");
+					string s = Console.ReadLine();
+
+					if (s != "")
+					{
+						cmd += s + "\n";
+						continue;
+					}
+
+					if (cmd.Length == 0)
+						continue;
+
+					Console.WriteLine("=====");
+					Console.WriteLine("{0}", cmd);
+					Console.WriteLine("=====");
+
+					if (cmd == "exit")
+						return;
+
+					try
+					{
+						Console.WriteLine("={0}", script.DoString(cmd));
+					}
+					catch (Exception ex)
+					{
+						Console.WriteLine("Error: {0}", ex.Message);
+					}
+
+					cmd = "";
+
+				}
+
+
+
+
 			}
 		}
 

src/PerformanceComparison/Program.cs

@@ -16,12 +16,12 @@ namespace PerformanceComparison
 	class Program
 	{
 #if PROFILER
-		const int ITERATIONS = 1000;
+		const int ITERATIONS = 10;
 #else
-		const int ITERATIONS = 1;
+		const int ITERATIONS = 100;
 #endif
 
-		static  string scriptText = @"
+		static  string scriptText2 = @"
 			function move(n, src, dst, via)
 				if n > 0 then
 					move(n - 1, src, via, dst)
@@ -34,7 +34,7 @@ namespace PerformanceComparison
 				move(4, 1, 2, 3)
 			end
 			";
-		static  string scriptText2 = @"
+		static  string scriptText = @"
 N = 8
  
 board = {}
@@ -71,15 +71,15 @@ if Find_Solution( 1 ) then
     for i = 1, N do
  	for j = 1, N do
   	    if board[i][j] then 
-		print( 'Q' )
+		--print( 'Q' )
 	    else 
-		print( 'x' )
+		--print( 'x' )
 	    end
 	end
-	print( '|' )
+	--print( '|' )
     end
 else
-    print( 'NO!' )
+    --print( 'NO!' )
 end
  
 			";
@@ -125,7 +125,8 @@ end
 
 			sw = Stopwatch.StartNew();
 
-			Script.RunString("return 0;");
+			var _s = new Script();
+			_s.LoadString(scriptText);
 
 			sw.Stop();
 

src/moonsharp.sln

@@ -32,6 +32,7 @@ Global
 	EndGlobalSection
 	GlobalSection(ProjectConfigurationPlatforms) = postSolution
 		{2A4BD262-D6EB-4611-A28B-27B6DAEB089B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2A4BD262-D6EB-4611-A28B-27B6DAEB089B}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{2A4BD262-D6EB-4611-A28B-27B6DAEB089B}.Debug|x86.ActiveCfg = Debug|x86
 		{2A4BD262-D6EB-4611-A28B-27B6DAEB089B}.Debug|x86.Build.0 = Debug|x86
 		{2A4BD262-D6EB-4611-A28B-27B6DAEB089B}.Release|Any CPU.ActiveCfg = Release|Any CPU