GetBytes() [2/9]

unsafe override int System.Text.UnicodeEncoding.GetBytes ( char * chars, int charCount, byte * bytes, int byteCount, EncoderNLS encoder )

inlinesealedpackagevirtual

Reimplemented from System.Text.Encoding.

Definition at line 502 of file UnicodeEncoding.cs.

    {
        char c = '\0';
        bool flag = false;
        byte* ptr = bytes + byteCount;
        char* ptr2 = chars + charCount;
        byte* ptr3 = bytes;
        char* ptr4 = chars;
        EncoderFallbackBuffer encoderFallbackBuffer = null;
        if (encoder != null)
        {
            c = encoder._charLeftOver;
            if (encoder.InternalHasFallbackBuffer)
            {
                encoderFallbackBuffer = encoder.FallbackBuffer;
                if (encoderFallbackBuffer.Remaining > 0 && encoder._throwOnOverflow)
                {
                    throw new ArgumentException(SR.Format(SR.Argument_EncoderFallbackNotEmpty, EncodingName, encoder.Fallback?.GetType()));
                }
                encoderFallbackBuffer.InternalInitialize(ptr4, ptr2, encoder, setEncoder: false);
            }
        }
        while (true)
        {
            char num = encoderFallbackBuffer?.InternalGetNextChar() ?? '\0';
            char c2 = num;
            char* chars2;
            if (num != 0 || chars < ptr2)
            {
                if (c2 == '\0')
                {
                    if ((bigEndian ^ BitConverter.IsLittleEndian) && ((ulong)chars & 7uL) == 0L && c == '\0')
                    {
                        ulong* ptr5 = (ulong*)(chars - 3 + ((ptr - bytes >> 1 < ptr2 - chars) ? (ptr - bytes >> 1) : (ptr2 - chars)));
                        ulong* ptr6 = (ulong*)chars;
                        ulong* ptr7 = (ulong*)bytes;
                        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*)ptr6;
                        bytes = (byte*)ptr7;
                        if (chars >= ptr2)
                        {
                            goto IL_039f;
                        }
                    }
                    c2 = *chars;
                    chars++;
                }
                if (c2 >= '\ud800' && c2 <= '\udfff')
                {
                    if (c2 <= '\udbff')
                    {
                        if (c > '\0')
                        {
                            chars--;
                            if (encoderFallbackBuffer == null)
                            {
                                encoderFallbackBuffer = ((encoder != null) ? encoder.FallbackBuffer : encoderFallback.CreateFallbackBuffer());
                                encoderFallbackBuffer.InternalInitialize(ptr4, ptr2, encoder, setEncoder: true);
                            }
                            chars2 = chars;
                            encoderFallbackBuffer.InternalFallback(c, ref chars2);
                            chars = chars2;
                            c = '\0';
                        }
                        else
                        {
                            c = c2;
                        }
                        continue;
                    }
                    if (c == '\0')
                    {
                        if (encoderFallbackBuffer == null)
                        {
                            encoderFallbackBuffer = ((encoder != null) ? encoder.FallbackBuffer : encoderFallback.CreateFallbackBuffer());
                            encoderFallbackBuffer.InternalInitialize(ptr4, ptr2, encoder, setEncoder: true);
                        }
                        chars2 = chars;
                        encoderFallbackBuffer.InternalFallback(c2, ref chars2);
                        chars = chars2;
                        continue;
                    }
                    if (bytes + 3 >= ptr)
                    {
                        if (encoderFallbackBuffer != null && encoderFallbackBuffer.bFallingBack)
                        {
                            encoderFallbackBuffer.MovePrevious();
                            encoderFallbackBuffer.MovePrevious();
                        }
                        else
                        {
                            chars -= 2;
                        }
                        ThrowBytesOverflow(encoder, bytes == ptr3);
                        c = '\0';
                        goto IL_039f;
                    }
                    if (bigEndian)
                    {
                        *(bytes++) = (byte)((int)c >> 8);
                        *(bytes++) = (byte)c;
                    }
                    else
                    {
                        *(bytes++) = (byte)c;
                        *(bytes++) = (byte)((int)c >> 8);
                    }
                    c = '\0';
                }
                else if (c > '\0')
                {
                    chars--;
                    if (encoderFallbackBuffer == null)
                    {
                        encoderFallbackBuffer = ((encoder != null) ? encoder.FallbackBuffer : encoderFallback.CreateFallbackBuffer());
                        encoderFallbackBuffer.InternalInitialize(ptr4, ptr2, encoder, setEncoder: true);
                    }
                    chars2 = chars;
                    encoderFallbackBuffer.InternalFallback(c, ref chars2);
                    chars = chars2;
                    c = '\0';
                    continue;
                }
                if (bytes + 1 < ptr)
                {
                    if (bigEndian)
                    {
                        *(bytes++) = (byte)((int)c2 >> 8);
                        *(bytes++) = (byte)c2;
                    }
                    else
                    {
                        *(bytes++) = (byte)c2;
                        *(bytes++) = (byte)((int)c2 >> 8);
                    }
                    continue;
                }
                if (encoderFallbackBuffer != null && encoderFallbackBuffer.bFallingBack)
                {
                    encoderFallbackBuffer.MovePrevious();
                }
                else
                {
                    chars--;
                }
                ThrowBytesOverflow(encoder, bytes == ptr3);
            }
            goto IL_039f;
            IL_039f:
            if (c <= '\0' || (encoder != null && !encoder.MustFlush))
            {
                break;
            }
            if (flag)
            {
                throw new ArgumentException(SR.Format(SR.Argument_RecursiveFallback, c), "chars");
            }
            if (encoderFallbackBuffer == null)
            {
                encoderFallbackBuffer = ((encoder != null) ? encoder.FallbackBuffer : encoderFallback.CreateFallbackBuffer());
                encoderFallbackBuffer.InternalInitialize(ptr4, ptr2, encoder, setEncoder: true);
            }
            chars2 = chars;
            encoderFallbackBuffer.InternalFallback(c, ref chars2);
            chars = chars2;
            c = '\0';
            flag = true;
        }
        if (encoder != null)
        {
            encoder._charLeftOver = c;
            encoder._charsUsed = (int)(chars - ptr4);
        }
        return (int)(bytes - ptr3);
    }

References System.Text.EncoderNLS._charLeftOver, System.Text.EncoderNLS._throwOnOverflow, System.SR.Argument_EncoderFallbackNotEmpty, System.SR.Argument_RecursiveFallback, System.Text.EncoderFallbackBuffer.bFallingBack, System.Text.UnicodeEncoding.bigEndian, System.byteCount, System.bytes, System.charCount, System.chars, System.Text.EncoderFallback.CreateFallbackBuffer(), System.Text.Encoding.encoderFallback, System.Text.Encoding.EncodingName, System.Text.EncoderNLS.Fallback, System.Text.EncoderNLS.FallbackBuffer, System.SR.Format(), System.Text.EncoderFallbackBuffer.InternalFallback(), System.Text.EncoderFallbackBuffer.InternalGetNextChar(), System.Text.EncoderNLS.InternalHasFallbackBuffer, System.Text.EncoderFallbackBuffer.InternalInitialize(), System.BitConverter.IsLittleEndian, System.L, System.Text.EncoderFallbackBuffer.MovePrevious(), System.Text.EncoderNLS.MustFlush, System.Text.EncoderFallbackBuffer.Remaining, and System.Text.Encoding.ThrowBytesOverflow().