DecodeBytes()

unsafe int System.Net.Mime.QEncodedStream.DecodeBytes ( byte[] buffer, int offset, int count )

inline

Implements System.Net.Mime.IEncodableStream.

Definition at line 150 of file QEncodedStream.cs.

    {
        fixed (byte* ptr = buffer)
        {
            byte* ptr2 = ptr + offset;
            byte* ptr3 = ptr2;
            byte* ptr4 = ptr2;
            byte* ptr5 = ptr2 + count;
            if (ReadState.IsEscaped)
            {
                if (ReadState.Byte == -1)
                {
                    if (count == 1)
                    {
                        ReadState.Byte = *ptr3;
                        return 0;
                    }
                    if (*ptr3 != 13 || ptr3[1] != 10)
                    {
                        byte b = HexDecodeMap[*ptr3];
                        byte b2 = HexDecodeMap[ptr3[1]];
                        if (b == byte.MaxValue)
                        {
                            throw new FormatException(System.SR.Format(System.SR.InvalidHexDigit, b));
                        }
                        if (b2 == byte.MaxValue)
                        {
                            throw new FormatException(System.SR.Format(System.SR.InvalidHexDigit, b2));
                        }
                        *(ptr4++) = (byte)((b << 4) + b2);
                    }
                    ptr3 += 2;
                }
                else
                {
                    if (ReadState.Byte != 13 || *ptr3 != 10)
                    {
                        byte b3 = HexDecodeMap[ReadState.Byte];
                        byte b4 = HexDecodeMap[*ptr3];
                        if (b3 == byte.MaxValue)
                        {
                            throw new FormatException(System.SR.Format(System.SR.InvalidHexDigit, b3));
                        }
                        if (b4 == byte.MaxValue)
                        {
                            throw new FormatException(System.SR.Format(System.SR.InvalidHexDigit, b4));
                        }
                        *(ptr4++) = (byte)((b3 << 4) + b4);
                    }
                    ptr3++;
                }
                ReadState.IsEscaped = false;
                ReadState.Byte = -1;
            }
            while (ptr3 < ptr5)
            {
                if (*ptr3 != 61)
                {
                    if (*ptr3 == 95)
                    {
                        *(ptr4++) = 32;
                        ptr3++;
                    }
                    else
                    {
                        *(ptr4++) = *(ptr3++);
                    }
                    continue;
                }
                long num = ptr5 - ptr3;
                if (num != 1)
                {
                    if (num != 2)
                    {
                        if (ptr3[1] != 13 || ptr3[2] != 10)
                        {
                            byte b5 = HexDecodeMap[ptr3[1]];
                            byte b6 = HexDecodeMap[ptr3[2]];
                            if (b5 == byte.MaxValue)
                            {
                                throw new FormatException(System.SR.Format(System.SR.InvalidHexDigit, b5));
                            }
                            if (b6 == byte.MaxValue)
                            {
                                throw new FormatException(System.SR.Format(System.SR.InvalidHexDigit, b6));
                            }
                            *(ptr4++) = (byte)((b5 << 4) + b6);
                        }
                        ptr3 += 3;
                        continue;
                    }
                    ReadState.Byte = ptr3[1];
                }
                ReadState.IsEscaped = true;
                break;
            }
            return (int)(ptr4 - ptr2);
        }
    }

References System.buffer, System.count, System.SR.Format(), System.Net.Mime.QEncodedStream.HexDecodeMap, System.SR.InvalidHexDigit, and System.offset.