Operators by sub types with virtual props that redirect static fields

Sébastien Geiser · Sébastien Geiser · commit 5f17d983f2ac · 2019-05-21T14:01:29.000+02:00
diff --git a/CodingSeb.ExpressionEvaluator.Tests/ExpressionEvaluatorTests.cs b/CodingSeb.ExpressionEvaluator.Tests/ExpressionEvaluatorTests.cs
@@ -1526,7 +1526,6 @@ public static IEnumerable<TestCaseData> TestCasesEvaluateWithSpecificEvaluator
                     .SetCategory("Options")
                     .SetCategory("Integer Numbers default types");
 
-
                 yield return new TestCaseData(new ExpressionEvaluator
                     {
                         OptionForceIntegerNumbersEvaluationsAsDoubleByDefault = false
@@ -1604,9 +1603,13 @@ public static IEnumerable<TestCaseData> TestCasesEvaluateWithSpecificEvaluator
                 void VariableEval(object sender, VariableEvaluationEventArg e)
                 {
                     if (e.Name.Equals("GetSpecifiedGenericTypesVar"))
+                    {
                         e.Value = e.EvaluateGenericTypes();
+                    }
                     else if (e.Name.Equals("myvar2"))
+                    {
                         e.Value = 50;
+                    }
                     else if (e.This is ClassOrEnumType classOrTypeName && classOrTypeName.Type == typeof(ClassForTest1) && e.Name.Equals("OnTheFlyStaticVar"))
                     {
                         e.Value = 10;
@@ -1616,7 +1619,9 @@ void VariableEval(object sender, VariableEvaluationEventArg e)
                 void FunctionEval(object sender, FunctionEvaluationEventArg e)
                 {
                     if (e.Name.Equals("GetSpecifiedGenericTypesFunc"))
+                    {
                         e.Value = e.EvaluateGenericTypes();
+                    }
                     else if (e.This is ClassOrEnumType classOrTypeName && classOrTypeName.Type == typeof(ClassForTest1) && e.Name.Equals("OnTheFlyStaticFunc"))
                     {
                         e.Value = 8;
@@ -1814,7 +1819,6 @@ void Evaluator_PreEvaluateVariable(object sender, VariablePreEvaluationEventArg
                     .SetCategory("inherits ExpressionEvaluator")
                     .SetCategory("Custom operators");
 
-
                 yield return new TestCaseData(xExpressionEvaluator1
                     , "true || true"
                     , new Func<Exception, object> (exception =>
@@ -1828,7 +1832,6 @@ void Evaluator_PreEvaluateVariable(object sender, VariablePreEvaluationEventArg
                     .SetCategory("inherits ExpressionEvaluator")
                     .SetCategory("Custom operators");
 
-                XExpressionEvaluator2.StaticInit();
                 ExpressionEvaluator xExpressionEvaluator2 = new XExpressionEvaluator2();
 
                 yield return new TestCaseData(xExpressionEvaluator2
@@ -1866,7 +1869,6 @@ void Evaluator_PreEvaluateVariable(object sender, VariablePreEvaluationEventArg
                     .SetCategory("inherits ExpressionEvaluator")
                     .SetCategory("Custom operators");
 
-
                 #endregion
 
                 #region bug resolution
@@ -1883,7 +1885,6 @@ void Evaluator_PreEvaluateVariable(object sender, VariablePreEvaluationEventArg
 
         #endregion
 
-
         [TestCaseSource(nameof(TestCasesEvaluateWithSpecificEvaluator))]
         public object EvaluateWithSpecificEvaluator(ExpressionEvaluator evaluator, string expression, Func<Exception, object> inCaseOfException)
         {
diff --git a/CodingSeb.ExpressionEvaluator.Tests/TestsUtils/XExpressionEvaluator2.cs b/CodingSeb.ExpressionEvaluator.Tests/TestsUtils/XExpressionEvaluator2.cs
@@ -1,17 +1,26 @@
 ﻿using System;
+using System.Collections.Generic;
+using System.Linq;
 
 namespace CodingSeb.ExpressionEvaluator.Tests
 {
     public class XExpressionEvaluator2 : ExpressionEvaluator
     {
-        public static void StaticInit()
-        {
-            leftOperandOnlyOperatorsEvaluationDictionary.Add(XExpressionOperator2.Sharp);
+        protected new static readonly IList<ExpressionOperator> leftOperandOnlyOperatorsEvaluationDictionary =
+            ExpressionEvaluator.leftOperandOnlyOperatorsEvaluationDictionary
+                .ToList()
+                .FluidAdd(XExpressionOperator2.Sharp);
+
+        //protected new static readonly IList<ExpressionOperator> rightOperandOnlyOperatorsEvaluationDictionary = new List<ExpressionOperator>(ExpressionEvaluator.rightOperandOnlyOperatorsEvaluationDictionary);
 
-            operatorsEvaluations
+        protected new static readonly IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> operatorsEvaluations =
+            ExpressionEvaluator.operatorsEvaluations
+                .Copy()
                 .AddOperatorEvaluationAtNewLevelAfter(XExpressionOperator2.Sharp, (left, _) => Math.Pow(left, -left), ExpressionOperator.UnaryPlus)
                 .AddOperatorEvaluationAtLevelOf(XExpressionOperator2.Love, (left, right) => (left | right) << 1, ExpressionOperator.ShiftBitsLeft);
-        }
+
+        protected override IList<ExpressionOperator> LeftOperandOnlyOperatorsEvaluationDictionary => leftOperandOnlyOperatorsEvaluationDictionary;
+        protected override IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> OperatorsEvaluations => operatorsEvaluations;
 
         protected override void Init()
         {
diff --git a/CodingSeb.ExpressionEvaluator/ExpressionEvaluator.cs b/CodingSeb.ExpressionEvaluator/ExpressionEvaluator.cs
@@ -208,6 +208,10 @@ private enum TryBlockEvaluatedState
             ExpressionOperator.UnaryMinus
         };
 
+        protected virtual IList<ExpressionOperator> LeftOperandOnlyOperatorsEvaluationDictionary => leftOperandOnlyOperatorsEvaluationDictionary;
+        protected virtual IList<ExpressionOperator> RightOperandOnlyOperatorsEvaluationDictionary => rightOperandOnlyOperatorsEvaluationDictionary;
+        protected virtual IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> OperatorsEvaluations => operatorsEvaluations;
+
         protected static readonly IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> operatorsEvaluations =
             new List<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>>()
         {
@@ -1287,7 +1291,6 @@ void forAction(int index)
                                 if (isContinue)
                                 {
                                     isContinue = false;
-                                    continue;
                                 }
                             }
                         }
@@ -1305,9 +1308,7 @@ void forAction(int index)
                             }
                             else
                             {
-                                dynamic collection = Evaluate(foreachParenthisEvaluationMatch.Groups["collection"].Value);
-
-                                foreach (dynamic foreachValue in collection)
+                                foreach (dynamic foreachValue in (dynamic)Evaluate(foreachParenthisEvaluationMatch.Groups["collection"].Value))
                                 {
                                     Variables[foreachParenthisEvaluationMatch.Groups["variableName"].Value] = foreachValue;
 
@@ -1847,7 +1848,9 @@ protected virtual bool EvaluateVarOrFunc(string expr, string restOfExpression, S
                                                     stack.Push(functionEvaluationEventArg.Value);
                                                 }
                                                 else
+                                                {
                                                     throw new ExpressionEvaluatorSyntaxErrorException($"[{objType}] object has no Method named \"{varFuncName}\".");
+                                                }
                                             }
                                         }
                                     }
@@ -2029,7 +2032,7 @@ protected virtual bool EvaluateVarOrFunc(string expr, string restOfExpression, S
                                             {
                                                 ExpressionOperator op = operatorsDictionary[varFuncMatch.Groups["assignmentPrefix"].Value];
 
-                                                varValue = operatorsEvaluations.ToList().Find(dict => dict.ContainsKey(op))[op](varValue, Evaluate(rightExpression));
+                                                varValue = OperatorsEvaluations.ToList().Find(dict => dict.ContainsKey(op))[op](varValue, Evaluate(rightExpression));
                                             }
                                             else
                                             {
@@ -2137,7 +2140,7 @@ protected virtual bool EvaluateVarOrFunc(string expr, string restOfExpression, S
 
                                         ExpressionOperator op = operatorsDictionary[varFuncMatch.Groups["assignmentPrefix"].Value];
 
-                                        cusVarValueToPush = operatorsEvaluations.ToList().Find(dict => dict.ContainsKey(op))[op](cusVarValueToPush, Evaluate(rightExpression));
+                                        cusVarValueToPush = OperatorsEvaluations.ToList().Find(dict => dict.ContainsKey(op))[op](cusVarValueToPush, Evaluate(rightExpression));
                                     }
                                     else
                                     {
@@ -2455,9 +2458,9 @@ protected virtual bool EvaluateIndexing(string expr, string s, Stack<object> sta
                         {
                             ExpressionOperator prefixOp = operatorsDictionary[assignationOrPostFixOperatorMatch.Groups["assignmentPrefix"].Value];
 
-                            valueToPush = operatorsEvaluations[0][op](left, right);
+                            valueToPush = OperatorsEvaluations[0][op](left, right);
 
-                            valueToPush = operatorsEvaluations.ToList().Find(dict => dict.ContainsKey(prefixOp))[prefixOp](valueToPush, Evaluate(rightExpression));
+                            valueToPush = OperatorsEvaluations.ToList().Find(dict => dict.ContainsKey(prefixOp))[prefixOp](valueToPush, Evaluate(rightExpression));
                         }
                         else
                         {
@@ -2474,7 +2477,7 @@ protected virtual bool EvaluateIndexing(string expr, string s, Stack<object> sta
                 }
                 else
                 {
-                    valueToPush = operatorsEvaluations[0][op](left, right);
+                    valueToPush = OperatorsEvaluations[0][op](left, right);
                 }
 
                 stack.Push(valueToPush);
@@ -2621,7 +2624,7 @@ protected virtual object ProcessStack(Stack<object> stack)
                 .Select(e => e is ValueTypeNestingTrace valueTypeNestingTrace ? valueTypeNestingTrace.Value : e)
                 .ToList();
 
-            operatorsEvaluations.ToList().ForEach((IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>> operatorEvalutationsDict) =>
+            OperatorsEvaluations.ToList().ForEach((IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>> operatorEvalutationsDict) =>
             {
                 for (int i = list.Count - 1; i >= 0; i--)
                 {
@@ -2631,13 +2634,13 @@ protected virtual object ProcessStack(Stack<object> stack)
 
                         if ((list[i] as ExpressionOperator) == eOp)
                         {
-                            if (rightOperandOnlyOperatorsEvaluationDictionary.Contains(eOp))
+                            if (RightOperandOnlyOperatorsEvaluationDictionary.Contains(eOp))
                             {
                                 list[i] = operatorEvalutationsDict[eOp](null, (dynamic)list[i - 1]);
                                 list.RemoveAt(i - 1);
                                 break;
                             }
-                            else if (leftOperandOnlyOperatorsEvaluationDictionary.Contains(eOp))
+                            else if (LeftOperandOnlyOperatorsEvaluationDictionary.Contains(eOp))
                             {
                                 list[i] = operatorEvalutationsDict[eOp]((dynamic)list[i + 1], null);
                                 list.RemoveAt(i + 1);
@@ -2708,6 +2711,7 @@ public string RemoveComments(string scriptWithComments)
         #region Utils methods for parsing and interpretation
 
         private delegate dynamic InternalDelegate(params dynamic[] args);
+
         private bool GetLambdaExpression(string expr, Stack<object> stack)
         {
             Match lambdaExpressionMatch = lambdaExpressionRegex.Match(expr);
@@ -3264,6 +3268,7 @@ public DelegateEncaps(InternalDelegate lambda)
             {
                 this.lambda = lambda;
             }
+
             public DelegateEncaps(object target, MethodInfo methodInfo)
             {
                 this.target = target;
@@ -3280,66 +3285,82 @@ public TResult Func0<TResult>()
             {
                 return (TResult)lambda();
             }
+
             public TResult Func1<T, TResult>(T arg)
             {
                 return (TResult)lambda(arg);
             }
+
             public TResult Func2<T1, T2, TResult>(T1 arg1, T2 arg2)
             {
                 return (TResult)lambda(arg1, arg2);
             }
+
             public TResult Func3<T1, T2, T3, TResult>(T1 arg1, T2 arg2, T3 arg3)
             {
                 return (TResult)lambda(arg1, arg2, arg3);
             }
+
             public TResult Func4<T1, T2, T3, T4, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
             {
                 return (TResult)lambda(arg1, arg2, arg3, arg4);
             }
+
             public TResult Func5<T1, T2, T3, T4, T5, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
             {
                 return (TResult)lambda(arg1, arg2, arg3, arg4, arg5);
             }
+
             public TResult Func6<T1, T2, T3, T4, T5, T6, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
             {
                 return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6);
             }
+
             public TResult Func7<T1, T2, T3, T4, T5, T6, T7, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
             {
                 return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
             }
+
             public TResult Func8<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
             {
                 return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
             }
+
             public TResult Func9<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
             {
                 return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
             }
+
             public TResult Func10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
             {
                 return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
             }
+
             public TResult Func11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
             {
                 return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
             }
+
             public TResult Func12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
             {
                 return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
             }
+
             public TResult Func13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
             {
                 return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
             }
+
             public TResult Func14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
             {
                 return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
             }
+
             public TResult Func15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)
             {
                 return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
             }
+
             public TResult Func16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)
             {
                 return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16);
@@ -3425,6 +3446,13 @@ public bool Equals(ExpressionOperator otherOperator)
 
     public static partial class OperatorsEvaluationsExtensions
     {
+        public static IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> Copy(this IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> operatorsEvaluations)
+        {
+            return (IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>>)operatorsEvaluations
+                .Select(dic => (IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>)new Dictionary<ExpressionOperator, Func<dynamic, dynamic, object>>(dic))
+                .ToList();
+        }
+
         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
@@ -3478,6 +3506,20 @@ public static IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, objec
 
             return operatorsEvaluations;
         }
+
+        public static IList<ExpressionOperator> FluidAdd(this IList<ExpressionOperator> listOfOperator, ExpressionOperator operatorToAdd)
+        {
+            listOfOperator.Add(operatorToAdd);
+
+            return listOfOperator;
+        }
+
+        public static IList<ExpressionOperator> FluidRemove(this IList<ExpressionOperator> listOfOperator, ExpressionOperator operatorToRemove)
+        {
+            listOfOperator.Remove(operatorToRemove);
+
+            return listOfOperator;
+        }
     }
 
     #endregion
diff --git a/TryWindow/Properties/AssemblyInfo.cs b/TryWindow/Properties/AssemblyInfo.cs
@@ -30,7 +30,6 @@
 
 //[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)]
 
-
 [assembly: ThemeInfo(
     ResourceDictionaryLocation.None, //où se trouvent les dictionnaires de ressources spécifiques à un thème
                                      //(utilisé si une ressource est introuvable dans la page,
@@ -40,7 +39,6 @@
                                               // dans l'application ou dans l'un des dictionnaires de ressources spécifiques à un thème)
 )]
 
-
 // Les informations de version pour un assembly se composent des quatre valeurs suivantes :
 //
 //      Version principale

Original file line number	Diff line number	Diff line change
`@@ -208,6 +208,10 @@ private enum TryBlockEvaluatedState`
`208`	`208`	`ExpressionOperator.UnaryMinus`
`209`	`209`	`};`
`210`	`210`
	`211`	`+ protected virtual IList<ExpressionOperator> LeftOperandOnlyOperatorsEvaluationDictionary => leftOperandOnlyOperatorsEvaluationDictionary;`
	`212`	`+ protected virtual IList<ExpressionOperator> RightOperandOnlyOperatorsEvaluationDictionary => rightOperandOnlyOperatorsEvaluationDictionary;`
	`213`	`+ protected virtual IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> OperatorsEvaluations => operatorsEvaluations;`
	`214`	`+`
`211`	`215`	`protected static readonly IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> operatorsEvaluations =`
`212`	`216`	`new List<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>>()`
`213`	`217`	`{`
`@@ -1287,7 +1291,6 @@ void forAction(int index)`
`1287`	`1291`	`if (isContinue)`
`1288`	`1292`	`{`
`1289`	`1293`	`isContinue = false;`
`1290`		`- continue;`
`1291`	`1294`	`}`
`1292`	`1295`	`}`
`1293`	`1296`	`}`
`@@ -1305,9 +1308,7 @@ void forAction(int index)`
`1305`	`1308`	`}`
`1306`	`1309`	`else`
`1307`	`1310`	`{`
`1308`		`- dynamic collection = Evaluate(foreachParenthisEvaluationMatch.Groups["collection"].Value);`
`1309`		`-`
`1310`		`- foreach (dynamic foreachValue in collection)`
	`1311`	`+ foreach (dynamic foreachValue in (dynamic)Evaluate(foreachParenthisEvaluationMatch.Groups["collection"].Value))`
`1311`	`1312`	`{`
`1312`	`1313`	`Variables[foreachParenthisEvaluationMatch.Groups["variableName"].Value] = foreachValue;`
`1313`	`1314`
`@@ -1847,7 +1848,9 @@ protected virtual bool EvaluateVarOrFunc(string expr, string restOfExpression, S`
`1847`	`1848`	`stack.Push(functionEvaluationEventArg.Value);`
`1848`	`1849`	`}`
`1849`	`1850`	`else`
	`1851`	`+ {`
`1850`	`1852`	`throw new ExpressionEvaluatorSyntaxErrorException($"[{objType}] object has no Method named \"{varFuncName}\".");`
	`1853`	`+ }`
`1851`	`1854`	`}`
`1852`	`1855`	`}`
`1853`	`1856`	`}`
`@@ -2029,7 +2032,7 @@ protected virtual bool EvaluateVarOrFunc(string expr, string restOfExpression, S`
`2029`	`2032`	`{`
`2030`	`2033`	`ExpressionOperator op = operatorsDictionary[varFuncMatch.Groups["assignmentPrefix"].Value];`
`2031`	`2034`
`2032`		`- varValue = operatorsEvaluations.ToList().Find(dict => dict.ContainsKey(op))[op](varValue, Evaluate(rightExpression));`
	`2035`	`+ varValue = OperatorsEvaluations.ToList().Find(dict => dict.ContainsKey(op))[op](varValue, Evaluate(rightExpression));`
`2033`	`2036`	`}`
`2034`	`2037`	`else`
`2035`	`2038`	`{`
`@@ -2137,7 +2140,7 @@ protected virtual bool EvaluateVarOrFunc(string expr, string restOfExpression, S`
`2137`	`2140`
`2138`	`2141`	`ExpressionOperator op = operatorsDictionary[varFuncMatch.Groups["assignmentPrefix"].Value];`
`2139`	`2142`
`2140`		`- cusVarValueToPush = operatorsEvaluations.ToList().Find(dict => dict.ContainsKey(op))[op](cusVarValueToPush, Evaluate(rightExpression));`
	`2143`	`+ cusVarValueToPush = OperatorsEvaluations.ToList().Find(dict => dict.ContainsKey(op))[op](cusVarValueToPush, Evaluate(rightExpression));`
`2141`	`2144`	`}`
`2142`	`2145`	`else`
`2143`	`2146`	`{`
`@@ -2455,9 +2458,9 @@ protected virtual bool EvaluateIndexing(string expr, string s, Stack<object> sta`
`2455`	`2458`	`{`
`2456`	`2459`	`ExpressionOperator prefixOp = operatorsDictionary[assignationOrPostFixOperatorMatch.Groups["assignmentPrefix"].Value];`
`2457`	`2460`
`2458`		`- valueToPush = operatorsEvaluations[0][op](left, right);`
	`2461`	`+ valueToPush = OperatorsEvaluations[0][op](left, right);`
`2459`	`2462`
`2460`		`- valueToPush = operatorsEvaluations.ToList().Find(dict => dict.ContainsKey(prefixOp))[prefixOp](valueToPush, Evaluate(rightExpression));`
	`2463`	`+ valueToPush = OperatorsEvaluations.ToList().Find(dict => dict.ContainsKey(prefixOp))[prefixOp](valueToPush, Evaluate(rightExpression));`
`2461`	`2464`	`}`
`2462`	`2465`	`else`
`2463`	`2466`	`{`
`@@ -2474,7 +2477,7 @@ protected virtual bool EvaluateIndexing(string expr, string s, Stack<object> sta`
`2474`	`2477`	`}`
`2475`	`2478`	`else`
`2476`	`2479`	`{`
`2477`		`- valueToPush = operatorsEvaluations[0][op](left, right);`
	`2480`	`+ valueToPush = OperatorsEvaluations[0][op](left, right);`
`2478`	`2481`	`}`
`2479`	`2482`
`2480`	`2483`	`stack.Push(valueToPush);`
`@@ -2621,7 +2624,7 @@ protected virtual object ProcessStack(Stack<object> stack)`
`2621`	`2624`	`.Select(e => e is ValueTypeNestingTrace valueTypeNestingTrace ? valueTypeNestingTrace.Value : e)`
`2622`	`2625`	`.ToList();`
`2623`	`2626`
`2624`		`- operatorsEvaluations.ToList().ForEach((IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>> operatorEvalutationsDict) =>`
	`2627`	`+ OperatorsEvaluations.ToList().ForEach((IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>> operatorEvalutationsDict) =>`
`2625`	`2628`	`{`
`2626`	`2629`	`for (int i = list.Count - 1; i >= 0; i--)`
`2627`	`2630`	`{`
`@@ -2631,13 +2634,13 @@ protected virtual object ProcessStack(Stack<object> stack)`
`2631`	`2634`
`2632`	`2635`	`if ((list[i] as ExpressionOperator) == eOp)`
`2633`	`2636`	`{`
`2634`		`- if (rightOperandOnlyOperatorsEvaluationDictionary.Contains(eOp))`
	`2637`	`+ if (RightOperandOnlyOperatorsEvaluationDictionary.Contains(eOp))`
`2635`	`2638`	`{`
`2636`	`2639`	`list[i] = operatorEvalutationsDict[eOp](null, (dynamic)list[i - 1]);`
`2637`	`2640`	`list.RemoveAt(i - 1);`
`2638`	`2641`	`break;`
`2639`	`2642`	`}`
`2640`		`- else if (leftOperandOnlyOperatorsEvaluationDictionary.Contains(eOp))`
	`2643`	`+ else if (LeftOperandOnlyOperatorsEvaluationDictionary.Contains(eOp))`
`2641`	`2644`	`{`
`2642`	`2645`	`list[i] = operatorEvalutationsDict[eOp]((dynamic)list[i + 1], null);`
`2643`	`2646`	`list.RemoveAt(i + 1);`
`@@ -2708,6 +2711,7 @@ public string RemoveComments(string scriptWithComments)`
`2708`	`2711`	`#region Utils methods for parsing and interpretation`
`2709`	`2712`
`2710`	`2713`	`private delegate dynamic InternalDelegate(params dynamic[] args);`
	`2714`	`+`
`2711`	`2715`	`private bool GetLambdaExpression(string expr, Stack<object> stack)`
`2712`	`2716`	`{`
`2713`	`2717`	`Match lambdaExpressionMatch = lambdaExpressionRegex.Match(expr);`
`@@ -3264,6 +3268,7 @@ public DelegateEncaps(InternalDelegate lambda)`
`3264`	`3268`	`{`
`3265`	`3269`	`this.lambda = lambda;`
`3266`	`3270`	`}`
	`3271`	`+`
`3267`	`3272`	`public DelegateEncaps(object target, MethodInfo methodInfo)`
`3268`	`3273`	`{`
`3269`	`3274`	`this.target = target;`
`@@ -3280,66 +3285,82 @@ public TResult Func0<TResult>()`
`3280`	`3285`	`{`
`3281`	`3286`	`return (TResult)lambda();`
`3282`	`3287`	`}`
	`3288`	`+`
`3283`	`3289`	`public TResult Func1<T, TResult>(T arg)`
`3284`	`3290`	`{`
`3285`	`3291`	`return (TResult)lambda(arg);`
`3286`	`3292`	`}`
	`3293`	`+`
`3287`	`3294`	`public TResult Func2<T1, T2, TResult>(T1 arg1, T2 arg2)`
`3288`	`3295`	`{`
`3289`	`3296`	`return (TResult)lambda(arg1, arg2);`
`3290`	`3297`	`}`
	`3298`	`+`
`3291`	`3299`	`public TResult Func3<T1, T2, T3, TResult>(T1 arg1, T2 arg2, T3 arg3)`
`3292`	`3300`	`{`
`3293`	`3301`	`return (TResult)lambda(arg1, arg2, arg3);`
`3294`	`3302`	`}`
	`3303`	`+`
`3295`	`3304`	`public TResult Func4<T1, T2, T3, T4, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4)`
`3296`	`3305`	`{`
`3297`	`3306`	`return (TResult)lambda(arg1, arg2, arg3, arg4);`
`3298`	`3307`	`}`
	`3308`	`+`
`3299`	`3309`	`public TResult Func5<T1, T2, T3, T4, T5, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)`
`3300`	`3310`	`{`
`3301`	`3311`	`return (TResult)lambda(arg1, arg2, arg3, arg4, arg5);`
`3302`	`3312`	`}`
	`3313`	`+`
`3303`	`3314`	`public TResult Func6<T1, T2, T3, T4, T5, T6, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)`
`3304`	`3315`	`{`
`3305`	`3316`	`return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6);`
`3306`	`3317`	`}`
	`3318`	`+`
`3307`	`3319`	`public TResult Func7<T1, T2, T3, T4, T5, T6, T7, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)`
`3308`	`3320`	`{`
`3309`	`3321`	`return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7);`
`3310`	`3322`	`}`
	`3323`	`+`
`3311`	`3324`	`public TResult Func8<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)`
`3312`	`3325`	`{`
`3313`	`3326`	`return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);`
`3314`	`3327`	`}`
	`3328`	`+`
`3315`	`3329`	`public TResult Func9<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)`
`3316`	`3330`	`{`
`3317`	`3331`	`return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);`
`3318`	`3332`	`}`
	`3333`	`+`
`3319`	`3334`	`public TResult Func10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)`
`3320`	`3335`	`{`
`3321`	`3336`	`return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);`
`3322`	`3337`	`}`
	`3338`	`+`
`3323`	`3339`	`public TResult Func11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)`
`3324`	`3340`	`{`
`3325`	`3341`	`return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);`
`3326`	`3342`	`}`
	`3343`	`+`
`3327`	`3344`	`public TResult Func12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)`
`3328`	`3345`	`{`
`3329`	`3346`	`return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);`
`3330`	`3347`	`}`
	`3348`	`+`
`3331`	`3349`	`public TResult Func13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)`
`3332`	`3350`	`{`
`3333`	`3351`	`return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);`
`3334`	`3352`	`}`
	`3353`	`+`
`3335`	`3354`	`public TResult Func14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)`
`3336`	`3355`	`{`
`3337`	`3356`	`return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);`
`3338`	`3357`	`}`
	`3358`	`+`
`3339`	`3359`	`public TResult Func15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)`
`3340`	`3360`	`{`
`3341`	`3361`	`return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);`
`3342`	`3362`	`}`
	`3363`	`+`
`3343`	`3364`	`public TResult Func16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)`
`3344`	`3365`	`{`
`3345`	`3366`	`return (TResult)lambda(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16);`
`@@ -3425,6 +3446,13 @@ public bool Equals(ExpressionOperator otherOperator)`
`3425`	`3446`
`3426`	`3447`	`public static partial class OperatorsEvaluationsExtensions`
`3427`	`3448`	`{`
	`3449`	`+ public static IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> Copy(this IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>> operatorsEvaluations)`
	`3450`	`+ {`
	`3451`	`+ return (IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>>)operatorsEvaluations`
	`3452`	`+ .Select(dic => (IDictionary<ExpressionOperator, Func<dynamic, dynamic, object>>)new Dictionary<ExpressionOperator, Func<dynamic, dynamic, object>>(dic))`
	`3453`	`+ .ToList();`
	`3454`	`+ }`
	`3455`	`+`
`3428`	`3456`	`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)`
`3429`	`3457`	`{`
`3430`	`3458`	`operatorsEvaluations`
`@@ -3478,6 +3506,20 @@ public static IList<IDictionary<ExpressionOperator, Func<dynamic, dynamic, objec`
`3478`	`3506`
`3479`	`3507`	`return operatorsEvaluations;`
`3480`	`3508`	`}`
	`3509`	`+`
	`3510`	`+ public static IList<ExpressionOperator> FluidAdd(this IList<ExpressionOperator> listOfOperator, ExpressionOperator operatorToAdd)`
	`3511`	`+ {`
	`3512`	`+ listOfOperator.Add(operatorToAdd);`
	`3513`	`+`
	`3514`	`+ return listOfOperator;`
	`3515`	`+ }`
	`3516`	`+`
	`3517`	`+ public static IList<ExpressionOperator> FluidRemove(this IList<ExpressionOperator> listOfOperator, ExpressionOperator operatorToRemove)`
	`3518`	`+ {`
	`3519`	`+ listOfOperator.Remove(operatorToRemove);`
	`3520`	`+`
	`3521`	`+ return listOfOperator;`
	`3522`	`+ }`
`3481`	`3523`	`}`
`3482`	`3524`
`3483`	`3525`	`#endregion`