private static int Log2SoftwareFallbackPow2(uint value)
{
if ((value & (value - 1)) == 0) // Power of 2
{
// uint.MaxValue >> 27 is always in range [0 - 31] so we use Unsafe.AddByteOffset to avoid bounds check
return(Unsafe.AddByteOffset(
// Using deBruijn sequence, k=2, n=5 (2^5=32) : 0b_0000_0111_0111_1100_1011_0101_0011_0001u
ref MemoryMarshal.GetReference(s_Log2DeBruijnPow2),
// long -> IntPtr cast on 32-bit platforms is expensive - it does overflow checks not needed here
(IntPtr)(int)((value * 0x077CB531u) >> 27)));
}
value |= value >> 01;
value |= value >> 02;
value |= value >> 04;
value |= value >> 08;
value |= value >> 16;
// uint.MaxValue >> 27 is always in range [0 - 31] so we use Unsafe.AddByteOffset to avoid bounds check
return(Unsafe.AddByteOffset(
// Using deBruijn sequence, k=2, n=5 (2^5=32) : 0b_0000_0111_1100_0100_1010_1100_1101_1101u
ref MemoryMarshal.GetReference(s_Log2DeBruijn),
// long -> IntPtr cast on 32-bit platforms is expensive - it does overflow checks not needed here
(IntPtr)(int)((value * 0x07C4ACDDu) >> 27)));
}
private static Int64 ReadFast(ref MessagePackReader reader, ref byte position)
{
var value = Unsafe.AddByteOffset(ref position, (IntPtr)1);
reader.AdvanceWithinSpan(2);
return(value);
}
internal static void WriteRawBytes(ref byte destination, ref byte source, int sourceBytesToCopy, ref int idx)
{
//if (0u >= (uint)sourceBytesToCopy) { return; }
MessagePackBinary.CopyMemory(ref source, ref Unsafe.AddByteOffset(ref destination, (IntPtr)idx), sourceBytesToCopy);
idx += sourceBytesToCopy;
}
public Float64Bits(ref byte bigEndianBytes)
{
this = default(Float64Bits);
IntPtr offset = (IntPtr)1;
if (BitConverter.IsLittleEndian)
{
this.Byte0 = Unsafe.AddByteOffset(ref bigEndianBytes, offset + 7);
this.Byte1 = Unsafe.AddByteOffset(ref bigEndianBytes, offset + 6);
this.Byte2 = Unsafe.AddByteOffset(ref bigEndianBytes, offset + 5);
this.Byte3 = Unsafe.AddByteOffset(ref bigEndianBytes, offset + 4);
this.Byte4 = Unsafe.AddByteOffset(ref bigEndianBytes, offset + 3);
this.Byte5 = Unsafe.AddByteOffset(ref bigEndianBytes, offset + 2);
this.Byte6 = Unsafe.AddByteOffset(ref bigEndianBytes, offset + 1);
this.Byte7 = Unsafe.AddByteOffset(ref bigEndianBytes, offset);
}
else
{
this.Byte0 = Unsafe.AddByteOffset(ref bigEndianBytes, offset);
this.Byte1 = Unsafe.AddByteOffset(ref bigEndianBytes, offset + 1);
this.Byte2 = Unsafe.AddByteOffset(ref bigEndianBytes, offset + 2);
this.Byte3 = Unsafe.AddByteOffset(ref bigEndianBytes, offset + 3);
this.Byte4 = Unsafe.AddByteOffset(ref bigEndianBytes, offset + 4);
this.Byte5 = Unsafe.AddByteOffset(ref bigEndianBytes, offset + 5);
this.Byte6 = Unsafe.AddByteOffset(ref bigEndianBytes, offset + 6);
this.Byte7 = Unsafe.AddByteOffset(ref bigEndianBytes, offset + 7);
}
}
private static int ViaUnsafe(uint value)
{
int log10 = Unsafe.AddByteOffset(
ref MemoryMarshal.GetReference(s_Log10Ceiling32),
(IntPtr)BitOps.LeadingZeroCount(value));
//var u = Unsafe.AsRef<uint[]>(_foo);// s_Pow10Ceiling32);
var u = new ReadOnlySpan <uint>(s_Pow10Ceiling32);
//ReadOnlySpan<uint> u = stackalloc uint[12]
//{
// 0,
// 1,
// 10,
// 100,
// 1000,
// 10000,
// 100000,
// 1000000,
// 10000000,
// 100000000,
// 1000000000,
// 0
//};
//fixed (uint* u = Unsafe.AsRef(_foo))
{
int diff = (int)((value - u[log10]) >> 31);
//int diff = unchecked((int)((value - Unsafe.Add(ref s_Pow10Ceiling32.GetRawSzArrayData(), y)) >> 31));
return((int)(log10 - diff));
}
}
internal static ref byte ComputeEffectiveAddress(
ref byte nativePtr,
Index1 index,
int elementSize) =>
ref Unsafe.AddByteOffset(
ref nativePtr,
new IntPtr(index * elementSize));
private static unsafe bool AreEqual_Current(ref byte first, ref byte second, int l)
{
IntPtr length = (IntPtr)l;
#if !NETSTANDARD2_0 && !NET461 && !NET47 && !NETCOREAPP2_1
if (Avx2.IsSupported && (byte *)length == (byte *)64)
{
return
(Avx2.MoveMask(Avx2.CompareEqual(Unsafe.ReadUnaligned <Vector256 <byte> >(ref first), Unsafe.ReadUnaligned <Vector256 <byte> >(ref second))) == unchecked ((int)0b1111_1111_1111_1111_1111_1111_1111_1111)
& Avx2.MoveMask(Avx2.CompareEqual(Unsafe.ReadUnaligned <Vector256 <byte> >(ref Unsafe.AddByteOffset(ref first, (IntPtr)32)), Unsafe.ReadUnaligned <Vector256 <byte> >(ref Unsafe.AddByteOffset(ref second, (IntPtr)32)))) == unchecked ((int)0b1111_1111_1111_1111_1111_1111_1111_1111));
}
else if (Avx2.IsSupported && (byte *)length == (byte *)32)
{
return(Avx2.MoveMask(Avx2.CompareEqual(Unsafe.ReadUnaligned <Vector256 <byte> >(ref first), Unsafe.ReadUnaligned <Vector256 <byte> >(ref second))) == unchecked ((int)0b1111_1111_1111_1111_1111_1111_1111_1111));
}
else if (Sse2.IsSupported && (byte *)length == (byte *)16)
{
return(Sse2.MoveMask(Sse2.CompareEqual(Unsafe.ReadUnaligned <Vector128 <byte> >(ref first), Unsafe.ReadUnaligned <Vector128 <byte> >(ref second))) == 0b1111_1111_1111_1111);
}
else
#endif
if (Vector.IsHardwareAccelerated && (byte *)length >= (byte *)Vector <byte> .Count)
{
Vector <byte> accumulator = new Vector <byte>();
IntPtr endOffset = length - sizeof(Vector <byte>);
ref byte firstEnd = ref Unsafe.AddByteOffset(ref first, endOffset);
ref byte secondEnd = ref Unsafe.AddByteOffset(ref second, endOffset);
private static int GetDigitValueInternalNoBoundsCheck(uint codePoint)
{
nuint offset = GetNumericGraphemeTableOffsetNoBoundsChecks(codePoint);
int rawValue = Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(DigitValues), offset);
return((rawValue & 0xF) - 1); // return the low nibble of the result, minus 1 so that "not a digit value" gets normalized to -1
}
private unsafe static void SetDecimal(ref byte start, decimal value)
{
var bits = decimal.GetBits(value);
uint lo = (uint)bits[0];
uint mid = (uint)bits[1];
uint high = (uint)bits[2];
uint flags = (uint)bits[3];
IntPtr offset = (IntPtr)0;
Unsafe.AddByteOffset(ref start, offset) = (byte)(lo >> 24); // lo
Unsafe.AddByteOffset(ref start, offset + 1) = (byte)(lo >> 16);
Unsafe.AddByteOffset(ref start, offset + 2) = (byte)(lo >> 8);
Unsafe.AddByteOffset(ref start, offset + 3) = (byte)lo;
Unsafe.AddByteOffset(ref start, offset + 4) = (byte)(mid >> 24); // mid
Unsafe.AddByteOffset(ref start, offset + 5) = (byte)(mid >> 16);
Unsafe.AddByteOffset(ref start, offset + 6) = (byte)(mid >> 8);
Unsafe.AddByteOffset(ref start, offset + 7) = (byte)mid;
Unsafe.AddByteOffset(ref start, offset + 8) = (byte)(high >> 24); // high
Unsafe.AddByteOffset(ref start, offset + 9) = (byte)(high >> 16);
Unsafe.AddByteOffset(ref start, offset + 10) = (byte)(high >> 8);
Unsafe.AddByteOffset(ref start, offset + 11) = (byte)high;
Unsafe.AddByteOffset(ref start, offset + 12) = (byte)(flags >> 24); // flags
Unsafe.AddByteOffset(ref start, offset + 13) = (byte)(flags >> 16);
Unsafe.AddByteOffset(ref start, offset + 14) = (byte)(flags >> 8);
Unsafe.AddByteOffset(ref start, offset + 15) = (byte)flags;
}
public sbyte ReadFast(ref MessagePackReader reader, ref byte position)
{
var value = unchecked ((sbyte)Unsafe.AddByteOffset(ref position, (IntPtr)1));
reader.AdvanceWithinSpan(2);
return(value);
}
private static void _BulkMoveWithWriteBarrier(ref byte destination, ref byte source, nuint byteCount)
{
Debug.Assert(byteCount > BulkMoveWithWriteBarrierChunk);
if (Unsafe.AreSame(ref source, ref destination))
{
return;
}
// This is equivalent to: (destination - source) >= byteCount || (destination - source) < 0
if ((nuint)(nint)Unsafe.ByteOffset(ref source, ref destination) >= byteCount)
{
// Copy forwards
do
{
byteCount -= BulkMoveWithWriteBarrierChunk;
__BulkMoveWithWriteBarrier(ref destination, ref source, BulkMoveWithWriteBarrierChunk);
destination = ref Unsafe.AddByteOffset(ref destination, BulkMoveWithWriteBarrierChunk);
source = ref Unsafe.AddByteOffset(ref source, BulkMoveWithWriteBarrierChunk);
}while (byteCount > BulkMoveWithWriteBarrierChunk);
}
else
{
// Copy backwards
do
{
byteCount -= BulkMoveWithWriteBarrierChunk;
__BulkMoveWithWriteBarrier(ref Unsafe.AddByteOffset(ref destination, byteCount), ref Unsafe.AddByteOffset(ref source, byteCount), BulkMoveWithWriteBarrierChunk);
}while (byteCount > BulkMoveWithWriteBarrierChunk);
}
__BulkMoveWithWriteBarrier(ref destination, ref source, byteCount);
}
private unsafe static void SetDecimalLE(ref byte start, decimal value)
{
var bits = decimal.GetBits(value);
uint lo = (uint)bits[0];
uint mid = (uint)bits[1];
uint high = (uint)bits[2];
uint flags = (uint)bits[3];
nint offset = 0;
Unsafe.AddByteOffset(ref start, offset) = (byte)lo;
Unsafe.AddByteOffset(ref start, offset + 1) = (byte)(lo >> 8);
Unsafe.AddByteOffset(ref start, offset + 2) = (byte)(lo >> 16);
Unsafe.AddByteOffset(ref start, offset + 3) = (byte)(lo >> 24); // lo
Unsafe.AddByteOffset(ref start, offset + 4) = (byte)mid;
Unsafe.AddByteOffset(ref start, offset + 5) = (byte)(mid >> 8);
Unsafe.AddByteOffset(ref start, offset + 6) = (byte)(mid >> 16);
Unsafe.AddByteOffset(ref start, offset + 7) = (byte)(mid >> 24); // mid
offset += 8;
Unsafe.AddByteOffset(ref start, offset) = (byte)high;
Unsafe.AddByteOffset(ref start, offset + 1) = (byte)(high >> 8);
Unsafe.AddByteOffset(ref start, offset + 2) = (byte)(high >> 16);
Unsafe.AddByteOffset(ref start, offset + 3) = (byte)(high >> 24); // high
Unsafe.AddByteOffset(ref start, offset + 4) = (byte)flags;
Unsafe.AddByteOffset(ref start, offset + 5) = (byte)(flags >> 8);
Unsafe.AddByteOffset(ref start, offset + 6) = (byte)(flags >> 16);
Unsafe.AddByteOffset(ref start, offset + 7) = (byte)(flags >> 24); // flags
}
/// <summary>
/// Clears the contents of this span.
/// </summary>
public unsafe void Clear()
{
int length = _length;
if (length == 0)
{
return;
}
var byteLength = (UIntPtr)((uint)length * Unsafe.SizeOf <T>());
if ((Unsafe.SizeOf <T>() & (sizeof(IntPtr) - 1)) != 0)
{
if (_pinnable == null)
{
var ptr = (byte *)_byteOffset.ToPointer();
SpanHelpers.ClearLessThanPointerSized(ptr, byteLength);
}
else
{
ref byte b = ref Unsafe.As <T, byte>(ref Unsafe.AddByteOffset <T>(ref _pinnable.Data, _byteOffset));
SpanHelpers.ClearLessThanPointerSized(ref b, byteLength);
}
}
private static bool EqualsOrdinalIgnoreCaseNonAscii(ref char charA, ref char charB, int length)
{
//if (!GlobalizationMode.Invariant)
//{
// return CompareStringOrdinalIgnoreCase(ref charA, length, ref charB, length) == 0;
//}
//else
{
// If we don't have localization tables to consult, we'll still perform a case-insensitive
// check for ASCII characters, but if we see anything outside the ASCII range we'll immediately
// fail if it doesn't have true bitwise equality.
IntPtr byteOffset = IntPtr.Zero;
while (length != 0)
{
// Ordinal equals or lowercase equals if the result ends up in the a-z range
uint valueA = Unsafe.AddByteOffset(ref charA, byteOffset);
uint valueB = Unsafe.AddByteOffset(ref charB, byteOffset);
if (valueA == valueB ||
((valueA | 0x20) == (valueB | 0x20) &&
(uint)((valueA | 0x20) - 'a') <= (uint)('z' - 'a')))
{
byteOffset += 2;
length--;
}
else
{
return(false);
}
}
return(true);
}
}
public static long Make(ReadOnlySpan <byte> x)
{
unchecked
{
long hashCode = 0;
var i8Span = MemoryMarshal.Cast <byte, long>(x);
foreach (var v in i8Span)
{
hashCode = (hashCode * 397) ^ v;
}
var remainingLength = x.Length & 7;
var i1Span = x.Slice(x.Length - remainingLength, remainingLength);
ref var i1Ref = ref MemoryMarshal.GetReference(i1Span);
switch (remainingLength)
{
case 0:
break;
case 1:
hashCode = (hashCode * 397) ^ i1Ref;
break;
case 2:
hashCode = (hashCode * 397) ^ Unsafe.ReadUnaligned <ushort>(ref i1Ref);
break;
case 3:
hashCode = (hashCode * 397) ^ Unsafe.ReadUnaligned <ushort>(ref i1Ref);
hashCode = (hashCode * 397) ^ Unsafe.ReadUnaligned <byte>(ref Unsafe.AddByteOffset(ref i1Ref, (IntPtr)2));
break;
case 4:
hashCode = (hashCode * 397) ^ Unsafe.ReadUnaligned <uint>(ref i1Ref);
break;
case 5:
hashCode = (hashCode * 397) ^ Unsafe.ReadUnaligned <uint>(ref i1Ref);
hashCode = (hashCode * 397) ^ Unsafe.ReadUnaligned <byte>(ref Unsafe.AddByteOffset(ref i1Ref, (IntPtr)4));
break;
case 6:
hashCode = (hashCode * 397) ^ Unsafe.ReadUnaligned <uint>(ref i1Ref);
hashCode = (hashCode * 397) ^ Unsafe.ReadUnaligned <ushort>(ref Unsafe.AddByteOffset(ref i1Ref, (IntPtr)4));
break;
case 7:
hashCode = (hashCode * 397) ^ Unsafe.ReadUnaligned <uint>(ref i1Ref);
hashCode = (hashCode * 397) ^ Unsafe.ReadUnaligned <ushort>(ref Unsafe.AddByteOffset(ref i1Ref, (IntPtr)4));
hashCode = (hashCode * 397) ^ Unsafe.ReadUnaligned <byte>(ref Unsafe.AddByteOffset(ref i1Ref, (IntPtr)6));
break;
}
return(hashCode);
}
public static uint32_t is_structural_or_whitespace(uint8_t c)
{
// Bypass bounds check as c can never
// exceed the bounds of structural_or_whitespace
return(Unsafe.AddByteOffset(
ref MemoryMarshal.GetReference(structural_or_whitespace),
(IntPtr)c));
}
private static ExtensionResult ReadFast(ref MessagePackReader reader, ref byte position)
{
var typeCode = unchecked ((sbyte)Unsafe.AddByteOffset(ref position, (IntPtr)1));
var valueSpan = reader.PeekFast(2, 1);
reader.AdvanceWithinSpan(3);
return(new ExtensionResult(typeCode, valueSpan));
}
private static uint8_t escape(uint8_t c)
{
// Bypass bounds check as c can never
// exceed the bounds of escape_map
return Unsafe.AddByteOffset(
ref MemoryMarshal.GetReference(escape_map),
(IntPtr)c);
}
private static String ReadFast(ref MessagePackReader reader, ref byte position)
{
var length = (int)Unsafe.AddByteOffset(ref position, (IntPtr)1);
var valueSpan = reader.PeekFast(2, length);
reader.AdvanceWithinSpan(length + 2);
return(EncodingUtils.ToString(valueSpan));
}
private static Int16 ReadFast(ref MessagePackReader reader, ref byte position)
{
IntPtr offset = (IntPtr)1;
var value = checked ((short)((Unsafe.AddByteOffset(ref position, offset) << 8) + Unsafe.AddByteOffset(ref position, offset + 1)));
reader.AdvanceWithinSpan(3);
return(value);
}
public static T Deserialize <T>(this JsonElement element, JsonSerializerOptions?options = null)
{
JsonDocument documentRef = Unsafe.As <JsonElement, JsonDocument>(ref element);
int idxPtr = Unsafe.AddByteOffset(ref Unsafe.As <JsonElement, int>(ref element), new IntPtr(IntPtr.Size));
ReadOnlyMemory <byte> memory = _jsonDocumentGetRawdataDelegate(documentRef, idxPtr, true);
return(JsonSerializer.Deserialize <T>(memory.Span, options) !);
}
private static Int64 ReadFast(ref MessagePackReader reader, ref byte position)
{
IntPtr offset = (IntPtr)1;
var value = (Unsafe.AddByteOffset(ref position, offset) << 8) | Unsafe.AddByteOffset(ref position, offset + 1);
reader.AdvanceWithinSpan(3);
return(value);
}
public static bool is_not_structural_or_whitespace_or_exponent_or_decimal(uchar1 c)
{
// Bypass bounds check as c can never
// exceed the bounds of structural_or_whitespace_or_exponent_or_decimal_negated
return(Unsafe.AddByteOffset(
ref MemoryMarshal.GetReference(structural_or_whitespace_or_exponent_or_decimal_negated),
(IntPtr)c) == 1);
}
public void WriteIid(string name, Guid value)
{
if (_config.GenerateUnmanagedConstants)
{
AddUsingDirective("System");
AddUsingDirective("System.Diagnostics");
AddUsingDirective("System.Runtime.CompilerServices");
AddUsingDirective("System.Runtime.InteropServices");
WriteIndented("public static ref readonly Guid ");
WriteLine(name);
WriteBlockStart();
WriteIndentedLine("get");
WriteBlockStart();
WriteIndentedLine("ReadOnlySpan<byte> data = new byte[] {");
IncreaseIndentation();
WriteIndentation();
WriteValueAsBytes(Unsafe.As <Guid, uint>(ref value), 4);
WriteLine(',');
WriteIndentation();
WriteValueAsBytes(Unsafe.As <Guid, ushort>(ref Unsafe.AddByteOffset(ref value, (nint)4)), 2);
WriteLine(',');
WriteIndentation();
WriteValueAsBytes(Unsafe.As <Guid, ushort>(ref Unsafe.AddByteOffset(ref value, (nint)6)), 2);
for (var i = 8; i < 16; i++)
{
WriteLine(',');
WriteIndentation();
WriteValueAsBytes(Unsafe.As <Guid, ushort>(ref Unsafe.AddByteOffset(ref value, (nint)i)), 1);
}
WriteNewline();
DecreaseIndentation();
WriteIndentedLine("};");
NeedsNewline = true;
WriteIndentedLine("Debug.Assert(data.Length == Unsafe.SizeOf<Guid>());");
WriteIndentedLine("return ref Unsafe.As<byte, Guid>(ref MemoryMarshal.GetReference(data));");
WriteBlockEnd();
WriteBlockEnd();
}
else
{
var valueString = value.ToString("X").ToUpperInvariant().Replace("{", "").Replace("}", "").Replace('X', 'x').Replace(",", ", ");
WriteIid(name, valueString);
}
}
private static void ReadFast(ref MessagePackReader reader, ref byte position)
{
IntPtr offset = (IntPtr)1;
var length = unchecked (
(Unsafe.AddByteOffset(ref position, offset) << 8) |
Unsafe.AddByteOffset(ref position, offset + 1));
reader.AdvanceWithinSpan(length + 3);
}
private static String ReadFast(ref MessagePackReader reader, ref byte position)
{
IntPtr offset = (IntPtr)1;
var length = unchecked ((Unsafe.AddByteOffset(ref position, offset) << 8) + Unsafe.AddByteOffset(ref position, offset + 1));
var valueSpan = reader.PeekFast(3, length);
reader.AdvanceWithinSpan(length + 3);
return(EncodingUtils.ToString(valueSpan));
}
private unsafe static void SetMediumLE(ref byte start, int value)
{
uint unsignedValue = (uint)value;
nint offset = 0;
Unsafe.AddByteOffset(ref start, offset) = (byte)unsignedValue;
Unsafe.AddByteOffset(ref start, offset + 1) = (byte)(unsignedValue >> 8);
Unsafe.AddByteOffset(ref start, offset + 2) = (byte)(unsignedValue >> 16);
}
public static long UnsafeUnpackVInt(ref byte data, int len)
{
switch (len)
{
case 1:
return((long)data - 0x80);
case 2:
{
var sign = (long)((data & 0x80) >> 7) - 1; // -1 for negative, 0 for positive
return((0x1fffu & AsBigEndian(Unsafe.ReadUnaligned <ushort>(ref data))) - (0x2000 & sign));
}
case 3:
{
var sign = (long)((data & 0x80) >> 7) - 1; // -1 for negative, 0 for positive
var res = (data & 0x0F) << 16;
data = ref Unsafe.AddByteOffset(ref data, (IntPtr)1);
return(res + AsBigEndian(Unsafe.ReadUnaligned <ushort>(ref data)) - (0x10_0000 & sign));
}
case 4:
{
var sign = (long)((data & 0x80) >> 7) - 1; // -1 for negative, 0 for positive
return((0x07ff_ffff & AsBigEndian(Unsafe.ReadUnaligned <uint>(ref data))) - (0x0800_0000 & sign));
}
case 5:
{
var sign = (long)((data & 0x80) >> 7) - 1; // -1 for negative, 0 for positive
var res = (long)(data & 0x03u) << 32;
data = ref Unsafe.AddByteOffset(ref data, (IntPtr)1);
return(res + AsBigEndian(Unsafe.ReadUnaligned <uint>(ref data)) - (0x04_0000_0000 & sign));
}
case 6:
{
var sign = (long)((data & 0x80) >> 7) - 1; // -1 for negative, 0 for positive
var res = (0x01ffL & AsBigEndian(Unsafe.ReadUnaligned <ushort>(ref data))) << 32;
data = ref Unsafe.AddByteOffset(ref data, (IntPtr)2);
return(res + AsBigEndian(Unsafe.ReadUnaligned <uint>(ref data)) - (0x0200_0000_0000 & sign));
}
case 7:
{
var sign = (long)((data & 0x80) >> 7) - 1; // -1 for negative, 0 for positive
data = ref Unsafe.AddByteOffset(ref data, (IntPtr)1);
var res = (long)AsBigEndian(Unsafe.ReadUnaligned <ushort>(ref data)) << 32;
data = ref Unsafe.AddByteOffset(ref data, (IntPtr)2);
return(res + AsBigEndian(Unsafe.ReadUnaligned <uint>(ref data)) - (0x01_0000_0000_0000 & sign));
}
default:
data = ref Unsafe.AddByteOffset(ref data, (IntPtr)1);
return((long)AsBigEndian(Unsafe.ReadUnaligned <ulong>(ref data)));
}
}
public static int TrailingZeroCount(uint value)
{
// uint.MaxValue >> 27 is always in range [0 - 31] so we use Unsafe.AddByteOffset to avoid bounds check
return(Unsafe.AddByteOffset(
// Using deBruijn sequence, k=2, n=5 (2^5=32) : 0b_0000_0111_0111_1100_1011_0101_0011_0001u
ref MemoryMarshal.GetReference(TrailingZeroCountDeBruijn),
// uint|long -> IntPtr cast on 32-bit platforms does expensive overflow checks not needed here
(IntPtr)(int)(((value & (uint)-(int)value) * 0x077CB531u) >> 27))); // Multi-cast mitigates redundant conv.u8
}
/*
* GetIsWhiteSpace
* ===========================
* Data derived from https://unicode.org/reports/tr44/#White_Space. Represents whether a code point
* is listed as White_Space per PropList.txt.
*/
internal static bool GetIsWhiteSpace(char ch)
{
// We don't need a (string, int) overload because all current white space chars are in the BMP.
nuint offset = GetCategoryCasingTableOffsetNoBoundsChecks(ch);
// High bit of each value in the 'CategoriesValues' array denotes whether this code point is white space.
return((sbyte)Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(CategoriesValues), offset) < 0);
}
