//------------------------------------------------------------
// Copyright (c) Microsoft Corporation.  All rights reserved.
//------------------------------------------------------------
namespace System.Xml
{
    using System;
    using System.Collections;
    using System.Globalization;
    using System.IO;
    using System.Runtime;
    using System.Runtime.Serialization;
    using System.Security;
    using System.Text;

    class XmlBufferReader
    {
        XmlDictionaryReader reader;
        Stream stream;
        byte[] streamBuffer;
        byte[] buffer;
        int offsetMin;
        int offsetMax;
        IXmlDictionary dictionary;
        XmlBinaryReaderSession session;
        byte[] guid;
        int offset;
        const int maxBytesPerChar = 3;
        char[] chars;
        int windowOffset;
        int windowOffsetMax;
        ValueHandle listValue;
        static byte[] emptyByteArray = new byte[0];
        static XmlBufferReader empty = new XmlBufferReader(emptyByteArray);

        public XmlBufferReader(XmlDictionaryReader reader)
        {
            this.reader = reader;
        }

        public XmlBufferReader(byte[] buffer)
        {
            this.reader = null;
            this.buffer = buffer;
        }

        static public XmlBufferReader Empty
        {
            get
            {
                return empty;
            }
        }

        public byte[] Buffer
        {
            get
            {
                return buffer;
            }
        }

        public bool IsStreamed
        {
            get
            {
                return stream != null;
            }
        }

        public void SetBuffer(Stream stream, IXmlDictionary dictionary, XmlBinaryReaderSession session)
        {
            if (streamBuffer == null)
            {
                streamBuffer = new byte[128];
            }
            SetBuffer(stream, streamBuffer, 0, 0, dictionary, session);
            this.windowOffset = 0;
            this.windowOffsetMax = streamBuffer.Length;
        }

        public void SetBuffer(byte[] buffer, int offset, int count, IXmlDictionary dictionary, XmlBinaryReaderSession session)
        {
            SetBuffer(null, buffer, offset, count, dictionary, session);
        }

        void SetBuffer(Stream stream, byte[] buffer, int offset, int count, IXmlDictionary dictionary, XmlBinaryReaderSession session)
        {
            this.stream = stream;
            this.buffer = buffer;
            this.offsetMin = offset;
            this.offset = offset;
            this.offsetMax = offset + count;
            this.dictionary = dictionary;
            this.session = session;
        }

        public void Close()
        {
            if (streamBuffer != null && streamBuffer.Length > 4096)
            {
                streamBuffer = null;
            }
            if (stream != null)
            {
                stream.Close();
                this.stream = null;
            }
            this.buffer = emptyByteArray;
            this.offset = 0;
            this.offsetMax = 0;
            this.windowOffset = 0;
            this.windowOffsetMax = 0;
            this.dictionary = null;
            this.session = null;
        }

        public bool EndOfFile
        {
            get
            {
                return offset == offsetMax && !TryEnsureByte();
            }
        }

        public byte GetByte()
        {
            int offset = this.offset;
            if (offset < offsetMax)
                return buffer[offset];
            else
                return GetByteHard();
        }

        public void SkipByte()
        {
            Advance(1);
        }

        byte GetByteHard()
        {
            EnsureByte();
            return buffer[offset];
        }

        public byte[] GetBuffer(int count, out int offset)
        {
            offset = this.offset;
            if (offset <= this.offsetMax - count)
                return buffer;
            return GetBufferHard(count, out offset);
        }

        public byte[] GetBuffer(int count, out int offset, out int offsetMax)
        {
            offset = this.offset;
            if (offset <= this.offsetMax - count)
            {
                offsetMax = this.offset + count;
            }
            else
            {
                TryEnsureBytes(Math.Min(count, windowOffsetMax - offset));
                offsetMax = this.offsetMax;
            }
            return buffer;
        }

        public byte[] GetBuffer(out int offset, out int offsetMax)
        {
            offset = this.offset;
            offsetMax = this.offsetMax;
            return buffer;
        }

        byte[] GetBufferHard(int count, out int offset)
        {
            offset = this.offset;
            EnsureBytes(count);
            return buffer;
        }

        void EnsureByte()
        {
            if (!TryEnsureByte())
                XmlExceptionHelper.ThrowUnexpectedEndOfFile(reader);
        }

        bool TryEnsureByte()
        {
            if (stream == null)
                return false;
            if (offsetMax >= windowOffsetMax)
                XmlExceptionHelper.ThrowMaxBytesPerReadExceeded(reader, windowOffsetMax - windowOffset);
            if (offsetMax >= buffer.Length)
                return TryEnsureBytes(1);
            int b = stream.ReadByte();
            if (b == -1)
                return false;
            buffer[offsetMax++] = (byte)b;
            return true;
        }

        void EnsureBytes(int count)
        {
            if (!TryEnsureBytes(count))
                XmlExceptionHelper.ThrowUnexpectedEndOfFile(reader);
        }

        bool TryEnsureBytes(int count)
        {
            if (stream == null)
                return false;
            if (offset > int.MaxValue - count)
                XmlExceptionHelper.ThrowMaxBytesPerReadExceeded(reader, windowOffsetMax - windowOffset);
            int newOffsetMax = offset + count;
            if (newOffsetMax < offsetMax)
                return true;
            if (newOffsetMax > windowOffsetMax)
                XmlExceptionHelper.ThrowMaxBytesPerReadExceeded(reader, windowOffsetMax - windowOffset);
            if (newOffsetMax > buffer.Length)
            {
                byte[] newBuffer = new byte[Math.Max(newOffsetMax, buffer.Length * 2)];
                System.Buffer.BlockCopy(this.buffer, 0, newBuffer, 0, offsetMax);
                buffer = newBuffer;
                streamBuffer = newBuffer;
            }
            int needed = newOffsetMax - offsetMax;
            while (needed > 0)
            {
                int actual = stream.Read(buffer, offsetMax, needed);
                if (actual == 0)
                    return false;
                offsetMax += actual;
                needed -= actual;
            }
            return true;
        }

#if NO
        void ReadByte(byte b)
        {
            if (BufferReader.GetByte() != b)
                XmlExceptionHelper.ThrowTokenExpected(this, ((char)b).ToString(), (char)BufferReader.GetByte());
        }
#endif
        public void Advance(int count)
        {
            Fx.Assert(this.offset + count <= offsetMax, "");
            this.offset += count;
        }

        public void InsertBytes(byte[] buffer, int offset, int count)
        {
            Fx.Assert(stream != null, "");
            if (offsetMax > buffer.Length - count)
            {
                byte[] newBuffer = new byte[offsetMax + count];
                System.Buffer.BlockCopy(this.buffer, 0, newBuffer, 0, this.offsetMax);
                this.buffer = newBuffer;
                this.streamBuffer = newBuffer;
            }
            System.Buffer.BlockCopy(this.buffer, this.offset, this.buffer, this.offset + count, this.offsetMax - this.offset);
            offsetMax += count;
            System.Buffer.BlockCopy(buffer, offset, this.buffer, this.offset, count);
        }

        public void SetWindow(int windowOffset, int windowLength)
        {
            // [0...elementOffset-1][elementOffset..offset][offset..offsetMax-1][offsetMax..buffer.Length]
            // ^--Elements, Attributes in scope
            //                      ^-- The node just consumed
            //                                             ^--Data buffered, not consumed
            //                                                                  ^--Unused space
            if (windowOffset > int.MaxValue - windowLength)
                windowLength = int.MaxValue - windowOffset;

            if (offset != windowOffset)
            {
                System.Buffer.BlockCopy(buffer, offset, buffer, windowOffset, offsetMax - offset);
                offsetMax = windowOffset + (offsetMax - offset);
                offset = windowOffset;
            }
            this.windowOffset = windowOffset;
            this.windowOffsetMax = Math.Max(windowOffset + windowLength, offsetMax);
        }

        public int Offset
        {
            get
            {
                return offset;
            }
            set
            {
                Fx.Assert(value >= offsetMin && value <= offsetMax, "");
                this.offset = value;
            }
        }

        public int ReadBytes(int count)
        {
            Fx.Assert(count >= 0, "");
            int offset = this.offset;
            if (offset > offsetMax - count)
                EnsureBytes(count);
            this.offset += count;
            return offset;
        }

        public int ReadMultiByteUInt31()
        {
            int i = GetByte();
            Advance(1);
            if ((i & 0x80) == 0)
                return i;
            i &= 0x7F;

            int j = GetByte();
            Advance(1);
            i |= ((j & 0x7F) << 7);
            if ((j & 0x80) == 0)
                return i;

            int k = GetByte();
            Advance(1);
            i |= ((k & 0x7F) << 14);
            if ((k & 0x80) == 0)
                return i;

            int l = GetByte();
            Advance(1);
            i |= ((l & 0x7F) << 21);
            if ((l & 0x80) == 0)
                return i;

            int m = GetByte();
            Advance(1);
            i |= (m << 28);
            if ((m & 0xF8) != 0)
                XmlExceptionHelper.ThrowInvalidBinaryFormat(reader);

            return i;
        }

        public int ReadUInt8()
        {
            byte b = GetByte();
            Advance(1);
            return b;
        }

        public int ReadInt8()
        {
            return (sbyte)ReadUInt8();
        }

        public int ReadUInt16()
        {
            int offset;
            byte[] buffer = GetBuffer(2, out offset);
            int i = buffer[offset + 0] + (buffer[offset + 1] << 8);
            Advance(2);
            return i;
        }

        public int ReadInt16()
        {
            return (Int16)ReadUInt16();
        }

        public int ReadInt32()
        {
            int offset;
            byte[] buffer = GetBuffer(4, out offset);
            byte b1 = buffer[offset + 0];
            byte b2 = buffer[offset + 1];
            byte b3 = buffer[offset + 2];
            byte b4 = buffer[offset + 3];
            Advance(4);
            return (((((b4 << 8) + b3) << 8) + b2) << 8) + b1;
        }

        public int ReadUInt31()
        {
            int i = ReadInt32();
            if (i < 0)
                XmlExceptionHelper.ThrowInvalidBinaryFormat(reader);
            return i;
        }

        public long ReadInt64()
        {
            Int64 lo = (UInt32)ReadInt32();
            Int64 hi = (UInt32)ReadInt32();
            return (hi << 32) + lo;
        }

        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code.",
            Safe = "Unsafe code is effectively encapsulated, all inputs are validated.")]
        [SecuritySafeCritical]
        unsafe public float ReadSingle()
        {
            int offset;
            byte[] buffer = GetBuffer(ValueHandleLength.Single, out offset);
            float value;
            byte* pb = (byte*)&value;
            Fx.Assert(sizeof(float) == 4, "");
            pb[0] = buffer[offset + 0];
            pb[1] = buffer[offset + 1];
            pb[2] = buffer[offset + 2];
            pb[3] = buffer[offset + 3];
            Advance(ValueHandleLength.Single);
            return value;
        }

        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code.",
            Safe = "Unsafe code is effectively encapsulated, all inputs are validated.")]
        [SecuritySafeCritical]
        unsafe public double ReadDouble()
        {
            int offset;
            byte[] buffer = GetBuffer(ValueHandleLength.Double, out offset);
            double value;
            byte* pb = (byte*)&value;
            Fx.Assert(sizeof(double) == 8, "");
            pb[0] = buffer[offset + 0];
            pb[1] = buffer[offset + 1];
            pb[2] = buffer[offset + 2];
            pb[3] = buffer[offset + 3];
            pb[4] = buffer[offset + 4];
            pb[5] = buffer[offset + 5];
            pb[6] = buffer[offset + 6];
            pb[7] = buffer[offset + 7];
            Advance(ValueHandleLength.Double);
            return value;
        }

        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code.",
            Safe = "Unsafe code is effectively encapsulated, all inputs are validated.")]
        [SecuritySafeCritical]
        unsafe public decimal ReadDecimal()
        {
            const int SignMask = unchecked((int)0x80000000);
            const int ScaleMask = 0x00FF0000;

            int offset;
            byte[] buffer = GetBuffer(ValueHandleLength.Decimal, out offset);
            byte b1 = buffer[offset + 0];
            byte b2 = buffer[offset + 1];
            byte b3 = buffer[offset + 2];
            byte b4 = buffer[offset + 3];
            int flags = (((((b4 << 8) + b3) << 8) + b2) << 8) + b1;

            //this logic mirrors the code in Decimal(int []) ctor.
            if ((flags & ~(SignMask | ScaleMask)) == 0 && (flags & ScaleMask) <= (28 << 16))
            {
                decimal value;
                byte* pb = (byte*)&value;
                for (int i = 0; i < sizeof(decimal); i++)
                    pb[i] = buffer[offset + i];

                Advance(ValueHandleLength.Decimal);
                return value;
            }
            else
            {
                XmlExceptionHelper.ThrowInvalidBinaryFormat(this.reader);
            }

            //compiler doesn't know that XmlExceptionHelper.ThrowInvalidBinaryFormat always throws, 
            //so we have to have a return statement here even though we shouldn't hit this code path...
            Fx.Assert("A decimal value should have been returned or an exception should have been thrown.");
            return default(decimal);
        }

        public UniqueId ReadUniqueId()
        {
            int offset;
            byte[] buffer = GetBuffer(ValueHandleLength.UniqueId, out offset);
            UniqueId uniqueId = new UniqueId(buffer, offset);
            Advance(ValueHandleLength.UniqueId);
            return uniqueId;
        }

        public DateTime ReadDateTime()
        {
            long value = 0;
            try
            {
                value = ReadInt64();
                return DateTime.FromBinary(value);
            }
            catch (ArgumentException exception)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateConversionException(value.ToString(CultureInfo.InvariantCulture), "DateTime", exception));
            }
            catch (FormatException exception)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateConversionException(value.ToString(CultureInfo.InvariantCulture), "DateTime", exception));
            }
            catch (OverflowException exception)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateConversionException(value.ToString(CultureInfo.InvariantCulture), "DateTime", exception));
            }
        }

        public TimeSpan ReadTimeSpan()
        {
            long value = 0;
            try
            {
                value = ReadInt64();
                return TimeSpan.FromTicks(value);
            }
            catch (ArgumentException exception)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateConversionException(value.ToString(CultureInfo.InvariantCulture), "TimeSpan", exception));
            }
            catch (FormatException exception)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateConversionException(value.ToString(CultureInfo.InvariantCulture), "TimeSpan", exception));
            }
            catch (OverflowException exception)
            {
                throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlExceptionHelper.CreateConversionException(value.ToString(CultureInfo.InvariantCulture), "TimeSpan", exception));
            }
        }

        public Guid ReadGuid()
        {
            int offset;
            byte[] buffer = GetBuffer(ValueHandleLength.Guid, out offset);
            Guid guid = GetGuid(offset);
            Advance(ValueHandleLength.Guid);
            return guid;
        }

        public string ReadUTF8String(int length)
        {
            int offset;
            byte[] buffer = GetBuffer(length, out offset);
            char[] chars = GetCharBuffer(length);
            int charCount = GetChars(offset, length, chars);
            string value = new string(chars, 0, charCount);
            Advance(length);
            return value;
        }

        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code. Caller needs to validate arguments.")]
        [SecurityCritical]
        unsafe public void UnsafeReadArray(byte* dst, byte* dstMax)
        {
            UnsafeReadArray(dst, (int)(dstMax - dst));
        }

        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code. Caller needs to validate arguments.")]
        [SecurityCritical]
        unsafe void UnsafeReadArray(byte* dst, int length)
        {
            if (stream != null)
            {
                const int chunk = 256;
                while (length >= chunk)
                {
                    byte[] _buffer = GetBuffer(chunk, out offset);
                    for (int i = 0; i < chunk; i++)
                    {
                        *dst++ = _buffer[offset + i];
                    }
                    Advance(chunk);
                    length -= chunk;
                }
            }

            if (length > 0)
            {
                byte[] buffer = GetBuffer(length, out offset);
                fixed (byte* _src = &buffer[offset])
                {
                    byte* src = _src;
                    byte* dstMax = dst + length;
                    while (dst < dstMax)
                    {
                        *dst = *src;
                        dst++;
                        src++;
                    }
                }
                Advance(length);
            }
        }

        char[] GetCharBuffer(int count)
        {
            if (count > 1024)
                return new char[count];
            if (chars == null || chars.Length < count)
                chars = new char[count];
            return chars;
        }

        int GetChars(int offset, int length, char[] chars)
        {
            byte[] buffer = this.buffer;
            for (int i = 0; i < length; i++)
            {
                byte b = buffer[offset + i];
                if (b >= 0x80)
                    return i + XmlConverter.ToChars(buffer, offset + i, length - i, chars, i);
                chars[i] = (char)b;
            }
            return length;
        }

        int GetChars(int offset, int length, char[] chars, int charOffset)
        {
            byte[] buffer = this.buffer;
            for (int i = 0; i < length; i++)
            {
                byte b = buffer[offset + i];
                if (b >= 0x80)
                    return i + XmlConverter.ToChars(buffer, offset + i, length - i, chars, charOffset + i);
                chars[charOffset + i] = (char)b;
            }
            return length;
        }

        public string GetString(int offset, int length)
        {
            char[] chars = GetCharBuffer(length);
            int charCount = GetChars(offset, length, chars);
            return new string(chars, 0, charCount);
        }

        public string GetUnicodeString(int offset, int length)
        {
            return XmlConverter.ToStringUnicode(buffer, offset, length);
        }

        public string GetString(int offset, int length, XmlNameTable nameTable)
        {
            char[] chars = GetCharBuffer(length);
            int charCount = GetChars(offset, length, chars);
            return nameTable.Add(chars, 0, charCount);
        }

        public int GetEscapedChars(int offset, int length, char[] chars)
        {
            byte[] buffer = this.buffer;
            int charCount = 0;
            int textOffset = offset;
            int offsetMax = offset + length;
            while (true)
            {
                while (offset < offsetMax && IsAttrChar(buffer[offset]))
                    offset++;
                charCount += GetChars(textOffset, offset - textOffset, chars, charCount);
                if (offset == offsetMax)
                    break;
                textOffset = offset;
                if (buffer[offset] == '&')
                {
                    while (offset < offsetMax && buffer[offset] != ';')
                        offset++;
                    offset++;
                    int ch = GetCharEntity(textOffset, offset - textOffset);
                    textOffset = offset;
                    if (ch > char.MaxValue)
                    {
                        SurrogateChar surrogate = new SurrogateChar(ch);
                        chars[charCount++] = surrogate.HighChar;
                        chars[charCount++] = surrogate.LowChar;
                    }
                    else
                    {
                        chars[charCount++] = (char)ch;
                    }
                }
                else if (buffer[offset] == '\n' || buffer[offset] == '\t')
                {
                    chars[charCount++] = ' ';
                    offset++;
                    textOffset = offset;
                }
                else // '\r'
                {
                    chars[charCount++] = ' ';
                    offset++;

                    if (offset < offsetMax && buffer[offset] == '\n')
                        offset++;

                    textOffset = offset;
                }

            }
            return charCount;
        }

        bool IsAttrChar(int ch)
        {
            switch (ch)
            {
                case '&':
                case '\r':
                case '\t':
                case '\n':
                    return false;

                default:
                    return true;
            }
        }

        public string GetEscapedString(int offset, int length)
        {
            char[] chars = GetCharBuffer(length);
            int charCount = GetEscapedChars(offset, length, chars);
            return new string(chars, 0, charCount);
        }

        public string GetEscapedString(int offset, int length, XmlNameTable nameTable)
        {
            char[] chars = GetCharBuffer(length);
            int charCount = GetEscapedChars(offset, length, chars);
            return nameTable.Add(chars, 0, charCount);
        }

        int GetLessThanCharEntity(int offset, int length)
        {
            byte[] buffer = this.buffer;
            if (length != 4 ||
                buffer[offset + 1] != (byte)'l' ||
                buffer[offset + 2] != (byte)'t')
            {
                XmlExceptionHelper.ThrowInvalidCharRef(reader);
            }
            return (int)'<';
        }

        int GetGreaterThanCharEntity(int offset, int length)
        {
            byte[] buffer = this.buffer;
            if (length != 4 ||
                buffer[offset + 1] != (byte)'g' ||
                buffer[offset + 2] != (byte)'t')
            {
                XmlExceptionHelper.ThrowInvalidCharRef(reader);
            }
            return (int)'>';
        }

        int GetQuoteCharEntity(int offset, int length)
        {
            byte[] buffer = this.buffer;
            if (length != 6 ||
                buffer[offset + 1] != (byte)'q' ||
                buffer[offset + 2] != (byte)'u' ||
                buffer[offset + 3] != (byte)'o' ||
                buffer[offset + 4] != (byte)'t')
            {
                XmlExceptionHelper.ThrowInvalidCharRef(reader);
            }
            return (int)'"';
        }

        int GetAmpersandCharEntity(int offset, int length)
        {
            byte[] buffer = this.buffer;
            if (length != 5 ||
                buffer[offset + 1] != (byte)'a' ||
                buffer[offset + 2] != (byte)'m' ||
                buffer[offset + 3] != (byte)'p')
            {
                XmlExceptionHelper.ThrowInvalidCharRef(reader);
            }
            return (int)'&';
        }

        int GetApostropheCharEntity(int offset, int length)
        {
            byte[] buffer = this.buffer;
            if (length != 6 ||
                buffer[offset + 1] != (byte)'a' ||
                buffer[offset + 2] != (byte)'p' ||
                buffer[offset + 3] != (byte)'o' ||
                buffer[offset + 4] != (byte)'s')
            {
                XmlExceptionHelper.ThrowInvalidCharRef(reader);
            }
            return (int)'\'';
        }

        int GetDecimalCharEntity(int offset, int length)
        {
            byte[] buffer = this.buffer;
            Fx.Assert(buffer[offset + 0] == '&', "");
            Fx.Assert(buffer[offset + 1] == '#', "");
            Fx.Assert(buffer[offset + length - 1] == ';', "");
            int value = 0;
            for (int i = 2; i < length - 1; i++)
            {
                byte ch = buffer[offset + i];
                if (ch < (byte)'0' || ch > (byte)'9')
                    XmlExceptionHelper.ThrowInvalidCharRef(reader);
                value = value * 10 + (ch - '0');
                if (value > SurrogateChar.MaxValue)
                    XmlExceptionHelper.ThrowInvalidCharRef(reader);
            }
            return value;
        }

        int GetHexCharEntity(int offset, int length)
        {
            byte[] buffer = this.buffer;
            Fx.Assert(buffer[offset + 0] == '&', "");
            Fx.Assert(buffer[offset + 1] == '#', "");
            Fx.Assert(buffer[offset + 2] == 'x', "");
            Fx.Assert(buffer[offset + length - 1] == ';', "");
            int value = 0;
            for (int i = 3; i < length - 1; i++)
            {
                byte ch = buffer[offset + i];
                int digit = 0;
                if (ch >= '0' && ch <= '9')
                    digit = (ch - '0');
                else if (ch >= 'a' && ch <= 'f')
                    digit = 10 + (ch - 'a');
                else if (ch >= 'A' && ch <= 'F')
                    digit = 10 + (ch - 'A');
                else
                    XmlExceptionHelper.ThrowInvalidCharRef(reader);
                Fx.Assert(digit >= 0 && digit < 16, "");
                value = value * 16 + digit;
                if (value > SurrogateChar.MaxValue)
                    XmlExceptionHelper.ThrowInvalidCharRef(reader);
            }
            return value;
        }

        public int GetCharEntity(int offset, int length)
        {
            if (length < 3)
                XmlExceptionHelper.ThrowInvalidCharRef(reader);
            byte[] buffer = this.buffer;
            Fx.Assert(buffer[offset] == '&', "");
            Fx.Assert(buffer[offset + length - 1] == ';', "");
            switch (buffer[offset + 1])
            {
                case (byte)'l':
                    return GetLessThanCharEntity(offset, length);
                case (byte)'g':
                    return GetGreaterThanCharEntity(offset, length);
                case (byte)'a':
                    if (buffer[offset + 2] == (byte)'m')
                        return GetAmpersandCharEntity(offset, length);
                    else
                        return GetApostropheCharEntity(offset, length);
                case (byte)'q':
                    return GetQuoteCharEntity(offset, length);
                case (byte)'#':
                    if (buffer[offset + 2] == (byte)'x')
                        return GetHexCharEntity(offset, length);
                    else
                        return GetDecimalCharEntity(offset, length);
                default:
                    XmlExceptionHelper.ThrowInvalidCharRef(reader);
                    return 0;
            }
        }

        public bool IsWhitespaceKey(int key)
        {
            string s = GetDictionaryString(key).Value;
            for (int i = 0; i < s.Length; i++)
            {
                if (!XmlConverter.IsWhitespace(s[i]))
                    return false;
            }
            return true;
        }

        public bool IsWhitespaceUTF8(int offset, int length)
        {
            byte[] buffer = this.buffer;
            for (int i = 0; i < length; i++)
            {
                if (!XmlConverter.IsWhitespace((char)buffer[offset + i]))
                    return false;
            }
            return true;
        }

        public bool IsWhitespaceUnicode(int offset, int length)
        {
            byte[] buffer = this.buffer;
            for (int i = 0; i < length; i += sizeof(char))
            {
                char ch = (char)GetInt16(offset + i);
                if (!XmlConverter.IsWhitespace(ch))
                    return false;
            }
            return true;
        }

        public bool Equals2(int key1, int key2, XmlBufferReader bufferReader2)
        {
            // If the keys aren't from the same dictionary, they still might be the same
            if (key1 == key2)
                return true;
            else
                return GetDictionaryString(key1).Value == bufferReader2.GetDictionaryString(key2).Value;
        }

        public bool Equals2(int key1, XmlDictionaryString xmlString2)
        {
            if ((key1 & 1) == 0 && xmlString2.Dictionary == dictionary)
                return xmlString2.Key == (key1 >> 1);
            else
                return GetDictionaryString(key1).Value == xmlString2.Value;
        }

        public bool Equals2(int offset1, int length1, byte[] buffer2)
        {
            int length2 = buffer2.Length;
            if (length1 != length2)
                return false;
            byte[] buffer1 = this.buffer;
            for (int i = 0; i < length1; i++)
            {
                if (buffer1[offset1 + i] != buffer2[i])
                    return false;
            }
            return true;
        }

        public bool Equals2(int offset1, int length1, XmlBufferReader bufferReader2, int offset2, int length2)
        {
            if (length1 != length2)
                return false;
            byte[] buffer1 = this.buffer;
            byte[] buffer2 = bufferReader2.buffer;
            for (int i = 0; i < length1; i++)
            {
                if (buffer1[offset1 + i] != buffer2[offset2 + i])
                    return false;
            }
            return true;
        }

        public bool Equals2(int offset1, int length1, int offset2, int length2)
        {
            if (length1 != length2)
                return false;
            if (offset1 == offset2)
                return true;
            byte[] buffer = this.buffer;
            for (int i = 0; i < length1; i++)
            {
                if (buffer[offset1 + i] != buffer[offset2 + i])
                    return false;
            }
            return true;
        }

        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code.",
            Safe = "Unsafe code is effectively encapsulated, all inputs are validated.")]
        [SecuritySafeCritical]
        unsafe public bool Equals2(int offset1, int length1, string s2)
        {
            int byteLength = length1;
            int charLength = s2.Length;

            // N unicode chars will be represented in at least N bytes, but
            // no more than N * 3 bytes.  If the byte count falls outside of this
            // range, then the strings cannot be equal.
            if (byteLength < charLength || byteLength > charLength * maxBytesPerChar)
                return false;

            byte[] buffer = this.buffer;
            if (length1 < 8)
            {
                int length = Math.Min(byteLength, charLength);
                int offset = offset1;
                for (int i = 0; i < length; i++)
                {
                    byte b = buffer[offset + i];
                    if (b >= 0x80)
                        return XmlConverter.ToString(buffer, offset1, length1) == s2;
                    if (s2[i] != (char)b)
                        return false;
                }
                return byteLength == charLength;
            }
            else
            {
                int length = Math.Min(byteLength, charLength);
                fixed (byte* _pb = &buffer[offset1])
                {
                    byte* pb = _pb;
                    byte* pbMax = pb + length;
                    fixed (char* _pch = s2)
                    {
                        char* pch = _pch;
                        // Try to do the fast comparison in ascii space
                        int t = 0;
                        while (pb < pbMax && *pb < 0x80)
                        {
                            t = *pb - (byte)(*pch);
                            // The code generated is better if we break out then return
                            if (t != 0)
                                break;
                            pb++;
                            pch++;
                        }
                        if (t != 0)
                            return false;
                        if (pb == pbMax)
                            return (byteLength == charLength);
                    }
                }
                return XmlConverter.ToString(buffer, offset1, length1) == s2;
            }
        }

        public int Compare(int offset1, int length1, int offset2, int length2)
        {
            byte[] buffer = this.buffer;
            int length = Math.Min(length1, length2);
            for (int i = 0; i < length; i++)
            {
                int s = buffer[offset1 + i] - buffer[offset2 + i];
                if (s != 0)
                    return s;
            }
            return length1 - length2;
        }

        public byte GetByte(int offset)
        {
            return buffer[offset];
        }

        public int GetInt8(int offset)
        {
            return (sbyte)GetByte(offset);
        }

        public int GetInt16(int offset)
        {
            byte[] buffer = this.buffer;
            return (Int16)(buffer[offset] + (buffer[offset + 1] << 8));
        }

        public int GetInt32(int offset)
        {
            byte[] buffer = this.buffer;
            byte b1 = buffer[offset + 0];
            byte b2 = buffer[offset + 1];
            byte b3 = buffer[offset + 2];
            byte b4 = buffer[offset + 3];
            return (((((b4 << 8) + b3) << 8) + b2) << 8) + b1;
        }

        public long GetInt64(int offset)
        {
            byte[] buffer = this.buffer;
            byte b1, b2, b3, b4;
            b1 = buffer[offset + 0];
            b2 = buffer[offset + 1];
            b3 = buffer[offset + 2];
            b4 = buffer[offset + 3];
            Int64 lo = (UInt32)(((((b4 << 8) + b3) << 8) + b2) << 8) + b1;
            b1 = buffer[offset + 4];
            b2 = buffer[offset + 5];
            b3 = buffer[offset + 6];
            b4 = buffer[offset + 7];
            Int64 hi = (UInt32)(((((b4 << 8) + b3) << 8) + b2) << 8) + b1;
            return (hi << 32) + lo;
        }

        public ulong GetUInt64(int offset)
        {
            return (ulong)GetInt64(offset);
        }

        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code.",
            Safe = "Unsafe code is effectively encapsulated, all inputs are validated.")]
        [SecuritySafeCritical]
        unsafe public float GetSingle(int offset)
        {
            byte[] buffer = this.buffer;
            float value;
            byte* pb = (byte*)&value;
            Fx.Assert(sizeof(float) == 4, "");
            pb[0] = buffer[offset + 0];
            pb[1] = buffer[offset + 1];
            pb[2] = buffer[offset + 2];
            pb[3] = buffer[offset + 3];
            return value;
        }

        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code.",
            Safe = "Unsafe code is effectively encapsulated, all inputs are validated.")]
        [SecuritySafeCritical]
        unsafe public double GetDouble(int offset)
        {
            byte[] buffer = this.buffer;
            double value;
            byte* pb = (byte*)&value;
            Fx.Assert(sizeof(double) == 8, "");
            pb[0] = buffer[offset + 0];
            pb[1] = buffer[offset + 1];
            pb[2] = buffer[offset + 2];
            pb[3] = buffer[offset + 3];
            pb[4] = buffer[offset + 4];
            pb[5] = buffer[offset + 5];
            pb[6] = buffer[offset + 6];
            pb[7] = buffer[offset + 7];
            return value;
        }

        [Fx.Tag.SecurityNote(Critical = "Contains unsafe code.",
            Safe = "Unsafe code is effectively encapsulated, all inputs are validated.")]
        [SecuritySafeCritical]
        public unsafe decimal GetDecimal(int offset)
        {
            const int SignMask = unchecked((int)0x80000000);
            const int ScaleMask = 0x00FF0000;

            byte[] buffer = this.buffer;
            byte b1 = buffer[offset + 0];
            byte b2 = buffer[offset + 1];
            byte b3 = buffer[offset + 2];
            byte b4 = buffer[offset + 3];
            int flags = (((((b4 << 8) + b3) << 8) + b2) << 8) + b1;

            //this logic mirrors the code in Decimal(int []) ctor.
            if ((flags & ~(SignMask | ScaleMask)) == 0 && (flags & ScaleMask) <= (28 << 16))
            {
                decimal value;
                byte* pb = (byte*)&value;
                for (int i = 0; i < sizeof(decimal); i++)
                    pb[i] = buffer[offset + i];
                return value;
            }
            else
            {
                XmlExceptionHelper.ThrowInvalidBinaryFormat(this.reader);
            }

            //compiler doesn't know that XmlExceptionHelper.ThrowInvalidBinaryFormat always throws, 
            //so we have to have a return statement here even though we shouldn't hit this code path...
            Fx.Assert("A decimal value should have been returned or an exception should have been thrown.");
            return default(decimal);
        }

        public UniqueId GetUniqueId(int offset)
        {
            return new UniqueId(this.buffer, offset);
        }

        public Guid GetGuid(int offset)
        {
            if (guid == null)
                guid = new byte[16];
            System.Buffer.BlockCopy(buffer, offset, guid, 0, guid.Length);
            return new Guid(guid);
        }

        public void GetBase64(int srcOffset, byte[] buffer, int dstOffset, int count)
        {
            System.Buffer.BlockCopy(this.buffer, srcOffset, buffer, dstOffset, count);
        }

        public XmlBinaryNodeType GetNodeType()
        {
            return (XmlBinaryNodeType)GetByte();
        }

        public void SkipNodeType()
        {
            SkipByte();
        }

        public object[] GetList(int offset, int count)
        {
            int bufferOffset = this.Offset;
            this.Offset = offset;
            try
            {
                object[] objects = new object[count];
                for (int i = 0; i < count; i++)
                {
                    XmlBinaryNodeType nodeType = GetNodeType();
                    SkipNodeType();
                    Fx.Assert(nodeType != XmlBinaryNodeType.StartListText, "");
                    ReadValue(nodeType, listValue);
                    objects[i] = listValue.ToObject();
                }
                return objects;
            }
            finally
            {
                this.Offset = bufferOffset;
            }
        }

        public XmlDictionaryString GetDictionaryString(int key)
        {
            IXmlDictionary keyDictionary;
            if ((key & 1) != 0)
            {
                keyDictionary = session;
            }
            else
            {
                keyDictionary = dictionary;
            }
            XmlDictionaryString s;
            if (!keyDictionary.TryLookup(key >> 1, out s))
                XmlExceptionHelper.ThrowInvalidBinaryFormat(reader);
            return s;
        }

        public int ReadDictionaryKey()
        {
            int key = ReadMultiByteUInt31();
            if ((key & 1) != 0)
            {
                if (session == null)
                    XmlExceptionHelper.ThrowInvalidBinaryFormat(reader);
                int sessionKey = (key >> 1);
                XmlDictionaryString xmlString;
                if (!session.TryLookup(sessionKey, out xmlString))
                {
                    if (sessionKey < XmlDictionaryString.MinKey || sessionKey > XmlDictionaryString.MaxKey)
                        XmlExceptionHelper.ThrowXmlDictionaryStringIDOutOfRange(this.reader);
                    XmlExceptionHelper.ThrowXmlDictionaryStringIDUndefinedSession(this.reader, sessionKey);
                }
            }
            else
            {
                if (dictionary == null)
                    XmlExceptionHelper.ThrowInvalidBinaryFormat(reader);
                int staticKey = (key >> 1);
                XmlDictionaryString xmlString;
                if (!dictionary.TryLookup(staticKey, out xmlString))
                {
                    if (staticKey < XmlDictionaryString.MinKey || staticKey > XmlDictionaryString.MaxKey)
                        XmlExceptionHelper.ThrowXmlDictionaryStringIDOutOfRange(this.reader);
                    XmlExceptionHelper.ThrowXmlDictionaryStringIDUndefinedStatic(this.reader, staticKey);
                }
            }

            return key;
        }

        public void ReadValue(XmlBinaryNodeType nodeType, ValueHandle value)
        {
            switch (nodeType)
            {
                case XmlBinaryNodeType.EmptyText:
                    value.SetValue(ValueHandleType.Empty);
                    break;
                case XmlBinaryNodeType.ZeroText:
                    value.SetValue(ValueHandleType.Zero);
                    break;
                case XmlBinaryNodeType.OneText:
                    value.SetValue(ValueHandleType.One);
                    break;
                case XmlBinaryNodeType.TrueText:
                    value.SetValue(ValueHandleType.True);
                    break;
                case XmlBinaryNodeType.FalseText:
                    value.SetValue(ValueHandleType.False);
                    break;
                case XmlBinaryNodeType.BoolText:
                    value.SetValue(ReadUInt8() != 0 ? ValueHandleType.True : ValueHandleType.False);
                    break;
                case XmlBinaryNodeType.Chars8Text:
                    ReadValue(value, ValueHandleType.UTF8, ReadUInt8());
                    break;
                case XmlBinaryNodeType.Chars16Text:
                    ReadValue(value, ValueHandleType.UTF8, ReadUInt16());
                    break;
                case XmlBinaryNodeType.Chars32Text:
                    ReadValue(value, ValueHandleType.UTF8, ReadUInt31());
                    break;
                case XmlBinaryNodeType.UnicodeChars8Text:
                    ReadUnicodeValue(value, ReadUInt8());
                    break;
                case XmlBinaryNodeType.UnicodeChars16Text:
                    ReadUnicodeValue(value, ReadUInt16());
                    break;
                case XmlBinaryNodeType.UnicodeChars32Text:
                    ReadUnicodeValue(value, ReadUInt31());
                    break;
                case XmlBinaryNodeType.Bytes8Text:
                    ReadValue(value, ValueHandleType.Base64, ReadUInt8());
                    break;
                case XmlBinaryNodeType.Bytes16Text:
                    ReadValue(value, ValueHandleType.Base64, ReadUInt16());
                    break;
                case XmlBinaryNodeType.Bytes32Text:
                    ReadValue(value, ValueHandleType.Base64, ReadUInt31());
                    break;
                case XmlBinaryNodeType.DictionaryText:
                    value.SetDictionaryValue(ReadDictionaryKey());
                    break;
                case XmlBinaryNodeType.UniqueIdText:
                    ReadValue(value, ValueHandleType.UniqueId, ValueHandleLength.UniqueId);
                    break;
                case XmlBinaryNodeType.GuidText:
                    ReadValue(value, ValueHandleType.Guid, ValueHandleLength.Guid);
                    break;
                case XmlBinaryNodeType.DecimalText:
                    ReadValue(value, ValueHandleType.Decimal, ValueHandleLength.Decimal);
                    break;
                case XmlBinaryNodeType.Int8Text:
                    ReadValue(value, ValueHandleType.Int8, ValueHandleLength.Int8);
                    break;
                case XmlBinaryNodeType.Int16Text:
                    ReadValue(value, ValueHandleType.Int16, ValueHandleLength.Int16);
                    break;
                case XmlBinaryNodeType.Int32Text:
                    ReadValue(value, ValueHandleType.Int32, ValueHandleLength.Int32);
                    break;
                case XmlBinaryNodeType.Int64Text:
                    ReadValue(value, ValueHandleType.Int64, ValueHandleLength.Int64);
                    break;
                case XmlBinaryNodeType.UInt64Text:
                    ReadValue(value, ValueHandleType.UInt64, ValueHandleLength.UInt64);
                    break;
                case XmlBinaryNodeType.FloatText:
                    ReadValue(value, ValueHandleType.Single, ValueHandleLength.Single);
                    break;
                case XmlBinaryNodeType.DoubleText:
                    ReadValue(value, ValueHandleType.Double, ValueHandleLength.Double);
                    break;
                case XmlBinaryNodeType.TimeSpanText:
                    ReadValue(value, ValueHandleType.TimeSpan, ValueHandleLength.TimeSpan);
                    break;
                case XmlBinaryNodeType.DateTimeText:
                    ReadValue(value, ValueHandleType.DateTime, ValueHandleLength.DateTime);
                    break;
                case XmlBinaryNodeType.StartListText:
                    ReadList(value);
                    break;
                case XmlBinaryNodeType.QNameDictionaryText:
                    ReadQName(value);
                    break;
                default:
                    XmlExceptionHelper.ThrowInvalidBinaryFormat(reader);
                    break;
            }
        }

        void ReadValue(ValueHandle value, ValueHandleType type, int length)
        {
            int offset = ReadBytes(length);
            value.SetValue(type, offset, length);
        }

        void ReadUnicodeValue(ValueHandle value, int length)
        {
            if ((length & 1) != 0)
                XmlExceptionHelper.ThrowInvalidBinaryFormat(reader);
            ReadValue(value, ValueHandleType.Unicode, length);
        }

        void ReadList(ValueHandle value)
        {
            if (listValue == null)
            {
                listValue = new ValueHandle(this);
            }
            int count = 0;
            int offset = this.Offset;
            while (true)
            {
                XmlBinaryNodeType nodeType = GetNodeType();
                SkipNodeType();
                if (nodeType == XmlBinaryNodeType.StartListText)
                    XmlExceptionHelper.ThrowInvalidBinaryFormat(reader);
                if (nodeType == XmlBinaryNodeType.EndListText)
                    break;
                ReadValue(nodeType, listValue);
                count++;
            }
            value.SetValue(ValueHandleType.List, offset, count);
        }

        public void ReadQName(ValueHandle value)
        {
            int prefix = ReadUInt8();
            if (prefix >= 26)
                XmlExceptionHelper.ThrowInvalidBinaryFormat(reader);
            int key = ReadDictionaryKey();
            value.SetQNameValue(prefix, key);
        }

        public int[] GetRows()
        {
            if (buffer == null)
            {
                return new int[1] { 0 };
            }

            ArrayList list = new ArrayList();
            list.Add(offsetMin);
            for (int i = offsetMin; i < offsetMax; i++)
            {
                if (buffer[i] == (byte)13 || buffer[i] == (byte)10)
                {
                    if (i + 1 < offsetMax && buffer[i + 1] == (byte)10)
                        i++;
                    list.Add(i + 1);
                }
            }
            return (int[])list.ToArray(typeof(int));
        }
    }
}