TranscodeToUtf8()

static unsafe OperationStatus System.Text.Unicode.Utf8Utility.TranscodeToUtf8 ( char * pInputBuffer, int inputLength, byte * pOutputBuffer, int outputBytesRemaining, out char * pInputBufferRemaining, out byte * pOutputBufferRemaining )

inlinestatic

Definition at line 834 of file Utf8Utility.cs.

    {
        nuint num = ASCIIUtility.NarrowUtf16ToAscii(pInputBuffer, pOutputBuffer, (uint)Math.Min(inputLength, outputBytesRemaining));
        pInputBuffer += num;
        pOutputBuffer += num;
        if ((int)num == inputLength)
        {
            pInputBufferRemaining = pInputBuffer;
            pOutputBufferRemaining = pOutputBuffer;
            return OperationStatus.Done;
        }
        inputLength -= (int)num;
        outputBytesRemaining -= (int)num;
        if (inputLength < 2)
        {
            goto IL_04f0;
        }
        char* ptr = pInputBuffer + (uint)inputLength - 2;
        Vector128<short> value;
        if (Sse41.X64.IsSupported || AdvSimd.Arm64.IsSupported)
        {
            value = Vector128.Create((short)(-128));
        }
        uint num2;
        while (true)
        {
            IL_006d:
            num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
            while (true)
            {
                IL_0074:
                if (!Utf16Utility.AllCharsInUInt32AreAscii(num2))
                {
                    goto IL_02e9;
                }
                if (outputBytesRemaining < 2)
                {
                    break;
                }
                uint num3 = num2 | (num2 >> 8);
                Unsafe.WriteUnaligned(pOutputBuffer, (ushort)num3);
                pInputBuffer += 2;
                pOutputBuffer += 2;
                outputBytesRemaining -= 2;
                uint num4 = (uint)((int)(ptr - pInputBuffer) + 2);
                uint num5 = (uint)Math.Min(num4, outputBytesRemaining);
                int num7;
                ulong num8;
                Vector128<short> vector;
                int num10;
                uint num11;
                if (Sse41.X64.IsSupported || AdvSimd.Arm64.IsSupported)
                {
                    uint num6 = num5 / 8;
                    num7 = 0;
                    while ((uint)num7 < num6)
                    {
                        Unsafe.SkipInit<Vector128<short>>(out value);
                        vector = Unsafe.ReadUnaligned<Vector128<short>>(pInputBuffer);
                        if (AdvSimd.IsSupported)
                        {
                        }
                        if (Sse41.TestZ(vector, value))
                        {
                            Sse2.StoreScalar((ulong*)pOutputBuffer, Sse2.PackUnsignedSaturate(vector, vector).AsUInt64());
                            pInputBuffer += 8;
                            pOutputBuffer += 8;
                            num7++;
                            continue;
                        }
                        goto IL_019c;
                    }
                    outputBytesRemaining -= 8 * num7;
                    if ((num5 & 4u) != 0)
                    {
                        num8 = Unsafe.ReadUnaligned<ulong>(pInputBuffer);
                        if (!Utf16Utility.AllCharsInUInt64AreAscii(num8))
                        {
                            goto IL_0213;
                        }
                        vector = Vector128.CreateScalarUnsafe(num8).AsInt16();
                        if (AdvSimd.IsSupported)
                        {
                        }
                        Unsafe.WriteUnaligned(pOutputBuffer, Sse2.ConvertToUInt32(Sse2.PackUnsignedSaturate(vector, vector).AsUInt32()));
                        pInputBuffer += 4;
                        pOutputBuffer += 4;
                        outputBytesRemaining -= 4;
                    }
                }
                else
                {
                    uint num9 = num5 / 4;
                    num10 = 0;
                    while ((uint)num10 < num9)
                    {
                        num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
                        num11 = Unsafe.ReadUnaligned<uint>(pInputBuffer + 2);
                        if (Utf16Utility.AllCharsInUInt32AreAscii(num2 | num11))
                        {
                            Unsafe.WriteUnaligned(pOutputBuffer, (ushort)(num2 | (num2 >> 8)));
                            Unsafe.WriteUnaligned(pOutputBuffer + 2, (ushort)(num11 | (num11 >> 8)));
                            pInputBuffer += 4;
                            pOutputBuffer += 4;
                            num10++;
                            continue;
                        }
                        goto IL_02b8;
                    }
                    outputBytesRemaining -= 4 * num10;
                }
                goto IL_04de;
                IL_04ae:
                if (IsWellFormedUtf16SurrogatePair(num2))
                {
                    if (outputBytesRemaining >= 4)
                    {
                        Unsafe.WriteUnaligned(pOutputBuffer, ExtractFourUtf8BytesFromSurrogatePair(num2));
                        pInputBuffer += 2;
                        pOutputBuffer += 4;
                        outputBytesRemaining -= 4;
                        goto IL_04de;
                    }
                    goto IL_05a7;
                }
                goto IL_05ac;
                IL_038f:
                if (outputBytesRemaining >= 3)
                {
                    _ = BitConverter.IsLittleEndian;
                    num2 >>= 16;
                    pOutputBuffer[2] = (byte)num2;
                    pInputBuffer += 2;
                    pOutputBuffer += 3;
                    outputBytesRemaining -= 3;
                    goto IL_04de;
                }
                pInputBuffer++;
                pOutputBuffer += 2;
                goto IL_05a7;
                IL_04de:
                if (pInputBuffer <= ptr)
                {
                    goto IL_006d;
                }
                goto IL_04e5;
                IL_04e5:
                inputLength = (int)(ptr - pInputBuffer) + 2;
                goto IL_04f0;
                IL_0213:
                num2 = (uint)num8;
                if (Utf16Utility.AllCharsInUInt32AreAscii(num2))
                {
                    Unsafe.WriteUnaligned(pOutputBuffer, (ushort)(num2 | (num2 >> 8)));
                    pInputBuffer += 2;
                    pOutputBuffer += 2;
                    outputBytesRemaining -= 2;
                    num2 = (uint)(num8 >> 32);
                }
                goto IL_02e9;
                IL_019c:
                outputBytesRemaining -= 8 * num7;
                num8 = ((!Sse2.X64.IsSupported) ? vector.AsUInt64().ToScalar() : Sse2.X64.ConvertToUInt64(vector.AsUInt64()));
                if (Utf16Utility.AllCharsInUInt64AreAscii(num8))
                {
                    if (AdvSimd.IsSupported)
                    {
                    }
                    Unsafe.WriteUnaligned(pOutputBuffer, Sse2.ConvertToUInt32(Sse2.PackUnsignedSaturate(vector, vector).AsUInt32()));
                    pInputBuffer += 4;
                    pOutputBuffer += 4;
                    outputBytesRemaining -= 4;
                    num8 = vector.AsUInt64().GetElement(1);
                }
                goto IL_0213;
                IL_02b8:
                outputBytesRemaining -= 4 * num10;
                if (Utf16Utility.AllCharsInUInt32AreAscii(num2))
                {
                    Unsafe.WriteUnaligned(pOutputBuffer, (ushort)(num2 | (num2 >> 8)));
                    pInputBuffer += 2;
                    pOutputBuffer += 2;
                    outputBytesRemaining -= 2;
                    num2 = num11;
                }
                goto IL_02e9;
                IL_02e9:
                while (true)
                {
                    if (IsFirstCharAscii(num2))
                    {
                        if (outputBytesRemaining == 0)
                        {
                            break;
                        }
                        _ = BitConverter.IsLittleEndian;
                        *pOutputBuffer = (byte)num2;
                        pInputBuffer++;
                        pOutputBuffer++;
                        outputBytesRemaining--;
                        if (pInputBuffer > ptr)
                        {
                            goto IL_04e5;
                        }
                        num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
                    }
                    if (!IsFirstCharAtLeastThreeUtf8Bytes(num2))
                    {
                        while (IsSecondCharTwoUtf8Bytes(num2))
                        {
                            if (outputBytesRemaining < 4)
                            {
                                goto end_IL_0074;
                            }
                            Unsafe.WriteUnaligned(pOutputBuffer, ExtractTwoUtf8TwoByteSequencesFromTwoPackedUtf16Chars(num2));
                            pInputBuffer += 2;
                            pOutputBuffer += 4;
                            outputBytesRemaining -= 4;
                            if (pInputBuffer <= ptr)
                            {
                                num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
                                if (!IsFirstCharTwoUtf8Bytes(num2))
                                {
                                    goto IL_0074;
                                }
                                continue;
                            }
                            goto IL_04e5;
                        }
                        if (outputBytesRemaining < 2)
                        {
                            break;
                        }
                        Unsafe.WriteUnaligned(pOutputBuffer, (ushort)ExtractUtf8TwoByteSequenceFromFirstUtf16Char(num2));
                        if (IsSecondCharAscii(num2))
                        {
                            goto IL_038f;
                        }
                        pInputBuffer++;
                        pOutputBuffer += 2;
                        outputBytesRemaining -= 2;
                        if (pInputBuffer > ptr)
                        {
                            goto IL_04e5;
                        }
                        num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
                    }
                    while (!IsFirstCharSurrogate(num2))
                    {
                        if (IsSecondCharAtLeastThreeUtf8Bytes(num2) && !IsSecondCharSurrogate(num2) && outputBytesRemaining >= 6)
                        {
                            WriteTwoUtf16CharsAsTwoUtf8ThreeByteSequences(ref *pOutputBuffer, num2);
                            pInputBuffer += 2;
                            pOutputBuffer += 6;
                            outputBytesRemaining -= 6;
                            if (pInputBuffer <= ptr)
                            {
                                num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
                                if (!IsFirstCharAtLeastThreeUtf8Bytes(num2))
                                {
                                    goto IL_0074;
                                }
                                continue;
                            }
                        }
                        else
                        {
                            if (outputBytesRemaining < 3)
                            {
                                goto end_IL_02e9;
                            }
                            WriteFirstUtf16CharAsUtf8ThreeByteSequence(ref *pOutputBuffer, num2);
                            pInputBuffer++;
                            pOutputBuffer += 3;
                            outputBytesRemaining -= 3;
                            if (!IsSecondCharAscii(num2))
                            {
                                goto IL_049e;
                            }
                            if (outputBytesRemaining == 0)
                            {
                                goto end_IL_02e9;
                            }
                            _ = BitConverter.IsLittleEndian;
                            *pOutputBuffer = (byte)(num2 >> 16);
                            pInputBuffer++;
                            pOutputBuffer++;
                            outputBytesRemaining--;
                            if (pInputBuffer <= ptr)
                            {
                                num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
                                if (!IsFirstCharAtLeastThreeUtf8Bytes(num2))
                                {
                                    goto IL_0074;
                                }
                                continue;
                            }
                        }
                        goto IL_04e5;
                    }
                    goto IL_04ae;
                    IL_049e:
                    if (pInputBuffer <= ptr)
                    {
                        num2 = Unsafe.ReadUnaligned<uint>(pInputBuffer);
                        continue;
                    }
                    goto IL_04e5;
                    continue;
                    end_IL_02e9:
                    break;
                }
                goto IL_05a7;
                continue;
                end_IL_0074:
                break;
            }
            break;
        }
        _ = BitConverter.IsLittleEndian;
        uint num12 = num2 & 0xFFFFu;
        goto IL_050b;
        IL_05af:
        pInputBufferRemaining = pInputBuffer;
        pOutputBufferRemaining = pOutputBuffer;
        OperationStatus result;
        return result;
        IL_05a7:
        result = OperationStatus.DestinationTooSmall;
        goto IL_05af;
        IL_05ac:
        result = OperationStatus.InvalidData;
        goto IL_05af;
        IL_059d:
        result = OperationStatus.Done;
        goto IL_05af;
        IL_050b:
        if (num12 <= 127)
        {
            if (outputBytesRemaining != 0)
            {
                *pOutputBuffer = (byte)num12;
                pInputBuffer++;
                pOutputBuffer++;
                goto IL_0599;
            }
        }
        else if (num12 < 2048)
        {
            if (outputBytesRemaining >= 2)
            {
                pOutputBuffer[1] = (byte)((num12 & 0x3Fu) | 0xFFFFFF80u);
                *pOutputBuffer = (byte)((num12 >> 6) | 0xFFFFFFC0u);
                pInputBuffer++;
                pOutputBuffer += 2;
                goto IL_0599;
            }
        }
        else
        {
            if (UnicodeUtility.IsSurrogateCodePoint(num12))
            {
                if (num12 > 56319)
                {
                    goto IL_05ac;
                }
                result = OperationStatus.NeedMoreData;
                goto IL_05af;
            }
            if (outputBytesRemaining >= 3)
            {
                pOutputBuffer[2] = (byte)((num12 & 0x3Fu) | 0xFFFFFF80u);
                pOutputBuffer[1] = (byte)(((num12 >> 6) & 0x3Fu) | 0xFFFFFF80u);
                *pOutputBuffer = (byte)((num12 >> 12) | 0xFFFFFFE0u);
                pInputBuffer++;
                pOutputBuffer += 3;
                goto IL_0599;
            }
        }
        goto IL_05a7;
        IL_04f0:
        if (inputLength != 0)
        {
            num12 = *pInputBuffer;
            goto IL_050b;
        }
        goto IL_059d;
        IL_0599:
        if (inputLength <= 1)
        {
            goto IL_059d;
        }
        goto IL_05a7;
    }

References System.Text.Unicode.Utf16Utility.AllCharsInUInt32AreAscii(), System.Text.Unicode.Utf16Utility.AllCharsInUInt64AreAscii(), System.Runtime.Intrinsics.X86.Sse2.ConvertToUInt32(), System.Runtime.Intrinsics.X86.Sse2.X64.ConvertToUInt64(), System.Runtime.Intrinsics.Vector128< T >.Create(), System.Runtime.Intrinsics.Vector128< T >.CreateScalarUnsafe(), System.Text.Unicode.Utf8Utility.ExtractFourUtf8BytesFromSurrogatePair(), System.Text.Unicode.Utf8Utility.ExtractTwoUtf8TwoByteSequencesFromTwoPackedUtf16Chars(), System.Text.Unicode.Utf8Utility.ExtractUtf8TwoByteSequenceFromFirstUtf16Char(), System.Text.Unicode.Utf8Utility.IsFirstCharAscii(), System.Text.Unicode.Utf8Utility.IsFirstCharAtLeastThreeUtf8Bytes(), System.Text.Unicode.Utf8Utility.IsFirstCharSurrogate(), System.Text.Unicode.Utf8Utility.IsFirstCharTwoUtf8Bytes(), System.BitConverter.IsLittleEndian, System.Text.Unicode.Utf8Utility.IsSecondCharAscii(), System.Text.Unicode.Utf8Utility.IsSecondCharAtLeastThreeUtf8Bytes(), System.Text.Unicode.Utf8Utility.IsSecondCharSurrogate(), System.Text.Unicode.Utf8Utility.IsSecondCharTwoUtf8Bytes(), System.Runtime.Intrinsics.Arm.AdvSimd.Arm64.IsSupported, System.Runtime.Intrinsics.Arm.AdvSimd.IsSupported, System.Runtime.Intrinsics.X86.Sse2.X64.IsSupported, System.Runtime.Intrinsics.X86.Sse41.X64.IsSupported, System.Text.UnicodeUtility.IsSurrogateCodePoint(), System.Text.Unicode.Utf8Utility.IsWellFormedUtf16SurrogatePair(), System.Math.Min(), System.Text.ASCIIUtility.NarrowUtf16ToAscii(), System.Runtime.Intrinsics.X86.Sse2.PackUnsignedSaturate(), System.Runtime.Intrinsics.X86.Sse2.StoreScalar(), System.Runtime.Intrinsics.X86.Sse41.TestZ(), System.value, System.Text.Unicode.Utf8Utility.WriteFirstUtf16CharAsUtf8ThreeByteSequence(), and System.Text.Unicode.Utf8Utility.WriteTwoUtf16CharsAsTwoUtf8ThreeByteSequences().

Referenced by System.Text.Unicode.Utf8.FromUtf16(), and System.Text.UTF8Encoding.GetBytesFast().