GetPointerToFirstInvalidByte()

static unsafe byte * System.Text.Unicode.Utf8Utility.GetPointerToFirstInvalidByte ( byte * pInputBuffer, int inputLength, out int utf16CodeUnitCountAdjustment, out int scalarCountAdjustment )

inlinestatic

Definition at line 1229 of file Utf8Utility.cs.

    {
        nuint indexOfFirstNonAsciiByte = ASCIIUtility.GetIndexOfFirstNonAsciiByte(pInputBuffer, (uint)inputLength);
        pInputBuffer += indexOfFirstNonAsciiByte;
        inputLength -= (int)indexOfFirstNonAsciiByte;
        if (inputLength == 0)
        {
            utf16CodeUnitCountAdjustment = 0;
            scalarCountAdjustment = 0;
            return pInputBuffer;
        }
        int num = 0;
        int num2 = 0;
        nuint num13;
        if (inputLength >= 4)
        {
            byte* ptr = pInputBuffer + (uint)inputLength - 4;
            while (pInputBuffer <= ptr)
            {
                uint num3 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
                while (true)
                {
                    IL_0043:
                    if (ASCIIUtility.AllBytesInUInt32AreAscii(num3))
                    {
                        pInputBuffer += 4;
                        if ((nint)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *ptr) < (nint)16)
                        {
                            break;
                        }
                        num3 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
                        if (ASCIIUtility.AllBytesInUInt32AreAscii(num3))
                        {
                            pInputBuffer = (byte*)((nuint)(pInputBuffer + 4) & ~(nuint)3u);
                            byte* ptr2 = ptr - 12;
                            if (AdvSimd.Arm64.IsSupported)
                            {
                            }
                            uint num4;
                            while (true)
                            {
                                if (Sse2.IsSupported)
                                {
                                    num4 = (uint)Sse2.MoveMask(Sse2.LoadVector128(pInputBuffer));
                                    if (num4 != 0)
                                    {
                                        break;
                                    }
                                    goto IL_00da;
                                }
                                if (ASCIIUtility.AllBytesInUInt32AreAscii(*(uint*)pInputBuffer | *(uint*)(pInputBuffer + 4)))
                                {
                                    if (ASCIIUtility.AllBytesInUInt32AreAscii(*(uint*)(pInputBuffer + (nint)2 * (nint)4) | *(uint*)(pInputBuffer + (nint)3 * (nint)4)))
                                    {
                                        goto IL_00da;
                                    }
                                    pInputBuffer += 8;
                                }
                                num3 = *(uint*)pInputBuffer;
                                if (ASCIIUtility.AllBytesInUInt32AreAscii(num3))
                                {
                                    pInputBuffer += 4;
                                    num3 = *(uint*)pInputBuffer;
                                }
                                goto IL_011e;
                                IL_00da:
                                pInputBuffer += 16;
                                if (pInputBuffer > ptr2)
                                {
                                    goto end_IL_0043;
                                }
                            }
                            nuint num5 = (nuint)BitOperations.TrailingZeroCount(num4);
                            pInputBuffer += num5;
                            if (pInputBuffer > ptr)
                            {
                                goto end_IL_0428;
                            }
                            num3 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
                            goto IL_013d;
                        }
                    }
                    goto IL_011e;
                    IL_011e:
                    uint num6 = ASCIIUtility.CountNumberOfLeadingAsciiBytesFromUInt32WithSomeNonAsciiData(num3);
                    pInputBuffer += num6;
                    if (ptr < pInputBuffer)
                    {
                        goto end_IL_0428;
                    }
                    num3 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
                    goto IL_013d;
                    IL_039e:
                    pInputBuffer += 6;
                    num -= 4;
                    break;
                    IL_013d:
                    while (true)
                    {
                        uint num7 = num3;
                        if (!BitConverter.IsLittleEndian)
                        {
                        }
                        num3 = num7 - 32960;
                        uint num8 = num3;
                        if (!BitConverter.IsLittleEndian)
                        {
                        }
                        if ((num8 & 0xC0E0u) != 0)
                        {
                            break;
                        }
                        _ = BitConverter.IsLittleEndian;
                        if ((uint)(byte)num3 >= 2u)
                        {
                            if (!BitConverter.IsLittleEndian)
                            {
                            }
                            while (true)
                            {
                                _ = BitConverter.IsLittleEndian;
                                if (!UInt32EndsWithValidUtf8TwoByteSequenceLittleEndian(num3) && BitConverter.IsLittleEndian)
                                {
                                    break;
                                }
                                pInputBuffer += 4;
                                num -= 2;
                                if (pInputBuffer > ptr)
                                {
                                    goto end_IL_0428;
                                }
                                num3 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
                                _ = BitConverter.IsLittleEndian;
                                if (!UInt32BeginsWithValidUtf8TwoByteSequenceLittleEndian(num3))
                                {
                                    goto IL_0043;
                                }
                            }
                            num--;
                            if (UInt32ThirdByteIsAscii(num3))
                            {
                                if (UInt32FourthByteIsAscii(num3))
                                {
                                    pInputBuffer += 4;
                                    goto end_IL_0043;
                                }
                                pInputBuffer += 3;
                                if (pInputBuffer > ptr)
                                {
                                    goto end_IL_0043;
                                }
                                num3 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
                                continue;
                            }
                            pInputBuffer += 2;
                            goto end_IL_0043;
                        }
                        goto IL_0521;
                    }
                    uint num9 = num3;
                    if (!BitConverter.IsLittleEndian)
                    {
                    }
                    num3 = num9 - 8388640;
                    uint num10 = num3;
                    if (!BitConverter.IsLittleEndian)
                    {
                    }
                    if ((num10 & 0xC0C0F0) == 0)
                    {
                        while (true)
                        {
                            _ = BitConverter.IsLittleEndian;
                            if ((num3 & 0x200F) == 0 || ((num3 - 8205) & 0x200F) == 0)
                            {
                                break;
                            }
                            while (true)
                            {
                                IL_024a:
                                _ = BitConverter.IsLittleEndian;
                                nint num11 = (int)num3 >> 31;
                                pInputBuffer += 4;
                                pInputBuffer += num11;
                                num -= 2;
                                ulong num12;
                                while (true)
                                {
                                    _ = IntPtr.Size;
                                    _ = BitConverter.IsLittleEndian;
                                    if ((nint)(ptr - pInputBuffer) < 5)
                                    {
                                        break;
                                    }
                                    num12 = Unsafe.ReadUnaligned<ulong>(pInputBuffer);
                                    num3 = (uint)num12;
                                    if ((num12 & 0xC0F0C0C0F0C0C0F0uL) == 9286563722648649952uL && IsUtf8ContinuationByte(in pInputBuffer[8]))
                                    {
                                        if (((int)num12 & 0x200F) == 0 || (((int)num12 - 8205) & 0x200F) == 0)
                                        {
                                            goto end_IL_0222;
                                        }
                                        num12 >>= 24;
                                        if (((uint)(int)num12 & 0x200Fu) != 0 && ((uint)((int)num12 - 8205) & 0x200Fu) != 0)
                                        {
                                            num12 >>= 24;
                                            if (((uint)(int)num12 & 0x200Fu) != 0 && ((uint)((int)num12 - 8205) & 0x200Fu) != 0)
                                            {
                                                pInputBuffer += 9;
                                                num -= 6;
                                                continue;
                                            }
                                        }
                                        goto IL_024a;
                                    }
                                    goto IL_033c;
                                }
                                break;
                                IL_033c:
                                if ((num12 & 0xC0C0F0C0C0F0L) == 141291010687200L)
                                {
                                    if (((int)num12 & 0x200F) == 0 || (((int)num12 - 8205) & 0x200F) == 0)
                                    {
                                        goto end_IL_0222;
                                    }
                                    num12 >>= 24;
                                    if (((int)num12 & 0x200F) == 0 || (((int)num12 - 8205) & 0x200F) == 0)
                                    {
                                        continue;
                                    }
                                    goto IL_039e;
                                }
                                goto IL_03ac;
                            }
                            if (pInputBuffer > ptr)
                            {
                                goto end_IL_0428;
                            }
                            num3 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
                            if (!UInt32BeginsWithUtf8ThreeByteMask(num3))
                            {
                                goto IL_0043;
                            }
                            continue;
                            IL_03ac:
                            if (!UInt32BeginsWithUtf8ThreeByteMask(num3))
                            {
                                goto IL_0043;
                            }
                            continue;
                            end_IL_0222:
                            break;
                        }
                    }
                    else
                    {
                        _ = BitConverter.IsLittleEndian;
                        num3 &= 0xC0C0FFFFu;
                        if ((int)num3 <= -2147467265)
                        {
                            num3 = BitOperations.RotateRight(num3, 8);
                            if (UnicodeUtility.IsInRangeInclusive(num3, 276824080u, 343932943u))
                            {
                                pInputBuffer += 4;
                                num -= 2;
                                num2--;
                                break;
                            }
                        }
                    }
                    goto IL_0521;
                    continue;
                    end_IL_0043:
                    break;
                }
                continue;
                end_IL_0428:
                break;
            }
            num13 = (nuint)((byte*)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *ptr) + 4);
        }
        else
        {
            num13 = (uint)inputLength;
        }
        while (num13 != 0)
        {
            uint num14 = *pInputBuffer;
            if ((uint)(byte)num14 < 128u)
            {
                pInputBuffer++;
                num13--;
                continue;
            }
            if (num13 < 2)
            {
                break;
            }
            uint value = pInputBuffer[1];
            if ((uint)(byte)num14 < 224u)
            {
                if ((uint)(byte)num14 < 194u || !IsLowByteUtf8ContinuationByte(value))
                {
                    break;
                }
                pInputBuffer += 2;
                num--;
                num13 -= 2;
                continue;
            }
            if (num13 < 3 || (uint)(byte)num14 >= 240u)
            {
                break;
            }
            if ((byte)num14 == 224)
            {
                if (!UnicodeUtility.IsInRangeInclusive(value, 160u, 191u))
                {
                    break;
                }
            }
            else if ((byte)num14 == 237)
            {
                if (!UnicodeUtility.IsInRangeInclusive(value, 128u, 159u))
                {
                    break;
                }
            }
            else if (!IsLowByteUtf8ContinuationByte(value))
            {
                break;
            }
            if (!IsUtf8ContinuationByte(in pInputBuffer[2]))
            {
                break;
            }
            pInputBuffer += 3;
            num -= 2;
            num13 -= 3;
        }
        goto IL_0521;
        IL_0521:
        utf16CodeUnitCountAdjustment = num;
        scalarCountAdjustment = num2;
        return pInputBuffer;
    }

References System.Text.ASCIIUtility.AllBytesInUInt32AreAscii(), System.Text.ASCIIUtility.CountNumberOfLeadingAsciiBytesFromUInt32WithSomeNonAsciiData(), System.Text.ASCIIUtility.GetIndexOfFirstNonAsciiByte(), System.Text.UnicodeUtility.IsInRangeInclusive(), System.BitConverter.IsLittleEndian, System.Text.Unicode.Utf8Utility.IsLowByteUtf8ContinuationByte(), System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.IsSupported, System.Runtime.Intrinsics.X86.Sse2.IsSupported, System.Text.Unicode.Utf8Utility.IsUtf8ContinuationByte(), System.Text.Unicode.L, System.Runtime.Intrinsics.X86.Sse2.LoadVector128(), System.Runtime.Intrinsics.X86.Sse2.MoveMask(), System.Numerics.BitOperations.RotateRight(), System.IntPtr.Size, System.Numerics.BitOperations.TrailingZeroCount(), System.Text.Unicode.Utf8Utility.UInt32BeginsWithUtf8ThreeByteMask(), System.Text.Unicode.Utf8Utility.UInt32BeginsWithValidUtf8TwoByteSequenceLittleEndian(), System.Text.Unicode.Utf8Utility.UInt32EndsWithValidUtf8TwoByteSequenceLittleEndian(), System.Text.Unicode.Utf8Utility.UInt32FourthByteIsAscii(), System.Text.Unicode.Utf8Utility.UInt32ThirdByteIsAscii(), and System.value.

Referenced by System.Text.UTF8Encoding.GetCharCountFast().