mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-16 17:10:20 -10:00
* replace DefineConstants with SDK ones Signed-off-by: dotnet-bot <[email protected]>
925 lines
37 KiB
C#
925 lines
37 KiB
C#
// Licensed to the .NET Foundation under one or more agreements.
|
|
// The .NET Foundation licenses this file to you under the MIT license.
|
|
// See the LICENSE file in the project root for more information.
|
|
|
|
using System.Diagnostics;
|
|
#if !NETSTANDARD2_0
|
|
using Internal.Runtime.CompilerServices;
|
|
#endif
|
|
|
|
namespace System
|
|
{
|
|
internal static partial class SpanHelpers // .T
|
|
{
|
|
public static int IndexOf<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength)
|
|
#nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
|
|
where T : IEquatable<T>
|
|
#nullable restore
|
|
{
|
|
Debug.Assert(searchSpaceLength >= 0);
|
|
Debug.Assert(valueLength >= 0);
|
|
|
|
if (valueLength == 0)
|
|
return 0; // A zero-length sequence is always treated as "found" at the start of the search space.
|
|
|
|
T valueHead = value;
|
|
ref T valueTail = ref Unsafe.Add(ref value, 1);
|
|
int valueTailLength = valueLength - 1;
|
|
|
|
int index = 0;
|
|
while (true)
|
|
{
|
|
Debug.Assert(0 <= index && index <= searchSpaceLength); // Ensures no deceptive underflows in the computation of "remainingSearchSpaceLength".
|
|
int remainingSearchSpaceLength = searchSpaceLength - index - valueTailLength;
|
|
if (remainingSearchSpaceLength <= 0)
|
|
break; // The unsearched portion is now shorter than the sequence we're looking for. So it can't be there.
|
|
|
|
// Do a quick search for the first element of "value".
|
|
int relativeIndex = IndexOf(ref Unsafe.Add(ref searchSpace, index), valueHead, remainingSearchSpaceLength);
|
|
if (relativeIndex == -1)
|
|
break;
|
|
index += relativeIndex;
|
|
|
|
// Found the first element of "value". See if the tail matches.
|
|
if (SequenceEqual(ref Unsafe.Add(ref searchSpace, index + 1), ref valueTail, valueTailLength))
|
|
return index; // The tail matched. Return a successful find.
|
|
|
|
index++;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
// Adapted from IndexOf(...)
|
|
public static unsafe bool Contains<T>(ref T searchSpace, T value, int length)
|
|
#nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
|
|
where T : IEquatable<T>
|
|
#nullable restore
|
|
{
|
|
Debug.Assert(length >= 0);
|
|
|
|
IntPtr index = (IntPtr)0; // Use IntPtr for arithmetic to avoid unnecessary 64->32->64 truncations
|
|
|
|
if (default(T)! != null || (object)value != null) // TODO-NULLABLE: default(T) == null warning (https://github.com/dotnet/roslyn/issues/34757)
|
|
{
|
|
while (length >= 8)
|
|
{
|
|
length -= 8;
|
|
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index + 0)) ||
|
|
value.Equals(Unsafe.Add(ref searchSpace, index + 1)) ||
|
|
value.Equals(Unsafe.Add(ref searchSpace, index + 2)) ||
|
|
value.Equals(Unsafe.Add(ref searchSpace, index + 3)) ||
|
|
value.Equals(Unsafe.Add(ref searchSpace, index + 4)) ||
|
|
value.Equals(Unsafe.Add(ref searchSpace, index + 5)) ||
|
|
value.Equals(Unsafe.Add(ref searchSpace, index + 6)) ||
|
|
value.Equals(Unsafe.Add(ref searchSpace, index + 7)))
|
|
{
|
|
goto Found;
|
|
}
|
|
|
|
index += 8;
|
|
}
|
|
|
|
if (length >= 4)
|
|
{
|
|
length -= 4;
|
|
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index + 0)) ||
|
|
value.Equals(Unsafe.Add(ref searchSpace, index + 1)) ||
|
|
value.Equals(Unsafe.Add(ref searchSpace, index + 2)) ||
|
|
value.Equals(Unsafe.Add(ref searchSpace, index + 3)))
|
|
{
|
|
goto Found;
|
|
}
|
|
|
|
index += 4;
|
|
}
|
|
|
|
while (length > 0)
|
|
{
|
|
length--;
|
|
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index)))
|
|
goto Found;
|
|
|
|
index += 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
byte* len = (byte*)length;
|
|
for (index = (IntPtr)0; index.ToPointer() < len; index += 1)
|
|
{
|
|
if ((object)Unsafe.Add(ref searchSpace, index) is null)
|
|
{
|
|
goto Found;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
|
|
Found:
|
|
return true;
|
|
}
|
|
|
|
public static unsafe int IndexOf<T>(ref T searchSpace, T value, int length)
|
|
#nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
|
|
where T : IEquatable<T>
|
|
#nullable restore
|
|
{
|
|
Debug.Assert(length >= 0);
|
|
|
|
IntPtr index = (IntPtr)0; // Use IntPtr for arithmetic to avoid unnecessary 64->32->64 truncations
|
|
if (default(T)! != null || (object)value != null) // TODO-NULLABLE: default(T) == null warning (https://github.com/dotnet/roslyn/issues/34757)
|
|
{
|
|
while (length >= 8)
|
|
{
|
|
length -= 8;
|
|
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index)))
|
|
goto Found;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index + 1)))
|
|
goto Found1;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index + 2)))
|
|
goto Found2;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index + 3)))
|
|
goto Found3;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index + 4)))
|
|
goto Found4;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index + 5)))
|
|
goto Found5;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index + 6)))
|
|
goto Found6;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index + 7)))
|
|
goto Found7;
|
|
|
|
index += 8;
|
|
}
|
|
|
|
if (length >= 4)
|
|
{
|
|
length -= 4;
|
|
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index)))
|
|
goto Found;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index + 1)))
|
|
goto Found1;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index + 2)))
|
|
goto Found2;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index + 3)))
|
|
goto Found3;
|
|
|
|
index += 4;
|
|
}
|
|
|
|
while (length > 0)
|
|
{
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, index)))
|
|
goto Found;
|
|
|
|
index += 1;
|
|
length--;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
byte* len = (byte*)length;
|
|
for (index = (IntPtr)0; index.ToPointer() < len; index += 1)
|
|
{
|
|
if ((object)Unsafe.Add(ref searchSpace, index) is null)
|
|
{
|
|
goto Found;
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
|
|
Found: // Workaround for https://github.com/dotnet/coreclr/issues/13549
|
|
return (int)(byte*)index;
|
|
Found1:
|
|
return (int)(byte*)(index + 1);
|
|
Found2:
|
|
return (int)(byte*)(index + 2);
|
|
Found3:
|
|
return (int)(byte*)(index + 3);
|
|
Found4:
|
|
return (int)(byte*)(index + 4);
|
|
Found5:
|
|
return (int)(byte*)(index + 5);
|
|
Found6:
|
|
return (int)(byte*)(index + 6);
|
|
Found7:
|
|
return (int)(byte*)(index + 7);
|
|
}
|
|
|
|
public static int IndexOfAny<T>(ref T searchSpace, T value0, T value1, int length)
|
|
#nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
|
|
where T : IEquatable<T>
|
|
#nullable restore
|
|
{
|
|
Debug.Assert(length >= 0);
|
|
|
|
T lookUp;
|
|
int index = 0;
|
|
if (default(T)! != null || ((object)value0 != null && (object)value1 != null)) // TODO-NULLABLE: default(T) == null warning (https://github.com/dotnet/roslyn/issues/34757)
|
|
{
|
|
while ((length - index) >= 8)
|
|
{
|
|
lookUp = Unsafe.Add(ref searchSpace, index);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 1);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found1;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 2);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found2;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 3);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found3;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 4);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found4;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 5);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found5;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 6);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found6;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 7);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found7;
|
|
|
|
index += 8;
|
|
}
|
|
|
|
if ((length - index) >= 4)
|
|
{
|
|
lookUp = Unsafe.Add(ref searchSpace, index);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 1);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found1;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 2);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found2;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 3);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found3;
|
|
|
|
index += 4;
|
|
}
|
|
|
|
while (index < length)
|
|
{
|
|
lookUp = Unsafe.Add(ref searchSpace, index);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found;
|
|
|
|
index++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (index = 0; index < length; index++)
|
|
{
|
|
lookUp = Unsafe.Add(ref searchSpace, index);
|
|
if ((object?)lookUp is null)
|
|
{
|
|
if ((object?)value0 is null || (object?)value1 is null)
|
|
{
|
|
goto Found;
|
|
}
|
|
}
|
|
else if (lookUp.Equals(value0) || lookUp.Equals(value1))
|
|
{
|
|
goto Found;
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
|
|
Found: // Workaround for https://github.com/dotnet/coreclr/issues/13549
|
|
return index;
|
|
Found1:
|
|
return index + 1;
|
|
Found2:
|
|
return index + 2;
|
|
Found3:
|
|
return index + 3;
|
|
Found4:
|
|
return index + 4;
|
|
Found5:
|
|
return index + 5;
|
|
Found6:
|
|
return index + 6;
|
|
Found7:
|
|
return index + 7;
|
|
}
|
|
|
|
public static int IndexOfAny<T>(ref T searchSpace, T value0, T value1, T value2, int length)
|
|
#nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
|
|
where T : IEquatable<T>
|
|
#nullable restore
|
|
{
|
|
Debug.Assert(length >= 0);
|
|
|
|
T lookUp;
|
|
int index = 0;
|
|
if (default(T)! != null || ((object)value0 != null && (object)value1 != null && (object)value2 != null)) // TODO-NULLABLE: default(T) == null warning (https://github.com/dotnet/roslyn/issues/34757)
|
|
{
|
|
while ((length - index) >= 8)
|
|
{
|
|
lookUp = Unsafe.Add(ref searchSpace, index);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 1);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found1;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 2);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found2;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 3);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found3;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 4);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found4;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 5);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found5;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 6);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found6;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 7);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found7;
|
|
|
|
index += 8;
|
|
}
|
|
|
|
if ((length - index) >= 4)
|
|
{
|
|
lookUp = Unsafe.Add(ref searchSpace, index);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 1);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found1;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 2);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found2;
|
|
lookUp = Unsafe.Add(ref searchSpace, index + 3);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found3;
|
|
|
|
index += 4;
|
|
}
|
|
|
|
while (index < length)
|
|
{
|
|
lookUp = Unsafe.Add(ref searchSpace, index);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found;
|
|
|
|
index++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (index = 0; index < length; index++)
|
|
{
|
|
lookUp = Unsafe.Add(ref searchSpace, index);
|
|
if ((object?)lookUp is null)
|
|
{
|
|
if ((object?)value0 is null || (object?)value1 is null || (object?)value2 is null)
|
|
{
|
|
goto Found;
|
|
}
|
|
}
|
|
else if (lookUp.Equals(value0) || lookUp.Equals(value1) || lookUp.Equals(value2))
|
|
{
|
|
goto Found;
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
|
|
Found: // Workaround for https://github.com/dotnet/coreclr/issues/13549
|
|
return index;
|
|
Found1:
|
|
return index + 1;
|
|
Found2:
|
|
return index + 2;
|
|
Found3:
|
|
return index + 3;
|
|
Found4:
|
|
return index + 4;
|
|
Found5:
|
|
return index + 5;
|
|
Found6:
|
|
return index + 6;
|
|
Found7:
|
|
return index + 7;
|
|
}
|
|
|
|
public static int IndexOfAny<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength)
|
|
#nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
|
|
where T : IEquatable<T>
|
|
#nullable restore
|
|
{
|
|
Debug.Assert(searchSpaceLength >= 0);
|
|
Debug.Assert(valueLength >= 0);
|
|
|
|
if (valueLength == 0)
|
|
return -1; // A zero-length set of values is always treated as "not found".
|
|
|
|
int index = -1;
|
|
for (int i = 0; i < valueLength; i++)
|
|
{
|
|
int tempIndex = IndexOf(ref searchSpace, Unsafe.Add(ref value, i), searchSpaceLength);
|
|
if ((uint)tempIndex < (uint)index)
|
|
{
|
|
index = tempIndex;
|
|
// Reduce space for search, cause we don't care if we find the search value after the index of a previously found value
|
|
searchSpaceLength = tempIndex;
|
|
|
|
if (index == 0)
|
|
break;
|
|
}
|
|
}
|
|
return index;
|
|
}
|
|
|
|
public static int LastIndexOf<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength)
|
|
#nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
|
|
where T : IEquatable<T>
|
|
#nullable restore
|
|
{
|
|
Debug.Assert(searchSpaceLength >= 0);
|
|
Debug.Assert(valueLength >= 0);
|
|
|
|
if (valueLength == 0)
|
|
return 0; // A zero-length sequence is always treated as "found" at the start of the search space.
|
|
|
|
T valueHead = value;
|
|
ref T valueTail = ref Unsafe.Add(ref value, 1);
|
|
int valueTailLength = valueLength - 1;
|
|
|
|
int index = 0;
|
|
while (true)
|
|
{
|
|
Debug.Assert(0 <= index && index <= searchSpaceLength); // Ensures no deceptive underflows in the computation of "remainingSearchSpaceLength".
|
|
int remainingSearchSpaceLength = searchSpaceLength - index - valueTailLength;
|
|
if (remainingSearchSpaceLength <= 0)
|
|
break; // The unsearched portion is now shorter than the sequence we're looking for. So it can't be there.
|
|
|
|
// Do a quick search for the first element of "value".
|
|
int relativeIndex = LastIndexOf(ref searchSpace, valueHead, remainingSearchSpaceLength);
|
|
if (relativeIndex == -1)
|
|
break;
|
|
|
|
// Found the first element of "value". See if the tail matches.
|
|
if (SequenceEqual(ref Unsafe.Add(ref searchSpace, relativeIndex + 1), ref valueTail, valueTailLength))
|
|
return relativeIndex; // The tail matched. Return a successful find.
|
|
|
|
index += remainingSearchSpaceLength - relativeIndex;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
public static int LastIndexOf<T>(ref T searchSpace, T value, int length)
|
|
#nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
|
|
where T : IEquatable<T>
|
|
#nullable restore
|
|
{
|
|
Debug.Assert(length >= 0);
|
|
|
|
if (default(T)! != null || (object)value != null) // TODO-NULLABLE: default(T) == null warning (https://github.com/dotnet/roslyn/issues/34757)
|
|
{
|
|
while (length >= 8)
|
|
{
|
|
length -= 8;
|
|
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, length + 7)))
|
|
goto Found7;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, length + 6)))
|
|
goto Found6;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, length + 5)))
|
|
goto Found5;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, length + 4)))
|
|
goto Found4;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, length + 3)))
|
|
goto Found3;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, length + 2)))
|
|
goto Found2;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, length + 1)))
|
|
goto Found1;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, length)))
|
|
goto Found;
|
|
}
|
|
|
|
if (length >= 4)
|
|
{
|
|
length -= 4;
|
|
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, length + 3)))
|
|
goto Found3;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, length + 2)))
|
|
goto Found2;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, length + 1)))
|
|
goto Found1;
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, length)))
|
|
goto Found;
|
|
}
|
|
|
|
while (length > 0)
|
|
{
|
|
length--;
|
|
|
|
if (value.Equals(Unsafe.Add(ref searchSpace, length)))
|
|
goto Found;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (length--; length >= 0; length--)
|
|
{
|
|
if ((object)Unsafe.Add(ref searchSpace, length) is null)
|
|
{
|
|
goto Found;
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
|
|
Found: // Workaround for https://github.com/dotnet/coreclr/issues/13549
|
|
return length;
|
|
Found1:
|
|
return length + 1;
|
|
Found2:
|
|
return length + 2;
|
|
Found3:
|
|
return length + 3;
|
|
Found4:
|
|
return length + 4;
|
|
Found5:
|
|
return length + 5;
|
|
Found6:
|
|
return length + 6;
|
|
Found7:
|
|
return length + 7;
|
|
}
|
|
|
|
public static int LastIndexOfAny<T>(ref T searchSpace, T value0, T value1, int length)
|
|
#nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
|
|
where T : IEquatable<T>
|
|
#nullable restore
|
|
{
|
|
Debug.Assert(length >= 0);
|
|
|
|
T lookUp;
|
|
if (default(T)! != null || ((object)value0 != null && (object)value1 != null)) // TODO-NULLABLE: default(T) == null warning (https://github.com/dotnet/roslyn/issues/34757)
|
|
{
|
|
while (length >= 8)
|
|
{
|
|
length -= 8;
|
|
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 7);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found7;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 6);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found6;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 5);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found5;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 4);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found4;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 3);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found3;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 2);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found2;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 1);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found1;
|
|
lookUp = Unsafe.Add(ref searchSpace, length);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found;
|
|
}
|
|
|
|
if (length >= 4)
|
|
{
|
|
length -= 4;
|
|
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 3);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found3;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 2);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found2;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 1);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found1;
|
|
lookUp = Unsafe.Add(ref searchSpace, length);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found;
|
|
}
|
|
|
|
while (length > 0)
|
|
{
|
|
length--;
|
|
|
|
lookUp = Unsafe.Add(ref searchSpace, length);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp))
|
|
goto Found;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (length--; length >= 0; length--)
|
|
{
|
|
lookUp = Unsafe.Add(ref searchSpace, length);
|
|
if ((object?)lookUp is null)
|
|
{
|
|
if ((object?)value0 is null || (object?)value1 is null)
|
|
{
|
|
goto Found;
|
|
}
|
|
}
|
|
else if (lookUp.Equals(value0) || lookUp.Equals(value1))
|
|
{
|
|
goto Found;
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
|
|
Found: // Workaround for https://github.com/dotnet/coreclr/issues/13549
|
|
return length;
|
|
Found1:
|
|
return length + 1;
|
|
Found2:
|
|
return length + 2;
|
|
Found3:
|
|
return length + 3;
|
|
Found4:
|
|
return length + 4;
|
|
Found5:
|
|
return length + 5;
|
|
Found6:
|
|
return length + 6;
|
|
Found7:
|
|
return length + 7;
|
|
}
|
|
|
|
public static int LastIndexOfAny<T>(ref T searchSpace, T value0, T value1, T value2, int length)
|
|
#nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
|
|
where T : IEquatable<T>
|
|
#nullable restore
|
|
{
|
|
Debug.Assert(length >= 0);
|
|
|
|
T lookUp;
|
|
if (default(T)! != null || ((object)value0 != null && (object)value1 != null)) // TODO-NULLABLE: default(T) == null warning (https://github.com/dotnet/roslyn/issues/34757)
|
|
{
|
|
while (length >= 8)
|
|
{
|
|
length -= 8;
|
|
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 7);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found7;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 6);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found6;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 5);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found5;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 4);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found4;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 3);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found3;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 2);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found2;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 1);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found1;
|
|
lookUp = Unsafe.Add(ref searchSpace, length);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found;
|
|
}
|
|
|
|
if (length >= 4)
|
|
{
|
|
length -= 4;
|
|
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 3);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found3;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 2);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found2;
|
|
lookUp = Unsafe.Add(ref searchSpace, length + 1);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found1;
|
|
lookUp = Unsafe.Add(ref searchSpace, length);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found;
|
|
}
|
|
|
|
while (length > 0)
|
|
{
|
|
length--;
|
|
|
|
lookUp = Unsafe.Add(ref searchSpace, length);
|
|
if (value0.Equals(lookUp) || value1.Equals(lookUp) || value2.Equals(lookUp))
|
|
goto Found;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (length--; length >= 0; length--)
|
|
{
|
|
lookUp = Unsafe.Add(ref searchSpace, length);
|
|
if ((object?)lookUp is null)
|
|
{
|
|
if ((object?)value0 is null || (object?)value1 is null || (object?)value2 is null)
|
|
{
|
|
goto Found;
|
|
}
|
|
}
|
|
else if (lookUp.Equals(value0) || lookUp.Equals(value1) || lookUp.Equals(value2))
|
|
{
|
|
goto Found;
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
|
|
Found: // Workaround for https://github.com/dotnet/coreclr/issues/13549
|
|
return length;
|
|
Found1:
|
|
return length + 1;
|
|
Found2:
|
|
return length + 2;
|
|
Found3:
|
|
return length + 3;
|
|
Found4:
|
|
return length + 4;
|
|
Found5:
|
|
return length + 5;
|
|
Found6:
|
|
return length + 6;
|
|
Found7:
|
|
return length + 7;
|
|
}
|
|
|
|
public static int LastIndexOfAny<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength)
|
|
#nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
|
|
where T : IEquatable<T>
|
|
#nullable restore
|
|
{
|
|
Debug.Assert(searchSpaceLength >= 0);
|
|
Debug.Assert(valueLength >= 0);
|
|
|
|
if (valueLength == 0)
|
|
return -1; // A zero-length set of values is always treated as "not found".
|
|
|
|
int index = -1;
|
|
for (int i = 0; i < valueLength; i++)
|
|
{
|
|
int tempIndex = LastIndexOf(ref searchSpace, Unsafe.Add(ref value, i), searchSpaceLength);
|
|
if (tempIndex > index)
|
|
index = tempIndex;
|
|
}
|
|
return index;
|
|
}
|
|
|
|
public static bool SequenceEqual<T>(ref T first, ref T second, int length)
|
|
#nullable disable // to enable use with both T and T? for reference types due to IEquatable<T> being invariant
|
|
where T : IEquatable<T>
|
|
#nullable restore
|
|
{
|
|
Debug.Assert(length >= 0);
|
|
|
|
if (Unsafe.AreSame(ref first, ref second))
|
|
goto Equal;
|
|
|
|
IntPtr index = (IntPtr)0; // Use IntPtr for arithmetic to avoid unnecessary 64->32->64 truncations
|
|
T lookUp0;
|
|
T lookUp1;
|
|
while (length >= 8)
|
|
{
|
|
length -= 8;
|
|
|
|
lookUp0 = Unsafe.Add(ref first, index);
|
|
lookUp1 = Unsafe.Add(ref second, index);
|
|
if (!(lookUp0?.Equals(lookUp1) ?? (object?)lookUp1 is null))
|
|
goto NotEqual;
|
|
lookUp0 = Unsafe.Add(ref first, index + 1);
|
|
lookUp1 = Unsafe.Add(ref second, index + 1);
|
|
if (!(lookUp0?.Equals(lookUp1) ?? (object?)lookUp1 is null))
|
|
goto NotEqual;
|
|
lookUp0 = Unsafe.Add(ref first, index + 2);
|
|
lookUp1 = Unsafe.Add(ref second, index + 2);
|
|
if (!(lookUp0?.Equals(lookUp1) ?? (object?)lookUp1 is null))
|
|
goto NotEqual;
|
|
lookUp0 = Unsafe.Add(ref first, index + 3);
|
|
lookUp1 = Unsafe.Add(ref second, index + 3);
|
|
if (!(lookUp0?.Equals(lookUp1) ?? (object?)lookUp1 is null))
|
|
goto NotEqual;
|
|
lookUp0 = Unsafe.Add(ref first, index + 4);
|
|
lookUp1 = Unsafe.Add(ref second, index + 4);
|
|
if (!(lookUp0?.Equals(lookUp1) ?? (object?)lookUp1 is null))
|
|
goto NotEqual;
|
|
lookUp0 = Unsafe.Add(ref first, index + 5);
|
|
lookUp1 = Unsafe.Add(ref second, index + 5);
|
|
if (!(lookUp0?.Equals(lookUp1) ?? (object?)lookUp1 is null))
|
|
goto NotEqual;
|
|
lookUp0 = Unsafe.Add(ref first, index + 6);
|
|
lookUp1 = Unsafe.Add(ref second, index + 6);
|
|
if (!(lookUp0?.Equals(lookUp1) ?? (object?)lookUp1 is null))
|
|
goto NotEqual;
|
|
lookUp0 = Unsafe.Add(ref first, index + 7);
|
|
lookUp1 = Unsafe.Add(ref second, index + 7);
|
|
if (!(lookUp0?.Equals(lookUp1) ?? (object?)lookUp1 is null))
|
|
goto NotEqual;
|
|
|
|
index += 8;
|
|
}
|
|
|
|
if (length >= 4)
|
|
{
|
|
length -= 4;
|
|
|
|
lookUp0 = Unsafe.Add(ref first, index);
|
|
lookUp1 = Unsafe.Add(ref second, index);
|
|
if (!(lookUp0?.Equals(lookUp1) ?? (object?)lookUp1 is null))
|
|
goto NotEqual;
|
|
lookUp0 = Unsafe.Add(ref first, index + 1);
|
|
lookUp1 = Unsafe.Add(ref second, index + 1);
|
|
if (!(lookUp0?.Equals(lookUp1) ?? (object?)lookUp1 is null))
|
|
goto NotEqual;
|
|
lookUp0 = Unsafe.Add(ref first, index + 2);
|
|
lookUp1 = Unsafe.Add(ref second, index + 2);
|
|
if (!(lookUp0?.Equals(lookUp1) ?? (object?)lookUp1 is null))
|
|
goto NotEqual;
|
|
lookUp0 = Unsafe.Add(ref first, index + 3);
|
|
lookUp1 = Unsafe.Add(ref second, index + 3);
|
|
if (!(lookUp0?.Equals(lookUp1) ?? (object?)lookUp1 is null))
|
|
goto NotEqual;
|
|
|
|
index += 4;
|
|
}
|
|
|
|
while (length > 0)
|
|
{
|
|
lookUp0 = Unsafe.Add(ref first, index);
|
|
lookUp1 = Unsafe.Add(ref second, index);
|
|
if (!(lookUp0?.Equals(lookUp1) ?? (object?)lookUp1 is null))
|
|
goto NotEqual;
|
|
index += 1;
|
|
length--;
|
|
}
|
|
|
|
Equal:
|
|
return true;
|
|
|
|
NotEqual: // Workaround for https://github.com/dotnet/coreclr/issues/13549
|
|
return false;
|
|
}
|
|
|
|
public static int SequenceCompareTo<T>(ref T first, int firstLength, ref T second, int secondLength)
|
|
where T : IComparable<T>
|
|
{
|
|
Debug.Assert(firstLength >= 0);
|
|
Debug.Assert(secondLength >= 0);
|
|
|
|
int minLength = firstLength;
|
|
if (minLength > secondLength)
|
|
minLength = secondLength;
|
|
for (int i = 0; i < minLength; i++)
|
|
{
|
|
T lookUp = Unsafe.Add(ref second, i);
|
|
int result = (Unsafe.Add(ref first, i)?.CompareTo(lookUp) ?? (((object?)lookUp is null) ? 0 : -1));
|
|
if (result != 0)
|
|
return result;
|
|
}
|
|
return firstLength.CompareTo(secondLength);
|
|
}
|
|
}
|
|
}
|