NTERA/NTERA.Engine/Runtime/EraRuntime.cs

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

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>();

		protected List<FunctionDefinition> TotalProcedureDefinitions = new List<FunctionDefinition>(BaseDefinitions.DefaultGlobalFunctions);

		public EraRuntime(IExecutionProvider executionProvider)
		{
			ExecutionProvider = executionProvider;

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

		public bool Initialize(IConsole console)
		{
			Console = console;
			return true;
		}

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

			try
			{
				Call(ExecutionProvider.DefinedProcedures.First(x => x.Name == "SYSTEM_TITLE"));
			}
			catch (Exception ex)
			{
				Console.PrintSystemLine($"Unhandled exception: {ex.Message}");
				Console.PrintSystemLine("Stack trace:");

				foreach (var stackMember in ExecutionStack)
					Console.PrintSystemLine($"  - @{stackMember.SelfDefinition.Name} ({stackMember.SelfDefinition.Position} > {stackMember.SelfDefinition.Filename})");

				throw;
			}

			System.Threading.Thread.Sleep(-1);
		}

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

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

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

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

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

			var context = new StackFrame
			{
				SelfDefinition = function,
				GlobalVariables = globalVariables,
				LocalVariables = localVariables
			};

			ExecutionResult result;

			ExecutionStack.Push(context);

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

				result = 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 paramVariable = ComputeVariable(context, parameter.Name);
							
						paramVariable[parameter.Index] = parameters[index];
					}
				}

				var executionContents = ExecutionProvider.GetExecutionNodes(function);

				result = ExecuteSet(context, executionContents.ToList());
			}

			ExecutionStack.Pop();

			return result;
		}

		public ExecutionResult ExecuteSet(StackFrame context, IList<ExecutionNode> nodes)
		{
			for (int index = 0; index < nodes.Count; index++)
			{
				ExecutionNode node = nodes[index];

				if (node.Type == "statement")
				{
					if (node["name"].Equals("FOR", StringComparison.OrdinalIgnoreCase))
					{
						int endIndex = -1;
						int forLevel = 0;

						for (int subIndex = index + 1; subIndex < nodes.Count; subIndex++)
						{
							ExecutionNode subNode = nodes[subIndex];

							if (subNode.Type != "statement")
								continue;

							if (subNode["name"].Equals("FOR", StringComparison.OrdinalIgnoreCase))
								forLevel++;

							if (subNode["name"].Equals("NEXT", StringComparison.OrdinalIgnoreCase))
							{
								if (forLevel == 0)
								{
									endIndex = subIndex;
									break;
								}

								forLevel--;
							}
						}

						if (endIndex == -1)
							throw new EraRuntimeException("Could not find matching NEXT for FOR statement");

						//string variableName = 

						//for (context.LocalVariables[])
						ExecuteSet(context, nodes.Skip(index).Take(endIndex - index).ToArray());

						index = endIndex;
						continue;
					}
				}

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

				ExecuteNode(context, node);
			}

			return ExecutionResult.None;
		}

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

					if (!Base.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}'");

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

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

					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.LocalVariables.TryGetValue(variableName, out var variable)
				|| context.GlobalVariables.TryGetValue(variableName, out variable))
				return variable;

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

		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}'");

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

					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;
						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;
							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)
		{
			throw new NotImplementedException();
		}

		public void InputInteger(long input)
		{
			throw new NotImplementedException();
		}

		public void InputSystemInteger(long input)
		{
			throw new NotImplementedException();
		}

		public CroppedImage GetImage(string name)
		{
			var bitmap = new Bitmap(@"M:\era\eraSemifullTest\resources\bbb.png");
			return new CroppedImage(name, bitmap, new Rectangle(Point.Empty, bitmap.Size), false);
		}
	}
}