Update ExpressionEvaluator

Author: Sébastien Geiser

RegexDialog/Utils/ExpressionEvaluator.cs

@@ -1,6 +1,6 @@
 /******************************************************************************************************
     Title : ExpressionEvaluator (https://github.com/codingseb/ExpressionEvaluator)
-    Version : 1.3.7.3 
+    Version : 1.4.0.0 
     (if last digit (the forth) is not a zero, the version is an intermediate version and can be unstable)
 
     Author : Coding Seb
@@ -883,6 +883,8 @@ protected virtual void Init()
 
         #region Main evaluate methods (Expressions and scripts ==> public)
 
+        #region Scripts
+
         protected bool inScript;
 
         /// <summary>
@@ -1370,6 +1372,10 @@ void forAction(int index)
                 throw new ExpressionEvaluatorSyntaxErrorException("No [return] keyword found");
         }
 
+        #endregion
+
+        #region Expressions
+
         /// <summary>
         /// Evaluate the specified math or pseudo C# expression
         /// </summary>
@@ -1381,71 +1387,43 @@ public T Evaluate<T>(string expression)
             return (T)Evaluate(expression);
         }
 
+        private IList<ParsingMethodDelegate> parsingMethods;
+
+        protected virtual IList<ParsingMethodDelegate> ParsingMethods => parsingMethods ?? (parsingMethods = new List<ParsingMethodDelegate>()
+        {
+            EvaluateCast,
+            EvaluateNumber,
+            EvaluateInstanceCreationWithNewKeyword,
+            EvaluateVarOrFunc,
+            EvaluateOperators,
+            EvaluateChar,
+            EvaluateParenthis,
+            EvaluateIndexing,
+            EvaluateString,
+            EvaluateTernaryConditionalOperator,
+        });
+
         /// <summary>
         /// Evaluate the specified math or pseudo C# expression
         /// </summary>
         /// <param name="expression">the math or pseudo C# expression to evaluate</param>
         /// <returns>The result of the operation if syntax is correct</returns>
         public object Evaluate(string expression)
         {
-            bool continueEvaluation = true;
-
             expression = expression.Trim();
 
             Stack<object> stack = new Stack<object>();
 
             if (GetLambdaExpression(expression, stack))
                 return stack.Pop();
 
-            for (int i = 0; i < expression.Length && continueEvaluation; i++)
+            for (int i = 0; i < expression.Length; i++)
             {
-                if (!(EvaluateCast(expression, stack, ref i)
-                    || EvaluateNumber(expression, stack, ref i)
-                    || EvaluateInstanceCreationWithNewKeyword(expression, stack, ref i)
-                    || EvaluateVarOrFunc(expression, stack, ref i)
-                    || EvaluateOperators(expression, stack, ref i)
-                    || EvaluateChar(expression, stack, ref i)
-                    || EvaluateParenthis(expression, stack, ref i)
-                    || EvaluateIndexing(expression, stack, ref i)
-                    || EvaluateString(expression, stack, ref i)))
+                if (!ParsingMethods.Any(m => m(expression, stack, ref i)))
                 {
                     string s = expression.Substring(i, 1);
 
-                    if (s.Equals("?"))
-                    {
-                        bool condition = (bool)ProcessStack(stack);
-
-                        string restOfExpression = expression.Substring(i);
-
-                        for (int j = 1; j < restOfExpression.Length; j++)
-                        {
-                            string s2 = restOfExpression.Substring(j, 1);
-
-                            Match internalStringMatch = stringBeginningRegex.Match(restOfExpression.Substring(j));
-
-                            if (internalStringMatch.Success)
-                            {
-                                string innerString = internalStringMatch.Value + GetCodeUntilEndOfString(restOfExpression.Substring(j + internalStringMatch.Length), internalStringMatch);
-                                j += innerString.Length - 1;
-                            }
-                            else if (s2.Equals("("))
-                            {
-                                j++;
-                                GetExpressionsBetweenParenthesesOrOtherImbricableBrackets(restOfExpression, ref j, false);
-                            }
-                            else if (s2.Equals(":"))
-                            {
-                                stack.Clear();
-
-                                stack.Push(condition ? Evaluate(restOfExpression.Substring(1, j - 1)) : Evaluate(restOfExpression.Substring(j + 1)));
-
-                                continueEvaluation = false;
-
-                                break;
-                            }
-                        }
-                    }
-                    else if (!s.Trim().Equals(string.Empty))
+                    if (!s.Trim().Equals(string.Empty))
                     {
                         throw new ExpressionEvaluatorSyntaxErrorException($"Invalid character [{(int)s[0]}:{s}]");
                     }
@@ -1457,6 +1435,8 @@ public object Evaluate(string expression)
 
         #endregion
 
+        #endregion
+
         #region Sub parts evaluate methods (protected virtual)
 
         protected virtual bool EvaluateCast(string expression, Stack<object> stack, ref int i)
@@ -2325,6 +2305,46 @@ protected virtual bool EvaluateOperators(string expression, Stack<object> stack,
             return false;
         }
 
+        protected virtual bool EvaluateTernaryConditionalOperator(string expression, Stack<object> stack, ref int i)
+        {
+            if (expression.Substring(i, 1).Equals("?"))
+            {
+                bool condition = (bool)ProcessStack(stack);
+
+                string restOfExpression = expression.Substring(i + 1);
+
+                for (int j = 0; j < restOfExpression.Length; j++)
+                {
+                    string s2 = restOfExpression.Substring(j, 1);
+
+                    Match internalStringMatch = stringBeginningRegex.Match(restOfExpression.Substring(j));
+
+                    if (internalStringMatch.Success)
+                    {
+                        string innerString = internalStringMatch.Value + GetCodeUntilEndOfString(restOfExpression.Substring(j + internalStringMatch.Length), internalStringMatch);
+                        j += innerString.Length - 1;
+                    }
+                    else if (s2.Equals("("))
+                    {
+                        j++;
+                        GetExpressionsBetweenParenthesesOrOtherImbricableBrackets(restOfExpression, ref j, false);
+                    }
+                    else if (s2.Equals(":"))
+                    {
+                        stack.Clear();
+
+                        stack.Push(condition ? Evaluate(restOfExpression.Substring(1, j - 1)) : Evaluate(restOfExpression.Substring(j + 1)));
+
+                        i = expression.Length;
+
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
         protected virtual bool EvaluateParenthis(string expression, Stack<object> stack, ref int i)
         {
             string s = expression.Substring(i, 1);
@@ -3770,4 +3790,4 @@ public FunctionPreEvaluationEventArg(string name, Func<string, object> evaluateF
     }
 
     #endregion
-}
+}