Easilly adding Operators with priorities

Author: Sébastien Geiser

CodingSeb.ExpressionEvaluator.Tests/ExpressionEvaluatorTests.cs

@@ -1828,7 +1828,43 @@ void Evaluator_PreEvaluateVariable(object sender, VariablePreEvaluationEventArg
                     .SetCategory("inherits ExpressionEvaluator")
                     .SetCategory("Custom operators");
 
+                XExpressionEvaluator2.StaticInit();
+                ExpressionEvaluator xExpressionEvaluator2 = new XExpressionEvaluator2();
 
+                yield return new TestCaseData(xExpressionEvaluator2
+                    , "1#", null)
+                    .Returns(1)
+                    .SetCategory("ExpressionEvaluator extend")
+                    .SetCategory("inherits ExpressionEvaluator")
+                    .SetCategory("Custom operators");
+
+                yield return new TestCaseData(xExpressionEvaluator2
+                    , "2#", null)
+                    .Returns(0.25)
+                    .SetCategory("ExpressionEvaluator extend")
+                    .SetCategory("inherits ExpressionEvaluator")
+                    .SetCategory("Custom operators");
+
+                yield return new TestCaseData(xExpressionEvaluator2
+                    , "-4# - 6", null)
+                    .Returns(250)
+                    .SetCategory("ExpressionEvaluator extend")
+                    .SetCategory("inherits ExpressionEvaluator")
+                    .SetCategory("Custom operators");
+
+                yield return new TestCaseData(xExpressionEvaluator2
+                    , "1 love 2", null)
+                    .Returns(6)
+                    .SetCategory("ExpressionEvaluator extend")
+                    .SetCategory("inherits ExpressionEvaluator")
+                    .SetCategory("Custom operators");
+
+                yield return new TestCaseData(xExpressionEvaluator2
+                    , "1 love 2 >> 1", null)
+                    .Returns(3)
+                    .SetCategory("ExpressionEvaluator extend")
+                    .SetCategory("inherits ExpressionEvaluator")
+                    .SetCategory("Custom operators");
 
 
                 #endregion

CodingSeb.ExpressionEvaluator.Tests/TestsUtils/XExpressionEvaluator2.cs

@@ -1,7 +1,18 @@
-namespace CodingSeb.ExpressionEvaluator.Tests
+using System;
+
+namespace CodingSeb.ExpressionEvaluator.Tests
 {
     public class XExpressionEvaluator2 : ExpressionEvaluator
     {
+        public static void StaticInit()
+        {
+            leftOperandOnlyOperatorsEvaluationDictionary.Add(XExpressionOperator2.Sharp);
+
+            operatorsEvaluations
+                .AddOperatorEvaluationAtNewLevelAfter(XExpressionOperator2.Sharp, (left, _) => Math.Pow(left, -left), ExpressionOperator.UnaryPlus)
+                .AddOperatorEvaluationAtLevelOf(XExpressionOperator2.Love, (left, right) => (left | right) << 1, ExpressionOperator.ShiftBitsLeft);
+        }
+
         protected override void Init()
         {
             operatorsDictionary.Add("#", XExpressionOperator2.Sharp);

CodingSeb.ExpressionEvaluator/ExpressionEvaluator.cs

@@ -198,14 +198,14 @@ private enum TryBlockEvaluatedState
             { "??", ExpressionOperator.NullCoalescing },
         };
 
-        protected static readonly IDictionary<ExpressionOperator, bool> leftOperandOnlyOperatorsEvaluationDictionary = new Dictionary<ExpressionOperator, bool>();
+        protected static readonly IList<ExpressionOperator> leftOperandOnlyOperatorsEvaluationDictionary = new List<ExpressionOperator>();
 
-        protected static readonly IDictionary<ExpressionOperator, bool> rightOperandOnlyOperatorsEvaluationDictionary = new Dictionary<ExpressionOperator, bool>()
+        protected static readonly IList<ExpressionOperator> rightOperandOnlyOperatorsEvaluationDictionary = new List<ExpressionOperator>()
         {
-            {ExpressionOperator.LogicalNegation, true },
-            {ExpressionOperator.BitwiseComplement, true },
-            {ExpressionOperator.UnaryPlus, true },
-            {ExpressionOperator.UnaryMinus, true }
+            ExpressionOperator.LogicalNegation,
+            ExpressionOperator.BitwiseComplement,
+            ExpressionOperator.UnaryPlus,
+            ExpressionOperator.UnaryMinus
         };
 
         protected static readonly IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> operatorsEvaluations =
@@ -2631,13 +2631,13 @@ protected virtual object ProcessStack(Stack<object> stack)
 
                         if ((list[i] as ExpressionOperator) == eOp)
                         {
-                            if (rightOperandOnlyOperatorsEvaluationDictionary.ContainsKey(eOp))
+                            if (rightOperandOnlyOperatorsEvaluationDictionary.Contains(eOp))
                             {
                                 list[i] = operatorEvalutationsDict[eOp](null, (dynamic)list[i - 1]);
                                 list.RemoveAt(i - 1);
                                 break;
                             }
-                            else if (leftOperandOnlyOperatorsEvaluationDictionary.ContainsKey(eOp))
+                            else if (leftOperandOnlyOperatorsEvaluationDictionary.Contains(eOp))
                             {
                                 list[i] = operatorEvalutationsDict[eOp]((dynamic)list[i + 1], null);
                                 list.RemoveAt(i + 1);
@@ -3362,6 +3362,8 @@ public enum OptionOnNoReturnKeywordFoundInScriptAction
 
     #region ExpressionEvaluator linked public classes (specific Exceptions, EventArgs and Operators)
 
+    #region Operators Management
+
     public partial class ExpressionOperator : IEquatable<ExpressionOperator>
     {
         protected static uint indexer = 0;
@@ -3421,6 +3423,64 @@ public bool Equals(ExpressionOperator otherOperator)
         }
     }
 
+    public static partial class OperatorsEvaluationsExtensions
+    {
+        public static IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> AddOperatorEvaluationAtLevelOf(this IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> operatorsEvaluations, ExpressionOperator operatorToAdd, Func<dynamic, dynamic, object> evaluation, ExpressionOperator levelOfThisOperator)
+        {
+            operatorsEvaluations
+                .First(dict => dict.ContainsKey(levelOfThisOperator))
+                .Add(operatorToAdd, evaluation);
+
+            return operatorsEvaluations;
+        }
+
+        public static IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> AddOperatorEvaluationAtLevel(this IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> operatorsEvaluations, ExpressionOperator operatorToAdd, Func<dynamic, dynamic, object> evaluation, int level)
+        {
+            operatorsEvaluations[level]
+                .Add(operatorToAdd, evaluation);
+
+            return operatorsEvaluations;
+        }
+
+        public static IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> AddOperatorEvaluationAtNewLevelAfter(this IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> operatorsEvaluations, ExpressionOperator operatorToAdd, Func<dynamic, dynamic, object> evaluation, ExpressionOperator levelOfThisOperator)
+        {
+            int level = operatorsEvaluations
+                .IndexOf(operatorsEvaluations.First(dict => dict.ContainsKey(levelOfThisOperator)));
+
+            operatorsEvaluations
+                .Insert(level + 1, new Dictionary<ExpressionOperator, Func<dynamic, dynamic, object>> { { operatorToAdd, evaluation } });
+
+            return operatorsEvaluations;
+        }
+
+        public static IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> AddOperatorEvaluationAtNewLevelBefore(this IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> operatorsEvaluations, ExpressionOperator operatorToAdd, Func<dynamic, dynamic, object> evaluation, ExpressionOperator levelOfThisOperator)
+        {
+            int level = operatorsEvaluations
+                .IndexOf(operatorsEvaluations.First(dict => dict.ContainsKey(levelOfThisOperator)));
+
+            operatorsEvaluations
+                .Insert(level, new Dictionary<ExpressionOperator, Func<dynamic, dynamic, object>> { { operatorToAdd, evaluation } });
+
+            return operatorsEvaluations;
+        }
+
+        public static IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> AddOperatorEvaluationAtNewLevel(this IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> operatorsEvaluations, ExpressionOperator operatorToAdd, Func<dynamic, dynamic, object> evaluation, int level)
+        {
+            operatorsEvaluations
+                .Insert(level, new Dictionary<ExpressionOperator, Func<dynamic, dynamic, object>> { { operatorToAdd, evaluation } });
+
+            return operatorsEvaluations;
+        }
+
+        public static IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> RemoveOperatorEvaluation(this IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> operatorsEvaluations, ExpressionOperator operatorToRemove)
+        {
+            operatorsEvaluations.First(dict => dict.ContainsKey(operatorToRemove)).Remove(operatorToRemove);
+
+            return operatorsEvaluations;
+        }
+    }
+
+    #endregion
 
     public partial class ClassOrEnumType
     {