before refactoring

src/MoonSharp.Interpreter/DataStructs/ITrackableReference.cs

@@ -0,0 +1,13 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace MoonSharp.Interpreter.DataStructs
+{
+	public interface ITrackableReference
+	{
+		int ReferenceID { get; }
+
+	}
+}

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

@@ -7,20 +7,22 @@ using System.IO;
 using System.Linq;
 using System.Text;
 using System.Threading;
+using MoonSharp.Interpreter.DataStructs;
 
 namespace MoonSharp.Interpreter.Execution.VM
 {
-	public class ByteCode
+	public class ByteCode : ITrackableReference
 	{
 		public List<Instruction> Code = new List<Instruction>();
 		internal LoopTracker LoopTracker = new LoopTracker();
 
+		#region ITrackableReference
+
 		static int s_RefIDCounter = 0;
 		private int m_RefID = Interlocked.Increment(ref s_RefIDCounter);
-
-
 		public int ReferenceID { get { return m_RefID; } }
 
+		#endregion
 
 		public void Dump(string file)
 		{
@@ -46,180 +48,173 @@ namespace MoonSharp.Interpreter.Execution.VM
 			return Code.Count - 1;
 		}
 
-		private Instruction Emit(Instruction c)
+		private Instruction AppendInstruction(Instruction c)
 		{
 			Code.Add(c);
 			return c;
 		}
 
-		public Instruction Nop(string comment)
+		public Instruction Emit_Nop(string comment)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Nop, Name = comment });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Nop, Name = comment });
 		}
 
-		public Instruction Invalid(string type)
+		public Instruction Emit_Invalid(string type)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Invalid, Name = type });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Invalid, Name = type });
 		}
 
-		public Instruction Pop(int num = 1)
+		public Instruction Emit_Pop(int num = 1)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Pop, NumVal = num });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Pop, NumVal = num });
 		}
 
-		public void Call(int argCount)
+		public void Emit_Call(int argCount)
 		{
-			Emit(new Instruction() { OpCode = OpCode.Call, NumVal = argCount });
-			Emit(new Instruction() { OpCode = OpCode.TailChk });
+			AppendInstruction(new Instruction() { OpCode = OpCode.Call, NumVal = argCount });
+			AppendInstruction(new Instruction() { OpCode = OpCode.TailChk });
 		}
 
-		public Instruction Load(SymbolRef symref)
+		public Instruction Emit_Load(SymbolRef symref)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Load, Symbol = symref });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Load, Symbol = symref });
 		}
 
-		public Instruction Literal(DynValue value)
+		public Instruction Emit_Literal(DynValue value)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Literal, Value = value });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Literal, Value = value });
 		}
 
-		public Instruction Assign(int cntL, int cntR)
+		public Instruction Emit_Assign(int cntL, int cntR)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Assign, NumVal = cntL, NumVal2 = cntR });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Assign, NumVal = cntL, NumVal2 = cntR });
 		}
 
-		public Instruction Store()
+		public Instruction Emit_Store()
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Store });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Store });
 		}
 
-		public Instruction Symbol(SymbolRef symref)
+		public Instruction Emit_Symbol(SymbolRef symref)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Symbol, Symbol = symref });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Symbol, Symbol = symref });
 		}
 
-		public Instruction Jump(OpCode jumpOpCode, int idx, int optPar = 0)
+		public Instruction Emit_Jump(OpCode jumpOpCode, int idx, int optPar = 0)
 		{
-			return Emit(new Instruction() { OpCode = jumpOpCode, NumVal = idx, NumVal2 = optPar });
+			return AppendInstruction(new Instruction() { OpCode = jumpOpCode, NumVal = idx, NumVal2 = optPar });
 		}
 
-		public Instruction MkTuple(int cnt)
+		public Instruction Emit_MkTuple(int cnt)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.MkTuple, NumVal = cnt });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.MkTuple, NumVal = cnt });
 		}
 
-		public Instruction Operator(OpCode opcode)
+		public Instruction Emit_Operator(OpCode opcode)
 		{
-			var i = Emit(new Instruction() { OpCode = opcode });
+			var i = AppendInstruction(new Instruction() { OpCode = opcode });
 
 			if (opcode == OpCode.Eq || opcode == OpCode.Less || opcode == OpCode.LessEq)
-				Emit(new Instruction() { OpCode = OpCode.ToBool });
+				AppendInstruction(new Instruction() { OpCode = OpCode.ToBool });
 
 			return i;
 		}
 
 
 		//[Conditional("EMIT_DEBUG_OPS")]
-		public void Debug(string str)
-		{
-			Emit(new Instruction() { OpCode = OpCode.Debug, Name = str.Substring(0, Math.Min(32, str.Length)) });
-		}
-
-		//[Conditional("EMIT_DEBUG_OPS")]
-		public void Debug(Antlr4.Runtime.Tree.IParseTree parseTree)
+		public void Emit_Debug(string str)
 		{
-			string str = parseTree.GetText();
-			Emit(new Instruction() { OpCode = OpCode.Debug, Name = str.Substring(0, Math.Min(32, str.Length)) });
+			AppendInstruction(new Instruction() { OpCode = OpCode.Debug, Name = str.Substring(0, Math.Min(32, str.Length)) });
 		}
 
-		public Instruction Enter(RuntimeScopeBlock runtimeScopeBlock)
+		public Instruction Emit_Enter(RuntimeScopeBlock runtimeScopeBlock)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Enter, Block = runtimeScopeBlock });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Enter, Block = runtimeScopeBlock });
 		}
 
-		public Instruction Leave(RuntimeScopeBlock runtimeScopeBlock)
+		public Instruction Emit_Leave(RuntimeScopeBlock runtimeScopeBlock)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Leave, Block = runtimeScopeBlock });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Leave, Block = runtimeScopeBlock });
 		}
 
-		public Instruction Exit(RuntimeScopeBlock runtimeScopeBlock)
+		public Instruction Emit_Exit(RuntimeScopeBlock runtimeScopeBlock)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Exit, Block = runtimeScopeBlock });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Exit, Block = runtimeScopeBlock });
 		}
 
-		public Instruction Closure(SymbolRef[] symbols, int jmpnum)
+		public Instruction Emit_Closure(SymbolRef[] symbols, int jmpnum)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Closure, SymbolList = symbols, NumVal = jmpnum });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Closure, SymbolList = symbols, NumVal = jmpnum });
 		}
 
-		public Instruction Args(SymbolRef[] symbols)
+		public Instruction Emit_Args(SymbolRef[] symbols)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Args, SymbolList = symbols });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Args, SymbolList = symbols });
 		}
 
-		public Instruction Ret(int retvals)
+		public Instruction Emit_Ret(int retvals)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Ret, NumVal = retvals });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Ret, NumVal = retvals });
 		}
 
-		public Instruction ToNum()
+		public Instruction Emit_ToNum()
 		{
-			return Emit(new Instruction() { OpCode = OpCode.ToNum });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.ToNum });
 		}
 
-		public Instruction SymStorN(SymbolRef symb)
+		public Instruction Emit_SymStorN(SymbolRef symb)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.SymStorN, Symbol = symb });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.SymStorN, Symbol = symb });
 		}
 
-		public Instruction Incr(int i)
+		public Instruction Emit_Incr(int i)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Incr, NumVal = i });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Incr, NumVal = i });
 		}
 
-		public Instruction Index()
+		public Instruction Emit_Index()
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Index });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Index });
 		}
 
-		public Instruction IndexRef()
+		public Instruction Emit_IndexRef()
 		{
-			return Emit(new Instruction() { OpCode = OpCode.IndexRef });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.IndexRef });
 		}
 
-		public Instruction IndexRefN()
+		public Instruction Emit_IndexRefN()
 		{
-			return Emit(new Instruction() { OpCode = OpCode.IndexRefN });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.IndexRefN });
 		}
 
-		public Instruction NewTable()
+		public Instruction Emit_NewTable()
 		{
-			return Emit(new Instruction() { OpCode = OpCode.NewTable });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.NewTable });
 		}
 
-		public Instruction IterPrep()
+		public Instruction Emit_IterPrep()
 		{
-			return Emit(new Instruction() { OpCode = OpCode.IterPrep });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.IterPrep });
 		}
 
-		public Instruction ExpTuple(int stackOffset)
+		public Instruction Emit_ExpTuple(int stackOffset)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.ExpTuple, NumVal = stackOffset });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.ExpTuple, NumVal = stackOffset });
 		}
 
-		public Instruction IterUpd()
+		public Instruction Emit_IterUpd()
 		{
-			return Emit(new Instruction() { OpCode = OpCode.IterUpd });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.IterUpd });
 		}
 
-		public Instruction Method()
+		public Instruction Emit_Method()
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Method });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Method });
 		}
 
-		public Instruction BeginFn(RuntimeScopeFrame m_StackFrame, string funcName)
+		public Instruction Emit_BeginFn(RuntimeScopeFrame m_StackFrame, string funcName)
 		{
-			return Emit(new Instruction() { OpCode = OpCode.BeginFn, 
+			return AppendInstruction(new Instruction() { OpCode = OpCode.BeginFn, 
 				SymbolList = m_StackFrame.DebugSymbols.ToArray(), 
 				NumVal = m_StackFrame.Count,
 				NumVal2 = m_StackFrame.ToFirstBlock,
@@ -227,9 +222,9 @@ namespace MoonSharp.Interpreter.Execution.VM
 			});
 		}
 
-		public Instruction Scalar()
+		public Instruction Emit_Scalar()
 		{
-			return Emit(new Instruction() { OpCode = OpCode.Scalar });
+			return AppendInstruction(new Instruction() { OpCode = OpCode.Scalar });
 		}
 	}
 }

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

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using MoonSharp.Interpreter.Debugging;
+
+namespace MoonSharp.Interpreter.Execution.VM
+{
+	public class Chunk
+	{
+		public SourceCode SourceCode { get; private set; }
+		public ByteCode ByteCode { get; private set; }
+	}
+}

src/MoonSharp.Interpreter/MoonSharp.Interpreter.csproj

@@ -93,6 +93,7 @@
     <Compile Include="CoreLib\TableIterators.cs" />
     <Compile Include="DataStructs\Extension_Methods.cs" />
     <Compile Include="DataStructs\FastStackDynamic.cs" />
+    <Compile Include="DataStructs\ITrackableReference.cs" />
     <Compile Include="DataStructs\LinkedListIndex.cs" />
     <Compile Include="DataStructs\Slice.cs" />
     <Compile Include="Debugging\DebuggerAction.cs" />
@@ -119,6 +120,7 @@
       <SubType>Code</SubType>
     </Compile>
     <Compile Include="Debugging\SourceCode.cs" />
+    <Compile Include="Execution\VM\Chunk.cs" />
     <Compile Include="Interface\IteratorHelper.cs" />
     <Compile Include="Loaders\ClassicLuaScriptLoader.cs" />
     <Compile Include="Loaders\IScriptLoader.cs" />

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

@@ -21,7 +21,7 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 		public override void Compile(Execution.VM.ByteCode bc)
 		{
 			expression.Compile(bc);
-			bc.Scalar();
+			bc.Emit_Scalar();
 		}
 
 

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

@@ -32,7 +32,7 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 				exp.Compile(bc);
 
 			if (expressions.Length > 1)
-				bc.MkTuple(expressions.Length);
+				bc.Emit_MkTuple(expressions.Length);
 		}
 	}
 }

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

@@ -94,16 +94,16 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 
 		public int CompileBody(ByteCode bc, string friendlyName)
 		{
-			Instruction I = bc.Jump(OpCode.Jump, -1);
+			Instruction I = bc.Emit_Jump(OpCode.Jump, -1);
 
-			bc.BeginFn(m_StackFrame, friendlyName ?? "<anonymous>");
+			bc.Emit_BeginFn(m_StackFrame, friendlyName ?? "<anonymous>");
 
 			if (m_ParamNames.Length > 0)
-				bc.Args(m_ParamNames);
+				bc.Emit_Args(m_ParamNames);
 
 			m_Statement.Compile(bc);
 
-			bc.Ret(0);
+			bc.Emit_Ret(0);
 
 			I.NumVal = bc.GetJumpPointForNextInstruction();
 
@@ -112,7 +112,7 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 
 		public int Compile(ByteCode bc, Action afterDecl, string friendlyName)
 		{
-			bc.Closure(m_Closure.ToArray(), bc.GetJumpPointForNextInstruction() + 3);
+			bc.Emit_Closure(m_Closure.ToArray(), bc.GetJumpPointForNextInstruction() + 3);
 			afterDecl();
 			return CompileBody(bc, friendlyName);
 		}
@@ -120,7 +120,7 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 
 		public override void Compile(ByteCode bc)
 		{
-			Compile(bc, () => bc.Nop(null), null);
+			Compile(bc, () => bc.Emit_Nop(null), null);
 		}
 
 	}

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

@@ -27,7 +27,7 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 		{
 			m_BaseExp.Compile(bc);
 			m_IndexExp.Compile(bc);
-			bc.Index();
+			bc.Emit_Index();
 		}
 
 
@@ -35,7 +35,7 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 		{
 			m_BaseExp.Compile(bc);
 			m_IndexExp.Compile(bc);
-			bc.IndexRef();
+			bc.Emit_IndexRef();
 		}
 	}
 }

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

@@ -88,7 +88,7 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 
 		public override void Compile(Execution.VM.ByteCode bc)
 		{
-			bc.Literal(m_Value);
+			bc.Emit_Literal(m_Value);
 		}
 	}
 }

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

@@ -133,7 +133,7 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 
 			if (m_Operator == Operator.Or)
 			{
-				Instruction i = bc.Jump(OpCode.JtOrPop, -1);
+				Instruction i = bc.Emit_Jump(OpCode.JtOrPop, -1);
 				m_Exp2.Compile(bc);
 				i.NumVal = bc.GetJumpPointForNextInstruction();
 				return;
@@ -141,7 +141,7 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 
 			if (m_Operator == Operator.And)
 			{
-				Instruction i = bc.Jump(OpCode.JfOrPop, -1);
+				Instruction i = bc.Emit_Jump(OpCode.JfOrPop, -1);
 				m_Exp2.Compile(bc);
 				i.NumVal = bc.GetJumpPointForNextInstruction();
 				return;
@@ -153,10 +153,10 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 				m_Exp2.Compile(bc);
 			}
 
-			bc.Operator(OperatorToOpCode(m_Operator));
+			bc.Emit_Operator(OperatorToOpCode(m_Operator));
 
 			if (ShouldInvertBoolean(m_Operator))
-				bc.Operator(OpCode.Not);
+				bc.Emit_Operator(OpCode.Not);
 		}
 
 		private bool ShouldInvertBoolean(Operator op)

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

@@ -22,12 +22,12 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 
 		public override void Compile(Execution.VM.ByteCode bc)
 		{
-			bc.Load(m_Ref);
+			bc.Emit_Load(m_Ref);
 		}
 
 		public void CompileAssignment(Execution.VM.ByteCode bc)
 		{
-			bc.Symbol(m_Ref);
+			bc.Emit_Symbol(m_Ref);
 		}
 	}
 }

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

@@ -51,22 +51,22 @@ namespace MoonSharp.Interpreter.Tree.Expressions
 
 		public override void Compile(Execution.VM.ByteCode bc)
 		{
-			bc.NewTable();
+			bc.Emit_NewTable();
 
 			foreach (var kvp in m_CtorArgs)
 			{
 				kvp.Key.Compile(bc);
-				bc.IndexRefN();
+				bc.Emit_IndexRefN();
 				kvp.Value.Compile(bc);
-				bc.Store();
+				bc.Emit_Store();
 			}
 
 			for (int i = 0; i < m_PositionalValues.Count; i++)
 			{
-				bc.Literal(DynValue.NewNumber(i+1));
-				bc.IndexRefN();
+				bc.Emit_Literal(DynValue.NewNumber(i+1));
+				bc.Emit_IndexRefN();
 				m_PositionalValues[i].Compile(bc);
-				bc.Store();
+				bc.Emit_Store();
 			}
 		}
 

src/MoonSharp.Interpreter/Tree/FunctionCall.cs

@@ -29,15 +29,15 @@ namespace MoonSharp.Interpreter.Tree
 
 			if (!string.IsNullOrEmpty(m_Name))
 			{
-				bc.Literal(DynValue.NewString(m_Name));
-				bc.Method();
+				bc.Emit_Literal(DynValue.NewString(m_Name));
+				bc.Emit_Method();
 				++argslen;
 			}
 
 			for (int i = 0; i < m_Arguments.Length; i++)
 				m_Arguments[i].Compile(bc);
 
-			bc.Call(argslen);
+			bc.Emit_Call(argslen);
 		}
 	}
 }

src/MoonSharp.Interpreter/Tree/Loader.cs

@@ -0,0 +1,106 @@
+#define DEBUG_COMPILER
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using Antlr4.Runtime;
+using MoonSharp.Interpreter.Diagnostics;
+using MoonSharp.Interpreter.Execution;
+using MoonSharp.Interpreter.Execution.VM;
+using MoonSharp.Interpreter.Grammar;
+using MoonSharp.Interpreter.Tree.Expressions;
+using MoonSharp.Interpreter.Tree.Statements;
+
+namespace MoonSharp.Interpreter.Tree
+{
+	internal static class Loader
+	{
+		internal static int LoadChunkFromICharStream(ICharStream charStream, ByteCode bytecode, string sourceName, int sourceIdx)
+		{
+			LuaParser parser = CreateParser(charStream, sourceIdx);
+
+			ScriptLoadingContext lcontext = CreateLoadingContext(sourceName, sourceIdx);
+			ChunkStatement stat = new ChunkStatement(parser.chunk(), lcontext);
+
+			int beginIp = -1;
+
+			using (var _ = new CodeChrono("ChunkStatement.LoadFromICharStream/Compile"))
+			{
+				bytecode.Emit_Nop(string.Format("Begin chunk {0}", sourceName));
+				beginIp = bytecode.GetJumpPointForLastInstruction();
+				stat.Compile(bytecode);
+				bytecode.Emit_Nop(string.Format("End chunk {0}", sourceName));
+
+				Debug_DumpByteCode(bytecode, sourceIdx);
+			}
+
+			return beginIp;
+		}
+
+		internal static int LoadFunctionFromICharStream(ICharStream charStream, ByteCode bytecode, string sourceName, int sourceIdx)
+		{
+			LuaParser parser = CreateParser(charStream, sourceIdx);
+
+			ScriptLoadingContext lcontext = CreateLoadingContext(sourceName, sourceIdx);
+			FunctionDefinitionExpression fndef = new FunctionDefinitionExpression(parser.anonfunctiondef(), lcontext);
+
+			int beginIp = -1;
+
+			using (var _ = new CodeChrono("ChunkStatement.LoadFromICharStream/Compile"))
+			{
+				bytecode.Emit_Nop(string.Format("Begin function {0}", sourceName));
+				beginIp = fndef.CompileBody(bytecode, sourceName);
+				bytecode.Emit_Nop(string.Format("End function {0}", sourceName));
+
+				Debug_DumpByteCode(bytecode, sourceIdx);
+			}
+
+			return beginIp;
+		}
+
+
+		[Conditional("DEBUG_COMPILER")]
+		private static void Debug_DumpByteCode(ByteCode bytecode, int sourceIdx)
+		{
+			bytecode.Dump(string.Format(@"c:\temp\codedump_{0}.txt", sourceIdx));
+		}
+
+		[Conditional("DEBUG_COMPILER")]
+		private static void Debug_DumpAst(LuaParser parser, int sourceIdx)
+		{
+			AstDump astDump = new AstDump();
+			astDump.DumpTree(parser.chunk(), string.Format(@"c:\temp\treedump_{0:000}.txt", sourceIdx));
+			parser.Reset();
+		}
+
+
+		private static ScriptLoadingContext CreateLoadingContext(string sourceName, int sourceIdx)
+		{
+			return new ScriptLoadingContext()
+			{
+				Scope = new BuildTimeScope(),
+				SourceIdx = sourceIdx,
+				SourceName = sourceName,
+			};
+		}
+
+		private static LuaParser CreateParser(ICharStream charStream, int sourceIdx)
+		{
+			LuaLexer lexer;
+			LuaParser parser;
+
+			using (var _ = new CodeChrono("ChunkStatement.LoadFromICharStream/Parsing"))
+			{
+				lexer = new LuaLexer(charStream);
+				parser = new LuaParser(new CommonTokenStream(lexer));
+			}
+
+			Debug_DumpAst(parser, sourceIdx);
+
+			return parser;
+		}
+
+	}
+}

src/MoonSharp.Interpreter/Tree/Loop.cs

@@ -14,8 +14,8 @@ namespace MoonSharp.Interpreter.Tree
 
 		public void CompileBreak(ByteCode bc)
 		{
-			bc.Exit(Scope);
-			BreakJumps.Add(bc.Jump(OpCode.Jump, -1));
+			bc.Emit_Exit(Scope);
+			BreakJumps.Add(bc.Emit_Jump(OpCode.Jump, -1));
 		}
 	}
 

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

@@ -35,7 +35,7 @@ namespace MoonSharp.Interpreter.Tree.Statements
 			{
 				m_LValues[0].CompileAssignment(bc);
 				m_RValues[0].Compile(bc);
-				bc.Store();
+				bc.Emit_Store();
 			}
 			else
 			{
@@ -45,7 +45,7 @@ namespace MoonSharp.Interpreter.Tree.Statements
 				foreach (var exp in m_RValues)
 					exp.Compile(bc);
 
-				bc.Assign(m_LValues.Length, m_RValues.Length);
+				bc.Emit_Assign(m_LValues.Length, m_RValues.Length);
 			}
 		}
 

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

@@ -27,9 +27,9 @@ namespace MoonSharp.Interpreter.Tree.Statements
 
 		public override void Compile(Execution.VM.ByteCode bc)
 		{
-			bc.BeginFn(m_StackFrame, "<chunk-root>");
+			bc.Emit_BeginFn(m_StackFrame, "<chunk-root>");
 			m_Block.Compile(bc);
-			bc.Ret(0);
+			bc.Emit_Ret(0);
 			//bc.Leave(m_StackFrame);
 		}
 	}

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

@@ -45,7 +45,7 @@ namespace MoonSharp.Interpreter.Tree.Statements
 				{
 					if (!(s is NullStatement))
 					{
-						bc.Debug(s.TreeNode);
+						bc.Emit_Debug(s.TreeNode.GetText());
 						s.Compile(bc);
 					}
 				}

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

@@ -51,47 +51,47 @@ namespace MoonSharp.Interpreter.Tree.Statements
 			m_RValues.Compile(bc);
 
 			// prepares iterator tuple - stack : iterator-tuple
-			bc.IterPrep();
+			bc.Emit_IterPrep();
 
 			// loop start - stack : iterator-tuple
 			int start = bc.GetJumpPointForNextInstruction();
-			bc.Enter(m_StackFrame);
+			bc.Emit_Enter(m_StackFrame);
 
 			// push all iterating variables - stack : iterator-tuple, iter-var-symbols
 			foreach (SymbolRef s in m_Names)
-				bc.Symbol(s);
+				bc.Emit_Symbol(s);
 
 			// expand the tuple - stack : iterator-tuple, iter-var-symbols, f, var, s
-			bc.ExpTuple(m_Names.Length);  
+			bc.Emit_ExpTuple(m_Names.Length);  
 
 			// calls f(s, var) - stack : iterator-tuple, iter-var-symbols, iteration result
-			bc.Call(2);
+			bc.Emit_Call(2);
 
 			// assigns to iter-var-symbols - stack : iterator-tuple
-			bc.Assign(m_Names.Length, 1);
+			bc.Emit_Assign(m_Names.Length, 1);
 
 			// repushes the main iterator var - stack : iterator-tuple, main-iterator-var
-			bc.Load(m_Names[0]);
+			bc.Emit_Load(m_Names[0]);
 
 			// updates the iterator tuple - stack : iterator-tuple, main-iterator-var
-			bc.IterUpd();
+			bc.Emit_IterUpd();
 
 			// checks head, jumps if nil - stack : iterator-tuple, main-iterator-var
-			var endjump = bc.Jump(OpCode.JNil, -1);
+			var endjump = bc.Emit_Jump(OpCode.JNil, -1);
 
 			// executes the stuff - stack : iterator-tuple
 			m_Block.Compile(bc);
 
 			// loop back again - stack : iterator-tuple
-			bc.Leave(m_StackFrame);
-			bc.Jump(OpCode.Jump, start);
+			bc.Emit_Leave(m_StackFrame);
+			bc.Emit_Jump(OpCode.Jump, start);
 
 			int exitpointLoopExit = bc.GetJumpPointForNextInstruction();
-			bc.Leave(m_StackFrame);
+			bc.Emit_Leave(m_StackFrame);
 
 			int exitpointBreaks = bc.GetJumpPointForNextInstruction();
 
-			bc.Pop();
+			bc.Emit_Pop();
 
 			foreach (Instruction i in L.BreakJumps)
 				i.NumVal = exitpointBreaks;

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

@@ -46,21 +46,21 @@ namespace MoonSharp.Interpreter.Tree.Statements
 			bc.LoopTracker.Loops.Push(L);
 
 			m_End.Compile(bc);
-			bc.ToNum();
+			bc.Emit_ToNum();
 			m_Step.Compile(bc);
-			bc.ToNum();
+			bc.Emit_ToNum();
 			m_Start.Compile(bc);
-			bc.ToNum();
+			bc.Emit_ToNum();
 
 			int start = bc.GetJumpPointForNextInstruction();
-			var jumpend = bc.Jump(OpCode.JFor, -1);
-			bc.Enter(m_StackFrame);
-			bc.SymStorN(m_VarName);
+			var jumpend = bc.Emit_Jump(OpCode.JFor, -1);
+			bc.Emit_Enter(m_StackFrame);
+			bc.Emit_SymStorN(m_VarName);
 			m_InnerBlock.Compile(bc);
-			bc.Debug("..end");
-			bc.Leave(m_StackFrame);
-			bc.Incr(1);
-			bc.Jump(OpCode.Jump, start);
+			bc.Emit_Debug("..end");
+			bc.Emit_Leave(m_StackFrame);
+			bc.Emit_Incr(1);
+			bc.Emit_Jump(OpCode.Jump, start);
 
 			int exitpoint = bc.GetJumpPointForNextInstruction();
 
@@ -68,7 +68,7 @@ namespace MoonSharp.Interpreter.Tree.Statements
 				i.NumVal = exitpoint;
 
 			jumpend.NumVal = exitpoint;
-			bc.Pop(3);
+			bc.Emit_Pop(3);
 		}
 
 	}

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

@@ -24,7 +24,7 @@ namespace MoonSharp.Interpreter.Tree.Statements
 		public override void Compile(ByteCode bc)
 		{
 			m_FunctionCallChain.Compile(bc);
-			bc.Pop();
+			bc.Emit_Pop();
 		}
 	}
 }

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

@@ -74,36 +74,36 @@ namespace MoonSharp.Interpreter.Tree.Statements
 		{
 			if (m_Local)
 			{
-				bc.Symbol(m_FuncName);
-				bc.Literal(DynValue.Nil);
-				bc.Store();
-				bc.Symbol(m_FuncName);
-				m_FuncDef.Compile(bc, () => bc.Store(), m_FriendlyName);
+				bc.Emit_Symbol(m_FuncName);
+				bc.Emit_Literal(DynValue.Nil);
+				bc.Emit_Store();
+				bc.Emit_Symbol(m_FuncName);
+				m_FuncDef.Compile(bc, () => bc.Emit_Store(), m_FriendlyName);
 				return;
 			}
 			else if (m_MethodName == null)
 			{
-				bc.Symbol(m_FuncName);
-				m_FuncDef.Compile(bc, () => bc.Store(), m_FriendlyName);
+				bc.Emit_Symbol(m_FuncName);
+				m_FuncDef.Compile(bc, () => bc.Emit_Store(), m_FriendlyName);
 				return;
 			}
 			else
 			{
-				bc.Load(m_FuncName);
+				bc.Emit_Load(m_FuncName);
 
 				foreach (string str in m_TableAccessors)
 				{
-					bc.Literal(DynValue.NewString(str));
-					bc.Index();
+					bc.Emit_Literal(DynValue.NewString(str));
+					bc.Emit_Index();
 				}
 
-				bc.Literal(DynValue.NewString(m_MethodName));
+				bc.Emit_Literal(DynValue.NewString(m_MethodName));
 
-				bc.IndexRef();
+				bc.Emit_IndexRef();
 
-				m_FuncDef.Compile(bc, () => bc.Nop(null), m_FriendlyName);
+				m_FuncDef.Compile(bc, () => bc.Emit_Nop(null), m_FriendlyName);
 
-				bc.Store();
+				bc.Emit_Store();
 			}
 		}
 

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

@@ -62,20 +62,20 @@ namespace MoonSharp.Interpreter.Tree.Statements
 					lastIfJmp.NumVal = bc.GetJumpPointForNextInstruction();
 
 				ifblock.Exp.Compile(bc);
-				lastIfJmp = bc.Jump(OpCode.Jf, -1);
-				bc.Enter(ifblock.StackFrame);
+				lastIfJmp = bc.Emit_Jump(OpCode.Jf, -1);
+				bc.Emit_Enter(ifblock.StackFrame);
 				ifblock.Block.Compile(bc);
-				bc.Leave(ifblock.StackFrame);
-				endJumps.Add(bc.Jump(OpCode.Jump, -1));
+				bc.Emit_Leave(ifblock.StackFrame);
+				endJumps.Add(bc.Emit_Jump(OpCode.Jump, -1));
 			}
 
 			lastIfJmp.NumVal = bc.GetJumpPointForNextInstruction();
 
 			if (m_Else != null)
 			{
-				bc.Enter(m_ElseStackFrame);
+				bc.Emit_Enter(m_ElseStackFrame);
 				m_Else.Compile(bc);
-				bc.Leave(m_ElseStackFrame);
+				bc.Emit_Leave(m_ElseStackFrame);
 			}
 
 			foreach(var endjmp in endJumps)

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

@@ -40,19 +40,19 @@ namespace MoonSharp.Interpreter.Tree.Statements
 		{
 			if (m_Names.Length == 1 && m_RValues.Length == 1)
 			{
-				bc.Symbol(m_Names[0]);
+				bc.Emit_Symbol(m_Names[0]);
 				m_RValues[0].Compile(bc);
-				bc.Store();
+				bc.Emit_Store();
 			}
 			else
 			{
 				foreach (var var in m_Names)
-					bc.Symbol(var);
+					bc.Emit_Symbol(var);
 
 				foreach (var exp in m_RValues)
 					exp.Compile(bc);
 
-				bc.Assign(m_Names.Length, m_RValues.Length);
+				bc.Emit_Assign(m_Names.Length, m_RValues.Length);
 			}
 		}
 	}

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

@@ -35,13 +35,13 @@ namespace MoonSharp.Interpreter.Tree.Statements
 
 			int start = bc.GetJumpPointForNextInstruction();
 
-			bc.Enter(m_StackFrame);
+			bc.Emit_Enter(m_StackFrame);
 			m_Block.Compile(bc);
-			bc.Debug("..end");
+			bc.Emit_Debug("..end");
 
 			m_Condition.Compile(bc);
-			bc.Leave(m_StackFrame);
-			bc.Jump(OpCode.Jf, start);
+			bc.Emit_Leave(m_StackFrame);
+			bc.Emit_Jump(OpCode.Jf, start);
 
 			int exitpoint = bc.GetJumpPointForNextInstruction();
 

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

@@ -28,11 +28,11 @@ namespace MoonSharp.Interpreter.Tree.Statements
 			if (m_Expression != null)
 			{
 				m_Expression.Compile(bc);
-				bc.Ret(1);
+				bc.Emit_Ret(1);
 			}
 			else
 			{
-				bc.Ret(0);
+				bc.Emit_Ret(0);
 			}
 		}
 	}

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

@@ -22,9 +22,9 @@ namespace MoonSharp.Interpreter.Tree.Statements
 
 		public override void Compile(Execution.VM.ByteCode bc)
 		{
-			bc.Enter(m_StackFrame);
+			bc.Emit_Enter(m_StackFrame);
 			m_Block.Compile(bc);
-			bc.Leave(m_StackFrame);
+			bc.Emit_Leave(m_StackFrame);
 		}
 
 	}

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

@@ -37,13 +37,13 @@ namespace MoonSharp.Interpreter.Tree.Statements
 			int start = bc.GetJumpPointForNextInstruction();
 
 			m_Condition.Compile(bc);
-			var jumpend = bc.Jump(OpCode.Jf, -1);
+			var jumpend = bc.Emit_Jump(OpCode.Jf, -1);
 
-			bc.Enter(m_StackFrame);
+			bc.Emit_Enter(m_StackFrame);
 			m_Block.Compile(bc);
-			bc.Debug("..end");
-			bc.Leave(m_StackFrame);
-			bc.Jump(OpCode.Jump, start);
+			bc.Emit_Debug("..end");
+			bc.Emit_Leave(m_StackFrame);
+			bc.Emit_Jump(OpCode.Jump, start);
 
 			int exitpoint = bc.GetJumpPointForNextInstruction();
 

src/moonsharp.sln

@@ -32,7 +32,6 @@ 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
@@ -48,7 +47,6 @@ Global
 		{91EA9B9D-FE03-4273-BDAF-8AD42EDE1E59}.Release|x86.ActiveCfg = Release|x86
 		{91EA9B9D-FE03-4273-BDAF-8AD42EDE1E59}.Release|x86.Build.0 = Release|x86
 		{4AD350E6-E296-43EF-9FEA-CB70358467E4}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{4AD350E6-E296-43EF-9FEA-CB70358467E4}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{4AD350E6-E296-43EF-9FEA-CB70358467E4}.Debug|x86.ActiveCfg = Debug|x86
 		{4AD350E6-E296-43EF-9FEA-CB70358467E4}.Debug|x86.Build.0 = Debug|x86
 		{4AD350E6-E296-43EF-9FEA-CB70358467E4}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -56,7 +54,6 @@ Global
 		{4AD350E6-E296-43EF-9FEA-CB70358467E4}.Release|x86.ActiveCfg = Release|x86
 		{4AD350E6-E296-43EF-9FEA-CB70358467E4}.Release|x86.Build.0 = Release|x86
 		{01C3C379-C816-4779-942D-0263763F8EA5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{01C3C379-C816-4779-942D-0263763F8EA5}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{01C3C379-C816-4779-942D-0263763F8EA5}.Debug|x86.ActiveCfg = Debug|x86
 		{01C3C379-C816-4779-942D-0263763F8EA5}.Debug|x86.Build.0 = Debug|x86
 		{01C3C379-C816-4779-942D-0263763F8EA5}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -64,7 +61,6 @@ Global
 		{01C3C379-C816-4779-942D-0263763F8EA5}.Release|x86.ActiveCfg = Release|x86
 		{01C3C379-C816-4779-942D-0263763F8EA5}.Release|x86.Build.0 = Release|x86
 		{470C034F-1F1F-499C-9499-DC00B9EEEDE9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{470C034F-1F1F-499C-9499-DC00B9EEEDE9}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{470C034F-1F1F-499C-9499-DC00B9EEEDE9}.Debug|x86.ActiveCfg = Debug|x86
 		{470C034F-1F1F-499C-9499-DC00B9EEEDE9}.Debug|x86.Build.0 = Debug|x86
 		{470C034F-1F1F-499C-9499-DC00B9EEEDE9}.Release|Any CPU.ActiveCfg = Release|Any CPU
@@ -72,7 +68,6 @@ Global
 		{470C034F-1F1F-499C-9499-DC00B9EEEDE9}.Release|x86.ActiveCfg = Release|x86
 		{470C034F-1F1F-499C-9499-DC00B9EEEDE9}.Release|x86.Build.0 = Release|x86
 		{F4F82CCE-2E13-441B-939C-63CF2343B1C9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{F4F82CCE-2E13-441B-939C-63CF2343B1C9}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F4F82CCE-2E13-441B-939C-63CF2343B1C9}.Debug|x86.ActiveCfg = Debug|x86
 		{F4F82CCE-2E13-441B-939C-63CF2343B1C9}.Debug|x86.Build.0 = Debug|x86
 		{F4F82CCE-2E13-441B-939C-63CF2343B1C9}.Release|Any CPU.ActiveCfg = Release|Any CPU