GetBytes() [2/9]

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

inlinepackagevirtual

Reimplemented from System.Text.Encoding.

Definition at line 409 of file UTF32Encoding.cs.

    {
        char* ptr = chars;
        char* ptr2 = chars + charCount;
        byte* ptr3 = bytes;
        byte* ptr4 = bytes + byteCount;
        char c = '\0';
        EncoderFallbackBuffer encoderFallbackBuffer = null;
        if (encoder != null)
        {
            c = encoder._charLeftOver;
            encoderFallbackBuffer = encoder.FallbackBuffer;
            if (encoder._throwOnOverflow && encoderFallbackBuffer.Remaining > 0)
            {
                throw new ArgumentException(SR.Format(SR.Argument_EncoderFallbackNotEmpty, EncodingName, encoder.Fallback?.GetType()));
            }
        }
        else
        {
            encoderFallbackBuffer = encoderFallback.CreateFallbackBuffer();
        }
        encoderFallbackBuffer.InternalInitialize(ptr, ptr2, encoder, setEncoder: true);
        while (true)
        {
            char c2;
            char* chars2;
            if ((c2 = encoderFallbackBuffer.InternalGetNextChar()) != 0 || chars < ptr2)
            {
                if (c2 == '\0')
                {
                    c2 = *chars;
                    chars++;
                }
                if (c != 0)
                {
                    if (!char.IsLowSurrogate(c2))
                    {
                        chars--;
                        chars2 = chars;
                        encoderFallbackBuffer.InternalFallback(c, ref chars2);
                        chars = chars2;
                        c = '\0';
                        continue;
                    }
                    uint surrogate = GetSurrogate(c, c2);
                    c = '\0';
                    if (bytes + 3 < ptr4)
                    {
                        if (_bigEndian)
                        {
                            *(bytes++) = 0;
                            *(bytes++) = (byte)(surrogate >> 16);
                            *(bytes++) = (byte)(surrogate >> 8);
                            *(bytes++) = (byte)surrogate;
                        }
                        else
                        {
                            *(bytes++) = (byte)surrogate;
                            *(bytes++) = (byte)(surrogate >> 8);
                            *(bytes++) = (byte)(surrogate >> 16);
                            *(bytes++) = 0;
                        }
                        continue;
                    }
                    if (encoderFallbackBuffer.bFallingBack)
                    {
                        encoderFallbackBuffer.MovePrevious();
                        encoderFallbackBuffer.MovePrevious();
                    }
                    else
                    {
                        chars -= 2;
                    }
                    ThrowBytesOverflow(encoder, bytes == ptr3);
                    c = '\0';
                }
                else
                {
                    if (char.IsHighSurrogate(c2))
                    {
                        c = c2;
                        continue;
                    }
                    if (char.IsLowSurrogate(c2))
                    {
                        chars2 = chars;
                        encoderFallbackBuffer.InternalFallback(c2, ref chars2);
                        chars = chars2;
                        continue;
                    }
                    if (bytes + 3 < ptr4)
                    {
                        if (_bigEndian)
                        {
                            *(bytes++) = 0;
                            *(bytes++) = 0;
                            *(bytes++) = (byte)((uint)c2 >> 8);
                            *(bytes++) = (byte)c2;
                        }
                        else
                        {
                            *(bytes++) = (byte)c2;
                            *(bytes++) = (byte)((uint)c2 >> 8);
                            *(bytes++) = 0;
                            *(bytes++) = 0;
                        }
                        continue;
                    }
                    if (encoderFallbackBuffer.bFallingBack)
                    {
                        encoderFallbackBuffer.MovePrevious();
                    }
                    else
                    {
                        chars--;
                    }
                    ThrowBytesOverflow(encoder, bytes == ptr3);
                }
            }
            if ((encoder != null && !encoder.MustFlush) || c <= '\0')
            {
                break;
            }
            chars2 = chars;
            encoderFallbackBuffer.InternalFallback(c, ref chars2);
            chars = chars2;
            c = '\0';
        }
        if (encoder != null)
        {
            encoder._charLeftOver = c;
            encoder._charsUsed = (int)(chars - ptr);
        }
        return (int)(bytes - ptr3);
    }

References System.Text.UTF32Encoding._bigEndian, System.Text.EncoderNLS._charLeftOver, System.Text.EncoderNLS._throwOnOverflow, System.SR.Argument_EncoderFallbackNotEmpty, System.Text.EncoderFallbackBuffer.bFallingBack, 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.UTF32Encoding.GetSurrogate(), System.Text.EncoderFallbackBuffer.InternalFallback(), System.Text.EncoderFallbackBuffer.InternalGetNextChar(), System.Text.EncoderFallbackBuffer.InternalInitialize(), System.Text.EncoderFallbackBuffer.MovePrevious(), System.Text.EncoderNLS.MustFlush, System.Text.EncoderFallbackBuffer.Remaining, and System.Text.Encoding.ThrowBytesOverflow().