Code:
/ WCF / WCF / 3.5.30729.1 / untmp / Orcas / SP / ndp / cdf / src / WCF / Serialization / System / Xml / XmlBufferReader.cs / 1 / XmlBufferReader.cs
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//-----------------------------------------------------------
namespace System.Xml
{
using System;
using System.IO;
using System.Xml;
using System.Collections;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Security;
using System.Text;
using System.Globalization;
using System.Runtime.Serialization;
using System.Collections.Generic;
using System.Collections.ObjectModel;
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)
{
DiagnosticUtility.DebugAssert(this.offset + count <= offsetMax, "");
this.offset += count;
}
public void InsertBytes(byte[] buffer, int offset, int count)
{
DiagnosticUtility.DebugAssert(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
{
DiagnosticUtility.DebugAssert(value >= offsetMin && value <= offsetMax, "");
this.offset = value;
}
}
public int ReadBytes(int count)
{
DiagnosticUtility.DebugAssert(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;
}
///
/// Critical - contains unsafe code
/// Safe - unsafe code is effectively encapsulated, all inputs are validated
///
[SecurityCritical, SecurityTreatAsSafe]
unsafe public float ReadSingle()
{
int offset;
byte[] buffer = GetBuffer(ValueHandleLength.Single, out offset);
float value;
byte* pb = (byte*)&value;
DiagnosticUtility.DebugAssert(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;
}
///
/// Critical - contains unsafe code
/// Safe - unsafe code is effectively encapsulated, all inputs are validated
///
[SecurityCritical, SecurityTreatAsSafe]
unsafe public double ReadDouble()
{
int offset;
byte[] buffer = GetBuffer(ValueHandleLength.Double, out offset);
double value;
byte* pb = (byte*)&value;
DiagnosticUtility.DebugAssert(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;
}
///
/// Critical - contains unsafe code
/// Safe - unsafe code is effectively encapsulated, all inputs are validated
///
[SecurityCritical, SecurityTreatAsSafe]
unsafe public decimal ReadDecimal()
{
int offset;
byte[] buffer = GetBuffer(ValueHandleLength.Decimal, out offset);
decimal value;
byte* pb = (byte*)&value;
for (int i = 0; i < sizeof(decimal); i++)
pb[i] = buffer[offset + i];
Advance(ValueHandleLength.Decimal);
return value;
}
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;
}
///
/// Critical - contains unsafe code
/// caller needs to validate arguments
///
[SecurityCritical]
unsafe public void UnsafeReadArray(byte* dst, byte* dstMax)
{
UnsafeReadArray(dst, (int)(dstMax - dst));
}
///
/// 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;
DiagnosticUtility.DebugAssert(buffer[offset + 0] == '&', "");
DiagnosticUtility.DebugAssert(buffer[offset + 1] == '#', "");
DiagnosticUtility.DebugAssert(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;
DiagnosticUtility.DebugAssert(buffer[offset + 0] == '&', "");
DiagnosticUtility.DebugAssert(buffer[offset + 1] == '#', "");
DiagnosticUtility.DebugAssert(buffer[offset + 2] == 'x', "");
DiagnosticUtility.DebugAssert(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);
DiagnosticUtility.DebugAssert(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;
DiagnosticUtility.DebugAssert(buffer[offset] == '&', "");
DiagnosticUtility.DebugAssert(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;
}
///
/// Critical - contains unsafe code
/// Safe - unsafe code is effectively encapsulated, all inputs are validated
///
[SecurityCritical, SecurityTreatAsSafe]
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);
}
///
/// Critical - contains unsafe code
/// Safe - unsafe code is effectively encapsulated, all inputs are validated
///
[SecurityCritical, SecurityTreatAsSafe]
unsafe public float GetSingle(int offset)
{
byte[] buffer = this.buffer;
float value;
byte* pb = (byte*)&value;
DiagnosticUtility.DebugAssert(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;
}
///
/// Critical - contains unsafe code
/// Safe - unsafe code is effectively encapsulated, all inputs are validated
///
[SecurityCritical, SecurityTreatAsSafe]
unsafe public double GetDouble(int offset)
{
byte[] buffer = this.buffer;
double value;
byte* pb = (byte*)&value;
DiagnosticUtility.DebugAssert(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;
}
///
/// Critical - contains unsafe code
/// Safe - unsafe code is effectively encapsulated, all inputs are validated
///
[SecurityCritical, SecurityTreatAsSafe]
public unsafe decimal GetDecimal(int offset)
{
byte[] buffer = this.buffer;
decimal value;
byte* pb = (byte*)&value;
for (int i = 0; i < sizeof(decimal); i++)
pb[i] = buffer[offset + i];
return value;
}
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();
DiagnosticUtility.DebugAssert(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));
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- SchemaDeclBase.cs
- WebConvert.cs
- CardSpacePolicyElement.cs
- BuildManager.cs
- PaperSize.cs
- GridViewCancelEditEventArgs.cs
- DetailsViewUpdatedEventArgs.cs
- Util.cs
- AttachedAnnotationChangedEventArgs.cs
- XmlSerializerFactory.cs
- ToolStripButton.cs
- TableCellAutomationPeer.cs
- AsymmetricAlgorithm.cs
- Quad.cs
- BitmapEffectInput.cs
- PngBitmapDecoder.cs
- FormatSettings.cs
- DrawingContext.cs
- ButtonBaseAutomationPeer.cs
- ParameterSubsegment.cs
- XmlDocument.cs
- Path.cs
- ChangePasswordAutoFormat.cs
- FixedFlowMap.cs
- Mappings.cs
- EntityModelBuildProvider.cs
- TableItemStyle.cs
- ResXBuildProvider.cs
- TextCollapsingProperties.cs
- TrackingConditionCollection.cs
- ResourcesChangeInfo.cs
- CriticalExceptions.cs
- InputBinding.cs
- ToolTip.cs
- ZipIOCentralDirectoryFileHeader.cs
- NativeMethods.cs
- EncoderBestFitFallback.cs
- CryptoApi.cs
- TriggerCollection.cs
- RequestCachePolicyConverter.cs
- HttpResponseHeader.cs
- MenuAutomationPeer.cs
- SqlClientWrapperSmiStreamChars.cs
- XmlEncodedRawTextWriter.cs
- NotSupportedException.cs
- DataSpaceManager.cs
- prefixendpointaddressmessagefilter.cs
- Pen.cs
- VScrollBar.cs
- Object.cs
- InvalidateEvent.cs
- XmlSchemaSimpleContentExtension.cs
- MD5.cs
- ClientRuntimeConfig.cs
- DateTimeOffset.cs
- WebPartExportVerb.cs
- CmsInterop.cs
- CryptoKeySecurity.cs
- CellCreator.cs
- DateTimeAutomationPeer.cs
- MyContact.cs
- DefaultMemberAttribute.cs
- SocketPermission.cs
- MenuScrollingVisibilityConverter.cs
- SoapDocumentMethodAttribute.cs
- TreeViewBindingsEditor.cs
- DbModificationCommandTree.cs
- coordinatorscratchpad.cs
- OutputScope.cs
- OleServicesContext.cs
- XmlHierarchicalDataSourceView.cs
- DivideByZeroException.cs
- String.cs
- Message.cs
- ResourceBinder.cs
- LinkLabel.cs
- XmlSchemaComplexContent.cs
- XmlSchemaDatatype.cs
- XmlWellformedWriter.cs
- PeerNameRecord.cs
- SimpleHandlerBuildProvider.cs
- TextDecorationLocationValidation.cs
- PcmConverter.cs
- ThreadStaticAttribute.cs
- DataKeyCollection.cs
- SafeHandle.cs
- SplashScreen.cs
- DynamicValueConverter.cs
- BoundingRectTracker.cs
- BaseTreeIterator.cs
- InstanceOwner.cs
- Button.cs
- PropertyConverter.cs
- ThicknessKeyFrameCollection.cs
- ModuleBuilderData.cs
- IOException.cs
- AsymmetricSignatureFormatter.cs
- TextComposition.cs
- TextEditorMouse.cs
- ScriptControl.cs