Operation visitor.

Author: NTDLS

NTDLS.ExpressionParser/ExpressionState.cs

@@ -8,6 +8,7 @@ internal class ExpressionState
     {
         public VisitorCache<ScanStepItem> ScanStepCache;
         public VisitorCache<ComputedStepItem> ComputedStepCache;
+        public VisitorCache<OperationStepItem> OperationStepCache;
 
         public string WorkingText { get; set; } = string.Empty;
         public readonly StringBuilder Buffer;
@@ -31,6 +32,7 @@ public ExpressionState(Sanitized sanitized, ExpressionOptions options)
 
             ScanStepCache = new(_operationCount * 3);
             ComputedStepCache = new(_operationCount * 3);
+            OperationStepCache = new(_operationCount);
 
             for (int i = 0; i < sanitized.ConsumedPlaceholderCacheSlots; i++)
             {
@@ -46,8 +48,9 @@ public ExpressionState(Sanitized sanitized, ExpressionOptions options)
         public ExpressionState(ExpressionOptions options, int operationCount, int preAllocation)
         {
             Buffer = new StringBuilder(preAllocation);
-            ScanStepCache = new(_operationCount * 3);
-            ComputedStepCache = new(_operationCount * 3);
+            ScanStepCache = new(operationCount * 3);
+            ComputedStepCache = new(operationCount * 3);
+            OperationStepCache = new(operationCount);
             _options = options;
         }
 
@@ -110,6 +113,7 @@ public void HydrateTemplateCache(int expressionHash)
                         {
                             ComputedStepCache.CopyTo(entry.State.ComputedStepCache);
                             ScanStepCache.CopyTo(entry.State.ScanStepCache);
+                            OperationStepCache.CopyTo(entry.State.OperationStepCache);
                         }
                         _isTemplateCacheHydrated = true;
                     }
@@ -123,6 +127,7 @@ public void Reset(Sanitized sanitized)
             _nextPlaceholderCacheSlot = sanitized.ConsumedPlaceholderCacheSlots;
             ComputedStepCache.Reset();
             ScanStepCache.Reset();
+            OperationStepCache.Reset();
         }
 
         public ExpressionState Clone(Sanitized sanitized)
@@ -133,13 +138,12 @@ public ExpressionState Clone(Sanitized sanitized)
                 _operationCount = _operationCount,
                 _nextPlaceholderCacheSlot = _nextPlaceholderCacheSlot,
                 _placeholderCache = new PlaceholderCacheItem[_placeholderCache.Length],
-                _isTemplateCacheHydrated = _isTemplateCacheHydrated,
-                ComputedStepCache = new(_operationCount * 3),
-                ScanStepCache = new(_operationCount * 3),
+                _isTemplateCacheHydrated = _isTemplateCacheHydrated
             };
 
             ComputedStepCache.CopyTo(clone.ComputedStepCache);
             ScanStepCache.CopyTo(clone.ScanStepCache);
+            OperationStepCache.CopyTo(clone.OperationStepCache);
 
             for (int i = 0; i < sanitized.ConsumedPlaceholderCacheSlots; i++)
             {

NTDLS.ExpressionParser/SubExpression.cs

@@ -416,23 +416,42 @@ private int GetFreestandingNotOperation(out string outFoundOperation)
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private int GetIndexOfOperation(ReadOnlySpan<char> validOperations, out string foundOperation)
         {
-            ReadOnlySpan<char> span = Text.AsSpan();
-
-            for (int i = 1; i < span.Length; i++)
+            if (_parentExpression.State.OperationStepCache.TryGet(out var cachedObj))
             {
-                char c = span[i];
-                for (int j = 0; j < validOperations.Length; j++)
+                foundOperation = cachedObj.Operation;
+                return cachedObj.Index;
+            }
+            else
+            {
+                ReadOnlySpan<char> span = Text.AsSpan();
+
+                for (int i = 1; i < span.Length; i++)
                 {
-                    if (c == validOperations[j])
+                    char c = span[i];
+                    for (int j = 0; j < validOperations.Length; j++)
                     {
-                        foundOperation = c.ToString();
-                        return i;
+                        if (c == validOperations[j])
+                        {
+                            _parentExpression.State.OperationStepCache.Store(new OperationStepItem()
+                            {
+                                Index = i,
+                                Operation = c.ToString()
+                            }, true);
+                            foundOperation = c.ToString();
+                            return i;
+                        }
                     }
                 }
-            }
 
-            foundOperation = string.Empty;
-            return -1;
+                foundOperation = string.Empty;
+
+                _parentExpression.State.OperationStepCache.Store(new OperationStepItem()
+                {
+                    Index = -1
+                }, true);
+
+                return -1;
+            }
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]

NTDLS.ExpressionParser/Types.cs

@@ -12,6 +12,12 @@ internal struct ComputedStepItem
         public int EndPosition;
     }
 
+    internal struct OperationStepItem
+    {
+        public string Operation;
+        public int Index;
+    }
+
     internal struct ScanStepItem
     {
         public double? Value;

TestHarness/Program.cs

@@ -14,7 +14,7 @@ static void EvalPrint(string exp)
 
         static void Baseline()
         {
-            var expression = new Expression("10 * ((5 + 1000 + ( 10 )) *  60.5) * 10"); //71.8829
+            var expression = new Expression("(2+3)*4"); //71.8829
 
             var stopwatch = Stopwatch.StartNew();
             for (int i = 0; i < 100000; i++)