GetChars() [2/6]

unsafe override int System.Text.UnicodeEncoding.GetChars ( byte * bytes, int byteCount, char * chars, int charCount, DecoderNLS baseDecoder )

inlinesealedpackagevirtual

Reimplemented from System.Text.Encoding.

Definition at line 875 of file UnicodeEncoding.cs.

    {
        Decoder decoder = (Decoder)baseDecoder;
        int num = -1;
        char c = '\0';
        if (decoder != null)
        {
            num = decoder.lastByte;
            c = decoder.lastChar;
        }
        DecoderFallbackBuffer decoderFallbackBuffer = null;
        byte* ptr = bytes + byteCount;
        char* ptr2 = chars + charCount;
        byte* ptr3 = bytes;
        char* ptr4 = chars;
        while (bytes < ptr)
        {
            if ((bigEndian ^ BitConverter.IsLittleEndian) && ((ulong)chars & 7uL) == 0L && num == -1 && c == '\0')
            {
                ulong* ptr5 = (ulong*)(bytes - 7 + ((ptr - bytes >> 1 < ptr2 - chars) ? (ptr - bytes) : (ptr2 - chars << 1)));
                ulong* ptr6 = (ulong*)bytes;
                ulong* ptr7 = (ulong*)chars;
                while (ptr6 < ptr5)
                {
                    if ((0x8000800080008000uL & *ptr6) != 0L)
                    {
                        ulong num2 = (0xF800F800F800F800uL & *ptr6) ^ 0xD800D800D800D800uL;
                        if ((num2 & 0xFFFF000000000000uL) == 0L || (num2 & 0xFFFF00000000L) == 0L || (num2 & 0xFFFF0000u) == 0L || (num2 & 0xFFFF) == 0L)
                        {
                            long num3 = -287953294993589248L & (long)(*ptr6);
                            if (!BitConverter.IsLittleEndian)
                            {
                            }
                            if (num3 != -2593835887162763264L)
                            {
                                break;
                            }
                        }
                    }
                    Unsafe.WriteUnaligned(ptr7, *ptr6);
                    ptr6++;
                    ptr7++;
                }
                chars = (char*)ptr7;
                bytes = (byte*)ptr6;
                if (bytes >= ptr)
                {
                    break;
                }
            }
            if (num < 0)
            {
                num = *(bytes++);
                continue;
            }
            char c2 = ((!bigEndian) ? ((char)((*(bytes++) << 8) | num)) : ((char)((num << 8) | *(bytes++))));
            num = -1;
            if (c2 >= '\ud800' && c2 <= '\udfff')
            {
                if (c2 <= '\udbff')
                {
                    if (c > '\0')
                    {
                        byte[] array = null;
                        array = ((!bigEndian) ? new byte[2]
                        {
                            (byte)c,
                            (byte)((int)c >> 8)
                        } : new byte[2]
                        {
                            (byte)((int)c >> 8),
                            (byte)c
                        });
                        if (decoderFallbackBuffer == null)
                        {
                            decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
                            decoderFallbackBuffer.InternalInitialize(ptr3, ptr2);
                        }
                        char* chars2 = chars;
                        bool flag = decoderFallbackBuffer.InternalFallback(array, bytes, ref chars2);
                        chars = chars2;
                        if (!flag)
                        {
                            bytes -= 2;
                            decoderFallbackBuffer.InternalReset();
                            ThrowCharsOverflow(decoder, chars == ptr4);
                            break;
                        }
                    }
                    c = c2;
                    continue;
                }
                if (c == '\0')
                {
                    byte[] array2 = null;
                    array2 = ((!bigEndian) ? new byte[2]
                    {
                        (byte)c2,
                        (byte)((int)c2 >> 8)
                    } : new byte[2]
                    {
                        (byte)((int)c2 >> 8),
                        (byte)c2
                    });
                    if (decoderFallbackBuffer == null)
                    {
                        decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
                        decoderFallbackBuffer.InternalInitialize(ptr3, ptr2);
                    }
                    char* chars2 = chars;
                    bool flag2 = decoderFallbackBuffer.InternalFallback(array2, bytes, ref chars2);
                    chars = chars2;
                    if (!flag2)
                    {
                        bytes -= 2;
                        decoderFallbackBuffer.InternalReset();
                        ThrowCharsOverflow(decoder, chars == ptr4);
                        break;
                    }
                    continue;
                }
                if (chars >= ptr2 - 1)
                {
                    bytes -= 2;
                    ThrowCharsOverflow(decoder, chars == ptr4);
                    break;
                }
                *(chars++) = c;
                c = '\0';
            }
            else if (c > '\0')
            {
                byte[] array3 = null;
                array3 = ((!bigEndian) ? new byte[2]
                {
                    (byte)c,
                    (byte)((int)c >> 8)
                } : new byte[2]
                {
                    (byte)((int)c >> 8),
                    (byte)c
                });
                if (decoderFallbackBuffer == null)
                {
                    decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
                    decoderFallbackBuffer.InternalInitialize(ptr3, ptr2);
                }
                char* chars2 = chars;
                bool flag3 = decoderFallbackBuffer.InternalFallback(array3, bytes, ref chars2);
                chars = chars2;
                if (!flag3)
                {
                    bytes -= 2;
                    decoderFallbackBuffer.InternalReset();
                    ThrowCharsOverflow(decoder, chars == ptr4);
                    break;
                }
                c = '\0';
            }
            if (chars >= ptr2)
            {
                bytes -= 2;
                ThrowCharsOverflow(decoder, chars == ptr4);
                break;
            }
            *(chars++) = c2;
        }
        if (decoder == null || decoder.MustFlush)
        {
            if (c > '\0')
            {
                byte[] array4 = null;
                array4 = ((!bigEndian) ? new byte[2]
                {
                    (byte)c,
                    (byte)((int)c >> 8)
                } : new byte[2]
                {
                    (byte)((int)c >> 8),
                    (byte)c
                });
                if (decoderFallbackBuffer == null)
                {
                    decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
                    decoderFallbackBuffer.InternalInitialize(ptr3, ptr2);
                }
                char* chars2 = chars;
                bool flag4 = decoderFallbackBuffer.InternalFallback(array4, bytes, ref chars2);
                chars = chars2;
                if (!flag4)
                {
                    bytes -= 2;
                    if (num >= 0)
                    {
                        bytes--;
                    }
                    decoderFallbackBuffer.InternalReset();
                    ThrowCharsOverflow(decoder, chars == ptr4);
                    bytes += 2;
                    if (num >= 0)
                    {
                        bytes++;
                    }
                    goto IL_04df;
                }
                c = '\0';
            }
            if (num >= 0)
            {
                if (decoderFallbackBuffer == null)
                {
                    decoderFallbackBuffer = ((decoder != null) ? decoder.FallbackBuffer : decoderFallback.CreateFallbackBuffer());
                    decoderFallbackBuffer.InternalInitialize(ptr3, ptr2);
                }
                char* chars2 = chars;
                bool flag5 = decoderFallbackBuffer.InternalFallback(new byte[1] { (byte)num }, bytes, ref chars2);
                chars = chars2;
                if (!flag5)
                {
                    bytes--;
                    decoderFallbackBuffer.InternalReset();
                    ThrowCharsOverflow(decoder, chars == ptr4);
                    bytes++;
                }
                else
                {
                    num = -1;
                }
            }
        }
        goto IL_04df;
        IL_04df:
        if (decoder != null)
        {
            decoder._bytesUsed = (int)(bytes - ptr3);
            decoder.lastChar = c;
            decoder.lastByte = num;
        }
        return (int)(chars - ptr4);
    }

References System.array, System.Text.UnicodeEncoding.bigEndian, System.byteCount, System.bytes, System.charCount, System.chars, System.Text.DecoderFallback.CreateFallbackBuffer(), System.Text.Encoding.decoderFallback, System.Text.DecoderNLS.FallbackBuffer, System.Text.DecoderFallbackBuffer.InternalFallback(), System.Text.DecoderFallbackBuffer.InternalInitialize(), System.Text.DecoderFallbackBuffer.InternalReset(), System.BitConverter.IsLittleEndian, System.L, System.Text.UnicodeEncoding.Decoder.lastByte, System.Text.UnicodeEncoding.Decoder.lastChar, System.Text.DecoderNLS.MustFlush, and System.Text.Encoding.ThrowCharsOverflow().