Files
serein-flow/Serein.Script/SereinScriptInterpreter.cs

533 lines
20 KiB
C#
Raw Normal View History

using Newtonsoft.Json.Linq;
using Serein.Library;
using Serein.Library.Api;
using Serein.Library.Utils;
using Serein.Script.Node;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Xml.Linq;
namespace Serein.Script
{
public sealed class SereinSciptException : Exception
{
//public ASTNode Node { get; }
public override string Message { get; }
public SereinSciptException(ASTNode node, string message)
{
//this.Node = node;
Message = $"异常信息 : {message} ,代码在第{node.Row}行: {node.Code.Trim()}";
}
}
public class SereinScriptInterpreter
{
/// <summary>
/// 定义的变量
/// </summary>
private Dictionary<string, object> _variables = new Dictionary<string, object>();
/// <summary>
/// 挂载的函数
/// </summary>
private static Dictionary<string, DelegateDetails> _functionTable = new Dictionary<string, DelegateDetails>();
/// <summary>
/// 挂载的函数调用的对象(用于函数需要实例才能调用的场景)
/// </summary>
private static Dictionary<string, Func<object>> _callFuncOfGetObjects = new Dictionary<string, Func<object>>();
/// <summary>
/// 定义的类型
/// </summary>
private static Dictionary<string, Type> _classDefinition = new Dictionary<string, Type>();
/// <summary>
/// 重置的变量
/// </summary>
public void ResetVar()
{
foreach (var nodeObj in _variables.Values)
{
if (nodeObj is not null)
{
if (typeof(IDisposable).IsAssignableFrom(nodeObj?.GetType()) && nodeObj is IDisposable disposable)
{
disposable?.Dispose();
}
}
else
{
}
}
_variables.Clear();
}
/// <summary>
/// 挂载函数
/// </summary>
/// <param name="functionName">函数名称</param>
/// <param name="methodInfo">方法信息</param>
public static void AddFunction(string functionName, MethodInfo methodInfo, Func<object>? callObj = null)
{
//if (!_functionTable.ContainsKey(functionName))
//{
// _functionTable[functionName] = new DelegateDetails(methodInfo);
//}
if(!methodInfo.IsStatic && callObj is null)
{
SereinEnv.WriteLine(InfoType.WARN, "函数挂载失败:试图挂载非静态的函数,但没有传入相应的获取实例的方法。");
return;
}
if(!methodInfo.IsStatic && callObj is not null)
{
// 静态函数不需要
_callFuncOfGetObjects.Add(functionName, callObj);
}
_functionTable[functionName] = new DelegateDetails(methodInfo);
}
/// <summary>
/// 挂载类型
/// </summary>
/// <param name="typeName">函数名称</param>
/// <param name="type">方法信息</param>
public static void AddClassType(Type type , string typeName = "")
{
if (string.IsNullOrEmpty(typeName))
{
typeName = type.Name;
}
if (!_classDefinition.ContainsKey(typeName))
{
_classDefinition[typeName] = type;
}
}
/// <summary>
/// 入口节点
/// </summary>
/// <param name="programNode"></param>
/// <returns></returns>
private async Task<object?> ExecutionProgramNodeAsync(ProgramNode programNode)
{
// 遍历 ProgramNode 中的所有语句并执行它们
foreach (var statement in programNode.Statements)
{
// 直接退出
if (statement is ReturnNode returnNode) // 遇到 Return 语句 提前退出
{
return await EvaluateAsync(statement);
}
else
{
await InterpretAsync(statement);
}
}
return null;
}
/// <summary>
/// 类型定义
/// </summary>
/// <param name="programNode"></param>
/// <returns></returns>
private void ExecutionClassTypeDefinitionNode(ClassTypeDefinitionNode classTypeDefinitionNode)
{
if (_classDefinition.ContainsKey(classTypeDefinitionNode.ClassName))
{
//SereinEnv.WriteLine(InfoType.WARN, $"异常信息 : 类型重复定义,代码在第{classTypeDefinitionNode.Row}行: {classTypeDefinitionNode.Code.Trim()}");
return;
}
var type = DynamicObjectHelper.CreateTypeWithProperties(classTypeDefinitionNode.Fields, classTypeDefinitionNode.ClassName);
_classDefinition[classTypeDefinitionNode.ClassName] = type; // 定义对象
}
/// <summary>
/// IF...ELSE... 语句块
/// </summary>
/// <param name="ifNode"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
private async Task ExecutionIfNodeAsync(IfNode ifNode)
{
var result = await EvaluateAsync(ifNode.Condition) ?? throw new SereinSciptException(ifNode, $"条件语句返回了 null");
if (result is not bool condition)
{
throw new SereinSciptException(ifNode, "条件语句返回值不为 bool 类型");
}
if (condition)
{
foreach (var trueNode in ifNode.TrueBranch)
{
await InterpretAsync(trueNode);
}
}
else
{
foreach (var falseNode in ifNode.FalseBranch)
{
await InterpretAsync(falseNode);
}
}
}
/// <summary>
/// WHILE(){...} 语句块
/// </summary>
/// <param name="whileNode"></param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
private async Task ExectutionWhileNodeAsync(WhileNode whileNode)
{
while (true)
{
var result = await EvaluateAsync(whileNode.Condition) ?? throw new SereinSciptException(whileNode, $"条件语句返回了 null");
if (result is not bool condition)
{
throw new SereinSciptException(whileNode, $"条件语句返回值不为 bool 类型(当前返回值类型为 {result.GetType()})");
}
if (!condition)
{
break;
}
foreach(var node in whileNode.Body)
{
await InterpretAsync(node);
}
}
}
/// <summary>
/// 操作节点
/// </summary>
/// <param name="assignmentNode"></param>
/// <returns></returns>
private async Task ExecutionAssignmentNodeAsync(AssignmentNode assignmentNode)
{
var tmp = await EvaluateAsync(assignmentNode.Value);
_variables[assignmentNode.Variable] = tmp;
}
private async Task<object> InterpretFunctionCallAsync(FunctionCallNode functionCallNode)
{
// 评估函数参数
var arguments = new object?[functionCallNode.Arguments.Count];
for (int i = 0; i < functionCallNode.Arguments.Count; i++)
{
ASTNode? arg = functionCallNode.Arguments[i];
arguments[i] = await EvaluateAsync(arg); // 评估每个参数
}
var funcName = functionCallNode.FunctionName;
object? instance = null; // 静态方法不需要传入实例所以可以传入null
// 查找并执行对应的函数
if (_functionTable.TryGetValue(funcName, out DelegateDetails? function))
{
if (!function.EmitMethodInfo.IsStatic)
{
if(_callFuncOfGetObjects.TryGetValue(funcName, out var action))
{
instance = action.Invoke();// 非静态的方法需要获取相应的实例
if (instance is null)
{
throw new SereinSciptException(functionCallNode, $"函数 {funcName} 尝试获取实例时返回了 null ");
}
}
else
{
throw new SereinSciptException(functionCallNode, $"挂载函数 {funcName} 时需要同时给定获取实例的 Func<object>");
}
}
var result = await function.InvokeAsync(instance,arguments);
return result;
}
else
{
throw new Exception($"Unknown function: {functionCallNode.FunctionName}");
}
}
public async Task<object?> InterpretAsync(ASTNode node)
{
if(node == null)
{
return null;
}
switch (node)
{
case ProgramNode programNode: // AST树入口
var scritResult = await ExecutionProgramNodeAsync(programNode);
return scritResult; // 遍历 ProgramNode 中的所有语句并执行它们
case ClassTypeDefinitionNode classTypeDefinitionNode: // 定义类型
ExecutionClassTypeDefinitionNode(classTypeDefinitionNode);
break;
case AssignmentNode assignment: // 出现在 = 右侧的表达式
await ExecutionAssignmentNodeAsync(assignment);
break;
case MemberAssignmentNode memberAssignmentNode: // 设置对象属性
await SetMemberValue(memberAssignmentNode);
break;
case MemberFunctionCallNode memberFunctionCallNode:
return await CallMemberFunction(memberFunctionCallNode);
break;
case IfNode ifNode: // 执行 if...else... 语句块
await ExecutionIfNodeAsync(ifNode);
break;
case WhileNode whileNode: // 循环语句块
await ExectutionWhileNodeAsync(whileNode);
break;
case FunctionCallNode functionCallNode: // 方法调用节点
return await InterpretFunctionCallAsync(functionCallNode);
case ReturnNode returnNode:
return await EvaluateAsync(returnNode);
default:
throw new SereinSciptException(node, "解释器 InterpretAsync() 未实现节点行为");
}
return null;
}
private async Task<object?> EvaluateAsync(ASTNode node)
{
if(node == null)
{
return null;
}
switch (node)
{
case NullNode nullNode:
return null;
case BooleanNode booleanNode:
return booleanNode.Value; // 返回数值
case NumberNode numberNode:
return numberNode.Value; // 返回数值
case StringNode stringNode:
return stringNode.Value; // 返回字符串值
case IdentifierNode identifierNode:
if (_variables.TryGetValue(identifierNode.Name, out var result))
{
//if(result == null)
//{
// throw new SereinSciptException(identifierNode, "尝试使用值为null的变量");
//}
return result; // 获取变量值
}
else
{
throw new SereinSciptException(identifierNode, "尝试使用未声明的变量");
}
case BinaryOperationNode binOpNode:
// 递归计算二元操作
var left = await EvaluateAsync(binOpNode.Left);
//if (left == null )
//{
// throw new SereinSciptException(binOpNode.Left, $"左值尝试使用 null");
//}
var right = await EvaluateAsync(binOpNode.Right);
//if (right == null)
//{
// throw new SereinSciptException(binOpNode.Right, "右值尝试使用计算 null");
//}
return EvaluateBinaryOperation(left, binOpNode.Operator, right);
case ObjectInstantiationNode objectInstantiationNode:
if (_classDefinition.TryGetValue(objectInstantiationNode.TypeName,out var type ))
{
object?[] args = new object[objectInstantiationNode.Arguments.Count];
for (int i = 0; i < objectInstantiationNode.Arguments.Count; i++)
{
var argNode = objectInstantiationNode.Arguments[i];
args[i] = await EvaluateAsync(argNode);
}
var obj = Activator.CreateInstance(type,args: args);// 创建对象
if (obj == null)
{
throw new SereinSciptException(objectInstantiationNode, $"类型创建失败\"{objectInstantiationNode.TypeName}\"");
}
return obj;
}
else
{
throw new SereinSciptException(objectInstantiationNode, $"使用了未定义的类型\"{objectInstantiationNode.TypeName}\"");
}
case FunctionCallNode callNode:
return await InterpretFunctionCallAsync(callNode); // 调用方法返回函数的返回值
case MemberAccessNode memberAccessNode:
return await GetValue(memberAccessNode);
case ReturnNode returnNode: //
return await EvaluateAsync(returnNode.Value); // 直接返回响应的内容
default:
throw new SereinSciptException(node, "解释器 EvaluateAsync() 未实现节点行为");
}
}
private object EvaluateBinaryOperation(object left, string op, object right)
{
// 根据运算符执行不同的运算
switch (op)
{
case "+":
if (left is string || right is string)
{
return left?.ToString() + right?.ToString(); // 字符串拼接
}
else if (left is int leftInt && right is int rightInt)
{
return leftInt + rightInt; // 整数加法
}
else if (left is long leftLong && right is long rightLong)
{
return leftLong + rightLong; // 整数加法
}
else if (left is double leftDouble && right is double rightDouble)
{
return leftDouble + rightDouble; // 整数加法
}
else
{
dynamic leftValue = Convert.ToDouble(left);
dynamic rightValue = Convert.ToDouble(right);
return leftValue + rightValue;
}
throw new Exception("Invalid types for + operator");
case "-":
return (int)left - (int)right;
case "*":
return (int)left * (int)right;
case "/":
return (int)left / (int)right;
case ">":
return (int)left > (int)right;
case "<":
return (int)left < (int)right;
case "==":
return Equals(left, right);
case "!=":
return !Equals(left, right);
default:
throw new NotImplementedException("未定义的操作符: " + op);
}
}
/// <summary>
/// 设置对象成员
/// </summary>
/// <param name="memberAssignmentNode"></param>
/// <returns></returns>
/// <exception cref="SereinSciptException"></exception>
public async Task SetMemberValue(MemberAssignmentNode memberAssignmentNode)
{
var target = await EvaluateAsync(memberAssignmentNode.Object);
var value = await EvaluateAsync(memberAssignmentNode.Value);
// 设置值
var lastMember = memberAssignmentNode.MemberName;
var lastProperty = target?.GetType().GetProperty(lastMember);
if (lastProperty is null)
{
var lastField = target?.GetType().GetRuntimeField(lastMember);
if (lastField is null)
{
throw new SereinSciptException(memberAssignmentNode, $"对象没有成员\"{memberAssignmentNode.MemberName}\"");
}
else
{
var convertedValue = Convert.ChangeType(value, lastField.FieldType);
lastField.SetValue(target, convertedValue);
}
}
else
{
var convertedValue = Convert.ChangeType(value, lastProperty.PropertyType);
lastProperty.SetValue(target, convertedValue);
}
}
/// <summary>
/// 获取对象成员
/// </summary>
/// <param name="memberAccessNode"></param>
/// <returns></returns>
/// <exception cref="SereinSciptException"></exception>
public async Task<object?> GetValue(MemberAccessNode memberAccessNode)
{
var target = await EvaluateAsync(memberAccessNode.Object);
var lastMember = memberAccessNode.MemberName;
var lastProperty = target?.GetType().GetProperty(lastMember);
if (lastProperty is null)
{
var lastField = target?.GetType().GetRuntimeField(lastMember);
if (lastField is null)
{
throw new SereinSciptException(memberAccessNode, $"对象没有成员\"{memberAccessNode.MemberName}\"");
}
else
{
return lastField.GetValue(target);
}
}
else
{
return lastProperty.GetValue(target);
}
}
/// <summary>
/// 缓存method委托
/// </summary>
private Dictionary<string, DelegateDetails> MethodToDelegateCaches { get; } = new Dictionary<string, DelegateDetails>();
public async Task<object?> CallMemberFunction(MemberFunctionCallNode memberFunctionCallNode)
{
var target = await EvaluateAsync(memberFunctionCallNode.Object);
var lastMember = memberFunctionCallNode.FunctionName;
var methodInfo = target?.GetType().GetMethod(lastMember) ?? throw new SereinSciptException(memberFunctionCallNode, $"对象没有方法\"{memberFunctionCallNode.FunctionName}\"");
if(!MethodToDelegateCaches.TryGetValue(methodInfo.Name, out DelegateDetails? delegateDetails))
{
delegateDetails = new DelegateDetails(methodInfo);
MethodToDelegateCaches[methodInfo.Name] = delegateDetails;
}
var arguments = new object?[memberFunctionCallNode.Arguments.Count];
for (int i = 0; i < memberFunctionCallNode.Arguments.Count; i++)
{
ASTNode? arg = memberFunctionCallNode.Arguments[i];
arguments[i] = await EvaluateAsync(arg); // 评估每个参数
}
return await delegateDetails.InvokeAsync(target, arguments);
}
}
}