EP RScript 仍存在一些问题, 但是能够运行

Convention/[RScript]/Parser/ExpressionParser.cs

@@ -0,0 +1,76 @@
+using Flee.PublicTypes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Convention.RScript.Parser
+{
+    public static class ExpressionExtension
+    {
+        public const double DefaultDoubleAccuracy = 1e-7;
+
+        public static bool IsClose(this double value1, double value2, double maximumAbsoluteError = DefaultDoubleAccuracy)
+        {
+            if (double.IsInfinity(value1) || double.IsInfinity(value2))
+            {
+                return Equals(value1, value2);
+            }
+
+            if (double.IsNaN(value1) || double.IsNaN(value2))
+            {
+                return false;
+            }
+
+            var delta = value1 - value2;
+            return !(delta > maximumAbsoluteError || delta < -maximumAbsoluteError);
+        }
+
+        public static bool IsCloseToZero(this double value, double maximumAbsoluteError = DefaultDoubleAccuracy)
+        {
+            return !(double.IsInfinity(value) || double.IsNaN(value) || value > maximumAbsoluteError || value < -maximumAbsoluteError);
+        }
+    }
+
+    public class ExpressionParser
+    {
+        public readonly ExpressionContext context;
+
+        public ExpressionParser(ExpressionContext context)
+        {
+            this.context = context;
+        }
+
+        private readonly Dictionary<string, IExpression> CompileGenericExpression = new();
+        private readonly Dictionary<string, IDynamicExpression> CompileDynamicExpression = new();
+
+        public void ClearCache()
+        {
+            CompileGenericExpression.Clear();
+            CompileDynamicExpression.Clear();
+        }
+
+        public T Evaluate<T>(string expression)
+        {
+            if (CompileGenericExpression.TryGetValue(expression, out var result))
+            {
+                return (result as IGenericExpression<T>).Evaluate();
+            }
+            var compile = context.CompileGeneric<T>(expression);
+            CompileGenericExpression[expression] = compile;
+            return compile.Evaluate();
+        }
+
+        public object Evaluate(string expression)
+        {
+            if (CompileDynamicExpression.TryGetValue(expression, out var result))
+            {
+                return result.Evaluate();
+            }
+            var compile = context.CompileDynamic(expression);
+            CompileDynamicExpression[expression] = compile;
+            return compile.Evaluate();
+        }
+    }
+}