GetChars() [2/6]

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

inlinevirtual

Reimplemented from System.Text.DBCSCodePageEncoding.

Definition at line 292 of file GB18030Encoding.cs.

    {
        GB18030Decoder gB18030Decoder = (GB18030Decoder)baseDecoder;
        EncodingCharBuffer encodingCharBuffer = new EncodingCharBuffer(this, gB18030Decoder, chars, charCount, bytes, byteCount);
        short num = -1;
        short num2 = -1;
        short num3 = -1;
        short num4 = -1;
        if (gB18030Decoder != null && gB18030Decoder.bLeftOver1 != -1)
        {
            num = gB18030Decoder.bLeftOver1;
            num2 = gB18030Decoder.bLeftOver2;
            num3 = gB18030Decoder.bLeftOver3;
            num4 = gB18030Decoder.bLeftOver4;
            while (num != -1)
            {
                if (!IsGBLeadByte(num))
                {
                    if (num <= 127)
                    {
                        if (!encodingCharBuffer.AddChar((char)num))
                        {
                            break;
                        }
                    }
                    else if (!encodingCharBuffer.Fallback((byte)num))
                    {
                        break;
                    }
                    num = num2;
                    num2 = num3;
                    num3 = num4;
                    num4 = -1;
                    continue;
                }
                while (num2 == -1 || (IsGBFourByteTrailing(num2) && num4 == -1))
                {
                    if (!encodingCharBuffer.MoreData)
                    {
                        if (gB18030Decoder.MustFlush)
                        {
                            break;
                        }
                        if (chars != null)
                        {
                            gB18030Decoder.bLeftOver1 = num;
                            gB18030Decoder.bLeftOver2 = num2;
                            gB18030Decoder.bLeftOver3 = num3;
                            gB18030Decoder.bLeftOver4 = num4;
                        }
                        gB18030Decoder.m_bytesUsed = encodingCharBuffer.BytesUsed;
                        return encodingCharBuffer.Count;
                    }
                    if (num2 == -1)
                    {
                        num2 = encodingCharBuffer.GetNextByte();
                    }
                    else if (num3 == -1)
                    {
                        num3 = encodingCharBuffer.GetNextByte();
                    }
                    else
                    {
                        num4 = encodingCharBuffer.GetNextByte();
                    }
                }
                if (IsGBTwoByteTrailing(num2))
                {
                    int num5 = num << 8;
                    num5 |= (byte)num2;
                    if (!encodingCharBuffer.AddChar(mapBytesToUnicode[num5], 2))
                    {
                        break;
                    }
                    num = -1;
                    num2 = -1;
                }
                else if (IsGBFourByteTrailing(num2) && IsGBLeadByte(num3) && IsGBFourByteTrailing(num4))
                {
                    int fourBytesOffset = GetFourBytesOffset(num, num2, num3, num4);
                    if (fourBytesOffset <= 39419)
                    {
                        if (!encodingCharBuffer.AddChar(map4BytesToUnicode[fourBytesOffset], 4))
                        {
                            break;
                        }
                    }
                    else if (fourBytesOffset >= 189000 && fourBytesOffset <= 1237575)
                    {
                        fourBytesOffset -= 189000;
                        if (!encodingCharBuffer.AddChar((char)(55296 + fourBytesOffset / 1024), (char)(56320 + fourBytesOffset % 1024), 4))
                        {
                            break;
                        }
                    }
                    else if (!encodingCharBuffer.Fallback((byte)num, (byte)num2, (byte)num3, (byte)num4))
                    {
                        break;
                    }
                    num = -1;
                    num2 = -1;
                    num3 = -1;
                    num4 = -1;
                }
                else
                {
                    if (!encodingCharBuffer.Fallback((byte)num))
                    {
                        break;
                    }
                    num = num2;
                    num2 = num3;
                    num3 = num4;
                    num4 = -1;
                }
            }
        }
        while (encodingCharBuffer.MoreData)
        {
            byte nextByte = encodingCharBuffer.GetNextByte();
            if (nextByte <= 127)
            {
                if (!encodingCharBuffer.AddChar((char)nextByte))
                {
                    break;
                }
            }
            else if (IsGBLeadByte(nextByte))
            {
                if (encodingCharBuffer.MoreData)
                {
                    byte nextByte2 = encodingCharBuffer.GetNextByte();
                    if (IsGBTwoByteTrailing(nextByte2))
                    {
                        int num6 = nextByte << 8;
                        num6 |= nextByte2;
                        if (!encodingCharBuffer.AddChar(mapBytesToUnicode[num6], 2))
                        {
                            break;
                        }
                    }
                    else if (IsGBFourByteTrailing(nextByte2))
                    {
                        if (encodingCharBuffer.EvenMoreData(2))
                        {
                            byte nextByte3 = encodingCharBuffer.GetNextByte();
                            byte nextByte4 = encodingCharBuffer.GetNextByte();
                            if (IsGBLeadByte(nextByte3) && IsGBFourByteTrailing(nextByte4))
                            {
                                int fourBytesOffset2 = GetFourBytesOffset(nextByte, nextByte2, nextByte3, nextByte4);
                                if (fourBytesOffset2 <= 39419)
                                {
                                    if (!encodingCharBuffer.AddChar(map4BytesToUnicode[fourBytesOffset2], 4))
                                    {
                                        break;
                                    }
                                }
                                else if (fourBytesOffset2 >= 189000 && fourBytesOffset2 <= 1237575)
                                {
                                    fourBytesOffset2 -= 189000;
                                    if (!encodingCharBuffer.AddChar((char)(55296 + fourBytesOffset2 / 1024), (char)(56320 + fourBytesOffset2 % 1024), 4))
                                    {
                                        break;
                                    }
                                }
                                else if (!encodingCharBuffer.Fallback(nextByte, nextByte2, nextByte3, nextByte4))
                                {
                                    break;
                                }
                            }
                            else
                            {
                                encodingCharBuffer.AdjustBytes(-3);
                                if (!encodingCharBuffer.Fallback(nextByte))
                                {
                                    break;
                                }
                            }
                            continue;
                        }
                        if (gB18030Decoder != null && !gB18030Decoder.MustFlush)
                        {
                            if (chars != null)
                            {
                                num = nextByte;
                                num2 = nextByte2;
                                num3 = (short)((!encodingCharBuffer.MoreData) ? (-1) : encodingCharBuffer.GetNextByte());
                                num4 = -1;
                            }
                            break;
                        }
                        if (!encodingCharBuffer.Fallback(nextByte, nextByte2))
                        {
                            break;
                        }
                    }
                    else
                    {
                        encodingCharBuffer.AdjustBytes(-1);
                        if (!encodingCharBuffer.Fallback(nextByte))
                        {
                            break;
                        }
                    }
                    continue;
                }
                if (gB18030Decoder != null && !gB18030Decoder.MustFlush)
                {
                    if (chars != null)
                    {
                        num = nextByte;
                        num2 = -1;
                        num3 = -1;
                        num4 = -1;
                    }
                    break;
                }
                if (!encodingCharBuffer.Fallback(nextByte))
                {
                    break;
                }
            }
            else if (!encodingCharBuffer.Fallback(nextByte))
            {
                break;
            }
        }
        if (gB18030Decoder != null)
        {
            if (chars != null)
            {
                gB18030Decoder.bLeftOver1 = num;
                gB18030Decoder.bLeftOver2 = num2;
                gB18030Decoder.bLeftOver3 = num3;
                gB18030Decoder.bLeftOver4 = num4;
            }
            gB18030Decoder.m_bytesUsed = encodingCharBuffer.BytesUsed;
        }
        return encodingCharBuffer.Count;
    }

References System.Text.Encoding.EncodingCharBuffer.AddChar(), System.Text.Encoding.EncodingCharBuffer.AdjustBytes(), System.Text.GB18030Encoding.GB18030Decoder.bLeftOver1, System.Text.GB18030Encoding.GB18030Decoder.bLeftOver2, System.Text.GB18030Encoding.GB18030Decoder.bLeftOver3, System.Text.GB18030Encoding.GB18030Decoder.bLeftOver4, System.byteCount, System.bytes, System.Text.Encoding.EncodingCharBuffer.BytesUsed, System.charCount, System.chars, System.Text.Encoding.EncodingCharBuffer.Count, System.Text.Encoding.EncodingCharBuffer.Fallback(), System.Text.GB18030Encoding.GetFourBytesOffset(), System.Text.Encoding.EncodingCharBuffer.GetNextByte(), System.Text.GB18030Encoding.IsGBFourByteTrailing(), System.Text.GB18030Encoding.IsGBLeadByte(), System.Text.GB18030Encoding.IsGBTwoByteTrailing(), System.Text.GB18030Encoding.map4BytesToUnicode, System.Text.DBCSCodePageEncoding.mapBytesToUnicode, System.Text.Encoding.EncodingCharBuffer.MoreData, and System.Text.DecoderNLS.MustFlush.

Referenced by System.Text.GB18030Encoding.GetCharCount().