NTERA/NTERA.Engine/Runtime/EraRuntime.cs

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading;
using NTERA.Core;
using NTERA.EmuEra.Game.EraEmu.Content;
using NTERA.Engine.Compiler;
using NTERA.Engine.Runtime.Base;

namespace NTERA.Engine.Runtime
{
	public class EraRuntime : IScriptEngine
	{
		public IExecutionProvider ExecutionProvider { get; }
		public IConsole Console { get; protected set; }

		public Stack<StackFrame> ExecutionStack { get; } = new Stack<StackFrame>();
		public Stack<ExecutionResult> ExecutionResultStack { get; } = new Stack<ExecutionResult>();

		public List<FunctionDefinition> TotalProcedureDefinitions { get; } = new List<FunctionDefinition>(BaseDefinitions.DefaultGlobalFunctions);
		public Dictionary<string, Variable> GlobalVariables { get; } = new Dictionary<string, Variable>();


		public Value LastInputValue { get; protected set; }
		public AutoResetEvent InputResetEvent { get; } = new AutoResetEvent(false);

		public bool IgnoreErrors = false;

		public EraRuntime(IExecutionProvider executionProvider, bool ignoreErrors)
		{
			ExecutionProvider = executionProvider;
			IgnoreErrors = ignoreErrors;
		}

		public bool Initialize(IConsole console)
		{
			Console = console;

			ExecutionStack.Clear();
			ExecutionResultStack.Clear();
			GlobalVariables.Clear();

			ExecutionProvider.Initialize(console);

			TotalProcedureDefinitions.Clear();
			TotalProcedureDefinitions.AddRange(ExecutionProvider.DefinedProcedures);
			TotalProcedureDefinitions.AddRange(BaseDefinitions.DefaultGlobalFunctions);

			foreach (var variable in BaseDefinitions.DefaultGlobalVariables)
			{
				var globalVariable = new Variable(variable.Name, variable.ValueType)
				{
					[0] = variable.CalculatedValue
				};

				GlobalVariables.Add(variable.Name, globalVariable);
			}

			foreach (var variable in ExecutionProvider.DefinedConstants)
			{
				var globalVariable = new Variable(variable.Name, variable.ValueType)
				{
					[0] = variable.CalculatedValue
				};

				GlobalVariables.Add(variable.Name, globalVariable);
			}


			foreach (var kv in Variables.StaticVariables)
			{
				GlobalVariables[kv.Key.Name] = new DynamicVariable(kv.Key.Name, kv.Key.Type, this, kv.Value);
			}

			return true;
		}

		public void Reset()
		{
			ExecutionStack.Clear();
			ExecutionResultStack.Clear();
			GlobalVariables.Clear();
		}

		private void PrintStackTrace(bool toSystemConsoleOnly)
		{
			if (!toSystemConsoleOnly)
				Console.PrintError("Stack trace:");

			foreach (var stackMember in ExecutionStack)
			{
				string name = stackMember.IsAnonymous ? "<anonymous>" : $"@{stackMember.SelfDefinition.Name}";
				string msg = $"  - {name} ({stackMember.SelfDefinition.Position} > {stackMember.SelfDefinition.Filename})";

				System.Console.WriteLine(msg);

				if (!toSystemConsoleOnly)
					Console.PrintError(msg);
			}
		}

		public void Start()
		{
			Console.PrintSystemLine("EraJIT x64 0.0.0.0");
			Console.PrintSystemLine("");

			try
			{
				Call(ExecutionProvider.DefinedProcedures.First(x => x.Name == "SYSTEM_TITLE"));

				while (ExecutionStack.Count > 0)
				{
					ExecuteSet();
				}
			}
			catch (Exception ex)
			{
				Console.PrintError($"Unhandled exception: {ex.Message.Replace("\r\n", " ")}");
				PrintStackTrace(false);

				throw;
			}

			Thread.Sleep(-1);
		}

		public void Call(FunctionDefinition function, IList<Parameter> parameters = null)
		{
			var localVariables = new Dictionary<string, Variable>();

			foreach (var variable in function.Variables)
			{
				var localVariable = new Variable(variable.Name, variable.ValueType)
				{
					[0] = variable.CalculatedValue
				};

				localVariables.Add(variable.Name, localVariable);
			}

			foreach (var variable in GlobalVariables)
			{
				localVariables.Add(variable.Key, variable.Value);
			}

			var newContext = new StackFrame
			{
				SelfDefinition = function,
				Variables = localVariables
			};

			if (function.Filename == "__GLOBAL")
			{
				var resultValue = Functions.StaticFunctions[function.Name].Invoke(this, newContext, parameters);

				ExecutionResultStack.Push(new ExecutionResult(ExecutionResultType.FunctionReturn, resultValue));
			}
			else
			{
				if (parameters != null)
				{
					for (var index = 0; index < parameters.Count; index++)
					{
						FunctionParameter parameter;

						if (index < function.Parameters.Length)
							parameter = function.Parameters[index];
						else if (index >= function.Parameters.Length && function.Parameters.Last().IsArrayParameter)
							parameter = function.Parameters.Last();
						else
							throw new EraRuntimeException($"Unable to assign parameter #{index + 1}");


						var localVariable = function.Variables.FirstOrDefault(x => x.Name == parameter.Name);

						if (localVariable != null && localVariable.VariableType.HasFlag(VariableType.Reference))
						{
							if (parameters[index].BackingVariable == null)
								throw new EraRuntimeException("Expected a variable to pass through as REF");

							newContext.Variables[localVariable.Name] = parameters[index].BackingVariable;
						}
						else
						{
							var paramVariable = ComputeVariable(newContext, parameter.Name);
							paramVariable[parameter.Index] = parameters[index];
						}
					}
				}


				newContext.ExecutionNodes = ExecutionProvider.GetExecutionNodes(function).ToList();

				ExecutionStack.Push(newContext);
			}
		}

		public void ExecuteSet()
		{
			var context = ExecutionStack.Peek();

			if (context.ExecutionIndex >= context.ExecutionNodes.Count)
			{
				if (!context.IsAnonymous || context.AnonymousExitCondition?.Invoke(context) != false)
				{
					ExecutionStack.Pop();

					if (!context.IsAnonymous && context.SelfDefinition.IsReturnFunction)
						throw new EraRuntimeException("Function did not return a value");

					return;
				}
			}

			ExecutionNode node = context.ExecutionNodes[context.ExecutionIndex++];

			if (node.Type == "for")
			{
				ExecutionNode startContext = node.GetSubtype("start-context");

				var iterationVariable = ComputeVariable(context, startContext[0], out var iterationIndex);

				var beginNumber = ComputeExpression(context, startContext[1]);
				var endNumber = ComputeExpression(context, startContext[2]);

				iterationVariable[iterationIndex] = beginNumber;

				var newContext = context.Clone(node.Skip(2).ToList());

				newContext.AnonymousExitCondition = frame =>
				{
					iterationVariable[iterationIndex]++;

					if (iterationVariable[iterationIndex] >= endNumber)
						return true;

					frame.ExecutionIndex = 0;
					return false;
				};

				ExecutionStack.Push(newContext);

				return;
			}

			if (node.Type == "do")
			{
				ExecutionNode endContext = node.GetSubtype("end-context");

				var loopVariable = ComputeVariable(context, endContext[0], out var loopIndex);

				var newContext = context.Clone(node.Skip(2).ToList());

				newContext.AnonymousExitCondition = frame =>
				{
					if (!loopVariable[loopIndex])
						return true;

					frame.ExecutionIndex = 0;
					return false;
				};

				ExecutionStack.Push(newContext);

				return;
			}

			if (node.Type == "select")
			{
				ExecutionNode loopContext = node.GetSubtype("start-context");

				var selectVariable = ComputeVariable(context, loopContext[0], out var selectIndex);
				var computedValue = selectVariable[selectIndex];

				var caseNode = node.SubNodes
				               .Skip(2)
							   .Where(n => n.Type.Equals("case", StringComparison.OrdinalIgnoreCase))
							   .FirstOrDefault(n =>
				{
					return n.SubNodes.Any(y =>
					{
						if (y.Type.Equals("case-exact"))
						{
							return ComputeExpression(context, y[0]) == computedValue;
						}

						if (y.Type.Equals("case-to"))
						{
							return ComputeExpression(context, y[0]) <= computedValue
								&& ComputeExpression(context, y[1]) >= computedValue;
						}

						throw new EraRuntimeException($"Unknown case type '{y.Type}'");
					});
				});

				if (caseNode == null)
					return;

				var nodeList = node.SubNodes
								   .SkipWhile(x => x != caseNode)
								   .Skip(1)
								   .TakeWhile(x => !x.Type.Equals("case", StringComparison.OrdinalIgnoreCase))
								   .ToList();

				var newContext = context.Clone(nodeList);

				ExecutionStack.Push(newContext);

				return;
			}

			if (node.Type == "result")
			{
				ExecutionResultStack.Push(new ExecutionResult(ExecutionResultType.FunctionReturn, ComputeExpression(context, node.Single())));

				return;
			}


			try
			{
				ExecuteNode(context, node);
			}
			catch (Exception ex)
			{
				if (!IgnoreErrors)
					throw;

				System.Console.Write($"Error: {ex.Message}\n");
				PrintStackTrace(true);
			}
		}

		public void ExecuteNode(StackFrame context, ExecutionNode node)
		{
			switch (node.Type)
			{
				case "statement":
					string statement = node["name"];

					if (!Keywords.StaticKeywords.TryGetValue(statement, out var keywordAction))
						throw new EraRuntimeException($"Unknown statement: '{statement}'");

					keywordAction(this, context, node);

					return;

				case "assignment":
					Variable variable = ComputeVariable(context, node.GetSubtype("variable"), out var index);

					variable[index] = ComputeExpression(context, node.GetSubtype("value").Single());

					return;

				case "call":
					string procedureName = node["target"];
					var procedure = TotalProcedureDefinitions.FirstOrDefault(func => !func.IsReturnFunction && func.Name.Equals(procedureName, StringComparison.OrdinalIgnoreCase));

					if (procedure == null)
						throw new EraRuntimeException($"Unknown procedure: '{procedureName}'");

					Call(procedure, node.GetSubtype("parameters").Select(x => ComputeParameter(context, x)).ToArray());

					return;

				case "anchor":
					//for now, anchors are explicit types and not attached to ordinary nodes
					return;

				default:
					throw new EraRuntimeException($"Unknown node type: '{node.Type}'");
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Variable ComputeVariable(StackFrame context, ExecutionNode variableNode, out int[] index)
		{
			string variableName = variableNode["name"];
			index = new[] { 0 };

			if (variableNode.SubNodes.Any(x => x.Type == "index"))
			{
				ExecutionNode indexNode = variableNode.GetSubtype("index");

				index = indexNode.SubNodes.Select(x => (int)ComputeExpression(context, x)).ToArray();
			}

			return ComputeVariable(context, variableName);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Variable ComputeVariable(StackFrame context, string variableName)
		{
			if (context.Variables.TryGetValue(variableName, out var variable))
				return variable;

			throw new EraRuntimeException($"Unable to retrieve variable '{variableName}'");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Parameter ComputeParameter(StackFrame context, ExecutionNode variableNode)
		{
			if (variableNode.Type == "variable")
			{
				var variable = ComputeVariable(context, variableNode, out int[] index);

				return new Parameter(variable[index], variable, index);
			}

			return new Parameter(ComputeExpression(context, variableNode));
		}

		public Value ComputeExpression(StackFrame context, ExecutionNode expressionNode)
		{
			switch (expressionNode.Type)
			{
				case "constant":
					ValueType type = (ValueType)Enum.Parse(typeof(ValueType), expressionNode["type"]);

					string strValue = expressionNode["value"];

					return type == ValueType.String ? (Value)strValue : (Value)double.Parse(strValue);

				case "variable":
					Variable variable = ComputeVariable(context, expressionNode, out var index);

					return variable[index];

				case "call":
					string functionName = expressionNode["target"];

					var function = TotalProcedureDefinitions.FirstOrDefault(func => func.IsReturnFunction && func.Name.Equals(functionName, StringComparison.OrdinalIgnoreCase));

					if (function == null)
						throw new EraRuntimeException($"Unknown function: '{functionName}'");

					int currentStackLevel = ExecutionStack.Count;

					Call(function, expressionNode.GetSubtype("parameters").Select(x => ComputeParameter(context, x)).ToArray());

					while (ExecutionStack.Count > currentStackLevel)
						ExecuteSet();

					var executionResult = ExecutionResultStack.Pop();

					if (executionResult.Type != ExecutionResultType.FunctionReturn || !executionResult.Result.HasValue)
						throw new EraRuntimeException($"Unexpected result from function '{functionName}': {executionResult.Type}");

					return executionResult.Result.Value;

				case "operation":
					bool isUnary = expressionNode.Metadata.ContainsKey("unary") && bool.Parse(expressionNode["unary"]);
					string operationType = expressionNode["type"];

					Token operatorToken;

					switch (operationType)
					{
						case "add":
							operatorToken = Token.Plus;
							break;
						case "subtract":
							operatorToken = Token.Minus;
							break;
						case "multiply":
							operatorToken = Token.Asterisk;
							break;
						case "Not":
							operatorToken = Token.Not;
							break;
						default: throw new EraRuntimeException($"Unknown operation type: '{operationType}'");
					}

					if (isUnary)
					{
						Value innerValue = ComputeExpression(context, expressionNode.Single());

						switch (operatorToken)
						{
							case Token.Plus: return innerValue;
							case Token.Minus: return innerValue * -1;
							case Token.Not: return !innerValue;
							default: throw new EraRuntimeException($"Unsupported unary operation type: '{operationType}'");
						}
					}

					var left = ComputeExpression(context, expressionNode[0]);
					var right = ComputeExpression(context, expressionNode[1]);

					return left.Operate(right, operatorToken);

				default:
					throw new EraRuntimeException($"Unknown expression type: '{expressionNode.Type}'");
			}
		}

		public void InputString(string input) => Input(input);

		public void InputInteger(long input) => Input(input);

		public void InputSystemInteger(long input) => Input(input);

		public void Input(Value value)
		{
			LastInputValue = value;
			InputResetEvent.Set();
		}

		public CroppedImage GetImage(string name)
		{
			var bitmap = ExecutionProvider.GetImage(name, out var definition);
			return new CroppedImage(name, bitmap, definition.Dimensions ?? new Rectangle(Point.Empty, bitmap.Size), false);
		}
	}
}