private unsafe int InternalReadChars(char[] buffer, int index, int count)
{
int charCount = count;
if (this.m_charBytes == null)
{
this.m_charBytes = new byte[128];
}
while (charCount > 0)
{
int count1 = charCount;
DecoderNLS decoderNls = this.m_decoder as DecoderNLS;
if (decoderNls != null && decoderNls.HasState && count1 > 1)
{
--count1;
}
if (this.m_2BytesPerChar)
{
count1 <<= 1;
}
if (count1 > 128)
{
count1 = 128;
}
int num = 0;
int byteCount;
byte[] numArray;
if (this.m_isMemoryStream)
{
MemoryStream memoryStream = this.m_stream as MemoryStream;
num = memoryStream.InternalGetPosition();
int count2 = count1;
byteCount = memoryStream.InternalEmulateRead(count2);
numArray = memoryStream.InternalGetBuffer();
}
else
{
byteCount = this.m_stream.Read(this.m_charBytes, 0, count1);
numArray = this.m_charBytes;
}
if (byteCount == 0)
{
return(count - charCount);
}
int chars;
fixed(byte *numPtr = numArray)
fixed(char *chPtr = buffer)
chars = this.m_decoder.GetChars(numPtr + num, byteCount, chPtr + index, charCount, false);
charCount -= chars;
index += chars;
}
return(count - charCount);
}
private int InternalReadChars(char[] buffer, int index, int count)
{
Contract.Requires(buffer != null);
Contract.Requires(index >= 0 && count >= 0);
Contract.Assert(m_stream != null);
int numBytes = 0;
int charsRemaining = count;
if (m_charBytes == null)
{
m_charBytes = new byte[MaxCharBytesSize];
}
while (charsRemaining > 0)
{
int charsRead = 0;
// We really want to know what the minimum number of bytes per char
// is for our encoding. Otherwise for UnicodeEncoding we'd have to
// do ~1+log(n) reads to read n characters.
numBytes = charsRemaining;
// special case for DecoderNLS subclasses when there is a hanging byte from the previous loop
DecoderNLS decoder = m_decoder as DecoderNLS;
if (decoder != null && decoder.HasState && numBytes > 1)
{
numBytes -= 1;
}
if (m_2BytesPerChar)
{
numBytes <<= 1;
}
if (numBytes > MaxCharBytesSize)
{
numBytes = MaxCharBytesSize;
}
int position = 0;
byte[] byteBuffer = null;
if (m_isMemoryStream)
{
MemoryStream mStream = m_stream as MemoryStream;
Contract.Assert(mStream != null, "m_stream as MemoryStream != null");
position = mStream.InternalGetPosition();
numBytes = mStream.InternalEmulateRead(numBytes);
byteBuffer = mStream.InternalGetBuffer();
}
else
{
numBytes = m_stream.Read(m_charBytes, 0, numBytes);
byteBuffer = m_charBytes;
}
if (numBytes == 0)
{
return(count - charsRemaining);
}
Contract.Assert(byteBuffer != null, "expected byteBuffer to be non-null");
checked {
if (position < 0 || numBytes < 0 || position + numBytes > byteBuffer.Length)
{
throw new ArgumentOutOfRangeException("byteCount");
}
if (index < 0 || charsRemaining < 0 || index + charsRemaining > buffer.Length)
{
throw new ArgumentOutOfRangeException("charsRemaining");
}
unsafe
{
fixed(byte *pBytes = byteBuffer)
{
fixed(char *pChars = buffer)
{
charsRead = m_decoder.GetChars(pBytes + position, numBytes, pChars + index, charsRemaining, false);
}
}
}
}
charsRemaining -= charsRead;
index += charsRead;
}
// this should never fail
Contract.Assert(charsRemaining >= 0, "We read too many characters.");
// we may have read fewer than the number of characters requested if end of stream reached
// or if the encoding makes the char count too big for the buffer (e.g. fallback sequence)
return(count - charsRemaining);
}
private int InternalReadChars(char[] buffer, int index, int count)
{
int numBytes = 0;
int charsRemaining = count;
if (m_charBytes == null)
{
m_charBytes = new byte[MaxCharBytesSize];
}
while (charsRemaining > 0)
{
int charsRead = 0;
// We really want to know what the minimum number of bytes per char
// is for our encoding. Otherwise for UnicodeEncoding we'd have to
// do ~1+log(n) reads to read n characters.
numBytes = charsRemaining;
// special case for DecoderNLS subclasses when there is a hanging byte from the previous loop
DecoderNLS decoder = m_decoder as DecoderNLS;
if (decoder != null && decoder.HasState && numBytes > 1)
{
numBytes -= 1;
}
if (m_2BytesPerChar)
{
numBytes <<= 1;
}
if (numBytes > MaxCharBytesSize)
{
numBytes = MaxCharBytesSize;
}
int position = 0;
byte[] byteBuffer = null;
if (m_isMemoryStream)
{
MemoryStream mStream = m_stream as MemoryStream;
position = mStream.InternalGetPosition();
numBytes = mStream.InternalEmulateRead(numBytes);
byteBuffer = mStream.InternalGetBuffer();
}
else
{
numBytes = m_stream.Read(m_charBytes, 0, numBytes);
byteBuffer = m_charBytes;
}
if (numBytes == 0)
{
return(count - charsRemaining);
}
unsafe
{
fixed(byte *pBytes = byteBuffer)
fixed(char *pChars = buffer)
{
charsRead = m_decoder.GetChars(pBytes + position, numBytes, pChars + index, charsRemaining, false);
}
}
charsRemaining -= charsRead;
index += charsRead;
}
// we may have read fewer than the number of characters requested if end of stream reached
// or if the encoding makes the char count too big for the buffer (e.g. fallback sequence)
return(count - charsRemaining);
}
private unsafe int InternalReadChars(char[] buffer, int index, int count)
{
int i = count;
if (this.m_charBytes == null)
{
this.m_charBytes = new byte[128];
}
while (i > 0)
{
int num = i;
DecoderNLS decoderNLS = this.m_decoder as DecoderNLS;
if (decoderNLS != null && decoderNLS.HasState && num > 1)
{
num--;
}
if (this.m_2BytesPerChar)
{
num <<= 1;
}
if (num > 128)
{
num = 128;
}
int num2 = 0;
byte[] array;
if (this.m_isMemoryStream)
{
MemoryStream memoryStream = this.m_stream as MemoryStream;
num2 = memoryStream.InternalGetPosition();
num = memoryStream.InternalEmulateRead(num);
array = memoryStream.InternalGetBuffer();
}
else
{
num = this.m_stream.Read(this.m_charBytes, 0, num);
array = this.m_charBytes;
}
if (num == 0)
{
return(count - i);
}
int chars;
checked
{
if (num2 < 0 || num < 0 || num2 + num > array.Length)
{
throw new ArgumentOutOfRangeException("byteCount");
}
if (index < 0 || i < 0 || index + i > buffer.Length)
{
throw new ArgumentOutOfRangeException("charsRemaining");
}
fixed(byte *ptr = array)
{
fixed(char *ptr2 = buffer)
{
chars = this.m_decoder.GetChars(ptr + num2, num, ptr2 + index, i, false);
}
}
}
i -= chars;
index += chars;
}
return(count - i);
}
