Improves expression parsing efficiency.

NTDLS · NTDLS · commit 47562899df35 · 2025-10-29T13:03:43.000-04:00
Reduces memory allocations during expression evaluation by renaming and repurposing the pre-parsed cache to a more general placeholder cache.

This allows caching of intermediate values and avoids redundant calculations.
Additionally, the ExpressionState class now pre-allocates the StringBuilder for better performance.
diff --git a/NTDLS.ExpressionParser/Expression.cs b/NTDLS.ExpressionParser/Expression.cs
@@ -57,8 +57,6 @@ public Expression(string text, ExpressionOptions? options = null)
             }
         }
 
-
-
         #endregion
 
         #region Evaluate.
diff --git a/NTDLS.ExpressionParser/ExpressionState.cs b/NTDLS.ExpressionParser/ExpressionState.cs
@@ -10,26 +10,27 @@ namespace NTDLS.ExpressionParser
     internal class ExpressionState
     {
         public string WorkingText { get; set; } = string.Empty;
-        public readonly StringBuilder Buffer = new();
+        public readonly StringBuilder Buffer;
 
-        private int _nextPreParsedCacheSlot = 0;
+        private int _nextPlaceholderCacheSlot = 0;
         private PreComputedCacheItem[] _preComputedCache = [];
         private int _nextPreComputedCacheSlot = 0;
         private int _operationCount = 0;
-        private PreParsedCacheItem?[] _preParsedCache = [];
+        private PlaceholderCacheItem?[] _placeholderCache = [];
         private readonly ExpressionOptions _options;
-        private bool _isPreParsedCacheHydrated = false;
+        private bool _isPlaceholderCacheHydrated = false;
 
         public ExpressionState(Sanitized sanitized, ExpressionOptions options)
         {
             _options = options;
+            Buffer = new StringBuilder();
 
             WorkingText = sanitized.Text;
             _operationCount = sanitized.OperationCount;
             _nextPreComputedCacheSlot = sanitized.ConsumedPreComputedCacheSlots;
             _preComputedCache = new PreComputedCacheItem[sanitized.OperationCount];
-            _preParsedCache = new PreParsedCacheItem?[_operationCount];
-            _nextPreParsedCacheSlot = 0;
+            _placeholderCache = new PlaceholderCacheItem?[_operationCount];
+            _nextPlaceholderCacheSlot = 0;
 
             for (int i = 0; i < sanitized.ConsumedPreComputedCacheSlots; i++)
             {
@@ -42,24 +43,26 @@ public ExpressionState(Sanitized sanitized, ExpressionOptions options)
             }
         }
 
-        public ExpressionState(ExpressionOptions options)
+        public ExpressionState(ExpressionOptions options, int preAllocation)
         {
+            Buffer = new StringBuilder(preAllocation);
+
             _options = options;
         }
 
         #region Pre-Parsed Cache Management.
 
-        public int ConsumeNextPreParsedCacheSlot()
+        public int ConsumeNextPlaceholderCacheSlot()
         {
-            return _nextPreParsedCacheSlot++;
+            return _nextPlaceholderCacheSlot++;
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public bool TryGetPreParsedCache(int slot, [NotNullWhen(true)] out PreParsedCacheItem value)
+        public bool TryGetPlaceholderCache(int slot, [NotNullWhen(true)] out PlaceholderCacheItem value)
         {
-            if (slot < _preParsedCache.Length)
+            if (slot < _placeholderCache.Length)
             {
-                var cached = _preParsedCache[slot];
+                var cached = _placeholderCache[slot];
                 if (cached != null)
                 {
                     value = cached.Value;
@@ -71,13 +74,13 @@ public bool TryGetPreParsedCache(int slot, [NotNullWhen(true)] out PreParsedCach
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void StorePreParsedCache(int slot, PreParsedCacheItem value)
+        public void StorePlaceholderCache(int slot, PlaceholderCacheItem value)
         {
-            if (slot >= _preParsedCache.Length) //Resize the cache if needed.
+            if (slot >= _placeholderCache.Length) //Resize the cache if needed.
             {
-                Array.Resize(ref _preParsedCache, (_preParsedCache.Length + 1) * 2);
+                Array.Resize(ref _placeholderCache, (_placeholderCache.Length + 1) * 2);
             }
-            _preParsedCache[slot] = value;
+            _placeholderCache[slot] = value;
         }
 
         #endregion
@@ -127,48 +130,48 @@ public PreComputedCacheItem GetPreComputedCacheItem(ReadOnlySpan<char> span)
 
         public void HydrateTemplateParsedCache(int expressionHash)
         {
-            if (!_isPreParsedCacheHydrated)
+            if (!_isPlaceholderCacheHydrated)
             {
                 lock (this)
                 {
-                    if (!_isPreParsedCacheHydrated)
+                    if (!_isPlaceholderCacheHydrated)
                     {
                         if (Utility.PersistentCaches.TryGetValue(expressionHash, out CachedState? entry) && entry != null)
                         {
-                            entry.State.HydratePreParsedCache(_preParsedCache);
+                            entry.State.HydratePlaceholderCache(_placeholderCache);
                         }
-                        _isPreParsedCacheHydrated = true;
+                        _isPlaceholderCacheHydrated = true;
                     }
                 }
             }
         }
 
-        private void HydratePreParsedCache(PreParsedCacheItem?[] populatedCache)
+        private void HydratePlaceholderCache(PlaceholderCacheItem?[] populatedCache)
         {
-            Interlocked.Exchange(ref _preParsedCache, populatedCache);
+            Interlocked.Exchange(ref _placeholderCache, populatedCache);
         }
 
         public void Reset(Sanitized sanitized)
         {
             _nextPreComputedCacheSlot = sanitized.ConsumedPreComputedCacheSlots;
-            _nextPreParsedCacheSlot = 0;
+            _nextPlaceholderCacheSlot = 0;
         }
 
         public ExpressionState Clone()
         {
-            var clone = new ExpressionState(_options)
+            var clone = new ExpressionState(_options, WorkingText.Length * 2)
             {
                 WorkingText = WorkingText,
                 _operationCount = _operationCount,
                 _nextPreComputedCacheSlot = _nextPreComputedCacheSlot,
                 _preComputedCache = new PreComputedCacheItem[_preComputedCache.Length],
-                _preParsedCache = new PreParsedCacheItem?[_preParsedCache.Length],
-                _nextPreParsedCacheSlot = 0,
-                _isPreParsedCacheHydrated = _isPreParsedCacheHydrated
+                _placeholderCache = new PlaceholderCacheItem?[_placeholderCache.Length],
+                _nextPlaceholderCacheSlot = 0,
+                _isPlaceholderCacheHydrated = _isPlaceholderCacheHydrated
             };
 
             Array.Copy(_preComputedCache, clone._preComputedCache, _preComputedCache.Length); //Copy any pre-computed NULLs.
-            Array.Copy(_preParsedCache, clone._preParsedCache, _preParsedCache.Length);
+            Array.Copy(_placeholderCache, clone._placeholderCache, _placeholderCache.Length);
 
             return clone;
         }
diff --git a/NTDLS.ExpressionParser/SubExpression.cs b/NTDLS.ExpressionParser/SubExpression.cs
@@ -156,27 +156,27 @@ internal string Compute(bool isCacheable)
                 //Pre-first-order:
                 while ((operatorIndex = GetFreestandingNotOperation(out _)) != -1)
                 {
-                    var preParsedCacheSlot = _parentExpression.State.ConsumeNextPreParsedCacheSlot();
+                    var placeholderCacheSlot = _parentExpression.State.ConsumeNextPlaceholderCacheSlot();
 
-                    if (_parentExpression.State.TryGetPreParsedCache(preParsedCacheSlot, out PreParsedCacheItem cachedObj))
+                    if (_parentExpression.State.TryGetPlaceholderCache(placeholderCacheSlot, out PlaceholderCacheItem cachedObj))
                     {
                         StorePreComputed(cachedObj.BeginPosition, cachedObj.EndPosition, cachedObj.ParsedValue);
                     }
                     else
                     {
-                        var rightValue = GetRightValue(operatorIndex + 1, out int outParsedLength, out bool isOperCacheable);
+                        var rightValue = GetRightValue(operatorIndex + 1, out int outParsedLength, out bool isOperationCacheable);
                         int? calculatedResult = rightValue == null ? null : (rightValue == 0) ? 1 : 0;
                         StorePreComputed(operatorIndex, operatorIndex + outParsedLength, calculatedResult);
 
-                        if (isCacheable && isOperCacheable)
+                        if (isCacheable && isOperationCacheable)
                         {
-                            var parsedNumber = new PreParsedCacheItem
+                            var parsedNumber = new PlaceholderCacheItem
                             {
                                 ParsedValue = calculatedResult,
                                 BeginPosition = operatorIndex,
                                 EndPosition = operatorIndex + outParsedLength
                             };
-                            _parentExpression.State.StorePreParsedCache(preParsedCacheSlot, parsedNumber);
+                            _parentExpression.State.StorePlaceholderCache(placeholderCacheSlot, parsedNumber);
                         }
                     }
                 }
@@ -185,30 +185,30 @@ internal string Compute(bool isCacheable)
                 operatorIndex = GetIndexOfOperation(Utility.FirstOrderOperations, out string operation);
                 if (operatorIndex > 0)
                 {
-                    var preParsedCacheSlot = _parentExpression.State.ConsumeNextPreParsedCacheSlot();
+                    var placeholderCacheSlot = _parentExpression.State.ConsumeNextPlaceholderCacheSlot();
 
-                    if (_parentExpression.State.TryGetPreParsedCache(preParsedCacheSlot, out PreParsedCacheItem cachedObj))
+                    if (_parentExpression.State.TryGetPlaceholderCache(placeholderCacheSlot, out PlaceholderCacheItem cachedObj))
                     {
                         StorePreComputed(cachedObj.BeginPosition, cachedObj.EndPosition, cachedObj.ParsedValue);
                     }
                     else
                     {
                         double? calculatedResult = null;
-                        if (GetLeftAndRightValues(operation, operatorIndex, out double leftValue, out double rightValue, out int beginPosition, out int endPosition, out bool isOperCacheable))
+                        if (GetLeftAndRightValues(operation, operatorIndex, out double leftValue, out double rightValue, out int beginPosition, out int endPosition, out bool isOperationCacheable))
                         {
                             calculatedResult = Utility.ComputePrivative(leftValue, operation, rightValue);
                         }
 
                         StorePreComputed(beginPosition, endPosition, calculatedResult);
-                        if (isCacheable && isOperCacheable)
+                        if (isCacheable && isOperationCacheable)
                         {
-                            var parsedNumber = new PreParsedCacheItem
+                            var parsedNumber = new PlaceholderCacheItem
                             {
                                 ParsedValue = calculatedResult,
                                 BeginPosition = beginPosition,
                                 EndPosition = endPosition
                             };
-                            _parentExpression.State.StorePreParsedCache(preParsedCacheSlot, parsedNumber);
+                            _parentExpression.State.StorePlaceholderCache(placeholderCacheSlot, parsedNumber);
                         }
                     }
 
@@ -219,30 +219,30 @@ internal string Compute(bool isCacheable)
                 operatorIndex = GetIndexOfOperation(Utility.SecondOrderOperations, out operation);
                 if (operatorIndex > 0)
                 {
-                    var preParsedCacheSlot = _parentExpression.State.ConsumeNextPreParsedCacheSlot();
+                    var placeholderCacheSlot = _parentExpression.State.ConsumeNextPlaceholderCacheSlot();
 
-                    if (_parentExpression.State.TryGetPreParsedCache(preParsedCacheSlot, out PreParsedCacheItem cachedObj))
+                    if (_parentExpression.State.TryGetPlaceholderCache(placeholderCacheSlot, out PlaceholderCacheItem cachedObj))
                     {
                         StorePreComputed(cachedObj.BeginPosition, cachedObj.EndPosition, cachedObj.ParsedValue);
                     }
                     else
                     {
                         double? calculatedResult = null;
-                        if (GetLeftAndRightValues(operation, operatorIndex, out double leftValue, out double rightValue, out int beginPosition, out int endPosition, out bool isOperCacheable))
+                        if (GetLeftAndRightValues(operation, operatorIndex, out double leftValue, out double rightValue, out int beginPosition, out int endPosition, out bool isOperationCacheable))
                         {
                             calculatedResult = Utility.ComputePrivative(leftValue, operation, rightValue);
                         }
 
                         StorePreComputed(beginPosition, endPosition, calculatedResult);
-                        if (isCacheable && isOperCacheable)
+                        if (isCacheable && isOperationCacheable)
                         {
-                            var parsedNumber = new PreParsedCacheItem
+                            var parsedNumber = new PlaceholderCacheItem
                             {
                                 ParsedValue = calculatedResult,
                                 BeginPosition = beginPosition,
                                 EndPosition = endPosition
                             };
-                            _parentExpression.State.StorePreParsedCache(preParsedCacheSlot, parsedNumber);
+                            _parentExpression.State.StorePlaceholderCache(placeholderCacheSlot, parsedNumber);
                         }
                     }
                     continue;
@@ -252,31 +252,31 @@ internal string Compute(bool isCacheable)
                 operatorIndex = GetIndexOfOperation(Utility.ThirdOrderOperations, out operation);
                 if (operatorIndex > 0)
                 {
-                    var preParsedCacheSlot = _parentExpression.State.ConsumeNextPreParsedCacheSlot();
+                    var placeholderCacheSlot = _parentExpression.State.ConsumeNextPlaceholderCacheSlot();
 
-                    if (_parentExpression.State.TryGetPreParsedCache(preParsedCacheSlot, out PreParsedCacheItem cachedObj))
+                    if (_parentExpression.State.TryGetPlaceholderCache(placeholderCacheSlot, out PlaceholderCacheItem cachedObj))
                     {
                         StorePreComputed(cachedObj.BeginPosition, cachedObj.EndPosition, cachedObj.ParsedValue);
                     }
                     else
                     {
                         double? calculatedResult = null;
 
-                        if (GetLeftAndRightValues(operation, operatorIndex, out double leftValue, out double rightValue, out int beginPosition, out int endPosition, out bool isOperCacheable))
+                        if (GetLeftAndRightValues(operation, operatorIndex, out double leftValue, out double rightValue, out int beginPosition, out int endPosition, out bool isOperationCacheable))
                         {
                             calculatedResult = Utility.ComputePrivative(leftValue, operation, rightValue);
                         }
 
                         StorePreComputed(beginPosition, endPosition, calculatedResult);
-                        if (isCacheable && isOperCacheable)
+                        if (isCacheable && isOperationCacheable)
                         {
-                            var parsedNumber = new PreParsedCacheItem
+                            var parsedNumber = new PlaceholderCacheItem
                             {
                                 ParsedValue = calculatedResult,
                                 BeginPosition = beginPosition,
                                 EndPosition = endPosition
                             };
-                            _parentExpression.State.StorePreParsedCache(preParsedCacheSlot, parsedNumber);
+                            _parentExpression.State.StorePlaceholderCache(placeholderCacheSlot, parsedNumber);
                         }
                     }
                     continue;
diff --git a/NTDLS.ExpressionParser/Types.cs b/NTDLS.ExpressionParser/Types.cs
@@ -5,7 +5,7 @@
     /// </summary>
     public delegate double? ExpressionFunction(double[] parameters);
 
-    internal struct PreParsedCacheItem
+    internal struct PlaceholderCacheItem
     {
         public double? ParsedValue;
         public int BeginPosition;

Original file line number	Diff line number	Diff line change
`@@ -57,8 +57,6 @@ public Expression(string text, ExpressionOptions? options = null)`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
`60`		`-`
`61`		`-`
`62`	`60`	`#endregion`
`63`	`61`
`64`	`62`	`#region Evaluate.`
Original file line number	Diff line number	Diff line change
`@@ -10,26 +10,27 @@ namespace NTDLS.ExpressionParser`
`10`	`10`	`internal class ExpressionState`
`11`	`11`	`{`
`12`	`12`	`public string WorkingText { get; set; } = string.Empty;`
`13`		`- public readonly StringBuilder Buffer = new();`
	`13`	`+ public readonly StringBuilder Buffer;`
`14`	`14`
`15`		`- private int _nextPreParsedCacheSlot = 0;`
	`15`	`+ private int _nextPlaceholderCacheSlot = 0;`
`16`	`16`	`private PreComputedCacheItem[] _preComputedCache = [];`
`17`	`17`	`private int _nextPreComputedCacheSlot = 0;`
`18`	`18`	`private int _operationCount = 0;`
`19`		`- private PreParsedCacheItem?[] _preParsedCache = [];`
	`19`	`+ private PlaceholderCacheItem?[] _placeholderCache = [];`
`20`	`20`	`private readonly ExpressionOptions _options;`
`21`		`- private bool _isPreParsedCacheHydrated = false;`
	`21`	`+ private bool _isPlaceholderCacheHydrated = false;`
`22`	`22`
`23`	`23`	`public ExpressionState(Sanitized sanitized, ExpressionOptions options)`
`24`	`24`	`{`
`25`	`25`	`_options = options;`
	`26`	`+ Buffer = new StringBuilder();`
`26`	`27`
`27`	`28`	`WorkingText = sanitized.Text;`
`28`	`29`	`_operationCount = sanitized.OperationCount;`
`29`	`30`	`_nextPreComputedCacheSlot = sanitized.ConsumedPreComputedCacheSlots;`
`30`	`31`	`_preComputedCache = new PreComputedCacheItem[sanitized.OperationCount];`
`31`		`- _preParsedCache = new PreParsedCacheItem?[_operationCount];`
`32`		`- _nextPreParsedCacheSlot = 0;`
	`32`	`+ _placeholderCache = new PlaceholderCacheItem?[_operationCount];`
	`33`	`+ _nextPlaceholderCacheSlot = 0;`
`33`	`34`
`34`	`35`	`for (int i = 0; i < sanitized.ConsumedPreComputedCacheSlots; i++)`
`35`	`36`	`{`
`@@ -42,24 +43,26 @@ public ExpressionState(Sanitized sanitized, ExpressionOptions options)`
`42`	`43`	`}`
`43`	`44`	`}`
`44`	`45`
`45`		`- public ExpressionState(ExpressionOptions options)`
	`46`	`+ public ExpressionState(ExpressionOptions options, int preAllocation)`
`46`	`47`	`{`
	`48`	`+ Buffer = new StringBuilder(preAllocation);`
	`49`	`+`
`47`	`50`	`_options = options;`
`48`	`51`	`}`
`49`	`52`
`50`	`53`	`#region Pre-Parsed Cache Management.`
`51`	`54`
`52`		`- public int ConsumeNextPreParsedCacheSlot()`
	`55`	`+ public int ConsumeNextPlaceholderCacheSlot()`
`53`	`56`	`{`
`54`		`- return _nextPreParsedCacheSlot++;`
	`57`	`+ return _nextPlaceholderCacheSlot++;`
`55`	`58`	`}`
`56`	`59`
`57`	`60`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`58`		`- public bool TryGetPreParsedCache(int slot, [NotNullWhen(true)] out PreParsedCacheItem value)`
	`61`	`+ public bool TryGetPlaceholderCache(int slot, [NotNullWhen(true)] out PlaceholderCacheItem value)`
`59`	`62`	`{`
`60`		`- if (slot < _preParsedCache.Length)`
	`63`	`+ if (slot < _placeholderCache.Length)`
`61`	`64`	`{`
`62`		`- var cached = _preParsedCache[slot];`
	`65`	`+ var cached = _placeholderCache[slot];`
`63`	`66`	`if (cached != null)`
`64`	`67`	`{`
`65`	`68`	`value = cached.Value;`
`@@ -71,13 +74,13 @@ public bool TryGetPreParsedCache(int slot, [NotNullWhen(true)] out PreParsedCach`
`71`	`74`	`}`
`72`	`75`
`73`	`76`	`[MethodImpl(MethodImplOptions.AggressiveInlining)]`
`74`		`- public void StorePreParsedCache(int slot, PreParsedCacheItem value)`
	`77`	`+ public void StorePlaceholderCache(int slot, PlaceholderCacheItem value)`
`75`	`78`	`{`
`76`		`- if (slot >= _preParsedCache.Length) //Resize the cache if needed.`
	`79`	`+ if (slot >= _placeholderCache.Length) //Resize the cache if needed.`
`77`	`80`	`{`
`78`		`- Array.Resize(ref _preParsedCache, (_preParsedCache.Length + 1) * 2);`
	`81`	`+ Array.Resize(ref _placeholderCache, (_placeholderCache.Length + 1) * 2);`
`79`	`82`	`}`
`80`		`- _preParsedCache[slot] = value;`
	`83`	`+ _placeholderCache[slot] = value;`
`81`	`84`	`}`
`82`	`85`
`83`	`86`	`#endregion`
`@@ -127,48 +130,48 @@ public PreComputedCacheItem GetPreComputedCacheItem(ReadOnlySpan<char> span)`
`127`	`130`
`128`	`131`	`public void HydrateTemplateParsedCache(int expressionHash)`
`129`	`132`	`{`
`130`		`- if (!_isPreParsedCacheHydrated)`
	`133`	`+ if (!_isPlaceholderCacheHydrated)`
`131`	`134`	`{`
`132`	`135`	`lock (this)`
`133`	`136`	`{`
`134`		`- if (!_isPreParsedCacheHydrated)`
	`137`	`+ if (!_isPlaceholderCacheHydrated)`
`135`	`138`	`{`
`136`	`139`	`if (Utility.PersistentCaches.TryGetValue(expressionHash, out CachedState? entry) && entry != null)`
`137`	`140`	`{`
`138`		`- entry.State.HydratePreParsedCache(_preParsedCache);`
	`141`	`+ entry.State.HydratePlaceholderCache(_placeholderCache);`
`139`	`142`	`}`
`140`		`- _isPreParsedCacheHydrated = true;`
	`143`	`+ _isPlaceholderCacheHydrated = true;`
`141`	`144`	`}`
`142`	`145`	`}`
`143`	`146`	`}`
`144`	`147`	`}`
`145`	`148`
`146`		`- private void HydratePreParsedCache(PreParsedCacheItem?[] populatedCache)`
	`149`	`+ private void HydratePlaceholderCache(PlaceholderCacheItem?[] populatedCache)`
`147`	`150`	`{`
`148`		`- Interlocked.Exchange(ref _preParsedCache, populatedCache);`
	`151`	`+ Interlocked.Exchange(ref _placeholderCache, populatedCache);`
`149`	`152`	`}`
`150`	`153`
`151`	`154`	`public void Reset(Sanitized sanitized)`
`152`	`155`	`{`
`153`	`156`	`_nextPreComputedCacheSlot = sanitized.ConsumedPreComputedCacheSlots;`
`154`		`- _nextPreParsedCacheSlot = 0;`
	`157`	`+ _nextPlaceholderCacheSlot = 0;`
`155`	`158`	`}`
`156`	`159`
`157`	`160`	`public ExpressionState Clone()`
`158`	`161`	`{`
`159`		`- var clone = new ExpressionState(_options)`
	`162`	`+ var clone = new ExpressionState(_options, WorkingText.Length * 2)`
`160`	`163`	`{`
`161`	`164`	`WorkingText = WorkingText,`
`162`	`165`	`_operationCount = _operationCount,`
`163`	`166`	`_nextPreComputedCacheSlot = _nextPreComputedCacheSlot,`
`164`	`167`	`_preComputedCache = new PreComputedCacheItem[_preComputedCache.Length],`
`165`		`- _preParsedCache = new PreParsedCacheItem?[_preParsedCache.Length],`
`166`		`- _nextPreParsedCacheSlot = 0,`
`167`		`- _isPreParsedCacheHydrated = _isPreParsedCacheHydrated`
	`168`	`+ _placeholderCache = new PlaceholderCacheItem?[_placeholderCache.Length],`
	`169`	`+ _nextPlaceholderCacheSlot = 0,`
	`170`	`+ _isPlaceholderCacheHydrated = _isPlaceholderCacheHydrated`
`168`	`171`	`};`
`169`	`172`
`170`	`173`	`Array.Copy(_preComputedCache, clone._preComputedCache, _preComputedCache.Length); //Copy any pre-computed NULLs.`
`171`		`- Array.Copy(_preParsedCache, clone._preParsedCache, _preParsedCache.Length);`
	`174`	`+ Array.Copy(_placeholderCache, clone._placeholderCache, _placeholderCache.Length);`
`172`	`175`
`173`	`176`	`return clone;`
`174`	`177`	`}`
Original file line number	Diff line number	Diff line change
`@@ -156,27 +156,27 @@ internal string Compute(bool isCacheable)`
`156`	`156`	`//Pre-first-order:`
`157`	`157`	`while ((operatorIndex = GetFreestandingNotOperation(out _)) != -1)`
`158`	`158`	`{`
`159`		`- var preParsedCacheSlot = _parentExpression.State.ConsumeNextPreParsedCacheSlot();`
	`159`	`+ var placeholderCacheSlot = _parentExpression.State.ConsumeNextPlaceholderCacheSlot();`
`160`	`160`
`161`		`- if (_parentExpression.State.TryGetPreParsedCache(preParsedCacheSlot, out PreParsedCacheItem cachedObj))`
	`161`	`+ if (_parentExpression.State.TryGetPlaceholderCache(placeholderCacheSlot, out PlaceholderCacheItem cachedObj))`
`162`	`162`	`{`
`163`	`163`	`StorePreComputed(cachedObj.BeginPosition, cachedObj.EndPosition, cachedObj.ParsedValue);`
`164`	`164`	`}`
`165`	`165`	`else`
`166`	`166`	`{`
`167`		`- var rightValue = GetRightValue(operatorIndex + 1, out int outParsedLength, out bool isOperCacheable);`
	`167`	`+ var rightValue = GetRightValue(operatorIndex + 1, out int outParsedLength, out bool isOperationCacheable);`
`168`	`168`	`int? calculatedResult = rightValue == null ? null : (rightValue == 0) ? 1 : 0;`
`169`	`169`	`StorePreComputed(operatorIndex, operatorIndex + outParsedLength, calculatedResult);`
`170`	`170`
`171`		`- if (isCacheable && isOperCacheable)`
	`171`	`+ if (isCacheable && isOperationCacheable)`
`172`	`172`	`{`
`173`		`- var parsedNumber = new PreParsedCacheItem`
	`173`	`+ var parsedNumber = new PlaceholderCacheItem`
`174`	`174`	`{`
`175`	`175`	`ParsedValue = calculatedResult,`
`176`	`176`	`BeginPosition = operatorIndex,`
`177`	`177`	`EndPosition = operatorIndex + outParsedLength`
`178`	`178`	`};`
`179`		`- _parentExpression.State.StorePreParsedCache(preParsedCacheSlot, parsedNumber);`
	`179`	`+ _parentExpression.State.StorePlaceholderCache(placeholderCacheSlot, parsedNumber);`
`180`	`180`	`}`
`181`	`181`	`}`
`182`	`182`	`}`
`@@ -185,30 +185,30 @@ internal string Compute(bool isCacheable)`
`185`	`185`	`operatorIndex = GetIndexOfOperation(Utility.FirstOrderOperations, out string operation);`
`186`	`186`	`if (operatorIndex > 0)`
`187`	`187`	`{`
`188`		`- var preParsedCacheSlot = _parentExpression.State.ConsumeNextPreParsedCacheSlot();`
	`188`	`+ var placeholderCacheSlot = _parentExpression.State.ConsumeNextPlaceholderCacheSlot();`
`189`	`189`
`190`		`- if (_parentExpression.State.TryGetPreParsedCache(preParsedCacheSlot, out PreParsedCacheItem cachedObj))`
	`190`	`+ if (_parentExpression.State.TryGetPlaceholderCache(placeholderCacheSlot, out PlaceholderCacheItem cachedObj))`
`191`	`191`	`{`
`192`	`192`	`StorePreComputed(cachedObj.BeginPosition, cachedObj.EndPosition, cachedObj.ParsedValue);`
`193`	`193`	`}`
`194`	`194`	`else`
`195`	`195`	`{`
`196`	`196`	`double? calculatedResult = null;`
`197`		`- if (GetLeftAndRightValues(operation, operatorIndex, out double leftValue, out double rightValue, out int beginPosition, out int endPosition, out bool isOperCacheable))`
	`197`	`+ if (GetLeftAndRightValues(operation, operatorIndex, out double leftValue, out double rightValue, out int beginPosition, out int endPosition, out bool isOperationCacheable))`
`198`	`198`	`{`
`199`	`199`	`calculatedResult = Utility.ComputePrivative(leftValue, operation, rightValue);`
`200`	`200`	`}`
`201`	`201`
`202`	`202`	`StorePreComputed(beginPosition, endPosition, calculatedResult);`
`203`		`- if (isCacheable && isOperCacheable)`
	`203`	`+ if (isCacheable && isOperationCacheable)`
`204`	`204`	`{`
`205`		`- var parsedNumber = new PreParsedCacheItem`
	`205`	`+ var parsedNumber = new PlaceholderCacheItem`
`206`	`206`	`{`
`207`	`207`	`ParsedValue = calculatedResult,`
`208`	`208`	`BeginPosition = beginPosition,`
`209`	`209`	`EndPosition = endPosition`
`210`	`210`	`};`
`211`		`- _parentExpression.State.StorePreParsedCache(preParsedCacheSlot, parsedNumber);`
	`211`	`+ _parentExpression.State.StorePlaceholderCache(placeholderCacheSlot, parsedNumber);`
`212`	`212`	`}`
`213`	`213`	`}`
`214`	`214`
`@@ -219,30 +219,30 @@ internal string Compute(bool isCacheable)`
`219`	`219`	`operatorIndex = GetIndexOfOperation(Utility.SecondOrderOperations, out operation);`
`220`	`220`	`if (operatorIndex > 0)`
`221`	`221`	`{`
`222`		`- var preParsedCacheSlot = _parentExpression.State.ConsumeNextPreParsedCacheSlot();`
	`222`	`+ var placeholderCacheSlot = _parentExpression.State.ConsumeNextPlaceholderCacheSlot();`
`223`	`223`
`224`		`- if (_parentExpression.State.TryGetPreParsedCache(preParsedCacheSlot, out PreParsedCacheItem cachedObj))`
	`224`	`+ if (_parentExpression.State.TryGetPlaceholderCache(placeholderCacheSlot, out PlaceholderCacheItem cachedObj))`
`225`	`225`	`{`
`226`	`226`	`StorePreComputed(cachedObj.BeginPosition, cachedObj.EndPosition, cachedObj.ParsedValue);`
`227`	`227`	`}`
`228`	`228`	`else`
`229`	`229`	`{`
`230`	`230`	`double? calculatedResult = null;`
`231`		`- if (GetLeftAndRightValues(operation, operatorIndex, out double leftValue, out double rightValue, out int beginPosition, out int endPosition, out bool isOperCacheable))`
	`231`	`+ if (GetLeftAndRightValues(operation, operatorIndex, out double leftValue, out double rightValue, out int beginPosition, out int endPosition, out bool isOperationCacheable))`
`232`	`232`	`{`
`233`	`233`	`calculatedResult = Utility.ComputePrivative(leftValue, operation, rightValue);`
`234`	`234`	`}`
`235`	`235`
`236`	`236`	`StorePreComputed(beginPosition, endPosition, calculatedResult);`
`237`		`- if (isCacheable && isOperCacheable)`
	`237`	`+ if (isCacheable && isOperationCacheable)`
`238`	`238`	`{`
`239`		`- var parsedNumber = new PreParsedCacheItem`
	`239`	`+ var parsedNumber = new PlaceholderCacheItem`
`240`	`240`	`{`
`241`	`241`	`ParsedValue = calculatedResult,`
`242`	`242`	`BeginPosition = beginPosition,`
`243`	`243`	`EndPosition = endPosition`
`244`	`244`	`};`
`245`		`- _parentExpression.State.StorePreParsedCache(preParsedCacheSlot, parsedNumber);`
	`245`	`+ _parentExpression.State.StorePlaceholderCache(placeholderCacheSlot, parsedNumber);`
`246`	`246`	`}`
`247`	`247`	`}`
`248`	`248`	`continue;`
`@@ -252,31 +252,31 @@ internal string Compute(bool isCacheable)`
`252`	`252`	`operatorIndex = GetIndexOfOperation(Utility.ThirdOrderOperations, out operation);`
`253`	`253`	`if (operatorIndex > 0)`
`254`	`254`	`{`
`255`		`- var preParsedCacheSlot = _parentExpression.State.ConsumeNextPreParsedCacheSlot();`
	`255`	`+ var placeholderCacheSlot = _parentExpression.State.ConsumeNextPlaceholderCacheSlot();`
`256`	`256`
`257`		`- if (_parentExpression.State.TryGetPreParsedCache(preParsedCacheSlot, out PreParsedCacheItem cachedObj))`
	`257`	`+ if (_parentExpression.State.TryGetPlaceholderCache(placeholderCacheSlot, out PlaceholderCacheItem cachedObj))`
`258`	`258`	`{`
`259`	`259`	`StorePreComputed(cachedObj.BeginPosition, cachedObj.EndPosition, cachedObj.ParsedValue);`
`260`	`260`	`}`
`261`	`261`	`else`
`262`	`262`	`{`
`263`	`263`	`double? calculatedResult = null;`
`264`	`264`
`265`		`- if (GetLeftAndRightValues(operation, operatorIndex, out double leftValue, out double rightValue, out int beginPosition, out int endPosition, out bool isOperCacheable))`
	`265`	`+ if (GetLeftAndRightValues(operation, operatorIndex, out double leftValue, out double rightValue, out int beginPosition, out int endPosition, out bool isOperationCacheable))`
`266`	`266`	`{`
`267`	`267`	`calculatedResult = Utility.ComputePrivative(leftValue, operation, rightValue);`
`268`	`268`	`}`
`269`	`269`
`270`	`270`	`StorePreComputed(beginPosition, endPosition, calculatedResult);`
`271`		`- if (isCacheable && isOperCacheable)`
	`271`	`+ if (isCacheable && isOperationCacheable)`
`272`	`272`	`{`
`273`		`- var parsedNumber = new PreParsedCacheItem`
	`273`	`+ var parsedNumber = new PlaceholderCacheItem`
`274`	`274`	`{`
`275`	`275`	`ParsedValue = calculatedResult,`
`276`	`276`	`BeginPosition = beginPosition,`
`277`	`277`	`EndPosition = endPosition`
`278`	`278`	`};`
`279`		`- _parentExpression.State.StorePreParsedCache(preParsedCacheSlot, parsedNumber);`
	`279`	`+ _parentExpression.State.StorePlaceholderCache(placeholderCacheSlot, parsedNumber);`
`280`	`280`	`}`
`281`	`281`	`}`
`282`	`282`	`continue;`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`/// </summary>`
`6`	`6`	`public delegate double? ExpressionFunction(double[] parameters);`
`7`	`7`
`8`		`- internal struct PreParsedCacheItem`
	`8`	`+ internal struct PlaceholderCacheItem`
`9`	`9`	`{`
`10`	`10`	`public double? ParsedValue;`
`11`	`11`	`public int BeginPosition;`